home *** CD-ROM | disk | FTP | other *** search
/ NetNews Usenet Archive 1992 #30 / NN_1992_30.iso / spool / alt / irc / 4722 < prev    next >
Encoding:
Text File  |  1992-12-17  |  15.0 KB  |  713 lines
  1. Path: sparky!uunet!munnari.oz.au!manuel.anu.edu.au!coombs!avalon
  2. From: avalon@coombs.anu.edu.au (Darren Reed)
  3. Newsgroups: alt.irc
  4. Subject: IRC Traffic Stats stuff.
  5. Date: 17 Dec 92 16:05:45 GMT
  6. Organization: Australian National University
  7. Lines: 702
  8. Message-ID: <avalon.724608345@coombs>
  9. NNTP-Posting-Host: 150.203.76.2
  10.  
  11.  
  12. I've reworked the stats program a bit and included a couple of perl
  13. scripts which can be used to easily generate a set of commands for
  14. gnuplot.  If you dont have gnuplot then this wont be of much use,
  15. even less use if your system isn't a member of the perl club.
  16.  
  17. unshar, "make all" and run "runplot".  The stats collector backgrounds
  18. into a 'daemon' mode.  use "genplot" to generate the plot file for
  19. gnuplot.  A few data files are also created.  Any bugs, send me email.
  20. Nothing much else has changed.  The graph should turn out to be bytes vs
  21. time and messages vs time.  If you know a bit about gnuplot, you can
  22. get a postscript file of the graph too.  This would be best run by those
  23. who are concerned about traffic and/or would like some hard data about
  24. how much bandwidth IRC is using.
  25.  
  26. avalon
  27. ----cut here--------cut here--------cut here--------cut here--------cut here----
  28. #!/bin/sh
  29. # This is a shell archive.  Save it in a file, remove anything before
  30. # this line, and then unpack it by entering "sh file".  Note, it may
  31. # create directories; files and directories will be owned by you and
  32. # have default permissions.
  33. #
  34. # This archive contains:
  35. #
  36. #    stat/Makefile
  37. #    stat/README
  38. #    stat/flowmon.c
  39. #    stat/genplot
  40. #    stat/runplot
  41. #
  42. echo x - stat/Makefile
  43. sed 's/^X//' >stat/Makefile << 'END-of-stat/Makefile'
  44. X# Makefile (C)1992 Darren Reed
  45. X# Makefile for realtime server stats clients
  46. X#
  47. XLIBS=-lcurses -ltermcap
  48. XCFLAGS=-O
  49. XPROGS=flowmon
  50. X
  51. Xall: $(PROGS)
  52. X
  53. Xcmdmon: cmdmon.c
  54. X    $(CC) $@.c $(CFLAGS) -o $@ $(LIBS)
  55. X
  56. Xflowmon: flowmon.c
  57. X    $(CC) $@.c $(CFLAGS) -o $@ $(LIBS)
  58. X
  59. Xclean:
  60. X    /bin/rm -f core *.o $(PROGS)
  61. END-of-stat/Makefile
  62. echo x - stat/README
  63. sed 's/^X//' >stat/README << 'END-of-stat/README'
  64. X
  65. XSimple...
  66. X
  67. XEdit them to set the nicks, user info and server and then get them compiled.
  68. X
  69. Xthen run using
  70. X
  71. Xcmdmon [ server [ port [ updatedelay ] ] ]
  72. Xflowmon [ server [ port [ updatedelay ] ] ]
  73. X
  74. XBrief.
  75. X------
  76. X
  77. Xcmdmon
  78. X
  79. X   Shows the changing use of the most used commands on the server in sorted
  80. Xorder of most used to least used.
  81. X
  82. Xflowmon
  83. X
  84. X   Shows the flow of data into a server and out its links.  Can be very
  85. Xuseful.  Try flowmon -h for command line options.
  86. X
  87. XBoth use curses to maintain the display and should show as many entries
  88. Xas possible.
  89. X
  90. XThere are probably bugs somewhere too.
  91. END-of-stat/README
  92. echo x - stat/flowmon.c
  93. sed 's/^X//' >stat/flowmon.c << 'END-of-stat/flowmon.c'
  94. X/*
  95. X * flownmon.c (C)1992 Darren Reed.
  96. X * monitors data flow over irc server connections.
  97. X * maybe of use to someone.
  98. X */
  99. X#ifndef lint
  100. Xstatic    char    sccsid[] = "@(#)flowmon.c 2.2 12/18/92 (C)1992 Darren Reed";
  101. X#endif
  102. X
  103. X#include <sys/types.h>
  104. X#include <sys/time.h>
  105. X#include <netinet/in.h>
  106. X#include <sys/socket.h>
  107. X#include <stdio.h>
  108. X#include <fcntl.h>
  109. X#include <curses.h>
  110. X#include <netdb.h>
  111. X/*
  112. X * change this.
  113. X */
  114. Xchar    signon[] ="NICK %s\n\rUSER %s xx xx :Flow monitor\n\rMODE %s +i\r\n";
  115. X/*
  116. X * leave these
  117. X */
  118. Xchar    pong[] = "PONG ping\r\n";
  119. Xchar    statsm[] ="STATS l *\r\n";
  120. Xchar    sends[100], *msg;
  121. Xchar    operm[] = "OPER ---- -----\r\n";
  122. X
  123. X#define    SERVERIP    "150.203.76.2"
  124. X#define    SERVERPORT    6667
  125. X#define    UPDATEDELAY    60
  126. X
  127. Xchar    buff[8192], servn[60], nick[20];
  128. Xchar    name[60];
  129. Xint    port;
  130. Xlong    sq, sm, sb, rm, rb;
  131. Xint    logfd[4];
  132. X
  133. Xstruct stats {
  134. X    int    sndq, sndm, sndb, rcvm, rcvb;
  135. X};
  136. X
  137. Xtypedef struct    Message {
  138. X    char    cnam[60];
  139. X    struct    stats    now;
  140. X     struct    stats    old;
  141. X    long    update;
  142. X} MType;
  143. X
  144. Xstruct Message msgtab[256];
  145. X
  146. Xstatic    int    entries = sizeof(msgtab)/sizeof(MType);
  147. X
  148. Xvoid    doio();
  149. X
  150. Xmain(argc, argv)
  151. Xint    argc;
  152. Xchar    *argv[];
  153. X{
  154. X    FILE    *f;
  155. X    int    fd, mlen, daemon = 0;
  156. X    int    log = 0, set = 0, samples = 0;
  157. X    char    *remote = NULL, *server, *progname = *argv;
  158. X    char    *nick = NULL, *user = NULL;
  159. X    long    waittime;
  160. X    struct    hostent *hp = NULL;
  161. X
  162. X    bzero(msgtab, sizeof(msgtab));
  163. X
  164. X    argv++;
  165. X    argc--;
  166. X    server =  SERVERIP;
  167. X    port = SERVERPORT;
  168. X    waittime = UPDATEDELAY;
  169. X
  170. X    while (*argv && **argv == '-')
  171. X        {
  172. X        register char *s = *argv;
  173. X
  174. X        argc--;
  175. X        for (s++; *s; s++)
  176. X            switch(*s)
  177. X            {
  178. X            case 'd' :
  179. X                daemon = 1;
  180. X                break;
  181. X            case 'l' :
  182. X                log = 1;
  183. X                break;
  184. X            case 'n' :
  185. X                if (*(argv+1))
  186. X                    nick = *++argv;
  187. X                break;
  188. X            case 'p' :
  189. X                if (*(argv+1))
  190. X                    port = atoi(*++argv);
  191. X                break;
  192. X            case 'r' :
  193. X                if (*(argv+1))
  194. X                    remote = *++argv;
  195. X                break;
  196. X            case 's' :
  197. X                if (*(argv+1))
  198. X                    server = *++argv;
  199. X                break;
  200. X            case 'u' :
  201. X                if (*(argv+1))
  202. X                    user = *++argv;
  203. X                break;
  204. X            case 'w' :
  205. X                if (*(argv+1))
  206. X                    waittime = atoi(*++argv);
  207. X                break;
  208. X            case 'z' :
  209. X                if (*(argv+1))
  210. X                    samples = atoi(*++argv);
  211. X                break;
  212. X            case '?' :
  213. X                printf("Usage: %s [-dl] [-n nick] [-p port] \
  214. X[-r server] [-s server] [-u username] [-w seconds]\n");
  215. X                exit(1);
  216. X            default :
  217. X                break;
  218. X            }
  219. X        argv++;
  220. X        }
  221. X    /*
  222. X     * ip# of server to connect to
  223. X     */
  224. X
  225. X    if (remote)
  226. X        {
  227. X        sprintf(sends, "STATS l %s\r\n", remote);
  228. X        if (strcasecmp(remote, server))
  229. X            mlen = strlen(msg = sends);
  230. X        else
  231. X            mlen = strlen(msg = statsm);
  232. X        }
  233. X    else
  234. X        {
  235. X        remote = server;
  236. X        mlen = strlen(msg = statsm);
  237. X        }
  238. X    if (!nick)
  239. X        nick = "flower";
  240. X    if (!user)
  241. X        user = "power";
  242. X
  243. X    sprintf(buff, signon, nick, user, nick);
  244. X    if (log)
  245. X        openlogs(remote);
  246. X
  247. X    fd = connectto(server);
  248. X
  249. X    printf("Connected.\n");
  250. X    write(fd, buff, strlen(buff));
  251. X    write(fd, msg, mlen);
  252. X    bzero(buff, sizeof(buff));
  253. X    if (waittime < 10)
  254. X        waittime = 10;
  255. X
  256. X    if (!daemon)
  257. X        {
  258. X        initscr();
  259. X        clear();
  260. X        refresh();
  261. X        }
  262. X    else
  263. X        {
  264. X        if (fork())
  265. X            exit(0);
  266. X        setpgrp(getpid(),0);
  267. X        }
  268. X
  269. X    while (1) 
  270. X        doio(fd, msg, mlen, remote, log, waittime, daemon, samples);
  271. X}
  272. X
  273. Xint    connectto(server)
  274. Xchar    *server;
  275. X{
  276. X    struct    hostent    *hp;
  277. X    struct    sockaddr_in    sock;
  278. X    int    fd;
  279. X
  280. X    bzero(&sock, sizeof(sock));
  281. X    if (*server)
  282. X        {
  283. X        hp = gethostbyname(server);
  284. X        if (hp)
  285. X            bcopy(hp->h_addr_list[0], (char *)&sock.sin_addr,
  286. X                sizeof(struct in_addr));
  287. X        else
  288. X            {
  289. X            printf("couldnt lookup %s\n",server);
  290. X            exit(0);
  291. X            }
  292. X        }
  293. X    else
  294. X        sock.sin_addr.s_addr = inet_addr(server);
  295. X    printf("Connecting to %s\n", inet_ntoa(sock.sin_addr));
  296. X    sock.sin_port = htons(port);
  297. X    sock.sin_family = AF_INET;
  298. X
  299. X    if ((fd = socket(AF_INET, SOCK_STREAM, 0))<0) {
  300. X        perror("socket");
  301. X        exit(-1);
  302. X    }
  303. X
  304. X    if (connect(fd, (char *)&sock, sizeof(sock))==-1) {
  305. X        perror("connect");
  306. X        exit(-1);
  307. X    }
  308. X    return fd;
  309. X}
  310. X
  311. Xvoid    doio(fd, cmd, cmdlen, remserver, dolog, waittime, daemon, samples)
  312. Xchar    *cmd, *remserver;
  313. Xint    cmdlen, dolog, daemon, samples;
  314. Xlong    waittime;
  315. X{
  316. X    static    long    last = 0, lastm = 0, scanned = 0;
  317. X    static    char    *head = buff, *tail = buff;
  318. X    static    int    done = 0;
  319. X    int    n, len, fields, numb;
  320. X    char    *s = NULL, *t = NULL;
  321. X    fd_set    rd;
  322. X    struct    timeval wait;
  323. X
  324. X    if (!last)
  325. X        last = time(NULL);
  326. X    if (!lastm)
  327. X        lastm = time(NULL);
  328. X    if (!scanned)
  329. X        scanned = time(NULL);
  330. X
  331. X    wait.tv_sec = 1;
  332. X    wait.tv_usec = 0;
  333. X    FD_ZERO(&rd);
  334. X    FD_SET(fd, &rd);
  335. X    n = select(FD_SETSIZE, &rd, NULL, NULL, &wait);
  336. X    if (FD_ISSET(fd, &rd))
  337. X        {
  338. X        len = sizeof(buff) - (tail - buff);
  339. X        if ((len = read(fd, tail, len)) <= 0)
  340. X            {
  341. X            s_error(s);
  342. X            exit(-1);
  343. X            }
  344. X        tail += len;
  345. X        *tail = '\0';
  346. X        /*
  347. X        ** check buffer for presence of full replies (terminated by
  348. X        ** \n's).
  349. X        */
  350. X        while (s = (char *)index(head, '\n'))
  351. X            {
  352. X            *s++ = '\0';
  353. X            len -= (s - head);
  354. X            head = s;
  355. X            if (len <= 0)
  356. X                *buff = '\0';
  357. X            if (t = (char *)index(head, ' '))
  358. X                if (!isdigit(*++t))
  359. X                    continue;
  360. X            fields = sscanf(head, ":%s %d %s", servn, &numb, nick);
  361. X            if ((fields != 3) || (numb < 211) || (numb > 219))
  362. X                continue;
  363. X            if (numb == 219)
  364. X                {
  365. X                if (!daemon)
  366. X                    showstats(remserver, scanned);
  367. X                done++;
  368. X                if (samples && (done == samples))
  369. X                    {
  370. X                    if (dolog)
  371. X                        closelogs();
  372. X                    exit(0);
  373. X                    }
  374. X                }
  375. X            else if (numb == 211)
  376. X                {
  377. X                fields = sscanf(head,
  378. X                        ":%s %d %s %s %d %d %d %d %d",
  379. X                        servn, &numb, nick, name,
  380. X                        &sq, &sm, &sb, &rm, &rb);
  381. X                if (fields == 9)
  382. X                    dostats(remserver, dolog, scanned);
  383. X                }
  384. X            }
  385. X        if (len > 0 && head != buff)
  386. X            {
  387. X            movemem(head, buff, len);
  388. X            head = buff;
  389. X            tail = head + len;
  390. X            *(tail+1) = '\0';
  391. X            }
  392. X        else
  393. X            {
  394. X            head = tail = buff;
  395. X            *buff = '\0';
  396. X            }
  397. X        }
  398. X
  399. X    if ((time(NULL) - last) > 30)
  400. X        {
  401. X        write(fd, pong, strlen(pong));
  402. X        last = time(NULL);
  403. X        }
  404. X
  405. X    if ((time(NULL) - lastm) > waittime)
  406. X        {
  407. X        write(fd, cmd, cmdlen);
  408. X        scanned = lastm = time(NULL);
  409. X        }
  410. X}
  411. X
  412. Xs_error(fd)
  413. Xint    fd;
  414. X{
  415. X    perror("read");
  416. X}
  417. X
  418. Xdostats(remserver, dolog, scantime)
  419. Xchar    *remserver;
  420. Xint    dolog;
  421. Xlong    scantime;
  422. X{
  423. X    register int i;
  424. X    register MType *mp;
  425. X
  426. X    /*
  427. X    ** update old table entry
  428. X    */
  429. X    mp = msgtab;
  430. X    for (i = 256; i; i--, mp++)
  431. X        if (!strcasecmp(mp->cnam, name))
  432. X            {
  433. X            bcopy(&mp->now, &mp->old,
  434. X                sizeof(struct stats));
  435. X            mp->now.sndq = sq;
  436. X            mp->now.sndb = sb;
  437. X            mp->now.sndm = sm;
  438. X            mp->now.rcvb = rb;
  439. X            mp->now.rcvm = rm;
  440. X            mp->update = scantime;
  441. X            if (dolog && !strcasecmp(name, remserver))
  442. X                {
  443. X                    char    num[16];
  444. X    
  445. X                    sprintf(num, "%d\n",
  446. X                        sb - mp->old.sndb);
  447. X                    write(logfd[0], num, strlen(num));
  448. X                    sprintf(num, "%d\n",
  449. X                        sm - mp->old.sndm);
  450. X                    write(logfd[1], num, strlen(num));
  451. X                    sprintf(num, "%d\n",
  452. X                        rb - mp->old.rcvb);
  453. X                    write(logfd[2], num, strlen(num));
  454. X                    sprintf(num, "%d\n",
  455. X                        rm - mp->old.rcvm);
  456. X                    write(logfd[3], num, strlen(num));
  457. X                }
  458. X            return;
  459. X            }
  460. X
  461. X    /*
  462. X    ** add a new one in
  463. X    */
  464. X    mp = msgtab;
  465. X    for (i = 256; i; i--, mp++)
  466. X        if (!*mp->cnam)
  467. X            {
  468. X            strcpy(mp->cnam, name);
  469. X            mp->now.sndq = sq;
  470. X            mp->now.sndb = sb;
  471. X            mp->now.sndm = sm;
  472. X            mp->now.rcvb = rb;
  473. X            mp->now.rcvm = rm;
  474. X            mp->update = scantime;
  475. X            break;
  476. X            }
  477. X}
  478. X
  479. X/*
  480. X** remove un updated entries from the table
  481. X*/
  482. Xremoveold(scantime)
  483. Xlong    scantime;
  484. X{
  485. X    register    int i;
  486. X    register MType *mp;
  487. X
  488. X    mp = msgtab;
  489. X    for (i = 256; i; i--,mp++)
  490. X        if (mp->update && (mp->update < scantime))
  491. X            {
  492. X            mp->now.rcvb = 0;
  493. X            mp->now.sndb = 0;
  494. X            *mp->cnam = '\0';
  495. X            }
  496. X}
  497. X
  498. X/*
  499. X** sort table on bytes received
  500. X*/
  501. Xsortm(p1, p2)
  502. Xregister MType *p1, *p2;
  503. X{
  504. X    return (p2->now.rcvb - p1->now.rcvb);
  505. X}
  506. X
  507. Xshowstats(remserver, scantime)
  508. Xchar    *remserver;
  509. Xlong    scantime;
  510. X{
  511. X    register MType *mp;
  512. X    int    i, show;
  513. X    long    now = time(0);
  514. X    char    *s;
  515. X
  516. X    if ((show = entries) > LINES - 3)
  517. X        show = LINES - 3;
  518. X
  519. X    removeold(scantime);
  520. X    qsort(msgtab, sizeof(msgtab)/sizeof(MType), sizeof(MType), sortm);
  521. X    move(0,0);
  522. X    refresh();
  523. X    mvcur(LINES-1,COLS-1,0,0);
  524. X    refresh();
  525. X    printw("%s %d %s", remserver, port, ctime(&now));
  526. X    printw("Connection                SendQ  SendM     SendB      \
  527. X RecvM     RecvB\n");
  528. X    printw("------------------------- ------ --------- -----------\
  529. X --------- -----------\n");
  530. X
  531. X    mp = msgtab;
  532. X    for (i = COLS - 3; i; i--, mp++)
  533. X        {
  534. X        if (!*mp->cnam)
  535. X            clrtoeol();
  536. X        else
  537. X            {
  538. X            printw("%-25.25s %6d %9d %11d ", mp->cnam,
  539. X                mp->now.sndq, mp->now.sndm - mp->old.sndm,
  540. X                mp->now.sndb - mp->old.sndb);
  541. X            printw("%9d %11d\n", mp->now.rcvm - mp->old.rcvm,
  542. X                mp->now.rcvb - mp->old.rcvb);
  543. X            }
  544. X        }
  545. X    refresh();
  546. X    mvcur(LINES-1,COLS-1,0,0);
  547. X    refresh();
  548. X}
  549. X
  550. X
  551. Xmovemem(s,t,l)
  552. Xregister char *s, *t;
  553. Xregister int l;
  554. X{
  555. X    for (; l >= 0; l--, s++, t++) *t = *s;
  556. X}
  557. X
  558. Xint    stlen(s)
  559. Xregister char *s;
  560. X{
  561. X    register int i = 0;
  562. X
  563. X    for (; *s; s++, i++)
  564. X        ;
  565. X    return i;
  566. X}
  567. X
  568. X/*
  569. X** open 1 log file for each report: bytes in and out, messages in and out
  570. X*/
  571. Xopenlogs(server)
  572. Xchar    *server;
  573. X{
  574. X    char    name[50], *s, logname[70];
  575. X
  576. X    if (s = (char *)index(server, '.'))
  577. X        {
  578. X        *s = '\0';
  579. X        strncpy(name, server, sizeof(name)-1);
  580. X        name[sizeof(name)-1] = '\0';
  581. X        *s = '.';
  582. X        }
  583. X    else
  584. X        {
  585. X        strncpy(name, server, sizeof(name)-1);
  586. X        name[sizeof(name)-1] = '\0';
  587. X        }
  588. X    sprintf(logname, "%s.b-out", name);
  589. X    truncate(logname, 0);
  590. X    if ((logfd[0] = open(logname, O_WRONLY|O_CREAT,0600)) == -1)
  591. X        logopen_error();
  592. X    sprintf(logname, "%s.m-out", name);
  593. X    truncate(logname, 0);
  594. X    if((logfd[1] = open(logname, O_WRONLY|O_CREAT,0600)) == -1)
  595. X        logopen_error();
  596. X    sprintf(logname, "%s.b-in", name);
  597. X    truncate(logname, 0);
  598. X    if((logfd[2] = open(logname, O_WRONLY|O_CREAT,0600)) == -1)
  599. X        logopen_error();
  600. X    sprintf(logname, "%s.m-in", name);
  601. X    truncate(logname, 0);
  602. X    if((logfd[3] = open(logname, O_WRONLY|O_CREAT,0600)) == -1)
  603. X        logopen_error();
  604. X}
  605. X
  606. Xlogopen_error()
  607. X{
  608. X    perror("open");
  609. X    exit(-1);
  610. X}
  611. X
  612. Xcloselogs()
  613. X{
  614. X    int    i;
  615. X
  616. X    for (i = 0; i < 4; i++)
  617. X        close(logfd[i]);
  618. X}
  619. END-of-stat/flowmon.c
  620. echo x - stat/genplot
  621. sed 's/^X//' >stat/genplot << 'END-of-stat/genplot'
  622. X#!/usr/bin/perl
  623. X
  624. X$sccsid = "@(#)genplot    1.1 12/17/92 (C)1992 Darren Reed";
  625. X
  626. Xprint "Generate plot for which server ? ";
  627. X$server=<STDIN>;
  628. Xchop($server);
  629. Xif ($server =~ /[^\.]*\./) {
  630. X    $server =~ s/([^\.]*).*/$1/;
  631. X}
  632. X
  633. X
  634. Xopen(PLT,">$server.plt") || die $!;
  635. Xopen(WC,"wc -l $server.b-in|") || die $!;
  636. X$txt = <WC>;
  637. X@s = split(' ',$txt);
  638. X$lines = @s[0];
  639. Xclose(WC);
  640. Xprint "$lines samples.\n";
  641. X
  642. Xprint PLT "set samples $lines\n";
  643. Xprint PLT "set autoscale y; set grid; set border\n";
  644. Xprint PLT "set xrange[0:$lines]\n";
  645. Xprint PLT "set xlabel \"Time\"\n";
  646. Xprint PLT "plot [0:$lines] '$server.b-in' w lines, '$server.b-out' w lines\n";
  647. Xprint PLT "pause -1\n";
  648. Xprint PLT "plot [0:$lines] '$server.m-in' w lines, '$server.m-out' w lines\n";
  649. Xprint PLT "pause -1\n";
  650. Xclose(PLT);
  651. Xprint "File for gnuplot: $server.plt\n";
  652. Xprint "Datafiles: $server.b-in $server.b-out $server.m-in $server.m-out\n";
  653. X
  654. END-of-stat/genplot
  655. echo x - stat/runplot
  656. sed 's/^X//' >stat/runplot << 'END-of-stat/runplot'
  657. X#!/usr/bin/perl
  658. X$sccsid = "@(#)runplot    1.2 12/18/92 (C)1992 Darren Reed";
  659. X
  660. Xsub ReadName {
  661. X    $_ = <>;
  662. X    chop;
  663. X    if (length < 1) {
  664. X        exit(0);
  665. X    }
  666. X    return $_;
  667. X}
  668. X
  669. X    
  670. Xprint "\nIRC Traffic Monitor\n-------------------\n";
  671. Xprint "Server to connect monitor to > ";
  672. X$server = &ReadName();
  673. Xprint "Server to gather stats on > ";
  674. X$remserver = &ReadName();
  675. Xprint "Nick for monitor to use > ";
  676. X$nick = &ReadName();
  677. Xprint "Number of samples to collect > ";
  678. X$samples = &ReadName();
  679. Xprint "Interval between samples (eg 1s or 1, 2m, 1h) > ";
  680. X$_ = &ReadName();
  681. X
  682. Xif (/[1-9]*m$/) {
  683. X    chop;
  684. X    $interval = $_ * 60;
  685. X} elsif (/[1-9]*h$/) {
  686. X    chop;
  687. X    $interval = $_ * 3600;
  688. X} elsif (/[1-9]*$/) {
  689. X    $interval = $_;
  690. X} elsif ($intv =~ /[1-9]*s$/) {
  691. X    chop;
  692. X    $interval = $_;
  693. X} else {
  694. X    print "Unkown quantity \"$_\"\n";
  695. X    exit(-1);
  696. X}
  697. X
  698. Xprint "Server       : $server\nTarget Server: $remserver\n";
  699. Xprint "Nick         : $nick\nNo. of samples : $samples\n";
  700. Xprint "Interval     : $interval\n";
  701. Xprint "\nOk ? (y/N) ";
  702. X
  703. X$_ = &ReadName();
  704. X
  705. Xif (/^y|^Y/) {
  706. X    system("flowmon -dlsrnwz $server $remserver $nick $interval $samples");
  707. X    print "Monitoring started.\n";
  708. X    print "Come back later and run \"genplot\" to generate gnuplot file\n";
  709. X}
  710. END-of-stat/runplot
  711. exit
  712.  
  713.