#include <netinet/in.h>

typedef uint32_t in_addr_t; //无符号32位整数，IPv4地址
typedef uint16_t in_port_t; //无符号16位整数，TCP或UDP端口
typedef unsigned short sa_family_t; //套接字地址结构的地址族 unsigned short 0~65535字节

struct in_addr{
    in_addr_t s_addr; //s_addr成员存储的是网络字节序的32位IPv4地址
};

struct sockaddr_in{
    uint8_t sin_len; //长度成员，存储套接字地址结构的长度(一般不设置)
    sa_family_t sin_family; //sin_family是Internet地址族，在IPv4中是AF_INET
    in_port_t sin_port; //端口号，以网络字节序存储
    struct in_addr sin_addr; //是一个结构，该结构中的成员存储的才是IP地址
    char sin_zero[8]; //未使用，置0
};

struct sockaddr_in ser;
ser.sin_addr给出的是一个存放地址的结构
ser.sin_addr.s_addr存储的是地址中的内容，也就是IP地址的值

#include <netinet/in.h>
typedef uint16_t in_port_t;
typedef unsigned short sa_family_t;

struct in6_addr{
    uint8_t s6_addr[16];
};

struct sockaddr_in6{
    uint8_t sin6_len; //长度成员
    sa_family_t sin6_family; //Internet地址族，在IPv6中是AF_INET6
    in_port_t sin6_port; //端口号，以网络字节序存储
    uint32_t sin6_flowinfo; //低24位是流量标号，下4位是优先级，再下4位保留
    struct in6_addr sin6_addr; //in6_addr结构中的s6_addr成员，存储的是网络字节序的128位IPv6地址
};

#include <sys/socket.h>
struct sockaddr{
  uint8_t sa_len;
  sa_family_t sa_family;
  char sa_data[14];
};

#include <netinet/in.h>
uint16_t htons(uint16_t hosts);
uint32_t htonl(uint32_t hostl);
uint16_t ntohs(uint16_t nets);
uint32_t ntohl(uint32_t netl);

#include <string.h>
void bzero(void *dest, size_t len); //bzero函数将目标中指定数目的字节置为0，经常用此函数来对套接字地址结构进行初始化
void bcopy(const void *src, void *dest, size_t len); //bcopy函数将指定数目的字节从源拷贝到目标
int bcmp(const void *src, void *dest, size_t len); //bcmp函数比较源和目标两个字符串，若相同返回值为0，否则返回非0值

void *memset(void *dest, int x, size_t len); //将目标指定数目的字节置为值x
void *memcpy(void *dest, const void *src, size_t len); //将指定数目的字节从源拷贝到目标
int memcmp(const void *str1, const void *str2, size_t len); //比较两个字符串，若相同返回值为0，否则返回非0值。如果str1所指字节大于str2所指字节，则返回值大于0，否则返回值小于0

#include <arpa/inet.h>
in_addr_t inet_addr(const char *str); 
int inet_aton(const char *str, struct in_addr *numstr);
char *inet_ntoa(struct in_addr inaddr);

#include <arpa/inet.h>
int inet_pton(int family, const char *str, void *numstr);
const char *inet_ntop(int family, const void *numstr, char *str, size_t len);

#include <sys/stat.h>
int isfdtype(int fd, int fdtype);

struct sockaddr_in ser;
bind(sockfd, (struct sockaddr *)&ser, sizeof(ser));

struct sockaddr_in client;
socklen_t len;
len = sizeof(client);
accept(listenfd, (struct sockaddr *)&client, &len);

#include <sys/socket.h>
int socket(int family, int type, int protocol);

#include <sys/socket.h>
......
int sockfd;
if((sockfd = socket(AF_INET, SOCK_STREAM, 0)) == -1)
{
    //handle exception
    ......
}

#include <sys/socket.h>
int connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen);

#include <sys/socket.h>
......
int socked;
struct sockaddr_in server;
......
bzero(&server, sizeof(server));//为套接字地址结构server设置初始值0
server.sin_family = AF_INET; //为套接字地址结构中的成员赋值
server.sin_port = htons(1234); //为套接字地址结构中的成员赋值，端口号为1234
server.sin_addr.s_addr = inet_addr("127.0.0.1"); //为套接字地址结构中的成员赋值，127.0.0.1是客户端要建立连接的服务器的IP地址
if(connect(sockfd, (struct sockaddr *)&server, sizeof(server) == -1) //调用connect函数，与服务器建立连接，connect函数第二个参数为将IPv4的套接字地址结构强制转换为通用地址结构
{
    //handle exception //如果调用connect函数失败，连接失败的异常处理
    ......
}
......

#include <sys/socket.h>
int bind(int socked. const struct sockaddr *server, socklen_len addrlen);

#include <sys/socket.h>
......
int sockfd;
int port = 1234;//bind的端口号为1234
struct sockaddr_in server;
......
bzero(&server, sizeof(server));
server.sin_family = AF_INET;
server.sin_port = htons(port);
server.sin_addr.s_addr = htonl(INADDR_ANY);//IP地址是一个通配地址，由内核选择IP地址。关于INADDR_ANY见上图
if(bind(sockfd, (struct sockaddr *)&server, sizeof(server) == -1))
{
    //handle exception
    ......
}
......

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

#include <sys/socket.h>
......
int sockfd;
int BACKLOG = 5; //设置监听的最大连接数为5
......
if(listen(sockfd, BACKLOG) == -1) //调用listen函数，将sockfd描述符设置为监听描述符
{
    //handle exception //当listen函数调用失败时的异常处理
    ......
}
......

#include <sys/socket.h>
int accept(int listenfd, struct sockaddr *client, socklen_t *addrlen);

#include <sys/socket.h>
......
int listenfd, connfd; 
//定义了两个套接字描述符，一个是监听套接字描述符，一个是已连接套接字描述符

struct sockaddr_in client;
socklen_t addrlen;
addrlen = sizeof(client); //得到client当前的长度
......
connfd = accept(listenfd, (struct sockaddr *)&client, &addrlen);
//调用accept函数，接收连接请求，返回已连接套接字描述符
//与服务器连接的客户端的协议地址可以通过参数client得到，addrlen返回内核写入client结构体中的准确字节数
if(connfd == -1){
    //handle exception
    ......
}
......

#include <unistd.h>
int write(int sockfd, char *buf, int len);

#include <unistd.h>
int read(int sockfd, char *buf, int len);

#include <unistd.h>
#include <sys/socket.h>
#define MAXDATASIZE 100 //定义接收信息的数据缓冲区的长度
......
int num, connfd;
char buf[MAXDATASIZE];
......
if( (num = read(connfd, buf, MAXDATASIZE)) > 0){ //接收数据，整数num返回接收的字节数
    //handle data //处理收到的数据
    ......
}
......

#include <sys/types.h>
#include <sys/socket.h>
ssize_t send(int sockfd, const void *buf, size_t len, int flags);

#include <sys/types.h>
#include <sys/socket.h>
ssize_t recv(int sockfd, void *buf, size_t len, int flags);

#include <unistd.h>
#include <sys/socket.h>
#define MAXDATASIZE 100
......
int num, connfd;
char buf[MAXDATASIZE];
......

if( (num = recv(connfd, buf, MAXDATASIZE)) > 0){ //接收数据，整数num返回接收的字节数
    //handle data //处理收到的数据
    ......
}
......

#include <stdio.h>
#include <strings.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h> //通用套接字地址结构
#include <netinet/in.h> //IPv4套接字地址结构
#include <arpa/inet.h> //IP地址转换函数
#include <string.h>
#include <stdlib.h>

#define PORT 1234 //客户端与服务器的端口要对应
#define BACKLOG 1//listen函数中的参数，此参数规定了请求队列中的最大连接个数，由于本例不是并发服务器，所以最大允许连接的数量BACKLOG定义为1

main()
{
	int listenfd, connectfd/*已连接套接字描述符*/;
	struct sockaddr_in server;//套接字地址结构
	struct sockaddr_in client;
	socklen_t addrlen; 

	/*Create TCP socket*/
	if ((listenfd=socket(AF_INET, SOCK_STREAM, 0)) == -1) 
	//创建TCP套接字,socket()函数第二个参数为字节流接口。如果出错打印错误信息。
	{
		perror("socket() error.");
		exit(-1);
	}

	int opt = SO_REUSEADDR;
	setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));
	//以上两行设置套接字选项SO_REUSEADDR，即地址重用选项。
	//由于系统默认是只允许一个套接字绑定一个特定的协议地址上，并且当该套接字关闭后，系统仍不允许在该地址上绑定其他套接字。
	//如果去掉这两行，程序运行时产生的错误信息为:"Bind() error:Address already in use"

	bzero(&server, sizeof(server));//初始化server套接字地址结构，初始值为0
	server.sin_family = AF_INET;//为套接字地址结构中的成员赋值
	server.sin_port = htons(PORT);
	server.sin_addr.s_addr = htonl(INADDR_ANY);
	if (bind(listenfd, (struct sockaddr *)&server, sizeof(server)) == -1)
	//调用bind()函数将套接字描述符与server套接字地址结构中的协议地址绑定
	{
		perror("bind() eror");
		exit(1);
	}

	if (listen(listenfd, BACKLOG) == -1) //listen()函数将listenfd描述符设置为监听套接字，等待客户连接
	{
		perror("listen() error.\n");
		exit(1);
	}

	addrlen = sizeof(client);//得到client当前的长度
	if ((connectfd = accept(listenfd, (struct sockaddr *)&client, &addrlen)) == -1)
	//接受客户端连接，将客户的地址信息存放在client地址结构中，&addrlen为内核写入client结构体中的准确字节数
	{
		perror("accept() error\n");
		exit(1);
	}
	printf("You got a connection from client's ip is %s, port is %d\n", inet_ntoa(client.sin_addr), htons(client.sin_port));
	//显示客户的IP地址和端口号，通过inet_ntoa()函数将IP地址转换成可显示的ASCII串，通过htons()函数将端口号转换成网络字节序
	send(connectfd, "Welcome\n",8,0);//发送Welcome字符串给客户端
	close(connectfd);//先关闭已连接套接字，再关闭监听套接字
	close(listenfd);
	return 0;
}

#include <stdio.h>
#include <unistd.h>
#include <strings.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netdb.h>
#include <string.h>
#include <stdlib.h>

#define PORT 1234 //服务器的端口与客户端的端口对等
#define MAXDATASIZE 100 //这里的缓冲区采用静态方式分配

int main(int argc, char *argv[])
{
	int sockfd, num;
	char buf[MAXDATASIZE];
	struct hostent *he;
	struct sockaddr_in server;
	if (argc != 2) //检查用户的输入。如果用户输入不正确，提示用户正确的输入方式
	{
		printf("Usage:%s <IP Address>\n", argv[0]);
		exit(1);
	}

	//通过用户输入的点分十进制形式的IP地址，获得服务器的相关地址信息
	if ((he = gethostbyname(argv[1])) == NULL)
	{
		printf("gethostbyname() error\n");
		exit(1);
	}

	//调用socket()函数产生套接字描述符
	if ((sockfd = socket(AF_INET, SOCK_STREAM, 0)) == -1)
	{
		printf("socket() error\n");
		exit(1);
	}

	//初始化服务器的地址结构，并为地址结构的成员赋值
	bzero(&server, sizeof(server));
	server.sin_family = AF_INET;
	server.sin_port = htons(PORT);
	server.sin_addr = *((struct in_addr *)he->h_addr);

	//调用connect()函数连接到服务器server
	if (connect(sockfd, (struct sockaddr *)&server, sizeof(server)) == -1)
	{
		printf("connect() error\n");
		exit(1);
	}

	//接受服务器发过来的字符串，并保存在buf中。接收的真正字节数被存储在num中
	if ((num = recv(sockfd, buf, MAXDATASIZE,0)) == -1)
	{
		printf("recv() error\n");
		exit(1);
	}
	buf[num-1] = '\0'; //以\0标志字符串的结束
	printf("server message: %s\n", buf);//显示从服务器接收到的buf中的信息
	close(sockfd); //关闭套接字
}

#include <sys/types.h>
#include <sys/socket.h>
ssize_t recvfrom(int sockfd, void *buf, size_t len, int flags, struct sockaddr *from, size_t *addrlen);
//前三个参数分别为:调用socket函数生成的描述符、指向读入缓冲区的指针、读入的字节数
//flags参数是传输控制标志，其值通常为0，代表所做的操作与read相同，还有MSG_OOB, MSG_PEEK
//from返回与之通信的对方的套接字地址结构，告诉用户接收到的数据报来自于谁
//addrlen是一个指向整数值的指针(值-结果参数)，存储数据发送者的套接字地址结构的字节数
//如果from或addrlen两者之一要为空，必须同时设为空

#include <sys/types.h>
#include <sys/socket.h>
#define MAXDATASIZE 100
......
int num, sockfd;
socklen_t addrlen;
sockaddr_in peer_addr;
char buf[MAXDATASIZE];
......
addrlen = sizeof(peer_addr);
while(1)
{
	num = recvfrom(sockfd, buf, MAXDATASIZE, 0, (struct sockaddr *)&peer_addr, &addrlen);
	//用recvfrom函数接收数据，将接收到的数据保存在buf中，整数num返回接收的字节
	//地址结构peer_addr返回发送数据方的协议地址，addrlen返回存储在peer_addr中的字节数
	if (num < 0)
	{
		/*handle exception*/
	}
	/*handle data*/
	......
}
......

#include <sys/types.h>
#include <sys/socket.h>
ssize_t sendto(int sockfd, const void *buf, size_t len, int flags, const struct sockaddr *to, int addrlen);
//前三个参数分别为:调用socket函数生成的描述符、指向发送缓冲区的指针、发送的字节数
//flags参数是传输控制标志，其值通常为0，代表所做的操作与write相同，还有MSG_DONTROUTE，MSG_OOB
//函数sendto的参数to的类型是套接字地址结构，指明数据将发往的协议地址，它的大小由addrlen参数决定

#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <stdlib.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#define PORT 1234 //定义端口号
#define MAXDATASIZE 100 //定义接收缓冲区大小
main()
{
	int sockfd;
	struct sockaddr_in server;
	struct sockaddr_in client;
	socklen_t len;
	int num;
	char buf[MAXDATASIZE];
	/*creating UDP socket*/
	if ((sockfd = socket(AF_INET, SOCK_DGRAM, 0)) == -1)
	{//调用socket函数，产生UDP套接字。如果出错打印错误信息。
		perror("Creating socket failed.");
		exit(1);
	}
	bzero(&server, sizeof(server));//初始化server套接字地址结构，并对地址结构中的成员赋值
	server.sin_family = AF_INET;
	server.sin_port = htons(PORT);
	server.sin_addr.s_addr = htonl(INADDR_ANY);
	if (bind(sockfd, (struct sockaddr *)&server, sizeof(server)) == -1)
	{//将套接字和指定的协议地址绑定
		perror("Bind() error.");
		exit(1);
	}
	len = sizeof(client);
	while(1)
	{
		num = recvfrom(sockfd, buf, MAXDATASIZE, 0, (struct sockaddr *)&client, &len);
		//接收客户端的信息，并存放在buf中，客户端的地址信息存放在client地址结构中。如果成功num返回接收的字符串的长度。
		if (num < 0)
		{
			perror("recvfrom() error\n");
			exit(1);
		}
		buf[num]='\0';
		printf("You got a message <%s> from client.\nIt's ip is %s, port is %d.\n", buf, inet_ntoa(client.sin_addr), htons(client.sin_port));
		//显示接收到的客户信息、客户的IP地址和端口号。通过inet_ntoa()函数将IP地址转换成可显示的ASCII串，通过htons()函数将端口号转换成网络字节序
		sendto(sockfd, "Welcome\n", 8, 0, (struct sockaddr *)&client, len);//发送Welcome字符串给客户端
		if (!strcmp(buf, "bye")) //如果客户端发来的字符串是"bye"，则退出循环
		{
			break;
		}
	}
	close(sockfd);
}

#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <stdlib.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <netdb.h>
#define PORT 1234 //这里的端口号要和服务器的端口号一样
#define MAXDATASIZE 100
int main(int argc, char const *argv[])
{
	int sockfd, num;
	char buf[MAXDATASIZE];
	struct hostent *he;
	struct sockaddr_in server, peer;
	socklen_t len;
	if (argc != 3) //检查用户的输入
	{
		printf("Usage: %s <IP Address><message>\n", argv[0]);
		exit(1);
	}
	if ((he = gethostbyname(argv[1])) == NULL)
	{
		printf("gethostbyname() error\n");
		exit(1);
	}
	if ((sockfd = socket(AF_INET, SOCK_DGRAM, 0)) == -1){
		//调用socket()函数产生套接字描述符
		printf("socket() error\n");
		exit(1);
	}
	bzero(&server, sizeof(server));
	server.sin_family = AF_INET;
	server.sin_port = htons(PORT);
	server.sin_addr = *((struct in_addr *)he->h_addr); /*he->h_addr the first ip*/
	sendto(sockfd, argv[2], strlen(argv[2]), 0, (struct sockaddr *)&server, sizeof(server));
	//将用户从命令行输入的消息发送给服务器server
	len = sizeof(server);
	while(1)
	{
		if ((num = recvfrom(sockfd, buf, MAXDATASIZE, 0, (struct sockaddr *)&peer, &len)) == -1)
		//接收服务器发过来的字符串，并保存在buf中。接收的真正字节数被存储在num中，同时peer返回接收服务器的地址
		{
			printf("recvfrom() error\n");
			exit(1);
		}
		if (len!= sizeof(server) || memcmp((const void *)&server, (const void *)&peer, len) != 0)
		//由于UDP套接字是无连接的，它可能接收到其他服务器发来的信息，所以应判断信息是否来自于相应的服务器。
		//首先，比较recvfrom()函数调用后返回的地址长度len是否等于结构体server的长度。如果不是，则说明消息来自于其它服务器。
		//然后判断server和peer变量中的内容是否一致。如果一致，则说明收到的消息来自于相应的服务器。
		//注意，server和peer使用memcmp函数进行比较时，首先应转换成常量指针才能使用。
		{
			printf("Receive message from other server.\n");
			continue;
		}
		buf[num] = '\0';
		printf("Server Message: %s.\n", buf);//显示来自于服务器的信息
		break;
	}
	close(sockfd);
}