Linux中的socket通信——TCP

一、socket通信原理简述

        socket是 一种特殊的IO，完成的是网络中的两个主机上的两个特定进程的通信，我们暂且忽略协议栈和具体的网络传输过程，其原理简单地说就是主机A的x号进程将要通信的数据通过网络发送给主机B上的y号进程，而我们知道在网络中用IP地址可以标识一台主机，在一个机器上，用一个序号（将用以通信的进程序号称为端口号）就可以标识一个进程，所以套接字就由IP+端口号组成，这就是socket通信的原理。

二、基本函数

1、socket函数
int socket(int domain, int type, int protocol);
功能说明：
        调用成功，返回socket文件描述符；失败，返回－1，并设置errno
参数说明：
　　domain指明所使用的协议族，通常为PF_INET，表示TCP/IP协议；
　　type参数指定socket的类型，基本上有三种：数据流套接字、数据报套接字、原始套接字
　　protocol通常赋值”0”。
　　两个网络程序之间的一个网络连接包括五种信息：通信协议、本地协议地址、本地主机端口、远端主机地址和远端协议端口。socket数据结构中包含这五种信息。

2、bind函数
int bind(int sock_fd,struct sockaddr_in *my_addr, int addrlen);
功能说明：
        将套接字和指定的端口相连。成功返回0，否则，返回－1，并置errno.
参数说明：
        sock_fd是调用socket函数返回值,
　　my_addr是一个指向包含有本机IP地址及端口号等信息的sockaddr类型的指针；
　　struct sockaddr_in结构类型是用来保存socket信息的：
　　struct sockaddr_in {
　　short int sin_family;
　　unsigned short int sin_port;
　　struct in_addr sin_addr;
　　unsigned char sin_zero[8];
　　};
addrlen为sockaddr的长度。

3、connect函数
int connect(int sock_fd, struct sockaddr *serv_addr,int addrlen);
功能说明：
        客户端发送服务请求。成功返回0，否则返回－1，并置errno。
参数说明：
        sock_fd 是socket函数返回的socket描述符；
        saddrlen是结构sockaddr_in的长度。

4、listen函数
int listen(int sock_fd， int backlog);
功能说明：
        等待指定的端口的出现客户端连接。调用成功返回0，否则，返回－1，并置errno.
参数说明：
        sock_fd 是socket()函数返回值；
        backlog指定在请求队列中允许的最大请求数

5、accecpt函数
int accept(int sock_fd, struct sockadd_in* addr, int addrlen);
功能说明：
        用于接受客户端的服务请求，成功返回新的套接字描述符，失败返回－1，并置errno。
参数说明：
        sock_fd是被监听的socket描述符，
        addr通常是一个指向sockaddr_in变量的指针，
        addrlen是结构sockaddr_in的长度。

6、write函数
ssize_t write(int fd,const void *buf,size_t nbytes)
功能说明：
        write函数将buf中的nbytes字节内容写入文件描述符fd.成功时返回写的字节数.失败时返回-1. 并设置errno变量.
        在网络程序中,当我们向套接字文件描述符写时有俩种可能：
                1)write的返回值大于0,表示写了部分或者是全部的数据.
                2)返回的值小于0,此时出现了错误.需要根据错误类型来处理.
                如果错误为EINTR表示在写的时候出现了中断错误.
                如果错误为EPIPE表示网络连接出现了问题.

7、read函数
ssize_t read(int fd,void *buf,size_t nbyte)
函数说明：
        read函数是负责从fd中读取内容.当读成功时,read返回实际所读的字节数,如果返回的值是0 表示已经读到文件的结束了,也就是说对端关闭了连接，小于0表示出现了错误.
        如果错误为EINTR说明读是由中断引起的,
        如果错误是ECONNREST表示网络连接出了问题.

8、close函数
int close(sock_fd);
说明:
        当所有的数据操作结束以后，你可以调用close()函数来释放该socket，从而停止在该socket上的任何数据操作，函数运行成功返回0，否则返回-1

三、基本流程

四、实例

server端：

#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/wait.h>
#include <pthread.h>
#include <string.h>
#include <stdlib.h>
#include <netinet/in.h>
#include <arpa/inet.h>

static void Usage(const char* msg)
{
    printf("Usage:%s [local_ip] [local_prot]",msg);
}

int startup(const char* _ip,int _port)
{
    int sock=socket(AF_INET,SOCK_STREAM,0);
    if(sock<0){
        perror("socket");
        exit(2);
    }

    printf("sockt_fd: %d\n",sock);

    struct sockaddr_in local;
    local.sin_family=AF_INET;
    local.sin_port=htons(_port);
    local.sin_addr.s_addr=inet_addr(_ip);

    if(bind(sock,(struct sockaddr*)&local,sizeof(local))<0){
        perror("bind");
        exit(3);
    }

    if(listen(sock,10)<0){
        perror("listen");
        exit(4);
    }
    return sock;
}

void*request(void* arg)
{
    int new_sock=(int)arg;
            char buf[1024];
            while(1){
                ssize_t s=read(new_sock,buf,sizeof(buf)-1);
                if(s>0){
                    buf[s]=0;
                    printf("client echo##   ");
                    write(new_sock,buf,strlen(buf));
                }else if(s==0){
                    printf("client quit");
                    break;
                }else{
                    perror("read");
                    return 5;
                }
            }
            close(new_sock);
            return (void*)0;

}
int main(int argc,char* argv[])
{
    if(argc!=3){
        Usage(argv[0]);
    }

    int listen_sock=startup(argv[1],atoi(argv[2]));

    printf("listen_sock:%d\n",listen_sock);

    while(1){
        struct sockaddr_in client;
        socklen_t len=sizeof(client);

        int new_sock=accept(listen_sock,(struct sockaddr*)&client,&len);

        if(new_sock<0){
            perror("accept");
            continue;
        }

        printf("get a client:[%s:%d]\n",\
                inet_ntoa(client.sin_addr),\
                ntohs(client.sin_port));

    //  线程实现版本
    //  pthread_t id;
    //  pthread_creat(&id,NULL,requst,(void*)new_sock);
    //  pthread_detach(id);



    //  进程实现版本  
        pid_t id=fork();
        if(id<0){
            perror("fork");
            exit(5);
        }else if(id==0){

            if(fork() > 0){
                exit(6);
            }

            char buf[1024];
            while(1){
                ssize_t s=read(new_sock,buf,sizeof(buf)-1);
                if(s>0){
                    buf[s]=0;
                    printf("client echo##   ");
                    write(new_sock,buf,strlen(buf));
                }else if(s==0){
                    printf("client quit");
                    break;
                }else{
                    perror("read");
                    return 5;
                }
            }
        }else{
            close(new_sock);
            waitpid(id,NULL,0);

        }
    }
    return 0;
}

三种服务器模型分析：

1. 单进程服务器
           一个进程只服务一个客户端的请求，并发性太低，但是绝对稳定。
2. 多进程服务器
           每个进程单独处理一个客户端请求，并发性高，但是每个机器能创建的进程数是有限的， 而且进程的创建、执行、切换对撤销系统开销较大，如果进程较多则会造成饥饿现象，使得有的客户端请求不能被处理。
3. 多线程服务器
           每一个线程单独处理一个客户端的请求，而且线程的创建、执行、切换对撤销系统开销小，这种模型是理想的方式。

client端：

#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/wait.h>
#include <string.h>
#include <stdlib.h>
#include <netinet/in.h>
#include <arpa/inet.h>

static void Usage(const char* msg)
{
    printf("Usage:%s [server_ip] [server_prot]",msg);
}

int main(int argc,char* argv[])
{
    if(argc!=3){
        Usage(argv[0]);
    }
    int sock=socket(AF_INET,SOCK_STREAM,0);
    if(sock<0){
        perror("sock");
        return 2;
    }

    struct sockaddr_in server;
    server.sin_family=AF_INET;
    server.sin_port=htons(atoi(argv[2]));
    server.sin_addr.s_addr=inet_addr(argv[1]);
    socklen_t len=sizeof(server);

    if(connect(sock,(struct sockaddr*)&server,len)<0){
        perror("connect");
        return 3;
    }

    char buf[1024];
    while(1){
        printf("Please enter##  ");
        fflush(stdout);
        ssize_t s=read(0,buf,sizeof(buf)-1);
        if(s<0){
            perror("read");
            return 4;
        }else{
            buf[s-1]=0;
            write(sock,buf,strlen(buf));
            ssize_t _s=read(sock,buf,sizeof(buf)-1);
            if(_s<0){
                perror("read");
                return 6;
            }else if(_s==0){
                printf("server quit!\n");
                break;
            }else if(_s>0){
                buf[_s]=0;
                printf("Server say##  %s\n",buf);
            }

        }
    }
    close(sock);
    return 0;
}

运行结果（在一台主机上进行的本地环回测试）：