devbox
我家自动化
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

C语言之网络编程（服务器和客户端）_c语言服务器编程

作者：我家自动化 | 2024-02-26 04:49:06

赞

踩

c语言服务器编程

Linux网络编程

1、 套接字：源IP地址和目的IP地址以及源端口号和目的端口号的组合称为套接字。其用于标识客户端请求的服务器和服务。

常用的TCP/IP协议的3种套接字类型如下所示。

（1）流套接字（SOCK_STREAM）：

流套接字用于提供面向连接、可靠的数据传输服务。该服务将保证数据能够实现无差错、无重复发送，并按顺序接收。流套接字之所以能够实现可靠的数据服务，原因在于其使用了传输控制协议，即TCP（The Transmission ControlProtocol）协议。

（2）       数据报套接字（SOCK_DGRAM）：

数据报套接字提供了一种无连接的服务。该服务并不能保证数据传输的可靠性，数据有可能在传输过程中丢失或出现数据重复，且无法保证顺序地接收到数据。数据报套接字使用UDP（User Datagram Protocol）协议进行数据的传输。由于数据报套接字不能保证数据传输的可靠性，对于有可能出现的数据丢失情况，需要在程序中做相应的处理。

（3）       原始套接字（SOCK_RAW）：（一般不用这个套接字）

原始套接字(SOCKET_RAW)允许对较低层次的协议直接访问，比如IP、 ICMP协议，它常用于检验新的协议实现，或者访问现有服务中配置的新设备，因为RAW SOCKET可以自如地控制Windows下的多种协议，能够对网络底层的传输机制进行控制，所以可以应用原始套接字来操纵网络层和传输层应用。比如，我们可以通过RAW SOCKET来接收发向本机的ICMP、IGMP协议包，或者接收TCP/IP栈不能够处理的IP包，也可以用来发送一些自定包头或自定协议的IP包。网络监听技术很大程度上依赖于SOCKET_RAW

2、 套接字基本函数：

（1）      创建套接字：int socket(int family, int type, intprotocol);

功能介绍：

      在Linux操作系统中，一切皆文件，这个大家都知道，个人理解创建socket的过程其实就是一个获得文件描述符的过程，当然这个过程会是比较复杂的。可以从内核中找到创建socket的代码，并且socket的创建和其他的listen，bind等操作分离开来。socket函数完成正确的操作是返回值大于0的文件描述符，当返回小于0的值时，操作错误。同样是返回一个文件描述符，但是会因为三个参数组合不同，对于数据具体的工作流程不同，对于应用层编程来说，这些也是不可见的。

参数说明：

      从socket创建的函数可以看出，socket有三个参数，family代表一个协议族，比较熟知的就是AF_INET，PF_PACKET等；第二个参数是协议类型，常见类型是SOCK_STREAM,SOCK_DGRAM, SOCK_RAW, SOCK_PACKET等；第三个参数是具体的协议，对于标准套接字来说，其值是0，对于原始套接字来说就是具体的协议值。

（2）      套接字绑定函数： intbind(int sockfd, const struct sockaddr *myaddr, socklen_t addrlen);

功能介绍：

      bind函数主要应用于服务器模式一端，其主要的功能是将addrlen长度 structsockaddr类型的myaddr地址与sockfd文件描述符绑定到一起，在sockaddr中主要包含服务器端的协议族类型，网络地址和端口号等。在客户端模式中不需要使用bind函数。当bind函数返回0时，为正确绑定，返回-1，则为绑定失败。

参数说明：

      bind函数的第一个参数sockfd是在创建socket套接字时返回的文件描述符。

      bind函数的第二个参数是structsockaddr类型的数据结构，由于structsockaddr数据结构类型不方便设置，所以通常会通过对tructsockaddr_in进行地质结构设置，然后进行强制类型转换成structsockaddr类型的数据，

 

（3）      监听函数：int listen(int sockfd, int backlog);

功能介绍：

      刚开始理解listen函数会有一个误区，就是认为其操作是在等在一个新的connect的到来，其实不是这样的，真正等待connect的是accept操作，listen的操作就是当有较多的client发起connect时，server端不能及时的处理已经建立的连接，这时就会将connect连接放在等待队列中缓存起来。这个等待队列的长度有listen中的backlog参数来设定。listen和accept函数是服务器模式特有的函数，客户端不需要这个函数。当listen运行成功时，返回0；运行失败时，返回值位-1.

参数说明：

      sockfd是前面socket创建的文件描述符;backlog是指server端可以缓存连接的最大个数，也就是等待队列的长度。

 

（4）      请求接收函数： int accept(int sockfd, structsockaddr *client_addr, socklen_t *len);

功能介绍：

      接受函数accept其实并不是真正的接受，而是客户端向服务器端监听端口发起的连接。对于TCP来说，accept从阻塞状态返回的时候，已经完成了三次握手的操作。Accept其实是取了一个已经处于connected状态的连接，然后把对方的协议族，网络地址以及端口都存在了client_addr中，返回一个用于操作的新的文件描述符，该文件描述符表示客户端与服务器端的连接，通过对该文件描述符操作，可以向client端发送和接收数据。同时之前socket创建的sockfd，则继续监听有没有新的连接到达本地端口。返回大于0的文件描述符则表示accept成功，否则失败。

参数说明：

      sockfd是socket创建的文件描述符；client_addr是本地服务器端的一个structsockaddr类型的变量，用于存放新连接的协议族，网络地址以及端口号等；第三个参数len是第二个参数所指内容的长度，对于TCP来说其值可以用sizeof(structsockaddr_in)来计算大小，说要说明的是accept的第三个参数要是指针的形式，因为这个值是要传给协议栈使用的。

（5）客户端请求连接函数： intconnect(int sock_fd, struct sockaddr *serv_addr,int addrlen);

功能介绍：

      连接函数connect是属于client端的操作函数，其目的是向服务器端发送连接请求，这也是从客户端发起TCP三次握手请求的开始，服务器端的协议族，网络地址以及端口都会填充到connect函数的serv_addr地址当中。当connect返回0时说明已经connect成功，返回值是-1时，表示connect失败。

参数说明：

      connect的第一个参数是socket创建的文件描述符；第二个参数是一个structsockaddr类型的指针，这个参数中设置的是要连接的目标服务器的协议族，网络地址以及端口号；第三个参数表示第二个参数内容的大小，与accept不同，这个值不是一个指针。

      

      在服务器端和客户端建立连接之后是进行数据间的发送和接收，主要使用的接收函数是recv和read，发送函数是send和write。因为对于socket套接字来说，最终实际操作的是文件描述符，所以可以使用对文件进行操作的接收和发送函数对socket套接字进行操作。read和write函数是文件编程里的知识，所以这里不再做多与的赘述。

 

3、 有了以上的知识，那么我们就可以编写一个简单的服务器和客户端了

（1）       简易服务器：这个服务器只能与一个客户端相连接，如果有多个客户端就不能用这个服务器进行连接。

  1. 代码：
  2.  
  3. #include <sys/types.h>
  4. #include <sys/socket.h>
  5. #include <stdio.h>
  6. #include <unistd.h>
  7. #include <string.h>
  8. #include <arpa/inet.h>
  9.  
  10.  
  11. #define PORT 9990   //端口号
  12. #define SIZE 1024   //定义的数组大小
  13.  
  14. int Creat_socket()    //创建套接字和初始化以及监听函数
  15. {
  16. 	int listen_socket = socket(AF_INET, SOCK_STREAM, 0);   //创建一个负责监听的套接字
  17. 	if(listen_socket == -1)
  18. 	{
  19. 		perror("socket");
  20. 		return -1;
  21. 	}
  22. 	struct sockaddr_in addr;
  23. 	memset(&addr, 0, sizeof(addr));
  24. 	
  25. 	addr.sin_family = AF_INET;  /* Internet地址族 */
  26.     addr.sin_port = htons(PORT);  /* 端口号 */
  27.     addr.sin_addr.s_addr = htonl(INADDR_ANY);   /* IP地址 */
  28. 	
  29. 	int ret = bind(listen_socket, (struct sockaddr *)&addr, sizeof(addr));  //连接
  30. 	if(ret == -1)
  31. 	{
  32. 		perror("bind");
  33. 		return -1;
  34. 	}
  35. 	
  36. 	ret = listen(listen_socket, 5);        //监听
  37. 	if(ret == -1)
  38. 	{
  39. 		perror("listen");
  40. 		return -1;
  41. 	}
  42. 	return listen_socket;
  43. }
  44.  
  45. int wait_client(int listen_socket)
  46. {
  47. 	struct sockaddr_in cliaddr;
  48. 	int addrlen = sizeof(cliaddr);
  49. 	printf("等待客户端连接。。。。\n");
  50. 	int client_socket = accept(listen_socket, (struct sockaddr *)&cliaddr, &addrlen);   //创建一个和客户端交流的套接字
  51. 	if(client_socket == -1)
  52. 	{
  53. 		perror("accept");
  54. 		return -1;
  55. 	}
  56. 	
  57. 	printf("成功接收到一个客户端：%s\n", inet_ntoa(cliaddr.sin_addr));
  58. 	
  59. 	return client_socket;
  60. }
  61.  
  62. void hanld_client(int listen_socket, int client_socket)   //信息处理函数,功能是将客户端传过来的小写字母转化为大写字母
  63. {
  64. 	char buf[SIZE];
  65. 	while(1)
  66. 	{
  67. 		int ret = read(client_socket, buf, SIZE-1);
  68. 		if(ret == -1)
  69. 		{
  70. 			perror("read");
  71. 			break;
  72. 		}
  73. 		if(ret == 0)
  74. 		{
  75. 			break;
  76. 		}
  77. 		buf[ret] = '\0';
  78. 		int i;
  79. 		for(i = 0; i < ret; i++)
  80. 		{
  81. 			buf[i] = buf[i] + 'A' - 'a';
  82. 		}
  83. 		
  84. 		printf("%s\n", buf);
  85. 		write(client_socket, buf, ret);
  86. 		
  87. 		if(strncmp(buf, "end", 3) == 0)
  88. 		{
  89. 			break;
  90. 		}
  91. 	}
  92. 	close(client_socket);
  93. }
  94.  
  95. int main()
  96. {
  97. 	int listen_socket = Creat_socket();
  98. 	
  99. 	int client_socket = wait_client(listen_socket);
  100. 	
  101. 	hanld_client(listen_socket, client_socket);
  102. 	
  103. 	close(listen_socket);
  104. 	
  105. 	return 0;
  106. }


（2） 多进程并发服务器：该服务器就完全弥补了上一个服务器的不足，可以同时处理多个客户端，只要有客户端来连接它，他就能响应。在我们这个服务器中，父进程主要负责监听，所以在父进程一开始就要把父进程的接收函数关闭掉，防止父进程在接收函数处阻塞，导致子进程不能创建成功。同理，子进程主要负责接收客户端，并做相关处理，所以子进程在一创建就要把监听函数关闭，不然会导致服务器功能的紊乱。这个服务器有一个特别要注意的是，子进程在退出时会产生僵尸进程，所以我们一定要对子进程退出后进行处理。

  1. 代码：
  2. #include <sys/types.h>
  3. #include <sys/socket.h>
  4. #include <stdio.h>
  5. #include <unistd.h>
  6. #include <string.h>
  7. #include <arpa/inet.h>
  8. #include <signal.h>
  9. #include <sys/wait.h>
  10.  
  11. #define PORT 9990
  12. #define SIZE 1024
  13.  
  14. int Creat_socket()         //创建套接字和初始化以及监听函数
  15. {
  16. 	int listen_socket = socket(AF_INET, SOCK_STREAM, 0);      //创建一个负责监听的套接字  
  17. 	if(listen_socket == -1)
  18. 	{
  19. 		perror("socket");
  20. 		return -1;
  21. 	}
  22. 	struct sockaddr_in addr;
  23. 	memset(&addr, 0, sizeof(addr));
  24. 	
  25. 	addr.sin_family = AF_INET;  /* Internet地址族 */
  26.     addr.sin_port = htons(PORT);  /* 端口号 */
  27.     addr.sin_addr.s_addr = htonl(INADDR_ANY);   /* IP地址 */
  28. 	
  29. 	int ret = bind(listen_socket, (struct sockaddr *)&addr, sizeof(addr));    //连接
  30. 	if(ret == -1)
  31. 	{
  32. 		perror("bind");
  33. 		return -1;
  34. 	}
  35. 	
  36. 	ret = listen(listen_socket, 5);   //监听
  37. 	if(ret == -1)
  38. 	{
  39. 		perror("listen");
  40. 		return -1;
  41. 	}
  42. 	return listen_socket;
  43. }
  44.  
  45. int wait_client(int listen_socket)
  46. {
  47. 	struct sockaddr_in cliaddr;
  48. 	int addrlen = sizeof(cliaddr);
  49. 	printf("等待客户端连接。。。。\n");
  50. 	int client_socket = accept(listen_socket, (struct sockaddr *)&cliaddr, &addrlen);     //创建一个和客户端交流的套接字
  51. 	if(client_socket == -1)
  52. 	{
  53. 		perror("accept");
  54. 		return -1;
  55. 	}
  56. 	
  57. 	printf("成功接收到一个客户端：%s\n", inet_ntoa(cliaddr.sin_addr));
  58. 	
  59. 	return client_socket;
  60. }
  61.  
  62. void hanld_client(int listen_socket, int client_socket)    //信息处理函数,功能是将客户端传过来的小写字母转化为大写字母
  63. {
  64. 	char buf[SIZE];
  65. 	while(1)
  66. 	{
  67. 		int ret = read(client_socket, buf, SIZE-1);
  68. 		if(ret == -1)
  69. 		{
  70. 			perror("read");
  71. 			break;
  72. 		}
  73. 		if(ret == 0)
  74. 		{
  75. 			break;
  76. 		}
  77. 		buf[ret] = '\0';
  78. 		int i;
  79. 		for(i = 0; i < ret; i++)
  80. 		{
  81. 			buf[i] = buf[i] + 'A' - 'a';
  82. 		}
  83. 		
  84. 		printf("%s\n", buf);
  85. 		write(client_socket, buf, ret);
  86. 		
  87. 		if(strncmp(buf, "end", 3) == 0)
  88. 		{
  89. 			break;
  90. 		}
  91. 	}
  92. 	close(client_socket);
  93. }
  94.  
  95. void handler(int sig)
  96. {
  97. 	
  98. 	while (waitpid(-1,  NULL,   WNOHANG) > 0)
  99. 	{
  100. 		printf ("成功处理一个子进程的退出\n");
  101. 	}
  102. }
  103.  
  104. int main()
  105. {
  106. 	int listen_socket = Creat_socket();
  107. 	
  108.  
  109. 	signal(SIGCHLD,  handler);    //处理子进程，防止僵尸进程的产生
  110. 	while(1)
  111. 	{
  112. 		int client_socket = wait_client(listen_socket);   //多进程服务器，可以创建子进程来处理，父进程负责监听。
  113. 		int pid = fork();
  114. 		if(pid == -1)
  115. 		{
  116. 			perror("fork");
  117. 			break;
  118. 		}
  119. 		if(pid > 0)
  120. 		{
  121. 			close(client_socket);
  122. 			continue;
  123. 		}
  124. 		if(pid == 0)
  125. 		{
  126. 			close(listen_socket);
  127. 			hanld_client(listen_socket, client_socket);
  128. 			break;
  129. 		}
  130. 	}
  131. 	
  132. 	close(listen_socket);
  133. 	
  134. 	return 0;
  135. }


（3） 多线程并发服务器：上一个多进程服务器有一个缺点，就是每当一个子进程得到响应的时候，都要复制父进程的一切信息，这样就导致了CPU资源的浪费，当客户端有很多来连接这个服务器的时候，就会产生很多的子进程，会导致服务器的响应变得很慢。所以我们就想到了多线程并发服务器，我们知道线程的速度是进程的30倍左右，所以我们就用线程来做服务器。

  1. 代码：
  2. #include <sys/types.h>
  3. #include <sys/socket.h>
  4. #include <stdio.h>
  5. #include <unistd.h>
  6. #include <string.h>
  7. #include <arpa/inet.h>
  8. #include <pthread.h>
  9.  
  10.  
  11. #define PORT 9990
  12. #define SIZE 1024
  13.  
  14. int Creat_socket()         //创建套接字和初始化以及监听函数
  15. {
  16. 	int listen_socket = socket(AF_INET, SOCK_STREAM, 0);      //创建一个负责监听的套接字  
  17. 	if(listen_socket == -1)
  18. 	{
  19. 		perror("socket");
  20. 		return -1;
  21. 	}
  22. 	struct sockaddr_in addr;
  23. 	memset(&addr, 0, sizeof(addr));
  24. 	
  25. 	addr.sin_family = AF_INET;  /* Internet地址族 */
  26.     addr.sin_port = htons(PORT);  /* 端口号 */
  27.     addr.sin_addr.s_addr = htonl(INADDR_ANY);   /* IP地址 */
  28. 	
  29. 	int ret = bind(listen_socket, (struct sockaddr *)&addr, sizeof(addr));    //连接
  30. 	if(ret == -1)
  31. 	{
  32. 		perror("bind");
  33. 		return -1;
  34. 	}
  35. 	
  36. 	ret = listen(listen_socket, 5);   //监听
  37. 	if(ret == -1)
  38. 	{
  39. 		perror("listen");
  40. 		return -1;
  41. 	}
  42. 	return listen_socket;
  43. }
  44.  
  45. int wait_client(int listen_socket)
  46. {
  47. 	struct sockaddr_in cliaddr;
  48. 	int addrlen = sizeof(cliaddr);
  49. 	printf("等待客户端连接。。。。\n");
  50. 	int client_socket = accept(listen_socket, (struct sockaddr *)&cliaddr, &addrlen);     //创建一个和客户端交流的套接字
  51. 	if(client_socket == -1)
  52. 	{
  53. 		perror("accept");
  54. 		return -1;
  55. 	}
  56. 	
  57. 	printf("成功接收到一个客户端：%s\n", inet_ntoa(cliaddr.sin_addr));
  58. 	
  59. 	return client_socket;
  60. }
  61.  
  62. void hanld_client(int listen_socket, int client_socket)    //信息处理函数,功能是将客户端传过来的小写字母转化为大写字母
  63. {
  64. 	char buf[SIZE];
  65. 	while(1)
  66. 	{
  67. 		int ret = read(client_socket, buf, SIZE-1);
  68. 		if(ret == -1)
  69. 		{
  70. 			perror("read");
  71. 			break;
  72. 		}
  73. 		if(ret == 0)
  74. 		{
  75. 			break;
  76. 		}
  77. 		buf[ret] = '\0';
  78. 		int i;
  79. 		for(i = 0; i < ret; i++)
  80. 		{
  81. 			buf[i] = buf[i] + 'A' - 'a';
  82. 		}
  83. 		
  84. 		printf("%s\n", buf);
  85. 		write(client_socket, buf, ret);
  86. 		
  87. 		if(strncmp(buf, "end", 3) == 0)
  88. 		{
  89. 			break;
  90. 		}
  91. 	}
  92. 	close(client_socket);
  93. }
  94.  
  95. int main()
  96. {
  97. 	int listen_socket = Creat_socket();
  98. 	
  99. 	while(1)
  100. 	{
  101. 		int client_socket = wait_client(listen_socket);
  102. 		
  103. 		pthread_t id;
  104. 		pthread_create(&id, NULL, hanld_client, (void *)client_socket);  //创建一个线程，来处理客户端。
  105. 		
  106. 		 pthread_detach(id);   //把线程分离出去。
  107. 	}
  108. 	
  109. 	close(listen_socket);
  110. 	
  111. 	return 0;
  112. }
（4）客户端：客户端相对于服务器来说就简单多了，客户端只需要创建和服务器相连接的套接字，然后对其初始化，然后再进行连接就可以了，连接上服务器就可以发送你想发送的数据了。 
  1. 代码:
  2. #include <sys/types.h>
  3. #include <sys/socket.h>
  4. #include <stdio.h>
  5. #include <unistd.h>
  6. #include <string.h>
  7. #include <arpa/inet.h>
  8.  
  9.  
  10. #define PORT 9990
  11. #define SIZE 1024
  12.  
  13. int main()
  14. {
  15. 	int client_socket = socket(AF_INET, SOCK_STREAM, 0);   //创建和服务器连接套接字
  16. 	if(client_socket == -1)
  17. 	{
  18. 		perror("socket");
  19. 		return -1;
  20. 	}
  21. 	struct sockaddr_in addr;
  22. 	memset(&addr, 0, sizeof(addr));
  23. 	
  24. 	addr.sin_family = AF_INET;  /* Internet地址族 */
  25.     addr.sin_port = htons(PORT);  /* 端口号 */
  26.     addr.sin_addr.s_addr = htonl(INADDR_ANY);   /* IP地址 */
  27. 	inet_aton("127.0.0.1", &(addr.sin_addr));
  28.  
  29. 	int addrlen = sizeof(addr);
  30. 	int listen_socket =  connect(client_socket,  (struct sockaddr *)&addr, addrlen);  //连接服务器
  31. 	if(listen_socket == -1)
  32. 	{
  33. 		perror("connect");
  34. 		return -1;
  35. 	}
  36. 	
  37. 	printf("成功连接到一个服务器\n");
  38. 	
  39. 	char buf[SIZE] = {0};
  40. 	
  41. 	while(1)        //向服务器发送数据，并接收服务器转换后的大写字母
  42. 	{
  43. 		printf("请输入你相输入的：");
  44. 		scanf("%s", buf);
  45. 		write(client_socket, buf, strlen(buf));
  46. 		
  47. 		int ret = read(client_socket, buf, strlen(buf));
  48. 		
  49. 		printf("buf = %s", buf);
  50. 		printf("\n");
  51. 		if(strncmp(buf, "END", 3) == 0)     //当输入END时客户端退出
  52. 		{
  53. 			break;
  54. 		}
  55. 	}
  56. 	close(listen_socket);
  57. 	
  58. 	return 0;
  59. }






声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/我家自动化/article/detail/144136
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号