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 ********************/
52 /********************* Network slot ********************/
73 for(i = 0; i < 5; i++)
78 code_transmit = FALSE;
81 /*********************** NET Module *****************************/
93 /* List of the Interpeter slots */
94 QList<INTlink> Interpreters;
95 /* List of the Network slots */
100 void load_config(char*);
101 void write_at_console(char*);
102 void send_to_kernel(MESSAGE*);
103 void sock_reopen(NETlink*);
104 void send_connect_info(NETlink*);
105 void send_accept_info(NETlink*);
106 void send_to_node(NETlink*, MESSAGE*);
107 void send_to_int(MESSAGE*);
108 void send_code_ack(NETlink*);
109 void send_to_all(MESSAGE *);
111 NETlink *findNETlink(int node);
112 INTlink *findINTlink(int id);
113 void transmit_file(int ton, char *fname, int fromINT);
114 void propagate_msg(MESSAGE *msg);
115 void check_node(int, int);
118 void exit_sequence();
119 void disconnect_seq();
120 void connect_seq(char*);
121 void accept_connection();
123 void remote_messages();
125 void get_message(NETlink*);
132 NETMOD::NETMOD(char *kernel_name)
137 struct sockaddr_in svr;
138 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,
156 all_connected = FALSE;
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,
171 m.msg_type = MSG_NET;
172 m.param.pword[0] = NET_NODE;
173 m.param.pword[1] = MyNode;
176 /* if (regme) regme_sequence();*/
178 if (to_connect > 0) {
179 write_at_console("Connecting remote VLPs...");
180 while (!all_connected) {
184 sprintf(s, "Local node number %d", MyNode);
188 /*##################### Load configuration ##########################*/
190 void NETMOD::load_config(char *fname)
193 config_setting_t *setting;
200 /* Hack for checking if file exists without using external libs.*/
201 FILE * file = fopen(fname, "rt");
203 fprintf(stderr, "Error: Cannot load configuration file %s!\n",
205 write_at_console("Cannot load configuration file!");
210 /* Read the file. If there is an error, report it and exit. */
211 if (!config_read(&cfg, file)) {
212 fprintf(stderr, "%s: In file %s, line %d\n",
213 config_error_text(&cfg),
214 config_error_file(&cfg),
215 config_error_line(&cfg));
216 config_destroy(&cfg);
218 /* from original code. */
222 setting = config_lookup(&cfg, "node_number");
224 MyNode = config_setting_get_int(setting);
227 if (!setting || MyNode == -1) {
228 fprintf(stderr, "%s! In file %s, '%s' was not found.\n",
229 "Error", fname, "node_number");
230 write_at_console("Node number must be specified");
231 config_destroy(&cfg);
236 setting = config_lookup(&cfg, "host");
239 pomlink = new NETlink;
241 switch(config_setting_type(setting)) {
242 /* TODO: Deprecated. Made for back compatibility. */
243 case CONFIG_TYPE_STRING:
244 strncpy(pomlink->addr,
245 config_setting_get_string(setting), 255);
247 case CONFIG_TYPE_ARRAY:
248 strncpy(pomlink->addr,
249 config_setting_get_string_elem(setting, 0),
253 fprintf(stderr, "%s! In file %s, bad entry type for %s."
254 " Will not be read.\n",
255 "Fatal error", fname, "host");
256 config_destroy(&cfg);
260 pomlink->connected = FALSE;
261 pomlink->sock = socket(AF_INET, SOCK_STREAM, 0);
262 fcntl(pomlink->sock, F_SETFL,O_NONBLOCK |
263 fcntl(pomlink->sock, F_GETFL, 0));
265 setsockopt(pomlink->sock, IPPROTO_TCP, TCP_NODELAY, (char*)&on,
267 Links.append(pomlink);
270 fprintf(stderr, "%s! In file %s, '%s' was not found.\n",
271 "Warning", fname, "host");
274 config_destroy(&cfg);
278 all_connected = TRUE;
282 void NETMOD::write_at_console(char *s)
286 msg.msg_type = MSG_NET;
287 msg.param.pword[0] = NET_CSWRITELN;
288 strcpy(msg.param.pstr, s);
289 send_to_kernel(&msg);
293 * Sends message to kernel
294 * @param msg Message to send.
296 void NETMOD::send_to_kernel(MESSAGE *msg)
298 write(kernel_sock, msg, sizeof(MESSAGE));
302 * Sends message to given node
303 * @param lnk Interpreter link.
304 * @param msg Message to send.
306 void NETMOD::send_to_node(NETlink *lnk, MESSAGE *msg)
308 msg->msg_type = MSG_NET;
309 /* msg2netmsg(msg);*/
311 write(lnk->sock, msg, sizeof(MESSAGE));
316 * Sends message to interpreter
317 * @param msg Message to send.
319 void NETMOD::send_to_int(MESSAGE *msg)
323 pomlink = findINTlink(msg->param.pword[5]);
324 if (pomlink != NULL) {
325 write(pomlink->sock, msg, sizeof(MESSAGE));
329 void NETMOD::accept_connection()
334 struct sockaddr_in svr;
337 struct timeval tout = {0, 0};
342 FD_SET(listen_sock, &rset);
344 if (select(listen_sock + 1, &rset, &wset, 0, (struct timeval *)&tout) >
346 if (FD_ISSET(listen_sock,&rset)) {
347 /* accept connection on listen socket */
349 bzero(&svr, sizeof(svr));
350 nsock = accept(listen_sock, (struct sockaddr*)&svr,
355 /* i<0 someone wants to connect us */
356 pomlink = new NETlink;
357 strcpy(pomlink->addr, inet_ntoa(svr.sin_addr));
358 pomlink->sock = nsock;
359 pomlink->connected = TRUE;
360 fcntl(pomlink->sock, F_SETFL, O_NONBLOCK |
361 fcntl(pomlink->sock, F_GETFL,0));
363 setsockopt(pomlink->sock, IPPROTO_TCP,
364 TCP_NODELAY, (char*)&on, sizeof(on));
365 Links.append(pomlink);
372 void NETMOD::check_node(int n, int sc)
377 m.msg_type = MSG_NET;
378 m.param.pword[0] = NET_NODE_EXIST;
380 pomlink = Links.first();
381 m.param.pword[1] = 0;
382 while (pomlink != NULL) {
383 if (pomlink->node_number == n) {
384 m.param.pword[1] = 1;
385 strcpy(m.param.pstr, pomlink->addr);
388 pomlink = Links.next();
390 write(sc, &m, sizeof(MESSAGE));
395 * Internal message from kernel or INT
397 void NETMOD::get_internal()
406 struct timeval tout={0, 0};
408 struct sockaddr_un svr;
412 FD_SET(kernel_sock, &readset);
415 pomlink = Interpreters.first();
416 while (pomlink != NULL) {
417 FD_SET(pomlink->sock, &readset);
418 if (nrset < pomlink->sock) {
419 nrset = pomlink->sock;
421 pomlink = Interpreters.next();
424 if (select(nrset + 1, &readset, &writeset, 0, (struct timeval *)&tout) >
427 /* Check request sockets */
428 pomlink = Interpreters.first();
429 while (pomlink != NULL) {
430 if (FD_ISSET(pomlink->sock, &readset)) {
431 nr = read(pomlink->sock, &msg, sizeof(MESSAGE));
433 if (msg.msg_type == MSG_NET) {
434 switch(msg.param.pword[0]) {
439 check_node(msg.param.pword[1], pomlink->sock);
442 conn_info(pomlink->sock);
445 msg.param.pword[0] = NET_NODES_NUM_RESPONSE;
446 msg.param.pword[1] = Links.count();
447 write(pomlink->sock, &msg, sizeof(MESSAGE));
453 pomlink=Interpreters.next();
456 /* Check internal socket */
457 if (FD_ISSET(kernel_sock,&readset)) {
458 nr = read(kernel_sock, &msg, sizeof(MESSAGE));
460 if (msg.msg_type == MSG_NET) {
461 switch(msg.param.pword[0]) {
462 case NET_TRANSMIT_CODE:
463 transmit_file(msg.param.pword[2],
472 conn_info(kernel_sock);
481 check_node(msg.param.pword[1], kernel_sock);
484 connect_seq(msg.param.pstr);
488 if (msg.msg_type == MSG_VLP) {
489 switch(msg.param.pword[0]) {
491 pomlink = new INTlink;
492 pomlink->sock = socket(AF_UNIX, SOCK_STREAM, 0);
493 bzero(&svr,sizeof(svr));
494 svr.sun_family = AF_UNIX;
495 strcpy(svr.sun_path, msg.param.pstr);
496 si = strlen(svr.sun_path) + sizeof(svr.sun_family);
497 sj = connect(pomlink->sock, (struct sockaddr*)&svr, si);
499 fcntl(pomlink->sock, F_SETFL, O_NONBLOCK | fcntl(pomlink->sock, F_GETFL, 0));
501 setsockopt(pomlink->sock, IPPROTO_TCP, TCP_NODELAY, (char*)&on, sizeof(on));
502 pomlink->ID = msg.param.pword[1];
503 pomlink->connected=TRUE;
504 Interpreters.append(pomlink);
507 case VLP_INTERPRETER_DOWN: {
508 pomlink = findINTlink(msg.param.pword[1]);
509 if (pomlink != NULL) {
510 close(pomlink->sock);
511 Interpreters.remove(pomlink);
523 void NETMOD::get_message(NETlink *lnk)
533 struct sockaddr_in svr;
534 unsigned char buffer[FILE_BUFFER_SIZE];
537 if (lnk->connected) {
538 nr = read(lnk->sock, &msg, sizeof(MESSAGE));
540 /* netmsg2msg(&msg); */
541 if (msg.msg_type == MSG_NET) {
542 switch(msg.param.pword[0]) {
544 lnk->code_transmit = TRUE;
545 sprintf(pomstr, "%s/%s", REMOTE_PATH, msg.param.pstr);
546 strcat(pomstr,".ccd");
547 lnk->CodeFile = fopen(pomstr, "wb");
548 if (lnk->CodeFile == NULL) {
549 write_at_console("Cannot open file\n");
550 lnk->code_transmit = FALSE;
552 lnk->CodeSize = msg.param.pword[1];
553 psock = socket(AF_INET, SOCK_STREAM, 0);
554 bzero(&svr, sizeof(svr));
555 svr.sin_family = AF_INET;
556 svr.sin_port = htons(CODEPORT);
557 svr.sin_addr.s_addr = inet_addr(lnk->addr);
558 j = connect(psock, (struct sockaddr*)&svr, sizeof(svr));
560 /*fcntl(psock, F_SETFL,O_NONBLOCK | fcntl(psock, F_GETFL,0));*/
562 while (sz < lnk->CodeSize) {
563 rd = read(psock, &buffer, sizeof(buffer));
564 rdbt = fwrite(&buffer, sizeof(unsigned char), rd, lnk->CodeFile);
568 fclose(lnk->CodeFile);
572 lnk->code_transmit = TRUE;
573 sprintf(pomstr, "%s/%s", REMOTE_PATH, msg.param.pstr);
574 strcat(pomstr, ".pcd");
575 lnk->CodeFile = fopen(pomstr, "wb");
576 if (lnk->CodeFile == NULL) {
577 write_at_console("Cannot open file\n");
578 lnk->code_transmit = FALSE;
580 lnk->CodeSize = msg.param.pword[1];
581 psock = socket(AF_INET, SOCK_STREAM, 0);
582 bzero(&svr, sizeof(svr));
583 svr.sin_family = AF_INET;
584 svr.sin_port = htons(CODEPORT1);
585 svr.sin_addr.s_addr = inet_addr(lnk->addr);
586 j = connect(psock, (struct sockaddr*)&svr, sizeof(svr));
588 /*fcntl(psock, F_SETFL,O_NONBLOCK | fcntl(psock, F_GETFL,0));*/
590 while (sz < lnk->CodeSize) {
591 rd = read(psock, &proto, sizeof(proto));
592 rdbt = fwrite(&proto, sizeof(unsigned char), rd, lnk->CodeFile);
596 fclose(lnk->CodeFile);
600 sprintf(pomstr, "Node: %d Addr: %s",
601 msg.param.pword[1], lnk->addr);
602 lnk->node_number = msg.param.pword[1];
603 write_at_console(pomstr);
604 send_accept_info(lnk);
607 sprintf(pomstr, "Node: %d Addr: %s",
608 msg.param.pword[1], lnk->addr);
609 lnk->node_number = msg.param.pword[1];
610 write_at_console(pomstr);
613 sprintf(pomstr,"Node: %d disconnected",
615 write_at_console(pomstr);
621 if (msg.param.pword[1] == MSG_VLP) {
622 send_to_kernel(&msg);
623 } else if (msg.param.pword[1] == MSG_INT) {
636 void NETMOD::remote_messages()
640 struct timeval tout={0, 0};
647 pomlink = Links.first();
648 while (pomlink != NULL) {
649 if (pomlink->connected) {
650 FD_SET(pomlink->sock, &rset);
651 if (max < pomlink->sock){
655 pomlink=Links.next();
658 if (select(max + 1, &rset, &wset, 0, (struct timeval *)&tout) > 0) {
659 pomlink=Links.first();
660 while (pomlink!=NULL) {
661 if (FD_ISSET(pomlink->sock,&rset)) {
662 get_message(pomlink);
664 pomlink=Links.next();
669 /******************************2010********************************************/
670 void NETMOD::doitall() {
672 int nsock,max = 0, on, nr, si, sj;
673 struct sockaddr_in svr;
677 struct sockaddr_un svr2;
681 FD_SET(listen_sock, &rset);
683 FD_SET(kernel_sock, &rset);
684 if (max < kernel_sock) {
687 pomlink2 = Interpreters.first();
688 while (pomlink2 != NULL) {
689 FD_SET(pomlink2->sock, &rset);
690 if (max < pomlink2->sock) {
693 pomlink2 = Interpreters.next();
695 pomlink = Links.first();
696 while (pomlink != NULL) {
697 if (pomlink->connected) {
698 FD_SET(pomlink->sock, &rset);
699 if (max < pomlink->sock) {
703 pomlink=Links.next();
707 if (select(max + 1, &rset, 0, 0, NULL) > 0) {
708 /* accept connection */
709 if (FD_ISSET(listen_sock,&rset)) {
710 /* accept connection on listen socket */
712 bzero(&svr, sizeof(svr));
713 nsock = accept(listen_sock, (struct sockaddr*)&svr, &sz);
715 pomlink = new NETlink;
716 strcpy(pomlink->addr, inet_ntoa(svr.sin_addr));
717 pomlink->sock = nsock;
718 pomlink->connected = TRUE;
719 fcntl(pomlink->sock, F_SETFL,O_NONBLOCK |
720 fcntl(pomlink->sock, F_GETFL, 0));
722 setsockopt(pomlink->sock, IPPROTO_TCP, TCP_NODELAY, (char*)&on, sizeof(on));
723 Links.append(pomlink);
727 /* get internal message*/
728 /* Check request sockets */
729 pomlink2 = Interpreters.first();
730 while (pomlink2 != NULL) {
731 if (FD_ISSET(pomlink2->sock,&rset)) {
732 nr = read(pomlink2->sock, &msg, sizeof(MESSAGE));
734 if (msg.msg_type == MSG_NET) {
735 switch(msg.param.pword[0]) {
740 check_node(msg.param.pword[1], pomlink2->sock);
743 conn_info(pomlink2->sock);
746 msg.param.pword[0] = NET_NODES_NUM_RESPONSE;
747 msg.param.pword[1] = Links.count();
748 write(pomlink2->sock, &msg, sizeof(MESSAGE));
754 pomlink2 = Interpreters.next();
757 /* Check internal socket */
758 if (FD_ISSET(kernel_sock, &rset)) {
759 nr = read(kernel_sock, &msg, sizeof(MESSAGE));
761 if (msg.msg_type == MSG_NET) {
762 switch(msg.param.pword[0]) {
763 case NET_TRANSMIT_CODE:
764 transmit_file(msg.param.pword[2], msg.param.pstr, msg.param.pword[1]);
771 conn_info(kernel_sock);
780 check_node(msg.param.pword[1], kernel_sock);
783 connect_seq(msg.param.pstr);
786 if (msg.msg_type == MSG_VLP) {
787 switch(msg.param.pword[0]) {
789 pomlink2 = new INTlink;
790 pomlink2->sock = socket(AF_UNIX, SOCK_STREAM, 0);
791 bzero(&svr2, sizeof(svr2));
792 svr2.sun_family = AF_UNIX;
793 strcpy(svr2.sun_path, msg.param.pstr);
794 si = strlen(svr2.sun_path) + sizeof(svr2.sun_family);
795 sj = connect(pomlink2->sock,(struct sockaddr*)&svr2, si);
797 fcntl(pomlink2->sock,F_SETFL, O_NONBLOCK | fcntl(pomlink2->sock, F_GETFL, 0));
799 setsockopt(pomlink2->sock, IPPROTO_TCP, TCP_NODELAY, (char*)&on, sizeof(on));
800 pomlink2->ID = msg.param.pword[1];
801 pomlink2->connected = TRUE;
802 Interpreters.append(pomlink2);
805 case VLP_INTERPRETER_DOWN: {
806 pomlink2 = findINTlink(msg.param.pword[1]);
807 if (pomlink2 != NULL) {
808 close(pomlink2->sock);
809 Interpreters.remove(pomlink2);
818 /* get remote message*/
820 pomlink=Links.first();
821 while (pomlink != NULL) {
822 if (FD_ISSET(pomlink->sock, &rset))
823 get_message(pomlink);
824 pomlink=Links.next();
828 /****************************** END 2010 **************************************/
832 void NETMOD::propagate_msg(MESSAGE *msg)
837 pomlink = findNETlink(msg->param.pword[4]);
838 if ((pomlink != NULL) && (pomlink->connected))
839 send_to_node(pomlink, msg);
841 if (msg->param.pword[1] == MSG_INT) {
844 sprintf(ss, "Not connected to Node %d",
845 msg->param.pword[4]);
846 write_at_console(ss);
851 void NETMOD::connect_seq(char *a)
854 struct sockaddr_in svr;
858 while (pom != NULL) {
859 if (strcmp(pom->addr, a) == 0)
864 strcpy(pom->addr, a);
865 pom->connected = FALSE;
866 pom->sock = socket(AF_INET, SOCK_STREAM, 0);
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(pom->addr);
871 j = connect(pom->sock, (struct sockaddr*)&svr, sizeof(svr));
873 pom->connected = TRUE;
874 fcntl(pom->sock, F_SETFL, O_NONBLOCK | fcntl(pom->sock, F_GETFL,
877 setsockopt(pom->sock, IPPROTO_TCP, TCP_NODELAY, (char*)&on,
879 send_connect_info(pom);
882 write_at_console("Connection failed");
886 void NETMOD::check_links()
889 struct sockaddr_in svr;
892 /* connect to all other nodes */
893 if (!all_connected) {
894 pomlink = Links.first();
895 while (pomlink != NULL) {
896 if (!(pomlink->connected)) {
897 bzero(&svr, sizeof(svr));
898 svr.sin_family = AF_INET;
899 svr.sin_port = htons(LOGPORT);
900 svr.sin_addr.s_addr = inet_addr(pomlink->addr);
902 j = connect(pomlink->sock,
903 (struct sockaddr*)&svr, sizeof(svr));
905 pomlink->connected = TRUE;
906 fcntl(pomlink->sock, F_SETFL, O_NONBLOCK
907 | fcntl(pomlink->sock, F_GETFL,
909 send_connect_info(pomlink);
911 if (errno == ECONNREFUSED) {
912 sock_reopen(pomlink);
914 } /* not connected */
915 pomlink = Links.next();
918 all_connected = TRUE;
919 pomlink = Links.first();
920 while(pomlink != NULL) {
921 if (pomlink->connected == FALSE) {
922 all_connected = FALSE;
925 pomlink = Links.next();
929 void NETMOD::sock_reopen(NETlink *lnk)
934 lnk->sock = socket(AF_INET, SOCK_STREAM, 0);
935 fcntl(lnk->sock, F_SETFL,O_NONBLOCK | fcntl(lnk->sock, F_GETFL, 0));
936 setsockopt(lnk->sock, IPPROTO_TCP,TCP_NODELAY, (char*)&on, sizeof(on));
939 /***************** Acknowledges **************************/
941 void NETMOD::send_connect_info(NETlink *lnk)
945 m.param.pword[0] = NET_CONNECT;
946 m.param.pword[1] = MyNode;
947 m.msg_type = MSG_NET;
950 write(lnk->sock, &m, sizeof(MESSAGE));
953 void NETMOD::send_accept_info(NETlink *lnk)
957 m.param.pword[0] = NET_ACCEPT;
958 m.param.pword[1] = MyNode;
959 m.msg_type = MSG_NET;
962 write(lnk->sock, &m, sizeof(MESSAGE));
965 void NETMOD::send_code_ack(NETlink *lnk)
969 m.param.pword[0] = NET_CODESTREAM_OK;
970 m.msg_type = MSG_NET;
973 write(lnk->sock, &m, sizeof(MESSAGE));
976 void NETMOD::send_to_all(MESSAGE *msg)
979 pomlink = Links.first();
980 while (pomlink != NULL) {
981 write(pomlink->sock, msg, sizeof(MESSAGE));
982 pomlink = Links.next();
999 void NETMOD::exit_sequence()
1003 ::close(kernel_sock);
1004 ::close(listen_sock);
1006 pomlink = Links.first();
1007 while (pomlink != NULL) {
1008 ::close(pomlink->sock);
1009 pomlink = Links.next();
1014 void NETMOD::disconnect_seq()
1019 bzero(&m, sizeof(MESSAGE));
1020 m.msg_type = MSG_NET;
1021 m.param.pword[0] = NET_DISCONNECT;
1022 m.param.pword[1] = MyNode;
1026 send_to_node(p, &m);
1037 NETlink * NETMOD::findNETlink(int node)
1040 pomlink = Links.first();
1041 while(pomlink != NULL) {
1042 if (pomlink->node_number == node)
1045 pomlink = Links.next();
1050 INTlink * NETMOD::findINTlink(int id)
1053 pomlink = Interpreters.first();
1054 while(pomlink != NULL) {
1055 if (pomlink->ID == id)
1057 pomlink = Interpreters.next();
1064 * Sending code to a remote node
1066 void NETMOD::transmit_file(int ton, char *fname, int fromINT)
1072 unsigned char buffer[FILE_BUFFER_SIZE];
1077 struct sockaddr_in svr;
1081 /***************** CCD FILE */
1084 f = fopen(fn, "rb");
1086 fseek(f, 0, SEEK_END);
1087 msg.param.pword[1] = ftell(f);
1089 f = fopen(fn, "rb");
1091 strcpy(b, rindex(fname, '/'));
1092 for(i = 0; i < strlen(b); i++)
1095 msg.param.pword[0] = NET_CCD_START;
1096 strcpy(msg.param.pstr, b);
1098 outlink = findNETlink(ton);
1099 if (outlink == NULL)
1101 bzero(&svr, sizeof(svr));
1102 sock = socket(AF_INET, SOCK_STREAM, 0);
1103 svr.sin_family = AF_INET;
1104 svr.sin_addr.s_addr = INADDR_ANY;
1105 svr.sin_port = htons(CODEPORT);
1106 bind(sock, (struct sockaddr*)&svr, sizeof(svr));
1108 send_to_node(outlink, &msg);
1112 FD_SET(sock, &rset);
1113 if (select(sock + 1, &rset, &wset, 0, 0))
1114 if (FD_ISSET(sock,&rset))
1115 tsock = accept(sock, (struct sockaddr*)&svr,
1120 i = fread(&buffer, 1, sizeof(buffer), f);
1121 write(tsock, &buffer, i);
1124 FD_SET(tsock, &wset);
1125 select(tsock + 1, &rset, &wset, 0, 0);
1132 sprintf(b, "Cannot open file to send %s\n", fname);
1133 write_at_console(b);
1137 /**************** PCD FILE */
1143 fseek(f, 0, SEEK_END);
1144 msg.param.pword[1] = ftell(f);
1146 f = fopen(fn, "rb");
1148 strcpy(b, rindex(fname, '/'));
1149 for(i = 0; i < strlen(b); i++)
1151 msg.param.pword[0] = NET_PCD_START;
1152 strcpy(msg.param.pstr, b);
1154 outlink = findNETlink(ton);
1155 if (outlink == NULL)
1157 bzero(&svr, sizeof(svr));
1158 sock = socket(AF_INET, SOCK_STREAM, 0);
1159 svr.sin_family = AF_INET;
1160 svr.sin_addr.s_addr = INADDR_ANY;
1161 svr.sin_port = htons(CODEPORT1);
1162 bind(sock, (struct sockaddr*)&svr, sizeof(svr));
1164 send_to_node(outlink, &msg);
1168 FD_SET(sock, &rset);
1169 if (select(sock + 1, &rset, &wset, 0, 0))
1170 if (FD_ISSET(sock, &rset))
1171 tsock = accept(sock, (struct sockaddr*)&svr,
1176 i = fread(&proto, 1, sizeof(proto), f);
1177 write(tsock, &proto, i);
1180 FD_SET(tsock, &wset);
1181 select(tsock + 1, &rset, &wset, 0, 0);
1188 sprintf(b, "Cannot open file to send %s\n", fname);
1189 write_at_console(b);
1192 msg.msg_type = MSG_NET;
1193 msg.param.pword[0] = NET_TRANSMITTED;
1194 msg.param.pword[1] = fromINT;
1195 send_to_kernel(&msg);
1198 void NETMOD::conn_info(int sk)
1205 m.msg_type = MSG_NET;
1206 m.param.pword[0] = NET_INFO;
1207 strcpy(m.param.pstr, "");
1208 pom = Links.first();
1209 while (pom != NULL) {
1210 sprintf(poms, "%d=%s;", pom->node_number, pom->addr);
1211 strcat(m.param.pstr, poms);
1214 m.param.pword[1] = 12;
1215 write(sk, &m, sizeof(MESSAGE));
1221 m.param.pword[1] = k;
1222 write(sk, &m, sizeof(MESSAGE));
1224 m.msg_type = MSG_NET;
1225 m.param.pword[0] = NET_INFO_END;
1226 write(sk, &m, sizeof(MESSAGE));
1229 int main(int argc, char **argv)
1231 NETMOD netter(argv[1]);