/home/jared/lsdmake/src/socket.h

/*
 *  socket.h
 *  Liq's Standard Library.
 *
 *  Created by Freddie Gutierrez on Sun Dec 19 2004.
 *  Copyright (c) 2004 Freddie Gutierrez. All rights reserved.
 *
 */

/*
How to set blocking after setting non-blocking.
<JeremyC> Liquidice: flags = fcntl(sock, F_GETFL);
<JeremyC> flags &= ~O_NONBLOCK;
<JeremyC> fcntl(sock, F_SETFL, flags);
*/

/* Declare function prototypes. */
int sock_connect(unsigned ip, unsigned short port);
void *memstr(const void *s1, size_t l1, const void *s2, size_t l2);
int scknread2(int sck, char *result, unsigned int to_read);
int sock_write(int sockfd, char *str);
int sock_close(int sockfd);
void Disconnect(int sockfd);
bool Connect(int &sockfd, const char *ip);


bool Connect(int &sockfd, const char *ip) {
        struct in_addr ipaddr;
        
        
        memset(&ipaddr, 0, sizeof(in_addr));
        
        if (inet_aton(ip, &ipaddr)) {
                sockfd = sock_connect(ipaddr.s_addr, 80);
                
                if (sockfd == -1)
                        printf("Error: Could not open socket.\n");
                else if (sockfd == -2)
                        printf("Error: Could not make connection.\n");
                else
                        return true;
        }

        return false;
}

void Disconnect(int sockfd) {
        sock_close(sockfd);
}

int sock_connect(unsigned ip, unsigned short port) {

        int sockfd; //sockfd = Socket File Descriptor
        struct sockaddr_in serv_addr;


        if ((sockfd = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
                //fprintf(stderr, "ERROR opening socket\n");
                return -1;
        } else {
                memset(&serv_addr, 0, sizeof(serv_addr)); //fill in the memory with zeros
                serv_addr.sin_family = AF_INET;
                serv_addr.sin_addr.s_addr = ip;
                serv_addr.sin_port = htons(port);

                if (connect(sockfd,(struct sockaddr *)&serv_addr,sizeof(serv_addr)) < 0) {
                        //fprintf(stderr,"ERROR connecting\n");
                        close(sockfd); //No connection could be made, so close the socket's file descriptor.
                        return -2;
                }
        }
        return sockfd; //w00t we're connected, so set the result to the file descriptor :D
}

bool sock_is_connected(int sockfd, unsigned int ip, unsigned short port) {
        struct sockaddr_in serv_addr;

        memset(&serv_addr, 0, sizeof(serv_addr));
        serv_addr.sin_family = AF_INET;
        serv_addr.sin_addr.s_addr = ip;
        serv_addr.sin_port = htons(port);

        connect(sockfd,(struct sockaddr *)&serv_addr,sizeof(serv_addr));

        if (errno == EISCONN)
                return true;

        return false;
}

char *sock_readall(int sockfd) {
        char *result, *tmp, *buffer[102400];
        int bytesread, lenlast, lentotal;
        struct pollfd wait;


        wait.fd = sockfd;
        wait.events = POLLIN;
        result = tmp = NULL;
        bytesread = lenlast = lentotal = 0;


        //printf("Initial Poll()...\n");
        fflush(stdout);

        /* Initial wait is 60 seconds. */
        if (poll(&wait, 1, 60000) == 1) { /* wait up to 60 seconds for data to become available */
                //puts("Reading...");
                fflush(stdout);
                bytesread = recv(sockfd, buffer, 102400, MSG_WAITALL);
                //printf("Read %d bytes. err = %i : %s\n", bytesread, errno, strerror(errno));

                if (bytesread > 0) {

                        result = (char *) malloc(lentotal + bytesread);
                        if (result == NULL)
                                return NULL;
                        memcpy(result+lentotal, buffer, bytesread);
                        lentotal += bytesread;
                }

        } else {
                //puts("sock_readall: Timed out while waiting for a response.");
        }

        /* If we received any data, check if there's anymore, But don't wait as long. */
        while(bytesread > 0) {

                lenlast = bytesread;
                bytesread = 0;
                //printf("Poll()...\n");
                fflush(stdout);

                if (poll(&wait, 1, 5000) == 1) { /* wait up to 5 seconds for data to become available */
                        //puts("Reading...");
                        fflush(stdout);
                        bytesread = recv(sockfd, buffer, 102400, MSG_WAITALL);
                        //printf("Read %d bytes. err = %i : %s\n", bytesread, errno, strerror(errno));

                        if (bytesread > 0) {
                                /* Safe realloc. */
                                tmp = (char *) realloc(result, (lentotal + bytesread));
                                if (tmp == NULL) {
                                        free(result);
                                        return NULL;
                                }
                                result = tmp;

                                memcpy(result+lentotal, buffer, bytesread);
                                lentotal += bytesread;
                        } else
                                break;

                } else {
                        puts("sock_readall: Timed out while waiting for a response.");
                        break;
                }
        }

        /* Safe realloc. */
        tmp = (char *) realloc(result, lentotal+1);
        if (tmp == NULL) {
                free(result);
                return NULL;
        }
        result = tmp;

        result[lentotal] = '\0';

        return result;
}


//buffer must have enough room for result_len + halt_str_len
int sckstrstr(int sockfd, char *result, size_t b_size, const char *halt_str) {
        unsigned int halt_str_len, total_len, reads;
        int this_read;
        char *str_ptr;


        total_len = reads = 0;
        halt_str_len = strlen(halt_str);

        do {
                this_read = recv(sockfd, result+total_len, b_size - total_len, 0);
                if (this_read > 0) {
                        total_len += this_read;
                        //if ((str_ptr = memstr(result, total_len,
                        //                                        halt_str, halt_str_len)) != NULL) {
                                str_ptr[halt_str_len - 1] = 0;

                                total_len = (unsigned int) ((str_ptr+halt_str_len) - result);
                                break;
                        //}
                } else {
                        if (this_read == 0)
                                printf("Read 0\n");
                        else
                                printf("recv(): %s\n", strerror(errno));
                        break;
                }
        } while(total_len < b_size);

        /* TODO: clear socket buffer. */

        return total_len;
}

/* TODO: clear socket buffer once done recv'ing unless you're going to
close() the socket. */
int sckssto(int sck, char *result, size_t b_size, const char *halt_str, float timeout) {
        unsigned int halt_str_len, total_len, reads;
        int select_result, this_read;
        char *str_ptr;
        struct timeval tv;
        fd_set rfds;
        
        total_len = reads = 0;
        halt_str_len = strlen(halt_str);
        FD_ZERO(&rfds);
        FD_SET(sck, &rfds);
        
        
        do {
                printf("Waiting.\n");
                tv.tv_sec = (int) timeout;
                tv.tv_usec = (int) (timeout - (float) tv.tv_sec) * 1000;
                select_result = select(sck+1, &rfds, NULL, NULL, &tv);
                printf("time's up sck = %i fd_set = %lu\n",
                           FD_ISSET(sck, &rfds), sizeof(fd_set));
                if (select_result == -1 && errno == EINTR)
                        continue;
                
                if (select_result > 0) {
                        printf("Reading.\n");
                        this_read = recv(sck, result+total_len, b_size - total_len, 0);
                        
                        if (this_read) {
                                total_len += this_read;
                                /* BUG: if only half of the halt_str is recv'd memstr 
                                will never beable to locate it because we've set the 
                                pointer past it. */
                                //if ((str_ptr = memstr(result+(total_len-this_read), this_read,
                                //                                        halt_str, halt_str_len)) != NULL) {
                                        printf("Got %i/%c\n", (int) *(str_ptr+halt_str_len), (char) *(str_ptr+halt_str_len));
                                        str_ptr[halt_str_len] = 0;
                                        total_len += strlen(result+(total_len - this_read)) - this_read;
                                        break;
                                //}
                        } else {
                                if (this_read == -1)
                                        return -1;
                                break;
                        }
                } else {
                        errno = ETIMEDOUT;
                        return -1;
                }
        } while(total_len < b_size);
        
        return total_len;
}

int scknstr_timeout(int sck, char *result, size_t b_size, const char *halt_str, short timeout) {
        unsigned int halt_str_len, total_len = 0;
        int this_read, select_result;
        char *str_ptr;
        struct timeval tv;
        fd_set rfds;


        /* Find length of halt string */
        halt_str_len = strlen(halt_str);

        /* Prepare our fd_set to watch for incoming data. */
        FD_ZERO(&rfds);
        FD_SET(sck, &rfds);

        /* Set timeout */
        tv.tv_sec = timeout;
        tv.tv_usec = 0;

        do {
                /* Wait for data to become available */
                select_result = select(sck+1, &rfds, NULL, NULL, &tv);

                /* If our select was interupted, re-start the loop. */
                if (select_result == -1 && errno == EINTR)
                        continue;

                if (select_result > 0) {
                        this_read = recv(sck, result+total_len, b_size - total_len, 0);
                        if (this_read > 0) {
                                total_len += this_read;
                                /* Search for halt string, if found, nul terminate 
                                buffer, correct total_len and break out of loop. */
                                //if ((str_ptr = memstr(result, total_len,
                                //                                        halt_str, halt_str_len)) != NULL) {
                                        str_ptr[halt_str_len] = 0;
                                        total_len += strlen(result+(total_len - this_read)) - this_read;
                                        break;
                        //      }
                        } else {
                                /* if recv() error, return and exit function */
                                if (this_read == -1)
                                        return -1;
                                /* recv() read 0 so break and return total read bytes */
                                break;
                        }
                } else {
                        /* select timed out, no data available */
                        errno = ETIMEDOUT;
                        return -1;
                }
        } while(total_len < b_size);

        return total_len;
}

void *memstr(const void *s1, size_t l1, const void *s2, size_t l2) {

        if (l1 || l2)
                while (l1 >= l2) {
                        l1--;
                        if (!memcmp(s1,s2,l2))
                                return (void *) s1;
                        ((char *) s1)++;
                }

        return NULL;
}

int sock_write(int sockfd, char *str) {
        if (send(sockfd, str, strlen(str), 0)) {
                return true;
        } else {

                fprintf(stderr, "sock_write: %s", strerror(errno));
                return false;
        }
        //return (send(sockfd, str, strlen(str), 0)) ? 1 : 0;
}

int sock_close(int sockfd) {
        return (close(sockfd) == 0) ? 1 : 0;
}

---