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

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

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

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

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

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

 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 */

  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 }

  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 info of the client */
 83                 char clntipv4[16] = { 0 };
 84                 const char *ptr = inet_ntop(AF_INET,
 85                                             &clnt_addr.sin_addr,
 86                                             clntipv4,
 87                                             sizeof (clntipv4));
 88                 printf("\nconnection from %s:%d\n", ptr,
 89                     (int)ntohs(clnt_addr.sin_port));
 90 
 91                 /* 5. recv */
 92                 rc = recv_file(conn_fd);
 93                 if (rc != 0) {
 94                         fprintf(stderr, "fail to recv file on fd %d\n",
 95                             conn_fd);
 96                         close(conn_fd);
 97                         continue;
 98                 }
 99 
100                 close(conn_fd);
101         }
102 
103         /* 6. shutdown */
104         close(listen_fd);
105 
106         return 0;
107 }

 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",
56                     errno, strerror(errno));
57                 return -1;
58         }
59 
60         /* 3. send */
61         rc = send_file(sock_fd, dstfile, srcfile);
62         if (rc != 0) {
63                 fprintf(stderr, "fail to send srcfile %s to dstfile %s\n",
64                     srcfile, dstfile);
65                 close(sock_fd);
66                 return 3;
67         }
68 
69         printf("OKAY - send file %s to %s:%s successfully!\n",
70             srcfile, ipv4, dstfile);
71 
72         /* 4. shutdown */
73         close(sock_fd);
74 
75         return 0;
76 }

 1 CC      = gcc
 2 CFLAGS  = -g -Wall -std=gnu99 -m32
 3 
 4 all: client server
 5 
 6 client: client.o libfoo.o
 7         ${CC} ${CFLAGS} -o $@ $^
 8 
 9 client.o: client.c
10         ${CC} ${CFLAGS} -c $<
11 
12 server: server.o libfoo.o
13         ${CC} ${CFLAGS} -o $@ $^
14 
15 server.o: server.c
16         ${CC} ${CFLAGS} -c $<
17 
18 libfoo.o: libfoo.c libfoo.h
19         ${CC} ${CFLAGS} -c $<
20 
21 clean:
22         rm -f *.o
23 clobber: clean
24         rm -f client server
25 cl: clobber

$ make
gcc -g -Wall -std=gnu99 -m32 -c client.c
gcc -g -Wall -std=gnu99 -m32 -c libfoo.c
gcc -g -Wall -std=gnu99 -m32 -o client client.o libfoo.o
gcc -g -Wall -std=gnu99 -m32 -c server.c
gcc -g -Wall -std=gnu99 -m32 -o server server.o libfoo.o

# --- Terminal 1: start server -------------------------------------------

$ ifconfig eth0 | grep ‘inet addr‘
          inet addr:192.168.1.100  Bcast:192.168.1.255  Mask:255.255.255.0
$ ./server 192.168.1.100
Now tcp server is listening on 192.168.1.100:2345

# --- Terminal 2: start client -------------------------------------------

$ ./client 192.168.1.100 /tmp/client.c /tmp/foo.c
OKAY - send file /tmp/client.c to 192.168.1.100:/tmp/foo.c successfully!

$ rm -f /tmp/foo.c
$ diff /tmp/client.c /tmp/foo.c
$ echo $?
0

# --- Back to Terminal 1 -------------------------------------------------

$ ./server 192.168.1.100
Now tcp server is listening on 192.168.1.100:2345

connection from 0.0.0.0:45182
> dst filename=/tmp/foo.c, filesize=1532, filemode=644
^C