TCP网络编程套接字（多进程）

socket（）；

 #include <sys/types.h>          /* See NOTES */
#include <sys/socket.h>

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

socket()打开一个网络通讯端口，如果成功的话，就像open函数一样返回一个文件描述符；

应用程序可以像读写文件一样用read和write在网络上收发数据；

返回-1，代表出错。

对于IPv4 family指定位AF_INET；

对于TCP协议，type参数指定为SOCK_STREAM，代表面向字节流传输协议。

在本博客 UDP网络编程套接字 中提到过一些接口，这里分析一下：

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

服务器程序所监听的网络地址和端口号通常是固定不变的，客户端程序得知服务器程序的地址和端口号就可以向服务器发起连接请求，服务器需要调用bind绑定一个固定的网络地址和端口号；

bind()成功返回0 ，失败-1；

bind()的作用是将参数sockfd 和myaddr绑定在一起，使sockfd这个网络通讯的文件描述符监听myaddr所描述的地址和端口号。

struct sockaddr* 是一个通用的指针类型，myaddr参数实际上可以接受多种协议的sockaddr结构体，而它们的长度却各不相同，所以第三个参数addrlen指定结构体的长度。

对myaddr的初始化：

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

1.将整个结构体清零；

2.设置地址类型为AF_INET;

3.网络地址为INADDR_ANY，这个宏表示本地的任意IP地址，服务器可能有多个网卡，每个网卡可能绑定多个IP地址，这样设置可以在所有的IP地址上监听，知道确定与某个客户端建立了连接时才确定下来到底用哪个IP地址。

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

int accept(int s, struct sockaddr *addr, socklen_t *addrlen);

listen()声明sockfd处于监听状态，并且最多允许有blocklog个客户端处于连接等待状态，如果接收到更多的请求就忽略且设置一般为5；

主要是从底层获取新的连接，成功为0，失败-1.

accept()：把链接从底层拿上来（从监听套接字中拿）成功返回文件描述符。

三次握手完成后，服务器调用accept（）接受连接。

如果服务器调用accept()没有客户端的连接请求，就处于阻塞式等待，

addr是一个传出参数，accept()返回时传出客户端的端口号和地址

addrlen为了避免溢出的问题，传出是客户端地址的结构体的实际长度

以下为多进程的网络程序

//服务器

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


#define MAX 128

void service(int sock,char* ip,int port)
{
    char buf[MAX];
    while(1)
    {
        buf[0] = 0;
       ssize_t s =  read(sock,buf,sizeof(buf)-1);
        if(s > 0)
        {
            buf[s] = 0;
            printf("[%s:%d] say# %s\n",ip,port,buf);
            write(sock,buf,strlen(buf));
        }
        else if(s == 0)
        {
            printf("client [%s:%d] quit\n",ip,port);
            break;
        }
        else
        {
            printf("read error\n");
            break;
        }
    }
}

int statup(char* ip,int port)
{
    int sock = socket(AF_INET,SOCK_STREAM,0);
    if(sock < 0)
    {
        printf("socket error\n");
        exit(2);
    }
    struct sockaddr_in local;
    local.sin_family = AF_INET;
    local.sin_addr.s_addr = inet_addr(ip);
    local.sin_port = htons(port);
    
    if(bind(sock,(struct sockaddr*)&local,sizeof(local)) < 0)
    {
        printf("bind error\n");
        exit(3);
    }
    
    if(listen(sock,5) < 0)
    {
        printf("listen error\n");
        exit(4);
    }
    return sock;
}

// ./tcpServer 127.0.0.1 8080
int main(int argc,char* argv[])
{
    if(argc != 3)
    {
        printf("Usage: %s[ip][port]\n",argv[0]);
        return 1;
    }
    int listen_sock = statup(argv[1],atoi(argv[2]));
    
    struct sockaddr_in peer;

    char ipBuf[24];
    for(;;)
    {
        ipBuf[0] = 0;
        socklen_t len = sizeof(peer);
        int new_sock = accept(listen_sock,(struct sockaddr*)&peer,&len);
        if(new_sock < 0)
        {
            printf("accept error\n");
           continue; 
        }
        inet_ntop(AF_INET,(const char*)&peer.sin_addr,ipBuf,sizeof(ipBuf));
        int port = ntohs(peer.sin_port);
        printf("get a new connet,[%s:%d]\n",ipBuf,port);


        pid_t id = fork();
        if(id == 0)
        {
            //child
            close(listen_sock);
            if(fork() > 0)
            {
                return 0;
            }
            service(new_sock,ipBuf,port);
            close(new_sock);
            return 0;
        }
        else if(id > 0)
        {
            //father
            close(new_sock);
            waitpid(id,NULL,0);
        }
        else
        {
            printf("fork error\n");
            continue;
        }
    }
    
    return 0;
}

//客户端

#include<stdio.h>
#include<sys/types.h>
#include<sys/socket.h>
#include<stdlib.h>
#include<stdlib.h>
#include <arpa/inet.h>
#include<unistd.h>
#include<string.h>


#define MAX 128


// ./tcpClient 127.0.0.1 8080
int main(int argc,char* argv[])
{
    if(argc != 3)
    {
        printf("Usage: %s [ip] [port]\n",argv[0]);
        exit(1);
    }
    int sock = socket(AF_INET,SOCK_STREAM,0);
    if(sock < 0)
    {
        printf("socket error\n");
        exit(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]);
    if(connect(sock,(struct sockaddr*)&server,sizeof(server)) < 0)
    {
        printf("connect error\n");
        exit(3);
    }
   
    char buf[MAX];

    while(1)
    {
        printf("please Enter# ");
        fflush(stdout);
        ssize_t s = read(0,buf,sizeof(buf)-1);
        if(s > 0)
        {
            buf[s-1] = 0;
            if(strcmp("quit",buf) == 0)
            {
                printf("client quit\n");
                break;
            }
            write(sock,buf,strlen(buf));
            s = read(sock,buf,sizeof(buf)-1);
            buf[s] = 0;
            printf("Server Echo %s\n",buf);
        }
        
    }
    close(sock);
    return 0;
}