A two-way communication without IP confirmation via Udp

Preface

UDP is an unreliable communication, but it is still used sometimes. Today I will share an example: the main logic, a port broadcasts an address, after receiving the IP address data, other ports are bound based on this IP, and finally communicate. This ensures that we do not need to pay attention to the IP address binding problem when we continue to increase port interaction in the future.

Main principles

• The low communication frequency port performs UDP broadcast of the server IP information. The receiving end monitors the specific port of any IP address of the host without fixed IP address.
• After receiving the IP address of the broadcast channel, establish TCP or UDP two-way high-frequency communication with the specific IP and port.

The following figure shows the Socket function call process based on UDP:

Only when receiving do you need to bind the IP and port

Socket listens to all IP specific port codes:

 #define PORT 6000
 bzero ( & adr_inet , sizeof ( adr_inet ) ) ;
 adr_inet .sin_family = AF_INET ;
 adr_inet .sin_addr .s_addr = htonl ( INADDR_ANY ) ;
 adr_inet .sin_port = htons ( port ) ;
 ret = bind ( cfd , ( struct sockaddr * ) & addr , sizeof ( addr ) ) ;

Description of the socket binding IP as INADDR_ANY:

socket INADDR_ANY listens to the 0.0.0.0 address socket and only binds the port to let the routing table decide which IP address to transmit to.

Among them, INADDR_ANY is the address with the specified address of 0.0.0.0. This address actually represents an uncertain address, or "all addresses", "any address". If the IP address is specified as a wildcard address (INADDR_ANY), the kernel will wait until the socket is connected (TCP) or a datagram has been sent on the socket before selecting a local IP address. In general, if you want to build a network server, you need to notify the server operating system: please listen on a port yyyy on a certain address xxx.xxx.xxx.xxx, and send the intercepted data packets to me. This process is completed through the bind() system call. - In other words, your program needs to bind to a certain address of the server, or in other words: occupy a certain port on a certain address of the server as used. The server operating system can give you this specified address, or it can not.

If your server has multiple network cards, and your service (whether listening on a udp port or a tcp port), for some reason: it may be that your server operating system may increase or decrease IP addresses at any time, or it may be to save the trouble of determining what network ports (network cards) are on the server - you can tell the operating system when calling bind(): "I need to listen on port yyyy, so the data sent to this port on the server, no matter which network card/which IP address receives it, is processed by me." At this time, the server listens on the address 0.0.0.0. No matter which IP is connected, it can be connected, as long as all IPs that send to this port can be connected.

Sample code:

data_send.c performs UDP broadcast of the IP address on port 9001 and reads the terminal data and broadcasts it to port 7000

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

 #define IP "127.0.0.1"
 #define
 #define

 // gcc data_send .c - o data_send - pthread

 int cfd = - 1 ;
 // Receive thread function
 void * receive ( void * pth_arg )
 {
 int ret = 0 ;
 char name_data [ 3 ] = { 0 } ;
 struct sockaddr_in addr0 = { 0 } ;
 int addr0_size = sizeof ( addr0 ) ;
 // Receive messages from the peer IP and port number, specify addr0 to store messages
 while ( 1 )
 {
 bzero ( name_data , sizeof ( name_data ) ) ;
 ret = recvfrom ( cfd , name_data , sizeof ( name_data ) , 0 , ( struct sockaddr * ) & addr0 , & addr0_size ) ;
 if ( - 1 == ret )
 {
 fprintf ( stderr , "%d, %s :%s" , __LINE__ , "recv failed" , strerror ( errno ) ) ;
 exit ( - 1 ) ;
 }
 else if ( ret > 0 )
 {
 printf ( "\nname = %s " , name_data ) ; // Print the other party's message and port number
 printf ( "ip %s,port %d \n" , inet_ntoa ( addr0 .sin_addr ) , ntohs ( addr0 .sin_port ) ) ;
 }
 }
 }
 void * data_send ( void * pth_arg )
 {
 int ret = 0 ;
 char data [ ] = "IP address" ;
 struct sockaddr_in addr0 = { 0 } ;
 addr0 .sin_family = AF_INET ; // Set the TCP protocol family
 addr0 .sin_port = htons ( DATA_PORT ) ; // Set port number
 addr0 .sin_addr .s_addr = htonl ( INADDR_ANY ) ; // Set IP address
 // Send message
 while ( 1 )
 {
 ret = sendto ( cfd , ( void * ) data , sizeof ( data ) , 0 , ( struct sockaddr * ) & addr0 , sizeof ( addr0 ) ) ;
 sleep ( 1 ) ;
 if ( - 1 == ret )
 {
 fprintf ( stderr , "%d, %s :%s" , __LINE__ , "sendto failed" , strerror ( errno ) ) ;
 exit ( - 1 ) ;
 }
 }
 }

 int main ( )
 {
 int ret = - 1 ;
 // Create the TCP / IP protocol family and specify the communication mode as unreliable communication without link
 cfd = socket ( AF_INET , SOCK_DGRAM , 0 ) ;
 if ( - 1 == cfd )
 {
 fprintf ( stderr , "%d, %s :%s" , __LINE__ , "socket failed" , strerror ( errno ) ) ;
 exit ( - 1 ) ;
 }

 // Bind port number and ip
 struct sockaddr_in addr ;
 addr .sin_family = AF_INET ; // Set the TCP protocol family
 addr .sin_port = htons ( PORT ) ; // Set the port number
 addr .sin_addr .s_addr = inet_addr ( IP ) ; // Set IP address
 ret = bind ( cfd , ( struct sockaddr * ) & addr , sizeof ( addr ) ) ;

 if ( - 1 == ret )
 {
 fprintf ( stderr , "%d, %s :%s" , __LINE__ , "bind failed" , strerror ( errno ) ) ;
 exit ( - 1 ) ;
 }

 // Create a thread function to process data reception
 pthread_t id , data_send_id ;
 ret = pthread_create ( & id , NULL , receive , NULL ) ;
 if ( - 1 == ret )
 {
 fprintf ( stderr , "%d, %s :%s" , __LINE__ , "pthread_create failed" , strerror ( errno ) ) ;
 exit ( - 1 ) ;
 }
 // pthread_join ( id , NULL ) ;
 ret = pthread_create ( & data_send_id , NULL , data_send , NULL ) ;
 if ( - 1 == ret )
 {
 fprintf ( stderr , "%d, %s :%s" , __LINE__ , "pthread_create failed" , strerror ( errno ) ) ;
 exit ( - 1 ) ;
 }

 struct sockaddr_in addr0 ;
 addr0 .sin_family = AF_INET ; // Set the TCP protocol family
 addr0 .sin_port = htons ( 7000 ) ; // Set the port number
 addr0 .sin_addr .s_addr = inet_addr ( IP ) ; // Set IP address

 char name_send [ 3 ] = { 0 } ;
 // Send message
 while ( 1 )
 {
 bzero ( name_send , sizeof ( name_send ) ) ;
 printf ( "send name: " ) ;
 scanf ( "%s" , name_send ) ;

 // When sending a message, you need to bind the other party's IP and port number
 ret = sendto ( cfd , ( void * ) name_send , sizeof ( name_send ) , 0 , ( struct sockaddr * ) & addr0 , sizeof ( addr0 ) ) ;
 if ( - 1 == ret )
 {
 fprintf ( stderr , "%d, %s :%s" , __LINE__ , "accept failed" , strerror ( errno ) ) ;
 exit ( - 1 ) ;
 }
 }
 return 0 ;
 }

data_process.c captures the IP data of port 9001. After receiving the IP data, it binds the broadcast IP address to send and receive data. UDP is used for reception here, and you can also try TCP interaction.

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

 #define IP "127.0.0.1"
 #define
 #define
 // typedef uint32_t in_addr_t ;

 // gcc data_process .c - o data_process - pthread
 int cfd = - 1 , data_fd = - 1 ;
 uint32_t receive_ip = - 1 ;
 void * receive ( void * pth_arg )
 {
 int ret = 0 ;
 char name_data [ 3 ] = { 0 } ;
 struct sockaddr_in addr0 = { 0 } ;
 int addr0_size = sizeof ( addr0 ) ;
 while ( 1 )
 {
 printf ( "receive: " ) ;
 bzero ( name_data , sizeof ( name_data ) ) ;
 ret = recvfrom ( cfd , name_data , sizeof ( name_data ) , 0 , ( struct sockaddr * ) & addr0 , & addr0_size ) ;
 if ( - 1 == ret )
 {
 fprintf ( stderr , "%d, %s :%s" , __LINE__ , "recv failed" , strerror ( errno ) ) ;
 exit ( - 1 ) ;
 }
 else if ( ret > 0 )
 {
 printf ( "\nname = %s " , name_data ) ;
 printf ( "ip %s,port %d \n" , inet_ntoa ( addr0 .sin_addr ) , ntohs ( addr0 .sin_port ) ) ;
 }
 }
 }
 void * data_receive ( void * pth_arg )
 {
 int ret = 0 ;
 char name_data [ 10 ] = { 0 } ;
 struct sockaddr_in addr0 = { 0 } ;
 int addr0_size = sizeof ( addr0 ) ;
 while ( 1 )
 {
 bzero ( name_data , sizeof ( name_data ) ) ;
 ret = recvfrom ( data_fd , name_data , sizeof ( name_data ) , 0 , ( struct sockaddr * ) & addr0 , & addr0_size ) ;
 if ( - 1 == ret )
 {
 fprintf ( stderr , "%d, %s :%s" , __LINE__ , "recv failed" , strerror ( errno ) ) ;
 exit ( - 1 ) ;
 }
 else if ( ret > 0 )
 {
 printf ( "\nname = %s " , name_data ) ;
 printf ( "ip %s,port %d \n" , inet_ntoa ( addr0 .sin_addr ) , ntohs ( addr0 .sin_port ) ) ;
 receive_ip = addr0 .sin_addr .s_addr ;
 char buf [ 20 ] = {0} ;​
 inet_ntop ( AF_INET , & receive_ip , buf , sizeof ( buf ) ) ;
 printf ( "receive_ip ip = %s " , buf ) ;
 // printf ( "receive_ip ip = %s " , inet_ntop ( receive_ip ) ) ;
 break ;
 }
 }
 }
 int main ( )
 {
 int ret = - 1 ;
 data_fd = socket ( AF_INET , SOCK_DGRAM , 0 ) ;
 if ( - 1 == data_fd )
 {
 fprintf ( stderr , "%d, %s :%s" , __LINE__ , "socket failed" , strerror ( errno ) ) ;
 exit ( - 1 ) ;
 }

 struct sockaddr_in addr ;
 addr .sin_family = AF_INET ; // Set the TCP protocol family
 addr .sin_port = htons ( DATA_PORT ) ; // Set the port number
 addr .sin_addr .s_addr = inet_addr ( IP ) ; // Set IP address
 ret = bind ( data_fd , ( struct sockaddr * ) & addr , sizeof ( addr ) ) ;
 if ( - 1 == ret )
 {
 fprintf ( stderr , "%d, %s :%s" , __LINE__ , "bind failed" , strerror ( errno ) ) ;
 exit ( - 1 ) ;
 }
 pthread_t receive_id ;
 ret = pthread_create ( & receive_id , NULL , data_receive , NULL ) ;
 if ( - 1 == ret )
 {
 fprintf ( stderr , "%d, %s :%s" , __LINE__ , "pthread_create failed" , strerror ( errno ) ) ;
 exit ( - 1 ) ;
 }
 pthread_join ( receive_id , NULL ) ;

 cfd = socket ( AF_INET , SOCK_DGRAM , 0 ) ;
 if ( - 1 == cfd )
 {
 fprintf ( stderr , "%d, %s :%s" , __LINE__ , "socket failed" , strerror ( errno ) ) ;
 exit ( - 1 ) ;
 }

 struct sockaddr_in addr1 ;
 addr1 .sin_family = AF_INET ; // Set the TCP protocol family
 addr1 .sin_port = htons ( PORT ) ; // Set the port number
 addr1 .sin_addr .s_addr = receive_ip ; // Set IP address
 char buf [ 20 ] = {0} ;​
 inet_ntop ( AF_INET , & receive_ip , buf , sizeof ( buf ) ) ;
 printf ( "ip = %s " , buf ) ;

 ret = bind ( cfd , ( struct sockaddr * ) & addr1 , sizeof ( addr1 ) ) ;
 if ( - 1 == ret )
 {
 fprintf ( stderr , "%d, %s :%s" , __LINE__ , "bind failed" , strerror ( errno ) ) ;
 exit ( - 1 ) ;
 }

 pthread_t id ;
 ret = pthread_create ( & id , NULL , receive , NULL ) ;
 if ( - 1 == ret )
 {
 fprintf ( stderr , "%d, %s :%s" , __LINE__ , "pthread_create failed" , strerror ( errno ) ) ;
 exit ( - 1 ) ;
 }
 pthread_join ( id , NULL ) ;

 struct sockaddr_in addr0 ;
 addr0 .sin_family = AF_INET ; // Set the TCP protocol family
 addr0 .sin_port = htons ( 6000 ) ; // Set the port number
 addr0 .sin_addr .s_addr = inet_addr ( IP ) ; // Set IP address

 char name_send [ 3 ] = { 0 } ;
 while ( 1 )
 {
 bzero ( name_send , sizeof ( name_send ) ) ;
 printf ( "send name: " ) ;
 scanf ( "%s" , name_send ) ;

 ret = sendto ( cfd , ( void * ) name_send , sizeof ( name_send ) , 0 , ( struct sockaddr * ) & addr0 , sizeof ( addr0 ) ) ;
 if ( - 1 == ret )
 {
 fprintf ( stderr , "%d, %s :%s" , __LINE__ , "accept failed" , strerror ( errno ) ) ;
 exit ( - 1 ) ;
 }
 }
 return 0 ;
 }

One terminal captures data, sudo tcpdump -i lo portrange 5000-8000 -vv -XX -nn, and the other two terminals exchange data

Conclusion

This is my own sharing of some of my UDP design ideas. If you have better ideas and needs, you are also welcome to add me as a friend to communicate and share.

Author: Liangzhiyoucun, works hard during the day and is the original account owner at night. In addition to technology, the content of the public account also contains some life insights. He is a workplace veteran who outputs content seriously, and also a person who enriches his life outside of technology, photography, music and basketball.