• 2024/4/16 网络编程day4

    1. /*TCP并发服务器端*/
    2. #include <myhead.h>
    3. #define SER_IP "192.168.125.173"
    4. #define SER_PORT 8888
    5. void sighanger(int signum){
    6. 	if(signum==SIGCHLD){//子进程终止信号
    7. 		while(waitpid(-1,NULL,WNOHANG)>0);//循环回收僵尸进程
    8. 	}
    9. }
    10.  
    11. int main(int argc, const char *argv[])
    12. {
    13. 	//函数调用出错返回SIG_ERR
    14.  
    15. 	if(signal(SIGCHLD,sighanger)==SIG_ERR){
    16. 		perror("signal error");
    17. 		return -1;
    18. 	}
    19. 	//创建套接字
    20. 	int rfd=socket(AF_INET,SOCK_STREAM,0);
    21. 	if(rfd==-1){
    22. 		perror("socket error");
    23. 		return -1;
    24. 	}
    25. 	printf("socket success\n");
    26.  
    27. 	//为服务器绑定ip地址端口号
    28. 	struct sockaddr_in cin;
    29. 	cin.sin_family=AF_INET;
    30. 	cin.sin_port=htons(SER_PORT);
    31. 	cin.sin_addr.s_addr=inet_addr(SER_IP);
    32. 	if(bind(rfd,(struct sockaddr*)&cin,sizeof(cin))==-1){
    33. 			perror("bind error");
    34. 			return -1;
    35. 			}
    36. 	//设置监听
    37. 	if(listen(rfd,128)==-1){
    38. 		perror("listen error");
    39. 		return -1;
    40. 	}
    41. 	printf("listen success\n");
    42. 	struct sockaddr_in sin;
    43. 	socklen_t socklen=sizeof(sin);
    44. 	while(1){//循环接收客户端请求
    45. 		int newfd=accept(rfd,(struct sockaddr*)&sin,&socklen);
    46. 		if(newfd==-1){
    47. 			perror("accept error");
    48. 			return -1;
    49. 		}
    50. 		pid_t pid=fork();
    51. 		if(pid>0){
    52. 			close(newfd);
    53. 		}else if(pid==0){//子进程数据通信
    54. 			close(rfd);
    55. 			char rbuf[128]="";
    56. 			while(1){
    57. 				bzero(rbuf,sizeof(rbuf));
    58. 				int res=read(newfd,rbuf,sizeof(rbuf));
    59. 				if(res==0){
    60.  
    61. 					printf("客户端已下线\n");
    62. 					break;
    63. 				}
    64.  
    65. 				printf("[%s:%d]:%s\n",inet_ntoa(cin.sin_addr),ntohs(cin.sin_port),rbuf);
    66. 				//将字符串加777发送回去
    67. 				strcat(rbuf,"777");
    68. 				write(newfd,rbuf,sizeof(rbuf));
    69. 				printf("发送成功\n");
    70.  
    71. 			}
    72. 			close(newfd);
    73. 			exit(EXIT_SUCCESS);
    74. 		}
    75. 	}
    76. 	close(rfd);
    77. 	return 0;
    78. }

    1. //多线程实现TCP并发服务器
    2. #include<myhead.h>
    3. #define SER_IP "192.168.125.117"        //服务器IP地址
    4. #define SER_PORT 8888                   //服务器端口号
    5.  
    6. //定义用于给线程体传参的结构体类型
    7. struct MsgInfo
    8. {
    9.     int newfd;
    10.     struct sockaddr_in cin;
    11. };
    12.  
    13. //定义线程体函数
    14. void *deal_cli_msg(void *arg)
    15. {
    16.  
    17.     //将传递进来的数据解析出来
    18.     int newfd = ((struct MsgInfo*)arg)->newfd;
    19.     struct sockaddr_in cin = ((struct MsgInfo*)arg)->cin;
    20.  
    21.     //5、数据通信
    22.     char rbuf[128] = "";       //用于接受消息
    23.     while(1)
    24.     {
    25.         bzero(rbuf, sizeof(rbuf));    //清空容器
    26.         //从套接字文件中读取消息
    27.         //int ret = read(newfd, rbuf, sizeof(rbuf));
    28.         int ret = recv(newfd, rbuf, sizeof(rbuf), 0);
    29.         if(ret == 0)
    30.         {
    31.             printf("客户端已下线\n");
    32.             break;
    33.         }
    34.         printf("[%s:%d]: %s\n", \
    35.                 inet_ntoa(cin.sin_addr), ntohs(cin.sin_port),rbuf );
    36.  
    37.         //将字符串加个笑脸回回去
    38.         strcat(rbuf, "*_*");
    39.         //write(newfd, rbuf, strlen(rbuf));
    40.         send(newfd, rbuf, strlen(rbuf), 0);
    41.         printf("发送成功\n");
    42.  
    43.     }
    44.  
    45.     //6、关闭套接字
    46.     close(newfd);
    47.  
    48.     //退出线程
    49.     pthread_exit(NULL);
    50.  
    51.  
    52. }
    53.  
    54.  
    55.  
    56. /**主程序**/
    57. int main(int argc, const char *argv[])
    58. {
    59.     //1、创建套节字：用于接收客户端链接请求的
    60.     int sfd = socket(AF_INET, SOCK_STREAM, 0);
    61.     if(sfd == -1)
    62.     {
    63.         perror("socket error");
    64.         return -1;
    65.     }
    66.     printf("socket success sfd = %d\n", sfd);     //3
    67.  
    68.     //设置端口号快速重用
    69.     int reuse = 1;
    70.     if(setsockopt(sfd, SOL_SOCKET, SO_REUSEADDR, &reuse, sizeof(reuse))==-1)
    71.     {
    72.         perror("setsockopt error");
    73.         return -1;
    74.     }
    75.     printf("端口号快速重用成功\n");
    76.     
    77.     //2、绑定IP地址和端口号
    78.     //2.1 填充地址信息结构体
    79.     struct sockaddr_in sin;
    80.     sin.sin_family = AF_INET;       //地址族
    81.     sin.sin_port = htons(SER_PORT);  //端口号
    82.     sin.sin_addr.s_addr = inet_addr(SER_IP);    //IP地址
    83.  
    84.     //2.2 绑定工作
    85.     if( bind(sfd, (struct sockaddr*)&sin, sizeof(sin)) ==-1)
    86.     {
    87.         perror("bind error");
    88.         return -1;
    89.     }
    90.     printf("bind success\n");
    91.  
    92.  
    93.     //3、讲套节字设置成被动监听状态
    94.     if( listen(sfd, 128) == -1)
    95.     {
    96.         perror("listen error");
    97.         return -1;
    98.     }
    99.     printf("listen success\n");
    100.  
    101.     //4、阻塞等待客户端连接请求
    102.     //定义地址信息结构体变量用于接受客户端的地址信息
    103.     struct sockaddr_in cin;
    104.     socklen_t socklen = sizeof(cin);     //接受地址信息的长度
    105.     
    106.     while(1)
    107.     {
    108.         int newfd = accept(sfd, (struct sockaddr*)&cin, &socklen);
    109.         if(newfd == -1)
    110.         {
    111.             perror("accept error");
    112.             return -1;
    113.         }
    114.  
    115.         printf("[%s:%d]:已连接, newfd = %d\n",\
    116.                 inet_ntoa(cin.sin_addr), ntohs(cin.sin_port) ,newfd);    //4
    117.  
    118.         //定义用于传参的变量
    119.         struct MsgInfo info = {newfd, cin};
    120. 	  //创建分支线程用于通信
    121.         pthread_t tid = -1;
    122.         if(pthread_create(&tid, NULL, deal_cli_msg, &info) != 0)
    123.         {
    124.             printf("线程创建失败\n");
    125.             return -1;
    126.         }
    127.         //回收分支线程的资源
    128. 		pthread_detach(tid);
    129.  
    130.     }
    131.  
    132.     close(sfd);
    133.  
    134.  
    135.     return 0;
    136. }

    1. //流式域套接字服务器端
    2. #include<myhead.h>
    3. int main(int argc, const char *argv[])
    4. {
    5.     //1、创建套节字：用于接收客户端链接请求的
    6.     int sfd = socket(AF_UNIX, SOCK_STREAM, 0);
    7.     if(sfd == -1)
    8.     {
    9.         perror("socket error");
    10.         return -1;
    11.     }
    12.     printf("socket success sfd = %d\n", sfd);     //3
    13.  
    14.     //判断要绑定的套接字文件是否存在，如果存在，需要将其删除
    15.     if(access("./unix", F_OK) == 0)
    16.     {
    17.         //说明文件存在，需要将其删除
    18.         if(unlink("./unix") != 0)
    19.         {
    20.             perror("unlink error");
    21.             return -1;
    22.         }
    23.     }
    24.  
    25.     //2、绑定套接字文件
    26.     //2.1 填充地址信息结构体
    27.     struct sockaddr_un sun;
    28.     sun.sun_family = AF_UNIX;    //通信域
    29.     strcpy(sun.sun_path , "./unix");    //套接字文件
    30.  
    31.  
    32.     //2.2 绑定工作
    33.     if( bind(sfd, (struct sockaddr*)&sun, sizeof(sun)) ==-1)
    34.     {
    35.         perror("bind error");
    36.         return -1;
    37.     }
    38.     printf("bind success\n");
    39.  
    40.  
    41.     //3、讲套节字设置成被动监听状态
    42.     if( listen(sfd, 128) == -1)
    43.     {
    44.         perror("listen error");
    45.         return -1;
    46.     }
    47.     printf("listen success\n");
    48.  
    49.     //4、阻塞等待客户端连接请求
    50.     //定义地址信息结构体变量用于接受客户端的地址信息
    51.     struct sockaddr_un cun;
    52.     socklen_t socklen = sizeof(cun);     //接受地址信息的长度
    53.     
    54.     int newfd = accept(sfd, (struct sockaddr*)&cun, &socklen);
    55.     if(newfd == -1)
    56.     {
    57.         perror("accept error");
    58.         return -1;
    59.     }
    60.  
    61.     printf("[%s]:已连接, newfd = %d\n", cun.sun_path,newfd);    //4
    62.  
    63.     //5、数据通信
    64.     char rbuf[128] = "";       //用于接受消息
    65.     while(1)
    66.     {
    67.         bzero(rbuf, sizeof(rbuf));    //清空容器
    68.         //从套接字文件中读取消息
    69.         //int ret = read(newfd, rbuf, sizeof(rbuf));
    70.         int ret = recv(newfd, rbuf, sizeof(rbuf), 0);
    71.         if(ret == 0)
    72.         {
    73.             printf("客户端已下线\n");
    74.             break;
    75.         }
    76.         printf("[%s]: %s\n", cun.sun_path ,rbuf );
    77.  
    78.         //将字符串加个笑脸回回去
    79.         strcat(rbuf, "*_*");
    80.         //write(newfd, rbuf, strlen(rbuf));
    81.         send(newfd, rbuf, strlen(rbuf), 0);
    82.         printf("发送成功\n");
    83.  
    84.     }
    85.     //6、关闭套接字
    86.     close(newfd);
    87.     close(sfd);
    88.  
    89.     return 0;
    90. }

    1. //报式域套接字服务器端
    2. #include<myhead.h>
    3. int main(int argc, const char *argv[])
    4. {
    5.     //1、创建用于通信的套接字文件描述符
    6.     int sfd = socket(AF_UNIX, SOCK_DGRAM, 0);
    7.     if(sfd == -1)
    8.     {
    9.         perror("socket error");
    10.         return -1;
    11.     }
    12.     printf("socket success sfd = %d\n", sfd);         //3
    13.  
    14.     //判断要绑定的套接字文件是否存在，如果存在，需要将其删除
    15.     if(access("./unix", F_OK) == 0)
    16.     {
    17.         //说明文件存在，需要将其删除
    18.         if(unlink("./unix") != 0)
    19.         {
    20.             perror("unlink error");
    21.             return -1;
    22.         }
    23.     }
    24.     //2、绑定IP地址和端口号
    25.     //2.1 填充地址信息结构体
    26.     struct sockaddr_un sun;
    27.     sun.sun_family = AF_UNIX;       //协议族
    28.     strcpy(sun.sun_path, "./unix");   //服务器的套接字文件
    29.  
    30.     //2.2 绑定工作
    31.     if(bind(sfd, (struct sockaddr*)&sun, sizeof(sun)) == -1)
    32.     {
    33.         perror("bind error");
    34.         return -1;
    35.     }
    36.     printf("bind success\n");
    37.  
    38.     //3、数据的收发
    39.     //定义变量接收客户端地址信息结构体
    40.     struct sockaddr_un cun;
    41.     socklen_t socklen = sizeof(cun);
    42.  
    43.     char rbuf[128] = "";
    44.     while(1)
    45.     {
    46.         bzero(rbuf, sizeof(rbuf));
    47.  
    48.         //读取套接字中的数据
    49.         recvfrom(sfd, rbuf, sizeof(rbuf), 0, (struct sockaddr*)&cun, &socklen);
    50.         printf("[%s]：%s\n",cun.sun_path, rbuf);
    51.  
    52.         //加个笑脸将消息回回去
    53.         strcat(rbuf, "*_*");
    54.         if(sendto(sfd, rbuf, strlen(rbuf), 0, (struct sockaddr*)&cun, sizeof(cun)) ==-1)
    55.         {
    56.             perror("write error");
    57.             return -1;
    58.         }
    59.         printf("发送成功\n");
    60.  
    61.     }
    62.  
    63.     //4、关闭套接字
    64.     close(sfd);
    65.  
    66.     return 0;
    67. }

    通过TFTP用UDP实现上传和下载文件

    1. #include 
    2. #define SER_IP "192.168.125.99"
    3. #define SER_PORT 69
    4. #define IP "192.168.125.173"
    5. #define PORT 8888
    6. void download(char data[],short* p1,char* p2){
    7. 		char filename[128]="";
    8. 		printf("请输入要下载的文件名:");
    9. 		fgets(filename,sizeof(filename),stdin);
    10. 		filename[strlen(filename)-1]=0;
    11. 		int fp=open(filename,O_WRONLY | O_CREAT|O_TRUNC, 0664);//创建文件
    12. 		if(fp==-1){
    13. 			perror("open error");
    14. 			return ;
    15. 		}
    16. 		*p1=htons(1);//下载
    17. 		strcpy(p2,filename);
    18. 		char* p4=p2+strlen(filename)+1;
    19. 		strcpy(p4,"octet");
    20. 		int len=4+strlen(filename)+strlen("octet");
    21. 		printf("%s\n",p2);
    22. 		int sfd=socket(AF_INET,SOCK_DGRAM,0);
    23. 		if(sfd==-1){
    24. 			perror("socket error");
    25. 			return ;
    26. 		}
    27. 		struct sockaddr_in rin;
    28.     	rin.sin_family=AF_INET;
    29. 		rin.sin_port=htons(PORT);
    30. 		rin.sin_addr.s_addr=inet_addr(IP);
    31. 		if(bind(sfd,(struct sockaddr*)&rin,sizeof(rin))==-1){
    32. 			perror("bind error");
    33. 			return ;
    34. 		}
    35. 		printf("bind success\n");
    36. 		struct sockaddr_in sin;
    37.     	sin.sin_family=AF_INET;
    38. 		sin.sin_port=htons(SER_PORT);
    39. 		sin.sin_addr.s_addr=inet_addr(SER_IP);	
    40. 		socklen_t sin_size = sizeof(sin);  
    41. 		//发送下载请求
    42. 		sendto(sfd,data,len,0,(struct sockaddr*)&sin,sizeof(sin));
    43. 		char buf[516];
    44. 		short ack[2];
    45. 		ack[0]=htons(4);
    46. 		int res;
    47. 		while(1){
    48. 			bzero(buf,sizeof(buf));
    49. 			//接收数据到buf
    50. 			res=recvfrom(sfd, buf, sizeof(buf), 0, (struct sockaddr*)&sin, &sin_size);
    51. 			//返回接收数据字节数
    52. 			//从返回数据包中取出块编号，放到ack中去
    53. 			ack[1]=*(short*)(buf+2);
    54. 			
    55. 			//返回ACK确认
    56. 			
    57. 			sendto(sfd, ack, sizeof(ack), 0, (struct sockaddr*)&sin, sin_size);
    58. 			//将buf中的数据写到文件
    59. 			write(fp,buf+4,res-4);//写res-4个数据从buf+4位置到文件
    60. 			if(res!=516){
    61. 				break;
    62. 			}
    63. 		}
    64. 		close(fp);
    65. }
    66. void transmit(char data[],short* p1,char* p2){
    67. 	char filename[128]="";
    68. 	printf("请输入要上传的文件名:");
    69. 	fgets(filename,sizeof(filename),stdin);
    70. 	filename[strlen(filename)-1]=0;
    71. 	*p1=htons(2);//写，上传请求
    72. 	int fp=open(filename,O_RDONLY, 0664);//打开文件
    73. 	strcpy(p2,filename);
    74. 	char* p4=p2+strlen(filename)+1;
    75. 	strcpy(p4,"octet");
    76. 	int len=4+strlen(filename)+strlen("octet");
    77. 	int sfd=socket(AF_INET,SOCK_DGRAM,0);
    78. 		if(sfd==-1){
    79. 			perror("socket error");
    80. 			return ;
    81. 		}
    82. 		struct sockaddr_in rin;
    83.     	rin.sin_family=AF_INET;
    84. 		rin.sin_port=htons(PORT);
    85. 		rin.sin_addr.s_addr=inet_addr(IP);
    86. 		if(bind(sfd,(struct sockaddr*)&rin,sizeof(rin))==-1){
    87. 			perror("bind error");
    88. 			return ;
    89. 		}
    90. 		printf("bind success\n");
    91. 		struct sockaddr_in sin;
    92.     	sin.sin_family=AF_INET;
    93. 		sin.sin_port=htons(SER_PORT);
    94. 		sin.sin_addr.s_addr=inet_addr(SER_IP);	
    95. 		socklen_t sin_size = sizeof(sin);  
    96. 		//发送下载请求
    97. 		sendto(sfd,data,len,0,(struct sockaddr*)&sin,sizeof(sin));
    98. 		int count=1;
    99. 		*p1=htons(3);
    100. 		short* p10=data+2;
    101. 		while(1){
    102. 			*p10=htons(count);
    103. 			int ress=read(fp,data+4,512);
    104. 			if(ress==0){break;}
    105. 			sendto(sfd, data, sizeof(data), 0, (struct sockaddr*)&sin, sin_size);
    106. 			count++;
    107.  
    108.  
    109. 		}
    110.  
    111. 	close(fp);
    112. }
    113. int main(int argc, const char *argv[])
    114. {
    115.  
    116. 	printf("1.下载2.上传");
    117. 	printf("请输入>>>");
    118. 	int flag=0;
    119. 	scanf("%d",&flag);
    120. 	while(getchar()!=10);
    121. 	char data[516]="";
    122. 	short* p1=data;
    123. 	char* p2=data+2;
    124. 	if(flag==1){
    125. 		download(data,p1,p2);
    126. 	}else if(flag==2){
    127. 		transmit(data,p1,p2);
    128. 	}
    129. 	
    130. 	return 0;
    131. }

  • 相关阅读:
    Django与Ajax
    【路径规划-TSP问题】基于遗传算法求解多起点多TSP问题附matlab代码
    达拉斯市（Dallas）利用 OpenText 安全解决方案加速信息发现
    Vue3 企业级优雅实战 - 组件库框架 - 6 搭建example环境
    Go编译原理系列8（变量捕获）
    “CarrotMovement“ app Tech Support（URL）
    STM32F407ZGT6移植HC-05蓝牙模块
    皕杰报表之控件元素
    队列的实现和OJ练习（c语言）
    【Gazebo入门教程】第一讲 Gazebo的安装、UI界面、SDF文件介绍
  • 原文地址：https://blog.csdn.net/m0_67764503/article/details/137836133