• 用进程和线程完成TCP进行通信操作及广播和组播的通信

    进程

    代码

    1.  #include <stdio.h>
    2.  #include <sys/types.h>
    3.  #include <sys/socket.h>
    4.  #include <netinet/in.h>
    5.  #include <arpa/inet.h>
    6.  #include <string.h>
    7.  #include <unistd.h>
    8.  #include <stdlib.h>
    9.  #include <signal.h>
    10.  #include <sys/wait.h>
    11.  
    12.  #define PORT 8888
    13.  #define IP "192.168.124.62"                                                                                                           
    14.  #define ERR_MSG(msg) do{\
    15.      fprintf(stderr,"line=%d",__LINE__);\
    16.      perror(msg);\
    17.  }while(0)
    18.  void handler(int sig)
    19.  {
    20.      while(waitpid(-1,NULL,WNOHANG)>0);
    21.  }
    22.  int main(int argc, const char *argv[])
    23.  {
    24.      //创建套接字
    25.      int fd = socket(AF_INET,SOCK_STREAM,0);
    26.      if(fd<0)
    27.      {
    28.          ERR_MSG("socket");
    29.          return -1;
    30.      }
    31.      printf("-流式套接字\n");
    32.      //捕获17号信息SIGCHLD
    33.      if(signal(17,handler) == SIG_ERR)
    34.      {
    35.          ERR_MSG("signal");
    36.          return -1;
    37.      }
    38.  
    39.      //允许端口号重复使用
    40.      int reuse = 1;
    41.      if(setsockopt(fd,SOL_SOCKET,SO_REUSEADDR,&reuse,sizeof(reuse))<0)
    42.      {
    43.          ERR_MSG("setsockopt");
    44.          return -1;
    45.      }
    46.      printf("端口允许快速重用\n");
    47.      //创建一个地址信息结构体,bind绑定需要用到
    48.      struct sockaddr_in sin;
    49.      sin.sin_family = AF_INET;
    50.      sin.sin_port   = htons(PORT);
    51.      sin.sin_addr.s_addr = inet_addr(IP);
    52.      //绑定ip和端口
    53.      if(bind(fd,(struct sockaddr*)&sin,sizeof(sin))<0)
    54.      {
    55.          ERR_MSG("bind");
    56.          return -1;
    57.      }
    58.      printf("绑定成功\n");
    59.  
    60.      //将套接字设置为监听状态
    61.      if(listen(fd,128)<0)
    62.      {
    63.          ERR_MSG("listen");
    64.          return -1;
    65.      }
    66.      printf("监听成功\n");
    67.  
    68.      int newfd;
    69.      pid_t pid;
    70.      struct sockaddr_in cin;
    71.      socklen_t socklen = sizeof(cin);
    72.  
    73.  while(1)
    74.  {
    75.      //获取连接成功的套接字,用于阻塞等待连接
    76.      newfd = accept(fd,(struct sockaddr*)&cin,&socklen);
    77.      if(newfd <0)
    78.      {
    79.          ERR_MSG("accept");
    80.          return -1;
    81.      }
    82.      printf("[%s:%d]客户端连接成功%d\n",inet_ntoa(sin.sin_addr),ntohs(sin.sin_port),newfd);
    83.  
    84.      pid = fork();
    85.      if(pid == 0)
    86.      {
    87.          close(fd);
    88.          //接收与发送
    89.          char buf[128];
    90.          ssize_t size;
    91.          while(1)
    92.          {
    93.              //接收
    94.              //
    95.              bzero(buf,sizeof(buf));//清空数组内容
    96.      //      size = read(newfd,buf,sizeof(buf));
    97.              size = recv(newfd,buf,sizeof(buf),0);
    98.      //      size = recvfrom(newfd,buf,sizeof(buf),0,NULL,NULL);
    99.              if(size<0)
    100.              {
    101.                  ERR_MSG("recv");
    102.                  return -1;
    103.              }else if(size==0)
    104.              {
    105.                  printf("[%s:%d]客户端下线\n",inet_ntoa(sin.sin_addr),ntohs(sin.sin_port));
    106.                  break;
    107.              }
    108.              printf("[%s:%d]接收成功newfd=%d:%s\n",inet_ntoa(sin.sin_addr),ntohs(sin.sin_port),newfd,buf);
    109.  
    110.  
    111.              //发送
    112.              printf("服务器回复>>>>");
    113.              fgets(buf,sizeof(buf),stdin);
    114.              buf[strlen(buf)-1] = '\0';
    115.  
    116.              if(send(newfd,buf,sizeof(buf),0)<0)
    117.              {
    118.                  ERR_MSG("send");
    119.                  break;
    120.              }
    121.              printf("发送成功\n");
    122.          }
    123.          close(newfd);
    124.          exit(0);
    125.      }
    126.      close(newfd);
    127.  }
    128.      close(fd);
    129.  
    130.      return 0;
    131.  }

    运行结果图：

    线程

    代码：

    1.   1 #include <stdio.h>
    2.   2 #include <sys/types.h>
    3.   3 #include <sys/socket.h>
    4.   4 #include <netinet/in.h>
    5.   5 #include <arpa/inet.h>
    6.   6 #include <string.h>
    7.   7 #include <unistd.h>
    8.   8 #include <stdlib.h>
    9.   9 #include <signal.h>
    10.  10 #include <sys/wait.h>
    11.  11 #include <pthread.h>
    12.  12 
    13.  13 #define PORT 8888
    14.  14 #define IP "192.168.124.62"
    15.  15 #define ERR_MSG(msg) do{\
    16.  16     fprintf(stderr,"line=%d",__LINE__);\
    17.  17     perror(msg);\
    18.  18 }while(0)
    19.  19 
    20.  20 struct msg
    21.  21 {
    22.  22     int newfd;
    23.  23     struct sockaddr_in cin;
    24.  24 };
    25.  25 void* huidiaolist(void* arg);
    26.  26 int main(int argc, const char *argv[])
    27.  27 {
    28.  28     //创建套接字
    29.  29     int fd = socket(AF_INET,SOCK_STREAM,0);
    30.  30     if(fd<0)
    31.  31     {
    32.  32         ERR_MSG("socket");
    33.  33         return -1;
    34.  34     }
    35.  35     printf("-流式套接字\n");
    36.  36     //允许端口号重复使用
    37.  37     int reuse = 1;
    38.  38     if(setsockopt(fd,SOL_SOCKET,SO_REUSEADDR,&reuse,sizeof(reuse))<0)
    39.  39     {
    40.  40         ERR_MSG("setsockopt");
    41.  41         return -1;
    42.  42     }
    43.  43     printf("端口允许快速重用\n");
    44.  44     //创建一个地址信息结构体,bind绑定需要用到
    45.  45     struct sockaddr_in sin;
    46.  46     sin.sin_family = AF_INET;
    47.  47     sin.sin_port   = htons(PORT);
    48.  48     sin.sin_addr.s_addr = inet_addr(IP);
    49.  49     //绑定ip和端口
    50.  50     if(bind(fd,(struct sockaddr*)&sin,sizeof(sin))<0)
    51.  51     {
    52.  52         ERR_MSG("bind");
    53.  53         return -1;
    54.  54     }
    55.  55     printf("绑定成功\n");
    56.  56 
    57.  57     //将套接字设置为监听状态
    58.  58     if(listen(fd,128)<0)
    59.  59     {
    60.  60         ERR_MSG("listen");
    61.  61         return -1;
    62.  62     }
    63.  63     printf("监听成功\n");
    64.  64 
    65.  65     int newfd;
    66.  66     pid_t pid;
    67.  67     struct sockaddr_in cin;
    68.  68     socklen_t socklen = sizeof(cin);
    69.  69 
    70.  70     pthread_t tid;
    71.  71     struct msg  clinfo;
    72.  72     while(1)
    73.  73     {
    74.  74         //获取连接成功的套接字,用于阻塞等待连接
    75.  75         newfd = accept(fd,(struct sockaddr*)&cin,&socklen);
    76.  76         if(newfd <0)
    77.  77         {
    78.  78             ERR_MSG("accept");
    79.  79             return -1;
    80.  80         }
    81.  81         printf("[%s:%d]客户端连接成功%d\n",\
    82.  82                 inet_ntoa(sin.sin_addr),ntohs(sin.sin_port),newfd);
    83.  83 
    84.  84         clinfo.newfd = newfd;
    85.  85         clinfo.cin = cin;
    86.  86         if(pthread_create(&tid,NULL,huidiaolist,(void*)&clinfo)!=0)
    87.  87         {
    88.  88             fprintf(stderr,"line=%d",__LINE__);
    89.  89             break;
    90.  90         }
    91.  91         pthread_detach(tid);
    92.  92     }
    93.  93     close(fd);
    94.  94 
    95.  95 return 0;
    96.  96 }
    97.  97 
    98.  98 void* huidiaolist(void* arg)
    99.  99 {
    100. 100          //接收与发送
    101. 101          int newfd = ((struct msg*)arg)->newfd;
    102. 102          struct sockaddr_in cin = ((struct msg*)arg)->cin;
    103. 103 
    104. 104          char buf[128];
    105. 105          ssize_t size;
    106. 106          while(1)
    107. 107          {
    108. 108              //接收
    109. 109              //
    110. 110              bzero(buf,sizeof(buf));//清空数组内容
    111. 111      //      size = read(newfd,buf,sizeof(buf));
    112. 112              size = recv(newfd,buf,sizeof(buf),0);
    113. 113      //      size = recvfrom(newfd,buf,sizeof(buf),0,NULL,NULL);
    114. 114              if(size<0)
    115. 115              {
    116. 116                  ERR_MSG("recv");
    117. 117                  break;
    118. 118              }else if(size==0)
    119. 119              {
    120. 120                  printf("[%s:%d]客户端下线\n",\
    121. 121                          inet_ntoa(cin.sin_addr),ntohs(cin.sin_port));
    122. 122                  break;
    123. 123              }
    124. 124              printf("[%s:%d]接收成功newfd=%d:%s\n",\
    125. 125                      inet_ntoa(cin.sin_addr),ntohs(cin.sin_port),newfd,buf);
    126. 126 
    127. 127 
    128. 128              //发送
    129. 129              strcpy(buf,"回复");
    130. 130              if(send(newfd,buf,sizeof(buf),0)<0)
    131. 131              {
    132. 132                  ERR_MSG("send");
    133. 133                  break;
    134. 134              }
    135. 135              printf("发送成功\n");
    136. 136          }
    137. 137     close(newfd);
    138. 138     pthread_exit(NULL);

    结果图：

    广播

    1. #include <stdio.h>
    2. #include <sys/types.h>
    3. #include <sys/socket.h>
    4. #include <netinet/in.h>
    5. #include <string.h>
    6. #include <arpa/inet.h>
    7. #include <unistd.h>
    8.  
    9. #define PORT 6667
    10. #define IP "192.168.124.255"
    11. #define ERR_MSG(msg) do{\
    12.     fprintf(stderr,"line:%d\n",__LINE__);\
    13.     perror(msg);\
    14. }while(0)
    15.  
    16.  
    17. int main(int argc, const char *argv[])
    18. {
    19.     int fd = socket(AF_INET,SOCK_DGRAM,0);
    20.     if(fd<0)
    21.     {
    22.         ERR_MSG("scoket");
    23.         return -1;
    24.     }
    25.     printf("创建流式套接字成功cd=%d\n",fd);
    26.  
    27.  
    28.     //允许端口被重
    29.     int reuse = 1;
    30.     if(setsockopt(fd,SOL_SOCKET,SO_REUSEADDR,&reuse,sizeof(reuse))<0)
    31.     {
    32.         ERR_MSG("setsockopt");
    33.         return -1;
    34.     }
    35.     printf("允许端口被重复使用\n");
    36.     //允许广播
    37.     if(setsockopt(fd,SOL_SOCKET,SO_BROADCAST,&reuse,sizeof(reuse))<0)
    38.     {
    39.         ERR_MSG("setsockopt");
    40.         return -1;
    41.     }
    42.     //绑定服务器地址信息,必须绑定
    43.     struct sockaddr_in sin;
    44.     sin.sin_family     = AF_INET;
    45.     sin.sin_port       = htons(PORT);
    46.     sin.sin_addr.s_addr= inet_addr(IP);
    47.     //绑定IP及端口号
    48.     if(bind(fd,(struct sockaddr*)&sin,sizeof(sin))<0)
    49.     {
    50.         ERR_MSG("bind");
    51.         return -1;
    52.     }
    53.     printf("绑定成功\n");
    54.  
    55.     char arr[128];
    56.     struct sockaddr_in cin;
    57.     socklen_t addrlen = sizeof(arr);
    58.     while(1)
    59.     {
    60.         //发送数据
    61.         printf("请输入数据>>>>>");
    62.         fgets(arr,sizeof(arr),stdin);
    63.         arr[strlen(arr)-1] = '\0';
    64.         if(sendto(fd,arr,sizeof(arr),0,\
    65.                     (struct sockaddr*)&sin,sizeof(sin))<0)                  
    66.         {
    67.             ERR_MSG("sendto");
    68.             return -1;
    69.         }
    70.         printf("发送成功\n");
    71.         bzero(arr,sizeof(arr));
    72.     }
    73.     close(fd);
    74.     return 0;
    75. }

    组播

    1. #include <stdio.h>
    2. #include <sys/types.h>
    3. #include <sys/socket.h>
    4. #include <netinet/in.h>
    5. #include <string.h>
    6. #include <arpa/inet.h>
    7. #include <unistd.h>
    8.  
    9. #define PORT 6667
    10. #define IP "224.1.2.3"
    11. #define ERR_MSG(msg) do{\
    12.     fprintf(stderr,"line:%d\n",__LINE__);\
    13.     perror(msg);\
    14. }while(0)
    15.  
    16.  
    17. int main(int argc, const char *argv[])
    18. {
    19.     int fd = socket(AF_INET,SOCK_DGRAM,0);
    20.     if(fd<0)
    21.     {
    22.         ERR_MSG("scoket");
    23.         return -1;                                                    
    24.     }
    25.     printf("创建流式套接字成功cd=%d\n",fd);
    26.  
    27.  
    28.     //允许端口被重
    29.     int reuse = 1;
    30.     if(setsockopt(fd,SOL_SOCKET,SO_REUSEADDR,&reuse,sizeof(reuse))<0)
    31.     {
    32.         ERR_MSG("setsockopt");
    33.         return -1;
    34.     }
    35.     printf("允许端口被重复使用\n");
    36.     //允许广播
    37.     if(setsockopt(fd,SOL_SOCKET,SO_BROADCAST,&reuse,sizeof(reuse))<0)
    38.     {
    39.         ERR_MSG("setsockopt");
    40.         return -1;
    41.     }
    42.     //绑定服务器地址信息,必须绑定
    43.     struct sockaddr_in sin;
    44.     sin.sin_family     = AF_INET;
    45.     sin.sin_port       = htons(PORT);
    46.     sin.sin_addr.s_addr= inet_addr(IP);
    47.     //绑定IP及端口号
    48.     if(bind(fd,(struct sockaddr*)&sin,sizeof(sin))<0)
    49.     {
    50.         ERR_MSG("bind");
    51.         return -1;
    52.     }
    53.     printf("绑定成功\n");
    54.  
    55.     char arr[128];
    56.     struct sockaddr_in cin;
    57.     socklen_t addrlen = sizeof(arr);
    58.     while(1)
    59.     {
    60.  
    61.         //发送数据 
    62.         printf("请输入数据>>>>>");
    63.         fgets(arr,sizeof(arr),stdin);
    64.         arr[strlen(arr)-1] = '\0';
    65.         if(sendto(fd,arr,sizeof(arr),0,\
    66.                     (struct sockaddr*)&sin,sizeof(sin))<0)
    67.         {
    68.             ERR_MSG("sendto");
    69.             return -1;
    70.         }
    71.         printf("发送成功\n");
    72.         bzero(arr,sizeof(arr));
    73.     }
    74.     close(fd);
    75.     return 0;
    76. }
    77.

  • 相关阅读:
    计算机二级python简单应用题刷题笔记（一）
    Visual Studio Code如何写C语言
    可编程 USB 转串口适配器开发板芯片驱动文件说明
    docker系统笔记-03镜像的创建管理和发布
    关于到年底日常生活的工作计划
    新概念英语（第二册）复习——Lesson 16 - Lesson20
    【Java 基础篇】Java标准输入流详解：读取用户输入的完整指南
    SpringCloud之Nacos配置中心解读
    Word参考文献交叉引用
    基于javaweb的农业信息管理系统(java+ssm+jsp+js+html+mysql)
  • 原文地址：https://blog.csdn.net/qq_42129915/article/details/139868295