A brief analysis of Linux network programming functions

Some basic functions of network programming: It is also the basic step to realize TCP protocol communication. The implementation code is at the end. The IP needs to be modified to your own IP to communicate.

1. Create a socket

Function prototype:

#include <sys/types.h>
#include <sys/socket.h>
int socket(int domain, int type, int protocol);

Parameter list:

The domain parameter has the following values:

AF_INET: IPv4 protocol
AF_INET6: IPv6 protocol
AF_LOCAL: Unix domain protocol
AF_ROUTE: Routing socket
AF_KEY: Key socket

Values ​​of type:

SOCKET_STREAM: bidirectional reliable data stream, corresponding to TCP
SOCKET_DGRAM: bidirectional unreliable datagram, corresponding to UDP
SOCKET_RAW: Provides protocols below the transport layer and can access internal network interfaces, such as receiving and sending ICMP messages

protocol value:

When type is SOCKET_RAW, you need to set this value to indicate the protocol type. For other types, just set it to 0

The function is to create a socket of a specified format and return its descriptor. If successful, the descriptor is returned, otherwise -1 is returned.

2. Bind socket bind

Function prototype:

#include <sys/types.h>
#include <sys/socket.h>
int bind(int sockfd, const struct sockaddr *my_addr, socklen_t addrlen);

Parameter list:

sockfd is the socket descriptor created previously

my_addr is a pointer to a general socket structure. When doing TCP protocol programming, the sockaddr_in structure is usually used.

The content of the structure is as follows;

struct socketaddr_in
{
   unsigned short int sin_family; //Fill in AF_INTE for the corresponding address family IP v4
   uint16_t sin_port; //corresponding port number struct in_addr sin_addr; //corresponding IP address unsigned char sin_zero[8];
};
struct in_addr
{
   uint32_t s_addr;
};

addrlen is the size of the above structure, which can be obtained using sizeof;

Before using the bind function, you need to create a sockaddr_in type structure, save the server information into the structure, and then bind the created socket to it; return 0 if successful, and -1 if failed;

When setting the port number and IP, clear the structure first. If the main function passes parameters, the corresponding port number and IP are in string format and need to be converted using a function. The conversion format is as follows:

char port[]="8888"
char ip[]="192.168.1.1"
struct sockaddr_in seraddr'
seraddr.sin_port = htos(atoi(port))
seraddr.sin_addr.s_addr = inet_addr(ip);

3. Create a listener; listen

Function prototype:

int listen(int fd, int backlog);

Parameter list:

fd is the socket descriptor to be monitored; backlog is the size of the monitoring queue;

(1) After executing listen, the socket enters passive mode.

(2) When the queue is full, new connection requests will be rejected. The client will get a connect error WSAECONNREFUSED.

(3) Executing listen on a socket that is already listening has no effect.

4. Wait for the connection to be accepted

Function prototype:

#include <sys/socket.h>
 int accept(int s, struct sockaddr * addr, int * addrlen);

Comparing the bind function, we can find that the parameters of the two are almost the same, but the addr in accept is not modified by const, that is, addr is used to save the address information of the connected client, and the size of addr returned when Yangsaddlen;

Therefore, the accept function returns the file descriptor of the connected client and saves the client's address information in a new sockaddr_in structure; if the connection fails, it returns -1;

5. Send and receive messages send and recv

Function prototype

 int send( SOCKET s, const char FAR *buf, int len, int flags );
int recv( SOCKET s, char FAR *buf, int len, int flags);

The parameters of this function are:

• The first parameter specifies the sender/receiver socket descriptor;
• The second parameter specifies a buffer to store the data to be sent by the application;
• The third parameter indicates the number of bytes of data actually to be sent/received;
• The fourth parameter is usually set to 0.

The process of send :

Here we only describe the execution flow of the send function of the synchronous Socket. When calling this function, send first compares the length len of the data to be sent with the length of the send buffer of socket s. If len is greater than the length of the send buffer of s, the function returns SOCKET_ERROR; if len is less than or equal to the length of the send buffer of s, then send first checks whether the protocol is sending the data in the send buffer of s. If so, it waits for the protocol to finish sending the data. If the protocol has not started to send the data in the send buffer of s or there is no data in the send buffer of s, then send compares the remaining space of the send buffer of s with len. If len is greater than the remaining space, send waits for the protocol to finish sending the data in the send buffer of s. If len is less than the remaining space, send just copies the data in buf to the remaining space (note that send does not transmit the data in the send buffer of s to the other end of the connection, but the protocol. Send just copies the data in buf to the remaining space of s's send buffer);

If the send function copies data successfully, it returns the actual number of bytes copied. If an error occurs when copying data, send returns SOCKET_ERROR; if the network is disconnected while send is waiting for the protocol to transmit data, the send function also returns SOCKET_ERROR.

It should be noted that the send function returns after successfully copying the data in buf to the remaining space in s's send buffer, but at this time the data may not be immediately transmitted to the other end of the connection. If a network error occurs during the subsequent transmission process of the protocol, the next Socket function will return SOCKET_ERROR. (Every Socket function except send must wait for the data in the socket's send buffer to be transmitted by the protocol before it can continue. If a network error occurs while waiting, the Socket function returns SOCKET_ERROR).

The process of recv :

Here we only describe the execution flow of the recv function of the synchronous Socket. When the application calls the recv function, recv first waits for the data in s's send buffer to be transmitted by the protocol. If a network error occurs when the protocol transmits the data in s's send buffer, the recv function returns SOCKET_ERROR. If there is no data in s's send buffer or the data is successfully sent by the protocol, recv first checks the socket s's receive buffer. If there is no data in s's receive buffer or the protocol is receiving data, recv will wait until the protocol has received the data. When the protocol has finished receiving the data, the recv function copies the data in s's receive buffer to buf (note that the data received by the protocol may be larger than the length of buf, so in this case the recv function must be called several times to copy all the data in s's receive buffer. The recv function only copies data, and the actual reception of data is completed by the protocol). The recv function returns the number of bytes actually copied. If recv fails during copying, it returns SOCKET_ERROR; if the network is interrupted while the recv function is waiting for the protocol to receive data, it returns 0.

The TCP protocol itself is reliable, but it does not mean that the application sending data using TCP is necessarily reliable. Regardless of whether it is blocked or not, the size of the send does not represent how much data the other end recvs.

In blocking mode, the process of the send function is to copy the data requested by the application to the send buffer, send it and return after confirmation. However, due to the existence of the send buffer, it is manifested as follows: if the send buffer size is larger than the requested size, the send function returns immediately and sends data to the network at the same time; otherwise, send sends the part of the data that cannot be accommodated in the buffer to the network, and waits for the confirmation of the other end before returning (as long as the receiving end receives the data in the receiving buffer, it will confirm, and it does not have to wait for the application to call recv);

In non-blocking mode, the send function only copies the data to the buffer of the protocol stack. If the available space in the buffer is insufficient, it will copy as much as possible and return the size of the successful copy. If the available space in the buffer is 0, it will return -1 and set errno to EAGAIN.

6. Close the socket descriptor close

function:

close(sockfd);

Like file operations, a socket is also a file and must be closed after use;

7. C/S server model based on TCP protocol

Illustrated TCP model

8. Implementation code

Server:

#include <stdio.h>
#include <stdlib.h>
#include <strings.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/ip.h>
#include <arpa/inet.h>
#include <unistd.h>
 
typedef struct sockaddr_in SIN;
typedef struct sockaddr SA;
 
int main(int argc,char *argv[])
{
    SIN seraddr;
    SIN cliaddr;
    int len=sizeof(SIN);
    //Create a listening socket int lisfd=socket(AF_INET,SOCK_STREAM,0);
    if(lisfd<0)
    {
        perror("socket");
        exit(0);
    }
    printf("Created socket%d successfully\n",lisfd);
    bzero(&seraddr,sizeof(seraddr));
    seraddr.sin_family=AF_INET;
    seraddr.sin_port = htons(8888);
    seraddr.sin_addr.s_addr = inet_addr("192.168.1.6");
    //Bind socket int ret=bind(lisfd,(SA*)(&seraddr),len);
    if(ret<0)
    {
        perror("bind");
        exit(0);
    }
    printf("Binding successful\n");
    //Start listening ret=listen(lisfd,1024);
    if(ret<0)
    {
        perror("listen");
        exit(0);
    }
    printf("Monitoring successful\n");
    //Wait for connection and save the connected socket information int clifd=accept(lisfd,(SA*)(&cliaddr),(socklen_t *)(&len));
    if(clifd<0)
    {
        perror("accept");
        exit(0);
    }
    printf("Client %d connected successfully\n",clifd);
    //Read and write char readbuf[1024]={0};
    char sendbuf[1024]={0};
    while(1)
    {
        recv(clifd,readbuf,sizeof(readbuf),0);
        printf("recv:%s\n",readbuf);
        fgets(sendbuf,sizeof(sendbuf),stdin);
        send(clifd,sendbuf,sizeof(sendbuf),0);
    }
    //Close the socket close(clifd);
    close(lisfd);
    return 0;
}

Client:

#include <stdio.h>
#include <stdlib.h>
#include <strings.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/ip.h>
#include <arpa/inet.h>
#include <unistd.h>
 
typedef struct sockaddr_in SIN;
typedef struct sockaddr SA;
 
int main(int argc,char *argv[])
{
    SIN seraddr;
    //Create a listening socket int serfd=socket(AF_INET,SOCK_STREAM,0);
    if(serfd<0)
    {
        perror("socket");
        exit(0);
    }
    printf("Created socket%d successfully\n",serfd);
    bzero(&seraddr,sizeof(seraddr));
    seraddr.sin_family=AF_INET;
    seraddr.sin_port = htons(8888);
    seraddr.sin_addr.s_addr = inet_addr("192.168.1.6");
    //Request connection int ret=connect(serfd,(SA*)(&seraddr),sizeof(SIN));
    if(ret == -1)
    {
        perror("connect");
        exit(0);
    }
    printf("Connection successful\n");
    //Read and write char senbuf[1024]={0};
    char readbuf[1024]={0};
    while(1)
    {
        fgets(senbuf,sizeof(senbuf),stdin);
        send(serfd,senbuf,sizeof(senbuf),0);
        recv(serfd,readbuf,sizeof(readbuf),0);
        printf("recv:%s\n",readbuf);
    }
    //Close the socket close(serfd);
    return 0;
}

This is the end of this article about a brief analysis of Linux network programming functions. For more relevant Linux network programming function content, please search for previous articles on 123WORDPRESS.COM or continue to browse the following related articles. I hope everyone will support 123WORDPRESS.COM in the future!