掌握socket网络编程需要学习哪些基础知识
来源链接：https://blog.csdn.net/qq_36958285/article/details/84672346
- Linux网络编程篇(一)之Socket 编程预备知识
- 一. 客户机/服务器模型
- 二. 网络套接字(socket)介绍
- 三. 套接字编程基础
- 1. socket
- 2. bind
- 3. listen
- 4. accept
- 5. connect
- 6. close & shutdown
- 四．相关常用函数
- 1. 网络字节顺序(Network Byte Order)
- 2. Ip地址处理转换函数
- 3. gethostbyname()
- 五. 消息发送与接收
- 1. send() 和 recv() 函数
- 2. sendto() 和 recvfrom() 函数
Linux网络编程篇(一)之Socket 编程预备知识
Linux系统的一大特点是它的网络编程能力十分强大, 学习它, 让我们真正体会网络的魅力!
一. 客户机/服务器模型
网络应用程序一般是以c/s模型的方式工作的,因特网便是c/s模型的一个典型例子,在这种工作方式中,一个服务器通常事先启动,并在一个熟知端口帧听对服务器的请求,如ftp服务器,web服务器等.当客户机应用程序需要某种服务时,需向提供这个服务的服务器发出请求,服务器收到请求后,向客户机发出相应请求服务.这样客户机应用程序和服务器程序之间就建立了通信连接,此后便可以进行数据通信,通信任务完成后,需要关闭它们之间的通信连接.
二. 网络套接字(socket)介绍
在网路中要全局的标示一个参与通信的进程,需要采用三元组: 协议， 主机ip地址,端口号.要描述两个应用进程之间的端到端的通信则需要一个五元组: 协议,信源机ip地址,信源应用进程端口, 信宿机ip地址,信宿应用进程端口.那么从程序设计的角度如何实现两个应用进程的通信连接的建立,并如何实现两个进程指佳酿数据传输呢?人们引入套接字(Socket)的概念.
- 套接字实现了对网络和传输层协议的封装
- 套接字可以看做是处于不同主机之间的两个进程的通信连接端点
- 在实现两个进程间的通信时, 首先应用进程各自创建自己的套接字,然后通过套接字建立双方的通信链路,进而利用各自的套接字进行数据的发送个接收
socket这个词可以表示很多概念：
-
在TCP/IP协议中，“IP地址+TCP或UDP端口号”唯一标识网络通讯中的一个进程，“IP地址+端口号”就称为socket。
-
在TCP协议中，建立连接的两个进程各自有一个socket来标识，那么这两个socket组成的socket pair就唯一标识一个连接。socket本身有“插座”的意思，因此用来
描述网络连接的一对一关系。 -
TCP/IP协议最早在BSD UNIX上实现，为TCP/IP协议设计的应用层编程接口称为socket API
Socket进一步介绍:
socket是使用标准unix文件描述符(file descriptor)和其他程序通讯的方式. Unix中的一切都是文件,接触过Unix/Linux,就一定会听过这句话. 实际上, unix程序在执行任何形式的I/O时,程序都是在读或者写一个文件描述符. 一个文件描述符只是一个跟打开的文件相关联的整数, 这个文件可能是一个网络连接, FIFO, 管道, 终端, 文件或者什么其他东西. 所以你要和网络上的其他程序通信时,你就要用到文件描述符, 那怎么得到网络通信的文件描述符呢?
利用系统调用socket((),它会返回套接字描述符(socket descriptor), 然后就可以用它来send(), recv() ,发送接收数据.
三. 套接字编程基础
Tcp/Ip的核心内容被封装在操作系统中,网络应用程序要使用tcp/ip来实现自己的功能,需要通过操作系统提供给用户的编程借口来实现. 套接字就是Tcp/Ip网络编程接口的集合,他是应用程序预tcp/ip协议族通信的中间软件抽象层.
1. socket
// socket - create an endpoint for communication
#include
#include
int socket(int domain, int type,int protocol)
// DESCRIPTION
// socket() creates an endpoint for communication and returns a file descriptor that
// refers to that endpoint. The file descriptor returned by a successful call will
// be the lowest-numbered file descrip‐tor not currently open for the process.
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
domain: 说明我们网络程序所在的主机采用的通讯协族(AF_UNIX 和 AF_INET 等). AF_UNIX 只能够用于单一的 Unix 系统进程间通信,而 AF_INET 是针对 Internet 的,因而可以允许在远程 主机之间通信(当我们 man socket 时发现 domain 可选项是 PF_而不是 AF_,因为glibc 是 posix 的实现 所以用 PF 代替了 AF,不过我们都可以使用的).
type: 我们网络程序所采用的通讯协议(SOCK_STREAM,SOCK_DGRAM 等)
-
SOCK_STREAM(流套接字) 表明我们用的是 TCP 协议,这样会提供按顺序的,可靠,双向,面向连接的比特流. -
SOCK_DGRAM(数据包套接字) 表明我们用的是 UDP 协议,这样只会提供定长的,不可靠,无连接的通信. -
SOCK_RAW(原始套接字) 表明这是个原始套接字, 相对与上面两种类型, 提供了更多的功能, 实现ping/traceruoute等均需要创建此类套接字
| 网络层次 | Operation | SOCK_STREAM / SOCK_DGRAM | SOCK_ROW |
|---|---|---|---|
| 应用层(Application Layer) | telnet, ftp, http, dns… | √ | √ |
| 传输层(Transport Layer) | TCP, UDP | √(数据部分) | √ |
| 网络层(Internet Layer) | IP | × | √ |
| 数据链路层(Data link) | MAC | × | √ |
链路层的原始套接字可以直接用于接收和发送链路层的MAC帧，在发送时需要由调用者自行构造和封装MAC首部。
网络层的原始套接字可以直接用于接收和发送IP层的报文数据，在发送时需要自行构造IP报文头
一般的套接字只能操作传输层的数据部分的内容, 我们只能将发送的数据(buffer)传递给系统, 系统帮我们给数据加上tcp/udp头部,再加上ip头部, 再给发出去; 而使用原始套接字 需要我们自己构造每个部分, 系统只是将它发出去, 想一想, 这是不是多了好多乐趣呢 ^_^
注: 原始套接字需要root权限, 针对具体情况使用相应套接字类型, 推荐阅读 书 籍 书 籍 书 籍 书籍书籍 书籍 书籍书籍书籍书籍1
protocol :由于我们指定了 type,所以这个地方我们一般只要用 0 来代替就可以了, socket 为网络通讯做基本的准备. 如果我们使用的是原始套接字,这个时候系统是不知道你要发送什么类型数据结构的数据, 这时候就需要指定协议类型, 如 IPPROTO_ICMP, IPPROTO_TCP, IPPROTO_UDP等.
Return Value : 成功时返回文件描述符,失败时返回-1,看 全局变量 errno 可知道出错的详细情况
// 常用方式 下同
if((sockfd = socket(AF_INET, SOCK_STREAM, 0)) == -1){
fprintf(stderr,"Create Socket Error, %s\n", perror(errno);
exit(errno);
}
- 1
- 2
- 3
- 4
- 5
2. bind
// bind - bind a name to a socket
#include int bind(int sockfd, struct sockaddr *my_addr, int addrlen)
- 1
- 2
- 3
- 4
- 5
sockfd: 是由 socket 调用返回的文件描述符.
addrlen: 是 sockaddr 结构的长度.
my_addr: 是一个指向结构体 sockaddr 的指针,它保存你的地址(即端口和 IP 地址) 信息。 在
struct sockaddr{
unisgned short as_family;
char sa_data[14];
};
- 1
- 2
- 3
- 4
不过由于系统的兼容性,我们一般不用这个头文件,而使用另外一个结构(struct sockaddr_in) 来代替.在
struct sockaddr_in{
unsigned short sin_family;
unsigned short int sin_port;
struct in_addr sin_addr;
unsigned char sin_zero[8];
}
- 1
- 2
- 3
- 4
- 5
- 6
注: 由于sockaddr数据结构与sockaddr_in数据结构的大小是相同的,指向sockaddr_in的指针可以通过强制类型转换,转换成指向sockaddr结构的指针
我们主要使用 Internet 所以 sin_family 一般为 AF_INET,
sin_addr.s_addr 设置为 INADDR_ANY 表示自动填上所运行的机器的ip地址,
sin_port 是我们要监听的端口号, 赋值0则告诉系统自动选择端口
sin_zero[8]是用来填充的
bind 将本地的端口同 socket 返回的文件描述符捆绑在一起.成功是返回 0,失败的情况和socket 一样
简单例子:
#include int main(void)
{
int sockfd; // 定义套接字
struct sockaddr_in my_addr; // 定义存储本地地址信息的结构体
sockfd = socket(PF_INET, SOCK_STREAM, 0); // 创建套接字
my_addr.sin_family = AF_INET;
my_addr.sin_port = htons(_INT_PORT);
my_addr.sin_addr.s_addr = inet_addr("132.241.5.10");
bzero(&(my_addr.sin_zero), sizeof(my_addr.sin_zero));
if(bind(sockfd, (struct sockaddr *)&my_addr,sizeof(struct sockaddr_in)) == -1){ // 绑定套接字
fprintf(stderr, "Bind socket error, %s\n", perror(errno));
exit(errno);
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
这个过程就是指定程序绑定到系统的某一个端口, 试想一下, 这个bind过程 是不是必须的呢?
3. listen
// listen - listen for connections on a socket
#include int listen(int sockfd, int backlog);
- 1
- 2
- 3
- 4
- 5
sockfd:是 bind 后的文件描述符.
backlog:设置请求排队的最大长度.当有多个客户端程序和服务端相连时, 使用这个表示可以连接的最大长度.
listen 函数将 bind 的文件描述符变为监听套接字.返回的情况和 bind 一样.在发生错误的时候返回-1,并设置全局错误变量 errno
以上的过程就是, 创建一个套接字, 绑定本地的地址信息, 然后在 Listen, 监听这个端口 , 等待别人来连接, 而我们用下面的accept来接收别人的连接
4. accept
// 在发生错误的时候返回-1,并设置全局错误变量 errno
#include int accept(int sockfd, struct sockaddr addr,int addrlen)
- 1
- 2
- 3
- 4
- 5
sockfd:是 listen 后的文件描述符.
addr,addrlen 是用来给客户端的程序填写的,服务器端只要传递指针就可以了.
bind,listen 和 accept 是服务器端用的函数,
accept 调用时,服务器端的程序会一直阻塞到有一个客户程序发出了连接. accept 成功时返回最后的服务器端的文件描述符,这个时候服务器端可以通过该描述符进行send() 和 recv()操作. 失败时返回-1
具体代码感受一下:
#include#include #include #define SET_PORT 3490 int main(void) { int sockfd, new_fd; struct sockaddr_in my_addr; struct sockaddr_in their_addr; int sin_size; sockfd = socket(PF_INET, SOCK_STREAM, 0); my_addr.sin_family = AF_INET; my_addr.sin_port = htons(_INT_PORT); my_addr.sin_addr.s_addr = INADDR_ANY; bzero(&(my_addr.sin_zero),sizeof(my_addr.sin_zero)); bind(sockfd, (struct sockaddr *)&my_addr,sizeof(struct sockaddr));// 绑定套接字 listen(sockfd, 10); // 监听套接字 sin_size = sizeof(struct sockaddr_in); new_fd = accept(sockfd, &their_addr, &sin_size); // 接收套接字
}
- 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
5. connect
// connect - initiate a connection on a socket
#include int connect(int sockfd, struct sockaddr * serv_addr,int addrlen)
- 1
- 2
- 3
- 4
- 5
sockfd:socket 返回的文件描述符.
serv_addr:储存了服务器端的地址信息(IP地址, 端口号)的数据结构.其中 sin_add 是服务端的地址
addrlen:serv_addr 的长度 sizeof(struct sockaddr);
connect 函数是客户端用来同服务端连接的.成功时返回 0,sockfd 是同服务端通讯的文件描述符 失败时返回-1.
我们想一想,我们连接服务器,是不是只需要在套接字中提供服务器端的ip地址和端口号即可, 不需要指定本地的ip地址和端口号, 也即这个时候使用bind()来绑定客户端的地址信息,这个操作不是必须的, 系统会自动获取本地ip, 自动为该套接字分配端口号
6. close & shutdown
如果你已经整天都在发送 (send()) 和接收 (recv()) 数据了,现在你准备关 闭你的套接字描述符了。
这很简单,你可以使用一般的 Unix 文件描述符 的 close() 函数:
close(sockfd);它将防止套接字上更多的数据的读写。任何在另一端读写套接字的企图都将返回错误信息。
如果你想在如何关闭套接字上有多一点的控制,你可以使用函数 shutdown()。
它允许你将一定方向上的通讯或者双向的通讯(就象 close()一 样)关闭,你可以使用:
int shutdown(int sockfd, int how);
sockfd 是你想要关闭的套接字文件描述复。how 的值是下面的其中之 一:
0 - 不允许接受
1 - 不允许发送
2 - 不允许发送和接受(和 close() 一样)
shutdown() 成功时返回 0,失败时返回 -1(同时设置 errno。) 如果在无连接的数据报套接字中使用 shutdown(),那么只不过是让 send() 和 recv() 不能使用(记住你在数据报套接字中使用了 connect 后 是可以使用它们的)
四．相关常用函数
1. 网络字节顺序(Network Byte Order)
内存中的多字节数据相对于内存地址有大端和小端之分，磁盘文件中的多字节数据相对于文件中的偏移地址也
有大端小端之分。网络数据流同样有大端小端之分，那么如何定义网络数据流的地址呢？发送主机通常将发送
缓冲区中的数据按内存地址从低到高的顺序发出，接收主机把从网络上接到的字节依次保存在接收缓冲区中，
也是按内存地址从低到高的顺序保存，因此，网络数据流的地址这样规定：先发出的数据是低地址，后发出
的数据是高地址。
Tcp/Ip协议规定, 网络传输字节顺序为高位优先,为了使网络程序具有可移植性, 需要对程序将本地字节顺序转换为网络字节顺序, 可以调用库函数做网络字节序和主机字节序(Host Byte Order)的转换, 常用函数如下:
#includeuint32_t htonl(uint32_l hostlong); // "Host to Network Long" uint16_t htons(uint16_t hostshort); // "Host to Network Short" uint32_t ntohl(uint32_t netlong); // "Network to Host Long" uint16_t ntohs(uint16_t netshort); // "Network to Host Short"
- 1
- 2
- 3
- 4
- 5
- 6
- 问: 如果我的主机使用的就是网络字节顺序, 为什么还要调用 htonl() 转换 IP 地址呢？
因为将你的程序移植到别人的电脑上可能会报错(具备可移植性). 记住:在你将数据放到网络上的时候,确信它们是网络字节顺序的! - 问: 为什么在数据结构 struct sockaddr_in 中, sin_addr 和 sin_port 需要转换为网络字节顺序,而 sin_family 需不需要呢?
答案是:sin_addr 和 sin_port分别封装在包的 IP 和 UDP 层。因此,它们必须要 是网络字节顺序。但是 sin_family域只是被内核 (kernel) 使用来决定在数 据结构中包含什么类型的地址,所以它必须是本机字节顺序。同时, sin_family 没有发送到网络上,它们可以是本机字节顺序。
2. Ip地址处理转换函数
我们有很多的函数来方便地操作 IP 地址。没有必要用手工计算它们,也没有必要用"<<"操作来储存成长整字型．
假如我们现在有一个sockaddr_Ser 的地址结构体, 要将ip地址"103.21.187.5"保存到该结构体中, 我们可以用
#include sockaddr_Ser.sin_addr.s_addr = inet_addr(“103.21.187.5”);
- 1
- 2
- 3
- 4
- 5
注意, inet_addr()返回的地址已经是网络字节格式,所以你无需再调用 函数 htonl()。
那如何讲一个长整型的ip地址转为点分十进制呢?
#include printf("%s", inet_ntoa(sockaddr_Clinet.sin_addr));
- 1
- 2
- 3
- 4
- 5
inet_ntoa() 含义 network to ascii .
需要注意的是 inet_ntoa()将结构体 in-addr 作为一 个参数,不是长整形
同样需要注意的是它返回的是一个指向一个字符的指针。它是一个由 inet_ntoa()控制的静态的固定的指针,所以每次调用 inet_ntoa(),它就将覆盖上次调用时所得的IP 地址
3. gethostbyname()
通过给定的名字, 找到相应的主机信息, 如给定域名,查找返回ip地址, 进行bind, connect等操作.
#include struct hostent gethostbyname(const char name);
// 很明白的是,它返回一个指向 struct hostent 的指针。这个数据结构 是这样的:
struct hostent
{
char h_name; // 地址的正式名称
char h_aliases; // 空字节-地址的预备名称的指针
int h_addrtype; // 地址类型; 通常是 AF_INET
int h_length; // 地址的比特长度
char *h_addr_list; // 零字节-主机网络地址指针。网络字节顺序
};
#define h_addr h_addr_list[0]
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
gethostbyname() 成功时返回一个指向结构体 hostent 的指针,或者 是个空 (NULL)指 针 。 ( 但 是 和 以 前 不 同 , 不 设 置 errno , h_errno 设 置 错 误 信 息 。)
参照代码例子, 加快理解:
#include int main(int argc, char argv[]){
struct hostent ht;
char pptr;
int type;
if(argc != 2){
fprintf(stderr, “usage: ./filename [address]\n”);
exit(EXIT_FAILURE);
}
if(!(ht = gethostbyname(argv[1]))){
herror(“main gethostbyname error”);
exit(EXIT_FAILURE);
}
//打印所有信息
printf(“Host name is: %s\n”, ht->h_name);
//打印所有的主机地址
for(pptr=ht->h_aliases; (pptr); ++pptr)
printf(“alias of host: %s\n”, pptr);
printf(“Host addrtype is: %d\n”, type = ht->h_addrtype);
printf(“Host length is: %d\n”, ht->h_length);
if(typeAF_INET || typeAF_INET6){
char ip[32];
for(pptr = ht->h_addr_list; (pptr); ++pptr){
inet_ntop(type, pptr, ip, sizeof ip);
printf(“address: %s\n”, ip);
}
}
return 0;
}
- 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
五. 消息发送与接收
前面我们已经讲了如何创建,绑定, 监听, 连接套接字的操作, 可能等不及的同学已经开始想, 那怎么通过套接字发送数据呢. 这一小节我们就来讲消息发送接收的函数调用.
在这之前,附上一张简单但很重要的流程图, 纵使这系列后面的内容说的再天花乱坠, 实质上也是这图上的流程. 特别是刚起步的同学, 记住这张图, 就把握了整体的流程脉络, 不至于代码无从敲起.
1. send() 和 recv() 函数
这两个函数用于流式套接字或者数据报套接字的通讯。
#include // send — send a message on a socket
ssize_t send(int socket, const void *buffer, size_t length, int flags);
// recv — receive a message from a connected socket
ssize_t recv(int socket, void *buffer, size_t length, int flags);
- 1
- 2
- 3
- 4
- 5
- 6
- 7
socket 是你想发送数据的套接字描述符(或者是调用 socket() 或者是 accept() 返回的 )
buffer 是指向你想发送的数据的指针。
length 是数据的长度。
把 flags 设置为 0 就可以了, 刚开始用不上(详细的资料请看 send() 的 man page)
send() 返回实际发送的数据的字节数–它可能小于你要求发送的数 目!
注意,有时候你告诉它要发送一堆数据可是它不能处理成功。它只是 发送它可能发送的数据,然后希望你能够发送其它的数据。记住,如果 send() 返回的数据和 len 不匹配,你就应该发送其它的数据。
最后要说得就是,它在错误的时候返回-1,并设置 errno。
recv() 函数很类似
socket 是要读的套接字描述符。
buffer 是要读的信息的缓冲。
length 是缓 冲的最大长度。
flags 可以设置为 0。(请参考 recv() 的 man page)
recv() 返回实际读入缓冲的数据的字节数。或者在错误的时候返回-1, 同时设置 errno。
2. sendto() 和 recvfrom() 函数
这两个函数用于 无连接数据报套接字
#include ssize_t sendto(int socket, const void buffer, size_t length, int flags,
const struct sockaddr dest_addr,socklen_t dest_len);
ssize_t recvfrom(int socket, void restrict buffer, size_t length,
int flags, struct sockaddr restrict address,
socklen_t *restrict address_len);
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
可以看到,sendto() 函数除了另外的两个信息外,其余的和函数 send() 是一样 的。
dest_addr 是个指向数据结构 struct sockaddr 的指针,它包含了目的地的 IP 地址和端口信息。
dest_len 可以简单地设置为 sizeof(struct sockaddr)。
和函数 send() 类似, sendto() 返回实际发送的字节数(它也可能小于 你想要发送的字节数!),或者在错误的时候返回 -1。
recvfrom() 函数也是类似, 除了两个增加的参数外,这个函数和 recv() 也是一样的。
address 是一个指向局部数据结构 struct sockaddr 的指针,它的内容是请求连接方的 IP 地址和端口信息。
address_len 是个 int 型的局部指针,它的初始值为 sizeof(struct sockaddr)。
函数调用返回后, address_len 保存着实际储存在 address 中的地址的长度。
recvfrom() 返回收到的字节长度,或者在发生错误后返回 -1。
问: 为什么udp连接的套接字函数(sendto, recvfrom) 相比与tcp的通信的套接字,要提供更多的参数呢?
答: 这是因为tcp是面向连接的协议,在双方通信之前,是已经建立好了连接, 直接send数据, 便可发到连接另一端的消息接收方;
而udp是无连接的协议, 通信之间没有建立连接, 所以在发送消息时, 必须指明消息接收方的地址信息(IP地址及端口号), 才能将消息发送给对方.
注: 如果你用 connect() 连接一个数据报套接字,你可以简单的调 用 send() 和recv() 来满足你的要求。这个时候依然是数据报套接字,依 然使用 UDP,系统套接字接口会为你自动加上了目标和源的信息
原来是不想贴代码的, 但怕有些人看完上面的内容,急不可耐的向感受一下, 还是给附上一个最简单的demo:
更多代码移步我github: https://github.com/D-lyw/Socket_C_linux 查看相关代码: tcp, udp, ping, tracert, dns, ftp…
tcp_server.c
/*
* @Author: D-lyw
* @Date: 2018-10-25 00:48:44
* @Last Modified by: D-lyw
* @Last Modified time: 2018-11-16 12:29:37
*/
#include
#include
#include
#include
#include
#include
#include
#include
#include
#define SERVADDR_PORT 8800
const char *LOCALIP = “127.0.0.1”;
int main(int argc, char const *argv[])
{
// 定义变量存储生成或接收的套接字描述符
int listenfd, recvfd;
// 定义一个数据结构用来存储套接字的协议,ip,端口等地址结构信息
struct sockaddr_in servaddr, clientaddr;
// 定义接收的套接字的数据结构的大小
unsigned int cliaddr_len, recvLen;
char recvBuf[1024];
//创建用于帧听的套接字
listenfd = socket(AF_INET, SOCK_STREAM, 0);
// 给套接字数据结构赋值,指定ip地址和端口号
servaddr.sin_family = AF_INET;
servaddr.sin_port = htons(SERVADDR_PORT);
servaddr.sin_addr.s_addr = inet_addr(LOCALIP);
// 绑定套接字
if(bind(listenfd, (struct sockaddr *)&servaddr, sizeof(servaddr)) == -1){
fprintf(stderr, "绑定套接字失败,%s\n", strerror(errno));
exit(errno);
}
// 监听请求
if(listen(listenfd, 10) == -1){
fprintf(stderr, "绑定套接字失败,%s\n", strerror(errno));
exit(errno);
}
cliaddr_len = sizeof(struct sockaddr);
// 等待连接请求
while (1){
// 接受由客户机进程调用connet函数发出的连接请求
recvfd = accept(listenfd, (struct sockaddr *)&clientaddr, &cliaddr_len);
printf("接收到请求套接字描述符: %d\n", recvfd);
while(1){
// 在已建立连接的套接字上接收数据
if((recvLen = recv(recvfd, recvBuf, 1024, 0)) == -1){
fprintf(stderr,"接收数据错误, %s\n",strerror(errno));
}
printf("%s", recvBuf);
}
}
close(recvfd);
return 0;
}
- 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
tcp_client.c
/*
* @Author: D-lyw
* @Date: 2018-10-26 14:06:32
* @Last Modified by: D-lyw
* @Last Modified time: 2018-11-16 12:34:08
* @name tcp_client.c
* @descripe 实现最基本的创建套接字, 填充客户端信息,connet连接服务端, 可连续向服务端发送消息
*/
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
extern int errno;
#define SERVERPORT 8800
int main(int argc, char const *argv[])
{
// 定义变量存储本地套接字描述符
int clifd;
// 设置本地ip地址
const char serverIp[] = “127.0.0.1”;
// 定义套接字结构存储套接字的ip,port等信息
struct sockaddr_in cliaddr_in;
// 定义发送,接收缓冲区大小
char sendBuf[1024], recvBuf[1024];
// 创建套接字
if((clifd = socket(AF_INET, SOCK_STREAM, 0)) == -1){
fprintf(stderr, "创建套接字失败,%s\n", strerror(errno));
exit(errno);
}
// 填充 服务器端结构体信息
cliaddr_in.sin_family = AF_INET;
cliaddr_in.sin_addr.s_addr = inet_addr(serverIp);
cliaddr_in.sin_port = htons(SERVERPORT);
// 请求连接服务器进程
if(connect(clifd, (struct sockaddr *)&cliaddr_in, sizeof(struct sockaddr)) == -1){
fprintf(stderr,"请求连接服务器失败, %s\n", strerror(errno));
exit(errno);
}
strcpy(sendBuf, "hi,hi, severs!\n");
// 发送打招呼消息
if(send(clifd, sendBuf, 1024, 0) == -1){
fprintf(stderr, "send message error:(, %s\n", strerror(errno));
exit(errno);
}
// 阻塞等待输入,发送消息
while(1){
fgets(sendBuf, 1024, stdin);
if(send(clifd, sendBuf, 1024, 0) == -1){
fprintf(stderr, "send message error:(, %s\n", strerror(errno));
}
}
close(clifd);
return 0;
}
- 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
终于写完了, 如果觉得写的还可以,请点个赞 :）．．．
这是Linux网络编程系列的第一篇文章, 感兴趣的同学, 可浏览该系列的其他文章
- Linux网络编程篇之ICMP协议分析及ping程序实现
- Linux网络编程之TCP及聊天室功能实现
- 未完待续…
UNIX网络编程 卷1：套接字联网API ↩︎