嵌入式Linux网络编程——TCP/UDP

最新推荐文章于 2023-04-11 14:19:35 发布
最新推荐文章于 2023-04-11 14:19:35 发布
阅读量1.6k 收藏 13
点赞数 1
分类专栏： 嵌入式基础 Linux应用 文章标签： tcp_udp
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hceng_linux/article/details/89874013
版权

CSDN仅用于增加百度收录权重，排版未优化，日常不维护。请访问：www.hceng.cn 查看、评论。
本博文对应地址: https://hceng.cn/2017/12/30/嵌入式Linux网络编程——TCP_UDP/#more

本文主要记录TCP/UDP网络编程的基础知识，采用TCP/UDP实现宿主机和目标机之间的网络通信。

回想去年校招那会，笔试题老是出现TCP/UDP相关的内容。
那时候的我，熟悉点硬件，勉强会点STM32，哪知道什么TCP/UDP……
渐渐的，TCP/UDP似乎就成了一个挥之不去的阴影。
赶在今年年底，简单的入下门，明年估计会用上。

1.目标

暂时想不出什么好的应用场景，
目前想到目标就是实现让两个设备通过网络传输数据，
比如开发板和Linux主机之间传数据，
以后就可以实现开发板通过网络上报数据或者主机通过网络控制开发板。

此外，暂时不想关心具体的网络模型，更注重于网络相关函数的直接使用。

2.Linux网络编程基础

2.1 嵌套字

多个TCP连接或者多个应用程序进程 可能需要同一个TCP端口传输数据。
为了区分不同应用程序进程和连接，许多计算机操作系统为应用程序与TCP/IP交互提供了称为**嵌套字(Socket)**的接口。
Linux中的网络编程正是通过Socket接口实现的，Socket是一种文件描述符。

常用的TCP/IP有以下三种类型的嵌套字：

  • 流式嵌套字（SOCK_STREAM）
    用于提供面向连接的、可靠的数据传输服务，即使用TCP进行传输。
  • 数据报嵌套字（SOCK_DGRAM）
    用于提供无连接的服务，即使用UDP进行传输。
  • 原始嵌套字（SOCK_RAW）
    可以读写内核没有处理的IP数据报，而流式嵌套字只能读取TCP的数据，数据报嵌套字只能读取UDP的数据。

因此，如果要访问其它协议发送的数据必须使用原始嵌套字，它允许对底层协议(如IP或ICMP)直接访问。

2.2 端口

TCP/IP协议中的端口，端口号的范围从0~65535。
一类是由互联网指派名字和号码公司ICANN负责分配给一些常用的应用程序固定使用的“周知的端口”，其值一般为0~1023。例如http的端口号是80，FTP为21，SSH为22，Telnet为23等。
还有一类是用户自己定义的，通常是大于1024的整型值。

2.3 网络地址

网络通信，归根到底还是进程间的通信(不同计算机上的进程间通信)。
在网络中，每一个节点(计算机或路由)都有一个网络地址，如192.168.1.4，也就是IP地址。
两个进程通信时，首先要确定各自所在的网络节点的网络地址。

但是，网络地址只能确定进程所在的计算机，而一台计算机上很可能同时运行着多个进程，所以仅凭网络地址还不能确定到底是和网络中的哪一个进程进行通信，因此套接口中还需要包括其他的信息，也就是端口号（PORT）。
在一台计算机中，一个端口号一次只能分配给一个进程，也就是说，在一台计算机中，端口号和进程之间是一一对应关系。

所以，使用端口号和网络地址的组合可以唯一的确定整个网络中的一个网络进程。

例如，如网络中某一台计算机的IP为192.168.1.4，操作系统分配给计算机中某一应用程序进程的端口号为1500，则此时192.168.1.4 1500就构成了一个套接口。

2.3.1 网络地址的格式

在Socket程序设计中，struct sockaddr用于记录网络地址，其格式如下：
{% codeblock lang:c %}
struct sockaddr
{
unsigned short sa_family; /协议族，采用AF_XXX的形式，例如AF_INET(IPv4协议族)/
char sa_data[14]; /14字节的协议地址，包含该socket的IP地址和端口号。/
};
{% endcodeblock %}
但在实际编程中，并不针对sockaddr数据结构进行操作，而是用与其等价的sockaddr_in数据结构：
{% codeblock lang:c %}
struct sockaddr_in
{
short int sa_family; /地址族/
unsigned short int sin_port; /端口号/
struct in_addr sin_addr; /IP地址/
unsigned char sin_zero[8]; /填充0 以保持与struct sockaddr同样大小/
};
{% endcodeblock %}

2.3.2 网络地址的转换

IP地址通常用数字加点(如192.168.1.4)表示，而在struct in_addr中使用的式32位整数表示。因此，Linux提供如下函数进行两者之间的转换：

  • inet_aton()函数：

所需要头文件：
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
函数格式：
int inet_aton(const char *cp, struct in_addr *inp);
函数功能：
将a.b.c.d字符串形式的IP地址转换成32位网络序号IP地址；
*cp:存放字符串形式的IP地址的指针
*inp:存放32位的网络序号IP地址
返回值：
转换成功，返回非0，否则返回0；

  • inet_ntoa()函数：客户机端:

所需要头文件：
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
函数格式：
char *inet_ntoa(struct in_addr in);
函数功能：
将32位网络序号IP地址转换成a.b.c.d字符串形式的IP地址；
in：Internet主机地址的结构
返回值：
转换成功，返回一个字符指针，否则返回NULL；

2.4 字节序

不同的CPU采用对变量的字节存储顺序可能不同。
常用的X86结构是小端模式，很多的ARM，DSP都为小端模式，即内存的低地址存储数据的低字节，高地址存储数据的高字节。
而KEIL C51则为大端模式，内存的高地址存储数据的低字节，低地址存储数据高字节。

对于网络传输来说，数据顺序必须是一致的，网络字节顺序采用大端字节序方式。
下面是四个常用的转换函数：

主机转网络：

  • htons()函数：

所需要头文件：
#include <netinet/in.h>
函数格式：
unsigned short int htons(unsigned short int hostshort)
函数功能：
将参数指定的16位主机(host)字符顺序转换成网络(net)字符顺序；
hostshort：待转换的16位主机字符顺序数
返回值：
返回对应的网络字符顺序数；

  • htonl()函数：

所需要头文件：
#include <netinet/in.h>
函数格式：
unsigned long int htons(unsigned long int hostlong)
函数功能：
将参数指定的32位主机(host)字符顺序转换成网络(net)字符顺序；
hostlong：待转换的32位主机字符顺序数
返回值：
返回对应的网络字符顺序数；

网络转主机：

  • ntohs()函数：

所需要头文件：
#include <netinet/in.h>
函数格式：
unsigned short int ntohs(unsigned short int netshort)
函数功能：
将参数指定的16位网络(net)字符顺序转换成主机(host)字符顺序；
netshort：待转换的16位网络字符顺序数
返回值：
返回对应的主机字符顺序数；

  • ntohl()函数：

所需要头文件：
#include <netinet/in.h>
函数格式：
unsigned long int ntohl(unsigned long int netlong)
函数功能：
将参数指定的32位网络(net)字符顺序转换成主机(host)字符顺序；
netshort：待转换的32位网络字符顺序数
返回值：
返回对应的主机字符顺序数；

3.TCP

TCP有专门的传递保证机制，收到数据时会自动发送确认消息，发送方收到确认消息后才会继续发送消息，否则继续等待。
这样的好处是传输的数据是可靠的，此外它是有连接的传输，大多数网络传输都是用的TCP。

3.1 TCP流程图

3.2 TCP步骤分析##

程序分为服务器端和客户机端，先从服务器端开始分析。

  • 服务器端:
    a. 创建socket
    {% codeblock lang:c %}
    sock_fd = socket(AF_INET, SOCK_STREAM, 0);//AF_INET:IPV4;SOCK_STREAM:TCP
    if (-1 == sock_fd)
    {
    fprintf(stderr,“socket error:%s\n\a”, strerror(errno));
    exit(1);
    }
    {% endcodeblock %}

所需要头文件：
#include <sys/types.h>
#include <sys/socket.h>
函数格式：
int socket(int domain, int type, int protocol);
函数功能：
创建一个套接字；
domain:协议域(族)，决定了套接字的地址类型，例如AF_INET决定了要用IPv4地址(32位)与端口号(16位)的组合。常见的协议族有：AF_INET、AF_INET6、AF_LOCAL(或称AF_UNIX)、AF_ROUTE等；
type：指定套接字类型，SOCK_STREAM(TCP)、SOCK_DGRAM(UDP)、SOCK_RAW
protocol:指定socket所使用的传输协议编号，通常为0
返回值：
若成功，返回一个套接字描述符，否则返回-1；

Socket就是一种文件描述符，和普通的打开文件一样，需要检测其返回结果。

b. 设置socket
{% codeblock lang:c %}
memset(&server_addr, 0, sizeof(struct sockaddr_in));//clear
server_addr.sin_family = AF_INET;
server_addr.sin_addr.s_addr = htonl(INADDR_ANY);//INADDR_ANY:This machine all IP
server_addr.sin_port = htons(PORT_NUMBER);
{% endcodeblock %}
设置何种协议族，设置本机IP和端口，也就有了唯一性。

c. 绑定socket
{% codeblock lang:c %}
ret = bind(sock_fd, (struct sockaddr *)(&server_addr), sizeof(struct sockaddr));
if(-1 == ret)
{
fprintf(stderr,“bind error:%s\n\a”, strerror(errno));
close(sock_fd);
exit(1);
}
{% endcodeblock %}

所需要头文件：
#include <sys/types.h>
#include <sys/socket.h>
函数格式：
int bind(int sockfd, struct sockaddr *addr, int addrlen);
函数功能：
把套接字绑定到本地计算机的某一个端口上；
sockfd:待绑定的套接字描述符
addr：一个struct sockaddr *指针，指定要绑定给sockfd的协议地址。内容结构由前面的协议族决定。
addrlen:地址的长度
返回值：
若成功，返回0，否则返回-1，错误信息存在errno中；

d. 开始监听
{% codeblock lang:c %}
ret = listen(sock_fd, BACKLOG);
if (-1 == ret)
{
fprintf(stderr,“listen error:%s\n\a”, strerror(errno));
close(sock_fd);
exit(1);
}
{% endcodeblock %}

所需要头文件：
#include <sys/types.h>
#include <sys/socket.h>
函数格式：
int listen(int sockfd, int backlog);
函数功能：
使服务器的这个端口和IP处于监听状态，等待网络中某一客户机的连接请求，最大连接数量为backlog≤128；
sockfd:待监听的套接字描述符
backlog：最大可监听和连接的客户端数量
返回值：
若成功，返回0，否则返回-1；

e. 阻塞，等待连接
{% codeblock lang:c %}
addr_len = sizeof(struct sockaddr);
new_fd = accept(sock_fd, (struct sockaddr *)&client_addr, &addr_len);
if (-1 == new_fd)
{
fprintf(stderr,“accept error:%s\n\a”, strerror(errno));
close(sock_fd);
exit(1);
}
{% endcodeblock %}

所需要头文件：
#include <sys/types.h>
#include <sys/socket.h>
函数格式：
int accept(int sockfd, struct sockaddr *addr, int *addrlen);
函数功能：
接受连接请求，建立起与客户机之间的通信连接。服务器处于监听状态时，如果某时刻获得客户机的连接请求，此时并不是立即处理这个请求，而是将这个请求放在等待队列中，当系统空闲时再处理客户机的连接请求；
当accept函数接受一个连接时，会返回一个新的socket标识符，以后的数据传输和读取就要通过这个新的socket编号来处理，原来参数中的socket也可以继续使用，继续监听其它客户机的连接请求；
accept连接成功时，参数addr所指的结构体会填入所连接机器的地址数据；
sockfd:待监听的套接字描述符
addr:指向struct sockaddr的指针，用于返回客户端的协议地址
addrlen:协议地址的长度
返回值：
若成功，返回一个由内核自动生成的一个全新描述字，代表与返回客户的TCP连接，否则返回-1，错误信息存在errno中；

f. 接收数据
{% codeblock lang:c %}
recv_len = recv(new_fd, recv_buf, 999, 0);
if (recv_len <= 0)
{
fprintf(stderr, “recv error:%s\n\a”, strerror(errno))；
close(new_fd);
exit(1);
}
else
{
recv_buf[recv_len] = ‘\0’;
printf(“Get msg from client%d: %s\n”, client_num, recv_buf);
}
{% endcodeblock %}

所需要头文件：
#include <sys/types.h>
#include <sys/socket.h>
函数格式：
int recv(int sockfd, void *buf, size_t len, int flags);
函数功能：
用新的套接字来接收远端主机传来的数据，并把数据存到由参数buf指向的内存空间；
sockfd:sockfd为前面accept的返回值，即new_fd，也就是新的套接字
buf:指明一个缓冲区
len:指明缓冲区的长度
flags:通常为0
返回值：
若成功，返回接收到的字节数，另一端已关闭则返回0，否则返回-1，错误信息存在errno中；

g. 关闭socket
{% codeblock lang:c %}
close(sock_fd);
exit(0);
{% endcodeblock %}

为了应对多个连接，并保证它们之间相互独立，实际编程中往往还要加入多进程fork()。
让子进程接收数据，父进程继续监听新的连接。

  • 客户机端:

a. 创建socket
{% codeblock lang:c %}
sock_fd = socket(AF_INET, SOCK_STREAM, 0);//AF_INET:IPV4;SOCK_STREAM:TCP
if (-1 == sock_fd)
{
fprintf(stderr,“socket error:%s\n\a”, strerror(errno));
exit(1);
}
{% endcodeblock %}

b. 设置socket
{% codeblock lang:c %}
memset(&server_addr, 0, sizeof(struct sockaddr_in));//clear
server_addr.sin_family = AF_INET;
server_addr.sin_port = htons(PORT_NUMBER);
{% endcodeblock %}
其中注意的是，这里设置的socket内容是指 希望连接的服务器IP和端口号信息，IP地址来自用户的输入，并转换格式得到。因此，这里的设置和服务器的设置，要保持内容上的一致。
{% codeblock lang:c %}
ret = inet_aton(argv[1], &server_addr.sin_addr);
if(0 == ret)
{
fprintf(stderr,“server_ip error.\n”);
close(sock_fd);
exit(1);
}
{% endcodeblock %}

c. 连接
{% codeblock lang:c %}
ret = connect(sock_fd, (const struct sockaddr *)&server_addr, sizeof(struct sockaddr));
if (-1 == ret)
{
fprintf(stderr,“connect error:%s\n\a”, strerror(errno));
close(sock_fd);
exit(1);
}
{% endcodeblock %}

所需要头文件：
#include <sys/types.h>
#include <sys/socket.h>
函数格式：
int connect (int sockfd, struct sockaddr *serv_addr, int addrlen);
函数功能：
用来请求连接远程服务器，将参数sockfd的socket连至参数serv_addr所指定的服务器IP和端口号上去；
sockfd:客户端的socket套接字
serv_addr:一个struct sockaddr类型的结构体指针变量，存储着远程服务器的IP与端口号信息
addrlen:结构体变量的长度
返回值：
若成功，返回0，否则返回-1，错误信息存在errno中；

d. 发送
{% codeblock lang:c %}
send_buf = send(sock_fd, send_buf, strlen(send_buf), 0);
if (send_buf <= 0)
{
fprintf(stderr,“send error:%s\n\a”, strerror(errno));
close(sock_fd);
exit(1);
}
{% endcodeblock %}

所需要头文件：
#include <sys/types.h>
#include <sys/socket.h>
函数格式：
int send(int sockfd, const void *buf, int len, int flags);
函数功能：
用来发送数据给指定的远端主机；
sockfd:客户端的socket套接字
buf:指明一个缓冲区
len:指明缓冲区的长度
flags:通常为0
返回值：
若成功，返回发送的字节数，否则返回-1，错误信息存在errno中

d. 关闭socket
{% codeblock lang:c %}
close(sock_fd);
exit(0);
{% endcodeblock %}

3.3 TCP完整代码##

{% codeblock lang:c [tcp_server.c] https://github.com/hceng/learn/blob/master/tcp_udp/tcp/tcp_server.c %}
/*

  • tcp_server.c

Copyright © 2017 hceng, huangcheng.job@foxmail.com

Licensed under terms of GPLv2

This program is used for TCP / UDP learning.

https://hceng.cn/

*/
#include <stdlib.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <string.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <stdio.h>
#include <signal.h>

#define PORT_NUMBER 8888
#define BACKLOG 10

/* socket->bind->listen->accept->send/recv->close*/

int main(int argc, char **argv)
{
int sock_fd, new_fd;
struct sockaddr_in server_addr;
struct sockaddr_in client_addr;
int ret;
int addr_len;
int recv_len;
unsigned char recv_buf[1000];
int client_num = -1;

signal(SIGCHLD,SIG_IGN);

/* socket */
sock_fd = socket(AF_INET, SOCK_STREAM, 0);//AF_INET:IPV4;SOCK_STREAM:TCP
if (-1 == sock_fd)
{
    fprintf(stderr,"socket error:%s\n\a", strerror(errno));
    exit(1);
}

/* set server sockaddr_in */
memset(&server_addr, 0, sizeof(struct sockaddr_in));//clear
server_addr.sin_family = AF_INET;
server_addr.sin_addr.s_addr = htonl(INADDR_ANY);//INADDR_ANY:This machine all IP
server_addr.sin_port = htons(PORT_NUMBER);

/* bind */
ret = bind(sock_fd, (struct sockaddr *)(&server_addr), sizeof(struct sockaddr));
if(-1 == ret)
{
    fprintf(stderr,"bind error:%s\n\a", strerror(errno));
    close(sock_fd);
    exit(1);
}

/* listen */
ret = listen(sock_fd, BACKLOG);
if (-1 == ret)
{
    fprintf(stderr,"listen error:%s\n\a", strerror(errno));
    close(sock_fd);
    exit(1);
}

/* accept */
while(1)
{
    addr_len = sizeof(struct sockaddr);
    new_fd = accept(sock_fd, (struct sockaddr *)&client_addr, &addr_len);
    if (-1 == new_fd)
    {
        fprintf(stderr,"accept error:%s\n\a", strerror(errno));
        close(sock_fd);
        exit(1);
    }
    
    client_num++;
    fprintf(stderr, "Server get connetion form client%d: %s\n", client_num, inet_ntoa(client_addr.sin_addr));
    
    if (!fork())
	{
        /* Child process */
        while (1)
        {
            /* recv */
            recv_len = recv(new_fd, recv_buf, 999, 0);
            if (recv_len <= 0)
            {
                fprintf(stderr, "recv error:%s\n\a", strerror(errno));
                close(new_fd);	
                exit(1);
            }
            else
            {
                recv_buf[recv_len] = '\0';
                printf("Get msg from client%d: %s\n", client_num, recv_buf);
            }
        }	
        close(new_fd);			
    }	   
}

/* close */
close(sock_fd);
exit(0);

}
{% endcodeblock %}

{% codeblock lang:c [tcp_client.c] https://github.com/hceng/learn/blob/master/tcp_udp/tcp/tcp_client.c %}
/*

  • tcp_client.c

Copyright © 2017 hceng, huangcheng.job@foxmail.com

Licensed under terms of GPLv2

This program is used for TCP / UDP learning.

https://hceng.cn/

*/
#include <stdlib.h>
#include <stdio.h>
#include <errno.h>
#include <string.h>
#include <netdb.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <unistd.h>

#define PORT_NUMBER 8888

/* socket->connect->send->close*/
int main(int argc, char *argv[])
{
int sock_fd;
struct sockaddr_in server_addr;
int ret;
unsigned char send_buf[1000];
int send_len;

if(argc != 2)
{
    fprintf(stderr, "Usage:%s hostname\n\a", argv[0]);
    exit(1);
}

/* socket */
sock_fd = socket(AF_INET, SOCK_STREAM, 0);//AF_INET:IPV4;SOCK_STREAM:TCP
if (-1 == sock_fd)
{
    fprintf(stderr,"socket error:%s\n\a", strerror(errno));
    exit(1);
}

/* set sockaddr_in parameter*/
memset(&server_addr, 0, sizeof(struct sockaddr_in));//clear
server_addr.sin_family = AF_INET;
server_addr.sin_port = htons(PORT_NUMBER);
ret = inet_aton(argv[1], &server_addr.sin_addr);
if(0 == ret)
{
    fprintf(stderr,"server_ip error.\n");
    close(sock_fd);
    exit(1);
}

/* connect */
ret = connect(sock_fd, (const struct sockaddr *)&server_addr, sizeof(struct sockaddr));	
if (-1 == ret)
{
    fprintf(stderr,"connect error:%s\n\a", strerror(errno));
    close(sock_fd);
    exit(1);
}

while (1)
{
    if (fgets(send_buf, 999, stdin))
    {
        /* send */
        send_len = send(sock_fd, send_buf, strlen(send_buf), 0);
        if (send_len <= 0)
        {
            fprintf(stderr,"send error:%s\n\a", strerror(errno));
            close(sock_fd);
            exit(1);
        }
    }
}

/* close */
close(sock_fd);
exit(0);

}
{% endcodeblock %}

3.4 测试结果

先在Ubuntu主机上交叉编译服务器端代码，再在Ubuntu主机上编译客户端代码。
在开发板上运行服务器端代码，在Ubuntu主机先启动tmux分屏，再分别运行客户端代码。

  • 服务器端
  • 客户机端

4.UDP

UDP没有传递保证机制，如果传输中数据丢失，协议不会有任何的检测或提示。
这样的好处是传输的数据是持续的，此外它是无连接的传输，比如实时视频时，如果采用TCP，中途有一点点数据出错都会卡住，进行等待，产生延时。加入使用UDP，尽管有少量的丢帧，但数据是实时的。

4.1 UDP流程图

4.2 UDP步骤分析

从流程图可以看出，UDP比TCP的步骤少多了。

  • 服务器端:

a. 创建socket
{% codeblock lang:c %}
sock_fd = socket(AF_INET, SOCK_DGRAM, 0);//AF_INET:IPV4;SOCK_DGRAM:UDP
if (-1 == sock_fd)
{
fprintf(stderr,“socket error:%s\n\a”, strerror(errno));
exit(1);
}
{% endcodeblock %}
协议族改成SOCK_DGRAM。

b. 设置socket
{% codeblock lang:c %}
memset(&server_addr, 0, sizeof(struct sockaddr_in));//clear
server_addr.sin_family = AF_INET;
server_addr.sin_addr.s_addr = htonl(INADDR_ANY);//INADDR_ANY:This machine all IP
server_addr.sin_port = htons(PORT_NUMBER);
{% endcodeblock %}
和前面的TCP设置还是一样的。

c. 绑定socket
{% codeblock lang:c %}
ret = bind(sock_fd, (struct sockaddr *)(&server_addr), sizeof(struct sockaddr));
if(-1 == ret)
{
fprintf(stderr,“bind error:%s\n\a”, strerror(errno));
close(sock_fd);
exit(1);
}
{% endcodeblock %}
绑定的操作也没有变。

d. 接收数据
{% codeblock lang:c %}
addr_len = sizeof(struct sockaddr);
recv_len = recvfrom(sock_fd, recv_buf, 999, 0, (struct sockaddr *)&server_addr, &addr_len);
if (recv_len <= 0)
{
fprintf(stderr, “recvfrom error:%s\n\a”, strerror(errno));
close(sock_fd);
exit(1);
}
else
{
recv_buf[recv_len] = ‘\0’;
printf(“Get msg from client%d: %s\n”, client_num, recv_buf);
}
{% endcodeblock %}

所需要头文件：
#include <sys/types.h>
#include <sys/socket.h>
函数格式：
int recvfrom(int sockfd, char FAR *buf, int len, int flags, struct sockaddr FAR *from, int FAR *fromlen);
函数功能：
从套接字上接收一个数据报并保存源地址；
sockfd:标识一个已连接套接字的描述符
buf:接收数据缓冲区
len:接收数据缓冲区长度
flags:调用操作方式，由以下零个或多个组成

| flags | 说明 | recv | send |
|:-------------?:------------------?:----?:----?
| MSG_DONTROUTE | 绕过路由表查找 | | • |
| MSG_DONTWAIT | 仅本操作非阻塞 | • | • |
| MSG_OOB | 发送或接收带外数据 | • | • |
| MSG_PEEK | 窥看外来消息 | • | |
| MSG_WAITALL | 等待所有数据 | • | |

from:(可选)指针，指向装有源地址的缓冲区
fromlen:(可选)指针，指向from缓冲区长度值
返回值：
若成功，返回读入的字节数，否则返回0；

e. 关闭
{% codeblock lang:c %}
close(sock_fd);
exit(0);
{% endcodeblock %}

  • 客户机端:

a. 创建socket
{% codeblock lang:c %}
sock_fd = socket(AF_INET, SOCK_DGRAM, 0);//AF_INET:IPV4;SOCK_DGRAM:UDP
if (-1 == sock_fd)
{
fprintf(stderr,“socket error:%s\n\a”, strerror(errno));
exit(1);
}
{% endcodeblock %}
协议族改成SOCK_DGRAM。

b. 设置socket
{% codeblock lang:c %}
memset(&server_addr, 0, sizeof(struct sockaddr_in));//clear
server_addr.sin_family = AF_INET;
server_addr.sin_port = htons(PORT_NUMBER);
ret = inet_aton(argv[1], &server_addr.sin_addr);
if(0 == ret)
{
fprintf(stderr,“server_ip error.\n”);
close(sock_fd);
exit(1);
}
{% endcodeblock %}

c. 发送数据
{% codeblock lang:c %}
addr_len = sizeof(struct sockaddr);
send_len = sendto(sock_fd, send_buf, strlen(send_buf), 0, (const struct sockaddr *)&server_addr, addr_len);
if (send_len <= 0)
{
fprintf(stderr,“send error:%s\n\a”, strerror(errno));
close(sock_fd);
exit(1);
}
{% endcodeblock %}

所需要头文件：
#include <sys/types.h>
#include <sys/socket.h>
函数格式：
int sendto(int sockfd, char FAR *buf, int len, int flags, struct sockaddr FAR *to, int FAR *tolen);
函数功能：
向一指定目的地发送数据；
sockfd:一个标识套接字的描述字
buf:发送数据缓冲区
len:发送数据缓冲区长度
flags:调用方式标志位
to:(可选)指针，指向目的的套接字的地址
tolen:目的套接字地址的长度
返回值：
若成功，返回发送的字节数，如果连接已中止，返回0，如果发生错误，返回-1；

d. 关闭
{% codeblock lang:c %}
close(sock_fd);
exit(0);
{% endcodeblock %}
UDP传输的客户端少了connect()，原本该在connect()函数里传入服务器地址相关信息，现在变成了在sendto()里传入。

4.3 UDP完整代码

{% codeblock lang:c [udp_client.c] https://github.com/hceng/learn/blob/master/tcp_udp/udp/udp_server.c %}
/*

  • udp_server.c

Copyright © 2017 hceng, huangcheng.job@foxmail.com

Licensed under terms of GPLv2

This program is used for TCP / UDP learning.

https://hceng.cn/

*/
#include <stdlib.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <string.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <stdio.h>
#include <signal.h>

#define PORT_NUMBER 8888

/* socket->bind->recvfrom/sendto->close */

int main(int argc, char **argv)
{
int sock_fd;
struct sockaddr_in server_addr;
struct sockaddr_in client_addr;
int ret;
int addr_len;
int recv_len;
unsigned char recv_buf[1000];

/* socket */
sock_fd = socket(AF_INET, SOCK_DGRAM, 0);//AF_INET:IPV4;SOCK_DGRAM:UDP
if (-1 == sock_fd)
{
    fprintf(stderr,"socket error:%s\n\a", strerror(errno));
    exit(1);
}

/* set sockaddr_in parameter*/
memset(&server_addr, 0, sizeof(struct sockaddr_in));//clear
server_addr.sin_family = AF_INET;
server_addr.sin_addr.s_addr = htonl(INADDR_ANY);//INADDR_ANY:This machine all IP
server_addr.sin_port = htons(PORT_NUMBER);

/* bind */
ret = bind(sock_fd, (struct sockaddr *)(&server_addr), sizeof(struct sockaddr));
if(-1 == ret)
{
    fprintf(stderr,"bind error:%s\n\a", strerror(errno));
    close(sock_fd);
    exit(1);
}

while (1)
{
    /* recvfrom */
    addr_len = sizeof(struct sockaddr);
    recv_len = recvfrom(sock_fd, recv_buf, 999, 0, (struct sockaddr *)&client_addr, &addr_len);
    if (recv_len <= 0)
    {
        fprintf(stderr, "recvfrom error:%s\n\a", strerror(errno));
        close(sock_fd);	
        exit(1);
    }
    else
    {
        recv_buf[recv_len] = '\0';
        printf("Get msg from client:%s: %s\n", inet_ntoa(client_addr.sin_addr), recv_buf);
    }
}			

/* close */
close(sock_fd);
exit(0);

}
{% endcodeblock %}

{% codeblock lang:c [udp_client.c] https://github.com/hceng/learn/blob/master/tcp_udp/udp/udp_client.c %}
/*

  • udp_client.c

Copyright © 2017 hceng, huangcheng.job@foxmail.com

Licensed under terms of GPLv2

This program is used for TCP / UDP learning.

https://hceng.cn/

*/
#include <stdlib.h>
#include <stdio.h>
#include <errno.h>
#include <string.h>
#include <netdb.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <unistd.h>

#define PORT_NUMBER 8888

/* socket->bind->recvfrom/sendto->close */
int main(int argc, char *argv[])
{
int sock_fd;
struct sockaddr_in server_addr;
int ret;
unsigned char send_buf[1000];
int send_len;
int addr_len;

if(argc != 2)
{
    fprintf(stderr, "Usage:%s hostname\n\a", argv[0]);
    exit(1);
}

/* socket */
sock_fd = socket(AF_INET, SOCK_DGRAM, 0);//AF_INET:IPV4;SOCK_DGRAM:UDP
if (-1 == sock_fd)
{
    fprintf(stderr,"socket error:%s\n\a", strerror(errno));
    exit(1);
}

/* set sockaddr_in parameter*/
memset(&server_addr, 0, sizeof(struct sockaddr_in));//clear
server_addr.sin_family = AF_INET;
server_addr.sin_port = htons(PORT_NUMBER);
ret = inet_aton(argv[1], &server_addr.sin_addr);
if(0 == ret)
{
    fprintf(stderr,"server_ip error.\n");
    close(sock_fd);
    exit(1);
}
 
while (1)
{
    if (fgets(send_buf, 999, stdin))
    {
        /* sendto */
        addr_len = sizeof(struct sockaddr);
        send_len = sendto(sock_fd, send_buf, strlen(send_buf), 0, \

(const struct sockaddr *)&server_addr, addr_len);
if (send_len <= 0)
{
fprintf(stderr,“send error:%s\n\a”, strerror(errno));
close(sock_fd);
exit(1);
}
}
}

/* close */
close(sock_fd);
exit(0);

}
{% endcodeblock %}

4.4 测试结果

和前面TCP测试方式一样，先在Ubuntu主机上交叉编译服务器端代码，再在Ubuntu主机上编译客户端代码。
在开发板上运行服务器端代码，在Ubuntu主机先启动tmux分屏，再分别运行客户端代码。

  • 服务器端
  • 客户机端

参考资料：
博客：很全的linux网络编程技巧
王粉花. 2016. 嵌入式Linux编程与实践教程.北京: 科学出版社.
韦东山第三期项目:第1课第6.1节_一小时学会网络编程_两个简单例子_tcp_udp

hceng_blog
关注
  • 1
    点赞
  • 踩
  • 13
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
嵌入式Linux网络编程ppt
11-18
本章的内容主要分为五个部分，旨在帮助开发者掌握TCP/IP协议基础知识、嵌入式Linux的基本和高级网络编程，以及通过分析Ping源代码加深理解，并能够独立编写客户端和服务器端的通信程序，实现NTP协议。 1. **TCP/IP...
Wattcp开发包,开发DOS下的TCP/UDP程序
03-29
标题"**Wattcp开发包,开发DOS下的TCP/UDP程序**"指的是这个开发包的核心功能——为DOS环境提供TCP/IP通信的能力。`Wattcp`不仅实现了基本的TCP和UDP协议，还支持更复杂的网络操作，例如DNS解析和FTP传输，这在DOS...
Linux系统编程之网络编程
qq_52531759的博客
10-11 837
本文主要介绍TCP和UDP的编程流程。
linux内核学习之网络篇——TCP/IP概述
wintree的专栏
09-26 2603
1.ISO 参考模型 因特网协议栈中的层 人们已经进行了一些讨论关于如何将TCP/IP参考模型映射到到OSI模型。由于TCP/IP和OSI模型组不能精确地匹配，还没有一个完全正确的答案。 另外，OSI模型下层还不具备能够真正占据真正层的位置的能力；在传输层和网络层之间还需要另外一个层（网络互连层）。特定网络类型专用的一些协议应该运行在网络层上，但是却运行在基本的硬件帧交换上。类似协议的例子有
Linux系统编程——网络编程
weixin_54794458的博客
10-30 3828
Linux 系统编程——网络编程
Linux网络编程（TCP/IP/UDP）
dfjkhksc的博客
04-19 4227
参考博主 http://t.csdn.cn/9ldOh http://t.csdn.cn/9VpGz http://t.csdn.cn/QsYdv 感谢博主。 TCP/IP 是互联网的基础， TCP代表传输控制协议，IP代表互联网协议。目前有两个版本IP，一个是32位地址的IPv4 和一个是128位的 IPv6 。而IPv4 是现如今使用最多的IP版本，也是这次讨论的重点。 一、IP主机和IP地址 每一个注意由一个32位的IP地址来标识。为了方便起见，通常用32位的IP低质号用记点法标...
Linux关于TCP通讯协议的测试
weixin_45631738的博客
01-23 500
文章目录网络编程一.简介二.程序1.服务器2.客户端三.测试结果 网络编程 一.简介 这篇我们说一下，tcp通讯协议的使用，这里我们用AC7020开发板作为服务器，然后用windows下虚拟机作为客户端，两者连接到局域网当中，进行测试，首先开启服务器，然后再打开客户端程序，发送数据，服务器就会将发送的数据进行回传显示。 我们都知道tcp相对于udp比较可靠，可以理解一下 三次握手 四次挥手 三次握手 四次挥手 二.程序 我测试的局域网处于零网段的所以ip地址为 192.168.0.103，如果是两根网
FSP.rar_Linux/Unix编程_plenty4tu
09-23
在计算机网络中，PDU是数据在传输层的表示，如TCP或UDP数据段。学习如何正确构建和解析PDU是进行网络编程的关键。 3. **头文件与数据结构**：`7V2PDU.h`是一个头文件，通常包含函数声明、常量定义和数据结构定义。...
colibri-pxa3xx.rar_Linux/Unix编程_Unix_Linux_
08-11
6. **网络编程**：使用套接字API（`socket()`, `bind()`, `listen()`, `accept()`, `connect()`, `send()`, `recv()`等）进行TCP/IP和UDP通信。 7. **设备驱动编程**：理解内核模块的加载和卸载，以及如何编写字符...
嵌入式Linux应用程序开发标准教程(第2版全)
10-11
第10章 嵌入式Linux网络编程 10.1 TCP/IP概述 10.1.1 OSI参考模型及TCP/IP参考模型 10.1.2 TCP/IP协议族 10.1.3 TCP和UDP 10.2 网络基础编程 10.2.1 socket概述 10.2.2 地址及顺序处理 10.2.3 socket基础编程 10.3 ...
《Linux高性能服务器编程》学习总结（三）——TCP协议详解
a5615024的博客
02-01 114
第三章 TCP协议详解 　　TCP协议是TCP/IP协议族中另外一个重要的协议，作为传输层上的协议，它更靠近应用程序，所以具有更强的可操作性，许多socket选项都是针对TCP协议设置的。 　　我们在第一章提到过，传输层协议主要有两个，TCP协议和UDP协议，并说明了两者的区别，简单来说，TCP协议双方再数据传输之前需要先建立连接，并为该连接分配必要的内核资源，完成数据交换...
Linux网络编程 - 基于TCP的服务器端/客户端（2）
yunfan
12-31 2469
在上一篇博文中，我们实现了回声服务器端/客户端程序，并且还遗留一个回声客户端程序存在的一个问题。在本篇博文中，我们将给出遗留问题的解决方案，并详细讨论TCP的工作原理。
无连接应用程序丢包率测试/UDP丢包率测试【基于数据报套接字的网络程序设计】
一只猫猫的博客
12-01 6678
目录无连接应用程序丢包率测试UDP 丢包率测试服务端UDP丢包率测试客户端用户使用说明（输入 / 输出规定） 无连接应用程序丢包率测试 UDP的不可靠性使得基于该协议的应用程序在数据通信过程中不可避免地会遇到丢包现象。 一方面，网络拥塞导致路由器转发数据报文时丢失；另一方面，慢速设备来不及处理快速到达的数据报文，使得接收缓存溢出而丢包，等等。在应用程序开发前，设计者需要对当前的网络状况和主机性能进行测试，以确定选择哪种协议承载运输、使用循环方式还是并发方式处理网络通信等等，其中丢包率测试是常用的项目，它可以
开发板与PC机的数据传输方式总结
Stephen_jie的博客
10-29 5050
最近在学习嵌入式开发的时候，遇到了一个问题：PC机如何与开发板传送数据？在开发过程，我们总是先在自己的PC机上编写代码，然后交叉编译，完了之后再将我们生成的可执行文件“拷贝”到开发板上去运行，这就涉及到怎样将我们开发的程序传送到开发板上运行的问题。然后上网找了一些资料，补了补脑,并总结出来便于日后回顾：   一般而言PC机与开发板数据传输的方式有四种： 第一：通过U盘拷贝 第二：通过TFT
嵌入式Linux应用程序开发-TCP-IP网络通信应用程序
最新发布
newzhpfree的博客
04-11 1043
嵌入式Linux应用程序开发-TCP-IP网络通信应用程序
TCP/IP：UDP(4) 缓存与抑制
yxccc的博客
02-04 577
1.UDP协议，发送方有一个虚拟的发送缓存区。假的，意思是UDP应用程序生成数据报，就直接发送出去，不做任何处理。发送缓存区主要是限制单个数据报的大小。如果写一个太大的数据报，内核返回该进程一个EMSGSIZE错误。因为UDP是不可靠的，它不必保存应用进程数据的一个副本，因此无需一个真正的发送缓存区。2.UDP接收方具有接收缓存区，输出队列是FIFO的。3.接收缓存区有固定大小，可以通过SO_RCV
C++/socket缓冲区的大小设置
he_wen_jian的专栏
05-29 9769
//设置socket发送、接收缓冲区大小为64k，默认为8k，最大为64k int value=65535; int tmpCode=0; tmpCode=::setsockopt(m_UdpSendSocket_Quot, SOL_SOCKET, SO_RCVBUF, (char*)&value, sizeof(value)); tmpCode=::setsockopt(m_UdpSe
关于c语言的tcp通讯详细讲解
sakura0908的博客
03-17 5864
简单来讲，TCP 类似于打电话，说话前需要花一定的时间接通电话，等到对方接听了之后双方才能开始通信，通信的过程中每个数据的传送，接收方都会给发送方回执确认，断开的时候也会互相通知以便于释放各自相关的资源。TCP的通信流程跟打电话是几乎一样的，因此可以将通信的过程细分为主动发起连接者（客户端）和被动接受连接者（服务端）两方来分别讨论。2、填充服务器的结构体，绑定主机的IP地址和端口号（bind）//2、绑定主机的IP地址和端口号（bind）（可以省略）4、聊天 -- 发送数据（send/write）
udp接收缓冲设置多大
Linux C/C++后台开发
09-09 9425
先说一下保护消息边界，就是指传输协议把数据当作一条独立的消息在网上传输，接收端只能接收独立的消息。这个机制决定了udp的特性： 1. udp可以多线程对同一个fd进行发包操作，如果是tcp多线程发送，会让流乱序，接收端完全无法解析出来 2. udp接收端每次只能拿到一个包，tcp需要借助自定义包头来拆分出一个一个的包 假如现在发送端发送了长度为100,200,300的3个包，接收端需要调用3...
嵌入式软件开发技术：第6章 嵌入式Linux网络编程.ppt
05-31
嵌入式软件开发技术：第6章 嵌入式Linux网络编程.ppt

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值