温故Linux后端编程（五）：SOCKET网络编程

//旧版本就不看了，直接看新版本吧

#include<arpa/inet.h>

int inet_pton(int af,const char *src,void *dst);  //[将“点分十进制” －> “整数”],这个函数转换字符串到网络地址.
//返回值：若成功则为1，若输入不是有效的表达式则为0，若出错则为-1
const char *inet_ntop(int af,const void *src,char *dst,socklen_t size);
//返回值：若成功则为指向结构的指针，若出错则为NULL

//支持ipv4和ipv6
//可重入函数

//参数释义
// af：参数既可以是AF_INET也可以是AF_INET6。
// src：第一个函数尝试转换由src指针所指向的字符串，并通过dst指针存放二进制结果
// inet_ntop进行相反的转换，从数值格式（addrptr）转换到表达式（strptr)。len参数是目标存储单元的大小，以免该函数溢出其调用者的缓冲区。为有助于指定这个大小，在

#define INET_ADDRSTRLEN 16
#define INET6_ADDRSTRLEN 46

//如果len太小，不足以容纳表达式结果，那么返回一个空指针，并置为errno

struct sockaddr
 {
	unsigned short sa_family; /* address族, AF_xxx */
	char sa_data[14]; 	  /* 14 bytes的协议地址 */
};

//   sa_family 一般来说， IPV4使用“AF_INET”。

struct sockaddr_in 
{
	short int sin_family; /* Internet地址族 */
	unsigned short int sin_port; /* 端口号 */
	struct in_addr sin_addr; /* Internet地址 */
	unsigned char sin_zero[8]; /* 添0（和struct sockaddr一样大小）*/
};

//这两个数据类型是等效的，可以相互转换，通常使用sockaddr_in更为方便

//头文件

#include<sys/type.h>
#include<sys/socket.h>

//socket函数：

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

//参数释义：
domain:
AF_INET:用来产生IPV4 - socket 的协议，使用TCP或UDP来传输，用IPV4的地址
AF_INET6:和上面的差不多，这个是IPV6的
AF_UNIX:本地协议，用在Unix和Linux系统上，一般都是服务端和客户端在同一台机器上时使用。

type:
SOCK_STREAM:这个协议是按照顺序的、可靠的、数据完整的基于字节流的连接。这是一个使用最多的socket类型，是用TCP协议来传输的。
SOCK_DGRAM：这个协议是无连接的，固定长度的连接调用。该协议是不可靠的，使用UDP来进行它的连接。
SOCK_SEQPACKET：这个协议是双线路的、可靠的连接，发送固定长度的数据包进行传输。（注（1））必须把整个包完整的接收才能够进行读取。
SOCK_RAW:这个socket类型提供单一的网络访问

protocol:0，默认协议

返回值：
	成功返回一个文件描述符，失败返回-1，设置errno。

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

参数释义：
sockfd：socket文件描述符
addr：构造出IP地址加端口号
addrlen：sizeof(addr)的长度 

struct sockaddr_in servaddr;
bzero(&servaddr,sizeof(servaddr));  //清空servaddr内容
servaddr.sin_family = PF_INET;
servaddr.sin_addr = htonl(INADDR_ANY);  //这个宏表示任意的IP地址
//服务器一般有多个网卡，每个网卡也可能绑定了多个IP地址，这样可以设置在所有IP地址上监听，直到与某个客户端建立连接。
servaddr.sin_port = htons(8000);

int listen(int sockfd,int backlog);

参数释义：
	backlog：排队建立三次握手队列和刚建立三次握手队列的链接数和

cat /proc/sys/net/ipv4/tcp_max_syn_backlog  查看系统默认backlog

listen函数声明sockfd处于监听状态，并且最多允许backlog个客户端处于连接状态，如果多了就忽略。

成功返回0，失败返回-1.

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

参数释义：
	addr：传出参数，返回连接客户地址信息，含IP地址和端口号。
	addrlen：传入addr的大小，返回真正的大小。

返回值：成功返回一个新的sockfd，用于和客户端通信，失败返回-1.

while(1)
{
	cliaddr_len = sizeof(cliaddr);
	connfd = accept(listenfd,(struct sockaddr *)&cliaddr,&cliaddr_len);  //那个强转，历史遗留问题
	n = read(connfd,buf,MAXLINE);
	···
	close(connfd);
}

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

参数释义：
addr:传入参数，指定服务器的地址信息，含IP地址和端口号。

返回值：成功返回0，失败返回-1.

    #include <stdio.h>
    #include <string.h>
    #include <stdlib.h>
    #include <unistd.h>
    #include <arpa/inet.h>
    #include <sys/socket.h>
    #include <netinet/in.h>
    int main(){
        //创建套接字
        int serv_sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
        //将套接字和IP、端口绑定
        struct sockaddr_in serv_addr;
        memset(&serv_addr, 0, sizeof(serv_addr));  //每个字节都用0填充
        serv_addr.sin_family = AF_INET;  //使用IPv4地址
        serv_addr.sin_addr.s_addr = inet_addr("127.0.0.1");  //具体的IP地址
        serv_addr.sin_port = htons(1234);  //端口
        bind(serv_sock, (struct sockaddr*)&serv_addr, sizeof(serv_addr));
        //进入监听状态，等待用户发起请求
        listen(serv_sock, 20);
        //接收客户端请求
        struct sockaddr_in clnt_addr;
        socklen_t clnt_addr_size = sizeof(clnt_addr);
        int clnt_sock = accept(serv_sock, (struct sockaddr*)&clnt_addr, &clnt_addr_size);
        //向客户端发送数据
        char str[] = "hello client!";
        write(clnt_sock, str, sizeof(str));
       
        //关闭套接字
        close(clnt_sock);
        close(serv_sock);
        return 0;
    }

    #include <stdio.h>
    #include <string.h>
    #include <stdlib.h>
    #include <unistd.h>
    #include <arpa/inet.h>
    #include <sys/socket.h>
    int main(){
        //创建套接字
        int sock = socket(AF_INET, SOCK_STREAM, 0);
        //向服务器（特定的IP和端口）发起请求
        struct sockaddr_in serv_addr;
        memset(&serv_addr, 0, sizeof(serv_addr));  //每个字节都用0填充
        serv_addr.sin_family = AF_INET;  //使用IPv4地址
        serv_addr.sin_addr.s_addr = inet_addr("127.0.0.1");  //具体的IP地址
        serv_addr.sin_port = htons(12345);  //端口
        connect(sock, (struct sockaddr*)&serv_addr, sizeof(serv_addr));
       
        //读取服务器传回的数据
        //char buffer[40];
        //read(sock, buffer, sizeof(buffer)-1);
char str[] = "hello server!";
        write(sock, str, sizeof(str));       
        printf("Message to server");
       

       
        //关闭套接字
        close(sock);
        return 0;
    }

#include <sys/types.h>
#include <sys/socket.h>

int getsockopt(int sock, int level, int optname, void *optval, socklen_t *optlen);

int setsockopt(int sock, int level, int optname, const void *optval, socklen_t optlen);

level指定控制套接字的层次.可以取三种值:
1)SOL_SOCKET:通用套接字选项.
2)IPPROTO_IP:IP选项.
3)IPPROTO_TCP:TCP选项

1. closesocket（一般不会立即关闭而经历TIME_WAIT的过程）后想继续重用该socket：
BOOL bReuseaddr=TRUE;
setsockopt (s,SOL_SOCKET ,SO_REUSEADDR,(const char*)&bReuseaddr,sizeof(BOOL));


2. 如果要已经处于连接状态的soket在调用closesocket后强制关闭，不经历
TIME_WAIT的过程：
BOOL bDontLinger = FALSE;
setsockopt (s,SOL_SOCKET,SO_DONTLINGER,(const char*)&bDontLinger,sizeof(BOOL));


3. 在send(),recv()过程中有时由于网络状况等原因，发收不能预期进行,而设置收发时限：
int nNetTimeout=1000;//1秒
//发送时限
setsockopt (socket，SOL_S0CKET,SO_SNDTIMEO，(char *)&nNetTimeout,sizeof(int));
//接收时限
setsockopt (socket，SOL_S0CKET,SO_RCVTIMEO，(char *)&nNetTimeout,sizeof(int));


4. 在send()的时候，返回的是实际发送出去的字节(同步)或发送到socket缓冲区的字节
(异步);系统默认的状态发送和接收一次为8688字节(约为8.5K)；在实际的过程中发送数据
和接收数据量比较大，可以设置socket缓冲区，而避免了send(),recv()不断的循环收发：
// 接收缓冲区
int nRecvBuf=32*1024;//设置为32K
setsockopt (s,SOL_SOCKET,SO_RCVBUF,(const char*)&nRecvBuf,sizeof(int));
//发送缓冲区
int nSendBuf=32*1024;//设置为32K
setsockopt (s,SOL_SOCKET,SO_SNDBUF,(const char*)&nSendBuf,sizeof(int));


5. 如果在发送数据的时，希望不经历由系统缓冲区到socket缓冲区的拷贝而影响
程序的性能：
int nZero=0;
setsockopt (socket，SOL_S0CKET,SO_SNDBUF，(char *)&nZero,sizeof(nZero));


6. 同上在recv()完成上述功能(默认情况是将socket缓冲区的内容拷贝到系统缓冲区)：
int nZero=0;
setsockopt (socket，SOL_S0CKET,SO_RCVBUF，(char *)&nZero,sizeof(int));


7. 一般在发送UDP数据报的时候，希望该socket发送的数据具有广播特性：
BOOL bBroadcast=TRUE;
setsockopt (s,SOL_SOCKET,SO_BROADCAST,(const char*)&bBroadcast,sizeof(BOOL));


8. 在client连接服务器过程中，如果处于非阻塞模式下的socket在connect()的过程中可
以设置connect()延时,直到accpet()被呼叫(本函数设置只有在非阻塞的过程中有显著的
作用，在阻塞的函数调用中作用不大)
BOOL bConditionalAccept=TRUE;
setsockopt (s,SOL_SOCKET,SO_CONDITIONAL_ACCEPT,(const char*)&bConditionalAccept,sizeof(BOOL));


9 . 如果在发送数据的过程中(send()没有完成，还有数据没发送)而调用了closesocket(),以前我们
一般采取的措施是"从容关闭"shutdown(s,SD_BOTH),但是数据是肯定丢失了，如何设置让程序满足具体
应用的要求(即让没发完的数据发送出去后在关闭socket)？
struct linger {
u_short l_onoff;
u_short l_linger;
};
linger m_sLinger;
m_sLinger.l_onoff=1;//(在closesocket()调用,但是还有数据没发送完毕的时候容许逗留)
// 如果m_sLinger.l_onoff=0;则功能和2.)作用相同;
m_sLinger.l_linger=5;//(容许逗留的时间为5秒)
setsockopt (s,SOL_SOCKET,SO_LINGER,(const char*)&m_sLinger,sizeof(linger));

int recv(SOCKET s,char *buf, int len, int flags)；

int send( SOCKET s,char *buf,int len,int flags );

  （i）如果len大于剩余空间大小send就一直等待协议把s的发送缓冲中的数据发送完；

  （ii）如果len小于剩余空间大小send就仅仅把buf中的数据copy到剩余空间里。