---

nsds_util.c

Go to the documentation of this file.

#include "nsds_util.h"
#include "flog.h"

#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <netdb.h>
#include <errno.h>
#include <stdlib.h>
#include <stdio.h>
#include <math.h>
#include <unistd.h>
#include <stdint.h>
#include <string.h>
#include <signal.h>
#include <time.h>
#include <sys/time.h>

// Ref to control-c handler
extern bool control_break;


// ---------------------------------------------------------------------
char *gen_timestamp(void)
{
    char           me[] = "gen_timestamp";
    struct tm      l_tm;
    struct timeval t_highres;
    int            rc;
    static char    timebuf[80];
    time_t         in_time;
    
    // get fractional seconds
    rc = gettimeofday(&t_highres, NULL);
    if(rc != 0)
    {
    flog_usr(FLOG_ERROR, FL_ERR_SYSTEM, me,
         "Error reading current time!");
    return(NULL);
    }

    // Save elapsed seconds into time_t
    in_time = (time_t) t_highres.tv_sec;

    // Convert current into UTC
    gmtime_r(&in_time, &l_tm);
    
    // ISO 8601 format, as per 
    // http://www.exit109.com/~ghealton/y2k/yrexamples.html
    sprintf(timebuf, "%04d-%02d-%02dT%02d:%02d:%02d.%05.0f",
        l_tm.tm_year + 1900,
        l_tm.tm_mon + 1,
        l_tm.tm_mday,
        l_tm.tm_hour,
        l_tm.tm_min,
        l_tm.tm_sec,
        (float) (t_highres.tv_usec / 10.0));
    
    return(timebuf);
}


int tcp_socket_make(const uint16_t SRV_PORT, const int QUEUE_LENGTH)
{
    char                me[] = "tcp_socket_make";
    struct sockaddr_in  serv_in;
    struct protoent     *ppe = NULL;
    int             itmp;
    int                 new_socket = 0;
    const int           no_socket = -1;
    int                 so_reuseaddr = 1;
    struct linger       so_linger;

    
    ppe = getprotobyname("tcp");
    if(ppe == NULL)
    {
    flog_usr(FLOG_ERROR, FL_ERR_SYSTEM, me, 
         "Error on getprotobyname");
    return(no_socket);
    }
    
    itmp = socket(PF_INET, SOCK_STREAM, ppe->p_proto);
    
    // Socket returns -1 on an error
    if(itmp < 0)
    {
    flog_usr(FLOG_ERROR, FL_ERR_SOCKET, me,
         "Error on socket creation; server running?");
    return(no_socket);
    }
    else
    new_socket = itmp;

    // Set socket options - see LSPBE book for details
    itmp = setsockopt(new_socket, SOL_SOCKET, SO_REUSEADDR,
              &so_reuseaddr, sizeof(so_reuseaddr));
    if(itmp != 0)
    flog_usr(FLOG_WARNING, 0, me,
         "Failure on setsockopt");

    // Set linger to true so that close waits for flush
    so_linger.l_onoff = true;
    so_linger.l_linger = 5;    // 5 second timeout on close(2)
    itmp = setsockopt(new_socket, SOL_SOCKET, SO_LINGER,
              &so_linger, sizeof(so_linger));
    if(itmp != 0)
    flog_usr(FLOG_WARNING, 0, me,
         "Failure on setsockopt");
    
    // Set up servers' address
    serv_in.sin_family = AF_INET;
    serv_in.sin_addr.s_addr = INADDR_ANY;
    serv_in.sin_port = htons(SRV_PORT);
    
    // Bind the socket to address
    itmp = bind(new_socket, (struct sockaddr *) &serv_in, sizeof(serv_in));
    
    // bind also returns -1 on an error
    if(itmp < 0)
    {
    flog_usr(FLOG_ERROR, FL_ERR_SOCKET, me,
         "Unable to bind to local port; server already running?");

        close(new_socket);
    return(no_socket);
    }
    
    // enable incoming connections
    // No max queue length in linux >= 2.2, not sure about other unixes -
    // this is a side benefit of the syn flood fixes
    itmp = listen(new_socket, QUEUE_LENGTH);
    if(itmp < 0)
    {
    flog_usr(FLOG_ERROR, FL_ERR_SOCKET, me, "Listen failure");
    close(new_socket);
         
    return(no_socket);
    }
    
    flog_usr(FLOG_NOTICE, 0, me,
         "Network setup completed OK on port %d", SRV_PORT);

    return(new_socket);
}

int tcp_nl_write(const int socket, const char *buf)
{
    char   me[] = "tcp_nl_write";
    int    rc;
    int    len = strlen(buf);
    char   newline[] = "\n";
    
    rc = write(socket, buf, len);
    if(rc != len)
    {
    flog_usr(FLOG_ERROR, FL_ERR_TRANSCEIVE, me,
         "Error writing to socket");
    return(rc);
    }
    
    // Append newline
    rc = write(socket, newline, 1);
    if(rc != 1)
    {
    flog_usr(FLOG_ERROR, FL_ERR_TRANSCEIVE, me,
         "Error writing newline to socket");
    return(rc);
    }

    // Flush
    fsync(socket);
    
    // Made it OK
    return(len);
}

int tcp_nl_read(const uint16_t socket, char *buf, const time_t timeout)
{
    char              me[] = "tcp_nl_read";
    int               bytes_read = 0;
    int               rc;
    char              *write_ptr = buf;
    bool              done = false;
    bool              got_newline = false;
    socket_wait_ret   sel_rc;
    bool              got_err = false;    

    if(buf == NULL)
    return(-1);

    // DDT zero the buffer
    memset(buf, 0x00, MAX_CMD_LEN);
    
    while(!done)
    {
      sel_rc = SWAIT_SYS_ERR;

    if(bytes_read >= (MAX_CMD_LEN - 1))
    {
        flog_usr(FLOG_ERROR, FL_ERR_BUF_NOSPACE, me,
             "Max cmd length %d exceeded with no delimiter",
             MAX_CMD_LEN);
        done = true;
        got_err = true;
        break;
    }

    // Wait for data available
    sel_rc = tcp_socket_wait(socket, timeout);
    if(sel_rc == SWAIT_TIMEOUT)
    {
        flog_usr(FLOG_L3BUG, 0, me, "No data before timeout");
        done = true;
        break;
    }
    if(sel_rc != SWAIT_GOT_DATA)
    {
        flog_usr(FLOG_ERROR, FL_ERR_SOCKET, me, "Error waiting for data");
        done = true;
        got_err = true;
        break;
    }
    
    // read a byte at a time, Bottlenecks Anonymous
    rc = read(socket, write_ptr, 1);
    if(rc == 1)
    {
        // got a byte
        if((*write_ptr == '\n') || (*write_ptr == '\r'))
        {
        // Strip leading newlines, in case get cr/lf combo
        if(bytes_read == 0)
        {
            // Discard the data by leaving write ptr in same place
            continue;
        }
            
        got_newline = true;
        done = true;
        
        // Terminate the string, overwrites newline
        *write_ptr = 0x00;
        
        break;
        }
        else // No newline
        {
        write_ptr++;
        bytes_read++;
        }
        
    }
    else if(rc <= 0) // Error on read?
    {
        done = true;
        got_err = true;
        break;
    }
    else // should never occur, but just in case
        usleep(10);
    }

    // DDT
    //    printf("\nnl_read bytes: %d newline: %d", bytes_read, got_newline);
    
    if(got_newline)
    return(bytes_read);
    else if(got_err == false)
    return(0);
    else
      return(-1);
}

    
int tcp_connect(const char *server, const uint16_t port)
{
    char               me[] = "tcp_connect";
    struct hostent     *phe;    /* pointer to host information entry    */
    struct protoent    *ppe;    /* pointer to protocol information entry*/
    struct sockaddr_in sin;     /* an Internet endpoint address         */
    int                s, type; /* socket descriptor and socket type    */
    struct linger      so_linger;
    int                itmp;
    
    // Zero struct
    memset(&sin, 0x00, sizeof(sin));

    // Address family is INET
    sin.sin_family = AF_INET;

    /* Map service name to port number, ensuring network byte order */
    sin.sin_port = htons(port);

    /* Map host name to IP address, allowing for dotted decimal */
    phe = gethostbyname(server);

    if(phe != NULL)
        memcpy(&sin.sin_addr, phe->h_addr, phe->h_length);
    else
    {
    flog_usr(FLOG_ERROR, FL_ERR_HOST_NOTFOUND, me,
         "Connection error in gethostbyname");
        return(-1);
    }

    /* Map protocol name to protocol number */
    if ( (ppe = getprotobyname("tcp")) == 0)
    {
    flog_usr(FLOG_ERROR, FL_ERR_SYSTEM, me, 
         "Connection error in getprotobyname");
        return(-2);
    }

    type = SOCK_STREAM;

    /* Allocate a socket */
    s = socket(PF_INET, type, ppe->p_proto);
    if (s < 0)
    {
    flog_usr(FLOG_ERROR, FL_ERR_SYSTEM, me, "Error allocating socket");
        return(-3);
    }

    // Set linger to true so that close waits for flush, new 6/24/01 pfh
    so_linger.l_onoff = true;
    so_linger.l_linger = 5;    // 5 second timeout on close(2)
    itmp = setsockopt(s, SOL_SOCKET, SO_LINGER,
              &so_linger, sizeof(so_linger));
    if(itmp != 0)
    flog_usr(FLOG_WARNING, FL_ERR_SOCKET, me, 
         "Error setting socket opts");
    
    /* Connect the socket */
    if(connect(s, (struct sockaddr *)&sin, sizeof(sin)) < 0)
        return(-1);
   
    return s;
}

// ------------------------------------------------------------------------------
socket_wait_ret tcp_socket_wait(const int socket, const time_t timeout)
{
    char            me[] = "tcp_socket_wait";
    fd_set          read_fds;
    fd_set          err_fds;
    struct timeval  *sel_timeout = NULL;
    int             num_fds;
    int             sel_return;
    struct timeval  foo;


    // Do we have to worry about timeouts?
    if(timeout > 0)
    {
    sel_timeout = (struct timeval *) &foo;

    sel_timeout->tv_sec = timeout;
    sel_timeout->tv_usec = 0L;
    }
    else
    sel_timeout = NULL;
    
    // Clear all bits in read and error bitmaps
    FD_ZERO(&read_fds);
    FD_ZERO(&err_fds);

    // Flag socket descriptor as active in both
    FD_SET(socket, &read_fds);
    FD_SET(socket, &err_fds);

    // Ask system how many file descriptors we have to track
    num_fds = getdtablesize();

    // Call select, note that this is _only_ for reading!
    sel_return = select(num_fds, &read_fds,
            NULL, &err_fds, sel_timeout);

    // See if we got a readable socket or an error
    if(FD_ISSET(socket, &err_fds))
    {
    flog_usr(FLOG_INFO, FL_ERR_SOCKET, me, 
         "Error bit set in select");
    return(SWAIT_SYS_ERR);
    }

    // Figure out return code
    if((sel_return > 0) && (FD_ISSET(socket, &read_fds)))
    return(SWAIT_GOT_DATA);

    if(sel_return == -1)
    {
    flog_usr(FLOG_INFO, FL_ERR_SOCKET, me, "select returns -1");
    return(SWAIT_SYS_ERR);
    }

    if(sel_return == 0)
    return(SWAIT_TIMEOUT);

    // Catch-all; should be unreachable
    flog_usr(FLOG_L3BUG, 0, me,
         "Select returned %d, errno=%d", sel_return, errno);
    return(SWAIT_SYS_ERR);
}

// ---------------------------------------------------------------------
char * tcp_peername(const int socket)
{
    char               me[] = "tcp_peername";
    int                itmp, rc;
    struct sockaddr    client_info;
    struct sockaddr_in *so = (struct sockaddr_in *) &client_info;
    struct hostent     *cl_hostent = NULL;
    static char        remote_hostname[128] = "";
    

    // Check who connected
    itmp = sizeof(struct sockaddr);
    rc = getpeername(socket, &client_info, &itmp);
    if((rc != 0) || (itmp < 0))
    {
    flog_usr(FLOG_ERROR, FL_ERR_HOST_NOTFOUND, me,
         "Error getting peer information");
    return(remote_hostname);
    }

    // Do reverse DNS lookup
    cl_hostent = gethostbyaddr((char *) &so->sin_addr.s_addr,
                   sizeof(so->sin_addr.s_addr), AF_INET);
    if(cl_hostent == NULL)
    {
    flog_usr(FLOG_ERROR, FL_ERR_HOST_NOTFOUND, me,
         "Reverse DNS lookup failed");
    strcpy(remote_hostname, inet_ntoa(so->sin_addr));
    }
    else
    strcpy(remote_hostname, cl_hostent->h_name);
    
    return(remote_hostname);
}

    

// ---------------------------------------------------------------------
int tcp_connect_retry(const char *host, const uint16_t port,
              const time_t retry_delay, const time_t end_time,
              const char *description)
{
    char      me[] = "tcp_connect_retry";
    bool      done = false;
    int       retry_count = 0;
    int       cl_socket = -1;
    const char      *desc = NULL;
    

    // Use description if provided
    if(description != NULL)
    desc = description;
    else
    desc = host;
    
    while((done == false) && !(control_break))
    {
    // If end time is valid (>0), check
    if((end_time > 0) && (time(NULL) >= end_time))
    {
        flog_usr(FLOG_L3BUG, 0, me,
             "End time reached without connection, exiting");
        
        done = true;
        break;
    }

    flog_usr(FLOG_L2BUG, 0, me, 
         "Connecting to %s on %s, port %d", desc, host, port);
    
    cl_socket = tcp_connect(host, port);
    if(cl_socket > 0)
    {
        done = true;
        break;
    }
    
    flog_usr(FLOG_CL2BUG, 0, me,
         "Unable to connect to %s on %s, sleeping %d seconds",
         desc, host, (int) retry_delay);
    
    retry_count++;
    sleep(retry_delay);
    }
    
    return(cl_socket);
}

// ---------------------------------------------------------------------
void tcp_close(const int socket_fd)
{
    if(socket_fd <= 0)
    return;
    
    //Assume valid FD
    shutdown(socket_fd, SHUT_RDWR);
    close(socket_fd);
    
    return;
}

---