Chinaunix首页 | 论坛 | 博客

jackywgw的ChinaUnix博客

首页　| 　博文目录　| 　关于我

jackywgw

  • 博客访问： 535704
  • 博文数量： 142
  • 博客积分： 0
  • 博客等级： 民兵
  • 技术积分： 1452
  • 用 户 组： 普通用户
  • 注册时间： 2013-09-12 16:28
文章分类

全部博文（142）

文章存档

2016年（10）

2015年（60）

2014年（72）

我的朋友
最近访客
推荐博文
相关博文
TCP客户/服务器回射程序

分类： C/C++

2014-09-26 15:17:43


一、正常启动
1.启动服务器
./tcpserver
gwwu@hz-dev2.wgw.com:~/test/socket>netstat -a -n -t
Active Internet connections (servers and established)
Proto Recv-Q Send-Q Local Address               Foreign Address             State           
tcp        0      0 127.0.0.1:10000             0.0.0.0:*                   LISTEN    
服务器启动后，经过socket，bind，listen，阻塞于accept，等待客户端的连接。
gwwu@hz-dev2.wgw.com:~/test/socket>netstat -a -n -t
Active Internet connections (servers and established)
Proto Recv-Q Send-Q     Local Address               Foreign Address             State           
tcp        0          0        127.0.0.1:10000             0.0.0.0:*                   LISTEN    

2.启动客户端
./tcpclient
客户端调用socket，connect，connect引发三次握手。当三次握手结束，客户端的connect和服务器的accept均返回，连接建立。
(1)客户端调用str_cli阻塞于fgets
(2)服务器父进程阻塞于accept，等待新的客户来连接
(3)服务器子进程调用str_echo阻塞于read。

gwwu@hz-dev2.wgw.com:~/test/socket>netstat -a -n -t
Active Internet connections (servers and established)
Proto Recv-Q Send-Q Local Address               Foreign Address             State       
tcp        0        0        127.0.0.1:10000             0.0.0.0:*                   LISTEN      
tcp        0        0        127.0.0.1:10000             127.0.0.1:49277        ESTABLISHED 
tcp        0        0        127.0.0.1:49277             127.0.0.1:10000        ESTABLISHED 

使用ps命令来查看进程的状态和关系
gwwu@hz-dev2.wgw.com:~/test/socket>ps -t pts/12 -o pid,ppid,tty,stat,args,wchan 
  PID  PPID TT       STAT COMMAND                     WCHAN
17561 23965 pts/12   S+   ./tcpclient                 n_tty_read
23965 23957 pts/12   Ss   -bash                       wait
gwwu@hz-dev2.wgw.com:~/test/socket>ps -t pts/9 -o pid,ppid,tty,stat,args,wchan  
  PID  PPID TT       STAT COMMAND                     WCHAN
15339 15338 pts/9    Ss   -bash                       wait
17546 15339 pts/9    S+   ./tcpserver                 inet_csk_accept-----------服务器父进程
17562 17546 pts/9    S+   ./tcpserver                 sk_wait_data-----------服务器子进程

二、正常终止
连接建立以后，客户端输入啥，立即回射该内容
当在客户端输入CTRL+D(终端的EOF字符)时：
(1)客户端str_cli函数中的fgets返回NULL，str_cli函数退出，最终客户端退出，客户端进程退出，会close打开的socket描述符，这会导致客户端发送FIN报文给服务器。
(2)服务器收到客户端的FIN报文，read函数返回0，导致str_echo函数退出，最终服务端的子进程退出，关闭对应的socket套接字，发送FIN报文给客户端，并发送SIGCHLD信号给父进程，如果父进程没有响应该信号，则该子进程编程僵死进程。
gwwu@hz-dev2.wgw.com:~/test/socket>ps -t pts/9 -o pid,ppid,tty,stat,args,wchan
  PID  PPID TT       STAT COMMAND                     WCHAN
15339 15338 pts/9    Ss   -bash                       wait
17546 15339 pts/9    S+   ./tcpserver                 inet_csk_accept
17562 17546 pts/9    Z+   [tcpserver]       exit --------------------------------此为僵死进程

(3)客户端响应FIN报文，发送ACK，进入TIME_WAIT状态

tcpserver.c

点击(此处)折叠或打开

  1. #include <unistd.h>
  2. #include <stdio.h>
  3. #include <stdlib.h>
  4. #include <signal.h>
  5. #include <sys/socket.h>
  6. #include <sys/types.h>
  7. #include <sys/wait.h>
  8. #include <errno.h>
  9. #include <netinet/in.h>
  10. #include <arpa/inet.h>
  11. #include <sys/wait.h>
  12. #include <strings.h>
  13. #include "readn.h"

  15. /*read函数从套接字读入数据，writen函数把其中的内容回射给客户。如果客户关闭连接，那么接收到客户的FIN将导致服务器子进程的read函数返回0，这又导致str_echo函数的返回，从而终止了子进程*/
  16. void str_echo(int fd)
  17. {
  18.     int n;
  19.     char recvline[MAXLINE];
  20. again:
  21.     while((n = read(fd,recvline,MAXLINE))>0) {
  22.         writen(fd,recvline,n);
  23.     }
  24.     if(n < 0 && errno == EINTR) {
  25.         goto again;
  26.     }else if (n < 0) {
  27.         printf("read error\n");
  28.     }
  29. }

  31. int main(int argc,char *argv[])
  32. {
  33.     int ret = 0;
  34.     int listen_fd;
  35.     int conn_fd;
  36.     struct sockaddr_in server_addr;
  37.     struct sockaddr_in client_addr;
  38.     pid_t pid;
  39.     pid_t child_pid;
  40.     int status;
  41.     socklen_t len;

  43.     listen_fd = socket(AF_INET,SOCK_STREAM,0);

  45.     if(listen_fd < 0) {
  46.         printf("socket error\n");
  47.         return -1;
  48.     }

  50.     bzero(&server_addr,sizeof(struct sockaddr_in));

  52.     server_addr.sin_family = AF_INET;
  53.     server_addr.sin_port = htons(10000);
  54.     //server_addr.sin_addr.s_addr = inet_addr("127.0.0.1");
  55.     ret = inet_pton(AF_INET,"127.0.0.1",&server_addr.sin_addr.s_addr);
  56.     if(ret < 0) {
  57.         printf("inet_pton error\n");
  58.         close(listen_fd);
  59.         return ret;
  60.     }else if(ret == 0) {
  61.         printf("the second parameter of inet_addr is null\n");
  62.     }

  64.     if(bind(listen_fd,(struct sockaddr*)&server_addr,sizeof(struct sockaddr)) == -1) {
  65.             printf("bind error\n");
  66.             close(listen_fd);
  67.             return -1;
  68.     }
  69.     

  71.     if(listen(listen_fd,1024) == -1) {
  72.         printf("listen error\n");
  73.         close(listen_fd);
  74.         return -1;
  75.     }

  77.     for(;;) {
  78.         len = sizeof(client_addr);
  79.         conn_fd = accept(listen_fd,(struct sockaddr*)&client_addr,&len);
  80.         if(conn_fd < 0) {
  81.             printf("accept error,errno=%d\n",errno);
  82.             if(errno == EINTR)
  83.                 continue;
  84.             return -1;
  85.         }

  87.         pid = fork();

  89.         if(pid < 0) {
  90.             printf("fork error\n");
  91.             return -1;
  92.         }else if(pid == 0) {
  93.             close(listen_fd);
  94.             /*TODO::handle on conn_fd*/
  95.             str_echo(conn_fd);
  96.             exit(0);
  97.         }
  98.         close(conn_fd);
  99.         child_pid = waitpid(pid,&status,WNOHANG);
  100.         if(child_pid < 0)
  101.             printf("wait error\n");
  102.     }

  104.     return 0;
  105. }


tcpclient.c

点击(此处)折叠或打开

  1. #include <unistd.h>
  2. #include <stdio.h>
  3. #include <stdlib.h>
  4. #include <sys/socket.h>
  5. #include <string.h>
  6. #include <sys/types.h>
  7. #include <arpa/inet.h>
  8. #include "readn.h"

  10. void str_cli(FILE *fp,int fd)
  11. {
  12.     char sendline[1024], recvline[1024];

  14.     while(fgets(sendline,1024,fp)) {
  15.         writen(fd,sendline,strlen(sendline));
  16.         memset(recvline,0,sizeof(recvline));
  17.         readline(fd,recvline,sizeof(recvline));
  18.         fputs(recvline,stdout);
  19.     }
  20. }

  22. int main(int argc,char* argv[])
  23. {
  24.     int fd;
  25.     struct sockaddr_in server_addr;
  26.     int ret = 0;


  29.     fd = socket(AF_INET,SOCK_STREAM,0);

  31.     if(fd < 0) {
  32.         printf("socket error\n");
  33.         return -1;
  34.     }

  36.     bzero(&server_addr,sizeof(struct sockaddr_in));

  38.     server_addr.sin_family = AF_INET;
  39.     ret = inet_pton(AF_INET,"127.0.0.1",&server_addr.sin_addr);

  41.     if(ret < 0) {
  42.         printf("inet_pton error\n");
  43.         return -1;
  44.     }else if(ret == 0) {
  45.         printf("the second parameter of inet_pton is NULL\n");
  46.     }
  47.     server_addr.sin_port = htons(10000);

  49.     ret = connect(fd,(struct sockaddr*)&server_addr,sizeof(struct sockaddr));
  50.     if(ret < 0) {
  51.         printf("connect error\n");
  52.         return -1;
  53.     }

  55.     str_cli(stdin,fd);

  57.     return 0;
  58. }

readn.h

点击(此处)折叠或打开

  1. #ifndef __READN_H__
  2. #define __READN_H__
  3. #define MAXLINE 1024
  4. int readn(int fd, void* buffer, size_t n);
  5. int writen(int fd, void* buffer, size_t n);
  6. size_t readline(int fd, void * buffer, size_t maxlen);
  7. #endif
readn.c

点击(此处)折叠或打开

  1. #include <unistd.h>
  2. #include <signal.h>
  3. #include <stdio.h>
  4. #include <stdlib.h>
  5. #include <errno.h>
  6. #include "readn.h"

  8. int readn(int fd, void* buffer, size_t n)
  9. {
  10.     int nread;
  11.     int nleft;
  12.     char *ptr;

  14.     ptr = buffer;
  15.     nleft = n;
  16.     while(nleft >0) {
  17.         if((nread=read(fd,ptr,nleft)) < 0){
  18.             if(errno == EINTR) {
  19.                 nread = 0;
  20.                 continue;
  21.             }else {
  22.                 return -1;
  23.             }
  24.         }else if (nread==0) {
  25.             break;
  26.         }
  27.         ptr += nread;
  28.         nleft -= nread;
  29.     }
  30.     return (n - nleft);
  31. }

  33. int writen(int fd, void* buffer, size_t n)
  34. {
  35.     int nwrite;
  36.     int nleft;
  37.     char* ptr;

  39.     ptr = buffer;
  40.     nleft = n;
  41.     while(nleft > 0) {
  42.         if((nwrite = write(fd,ptr,nleft)) < 0) {
  43.             if(errno == EINTR) {
  44.                 nwrite = 0;
  45.                 continue;
  46.             }else {
  47.                 return -1;
  48.             }
  49.         }else if(nwrite == 0){
  50.             break;
  51.         }
  52.         ptr += nwrite;
  53.         nleft -= nwrite;
  54.     }
  55.     return (n-nleft);
  56. }
  57. static char *ptr;
  58. static int len = 0;
  59. char read_buffer[MAXLINE];
  60. ssize_t my_read(int fd, char* buffer)
  61. {
  62.     int nread;

  64.     if(len <= 0) {
  65. again:
  66.         if((nread = read(fd,read_buffer,MAXLINE)) < 0) {
  67.             if(errno == EINTR)
  68.                 goto again;
  69.             return -1;
  70.         }else if(nread == 0) {
  71.             return 0;
  72.         }
  73.         ptr = read_buffer;
  74.         len = nread;
  75.     }
  76.     *buffer = *ptr++;
  77.     len--;
  78.     return 1;
  79. }

  81. size_t readline(int fd, void * buffer, size_t maxlen)
  82. {
  83.     int i;
  84.     int nread;
  85.     char c;
  86.     char *ptr;

  88.     ptr=buffer;
  89.     for(i = 0;i < maxlen;i++) {
  90. again:
  91.         if((nread = my_read(fd,&c)) == 1){
  92.             *ptr++ = c;
  93.             if(c == '\n')
  94.                 break;
  95.         }else if(nread == 0) {
  96.             *ptr = 0;
  97.             return i-1;
  98.         }else {
  99.             if(errno == EINTR) {
  100.                 goto again;
  101.             }else {
  102.                 return -1;
  103.             }
  104.         }
  105.     }
  106.     *ptr = 0;
  107.     return i;
  108. }

编译运行：
gcc -g readn.c tcpclient.c -o tcpclient -Wall
gcc -g readn.c tcpserver.c -o tcpserver -Wall

SERVER端：
./tcpserver
client端：
./tcpclient
abc
abc


阅读(855) | 评论(0) | 转发(0) |
0

上一篇：fgets & fputs

下一篇：linux SIGPIPE信号

给主人留下些什么吧！~~
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

Copyright 2001-2010 ChinaUnix.net All Rights Reserved 北京皓辰网域网络信息技术有限公司. 版权所有

感谢所有关心和支持过ChinaUnix的朋友们

16024965号-6