TCP Client/Server (select) 運作觀念

tags: linux select C LANGUAGE

Author: WhoAmI
Date: 20220805
E-mail: [e-mail]
Copyright: CC BY-NC-SA

---

有效的 fd 個數, fd 的 狀態(新連線, 讀, 寫, 例外), timeout , 與 select() 回傳狀態 是此種方法的重點之一!
至於 poll 而 epoll epoll_wait 則是 Linux 改良版 (red-black tree)! 都是類似觀念!

重要提醒這是一個小程式(能動不代表能用) 但是可學的問題很多, select (與 epoll, epoll_wait)是很重要的system call, "一定要會". 這不一定只用於網路程式, 用於很多地方, 尤其I/O 的部分!

Futher Reading:
select system call-synchronous I/O multiplexing

---

/*
Source:
select.c

Usage:
Server:
./select

Client:
telnet ip port
//如果用 window putty 的 telnet 可能怪怪的, 因此最好寫一簡單的client 參考 Append A.

select 是很重要的 function 用途很多!
上課說明 UNIX OS 原來設計的缺點, (不用害怕, 不難的!!) 效能不好 因此後來改 epoll_wait 或 non-blocking mode 這裡也是實作關鍵, 還有 write_fds 也可用
再次提醒: tv 值會被 OS 改變為剩下時間!!

**TRY IT and FIX IT **

以下很重要 不小心會崩潰如山倒*

congestion propagation:整個系統效能除了本身程式效能以外還與系統規劃設計有關

input buffer 與 output buffer 的觀念相當重要! (這裡我們不研究研究數學理論)

整個 系統是 input queue 與 output queue 環環相扣的 queueing networks 的問題!(想像這世界的交通網路!)

Computer Organization | Locality and Cache friendly code

if(發生機率高){

}else{

}

效能一般比較好

Linux kernel 中就有 likely ()和 unlikely () macro
優化效能

DEAD LOCK
There are many bugs when "recv/read" and "send/write" are performed, in real case.
Notice that "send/write" may cause the blocking effect, when the network or OS is un-stable.

HW:
TRY to WRITE a CLIENT to GENERATE SERVER CRASH

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

//以下 PANIC 比較好的 exit(0)? 還是 exit(-1); 我先寫出來避免忘了說~~請看 HELP 3  與 "zombie" 的產生!!
#define PANIC(msg) { perror(msg); exit(0); }

#define STDIN 0

//One must handle  SIGPIPE -----------------------------------
//Notice SIGPIPE for data transmission, see man 7 signal
//
static void sig_pipe(int signum)
{
    printf(" Broken Pipe!\n");
}
static void HandleSignal(void){  //handle all signals
   signal(SIGPIPE, sig_pipe);
}
//---------------------------------------------------------------------
int main(int argc, char *argv[])
{
 int server_fd;
 int client_fd;
 struct sockaddr_in server_addr;
 struct sockaddr_in client_addr;
 fd_set master_fds;
 fd_set read_fds;
 int fdmax;
 struct timeval tv; 
 int port;
 int len;
 int i, j;
 char buf[256],ch;
 int nbytes;
 int yes=1;
 int retval;
 
 
 if(argc>1)port=atoi(argv[1]);
        else port=9999;
       
     
 HandleSignal();

 FD_ZERO(&master_fds);
 FD_ZERO(&read_fds);
 
 if ((server_fd = socket(AF_INET, SOCK_STREAM, 0)) == -1) PANIC("socket");
 if (setsockopt(server_fd,SOL_SOCKET,SO_REUSEADDR,&yes,sizeof(int)) == -1) PANIC("setsockopt");
  
        memset(&server_addr,0,sizeof(server_addr));
 server_addr.sin_family = AF_INET;
 server_addr.sin_addr.s_addr = INADDR_ANY;
 server_addr.sin_port = htons(port);
 
 if (bind(server_fd,(struct sockaddr *)&server_addr,sizeof(server_addr))==-1) PANIC("bind");
 if (listen(server_fd,10) == -1) PANIC("listen");

 FD_SET(server_fd,&master_fds);
 FD_SET(STDIN,&master_fds); //for STDIIN
 
 fdmax = server_fd;
   
 //  Server Loop
 for(;;) {
  read_fds=master_fds;

//效能不好 因此後來改 epoll_wait, 還有如何使用master_fds 省去 read_fds=master_fds;

  tv.tv_sec = 60;            //時間控制很重要 
  tv.tv_usec = 0;
//----------------------------------------------------------------------------------
  retval = select(fdmax+1,&read_fds,NULL,NULL,&tv); 

//------------------------------------------------------------------------------------  
  switch(retval){   

//switch, if, ...有牽涉執行效能問題 , Linux kernel 有 unlikely, likely, 還有指令排序問題, 提醒我上課時說明

       case -1:
   perror("select");
   continue;
       case 0:
          printf("Time Out...");
          for(i=3; i<= fdmax; i++) {   // 為何 3?
           if (FD_ISSET(i,&master_fds)) close(i);
          }  
          exit(0);  // 暴力法~~其實有改善空間           
  }
                  
  for(i=0; i<=fdmax; i++) {
      if (FD_ISSET(i,&read_fds)) {
         if (i==server_fd) { //Handle New Connection
    len = sizeof(client_addr);
    if ((client_fd=accept(server_fd,(struct sockaddr *)&client_addr,&len)) == -1) {
                perror("accept"); // 還是使用 PANIC(msg) 暴力法忍痛離開 ?
                continue;
    } else {
         FD_SET(client_fd, &master_fds);
                       if (client_fd > fdmax) {
                    fdmax = client_fd;
                        }
                       printf("New connection from %s on socket %d\n",inet_ntoa(client_addr.sin_addr),client_fd);
                 }
                }else { // Handle data from the clients and the STDIN
                 
//one can read string from stdin

     if ((nbytes=read(i, buf, sizeof(buf))) > 0) {   //see HELP 1

         write(0,buf,nbytes); //a little bug before write(0,...), why?
         for(j=0; j<=fdmax; j++) {
                                   if (FD_ISSET(j, &master_fds)) {
                                       if (j!=server_fd && j!=i &&j!=0) {
                                            if (send(j, buf, nbytes, 0) == -1) {  //see HELP 1
                                                perror("send"); //FIX IT  e.g. close(j)!
/*
(1) how to handle SIGPIPE
(2) how to handle blocking

*/
                                            }
                                        }
                                   }
                                   }//for
      
                          } else {
                                perror("recv");
                       close(i);
                       FD_CLR(i, &master_fds);
                          }
                      }

                 }//if
            } //for scan all IO
        }//for server loop
       return 0;
}

Basic idea:

process–>ADD fd to read_fds –->(I) select active fd
(a)if active –>generate new fd–>(II)add new fd to the select read_fds
(b)if the active fd is socket fd–>generate new fd–>(II) add new fd to the select read_fds
© if the active fd is read/write fd–>read/write–>(I)select active fd

HELP 1:
(a) system level ERROR PROPAGATION & DEAD LOCK
for (…){
assume i=k
(nbytes=read(i, buf, sizeof(buf))) > 0
…
for all j!=k {
send(j, buf, nbytes, 0)
}
If client k has many data frames, the server will forward data frames to all clients (j!=k).
This will cause a big problem because the network will crash.
Hence, one must set "send IO" timeout usually.
…
}
(b) send: blocking problem (non-blocking mode or timeout)

​​​​  HOW TO generate this problem
​​​​  如何測試? 提供您想法: client >>透過無線或3G 大量資料快速傳送至 server 

© send: broken pipe (SIGPIPE)
(a) HOW TO generate this problem
(b) Use signal(SIGPIPE, SIG_IGN) to avoid the signal
如何測試? 提供您想法: client >>透過無線或3G 大量資料快速傳送至 server, 然後讓server 非正常 off!

​​​​  /*
​​​​  Please see man 2 send
​
​​​​  */

(d)
For advanced user, please study three problems:

Handle TCP_NODELAY with care
/* Disable TCP Nagle i.e., set tcp_proto->p_proto TCP_NODELAY*/
optval=1;
setsockopt(fd, SOL_TCP, TCP_NODELAY, &optval, sizeof(optval))

Please care
O_NONBLOCK
fcntl(fd, F_SETFL, O_NONBLOCK);

​​​​    SO_KEEPALIVE

*/

HELP 3 "zombie" 的產生!! & SIGCHLD
Linux man page

exit - cause normal process termination

#include <stdlib.h>
void exit(int status);

The exit() function causes normal process termination and the value of status & 0377 is returned to the parent (see wait(2)).
//小心~~~順便一提 0377 是 C 語言 的8進位 (0377 =0xFF) <<<很多人搞錯的!!

The C standard specifies two constants, EXIT_SUCCESS and EXIT_FAILURE, that may be passed to exit() to indicate successful or unsuccessful termination, respectively. ***

---

Constant Explanation
EXIT_SUCCESS successful execution of a program
EXIT_FAILURE unsuccessful execution of a program

***http://en.cppreference.com/w/c/program/EXIT_status

---

If your process has child processes, please handle SIGCHLD or set signal(SIGCHLD, SIG_IGN) before the fork.
see https://www.win.tue.nl/~aeb/linux/lk/lk-5.html

After exit(), the exit status must be transmitted to the parent process. There are three cases:

(A) If the parent has set SA_NOCLDWAIT, or has set the SIGCHLD handler to SIG_IGN, the status is discarded and the child dies immediately.

(B) If the parent was waiting on the child, it is notified of the exit status and the child dies immediately.

© Otherwise, the child becomes a "zombie" process: most of the process resources are recycled, but a slot containing minimal information about the child process (termination status, resource usage statistics) is retained in process table. This allows the parent to subsequently use waitpid(2) (or similar) to learn the termination status of the child; at that point the zombie process slot is released.

其實會簡單的 GPIO driver 配合 user space select 很有用途

我只提幾個
很多 device node 可以用 open 但不能用 fopen ! 為甚麼?
很多 device node 可以用 read 不能用 select 為甚麼?
當不能用時, 如何改寫!
只能一個 process 讀取, 如何改變成 多個 process 讀取?
…
很多技巧…期待您好好學~這可是您的專長之一

再次顯示 "會動容易, 實用不容易"

Append A. 這是簡單測試用
//注意小bug 沒有 '\0'!!! 請自己寫!!

---

//simple client
#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <errno.h>

#include <unistd.h>

#include <sys/types.h>

#include <sys/socket.h>

#include <netinet/in.h>

#include <arpa/inet.h>

static int opentcp(char  *ip, int port)

{   int sockfd;

    struct sockaddr_in dest;

    int len;

    int ret;



    /*---Open socket for streaming---*/

    if ( (sockfd = socket(AF_INET, SOCK_STREAM, 0)) < 0 )

    {

        perror("Socket");

 

    }



    /*---Initialize server address/port struct---*/

    memset(&dest, 0,sizeof(dest));

    dest.sin_family = AF_INET;

    dest.sin_port = htons(port);

    dest.sin_addr.s_addr=inet_addr(ip);





    /*---Connect to server---*/

    if ( connect(sockfd, (struct sockaddr*)&dest, sizeof(dest)) != 0 )

    {

        perror("Connect ");



        close(sockfd);

        return -1;

    }



    return sockfd;

}

int main(int argc, char *argv[])
{

  int i;
  char *ip="127.0.0.1";
  int port=9999;
  char cmd[256]="ok\n";
  int fd;
  int n;
  for(i=0;i<argc;i++){
      if(strcmp("-ip",argv[i])==0)ip=argv[++i];
      if(strcmp("-port",argv[i])==0)port=atoi(argv[++i]);
  }

   fd=opentcp(ip,port);

   if(fd>0){
     do{
       printf("virt>");
       if ( fgets(cmd, sizeof(cmd), stdin) != 0 )
        {

           write(fd,cmd,strlen(cmd)); //注意小bug 沒有 '\0'!!! 請自己寫!!
           printf("[%s]\n",cmd);
           if(strstr(cmd,"bye"))break;
        }
        //事實上以下有實務性的考量, 實際上需要更嚴謹!!  FIX IT!
        //How to read byte stream, if we cannot know its length in advance? 
        //提醒我 敎 ring buffer 與 malloc 實際使用差別!! 尤其  embedded system 特別重要!! See Ring Buffer

          n=read(fd, cmd, 256);
          if(n>0){cmd[n]=0;printf("%s",cmd);}

      }while(1);
       close(fd);
   }
}

Appendix B.
O_NONBLOCK, connect, read, send 與 select 合併運用提供參考

read system call

ERRORS:

EAGAIN or EWOULDBLOCK
The file descriptor fd refers to a socket and has been marked nonblocking (O_NONBLOCK), and the read would block.

EINTR
The call was interrupted by a signal before any data was read;

write system call

ERRORS:

EAGAIN

The file descriptor fd refers to a file other than a socket and has been marked nonblocking (O_NONBLOCK), and the write would block.

EINTR
The call was interrupted by a signal before any data was written;

EPIPE
fd is connected to a pipe or socket whose reading end is closed. When this happens the writing process will also receive a SIGPIPE signal. (Thus, the write return value is seen only if the program catches, blocks or ignores this signal.)

Socket options (see man 7 socket)

---

SO_RCVTIMEO and SO_SNDTIMEO
Specify the receiving or sending timeouts until reporting an
error. The argument is a struct timeval. If an input or out‐
put function blocks for this period of time, and data has been
sent or received, the return value of that function will be
the amount of data transferred; if no data has been trans‐
ferred and the timeout has been reached, then -1 is returned
with errno set to EAGAIN or EWOULDBLOCK, or EINPROGRESS (for
connect(2)) just as if the socket was specified to be non‐
blocking. If the timeout is set to zero (the default), then
the operation will never timeout.

Timeouts only have effectfor system calls that perform socket I/O (e.g., read(2), recvmsg(2), send(2), sendmsg(2));
timeouts have no effect for select(2), poll(2), epoll_wait(2), and so on.

運用 popen 執行server 端的程式

popen, pclose - pipe stream to or from a process

/*

Important syytem call: 
  select()

I/O re-direction
popen application




WhoAmI 20191210
*/



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

#include <sys/wait.h>

#define PANIC(msg) { perror(msg); exit(EXIT_FAILURE); }
#define STDIN 0 


static void sig_handler(int signo)
{
    pid_t pid;
    int stat;


    switch(signo)
    {

        case SIGCHLD:
            printf("SIGCHLD=%d\n",signo);
            pid=waitpid(0,&stat,WNOHANG);
            break;

        case SIGINT:
            printf("SIGINT=%d\n",signo);
            break;
        case SIGALRM:
            printf("Got SIGALRM=%d, exit!\n",signo);
            exit( EXIT_FAILURE);

            break;

        case SIGPIPE:
             printf("Got SIGPIPE=%d, exit!\n",signo);
             //exit( EXIT_FAILURE);
            
        default:
            printf("signal=%d\n",signo);

        }
      

    return;
}

#define MY_LENTH 1023

int writet(int fd,char *buf,int len,int secs)
{
	fd_set w_fds;
	struct timeval tv;
    int n;
    int m,j;

    tv.tv_sec = secs;
    tv.tv_usec = 0;
    FD_ZERO(&w_fds);
	FD_SET(fd,&w_fds);

    m=0;
    j=0;
    do{

     n = select(fd+1, NULL, &w_fds, NULL,  &tv );

     switch(n){
            case 0:
           
                errno = ETIMEDOUT;
                printf("Write timeout!\n");         

                return -1;
                break;
            case -1:
                return -1;

            default:

                 m=write(fd,buf+j,len-j);
                 j=j+m;

                 break;
      }  

     }while(m>0);
}




static int run(int ofd, char *buf,int n)
{

   FILE *fp;
   int fd;
   unsigned char *p;
   int i,len;
   char obuf[MY_LENTH+1];
  
   
   
   for(p=buf;*p>=' ';p++){
      
   }
   *p=0;

   printf("%s\n",buf);
  // fp=popen("ls -l","r");
   fp = popen(buf,"r");
   fd=fileno(fp);

   do{


     memset(obuf,0,MY_LENTH+1);

     p=fgets(obuf, MY_LENTH , fp);

     obuf[MY_LENTH]=0;
     

     printf("%s",obuf);

     if(ofd>0){

          if(p)writet(ofd,p,strlen(p),1);
     }

   }while(p!=NULL);
   pclose(fp);  
   
  
   
}

int main(int argc, char *argv[])
{
	int server_fd; 
	int client_fd; 
	struct sockaddr_in server_addr; 
	struct sockaddr_in client_addr; 
	fd_set master_fds; 
	fd_set read_fds; 
	int fdmax; 
	struct timeval tv;	
	int port;
	int len;
	int i, j;
	char buf[1024],ch; 
	int nbytes;
	int yes=1; 
	int retval;
    char cmd[512];
    int n;
    int timeout;
	
	 
	if(argc>1)port=atoi(argv[1]);
        else port=9999;

    if(argc>2)timeout=atoi(argv[2]);
        else timeout=160; 

    printf("Server start port=%d timeout=%d\n",port,timeout);

         
    signal (SIGPIPE, sig_handler);   
//	signal (SIGPIPE,SIG_IGN);

	FD_ZERO(&master_fds); 
	FD_ZERO(&read_fds);
	
	if ((server_fd = socket(AF_INET, SOCK_STREAM, 0)) == -1) PANIC("socket");
	if (setsockopt(server_fd,SOL_SOCKET,SO_REUSEADDR,&yes,sizeof(int)) == -1) PANIC("setsockopt");
		
        memset(&server_addr,0,sizeof(server_addr));
	server_addr.sin_family = AF_INET;
	server_addr.sin_addr.s_addr = INADDR_ANY;
	server_addr.sin_port = htons(port);
	
	if (bind(server_fd,(struct sockaddr *)&server_addr,sizeof(server_addr))==-1) PANIC("bind");
	if (listen(server_fd,10) == -1) PANIC("listen");

	FD_SET(server_fd,&master_fds);
	FD_SET(STDIN,&master_fds);
	
	fdmax = server_fd; 
			
	//  Server Loop
	for(;;) {
		read_fds=master_fds; 
		tv.tv_sec = 160;
	        tv.tv_usec = 0;
		retval = select(fdmax+1,&read_fds,NULL,NULL,&tv);
		
		switch(retval){			
		     case -1:
			perror("select");
			continue;
		     case 0:
		        printf("Time Out...");
		        for(i=3; i<= fdmax; i++) {
		        	if (FD_ISSET(i,&master_fds)) close(i);
		        } 	
		        exit(0);		         	
		}
              	      
		for(i=0; i<=fdmax; i++) {
		    if (FD_ISSET(i,&read_fds)) { 
		       if (i==server_fd) { //Handle New Connection
				len = sizeof(client_addr);
				if ((client_fd=accept(server_fd,(struct sockaddr *)&client_addr,&len)) == -1) {
			             perror("accept");
			             continue;
				} else {
				     FD_SET(client_fd, &master_fds); 
		                     if (client_fd > fdmax) { 
			                 fdmax = client_fd;
		                      }
		                     printf("New connection from %s on socket %d\n",inet_ntoa(client_addr.sin_addr),client_fd);
                             n=sprintf(cmd,"Welcome new connection from IP:%s on socket %d\n",inet_ntoa(client_addr.sin_addr),client_fd);
                             write(client_fd,cmd,n);
		               }
	               }else { // Handle data from the clients and the STDIN
	               	
			  if ((nbytes=read(i, buf, sizeof(buf))) > 0) {

                   if(buf[0]=='!'){
                      
                      run(i, &buf[1],nbytes-1);
                      //close connection

                      close(i); 
	                  FD_CLR(i, &master_fds); 
                     
                   }if(buf[0]=='@'){
                      //Don't close connction
                      run(i, &buf[1],nbytes-1);

                   }else{
                       
                      
                   }
			  	   write(0,buf,nbytes);


			  	   for(j=0; j<=fdmax; j++) { 
                                   if (FD_ISSET(j, &master_fds)) {
                                       if (j!=server_fd && j!=i &&j!=0) {
                                            if (send(j, buf, nbytes, 0) == -1) {
                                                perror("send");
                                            }
                                        }
                                   }
                                   }//for
			  	
                          } else { 
                                perror("recv");
	                     	close(i); 
	                     	FD_CLR(i, &master_fds); 
                          }
                   } //for loop

                 }//if
            } //for scan all IO
        }//for server loop
       return 0;
}

Homework:

Simple Mail Transfer Protocol(SMTP)