FACT++  1.0
didMarkus.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,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, 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,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, 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,"service",7)) ||
816  (!strncmp(opt_str,"SERVICE",7)))
817  Curr_view_opt = 2;
818  else if((!strncmp(opt_str,"error",5)) ||
819  (!strncmp(opt_str,"ERROR",5)))
820  Curr_view_opt = 3;
821  else if((!strncmp(opt_str,"help",4)) ||
822  (!strncmp(opt_str,"HELP",4)))
823  {
824  printf("Did - DIM Information Display\n");
825  printf("\t-all Show ALL Servers\n");
826  printf("\t-service=<str> Show Servers providing Service <str>\n");
827  printf("\t-node=<nodename> Show Servers on Node <nodename>\n");
828  printf("\t-error Show Servers in Error\n");
829  printf("\t-help Show this message\n\n");
830  exit(0);
831  }
832  else
833  Curr_view_opt = -1;
834  if((Curr_view_opt == 0) || (Curr_view_opt == 2))
835  {
836  if(!(ptr = strchr(argv[1],'=')))
837  {
838  if( (ptr = strchr(argv[2],'=')) )
839  {
840  ptr++;
841  if(!(*ptr))
842  ptr = argv[3];
843  }
844  else
845  ptr++;
846  }
847  else
848  {
849  ptr++;
850  if(!(*ptr))
851  ptr = argv[2];
852  }
853  for(i = 0;*ptr; ptr++, i++)
854  Curr_view_opt_par[i] = toupper(*ptr);
855  Curr_view_opt_par[i] = '\0';
856  }
857  }
858  }
859 
860  toplevel_widget = (Widget)gui_initialize(argc, argv);
861  app_initialize();
862  /*
863  * Sit around forever waiting to process X-events. We never leave
864  * XtAppMainLoop. From here on, we only execute our callback routines.
865  */
866 
867  while(1)
868  {
869  {
870  DISABLE_AST
871  mask = XtAppPending(app_context);
872  ENABLE_AST
873  }
874  if(mask)
875  {
876  DISABLE_AST
877  XtAppProcessEvent(app_context, mask);
878  if(Got_Service_List)
879  {
880  do_got_service_list(Got_Service_List);
881  Got_Service_List = 0;
882  }
883  if(Got_Client_List)
884  {
885  do_show_clients(Got_Client_List);
886  Got_Client_List = 0;
887  }
888  ENABLE_AST
889  }
890  else
891  {
892  dim_usleep(100000);
893  /*
894  usleep(100000);
895  */
896  }
897  }
898 
899 }
900 
901 static char no_link = -1;
902 
903 void app_initialize(int tag)
904 {
905 void check_put_label();
906 
907 void update_servers();
908 void update_servers_new();
909 void update_show_servers();
910 extern void get_all_colors();
911 extern void set_title();
912 extern void set_icon_title();
913 
914  char text[128];
915  int len;
916  if(tag){}
917  sprintf(text,"DID - DIM Information Display on ");
918  len = strlen(text);
919  dim_get_dns_node(text+len);
920  len = strlen(text);
921  sprintf(text+len,":%d",dim_get_dns_port());
922  get_all_colors(display,Matrix_id[Curr_matrix]);
923  set_title(toplevel_widget,text);
924  set_icon_title(toplevel_widget,"DID");
925  Timer_q = dtq_create();
926  dic_info_service("DIS_DNS/SERVER_INFO",MONITORED,0,0,0,update_servers,0,
927  &no_link,1);
928  /*
929  dic_info_service("DIS_DNS/SERVER_LIST",MONITORED,0,0,0,
930  update_servers_new,0, &no_link,1);
931  */
932  /*
933  dtq_add_entry(Timer_q, 2, check_put_label, 0);
934  */
935  XtAppAddTimeOut(app_context, 1000, update_show_servers, 0);
936 }
937 
938 /*
939  * All errors are fatal.
940  */
941 void s_error(char *problem_string)
942 {
943  printf("%s\n", problem_string);
944  exit(0);
945 }
946 
947 void did_exit(Widget w, int *tag, unsigned long *reason)
948 {
949  if(w){}
950  if(tag){}
951  if(reason){}
952  exit(0);
953 }
954 
955 extern Pixel rgb_colors[MAX_COLORS];
956 
957 void create_main (Widget w, int *tag, unsigned long *reason)
958 {
959  if(tag){}
960  if(reason){}
961  Window_id = w;
962 /*
963  dtq_start_timer(5, app_initialize, 0);
964 */
965 }
966 
967 void view_opts(Widget w, int tag, unsigned long *reason)
968 {
969  void get_server_node(), get_server_service(), show_servers();
970 
971  if(w){}
972  if(reason){}
973  Curr_view_opt = tag;
974  switch(tag)
975  {
976  case 0 :
977  get_server_node();
978  break;
979  case 1 :
980  show_servers();
981  break;
982  case 2 :
983  get_server_service();
984  break;
985  case 3 :
986  show_servers();
987  break;
988  }
989 }
990 
991 void dns_control(Widget w, int tag, unsigned long *reason)
992 {
993 
994  if(w){}
995  if(reason){}
996  switch(tag)
997  {
998  case 0 :
999  dic_cmnd_service("DIS_DNS/PRINT_STATS",0,0);
1000  break;
1001  case 1 :
1002  dic_cmnd_service("DIS_DNS/DEBUG_ON",0,0);
1003  break;
1004  case 2 :
1005  dic_cmnd_service("DIS_DNS/DEBUG_OFF",0,0);
1006  break;
1007  case 3 :
1008  put_selection(DID_KILL_ALL,"Confirmation");
1009  break;
1010  case 4 :
1011  dic_cmnd_service("DIS_DNS/PRINT_HASH_TABLE",0,0);
1012  break;
1013  }
1014 }
1015 
1016 void get_server_node()
1017 {
1018 Widget id,sel_id;
1019 int i, j, n_nodes, curr_index = 0;
1020 char nodes_str[MAX_NODE_NAME*MAX_CONNS], max_str[MAX_NODE_NAME];
1021 char *ptr, *nodeptrs[MAX_CONNS], *curr_str, *sptr;
1022 int get_nodes();
1023 
1024  sel_id = put_selection(DID_SEL_NODE,"Node Selection");
1025  id = XmSelectionBoxGetChild(sel_id,XmDIALOG_HELP_BUTTON);
1026  XtUnmanageChild(id);
1027  id = XmSelectionBoxGetChild(sel_id,XmDIALOG_APPLY_BUTTON);
1028  XtUnmanageChild(id);
1029  id = XmSelectionBoxGetChild(sel_id,XmDIALOG_LIST);
1030  XmListDeleteAllItems(id);
1031  n_nodes = get_nodes(nodes_str);
1032  ptr = nodes_str;
1033 
1034  for(i=0;i<n_nodes;i++)
1035  {
1036  nodeptrs[i] = ptr;
1037  sptr = ptr;
1038  ptr = strchr(ptr,'\n');
1039  for(j = 0; j < (int)strlen(sptr); j++)
1040  sptr[j] = tolower(sptr[j]);
1041  *ptr++ = '\0';
1042  }
1043  strcpy(max_str,"zzzzzzzzzzzzzzzzzzzzzzzzzzzz");
1044  for(i=0;i<n_nodes; i++)
1045  {
1046  curr_str = max_str;
1047  for(j=0;j<n_nodes; j++)
1048  {
1049  sptr = nodeptrs[j];
1050  if(!sptr)
1051  continue;
1052 
1053  if(strcmp(sptr,curr_str) < 0)
1054  {
1055  curr_str = sptr;
1056  curr_index = j;
1057  }
1058  }
1059  nodeptrs[curr_index] = 0;
1060  XmListAddItem(id,create_str(curr_str),i+1);
1061  }
1062  /*
1063  for(i=0;i<n_nodes;i++)
1064  {
1065  node = ptr;
1066  ptr = strchr(ptr,'\n');
1067  *ptr++ = '\0';
1068  XmListAddItem(id,create_str(node),i+1);
1069  }
1070  */
1071  set_something(id,XmNlistItemCount,i);
1072  set_something(id,XmNlistVisibleItemCount,(i < 8) ? i : 8);
1073 }
1074 
1075 void get_server_service()
1076 {
1077 Widget id,sel_id;
1078 
1079  sel_id = put_selection(DID_SEL_SERVICE,"Service Selection");
1080  id = XmSelectionBoxGetChild(sel_id,XmDIALOG_HELP_BUTTON);
1081  XtUnmanageChild(id);
1082  id = XmSelectionBoxGetChild(sel_id,XmDIALOG_APPLY_BUTTON);
1083  XtUnmanageChild(id);
1084 
1085  id = XmSelectionBoxGetChild(sel_id,XmDIALOG_LIST);
1086  /*
1087  XtUnmanageChild(id);
1088  */
1089  XtUnmapWidget(id);
1090 
1091  /*
1092  id = (Widget)XmSelectionBoxGetChild(sel_id,XmDIALOG_LIST_LABEL);
1093  XtUnmanageChild(id);
1094  */
1095 }
1096 
1097 int get_nodes(char *node_ptr)
1098 {
1099 DNS_SERVER_INFO *ptr;
1100 int n_nodes = 0;
1101 SERVER *servp;
1102 
1103  node_ptr[0] = '\0';
1104  servp = Server_head;
1105  while( (servp = (SERVER *)sll_get_next((SLL *)servp)) )
1106  {
1107  ptr = &servp->server;
1108  if(strstr(node_ptr,ptr->node) <= (char *)0)
1109  {
1110  strcat(node_ptr,ptr->node);
1111  strcat(node_ptr,"\n");
1112  n_nodes++;
1113  }
1114  }
1115  return(n_nodes);
1116 }
1117 
1118 void get_service_format()
1119 {
1120 
1121  char str[256], *ptr, *ptr1;
1122  int rpc_flag;
1123 
1124  strcpy(str,Curr_service_name);
1125  rpc_flag = 0;
1126  if( (ptr = strstr(str,"/RpcIn")) )
1127  {
1128  *ptr = '\0';
1129  rpc_flag = 1;
1130  }
1131  if( (ptr = strstr(str,"/RpcOut")) )
1132  {
1133  *ptr = '\0';
1134  rpc_flag = 2;
1135  }
1136  strcat(str,"|");
1137  if( (ptr = strstr(Curr_service_list,str)) )
1138  {
1139  if(!rpc_flag)
1140  {
1141  ptr += strlen(str);
1142  ptr1 = strchr(ptr,'|');
1143  }
1144  else if(rpc_flag == 1)
1145  {
1146  ptr += strlen(str);
1147  ptr1 = strchr(ptr,',');
1148  }
1149  else
1150  {
1151  ptr += strlen(str);
1152  ptr = strchr(ptr,',');
1153  ptr++;
1154  ptr1 = strchr(ptr,'|');
1155  }
1156  strncpy(Curr_service_format,ptr,(int)(ptr1 - ptr));
1157  Curr_service_format[(int)(ptr1-ptr)] = '\0';
1158  }
1159 }
1160 
1161 void recv_service_info(int *tag, int *buffer, int *size)
1162 {
1163 /*
1164  char str[256], *ptr, *ptr1;
1165  int rpc_flag;
1166 */
1167  void print_service_formatted();
1168 
1169  if(tag){}
1170  Service_content_str = malloc(1024 + (*size)*16);
1171  Service_buffer = malloc(*size);
1172  memcpy(Service_buffer, (char *)buffer, *size);
1173  Service_size = *size;
1174  get_service_format();
1175  if((*size == 4 ) && (*buffer == -1))
1176  {
1177  sprintf(Service_content_str,
1178  "Service %s Not Available\n", Curr_service_name);
1179  }
1180  else
1181  {
1182  switch(Curr_service_print_type)
1183  {
1184  case 0:
1185  print_service_formatted(buffer,*size);
1186  break;
1187  /*
1188  case 1:
1189  print_service_float(buffer, ((*size - 1) / 4) + 1);
1190  break;
1191  case 2:
1192  print_service_double(buffer, ((*size - 1) / 4) + 1);
1193  break;
1194  */
1195  }
1196  }
1197  set_something(Content_label_id,XmNlabelString, Service_content_str);
1198  /*
1199  if(Matrix_id[Curr_matrix])
1200  XFlush(XtDisplay(Matrix_id[Curr_matrix]));
1201  */
1202 }
1203 
1204 void print_service_formatted(void *buff, int size)
1205 {
1206 char type;
1207 int num, ret;
1208 char str[128];
1209 char *ptr;
1210 void *buffer_ptr;
1211 char timestr[128], aux[10];
1212 int quality = 0, secs = 0, mili = 0;
1213 int did_write_string(char, int, void **, int);
1214 time_t tsecs;
1215 
1216  sprintf(Service_content_str,
1217  "Service %s (%s) Contents :\n \n", Curr_service_name,
1218  Curr_service_format);
1219  /*
1220  if(Curr_service_id)
1221  {
1222  */
1223  dic_get_timestamp(0, &secs, &mili);
1224  quality = dic_get_quality(0);
1225 /*
1226 #ifdef LYNXOS
1227  ctime_r((time_t *)&secs, timestr, 128);
1228 #else
1229  ctime_r((time_t *)&secs, timestr);
1230 #endif
1231 */
1232  tsecs = secs;
1233  my_ctime(&tsecs, timestr, 128);
1234  ptr = strrchr(timestr,' ');
1235  strcpy(aux, ptr);
1236  sprintf(ptr,".%03d",mili);
1237  strcat(timestr, aux);
1238  timestr[strlen(timestr)-1] = '\0';
1239 
1240  sprintf(str," Timestamp: %s Quality: %d\n\n",
1241  timestr, quality);
1242 
1243  strcat(Service_content_str,str);
1244  /*
1245  }
1246  */
1247  ptr = Curr_service_format;
1248  buffer_ptr = buff;
1249  while(*ptr)
1250  {
1251  type = *ptr++;
1252  if(*ptr == ':')
1253  {
1254  ptr++;
1255  sscanf(ptr, "%d", &num);
1256  ret = did_write_string(type, num, &buffer_ptr, size);
1257  size -= ret;
1258  if( (ptr = strchr(ptr,';')) )
1259  ptr++;
1260  else
1261  break;
1262  }
1263  else
1264  {
1265  ret = did_write_string(type, 0, &buffer_ptr, size);
1266  size -= ret;
1267  break;
1268  }
1269  }
1270 }
1271 
1272 int did_write_string(char type, int num, void **buffer_ptr, int ssize)
1273 {
1274 void *ptr;
1275 int size, psize;
1276 
1277  void print_service_standard();
1278  void print_service_char();
1279  void print_service_short();
1280  void print_service_float();
1281  void print_service_double();
1282 
1283  ptr = *buffer_ptr;
1284  switch(type)
1285  {
1286  case 'L':
1287  case 'l':
1288  strcat(Service_content_str," L");
1289  if(!num)
1290  size = ssize/sizeof(int);
1291  else
1292  size = num;
1293  psize = size * sizeof(int);
1294  print_service_standard(ptr, size);
1295  break;
1296  case 'I':
1297  case 'i':
1298  strcat(Service_content_str," I");
1299  if(!num)
1300  size = ssize/sizeof(int);
1301  else
1302  size = num;
1303  psize = size * sizeof(int);
1304  print_service_standard(ptr, size);
1305  break;
1306  case 'S':
1307  case 's':
1308  strcat(Service_content_str," S");
1309  if(!num)
1310  size = ssize/sizeof(short);
1311  else
1312  size = num;
1313  psize = size * sizeof(short);
1314  print_service_short(ptr, size);
1315  break;
1316  case 'F':
1317  case 'f':
1318  strcat(Service_content_str," F");
1319  if(!num)
1320  size = ssize/sizeof(float);
1321  else
1322  size = num;
1323  psize = size * sizeof(float);
1324  print_service_float(ptr, size);
1325  break;
1326  case 'D':
1327  case 'd':
1328  strcat(Service_content_str," D");
1329  if(!num)
1330  size = ssize/sizeof(double);
1331  else
1332  size = num;
1333  psize = size * sizeof(double);
1334  print_service_double(ptr, size);
1335  break;
1336  case 'X':
1337  case 'x':
1338  strcat(Service_content_str," X");
1339  if(!num)
1340  size = ssize/sizeof(longlong);
1341  else
1342  size = num;
1343  psize = size * sizeof(longlong);
1344  print_service_standard(ptr, size*2);
1345  break;
1346  case 'C':
1347  case 'c':
1348  default:
1349  strcat(Service_content_str," C");
1350  if(!num)
1351  size = ssize;
1352  else
1353  size = num;
1354  psize = size;
1355  print_service_char(ptr, size);
1356  }
1357  ptr = (char *)ptr + psize;
1358  *buffer_ptr = ptr;
1359  return psize;
1360 }
1361 /*
1362 print_service(buff, size)
1363 int *buff, size;
1364 {
1365 int i,j, str_flag = 0;
1366 char *asc, *ptr, str[80];
1367 int last[4];
1368 
1369  sprintf(Service_content_str,
1370  "Service %s (%s) Contents :\n \n", Curr_service_name,
1371  Curr_service_format);
1372  asc = (char *)buff;
1373  for( i = 0; i < size; i++)
1374  {
1375  if(i%4 == 0)
1376  {
1377  sprintf(str,"%4d: ",i);
1378  strcat(Service_content_str,str);
1379  }
1380  if(!(i%4))
1381  strcat(Service_content_str,"H");
1382  sprintf(str," %08X ",buff[i]);
1383  strcat(Service_content_str,str);
1384  last[i%4] = buff[i];
1385  if(i%4 == 3)
1386  {
1387  strcat(Service_content_str," '");
1388  for(j = 0; j <16; j++)
1389  {
1390  if(isprint(asc[j]))
1391  {
1392  sprintf(str,"%c",asc[j]);
1393  strcat(Service_content_str,str);
1394  }
1395  else
1396  {
1397  sprintf(str,".");
1398  strcat(Service_content_str,str);
1399  }
1400  }
1401  strcat(Service_content_str,"'\n");
1402  for(j = 0; j <4; j++)
1403  {
1404  if(j == 0)
1405  strcat(Service_content_str," D");
1406  sprintf(str,"%11d ",last[j]);
1407  strcat(Service_content_str,str);
1408  }
1409  strcat(Service_content_str,"\n");
1410  asc = (char *)&buff[i+1];
1411  }
1412  }
1413  if(i%4)
1414  {
1415  for(j = 0; j < 4 - (i%4); j++)
1416  strcat(Service_content_str," ");
1417  strcat(Service_content_str," '");
1418  for(j = 0; j < (i%4) * 4; j++)
1419  {
1420  if(isprint(asc[j]))
1421  {
1422  sprintf(str,"%c",asc[j]);
1423  strcat(Service_content_str,str);
1424  }
1425  else
1426  strcat(Service_content_str,".");
1427  }
1428  strcat(Service_content_str,"'\n");
1429  for(j = 0; j < (i%4); j++)
1430  {
1431  if(j == 0)
1432  strcat(Service_content_str," D");
1433  sprintf(str,"%11d ",last[j]);
1434  strcat(Service_content_str,str);
1435  }
1436  strcat(Service_content_str,"\n");
1437  }
1438 }
1439 */
1440 
1441 void print_service_standard(int *buff, int size)
1442 {
1443 int i,j;
1444 char *asc, *ptr, str[80], tmp[256];
1445 int last[4];
1446 
1447  asc = (char *)buff;
1448  ptr = Service_content_str;
1449  ptr += strlen(Service_content_str);
1450  for( i = 0; i < size; i++)
1451  {
1452  strcpy(tmp,"");
1453  if(i%4 == 0)
1454  {
1455  if(i != 0)
1456  {
1457  strcat(tmp," ");
1458  }
1459  sprintf(str,"%5d ",i);
1460  strcat(tmp,str);
1461  }
1462  if(!(i%4))
1463  strcat(tmp,"H: ");
1464  sprintf(str," %08X",buff[i]);
1465  strcat(tmp,str);
1466  last[i%4] = buff[i];
1467  if((i%4 == 3) || (i == (size-1)))
1468  {
1469  /*
1470  if(i%4 != 3)
1471  {
1472  for(j = 1; j < 4 - (i%4); j++)
1473  strcat(tmp," ");
1474  }
1475  strcat(tmp," '");
1476  for(j = 0; j < ((i%4)*4)+4 ; j++)
1477  {
1478  if(isprint(asc[j]))
1479  {
1480  sprintf(str,"%c",asc[j]);
1481  strcat(tmp,str);
1482  }
1483  else
1484  {
1485  sprintf(str,".");
1486  strcat(tmp,str);
1487  }
1488  }
1489  */
1490  strcat(tmp,"\n");
1491  for(j = 0; j <= (i%4); j++)
1492  {
1493  if(j == 0)
1494  strcat(tmp," D: ");
1495  sprintf(str,"%12d",last[j]);
1496  strcat(tmp,str);
1497  }
1498  strcat(tmp,"\n");
1499  asc = (char *)&buff[i+1];
1500  }
1501  strcpy(ptr, tmp);
1502  ptr += strlen(tmp);
1503  }
1504  strcpy(tmp,"\n");
1505  strcpy(ptr, tmp);
1506 }
1507 
1508 void print_service_longlong(longlong *buff, int size)
1509 {
1510 int i,j;
1511 char *asc, *ptr, str[80], tmp[256];
1512 longlong last[4];
1513 
1514  asc = (char *)buff;
1515  ptr = Service_content_str;
1516  ptr += strlen(Service_content_str);
1517  for( i = 0; i < size; i++)
1518  {
1519  strcpy(tmp,"");
1520  if(i%4 == 0)
1521  {
1522  if(i != 0)
1523  {
1524  strcat(tmp," ");
1525  }
1526  sprintf(str,"%5d ",i);
1527  strcat(tmp,str);
1528  }
1529  if(!(i%4))
1530  strcat(tmp,"H: ");
1531  sprintf(str," %08X",(unsigned)buff[i]);
1532  strcat(tmp,str);
1533  last[i%4] = buff[i];
1534  if((i%4 == 3) || (i == (size-1)))
1535  {
1536  strcat(tmp,"\n");
1537  for(j = 0; j <= (i%4); j++)
1538  {
1539  if(j == 0)
1540  strcat(tmp," D: ");
1541  sprintf(str,"%12d",(int)last[j]);
1542  strcat(tmp,str);
1543  }
1544  strcat(tmp,"\n");
1545  asc = (char *)&buff[i+1];
1546  }
1547  strcpy(ptr, tmp);
1548  ptr += strlen(tmp);
1549  }
1550  strcpy(tmp,"\n");
1551  strcpy(ptr, tmp);
1552 }
1553 
1554 void print_service_short(short *buff, int size)
1555 {
1556 int i,j;
1557 char *asc, *ptr, str[80], tmp[256];
1558 short last[8];
1559 
1560  asc = (char *)buff;
1561  ptr = Service_content_str;
1562  ptr += strlen(Service_content_str);
1563  for( i = 0; i < size; i++)
1564  {
1565  strcpy(tmp,"");
1566  if(i%8 == 0)
1567  {
1568  if(i != 0)
1569  {
1570  strcat(tmp," ");
1571  }
1572  sprintf(str,"%5d ",i);
1573  strcat(tmp,str);
1574  }
1575  if(!(i%8))
1576  strcat(tmp,"H: ");
1577  sprintf(str," %04X",buff[i]);
1578  strcat(tmp,str);
1579  last[i%8] = buff[i];
1580  if((i%8 == 7) || (i == (size-1)))
1581  {
1582  /*
1583  if(i%7 != 7)
1584  {
1585  for(j = 1; j < 8 - (i%8); j++)
1586  strcat(tmp," ");
1587  }
1588  strcat(tmp," '");
1589  for(j = 0; j < ((i%8)*2)+2 ; j++)
1590  {
1591  if(isprint(asc[j]))
1592  {
1593  sprintf(str,"%c",asc[j]);
1594  strcat(tmp,str);
1595  }
1596  else
1597  {
1598  sprintf(str,".");
1599  strcat(tmp,str);
1600  }
1601  }
1602  */
1603  strcat(tmp,"\n");
1604  for(j = 0; j <= (i%8); j++)
1605  {
1606  if(j == 0)
1607  strcat(tmp," D: ");
1608  sprintf(str," %5d",last[j]);
1609  strcat(tmp,str);
1610  }
1611  strcat(tmp,"\n");
1612  asc = (char *)&buff[i+1];
1613  }
1614  strcpy(ptr, tmp);
1615  ptr += strlen(tmp);
1616  }
1617  strcpy(tmp,"\n");
1618  strcpy(ptr, tmp);
1619 }
1620 
1621 void print_service_char(char *buff, int size)
1622 {
1623 int i,j;
1624 char *asc, *ptr, str[80], tmp[256];
1625 char last[16];
1626 
1627  asc = (char *)buff;
1628  ptr = Service_content_str;
1629  ptr += strlen(Service_content_str);
1630  for( i = 0; i < size; i++)
1631  {
1632  strcpy(tmp,"");
1633  if(i%16 == 0)
1634  {
1635  if(i != 0)
1636  {
1637  strcat(tmp," ");
1638  }
1639  sprintf(str,"%5d ",i);
1640  strcat(tmp,str);
1641  }
1642  if(!(i%16))
1643  strcat(tmp,"H: ");
1644  sprintf(str,"%02X",buff[i]);
1645 /* strcat(tmp,str);
1646 */
1647  strcat(tmp," ");
1648  strcat(tmp,&str[strlen(str)-2]);
1649  last[i%16] = buff[i];
1650  /*
1651  if(i%4 == 3)
1652  strcat(tmp," ");
1653  */
1654  if((i%16 == 15) || (i == (size-1)))
1655  {
1656  if(i%16 != 15)
1657  {
1658  for(j = 1; j < 16 - (i%16); j++)
1659  strcat(tmp," ");
1660  }
1661  strcat(tmp," '");
1662  for(j = 0; j <= (i%16) ; j++)
1663  {
1664  if(isprint(asc[j]))
1665  {
1666  sprintf(str,"%c",asc[j]);
1667  strcat(tmp,str);
1668  }
1669  else
1670  {
1671  sprintf(str,".");
1672  strcat(tmp,str);
1673  }
1674  }
1675  strcat(tmp,"'\n");
1676  asc = (char *)&buff[i+1];
1677  }
1678  strcpy(ptr, tmp);
1679  ptr += strlen(tmp);
1680  }
1681  strcpy(tmp,"\n");
1682  strcpy(ptr, tmp);
1683 }
1684 
1685 void print_service_float(float *buff, int size)
1686 {
1687 int i;
1688 char *ptr, str[80], tmp[256];
1689 
1690  ptr = Service_content_str;
1691  ptr += strlen(Service_content_str);
1692  for( i = 0; i < size; i++)
1693  {
1694  strcpy(tmp,"");
1695  if(i%4 == 0)
1696  {
1697  if(i != 0)
1698  {
1699  strcat(tmp," ");
1700  }
1701  sprintf(str," %5d: ",i);
1702  strcat(tmp,str);
1703  }
1704  sprintf(str,"%12.3G",*(buff++));
1705  strcat(tmp,str);
1706  if((i%4 == 3) || (i == size-1))
1707  {
1708  strcat(tmp,"\n");
1709  }
1710  strcpy(ptr, tmp);
1711  ptr += strlen(tmp);
1712  }
1713  strcpy(tmp,"\n");
1714  strcpy(ptr, tmp);
1715  ptr += strlen(tmp);
1716 }
1717 
1718 void print_service_double(double *buff, int size)
1719 {
1720 int i;
1721 char *ptr, str[80], tmp[256];
1722 
1723  ptr = Service_content_str;
1724  ptr += strlen(Service_content_str);
1725  for( i = 0; i < size; i++)
1726  {
1727  strcpy(tmp,"");
1728  if(i%4 == 0)
1729  {
1730  if(i != 0)
1731  {
1732  strcat(tmp," ");
1733  }
1734  sprintf(str," %5d: ",i);
1735  strcat(tmp,str);
1736  }
1737  sprintf(str,"%12.3G",*(buff++));
1738  strcat(tmp,str);
1739  if((i%4 == 3) || (i == size-1))
1740  {
1741  strcat(tmp,"\n");
1742  }
1743  strcpy(ptr, tmp);
1744  ptr += strlen(tmp);
1745  }
1746  strcpy(tmp,"\n");
1747  strcpy(ptr, tmp);
1748  ptr += strlen(tmp);
1749 }
1750 
1751 void ok_pop_up (Widget w, long tag, unsigned long *reason)
1752 {
1753 Widget id, sel_id;
1754 char *str, *pstr;
1755 void recv_service_info();
1756 void did_prepare_command();
1757 void show_servers();
1758 
1759 /*
1760  if(tag == 5)
1761  {
1762  id = (Widget)XmSelectionBoxGetChild(w,XmDIALOG_TEXT);
1763  str = (char *)XmTextGetString(id);
1764  if(!str[0])
1765  {
1766  XtFree(str);
1767  return;
1768  }
1769  if( ( fptr = fopen( str, "w" ) ) == (FILE *)0 )
1770  {
1771  printf("Cannot open: %s for writing\n",str);
1772  return;
1773  }
1774  ptr = &Curr_servp->server;
1775  if (ptr->pid > 0x1000000)
1776  fprintf(fptr,"Server %s (pid = %X) on node %s\n provides %d services :\n",
1777  Curr_servp->name, ptr->pid, ptr->node, ptr->n_services);
1778  else
1779  fprintf(fptr,"Server %s (pid = %d) on node %s\n provides %d services :\n",
1780  Curr_servp->name, ptr->pid, ptr->node, ptr->n_services);
1781  service_ptr = Curr_servp->service_ptr;
1782  for(i=0;i<ptr->n_services; i++)
1783  {
1784  sprintf(str,service_ptr->name);
1785  fprintf(fptr," %s\n",service_ptr->name);
1786  service_ptr++;
1787  }
1788  fclose(fptr);
1789  XtFree(str);
1790  return;
1791  }
1792  if(tag == 4)
1793  {
1794  sel_id = put_selection(4, "Printing...");
1795  id = (Widget)XmSelectionBoxGetChild(sel_id,XmDIALOG_HELP_BUTTON);
1796  XtUnmanageChild(id);
1797 
1798  id = (Widget)XmSelectionBoxGetChild(sel_id,XmDIALOG_APPLY_BUTTON);
1799  XtUnmanageChild(id);
1800  id = (Widget)XmSelectionBoxGetChild(sel_id,XmDIALOG_TEXT);
1801  str = (char *)XmTextGetString(id);
1802  if(!str[0])
1803  {
1804  XtFree(str);
1805  return;
1806  }
1807  ptr = &Curr_servp->server;
1808  if(pstr = strrchr(str,']'))
1809  *(++pstr) = '\0';
1810  if(pstr = strrchr(str,'/'))
1811  *(++pstr) = '\0';
1812  sprintf(txt_str,"%s%s.TXT",str,Curr_servp->name);
1813  XtFree(str);
1814  XmTextSetString(id, txt_str);
1815  return;
1816  }
1817 */
1818  if(reason){}
1819  if(tag == DID_KILL_ALL)
1820  {
1821  dic_cmnd_service("DIS_DNS/KILL_SERVERS",0,0);
1822  return;
1823  }
1824  id = XmSelectionBoxGetChild(w,XmDIALOG_TEXT);
1825  str = XmTextGetString(id);
1826  if(!str[0])
1827  {
1828  XtFree(str);
1829  return;
1830  }
1831  if ((tag == DID_SEL_NODE) || (tag == DID_SEL_SERVICE))
1832  {
1833  strcpy(Curr_view_opt_par, str);
1834  show_servers();
1835  XtFree(str);
1836  }
1837  if(tag == DID_SERVICES)
1838  {
1839  pstr = strchr(str,' ');
1840  if(!pstr)
1841  {
1842  strcpy(Curr_service_name, str);
1843  strcpy(str,"SVC");
1844  }
1845  else
1846  {
1847  pstr++;
1848  strcpy(Curr_service_name, pstr);
1849  }
1850  if(Curr_service_id)
1851  {
1852  dic_release_service(Curr_service_id);
1853  Curr_service_id = 0;
1854  }
1855  if(str[0] == 'S')
1856  {
1857  /*
1858  if((!strstr(pstr,"/SERVICE_LIST")) &&
1859  (!strstr(pstr,"/CLIENT_LIST")) &&
1860  (!strstr(pstr,"/SERVER_LIST")))
1861  {
1862  Curr_service_id = dic_info_service(Curr_service_name,
1863  MONITORED,5,0,0,
1864  recv_service_info,0,
1865  &no_link_int,4);
1866  }
1867  else
1868  {
1869  */
1870  dic_info_service_stamped(Curr_service_name,
1871  ONCE_ONLY,10,0,0,
1872  recv_service_info,0,
1873  &no_link_int,4);
1874  /*
1875  }
1876  */
1877  put_selection(DID_SERVICE,"Service Contents");
1878  }
1879  else
1880  {
1881  get_service_format();
1882  sel_id = put_selection(DID_COMMAND,"Send Command");
1883  id = XmSelectionBoxGetChild(sel_id,XmDIALOG_HELP_BUTTON);
1884  XtUnmanageChild(id);
1885  id = XmSelectionBoxGetChild(sel_id,XmDIALOG_APPLY_BUTTON);
1886  XtUnmanageChild(id);
1887  id = XmSelectionBoxGetChild(sel_id,XmDIALOG_LIST);
1888  /*
1889  XtUnmanageChild(id);
1890  */
1891  XtUnmapWidget(id);
1892  }
1893  XtFree(str);
1894  }
1895  if(tag == DID_COMMAND)
1896  {
1897  did_prepare_command(str);
1898  XtFree(str);
1899  }
1900 }
1901 
1902 int get_type_size(char type)
1903 {
1904  int size;
1905 
1906  switch(type)
1907  {
1908  case 'L':
1909  case 'l':
1910  size = sizeof(long);
1911  break;
1912  case 'I':
1913  case 'i':
1914  size = sizeof(int);
1915  break;
1916  case 'S':
1917  case 's':
1918  size = sizeof(short);
1919  break;
1920  case 'F':
1921  case 'f':
1922  size = sizeof(float);
1923  break;
1924  case 'D':
1925  case 'd':
1926  size = sizeof(double);
1927  break;
1928  case 'C':
1929  case 'c':
1930  default:
1931  size = 1;
1932  }
1933  return(size);
1934 }
1935 
1936 void did_prepare_command(char *str)
1937 {
1938 char type;
1939 int num;
1940 int size, full_size = 0;
1941 char *ptr;
1942 static int last_size = 0;
1943 static void *last_buffer = 0;
1944 void *buffer_ptr;
1945 char *str_ptr;
1946 void did_read_string(char, int, void **, char **);
1947 
1948  str_ptr = str;
1949  ptr = Curr_service_format;
1950  while(*ptr)
1951  {
1952  type = *ptr++;
1953  if(*ptr == ':')
1954  {
1955  ptr++;
1956  size = get_type_size(type);
1957  sscanf(ptr, "%d", &num);
1958  full_size += size * num;
1959  if( (ptr = strchr(ptr,';')) )
1960  ptr++;
1961  else
1962  break;
1963  }
1964  }
1965 
1966  full_size += 256;
1967  if(full_size > last_size)
1968  {
1969  if(last_size)
1970  free(last_buffer);
1971  last_buffer = malloc(full_size);
1972  last_size = full_size;
1973  }
1974  buffer_ptr = last_buffer;
1975  ptr = Curr_service_format;
1976  while(*ptr)
1977  {
1978  type = *ptr++;
1979  if(*ptr == ':')
1980  {
1981  ptr++;
1982  sscanf(ptr, "%d", &num);
1983  did_read_string(type, num, &buffer_ptr, &str_ptr);
1984  if(!str_ptr)
1985  break;
1986  if( (ptr = strchr(ptr,';')) )
1987  ptr++;
1988  else
1989  break;
1990  }
1991  else
1992  {
1993  did_read_string(type, 0, &buffer_ptr, &str_ptr);
1994  break;
1995  }
1996  }
1997  full_size = (int) ((char *)buffer_ptr - (char *)last_buffer);
1998  dic_cmnd_service(Curr_service_name,last_buffer,full_size);
1999 }
2000 
2001 int read_str_int(char *str)
2002 {
2003  int i;
2004  if((str[0] == '0') && (str[1] == 'x'))
2005  sscanf(str+2,"%x",&i);
2006  else
2007  sscanf(str,"%d",&i);
2008  return(i);
2009 }
2010 
2011 int read_str_char(char *str, char *cc)
2012 {
2013 
2014  if(str[0] == '\'')
2015  *cc = str[1];
2016  else if(str[0] == '\"')
2017  return(0);
2018  else if((str[0] == '0') && (str[1] == 'x'))
2019  sscanf(str+2,"%x",(int *)cc);
2020  else if(isalpha(str[0]))
2021  return(-1);
2022  else
2023  sscanf(str,"%d",(int *)cc);
2024  return(1);
2025 }
2026 
2027 void did_read_string(char type, int num, void **buffer_ptr, char **str_ptr)
2028 {
2029 int i, ret = 0;
2030 float ff;
2031 double dd;
2032 void *ptr;
2033 char *strp, *ptr1;
2034 char cc;
2035  short s;
2036 
2037  strp = *str_ptr;
2038  ptr = *buffer_ptr;
2039  if(!num)
2040  num = 1000000;
2041  switch(type)
2042  {
2043  case 'L':
2044  case 'l':
2045  case 'I':
2046  case 'i':
2047  for(i = 0; i<num; i++)
2048  {
2049  *(int *)ptr = read_str_int(strp);
2050  ptr = (int *)ptr +1;
2051  if( (strp = strchr(strp,' ')) )
2052  strp++;
2053  else
2054  break;
2055  }
2056  break;
2057  case 'S':
2058  case 's':
2059  for(i = 0; i<num; i++)
2060  {
2061  s = (short)read_str_int(strp);
2062  *((short *)ptr) = s;
2063  ptr = (short *)ptr +1;
2064  if( (strp = strchr(strp,' ')) )
2065  strp++;
2066  else
2067  break;
2068  }
2069  break;
2070  case 'F':
2071  case 'f':
2072  for(i = 0; i<num; i++)
2073  {
2074  sscanf(strp,"%f",&ff);
2075  *(float *)ptr = ff;
2076  ptr = (float *)ptr +1;
2077  if( (strp = strchr(strp,' ')) )
2078  strp++;
2079  else
2080  break;
2081  }
2082  break;
2083  case 'D':
2084  case 'd':
2085  for(i = 0; i<num; i++)
2086  {
2087  sscanf(strp,"%f",&ff);
2088  dd = (double)ff;
2089  *(double *)ptr = dd;
2090  ptr = (double *)ptr +1;
2091  if( (strp = strchr(strp,' ')) )
2092  strp++;
2093  else
2094  break;
2095  }
2096  break;
2097  case 'C':
2098  case 'c':
2099  default:
2100  for(i = 0; i<num; i++)
2101  {
2102  if((ret = read_str_char(strp, &cc)) <= 0)
2103  break;
2104  *(char *)ptr = cc;
2105  ptr = (char *)ptr +1;
2106  if( (strp = strchr(strp,' ')) )
2107  strp++;
2108  else
2109  break;
2110  }
2111  if(ret <= 0)
2112  {
2113  if(!ret)
2114  {
2115  strp++;
2116  }
2117  num = strlen(strp)+1;
2118  strncpy((char *)ptr,strp,num);
2119  if( (ptr1 = (char *)strchr((char *)ptr,'\"')) )
2120  {
2121  num--;
2122  *ptr1 = '\0';
2123  }
2124  ptr = (char *)ptr + num;
2125  if( (strp = strchr(strp,' ')) )
2126  strp++;
2127  else
2128  break;
2129  }
2130  }
2131  *buffer_ptr = ptr;
2132  *str_ptr = strp;
2133 }
2134 
2135 void cancel_pop_up (Widget w, int tag, unsigned long *reason)
2136 {
2137  void print_service_formatted();
2138 
2139  if(reason){}
2140  if(tag == MAX_POP_UPS+1)
2141  {
2142  print_service_formatted(Service_buffer,Service_size);
2143  set_something(Content_label_id,XmNlabelString, Service_content_str);
2144  Curr_service_print_type = 0;
2145  }
2146  /*
2147  else if(tag == MAX_POP_UPS+2)
2148  {
2149  print_service_float(Service_buffer, ((Service_size - 1) / 4) + 1);
2150  set_something(Content_label_id,XmNlabelString, Service_content_str);
2151  Curr_service_print_type = 1;
2152  }
2153  else if(tag == MAX_POP_UPS+3)
2154  {
2155  print_service_double(Service_buffer, ((Service_size - 1) / 4) + 1);
2156  set_something(Content_label_id,XmNlabelString, Service_content_str);
2157  Curr_service_print_type = 2;
2158  }
2159  */
2160  else if(tag == MAX_POP_UPS+4)
2161  {
2162 
2163  if((!strstr(Curr_service_name,"/SERVICE_LIST")) &&
2164  (!strstr(Curr_service_name,"/CLIENT_LIST")) &&
2165  (!strstr(Curr_service_name,"/SERVER_LIST")))
2166  {
2167  if(Curr_service_id)
2168  {
2169  dic_release_service(Curr_service_id);
2170  Curr_service_id = 0;
2171  }
2172  Curr_service_id = dic_info_service_stamped(Curr_service_name,
2173  MONITORED,10,0,0,
2174  recv_service_info,0,
2175  &no_link_int,4);
2176  }
2177  XtSetSensitive(w, False);
2178  XtSetSensitive(SubscribeButton, True);
2179  }
2180  else if(tag == MAX_POP_UPS+5)
2181  {
2182 
2183  if((!strstr(Curr_service_name,"/SERVICE_LIST")) &&
2184  (!strstr(Curr_service_name,"/CLIENT_LIST")) &&
2185  (!strstr(Curr_service_name,"/SERVER_LIST")))
2186  {
2187  if(Curr_service_id)
2188  {
2189  dic_release_service(Curr_service_id);
2190  Curr_service_id = 0;
2191  }
2192  Curr_service_id = dic_info_service_stamped(Curr_service_name,
2193  MONITORED,0,0,0,
2194  recv_service_info,0,
2195  &no_link_int,4);
2196  }
2197  XtSetSensitive(w, False);
2198  XtSetSensitive(Subscribe10Button, True);
2199  }
2200 /*
2201  else if(tag == 5)
2202  {
2203  *
2204  XtUnmapWidget(XtParent(pop_widget_id[4]));
2205  *
2206  }
2207 */
2208  else if(tag == DID_SERVICE)
2209  {
2210  if(Curr_service_id)
2211  {
2212  dic_release_service(Curr_service_id);
2213  Curr_service_id = 0;
2214  }
2215  XtUnmanageChild(pop_widget_id[DID_SERVICE]);
2216  free(Service_content_str);
2217  free(Service_buffer);
2218  }
2219 }
2220 
2221 void create_matrix(Widget w, int *tag, unsigned long *reason)
2222 {
2223 
2224  if(reason){}
2225  Matrix_id[*tag] = w;
2226  if(*tag)
2227  XtUnmanageChild(w);
2228  else
2229  Curr_matrix = 0;
2230 }
2231 
2232 void create_label(Widget w, int *tag, unsigned long *reason)
2233 {
2234  if(reason){}
2235  if(!*tag)
2236  Label_id = w;
2237  else
2238  Content_label_id = w;
2239 }
2240 
2241 void switch_matrix()
2242 {
2243  /*
2244  XtUnmanageChild(Matrix_id[Curr_matrix]);
2245  Curr_matrix = (Curr_matrix) ? 0 : 1;
2246  XtManageChild(Matrix_id[Curr_matrix]);
2247  */
2248  XmScrolledWindowSetAreas(Window_id,NULL, NULL, Matrix_id[Curr_matrix]);
2249 }
2250 
2251 /*
2252 static int curr_allocated_size = 0;
2253 static DNS_SERVER_INFO *dns_info_buffer;
2254 */
2255 
2256 void update_servers_new(int *tag, char *buffer, int *size)
2257 {
2258  if(tag){}
2259  if(size){}
2260  printf("Server_list:\n%s\n",buffer);
2261 }
2262 
2263 SERVER *find_server(char *node, int pid)
2264 {
2265  SERVER *servp;
2266  DNS_SERVER_INFO *ptr;
2267 
2268  servp = Server_head;
2269  while( (servp = (SERVER *)sll_get_next((SLL *)servp)) )
2270  {
2271  ptr = &servp->server;
2272  if((ptr->pid == pid) && (!strcmp(ptr->node,node)))
2273  {
2274  return(servp);
2275  }
2276  }
2277  return ((SERVER *)0);
2278 }
2279  /*
2280  if(!(servp = (SERVER *)sll_search((SLL *)Server_head,
2281  (char *)&buffer->server, MAX_NODE_NAME+MAX_TASK_NAME-4)))
2282  */
2283 
2284 
2285 void update_servers(int *tag, DNS_DID *buffer, int *size)
2286 {
2287 int n_services, service_size;
2288 SERVER *servp;
2289 int j;
2290 char str[MAX_NAME], sname[MAX_NAME], *ptr;
2291 
2292  if(tag){}
2293  if(!Server_head)
2294  {
2295  Server_head = (SERVER *)malloc(sizeof(SERVER));
2296  sll_init((SLL *)Server_head);
2297  }
2298  if(First_time)
2299  {
2300  switch_matrix();
2301  First_time = 0;
2302  }
2303 
2304  if(!*size)
2305  return;
2306  if(*(char *)buffer == -1)
2307  {
2308  N_servers = 0;
2309  N_services = 0;
2310  return;
2311  }
2312  buffer->server.n_services = vtohl(buffer->server.n_services);
2313  buffer->server.pid = vtohl(buffer->server.pid);
2314  n_services = buffer->server.n_services;
2315 
2316  if(n_services == 1)
2317  return;
2318  strcpy(sname, buffer->server.task);
2319  if(n_services > 1)
2320  {
2321  for(j = 0; j < n_services; j++)
2322  {
2323  buffer->services[j].type = vtohl(
2324  buffer->services[j].type);
2325  buffer->services[j].status = vtohl(
2326  buffer->services[j].status);
2327  buffer->services[j].n_clients = vtohl(
2328  buffer->services[j].n_clients);
2329  if(strlen(sname) == MAX_TASK_NAME-4-1)
2330  {
2331  strcpy(str,buffer->services[j].name);
2332  if( (ptr = strstr(str,"/CLIENT_LIST")) )
2333  {
2334  *ptr = '\0';
2335  strcpy(sname,str);
2336  }
2337  }
2338  }
2339  }
2340  if (!(servp = find_server(buffer->server.node,buffer->server.pid)))
2341  /*
2342  if(!(servp = (SERVER *)sll_search((SLL *)Server_head,
2343  (char *)&buffer->server, MAX_NODE_NAME+MAX_TASK_NAME-4)))
2344  */
2345  {
2346  if(n_services)
2347  {
2348  servp = (SERVER *)malloc(sizeof(SERVER));
2349  strcpy(servp->name,sname);
2350  servp->next = 0;
2351  servp->button_id = 0;
2352  servp->pop_widget_id[0] = 0;
2353  servp->pop_widget_id[1] = 0;
2354  servp->busy = 0;
2355  servp->server.n_services = 0;
2356  servp->service_ptr = 0;
2357  sll_insert_queue((SLL *)Server_head,(SLL *)servp);
2358  }
2359  }
2360  if(n_services != 0)
2361  {
2362  if(n_services == servp->server.n_services)
2363  {
2364  return;
2365  }
2366  if(servp->server.n_services == 0)
2367  N_servers++;
2368  if(servp->server.n_services != -1)
2369  N_services -= servp->server.n_services;
2370  memcpy(&servp->server,&buffer->server,sizeof(DNS_SERVER_INFO));
2371  if(servp->service_ptr)
2372  {
2373  free(servp->service_ptr);
2374  servp->service_ptr = 0;
2375  }
2376  if(n_services != -1)
2377  {
2378  service_size = n_services*sizeof(DNS_SERVICE_INFO);
2379  servp->service_ptr = (DNS_SERVICE_INFO *)malloc(service_size);
2380  memcpy(servp->service_ptr, buffer->services, service_size);
2381  N_services += n_services;
2382  }
2383  servp->busy = 1;
2384  }
2385  else
2386  {
2387  if(servp)
2388  {
2389  N_servers--;
2390  if(servp->server.n_services != -1)
2391  {
2392  N_services -= servp->server.n_services;
2393  }
2394  else
2395  Force_update = 1;
2396  servp->server.n_services = 0;
2397  servp->busy = -1;
2398  }
2399  }
2400 }
2401 
2402 void show_servers()
2403 {
2404 SERVER *servp;
2405 void update_show_servers();
2406 void remove_all_buttons();
2407 void put_label();
2408 
2409  if(!Matrix_id[Curr_matrix])
2410  return;
2411  remove_all_buttons();
2412 
2413 #ifndef linux
2414  switch_matrix();
2415 #endif
2416  put_label();
2417  servp = Server_head;
2418  while( (servp = (SERVER *)sll_get_next((SLL *)servp)) )
2419  {
2420  servp->busy = 1;
2421  }
2422  Force_update = 1;
2423 }
2424 
2425 void update_show_servers(void *tag, unsigned long *reason)
2426 {
2427 DNS_SERVER_INFO *server_ptr;
2428 DNS_SERVICE_INFO *service_ptr;
2429 int i, j, found, n_done = 0;
2430 Widget w, create_button();
2431 SERVER *servp, *prevp;
2432 static int old_n_services = 0;
2433 char node[MAX_NODE_NAME], par[MAX_NODE_NAME], *ptr;
2434 void remove_button();
2435 void remove_all_buttons();
2436 void put_label();
2437 
2438  DISABLE_AST
2439  if(tag){}
2440  if(reason){}
2441  if((N_services != old_n_services) || (Force_update))
2442  {
2443  if(!Matrix_id[Curr_matrix])
2444  {
2445  XtAppAddTimeOut(app_context, 1000, update_show_servers, 0);
2446  ENABLE_AST
2447  return;
2448  }
2449  if(!N_servers)
2450  {
2451  remove_all_buttons();
2452  if(! No_link_button_id)
2453  {
2454  No_link_button_id = create_button("DNS is down", 0);
2455  set_color(No_link_button_id, XmNbackground, RED);
2456  get_something(No_link_button_id,XmNuserData,&w);
2457  set_color(w, XmNbackground, RED);
2458  XtSetSensitive(No_link_button_id, False);
2459  }
2460  while(!sll_empty((SLL *)Server_head))
2461  {
2462  servp = (SERVER *)sll_remove_head((SLL *)Server_head);
2463  if(servp->service_ptr)
2464  free(servp->service_ptr);
2465  free(servp);
2466  }
2467  put_label();
2468  old_n_services = N_services;
2469  Force_update = 0;
2470  XtAppAddTimeOut(app_context, 1000, update_show_servers, 0);
2471  ENABLE_AST
2472  return;
2473  }
2474  if(No_link_button_id)
2475  {
2476  XtDestroyWidget(No_link_button_id);
2477  /*
2478  XFlush(XtDisplay(No_link_button_id));
2479  */
2480  No_link_button_id = 0;
2481  }
2482  servp = Server_head;
2483  prevp = 0;
2484  while( (servp = (SERVER *)sll_get_next((SLL *)servp)) )
2485  {
2486  if(prevp)
2487  {
2488  free(prevp);
2489  prevp = 0;
2490  }
2491  if(n_done == 10)
2492  {
2493  if(!Force_update)
2494  put_label();
2495  XtAppAddTimeOut(app_context, 100, update_show_servers, 0);
2496  ENABLE_AST
2497  return;
2498  }
2499  server_ptr = &servp->server;
2500  if(servp->busy == 1)
2501  {
2502  if(!servp->button_id)
2503  {
2504  switch(Curr_view_opt)
2505  {
2506  case 1 :
2507  servp->button_id = create_button(/*server_ptr->task*/servp->name, servp);
2508  n_done++;
2509  break;
2510  case 0 :
2511  strcpy(node, server_ptr->node);
2512  strcpy(par, Curr_view_opt_par);
2513  ptr = strchr(node, '.');
2514  if(ptr)
2515  *ptr = '\0';
2516  ptr = strchr(par,'.');
2517  if(ptr)
2518  *ptr = '\0';
2519  ptr = node;
2520  for(i = 0; i < (int)strlen(ptr); i++)
2521  ptr[i] = tolower(ptr[i]);
2522  ptr = par;
2523  for(i = 0; i < (int)strlen(ptr); i++)
2524  ptr[i] = tolower(ptr[i]);
2525  if(!strcmp(/*server_ptr->*/node, /*Curr_view_opt_*/par))
2526  {
2527  servp->button_id = create_button(/*server_ptr->task*/servp->name, servp);
2528  n_done++;
2529  }
2530  break;
2531  case 2 :
2532  found = 0;
2533  if(!(service_ptr = servp->service_ptr))
2534  break;
2535  for(j = 0; j < server_ptr->n_services; j++)
2536  {
2537  if(strstr(service_ptr->name, Curr_view_opt_par) > (char *)0)
2538  {
2539  found = 1;
2540  break;
2541  }
2542  service_ptr++;
2543  }
2544  if (found)
2545  {
2546  servp->button_id = create_button(/*server_ptr->task*/servp->name, servp);
2547  n_done++;
2548  }
2549  break;
2550  case 3 :
2551  if(server_ptr->n_services == -1)
2552  {
2553  servp->button_id = create_button(/*server_ptr->task*/servp->name, servp);
2554  n_done++;
2555  }
2556  else
2557  {
2558  if(servp->button_id)
2559  remove_button(servp);
2560  }
2561  n_done++;
2562  break;
2563  }
2564  }
2565  servp->busy = 2;
2566  if(servp->button_id)
2567  {
2568  if(Curr_view_opt != -1)
2569  {
2570  if (server_ptr->n_services == -1)
2571  {
2572  set_color(servp->button_id, XmNbackground, RED);
2573  get_something(servp->button_id,XmNuserData,&w);
2574  set_color(w, XmNbackground, RED);
2575  }
2576  else
2577  {
2578  set_color(servp->button_id, XmNbackground, GREEN);
2579  get_something(servp->button_id,XmNuserData,&w);
2580  set_color(w, XmNbackground, GREEN);
2581  }
2582  }
2583  }
2584  }
2585  else if (servp->busy == -1)
2586  {
2587  remove_button(servp);
2588  sll_remove((SLL *)Server_head, (SLL *)servp);
2589  if(servp->service_ptr)
2590  {
2591  free(servp->service_ptr);
2592  servp->service_ptr = 0;
2593  }
2594  prevp = servp;
2595  n_done++;
2596  }
2597  }
2598  if(prevp)
2599  {
2600  free(prevp);
2601  prevp = 0;
2602  }
2603  put_label();
2604  old_n_services = N_services;
2605  Force_update = 0;
2606  }
2607  XtAppAddTimeOut(app_context, 1000, update_show_servers, 0);
2608  ENABLE_AST
2609 }
2610 
2611 Widget create_button(char *name, SERVER *servp)
2612 {
2613 Arg arglist[10];
2614 int n, n_services = -1;
2615 Widget w, ww, w_id;
2616 void activate_services(), activate_clients();
2617 char w_name[MAX_NAME];
2618 
2619  w_name[0] = 0;
2620  if(servp)
2621  n_services = servp->server.n_services;
2622  strcpy(w_name,name);
2623  if(strlen(w_name) >= MAX_TASK_NAME - 4)
2624  w_name[16] = '\0';
2625  n = 0;
2626  XtSetArg(arglist[n], XmNorientation, XmVERTICAL); n++;
2627  XtSetArg(arglist[n], XmNentryAlignment, XmALIGNMENT_CENTER); n++;
2628  w_id = w = XmCreateMenuBar(Matrix_id[Curr_matrix],
2629  (String)XmStringCreateLtoR ( w_name,XmSTRING_DEFAULT_CHARSET),
2630  arglist,n);
2631 /*
2632  if(n_services == -1)
2633  set_color(w, XmNbackground, RED);
2634  else
2635  set_color(w, XmNbackground, GREEN);
2636 */
2637  XtManageChild(w);
2638  strcat(w_name,"1");
2639  n = 0;
2640  XtSetArg(arglist[n], XmNalignment, XmALIGNMENT_CENTER); n++;
2641  XtSetArg(arglist[n], XmNfontList, did_server_font); n++;
2642  w = XmCreateCascadeButton(w,
2643  (String)XmStringCreateLtoR ( w_name,XmSTRING_DEFAULT_CHARSET),
2644  arglist,n);
2645  set_something(w,XmNlabelString,name);
2646  set_something(w,XmNalignment,XmALIGNMENT_CENTER);
2647 /*
2648  if(n_services == -1)
2649  set_color(w, XmNbackground, RED);
2650  else
2651  set_color(w, XmNbackground, GREEN);
2652 */
2653  set_something(w_id,XmNuserData,w);
2654  strcat(w_name,"1");
2655  n = 0;
2656  ww = XmCreatePulldownMenu(w_id,
2657  (String)XmStringCreateLtoR ( w_name,XmSTRING_DEFAULT_CHARSET),
2658  arglist,n);
2659  set_something(w,XmNsubMenuId,ww);
2660  XtManageChild(w);
2661  strcat(w_name,"1");
2662  n = 0;
2663  XtSetArg(arglist[n], XmNfontList, did_default_font); n++;
2664  w = XmCreatePushButton(ww,
2665  (String)XmStringCreateLtoR ( w_name,XmSTRING_DEFAULT_CHARSET),
2666  arglist,n);
2667 
2668  set_something(w,XmNlabelString,"Services");
2669  if(servp)
2670  {
2671  XtAddCallback(w,XmNactivateCallback, activate_services, servp);
2672  XtManageChild(w);
2673  strcat(w_name,"1");
2674  n = 0;
2675  XtSetArg(arglist[n], XmNfontList, did_default_font); n++;
2676  w = XmCreatePushButton(ww,
2677  (String)XmStringCreateLtoR ( w_name,XmSTRING_DEFAULT_CHARSET),
2678  arglist,n);
2679 
2680  set_something(w,XmNlabelString,"Clients");
2681  XtAddCallback(w,XmNactivateCallback, activate_clients, servp);
2682  XtManageChild(w);
2683  /*
2684  servp->popping = 0;
2685  create_client_popup(servp);
2686  */
2687  }
2688  return(w_id);
2689 }
2690 
2691 void remove_all_buttons()
2692 {
2693 SERVER *servp;
2694 
2695  servp = Server_head;
2696  while( (servp = (SERVER *)sll_get_next((SLL *)servp)) )
2697  {
2698  if(servp->button_id)
2699  {
2700  XtDestroyWidget(servp->button_id);
2701  servp->button_id = 0;
2702  servp->busy = 0;
2703  }
2704  }
2705 }
2706 
2707 void remove_button(SERVER *servp)
2708 {
2709 
2710  if(servp->button_id)
2711  {
2712  XtDestroyWidget(servp->button_id);
2713  servp->button_id = 0;
2714  servp->busy = 0;
2715  }
2716 }
2717 
2718 void activate_services(Widget w, SERVER *servp, unsigned long *reason)
2719 {
2720 DNS_SERVER_INFO *ptr;
2721 char str[MAX_NAME];
2722 Widget id,sel_id;
2723 void got_service_list();
2724 void kick_it();
2725 
2726  if(w){}
2727  if(reason){}
2728  if(servp->pop_widget_id[0])
2729  {
2730  XtDestroyWidget(servp->pop_widget_id[0]);
2731  servp->pop_widget_id[0] = 0;
2732  /*
2733  return;
2734  */
2735  }
2736  Curr_servp = servp;
2737  ptr = &servp->server;
2738 
2739  sel_id = put_popup(servp, 0,"Service Info");
2740 
2741  id = XmSelectionBoxGetChild(sel_id,XmDIALOG_OK_BUTTON);
2742  XtUnmanageChild(id);
2743 
2744  id = XmSelectionBoxGetChild(sel_id,XmDIALOG_LIST_LABEL);
2745  if (ptr->pid > 0x1000000)
2746  sprintf(str,"Server %s (pid = %X) on node %s\n\nprovides %d services :\n",
2747  servp->name, ptr->pid, ptr->node, ptr->n_services);
2748  else
2749  sprintf(str,"Server %s (pid = %d) on node %s\n\nprovides %d services :\n",
2750  servp->name, ptr->pid, ptr->node, ptr->n_services);
2751  set_something(sel_id,XmNlistLabelString,str);
2752 
2753  id = XmSelectionBoxGetChild(sel_id,XmDIALOG_LIST);
2754  Curr_service_list_id = id;
2755 
2756  XmListAddItem(id,create_str(
2757  "Ordering services alphabeticaly, please be patient..."),1);
2758 
2759  set_something(id,XmNlistItemCount,1);
2760  set_something(id,XmNlistVisibleItemCount,1);
2761 
2762  sprintf(str,"%s/SERVICE_LIST",/*ptr->task*/servp->name);
2763  dic_info_service(str,ONCE_ONLY,20,0,0,
2764  got_service_list,(long)servp,"None",5);
2765  /*
2766 #ifdef solaris
2767  */
2768  /*
2769  XtAppAddTimeOut(app_context, 1000, kick_it, 0);
2770  */
2771  /*
2772 #endif
2773  */
2774 }
2775 
2776 void kick_it()
2777 {
2778  printf("kick_it\n");
2779 }
2780 
2781 typedef char DID_SLOT[MAX_NAME];
2782 
2783 void got_service_list(SERVER **servp_ptr, char *buffer, int *size)
2784 {
2785 SERVER *servp;
2786 void do_got_service_list();
2787 
2788  if(size){}
2789  servp = *servp_ptr;
2790  if(Curr_service_list)
2791  free(Curr_service_list);
2792  Curr_service_list = malloc(strlen(buffer)+1);
2793  strcpy(Curr_service_list, buffer);
2794  /*
2795 #ifdef solaris
2796  */
2797  Got_Service_List = servp;
2798  /*
2799 #else
2800  do_got_service_list(servp);
2801 #endif
2802  */
2803 }
2804 
2805 void do_got_service_list(SERVER *servp)
2806 {
2807 char cmd_str[256], svc_str[256];
2808 DNS_SERVER_INFO *ptr;
2809 DNS_SERVICE_INFO *service_ptr;
2810 Widget id;
2811 char *curr_str, max_str[MAX_NAME], *sptr;
2812 DID_SLOT *service_list;
2813 int i, j, curr_index = 0, n_services;
2814 XmString xstr;
2815 void delete_str();
2816 
2817  ptr = &servp->server;
2818  id = Curr_service_list_id;
2819 
2820  XmListDeleteAllItems(id);
2821 
2822  strcpy(cmd_str,"CMD: ");
2823  strcpy(svc_str,"SVC: ");
2824 
2825  service_ptr = servp->service_ptr;
2826  service_list = (DID_SLOT *)malloc(ptr->n_services * MAX_NAME);
2827  n_services = ptr->n_services;
2828 
2829  for(i=0;i<n_services; i++)
2830  {
2831  strcpy(service_list[i],service_ptr->name);
2832  service_ptr++;
2833  }
2834  strcpy(max_str,"zzzzzzzzzzzzzzzzzzzzzzzzzzzz");
2835  for(i=0;i<n_services; i++)
2836  {
2837  curr_str = max_str;
2838  for(j=0;j<n_services; j++)
2839  {
2840  sptr = service_list[j];
2841  if(!*sptr)
2842  continue;
2843 
2844  if(strcmp(sptr,curr_str) < 0)
2845  {
2846  curr_str = sptr;
2847  curr_index = j;
2848  }
2849  }
2850  service_list[curr_index][0] = '\0';
2851  service_ptr = &(servp->service_ptr[curr_index]);
2852  if(service_ptr->type)
2853  {
2854  strcpy(&cmd_str[5],service_ptr->name);
2855  xstr = create_str(cmd_str);
2856  XmListAddItem(id,xstr,i+1);
2857  delete_str(xstr);
2858  }
2859  else
2860  {
2861  strcpy(&svc_str[5],service_ptr->name);
2862  xstr = create_str(svc_str);
2863  XmListAddItem(id,xstr,i+1);
2864  delete_str(xstr);
2865  }
2866  }
2867  free(service_list);
2868 
2869  set_something(id,XmNlistItemCount,i);
2870  set_something(id,XmNlistVisibleItemCount,(i < 20) ? i : 20);
2871 }
2872 
2873 void show_clients(SERVER **servp_ptr, char *buffer, int *size)
2874 {
2875 SERVER *servp;
2876 void do_show_clients();
2877 
2878  if(size){}
2879  servp = *servp_ptr;
2880  if(Curr_client_list)
2881  free(Curr_client_list);
2882  Curr_client_list = malloc(strlen(buffer)+1);
2883  strcpy(Curr_client_list, buffer);
2884  /*
2885 #ifdef solaris
2886  */
2887  Got_Client_List = servp;
2888  /*
2889 #else
2890  do_show_clients(servp);
2891 #endif
2892  */
2893 }
2894 
2895 void do_show_clients(SERVER *servp)
2896 {
2897 int i = 0;
2898 char str[2048], *strp, *strp1;
2899 DNS_SERVER_INFO *ptr;
2900 XmString xstr;
2901 void delete_str();
2902 
2903  ptr = &servp->server;
2904  /*
2905  sel_id = servp->pop_widget_id[1];
2906  id = (Widget)XmSelectionBoxGetChild(sel_id,XmDIALOG_LIST_LABEL);
2907  */
2908  if(Curr_client_list[0] == -1)
2909  {
2910  sprintf(str,"Information not available\n");
2911  XmListAddItem(Curr_client_id,create_str(str),i+1);
2912  /*
2913  set_something(sel_id,XmNlistLabelString,str);
2914  */
2915  return;
2916  }
2917  /*
2918  sprintf(str,"Clients of %s are : \n",
2919  ptr->task);
2920  set_something(sel_id,XmNlistLabelString,str);
2921 
2922  id = (Widget)XmSelectionBoxGetChild(sel_id,XmDIALOG_LIST);
2923  XmListDeleteAllItems(id);
2924  */
2925  strp1 = Curr_client_list;
2926  while(strp1)
2927  {
2928  if(!*strp1)
2929  break;
2930  sprintf(str,"Process ");
2931  strp = strp1;
2932  strp1 = strchr(strp,'@');
2933  *strp1 = '\0';
2934  strp1++;
2935  strcat(str,strp);
2936  strcat(str," on node ");
2937  strp = strp1;
2938  if( (strp1 = strchr(strp,'|')) )
2939  {
2940  *strp1 = '\0';
2941  strp1++;
2942  }
2943  strcat(str,strp);
2944  xstr = create_str(str);
2945  XmListAddItem(Curr_client_id,xstr,i+1);
2946  delete_str(xstr);
2947  i++;
2948  }
2949  if(!i)
2950  {
2951  sprintf(str,"NONE");
2952  xstr = create_str(str);
2953  XmListAddItem(Curr_client_id,xstr,i+1);
2954  delete_str(xstr);
2955  }
2956  /*
2957  set_something(id,XmNlistItemCount,i);
2958  */
2959  /*
2960  if(Matrix_id[Curr_matrix])
2961  XFlush(XtDisplay(Matrix_id[Curr_matrix]));
2962  */
2963 }
2964 
2965 void activate_clients(Widget w, SERVER *servp, unsigned long *reason)
2966 {
2967 DNS_SERVER_INFO *ptr;
2968 char str[100];
2969 void show_clients();
2970 void kick_it_again();
2971 Widget id,sel_id;
2972 
2973  if(w) {}
2974  if(reason){}
2975  Curr_servp = servp;
2976  ptr = &servp->server;
2977  if(servp->pop_widget_id[1])
2978  {
2979  XtDestroyWidget(servp->pop_widget_id[1]);
2980  servp->pop_widget_id[1] = 0;
2981  }
2982  sel_id = put_popup(servp,1,"Client Info");
2983 
2984  id = XmSelectionBoxGetChild(sel_id,XmDIALOG_HELP_BUTTON);
2985  XtUnmanageChild(id);
2986 
2987  id = XmSelectionBoxGetChild(sel_id,XmDIALOG_APPLY_BUTTON);
2988  XtUnmanageChild(id);
2989 
2990  id = XmSelectionBoxGetChild(sel_id,XmDIALOG_CANCEL_BUTTON);
2991  XtUnmanageChild(id);
2992 
2993  id = XmSelectionBoxGetChild(sel_id,XmDIALOG_TEXT);
2994  XtUnmanageChild(id);
2995 
2996  id = XmSelectionBoxGetChild(sel_id,XmDIALOG_SELECTION_LABEL);
2997  XtUnmanageChild(id);
2998  /*
2999  id = (Widget)XmSelectionBoxGetChild(sel_id,XmDIALOG_LIST_LABEL);
3000  */
3001  id = XmSelectionBoxGetChild(sel_id,XmDIALOG_LIST);
3002  XmListDeleteAllItems(id);
3003 
3004  Curr_client_id = id;
3005  sprintf(str,"Clients of %s are : \n",
3006  servp->name);
3007  set_something(sel_id,XmNlistLabelString,str);
3008 
3009  sprintf(str,"%s/CLIENT_LIST",/*ptr->task*/servp->name);
3010  dic_info_service(str,ONCE_ONLY,10,0,0,
3011  show_clients,(long)servp,&no_link,1);
3012  /*
3013 #ifdef solaris
3014  */
3015  /*
3016  XtAppAddTimeOut(app_context, 1000, kick_it_again, 0);
3017  */
3018  /*
3019 #endif
3020  */
3021 }
3022 
3023 void kick_it_again()
3024 {
3025  printf("kick_it_again\n");
3026 }
3027 
3028 Widget put_popup(SERVER *servp, int type, char *title)
3029 {
3030  Widget id;
3031  void activate_services(), activate_clients();
3032  extern void set_title();
3033 
3034  if(type)
3035  {
3036  id = create_client_dialog();
3037  /*
3038  XtAddCallback(id,XmNokCallback, activate_clients, servp);
3039  XtAddCallback(id,XmNcancelCallback, activate_clients, servp);
3040  */
3041  }
3042  else
3043  {
3044  id = create_server_dialog();
3045  /*
3046  XtAddCallback(id,XmNcancelCallback, activate_services, servp);
3047  */
3048  }
3049  servp->pop_widget_id[type] = id;
3050  /*
3051  }
3052  */
3053  XtManageChild(id);
3054  set_title(XtParent(id),title);
3055  return(id);
3056 }
3057 
3058 Widget put_selection(int tag, char *title)
3059 {
3060  Widget id = 0;
3061  extern void set_title();
3062 
3063  if(pop_widget_id[tag])
3064  {
3065  XtDestroyWidget(pop_widget_id[tag]);
3066  }
3067  switch(tag)
3068  {
3069  case DID_SEL_NODE:
3070  id = create_node_selection();
3071  break;
3072  case DID_SEL_SERVICE:
3073  id = create_service_selection();
3074  break;
3075  case DID_KILL_ALL:
3076  id = create_kill_confirmation();
3077  break;
3078  case DID_SERVICE:
3079  id = create_service_dialog();
3080  break;
3081  case DID_COMMAND:
3082  id = create_send_command();
3083  break;
3084  }
3085 
3086  pop_widget_id[tag] = id;
3087  XtManageChild(id);
3088  set_title(XtParent(id),title);
3089  return(id);
3090 }
3091 
3092 void check_put_label(int tag)
3093 {
3094  static int old_n_services = 0;
3095  static int changing = 0;
3096  void put_label();
3097 
3098  if(tag){}
3099  if(N_services != old_n_services)
3100  {
3101  put_label();
3102  if(N_services > old_n_services)
3103  changing = 1;
3104  old_n_services = N_services;
3105 
3106 #ifdef linux
3107  show_servers();
3108 #endif
3109  }
3110 /*
3111  else
3112  {
3113  if(changing)
3114  {
3115  show_servers();
3116  changing = 0;
3117  }
3118  }
3119 */
3120 }
3121 
3122 void put_label()
3123 {
3124  char str[MAX_NAME], str1[MAX_NAME];
3125 
3126  DISABLE_AST
3127  sprintf(str,"%d Servers known - %d Services Available\n",
3128  N_servers,N_services);
3129  switch(Curr_view_opt)
3130  {
3131  case 1 :
3132  strcat(str,"Displaying ALL Servers");
3133  break;
3134  case 0 :
3135  sprintf(str1,"Displaying Servers on node %s",Curr_view_opt_par);
3136  strcat(str,str1);
3137  break;
3138  case 2 :
3139  sprintf(str1,"Displaying Servers providing Service *%s*",
3140  Curr_view_opt_par);
3141  strcat(str,str1);
3142  break;
3143  case 3 :
3144  strcat(str,"Displaying Servers in ERROR");
3145  break;
3146  case -1 :
3147  strcat(str,"Please Select Viewing Option");
3148  break;
3149  }
3150  set_something(Label_id,XmNlabelString,str);
3151  XFlush(XtDisplay(Label_id));
3152  ENABLE_AST
3153 }
3154 
3155 Widget create_client_dialog()
3156 {
3157  Widget id;
3158  id = create_selection_dialog("Dismiss","","","","",DID_CLIENTS, 3);
3159  return(id);
3160 
3161 }
3162 
3163 Widget create_server_dialog()
3164 {
3165  Widget id;
3166  id = create_selection_dialog("","View / Send","Dismiss","",
3167  "Service / Command :",
3168  DID_SERVICES, 20);
3169  return(id);
3170 }
3171 
3172 Widget create_node_selection()
3173 {
3174  Widget id;
3175  id = create_selection_dialog("","","","Nodes :","Selected Node :",DID_SEL_NODE, 8);
3176  return(id);
3177 
3178 }
3179 
3180 Widget create_service_selection()
3181 {
3182  Widget id;
3183  /*
3184  id = create_prompt_dialog("Enter Service Name :",DID_SEL_SERVICE);
3185  */
3186  id = create_selection_dialog("","","","","Enter Service Name (or search string):",DID_SEL_SERVICE, 0);
3187  return(id);
3188 
3189 }
3190 
3191 Widget create_send_command()
3192 {
3193  Widget id;
3194  char str[256], str1[256];
3195 
3196  sprintf(str,"Command to %s (%s)\n\n",
3197  Curr_service_name, Curr_service_format);
3198 
3199  id = create_selection_dialog("","","",str,"Command:",DID_COMMAND, 1);
3200 
3201  strcpy(str1,"Please enter items separated by spaces:\n(for example: 2 0x123 'A' 23.4 \"a text\")");
3202 
3203  set_something(id,XmNselectionLabelString,str1);
3204 
3205  return(id);
3206 
3207 }
3208 
3209 Widget create_kill_confirmation()
3210 {
3211  Widget id;
3212  id = create_question_dialog("Do you really want to kill ALL DIM servers ?",
3213  DID_KILL_ALL);
3214  return(id);
3215 
3216 }
3217 
3218 Widget create_selection_dialog(char *ok, char *apply, char *cancel, char *list, char *sel,
3219  long tag, int items)
3220 {
3221 Widget sd;
3222 XmString xmOk, xmApply, xmCancel, xmList, xmSelection;
3223 Arg ar[20];
3224 int n;
3225 
3226  xmList = create_str(list);
3227  xmOk = create_str(ok);
3228  xmApply = create_str(apply);
3229  xmCancel = create_str (cancel);
3230  xmSelection = create_str (sel);
3231 
3232  n = 0;
3233  /*
3234  XtSetArg(ar[n],XmNdialogStyle,XmDIALOG_FULL_APPLICATION_MODAL); n++;
3235  XtSetArg(ar[n],XmNmwmFunctions,MWM_FUNC_MOVE); n++;
3236  */
3237  XtSetArg(ar[n],XmNtitle,"Selection"); n++;
3238  XtSetArg(ar[n],XmNlabelFontList, did_default_font); n++;
3239  XtSetArg(ar[n],XmNbuttonFontList, did_default_font); n++;
3240  XtSetArg(ar[n],XmNtextFontList, did_small_font); n++;
3241  XtSetArg(ar[n],XmNborderWidth, 1); n++;
3242  XtSetArg(ar[n],XmNlistLabelString, xmList); n++;
3243  XtSetArg(ar[n],XmNlistVisibleItemCount,items); n++;
3244  if(ok[0])
3245  {
3246  XtSetArg(ar[n],XmNokLabelString, xmOk); n++;
3247  }
3248  if(apply[0])
3249  {
3250  XtSetArg(ar[n],XmNapplyLabelString, xmApply); n++;
3251  }
3252  if(cancel[0])
3253  {
3254  XtSetArg(ar[n],XmNcancelLabelString, xmCancel); n++;
3255  }
3256  if(sel[0])
3257  {
3258  XtSetArg(ar[n],XmNselectionLabelString, xmSelection); n++;
3259  }
3260  sd = XmCreateSelectionDialog ( toplevel_widget, "Selection", ar, n );
3261  XmStringFree(xmList);
3262  XmStringFree(xmOk);
3263  XmStringFree(xmApply);
3264  XmStringFree(xmCancel);
3265  XmStringFree(xmSelection);
3266  if(tag >= 0)
3267  {
3268  XtAddCallback ( sd, XmNcancelCallback,
3269  (XtCallbackProc)cancel_pop_up, (XtPointer)tag );
3270  XtAddCallback ( sd, XmNapplyCallback,
3271  (XtCallbackProc)ok_pop_up, (XtPointer)tag );
3272  XtAddCallback ( sd, XmNokCallback,
3273  (XtCallbackProc)ok_pop_up, (XtPointer)tag );
3274  }
3275  return(sd);
3276 }
3277 
3278 Widget create_file_selection_dialog(long type)
3279 {
3280 Widget sd;
3281 XmString xm1;
3282 Arg ar[20];
3283 int n;
3284 
3285  xm1 = create_str ("");
3286  n = 0;
3287  /*
3288  XtSetArg(ar[n],XmNdialogStyle,XmDIALOG_FULL_APPLICATION_MODAL); n++;
3289  XtSetArg(ar[n],XmNmwmFunctions,MWM_FUNC_MOVE); n++;
3290  */
3291  XtSetArg(ar[n],XmNtitle,"FileSelection"); n++;
3292  XtSetArg(ar[n],XmNlabelFontList, did_default_font); n++;
3293  XtSetArg(ar[n],XmNbuttonFontList, did_default_font); n++;
3294  XtSetArg(ar[n],XmNtextFontList, did_default_font); n++;
3295  XtSetArg(ar[n],XmNborderWidth, 1); n++;
3296  XtSetArg(ar[n],XmNwidth, 500); n++;
3297  XtSetArg(ar[n],XmNdirMask, xm1); n++;
3298  sd = XmCreateFileSelectionDialog ( toplevel_widget, "FileSelection", ar, n );
3299 
3300  XmStringFree(xm1);
3301 
3302  XtAddCallback ( sd, XmNcancelCallback,
3303  (XtCallbackProc)cancel_pop_up, (XtPointer)type );
3304  XtAddCallback ( sd, XmNokCallback,
3305  (XtCallbackProc)ok_pop_up, (XtPointer)type );
3306 
3307  return(sd);
3308 }
3309 
3310 Widget create_prompt_dialog(char *label, long tag)
3311 {
3312 Widget sd;
3313 XmString xm1;
3314 Arg ar[20];
3315 int n;
3316 
3317  xm1 = create_str (label);
3318  n = 0;
3319  XtSetArg(ar[n],XmNlabelFontList, did_default_font); n++;
3320  XtSetArg(ar[n],XmNbuttonFontList, did_default_font); n++;
3321  XtSetArg(ar[n],XmNborderWidth, 1); n++;
3322  /*
3323  XtSetArg(ar[n],XmNwidth, 450); n++;
3324  XtSetArg(ar[n],XmNresizePolicy, XmRESIZE_NONE); n++;
3325  */
3326  XtSetArg(ar[n],XmNselectionLabelString, xm1); n++;
3327  sd = XmCreatePromptDialog ( toplevel_widget, "Prompt", ar, n );
3328 
3329  XmStringFree(xm1);
3330 
3331  XtAddCallback ( sd, XmNcancelCallback,
3332  (XtCallbackProc)cancel_pop_up, (XtPointer)tag );
3333  XtAddCallback ( sd, XmNokCallback,
3334  (XtCallbackProc)ok_pop_up, (XtPointer)tag );
3335 
3336  return(sd);
3337 }
3338 
3339 Widget create_question_dialog(char *label, long tag)
3340 {
3341 Widget sd;
3342 XmString xm1;
3343 Arg ar[20];
3344 int n;
3345 
3346  xm1 = create_str (label);
3347  n = 0;
3348  XtSetArg(ar[n],XmNlabelFontList, did_default_font); n++;
3349  XtSetArg(ar[n],XmNbuttonFontList, did_default_font); n++;
3350  XtSetArg(ar[n],XmNborderWidth, 1); n++;
3351  /*
3352  XtSetArg(ar[n],XmNwidth, 450); n++;
3353  XtSetArg(ar[n],XmNresizePolicy, XmRESIZE_NONE); n++;
3354  */
3355  XtSetArg(ar[n],XmNmessageString, xm1); n++;
3356  sd = XmCreateQuestionDialog ( toplevel_widget, "Question", ar, n );
3357 
3358  XmStringFree(xm1);
3359 
3360  XtAddCallback ( sd, XmNcancelCallback,
3361  (XtCallbackProc)cancel_pop_up, (XtPointer)tag );
3362  XtAddCallback ( sd, XmNokCallback,
3363  (XtCallbackProc)ok_pop_up, (XtPointer)tag );
3364 
3365  return(sd);
3366 }
3367 
3368 Widget create_service_dialog()
3369 {
3370 Widget fd, rc, sw, lb, rc1;
3371 XmString xm1;
3372 Arg ar[20];
3373 int n, par;
3374 unsigned long reason;
3375 
3376  n = 0;
3377  XtSetArg(ar[n],XmNborderWidth, 1); n++;
3378  XtSetArg(ar[n],XmNresizePolicy, XmRESIZE_ANY); n++;
3379  fd = XmCreateFormDialog ( toplevel_widget, "Form", ar, n );
3380  XtManageChild(fd);
3381 
3382  /* create rowcolumn */
3383  n = 0;
3384  XtSetArg(ar[n],XmNborderWidth, 1); n++;
3385  XtSetArg(ar[n],XmNentryAlignment, XmALIGNMENT_CENTER); n++;
3386  XtSetArg(ar[n],XmNbottomAttachment, XmATTACH_FORM); n++;
3387  XtSetArg(ar[n],XmNbottomOffset, 0); n++;
3388  XtSetArg(ar[n],XmNrightAttachment, XmATTACH_FORM); n++;
3389  XtSetArg(ar[n],XmNrightOffset, 0); n++;
3390  XtSetArg(ar[n],XmNtopAttachment, XmATTACH_FORM); n++;
3391  XtSetArg(ar[n],XmNtopOffset, 0); n++;
3392  XtSetArg(ar[n],XmNleftAttachment, XmATTACH_FORM); n++;
3393  XtSetArg(ar[n],XmNleftOffset, 0); n++;
3394  rc = XmCreateRowColumn ( fd, "rowcol", ar, n );
3395  XtManageChild(rc);
3396 
3397  /* create scrolled window */
3398  n = 0;
3399  XtSetArg ( ar[n], XmNwidth, 770); n++;
3400  XtSetArg ( ar[n], XmNheight, 350); n++;
3401  XtSetArg ( ar[n], XmNscrollBarDisplayPolicy, XmAS_NEEDED); n++;
3402  XtSetArg ( ar[n], XmNscrollingPolicy, XmAUTOMATIC); n++;
3403 
3404  sw = XmCreateScrolledWindow ( rc, "ScrollWin", ar, n );
3405  XtManageChild ( sw );
3406 
3407  /* create label */
3408  n = 0;
3409  xm1 = create_str(" ");
3410  XtSetArg(ar[n],XmNfontList, did_small_font); n++;
3411  XtSetArg(ar[n],XmNlabelString, xm1); n++;
3412  XtSetArg(ar[n],XmNalignment, XmALIGNMENT_BEGINNING); n++;
3413  lb = XmCreateLabel ( sw, "label", ar, n );
3414  XtManageChild(lb);
3415  XmStringFree(xm1);
3416  par = 1;
3417  reason = 0;
3418  create_label(lb, &par, &reason);
3419 
3420  /* create button rowcolumn */
3421  n = 0;
3422  XtSetArg(ar[n],XmNborderWidth, 0); n++;
3423  XtSetArg(ar[n],XmNentryAlignment, XmALIGNMENT_CENTER); n++;
3424  XtSetArg(ar[n],XmNorientation, XmVERTICAL); n++;
3425  XtSetArg(ar[n],XmNnumColumns, 3); n++;
3426  XtSetArg(ar[n],XmNpacking, XmPACK_COLUMN); n++;
3427  rc1 = XmCreateRowColumn ( rc, "buttons", ar, n );
3428  XtManageChild(rc1);
3429  /*
3430  create_push_button(rc1,"View Standard",MAX_POP_UPS+1);
3431  create_push_button(rc1,"View Float",MAX_POP_UPS+2);
3432  create_push_button(rc1,"View Double",MAX_POP_UPS+3);
3433  */
3434  SubscribeButton = create_push_button(rc1," Subscribe (On Change) ",
3435  MAX_POP_UPS+5);
3436  Subscribe10Button = create_push_button(rc1," Subscribe (Update Rate 10 seconds) ",
3437  MAX_POP_UPS+4);
3438  create_push_button(rc1,"Dismiss",DID_SERVICE);
3439  Curr_service_print_type = 0;
3440 
3441  return(fd);
3442 }
3443 
3444 Widget create_push_button(Widget parent, char *str, long tag)
3445 {
3446 Widget b;
3447 XmString xm1;
3448 Arg ar[20];
3449 int n;
3450 
3451  n = 0;
3452  xm1 = create_str(str);
3453  XtSetArg(ar[n],XmNalignment, XmALIGNMENT_CENTER); n++;
3454  XtSetArg(ar[n],XmNfontList, did_default_font); n++;
3455  XtSetArg(ar[n],XmNlabelString, xm1); n++;
3456  b = XmCreatePushButton ( parent, "button", ar, n );
3457 
3458  XtManageChild(b);
3459  XmStringFree(xm1);
3460 
3461  XtAddCallback ( b, XmNactivateCallback,
3462  (XtCallbackProc)cancel_pop_up, (XtPointer)tag );
3463  return(b);
3464 }
3465 
3466 
3467 
3468 
did_server_font
static XmFontList did_server_font
Definition: didMarkus.c:40
get_type_size
int get_type_size(char type)
Definition: didMarkus.c:1902
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
node
Definition: dns.c:26
Subscribe10Button
Widget Subscribe10Button
Definition: didMarkus.c:32
pop_widget_id
Widget pop_widget_id[MAX_POP_UPS]
Definition: did.h:62
Service_size
int Service_size
Definition: didMarkus.c:22
activate_clients
void activate_clients(Widget w, SERVER *servp, unsigned long *reason)
Definition: didMarkus.c:2965
create_question_dialog
Widget create_question_dialog(char *label, long tag)
Definition: didMarkus.c:3339
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
create_matrix_widget
void create_matrix_widget()
Definition: didMarkus.c:117
Curr_view_opt_par
char Curr_view_opt_par[80]
Definition: didMarkus.c:11
Content_label_id
Widget Content_label_id
Definition: did.h:60
print_service_longlong
void print_service_longlong(longlong *buff, int size)
Definition: didMarkus.c:1508
ok_pop_up
void ok_pop_up()
gui_toplevel
Widget gui_toplevel(char **argv)
Definition: didMarkus.c:749
item::busy
int busy
Definition: did.h:52
Curr_service_print_type
int Curr_service_print_type
Definition: didMarkus.c:14
got_service_list
void got_service_list(SERVER **servp_ptr, char *buffer, int *size)
Definition: didMarkus.c:2783
show_servers
void show_servers()
Definition: didMarkus.c:2402
put_label
void put_label()
Definition: didMarkus.c:3122
item
Definition: did.h:42
DNS_SERVICE_INFO
Definition: dim.h:330
create_matrix
void create_matrix()
kick_it_again
void kick_it_again()
Definition: didMarkus.c:3023
i
int i
Definition: db_dim_client.c:21
show_clients
void show_clients(SERVER **servp_ptr, char *buffer, int *size)
Definition: didMarkus.c:2873
item::button_id
Widget button_id
Definition: did.h:47
SubscribeButton
Widget SubscribeButton
Definition: didMarkus.c:31
no_link_int
int no_link_int
Definition: didMarkus.c:17
str
char str[80]
Definition: test_client.c:7
MONITORED
#define MONITORED
Definition: dim_common.h:9
did_read_string
void did_read_string(char type, int num, void **buffer_ptr, char **str_ptr)
Definition: didMarkus.c:2027
DNS_SERVER_INFO::node
char node[MAX_NODE_NAME]
Definition: dim.h:338
N_services
int N_services
Definition: didMarkus.c:16
cancel_pop_up
void cancel_pop_up()
get_nodes
int get_nodes(char *node_ptr)
Definition: didMarkus.c:1097
dim_usleep
void dim_usleep(int usecs)
Definition: dtq.c:293
did_prepare_command
void did_prepare_command(char *str)
Definition: didMarkus.c:1936
DEFAULT_FONT
#define DEFAULT_FONT
Definition: did.h:27
Window_id
Widget Window_id
Definition: did.h:61
s_error
void s_error(char *problem_string)
Definition: didMarkus.c:941
dtq_create
int dtq_create()
Definition: dtq.c:353
get_all_colors
void get_all_colors(Display *display, Widget w)
Definition: dui_util.c:218
set_icon_title
void set_icon_title(Widget w, char *title)
Definition: dui_util.c:296
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
create_client_dialog
Widget create_client_dialog()
Definition: didMarkus.c:3155
activate_services
void activate_services(Widget w, SERVER *servp, unsigned long *reason)
Definition: didMarkus.c:2718
MAX_COLORS
Definition: dui_colors.h:4
Label_id
Widget Label_id
Definition: did.h:59
recv_service_info
void recv_service_info(int *tag, int *buffer, int *size)
Definition: didMarkus.c:1161
MAX_CONNS
#define MAX_CONNS
Definition: dim.h:163
create_kill_confirmation
Widget create_kill_confirmation()
Definition: didMarkus.c:3209
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
dic_get_quality
int dic_get_quality(unsigned serv_id)
Definition: dic.c:937
set_title
void set_title(Widget w, char *title)
Definition: dui_util.c:283
put_selection
Widget put_selection(int tag, char *title)
Definition: didMarkus.c:3058
DNS_SERVICE_INFO::type
int type
Definition: dim.h:332
read_str_int
int read_str_int(char *str)
Definition: didMarkus.c:2001
print_service_formatted
void print_service_formatted(void *buff, int size)
Definition: didMarkus.c:1204
main
int main(int argc, char *argv[])
Definition: didMarkus.c:791
do_show_clients
void do_show_clients(SERVER *servp)
Definition: didMarkus.c:2895
Got_Client_List
SERVER * Got_Client_List
Definition: didMarkus.c:29
Service_buffer
char * Service_buffer
Definition: didMarkus.c:21
create_label
void create_label()
MENU_FONT
#define MENU_FONT
Definition: did.h:29
check_put_label
void check_put_label(int tag)
Definition: didMarkus.c:3092
print_service_float
void print_service_float(float *buff, int size)
Definition: didMarkus.c:1685
N_servers
int N_servers
Definition: didMarkus.c:15
view_opts
void view_opts()
print_service_double
void print_service_double(double *buff, int size)
Definition: didMarkus.c:1718
Server_head
SERVER * Server_head
Definition: did.h:55
item::name
char name[132]
Definition: did.h:46
sll_get_next
SLL * sll_get_next(SLL *item)
Definition: sll.c:50
create_service_dialog
Widget create_service_dialog()
Definition: didMarkus.c:3368
print_service_standard
void print_service_standard(int *buff, int size)
Definition: didMarkus.c:1441
DNS_DID::server
DNS_SERVER_INFO server
Definition: dim.h:345
update_servers_new
void update_servers_new(int *tag, char *buffer, int *size)
Definition: didMarkus.c:2256
did_default_font
static XmFontList did_default_font
Definition: didMarkus.c:40
dim_get_dns_node
int dim_get_dns_node(char *node)
Definition: open_dns.c:72
sll
Definition: dim.h:536
Curr_view_opt
int Curr_view_opt
Definition: didMarkus.c:10
item::pop_widget_id
Widget pop_widget_id[2]
Definition: did.h:48
First_time
int First_time
Definition: didMarkus.c:9
display
Display * display
Definition: did.h:37
get_server_service
void get_server_service()
Definition: didMarkus.c:1075
sll_remove_head
SLL * sll_remove_head(SLL *head)
Definition: sll.c:94
dic_cmnd_service
int dic_cmnd_service(char *serv_name, void *serv_address, int serv_size)
Definition: dic.c:694
Curr_client_list
char * Curr_client_list
Definition: didMarkus.c:24
Curr_service_id
int Curr_service_id
Definition: didMarkus.c:25
create_service_selection
Widget create_service_selection()
Definition: didMarkus.c:3180
create_send_command
Widget create_send_command()
Definition: didMarkus.c:3191
kick_it
void kick_it()
Definition: didMarkus.c:2776
dim_no_threads
void dim_no_threads()
Definition: dtq.c:80
type
int type
Definition: dim_get_service.c:9
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
create_separator
Widget create_separator(Widget parent_id)
Definition: didMarkus.c:358
Curr_service_name
char Curr_service_name[132]
Definition: didMarkus.c:12
item::service_ptr
DNS_SERVICE_INFO * service_ptr
Definition: did.h:45
create_selection_dialog
Widget create_selection_dialog(char *ok, char *apply, char *cancel, char *list, char *sel, long tag, int items)
Definition: didMarkus.c:3218
DNS_SERVICE_INFO::name
char name[MAX_NAME]
Definition: dim.h:331
MAX_TASK_NAME
#define MAX_TASK_NAME
Definition: dim.h:181
item::next
struct item * next
Definition: did.h:43
create_push_button
Widget create_push_button(Widget parent, char *str, long tag)
Definition: didMarkus.c:3444
util_get_font
XmFontList util_get_font(char *fontname, Widget top)
Definition: didMarkus.c:89
Got_Service_List
SERVER * Got_Service_List
Definition: didMarkus.c:28
Curr_service_list_id
Widget Curr_service_list_id
Definition: didMarkus.c:27
create_file_selection_dialog
Widget create_file_selection_dialog(long type)
Definition: didMarkus.c:3278
did_label_font
static XmFontList did_label_font
Definition: didMarkus.c:40
dim_get_dns_port
int dim_get_dns_port()
Definition: open_dns.c:121
sll_remove
int sll_remove(SLL *head, SLL *item)
Definition: sll.c:74
switch_matrix
void switch_matrix()
Definition: didMarkus.c:2241
set_something
void set_something()
item::server
DNS_SERVER_INFO server
Definition: did.h:44
set_color
void set_color()
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
did_write_string
int did_write_string(char type, int num, void **buffer_ptr, int ssize)
Definition: didMarkus.c:1272
gui_create_main_window
void gui_create_main_window(Widget parent)
Definition: didMarkus.c:139
find_server
SERVER * find_server(char *node, int pid)
Definition: didMarkus.c:2263
dns_control
void dns_control()
delete_str
void delete_str(XmString str)
Definition: dui_util.c:55
toplevel_widget
Widget toplevel_widget
Definition: did.h:39
size
int size
Definition: db_dim_server.c:17
get_something
void get_something()
print_service_char
void print_service_char(char *buff, int size)
Definition: didMarkus.c:1621
rgb_colors
Pixel rgb_colors[MAX_COLORS]
Definition: dui_util.c:161
do_got_service_list
void do_got_service_list(SERVER *servp)
Definition: didMarkus.c:2805
Memory::free
void free(void *mem)
Definition: EventBuilder.cc:126
create_button
Widget create_button(char *name, SERVER *servp)
Definition: didMarkus.c:2611
did_exit
void did_exit()
Curr_service_list
char * Curr_service_list
Definition: didMarkus.c:23
remove_button
void remove_button(SERVER *servp)
Definition: didMarkus.c:2707
Force_update
int Force_update
Definition: didMarkus.c:36
longlong
int64_t longlong
Definition: dim_common.h:56
MAX_NODE_NAME
#define MAX_NODE_NAME
Definition: dim.h:180
get_service_format
void get_service_format()
Definition: didMarkus.c:1118
Curr_matrix
int Curr_matrix
Definition: did.h:58
app_initialize
void app_initialize(int tag)
Definition: didMarkus.c:903
did_small_font
static XmFontList did_small_font
Definition: didMarkus.c:40
print_service_short
void print_service_short(short *buff, int size)
Definition: didMarkus.c:1554
DNS_DID
Definition: dim.h:344
create_str
XmString create_str()
buff
int buff[BUFFSIZE]
Definition: db_dim_client.c:15
gui_create_main_menu
void gui_create_main_menu(Widget mb)
Definition: didMarkus.c:370
DID_SLOT
char DID_SLOT[MAX_NAME]
Definition: didMarkus.c:2781
gui_initialize
Widget gui_initialize(int argc, char **argv)
Definition: didMarkus.c:764
put_popup
Widget put_popup(SERVER *servp, int type, char *title)
Definition: didMarkus.c:3028
Timer_q
int Timer_q
Definition: didMarkus.c:34
no_link
static char no_link
Definition: didMarkus.c:901
DNS_SERVER_INFO::n_services
int n_services
Definition: dim.h:341
Service_content_str
char * Service_content_str
Definition: didMarkus.c:20
read_str_char
int read_str_char(char *str, char *cc)
Definition: didMarkus.c:2011
update_show_servers
void update_show_servers(void *tag, unsigned long *reason)
Definition: didMarkus.c:2425
ONCE_ONLY
#define ONCE_ONLY
Definition: dim_common.h:7
create_node_selection
Widget create_node_selection()
Definition: didMarkus.c:3172
fptr
FILE * fptr
Definition: didMarkus.c:18
Curr_servp
SERVER * Curr_servp
Definition: didMarkus.c:87
LABEL_FONT
#define LABEL_FONT
Definition: did.h:25
create_prompt_dialog
Widget create_prompt_dialog(char *label, long tag)
Definition: didMarkus.c:3310
dic_release_service
void dic_release_service(unsigned service_id)
Definition: dic.c:1025
Curr_client_id
Widget Curr_client_id
Definition: didMarkus.c:26
get_server_node
void get_server_node()
Definition: didMarkus.c:1016
DNS_DID::services
DNS_SERVICE_INFO services[1]
Definition: dim.h:346
create_main
void create_main()
sll_empty
int sll_empty(SLL *head)
Definition: sll.c:60
sprintf
sprintf(name1,"NewService%d", i)
Curr_service_format
char Curr_service_format[256]
Definition: didMarkus.c:13
update_servers
void update_servers(int *tag, DNS_DID *buffer, int *size)
Definition: didMarkus.c:2285
RED
Definition: dui_colors.h:4
create_server_dialog
Widget create_server_dialog()
Definition: didMarkus.c:3163
remove_all_buttons
void remove_all_buttons()
Definition: didMarkus.c:2691
dic_get_timestamp
int dic_get_timestamp(unsigned serv_id, int *secs, int *milisecs)
Definition: dic.c:984