【Linux】socket

socket套接字是一种网络IPC，既可以在计算机内通信，也可以在计算机间通信。socket接口可以采用许多不同的网络通信协议，如常见的TCP/IP协议。

1、socket描述符

类似于文件描述符，访问socket也有对应的socket描述符。要创建一个套接字，调用socket函数：

#include <sys/socket.h> 
int socket(int domain, int type, int protocol);

socket函数成功时返回socket描述符，失败则返回-1。参数domain，即域，指通信的特性，包括地址格式。各个域有自己的格式表示地址，而表示各个域的常数都以“AF_”开头，意思是地址族，代表英文单词Address Family。在Linux上，通过man查得有如下域：

Name            Purpose                                 Man page 
AF_UNIX, AF_LOCAL     Local communication           unix(7) 
AF_INET             IPv4 Internet protocols     ip(7) 
AF_INET6            IPv6 Internet protocols     ipv6(7) 
AF_IPX          IPX - Novell protocols 
AF_NETLINK      Kernel user interface device        netlink(7) 
AF_X25          ITU-T X.25 / ISO-8208 protocol      x25(7) 
AF_AX25         Amateur radio AX.25 protocol 
AF_ATMPVC       Access to raw ATM PVCs 
AF_APPLETALK        Appletalk                               ddp(7) 
AF_PACKET           Low level packet interface          packet(7) 

POSIX.1还包括AF_UNSPEC，可以代表任何域。参数type确定套接字的类型，进一步确定通信特征。通过man查得有如下类型：

SOCK_STREAM：Provides sequenced, reliable, two-way, connection-based  byte  streams.   An out-of-band data transmission mechanism may be supported. 有序、可靠、双向的面向连接字节流，应用程序意识不到报文边界。
SOCK_DGRAM ：Supports  datagrams  (connectionless, unreliable messages of a fixed maximum length). 长度固定的、无连接的不可靠报文传递。
SOCK_SEQPACKET ：Provides a sequenced, reliable, two-way connection-based  data  transmission path  for  datagrams of fixed maximum length; a consumer is required to read an entire packet with each input system call. 长度固定、有序、可靠的面向连接报文传递。
SOCK_RAW：Provides raw network protocol access. IP协议的数据包接口，应用程序负责构造自己的协议首部，由于绕过了传输协议如TCP和UDP等，创建一个原始套接字时需要超级用户权限，用以防止恶意程序绕过内建安全机制来创建报文。
SOCK_RDM：Provides a reliable datagram layer that does not guarantee ordering. 
SOCK_PACKET：Obsolete and should not be used in new programs; see packet(7). 
SOCK_NONBLOCK：Set the O_NONBLOCK file status flag on the new open file description.  Using this flag saves extra calls to fcntl(2) to achieve the same result. 
SOCK_CLOEXEC：Set the close-on-exec (FD_CLOEXEC) flag on the new file descriptor.  See the description  of  the  O_CLOEXEC  flag in open(2) for reasons why this may be useful. 

参数protocol通常是零，表示按给定的域和套接字类型选择默认协议。当对同一域和套接字类型支持多个协议时，可以使用protocol参数选择一个特性协议。在AF_INET通信域中套接字类型SOCK_STREAM的默认协议是TCP传输控制协议， 在AF_INET通信域中套接字类型 SOCK_DGRAM的默认协议是UDP用户数据报协议。

对于数据报接口，与对方通信时是不需要逻辑连接的，只需要送出一个报文，其地址是一个对方进程所使用的套接字，因此数据报提供了一个无连接的服务。而字节流要求在交换之前，在本地套接字和与之通信的远程套接字之间建立一个逻辑连接。数据报是一种自包含报文，发送数据报近似于给某人邮寄邮件，可以邮寄很多信，但不能保证投递的次序，并且可能有些信件丢失在路上，每封信件包含接收者的地址，使这封信件独立于所有其它信件，每封信件可能送达不同的接收者。相比之下，使用面向连接的协议通信就像与对方打电话，首先需要通过电话建立一个连接，连接建立好之后，彼此能双向通信，每个连接是端到端的通信通道，会话中不包含地址信息，就像呼叫的两端存在一个点对点虚拟连接，并且连接本身暗含特定的源和目的地。

适用于文件描述符的一些函数同样适用于socket描述符，如read和write等。套接字通信是双向的，可以采用shutdown函数来禁止套接字上的输入、输出，函数如下：

#include <sys/socket.h> 
int shutdown(int sockfd, int how);

参数how可以是SHUT_RD、SHUT_WR、SHUT_RDWR，分别表示关闭读、写、读写。

2、大小端字节序

字节序是一个处理器架构特性，用于指示像整数这样的大数据类型的内部字节顺序。如果处理器架构支持大端（big-endian）字节序，那么最大字节地址对应于数字最低有效字节（LSB），小端（small-endian）字节序则相反，数字最低字节对应于最小字节地址。注意不管字节如何排序，数字最高位总是在左边，最低位总是在右边。

运行在同一台计算机上的进程相互通信时，一般不用考虑字节序。网络协议指定了字节序，因此异构计算机系统能够交换协议信息而不会混淆字节序。TCP/IP协议采用大端字节序，应用程序交换格式化数据时，字节序可能就会出问题，所以需要在处理器和网络之间进行字节序转换，下面是四个转换函数：

#include <arpa/inet.h> 
uint32_t htonl(uint32_t hostlong); 
uint16_t htons(uint16_t hostshort); 
uint32_t ntohl(uint32_t netlong); 
uint16_t ntohs(uint16_t netshort); 

上面函数中，h表示主机host，n表示网络net，l表示长整型long，s表示短整型short。

3、套接字地址格式

地址标识了特定通信域中的套接字特点，地址格式与特定的通信域相关。为使不同格式地址能够被传入到套接字函数，地址被强制转换成通用的地址结构sockaddr表示：

struct sockaddr {
        sa_family_t sa_family;    /* address family */
        char sa_data[];    /* variable-length address */
        ... 
}

sockaddr中， sa_data长度是可变的，在Linux中为14，还可以自由地添加额外的成员。“netinet/in.h”头文件中定义了IPv4因特网域AF_INET的套接字地址结构sockaddr_in：

struct in_addr {
        in_addr_t s_addr;    /* IPv4 address */
}

struct sockaddr_in {
        sa_family_t sin_family;    /* address family */
        in_port_t sin_port;    /* port number */
        struct in_addr sin_addr;    /* IPv4 address */
}

如上sockaddr_in结构是SUS规定的，此外，每个实现可以自由地添加额外的字段。在Linux下， sockaddr_in定义如下：

struct sockaddr_in {
        sa_family_t sin_family;    /* address family */
        in_port_t sin_port;    /* port number */
        struct in_addr sin_addr;    /* IPv4 address */
        unsigned char sin_zero[8];    /* filter */
}

sin_zero为填充字段，必须全部被置为0。有时候需打印出能被人所理解的地址格式，如函数inet_addr和inet_ntoa，用于在二进制地址格式与点分十进制字符串表示之间相互转换，但它们仅用于IPv4，功能相似的两个函数inet_ntop和inet_pton则支持IPv4和IPv6。

#include <arpa/inet.h> 
const char *inet_ntop(int af, const void *src, char *dst, socklen_t size);
int inet_pton(int af, const char *src, void *dst);

n表示网络字节序的二进制地址，p表示文本字符串格式（点分十进制字符串）。参数af为AF_INET或AF_INET6，为AF_INET时缓冲区dst需要有足够大的空间来存放32位地址，为AF_INET6时缓冲区dst需要有足够大的空间来存放128位地址，参数size指定了用以保存文本字符串的缓冲区dst的大小，为了简化工作，INET_ADDRSTRLEN定义了足够大的空间来存放表示IPv4地址的文本字符串，INET6_ADDRSTRLEN定义了足够大的空间来存放表示IPv6地址的文本字符串。

4、socket地址查询

理想情况下，应用程序不需要了解套接字地址的内部结构，如果应用程序只是简单地传递类似于sockaddr结构的套接字地址，并且不依赖与任何协议相关的特性，那么可以与提供相同服务的许多不多协议协作。计算机网络配置信息可能存放在许多地方，如“/etc/hosts”、“/etc/services”等，无论这些信息放在何处，调用相关函数都能够访问它们。通过调用gethostent函数，便可以找到给定计算机的主机信息。

 #include <netdb.h>
struct hostent *gethostbyname(const char *name);
#include <sys/socket.h>
struct hostent *gethostbyaddr(const void *addr, socklen_t len, int type);
struct hostent *gethostent(void);
void sethostent(int stayopen);
void endhostent(void);

struct hostent { 
    char  *h_name;            /* official name of host */ 
    char **h_aliases;         /* alias list */ 
    int    h_addrtype;        /* host address type */ 
    int    h_length;          /* length of address */ 
    char **h_addr_list;       /* list of addresses */ 
} 

如果主机数据文件没有打开，gethostent会打开它，返回文件的下一个条目，返回类型为指向hostent结构的指针，该结构可能包含一个静态的数据缓冲区，每次调用都会覆盖这个缓冲区，返回的地址采用网络字节序。sethostent会打开文件，如果文件已经被打开，那么将其回绕。函数endhostent将关闭文件。除了上面提到的几个函数，还有gethostbyname和gethostbyaddr有类似的功能，不过它们可能是被认为过时的。如下几个函数可以获得网路名字和网路号，网络号按照网络字节序返回。

#include <netdb.h> 
struct netent *getnetent(void); 
struct netent *getnetbyname(const char *name); 
struct netent *getnetbyaddr(uint32_t net, int type); 
void setnetent(int stayopen); 
void endnetent(void);

struct netent { 
    char      *n_name;     /* official network name */ 
    char     **n_aliases;  /* alias list */ 
    int        n_addrtype; /* net address type */ 
    uint32_t   n_net;      /* network number */ 
}

另外，协议名字和协议号可以采用如下函数映射：

#include <netdb.h> 
struct protoent *getprotoent(void); 
struct protoent *getprotobyname(const char *name); 
 struct protoent *getprotobynumber(int proto); 
void setprotoent(int stayopen); 
void endprotoent(void); 

struct protoent { 
    char  *p_name;       /* official protocol name */ 
    char **p_aliases;    /* alias list */ 
    int    p_proto;      /* protocol number */ 
}

服务是由地址的端口号部分表示的，每个服务由一个唯一的、熟知的端口号来提供。采用函数getservbyname可以将一个服务名字映射到一个端口号，函数getservbyport将一个端口号映射到一个服务名，或者采用函数getservent顺序扫描服务数据库。

#include <netdb.h> 
struct servent *getservent(void); 
struct servent *getservbyname(const char *name, const char *proto); 
struct servent *getservbyport(int port, const char *proto); 
void setservent(int stayopen); 
void endservent(void);

struct servent { 
    char  *s_name;       /* official service name */ 
    char **s_aliases;    /* alias list */ 
    int    s_port;       /* port number */ 
    char  *s_proto;      /* protocol to use */ 
}

函数getaddrinfo允许将一个主机名字和服务名字映射到一个地址：

#include <netdb.h> 
int getaddrinfo(const char *node, const char *service, 
        const struct addrinfo *hints, 
        struct addrinfo **res); 
void freeaddrinfo(struct addrinfo *res); 

const char *gai_strerror(int errcode);

struct addrinfo { 
    int              ai_flags; 
    int              ai_family; 
    int              ai_socktype; 
    int              ai_protocol; 
    socklen_t        ai_addrlen; 
    struct sockaddr *ai_addr; 
    char            *ai_canonname; 
    struct addrinfo *ai_next; 
}; 

freeaddrinfo用来释放一个或多个addrinfo结构，出错时不能使用perror函数或者strerror函数来生成错误消息，要用上面的gai_strerror函数。

函数getnameinfo则将地址转换成主机名或者服务名：

#include <sys/socket.h> 
#include <netdb.h> 
int getnameinfo(const struct sockaddr *sa, socklen_t salen, 
        char *host, size_t hostlen, 
        char *serv, size_t servlen, int flags);

5、绑定套接字与地址

绑定地址到套接字使用函数bind：

 #include <sys/socket.h> 
int bind(int sockfd, const struct sockaddr *addr, 
        socklen_t addrlen); 

在进程所运行的机器上，指定的地址必须有效，不能指定一个其它及其的地址。地址必须和创建套接字时的地址族所支持的格式相匹配。端口号必须不小于1024，除非该进程具有相应的特权。一般只有套接字端点能够与地址绑定，尽管有些协议允许多重绑定。调用函数getsockname可以发现绑定到一个套接字的地址，如果套接字已经和对方连接，则调用getpeername函数。

#include <sys/socket.h> 
int getsockname(int sockfd, struct sockaddr *addr, socklen_t *addrlen);
int getpeername(int sockfd, struct sockaddr *addr, socklen_t *addrlen);

6、建立连接

如果处理的是面向连接的网络服务，如SOCK_STREAM，在开始交换数据以前，需要在客户端和服务器之间建立一个连接，调用connect函数。

#include <sys/socket.h> 
int connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen); 

在connect中所指定的地址是想与之通信的服务器地址，如果sockfd没有绑定到一个地址，connect会给调用者绑定到一个默认地址。connect时有可能失败，下面的例子使用了指数补偿算法进行连接。

#include <stdio.h> 
#include <sys/socket.h> 

#define MAXSLEEP 128 

int connect_retry(int sockfd, const struct sockaddr *addr, socklen_t alen) 
{ 
    int nsec; 
    for (nsec = 1; nsec <= MAXSLEEP; nsec <<= 1) { 
        if (0 == connect(sockfd, addr, alen)) { 
            return 0; 
        } 
        if (nsec <= MAXSLEEP / 2) { 
            sleep(nsec); 
        } 
    } 
    return -1; 
}

客户端connect成功后，服务器调用listen开始监听，宣告可以接受连接请求。

#include <sys/socket.h> 
int listen(int sockfd, int backlog); 

参数backlog表示同时可接受的最大请求数量，这个值有上限，依据系统而定。如果请求队列已满，系统会拒绝多余连接请求。一旦服务器listen成功，套接字就能接收连接请求，使用accept函数获得连接请求并建立连接。

#include <sys/socket.h> 
int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen); 

accept失败返回-1，成功返回套接字描述符，该描述符连接到调用connect的客户端，并且和原始套接字，即accept参数sockfd具有相同的套接字类型和地址族。原始套接字没有关联到这个连接，而是继续保持可用状态并接受其它连接请求。accept是个阻塞函数，如果服务器调用accept并且当前没有连接请求，服务器会阻塞直到一个请求到来。如果sockfd处于非阻塞模式，在没有连接请求等待处理时，accept立即出错返回。

7、数据传输

数据传输有下列几个函数：

#include <sys/socket.h> 
ssize_t send(int sockfd, const void *buf, size_t len, int flags); 
ssize_t sendto(int sockfd, const void *buf, size_t len, int flags, 
        const struct sockaddr *dest_addr, socklen_t addrlen); 
ssize_t sendmsg(int sockfd, const struct msghdr *msg, int flags);

ssize_t recv(int sockfd, void *buf, size_t len, int flags); 
ssize_t recvfrom(int sockfd, void *buf, size_t len, int flags, 
        struct sockaddr *src_addr, socklen_t *addrlen); 
ssize_t recvmsg(int sockfd, struct msghdr *msg, int flags); 

struct msghdr {
               void         *msg_name;       /* optional address */
               socklen_t     msg_namelen;    /* size of address */
               struct iovec *msg_iov;        /* scatter/gather array */
               size_t        msg_iovlen;     /* # elements in msg_iov */
               void         *msg_control;    /* ancillary data, see below */
               size_t        msg_controllen; /* ancillary data buffer len */
               int           msg_flags;      /* flags (unused) */
};

send和recv用于面向连接的套接字，sendto和recvfrom用于无连接的套接字，sendmsg和recvmsg用来指定多重缓冲区传输数据。上面函数的flags参数有以下几个选项：

MSG_OOB：如果协议支持，接收带外数据。
MSG_PEEK：返回报文内容而不真正取走报文。
MSG_TRUNC：即使报文被截断，要求返回的是报文的实际长度。
MSG_WAITALL：等待直到所有的数据可用，仅SOCK_STREAM。
MSG_CTRUNC：控制数据被截断。
MSG_DONTWAIT：recvmsg处于非阻塞模式。
MSG_EOR：接收到记录结束符。

通常，recv函数没有数据可用时会阻塞等待，当套接字输出队列没有足够空间来发送消息是send函数也会阻塞，但是在套接字非阻塞模式下，函数不会阻塞而是立即失败返回。通过两个步骤来使用异步IO：建立套接字拥有者关系，信号（SIGIO）可以被发送到合适的进程；通知套接字当IO操作不会阻塞时发信号告知。第一个步骤有三种方式：在fcntl中使用F_SETOWN命令；在ioctl中使用FIOSETOWN命令；在ioctl中使用FIOCSPGRP命令。第二个步骤有两种方式：在fcntl中使用F_SETFL命令并且设置O_ASYNC标志；在ioctl中使用FIOASYNC命令。

另外，套接字机制还提供了两个套接字选项接口来控制套接字行为，一个接口用来设置选项，另一个接口允许查询一个选项的状态，对应的函数如下。

#include <sys/types.h>
#include <sys/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);

套接字选项的一个应用场景：当服务器终止并尝试立即重启时，因为通常TCP的实现不允许绑定到同一个地址，所以在超时前会连接失败，不过可以使用setsockopt的SO_REUSEADDR选项来绕过这个限制，参数optval设置为一个非零的整数值（如1），表示打开指定的optname选项。

带外数据——

带外数据out-of-band是一些通信协议支持的可选特征，运行更高优先级的数据比普通数据优先传输，即使传输队列已经有数据，带外数据优先传输。TCP支持带外数据，但是UDP不支持。TCP将带外数据称为紧急数据，仅支持一个字节，还有个紧急标记，表示在普通数据流中紧急数据所在的位置。如果采用套接字选项SO_OOBINLINE，那么可以在普通数据中接收紧急数据，为帮助判断是否接收到紧急标记，可以使用函数sockatmark。

8、总结

对于无连接套接字，数据包的到来可能已经没有次序，因此当所有的数据不能放在一个包里时，在应用程序里必须关心包的次序。包的最大尺寸是通信协议的特性。对于无连接套接字，包可能丢失。如果应用程序不能容忍这种丢失，必须使用面向连接的套接字。容忍包丢失意味着两个选择：如果想和对方可靠通信，必须对数据包编号，如果发现包丢失，则要求对方重新传输，如果因延时导致的数据包重复传送，还必须识别这种情况，丢弃重复的包；另外一个选择是通过让用户再次尝试命令来处理错误，但对于复杂程序也不可行。面向连接的套接字缺陷在于需要更多的时间和工作来建立一个连接，而且每次连接需要从操作系统中消耗更多的资源。

面向连接（TCP）的服务器步骤：
（1）创建套接字socket。
（2）把地址绑定到套接字bind。
（3）监听连接listen。
（4）接收客户端的连接accept。
（5）数据传输recv、send。
（6）结束。

面向连接（TCP）的客户端步骤：
（1）创建套接字socket。
（2）连接服务器connect。
（3）数据传输recv、send。
（4）结束。

无连接（UDP）的服务器步骤：
（1）创建套接字socket。
（2）把地址绑定到套接字bind。
（3）数据传输recvfrom、sendto。
（4）结束。

无连接（UDP）的客户端步骤：
（1）创建套接字socket。
（3）数据传输recvfrom、sendto。
（3）结束。

9、例子

下面是一个TCP/IP面向连接的例子，客户端向服务器发送一个字母（没有做输入合法性验证），服务器判断字母大小写，并进行大小写转换，转换结果再发送给客户端，客户端输入数字0时结束，运行客户端时要通过命令行参数指定要连接的服务器IP。

// client
// character convertion between upper and lower

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>

#define SOCKPORT 8000

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

    if (argc != 2) {
        printf("usage: ./client <server_ip>\n");
        return -1;
    }

    if ((sockfd = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
        printf("socket error: %s\n", strerror(errno));
        return -1;
    }

    memset(&servaddr, 0, sizeof(servaddr));
    servaddr.sin_family = AF_INET;
    servaddr.sin_port = htons(SOCKPORT);
    if (inet_pton(AF_INET, argv[1], &servaddr.sin_addr) <= 0) {
        printf("inet_pton error: %s, ip is %s\n", strerror(errno), argv[1]);
        close(sockfd);
        return -1;
    }

    if (connect(sockfd, (struct sockaddr*)&servaddr, sizeof(servaddr)) == -1) {
        printf("connect error: %s\n", strerror(errno));
        close(sockfd);
        return -1;
    }

    while (1) {
        printf("\ninput a character:\n\talphabet - convert between upper and lower\n\tdigit 0 - quit\n");
        printf("\n\tyour characer: ");
        scanf("%c", &sendletter);
        getchar();

        if (strncmp(&sendletter, "0", 1) == 0) {
            printf("quit\n");
            break;
        }

        if (send(sockfd, &sendletter, sizeof(sendletter), 0) == -1) {
            printf("send error: %s\n", strerror(errno));
            break;
        }

        if (recv(sockfd, &recvletter, sizeof(recvletter), 0) == -1) {
            printf("recv error: %s\n", strerror(errno));
            break;
        }

        printf("\tfrom [%c] to [%c]\n", sendletter, recvletter);
    }

    close(sockfd);
    return 0;
}

// server
// character convertion between upper and lower

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>

#define SOCKPORT 8000

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

    if ((sockfd = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
        printf("socket error: %s\n", strerror(errno));
        return -1;
    }

    memset(&servaddr, 0, sizeof(servaddr));
    servaddr.sin_family = AF_INET;
    servaddr.sin_port = htons(SOCKPORT);
    servaddr.sin_addr.s_addr = htonl(INADDR_ANY); // INADDR_ANY native ip

    if (bind(sockfd, (struct sockaddr*)&servaddr, sizeof(servaddr)) == -1) {
        printf("bind error: %s\n",strerror(errno));
        close(sockfd);
        return -1;
    }

    if (listen(sockfd, 1) == -1) {
        printf("listen error: %s\n", strerror(errno));
        close(sockfd);
        return -1;
    }
    printf("===== waiting for client's request =====\n");

    if((clifd = accept(sockfd, (struct sockaddr*)NULL, NULL)) == -1) {
        printf("accept error: %s\n", strerror(errno));
        close(sockfd);
        return -1;
    }

    while (1) {
        if (recv(clifd, &srcletter, sizeof(srcletter), 0) == -1) {
            printf("recv error: %s\n", strerror(errno));
            break;
        }

        if (isupper(srcletter)) {
            desletter = tolower(srcletter);
        }
        else if (islower(srcletter)) {
            desletter = toupper(srcletter);
        }
        printf("recv [%c] send[%c]\n", srcletter, desletter);

        if (send(clifd, &desletter, sizeof(desletter), 0) == -1) {
            printf("send error: %s\n", strerror(errno));
            break;
        }
    }

    close(clifd);
    close(sockfd);
    return 0;
}