socket编程函数

连接

TCP/IP协议规定网络数据传输应采用大端字节序

• socket地址

struct sockaddr{

unsigned short sa_family;

char sa_data[14];

};

一般不采用上述socket地址，系统兼容性考虑采用sockaddr_in。

#include <netinet/in.h>

typedef uint32_t in_addr_t;

struct in_addr {

in_addr_t s_addr;

};

struct sockaddr_in {

sa_family_t sin_family; //short

in_port_t sin_port; // unsigned short

struct in_addr sin_addr;

};

• socket

sys/socket.h

int socket(int domain, int type, int protocal);

family: AF_INET, AT_INET6, AF_UNIX

AF_UNIX只能用于单一的（unix)进程间通信

AF_INET是针对Internet的，允许在远程主机之间通信

type: SOCK_STREAM(tcp), SOCK_DGRAM(udp)

protocal:协议 0

return：失败-1，成功fd。

• bind

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

bzero(&servaddr, sizeof(servaddr));

servaddr.sin_family = AF_INET;

servaddr.sin_port = htons(SERV_PORT);

servaddr.sin_addr.s_addr = htonl(INADDR_ANY);

INADDR_ANY标识可以和任何的主机通信。

return: 失败-1（设置errno），成功0

• listen

int listen(int sockfd, int backlog);

backlog:最多允许有多上个客户端处于连接等待状态，超过忽略。

return：失败-1，成功0

listen完成后，内核自动完成三次握手，与accept无关。

当有客户端发起链接时，服务器端调用accept()返回并接受这个连接。如果有大量客户端发起连接，服务器来不及处理，尚未accept的客户端就处于连接等待状态。

• accept

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

cliaddr:客户端地址（传出）；

addrlen：传入传出（缓冲区大小，地址大小）

return:失败-1，成功：新的文件描述符。

服务器端调用accept()还没有客户端连接请求时，阻塞等待。

链接关闭时，返回错误码ECONNABORTED，此时应重试连接。

perror("accept()");
if((errno == ECONNABORTED) || (errno == EINTR))
    continue;

• connect

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

servaddr：服务器地址。

return:失败-1；成功0。

客户端port由内核自动分配。

当连接不成功时，应阻塞等待。

出错原因：

1. 指定IP无效。
2. 无服务器进程。
3. 超时Timeout。

慢系统调用accept，read，write被信号中断时应该重试。对于accept，如果errno为ECONNABORTED，也应该重试。

读写数据

#include <unistd.h>

ssize_t read(int fd, void *buf, size_t count);

return:成功，返回读取到的字节数；失败-1。

有数据到达，返回读到的字节数；无数据到达，

• 连接关闭，返回0
• 连接未关闭，阻塞。

sszie_t write(int fd, const void *buf, size_t count);

return:成功，返回写入的字节数；失败-1。

连接关闭，收到SIGPIPE，返回-1。连接未关闭，

• 发生流量控制，阻塞；
• 无流量控制，返回写入字节数。

关闭socket

关闭socket有两个函数close和shutdown。

int shutdown(int sockfd, int howto);

TCP连接是双向的（可读可写），当我们使用close时，会把读写通道都关闭，有时候希望只关闭一个方向，这个时候用shutdown。

howto=0关闭读通道，可以写。

howto=1关别写通道，可以读。

howto=2关闭读写通道，和close一样。

注：shutdown不能代替close，其仅关闭连接，不销毁连接套接字，其后还要close。

多进程程序里，如果有几个进程共享一个socket，如果使用shutdown，那么所有子进程都不能操作了，这个时候只能使用close来关闭子进程的套接子描述符。

总结

总的来说，网络程序是由两个部分组成的--客户端和服务器端。它们建立的步骤一般是：

服务器端

socket-> bind -> listen -> accept

客户端

socket -> connect

注：由于客户端不需要固定端口，因此不必调用bind()。不调用bind(),端口号由内核自动分配。

客户端不是不可以调用bind(),只是没有必要调用bind()固定一个端口号，服务器也不是必须调用bind(),但如果服务器不调用bind(),由内核分配端口号，每次重启服务器时端口号都不一样，客户端连接服务器就会遇到麻烦。

示例

客户端程序读数据，服务器端多进程并发写数据。

每次accept一个新客户端连接就fork出一个子进程专门服务这个客户端。但是子进程退出时会产生僵尸进程，父进程要注意处理SIGCHLD信号和调用wait清理僵尸进程。

// ser.c
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <signal.h>
#include <errno.h>

#define SERV_PORT 10000
#define MAX_CONN 2
#define STR_SND "I love you!"

int main(int argc, char *argv[])
{
    int fd, sfd;
    int ret = ;
    struct sockaddr_in saddr, cliaddr;
    socklen_t slen;

    fd = socket(AF_INET, SOCK_STREAM, );
    if(- == fd){
        fprintf(stderr, "socket error\n");
        exit(EXIT_FAILURE);
    }   

    memset(&saddr, , sizeof(struct sockaddr_in));
    saddr.sin_family = AF_INET;
    saddr.sin_addr.s_addr = htonl(INADDR_ANY);
    saddr.sin_port = htons(SERV_PORT);
    ret = bind(fd, (struct sockaddr *)&saddr, sizeof(struct sockaddr));
    if(- == ret){
        fprintf(stderr, "bind error\n");
        exit(EXIT_FAILURE);
    }

    ret = listen(fd, MAX_CONN);
    if( - == ret){
        fprintf(stderr, "listen error\n");
        exit(EXIT_FAILURE);
    }

    while(){
        slen = sizeof(struct sockaddr);
        sfd = accept(fd, (struct sockaddr*)&cliaddr, &slen);
        if(sfd < ){
            // fprintf(stderr, "accept error\n");
　　　　　　　perror("accept()");
            if((errno == ECONNABORTED) || (errno == EINTR))
　　　　　　　　　　continue;
        }
        signal(SIGCHLD, SIG_IGN);
　　　　 signal(SIGPIPE, SIG_IGN);
        ret = fork();
        if(ret > ){
            printf("connet:%s %d\n", inet_ntoa(cliaddr.sin_addr), ntohs(cliaddr.sin_port));
            while(){
                ret = write(sfd, STR_SND, sizeof(STR_SND));
                //ret = write(sfd, STR_SND, 100);
                if(ret == -){
                    if(errno == EPIPE){
                        close(sfd);
                        printf("client [%s:%d] disconnect\n", inet_ntoa(cliaddr.sin_addr), ntohs(cliaddr.sin_port));
                        exit(EXIT_SUCCESS);
                    }
                }
                sleep();
            }
        } else if(ret < ) {
            perror("fork");
            fprintf(stderr, "fork error\n");
        }
    }

    close(fd);
    return ;
}

// cli.c
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <errno.h>

#define SERV_IP "127.0.0.1"
#define SERV_PORT 10000
#define BSIZE 1024

int main(int argc, char *argv[])
{
    int fd;
    int ret = ;
    struct sockaddr_in saddr;
    char buf[BSIZE];

    fd = socket(AF_INET, SOCK_STREAM, );
    if(- == fd){
        fprintf(stderr, "socket error\n");
        exit(EXIT_FAILURE);
    }
    memset(&saddr, , sizeof(struct sockaddr_in));
    saddr.sin_family = AF_INET;
    inet_pton(AF_INET, SERV_IP, &saddr.sin_addr.s_addr);
    saddr.sin_port = htons(SERV_PORT);
    ret = connect(fd, (struct sockaddr *)&saddr, sizeof(struct sockaddr));
    if( - == ret){
        fprintf(stderr, "connect error\n");
        exit(EXIT_FAILURE);
    }

    while(){
        memset(buf, , sizeof(buf));
        ret = read(fd, buf, sizeof(buf));
        if( ret > ){
            if(buf[ret-] != '\n'){
                buf[ret-] = '\n';
            }
            fprintf(stdout, "%d:%s", ret, buf);
            fflush(stdout);
        } else if(ret == ){ // network disconneted
            fprintf(stderr, "disconnect \n");
            break;
        } else {
            if(errno == EINTR){
                continue;
            }
        }

    }

    close(fd);
    return ;
}

运行结果：

~$gcc ser.c -Wall -o ser
~$gcc cli.c -Wall -o cli
~$./ser
connet:127.0.0.1
connet:127.0.0.1
connet:127.0.0.1
connet:127.0.0.1
connet:127.0.0.1
connet:127.0.0.1
client [127.0.0.1:] disconnect
client [127.0.0.1:] disconnect
client [127.0.0.1:] disconnect
client [127.0.0.1:] disconnect
client [127.0.0.1:] disconnect
client [127.0.0.1:] disconnect
~$./ser
bind error
~$ps aux | grep -w 'ser'
yuxi       0.0  0.0        pts/    S    :   : ./ser
yuxi       0.0  0.0       pts/    S+   :   : grep --color=auto -w ser
~$killall ser
~$ps aux | grep -w 'ser'
yuxi       0.0  0.0       pts/    S+   :   : grep --color=auto -w ser

"bind error"是因为父进程一直在监听，没有退出。

从上述示例也可以看出，判断网络断开的方法：read返回sockfd，返回0；write返回-1，errno为EPIPE。

注：SIGPIPE默认动作为程序退出，一旦收到SIGPIPE信号程序就退出，从而无法判断errno，故设置signal(SIGPIPE, SIG_IGN);

可参考：

1. linux网络编程之socket（四）：使用fork并发处理多个client的请求和对等通信p2p