sin_family is not network order
[openafs.git] / src / scout / scout.c
1 /*
2  * Copyright 2000, International Business Machines Corporation and others.
3  * All Rights Reserved.
4  *
5  * This software has been released under the terms of the IBM Public
6  * License.  For details, see the LICENSE file in the top-level source
7  * directory or online at http://www.openafs.org/dl/license10.html
8  */
9
10 /*
11  * Scout: A quick and (semi-)dirty attempt at the old CMU vopcon.
12  *------------------------------------------------------------------------*/
13
14 #include <afsconfig.h>
15 #include <afs/param.h>
16
17
18 #undef  IN
19 #ifdef  AFS_AIX32_ENV
20 #include <signal.h>
21 #endif
22 #include <string.h>
23 #undef IN
24 #include <afs/gtxwindows.h>             /*Generic window package */
25 #include <afs/gtxobjects.h>             /*Object definitions */
26 #include <afs/gtxtextobj.h>             /*Text object interface */
27 #include <afs/gtxlightobj.h>    /*Light object interface */
28 #include <afs/gtxcurseswin.h>   /*Curses window package */
29 #include <afs/gtxdumbwin.h>             /*Dumb terminal window package */
30 #include <afs/gtxX11win.h>              /*X11 window package */
31 #include <afs/gtxframe.h>               /*Frame package */
32 #include <afs/gtxinput.h>
33 #include <stdio.h>              /*Standard I/O stuff */
34 #include <afs/cmd.h>            /*Command interpretation library */
35 #include <afs/fsprobe.h>                /*Interface for fsprobe module */
36 #include <errno.h>
37 #include <afs/afsutil.h>
38 #include <netdb.h>
39 #ifdef HAVE_STDINT_H
40 # include <stdint.h>
41 #endif
42
43 /*
44  * Command line parameter indicies.
45  */
46 #define P_SERVER    0
47 #define P_BASE      1
48 #if 0
49 #define P_PACKAGE   2
50 #endif /* 0 */
51 #define P_FREQ      2
52 #define P_HOST      3
53 #define P_ATTENTION 4
54 #define P_DEBUG     5
55 #define P_WIDTHS    6
56
57 /*
58   * Define the default width in chars for each light object on the mini-line.
59   */
60 #define LIGHTOBJ_CONN_WIDTH      5
61 #define LIGHTOBJ_FETCH_WIDTH    10
62 #define LIGHTOBJ_STORE_WIDTH    10
63 #define LIGHTOBJ_WK_WIDTH        5
64 #define LIGHTOBJ_SRVNAME_WIDTH  13
65 #define LIGHTOBJ_DISK_WIDTH     12
66
67 /*
68  * Define column width indices.
69  */
70 #define COL_CONN        0
71 #define COL_FETCH       1
72 #define COL_STORE       2
73 #define COL_WK          3
74 #define COL_SRVNAME     4
75 #define COL_DISK        5
76
77 /*
78  * Define the types of justification we can perform.
79  */
80 #define SCOUT_RIGHT_JUSTIFY     0
81 #define SCOUT_LEFT_JUSTIFY      1
82 #define SCOUT_CENTER            2
83
84 /*
85  * Define the types of truncation we can perform.
86  */
87 #define SCOUT_LEFT_TRUNC        0
88 #define SCOUT_RIGHT_TRUNC       1
89
90 /*
91  * Define whether the value passed is a labeled disk quantity.
92  */
93 #define SCOUT_ISNT_LDISK        0
94 #define SCOUT_IS_LDISK          1
95
96 /*
97   * We sometimes use index-base pointers, so we need a distinguished
98   * NIL value.
99   */
100 #define SCOUT_NIL  (-1)
101
102 /*
103   * Structure describing everything you want to know about a FileServer
104   * disk.
105   */
106 struct scout_disk {
107     int prev;                   /*Index of previous list entry */
108     int next;                   /*Index of next list entry */
109     int active;                 /*Is this disk known to exist? */
110     char *name;                 /*Single-letter disk name */
111     struct onode *disk_lp;      /*Ptr to disk light object */
112 };
113
114 /*
115   * Structure defining all the objects in the Scout line (or lines)
116   * for each server being watched.  Note that scout_disk linked list
117   * for used disks is ordered alphabetically.
118   */
119 struct mini_line {
120     /*
121      * Information on server location & configuration.
122      */
123     struct sockaddr_in skt;     /*Server's socket info */
124     int numDisks;               /*Number of disks used */
125     /*
126      * Screen location info.
127      */
128     int base_line;              /*Line number on the screen */
129     int num_lines;              /*Number of lines of info */
130     /*
131      * Associated light objects.
132      */
133     struct onode *currConns_lp; /*Number of current connections */
134     struct onode *fetches_lp;   /*Number of data fetches */
135     struct onode *stores_lp;    /*Number of data stores */
136     struct onode *workstations_lp;      /*Workstation info */
137     struct onode *srvName_lp;   /*Server name */
138     struct scout_disk disks[VOLMAXPARTS];       /*Info on all the disks */
139     int used_head;              /*Index of first used disk struct */
140     int used_tail;              /*Index of last used disk struct */
141     int free_head;              /*Index of first free disk struct */
142     int free_tail;              /*Index of last free disk struct */
143 };
144
145 /*
146   * Structure defining the contents of the Scout screen.
147   */
148 struct mini_screen {
149     int numServers;             /*Number of servers being watched */
150     int base_line_num;          /*Base mini-line number */
151     struct mini_line *line;     /*Array of screen lines */
152 };
153
154 static char pn[] = "scout";     /*Program name */
155 static int scout_debug = 0;     /*Is debugging turned on? */
156 static FILE *scout_debugfd;     /*Debugging file descriptor */
157 static int scout_gtx_initialized = 0;   /*Has gtx been initialized? */
158 static struct mini_screen scout_screen; /*Mini-screen itself */
159 static int scout_probefreq;     /*Probe frequency in seconds */
160 static char scout_basename[64]; /*Base server name */
161 static char scout_hostname[128];        /*Name of machine we're running on */
162 static int scout_showhostname = 0;      /*Show name of machine we're on? */
163 static char scout_blankline[256];       /*Blank line */
164 static struct gwin *scout_gwin; /*Window to use */
165 static struct gtx_frame *scout_frame;   /*Frame to use */
166 static struct onode *scout_banner0_lp;  /*Banner light, line 0 */
167 static struct onode *scout_banner1_lp;  /*Banner light, line 1 */
168 static struct onode *scout_banner2_lp;  /*Banner light, line 2 */
169 static int scout_DiskLightLeftCol = 0;  /*Column for leftmost disk light */
170 static struct gwin_sizeparams scout_frameDims;  /*Frame dimensions */
171
172 static int scout_col_width[] = { LIGHTOBJ_CONN_WIDTH,
173     LIGHTOBJ_FETCH_WIDTH,
174     LIGHTOBJ_STORE_WIDTH,
175     LIGHTOBJ_WK_WIDTH,
176     LIGHTOBJ_SRVNAME_WIDTH,
177     LIGHTOBJ_DISK_WIDTH
178 };
179
180 /*
181   * Attention thresholds & modes.
182   */
183 #define SCOUT_ATTN_NOTUSED  (-1)
184 #define SCOUT_DISKM_PCUSED    0
185 #define SCOUT_DISKM_MINFREE   1
186
187 static int scout_attn_conn = SCOUT_ATTN_NOTUSED;
188 static int scout_attn_fetch = SCOUT_ATTN_NOTUSED;
189 static int scout_attn_store = SCOUT_ATTN_NOTUSED;
190 static int scout_attn_workstations = SCOUT_ATTN_NOTUSED;
191 static int scout_attn_disk_mode = SCOUT_DISKM_PCUSED;
192 static int scout_attn_disk_minfree = 1000;
193 static float scout_attn_disk_pcused = 0.95;
194 static char scout_attn_disk_pcusedstr[8] = "95";
195
196 /*
197   * Some strings we'll be using over and over again.
198   */
199 static char scout_Banner[256];
200 static const char *scout_label[] =
201     { "Conn", "Fetch", "Store", "Ws", "", "Disk attn" };
202 static const char *scout_underline[] =
203     { "----", "--------", "--------", "-----", "", "----------" };
204
205
206 /*------------------------------------------------------------------------
207  * scout_CleanExit
208  *
209  * Description:
210  *      Exits cleanly from the Scout.  If gtx has not yet been initialized,
211  *      then we simply call exit() with the value provided.  Otherwise,
212  *      we call the appropriate gtx routine to exit cleanly from gtx, which
213  *      must reset the terminal or window.  We also close the debugging
214  *      file descriptor, if one has been opened.
215  *
216  * Arguments:
217  *      int a_exitval : Value with which to exit the program.
218  *
219  * Returns:
220  *      Void.
221  *
222  * Environment:
223  *      Actions depend on scout_gtx_initialized.
224  *
225  * Side Effects:
226  *      This routine will always exit Scout.
227  *------------------------------------------------------------------------*/
228
229 static void
230 scout_CleanExit(int a_exitval)
231 {                               /*scout_CleanExit */
232
233     static char rn[] = "scout_CleanExit";       /*Routine name */
234
235     if (scout_debugfd != (FILE *) 0) {
236         fprintf(scout_debugfd, "[%s] Closing debugging file\n", rn);
237         fclose(scout_debugfd);
238     }
239
240     if (scout_gtx_initialized) {
241         gtxframe_exitValue = a_exitval;
242         gtxframe_ExitCmd((void *)(&gtxframe_exitValue), NULL);
243     } else
244         exit(a_exitval);
245
246 }                               /*scout_CleanExit */
247
248 /*------------------------------------------------------------------------
249  * mini_initLightObject
250  *
251  * Description:
252  *      Create and initialize a light onode according to the given
253  *      parameters.
254  *
255  * Arguments:
256  *      char *a_name       : Ptr to the light's string name.
257  *      int a_x            : X offset.
258  *      int a_y            : Y offset.
259  *      int a_width        : Width in chars.
260  *      struct gwin *a_win : Ptr to window structure.
261  *
262  * Returns:
263  *      Ptr to new light onode on success,
264  *      A null pointer otherwise.
265  *
266  * Environment:
267  *      See above.
268  *
269  * Side Effects:
270  *      As advertised.
271  *------------------------------------------------------------------------*/
272
273 static struct onode *
274 mini_initLightObject(char *a_name, int a_x, int a_y, int a_width, struct gwin *a_win)
275 {                               /*mini_initLightObject */
276
277     static char rn[] = "mini_initLightObject";  /*Routine name */
278     struct onode *newlightp;    /*Ptr to new light onode */
279     /*We only support curses right now */
280     struct gator_light_crparams light_crparams; /*Light creation params */
281     char *truncname;            /*Truncated name, if needed */
282     int name_len;               /*True length of name */
283
284     if (scout_debug) {
285         fprintf(scout_debugfd,
286                 "[%s] Called for name '%s', [%d, %d], %d-char field\n", rn,
287                 a_name, a_x, a_y, a_width);
288         fflush(scout_debugfd);
289     }
290     newlightp = NULL;
291
292     /*
293      * Set up the creation parameters according to the information we've
294      * received.
295      */
296     light_crparams.onode_params.cr_type = GATOR_OBJ_LIGHT;
297     name_len = strlen(a_name);
298     if (scout_debug)
299         fprintf(scout_debugfd, "[%s] Name '%s' has %d chars\n", rn, a_name,
300                 name_len);
301     if (name_len <= a_width)
302         sprintf(light_crparams.onode_params.cr_name, "%s", a_name);
303     else {
304         /*
305          * We need to truncate the given name, leaving a `*' at the end to
306          * show us it's been truncated.
307          */
308         truncname = light_crparams.onode_params.cr_name;
309         strncpy(truncname, a_name, a_width - 1);
310         truncname[a_width - 1] = '*';
311         truncname[a_width] = 0;
312     }
313     light_crparams.onode_params.cr_x = a_x;
314     light_crparams.onode_params.cr_y = a_y;
315     light_crparams.onode_params.cr_width = a_width;
316     light_crparams.onode_params.cr_height = 1;
317     light_crparams.onode_params.cr_window = a_win;
318     light_crparams.onode_params.cr_home_obj = NULL;
319     light_crparams.onode_params.cr_prev_obj = NULL;
320     light_crparams.onode_params.cr_parent_obj = NULL;
321     light_crparams.onode_params.cr_helpstring = NULL;
322
323     light_crparams.appearance = 0;
324     light_crparams.flashfreq = 0;
325     sprintf(light_crparams.label, "%s", a_name);
326     light_crparams.label_x = 0;
327     light_crparams.label_y = 0;
328
329     newlightp =
330         gator_objects_create((struct onode_createparams *)(&light_crparams));
331
332     /*
333      * Return the news, happy or not.
334      */
335     return (newlightp);
336
337 }                               /*mini_initLightObject */
338
339 /*------------------------------------------------------------------------
340  * scout_initDiskLightObjects
341  *
342  * Description:
343  *      Create and initialize all Scout light objects for a server's
344  *      disks.
345  *
346  * Arguments:
347  *      struct scout_disk *a_line : Ptr to the server object line.
348  *      struct gwin *a_win        : Ptr to window structure.
349  *
350  * Returns:
351  *      0 on success,
352  *      -1 otherwise.
353  *
354  * Environment:
355  *      See above.
356  *
357  * Side Effects:
358  *      As advertised.
359  *------------------------------------------------------------------------*/
360
361 static int
362 scout_initDiskLightObjects(struct mini_line *a_line, struct gwin *a_win)
363 {                               /*scout_initDiskLightObjects */
364
365     static char rn[] = "scout_initDiskLightObjects";    /*Routine name */
366     struct scout_disk *curr_disk;       /*Ptr to current disk being set up */
367     int i;                      /*Loop variable */
368
369     if (scout_debug) {
370         fprintf(scout_debugfd, "[%s] Called\n", rn);
371         fflush(scout_debugfd);
372     }
373
374     /*
375      * Set up the base linked list fields.
376      */
377     a_line->used_head = SCOUT_NIL;
378     a_line->used_tail = SCOUT_NIL;
379     a_line->free_head = 0;
380     a_line->free_tail = VOLMAXPARTS - 1;
381
382     /*
383      * Sweep through the disk structures, creating the light objects and
384      * marking them all as free.
385      */
386     curr_disk = a_line->disks;
387     for (i = 0; i < VOLMAXPARTS; i++) {
388         /*
389          * Create the disk light object.
390          */
391         if ((curr_disk->disk_lp = mini_initLightObject("Disk",  /*Object name */
392                                                        0,       /*X value */
393                                                        0,       /*Y value */
394                                                        scout_col_width[COL_DISK],       /*Width */
395                                                        a_win))  /*Window */
396             == NULL) {
397             fprintf(stderr, "[%s:%s] Can't create disk %d light object\n", pn,
398                     rn, i);
399             return (-1);
400         }
401
402         /*
403          * Set the other fields in the disk records; Note that in the
404          * fencepost cases, the prev and next pointers will have to be
405          * fixed.
406          */
407         curr_disk->prev = i - 1;
408         curr_disk->next = i + 1;
409         curr_disk->active = 0;
410         curr_disk->name = '\0';
411
412         /*
413          * Bump up to the next disk structure.
414          */
415         curr_disk++;
416
417     }                           /*for each disk structure */
418
419     /*
420      * We made it all the way through.  Fix the fencepost pointers, set
421      * the overall pointers, then return success.
422      */
423     a_line->disks[0].prev = SCOUT_NIL;
424     a_line->disks[VOLMAXPARTS - 1].next = SCOUT_NIL;
425
426     return (0);
427
428 }                               /*scout_initDiskLightObjects */
429
430
431 /*------------------------------------------------------------------------
432  * mini_justify
433  *
434  * Description:
435  *      Place the chars in the source buffer into the target buffer
436  *      with the desired justification, either centered, left-justified
437  *      or right-justified.  Also, support inidication of truncation
438  *      with a star (*), either on the left or right of the string,
439  *      and whether we're justifying a labeled disk quantity.
440  *
441  * Arguments:
442  *      char *a_srcbuff     : Ptr to source char buffer.
443  *      char *a_dstbuff     : Ptr to dest char buffer.
444  *      int a_dstwidth      : Width of dest buffer in chars.
445  *      int a_justification : Kind of justification.
446  *      int a_rightTrunc    : If non-zero, place the truncation char
447  *                            on the right of the string.  Otherwise,
448  *                            place it on the left.
449  *      int a_isLabeledDisk : Is this a labeled disk quantity?
450  *
451  * Returns:
452  *      0 on success,
453  *      -1 otherwise.
454  *
455  * Environment:
456  *      All it needs to know is exported by the fsprobe module, namely
457  *      the data structure where the probe results are stored.
458  *
459  * Side Effects:
460  *      As advertised.
461  *------------------------------------------------------------------------*/
462
463 int
464 mini_justify(char *a_srcbuff, char *a_dstbuff, int a_dstwidth,
465              int a_justification, int a_rightTrunc,
466              int a_isLabeledDisk)
467 {                               /*mini_justify */
468
469     static char rn[] = "mini_justify";  /*Routine name */
470     int leftpad_chars;          /*# of chars for left-padding */
471     int num_src_chars;          /*# of chars in source */
472     int true_num_src_chars;     /*# src chars before truncation */
473     int trunc_needed;           /*Is truncation needed? */
474     char diskChar = 0;          /*Disk name prefix */
475
476     if (scout_debug) {
477         fprintf(scout_debugfd, "[%s] Called with '%s', dest width=%d\n", rn,
478                 a_srcbuff, a_dstwidth);
479         fflush(scout_debugfd);
480     }
481
482     /*
483      * Remember the disk label, if we've been passed such a thing.
484      */
485     if (a_isLabeledDisk)
486         diskChar = *a_srcbuff;
487
488     /*
489      * If the destination width will overrun the gtx string storage,
490      * we automatically shorten up.
491      */
492     if (a_dstwidth > GATOR_LABEL_CHARS) {
493         if (scout_debug) {
494             fprintf(scout_debugfd,
495                     "[%s] Dest width (%d) > gtx buflen (%d), shrinking dest width\n",
496                     rn, a_dstwidth, GATOR_LABEL_CHARS);
497             fflush(scout_debugfd);
498         }
499         a_dstwidth = GATOR_LABEL_CHARS;
500     }
501
502     /*
503      * If our source string is too long, prepare for truncation.
504      */
505     true_num_src_chars = strlen(a_srcbuff);
506     if (true_num_src_chars >= a_dstwidth) {
507         trunc_needed = 1;
508         num_src_chars = a_dstwidth - 1;
509         leftpad_chars = 0;
510         if (!a_rightTrunc)
511             a_srcbuff += (true_num_src_chars - num_src_chars);
512     } else {
513         trunc_needed = 0;
514         num_src_chars = true_num_src_chars;
515
516         /*
517          * Compute the necessary left-padding.
518          */
519         switch (a_justification) {
520
521         case SCOUT_RIGHT_JUSTIFY:
522             leftpad_chars = (a_dstwidth - 1) - num_src_chars;
523             break;
524
525         case SCOUT_LEFT_JUSTIFY:
526             /*
527              * This is the really easy one.
528              */
529             leftpad_chars = 0;
530             break;
531
532         case SCOUT_CENTER:
533             leftpad_chars = ((a_dstwidth - 1) - num_src_chars) / 2;
534             break;
535
536         default:
537             fprintf(stderr, "[%s] Illegal justification command: %d", rn,
538                     a_justification);
539             return (-1);
540         }                       /*Switch on justification type */
541     }
542
543     /*
544      * Clear out the dest buffer, then place the source string at the
545      * appropriate padding location.  Remember to place a string
546      * terminator at the end of the dest buffer, plus whatever truncation
547      * may be needed.  If we're left-truncating, we've already shifted
548      * the src buffer appropriately.
549      */
550     strncpy(a_dstbuff, scout_blankline, a_dstwidth);
551     strncpy(a_dstbuff + leftpad_chars, a_srcbuff, num_src_chars);
552     *(a_dstbuff + a_dstwidth - 1) = '\0';
553     if (trunc_needed) {
554         if (a_rightTrunc)
555             *(a_dstbuff + a_dstwidth - 2) = '*';        /*Truncate on the right */
556         else {
557             if (a_isLabeledDisk) {
558                 *a_dstbuff = diskChar;
559                 *(a_dstbuff + 1) = ':';
560                 *(a_dstbuff + 2) = '*'; /*Truncate on the left, disk */
561             } else
562                 *a_dstbuff = '*';       /*Truncate on the left, non-disk */
563         }
564     }
565
566     /*Handle truncations */
567     /*
568      * Return the good news.
569      */
570     return (0);
571
572 }                               /*mini_justify */
573
574 /*------------------------------------------------------------------------
575  * scout_SetNonDiskLightLine
576  *
577  * Description:
578  *      Given a mini-line and a line number, place all non-disk lights
579  *      on that line.
580  *
581  * Arguments:
582  *      struct mini_line *a_srvline : Ptr to server descriptor.
583  *      int a_linenum               : Line number to move to.
584  *
585  * Returns:
586  *      Nothing.
587  *
588  * Environment:
589  *      The light's location is stored not only in the onode, but in
590  *      the light's rock, so we have to change both sets of value.
591  *
592  * Side Effects:
593  *      As described.
594  *------------------------------------------------------------------------*/
595
596 static void
597 scout_SetNonDiskLightLine(struct mini_line *a_srvline, int a_linenum)
598 {                               /*scout_SetNonDiskLightLine */
599
600     struct gator_lightobj *nondisk_lightdata;   /*Non-disk light data field */
601     struct gwin_strparams *nondisk_strparams;   /*Associated string params */
602
603     /*
604      * Do the exact same operation for each non-disk light in the record.
605      */
606     a_srvline->currConns_lp->o_y = a_linenum;
607     nondisk_lightdata =
608         (struct gator_lightobj *)(a_srvline->currConns_lp->o_data);
609     nondisk_strparams = (struct gwin_strparams *)(nondisk_lightdata->llrock);
610     nondisk_strparams->y = a_linenum;
611
612     a_srvline->fetches_lp->o_y = a_linenum;
613     nondisk_lightdata =
614         (struct gator_lightobj *)(a_srvline->fetches_lp->o_data);
615     nondisk_strparams = (struct gwin_strparams *)(nondisk_lightdata->llrock);
616     nondisk_strparams->y = a_linenum;
617
618     a_srvline->stores_lp->o_y = a_linenum;
619     nondisk_lightdata =
620         (struct gator_lightobj *)(a_srvline->stores_lp->o_data);
621     nondisk_strparams = (struct gwin_strparams *)(nondisk_lightdata->llrock);
622     nondisk_strparams->y = a_linenum;
623
624     a_srvline->workstations_lp->o_y = a_linenum;
625     nondisk_lightdata =
626         (struct gator_lightobj *)(a_srvline->workstations_lp->o_data);
627     nondisk_strparams = (struct gwin_strparams *)(nondisk_lightdata->llrock);
628     nondisk_strparams->y = a_linenum;
629
630     a_srvline->srvName_lp->o_y = a_linenum;
631     nondisk_lightdata =
632         (struct gator_lightobj *)(a_srvline->srvName_lp->o_data);
633     nondisk_strparams = (struct gwin_strparams *)(nondisk_lightdata->llrock);
634     nondisk_strparams->y = a_linenum;
635
636 }                               /*scout_SetNonDiskLightLine */
637
638 /*------------------------------------------------------------------------
639  * scout_RecomputeLightLocs
640  *
641  * Description:
642  *      Given a pointer to a server record, recompute its disk light
643  *      locations (and keep proper track of the number of screen lines
644  *      required for the server record).
645  *
646  * Arguments:
647  *      struct mini_line *a_srvline : Ptr to server descriptor.
648  *
649  * Returns:
650  *      0 if anything went wrong,
651  *      else the number of lines used by this server record.
652  *
653  * Environment:
654  *      One or more records have joined or left the used light list
655  *      for this server.  We're not sure which ones, so we recompute
656  *      them all.  We may also have had a width change in the gtx
657  *      frame.  The base_line field in the server record is guaranteed
658  *      to be correct at this point.
659  *
660  * Side Effects:
661  *      As described.
662  *------------------------------------------------------------------------*/
663
664 static int
665 scout_RecomputeLightLocs(struct mini_line *a_srvline)
666 {                               /*scout_RecomputeLightLocs */
667
668     static char rn[] = "scout_RecomputeLightLocs";      /*Routine name */
669     int lights_per_line;        /*# lights/line */
670     int lights_this_line;       /*# lights on cur line */
671     int curr_idx;               /*Current disk light idx */
672     struct scout_disk *sc_disk; /*Ptr to disk record array */
673     int lines_for_server;       /*Num lines in server record */
674     int curr_line;              /*Current line being filled */
675     int curr_x;                 /*Current x value for light */
676     struct gator_lightobj *disk_lightdata;      /*Disk light data field */
677     struct gwin_strparams *disk_strparams;      /*String params for disk light */
678
679     if (scout_debug) {
680         fprintf(scout_debugfd, "[%s] Called\n", rn);
681         fflush(scout_debugfd);
682     }
683
684     /*
685      * If we haven't yet computed the column for the leftmost disk light,
686      * do it now.
687      */
688     if (scout_DiskLightLeftCol == 0) {
689         int i;
690         int num_cols = sizeof(scout_col_width) / sizeof(*scout_col_width);
691         scout_DiskLightLeftCol = 0;
692         for (i = 0; i < (num_cols - 1); i++) {
693             scout_DiskLightLeftCol += scout_col_width[i] + 1;
694         }
695     }
696
697     /*
698      * Calculate how many disk light objects can fit in one line.
699      */
700     lights_per_line =
701         (scout_frameDims.maxx -
702          scout_DiskLightLeftCol) / (scout_col_width[COL_DISK] + 1);
703     if (scout_debug) {
704         fprintf(scout_debugfd, "[%s] %d lights per line\n", rn,
705                 lights_per_line);
706         fflush(scout_debugfd);
707     }
708
709     /*
710      * Sweep through the used disk light list, computing the location
711      * for each.
712      */
713     lights_this_line = 0;
714     curr_idx = a_srvline->used_head;
715     lines_for_server = 1;
716     curr_line = a_srvline->base_line;
717     curr_x = scout_DiskLightLeftCol;
718
719     while (curr_idx != SCOUT_NIL) {
720         /*
721          * Bump the number of lines for the server if we've already
722          * filled up the current line.
723          */
724         if (lights_this_line >= lights_per_line) {
725             lights_this_line = 0;
726             lines_for_server++;
727             curr_line++;
728             curr_x = scout_DiskLightLeftCol;
729         }
730
731         /*Current line filled up */
732         /*
733          * Set the current disk light's location.
734          */
735         sc_disk = a_srvline->disks;
736         sc_disk[curr_idx].disk_lp->o_x = curr_x;
737         sc_disk[curr_idx].disk_lp->o_y = curr_line;
738         disk_lightdata =
739             (struct gator_lightobj *)(sc_disk[curr_idx].disk_lp->o_data);
740         disk_strparams = (struct gwin_strparams *)(disk_lightdata->llrock);
741         disk_strparams->x = curr_x;
742         disk_strparams->y = curr_line;
743         if (scout_debug) {
744             fprintf(scout_debugfd,
745                     "[%s] Disk light at index %d located at [%d, %d]\n", rn,
746                     curr_idx, curr_x, curr_line);
747             fflush(scout_debugfd);
748         }
749
750         /*
751          * Record the inclusion of the light and move on to the next
752          * light, if any.
753          */
754         lights_this_line++;
755         curr_x += scout_col_width[COL_DISK] + 1;
756         curr_idx = sc_disk[curr_idx].next;
757
758     }                           /*Update each used disk light */
759
760     /*
761      * Remember to record the (possibly new) number of lines in the
762      * server record before returning the value of that field.
763      */
764     if (a_srvline->num_lines != lines_for_server) {
765         if (scout_debug) {
766             fprintf(scout_debugfd,
767                     "[%s] Server previously had %d screen lines; now changed\n",
768                     rn, a_srvline->num_lines);
769             fflush(scout_debugfd);
770         }
771         a_srvline->num_lines = lines_for_server;
772     }
773
774     if (scout_debug) {
775         fprintf(scout_debugfd, "[%s] Server has %d screen lines\n", rn,
776                 a_srvline->num_lines);
777         fflush(scout_debugfd);
778     }
779     return (a_srvline->num_lines);
780
781 }                               /*scout_RecomputeLightLocs */
782
783 /*------------------------------------------------------------------------
784  * scout_FindUsedDisk
785  *
786  * Description:
787  *      Given a single-letter disk name and a pointer to the current server
788  *      record, look for a used disk record with that name within the server.
789  *      If we can't find one, we create and incorporate one, and return that
790  *      fact to our caller.
791  *
792  * Arguments:
793  *      char a_diskname             : Single-char disk name.
794  *      struct mini_line *a_srvline : Ptr to server descriptor.
795  *      int *a_record_added         : Was a new record added?
796  *
797  * Returns:
798  *      Index of matching used disk record,
799  *      SCOUT_NIL otherwise.
800  *
801  * Return via parameter:
802  *      a_record_added set to 1 iff record was added to the used disk list.
803  *
804  * Environment:
805  *      Used disk records are kept in alphabetical order by the single-char
806  *      disk name.  Should a matching used disk record not be found, one is
807  *      pulled from the free pool.
808  *
809  * Side Effects:
810  *      An entry may be pulled off the free list and inserted into the
811  *      used list.  This entry is placed in the update list for the
812  *      current gtx frame (at least not by this routine).
813  *------------------------------------------------------------------------*/
814
815 static int
816 scout_FindUsedDisk(char *a_diskname, struct mini_line *a_srvline, int *a_record_added)
817 {                               /*scout_FindUsedDisk */
818
819     static char rn[] = "scout_FindUsedDisk";    /*Routine name */
820     int curr_idx;               /*Disk record index */
821     int append_idx;             /*Index to append after */
822     int new_idx;                /*Index of new used record */
823     struct scout_disk *sc_disk; /*Ptr to disk record */
824     int code;                   /*Function return value */
825
826     if (scout_debug) {
827         fprintf(scout_debugfd, "[%s] Called\n", rn);
828         fflush(scout_debugfd);
829     }
830
831     /*
832      * Sweep through the used disk records, looking for a match.
833      */
834     curr_idx = a_srvline->used_head;
835     append_idx = SCOUT_NIL;
836     sc_disk = a_srvline->disks;
837     if (scout_debug) {
838         fprintf(scout_debugfd,
839                 "[%s] Scanning existing used disk entries for disk '%s'\n",
840                 rn, a_diskname);
841         fflush(scout_debugfd);
842     }
843     while (curr_idx != SCOUT_NIL) {
844         if (scout_debug) {
845             fprintf(scout_debugfd, "[%s] Disk %d is named '%s'\n", rn,
846                     curr_idx, sc_disk[curr_idx].name);
847             fflush(scout_debugfd);
848         }
849         if (strcmp(sc_disk[curr_idx].name, a_diskname) == 0) {
850             /*
851              * We found it!  Bug out.
852              */
853             if (scout_debug) {
854                 fprintf(scout_debugfd, "[%s] Match found\n", rn);
855                 fflush(scout_debugfd);
856             }
857             return (curr_idx);
858         }
859
860         /*
861          * If we are alphabetically past the given disk name, we
862          * know that we won't find it in the used disk list; we
863          * also have the append index set correctly.
864          */
865         if (strcmp(a_diskname, sc_disk[curr_idx].name) < 0) {
866             if (scout_debug) {
867                 fprintf(scout_debugfd, "[%s] Disk '%s' can't be here\n", rn,
868                         a_diskname);
869                 fflush(scout_debugfd);
870             }
871             break;
872         }
873
874         /*
875          * There's still hope we'll find it.  Move on to the next used
876          * disk record, keeping this index as the best candidate so far
877          * for appending a missing entry.
878          */
879         append_idx = curr_idx;
880         curr_idx = sc_disk[curr_idx].next;
881     }                           /*Look for match */
882
883     /*
884      * We didn't find the record we wanted, which means we'll pull a
885      * record out of the free pool for it.  If we didn't find a place
886      * to append it, we then insert it at the beginning of the queue.
887      */
888     if (a_srvline->free_head == SCOUT_NIL)
889         return (SCOUT_NIL);
890     *a_record_added = 1;
891     new_idx = a_srvline->free_head;
892     if (scout_debug) {
893         fprintf(scout_debugfd, "[%s] Choosing free index %d for new entry\n",
894                 rn, new_idx);
895         fflush(scout_debugfd);
896     }
897     a_srvline->free_head = sc_disk[new_idx].next;
898     if (a_srvline->free_head == SCOUT_NIL)
899         a_srvline->free_tail = SCOUT_NIL;
900
901     /*
902      * Fill in the new record.
903      */
904     sc_disk[new_idx].active = 0;
905     sc_disk[new_idx].name = a_diskname;
906
907     /*
908      * Insert the new record where it belongs on the used disk list.
909      */
910     if (append_idx == SCOUT_NIL) {
911         /*
912          * It belongs at the beginning of the list.
913          */
914         if (scout_debug) {
915             fprintf(scout_debugfd, "[%s] Inserted at used disk head\n", rn);
916             fflush(scout_debugfd);
917         }
918         sc_disk[new_idx].next = a_srvline->used_head;
919         sc_disk[new_idx].prev = SCOUT_NIL;
920         a_srvline->used_head = new_idx;
921         if (a_srvline->used_tail == SCOUT_NIL)
922             a_srvline->used_tail = new_idx;
923     } else {
924         if (scout_debug) {
925             fprintf(scout_debugfd, "[%s] Entry appended after index %d\n", rn,
926                     append_idx);
927             fflush(scout_debugfd);
928         }
929         sc_disk[new_idx].prev = append_idx;
930         sc_disk[new_idx].next = sc_disk[append_idx].next;
931         sc_disk[append_idx].next = new_idx;
932         if (sc_disk[new_idx].next == SCOUT_NIL)
933             a_srvline->used_tail = new_idx;
934         else
935             sc_disk[sc_disk[new_idx].next].prev = new_idx;
936     };
937
938     /*
939      * Add the new used disk light object to the display list for
940      * the scout frame.
941      */
942     if (scout_debug) {
943         fprintf(scout_debugfd,
944                 "[%s] Adding disk light at index %d to display list\n", rn,
945                 new_idx);
946         fflush(scout_debugfd);
947     }
948     code = gtxframe_AddToList(scout_frame, sc_disk[new_idx].disk_lp);
949     if (code) {
950         if (scout_debug) {
951             fprintf(scout_debugfd,
952                     "[%s] Can't add to display list, code is %d\n", rn, code);
953             fflush(scout_debugfd);
954         }
955     }
956     return (new_idx);
957
958 }                               /*scout_FindUsedDisk */
959
960 /*------------------------------------------------------------------------
961  * scout_RemoveInactiveDisk
962  *
963  * Description:
964  *      Given a server record and a used disk index, remove the disk
965  *      record from the used list, put it on the free list, and remove
966  *      it from the gtx frame update list.
967  *
968  * Arguments:
969  *      struct mini_line *a_srvline     : Ptr to server descriptor.
970  *      int a_used_idx                  : Index of used disk record.
971  *
972  * Returns:
973  *      Nothing.
974  *
975  * Environment:
976  *      Formerly-used disk records are returned to the free pool.
977  *
978  * Side Effects:
979  *      Free and used disk record lists are modified for this server.
980  *      The disk record in question is pulled off the gtx update list
981  *      for the frame.
982  *------------------------------------------------------------------------*/
983
984 static void
985 scout_RemoveInactiveDisk(struct mini_line *a_srvline, int a_used_idx)
986 {                               /*scout_RemoveInactiveDisk */
987
988     static char rn[] = "scout_RemoveInactiveDisk";      /*Routine name */
989
990     if (scout_debug) {
991         fprintf(scout_debugfd, "[%s] Called\n", rn);
992         fflush(scout_debugfd);
993     }
994
995     /*code = gtxframe_RemoveFromList(scout_frame->window, lightobj); */
996
997 }                               /*scout_RemoveInactiveDisk */
998
999 /*------------------------------------------------------------------------
1000  * mini_PrintDiskStats
1001  *
1002  * Description:
1003  *      Given server indexing and light object information, a pointer
1004  *      to a set of statistics, and whether the probe that produced these
1005  *      stats succeeded or not, print out the stats in a nice way.
1006  *
1007  * Arguments:
1008  *      struct mini_line *a_srvline     : Ptr to server descriptor.
1009  *      struct ProbeViceStatistics *a_stats     : Ptr to current stats.
1010  *      int a_probeOK                   : Was the probe OK?
1011  *      int a_width_changed             : Has the frame width changed?
1012  *      int a_fix_line_num              : Is the line number wrong?
1013  *      int a_delta_line_num            : Change in line number.
1014  *
1015  * Returns:
1016  *      0 if something went wrong,
1017  *      else the number of lines taken up by this server record.
1018  *
1019  * Environment:
1020  *      Nothing interesting.
1021  *
1022  * Side Effects:
1023  *      As advertised.
1024  *------------------------------------------------------------------------*/
1025
1026 static int
1027 mini_PrintDiskStats(struct mini_line *a_srvline,
1028                     struct ProbeViceStatistics *a_stats,
1029                     int a_probeOK, int a_width_changed,
1030                     int a_fix_line_num, int a_delta_line_num)
1031 {                               /*mini_PrintDiskStats */
1032
1033     static char rn[] = "mini_PrintDiskStats";   /*Routine name */
1034     int code;                   /*Return code */
1035     char s[128];                /*String buffer */
1036     struct onode *curr_disklight;       /*Ptr to current disk light */
1037     struct onode *srvname_light;        /*Ptr to server name light */
1038     ViceDisk *curr_diskstat;    /*Ptr to current disk stat */
1039     int curr_disk;              /*Current disk stat number */
1040     int used_disk_idx;          /*Used disk index */
1041     int next_used_idx;          /*Ditto */
1042     int pastthreshold;          /*Was disk past threshold? */
1043     struct gator_lightobj *diskdata;    /*Private light data */
1044     struct gwin_strparams *disk_strparams;      /*String params for disk light */
1045     char *diskname = 0;         /*Name of disk */
1046     int found_idx;              /*Idx of matching disk */
1047     char *srv_name;             /*Server name */
1048     struct scout_disk *sc_disk; /*Ptr to scout disk desc */
1049     int fix_light_locs;         /*Recompute disk light locs? */
1050
1051     if (scout_debug) {
1052         fprintf(scout_debugfd, "[%s] Called\n", rn);
1053         fflush(scout_debugfd);
1054     }
1055
1056     /*
1057      * Remember the current server's print name, don't recompute light
1058      * locations yet.
1059      */
1060     srvname_light = a_srvline->srvName_lp;
1061     srv_name = ((struct gator_lightobj *)(srvname_light->o_data))->label;
1062     fix_light_locs = 0;
1063     if (scout_debug) {
1064         fprintf(scout_debugfd, "[%s] Value of a_delta_line_num is %d\n", rn,
1065                 a_delta_line_num);
1066         fflush(scout_debugfd);
1067     }
1068
1069     /*
1070      * If the probe failed, we simply blank out all the used disk
1071      * objects.  Note: a NON-ZERO value of a_probeOK implies failure.
1072      */
1073     if (a_probeOK) {
1074         used_disk_idx = a_srvline->used_head;
1075         while (used_disk_idx != SCOUT_NIL) {
1076             /*
1077              * Point to the current used disk's light, blank out its
1078              * contents, and make sure highlighting is turned off.  We
1079              * also take this opportunity to fix the line numbers if
1080              * needed.
1081              */
1082             curr_disklight = a_srvline->disks[used_disk_idx].disk_lp;
1083             diskdata = (struct gator_lightobj *)(curr_disklight->o_data);
1084             if (scout_debug) {
1085                 fprintf(scout_debugfd,
1086                         "[%s] Prev value of disk light %d: '%s'\n", rn,
1087                         used_disk_idx, diskdata->label);
1088                 fflush(scout_debugfd);
1089             }
1090             code = mini_justify(" ",    /*Src buffer */
1091                                 diskdata->label,        /*Dest buffer */
1092                                 scout_col_width[COL_DISK],      /*Dest's width */
1093                                 SCOUT_RIGHT_JUSTIFY,    /*Right-justify */
1094                                 SCOUT_LEFT_TRUNC,       /*Left-truncate */
1095                                 SCOUT_ISNT_LDISK);      /*Not a labeled disk */
1096             code = gator_light_set(curr_disklight, 0);
1097             if (a_fix_line_num) {
1098                 curr_disklight->o_y += a_delta_line_num;
1099                 disk_strparams = (struct gwin_strparams *)(diskdata->llrock);
1100                 disk_strparams->y += a_delta_line_num;
1101             }
1102
1103             /*
1104              * Advance to next used disk, if any.
1105              */
1106             used_disk_idx = a_srvline->disks[used_disk_idx].next;
1107
1108         }                       /*Blank out disk name field */
1109
1110         /*
1111          * If the frame width has changed, we have to recompute all disk
1112          * light locations.  After that, the number of lines in the server
1113          * record will be accurate, and we return them.
1114          */
1115         if (a_width_changed)
1116             scout_RecomputeLightLocs(a_srvline);
1117
1118         return (a_srvline->num_lines);
1119
1120     }
1121
1122     /*Probe failed for the server */
1123     /*
1124      * Probe was successful.  Sweep through the statistics records,
1125      * and put up all values having to do with AFS partitions.  First,
1126      * mark all used disk objects for this server as inactive and fix
1127      * their line numbers if needed.
1128      */
1129     sc_disk = a_srvline->disks;
1130     used_disk_idx = a_srvline->used_head;
1131     while (used_disk_idx != SCOUT_NIL) {
1132         if (scout_debug) {
1133             fprintf(scout_debugfd, "[%s] Marking used disk %d inactive\n", rn,
1134                     used_disk_idx);
1135             fflush(scout_debugfd);
1136         }
1137         sc_disk = (a_srvline->disks) + used_disk_idx;
1138         sc_disk->active = 0;
1139         used_disk_idx = sc_disk->next;
1140         if (a_fix_line_num) {
1141             sc_disk->disk_lp->o_y += a_delta_line_num;
1142             diskdata = (struct gator_lightobj *)(sc_disk->disk_lp->o_data);
1143             disk_strparams = (struct gwin_strparams *)(diskdata->llrock);
1144             disk_strparams->y += a_delta_line_num;
1145         }
1146     }                           /*Mark used disks inactive */
1147
1148     curr_diskstat = (ViceDisk *) a_stats->Disk;
1149     for (curr_disk = 0; curr_disk < VOLMAXPARTS; curr_disk++) {
1150         /*
1151          * An AFS partition name must be prefixed by `/vicep`.
1152          */
1153         if (scout_debug) {
1154             fprintf(scout_debugfd, "[%s] Disk stats at %p for disk '%s'\n",
1155                     rn, curr_diskstat, curr_diskstat->Name);
1156             fflush(scout_debugfd);
1157         }
1158         if (strncmp("/vice", curr_diskstat->Name, 5) == 0) {
1159             /*
1160              * Pull out the single-letter name (actually, abbreviation)
1161              * of the disk and look for such an entry in the used disks.
1162              */
1163             diskname = &curr_diskstat->Name[6];
1164             found_idx = scout_FindUsedDisk(diskname,    /*1-char name */
1165                                            a_srvline,   /*Server record */
1166                                            &fix_light_locs);    /*Recompute? */
1167             if (found_idx == SCOUT_NIL) {
1168                 fprintf(stderr,
1169                         "[%s] Can't display /vicep%s on server '%s'\n", rn,
1170                         diskname, srv_name);
1171             } else {
1172                 /*
1173                  * Found (or created) record for this disk.  Fill in the single-
1174                  * letter name of the disk followed by the number of free blocks.
1175                  * Turn the disk light on if the number of free blocks exceeds
1176                  * the threshold the user set, either % used or min free blocks.
1177                  */
1178                 sprintf(s, "%s:%d", diskname, curr_diskstat->BlocksAvailable);
1179                 if (scout_attn_disk_mode == SCOUT_DISKM_PCUSED) {
1180                     if ((float)
1181                         (curr_diskstat->TotalBlocks -
1182                          curr_diskstat->BlocksAvailable) /
1183                         (float)(curr_diskstat->TotalBlocks) >
1184                         scout_attn_disk_pcused)
1185                         pastthreshold = 1;
1186                     else
1187                         pastthreshold = 0;
1188                 } else
1189                     pastthreshold =
1190                         (curr_diskstat->BlocksAvailable <
1191                          scout_attn_disk_minfree) ? 1 : 0;
1192                 sc_disk = (a_srvline->disks) + found_idx;
1193                 sc_disk->active = 1;
1194                 diskdata =
1195                     (struct gator_lightobj *)(sc_disk->disk_lp->o_data);
1196                 if (scout_debug) {
1197                     fprintf(scout_debugfd,
1198                             "[%s] Justifying %s for disk idx %d (prev value: '%s')\n",
1199                             rn, s, found_idx, diskdata->label);
1200                     fflush(scout_debugfd);
1201                 }
1202                 code = mini_justify(s,  /*Src buffer */
1203                                     diskdata->label,    /*Dest buffer */
1204                                     scout_col_width[COL_DISK],  /*Dest's width */
1205                                     SCOUT_LEFT_JUSTIFY, /*Left-justify */
1206                                     SCOUT_LEFT_TRUNC,   /*Left-truncate */
1207                                     SCOUT_IS_LDISK);    /*Labeled disk */
1208
1209                 code = gator_light_set(sc_disk->disk_lp, pastthreshold);
1210
1211             }                   /*Found disk record */
1212         }
1213
1214         /*Found AFS disk name */
1215         /*
1216          * Advance to the next disk statistics record.
1217          */
1218         curr_diskstat++;
1219     }                           /*For each statistics record */
1220
1221     /*
1222      * We've now pulled out all the disk statistics from the probe.
1223      * See if any used disks that were there from the last time are
1224      * now gone.  If so, we remove them.
1225      */
1226     if (scout_debug) {
1227         fprintf(scout_debugfd,
1228                 "[%s] Scanning used disk records for inactive entries\n", rn);
1229         fflush(scout_debugfd);
1230     }
1231     used_disk_idx = a_srvline->used_head;
1232     while (used_disk_idx != SCOUT_NIL) {
1233         if (scout_debug) {
1234             fprintf(scout_debugfd, "[%s] Examining entry at index %d\n", rn,
1235                     used_disk_idx);
1236             fflush(scout_debugfd);
1237         }
1238         sc_disk = (a_srvline->disks) + used_disk_idx;
1239         next_used_idx = sc_disk->next;
1240         if (!(sc_disk->active)) {
1241             scout_RemoveInactiveDisk(a_srvline, /*Server record */
1242                                      used_disk_idx);    /*Disk index to nuke */
1243             fix_light_locs = 1;
1244         }
1245         used_disk_idx = next_used_idx;
1246
1247     }                           /*Remove inactive used disks */
1248
1249     /*
1250      * If we've had to add or remove disks to/from the used list,
1251      * or if the frame width has changed, we recompute the light
1252      * locations before returning.
1253      */
1254     if (fix_light_locs || a_width_changed)
1255         scout_RecomputeLightLocs(a_srvline);
1256
1257     /*
1258      * Return the (possibly new) size of the current server record.
1259      */
1260     return (a_srvline->num_lines);
1261
1262 }                               /*mini_PrintDiskStats */
1263
1264 /*------------------------------------------------------------------------
1265  * FS_Handler
1266  *
1267  * Description:
1268  *      Handler routine passed to the fsprobe module.  This handler is
1269  *      called immediately after a poll of all the FileServers has taken
1270  *      place.  Its job is to write out selected data to the scout
1271  *      screen.
1272  *
1273  * Arguments:
1274  *      None.
1275  *
1276  * Returns:
1277  *      0 on success,
1278  *      -1 otherwise.
1279  *
1280  * Environment:
1281  *      All it needs to know is exported by the fsprobe module, namely
1282  *      the data structure where the probe results are stored.
1283  *
1284  * Side Effects:
1285  *      Recomputes disk light locations in response to reshaping the
1286  *      scout window or from adding/deleting disk lights to/from
1287  *      individual servers.
1288  *------------------------------------------------------------------------*/
1289
1290 int
1291 FS_Handler(void)
1292 {                               /*FS_Handler */
1293
1294     static char rn[] = "FS_Handler";    /*Routine name */
1295     int code;                   /*Return code */
1296     struct ProbeViceStatistics *curr_stats;     /*Ptr to current stats */
1297     int *curr_probeOK;          /*Ptr to current probeOK field */
1298     int curr_srvidx;            /*Current server index */
1299     char s[128];                /*String buffer */
1300     static char sblank[] = " "; /*Blank string buffer */
1301     char *sp;                   /*Ptr to string buffer */
1302     struct mini_line *curr_line;        /*Current mini-line */
1303     int curr_line_num;          /*Current line number */
1304     struct gator_lightobj *lightdata;   /*Private light data */
1305     int setting;                /*Light setting (on or off) */
1306     int old_width;              /*Keep the old width value */
1307     int width_changed;          /*Has the frame width changed? */
1308     int fix_line_num;           /*Line number needs fixing */
1309     int delta_line_num;         /*Change in line number */
1310
1311     /*
1312      * See if the size of the scout frame has changed since the last
1313      * time.
1314      */
1315     old_width = scout_frameDims.maxx;
1316     if (scout_debug) {
1317         fprintf(scout_debugfd, "[%s] Calling wop_getdimensions\n", rn);
1318         fflush(scout_debugfd);
1319     }
1320     WOP_GETDIMENSIONS(scout_frame->window, &scout_frameDims);
1321     width_changed = (old_width == scout_frameDims.maxx) ? 0 : 1;
1322     if (scout_debug) {
1323         fprintf(scout_debugfd,
1324                 "[%s] Frame dimensions are %d rows, %d columns\n", rn,
1325                 scout_frameDims.maxy, scout_frameDims.maxx);
1326         if (width_changed)
1327             fprintf(scout_debugfd, "[%s] Width has changed from %d columns\n",
1328                     rn, old_width);
1329         fflush(scout_debugfd);
1330     }
1331
1332     /*
1333      * Print out the selected fields for each server.  We actually change
1334      * the light's label to the new data.
1335      */
1336     curr_line = scout_screen.line;
1337     curr_stats = fsprobe_Results.stats;
1338     curr_probeOK = fsprobe_Results.probeOK;
1339     curr_line_num = curr_line->base_line;
1340
1341     setting = 0;
1342     for (curr_srvidx = 0; curr_srvidx < scout_screen.numServers;
1343          curr_srvidx++) {
1344         /*
1345          * If the current server record is set up on the wrong line, fix
1346          * the non-disk light objects directly, and remember to fix the
1347          * disk light objects later on.
1348          */
1349         if (curr_line->base_line != curr_line_num) {
1350             fix_line_num = 1;
1351             delta_line_num = curr_line_num - curr_line->base_line;
1352             curr_line->base_line = curr_line_num;
1353             scout_SetNonDiskLightLine(curr_line, curr_line_num);
1354         } else {
1355             fix_line_num = 0;
1356             delta_line_num = 0;
1357         }
1358
1359         lightdata =
1360             (struct gator_lightobj *)(curr_line->currConns_lp->o_data);
1361         if (*curr_probeOK == 0) {
1362             sp = s;
1363             sprintf(sp, "%d", curr_stats->CurrentConnections);
1364         } else
1365             sp = sblank;
1366         code = mini_justify(sp, /*Src buffer */
1367                             lightdata->label,   /*Dest buffer */
1368                             scout_col_width[COL_CONN],  /*Dest's width */
1369                             SCOUT_RIGHT_JUSTIFY,        /*Right-justify */
1370                             SCOUT_LEFT_TRUNC,   /*Left-truncate */
1371                             SCOUT_ISNT_LDISK);  /*Not a labeled disk */
1372         if (scout_attn_conn != SCOUT_ATTN_NOTUSED
1373             && curr_stats->CurrentConnections >= scout_attn_conn)
1374             setting = 1;
1375         else
1376             setting = 0;
1377         code = gator_light_set(curr_line->currConns_lp, setting);
1378
1379         lightdata = (struct gator_lightobj *)(curr_line->fetches_lp->o_data);
1380         if (*curr_probeOK == 0) {
1381             sp = s;
1382             sprintf(sp, "%u", curr_stats->TotalFetchs);
1383         } else
1384             sp = sblank;
1385         code = mini_justify(sp, /*Src buffer */
1386                             lightdata->label,   /*Dest buffer */
1387                             scout_col_width[COL_FETCH], /*Dest's width */
1388                             SCOUT_RIGHT_JUSTIFY,        /*Right-justify */
1389                             SCOUT_LEFT_TRUNC,   /*Left-truncate */
1390                             SCOUT_ISNT_LDISK);  /*Not a labeled disk */
1391         if (scout_attn_fetch != SCOUT_ATTN_NOTUSED
1392             && curr_stats->TotalFetchs >= scout_attn_fetch)
1393             setting = 1;
1394         else
1395             setting = 0;
1396         code = gator_light_set(curr_line->fetches_lp, setting);
1397
1398         lightdata = (struct gator_lightobj *)(curr_line->stores_lp->o_data);
1399         if (*curr_probeOK == 0) {
1400             sp = s;
1401             sprintf(sp, "%u", curr_stats->TotalStores);
1402         } else
1403             sp = sblank;
1404         code = mini_justify(sp, /*Src buffer */
1405                             lightdata->label,   /*Dest buffer */
1406                             scout_col_width[COL_STORE], /*Dest's width */
1407                             SCOUT_RIGHT_JUSTIFY,        /*Right-justify */
1408                             SCOUT_LEFT_TRUNC,   /*Left-truncate */
1409                             SCOUT_ISNT_LDISK);  /*Not a labeled disk */
1410         if (scout_attn_store != SCOUT_ATTN_NOTUSED
1411             && curr_stats->TotalStores >= scout_attn_store)
1412             setting = 1;
1413         else
1414             setting = 0;
1415         code = gator_light_set(curr_line->stores_lp, setting);
1416
1417         lightdata =
1418             (struct gator_lightobj *)(curr_line->workstations_lp->o_data);
1419         if (*curr_probeOK == 0) {
1420             sp = s;
1421             sprintf(sp, "%d", curr_stats->WorkStations);
1422         } else
1423             sp = sblank;
1424         code = mini_justify(sp, /*Src buffer */
1425                             lightdata->label,   /*Dest buffer */
1426                             scout_col_width[COL_WK],    /*Dest's width */
1427                             SCOUT_RIGHT_JUSTIFY,        /*Right-justify */
1428                             SCOUT_LEFT_TRUNC,   /*Left-truncate */
1429                             SCOUT_ISNT_LDISK);  /*Not a labeled disk */
1430         if (scout_attn_workstations != SCOUT_ATTN_NOTUSED
1431             && curr_stats->WorkStations >= scout_attn_workstations)
1432             setting = 1;
1433         else
1434             setting = 0;
1435         code = gator_light_set(curr_line->workstations_lp, setting);
1436
1437         /*
1438          * We turn the server light on if there was an error in the
1439          * current probe (e.g., if the curr_probeOK field is non-zero.
1440          * (Don't forget to fix the light's line if it needs it).
1441          */
1442         setting = (*curr_probeOK) ? 1 : 0;
1443         code = gator_light_set(curr_line->srvName_lp, setting);
1444
1445         /*
1446          * Print out the disk statistics.  The value returned is the
1447          * number of lines taken up by the server record (or 0 if
1448          * something went wrong).
1449          */
1450         code = mini_PrintDiskStats(curr_line,   /*Ptr to server line */
1451                                    curr_stats,  /*Fresh disk stats */
1452                                    *curr_probeOK,       /*Was probe OK? */
1453                                    width_changed,       /*Has the width changed? */
1454                                    fix_line_num,        /*Fix the line number? */
1455                                    delta_line_num);     /*Change in line number */
1456         if (code == 0) {
1457             fprintf(stderr, "[%s] Error in printing out disk statistics\n",
1458                     rn);
1459             return (-1);
1460         } else
1461             curr_line_num += code;
1462
1463         /*
1464          * Advance the current mini_line, stats source, and probe success
1465          * indication.
1466          */
1467         curr_line++;
1468         curr_stats++;
1469         curr_probeOK++;
1470
1471     }                           /*for each server probed */
1472
1473     /*
1474      * Display the scout frame.
1475      */
1476     sprintf(s, "Probe %d results", fsprobe_Results.probeNum);
1477     gtxframe_DisplayString(scout_frame, s);
1478     WOP_DISPLAY(scout_gwin);
1479
1480     /*
1481      * Return the happy news.
1482      */
1483     return (0);
1484
1485 }                               /*FS_Handler */
1486
1487 /*------------------------------------------------------------------------
1488  * init_mini_line
1489  *
1490  * Description:
1491  *      Initialize each line in the mini_screen.
1492  *
1493  * Arguments:
1494  *      struct sockaddr_in *a_skt : Ptr to server socket info.
1495  *      int a_lineNum;            : Line number being created.
1496  *      struct mini_line *a_line  : Ptr to mini_line to set up.
1497  *      char *a_srvname           : Printable server name.
1498  *
1499  * Returns:
1500  *      0 on success,
1501  *      Error value otherwise.
1502  *
1503  * Environment:
1504  *      Nothing interesting.
1505  *
1506  * Side Effects:
1507  *      As advertised.
1508  *------------------------------------------------------------------------*/
1509
1510 static int
1511 init_mini_line(struct sockaddr_in *a_skt, int a_lineNum,
1512                struct mini_line *a_line, char *a_srvname)
1513 {                               /*init_mini_line */
1514
1515     static char rn[] = "init_mini_line";        /*Routine name */
1516     int curr_x;                 /*Current X position */
1517     int curr_y;                 /*Current Y position */
1518     char s[128];                /*Scratch buffer */
1519     int code;                   /*Return code */
1520     struct gator_lightobj *lightdata;   /*Private light data */
1521
1522     if (scout_debug) {
1523         fprintf(scout_debugfd, "[%s] Called for base line %d\n", rn,
1524                 a_lineNum);
1525         fflush(scout_debugfd);
1526     }
1527
1528     /*
1529      * Fill in the top fields (except the disk fields, which will be
1530      * done elsewhere), then create the light onodes.
1531      */
1532     memcpy((char *)&(a_line->skt), (char *)a_skt, sizeof(struct sockaddr_in));
1533     a_line->numDisks = 0;
1534     a_line->base_line = a_lineNum + scout_screen.base_line_num;
1535     a_line->num_lines = 1;
1536
1537     curr_x = 1;
1538     curr_y = a_line->base_line;
1539     if ((a_line->currConns_lp =
1540          mini_initLightObject("Conns", curr_x, curr_y, scout_col_width[COL_CONN],
1541                               scout_gwin))
1542         == NULL) {
1543         fprintf(stderr, "[%s:%s] Can't create currConns light object\n", pn,
1544                 rn);
1545         return (-1);
1546     }
1547     curr_x += scout_col_width[COL_CONN] + 1;
1548
1549     if ((a_line->fetches_lp =
1550          mini_initLightObject("Fetches", curr_x, curr_y, scout_col_width[COL_FETCH],
1551                               scout_frame->window))
1552         == NULL) {
1553         fprintf(stderr, "[%s:%s] Can't create fetches light object\n", pn,
1554                 rn);
1555         return (-1);
1556     }
1557     curr_x += scout_col_width[COL_FETCH] + 1;
1558
1559     if ((a_line->stores_lp =
1560          mini_initLightObject("Stores", curr_x, curr_y, scout_col_width[COL_STORE],
1561                               scout_frame->window))
1562         == NULL) {
1563         fprintf(stderr, "[%s:%s] Can't create stores light object\n", pn, rn);
1564         return (-1);
1565     }
1566     curr_x += scout_col_width[COL_STORE] + 1;
1567
1568     if ((a_line->workstations_lp =
1569          mini_initLightObject("WrkStn", curr_x, curr_y, scout_col_width[COL_WK],
1570                               scout_frame->window))
1571         == NULL) {
1572         fprintf(stderr, "[%s:%s] Can't create workstations light object\n",
1573                 pn, rn);
1574         return (-1);
1575     }
1576     curr_x += scout_col_width[COL_WK] + 1;
1577
1578     if ((a_line->srvName_lp =
1579          mini_initLightObject(a_srvname, curr_x, curr_y,
1580                               scout_col_width[COL_SRVNAME], scout_frame->window))
1581         == NULL) {
1582         fprintf(stderr, "[%s:%s] Can't create server name light object\n", pn,
1583                 rn);
1584         return (-1);
1585     }
1586     sprintf(s, "%s", a_srvname);
1587     lightdata = (struct gator_lightobj *)(a_line->srvName_lp->o_data);
1588     code = mini_justify(s,      /*Src buffer */
1589                         lightdata->label,       /*Dest buffer */
1590                         scout_col_width[COL_SRVNAME],   /*Dest's width */
1591                         SCOUT_CENTER,   /*Centered */
1592                         SCOUT_RIGHT_TRUNC,      /*Right-truncate */
1593                         SCOUT_ISNT_LDISK);      /*Not a labeled disk */
1594     if (code) {
1595         fprintf(stderr,
1596                 "[%s] Can't center server name inside of light object\n", rn);
1597         return (code);
1598     }
1599     curr_x += scout_col_width[COL_SRVNAME] + 1;
1600
1601     if (scout_initDiskLightObjects(a_line, scout_frame->window)) {
1602         fprintf(stderr, "[%s:%s] Can't create disk light objects\n", pn, rn);
1603         return (-1);
1604     }
1605
1606     /*
1607      * Finally, return the happy news.
1608      */
1609     return (0);
1610
1611 }                               /*init_mini_line */
1612
1613 /*------------------------------------------------------------------------
1614  * execute_scout
1615  *
1616  * Description:
1617  *      Workhorse routine that starts up the FileServer probe.
1618  *
1619  * Arguments:
1620  *      int a_numservers                : Length of above list.
1621  *      struct cmd_item *a_srvname      : List of FileServer machines to
1622  *                                        monitor.
1623  *      int a_pkg                       : Window package to use.
1624  *
1625  * Returns:
1626  *      0 on success,
1627  *      Error value otherwise.
1628  *
1629  * Environment:
1630  *      Nothing interesting.
1631  *
1632  * Side Effects:
1633  *      As advertised.
1634  *------------------------------------------------------------------------*/
1635
1636 static int
1637 execute_scout(int a_numservers, struct cmd_item *a_srvname, int a_pkg)
1638 {                               /*execute_scout */
1639
1640     static char rn[] = "execute_scout"; /*Routine name */
1641     static char fullsrvname[128];       /*Full server name */
1642     int code;           /*Return code */
1643     struct sockaddr_in *FSSktArray;     /*Server socket array */
1644     int sktbytes;               /*Num bytes in above */
1645     struct sockaddr_in *curr_skt;       /*Ptr to current socket */
1646     struct cmd_item *curr_item; /*Ptr to current cmd item */
1647     struct hostent *he;         /*Host entry */
1648     struct mini_line *mini_lines;       /*Ptr to all mini-lines */
1649     struct mini_line *curr_line;        /*Ptr to current line */
1650     int i;                      /*Generic loop variable */
1651     int mini_line_bytes;        /*Num bytes in mini_lines */
1652     struct timeval tv;          /*Time structure */
1653     int linenum;                /*Current mini-line number */
1654 #if 0
1655     PROCESS pid;                /*Main LWP process ID */
1656     PROCESS gxlistener_ID;      /*Input Server LWP process ID */
1657 #endif /* 0 */
1658     struct gator_lightobj *lightdata;   /*Private light data */
1659
1660     if (scout_debug) {
1661         fprintf(scout_debugfd, "[%s] Called\n", rn);
1662         fflush(scout_debugfd);
1663     }
1664
1665     /*
1666      * We have to initialize LWP support before we start up any of
1667      * our packages.
1668      */
1669 #if 0
1670     code = LWP_InitializeProcessSupport(LWP_NORMAL_PRIORITY, &pid);
1671     if (code) {
1672         fprintf(stderr, "[%s:%s] Can't initialize LWP\n", pn, rn);
1673         scout_CleanExit(code);
1674     }
1675 #endif /* 0 */
1676
1677     /*
1678      * Initialize the gtx package.
1679      */
1680 #if 0
1681     fprintf(stderr, "[%s:%s] Starting up gtx package\n", pn, rn);
1682 #endif /* 0 */
1683     scout_gwin = gtx_Init(0,    /*Don't start up InputServer yet */
1684                           -1);  /*Type of window package */
1685     if (scout_gwin == NULL) {
1686         fprintf(stderr, "[%s:%s] Call to gtx_Init() failed!\n", pn, rn);
1687         return (-1);
1688     }
1689
1690     /*
1691      * Remember we've set up gtx so we can exit cleanly from now on.
1692      */
1693     scout_gtx_initialized = 1;
1694
1695     /*
1696      * Create the frame everything will go into, set it up as our only
1697      * frame for this window.
1698      */
1699     scout_frame = gtxframe_Create();
1700     if (scout_frame == (struct gtx_frame *)0) {
1701         fprintf(stderr, "[%s:%s] Call to gtxframe_Create() failed!\n", pn,
1702                 rn);
1703         return (-1);
1704     }
1705     gtxframe_SetFrame(scout_gwin, scout_frame);
1706     WOP_GETDIMENSIONS(scout_frame->window, &scout_frameDims);
1707
1708     /*
1709      * Allocate an array of sockets to describe each FileServer we'll be
1710      * watching.
1711      */
1712     sktbytes = a_numservers * sizeof(struct sockaddr_in);
1713     FSSktArray = (struct sockaddr_in *)malloc(sktbytes);
1714     if (FSSktArray == (struct sockaddr_in *)0) {
1715         fprintf(stderr,
1716                 "[%s] Can't malloc() %d sockaddrs (%d bytes) for the given servers\n",
1717                 rn, a_numservers, sktbytes);
1718         scout_CleanExit(-1);
1719     }
1720     memset(FSSktArray, 0, sktbytes);
1721
1722     /*
1723      * Sweep through the server names provided, filling in the socket
1724      * info for each.  Take into account the fact that we may have a
1725      * base name associated for each.
1726      */
1727     curr_item = a_srvname;
1728     curr_skt = FSSktArray;
1729     while (curr_item) {
1730         if (*scout_basename == '\0')
1731             sprintf(fullsrvname, "%s", curr_item->data);
1732         else
1733             sprintf(fullsrvname, "%s.%s", curr_item->data, scout_basename);
1734         he = hostutil_GetHostByName(fullsrvname);
1735         if (he == NULL) {
1736             fprintf(stderr, "[%s] Can't get host info for '%s'\n", rn,
1737                     fullsrvname);
1738             return (-1);
1739         }
1740         memcpy(&(curr_skt->sin_addr.s_addr), he->h_addr, 4);
1741         curr_skt->sin_family = AF_INET;
1742         curr_skt->sin_port = htons(7000);       /* FileServer port */
1743
1744         /*
1745          * Bump our pointers.
1746          */
1747         curr_item = curr_item->next;
1748         curr_skt++;
1749
1750     }                           /*Build socket entry for each server */
1751
1752     /*
1753      * Create the set of mini-lines, one per server.
1754      */
1755     mini_line_bytes = a_numservers * sizeof(struct mini_line);
1756     mini_lines = (struct mini_line *)malloc(mini_line_bytes);
1757     if (mini_lines == (struct mini_line *)0) {
1758         fprintf(stderr, "[%s] Can't malloc() %d bytes for %d screen lines\n",
1759                 rn, mini_line_bytes, a_numservers);
1760         return (-1);
1761     }
1762     memset(mini_lines, 0, mini_line_bytes);
1763
1764     /*
1765      * Set up each line in the mini_lines, creating and initializing
1766      * its light objects.
1767      */
1768     scout_screen.base_line_num = 4;
1769     curr_line = mini_lines;
1770     curr_skt = FSSktArray;
1771     linenum = 0;
1772     curr_item = a_srvname;
1773     gtxframe_ClearList(scout_frame);
1774
1775     /*
1776      * Create the light objects that server as banner lines.  Remember
1777      * to take into account the server basename, if any, and the name
1778      * of the host that scout if running on, if that's wanted.
1779      */
1780     if (scout_showhostname) {
1781         if (*scout_basename == '\0')
1782             sprintf(scout_Banner, "[%s] %s", scout_hostname, "Scout");
1783         else
1784             sprintf(scout_Banner, "[%s] Scout for %s", scout_hostname,
1785                     scout_basename);
1786     } else {
1787         if (*scout_basename == '\0')
1788             sprintf(scout_Banner, "%s", " Scout");
1789         else
1790             sprintf(scout_Banner, " Scout for %s", scout_basename);
1791     }
1792     scout_banner0_lp = mini_initLightObject("Banner 0", /*Light name */
1793                                             0, /*X*/ 0, /*Y*/ scout_frameDims.maxx,     /*Width */
1794                                             scout_gwin);        /*Window */
1795     if (scout_banner0_lp != NULL) {
1796         lightdata = (struct gator_lightobj *)(scout_banner0_lp->o_data);
1797         code =
1798             mini_justify(scout_Banner, lightdata->label, scout_frameDims.maxx,
1799                          SCOUT_CENTER, SCOUT_RIGHT_TRUNC, SCOUT_ISNT_LDISK);
1800         code = gator_light_set(scout_banner0_lp, 1);
1801         code = gtxframe_AddToList(scout_frame, scout_banner0_lp);
1802
1803         /*Debugging */
1804         if (scout_debug)
1805             fprintf(scout_debugfd, "[%s] Scout label is '%s', %" AFS_SIZET_FMT " chars\n", rn,
1806                     lightdata->label, strlen(lightdata->label));
1807     }
1808
1809     scout_banner1_lp = mini_initLightObject("Banner 1", /*Light name */
1810                                             0, /*X*/ 2, /*Y*/ scout_frameDims.maxx,     /*Width */
1811                                             scout_gwin);        /*Window */
1812     if (scout_banner1_lp != NULL) {
1813         char attn_label[256];
1814         if (scout_attn_disk_mode == SCOUT_DISKM_PCUSED) {
1815             snprintf(attn_label, sizeof(attn_label), "%s: > %s%% used",
1816                      scout_label[5], scout_attn_disk_pcusedstr);
1817         } else {
1818             snprintf(attn_label, sizeof(attn_label), "%s: < %d blocks free",
1819                      scout_label[5], scout_attn_disk_minfree);
1820         }
1821         snprintf(scout_Banner, sizeof(scout_Banner),
1822                  "%*s %*s %*s %*s %*s %s",
1823                  scout_col_width[0], scout_label[0],
1824                  scout_col_width[1], scout_label[1],
1825                  scout_col_width[2], scout_label[2],
1826                  scout_col_width[3], scout_label[3],
1827                  scout_col_width[4], scout_label[4],
1828                  attn_label);
1829
1830         lightdata = (struct gator_lightobj *)(scout_banner1_lp->o_data);
1831         code =
1832             mini_justify(scout_Banner, lightdata->label, scout_frameDims.maxx,
1833                          SCOUT_LEFT_JUSTIFY, SCOUT_RIGHT_TRUNC,
1834                          SCOUT_ISNT_LDISK);
1835
1836         code = gtxframe_AddToList(scout_frame, scout_banner1_lp);
1837     }
1838
1839     scout_banner2_lp = mini_initLightObject("Banner 2", /*Light name */
1840                                             0, /*X*/ 3, /*Y*/ scout_frameDims.maxx,     /*Width */
1841                                             scout_gwin);        /*Window */
1842     if (scout_banner2_lp != NULL) {
1843         snprintf(scout_Banner, sizeof(scout_Banner),
1844                  "%*s %*s %*s %*s %*s %s",
1845                  scout_col_width[0], scout_underline[0],
1846                  scout_col_width[1], scout_underline[1],
1847                  scout_col_width[2], scout_underline[2],
1848                  scout_col_width[3], scout_underline[3],
1849                  scout_col_width[4], scout_underline[4],
1850                  scout_underline[5]);
1851
1852         lightdata = (struct gator_lightobj *)(scout_banner2_lp->o_data);
1853         code =
1854             mini_justify(scout_Banner, lightdata->label,
1855                          scout_frameDims.maxx, SCOUT_LEFT_JUSTIFY,
1856                          SCOUT_RIGHT_TRUNC, SCOUT_ISNT_LDISK);
1857         code = gtxframe_AddToList(scout_frame, scout_banner2_lp);
1858     }
1859
1860     for (i = 0; i < a_numservers; i++) {
1861         code = init_mini_line(curr_skt, linenum, curr_line, curr_item->data);
1862         if (code) {
1863             fprintf(stderr, "[%s] Can't initialize line for server %d\n", rn,
1864                     i);
1865             return (-1);
1866         }
1867         curr_skt++;
1868         curr_line++;
1869         linenum++;
1870         curr_item = curr_item->next;
1871     }
1872
1873     /*
1874      * Now that all lines have been set up, we feed in the light items
1875      * created.  Note: the disk lights are entered at a later time,
1876      * as they enter the used disk list for each server.
1877      */
1878     curr_line = mini_lines;
1879     for (i = 0; i < a_numservers; i++) {
1880         code = gtxframe_AddToList(scout_frame, curr_line->currConns_lp);
1881         if (code) {
1882             fprintf(stderr,
1883                     "[%s] Can't add client connections light to display list\n",
1884                     rn);
1885             return (code);
1886         }
1887
1888         code = gtxframe_AddToList(scout_frame, curr_line->fetches_lp);
1889         if (code) {
1890             fprintf(stderr,
1891                     "[%s] Can't add fetches light to frame display list\n",
1892                     rn);
1893             return (code);
1894         }
1895
1896         code = gtxframe_AddToList(scout_frame, curr_line->stores_lp);
1897         if (code) {
1898             fprintf(stderr,
1899                     "[%s] Can't add stores light to frame display list\n",
1900                     rn);
1901             return (code);
1902         }
1903
1904         code = gtxframe_AddToList(scout_frame, curr_line->workstations_lp);
1905         if (code) {
1906             fprintf(stderr,
1907                     "[%s] Can't add workstation light to display list\n", rn);
1908             return (code);
1909         }
1910
1911         code = gtxframe_AddToList(scout_frame, curr_line->srvName_lp);
1912         if (code) {
1913             fprintf(stderr,
1914                     "[%s] Can't add server name light to display list\n", rn);
1915             return (code);
1916         }
1917
1918         /*
1919          * Move down to the next server record.
1920          */
1921         curr_line++;
1922
1923     }                           /*Add lights in server records to display list */
1924
1925 #if 0
1926     /*
1927      * Set up the minimal keymap.
1928      */
1929     code = keymap_BindToString(scout_frame->keymap,     /*Ptr to keymap */
1930                                "e",     /*Key to bind */
1931                                ExitCmd, /*Cmd to execute */
1932                                NULL,    /*Name */
1933                                NULL);   /*Ptr to rock */
1934     if (code) {
1935         fprintf(stderr, "[%s] Can't bind key `e', code is %d\n", rn, code);
1936         return (code);
1937     }
1938 #endif /* 0 */
1939
1940     /*
1941      * Finish setting up the overall mini_screen structure.
1942      */
1943     scout_screen.numServers = a_numservers;
1944     scout_screen.line = mini_lines;
1945     WOP_GETDIMENSIONS(scout_frame->window, &scout_frameDims);
1946
1947     /*
1948      * Start up the fsprobe package, which will gather FileServer
1949      * statistics for us on a regular basis.
1950      */
1951     gtxframe_DisplayString(scout_frame,
1952                            "Establishing File Server connection(s)...");
1953     code = fsprobe_Init(a_numservers,   /*Num FileServers to probe */
1954                         FSSktArray,     /*FileServer socket array */
1955                         scout_probefreq,        /*Probe frequency */
1956                         FS_Handler,     /*Handler routine */
1957                         0);     /*Turn debugging output off */
1958 #if 0
1959     scout_debug);               /*Turn debugging output off */
1960 #endif /* 0 */
1961     if (code) {
1962         fprintf(stderr, "[%s] Error returned by fsprobe_Init: %d\n", rn,
1963                 code);
1964         return (-1);
1965     }
1966
1967
1968     /*
1969      * Start up the input server LWP for our window.
1970      */
1971 #if 0
1972     code = LWP_CreateProcess(gtx_InputServer,   /*Fcn to start up */
1973                              8192,      /*Stack size in bytes */
1974                              LWP_NORMAL_PRIORITY,       /*Priority */
1975                              (void *)scout_gwin,        /*Params: Ptr to window */
1976                              "gx-listener",     /*Name to use */
1977                              &gxlistener_ID);   /*Returned LWP process ID */
1978 #endif /* 0 */
1979
1980     code = (int)(intptr_t)gtx_InputServer(scout_gwin);
1981     if (code) {
1982         fprintf(stderr,
1983                 "[%s] Error exit from gtx_InputServer(), error is %d\n", rn,
1984                 code);
1985         scout_CleanExit(code);
1986     }
1987
1988     /*
1989      * We fall into a loop, sleeping forever.
1990      */
1991     while (1) {
1992         tv.tv_sec = 60 * 60;    /*Sleep for an hour at a time */
1993         tv.tv_usec = 0;
1994         code = select(0,        /*Num fds */
1995                       0,        /*Descriptors ready for reading */
1996                       0,        /*Descriptors ready for writing */
1997                       0,        /*Descriptors with exceptional conditions */
1998                       &tv);     /*Timeout structure */
1999     }                           /*Sleep forever */
2000
2001 #if 0
2002     /*
2003      * How did we get here?  Oh, well, clean up our windows and
2004      * return sweetness and light anyway.
2005      */
2006     WOP_CLEANUP(&scout_gwin);
2007     return (0);
2008 #endif /* 0 */
2009
2010 }                               /*execute_scout */
2011
2012 /*------------------------------------------------------------------------
2013  * countServers
2014  *
2015  * Description:
2016  *      Given a pointer to the list of servers we'll be polling,
2017  *      compute the length of the list.
2018  *
2019  * Arguments:
2020  *      struct cmd_item *a_firstItem : Ptr to first item in list.
2021  *
2022  * Returns:
2023  *      Length of the above list.
2024  *
2025  * Environment:
2026  *      Nothing interesting.
2027  *
2028  * Side Effects:
2029  *      As advertised.
2030  *------------------------------------------------------------------------*/
2031
2032 static int countServers(struct cmd_item *a_firstItem)
2033 {                               /*countServers */
2034
2035     int list_len;               /*List length */
2036     struct cmd_item *curr_item; /*Ptr to current item */
2037
2038     list_len = 0;
2039     curr_item = a_firstItem;
2040
2041     /*
2042      * Count 'em up.
2043      */
2044     while (curr_item) {
2045         list_len++;
2046         curr_item = curr_item->next;
2047     }
2048
2049     /*
2050      * Return our tally.
2051      */
2052     return (list_len);
2053
2054 }                               /*countServers */
2055
2056 /*------------------------------------------------------------------------
2057  * scout_AdoptThresholds
2058  *
2059  * Description:
2060  *      Parse and adopt one or more threshold values, as read off the
2061  *      command line.
2062  *
2063  * Arguments:
2064  *      struct cmd_item *a_thresh_item : Ptr to item on command-line
2065  *                                       threshold list.
2066  *
2067  * Returns:
2068  *      Nothing (but may exit the entire program on error!)
2069  *
2070  * Environment:
2071  *      Valid keywords are:
2072  *          conn, disk, fetch, store, ws
2073  *      The disk value, if it has a % sign, signifies that attention
2074  *      will be triggered when the disk is more than that percentage
2075  *      full; otherwise, it will specify the minimum number of free
2076  *      blocks.
2077  *
2078  * Side Effects:
2079  *      As specified.
2080  *------------------------------------------------------------------------*/
2081
2082 static void scout_AdoptThresholds(struct cmd_item *a_thresh_item)
2083 {                               /*scout_AdoptThresholds */
2084
2085     static char rn[] = "scout_AdoptThresholds"; /*Routine name */
2086     struct cmd_item *curr_item; /*Current item */
2087     char *curr_name;            /*Current name half of pair */
2088     char *curr_value;           /*Current value half of pair */
2089     int diskval_len;            /*Length of disk attn value */
2090
2091     curr_item = a_thresh_item;
2092     while (curr_item) {
2093         /*
2094          * If there isn't a corresponding value for the current
2095          * attention field, bitch & die.
2096          */
2097         if (curr_item->next == (struct cmd_item *)0) {
2098             printf("[%s] No threshold value given for '%s'\n", rn,
2099                    curr_item->data);
2100             scout_CleanExit(-1);
2101         }
2102
2103         curr_name = curr_item->data;
2104         curr_value = curr_item->next->data;
2105
2106         if (strcmp(curr_name, "conn") == 0) {
2107             if (scout_debug) {
2108                 fprintf(scout_debugfd,
2109                         "[%s] Setting conn attn value to %d (default %d)\n",
2110                         rn, atoi(curr_value), scout_attn_conn);
2111                 fflush(scout_debugfd);
2112             }
2113             scout_attn_conn = atoi(curr_value);
2114         } else if (strcmp(curr_name, "disk") == 0) {
2115             /*
2116              * If there's a '%' as the last character in the value,
2117              * we use percentage mode.
2118              */
2119             diskval_len = strlen(curr_value);
2120             if (curr_value[diskval_len - 1] == '%') {
2121                 curr_value[diskval_len - 1] = '\0';
2122                 if (scout_debug) {
2123                     fprintf(scout_debugfd,
2124                             "[%s] New disk attn value: 0.%s used (default %f)\n",
2125                             rn, curr_value, scout_attn_disk_pcused);
2126                     fflush(scout_debugfd);
2127                 }
2128                 sprintf(scout_attn_disk_pcusedstr, "%s", curr_value);
2129                 scout_attn_disk_pcused =
2130                     ((float)(atoi(curr_value))) / ((float)(100));
2131             } /*Percentage mode */
2132             else {
2133                 if (scout_debug) {
2134                     fprintf(scout_debugfd,
2135                             "[%s] New disk attn value: %s min free (default %f)\n",
2136                             rn, curr_value, scout_attn_disk_pcused);
2137                     fflush(scout_debugfd);
2138                 }
2139                 scout_attn_disk_mode = SCOUT_DISKM_MINFREE;
2140                 scout_attn_disk_minfree = atoi(curr_value);
2141             }                   /*Min free blocks mode */
2142         } else if (strcmp(curr_name, "fetch") == 0) {
2143             if (scout_debug) {
2144                 fprintf(scout_debugfd,
2145                         "[%s] Setting fetch attn value to %d (default %d)\n",
2146                         rn, atoi(curr_value), scout_attn_fetch);
2147                 fflush(scout_debugfd);
2148             }
2149             scout_attn_fetch = atoi(curr_value);
2150         } else if (strcmp(curr_name, "store") == 0) {
2151             if (scout_debug) {
2152                 fprintf(scout_debugfd,
2153                         "[%s] Setting store attn value to %d (default %d)\n",
2154                         rn, atoi(curr_value), scout_attn_store);
2155                 fflush(scout_debugfd);
2156             }
2157             scout_attn_store = atoi(curr_value);
2158         } else if (strcmp(curr_name, "ws") == 0) {
2159             if (scout_debug) {
2160                 fprintf(scout_debugfd,
2161                         "[%s] Setting workstation attn value to %d (default %d)\n",
2162                         rn, atoi(curr_value), scout_attn_workstations);
2163                 fflush(scout_debugfd);
2164             }
2165             scout_attn_workstations = atoi(curr_value);
2166         } else {
2167             printf("[%s] Unknown attention item: '%s'\n", rn,
2168                    curr_item->data);
2169             scout_CleanExit(-1);
2170         }
2171
2172         /*
2173          * Advance past the just-processed pair.
2174          */
2175         curr_item = curr_item->next->next;
2176
2177     }                           /*Interpret each name-value pair */
2178
2179 }                               /*scout_AdoptThresholds */
2180
2181 /**
2182  * Setup the user specified column widths.
2183  *
2184  * The column widths specifies the number of digits which
2185  * will be displayed without truncation.  The column widths
2186  * are given in the same order in which they are displayed,
2187  * from left to right. Not all columns need to be specified
2188  * on the command line. The default column widths for those
2189  * columns not specified. Column widths can not be set smaller
2190  * than the heading underline.
2191  *
2192  * @param[in] a_width_item      command line width item list
2193  */
2194 void
2195 scout_SetColumnWidths(struct cmd_item *a_width_item)
2196 {
2197     int i;
2198     int width;
2199     int num_cols = sizeof(scout_col_width) / sizeof(*scout_col_width);
2200
2201     for (i = 0; a_width_item && i < num_cols; i++) {
2202         width = atoi(a_width_item->data);
2203         if (width > 0) {
2204             int min_width = strlen(scout_underline[i]);
2205             if (min_width) {
2206                width = max(width, min_width);
2207             }
2208             scout_col_width[i] = width + 1;
2209         }
2210         a_width_item = a_width_item->next;
2211     }
2212     if (a_width_item) {
2213         fprintf(stderr, "Too many values given for -columnwidths\n");
2214         scout_CleanExit(1);
2215     }
2216 }
2217
2218 /*------------------------------------------------------------------------
2219  * scoutInit
2220  *
2221  * Description:
2222  *      Routine called when Scout is invoked, responsible for basic
2223  *      initialization, command line parsing, and calling the
2224  *      routine that does all the work.
2225  *
2226  * Arguments:
2227  *      as      : Command syntax descriptor.
2228  *      arock   : Associated rock (not used here).
2229  *
2230  * Returns:
2231  *      Zero (but may exit the entire program on error!)
2232  *
2233  * Environment:
2234  *      Nothing interesting.
2235  *
2236  * Side Effects:
2237  *      Initializes this program.
2238  *------------------------------------------------------------------------*/
2239
2240 static int scoutInit(struct cmd_syndesc *as, void *arock)
2241 {                               /*scoutInit */
2242
2243     static char rn[] = "scoutInit";     /*Routine name */
2244     int code;                   /*Return code */
2245     int wpkg_to_use;            /*Window package to use */
2246     int server_count;           /*Number of servers to watch */
2247     char *debug_filename;       /*Name of debugging output file */
2248
2249     if (scout_debug) {
2250         fprintf(scout_debugfd, "[%s] Called\n", rn);
2251         fflush(scout_debugfd);
2252     }
2253
2254     if (as->parms[P_DEBUG].items != 0) {
2255         scout_debug = 1;
2256         debug_filename = as->parms[P_DEBUG].items->data;
2257         scout_debugfd = fopen(debug_filename, "w");
2258         if (scout_debugfd == (FILE *) 0) {
2259             printf("[%s] Can't open debugging file '%s'!\n", rn,
2260                    debug_filename);
2261             scout_CleanExit(-1);
2262         }
2263         fprintf(scout_debugfd, "[%s] Writing to Scout debugging file '%s'\n",
2264                 rn, debug_filename);
2265     }
2266 #if 0
2267     wpkg_to_use = atoi(as->parms[P_PACKAGE].items->data);
2268 #endif /* 0 */
2269     wpkg_to_use = 2;            /*Always use curses for now */
2270 #if 0
2271     fprintf(stderr, "[%s:%s] Using graphics package %d: ", pn, rn,
2272             wpkg_to_use);
2273     switch (wpkg_to_use) {
2274     case GATOR_WIN_CURSES:
2275         fprintf(stderr, "curses\n");
2276         break;
2277     case GATOR_WIN_DUMB:
2278         fprintf(stderr, "dumb terminal\n");
2279         break;
2280     case GATOR_WIN_X11:
2281         fprintf(stderr, "X11\n");
2282         break;
2283     default:
2284         fprintf(stderr, "Illegal graphics package: %d\n", wpkg_to_use);
2285         scout_CleanExit(-1);
2286     }                           /*end switch (wpkg_to_use) */
2287 #endif /* 0 */
2288
2289     if (as->parms[P_FREQ].items != 0)
2290         scout_probefreq = atoi(as->parms[P_FREQ].items->data);
2291     else
2292         scout_probefreq = 60;
2293
2294     /*
2295      * See if we've been fed a base server name.
2296      */
2297     if (as->parms[P_BASE].items != 0)
2298         sprintf(scout_basename, "%s", as->parms[P_BASE].items->data);
2299     else
2300         *scout_basename = '\0';
2301
2302     /*
2303      * Count the number of servers we've been asked to monitor.
2304      */
2305     server_count = countServers(as->parms[P_SERVER].items);
2306
2307     /*
2308      * Create a line of blanks, a generally-useful thing.
2309      */
2310     sprintf(scout_blankline, "%255s", " ");
2311
2312     /*
2313      * Pull in the name of the host we're executing on if we've been
2314      * asked to.  If we can't get the name, we provide a default.
2315      */
2316     if (as->parms[P_HOST].items != 0) {
2317         scout_showhostname = 1;
2318         *scout_hostname = '\0';
2319         code = gethostname(scout_hostname, 128);
2320         if (code)
2321             sprintf(scout_hostname, "%s", "*No Hostname*");
2322     }
2323
2324     /*
2325      * Pull in any and all attention/highlighting thresholds.
2326      */
2327     if (as->parms[P_ATTENTION].items != 0)
2328         scout_AdoptThresholds(as->parms[P_ATTENTION].items);
2329
2330     if (as->parms[P_WIDTHS].items != 0) {
2331         scout_SetColumnWidths(as->parms[P_WIDTHS].items);
2332     }
2333
2334     /*
2335      * Now, drive the sucker.
2336      */
2337     code = execute_scout(server_count,  /*Num servers */
2338                          as->parms[P_SERVER].items,     /*Ptr to srv names */
2339                          wpkg_to_use);  /*Graphics pkg */
2340     if (code) {
2341         fprintf(stderr, "[%s] Error executing scout: %d\n", rn, code);
2342         scout_CleanExit(-1);
2343     }
2344
2345     /*
2346      * We initialized (and ran) correctly, so return the good news.
2347      */
2348     return (0);
2349
2350 }                               /*scoutInit */
2351
2352 #include "AFS_component_version_number.c"
2353
2354 int
2355 main(int argc, char **argv)
2356 {                               /*main */
2357
2358     afs_int32 code;     /*Return code */
2359     struct cmd_syndesc *ts;     /*Ptr to cmd line syntax descriptor */
2360
2361 #ifdef  AFS_AIX32_ENV
2362     /*
2363      * The following signal action for AIX is necessary so that in case of a
2364      * crash (i.e. core is generated) we can include the user's data section
2365      * in the core dump. Unfortunately, by default, only a partial core is
2366      * generated which, in many cases, isn't too useful.
2367      */
2368     struct sigaction nsa;
2369
2370     sigemptyset(&nsa.sa_mask);
2371     nsa.sa_handler = SIG_DFL;
2372     nsa.sa_flags = SA_FULLDUMP;
2373     sigaction(SIGSEGV, &nsa, NULL);
2374 #endif
2375     /*
2376      * Set up the commands we understand.
2377      */
2378     ts = cmd_CreateSyntax("initcmd", scoutInit, NULL, "initialize the program");
2379     cmd_AddParm(ts, "-server", CMD_LIST, CMD_REQUIRED,
2380                 "FileServer name(s) to monitor");
2381     cmd_AddParm(ts, "-basename", CMD_SINGLE, CMD_OPTIONAL,
2382                 "base server name");
2383 #if 0
2384     cmd_AddParm(ts, "-package", CMD_SINGLE, CMD_REQUIRED,
2385                 "Graphics package to use");
2386 #endif /* 0 */
2387     cmd_AddParm(ts, "-frequency", CMD_SINGLE, CMD_OPTIONAL,
2388                 "poll frequency, in seconds");
2389     cmd_AddParm(ts, "-host", CMD_FLAG, CMD_OPTIONAL,
2390                 "show name of host you're running on");
2391     cmd_AddParm(ts, "-attention", CMD_LIST, CMD_OPTIONAL,
2392                 "specify attention (highlighting) level");
2393     cmd_AddParm(ts, "-debug", CMD_SINGLE, CMD_OPTIONAL,
2394                 "turn debugging output on to the named file");
2395     cmd_AddParm(ts, "-columnwidths", CMD_LIST, CMD_OPTIONAL,
2396                 "specify column widths");
2397
2398     /*
2399      * Parse command-line switches & execute the test, then get the heck
2400      * out of here.
2401      */
2402     code = cmd_Dispatch(argc, argv);
2403     if (code) {
2404 #if 0
2405         fprintf(stderr, "[%s:%s] Call to cmd_Dispatch() failed; code is %d\n",
2406                 pn, rn, code);
2407 #endif /* 0 */
2408         scout_CleanExit(1);
2409     } else
2410         scout_CleanExit(0);
2411
2412     return 0; /* not reachable */
2413 }                               /*main */