Socket 初探

什么是Socket

在计算机通信领域，socket 被翻译为“套接字”，它是计算机之间进行通信的一种约定或一种方式。通过 socket 这种约定，一台计算机可以接收其他计算机的数据，也可以向其他计算机发送数据
　　socket起源于Unix，而Unix/Linux基本哲学之一就是“一切皆文件”，都可以用“打开open –> 读写write/read –> 关闭close”模式来操作。
　　我的理解就是Socket就是该模式的一个实现：即socket是一种特殊的文件，一些socket函数就是对其进行的操作（读/写IO、打开、关闭）。
　　Socket()函数返回一个整型的Socket描述符，随后的连接建立、数据传输等操作都是通过该Socket实现的。

Socket基础

首先看一个基于TCP的CS案例，客户端连接到服务器后，收到服务器发来的消息并打印，为步骤清晰，去掉了一些差错判断。

Server

#include <iostream>
#include <sys/socket.h> // int     socket(int, int, int);
#include <netinet/in.h> // IPPROTO_TCP
#include <arpa/inet.h> // in_addr_t	 inet_addr(const char *);
#include <unistd.h> //write and read

int setAddr(sockaddr_in * addr,short port,const char * ip){
    memset(addr, 0, sizeof(sockaddr_in));  //每个字节都用0填充
    addr->sin_family = AF_INET;  //使用IPv4地址
    addr->sin_addr.s_addr = inet_addr(ip);  //具体的IP地址
    addr->sin_port = htons(port);  //端口，使用htons转换为网络字节序
    return 0;
}

int main() {
    // 配置地址：ip port 协议
    sockaddr_in addr{};
    setAddr(&addr,1234,"127.0.0.1");

    // 创建socket
    int fd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
  
    // 绑定socket和addr
    if(0!=bind(fd, (struct sockaddr *) &addr, sizeof(addr))){
        std::cout << "bind failed!" << std::endl;
    }

    // 监听指定地址端口
    if(0!=listen(fd, 20)){
        std::cout << "listen failed!" << std::endl;
    }

    //接收连接请求
    sockaddr_in clientAddr{};
    socklen_t clientAddrLen = sizeof(clientAddr);
    int clientFd = accept(fd, (struct sockaddr*)&clientAddr, &clientAddrLen);

    //向客户端发送数据
    char str[] = "Welcome!";
    write(clientFd, str, sizeof(str));

    //关闭套接字
    close(clientFd);
    close(fd);

    return 0;
}

Client

#include <iostream>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>
int setAddr(sockaddr_in * addr,short port,const char * ip){
    memset(addr, 0, sizeof(sockaddr_in));  //每个字节都用0填充
    addr->sin_family = AF_INET;  //使用IPv4地址
    addr->sin_addr.s_addr = inet_addr(ip);  //具体的IP地址
    addr->sin_port = htons(port);  //端口
    return 0;
}

int main() {

    // 地址
    sockaddr_in addr{};

    setAddr(&addr,1234,"127.0.0.1");

    //1创建socket
    int fd = socket(AF_INET, SOCK_STREAM, 0);
  
    //2连接到socket
    if(0!=connect(fd,(struct sockaddr*)&addr,sizeof(addr) ) ){
        std::cout<<"connect failed!"<<std::endl;
    }

    //3读取服务器传回的数据
    char buffer[40];
    read(fd, buffer, sizeof(buffer)-1);
    printf("%s\n", buffer);

    //4关闭
    close(fd);
    return 0;
}

相关结构

typedef unsigned char           __uint8_t;
typedef __uint8_t               sa_family_t;
typedef __uint16_t              in_port_t;
typedef __uint32_t      				in_addr_t; 

struct sockaddr {
	__uint8_t       sa_len;
	sa_family_t     sa_family;//__uint8_t
	char            sa_data[14];
};

struct in_addr {
	in_addr_t s_addr;//__uint32_t
};

struct sockaddr_in {
	__uint8_t       sin_len;		//1byte
	sa_family_t     sin_family;	//1byte
	in_port_t       sin_port;		//2byte
	struct  in_addr sin_addr;		//4byte
	char            sin_zero[8];//8byte
};

相关函数

socket

/*
 * @file #include <sys/socket.h>
 * @brief create an endpoint for communication 
 * @param domain
 * 	PF_LOCAL(AF_UNIX)        		Host-internal protocols, formerly called PF_UNIX,
 * 	PF_UNIX(AF_UNIX)         		Host-internal protocols, deprecated, use PF_LOCAL,
 * 	PF_INET(AF_INET)         		Internet version 4 protocols,
 * 	PF_ROUTE(AF_ROUTE)        	Internal Routing protocol,
 * 	PF_KEY(pseudo_AF_KEY)       Internal key-management function,
 * 	PF_INET6(AF_INET6)        	Internet version 6 protocols,
 * 	PF_SYSTEM(AF_SYSTEM)       	System domain,
 * 	PF_NDRV(AF_NDRV)         		Raw access to network device,
 * 	PF_VSOCK(AF_VSOCK)        	VM Sockets protocols
 *
 * @param type
 * 	SOCK_STREAM			stream socket
 *	SOCK_DGRAM			datagram socket
 *	SOCK_RAW				raw-protocol interface
 *
 * @param protocol	usrally 0
 *	IPPROTO_TCP
 *	IPPROTO_UDP
 *	... more in netinet/in.h
 *
 * @return -1 if an error occurs, otherwise the return value is a descriptor referencing the socket.
 * 
 * ERRORS
     The socket() system call fails if:
     [EACCES]           Permission to create a socket of the specified type and/or protocol is denied.
     [EAFNOSUPPORT]     The specified address family is not supported.
     [EMFILE]           The per-process descriptor table is full.
     [ENFILE]           The system file table is full.
     [ENOBUFS]          Insufficient buffer space is available.  The socket
                        cannot be created until sufficient resources are freed.
     [ENOMEM]           Insufficient memory was available to fulfill the request.
     [EPROTONOSUPPORT]  The protocol type or the specified protocol is not supported within this domain.
     [EPROTOTYPE]       The socket type is not supported by the protocol.
     If a new protocol family is defined, the socreate process is free to return any desired error code.  
     The socket() system call will pass this error code along (even if it is undefined).
 */
int socket(int domain, int type, int protocol);

bind

/*
 * @file #include <sys/socket.h>
 * @brief bind a file descriptor with sockaddr
 * @param socket 			socket file descriptor
 * @param addr				point of addr struct
 * @param socklen_t 	size of addr
 */
int     bind(int socket, const struct sockaddr * addr, socklen_t) 

listen

/*
 * @file #include <sys/socket.h>
 * @brief bind a file descriptor with sockaddr
 * @param socket 				socket file descriptor
 * @param backlog				maximum length for the queue of pending connections
 * @return value 0 if successful; otherwise the value -1
 */
int listen(int socket, int backlog);

accept

/*
 * @file #include <sys/socket.h>
 * @brief bind a file descriptor with sockaddr
 * @param socket 									socket file descriptor
 * @param restrict_address				maximum length for the queue of pending connections
 * @param restrict_address_len		maximum length for the queue of pending connections
 * @return -1 on error,a non-negative integer that is a descriptor for the accepted socket if it succeeds.
 */
int accept(int socket, struct sockaddr *restrict_address, socklen_t *restrict_address_len);

read & write

/*
 * @file #include <unistd.h>
 * @brief read or write data from fd to buffer
 */
ssize_t	 read(int fd, void * buffer, size_t buffer_size) ;
ssize_t	 write(int fd, const void * buffer, size_t buffer_size) 

close

/*
 * @file #include <unistd.h>
 * @brief close a opened fd
 */
int  close(int fd);

recv & send

上述例子中使用了read和write函数对socket进行读取和写入数据，事实上，操作socket的数据有更好的方式，即使用recv函数和send函数。

send

#include <sys/socket.h>
/*
 * @brief send is used to transmit a message to another socket.
 * @param socket	socket file descriptor
 * @param buffer	message buffer
 * @param length  message bytes
 * @param flags  usrally 0。
 		The flags parameter may include one or more of the following: 
     #define MSG_OOB        0x1  // process out-of-band data 
     #define MSG_DONTROUTE  0x4  // bypass routing, use direct interface, usually used only by diagnostic or routing
     programs.
     
 * @return:
 			Upon successful completion, the number of bytes which were sent is returned. 
 			Otherwise, -1 is returned and the global variable errno is set to indicate the error.
*/
ssize_t send(int socket, const void *buffer, size_t length, int flags);

recv

#include <sys/socket.h>
/*
 * @brief recv receive messages from a socket, and may be used to receive data on
     a socket whether or not it is connection-oriented.
     
 * @param socket	socket file descriptor
 * @param buffer	message buffer
 * @param length  message bytes
 * @param flags  usrally 0。
 		The flags parameter may include one or more of the following: 
    	MSG_OOB        process out-of-band data
      MSG_PEEK       peek at incoming message
      MSG_WAITALL    wait for full request or error
     
 * @return:
 		 Return the number of bytes received, or -1 if an error occurred.
     For TCP sockets, the return value 0 means the peer has closed its half side of the connection.
*/
ssize_t recv(int socket, void *buffer, size_t length, int flags);

除此之外，还有

ssize_t sendmsg(int socket, const struct msghdr *message, int flags);
ssize_t recvmsg(int socket, struct msghdr *message, int flags);

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

关于read/write，recv/send，recvmsg/sendmsg，recvfrom/sendto的区别

• read/write：通用文件描述符操作函数
• send：发送消息，send只可用于基于连接的套接字，send 和 write唯一的不同点是标志的存在，当标志为0时，send等同于write。
• sendto 和 sendmsg：既可用于无连接的套接字，也可用于基于连接的套接字；除了套接字设置为非阻塞模式，调用将会阻塞直到数据被发送完。
• recv：读取消息，一般只用在面向连接的套接字。
• recvfrom和recvmsg：可同时应用于面向连接的和无连接的套接字。

使用示例参考后文。

Example - Tcp Echo Server

基于有连接的网络通信，使用send和recv进行数据的收发

recv

char buffer[4096];
ssize_t bytes = recv(cfd, (void *)&buffer, 4096, 0);

send

char buffer[4096]{"test!"};
send(client_fd, &buffer, strlen(buffer), 0)

Server

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

int main(int , char **) {

    int fd = socket(AF_INET, SOCK_STREAM, 0);
    if (fd < 0) {
        std::cerr << "Socket creat failed!"<<std::endl;
        return -2;
    }

    sockaddr_in server_addr{};
    server_addr.sin_family = AF_INET;
    server_addr.sin_port = htons(1234);
    server_addr.sin_addr.s_addr = inet_addr("127.0.0.1");

    if (bind(fd, (sockaddr *)&server_addr, sizeof(server_addr)) < 0) {
        std::cerr <<"bind error."<<std::endl;
        return -3;
    }
    if (listen(fd, 20) < 0) {
        std::cerr << "listen error."<<std::endl;
        return -4;
    }

    sockaddr_in client_addr{};
    socklen_t client_addr_size = sizeof(client_addr);
    int cfd = accept(fd, (sockaddr*)&client_addr, &client_addr_size);
    if (cfd < 0) {
        std::cerr << "accept error"<<std::endl;
        return -5;
    }
    close(fd);//关闭监听的socket


    char buffer[4096];
    ssize_t bytes;
    while (true) {
        bytes = recv(cfd, (void *)&buffer, 4096, 0);
        if (bytes == 0) {
            std::cout << "client disconnected."<<std::endl;
            break;
        }
        else if (bytes < 0) {
            std::cerr << "recv error."<<std::endl;
            break;
        }
        else {
            std::cout << "[client]" << std::string(buffer, 0, bytes) << std::endl;
            if (send(cfd, &buffer, bytes, 0) < 0) {
                std::cerr << "send error, exiting...\n";
                break;
            }
        }
    }
    close(cfd);

    return 0;
}

Client

#include <iostream>
#include <string>
#include <cstring>
#include <unistd.h>
#include <sys/socket.h>
#include <arpa/inet.h>

int main(int , char **) {

    int fd = socket(AF_INET, SOCK_STREAM, 0);
    if (fd < 0) {
        std::cerr << "Socket creat error."<<std::endl;
        return -2;
    }

    sockaddr_in server_addr{};
    server_addr.sin_family = AF_INET;
    server_addr.sin_port = htons(1234);
    server_addr.sin_addr.s_addr = inet_addr("127.0.0.1");

    if (connect(fd, (sockaddr*)&server_addr, sizeof(server_addr)) < 0) {
        std::cerr << "connect error."<<std::endl;
        return -3;
    }

    char buf[4096];
    std::string inputTemp;
    while(true) {
        std::memset(buf, 0, 4096);
        std::cout << ">";
        std::getline(std::cin, inputTemp, '\n');
        std::strcpy(buf, inputTemp.c_str());

        if (strlen(buf)==0) {
            continue;
        }
        else if (strcmp(buf, "quit")==0) {
            break;
        }

        ssize_t bytes_send = send(fd, &buf, (size_t)strlen(buf), 0);
        if (bytes_send < 0) {
            std::cerr << "send error."<<std::endl;
            break;
        }

        ssize_t bytes_recv = recv(fd, &buf, 4096, 0);
        if (bytes_recv < 0) {
            std::cerr << "recv error."<<std::endl;
        }
        else if (bytes_recv == 0) {
            std::cout << "server closed.";
        }
        else {
            std::cout << "[server]" << std::string(buf, 0, bytes_recv) << std::endl;
        }
    }
    close(fd);
    return 0;
}

Example - Udp Echo Server

基于无连接的网络通信，使用sendto和recvfrom收发消息

sendto和recvfrom也可以支持面向连接的网络通信

recvfrom

ssize_t bytes_len = recvfrom(server_fd, buf, sizeof(buf), 0, (struct sockaddr *)&client_addr, &socklen);

sendto

ssize_t bytes_len = sendto(server_fd, buf, sizeof(buf), 0, (struct sockaddr *)&client_addr, socklen);

Server

#include <sys/socket.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <iostream>

int main()
{
    sockaddr_in addr{};
    addr.sin_family = AF_INET;
    addr.sin_addr.s_addr = inet_addr("127.0.0.1");
    addr.sin_port = htons(1234);

    int fd = socket(AF_INET, SOCK_DGRAM, 0);//SOCK_DGRAM=>udp
    if (fd < 0){
        return -1;
    }
    if (bind(fd, (const sockaddr *)&addr, sizeof(addr))<0){
        return -2;
    }
    char buf[1024];
    sockaddr_in client_addr{};
    socklen_t   socklen = sizeof(client_addr);

    while (true)
    {
        ssize_t bytes_len = recvfrom(fd, buf, sizeof(buf), 0, (struct sockaddr *)&client_addr, &socklen);
        if (bytes_len < 0){
            std::cout<<"recv failed"<<std::endl;
            break;
        }
        else{
            std::cout<<"[client]"<<buf<<std::endl;
        }

        bytes_len = sendto(fd, buf, sizeof(buf), 0, (struct sockaddr *)&client_addr, socklen);
        if (bytes_len < 0){
            std::cout<<"send failed"<<std::endl;
            break;
        }
    }
    close(fd);
    return 0;
}

Client

#include <sys/socket.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <iostream>

int main()
{
    sockaddr_in addr{};
    addr.sin_family = AF_INET;
    addr.sin_addr.s_addr = inet_addr("127.0.0.1");
    addr.sin_port = htons(1234);

    int fd = socket(AF_INET, SOCK_DGRAM, 0);
    if(fd < 0){
        return -1;
    }

    ssize_t bytes_len ;
    char buf[1024] = "hello world!";
    bytes_len = sendto(fd, buf, strlen(buf), 0, (sockaddr*)&addr, sizeof(addr));
    if(bytes_len < 0){
        std::cout<<"send failed"<<std::endl;
        return -2;
    }
    bytes_len = recvfrom(fd, buf, strlen(buf), 0,nullptr, nullptr);
    if(bytes_len < 0){
        std::cout<<"recv failed"<<std::endl;
        return -3;
    }
    else{
        std::cout<<"[server]"<<buf<<std::endl;
    }
    close(fd);
    return 0;
}

Example - Sendmsg and Recvmsg

基于无连接的网络通信，使用sendto和recvfrom收发消息

sendto和recvfrom也可以支持面向连接的网络通信

首先回顾一下recvmsg和sendmsg的函数原型

struct iovec {
	void *   iov_base;      /* [XSI] Base address of I/O memory region */
	size_t   iov_len;       /* [XSI] Size of region iov_base points to */
};

struct msghdr {
	void            *msg_name;      /* [XSI] optional address */
	socklen_t       msg_namelen;    /* [XSI] size of address */
	struct          iovec *msg_iov; /* [XSI] scatter/gather array */
	int             msg_iovlen;     /* [XSI] # elements in msg_iov */
	void            *msg_control;   /* [XSI] ancillary data, see below */
	socklen_t       msg_controllen; /* [XSI] ancillary data buffer len */
	int             msg_flags;      /* [XSI] flags on received message */
};

ssize_t sendmsg(int socket, const struct msghdr *message, int flags);
ssize_t recvmsg(int socket, struct msghdr *message, int flags);

Basic Usage

详细参考：https://blog.csdn.net/weixin_45309916/article/details/107905942

char buf[1024];
sockaddr_in client_addr{};

struct iovec msg_iov[1];
msg_iov[0].iov_base = buf;
msg_iov[0].iov_len = sizeof(buf);

struct msghdr msg{};
msg.msg_name = &client_addr;
msg.msg_namelen = sizeof(client_addr);
msg.msg_iov = msg_iov;
msg.msg_iovlen = 1;
msg.msg_control = nullptr;
msg.msg_controllen = 0;
msg.msg_flags = 0;

ssize_t bytes_len;

bytes_len = sendmsg(fd, &msg, 0);
bytes_len = recvmsg(fd, &msg, 0);

Server

#include <sys/socket.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <iostream>
int main()
{
    sockaddr_in addr{};
    addr.sin_family = AF_INET;
    addr.sin_addr.s_addr = inet_addr("127.0.0.1");
    addr.sin_port = htons(1234);

    int fd = socket(AF_INET, SOCK_DGRAM, 0);//SOCK_DGRAM=>udp
    if (fd < 0){
        return -1;
    }
    if (bind(fd, (const sockaddr *)&addr, sizeof(addr))<0){
        return -2;
    }
    char buf[1024];
    sockaddr_in client_addr{};

    iovec msg_iov[1];
    msg_iov[0].iov_base = buf;
    msg_iov[0].iov_len = sizeof(buf);

    msghdr msg{};
    msg.msg_name = &client_addr;
    msg.msg_namelen = sizeof(client_addr);
    msg.msg_iov = msg_iov;
    msg.msg_iovlen = 1;
    msg.msg_control = nullptr;
    msg.msg_controllen = 0;
    msg.msg_flags = 0;

    while (true)
    {
        ssize_t bytes_len = recvmsg(fd,&msg,0);
        if(bytes_len < 0){
            std::cout<<"recv failed"<<std::endl;
            break;
        }
        else{
            std::cout<<"[client]"<<buf<<std::endl;
        }

        //change msg
        memset(buf,0,sizeof(buf));
        strcpy(buf,"Hi,Im server!");

        bytes_len = sendmsg(fd, &msg, 0);
        if (bytes_len < 0){
            std::cout<<"send failed"<<std::endl;
            break;
        }
    }
    close(fd);
    return 0;
}

Client

#include <sys/socket.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <iostream>

int main()
{
    sockaddr_in addr{};
    addr.sin_family = AF_INET;
    addr.sin_addr.s_addr = inet_addr("127.0.0.1");
    addr.sin_port = htons(1234);

    int fd = socket(AF_INET, SOCK_DGRAM, 0);
    if(fd < 0){
        return -1;
    }

    ssize_t bytes_len ;
    char buf[1024] = "hello world!";

    iovec msg_iov{};
    msg_iov.iov_base = buf;
    msg_iov.iov_len = sizeof(buf);

    msghdr msg{};
    msg.msg_name = &addr;
    msg.msg_namelen = sizeof(addr);
    msg.msg_iov = &msg_iov;
    msg.msg_iovlen = 1;
    msg.msg_control = nullptr;
    msg.msg_controllen = 0;
    msg.msg_flags = 0;

    bytes_len = sendmsg(fd, &msg, 0);
    if(bytes_len < 0){
        std::cout<<"send failed"<<std::endl;
        return -2;
    }

    bytes_len = recvmsg(fd,&msg,0);
    if(bytes_len < 0){
        std::cout<<"recv failed"<<std::endl;
        return -3;
    }
    else{
        std::cout<<"[server]"<<buf<<std::endl;
    }
    close(fd);
    return 0;
}