新手socket编程入门详解指南

193 阅读 0 评论 128 点赞

我是靠谱客的博主外向魔镜，这篇文章主要介绍新手socket编程入门详解指南，现在分享给大家，希望可以做个参考。

开发环境

运行平台：Ubantu 14.04 LTS

疑问引导

问题1：头文件的疑问：

#include <sys/socket.h>与#include <linux/socket.h>有何区别？

解答：

1. 使用diff查看：adc分别表示添加、删除、修改

2. 其实是路径的不同导致有不同的socke.h文件

3. <sys/socket.h> 是 Internet Protocol family，也就是tcpip协议的应用层接口

4. <linux/socket.h>目前暂时未弄懂，但不是接口函数，估计是系统函数。它应该是被操作系统使用，猜测该文件在tcpip的传输层

问题2：大小端字节序问题：

1.c语言检测：利用指针取值和取址的交叉应用，为了增强网络移植性

2. 而socket提供了字节序转换函数：h：host；n：network；l：long32位；s：short16位

3. htonl：将主机的32位主机字节序（ip地址），转换为网络字节序（一列数据）。

问题3：就一个服务器、一个客户端来说，有如下的对应角色说法：

对象first	对象second
服务器	客户端
监听者	广播者
提供服务	请求服务

解析socket编程整体过程：

建立与删除
服务器和客户端通过同一的socket信道通信，而创建一个socket信道，提供socket连接。

int socket(int domain,int type,int protocol);

domain（域）：各个域以AF_XXX命令，意指地址族。决定使用何种的地址类型，确定通信特性：包括地址格式
type：确定套字节的类型，（还）可以自由增加类型。
常用：SOCK_STREAM （即：TCP）和 SOCK_DGRAM（即：UDP）
protocol：指定socket使用的传输协议编号，一般直接设置为0即可，以此表示为给定的域和套接字类型选择默认的传输协议。
返回值：正确返回套接字处理代码（我称之为套接字文件描述符），错误返回-1。该数值将存储使用。

服务器和客户端通都可以，关闭socket通信IO

int shutdown(int s,int how);

s：代表socket_fd，需要关闭的套接字文件描述符
how：为一种方式
shutdown是使socket信道处于不活动状态。可以让该信道关闭写端，而继续接收该套接字读端以此确定数据何时结束，然后再使用close来关闭这个信道。

连接关系

创建和销毁或关闭IO之后，需要知道如何标识一个目标通信进程。
原因：网络有多个计算机，某台计算机上运行着多个程序（进程）。下面是两层关系：
1）目标计算机的网络地址
2）目标计算机上的目标进程的所代表的端口号

所以，目前你需要了解到的有下面几点：

1. 字节序：直接看上面的问题2即可，简单的转换关系。
2. 地址格式：根据不同的因特网地址，在<netinet/in.h>定义不同的结构体，部分socket函数参数调用。如下
3. 定义地址结构体，根据实际装入数值作为socket API实参
4. 地址进制转换：对地址进行二进制与文本字符串格式之间的转换。inet_ntop或inet_pton

绑定接着，对于服务端来说，需要绑定（关联）地址和套接字。为给定的sockfd关联一个sockaddr结构数据。只有服务端将套接字绑定在（域）地址上，客户端才能够连接（connect）成功。

int bind(int sockfd,struct sockaddr * my_addr,int addrlen);

sockfd：套接字文件描述符，是socket返回的值
my_addr：（服务器）网络地址信息
返回值：判断是否正确绑定地址和套接字

连接在此之前，我们创建了套接字（socket）、建立连接基础（bind）。那么，就这就是为了在通信之前，将socket信道连接起来。

int connect (int sockfd,struct sockaddr * serv_addr,int addrlen);

sockfd：套接字文件描述符，是socket返回的值
serv_addr ：网络地址信息
返回值：判断是否正确连接，客户端程序必须要能够处理connect返回的错误。

到目前，你或许已经发现了，connect函数的参数类型与个数都跟bind是一样的（他们的值并不一样，我所说的是形式），结合一起去理解，会更好。
毕竟，根据TCPIP协议，需要连接的信息：IP地址，端口号，就已经足够了。至于其余的MAC地址等等，在socket里面，我们不需要理会。

监听需要注意的是，这种连接，服务器还需要确定是哪个客户端请求连接。所以，服务器首先进入运行请求客户端（任意一个）连接的状态，进入listen（监听）状态。使用函数：

int listen(int s,int backlog);

s：服务器套接字描述符，是socket返回的值
backlog：指定同时能够处理的最大连接要求
函数返回值：是否正确进入监听状态

连接这时候，服务器已经进入了listen状态，然后紧接着调用：

int accept(int s,struct sockaddr * addr,int * addrlen);

s：服务器套接字描述符，是socket返回的值
addr：某一被连接的客户端的套接字数据
addrlen：某一被连接的客户端的套接字数据长度
返回：某一被连接的客户端的文件描述符

读取与发送数据

到目前为止，服务器和客户端都已经做好了双向通信的基础准备。
send与recv暂时不提及，读者自己去查API

复制代码

1
2
int recv(int s,void *buf,int len,unsigned int flags); 
int send(int s,const void * msg,int len,unsigned int falgs);

以下直接与代码相关：

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
//常用包含头文件 and socket编程的作用
#include <stdio.h> //
#include <stdlib.h> //
#include <errno.h> //errno错误信息变量
#include <unistd.h> //
#include <stddef.h> //

#include <sys/socket.h> //提供socket API
#include <sys/un.h> // 
#include <sys/types.h> //socket API参数的类型定义文件
#include <arpa/inet.h> //地址转换函数
#include <netinet/in.h> //字节序函数（宏）、域地址类型定义

客户端代码：

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <netinet/in.h>
#include <pthread.h>

#include "wrap.h"

#define MAXLINE 80
#define SERV_PORT 8000

int main(int argc, char *argv[])
{
 struct sockaddr_in servaddr;
 char buf[MAXLINE];
 int sockfd, n;
 sockfd = Socket(AF_INET, SOCK_STREAM, 0);
 bzero(&servaddr, sizeof(servaddr));
 servaddr.sin_family = AF_INET;
 inet_pton(AF_INET, "192.168.191.6", &servaddr.sin_addr);
 servaddr.sin_port = htons(SERV_PORT);
 Connect(sockfd, (struct sockaddr *) &servaddr, sizeof(servaddr));
 while (fgets(buf, MAXLINE, stdin) != NULL) {
 Write(sockfd, buf, strlen(buf));
 n = Read(sockfd, buf, MAXLINE);
 if (n == 0)
 printf("the other side has been closed.n");
 else
 Write(STDOUT_FILENO, buf, n);
 }
 Close(sockfd);
 return 0;
}

服务器代码：

复制代码

#include <stdio.h>
#include <string.h>
#include <netinet/in.h>
#include "wrap.h"

#define MAXLINE 80
#define SERV_PORT 8000

int main(void)
{
 struct sockaddr_in servaddr, cliaddr;
 socklen_t cliaddr_len;
 int listenfd, connfd;
 char buf[MAXLINE];
 char str[INET_ADDRSTRLEN];
 int i, n;

listenfd = Socket(AF_INET, SOCK_STREAM, 0);

bzero(&servaddr, sizeof(servaddr));
 servaddr.sin_family = AF_INET;
 servaddr.sin_addr.s_addr = inet_addr("192.168.191.6");
 servaddr.sin_port = htons(SERV_PORT);

Bind(listenfd, (struct sockaddr *) &servaddr, sizeof(servaddr));
 Listen(listenfd, 20);
 printf("Accepting connections ...n");

while (1) {
 cliaddr_len = sizeof(cliaddr);
 connfd = Accept(listenfd,
 (struct sockaddr *) &cliaddr,
 &cliaddr_len);
 while (1) {
 n = Read(connfd, buf, MAXLINE);
 if (n == 0) {
 printf("the other side has been closed.n");
 break;
 }
 printf("received from %s at PORT %dn",
 (char *)inet_ntop(AF_INET,
 &cliaddr.sin_addr, str,
 sizeof(str)),
 (int)ntohs(cliaddr.sin_port));
 for (i = 0; i < n; i++)
 buf[i] = toupper(buf[i]);
 Write(connfd, buf, n);
 }
 Close(connfd);
 }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
#include <stdio.h>
#include <string.h>
#include <netinet/in.h>
#include "wrap.h"

#define MAXLINE 80
#define SERV_PORT 8000

int main(void)
{
 struct sockaddr_in servaddr, cliaddr;
 socklen_t cliaddr_len;
 int listenfd, connfd;
 char buf[MAXLINE];
 char str[INET_ADDRSTRLEN];
 int i, n;

 listenfd = Socket(AF_INET, SOCK_STREAM, 0);

 bzero(&servaddr, sizeof(servaddr));
 servaddr.sin_family = AF_INET;
 servaddr.sin_addr.s_addr = inet_addr("192.168.191.6");
 servaddr.sin_port = htons(SERV_PORT);

 Bind(listenfd, (struct sockaddr *) &servaddr, sizeof(servaddr));
 Listen(listenfd, 20);
 printf("Accepting connections ...n");

 while (1) {
 cliaddr_len = sizeof(cliaddr);
 connfd = Accept(listenfd,
 (struct sockaddr *) &cliaddr,
 &cliaddr_len);
 while (1) {
 n = Read(connfd, buf, MAXLINE);
 if (n == 0) {
 printf("the other side has been closed.n");
 break;
 }
 printf("received from %s at PORT %dn",
 (char *)inet_ntop(AF_INET,
 &cliaddr.sin_addr, str,
 sizeof(str)),
 (int)ntohs(cliaddr.sin_port));
 for (i = 0; i < n; i++)
 buf[i] = toupper(buf[i]);
 Write(connfd, buf, n);
 }
 Close(connfd);
 }
}

运行结果：

复制代码

1
2
3
4
5
6
7
hhc@my:~/sharefile/socket/tcp$ ./server &
[1] 15371
hhc@my:~/sharefile/socket/tcp$ Accepting connections ...
hhc@my:~/sharefile/socket/tcp$ ./client
this is a test! 
received from 192.168.191.6 at PORT 53685
THIS IS A TEST!

个人封装的socket接口函数：

复制代码

#include "wrap.h"

void perr_exit(const char *s)
{
 perror(s);
 exit(1);
}

int Accept(int fd, struct sockaddr *sa, socklen_t * salenptr)
{
 int n;
 again:
 if ((n = accept(fd, sa, salenptr)) < 0) {
 if ((errno == ECONNABORTED) || (errno == EINTR))
 goto again;
 else
 perr_exit("accept error");
 }
 return n;
}

void Bind(int fd, const struct sockaddr *sa, socklen_t salen)
{
 if (bind(fd, sa, salen) < 0)
 perr_exit("bind error");
}

void Connect(int fd, const struct sockaddr *sa, socklen_t salen)
{
 if (connect(fd, sa, salen) < 0)
 perr_exit("connect error");
}

void Listen(int fd, int backlog)
{
 if (listen(fd, backlog) < 0)
 perr_exit("listen error");
}

int Socket(int family, int type, int protocol)
{
 int n;
 if ((n = socket(family, type, protocol)) < 0)
 perr_exit("socket error");
 return n;
}

ssize_t Read(int fd, void *ptr, size_t nbytes)
{
 ssize_t n;
 again:
 if ((n = read(fd, ptr, nbytes)) == -1) {
 if (errno == EINTR)
 goto again;
 else
 return -1;
 }
 return n;
}

ssize_t Write(int fd, const void *ptr, size_t nbytes)
{
 ssize_t n;
 again:
 if ((n = write(fd, ptr, nbytes)) == -1) {
 if (errno == EINTR)
 goto again;
 else
 return -1;
 }
 return n;
}

void Close(int fd)
{
 if (close(fd) == -1)
 perr_exit("close error");
}

ssize_t Readn(int fd, void *vptr, size_t n)
{
 size_t nleft;
 ssize_t nread;
 char *ptr;
 ptr = vptr;
 nleft = n;
 while (nleft > 0) {
 if ((nread = read(fd, ptr, nleft)) < 0) {
 if (errno == EINTR)
 nread = 0;
 else
 return -1;
 } else if (nread == 0)
 break;
 nleft -= nread;
 ptr += nread;
 }
 return n - nleft;
}

ssize_t Writen(int fd, const void *vptr, size_t n)
{
 size_t nleft;
 ssize_t nwritten;
 const char *ptr;
 ptr = vptr;
 nleft = n;
 while (nleft > 0) {
 if ((nwritten = write(fd, ptr, nleft)) <= 0) {
 if (nwritten < 0 && errno == EINTR)
 nwritten = 0;
 else
 return -1;
 }
 nleft -= nwritten;
 ptr += nwritten;
 }
 return n;
}

ssize_t my_read(int fd, char *ptr)
{
 static int read_cnt;
 static char *read_ptr;
 static char read_buf[100];
 if (read_cnt <= 0) {
 again:
 if ((read_cnt = read(fd, read_buf, sizeof(read_buf))) < 0) {
 if (errno == EINTR)
 goto again;
 return -1;
 } else if (read_cnt == 0)
 return 0;
 read_ptr = read_buf;
 }
 read_cnt--;
 *ptr = *read_ptr++;
 return 1;
}

ssize_t Readline(int fd, void *vptr, size_t maxlen)
{
 ssize_t n, rc;
 char c, *ptr;
 ptr = vptr;
 for (n = (ssize_t)1; n < (ssize_t)maxlen; n++) {
 if ((rc = my_read(fd, &c)) == 1) {
 *ptr++ = c;
 if (c == 'n')
 break;
 } else if (rc == 0) {
 *ptr = 0;
 return n - 1;
 } else
 return -1;
 }
 *ptr = 0;
 return n;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
#include "wrap.h"

void perr_exit(const char *s)
{
 perror(s);
 exit(1);
}

int Accept(int fd, struct sockaddr *sa, socklen_t * salenptr)
{
 int n;
 again:
 if ((n = accept(fd, sa, salenptr)) < 0) {
 if ((errno == ECONNABORTED) || (errno == EINTR))
 goto again;
 else
 perr_exit("accept error");
 }
 return n;
}

void Bind(int fd, const struct sockaddr *sa, socklen_t salen)
{
 if (bind(fd, sa, salen) < 0)
 perr_exit("bind error");
}

void Connect(int fd, const struct sockaddr *sa, socklen_t salen)
{
 if (connect(fd, sa, salen) < 0)
 perr_exit("connect error");
}

void Listen(int fd, int backlog)
{
 if (listen(fd, backlog) < 0)
 perr_exit("listen error");
}

int Socket(int family, int type, int protocol)
{
 int n;
 if ((n = socket(family, type, protocol)) < 0)
 perr_exit("socket error");
 return n;
}

ssize_t Read(int fd, void *ptr, size_t nbytes)
{
 ssize_t n;
 again:
 if ((n = read(fd, ptr, nbytes)) == -1) {
 if (errno == EINTR)
 goto again;
 else
 return -1;
 }
 return n;
}

ssize_t Write(int fd, const void *ptr, size_t nbytes)
{
 ssize_t n;
 again:
 if ((n = write(fd, ptr, nbytes)) == -1) {
 if (errno == EINTR)
 goto again;
 else
 return -1;
 }
 return n;
}

void Close(int fd)
{
 if (close(fd) == -1)
 perr_exit("close error");
}

ssize_t Readn(int fd, void *vptr, size_t n)
{
 size_t nleft;
 ssize_t nread;
 char *ptr;
 ptr = vptr;
 nleft = n;
 while (nleft > 0) {
 if ((nread = read(fd, ptr, nleft)) < 0) {
 if (errno == EINTR)
 nread = 0;
 else
 return -1;
 } else if (nread == 0)
 break;
 nleft -= nread;
 ptr += nread;
 }
 return n - nleft;
}

ssize_t Writen(int fd, const void *vptr, size_t n)
{
 size_t nleft;
 ssize_t nwritten;
 const char *ptr;
 ptr = vptr;
 nleft = n;
 while (nleft > 0) {
 if ((nwritten = write(fd, ptr, nleft)) <= 0) {
 if (nwritten < 0 && errno == EINTR)
 nwritten = 0;
 else
 return -1;
 }
 nleft -= nwritten;
 ptr += nwritten;
 }
 return n;
}

ssize_t my_read(int fd, char *ptr)
{
 static int read_cnt;
 static char *read_ptr;
 static char read_buf[100];
 if (read_cnt <= 0) {
 again:
 if ((read_cnt = read(fd, read_buf, sizeof(read_buf))) < 0) {
 if (errno == EINTR)
 goto again;
 return -1;
 } else if (read_cnt == 0)
 return 0;
 read_ptr = read_buf;
 }
 read_cnt--;
 *ptr = *read_ptr++;
 return 1;
}

ssize_t Readline(int fd, void *vptr, size_t maxlen)
{
 ssize_t n, rc;
 char c, *ptr;
 ptr = vptr;
 for (n = (ssize_t)1; n < (ssize_t)maxlen; n++) {
 if ((rc = my_read(fd, &c)) == 1) {
 *ptr++ = c;
 if (c == 'n')
 break;
 } else if (rc == 0) {
 *ptr = 0;
 return n - 1;
 } else
 return -1;
 }
 *ptr = 0;
 return n;
}