Linux Socket

时间：2018-06-06 01:19:18 阅读：225 评论：0 收藏：0 [点我收藏+]

标签：char s seq 没有 errno.h 返回模式服务器接收 recv

socket可以看成是用户进程与内核网络协议栈的编程接口。

socket不仅可以用于本机的进程间通信，还可以用于网络上不同主机的进程间通信。

技术分享图片

TCP 一般是CS模型

技术分享图片

数据流

技术分享图片

IPv4套接口地址结构

IPv4套接口地址结构通常也称为“网际套接字地址结构”，它以“sockaddr_in”命名，定义在头文件<netinet/in.h>中

struct sockaddr_in {

uint8_t sin_len; 4

sa_family_t sin_family; 4

in_port_t sin_port; 2

struct in_addr sin_addr; 4

char sin_zero[8]; 8

};

sin_len：整个sockaddr_in结构体的长度，在4.3BSD-Reno版本之前的第一个成员是sin_family.

sin_family：指定该地址家族，在这里必须设为AF_INET 表示是TCP/IP协议

sin_port：端口

sin_addr：IPv4的地址；

sin_zero：暂不使用，一般将其设置为0

通用地址结构

通用地址结构用来指定与套接字关联的地址。

struct sockaddr {

uint8_t sin_len;

sa_family_t sin_family;

char sa_data[14]; //14

};

sin_len：整个sockaddr结构体的长度

sin_family：指定该地址家族

sa_data：由sin_family决定它的形式。

上面两个结构在大小上面是一样的，是通用的数据结构。

网络字节序

大端字节序（Big Endian)

最高有效位（MSB：Most Significant Bit）存储于最低内存地址处，最低有效位（LSB：Lowest Significant Bit）存储于最高内存地址处。

小端字节序（Little Endian）

最高有效位（MSB：Most Significant Bit）存储于最高内存地址处，最低有效位（LSB：Lowest Significant Bit）存储于最低内存地址处。

本地主机字节序

不同的主机有不同的字节序，如x86为小端字节序，Motorola 6800为大端字节序，ARM字节序是可配置的。

网络字节序

网络字节序规定为大端字节序

发送数据之前先转换成为网络字节序，然后在转成本地字节序。

//测试大端还是小端字节序
#include <stdio.h>

int main()
{
    typedef union charseq{
    int a;
    char ch[4];
    } charseq;
    charseq c;
    c.a = 0x12345678;
    printf("%x %x %x %x \n", c.ch[0], c.ch[1], c.ch[2], c.ch[3]);
    if( (&c.ch[0] < &c.ch[1]) && c.ch[0] == 0x78)
   { 
         printf("小端字节序\n");
   }
    if( (&c.ch[0] < &c.ch[1]) && c.ch[0] == 0x12)
    {  
        printf("大端字节序\n");
    }
    return 0;
 
}

字节序转换函数

uint32_t htonl(uint32_t hostlong);

uint16_t htons(uint16_t hostshort);

uint32_t ntohl(uint32_t netlong);

uint16_t ntohs(uint16_t netshort);

说明：在上述的函数中，h代表host；n代表network s代表short；l代表long

地址转换解析函数

int inet_aton(const char *cp, struct in_addr *inp);

char *inet_ntoa(struct in_addr in);

in_addr_t inet_addr(const char *cp);

typedef uint32_t in_addr_t;
struct in_addr {

　　in_addr_t s_addr;
};

地址转换函数，在TCP/IP协议里面,IPV4是32位的，将点分IP转换成为 char*，于是这套API就出来了。

通用的结构可以兼容很多模式 TCP/IP不仅仅支持TCP/IP协议，同时支持Unix域，当拿到一个具体的结构的时候，最后转换成为通用地址结构就可以了，然后放到Socket API中就可以了。

套接字类型

流式套接字(SOCK_STREAM)。提供面向连接的、可靠的数据传输服务，数据无差错，无重复的发送，且按发送顺序接收。

数据报式套接字(SOCK_DGRAM)。提供无连接服务。不提供无错保证，数据可能丢失或重复，并且接收顺序混乱。

原始套接字（SOCK_RAW）

技术分享图片

Socket 编程API

socket函数

包含头文件<sys/socket.h>

功能：创建一个套接字用于通信

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

domain ：指定通信协议族（protocol family）

type：指定socket类型，流式套接字SOCK_STREAM，数据报套接字SOCK_DGRAM，原始套接字SOCK_RAW

protocol ：协议类型

返回值：成功返回非负整数，它与文件描述符类似，我们把它称为套接口描述字，简称套接字。失败返回-1

bind函数

包含头文件<sys/socket.h>

绑定一个本地地址到套接字

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

sockfd：socket函数返回的套接字

addr：要绑定的地址

addrlen：地址长度

返回值：成功返回0，失败返回-1

listen函数

一般来说，listen函数应该在调用socket和bind函数之后，调用函数accept之前调用。

对于给定的监听套接口，内核要维护两个队列：

1、已由客户发出并到达服务器，服务器正在等待完成相应的TCP三路握手过程

2、已完成连接的队列

技术分享图片

对服务器来讲，服务器要进行监听，一旦调用完listen这个函数，这个套接字将要变成被动套接字，只能接受连接不能发送连接。listen背后做了两个对列，一个是已经完成的连接，一个是未完成的连接（正在进行三次握手的连接），当三次握手建立之后，将这个连接从未完成队列中转移到已经完成的队列中。当服务器中有accept函数的时候，再从已经建立连接的队列中将连接取出来。让客户端和服务器端建立真正的连接。

accept函数

从已完成连接队列返回第一个连接，如果已完成连接队列为空，则阻塞。

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

sockfd：服务器套接字

addr：将返回对等方的套接字地址

addrlen：返回对等方的套接字地址长度

返回值：成功返回非负整数，失败返回-1

connect函数

建立一个连接至addr所指定的套接字

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

sockfd：未连接套接字

addr：要连接的套接字地址

addrlen：第二个参数addr长度

成功返回0，失败返回-1

TCP IP的状态处于 WAIT_TIME 的时候，是不能立刻进行连接的，不能绑定端口，这个时候，需要一个技术，叫做地址复用技术。

SO_REUSEADDR

服务器端尽可能使用SO_REUSEADDR

在绑定之前尽可能调用setsockopt来设置SO_REUSEADDR套接字选项。

使用SO_REUSEADDR选项可以使得不必等待TIME_WAIT状态消失就可以重启服务器

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);

下面贴一个简单的服务器客户端模型

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

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

    struct sockaddr_in srvaddr;
    srvaddr.sin_family = AF_INET;
    srvaddr.sin_port = htons(8001);
    srvaddr.sin_addr.s_addr = inet_addr("172.20.53.162");

    int optval = 1;
    
    if(setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR,&optval, sizeof(optval)) <0 )
    {
        perror("setsockopt failed!\n");
        exit(-1);
    }
    
    if(bind(sockfd, (struct sockaddr*)&srvaddr, sizeof(srvaddr)) < 0)
    {
        perror("bind failed!\n");
        exit(-1);
    }
    
    if( listen(sockfd, SOMAXCONN) < 0)
    {
        perror("listen failed!\n");
        exit(-1);
    }
    
    struct sockaddr_in  perraddr;
    socklen_t addrlen = sizeof(perraddr);
    
    int conn = 0;
    conn = accept(sockfd, (struct sockaddr*)&perraddr, &addrlen);
    if( conn < 0)
    {
        perror("acccept failed!\n");
        exit(-1);
    }
    
    printf("From:%s port:%d connetc\n", inet_ntoa(perraddr.sin_addr), ntohs(perraddr.sin_port));
    
    char recvbuf[1024] = {0};
    
    while(1)
    {
        int ret = read(conn, recvbuf, sizeof(recvbuf));
        if(ret == 0)
        {
            printf("对方已经关闭！\n");
            exit(0);
        }
        else if(ret < 0)
        {
            printf("读取失败!\n");
            exit(0);
        }
        fputs(recvbuf, stdout);
        write(conn, recvbuf, ret);
    }
    close(sockfd);
    close(conn)

}

//client.h
#include <unistd.h>
#include <sys/stat.h>
#include <sys/wait.h>
#include <sys/types.h>
#include <fcntl.h>
#include <stdlib.h>
#include <stdio.h>
#include <errno.h>
#include <string.h>
#include <signal.h>
#include <arpa/inet.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
int  main()
{
    int sockfd;
    sockfd = socket(AF_INET, SOCK_STREAM, 0);
    if(sockfd == -1)
    {
        perror("socket failed!\n");
        exit(-1);
    }

    struct sockaddr_in srvaddr;
    srvaddr.sin_family = AF_INET;
    srvaddr.sin_port = htons(8001);
    srvaddr.sin_addr.s_addr = inet_addr("172.20.53.162");

    int ret = connect(sockfd, (struct sockaddr*)&srvaddr, sizeof(srvaddr));
    
    if(ret == -1)
    {
        perror("connect failed!\n");
        exit(0);
    }
    
    
    char recvbuf[1024] = {0};
    char sendbuf[1024] = {0};
    
    while(fgets(sendbuf, sizeof(sendbuf),stdin) != NULL)
    {
        
        write(sockfd, sendbuf, strlen(sendbuf));
        int ret = read(sockfd, recvbuf, sizeof(recvbuf));
        if(ret == 0)
        {
            printf("对方已经关闭！\n");
            exit(0);
        }
        else if(ret < 0)
        {
            printf("读取失败!\n");
            exit(0);
        }
        fputs(recvbuf, stdout);
        write(sockfd, recvbuf, ret);
        
        bzero(recvbuf, sizeof(recvbuf));
        bzero(sendbuf, sizeof(sendbuf));
    }
    
    close(sockfd);

    return 0;
}

上面这个最基本的模型只能支持单个客户端，不能支持多个客户端，原因是服务器一直和第一个客户端进行交互，不能用来进行其他客户端连接的处理。不过建立连接的过程是内核TCP协议栈在背后进行的，因此可以同时建立多个连接，却只能有一个连接进行通信。

Socket服务支持多并发（多客户端连接）

下面是一个多进程模型，每次来一个连接都使用一个子进程来进行通讯

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

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

    struct sockaddr_in srvaddr;
    srvaddr.sin_family = AF_INET;
    srvaddr.sin_port = htons(8001);
    srvaddr.sin_addr.s_addr = inet_addr("172.20.53.162");

    //用来设置地址复用
    int optval = 1;
    if(setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR,&optval, sizeof(optval)) <0 )
    {
        perror("setsockopt failed!\n");
        exit(-1);
    }
    
    if(bind(sockfd, (struct sockaddr*)&srvaddr, sizeof(srvaddr)) < 0)
    {
        perror("bind failed!\n");
        exit(-1);
    }
    
    if( listen(sockfd, SOMAXCONN) < 0)
    {
        perror("listen failed!\n");
        exit(-1);
    }
    
    struct sockaddr_in  perraddr;
    socklen_t addrlen = sizeof(perraddr);

    int conn = 0;
    while(1)
    {
        conn = accept(sockfd, (struct sockaddr*)&perraddr, &addrlen);
        if( conn < 0)
        {
            perror("acccept failed!\n");
            exit(-1);
        }
        
        int pid = fork();
        if(pid < 0)
        {
            printf("创建进程失败!\n");
            exit(0);    
        }
        
        if(pid == 0)
        {
            close(sockfd);
            char recvbuf[1024] = {0};
            while(1)
            {    
                int ret = read(conn, recvbuf, sizeof(recvbuf));
                if(ret > 0)
                    printf("From:%s port:%d connetc\n", inet_ntoa(perraddr.sin_addr), ntohs(perraddr.sin_port));
                if(ret == 0)
                {
                    printf("对方已经关闭！\n");
                    close(conn);
                    exit(0);
                }
                else if(ret < 0)
                {
                    printf("读取失败!\n");
                    exit(0);
                }
                fputs(recvbuf, stdout);
                write(conn, recvbuf, ret);    
                bzero(recvbuf, sizeof(recvbuf));
            }
            close(conn);
            exit(0);
        }
        close(conn);
    }
    close(sockfd);
}

如果没有客户端来进行连接，accept将会阻塞在哪里，直到有连接的到来为止。

长连接和短链接

服务器端的长连接还是短链接不是服务器说了算，是客户单说了算，服务器端是提供服务的，一般服务器端是不会关闭连接的。客户端和服务器建立连接之后就不会断了，这就是长连接。客户端每做一次通讯就连接一次服务端，这就是短链接。上面的模型都是长连接模型。

Linux Socket

标签：char s seq 没有 errno.h 返回模式服务器接收 recv

原文地址：https://www.cnblogs.com/randyniu/p/9142588.html

踩

(0)

评论一句话评论（0）

分享档案

更多>

2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)

周排行