Three kinds of socket interface type analysis common in embedded programming

Network programming in Linux is done through the socket interface, which is a file descriptor. Socket also has a function call similar to opening a file. This function returns an integer socket descriptor. Subsequent connection establishment and data transfer operations are implemented through sockets.

There are 3 types of common sockets:

(1) Streaming socket (SOCK_STREAM) streaming sockets provide a reliable, connection-oriented communication flow; it uses the TCP protocol to ensure the correctness and sequence of data transmission.

(2) Datagram socket (SOCK_DGRAM) The datagram socket defines a connectionless service. Data is transmitted through mutually independent messages, which are unordered and are not guaranteed to be reliable and error-free. It uses the datagram protocol UDP.

(3) Original socket, the original socket allows direct access to the underlying protocols such as IP or ICMP. It is powerful but inconvenient to use, mainly for the development of some protocols.

1.sockaddr/_in: is used to save socket information. After socketadd or sockaddr_in is created, the socket can be properly manipulated.

Struct sockaddr {

Unsigned short sa_family; /*address family*/

Char sa_data[14]; /*14 bytes of protocol address containing the IP address and port number of the socket. */

};

Struct sockaddr_in {

Short int sin_family; /*address family*/

Unsigned short int sin_port; /*port number*/

Struct in_addr sin_addr; /*IP address*/

Unsigned char sin_zero[8]; /* padding 0 to keep the same size as struct sockaddr*/

};

Commonly used sa_family has the following types:

AF_INET: IPv4 protocol

AF_INET6: IPv6 protocol

AF_LOCAL: UNIX Domain Protocol

AF_LINK: Link Address Protocol

AF_KEY: key socket (socket)

2. Data storage priority

Computer data storage has two byte priority orders: high byte first (big endian mode) and low byte first (small segment mode). On the Internet, the high-order byte is prioritized in the network, and the PC usually uses the little-end mode, so sometimes it is necessary to convert the two-byte storage priority. Four functions are used: htons(), ntohs(), htonl(), and ntohl(). h stands for host, n stands for network, s stands for short, and l stands for long. Usually the 16-bit IP port number uses s, and the IP address uses l.

Function format description

Uint16_t htons(unit16_t host16bit) The parameter is the 16-bit data of the host endian

Uint32_t htonl(unit32_t host32bit) The parameter is the 32-bit data of the host endian

Uint16_t ntohs(unit16_t net16bit) The parameter is the 16-bit data of the network byte order.

Uint32_t ntohs(unit32_t net32bit) The parameter is the 32-bit data of the network endian

Address format conversion

The IP address is usually represented by a digital dot (192.168.0.1), and the IP address used in struct in_addr is represented by a 32-bit integer. The following three functions can be used for conversion:

The functions used in Pv4 are inet_aton, inet_addr, and inet_ntoa.

Pv4 and IPv6 compatible functions are inet_pton and inet_ntop, where p is decimal and n is binary.

Int inet_pton(int family, const char *strptr, void *addrptr)

Int inet_ntop(int family, void *addrptr, char *strptr, size_t len)

Family is passed to AF_INET or AF_INET6, addrptr is the converted address, strptr is the value to be converted, len is the size of the converted value, successfully returns 0, and the error returns -1.

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

Among them, inet_aton converts the IP in abcd format to 32-bit IP and stores it in the inp pointer; inet_ntoa converts 32-bit IP to abcd; inet_addr converts a dotted decimal IP into a long integer.

Name address translation

Usually, people don't want to remember lengthy IP addresses during use, so using hostnames is a good choice. Gethostbyname() converts the hostname to an IP address, and gethostbyaddr() is an inverse operation that translates the IP address to a hostname. They all involve a hostent structure, as follows:

Struct hostent

{

Char *h_name; /* official host name */

Char **h_aliases; /*host alias*/

Int h_addrtype; /*address type*/

Int h_length; /* address byte length */

Char **h_addr_list; /* pointed to an IPv4 or IPv6 address pointer array */

};

We can get information about the hostent structure after calling gethostbyname() or gethostbyaddr().

3. The basic functions of socket programming include socket(), bind(), listen(), accept(), sent(), sendto(), recv(), and recvfrom(), as described below.

Based on TCP-Server: Create socket()—>bind() to bind IP address, port information to socket—>listen() set to allow maximum number of connections—>accept() wait for connection request from client—>send() , recv () or read (), write () send and receive data -> close the connection.

Based on TCP-client: Create socket() -> set the IP address and port of the server to be connected, etc. -> connect() to connect to the server -> send(), recv() or read(), write() to send and receive data - >Close the network connection.

Circular Server: The server can only respond to a client's request at the same time.

Socket(...);

Bind(...);

Listen(...);

While(1)

{

Accept(...);

Process(...);

Close(...);

}