c 网络与套接字socket

我们已经知道如何使用I/O与文件通信,还知道了如何让同一计算机上的两个进程进行通信,这篇文章将创建具有服务器和客户端功能的程序

互联网中大部分的底层网络代码都是用C语言写的。 网络程序通常有两部分组成:服务器和客户端。

工具介绍: telnet

为了测试功能,我们使用一个叫做telnet的客户端程序连接服务器,telnet 接受两个参数:一个是服务器地址,另一个是服务器运行的端口号,

如果在运行服务器的那台计算机上运行telnet,地址可填写127.0.0.1

这样使用:假设端口号是30000

telnet 127.0.0.1 30000

 

我们先说服务器这一端的:

服务器连接网络分为四部曲:①绑定(Bind) ②监听(Listen) ③接受(Accept) ④开始(Begin) 

把每个首字母连起来就是BLAM

如果想写一个与网络通信的程序,就需要一种新的数据流---套接字

#include <sys/socket.h>
  int listener_d = socket(PF_INET, SOCK_STREAM, 0);
    if (listener_d == -1) {
        error("不能打开套接字");
    }

其中 listener_d 是套接字描述符  /  0 是协议号,一般填0就行

1.绑定(Bind)

计算机可能同时运行多个服务器程序,一个发送网页,一个发送邮件,另一个运行聊天服务器。为了防止不同对话发生混淆,每项服务必须使用不同的端口(port)。

端口就好比电视频道,我们在不同的端口使用不同的网络服务,就像我们在不同频道收看不同的电视节目。

 

#include <arpa/inet.h>
 // 绑定端口
    struct sockaddr_in name;
    name.sin_family = PF_INET;
    name.sin_port = (in_port_t)htons(30000);
    name.sin_addr.s_addr = htonl(INADDR_ANY);
    int c = bind(listener_d, (struct sockaddr *)&name, sizeof(name));
    if (c == -1) {
        error("无法绑定端口");
    }

2.监听(Listen)

通常会有很多客户端连接到服务器,如果我们想要客户端排队等待连接,就要使用listen()来告诉操作系统你希望队列有多长。

// 监听
    if (listen(listener_d, 10) == -1) {
        error("无法监听");
    }

调用listen()把队列长度设为10,也就是说最多可以有10个客户端可以尝试连接服务器,他们并不会立刻得到相应,但是可以排队等待,而第11个客户端会被告知服务器太忙了。

3.接受连接(Accept)

对于服务器端来说,当我们已经绑定完了端口,设置了监听队列,唯一可做的就是等待了。服务器一生都在等待客户端来连接他们,accept()调用会一直等待,知道有客户端链接服务器时,他会返回第二个套接字描述符,然后就可以通信了。

 // 接受链接
        struct sockaddr_storage client_addr; // 保存链接客户端的相信信息
        unsigned int address_size = sizeof(client_addr);
        int connect_d = accept(listener_d, (struct sockaddr *)&client_addr, &address_size);
        if (connect_d == -1) {
            error("无法打开副套接字");
        }

 

套接字并不是传统意义上的数据流

我们知道的数据流有:文件,标准输入,标准输出。都可以使用fprintf和fscanf函数和他们通信,这俩个函数都是单向的,但套接字不同,套接字是双向的,既可以用作输出,也可以用作输入,因此需要别的函数。

输出:send()   输入:recv()

我们先介绍send函数

        char *msg = "Internet Knock-Knock Protocol Server\r\nVersion 1.0\r\nKnock! Knock!\r\n>";
        
        if (send(connect_d, msg, strlen(msg), 0) == -1) {
            error("send");
        }

 好了,让我们先用一个例子来演示一下上边的功能怎么用,先看代码:

 1 #include <stdio.h>
 2 #include <sys/socket.h>
 3 #include <arpa/inet.h>
 4 #include <string.h>
 5 #include <errno.h>
 6 #include <stdlib.h>
 7 #include <unistd.h>
 8 
 9 void error(char *msg) {
10     fprintf(stderr, "Error: %s  %s", msg, strerror(errno));
11     exit(1);
12 }
13 
14 
15 int main(int argc, const char * argv[]) {
16  
17     
18     char *advice[] = {
19                         "你为什么这么帅!\r\n",
20                         "有没有人夸过你帅?",
21                         "傻逼牛头,笨鳖",
22                         "牛,你是第六人吗?",
23                         "拔插座了吧"};
24     
25     
26     // 打开
27     int listener_d = socket(PF_INET, SOCK_STREAM, 0);
28     if (listener_d == -1) {
29         error("不能打开套接字");
30     }
31     
32     // int reuse = 1;
33    // if (setsockopt(listener_d, SOL_SOCKET, SO_REUSEADDR, (char *)&reuse, sizeof(int)) == -1) {
34     //    error("无法设置套接字的“重新使用端口”选项");
35    // }
36     // 绑定端口
37     struct sockaddr_in name;
38     name.sin_family = PF_INET;
39     name.sin_port = (in_port_t)htons(30000);
40     name.sin_addr.s_addr = htonl(INADDR_ANY);
41     int c = bind(listener_d, (struct sockaddr *)&name, sizeof(name));
42     if (c == -1) {
43         error("无法绑定端口");
44     }
45     
46     // 监听
47     if (listen(listener_d, 10) == -1) {
48         error("无法监听");
49     }
50     
51     puts("等待链接...");
52     
53     while (1) {
54         // 接受链接
55         struct sockaddr_storage client_addr; // 保存链接客户端的相信信息
56         unsigned int address_size = sizeof(client_addr);
57         int connect_d = accept(listener_d, (struct sockaddr *)&client_addr, &address_size);
58         if (connect_d == -1) {
59             error("无法打开副套接字");
60         }
61         
62         // 通信
63         //    char *msg = "Internet Knock-Knock Protocol Server\r\nVersion 1.0\r\nKnock! Knock!\r\n>";
64         char *msg = advice[rand() % 5];
65         if (send(connect_d, msg, strlen(msg), 0) == -1) {
66             error("send");
67         }
68         
69         if (close(connect_d) == -1) {
70             error("无法关闭链接");
71         }
72         
73     }
74    
75 
76     return 0;
77 }
// Mac 下编译运行
gcc socket.c -o socket ./socket

终端显示成这样

我们打开另一个终端来模拟客户端

太棒了,服务器和客户端能够连接且服务器能够给客户端发送数据了,但是这样的程序还是有问题的,当我们快速使用Ctrl-C结束服务器的程序,在用./socket打开机会出现这样的错误

为什么会出现这个错误呢?因为绑定端口是有延时的。

当你在某个端口绑定了一个程序,系统不允许在30秒内再绑定其他的程序,也包括上一次绑定这个端口的程序。只要在绑定前设置套接字的某个选项就能解决这个问题

把上边的代码注释的地方打开

 int reuse = 1;
    if (setsockopt(listener_d, SOL_SOCKET, SO_REUSEADDR, (char *)&reuse, sizeof(int)) == -1) {
        error("无法设置套接字的“重新使用端口”选项");
    }

重复之前的的操作,Ctrl-C ./socket 就没这问题了。

然而,在现实世界中,我们不仅需要给客户端发消息,我们还要能在客户端读消息。

答案就是recv()函数。

需要注意下边几点:

1.接受到的字符串并不是以'\0'结尾的

2.当用户在telnet输入文本并按了回车后,接受到的字符串是以'\r\n'结尾的

3.recv() 返回字符串的个数,如果发生错误就返回-1,如果客户端关闭了链接就返回0

4.recv()调用不一定能一次性收到所有的字符串,可能分几次返回也就是多次调用recv()

由于上边4所造成的需要调用多次的情况,因此recv()使用起来还是很繁琐的,最好能封装到一个方法中;

 1 // 从客户端读取数据
 2 int read_in(int socket, char *buf, int len) {
 3     char *s = buf;
 4     int slen = len;
 5     int c = (int)recv(socket, s, slen, 0);
 6     while ((c > 0) && (s[c-1] != '\n')) {
 7         s += c;
 8         slen -= c;
 9         c = (int)recv(socket, s, slen, 0);
10     }
11     
12     if (c < 0) {
13         return c;
14     }else if (c == 0) {
15         buf[0] = '\0';
16     }else {
17         s[c - 1] = '\0';
18     }
19     
20     return len - slen;
21 }

下边我们就写一个服务器和客户端能够交互的程序,这个程序其实跟HTTP协议的原理很像,都是在双方必须遵守某项定好的协议前提下进行通信的。我们把上面讲的通信前的准备都封装成了单独的函数,比如

// 错误处理函数
void error(char *msg)
// 开启socket
int open_listener_socket()
// 绑定端口
void bind_to_port(int socket, int port) 
// 向客户端发消息
int say(int socket, char *s)
// 处理服务中断
void handle_shutdown(int sig)
// 监听信号
int catch_signal(int sig, void (*handler)(int))
// 从客户端读取数据
int read_in(int socket, char *buf, int len)

代码如下 

  1 #include <stdio.h>
  2 #include <sys/socket.h>
  3 #include <arpa/inet.h>
  4 #include <string.h>
  5 #include <errno.h>
  6 #include <stdlib.h>
  7 #include <unistd.h>
  8 #include <signal.h>
  9 
 10 int listener_d;
 11 
 12 // 错误处理函数
 13 void error(char *msg) {
 14     fprintf(stderr, "Error: %s  %s", msg, strerror(errno));
 15     exit(1);
 16 }
 17 
 18 // 开启socket
 19 int open_listener_socket() {
 20     int s = socket(PF_INET, SOCK_STREAM, 0);
 21     if (s == -1) {
 22         error("Can't open socket");
 23     }
 24     return s;
 25 }
 26 
 27 // 绑定端口
 28 void bind_to_port(int socket, int port) {
 29     struct sockaddr_in name;
 30     name.sin_family = PF_INET;
 31     name.sin_port = (in_port_t)htons(port);
 32     name.sin_addr.s_addr = htonl(INADDR_ANY);
 33     int reuse = 1;
 34     if (setsockopt(socket, SOL_SOCKET, SO_REUSEADDR, (char *)&reuse, sizeof(int)) == -1) {
 35         error("Can't set the reuse option on the socket");
 36     }
 37     int c = bind(socket, (struct sockaddr*)&name, sizeof(name));
 38     if (c == -1) {
 39         error("Can't bind to socket");
 40     }
 41 }
 42 
 43 // 向客户端发消息
 44 int say(int socket, char *s) {
 45     int result = (int)send(socket, s, strlen(s), 0);
 46     if (result == -1) {
 47         fprintf(stderr, "%s: %s \n","和客户端通信发生错误",strerror(errno));
 48     }
 49     return result;
 50 }
 51 
 52 // 处理服务中断
 53 void handle_shutdown(int sig) {
 54     if (listener_d) {
 55         close(listener_d);
 56     }
 57     fprintf(stderr, "Bye! \n");
 58     exit(0);
 59 }
 60 
 61 // 监听信号
 62 int catch_signal(int sig, void (*handler)(int)) {
 63     // 创建一个新动作
 64     struct sigaction action;
 65     // 想让计算机调用哪个函数,这个被包装的my_custom_fun函数就叫做处理器
 66     action.sa_handler = handler;
 67     // 使用掩码过滤信号,通常会用一个空的掩码
 68     sigemptyset(&action.sa_mask);
 69     // 一些附加的标志位,置为0就行了
 70     action.sa_flags = 0;
 71     
 72     return sigaction(sig, &action, NULL);
 73 }
 74 
 75 // 从客户端读取数据
 76 int read_in(int socket, char *buf, int len) {
 77     char *s = buf;
 78     int slen = len;
 79     int c = (int)recv(socket, s, slen, 0);
 80     while ((c > 0) && (s[c-1] != '\n')) {
 81         s += c;
 82         slen -= c;
 83         c = (int)recv(socket, s, slen, 0);
 84     }
 85     
 86     if (c < 0) {
 87         return c;
 88     }else if (c == 0) {
 89         buf[0] = '\0';
 90     }else {
 91         s[c - 1] = '\0';
 92     }
 93     
 94     return len - slen;
 95 }
 96 int main(int argc, const char * argv[]) {
 97 
 98     // 监听中断
 99     if (catch_signal(SIGINT, handle_shutdown) == -1) {
100         error("Can not set the interrupt handler");
101     }
102     
103     // 打开socket
104     listener_d = open_listener_socket();
105     
106     // 绑定端口
107     bind_to_port(listener_d, 30000);
108     
109     // 监听
110     if (listen(listener_d, 1) == -1) {
111         error("Can't listen");
112     }
113     
114     puts("Waiting for connection");
115     
116     // 客户端
117     struct sockaddr_storage client_addr;
118     unsigned int addr_size = sizeof(client_addr);
119     
120     char buf[255];
121     
122     while (1) {
123         
124         // 链接
125         int connect_d = accept(listener_d, (struct sockaddr*) &client_addr, &addr_size);
126         if (connect_d == -1) {
127             error("Can't open secondary socket");
128         }
129         
130         // 子进程
131         //if (!fork()) {
132             
133            // close(listener_d);
134             
135             if (say(connect_d, "Internet Knock-Knock Protocol Servet\r\nVersion 1.0\r\nKnock! Knock!\r\n>") != -1) {
136                 
137                 read_in(connect_d, buf, sizeof(buf));
138                 if (strncasecmp("Who's there?", buf, (2))) {
139                     say(connect_d, "You should say 'Who's there?' !");
140                 }else {
141                     if (say(connect_d, "Oscar\r\n>") != -1) {
142                         read_in(connect_d, buf, sizeof(buf));
143                         
144                         if (strncasecmp("Oscar who?", buf, (0))) {
145                             say(connect_d, "You should say 'Oscar who?' !");
146                         }else {
147                             say(connect_d, "Oscar silly question, you set a silly answer!\r\n");
148                         }
149                     }
150                 }
151                 
152             }
153             
154            // close(connect_d);
155            // exit(0);
156        // }
157  
158         close(connect_d);
159     }
160     
161 
162     return 0;
163 }

编译并运行后

我们打开另一个终端

我们现在已经能够接受客户端的数据,并且能够按照我们自定义的协议进行通信了。

但是我们还需要想的更多,现在是和一个客户端通信,如果跟多个客户端呢?

打开我们上边代码中注释的部分,恢复后的代码是这样的

 1  // 子进程
 2         if (!fork()) {
 3             
 4             close(listener_d);
 5             
 6             if (say(connect_d, "Internet Knock-Knock Protocol Servet\r\nVersion 1.0\r\nKnock! Knock!\r\n>") != -1) {
 7                 
 8                 read_in(connect_d, buf, sizeof(buf));
 9                 if (strncasecmp("Who's there?", buf, (2))) {
10                     say(connect_d, "You should say 'Who's there?' !");
11                 }else {
12                     if (say(connect_d, "Oscar\r\n>") != -1) {
13                         read_in(connect_d, buf, sizeof(buf));
14                         
15                         if (strncasecmp("Oscar who?", buf, (0))) {
16                             say(connect_d, "You should say 'Oscar who?' !");
17                         }else {
18                             say(connect_d, "Oscar silly question, you set a silly answer!\r\n");
19                         }
20                     }
21                 }
22                 
23             }
24             
25             close(connect_d);
26             exit(0);
27         }

通过对比可以看出,当我们接受到客户端的数据的时候,我们创建一个子进程,这样我们就只使用父进程监听连接,子进程处理各自的任务了

多打开几个终端试试。

。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。

到这里我们已经能够写服务器端的代码了,能够发消息和接受消息。

但这远远不够,我现在就想手写一个客户端,通过我的请求能够获取服务器端的某些数据。这其实也很简单

这时候主动权就在我们手里了。

客户端和服务器段都是用套接字来进行通信,但是两者获取套接字的方式不同。

服务器端使用的是BLAM :服务器连接网络分为四部曲:①绑定(Bind) ②监听(Listen) ③接受(Accept) ④开始(Begin) 

客户端只需要两步就可以了 ①连接远程端口 ②开始通信

服务器在网络连接时必须决定使用哪个端口,而客户端除了要端口号还需要知道远程服务器的IP地址

但是这样太不容易记忆了,人们更喜欢使用域名:www.baidu.com

 

 

接下来就让我们编写一段代码。实现网络请求的任务,下边的代码需要能够连接外网才行,也就是需要翻墙

 1 #include <stdio.h>
 2 #include <sys/socket.h>
 3 #include <arpa/inet.h>
 4 #include <string.h>
 5 #include <errno.h>
 6 #include <stdlib.h>
 7 #include <unistd.h>
 8 #include <signal.h>
 9 #include <netdb.h>
10 
11 
12 // 错误处理函数
13 void error(char *msg) {
14     fprintf(stderr, "Error: %s  %s", msg, strerror(errno));
15     exit(1);
16 }
17 
18 // 向客户端发消息
19 int say(int socket, char *s) {
20     int result = (int)send(socket, s, strlen(s), 0);
21     if (result == -1) {
22         fprintf(stderr, "%s: %s \n","和客户端通信发生错误",strerror(errno));
23     }
24     return result;
25 }
26 
27 
28 
29 // 根据域名和端口开启socket
30 int open_socket(char *host, char *port) {
31     
32     struct addrinfo *res;
33     struct addrinfo hints;
34     memset(&hints, 0, sizeof(hints));
35     hints.ai_family = PF_UNSPEC;
36     hints.ai_socktype = SOCK_STREAM;
37     if (getaddrinfo(host, port, &hints, &res) == -1) {
38         error("Can't resolve the address");
39     }
40     
41     int d_sock = socket(res->ai_family, res->ai_socktype, res->ai_protocol);
42     if (d_sock == -1) {
43         error("Can't open socket");
44     }
45     
46     int c = connect(d_sock, res->ai_addr, res->ai_addrlen);
47     if (c == -1) {
48         error("Can't connect to socket");
49     }
50     
51     return d_sock;
52 }
53 
54 
55 int main(int argc, const char * argv[]) {
56     
57 
58     
59     int d_sock;
60     d_sock = open_socket("en.wikipedia.org", "80");
61     
62     char buf[255];
63     sprintf(buf, "GET /wiki/%s http/1.1\r\n",argv[1]);
64     
65     say(d_sock, buf);
66     say(d_sock, "Host: en.wikipedia.org\r\n\r\n");
67     
68     char rec[256];
69     int bytesRcvd = recv(d_sock, rec, 255, 0);
70     while (bytesRcvd) {
71         if (bytesRcvd == -1) {
72             error("Can't read from server");
73         }
74         
75         rec[bytesRcvd] = '\0';
76         printf("%s",rec);
77         bytesRcvd = recv(d_sock, rec, 255, 0);
78     }
79     
80     close(d_sock);
81     
82     return 0;
83 }

posted @ 2016-07-13 09:15  马在路上  阅读(7139)  评论(0编辑  收藏