unix-network-programming-3rd

/*************************/
/* intro/daytimectpcli.c */
/*************************/

include "unp.h"

int main(int argc, char *argv[])
{
    int                 sockfd;
    int                 n;
    char                recvline[MAXLINE + 1];
    struct sockadr_in   servaddr;

    if (argc != 2) {
        err_quit("usage: a.out <IPaddress>");
    }

    if ((sockfd = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
        err_sys("socket error");
    }

    bzero(&servaddr, sizeof(servaddr));
    servaddr.sin_family = AF_INET;
    servaddr.sin_port = htons(13);    /* daytime server port */
    if (inet_pton(AF_INET, argv[1], &servaddr.sin_addr) <= 0) {
        err_quit("inet_pton error for %s", argv[1]);
    }
    /**********************************************/
    /* in unp.h, #define SA to be struct sockaddr */
    /**********************************************/
    if (connect(sockfd, (SA *) &servaddr, sizeof(servaddr)) < 0) {
        err_sys("connect error");
    }

    while ((n = read(sockfd, recvline, MAXLINE)) > 0) {
        recvline[n] = 0;
        if (fputs(recvline, stdout) == EOF) {
            err_sys("fputs error");
        }
    }
    if (n < 0) {
        err_sys("read error");
    }
    return 0;
}

~/test/unpbook/intro$ ./daytimetcpcli 127.0.0.1
Wed Nov 20 14:33:08 2013

sockfd = socket(AF_INET, SOCK_STREAM, 0);
int Socket(int family, int type, int protocol) {
    int n;
    if ((n = socket(family, type, protocol)) < 0) {
        err_sys("socket error");
    }
    return (n);
}

/**************************/
/* intro/daytimetcpsrv.c  */
/**************************/
#include "unp.h"
#include <time.h>

int main(int argc, char *argv[])
{
    int       listenfd;
    int       connfd;
    char      buff[MAXLINE];
    time_t    ticks;

    listenfd = Socket(AF_INET, SOCK_STREAM, 0);

    bzeros(&servaddr, sizeof(servaddr));
    servaddr.sin_family = AF_INET;
    servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
    servaddr.sin_port = htons(13); /* daytime server port */

    Bind(listenfd, (SA*) &servaddr, siezeof(servaddr));
    /**********************************************************/
    /* LISTENQ is from unp.h, it specifies the maximum number */
    /* of client connections that kernel will queue for this  */
    /* listening descriptor                                   */
    /**********************************************************/
    Listen(listenfd, LISTENQ);

    for ( ; ;) {
        connfd = Accept(listenfd, (SA*)NULL, NULL);

        ticks = time(NULL);
        snprintf(buff, sizeof(buff), "%.24s\n\n", ctime(&ticks));
        Write(connfd, buff, strlen(buff));
        Close(connfd);
    }
    return 0;
}

int main(int argc, char *argv[])
{
    union {
        short    s;
        char     c[sizeof(short)];
    } un;

    un.s = 0x0102;
    printf("%s: ", CPU_VENDOR_OS);
    if (sizeof(short) == 2) {
        if (un.c[0] == 1 && un.c[1] == 2) {
            printf("big-endian\n");
        } else if (un.c[0] ==2 && un.c[1] == 1) {
            printf("little-endian\n");
        } else {
            printf("unknown\n");
        }
    } else {
        printf("sizeof(short) = %d\n", sizeof(short));
    }
    return 0;
}

#includ <netinet/in.h>

// Both return: value in network byte order
uint16_t htons(uint16_t host16bitvalue);
uint32_t htonl(uint32_t host32bitvalue);

// Both return: value in host byte order
uint16_t ntohs(uint16_t net16bitvalue);
uint32_t ntohl(uint32_t net32bitvalue);

#include <arpa/inet.h>

// 1] converts c character pointed to by strptr into it2 32-bit
// binary network byte order value stored in addrptr
// 2] if string was valid return 1, otherwise return 0
// 3] if addrpter is NULL, the function still performs the validation
int inet_aton(const char* strptr, struct in_addr* addrptr);

// return pointers to dotted-decimal string
// use static memory in inet_ntoa implementation and thus NOT reentrant
char *inet_ntoa(struct in_addr inaddr);

char * inet_ntoa_r(struct in_addr in, char *buf, socklen_t size) {
        (void) inet_ntop(AF_INET, &in, buf, size);
        return (buf);
}

#include <arpa/inet.h>

int inet_pton(int family, const char *strptr, void *addrptr);

const char* inet_ntop(int family, const void *addrptr, char *strptr, size_t len);

char * sock_ntop(const struct sockaddr* sa, socklen_t salen) {
    char          portstr[8];
    static char   str[128];   /* unix domain is largest */

    switch (sa->sa_family) {
    case AF_INET: {
        struct sockaddr_in *sin = (struct sockaddr_in *)sa;

        if (inet_ntop(AF_INET, &sin->sin_addr, str, sizeof(str)) == NULL) {
            return (NULL);
        }
        if (ntohs(sin->sin_port) != 0) {
            snprintf(portstr, sizeof(portstr) ":%d",
                     ntohs(sin->sin_port));
            strcat(str, portstr);
        }
        return (str);
    }
        //.....
    }
}

int sock_bin_wild(int sockfd, int family);

int sock_cmp_addr(const struct sockaddr *sockaddr1,
                  const struct sockaddr *sockaddr2,
                  socklen_t addrlen);
int sock_cmp_port(const struct sockaddr *sockaddr1,
                  const struct sockaddr *sockaddr2,
                  socklen_t addrlen);
int sock_get_port(const struct sockaddr* sockaddr, socklen_t addrlen);
char *sock_ntop_host(const struct sockaddr* sockaddr, socklen_t addrlen);
void sock_set_addr(const struct sockaddr *sockaddr, socklen_t addrlen, void *ptr);
void sock_set_port(const struct sockaddr *sockaddr, socklen_t addrlen, int port);
void sock_set_wild(struct sockaddr *sockaddr, socklen_t addrlen);

static int read_cnt;
static char *read_ptr;
static char read_buf[MAXLINE];

static ssize_t
my_read(int fd, char *ptr) {
    if (read_cnt <= 0) {
    again:
        if ((read_cnt == read(fd, read_buf, sizeof(read_buf))) < 0) {
            if (errno == EINTR) {
                goto again;
            }
            return (-1);
        } else if (read_cnt == 0) {
            return (0);
        }
        read_ptr = read_buf;
    }

    read_cnt--;
    *ptr = *read_ptr++;
    return (1);
}

ssize_t
readline(int fd, void *vptr, size_t maxlen) {
    ssize_t n, rc;
    char    c, *ptr;

    ptr = vptr;
    for (n = 1; n < maxlen; n++) {
        if ((rc = my_read(fd, &c)) == 1) {
            *ptr++ = c;
            if (c == '\n') {
                break;
            }
        } else if (rc == 0) {
            *ptr = 0;
            return (n-1);
        } else {
            return (-1);
        }
    }

    *ptr = 0;
    return (n);
}


ssize_t
readlinebuf(void **vptrptr) {
    if (read_cn) {
        *vptrptr = read_ptr;
    }
    return (read_cn);
}

#include <sys/socket.h>

int socket(int family, int type, int protocol);

#include <sys/socket.h>

int connect(int socfd, const struct sockaddr *servaddr, socklen_t addrlen);

#include <sys/socket.h>

int bind(int sockfd, const struct sockaddr *myaddr, socklen_t addrlen);

#include <sys/socket.h>

int listen(int sockfd, int backlog);

#include <sys/socket.h>

int accept(int sockfd, struct sockaddr *cliaddr, socklen_t *addrlen);

#include "unp.h"
#include <time.h>

int
main(int argc, char *argv) {
    int          listenfd, confd;
    socklen_t    len;
    struct sockaddr_in servaddr, cliaddr;
    char         buff[MAXLINE];
    time_t       ticks;

    listenfd = Socket(AF_INET, SOCK_STRAM, 0);

    bzero(&servaddr, sizeof(servaddr));
    servaddr.sin_family = AF_INET;
    servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
    servaddr.sin_port = htons(13);   /* daytime server */

    Bind(listenfd, (SA*)&servaddr, sizeof(servaddr));

    Listen(listenfd, LISTENQ);

    for ( ; ;) {
        len = sizeof(cliaddr);
        connfd = Accept(listenfd, (SA *) &cliaddr, &len);
        printf("connection from %s, port %d\n",
               Inet_ntop(AF_INET, &cliaddr.sin_addr, buff, sizeof(buff)),
               ntohs(cliaddr.sin_port));

        ticks = time(NULL);
        snprintf(buff, sizeof(buff), "%.24s\r\n", ctime(&ticks));
        Write(connfd, buff, strlen(buff));

        Close(connfd);
    }
    //listening socket will be close at last with exit()
}

#include <unistd.h>

pid_t fork(void);

#include <unistd.h>

int execl(const char *pathname, const char *arg0, .../* (char*) 0 */);

int execv(const char *pathname, char *const argv[]);

int execle(const char *pathname, const char *arg0, ...
           /* (char *)0, char *const envp[] */);

int execve(const char  *pathname, char *const argv[], char *const envp[]);

int execlp(const char *filename, const char *arg0, .../* (char *) 0 */);

int execvp(const char *filename, char *const *const argv[]);

pid_t pid;
int   listenfd,  connfd;

listenfd = Socket(/*...*/);

Bind(listenfd, /*...*/);
Listen(listenfd, LISTENQ);

for ( ; ;) {
    connfd = Accept(listenfd, ...);

    if ((pid = Fork()) == 0) {
        /* child closes listenindg socket
           as this listenfd is copied from
           parent, ref count will be 2, this
           close minus it to 1, and the parent
           copy will be used normally.
         */
        Close(litenfd);
        doit(connfd);         /* process the request */
        Close(connfd);        /* done with this client */
        exit(0);              /* child terminates */
    }
    /* parent closes connected socket
       as this connfd is copied to child,
       ref count will be 2, this close
       minus it to 1, and the child copy
       close will finally cause the four-way
       wave
       */
    Close(connfd);
}

#include <unisd.h>

int close(int sockfd);

int getsockname(int sockfd, struct sockaddr* localaddr, socklen_t* addrlen);

int getpeername(int sockfd, struct sockaddr *peeraddr, socklen_t *addrlen);

#include   "unp.h"

int
main(int argc, char **argv) {
    int         listenfd, connfd;
    pid_t       childpid;
    socklen_t   clilen;
    struct sockaddr_in cliaddr, servaddr;

    listenfd = Socket(AF_INET, SOCK_STREAM, 0);

    bzero(&servaddr, sizeof(servaddr));
    servaddr.sin_family = AF_INET;
    servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
    servaddr.sin_port = htons(SERV_PORT);

    Bind(listenfd, (SA*)&servaddr, sizeof(servaddr));

    Listen(listenfd, LISTENQ);

    for (; ;) {
        clilen = sizeof(cliaddr);
        connfd = Accept(listenfd, (SA*)&cliaddr, &clilen);

        if ((childpid = Fork()) == 0) { /* child process */
            Close(listenfd);            /* close listening socket */
            str_echo(connfd);           /* process the request */
            exit(0);
        }
        Close(connfd);                  /* parent closes connected socket */
    }
}

#include   "unp.h"

void
str_echo(int sockfd) {
    ssize_t    n;
    char       buf[MAXLINE];

again:
    while ((n = read(sockfd, buf, MAXLINE)) > 0) {
        Writen(sockfd, buf, n);
    }

    if (n < 0 && errno == EINTR) {
        goto again;
    } else if (n < 0) {
        err_sys("str_echo: read error");
    }
}

#include "unp.h"

int main(int argc, char **argv) {
    int        sockfd;
    struct sockaddr_in servaddr;

    if (argc != 2) {
        err_quit("usage: tcp cli <IPaddress>");
    }
    sockfd = Socket(AF_INET, SOCK_STREAM, 0);

    bzero(&servaddr, sizeof(servaddr));
    servaddr.sin_family = AF_INET;
    servaddr.sin_port = htons(SERV_PORT);
    Inet_pton(AF_INET, argv[1], &servaddr.sin_addr);

    Connect(sockfd, (SA*) &servaddr, sizeof(servaddr));

    str_cli(stdin, sockfd);    /* do it all */
    exit(0);
}

#include    "unp.h"

void str_cli(FILE *fp, int sockfd) {
    char         sendline[MAXLINE], recvline[MAXLINE];

    while (Fgets(sendline, MAXLINE, fp) != NULL) {
        Writen(sockfd, sendline, strlen(sendline));

        if (Readline(sockfd, recvline, MAXLINE) == 0) {
            err_quit("str_cli: server terminated permaturely");
        }

        Fputs(recvline, stdout);
    }
}

linux % tcpserv01 &
[1] 17870

linux % netstat -a
Active Internet connections (servers and established)
Proto   Recv-Q Send-Q Local Address   Foreign Address    State
tcp          0      0 *:9877          *:*                LISTEN

linux % tcpcli01 127.0.0.1

linux % netstat -a
Active Internet connections (servers and established)
Proto  Recv-Q  Send-Q  Local Address       Foreign Address    State
tcp         0       0  local host:9877     localhost:42758    ESTABLISHED
tcp         0       0  local host:42758    localhost:9877     ESTABLISHED
tcp         0       0  *:9877              *:*                LISTEN

linux % tcpcli01 127.0.0.1
hello, world
hello, world
good bye
good bye
^D

linux % netstat -a | grep 9877
tcp      0    0   *:9877                   *:*                LISTEN
tcp      0    0   localhost:42758          localhost:9877     TIME_WAIT

#include <sys/wait.h>

pid_t wait(int *statloc);
pid_t waitpid(pid_t pid, int *statloc, int options);

#include    "unp.h"

void str_cli(FILE *fp, int sockfd) {
    char     sendline[MAXLINE], recvline[MAXLINE];

    while(Fgets(sendline, MAXLINE, fp) != NULL) {
        Writen(sockfd, sendline, 1);
        sleep(1);
        Writen(sockfd, sendline + 1, strlen(sendline) - 1);

        if (Readline(sockfd, recvline, MAXLINE) == 0) {
            err_quit("str_cli: server terminated prematurely");
        }

        Fputs(recvline, stdout);
    }
}

linux % tcpcli11 127.0.0.1
hi there
hi there

bye

#include <sys/select.h>
#include <sys/time.h>

/*************************************************/
/* Returns: positive count of ready descriptors, */
/* 0 on timeout, -1 on error                     */
/*************************************************/
int select(int maxfdp1, fd_set* readset, fd_set* writeset,
           fd_set* exceptset, const struct timeval* timeout);

struct timeval {
    long   tv_sec;         /* secondes */
    long   tv_usec;        /* microseconds */
};

void FD_ZERO(fd_set *fdset);         /* clear all bitst in fdset */
void FD_SET(int fd, fd_set *fdset);  /* turn on the bit for fd in fdset */
void FD_CLR(int fd, fd_set *fdset);  /* turn off the bit for fd in fdset */
int FD_ISSET(int fd, fd_set *fdset); /* is the bit for fd on in fdset? */

#include "unp.h"

void str_cli(FILE *fp, int sockfd) {
    int    maxfdp1;
    fd_set reset;
    char   sendline[MAXLINE], recvline[MAXLINE];

    FD_ZERO(&rset);
    for( ; ;) {
        FD_SET(fileno(fp), &rset);
        FD_SET(sockfd, &rset);
        maxfdp1 = max(fileno(fp), sockfd) + 1;
        Select(maxfdp1, &rset, NULL, NULL, NULL);

        if (FD_ISSET(sockfd, &rset)) { /* socket is readable */
            if (Readline(sockfd, recvline, MAXLINE) == 0) {
                err_quit("str_cli: server terminated prematurely");
            }
            Fputs(recvline, stdout);
        }

        if (FD_ISSET(fileno(fp), &rset)) { /* input is readable */
            if (Fgets(sendline, MAXLINE, fp) == NULL) {
                return;    /* all done */
            }
            Writen(sockfd, sendline, strlen(sendline));
        }
    }
}

#include <sys/socket.h>

int shutdown(int sockfd, int howto);

#include "unp.h"

void str_cli(FILE *fp, int sockfd) {
    int     maxfdp1, stdineof;
    fd_set  reset;
    char    buf[MAXLINE];
    int     n;

    stdineof = 0;
    FD_ZERO(&rset);
    for (; ;) {
        if (stdineof == 0) {
            FD_SET(fileno(fp), &rset);
        }

        FD_SET(sockfd, &rset);
        maxfdp1 = max(fileno(fp), sockfd) + 1;
        Select(maxfdp1, &rset, NULL, NULL, NULL);

        if (FD_ISSET(sockfd, &rset)) {   /* socket is readable */
            if ((n = Read(sockfd, buf, MAXLINE)) == 0) {
                if (stdineof == 1) {
                    return;
                } else {
                    err_quit("str_cli: server terminated prematurely");
                }
                Write(fileno(stdout), buf, n);
            }
        }
        if (FD_ISSET(fileno(fp), &rset)) { /* input is readable */
            if ((n = Read(fileno(fp), buf, MAXLINE)) == 0) {
                stdineof = 1;
                Shutdown(sockfd, SHUT_WR);  /* send FIN ==> half close */
                FD_CLR(fileno(fp), &rset);
                continue;
            }
            Writen(sockfd, buf, n);
        }
    }
}

 1: #include  "unp.h"
 2: 
 3: int main(int argc, char *argv[])
 4: {
 5:     int         i, maxi, maxfd, listenfd, connfd, sockfd;
 6:     int         nready, client[FD_SETSIZE];
 7:     ssize_t     n;
 8:     fd_set      rset, allset;
 9:     char        buf[MAXLINE];
10:     socklen_t   clilen;
11:     struct sockaddr_in cliaddr, servaddr;
12: 
13:     listenfd = Socket(AF_INET, SOCK_STREAM, 0);
14: 
15:     bzero(servaddr, sizeof(servaddr));
16:     servaddr.sin_family = AF_INET;
17:     servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
18:     servaddr.sin_port = htons(SERV_PORT);
19: 
20:     Bind(listenfd, (SA*)&servaddr, sizeof(servaddr));
21: 
22:     Listen(listenfd, LISTENQ);
23: 
24:     maxfd = listenfd;           /* initialize */
25:     maxi = -1;                  /* index into client[] array */
26:     for (i = 0; i < FD_SETSIZE; i++) {
27:         client[i] = -1;         /* -1 indicates available entry */
28:     }
29:     FD_ZERO(&allset);
30:     FD_SET(listenfd, &allset);
31: 
32:     for (; :) {
33:         rset = allset;         /* structure assignment */
34:         nready = Select(maxfd + 1, &rset, NULL, NULL, NULL);
35: 
36:         if (FD_ISSET(listenfd, &rset)) {  /* new client connection */
37:             clilen = sizeof(cliaddr);
38:             connfd = Accept(listenfd, (SA*)&cliaddr, &clilen);
39: 
40:             for (i = 0; i < FD_SETSIZE; i++) {
41:                 if (client[i] < 0) {
42:                     client[i] = connfd;  /* save descriptor */
43:                     break;
44:                 }
45:             }
46:             if (i == FD_SETSIZE) {
47:                 err_quit("too many clients");
48:             }
49:             FD_SET(connfd, &allset);       /* add new descriptor to set */
50: 
51:             if (connfd > maxfd) {
52:                 maxfd = connfd;
53:             }
54:             if (i > maxi) {
55:                 maxi = i;
56:             }
57:             if (--nready <= 0) {
58:                 continue;
59:             }
60:         }
61: 
62:         for (i = 0; i <= maxi; i++) {
63:             if ((sockfd = client[i]) < 0) {
64:                 continue;
65:             }
66:             if (FD_ISSET(sockfd, &rset)) {
67:                 if ((n = Read(sockfd, buf, MAXLINE)) == 0) {
68:                     /* connection closed by client */
69:                     Close(sockfd);
70:                 } else {
71:                     Writen(sockfd, buf, n);
72:                 }
73: 
74:                 if (--nready <= 0) {
75:                     break;
76:                 }
77:             }
78:         }
79:     }
80:     return 0;
81: }

#include <sys/select.h>
#include <signal.h>
#include <time.h>

/*****************************************************************/
/* Returns: count of ready descriptor, 0 on timeout, -1 on error */
/*****************************************************************/
int pselect(int maxfdp1, fd_set* readset, fd_set* writeset, fd_set* exceptset,
            const struct timespec* timeout, const sigset_t *sgmask);

#include <poll.h>

/******************************************************************/
/* Returns: count of ready descriptors, 0 on timeout, -1 on error */
/******************************************************************/
int poll(struct pollfd *fdarray, unsigned long nfds, int timeout);

struct pollfd {
    int      fd;        /* descriptor to check */
    short    events;    /* events of interest on fd */
    sthort   revents;   /* events that occurred on fd */
};

#include   "unp.h"
#include   <limits.h>          /* for OPEN_MAX */

int main(int argc, char *argv[])
{
    int       i, maxi, listenfd, connfd, sockfd;
    int       nready;
    ssize_t   n;
    char      buf[MAXLINE];
    socklen_t clilen;
    struct pollfd client[OPEN_MAX];
    struct sockaddr_in cliaddr, servaddr;

    listenfd = Socket(AF_INET, SOCK_STREAM, 0);

    bzero(&servaddr, sizeof(servaddr));
    servaddr.sin_family = AF_INET;
    servaddr.sin_addr.s_addr = htol(INADDR_ANY);
    servaddr.sin_port = htons(SERV_PORT);

    Bind(listenfd, (SA*) &servaddr. sizeof(servaddr));

    Listen(listenfd, LISTENQ);

    client[0].fd = listenfd;
    client[0].events = POLLRDNORM;
    for (i = 1; i < OPEN_MAX; i++) {
        client[i].fd = -1;
    }
    maxi = 0;
    for (; ;) {
        nready = Poll(client, maxi + 1, INFTIM);
        if (client[0].revents & POLLRDNORM) { /* new client connection */
            clilen = sizeof(cliaddr);
            connfd = Accept(listenfd, (SA*)&cliaddr, &clilen);

            for (i = 1; i < OPEN_MAX; i++) {
                if (client[i].fd < 0) {
                    client[i].fd = connfd;  /* save descriptor */
                    break;
                }
            }
            if (i == OPEN_MAX) {
                err_quit("too many clients");
            }
            client[i].events = POLLRDNORM;

            if (i > maxi) {
                maxi = i;
            }

            if (--nready <= 0) {
                continue;
            }
        }
    }

    for (i = 1; i <= maxi; i++) {    /* check all clients for data */
        if ((sockfd = client[i].fd) < 0) {
            continue;
        }
        if (client[i].revents & (POLLRDNORM | POLLERR)) {
            if ((n = read(sokfd, buf, MAXLINE)) < 0) {
                if (errno == ECONNERESET) {
                    /* connection reset by client */
                    Close(sockf);
                    client[i].fd = -1;
                } else if (n == 0) {
                    /* connection close by client */
                    Close(sockfd);
                    client[i].fd = -1;
                } else {
                    Writen(sockfd, buf, n);
                }
                if (--nready <= 0) {
                    break;
                }
            }
        }
    }
    return 0;
}

#include <syt/socket.h>

int getsockopt(int sockfd, int level, int optname, void *optval, socklen_t* optlen);

int setsockopt(int sockfd, int level, int optname, const void* optval, socklen_t optlen);

 1: #include   "unp.h"
 2: #include   <netinet/tcp.h>     /* for TCP_xxx defines */
 3: 
 4: union val {
 5:     int                  i_val;
 6:     long                 l_val;
 7:     struct linger        linger_val;
 8:     struct timeval       timeval_val;
 9: }val;
10: 
11: static char *sock_str_flag(union val*, int);
12: static char *sock_str_int(union val*, int);
13: static char *sock_str_linger(union val*, int);
14: static char *sock_str_timeval(union val*, int);
15: 
16: struct sock_opts{
17:     const  char*   opt_str;
18:     int            opt_level;
19:     int            opt_name;
20:     char           *(*opt_val_str) (union val *, int);
21: } sock_opts[] = {
22:     { "SO_BROADCAST",        SOL_SOCKET, SO_BROADCAST,   sock_str_flag },
23:     { "SO_DEBUG",            SOL_SOCKET, SO_DEBUG,       sock_str_flag },
24:     { "SO_DONTROUTE",        SOL_SOCKET, SO_DONTROUTE,   sock_str_flag },
25:     { "SO_ERROR",            SOL_SOCKET, SO_ERROR,       sock_str_int },
26:     { "SO_KEEPALIVE",        SOL_SOCKET, SO_KEEPALIVE,   sock_str_flag },
27:     { "SO_LINGER",           SOL_SOCKET, SO_LINGER,      sock_str_linger },
28:     { "SO_OOBINLINE",        SOL_SOCKET, SO_OOBINLINE,   sock_str_flag },
29:     { "SO_RCVBUF",           SOL_SOCKET, SO_RCVBUF,      sock_str_int },
30:     { "SO_SNDBUF",           SOL_SOCKET, SO_SNDBUF,      sock_str_int },
31:     { "SO_RCVLOWAT",         SOL_SOCKET, SO_RCVLOWAT,    sock_str_int },
32:     { "SO_SNDLOWAT",         SOL_SOCKET, SO_SNDLOWAT,    sock_str_int },
33:     { "SO_RCVTIMEO",         SOL_SOCKET, SO_RCVTIMEO,    sock_str_timeval },
34:     { "SO_SNDTIMEO",         SOL_SOCKET, SO_SNDTIMEO,    sock_str_timeval },
35:     { "SO_REUSEADDR",        SOL_SOCKET, SO_REUSEADDR,   sock_str_flag },
36: #ifdef SO_REUSEPORT
37:     { "SO_REUSEPORT",        SOL_SOCKET, SO_REUSEPORT,   sock_str_flag },
38: #else
39:     { "SO_REUSEPORT",        0,          0,              NULL },
40: #endif
41:     { "SO_TYPE",             SOL_SOCKET, SO_TYPE,        sock_str_int },
42:     { "SO_USELOOPBACK",      SOL_SOCKET, SO_USELOOPBACK, sock_str_flag },
43:     { "IP_TOS",              IPPROTO_IP, IP_TOS,         sock_str_int },
44:     { "IP_TTL",              IPPROTO_IP, IP_TTL,         sock_str_int },
45:     { "IPV6_DONTFRAG",       IPPROTO_IPV6,IPV6_DONTFRAG, sock_str_flag },
46:     { "IPV6_UNICAST_HOPS",   IPPROTO_IPV6,IPV6_UNICAST_HOPS,sock_str_int },
47:     { "IPV6_V6ONLY",         IPPROTO_IPV6,IPV6_V6ONLY,   sock_str_flag },
48:     { "TCP_MAXSEG",          IPPROTO_TCP,TCP_MAXSEG,     sock_str_int },
49:     { "TCP_NODELAY",         IPPROTO_TCP,TCP_NODELAY,    sock_str_flag },
50:     { "SCTP_AUTOCLOSE",      IPPROTO_SCTP,SCTP_AUTOCLOSE,sock_str_int },
51:     { "SCTP_MAXBURST",       IPPROTO_SCTP,SCTP_MAXBURST, sock_str_int },
52:     { "SCTP_MAXSEG",         IPPROTO_SCTP,SCTP_MAXSEG,   sock_str_int },
53:     { "SCTP_NODELAY",        IPPROTO_SCTP,SCTP_NODELAY,  sock_str_flag },
54:     { NULL,                  0,          0,              NULL }
55: };

static char strres[128];

static char* sock_str_flag(union val* ptr, int len) {
    if (len != sizeof(int)) {
        snprintf(strres, sizeof(strres), "size (%d) ont sizeof(int)", len);
    } else {
        snprintf(strres, sizeof(strres),
                 "%s", (ptr->i_val == 0) ? "off" : "on");
    }
}

{ NULL,                  0,          0,              NULL }

 1: int main(int argc, char *argv[])
 2: {
 3:     int       fd;
 4:     socklen_t len;
 5:     struct sock_opts* ptr;
 6: 
 7:     for (ptr = sock_opts; ptr->opt_str != NULL; ptr++) {
 8:         printf("%s: ", ptr->opt_str);
 9:         if (ptr->opt_val_str == NULL) {
10:             printf("(undefined) \n");
11:         } else {
12:             switch(ptr->opt_level) {
13:             case SOL_SOCKET:
14:             case IPPROTO_IP:
15:             case IPPROTO_TCP:
16:                 fd = Socket(AF_INET, SOCK_STREAM, 0);
17:                 break;
18: #ifdef IPV6
19:             case IPPROTO_IPV6:
20:                 fd = Socket(AF_INET6, SOCK_STREAM, 0);
21:                 break;
22: #endif
23: #ifdef IPPROTO_SCTP
24:             case IPPROTO_SCTP:
25:                 fd = Socket(AF_INET, SOCK_SEQPACKET, IPPROTO_SCTP);
26:                 break;
27: #endif
28:             default:
29:                 err_quit("Can't create fd for level %d\n", ptr->opt_level);
30:             }
31:             len = sizeof(val);
32:             if (getsockopt(fd, ptr->opt_level, ptr->opt_name,
33:                            &val, &len) == -1) {
34:                 err_ret("getsockopt error");
35:             } else {
36:                 printf("default = %s\n", (*ptr->opt_val_str) (&val, len));
37:             }
38:             close(fd);
39:         }
40:     }
41:     return 0;
42: }

hfeng@ubuntu-server64:~/tmp/unpbook/sockopt$ ./checkopts
SO_BROADCAST: default = off
SO_DEBUG: default = off
SO_DONTROUTE: default = off
SO_ERROR: default = 0
SO_KEEPALIVE: default = off
SO_LINGER: default = l_onoff = 0, l_linger = 0
SO_OOBINLINE: default = off
SO_RCVBUF: default = 87380
SO_SNDBUF: default = 16384
SO_RCVLOWAT: default = 1
SO_SNDLOWAT: default = 1
SO_RCVTIMEO: default = 0 sec, 0 usec
SO_SNDTIMEO: default = 0 sec, 0 usec
SO_REUSEADDR: default = off
SO_REUSEPORT: (undefined)
SO_TYPE: default = 1
IP_TOS: default = 0
IP_TTL: default = 64
IPV6_DONTFRAG: (undefined)
IPV6_UNICAST_HOPS: default = 64
IPV6_V6ONLY: default = off
TCP_MAXSEG: default = 536
TCP_NODELAY: default = off
SCTP_AUTOCLOSE: (undefined)
SCTP_MAXBURST: (undefined)
SCTP_MAXSEG: (undefined)
SCTP_NODELAY: (undefined)

#include <fcntl.h>

/**********************************************/
/* Returns: depends on cmd if OK, -1 on error */
/**********************************************/
int fcntl(int fd, int cmd, .../*int arg*/);

int   flags;

if ((flags = fcntl(fd, F_GETFL,0)) < 0) {
    err_sys("F_GETFL error");
}

flags |= O_NONBLOCK;
if (fcntl(fd, F_SETFL, flags) < 0) {
    err_sys("F_SETFL error");
}

/* !! Wrong way to set a socket as non blocking !! */
if (fcntl(fd, F_SETFL, O_NONBLOCK) < 0) {
    err_sys("F_SETFL error");
}

int   flags;

if ((flags = fcntl(fd, F_GETFL,0)) < 0) {
    err_sys("F_GETFL error");
}

flags &= ~O_NONBLOCK;
if (fcntl(fd, F_SETFL, flags) < 0) {
    err_sys("F_SETFL error");
}

#include <sys/socket.h>

/*******************************************************************/
/* Both return: number of bytes read or written if OK, -1 on error */
/*******************************************************************/
ssize_t recvfrom(int sockfd, void* buff, size_t nbytes, int flags,
                 struct sockaddr* from, socklen_t* addrlen);
ssize_t sendto(int sockfd, const void* buff, size_t nbytes, int flags,
               const struct sockaddr* to, socklen_t addrlen);

#include      "unp.h"

int main(int argc, char *argv[])
{
    int   sockfd;
    struct sockaddr_in servaddr, cliaddr;

    sockfd = Socket(AF_INET, SOCK_DGRAM, 0);

    bzero(&servaddr, sizeof(servaddr));
    servadr.sin_family = AF_INET;
    servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
    servaddr.sin_port = htons(SERV_PORT);

    Bind(sockfd, (SA*)&servaddr, sizeof(servaddr));

    dg_echo(sockfd, (SA*)&cliaddr, sizeof(cliaddr));
    return 0;
}

#include "unp.h"

void dg_echo(int sockfd, SA* pcliaddr, socklen_t clilen) {
    int   n;
    socklen_t len;
    char mesg[MAXLINE];

    for (; ;) {
        len = clilen;
        n = Recvfrom(sockfd, mesg, MAXLINE, 0, pcliaddr, &len);

        Sendto(sock, mesg, n, 0, pcliaddr, len);
    }
}

 1: #include "unp.h"
 2: int main(int argc, char *argv[])
 3: {
 4:     int    sockfd;
 5:     struct sockaddr_in servaddr;
 6: 
 7:     if (argc != 2) {
 8:         err_quit("usage: udpcli <IPaddress>");
 9:     }
10: 
11:     bzero(&servaddr, sizeof(servaddr));
12:     servaddr.sin_family = AF_INET;
13:     servaddr.sin_port = htons(SERV_PORT);
14:     Inet_pton(AF_INET, argv[1], &servaddr.sin_addr);
15: 
16:     sockfd = Socket(AF_INET, SOCK_DGRAM, 0);
17:     dg_cli(stdin, sockfd, (SA*) &servaddr, sizeof(servaddr));
18:     return 0;
19: }

 1: #include "unp.h"
 2: 
 3: void dg_cli(FILE* fp, int sockfd, const SA* pservaddr, socklen_t servlen) {
 4:     int    n;
 5:     char   sendline[MAXLINE], recvline[MAXLINE + 1];
 6: 
 7:     while (Fgets(sendline, MAXLINE, fp) ! = NULL) {
 8:         Sendto(sockfd, sendlin, strlen(sendline), 0, pservaddr, servlen);
 9: 
10:         n = Recvfrom(sockfd, recvline, MAXLINE, 0, NULL, NULL);
11: 
12:         recvline[n] = 0;   /* null terminate */
13:         Fputs(recvline, stdout);
14:     }
15: }