/* ** TOP.EXE fuer TNN 1.72 und groesser (c) DG8BR ** Eigentlicher Titel "MHTNN.EXE" ** Ein Programm um die MHEARD.TAB in TNN direkt auszuwerten ** ** ** Zum Compilieren BITTE die TOP.MAK benutzen. Turbo-C. ** Eventuell die Pfade aendern. ** Falls die Datei nicht mitgegeben wurde, hier nochmal die Parameter fuer ** den Compiler (TC1/3.0++) ** TCC -2 -mc -f- -a -d -G -O ** ** Fuer Linux habe ich kein Makefile. ** Einfach gcc -Wall top_gnu.c -o top.exe . ** ** ** Aenderungen BITTE an mich weitergeben!! ** Mein Copyright darf NICHT entfernt werden!! ** ** Dieses Programm ist PUBLIC DOMAIN, mit den Einschraenkungen durch ** die ALAS (Allgemeine Lizenz fuer Amateurfunk Software), entweder ** Version 1, veroeffentlicht von Hans Georg Giese (DF2AU), ** am 13.Oct.1992, oder (wenn gewuenscht) jede spaetere Version. ****************************************************************************** ** Beginn 10.02.1995 ** Anpassung auf neue MHEARD.TAB am 13.02.97 by DG1KWA ** ** neues Format der MHEARD.TAB jetzt reiner ASCII ** Aufbau : Zeit im PC-Format , RX-Bytes , TX-Bytes , Port ** rx-rej , tx-rej , dama-verstoesse , Call ** ** Beispiel: 855398713 1083577 170775 2 1 8 2 DG9FU-2 ** ** Endgueltige Anpassung auf das neue Format. ** Externe Hilfe rausgeworfen. ** Rennt nun unter GNU32 und Linux ** ** Seit der 1.73 ist Max_MH = 5000. Darum habe ich auf das ** Speichermodul COMPACT umgestellt. ** ** Ein struct line *liste benoetigt 52 Bytes. Das bedeutet es muss 240000 ** Bytes freier Speicher fuer die Daten vorhanden sein. Dazu kommt noch das ** Programm. */ #define DATUM "28.12.2000" /* Letzte Aenderung DG8BR */ #define EOS '\0' #ifdef __MSDOS__ #define Seperator '\\' #endif #ifdef __linux__ #define Seperator '/' #endif /*#define DEBUG*/ #include #include #include #include #include #ifdef __MSDOS__ #include #include #endif #if defined(__linux__) || defined(__GO32__) #include #include #include #endif #ifdef WIN32 #include #include #define Seperator '\\' #endif /* WIN32 */ /* prototypen */ int get_ftime (int); /* Dateizeit der MHEARD.TAB holen */ void config_lesen (void); /* config-file einlesen */ char grossbuchstabe (char); /* meine toupper-Version */ void prozent (unsigned long, unsigned long, char*); /* Prozentberechnung */ void ssid_weg ( char* ); /* die SSiD von Call entfernen */ void benutzung (void); /* Kurzhilfe ausgeben */ void einles (int, int); /* Hauptleseroutine */ void addier (void); /* Bytes der einzelnen Call's addieren */ void sortier (int, int); /* nach Menge sortieren, Plaetze vergeben, Ausgabe */ char* punkte (char*, unsigned long); /* Zahl mit 100ter Punkte */ void callraus (char*); /* Einzelausgabe von Call */ int callcmp (char*, char*, int); /* Call mit Call vergleichen */ /* globale Variablen */ char VERSION[] = "TOP v1.06g ("DATUM") (c) DG8BR"; struct line { /* Struktur fuer die Daten. Speicherbedarf 52 Bytes */ struct line *naechster; /* naechster Eintrag */ unsigned int platz; unsigned long gesamt; time_t heard; /* Uhrzeit */ unsigned long tx; /* gesendete Bytes */ unsigned long rx; /* empfangene Bytes */ unsigned int d; /* Damaverstoesse */ unsigned int t; /* gesendete Rejects */ unsigned int r; /* empfangene Rejects */ unsigned int mhport; /* Digiport */ unsigned int flag; /* Call aktiv */ char call[10]; char via[10]; int dummi; /* fuer die verschiedene Via's */ } *liste; struct line *listenanfang; /* Eintrag der ersten Station der Liste */ time_t Dateianfang; /* Wann die MHEARD.TAB gegonnen wurde. */ time_t filetime; /* entspricht dem Listenende */ char zeitzone[3] = "UTC"; /* Zeitzonenbezeichnung */ unsigned long max; /* Gesamtbytes ueber alles */ int max_user; /* alle gezaehlten Benutzer */ int max_nenner; char filename[12]; struct kanal { /* hier wird die config.top abgelegt */ char name[11]; unsigned long gesamt; } port[16]; /* Port0 -Port15 */ /*---------------------------------------------------------------------------- * Zeit der MHEARD.TAB holen. Wird als bis-Zeit genommen. Damit sollte egal * in welcher Reihenfolge die Daten stehen, bzw. wie durcheinander sie sind. */ int get_ftime(int handle) { #ifdef WIN32 #else struct stat filestat; if (fstat(handle, &filestat) == -1) return(-1); filetime = filestat.st_mtime; /* filetime ist 32bit-Zahl */ #endif return(0); } /*---------------------------------------------------------------------------- ** Config-File einlesen ** Wird von main aufgerufen. Rueckgabewert: Keiner ** ** Diese Datei sollte in dem TNN-Pfad stehen. ** ** Config sollte folgendermassen aussehen: ** #Beispiel fuer den Einstieg. Alle Zeilen ohne # werden eingelesen ** P0 = 70cm */ void config_lesen (void) { FILE *ein; char buffer[81]; char standard[] = "P 0"; int a; if ((ein = fopen("config.top","rt")) != NULL) { while(!feof(ein)) { fgets(buffer,80,ein); if((buffer[0] != '#') && (strlen(buffer) > 1)) /* nur lesen wenn # */ { /* und Zeile > 1 */ a = atoi(&buffer[1]); /* Portnummer holen */ strtok(buffer," ="); if ( buffer[0] == 'P' ) strcpy(port[a].name ,strtok(NULL," =\n\r")); /* Portnamen */ } } } for ( a = 0; a < 16; a++) /* PORT wird nun von 0-15 eingerichtet */ { if (port[a].name[0] == EOS) /* wenn der Port nicht von der Config */ strcpy(port[a].name,standard); /* versorgt wurde */ if ( standard[2] == '9' ) /* wenn 9 dann auf 0 setzen und das */ { /* vorherige Byte auf 1 */ standard[1] = '1'; standard[2] = '0'; } else standard[2]++; /* wenn nicht, dann nur erhoehen */ } #ifdef DEBUG printf("config erfolgreich.\n"); #endif } /*---------------------------------------------------------------------------- ** Diese Routine wurde aus dem TNN-Packet entnommen. ** Erdacht hat sie DG9AML. Von mir an TOP angepasst. */ void prozent (unsigned long zaehler, unsigned long nenner, char *resultstr) { int i, zaehlernull; char tmp[32]; tmp[0] = EOS; *resultstr = EOS; zaehlernull = 0; if (nenner == 0) /* dividiert durch 0 ergibt eine Fehlermeldung */ { zaehler = 0L; nenner = 1L; } if (zaehler / nenner != 0) /* 100er Stelle */ { sprintf(tmp, "%s%lu", resultstr, zaehler / nenner); strcpy(resultstr,tmp); } else zaehlernull = 1; /* Solange der zaehler kleiner nenner ist wird der zaehler um eine 10-potenz ** hoeher. Da bei 4,3G grossen Zahlen ein Ueberlauf stattfinden wuerde, ** werden beide Zahlen um eine 10er-potenz gekuerzt. */ if ( zaehler > 430000000L) { zaehler = zaehler / 10; nenner = nenner / 10; } zaehler = (zaehler % nenner) * 10; if (zaehlernull != 1 || zaehler / nenner != 0) /* 10er Stelle */ { sprintf(tmp, "%s%lu",resultstr, zaehler / nenner); strcpy(resultstr,tmp); } if ( zaehler > 430000000L) { zaehler = zaehler / 10; nenner = nenner / 10; } zaehler = (zaehler % nenner) * 10; sprintf(tmp, "%s%lu", resultstr, zaehler / nenner); /* 1er Stelle */ strcpy(resultstr,tmp); if ( zaehler > 430000000L) { zaehler = zaehler / 10; nenner = nenner / 10; } zaehler = (zaehler % nenner) * 10; strcat(resultstr, "."); for (i = 0 ; i < 2; i++) /* 2 Kommastellen */ { sprintf(tmp, "%s%lu", resultstr, zaehler / nenner); if ( zaehler > 430000000L) { zaehler = zaehler / 10; nenner = nenner / 10; } zaehler = (zaehler % nenner) * 10; strcpy(resultstr,tmp); } return; } /*---------------------------------------------------------------------------- ** meine Version von 'toupper' */ char grossbuchstabe ( char buchstabe ) { if ( buchstabe > 'Z' ) buchstabe -= ' '; return ( buchstabe ); } /*---------------------------------------------------------------------------- ** Die SSID vom call entfernen. ** Return ist ein String ohne SSID ** Es gibt kein eigentliches Return. Es wird direkt der Eintrag via Zeiger ** geaendert. */ void ssid_weg (char *callmit) { char *callohne; for (callohne = callmit; *callohne; callohne++) if ( *callohne == '-' ) *callohne = EOS; } /*----------------------------------------------------------------------------- ** Kurzanleitung ausgeben */ void benutzung (void) { printf("\n"); printf(" Befehlssyntax Bedeutung Beispiel\n\n"); printf(" TOP alle Port, 10 Plaetze TOP\n"); printf(" TOP Anzahl <*> soviel Plaetze, alle Ports TOP 45\n"); printf(" TOP -Port einen Port, 10 Plaetze TOP -0 \n"); printf(" TOP Anzahl -Port soviel Plaetze, ein Port TOP 30 -0\n"); printf(" TOP -Port Anzahl ein Port, soviel Plaetze TOP -0 30 \n"); printf(" TOP Call nur ein Rufzeichen TOP dg8br\n"); printf(" TOP Ca* Alle Call's mit DL TOP dl*\n"); printf(" TOP -L3 Die L3HEARD auswerten\n"); printf(" TOP -v Version\n"); printf(" TOP -h dieses hier\n\n"); printf("Weitere Hilfe gibt es mit 'Help Top'\n"); /* Hinweis auf Help */ } /*---------------------------------------------------------------------------- ** Vergleicht 2 Calls miteinander. ** Beide calls werden ohne SSId geliefert. ** Returnwert : bei Gleichheit 0, sonst 1 ** call1 == das Call das gesucht wird. ** call2 == mit dem wird verglichen ** wird von addier und callraus aufgerufen */ int callcmp ( char *call1 , char *call2, int len ) { while ( len-- ) /* Call wird zeichenweise verglichen */ if (*call1++ != *call2++ ) /* bei Gleichheit return mit 0 */ return (1); return (0); } /*---------------------------------------------------------------------------- ** Die Gesamt-Zahl der Endsummen werden zwecks besserer Lesbarkeit ** mit 100ter Punkte versehen. ** Wird von sortier aufgerufen. ** Rueckgabe : gepunkteter String */ char* punkte (char *string, unsigned long all) { char temp[20]; /* Hilfsstring */ char *tp = temp; /* Zeiger auf temp */ int a = 0; /* Zaehler fuer Punkte */ int b = 0; /* Zaehler Returnstring */ while ( all ) /* Solange das Ende von all nicht erreicht */ { #ifdef WIN32 *tp++ = (char)((all % 10) + '0'); /* Zahl/10 und den Rest verasscien */ #else *tp++ = (all % 10) + '0'; /* Zahl/10 und den Rest verasscien */ #endif /* WIN32 */ all = all / 10; /* Quelle muss auch geteilt werden */ a++; if ( a == 3 && all != EOS) /* Punkt einfuegen */ { *tp++ = '.'; a = 0; } } *tp = EOS; a = strlen(temp); while ( a ) /* und nun kopieren, aber von hinten nach vorne */ string[b++] = temp[--a]; string[b] = EOS; return(string); } /*---------------------------------------------------------------------------- ** Generelle Einleseroutine. Wird von main aufgerufen. ** Es wird immer fuer einen Eintrag dynamisch Speicher allociert. ** Und auch nur ein Eintrag zur Zeit gelesen. ** Der erste Speicherplatz hat auch schon gueltige Daten. Der letze Eintrag ** hat im "naechster" ein NULL stehen!! Es geht bis zum NULL-Eintrag!! ** User die im TX oder RX nichts haben, werden eingelesen aber wenn keine ** Einzelausgabe gewuenscht sofort wieder geloescht. ** Wird von main aufgerufen. ** ** Der CONFPATH wird nun vom Programm ermittelt. Es wird also bei der Linux- ** Version kein globaler CONFPATH-Eintrag mehr benoetigt. Bei der DOS(GNU32) ** wird es aber gesetzt, aber nicht genutzt. Bei der Linux-Version wird der ** Eintrag auch gesetzt, gilt aber nur fuer den TNN-Task. ** ** neues Format der MHEARD.TAB jetzt reiner ASCII ** Erster Eintrag ist der neuste Eintrag. ** Aufbau : Zeit im PC-Format , RX-Bytes , TX-Bytes , Port ** rx-rej , tx-rej , dama-verstoesse , Call ** ** Bespiel: 855398713 1083577 170775 2 1 8 2 DG9FU-15 */ void einles (int alles, int Gesamt) { FILE *ein; int a = 0; char buffer[81]; char file[81]; char *fp; struct line *indexalt = NULL; /* Hilfszeiger um alten Eintrag zufinden */ int kontrolle = 0; /* Zaehler der eingelesenen Datensaetze */ *file = EOS; if(getcwd(file,80) == NULL) /* Pfad feststellen */ { printf("\nKonnte den Pfad nicht ermitteln !\n"); exit(0); } if(*(fp = file + strlen(file)) != Seperator) { *fp++ = Seperator; /* Seperator anhaengen */ *fp = EOS; /* und schulz */ } strcat(file,filename); if (( ein = fopen (file , "rb")) == NULL) { printf ("\n%s nicht gefunden!\n", file); exit (0); } if (get_ftime(fileno(ein)) != 0) printf("\nEndezeit kann nicht ermittelt werden !\n"); while (!feof(ein)) { if ((liste = malloc(sizeof(struct line))) == NULL) { printf("Kein Speicher!!! %d Datensaetze eingelesen.\n",kontrolle); kontrolle = sizeof(struct line); printf("Eine Datenzeile benoetigt %d Bytes.\n",kontrolle); printf("Bitte diese Zeilen mit Digicall mir, DG8BR, zuschicken!!"); exit(0); } kontrolle++; if (( fgets (buffer, 80, ein )) != NULL) { if ( buffer[0] == ':' ) /* dann wurde die MHEARD begonnen */ { /* ist ab der 1.74xx drin */ sscanf ( buffer+1, "%lu", (unsigned long *)&Dateianfang ); continue; } liste->via[0] = EOS; liste->call[0] = EOS; sscanf (buffer ,"%lu %lu %lu %u %u %u %u %u %s %s", (unsigned long *)&liste->heard ,&liste->rx ,&liste->tx ,&liste->mhport, &liste->d, &liste->r ,&liste->t ,&liste->flag,liste->call, liste->via); if(Gesamt == 0) { if(alles == 1 && ((liste ->tx == 0L) || (liste->rx == 0L))) { free(liste); continue; /* Bei Summenausgabe, nur Leute mit gueltigen Daten */ } } if ( alles == 1 ) /* Bei Summenausgabe, die SSId weg */ ssid_weg (liste->call); liste->dummi = ' '; liste->gesamt = 0L; if ( a == 0 ) { listenanfang = liste; /* Damit wird der 1.te Eintrag gefunden */ indexalt = liste; /* beim 1.ten Mal muss hier gespeichert werden */ a++; } indexalt->naechster = liste; /* im vorherigen Eintrag den Naechsten */ indexalt = liste; /* eintragen. Und dann den Alten auf neu setzen */ } } indexalt->naechster = NULL; /* Sonst wird das Ende der Liste nicht bemerkt*/ fclose(ein); #ifdef DEBUG printf("%d Datensaetze eingelesen.\n",kontrolle); printf("einles erfolgreich.\n"); #endif } /*---------------------------------------------------------------------------- ** Alle Bytes eines Call's zusammenzaehlen. Es werden bis auf einen Listen- ** eintrag alle ungueltig gemacht. ** Ermittelt fuer die globalen Variablen max und port.gesamt die Werte. ** Wird von main aufgerufen. ** */ void addier (void) { struct line *index = NULL; /* Zieleintrag */ struct line *indexalt = NULL; /* vorheriger Eintrag beim Durchsuchen */ liste = listenanfang; /* Und nu geht es los */ while ( liste != NULL ) { index = liste; /* call uebernehmen */ indexalt = liste; /* aktuell merken */ liste = liste->naechster; /* und weiterschalten */ while ( liste != NULL) { if (!callcmp (index->call, liste->call, 6 )) /* call gleich ?? */ { if (index->mhport == liste->mhport) /* und Port gleich ?? */ { index->tx += liste->tx; /* a weng rechnen */ index->rx += liste->rx; index->t += liste->t; index->r += liste->r; index->d += liste->d; indexalt->naechster = liste->naechster; /* Listenplatz aendern */ free ( liste ); /* und den Alten wech */ liste = indexalt->naechster; /* zurueck auf aktuellen Stand */ } else /* Call gleich, aber anderer port */ { if (index->dummi != '#') /* wenn noch nicht gekennzeichnet */ { index->dummi = liste->dummi = '#'; max_user--; /* Jedes Call wird nur einmal gezaehlt */ } indexalt = liste; liste = liste->naechster; /* und weiterschalten */ } } else /* call nicht gleich */ { indexalt = liste; /* aktuell merken */ liste = liste->naechster; /* und weiterschalten */ } } index->gesamt = index->tx + index->rx; /* Ergebnisse speichern */ index->platz = 0; max_user++; max += index->gesamt; /* Gesamtdurchsatz des Digi's */ port[index->mhport].gesamt += index->gesamt; /* Portdurchsatz */ liste = index->naechster; /* zurueck */ } #ifdef DEBUG printf("addier erfolgreich.\n"); #endif } /*---------------------------------------------------------------------------- ** Suche nach der groessten Zahl und zwar nehme 1.te Zahl und vergleiche mit ** der naechsten. Ist sie groesser, nehmen, sonst naechsten Platz. Wenn Zahl ** gefunden, wird ein Platz vergeben und es beginnt von vorne. Die Liste ** wird nur nach gueltigen Listenplaetzen durchsucht. D.h. nur wenn Platz = 0 ** ist. ** Hier ist nun auch die Ausgabe. Ausgegeben wird bis Anzahl erreicht. Die ** Liste wird trotzdem bis zum Ende durchsucht um die Anzahl der Benutzer ** zubekommen. ** Wird von main aufgerufen. ** */ void sortier (int anzahl, int ports) { int a; int c = 0; /* Ausgabeplatz */ char f[32]; unsigned long aktu; unsigned long alleszusammen = 0L; char tmp[15]; /* Rueckgabevariable fuer gepunkteten String */ struct line *indexplatz = NULL; /* hat zur Zeit das meiste */ /* und wird ausgegeben */ struct tm *ts; liste = listenanfang; /* von Vorne suchen */ while ( liste != NULL ) { a = 0; aktu = 0L; /* und wieder auf 0, damit wieder richtig gefunden wird */ while ( liste != NULL ) /* Es wird immer die ganze Tabelle durchsucht */ { #ifdef WIN32 if((liste->platz == 0) && (liste->mhport == (unsigned int)ports || ports == 'a')) #else if((liste->platz == 0) && (liste->mhport == ports || ports == 'a')) #endif /* WIN32 */ { /* platz gueltig, dann mit aktu vergleichen */ if ((liste->gesamt) >= aktu) /* wenn aktu > gesamt */ { /* dann neuen aktu uebernehmen */ aktu = liste->gesamt; /* um die Plaetze zuerhalten */ indexplatz = liste; /* der hat die meisten, uebernehmen */ a = 1; /* Flag setzen fuer fuendig geworden */ } } liste = liste->naechster; } if (a == 1) /* Es wurde was gefunden */ { indexplatz->platz = 5000; /* Pseudo-Platznummer vergeben */ if ( c == 0 ) /* nur beim 1ten mal */ { ts = localtime(&Dateianfang); /* Zeit von Anfang holen */ if (!strcmp(filename, "mheard.tab")) printf("\n\n MHEARD-Auswertung"); else printf("\n\n L3MHEARD-Auswertung"); printf(" vom %02d.%02d.%02d %02d:%02d %.3s", ts->tm_mday, ts->tm_mon+1, ts->tm_year%100, ts->tm_hour, ts->tm_min, zeitzone); ts = localtime(&filetime); /* Zeit von Listenende */ printf(" bis %02d.%02d.%02d %02d:%02d %.3s\n",ts->tm_mday, ts->tm_mon+1, ts->tm_year%100, ts->tm_hour, ts->tm_min, zeitzone); printf("\nNr. Call Port Rx Tx " "Summe %%"); if (!strcmp( filename,"mheard.tab")) printf(" RxRej TxRej Dama\n"); c++; /* nun Platzzaehler */ } if ( ports == 'a' ) /* Alle Ports ausgeben ? */ prozent(indexplatz->gesamt,max, f); else prozent(indexplatz->gesamt ,port[ports].gesamt,f); /* Prozentsatz des Users berechnen */ printf("\n%3u %-6s %-10s %10lu %10lu %10lu %5s", c,indexplatz->call,port[indexplatz->mhport].name,indexplatz->tx, indexplatz->rx,indexplatz->gesamt,f); if (!strcmp( filename , "mheard.tab")) { printf(" %5u %5u %4u %c",indexplatz->t,indexplatz->r, indexplatz->d,indexplatz->dummi); if ( indexplatz->via[0] != EOS ) /* via gibt es nicht mehr */ printf("*"); } else /* L3MHEARD */ printf(" %2c",indexplatz->dummi); alleszusammen += indexplatz->gesamt; c++; /* Anzahl erhoehen */ liste = listenanfang; /* und wieder an Anfang gehen */ } if ( c > anzahl ) break; } if (c == 0 ) /* was gefunden ? */ { if ( ports != 'a' ) printf("\nFuer diesen Port sind keine Daten in der MHEARD-Tabelle!\n"); else printf("\nKeine Daten in der MHEARD-Tabelle!\n"); } else { if ( ports == 'a' ) { prozent(alleszusammen,max,f); printf("\n\nDiese User haben auf allen Ports %s Bytes = %s %%" " uebertragen.\n",punkte( tmp,alleszusammen ), f); } else { prozent(alleszusammen,port[ports].gesamt,f); printf("\n\nDiese User haben auf Port %d (%s) %s Bytes = %s%%" " uebertragen.\n",ports,port[ports].name,punkte( tmp, alleszusammen ),f ); } printf("Insgesamt wurden %s Bytes von %d Benutzer bewegt.\n",punkte (tmp,max), (max_user)); } #ifdef DEBUG printf("sortiert erfolgreich.\n"); #endif } /*---------------------------------------------------------------------------- ** Einzelaugabe eines Calls ** Seit der 1.75 gibt es im L2 keine Via-Eintraege mehr in der MHEARD.TAB. */ void callraus(char *suchcall) { int a; int calllen = 0; char vergleichcall[10] = "0x00"; struct line *liste; struct tm *ts; calllen = strlen (suchcall); for ( a = 0; a < calllen; a++ ) /* call in Grossbuchstaben wandeln */ { suchcall[a] = grossbuchstabe ( suchcall[a] ); } if ( suchcall[calllen -1] =='*' ) /* Wenn * vorhanden, calllen 1 weniger */ calllen-- ; /* sonst wird das * mitgesucht. */ else calllen = 6; a = 0; liste = listenanfang; while (liste != NULL) { strcpy(vergleichcall, liste->call); ssid_weg ( vergleichcall ); if (!callcmp(suchcall,vergleichcall,calllen)) /* und guggen ob da */ { if ( a == 0 ) /* nur beim erstenmal */ { printf("\nDatum Port Rx Tx RxRej " "TxRej D Call\n"); } ts = localtime ( &liste->heard ) ; printf("\n%02d.%02d.%02d %02d:%02d ", ts->tm_mday, ts->tm_mon+1, ts->tm_year%100, ts->tm_hour, ts->tm_min); printf("%-10s %9lu %9lu %5u %5u %3u %-9s", port[liste->mhport].name,liste->tx,liste->rx,liste->t,liste->r, liste->d,liste->call); a = 1; } liste = liste->naechster; } if ( a == 0 ) printf("\n%s nicht gehoert!",suchcall); ts = localtime ( &filetime ); /* wann das letze Mal gesaved */ printf("\n\nStand: %02d.%02d.%02d %02d:%02d %.3s\n", ts->tm_mday, ts->tm_mon+1, ts->tm_year%100, ts->tm_hour, ts->tm_min, zeitzone); #ifdef DEBUG printf("callraus erfolgreich\n"); #endif } /*---------------------------------------------------------------------------- ** Aufruf ohne Parameter ergibt eine Ausgabe von 10 Eintraege von allen Ports. ** Es koennen ein bestimmter Port oder eine bestimmte Anzahl uebergeben ** werden. Oder beides gemeinsam. Reihenfolge, egal. ** Dann kann man noch ein Rufzeichen eingeben. Aber dann nur das!! */ int main (int argc, char *argv[]) { int uni; /* Uebergabevariable fuer max_user */ int Ausgabe = 10; int Gesamt = 0; char Port = 'a'; /* Dummi fuer Ausgabe alle Ports */ char call[10] = "\x0"; char *port_z; /* Zeiger fuer Port */ #ifdef DEBUG clock_t ende; #endif strcpy (filename, "mheard.tab"); for ( argc--, uni = 1; uni < argc; uni++ ) { if (argv[uni][0] == '-') /* erstmal die -Parameter bearbeiten */ { switch (argv[uni][1] ) { case 'V' : case 'v' : printf("\n%s\n",VERSION); exit(0); break; case 'H' : case 'h' : case '?' : benutzung (); exit(0); case 'L' : case 'l' : strcpy(filename, "l3heard.tab"); break; default : if (isdigit( argv[uni][1])) { port_z = argv[uni]; /* auf zeiger umkopieren */ port_z++; /* einen weiterdrehen, damit - verschwindet */ Port = atoi(port_z); /* aus Asci "echte" Hexwerte */ break; /*machen. Kann dann nur Port sein */ } else { benutzung(); /* Kurzhilfe ausgeben */ exit(0); } } } if ( isdigit (argv[uni][0] )) /* Zahl ?? */ Ausgabe = atoi (argv[uni]); /* Anzahl der Ausgabe */ if ( isalpha (argv [uni][0])) /* Buchstabe ?? */ { strncpy ( call, argv[uni],9 ); uni = argc; /* Bei Call wird ALLES ignoriert!! */ if ( strlen ( call ) < 3 ) /* Es sollte mehr als 1 Buchstabe sein */ { printf("\nMindestens 2 Buchstaben und eine Zahl oder * eingeben!\n"); exit (0); } } if(*argv[uni] == '*') Gesamt = 1; /* Alles einlesen, aber SSId weg */ } config_lesen(); if ((port_z = getenv("TZ")) != NULL) strcpy(zeitzone,port_z); if( call[0] ) /* wenn call angegeben, alles ignorieren */ { einles(0,Gesamt); /* MHEARD.TAB einlesen mit Nullbyteleute */ callraus(call); /* Einzelcall ausgeben */ } else { einles(1,Gesamt); /* MHEARD.TAB einlesen OHNE Nullbyteleute */ addier(); sortier(Ausgabe, Port); /* sortiert und gibt aus */ } #ifdef DEBUG ende = clock(); printf("Laufzeit = %ld \n",(ende*100) / 182); #endif exit(EXIT_SUCCESS); }