From a056d93a99e1717677877a3e8980b3e7caa76972 Mon Sep 17 00:00:00 2001 From: curt Date: Thu, 13 Jan 2000 17:27:32 +0000 Subject: [PATCH] 13 Dec 2000 updates from Oliver. --- src/NetworkOLK/Tools/FILES | 9 + src/NetworkOLK/Tools/HEADERS | 11 + src/NetworkOLK/Tools/Makefile | 14 +- src/NetworkOLK/Tools/README | 232 +++++++++-- src/NetworkOLK/Tools/fgd.c | 499 +++++++++++++++++----- src/NetworkOLK/Tools/fgd.h | 8 + src/NetworkOLK/Tools/fgd_com.c | 94 +++-- src/NetworkOLK/Tools/fgd_mcp.c | 593 ++++++++++++++++++++++++++ src/NetworkOLK/Tools/fgd_scan.c | 10 +- src/NetworkOLK/Tools/fgd_verbose.c | 642 +++++++++++++++++++++++++++++ 10 files changed, 1914 insertions(+), 198 deletions(-) create mode 100644 src/NetworkOLK/Tools/FILES create mode 100644 src/NetworkOLK/Tools/HEADERS create mode 100644 src/NetworkOLK/Tools/fgd.h create mode 100644 src/NetworkOLK/Tools/fgd_mcp.c create mode 100644 src/NetworkOLK/Tools/fgd_verbose.c diff --git a/src/NetworkOLK/Tools/FILES b/src/NetworkOLK/Tools/FILES new file mode 100644 index 000000000..13d08a414 --- /dev/null +++ b/src/NetworkOLK/Tools/FILES @@ -0,0 +1,9 @@ +FILES - This file, describing the other files +HEADERS - Necessairy headers to compile the programs +README - Infos about programs +Makefile - +fgd.h - Headerfile included by all programs +fgd.c - Flightgear deamon +fgd_com.c - Sends commandos to fgd +fgd_scan.c - Scanner to detect Flightgear deamons via TCP +fgd_mcp.c - Master Control Program for fgd diff --git a/src/NetworkOLK/Tools/HEADERS b/src/NetworkOLK/Tools/HEADERS new file mode 100644 index 000000000..09b47436d --- /dev/null +++ b/src/NetworkOLK/Tools/HEADERS @@ -0,0 +1,11 @@ +Please check the presence of the following header files on your system + +#include +#include +#include +#include +#include +#include +#include +#include +#include \ No newline at end of file diff --git a/src/NetworkOLK/Tools/Makefile b/src/NetworkOLK/Tools/Makefile index 40eecdd58..1c7461f81 100644 --- a/src/NetworkOLK/Tools/Makefile +++ b/src/NetworkOLK/Tools/Makefile @@ -2,7 +2,7 @@ CPPFLAGS = CFLAGS = CC = gcc RM = rm -PROGS = fgd fgd_scan fgd_com +PROGS = fgd fgd_scan fgd_com fgd_mcp fgd_verbose BINDIR = /usr/local/bin all: $(PROGS) @@ -10,21 +10,23 @@ all: $(PROGS) fgd: fgd.c $(CC) -o $@ $^ +fgd_verbose: fgd_verbose.c + $(CC) -o $@ $^ + fgd_scan: fgd_scan.c $(CC) -o $@ $^ fgd_com: fgd_com.c $(CC) -o $@ $^ +fgd_mcp: fgd_mcp.c + $(CC) -o $@ $^ + clean: -$(RM) -f *.o $(PROGS) *~ core -install: all devs - install -d $(BINDIR) +install: all install $(PROGS) $(BINDIR) - install -d $(MANDIR)/man4 - install -m 644 js.4 $(MANDIR)/man4 dist: clean tar czf ../`basename \`pwd\``.tar.gz -C .. `basename \`pwd\`` - diff --git a/src/NetworkOLK/Tools/README b/src/NetworkOLK/Tools/README index 936301d54..df6d29f05 100644 --- a/src/NetworkOLK/Tools/README +++ b/src/NetworkOLK/Tools/README @@ -1,117 +1,287 @@ Welcome to FlightGear Deamon fgd -------------------------------- Here the first Tools to play with FlightGear Deamon. -This is yet pre-alpha and the sources remain to be tidied up, +This is yet alpha and the sources remain to be tidied up, and to get documented. +Why this software? +------------------ +The goal of the author is to keep unnecessairy jobs out of FGFS. This keeps +FGFS doing what it should do: simulate! +Adding more fancy stuff into FGFS would maybe spoil it's framerates and lead +to larger compiletimes. For that reason an external solution comes in quite +handy. Firing up the deamon on another machine than FGFS is running does not +affect the cpu-time of FGFS. Let the deamon do all the other jobs for your +FGFS, also let *him* communicate with the outer world and present the +results in a "precooked" way. + + Theory of operation: -------------------- -The FlightGear Deamon called fgd is a standalone program which registers +The FlightGear Deamon, called fgd, is a standalone program which registers FGFS players willing to have a multiplayer FGFS environment via TCP/IP. -Information like player's ip/lon/lat/alt etc. can be send to fgd. +Information like player's IP/lon/lat/alt etc and also messages can be send +to fgd. + The deamon fgd in turn sends back the gathered information upon request. + The purpose of the scan prog "fgd_scan" is to locate free ports on the network, which can be used for exchanging data between FGFS and fgd. -The commando program fgd_com serves as an example of how the communication -to fgd can be done. For the moment consider fgd_com as FGFS. -Parts of fgd_com will be later incorporated into FGFS. + +The commando program "fgd_com" serves as an example of how the communication +to fgd can be done. For the moment, the functionality of fgd_com is not yet +integrated into FGFS. Parts of fgd_com will be later incorporated into FGFS. + +The master control program "fgd_mcp" is some sort virtual fgfs. It simulates +up to x FlightGear simulators. It's main purpose is being a development +platform for network related stuff. The coolest advantage here is the +possibilty of having multiple fgfs's in one little program. That saves *much* +memory and also time because recompiling fgd_mcp is way faster then FGFS. How to play with the tools: --------------------------- -Just fire up fgd on whatever machine reachable from the one on which -FGFS will be running. Even the same machine is ok. +Just fire up fgd on whatever machine reachable from the one on which FGFS +will be running. Even the same machine is ok. Then use fgd_scan to locate the fgd-deamon. Also use fgd_com to pass some commandos to fgd. +Try setting up various scenarios with fgd_mcp and see if everything works. How to compile: --------------- +Have a look at the HEADERS file and check the presence of the required headers +on your machine and adjust them in the fgd.h file just in case of being located +elsewhere. This software is libc5 proof, so maybe on glibc (>=2), the header +files will be located elsewhere. + Use the Makefile with make or just gcc -o prog prog.c +Default location for "make" is current directory, so be sure to have r/w-access +to it. For "make install" you have to be root, binaries go by default into +/usr/local/bin. Usage: ------ -- fgd [start port] [end port] <-v -vv> +- fgd [start port] [end port] [name] <-v -vv> where - - start port and end port is the range where it should listen and - talk to. (Later the range will be used to check for a free port - within this range, which can be used for communicating with FGFS. + - start port and end port is the (numeric) range where it should + listen and talk to. (Later the range will be used to check for a + free port within this range, which can be used for communicating + with FGFS. for the moment make sure you use the _SAME_ port value for start - and stop. A good starting point should be above 10000. + and stop. A good starting point should be above or equal 10000. + - name (string) of the deamon. - -v or -vv is the verbose level. This param can be ommitted. + + Be careful, trying fgd on a used port doesn't work. Also it doesn't + make any sense and luckyly doesn't goof the service of the used port. + Just in case you did fgd will complain and advise you to look for an + unused port first. - fgd_scan [host] [start port] [end port] <-v -vv> -comment: params are the same as for fgd except that the start-stop range - must be different to detect fgd. +comment: params are the same as for fgd except that the start/stop values + should be different to detect fgd. In case of knowning the port, + which fgd uses, one should of course set equal port-values. Also host means the host running fgd, not where the scanner is fired up. Just for fun you can take also the dangerous (priviledged ports) - But the fgd-scanner will be stuck at some used ports. + But the fgd-scanner could maybe get stuck at some used ports. It doesn't hurt to experiment in the used regions, a ctrl-c will abort the scanning so that new params can be used. + +ACHTUNG! A well configured system, in this case the target-ip the + scanner inquires, will log the replies of various services + trying to react to the scanner. It depends on the vigilance + and mood of the respective sysadmin what will happen to the + *evil* person sending requests to the target system. + Scanning unused ports doesn't hurt at all. + + Have a look at the "/etc/services" file which describes all + the "official" services & deamons lurking on various ports. + - fgd_com [FGD-host] [start port] [end port] [-v -vv] [commando] -comment: see fgd_scan, but you must enter either a ip/fqdn or dummystring as - last param, some commandos use it to pass it as real information to - fgd. +comment: like fgd_scan, but you must enter either an ip (numeric) or alias + (string) or a fqdn (like foo.bar.com) or dummystring as last parameter + here: . + Some commandos use it to pass it as real information to fgd. Maybe the + start/end port options will go away later because it's the job of the + scanner to find fgd within a range. + It's a waste to spoil the net with commands (tcp-packets). + + +- fgd_mcp + +comment: works like fgd_com except that it is *not* a single shot program as + the other programs, yes it works interactively so you have to enter + all relevant values yourself at runtime. You can stresstest any + FlightGear deamon to see if it responds a) accurate b) fast enough. + + You can enter a Flight route just by entering the start/stop coords + and the speed. This master control program will then automagically + send information about current aircraft to the deamon, like a real + FGFS would do. + + You can even define multiple scenarios. That means that all defined + aircrafts fly simultaneous at the same time. + Relevant params here are alt, lon, lat, speed, roll, pitch, yaw, + pilot, model, start/stop-coords and update frequency. + + Watch out for broken pipes, never had any in a xterm but often on + text consoles. They will go away when the "recv"-loops will be + replaced by "select"-calls. + + The default values suit my personal needs. So don't be paniked if + you get some errormessages. You just have to adjust some values + like IP's and HOST-names in either sourcecode or to enter them at + runtime. The commandos for fgd_com: -------------------------- - 0 : fgd idenditfies itself, answeres back to scanner + 0 : fgd identifies itself and answeres back to scanner 1 : registering to fgd 2 : show who's registered 3 : send message to one specific user (not implemented yet) 4 : send message to all users (not implemented yet) 5 : scan for other fgd's (not implemented yet) - 6 : update (fgd sends it's database to user) (not implemented yet) + 6 : push (fgd_com sends FGFS-data to fgd) (not implemented yet) + 7 : pop (fgd_com receives data from fgd) (not implemented yet) 8 : unregister from fgd 9 : shutdown fgd Comments: --------- -Commands 1/2/8 use the last parameter (see above, dummy-string) for the +Commandos 1/2/8 use the last parameter (see above, dummy-string) for the ip or hostname or fqdn of the fgfs-machine which will be added/listed/removed from fgd. + +Commandos 3+4 are some sort of "talk" to registered users on fgd. +The messages are keyed in, then send and stored into fgd until the +recepient user requests fgd data via command 7 (pop). + +Command 5 scans the net (within a range given) for other fgd-deamons. + +Commandos 6+7 are seperated send/receive requests to/from fgd. +Later it will be FGFS who queries fgd in given intervalls. By now it's +the user who sends/receives at will via menu or keyboard while flying. + +Command 9 is a remote shutdown for fgd. This at least avoids telnetting +to the remote machine, where fgd is fired up. Caveat Emptor: be careful, +everybody connected to fgd can send the "fgd-shutdown"-command. And hey, +also everybody can unregister another user... + +Since all FGFS pilots are friendly and Multipilot-mode is considered +cooperative rather then deathmatch, I don't expect any malicious mis-use +of Multipilot-mode, err...yes? Also this keeps me from adding foolproof +if/then/else-stuff because FGFS is a serious Simulation Software used by +serious people who *know* what they are doing, even if they store FGFS in +directories like: + /usr/games/fgfs or D:\SPEL\FlightGear or /home/olk/spiele/fgfs + Try registering and unregistering various hosts to see if the add/remove -mechanism works well. It should work correctly. +mechanism works well. It should work correctly as it can be veryfied +with the "2" command. Examples: --------- -- fgd olk 10003 10003 -vv - fgd runs on host "olk" using port "10003" using max. verbose level +- fgd 10003 10003 Johnney -vv + fgd runs locally on port "10003" called "Johnney" using max. verbose level + +- fgd_scan olk 1 1024 -vv + scans for flightgear deamons on host "olk" using ports "1" thru "1024" + beeing very verbose. Using ports below 10000 is, err...you know. - fgd_com olk 10003 10003 -vv 1 johnny send "register host"-command to fgd running on host "olk" using port"10003" - and register machine "johnny" + and register machine "johnny", here "johnny" is a fqdn. + +- fgd_mcp (without any commandline params) + To do: ------ +- modify FGFS to talk to fgd and display the data on HUD and draw any found + pilot's aircraft within visible area +- porting to Mac and Windows(95/98/2K/NT) - clean-up code +- replace "recv"-loops by "select" (blocking vs nonblocking discussion) +- concatenate the elements of one command into one single net-call instead + of sending each element seperately !!! +- reducing of data to be transfered - here: wiping out redundancy, + computers can be upgraded easily but upgrading the bandwith of the net is + almost impossible ;-(( - document the code -- convert code from c to c++ -- find a place within FGFS where to reside +- convert code from c to c++ ? +- find a place within FGFS, where to reside +- make fgd a *REAL* deamon which is forked in background +- make fgd concurrent instead of iterative, hmmm... - make the code more autodetectable, to reduce commandline params - implement missing commands - find other useful commands - find and resolve bugs ;-) +History: +-------- + v0.1pre-alpha: May 25 1999 -> First release + v0.1-alpha : Nov 08 1999 -> Introducing fgd-Master-Control-Program + Some cleanups, implementing missing commands + of fgd_com into fgd_mcp + Nov 29 1999 -> Implementing scenario functions like virtual + Pilots + Nov 30 1999 -> ??? + + +Future Plans: +------------- + Adding support for downloading files from Webserververs or FTP sites, + eg. weather data (METAR) and passing the infos to FGFS. + + Adding some sort of "Tower Control" to the deamon. It could for instance + calculate the nearest airport for each pilot. + + Modifying FGFS in a way to accept foreign-data. A so called remote-used + FGFS could display another view of the same flight. Well this requires + at least two or more machines, err...hummm. + On the other hand a remote used FGFS could serve as a teaching facility, + watching somebody else's fly could be very instructive ;-) + + Another idea is to implement "black box" features into fgd. The deamon + would serve here as a flightrecorder. By this one could review a past + flight or any flight recorded by somebody else. The recorded "scenario files" + could be read by any deamon and serve as input data for any FGFS switched + into remote mode, see above paragraph. + + +Thanks: +------- + - W.Richard Stevens+, for his fantastic Unix Network Programming books + - Tennessee Carmel-Veilleux, e-mail: veilleux@ameth.org, for his portscan + program which inspired me writing the FlightGear metwork support. + + REMEMBER: --------- -This 3 toys are pre-alpha and dirty and need also to be documented. +Those 4 toys are alpha and dirty and need also to be documented. +The programs are fairly well tested under Linux only, but the code should +conform to Unix98. + +This software is OPEN SOURCE SOFTWARE, this helps to avoid this package to +be involved into _EVIL_ discussions about copyrights etc... +You can do whatever you want with this software, even enhance it. -Send comments/flame/beer/whatever to delise@rp-plus.de +Send comments/flames/BEER/whatever to delise@mail.isis.de -Oliver Delise 25/May/99 +Oliver Delise Nov/08/99 diff --git a/src/NetworkOLK/Tools/fgd.c b/src/NetworkOLK/Tools/fgd.c index dc875ddff..a41b93395 100644 --- a/src/NetworkOLK/Tools/fgd.c +++ b/src/NetworkOLK/Tools/fgd.c @@ -1,33 +1,34 @@ -/***********************************************************/ -/* FGD.C by Oliver Delise */ -/* Contact info: */ -/* e-mail: delise@rp-plus.de */ -/* www: http://www.online-club.de/~olk/progs/mmx-emu/ */ -/* ftp: http://www.online-club.de/~olk/progs/flightgear */ -/* */ -/* Version 0.1pre-alpha */ -/* The author of this program offers no waranty at all */ -/* about the correct execution of this software material. */ -/* Furthermore, the author can NOT be held responsible for */ -/* any physical or moral damage caused by the use of this */ -/* software. */ -/* */ -/* This is a standalone Tool to communicate with any */ -/* FlightGear System and FGFS-Deamon. */ -/* This is Open Source Software with many parts */ -/* shamelessly stolen from others... */ -/* */ -/* -> This program will scan for TCP port listening on a */ -/* remote or local host inside the range you give to it.*/ -/* I offer no warranty over the accuracy though :) */ -/* There are 3 verbose modes: No info, service info, and*/ -/* full info. No info is good of you only want the list */ -/* of the ports, no more info. The best mode is Full */ -/* info, as you get error information,etc. The main */ -/* output is STDOUT, and ALL the errors go to STDERR. */ -/* */ -/* History: v0.1pre-alpha: May 25 1999 -> First release */ -/***********************************************************/ +/*************************************************************/ +/* FGD.C by Oliver Delise */ +/* Contact info: */ +/* e-mail: delise@mail.isis.de */ +/* www: http://www.isis.de/members/~odelise/progs/mmx-emu/ */ +/* ftp: http://www.isis.de/members/~odelise/progs/flightgear */ +/* */ +/* Version 0.1-alpha */ +/* The author of this program offers no waranty at all */ +/* about the correct execution of this software material. */ +/* Furthermore, the author can NOT be held responsible for */ +/* any physical or moral damage caused by the use of this */ +/* software. */ +/* */ +/* This is a standalone Tool to communicate with any */ +/* FlightGear System and FGFS-Deamon. */ +/* This is Open Source Software with some parts */ +/* shamelessly stolen from others... */ +/* */ +/* -> This program will use a TCP port listening on a */ +/* remote or local host inside the range you give to it. */ +/* I offer no warranty over the accuracy though :) */ +/* There are 3 verbose modes: No info, service info, and */ +/* full info. No info is good of you only want the list */ +/* of the ports, no more info. The best mode is Full */ +/* info, as you get error information,etc. The main */ +/* output is STDOUT, and ALL the errors go to STDERR. */ +/* */ +/* History: v0.1pre-alpha: May 25 1999 -> First release */ +/* v0.1-alpha : Nov 08 1999 */ +/*************************************************************/ #include @@ -40,6 +41,7 @@ #include #include +#define printf // /* Net-stuff */ fd_set rset, allset; @@ -48,31 +50,48 @@ struct timeval tv; struct utsname myname; char *fgd_host, *src_host; +/* Program-stuff */ +int verbose, fgd_len_msg; + /* List-stuff (doubly-Linked-list) */ #include #include -int i,j; -char *vb; +int i, j, fgd_cnt, fgd_curpos; +char *vb, *fgd_txt; const int True = 0; const int False= -1; +float sgFGD_COORD[4][4]; + struct list_ele { - unsigned char ipadr[16], squak[16]; - float *lon, *lat, *alt, *roll, *pitch, *yaw; + unsigned char ipadr[16], callsign[16]; + unsigned char lat[8], lon[8], alt[8], speed[8], roll[8], pitch[8], yaw[8]; + float latf, lonf, altf, speedf, rollf, pitchf, yawf; + float sgFGD_COORD[4][4]; struct list_ele *next, *prev; }; -struct list_ele *head, *tail, *act, *test; /* fgd_msg; */ +struct list_ele *head, *tail, *act, *test, *incoming; /* fgd_msg; */ + +struct fgd_sock_list { + char adr[16]; + int prev_sock; +}; + +struct fgd_sock_list fgd_cli_list[255]; +int fgd_known_cli = -1; /* False */ +int fgd_cli = 0; /*...Create head and tail of list */ void list_init( void) { + incoming = (struct list_ele*) malloc(sizeof(struct list_ele)); head = (struct list_ele*) malloc(sizeof(struct list_ele)); tail = (struct list_ele*) malloc(sizeof(struct list_ele)); if (head == NULL || tail == NULL) { printf("Out of memory\n"); exit(1); } /* fixme :Where is the "with foobar do command " head->ipadr = "127.0.0.0"; - head->squak = "None"; + strcpy(head->callsign, "None"); head->lon = 0; head->lat = 0; head->alt = 0; @@ -80,7 +99,7 @@ void list_init( void) { head->roll = 0; head->yaw = 0; */ - /* yaw!. Who the f$%& invented this ;-) */ + /* yaw!. Who the f$%& invented this ;-) */ head->ipadr[0] = 0; tail->ipadr[0] = 255; tail->ipadr[1] = 0; @@ -92,18 +111,69 @@ void list_init( void) { void list_output( void) { } +void list_search( char name[16]) { + + if (strcmp(name, head->next->ipadr) <= 0) act = head; + else if (strcmp(name, tail->prev->ipadr) > 0) act = tail->prev; + else { + int vergleich = strcmp(name, act->ipadr); + if (vergleich > 0) + while (strcmp(name, act->next->ipadr) > 0) { + act = act->next; + } + else if (vergleich < 0) + while (strcmp(name, act->ipadr) < 0) { + act = act->prev; + } + else + while (strcmp(name, act->ipadr) == 0) { + act = act->prev; + } + } +} + void list_insert( char newip[16]) { struct list_ele *new_ele; new_ele = (struct list_ele*) malloc(sizeof(struct list_ele)); if (new_ele == NULL) { printf("Out of memory\n"); exit(1); } strcpy(new_ele->ipadr, newip); +/* setting default */ + strcpy(new_ele->callsign, "not assigned"); list_search( newip); new_ele->prev = act; new_ele->next = act->next; act->next->prev = act->next = new_ele; } +void list_setval( char newip[16]) { + + list_search( newip); + strcpy( act->next->callsign, incoming->callsign); + act->next->latf = incoming->latf; + act->next->lonf = incoming->lonf; + act->next->altf = incoming->altf; + act->next->speedf = incoming->speedf; + act->next->rollf = incoming->rollf; + act->next->pitchf = incoming->pitchf; + act->next->yawf = incoming->yawf; + printf("Callsign %s ", act->next->callsign); + printf(" lat: %7.3f lon: %7.3f alt: %7.3f speed: %7.3f roll: %7.3f pitch: %7.3f yaw: %7.3f", + act->next->latf, act->next->lonf, act->next->altf, act->next->speedf, + act->next->rollf, act->next->pitchf, act->next->yawf); +} + +void list_setval_Mat4( char newip[16]) { + + list_search( newip); + strcpy( act->next->callsign, incoming->callsign); + for (i=0;i<4;i++) + for (j=0;j<4;j++) + act->next->sgFGD_COORD[i][j] = incoming->sgFGD_COORD[i][j]; + printf("Callsign %s ", act->next->callsign); +} + + void list_clear( char clrip[16]) { struct list_ele *clr_ele; @@ -118,26 +188,6 @@ struct list_ele *clr_ele; } } -void list_search( char name[16]) { - - if (strcmp(name, head->next->ipadr) <= 0) act = head; - else if (strcmp(name, tail->prev->ipadr) > 0) act = tail->prev; - else { - int vergleich = strcmp(name, act->ipadr); - if (vergleich > 0) - while (strcmp(name, act->next->ipadr) > 0) { - act = act->next; - } - else if (vergleich < 0) - while (strcmp(name, act->ipadr) < 0) { - act = act->prev; - } - else - while (strcmp(name, act->ipadr) == 0) { - act = act->prev; - } - } -} int list_not_in( char name[16]) { @@ -146,7 +196,7 @@ int list_not_in( char name[16]) { while ((test != tail) && (i==True)) { i = (strcmp(test->ipadr, name) ? True : False); test = test->next; - printf("list_not_in : %d\n",i); + if (verbose != 0) printf("list_not_in : %d\n",i); } return(i); } @@ -154,13 +204,14 @@ int list_not_in( char name[16]) { -int i; int sock = -1; int my_sock; int fgd_com; +int *ip; size_t anz; -char *buff; -struct { char *adr, *squak, *lon, *lat, *alt;} fgd_client; +char buff[1024]; +char *fgd_name; +struct { char *adr, *lon, *lat, *alt;} fgd_client; int fgd_ele_len; struct sockaddr_in address; @@ -171,7 +222,6 @@ extern int errno; int current_port = 0; u_short base_port = 0; u_short end_port = 1024; -int verbose = 0; struct hostent *host_info; struct servent *service_info; @@ -179,23 +229,24 @@ void fgd_init(void); int main(int argc, char **argv) { - if (argc < 3) { - fprintf(stderr,"Usage: fgd [start port] [end port] <-v or -vv>\n"); + if (argc < 4) { + fprintf(stderr,"Usage: fgd [start port] [end port] [name] <-v or -vv>\n"); exit(1); } switch (argc) { - case 4: if (!strcmp(argv[3],"-v")) + case 5: if (!strcmp(argv[4],"-v")) verbose = 1; - else if (!strcmp(argv[3],"-vv")) + else if (!strcmp(argv[4],"-vv")) verbose = 2; - else { fprintf(stderr,"Usage: fgd [start port] [end port] <-v or -vv>\n"); + else { fprintf(stderr,"Usage: fgd [start port] [end port] [name] <-v or -vv>\n"); exit(1); } - case 3: base_port = (u_short)atoi(argv[1]); + case 4: base_port = (u_short)atoi(argv[1]); end_port = (u_short)atoi(argv[2]); + fgd_name = argv[3]; break; - default: fprintf(stderr,"Usage: fgd [start port] [end port] <-v or -vv>\n"); + default: fprintf(stderr,"Usage: fgd [start port] [end port] [name] <-v or -vv>\n"); exit(1); break; } @@ -203,9 +254,9 @@ int main(int argc, char **argv) bzero((char *)&address, sizeof(address)); address.sin_family = AF_INET; if (uname(&myname) == 0) fgd_host = myname.nodename; - printf("I am running on HOST : %s\n", fgd_host); + printf(" I am running as %s on HOST %s\n", fgd_name, fgd_host); - if (verbose == 2) printf("Resolving: %s ->",fgd_host); + if (verbose == 2) printf(" Resolving: %s ->",fgd_host); if (host_info = gethostbyname(fgd_host)) { bcopy(host_info->h_addr, (char *)&address.sin_addr,host_info->h_length); printf(" fgd : ip = %s\n", inet_ntoa( address.sin_addr)); @@ -221,11 +272,11 @@ int main(int argc, char **argv) fprintf(stderr,"Bad port range : start=%d end=%d !\n"); exit(1); } else if (verbose == 2) { - printf("Port range: %d to %d\n",base_port,end_port); + printf(" Port range: %d to %d\n",base_port,end_port); } - vb = (char) &verbose; - printf("vb %s",&vb); - exit(0); + printf(" verbose: %d\n",verbose); + /* some init stuff */ + fgd_txt = (char *) malloc(1024); list_init(); fgd_init(); exit(0); @@ -233,7 +284,7 @@ int main(int argc, char **argv) void fgd_init(void) { -struct { char *ip, *squak, *lon, *lat, *alt;} fg_id; +struct { char *ip, *lon, *lat, *alt;} fg_id; current_port = base_port; @@ -246,9 +297,12 @@ struct { char *ip, *squak, *lon, *lat, *alt;} fg_id; } address.sin_port = htons(current_port); - printf("address.sin_port : %d\n",htons(address.sin_port)); + if (verbose == 2) printf(" address.sin_port : %d\n",htons(address.sin_port)); if (1 == 1) { - bind(sock, (struct sockaddr *)&address, sizeof(address)); + if ( bind(sock, (struct sockaddr *)&address, sizeof(address)) == -1) { + printf(" Aiiiieeehh...ADRESS ALSO IN USE...\7hmmm...please check another port\n"); + exit(-1); + } listen(sock, 5); /* Hier neu */ @@ -261,80 +315,298 @@ for (;;){ tv.tv_usec = 0; nready = select( sock + 1, &rset, NULL, NULL, &tv); if (FD_ISSET( sock, &rset)) { - my_sock = accept( sock, (struct sockaddr *)&address, sizeof(address)); + my_sock = accept( sock, (struct sockaddr *)&address, (int*) sizeof(address)); anz = 2; - /* reading length of senders' ip */ fgd_ele_len = 0; - buff = ""; - read( my_sock, &buff, 1); - fgd_ele_len = (int)(char) buff; + read( my_sock, buff, 1); + fgd_ele_len = buff[0]; + if (verbose == 2) printf("ele_len %d\n", fgd_ele_len); /* reading senders' ip */ read( my_sock, &buff, fgd_ele_len); - fgd_client.adr = inet_ntoa(buff); + ip = (int *) buff; +// printf("%d %d %d %d %x %x %x\n", buff[0], buff[1], buff[2], buff[3], &ip, ip, *ip); + fgd_client.adr = (char*) inet_ntoa( *ip); src_host = fgd_client.adr; /* reading commando */ read( my_sock, &buff, 1); +/* closing previous file descriptor of same client, at least we know now + that the previous command is finished since it's the same client who + again requests something. Maybe I'm to quick and diiirty ;-) */ + printf("FGD : Using socket #%d\n", my_sock); + fgd_known_cli = False; + for ( fgd_cnt = 1; fgd_cnt < fgd_cli+1; fgd_cnt++) { + printf("FGD : fgd_cnt:%d fgd_cli:%d fgd_client.adr: %s prev.sock:%d fgd_cli_list[fgd_cnt].adr: %s\n", + fgd_cnt, fgd_cli, fgd_client.adr, + fgd_cli_list[fgd_cnt].prev_sock, fgd_cli_list[fgd_cnt].adr); + if ( strcmp( fgd_cli_list[fgd_cnt].adr, fgd_client.adr) == 0) { + printf("FGD : In Vergleichsloop. Closing socket: %d\n", + fgd_cli_list[fgd_cnt].prev_sock); + close( fgd_cli_list[fgd_cnt].prev_sock); + fgd_cli_list[fgd_cnt].prev_sock = my_sock; + fgd_known_cli = True; + } + } + if ( fgd_known_cli == False) { + fgd_cli++; + fgd_cli_list[fgd_cli].prev_sock = my_sock; + strcpy(fgd_cli_list[fgd_cli].adr, fgd_client.adr); + } printf(" Commando received : %s from Host : %s\n", &buff, src_host); - fgd_com = (int) atoi(&buff); + fgd_com = ( (char) buff[0]) - 0x30; + printf("%d \n", fgd_com); switch (fgd_com) { case 0: printf(" fgd : Identify\n"); - write( my_sock, "FGD", 3); - close(my_sock); + sprintf( (char*) buff, "FGDLH%s", fgd_name); + buff[3] = strlen(fgd_name) + 1; /* Lo, incl.zero */ + buff[4] = 0; /* Hi, names < 0xff ! */ + buff[buff[3] + 4] = 0; /* Term.zero */ + printf(" I am : %s\n", fgd_name); + write( my_sock, &buff, buff[3]+5); /* fgd housekeeping ;-) */ + // close(my_sock); break; case 1: printf(" fgd : Register\n"); /* reading length of FGFS_host ip */ fgd_ele_len = 0; - buff = ""; read( my_sock, &buff, 1); - fgd_ele_len = (int)(char) buff; + fgd_ele_len = (int) &buff; /* reading FGFS_host ip */ read( my_sock, &buff, fgd_ele_len); - fgd_client.adr = inet_ntoa(buff); - if (list_not_in(fgd_client.adr) == True) list_insert(fgd_client.adr); - printf(" IP : %s\n", fgd_client.adr); - printf(" PILOT : %s\n", "OLK"); - printf(" LON : %s\n", "42.26"); - printf(" LAT : %s\n", "21.89"); - printf(" ALT : %s\n", "6000"); - close(my_sock); + ip = (int *) buff; + fgd_client.adr = (char*) inet_ntoa( *ip); + if (list_not_in(fgd_client.adr) == True) { + list_insert(fgd_client.adr); + list_search(fgd_client.adr); +// strcpy(act->callsign, "None"); + printf(" Setting default values\n"); + printf(" IP : %s\n", act->next->ipadr); + printf(" PILOT : %s\n", act->next->callsign); + } + /* writing answer back to client */ + sprintf( (char*) buff, "FGDLH%s", fgd_client.adr); + buff[3] = strlen(fgd_client.adr) + 1; /* Lo, incl.zero */ + buff[4] = 0; /* Hi, names < 0xff ! */ + buff[buff[3] + 4] = 0; /* Term.zero */ + write( my_sock, &buff, buff[3]+5); /* fgd housekeeping ;-) */ + // close(my_sock); break; case 2: printf(" fgd : Show Registered\n"); + sprintf( (char*) buff, "FGD"); + // buff[3] = buff[4] = 0; + fgd_cnt = 0; + fgd_curpos = 6; test = head->next; while (test != tail) { - printf(" ip : %s\n", test->ipadr); + printf(" IP : %s\n", test->ipadr); + fgd_cnt++; + fgd_ele_len = strlen(test->ipadr) + 1; +// printf(" ele_len %d curpos %d\n", fgd_ele_len, fgd_curpos); + buff[fgd_curpos] = fgd_ele_len; + fgd_curpos++; + bcopy(test->ipadr, &buff[fgd_curpos], fgd_ele_len); + fgd_curpos += fgd_ele_len; + //buff[fgd_curpos] = 0; test = test->next; } - close(my_sock); - break; + if (fgd_cnt == 0) fgd_curpos--; + buff[3] = fgd_curpos & 0xff; + buff[4] = fgd_curpos >> 8; + buff[5] = fgd_cnt; + write( my_sock, &buff, fgd_curpos); +// close(my_sock); + break; case 3: printf(" fgd : Send MSG\n"); - close(my_sock); +// close(my_sock); break; case 4: printf(" fgd : Send MSG to all\n"); - close(my_sock); +// close(my_sock); break; - case 5: printf(" fgd : Scan for fgd's\n"); - close(my_sock); - break; - case 6: printf(" fgd : Update\n"); - close(my_sock); + case 5: printf(" fgd : Get DATA from client\n"); + read( my_sock, &buff, 1); + fgd_ele_len = buff[0]; + read( my_sock, &buff, fgd_ele_len); + ip = (int *) buff; + fgd_client.adr = (char*) inet_ntoa( *ip); + printf(" IP : %s\n", fgd_client.adr); + if (verbose != 0) printf("not_in (CASE) : %d\n", list_not_in(fgd_client.adr)); + if (list_not_in(fgd_client.adr) == False) { + printf(" Checkpoint\n"); + read( my_sock, &buff, 1); + printf(" Checkpoint 1\n"); + fgd_ele_len = buff[0]; + read( my_sock, &buff, fgd_ele_len); + incoming->callsign[fgd_ele_len] = 0; + bcopy( &buff, incoming->callsign, fgd_ele_len); + /* lat, lon */ + read( my_sock, &buff, 56); + sscanf( buff," %7f %7f %7f %7f %7f %7f %7f", &incoming->latf, &incoming->lonf, + &incoming->altf, &incoming->speedf, &incoming->rollf, + &incoming->pitchf, &incoming->yawf); + 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", + incoming->latf, incoming->lonf, incoming->altf, incoming->speedf, + incoming->rollf, incoming->pitchf, incoming->yawf); + list_setval(fgd_client.adr); + } + else strcpy( fgd_client.adr, "UNKNOWN"); + /* writing answer back to client */ + sprintf( (char*) buff, "%s %s", "FGD", fgd_client.adr); + buff[3] = strlen(fgd_client.adr); + printf(" IP : %s\n", fgd_client.adr); + write( my_sock, &buff, buff[3]+4); +// close(my_sock); + break; + case 17: printf(" fgd : Get Mat4 DATA from client\n"); + read( my_sock, &buff, 1); + fgd_ele_len = buff[0]; + read( my_sock, &buff, fgd_ele_len); + ip = (int *) buff; + fgd_client.adr = (char*) inet_ntoa( *ip); + printf(" IP : %s\n", fgd_client.adr); + if (verbose != 0) printf("not_in (CASE) : %d\n", list_not_in(fgd_client.adr)); + if (list_not_in(fgd_client.adr) == False) { + printf(" Checkpoint\n"); + read( my_sock, &buff, 1); + printf(" Checkpoint 1\n"); + fgd_ele_len = buff[0]; + read( my_sock, &buff, fgd_ele_len); + incoming->callsign[fgd_ele_len] = 0; + bcopy( &buff, incoming->callsign, fgd_ele_len); + /* lat, lon */ + read( my_sock, &buff, 158); + i = sscanf( buff," %f %f %f %f %f %f %f %f %f %f %f %f %f %f %f %f", + &incoming->sgFGD_COORD[0][0], &incoming->sgFGD_COORD[0][1], &incoming->sgFGD_COORD[0][2], &incoming->sgFGD_COORD[0][3], + &incoming->sgFGD_COORD[1][0], &incoming->sgFGD_COORD[1][1], &incoming->sgFGD_COORD[1][2], &incoming->sgFGD_COORD[1][3], + &incoming->sgFGD_COORD[2][0], &incoming->sgFGD_COORD[2][1], &incoming->sgFGD_COORD[2][2], &incoming->sgFGD_COORD[2][3], + &incoming->sgFGD_COORD[3][0], &incoming->sgFGD_COORD[3][1], &incoming->sgFGD_COORD[3][2], &incoming->sgFGD_COORD[3][3]); + +// printf(" sscanf input: %d\n",i); + printf(" sgMat4: \n%f %f %f %f %f %f %f %f %f %f %f %f %f %f %f %f\n", + incoming->sgFGD_COORD[0][0], incoming->sgFGD_COORD[0][1], incoming->sgFGD_COORD[0][2], incoming->sgFGD_COORD[0][3], + incoming->sgFGD_COORD[1][0], incoming->sgFGD_COORD[1][1], incoming->sgFGD_COORD[1][2], incoming->sgFGD_COORD[1][3], + incoming->sgFGD_COORD[2][0], incoming->sgFGD_COORD[2][1], incoming->sgFGD_COORD[2][2], incoming->sgFGD_COORD[2][3], + incoming->sgFGD_COORD[3][0], incoming->sgFGD_COORD[3][1], incoming->sgFGD_COORD[3][2], incoming->sgFGD_COORD[3][3]); + list_setval_Mat4(fgd_client.adr); + } + else strcpy( fgd_client.adr, "UNKNOWN"); + /* writing answer back to client */ + sprintf( (char*) buff, "FGDLH%s", fgd_client.adr); + buff[3] = strlen(fgd_client.adr) + 1; + buff[4] = buff[buff[3]+5] = 0; + printf(" IP : %s\n", fgd_client.adr); + write( my_sock, &buff, buff[3]+5); +// close(my_sock); + break; + case 6: printf(" fgd : Send all DATA to client\n"); + sprintf( (char*) buff, "%s %s", "FGD", fgd_client.adr); + buff[3] = 0; + fgd_cnt = 0; + fgd_curpos = 5; + test = head->next; + while (test != tail) { + printf(" IP : %-16s Callsign : %-16s\n", test->ipadr, test->callsign); + fgd_cnt++; + /* IP */ + fgd_ele_len = strlen(test->ipadr); + printf(" ele_len %d curpos %d\n", fgd_ele_len, fgd_curpos); + buff[fgd_curpos] = fgd_ele_len; + fgd_curpos++; + bcopy(test->ipadr, &buff[fgd_curpos], fgd_ele_len); + fgd_curpos = fgd_curpos + fgd_ele_len; + /* Callsign */ + fgd_ele_len = strlen(test->callsign); + printf(" ele_len %d curpos %d\n", fgd_ele_len, fgd_curpos); + buff[fgd_curpos] = fgd_ele_len; + fgd_curpos++; + bcopy(test->callsign, &buff[fgd_curpos], fgd_ele_len); + fgd_curpos = fgd_curpos + fgd_ele_len; + /* Lat, Lon, Alt, Speed, Roll, Pitch, Yaw + hope this sprintf call is not too expensive */ + sprintf( fgd_txt, " %7.3f %7.3f %7.3f %7.3f %7.3f %7.3f %7.3f", + test->latf, test->lonf, test->altf, test->speedf, + test->rollf, test->pitchf, test->yawf); + printf(" ele_len %d curpos %d\n", fgd_ele_len, fgd_curpos); + printf(" Data : %s\n", fgd_txt); + bcopy((char *) fgd_txt, &buff[fgd_curpos], 56); + fgd_curpos += 56; + test = test->next; + } + if (fgd_cnt == 0) fgd_curpos --; + printf(" ele_len %d curpos %d\n", fgd_ele_len, fgd_curpos); + buff[3] = fgd_curpos; + buff[4] = fgd_cnt; + write( my_sock, &buff, fgd_curpos); +// close(my_sock); + break; + case 18: printf(" fgd : Send all Mat4 DATA to client\n"); + sprintf( (char*) buff, "FGDLH"); + buff[3] = buff[4] = 0; + fgd_cnt = 0; + fgd_curpos = 6; + test = head->next; + while (test != tail) { + printf(" IP : %-16s Callsign : %-16s\n", test->ipadr, test->callsign); + fgd_cnt++; + /* IP */ + fgd_ele_len = strlen(test->ipadr); + printf(" ele_len %d curpos %d\n", fgd_ele_len, fgd_curpos); + buff[fgd_curpos] = fgd_ele_len; + fgd_curpos++; + bcopy(test->ipadr, &buff[fgd_curpos], fgd_ele_len); + fgd_curpos = fgd_curpos + fgd_ele_len; + /* Callsign */ + fgd_ele_len = strlen(test->callsign); + printf(" ele_len %d curpos %d\n", fgd_ele_len, fgd_curpos); + buff[fgd_curpos] = fgd_ele_len; + fgd_curpos++; + bcopy(test->callsign, &buff[fgd_curpos], fgd_ele_len); + fgd_curpos = fgd_curpos + fgd_ele_len; + /* Lat, Lon, Alt, Speed, Roll, Pitch, Yaw + hope this sprintf call is not too expensive */ + fgd_len_msg = sprintf( fgd_txt, " %f %f %f %f %f %f %f %f %f %f %f %f %f %f %f %f", + test->sgFGD_COORD[0][0], test->sgFGD_COORD[0][1], test->sgFGD_COORD[0][2], test->sgFGD_COORD[0][3], + test->sgFGD_COORD[1][0], test->sgFGD_COORD[1][1], test->sgFGD_COORD[1][2], test->sgFGD_COORD[1][3], + test->sgFGD_COORD[2][0], test->sgFGD_COORD[2][1], test->sgFGD_COORD[2][2], test->sgFGD_COORD[2][3], + test->sgFGD_COORD[3][0], test->sgFGD_COORD[3][1], test->sgFGD_COORD[3][2], test->sgFGD_COORD[3][3]); + fgd_txt[fgd_len_msg] = 0; + printf(" ele_len %d curpos %d\n", fgd_ele_len, fgd_curpos); + printf(" Data : %s\n", fgd_txt); + bcopy((char *) fgd_txt, &buff[fgd_curpos], fgd_len_msg+1); + fgd_curpos += fgd_len_msg+1; + test = test->next; + } + if (fgd_cnt == 0) fgd_curpos -= 1; + printf(" ele_len %d curpos %d\n", fgd_ele_len, fgd_curpos); + buff[3] = fgd_curpos & 0xff; + buff[4] = fgd_curpos / 256; + buff[5] = fgd_cnt; + printf("ANZ: %d CURPOS: %d\n", (unsigned char) buff[3] + (unsigned char) buff[4] * 256, fgd_curpos); + write( my_sock, &buff, fgd_curpos); +// close(my_sock); break; case 8: printf(" fgd : Unregister\n"); read( my_sock, &buff, 1); fgd_ele_len = (int) &buff; read( my_sock, &buff, fgd_ele_len); - fgd_client.adr = inet_ntoa(buff); + ip = (int *) buff; + fgd_client.adr = (char*) inet_ntoa( *ip); printf(" IP : %s\n", fgd_client.adr); - printf("not_in (CASE) : %d\n", list_not_in(fgd_client.adr)); - - if (list_not_in(fgd_client.adr) == -1) list_clear(fgd_client.adr); - close(my_sock); + if (verbose != 0) printf("not_in (CASE) : %d\n", list_not_in(fgd_client.adr)); + if (list_not_in(fgd_client.adr) == -1) { + list_clear(fgd_client.adr); + } + else strcpy( fgd_client.adr, "UNKNOWN"); + /* writing answer back to client */ + sprintf( (char*) buff, "%s %s", "FGD", fgd_client.adr); + buff[3] = strlen(fgd_client.adr); + printf(" IP : %s\n", fgd_client.adr); + write( my_sock, &buff, buff[3]+4); +// close(my_sock); break; case 9: printf(" fgd : Shutdown\n"); close(my_sock); close(sock); exit(0); - default: printf(" fgd : Illegal Command\n"); + default: printf(" fgd : Huh?...Unknown Command\n"); break; } } @@ -368,4 +640,3 @@ for (;;){ if (verbose == 2) printf("Port scan finished !\n"); } - diff --git a/src/NetworkOLK/Tools/fgd.h b/src/NetworkOLK/Tools/fgd.h new file mode 100644 index 000000000..a1cbb766b --- /dev/null +++ b/src/NetworkOLK/Tools/fgd.h @@ -0,0 +1,8 @@ +#include +#include +#include +#include +#include +#include +#include +#include diff --git a/src/NetworkOLK/Tools/fgd_com.c b/src/NetworkOLK/Tools/fgd_com.c index cef26b92c..276d98f56 100644 --- a/src/NetworkOLK/Tools/fgd_com.c +++ b/src/NetworkOLK/Tools/fgd_com.c @@ -1,11 +1,11 @@ /***********************************************************/ /* FGD_COM.C by Oliver Delise */ /* Contact info: */ -/* e-mail: delise@rp-plus.de */ +/* e-mail: delise@mail-isis.de */ /* www: http://www.online-club.de/~olk/progs/mmx-emu/ */ /* ftp: http://www.online-club.de/~olk/progs/flightgear */ /* */ -/* Version 0.1pre-alpha */ +/* Version 0.1-alpha */ /* The author of this program offers no waranty at all */ /* about the correct execution of this software material. */ /* Furthermore, the author can NOT be held responsible for */ @@ -17,7 +17,7 @@ /* This is Open Source Software with many parts */ /* shamelessly stolen from others... */ /* */ -/* -> This program will scan for TCP port listening on a */ +/* -> This program will use a TCP port listening on a */ /* remote or local host inside the range you give to it.*/ /* I offer no warranty over the accuracy though :) */ /* There are 3 verbose modes: No info, service info, and*/ @@ -27,6 +27,7 @@ /* output is STDOUT, and ALL the errors go to STDERR. */ /* */ /* History: v0.1pre-alpha: May 25 1999 -> First release */ +/* v0.1-alpha Nov 08 1999 */ /***********************************************************/ #include @@ -39,7 +40,8 @@ #include #include -int i; + +/* Netstuff */ int sock = -1; int my_sock; struct sockaddr_in address; @@ -55,53 +57,29 @@ struct hostent *host_info, *f_host_info; struct servent *service_info; struct utsname myname; +/* Program-stuff */ +int i; +int fgd_len_msg = 1; size_t anz; char *buff; -char *src_host; +char *src_host, *fgd_host, fgfs_host; +char *usage = "Usage:\n fgd_com [FGD host] [start port] [end port] [-v or -vv] [Commando] [FGFS host]\n"; -void port_scan( char *FGD_com, char *FGFS_host); -int main(int argc, char **argv) -{ - if (argc < 6) { - fprintf(stderr," Usage:\n fgd_com [FGD host] [start port] [end port] [-v or -vv] [Commando] [FGFS host]\n"); - exit(1); - } - printf("argc %d argv[5] %s\n",argc,argv[5]); - switch (argc) { - case 7: printf("fgd commando : %s\n",argv[5]); - base_port = (u_short)atoi(argv[2]); - end_port = (u_short)atoi(argv[3]); - verbose = 2; -// src_host = argv[6]; - break; - case 5: if (!strcmp(argv[4],"-v")) - verbose = 1; - else if (!strcmp(argv[4],"-vv")) - verbose = 2; - else { fprintf(stderr," Usage:\n fgd_com [FGD host] [start port] [end port] <-v or -vv> [FGFS-host]\n"); - exit(1); } +void fgd_init(void){ - case 4: base_port = (u_short)atoi(argv[2]); - end_port = (u_short)atoi(argv[3]); - break; - default: fprintf(stderr,"Usage:\n fgd_com [FGD host] [start port] [end port] <-v> [FGFS-host]\n"); - exit(1); - break; - } - bzero((char *)&address, sizeof(address)); address.sin_family = AF_INET; /* determinating the source/sending host */ if (uname(&myname) == 0) src_host = myname.nodename; printf("I'm running on HOST : %s\n", src_host); /* resolving the destination host, here fgd's host */ - if (verbose == 2) printf("Resolving: %s ->",argv[1]); - if (host_info = gethostbyname(argv[1])) { + if (verbose == 2) printf("Resolving: %s ->", fgd_host); + if (host_info = gethostbyname( fgd_host)) { bcopy(host_info->h_addr, (char *)&address.sin_addr,host_info->h_length); if (verbose == 2) printf(" resolved\n"); - } else if ((address.sin_addr.s_addr = inet_addr(argv[1])) == INADDR_NONE) { - fprintf(stderr,"Could not get %s host entry !\n",argv[1]); + } else if ((address.sin_addr.s_addr = inet_addr( fgd_host)) == INADDR_NONE) { + fprintf(stderr,"Could not get %s host entry !\n", fgd_host); printf(" NOT resolved !!!\n"); exit(1); } else if (verbose == 2) printf(" address valid\n"); @@ -111,14 +89,11 @@ int main(int argc, char **argv) exit(1); } else if (verbose == 2) { printf("Port range: %d to %d\n",base_port,end_port); - } - port_scan( argv[5], argv[6]); - exit(0); + } } -int fgd_len_msg = 1; -void port_scan( char *FGD_com, char *FGFS_host) { +void fgd_send_com( char *FGD_com, char *FGFS_host) { current_port = base_port; printf("Sending : %s\n", FGD_com); while (current_port <= end_port) { @@ -190,3 +165,36 @@ void port_scan( char *FGD_com, char *FGFS_host) { if (verbose == 2) printf("fgd_com terminated.\n"); } + +int main(int argc, char **argv) { + + if (argc < 6) { + fprintf(stderr, usage); + exit(1); + } + printf("argc %d argv[5] %s\n",argc,argv[5]); + switch (argc) { + case 7: printf("fgd commando : %s\n",argv[5]); + base_port = (u_short)atoi(argv[2]); + end_port = (u_short)atoi(argv[3]); + fgd_host = argv[1]; + verbose = 2; + break; + case 5: if (!strcmp(argv[4],"-v")) + verbose = 1; + else if (!strcmp(argv[4],"-vv")) + verbose = 2; + else { fprintf(stderr, usage); + exit(1); } + + case 4: base_port = (u_short)atoi(argv[2]); + end_port = (u_short)atoi(argv[3]); + break; + default: fprintf(stderr, usage); + exit(1); + break; + } + fgd_init(); + fgd_send_com( argv[5], argv[6]); + exit(0); +} diff --git a/src/NetworkOLK/Tools/fgd_mcp.c b/src/NetworkOLK/Tools/fgd_mcp.c new file mode 100644 index 000000000..e3466aa19 --- /dev/null +++ b/src/NetworkOLK/Tools/fgd_mcp.c @@ -0,0 +1,593 @@ +/*************************************************************/ +/* FGD_MCP.C by Oliver Delise */ +/* Contact info: */ +/* e-mail: delise@mail.isis.de */ +/* www: http://www.isis.de/members/~odelise/progs/mmx-emu/ */ +/* ftp: http://www.isis.de/members/~odelise/progs/flightgear */ +/* */ +/* Version 0.1-alpha */ +/* The author of this program offers no waranty at all */ +/* about the correct execution of this software material. */ +/* Furthermore, the author can NOT be held responsible for */ +/* any physical or moral damage caused by the use of this */ +/* software. */ +/* */ +/* This is an interactive standalone Tool to communicate */ +/* with any FlightGear-Deamon. */ +/* This is Open Source Software with many parts */ +/* shamelessly stolen from others... */ +/* */ +/* -> This program will use a TCP port listening on a */ +/* remote or local host inside the range you give to it. */ +/* I offer no warranty over the accuracy though :) */ +/* There are 3 verbose modes: No info, service info, and */ +/* full info. No info is good of you only want the list */ +/* of the ports, no more info. The best mode is Full */ +/* info, as you get error information,etc. The main */ +/* output is STDOUT, and ALL the errors go to STDERR. */ +/* */ +/* History: v0.1pre-alpha: May 25 1999 -> First release */ +/* v0.1-alpha Nov 11 1999 */ +/*************************************************************/ + +#include +#include "fgd.h" + +//#define printf // + +/* Netstuff */ +int sock = -1; +int my_sock; +struct sockaddr_in address; +struct sockaddr_in my_address; +int result; +extern char *sys_errlist[]; +extern int errno; +int current_port = 10000; +u_short base_port = 10000; +u_short end_port = 10000; +int verbose = 2; +struct hostent *host_info, *f_host_info; +struct servent *service_info; +struct utsname myname; + +/* Program-stuff */ +int i, j; +int fgd_len_msg = 1, fgd_status, fgd_ele_len, fgd_curpos, fgd_cnt, fgd_ppl, + fgd_ppl_old, fgd_loss; +size_t anz; +char *fgd_job, *fgd_callsign, *fgd_name, *fgd_ip, *fgd_mcp_ip; +char *buffp, *src_host, *fgd_host, *fgfs_host, *fgfs_pilot, *fgd_txt; + +/* List-stuff */ + +const int True = 0; +const int False= -1; + +struct list_ele { + unsigned char ipadr[16], callsign[16]; + unsigned char lon[8], lat[8], alt[8], roll[8], pitch[8], yaw[8]; + float lonf, latf, altf, speedf, rollf, pitchf, yawf; + struct list_ele *next, *prev; +}; + +struct list_ele *head, *tail, *act, *test, *incoming, *boss, *other; /* fgd_msg; */ + +/*...Create head and tail of list */ +void list_init( void) { + + incoming = (struct list_ele*) malloc(sizeof(struct list_ele)); + boss = (struct list_ele*) malloc(sizeof(struct list_ele)); + other = (struct list_ele*) malloc(sizeof(struct list_ele)); + head = (struct list_ele*) malloc(sizeof(struct list_ele)); + tail = (struct list_ele*) malloc(sizeof(struct list_ele)); + if (head == NULL || tail == NULL) { printf("Out of memory\n"); exit(1); } + head->ipadr[0] = 0; + tail->ipadr[0] = 255; + tail->ipadr[1] = 0; + head->prev = tail->prev = head; + head->next = tail->next = tail; + act = head; /* put listpointer to beginning of list */ +} + +void list_output( void) { +} + +void list_search( char name[16]) { + + if (strcmp(name, head->next->ipadr) <= 0) act = head; + else if (strcmp(name, tail->prev->ipadr) > 0) act = tail->prev; + else { + int vergleich = strcmp(name, act->ipadr); + if (vergleich > 0) + while (strcmp(name, act->next->ipadr) > 0) { + act = act->next; + } + else if (vergleich < 0) + while (strcmp(name, act->ipadr) < 0) { + act = act->prev; + } + else + while (strcmp(name, act->ipadr) == 0) { + act = act->prev; + } + } +} + +void list_insert( char newip[16]) { +struct list_ele *new_ele; + + new_ele = (struct list_ele*) malloc(sizeof(struct list_ele)); + if (new_ele == NULL) { printf("Out of memory\n"); exit(1); } + strcpy(new_ele->ipadr, newip); +/* setting default */ + strcpy(new_ele->callsign, "not assigned"); + list_search( newip); + new_ele->prev = act; + new_ele->next = act->next; + act->next->prev = act->next = new_ele; +} + +void list_setval( char newip[16]) { + + list_search( newip); + strcpy( act->next->callsign, incoming->callsign); + printf("Callsign %s\n", act->next->callsign); + +} + +void list_clear( char clrip[16]) { +struct list_ele *clr_ele; + + list_search( clrip); + if ( strcmp( clrip, act->next->ipadr)) + printf("....Name %s nicht vorhanden", clrip); + else { + clr_ele = act->next; + act->next = act->next->next; + act->next->prev = act; + free( clr_ele); + } +} + +int list_not_in( char name[16]) { + + i = True; + test = head->next; + while ((test != tail) && (i==True)) { + i = (strcmp(test->ipadr, name) ? True : False); + test = test->next; + if (verbose != 0) printf("list_not_in : %d\n",i); + } + return(i); +} + +void fgd_init(void){ + +/* Let's init a few things */ + printf("MCP: Allocating memory..."); + buffp = (char *) malloc(1024); /* No I don't check if there are another KB */ + fgd_job = (char *) malloc(8); + fgd_host = (char *) malloc(64); + fgd_callsign = (char *) malloc(64); + fgd_name = (char*) malloc(64); + fgd_ip = (char *) malloc(16); + fgd_mcp_ip = (char *) malloc(16); + fgfs_host = (char *) malloc(64); + fgfs_pilot = (char *) malloc(64); + src_host = (char *) malloc(64); + fgd_txt = (char *) malloc(1024); + printf("ok\nMCP: Initializing values..."); + strcpy( fgd_job, "xxx"); + strcpy( fgd_host, "Johnny"); + strcpy( fgd_callsign, "Unknown"); + strcpy( fgd_name, "Unknown"); + strcpy( fgd_ip, (char *) inet_ntoa(address.sin_addr)); + strcpy( fgd_txt, ""); + printf("ok\n"); + boss->latf = 112.3; + boss->lonf = 4.5; + boss->altf = 0.67; + boss->speedf = 100.95; + boss->rollf = 89.0; + boss->pitchf = 1.23; + boss->yawf = 456.789; + fgd_ppl = 0; + bzero((char *)&address, sizeof(address)); + address.sin_family = AF_INET; +/* determinating the source/sending host */ + if (uname(&myname) == 0) strcpy(src_host , myname.nodename); + printf("MCP: I'm running on HOST : %s ", src_host); + if (host_info = gethostbyname( src_host)) { + bcopy(host_info->h_addr, (char *)&address.sin_addr,host_info->h_length); + strcpy((char *) fgd_mcp_ip, (char *) inet_ntoa(address.sin_addr)); + } + printf("IP : %s\n", fgd_mcp_ip); +/* resolving the destination host, here fgd's host */ + if (verbose == 2) printf(" Resolving default DEAMON: %s ->", fgd_host); + if (host_info = gethostbyname( fgd_host)) { + bcopy(host_info->h_addr, (char *)&address.sin_addr,host_info->h_length); + strcpy((char *) fgd_ip, (char *) inet_ntoa(address.sin_addr)); + if (verbose == 2) { + printf(" resolved\n FGD running on HOST : %s", fgd_host); + printf(" IP : %s\n", fgd_ip); + } + } else if ((address.sin_addr.s_addr = inet_addr( fgd_host)) == INADDR_NONE) { + fprintf(stderr," Could not get %s host entry !\n", fgd_host); + printf(" NOT resolved !!!\n"); + exit(1); + } else if (verbose == 2) printf(" address valid\n"); + + if ((base_port > end_port) || ((short)base_port < 0)) { + fprintf(stderr,"Bad port range : start=%d end=%d !\n"); + exit(1); + } else if (verbose == 2) { + printf(" Port range: %d to %d\n",base_port,end_port); + } +} + + +void fgd_send_com( char *FGD_com, char *FGFS_host) { + + strcpy( buffp, " "); + current_port = base_port; + printf(" Sending : %s\n", FGD_com); + while (current_port <= end_port) { +/* fprintf(stderr,"Trying port: %d\n",current_port); */ + sock = socket(PF_INET, SOCK_STREAM, 0); + if (sock == -1) + { + fprintf(stderr, "Error assigning master socket: %s\n",sys_errlist[errno]); + exit(-1); + } + + address.sin_port = htons(current_port); + printf(" address.sin_port : %d\n",htons(address.sin_port)); + + f_host_info = gethostbyname(src_host); + +//printf ("src_host : %s", ntohs(f_host_info->h_addr)); + + if (connect(sock, (struct sockaddr *)&address, sizeof(address)) == 0) { +/* FIXME: make a single string instead of sending elements */ + + fgd_len_msg = (int) sizeof(f_host_info->h_addr); +/* send length of sender-ip */ + write( sock, &fgd_len_msg,1); +/* send sender-ip */ + write( sock, f_host_info->h_addr, fgd_len_msg); +/* send commando */ + write( sock, FGD_com, 1); +/* send length of dummy-string, for the moment with _WHO_ to execute commando + here: his length of ip */ + f_host_info = gethostbyname(FGFS_host); + fgd_len_msg = (int) sizeof(f_host_info->h_addr); + write( sock, &fgd_len_msg,1); +/* send dummy-string, for the moment with _WHO_ to execute commando + here: his ip */ + write( sock, f_host_info->h_addr, fgd_len_msg); +/* END FIXME */ + +/* Here we send subsequent data... */ + switch (atoi((char *) FGD_com)) { + case 5: fgd_len_msg = strlen( fgd_callsign); + write( sock, &fgd_len_msg,1); + /* send string, for the moment, here: callsign */ + write( sock, fgd_callsign, fgd_len_msg); + /* Lon, Lat, Alt, Speed, Roll, Pitch, Yaw + hope this sprintf call is not too expensive */ + sprintf( fgd_txt, " %7.3f %7.3f %7.3f %7.3f %7.3f %7.3f %7.3f", + boss->latf, boss->lonf, boss->altf, boss->speedf, + boss->rollf, boss->pitchf, boss->yawf); + write( sock, fgd_txt, 56); + break; + default: break; + } + + +/* be verbose, this goes later into own (*void) */ + printf(" Message : %s\n", FGD_com); + switch (verbose) { + case 0: printf("%d\n",current_port); + break; + case 1: service_info = getservbyport(htons(current_port),"tcp"); + if (!service_info) { + printf("%d -> service name unknown\n",current_port); + } else { + printf("%d -> %s\n",current_port,service_info->s_name); + } + break; + case 2: service_info = getservbyport(htons(current_port),"tcp"); + if (!service_info) { + printf(" Port %d found. Service name unknown\n",current_port); + } else { + printf(" Port %d found. Service name: %s\n",current_port,service_info->s_name); + } + break; + } + } else if (errno == 113) { + fprintf(stderr,"No route to host !\n"); + exit(1); + } +/* fprintf(stderr,"Error %d connecting socket %d to port %d: %s\n", + errno,sock,current_port,sys_errlist[errno]); */ + +// service_info = getservbyport(htons(current_port),"tcp"); +// if (!service_info) { + + + +/* The Receiving Part, fgd returns errormessages, succes, etc... */ + do { + fgd_status = recv( sock, (char *) buffp, 4, MSG_WAITALL); + printf(" status %d\n", fgd_status); + } +// while ( (fgd_status != 4) && (fgd_status != 0) ); + while ( (fgd_status == -1) || (fgd_status == -1) ); + if (verbose == 2) { + printf(" Got reply : %x %x %x\n", buffp[0], buffp[1], buffp[2]); + printf(" Got reply : %x\n", &buffp); + } + if (strncmp( buffp, "FGD", 3) == 0) { + switch (atoi((char *) FGD_com)) { + case 0: read( sock, fgd_name, buffp[3]); + fgd_name[buffp[3]] = 0; + printf("FGD: FlightGear-Deamon %s detected\n", fgd_name); + break; + case 1: printf("FGD: Registering Host %s\n", FGFS_host); + break; + case 2: printf("FGD: Showing registered Hosts at %s\n", fgd_host); + if (buffp[3] != 4) { +/* FIXME: replace with SELECT to avoid broken pipes, known bug (-; */ + do { + fgd_status = recv( sock, fgd_txt, buffp[3]-4, MSG_WAITALL); +// printf(" status %d\n", fgd_status); + } +// while ( (fgd_status != 4) && (fgd_status != 0) ); + while ( (fgd_status == -1) || (fgd_status == -1) ); +// read( sock, fgd_txt, buffp[3]-4); + fgd_curpos = 2; + for (fgd_cnt = 1; fgd_cnt < (fgd_txt[0]+1); fgd_cnt++) { + fgd_ele_len = fgd_txt[fgd_curpos-1]; + bcopy( &fgd_txt[fgd_curpos], fgfs_host, fgd_ele_len); + fgfs_host[fgd_ele_len] = 0; + fgd_curpos = fgd_curpos + fgd_ele_len + 1; + printf(" #%d %s\n", fgd_cnt, fgfs_host); + } + } + + break; + case 5: printf("FGD: Receiving data from Host %s\n", FGFS_host); + read( sock, fgd_txt, buffp[3]); + fgd_txt[buffp[3]] = 0; + if (strcmp(fgd_txt, "UNKNOWN") == -1) { + printf("FGD: Data from Host %s received\n", fgd_txt); + } + else printf("FGD: Host not in list, sorry...\n"); + break; + case 6: printf("FGD: Sending data to Host %s\n", FGFS_host); + if (buffp[3] != 4) { +/* FIXME: replace with SELECT */ + if (verbose == 2) printf("Noch %d bytes\n", (unsigned char) buffp[3]); + do { + fgd_status = recv( sock, fgd_txt, (unsigned char) buffp[3]-4, MSG_PEEK); + if (verbose == 2) printf("Status %d\n", fgd_status); + } + while ( (fgd_status == 4) || (fgd_status == -1) ); +// while ( (fgd_status == -1) || (fgd_status == -1) ); + read( sock, fgd_txt, buffp[3]-4); + fgd_curpos = 2; + fgd_ppl_old = fgd_ppl; + fgd_ppl = fgd_txt[0]; + /* Check if list has changed (pilot joined/left) */ + if (fgd_ppl != fgd_ppl_old) { + printf(" List changed!!!\n"); + for (fgd_cnt = 1; fgd_cnt <= abs(fgd_ppl - fgd_ppl_old); fgd_cnt++) { + printf(" Checkpoint\n"); + incoming = head->next; + if ((fgd_ppl - fgd_ppl_old) > 0) list_insert("test\0"); + else { + printf(" Clearing entry.\n"); + list_clear(incoming->ipadr); + } + } + } +// else { + incoming = head->next; + for (fgd_cnt = 1; fgd_cnt < (fgd_ppl+1); fgd_cnt++) { + /* IP */ + fgd_ele_len = fgd_txt[fgd_curpos-1]; + bcopy( &fgd_txt[fgd_curpos], incoming->ipadr, fgd_ele_len); + incoming->ipadr[fgd_ele_len] = 0; + fgd_curpos = fgd_curpos + fgd_ele_len + 1; + /* Pilot */ + fgd_ele_len = fgd_txt[fgd_curpos-1]; + bcopy( &fgd_txt[fgd_curpos], incoming->callsign, fgd_ele_len); + incoming->callsign[fgd_ele_len] = 0; + fgd_curpos = fgd_curpos + fgd_ele_len + 1; + /* Lon, Lat...etc */ + printf(" #%d %-16s %s\n", fgd_cnt, incoming->ipadr, incoming->callsign); + printf(" curpos:%d\n", fgd_curpos); + sscanf( &fgd_txt[fgd_curpos]," %7f %7f %7f %7f %7f %7f %7f", + &incoming->latf, &incoming->lonf, + &incoming->altf, &incoming->speedf, &incoming->rollf, + &incoming->pitchf, &incoming->yawf); + 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", + incoming->latf, incoming->lonf, incoming->altf, incoming->speedf, + incoming->rollf, incoming->pitchf, incoming->yawf); + fgd_curpos += 56; + incoming = incoming->next; + } /* end for */ +// } /* end else */ + } /* end if "data available" */ +/* Here reading the answer of completed command by fgd */ +/* read( sock, fgd_txt, buffp[3]); + fgd_txt[buffp[3]] = 0; + if (strcmp(fgd_txt, "UNKNOWN") == -1) { + printf("FGD: Data to Host sent\n"); + } + else printf("FGD: Host not in list, sorry...\n"); +*/ + break; + case 8: printf("FGD: Unregistering Host %s\n", FGFS_host); + read( sock, fgd_txt, buffp[3]); + fgd_txt[buffp[3]] = 0; + if (strcmp(fgd_txt, "UNKNOWN") == -1) { + printf("FGD: Host %s unregistered\n", fgd_txt); + } + else printf("FGD: Host not in list, sorry...\n"); + break; + case 9: printf(" Shutdown FlightGear-Deamon %s .\n", fgd_name); + break; + default: break; + } + } else printf(" Huh?: no deamon present, yuk!!!\n"); +// } + close(sock); + current_port++; + } + + if (verbose == 2) printf("fgd_com completed.\n"); +} + + +int main(int argc, char **argv) { + + list_init(); + fgd_init(); + for ( ; (atoi( (char*) fgd_job)) != 99;){ + printf("MCP: ready...enter commando (42 help) "); + gets((char *) fgd_job); + if (verbose == 2) printf("MCP: got %s %d\n", (char *) fgd_job, strlen((char *) fgd_job)); + if ( strcmp( fgd_job, "") > 0 ) switch( atoi((char*) fgd_job)) { + case 0 : if ( strcmp( (char *) fgd_job, "0") == 0 ){ + printf("MCP: Scan for fgd\n"); + fgd_send_com( "0", src_host); + } + break; + case 1 : printf("MCP: Register to fgd\n"); + fgd_send_com( "1", src_host); + break; + case 2 : printf("MCP: Show registered\n"); + fgd_send_com( "2", src_host); + break; + case 3 : printf("MCP: Send MSG\n"); + break; + case 4 : printf("MCP: Send MSG to ALL\n"); + break; + case 5 : printf("MCP: Push Data to fgd\n"); + fgd_send_com( "5", src_host); + break; + case 6 : printf("MCP: Pop Data from fgd\n"); + fgd_send_com( "6", src_host); + break; + case 8 : printf("MCP: Unregister from fgd\n"); + fgd_send_com( "8", src_host); + break; + case 9 : printf("MCP: Shutdown fgd-deamon\n"); + fgd_send_com( "9", src_host); + break; + case 10 : printf("MCP: Choose default deamon HOST:\n"); + printf(" Deamon Host IP Port\n"); + printf(" %-16s%-16s%-16s%-16d\n", fgd_name, fgd_host, fgd_ip, base_port); + printf("\n Enter new Host:[%s] ", fgd_host); + gets((char *) fgd_txt); + if ( strlen(fgd_txt) != 0 ) { + strcpy(fgd_host, fgd_txt); + if (host_info = gethostbyname( fgd_host)) { + bcopy(host_info->h_addr, (char *)&address.sin_addr,host_info->h_length); + strcpy((char *) fgd_ip, (char *) inet_ntoa(address.sin_addr)); + if (verbose == 2) { + printf(" resolved\n FGD running on HOST : %s", fgd_host); + printf(" IP : %s\n", fgd_ip); + } + } else if ((address.sin_addr.s_addr = inet_addr( fgd_host)) == INADDR_NONE) { + fprintf(stderr," Could not get %s host entry !\n", fgd_host); + printf(" NOT resolved !!!\n"); + exit(1); + } else if (verbose == 2) printf(" address valid\n"); + } + break; + case 11 : printf("MCP: Choose default deamon Port:\n"); + printf(" Deamon Host IP Port\n"); + printf(" %-16s%-16s%-16s%-16d\n", fgd_name, fgd_host, fgd_ip, base_port); + printf(" Enter new Port: "); + gets((char *) buffp); + current_port = atoi((char*) buffp); + if (current_port != 0) { + base_port = atoi((char*) buffp); + end_port = base_port; + } + break; + case 20 : printf("MCP: Current values:\n"); + printf(" Deamon Host IP Port\n"); + printf(" %-16s%-16s%-16s%-16d\n", fgd_name, fgd_host, fgd_ip, base_port); + printf(" -----------------------------------------------------\n"); + printf(" Callsign Host IP Port\n"); + printf(" %-16s%-16s%-16s%-16d\n", fgd_callsign, src_host, fgd_mcp_ip, base_port); + printf(" Lat Lon Alt Speed Roll Pitch Yaw\n"); + printf(" %-8s % 7.3f % 7.3f % 7.3f % 7.3f % 7.3f % 7.3f % 7.3f\n", fgd_callsign, boss->latf, + boss->lonf, boss->altf, boss->speedf, boss->rollf, boss->pitchf, boss->yawf); + printf(" -----------------------------------------------------\n"); + printf(" Pilot list:\n"); + test = head->next; + while (test != tail) { + printf(" Callsign Host\n"); + printf(" %-16s%-16s\n", test->callsign, test->ipadr); + printf(" Lat Lon Alt Speed Roll Pitch Yaw\n"); + printf(" %-8s % 7.3f % 7.3f % 7.3f % 7.3f % 7.3f % 7.3f % 7.3f\n", test->callsign, test->latf, + test->lonf, test->altf, test->speedf, test->rollf, test->pitchf, test->yawf); + test = test->next; + } + printf(" -----------------------------------------------------\n"); + + break; + case 21 : printf("MCP: Enter your callsign, Pilot "); + gets((char *) fgd_callsign); + break; + case 42 : printf("MCP: Commands available:\n 0 Scan for fgd\n 1 Register\n"); + printf(" 2 Show registered\n 3 Send MSG\n 4 Send MSG to ALL\n"); + printf(" 5 Push Data to fgd\n 6 Pop Data from fgd\n"); + printf(" 8 Unregister from fgd\n 9 Shutdown fgd\n"); + printf("10 Set deamon HOST\n11 Set deamon PORT\n"); + printf("20 Show values\n21 Set own callsign\n"); + printf("31 Set deamon PORT\n"); + printf("98 Stress test\n"); + printf("99 Quit Master Control Program (not recommended)\n"); + break; + case 98 : printf("MCP: Stress test "); + fgd_loss = 0; + list_search(fgd_mcp_ip); + other = act->next; + printf("other-ip %s\n", other->ipadr); + sleep(3); + for ( j=1; j<10000; j++) { + boss->latf += 0.001; + fgd_send_com( "5", src_host); + fgd_send_com( "6", src_host); + printf("other lat:%7.3f boss lat:%7.3f\n", other->latf, boss->latf); + if (fabs(boss->latf - other->latf) > 0.001) { + printf("other lat:%7.3f boss lat:%7.3f\n", other->latf, boss->latf); + fgd_loss++; + } + } + printf(" Packets lost: %d\n", fgd_loss); + break; + default: break; + } + } + // fgd_send_com( argv[5], argv[6]); + free(buffp); + free(fgd_job); + free(fgd_host); + free(fgd_callsign); + free(fgd_name); + free(fgd_ip); + free(fgd_mcp_ip); + free(fgfs_host); + free(fgfs_pilot); + free(src_host); + free(fgd_txt); + printf("MCP: Exit...\n"); + exit(0); +} diff --git a/src/NetworkOLK/Tools/fgd_scan.c b/src/NetworkOLK/Tools/fgd_scan.c index 4d9420c4d..25f617cf1 100644 --- a/src/NetworkOLK/Tools/fgd_scan.c +++ b/src/NetworkOLK/Tools/fgd_scan.c @@ -1,11 +1,11 @@ /***********************************************************/ /* FGD_SCAN.C by Oliver Delise */ /* Contact info: */ -/* e-mail: delise@rp-plus.de */ +/* e-mail: delise@mail-isis.de */ /* www: http://www.online-club.de/~olk/progs/mmx-emu/ */ /* ftp: http://www.online-club.de/~olk/progs/flightgear */ /* */ -/* Version 0.1pre-alpha */ +/* Version 0.1-alpha */ /* The author of this program offers no waranty at all */ /* about the correct execution of this software material. */ /* Furthermore, the author can NOT be held responsible for */ @@ -27,6 +27,7 @@ /* output is STDOUT, and ALL the errors go to STDERR. */ /* */ /* History: v0.1pre-alpha: May 25 1999 -> First release */ +/* v0.1-alpha Nov 08 1999 */ /***********************************************************/ @@ -166,10 +167,11 @@ void fgd_scan() { break; case 2: service_info = getservbyport(htons(current_port),"tcp"); if (!service_info) { - read( sock, &buff, 3); + read( sock, &buff, 4); printf(" Got reply : %s\n", &buff); if (strncmp(&buff, "FGD", 3) == 0) { - printf(" FlightGear-Deamon detected\n"); + read( sock, &buff, (int) &buff[3]); + printf(" FlightGear-Deamon %s detected.\n", &buff); break; } printf("Port %d found. Service name unknown\n",current_port); diff --git a/src/NetworkOLK/Tools/fgd_verbose.c b/src/NetworkOLK/Tools/fgd_verbose.c new file mode 100644 index 000000000..476e32b7f --- /dev/null +++ b/src/NetworkOLK/Tools/fgd_verbose.c @@ -0,0 +1,642 @@ +/*************************************************************/ +/* FGD.C by Oliver Delise */ +/* Contact info: */ +/* e-mail: delise@mail.isis.de */ +/* www: http://www.isis.de/members/~odelise/progs/mmx-emu/ */ +/* ftp: http://www.isis.de/members/~odelise/progs/flightgear */ +/* */ +/* Version 0.1-alpha */ +/* The author of this program offers no waranty at all */ +/* about the correct execution of this software material. */ +/* Furthermore, the author can NOT be held responsible for */ +/* any physical or moral damage caused by the use of this */ +/* software. */ +/* */ +/* This is a standalone Tool to communicate with any */ +/* FlightGear System and FGFS-Deamon. */ +/* This is Open Source Software with some parts */ +/* shamelessly stolen from others... */ +/* */ +/* -> This program will use a TCP port listening on a */ +/* remote or local host inside the range you give to it. */ +/* I offer no warranty over the accuracy though :) */ +/* There are 3 verbose modes: No info, service info, and */ +/* full info. No info is good of you only want the list */ +/* of the ports, no more info. The best mode is Full */ +/* info, as you get error information,etc. The main */ +/* output is STDOUT, and ALL the errors go to STDERR. */ +/* */ +/* History: v0.1pre-alpha: May 25 1999 -> First release */ +/* v0.1-alpha : Nov 08 1999 */ +/*************************************************************/ + + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// #define printf // + +/* Net-stuff */ +fd_set rset, allset; +int maxfd, nready, retval; +struct timeval tv; +struct utsname myname; +char *fgd_host, *src_host; + +/* Program-stuff */ +int verbose, fgd_len_msg; + +/* List-stuff (doubly-Linked-list) */ +#include +#include + +int i, j, fgd_cnt, fgd_curpos; +char *vb, *fgd_txt; +const int True = 0; +const int False= -1; + +float sgFGD_COORD[4][4]; + +struct list_ele { + unsigned char ipadr[16], callsign[16]; + unsigned char lat[8], lon[8], alt[8], speed[8], roll[8], pitch[8], yaw[8]; + float latf, lonf, altf, speedf, rollf, pitchf, yawf; + float sgFGD_COORD[4][4]; + struct list_ele *next, *prev; +}; + +struct list_ele *head, *tail, *act, *test, *incoming; /* fgd_msg; */ + +struct fgd_sock_list { + char adr[16]; + int prev_sock; +}; + +struct fgd_sock_list fgd_cli_list[255]; +int fgd_known_cli = -1; /* False */ +int fgd_cli = 0; + +/*...Create head and tail of list */ +void list_init( void) { + incoming = (struct list_ele*) malloc(sizeof(struct list_ele)); + head = (struct list_ele*) malloc(sizeof(struct list_ele)); + tail = (struct list_ele*) malloc(sizeof(struct list_ele)); + if (head == NULL || tail == NULL) { printf("Out of memory\n"); exit(1); } +/* fixme :Where is the "with foobar do command " + head->ipadr = "127.0.0.0"; + strcpy(head->callsign, "None"); + head->lon = 0; + head->lat = 0; + head->alt = 0; + head->pitch = 0; + head->roll = 0; + head->yaw = 0; +*/ + /* yaw!. Who the f$%& invented this ;-) */ + head->ipadr[0] = 0; + tail->ipadr[0] = 255; + tail->ipadr[1] = 0; + head->prev = tail->prev = head; + head->next = tail->next = tail; + act = head; /* put listpointer to beginning of list */ +} + +void list_output( void) { +} + +void list_search( char name[16]) { + + if (strcmp(name, head->next->ipadr) <= 0) act = head; + else if (strcmp(name, tail->prev->ipadr) > 0) act = tail->prev; + else { + int vergleich = strcmp(name, act->ipadr); + if (vergleich > 0) + while (strcmp(name, act->next->ipadr) > 0) { + act = act->next; + } + else if (vergleich < 0) + while (strcmp(name, act->ipadr) < 0) { + act = act->prev; + } + else + while (strcmp(name, act->ipadr) == 0) { + act = act->prev; + } + } +} + +void list_insert( char newip[16]) { +struct list_ele *new_ele; + + new_ele = (struct list_ele*) malloc(sizeof(struct list_ele)); + if (new_ele == NULL) { printf("Out of memory\n"); exit(1); } + strcpy(new_ele->ipadr, newip); +/* setting default */ + strcpy(new_ele->callsign, "not assigned"); + list_search( newip); + new_ele->prev = act; + new_ele->next = act->next; + act->next->prev = act->next = new_ele; +} + +void list_setval( char newip[16]) { + + list_search( newip); + strcpy( act->next->callsign, incoming->callsign); + act->next->latf = incoming->latf; + act->next->lonf = incoming->lonf; + act->next->altf = incoming->altf; + act->next->speedf = incoming->speedf; + act->next->rollf = incoming->rollf; + act->next->pitchf = incoming->pitchf; + act->next->yawf = incoming->yawf; + printf("Callsign %s ", act->next->callsign); + printf(" lat: %7.3f lon: %7.3f alt: %7.3f speed: %7.3f roll: %7.3f pitch: %7.3f yaw: %7.3f", + act->next->latf, act->next->lonf, act->next->altf, act->next->speedf, + act->next->rollf, act->next->pitchf, act->next->yawf); +} + +void list_setval_Mat4( char newip[16]) { + + list_search( newip); + strcpy( act->next->callsign, incoming->callsign); + for (i=0;i<4;i++) + for (j=0;j<4;j++) + act->next->sgFGD_COORD[i][j] = incoming->sgFGD_COORD[i][j]; + printf("Callsign %s ", act->next->callsign); +} + + +void list_clear( char clrip[16]) { +struct list_ele *clr_ele; + + list_search( clrip); + if ( strcmp( clrip, act->next->ipadr)) + printf("....Name %s nicht vorhanden", clrip); + else { + clr_ele = act->next; + act->next = act->next->next; + act->next->prev = act; + free( clr_ele); + } +} + + +int list_not_in( char name[16]) { + + i = True; + test = head->next; + while ((test != tail) && (i==True)) { + i = (strcmp(test->ipadr, name) ? True : False); + test = test->next; + if (verbose != 0) printf("list_not_in : %d\n",i); + } + return(i); +} + + + + +int sock = -1; +int my_sock; +int fgd_com; +int *ip; +size_t anz; +char buff[1024]; +char *fgd_name; +struct { char *adr, *lon, *lat, *alt;} fgd_client; +int fgd_ele_len; + +struct sockaddr_in address; +struct sockaddr_in my_address; +int result; +extern char *sys_errlist[]; +extern int errno; +int current_port = 0; +u_short base_port = 0; +u_short end_port = 1024; +struct hostent *host_info; +struct servent *service_info; + +void fgd_init(void); + +int main(int argc, char **argv) +{ + if (argc < 4) { + fprintf(stderr,"Usage: fgd [start port] [end port] [name] <-v or -vv>\n"); + exit(1); + } + + switch (argc) { + case 5: if (!strcmp(argv[4],"-v")) + verbose = 1; + else if (!strcmp(argv[4],"-vv")) + verbose = 2; + else { fprintf(stderr,"Usage: fgd [start port] [end port] [name] <-v or -vv>\n"); + exit(1); } + + case 4: base_port = (u_short)atoi(argv[1]); + end_port = (u_short)atoi(argv[2]); + fgd_name = argv[3]; + break; + default: fprintf(stderr,"Usage: fgd [start port] [end port] [name] <-v or -vv>\n"); + exit(1); + break; + } + + bzero((char *)&address, sizeof(address)); + address.sin_family = AF_INET; + if (uname(&myname) == 0) fgd_host = myname.nodename; + printf(" I am running as %s on HOST %s\n", fgd_name, fgd_host); + + if (verbose == 2) printf(" Resolving: %s ->",fgd_host); + if (host_info = gethostbyname(fgd_host)) { + bcopy(host_info->h_addr, (char *)&address.sin_addr,host_info->h_length); + printf(" fgd : ip = %s\n", inet_ntoa( address.sin_addr)); + + if (verbose == 2) printf(" resolved\n"); + } else if ((address.sin_addr.s_addr = inet_addr(fgd_host)) == INADDR_NONE) { + fprintf(stderr,"Could not get %s host entry !\n",argv[1]); + printf(" NOT resolved !!!\n"); + exit(1); + } else if (verbose == 2) printf(" address valid\n"); + + if ((base_port > end_port) || ((short)base_port < 0)) { + fprintf(stderr,"Bad port range : start=%d end=%d !\n"); + exit(1); + } else if (verbose == 2) { + printf(" Port range: %d to %d\n",base_port,end_port); + } + printf(" verbose: %d\n",verbose); + /* some init stuff */ + fgd_txt = (char *) malloc(1024); + list_init(); + fgd_init(); + exit(0); +} + +void fgd_init(void) { + +struct { char *ip, *lon, *lat, *alt;} fg_id; + + + current_port = base_port; + while (current_port <= end_port) { + sock = socket(PF_INET, SOCK_STREAM, 0); + if (sock == -1) + { + fprintf(stderr, "Error assigning master socket: %s\n",sys_errlist[errno]); + exit(-1); + } + + address.sin_port = htons(current_port); + if (verbose == 2) printf(" address.sin_port : %d\n",htons(address.sin_port)); + if (1 == 1) { + if ( bind(sock, (struct sockaddr *)&address, sizeof(address)) == -1) { + printf(" Aiiiieeehh...ADRESS ALSO IN USE...\7hmmm...please check another port\n"); + exit(-1); + } + listen(sock, 5); + +/* Hier neu */ + maxfd = sock; + FD_ZERO( &allset); + FD_SET( sock, &allset); +for (;;){ + rset = allset; + tv.tv_sec = 1; + tv.tv_usec = 0; + nready = select( sock + 1, &rset, NULL, NULL, &tv); + if (FD_ISSET( sock, &rset)) { + my_sock = accept( sock, (struct sockaddr *)&address, (int*) sizeof(address)); + anz = 2; +/* reading length of senders' ip */ + fgd_ele_len = 0; + read( my_sock, buff, 1); + fgd_ele_len = buff[0]; + if (verbose == 2) printf("ele_len %d\n", fgd_ele_len); +/* reading senders' ip */ + read( my_sock, &buff, fgd_ele_len); + ip = (int *) buff; +// printf("%d %d %d %d %x %x %x\n", buff[0], buff[1], buff[2], buff[3], &ip, ip, *ip); + fgd_client.adr = (char*) inet_ntoa( *ip); + src_host = fgd_client.adr; +/* reading commando */ + read( my_sock, &buff, 1); +/* closing previous file descriptor of same client, at least we know now + that the previous command is finished since it's the same client who + again requests something. Maybe I'm to quick and diiirty ;-) */ + printf("FGD : Using socket #%d\n", my_sock); + fgd_known_cli = False; + for ( fgd_cnt = 1; fgd_cnt < fgd_cli+1; fgd_cnt++) { + printf("FGD : fgd_cnt:%d fgd_cli:%d fgd_client.adr: %s prev.sock:%d fgd_cli_list[fgd_cnt].adr: %s\n", + fgd_cnt, fgd_cli, fgd_client.adr, + fgd_cli_list[fgd_cnt].prev_sock, fgd_cli_list[fgd_cnt].adr); + if ( strcmp( fgd_cli_list[fgd_cnt].adr, fgd_client.adr) == 0) { + printf("FGD : In Vergleichsloop. Closing socket: %d\n", + fgd_cli_list[fgd_cnt].prev_sock); + close( fgd_cli_list[fgd_cnt].prev_sock); + fgd_cli_list[fgd_cnt].prev_sock = my_sock; + fgd_known_cli = True; + } + } + if ( fgd_known_cli == False) { + fgd_cli++; + fgd_cli_list[fgd_cli].prev_sock = my_sock; + strcpy(fgd_cli_list[fgd_cli].adr, fgd_client.adr); + } + printf(" Commando received : %s from Host : %s\n", &buff, src_host); + fgd_com = ( (char) buff[0]) - 0x30; + printf("%d \n", fgd_com); + switch (fgd_com) { + case 0: printf(" fgd : Identify\n"); + sprintf( (char*) buff, "FGDLH%s", fgd_name); + buff[3] = strlen(fgd_name) + 1; /* Lo, incl.zero */ + buff[4] = 0; /* Hi, names < 0xff ! */ + buff[buff[3] + 4] = 0; /* Term.zero */ + printf(" I am : %s\n", fgd_name); + write( my_sock, &buff, buff[3]+5); /* fgd housekeeping ;-) */ + // close(my_sock); + break; + case 1: printf(" fgd : Register\n"); + /* reading length of FGFS_host ip */ + fgd_ele_len = 0; + read( my_sock, &buff, 1); + fgd_ele_len = (int) &buff; + /* reading FGFS_host ip */ + read( my_sock, &buff, fgd_ele_len); + ip = (int *) buff; + fgd_client.adr = (char*) inet_ntoa( *ip); + if (list_not_in(fgd_client.adr) == True) { + list_insert(fgd_client.adr); + list_search(fgd_client.adr); +// strcpy(act->callsign, "None"); + printf(" Setting default values\n"); + printf(" IP : %s\n", act->next->ipadr); + printf(" PILOT : %s\n", act->next->callsign); + } + /* writing answer back to client */ + sprintf( (char*) buff, "FGDLH%s", fgd_client.adr); + buff[3] = strlen(fgd_client.adr) + 1; /* Lo, incl.zero */ + buff[4] = 0; /* Hi, names < 0xff ! */ + buff[buff[3] + 4] = 0; /* Term.zero */ + write( my_sock, &buff, buff[3]+5); /* fgd housekeeping ;-) */ + // close(my_sock); + break; + case 2: printf(" fgd : Show Registered\n"); + sprintf( (char*) buff, "FGD"); + // buff[3] = buff[4] = 0; + fgd_cnt = 0; + fgd_curpos = 6; + test = head->next; + while (test != tail) { + printf(" IP : %s\n", test->ipadr); + fgd_cnt++; + fgd_ele_len = strlen(test->ipadr) + 1; +// printf(" ele_len %d curpos %d\n", fgd_ele_len, fgd_curpos); + buff[fgd_curpos] = fgd_ele_len; + fgd_curpos++; + bcopy(test->ipadr, &buff[fgd_curpos], fgd_ele_len); + fgd_curpos += fgd_ele_len; + //buff[fgd_curpos] = 0; + test = test->next; + } + if (fgd_cnt == 0) fgd_curpos--; + buff[3] = fgd_curpos & 0xff; + buff[4] = fgd_curpos >> 8; + buff[5] = fgd_cnt; + write( my_sock, &buff, fgd_curpos); +// close(my_sock); + break; + case 3: printf(" fgd : Send MSG\n"); +// close(my_sock); + break; + case 4: printf(" fgd : Send MSG to all\n"); +// close(my_sock); + break; + case 5: printf(" fgd : Get DATA from client\n"); + read( my_sock, &buff, 1); + fgd_ele_len = buff[0]; + read( my_sock, &buff, fgd_ele_len); + ip = (int *) buff; + fgd_client.adr = (char*) inet_ntoa( *ip); + printf(" IP : %s\n", fgd_client.adr); + if (verbose != 0) printf("not_in (CASE) : %d\n", list_not_in(fgd_client.adr)); + if (list_not_in(fgd_client.adr) == False) { + printf(" Checkpoint\n"); + read( my_sock, &buff, 1); + printf(" Checkpoint 1\n"); + fgd_ele_len = buff[0]; + read( my_sock, &buff, fgd_ele_len); + incoming->callsign[fgd_ele_len] = 0; + bcopy( &buff, incoming->callsign, fgd_ele_len); + /* lat, lon */ + read( my_sock, &buff, 56); + sscanf( buff," %7f %7f %7f %7f %7f %7f %7f", &incoming->latf, &incoming->lonf, + &incoming->altf, &incoming->speedf, &incoming->rollf, + &incoming->pitchf, &incoming->yawf); + 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", + incoming->latf, incoming->lonf, incoming->altf, incoming->speedf, + incoming->rollf, incoming->pitchf, incoming->yawf); + list_setval(fgd_client.adr); + } + else strcpy( fgd_client.adr, "UNKNOWN"); + /* writing answer back to client */ + sprintf( (char*) buff, "%s %s", "FGD", fgd_client.adr); + buff[3] = strlen(fgd_client.adr); + printf(" IP : %s\n", fgd_client.adr); + write( my_sock, &buff, buff[3]+4); +// close(my_sock); + break; + case 17: printf(" fgd : Get Mat4 DATA from client\n"); + read( my_sock, &buff, 1); + fgd_ele_len = buff[0]; + read( my_sock, &buff, fgd_ele_len); + ip = (int *) buff; + fgd_client.adr = (char*) inet_ntoa( *ip); + printf(" IP : %s\n", fgd_client.adr); + if (verbose != 0) printf("not_in (CASE) : %d\n", list_not_in(fgd_client.adr)); + if (list_not_in(fgd_client.adr) == False) { + printf(" Checkpoint\n"); + read( my_sock, &buff, 1); + printf(" Checkpoint 1\n"); + fgd_ele_len = buff[0]; + read( my_sock, &buff, fgd_ele_len); + incoming->callsign[fgd_ele_len] = 0; + bcopy( &buff, incoming->callsign, fgd_ele_len); + /* lat, lon */ + read( my_sock, &buff, 158); + i = sscanf( buff," %f %f %f %f %f %f %f %f %f %f %f %f %f %f %f %f", + &incoming->sgFGD_COORD[0][0], &incoming->sgFGD_COORD[0][1], &incoming->sgFGD_COORD[0][2], &incoming->sgFGD_COORD[0][3], + &incoming->sgFGD_COORD[1][0], &incoming->sgFGD_COORD[1][1], &incoming->sgFGD_COORD[1][2], &incoming->sgFGD_COORD[1][3], + &incoming->sgFGD_COORD[2][0], &incoming->sgFGD_COORD[2][1], &incoming->sgFGD_COORD[2][2], &incoming->sgFGD_COORD[2][3], + &incoming->sgFGD_COORD[3][0], &incoming->sgFGD_COORD[3][1], &incoming->sgFGD_COORD[3][2], &incoming->sgFGD_COORD[3][3]); + +// printf(" sscanf input: %d\n",i); + printf(" sgMat4: \n%f %f %f %f %f %f %f %f %f %f %f %f %f %f %f %f\n", + incoming->sgFGD_COORD[0][0], incoming->sgFGD_COORD[0][1], incoming->sgFGD_COORD[0][2], incoming->sgFGD_COORD[0][3], + incoming->sgFGD_COORD[1][0], incoming->sgFGD_COORD[1][1], incoming->sgFGD_COORD[1][2], incoming->sgFGD_COORD[1][3], + incoming->sgFGD_COORD[2][0], incoming->sgFGD_COORD[2][1], incoming->sgFGD_COORD[2][2], incoming->sgFGD_COORD[2][3], + incoming->sgFGD_COORD[3][0], incoming->sgFGD_COORD[3][1], incoming->sgFGD_COORD[3][2], incoming->sgFGD_COORD[3][3]); + list_setval_Mat4(fgd_client.adr); + } + else strcpy( fgd_client.adr, "UNKNOWN"); + /* writing answer back to client */ + sprintf( (char*) buff, "FGDLH%s", fgd_client.adr); + buff[3] = strlen(fgd_client.adr) + 1; + buff[4] = buff[buff[3]+5] = 0; + printf(" IP : %s\n", fgd_client.adr); + write( my_sock, &buff, buff[3]+5); +// close(my_sock); + break; + case 6: printf(" fgd : Send all DATA to client\n"); + sprintf( (char*) buff, "%s %s", "FGD", fgd_client.adr); + buff[3] = 0; + fgd_cnt = 0; + fgd_curpos = 5; + test = head->next; + while (test != tail) { + printf(" IP : %-16s Callsign : %-16s\n", test->ipadr, test->callsign); + fgd_cnt++; + /* IP */ + fgd_ele_len = strlen(test->ipadr); + printf(" ele_len %d curpos %d\n", fgd_ele_len, fgd_curpos); + buff[fgd_curpos] = fgd_ele_len; + fgd_curpos++; + bcopy(test->ipadr, &buff[fgd_curpos], fgd_ele_len); + fgd_curpos = fgd_curpos + fgd_ele_len; + /* Callsign */ + fgd_ele_len = strlen(test->callsign); + printf(" ele_len %d curpos %d\n", fgd_ele_len, fgd_curpos); + buff[fgd_curpos] = fgd_ele_len; + fgd_curpos++; + bcopy(test->callsign, &buff[fgd_curpos], fgd_ele_len); + fgd_curpos = fgd_curpos + fgd_ele_len; + /* Lat, Lon, Alt, Speed, Roll, Pitch, Yaw + hope this sprintf call is not too expensive */ + sprintf( fgd_txt, " %7.3f %7.3f %7.3f %7.3f %7.3f %7.3f %7.3f", + test->latf, test->lonf, test->altf, test->speedf, + test->rollf, test->pitchf, test->yawf); + printf(" ele_len %d curpos %d\n", fgd_ele_len, fgd_curpos); + printf(" Data : %s\n", fgd_txt); + bcopy((char *) fgd_txt, &buff[fgd_curpos], 56); + fgd_curpos += 56; + test = test->next; + } + if (fgd_cnt == 0) fgd_curpos --; + printf(" ele_len %d curpos %d\n", fgd_ele_len, fgd_curpos); + buff[3] = fgd_curpos; + buff[4] = fgd_cnt; + write( my_sock, &buff, fgd_curpos); +// close(my_sock); + break; + case 18: printf(" fgd : Send all Mat4 DATA to client\n"); + sprintf( (char*) buff, "FGDLH"); + buff[3] = buff[4] = 0; + fgd_cnt = 0; + fgd_curpos = 6; + test = head->next; + while (test != tail) { + printf(" IP : %-16s Callsign : %-16s\n", test->ipadr, test->callsign); + fgd_cnt++; + /* IP */ + fgd_ele_len = strlen(test->ipadr); + printf(" ele_len %d curpos %d\n", fgd_ele_len, fgd_curpos); + buff[fgd_curpos] = fgd_ele_len; + fgd_curpos++; + bcopy(test->ipadr, &buff[fgd_curpos], fgd_ele_len); + fgd_curpos = fgd_curpos + fgd_ele_len; + /* Callsign */ + fgd_ele_len = strlen(test->callsign); + printf(" ele_len %d curpos %d\n", fgd_ele_len, fgd_curpos); + buff[fgd_curpos] = fgd_ele_len; + fgd_curpos++; + bcopy(test->callsign, &buff[fgd_curpos], fgd_ele_len); + fgd_curpos = fgd_curpos + fgd_ele_len; + /* Lat, Lon, Alt, Speed, Roll, Pitch, Yaw + hope this sprintf call is not too expensive */ + fgd_len_msg = sprintf( fgd_txt, " %f %f %f %f %f %f %f %f %f %f %f %f %f %f %f %f", + test->sgFGD_COORD[0][0], test->sgFGD_COORD[0][1], test->sgFGD_COORD[0][2], test->sgFGD_COORD[0][3], + test->sgFGD_COORD[1][0], test->sgFGD_COORD[1][1], test->sgFGD_COORD[1][2], test->sgFGD_COORD[1][3], + test->sgFGD_COORD[2][0], test->sgFGD_COORD[2][1], test->sgFGD_COORD[2][2], test->sgFGD_COORD[2][3], + test->sgFGD_COORD[3][0], test->sgFGD_COORD[3][1], test->sgFGD_COORD[3][2], test->sgFGD_COORD[3][3]); + fgd_txt[fgd_len_msg] = 0; + printf(" ele_len %d curpos %d\n", fgd_ele_len, fgd_curpos); + printf(" Data : %s\n", fgd_txt); + bcopy((char *) fgd_txt, &buff[fgd_curpos], fgd_len_msg+1); + fgd_curpos += fgd_len_msg+1; + test = test->next; + } + if (fgd_cnt == 0) fgd_curpos -= 1; + printf(" ele_len %d curpos %d\n", fgd_ele_len, fgd_curpos); + buff[3] = fgd_curpos & 0xff; + buff[4] = fgd_curpos / 256; + buff[5] = fgd_cnt; + printf("ANZ: %d CURPOS: %d\n", (unsigned char) buff[3] + (unsigned char) buff[4] * 256, fgd_curpos); + write( my_sock, &buff, fgd_curpos); +// close(my_sock); + break; + case 8: printf(" fgd : Unregister\n"); + read( my_sock, &buff, 1); + fgd_ele_len = (int) &buff; + read( my_sock, &buff, fgd_ele_len); + ip = (int *) buff; + fgd_client.adr = (char*) inet_ntoa( *ip); + printf(" IP : %s\n", fgd_client.adr); + if (verbose != 0) printf("not_in (CASE) : %d\n", list_not_in(fgd_client.adr)); + if (list_not_in(fgd_client.adr) == -1) { + list_clear(fgd_client.adr); + } + else strcpy( fgd_client.adr, "UNKNOWN"); + /* writing answer back to client */ + sprintf( (char*) buff, "%s %s", "FGD", fgd_client.adr); + buff[3] = strlen(fgd_client.adr); + printf(" IP : %s\n", fgd_client.adr); + write( my_sock, &buff, buff[3]+4); +// close(my_sock); + break; + case 9: printf(" fgd : Shutdown\n"); + close(my_sock); + close(sock); + exit(0); + default: printf(" fgd : Huh?...Unknown Command\n"); + break; + } + } + } +/* + switch (verbose) { + case 0: printf("%d\n",base_port+current_port); + break; + case 1: service_info = getservbyport(htons(base_port+current_port),"tcp"); + if (!service_info) { + printf("%d -> service name unknown\n",base_port+current_port); + } else { + printf("%d -> %s\n",base_port+current_port,service_info->s_name); + } + break; + case 2: service_info = getservbyport(htons(base_port+current_port),"tcp"); + if (!service_info) { + printf("Port %d found. Service name unknown\n",base_port+current_port); + } else { + printf("Port %d found. Service name: %s\n",base_port+current_port,service_info->s_name); + } + break; + } +*/ + } else if (errno == 113) { + fprintf(stderr,"No route to host !\n"); + exit(1); + } +/* current_port++; */ + } + + if (verbose == 2) printf("Port scan finished !\n"); +} -- 2.39.5