---

di_tempd.c

Go to the documentation of this file.

#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <netdb.h>

#include <stdlib.h>
#include <math.h>
#include <unistd.h>
#include <stdint.h>

#include "di194.h"

/* Globals */
const int SRV_PORT = 51307;
const int QUEUE_LENGTH = 64;
bool do_exit;

int socket_make(void)
{
    struct sockaddr_in  serv_in;
    struct protoent     *ppe = NULL;
    int                 itmp;
    int                 k_socket = 0;
    const int           no_socket = -1;
    int                 so_reuseaddr = 1;
    struct linger       so_linger;

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

    // ------------------------------------------------------
    // Set socket options - see LSPBE book for details
    itmp = setsockopt(k_socket, SOL_SOCKET, SO_REUSEADDR,
                      &so_reuseaddr, sizeof(so_reuseaddr));
    if(itmp != 0)
        perror("Warning; 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(k_socket, SOL_SOCKET, SO_LINGER,
                      &so_linger, sizeof(so_linger));
    if(itmp != 0)
        perror("Warning; 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(k_socket, (struct sockaddr *) &serv_in, sizeof(serv_in));
        
    // bind also returns -1 on an error
    if(itmp < 0)
    {
        perror("Unable to bind to local port; server already running?");

        close(k_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(k_socket, QUEUE_LENGTH);
    if(itmp < 0)
    {
        perror("Listen failure");
        close(k_socket);
        
        return(no_socket);
    }

    printf("\nNetwork setup completed OK on port %d\n", SRV_PORT);

    return(k_socket);
}

// ---------------------------------------------------------------------
void sighandler(int signal)
{
    char    me[] = "sighandler";

    fprintf(stderr, "\n%s: Got signal %d, exiting\n", me, signal);
    fflush(stderr);
    
    do_exit = true;

    return;
}

int daq_loop(const int CLIENT_SOCKET, const int USEC_DELAY)
{
    int           rc, s_len;
    char          asc_buf[128];
    daq_reading_t data;
    int           DI_FD = -1;
    float         temp_c = 0.0;
    time_t        t_now;
        
    DI_FD = di_open(getenv("DI194_PORT"));
    if(DI_FD <= 0)
    {
        fprintf(stderr, "\nError %d opening device\n", rc);
        di_close(DI_FD);
        close(CLIENT_SOCKET);
        
        return(rc);
    }
    
    rc = di_start(DI_FD);
    if(rc != 0)
    {
        fprintf(stderr, "\nError %d starting DAQ\n", rc);
        di_close(DI_FD);
        close(CLIENT_SOCKET);
        
        return(rc);
    }
    rc = di_daq_sync(DI_FD);
    if(rc != 0)
    {
        fprintf(stderr, "\nError %d syncing DAQ\n", rc);
        close(CLIENT_SOCKET);
        di_close(DI_FD);
        
        return(rc);
    }

    // Read one value
    rc = di_read(DI_FD, &data);
    if(rc != 0)
    {
        fprintf(stderr, "\nError %d reading data", rc);
        return(rc);
    }
    
    // Fixed format output - sensor is 10mV per degree C
    temp_c = (float) data.analog[0] * 100.0;
    
    sprintf(asc_buf, "%5.2f Celsius\n", temp_c);

    // Write it out the TCP port
    s_len = strlen(asc_buf);
    rc = write(CLIENT_SOCKET, asc_buf, (size_t) s_len);
    if(rc != s_len)
            fprintf(stderr, "\nError sending data: '%s'",
                    strerror(errno));

    printf("Reading: %5.2f volts ==> %5.2f Celsius, %5.2f F", 
           data.analog[0], temp_c,
           ((9.0 / 5.0) * temp_c) + 32.0);
    t_now = time(NULL);
    printf(" at %s", asctime(localtime(&t_now)));
        
    di_close(DI_FD);
    close(CLIENT_SOCKET);
    return(rc);
}

void main_loop(const int usec_delay)
{
    int                rc, itmp;
    int                client_socket = -1;
    struct sockaddr_in fsin;
    int                addr_len = sizeof(fsin);
    int                k_socket = -1;
    struct sockaddr    client_info;
    struct sockaddr_in *so = (struct sockaddr_in *) &client_info;
    struct hostent     *cl_hostent = NULL;
    char               remote_hostname[128] = "";
    

    // Setup the network; bail if failure
    k_socket = socket_make();
    if(k_socket <= 0)
        return;

    while(do_exit == false)
    {
        // Off we go
        printf("\nWaiting for client connection...");
        fflush(stdout);
    
        client_socket = accept(k_socket, 
                               (struct sockaddr *) &fsin, &addr_len);

        // Check who connected
        itmp = sizeof(struct sockaddr);
        rc = getpeername(client_socket, &client_info, &itmp);
        if((rc != 0) || (itmp < 0))
        {
            perror("Error getting peer information");
            continue;
        }
        
        // 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)
        {
            perror("Reverse DNS lookup failed");
            strcpy(remote_hostname, inet_ntoa(so->sin_addr));
        }
        else
            strcpy(remote_hostname, cl_hostent->h_name);
        
        printf("\nClient '%s' (%s) connected", 
               remote_hostname, inet_ntoa(so->sin_addr));
        
        // Call loop that does read'n'send
        daq_loop(client_socket, usec_delay);
    }
    
    return;
}
        
//***********************************************************************
int main(int argc, char *argv[])
{
    char          me[] = "main";
    const int     usec_delay = 1000;
    

    printf("%s: Installing signal handler.\n", me);
    do_exit = false;
    signal(SIGINT, sighandler);
    signal(SIGPIPE, sighandler);
    
    // Call main routine
    main_loop(usec_delay);
    
    return(0);
}

---