4 #include <sys/socket.h>
6 #include <netinet/in.h>
11 #include <sys/types.h>
22 #include <qstringlist.h>
25 #include <libconfig.h>
27 #define REMOTE_PATH "REMOTE"
31 #define CODEPORT1 3800
33 #define FILE_BUFFER_SIZE 2048
37 // ************** Interpreter slot *******************
54 // ******************** Network slot ********************
59 bool connected,code_transmit;
76 for(i=0;i<5;i++) aliases[i]=-1;
85 //********************** NET Module ****************************
90 int kernel_sock,listen_sock;
91 bool all_connected,local_mode;
92 int to_connect,MyNode;
96 QList<INTlink> Interpreters; // List of the Interpeter slots
97 QList<NETlink> Links; // List of the Network slots
101 void load_config(char*);
102 void write_at_console(char*);
103 void send_to_kernel(MESSAGE*);
104 void sock_reopen(NETlink*);
105 void send_connect_info(NETlink*);
106 void send_accept_info(NETlink*);
107 void send_to_node(NETlink*,MESSAGE*);
108 void send_to_int(MESSAGE*);
109 void send_code_ack(NETlink*);
110 void send_to_all(MESSAGE *);
112 NETlink *findNETlink(int node);
113 INTlink *findINTlink(int id);
114 void transmit_file(int ton, char *fname, int fromINT);
115 void propagate_msg(MESSAGE *msg);
116 void check_node(int,int);
119 void exit_sequence();
120 void disconnect_seq();
121 void connect_seq(char*);
122 void accept_connection();
124 void remote_messages();
126 void get_message(NETlink*);
129 void doitall(); // 2010
133 NETMOD::NETMOD(char *kernel_name)
136 struct sockaddr_in svr;
137 struct sockaddr_un svr1;
143 Interpreters.clear();
145 bzero(&svr, sizeof(svr));
146 listen_sock = socket(AF_INET, SOCK_STREAM, 0);
147 svr.sin_family = AF_INET;
148 svr.sin_addr.s_addr = INADDR_ANY;
149 svr.sin_port = htons(LOGPORT);
150 bind(listen_sock, (struct sockaddr*)&svr, sizeof(svr));
151 listen(listen_sock,5);
152 fcntl(listen_sock, F_SETFL,O_NONBLOCK | fcntl(listen_sock, F_GETFL,0));
156 load_config("vlp.cfg");
158 kernel_sock = socket(AF_UNIX,SOCK_STREAM,0);
159 bzero(&svr1,sizeof(svr1));
160 svr1.sun_family = AF_UNIX;
161 strcpy(svr1.sun_path,kernel_name);
162 strcpy(kername,kernel_name);
163 len = strlen(svr1.sun_path)+sizeof(svr1.sun_family);
164 i = connect(kernel_sock,(struct sockaddr*)&svr1,len);
166 fcntl(kernel_sock,F_SETFL, O_NONBLOCK|fcntl(kernel_sock,F_GETFL,0));
168 setsockopt(kernel_sock,IPPROTO_TCP,TCP_NODELAY,(char*)&on,sizeof(on));
169 m.msg_type = MSG_NET;
170 m.param.pword[0] = NET_NODE;
171 m.param.pword[1] = MyNode;
174 // if (regme) regme_sequence();
177 write_at_console("Connecting remote VLPs...");
178 while (!all_connected) check_links();
180 sprintf(s,"Local node number %d",MyNode);
184 // ##################### Load configuration ##########################
186 void NETMOD::load_config(char *fname)
189 config_setting_t *setting;
196 /* Hack for checking if file exists without using external libs.*/
197 FILE * file = fopen(fname, "rt");
199 fprintf(stderr, "Error: Cannot load configuration file %s!\n", fname);
200 write_at_console("Cannot load configuration file!");
205 /* Read the file. If there is an error, report it and exit. */
206 if(!config_read(&cfg, file))
208 fprintf(stderr, "%s: In file %s, line %d\n",
209 config_error_text(&cfg),
210 config_error_file(&cfg),
211 config_error_line(&cfg));
212 config_destroy(&cfg);
214 exit(3);/* from original code. */
217 setting = config_lookup(&cfg, "node_number");
220 MyNode = config_setting_get_int(setting);
223 if (!setting || MyNode==-1)
225 fprintf(stderr, "%s! In file %s, '%s' was not found.\n",
229 write_at_console("Node number must be specified");
230 config_destroy(&cfg);
235 setting = config_lookup(&cfg, "host");
238 pomlink = new NETlink;
240 switch(config_setting_type(setting)) {
241 case CONFIG_TYPE_STRING:/* TODO: Deprecated. Made for back compatibility. */
242 strncpy(pomlink->addr, config_setting_get_string(setting), 255);
244 case CONFIG_TYPE_ARRAY:
245 strncpy(pomlink->addr, config_setting_get_string_elem(setting, 0), 255);
248 fprintf(stderr, "%s! In file %s, bad entry type for %s. Will not be read.\n"
252 config_destroy(&cfg);
256 pomlink->connected = FALSE;
257 pomlink->sock = socket(AF_INET, SOCK_STREAM, 0);
258 fcntl(pomlink->sock, F_SETFL,O_NONBLOCK | fcntl(pomlink->sock,F_GETFL,0));
260 setsockopt(pomlink->sock,IPPROTO_TCP,TCP_NODELAY,(char*)&on,sizeof(on));
261 Links.append(pomlink);
265 fprintf(stderr, "%s! In file %s, '%s' was not found.\n",
271 config_destroy(&cfg);
274 if (k==0) all_connected=TRUE;
279 void NETMOD::write_at_console(char *s)
283 msg.msg_type = MSG_NET;
284 msg.param.pword[0] = NET_CSWRITELN;
285 strcpy(msg.param.pstr,s);
286 send_to_kernel(&msg);
289 void NETMOD::send_to_kernel(MESSAGE *msg)
291 write(kernel_sock,msg,sizeof(MESSAGE));
294 void NETMOD::send_to_node(NETlink *lnk, MESSAGE *msg)
296 msg->msg_type = MSG_NET;
299 write(lnk->sock,msg,sizeof(MESSAGE));
302 void NETMOD::send_to_int(MESSAGE *msg)
306 pomlink = findINTlink(msg->param.pword[5]);
307 if (pomlink!=NULL) write(pomlink->sock,msg,sizeof(MESSAGE));
312 void NETMOD::accept_connection()
316 struct sockaddr_in svr;
318 struct timeval tout = {0,0};
321 FD_ZERO(&rset);FD_ZERO(&wset);
322 FD_SET(listen_sock,&rset);
324 if (select(listen_sock+1,&rset,&wset,0,(struct timeval *)&tout)>0)
325 if (FD_ISSET(listen_sock,&rset))
328 /* accept connection on listen socket */
330 bzero(&svr, sizeof(svr));
331 nsock = accept(listen_sock, (struct sockaddr*)&svr, &sz);
336 /* i<0 someone wants to connect us */
338 pomlink = new NETlink;
339 strcpy(pomlink->addr,inet_ntoa(svr.sin_addr));
340 pomlink->sock = nsock;
341 pomlink->connected = TRUE;
342 fcntl(pomlink->sock, F_SETFL,O_NONBLOCK | fcntl(pomlink->sock,
345 setsockopt(pomlink->sock,IPPROTO_TCP,TCP_NODELAY,(char*)&on,sizeof(on));
346 Links.append(pomlink);
352 void NETMOD::check_node(int n, int sc)
357 m.msg_type = MSG_NET;
358 m.param.pword[0] = NET_NODE_EXIST;
360 pomlink = Links.first();
361 m.param.pword[1] = 0;
362 while (pomlink!=NULL)
364 if ( pomlink->node_number==n )
366 m.param.pword[1] = 1;
367 strcpy(m.param.pstr,pomlink->addr);
370 pomlink = Links.next();
372 write(sc,&m,sizeof(MESSAGE));
376 // ************* Internal message from kernel or INT *******************
378 void NETMOD::get_internal()
383 fd_set readset,writeset;
384 struct timeval tout={0,0};
386 struct sockaddr_un svr;
390 FD_ZERO(&readset);FD_ZERO(&writeset);
391 FD_SET(kernel_sock,&readset);
394 pomlink = Interpreters.first();
395 while (pomlink!=NULL)
397 FD_SET(pomlink->sock,&readset);
398 if (nrset<pomlink->sock) nrset=pomlink->sock;
399 pomlink=Interpreters.next();
402 if (select(nrset+1,&readset,&writeset,0,(struct timeval *)&tout)>0)
405 /* Check request sockets */
406 pomlink = Interpreters.first();
407 while (pomlink!=NULL)
409 if (FD_ISSET(pomlink->sock,&readset))
411 nr = read(pomlink->sock,&msg,sizeof(MESSAGE));
414 if (msg.msg_type == MSG_NET)
415 switch(msg.param.pword[0])
417 case NET_PROPAGATE:propagate_msg(&msg);break;
418 case NET_NODE_EXIST:check_node(msg.param.pword[1],pomlink->sock);break;
419 case NET_GET_INFO: conn_info(pomlink->sock);break;
420 case NET_NODES_NUM: msg.param.pword[0]=NET_NODES_NUM_RESPONSE;
421 msg.param.pword[1]=Links.count();
422 write(pomlink->sock,&msg,sizeof(MESSAGE));
427 pomlink=Interpreters.next();
430 /* Check internal socket */
431 if (FD_ISSET(kernel_sock,&readset))
433 nr = read(kernel_sock, &msg, sizeof(MESSAGE));
436 if (msg.msg_type == MSG_NET)
438 switch(msg.param.pword[0])
440 case NET_TRANSMIT_CODE:
441 transmit_file(msg.param.pword[2],msg.param.pstr,msg.param.pword[1]);
443 case NET_EXIT: { disconnect_seq();exit_sequence();}
445 case NET_GET_INFO: conn_info(kernel_sock);break;
446 case NET_PROPAGATE:propagate_msg(&msg);break;
447 case NET_DISCONNECT:disconnect_seq();
449 case NET_NODE_EXIST: check_node(msg.param.pword[1],kernel_sock);break;
450 case NET_CONNECT_TO: connect_seq(msg.param.pstr);
455 if (msg.msg_type == MSG_VLP)
456 switch(msg.param.pword[0])
460 pomlink = new INTlink;
461 pomlink->sock = socket(AF_UNIX,SOCK_STREAM,0);
462 bzero(&svr,sizeof(svr));
463 svr.sun_family = AF_UNIX;
464 strcpy(svr.sun_path,msg.param.pstr);
465 si = strlen(svr.sun_path)+sizeof(svr.sun_family);
466 sj = connect(pomlink->sock,(struct sockaddr*)&svr,si);
468 fcntl(pomlink->sock,F_SETFL, O_NONBLOCK|
469 fcntl(pomlink->sock,F_GETFL,0));
471 setsockopt(pomlink->sock,IPPROTO_TCP,TCP_NODELAY,(char*)&on,sizeof(on));
472 pomlink->ID = msg.param.pword[1];
473 pomlink->connected=TRUE;
474 Interpreters.append(pomlink);
477 case VLP_INTERPRETER_DOWN:
479 pomlink = findINTlink(msg.param.pword[1]);
482 close(pomlink->sock);
483 Interpreters.remove(pomlink);
496 void NETMOD::get_message(NETlink *lnk)
501 int rdbt,rd,sz,j,psock;
502 struct sockaddr_in svr;
503 unsigned char buffer[FILE_BUFFER_SIZE];
508 nr = read(lnk->sock,&msg, sizeof(MESSAGE));
512 if (msg.msg_type == MSG_NET)
514 switch(msg.param.pword[0])
518 lnk->code_transmit = TRUE;
519 sprintf(pomstr,"%s/%s",REMOTE_PATH,msg.param.pstr);
520 strcat(pomstr,".ccd");
521 lnk->CodeFile = fopen(pomstr,"wb");
522 if ( lnk->CodeFile == NULL) { write_at_console("Cannot open file\n");
523 lnk->code_transmit=FALSE;}
524 lnk->CodeSize=msg.param.pword[1];
525 psock = socket(AF_INET, SOCK_STREAM, 0);
526 bzero(&svr, sizeof(svr));
527 svr.sin_family = AF_INET;
528 svr.sin_port = htons(CODEPORT);
529 svr.sin_addr.s_addr = inet_addr(lnk->addr);
530 j = connect(psock, (struct sockaddr*)&svr, sizeof(svr));
533 //fcntl(psock, F_SETFL,O_NONBLOCK | fcntl(psock, F_GETFL,0));
535 while (sz<lnk->CodeSize)
537 rd = read(psock,&buffer,sizeof(buffer));
538 rdbt = fwrite(&buffer,sizeof(unsigned char),rd,lnk->CodeFile);
542 fclose(lnk->CodeFile);
549 lnk->code_transmit = TRUE;
550 sprintf(pomstr,"%s/%s",REMOTE_PATH,msg.param.pstr);
551 strcat(pomstr,".pcd");
552 lnk->CodeFile = fopen(pomstr,"wb");
553 if ( lnk->CodeFile == NULL) { write_at_console("Cannot open file\n");
554 lnk->code_transmit=FALSE;}
555 lnk->CodeSize=msg.param.pword[1];
556 psock = socket(AF_INET, SOCK_STREAM, 0);
557 bzero(&svr, sizeof(svr));
558 svr.sin_family = AF_INET;
559 svr.sin_port = htons(CODEPORT1);
560 svr.sin_addr.s_addr = inet_addr(lnk->addr);
561 j = connect(psock, (struct sockaddr*)&svr, sizeof(svr));
564 //fcntl(psock, F_SETFL,O_NONBLOCK | fcntl(psock, F_GETFL,0));
566 while (sz<lnk->CodeSize)
568 rd = read(psock,&proto,sizeof(proto));
569 rdbt = fwrite(&proto,sizeof(unsigned char),rd,lnk->CodeFile);
573 fclose(lnk->CodeFile);
580 sprintf(pomstr,"Node: %d Addr: %s",msg.param.pword[1],
582 lnk->node_number = msg.param.pword[1];
583 write_at_console(pomstr);
584 send_accept_info(lnk);
588 sprintf(pomstr,"Node: %d Addr: %s",msg.param.pword[1],
590 lnk->node_number = msg.param.pword[1];
591 write_at_console(pomstr);
595 sprintf(pomstr,"Node: %d disconnected",msg.param.pword[1]);
596 write_at_console(pomstr);
603 if (msg.param.pword[1] == MSG_VLP) send_to_kernel(&msg);
604 else if (msg.param.pword[1] == MSG_INT) send_to_int(&msg);
617 void NETMOD::remote_messages()
621 struct timeval tout={0,0};
624 FD_ZERO(&rset);FD_ZERO(&wset);
627 pomlink = Links.first();
628 while (pomlink!=NULL)
630 if (pomlink->connected)
632 FD_SET(pomlink->sock,&rset);
633 if (max<pomlink->sock) max=pomlink->sock;
635 pomlink=Links.next();
638 if (select(max+1,&rset,&wset,0,(struct timeval *)&tout)>0)
640 pomlink=Links.first();
641 while (pomlink!=NULL)
643 if (FD_ISSET(pomlink->sock,&rset)) get_message(pomlink);
644 pomlink=Links.next();
651 /****************************** 2010 ********************************************/
652 void NETMOD::doitall() {
654 int nsock,max=0,on, nr, si, sj;
655 struct sockaddr_in svr;
659 struct sockaddr_un svr2;
664 FD_SET(listen_sock,&rset);
666 FD_SET(kernel_sock,&rset);
667 if (max<kernel_sock) { max=kernel_sock;}
668 pomlink2 = Interpreters.first();
669 while (pomlink2!=NULL)
671 FD_SET(pomlink2->sock,&rset);
672 if (max<pomlink2->sock) max=pomlink2->sock;
673 pomlink2=Interpreters.next();
675 pomlink = Links.first();
676 while (pomlink!=NULL)
678 if (pomlink->connected)
680 FD_SET(pomlink->sock,&rset);
681 if (max<pomlink->sock) max=pomlink->sock;
683 pomlink=Links.next();
687 if (select(max+1,&rset,0,0,NULL) > 0) {
689 if (FD_ISSET(listen_sock,&rset))
691 /* accept connection on listen socket */
693 bzero(&svr, sizeof(svr));
694 nsock = accept(listen_sock, (struct sockaddr*)&svr, &sz);
697 pomlink = new NETlink;
698 strcpy(pomlink->addr,inet_ntoa(svr.sin_addr));
699 pomlink->sock = nsock;
700 pomlink->connected = TRUE;
701 fcntl(pomlink->sock, F_SETFL,O_NONBLOCK | fcntl(pomlink->sock,F_GETFL,0));
703 setsockopt(pomlink->sock,IPPROTO_TCP,TCP_NODELAY,(char*)&on,sizeof(on));
704 Links.append(pomlink);
708 // get internal message
709 /* Check request sockets */
710 pomlink2 = Interpreters.first();
711 while (pomlink2!=NULL)
713 if (FD_ISSET(pomlink2->sock,&rset))
715 nr = read(pomlink2->sock,&msg,sizeof(MESSAGE));
718 if (msg.msg_type == MSG_NET)
719 switch(msg.param.pword[0])
721 case NET_PROPAGATE:propagate_msg(&msg); break;
722 case NET_NODE_EXIST:check_node(msg.param.pword[1],pomlink2->sock);break;
723 case NET_GET_INFO: conn_info(pomlink2->sock);break;
724 case NET_NODES_NUM: msg.param.pword[0]=NET_NODES_NUM_RESPONSE;
725 msg.param.pword[1]=Links.count();
726 write(pomlink2->sock,&msg,sizeof(MESSAGE));
731 pomlink2=Interpreters.next();
733 /* Check internal socket */
734 if (FD_ISSET(kernel_sock,&rset))
736 nr = read(kernel_sock, &msg, sizeof(MESSAGE));
739 if (msg.msg_type == MSG_NET)
741 switch(msg.param.pword[0])
743 case NET_TRANSMIT_CODE:
745 transmit_file(msg.param.pword[2],msg.param.pstr,msg.param.pword[1]);
748 case NET_EXIT: { disconnect_seq();exit_sequence();}
750 case NET_GET_INFO: conn_info(kernel_sock);break;
751 case NET_PROPAGATE:propagate_msg(&msg);break;
752 case NET_DISCONNECT:disconnect_seq();
754 case NET_NODE_EXIST: check_node(msg.param.pword[1],kernel_sock);break;
755 case NET_CONNECT_TO: connect_seq(msg.param.pstr);
758 if (msg.msg_type == MSG_VLP)
759 switch(msg.param.pword[0])
764 pomlink2 = new INTlink;
765 pomlink2->sock = socket(AF_UNIX,SOCK_STREAM,0);
766 bzero(&svr2,sizeof(svr2));
767 svr2.sun_family = AF_UNIX;
768 strcpy(svr2.sun_path,msg.param.pstr);
769 si = strlen(svr2.sun_path)+sizeof(svr2.sun_family);
770 sj = connect(pomlink2->sock,(struct sockaddr*)&svr2,si);
772 fcntl(pomlink2->sock,F_SETFL, O_NONBLOCK|fcntl(pomlink2->sock,F_GETFL,0));
774 setsockopt(pomlink2->sock,IPPROTO_TCP,TCP_NODELAY,(char*)&on,sizeof(on));
775 pomlink2->ID = msg.param.pword[1];
776 pomlink2->connected=TRUE;
777 Interpreters.append(pomlink2);
780 case VLP_INTERPRETER_DOWN:
783 pomlink2 = findINTlink(msg.param.pword[1]);
786 close(pomlink2->sock);
787 Interpreters.remove(pomlink2);
794 // get remote message
796 pomlink=Links.first();
797 while (pomlink!=NULL)
799 if (FD_ISSET(pomlink->sock,&rset)) get_message(pomlink);
800 pomlink=Links.next();
806 /****************************** END 2010 ********************************************/
810 void NETMOD::propagate_msg(MESSAGE *msg)
815 pomlink = findNETlink(msg->param.pword[4]);
816 if ((pomlink!=NULL)&&(pomlink->connected))
817 send_to_node(pomlink,msg);
819 if (msg->param.pword[1]==MSG_INT)
825 sprintf(ss,"Not connected to Node %d",msg->param.pword[4]);
826 write_at_console(ss);
833 void NETMOD::connect_seq(char *a)
836 struct sockaddr_in svr;
843 if (strcmp(pom->addr,a)==0) return;
848 pom->connected = FALSE;
849 pom->sock = socket(AF_INET, SOCK_STREAM, 0);
850 bzero(&svr, sizeof(svr));
851 svr.sin_family = AF_INET;
852 svr.sin_port = htons(LOGPORT);
853 svr.sin_addr.s_addr = inet_addr(pom->addr);
854 j = connect(pom->sock, (struct sockaddr*)&svr, sizeof(svr));
856 { pom->connected = TRUE;
857 fcntl(pom->sock, F_SETFL,O_NONBLOCK | fcntl(pom->sock,
860 setsockopt(pom->sock,IPPROTO_TCP,TCP_NODELAY,(char*)&on,sizeof(on));
861 send_connect_info(pom);
864 else write_at_console("Connection failed");
867 void NETMOD::check_links()
871 struct sockaddr_in svr;
874 /* connect to all other nodes */
877 pomlink=Links.first();
878 while (pomlink!=NULL)
880 if ( !(pomlink->connected) )
882 bzero(&svr, sizeof(svr));
883 svr.sin_family = AF_INET;
884 svr.sin_port = htons(LOGPORT);
885 svr.sin_addr.s_addr = inet_addr(pomlink->addr);
887 j = connect(pomlink->sock, (struct sockaddr*)&svr, sizeof(svr));
889 { pomlink->connected = TRUE;
890 fcntl(pomlink->sock, F_SETFL,O_NONBLOCK | fcntl(pomlink->sock,
892 send_connect_info(pomlink);
895 if (errno == ECONNREFUSED)
896 sock_reopen(pomlink);
898 pomlink=Links.next();
903 pomlink=Links.first();
906 if (pomlink->connected==FALSE) {all_connected=FALSE;break;}
907 pomlink=Links.next();
912 void NETMOD::sock_reopen(NETlink *lnk)
917 lnk->sock = socket(AF_INET, SOCK_STREAM, 0);
918 fcntl(lnk->sock, F_SETFL,O_NONBLOCK | fcntl(lnk->sock,
920 setsockopt(lnk->sock,IPPROTO_TCP,TCP_NODELAY,(char*)&on,sizeof(on));
924 // **************** Acknowledges *************************
926 void NETMOD::send_connect_info(NETlink *lnk)
930 m.param.pword[0] = NET_CONNECT;
931 m.param.pword[1] = MyNode;
932 m.msg_type = MSG_NET;
935 write(lnk->sock,&m,sizeof(MESSAGE));
938 void NETMOD::send_accept_info(NETlink *lnk)
942 m.param.pword[0] = NET_ACCEPT;
943 m.param.pword[1] = MyNode;
944 m.msg_type = MSG_NET;
947 write(lnk->sock,&m,sizeof(MESSAGE));
950 void NETMOD::send_code_ack(NETlink *lnk)
954 m.param.pword[0] = NET_CODESTREAM_OK;
955 m.msg_type = MSG_NET;
958 write(lnk->sock,&m,sizeof(MESSAGE));
962 void NETMOD::send_to_all(MESSAGE *msg)
965 pomlink=Links.first();
966 while (pomlink!=NULL)
968 write(pomlink->sock,msg,sizeof(MESSAGE));
969 pomlink=Links.next();
980 /*accept_connection();
982 remote_messages(); */
988 void NETMOD::exit_sequence()
992 ::close(kernel_sock);
993 ::close(listen_sock);
995 pomlink = Links.first();
996 while (pomlink!=NULL)
998 ::close(pomlink->sock);
999 pomlink=Links.next();
1004 void NETMOD::disconnect_seq()
1009 bzero(&m,sizeof(MESSAGE));
1010 m.msg_type = MSG_NET;
1011 m.param.pword[0] = NET_DISCONNECT;
1012 m.param.pword[1] = MyNode;
1029 NETlink *NETMOD::findNETlink(int node)
1032 pomlink=Links.first();
1033 while(pomlink!=NULL)
1035 if (pomlink->node_number == node) return(pomlink);
1036 pomlink=Links.next();
1041 INTlink *NETMOD::findINTlink(int id)
1044 pomlink=Interpreters.first();
1045 while(pomlink!=NULL)
1047 if (pomlink->ID == id) return(pomlink);
1048 pomlink=Interpreters.next();
1054 /* ---------------- Sending code to a remote node -------------- */
1056 void NETMOD::transmit_file(int ton, char *fname, int fromINT)
1062 unsigned char buffer[FILE_BUFFER_SIZE];
1067 struct sockaddr_in svr;
1071 // **************** CCD FILE
1078 fseek(f,0,SEEK_END);
1079 msg.param.pword[1] = ftell(f);
1083 strcpy(b,rindex(fname,'/'));
1084 for(i=0;i<strlen(b);i++)
1086 msg.param.pword[0] = NET_CCD_START;
1087 strcpy(msg.param.pstr,b);
1089 outlink = findNETlink(ton);
1090 if (outlink==NULL) exit(1);
1091 bzero(&svr,sizeof(svr));
1092 sock = socket(AF_INET,SOCK_STREAM,0);
1093 svr.sin_family = AF_INET;
1094 svr.sin_addr.s_addr = INADDR_ANY;
1095 svr.sin_port = htons(CODEPORT);
1096 bind(sock, (struct sockaddr*)&svr, sizeof(svr));
1098 send_to_node(outlink, &msg);
1100 FD_ZERO(&rset);FD_ZERO(&wset);
1102 if (select(sock+1,&rset,&wset,0,0))
1103 if (FD_ISSET(sock,&rset))
1104 tsock = accept(sock, (struct sockaddr*)&svr,&sz );
1110 i = fread(&buffer,1,sizeof(buffer),f);
1111 write(tsock,&buffer,i);
1112 FD_ZERO(&rset);FD_ZERO(&wset);
1113 FD_SET(tsock,&wset);
1114 select(tsock+1,&rset,&wset,0,0);
1122 sprintf(b,"Cannot open file to send %s\n",fname);
1123 write_at_console(b);
1127 // *************** PCD FILE
1134 fseek(f,0,SEEK_END);
1135 msg.param.pword[1] = ftell(f);
1139 strcpy(b,rindex(fname,'/'));
1140 for(i=0;i<strlen(b);i++)
1142 msg.param.pword[0] = NET_PCD_START;
1143 strcpy(msg.param.pstr,b);
1145 outlink = findNETlink(ton);
1146 if (outlink==NULL) exit(1);
1147 bzero(&svr,sizeof(svr));
1148 sock = socket(AF_INET,SOCK_STREAM,0);
1149 svr.sin_family = AF_INET;
1150 svr.sin_addr.s_addr = INADDR_ANY;
1151 svr.sin_port = htons(CODEPORT1);
1152 bind(sock, (struct sockaddr*)&svr, sizeof(svr));
1154 send_to_node(outlink, &msg);
1156 FD_ZERO(&rset);FD_ZERO(&wset);
1158 if (select(sock+1,&rset,&wset,0,0))
1159 if (FD_ISSET(sock,&rset))
1160 tsock = accept(sock, (struct sockaddr*)&svr,&sz );
1166 i = fread(&proto,1,sizeof(proto),f);
1167 write(tsock,&proto,i);
1168 FD_ZERO(&rset);FD_ZERO(&wset);
1169 FD_SET(tsock,&wset);
1170 select(tsock+1,&rset,&wset,0,0);
1178 sprintf(b,"Cannot open file to send %s\n",fname);
1179 write_at_console(b);
1183 msg.msg_type = MSG_NET;
1184 msg.param.pword[0] = NET_TRANSMITTED;
1185 msg.param.pword[1] = fromINT;
1186 send_to_kernel(&msg);
1193 void NETMOD::conn_info(int sk)
1200 m.msg_type = MSG_NET;
1201 m.param.pword[0] = NET_INFO;
1202 strcpy(m.param.pstr,"");
1206 sprintf(poms,"%d=%s;",pom->node_number,pom->addr);
1207 strcat(m.param.pstr,poms);
1211 m.param.pword[1]=12;
1212 write(sk,&m,sizeof(MESSAGE));
1220 write(sk,&m,sizeof(MESSAGE));
1222 m.msg_type = MSG_NET;
1223 m.param.pword[0] = NET_INFO_END;
1224 write(sk,&m,sizeof(MESSAGE));
1227 int main(int argc,char **argv)
1229 NETMOD netter(argv[1]);