FACT++  1.0
did.c
Go to the documentation of this file.
1 #include <stdio.h>
2 #include <ctype.h>
3 #include <time.h>
4 #include <dim.h>
5 #include <dic.h>
6 #include <dis.h>
7 #include "did.h"
8 
9 int First_time = 1;
10 int Curr_view_opt = -1;
11 char Curr_view_opt_par[80];
12 char Curr_service_name[132];
13 char Curr_service_format[256];
14 int Curr_service_print_type = 0;
15 int N_servers = 0;
16 int N_services = 0;
17 int no_link_int = -1;
18 FILE *fptr;
19 
20 char *Service_content_str;
21 char *Service_buffer;
22 int Service_size;
23 char *Curr_service_list = 0;
24 char *Curr_client_list = 0;
25 int Curr_service_id = 0;
26 Widget Curr_client_id;
27 Widget Curr_service_list_id;
28 SERVER *Got_Service_List = 0;
29 SERVER *Got_Client_List = 0;
30 
31 Widget SubscribeButton;
32 Widget Subscribe10Button;
33 
34 int Timer_q;
35 
36 int Force_update = 0;
37 /*
38  * Global data
39  */
40 static XmFontList did_default_font, did_small_font,
41  did_label_font, did_server_font;
42 
43 /*static MrmType class_id;*/ /* Place to keep class ID*/
44 /*static MrmType *dummy_class;*/ /* and class variable. */
45 
46 /*static char *db_filename_vec[1];*/ /* Mrm.hierachy file list. */
47 /*static int db_filename_num;*/
48 
49 /*
50  * Forward declarations
51  */
52 void did_exit();
53 void create_main();
54 void create_label();
55 void create_matrix();
56 void view_opts();
57 void dns_control();
58 void ok_pop_up();
59 void cancel_pop_up();
60 
61 extern void set_something();
62 extern void get_something();
63 extern void set_color();
64 
65 /*
66  * Names and addresses of callback routines to register with Mrm
67  */
68 /*
69 static MrmRegisterArg reglist [] = {
70 {"did_exit", (caddr_t)did_exit},
71 {"create_main", (caddr_t)create_main},
72 {"create_label", (caddr_t)create_label},
73 {"create_matrix", (caddr_t)create_matrix},
74 {"view_opts", (caddr_t)view_opts},
75 {"dns_control", (caddr_t)dns_control},
76 {"ok_pop_up", (caddr_t)ok_pop_up},
77 {"cancel_pop_up", (caddr_t)cancel_pop_up},
78 };
79 
80 static int reglist_num = (sizeof reglist / sizeof reglist[0]);
81 */
82 /*
83  * OS transfer point. The main routine does all the one-time setup and
84  * then calls XtAppMainLoop.
85  */
86 
87 SERVER *Curr_servp;
88 
89 XmFontList util_get_font( char *fontname, Widget top )
90 {
91 XFontStruct * mf;
92 XmFontList font;
93 /*
94 char * fontname;
95 
96  if ( size == 'm' ) {
97  fontname = MENU_FONT;
98  }
99  else if ( size == 'b' ) {
100  fontname = LABEL_FONT;
101  }
102  else {
103  fontname = DEFAULT_FONT;
104  }
105 */
106  if ( (mf = XLoadQueryFont(XtDisplay(top),fontname))==NULL) {
107  printf("Couldn't open the following fonts:\n\t%s\n",
108  fontname);
109  XtVaGetValues ( top, XmNdefaultFontList, &font, NULL );
110  }
111  else {
112  font = XmFontListCreate (mf, XmSTRING_DEFAULT_CHARSET);
113  }
114  return font;
115 }
116 
117 void create_matrix_widget()
118 {
119 Widget row_col_id, top_id;
120 Arg arglist[10];
121 int n = 0;
122 char w_name[MAX_NAME];
123 
124  top_id = Window_id;
125  XtSetArg(arglist[n], XmNborderWidth, 0); n++;
126  XtSetArg(arglist[n], XmNorientation, XmVERTICAL); n++;
127  XtSetArg(arglist[n], XmNnumColumns, 4); n++;
128  XtSetArg(arglist[n], XmNpacking, XmPACK_COLUMN); n++;
129  XtSetArg(arglist[n], XmNadjustLast, False); n++;
130  sprintf(w_name,"matrix_row");
131  row_col_id = XmCreateRowColumn(top_id,w_name,arglist,(Cardinal)n);
132  XtManageChild(row_col_id);
133  Matrix_id[Curr_matrix] = row_col_id;
134  /*
135  XmScrolledWindowSetAreas(Window_id,NULL, NULL, Matrix_id);
136  */
137 }
138 
139 void gui_create_main_window(Widget parent)
140 {
141 
142 Widget mw;
143 Widget mb;
144 Widget mf;
145 Widget tl;
146 Widget sl;
147 Widget f;
148 XmString xms;
149 int par;
150 int reason;
151 Arg ar[20];
152 int n;
153 
154  mw = XmCreateMainWindow ( parent, "DidMainWindow", NULL, 0 );
155  XtVaSetValues( mw,
156  XmNresizePolicy, XmRESIZE_ANY,
157 
158  XmNfontList, did_default_font,
159  NULL);
160  XtManageChild( mw );
161  /* create menu bar */
162  mb = XmCreateMenuBar ( mw, "DidMenuBar", NULL, 0 );
163  XtVaSetValues( mb,
164  XmNmarginHeight,2,
165  XmNborderWidth, 0,
166  XmNfontList, did_default_font,
167  NULL);
168 
169  gui_create_main_menu( mb );
170  XtManageChild ( mb );
171 
172  /* create main form */
173  mf = XmCreateForm ( mw, "DidMainForm", NULL, 0 );
174  XtVaSetValues ( mf,
175  XmNresizePolicy, XmRESIZE_NONE,
176 
177  NULL );
178  XtManageChild ( mf );
179 
180  /* create top label */
181  xms = create_str(" \n ");
182 
183  tl = XmCreateLabel ( mf, "DidTitle", NULL, 0 );
184  XtVaSetValues( tl,
185  XmNtopAttachment, XmATTACH_FORM,
186  XmNbottomAttachment, XmATTACH_NONE,
187  XmNleftAttachment, XmATTACH_FORM,
188  XmNrightAttachment, XmATTACH_FORM,
189  XmNleftOffset, 0,
190  XmNtopOffset, 0,
191  XmNbottomOffset, 0,
192  XmNrightOffset, 0,
193  XmNborderWidth, 0,
194  XmNlabelString, xms,
195  XmNshadowThickness, 0,
196  XmNhighlightThickness, 0,
197  XmNheight, 32,
198  XmNalignment, XmALIGNMENT_CENTER,
199  XmNfontList, did_label_font,
200  NULL);
201  XtManageChild( tl );
202 /*
203  tl = XtVaCreateManagedWidget( "SmiTitle",
204  xmPushButtonWidgetClass, mw,
205  XmNborderWidth, 0,
206  XmNlabelString, xms,
207  XmNshadowThickness, 0,
208  XmNhighlightThickness, 0,
209  XmNalignment, XmALIGNMENT_CENTER,
210  XmNfontList, smid_label_font,
211  NULL);
212 */
213  XmStringFree ( xms );
214  /*
215  XtAddCallback(tl, MrmNcreateCallback,
216  (XtCallbackProc)create_label, 0);
217  */
218  par = 0;
219  reason = 0;
220  create_label(tl, &par, &reason);
221 
222  /* create main form */
223  /*
224  mf = (Widget)XmCreateForm ( mw, "DidMainForm", NULL, 0 );
225  XtVaSetValues ( mf,
226  XmNborderWidth,1,
227  XmNshadowThickness, 2,
228  XmNwidth,806,
229  XmNheight,300,
230 
231  XmNresizePolicy, XmRESIZE_NONE, NULL );
232  XtManageChild ( mf );
233  */
234  /*
235  XtAddCallback(mf, MrmNcreateCallback,
236  (XtCallbackProc)create_main, 0);
237  */
238 
239  create_main(mf, &par, &reason);
240 
241  f = XmCreateForm( mf, "ScrollForm", NULL, 0 );
242  XtVaSetValues ( f,
243  XmNwidth, 806,
244  XmNheight,300,
245  XmNtopAttachment, XmATTACH_WIDGET,
246  XmNbottomAttachment, XmATTACH_FORM,
247  XmNleftAttachment, XmATTACH_FORM,
248  XmNrightAttachment, XmATTACH_FORM,
249  XmNrightOffset, 0,
250  XmNleftOffset, 0,
251  XmNbottomOffset, 0,
252  XmNtopWidget, tl,
253  XmNtopOffset, 0,
254  XmNshadowThickness, 2,
255  XmNbottomOffset, 0,
256  /*
257  XmNshadowType, XmSHADOW_OUT,
258  */
259  XmNborderWidth,0,
260  NULL);
261 
262  /*
263  f = XtVaCreateManagedWidget ( "XDScrolledForm",
264  xmFormWidgetClass, mf,
265  XmNtopAttachment, XmATTACH_WIDGET,
266  XmNbottomAttachment, XmATTACH_FORM,
267  XmNleftAttachment, XmATTACH_FORM,
268  XmNrightAttachment, XmATTACH_FORM,
269  XmNrightOffset, 0,
270  XmNleftOffset, 0,
271  XmNbottomOffset, 0,
272  XmNtopWidget, tl,
273  XmNtopOffset, 0,
274  XmNshadowThickness, 2,
275  XmNbottomOffset, 0,
276  XmNshadowType, XmSHADOW_OUT,
277  XmNborderWidth,1,
278  NULL);
279 */
280  /*
281  XtAddCallback(f, MrmNcreateCallback,
282  (XtCallbackProc)create_window, 0);
283  */
284 
285  XtManageChild ( f );
286  /* create scrolled list */
287 
288  n = 0;
289  XtSetArg ( ar[n], XmNtopAttachment, XmATTACH_FORM); n++;
290  XtSetArg ( ar[n], XmNbottomAttachment, XmATTACH_FORM); n++;
291  XtSetArg ( ar[n], XmNleftAttachment, XmATTACH_FORM); n++;
292  XtSetArg ( ar[n], XmNrightAttachment, XmATTACH_FORM); n++;
293  XtSetArg ( ar[n], XmNrightOffset, 0); n++;
294  XtSetArg ( ar[n], XmNleftOffset, 0); n++;
295  XtSetArg ( ar[n], XmNbottomOffset, 0); n++;
296  XtSetArg ( ar[n], XmNtopOffset, 0); n++;
297  /*
298  XtSetArg ( ar[n], XmNvisualPolicy, XmCONSTANT); n++;
299  */
300  XtSetArg ( ar[n], XmNscrollBarDisplayPolicy, XmAS_NEEDED); n++;
301 
302  XtSetArg ( ar[n], XmNscrollingPolicy, XmAUTOMATIC); n++;
303 
304  sl = XmCreateScrolledWindow ( f, "ScrollWin", ar, (Cardinal)n );
305  /*
306  XtVaSetValues ( sl,
307  XmNtopAttachment, XmATTACH_FORM,
308  XmNbottomAttachment, XmATTACH_FORM,
309  XmNleftAttachment, XmATTACH_FORM,
310  XmNrightAttachment, XmATTACH_FORM,
311  XmNrightOffset, 0,
312  XmNleftOffset, 0,
313  XmNbottomOffset, 0,
314  XmNtopOffset, 0,
315 
316  XmNvisualPolicy, XmCONSTANT,
317 
318  XmNscrollBarDisplayPolicy, XmSTATIC,
319 
320  XmNscrollingPolicy, XmAUTOMATIC,
321 
322  NULL);
323  */
324  XtManageChild ( sl );
325  /*
326  create_window(sl, &par, &reason);
327  */
328  Window_id = sl;
329 
330  create_matrix_widget();
331 
332 /*
333  sl = XtVaCreateWidget ( "DidServersScrl",
334  xmScrolledWindowWidgetClass, f,
335  XmNscrollingPolicy, XmAUTOMATIC,
336  XmNscrollBarDisplayPolicy, XmSTATIC,
337  XmNtopAttachment, XmATTACH_FORM,
338  XmNleftAttachment, XmATTACH_FORM,
339  XmNrightAttachment, XmATTACH_FORM,
340  XmNbottomAttachment, XmATTACH_FORM,
341  XmNvisualPolicy, XmCONSTANT,
342  XmNtopOffset, 4,
343  XmNleftOffset, 4,
344  XmNbottomOffset, 4,
345  XmNrightOffset, 4,
346  NULL );
347  XtManageChild ( sl );
348 */
349  /*
350  XtVaSetValues( mw,
351  XmNworkWindow,mf,
352  XmNcommandWindow, tl,
353  NULL);
354  */
355 
356 }
357 
358 Widget create_separator(Widget parent_id)
359 {
360  Widget w;
361  Arg arglist[10];
362  int n = 0;
363 
364  w = XmCreateSeparator(parent_id, "separator",
365  arglist,(Cardinal)n);
366  XtManageChild(w);
367  return(w);
368 }
369 
370 void gui_create_main_menu( Widget mb )
371 {
372 Widget cb;
373 Widget mn;
374 Widget bt;
375 XmString xms;
376  /* File */
377  mn = XmCreatePulldownMenu ( mb, "FileMB", NULL, 0 );
378  cb = XmCreateCascadeButton(mb, "File", NULL, 0);
379  XtVaSetValues ( cb,
380  XmNsubMenuId, mn,
381  NULL);
382  XtManageChild ( cb );
383  /*
384  cb = XtVaCreateManagedWidget ( "File",
385  xmCascadeButtonWidgetClass, mb,
386  XtVaTypedArg, XmNmnemonic, XmRString, "F", 2,
387  XmNsubMenuId, mn,
388  NULL);
389  */
390  XtVaSetValues ( mn,
391  XmNradioAlwaysOne, True,
392  XmNradioBehavior, True,
393  NULL);
394  XtVaSetValues ( cb,
395  XmNfontList, did_default_font,
396  NULL);
397  /* buttons */
398  xms = create_str ("Exit DID");
399  /*
400  bt = XtVaCreateManagedWidget ( "MenuExitButton",
401  xmPushButtonWidgetClass, mn,
402  XmNlabelString, xms,
403  XmNaccelerator, "Ctrl<Key>C",
404  XmNacceleratorText, xma,
405  NULL);
406  */
407  bt = XmCreatePushButton ( mn, "button", NULL, 0 );
408  XtVaSetValues( bt,
409  XmNlabelString, xms,
410  XmNfontList, did_default_font,
411  NULL);
412  XtManageChild( bt );
413  XmStringFree ( xms );
414  XtAddCallback ( bt, XmNactivateCallback, (XtCallbackProc)did_exit, 0 );
415  /*
416  util_recolor ( XtParent(mn) );
417  */
418  /* View */
419  mn = XmCreatePulldownMenu ( mb, "ViewMB", NULL, 0 );
420  cb = XmCreateCascadeButton(mb, "View", NULL, 0);
421  XtVaSetValues ( cb,
422  XmNsubMenuId, mn,
423  NULL);
424  XtVaSetValues ( cb,
425  XmNfontList, did_default_font,
426  NULL);
427  XtManageChild ( cb );
428  /*
429  cb = XtVaCreateManagedWidget ( "View",
430  xmCascadeButtonWidgetClass, mb,
431  XtVaTypedArg, XmNmnemonic, XmRString, "V", 2,
432  XmNsubMenuId, mn,
433  NULL);
434  */
435  XtVaSetValues ( mn,
436  XmNradioAlwaysOne, True,
437  XmNradioBehavior, True,
438  NULL);
439  /* buttons */
440 
441  xms = create_str ("All Servers");
442  /*
443  bt = XtVaCreateManagedWidget ( "V_MenuAllButton",
444  xmPushButtonWidgetClass, mn,
445  XmNlabelString, xms,
446  XmNaccelerator, "Ctrl<Key>A",
447  XmNacceleratorText, xma,
448  NULL);
449  */
450  bt = XmCreatePushButton ( mn, "button", NULL, 0 );
451  XtVaSetValues( bt,
452  XmNlabelString, xms,
453  XmNfontList, did_default_font,
454  NULL);
455  XtManageChild( bt );
456  XmStringFree ( xms );
457  XtAddCallback ( bt, XmNactivateCallback, (XtCallbackProc)view_opts,
458  (XtPointer)1 );
459 
460  xms = create_str ("Servers by Node");
461  /*
462  bt = XtVaCreateManagedWidget ( "V_MenuNodeButton",
463  xmPushButtonWidgetClass, mn,
464  XmNlabelString, xms,
465  XmNaccelerator, "Ctrl<Key>N",
466  XmNacceleratorText, xma,
467  NULL);
468  XmStringFree ( xms );
469  */
470  bt = XmCreatePushButton ( mn, "button", NULL, 0 );
471  XtVaSetValues( bt,
472  XmNlabelString, xms,
473  XmNfontList, did_default_font,
474  NULL);
475  XtManageChild( bt );
476  XmStringFree ( xms );
477  XtAddCallback ( bt, XmNactivateCallback, (XtCallbackProc)view_opts,
478  (XtPointer)0 );
479 
480  xms = create_str ("Servers by Service");
481  /*
482  bt = XtVaCreateManagedWidget ( "V_MenuServiceButton",
483  xmPushButtonWidgetClass, mn,
484  XmNlabelString, xms,
485  XmNaccelerator, "Ctrl<Key>S",
486  XmNacceleratorText, xma,
487  NULL);
488  XmStringFree ( xms );
489  XmStringFree ( xma );
490  */
491  bt = XmCreatePushButton ( mn, "button", NULL, 0 );
492  XtVaSetValues( bt,
493  XmNlabelString, xms,
494  XmNfontList, did_default_font,
495  NULL);
496  XtManageChild( bt );
497  XmStringFree ( xms );
498  XtAddCallback ( bt, XmNactivateCallback, (XtCallbackProc)view_opts,
499  (XtPointer)2 );
500 
501  create_separator(mn);
502  /*
503  bt = XtVaCreateManagedWidget ( "W_MenuSep",
504  xmSeparatorGadgetClass, mn,
505  NULL);
506  */
507  xms = create_str ("Servers in Error");
508  /*
509  bt = XtVaCreateManagedWidget ( "V_MenuErrorButton",
510  xmPushButtonWidgetClass, mn,
511  XmNlabelString, xms,
512  XmNaccelerator, "Ctrl<Key>E",
513  XmNacceleratorText, xma,
514  NULL);
515  XmStringFree ( xms );
516  XmStringFree ( xma );
517  */
518  bt = XmCreatePushButton ( mn, "button", NULL, 0 );
519  XtVaSetValues( bt,
520  XmNlabelString, xms,
521  XmNfontList, did_default_font,
522  NULL);
523  XtManageChild( bt );
524  XmStringFree ( xms );
525  XtAddCallback ( bt, XmNactivateCallback, (XtCallbackProc)view_opts,
526  (XtPointer)3 );
527  /*
528  util_recolor ( XtParent(mn) );
529  */
530  /* Commands */
531  mn = XmCreatePulldownMenu ( mb, "CommandMB", NULL, 0 );
532  cb = XmCreateCascadeButton(mb, "Commands", NULL, 0);
533  XtVaSetValues ( cb,
534  XmNsubMenuId, mn,
535  NULL);
536  XtVaSetValues ( cb,
537  XmNfontList, did_default_font,
538  NULL);
539  XtManageChild ( cb );
540  /*
541  cb = XtVaCreateManagedWidget ( "Commands",
542  xmCascadeButtonWidgetClass, mb,
543  XtVaTypedArg, XmNmnemonic, XmRString, "C", 2,
544  XmNsubMenuId, mn,
545  XmNsensitive, commands_enable,
546  NULL);
547  */
548  /* buttons */
549  /* Utils */
550  /*
551  xms = util_create_str ("Show Command Buttons");
552  xma = util_create_str ("Ctrl+B");
553  bt = XtVaCreateManagedWidget ( "C_ShowCmndButt",
554  xmToggleButtonWidgetClass, mn,
555  XmNlabelString, xms,
556  XmNaccelerator, "Ctrl<Key>B",
557  XmNacceleratorText, xma,
558  XmNset, False,
559  XmNindicatorSize,12,
560  XmNvisibleWhenOff, True,
561  NULL);
562  XmStringFree ( xms );
563  XmStringFree ( xma );
564  XtAddCallback ( bt, XmNvalueChangedCallback, (XtCallbackProc)show_command_buttons_callback, NULL );
565 
566  bt = XtVaCreateManagedWidget ( "W_MenuSep",
567  xmSeparatorGadgetClass, mn,
568  NULL);
569  */
570 
571  xms = create_str ("LOG Connections");
572  /*
573  bt = XtVaCreateManagedWidget ( "C_MenuButtonLOG",
574  xmPushButtonWidgetClass, mn,
575  XmNlabelString, xms,
576  XmNaccelerator, "Ctrl<Key>G",
577  XmNacceleratorText, xma,
578  NULL);
579  XmStringFree ( xms );
580  XmStringFree ( xma );
581  XtAddCallback ( bt, XmNactivateCallback, (XtCallbackProc)dns_control_callback, "log" );
582  */
583  bt = XmCreatePushButton ( mn, "button", NULL, 0 );
584  XtVaSetValues( bt,
585  XmNlabelString, xms,
586  XmNfontList, did_default_font,
587  NULL);
588  XtManageChild( bt );
589  XmStringFree ( xms );
590  XtAddCallback ( bt, XmNactivateCallback, (XtCallbackProc)dns_control,
591  (XtPointer)0 );
592 
593  create_separator(mn);
594  /*
595  bt = XtVaCreateManagedWidget ( "W_MenuSep",
596  xmSeparatorGadgetClass, mn,
597  NULL);
598  */
599  xms = create_str ("Set Debug ON");
600  /*
601  bt = XtVaCreateManagedWidget ( "C_MenuButtonDON",
602  xmPushButtonWidgetClass, mn,
603  XmNlabelString, xms,
604  XmNaccelerator, "<Key>F2:",
605  XmNacceleratorText, xma,
606  NULL);
607  XmStringFree ( xms );
608  XmStringFree ( xma );
609  XtAddCallback ( bt, XmNactivateCallback, (XtCallbackProc)dns_control_callback, "on" );
610  */
611  bt = XmCreatePushButton ( mn, "button", NULL, 0 );
612  XtVaSetValues( bt,
613  XmNlabelString, xms,
614  XmNfontList, did_default_font,
615  NULL);
616  XtManageChild( bt );
617  XmStringFree ( xms );
618  XtAddCallback ( bt, XmNactivateCallback, (XtCallbackProc)dns_control,
619  (XtPointer)1 );
620 
621  xms = create_str ("Set Debug OFF");
622  /*
623  bt = XtVaCreateManagedWidget ( "C_MenuButtonDOFF",
624  xmPushButtonWidgetClass, mn,
625  XmNlabelString, xms,
626  XmNaccelerator, "<Key>F3:",
627  XmNacceleratorText, xma,
628  NULL);
629  XmStringFree ( xms );
630  XmStringFree ( xma );
631  XtAddCallback ( bt, XmNactivateCallback, (XtCallbackProc)dns_control_callback, "off" );
632  */
633  bt = XmCreatePushButton ( mn, "button", NULL, 0 );
634  XtVaSetValues( bt,
635  XmNlabelString, xms,
636  XmNfontList, did_default_font,
637  NULL);
638  XtManageChild( bt );
639  XmStringFree ( xms );
640  XtAddCallback ( bt, XmNactivateCallback, (XtCallbackProc)dns_control,
641  (XtPointer)2 );
642 
643  create_separator(mn);
644  /*
645  bt = XtVaCreateManagedWidget ( "W_MenuSep",
646  xmSeparatorGadgetClass, mn,
647  NULL);
648  */
649  xms = create_str ("Print Hash Table");
650  /*
651  bt = XtVaCreateManagedWidget ( "C_MenuButtonPrint",
652  xmPushButtonWidgetClass, mn,
653  XmNlabelString, xms,
654  XmNaccelerator, "Ctrl<Key>T",
655  XmNacceleratorText, xma,
656  NULL);
657  XmStringFree ( xms );
658  XmStringFree ( xma );
659  XtAddCallback ( bt, XmNactivateCallback, (XtCallbackProc)dns_control_callback, "hash" );
660  */
661  bt = XmCreatePushButton ( mn, "button", NULL, 0 );
662  XtVaSetValues( bt,
663  XmNlabelString, xms,
664  XmNfontList, did_default_font,
665  NULL);
666  XtManageChild( bt );
667  XmStringFree ( xms );
668  XtAddCallback ( bt, XmNactivateCallback, (XtCallbackProc)dns_control,
669  (XtPointer)4 );
670  /* kill
671  create_separator(mn);
672  */
673  /*
674  bt = XtVaCreateManagedWidget ( "W_MenuSep",
675  xmSeparatorGadgetClass, mn,
676  NULL);
677  */
678  /* kill
679  xms = create_str ("Kill DIM Servers");
680  */
681  /*
682  bt = XtVaCreateManagedWidget ( "C_MenuButtonKill",
683  xmPushButtonWidgetClass, mn,
684  XmNlabelString, xms,
685  XmNaccelerator, "Ctrl<Key>K",
686  XmNacceleratorText, xma,
687  NULL);
688  XmStringFree ( xms );
689  XmStringFree ( xma );
690  XtAddCallback ( bt, XmNactivateCallback, (XtCallbackProc)dns_control_callback, "kill" );
691  */
692  /* kill
693  bt = XmCreatePushButton ( mn, "button", NULL, 0 );
694  XtVaSetValues( bt,
695  XmNlabelString, xms,
696  XmNfontList, did_default_font,
697  NULL);
698  XtManageChild( bt );
699  XmStringFree ( xms );
700  XtAddCallback ( bt, XmNactivateCallback, (XtCallbackProc)dns_control,
701  (XtPointer)3 );
702  */
703  /*
704  util_recolor ( XtParent(mn) );
705  */
706  /* Help */
707  mn = XmCreatePulldownMenu ( mb, "HelpMB", NULL, 0 );
708  /*
709  cb = XtVaCreateManagedWidget ( "Help",
710  xmCascadeButtonWidgetClass, mb,
711  XtVaTypedArg, XmNmnemonic, XmRString, "H", 2,
712  XmNsubMenuId, mn,
713  NULL);
714  */
715  cb = XmCreateCascadeButton ( mb, "Help", NULL, 0 );
716  XtVaSetValues( cb,
717  XmNsubMenuId, mn,
718  XmNfontList, did_default_font,
719  NULL);
720  XtManageChild( cb );
721 
722  xms = create_str ("Help");
723  /*
724  bt = XtVaCreateManagedWidget ( "C_XDAbout",
725  xmPushButtonWidgetClass, mn,
726  XmNlabelString, xms,
727  XmNaccelerator, "Ctrl<Key>H",
728  XmNacceleratorText, xma,
729  NULL);
730  */
731  bt = XmCreatePushButton ( mn, "button", NULL, 0 );
732  XtVaSetValues( bt,
733  XmNlabelString, xms,
734  XmNfontList, did_default_font,
735  NULL);
736  XtManageChild( bt );
737  XmStringFree ( xms );
738  /*
739  XtAddCallback ( bt, XmNactivateCallback, (XtCallbackProc)about_xd_callback, NULL );
740  */
741  /* set help menu */
742  XtVaSetValues ( mb, XmNmenuHelpWidget, cb, NULL );
743  /*
744  util_recolor ( XtParent(mn) );
745  */
746 }
747 
748 
749 Widget gui_toplevel(char **argv)
750 {
751 int n;
752 Arg arglist[6];
753 
754  n = 0;
755  XtSetArg ( arglist[n], XmNallowShellResize, True); n++;
756  XtSetArg ( arglist[n], XmNiconName, "DID"); n++;
757  XtSetArg ( arglist[n], XmNtitle, "xDid"); n++;
758  XtSetArg ( arglist[n], XmNtraversalOn,True); n++;
759  return XtAppCreateShell(argv[0], NULL, applicationShellWidgetClass,
760  display, arglist, (Cardinal)n);
761 
762 }
763 
764 Widget gui_initialize (int argc, char **argv)
765 {
766 Widget toplevel;
767 void gui_create_main_window();
768 
769  XtToolkitInitialize();
770  app_context = XtCreateApplicationContext();
771  display = XtOpenDisplay(app_context, NULL, argv[0], "DID",
772  NULL, 0, &argc, argv);
773  if (display == NULL)
774  {
775  printf("%s: Can't open display\n", argv[0]);
776  exit(1);
777  }
778  toplevel = gui_toplevel(argv);
779 
780  did_default_font = (XmFontList)util_get_font(DEFAULT_FONT, toplevel);
781  did_small_font = (XmFontList)util_get_font(MENU_FONT, toplevel);
782  did_label_font = (XmFontList)util_get_font(LABEL_FONT, toplevel);
783  did_server_font = (XmFontList)util_get_font(SERVER_FONT, toplevel);
784 
785  gui_create_main_window(toplevel);
786 
787  XtRealizeWidget ( toplevel );
788  return toplevel;
789 }
790 
791 int main(int argc, char *argv[])
792 {
793  int i;
794  char opt_str[20], *ptr;
795  XtInputMask mask;
796  void do_got_service_list();
797  void do_show_clients();
798  void app_initialize();
799 
800  dim_no_threads();
801  dic_disable_padding();
802  dis_disable_padding();
803 
804  if(argc > 1)
805  {
806  if(argv[1][0] == '-')
807  {
808  sprintf(opt_str,"%s",&argv[1][1]);
809  if((!strncmp(opt_str,"node",4)) ||
810  (!strncmp(opt_str,"NODE",4)))
811  Curr_view_opt = 0;
812  else if((!strncmp(opt_str,"all",3)) ||
813  (!strncmp(opt_str,"ALL",3)))
814  Curr_view_opt = 1;
815  else if((!strncmp(opt_str,"dns",3)) ||
816  (!strncmp(opt_str,"DNS",3))) {
817  char text[132];
818  sprintf(text,"DIM_DNS_NODE=%s",opt_str+4);
819  putenv(text);
820  dim_set_dns_node(opt_str+4);
821  }
822  else if((!strncmp(opt_str,"service",7)) ||
823  (!strncmp(opt_str,"SERVICE",7)))
824  Curr_view_opt = 2;
825  else if((!strncmp(opt_str,"error",5)) ||
826  (!strncmp(opt_str,"ERROR",5)))
827  Curr_view_opt = 3;
828  else if((!strncmp(opt_str,"help",4)) ||
829  (!strncmp(opt_str,"HELP",4)))
830  {
831  printf("Did - DIM Information Display\n");
832  printf("\t-all Show ALL Servers\n");
833  printf("\t-dns=<str> Show Servers with DIM_DNS_NODE provided by <str>\n");
834  printf("\t-service=<str> Show Servers providing Service <str>\n");
835  printf("\t-node=<nodename> Show Servers on Node <nodename>\n");
836  printf("\t-error Show Servers in Error\n");
837  printf("\t-help Show this message\n\n");
838  exit(0);
839  }
840  else
841  Curr_view_opt = -1;
842  if((Curr_view_opt == 0) || (Curr_view_opt == 2))
843  {
844  if(!(ptr = strchr(argv[1],'=')))
845  {
846  if( (ptr = strchr(argv[2],'=')) )
847  {
848  ptr++;
849  if(!(*ptr))
850  ptr = argv[3];
851  }
852  else
853  ptr++;
854  }
855  else
856  {
857  ptr++;
858  if(!(*ptr))
859  ptr = argv[2];
860  }
861  for(i = 0;*ptr; ptr++, i++)
862  Curr_view_opt_par[i] = (char)toupper((int)*ptr);
863  Curr_view_opt_par[i] = '\0';
864  }
865  }
866  }
867 
868  toplevel_widget = (Widget)gui_initialize(argc, argv);
869  app_initialize();
870  /*
871  * Sit around forever waiting to process X-events. We never leave
872  * XtAppMainLoop. From here on, we only execute our callback routines.
873  */
874 
875  while(1)
876  {
877  {
878  DISABLE_AST
879  mask = XtAppPending(app_context);
880  ENABLE_AST
881  }
882  if(mask)
883  {
884  DISABLE_AST
885  XtAppProcessEvent(app_context, mask);
886  if(Got_Service_List)
887  {
888  do_got_service_list(Got_Service_List);
889  Got_Service_List = 0;
890  }
891  if(Got_Client_List)
892  {
893  do_show_clients(Got_Client_List);
894  Got_Client_List = 0;
895  }
896  ENABLE_AST
897  }
898  else
899  {
900  dim_usleep(100000);
901  /*
902  usleep(100000);
903  */
904  }
905  }
906 
907 }
908 
909 static char no_link = -1;
910 
911 void app_initialize(int tag)
912 {
913 void check_put_label();
914 
915 void update_servers();
916 void update_servers_new();
917 void update_show_servers();
918 extern void get_all_colors();
919 extern void set_title();
920 extern void set_icon_title();
921 char dns_node[64];
922 int dns_port;
923 char title[128],icon_title[128];
924 
925  if(tag){}
926  dic_get_dns_node(dns_node);
927  dns_port = dic_get_dns_port();
928  if(dns_port != DNS_PORT)
929  {
930  sprintf(title,"DID - DIM Information Display DNS=%s:%d",dns_node,dns_port);
931  }
932  else
933  {
934  sprintf(title,"DID - DIM Information Display DNS=%s",dns_node);
935  }
936  sprintf(icon_title,"DID %s",dns_node);
937  get_all_colors(display,Matrix_id[Curr_matrix]);
938  set_title(toplevel_widget,title);
939  set_icon_title(toplevel_widget,icon_title);
940  Timer_q = dtq_create();
941  dic_info_service("DIS_DNS/SERVER_INFO",MONITORED,0,0,0,update_servers,0,
942  &no_link,1);
943  /*
944  dic_info_service("DIS_DNS/SERVER_LIST",MONITORED,0,0,0,
945  update_servers_new,0, &no_link,1);
946  */
947  /*
948  dtq_add_entry(Timer_q, 2, check_put_label, 0);
949  */
950  XtAppAddTimeOut(app_context, 1000, update_show_servers, 0);
951 }
952 
953 /*
954  * All errors are fatal.
955  */
956 void s_error(char *problem_string)
957 {
958  printf("%s\n", problem_string);
959  exit(0);
960 }
961 
962 void did_exit(Widget w, int *tag, unsigned long *reason)
963 {
964  if(w){}
965  if(tag){}
966  if(reason){}
967  exit(0);
968 }
969 
970 extern Pixel rgb_colors[MAX_COLORS];
971 
972 void create_main (Widget w, int *tag, unsigned long *reason)
973 {
974  if(tag){}
975  if(reason){}
976  Window_id = w;
977 /*
978  dtq_start_timer(5, app_initialize, 0);
979 */
980 }
981 
982 void view_opts(Widget w, int tag, unsigned long *reason)
983 {
984  void get_server_node(), get_server_service(), show_servers();
985 
986  if(w){}
987  if(reason){}
988  Curr_view_opt = tag;
989  switch(tag)
990  {
991  case 0 :
992  get_server_node();
993  break;
994  case 1 :
995  show_servers();
996  break;
997  case 2 :
998  get_server_service();
999  break;
1000  case 3 :
1001  show_servers();
1002  break;
1003  }
1004 }
1005 
1006 void dns_control(Widget w, int tag, unsigned long *reason)
1007 {
1008 
1009  if(w){}
1010  if(reason){}
1011  switch(tag)
1012  {
1013  case 0 :
1014  dic_cmnd_service("DIS_DNS/PRINT_STATS",0,0);
1015  break;
1016  case 1 :
1017  dic_cmnd_service("DIS_DNS/DEBUG_ON",0,0);
1018  break;
1019  case 2 :
1020  dic_cmnd_service("DIS_DNS/DEBUG_OFF",0,0);
1021  break;
1022  case 3 :
1023  put_selection(DID_KILL_ALL,"Confirmation");
1024  break;
1025  case 4 :
1026  dic_cmnd_service("DIS_DNS/PRINT_HASH_TABLE",0,0);
1027  break;
1028  }
1029 }
1030 
1031 void get_server_node()
1032 {
1033 Widget id,sel_id;
1034 int i, j, n_nodes, curr_index = 0;
1035 char nodes_str[MAX_NODE_NAME*MAX_CONNS*2], max_str[MAX_NODE_NAME];
1036 char *ptr, *nodeptrs[MAX_CONNS*2], *curr_str, *sptr;
1037 int get_nodes();
1038 
1039  sel_id = put_selection(DID_SEL_NODE,"Node Selection");
1040  id = XmSelectionBoxGetChild(sel_id,XmDIALOG_HELP_BUTTON);
1041  XtUnmanageChild(id);
1042  id = XmSelectionBoxGetChild(sel_id,XmDIALOG_APPLY_BUTTON);
1043  XtUnmanageChild(id);
1044  id = XmSelectionBoxGetChild(sel_id,XmDIALOG_LIST);
1045  XmListDeleteAllItems(id);
1046  n_nodes = get_nodes(nodes_str);
1047  ptr = nodes_str;
1048 
1049  for(i=0;i<n_nodes;i++)
1050  {
1051  nodeptrs[i] = ptr;
1052  sptr = ptr;
1053  ptr = strchr(ptr,'\n');
1054  *ptr++ = '\0';
1055  for(j = 0; j < (int)strlen(sptr); j++)
1056  sptr[j] = (char)tolower((int)sptr[j]);
1057  }
1058  strcpy(max_str,"zzzzzzzzzzzzzzzzzzzzzzzzzzzz");
1059  for(i=0;i<n_nodes; i++)
1060  {
1061  curr_str = max_str;
1062  for(j=0;j<n_nodes; j++)
1063  {
1064  sptr = nodeptrs[j];
1065  if(!sptr)
1066  continue;
1067 
1068  if(strcmp(sptr,curr_str) < 0)
1069  {
1070  curr_str = sptr;
1071  curr_index = j;
1072  }
1073  }
1074  nodeptrs[curr_index] = 0;
1075  XmListAddItem(id,create_str(curr_str),i+1);
1076  }
1077  /*
1078  for(i=0;i<n_nodes;i++)
1079  {
1080  node = ptr;
1081  ptr = strchr(ptr,'\n');
1082  *ptr++ = '\0';
1083  XmListAddItem(id,create_str(node),i+1);
1084  }
1085  */
1086  set_something(id,XmNlistItemCount,i);
1087  set_something(id,XmNlistVisibleItemCount,(i < 8) ? i : 8);
1088 }
1089 
1090 void get_server_service()
1091 {
1092 Widget id,sel_id;
1093 
1094  sel_id = put_selection(DID_SEL_SERVICE,"Service Selection");
1095  id = XmSelectionBoxGetChild(sel_id,XmDIALOG_HELP_BUTTON);
1096  XtUnmanageChild(id);
1097  id = XmSelectionBoxGetChild(sel_id,XmDIALOG_APPLY_BUTTON);
1098  XtUnmanageChild(id);
1099 
1100  id = XmSelectionBoxGetChild(sel_id,XmDIALOG_LIST);
1101  /*
1102  XtUnmanageChild(id);
1103  */
1104  XtUnmapWidget(id);
1105 
1106  /*
1107  id = (Widget)XmSelectionBoxGetChild(sel_id,XmDIALOG_LIST_LABEL);
1108  XtUnmanageChild(id);
1109  */
1110 }
1111 
1112 int get_nodes(char *node_ptr)
1113 {
1114 DNS_SERVER_INFO *ptr;
1115 int n_nodes = 0;
1116 SERVER *servp;
1117 
1118  node_ptr[0] = '\0';
1119  servp = Server_head;
1120  while( (servp = (SERVER *)sll_get_next((SLL *)servp)) )
1121  {
1122  ptr = &servp->server;
1123  if(strstr(node_ptr,ptr->node) <= (char *)0)
1124  {
1125  strcat(node_ptr,ptr->node);
1126  strcat(node_ptr,"\n");
1127  n_nodes++;
1128  }
1129  }
1130  return(n_nodes);
1131 }
1132 
1133 void get_service_format()
1134 {
1135 
1136  char str[256], *ptr, *ptr1;
1137  int rpc_flag;
1138 
1139  strcpy(str,Curr_service_name);
1140  rpc_flag = 0;
1141  if( (ptr = strstr(str,"/RpcIn")) )
1142  {
1143  *ptr = '\0';
1144  rpc_flag = 1;
1145  }
1146  if( (ptr = strstr(str,"/RpcOut")) )
1147  {
1148  *ptr = '\0';
1149  rpc_flag = 2;
1150  }
1151  strcat(str,"|");
1152  if( (ptr = strstr(Curr_service_list,str)) )
1153  {
1154  if(!rpc_flag)
1155  {
1156  ptr += strlen(str);
1157  ptr1 = strchr(ptr,'|');
1158  }
1159  else if(rpc_flag == 1)
1160  {
1161  ptr += strlen(str);
1162  ptr1 = strchr(ptr,',');
1163  }
1164  else
1165  {
1166  ptr += strlen(str);
1167  ptr = strchr(ptr,',');
1168  ptr++;
1169  ptr1 = strchr(ptr,'|');
1170  }
1171  strncpy(Curr_service_format,ptr,(size_t)(ptr1 - ptr));
1172  Curr_service_format[(int)(ptr1-ptr)] = '\0';
1173  }
1174 }
1175 
1176 void recv_service_info(int *tag, int *buffer, int *size)
1177 {
1178 /*
1179  char str[256], *ptr, *ptr1;
1180  int rpc_flag;
1181 */
1182  void print_service_formatted();
1183 
1184  if(tag){}
1185  Service_content_str = malloc((size_t)(1024 + (*size)*16));
1186  Service_buffer = malloc((size_t)*size);
1187  memcpy(Service_buffer, (char *)buffer, (size_t)*size);
1188  Service_size = *size;
1189  get_service_format();
1190  if((*size == 4 ) && (*buffer == -1))
1191  {
1192  sprintf(Service_content_str,
1193  "Service %s Not Available\n", Curr_service_name);
1194  }
1195  else
1196  {
1197  switch(Curr_service_print_type)
1198  {
1199  case 0:
1200  print_service_formatted(buffer,*size);
1201  break;
1202  /*
1203  case 1:
1204  print_service_float(buffer, ((*size - 1) / 4) + 1);
1205  break;
1206  case 2:
1207  print_service_double(buffer, ((*size - 1) / 4) + 1);
1208  break;
1209  */
1210  }
1211  }
1212  set_something(Content_label_id,XmNlabelString, Service_content_str);
1213  /*
1214  if(Matrix_id[Curr_matrix])
1215  XFlush(XtDisplay(Matrix_id[Curr_matrix]));
1216  */
1217 }
1218 
1219 void print_service_formatted(void *buff, int size)
1220 {
1221 char type;
1222 int num, ret;
1223 char str[128];
1224 char *ptr;
1225 void *buffer_ptr;
1226 char timestr[128], aux[10];
1227 int quality = 0, secs = 0, mili = 0;
1228 int did_write_string(char, int, void **, int);
1229 time_t tsecs;
1230 
1231  sprintf(Service_content_str,
1232  "Service %s (%s) Contents :\n \n", Curr_service_name,
1233  Curr_service_format);
1234  /*
1235  if(Curr_service_id)
1236  {
1237  */
1238  dic_get_timestamp(0, &secs, &mili);
1239  quality = dic_get_quality(0);
1240 /*
1241 #ifdef LYNXOS
1242  ctime_r((time_t *)&secs, timestr, 128);
1243 #else
1244  ctime_r((time_t *)&secs, timestr);
1245 #endif
1246 */
1247  tsecs = secs;
1248  my_ctime(&tsecs, timestr, 128);
1249  ptr = strrchr(timestr,' ');
1250  strcpy(aux, ptr);
1251  sprintf(ptr,".%03d",mili);
1252  strcat(timestr, aux);
1253  timestr[strlen(timestr)-1] = '\0';
1254 
1255  sprintf(str," Timestamp: %s Quality: %d\n\n",
1256  timestr, quality);
1257 
1258  strcat(Service_content_str,str);
1259  /*
1260  }
1261  */
1262  ptr = Curr_service_format;
1263  buffer_ptr = buff;
1264  while(*ptr)
1265  {
1266  type = *ptr++;
1267  if(*ptr == ':')
1268  {
1269  ptr++;
1270  sscanf(ptr, "%d", &num);
1271  ret = did_write_string(type, num, &buffer_ptr, size);
1272  size -= ret;
1273  if( (ptr = strchr(ptr,';')) )
1274  ptr++;
1275  else
1276  break;
1277  }
1278  else
1279  {
1280  ret = did_write_string(type, 0, &buffer_ptr, size);
1281  size -= ret;
1282  break;
1283  }
1284  }
1285 }
1286 
1287 int did_write_string(char type, int num, void **buffer_ptr, int ssize)
1288 {
1289 void *ptr;
1290 int size, psize;
1291 
1292  void print_service_standard();
1293  void print_service_char();
1294  void print_service_short();
1295  void print_service_float();
1296  void print_service_double();
1297 
1298  ptr = *buffer_ptr;
1299  switch(type)
1300  {
1301  case 'L':
1302  case 'l':
1303  strcat(Service_content_str," L");
1304  if(!num)
1305  size = ssize/(int)sizeof(int);
1306  else
1307  size = num;
1308  psize = size * (int)sizeof(int);
1309  print_service_standard(ptr, size);
1310  break;
1311  case 'I':
1312  case 'i':
1313  strcat(Service_content_str," I");
1314  if(!num)
1315  size = ssize/(int)sizeof(int);
1316  else
1317  size = num;
1318  psize = size * (int)sizeof(int);
1319  print_service_standard(ptr, size);
1320  break;
1321  case 'S':
1322  case 's':
1323  strcat(Service_content_str," S");
1324  if(!num)
1325  size = ssize/(int)sizeof(short);
1326  else
1327  size = num;
1328  psize = size * (int)sizeof(short);
1329  print_service_short(ptr, size);
1330  break;
1331  case 'F':
1332  case 'f':
1333  strcat(Service_content_str," F");
1334  if(!num)
1335  size = ssize/(int)sizeof(float);
1336  else
1337  size = num;
1338  psize = size * (int)sizeof(float);
1339  print_service_float(ptr, size);
1340  break;
1341  case 'D':
1342  case 'd':
1343  strcat(Service_content_str," D");
1344  if(!num)
1345  size = ssize/(int)sizeof(double);
1346  else
1347  size = num;
1348  psize = size * (int)sizeof(double);
1349  print_service_double(ptr, size);
1350  break;
1351  case 'X':
1352  case 'x':
1353  strcat(Service_content_str," X");
1354  if(!num)
1355  size = ssize/(int)sizeof(longlong);
1356  else
1357  size = num;
1358  psize = size * (int)sizeof(longlong);
1359  print_service_standard(ptr, size*2);
1360  break;
1361  case 'C':
1362  case 'c':
1363  default:
1364  strcat(Service_content_str," C");
1365  if(!num)
1366  size = ssize;
1367  else
1368  size = num;
1369  psize = size;
1370  print_service_char(ptr, size);
1371  }
1372  ptr = (char *)ptr + psize;
1373  *buffer_ptr = ptr;
1374  return psize;
1375 }
1376 /*
1377 print_service(buff, size)
1378 int *buff, size;
1379 {
1380 int i,j, str_flag = 0;
1381 char *asc, *ptr, str[80];
1382 int last[4];
1383 
1384  sprintf(Service_content_str,
1385  "Service %s (%s) Contents :\n \n", Curr_service_name,
1386  Curr_service_format);
1387  asc = (char *)buff;
1388  for( i = 0; i < size; i++)
1389  {
1390  if(i%4 == 0)
1391  {
1392  sprintf(str,"%4d: ",i);
1393  strcat(Service_content_str,str);
1394  }
1395  if(!(i%4))
1396  strcat(Service_content_str,"H");
1397  sprintf(str," %08X ",buff[i]);
1398  strcat(Service_content_str,str);
1399  last[i%4] = buff[i];
1400  if(i%4 == 3)
1401  {
1402  strcat(Service_content_str," '");
1403  for(j = 0; j <16; j++)
1404  {
1405  if(isprint(asc[j]))
1406  {
1407  sprintf(str,"%c",asc[j]);
1408  strcat(Service_content_str,str);
1409  }
1410  else
1411  {
1412  sprintf(str,".");
1413  strcat(Service_content_str,str);
1414  }
1415  }
1416  strcat(Service_content_str,"'\n");
1417  for(j = 0; j <4; j++)
1418  {
1419  if(j == 0)
1420  strcat(Service_content_str," D");
1421  sprintf(str,"%11d ",last[j]);
1422  strcat(Service_content_str,str);
1423  }
1424  strcat(Service_content_str,"\n");
1425  asc = (char *)&buff[i+1];
1426  }
1427  }
1428  if(i%4)
1429  {
1430  for(j = 0; j < 4 - (i%4); j++)
1431  strcat(Service_content_str," ");
1432  strcat(Service_content_str," '");
1433  for(j = 0; j < (i%4) * 4; j++)
1434  {
1435  if(isprint(asc[j]))
1436  {
1437  sprintf(str,"%c",asc[j]);
1438  strcat(Service_content_str,str);
1439  }
1440  else
1441  strcat(Service_content_str,".");
1442  }
1443  strcat(Service_content_str,"'\n");
1444  for(j = 0; j < (i%4); j++)
1445  {
1446  if(j == 0)
1447  strcat(Service_content_str," D");
1448  sprintf(str,"%11d ",last[j]);
1449  strcat(Service_content_str,str);
1450  }
1451  strcat(Service_content_str,"\n");
1452  }
1453 }
1454 */
1455 
1456 void print_service_standard(int *buff, int size)
1457 {
1458 int i,j;
1459 char *ptr, str[80], tmp[256];
1460 int last[4];
1461 /*
1462 char *asc;
1463  asc = (char *)buff;
1464 */
1465  ptr = Service_content_str;
1466  ptr += strlen(Service_content_str);
1467  for( i = 0; i < size; i++)
1468  {
1469  strcpy(tmp,"");
1470  if(i%4 == 0)
1471  {
1472  if(i != 0)
1473  {
1474  strcat(tmp," ");
1475  }
1476  sprintf(str,"%5d ",i);
1477  strcat(tmp,str);
1478  }
1479  if(!(i%4))
1480  strcat(tmp,"H: ");
1481  sprintf(str," %08X",buff[i]);
1482  strcat(tmp,str);
1483  last[i%4] = buff[i];
1484  if((i%4 == 3) || (i == (size-1)))
1485  {
1486  /*
1487  if(i%4 != 3)
1488  {
1489  for(j = 1; j < 4 - (i%4); j++)
1490  strcat(tmp," ");
1491  }
1492  strcat(tmp," '");
1493  for(j = 0; j < ((i%4)*4)+4 ; j++)
1494  {
1495  if(isprint(asc[j]))
1496  {
1497  sprintf(str,"%c",asc[j]);
1498  strcat(tmp,str);
1499  }
1500  else
1501  {
1502  sprintf(str,".");
1503  strcat(tmp,str);
1504  }
1505  }
1506  */
1507  strcat(tmp,"\n");
1508  for(j = 0; j <= (i%4); j++)
1509  {
1510  if(j == 0)
1511  strcat(tmp," D: ");
1512  sprintf(str,"%12d",last[j]);
1513  strcat(tmp,str);
1514  }
1515  strcat(tmp,"\n");
1516 /*
1517  asc = (char *)&buff[i+1];
1518 */
1519  }
1520  strcpy(ptr, tmp);
1521  ptr += strlen(tmp);
1522  }
1523  strcpy(tmp,"\n");
1524  strcpy(ptr, tmp);
1525 }
1526 
1527 void print_service_longlong(longlong *buff, int size)
1528 {
1529 int i,j;
1530 char *ptr, str[80], tmp[256];
1531 longlong last[4];
1532 /*
1533 char *asc;
1534  asc = (char *)buff;
1535 */
1536  ptr = Service_content_str;
1537  ptr += strlen(Service_content_str);
1538  for( i = 0; i < size; i++)
1539  {
1540  strcpy(tmp,"");
1541  if(i%4 == 0)
1542  {
1543  if(i != 0)
1544  {
1545  strcat(tmp," ");
1546  }
1547  sprintf(str,"%5d ",i);
1548  strcat(tmp,str);
1549  }
1550  if(!(i%4))
1551  strcat(tmp,"H: ");
1552  sprintf(str," %08X",(unsigned)buff[i]);
1553  strcat(tmp,str);
1554  last[i%4] = buff[i];
1555  if((i%4 == 3) || (i == (size-1)))
1556  {
1557  strcat(tmp,"\n");
1558  for(j = 0; j <= (i%4); j++)
1559  {
1560  if(j == 0)
1561  strcat(tmp," D: ");
1562  sprintf(str,"%12d",(int)last[j]);
1563  strcat(tmp,str);
1564  }
1565  strcat(tmp,"\n");
1566 /*
1567  asc = (char *)&buff[i+1];
1568 */
1569  }
1570  strcpy(ptr, tmp);
1571  ptr += strlen(tmp);
1572  }
1573  strcpy(tmp,"\n");
1574  strcpy(ptr, tmp);
1575 }
1576 
1577 void print_service_short(short *buff, int size)
1578 {
1579 int i,j;
1580 char *ptr, str[80], tmp[256];
1581 short last[8];
1582 /*
1583 char *asc;
1584  asc = (char *)buff;
1585 */
1586  ptr = Service_content_str;
1587  ptr += strlen(Service_content_str);
1588  for( i = 0; i < size; i++)
1589  {
1590  strcpy(tmp,"");
1591  if(i%8 == 0)
1592  {
1593  if(i != 0)
1594  {
1595  strcat(tmp," ");
1596  }
1597  sprintf(str,"%5d ",i);
1598  strcat(tmp,str);
1599  }
1600  if(!(i%8))
1601  strcat(tmp,"H: ");
1602  sprintf(str," %04X",buff[i]);
1603  strcat(tmp,str);
1604  last[i%8] = buff[i];
1605  if((i%8 == 7) || (i == (size-1)))
1606  {
1607  /*
1608  if(i%7 != 7)
1609  {
1610  for(j = 1; j < 8 - (i%8); j++)
1611  strcat(tmp," ");
1612  }
1613  strcat(tmp," '");
1614  for(j = 0; j < ((i%8)*2)+2 ; j++)
1615  {
1616  if(isprint(asc[j]))
1617  {
1618  sprintf(str,"%c",asc[j]);
1619  strcat(tmp,str);
1620  }
1621  else
1622  {
1623  sprintf(str,".");
1624  strcat(tmp,str);
1625  }
1626  }
1627  */
1628  strcat(tmp,"\n");
1629  for(j = 0; j <= (i%8); j++)
1630  {
1631  if(j == 0)
1632  strcat(tmp," D: ");
1633  sprintf(str," %5d",last[j]);
1634  strcat(tmp,str);
1635  }
1636  strcat(tmp,"\n");
1637 /*
1638  asc = (char *)&buff[i+1];
1639 */
1640  }
1641  strcpy(ptr, tmp);
1642  ptr += strlen(tmp);
1643  }
1644  strcpy(tmp,"\n");
1645  strcpy(ptr, tmp);
1646 }
1647 
1648 void print_service_char(char *buff, int size)
1649 {
1650 int i,j;
1651 char *asc, *ptr, str[80], tmp[256];
1652 /*
1653 char last[16];
1654 */
1655  asc = (char *)buff;
1656  ptr = Service_content_str;
1657  ptr += strlen(Service_content_str);
1658  for( i = 0; i < size; i++)
1659  {
1660  strcpy(tmp,"");
1661  if(i%16 == 0)
1662  {
1663  if(i != 0)
1664  {
1665  strcat(tmp," ");
1666  }
1667  sprintf(str,"%5d ",i);
1668  strcat(tmp,str);
1669  }
1670  if(!(i%16))
1671  strcat(tmp,"H: ");
1672  sprintf(str,"%02X",buff[i]);
1673 /* strcat(tmp,str);
1674 */
1675  strcat(tmp," ");
1676  strcat(tmp,&str[strlen(str)-2]);
1677  /*
1678  last[i%16] = buff[i];
1679  if(i%4 == 3)
1680  strcat(tmp," ");
1681  */
1682  if((i%16 == 15) || (i == (size-1)))
1683  {
1684  if(i%16 != 15)
1685  {
1686  for(j = 1; j < 16 - (i%16); j++)
1687  strcat(tmp," ");
1688  }
1689  strcat(tmp," '");
1690  for(j = 0; j <= (i%16) ; j++)
1691  {
1692  if(isprint(asc[j]))
1693  {
1694  sprintf(str,"%c",asc[j]);
1695  strcat(tmp,str);
1696  }
1697  else
1698  {
1699  sprintf(str,".");
1700  strcat(tmp,str);
1701  }
1702  }
1703  strcat(tmp,"'\n");
1704  asc = (char *)&buff[i+1];
1705  }
1706  strcpy(ptr, tmp);
1707  ptr += strlen(tmp);
1708  }
1709  strcpy(tmp,"\n");
1710  strcpy(ptr, tmp);
1711 }
1712 
1713 void print_service_float(float *buff, int size)
1714 {
1715 int i;
1716 char *ptr, str[80], tmp[256];
1717 
1718  ptr = Service_content_str;
1719  ptr += strlen(Service_content_str);
1720  for( i = 0; i < size; i++)
1721  {
1722  strcpy(tmp,"");
1723  if(i%4 == 0)
1724  {
1725  if(i != 0)
1726  {
1727  strcat(tmp," ");
1728  }
1729  sprintf(str," %5d: ",i);
1730  strcat(tmp,str);
1731  }
1732  sprintf(str,"%12.3G",*(buff++));
1733  strcat(tmp,str);
1734  if((i%4 == 3) || (i == size-1))
1735  {
1736  strcat(tmp,"\n");
1737  }
1738  strcpy(ptr, tmp);
1739  ptr += strlen(tmp);
1740  }
1741  strcpy(tmp,"\n");
1742  strcpy(ptr, tmp);
1743  ptr += strlen(tmp);
1744 }
1745 
1746 void print_service_double(double *buff, int size)
1747 {
1748 int i;
1749 char *ptr, str[80], tmp[256];
1750 
1751  ptr = Service_content_str;
1752  ptr += strlen(Service_content_str);
1753  for( i = 0; i < size; i++)
1754  {
1755  strcpy(tmp,"");
1756  if(i%4 == 0)
1757  {
1758  if(i != 0)
1759  {
1760  strcat(tmp," ");
1761  }
1762  sprintf(str," %5d: ",i);
1763  strcat(tmp,str);
1764  }
1765  sprintf(str,"%12.3G",*(buff++));
1766  strcat(tmp,str);
1767  if((i%4 == 3) || (i == size-1))
1768  {
1769  strcat(tmp,"\n");
1770  }
1771  strcpy(ptr, tmp);
1772  ptr += strlen(tmp);
1773  }
1774  strcpy(tmp,"\n");
1775  strcpy(ptr, tmp);
1776  ptr += strlen(tmp);
1777 }
1778 
1779 void ok_pop_up (Widget w, long tag, unsigned long *reason)
1780 {
1781 Widget id, sel_id;
1782 char *str, *pstr;
1783 void recv_service_info();
1784 void did_prepare_command();
1785 void show_servers();
1786 
1787 /*
1788  if(tag == 5)
1789  {
1790  id = (Widget)XmSelectionBoxGetChild(w,XmDIALOG_TEXT);
1791  str = (char *)XmTextGetString(id);
1792  if(!str[0])
1793  {
1794  XtFree(str);
1795  return;
1796  }
1797  if( ( fptr = fopen( str, "w" ) ) == (FILE *)0 )
1798  {
1799  printf("Cannot open: %s for writing\n",str);
1800  return;
1801  }
1802  ptr = &Curr_servp->server;
1803  if (ptr->pid > 0x1000000)
1804  fprintf(fptr,"Server %s (pid = %X) on node %s\n provides %d services :\n",
1805  Curr_servp->name, ptr->pid, ptr->node, ptr->n_services);
1806  else
1807  fprintf(fptr,"Server %s (pid = %d) on node %s\n provides %d services :\n",
1808  Curr_servp->name, ptr->pid, ptr->node, ptr->n_services);
1809  service_ptr = Curr_servp->service_ptr;
1810  for(i=0;i<ptr->n_services; i++)
1811  {
1812  sprintf(str,service_ptr->name);
1813  fprintf(fptr," %s\n",service_ptr->name);
1814  service_ptr++;
1815  }
1816  fclose(fptr);
1817  XtFree(str);
1818  return;
1819  }
1820  if(tag == 4)
1821  {
1822  sel_id = put_selection(4, "Printing...");
1823  id = (Widget)XmSelectionBoxGetChild(sel_id,XmDIALOG_HELP_BUTTON);
1824  XtUnmanageChild(id);
1825 
1826  id = (Widget)XmSelectionBoxGetChild(sel_id,XmDIALOG_APPLY_BUTTON);
1827  XtUnmanageChild(id);
1828  id = (Widget)XmSelectionBoxGetChild(sel_id,XmDIALOG_TEXT);
1829  str = (char *)XmTextGetString(id);
1830  if(!str[0])
1831  {
1832  XtFree(str);
1833  return;
1834  }
1835  ptr = &Curr_servp->server;
1836  if(pstr = strrchr(str,']'))
1837  *(++pstr) = '\0';
1838  if(pstr = strrchr(str,'/'))
1839  *(++pstr) = '\0';
1840  sprintf(txt_str,"%s%s.TXT",str,Curr_servp->name);
1841  XtFree(str);
1842  XmTextSetString(id, txt_str);
1843  return;
1844  }
1845 */
1846  if(reason){}
1847  if(tag == DID_KILL_ALL)
1848  {
1849  dic_cmnd_service("DIS_DNS/KILL_SERVERS",0,0);
1850  return;
1851  }
1852  id = XmSelectionBoxGetChild(w,XmDIALOG_TEXT);
1853  str = XmTextGetString(id);
1854  if(!str[0])
1855  {
1856  XtFree(str);
1857  return;
1858  }
1859  if ((tag == DID_SEL_NODE) || (tag == DID_SEL_SERVICE))
1860  {
1861  strcpy(Curr_view_opt_par, str);
1862  show_servers();
1863  XtFree(str);
1864  }
1865  if(tag == DID_SERVICES)
1866  {
1867  pstr = strchr(str,' ');
1868  if(!pstr)
1869  {
1870  strcpy(Curr_service_name, str);
1871  strcpy(str,"SVC");
1872  }
1873  else
1874  {
1875  pstr++;
1876  strcpy(Curr_service_name, pstr);
1877  }
1878  if(Curr_service_id)
1879  {
1880  dic_release_service(Curr_service_id);
1881  Curr_service_id = 0;
1882  }
1883  if(str[0] == 'S')
1884  {
1885  /*
1886  if((!strstr(pstr,"/SERVICE_LIST")) &&
1887  (!strstr(pstr,"/CLIENT_LIST")) &&
1888  (!strstr(pstr,"/SERVER_LIST")))
1889  {
1890  Curr_service_id = dic_info_service(Curr_service_name,
1891  MONITORED,5,0,0,
1892  recv_service_info,0,
1893  &no_link_int,4);
1894  }
1895  else
1896  {
1897  */
1898  dic_info_service_stamped(Curr_service_name,
1899  ONCE_ONLY,10,0,0,
1900  recv_service_info,0,
1901  &no_link_int,4);
1902  /*
1903  }
1904  */
1905  put_selection(DID_SERVICE,"Service Contents");
1906  }
1907  else
1908  {
1909  get_service_format();
1910  sel_id = put_selection(DID_COMMAND,"Send Command");
1911  id = XmSelectionBoxGetChild(sel_id,XmDIALOG_HELP_BUTTON);
1912  XtUnmanageChild(id);
1913  id = XmSelectionBoxGetChild(sel_id,XmDIALOG_APPLY_BUTTON);
1914  XtUnmanageChild(id);
1915  id = XmSelectionBoxGetChild(sel_id,XmDIALOG_LIST);
1916  /*
1917  XtUnmanageChild(id);
1918  */
1919  XtUnmapWidget(id);
1920  }
1921  XtFree(str);
1922  }
1923  if(tag == DID_COMMAND)
1924  {
1925  did_prepare_command(str);
1926  XtFree(str);
1927  }
1928 }
1929 
1930 int get_type_size(char type)
1931 {
1932  int size;
1933 
1934  switch(type)
1935  {
1936  case 'L':
1937  case 'l':
1938  size = sizeof(long);
1939  break;
1940  case 'I':
1941  case 'i':
1942  size = sizeof(int);
1943  break;
1944  case 'S':
1945  case 's':
1946  size = sizeof(short);
1947  break;
1948  case 'F':
1949  case 'f':
1950  size = sizeof(float);
1951  break;
1952  case 'D':
1953  case 'd':
1954  size = sizeof(double);
1955  break;
1956  case 'C':
1957  case 'c':
1958  default:
1959  size = 1;
1960  }
1961  return(size);
1962 }
1963 
1964 void did_prepare_command(char *str)
1965 {
1966 char type;
1967 int num;
1968 int size, full_size = 0;
1969 char *ptr;
1970 static int last_size = 0;
1971 static void *last_buffer = 0;
1972 void *buffer_ptr;
1973 char *str_ptr;
1974 void did_read_string(char, int, void **, char **);
1975 
1976  str_ptr = str;
1977  ptr = Curr_service_format;
1978  while(*ptr)
1979  {
1980  type = *ptr++;
1981  if(*ptr == ':')
1982  {
1983  ptr++;
1984  size = get_type_size(type);
1985  sscanf(ptr, "%d", &num);
1986  full_size += size * num;
1987  if( (ptr = strchr(ptr,';')) )
1988  ptr++;
1989  else
1990  break;
1991  }
1992  }
1993 
1994  full_size += 256;
1995  if(full_size > last_size)
1996  {
1997  if(last_size)
1998  free(last_buffer);
1999  last_buffer = malloc((size_t)full_size);
2000  last_size = full_size;
2001  }
2002  buffer_ptr = last_buffer;
2003  ptr = Curr_service_format;
2004  while(*ptr)
2005  {
2006  type = *ptr++;
2007  if(*ptr == ':')
2008  {
2009  ptr++;
2010  sscanf(ptr, "%d", &num);
2011  did_read_string(type, num, &buffer_ptr, &str_ptr);
2012  if(!str_ptr)
2013  break;
2014  if( (ptr = strchr(ptr,';')) )
2015  ptr++;
2016  else
2017  break;
2018  }
2019  else
2020  {
2021  did_read_string(type, 0, &buffer_ptr, &str_ptr);
2022  break;
2023  }
2024  }
2025  full_size = (int) ((char *)buffer_ptr - (char *)last_buffer);
2026  dic_cmnd_service(Curr_service_name,last_buffer,full_size);
2027 }
2028 
2029 int read_str_int(char *str)
2030 {
2031  int i;
2032  if((str[0] == '0') && (str[1] == 'x'))
2033  sscanf(str+2,"%x",&i);
2034  else
2035  sscanf(str,"%d",&i);
2036  return(i);
2037 }
2038 
2039 int read_str_char(char *str, char *cc)
2040 {
2041 
2042  if(str[0] == '\'')
2043  *cc = str[1];
2044  else if(str[0] == '\"')
2045  return(0);
2046  else if((str[0] == '0') && (str[1] == 'x'))
2047  sscanf(str+2,"%x",(int *)cc);
2048  else if(isalpha(str[0]))
2049  return(-1);
2050  else
2051  sscanf(str,"%d",(int *)cc);
2052  return(1);
2053 }
2054 
2055 void did_read_string(char type, int num, void **buffer_ptr, char **str_ptr)
2056 {
2057 int i, ret = 0;
2058 float ff;
2059 double dd;
2060 void *ptr;
2061 char *strp, *ptr1;
2062 char cc;
2063  short s;
2064 
2065  strp = *str_ptr;
2066  ptr = *buffer_ptr;
2067  if(!num)
2068  num = 1000000;
2069  switch(type)
2070  {
2071  case 'L':
2072  case 'l':
2073  case 'I':
2074  case 'i':
2075  for(i = 0; i<num; i++)
2076  {
2077  *(int *)ptr = read_str_int(strp);
2078  ptr = (int *)ptr +1;
2079  if( (strp = strchr(strp,' ')) )
2080  strp++;
2081  else
2082  break;
2083  }
2084  break;
2085  case 'S':
2086  case 's':
2087  for(i = 0; i<num; i++)
2088  {
2089  s = (short)read_str_int(strp);
2090  *((short *)ptr) = s;
2091  ptr = (short *)ptr +1;
2092  if( (strp = strchr(strp,' ')) )
2093  strp++;
2094  else
2095  break;
2096  }
2097  break;
2098  case 'F':
2099  case 'f':
2100  for(i = 0; i<num; i++)
2101  {
2102  sscanf(strp,"%f",&ff);
2103  *(float *)ptr = ff;
2104  ptr = (float *)ptr +1;
2105  if( (strp = strchr(strp,' ')) )
2106  strp++;
2107  else
2108  break;
2109  }
2110  break;
2111  case 'D':
2112  case 'd':
2113  for(i = 0; i<num; i++)
2114  {
2115  sscanf(strp,"%f",&ff);
2116  dd = (double)ff;
2117  *(double *)ptr = dd;
2118  ptr = (double *)ptr +1;
2119  if( (strp = strchr(strp,' ')) )
2120  strp++;
2121  else
2122  break;
2123  }
2124  break;
2125  case 'C':
2126  case 'c':
2127  default:
2128  for(i = 0; i<num; i++)
2129  {
2130  if((ret = read_str_char(strp, &cc)) <= 0)
2131  break;
2132  *(char *)ptr = cc;
2133  ptr = (char *)ptr +1;
2134  if( (strp = strchr(strp,' ')) )
2135  strp++;
2136  else
2137  break;
2138  }
2139  if(ret <= 0)
2140  {
2141  if(!ret)
2142  {
2143  strp++;
2144  }
2145  num = (int)strlen(strp)+1;
2146  strncpy((char *)ptr,strp,(size_t)num);
2147  if( (ptr1 = (char *)strchr((char *)ptr,'\"')) )
2148  {
2149  num--;
2150  *ptr1 = '\0';
2151  }
2152  ptr = (char *)ptr + num;
2153  if( (strp = strchr(strp,' ')) )
2154  strp++;
2155  else
2156  break;
2157  }
2158  }
2159  *buffer_ptr = ptr;
2160  *str_ptr = strp;
2161 }
2162 
2163 void cancel_pop_up (Widget w, int tag, unsigned long *reason)
2164 {
2165  void print_service_formatted();
2166 
2167  if(reason){}
2168  if(tag == MAX_POP_UPS+1)
2169  {
2170  print_service_formatted(Service_buffer,Service_size);
2171  set_something(Content_label_id,XmNlabelString, Service_content_str);
2172  Curr_service_print_type = 0;
2173  }
2174  /*
2175  else if(tag == MAX_POP_UPS+2)
2176  {
2177  print_service_float(Service_buffer, ((Service_size - 1) / 4) + 1);
2178  set_something(Content_label_id,XmNlabelString, Service_content_str);
2179  Curr_service_print_type = 1;
2180  }
2181  else if(tag == MAX_POP_UPS+3)
2182  {
2183  print_service_double(Service_buffer, ((Service_size - 1) / 4) + 1);
2184  set_something(Content_label_id,XmNlabelString, Service_content_str);
2185  Curr_service_print_type = 2;
2186  }
2187  */
2188  else if(tag == MAX_POP_UPS+4)
2189  {
2190 
2191  if((!strstr(Curr_service_name,"/SERVICE_LIST")) &&
2192  (!strstr(Curr_service_name,"/CLIENT_LIST")) &&
2193  (!strstr(Curr_service_name,"/SERVER_LIST")))
2194  {
2195  if(Curr_service_id)
2196  {
2197  dic_release_service(Curr_service_id);
2198  Curr_service_id = 0;
2199  }
2200  Curr_service_id = (int)dic_info_service_stamped(Curr_service_name,
2201  MONITORED,10,0,0,
2202  recv_service_info,0,
2203  &no_link_int,4);
2204  }
2205  XtSetSensitive(w, False);
2206  XtSetSensitive(SubscribeButton, True);
2207  }
2208  else if(tag == MAX_POP_UPS+5)
2209  {
2210 
2211  if((!strstr(Curr_service_name,"/SERVICE_LIST")) &&
2212  (!strstr(Curr_service_name,"/CLIENT_LIST")) &&
2213  (!strstr(Curr_service_name,"/SERVER_LIST")))
2214  {
2215  if(Curr_service_id)
2216  {
2217  dic_release_service(Curr_service_id);
2218  Curr_service_id = 0;
2219  }
2220  Curr_service_id = (int)dic_info_service_stamped(Curr_service_name,
2221  MONITORED,0,0,0,
2222  recv_service_info,0,
2223  &no_link_int,4);
2224  }
2225  XtSetSensitive(w, False);
2226  XtSetSensitive(Subscribe10Button, True);
2227  }
2228 /*
2229  else if(tag == 5)
2230  {
2231  *
2232  XtUnmapWidget(XtParent(pop_widget_id[4]));
2233  *
2234  }
2235 */
2236  else if(tag == DID_SERVICE)
2237  {
2238  if(Curr_service_id)
2239  {
2240  dic_release_service(Curr_service_id);
2241  Curr_service_id = 0;
2242  }
2243  XtUnmanageChild(pop_widget_id[DID_SERVICE]);
2244  free(Service_content_str);
2245  free(Service_buffer);
2246  }
2247 }
2248 
2249 void create_matrix(Widget w, int *tag, unsigned long *reason)
2250 {
2251 
2252  if(reason){}
2253  Matrix_id[*tag] = w;
2254  if(*tag)
2255  XtUnmanageChild(w);
2256  else
2257  Curr_matrix = 0;
2258 }
2259 
2260 void create_label(Widget w, int *tag, unsigned long *reason)
2261 {
2262  if(reason){}
2263  if(!*tag)
2264  Label_id = w;
2265  else
2266  Content_label_id = w;
2267 }
2268 
2269 void switch_matrix()
2270 {
2271  /*
2272  XtUnmanageChild(Matrix_id[Curr_matrix]);
2273  Curr_matrix = (Curr_matrix) ? 0 : 1;
2274  XtManageChild(Matrix_id[Curr_matrix]);
2275  */
2276  XmScrolledWindowSetAreas(Window_id,NULL, NULL, Matrix_id[Curr_matrix]);
2277 }
2278 
2279 /*
2280 static int curr_allocated_size = 0;
2281 static DNS_SERVER_INFO *dns_info_buffer;
2282 */
2283 
2284 void update_servers_new(int *tag, char *buffer, int *size)
2285 {
2286  if(tag){}
2287  if(size){}
2288  printf("Server_list:\n%s\n",buffer);
2289 }
2290 
2291 SERVER *find_server(char *node, int pid)
2292 {
2293  SERVER *servp;
2294  DNS_SERVER_INFO *ptr;
2295 
2296  servp = Server_head;
2297  while( (servp = (SERVER *)sll_get_next((SLL *)servp)) )
2298  {
2299  ptr = &servp->server;
2300  if((ptr->pid == pid) && (!strcmp(ptr->node,node)))
2301  {
2302  return(servp);
2303  }
2304  }
2305  return ((SERVER *)0);
2306 }
2307  /*
2308  if(!(servp = (SERVER *)sll_search((SLL *)Server_head,
2309  (char *)&buffer->server, MAX_NODE_NAME+MAX_TASK_NAME-4)))
2310  */
2311 
2312 
2313 void update_servers(int *tag, DNS_DID *buffer, int *size)
2314 {
2315 int n_services, service_size;
2316 SERVER *servp;
2317 int j;
2318 char str[MAX_NAME], sname[MAX_NAME], *ptr;
2319 
2320  if(tag){}
2321  if(!Server_head)
2322  {
2323  Server_head = (SERVER *)malloc(sizeof(SERVER));
2324  sll_init((SLL *)Server_head);
2325  }
2326  if(First_time)
2327  {
2328  switch_matrix();
2329  First_time = 0;
2330  }
2331 
2332  if(!*size)
2333  return;
2334  if(*(char *)buffer == -1)
2335  {
2336  N_servers = 0;
2337  N_services = 0;
2338  return;
2339  }
2340  buffer->server.n_services = vtohl(buffer->server.n_services);
2341  buffer->server.pid = vtohl(buffer->server.pid);
2342  n_services = buffer->server.n_services;
2343  /*
2344 printf("received pid %d, nservices %d\n",buffer->server.pid, n_services);
2345  */
2346  if(n_services == 1)
2347  return;
2348  strcpy(sname, buffer->server.task);
2349  /*
2350 printf("name = %s\n", sname);
2351  */
2352  if(n_services > 1)
2353  {
2354  for(j = 0; j < n_services; j++)
2355  {
2356  buffer->services[j].type = vtohl(
2357  buffer->services[j].type);
2358  buffer->services[j].status = vtohl(
2359  buffer->services[j].status);
2360  buffer->services[j].n_clients = vtohl(
2361  buffer->services[j].n_clients);
2362  if(strlen(sname) == MAX_TASK_NAME-4-1)
2363  {
2364  strcpy(str,buffer->services[j].name);
2365  if( (ptr = strstr(str,"/CLIENT_LIST")) )
2366  {
2367  *ptr = '\0';
2368  strcpy(sname,str);
2369  }
2370  }
2371  }
2372  }
2373  if (!(servp = find_server(buffer->server.node,buffer->server.pid)))
2374  /*
2375  if(!(servp = (SERVER *)sll_search((SLL *)Server_head,
2376  (char *)&buffer->server, MAX_NODE_NAME+MAX_TASK_NAME-4)))
2377  */
2378  {
2379  if(n_services)
2380  {
2381  servp = (SERVER *)malloc(sizeof(SERVER));
2382  strcpy(servp->name,sname);
2383  servp->next = 0;
2384  servp->button_id = 0;
2385  servp->pop_widget_id[0] = 0;
2386  servp->pop_widget_id[1] = 0;
2387  servp->busy = 0;
2388  servp->server.n_services = 0;
2389  servp->service_ptr = 0;
2390  sll_insert_queue((SLL *)Server_head,(SLL *)servp);
2391  }
2392  }
2393  if(n_services != 0)
2394  {
2395  if(n_services == servp->server.n_services)
2396  {
2397  return;
2398  }
2399  if(servp->server.n_services == 0)
2400  N_servers++;
2401  if(servp->server.n_services != -1)
2402  N_services -= servp->server.n_services;
2403  memcpy(&servp->server,&buffer->server,sizeof(DNS_SERVER_INFO));
2404  if(servp->service_ptr)
2405  {
2406  free(servp->service_ptr);
2407  servp->service_ptr = 0;
2408  }
2409  if(n_services != -1)
2410  {
2411  service_size = n_services*(int)sizeof(DNS_SERVICE_INFO);
2412  servp->service_ptr = (DNS_SERVICE_INFO *)malloc((size_t)service_size);
2413  memcpy(servp->service_ptr, buffer->services, (size_t)service_size);
2414  N_services += n_services;
2415  }
2416  servp->busy = 1;
2417  if(strcmp(servp->name, sname))
2418  {
2419  strcpy(servp->name,sname);
2420  Force_update = 1;
2421  servp->busy = 3;
2422  }
2423  }
2424  else
2425  {
2426  if(servp)
2427  {
2428  N_servers--;
2429  if(servp->server.n_services != -1)
2430  {
2431  N_services -= servp->server.n_services;
2432  }
2433  else
2434  Force_update = 1;
2435  servp->server.n_services = 0;
2436  servp->busy = -1;
2437  }
2438  }
2439 }
2440 
2441 void show_servers()
2442 {
2443 SERVER *servp;
2444 void update_show_servers();
2445 void remove_all_buttons();
2446 void put_label();
2447 
2448  if(!Matrix_id[Curr_matrix])
2449  return;
2450  remove_all_buttons();
2451 
2452 #ifndef linux
2453  switch_matrix();
2454 #endif
2455  put_label();
2456  servp = Server_head;
2457  while( (servp = (SERVER *)sll_get_next((SLL *)servp)) )
2458  {
2459  servp->busy = 1;
2460  }
2461  Force_update = 1;
2462 }
2463 
2464 void update_show_servers(void *tag, unsigned long *reason)
2465 {
2466 DNS_SERVER_INFO *server_ptr;
2467 DNS_SERVICE_INFO *service_ptr;
2468 int i, j, found, n_done = 0;
2469 Widget w, create_button();
2470 SERVER *servp, *prevp;
2471 static int old_n_services = 0;
2472 char node[MAX_NODE_NAME], par[MAX_NODE_NAME], *ptr;
2473 void remove_button();
2474 void remove_all_buttons();
2475 void put_label();
2476 
2477  DISABLE_AST
2478  if(tag){}
2479  if(reason){}
2480  if((N_services != old_n_services) || (Force_update))
2481  {
2482  if(!Matrix_id[Curr_matrix])
2483  {
2484  XtAppAddTimeOut(app_context, 1000, update_show_servers, 0);
2485  ENABLE_AST
2486  return;
2487  }
2488  if(!N_servers)
2489  {
2490  remove_all_buttons();
2491  if(! No_link_button_id)
2492  {
2493  No_link_button_id = create_button("DNS is down", 0);
2494  set_color(No_link_button_id, XmNbackground, RED);
2495  get_something(No_link_button_id,XmNuserData,&w);
2496  set_color(w, XmNbackground, RED);
2497  XtSetSensitive(No_link_button_id, False);
2498  }
2499  while(!sll_empty((SLL *)Server_head))
2500  {
2501  servp = (SERVER *)sll_remove_head((SLL *)Server_head);
2502  if(servp->service_ptr)
2503  free(servp->service_ptr);
2504  free(servp);
2505  }
2506  put_label();
2507  old_n_services = N_services;
2508  Force_update = 0;
2509  XtAppAddTimeOut(app_context, 1000, update_show_servers, 0);
2510  ENABLE_AST
2511  return;
2512  }
2513  if(No_link_button_id)
2514  {
2515  XtDestroyWidget(No_link_button_id);
2516  /*
2517  XFlush(XtDisplay(No_link_button_id));
2518  */
2519  No_link_button_id = 0;
2520  }
2521  servp = Server_head;
2522  prevp = 0;
2523  while( (servp = (SERVER *)sll_get_next((SLL *)servp)) )
2524  {
2525  if(prevp)
2526  {
2527  free(prevp);
2528  prevp = 0;
2529  }
2530  if(n_done == 10)
2531  {
2532  if(!Force_update)
2533  put_label();
2534  XtAppAddTimeOut(app_context, 100, update_show_servers, 0);
2535  ENABLE_AST
2536  return;
2537  }
2538  server_ptr = &servp->server;
2539  if(servp->busy == 3)
2540  {
2541  remove_button(servp);
2542  servp->busy = 1;
2543  }
2544  if(servp->busy == 1)
2545  {
2546  if(!servp->button_id)
2547  {
2548  switch(Curr_view_opt)
2549  {
2550  case 1 :
2551  servp->button_id = create_button(/*server_ptr->task*/servp->name, servp);
2552  n_done++;
2553  break;
2554  case 0 :
2555  strcpy(node, server_ptr->node);
2556  strcpy(par, Curr_view_opt_par);
2557  if(!isdigit(node[0]))
2558  {
2559  ptr = strchr(node, '.');
2560  if(ptr)
2561  *ptr = '\0';
2562  ptr = strchr(par,'.');
2563  if(ptr)
2564  *ptr = '\0';
2565  }
2566  ptr = node;
2567  for(i = 0; i < (int)strlen(ptr); i++)
2568  ptr[i] = (char)tolower((int)ptr[i]);
2569  ptr = par;
2570  for(i = 0; i < (int)strlen(ptr); i++)
2571  ptr[i] = (char)tolower((int)ptr[i]);
2572  if(!strcmp(/*server_ptr->*/node, /*Curr_view_opt_*/par))
2573  {
2574  servp->button_id = create_button(/*server_ptr->task*/servp->name, servp);
2575  n_done++;
2576  }
2577  break;
2578  case 2 :
2579  found = 0;
2580  if(!(service_ptr = servp->service_ptr))
2581  break;
2582  for(j = 0; j < server_ptr->n_services; j++)
2583  {
2584  if(strstr(service_ptr->name, Curr_view_opt_par) > (char *)0)
2585  {
2586  found = 1;
2587  break;
2588  }
2589  service_ptr++;
2590  }
2591  if (found)
2592  {
2593  servp->button_id = create_button(/*server_ptr->task*/servp->name, servp);
2594  n_done++;
2595  }
2596  break;
2597  case 3 :
2598  if(server_ptr->n_services == -1)
2599  {
2600  servp->button_id = create_button(/*server_ptr->task*/servp->name, servp);
2601  n_done++;
2602  }
2603  else
2604  {
2605  if(servp->button_id)
2606  remove_button(servp);
2607  }
2608  n_done++;
2609  break;
2610  }
2611  }
2612  servp->busy = 2;
2613  if(servp->button_id)
2614  {
2615  if(Curr_view_opt != -1)
2616  {
2617  if (server_ptr->n_services == -1)
2618  {
2619  set_color(servp->button_id, XmNbackground, RED);
2620  get_something(servp->button_id,XmNuserData,&w);
2621  set_color(w, XmNbackground, RED);
2622  }
2623  else
2624  {
2625  set_color(servp->button_id, XmNbackground, GREEN);
2626  get_something(servp->button_id,XmNuserData,&w);
2627  set_color(w, XmNbackground, GREEN);
2628  }
2629  }
2630  }
2631  }
2632  else if (servp->busy == -1)
2633  {
2634  remove_button(servp);
2635  sll_remove((SLL *)Server_head, (SLL *)servp);
2636  if(servp->service_ptr)
2637  {
2638  free(servp->service_ptr);
2639  servp->service_ptr = 0;
2640  }
2641  prevp = servp;
2642  n_done++;
2643  }
2644  }
2645  if(prevp)
2646  {
2647  free(prevp);
2648  prevp = 0;
2649  }
2650  put_label();
2651  old_n_services = N_services;
2652  Force_update = 0;
2653  }
2654  XtAppAddTimeOut(app_context, 1000, update_show_servers, 0);
2655  ENABLE_AST
2656 }
2657 
2658 Widget create_button(char *name, SERVER *servp)
2659 {
2660 Arg arglist[10];
2661 int n;
2662 /*
2663 int n_services = -1;
2664 */
2665 Widget w, ww, w_id;
2666 void activate_services(), activate_clients();
2667 char w_name[MAX_NAME];
2668 
2669  w_name[0] = 0;
2670 /*
2671  if(servp)
2672  n_services = servp->server.n_services;
2673 */
2674  strcpy(w_name,name);
2675  if(strlen(w_name) >= MAX_TASK_NAME - 4)
2676  w_name[16] = '\0';
2677  n = 0;
2678  XtSetArg(arglist[n], XmNorientation, XmVERTICAL); n++;
2679  XtSetArg(arglist[n], XmNentryAlignment, XmALIGNMENT_CENTER); n++;
2680  w_id = w = XmCreateMenuBar(Matrix_id[Curr_matrix],
2681  (String)XmStringCreateLtoR ( w_name,XmSTRING_DEFAULT_CHARSET),
2682  arglist,(Cardinal)n);
2683 /*
2684  if(n_services == -1)
2685  set_color(w, XmNbackground, RED);
2686  else
2687  set_color(w, XmNbackground, GREEN);
2688 */
2689  XtManageChild(w);
2690  strcat(w_name,"1");
2691  n = 0;
2692  XtSetArg(arglist[n], XmNalignment, XmALIGNMENT_CENTER); n++;
2693  XtSetArg(arglist[n], XmNfontList, did_server_font); n++;
2694  w = XmCreateCascadeButton(w,
2695  (String)XmStringCreateLtoR ( w_name,XmSTRING_DEFAULT_CHARSET),
2696  arglist,(Cardinal)n);
2697  set_something(w,XmNlabelString,name);
2698  set_something(w,XmNalignment,XmALIGNMENT_CENTER);
2699 /*
2700  if(n_services == -1)
2701  set_color(w, XmNbackground, RED);
2702  else
2703  set_color(w, XmNbackground, GREEN);
2704 */
2705  set_something(w_id,XmNuserData,w);
2706  strcat(w_name,"1");
2707  n = 0;
2708  ww = XmCreatePulldownMenu(w_id,
2709  (String)XmStringCreateLtoR ( w_name,XmSTRING_DEFAULT_CHARSET),
2710  arglist,(Cardinal)n);
2711  set_something(w,XmNsubMenuId,ww);
2712  XtManageChild(w);
2713  strcat(w_name,"1");
2714  n = 0;
2715  XtSetArg(arglist[n], XmNfontList, did_default_font); n++;
2716  w = XmCreatePushButton(ww,
2717  (String)XmStringCreateLtoR ( w_name,XmSTRING_DEFAULT_CHARSET),
2718  arglist,(Cardinal)n);
2719 
2720  set_something(w,XmNlabelString,"Services");
2721  if(servp)
2722  {
2723  XtAddCallback(w,XmNactivateCallback, activate_services, servp);
2724  XtManageChild(w);
2725  strcat(w_name,"1");
2726  n = 0;
2727  XtSetArg(arglist[n], XmNfontList, did_default_font); n++;
2728  w = XmCreatePushButton(ww,
2729  (String)XmStringCreateLtoR ( w_name,XmSTRING_DEFAULT_CHARSET),
2730  arglist,(Cardinal)n);
2731 
2732  set_something(w,XmNlabelString,"Clients");
2733  XtAddCallback(w,XmNactivateCallback, activate_clients, servp);
2734  XtManageChild(w);
2735  /*
2736  servp->popping = 0;
2737  create_client_popup(servp);
2738  */
2739  }
2740  return(w_id);
2741 }
2742 
2743 void remove_all_buttons()
2744 {
2745 SERVER *servp;
2746 
2747  servp = Server_head;
2748  while( (servp = (SERVER *)sll_get_next((SLL *)servp)) )
2749  {
2750  if(servp->button_id)
2751  {
2752  XtDestroyWidget(servp->button_id);
2753  servp->button_id = 0;
2754  servp->busy = 0;
2755  }
2756  }
2757 }
2758 
2759 void remove_button(SERVER *servp)
2760 {
2761 
2762  if(servp->button_id)
2763  {
2764  XtDestroyWidget(servp->button_id);
2765  servp->button_id = 0;
2766  servp->busy = 0;
2767  }
2768 }
2769 
2770 void activate_services(Widget w, SERVER *servp, unsigned long *reason)
2771 {
2772 DNS_SERVER_INFO *ptr;
2773 char str[MAX_NAME];
2774 Widget id,sel_id;
2775 void got_service_list();
2776 void kick_it();
2777 
2778  if(w){}
2779  if(reason){}
2780  if(servp->pop_widget_id[0])
2781  {
2782  XtDestroyWidget(servp->pop_widget_id[0]);
2783  servp->pop_widget_id[0] = 0;
2784  /*
2785  return;
2786  */
2787  }
2788  Curr_servp = servp;
2789  ptr = &servp->server;
2790 
2791  sel_id = put_popup(servp, 0,"Service Info");
2792 
2793  id = XmSelectionBoxGetChild(sel_id,XmDIALOG_OK_BUTTON);
2794  XtUnmanageChild(id);
2795 
2796  id = XmSelectionBoxGetChild(sel_id,XmDIALOG_LIST_LABEL);
2797  if (ptr->pid > 0x1000000)
2798  sprintf(str,"Server %s (pid = %X) on node %s\n\nprovides %d services :\n",
2799  servp->name, ptr->pid, ptr->node, ptr->n_services);
2800  else
2801  sprintf(str,"Server %s (pid = %d) on node %s\n\nprovides %d services :\n",
2802  servp->name, ptr->pid, ptr->node, ptr->n_services);
2803  set_something(sel_id,XmNlistLabelString,str);
2804 
2805  id = XmSelectionBoxGetChild(sel_id,XmDIALOG_LIST);
2806  Curr_service_list_id = id;
2807 
2808  XmListAddItem(id,create_str(
2809  "Ordering services alphabeticaly, please be patient..."),1);
2810 
2811  set_something(id,XmNlistItemCount,1);
2812  set_something(id,XmNlistVisibleItemCount,1);
2813 
2814  sprintf(str,"%s/SERVICE_LIST",/*ptr->task*/servp->name);
2815  dic_info_service(str,ONCE_ONLY,20,0,0,
2816  got_service_list,(long)servp,"None",5);
2817  /*
2818 #ifdef solaris
2819  */
2820  /*
2821  XtAppAddTimeOut(app_context, 1000, kick_it, 0);
2822  */
2823  /*
2824 #endif
2825  */
2826 }
2827 
2828 void kick_it()
2829 {
2830  printf("kick_it\n");
2831 }
2832 
2833 typedef char DID_SLOT[MAX_NAME];
2834 
2835 void got_service_list(SERVER **servp_ptr, char *buffer, int *size)
2836 {
2837 SERVER *servp;
2838 void do_got_service_list();
2839 
2840  if(size){}
2841  servp = *servp_ptr;
2842  if(Curr_service_list)
2843  free(Curr_service_list);
2844  Curr_service_list = malloc(strlen(buffer)+1);
2845  strcpy(Curr_service_list, buffer);
2846  /*
2847 #ifdef solaris
2848  */
2849  Got_Service_List = servp;
2850  /*
2851 #else
2852  do_got_service_list(servp);
2853 #endif
2854  */
2855 }
2856 
2857 void do_got_service_list(SERVER *servp)
2858 {
2859 char cmd_str[256], svc_str[256];
2860 DNS_SERVER_INFO *ptr;
2861 DNS_SERVICE_INFO *service_ptr;
2862 Widget id;
2863 char *curr_str, max_str[MAX_NAME], *sptr;
2864 DID_SLOT *service_list;
2865 int i, j, curr_index = 0, n_services;
2866 XmString xstr;
2867 void delete_str();
2868 
2869  ptr = &servp->server;
2870  id = Curr_service_list_id;
2871 
2872  XmListDeleteAllItems(id);
2873 
2874  strcpy(cmd_str,"CMD: ");
2875  strcpy(svc_str,"SVC: ");
2876 
2877  service_ptr = servp->service_ptr;
2878  service_list = (DID_SLOT *)malloc((size_t)(ptr->n_services * MAX_NAME));
2879  n_services = ptr->n_services;
2880 
2881  for(i=0;i<n_services; i++)
2882  {
2883  strcpy(service_list[i],service_ptr->name);
2884  service_ptr++;
2885  }
2886  strcpy(max_str,"zzzzzzzzzzzzzzzzzzzzzzzzzzzz");
2887  for(i=0;i<n_services; i++)
2888  {
2889  curr_str = max_str;
2890  for(j=0;j<n_services; j++)
2891  {
2892  sptr = service_list[j];
2893  if(!*sptr)
2894  continue;
2895 
2896  if(strcmp(sptr,curr_str) < 0)
2897  {
2898  curr_str = sptr;
2899  curr_index = j;
2900  }
2901  }
2902  service_list[curr_index][0] = '\0';
2903  service_ptr = &(servp->service_ptr[curr_index]);
2904  if(service_ptr->type)
2905  {
2906  strcpy(&cmd_str[5],service_ptr->name);
2907  xstr = create_str(cmd_str);
2908  XmListAddItem(id,xstr,i+1);
2909  delete_str(xstr);
2910  }
2911  else
2912  {
2913  strcpy(&svc_str[5],service_ptr->name);
2914  xstr = create_str(svc_str);
2915  XmListAddItem(id,xstr,i+1);
2916  delete_str(xstr);
2917  }
2918  }
2919  free(service_list);
2920 
2921  set_something(id,XmNlistItemCount,i);
2922  set_something(id,XmNlistVisibleItemCount,(i < 20) ? i : 20);
2923 }
2924 
2925 void show_clients(SERVER **servp_ptr, char *buffer, int *size)
2926 {
2927 SERVER *servp;
2928 void do_show_clients();
2929 
2930  if(size){}
2931  servp = *servp_ptr;
2932  if(Curr_client_list)
2933  free(Curr_client_list);
2934  Curr_client_list = malloc(strlen(buffer)+1);
2935  strcpy(Curr_client_list, buffer);
2936  /*
2937 #ifdef solaris
2938  */
2939  Got_Client_List = servp;
2940  /*
2941 #else
2942  do_show_clients(servp);
2943 #endif
2944  */
2945 }
2946 
2947 void do_show_clients(SERVER *servp)
2948 {
2949 int i = 0;
2950 char str[2048], *strp, *strp1;
2951 XmString xstr;
2952 void delete_str();
2953 
2954 /*
2955 DNS_SERVER_INFO *ptr;
2956  ptr = &servp->server;
2957  sel_id = servp->pop_widget_id[1];
2958  id = (Widget)XmSelectionBoxGetChild(sel_id,XmDIALOG_LIST_LABEL);
2959 */
2960  if(servp){}
2961  if(Curr_client_list[0] == -1)
2962  {
2963  sprintf(str,"Information not available\n");
2964  XmListAddItem(Curr_client_id,create_str(str),i+1);
2965  /*
2966  set_something(sel_id,XmNlistLabelString,str);
2967  */
2968  return;
2969  }
2970  /*
2971  sprintf(str,"Clients of %s are : \n",
2972  ptr->task);
2973  set_something(sel_id,XmNlistLabelString,str);
2974 
2975  id = (Widget)XmSelectionBoxGetChild(sel_id,XmDIALOG_LIST);
2976  XmListDeleteAllItems(id);
2977  */
2978  strp1 = Curr_client_list;
2979  while(strp1)
2980  {
2981  if(!*strp1)
2982  break;
2983  sprintf(str,"Process ");
2984  strp = strp1;
2985  strp1 = strchr(strp,'@');
2986  *strp1 = '\0';
2987  strp1++;
2988  strcat(str,strp);
2989  strcat(str," on node ");
2990  strp = strp1;
2991  if( (strp1 = strchr(strp,'|')) )
2992  {
2993  *strp1 = '\0';
2994  strp1++;
2995  }
2996  strcat(str,strp);
2997  xstr = create_str(str);
2998  XmListAddItem(Curr_client_id,xstr,i+1);
2999  delete_str(xstr);
3000  i++;
3001  }
3002  if(!i)
3003  {
3004  sprintf(str,"NONE");
3005  xstr = create_str(str);
3006  XmListAddItem(Curr_client_id,xstr,i+1);
3007  delete_str(xstr);
3008  }
3009  /*
3010  set_something(id,XmNlistItemCount,i);
3011  */
3012  /*
3013  if(Matrix_id[Curr_matrix])
3014  XFlush(XtDisplay(Matrix_id[Curr_matrix]));
3015  */
3016 }
3017 
3018 void activate_clients(Widget w, SERVER *servp, unsigned long *reason)
3019 {
3020 /*
3021 DNS_SERVER_INFO *ptr;
3022 */
3023 char str[100];
3024 void show_clients();
3025 void kick_it_again();
3026 Widget id,sel_id;
3027 
3028  if(w) {}
3029  if(reason){}
3030  Curr_servp = servp;
3031 /*
3032  ptr = &servp->server;
3033 */
3034  if(servp->pop_widget_id[1])
3035  {
3036  XtDestroyWidget(servp->pop_widget_id[1]);
3037  servp->pop_widget_id[1] = 0;
3038  }
3039  sel_id = put_popup(servp,1,"Client Info");
3040 
3041  id = XmSelectionBoxGetChild(sel_id,XmDIALOG_HELP_BUTTON);
3042  XtUnmanageChild(id);
3043 
3044  id = XmSelectionBoxGetChild(sel_id,XmDIALOG_APPLY_BUTTON);
3045  XtUnmanageChild(id);
3046 
3047  id = XmSelectionBoxGetChild(sel_id,XmDIALOG_CANCEL_BUTTON);
3048  XtUnmanageChild(id);
3049 
3050  id = XmSelectionBoxGetChild(sel_id,XmDIALOG_TEXT);
3051  XtUnmanageChild(id);
3052 
3053  id = XmSelectionBoxGetChild(sel_id,XmDIALOG_SELECTION_LABEL);
3054  XtUnmanageChild(id);
3055  /*
3056  id = (Widget)XmSelectionBoxGetChild(sel_id,XmDIALOG_LIST_LABEL);
3057  */
3058  id = XmSelectionBoxGetChild(sel_id,XmDIALOG_LIST);
3059  XmListDeleteAllItems(id);
3060 
3061  Curr_client_id = id;
3062  sprintf(str,"Clients of %s are : \n",
3063  servp->name);
3064  set_something(sel_id,XmNlistLabelString,str);
3065 
3066  sprintf(str,"%s/CLIENT_LIST",/*ptr->task*/servp->name);
3067  dic_info_service(str,ONCE_ONLY,10,0,0,
3068  show_clients,(long)servp,&no_link,1);
3069  /*
3070 #ifdef solaris
3071  */
3072  /*
3073  XtAppAddTimeOut(app_context, 1000, kick_it_again, 0);
3074  */
3075  /*
3076 #endif
3077  */
3078 }
3079 
3080 void kick_it_again()
3081 {
3082  printf("kick_it_again\n");
3083 }
3084 
3085 Widget put_popup(SERVER *servp, int type, char *title)
3086 {
3087  Widget id;
3088  void activate_services(), activate_clients();
3089  extern void set_title();
3090 
3091  if(type)
3092  {
3093  id = create_client_dialog();
3094  /*
3095  XtAddCallback(id,XmNokCallback, activate_clients, servp);
3096  XtAddCallback(id,XmNcancelCallback, activate_clients, servp);
3097  */
3098  }
3099  else
3100  {
3101  id = create_server_dialog();
3102  /*
3103  XtAddCallback(id,XmNcancelCallback, activate_services, servp);
3104  */
3105  }
3106  servp->pop_widget_id[type] = id;
3107  /*
3108  }
3109  */
3110  XtManageChild(id);
3111  set_title(XtParent(id),title);
3112  return(id);
3113 }
3114 
3115 Widget put_selection(int tag, char *title)
3116 {
3117  Widget id = 0;
3118  extern void set_title();
3119 
3120  if(pop_widget_id[tag])
3121  {
3122  XtDestroyWidget(pop_widget_id[tag]);
3123  }
3124  switch(tag)
3125  {
3126  case DID_SEL_NODE:
3127  id = create_node_selection();
3128  break;
3129  case DID_SEL_SERVICE:
3130  id = create_service_selection();
3131  break;
3132  case DID_KILL_ALL:
3133  id = create_kill_confirmation();
3134  break;
3135  case DID_SERVICE:
3136  id = create_service_dialog();
3137  break;
3138  case DID_COMMAND:
3139  id = create_send_command();
3140  break;
3141  }
3142 
3143  pop_widget_id[tag] = id;
3144  XtManageChild(id);
3145  set_title(XtParent(id),title);
3146  return(id);
3147 }
3148 
3149 void check_put_label(int tag)
3150 {
3151  static int old_n_services = 0;
3152 /*
3153  static int changing = 0;
3154 */
3155  void put_label();
3156 
3157  if(tag){}
3158  if(N_services != old_n_services)
3159  {
3160  put_label();
3161 /*
3162  if(N_services > old_n_services)
3163  changing = 1;
3164 */
3165  old_n_services = N_services;
3166 
3167 #ifdef linux
3168  show_servers();
3169 #endif
3170  }
3171 /*
3172  else
3173  {
3174  if(changing)
3175  {
3176  show_servers();
3177  changing = 0;
3178  }
3179  }
3180 */
3181 }
3182 
3183 void put_label()
3184 {
3185  char str[MAX_NAME], str1[MAX_NAME];
3186 
3187  DISABLE_AST
3188  sprintf(str,"%d Servers known - %d Services Available\n",
3189  N_servers,N_services);
3190  switch(Curr_view_opt)
3191  {
3192  case 1 :
3193  strcat(str,"Displaying ALL Servers");
3194  break;
3195  case 0 :
3196  sprintf(str1,"Displaying Servers on node %s",Curr_view_opt_par);
3197  strcat(str,str1);
3198  break;
3199  case 2 :
3200  sprintf(str1,"Displaying Servers providing Service *%s*",
3201  Curr_view_opt_par);
3202  strcat(str,str1);
3203  break;
3204  case 3 :
3205  strcat(str,"Displaying Servers in ERROR");
3206  break;
3207  case -1 :
3208  strcat(str,"Please Select Viewing Option");
3209  break;
3210  }
3211  set_something(Label_id,XmNlabelString,str);
3212  XFlush(XtDisplay(Label_id));
3213  ENABLE_AST
3214 }
3215 
3216 Widget create_client_dialog()
3217 {
3218  Widget id;
3219  id = create_selection_dialog("Dismiss","","","","",DID_CLIENTS, 3);
3220  return(id);
3221 
3222 }
3223 
3224 Widget create_server_dialog()
3225 {
3226  Widget id;
3227  id = create_selection_dialog("","View / Send","Dismiss","",
3228  "Service / Command :",
3229  DID_SERVICES, 20);
3230  return(id);
3231 }
3232 
3233 Widget create_node_selection()
3234 {
3235  Widget id;
3236  id = create_selection_dialog("","","","Nodes :","Selected Node :",DID_SEL_NODE, 8);
3237  return(id);
3238 
3239 }
3240 
3241 Widget create_service_selection()
3242 {
3243  Widget id;
3244  /*
3245  id = create_prompt_dialog("Enter Service Name :",DID_SEL_SERVICE);
3246  */
3247  id = create_selection_dialog("","","","","Enter Service Name (or search string):",DID_SEL_SERVICE, 0);
3248  return(id);
3249 
3250 }
3251 
3252 Widget create_send_command()
3253 {
3254  Widget id;
3255  char str[256], str1[256];
3256 
3257  sprintf(str,"Command to %s (%s)\n\n",
3258  Curr_service_name, Curr_service_format);
3259 
3260  id = create_selection_dialog("","","",str,"Command:",DID_COMMAND, 1);
3261 
3262  strcpy(str1,"Please enter items separated by spaces:\n(for example: 2 0x123 'A' 23.4 \"a text\")");
3263 
3264  set_something(id,XmNselectionLabelString,str1);
3265 
3266  return(id);
3267 
3268 }
3269 
3270 Widget create_kill_confirmation()
3271 {
3272  Widget id;
3273  id = create_question_dialog("Do you really want to kill ALL DIM servers ?",
3274  DID_KILL_ALL);
3275  return(id);
3276 
3277 }
3278 
3279 Widget create_selection_dialog(char *ok, char *apply, char *cancel, char *list, char *sel,
3280  long tag, int items)
3281 {
3282 Widget sd;
3283 XmString xmOk, xmApply, xmCancel, xmList, xmSelection;
3284 Arg ar[20];
3285 int n;
3286 
3287  xmList = create_str(list);
3288  xmOk = create_str(ok);
3289  xmApply = create_str(apply);
3290  xmCancel = create_str (cancel);
3291  xmSelection = create_str (sel);
3292 
3293  n = 0;
3294  /*
3295  XtSetArg(ar[n],XmNdialogStyle,XmDIALOG_FULL_APPLICATION_MODAL); n++;
3296  XtSetArg(ar[n],XmNmwmFunctions,MWM_FUNC_MOVE); n++;
3297  */
3298  XtSetArg(ar[n],XmNtitle,"Selection"); n++;
3299  XtSetArg(ar[n],XmNlabelFontList, did_default_font); n++;
3300  XtSetArg(ar[n],XmNbuttonFontList, did_default_font); n++;
3301  XtSetArg(ar[n],XmNtextFontList, did_small_font); n++;
3302  XtSetArg(ar[n],XmNborderWidth, 1); n++;
3303  XtSetArg(ar[n],XmNlistLabelString, xmList); n++;
3304  XtSetArg(ar[n],XmNlistVisibleItemCount,items); n++;
3305  if(ok[0])
3306  {
3307  XtSetArg(ar[n],XmNokLabelString, xmOk); n++;
3308  }
3309  if(apply[0])
3310  {
3311  XtSetArg(ar[n],XmNapplyLabelString, xmApply); n++;
3312  }
3313  if(cancel[0])
3314  {
3315  XtSetArg(ar[n],XmNcancelLabelString, xmCancel); n++;
3316  }
3317  if(sel[0])
3318  {
3319  XtSetArg(ar[n],XmNselectionLabelString, xmSelection); n++;
3320  }
3321  sd = XmCreateSelectionDialog ( toplevel_widget, "Selection", ar, (Cardinal)n );
3322  XmStringFree(xmList);
3323  XmStringFree(xmOk);
3324  XmStringFree(xmApply);
3325  XmStringFree(xmCancel);
3326  XmStringFree(xmSelection);
3327  if(tag >= 0)
3328  {
3329  XtAddCallback ( sd, XmNcancelCallback,
3330  (XtCallbackProc)cancel_pop_up, (XtPointer)tag );
3331  XtAddCallback ( sd, XmNapplyCallback,
3332  (XtCallbackProc)ok_pop_up, (XtPointer)tag );
3333  XtAddCallback ( sd, XmNokCallback,
3334  (XtCallbackProc)ok_pop_up, (XtPointer)tag );
3335  }
3336  return(sd);
3337 }
3338 
3339 Widget create_file_selection_dialog(long type)
3340 {
3341 Widget sd;
3342 XmString xm1;
3343 Arg ar[20];
3344 int n;
3345 
3346  xm1 = create_str ("");
3347  n = 0;
3348  /*
3349  XtSetArg(ar[n],XmNdialogStyle,XmDIALOG_FULL_APPLICATION_MODAL); n++;
3350  XtSetArg(ar[n],XmNmwmFunctions,MWM_FUNC_MOVE); n++;
3351  */
3352  XtSetArg(ar[n],XmNtitle,"FileSelection"); n++;
3353  XtSetArg(ar[n],XmNlabelFontList, did_default_font); n++;
3354  XtSetArg(ar[n],XmNbuttonFontList, did_default_font); n++;
3355  XtSetArg(ar[n],XmNtextFontList, did_default_font); n++;
3356  XtSetArg(ar[n],XmNborderWidth, 1); n++;
3357  XtSetArg(ar[n],XmNwidth, 500); n++;
3358  XtSetArg(ar[n],XmNdirMask, xm1); n++;
3359  sd = XmCreateFileSelectionDialog ( toplevel_widget, "FileSelection", ar, (Cardinal)n );
3360 
3361  XmStringFree(xm1);
3362 
3363  XtAddCallback ( sd, XmNcancelCallback,
3364  (XtCallbackProc)cancel_pop_up, (XtPointer)type );
3365  XtAddCallback ( sd, XmNokCallback,
3366  (XtCallbackProc)ok_pop_up, (XtPointer)type );
3367 
3368  return(sd);
3369 }
3370 
3371 Widget create_prompt_dialog(char *label, long tag)
3372 {
3373 Widget sd;
3374 XmString xm1;
3375 Arg ar[20];
3376 int n;
3377 
3378  xm1 = create_str (label);
3379  n = 0;
3380  XtSetArg(ar[n],XmNlabelFontList, did_default_font); n++;
3381  XtSetArg(ar[n],XmNbuttonFontList, did_default_font); n++;
3382  XtSetArg(ar[n],XmNborderWidth, 1); n++;
3383  /*
3384  XtSetArg(ar[n],XmNwidth, 450); n++;
3385  XtSetArg(ar[n],XmNresizePolicy, XmRESIZE_NONE); n++;
3386  */
3387  XtSetArg(ar[n],XmNselectionLabelString, xm1); n++;
3388  sd = XmCreatePromptDialog ( toplevel_widget, "Prompt", ar, (Cardinal)n );
3389 
3390  XmStringFree(xm1);
3391 
3392  XtAddCallback ( sd, XmNcancelCallback,
3393  (XtCallbackProc)cancel_pop_up, (XtPointer)tag );
3394  XtAddCallback ( sd, XmNokCallback,
3395  (XtCallbackProc)ok_pop_up, (XtPointer)tag );
3396 
3397  return(sd);
3398 }
3399 
3400 Widget create_question_dialog(char *label, long tag)
3401 {
3402 Widget sd;
3403 XmString xm1;
3404 Arg ar[20];
3405 int n;
3406 
3407  xm1 = create_str (label);
3408  n = 0;
3409  XtSetArg(ar[n],XmNlabelFontList, did_default_font); n++;
3410  XtSetArg(ar[n],XmNbuttonFontList, did_default_font); n++;
3411  XtSetArg(ar[n],XmNborderWidth, 1); n++;
3412  /*
3413  XtSetArg(ar[n],XmNwidth, 450); n++;
3414  XtSetArg(ar[n],XmNresizePolicy, XmRESIZE_NONE); n++;
3415  */
3416  XtSetArg(ar[n],XmNmessageString, xm1); n++;
3417  sd = XmCreateQuestionDialog ( toplevel_widget, "Question", ar, (Cardinal)n );
3418 
3419  XmStringFree(xm1);
3420 
3421  XtAddCallback ( sd, XmNcancelCallback,
3422  (XtCallbackProc)cancel_pop_up, (XtPointer)tag );
3423  XtAddCallback ( sd, XmNokCallback,
3424  (XtCallbackProc)ok_pop_up, (XtPointer)tag );
3425 
3426  return(sd);
3427 }
3428 
3429 Widget create_service_dialog()
3430 {
3431 Widget fd, rc, sw, lb, rc1;
3432 XmString xm1;
3433 Arg ar[20];
3434 int n, par;
3435 unsigned long reason;
3436 
3437  n = 0;
3438  XtSetArg(ar[n],XmNborderWidth, 1); n++;
3439  XtSetArg(ar[n],XmNresizePolicy, XmRESIZE_ANY); n++;
3440  fd = XmCreateFormDialog ( toplevel_widget, "Form", ar, (Cardinal)n );
3441  XtManageChild(fd);
3442 
3443  /* create rowcolumn */
3444  n = 0;
3445  XtSetArg(ar[n],XmNborderWidth, 1); n++;
3446  XtSetArg(ar[n],XmNentryAlignment, XmALIGNMENT_CENTER); n++;
3447  XtSetArg(ar[n],XmNbottomAttachment, XmATTACH_FORM); n++;
3448  XtSetArg(ar[n],XmNbottomOffset, 0); n++;
3449  XtSetArg(ar[n],XmNrightAttachment, XmATTACH_FORM); n++;
3450  XtSetArg(ar[n],XmNrightOffset, 0); n++;
3451  XtSetArg(ar[n],XmNtopAttachment, XmATTACH_FORM); n++;
3452  XtSetArg(ar[n],XmNtopOffset, 0); n++;
3453  XtSetArg(ar[n],XmNleftAttachment, XmATTACH_FORM); n++;
3454  XtSetArg(ar[n],XmNleftOffset, 0); n++;
3455  rc = XmCreateRowColumn ( fd, "rowcol", ar, (Cardinal)n );
3456  XtManageChild(rc);
3457 
3458  /* create scrolled window */
3459  n = 0;
3460  XtSetArg ( ar[n], XmNwidth, 770); n++;
3461  XtSetArg ( ar[n], XmNheight, 350); n++;
3462  XtSetArg ( ar[n], XmNscrollBarDisplayPolicy, XmAS_NEEDED); n++;
3463  XtSetArg ( ar[n], XmNscrollingPolicy, XmAUTOMATIC); n++;
3464 
3465  sw = XmCreateScrolledWindow ( rc, "ScrollWin", ar, (Cardinal)n );
3466  XtManageChild ( sw );
3467 
3468  /* create label */
3469  n = 0;
3470  xm1 = create_str(" ");
3471  XtSetArg(ar[n],XmNfontList, did_small_font); n++;
3472  XtSetArg(ar[n],XmNlabelString, xm1); n++;
3473  XtSetArg(ar[n],XmNalignment, XmALIGNMENT_BEGINNING); n++;
3474  lb = XmCreateLabel ( sw, "label", ar, (Cardinal)n );
3475  XtManageChild(lb);
3476  XmStringFree(xm1);
3477  par = 1;
3478  reason = 0;
3479  create_label(lb, &par, &reason);
3480 
3481  /* create button rowcolumn */
3482  n = 0;
3483  XtSetArg(ar[n],XmNborderWidth, 0); n++;
3484  XtSetArg(ar[n],XmNentryAlignment, XmALIGNMENT_CENTER); n++;
3485  XtSetArg(ar[n],XmNorientation, XmVERTICAL); n++;
3486  XtSetArg(ar[n],XmNnumColumns, 3); n++;
3487  XtSetArg(ar[n],XmNpacking, XmPACK_COLUMN); n++;
3488  rc1 = XmCreateRowColumn ( rc, "buttons", ar, (Cardinal)n );
3489  XtManageChild(rc1);
3490  /*
3491  create_push_button(rc1,"View Standard",MAX_POP_UPS+1);
3492  create_push_button(rc1,"View Float",MAX_POP_UPS+2);
3493  create_push_button(rc1,"View Double",MAX_POP_UPS+3);
3494  */
3495  SubscribeButton = create_push_button(rc1," Subscribe (On Change) ",
3496  MAX_POP_UPS+5);
3497  Subscribe10Button = create_push_button(rc1," Subscribe (Update Rate 10 seconds) ",
3498  MAX_POP_UPS+4);
3499  create_push_button(rc1,"Dismiss",DID_SERVICE);
3500  Curr_service_print_type = 0;
3501 
3502  return(fd);
3503 }
3504 
3505 Widget create_push_button(Widget parent, char *str, long tag)
3506 {
3507 Widget b;
3508 XmString xm1;
3509 Arg ar[20];
3510 int n;
3511 
3512  n = 0;
3513  xm1 = create_str(str);
3514  XtSetArg(ar[n],XmNalignment, XmALIGNMENT_CENTER); n++;
3515  XtSetArg(ar[n],XmNfontList, did_default_font); n++;
3516  XtSetArg(ar[n],XmNlabelString, xm1); n++;
3517  b = XmCreatePushButton ( parent, "button", ar, (Cardinal)n );
3518 
3519  XtManageChild(b);
3520  XmStringFree(xm1);
3521 
3522  XtAddCallback ( b, XmNactivateCallback,
3523  (XtCallbackProc)cancel_pop_up, (XtPointer)tag );
3524  return(b);
3525 }
3526 
create_matrix
void create_matrix()
DNS_SERVER_INFO
Definition: dim.h:337
SERVER_FONT
#define SERVER_FONT
Definition: did.h:31
MAX_NAME
#define MAX_NAME
Definition: dim.h:182
my_ctime
#define my_ctime(t, str, size)
Definition: dim_common.h:275
did_label_font
static XmFontList did_label_font
Definition: did.c:40
node
Definition: dns.c:26
Curr_service_name
char Curr_service_name[132]
Definition: did.c:12
pop_widget_id
Widget pop_widget_id[MAX_POP_UPS]
Definition: did.h:62
Curr_servp
SERVER * Curr_servp
Definition: did.c:87
create_prompt_dialog
Widget create_prompt_dialog(char *label, long tag)
Definition: did.c:3371
print_service_float
void print_service_float(float *buff, int size)
Definition: did.c:1713
N_services
int N_services
Definition: did.c:16
ok_pop_up
void ok_pop_up()
dic_info_service_stamped
unsigned dic_info_service_stamped(char *serv_name, int req_type, int req_timeout, void *serv_address, int serv_size, void(*usr_routine)(), dim_long tag, void *fill_addr, int fill_size)
Definition: dic.c:613
dis_disable_padding
void dis_disable_padding()
Definition: copy_swap.c:30
Matrix_id
Widget Matrix_id[2]
Definition: did.h:57
dic_info_service
unsigned dic_info_service(char *serv_name, int req_type, int req_timeout, void *serv_address, int serv_size, void(*usr_routine)(), dim_long tag, void *fill_addr, int fill_size)
Definition: dic.c:601
put_selection
Widget put_selection(int tag, char *title)
Definition: did.c:3115
print_service_double
void print_service_double(double *buff, int size)
Definition: did.c:1746
did_default_font
static XmFontList did_default_font
Definition: did.c:40
gui_toplevel
Widget gui_toplevel(char **argv)
Definition: did.c:749
Content_label_id
Widget Content_label_id
Definition: did.h:60
item::busy
int busy
Definition: did.h:52
dim_set_dns_node
int dim_set_dns_node(char *node)
Definition: open_dns.c:50
get_server_service
void get_server_service()
Definition: did.c:1090
remove_button
void remove_button(SERVER *servp)
Definition: did.c:2759
item
Definition: did.h:42
DNS_SERVICE_INFO
Definition: dim.h:330
Got_Client_List
SERVER * Got_Client_List
Definition: did.c:29
i
int i
Definition: db_dim_client.c:21
Service_size
int Service_size
Definition: did.c:22
item::button_id
Widget button_id
Definition: did.h:47
print_service_short
void print_service_short(short *buff, int size)
Definition: did.c:1577
print_service_longlong
void print_service_longlong(longlong *buff, int size)
Definition: did.c:1527
create_label
void create_label()
get_service_format
void get_service_format()
Definition: did.c:1133
create_service_dialog
Widget create_service_dialog()
Definition: did.c:3429
str
char str[80]
Definition: test_client.c:7
MONITORED
#define MONITORED
Definition: dim_common.h:9
Curr_client_id
Widget Curr_client_id
Definition: did.c:26
set_color
void set_color()
DNS_SERVER_INFO::node
char node[MAX_NODE_NAME]
Definition: dim.h:338
get_something
void get_something()
dim_usleep
void dim_usleep(int usecs)
Definition: dtq.c:293
DEFAULT_FONT
#define DEFAULT_FONT
Definition: did.h:27
Window_id
Widget Window_id
Definition: did.h:61
recv_service_info
void recv_service_info(int *tag, int *buffer, int *size)
Definition: did.c:1176
remove_all_buttons
void remove_all_buttons()
Definition: did.c:2743
create_question_dialog
Widget create_question_dialog(char *label, long tag)
Definition: did.c:3400
dtq_create
int dtq_create()
Definition: dtq.c:353
did_small_font
static XmFontList did_small_font
Definition: did.c:40
get_all_colors
void get_all_colors(Display *display, Widget w)
Definition: dui_util.c:218
Curr_service_list_id
Widget Curr_service_list_id
Definition: did.c:27
set_icon_title
void set_icon_title(Widget w, char *title)
Definition: dui_util.c:296
got_service_list
void got_service_list(SERVER **servp_ptr, char *buffer, int *size)
Definition: did.c:2835
create_node_selection
Widget create_node_selection()
Definition: did.c:3233
DNS_SERVICE_INFO::n_clients
int n_clients
Definition: dim.h:334
Memory::malloc
void * malloc()
Definition: EventBuilder.cc:99
app_context
XtAppContext app_context
Definition: did.h:38
id
char id[4]
Definition: FITS.h:71
put_popup
Widget put_popup(SERVER *servp, int type, char *title)
Definition: did.c:3085
dic_get_dns_port
int dic_get_dns_port()
Definition: open_dns.c:130
MAX_COLORS
Definition: dui_colors.h:4
Label_id
Widget Label_id
Definition: did.h:59
create_send_command
Widget create_send_command()
Definition: did.c:3252
Force_update
int Force_update
Definition: did.c:36
gui_initialize
Widget gui_initialize(int argc, char **argv)
Definition: did.c:764
read_str_char
int read_str_char(char *str, char *cc)
Definition: did.c:2039
MAX_CONNS
#define MAX_CONNS
Definition: dim.h:163
Service_buffer
char * Service_buffer
Definition: did.c:21
DNS_SERVER_INFO::task
char task[MAX_TASK_NAME]
Definition: dim.h:339
No_link_button_id
Widget No_link_button_id
Definition: did.h:63
get_server_node
void get_server_node()
Definition: did.c:1031
dic_get_quality
int dic_get_quality(unsigned serv_id)
Definition: dic.c:937
create_main
void create_main()
set_title
void set_title(Widget w, char *title)
Definition: dui_util.c:283
dns_control
void dns_control()
DNS_SERVICE_INFO::type
int type
Definition: dim.h:332
print_service_standard
void print_service_standard(int *buff, int size)
Definition: did.c:1456
create_kill_confirmation
Widget create_kill_confirmation()
Definition: did.c:3270
rgb_colors
Pixel rgb_colors[MAX_COLORS]
Definition: dui_util.c:161
main
int main(int argc, char *argv[])
Definition: did.c:791
Service_content_str
char * Service_content_str
Definition: did.c:20
Timer_q
int Timer_q
Definition: did.c:34
MENU_FONT
#define MENU_FONT
Definition: did.h:29
kick_it_again
void kick_it_again()
Definition: did.c:3080
Server_head
SERVER * Server_head
Definition: did.h:55
item::name
char name[132]
Definition: did.h:46
activate_clients
void activate_clients(Widget w, SERVER *servp, unsigned long *reason)
Definition: did.c:3018
do_got_service_list
void do_got_service_list(SERVER *servp)
Definition: did.c:2857
sll_get_next
SLL * sll_get_next(SLL *item)
Definition: sll.c:50
DNS_DID::server
DNS_SERVER_INFO server
Definition: dim.h:345
First_time
int First_time
Definition: did.c:9
read_str_int
int read_str_int(char *str)
Definition: did.c:2029
view_opts
void view_opts()
create_matrix_widget
void create_matrix_widget()
Definition: did.c:117
sll
Definition: dim.h:536
item::pop_widget_id
Widget pop_widget_id[2]
Definition: did.h:48
create_service_selection
Widget create_service_selection()
Definition: did.c:3241
app_initialize
void app_initialize(int tag)
Definition: did.c:911
display
Display * display
Definition: did.h:37
put_label
void put_label()
Definition: did.c:3183
sll_remove_head
SLL * sll_remove_head(SLL *head)
Definition: sll.c:94
Curr_service_print_type
int Curr_service_print_type
Definition: did.c:14
dic_cmnd_service
int dic_cmnd_service(char *serv_name, void *serv_address, int serv_size)
Definition: dic.c:694
dic_get_dns_node
int dic_get_dns_node(char *node)
Definition: open_dns.c:81
dim_no_threads
void dim_no_threads()
Definition: dtq.c:80
type
int type
Definition: dim_get_service.c:9
update_servers
void update_servers(int *tag, DNS_DID *buffer, int *size)
Definition: did.c:2313
sll_init
void sll_init(SLL *head)
Definition: sll.c:14
DNS_SERVER_INFO::pid
int pid
Definition: dim.h:340
sll_insert_queue
int sll_insert_queue(SLL *head, SLL *item)
Definition: sll.c:20
Curr_view_opt_par
char Curr_view_opt_par[80]
Definition: did.c:11
did_read_string
void did_read_string(char type, int num, void **buffer_ptr, char **str_ptr)
Definition: did.c:2055
Curr_client_list
char * Curr_client_list
Definition: did.c:24
find_server
SERVER * find_server(char *node, int pid)
Definition: did.c:2291
item::service_ptr
DNS_SERVICE_INFO * service_ptr
Definition: did.h:45
set_something
void set_something()
DNS_SERVICE_INFO::name
char name[MAX_NAME]
Definition: dim.h:331
create_push_button
Widget create_push_button(Widget parent, char *str, long tag)
Definition: did.c:3505
did_prepare_command
void did_prepare_command(char *str)
Definition: did.c:1964
MAX_TASK_NAME
#define MAX_TASK_NAME
Definition: dim.h:181
item::next
struct item * next
Definition: did.h:43
did_server_font
static XmFontList did_server_font
Definition: did.c:40
DID_SLOT
char DID_SLOT[MAX_NAME]
Definition: did.c:2833
get_nodes
int get_nodes(char *node_ptr)
Definition: did.c:1112
activate_services
void activate_services(Widget w, SERVER *servp, unsigned long *reason)
Definition: did.c:2770
check_put_label
void check_put_label(int tag)
Definition: did.c:3149
sll_remove
int sll_remove(SLL *head, SLL *item)
Definition: sll.c:74
fptr
FILE * fptr
Definition: did.c:18
gui_create_main_menu
void gui_create_main_menu(Widget mb)
Definition: did.c:370
create_selection_dialog
Widget create_selection_dialog(char *ok, char *apply, char *cancel, char *list, char *sel, long tag, int items)
Definition: did.c:3279
no_link
static char no_link
Definition: did.c:909
Curr_view_opt
int Curr_view_opt
Definition: did.c:10
item::server
DNS_SERVER_INFO server
Definition: did.h:44
dic_disable_padding
void dic_disable_padding()
Definition: copy_swap.c:25
buffer
int buffer[BUFFSIZE]
Definition: db_dim_client.c:14
DNS_SERVICE_INFO::status
int status
Definition: dim.h:333
GREEN
Definition: dui_colors.h:4
delete_str
void delete_str(XmString str)
Definition: dui_util.c:55
Subscribe10Button
Widget Subscribe10Button
Definition: did.c:32
did_write_string
int did_write_string(char type, int num, void **buffer_ptr, int ssize)
Definition: did.c:1287
toplevel_widget
Widget toplevel_widget
Definition: did.h:39
size
int size
Definition: db_dim_server.c:17
Curr_service_format
char Curr_service_format[256]
Definition: did.c:13
Memory::free
void free(void *mem)
Definition: EventBuilder.cc:126
cancel_pop_up
void cancel_pop_up()
do_show_clients
void do_show_clients(SERVER *servp)
Definition: did.c:2947
get_type_size
int get_type_size(char type)
Definition: did.c:1930
switch_matrix
void switch_matrix()
Definition: did.c:2269
longlong
int64_t longlong
Definition: dim_common.h:56
MAX_NODE_NAME
#define MAX_NODE_NAME
Definition: dim.h:180
Curr_matrix
int Curr_matrix
Definition: did.h:58
s_error
void s_error(char *problem_string)
Definition: did.c:956
DNS_DID
Definition: dim.h:344
create_str
XmString create_str()
buff
int buff[BUFFSIZE]
Definition: db_dim_client.c:15
no_link_int
int no_link_int
Definition: did.c:17
create_file_selection_dialog
Widget create_file_selection_dialog(long type)
Definition: did.c:3339
gui_create_main_window
void gui_create_main_window(Widget parent)
Definition: did.c:139
DNS_SERVER_INFO::n_services
int n_services
Definition: dim.h:341
SubscribeButton
Widget SubscribeButton
Definition: did.c:31
Got_Service_List
SERVER * Got_Service_List
Definition: did.c:28
print_service_char
void print_service_char(char *buff, int size)
Definition: did.c:1648
update_servers_new
void update_servers_new(int *tag, char *buffer, int *size)
Definition: did.c:2284
ONCE_ONLY
#define ONCE_ONLY
Definition: dim_common.h:7
update_show_servers
void update_show_servers(void *tag, unsigned long *reason)
Definition: did.c:2464
print_service_formatted
void print_service_formatted(void *buff, int size)
Definition: did.c:1219
create_server_dialog
Widget create_server_dialog()
Definition: did.c:3224
Curr_service_list
char * Curr_service_list
Definition: did.c:23
LABEL_FONT
#define LABEL_FONT
Definition: did.h:25
dic_release_service
void dic_release_service(unsigned service_id)
Definition: dic.c:1025
did_exit
void did_exit()
DNS_DID::services
DNS_SERVICE_INFO services[1]
Definition: dim.h:346
Curr_service_id
int Curr_service_id
Definition: did.c:25
show_clients
void show_clients(SERVER **servp_ptr, char *buffer, int *size)
Definition: did.c:2925
create_separator
Widget create_separator(Widget parent_id)
Definition: did.c:358
sll_empty
int sll_empty(SLL *head)
Definition: sll.c:60
kick_it
void kick_it()
Definition: did.c:2828
sprintf
sprintf(name1,"NewService%d", i)
DNS_PORT
#define DNS_PORT
Definition: dim.h:139
util_get_font
XmFontList util_get_font(char *fontname, Widget top)
Definition: did.c:89
RED
Definition: dui_colors.h:4
N_servers
int N_servers
Definition: did.c:15
show_servers
void show_servers()
Definition: did.c:2441
create_client_dialog
Widget create_client_dialog()
Definition: did.c:3216
create_button
Widget create_button(char *name, SERVER *servp)
Definition: did.c:2658
dic_get_timestamp
int dic_get_timestamp(unsigned serv_id, int *secs, int *milisecs)
Definition: dic.c:984