基于TCP的客户端--服务器

1040阅读　0评论2014-10-27　lt6419
分类：嵌入式

服务器端代码实现：

点击(此处)折叠或打开

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <signal.h>
  4. #include <sys/socket.h>
  5. #include <netinet/in.h>
  6. #include <arpa/inet.h>

  8. //信号的处理非常类似于中断的处理，当有信号产生时，执行这个函数
  9. void handler_signal(int signum)
  10. {
  11.     //非阻塞方式调用，有子进程退出时，对子进程进行收尸
  12.     waitpid(-1,NULL,WNOHANG);
  13.     return ;
  14. }

  16. int do_client(int connect_fd)
  17. {
  18.     int n;
  19.     char buf[1024];
  20.     
  21.     while(1)
  22.     {
  23.         n = read(connect_fd,buf,sizeof(buf) - 1);
  24.         if(n <= 0)
  25.             break;

  27.         buf[n] = '\0';
  28.         printf("Read %d bytes : %s\n",n,buf);
  29.     
  30.         if(strncmp(buf,"quit",4)==0)
  31.             break;
  32.     }

  34.     //子进程直接退出，让父进程对其收尸
  35.     exit(EXIT_SUCCESS);
  36. }

  38. //./server ip port
  39. int main(int argc, const char *argv[])
  40. {
  41.     int pid;
  42.     int sockfd;
  43.     int connect_fd;
  44.     struct sockaddr_in server_addr;
  45.     struct sockaddr_in peer_addr;
  46.     socklen_t addrlen = sizeof(struct sockaddr);

  48.     if(argc < 3)
  49.     {
  50.         fprintf(stderr,"Usage : %s \n",argv[0]);
  51.         exit(EXIT_FAILURE);
  52.     }

  54.     //为了防止将尸态子进程的出现，子进程退出时，父进程需要对子进程收尸
  55.     //设置SIGCHLD信号处理方式:捕捉
  56.     if(signal(SIGCHLD,handler_signal) == SIG_ERR)
  57.     {
  58.         perror("Fail to signal");
  59.         exit(EXIT_FAILURE);
  60.     }

  62.     //1.创建流式套接字
  63.     sockfd = socket(AF_INET,SOCK_STREAM,0);
  64.     if(sockfd < 0){
  65.         perror("Fail to socket");
  66.         exit(EXIT_FAILURE);
  67.     }

  69.     //2.填充服务器的IP地址和端口信息
  70.     server_addr.sin_family = AF_INET;
  71.     server_addr.sin_port = htons(atoi(argv[2]));
  72.     server_addr.sin_addr.s_addr = inet_addr(argv[1]);
  73.     //3.把服务器的端口和IP地址信息和流式套接字绑定
  74.     if(bind(sockfd,(struct sockaddr *)&server_addr,sizeof(server_addr)) < 0)
  75.     {
  76.         perror("Fail to bind");
  77.         exit(EXIT_FAILURE);
  78.     }

  80.     //4.设置流式套接字为监听模式
  81.     //在服务器端的某个应用程序需要一种状态去等候客户端的通信邀请，这种状态称之
  82.     //为“监听”，监听本身不具备连接的功能，它仅仅是一种等候。
  83.     listen(sockfd,128);

  85.     printf("listen ...\n");

  87.     while(1)
  88.     {
  89.         //在请求队列中提取客户端的请求，提取成功之后会新创建一个新客户端的套接字，
  90.         //这个新的套接字才是和客户端真正进行通信的套接字，而前面的套接字是用于实
  91.         //现监听的。
  92.         connect_fd = accept(sockfd,(struct sockaddr *)&peer_addr,&addrlen);
  93.         if(connect_fd < 0){
  94.             perror("Fail to accept");
  95.             exit(EXIT_FAILURE);
  96.         }

  98.         printf("connect_fd : %d\n",connect_fd);

  100.         printf("-----------------------------\n");
  101.         printf("Port : %d\n",ntohs(peer_addr.sin_port));
  102.         printf("Ip : %s\n",inet_ntoa(peer_addr.sin_addr));
  103.         printf("-----------------------------\n");

  105.         pid = fork();
  106.         if(pid < 0){
  107.             perror("Fail to fork");
  108.             exit(EXIT_FAILURE);
  109.         }

  111.         if(pid == 0)
  112.         {
  113.             //子进程中读取客户端的发送的数据，并且把父进程中拷贝过来的监听的套接字关闭
  114.             close(sockfd);
  115.             do_client(connect_fd);
  116.         }
  117.     
  118.         //为了防止文件描述符浪费，父子进程在最后执行完之后都应该关闭已经打开的文件描述符
  119.         close(connect_fd);
  120.     }
  121.     
  122.     return 0;
  123. }
客户端代码实现：

点击(此处)折叠或打开

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <sys/socket.h>
  4. #include <netinet/in.h>
  5. #include <arpa/inet.h>

  7. //./server ip port
  8. int main(int argc, const char *argv[])
  9. {
  10.     int n;
  11.     int sockfd;
  12.     int connect_fd;
  13.     char buf[1024];
  14.     struct sockaddr_in server_addr;
  15.     struct sockaddr_in peer_addr;
  16.     socklen_t addrlen = sizeof(struct sockaddr);

  18.     if(argc < 3)
  19.     {
  20.         fprintf(stderr,"Usage : %s \n",argv[0]);
  21.         exit(EXIT_FAILURE);
  22.     }

  24.     //1.创建流式套接字
  25.     sockfd = socket(AF_INET,SOCK_STREAM,0);
  26.     if(sockfd < 0){
  27.         perror("Fail to socket");
  28.         exit(EXIT_FAILURE);
  29.     }

  31.     //2.填充服务器IP地址和端口信息
  32.     server_addr.sin_family = AF_INET;
  33.     server_addr.sin_port = htons(atoi(argv[2]));
  34.     server_addr.sin_addr.s_addr = inet_addr(argv[1]);
  35.     //3.链接服务器(实质上是完成3次握手，链接成功之后Linux内核会把请求放置在内核的请求队列中)
  36.     // 特别注意:这个函数仅仅只在客户端使用，主要的目的就是完成和服务器的3次握手
  37.     if(connect(sockfd,(struct sockaddr *)&server_addr,sizeof(server_addr)) < 0)
  38.     {
  39.         perror("Fail to connect");
  40.         exit(EXIT_FAILURE);
  41.     }

  43.     while(1)
  44.     {
  45.         printf("client >");
  46.         fgets(buf,sizeof(buf),stdin);
  47.         buf[strlen(buf) - 1] = '\0';

  49.         //给服务器发送数据
  50.         n = write(sockfd,buf,strlen(buf));
  51.         if(n < 0){
  52.             perror("Fail to write");
  53.             exit(EXIT_FAILURE);
  54.         }
  55.     }
  56.     
  57.     return 0;
  58. }
运行测试结果如下：

点击(此处)折叠或打开

  1. ubuntu@ubuntu:~/network_teacher/day02/tcp/server$ ./server 192.168.127.131 8888
  2. listen ...
  3. connect_fd : 4
  4. -----------------------------
  5. Port : 53984
  6. Ip : 192.168.127.131
  7. -----------------------------
  8. Read 6 bytes : hello
  9. Read 5 bytes : world
  10. Read 3 bytes : xxx

点击(此处)折叠或打开

  1. ubuntu@ubuntu:~/network_teacher/day02/tcp/client$ ./client 192.168.127.131 8888
  2. client >hello
  3. client >world
  4. client >xxx
  5. client >
上一篇：自己实现的基于UDP的客户端--服务器
下一篇：TCP并发服务器的实现