计算机网络知识点、Linux Socket操作苏嵌嵌入式linux C实训 第 10 天

                                                                                      项目开发日报表

项目名称	【苏嵌实训-嵌入式 linux C 第10天】
今日进度以及任务	嵌入式Linux C网络编程
本日任务完成情况	见附录
本日开发中出现的问题汇总	无
本日未解决的问题	无
本日开发收获	加深了对c语言的理解，加深了对网络编程的理解
其他	无

 

附录
一、网络基础知识
 

二、网络编程代码实现
TCP的服务端：

#include <stdio.h>
#include <stdlib.h>
#include <strings.h>
#include <string.h>

#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>

#define PORT 33333

int main()
{
    int sockfd;
    sockfd = socket(AF_INET, SOCK_STREAM, 0);
    if(sockfd == -1){
        perror("socket create failed!");
        exit(1);
    }

    int opt = 1;
    setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof (opt));


    struct sockaddr_in addr;

    bzero(&addr, sizeof (struct sockaddr_in));
    addr.sin_family = AF_INET;
    addr.sin_port = htons(PORT);
    addr.sin_addr.s_addr = inet_addr("192.168.43.106"); //自己主机IP

    if(bind(sockfd, (struct sockaddr*)(&addr), sizeof (struct sockaddr_in)) < 0){
        perror("bind failed!");
        exit(1);
    }

    if(listen(sockfd, 3) < 0){
        perror("listen failed!");
        exit(1);
    }

    printf("listen successful\n");


    char buffer[1024];
    while (1) {

        memset(buffer, 0, sizeof(buffer));

        struct sockaddr_in c_addr;
        socklen_t c_len = sizeof (struct sockaddr_in);
        int cfd;

        bzero(&c_addr, sizeof (struct sockaddr_in));
        cfd = accept(sockfd, (struct sockaddr*)(&c_addr), &c_len);
        if(cfd == -1){
            perror("accept failed");
            exit(1);
        }
        printf("accept successful\n");
        printf("port = %d, ip = %s\n", ntohs(c_addr.sin_port), inet_ntoa(c_addr.sin_addr));
        

        recv(cfd, buffer, sizeof(buffer), 0);
        printf("re: %s \n", buffer);

        send(cfd, buffer, sizeof(buffer), 0);
    }



    return 0;
}

 
TCP的客户端：

#include <stdio.h>
#include <stdlib.h>
#include <strings.h>
#include <string.h>

#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>

#define PORT 33333

int main()
{
    int sockfd;
    sockfd = socket(AF_INET, SOCK_STREAM, 0);
    if(sockfd == -1){
        perror("socket create failed!");
        exit(1);
    }

    int opt = 1;
    setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof (opt));


    struct sockaddr_in addr;

    bzero(&addr, sizeof (struct sockaddr_in));
    addr.sin_family = AF_INET;
    addr.sin_port = htons(PORT);
    addr.sin_addr.s_addr = inet_addr("192.168.43.106"); //自己主机IP

    if(bind(sockfd, (struct sockaddr*)(&addr), sizeof (struct sockaddr_in)) < 0){
        perror("bind failed!");
        exit(1);
    }

    if(listen(sockfd, 3) < 0){
        perror("listen failed!");
        exit(1);
    }

    printf("listen successful\n");


    char buffer[1024];
    while (1) {

        memset(buffer, 0, sizeof(buffer));

        struct sockaddr_in c_addr;
        socklen_t c_len = sizeof (struct sockaddr_in);
        int cfd;

        bzero(&c_addr, sizeof (struct sockaddr_in));
        cfd = accept(sockfd, (struct sockaddr*)(&c_addr), &c_len);
        if(cfd == -1){
            perror("accept failed");
            exit(1);
        }
        printf("accept successful\n");
        printf("port = %d, ip = %s\n", ntohs(c_addr.sin_port), inet_ntoa(c_addr.sin_addr));
        

        recv(cfd, buffer, sizeof(buffer), 0);
        printf("re: %s \n", buffer);

        send(cfd, buffer, sizeof(buffer), 0);
    }



    return 0;
}

• socket函数

SOCK_STREAM | SOCK_NONBLOCK
                      
                      
                 - SOCK_CLOEXEC：表示一旦进程exec执行新程序后，自动关闭socket返回的“套接字文件描述符”。
                    图：
                    
                    这个标志也是可以和前面的宏进行 | 运算的，不过一般不指定这个标志。
                    
                    SOCK_STREAM | SOCK_NONBLOCK | SOCK_CLOEXEC 
 
               （c）返回值
          
               · 成功：返回套接字文件描述符。
                 
               · 失败：返回-1，errno被设置

 

socket()函数创建一个socket并且返回一个对应的描述符。
其参数分别为：
Address Family - AF_INET => IPv4
Type - SOCK_STREAM => socket连接使用TCP协议
Protocol - 0 => 使用IP协议

• setsockopt，setsockopt函数

NAME
       getsockopt, setsockopt - get and set options on sockets

SYNOPSIS
       #include <sys/types.h>          /* See NOTES */
       #include <sys/socket.h>

       int getsockopt(int sockfd, int level, int optname,
                      void *optval, socklen_t *optlen);
       int setsockopt(int sockfd, int level, int optname,
                      const void *optval, socklen_t optlen);

sockfd：将要被设置或者获取选项的套接字。
level：选项所在的协议层。
optname：需要访问的选项名。
optlen：对于getsockopt()，指向返回选项值的缓冲。对于setsockopt()，指向包含新选项值的缓冲。
optlen：对于getsockopt()，作为入口参数时，选项值的最大长度。作为出口参数时，选项值的实际长度。对于setsockopt()，现选项的长度。

level指定控制套接字的层次.可以取三种值:
1)SOL_SOCKET:通用套接字选项。
2)IPPROTO_IP:IP选项。
3)IPPROTO_TCP:TCP选项。

optname指定控制的方式
SO_REUSERADDR　 允许重用本地地址和端口　int

• Bind函数

#include <sys/types.h>          
               #include <sys/socket.h>
 
               int bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen);                    
            （a）功能：将指定了通信协议（TCP）的套接字文件与IP以及端口绑定起来。

•                   sorckfd：socket函数创建的套接字
•                    socket *addr 保存ip和端口号的结构体

addr：struct sockaddr结构体变量的地址，结构体成员用于设置你要绑定的ip和端口。
                    
                    - 结构体成员
                    
                      struct sockaddr {
                         sa_family_t sa_family;
                         char        sa_data[14];
                      }；
                     // ”192.168.1.10：55555“
                      sa_family：指定AF_***，表示使用的什么协议族的IP，前面说过，协议族不同，ip格式就不同
                      as_data：存放ip和端口 
 
                         大家可以看出，如果将ip和端口直接写入sa_data数组中，虽然可以做到，但是操作起来有点麻烦，
                      不过好在，我们可以使用更容易操作的struct sockaddr_in结构体来设置。
                         
                           struct sockaddr_in 
                           {
                                sa_family_t      sin_family; //设置AF_***（地址族）
                                __be16           sin_port;   //设置端口号
                                struct in_addr sin_addr;   //设置Ip
                                
                                /* 设置IP和端口时，这个成员用不到，这个成员的作用后面再解释， */
                                unsigned char    __pad[__SOCK_SIZE__ - sizeof(short int) - sizeof(unsigned short int) - sizeof(struct in_addr)];
                           };
                           
                           struct in_addr 
                           {
                                __be32 s_addr; //__be32是32位的unsigned int，因为IPV4的ip是32位的无符号整形数
                           };
                           
                         在struct sockaddr_in中，存放端口和ip的成员是分开的，所以设置起来很方便。
                         
                         使用struct sockaddr_in设置后，然后将其强制转为struct sockaddr类型，然后传递给bind
                      函数即可。
                         
                      
                    - struct sockaddr_in的使用例子：
                    
                      struct sockaddr_in addr;
                      
                      addr.sin_family = AF_INET;//使用是IPV4 TCP/IP协议族的ip地址（32位）
                      addr.sin_port    = htons(5006);//指定端口
                      addr.sin_addr.s_addr = inet_addr("192.168.1.105");//指定ip地址
                      
                      ret = bind(sockfd, (struct sockaddr*)&addr, sizeof(addr));
                      
                      
                      注意，如果是跨网通信时，绑定的一定是所在路由器的公网ip。
                      
                      bind会将sockfd代表的套接字文件与addr中设置的ip和端口绑定起来。

• addrlen：第二个参数的长度

            （b）返回值：成功返回0，失败返回-1，errno被设置。

• listen()、connect()函数

如果作为一个服务器，在调用socket()、bind()之后就会调用listen()来监听这个socket，如果客户端这时调用connect()发出连接请求，服务器端就会接收到这个请求。

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()函数取接收请求，这样连接就建立好了。之后就可以开始网络I/O操作了，即类同于普通文件的读写I/O操作。

int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen); //返回连接connect_fd

参数sockfd

参数sockfd就是上面解释中的监听套接字，这个套接字用来监听一个端口，当有一个客户与服务器连接时，它使用这个一个端口号，而此时这个端口号正与这个套接字关联。当然客户不知道套接字这些细节，它只知道一个地址和一个端口号。

参数addr

这是一个结果参数，它用来接受一个返回值，这返回值指定客户端的地址，当然这个地址是通过某个地址结构来描述的，用户应该知道这一个什么样的地址结构。如果对客户的地址不感兴趣，那么可以把这个值设置为NULL。

参数len

如同大家所认为的，它也是结果的参数，用来接受上述addr的结构的大小的，它指明addr结构所占有的字节个数。同样的，它也可以被设置为NULL。

 

如果accept成功返回，则服务器与客户已经正确建立连接了，此时服务器通过accept返回的套接字来完成与客户的通信。

注意：

      accept默认会阻塞进程，直到有一个客户连接建立后返回，它返回的是一个新可用的套接字，这个套接字是连接套接字。

此时我们需要区分两种套接字，

       监听套接字: 监听套接字正如accept的参数sockfd，它是监听套接字，在调用listen函数之后，是服务器开始调用socket()函数生成的，称为监听socket描述字(监听套接字)

       连接套接字：一个套接字会从主动连接的套接字变身为一个监听套接字；而accept函数返回的是已连接socket描述字(一个连接套接字)，它代表着一个网络已经存在的点点连接。

        一个服务器通常通常仅仅只创建一个监听socket描述字，它在该服务器的生命周期内一直存在。内核为每个由服务器进程接受的客户连接创建了一个已连接socket描述字，当服务器完成了对某个客户的服务，相应的已连接socket描述字就被关闭。

        自然要问的是：为什么要有两种套接字？原因很简单，如果使用一个描述字的话，那么它的功能太多，使得使用很不直观，同时在内核确实产生了一个这样的新的描述字。

连接套接字socketfd_new 并没有占用新的端口与客户端通信，依然使用的是与监听套接字socketfd一样的端口号

 

• read()、write()等函数

网络I/O操作有下面几组：

• read()/write()
• recv()/send()

NAME
       recv, recvfrom, recvmsg - receive a message from a socket

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

       ssize_t recv(int sockfd, void *buf, size_t len, int flags);

       ssize_t recvfrom(int sockfd, void *buf, size_t len, int flags,
                        struct sockaddr *src_addr, socklen_t *addrlen);

       ssize_t recvmsg(int sockfd, struct msghdr *msg, int flags);

sockfd 套接字
buf 缓冲区
len 缓冲区长度
flags 标志，一般为0 

NAME
       send, sendto, sendmsg - send a message on a socket

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

       ssize_t send(int sockfd, const void *buf, size_t len, int flags);

       ssize_t sendto(int sockfd, const void *buf, size_t len, int flags,
                      const struct sockaddr *dest_addr, socklen_t addrlen);

       ssize_t sendmsg(int sockfd, const struct msghdr *msg, int flags);

send函数用于发送数据，参数同revc函数。 

• readv()/writev()
• recvmsg()/sendmsg()
• recvfrom()/sendto()

我推荐使用recvmsg()/sendmsg()函数，这两个函数是最通用的I/O函数，实际上可以把上面的其它函数都替换成这两个函数。它们的声明如下：

       #include <unistd.h>

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

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

       ssize_t send(int sockfd, const void *buf, size_t len, int flags);
       ssize_t recv(int sockfd, void *buf, size_t len, int flags);

       ssize_t sendto(int sockfd, const void *buf, size_t len, int flags,
                      const struct sockaddr *dest_addr, socklen_t addrlen);
       ssize_t recvfrom(int sockfd, void *buf, size_t len, int flags,
                        struct sockaddr *src_addr, socklen_t *addrlen);

       ssize_t sendmsg(int sockfd, const struct msghdr *msg, int flags);
       ssize_t recvmsg(int sockfd, struct msghdr *msg, int flags);

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

write函数将buf中的nbytes字节内容写入文件描述符fd.成功时返回写的字节数。失败时返回-1，并设置errno变量。 在网络程序中，当我们向套接字文件描述符写时有俩种可能。1)write的返回值大于0，表示写了部分或者是全部的数据。2)返回的值小于0，此时出现了错误。我们要根据错误类型来处理。如果错误为EINTR表示在写的时候出现了中断错误。如果为EPIPE表示网络连接出现了问题(对方已经关闭了连接)。

 

• close()函数

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

#include <unistd.h>
int close(int fd);

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

注意：close操作只是使相应socket描述字的引用计数-1，只有当引用计数为0的时候，才会触发TCP客户端向服务器发送终止连接请求。

 

• Socket中TCP的建立（三次握手）

TCP协议通过三个报文段完成连接的建立，这个过程称为三次握手(three-way handshake)，过程如下图所示。

 

第一次握手：建立连接时，客户端发送syn包(syn=j)到服务器，并进入SYN_SEND状态，等待服务器确认；SYN：同步序列编号(Synchronize Sequence Numbers)。

第二次握手：服务器收到syn包，必须确认客户的SYN（ack=j+1），同时自己也发送一个SYN包（syn=k），即SYN+ACK包，此时服务器进入SYN_RECV状态；
第三次握手：客户端收到服务器的SYN+ACK包，向服务器发送确认包ACK(ack=k+1)，此包发送完毕，客户端和服务器进入ESTABLISHED状态，完成三次握手。
一个完整的三次握手也就是： 请求---应答---再次确认。