网络套接字编程基本api

   网络层的IP可以惟一标识网络中的主机，而传输层的协议、端口这两个东西可以表示主机中的进程（也就是网络应用程序）。

因此，通过IP、协议、端口号，可以标识网络的进程。

 

先说服务器这边吧

（1）服务器根据地址的类型（属于ipv4还是ipv6等）、socket类型（比如TCP、UDP）去创建socket，创建出的套接字socket本质上也是个文件描述符。

（2）服务器绑定IP地址和端口号到套接字socket

（3）服务器socket监听端口号请求，随时准备接收客户端发来的连接，但这个时候服务器的socket并没有被打开。

（4）根据地址的类型（属于ipv4还是ipv6等）、socket类型（比如TCP、UDP）去创建socket，创建出的套接字socket本质上也是个文件描述符。

（5）客户端根据服务器的ip地址和端口号，试图连接服务器

（6）服务器socket接收到客户端的socket请求，被动打开，开始接收客户端的请求，并等待客户端返回连接信息。这个阶段，服务器的accept方法是阻塞的，即等到刚才试图连接的客户端返回连接信息，accept方法才能返回，才能继续接收下一个最新的客户端连接请求。

（7）客户端连接成功，向服务器发送连接状态信息

（8）服务器accept方法返回，连接成功

（9）客户端发送消息

（10）服务端接收消息

（11）客户端关闭

（12）服务端关闭

 

顺便说一下：（5）（6）（7）（8）是不是就是三次握手了，呵呵。

1.socket函数

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

       #include <sys/socket.h>

 

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

 

创建一个套接字(套接字也是文件描述符，但也不是所有的文件操作函数都能用于套接字创建出的文件描述符)。

（1）参数domain

即协议域，也可以说是协议族(family)。

常见的协议族

AF_INET, AF_INET6, AF_LOCAL, AF_ROUTE等。

 

协议族决定了socket的地址类型，在通信中必须采用对应的地址。

 

  domain设置为AF_INET，即表示使用ipv4地址(32位)和端口号（16为）的组合。

domain设置为AF_UNIX，即表示使用一个绝对路径名作为地址

 

（2）参数type

参数type指定了套接字socket类型（比如是tcp类型、还是udp类型等），常用的socket类型有，SOCK_STREAM（对应可靠的面向连接的协议，即对应TCP）、SOCK_DGRAM（面向不连接不可靠的协议，即UDP）、SOCK_RAW、SOCK_PACKET、SOCK_SEQPACKET等等

（3）参数protocol

参数protocol表示的是指定协议，一般设置0，设置为0之后，socket函数会根据设置的type参数自动去选择协议。

常用的协议有，IPPROTO_TCP、IPPTOTO_UDP、IPPROTO_SCTP、IPPROTO_TIPC等，它们分别对应TCP传输协议、UDP传输协议、STCP传输协议、TIPC传输协议

 

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

 

    如果调用成功，返回创建的套接字描述符，如果失败，则linux下返回-1。

套接字描述符是一个整型值，每个进程的进程空间里都有一个套接字描述符表，该表中存放者新创建的套接字描述符和套接字数据结构的对应关系（关系就放在表中，表中对于某一行或一项来说，其中一个字段是描述符，另外一个字段存放套接字数据结构的地址）。每个进程都有自己的进程空间，他们的套接字描述符表也放在自己的进程空间，但是套接字数据结构却是放在操作系统的内核缓冲里。

 

2. bind函数

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

       #include <sys/socket.h>

 

       int bind(int sockfd, const struct sockaddr *addr,

socklen_t addrlen);

 

bind函数的主要作用是把ip地址和端口绑到套接字里面。

例如对应AF_INET、AF_INET6就是把一个ipv4或ipv6地址和端口号组合赋给socket。

 

（1）sockfd：也就是刚才通过socket函数创建出的套接字socket描述符，bind()函数的作用是给这个描述符绑定地址和端口。

（2）addr：一个const struct sockaddr *指针，指向要绑定给sockfd的协议地址。这个地址结构根据地址创建socket时的地址协议族的不同而不同，如ipv4对应的是： 

struct sockaddr_in {

    sa_family_t    sin_family; /* address family: AF_INET */

    in_port_t      sin_port;   /* port in network byte order */

    struct  in_addr   sin_addr;   /* internet address */

};

/* Internet address. */

struct   in_addr {

    uint32_t       s_addr;     /* address in network byte order */

};

ipv6对应的是： 

struct sockaddr_in6 {

    sa_family_t     sin6_family;   /* AF_INET6 */

    in_port_t       sin6_port;     /* port number */

    uint32_t        sin6_flowinfo; /* IPv6 flow information */

    struct in6_addr sin6_addr;     /* IPv6 address */

    uint32_t        sin6_scope_id; /* Scope ID (new in 2.4) */

};

struct in6_addr {

    unsigned char   s6_addr[16];   /* IPv6 address */

};

 

Unix域对应的是： 

#define UNIX_PATH_MAX    108

struct sockaddr_un {

    sa_family_t sun_family;               /* AF_UNIX */

    char        sun_path[UNIX_PATH_MAX];  /* pathname */

};

 

（3）addrlen：const struct sockaddr 结构体的长度。

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

（4）网络字节序与主机字节序

 

主机字节序

 

    就是我们平常说的大端和小端模式：不同的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。

 

 

3. listen 和 connect

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

 

       #include <sys/socket.h>

 

       int listen(int sockfd, int backlog);

 

 

       #include <sys/types.h>

       #include <sys/socket.h>

 

       int  connect(int  sockfd,  const  struct sockaddr *serv_addr, socklen_t

       addrlen);

 

   （1） listen函数的第一个参数sockfd即为要监听的socket描述字

   （2） listen第二个参数backlog为相应socket可以排队的准备道来的最大连接个数，这是个全局的参数,默认值为128。listen函数仅应用于type为SOCK_STREAM or SOCK_SEQPACKET的套接字socket。（值得注意的是，系统可能根据syncookies的处理能力会忽视参数backlog）。

 

    socket()函数创建的socket默认是一个主动类型的，listen函数将socket变为被动类型的，等待客户的连接请求。

 

 

connect函数

(1)第一个参数即为客户端的socket描述字

(2)第二参数为服务器的socket地址，第三个参数为socket地址的长度。

客户端通过调用connect函数来建立与TCP服务器的连接。

 

（如果服务器太忙，来不及处理新的连接，connect会失败，errno被设置成超时ETIMEDOUT）

 

 

4. accept

 

accept函数的主要作用是接受一个新的连接，服务器端（有被动接收连接的都是服务端啊，有时候客户端也是服务端。）才会用到。

 

TCP服务器端依次调用socket()、bind()、listen()之后，就会监听指定的socket地址了。   

 

TCP客户端依次调用socket()、connect()之后就向TCP服务器发送了一个连接请求。

 

TCP服务器监听到这个请求之后，就会调用accept()函数取接收请求，这样连接就建立好了。之后就可以开始网络I/O操作了，即类同于普通文件的读写I/O操作。

 

       #include <sys/types.h>

       #include <sys/socket.h>

 

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

           // 返回连接connect_fd

 

（1）参数sockfd

     参数sockfd就是上面解释中的监听套接字，这个套接字用来监听一个端口，当有一个客户端与服务器连接时，它使用这个一个端口号，而此时这个端口号正与这个套接字关联。当然客户端不需要了解这些服务器的监听和接受连接的细节，客户端只需要知道服务器的地址和端口号。

 

（2）参数addr

     addr参数是accept新连接时，得到了客户端地址的信息的结构体，如果对客户端的地址不感兴趣，那么可以把这个值设置为NULL。

 

（3）参数len

     addr的结构的大小的。如果对客户端的地址不感兴趣，那么可以把这个值设置为NULL。

 

如果accept成功返回，则服务器与客户已经正确建立连接了，此时服务器通过accept返回的套接字new_fd来完成与客户的通信。

 

注意：

      accept默认会阻塞进程，直到有一个客户连接建立后返回，它返回的是一个新可用的套接字，这个套接字是连接套接字。

 

此时我们需要区分两种套接字，

       监听套接字: 监听套接字正如accept的参数sockfd，它是监听套接字，在调用listen函数之后，是服务器开始调用socket()函数生成的，称为监听socket描述字(监听套接字)

       连接套接字：一个套接字会从主动连接的套接字变身为一个监听套接字；而accept函数返回的是已连接socket描述字(一个连接套接字)，它代表着一个网络已经存在的点点连接。

        一个服务器通常通常仅仅只创建一个监听socket描述字，它在该服务器的生命周期内一直存在。内核为每个由服务器进程接受的客户连接创建了一个已连接socket描述字，当服务器完成了对某个客户的服务，相应的已连接socket描述字就被关闭。

        自然要问的是：为什么要有两种套接字？原因很简单，如果使用一个描述字的话，那么它的功能太多，使得使用很不直观，同时在内核确实产生了一个这样的新的描述字。

连接套接字socketfd_new 并没有占用新的端口与客户端通信，依然使用的是与监听套接字socketfd一样的端口号

 

 

5.  read()、write()等函数

 

万事具备只欠东风，至此服务器与客户已经建立好连接了。可以调用网络I/O进行读写操作了，即实现了网咯中不同进程之间的通信！网络I/O操作有下面几组：

read()/write()

recv()/send()

readv()/writev()

recvmsg()/sendmsg()

recvfrom()/sendto()

我推荐使用recvmsg()/sendmsg()函数，这两个函数是最通用的I/O函数，实际上可以把上面的其它函数都替换成这两个函数。它们的声明如下：

       #include <unistd.h>        ssize_t read(int fd, void *buf, size_t count);       ssize_t write(int fd, const void *buf, size_t count);        #include <sys/types.h>       #include <sys/socket.h>        ssize_t send(int sockfd, const void *buf, size_t len, int flags);       ssize_t recv(int sockfd, 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 recvfrom(int sockfd, void *buf, size_t len, int flags,                        struct sockaddr *src_addr, socklen_t *addrlen);        ssize_t sendmsg(int sockfd, const struct msghdr *msg, int flags);       ssize_t recvmsg(int sockfd, struct msghdr *msg, int flags);

read函数是负责从fd中读取内容.当读成功时，read返回实际所读的字节数，如果返回的值是0表示已经读到文件的结束了，小于0表示出现了错误。如果错误为EINTR说明读是由中断引起的，如果是ECONNREST表示网络连接出了问题。

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

 

 

 

recv函数

 

recv是面向连接的接收数据的函数。

flags取值有：

0：常规操作，与read()相同

MSG_DONTWAIT:将单个I／O操作设置为非阻塞模式

MSG_OOB:指明发送的是带外信息

MSG_PEEK:可以查看可读的信息，在接收数据后不会将这些数据丢失

MSG_WAITALL:通知内核直到读到请求的数据字节数时，才返回。

 

 

send函数

 

flags取值有：

0： 与write()无异

MSG_DONTROUTE:告诉内核，目标主机在本地网络，不用查路由表

MSG_DONTWAIT:将单个I／O操作设置为非阻塞模式

MSG_OOB:指明发送的是带外信息

 

 

6. close

关闭套接字

       #include <unistd.h>

 

       int close(int fd);

 

close操作只是使相应的socket描述符的引用计数-1，只有当引用计数为0的时候，才会触发TCP客户端向服务器发送终止连接请求。

TCP服务端实例

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>		  /* See NOTES */
#include <sys/socket.h>
#include <netinet/in.h>  
#include <arpa/inet.h>  
#include <netdb.h>  
#include <errno.h>
#include <unistd.h>

extern int errno;

int main()
{
	int domain = AF_INET;
	int type = SOCK_STREAM;
	int protocol = 0;
	int ret  = -1;
	int nListenFd = -1;
	int nNewClientFd = -1;
	short int  port = 2000; 
	struct sockaddr_in addr_in;
	int backlog = 128; // 默认是128
	int len = 0;
	char chBuffer[1024] = {0};
	int flags = 0;
	
	nListenFd = socket( domain,  type,  protocol);
	if(nListenFd < 0)
	{
		printf("\n socket failed ! errno[%d]  err[%s]\n", errno, strerror(errno));
		return -1;
	}

	memset(&addr_in, 0, sizeof(struct sockaddr_in));
	addr_in.sin_family = AF_INET;
	addr_in.sin_port = htons(port);//htons的返回值是16位的网络字节序整型数   htons尾的字母s代表short
	addr_in.sin_addr.s_addr = htonl(INADDR_ANY);

	ret = bind(nListenFd, ( struct sockaddr * )(&addr_in), sizeof(struct sockaddr_in));
    if(ret < 0)
    {
    	printf("\n bind failed ! errno[%d]  err[%s]\n", errno, strerror(errno));
    	close(nListenFd); //避免资源泄漏
		return -1;
	}

    ret = listen(nListenFd, backlog);
    if(ret < 0)
    {
		printf("\n listen failed ! errno[%d]	err[%s]\n", errno, strerror(errno));
		close(nListenFd); //避免资源泄漏
		return -1;
	}

	nNewClientFd = accept(nListenFd, ( struct sockaddr *)NULL, NULL); //阻塞模式
	if(nNewClientFd < 0)
	{
		printf("\n accept failed ! errno[%d]	err[%s]\n", errno, strerror(errno));
		close(nListenFd); //避免资源泄漏
		return -1;
	}
	len = recv(nNewClientFd, chBuffer, sizeof(chBuffer) , flags);//flags为0，阻塞模式
	if(len < 0)
	{
		printf("\n recv failed ! errno[%d]	err[%s]\n", errno, strerror(errno));
		close(nListenFd); //避免资源泄漏
		close(nNewClientFd);
		return -1;
	}

	chBuffer[sizeof(chBuffer) - 1] = 0;

	printf("\n recv[%s]\n" , chBuffer);

	len = send(nNewClientFd, "Welcome", sizeof("Welcome"), flags);
	if(len < 0)
	{
		printf("\n send failed ! errno[%d]	err[%s]\n", errno, strerror(errno));
		close(nListenFd); //避免资源泄漏
		close(nNewClientFd);
		return -1;
	}

	close(nNewClientFd);
	close(nListenFd);

	return 0;
}

TCP客户端实例

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>		  /* See NOTES */
#include <sys/socket.h>
#include <netinet/in.h>  
#include <arpa/inet.h>  
#include <netdb.h>  
#include <errno.h>
#include <unistd.h>

extern int errno;

int main()
{
	int domain = AF_INET;//AF_INET
	int type = SOCK_STREAM;
	int protocol = 0;
	int ret  = -1;
	int nClientFd = -1;
	short int  port = 2000; 
	struct sockaddr_in addr_in;
	int len = 0;
	char chBuffer[1024] = {0};
	int flags = 0;
	char *pchServerIP = "192.168.1.211";
	
	nClientFd = socket( domain,  type,  protocol);
	if(nClientFd < 0)
	{
		printf("\n socket failed ! errno[%d]  err[%s]\n", errno, strerror(errno));
		return -1;
	}

    memset(&addr_in, 0, sizeof(struct sockaddr_in));
	addr_in.sin_family = AF_INET;
	addr_in.sin_port = htons(port);//htons的返回值是16位的网络字节序整型数   htons尾的字母s代表short
	//addr_in.sin_addr.s_addr = htonl(inet_addr(pchServerIP));//htonl的返回值是16位的网络字节序整型数   htonl尾的字母l代表32位长整型

	addr_in.sin_addr.s_addr = inet_addr(pchServerIP); //htonl(inet_addr(pchServerIP));
	ret = connect(nClientFd, ( struct sockaddr * )(&addr_in), sizeof(struct sockaddr_in));
    if(ret < 0)
    {
    	printf("\n connect failed ! errno[%d]  err[%s]\n", errno, strerror(errno));
    	close(nClientFd); //避免资源泄漏
		return -1;
	}

	len = send(nClientFd, "14.3", sizeof("14.3"), flags);
	if(len < 0)
	{
		printf("\n send failed ! errno[%d]	err[%s]\n", errno, strerror(errno));
		close(nClientFd); //避免资源泄漏
		return -1;
	}
    len = recv(nClientFd, chBuffer, sizeof(chBuffer) , flags);//flags为0，阻塞模式
	if(len < 0)
	{
		printf("\n recv failed ! errno[%d]	err[%s]\n", errno, strerror(errno));
		close(nClientFd); //避免资源泄漏
		return -1;
	}

	chBuffer[sizeof(chBuffer) - 1] = 0;

	printf("\n recv[%s]\n" , chBuffer);

	
	close(nClientFd);

	return 0;
}