图说使用socket建立TCP连接

Posted veli

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了图说使用socket建立TCP连接相关的知识,希望对你有一定的参考价值。

在网络应用如火如荼的今天,熟悉TCP/IP网络编程,那是最好不过。如果你并不非常熟悉,不妨花几分钟读一读。 为了帮助快速理解,先上个图,典型的使用socket建立和使用TCP/UDP连接过程为(截图来源戳这里):

下面仅讲述TCP连接建立的过程。 (参考资料来自这里)

1. Initial State (初始阶段)

o TCP is connection based, ... establishing it is a complex multistage process
o initially all machines are the same
o no special \'server\' machines
o the difference is all in the software
  • TCP是面向连接的协议,TCP连接的建立是一个复杂的多阶段的过程
  • 最开始所有机器状态都是一样的
  • 并不存在所谓的\'server\'机器
  • 所有的区别仅存在于软件之中

2. Passive Open (被动Open)

o server process does a \'passive\' open on a port
o it waits for a client to connect
o at this stage there is no Internet network traffic
o tells the TCP layer which process to connect to
  • 服务器端进程在某个端口上执行一个"被动"open
  • 服务器端进程等待某个客户端来连接
  • 这一阶段并不存在Internet网络传输
  • 告知TCP层哪一个进程可以接受连接

3. Active Open (主动Open)

o client process usually on a different machine
o performs an \'active\' open on the port
o port number at the client end is needed
          usually automatic (e.g. 2397)
          but can be chosen
o network message -> server machine
          requests connection
  • 客户端进程通常情况下运行在另外一个机器上
  • 客户端进程在某个端口上执行一个"主动"Open
  • 在客户端,端口号也是需要的,通常是自动分配的(例如:2397),也可以主动选择一个端口号
  • 网络消息->服务器机器,需要一个连接

4. Rendezvous (集结,也就是连接建立)

o server side accepts and TCP connection established
o a bi-directional reliable byte-stream
o connection identified by both host/port numbers
  e.g. <151.10017.25:2397/161.112.192.5:21>
o server port is not consumed
o can stay \'passive\' open for more connections
o like telephone call desk: one number many lines
  • 服务器端接受连接,TCP连接得以建立
  • 连接是一个双向的可靠字节流(即全双工可靠字节流)
  • 识别一个连接,可以用host/port对,例如: 151.10017.25:2397/161.112.192.5:21
  • 服务器端口并没有被消耗殆尽
  • 服务器端可以一直处于"被动"open状态以接收更多的连接请求
  • 类似于电话呼叫台: 一个号码多条线路

5. More

o other clients can connect to the same port
o state for connections in the client/server only
o no information needed in the network
  not like old style relay-based exchanges
o server can restrict access to specified host or port
o server can find out connected host/port
  • 其他客户端可以连接到同一个端口
  • 连接状态仅存在于client/server中
  • 与老式风格的基于中继的交换有所不同,tcp连接网络中不需要信息
  • 服务器可以对指定的主机或端口进行访问限制
  • 在服务器上可以找出已经连接的主机/端口

有关Passive open和Active open,区别如下:

passive - patient but lazy
 active - industrious but impatient

passive : waits for request for connection
        : waits for ever
 active : sends out request for connection
        : times out

o normally server does passive open
  waiting for client
o but not always (e.g. ftp)
o active opens can rendezvous ... but may miss due to time-outs
o either can specify local port
  but if not specified, allocated automatically

到此为止,我们已经弄明白了TCP连接建立的过程。下面给出一个简单的TCP client/server实现。

1. libfoo.h

 1 #ifndef _LIBFOO_H
 2 #define _LIBFOO_H
 3 
 4 #ifdef __cplusplus
 5 extern "C" {
 6 #endif
 7 
 8 #define PORT 2345
 9 
10 extern int send_file(int sockfd, char *dstfile, char *srcfile);
11 extern int recv_file(int sockfd);
12 
13 #ifdef __cplusplus
14 }
15 #endif
16 
17 #endif /* _LIBFOO_H */

2. libfoo.c

  1 #include <stdio.h>
  2 #include <unistd.h>
  3 #include <errno.h>
  4 #include <string.h>
  5 #include <fcntl.h>
  6 #include <sys/stat.h>
  7 #include <sys/types.h>
  8 #include <arpa/inet.h>
  9 #include "libfoo.h"
 10 
 11 typedef struct file_header_s {
 12         char *file[1024]; /* (dst) file absolute path */
 13         size_t size;      /* file size */
 14         mode_t mode;      /* file mode */
 15 } file_header_t;
 16 
 17 /*
 18  * send file via sockfd
 19  */
 20 int
 21 send_file(int sockfd, char *dstfile, char *srcfile)
 22 {
 23         int             fd;
 24         file_header_t   fhr;
 25         struct stat     sb;
 26         int             rc;
 27         int             n, m;
 28         size_t          count;
 29         char            buf[1024] = { 0 };
 30 
 31         /* open src file */
 32         if ((fd = open(srcfile, O_RDONLY)) < 0) {
 33                 fprintf(stderr, "cannot open `%s\' for reading: %s\\n",
 34                     srcfile, strerror(errno));
 35                 return 1;
 36         }
 37 
 38         /* stat src file */
 39         if ((rc = fstat(fd, &sb)) < 0) {
 40                 fprintf(stderr, "cannot stat fd %d: %s\\n",
 41                     fd, strerror(errno));
 42                 rc = 2;
 43                 goto done;
 44         }
 45 
 46         rc = 0;
 47 
 48         /*
 49          * create dst file header and send out
 50          * o dst file path != src file path in case they are on the same host
 51          * o dst file size == src file size
 52          * o dst file mode == src file mode
 53          */
 54         memset(&fhr, 0, sizeof (fhr));
 55         strncpy((char *)fhr.file, dstfile, strlen(dstfile));
 56         fhr.size = htonl(sb.st_size);
 57         fhr.mode = htonl(sb.st_mode & ~S_IFMT);
 58 
 59         /* write file header to sockfd */
 60         if ((n = write(sockfd, &fhr, sizeof (fhr))) == -1) {
 61                 fprintf(stderr, "cannot write file header to sock %d: %s\\n",
 62                     sockfd, strerror(errno));
 63                 rc = 3;
 64                 goto done;
 65         }
 66 
 67         /* read from fd, write to sockfd */
 68         count = sb.st_size;
 69         while (count > 0) {
 70                 m = (count >= sizeof (buf)) ? sizeof(buf) : count;
 71 
 72                 memset(buf, 0, sizeof (buf));
 73                 if ((n = read(fd, buf, m)) == -1) {
 74                         fprintf(stderr, "fail to read %d bytes from fd %d\\n",
 75                             m, fd);
 76                         rc = 4;
 77                         goto done;
 78                 }
 79 
 80                 if ((n = write(sockfd, buf, m)) == -1) {
 81                         fprintf(stderr, "fail to write %d bytes to sock %d\\n",
 82                             m, sockfd);
 83                         rc = 5;
 84                         goto done;
 85                 }
 86 
 87                 count -= m;
 88         }
 89 
 90 done:
 91         close(fd);
 92         return rc;
 93 }
 94 
 95 /*
 96  * read from sockfd then save to file
 97  */
 98 int
 99 recv_file(int sockfd)
100 {
101         int             fd;
102         file_header_t   fhr;
103         char            *file = NULL;
104         size_t          filesize;
105         mode_t          filemode;
106         size_t          count;
107         int             rc;
108         int             n, m;
109         char            buf[1024] = { 0 };
110 
111         /* 1. read file header */
112         if ((n = read(sockfd, &fhr, sizeof (fhr))) == -1) {
113                 fprintf(stderr, "fail to read file header from sock %d: %s\\n",
114                     sockfd, strerror(errno));
115                 return 1;
116         }
117         file = (char *)fhr.file;
118         filesize = ntohl(fhr.size);
119         filemode = ntohl(fhr.mode);
120         printf("> dst filename=%s, filesize=%u, filemode=%o\\n",
121             file, filesize, (int)filemode);
122 
123         /* 2. open file to save */
124         (void) umask(0);
125         if ((fd = open(file, O_RDWR|O_CREAT|O_TRUNC, filemode)) < 0) {
126                 fprintf(stderr, "cannot create `%s\' for writing: %s\\n",
127                     file, strerror(errno));
128                 return 2;
129         }
130 
131         rc = 0;
132 
133         /* 3. read from sockfd and write to fd */
134         count = filesize;
135         while (count > 0) {
136                 m = count >= sizeof (buf) ? sizeof(buf) : count;
137 
138                 memset(buf, 0, sizeof (buf));
139                 if ((n = read(sockfd, buf, m)) == -1) {
140                         fprintf(stderr, "fail to read %d bytes from sock %d\\n",
141                             m, sockfd);
142                         rc = 4;
143                         goto done;
144                 }
145 
146                 if ((n = write(fd, buf, m)) == -1) {
147                         fprintf(stderr, "fail to write %d bytes to file %d\\n",
148                             m, fd);
149                         rc = 5;
150                         goto done;
151                 }
152 
153                 count -= m;
154         }
155 
156 done:
157         close(fd);
158         return rc;
159 }

3. server.c

  1 /**
  2  * server.c - single connection tcp server
  3  */
  4 
  5 #include <stdio.h>
  6 #include <unistd.h>
  7 #include <errno.h>
  8 #include <string.h>
  9 #include <sys/types.h>
 10 #include <sys/types.h>
 11 #include <sys/stat.h>
 12 #include <fcntl.h>
 13 #include <sys/socket.h>
 14 #include <arpa/inet.h>
 15 #include "libfoo.h"
 16 
 17 int
 18 main(int argc, char *argv[])
 19 {
 20         int port = PORT;
 21         int rc = 0;
 22 
 23         if (argc != 2) {
 24                 fprintf(stderr, "Usage: %s <ipv4>\\n", argv[0]);
 25                 return -1;
 26         }
 27         char *ipv4 = argv[1];
 28 
 29         /* 1. socket */
 30         int listen_fd = socket(PF_INET, SOCK_STREAM, 0);
 31         if (listen_fd < 0) {
 32                 fprintf(stderr, "E: socket(),%d,%s\\n",
 33                     errno, strerror(errno));
 34                 return -1;
 35         }
 36 
 37         /* 2. bind */
 38         struct sockaddr_in srv_addr;
 39         memset(&srv_addr, 0, sizeof (struct sockaddr_in));
 40         srv_addr.sin_family = AF_INET;
 41 
 42         rc = inet_pton(AF_INET, ipv4, &srv_addr.sin_addr);
 43         if (rc != 1) {
 44                 fprintf(stderr, "E: inet_pton(),%d,%s\\n",
 45                     errno, strerror(errno));
 46                 return -1;
 47         }
 48         srv_addr.sin_port = htons(port);
 49 
 50         rc = bind(listen_fd, (struct sockaddr *)&srv_addr, sizeof (srv_addr));
 51         if (rc != 0) {
 52                 fprintf(stderr, "E: bind(),%d,%s\\n",
 53                     errno, strerror(errno));
 54                 return -1;
 55         }
 56 
 57         /* 3. lisen */
 58         rc = listen(listen_fd, 10);
 59         if (rc != 0) {
 60                 fprintf(stderr, "E: listen(),%d,%s\\n",
 61                     errno, strerror(errno));
 62                 return -1;
 63         }
 64 
 65         printf("Now tcp server is listening on %s:%d\\n", ipv4, port);
 66 
 67         while (1) {
 68                 /* 4. accept */
 69                 struct sockaddr_in clnt_addr;
 70                 size_t clnt_addr_len = sizeof (struct sockaddr_in);
 71                 memset(&clnt_addr, 0, sizeof (struct sockaddr_in));
 72 
 73                 int conn_fd = accept(listen_fd,
 74                                      (struct sockaddr *)&clnt_addr,
 75                                      &clnt_addr_len);
 76                 if (conn_fd < 0) {
 77                         fprintf(stderr, "E: accept(),%d,%s\\n",
 78                             errno, strerror(errno));
 79                         return 1;
 80                 }
 81 
 82                 /* get IPv4/port of the server */
 83                 memset(&srv_addr, 0, sizeof (struct sockaddr_in));
 84                 size_t srv_addr_len = sizeof (struct sockaddr_in);
 85                 rc = getsockname(conn_fd,
 86                                  (struct sockaddr *)&srv_addr,
 87                                  &srv_addr_len);
 88                 if (rc != 0) {
 89                         fprintf(stderr, "E: getsockname(),%d,%s\\n",
 90                             errno, strerror(errno));
 91                         return 1;
 92                 }
 93 
 94                 char srvipv4[16] = { 0 };
 95                 const char *ptr1 = inet_ntop(AF_INET,
 96                                             &srv_addr.sin_addr,
 97                                             srvipv4,
 98                                             sizeof (srvipv4));
 99 
100                 /* get IPv4/port of the client */
101                 rc = getpeername(conn_fd,
102                                  (struct sockaddr *)&clnt_addr,
103                                  &clnt_addr_len);
104                 if (rc != 0) {
105                         fprintf(stderr, "E: getpeername(),%d,%s\\n",
106                             errno, strerror(errno));
107                         return 1;
108                 }
109 
110                 char clntipv4[16] = { 0 };
111                 const char *ptr2 = inet_ntop(AF_INET,
112                                             &clnt_addr.sin_addr,
113                                             clntipv4,
114                                             sizeof (clntipv4));
115 
116                 printf("\\nlocal %s port %d connected with %s port %d\\n",
117                        ptr1, (int)ntohs(srv_addr.sin_port),
118                        ptr2, (int)ntohs(clnt_addr.sin_port));
119 
120                 /* 5. recv */
121                 rc = recv_file(conn_fd);
122                 if (rc != 0) {
123                         fprintf(stderr, "fail to recv file on fd %d\\n",
124                             conn_fd);
125                         close(conn_fd);
126                         continue;
127                 }
128 
129                 close(conn_fd);
130         }
131 
132         /* 6. shutdown */
133         close(listen_fd);
134 
135         return 0;
136 }

4. client.c

 1 /**
 2  * client.c - tcp client to send a file like scp
 3  */
 4 
 5 #include <stdio.h>
 6 #include <unistd.h>
 7 #include <errno.h>
 8 #include <string.h>
 9 #include <fcntl.h>
10 #include <sys/stat.h>
11 #include <sys/types.h>
12 #include <sys/socket.h>
13 #include <arpa/inet.h>
14 #include "libfoo.h"
15 
16 int
17 main(int argc, char *argv[])
18 {
19         int port = PORT;
20         int rc = 0;
21 
22         if (argc != 4) {
23                 fprintf(stderr, "Usage %s <server> <srcfile> <dstfile>\\n",
24                     argv[0]);
25                 return -1;
26         }
27 
28         /* 1. socket */
29         int sock_fd = socket(PF_INET, SOCK_STREAM, 0);
30         if (sock_fd < 0) {
31                 fprintf(stderr, "E: socket(),%d,%s\\n",
32                     errno, strerror(errno));
33                 return -1;
34         }
35 
36         char *ipv4 = argv[1];
37         char *srcfile = argv[2];
38         char *dstfile = argv[3];
39 
40         /* 2. connect */
41         struct sockaddr_in srv_addr;
42         memset(&srv_addr, 0, sizeof (struct sockaddr_in));
43         srv_addr.sin_family = AF_INET;
44 
45         rc = inet_pton(AF_INET, ipv4, &srv_addr.sin_addr);
46         if (rc != 1) {
47                 fprintf(stderr, "E: inet_pton(),%d,%s\\n",
48                     errno, strerror(errno));
49                 return -1;
50         }
51         srv_addr.sin_port = htons(port);
52 
53         rc = connect(sock_fd, (struct sockaddr *)&srv_addr, sizeof (srv_addr));
54         if (rc != 0) {
55                 fprintf(stderr, "E: bind(),%d,%s\\n"以上是关于图说使用socket建立TCP连接的主要内容,如果未能解决你的问题,请参考以下文章

1万字30张图说清TCP协议

大牛用1万字30张图说清TCP协议

Python攻防-Socket通信建立TCP反向连接

Python攻防-Socket通信建立TCP反向连接

TCP连接建立及相关socket深度探析

TCP连接建立及相关socket深度探析