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 /*************************************************************/
  33
  34
  35 #include <stdio.h>
  36 #include <sys/socket.h>
  37 #include <sys/types.h>
  38 #include <netinet/in.h>
  39 #include <unistd.h>
  40 #include <netdb.h>
  41 #include <sys/time.h>
  42 #include <fcntl.h>
  43 #include <sys/utsname.h>
  44
  45 //#define printf //
  46
  47 /* Net-stuff */
  48 fd_set rset, allset;
  49 int  maxfd, nready, retval;
  50 struct timeval tv;
  51 struct utsname myname;
  52 char *fgd_host, *src_host;
  53
  54 /* Program-stuff */
  55 int verbose, fgd_len_msg;
  56
  57 /* List-stuff (doubly-Linked-list) */
  58 #include <string.h>
  59 #include <stdlib.h>
  60
  61 int i, j, fgd_cnt, fgd_curpos;
  62 char *vb, *fgd_txt;
  63 const int True  = 0;
  64 const int False= -1;
  65
  66 float sgFGD_COORD[4][4];
  67
  68 struct list_ele {
  69    unsigned char ipadr[16], callsign[16];
  70    unsigned char lat[8], lon[8], alt[8], speed[8], roll[8], pitch[8], yaw[8];
  71    float latf, lonf, altf, speedf, rollf, pitchf, yawf;
  72    float sgFGD_COORD[4][4];
  73    struct list_ele *next, *prev;
  74 };
  75
  76 struct list_ele *head, *tail, *act, *test, *incoming;  /*  fgd_msg; */
  77
  78 struct fgd_sock_list {
  79    char adr[16];
  80    int  prev_sock;
  81 };
  82
  83 struct fgd_sock_list fgd_cli_list[255];
  84 int fgd_known_cli = -1;   /* False */
  85 int fgd_cli = 0;
  86
  87 /*...Create head and tail of list */
  88 void list_init( void) {
  89    incoming = (struct list_ele*) malloc(sizeof(struct list_ele));
  90    head = (struct list_ele*) malloc(sizeof(struct list_ele));
  91    tail = (struct list_ele*) malloc(sizeof(struct list_ele));
  92    if (head == NULL || tail == NULL) { printf("Out of memory\n"); exit(1); }
  93 /* fixme :Where is the "with foobar do command "
  94    head->ipadr = "127.0.0.0";
  95    strcpy(head->callsign, "None");
  96    head->lon = 0;
  97    head->lat = 0;
  98    head->alt = 0;
  99    head->pitch = 0;
 100    head->roll = 0;
 101    head->yaw = 0;
 102 */
 103    /* yaw!. Who the f$%& invented this ;-) */
 104    head->ipadr[0] = 0;
 105    tail->ipadr[0] = 255;
 106    tail->ipadr[1] = 0;
 107    head->prev = tail->prev = head;
 108    head->next = tail->next = tail;
 109    act = head;          /* put listpointer to beginning of list */
 110 }
 111
 112 void list_output( void) {
 113 }
 114
 115 void list_search( char name[16]) {
 116
 117    if (strcmp(name, head->next->ipadr) <= 0)     act = head;
 118    else if (strcmp(name, tail->prev->ipadr) > 0) act = tail->prev;
 119    else {
 120       int vergleich = strcmp(name, act->ipadr);
 121       if (vergleich > 0)
 122          while (strcmp(name, act->next->ipadr) > 0) {
 123             act = act->next;
 124          }
 125       else if (vergleich < 0)
 126          while (strcmp(name, act->ipadr) < 0) {
 127             act = act->prev;
 128          }
 129       else
 130          while (strcmp(name, act->ipadr) == 0) {
 131             act = act->prev;
 132          }
 133    }
 134 }
 135
 136 void list_insert( char newip[16]) {
 137 struct list_ele *new_ele;
 138
 139    new_ele = (struct list_ele*) malloc(sizeof(struct list_ele));
 140    if (new_ele == NULL) { printf("Out of memory\n"); exit(1); }
 141    strcpy(new_ele->ipadr, newip);
 142 /* setting default */
 143    strcpy(new_ele->callsign, "not assigned");
 144    list_search( newip);
 145    new_ele->prev = act;
 146    new_ele->next = act->next;
 147    act->next->prev = act->next = new_ele;
 148 }
 149
 150 void list_setval( char newip[16]) {
 151
 152    list_search( newip);
 153    strcpy( act->next->callsign, incoming->callsign);
 154    act->next->latf = incoming->latf;
 155    act->next->lonf = incoming->lonf;
 156    act->next->altf = incoming->altf;
 157    act->next->speedf = incoming->speedf;
 158    act->next->rollf = incoming->rollf;
 159    act->next->pitchf = incoming->pitchf;
 160    act->next->yawf = incoming->yawf;
 161    printf("Callsign %s ", act->next->callsign);
 162    printf(" lat: %7.3f lon: %7.3f alt: %7.3f speed: %7.3f roll: %7.3f pitch: %7.3f yaw: %7.3f",
 163             act->next->latf, act->next->lonf, act->next->altf, act->next->speedf,
 164             act->next->rollf, act->next->pitchf, act->next->yawf);
 165 }
 166
 167 void list_setval_Mat4( char newip[16]) {
 168
 169    list_search( newip);
 170    strcpy( act->next->callsign, incoming->callsign);
 171    for (i=0;i<4;i++)
 172      for (j=0;j<4;j++)
 173        act->next->sgFGD_COORD[i][j] = incoming->sgFGD_COORD[i][j];
 174    printf("Callsign %s ", act->next->callsign);
 175 }
 176
 177
 178 void list_clear( char clrip[16]) {
 179 struct list_ele *clr_ele;
 180
 181    list_search( clrip);
 182    if ( strcmp( clrip, act->next->ipadr))
 183       printf("....Name %s nicht vorhanden", clrip);
 184    else {
 185      clr_ele         = act->next;
 186      act->next       = act->next->next;
 187      act->next->prev = act;
 188      free( clr_ele);
 189    }
 190 }
 191
 192
 193 int list_not_in( char name[16]) {
 194
 195    i = True;
 196    test = head->next;
 197    while ((test != tail) && (i==True)) {
 198      i = (strcmp(test->ipadr, name) ? True : False);
 199      test = test->next;
 200      if (verbose != 0) printf("list_not_in : %d\n",i);
 201    }
 202    return(i);
 203 }
 204
 205
 206
 207
 208 int sock = -1;
 209 int my_sock;
 210 int fgd_com;
 211 int *ip;
 212 size_t anz;
 213 char buff[1024];
 214 char *fgd_name;
 215 struct { char *adr, *lon, *lat, *alt;} fgd_client;
 216 int fgd_ele_len;
 217
 218 struct sockaddr_in address;
 219 struct sockaddr_in my_address;
 220 int result;
 221
 222 extern int errno;
 223 int current_port = 0;
 224 u_short base_port = 0;
 225 u_short end_port = 1024;
 226 struct hostent *host_info;
 227 struct servent *service_info;
 228
 229 void fgd_init(void);
 230
 231 int main(int argc, char **argv)
 232 {
 233    if (argc < 4) {
 234     fprintf(stderr,"Usage: fgd [start port] [end port] [name] <-v or -vv>\n");
 235     exit(1);
 236    }
 237
 238    switch (argc) {
 239      case 5: if (!strcmp(argv[4],"-v"))
 240                verbose = 1;
 241              else if (!strcmp(argv[4],"-vv"))
 242                     verbose = 2;
 243                else { fprintf(stderr,"Usage: fgd [start port] [end port] [name] <-v or -vv>\n");
 244                       exit(1); }
 245
 246      case 4: base_port = (u_short)atoi(argv[1]);
 247              end_port = (u_short)atoi(argv[2]);
 248              fgd_name = argv[3];
 249              break;
 250      default: fprintf(stderr,"Usage: fgd [start port] [end port] [name] <-v or -vv>\n");
 251               exit(1);
 252               break;
 253    }
 254
 255    bzero((char *)&address, sizeof(address));
 256    address.sin_family = AF_INET;
 257    if (uname(&myname) == 0) fgd_host = myname.nodename;
 258    printf(" I am running as %s on HOST %s\n", fgd_name, fgd_host);
 259
 260    if (verbose == 2) printf(" Resolving: %s ->",fgd_host);
 261    if (host_info = gethostbyname(fgd_host)) {
 262      bcopy(host_info->h_addr, (char *)&address.sin_addr,host_info->h_length);
 263      printf(" fgd : ip = %s\n", inet_ntoa( address.sin_addr));
 264
 265      if (verbose == 2) printf(" resolved\n");
 266    } else if ((address.sin_addr.s_addr = inet_addr(fgd_host)) == INADDR_NONE) {
 267             fprintf(stderr,"Could not get %s host entry !\n",argv[1]);
 268             printf(" NOT resolved !!!\n");
 269             exit(1);
 270           } else if (verbose == 2) printf(" address valid\n");
 271
 272    if ((base_port > end_port) || ((short)base_port < 0)) {
 273      fprintf(stderr,"Bad port range : start=%d end=%d !\n");
 274      exit(1);
 275    } else if (verbose == 2) {
 276             printf(" Port range: %d to %d\n",base_port,end_port);
 277      }
 278    printf(" verbose: %d\n",verbose);
 279    /* some init stuff */
 280    fgd_txt = (char *) malloc(1024);
 281    list_init();
 282    fgd_init();
 283    exit(0);
 284 }
 285
 286 void fgd_init(void) {
 287
 288 struct { char *ip, *lon, *lat, *alt;} fg_id;
 289
 290
 291    current_port = base_port;
 292    while (current_port <= end_port) {
 293     sock = socket(PF_INET, SOCK_STREAM, 0);
 294     if (sock == -1)
 295      {
 296         fprintf(stderr, "Error assigning master socket: %s\n",sys_errlist[errno]);
 297         exit(-1);
 298      }
 299
 300     address.sin_port = htons(current_port);
 301     if (verbose == 2) printf(" address.sin_port : %d\n",htons(address.sin_port));
 302     if (1 == 1) {
 303     if ( bind(sock, (struct sockaddr *)&address, sizeof(address)) == -1) {
 304          printf(" Aiiiieeehh...ADRESS ALSO IN USE...\7hmmm...please check another port\n");
 305          printf(" Just wait a few seconds or do a netstat to see the port status.\n");
 306          exit(-1);
 307     }
 308     listen(sock, 5);
 309
 310 /* Hier neu */
 311     maxfd = sock;
 312     FD_ZERO( &allset);
 313     FD_SET( sock, &allset);
 314 for (;;){
 315     rset = allset;
 316     tv.tv_sec  = 1;
 317     tv.tv_usec = 0;
 318     nready = select( sock + 1, &rset, NULL, NULL, &tv);
 319     if (FD_ISSET( sock, &rset)) {
 320       my_sock = accept( sock, (struct sockaddr *)&address, (int*) sizeof(address));
 321       anz = 2;
 322 /* reading length of senders' ip */
 323       fgd_ele_len =  0;
 324       read( my_sock, buff, 1);
 325       fgd_ele_len =  buff[0];
 326       if (verbose == 2) printf("ele_len %d\n", fgd_ele_len);
 327 /* reading senders' ip */
 328       read( my_sock, &buff, fgd_ele_len);
 329       ip = (int *) buff;
 330 //      printf("%d %d %d %d   %x   %x  %x\n", buff[0], buff[1], buff[2], buff[3], &ip, ip, *ip);
 331       fgd_client.adr = (char*) inet_ntoa( *ip);
 332       src_host = fgd_client.adr;
 333 /* reading commando */
 334       read( my_sock, &buff, 1);
 335 /* closing previous file descriptor of same client, at least we know now
 336    that the previous command is finished since it's the same client who
 337    again requests something. Maybe I'm to quick and diiirty ;-) */
 338       printf("FGD : Using socket #%d\n", my_sock);
 339       fgd_known_cli = False;
 340       for ( fgd_cnt = 1; fgd_cnt < fgd_cli+1; fgd_cnt++) {
 341         printf("FGD : fgd_cnt:%d  fgd_cli:%d  fgd_client.adr: %s  prev.sock:%d  fgd_cli_list[fgd_cnt].adr: %s\n",
 342                       fgd_cnt, fgd_cli, fgd_client.adr,
 343                       fgd_cli_list[fgd_cnt].prev_sock, fgd_cli_list[fgd_cnt].adr);
 344         if ( strcmp( fgd_cli_list[fgd_cnt].adr, fgd_client.adr) == 0) {
 345              printf("FGD : In Vergleichsloop. Closing socket: %d\n",
 346                       fgd_cli_list[fgd_cnt].prev_sock);
 347              close( fgd_cli_list[fgd_cnt].prev_sock);
 348              fgd_cli_list[fgd_cnt].prev_sock = my_sock;
 349              fgd_known_cli = True;
 350         }
 351       }
 352       if ( fgd_known_cli == False) {
 353            fgd_cli++;
 354            fgd_cli_list[fgd_cli].prev_sock = my_sock;
 355            strcpy(fgd_cli_list[fgd_cli].adr, fgd_client.adr);
 356       }
 357       printf(" Commando received : %s from Host : %s\n", &buff, src_host);
 358       fgd_com = ( (char) buff[0]) - 0x30;
 359       printf("%d \n", fgd_com);
 360       switch (fgd_com) {
 361       case 0:   printf(" fgd   : Identify\n");
 362                 sprintf( (char*) buff, "FGDLH%s", fgd_name);
 363                 buff[3] = strlen(fgd_name) + 1;     /* Lo, incl.zero      */
 364                 buff[4] = 0;                        /* Hi, names < 0xff ! */
 365                 buff[buff[3] + 4] = 0;              /* Term.zero */
 366                 printf(" I am  : %s\n", fgd_name);
 367                 write( my_sock, &buff, buff[3]+5);  /* fgd housekeeping ;-) */
 368      //           close(my_sock);
 369                 break;
 370       case 1:   printf(" fgd   : Register\n");
 371       /* reading length of FGFS_host ip */
 372                 fgd_ele_len =  0;
 373                 read( my_sock, &buff, 1);
 374                 fgd_ele_len =  (int) &buff;
 375       /* reading FGFS_host ip */
 376                 read( my_sock, &buff, fgd_ele_len);
 377                 ip = (int *) buff;
 378                 fgd_client.adr = (char*) inet_ntoa( *ip);
 379                 if (list_not_in(fgd_client.adr) == True) {
 380                     list_insert(fgd_client.adr);
 381                     list_search(fgd_client.adr);
 382 //                    strcpy(act->callsign, "None");
 383                     printf(" Setting default values\n");
 384                     printf("    IP : %s\n", act->next->ipadr);
 385                     printf(" PILOT : %s\n", act->next->callsign);
 386                     }
 387       /* writing answer back to client */
 388                 sprintf( (char*) buff, "FGDLH%s", fgd_client.adr);
 389                 buff[3] = strlen(fgd_client.adr) + 1;     /* Lo, incl.zero      */
 390                 buff[4] = 0;                        /* Hi, names < 0xff ! */
 391                 buff[buff[3] + 4] = 0;              /* Term.zero */
 392                 write( my_sock, &buff, buff[3]+5);  /* fgd housekeeping ;-) */
 393  //               close(my_sock);
 394                 break;
 395       case 2:   printf(" fgd   : Show Registered\n");
 396                 sprintf( (char*) buff, "FGD");
 397                 // buff[3] = buff[4] = 0;
 398                 fgd_cnt = 0;
 399                 fgd_curpos = 6;
 400                 test = head->next;
 401                 while (test != tail) {
 402                    printf("    IP : %s\n", test->ipadr);
 403                    fgd_cnt++;
 404                    fgd_ele_len = strlen(test->ipadr) + 1;
 405 //                         printf(" ele_len %d  curpos %d\n", fgd_ele_len, fgd_curpos);
 406                    buff[fgd_curpos] = fgd_ele_len;
 407                    fgd_curpos++;
 408                    bcopy(test->ipadr, &buff[fgd_curpos], fgd_ele_len);
 409                    fgd_curpos += fgd_ele_len;
 410                    //buff[fgd_curpos] = 0;
 411                    test = test->next;
 412                 }
 413                 if (fgd_cnt == 0) fgd_curpos--;
 414                 buff[3] = fgd_curpos & 0xff;
 415                 buff[4] = fgd_curpos >> 8;
 416                 buff[5] = fgd_cnt;
 417                 write( my_sock, &buff, fgd_curpos);
 418 //                      close(my_sock);
 419                 break;
 420       case 3:   printf(" fgd   : Send MSG\n");
 421 //                close(my_sock);
 422                 break;
 423       case 4:   printf(" fgd   : Send MSG to all\n");
 424 //                      close(my_sock);
 425                 break;
 426       case 5:   printf(" fgd   : Get DATA from client\n");
 427                 read( my_sock, &buff, 1);
 428                 fgd_ele_len = buff[0];
 429                 read( my_sock, &buff, fgd_ele_len);
 430                 ip = (int *) buff;
 431                 fgd_client.adr = (char*) inet_ntoa( *ip);
 432                 printf("    IP : %s\n", fgd_client.adr);
 433                 if (verbose != 0) printf("not_in (CASE) : %d\n", list_not_in(fgd_client.adr));
 434                 if (list_not_in(fgd_client.adr) == False) {
 435                     printf(" Checkpoint\n");
 436                     read( my_sock, &buff, 1);
 437                     printf(" Checkpoint 1\n");
 438                     fgd_ele_len = buff[0];
 439                     read( my_sock, &buff, fgd_ele_len);
 440                     incoming->callsign[fgd_ele_len] = 0;
 441                     bcopy( &buff, incoming->callsign, fgd_ele_len);
 442                 /* lat, lon */
 443                     read( my_sock, &buff, 56);
 444                     sscanf( buff," %7f %7f %7f %7f %7f %7f %7f", &incoming->latf, &incoming->lonf,
 445                            &incoming->altf, &incoming->speedf, &incoming->rollf,
 446                            &incoming->pitchf, &incoming->yawf);
 447                     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",
 448                             incoming->latf, incoming->lonf, incoming->altf, incoming->speedf,
 449                             incoming->rollf, incoming->pitchf, incoming->yawf);
 450                     list_setval(fgd_client.adr);
 451                     }
 452                     else strcpy( fgd_client.adr, "UNKNOWN");
 453       /* writing answer back to client */
 454                 sprintf( (char*) buff, "%sLH%s ", "FGD", fgd_client.adr);
 455                 buff[3] = strlen(fgd_client.adr) + 1;
 456                 buff[4] = 0;
 457                 buff[ buff[3] + 4] = 0;
 458                 printf("    IP : %s\n", fgd_client.adr);
 459                 write( my_sock, &buff, buff[3]+5);
 460 //                      close(my_sock);
 461                 break;
 462       case 17:  printf(" fgd   : Get Mat4 DATA from client\n");
 463                 read( my_sock, &buff, 1);
 464                 fgd_ele_len = buff[0];
 465                 read( my_sock, &buff, fgd_ele_len);
 466                 ip = (int *) buff;
 467                 fgd_client.adr = (char*) inet_ntoa( *ip);
 468                 printf("    IP : %s\n", fgd_client.adr);
 469                 if (verbose != 0) printf("not_in (CASE) : %d\n", list_not_in(fgd_client.adr));
 470                 if (list_not_in(fgd_client.adr) == False) {
 471                     printf(" Checkpoint\n");
 472                     read( my_sock, &buff, 1);
 473                     printf(" Checkpoint 1\n");
 474                     fgd_ele_len = buff[0];
 475                     read( my_sock, &buff, fgd_ele_len);
 476                     incoming->callsign[fgd_ele_len] = 0;
 477                     bcopy( &buff, incoming->callsign, fgd_ele_len);
 478                 /* lat, lon */
 479                     read( my_sock, &buff, 158);
 480                     i = sscanf( buff," %f %f %f %f %f %f %f %f %f %f %f %f %f %f %f %f",
 481                             &incoming->sgFGD_COORD[0][0], &incoming->sgFGD_COORD[0][1], &incoming->sgFGD_COORD[0][2], &incoming->sgFGD_COORD[0][3],
 482                             &incoming->sgFGD_COORD[1][0], &incoming->sgFGD_COORD[1][1], &incoming->sgFGD_COORD[1][2], &incoming->sgFGD_COORD[1][3],
 483                             &incoming->sgFGD_COORD[2][0], &incoming->sgFGD_COORD[2][1], &incoming->sgFGD_COORD[2][2], &incoming->sgFGD_COORD[2][3],
 484                             &incoming->sgFGD_COORD[3][0], &incoming->sgFGD_COORD[3][1], &incoming->sgFGD_COORD[3][2], &incoming->sgFGD_COORD[3][3]);
 485
 486 //                    printf(" sscanf input: %d\n",i);
 487                     printf(" sgMat4: \n%f %f %f %f %f %f %f %f %f %f %f %f %f %f %f %f\n",
 488                                            incoming->sgFGD_COORD[0][0], incoming->sgFGD_COORD[0][1], incoming->sgFGD_COORD[0][2], incoming->sgFGD_COORD[0][3],
 489                                            incoming->sgFGD_COORD[1][0], incoming->sgFGD_COORD[1][1], incoming->sgFGD_COORD[1][2], incoming->sgFGD_COORD[1][3],
 490                                            incoming->sgFGD_COORD[2][0], incoming->sgFGD_COORD[2][1], incoming->sgFGD_COORD[2][2], incoming->sgFGD_COORD[2][3],
 491                                            incoming->sgFGD_COORD[3][0], incoming->sgFGD_COORD[3][1], incoming->sgFGD_COORD[3][2], incoming->sgFGD_COORD[3][3]);
 492                     list_setval_Mat4(fgd_client.adr);
 493                     }
 494                     else strcpy( fgd_client.adr, "UNKNOWN");
 495       /* writing answer back to client */
 496                 sprintf( (char*) buff, "FGDLH%s", fgd_client.adr);
 497                 buff[3] = strlen(fgd_client.adr) + 1;
 498                 buff[4] = buff[buff[3]+5] = 0;
 499                 printf("    IP : %s\n", fgd_client.adr);
 500                 write( my_sock, &buff, buff[3]+5);
 501 //                      close(my_sock);
 502                 break;
 503       case 6:   printf(" fgd   : Send all DATA to client\n");
 504                 sprintf( (char*) buff, "%s %s", "FGD", fgd_client.adr);
 505                 buff[3] = 0;
 506                 fgd_cnt = 0;
 507                 fgd_curpos = 6;
 508                 test = head->next;
 509                 while (test != tail) {
 510                    printf("    IP : %-16s  Callsign : %-16s\n", test->ipadr, test->callsign);
 511                    fgd_cnt++;
 512                 /* IP */
 513                    fgd_ele_len = strlen(test->ipadr);
 514                    printf(" ele_len %d  curpos %d\n", fgd_ele_len, fgd_curpos);
 515                    buff[fgd_curpos] = fgd_ele_len;
 516                    fgd_curpos++;
 517                    bcopy(test->ipadr, &buff[fgd_curpos], fgd_ele_len);
 518                    fgd_curpos = fgd_curpos + fgd_ele_len;
 519                 /* Callsign */
 520                    fgd_ele_len = strlen(test->callsign);
 521                    printf(" ele_len %d  curpos %d\n", fgd_ele_len, fgd_curpos);
 522                    buff[fgd_curpos] = fgd_ele_len;
 523                    fgd_curpos++;
 524                    bcopy(test->callsign, &buff[fgd_curpos], fgd_ele_len);
 525                    fgd_curpos = fgd_curpos + fgd_ele_len;
 526                 /* Lat, Lon, Alt, Speed, Roll, Pitch, Yaw
 527                    hope this sprintf call is not too expensive */
 528                    sprintf( fgd_txt, " %7.3f %7.3f %7.3f %7.3f %7.3f %7.3f %7.3f",
 529                             test->latf, test->lonf, test->altf, test->speedf,
 530                             test->rollf, test->pitchf, test->yawf);
 531                    printf(" ele_len %d  curpos %d\n", fgd_ele_len, fgd_curpos);
 532                    printf(" Data : %s\n", fgd_txt);
 533                    bcopy((char *) fgd_txt, &buff[fgd_curpos], 56);
 534                    fgd_curpos += 56;
 535                    test = test->next;
 536                 }
 537                 if (fgd_cnt == 0) fgd_curpos --;
 538                 printf(" ele_len %d  curpos %d\n", fgd_ele_len, fgd_curpos);
 539                 buff[3] = fgd_curpos;
 540                 buff[4] = fgd_curpos / 256;
 541                 buff[5] = fgd_cnt;
 542                 write( my_sock, &buff, fgd_curpos);
 543 //                      close(my_sock);
 544                 break;
 545       case 18:  printf(" fgd   : Send all Mat4 DATA to client\n");
 546                 sprintf( (char*) buff, "FGDLH");
 547                 buff[3] = buff[4] = 0;
 548                 fgd_cnt = 0;
 549                 fgd_curpos = 6;
 550                 test = head->next;
 551                 while (test != tail) {
 552                    printf("    IP : %-16s  Callsign : %-16s\n", test->ipadr, test->callsign);
 553                    fgd_cnt++;
 554                 /* IP */
 555                    fgd_ele_len = strlen(test->ipadr);
 556                    printf(" ele_len %d  curpos %d\n", fgd_ele_len, fgd_curpos);
 557                    buff[fgd_curpos] = fgd_ele_len;
 558                    fgd_curpos++;
 559                    bcopy(test->ipadr, &buff[fgd_curpos], fgd_ele_len);
 560                    fgd_curpos = fgd_curpos + fgd_ele_len;
 561                 /* Callsign */
 562                    fgd_ele_len = strlen(test->callsign);
 563                    printf(" ele_len %d  curpos %d\n", fgd_ele_len, fgd_curpos);
 564                    buff[fgd_curpos] = fgd_ele_len;
 565                    fgd_curpos++;
 566                    bcopy(test->callsign, &buff[fgd_curpos], fgd_ele_len);
 567                    fgd_curpos = fgd_curpos + fgd_ele_len;
 568                 /* Lat, Lon, Alt, Speed, Roll, Pitch, Yaw
 569                    hope this sprintf call is not too expensive */
 570                    fgd_len_msg = sprintf( fgd_txt, " %f %f %f %f %f %f %f %f %f %f %f %f %f %f %f %f",
 571                           test->sgFGD_COORD[0][0], test->sgFGD_COORD[0][1], test->sgFGD_COORD[0][2], test->sgFGD_COORD[0][3],
 572                           test->sgFGD_COORD[1][0], test->sgFGD_COORD[1][1], test->sgFGD_COORD[1][2], test->sgFGD_COORD[1][3],
 573                           test->sgFGD_COORD[2][0], test->sgFGD_COORD[2][1], test->sgFGD_COORD[2][2], test->sgFGD_COORD[2][3],
 574                           test->sgFGD_COORD[3][0], test->sgFGD_COORD[3][1], test->sgFGD_COORD[3][2], test->sgFGD_COORD[3][3]);
 575                  fgd_txt[fgd_len_msg] = 0;
 576                    printf(" ele_len %d  curpos %d\n", fgd_ele_len, fgd_curpos);
 577                    printf(" Data : %s\n", fgd_txt);
 578                    bcopy((char *) fgd_txt, &buff[fgd_curpos], fgd_len_msg+1);
 579                    fgd_curpos += fgd_len_msg+1;
 580                    test = test->next;
 581                 }
 582                 if (fgd_cnt == 0) fgd_curpos -= 1;
 583                 printf(" ele_len %d  curpos %d\n", fgd_ele_len, fgd_curpos);
 584                 buff[3] = fgd_curpos & 0xff;
 585                 buff[4] = fgd_curpos / 256;
 586                 buff[5] = fgd_cnt;
 587                 printf("ANZ: %d  CURPOS: %d\n", (unsigned char) buff[3] + (unsigned char) buff[4] * 256, fgd_curpos);
 588                 write( my_sock, &buff, fgd_curpos);
 589 //                      close(my_sock);
 590                 break;
 591       case 8:   printf(" fgd   : Unregister\n");
 592                 read( my_sock, &buff, 1);
 593                 fgd_ele_len = (int) &buff;
 594                 read( my_sock, &buff, fgd_ele_len);
 595                 ip = (int *) buff;
 596                 fgd_client.adr = (char*) inet_ntoa( *ip);
 597                 printf("    IP : %s\n", fgd_client.adr);
 598                 if (verbose != 0) printf("not_in (CASE) : %d\n", list_not_in(fgd_client.adr));
 599                 if (list_not_in(fgd_client.adr) == -1) {
 600                     list_clear(fgd_client.adr);
 601                     }
 602                     else strcpy( fgd_client.adr, "UNKNOWN");
 603       /* writing answer back to client */
 604                 sprintf( (char*) buff, "FGDLH%s", fgd_client.adr);
 605                 buff[3] = strlen(fgd_client.adr) + 1;
 606                 buff[4] = buff[buff[3]+5] = 0;
 607                 printf("    IP : %s\n", fgd_client.adr);
 608                 write( my_sock, &buff, buff[3]+5);
 609 //  Just leaving the old stuff in, to correct it for FGFS later...
 610 //  I'm sick of this f$%&ing libc5/glibc2.0/2.1 quirks
 611 //  Oliver...very angry...
 612 //      /* writing answer back to client */
 613 //                sprintf( (char*) buff, "%s %s", "FGD", fgd_client.adr);
 614 //                buff[3] = strlen(fgd_client.adr);
 615 //                printf("    IP : %s\n", fgd_client.adr);
 616 //                write( my_sock, &buff, buff[3]+4);
 617 //                close(my_sock);
 618                 break;
 619       case 9:   printf(" fgd   : Shutdown\n");
 620                 close(my_sock);
 621                 close(sock);
 622                 exit(0);
 623       default:  printf(" fgd   : Huh?...Unknown Command\n");
 624                 break;
 625       }
 626     }
 627     }
 628 /*
 629      switch (verbose) {
 630       case 0: printf("%d\n",base_port+current_port);
 631               break;
 632       case 1: service_info = getservbyport(htons(base_port+current_port),"tcp");
 633               if (!service_info) {
 634               printf("%d -> service name unknown\n",base_port+current_port);
 635               } else {
 636               printf("%d -> %s\n",base_port+current_port,service_info->s_name);
 637               }
 638               break;
 639       case 2: service_info = getservbyport(htons(base_port+current_port),"tcp");
 640               if (!service_info) {
 641               printf("Port %d found. Service name unknown\n",base_port+current_port);
 642               } else {
 643               printf("Port %d found. Service name: %s\n",base_port+current_port,service_info->s_name);
 644               }
 645               break;
 646      }
 647 */
 648     }  else if (errno == 113) {
 649          fprintf(stderr,"No route to host !\n");
 650          exit(1);
 651        }
 652 /*     current_port++; */
 653    }
 654
 655   if (verbose == 2) printf("Port scan finished !\n");
 656 }