1 /*************************************************************/
2 /* FGD.C by Oliver Delise */
4 /* e-mail: delise@mail.isis.de */
5 /* www: http://www.isis.de/members/~odelise/progs/flightgear */
8 /* The author of this program offers no waranty at all */
9 /* about the correct execution of this software material. */
10 /* Furthermore, the author can NOT be held responsible for */
11 /* any physical or moral damage caused by the use of this */
14 /* This is a standalone Tool to communicate with any */
15 /* FlightGear System and FGFS-Deamon. */
16 /* This is Open Source Software with some parts */
17 /* shamelessly stolen from others... */
19 /* -> This program will use a TCP port listening on a */
20 /* remote or local host inside the range you give to it. */
21 /* I offer no warranty over the accuracy though :) */
22 /* There are 3 verbose modes: No info, service info, and */
23 /* full info. No info is good of you only want the list */
24 /* of the ports, no more info. The best mode is Full */
25 /* info, as you get error information,etc. The main */
26 /* output is STDOUT, and ALL the errors go to STDERR. */
28 /* History: v0.1pre-alpha: May 25 1999 -> First release */
29 /* v0.1-alpha : Nov 08 1999 */
30 /* v0.1-beta : Jan 16 2000 */
31 /* libc5, glibc-2.0, 2.1 cleanups */
32 /* June 8 2000 socket cleanup */
33 /*************************************************************/
37 #include <sys/socket.h>
38 #include <sys/types.h>
39 #include <netinet/in.h>
44 #include <sys/utsname.h>
50 int maxfd, nready, retval;
52 struct utsname myname;
53 char *fgd_host, *src_host;
56 int verbose, fgd_len_msg;
58 /* List-stuff (doubly-Linked-list) */
62 int i, j, fgd_cnt, fgd_curpos;
67 float sgFGD_COORD[4][4];
70 unsigned char ipadr[16], callsign[16];
71 unsigned char lat[8], lon[8], alt[8], speed[8], roll[8], pitch[8], yaw[8];
72 float latf, lonf, altf, speedf, rollf, pitchf, yawf;
73 float sgFGD_COORD[4][4];
74 struct list_ele *next, *prev;
77 struct list_ele *head, *tail, *act, *test, *incoming; /* fgd_msg; */
79 struct fgd_sock_list {
84 struct fgd_sock_list fgd_cli_list[255];
85 int fgd_known_cli = -1; /* False */
88 /*...Create head and tail of list */
89 void list_init( void) {
90 incoming = (struct list_ele*) malloc(sizeof(struct list_ele));
91 head = (struct list_ele*) malloc(sizeof(struct list_ele));
92 tail = (struct list_ele*) malloc(sizeof(struct list_ele));
93 if (head == NULL || tail == NULL) { printf("Out of memory\n"); exit(1); }
94 /* fixme :Where is the "with foobar do command "
95 head->ipadr = "127.0.0.0";
96 strcpy(head->callsign, "None");
104 /* yaw!. Who the f$%& invented this ;-) */
106 tail->ipadr[0] = 255;
108 head->prev = tail->prev = head;
109 head->next = tail->next = tail;
110 act = head; /* put listpointer to beginning of list */
113 void list_output( void) {
116 void list_search( char name[16]) {
118 if (strcmp(name, head->next->ipadr) <= 0) act = head;
119 else if (strcmp(name, tail->prev->ipadr) > 0) act = tail->prev;
121 int vergleich = strcmp(name, act->ipadr);
123 while (strcmp(name, act->next->ipadr) > 0) {
126 else if (vergleich < 0)
127 while (strcmp(name, act->ipadr) < 0) {
131 while (strcmp(name, act->ipadr) == 0) {
137 void list_insert( char newip[16]) {
138 struct list_ele *new_ele;
140 new_ele = (struct list_ele*) malloc(sizeof(struct list_ele));
141 if (new_ele == NULL) { printf("Out of memory\n"); exit(1); }
142 strcpy(new_ele->ipadr, newip);
143 /* setting default */
144 strcpy(new_ele->callsign, "not assigned");
147 new_ele->next = act->next;
148 act->next->prev = act->next = new_ele;
151 void list_setval( char newip[16]) {
154 strcpy( act->next->callsign, incoming->callsign);
155 act->next->latf = incoming->latf;
156 act->next->lonf = incoming->lonf;
157 act->next->altf = incoming->altf;
158 act->next->speedf = incoming->speedf;
159 act->next->rollf = incoming->rollf;
160 act->next->pitchf = incoming->pitchf;
161 act->next->yawf = incoming->yawf;
162 printf("Callsign %s ", act->next->callsign);
163 printf(" lat: %7.3f lon: %7.3f alt: %7.3f speed: %7.3f roll: %7.3f pitch: %7.3f yaw: %7.3f",
164 act->next->latf, act->next->lonf, act->next->altf, act->next->speedf,
165 act->next->rollf, act->next->pitchf, act->next->yawf);
168 void list_setval_Mat4( char newip[16]) {
171 strcpy( act->next->callsign, incoming->callsign);
174 act->next->sgFGD_COORD[i][j] = incoming->sgFGD_COORD[i][j];
175 printf("Callsign %s ", act->next->callsign);
179 void list_clear( char clrip[16]) {
180 struct list_ele *clr_ele;
183 if ( strcmp( clrip, act->next->ipadr))
184 printf("....Name %s nicht vorhanden", clrip);
187 act->next = act->next->next;
188 act->next->prev = act;
194 int list_not_in( char name[16]) {
198 while ((test != tail) && (i==True)) {
199 i = (strcmp(test->ipadr, name) ? True : False);
201 if (verbose != 0) printf("list_not_in : %d\n",i);
216 struct { char *adr, *lon, *lat, *alt;} fgd_client;
219 struct sockaddr_in address;
220 struct sockaddr_in my_address;
222 socklen_t size = sizeof(address);
226 int current_port = 0;
227 u_short base_port = 0;
228 u_short end_port = 1024;
229 struct hostent *host_info;
230 struct servent *service_info;
234 int main(int argc, char **argv)
237 fprintf(stderr,"Usage: fgd [start port] [end port] [name] <-v or -vv>\n");
242 case 5: if (!strcmp(argv[4],"-v"))
244 else if (!strcmp(argv[4],"-vv"))
246 else { fprintf(stderr,"Usage: fgd [start port] [end port] [name] <-v or -vv>\n");
249 case 4: base_port = (u_short)atoi(argv[1]);
250 end_port = (u_short)atoi(argv[2]);
253 default: fprintf(stderr,"Usage: fgd [start port] [end port] [name] <-v or -vv>\n");
258 bzero((char *)&address, sizeof(address));
259 address.sin_family = AF_INET;
260 if (uname(&myname) == 0) fgd_host = myname.nodename;
261 printf(" I am running as %s on HOST %s\n", fgd_name, fgd_host);
263 if (verbose == 2) printf(" Resolving: %s ->",fgd_host);
264 if (host_info = gethostbyname(fgd_host)) {
265 bcopy(host_info->h_addr, (char *)&address.sin_addr,host_info->h_length);
266 printf(" fgd : ip = %s\n", inet_ntoa( address.sin_addr));
268 if (verbose == 2) printf(" resolved\n");
269 } else if ((address.sin_addr.s_addr = inet_addr(fgd_host)) == INADDR_NONE) {
270 fprintf(stderr,"Could not get %s host entry !\n",argv[1]);
271 printf(" NOT resolved !!!\n");
273 } else if (verbose == 2) printf(" address valid\n");
275 if ((base_port > end_port) || ((short)base_port < 0)) {
276 fprintf(stderr,"Bad port range : start=%d end=%d !\n");
278 } else if (verbose == 2) {
279 printf(" Port range: %d to %d\n",base_port,end_port);
281 printf(" verbose: %d\n",verbose);
282 /* some init stuff */
283 fgd_txt = (char *) malloc(1024);
289 void fgd_init(void) {
291 struct { char *ip, *lon, *lat, *alt;} fg_id;
294 current_port = base_port;
295 while (current_port <= end_port) {
296 sock = socket(PF_INET, SOCK_STREAM, 0);
299 fprintf(stderr, "Error assigning master socket: %s\n",sys_errlist[errno]);
303 address.sin_port = htons(current_port);
304 if (verbose == 2) printf(" address.sin_port : %d\n",htons(address.sin_port));
306 if ( bind(sock, (struct sockaddr *)&address, sizeof(address)) == -1) {
307 printf(" Aiiiieeehh...ADRESS ALSO IN USE...\7hmmm...please check another port\n");
308 printf(" Just wait a few seconds or do a netstat to see the port status.\n");
316 FD_SET( sock, &allset);
321 nready = select( sock + 1, &rset, NULL, NULL, &tv);
322 if (FD_ISSET( sock, &rset)) {
323 my_sock = accept( sock, (struct sockaddr *)&address, &size);
325 /* reading length of senders' ip */
327 read( my_sock, buff, 1);
328 fgd_ele_len = buff[0];
329 if (verbose == 2) printf("ele_len %d\n", fgd_ele_len);
330 /* reading senders' ip */
331 read( my_sock, &buff, fgd_ele_len);
333 // printf("%d %d %d %d %x %x %x\n", buff[0], buff[1], buff[2], buff[3], &ip, ip, *ip);
334 fgd_client.adr = (char*) inet_ntoa( *ip);
335 src_host = fgd_client.adr;
336 /* reading commando */
337 read( my_sock, &buff, 1);
338 /* closing previous file descriptor of same client, at least we know now
339 that the previous command is finished since it's the same client who
340 again requests something. Maybe I'm to quick and diiirty ;-) */
341 printf("FGD : Using socket #%d\n", my_sock);
342 fgd_known_cli = False;
343 for ( fgd_cnt = 1; fgd_cnt < fgd_cli+1; fgd_cnt++) {
344 printf("FGD : fgd_cnt:%d fgd_cli:%d fgd_client.adr: %s prev.sock:%d fgd_cli_list[fgd_cnt].adr: %s\n",
345 fgd_cnt, fgd_cli, fgd_client.adr,
346 fgd_cli_list[fgd_cnt].prev_sock, fgd_cli_list[fgd_cnt].adr);
347 if ( strcmp( fgd_cli_list[fgd_cnt].adr, fgd_client.adr) == 0) {
348 printf("FGD : In Vergleichsloop. Closing socket: %d\n",
349 fgd_cli_list[fgd_cnt].prev_sock);
350 close( fgd_cli_list[fgd_cnt].prev_sock);
351 fgd_cli_list[fgd_cnt].prev_sock = my_sock;
352 fgd_known_cli = True;
355 if ( fgd_known_cli == False) {
357 fgd_cli_list[fgd_cli].prev_sock = my_sock;
358 strcpy(fgd_cli_list[fgd_cli].adr, fgd_client.adr);
360 printf(" Commando received : %s from Host : %s\n", &buff, src_host);
361 fgd_com = ( (char) buff[0]) - 0x30;
362 printf("%d \n", fgd_com);
364 case 0: printf(" fgd : Identify\n");
365 sprintf( (char*) buff, "FGDLH%s", fgd_name);
366 buff[3] = strlen(fgd_name) + 1; /* Lo, incl.zero */
367 buff[4] = 0; /* Hi, names < 0xff ! */
368 buff[buff[3] + 4] = 0; /* Term.zero */
369 printf(" I am : %s\n", fgd_name);
370 write( my_sock, &buff, buff[3]+5); /* fgd housekeeping ;-) */
373 case 1: printf(" fgd : Register\n");
374 /* reading length of FGFS_host ip */
376 read( my_sock, &buff, 1);
377 fgd_ele_len = (int) &buff;
378 /* reading FGFS_host ip */
379 read( my_sock, &buff, fgd_ele_len);
381 fgd_client.adr = (char*) inet_ntoa( *ip);
382 if (list_not_in(fgd_client.adr) == True) {
383 list_insert(fgd_client.adr);
384 list_search(fgd_client.adr);
385 // strcpy(act->callsign, "None");
386 printf(" Setting default values\n");
387 printf(" IP : %s\n", act->next->ipadr);
388 printf(" PILOT : %s\n", act->next->callsign);
390 /* writing answer back to client */
391 sprintf( (char*) buff, "FGDLH%s", fgd_client.adr);
392 buff[3] = strlen(fgd_client.adr) + 1; /* Lo, incl.zero */
393 buff[4] = 0; /* Hi, names < 0xff ! */
394 buff[buff[3] + 4] = 0; /* Term.zero */
395 write( my_sock, &buff, buff[3]+5); /* fgd housekeeping ;-) */
398 case 2: printf(" fgd : Show Registered\n");
399 sprintf( (char*) buff, "FGD");
400 // buff[3] = buff[4] = 0;
404 while (test != tail) {
405 printf(" IP : %s\n", test->ipadr);
407 fgd_ele_len = strlen(test->ipadr) + 1;
408 // printf(" ele_len %d curpos %d\n", fgd_ele_len, fgd_curpos);
409 buff[fgd_curpos] = fgd_ele_len;
411 bcopy(test->ipadr, &buff[fgd_curpos], fgd_ele_len);
412 fgd_curpos += fgd_ele_len;
413 //buff[fgd_curpos] = 0;
416 if (fgd_cnt == 0) fgd_curpos--;
417 buff[3] = fgd_curpos & 0xff;
418 buff[4] = fgd_curpos >> 8;
420 write( my_sock, &buff, fgd_curpos);
423 case 3: printf(" fgd : Send MSG\n");
426 case 4: printf(" fgd : Send MSG to all\n");
429 case 5: printf(" fgd : Get DATA from client\n");
430 read( my_sock, &buff, 1);
431 fgd_ele_len = buff[0];
432 read( my_sock, &buff, fgd_ele_len);
434 fgd_client.adr = (char*) inet_ntoa( *ip);
435 printf(" IP : %s\n", fgd_client.adr);
436 if (verbose != 0) printf("not_in (CASE) : %d\n", list_not_in(fgd_client.adr));
437 if (list_not_in(fgd_client.adr) == False) {
438 printf(" Checkpoint\n");
439 read( my_sock, &buff, 1);
440 printf(" Checkpoint 1\n");
441 fgd_ele_len = buff[0];
442 read( my_sock, &buff, fgd_ele_len);
443 incoming->callsign[fgd_ele_len] = 0;
444 bcopy( &buff, incoming->callsign, fgd_ele_len);
446 read( my_sock, &buff, 56);
447 sscanf( buff," %7f %7f %7f %7f %7f %7f %7f", &incoming->latf, &incoming->lonf,
448 &incoming->altf, &incoming->speedf, &incoming->rollf,
449 &incoming->pitchf, &incoming->yawf);
450 printf(" lat :%7.3f\n lon :%7.3f\n alt :%7.3f\n speed :%7.3f\n roll :%7.3f\n pitch :%7.3f\n yaw :%7.3f\n",
451 incoming->latf, incoming->lonf, incoming->altf, incoming->speedf,
452 incoming->rollf, incoming->pitchf, incoming->yawf);
453 list_setval(fgd_client.adr);
455 else strcpy( fgd_client.adr, "UNKNOWN");
456 /* writing answer back to client */
457 sprintf( (char*) buff, "%sLH%s ", "FGD", fgd_client.adr);
458 buff[3] = strlen(fgd_client.adr) + 1;
460 buff[ buff[3] + 4] = 0;
461 printf(" IP : %s\n", fgd_client.adr);
462 write( my_sock, &buff, buff[3]+5);
465 case 17: printf(" fgd : Get Mat4 DATA from client\n");
466 read( my_sock, &buff, 1);
467 fgd_ele_len = buff[0];
468 read( my_sock, &buff, fgd_ele_len);
470 fgd_client.adr = (char*) inet_ntoa( *ip);
471 printf(" IP : %s\n", fgd_client.adr);
472 if (verbose != 0) printf("not_in (CASE) : %d\n", list_not_in(fgd_client.adr));
473 if (list_not_in(fgd_client.adr) == False) {
474 printf(" Checkpoint\n");
475 read( my_sock, &buff, 1);
476 printf(" Checkpoint 1\n");
477 fgd_ele_len = buff[0];
478 read( my_sock, &buff, fgd_ele_len);
479 incoming->callsign[fgd_ele_len] = 0;
480 bcopy( &buff, incoming->callsign, fgd_ele_len);
482 read( my_sock, &buff, 158);
483 i = sscanf( buff," %f %f %f %f %f %f %f %f %f %f %f %f %f %f %f %f",
484 &incoming->sgFGD_COORD[0][0], &incoming->sgFGD_COORD[0][1], &incoming->sgFGD_COORD[0][2], &incoming->sgFGD_COORD[0][3],
485 &incoming->sgFGD_COORD[1][0], &incoming->sgFGD_COORD[1][1], &incoming->sgFGD_COORD[1][2], &incoming->sgFGD_COORD[1][3],
486 &incoming->sgFGD_COORD[2][0], &incoming->sgFGD_COORD[2][1], &incoming->sgFGD_COORD[2][2], &incoming->sgFGD_COORD[2][3],
487 &incoming->sgFGD_COORD[3][0], &incoming->sgFGD_COORD[3][1], &incoming->sgFGD_COORD[3][2], &incoming->sgFGD_COORD[3][3]);
489 // printf(" sscanf input: %d\n",i);
490 printf(" sgMat4: \n%f %f %f %f %f %f %f %f %f %f %f %f %f %f %f %f\n",
491 incoming->sgFGD_COORD[0][0], incoming->sgFGD_COORD[0][1], incoming->sgFGD_COORD[0][2], incoming->sgFGD_COORD[0][3],
492 incoming->sgFGD_COORD[1][0], incoming->sgFGD_COORD[1][1], incoming->sgFGD_COORD[1][2], incoming->sgFGD_COORD[1][3],
493 incoming->sgFGD_COORD[2][0], incoming->sgFGD_COORD[2][1], incoming->sgFGD_COORD[2][2], incoming->sgFGD_COORD[2][3],
494 incoming->sgFGD_COORD[3][0], incoming->sgFGD_COORD[3][1], incoming->sgFGD_COORD[3][2], incoming->sgFGD_COORD[3][3]);
495 list_setval_Mat4(fgd_client.adr);
497 else strcpy( fgd_client.adr, "UNKNOWN");
498 /* writing answer back to client */
499 sprintf( (char*) buff, "FGDLH%s", fgd_client.adr);
500 buff[3] = strlen(fgd_client.adr) + 1;
501 buff[4] = buff[buff[3]+5] = 0;
502 printf(" IP : %s\n", fgd_client.adr);
503 write( my_sock, &buff, buff[3]+5);
506 case 6: printf(" fgd : Send all DATA to client\n");
507 sprintf( (char*) buff, "%s %s", "FGD", fgd_client.adr);
512 while (test != tail) {
513 printf(" IP : %-16s Callsign : %-16s\n", test->ipadr, test->callsign);
516 fgd_ele_len = strlen(test->ipadr);
517 printf(" ele_len %d curpos %d\n", fgd_ele_len, fgd_curpos);
518 buff[fgd_curpos] = fgd_ele_len;
520 bcopy(test->ipadr, &buff[fgd_curpos], fgd_ele_len);
521 fgd_curpos = fgd_curpos + fgd_ele_len;
523 fgd_ele_len = strlen(test->callsign);
524 printf(" ele_len %d curpos %d\n", fgd_ele_len, fgd_curpos);
525 buff[fgd_curpos] = fgd_ele_len;
527 bcopy(test->callsign, &buff[fgd_curpos], fgd_ele_len);
528 fgd_curpos = fgd_curpos + fgd_ele_len;
529 /* Lat, Lon, Alt, Speed, Roll, Pitch, Yaw
530 hope this sprintf call is not too expensive */
531 sprintf( fgd_txt, " %7.3f %7.3f %7.3f %7.3f %7.3f %7.3f %7.3f",
532 test->latf, test->lonf, test->altf, test->speedf,
533 test->rollf, test->pitchf, test->yawf);
534 printf(" ele_len %d curpos %d\n", fgd_ele_len, fgd_curpos);
535 printf(" Data : %s\n", fgd_txt);
536 bcopy((char *) fgd_txt, &buff[fgd_curpos], 56);
540 if (fgd_cnt == 0) fgd_curpos --;
541 printf(" ele_len %d curpos %d\n", fgd_ele_len, fgd_curpos);
542 buff[3] = fgd_curpos;
543 buff[4] = fgd_curpos / 256;
545 write( my_sock, &buff, fgd_curpos);
548 case 18: printf(" fgd : Send all Mat4 DATA to client\n");
549 sprintf( (char*) buff, "FGDLH");
550 buff[3] = buff[4] = 0;
554 while (test != tail) {
555 printf(" IP : %-16s Callsign : %-16s\n", test->ipadr, test->callsign);
558 fgd_ele_len = strlen(test->ipadr);
559 printf(" ele_len %d curpos %d\n", fgd_ele_len, fgd_curpos);
560 buff[fgd_curpos] = fgd_ele_len;
562 bcopy(test->ipadr, &buff[fgd_curpos], fgd_ele_len);
563 fgd_curpos = fgd_curpos + fgd_ele_len;
565 fgd_ele_len = strlen(test->callsign);
566 printf(" ele_len %d curpos %d\n", fgd_ele_len, fgd_curpos);
567 buff[fgd_curpos] = fgd_ele_len;
569 bcopy(test->callsign, &buff[fgd_curpos], fgd_ele_len);
570 fgd_curpos = fgd_curpos + fgd_ele_len;
571 /* Lat, Lon, Alt, Speed, Roll, Pitch, Yaw
572 hope this sprintf call is not too expensive */
573 fgd_len_msg = sprintf( fgd_txt, " %f %f %f %f %f %f %f %f %f %f %f %f %f %f %f %f",
574 test->sgFGD_COORD[0][0], test->sgFGD_COORD[0][1], test->sgFGD_COORD[0][2], test->sgFGD_COORD[0][3],
575 test->sgFGD_COORD[1][0], test->sgFGD_COORD[1][1], test->sgFGD_COORD[1][2], test->sgFGD_COORD[1][3],
576 test->sgFGD_COORD[2][0], test->sgFGD_COORD[2][1], test->sgFGD_COORD[2][2], test->sgFGD_COORD[2][3],
577 test->sgFGD_COORD[3][0], test->sgFGD_COORD[3][1], test->sgFGD_COORD[3][2], test->sgFGD_COORD[3][3]);
578 fgd_txt[fgd_len_msg] = 0;
579 printf(" ele_len %d curpos %d\n", fgd_ele_len, fgd_curpos);
580 printf(" Data : %s\n", fgd_txt);
581 bcopy((char *) fgd_txt, &buff[fgd_curpos], fgd_len_msg+1);
582 fgd_curpos += fgd_len_msg+1;
585 if (fgd_cnt == 0) fgd_curpos -= 1;
586 printf(" ele_len %d curpos %d\n", fgd_ele_len, fgd_curpos);
587 buff[3] = fgd_curpos & 0xff;
588 buff[4] = fgd_curpos / 256;
590 printf("ANZ: %d CURPOS: %d\n", (unsigned char) buff[3] + (unsigned char) buff[4] * 256, fgd_curpos);
591 write( my_sock, &buff, fgd_curpos);
594 case 8: printf(" fgd : Unregister\n");
595 read( my_sock, &buff, 1);
596 fgd_ele_len = (int) &buff;
597 read( my_sock, &buff, fgd_ele_len);
599 fgd_client.adr = (char*) inet_ntoa( *ip);
600 printf(" IP : %s\n", fgd_client.adr);
601 if (verbose != 0) printf("not_in (CASE) : %d\n", list_not_in(fgd_client.adr));
602 if (list_not_in(fgd_client.adr) == -1) {
603 list_clear(fgd_client.adr);
605 else strcpy( fgd_client.adr, "UNKNOWN");
606 /* writing answer back to client */
607 sprintf( (char*) buff, "FGDLH%s", fgd_client.adr);
608 buff[3] = strlen(fgd_client.adr) + 1;
609 buff[4] = buff[buff[3]+5] = 0;
610 printf(" IP : %s\n", fgd_client.adr);
611 write( my_sock, &buff, buff[3]+5);
612 // Just leaving the old stuff in, to correct it for FGFS later...
613 // I'm sick of this f$%&ing libc5/glibc2.0/2.1 quirks
614 // Oliver...very angry...
615 // /* writing answer back to client */
616 // sprintf( (char*) buff, "%s %s", "FGD", fgd_client.adr);
617 // buff[3] = strlen(fgd_client.adr);
618 // printf(" IP : %s\n", fgd_client.adr);
619 // write( my_sock, &buff, buff[3]+4);
622 case 9: printf(" fgd : Shutdown\n");
626 default: printf(" fgd : Huh?...Unknown Command\n");
633 case 0: printf("%d\n",base_port+current_port);
635 case 1: service_info = getservbyport(htons(base_port+current_port),"tcp");
637 printf("%d -> service name unknown\n",base_port+current_port);
639 printf("%d -> %s\n",base_port+current_port,service_info->s_name);
642 case 2: service_info = getservbyport(htons(base_port+current_port),"tcp");
644 printf("Port %d found. Service name unknown\n",base_port+current_port);
646 printf("Port %d found. Service name: %s\n",base_port+current_port,service_info->s_name);
651 } else if (errno == 113) {
652 fprintf(stderr,"No route to host !\n");
655 /* current_port++; */
658 if (verbose == 2) printf("Port scan finished !\n");