--- /dev/null
+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
--- /dev/null
+Please check the presence of the following header files on your system
+
+#include <stdio.h>
+#include <sys/socket.h>
+#include <sys/types.h>
+#include <netinet/in.h>
+#include <unistd.h>
+#include <netdb.h>
+#include <sys/time.h>
+#include <fcntl.h>
+#include <sys/utsname.h>
\ No newline at end of file
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)
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\``
-
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] <FGFS-host>
-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: <FGFS-host>.
+ 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
-/***********************************************************/
-/* 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 <stdio.h>
#include <fcntl.h>
#include <sys/utsname.h>
+#define printf //
/* Net-stuff */
fd_set rset, allset;
struct utsname myname;
char *fgd_host, *src_host;
+/* Program-stuff */
+int verbose, fgd_len_msg;
+
/* List-stuff (doubly-Linked-list) */
#include <string.h>
#include <stdlib.h>
-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;
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;
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;
}
}
-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]) {
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);
}
-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;
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;
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;
}
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));
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);
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;
}
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 */
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;
}
}
if (verbose == 2) printf("Port scan finished !\n");
}
-
--- /dev/null
+#include <sys/socket.h>
+#include <sys/types.h>
+#include <netinet/in.h>
+#include <unistd.h>
+#include <netdb.h>
+#include <sys/time.h>
+#include <fcntl.h>
+#include <sys/utsname.h>
/***********************************************************/
/* 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 */
/* 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*/
/* 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 <stdio.h>
#include <fcntl.h>
#include <sys/utsname.h>
-int i;
+
+/* Netstuff */
int sock = -1;
int my_sock;
struct sockaddr_in address;
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");
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) {
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);
+}
--- /dev/null
+/*************************************************************/
+/* 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 <stdio.h>
+#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);
+}
/***********************************************************/
/* 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 */
/* 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 */
/***********************************************************/
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);
--- /dev/null
+/*************************************************************/
+/* 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 <stdio.h>
+#include <sys/socket.h>
+#include <sys/types.h>
+#include <netinet/in.h>
+#include <unistd.h>
+#include <netdb.h>
+#include <sys/time.h>
+#include <fcntl.h>
+#include <sys/utsname.h>
+
+// #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 <string.h>
+#include <stdlib.h>
+
+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");
+}
projects / flightgear.git / commitdiff