写的一个linux客户端操作cmp

矫情吗；* 2022-12-10 07:29 130阅读 0赞

#include <stdio.h>
    #include <unistd.h>
    #include <stdlib.h>
    #include <string.h>
    #include <sys/socket.h>
    #include <arpa/inet.h>
    #include <signal.h>
    #include <errno.h>
    #define IPV4(a,b,c,d) ((a<<0)|(b<<8)|(c<<16)|(d<<24))
    #define ENDWITH '!' //需要PMAC代替
    #define SEPERATE "," //需要PMAC代替
    #define TIMER_USER 10000 //10ms
    #define STRING_FUN 0
    #define NUM_STRNG_FUN 1
    #define BYTES_FUN 2 
    #define ONLY2TJ 3 //定义四种功能
    #define MAX_CLIENT 4
    #define MAX_SIZE_ 100
    #define PMAC_VAR 10
    #define tout_ 2 //接收超时处理时间
    
    extern int close_client[MAX_CLIENT];//需用PMAC代替，自动断开客户端链接;
    
    extern int init_flag,max_index,exmaxfd;
    
    extern char *all_data;
    //extern char all_send_data[MAX_SIZE_*MAX_CLIENT];//需用PMAC代替
    extern char *all_send_data;
    
    //extern double all_send_num[PMAC_VAR*MAX_CLIENT];//需用PMAC代替
    extern double *all_send_num;//需用PMAC代替
    
    extern double *PMAC_global;
    
    extern fd_set all_fds,exread_fds;
    
    extern int all_tcp_client[MAX_CLIENT],FUN_FLAG[MAX_CLIENT];
    
    //extern int all_monitor_addr_port[20]; //用global变量代替 5 * MAX_CLIENT
    
    extern int *all_monitor_addr_port; 
    
    void init_external_client();
    
    int addr_gather(int *five_array,in_addr_t *rec);
    
    void deal_data();
    
    void deal_string(int,int);
    
    void deal_num_string(int,int);
    
    void deal_num_byte(int,int);
    
    void deal_ONLY2TJ(int,int);
    
    void deal_send();
    
    void alarm_tiout();
    
    //处理传来的字符串
    void split_cmd(char *src, const char *separator, char **dest, int *num)
    { 
     /* src 源字符串的首地址(buf的地址) separator 指定的分割字符 dest 接收子字符串的数组 num 分割后子字符串的个数 */
     char *pNext;
     int count = 0;
     if (src == NULL || strlen(src) == 0) //如果传入的地址为空或长度为0，直接终止
     return;
     if (separator == NULL || strlen(separator) == 0) //如未指定分割的字符串，直接终止
     return;
     pNext = (char *)strtok(src,separator); //使用(char *)进行强制类型转换
     while(pNext != NULL) { 
      *dest++ = pNext;
      ++count;
      pNext = (char *)strtok(NULL,separator);  //使用(char *)进行强制类型转换
     }
     *num = count;
    }
    
    void recv_tj(char *comd){ 
     char *split_comd[100];
     int num=0; 
     split_cmd(comd,"!",split_comd,&num);
     double x=0,y=0,z=0,a=0,b=0,c=0;
     int i=0;
     while(i<num){ 
     sscanf(split_comd[i],"%lf,%lf,%lf,%lf,%lf,%lf",&x,&y,&z,&a,&b,&c);
     SetGlobalArrayVar(tj_data_x,i,x);
     SetGlobalArrayVar(tj_data_y,i,y);
     SetGlobalArrayVar(tj_data_z,i,z);
     SetGlobalArrayVar(tj_data_a,i,a);
     SetGlobalArrayVar(tj_data_b,i,b);
     SetGlobalArrayVar(tj_data_c,i,c);
     i++;
     }
     SetGlobalVar(isfinish,1);
    }

#include <gplib.h> // Global Gp Shared memory pointer
    #include <stdio.h>
    #include <string.h>
    #include <stdlib.h>
    #include "client.h"
    #include "../../Include/pp_proj.h"
    
    int all_tcp_client[MAX_CLIENT]={ -1,-1,-1,-1};
    
    int close_client[MAX_CLIENT] = { -1,-1,-1,-1};//需用PMAC代替，自动断开客户端链接;
    
    int FUN_FLAG[MAX_CLIENT] = { -1,-1,-1,-1};//需用PMAC代替
    
    char temp_data[MAX_SIZE_*MAX_CLIENT];
    
    
    char buff_data[MAX_SIZE_*MAX_CLIENT];//缓冲区
    
    //char all_data[MAX_SIZE_*MAX_CLIENT];//需用PMAC代替
    char *all_data=NULL;
    //char all_send_data[MAX_SIZE_*MAX_CLIENT];//需用PMAC代替
    char *all_send_data = NULL;
    
    //double all_send_num[PMAC_VAR*MAX_CLIENT]={0};//需用PMAC代替
    double *all_send_num = NULL;//需用PMAC代替
    
    //double PMAC_global[PMAC_VAR*MAX_CLIENT];//需用PMAC代替，接受发过来的字符串浮点数;每个最大为PMAC_VAR个
    double *PMAC_global = NULL;
    struct timeval tv1;//select超时时间
    
    int max_index = 0;
    
    int global_signal[MAX_CLIENT] = { -1,-1,-1,-1};
    
    int exmaxfd = -1;
    
    //int all_monitor_addr_port[MAX_CLIENT*5] = {0};
    
    //int *Pall_monitor_addr_port = all_monitor_addr_port;//需用PMAC代替
    int *all_monitor_addr_port = NULL;
    
    fd_set all_fds,exread_fds;
    
    int init_flag = 0;
    
    void init_external_client()  //需要可以建立4
    { 
        if(init_flag == 0){ //初始化一次
            FD_ZERO(&all_fds);
            FD_ZERO(&exread_fds);
            tv1.tv_sec = 0;//select超时时间,0s
            tv1.tv_usec = 0;//select超时时间,0us
            memset(temp_data,0,sizeof temp_data);
            memset(buff_data,0,sizeof buff_data);
            signal(SIGALRM,alarm_tiout);
    		all_data=(char*)pushm+200;				//200 
    		all_send_data=(char*)pushm+600;				
    		all_send_num=(double*)pushm+125;					//1000
    		PMAC_global=(double*)pushm+165; //1320
    		all_monitor_addr_port=(int*)pushm+410;   //1640
            init_flag = 1;
        }
        if(all_tcp_client[MAX_CLIENT -1] != -1){ 
    		printf("linked reach max\n");
    		return;
    	}
    	int traverse_num = 0;
        int arrindex = 0;
        for(;traverse_num < 5*MAX_CLIENT;traverse_num+=5){ 
            
    		if(all_monitor_addr_port[traverse_num] && all_monitor_addr_port[traverse_num+4]){ 
    			if(all_tcp_client[traverse_num / 5] != -1 && FD_ISSET(all_tcp_client[traverse_num / 5],&all_fds)){ //证明该客户端已经链接，重新连接
    				close(all_tcp_client[traverse_num / 5]);
                    FD_CLR(all_tcp_client[traverse_num / 5],&all_fds);
                    if(all_tcp_client[traverse_num / 5]==exmaxfd)exmaxfd--;
                    all_tcp_client[traverse_num / 5]=-1;
    			}
                struct sockaddr_in external_serv_addr;//局部结构体
                memset(&external_serv_addr,0,sizeof external_serv_addr);//清空结构体
                int external_cfd = socket(AF_INET,SOCK_STREAM,0);
                external_serv_addr.sin_port = htons(all_monitor_addr_port[traverse_num+4]);
                external_serv_addr.sin_family = AF_INET;
                if(!addr_gather(&all_monitor_addr_port[traverse_num],&external_serv_addr.sin_addr.s_addr)){ 
                    perror("addr transfer");
                    return;
                }
                int rev = connect(external_cfd,(struct sockaddr *)&external_serv_addr,sizeof external_serv_addr);
                if (rev == -1)
                { 
                    perror("external_client_connect");
                    memset(&all_monitor_addr_port[traverse_num],0,5*sizeof(double));
                    memset(&all_send_data[(traverse_num) / 5 * MAX_SIZE_],0, MAX_SIZE_ * sizeof(char));
                    memset(&all_send_num[(traverse_num) / 5 * PMAC_VAR],0, PMAC_VAR * sizeof(char));
                    return;//如果服务器未启动，连接失败可以进行多次连接
                }
                for(;arrindex < MAX_CLIENT;arrindex++){ 
                   if(all_tcp_client[arrindex] == -1){ 
                       all_tcp_client[arrindex] = external_cfd;//将套接字加入自定义队列
                       FD_SET(external_cfd,&all_fds);//加入读取队列
                       if(external_cfd>exmaxfd) exmaxfd = external_cfd;
                       max_index = arrindex; //更新最大自定索引
                       break;
                   }
                }
                memset(&all_monitor_addr_port[traverse_num],0,5 * sizeof(int));
    		}
    	}
        return;
    }
    
    int addr_gather(int *five_array,in_addr_t *rec)//返回字符串IP
    { 
    	unsigned int value=IPV4(five_array[0],five_array[1],five_array[2],five_array[3]);
    	in_addr_t ip;
    	memcpy(&ip,&value,sizeof(value));
        return inet_pton(AF_INET,inet_ntoa(*((struct in_addr*)&ip)),rec);
    }
    
    void deal_data()
    { 
        exread_fds=all_fds;
        int sr=select(exmaxfd+1,&exread_fds,NULL,NULL,&tv1);//不阻塞
        if(sr==-1){ /*if(errno != EINTR){*/perror("select perror:");return;/*}else{errno = 0;}*/}//防止闹钟线程
        else if(sr==0){ tv1.tv_sec = 0;tv1.tv_usec = TIMER_USER;deal_send();set_var();return;}
        int tmpindex = 0;
        for(;tmpindex <= max_index;tmpindex++){ 
            if (FD_ISSET(all_tcp_client[tmpindex],&exread_fds)){ 
                int n = recv(all_tcp_client[tmpindex],&temp_data[tmpindex * MAX_SIZE_],MAX_SIZE_ * sizeof(char),0);
                if(n <= 0){ 
                    close(all_tcp_client[tmpindex]);
                    FD_CLR(all_tcp_client[tmpindex],&all_fds);
                    if(all_tcp_client[tmpindex]==exmaxfd)exmaxfd--;
                    all_tcp_client[tmpindex]=-1;
                    printf("%dth client host closed\n",tmpindex);
                    continue;
                }
                if(FUN_FLAG[tmpindex] == STRING_FUN){ 
                        deal_string(tmpindex,n);
                    }
                if(FUN_FLAG[tmpindex] == NUM_STRNG_FUN){ 
                        deal_num_string(tmpindex,n);
                }
                if(FUN_FLAG[tmpindex] == BYTES_FUN){ 
                        deal_num_byte(tmpindex,n);
                }
    			if(FUN_FLAG[tmpindex] == ONLY2TJ){ 
                        deal_ONLY2TJ(tmpindex,n);
                }
            }
        }
    }
    
    void deal_string(int tmpindex,int n)
    { 
        if(temp_data[tmpindex * MAX_SIZE_ + n - 1] == ENDWITH && buff_data[tmpindex * MAX_SIZE_] == '\0'){ 
            memcpy(&all_data[tmpindex * MAX_SIZE_],&temp_data[tmpindex * MAX_SIZE_],n -1);
            memset(&temp_data[tmpindex * MAX_SIZE_],0,MAX_SIZE_ * sizeof(char));
            printf("%dth client %s\n",tmpindex,&all_data[tmpindex * MAX_SIZE_]);
        }else if(temp_data[tmpindex * MAX_SIZE_ + n - 1] == ENDWITH && buff_data[tmpindex * MAX_SIZE_] != '\0'){ //是上一包的
            int cindex = 0;
            while(buff_data[tmpindex * MAX_SIZE_+cindex] != '\0'){ 
                cindex++;
            }
            memcpy(&all_data[tmpindex * MAX_SIZE_],&buff_data[tmpindex * MAX_SIZE_], cindex);
            memcpy(&all_data[tmpindex * MAX_SIZE_ + cindex],&temp_data[tmpindex * MAX_SIZE_],n-1);
            printf("%s\n",&all_data[tmpindex * MAX_SIZE_]);
            memset(&temp_data[tmpindex * MAX_SIZE_],0,MAX_SIZE_ * sizeof(char));
            memset(&buff_data[tmpindex * MAX_SIZE_],0,MAX_SIZE_ * sizeof(char));
    
        }else if(temp_data[tmpindex * MAX_SIZE_ + n] == '\0'){ //不够一包
                int cindex = 0;
                while(buff_data[tmpindex * MAX_SIZE_+cindex] != '\0'){ 
                    cindex++;
                }
                if(cindex >= MAX_SIZE_){ 
                    memset(&temp_data[tmpindex * MAX_SIZE_],0,MAX_SIZE_ * sizeof(char));
                    memset(&buff_data[tmpindex * MAX_SIZE_],0,MAX_SIZE_ * sizeof(char));
                    printf("excceed max range\n");
                }
                memcpy(&buff_data[tmpindex * MAX_SIZE_ + cindex],&temp_data[tmpindex * MAX_SIZE_],n);
                memset(&temp_data[tmpindex * MAX_SIZE_],0,MAX_SIZE_ * sizeof(char));
                if(global_signal[tmpindex] == -1){ 
                    global_signal[tmpindex] = tmpindex;
                    alarm(tout_);
                }
            }else if(temp_data[tmpindex * MAX_SIZE_ + MAX_SIZE_-1] != '\0'){ //大于接受范围，丢弃
                        memset(&temp_data[tmpindex * MAX_SIZE_],0,MAX_SIZE_ * sizeof(char));
                        printf("excceed max range\n");
                    }
    }
    
    void deal_num_string(int tmpindex, int n)
    { 
        if(temp_data[tmpindex * MAX_SIZE_ + n - 1] == ENDWITH && buff_data[tmpindex * MAX_SIZE_] == '\0'){ 
            temp_data[tmpindex * MAX_SIZE_ + n - 1] = '\0';
            char tempdeal[MAX_SIZE_];
            memcpy(tempdeal,&temp_data[tmpindex * MAX_SIZE_],MAX_SIZE_);
            char *p = strtok(tempdeal,SEPERATE);
            int mycount = 0;
            while(p!=NULL){ 
                  PMAC_global[PMAC_VAR*tmpindex+mycount] = atof(p);
                  printf("%dth %lf\n",tmpindex,PMAC_global[PMAC_VAR*tmpindex+mycount]);
                  p = strtok(NULL,SEPERATE);
                  mycount++;
            }
        }else if(temp_data[tmpindex * MAX_SIZE_ + n - 1] == ENDWITH && buff_data[tmpindex * MAX_SIZE_] != '\0'){ //是上一包的
            int cindex = 0;
            while(buff_data[tmpindex * MAX_SIZE_+cindex] != '\0'){ 
                cindex++;
            }
            memcpy(&all_data[tmpindex * MAX_SIZE_],&buff_data[tmpindex * MAX_SIZE_], cindex);
            memcpy(&all_data[tmpindex * MAX_SIZE_ + cindex],&temp_data[tmpindex * MAX_SIZE_],n-1);
            char tempdeal[MAX_SIZE_];
            memcpy(tempdeal,&all_data[tmpindex * MAX_SIZE_],MAX_SIZE_);
            char *p = strtok(tempdeal,SEPERATE);
            int mycount = 0;
            while(p!=NULL){ 
                  PMAC_global[PMAC_VAR*tmpindex+mycount] = atof(p);
                  printf("%dth %lf\n",tmpindex,PMAC_global[PMAC_VAR*tmpindex+mycount]);
                  p = strtok(NULL,SEPERATE);
                  mycount++;
            }
            memset(&all_data[tmpindex * MAX_SIZE_],0,MAX_SIZE_ * sizeof(char));
            memset(&temp_data[tmpindex * MAX_SIZE_],0,MAX_SIZE_ * sizeof(char));
            memset(&buff_data[tmpindex * MAX_SIZE_],0,MAX_SIZE_ * sizeof(char));
    
        }else if(temp_data[tmpindex * MAX_SIZE_ + n] == '\0'){ //不够一包
                int cindex = 0;
                while(buff_data[tmpindex * MAX_SIZE_+cindex] != '\0'){ 
                    cindex++;
                }
                if(cindex >= MAX_SIZE_){ 
                    memset(&temp_data[tmpindex * MAX_SIZE_],0,MAX_SIZE_ * sizeof(char));
                    memset(&buff_data[tmpindex * MAX_SIZE_],0,MAX_SIZE_ * sizeof(char));
                    printf("excceed max range\n");
                }
                if(global_signal[tmpindex] == -1){ 
                    global_signal[tmpindex] = tmpindex;
                    alarm(tout_);
                }
                memcpy(&buff_data[tmpindex * MAX_SIZE_ + cindex],&temp_data[tmpindex * MAX_SIZE_],n);
                memset(&temp_data[tmpindex * MAX_SIZE_],0,MAX_SIZE_ * sizeof(char));
            }else if(temp_data[tmpindex * MAX_SIZE_ + MAX_SIZE_-1] != '\0'){ //大于接受范围，丢弃
                        memset(&temp_data[tmpindex * MAX_SIZE_],0,MAX_SIZE_ * sizeof(char));
                        printf("excceed max range\n");
                    }
    }
    
    void deal_num_byte(int tmpindex, int n)
    { 
        if(temp_data[tmpindex * MAX_SIZE_ + n - 1] == ENDWITH && buff_data[tmpindex * MAX_SIZE_] == '\0'){ 
            int i = 0;
            for(;i < (int)((n-1)/(sizeof(double)));i++){ 
                PMAC_global[PMAC_VAR * tmpindex+i] = *(double *)(&temp_data[tmpindex * MAX_SIZE_]+i*sizeof(double));
            }
            memset(&temp_data[tmpindex * MAX_SIZE_],0,MAX_SIZE_*sizeof(char));
        }else if(temp_data[tmpindex * MAX_SIZE_ + n - 1] == ENDWITH && buff_data[tmpindex * MAX_SIZE_] != '\0'){ //是上一包的
            int cindex = 0;
            while(buff_data[tmpindex * MAX_SIZE_+cindex] != '\0'){ 
                cindex++;
            }
            memcpy(&all_data[tmpindex * MAX_SIZE_],&buff_data[tmpindex * MAX_SIZE_], cindex);
            memcpy(&all_data[tmpindex * MAX_SIZE_ + cindex],&temp_data[tmpindex * MAX_SIZE_],n-1);
            int i = 0;
            for(;i < (int)((n-1)/(sizeof(double)));i++){ 
                PMAC_global[PMAC_VAR * tmpindex+i] = *(double *)(&temp_data[tmpindex * MAX_SIZE_]+i*sizeof(double));
            }
            memset(&all_data[tmpindex * MAX_SIZE_],0,MAX_SIZE_ * sizeof(char));
            memset(&temp_data[tmpindex * MAX_SIZE_],0,MAX_SIZE_ * sizeof(char));
            memset(&buff_data[tmpindex * MAX_SIZE_],0,MAX_SIZE_ * sizeof(char));
    
        }else if(temp_data[tmpindex * MAX_SIZE_ + n - 1] == '\0'){ //不够一包
                int cindex = 0;
                while(buff_data[tmpindex * MAX_SIZE_+cindex] != '\0'){ 
                    cindex++;
                }
                if(cindex >= MAX_SIZE_){ 
                    memset(&temp_data[tmpindex * MAX_SIZE_],0,MAX_SIZE_ * sizeof(char));
                    memset(&buff_data[tmpindex * MAX_SIZE_],0,MAX_SIZE_ * sizeof(char));
                    printf("excceed max range\n");
                }
                if(global_signal[tmpindex] == -1){ 
                    global_signal[tmpindex] = tmpindex;
                    alarm(tout_);
                }
                memcpy(&buff_data[tmpindex * MAX_SIZE_ + cindex],&temp_data[tmpindex * MAX_SIZE_],n);
                memset(&temp_data[tmpindex * MAX_SIZE_],0,MAX_SIZE_ * sizeof(char));
            }else if(temp_data[tmpindex * MAX_SIZE_ + MAX_SIZE_-1] != '\0'){ //大于接受范围，丢弃
                        memset(&temp_data[tmpindex * MAX_SIZE_],0,MAX_SIZE_ * sizeof(char));
                        printf("excceed max range\n");
                    }
    }
    
    void deal_ONLY2TJ(int tmpindex, int n)
    { 
    	if(temp_data[tmpindex * MAX_SIZE_ + n - 1] == ENDWITH)
    	{ 
    		temp_data[tmpindex * MAX_SIZE_ + n - 1] = '\0';
            char tempdeal[MAX_SIZE_];
            memcpy(tempdeal,&temp_data[tmpindex * MAX_SIZE_],MAX_SIZE_);
    		//处理收到的字符串，放入全局变量中
    		recv_tj(tempdeal);
    	}
    }
    
    void deal_send()
    { 
    
        int n = 0;
        for(;n<=max_index;n++){ 
            if(close_client[n] == 1 && FD_ISSET(all_tcp_client[n],&all_fds))
            { 
                close(all_tcp_client[n]);
                FD_CLR(all_tcp_client[n],&all_fds);
                if(all_tcp_client[n]==exmaxfd)exmaxfd--;
                all_tcp_client[n]=-1;
    			SetGlobalArrayVar(c_client,n,-1);
                printf("%dth client voluntarily closed\n",n);
                continue;
            }
            if(FD_ISSET(all_tcp_client[n],&all_fds)){ 
                if(FUN_FLAG[n] == STRING_FUN || FUN_FLAG[n] == ONLY2TJ){ 
                    if(all_send_data[n * MAX_SIZE_] == '\0'){ 
                        continue;
                    }
                    char will_send[100];
                    memset(will_send,0,sizeof will_send);
                    int tmpcount = 0;
                    while(all_send_data[n * MAX_SIZE_ + tmpcount] != ENDWITH){ 
                        will_send[tmpcount] =  all_send_data[n * MAX_SIZE_ + tmpcount];
                        tmpcount++;
                    }
                    send(all_tcp_client[n],will_send,tmpcount,0);
                    memset(&all_send_data[n * MAX_SIZE_],0,MAX_SIZE_);
                }else if(FUN_FLAG[n] == NUM_STRNG_FUN){ 
                    if(all_send_num[n * PMAC_VAR] == 0){ 
                        continue;
                    }
                    char will_send[100];
                    memset(will_send,0,sizeof will_send);
                    int tmpcount = 0;
                    while(all_send_num[n * PMAC_VAR + tmpcount] != 0){ 
                        char tmpbuf[12];
                        memset(tmpbuf,0,sizeof tmpbuf);
                        gcvt(all_send_num[n * PMAC_VAR + tmpcount],8,tmpbuf);
                        strcat(tmpbuf,SEPERATE);
                        strcat(will_send,tmpbuf);
                        tmpcount++;
                    }
                    will_send[strlen(will_send)-1] = ENDWITH;
                    send(all_tcp_client[n],will_send,strlen(will_send),0);
                    memset(&all_send_num[n * PMAC_VAR],0,PMAC_VAR*sizeof(double));
                }else if(FUN_FLAG[n] == BYTES_FUN){ 
                    if(all_send_num[n * PMAC_VAR] == 0){ 
                        continue;
                    }
                    char will_send[100];
                    memset(will_send,0,sizeof will_send);
                    int tmpcount = 0;
                    while(all_send_num[n * PMAC_VAR + tmpcount] != 0){ 
                        tmpcount++;
                    }
                    memcpy(will_send,&all_send_num[n * PMAC_VAR],tmpcount*sizeof(double));
                    will_send[tmpcount*sizeof(double)] = ENDWITH;
                    send(all_tcp_client[n],will_send,tmpcount*sizeof(double)+1,0);
                    memset(&all_send_num[n * PMAC_VAR],0,PMAC_VAR*sizeof(double));
                }
    
            }
        }
    }
    
    void alarm_tiout()//接收数据延时错误处理
    { 
        int n = 0;
        for (;n<MAX_CLIENT;n++){ 
            if(global_signal[n] != -1){ 
                if(buff_data[global_signal[n] * MAX_SIZE_] != '\0'){ 
                    memset(&buff_data[global_signal[n] * MAX_SIZE_],0,MAX_SIZE_ * sizeof(char));
                    memset(&all_data[global_signal[n] * MAX_SIZE_],0,MAX_SIZE_ * sizeof(char));
                    global_signal[n] = -1;
                }
            }
        }
    }
    
    void set_var()
    { 
    	double var_temp[4];
    	int i;
    	for(i=0;i<4;i++)
    	{ 
    		var_temp[i]=GetGlobalArrayVar(c_client,i);
    		close_client[i]=(int)var_temp[i];
    	}
    	
    	
    	double fun_temp[4];
    	for(i=0;i<4;i++)
    	{ 
    		fun_temp[i]=GetGlobalArrayVar(fun_flag,i);
    		FUN_FLAG[i]=(int)fun_temp[i];
    	}
    }
    
    
    
    int main(void)
    { 	
    	InitLibrary();
    	while(1)
    	{ 
    		init_external_client();
    		deal_data();
    	}
    	CloseLibrary();	
    	return 0;
    }