UNP函数笔记一: 套接字编程简介

第三章  套接字编程简介:

struct in_addr {
    in_addr_t  s_addr;
};

struct sockaddr_in {
    uint8_t         sin_len;
    sa_family_t     sin_family;
    in_port_t       sin_port;
    struct in_addr  sin_addr;
    char            sin_zero[8];
};

struct sockaddr {
    uint8_t      sa_len;
    sa_family_t  sa_family;
    char         sa_data[14];
};

struct in6_addr {
    uint8_t  s6_addr[16];
};

#define SIN6_LEN

struct sockaddr_in6 {
    uint8_t          sin6_len;
    sa_family_t      sin6_family;
    in_port_t        sin6_port;
    uint32_t         sin6_flowinfo;
    struct in6_addr  sin6_addr;
    uint32_t         sin6_scope_id;
};

struct sockaddr_storage {
    uint8_t      ss_len;
    sa_family_t  ss_family;
    ...
};

#include <netinet/in.h>
uint16_t htons(uint16_t host16bitvalue);
uint32_t htonl(uint32_t host32bitvalue);
uint16_t ntohs(uint16_t net16bitvalue);
uint32_t ntohl(uint32_t net32bitvalue);

#include <strings.h>
void bzero(void * dest, size_t nbytes);
void bcopy(const void * src, void * dest, size_t nbytes);
int bcmp(const void * ptr1, const void * ptr2, size_t nbytes);

#include <string.h>
void * memset(void * dest, int c, size_t len);
void * memcpy(void * dest, const void * src, size_t nbytes);
int memcmp(const void * ptr1, const void * ptr2, size_t nbytes);

#include <arpa/inet.h>
int inet_aton(const char * strptr, struct in_addr * addrptr);
    success return 1, error return 0
in_addr_t inet_addr(const char * strptr);
    success return net-order-ipv4-addr, error return INADDR_NONE(~0)
char * inet_ntoa(struct in_addr inaddr);

#include <arpa/inet.h>
int inet_pton(int family, const char * strptr, void * addrptr);
    success return 1, invalid strptr return 0, error return -1
const char * inet_ntop(int family, const void * addrptr, 
                       char * strptr, size_t len);
    #define INET_ADDRSTRLEN    16
    #define INET6_ADDRSTRLEN   46

示例:

#include <stdio.h>
#include <stdlib.h>

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

    un.s = 0x0102;
    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));
    }

    exit(0);
}

#include <errno.h>
#include <string.h>
#include <netinet/in.h>

int 
inet_pton(int family, const char *strptr, void *addrptr)
{
    if (family == AF_INET) {
        struct in_addr  in_val;

        if (inet_aton(strptr, &in_val)) {
            memcpy(addrptr, &in_val, sizeof(struct in_addr));
            return(1);
        }
        return(0);
    }
    errno = EAFNOSUPPORT;
    return(-1);
}

#include <errno.h>
#include <stdio.h>
#include <string.h>
#include <netinet/in.h>

const char * 
inet_ntop(int family, const void * addrptr, char * strptr, size_t len)
{
    const u_char * p = (const u_char *) addrptr;

    if (family == AF_INET) {
        char  temp[INET_ADDRSTRLEN];

        snprintf(temp, sizeof(temp), "%d.%d.%d.%d",
                 p[0], p[1], p[2], p[3]);
        if (strlen(temp) >= len) {
            errno = ENOSPC;
            return(NULL);
        }
        strcpy(strptr, temp);
        return(strptr);
    }
    errno = EAFNOSUPPORT;
    return(NULL);
}

#include <stdio.h>
#include <string.h>
#include <arpa/inet.h>

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

    return (NULL);
}

#include <fcntl.h>
#include <errno.h>

ssize_t 
readn(int fd, void * vptr, size_t n)
{
    size_t    nleft;
    ssize_t   nread;
    char    * ptr;

    ptr = vptr;
    nleft = n;
    while (nleft > 0) {
        if ((nread = read(fd, ptr, nleft)) < 0) {
            if (errno == EINTR) {
                nread = 0;
            }
            else {
                return(-1);
            }
        }
        else if (nread == 0) {
            break;
        }

        nleft -= nread;
        ptr   += nread;
    }
    return(n - nleft);
}

#include <fcntl.h>
#include <errno.h>

ssize_t	
writen(int fd, const void * vptr, size_t n)
{
    size_t       nleft;
    ssize_t      nwritten;
    const char * ptr;

    ptr = vptr;
    nleft = n;
    while (nleft > 0) {
        if ((nwritten = write(fd, ptr, nleft)) <= 0) {
            if (nwritten < 0 && errno == EINTR)
                nwritten = 0;
            else
                return(-1);
        }

        nleft -= nwritten;
        ptr   += nwritten;
    }
    return(n);
}

#include <fcntl.h>
#include <errno.h>

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

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

    *ptr = 0;
    return(n);
}

#include <fcntl.h>
#include <errno.h>

#define MAXLINE  1024

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;
    ssize_t   rc;
    char      c;
    char    * 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_cnt) {
        *vptrptr = read_ptr;
    }
    return(read_cnt);
}