receiver.c File Reference

---

Detailed Description

CDiameterPeer Receiver process procedures.

Author:

Dragos Vingarzan vingarzan -at- fokus dot fraunhofer dot de

Definition in file receiver.c.

#include <unistd.h>
#include <errno.h>
#include <string.h>
#include <assert.h>
#include <sys/time.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/ioctl.h>
#include <signal.h>
#include <netinet/in.h>
#include <netdb.h>
#include <stdlib.h>
#include <stdio.h>
#include <time.h>
#include <sys/stat.h>
#include <fcntl.h>
#include "utils.h"
#include "globals.h"
#include "diameter_api.h"
#include "peerstatemachine.h"
#include "peermanager.h"
#include "config.h"
#include "receiver.h"

Go to the source code of this file.

Defines
#define	PIPE_PREFIX   "/tmp/cdp_send_"
	prefix for the send FIFO pipes
#define	hdr_len   20
	length of the Diameter message header
Functions
int	dp_add_pid (pid_t pid)
	Add a pid to the local process list.
void	dp_del_pid (pid_t pid)
	Delete a pid from the process list.
void	receive_loop (int sock)
	Receive Loop for Diameter messages.
void	receive_message (AAAMessage *msg, int sock)
	Receives a mesasge and does basic processing or call the sm_process().
static void	set_peer_pipe ()
	Sets the send pipe name for the peer serviced by this process.
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.
static int	select_recv (int s, void *buf, int len, int opt)
	Select on sockets for receiving.
int	peer_connect (peer *p)
	Initiate a connection to a peer.
int	peer_send_msg (peer *p, AAAMessage *msg)
	Sends a message to a peer (to be called from other processes).
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).
Variables
dp_config *	config
	Configuration for this diameter peer.
peer *	this_peer = 0
	pointer to the peer serviced by this process
int	pipe_fd
	file descriptor for reading from the send pipe
int	pipe_fd_out
	file descriptor for writting to the send pipe
str	pipe_name
	full path to the pipe

---

Define Documentation

#define PIPE_PREFIX   "/tmp/cdp_send_"

prefix for the send FIFO pipes

Definition at line 93 of file receiver.c.

Referenced by receiver_init().

#define hdr_len   20

length of the Diameter message header

Definition at line 272 of file receiver.c.

Referenced by receive_loop().

---

Function Documentation

int dp_add_pid

(

pid_t

pid

)

[inline]

Add a pid to the local process list.

Parameters:

pid

newly forked pid

Returns:

1 on success or 0 on error

Definition at line 95 of file diameter_peer.c.

{
    pid_list_t *n;
    lock_get(pid_list_lock);
    n = shm_malloc(sizeof(pid_list_t));
    if (!n){
        LOG_NO_MEM("shm",sizeof(pid_list_t));
        lock_release(pid_list_lock);
        return 0;
    }
    n->pid = pid;
    n->next = 0;
    n->prev = pid_list->tail;
    if (!pid_list->head) pid_list->head = n;
    if (pid_list->tail) pid_list->tail->next = n;
    pid_list->tail = n;
    lock_release(pid_list_lock);
    return 1;
}

void dp_del_pid

(

pid_t

pid

)

[inline]

Delete a pid from the process list.

Parameters:

pid

- the pid to remove

Definition at line 132 of file diameter_peer.c.

{   
    pid_list_t *i;
    lock_get(pid_list_lock);
    i = pid_list->head;
    if (!i) {
        lock_release(pid_list_lock);
        return;
    }
    while(i && i->pid!=pid) i = i->next;
    if (i){
        if (i->prev) i->prev->next = i->next;
        else pid_list->head = i->next;
        if (i->next) i->next->prev = i->prev;
        else pid_list->tail = i->prev;
        shm_free(i);
    }
    lock_release(pid_list_lock);
}

void receive_loop

(

int

sock

)

Receive Loop for Diameter messages.

Decodes the message and calls receive_message().

Parameters:

sock

- the socket to receive from

Returns:

when the socket is closed

Definition at line 280 of file receiver.c.

References AAATranslateMessage(), DP_MAX_MSG_LENGTH, get_3bytes, hdr_len, I_Peer_Disc, _peer_t::I_sock, LOG_NO_MEM, R_Peer_Disc, receive_message(), select_recv(), shutdownx, sm_process(), and this_peer.

Referenced by receiver_process().

{
    char buf[hdr_len],*msg;
    int buf_len,length,version,cnt,msg_len;
    AAAMessage *dmsg;
    
    while(!*shutdownx){
        buf_len=0;
        while(buf_len<1){   
            cnt = select_recv(sock,buf+buf_len,1,0);
            if (cnt<0) goto error;
            buf_len+=cnt;
        }
        version = (unsigned char)buf[0];
        if (version!=1) {
            LOG(L_ERR,"ERROR:receive_loop():[%d] Recv Unknown version [%d]\n",sock,(unsigned char)buf[0]);
            continue;           
        }       
        while(buf_len<hdr_len){
            cnt = select_recv(sock,buf+buf_len,hdr_len-buf_len,0);
            if (cnt<0) goto error;
            buf_len+=cnt;
        }
        length = get_3bytes(buf+1);
        if (length>DP_MAX_MSG_LENGTH){
            LOG(L_ERR,"ERROR:receive_loop():[%d] Msg too big [%d] bytes\n",sock,length);
            goto error;
        }
        LOG(L_DBG,"DBG:receive_loop():[%d] Recv Version %d Length %d\n",sock,version,length);
        msg = shm_malloc(length);
        if (!msg) {
            LOG_NO_MEM("shm",length);
            goto error;
        }
            
        memcpy(msg,buf,hdr_len);
        msg_len=hdr_len;
        while(msg_len<length){
            cnt = select_recv(sock,msg+msg_len,length-msg_len,0);
            if (cnt<0) {
                shm_free(msg);
                goto error;
            }
            msg_len+=cnt;
        }
        LOG(L_DBG,"DBG:receive_loop():[%d] Recv message complete\n",sock);
        
        dmsg = AAATranslateMessage((unsigned char*)msg,(unsigned int)msg_len,1);
        
        /*shm_free(msg);*/

        if (dmsg) receive_message(dmsg,sock);
        else{
            shm_free(msg);
        }
        
    }
error:
    if (this_peer) {
        if (this_peer->I_sock == sock) sm_process(this_peer,I_Peer_Disc,0,0,sock);
        if (this_peer->R_sock == sock) sm_process(this_peer,R_Peer_Disc,0,0,sock);
    }
    LOG(L_ERR,"INFO:receive_loop():[%d] Client closed connection or error... BYE\n",sock);
}

void receive_message	(	AAAMessage *	msg,
		int	sock
	)

Receives a mesasge and does basic processing or call the sm_process().

This gets called from the receive_loop for every message that is received.

Parameters:

	msg	- the message received
	sock	- socket received on

Definition at line 524 of file receiver.c.

References AAAFindMatchingAVP(), AAAFreeMessage(), dp_config::accept_unknown_peers, AVP_Origin_Host, AVP_Origin_Realm, Code_CE, Code_DP, Code_DW, _message_t::commandCode, config, avp::data, get_peer_from_fqdn(), get_peer_from_sock(), I_Open, I_Rcv_CEA, I_Rcv_CER, I_Rcv_DPA, I_Rcv_DPR, I_Rcv_DWA, I_Rcv_DWR, I_Rcv_Message, I_Rcv_Non_CEA, is_req, R_Conn_CER, R_Open, R_Rcv_CEA, R_Rcv_CER, R_Rcv_DPA, R_Rcv_DPR, R_Rcv_DWA, R_Rcv_DWR, R_Rcv_Message, set_peer_pipe(), sm_process(), _peer_t::state, this_peer, touch_peer(), and Wait_I_CEA.

Referenced by receive_loop().

{
    AAA_AVP *avp1,*avp2;
    LOG(L_DBG,"DBG:receive_message(): [%d] Recv msg %d\n",sock,msg->commandCode);

    if (!this_peer) {
        this_peer = get_peer_from_sock(sock);
        set_peer_pipe();
    }
    
    if (!this_peer){
        switch (msg->commandCode){
            case Code_CE:
                if (is_req(msg)){
                    avp1 = AAAFindMatchingAVP(msg,msg->avpList.head,AVP_Origin_Host,0,0);
                    avp2 = AAAFindMatchingAVP(msg,msg->avpList.head,AVP_Origin_Realm,0,0);
                    if (avp1&&avp2){
                        this_peer = get_peer_from_fqdn(avp1->data,avp2->data);
                    }
                    if (!this_peer) {
                        LOG(L_ERR,"ERROR:receive_msg(): Received CER from unknown peer (accept unknown=%d) -ignored\n",
                            config->accept_unknown_peers);
                        AAAFreeMessage(&msg);
                    }else{
                        set_peer_pipe();                        
                        sm_process(this_peer,R_Conn_CER,msg,0,sock);
                    }
                }
                else{
                    LOG(L_ERR,"ERROR:receive_msg(): Received CEA from an unknown peer -ignored\n");
                    AAAFreeMessage(&msg);
                }
                break;
            default:
                LOG(L_ERR,"ERROR:receive_msg(): Received non-CE from an unknown peer -ignored\n");
                AAAFreeMessage(&msg);               
        }
    }else{
        touch_peer(this_peer);
        switch (this_peer->state){
            case Wait_I_CEA:
                if (msg->commandCode!=Code_CE||is_req(msg)){
                    sm_process(this_peer,I_Rcv_Non_CEA,msg,0,sock);
                }else
                    sm_process(this_peer,I_Rcv_CEA,msg,0,sock);
                break;
            case I_Open:            
                switch (msg->commandCode){
                    case Code_CE:
                        if (is_req(msg)) sm_process(this_peer,I_Rcv_CER,msg,0,sock);    
                                    else sm_process(this_peer,I_Rcv_CEA,msg,0,sock);
                        break;
                    case Code_DW:
                        if (is_req(msg)) sm_process(this_peer,I_Rcv_DWR,msg,0,sock);    
                                    else sm_process(this_peer,I_Rcv_DWA,msg,0,sock);
                        break;
                    case Code_DP:
                        if (is_req(msg)) sm_process(this_peer,I_Rcv_DPR,msg,0,sock);    
                                    else sm_process(this_peer,I_Rcv_DPA,msg,0,sock);
                        break;
                    default:
                        sm_process(this_peer,I_Rcv_Message,msg,0,sock);
                }               
                break;              
            case R_Open:            
                switch (msg->commandCode){
                    case Code_CE:
                        if (is_req(msg)) sm_process(this_peer,R_Rcv_CER,msg,0,sock);    
                                    else sm_process(this_peer,R_Rcv_CEA,msg,0,sock);
                        break;
                    case Code_DW:
                        if (is_req(msg)) sm_process(this_peer,R_Rcv_DWR,msg,0,sock);    
                                    else sm_process(this_peer,R_Rcv_DWA,msg,0,sock);
                        break;
                    case Code_DP:
                        if (is_req(msg)) sm_process(this_peer,R_Rcv_DPR,msg,0,sock);    
                                    else sm_process(this_peer,R_Rcv_DPA,msg,0,sock);
                        break;
                    default:
                        sm_process(this_peer,R_Rcv_Message,msg,0,sock);
                }               
                break;              
            default:
                LOG(L_ERR,"ERROR:receive_msg(): Received msg while peer in state %d -ignored\n",this_peer->state);
                AAAFreeMessage(&msg);                               
        }
    }
}

static void set_peer_pipe

(

)

[inline, static]

Sets the send pipe name for the peer serviced by this process.

Definition at line 101 of file receiver.c.

References pipe_name, _peer_t::send_pipe, and this_peer.

Referenced by receive_message(), and receiver_init().

{
    if (!this_peer) return;
//  lock_get(this_peer->lock);
    this_peer->send_pipe = pipe_name;
//  lock_release(this_peer->lock);
}

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);
}

static int select_recv	(	int	s,
		void *	buf,
		int	len,
		int	opt
	)			[inline, static]

Select on sockets for receiving.

Selects on both the socket and on the send pipe.

Parameters:

	s	- the receive socket
	buf	- buffer to read into
	len	- max length of the read buffer
	opt	- recv() flags

Returns:

number of bytes read or -1 on error

Definition at line 187 of file receiver.c.

References AAAFreeMessage(), _message_t::buf, errno, pipe_fd, pipe_name, select, and shutdownx.

Referenced by receive_loop().

{
    fd_set rfds,efds;
    struct timeval tv;
    int n,max;
    AAAMessage *msg=0;
    int r=0,cnt=0;
    
//  if (shutdownx) return -1;
    max = s;
    if (pipe_fd>max) max = pipe_fd;
    n = 0;
    
    while(!n){
        if (shutdownx&&*shutdownx) break;   

        FD_ZERO(&rfds);
        FD_SET(s,&rfds);
        FD_SET(pipe_fd,&rfds);
        FD_ZERO(&efds);
        FD_SET(s,&efds);
        tv.tv_sec=1;
        tv.tv_usec=0;

//      LOG(L_CRIT,"ERROR:select_recv(): HERE\n");
        
        n = select(max+1,&rfds,0,&efds,&tv);
        if (n==-1){
            if (shutdownx&&*shutdownx) return -1;
            LOG(L_ERR,"ERROR:select_recv(): %s\n",strerror(errno));
            return -1;
        }else
            if (n){
                if (FD_ISSET(s,&efds)) return -1;               
                if (FD_ISSET(pipe_fd,&rfds)) {                  
                    LOG(L_DBG,"DBG:select_recv(): There is something on the pipe\n");
                    cnt = read(pipe_fd,&msg,sizeof(AAAMessage *));
                    LOG(L_DBG,"DBG:select_recv(): Pipe says [%p] %d\n",msg,cnt);
                    if (cnt==0){
                        //This is very stupid and might not work well - droped messages... to be fixed
                        LOG(L_INFO,"INFO:select_recv(): ReOpening pipe for read. This should not happen...\n");
                        close(pipe_fd);
                        pipe_fd = open(pipe_name.s, O_RDONLY | O_NDELAY);
                        goto receive;
                    }
                    if (cnt<sizeof(AAAMessage *)){
                        if (cnt<0) LOG(L_ERR,"ERROR:select_recv(): Error reading from pipe\n");
                        r = -1;
                        goto receive;
                    }   
                    
                    while( (cnt=write(s,msg->buf.s,msg->buf.len))==-1 ) {
                        if (errno==EINTR)
                            continue;
                        LOG(L_ERR,"ERROR:select_recv(): write returned error> %s\n",
                            strerror(errno));
                        close(s);
                        AAAFreeMessage(&msg);       
                        r = -1;
                        return r;
                    }
                                            
                    if (cnt!=msg->buf.len){
                        LOG(L_ERR,"ERROR:select_recv(): only wrote %d/%d bytes\n",cnt,msg->buf.len);
                        close(s);
                        AAAFreeMessage(&msg);       
                        r = -1;
                        return r;
                    }
                    AAAFreeMessage(&msg);
                    //don't return, maybe there is something to read
                }
receive:
                if (FD_ISSET(s,&rfds)) {
                    cnt = recv(s,buf,len,opt);
                    if (cnt==0) return -1;
                    else return cnt;
                }
            }
        //LOG(L_ERR,".");
    }
    return r;
}

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_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;
}

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;   
}

---

Variable Documentation

dp_config* config

Configuration for this diameter peer.

Definition at line 76 of file diameter_peer.c.

peer* this_peer = 0

pointer to the peer serviced by this process

Definition at line 90 of file receiver.c.

Referenced by receive_loop(), receive_message(), receiver_init(), receiver_process(), and set_peer_pipe().

int pipe_fd

file descriptor for reading from the send pipe

Definition at line 94 of file receiver.c.

Referenced by receiver_init(), receiver_process(), and select_recv().

int pipe_fd_out

file descriptor for writting to the send pipe

Definition at line 95 of file receiver.c.

Referenced by receiver_init(), and receiver_process().

str pipe_name

full path to the pipe

Definition at line 96 of file receiver.c.

Referenced by receiver_init(), receiver_process(), select_recv(), and set_peer_pipe().

---