FACT++  1.0
dis_old.c
Go to the documentation of this file.
1 /*
2  * DIS (Delphi Information Server) Package implements a library of
3  * routines to be used by servers.
4  *
5  * Started on : 10-11-91
6  * Last modification : 28-07-94
7  * Written by : C. Gaspar
8  * Adjusted by : G.C. Ballintijn
9  *
10  */
11 
12 #ifdef VMS
13 # include <lnmdef.h>
14 # include <ssdef.h>
15 # include <descrip.h>
16 # include <cfortran.h>
17 #endif
18 /*
19 #define DEBUG
20 */
21 #include <time.h>
22 #ifdef VAX
23 #include <timeb.h>
24 #else
25 #include <sys/timeb.h>
26 #endif
27 
28 #define DIMLIB
29 #include <dim.h>
30 #include <dis.h>
31 
32 #define ALL 0
33 #define MORE 1
34 #define NONE 2
35 
36 typedef struct dis_dns_ent {
37  struct dis_dns_ent *next;
38  struct dis_dns_ent *prev;
39  long dnsid;
40  char task_name[MAX_NAME];
41  TIMR_ENT *dns_timr_ent;
42  DIS_DNS_PACKET dis_dns_packet;
43  int dis_n_services;
44  int dns_dis_conn_id;
45  int dis_first_time;
46  int serving;
47  unsigned int dis_service_id;
48  unsigned int dis_client_id;
49  int updating_service_list;
50 } DIS_DNS_CONN;
51 
52 typedef struct req_ent {
53  struct req_ent *next;
54  struct req_ent *prev;
55  int conn_id;
56  int service_id;
57  int req_id;
58  int type;
59  struct serv *service_ptr;
60  int timeout;
61  int format;
62  int first_time;
63  int delay_delete;
64  int to_delete;
65  TIMR_ENT *timr_ent;
66  struct reqp_ent *reqpp;
67 } REQUEST;
68 
69 typedef struct serv {
70  struct serv *next;
71  struct serv *prev;
72  char name[MAX_NAME];
73  int id;
74  int type;
75  char def[MAX_NAME];
76  FORMAT_STR format_data[MAX_NAME/4];
77  int *address;
78  int size;
79  void (*user_routine)();
80  long tag;
81  int registered;
82  int quality;
83  int user_secs;
84  int user_millisecs;
85  int tid;
86  REQUEST *request_head;
87  DIS_DNS_CONN *dnsp;
88  int delay_delete;
89  int to_delete;
90 } SERVICE;
91 
92 typedef struct reqp_ent {
93  struct reqp_ent *next;
94  struct reqp_ent *prev;
95  REQUEST *reqp;
96 } REQUEST_PTR;
97 
98 typedef struct cli_ent {
99  struct cli_ent *next;
100  struct cli_ent *prev;
101  int conn_id;
102  REQUEST_PTR *requestp_head;
103  DIS_DNS_CONN *dnsp;
104 } CLIENT;
105 
106 static CLIENT *Client_head = (CLIENT *)0;
107 
108 static DIS_DNS_CONN *DNS_head = (DIS_DNS_CONN *)0;
109 
110 /*
111 static char Task_name[MAX_NAME];
112 static TIMR_ENT *Dns_timr_ent = (TIMR_ENT *)0;
113 static DIS_DNS_PACKET Dis_dns_packet = {0, 0, {0}};
114 static int Dis_n_services = 0;
115 */
116 static int Dis_first_time = 1;
117 /*
118 static int Dns_dis_conn_id = 0;
119 */
120 static int Protocol;
121 static int Port_number;
122 static int Dis_conn_id = 0;
123 static int Curr_conn_id = 0;
124 static int Serving = 0;
125 static void (*Client_exit_user_routine)() = 0;
126 static void (*Exit_user_routine)() = 0;
127 static void (*Error_user_routine)() = 0;
128 static int Error_conn_id = 0;
129 DIS_DNS_CONN *Default_DNS = 0;
130 
131 typedef struct exit_ent {
132  struct exit_ent *next;
133  int conn_id;
134  int exit_id;
135 } EXIT_H;
136 
137 static EXIT_H *Exit_h_head = (EXIT_H *)0;
138 
139 /* Do not forget to increase when this file is modified */
140 static int Version_number = DIM_VERSION_NUMBER;
141 static int Dis_timer_q = 0;
142 static int Threads_off = 0;
143 /*
144 static unsigned int Dis_service_id, Dis_client_id;
145 static int Updating_service_list = 0;
146 */
147 static int Last_client;
148 
149 #ifdef DEBUG
150 static int Debug_on = 1;
151 #else
152 static int Debug_on = 0;
153 #endif
154 
155 _DIM_PROTO( static void dis_insert_request, (int conn_id, DIC_PACKET *dic_packet,
156  int size, int status ) );
157 _DIM_PROTO( int execute_service, (int req_id) );
158 _DIM_PROTO( void execute_command, (SERVICE *servp, DIC_PACKET *packet) );
159 _DIM_PROTO( void register_dns_services, (int flag) );
160 _DIM_PROTO( void register_services, (DIS_DNS_CONN *dnsp, int flag, int dns_flag) );
161 _DIM_PROTO( void std_cmnd_handler, (long *tag, int *cmnd_buff, int *size) );
162 _DIM_PROTO( void client_info, (long *tag, int **bufp, int *size) );
163 _DIM_PROTO( void service_info, (long *tag, int **bufp, int *size) );
164 _DIM_PROTO( void add_exit_handler, (int *tag, int *bufp, int *size) );
165 _DIM_PROTO( static void exit_handler, (int *tag, int *bufp, int *size) );
166 _DIM_PROTO( static void error_handler, (int conn_id, int severity, int errcode, char *reason) );
167 _DIM_PROTO( SERVICE *find_service, (char *name) );
168 _DIM_PROTO( CLIENT *find_client, (int conn_id) );
169 _DIM_PROTO( static int get_format_data, (FORMAT_STR *format_data, char *def) );
170 _DIM_PROTO( static int release_conn, (int conn_id, int print_flag, int dns_flag) );
171 _DIM_PROTO( SERVICE *dis_hash_service_exists, (char *name) );
172 _DIM_PROTO( SERVICE *dis_hash_service_get_next, (int *start, SERVICE *prev, int flag) );
173 _DIM_PROTO( static unsigned do_dis_add_service_dns, (char *name, char *type, void *address, int size,
174  void (*user_routine)(), long tag, long dnsid ) );
175 _DIM_PROTO( static DIS_DNS_CONN *create_dns, (long dnsid) );
176 
177 void dis_set_debug_on()
178 {
179  Debug_on = 1;
180 }
181 
182 void dis_set_debug_off()
183 {
184  Debug_on = 0;
185 }
186 
187 void dis_no_threads()
188 {
189  Threads_off = 1;
190 }
191 
192 static DIS_STAMPED_PACKET *Dis_packet = 0;
193 static int Dis_packet_size = 0;
194 
195 int dis_set_buffer_size(int size)
196 {
197  if(Dis_packet_size)
198  free(Dis_packet);
199  Dis_packet = (DIS_STAMPED_PACKET *)malloc(DIS_STAMPED_HEADER + size);
200  if(Dis_packet)
201  {
202  Dis_packet_size = DIS_STAMPED_HEADER + size;
203  return(1);
204  }
205  else
206  return(0);
207 }
208 
209 static int check_service_name(char *name)
210 {
211  if(strlen(name) > (MAX_NAME - 1))
212  return(0);
213  return(1);
214 }
215 
216 static void dis_init()
217 {
218  int dis_hash_service_init();
219  void dis_dns_init();
220 
221  dis_dns_init();
222  {
223  DISABLE_AST
224  dis_hash_service_init();
225  ENABLE_AST
226  }
227 }
228 
229 static unsigned do_dis_add_service_dns( char *name, char *type, void *address, int size,
230  void (*user_routine)(), long tag, long dnsid )
231 {
232  register SERVICE *new_serv;
233  register int service_id;
234  char str[512];
235  int dis_hash_service_insert();
236  DIS_DNS_CONN *dnsp;
237  extern DIS_DNS_CONN *dis_find_dns(long);
238 
239  dis_init();
240  {
241  DISABLE_AST
242  if(!check_service_name(name))
243  {
244  strcpy(str,"Service name too long: ");
245  strcat(str,name);
246  error_handler(0, DIM_ERROR, DIMSVCTOOLG, str);
247  ENABLE_AST
248  return((unsigned) 0);
249  }
250  if( find_service(name) )
251  {
252  strcpy(str,"Duplicate Service: ");
253  strcat(str,name);
254  error_handler(0, DIM_ERROR, DIMSVCDUPLC, str);
255  ENABLE_AST
256  return((unsigned) 0);
257  }
258  new_serv = (SERVICE *)malloc( sizeof(SERVICE) );
259  strncpy( new_serv->name, name, MAX_NAME );
260  if(type != (char *)0)
261  {
262  if (strlen(type) >= MAX_NAME)
263  {
264  strcpy(str,"Format String Too Long: ");
265  strcat(str,name);
266  error_handler(0, DIM_ERROR, DIMSVCFORMT, str);
267  free(new_serv);
268  ENABLE_AST
269  return((unsigned) 0);
270  }
271  if (! get_format_data(new_serv->format_data, type))
272  {
273  strcpy(str,"Bad Format String: ");
274  strcat(str,name);
275  error_handler(0, DIM_ERROR, DIMSVCFORMT, str);
276  free(new_serv);
277  ENABLE_AST
278  return((unsigned) 0);
279  }
280  strcpy(new_serv->def,type);
281  }
282  else
283  {
284  new_serv->format_data[0].par_bytes = 0;
285  new_serv->def[0] = '\0';
286  }
287  new_serv->type = 0;
288  new_serv->address = (int *)address;
289  new_serv->size = size;
290  new_serv->user_routine = user_routine;
291  new_serv->tag = tag;
292  new_serv->registered = 0;
293  new_serv->quality = 0;
294  new_serv->user_secs = 0;
295  new_serv->tid = 0;
296  new_serv->delay_delete = 0;
297  new_serv->to_delete = 0;
298  dnsp = dis_find_dns(dnsid);
299  if(!dnsp)
300  dnsp = create_dns(dnsid);
301  new_serv->dnsp = dnsp;
302  service_id = id_get((void *)new_serv, SRC_DIS);
303  new_serv->id = service_id;
304  new_serv->request_head = (REQUEST *)malloc(sizeof(REQUEST));
305  dll_init( (DLL *) (new_serv->request_head) );
306  dis_hash_service_insert(new_serv);
307 /*
308  Dis_n_services++;
309 */
310  dnsp->dis_n_services++;
311  ENABLE_AST
312  }
313  return((unsigned)service_id);
314 }
315 
316 static unsigned do_dis_add_service( char *name, char *type, void *address, int size,
317  void (*user_routine)(), long tag )
318 {
319  return do_dis_add_service_dns( name, type, address, size,
320  user_routine, tag, 0 );
321 }
322 
323 #ifdef VxWorks
324 void dis_destroy(int tid)
325 {
326 register SERVICE *servp, *prevp;
327 int n_left = 0;
328 
329  prevp = 0;
330  while( servp = dis_hash_service_get_next(prevp))
331  {
332  if(servp->tid == tid)
333  {
334  dis_remove_service(servp->id);
335  }
336  else
337  {
338  prevp = servp;
339  n_left++;
340  }
341  }
342  if(n_left == 5)
343  {
344  prevp = 0;
345  while( servp = dis_hash_service_get_next(prevp))
346  {
347  dis_remove_service(servp->id);
348  }
349  dna_close(Dis_conn_id);
350  dna_close(Dns_dis_conn_id);
351  Dns_dis_conn_id = 0;
352  Dis_first_time = 1;
353  dtq_rem_entry(Dis_timer_q, Dns_timr_ent);
354  Dns_timr_ent = NULL;
355  }
356 }
357 
358 
359 #endif
360 
361 unsigned dis_add_service( char *name, char *type, void *address, int size,
362  void (*user_routine)(), long tag)
363 {
364  unsigned ret;
365 #ifdef VxWorks
366  register SERVICE *servp;
367 #endif
368 /*
369  DISABLE_AST
370 */
371  ret = do_dis_add_service( name, type, address, size, user_routine, tag);
372 #ifdef VxWorks
373  servp = (SERVICE *)id_get_ptr(ret, SRC_DIS);
374  servp->tid = taskIdSelf();
375 #endif
376 /*
377  ENABLE_AST
378 */
379  return(ret);
380 }
381 
382 unsigned dis_add_service_dns( long dnsid, char *name, char *type, void *address, int size,
383  void (*user_routine)(), long tag)
384 {
385  unsigned ret;
386 #ifdef VxWorks
387  register SERVICE *servp;
388 #endif
389 /*
390  DISABLE_AST
391 */
392  ret = do_dis_add_service_dns( name, type, address, size, user_routine, tag, dnsid);
393 #ifdef VxWorks
394  servp = (SERVICE *)id_get_ptr(ret, SRC_DIS);
395  servp->tid = taskIdSelf();
396 #endif
397 /*
398  ENABLE_AST
399 */
400  return(ret);
401 }
402 
403 static unsigned do_dis_add_cmnd_dns( char *name, char *type, void (*user_routine)(), long tag, long dnsid )
404 {
405  register SERVICE *new_serv;
406  register int service_id;
407  char str[512];
408  int dis_hash_service_insert();
409  DIS_DNS_CONN *dnsp;
410  extern DIS_DNS_CONN *dis_find_dns(long);
411 
412  dis_init();
413  {
414  DISABLE_AST
415  if(!check_service_name(name))
416  {
417  strcpy(str,"Command name too long: ");
418  strcat(str,name);
419  error_handler(0, DIM_ERROR, DIMSVCTOOLG, str);
420  ENABLE_AST
421  return((unsigned) 0);
422  }
423  if( find_service(name) )
424  {
425  ENABLE_AST
426  return((unsigned) 0);
427  }
428  new_serv = (SERVICE *)malloc(sizeof(SERVICE));
429  strncpy(new_serv->name, name, MAX_NAME);
430  if(type != (char *)0)
431  {
432  if( !get_format_data(new_serv->format_data, type))
433  {
434  ENABLE_AST
435  return((unsigned) 0);
436  }
437  strcpy(new_serv->def,type);
438  }
439  else
440  {
441  new_serv->format_data[0].par_bytes = 0;
442  new_serv->def[0] = '\0';
443  }
444  new_serv->type = COMMAND;
445  new_serv->address = 0;
446  new_serv->size = 0;
447  if(user_routine)
448  new_serv->user_routine = user_routine;
449  else
450  new_serv->user_routine = std_cmnd_handler;
451  new_serv->tag = tag;
452  new_serv->tid = 0;
453  new_serv->registered = 0;
454  new_serv->quality = 0;
455  new_serv->user_secs = 0;
456  new_serv->delay_delete = 0;
457  new_serv->to_delete = 0;
458  service_id = id_get((void *)new_serv, SRC_DIS);
459  new_serv->id = service_id;
460  dnsp = dis_find_dns(dnsid);
461  if(!dnsp)
462  dnsp = create_dns(dnsid);
463  new_serv->dnsp = dnsp;
464  new_serv->request_head = (REQUEST *)malloc(sizeof(REQUEST));
465  dll_init( (DLL *) (new_serv->request_head) );
466  dis_hash_service_insert(new_serv);
467 /*
468  Dis_n_services++;
469 */
470  dnsp->dis_n_services++;
471  ENABLE_AST
472  }
473  return((unsigned) service_id);
474 }
475 
476 static unsigned do_dis_add_cmnd( char *name, char *type, void (*user_routine)(), long tag)
477 {
478  return do_dis_add_cmnd_dns(name, type, user_routine, tag, 0);
479 }
480 
481 unsigned dis_add_cmnd( char *name, char *type, void (*user_routine)(), long tag )
482 {
483  unsigned ret;
484 
485 /*
486  DISABLE_AST
487 */
488  ret = do_dis_add_cmnd( name, type, user_routine, tag );
489 /*
490  ENABLE_AST
491 */
492  return(ret);
493 }
494 
495 unsigned dis_add_cmnd_dns( long dnsid, char *name, char *type, void (*user_routine)(), long tag )
496 {
497  unsigned ret;
498 
499  /*
500  DISABLE_AST
501  */
502  ret = do_dis_add_cmnd_dns( name, type, user_routine, tag, dnsid );
503  /*
504  ENABLE_AST
505  */
506  return(ret);
507 }
508 
509 void dis_add_client_exit_handler( void (*user_routine)())
510 {
511 
512  DISABLE_AST
513  Client_exit_user_routine = user_routine;
514  ENABLE_AST
515 }
516 
517 void dis_add_exit_handler( void (*user_routine)())
518 {
519 
520  DISABLE_AST
521  Exit_user_routine = user_routine;
522  ENABLE_AST
523 }
524 
525 void dis_add_error_handler( void (*user_routine)())
526 {
527 
528  DISABLE_AST
529  Error_user_routine = user_routine;
530  ENABLE_AST
531 }
532 
533 static int get_format_data(FORMAT_STR *format_data, char *def)
534 {
535  register char code, last_code = 0;
536  int num;
537 
538  code = *def;
539  while(*def)
540  {
541  if(code != last_code)
542  {
543  format_data->par_num = 0;
544  format_data->flags = 0;
545  switch(code)
546  {
547  case 'i':
548  case 'I':
549  case 'l':
550  case 'L':
551  format_data->par_bytes = SIZEOF_LONG;
552  format_data->flags |= SWAPL;
553  break;
554  case 'x':
555  case 'X':
556  format_data->par_bytes = SIZEOF_DOUBLE;
557  format_data->flags |= SWAPD;
558  break;
559  case 's':
560  case 'S':
561  format_data->par_bytes = SIZEOF_SHORT;
562  format_data->flags |= SWAPS;
563  break;
564  case 'f':
565  case 'F':
566  format_data->par_bytes = SIZEOF_FLOAT;
567  format_data->flags |= SWAPL;
568 #ifdef vms
569  format_data->flags |= IT_IS_FLOAT;
570 #endif
571  break;
572  case 'd':
573  case 'D':
574  format_data->par_bytes = SIZEOF_DOUBLE;
575  format_data->flags |= SWAPD;
576 #ifdef vms
577  format_data->flags |= IT_IS_FLOAT;
578 #endif
579  break;
580  case 'c':
581  case 'C':
582  format_data->par_bytes = SIZEOF_CHAR;
583  format_data->flags |= NOSWAP;
584  break;
585  }
586  }
587  def++;
588  if(*def != ':')
589  {
590  if(*def)
591  {
592 /*
593  printf("Bad service definition parsing\n");
594  fflush(stdout);
595 
596  error_handler("Bad service definition parsing",2);
597 */
598  return(0);
599  }
600  else
601  format_data->par_num = 0;
602  }
603  else
604  {
605  def++;
606  sscanf(def,"%d",&num);
607  format_data->par_num += num;
608  while((*def != ';') && (*def != '\0'))
609  def++;
610  if(*def)
611  def++;
612  }
613  last_code = code;
614  code = *def;
615  if(code != last_code)
616  format_data++;
617  }
618  format_data->par_bytes = 0;
619  return(1);
620 }
621 
622 void recv_dns_dis_rout( int conn_id, DNS_DIS_PACKET *packet, int size, int status )
623 {
624  char str[128];
625  int dns_timr_time;
626  extern int rand_tmout(int, int);
627  extern int open_dns(long, void (*)(), void (*)(), int, int, int);
628  extern DIS_DNS_CONN *find_dns_by_conn_id(int);
629  extern void do_register_services(DIS_DNS_CONN *);
630  extern void do_dis_stop_serving_dns(DIS_DNS_CONN *);
631  DIS_DNS_CONN *dnsp;
632 
633  if(size){}
634  dnsp = find_dns_by_conn_id(conn_id);
635  if(!dnsp)
636  {
637  return;
638  }
639  switch(status)
640  {
641  case STA_DISC: /* connection broken */
642  if( dnsp->dns_timr_ent ) {
643  dtq_rem_entry( Dis_timer_q, dnsp->dns_timr_ent );
644  dnsp->dns_timr_ent = NULL;
645  }
646 
647  if(dnsp->dns_dis_conn_id > 0)
648  dna_close(dnsp->dns_dis_conn_id);
649  if(dnsp->serving)
650  {
651  dnsp->dns_dis_conn_id = open_dns(dnsp->dnsid, recv_dns_dis_rout, error_handler,
652  DIS_DNS_TMOUT_MIN, DIS_DNS_TMOUT_MAX, SRC_DIS );
653  if(dnsp->dns_dis_conn_id == -2)
654  error_handler(0, DIM_FATAL, DIMDNSUNDEF, "DIM_DNS_NODE undefined");
655  }
656  break;
657  case STA_CONN: /* connection received */
658  if(dnsp->serving)
659  {
660  dnsp->dns_dis_conn_id = conn_id;
661  register_services(dnsp, ALL, 0);
662  dns_timr_time = rand_tmout(WATCHDOG_TMOUT_MIN,
663  WATCHDOG_TMOUT_MAX);
664  dnsp->dns_timr_ent = dtq_add_entry( Dis_timer_q,
665  dns_timr_time,
666  do_register_services, dnsp );
667  }
668  else
669  {
670  dna_close(conn_id);
671  }
672  break;
673  default : /* normal packet */
674  if(vtohl(packet->size) != DNS_DIS_HEADER)
675  break;
676  switch( vtohl(packet->type) )
677  {
678  case DNS_DIS_REGISTER :
679  sprintf(str,
680  "%s: Watchdog Timeout, DNS requests registration",
681  dnsp->task_name);
682  error_handler(0, DIM_WARNING, DIMDNSTMOUT, str);
683  register_services(dnsp, ALL, 0);
684  break;
685  case DNS_DIS_KILL :
686  sprintf(str,
687  "%s: Some Services already known to DNS",
688  dnsp->task_name);
689  /*
690  exit(2);
691  */
692  error_handler(0, DIM_FATAL, DIMDNSDUPLC, str);
693  do_dis_stop_serving_dns(dnsp);
694  dis_stop_serving();
695 /*
696  exit_tag = 0;
697  exit_code = 2;
698  exit_size = sizeof(int);
699  exit_handler(&exit_tag, &exit_code, &exit_size);
700 */
701  break;
702  case DNS_DIS_STOP :
703  sprintf(str,
704  "%s: DNS refuses connection",dnsp->task_name);
705 /*
706  exit(2);
707 */
708  error_handler(0, DIM_FATAL, DIMDNSREFUS, str);
709  do_dis_stop_serving_dns(dnsp);
710  dis_stop_serving();
711 /*
712  exit_tag = 0;
713  exit_code = 2;
714  exit_size = sizeof(int);
715  exit_handler(&exit_tag, &exit_code, &exit_size);
716 */
717  break;
718  case DNS_DIS_EXIT :
719  sprintf(str,
720  "%s: DNS requests Exit",dnsp->task_name);
721  error_handler(0, DIM_FATAL, DIMDNSEXIT, str);
722  break;
723  }
724  break;
725  }
726 }
727 
728 
729 /* register services within the name server
730  *
731  * Send services uses the DNA package. services is a linked list of services
732  * stored by add_service.
733  */
734 
735 int send_dns_update_packet(DIS_DNS_CONN *dnsp)
736 {
737  DIS_DNS_PACKET *dis_dns_p = &(dnsp->dis_dns_packet);
738  int n_services;
739  SERVICE_REG *serv_regp;
740 
741  n_services = 1;
742  dis_dns_p->n_services = htovl(n_services);
743  dis_dns_p->size = htovl(DIS_DNS_HEADER +
744  n_services * sizeof(SERVICE_REG));
745  serv_regp = dis_dns_p->services;
746  strcpy( serv_regp->service_name, "DUMMY_UPDATE_PACKET" );
747  if(dnsp->dns_dis_conn_id > 0)
748  {
749  if( !dna_write(dnsp->dns_dis_conn_id, &(dnsp->dis_dns_packet),
750  DIS_DNS_HEADER + n_services * sizeof(SERVICE_REG)))
751  {
752  release_conn(dnsp->dns_dis_conn_id, 0, 1);
753  }
754  }
755  return(1);
756 }
757 
758 void do_register_services(DIS_DNS_CONN *dnsp)
759 {
760  register_services(dnsp, NONE, 0);
761 }
762 
763 void register_services(DIS_DNS_CONN *dnsp, int flag, int dns_flag)
764 {
765  register DIS_DNS_PACKET *dis_dns_p = &(dnsp->dis_dns_packet);
766  register int n_services, tot_n_services;
767  register SERVICE *servp;
768  register SERVICE_REG *serv_regp;
769  int hash_index, new_entries;
770  extern int get_node_addr();
771  int dis_hash_service_registered();
772 
773  if(!dis_dns_p->src_type)
774  {
775  get_node_name( dis_dns_p->node_name );
776 /*
777  strcpy( dis_dns_p->task_name, Task_name );
778 */
779  strncpy( dis_dns_p->task_name, dnsp->task_name,
780  MAX_TASK_NAME-4 );
781  dis_dns_p->task_name[MAX_TASK_NAME-4-1] = '\0';
782  get_node_addr( dis_dns_p->node_addr );
783 /*
784  dis_dns_p->port = htovl(Port_number);
785 */
786  dis_dns_p->pid = htovl(getpid());
787  dis_dns_p->protocol = htovl(Protocol);
788  dis_dns_p->src_type = htovl(SRC_DIS);
789  dis_dns_p->format = htovl(MY_FORMAT);
790 
791  }
792 
793  dis_dns_p->port = htovl(Port_number);
794  serv_regp = dis_dns_p->services;
795  n_services = 0;
796  tot_n_services = 0;
797  if( flag == NONE ) {
798  dis_dns_p->n_services = htovl(n_services);
799  dis_dns_p->size = htovl( DIS_DNS_HEADER +
800  (n_services*sizeof(SERVICE_REG)));
801  if(dnsp->dns_dis_conn_id > 0)
802  {
803  if(!dna_write(dnsp->dns_dis_conn_id, &(dnsp->dis_dns_packet),
804  DIS_DNS_HEADER + n_services*sizeof(SERVICE_REG)))
805  {
806  release_conn(dnsp->dns_dis_conn_id, 0, 1);
807  }
808  }
809  return;
810  }
811  if(flag == ALL)
812  {
813  servp = 0;
814  hash_index = -1;
815  while( (servp = dis_hash_service_get_next(&hash_index, servp, 0)))
816  {
817  if(servp->dnsp == dnsp)
818  servp->registered = 0;
819  }
820  }
821  servp = 0;
822  hash_index = -1;
823  new_entries = 0;
824  if(flag == MORE)
825  new_entries = 1;
826  while( (servp = dis_hash_service_get_next(&hash_index, servp, new_entries)))
827  {
828  if( flag == MORE )
829  {
830  if( servp->registered )
831  {
832  continue;
833  }
834  }
835 
836  if(servp->dnsp != dnsp)
837  continue;
838 
839  strcpy( serv_regp->service_name, servp->name );
840  strcpy( serv_regp->service_def, servp->def );
841  if(servp->type == COMMAND)
842  serv_regp->service_id = htovl( servp->id | 0x10000000);
843  else
844  serv_regp->service_id = htovl( servp->id );
845 
846  serv_regp++;
847  n_services++;
848  dis_hash_service_registered(hash_index, servp);
849  if( n_services == MAX_SERVICE_UNIT )
850  {
851  dis_dns_p->n_services = htovl(n_services);
852  dis_dns_p->size = htovl(DIS_DNS_HEADER +
853  n_services * sizeof(SERVICE_REG));
854  if(dnsp->dns_dis_conn_id > 0)
855  {
856  if( !dna_write(dnsp->dns_dis_conn_id,
857  &(dnsp->dis_dns_packet),
858  DIS_DNS_HEADER + n_services *
859  sizeof(SERVICE_REG)) )
860  {
861  release_conn(dnsp->dns_dis_conn_id, 0, 1);
862  }
863  }
864  serv_regp = dis_dns_p->services;
865  tot_n_services += MAX_SERVICE_UNIT;
866  n_services = 0;
867  continue;
868  }
869  }
870  if( n_services )
871  {
872  dis_dns_p->n_services = htovl(n_services);
873  dis_dns_p->size = htovl(DIS_DNS_HEADER +
874  n_services * sizeof(SERVICE_REG));
875  if(dnsp->dns_dis_conn_id > 0)
876  {
877  if( !dna_write(dnsp->dns_dis_conn_id, &(dnsp->dis_dns_packet),
878  DIS_DNS_HEADER + n_services * sizeof(SERVICE_REG)))
879  {
880  release_conn(dnsp->dns_dis_conn_id, 0, 1);
881  }
882 
883  }
884  tot_n_services += n_services;
885  }
886  if(!dns_flag)
887  {
888  if(tot_n_services >= MAX_REGISTRATION_UNIT)
889  {
890  send_dns_update_packet(dnsp);
891  }
892  }
893 }
894 
895 void unregister_service(DIS_DNS_CONN *dnsp, SERVICE *servp)
896 {
897  register DIS_DNS_PACKET *dis_dns_p = &(dnsp->dis_dns_packet);
898  register int n_services;
899  register SERVICE_REG *serv_regp;
900  extern int get_node_addr();
901 
902  if(dnsp->dns_dis_conn_id > 0)
903  {
904  if(!dis_dns_p->src_type)
905  {
906  get_node_name( dis_dns_p->node_name );
907 /*
908  strcpy( dis_dns_p->task_name, Task_name );
909 */
910  strncpy( dis_dns_p->task_name, dnsp->task_name,
911  MAX_TASK_NAME-4 );
912  dis_dns_p->task_name[MAX_TASK_NAME-4-1] = '\0';
913  get_node_addr( dis_dns_p->node_addr );
914  dis_dns_p->port = htovl(Port_number);
915  dis_dns_p->protocol = htovl(Protocol);
916  dis_dns_p->src_type = htovl(SRC_DIS);
917  dis_dns_p->format = htovl(MY_FORMAT);
918  }
919  serv_regp = dis_dns_p->services;
920  strcpy( serv_regp->service_name, servp->name );
921  strcpy( serv_regp->service_def, servp->def );
922  serv_regp->service_id = htovl( servp->id | 0x80000000);
923  serv_regp++;
924  n_services = 1;
925  servp->registered = 0;
926  dis_dns_p->n_services = htovl(n_services);
927  dis_dns_p->size = htovl(DIS_DNS_HEADER +
928  n_services * sizeof(SERVICE_REG));
929 
930  if( !dna_write(dnsp->dns_dis_conn_id, &(dnsp->dis_dns_packet),
931  DIS_DNS_HEADER + n_services * sizeof(SERVICE_REG)) )
932  {
933  release_conn(dnsp->dns_dis_conn_id, 0, 1);
934  }
935  if(dnsp->dis_service_id)
936  dis_update_service(dnsp->dis_service_id);
937  }
938 }
939 
940 void do_update_service_list(DIS_DNS_CONN *dnsp)
941 {
942  dnsp->updating_service_list = 0;
943  dis_update_service(dnsp->dis_service_id);
944 }
945 
946 /* start serving client requests
947  *
948  * Using the DNA package start accepting requests from clients.
949  * When a request arrives the routine "dis_insert_request" will be executed.
950  */
951 
952 int dis_start_serving(char *task)
953 {
954  return dis_start_serving_dns(0, task);
955 }
956 
957 static DIS_DNS_CONN *create_dns(long dnsid)
958 {
959  DIS_DNS_CONN *dnsp;
960 
961  dnsp = malloc(sizeof(DIS_DNS_CONN));
962  dnsp->dns_timr_ent = (TIMR_ENT *)0;
963  dnsp->dis_n_services = 0;
964  dnsp->dns_dis_conn_id = 0;
965  dnsp->dis_first_time = 1;
966  dnsp->serving = 0;
967  dnsp->dis_dns_packet.size = 0;
968  dnsp->dis_dns_packet.src_type = 0;
969  dnsp->dis_dns_packet.node_name[0] = 0;
970  dnsp->updating_service_list = 0;
971  dnsp->dnsid = dnsid;
972  dll_insert_queue( (DLL *) DNS_head, (DLL *) dnsp );
973  return dnsp;
974 }
975 
976 void dis_dns_init()
977 {
978  static int done = 0;
979  DIS_DNS_CONN *dnsp;
980  void dim_init_threads(void);
981 
982  if(!done)
983  {
984  if(!Threads_off)
985  {
986  dim_init_threads();
987  }
988  {
989  DISABLE_AST
990  if(!DNS_head)
991  {
992  DNS_head = (DIS_DNS_CONN *)malloc(sizeof(DIS_DNS_CONN));
993  dll_init( (DLL *) DNS_head );
994  }
995  dnsp = create_dns(0);
996  Default_DNS = dnsp;
997  done = 1;
998  ENABLE_AST
999  }
1000  }
1001 }
1002 
1003 int dis_start_serving_dns(long dnsid, char *task/*, int *idlist*/)
1004 {
1005  char str0[MAX_NAME], str1[MAX_NAME],str2[MAX_NAME],
1006  str3[MAX_NAME],str4[MAX_NAME];
1007  char task_name_aux[MAX_TASK_NAME];
1008  extern int open_dns();
1009  extern DIS_DNS_CONN *dis_find_dns(long);
1010  DIS_DNS_CONN *dnsp;
1011  int more_ids[10] = {0};
1012 
1013  dis_init();
1014  {
1015  DISABLE_AST
1016  /*
1017 #ifdef VxWorks
1018  taskDeleteHookAdd(remove_all_services);
1019  printf("Adding delete hook\n");
1020 #endif
1021 */
1022 
1023  if(!Client_head)
1024  {
1025  Client_head = (CLIENT *)malloc(sizeof(CLIENT));
1026  dll_init( (DLL *) Client_head );
1027  }
1028  if(dnsid == 0)
1029  {
1030  dnsp = Default_DNS;
1031  }
1032  else if(!(dnsp = dis_find_dns(dnsid)))
1033  {
1034  dnsp = create_dns(dnsid);
1035  }
1036  dnsp->serving = 1;
1037  Serving = 1;
1038  if(Dis_first_time)
1039  {
1040  strncpy( task_name_aux, task, MAX_TASK_NAME );
1041  task_name_aux[MAX_TASK_NAME-1] = '\0';
1042  Port_number = SEEK_PORT;
1043  if( !(Dis_conn_id = dna_open_server( task_name_aux, dis_insert_request,
1044  &Protocol, &Port_number, error_handler) ))
1045  {
1046  ENABLE_AST
1047  return(0);
1048  }
1049  Dis_first_time = 0;
1050  }
1051  if(dnsp->dis_first_time)
1052  {
1053  dnsp->dis_first_time = 0;
1054 
1055  sprintf(str0, "%s/VERSION_NUMBER", task);
1056  sprintf(str1, "%s/CLIENT_LIST", task);
1057  sprintf(str2, "%s/SERVICE_LIST", task);
1058  sprintf(str3, "%s/SET_EXIT_HANDLER", task);
1059  sprintf(str4, "%s/EXIT", task);
1060 
1061  more_ids[0] = do_dis_add_service_dns( str0, "L", &Version_number,
1062  sizeof(Version_number), 0, 0, dnsid );
1063 
1064  more_ids[1] = do_dis_add_service_dns( str1, "C", 0, 0, client_info, (long)dnsp, dnsid );
1065  dnsp->dis_client_id = more_ids[1];
1066  more_ids[2] = do_dis_add_service_dns( str2, "C", 0, 0, service_info, (long)dnsp, dnsid );
1067  dnsp->dis_service_id = more_ids[2];
1068  more_ids[3] = do_dis_add_cmnd_dns( str3, "L:1", add_exit_handler, 0, dnsid );
1069  more_ids[4] = do_dis_add_cmnd_dns( str4, "L:1", exit_handler, 0, dnsid );
1070  more_ids[5] = 0;
1071  strcpy( dnsp->task_name, task );
1072  }
1073 /*
1074  if(idlist)
1075  {
1076  for(i = 0; idlist[i]; i++)
1077  {
1078  servp = (SERVICE *)id_get_ptr(idlist[i], SRC_DIS);
1079  if(servp)
1080  {
1081  servp->dnsp = dnsp;
1082  n_services++;
1083  }
1084  }
1085  }
1086  if(dnsp != Default_DNS)
1087  {
1088  for(i = 0; more_ids[i]; i++)
1089  {
1090  servp = (SERVICE *)id_get_ptr(more_ids[i], SRC_DIS);
1091  if(servp)
1092  {
1093  servp->dnsp = dnsp;
1094  n_services++;
1095  }
1096  }
1097  dnsp->dis_n_services += n_services;
1098  Dis_n_services -= n_services;
1099  }
1100 */
1101  if(!Dis_timer_q)
1102  Dis_timer_q = dtq_create();
1103  if( !dnsp->dns_dis_conn_id )
1104  {
1105  if(!strcmp(task,"DIS_DNS"))
1106  {
1107  register_services(dnsp, ALL, 1);
1108  ENABLE_AST
1109  return(id_get(&(dnsp->dis_dns_packet), SRC_DIS));
1110  }
1111  else
1112  {
1113 
1114  dnsp->dns_dis_conn_id = open_dns(dnsid, recv_dns_dis_rout, error_handler,
1115  DIS_DNS_TMOUT_MIN, DIS_DNS_TMOUT_MAX, SRC_DIS );
1116  if(dnsp->dns_dis_conn_id == -2)
1117  error_handler(0, DIM_FATAL, DIMDNSUNDEF, "DIM_DNS_NODE undefined");
1118  }
1119  }
1120  else
1121  {
1122  register_services(dnsp, MORE, 0);
1123  if(dnsp->dis_service_id)
1124  {
1125 /*
1126  dis_update_service(Dis_service_id);
1127 */
1128  if(!dnsp->updating_service_list)
1129  {
1130  dtq_start_timer(1, do_update_service_list, dnsp);
1131  dnsp->updating_service_list = 1;
1132  }
1133  }
1134  }
1135  ENABLE_AST
1136  }
1137  return(1);
1138 }
1139 
1140 
1141 /* asynchrounous reception of requests */
1142 /*
1143  Called by DNA package.
1144  A request has arrived, queue it to process later - dis_ins_request
1145 */
1146 static void dis_insert_request(int conn_id, DIC_PACKET *dic_packet, int size, int status)
1147 {
1148  register SERVICE *servp;
1149  register REQUEST *newp, *reqp;
1150  CLIENT *clip;
1151  REQUEST_PTR *reqpp;
1152  int type, new_client = 0, found = 0;
1153  int find_release_request();
1154  DIS_DNS_CONN *dnsp;
1155 
1156  if(size){}
1157  /* status = 1 => new connection, status = -1 => conn. lost */
1158  if(!Client_head)
1159  {
1160  Client_head = (CLIENT *)malloc(sizeof(CLIENT));
1161  dll_init( (DLL *) Client_head );
1162  }
1163  if(status != 0)
1164  {
1165  if(status == -1) /* release all requests from conn_id */
1166  {
1167  release_conn(conn_id, 0, 0);
1168  }
1169  }
1170  else
1171  {
1172  if(!(servp = find_service(dic_packet->service_name)))
1173  {
1174  release_conn(conn_id, 0, 0);
1175  return;
1176  }
1177  dic_packet->type = vtohl(dic_packet->type);
1178  type = dic_packet->type & 0xFFF;
1179  /*
1180  if(type == COMMAND)
1181  {
1182  Curr_conn_id = conn_id;
1183  execute_command(servp, dic_packet);
1184  Curr_conn_id = 0;
1185  return;
1186  }
1187  */
1188  if(type == DIM_DELETE)
1189  {
1190  find_release_request(conn_id, vtohl(dic_packet->service_id));
1191  return;
1192  }
1193  newp = (REQUEST *)/*my_*/malloc(sizeof(REQUEST));
1194  newp->service_ptr = servp;
1195  newp->service_id = vtohl(dic_packet->service_id);
1196  newp->type = dic_packet->type;
1197  newp->timeout = vtohl(dic_packet->timeout);
1198  newp->format = vtohl(dic_packet->format);
1199  newp->conn_id = conn_id;
1200  newp->first_time = 1;
1201  newp->delay_delete = 0;
1202  newp->to_delete = 0;
1203  newp->timr_ent = 0;
1204  newp->req_id = id_get((void *)newp, SRC_DIS);
1205  newp->reqpp = 0;
1206  if(type == ONCE_ONLY)
1207  {
1208  execute_service(newp->req_id);
1209  id_free(newp->req_id, SRC_DIS);
1210  free(newp);
1211  return;
1212  }
1213  if(type == COMMAND)
1214  {
1215  Curr_conn_id = conn_id;
1216  execute_command(servp, dic_packet);
1217  Curr_conn_id = 0;
1218  reqp = servp->request_head;
1219  while( (reqp = (REQUEST *) dll_get_next((DLL *)servp->request_head,
1220  (DLL *) reqp)) )
1221  {
1222  if(reqp->conn_id == conn_id)
1223  {
1224  id_free(newp->req_id, SRC_DIS);
1225  free(newp);
1226  found = 1;
1227  break;
1228  }
1229  }
1230  if(!found)
1231  dll_insert_queue( (DLL *) servp->request_head, (DLL *) newp );
1232  return;
1233  }
1234  dll_insert_queue( (DLL *) servp->request_head, (DLL *) newp );
1235  if(!(clip = find_client(conn_id)))
1236  {
1237  clip = (CLIENT *)malloc(sizeof(CLIENT));
1238  clip->conn_id = conn_id;
1239  clip->dnsp = servp->dnsp;
1240  clip->requestp_head = (REQUEST_PTR *)malloc(sizeof(REQUEST_PTR));
1241  dll_init( (DLL *) clip->requestp_head );
1242  dll_insert_queue( (DLL *) Client_head, (DLL *) clip );
1243  new_client = 1;
1244  }
1245  reqpp = (REQUEST_PTR *)malloc(sizeof(REQUEST_PTR));
1246  reqpp->reqp = newp;
1247  dll_insert_queue( (DLL *) clip->requestp_head, (DLL *) reqpp );
1248  newp->reqpp = reqpp;
1249  if((type != MONIT_ONLY) && (type != UPDATE))
1250  {
1251  execute_service(newp->req_id);
1252  }
1253  if((type != MONIT_ONLY) && (type != MONIT_FIRST))
1254  {
1255  if(newp->timeout != 0)
1256  {
1257  newp->timr_ent = dtq_add_entry( Dis_timer_q,
1258  newp->timeout,
1259  execute_service,
1260  newp->req_id );
1261  }
1262  }
1263  if(new_client)
1264  {
1265  Last_client = conn_id;
1266  dnsp = clip->dnsp;
1267  if(dnsp->dis_client_id)
1268  dis_update_service(dnsp->dis_client_id);
1269  }
1270  }
1271 }
1272 
1273 /* A timeout for a timed or monitored service occured, serve it. */
1274 
1275 int execute_service( int req_id )
1276 {
1277  int *buffp, size;
1278  register REQUEST *reqp;
1279  register SERVICE *servp;
1280  char str[80], def[MAX_NAME];
1281  register char *ptr;
1282  int last_conn_id;
1283  int *pkt_buffer, header_size, aux;
1284 #ifdef WIN32
1285  struct timeb timebuf;
1286 #else
1287  struct timeval tv;
1288  struct timezone *tz;
1289 #endif
1290  FORMAT_STR format_data_cp[MAX_NAME/4];
1291 
1292  reqp = (REQUEST *)id_get_ptr(req_id, SRC_DIS);
1293  if(!reqp)
1294  return(0);
1295  if(reqp->to_delete)
1296  return(0);
1297  reqp->delay_delete++;
1298  servp = reqp->service_ptr;
1299  last_conn_id = Curr_conn_id;
1300  Curr_conn_id = reqp->conn_id;
1301  ptr = servp->def;
1302  if(servp->type == COMMAND)
1303  {
1304  sprintf(str,"This is a COMMAND Service");
1305  buffp = (int *)str;
1306  size = 26;
1307  sprintf(def,"c:26");
1308  ptr = def;
1309  }
1310  else if( servp->user_routine != 0 )
1311  {
1312  (servp->user_routine)( &servp->tag, &buffp, &size,
1313  &reqp->first_time );
1314  reqp->first_time = 0;
1315 
1316  }
1317  else
1318  {
1319  buffp = servp->address;
1320  size = servp->size;
1321  }
1322  Curr_conn_id = last_conn_id;
1323 /* send even if no data but not if negative */
1324  if( size < 0)
1325  {
1326  reqp->delay_delete--;
1327  return(0);
1328  }
1329  if( DIS_STAMPED_HEADER + size > Dis_packet_size )
1330  {
1331  if( Dis_packet_size )
1332  free( Dis_packet );
1333  Dis_packet = (DIS_STAMPED_PACKET *)malloc(DIS_STAMPED_HEADER + size);
1334  if(!Dis_packet)
1335  {
1336  reqp->delay_delete--;
1337  return(0);
1338  }
1339  Dis_packet_size = DIS_STAMPED_HEADER + size;
1340  }
1341  Dis_packet->service_id = htovl(reqp->service_id);
1342  if((reqp->type & 0xFF000) == STAMPED)
1343  {
1344  pkt_buffer = ((DIS_STAMPED_PACKET *)Dis_packet)->buffer;
1345  header_size = DIS_STAMPED_HEADER;
1346  if(!servp->user_secs)
1347  {
1348 #ifdef WIN32
1349  ftime(&timebuf);
1350  aux = timebuf.millitm;
1351  Dis_packet->time_stamp[0] = htovl(aux);
1352  Dis_packet->time_stamp[1] = htovl((int)timebuf.time);
1353 #else
1354  tz = 0;
1355  gettimeofday(&tv, tz);
1356  aux = tv.tv_usec / 1000;
1357  Dis_packet->time_stamp[0] = htovl(aux);
1358  Dis_packet->time_stamp[1] = htovl(tv.tv_sec);
1359 #endif
1360  }
1361  else
1362  {
1363  aux = /*0xc0de0000 |*/ servp->user_millisecs;
1364  Dis_packet->time_stamp[0] = htovl(aux);
1365  Dis_packet->time_stamp[1] = htovl(servp->user_secs);
1366  }
1367  Dis_packet->reserved[0] = htovl(0xc0dec0de);
1368  Dis_packet->quality = htovl(servp->quality);
1369  }
1370  else
1371  {
1372  pkt_buffer = ((DIS_PACKET *)Dis_packet)->buffer;
1373  header_size = DIS_HEADER;
1374  }
1375  memcpy(format_data_cp, servp->format_data, sizeof(format_data_cp));
1376  size = copy_swap_buffer_out(reqp->format, format_data_cp,
1377  pkt_buffer,
1378  buffp, size);
1379  Dis_packet->size = htovl(header_size + size);
1380  if( !dna_write_nowait(reqp->conn_id, Dis_packet, header_size + size) )
1381  {
1382  reqp->to_delete = 1;
1383  }
1384 /*
1385  else
1386  {
1387  if((reqp->type & 0xFFF) == MONITORED)
1388  {
1389  if(reqp->timr_ent)
1390  dtq_clear_entry(reqp->timr_ent);
1391  }
1392  }
1393 */
1394  reqp->delay_delete--;
1395  return(1);
1396 }
1397 
1398 void remove_service( int req_id )
1399 {
1400  register REQUEST *reqp;
1401  register SERVICE *servp;
1402  static DIS_PACKET *dis_packet;
1403  static int packet_size = 0;
1404  int service_id;
1405 
1406  reqp = (REQUEST *)id_get_ptr(req_id, SRC_DIS);
1407  servp = reqp->service_ptr;
1408  if( !packet_size ) {
1409  dis_packet = (DIS_PACKET *)malloc(DIS_HEADER);
1410  packet_size = DIS_HEADER;
1411  }
1412  service_id = (reqp->service_id | 0x80000000);
1413  dis_packet->service_id = htovl(service_id);
1414  dis_packet->size = htovl(DIS_HEADER);
1415  if( !dna_write(reqp->conn_id, dis_packet, DIS_HEADER) )
1416  {
1417  release_conn(reqp->conn_id, 0, 0);
1418  }
1419 }
1420 
1421 void execute_command(SERVICE *servp, DIC_PACKET *packet)
1422 {
1423  int size;
1424  int format;
1425  FORMAT_STR format_data_cp[MAX_NAME/4], *formatp;
1426  static int *buffer;
1427  static int buffer_size = 0;
1428  int add_size;
1429 
1430  size = vtohl(packet->size) - DIC_HEADER;
1431  add_size = size + (size/2);
1432  if(!buffer_size)
1433  {
1434  buffer = (int *)malloc(add_size);
1435  buffer_size = add_size;
1436  }
1437  else
1438  {
1439  if( add_size > buffer_size )
1440  {
1441  free(buffer);
1442  buffer = (int *)malloc(add_size);
1443  buffer_size = add_size;
1444  }
1445  }
1446 
1447  dis_set_timestamp(servp->id, 0, 0);
1448  if(servp->user_routine != 0)
1449  {
1450  format = vtohl(packet->format);
1451  memcpy(format_data_cp, servp->format_data, sizeof(format_data_cp));
1452  if((format & 0xF) == ((MY_FORMAT) & 0xF))
1453  {
1454  for(formatp = format_data_cp; formatp->par_bytes; formatp++)
1455  {
1456  if(formatp->flags & IT_IS_FLOAT)
1457  formatp->flags |= (format & 0xf0);
1458  formatp->flags &= 0xFFF0; /* NOSWAP */
1459  }
1460  }
1461  else
1462  {
1463  for(formatp = format_data_cp; formatp->par_bytes; formatp++)
1464  {
1465  if(formatp->flags & IT_IS_FLOAT)
1466  formatp->flags |= (format & 0xf0);
1467  }
1468  }
1469  size = copy_swap_buffer_in(format_data_cp,
1470  buffer,
1471  packet->buffer, size);
1472  (servp->user_routine)(&servp->tag, buffer, &size);
1473  }
1474 }
1475 
1476 void dis_report_service(char *serv_name)
1477 {
1478  register SERVICE *servp;
1479  register REQUEST *reqp;
1480  int to_delete = 0, more;
1481 
1482 
1483  DISABLE_AST
1484  servp = find_service(serv_name);
1485  reqp = servp->request_head;
1486  while( (reqp = (REQUEST *) dll_get_next((DLL *)servp->request_head,
1487  (DLL *) reqp)) )
1488  {
1489  if((reqp->type & 0xFFF) != TIMED_ONLY)
1490  {
1491  execute_service(reqp->req_id);
1492  if(reqp->to_delete)
1493  to_delete = 1;
1494  }
1495  }
1496  if(to_delete)
1497  {
1498  do
1499  {
1500  more = 0;
1501  reqp = servp->request_head;
1502  while( (reqp = (REQUEST *) dll_get_next((DLL *)servp->request_head,
1503  (DLL *) reqp)) )
1504  {
1505  if(reqp->to_delete)
1506  {
1507  more = 1;
1508  release_conn(reqp->conn_id, 1, 0);
1509  break;
1510  }
1511  }
1512  }while(more);
1513  }
1514  ENABLE_AST
1515 }
1516 
1517 int dis_update_service(unsigned service_id)
1518 {
1519 int do_update_service();
1520 
1521  return(do_update_service(service_id,0));
1522 }
1523 
1524 int dis_selective_update_service(unsigned service_id, int *client_ids)
1525 {
1526 int do_update_service();
1527 
1528  return(do_update_service(service_id, client_ids));
1529 }
1530 
1531 int check_client(REQUEST *reqp, int *client_ids)
1532 {
1533  if(!client_ids)
1534  return(1);
1535  while(*client_ids)
1536  {
1537  if(reqp->conn_id == *client_ids)
1538  {
1539  return(1);
1540  }
1541  client_ids++;
1542  }
1543  return(0);
1544 }
1545 
1546 int do_update_service(unsigned service_id, int *client_ids)
1547 {
1548  register REQUEST *reqp;
1549  register SERVICE *servp;
1550  REQUEST_PTR *reqpp;
1551  CLIENT *clip;
1552  register int found = 0;
1553  int to_delete = 0, more, conn_id;
1554  char str[128];
1555  int release_request();
1556 
1557  DISABLE_AST
1558  if(!service_id)
1559  {
1560  sprintf(str, "Update Service - Invalid service id");
1561  error_handler(0, DIM_ERROR, DIMSVCINVAL, str);
1562  ENABLE_AST
1563  return(found);
1564  }
1565  servp = (SERVICE *)id_get_ptr(service_id, SRC_DIS);
1566  if(!servp)
1567  {
1568  ENABLE_AST
1569  return(found);
1570  }
1571  if(servp->id != (int)service_id)
1572  {
1573  ENABLE_AST
1574  return(found);
1575  }
1576  servp->delay_delete = 1;
1577  reqp = servp->request_head;
1578  while( (reqp = (REQUEST *) dll_get_next((DLL *)servp->request_head,
1579  (DLL *) reqp)) )
1580  {
1581 if(Debug_on)
1582 {
1583 dim_print_date_time_millis();
1584 printf("Updating %s (id = %d, ptr = %08lX) for %s@%s (req_id = %d, req_ptr = %08lX)\n",
1585  servp->name, (int)service_id, (unsigned long)servp,
1586  Net_conns[reqp->conn_id].task, Net_conns[reqp->conn_id].node, reqp->req_id, (unsigned long)reqp);
1587 }
1588  if(check_client(reqp, client_ids))
1589  reqp->delay_delete = 1;
1590  }
1591  ENABLE_AST
1592  {
1593  DISABLE_AST
1594  reqp = servp->request_head;
1595  while( (reqp = (REQUEST *) dll_get_next((DLL *)servp->request_head,
1596  (DLL *) reqp)) )
1597  {
1598  if(reqp->delay_delete && ((reqp->type & 0xFFF) != COMMAND))
1599  {
1600  if(check_client(reqp, client_ids))
1601  {
1602  if( (reqp->type & 0xFFF) != TIMED_ONLY )
1603  {
1604 /*
1605  DISABLE_AST
1606 */
1607  execute_service(reqp->req_id);
1608  found++;
1609  ENABLE_AST
1610  {
1611  DISABLE_AST
1612  }
1613  }
1614  }
1615  }
1616  }
1617  ENABLE_AST
1618  }
1619  {
1620  DISABLE_AST
1621  reqp = servp->request_head;
1622  while( (reqp = (REQUEST *) dll_get_next((DLL *)servp->request_head,
1623  (DLL *) reqp)) )
1624  {
1625  if(check_client(reqp, client_ids))
1626  {
1627  reqp->delay_delete = 0;
1628  if(reqp->to_delete)
1629  to_delete = 1;
1630  }
1631  }
1632  ENABLE_AST
1633  }
1634  if(to_delete)
1635  {
1636  DISABLE_AST
1637  do
1638  {
1639  more = 0;
1640  reqp = servp->request_head;
1641  while( (reqp = (REQUEST *) dll_get_next((DLL *)servp->request_head,
1642  (DLL *) reqp)) )
1643  {
1644  if(reqp->to_delete & 0x1)
1645  {
1646  more = 1;
1647  reqp->to_delete = 0;
1648  release_conn(reqp->conn_id, 1, 0);
1649  break;
1650  }
1651  else if(reqp->to_delete & 0x2)
1652  {
1653  more = 1;
1654  reqp->to_delete = 0;
1655  reqpp = reqp->reqpp;
1656  conn_id = reqp->conn_id;
1657  release_request(reqp, reqpp, 1);
1658  clip = find_client(conn_id);
1659  if(clip)
1660  {
1661  if( dll_empty((DLL *)clip->requestp_head) )
1662  {
1663  release_conn( conn_id, 0, 0);
1664  }
1665  }
1666  break;
1667  }
1668  }
1669  }while(more);
1670  ENABLE_AST
1671  }
1672  {
1673  DISABLE_AST
1674  servp->delay_delete = 0;
1675  if(servp->to_delete)
1676  {
1677  dis_remove_service(servp->id);
1678  }
1679  ENABLE_AST
1680  }
1681 
1682  return(found);
1683 }
1684 
1685 int dis_get_n_clients(unsigned service_id)
1686 {
1687  register REQUEST *reqp;
1688  register SERVICE *servp;
1689  register int found = 0;
1690  char str[128];
1691 
1692  DISABLE_AST
1693  if(!service_id)
1694  {
1695  sprintf(str, "Service Has Clients- Invalid service id");
1696  error_handler(0, DIM_ERROR, DIMSVCINVAL, str);
1697  ENABLE_AST
1698  return(found);
1699  }
1700  servp = (SERVICE *)id_get_ptr(service_id, SRC_DIS);
1701  if(!servp)
1702  {
1703  ENABLE_AST
1704  return(found);
1705  }
1706  if(servp->id != (int)service_id)
1707  {
1708  ENABLE_AST
1709  return(found);
1710  }
1711  reqp = servp->request_head;
1712  while( (reqp = (REQUEST *) dll_get_next((DLL *)servp->request_head,
1713  (DLL *) reqp)) )
1714  {
1715  found++;
1716  }
1717  ENABLE_AST
1718  return found;
1719 }
1720 
1721 int dis_get_timeout(unsigned service_id, int client_id)
1722 {
1723  register REQUEST *reqp;
1724  register SERVICE *servp;
1725  char str[128];
1726 
1727  if(!service_id)
1728  {
1729  sprintf(str,"Get Timeout - Invalid service id");
1730  error_handler(0, DIM_ERROR, DIMSVCINVAL, str);
1731  return(-1);
1732  }
1733  servp = (SERVICE *)id_get_ptr(service_id, SRC_DIS);
1734  if(!servp)
1735  {
1736  return(-1);
1737  }
1738  reqp = servp->request_head;
1739  while( (reqp = (REQUEST *) dll_get_next((DLL *)servp->request_head,
1740  (DLL *) reqp)) )
1741  {
1742  if(reqp->conn_id == client_id)
1743  return(reqp->timeout);
1744  }
1745  return(-1);
1746 }
1747 
1748 void dis_set_quality( unsigned serv_id, int quality )
1749 {
1750  register SERVICE *servp;
1751  char str[128];
1752 
1753  DISABLE_AST
1754  if(!serv_id)
1755  {
1756  sprintf(str,"Set Quality - Invalid service id");
1757  error_handler(0, DIM_ERROR, DIMSVCINVAL, str);
1758  ENABLE_AST
1759  return;
1760  }
1761  servp = (SERVICE *)id_get_ptr(serv_id, SRC_DIS);
1762  if(!servp)
1763  {
1764  ENABLE_AST
1765  return;
1766  }
1767  if(servp->id != (int)serv_id)
1768  {
1769  ENABLE_AST
1770  return;
1771  }
1772  servp->quality = quality;
1773  ENABLE_AST
1774 }
1775 
1776 int dis_set_timestamp( unsigned serv_id, int secs, int millisecs )
1777 {
1778  register SERVICE *servp;
1779  char str[128];
1780 #ifdef WIN32
1781  struct timeb timebuf;
1782 #else
1783  struct timeval tv;
1784  struct timezone *tz;
1785 #endif
1786 
1787  DISABLE_AST
1788  if(!serv_id)
1789  {
1790  sprintf(str,"Set Timestamp - Invalid service id");
1791  error_handler(0, DIM_ERROR, DIMSVCINVAL, str);
1792  ENABLE_AST
1793  return(0);
1794  }
1795  servp = (SERVICE *)id_get_ptr(serv_id, SRC_DIS);
1796  if(!servp)
1797  {
1798  ENABLE_AST
1799  return(0);
1800  }
1801  if(servp->id != (int)serv_id)
1802  {
1803  ENABLE_AST
1804  return(0);
1805  }
1806  if(secs == 0)
1807  {
1808 #ifdef WIN32
1809  ftime(&timebuf);
1810  servp->user_secs = (int)timebuf.time;
1811  servp->user_millisecs = timebuf.millitm;
1812 #else
1813  tz = 0;
1814  gettimeofday(&tv, tz);
1815  servp->user_secs = tv.tv_sec;
1816  servp->user_millisecs = tv.tv_usec / 1000;
1817 #endif
1818  }
1819  else
1820  {
1821  servp->user_secs = secs;
1822 /*
1823  servp->user_millisecs = (millisecs & 0xffff);
1824 */
1825  servp->user_millisecs = millisecs;
1826  }
1827  ENABLE_AST
1828  return(1);
1829 }
1830 
1831 int dis_get_timestamp( unsigned serv_id, int *secs, int *millisecs )
1832 {
1833  register SERVICE *servp;
1834  char str[128];
1835 
1836  DISABLE_AST
1837  if(!serv_id)
1838  {
1839  sprintf(str,"Get Timestamp - Invalid service id");
1840  error_handler(0, DIM_ERROR, DIMSVCINVAL, str);
1841  ENABLE_AST
1842  return(0);
1843  }
1844  servp = (SERVICE *)id_get_ptr(serv_id, SRC_DIS);
1845  if(!servp)
1846  {
1847  ENABLE_AST
1848  return(0);
1849  }
1850  if(servp->id != (int)serv_id)
1851  {
1852  ENABLE_AST
1853  return(0);
1854  }
1855  if(servp->user_secs)
1856  {
1857  *secs = servp->user_secs;
1858  *millisecs = servp->user_millisecs;
1859  }
1860  else
1861  {
1862  *secs = 0;
1863  *millisecs = 0;
1864  }
1865  ENABLE_AST
1866  return(1);
1867 }
1868 
1869 void dis_send_service(unsigned service_id, int *buffer, int size)
1870 {
1871  register REQUEST *reqp, *prevp;
1872  register SERVICE *servp;
1873  static DIS_PACKET *dis_packet;
1874  static int packet_size = 0;
1875  int conn_id;
1876  char str[128];
1877 
1878  DISABLE_AST
1879  if( !service_id ) {
1880  sprintf(str,"Send Service - Invalid service id");
1881  error_handler(0, DIM_ERROR, DIMSVCINVAL, str);
1882  ENABLE_AST
1883  return;
1884  }
1885  servp = (SERVICE *)id_get_ptr(service_id, SRC_DIS);
1886  if(!packet_size)
1887  {
1888  dis_packet = (DIS_PACKET *)malloc(DIS_HEADER+size);
1889  packet_size = DIS_HEADER + size;
1890  }
1891  else
1892  {
1893  if( DIS_HEADER+size > packet_size )
1894  {
1895  free(dis_packet);
1896  dis_packet = (DIS_PACKET *)malloc(DIS_HEADER+size);
1897  packet_size = DIS_HEADER+size;
1898  }
1899  }
1900  prevp = servp->request_head;
1901  while( (reqp = (REQUEST *) dll_get_next((DLL *)servp->request_head,
1902  (DLL *) prevp)) )
1903  {
1904  dis_packet->service_id = htovl(reqp->service_id);
1905  memcpy(dis_packet->buffer, buffer, size);
1906  dis_packet->size = htovl(DIS_HEADER + size);
1907 
1908  conn_id = reqp->conn_id;
1909  if( !dna_write_nowait(conn_id, dis_packet, size + DIS_HEADER) )
1910  {
1911  release_conn(conn_id, 1, 0);
1912  }
1913  else
1914  prevp = reqp;
1915  }
1916  ENABLE_AST
1917 }
1918 
1919 int dis_remove_service(unsigned service_id)
1920 {
1921  register REQUEST *reqp, *auxp;
1922  register SERVICE *servp;
1923  REQUEST_PTR *reqpp;
1924  int found = 0;
1925  char str[128];
1926  int release_request();
1927  int dis_hash_service_remove();
1928  DIS_DNS_CONN *dnsp;
1929  int n_services;
1930  void do_dis_stop_serving_dns(DIS_DNS_CONN *);
1931 
1932  DISABLE_AST
1933  if(!service_id)
1934  {
1935  sprintf(str,"Remove Service - Invalid service id");
1936  error_handler(0, DIM_ERROR, DIMSVCINVAL, str);
1937  ENABLE_AST
1938  return(found);
1939  }
1940  servp = (SERVICE *)id_get_ptr(service_id, SRC_DIS);
1941  if(!servp)
1942  {
1943  ENABLE_AST
1944  return(found);
1945  }
1946  if(servp->id != (int)service_id)
1947  {
1948  ENABLE_AST
1949  return(found);
1950  }
1951  if(servp->delay_delete)
1952  {
1953  servp->to_delete = 1;
1954  ENABLE_AST
1955  return(found);
1956  }
1957  /* remove from name server */
1958 
1959  dnsp = servp->dnsp;
1960  unregister_service(dnsp, servp);
1961  /* Release client requests and remove from actual clients */
1962  reqp = servp->request_head;
1963  while( (reqp = (REQUEST *) dll_get_next((DLL *)servp->request_head,
1964  (DLL *) reqp)) )
1965  {
1966  remove_service(reqp->req_id);
1967  auxp = reqp->prev;
1968  reqpp = (REQUEST_PTR *) reqp->reqpp;
1969  release_request(reqp, reqpp, 1);
1970  found = 1;
1971  reqp = auxp;
1972  }
1973  if(servp->id == (int)dnsp->dis_service_id)
1974  dnsp->dis_service_id = 0;
1975  if(servp->id == (int)dnsp->dis_client_id)
1976  dnsp->dis_client_id = 0;
1977  dis_hash_service_remove(servp);
1978  id_free(servp->id, SRC_DIS);
1979  free(servp->request_head);
1980  free(servp);
1981 /*
1982  if(dnsp != Default_DNS)
1983  {
1984  dnsp->dis_n_services--;
1985  n_services = dnsp->dis_n_services;
1986  }
1987  else
1988  {
1989  Dis_n_services--;
1990  n_services = Dis_n_services;
1991  }
1992 */
1993  dnsp->dis_n_services--;
1994  n_services = dnsp->dis_n_services;
1995 
1996  ENABLE_AST
1997  if(dnsp->serving)
1998  {
1999  if(n_services == 5)
2000  {
2001 /*
2002  dis_stop_serving();
2003 */
2004  do_dis_stop_serving_dns(dnsp);
2005  }
2006  }
2007  return(found);
2008 }
2009 
2010 void do_dis_stop_serving_dns(DIS_DNS_CONN *dnsp)
2011 {
2012 register SERVICE *servp, *prevp;
2013 void dim_stop_threads(void);
2014 int dis_no_dns();
2015 int hash_index, old_index;
2016 extern int close_dns(long, int);
2017 
2018  dnsp->serving = 0;
2019  dis_init();
2020 /*
2021  dis_hash_service_init();
2022  prevp = 0;
2023  if(Dis_conn_id)
2024  {
2025  dna_close(Dis_conn_id);
2026  Dis_conn_id = 0;
2027  }
2028 */
2029  {
2030  DISABLE_AST
2031  if(dnsp->dns_timr_ent)
2032  {
2033  dtq_rem_entry(Dis_timer_q, dnsp->dns_timr_ent);
2034  dnsp->dns_timr_ent = NULL;
2035  }
2036  if(dnsp->dns_dis_conn_id)
2037  {
2038  dna_close(dnsp->dns_dis_conn_id);
2039  dnsp->dns_dis_conn_id = 0;
2040  }
2041  ENABLE_AST
2042  }
2043  {
2044  DISABLE_AST
2045  prevp = 0;
2046  hash_index = -1;
2047  old_index = -1;
2048  while( (servp = dis_hash_service_get_next(&hash_index, prevp, 0)) )
2049  {
2050  if(servp->dnsp == dnsp)
2051  {
2052  dis_remove_service(servp->id);
2053  if(old_index != hash_index)
2054  prevp = 0;
2055  }
2056  else
2057  {
2058  prevp = servp;
2059  old_index = hash_index;
2060  }
2061  }
2062  ENABLE_AST
2063  }
2064  dnsp->dis_first_time = 1;
2065  dnsp->dis_n_services = 0;
2066  dnsp->dis_dns_packet.size = 0;
2067  dnsp->dis_dns_packet.src_type = 0;
2068  close_dns(dnsp->dnsid, SRC_DIS);
2069 /*
2070  if(dnsp != Default_DNS)
2071  {
2072  dll_remove(dnsp);
2073  free(dnsp);
2074  }
2075 */
2076 /*
2077  if(dll_empty(DNS_head))
2078 */
2079  if(dis_no_dns())
2080  dis_stop_serving();
2081 }
2082 
2083 void dis_stop_serving_dns(long dnsid)
2084 {
2085  DIS_DNS_CONN *dnsp, *dis_find_dns();
2086 
2087  dnsp = dis_find_dns(dnsid);
2088  do_dis_stop_serving_dns(dnsp);
2089 }
2090 
2091 void dis_stop_serving()
2092 {
2093 register SERVICE *servp, *prevp;
2094 void dim_stop_threads(void);
2095 int hash_index;
2096 
2097  Serving = 0;
2098  dis_init();
2099  if(Dis_conn_id)
2100  {
2101  dna_close(Dis_conn_id);
2102  Dis_conn_id = 0;
2103  }
2104 /*
2105  if(Dns_dis_conn_id)
2106  {
2107  dna_close(Dns_dis_conn_id);
2108  Dns_dis_conn_id = 0;
2109  }
2110 */
2111  {
2112  DISABLE_AST
2113  prevp = 0;
2114  hash_index = -1;
2115  while( (servp = dis_hash_service_get_next(&hash_index, prevp, 0)) )
2116  {
2117  dis_remove_service(servp->id);
2118  prevp = 0;
2119  }
2120  ENABLE_AST
2121  }
2122 /*
2123  if(Dis_conn_id)
2124  dna_close(Dis_conn_id);
2125  if(Dns_dis_conn_id)
2126  dna_close(Dns_dis_conn_id);
2127  Dns_dis_conn_id = 0;
2128 */
2129  Dis_first_time = 1;
2130 /*
2131  if(Dns_timr_ent)
2132  {
2133  dtq_rem_entry(Dis_timer_q, Dns_timr_ent);
2134  Dns_timr_ent = NULL;
2135  }
2136 */
2137  dtq_delete(Dis_timer_q);
2138  Dis_timer_q = 0;
2139  dim_stop_threads();
2140 }
2141 
2142 /* find service by name */
2143 SERVICE *find_service(char *name)
2144 {
2145  return(dis_hash_service_exists(name));
2146 }
2147 
2148 CLIENT *find_client(int conn_id)
2149 {
2150  register CLIENT *clip;
2151 
2152  clip = (CLIENT *)
2153  dll_search( (DLL *) Client_head, &conn_id, sizeof(conn_id));
2154  return(clip);
2155 }
2156 
2157 void release_all_requests(int conn_id, CLIENT *clip)
2158 {
2159  register REQUEST_PTR *reqpp, *auxp;
2160  register REQUEST *reqp;
2161  int found = 0;
2162  int release_request();
2163  DIS_DNS_CONN *dnsp;
2164 
2165  DISABLE_AST;
2166  if(clip)
2167  {
2168  reqpp = clip->requestp_head;
2169  while( (reqpp = (REQUEST_PTR *) dll_get_next((DLL *)clip->requestp_head,
2170  (DLL *) reqpp)) )
2171  {
2172  auxp = reqpp->prev;
2173  reqp = (REQUEST *) reqpp->reqp;
2174  release_request(reqp, reqpp, 0);
2175  found = 1;
2176  reqpp = auxp;
2177  }
2178  dnsp = clip->dnsp;
2179  dll_remove(clip);
2180  free(clip->requestp_head);
2181  free(clip);
2182  }
2183  if(found)
2184  {
2185  Last_client = -conn_id;
2186  if(dnsp->dis_client_id)
2187  dis_update_service(dnsp->dis_client_id);
2188  }
2189  dna_close(conn_id);
2190  ENABLE_AST;
2191 }
2192 
2193 CLIENT *check_delay_delete(int conn_id)
2194 {
2195  register REQUEST_PTR *reqpp;
2196  register CLIENT *clip;
2197  register REQUEST *reqp;
2198  int found = 0;
2199 
2200  DISABLE_AST;
2201  clip = find_client(conn_id);
2202  if(clip)
2203  {
2204  reqpp = clip->requestp_head;
2205  while( (reqpp = (REQUEST_PTR *) dll_get_next((DLL *)clip->requestp_head,
2206  (DLL *) reqpp)) )
2207  {
2208  reqp = (REQUEST *) reqpp->reqp;
2209  if(reqp->delay_delete)
2210  {
2211  reqp->to_delete = 1;
2212  found = 1;
2213  }
2214  }
2215  }
2216  ENABLE_AST;
2217  if(found)
2218  {
2219  return((CLIENT *)-1);
2220  }
2221  return(clip);
2222 }
2223 
2224 char *dis_get_error_services()
2225 {
2226  return(dis_get_client_services(Error_conn_id));
2227 }
2228 
2229 char *dis_get_client_services(int conn_id)
2230 {
2231  register REQUEST_PTR *reqpp;
2232  register CLIENT *clip;
2233  register REQUEST *reqp;
2234  register SERVICE *servp;
2235 
2236  int n_services = 0;
2237  int max_size;
2238  static int curr_allocated_size = 0;
2239  static char *service_info_buffer;
2240  char *buff_ptr;
2241 
2242 
2243  if(!conn_id)
2244  return((char *)0);
2245  {
2246  DISABLE_AST;
2247  clip = find_client(conn_id);
2248  if(clip)
2249  {
2250  reqpp = clip->requestp_head;
2251  while( (reqpp = (REQUEST_PTR *) dll_get_next((DLL *)clip->requestp_head,
2252  (DLL *) reqpp)))
2253  {
2254  n_services++;
2255  }
2256  if(!n_services)
2257  {
2258  ENABLE_AST
2259  return((char *)0);
2260  }
2261  max_size = n_services * MAX_NAME;
2262  if(!curr_allocated_size)
2263  {
2264  service_info_buffer = (char *)malloc(max_size);
2265  curr_allocated_size = max_size;
2266  }
2267  else if (max_size > curr_allocated_size)
2268  {
2269  free(service_info_buffer);
2270  service_info_buffer = (char *)malloc(max_size);
2271  curr_allocated_size = max_size;
2272  }
2273  service_info_buffer[0] = '\0';
2274  buff_ptr = service_info_buffer;
2275  reqpp = clip->requestp_head;
2276  while( (reqpp = (REQUEST_PTR *) dll_get_next((DLL *)clip->requestp_head,
2277  (DLL *) reqpp)) )
2278  {
2279  reqp = (REQUEST *) reqpp->reqp;
2280  servp = reqp->service_ptr;
2281  strcat(buff_ptr, servp->name);
2282  strcat(buff_ptr, "\n");
2283  buff_ptr += strlen(buff_ptr);
2284  }
2285  }
2286  else
2287  {
2288  ENABLE_AST
2289  return((char *)0);
2290  }
2291  ENABLE_AST;
2292  }
2293 /*
2294  dim_print_date_time();
2295  dna_get_node_task(conn_id, node, task);
2296  printf("Client %s@%s uses services: \n", task, node);
2297  printf("%s\n",service_info_buffer);
2298 */
2299  return(service_info_buffer);
2300 }
2301 
2302 int find_release_request(int conn_id, int service_id)
2303 {
2304  register REQUEST_PTR *reqpp, *auxp;
2305  register CLIENT *clip;
2306  register REQUEST *reqp;
2307  int release_request();
2308 
2309  DISABLE_AST
2310  clip = find_client(conn_id);
2311  if(clip)
2312  {
2313  reqpp = clip->requestp_head;
2314  while( (reqpp = (REQUEST_PTR *) dll_get_next((DLL *)clip->requestp_head,
2315  (DLL *) reqpp)) )
2316  {
2317  reqp = (REQUEST *) reqpp->reqp;
2318  if(reqp->service_id == service_id)
2319  {
2320  if(reqp->delay_delete)
2321  {
2322  reqp->to_delete += 0x2;
2323  }
2324  else
2325  {
2326  auxp = reqpp->prev;
2327  release_request(reqp, reqpp, 0);
2328  reqpp = auxp;
2329  }
2330  }
2331  }
2332  if( dll_empty((DLL *)clip->requestp_head) )
2333  {
2334  release_conn( conn_id, 0, 0 );
2335  }
2336  }
2337  ENABLE_AST
2338  return(1);
2339 }
2340 
2341 int release_request(REQUEST *reqp, REQUEST_PTR *reqpp, int remove)
2342 {
2343  int conn_id;
2344  CLIENT *clip;
2345 
2346  DISABLE_AST
2347  conn_id = reqp->conn_id;
2348  if(reqpp)
2349  dll_remove((DLL *)reqpp);
2350  dll_remove((DLL *)reqp);
2351  if(reqp->timr_ent)
2352  dtq_rem_entry(Dis_timer_q, reqp->timr_ent);
2353  id_free(reqp->req_id, SRC_DIS);
2354  free(reqp);
2355  free(reqpp);
2356 /* Would do it too early, the client will disconnect anyway
2357 */
2358  if((remove) && (!Serving))
2359  {
2360  clip = find_client(conn_id);
2361  if(clip)
2362  {
2363  if( dll_empty((DLL *)clip->requestp_head) )
2364  {
2365  release_conn( conn_id, 0, 0);
2366  }
2367  }
2368  }
2369 
2370  ENABLE_AST
2371  return(1);
2372 }
2373 
2374 static int release_conn(int conn_id, int print_flg, int dns_flag)
2375 {
2376  static int releasing = 0;
2377  CLIENT *clip;
2378  int do_exit_handler();
2379 
2380  DISABLE_AST
2381  if(print_flg){}
2382  if(dns_flag)
2383  {
2384  recv_dns_dis_rout( conn_id, 0, 0, STA_DISC );
2385  ENABLE_AST
2386  return(0);
2387  }
2388 #ifdef VMS
2389  if(print_flg)
2390  {
2391  dim_print_date_time();
2392  dna_get_node_task(conn_id, node, task);
2393  printf(" Couldn't write to client %s@%s, releasing connection %d\n",
2394  task, node, conn_id);
2395  fflush(stdout);
2396  }
2397 #endif
2398  clip = check_delay_delete(conn_id);
2399  if(clip != (CLIENT *)-1)
2400  {
2401  if( Client_exit_user_routine != 0 )
2402  {
2403  releasing++;
2404  Curr_conn_id = conn_id;
2405  do_exit_handler(conn_id);
2406  releasing--;
2407  }
2408  if(!releasing)
2409  {
2410  release_all_requests(conn_id, clip);
2411  }
2412  }
2413  ENABLE_AST
2414  return(1);
2415 }
2416 
2417 typedef struct cmnds{
2418  struct cmnds *next;
2419  long tag;
2420  int size;
2421  int buffer[1];
2422 } DIS_CMND;
2423 
2424 static DIS_CMND *Cmnds_head = (DIS_CMND *)0;
2425 
2426 void std_cmnd_handler(long *tag, int *cmnd_buff, int *size)
2427 {
2428  register DIS_CMND *new_cmnd;
2429 /* queue the command */
2430 
2431  if(!Cmnds_head)
2432  {
2433  Cmnds_head = (DIS_CMND *)malloc(sizeof(DIS_CMND));
2434  sll_init((SLL *) Cmnds_head);
2435  }
2436  new_cmnd = (DIS_CMND *)malloc((*size)+12);
2437  new_cmnd->next = 0;
2438  new_cmnd->tag = *tag;
2439  new_cmnd->size = *size;
2440  memcpy(new_cmnd->buffer, cmnd_buff, *size);
2441  sll_insert_queue((SLL *) Cmnds_head, (SLL *) new_cmnd);
2442 }
2443 
2444 int dis_get_next_cmnd(long *tag, int *buffer, int *size)
2445 {
2446  register DIS_CMND *cmndp;
2447  register int ret_val = -1;
2448 
2449  DISABLE_AST
2450  if(!Cmnds_head)
2451  {
2452  Cmnds_head = (DIS_CMND *)malloc(sizeof(DIS_CMND));
2453  sll_init((SLL *) Cmnds_head);
2454  }
2455  if(*size == 0)
2456  {
2457  if( (cmndp = (DIS_CMND *) sll_get_head((SLL *) Cmnds_head)))
2458  {
2459  if(cmndp->size > 0)
2460  {
2461  *size = cmndp->size;
2462  *tag = cmndp->tag;
2463  ENABLE_AST
2464  return(-1);
2465  }
2466  }
2467  }
2468  if( (cmndp = (DIS_CMND *) sll_remove_head((SLL *) Cmnds_head)) )
2469  {
2470  if (*size >= cmndp->size)
2471  {
2472  *size = cmndp->size;
2473  ret_val = 1;
2474  }
2475  memcpy(buffer, cmndp->buffer, *size);
2476  *tag = cmndp->tag;
2477  free(cmndp);
2478  ENABLE_AST
2479  return(ret_val);
2480  }
2481  ENABLE_AST
2482  return(0);
2483 }
2484 
2485 int dis_get_conn_id()
2486 {
2487  return(Curr_conn_id);
2488 }
2489 
2490 int dis_get_client(char *name)
2491 {
2492  int ret = 0;
2493  char node[MAX_NODE_NAME], task[MAX_TASK_NAME];
2494 
2495  DISABLE_AST
2496 
2497  if(Curr_conn_id)
2498  {
2499  dna_get_node_task(Curr_conn_id, node, task);
2500  strcpy(name,task);
2501  strcat(name,"@");
2502  strcat(name,node);
2503  ret = Curr_conn_id;
2504  }
2505  ENABLE_AST
2506  return(ret);
2507 }
2508 
2509 #ifdef VMS
2510 dis_convert_str(c_str, for_str)
2511 char *c_str;
2512 struct dsc$descriptor_s *for_str;
2513 {
2514  int i;
2515 
2516  strcpy(for_str->dsc$a_pointer, c_str);
2517  for(i = strlen(c_str); i< for_str->dsc$w_length; i++)
2518  for_str->dsc$a_pointer[i] = ' ';
2519 }
2520 #endif
2521 
2522 void client_info(long *tag, int **bufp, int *size, int *first_time)
2523 {
2524  register CLIENT *clip;
2525  int curr_conns[MAX_CONNS];
2526  int i, index, max_size;
2527  static int curr_allocated_size = 0;
2528  static char *dns_info_buffer;
2529  register char *dns_client_info;
2530  char node[MAX_NODE_NAME], task[MAX_TASK_NAME];
2531  DIS_DNS_CONN *dnsp = (DIS_DNS_CONN *)*tag;
2532 
2533  max_size = sizeof(DNS_CLIENT_INFO);
2534  if(!curr_allocated_size)
2535  {
2536  dns_info_buffer = malloc(max_size);
2537  curr_allocated_size = max_size;
2538  }
2539  dns_client_info = dns_info_buffer;
2540  dns_client_info[0] = '\0';
2541  index = 0;
2542  if(*first_time)
2543  {
2544  clip = Client_head;
2545  while( (clip = (CLIENT *)dll_get_next( (DLL *) Client_head,
2546  (DLL*) clip)) )
2547  {
2548  if(clip->dnsp != dnsp)
2549  continue;
2550  curr_conns[index++] = clip->conn_id;
2551  }
2552  max_size = (index+1)*sizeof(DNS_CLIENT_INFO);
2553  if (max_size > curr_allocated_size)
2554  {
2555  free(dns_info_buffer);
2556  dns_info_buffer = malloc(max_size);
2557  curr_allocated_size = max_size;
2558  }
2559  dns_client_info = dns_info_buffer;
2560  dns_client_info[0] = '\0';
2561  }
2562  else
2563  {
2564  if(Last_client > 0)
2565  {
2566  strcat(dns_client_info,"+");
2567  curr_conns[index++] = Last_client;
2568  }
2569  else
2570  {
2571  strcat(dns_client_info,"-");
2572  curr_conns[index++] = -Last_client;
2573  }
2574  }
2575 
2576  for(i=0; i<index;i++)
2577  {
2578  dna_get_node_task(curr_conns[i], node, task);
2579  strcat(dns_client_info,task);
2580  strcat(dns_client_info,"@");
2581  strcat(dns_client_info,node);
2582  strcat(dns_client_info,"|");
2583  }
2584  if(index)
2585  dns_client_info[strlen(dns_client_info)-1] = '\0';
2586  *bufp = (int *)dns_info_buffer;
2587  *size = strlen(dns_info_buffer)+1;
2588 }
2589 
2590 void append_service(char *service_info_buffer, SERVICE *servp)
2591 {
2592  char name[MAX_NAME], *ptr;
2593 
2594  if(strstr(servp->name,"/RpcIn"))
2595  {
2596  strcpy(name,servp->name);
2597  ptr = (char *)strstr(name,"/RpcIn");
2598  *ptr = 0;
2599  strcat(service_info_buffer, name);
2600  strcat(service_info_buffer, "|");
2601  if(servp->def[0])
2602  {
2603  strcat(service_info_buffer, servp->def);
2604  }
2605  strcat(name,"/RpcOut");
2606  if( (servp = find_service(name)) )
2607  {
2608  strcat(service_info_buffer, ",");
2609  if(servp->def[0])
2610  {
2611  strcat(service_info_buffer, servp->def);
2612  }
2613  }
2614  strcat(service_info_buffer, "|RPC");
2615  strcat(service_info_buffer, "\n");
2616  }
2617  else if(strstr(servp->name,"/RpcOut"))
2618  {
2619 /*
2620  if(servp->def[0])
2621  {
2622  strcat(service_info_buffer, servp->def);
2623  }
2624  strcat(service_info_buffer, "|RPC");
2625  strcat(service_info_buffer, "\n");
2626 
2627 */
2628  }
2629  else
2630  {
2631  strcat(service_info_buffer, servp->name);
2632  strcat(service_info_buffer, "|");
2633  if(servp->def[0])
2634  {
2635  strcat(service_info_buffer, servp->def);
2636  }
2637  strcat(service_info_buffer, "|");
2638  if(servp->type == COMMAND)
2639  {
2640  strcat(service_info_buffer, "CMD");
2641  }
2642  strcat(service_info_buffer, "\n");
2643  }
2644 }
2645 
2646 void service_info(long *tag, int **bufp, int *size, int *first_time)
2647 {
2648  register SERVICE *servp;
2649  int max_size, done = 0;
2650  static int curr_allocated_size = 0;
2651  static char *service_info_buffer;
2652  char *buff_ptr;
2653  DIS_DNS_CONN *dnsp = (DIS_DNS_CONN *)*tag;
2654  int hash_index;
2655 
2656  DISABLE_AST
2657  max_size = (dnsp->dis_n_services+10) * (MAX_NAME*2 + 4);
2658  if(!curr_allocated_size)
2659  {
2660  service_info_buffer = (char *)malloc(max_size);
2661  curr_allocated_size = max_size;
2662  }
2663  else if (max_size > curr_allocated_size)
2664  {
2665  free(service_info_buffer);
2666  service_info_buffer = (char *)malloc(max_size);
2667  curr_allocated_size = max_size;
2668  }
2669  service_info_buffer[0] = '\0';
2670  buff_ptr = service_info_buffer;
2671  servp = 0;
2672  hash_index = -1;
2673  if(*first_time)
2674  {
2675  while( (servp = dis_hash_service_get_next(&hash_index, servp, 0)) )
2676  {
2677  if(servp->dnsp != dnsp)
2678  continue;
2679  if(servp->registered)
2680  {
2681  servp->registered = 2;
2682  append_service(buff_ptr, servp);
2683  buff_ptr += strlen(buff_ptr);
2684  }
2685  }
2686  }
2687  else
2688  {
2689  while( (servp = dis_hash_service_get_next(&hash_index, servp, 0)) )
2690  {
2691  if(servp->dnsp != dnsp)
2692  continue;
2693  if(servp->registered == 1)
2694  {
2695  if(!done)
2696  {
2697  strcat(buff_ptr, "+");
2698  buff_ptr += strlen(buff_ptr);
2699  done = 1;
2700  }
2701  append_service(buff_ptr, servp);
2702  buff_ptr += strlen(buff_ptr);
2703  servp->registered = 2;
2704  }
2705  else if(servp->registered == 0)
2706  {
2707  strcat(buff_ptr, "-");
2708  buff_ptr += strlen(buff_ptr);
2709  append_service(buff_ptr, servp);
2710  buff_ptr += strlen(buff_ptr);
2711  }
2712  }
2713  }
2714  *bufp = (int *)service_info_buffer;
2715  *size = buff_ptr - service_info_buffer+1;
2716  ENABLE_AST
2717 }
2718 
2719 void add_exit_handler(int *tag, int *bufp, int *size)
2720 {
2721  EXIT_H *newp;
2722 
2723  if(size){}
2724  if(tag){}
2725  if(*bufp)
2726  {
2727  if(!Exit_h_head)
2728  {
2729  Exit_h_head = (EXIT_H *)malloc(sizeof(EXIT_H));
2730  sll_init( (SLL *) Exit_h_head );
2731  }
2732  newp = (EXIT_H *)malloc(sizeof(EXIT_H));
2733  newp->conn_id = Curr_conn_id;
2734  newp->exit_id = *bufp;
2735  sll_insert_queue( (SLL *) Exit_h_head, (SLL *) newp );
2736  }
2737  else
2738  {
2739  if(!Exit_h_head)
2740  return;
2741  if((newp = (EXIT_H *)sll_search((SLL *) Exit_h_head,
2742  (char *)&Curr_conn_id, 4)) )
2743  {
2744  sll_remove( (SLL *) Exit_h_head, (SLL *) newp );
2745  }
2746  }
2747 }
2748 
2749 void dis_set_client_exit_handler(int conn_id, int tag)
2750 {
2751  EXIT_H *newp;
2752 
2753  DISABLE_AST
2754  if(tag)
2755  {
2756  if(!Exit_h_head)
2757  {
2758  Exit_h_head = (EXIT_H *)malloc(sizeof(EXIT_H));
2759  sll_init( (SLL *) Exit_h_head );
2760  }
2761  if( (newp = (EXIT_H *)sll_search((SLL *) Exit_h_head,
2762  (char *)&conn_id, 4)) )
2763  {
2764  newp->conn_id = conn_id;
2765  newp->exit_id = tag;
2766  }
2767  else
2768  {
2769  newp = (EXIT_H *)malloc(sizeof(EXIT_H));
2770  newp->conn_id = conn_id;
2771  newp->exit_id = tag;
2772  sll_insert_queue( (SLL *) Exit_h_head, (SLL *) newp );
2773  }
2774  }
2775  else
2776  {
2777  if(!Exit_h_head)
2778  {
2779  ENABLE_AST
2780  return;
2781  }
2782  if( (newp = (EXIT_H *)sll_search((SLL *) Exit_h_head,
2783  (char *)&conn_id, 4)) )
2784  {
2785  sll_remove( (SLL *) Exit_h_head, (SLL *) newp );
2786  }
2787  }
2788  ENABLE_AST
2789 }
2790 
2791 int do_exit_handler(int conn_id)
2792 {
2793  register EXIT_H *exitp;
2794 
2795  DISABLE_AST;
2796  if(!Exit_h_head)
2797  {
2798  ENABLE_AST;
2799  return(0);
2800  }
2801  while( (exitp = (EXIT_H *) sll_search_next_remove((SLL *) Exit_h_head,
2802  0, (char *) &conn_id, 4)) )
2803  {
2804  (Client_exit_user_routine)( &exitp->exit_id );
2805  free(exitp);
2806  }
2807  ENABLE_AST
2808  return(1);
2809 }
2810 
2811 static void exit_handler(int *tag, int *bufp, int *size)
2812 {
2813 
2814  if(size){}
2815  if(tag){}
2816  if(Exit_user_routine)
2817  (Exit_user_routine)( bufp );
2818  else
2819  {
2820 /*
2821  printf("%s PID %d Exiting!\n", Task_name, getpid());
2822 */
2823  exit(*bufp);
2824  }
2825 }
2826 
2827 static void error_handler(int conn_id, int severity, int errcode, char *reason)
2828 {
2829  int exit_tag, exit_code, exit_size;
2830  int last_conn_id;
2831 
2832  if(Error_user_routine)
2833  {
2834  Error_conn_id = conn_id;
2835  last_conn_id = Curr_conn_id;
2836  Curr_conn_id = conn_id;
2837  (Error_user_routine)( severity, errcode, reason);
2838  Error_conn_id = 0;
2839  Curr_conn_id = last_conn_id;
2840  }
2841  else
2842  {
2843  dim_print_msg(reason, severity);
2844  }
2845  if(severity == DIM_FATAL)
2846  {
2847  exit_tag = 0;
2848  exit_code = errcode;
2849  exit_size = sizeof(int);
2850  exit_handler(&exit_tag, &exit_code, &exit_size);
2851  }
2852 }
2853 /*
2854 #define MAX_HASH_ENTRIES 2000
2855 */
2856 #define MAX_HASH_ENTRIES 5000
2857 
2858 static SERVICE *Service_hash_table[MAX_HASH_ENTRIES];
2859 static int Service_new_entries[MAX_HASH_ENTRIES];
2860 
2861 int dis_hash_service_init()
2862 {
2863  int i;
2864  static int done = 0;
2865 
2866  if(!done)
2867  {
2868  for( i = 0; i < MAX_HASH_ENTRIES; i++ )
2869  {
2870  Service_hash_table[i] = (SERVICE *) malloc(8);
2871  dll_init((DLL *) Service_hash_table[i]);
2872  Service_new_entries[i] = 0;
2873  }
2874  done = 1;
2875  }
2876  return(1);
2877 }
2878 
2879 int dis_hash_service_insert(SERVICE *servp)
2880 {
2881  int index;
2882  index = HashFunction(servp->name, MAX_HASH_ENTRIES);
2883  Service_new_entries[index]++;
2884  dll_insert_queue((DLL *) Service_hash_table[index],
2885  (DLL *) servp);
2886  return(1);
2887 }
2888 
2889 int dis_hash_service_registered(int index, SERVICE *servp)
2890 {
2891  servp->registered = 1;
2892  Service_new_entries[index]--;
2893  if(Service_new_entries[index] < 0)
2894  Service_new_entries[index] = 0;
2895  return 1;
2896 }
2897 
2898 int dis_hash_service_remove(SERVICE *servp)
2899 {
2900  dll_remove( (DLL *) servp );
2901  return(1);
2902 }
2903 
2904 
2905 SERVICE *dis_hash_service_exists(char *name)
2906 {
2907  int index;
2908  SERVICE *servp;
2909 
2910  index = HashFunction(name, MAX_HASH_ENTRIES);
2911  if( (servp = (SERVICE *) dll_search(
2912  (DLL *) Service_hash_table[index],
2913  name, strlen(name)+1)) )
2914  {
2915  return(servp);
2916  }
2917  return((SERVICE *)0);
2918 }
2919 
2920 SERVICE *dis_hash_service_get_next(int *curr_index, SERVICE *prevp, int new_entries)
2921 {
2922  int index;
2923  SERVICE *servp = 0;
2924 /*
2925  if(!prevp)
2926  {
2927  index = -1;
2928  }
2929 */
2930  index = *curr_index;
2931  if(index == -1)
2932  {
2933  index++;
2934  prevp = Service_hash_table[index];
2935  }
2936  if(!prevp)
2937  {
2938  prevp = Service_hash_table[index];
2939  }
2940  do
2941  {
2942  if((!new_entries) || (Service_new_entries[index] > 0))
2943  {
2944  servp = (SERVICE *) dll_get_next(
2945  (DLL *) Service_hash_table[index],
2946  (DLL *) prevp);
2947  if(servp)
2948  break;
2949  }
2950  index++;
2951  if(index == MAX_HASH_ENTRIES)
2952  {
2953  *curr_index = -1;
2954  return((SERVICE *) 0);
2955  }
2956  prevp = Service_hash_table[index];
2957  } while(!servp);
2958  *curr_index = index;
2959  return(servp);
2960 }
2961 
2962 DIS_DNS_CONN *dis_find_dns(long dnsid)
2963 {
2964  DIS_DNS_CONN *dnsp;
2965 
2966  dnsp = (DIS_DNS_CONN *)
2967  dll_search( (DLL *) DNS_head, &dnsid, sizeof(dnsid));
2968 /*
2969  if(!dnsp)
2970  {
2971  dnsp = create_dns(dnsid);
2972  }
2973 */
2974  return dnsp;
2975 }
2976 
2977 int dis_no_dns()
2978 {
2979  DIS_DNS_CONN *dnsp;
2980 
2981  dnsp = (DIS_DNS_CONN *) DNS_head;
2982  while ( (dnsp = (DIS_DNS_CONN *) dll_get_next( (DLL *) DNS_head, (DLL *) dnsp)))
2983  {
2984 /*
2985  if(dnsp != Default_DNS)
2986  return 0;
2987 */
2988  if(dnsp->serving)
2989  return 0;
2990  }
2991  return 1;
2992 }
2993 
2994 DIS_DNS_CONN *find_dns_by_conn_id(int conn_id)
2995 {
2996  DIS_DNS_CONN *dnsp;
2997  extern long dns_get_dnsid();
2998  long dnsid;
2999 
3000  dnsid = dns_get_dnsid(conn_id, SRC_DIS);
3001  dnsp = dis_find_dns(dnsid);
3002  if(!dnsp)
3003  dnsp = Default_DNS;
3004  return (DIS_DNS_CONN *)dnsp;
3005 }
3006 
3007 void dis_print_hash_table()
3008 {
3009  SERVICE *servp;
3010  int i;
3011  int n_entries, max_entry_index = 0;
3012  int max_entries = 0;
3013 
3014  for( i = 0; i < MAX_HASH_ENTRIES; i++ )
3015  {
3016  n_entries = 0;
3017  servp = Service_hash_table[i];
3018  while( (servp = (SERVICE *) dll_get_next(
3019  (DLL *) Service_hash_table[i],
3020  (DLL *) servp)) )
3021  {
3022  n_entries++;
3023  if(n_entries == 1)
3024  printf(" Name = %s\n",servp->name);
3025  }
3026  if(n_entries != 0)
3027  printf("HASH[%d] - %d entries\n", i, n_entries);
3028  if(n_entries > max_entries)
3029  {
3030  max_entries = n_entries;
3031  max_entry_index = i;
3032  }
3033  }
3034  printf("Maximum : HASH[%d] - %d entries\n", max_entry_index, max_entries);
3035  fflush(stdout);
3036 }
3037 
3038 void dis_hash_print()
3039 {
3040  SERVICE *servp;
3041  int hash_index;
3042 
3043  servp = 0;
3044  hash_index = -1;
3045  while( (servp = dis_hash_service_get_next(&hash_index, servp, 0)) )
3046  {
3047  printf("Name = %s\n",servp->name);
3048  }
3049 }
3050 
3051 #ifdef VMS
3052 /* CFORTRAN WRAPPERS */
3053 FCALLSCFUN1(INT, dis_start_serving, DIS_START_SERVING, dis_start_serving,
3054  STRING)
3055 FCALLSCFUN3(INT, dis_get_next_cmnd, DIS_GET_NEXT_CMND, dis_get_next_cmnd,
3056  PINT, PVOID, PINT)
3057 FCALLSCFUN1(INT, dis_get_client, DIS_GET_CLIENT, dis_get_client,
3058  PSTRING)
3059 FCALLSCFUN6(INT, dis_add_service, DIS_ADD_SERVICE, dis_add_service,
3060  STRING, PVOID, PVOID, INT, PVOID, INT)
3061 FCALLSCSUB4( dis_add_cmnd, DIS_ADD_CMND, dis_add_cmnd,
3062  STRING, PVOID, PVOID, INT)
3063 FCALLSCSUB1( dis_add_client_exit_handler, DIS_ADD_CLIENT_EXIT_HANDLER,
3064  dis_add_client_exit_handler,
3065  PVOID)
3066 FCALLSCSUB2( dis_set_client_exit_handler, DIS_SET_CLIENT_EXIT_HANDLER,
3067  dis_set_client_exit_handler,
3068  INT, INT)
3069 FCALLSCSUB1( dis_add_exit_handler, DIS_ADD_EXIT_HANDLER,
3070  dis_add_exit_handler,
3071  PVOID)
3072 FCALLSCSUB1( dis_report_service, DIS_REPORT_SERVICE, dis_report_service,
3073  STRING)
3074 FCALLSCSUB2( dis_convert_str, DIS_CONVERT_STR, dis_convert_str,
3075  PVOID, PVOID)
3076 FCALLSCFUN1(INT, dis_update_service, DIS_UPDATE_SERVICE, dis_update_service,
3077  INT)
3078 FCALLSCFUN1(INT, dis_remove_service, DIS_REMOVE_SERVICE, dis_remove_service,
3079  INT)
3080 FCALLSCSUB3( dis_send_service, DIS_SEND_SERVICE, dis_send_service,
3081  INT, PVOID, INT)
3082 FCALLSCSUB2( dis_set_quality, DIS_SET_QUALITY, dis_set_quality,
3083  INT, INT)
3084 FCALLSCSUB3(INT, dis_set_timestamp, DIS_SET_TIMESTAMP, dis_set_timestamp,
3085  INT, INT, INT)
3086 FCALLSCFUN2(INT, dis_selective_update_service, DIS_SELECTIVE_UPDATE_SERVICE,
3087  dis_selective_update_service,
3088  INT, PINT)
3089 FCALLSCSUB3(INT, dis_get_timestamp, DIS_GET_TIMESTAMP, dis_get_timestamp,
3090  INT, PINT, PINT)
3091 #endif
dis_no_dns
int dis_no_dns()
Definition: dis_old.c:2977
start
int start(int initState)
Definition: feeserver.c:1740
close_dns
int close_dns(dim_long dnsid, SRC_TYPES src_type)
Definition: open_dns.c:298
SERVICE
struct serv SERVICE
execute_service
int execute_service(int req_id)
Definition: dis_old.c:1275
SWAPS
Definition: dim.h:191
Dis_packet_size
static int Dis_packet_size
Definition: dis_old.c:193
MAX_REGISTRATION_UNIT
#define MAX_REGISTRATION_UNIT
Definition: dim.h:161
dis_get_conn_id
int dis_get_conn_id()
Definition: dis_old.c:2485
cmnds::tag
long tag
Definition: dis_old.c:2419
MAX_NAME
#define MAX_NAME
Definition: dim.h:182
serv::user_millisecs
int user_millisecs
Definition: dis.c:84
node
Definition: dns.c:26
REQUEST_PTR
struct reqp_ent REQUEST_PTR
DIMDNSTMOUT
#define DIMDNSTMOUT
Definition: dim_common.h:286
Threads_off
static int Threads_off
Definition: dis_old.c:142
DIC_PACKET
Definition: dim.h:230
serv::dnsp
DIS_DNS_CONN * dnsp
Definition: dis.c:87
dtq_delete
int dtq_delete(int queue_id)
Definition: dtq.c:378
dis_dns_ent::serving
int serving
Definition: dis.c:46
sll_get_head
SLL * sll_get_head(SLL *head)
Definition: sll.c:107
REQUEST
struct req_ent REQUEST
DIC_PACKET::type
int type
Definition: dim.h:234
dis_dns_ent::dns_dis_conn_id
int dns_dis_conn_id
Definition: dis.c:44
ALL
#define ALL
Definition: dis_old.c:32
Dis_timer_q
static int Dis_timer_q
Definition: dis_old.c:141
Dis_packet
static DIS_STAMPED_PACKET * Dis_packet
Definition: dis_old.c:192
dna_write
int dna_write(int conn_id, void *buffer, int size)
Definition: dna.c:455
do_dis_add_service
static unsigned do_dis_add_service(char *name, char *type, void *address, int size, void(*user_routine)(), long tag)
Definition: dis_old.c:316
dis_get_client
int dis_get_client(char *name)
Definition: dis_old.c:2490
add_exit_handler
void add_exit_handler(int *tag, int *bufp, int *size)
Definition: dis_old.c:2719
MONIT_FIRST
#define MONIT_FIRST
Definition: dim_common.h:15
service_id
unsigned service_id
Definition: db_dim_client.c:22
register_services
void register_services(DIS_DNS_CONN *dnsp, int flag, int dns_flag)
Definition: dis_old.c:763
dis_add_error_handler
void dis_add_error_handler(void(*user_routine)())
Definition: dis_old.c:525
copy_swap_buffer_in
int copy_swap_buffer_in(FORMAT_STR *format_data, void *buff_out, void *buff_in, int size)
Definition: copy_swap.c:270
dis_set_quality
void dis_set_quality(unsigned serv_id, int quality)
Definition: dis_old.c:1748
get_format_data
static int get_format_data(FORMAT_STR *format_data, char *def)
Definition: dis_old.c:533
dis_set_buffer_size
int dis_set_buffer_size(int size)
Definition: dis_old.c:195
dis_hash_service_exists
SERVICE * dis_hash_service_exists(char *name)
Definition: dis_old.c:2905
DIC_PACKET::service_name
char service_name[MAX_NAME]
Definition: dim.h:232
dis_print_hash_table
void dis_print_hash_table()
Definition: dis_old.c:3007
serv::to_delete
int to_delete
Definition: dis.c:89
dis_hash_service_get_next
SERVICE * dis_hash_service_get_next(int *curr_index, SERVICE *prevp, int new_entries)
Definition: dis_old.c:2920
send_dns_update_packet
int send_dns_update_packet(DIS_DNS_CONN *dnsp)
Definition: dis_old.c:735
dis_hash_service_insert
int dis_hash_service_insert(SERVICE *servp)
Definition: dis_old.c:2879
NET_CONNECTION::task
char task[MAX_TASK_NAME]
Definition: dim.h:408
dis_add_service_dns
unsigned dis_add_service_dns(long dnsid, char *name, char *type, void *address, int size, void(*user_routine)(), long tag)
Definition: dis_old.c:382
Port_number
static int Port_number
Definition: dis_old.c:121
dis_hash_print
void dis_hash_print()
Definition: dis_old.c:3038
STA_DISC
#define STA_DISC
Definition: dim.h:197
dis_dns_init
void dis_dns_init()
Definition: dis_old.c:976
exit_handler
static void exit_handler(int *tag, int *bufp, int *size)
Definition: dis_old.c:2811
i
int i
Definition: db_dim_client.c:21
release_all_requests
void release_all_requests(int conn_id, CLIENT *clip)
Definition: dis_old.c:2157
DIC_PACKET::service_id
int service_id
Definition: dim.h:233
Net_conns
DllExp DIM_NOSHARE NET_CONNECTION * Net_conns
Definition: conn_handler.c:32
Service_new_entries
static int Service_new_entries[MAX_HASH_ENTRIES]
Definition: dis_old.c:2859
CLIENT
struct cli_ent CLIENT
COMMAND
#define COMMAND
Definition: dim_common.h:10
dis_dns_ent::task_name
char task_name[MAX_NAME]
Definition: dis.c:40
dis_send_service
void dis_send_service(unsigned service_id, int *buffer, int size)
Definition: dis_old.c:1869
recv_dns_dis_rout
void recv_dns_dis_rout(int conn_id, DNS_DIS_PACKET *packet, int size, int status)
Definition: dis_old.c:622
str
char str[80]
Definition: test_client.c:7
id_get_ptr
void * id_get_ptr(int id, SRC_TYPES type)
Definition: conn_handler.c:184
req_ent::to_delete
int to_delete
Definition: dis.c:64
req_ent::service_id
int service_id
Definition: dis.c:56
dis_no_threads
void dis_no_threads()
Definition: dis_old.c:187
dll_insert_queue
void dll_insert_queue(DLL *head, DLL *item)
Definition: dll.c:23
dis_find_dns
DIS_DNS_CONN * dis_find_dns(long dnsid)
Definition: dis_old.c:2962
find_release_request
int find_release_request(int conn_id, int service_id)
Definition: dis_old.c:2302
client_info
void client_info(long *tag, int **bufp, int *size, int *first_time)
Definition: dis_old.c:2522
dis_dns_ent::prev
struct dis_dns_ent * prev
Definition: dis.c:38
dis_add_cmnd_dns
unsigned dis_add_cmnd_dns(long dnsid, char *name, char *type, void(*user_routine)(), long tag)
Definition: dis_old.c:495
cli_ent
Definition: dis.c:98
cmnds::buffer
int buffer[1]
Definition: dis.c:2731
dis_set_timestamp
int dis_set_timestamp(unsigned serv_id, int secs, int millisecs)
Definition: dis_old.c:1776
FORMAT_STR::flags
short flags
Definition: dim.h:219
SERVICE_REG
Definition: dim.h:263
serv::registered
int registered
Definition: dis.c:81
DIMDNSEXIT
#define DIMDNSEXIT
Definition: dim_common.h:285
rand_tmout
int rand_tmout(int min, int max)
Definition: open_dns.c:161
serv::name
char name[MAX_NAME]
Definition: dis.c:72
DIC_PACKET::timeout
int timeout
Definition: dim.h:235
dna_close
int dna_close(int conn_id)
Definition: dna.c:835
dtq_create
int dtq_create()
Definition: dtq.c:353
Client_head
static CLIENT * Client_head
Definition: dis_old.c:106
DNS_DIS_PACKET::type
int type
Definition: dim.h:288
dis_add_service
unsigned dis_add_service(char *name, char *type, void *address, int size, void(*user_routine)(), long tag)
Definition: dis_old.c:361
DIS_STAMPED_PACKET::time_stamp
int time_stamp[2]
Definition: dim.h:254
release_request
int release_request(REQUEST *reqp, REQUEST_PTR *reqpp, int remove)
Definition: dis_old.c:2341
dis_insert_request
static void dis_insert_request(int conn_id, DIC_PACKET *dic_packet, int size, int status)
Definition: dis_old.c:1146
DIMSVCFORMT
#define DIMSVCFORMT
Definition: dim_common.h:289
MAX_HASH_ENTRIES
#define MAX_HASH_ENTRIES
Definition: dis_old.c:2856
do_exit_handler
int do_exit_handler(int conn_id)
Definition: dis_old.c:2791
DIS_DNS_PACKET::node_addr
char node_addr[4]
Definition: dim.h:274
copy_swap_buffer_out
int copy_swap_buffer_out(int format, FORMAT_STR *format_data, void *buff_out, void *buff_in, int size)
Definition: copy_swap.c:170
SWAPL
Definition: dim.h:191
dis_start_serving
int dis_start_serving(char *task)
Definition: dis_old.c:952
Memory::malloc
void * malloc()
Definition: EventBuilder.cc:99
serv::tag
long tag
Definition: dis_old.c:80
SWAPD
Definition: dim.h:191
serv::type
int type
Definition: dis.c:74
id
char id[4]
Definition: FITS.h:71
DIS_STAMPED_HEADER
#define DIS_STAMPED_HEADER
Definition: dim.h:260
DNS_DIS_HEADER
#define DNS_DIS_HEADER
Definition: dim.h:291
dis_set_client_exit_handler
void dis_set_client_exit_handler(int conn_id, int tag)
Definition: dis_old.c:2749
dis_dns_ent::dis_n_services
int dis_n_services
Definition: dis.c:43
timer_entry
Definition: dim.h:370
DIS_DNS_TMOUT_MAX
#define DIS_DNS_TMOUT_MAX
Definition: dim.h:157
dis_stop_serving
void dis_stop_serving()
Definition: dis_old.c:2091
DIS_DNS_PACKET::task_name
char task_name[MAX_TASK_NAME-4]
Definition: dim.h:273
dis_hash_service_init
int dis_hash_service_init()
Definition: dis_old.c:2861
req_ent::prev
struct req_ent * prev
Definition: dis.c:54
dll_init
void dll_init(DLL *head)
Definition: dll.c:14
Default_DNS
DIS_DNS_CONN * Default_DNS
Definition: dis_old.c:129
MORE
#define MORE
Definition: dis_old.c:33
MAX_CONNS
#define MAX_CONNS
Definition: dim.h:163
NONE
#define NONE
Definition: dis_old.c:34
NET_CONNECTION::node
char node[MAX_NODE_NAME]
Definition: dim.h:407
do_dis_add_cmnd
static unsigned do_dis_add_cmnd(char *name, char *type, void(*user_routine)(), long tag)
Definition: dis_old.c:476
STAMPED
#define STAMPED
Definition: dim_common.h:17
DIS_DNS_PACKET::protocol
int protocol
Definition: dim.h:277
SERVICE_REG::service_id
int service_id
Definition: dim.h:265
dis_selective_update_service
int dis_selective_update_service(unsigned service_id, int *client_ids)
Definition: dis_old.c:1524
dis_hash_service_registered
int dis_hash_service_registered(int index, SERVICE *servp)
Definition: dis_old.c:2889
do_update_service_list
void do_update_service_list(DIS_DNS_CONN *dnsp)
Definition: dis_old.c:940
DIC_HEADER
#define DIC_HEADER
Definition: dim.h:240
EXIT_H
struct exit_ent EXIT_H
DIS_STAMPED_PACKET::reserved
int reserved[3]
Definition: dim.h:256
dis_get_timestamp
int dis_get_timestamp(unsigned serv_id, int *secs, int *millisecs)
Definition: dis_old.c:1831
serv::tag
dim_long tag
Definition: dis.c:80
get_node_addr
int get_node_addr(char *node_addr)
Definition: utilities.c:98
TIMED_ONLY
#define TIMED_ONLY
Definition: dim_common.h:14
SIZEOF_CHAR
#define SIZEOF_CHAR
Definition: dim.h:596
dis_dns_ent::updating_service_list
int updating_service_list
Definition: dis.c:49
DIS_DNS_TMOUT_MIN
#define DIS_DNS_TMOUT_MIN
Definition: dim.h:156
cmnds
Definition: dis.c:2727
Protocol
static int Protocol
Definition: dis_old.c:120
dis_report_service
void dis_report_service(char *serv_name)
Definition: dis_old.c:1476
SERVICE_REG::service_name
char service_name[MAX_NAME]
Definition: dim.h:264
req_ent::timr_ent
TIMR_ENT * timr_ent
Definition: dis.c:65
dll_remove
void dll_remove(DLL *item)
Definition: dll.c:100
Error_conn_id
static int Error_conn_id
Definition: dis_old.c:128
Error_user_routine
static void(* Error_user_routine)()=0
Definition: dis_old.c:127
DIS_DNS_PACKET::n_services
int n_services
Definition: dim.h:279
std_cmnd_handler
void std_cmnd_handler(long *tag, int *cmnd_buff, int *size)
Definition: dis_old.c:2426
Debug_on
static int Debug_on
Definition: dis_old.c:152
FORMAT_STR::par_bytes
short par_bytes
Definition: dim.h:218
Dis_first_time
static int Dis_first_time
Definition: dis_old.c:116
Service_hash_table
static SERVICE * Service_hash_table[MAX_HASH_ENTRIES]
Definition: dis_old.c:2858
req_ent::format
int format
Definition: dis.c:61
UPDATE
#define UPDATE
Definition: dim_common.h:13
DIS_DNS_PACKET::format
int format
Definition: dim.h:278
dis_add_client_exit_handler
void dis_add_client_exit_handler(void(*user_routine)())
Definition: dis_old.c:509
DIS_DNS_PACKET::node_name
char node_name[MAX_NODE_NAME]
Definition: dim.h:272
Version_number
static int Version_number
Definition: dis_old.c:140
serv::format_data
FORMAT_STR format_data[MAX_NAME/4]
Definition: dis.c:76
DIMDNSUNDEF
#define DIMDNSUNDEF
Definition: dim_common.h:282
cmnds::next
struct cmnds * next
Definition: dis.c:2728
DIS_DNS_PACKET::src_type
SRC_TYPES src_type
Definition: dim.h:271
dis_dns_ent::dnsid
dim_long dnsid
Definition: dis.c:39
SIZEOF_FLOAT
#define SIZEOF_FLOAT
Definition: dim.h:599
append_service
void append_service(char *service_info_buffer, SERVICE *servp)
Definition: dis_old.c:2590
dis_init
static void dis_init()
Definition: dis_old.c:216
dis_add_cmnd
unsigned dis_add_cmnd(char *name, char *type, void(*user_routine)(), long tag)
Definition: dis_old.c:481
open_dns
int open_dns(dim_long dnsid, void(*recv_rout)(), void(*error_rout)(), int tmout_min, int tmout_max, SRC_TYPES src_type)
Definition: open_dns.c:313
req_ent::reqpp
struct reqp_ent * reqpp
Definition: dis.c:66
DIMSVCTOOLG
#define DIMSVCTOOLG
Definition: dim_common.h:291
dis_get_error_services
char * dis_get_error_services()
Definition: dis_old.c:2224
sll
Definition: dim.h:536
Last_client
static int Last_client
Definition: dis_old.c:147
dim_init_threads
void dim_init_threads()
Definition: dim_thr.c:399
dis_add_exit_handler
void dis_add_exit_handler(void(*user_routine)())
Definition: dis_old.c:517
Curr_conn_id
static int Curr_conn_id
Definition: dis_old.c:123
SIZEOF_DOUBLE
#define SIZEOF_DOUBLE
Definition: dim.h:600
do_dis_add_cmnd_dns
static unsigned do_dis_add_cmnd_dns(char *name, char *type, void(*user_routine)(), long tag, long dnsid)
Definition: dis_old.c:403
Cmnds_head
static DIS_CMND * Cmnds_head
Definition: dis_old.c:2424
dll
Definition: dim.h:530
dtq_start_timer
void dtq_start_timer(int time, void(*user_routine)(), dim_long tag)
Definition: dtq.c:790
DNS_CLIENT_INFO
Definition: dim.h:349
sll_remove_head
SLL * sll_remove_head(SLL *head)
Definition: sll.c:94
serv::delay_delete
int delay_delete
Definition: dis.c:88
cli_ent::conn_id
int conn_id
Definition: dis.c:101
_DIM_PROTO
_DIM_PROTO(static void dis_insert_request,(int conn_id, DIC_PACKET *dic_packet, int size, int status))
dis_start_serving_dns
int dis_start_serving_dns(long dnsid, char *task)
Definition: dis_old.c:1003
serv
Definition: dis.c:69
type
int type
Definition: dim_get_service.c:9
serv::user_secs
int user_secs
Definition: dis.c:83
serv::request_head
REQUEST * request_head
Definition: dis.c:86
DNS_DIS_PACKET::size
int size
Definition: dim.h:287
cli_ent::dnsp
DIS_DNS_CONN * dnsp
Definition: dis.c:103
WATCHDOG_TMOUT_MIN
#define WATCHDOG_TMOUT_MIN
Definition: dim.h:174
sll_init
void sll_init(SLL *head)
Definition: sll.c:14
sll_insert_queue
int sll_insert_queue(SLL *head, SLL *item)
Definition: sll.c:20
service_info
void service_info(long *tag, int **bufp, int *size, int *first_time)
Definition: dis_old.c:2646
dtq_rem_entry
int dtq_rem_entry(int queue_id, TIMR_ENT *entry)
Definition: dtq.c:503
SERVICE_REG::service_def
char service_def[MAX_NAME]
Definition: dim.h:266
dis_dns_ent::dns_timr_ent
TIMR_ENT * dns_timr_ent
Definition: dis.c:41
dis_get_next_cmnd
int dis_get_next_cmnd(long *tag, int *buffer, int *size)
Definition: dis_old.c:2444
MAX_TASK_NAME
#define MAX_TASK_NAME
Definition: dim.h:181
do_dis_stop_serving_dns
void do_dis_stop_serving_dns(DIS_DNS_CONN *dnsp)
Definition: dis_old.c:2010
dis_update_service
int dis_update_service(unsigned service_id)
Definition: dis_old.c:1517
FORMAT_STR::par_num
int par_num
Definition: dim.h:217
SRC_DIS
Definition: dim_common.h:19
DIS_PACKET::size
int size
Definition: dim.h:244
dis_get_timeout
int dis_get_timeout(unsigned service_id, int client_id)
Definition: dis_old.c:1721
do_register_services
void do_register_services(DIS_DNS_CONN *dnsp)
Definition: dis_old.c:758
dis_dns_ent::dis_first_time
int dis_first_time
Definition: dis.c:45
sll_search_next_remove
SLL * sll_search_next_remove(SLL *item, int offset, char *data, int size)
Definition: sll.c:118
DIM_FATAL
Definition: dim_common.h:280
DIMSVCDUPLC
#define DIMSVCDUPLC
Definition: dim_common.h:288
unregister_service
void unregister_service(DIS_DNS_CONN *dnsp, SERVICE *servp)
Definition: dis_old.c:895
SIZEOF_LONG
#define SIZEOF_LONG
Definition: dim.h:598
DIS_PACKET::service_id
int service_id
Definition: dim.h:245
dns_get_dnsid
dim_long dns_get_dnsid(int conn_id, SRC_TYPES src_type)
Definition: open_dns.c:426
DIMDNSDUPLC
#define DIMDNSDUPLC
Definition: dim_common.h:284
dis_convert_str
#define dis_convert_str
Definition: dis.h:21
cli_ent::requestp_head
REQUEST_PTR * requestp_head
Definition: dis.c:102
dna_get_node_task
int dna_get_node_task(int conn_id, char *node, char *task)
Definition: dna.c:594
IT_IS_FLOAT
#define IT_IS_FLOAT
Definition: dim.h:27
DIMSVCINVAL
#define DIMSVCINVAL
Definition: dim_common.h:290
DIS_DNS_CONN
struct dis_dns_ent DIS_DNS_CONN
serv_id
int serv_id
Definition: demo_server.c:5
dis_set_debug_off
void dis_set_debug_off()
Definition: dis_old.c:182
DIS_DNS_PACKET
Definition: dim.h:269
serv::user_routine
void(* user_routine)()
Definition: dis.c:79
DIS_DNS_PACKET::size
int size
Definition: dim.h:270
sll_remove
int sll_remove(SLL *head, SLL *item)
Definition: sll.c:74
WATCHDOG_TMOUT_MAX
#define WATCHDOG_TMOUT_MAX
Definition: dim.h:175
dis_remove_service
int dis_remove_service(unsigned service_id)
Definition: dis_old.c:1919
dna_write_nowait
int dna_write_nowait(int conn_id, void *buffer, int size)
Definition: dna.c:412
cmnds::tag
dim_long tag
Definition: dis.c:2729
find_client
CLIENT * find_client(int conn_id)
Definition: dis_old.c:2148
buffer
int buffer[BUFFSIZE]
Definition: db_dim_client.c:14
dis_hash_service_remove
int dis_hash_service_remove(SERVICE *servp)
Definition: dis_old.c:2898
req_ent::service_ptr
struct serv * service_ptr
Definition: dis.c:59
req_ent::first_time
int first_time
Definition: dis.c:62
dll_empty
int dll_empty(DLL *head)
Definition: dll.c:88
DIC_PACKET::size
int size
Definition: dim.h:231
execute_command
void execute_command(SERVICE *servp, DIC_PACKET *packet)
Definition: dis_old.c:1421
DIM_ERROR
Definition: dim_common.h:280
find_service
SERVICE * find_service(char *name)
Definition: dis_old.c:2143
DIS_CMND
struct cmnds DIS_CMND
flag
Removed all warnings from DIM sources so that it can be compiled with Wall Wextra on Linux Changed the makefiles so that the default on Linux is now bits The flag
Definition: README_v19.txt:392
dna_open_server
int dna_open_server(char *task, void(*read_ast)(), int *protocol, int *port, void(*error_ast)())
Definition: dna.c:551
size
int size
Definition: db_dim_server.c:17
id_free
void id_free(int id, SRC_TYPES type)
Definition: conn_handler.c:206
error_handler
static void error_handler(int conn_id, int severity, int errcode, char *reason)
Definition: dis_old.c:2827
DIM_WARNING
Definition: dim_common.h:280
DIS_DNS_PACKET::port
int port
Definition: dim.h:276
DIC_PACKET::buffer
int buffer[1]
Definition: dim.h:237
DIS_PACKET::buffer
int buffer[1]
Definition: dim.h:246
serv::address
int * address
Definition: dis.c:77
dis_set_debug_on
void dis_set_debug_on()
Definition: dis_old.c:177
DIC_PACKET::format
int format
Definition: dim.h:236
Memory::free
void free(void *mem)
Definition: EventBuilder.cc:126
Serving
static int Serving
Definition: dis_old.c:124
dtq_add_entry
TIMR_ENT * dtq_add_entry(int queue_id, int time, void(*user_routine)(), dim_long tag)
Definition: dtq.c:399
req_ent::type
int type
Definition: dis.c:58
req_ent::delay_delete
int delay_delete
Definition: dis.c:63
req_ent::timeout
int timeout
Definition: dis.c:60
check_service_name
static int check_service_name(char *name)
Definition: dis_old.c:209
serv::def
char def[MAX_NAME]
Definition: dis.c:75
dll_get_next
DLL * dll_get_next(DLL *head, DLL *item)
Definition: dll.c:66
dis_get_n_clients
int dis_get_n_clients(unsigned service_id)
Definition: dis_old.c:1685
reqp_ent
Definition: dis.c:92
reqp_ent::reqp
REQUEST * reqp
Definition: dis.c:95
MAX_NODE_NAME
#define MAX_NODE_NAME
Definition: dim.h:180
id_get
int id_get(void *ptr, SRC_TYPES type)
Definition: conn_handler.c:152
reqp_ent::prev
struct reqp_ent * prev
Definition: dis.c:94
dim_print_date_time
void dim_print_date_time()
Definition: utilities.c:134
exit_ent::task
char task[MAX_TASK_NAME]
Definition: dis.c:136
req_ent::req_id
int req_id
Definition: dis.c:57
dis_dns_ent::next
struct dis_dns_ent * next
Definition: dis.c:37
dim_print_msg
void dim_print_msg(char *msg, int severity)
Definition: utilities.c:180
dis_dns_ent::dis_service_id
unsigned int dis_service_id
Definition: dis.c:47
HashFunction
int HashFunction(char *name, int max)
Definition: hash.c:22
DIM_VERSION_NUMBER
#define DIM_VERSION_NUMBER
Definition: dim.h:16
cmnds::size
int size
Definition: dis.c:2730
Exit_user_routine
static void(* Exit_user_routine)()=0
Definition: dis_old.c:126
exit_ent::exit_id
int exit_id
Definition: dis.c:134
SIZEOF_SHORT
#define SIZEOF_SHORT
Definition: dim.h:597
exit_ent
Definition: dis.c:131
FORMAT_STR
Definition: dim.h:216
more_ids
int more_ids[1024]
Definition: test_server.c:56
SEEK_PORT
#define SEEK_PORT
Definition: dim.h:140
DNS_DIS_PACKET
Definition: dim.h:286
serv::size
int size
Definition: dis.c:78
release_conn
static int release_conn(int conn_id, int print_flg, int dns_flag)
Definition: dis_old.c:2374
Client_exit_user_routine
static void(* Client_exit_user_routine)()=0
Definition: dis_old.c:125
do_update_service
int do_update_service(unsigned service_id, int *client_ids)
Definition: dis_old.c:1546
exit_ent::conn_id
int conn_id
Definition: dis.c:133
DIS_DNS_PACKET::pid
int pid
Definition: dim.h:275
ONCE_ONLY
#define ONCE_ONLY
Definition: dim_common.h:7
DIS_DNS_HEADER
#define DIS_DNS_HEADER
Definition: dim.h:283
DIS_STAMPED_PACKET::size
int size
Definition: dim.h:252
DIS_HEADER
#define DIS_HEADER
Definition: dim.h:249
DIS_DNS_PACKET::services
SERVICE_REG services[MAX_SERVICE_UNIT]
Definition: dim.h:280
remove_service
void remove_service(int req_id)
Definition: dis_old.c:1398
dis_dns_ent::dis_client_id
unsigned int dis_client_id
Definition: dis.c:48
serv::tid
int tid
Definition: dis.c:85
req_ent::conn_id
int conn_id
Definition: dis.c:55
do_dis_add_service_dns
static unsigned do_dis_add_service_dns(char *name, char *type, void *address, int size, void(*user_routine)(), long tag, long dnsid)
Definition: dis_old.c:229
Dis_conn_id
static int Dis_conn_id
Definition: dis_old.c:122
get_node_name
int get_node_name(char *node_name)
Definition: utilities.c:33
check_client
int check_client(REQUEST *reqp, int *client_ids)
Definition: dis_old.c:1531
dis_dns_ent::dis_dns_packet
DIS_DNS_PACKET dis_dns_packet
Definition: dis.c:42
req_ent
Definition: dis.c:52
DIM_DELETE
#define DIM_DELETE
Definition: dim_common.h:11
sprintf
sprintf(name1,"NewService%d", i)
dim_stop_threads
void dim_stop_threads()
Definition: dim_thr.c:404
DIMDNSREFUS
#define DIMDNSREFUS
Definition: dim_common.h:283
create_dns
static DIS_DNS_CONN * create_dns(long dnsid)
Definition: dis_old.c:957
MONIT_ONLY
#define MONIT_ONLY
Definition: dim_common.h:12
sll_search
SLL * sll_search(SLL *head, char *data, int size)
Definition: sll.c:35
dis_get_client_services
char * dis_get_client_services(int conn_id)
Definition: dis_old.c:2229
STA_CONN
#define STA_CONN
Definition: dim.h:199
dis_dns_ent
Definition: dis.c:36
user_routine
static void user_routine(void *tagp, void *bufp, int *size)
Definition: diccpp.cxx:11
dll_search
DLL * dll_search(DLL *head, char *data, int size)
Definition: dll.c:49
Exit_h_head
static EXIT_H * Exit_h_head
Definition: dis_old.c:137
DNS_head
static DIS_DNS_CONN * DNS_head
Definition: dis_old.c:108
DIS_STAMPED_PACKET
Definition: dim.h:251
dis_dns_ent::dnsid
long dnsid
Definition: dis_old.c:39
find_dns_by_conn_id
DIS_DNS_CONN * find_dns_by_conn_id(int conn_id)
Definition: dis_old.c:2994
serv::quality
int quality
Definition: dis.c:82
NOSWAP
Definition: dim.h:191
DIS_PACKET
Definition: dim.h:243
DIS_STAMPED_PACKET::service_id
int service_id
Definition: dim.h:253
DIS_STAMPED_PACKET::quality
int quality
Definition: dim.h:255
dis_stop_serving_dns
void dis_stop_serving_dns(long dnsid)
Definition: dis_old.c:2083
check_delay_delete
CLIENT * check_delay_delete(int conn_id)
Definition: dis_old.c:2193
MAX_SERVICE_UNIT
#define MAX_SERVICE_UNIT
Definition: dim.h:160
serv::id
int id
Definition: dis.c:73
dim_print_date_time_millis
void dim_print_date_time_millis()
Definition: utilities.c:157