fly/flightgear
1
0
Fork 0
Code Activity

13 Dec 2000 updates from Oliver.

Browse source
This commit is contained in:
curt 2000-01-13 17:27:32 +00:00
parent 3ae06c157e
commit a056d93a99
10 changed files with 1920 additions and 204 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

9
src/NetworkOLK/Tools/FILES Normal file
View file

@ -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

11
src/NetworkOLK/Tools/HEADERS Normal file
View file

@ -0,0 +1,11 @@
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>

14
src/NetworkOLK/Tools/Makefile
View file

@ -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\``

232
src/NetworkOLK/Tools/README
View file

@ -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] <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.
Send comments/flame/beer/whatever to delise@rp-plus.de
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.
Oliver Delise 25/May/99
Send comments/flames/BEER/whatever to delise@mail.isis.de
Oliver Delise Nov/08/99

511
src/NetworkOLK/Tools/fgd.c
View file

@ -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 <stdio.h>
@ -40,6 +41,7 @@
#include <fcntl.h>
#include <sys/utsname.h>
#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 <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;
@ -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,32 +111,6 @@ void list_init( void) {
void list_output( void) {
}
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);
list_search( newip);
new_ele->prev = act;
new_ele->next = act->next;
act->next->prev = act->next = new_ele;
}
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);
}
}
void list_search( char name[16]) {
if (strcmp(name, head->next->ipadr) <= 0) act = head;
@ -139,6 +132,63 @@ void list_search( char name[16]) {
}
}
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;
@ -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");
}

8
src/NetworkOLK/Tools/fgd.h Normal file
View file

@ -0,0 +1,8 @@
#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>

94
src/NetworkOLK/Tools/fgd_com.c
View file

@ -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 <stdio.h>
@ -39,7 +40,8 @@
#include <fcntl.h>
#include <sys/utsname.h>
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);
}

593
src/NetworkOLK/Tools/fgd_mcp.c Normal file
View file

@ -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 <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);
}

10
src/NetworkOLK/Tools/fgd_scan.c
View file

@ -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);

642
src/NetworkOLK/Tools/fgd_verbose.c Normal file
View file

@ -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 <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");
}