src/NetworkOLK/Tools/fgd.c

   1 /*************************************************************/
   2 /* FGD.C by Oliver Delise                                    */
   3 /* Contact info:                                             */
   4 /* e-mail: delise@mail.isis.de                               */
   5 /* www: http://www.isis.de/members/~odelise/progs/flightgear  */
   6 /*                                                           */
   7 /* Version 0.1-beta                                          */
   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    */
  12 /* software.                                                 */
  13 /*                                                           */
  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...                         */
  18 /*                                                           */
  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.     */
  27 /*                                                           */
  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 /*************************************************************/
  34
  35
  36 #include <stdio.h>
  37 #include <sys/socket.h>
  38 #include <sys/types.h>
  39 #include <netinet/in.h>
  40 #include <unistd.h>
  41 #include <netdb.h>
  42 #include <sys/time.h>
  43 #include <fcntl.h>
  44 #include <sys/utsname.h>
  45
  46 //#define printf //
  47
  48 /* Net-stuff */
  49 fd_set rset, allset;
  50 int  maxfd, nready, retval;
  51 struct timeval tv;
  52 struct utsname myname;
  53 char *fgd_host, *src_host;
  54
  55 /* Program-stuff */
  56 int verbose, fgd_len_msg;
  57
  58 /* List-stuff (doubly-Linked-list) */
  59 #include <string.h>
  60 #include <stdlib.h>
  61
  62 int i, j, fgd_cnt, fgd_curpos;
  63 char *vb, *fgd_txt;
  64 const int True  = 0;
  65 const int False= -1;
  66
  67 float sgFGD_COORD[4][4];
  68
  69 struct list_ele {
  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;
  75 };
  76
  77 struct list_ele *head, *tail, *act, *test, *incoming;  /*  fgd_msg; */
  78
  79 struct fgd_sock_list {
  80    char adr[16];
  81    int  prev_sock;
  82 };
  83
  84 struct fgd_sock_list fgd_cli_list[255];
  85 int fgd_known_cli = -1;   /* False */
  86 int fgd_cli = 0;
  87
  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");
  97    head->lon = 0;
  98    head->lat = 0;
  99    head->alt = 0;
 100    head->pitch = 0;
 101    head->roll = 0;
 102    head->yaw = 0;
 103 */
 104    /* yaw!. Who the f$%& invented this ;-) */
 105    head->ipadr[0] = 0;
 106    tail->ipadr[0] = 255;
 107    tail->ipadr[1] = 0;
 108    head->prev = tail->prev = head;
 109    head->next = tail->next = tail;
 110    act = head;          /* put listpointer to beginning of list */
 111 }
 112
 113 void list_output( void) {
 114 }
 115
 116 void list_search( char name[16]) {
 117
 118    if (strcmp(name, head->next->ipadr) <= 0)     act = head;
 119    else if (strcmp(name, tail->prev->ipadr) > 0) act = tail->prev;
 120    else {
 121       int vergleich = strcmp(name, act->ipadr);
 122       if (vergleich > 0)
 123          while (strcmp(name, act->next->ipadr) > 0) {
 124             act = act->next;
 125          }
 126       else if (vergleich < 0)
 127          while (strcmp(name, act->ipadr) < 0) {
 128             act = act->prev;
 129          }
 130       else
 131          while (strcmp(name, act->ipadr) == 0) {
 132             act = act->prev;
 133          }
 134    }
 135 }
 136
 137 void list_insert( char newip[16]) {
 138 struct list_ele *new_ele;
 139
 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");
 145    list_search( newip);
 146    new_ele->prev = act;
 147    new_ele->next = act->next;
 148    act->next->prev = act->next = new_ele;
 149 }
 150
 151 void list_setval( char newip[16]) {
 152
 153    list_search( newip);
 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);
 166 }
 167
 168 void list_setval_Mat4( char newip[16]) {
 169
 170    list_search( newip);
 171    strcpy( act->next->callsign, incoming->callsign);
 172    for (i=0;i<4;i++)
 173      for (j=0;j<4;j++)
 174        act->next->sgFGD_COORD[i][j] = incoming->sgFGD_COORD[i][j];
 175    printf("Callsign %s ", act->next->callsign);
 176 }
 177
 178
 179 void list_clear( char clrip[16]) {
 180 struct list_ele *clr_ele;
 181
 182    list_search( clrip);
 183    if ( strcmp( clrip, act->next->ipadr))
 184       printf("....Name %s nicht vorhanden", clrip);
 185    else {
 186      clr_ele         = act->next;
 187      act->next       = act->next->next;
 188      act->next->prev = act;
 189      free( clr_ele);
 190    }
 191 }
 192
 193
 194 int list_not_in( char name[16]) {
 195
 196    i = True;
 197    test = head->next;
 198    while ((test != tail) && (i==True)) {
 199      i = (strcmp(test->ipadr, name) ? True : False);
 200      test = test->next;
 201      if (verbose != 0) printf("list_not_in : %d\n",i);
 202    }
 203    return(i);
 204 }
 205
 206
 207
 208
 209 int sock = -1;
 210 int my_sock;
 211 int fgd_com;
 212 int *ip;
 213 size_t anz;
 214 char buff[1024];
 215 char *fgd_name;
 216 struct { char *adr, *lon, *lat, *alt;} fgd_client;
 217 int fgd_ele_len;
 218
 219 struct sockaddr_in address;
 220 struct sockaddr_in my_address;
 221 int result;
 222 socklen_t size = sizeof(address);
 223
 224
 225 extern int errno;
 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;
 231
 232 void fgd_init(void);
 233
 234 int main(int argc, char **argv)
 235 {
 236    if (argc < 4) {
 237     fprintf(stderr,"Usage: fgd [start port] [end port] [name] <-v or -vv>\n");
 238     exit(1);
 239    }
 240
 241    switch (argc) {
 242      case 5: if (!strcmp(argv[4],"-v"))
 243                verbose = 1;
 244              else if (!strcmp(argv[4],"-vv"))
 245                     verbose = 2;
 246                else { fprintf(stderr,"Usage: fgd [start port] [end port] [name] <-v or -vv>\n");
 247                       exit(1); }
 248
 249      case 4: base_port = (u_short)atoi(argv[1]);
 250              end_port = (u_short)atoi(argv[2]);
 251              fgd_name = argv[3];
 252              break;
 253      default: fprintf(stderr,"Usage: fgd [start port] [end port] [name] <-v or -vv>\n");
 254               exit(1);
 255               break;
 256    }
 257
 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);
 262
 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));
 267
 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");
 272             exit(1);
 273           } else if (verbose == 2) printf(" address valid\n");
 274
 275    if ((base_port > end_port) || ((short)base_port < 0)) {
 276      fprintf(stderr,"Bad port range : start=%d end=%d !\n");
 277      exit(1);
 278    } else if (verbose == 2) {
 279             printf(" Port range: %d to %d\n",base_port,end_port);
 280      }
 281    printf(" verbose: %d\n",verbose);
 282    /* some init stuff */
 283    fgd_txt = (char *) malloc(1024);
 284    list_init();
 285    fgd_init();
 286    exit(0);
 287 }
 288
 289 void fgd_init(void) {
 290
 291 struct { char *ip, *lon, *lat, *alt;} fg_id;
 292
 293
 294    current_port = base_port;
 295    while (current_port <= end_port) {
 296     sock = socket(PF_INET, SOCK_STREAM, 0);
 297     if (sock == -1)
 298      {
 299         fprintf(stderr, "Error assigning master socket: %s\n",sys_errlist[errno]);
 300         exit(-1);
 301      }
 302
 303     address.sin_port = htons(current_port);
 304     if (verbose == 2) printf(" address.sin_port : %d\n",htons(address.sin_port));
 305     if (1 == 1) {
 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");
 309          exit(-1);
 310     }
 311     listen(sock, 5);
 312
 313 /* Hier neu */
 314     maxfd = sock;
 315     FD_ZERO( &allset);
 316     FD_SET( sock, &allset);
 317 for (;;){
 318     rset = allset;
 319     tv.tv_sec  = 1;
 320     tv.tv_usec = 0;
 321     nready = select( sock + 1, &rset, NULL, NULL, &tv);
 322     if (FD_ISSET( sock, &rset)) {
 323       my_sock = accept( sock, (struct sockaddr *)&address, &size);
 324       anz = 2;
 325 /* reading length of senders' ip */
 326       fgd_ele_len =  0;
 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);
 332       ip = (int *) buff;
 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;
 353         }
 354       }
 355       if ( fgd_known_cli == False) {
 356            fgd_cli++;
 357            fgd_cli_list[fgd_cli].prev_sock = my_sock;
 358            strcpy(fgd_cli_list[fgd_cli].adr, fgd_client.adr);
 359       }
 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);
 363       switch (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 ;-) */
 371      //           close(my_sock);
 372                 break;
 373       case 1:   printf(" fgd   : Register\n");
 374       /* reading length of FGFS_host ip */
 375                 fgd_ele_len =  0;
 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);
 380                 ip = (int *) buff;
 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);
 389                     }
 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 ;-) */
 396  //               close(my_sock);
 397                 break;
 398       case 2:   printf(" fgd   : Show Registered\n");
 399                 sprintf( (char*) buff, "FGD");
 400                 // buff[3] = buff[4] = 0;
 401                 fgd_cnt = 0;
 402                 fgd_curpos = 6;
 403                 test = head->next;
 404                 while (test != tail) {
 405                    printf("    IP : %s\n", test->ipadr);
 406                    fgd_cnt++;
 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;
 410                    fgd_curpos++;
 411                    bcopy(test->ipadr, &buff[fgd_curpos], fgd_ele_len);
 412                    fgd_curpos += fgd_ele_len;
 413                    //buff[fgd_curpos] = 0;
 414                    test = test->next;
 415                 }
 416                 if (fgd_cnt == 0) fgd_curpos--;
 417                 buff[3] = fgd_curpos & 0xff;
 418                 buff[4] = fgd_curpos >> 8;
 419                 buff[5] = fgd_cnt;
 420                 write( my_sock, &buff, fgd_curpos);
 421 //                      close(my_sock);
 422                 break;
 423       case 3:   printf(" fgd   : Send MSG\n");
 424 //                close(my_sock);
 425                 break;
 426       case 4:   printf(" fgd   : Send MSG to all\n");
 427 //                      close(my_sock);
 428                 break;
 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);
 433                 ip = (int *) buff;
 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);
 445                 /* lat, lon */
 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);
 454                     }
 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;
 459                 buff[4] = 0;
 460                 buff[ buff[3] + 4] = 0;
 461                 printf("    IP : %s\n", fgd_client.adr);
 462                 write( my_sock, &buff, buff[3]+5);
 463 //                      close(my_sock);
 464                 break;
 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);
 469                 ip = (int *) buff;
 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);
 481                 /* lat, lon */
 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]);
 488
 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);
 496                     }
 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);
 504 //                      close(my_sock);
 505                 break;
 506       case 6:   printf(" fgd   : Send all DATA to client\n");
 507                 sprintf( (char*) buff, "%s %s", "FGD", fgd_client.adr);
 508                 buff[3] = 0;
 509                 fgd_cnt = 0;
 510                 fgd_curpos = 6;
 511                 test = head->next;
 512                 while (test != tail) {
 513                    printf("    IP : %-16s  Callsign : %-16s\n", test->ipadr, test->callsign);
 514                    fgd_cnt++;
 515                 /* IP */
 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;
 519                    fgd_curpos++;
 520                    bcopy(test->ipadr, &buff[fgd_curpos], fgd_ele_len);
 521                    fgd_curpos = fgd_curpos + fgd_ele_len;
 522                 /* Callsign */
 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;
 526                    fgd_curpos++;
 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);
 537                    fgd_curpos += 56;
 538                    test = test->next;
 539                 }
 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;
 544                 buff[5] = fgd_cnt;
 545                 write( my_sock, &buff, fgd_curpos);
 546 //                      close(my_sock);
 547                 break;
 548       case 18:  printf(" fgd   : Send all Mat4 DATA to client\n");
 549                 sprintf( (char*) buff, "FGDLH");
 550                 buff[3] = buff[4] = 0;
 551                 fgd_cnt = 0;
 552                 fgd_curpos = 6;
 553                 test = head->next;
 554                 while (test != tail) {
 555                    printf("    IP : %-16s  Callsign : %-16s\n", test->ipadr, test->callsign);
 556                    fgd_cnt++;
 557                 /* IP */
 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;
 561                    fgd_curpos++;
 562                    bcopy(test->ipadr, &buff[fgd_curpos], fgd_ele_len);
 563                    fgd_curpos = fgd_curpos + fgd_ele_len;
 564                 /* Callsign */
 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;
 568                    fgd_curpos++;
 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;
 583                    test = test->next;
 584                 }
 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;
 589                 buff[5] = fgd_cnt;
 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);
 592 //                      close(my_sock);
 593                 break;
 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);
 598                 ip = (int *) buff;
 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);
 604                     }
 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);
 620 //                close(my_sock);
 621                 break;
 622       case 9:   printf(" fgd   : Shutdown\n");
 623                 close(my_sock);
 624                 close(sock);
 625                 exit(0);
 626       default:  printf(" fgd   : Huh?...Unknown Command\n");
 627                 break;
 628       }
 629     }
 630     }
 631 /*
 632      switch (verbose) {
 633       case 0: printf("%d\n",base_port+current_port);
 634               break;
 635       case 1: service_info = getservbyport(htons(base_port+current_port),"tcp");
 636               if (!service_info) {
 637               printf("%d -> service name unknown\n",base_port+current_port);
 638               } else {
 639               printf("%d -> %s\n",base_port+current_port,service_info->s_name);
 640               }
 641               break;
 642       case 2: service_info = getservbyport(htons(base_port+current_port),"tcp");
 643               if (!service_info) {
 644               printf("Port %d found. Service name unknown\n",base_port+current_port);
 645               } else {
 646               printf("Port %d found. Service name: %s\n",base_port+current_port,service_info->s_name);
 647               }
 648               break;
 649      }
 650 */
 651     }  else if (errno == 113) {
 652          fprintf(stderr,"No route to host !\n");
 653          exit(1);
 654        }
 655 /*     current_port++; */
 656    }
 657
 658   if (verbose == 2) printf("Port scan finished !\n");
 659 }