commands/simple/udpstat.c

   1 /*
   2 udpstat.c
   3
   4 Created:        March 2001 by Philip Homburg <philip@f-mnx.phicoh.com>
   5 */
   6
   7 #define _MINIX_SOURCE
   8 #define _POSIX_C_SOURCE 2
   9
  10 #include <inet/inet.h>
  11 #undef printf
  12
  13 #include <assert.h>
  14 #include <fcntl.h>
  15 #include <stdio.h>
  16 #include <time.h>
  17 #include <unistd.h>
  18 #include <sys/svrctl.h>
  19 #ifndef __minix_vmd
  20 #include <sys/times.h>
  21 #endif
  22 #include <net/netlib.h>
  23 #include <net/gen/inet.h>
  24 #include <net/gen/netdb.h>
  25 #include <net/gen/socket.h>
  26 #include <minix/queryparam.h>
  27
  28 #include <inet/generic/buf.h>
  29 #include <inet/generic/clock.h>
  30 #include <inet/generic/event.h>
  31 #include <inet/generic/type.h>
  32 #include <inet/generic/udp_int.h>
  33
  34 char *prog_name;
  35 udp_fd_t udp_fd_table[UDP_FD_NR];
  36 udp_port_t *udp_port_table;
  37 udp_port_t *udp_port_tablep;
  38 size_t udp_port_table_s;
  39 size_t udp_port_table_rs;
  40 int udp_port_nr;
  41 char values[6 * sizeof(void *) + 3];
  42 char *valuesl= NULL;
  43 size_t v_size;
  44 int inclSel, numerical;
  45
  46 void print_fd(int i, clock_t now);
  47 void usage(void);
  48
  49 int main(int argc, char*argv[])
  50 {
  51         char *ipstat_device;
  52         int fd, i, r;
  53         size_t psize;
  54         char *pval, *param;
  55         struct timeval uptime;
  56         clock_t now;
  57         int fl;
  58         int a_flag, n_flag;
  59
  60         (prog_name=strrchr(argv[0], '/')) ? prog_name++ : (prog_name=argv[0]);
  61
  62         a_flag= 0;
  63         n_flag= 0;
  64         while ((fl= getopt(argc, argv, "?an")) != -1)
  65         {
  66                 switch(fl)
  67                 {
  68                 case '?':
  69                         usage();
  70                 case 'a':
  71                         a_flag= 1;
  72                         break;
  73                 case 'n':
  74                         n_flag= 1;
  75                         break;
  76                 default:
  77                         fprintf(stderr, "%s: getopt failed: '%c'\n",
  78                                 prog_name, fl);
  79                         exit(1);
  80                 }
  81         }
  82         inclSel= !!a_flag;
  83         numerical= !!n_flag;
  84
  85         ipstat_device= IPSTAT_DEVICE;
  86         if ((fd= open(ipstat_device, O_RDWR)) == -1)
  87         {
  88                 fprintf(stderr, "%s: unable to open '%s': %s\n", prog_name,
  89                         ipstat_device, strerror(errno));
  90                 exit(1);
  91         }
  92
  93         v_size= 2*sizeof(udp_fd_table)+1;
  94         valuesl= realloc(valuesl, v_size);
  95         if (!valuesl)
  96         {
  97                 fprintf(stderr, "%s: unable to malloc %u bytes for valuesl\n",
  98                         prog_name, v_size);
  99                 exit(1);
 100         }
 101
 102         param= "udp_fd_table";
 103         psize= strlen(param);
 104         r= write(fd, param, psize);
 105         if (r != psize)
 106         {
 107                 fprintf(stderr, "%s: write to %s failed: %s\n", prog_name,
 108                         ipstat_device,
 109                         r < 0 ?  strerror(errno) : "short write");
 110                 exit(1);
 111         }
 112         r= read(fd, valuesl, v_size);
 113         if (r < 0)
 114         {
 115                 fprintf(stderr, "%s: read from %s failed: %s\n", prog_name,
 116                         ipstat_device, strerror(errno));
 117                 exit(1);
 118         }
 119         pval= valuesl;
 120         if (paramvalue(&pval, udp_fd_table, sizeof(udp_fd_table)) !=
 121                 sizeof(udp_fd_table))
 122         {
 123                 fprintf(stderr,
 124         "%s: unable to decode the results from queryparam (udp_fd_table)\n",
 125                         prog_name);
 126                 exit(1);
 127         }
 128
 129         /* Get address, size, and element size of the UDP port table */
 130         param = "&udp_port_table,$udp_port_table,$udp_port_table[0]";
 131         psize = strlen(param);
 132         r= write(fd, param, psize);
 133         if (r != psize)
 134         {
 135                 fprintf(stderr, "%s: write to %s failed: %s\n", prog_name,
 136                         ipstat_device,
 137                         r < 0 ?  strerror(errno) : "short write");
 138                 exit(1);
 139         }
 140         r= read(fd, values, sizeof(values));
 141         if (r < 0)
 142         {
 143                 fprintf(stderr, "%s: read from %s failed: %s\n", prog_name,
 144                         ipstat_device, strerror(errno));
 145                 exit(1);
 146         }
 147         pval= values;
 148         if (paramvalue(&pval, &udp_port_tablep, sizeof(udp_port_tablep)) !=
 149                 sizeof(udp_port_tablep) ||
 150                 paramvalue(&pval, &udp_port_table_s, sizeof(udp_port_table_s))
 151                         != sizeof(udp_port_table_s) ||
 152                 paramvalue(&pval, &udp_port_table_rs, sizeof(udp_port_table_rs))
 153                         != sizeof(udp_port_table_rs))
 154         {
 155                 fprintf(stderr,
 156 "%s: unable to decode the results from queryparam (&udp_port_table, ...)\n",
 157                         prog_name);
 158                 exit(1);
 159         }
 160
 161         if (udp_port_table_rs != sizeof(udp_port_table[0]))
 162         {
 163                 fprintf(stderr,
 164         "%s: size mismatch in udp_port_table (different version of inet?)\n",
 165                         prog_name);
 166                 exit(1);
 167         }
 168         udp_port_nr= udp_port_table_s/udp_port_table_rs;
 169         assert(udp_port_table_s == udp_port_nr*udp_port_table_rs);
 170         udp_port_table= malloc(udp_port_table_s);
 171         if (!udp_port_table)
 172         {
 173                 fprintf(stderr,
 174         "%s: unable to malloc %u bytes for udp_port_table\n",
 175                         prog_name, udp_port_table_s);
 176                 exit(1);
 177         }
 178         v_size= 2*udp_port_table_s+1;
 179         valuesl= realloc(valuesl, v_size);
 180         if (!valuesl)
 181         {
 182                 fprintf(stderr, "%s: unable to malloc %u bytes for valuesl\n",
 183                         prog_name, v_size);
 184                 exit(1);
 185         }
 186
 187         param = "udp_port_table";
 188         psize = strlen(param);
 189         r= write(fd, param, psize);
 190         if (r != psize)
 191         {
 192                 fprintf(stderr, "%s: write to %s failed: %s\n", prog_name,
 193                         ipstat_device,
 194                         r < 0 ?  strerror(errno) : "short write");
 195                 exit(1);
 196         }
 197         r= read(fd, valuesl, v_size);
 198         if (r < 0)
 199         {
 200                 fprintf(stderr, "%s: read from %s failed: %s\n", prog_name,
 201                         ipstat_device, strerror(errno));
 202                 exit(1);
 203         }
 204         pval= valuesl;
 205         if (paramvalue(&pval, udp_port_table, udp_port_table_s) !=
 206                 udp_port_table_s)
 207         {
 208                 fprintf(stderr,
 209         "%s: unable to decode the results from queryparam (udp_port_table)\n",
 210                         prog_name);
 211                 exit(1);
 212         }
 213
 214         /* Get the uptime in clock ticks. */
 215 #ifdef __minix_vmd
 216         if (sysutime(UTIME_UPTIME, &uptime) == -1)
 217         {
 218                 fprintf(stderr, "%s: sysutime failed: %s\n", prog_name,
 219                         strerror(errno));
 220                 exit(1);
 221         }
 222         now= uptime.tv_sec * HZ + (uptime.tv_usec*HZ/1000000);
 223 #else   /* Minix 3 */
 224         now= times(NULL);
 225 #endif
 226
 227         for (i= 0; i<UDP_FD_NR; i++)
 228                 print_fd(i, now);
 229         exit(0);
 230 }
 231
 232 void print_fd(int i, clock_t now)
 233 {
 234         unsigned long nwuo_flags;
 235         int port_nr;
 236         udp_fd_t *udp_fd;
 237         udp_port_t *udp_port;
 238         char *locaddr_str, *remaddr_str;
 239         struct hostent *hostent;
 240         struct servent *servent;
 241         nwio_udpopt_t uf_udpopt;
 242
 243         udp_fd= &udp_fd_table[i];
 244         if (!(udp_fd->uf_flags & UFF_INUSE))
 245                 return;
 246         uf_udpopt= udp_fd->uf_udpopt;
 247         nwuo_flags= uf_udpopt.nwuo_flags;
 248         if (((nwuo_flags & NWUO_LOCPORT_MASK) != NWUO_LP_SET) && !inclSel)
 249                 return;
 250
 251         port_nr= udp_fd->uf_port-udp_port_tablep;
 252         udp_port= &udp_port_table[port_nr];
 253
 254         printf("%3d", i);
 255
 256         if (nwuo_flags & NWUO_EN_LOC)
 257         {
 258                 if (!numerical && (hostent=
 259                         gethostbyaddr((char *)&udp_port->up_ipaddr,
 260                         sizeof(ipaddr_t), AF_INET)) != NULL)
 261                 {
 262                         locaddr_str= hostent->h_name;
 263                 }
 264                 else
 265                         locaddr_str= inet_ntoa(udp_port->up_ipaddr);
 266         }
 267         else if (nwuo_flags & NWUO_EN_BROAD)
 268                 locaddr_str= "255.255.255.255";
 269         else
 270                 locaddr_str= "0.0.0.0";
 271
 272         printf(" %s:", locaddr_str);
 273
 274         if ((nwuo_flags & NWUO_LOCPORT_MASK) != NWUO_LP_SEL &&
 275                 (nwuo_flags & NWUO_LOCPORT_MASK) != NWUO_LP_SET)
 276         {
 277                 printf("*");
 278         }
 279         else if ((servent= getservbyport(uf_udpopt.nwuo_locport, "udp")) !=
 280                 NULL)
 281         {
 282                 printf("%s", servent->s_name);
 283         }
 284         else
 285                 printf("%u", ntohs(uf_udpopt.nwuo_locport));
 286
 287         printf(" -> ");
 288
 289         if (!(nwuo_flags & NWUO_RA_SET))
 290                 remaddr_str= "*";
 291         else if (!numerical &&
 292                 (hostent= gethostbyaddr((char *)&uf_udpopt.nwuo_remaddr,
 293                 sizeof(ipaddr_t), AF_INET)) != NULL)
 294         {
 295                 remaddr_str= hostent->h_name;
 296         }
 297         else
 298                 remaddr_str= inet_ntoa(uf_udpopt.nwuo_remaddr);
 299         printf("%s:", remaddr_str);
 300
 301         if (!(nwuo_flags & NWUO_RP_SET))
 302                 printf("*");
 303         else if ((servent= getservbyport(uf_udpopt.nwuo_remport, "udp")) !=
 304                 NULL)
 305         {
 306                 printf("%s", servent->s_name);
 307         }
 308         else
 309                 printf("%u", ntohs(uf_udpopt.nwuo_remport));
 310         printf("\n");
 311 }
 312
 313 void usage(void)
 314 {
 315         fprintf(stderr, "Usage: %s [-a] [-n]\n", prog_name);
 316         exit(1);
 317 }
 318
 319 /*
 320  * $PchId: udpstat.c,v 1.4 2005/01/30 01:04:57 philip Exp $
 321  */