在我们学习的过程中，对TCP/IP、UDP、Socket编程这些词应该有所了解了。随着网络技术的发展，这些词充斥着我们的耳朵。那么我想介绍一下：

什么是TCP/IP、UDP？
socket在哪里呢？
socket通信是什么呢？
socket接口函数
socket客户端与服务器端编程的具体实现

什么是TCP/IP、UDP？

TCP/IP（Transmission Control Protocol/Internet Protocol）即传输控制协议/网间协议，是一个工业标准的协议集，它是为广域网（WANs）设计的。
UDP（User Data Protocol，用户数据报协议）是与TCP相对应的协议。它是属于TCP/IP协议族中的一种。
这里有一张图，表明了这些协议的关系。TCP/IP协议族包括运输层、网络层、链路层。

socket在哪里呢？

上图我们并没有看到socket的身影，那么它究竟在哪里呢？下图一目了然地告诉了我们

由图可知，socket是应用层与TCP/IP协议族通信的中间软件抽象层。

socket通信是什么呢？

网络层的“ip地址”可以唯一标识网络中的主机，而传输层的“端口”可以唯一标识主机中的应用程序（进程）。这样利用二元组（ip地址，端口）就可以标识网络的进程了，网络中的进程通信就可以利用这个标志与其它进程进行交互。使用TCP/IP协议的应用程序通常采用应用编程接口：UNIX BSD的套接字（socket）和UNIX System V的TLI（已经被淘汰），来实现网络进程之间的通信。就目前而言，几乎所有的应用程序都是采用socket，而现在又是网络时代，网络中进程通信是无处不在，这就是我为什么说“一切皆socket”。
上面我们已经知道网络中的进程是通过socket来通信的，那什么是socket呢？socket起源于Unix，而Unix/Linux基本哲学之一就是“一切皆文件”，都可以用“打开open –> 读写write/read –> 关闭close”模式来操作。我的理解就是Socket就是该模式的一个实现，socket即是一种特殊的文件，一些socket函数就是对其进行的操作（读/写IO、打开、关闭），这些函数我们在后面进行介绍。

网络socket中服务器和客户的通信基本流程如下图

socket接口函数

既然socket是“open—write/read—close”模式的一种实现，那么socket就提供了这些操作对应的函数接口。下面以TCP为例，介绍几个基本的socket接口函数。

一、socket()函数

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

1、函数说明：socket()用于创建一个socket描述符（socket descriptor），它唯一标识一个socket。这个socket描述字跟文件描述字一样，后续的操作都有用到它，把它作为参数，通过它来进行一些读写操作。正如可以给fopen的传入不同参数值，以打开不同的文件。创建socket的时候，也可以指定不同的参数创建不同的socket描述符。

2、参数说明：

注意：并不是上面的type和protocol可以随意组合的，如SOCK_STREAM不可以跟IPPROTO_UDP组合。当protocol为0时，会自动选择type类型对应的默认协议。

当我们调用**socket()**创建一个socket时，返回的socket描述字它存在于协议族（address family，AF_XXX）空间中，但没有一个具体的地址。如果想要给它赋值一个地址，就必须调用bind()函数，否则就当调用connect()、listen()时系统会自动随机分配一个端口。

二、bind()函数

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

1、函数说明：通常服务器在启动的时候都会绑定一个众所周知的地址（如ip地址+端口号），用于提供服务，客户就可以通过它来接连服务器。

2、函数参数：

通常服务器在启动的时候都会绑定一个众所周知的地址（如ip地址+端口号），用于提供服务，客户就可以通过它来接连服务器；而客户端就不用指定，有系统自动分配一个端口号和自身的ip地址组合。这就是为什么通常服务器端在listen之前会调用bind()，而客户端就不会调用，而是在connect()时由系统随机生成一个。

网络字节序与主机字节序
主机字节序就是我们平常说的大端和小端模式：不同的CPU有不同的字节序类型，这些字节序是指整数在内存中保存的顺序，这个叫做主机序。引用标准的Big-Endian和Little-Endian的定义如下：
　　a) Little-Endian就是低位字节排放在内存的低地址端，高位字节排放在内存的高地址端。
　　b) Big-Endian就是高位字节排放在内存的低地址端，低位字节排放在内存的高地址端。
网络字节序：4个字节的32 bit值以下面的次序传输：首先是0～7bit，其次8～15bit，然后16～23bit，最后是24~31bit。这种传输次序称作大端字节序。由于TCP/IP首部中所有的二进制整数在网络中传输时都要求以这种次序，因此它又称作网络字节序。字节序，顾名思义字节的顺序，就是大于一个字节类型的数据在内存中的存放顺序，一个字节的数据没有顺序的问题了。

所以：在将一个地址绑定到socket的时候，请先将主机字节序转换成为网络字节序，而不要假定主机字节序跟网络字节序一样使用的是Big-Endian。由于这个问题曾引发过血案！公司项目代码中由于存在这个问题，导致了很多莫名其妙的问题，所以请谨记对主机字节序不要做任何假定，务必将其转化为网络字节序再赋给socket。

三、listen()、connect()函数

int listen(int sockfd, int backlog);

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

1、函数说明：如果作为一个服务器，在调用socket()、bind()之后就会调用listen()来监听这个socket，如果客户端这时调用connect()发出连接请求，服务器端就会接收到这个请求。

2、参数说明：

listen()

connect()

四、accept()函数

int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen)

1、函数说明：TCP服务器端依次调用socket()、bind()、listen()之后，就会监听指定的socket地址了。TCP客户端依次调用socket()、connect()之后就想TCP服务器发送了一个连接请求。TCP服务器监听到这个请求之后，就会调用accept()函数取接收请求，这个函数默认是一个阻塞函数，这也意味着如果没有客户端连接服务器的话该程序将一直阻塞着不会返回，直到有一个客户端连过来为止。一旦客户端调用connect()函数就会触发服务器的accept()返回，这时整个TCP链接就建立好了。之后就可以开始网络I/O操作了，即类同于普通文件的读写I/O操作。

2、参数说明：

项目代码

1. 服务器端源码

 14 #include <stdio.h>
 15 #include <sys/types.h>
 16 #include <sys/socket.h>
 17 #include <errno.h>
 18 #include <string.h>
 19 #include <unistd.h>
 20 #include <netinet/in.h>
 21 #include <arpa/inet.h>
 22 #include <getopt.h>
 23 #include <stdlib.h>
 24 
 25 #define MSG_STR "Hello Huyuanzhuo  iot studio client\n"
 26 #define BACKLOG 13
 27 
 28 int main(int argc, char **argv)
 29 {
 30     int                 sockfd = -1;
 31     int                 clifd;
 32     struct sockaddr_in  serv_addr;
 33     struct sockaddr_in  cli_addr;
 34     socklen_t           cliaddr_len;
 35     int                 port = 0;
 36     int                 ch;
 37     int                 rv = -1;
 38     int                 on = 1;
 39     char                buf[1024];
 40 
 41     if(argc <2)
 42     {
 43         printf("program usage: %s [Serv_port]\n", argv[0]);
 44         return -1;
 45     }
 46     port = atoi(argv[1]);
 47
 48
 49
 50
 51
 52     {
 53         printf("Create socket failure:%s\n",strerror(errno));
 54         return -1;
 55     }
 56     printf("Create socket successfully: %d\n", sockfd);
 57 
 58     //  setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(servaddr));
 59 
 60     memset(&serv_addr,0,sizeof(serv_addr));
 61     serv_addr.sin_family = AF_INET;
 62     serv_addr.sin_port  = htons(port);
 63     serv_addr.sin_addr.s_addr = htonl(INADDR_ANY);
 64 
 65     rv = bind(sockfd,(struct sockaddr *)&serv_addr,sizeof(serv_addr));
 66     if(rv < 0)
 67     {
 68         printf("socket[%d] bind to the port[%d] failure:%s\n",sockfd, port,strerror(errno));
 69         return -2;
 70     }
 71 
 72 
 73     listen(sockfd,BACKLOG);
 74     printf("Start to listen on port [%d]\n", port);
 75     while(1)
 76     {
 77         printf("Start to wait and accept new client...\n");
 78           clifd = accept(sockfd, (struct sockaddr *)&cli_addr, &cliaddr_len);
 79         if(clifd < 0)
 80         {
 81            printf("Accept client failure:%s\n",strerror(errno));
 82            continue;
 83         }
 84 
 85         printf("Accept new client[%s:%d] successfully\n", inet_ntoa(cli_addr.sin_addr), ntohs(cli_addr.sin_port));
 86 
 87         memset(buf, 0, sizeof(buf));
 88 
 89 
 90 
 91         rv=read(clifd, buf, sizeof(buf));
 92         if(rv < 0)
 93         {
 94             printf("Read data from client sockfd[%d] failure:%s\n", clifd,strerror(errno));
 95             close(clifd);
 96             continue;
 97         }
 98 
 99         else if(rv == 0)
100         {
101             printf("socket[%d] get disconnected\n", clifd);
102             close(clifd);
103             continue;
104         }
105 
106 
107         else if(rv > 0)
108         {
109             printf("Read %d data from server:%s\n", rv, buf);
110         }
111 
112 
113         rv = write(clifd, MSG_STR,strlen(MSG_STR));
114         if(rv < 0)
115         {
116             printf("Write to client by sockfd[%d] failure: %s\n", sockfd, strerror(errno));
117             close(clifd);
118             continue;
119         }
120 
121         printf("Close client socket[%d]\n", clifd);
122 
123     }
124      close(sockfd);
125
126    return 0;
127 }
128 

2.客户端源码

 
 14 #include <stdio.h>
 15 #include <sys/types.h>
 16 #include <sys/socket.h>
 17 #include <errno.h>
 18 #include <string.h>
 19 #include <unistd.h>
 20 #include <netinet/in.h>
 21 #include <arpa/inet.h>
 22 #include <getopt.h>
 23 #include <stdlib.h>
 24 
 25 #define MSG_STR "Hello Huyuanzhuo iot studio\n"
 26 
 27 
 28 int main(int argc, char **argv)
 29 {
 30 
 31     int                     sockfd = -1;
 32     struct sockaddr_in      servaddr;
 33     char                    *servip;
 34     int                     port = 0;
 35     int                     ch;
 36     int                     rv = -1;
 37     char                    buf[1024];
 38 
 39     if(argc < 3)
 40     {
 41         printf("program usage: %s[Server_ip] [Port]\n", argv[0]);
 42         return -1;
 43     }
 44 
 45     servip = argv[1];
 46     port = atoi(argv[2]);
 47 
 48 
 49     sockfd = socket(AF_INET, SOCK_STREAM, 0);
 50 
 51     if(sockfd < 0)
 52     {
 53         printf("Create socket failure:%s\n", strerror(errno));
 54         return -1;
 55     }
 56     printf("Create socket successfully: %d\n", sockfd);
 57 
 58 
 59     memset( &servaddr, 0, sizeof(servaddr));
 60     servaddr.sin_family = AF_INET;
 61     servaddr.sin_port = htons(port);
 62     inet_aton(servip, &servaddr.sin_addr);
 63 
 64     rv = connect(sockfd, (struct sockaddr *)&servaddr, sizeof(servaddr));
 65     if(rv < 0)
 66     {
 67         printf("Connect to server [%s:%d] failed:%s\n",servip, port, strerror(errno));
 68         return -2;
 69     }
 70 
 71     printf("Connect to server[%s:%d] successfully\n",servip, port);
 72 
 73 
 74     while(1)
 75     {
 76         rv = write(sockfd, MSG_STR, strlen(MSG_STR));
 77         if(rv < 0)
 78         {
 79             printf("Write to server by sockfd[%d] failure: %s\n", sockfd, strerror(errno));
 80             break;
 81         }
 82 
 83         memset(buf, 0, sizeof(buf));
 84         rv = read(sockfd, buf, sizeof(buf));
 85         if(rv < 0)
 86         {
 87             printf("Read data from server by sockfd[%d] failure: %s\n", sockfd, strerror(errno));
 88             break;
 89         }
 90         else if(rv == 0)
 91         {
 92             printf("socket[%d] get disconnected\n", sockfd);
 93             break;
 94         }
 95 
 96         else if(rv > 0)
 97         {
 98             printf("Read %d bytes data from server: %s\n", rv, buf);
 99             continue;
100 
101         }
102 
103 
104    }
105 
106    close(sockfd);
107 
108 }
109 

运行结果

为了灵活使用不同的ip和端口，我们使用argc和argv传递ip地址和端口号，其中argc是外部输入的参数个数，argv[ ]是参数的字符串数组。我们在gcc编译时就需要按照格式传ip地址和端口号。

首先启动服务器端（等待连接）

再启动客户端请求连接（连接成功，并读取到服务器端的数据）

客户端连接成功连接服务器端（连接成功，并读到客户端数据）

连接完成后继续阻塞，等待下一个客户端地请求连接…