嵌入式学习笔记--Linux Socket网络编程

咕咕猪蹄子

已于 2023-03-09 20:45:30 修改

阅读量441

点赞数

分类专栏： Linux网络编程文章标签： c语言 linux Powered by 金山文档

于 2023-03-09 17:04:25 首次发布

本文链接：https://blog.csdn.net/weixin_57672679/article/details/129311724

版权

Linux网络编程专栏收录该内容

2 篇文章 0 订阅

订阅专栏

文章介绍了TCP和UDP两种网络传输协议的区别，包括连接方式、可靠性、数据处理和适用场景。同时，详细阐述了Socket的基本概念，包括Socket服务器和客户端的开发步骤，以及相关函数如socket、bind、listen、connect、accept、read、write和close的使用。此外，提到了字节序在网络通信中的作用，并给出了简单的服务器和客户端示例代码。

摘要由CSDN通过智能技术生成

https://zhuanlan.zhihu.com/p/475601892

内容参考引用大佬博文

TCP/UDP对比

1. TCP面向连接（如打电话要先拨号建立连接）;UDP是无连接的，即发送数据之前不需要建立连接

2. TCP提供可靠的服务。也就是说,通过TCP连接传送的数据，无差错,不丢失,不重复,且按序到达;UDP尽最大努力交付，即不保证可靠交付。

3. TCP面向字节流，实际上是TCP把数据看成一连串无结构的字节流;UDP是面向报文的,UDP没有拥塞控制,因此网络出现拥塞不会使源主机的发送速率降低（对实时应用很有用,如IP电话,实时视频会议等）

4. 每一条TCP连接只能是点到点的;UDP支持一对一，一对多，多对一和多对多的交互通信。

5. TCP首部开销20字节;UDP的首部开销小，只有8个字节。

6. TCP的逻辑通信信道是全双工的可靠信道，UDP则是不可靠信道。

端口号的作用

字节序

1． Little endian：将低序字节存储在起始地址（小端字节序）

2． Big endian：将高序字节存储在起始地址（大端字节序）

网络字节序 = 大端字节序

字节序转换api

什么是Socket？

所谓套接字（Socket），就是对网络中不同主机上的应用进程之间进行双向通信的端点的抽象。一个套接字就是网络上进程通信的一端，提供了应用层进程利用网络协议交换数据的机制。从所处的地位来讲，套接字上联应用进程，下联网络协议栈，是应用程序通过网络协议进行通信的接口，是应用程序与网络协议栈进行交互的接口.

Sockt服务器和客户端的开发步骤

servr.c服务端的开发步骤

创建套接字

为套接字添加信息（IP地址和端口号）即地址准备好

监听网络连接

监听客户端接入，接受一个连接

数据交换

关闭套接字，断开连接

client.c客户端的开发步骤

创建套接字 socket

创建连接 connect

数据写入 write

数据读取 read

关闭套接字 close

Sokcet相关的函数、API

既然socket是“open—write/read—close”模式的一种实现，那么socket就提供了这些操作对应的函数接口。

scoket函数

#include <sys/types.h>         
#include <sys/socket.h>

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

socket函数对应于普通文件的打开操作。普通文件的打开操作返回一个文件描述字，而socket()用于创建一个socket描述符（socket descriptor），它唯一标识一个socket。这个socket描述字跟文件描述字一样，后续的操作都有用到它，把它作为参数，通过它来进行一些读写操作。

domain：即协议域，又称为协议族（family）。常用的协议族有，AF_INET、AF_INET6、AF_LOCAL（或称AF_UNIX，Unix域socket）、AF_ROUTE等等。协议族决定了Socket的地址类型，在通信中必须采用对应的地址，如AF_INET决定了要用ipv4地址（32位的）与端口号（16位的）的组合、AF_UNIX决定了要用一个绝对路径名作为地址。

type：指定Socket类型。常用的Socket类型有，SOCK_STREAM、SOCK_DGRAM、SOCK_RAW、SOCK_PACKET、SOCK_SEQPACKET等等（Socket的类型有哪些？）。

protocol：故名思意，就是指定协议。常用的协议有，IPPROTO_TCP、IPPTOTO_UDP、IPPROTO_SCTP、IPPROTO_TIPC等，它们分别对应TCP传输协议、UDP传输协议、STCP传输协议、TIPC传输协议。

注意：并不是上面的type和protocol可以随意组合的，如SOCK_STREAM不可以跟IPPROTO_UDP组合。当protocol为0时，会自动选择type类型对应的默认协议。

另外一些内容讲解、附带的宏等在man手册里查阅。

bind函数

#include <sys/types.h>       
#include <sys/socket.h>

int bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen);

sockfd：即socket描述字，它是通过socket()函数创建了，唯一标识一个socket。bind()函数就是将给这个描述字绑定一个名字。

addr：一个const struct sockaddr *指针，指向要绑定给sockfd的协议地址。这个地址结构根据地址创建socket时的地址协议族的不同而不同。

addrlen：对应的是地址的长度。

通常服务器在启动的时候都会绑定一个众所周知的地址（如ip地址+端口号），用于提供服务，客户就可以通过它来接连服务器；而客户端就不用指定，有系统自动分配一个端口号和自身的ip地址组合。这就是为什么通常服务器端在listen之前会调用bind()，而客户端就不会调用，而是在connect()时由系统随机生成一个。

国内一般常用的协议族为IPv4,国外为IPv6。

IPv4对应的地址协议族

struct sockaddr_in
{
    sa_family_t    sin_family; /* address family: AF_INET */
    in_port_t      sin_port;   /* port in network byte order */
    struct in_addr sin_addr;   /* internet address */
};

/* Internet address. */
struct in_addr
{
    uint32_t       s_addr;     /* address in network byte order */
};

IPv6对应的地址协议族

struct sockaddr_in6
{ 
    sa_family_t     sin6_family;   /* AF_INET6 */ 
    in_port_t       sin6_port;     /* port number */ 
    uint32_t        sin6_flowinfo; /* IPv6 flow information */ 
    struct in6_addr sin6_addr;     /* IPv6 address */ 
    uint32_t        sin6_scope_id; /* Scope ID (new in 2.4) */ 
};

struct in6_addr
{ 
    unsigned char   s6_addr[16];   /* IPv6 address */ 
};

listen函数和connect函数

#include <sys/types.h>          
#include <sys/socket.h>

int listen(int sockfd, int backlog);
int connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen);

listen函数的第一个参数即为要监听的socket描述字，第二个参数为相应Socket可以排队的最大连接个数。socket函数创建的Socket默认是一个主动类型的，listen函数将Socket变为被动类型的，等待客户的连接请求。

connect函数的第一个参数即为客户端的Socket描述字，第二参数为服务器的Socket地址，第三个参数为Socket地址的长度。客户端通过调用connect函数来建立与TCP服务器的连接。

accept函数

TCP服务器端依次调用socket()、bind()、listen()之后，就会监听指定的socket地址了。TCP客户端依次调用socket()、connect()之后就想TCP服务器发送了一个连接请求。TCP服务器监听到这个请求之后，就会调用accept()函数取接收请求，这样连接就建立好了。

#include <sys/types.h>          
#include <sys/socket.h>

int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);

accept函数的第一个参数为服务器的socket描述字，第二个参数为指向struct sockaddr *的指针，用于返回客户端的协议地址，第三个参数为协议地址的长度。如果accpet成功，那么其返回值是由内核自动生成的一个全新的描述字，代表与返回客户的TCP连接。

write/read读写函数

#include <unistd.h>

       ssize_t read(int fd, void *buf, size_t count);
       ssize_t write(int fd, const void *buf, size_t count);

read函数是负责从fd中读取内容.当读成功时，read返回实际所读的字节数，如果返回的值是0表示已经读到文件的结束了，小于0表示出现了错误。如果错误为EINTR说明读是由中断引起的，如果是ECONNREST表示网络连接出了问题。

write函数将buf中的nbytes字节内容写入文件描述符fd.成功时返回写的字节数。失败时返回-1，并设置errno变量。在网络程序中，当我们向套接字文件描述符写时有两种可能。

close函数

#include <unistd.h>

       int close(int fd);

在服务器与客户端建立连接之后，会进行一些读写操作，完成了读写操作就要关闭相应的socket描述字，好比操作完打开的文件要调用fclose关闭打开的文件。

close一个TCP socket的缺省行为时把该socket标记为以关闭，然后立即返回到调用进程。该描述字不能再由调用进程使用，也就是说不能再作为read或write的第一个参数。

代码展示

服务端server.c

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

int main(int argc, char **argv)
{
        int s_fd;
        int c_fd;
        int n_read;
        char readBuf[128];

        int mark = 0;//连接到顺序
        char msg[128] = {0};
//      char *msg = "I get your connect";
        struct sockaddr_in s_addr;
        struct sockaddr_in c_addr;

        if(argc != 3){
                printf("para is not good");
                exit(-1);
        }

        memset(&s_addr,0,sizeof(struct sockaddr_in));//对数据进行清空后再配置
        memset(&c_addr,0,sizeof(struct sockaddr_in));

        //1.socket
                  //IPv4        TCP
        s_fd = socket(AF_INET, SOCK_STREAM, 0);
        if(s_fd == -1){
                perror("socket");
                exit(-1);
        }

        s_addr.sin_family = AF_INET;//等于因特网域
        s_addr.sin_port = htons(atoi(argv[2]));//端口号 网络字节
        inet_aton(argv[1], &s_addr.sin_addr);//

        //2.bind
        bind(s_fd, (struct sockaddr *)&s_addr, sizeof(struct sockaddr_in));

        //3.listen
        listen(s_fd, 10);

        //4.accept
        int clen = sizeof(struct sockaddr_in);

        while(1){//fork函数 父进程的另一个用法

                c_fd = accept(s_fd, (struct sockaddr *)&c_addr, &clen);//
                if(c_fd == -1){
                        perror("accept");
                }

                mark++;
                printf("get connect: %s\n",inet_ntoa(c_addr.sin_addr));

                if(fork() == 0){

                        if(fork() == 0){
                                while(1){
                                        sprintf(msg,"welcome NO.%d client\n",mark);
                                        write(c_fd, msg, strlen(msg));
                                        sleep(3);
                                }
                        }

                        //5.read
                        while(1){
                                memset(readBuf,0,sizeof(readBuf));
                                n_read = read(c_fd, readBuf, 128);
                                if(n_read == -1){
                                        perror("read");
                                }else{
                                        printf("get message:%d,%s\n",n_read,readBuf);
                                }
                        }
                        break;
                }
        }

        return 0;
}

客户端client.c

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


int main(int argc, char **argv)
{
        int c_fd;
        int n_read;
        char readBuf[128];
//      char *msg = "msg from client";
        char msg[128] = {0};

        struct sockaddr_in c_addr;

        memset(&c_addr, 0, sizeof(struct sockaddr_in));


        //1.socket
        c_fd = socket(AF_INET, SOCK_STREAM, 0);
        if(c_fd == -1){
                perror("socket");
                exit(-1);
        }

        c_addr.sin_family = AF_INET;
        c_addr.sin_port = htons(atoi(argv[2]));
        inet_aton(argv[1], &c_addr.sin_addr);

        //2.connect
        if(connect(c_fd, (struct sockaddr *)&c_addr,sizeof(struct sockaddr)) == -1){
                perror("connect");
                exit(-1);
        }

        while(1){

                if(fork() == 0){
                        while(1){
                                memset(msg,0,sizeof(msg));
                                printf("input:");
                                //gets(msg);
                                fgets(msg, sizeof(msg), stdin);
                                write(c_fd,msg,strlen(msg));
                        }
                }

                while(1){
                        memset(readBuf,0,sizeof(readBuf));
                        n_read = read(c_fd, readBuf, 128);
                        if(n_read == -1){
                                perror("read");
                        }else{
                                printf("get message from server:%d,%s\n",n_read,readBuf);
                        }

                }
        }

        return 0;
}