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)
196 /* Hack for checking if file exists without using external libs.*/
197 FILE * file = fopen(fname, "r");
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 if(config_lookup_int(&cfg, "node_number", &MyNode))
220 write_at_console("Node number must be specified");
221 config_destroy(&cfg);
228 fprintf(stderr, "%s! In file %s, '%s' was not found.\n",
232 config_destroy(&cfg);
237 if(config_lookup_string(&cfg, "host", &str)) {
239 pomlink = new NETlink;
240 strcpy(pomlink->addr, str);
241 pomlink->connected = FALSE;
242 pomlink->sock = socket(AF_INET, SOCK_STREAM, 0);
243 fcntl(pomlink->sock, F_SETFL,O_NONBLOCK | fcntl(pomlink->sock,F_GETFL,0));
245 setsockopt(pomlink->sock,IPPROTO_TCP,TCP_NODELAY,(char*)&on,sizeof(on));
246 Links.append(pomlink);
250 fprintf(stderr, "%s! In file %s, '%s' was not found.\n",
256 config_destroy(&cfg);
259 if (k==0) all_connected=TRUE;
264 void NETMOD::write_at_console(char *s)
268 msg.msg_type = MSG_NET;
269 msg.param.pword[0] = NET_CSWRITELN;
270 strcpy(msg.param.pstr,s);
271 send_to_kernel(&msg);
274 void NETMOD::send_to_kernel(MESSAGE *msg)
276 write(kernel_sock,msg,sizeof(MESSAGE));
279 void NETMOD::send_to_node(NETlink *lnk, MESSAGE *msg)
281 msg->msg_type = MSG_NET;
284 write(lnk->sock,msg,sizeof(MESSAGE));
287 void NETMOD::send_to_int(MESSAGE *msg)
291 pomlink = findINTlink(msg->param.pword[5]);
292 if (pomlink!=NULL) write(pomlink->sock,msg,sizeof(MESSAGE));
297 void NETMOD::accept_connection()
301 struct sockaddr_in svr;
303 struct timeval tout = {0,0};
306 FD_ZERO(&rset);FD_ZERO(&wset);
307 FD_SET(listen_sock,&rset);
309 if (select(listen_sock+1,&rset,&wset,0,(struct timeval *)&tout)>0)
310 if (FD_ISSET(listen_sock,&rset))
313 /* accept connection on listen socket */
315 bzero(&svr, sizeof(svr));
316 nsock = accept(listen_sock, (struct sockaddr*)&svr, &sz);
321 /* i<0 someone wants to connect us */
323 pomlink = new NETlink;
324 strcpy(pomlink->addr,inet_ntoa(svr.sin_addr));
325 pomlink->sock = nsock;
326 pomlink->connected = TRUE;
327 fcntl(pomlink->sock, F_SETFL,O_NONBLOCK | fcntl(pomlink->sock,
330 setsockopt(pomlink->sock,IPPROTO_TCP,TCP_NODELAY,(char*)&on,sizeof(on));
331 Links.append(pomlink);
337 void NETMOD::check_node(int n, int sc)
342 m.msg_type = MSG_NET;
343 m.param.pword[0] = NET_NODE_EXIST;
345 pomlink = Links.first();
346 m.param.pword[1] = 0;
347 while (pomlink!=NULL)
349 if ( pomlink->node_number==n )
351 m.param.pword[1] = 1;
352 strcpy(m.param.pstr,pomlink->addr);
355 pomlink = Links.next();
357 write(sc,&m,sizeof(MESSAGE));
361 // ************* Internal message from kernel or INT *******************
363 void NETMOD::get_internal()
368 fd_set readset,writeset;
369 struct timeval tout={0,0};
371 struct sockaddr_un svr;
375 FD_ZERO(&readset);FD_ZERO(&writeset);
376 FD_SET(kernel_sock,&readset);
379 pomlink = Interpreters.first();
380 while (pomlink!=NULL)
382 FD_SET(pomlink->sock,&readset);
383 if (nrset<pomlink->sock) nrset=pomlink->sock;
384 pomlink=Interpreters.next();
387 if (select(nrset+1,&readset,&writeset,0,(struct timeval *)&tout)>0)
390 /* Check request sockets */
391 pomlink = Interpreters.first();
392 while (pomlink!=NULL)
394 if (FD_ISSET(pomlink->sock,&readset))
396 nr = read(pomlink->sock,&msg,sizeof(MESSAGE));
399 if (msg.msg_type == MSG_NET)
400 switch(msg.param.pword[0])
402 case NET_PROPAGATE:propagate_msg(&msg);break;
403 case NET_NODE_EXIST:check_node(msg.param.pword[1],pomlink->sock);break;
404 case NET_GET_INFO: conn_info(pomlink->sock);break;
405 case NET_NODES_NUM: msg.param.pword[0]=NET_NODES_NUM_RESPONSE;
406 msg.param.pword[1]=Links.count();
407 write(pomlink->sock,&msg,sizeof(MESSAGE));
412 pomlink=Interpreters.next();
415 /* Check internal socket */
416 if (FD_ISSET(kernel_sock,&readset))
418 nr = read(kernel_sock, &msg, sizeof(MESSAGE));
421 if (msg.msg_type == MSG_NET)
423 switch(msg.param.pword[0])
425 case NET_TRANSMIT_CODE:
426 transmit_file(msg.param.pword[2],msg.param.pstr,msg.param.pword[1]);
428 case NET_EXIT: { disconnect_seq();exit_sequence();}
430 case NET_GET_INFO: conn_info(kernel_sock);break;
431 case NET_PROPAGATE:propagate_msg(&msg);break;
432 case NET_DISCONNECT:disconnect_seq();
434 case NET_NODE_EXIST: check_node(msg.param.pword[1],kernel_sock);break;
435 case NET_CONNECT_TO: connect_seq(msg.param.pstr);
440 if (msg.msg_type == MSG_VLP)
441 switch(msg.param.pword[0])
445 pomlink = new INTlink;
446 pomlink->sock = socket(AF_UNIX,SOCK_STREAM,0);
447 bzero(&svr,sizeof(svr));
448 svr.sun_family = AF_UNIX;
449 strcpy(svr.sun_path,msg.param.pstr);
450 si = strlen(svr.sun_path)+sizeof(svr.sun_family);
451 sj = connect(pomlink->sock,(struct sockaddr*)&svr,si);
453 fcntl(pomlink->sock,F_SETFL, O_NONBLOCK|
454 fcntl(pomlink->sock,F_GETFL,0));
456 setsockopt(pomlink->sock,IPPROTO_TCP,TCP_NODELAY,(char*)&on,sizeof(on));
457 pomlink->ID = msg.param.pword[1];
458 pomlink->connected=TRUE;
459 Interpreters.append(pomlink);
462 case VLP_INTERPRETER_DOWN:
464 pomlink = findINTlink(msg.param.pword[1]);
467 close(pomlink->sock);
468 Interpreters.remove(pomlink);
481 void NETMOD::get_message(NETlink *lnk)
486 int rdbt,rd,sz,j,psock;
487 struct sockaddr_in svr;
488 unsigned char buffer[FILE_BUFFER_SIZE];
493 nr = read(lnk->sock,&msg, sizeof(MESSAGE));
497 if (msg.msg_type == MSG_NET)
499 switch(msg.param.pword[0])
503 lnk->code_transmit = TRUE;
504 sprintf(pomstr,"%s/%s",REMOTE_PATH,msg.param.pstr);
505 strcat(pomstr,".ccd");
506 lnk->CodeFile = fopen(pomstr,"wb");
507 if ( lnk->CodeFile == NULL) { write_at_console("Cannot open file\n");
508 lnk->code_transmit=FALSE;}
509 lnk->CodeSize=msg.param.pword[1];
510 psock = socket(AF_INET, SOCK_STREAM, 0);
511 bzero(&svr, sizeof(svr));
512 svr.sin_family = AF_INET;
513 svr.sin_port = htons(CODEPORT);
514 svr.sin_addr.s_addr = inet_addr(lnk->addr);
515 j = connect(psock, (struct sockaddr*)&svr, sizeof(svr));
518 //fcntl(psock, F_SETFL,O_NONBLOCK | fcntl(psock, F_GETFL,0));
520 while (sz<lnk->CodeSize)
522 rd = read(psock,&buffer,sizeof(buffer));
523 rdbt = fwrite(&buffer,sizeof(unsigned char),rd,lnk->CodeFile);
527 fclose(lnk->CodeFile);
534 lnk->code_transmit = TRUE;
535 sprintf(pomstr,"%s/%s",REMOTE_PATH,msg.param.pstr);
536 strcat(pomstr,".pcd");
537 lnk->CodeFile = fopen(pomstr,"wb");
538 if ( lnk->CodeFile == NULL) { write_at_console("Cannot open file\n");
539 lnk->code_transmit=FALSE;}
540 lnk->CodeSize=msg.param.pword[1];
541 psock = socket(AF_INET, SOCK_STREAM, 0);
542 bzero(&svr, sizeof(svr));
543 svr.sin_family = AF_INET;
544 svr.sin_port = htons(CODEPORT1);
545 svr.sin_addr.s_addr = inet_addr(lnk->addr);
546 j = connect(psock, (struct sockaddr*)&svr, sizeof(svr));
549 //fcntl(psock, F_SETFL,O_NONBLOCK | fcntl(psock, F_GETFL,0));
551 while (sz<lnk->CodeSize)
553 rd = read(psock,&proto,sizeof(proto));
554 rdbt = fwrite(&proto,sizeof(unsigned char),rd,lnk->CodeFile);
558 fclose(lnk->CodeFile);
565 sprintf(pomstr,"Node: %d Addr: %s",msg.param.pword[1],
567 lnk->node_number = msg.param.pword[1];
568 write_at_console(pomstr);
569 send_accept_info(lnk);
573 sprintf(pomstr,"Node: %d Addr: %s",msg.param.pword[1],
575 lnk->node_number = msg.param.pword[1];
576 write_at_console(pomstr);
580 sprintf(pomstr,"Node: %d disconnected",msg.param.pword[1]);
581 write_at_console(pomstr);
588 if (msg.param.pword[1] == MSG_VLP) send_to_kernel(&msg);
589 else if (msg.param.pword[1] == MSG_INT) send_to_int(&msg);
602 void NETMOD::remote_messages()
606 struct timeval tout={0,0};
609 FD_ZERO(&rset);FD_ZERO(&wset);
612 pomlink = Links.first();
613 while (pomlink!=NULL)
615 if (pomlink->connected)
617 FD_SET(pomlink->sock,&rset);
618 if (max<pomlink->sock) max=pomlink->sock;
620 pomlink=Links.next();
623 if (select(max+1,&rset,&wset,0,(struct timeval *)&tout)>0)
625 pomlink=Links.first();
626 while (pomlink!=NULL)
628 if (FD_ISSET(pomlink->sock,&rset)) get_message(pomlink);
629 pomlink=Links.next();
636 /****************************** 2010 ********************************************/
637 void NETMOD::doitall() {
639 int nsock,max=0,on, nr, si, sj;
640 struct sockaddr_in svr;
644 struct sockaddr_un svr2;
649 FD_SET(listen_sock,&rset);
651 FD_SET(kernel_sock,&rset);
652 if (max<kernel_sock) { max=kernel_sock;}
653 pomlink2 = Interpreters.first();
654 while (pomlink2!=NULL)
656 FD_SET(pomlink2->sock,&rset);
657 if (max<pomlink2->sock) max=pomlink2->sock;
658 pomlink2=Interpreters.next();
660 pomlink = Links.first();
661 while (pomlink!=NULL)
663 if (pomlink->connected)
665 FD_SET(pomlink->sock,&rset);
666 if (max<pomlink->sock) max=pomlink->sock;
668 pomlink=Links.next();
672 if (select(max+1,&rset,0,0,NULL) > 0) {
674 if (FD_ISSET(listen_sock,&rset))
676 /* accept connection on listen socket */
678 bzero(&svr, sizeof(svr));
679 nsock = accept(listen_sock, (struct sockaddr*)&svr, &sz);
682 pomlink = new NETlink;
683 strcpy(pomlink->addr,inet_ntoa(svr.sin_addr));
684 pomlink->sock = nsock;
685 pomlink->connected = TRUE;
686 fcntl(pomlink->sock, F_SETFL,O_NONBLOCK | fcntl(pomlink->sock,F_GETFL,0));
688 setsockopt(pomlink->sock,IPPROTO_TCP,TCP_NODELAY,(char*)&on,sizeof(on));
689 Links.append(pomlink);
693 // get internal message
694 /* Check request sockets */
695 pomlink2 = Interpreters.first();
696 while (pomlink2!=NULL)
698 if (FD_ISSET(pomlink2->sock,&rset))
700 nr = read(pomlink2->sock,&msg,sizeof(MESSAGE));
703 if (msg.msg_type == MSG_NET)
704 switch(msg.param.pword[0])
706 case NET_PROPAGATE:propagate_msg(&msg); break;
707 case NET_NODE_EXIST:check_node(msg.param.pword[1],pomlink2->sock);break;
708 case NET_GET_INFO: conn_info(pomlink2->sock);break;
709 case NET_NODES_NUM: msg.param.pword[0]=NET_NODES_NUM_RESPONSE;
710 msg.param.pword[1]=Links.count();
711 write(pomlink2->sock,&msg,sizeof(MESSAGE));
716 pomlink2=Interpreters.next();
718 /* Check internal socket */
719 if (FD_ISSET(kernel_sock,&rset))
721 nr = read(kernel_sock, &msg, sizeof(MESSAGE));
724 if (msg.msg_type == MSG_NET)
726 switch(msg.param.pword[0])
728 case NET_TRANSMIT_CODE:
730 transmit_file(msg.param.pword[2],msg.param.pstr,msg.param.pword[1]);
733 case NET_EXIT: { disconnect_seq();exit_sequence();}
735 case NET_GET_INFO: conn_info(kernel_sock);break;
736 case NET_PROPAGATE:propagate_msg(&msg);break;
737 case NET_DISCONNECT:disconnect_seq();
739 case NET_NODE_EXIST: check_node(msg.param.pword[1],kernel_sock);break;
740 case NET_CONNECT_TO: connect_seq(msg.param.pstr);
743 if (msg.msg_type == MSG_VLP)
744 switch(msg.param.pword[0])
749 pomlink2 = new INTlink;
750 pomlink2->sock = socket(AF_UNIX,SOCK_STREAM,0);
751 bzero(&svr2,sizeof(svr2));
752 svr2.sun_family = AF_UNIX;
753 strcpy(svr2.sun_path,msg.param.pstr);
754 si = strlen(svr2.sun_path)+sizeof(svr2.sun_family);
755 sj = connect(pomlink2->sock,(struct sockaddr*)&svr2,si);
757 fcntl(pomlink2->sock,F_SETFL, O_NONBLOCK|fcntl(pomlink2->sock,F_GETFL,0));
759 setsockopt(pomlink2->sock,IPPROTO_TCP,TCP_NODELAY,(char*)&on,sizeof(on));
760 pomlink2->ID = msg.param.pword[1];
761 pomlink2->connected=TRUE;
762 Interpreters.append(pomlink2);
765 case VLP_INTERPRETER_DOWN:
768 pomlink2 = findINTlink(msg.param.pword[1]);
771 close(pomlink2->sock);
772 Interpreters.remove(pomlink2);
779 // get remote message
781 pomlink=Links.first();
782 while (pomlink!=NULL)
784 if (FD_ISSET(pomlink->sock,&rset)) get_message(pomlink);
785 pomlink=Links.next();
791 /****************************** END 2010 ********************************************/
795 void NETMOD::propagate_msg(MESSAGE *msg)
800 pomlink = findNETlink(msg->param.pword[4]);
801 if ((pomlink!=NULL)&&(pomlink->connected))
802 send_to_node(pomlink,msg);
804 if (msg->param.pword[1]==MSG_INT)
810 sprintf(ss,"Not connected to Node %d",msg->param.pword[4]);
811 write_at_console(ss);
818 void NETMOD::connect_seq(char *a)
821 struct sockaddr_in svr;
828 if (strcmp(pom->addr,a)==0) return;
833 pom->connected = FALSE;
834 pom->sock = socket(AF_INET, SOCK_STREAM, 0);
835 bzero(&svr, sizeof(svr));
836 svr.sin_family = AF_INET;
837 svr.sin_port = htons(LOGPORT);
838 svr.sin_addr.s_addr = inet_addr(pom->addr);
839 j = connect(pom->sock, (struct sockaddr*)&svr, sizeof(svr));
841 { pom->connected = TRUE;
842 fcntl(pom->sock, F_SETFL,O_NONBLOCK | fcntl(pom->sock,
845 setsockopt(pom->sock,IPPROTO_TCP,TCP_NODELAY,(char*)&on,sizeof(on));
846 send_connect_info(pom);
849 else write_at_console("Connection failed");
852 void NETMOD::check_links()
856 struct sockaddr_in svr;
859 /* connect to all other nodes */
862 pomlink=Links.first();
863 while (pomlink!=NULL)
865 if ( !(pomlink->connected) )
867 bzero(&svr, sizeof(svr));
868 svr.sin_family = AF_INET;
869 svr.sin_port = htons(LOGPORT);
870 svr.sin_addr.s_addr = inet_addr(pomlink->addr);
872 j = connect(pomlink->sock, (struct sockaddr*)&svr, sizeof(svr));
874 { pomlink->connected = TRUE;
875 fcntl(pomlink->sock, F_SETFL,O_NONBLOCK | fcntl(pomlink->sock,
877 send_connect_info(pomlink);
880 if (errno == ECONNREFUSED)
881 sock_reopen(pomlink);
883 pomlink=Links.next();
888 pomlink=Links.first();
891 if (pomlink->connected==FALSE) {all_connected=FALSE;break;}
892 pomlink=Links.next();
897 void NETMOD::sock_reopen(NETlink *lnk)
902 lnk->sock = socket(AF_INET, SOCK_STREAM, 0);
903 fcntl(lnk->sock, F_SETFL,O_NONBLOCK | fcntl(lnk->sock,
905 setsockopt(lnk->sock,IPPROTO_TCP,TCP_NODELAY,(char*)&on,sizeof(on));
909 // **************** Acknowledges *************************
911 void NETMOD::send_connect_info(NETlink *lnk)
915 m.param.pword[0] = NET_CONNECT;
916 m.param.pword[1] = MyNode;
917 m.msg_type = MSG_NET;
920 write(lnk->sock,&m,sizeof(MESSAGE));
923 void NETMOD::send_accept_info(NETlink *lnk)
927 m.param.pword[0] = NET_ACCEPT;
928 m.param.pword[1] = MyNode;
929 m.msg_type = MSG_NET;
932 write(lnk->sock,&m,sizeof(MESSAGE));
935 void NETMOD::send_code_ack(NETlink *lnk)
939 m.param.pword[0] = NET_CODESTREAM_OK;
940 m.msg_type = MSG_NET;
943 write(lnk->sock,&m,sizeof(MESSAGE));
947 void NETMOD::send_to_all(MESSAGE *msg)
950 pomlink=Links.first();
951 while (pomlink!=NULL)
953 write(pomlink->sock,msg,sizeof(MESSAGE));
954 pomlink=Links.next();
965 /*accept_connection();
967 remote_messages(); */
973 void NETMOD::exit_sequence()
977 ::close(kernel_sock);
978 ::close(listen_sock);
980 pomlink = Links.first();
981 while (pomlink!=NULL)
983 ::close(pomlink->sock);
984 pomlink=Links.next();
989 void NETMOD::disconnect_seq()
994 bzero(&m,sizeof(MESSAGE));
995 m.msg_type = MSG_NET;
996 m.param.pword[0] = NET_DISCONNECT;
997 m.param.pword[1] = MyNode;
1014 NETlink *NETMOD::findNETlink(int node)
1017 pomlink=Links.first();
1018 while(pomlink!=NULL)
1020 if (pomlink->node_number == node) return(pomlink);
1021 pomlink=Links.next();
1026 INTlink *NETMOD::findINTlink(int id)
1029 pomlink=Interpreters.first();
1030 while(pomlink!=NULL)
1032 if (pomlink->ID == id) return(pomlink);
1033 pomlink=Interpreters.next();
1039 /* ---------------- Sending code to a remote node -------------- */
1041 void NETMOD::transmit_file(int ton, char *fname, int fromINT)
1047 unsigned char buffer[FILE_BUFFER_SIZE];
1052 struct sockaddr_in svr;
1056 // **************** CCD FILE
1063 fseek(f,0,SEEK_END);
1064 msg.param.pword[1] = ftell(f);
1068 strcpy(b,rindex(fname,'/'));
1069 for(i=0;i<strlen(b);i++)
1071 msg.param.pword[0] = NET_CCD_START;
1072 strcpy(msg.param.pstr,b);
1074 outlink = findNETlink(ton);
1075 if (outlink==NULL) exit(1);
1076 bzero(&svr,sizeof(svr));
1077 sock = socket(AF_INET,SOCK_STREAM,0);
1078 svr.sin_family = AF_INET;
1079 svr.sin_addr.s_addr = INADDR_ANY;
1080 svr.sin_port = htons(CODEPORT);
1081 bind(sock, (struct sockaddr*)&svr, sizeof(svr));
1083 send_to_node(outlink, &msg);
1085 FD_ZERO(&rset);FD_ZERO(&wset);
1087 if (select(sock+1,&rset,&wset,0,0))
1088 if (FD_ISSET(sock,&rset))
1089 tsock = accept(sock, (struct sockaddr*)&svr,&sz );
1095 i = fread(&buffer,1,sizeof(buffer),f);
1096 write(tsock,&buffer,i);
1097 FD_ZERO(&rset);FD_ZERO(&wset);
1098 FD_SET(tsock,&wset);
1099 select(tsock+1,&rset,&wset,0,0);
1107 sprintf(b,"Cannot open file to send %s\n",fname);
1108 write_at_console(b);
1112 // *************** PCD FILE
1119 fseek(f,0,SEEK_END);
1120 msg.param.pword[1] = ftell(f);
1124 strcpy(b,rindex(fname,'/'));
1125 for(i=0;i<strlen(b);i++)
1127 msg.param.pword[0] = NET_PCD_START;
1128 strcpy(msg.param.pstr,b);
1130 outlink = findNETlink(ton);
1131 if (outlink==NULL) exit(1);
1132 bzero(&svr,sizeof(svr));
1133 sock = socket(AF_INET,SOCK_STREAM,0);
1134 svr.sin_family = AF_INET;
1135 svr.sin_addr.s_addr = INADDR_ANY;
1136 svr.sin_port = htons(CODEPORT1);
1137 bind(sock, (struct sockaddr*)&svr, sizeof(svr));
1139 send_to_node(outlink, &msg);
1141 FD_ZERO(&rset);FD_ZERO(&wset);
1143 if (select(sock+1,&rset,&wset,0,0))
1144 if (FD_ISSET(sock,&rset))
1145 tsock = accept(sock, (struct sockaddr*)&svr,&sz );
1151 i = fread(&proto,1,sizeof(proto),f);
1152 write(tsock,&proto,i);
1153 FD_ZERO(&rset);FD_ZERO(&wset);
1154 FD_SET(tsock,&wset);
1155 select(tsock+1,&rset,&wset,0,0);
1163 sprintf(b,"Cannot open file to send %s\n",fname);
1164 write_at_console(b);
1168 msg.msg_type = MSG_NET;
1169 msg.param.pword[0] = NET_TRANSMITTED;
1170 msg.param.pword[1] = fromINT;
1171 send_to_kernel(&msg);
1178 void NETMOD::conn_info(int sk)
1185 m.msg_type = MSG_NET;
1186 m.param.pword[0] = NET_INFO;
1187 strcpy(m.param.pstr,"");
1191 sprintf(poms,"%d=%s;",pom->node_number,pom->addr);
1192 strcat(m.param.pstr,poms);
1196 m.param.pword[1]=12;
1197 write(sk,&m,sizeof(MESSAGE));
1205 write(sk,&m,sizeof(MESSAGE));
1207 m.msg_type = MSG_NET;
1208 m.param.pword[0] = NET_INFO_END;
1209 write(sk,&m,sizeof(MESSAGE));
1212 int main(int argc,char **argv)
1214 NETMOD netter(argv[1]);