2 #include "../head/comm.h"
4 #include <sys/socket.h>
6 #include <netinet/in.h>
11 #include <sys/types.h>
22 #include <qstringlist.h>
25 #define REMOTE_PATH "REMOTE"
29 #define CODEPORT1 3800
31 #define FILE_BUFFER_SIZE 2048
35 // ************** Interpreter slot *******************
52 // ******************** Network slot ********************
57 bool connected,code_transmit;
74 for(i=0;i<5;i++) aliases[i]=-1;
83 //********************** NET Module ****************************
88 int kernel_sock,listen_sock;
89 bool all_connected,local_mode;
90 int to_connect,MyNode;
94 QList<INTlink> Interpreters; // List of the Interpeter slots
95 QList<NETlink> Links; // List of the Network slots
99 void load_config(char*);
100 void write_at_console(char*);
101 void send_to_kernel(MESSAGE*);
102 void sock_reopen(NETlink*);
103 void send_connect_info(NETlink*);
104 void send_accept_info(NETlink*);
105 void send_to_node(NETlink*,MESSAGE*);
106 void send_to_int(MESSAGE*);
107 void send_code_ack(NETlink*);
108 void send_to_all(MESSAGE *);
110 NETlink *findNETlink(int node);
111 INTlink *findINTlink(int id);
112 void transmit_file(int ton, char *fname, int fromINT);
113 void propagate_msg(MESSAGE *msg);
114 void check_node(int,int);
117 void exit_sequence();
118 void disconnect_seq();
119 void connect_seq(char*);
120 void accept_connection();
122 void remote_messages();
124 void get_message(NETlink*);
127 void doitall(); // 2010
131 NETMOD::NETMOD(char *kernel_name)
134 struct sockaddr_in svr;
135 struct sockaddr_un svr1;
141 Interpreters.clear();
143 bzero(&svr, sizeof(svr));
144 listen_sock = socket(AF_INET, SOCK_STREAM, 0);
145 svr.sin_family = AF_INET;
146 svr.sin_addr.s_addr = INADDR_ANY;
147 svr.sin_port = htons(LOGPORT);
148 bind(listen_sock, (struct sockaddr*)&svr, sizeof(svr));
149 listen(listen_sock,5);
150 fcntl(listen_sock, F_SETFL,O_NONBLOCK | fcntl(listen_sock, F_GETFL,0));
154 load_config("vlp.cfg");
156 kernel_sock = socket(AF_UNIX,SOCK_STREAM,0);
157 bzero(&svr1,sizeof(svr1));
158 svr1.sun_family = AF_UNIX;
159 strcpy(svr1.sun_path,kernel_name);
160 strcpy(kername,kernel_name);
161 len = strlen(svr1.sun_path)+sizeof(svr1.sun_family);
162 i = connect(kernel_sock,(struct sockaddr*)&svr1,len);
164 fcntl(kernel_sock,F_SETFL, O_NONBLOCK|fcntl(kernel_sock,F_GETFL,0));
166 setsockopt(kernel_sock,IPPROTO_TCP,TCP_NODELAY,(char*)&on,sizeof(on));
167 m.msg_type = MSG_NET;
168 m.param.pword[0] = NET_NODE;
169 m.param.pword[1] = MyNode;
172 // if (regme) regme_sequence();
175 write_at_console("Connecting remote VLPs...");
176 while (!all_connected) check_links();
178 sprintf(s,"Local node number %d",MyNode);
182 // ##################### Load configuration ##########################
184 void NETMOD::load_config(char *fname)
194 write_at_console("Cannot load configuration file!");sleep(2);exit(3);
197 br = f.readLine(line,256);
200 QStringList l = QStringList::split("=",line,FALSE);
201 QStringList::Iterator it = l.begin();
205 val = val.stripWhiteSpace();
206 if (line == "node_number") {MyNode = val.toInt();};
207 if (line == "host" ) {
209 pomlink = new NETlink;
210 strcpy(pomlink->addr,val.ascii());
211 pomlink->connected = FALSE;
212 pomlink->sock = socket(AF_INET, SOCK_STREAM, 0);
213 fcntl(pomlink->sock, F_SETFL,O_NONBLOCK | fcntl(pomlink->sock,F_GETFL,0));
215 setsockopt(pomlink->sock,IPPROTO_TCP,TCP_NODELAY,(char*)&on,sizeof(on));
216 Links.append(pomlink);
219 br = f.readLine(line,256);
222 if (k==0) all_connected=TRUE;
223 if (MyNode==-1) {write_at_console("Node number must be specified");exit(1);};
228 void NETMOD::write_at_console(char *s)
232 msg.msg_type = MSG_NET;
233 msg.param.pword[0] = NET_CSWRITELN;
234 strcpy(msg.param.pstr,s);
235 send_to_kernel(&msg);
238 void NETMOD::send_to_kernel(MESSAGE *msg)
240 write(kernel_sock,msg,sizeof(MESSAGE));
243 void NETMOD::send_to_node(NETlink *lnk, MESSAGE *msg)
245 msg->msg_type = MSG_NET;
248 write(lnk->sock,msg,sizeof(MESSAGE));
251 void NETMOD::send_to_int(MESSAGE *msg)
255 pomlink = findINTlink(msg->param.pword[5]);
256 if (pomlink!=NULL) write(pomlink->sock,msg,sizeof(MESSAGE));
261 void NETMOD::accept_connection()
265 struct sockaddr_in svr;
267 struct timeval tout = {0,0};
270 FD_ZERO(&rset);FD_ZERO(&wset);
271 FD_SET(listen_sock,&rset);
273 if (select(listen_sock+1,&rset,&wset,0,(struct timeval *)&tout)>0)
274 if (FD_ISSET(listen_sock,&rset))
277 /* accept connection on listen socket */
279 bzero(&svr, sizeof(svr));
280 nsock = accept(listen_sock, (struct sockaddr*)&svr, &sz);
285 /* i<0 someone wants to connect us */
287 pomlink = new NETlink;
288 strcpy(pomlink->addr,inet_ntoa(svr.sin_addr));
289 pomlink->sock = nsock;
290 pomlink->connected = TRUE;
291 fcntl(pomlink->sock, F_SETFL,O_NONBLOCK | fcntl(pomlink->sock,
294 setsockopt(pomlink->sock,IPPROTO_TCP,TCP_NODELAY,(char*)&on,sizeof(on));
295 Links.append(pomlink);
301 void NETMOD::check_node(int n, int sc)
306 m.msg_type = MSG_NET;
307 m.param.pword[0] = NET_NODE_EXIST;
309 pomlink = Links.first();
310 m.param.pword[1] = 0;
311 while (pomlink!=NULL)
313 if ( pomlink->node_number==n )
315 m.param.pword[1] = 1;
316 strcpy(m.param.pstr,pomlink->addr);
319 pomlink = Links.next();
321 write(sc,&m,sizeof(MESSAGE));
325 // ************* Internal message from kernel or INT *******************
327 void NETMOD::get_internal()
332 fd_set readset,writeset;
333 struct timeval tout={0,0};
335 struct sockaddr_un svr;
339 FD_ZERO(&readset);FD_ZERO(&writeset);
340 FD_SET(kernel_sock,&readset);
343 pomlink = Interpreters.first();
344 while (pomlink!=NULL)
346 FD_SET(pomlink->sock,&readset);
347 if (nrset<pomlink->sock) nrset=pomlink->sock;
348 pomlink=Interpreters.next();
351 if (select(nrset+1,&readset,&writeset,0,(struct timeval *)&tout)>0)
354 /* Check request sockets */
355 pomlink = Interpreters.first();
356 while (pomlink!=NULL)
358 if (FD_ISSET(pomlink->sock,&readset))
360 nr = read(pomlink->sock,&msg,sizeof(MESSAGE));
363 if (msg.msg_type == MSG_NET)
364 switch(msg.param.pword[0])
366 case NET_PROPAGATE:propagate_msg(&msg);break;
367 case NET_NODE_EXIST:check_node(msg.param.pword[1],pomlink->sock);break;
368 case NET_GET_INFO: conn_info(pomlink->sock);break;
369 case NET_NODES_NUM: msg.param.pword[0]=NET_NODES_NUM_RESPONSE;
370 msg.param.pword[1]=Links.count();
371 write(pomlink->sock,&msg,sizeof(MESSAGE));
376 pomlink=Interpreters.next();
379 /* Check internal socket */
380 if (FD_ISSET(kernel_sock,&readset))
382 nr = read(kernel_sock, &msg, sizeof(MESSAGE));
385 if (msg.msg_type == MSG_NET)
387 switch(msg.param.pword[0])
389 case NET_TRANSMIT_CODE:
390 transmit_file(msg.param.pword[2],msg.param.pstr,msg.param.pword[1]);
392 case NET_EXIT: { disconnect_seq();exit_sequence();}
394 case NET_GET_INFO: conn_info(kernel_sock);break;
395 case NET_PROPAGATE:propagate_msg(&msg);break;
396 case NET_DISCONNECT:disconnect_seq();
398 case NET_NODE_EXIST: check_node(msg.param.pword[1],kernel_sock);break;
399 case NET_CONNECT_TO: connect_seq(msg.param.pstr);
404 if (msg.msg_type == MSG_VLP)
405 switch(msg.param.pword[0])
409 pomlink = new INTlink;
410 pomlink->sock = socket(AF_UNIX,SOCK_STREAM,0);
411 bzero(&svr,sizeof(svr));
412 svr.sun_family = AF_UNIX;
413 strcpy(svr.sun_path,msg.param.pstr);
414 si = strlen(svr.sun_path)+sizeof(svr.sun_family);
415 sj = connect(pomlink->sock,(struct sockaddr*)&svr,si);
417 fcntl(pomlink->sock,F_SETFL, O_NONBLOCK|
418 fcntl(pomlink->sock,F_GETFL,0));
420 setsockopt(pomlink->sock,IPPROTO_TCP,TCP_NODELAY,(char*)&on,sizeof(on));
421 pomlink->ID = msg.param.pword[1];
422 pomlink->connected=TRUE;
423 Interpreters.append(pomlink);
426 case VLP_INTERPRETER_DOWN:
428 pomlink = findINTlink(msg.param.pword[1]);
431 close(pomlink->sock);
432 Interpreters.remove(pomlink);
445 void NETMOD::get_message(NETlink *lnk)
450 int rdbt,rd,sz,j,psock;
451 struct sockaddr_in svr;
452 unsigned char buffer[FILE_BUFFER_SIZE];
457 nr = read(lnk->sock,&msg, sizeof(MESSAGE));
461 if (msg.msg_type == MSG_NET)
463 switch(msg.param.pword[0])
467 lnk->code_transmit = TRUE;
468 sprintf(pomstr,"%s/%s",REMOTE_PATH,msg.param.pstr);
469 strcat(pomstr,".ccd");
470 lnk->CodeFile = fopen(pomstr,"wb");
471 if ( lnk->CodeFile == NULL) { write_at_console("Cannot open file\n");
472 lnk->code_transmit=FALSE;}
473 lnk->CodeSize=msg.param.pword[1];
474 psock = socket(AF_INET, SOCK_STREAM, 0);
475 bzero(&svr, sizeof(svr));
476 svr.sin_family = AF_INET;
477 svr.sin_port = htons(CODEPORT);
478 svr.sin_addr.s_addr = inet_addr(lnk->addr);
479 j = connect(psock, (struct sockaddr*)&svr, sizeof(svr));
482 //fcntl(psock, F_SETFL,O_NONBLOCK | fcntl(psock, F_GETFL,0));
484 while (sz<lnk->CodeSize)
486 rd = read(psock,&buffer,sizeof(buffer));
487 rdbt = fwrite(&buffer,sizeof(unsigned char),rd,lnk->CodeFile);
491 fclose(lnk->CodeFile);
498 lnk->code_transmit = TRUE;
499 sprintf(pomstr,"%s/%s",REMOTE_PATH,msg.param.pstr);
500 strcat(pomstr,".pcd");
501 lnk->CodeFile = fopen(pomstr,"wb");
502 if ( lnk->CodeFile == NULL) { write_at_console("Cannot open file\n");
503 lnk->code_transmit=FALSE;}
504 lnk->CodeSize=msg.param.pword[1];
505 psock = socket(AF_INET, SOCK_STREAM, 0);
506 bzero(&svr, sizeof(svr));
507 svr.sin_family = AF_INET;
508 svr.sin_port = htons(CODEPORT1);
509 svr.sin_addr.s_addr = inet_addr(lnk->addr);
510 j = connect(psock, (struct sockaddr*)&svr, sizeof(svr));
513 //fcntl(psock, F_SETFL,O_NONBLOCK | fcntl(psock, F_GETFL,0));
515 while (sz<lnk->CodeSize)
517 rd = read(psock,&proto,sizeof(proto));
518 rdbt = fwrite(&proto,sizeof(unsigned char),rd,lnk->CodeFile);
522 fclose(lnk->CodeFile);
529 sprintf(pomstr,"Node: %d Addr: %s",msg.param.pword[1],
531 lnk->node_number = msg.param.pword[1];
532 write_at_console(pomstr);
533 send_accept_info(lnk);
537 sprintf(pomstr,"Node: %d Addr: %s",msg.param.pword[1],
539 lnk->node_number = msg.param.pword[1];
540 write_at_console(pomstr);
544 sprintf(pomstr,"Node: %d disconnected",msg.param.pword[1]);
545 write_at_console(pomstr);
552 if (msg.param.pword[1] == MSG_VLP) send_to_kernel(&msg);
553 else if (msg.param.pword[1] == MSG_INT) send_to_int(&msg);
566 void NETMOD::remote_messages()
570 struct timeval tout={0,0};
573 FD_ZERO(&rset);FD_ZERO(&wset);
576 pomlink = Links.first();
577 while (pomlink!=NULL)
579 if (pomlink->connected)
581 FD_SET(pomlink->sock,&rset);
582 if (max<pomlink->sock) max=pomlink->sock;
584 pomlink=Links.next();
587 if (select(max+1,&rset,&wset,0,(struct timeval *)&tout)>0)
589 pomlink=Links.first();
590 while (pomlink!=NULL)
592 if (FD_ISSET(pomlink->sock,&rset)) get_message(pomlink);
593 pomlink=Links.next();
600 /****************************** 2010 ********************************************/
601 void NETMOD::doitall() {
603 int nsock,max=0,on, nr, si, sj;
604 struct sockaddr_in svr;
608 struct sockaddr_un svr2;
613 FD_SET(listen_sock,&rset);
615 FD_SET(kernel_sock,&rset);
616 if (max<kernel_sock) { max=kernel_sock;}
617 pomlink2 = Interpreters.first();
618 while (pomlink2!=NULL)
620 FD_SET(pomlink2->sock,&rset);
621 if (max<pomlink2->sock) max=pomlink2->sock;
622 pomlink2=Interpreters.next();
624 pomlink = Links.first();
625 while (pomlink!=NULL)
627 if (pomlink->connected)
629 FD_SET(pomlink->sock,&rset);
630 if (max<pomlink->sock) max=pomlink->sock;
632 pomlink=Links.next();
636 if (select(max+1,&rset,0,0,NULL) > 0) {
638 if (FD_ISSET(listen_sock,&rset))
640 /* accept connection on listen socket */
642 bzero(&svr, sizeof(svr));
643 nsock = accept(listen_sock, (struct sockaddr*)&svr, &sz);
646 pomlink = new NETlink;
647 strcpy(pomlink->addr,inet_ntoa(svr.sin_addr));
648 pomlink->sock = nsock;
649 pomlink->connected = TRUE;
650 fcntl(pomlink->sock, F_SETFL,O_NONBLOCK | fcntl(pomlink->sock,F_GETFL,0));
652 setsockopt(pomlink->sock,IPPROTO_TCP,TCP_NODELAY,(char*)&on,sizeof(on));
653 Links.append(pomlink);
657 // get internal message
658 /* Check request sockets */
659 pomlink2 = Interpreters.first();
660 while (pomlink2!=NULL)
662 if (FD_ISSET(pomlink2->sock,&rset))
664 nr = read(pomlink2->sock,&msg,sizeof(MESSAGE));
667 if (msg.msg_type == MSG_NET)
668 switch(msg.param.pword[0])
670 case NET_PROPAGATE:propagate_msg(&msg); break;
671 case NET_NODE_EXIST:check_node(msg.param.pword[1],pomlink2->sock);break;
672 case NET_GET_INFO: conn_info(pomlink2->sock);break;
673 case NET_NODES_NUM: msg.param.pword[0]=NET_NODES_NUM_RESPONSE;
674 msg.param.pword[1]=Links.count();
675 write(pomlink2->sock,&msg,sizeof(MESSAGE));
680 pomlink2=Interpreters.next();
682 /* Check internal socket */
683 if (FD_ISSET(kernel_sock,&rset))
685 nr = read(kernel_sock, &msg, sizeof(MESSAGE));
688 if (msg.msg_type == MSG_NET)
690 switch(msg.param.pword[0])
692 case NET_TRANSMIT_CODE:
694 transmit_file(msg.param.pword[2],msg.param.pstr,msg.param.pword[1]);
697 case NET_EXIT: { disconnect_seq();exit_sequence();}
699 case NET_GET_INFO: conn_info(kernel_sock);break;
700 case NET_PROPAGATE:propagate_msg(&msg);break;
701 case NET_DISCONNECT:disconnect_seq();
703 case NET_NODE_EXIST: check_node(msg.param.pword[1],kernel_sock);break;
704 case NET_CONNECT_TO: connect_seq(msg.param.pstr);
707 if (msg.msg_type == MSG_VLP)
708 switch(msg.param.pword[0])
713 pomlink2 = new INTlink;
714 pomlink2->sock = socket(AF_UNIX,SOCK_STREAM,0);
715 bzero(&svr2,sizeof(svr2));
716 svr2.sun_family = AF_UNIX;
717 strcpy(svr2.sun_path,msg.param.pstr);
718 si = strlen(svr2.sun_path)+sizeof(svr2.sun_family);
719 sj = connect(pomlink2->sock,(struct sockaddr*)&svr2,si);
721 fcntl(pomlink2->sock,F_SETFL, O_NONBLOCK|fcntl(pomlink2->sock,F_GETFL,0));
723 setsockopt(pomlink2->sock,IPPROTO_TCP,TCP_NODELAY,(char*)&on,sizeof(on));
724 pomlink2->ID = msg.param.pword[1];
725 pomlink2->connected=TRUE;
726 Interpreters.append(pomlink2);
729 case VLP_INTERPRETER_DOWN:
732 pomlink2 = findINTlink(msg.param.pword[1]);
735 close(pomlink2->sock);
736 Interpreters.remove(pomlink2);
743 // get remote message
745 pomlink=Links.first();
746 while (pomlink!=NULL)
748 if (FD_ISSET(pomlink->sock,&rset)) get_message(pomlink);
749 pomlink=Links.next();
755 /****************************** END 2010 ********************************************/
759 void NETMOD::propagate_msg(MESSAGE *msg)
764 pomlink = findNETlink(msg->param.pword[4]);
765 if ((pomlink!=NULL)&&(pomlink->connected))
766 send_to_node(pomlink,msg);
768 if (msg->param.pword[1]==MSG_INT)
774 sprintf(ss,"Not connected to Node %d",msg->param.pword[4]);
775 write_at_console(ss);
782 void NETMOD::connect_seq(char *a)
785 struct sockaddr_in svr;
792 if (strcmp(pom->addr,a)==0) return;
797 pom->connected = FALSE;
798 pom->sock = socket(AF_INET, SOCK_STREAM, 0);
799 bzero(&svr, sizeof(svr));
800 svr.sin_family = AF_INET;
801 svr.sin_port = htons(LOGPORT);
802 svr.sin_addr.s_addr = inet_addr(pom->addr);
803 j = connect(pom->sock, (struct sockaddr*)&svr, sizeof(svr));
805 { pom->connected = TRUE;
806 fcntl(pom->sock, F_SETFL,O_NONBLOCK | fcntl(pom->sock,
809 setsockopt(pom->sock,IPPROTO_TCP,TCP_NODELAY,(char*)&on,sizeof(on));
810 send_connect_info(pom);
813 else write_at_console("Connection failed");
816 void NETMOD::check_links()
820 struct sockaddr_in svr;
823 /* connect to all other nodes */
826 pomlink=Links.first();
827 while (pomlink!=NULL)
829 if ( !(pomlink->connected) )
831 bzero(&svr, sizeof(svr));
832 svr.sin_family = AF_INET;
833 svr.sin_port = htons(LOGPORT);
834 svr.sin_addr.s_addr = inet_addr(pomlink->addr);
836 j = connect(pomlink->sock, (struct sockaddr*)&svr, sizeof(svr));
838 { pomlink->connected = TRUE;
839 fcntl(pomlink->sock, F_SETFL,O_NONBLOCK | fcntl(pomlink->sock,
841 send_connect_info(pomlink);
844 if (errno == ECONNREFUSED)
845 sock_reopen(pomlink);
847 pomlink=Links.next();
852 pomlink=Links.first();
855 if (pomlink->connected==FALSE) {all_connected=FALSE;break;}
856 pomlink=Links.next();
861 void NETMOD::sock_reopen(NETlink *lnk)
866 lnk->sock = socket(AF_INET, SOCK_STREAM, 0);
867 fcntl(lnk->sock, F_SETFL,O_NONBLOCK | fcntl(lnk->sock,
869 setsockopt(lnk->sock,IPPROTO_TCP,TCP_NODELAY,(char*)&on,sizeof(on));
873 // **************** Acknowledges *************************
875 void NETMOD::send_connect_info(NETlink *lnk)
879 m.param.pword[0] = NET_CONNECT;
880 m.param.pword[1] = MyNode;
881 m.msg_type = MSG_NET;
884 write(lnk->sock,&m,sizeof(MESSAGE));
887 void NETMOD::send_accept_info(NETlink *lnk)
891 m.param.pword[0] = NET_ACCEPT;
892 m.param.pword[1] = MyNode;
893 m.msg_type = MSG_NET;
896 write(lnk->sock,&m,sizeof(MESSAGE));
899 void NETMOD::send_code_ack(NETlink *lnk)
903 m.param.pword[0] = NET_CODESTREAM_OK;
904 m.msg_type = MSG_NET;
907 write(lnk->sock,&m,sizeof(MESSAGE));
911 void NETMOD::send_to_all(MESSAGE *msg)
914 pomlink=Links.first();
915 while (pomlink!=NULL)
917 write(pomlink->sock,msg,sizeof(MESSAGE));
918 pomlink=Links.next();
929 /*accept_connection();
931 remote_messages(); */
937 void NETMOD::exit_sequence()
941 ::close(kernel_sock);
942 ::close(listen_sock);
944 pomlink = Links.first();
945 while (pomlink!=NULL)
947 ::close(pomlink->sock);
948 pomlink=Links.next();
953 void NETMOD::disconnect_seq()
958 bzero(&m,sizeof(MESSAGE));
959 m.msg_type = MSG_NET;
960 m.param.pword[0] = NET_DISCONNECT;
961 m.param.pword[1] = MyNode;
978 NETlink *NETMOD::findNETlink(int node)
981 pomlink=Links.first();
984 if (pomlink->node_number == node) return(pomlink);
985 pomlink=Links.next();
990 INTlink *NETMOD::findINTlink(int id)
993 pomlink=Interpreters.first();
996 if (pomlink->ID == id) return(pomlink);
997 pomlink=Interpreters.next();
1003 /* ---------------- Sending code to a remote node -------------- */
1005 void NETMOD::transmit_file(int ton, char *fname, int fromINT)
1011 unsigned char buffer[FILE_BUFFER_SIZE];
1016 struct sockaddr_in svr;
1020 // **************** CCD FILE
1027 fseek(f,0,SEEK_END);
1028 msg.param.pword[1] = ftell(f);
1032 strcpy(b,rindex(fname,'/'));
1033 for(i=0;i<strlen(b);i++)
1035 msg.param.pword[0] = NET_CCD_START;
1036 strcpy(msg.param.pstr,b);
1038 outlink = findNETlink(ton);
1039 if (outlink==NULL) exit(1);
1040 bzero(&svr,sizeof(svr));
1041 sock = socket(AF_INET,SOCK_STREAM,0);
1042 svr.sin_family = AF_INET;
1043 svr.sin_addr.s_addr = INADDR_ANY;
1044 svr.sin_port = htons(CODEPORT);
1045 bind(sock, (struct sockaddr*)&svr, sizeof(svr));
1047 send_to_node(outlink, &msg);
1049 FD_ZERO(&rset);FD_ZERO(&wset);
1051 if (select(sock+1,&rset,&wset,0,0))
1052 if (FD_ISSET(sock,&rset))
1053 tsock = accept(sock, (struct sockaddr*)&svr,&sz );
1059 i = fread(&buffer,1,sizeof(buffer),f);
1060 write(tsock,&buffer,i);
1061 FD_ZERO(&rset);FD_ZERO(&wset);
1062 FD_SET(tsock,&wset);
1063 select(tsock+1,&rset,&wset,0,0);
1071 sprintf(b,"Cannot open file to send %s\n",fname);
1072 write_at_console(b);
1076 // *************** PCD FILE
1083 fseek(f,0,SEEK_END);
1084 msg.param.pword[1] = ftell(f);
1088 strcpy(b,rindex(fname,'/'));
1089 for(i=0;i<strlen(b);i++)
1091 msg.param.pword[0] = NET_PCD_START;
1092 strcpy(msg.param.pstr,b);
1094 outlink = findNETlink(ton);
1095 if (outlink==NULL) exit(1);
1096 bzero(&svr,sizeof(svr));
1097 sock = socket(AF_INET,SOCK_STREAM,0);
1098 svr.sin_family = AF_INET;
1099 svr.sin_addr.s_addr = INADDR_ANY;
1100 svr.sin_port = htons(CODEPORT1);
1101 bind(sock, (struct sockaddr*)&svr, sizeof(svr));
1103 send_to_node(outlink, &msg);
1105 FD_ZERO(&rset);FD_ZERO(&wset);
1107 if (select(sock+1,&rset,&wset,0,0))
1108 if (FD_ISSET(sock,&rset))
1109 tsock = accept(sock, (struct sockaddr*)&svr,&sz );
1115 i = fread(&proto,1,sizeof(proto),f);
1116 write(tsock,&proto,i);
1117 FD_ZERO(&rset);FD_ZERO(&wset);
1118 FD_SET(tsock,&wset);
1119 select(tsock+1,&rset,&wset,0,0);
1127 sprintf(b,"Cannot open file to send %s\n",fname);
1128 write_at_console(b);
1132 msg.msg_type = MSG_NET;
1133 msg.param.pword[0] = NET_TRANSMITTED;
1134 msg.param.pword[1] = fromINT;
1135 send_to_kernel(&msg);
1142 void NETMOD::conn_info(int sk)
1149 m.msg_type = MSG_NET;
1150 m.param.pword[0] = NET_INFO;
1151 strcpy(m.param.pstr,"");
1155 sprintf(poms,"%d=%s;",pom->node_number,pom->addr);
1156 strcat(m.param.pstr,poms);
1160 m.param.pword[1]=12;
1161 write(sk,&m,sizeof(MESSAGE));
1169 write(sk,&m,sizeof(MESSAGE));
1171 m.msg_type = MSG_NET;
1172 m.param.pword[0] = NET_INFO_END;
1173 write(sk,&m,sizeof(MESSAGE));
1176 int main(int argc,char **argv)
1178 NETMOD netter(argv[1]);