#include <sys/types.h>          /* See NOTES */
#include <sys/socket.h>
int socket(int domain, int type, int protocol);
domian指协议族/域，IPV4采用AF_INET；
type是套接口类型，对于TCP采用SOCK_STREAM； 
protocol一般取为0(表示使用默认协议).成功返回一个小的非负整数值，与文件描述符类似

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

当socket函数返回一个文件描述符时，只是存在于其协议族的空间中，并没有分配一个具体
的协议地址（IPV4和端口号的组合），bind函数可以将一组固定的地址绑定到sockfd上。成
功返回0，失败返回-1。

sockfd是socket()函数返回的描述符；类似于open以及fcntl函数  
addr指定了想要绑定的IP和端口号，均要使用网络字节序-即大端模式；兼容两种IP
地址，IPV4、IPV6
addrlen是前面struct sockaddr（与sockaddr_in等价）的长度。

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

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

listen函数的第一个参数即为要监听的socket描述字，第二个参数为相应socket
可以排队的最大连接个数。socket()函数创建的socket默认是一个主动类型的，
listen函数将socket变为被动类型的，等待客户的连接请求。

RETURN VALUE
       On success, zero is returned.  On error, -1 is returned, and errno is set appropriately.

#include <sys/types.h>          /* See NOTES */
#include <sys/socket.h>
int connect(int sockfd, const struct sockaddr *addr,
                   socklen_t addrlen);
connect函数的第一个参数即为客户端的socket描述字，第二参数为服务器的
socket地址，第三个参数为socket地址的长度。客户端通过调用connect函数
来建立与TCP服务器的连接。
通过connect函数建立于TCP服务器的连接，实际是发起三次握手过程，仅在连
接成功或失败后返回。参数sockfd是本地描述符，addr为服务器地址，addrlen
是socket地址长度。

int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen); //返回连接connect_fd
 
参数sockfd:
参数sockfd就是上面解释中的监听套接字，这个套接字用来监听一个端口，
当有一个客户与服务器连接时，它使用这个一个端口号，而此时这个端口号
正与这个套接字关联。当然客户不知道套接字这些细节，它只知道一个地址
和一个端口号。

参数addr:
这是一个结果参数，它用来接受一个返回值，这返回值指定客户端的地址，当然这个地址是通过
某个地址结构来描述的，用户应该知道这一个什么样的地址结构。如果对客户的地址不感兴趣，
那么可以把这个值设置为NULL。

参数addrlen:
如同大家所认为的，它也是结果的参数，用来接受上述addr的结构的大小的，它指明addr结构所
占有的字节个数。同样的，它也可以被设置为NULL。
 
如果accept成功返回，则服务器与客户已经正确建立连接了，此时服务器通过accept返回的套接
字来完成与客户的通信。

注意：
      accept 默认会阻塞进程，直到有一个客户连接建立后返回，它返回的是一个新可用的套接字，这个套接字是连接套接字。
此时我们需要区分两种套接字，
       监听套接字: 监听套接字正如accept的参数sockfd，它是监听套接字，是服务器开始调用socket()函数生成的，称为监听socket描述字(监听套接字)

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

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

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

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

#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);

对于函数所使用的参数详解查阅man手册

struct in_addr
{
    in_addr_t s_addr;
};

#include <netinet/in.h>
 
struct sockaddr {
    unsigned short    sa_family;    // 2 bytes address family, AF_xxx
    char              sa_data[14];     // 14 bytes of protocol address
};
 
// IPv4 AF_INET sockets:
 
struct sockaddr_in {
    short            sin_family;       // 2 bytes e.g. AF_INET, AF_INET6
    unsigned short   sin_port;    // 2 bytes e.g. htons(3490)
    struct in_addr   sin_addr;     // 4 bytes see struct in_addr, below
    char             sin_zero[8];     // 8 bytes zero this if you want to
};
 
struct in_addr {
    unsigned long s_addr;          // 4 bytes load with inet_pton()
};

int inet_aton(const char *cp, struct in_addr *inp);

inet_aton() 转换网络主机地址ip(如192.168.1.10)为二进制数值，并存储在struct in_addr结构中，即第二个参数*inp,函数返回非0表示cp主机有地有效，返回0表示主机地址无效。（这个转换完后不能用于网络传输，还需要调用htons或htonl函数才能将主机字节顺序转化为网络字节顺序）

in_addr_t inet_addr(const char *cp);

inet_addr函数转换网络主机地址（如192.168.1.10)为网络字节序二进制值，如果参数char *cp无效，函数返回-1(INADDR_NONE),这个函数在处理地址为255.255.255.255时也返回－1,255.255.255.255是一个有效的地址，不过inet_addr无法处理;

char *inet_ntoa(struct in_addr in);

inet_ntoa 函数转换网络字节排序的地址为标准的ASCII以点分开的地址,该函数返回指向点分开的字符串地址（如192.168.1.10)的指针，该字符串的空间为静态分配的，这意味着在第二次调用该函数时，上一次调用将会被重写（覆盖），所以如果需要保存该串最后复制出来自己管理！

`#include <arpe/inet.h>
int inet_pton(int family, const char *strptr, void *addrptr);    
//将点分十进制的ip地址转化为用于网络传输的数值格式
//返回值：若成功则为1，若输入不是有效的表达式则为0，若出错则为-1
 
const char * inet_ntop(int family, const void *addrptr, char *strptr, size_t len);     
//将数值格式转化为点分十进制的ip地址格式
//返回值：若成功则为指向结构的指针，若出错则为NULL
（1）这两个函数的family参数既可以是AF_INET（ipv4）也可以是AF_INET6（ipv6）。如果，以不被支持的地址族作为family参数，这两个函数都返回一个错误，并将errno置为EAFNOSUPPORT.

（2）第一个函数尝试转换由strptr指针所指向的字符串，并通过addrptr指针存放二进制结果，
若成功则返回值为1，否则如果所指定的family而言输入字符串不是有效的表达式格式，那么返回
值为0.

（3）inet_ntop进行相反的转换，从数值格式（addrptr）转换到表达式（strptr)。
inet_ntop函数的strptr参数不可以是一个空指针。调用者必须为目标存储单元分配内存并指定
其大小，调用成功时，这个指针就是该函数的返回值。len参数是目标存储单元的大小，以免该函
数溢出其调用者的缓冲区。如果len太小，不足以容纳表达式结果，那么返回一个空指针，并置为
errno为ENOSPC。

inet_pton(AF_INET, ip, &foo.sin_addr);   
//代替 foo.sin_addr.s_addr=inet_addr(ip);
  
char str[INET_ADDRSTRLEN];
char *ptr = inet_ntop(AF_INET,&foo.sin_addr, str, sizeof(str));      
 // 代替 ptr = inet_ntoa(foo.sin_addr)

#include <stdio.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <stdlib.h>
#include <string.h>

#define IP_ADDR "192.168.1.102"

int main(int argc, char *argv[])
{	
#if 0 
	struct in_addr addr = {0};
	int ret = 0;
	char *addr1 = NULL; 
	
	/*Error in this statement. This macro definition will not be replaced*/
	//printf("IP address in decimal format:IP_ADDR.\n");/*error*/
	printf("IP address in decimal format:%s.\n",IP_ADDR);/*correct*/
	
	//printf("IP address in decimal format:IP_ADDR.\n");
	ret = inet_aton(IP_ADDR, &addr);
	if (ret != 0)
	{
		printf("The address is in hex format:0x%x.\n", addr.s_addr);
	}
	else
	{
		printf("Invalid host address.\n");
		exit(-1);
	}
	
	if (NULL == addr1)
	{
		 addr1 = inet_ntoa(addr);
		 printf("The dot decimal format is:%s.\n", addr1);
		
	}
	else
	{
		printf("Warning: This pointer has been referenced.\n");
		
	}
	
#endif

#if 0
	in_addr_t ret = -1;
	
	printf("IP address in decimal format:%s.\n",IP_ADDR);
	ret = inet_addr(IP_ADDR);
	if (ret == -1)
	{
		printf("The passed parameter is invalid or\
the passed address cannot be processed.\n");
		exit(-1);
	}
	else
	{
		printf("The address is in hex format:0x%x.\n", ret);
	}
#endif 

#if 1
	int addr = 0;
	int ret = -1;
	char str[100] = {0};

	ret = inet_pton(AF_INET, IP_ADDR, &addr);
	if (ret != 1)
	{
		printf("inet_pton error.\n");
	}
	else
	{
		printf("The address is in hex format:0x%x.\n", addr);
	}

	inet_ntop(AF_INET, &addr, str, sizeof(str));
	printf("IP address in decimal format:%s.\n", str);
#endif

	return 0;
}

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

#define SERPORT 9003 //服务器开放给我们的IP地址和端口号
#define SERADDR "192.168.1.67"
#define BACKLOG 100

char recv_buf[100] = {0};

#define STAT_OK			30 // 回复ok
#define STAT_ERR		31 // 回复出错了

typedef struct commu
{
	char name[20];		// 学生姓名
	int age;			// 学生年龄
	char cmd[20];			// 命令码
	int stat;			// 状态信息，用来回复
}info;

int main(int argc, char *argv[])
{
	int sockfd = -1, ret = -1, clifd = -1;
	socklen_t len = 0;
	struct sockaddr_in seraddr = {0};
	struct sockaddr_in cliaddr = {0};
	char ipbuf[100] = {0};
	
	
	//第一步：使用socket打开文件描述符
	sockfd = socket(AF_INET, SOCK_STREAM, 0);
	if (-1 == sockfd)
	{
		perror("socket");
		return -1;
	}
	else
	{
		printf("sockfd = %d.\n", sockfd);
	}
	
	//第二步：bind绑定sockfd和当前电脑的ip地址以及端口号
	seraddr.sin_family = AF_INET;		// 设置地址族为IPv4;
	seraddr.sin_port = htons(SERPORT);  //设置地址的端口号信息
	seraddr.sin_addr.s_addr = inet_addr(SERADDR);//设置IP地址
	ret = bind(sockfd, (const struct sockaddr *)&seraddr, sizeof(seraddr));
	if (ret < 0)
	{
		perror("bind");
		return 0;
	}
	else
	{
		ret = -1;
		printf("bind success.\n");
	}
	
	//第三步，使用listen监听端口
	ret = listen(sockfd, BACKLOG);
	if (ret < 0)
	{
		printf("listen error.\n");
		
	}
	else
	{
		printf("listen success");
		ret = -1;
	}
	
	//第四步：accept阻塞等待客户端接入
	clifd = accept(sockfd, (struct sockaddr *)&cliaddr, &len);//返回连接connect_fd文件描述符
	printf("链接已经建立, client_fd = %d.\n", clifd);
	
	
	//第五步：建立连接后就可以通信了
	while(1)
	{
		info st1;
		int write_ret = -1;
		
		//回合中的第一步：服务器接收客户端发来的信息
		ret = recv(clifd, &st1, sizeof(info), 0);
				
		//回合中的第二步：服务器解析客户端数据包，然后进行处理
		//判断是否接收到数据包
		if (ret > 0)
		{
			printf("数据包接收成功.\n");
			
			//对于cmd命令回复的处理
			if (!strcmp("login", st1.cmd))
			{
				printf("客户端申请注册学生信息.\n");
				printf("学生姓名：%s, 年龄：%d.\n", st1.name, st1.age);
				//在这里服务器要进行真正的注册动作，一般是给数据库插入一条信息
				//我在这里通过写入一个文件代替数据库
				int fd = open("a.txt", O_WRONLY | O_APPEND | O_CREAT, 0666);
				if (fd < 0)
				{
					//printf("打开文件失败\n");
					perror("打开文件失败");
					exit(-1);
				}
				else 
				{
					printf("打开文件成功\n");
				}
				
				write_ret = write(fd, &st1, sizeof(st1));
				if (write_ret < 0)
				{

					perror("写入文件失败");
					exit(-1);
				}
				else
				{
					printf("写入文件成功,写入字符个数为：%d\n",write_ret);
					//回合中的第三步：回复客户端
					st1.stat = STAT_OK;
					ret = send(clifd, &st1, sizeof(st1), 0);
				}				
				
				
			}
			
			//对于check命令的处理
			if (!strcmp("check", st1.cmd))
			{
				//可自己设计功能实现
				
			}

			//对于getinfo命令的处理
			if (!strcmp("getinfo", st1.cmd))
			{
				//可自己设计功能实现
			}
			
		}//end ret > 0
					
	}//end while(1)
	
	return 0;
}` 

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

#define SERPORT 9003 //服务器开放给我们的IP地址和端口号
#define SERADDR "192.168.1.67"

#define STAT_OK			30 // 回复ok
#define STAT_ERR		31 // 回复出错了

char send_buf[100] = {0};
char recv_buf[100] = {0};
 
typedef struct commu
{
	char name[20]; //学生姓名
	int age;      //学生年龄
	char cmd[20];       //命令码
	int stat;      //状态信息，用来回复
}info;
 
 
int main(int argc, char *argv[])
{
	int sockfd = -1, ret = -1;
	struct sockaddr_in seraddr = {0};//使用IPV4
	struct sockaddr_in cliaddr = {0};
	
	//第一步：使用socket打开文件描述符
	sockfd = socket(AF_INET, SOCK_STREAM, 0);
	if (-1 == sockfd)
	{
		printf("socket error.\n");
		exit(-1);
	}
	else 
	{
		ret = -1;
		printf("sockfd = %d.\n", sockfd);	
	}
	
	//第二步：connect链接服务器,发起三次
	seraddr.sin_family = AF_INET;		// 设置地址族为IPv4;
	seraddr.sin_port = htons(SERPORT);  //设置地址的端口号信息
	seraddr.sin_addr.s_addr = inet_addr(SERADDR);//设置IP地址
	
	ret = connect(sockfd, (const struct sockaddr *)&seraddr, sizeof(seraddr));
	if (ret < 0)
	{
		printf("connect error.\n");
		exit(-1);
		
	}
	else
	{
		printf("connect successfully.\n");
		ret = -1;
	}
	//第三步：建立连接后就可以开始通信了
	//strcpy(sendbuf, "hello world.");
	//ret = send(sockfd, send_buf, sizeof(send_buf), 0);
	//printf("发送了%d个字节.\n", ret);
#if 0 
	while(1)
	{
		//客户端发送数据
		printf("请输入要发送的内容:.\n");
		scanf("%s", send_buf);
		ret = send(sockfd, send_buf, sizeof(send_buf), 0);
		if (ret < 0)
		{
			printf("send error.\n");
		}
		else
		{
			ret = -1;
			printf("发送了%d个字符.\n", ret);
		}		
		//客户端接收来自服务器的数据
		ret = recv(sockfd, send_buf, sizeof(send_buf), 0);
		if (ret < 0)
		{
			//printf("receive error.\n");
		
		}
		else
		{
			ret = -1;
			printf("成功接收了%d个字符.\n", ret);
			printf("client 发送的内容为:%s.\n", send_buf);
			
		}		
		
	}
#endif
	printf("访问远端服务器.\n");
	while(1)
	{
		//回合中第一步：客户端给服务器发送信息
		info st1;
		char cmd[50] = {0};
				
		printf("请输入学生的姓名：\n");
		scanf("%s", st1.name);
		printf("请输入学生的年龄：\n");
		scanf("%d", &st1.age);
		printf("请输入操作指令:\n");
		scanf("%s", st1.cmd);
		ret = send(sockfd, &st1, sizeof(st1), 0);
		
		//回合中第二步：客户端接收服务器的回复
		memset(&st1, 0, sizeof(st1));
		ret = recv(sockfd, &st1, sizeof(st1), 0);
		
		//回合中第三步：客户端解析服务器的回复，再做下一步处理
		if (ret > 0)
		{
			printf("收到回复.\n");
			
			//对于cmd命令回复的处理
			if (!strcmp("login", st1.cmd))
			{
				if (st1.stat == STAT_OK)
				{
					printf("学生信息注册成功.\n");					
				}
				else
				{
					printf("学生注册信息失败.\n");
				}
				
			}
			
			//对于check命令的处理
			if (!strcmp("check", st1.cmd))
			{
				if (st1.stat == STAT_OK)
				{
					printf("学生信息检查成功.\n");
					
				}
				else
				{
					printf("学生信息检查失败.\n");
				}
				
			}

			//对于getinfo命令的处理
			if (!strcmp("getinfo", st1.cmd))
			{
				if (st1.stat == STAT_OK)
				{
					printf("学生信息获取成功.\n");
					
				}
				else
				{
					printf("学生信息获取失败.\n");
				}
				
			}
						
		}//end ret >0
						
	}//end while(1)

	return 0;
}