Return to split.c CVS log

Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / mtr

Annotation of embedaddon/mtr/split.c, revision 1.1.1.1

1.1       misho       1: /*
                      2:     mtr  --  a network diagnostic tool
                      3:     Copyright (C) 1997  Matt Kimball
                      4: 
                      5:     split.c -- raw output (for inclusion in KDE Network Utilities or others
                      6:                          GUI based tools)
                      7:     Copyright (C) 1998  Bertrand Leconte <B.Leconte@mail.dotcom.fr>
                      8: 
                      9:     This program is free software; you can redistribute it and/or modify
                     10:     it under the terms of the GNU General Public License version 2 as 
                     11:     published by the Free Software Foundation.
                     12: 
                     13:     This program is distributed in the hope that it will be useful,
                     14:     but WITHOUT ANY WARRANTY; without even the implied warranty of
                     15:     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
                     16:     GNU General Public License for more details.
                     17: 
                     18:     You should have received a copy of the GNU General Public License
                     19:     along with this program; if not, write to the Free Software
                     20:     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
                     21: */
                     22: 
                     23: #include <config.h>
                     24: #include <ctype.h>
                     25: #include <stdlib.h>
                     26: #include <stdio.h>
                     27: #include <string.h>
                     28: #include <sys/types.h>
                     29: 
                     30: #include "mtr.h"
                     31: #include "display.h"
                     32: #include "dns.h"
                     33: 
                     34: #include "net.h"
                     35: #include "split.h"
                     36: 
                     37: #ifdef NO_CURSES
                     38: #include <sys/time.h>
                     39: #include <sys/types.h>
                     40: #include <unistd.h>
                     41: #else
                     42: /* Use the curses variant */
                     43: 
                     44: #if defined(HAVE_NCURSES_H)
                     45: #  include <ncurses.h>
                     46: #elif defined(HAVE_NCURSES_CURSES_H)
                     47: #  include <ncurses/curses.h>
                     48: #elif defined(HAVE_CURSES_H)
                     49: #  include <curses.h>
                     50: #else
                     51: #  error No curses header file available
                     52: #endif
                     53: 
                     54: #endif
                     55: 
                     56: 
                     57: extern char *Hostname;
                     58: extern int WaitTime;
                     59: extern int af;
                     60: 
                     61: /* There is 256 hops max in the IP header (coded with a byte) */
                     62: #define MAX_LINE_COUNT 256
                     63: #define MAX_LINE_SIZE  256
                     64: 
                     65: char Lines[MAX_LINE_COUNT][MAX_LINE_SIZE];
                     66: int  LineCount;
                     67: 
                     68: 
                     69: #define DEBUG 0
                     70: 
                     71: 
                     72: void split_redraw(void) 
                     73: {
                     74:   int   max;
                     75:   int   at;
                     76:   ip_t *addr;
                     77:   char  newLine[MAX_LINE_SIZE];
                     78:   int   i;
                     79: 
                     80: #if DEBUG
                     81:   fprintf(stderr, "split_redraw()\n"); 
                     82: #endif
                     83: 
                     84:   /* 
                     85:    * If there is less lines than last time, we delete them
                     86:    * TEST THIS PLEASE
                     87:    */
                     88:   max = net_max();
                     89:   for (i=LineCount; i>max; i--) {
                     90:     printf("-%d\n", i);
                     91:     LineCount--;
                     92:   }
                     93: 
                     94:   /*
                     95:    * For each line, we compute the new one and we compare it to the old one
                     96:    */
                     97:   for(at = 0; at < max; at++) {
                     98:     addr = net_addr(at);
                     99:     if(addrcmp((void*)addr, (void*)&unspec_addr, af)) {
                    100:       char str[256], *name;
                    101:       if (!(name = dns_lookup(addr)))
                    102:         name = strlongip(addr);
                    103:       if (show_ips) {
                    104:         snprintf(str, sizeof(str), "%s %s", name, strlongip(addr));
                    105:         name = str;
                    106:       }
                    107:       /* May be we should test name's length */
                    108:       snprintf(newLine, sizeof(newLine), "%s %d %d %d %d %d %d", name,
                    109:                net_loss(at),
                    110:                net_returned(at), net_xmit(at),
                    111:                net_best(at) /1000, net_avg(at)/1000,
                    112:                net_worst(at)/1000);
                    113:     } else {
                    114:       sprintf(newLine, "???");
                    115:     }
                    116: 
                    117:     if (strcmp(newLine, Lines[at]) == 0) {
                    118:       /* The same, so do nothing */
                    119: #if DEBUG
                    120:       printf("SAME LINE\n");
                    121: #endif
                    122:     } else {
                    123:       printf("%d %s\n", at+1, newLine);
                    124:       fflush(stdout);
                    125:       strcpy(Lines[at], newLine);
                    126:       if (LineCount < (at+1)) {
                    127:        LineCount = at+1;
                    128:       }
                    129:     }
                    130:   }
                    131: }
                    132: 
                    133: 
                    134: void split_open(void)
                    135: {
                    136:   int i;
                    137: #if DEBUG
                    138:   printf("split_open()\n");
                    139: #endif
                    140:   LineCount = -1;
                    141:   for (i=0; i<MAX_LINE_COUNT; i++) {
                    142:     strcpy(Lines[i], "???");
                    143:   }
                    144: }
                    145: 
                    146: 
                    147: void split_close(void)
                    148: {
                    149: #if DEBUG
                    150:   printf("split_close()\n");
                    151: #endif
                    152: }
                    153: 
                    154: 
                    155: int split_keyaction(void) 
                    156: {
                    157: #ifdef NO_CURSES
                    158:   fd_set readfds;
                    159:   struct timeval tv;
                    160:   char c;
                    161: 
                    162:   FD_ZERO (&readfds);
                    163:   FD_SET (0, &readfds);
                    164:   tv.tv_sec = 0;
                    165:   tv.tv_usec = 0;
                    166: 
                    167:   if (select (1, &readfds, NULL, NULL, &tv) > 0) {
                    168:     read (0, &c, 1);
                    169:   } else 
                    170:     return 0;
                    171: #else
                    172:   char c = getch();
                    173: #endif
                    174: 
                    175: #if DEBUG
                    176:   printf("split_keyaction()\n");
                    177: #endif
                    178:   if(tolower(c) == 'q')
                    179:     return ActionQuit;
                    180:   if(c==3)
                    181:     return ActionQuit;
                    182:   if(tolower(c) == 'r')
                    183:     return ActionReset;
                    184:   
                    185:   return 0;
                    186: }