receiver.h File Reference

---

Detailed Description

CDiameterPeer Receiver process procedures.

Author:

Dragos Vingarzan vingarzan -at- fokus dot fraunhofer dot de

Definition in file receiver.h.

#include "peer.h"
#include "diameter.h"

Go to the source code of this file.

Defines
#define	DP_MAX_MSG_LENGTH   65536
	Maximum incoming message length.
Functions
void	receiver_init (int sock, peer *p)
	Initializes the receiver.
void	receiver_process (int sock)
	The Receiver Process - calls the receiv_loop and it never returns.
int	peer_connect (peer *p)
	Initiate a connection to a peer.
int	peer_send (peer *p, int sock, AAAMessage *msg, int locked)
	Send a message to a peer (only to be called from the receiver process).
int	peer_send_msg (peer *p, AAAMessage *msg)
	Sends a message to a peer (to be called from other processes).

---

Define Documentation

#define DP_MAX_MSG_LENGTH   65536

Maximum incoming message length.

Definition at line 64 of file receiver.h.

Referenced by receive_loop().

---

Function Documentation

void receiver_init	(	int	sock,
		peer *	p
	)

Initializes the receiver.

Parameters:

	sock	- the socket to initialize with
	p	- the peer to initialize with

Definition at line 114 of file receiver.c.

References errno, pipe_fd, pipe_fd_out, pipe_name, PIPE_PREFIX, set_peer_pipe(), and this_peer.

Referenced by accept_connection().

{
    this_peer = p;
    
    pipe_name.s = shm_malloc(sizeof(PIPE_PREFIX)+64);
    sprintf(pipe_name.s,"%s%d_%d_%d",PIPE_PREFIX,(unsigned int) time(0),sock,getpid());
    pipe_name.len = strlen(pipe_name.s);
        
    set_peer_pipe();    

    mkfifo(pipe_name.s, 0666);  
    pipe_fd = open(pipe_name.s, O_RDONLY | O_NDELAY);
    if (pipe_fd<0){
        LOG(L_ERR,"ERROR:receiver_process(): FIFO open failed > %s\n",strerror(errno));
    }
    // we open it for writting just to keep it alive - won't close when all other writers close it
    pipe_fd_out = open(pipe_name.s, O_WRONLY);
}

void receiver_process

(

int

sock

)

The Receiver Process - calls the receiv_loop and it never returns.

Parameters:

sock

- socket to receive data from

Returns:

never, when disconnected it will exit

Definition at line 138 of file receiver.c.

References dp_del_pid(), _peer_t::lock, memlog, pipe_fd, pipe_fd_out, pipe_name, receive_loop(), _peer_t::send_pipe, and this_peer.

Referenced by accept_connection().

{
    LOG(L_INFO,"INFO:receiver_process(): [%d] Receiver process starting up...\n",sock);

        
    receive_loop(sock);
    LOG(L_INFO,"INFO:receiver_process(): [%d]... Receiver process cleaning-up.\n",sock);
    close(sock);
    close(pipe_fd);
    close(pipe_fd_out);
    remove(pipe_name.s);
    if (this_peer){
        lock_get(this_peer->lock);
        this_peer->send_pipe.s=0;
        this_peer->send_pipe.len=0;
        lock_release(this_peer->lock);
    }
    shm_free(pipe_name.s);
//done:     
    /* remove pid from list of running processes */
    dp_del_pid(getpid());
    
#ifdef CDP_FOR_SER
    drop_my_process();      
#else
#ifdef PKG_MALLOC
    #ifdef PKG_MALLOC
        LOG(memlog, "Receiver[%d] Memory status (pkg):\n",sock);
        //pkg_status();
        #ifdef pkg_sums
            pkg_sums();
        #endif 
    #endif
#endif
#endif      
        
    LOG(L_INFO,"INFO:receiver_process(): [%d]... Receiver process finished.\n",sock);
    exit(0);
}

int peer_connect

(

peer *

p

)

Initiate a connection to a peer.

Parameters:

p

- peer to connect to

Returns:

socket if OK, -1 on error

Definition at line 350 of file receiver.c.

References errno, _peer_t::fqdn, and _peer_t::port.

Referenced by I_Snd_Conn_Req().

{
    int sock;
    int pid;
    unsigned int option = 1;
    
    struct addrinfo *ainfo=0,*res=0,hints;      
    char buf[256],host[256],serv[256];
    int error;

    memset (&hints, 0, sizeof(hints));
    //hints.ai_protocol = IPPROTO_SCTP;
    //hints.ai_protocol = IPPROTO_TCP;
    hints.ai_flags = AI_ADDRCONFIG;
    hints.ai_socktype = SOCK_STREAM;
    
    sprintf(buf,"%d",p->port);

    error = getaddrinfo(p->fqdn.s, buf, &hints, &res);

    if (error!=0){
        LOG(L_WARN,"WARNING:peer_connect(): Error opening connection to %.*s:%d >%s\n",
            p->fqdn.len,p->fqdn.s,p->port,gai_strerror(error));
        goto error;
    }
        
    for(ainfo = res;ainfo;ainfo = ainfo->ai_next)
    {
        if (getnameinfo(ainfo->ai_addr,ainfo->ai_addrlen,
            host,256,serv,256,NI_NUMERICHOST|NI_NUMERICSERV)==0){
                LOG(L_WARN,"INFO:peer_connect(): Trying to connect to %s port %s\n",
                    host,serv);
        }               

        if ((sock = socket(ainfo->ai_family, ainfo->ai_socktype, ainfo->ai_protocol)) == -1) {
            LOG(L_ERR,"ERROR:create_socket(): error creating client socket to %s port %s >"
                " %s\n",host,serv,strerror(errno));
            continue;
        }

        if (connect(sock,ainfo->ai_addr,ainfo->ai_addrlen)!=0) {
            LOG(L_WARN,"WARNING:peer_connect(): Error opening connection to to %s port %s >%s\n",
                host,serv,strerror(errno));
            close(sock);        
            continue;
        }
    
        setsockopt(sock,SOL_SOCKET,SO_REUSEADDR,&option,sizeof(option));
    
        LOG(L_INFO,"INFO:peer_connect(): Peer %.*s:%d connected\n",p->fqdn.len,p->fqdn.s,p->port);

    
        receiver_init(sock,p);
    
        #ifdef CDP_FOR_SER
            pid = fork_process(p->port,"receiver I",0);
        #else
            pid = fork();
        #endif
        if (pid<0){
            LOG(L_ERR,"ERROR:peer_connect(): fork() failed > %s\n",strerror(errno));
            goto error;
        }
        if (pid==0){
            /* child */
            receiver_process(sock);
            LOG(L_CRIT,"ERROR:peer_connect(): receiver_process finished without exit!\n");
            exit(-1);
        }else{
            /* parent */
            LOG(L_INFO,"INFO:peer_connect(): Receiver process forked [%d]\n",pid);
            
            dp_add_pid(pid);
        }
        
        if (res) freeaddrinfo(res);         
        return sock;
    }
error:
    if (res) freeaddrinfo(res); 
    return -1;  
}

int peer_send	(	peer *	p,
		int	sock,
		AAAMessage *	msg,
		int	locked
	)

Send a message to a peer (only to be called from the receiver process).

This directly writes the message on the socket. It is used for transmission during the Capability Exchange procedure, when the send pipes are not opened yet.

Parameters:

	p	- the peer to send to
	sock	- the socket to send through
	msg	- the message to send
	locked	- whether the caller locked the peer already

Returns:

1 on success, 0 on error

Definition at line 483 of file receiver.c.

References AAABuildMsgBuffer(), AAAFreeMessage(), _message_t::buf, errno, I_Peer_Disc, _peer_t::I_sock, _peer_t::lock, R_Peer_Disc, and sm_process().

Referenced by Snd_CEA().

{
    int n;
//  LOG(L_CRIT,"[%d]\n",sock);
    
    if (!p||!msg||sock<0) return 0;
    
    if (!AAABuildMsgBuffer(msg)) return 0;
    
    if (!locked) lock_get(p->lock);

    while( (n=write(sock,msg->buf.s,msg->buf.len))==-1 ) {
        if (errno==EINTR)
            continue;
        LOG(L_ERR,"ERROR:peer_send(): write returned error: %s\n",
            strerror(errno));
        if (p->I_sock==sock) sm_process(p,I_Peer_Disc,0,1,p->I_sock);
        if (p->R_sock==sock) sm_process(p,R_Peer_Disc,0,1,p->R_sock);
        if (!locked) lock_release(p->lock);
        AAAFreeMessage(&msg);       
        return 0;
    }

    if (n!=msg->buf.len){
        LOG(L_ERR,"ERROR:peer_send(): only wrote %d/%d bytes\n",n,msg->buf.len);
        if (!locked) lock_release(p->lock);
        AAAFreeMessage(&msg);       
        return 0;
    }
    if (!locked) lock_release(p->lock);
    AAAFreeMessage(&msg);           
    return 1;   
}

int peer_send_msg	(	peer *	p,
		AAAMessage *	msg
	)

Sends a message to a peer (to be called from other processes).

This just writes the pointer to the message in the send pipe. The specific peer process will pick that up and send the message, as only that specific process has the id of socket (we are forking the peers dynamically and as such, the sockets are not visible between processes).

Parameters:

	p	- the peer to send to
	msg	- the message to send

Returns:

1 on success, 0 on failure

Definition at line 444 of file receiver.c.

References AAABuildMsgBuffer(), errno, _peer_t::fqdn, and _peer_t::send_pipe.

Referenced by AAASendMessage(), AAASendMessageToPeer(), AAASendRecvMessage(), AAASendRecvMessageToPeer(), api_callback(), I_Snd_CER(), Snd_DPA(), Snd_DPR(), Snd_DWA(), Snd_DWR(), and Snd_Message().

{
    int fd,n;
    if (!AAABuildMsgBuffer(msg)) return 0;
    if (!p->send_pipe.s) {
        LOG(L_ERR,"ERROR:peer_send_msg(): Peer %.*s has no attached send pipe\n",p->fqdn.len,p->fqdn.s);
        return 0;
    }
    fd = open(p->send_pipe.s,O_WRONLY);
    if (fd<0){
        LOG(L_ERR,"ERROR:peer_send_msg(): Peer %.*s error on pipe open > %s\n",p->fqdn.len,p->fqdn.s,strerror(errno));      
        return 0;
    }
    LOG(L_DBG,"DBG:peer_send_msg(): Pipe push [%p]\n",msg);
    n = write(fd,&msg,sizeof(AAAMessage *));
    if (n<0) {
        LOG(L_ERR,"ERROR:peer_send_msg(): Peer %.*s error on pipe write > %s\n",p->fqdn.len,p->fqdn.s,strerror(errno));     
        close(fd);
        return 0;
    }
    if (n!=sizeof(AAAMessage *)) {
        LOG(L_ERR,"ERROR:peer_send_msg(): Peer %.*s error on pipe write > only %d bytes written\n",p->fqdn.len,p->fqdn.s,n);        
        close(fd);
        return 0;
    }
    close(fd);
    return 1;
}

---