4 #include <sys/socket.h>
6 #include <netinet/in.h>
11 #include <sys/types.h>
22 #include <qstringlist.h>
25 #include <libconfig.h>
26 #include "AppConfiguration.h"
28 #define REMOTE_PATH "REMOTE"
32 #define CODEPORT1 3800
34 #define FILE_BUFFER_SIZE 2048
38 // ************** Interpreter slot *******************
55 // ******************** Network slot ********************
60 bool connected,code_transmit;
77 for(i=0;i<5;i++) aliases[i]=-1;
86 //********************** NET Module ****************************
91 int kernel_sock,listen_sock;
92 bool all_connected,local_mode;
93 int to_connect,MyNode;
97 QList<INTlink> Interpreters; // List of the Interpeter slots
98 QList<NETlink> Links; // List of the Network slots
102 void load_config(char*);
103 void write_at_console(char*);
104 void send_to_kernel(MESSAGE*);
105 void sock_reopen(NETlink*);
106 void send_connect_info(NETlink*);
107 void send_accept_info(NETlink*);
108 void send_to_node(NETlink*,MESSAGE*);
109 void send_to_int(MESSAGE*);
110 void send_code_ack(NETlink*);
111 void send_to_all(MESSAGE *);
113 NETlink *findNETlink(int node);
114 INTlink *findINTlink(int id);
115 void transmit_file(int ton, char *fname, int fromINT);
116 void propagate_msg(MESSAGE *msg);
117 void check_node(int,int);
120 void exit_sequence();
121 void disconnect_seq();
122 void connect_seq(char*);
123 void accept_connection();
125 void remote_messages();
127 void get_message(NETlink*);
130 void doitall(); // 2010
134 NETMOD::NETMOD(char *kernel_name)
137 struct sockaddr_in svr;
138 struct sockaddr_un svr1;
144 Interpreters.clear();
146 bzero(&svr, sizeof(svr));
147 listen_sock = socket(AF_INET, SOCK_STREAM, 0);
148 svr.sin_family = AF_INET;
149 svr.sin_addr.s_addr = INADDR_ANY;
150 svr.sin_port = htons(LOGPORT);
151 bind(listen_sock, (struct sockaddr*)&svr, sizeof(svr));
152 listen(listen_sock,5);
153 fcntl(listen_sock, F_SETFL,O_NONBLOCK | fcntl(listen_sock, F_GETFL,0));
157 load_config("vlp.cfg");
159 kernel_sock = socket(AF_UNIX,SOCK_STREAM,0);
160 bzero(&svr1,sizeof(svr1));
161 svr1.sun_family = AF_UNIX;
162 strcpy(svr1.sun_path,kernel_name);
163 strcpy(kername,kernel_name);
164 len = strlen(svr1.sun_path)+sizeof(svr1.sun_family);
165 i = connect(kernel_sock,(struct sockaddr*)&svr1,len);
167 fcntl(kernel_sock,F_SETFL, O_NONBLOCK|fcntl(kernel_sock,F_GETFL,0));
169 setsockopt(kernel_sock,IPPROTO_TCP,TCP_NODELAY,(char*)&on,sizeof(on));
170 m.msg_type = MSG_NET;
171 m.param.pword[0] = NET_NODE;
172 m.param.pword[1] = MyNode;
175 // if (regme) regme_sequence();
178 write_at_console("Connecting remote VLPs...");
179 while (!all_connected) check_links();
181 sprintf(s,"Local node number %d",MyNode);
185 // ##################### Load configuration ##########################
187 void NETMOD::load_config(char *fname)
197 /* Hack for checking if file exists without using external libs.*/
198 FILE * file = fopen(fname, "r");
200 fprintf(stderr, "Error: Cannot load configuration file %s!\n", fname);
201 write_at_console("Cannot load configuration file!");
204 /* File exists, so file has been locked. Release it. */
207 /* Read the file. If there is an error, report it and exit. */
208 if(!config_read_file(&cfg, fname))
210 AppConfiguration::error(&cfg);
211 config_destroy(&cfg);
212 exit(3);/* from original code. */
215 if(config_lookup_int(&cfg, "node_number", &MyNode))
218 write_at_console("Node number must be specified");
219 config_destroy(&cfg);
225 AppConfiguration::error(&cfg);
226 config_destroy(&cfg);
230 if(config_lookup_string(&cfg, "host", &str)) {
232 pomlink = new NETlink;
233 strcpy(pomlink->addr, str);
234 pomlink->connected = FALSE;
235 pomlink->sock = socket(AF_INET, SOCK_STREAM, 0);
236 fcntl(pomlink->sock, F_SETFL,O_NONBLOCK | fcntl(pomlink->sock,F_GETFL,0));
238 setsockopt(pomlink->sock,IPPROTO_TCP,TCP_NODELAY,(char*)&on,sizeof(on));
239 Links.append(pomlink);
243 AppConfiguration::error(&cfg);
246 config_destroy(&cfg);
248 if (k==0) all_connected=TRUE;
253 void NETMOD::write_at_console(char *s)
257 msg.msg_type = MSG_NET;
258 msg.param.pword[0] = NET_CSWRITELN;
259 strcpy(msg.param.pstr,s);
260 send_to_kernel(&msg);
263 void NETMOD::send_to_kernel(MESSAGE *msg)
265 write(kernel_sock,msg,sizeof(MESSAGE));
268 void NETMOD::send_to_node(NETlink *lnk, MESSAGE *msg)
270 msg->msg_type = MSG_NET;
273 write(lnk->sock,msg,sizeof(MESSAGE));
276 void NETMOD::send_to_int(MESSAGE *msg)
280 pomlink = findINTlink(msg->param.pword[5]);
281 if (pomlink!=NULL) write(pomlink->sock,msg,sizeof(MESSAGE));
286 void NETMOD::accept_connection()
290 struct sockaddr_in svr;
292 struct timeval tout = {0,0};
295 FD_ZERO(&rset);FD_ZERO(&wset);
296 FD_SET(listen_sock,&rset);
298 if (select(listen_sock+1,&rset,&wset,0,(struct timeval *)&tout)>0)
299 if (FD_ISSET(listen_sock,&rset))
302 /* accept connection on listen socket */
304 bzero(&svr, sizeof(svr));
305 nsock = accept(listen_sock, (struct sockaddr*)&svr, &sz);
310 /* i<0 someone wants to connect us */
312 pomlink = new NETlink;
313 strcpy(pomlink->addr,inet_ntoa(svr.sin_addr));
314 pomlink->sock = nsock;
315 pomlink->connected = TRUE;
316 fcntl(pomlink->sock, F_SETFL,O_NONBLOCK | fcntl(pomlink->sock,
319 setsockopt(pomlink->sock,IPPROTO_TCP,TCP_NODELAY,(char*)&on,sizeof(on));
320 Links.append(pomlink);
326 void NETMOD::check_node(int n, int sc)
331 m.msg_type = MSG_NET;
332 m.param.pword[0] = NET_NODE_EXIST;
334 pomlink = Links.first();
335 m.param.pword[1] = 0;
336 while (pomlink!=NULL)
338 if ( pomlink->node_number==n )
340 m.param.pword[1] = 1;
341 strcpy(m.param.pstr,pomlink->addr);
344 pomlink = Links.next();
346 write(sc,&m,sizeof(MESSAGE));
350 // ************* Internal message from kernel or INT *******************
352 void NETMOD::get_internal()
357 fd_set readset,writeset;
358 struct timeval tout={0,0};
360 struct sockaddr_un svr;
364 FD_ZERO(&readset);FD_ZERO(&writeset);
365 FD_SET(kernel_sock,&readset);
368 pomlink = Interpreters.first();
369 while (pomlink!=NULL)
371 FD_SET(pomlink->sock,&readset);
372 if (nrset<pomlink->sock) nrset=pomlink->sock;
373 pomlink=Interpreters.next();
376 if (select(nrset+1,&readset,&writeset,0,(struct timeval *)&tout)>0)
379 /* Check request sockets */
380 pomlink = Interpreters.first();
381 while (pomlink!=NULL)
383 if (FD_ISSET(pomlink->sock,&readset))
385 nr = read(pomlink->sock,&msg,sizeof(MESSAGE));
388 if (msg.msg_type == MSG_NET)
389 switch(msg.param.pword[0])
391 case NET_PROPAGATE:propagate_msg(&msg);break;
392 case NET_NODE_EXIST:check_node(msg.param.pword[1],pomlink->sock);break;
393 case NET_GET_INFO: conn_info(pomlink->sock);break;
394 case NET_NODES_NUM: msg.param.pword[0]=NET_NODES_NUM_RESPONSE;
395 msg.param.pword[1]=Links.count();
396 write(pomlink->sock,&msg,sizeof(MESSAGE));
401 pomlink=Interpreters.next();
404 /* Check internal socket */
405 if (FD_ISSET(kernel_sock,&readset))
407 nr = read(kernel_sock, &msg, sizeof(MESSAGE));
410 if (msg.msg_type == MSG_NET)
412 switch(msg.param.pword[0])
414 case NET_TRANSMIT_CODE:
415 transmit_file(msg.param.pword[2],msg.param.pstr,msg.param.pword[1]);
417 case NET_EXIT: { disconnect_seq();exit_sequence();}
419 case NET_GET_INFO: conn_info(kernel_sock);break;
420 case NET_PROPAGATE:propagate_msg(&msg);break;
421 case NET_DISCONNECT:disconnect_seq();
423 case NET_NODE_EXIST: check_node(msg.param.pword[1],kernel_sock);break;
424 case NET_CONNECT_TO: connect_seq(msg.param.pstr);
429 if (msg.msg_type == MSG_VLP)
430 switch(msg.param.pword[0])
434 pomlink = new INTlink;
435 pomlink->sock = socket(AF_UNIX,SOCK_STREAM,0);
436 bzero(&svr,sizeof(svr));
437 svr.sun_family = AF_UNIX;
438 strcpy(svr.sun_path,msg.param.pstr);
439 si = strlen(svr.sun_path)+sizeof(svr.sun_family);
440 sj = connect(pomlink->sock,(struct sockaddr*)&svr,si);
442 fcntl(pomlink->sock,F_SETFL, O_NONBLOCK|
443 fcntl(pomlink->sock,F_GETFL,0));
445 setsockopt(pomlink->sock,IPPROTO_TCP,TCP_NODELAY,(char*)&on,sizeof(on));
446 pomlink->ID = msg.param.pword[1];
447 pomlink->connected=TRUE;
448 Interpreters.append(pomlink);
451 case VLP_INTERPRETER_DOWN:
453 pomlink = findINTlink(msg.param.pword[1]);
456 close(pomlink->sock);
457 Interpreters.remove(pomlink);
470 void NETMOD::get_message(NETlink *lnk)
475 int rdbt,rd,sz,j,psock;
476 struct sockaddr_in svr;
477 unsigned char buffer[FILE_BUFFER_SIZE];
482 nr = read(lnk->sock,&msg, sizeof(MESSAGE));
486 if (msg.msg_type == MSG_NET)
488 switch(msg.param.pword[0])
492 lnk->code_transmit = TRUE;
493 sprintf(pomstr,"%s/%s",REMOTE_PATH,msg.param.pstr);
494 strcat(pomstr,".ccd");
495 lnk->CodeFile = fopen(pomstr,"wb");
496 if ( lnk->CodeFile == NULL) { write_at_console("Cannot open file\n");
497 lnk->code_transmit=FALSE;}
498 lnk->CodeSize=msg.param.pword[1];
499 psock = socket(AF_INET, SOCK_STREAM, 0);
500 bzero(&svr, sizeof(svr));
501 svr.sin_family = AF_INET;
502 svr.sin_port = htons(CODEPORT);
503 svr.sin_addr.s_addr = inet_addr(lnk->addr);
504 j = connect(psock, (struct sockaddr*)&svr, sizeof(svr));
507 //fcntl(psock, F_SETFL,O_NONBLOCK | fcntl(psock, F_GETFL,0));
509 while (sz<lnk->CodeSize)
511 rd = read(psock,&buffer,sizeof(buffer));
512 rdbt = fwrite(&buffer,sizeof(unsigned char),rd,lnk->CodeFile);
516 fclose(lnk->CodeFile);
523 lnk->code_transmit = TRUE;
524 sprintf(pomstr,"%s/%s",REMOTE_PATH,msg.param.pstr);
525 strcat(pomstr,".pcd");
526 lnk->CodeFile = fopen(pomstr,"wb");
527 if ( lnk->CodeFile == NULL) { write_at_console("Cannot open file\n");
528 lnk->code_transmit=FALSE;}
529 lnk->CodeSize=msg.param.pword[1];
530 psock = socket(AF_INET, SOCK_STREAM, 0);
531 bzero(&svr, sizeof(svr));
532 svr.sin_family = AF_INET;
533 svr.sin_port = htons(CODEPORT1);
534 svr.sin_addr.s_addr = inet_addr(lnk->addr);
535 j = connect(psock, (struct sockaddr*)&svr, sizeof(svr));
538 //fcntl(psock, F_SETFL,O_NONBLOCK | fcntl(psock, F_GETFL,0));
540 while (sz<lnk->CodeSize)
542 rd = read(psock,&proto,sizeof(proto));
543 rdbt = fwrite(&proto,sizeof(unsigned char),rd,lnk->CodeFile);
547 fclose(lnk->CodeFile);
554 sprintf(pomstr,"Node: %d Addr: %s",msg.param.pword[1],
556 lnk->node_number = msg.param.pword[1];
557 write_at_console(pomstr);
558 send_accept_info(lnk);
562 sprintf(pomstr,"Node: %d Addr: %s",msg.param.pword[1],
564 lnk->node_number = msg.param.pword[1];
565 write_at_console(pomstr);
569 sprintf(pomstr,"Node: %d disconnected",msg.param.pword[1]);
570 write_at_console(pomstr);
577 if (msg.param.pword[1] == MSG_VLP) send_to_kernel(&msg);
578 else if (msg.param.pword[1] == MSG_INT) send_to_int(&msg);
591 void NETMOD::remote_messages()
595 struct timeval tout={0,0};
598 FD_ZERO(&rset);FD_ZERO(&wset);
601 pomlink = Links.first();
602 while (pomlink!=NULL)
604 if (pomlink->connected)
606 FD_SET(pomlink->sock,&rset);
607 if (max<pomlink->sock) max=pomlink->sock;
609 pomlink=Links.next();
612 if (select(max+1,&rset,&wset,0,(struct timeval *)&tout)>0)
614 pomlink=Links.first();
615 while (pomlink!=NULL)
617 if (FD_ISSET(pomlink->sock,&rset)) get_message(pomlink);
618 pomlink=Links.next();
625 /****************************** 2010 ********************************************/
626 void NETMOD::doitall() {
628 int nsock,max=0,on, nr, si, sj;
629 struct sockaddr_in svr;
633 struct sockaddr_un svr2;
638 FD_SET(listen_sock,&rset);
640 FD_SET(kernel_sock,&rset);
641 if (max<kernel_sock) { max=kernel_sock;}
642 pomlink2 = Interpreters.first();
643 while (pomlink2!=NULL)
645 FD_SET(pomlink2->sock,&rset);
646 if (max<pomlink2->sock) max=pomlink2->sock;
647 pomlink2=Interpreters.next();
649 pomlink = Links.first();
650 while (pomlink!=NULL)
652 if (pomlink->connected)
654 FD_SET(pomlink->sock,&rset);
655 if (max<pomlink->sock) max=pomlink->sock;
657 pomlink=Links.next();
661 if (select(max+1,&rset,0,0,NULL) > 0) {
663 if (FD_ISSET(listen_sock,&rset))
665 /* accept connection on listen socket */
667 bzero(&svr, sizeof(svr));
668 nsock = accept(listen_sock, (struct sockaddr*)&svr, &sz);
671 pomlink = new NETlink;
672 strcpy(pomlink->addr,inet_ntoa(svr.sin_addr));
673 pomlink->sock = nsock;
674 pomlink->connected = TRUE;
675 fcntl(pomlink->sock, F_SETFL,O_NONBLOCK | fcntl(pomlink->sock,F_GETFL,0));
677 setsockopt(pomlink->sock,IPPROTO_TCP,TCP_NODELAY,(char*)&on,sizeof(on));
678 Links.append(pomlink);
682 // get internal message
683 /* Check request sockets */
684 pomlink2 = Interpreters.first();
685 while (pomlink2!=NULL)
687 if (FD_ISSET(pomlink2->sock,&rset))
689 nr = read(pomlink2->sock,&msg,sizeof(MESSAGE));
692 if (msg.msg_type == MSG_NET)
693 switch(msg.param.pword[0])
695 case NET_PROPAGATE:propagate_msg(&msg); break;
696 case NET_NODE_EXIST:check_node(msg.param.pword[1],pomlink2->sock);break;
697 case NET_GET_INFO: conn_info(pomlink2->sock);break;
698 case NET_NODES_NUM: msg.param.pword[0]=NET_NODES_NUM_RESPONSE;
699 msg.param.pword[1]=Links.count();
700 write(pomlink2->sock,&msg,sizeof(MESSAGE));
705 pomlink2=Interpreters.next();
707 /* Check internal socket */
708 if (FD_ISSET(kernel_sock,&rset))
710 nr = read(kernel_sock, &msg, sizeof(MESSAGE));
713 if (msg.msg_type == MSG_NET)
715 switch(msg.param.pword[0])
717 case NET_TRANSMIT_CODE:
719 transmit_file(msg.param.pword[2],msg.param.pstr,msg.param.pword[1]);
722 case NET_EXIT: { disconnect_seq();exit_sequence();}
724 case NET_GET_INFO: conn_info(kernel_sock);break;
725 case NET_PROPAGATE:propagate_msg(&msg);break;
726 case NET_DISCONNECT:disconnect_seq();
728 case NET_NODE_EXIST: check_node(msg.param.pword[1],kernel_sock);break;
729 case NET_CONNECT_TO: connect_seq(msg.param.pstr);
732 if (msg.msg_type == MSG_VLP)
733 switch(msg.param.pword[0])
738 pomlink2 = new INTlink;
739 pomlink2->sock = socket(AF_UNIX,SOCK_STREAM,0);
740 bzero(&svr2,sizeof(svr2));
741 svr2.sun_family = AF_UNIX;
742 strcpy(svr2.sun_path,msg.param.pstr);
743 si = strlen(svr2.sun_path)+sizeof(svr2.sun_family);
744 sj = connect(pomlink2->sock,(struct sockaddr*)&svr2,si);
746 fcntl(pomlink2->sock,F_SETFL, O_NONBLOCK|fcntl(pomlink2->sock,F_GETFL,0));
748 setsockopt(pomlink2->sock,IPPROTO_TCP,TCP_NODELAY,(char*)&on,sizeof(on));
749 pomlink2->ID = msg.param.pword[1];
750 pomlink2->connected=TRUE;
751 Interpreters.append(pomlink2);
754 case VLP_INTERPRETER_DOWN:
757 pomlink2 = findINTlink(msg.param.pword[1]);
760 close(pomlink2->sock);
761 Interpreters.remove(pomlink2);
768 // get remote message
770 pomlink=Links.first();
771 while (pomlink!=NULL)
773 if (FD_ISSET(pomlink->sock,&rset)) get_message(pomlink);
774 pomlink=Links.next();
780 /****************************** END 2010 ********************************************/
784 void NETMOD::propagate_msg(MESSAGE *msg)
789 pomlink = findNETlink(msg->param.pword[4]);
790 if ((pomlink!=NULL)&&(pomlink->connected))
791 send_to_node(pomlink,msg);
793 if (msg->param.pword[1]==MSG_INT)
799 sprintf(ss,"Not connected to Node %d",msg->param.pword[4]);
800 write_at_console(ss);
807 void NETMOD::connect_seq(char *a)
810 struct sockaddr_in svr;
817 if (strcmp(pom->addr,a)==0) return;
822 pom->connected = FALSE;
823 pom->sock = socket(AF_INET, SOCK_STREAM, 0);
824 bzero(&svr, sizeof(svr));
825 svr.sin_family = AF_INET;
826 svr.sin_port = htons(LOGPORT);
827 svr.sin_addr.s_addr = inet_addr(pom->addr);
828 j = connect(pom->sock, (struct sockaddr*)&svr, sizeof(svr));
830 { pom->connected = TRUE;
831 fcntl(pom->sock, F_SETFL,O_NONBLOCK | fcntl(pom->sock,
834 setsockopt(pom->sock,IPPROTO_TCP,TCP_NODELAY,(char*)&on,sizeof(on));
835 send_connect_info(pom);
838 else write_at_console("Connection failed");
841 void NETMOD::check_links()
845 struct sockaddr_in svr;
848 /* connect to all other nodes */
851 pomlink=Links.first();
852 while (pomlink!=NULL)
854 if ( !(pomlink->connected) )
856 bzero(&svr, sizeof(svr));
857 svr.sin_family = AF_INET;
858 svr.sin_port = htons(LOGPORT);
859 svr.sin_addr.s_addr = inet_addr(pomlink->addr);
861 j = connect(pomlink->sock, (struct sockaddr*)&svr, sizeof(svr));
863 { pomlink->connected = TRUE;
864 fcntl(pomlink->sock, F_SETFL,O_NONBLOCK | fcntl(pomlink->sock,
866 send_connect_info(pomlink);
869 if (errno == ECONNREFUSED)
870 sock_reopen(pomlink);
872 pomlink=Links.next();
877 pomlink=Links.first();
880 if (pomlink->connected==FALSE) {all_connected=FALSE;break;}
881 pomlink=Links.next();
886 void NETMOD::sock_reopen(NETlink *lnk)
891 lnk->sock = socket(AF_INET, SOCK_STREAM, 0);
892 fcntl(lnk->sock, F_SETFL,O_NONBLOCK | fcntl(lnk->sock,
894 setsockopt(lnk->sock,IPPROTO_TCP,TCP_NODELAY,(char*)&on,sizeof(on));
898 // **************** Acknowledges *************************
900 void NETMOD::send_connect_info(NETlink *lnk)
904 m.param.pword[0] = NET_CONNECT;
905 m.param.pword[1] = MyNode;
906 m.msg_type = MSG_NET;
909 write(lnk->sock,&m,sizeof(MESSAGE));
912 void NETMOD::send_accept_info(NETlink *lnk)
916 m.param.pword[0] = NET_ACCEPT;
917 m.param.pword[1] = MyNode;
918 m.msg_type = MSG_NET;
921 write(lnk->sock,&m,sizeof(MESSAGE));
924 void NETMOD::send_code_ack(NETlink *lnk)
928 m.param.pword[0] = NET_CODESTREAM_OK;
929 m.msg_type = MSG_NET;
932 write(lnk->sock,&m,sizeof(MESSAGE));
936 void NETMOD::send_to_all(MESSAGE *msg)
939 pomlink=Links.first();
940 while (pomlink!=NULL)
942 write(pomlink->sock,msg,sizeof(MESSAGE));
943 pomlink=Links.next();
954 /*accept_connection();
956 remote_messages(); */
962 void NETMOD::exit_sequence()
966 ::close(kernel_sock);
967 ::close(listen_sock);
969 pomlink = Links.first();
970 while (pomlink!=NULL)
972 ::close(pomlink->sock);
973 pomlink=Links.next();
978 void NETMOD::disconnect_seq()
983 bzero(&m,sizeof(MESSAGE));
984 m.msg_type = MSG_NET;
985 m.param.pword[0] = NET_DISCONNECT;
986 m.param.pword[1] = MyNode;
1003 NETlink *NETMOD::findNETlink(int node)
1006 pomlink=Links.first();
1007 while(pomlink!=NULL)
1009 if (pomlink->node_number == node) return(pomlink);
1010 pomlink=Links.next();
1015 INTlink *NETMOD::findINTlink(int id)
1018 pomlink=Interpreters.first();
1019 while(pomlink!=NULL)
1021 if (pomlink->ID == id) return(pomlink);
1022 pomlink=Interpreters.next();
1028 /* ---------------- Sending code to a remote node -------------- */
1030 void NETMOD::transmit_file(int ton, char *fname, int fromINT)
1036 unsigned char buffer[FILE_BUFFER_SIZE];
1041 struct sockaddr_in svr;
1045 // **************** CCD FILE
1052 fseek(f,0,SEEK_END);
1053 msg.param.pword[1] = ftell(f);
1057 strcpy(b,rindex(fname,'/'));
1058 for(i=0;i<strlen(b);i++)
1060 msg.param.pword[0] = NET_CCD_START;
1061 strcpy(msg.param.pstr,b);
1063 outlink = findNETlink(ton);
1064 if (outlink==NULL) exit(1);
1065 bzero(&svr,sizeof(svr));
1066 sock = socket(AF_INET,SOCK_STREAM,0);
1067 svr.sin_family = AF_INET;
1068 svr.sin_addr.s_addr = INADDR_ANY;
1069 svr.sin_port = htons(CODEPORT);
1070 bind(sock, (struct sockaddr*)&svr, sizeof(svr));
1072 send_to_node(outlink, &msg);
1074 FD_ZERO(&rset);FD_ZERO(&wset);
1076 if (select(sock+1,&rset,&wset,0,0))
1077 if (FD_ISSET(sock,&rset))
1078 tsock = accept(sock, (struct sockaddr*)&svr,&sz );
1084 i = fread(&buffer,1,sizeof(buffer),f);
1085 write(tsock,&buffer,i);
1086 FD_ZERO(&rset);FD_ZERO(&wset);
1087 FD_SET(tsock,&wset);
1088 select(tsock+1,&rset,&wset,0,0);
1096 sprintf(b,"Cannot open file to send %s\n",fname);
1097 write_at_console(b);
1101 // *************** PCD FILE
1108 fseek(f,0,SEEK_END);
1109 msg.param.pword[1] = ftell(f);
1113 strcpy(b,rindex(fname,'/'));
1114 for(i=0;i<strlen(b);i++)
1116 msg.param.pword[0] = NET_PCD_START;
1117 strcpy(msg.param.pstr,b);
1119 outlink = findNETlink(ton);
1120 if (outlink==NULL) exit(1);
1121 bzero(&svr,sizeof(svr));
1122 sock = socket(AF_INET,SOCK_STREAM,0);
1123 svr.sin_family = AF_INET;
1124 svr.sin_addr.s_addr = INADDR_ANY;
1125 svr.sin_port = htons(CODEPORT1);
1126 bind(sock, (struct sockaddr*)&svr, sizeof(svr));
1128 send_to_node(outlink, &msg);
1130 FD_ZERO(&rset);FD_ZERO(&wset);
1132 if (select(sock+1,&rset,&wset,0,0))
1133 if (FD_ISSET(sock,&rset))
1134 tsock = accept(sock, (struct sockaddr*)&svr,&sz );
1140 i = fread(&proto,1,sizeof(proto),f);
1141 write(tsock,&proto,i);
1142 FD_ZERO(&rset);FD_ZERO(&wset);
1143 FD_SET(tsock,&wset);
1144 select(tsock+1,&rset,&wset,0,0);
1152 sprintf(b,"Cannot open file to send %s\n",fname);
1153 write_at_console(b);
1157 msg.msg_type = MSG_NET;
1158 msg.param.pword[0] = NET_TRANSMITTED;
1159 msg.param.pword[1] = fromINT;
1160 send_to_kernel(&msg);
1167 void NETMOD::conn_info(int sk)
1174 m.msg_type = MSG_NET;
1175 m.param.pword[0] = NET_INFO;
1176 strcpy(m.param.pstr,"");
1180 sprintf(poms,"%d=%s;",pom->node_number,pom->addr);
1181 strcat(m.param.pstr,poms);
1185 m.param.pword[1]=12;
1186 write(sk,&m,sizeof(MESSAGE));
1194 write(sk,&m,sizeof(MESSAGE));
1196 m.msg_type = MSG_NET;
1197 m.param.pword[0] = NET_INFO_END;
1198 write(sk,&m,sizeof(MESSAGE));
1201 int main(int argc,char **argv)
1203 NETMOD netter(argv[1]);