tcp_accept.c File Reference

---

Detailed Description

CDiameterPeer TCP Acceptor Process.

Author:

Dragos Vingarzan vingarzan -at- fokus dot fraunhofer dot de

Definition in file tcp_accept.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 "utils.h"
#include "globals.h"
#include "tcp_accept.h"
#include "receiver.h"

Go to the source code of this file.

Functions
int	dp_add_pid (pid_t pid)
	Add a pid to the local process list.
int	create_socket (int listen_port, str bind_to, unsigned int *sock)
	Creates a socket and binds it.
static int	accept_connection (int server_sock, int *new_sock)
	Accepts an incoming connection by forking a receiver process.
void	accept_loop ()
	Accept loop that listens for incoming connections on all listening sockets.
Variables
unsigned int *	listening_socks = 0
	array of sockets listening for connections
int	h_errno

---

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

int create_socket	(	int	listen_port,
		str	bind_to,
		unsigned int *	sock
	)

Creates a socket and binds it.

Parameters:

	listen_port	- port to listen to
	bind_to	- IP address to bind to - if empty, will bind to :: (0.0.0.0) (all)
	sock	- socket to be update with the identifier of the opened one

Returns:

1 on success, 0 on error

Definition at line 91 of file tcp_accept.c.

References errno, and NULL.

Referenced by acceptor_process().

{
    unsigned int server_sock=-1;
    struct addrinfo *ainfo=0,*res=0,hints;
    char buf[256],host[256],serv[256];
    int error=0;
    unsigned int option;
    
    memset (&hints, 0, sizeof(hints));
    //hints.ai_protocol = IPPROTO_SCTP;
    //hints.ai_protocol = IPPROTO_TCP;
    hints.ai_flags = AI_PASSIVE|AI_ADDRCONFIG;
    hints.ai_socktype = SOCK_STREAM;

    sprintf(buf,"%d",listen_port);
    
    if (bind_to.len){
        error = getaddrinfo(bind_to.s, buf, &hints, &res);
        if (error!=0){
            LOG(L_WARN,"WARNING:create_socket(): Error opening %.*s port %d while doing gethostbyname >%s\n",
                bind_to.len,bind_to.s,listen_port,gai_strerror(error));
            goto error;
        }
    }else{
        error = getaddrinfo(NULL, buf, &hints, &res);
        if (error!=0){
            LOG(L_WARN,"WARNING:create_socket(): Error opening ANY port %d while doing gethostbyname >%s\n",
                listen_port,gai_strerror(error));
            goto error;
        }
    }
        
    LOG(L_DBG,"DBG:create_sockets: create socket and bind for IPv4...\n");

    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:create_socket(): Trying to open/bind/listen on %s port %s\n",
                    host,serv);
        }               

        if ((server_sock = socket(ainfo->ai_family, ainfo->ai_socktype, ainfo->ai_protocol)) == -1) {
            LOG(L_ERR,"ERROR:create_socket(): error creating server socket on %s port %s >"
                " %s\n",host,serv,strerror(errno));
            goto error;
        }
        option = 1;
        setsockopt(server_sock,SOL_SOCKET,SO_REUSEADDR,&option,sizeof(option));
        
        if (bind(   server_sock,ainfo->ai_addr,ainfo->ai_addrlen)==-1 ) {
            LOG(L_ERR,"ERROR:create_socket(): error binding on %s port %s >"
                " %s\n",host,serv,strerror(errno));
            goto error;
        }
    
        if (listen( server_sock, 5) == -1) {
            LOG(L_ERR,"ERROR:create_socket(): error listening on %s port %s > %s\n",host,serv,strerror(errno) );
            goto error;
        }
    
        *sock = server_sock;    
        
        LOG(L_WARN,"INFO:create_socket(): Successful socket open/bind/listen on %s port %s\n",
                    host,serv);
    }
    if (res) freeaddrinfo(res); 
    return 1;
error:
    if (res) freeaddrinfo(res);
    if (server_sock!=-1) close(server_sock);
    return 0;
    
}

static int accept_connection	(	int	server_sock,
		int *	new_sock
	)			[inline, static]

Accepts an incoming connection by forking a receiver process.

Parameters:

	server_sock	- socket that this connection came in to
	new_sock	- socket to be update with the value of the accepter socket

Returns:

1 on success, 0 on error

Definition at line 172 of file tcp_accept.c.

References dp_add_pid(), errno, listening_socks, receiver_init(), and receiver_process().

Referenced by accept_loop().

{
    unsigned int length;
    struct sockaddr_in remote;
    int pid;
        
    /* do accept */
    length = sizeof( struct sockaddr_in);
    *new_sock = accept( server_sock, (struct sockaddr*)&remote, &length);

    if (*new_sock==-1) {
        LOG(L_ERR,"ERROR:accept_connection(): accept failed!\n");
        goto error;
    } else {
        LOG(L_INFO,"INFO:accept_connection(): new tcp connection accepted!\n");
        
    }
    
    receiver_init(*new_sock,0);

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

void accept_loop

(

)

Accept loop that listens for incoming connections on all listening sockets.

When a connection is received, accept_connection() is called.

Returns:

only on shutdown

Definition at line 226 of file tcp_accept.c.

References accept_connection(), errno, listening_socks, select, and shutdownx.

{
    fd_set listen_set;
    struct timeval timeout;
    int i=0,max_sock=0,nready;
    int new_sock;
    

    while(listening_socks[i]){
        if (listening_socks[i]>max_sock) max_sock=listening_socks[i];
        i++;
    }

    while(1){
        if (shutdownx && *shutdownx) break;
        
        timeout.tv_sec=2;
        timeout.tv_usec=0;  
        FD_ZERO(&listen_set);
        i=0;
        while(listening_socks[i]){
            FD_SET(listening_socks[i],&listen_set);                 
            i++;
        }

        nready = select( max_sock+1, &listen_set, 0, 0, &timeout);
        if (nready == 0){
            LOG(L_DBG,"DBG:accept_loop(): No connection attempts\n");
            continue;
        }
        if (nready == -1) {
            if (errno == EINTR) {
                continue;
            } else {
                LOG(L_ERR,"ERROR:accept_loop(): select fails: %s\n",
                    strerror(errno));
                sleep(2);
                continue;
            }
        }

        i=0;
        while(listening_socks[i]){
            if (FD_ISSET(listening_socks[i],&listen_set)){
                accept_connection(listening_socks[i],&new_sock);
            }
            i++;
        }
    }
}

---

Variable Documentation

unsigned int* listening_socks = 0

array of sockets listening for connections

Definition at line 79 of file tcp_accept.c.

Referenced by accept_connection(), accept_loop(), and acceptor_process().

int h_errno

---