FACT++  1.0
dic.c
Go to the documentation of this file.
1 
2 /*
3  * DIC (Delphi Information Client) Package implements a library of
4  * routines to be used by clients.
5  *
6  * Started on : 10-11-91
7  * Last modification : 10-08-94
8  * Written by : C. Gaspar
9  * Adjusted by : G.C. Ballintijn
10  *
11  */
12 
13 #ifdef VMS
14 # include <cfortran.h>
15 # include <assert.h>
16 #endif
17 
18 #define DIMLIB
19 #include <dim.h>
20 #include <dic.h>
21 
22 /*
23 #define DEBUG
24 */
25 
26 #ifdef VMS
27 #define TMP_ENABLE_AST long int ast_enable = sys$setast(1);
28 #define TMP_DISABLE_AST if (ast_enable != SS$_WASSET) sys$setast(0);
29 #endif
30 
31 #define BAD_CONN_TIMEOUT 2
32 
33 typedef struct bad_conn {
34  struct bad_conn *next;
35  struct bad_conn *prev;
36  DIC_CONNECTION conn;
37  int n_retries;
38  int retrying;
39 } DIC_BAD_CONNECTION;
40 
41 static DIC_SERVICE *Service_pend_head = 0;
42 static DIC_SERVICE *Cmnd_head = 0;
43 static DIC_SERVICE *Current_server = 0;
44 static DIC_BAD_CONNECTION *Bad_connection_head = 0;
45 static int Dic_timer_q = 0;
46 static int Dns_dic_conn_id = 0;
47 static TIMR_ENT *Dns_dic_timr = NULL;
48 static int Tmout_max = 0;
49 static int Tmout_min = 0;
50 static int Threads_off = 0;
51 
52 static void (*Error_user_routine)() = 0;
53 static int Error_conn_id = 0;
54 static int Curr_conn_id = 0;
55 
56 #ifdef DEBUG
57 static int Debug_on = 1;
58 #else
59 static int Debug_on = 0;
60 #endif
61 
62 _DIM_PROTO( unsigned request_service, (char *service_name, int req_type,
63  int req_timeout, void *service_address,
64  int service_size, void (*usr_routine)(void*,void*,int*),
65  dim_long tag, void *fill_addr, int fill_size, int stamped) );
66 _DIM_PROTO( int request_command, (char *service_name, void *service_address,
67  int service_size, void (*usr_routine)(void*,int*),
68  dim_long tag, int stamped) );
69 _DIM_PROTO( DIC_SERVICE *insert_service, (int type, int timeout, char *name,
70  int *address, int size, void (*routine)(),
71  dim_long tag, int *fill_addr, int fill_size,
72  int pending, int stamped ) );
73 _DIM_PROTO( void modify_service, (DIC_SERVICE *servp, int timeout,
74  int *address, int size, void (*routine)(),
75  dim_long tag, int *fill_addr, int fill_size, int stamped) );
76 _DIM_PROTO( DIC_SERVICE *locate_command, (char *serv_name) );
77 _DIM_PROTO( DIC_SERVICE *locate_pending, (char *serv_name) );
78 _DIM_PROTO( DIC_BAD_CONNECTION *locate_bad, (char *node, char *task, int port) );
79 _DIM_PROTO( void service_tmout, (int serv_id) );
80 _DIM_PROTO( static void request_dns_info, (int retry) );
81 _DIM_PROTO( static int handle_dns_info, (DNS_DIC_PACKET *) );
82 _DIM_PROTO( void close_dns_conn, (void) );
83 _DIM_PROTO( static void release_conn, (int conn_id) );
84 _DIM_PROTO( static void get_format_data, (int format, FORMAT_STR *format_data,
85  char *def) );
86 _DIM_PROTO( static void execute_service, (DIS_PACKET *packet,
87  DIC_SERVICE *servp, int size) );
88 
89 void print_packet(DIS_PACKET *packet)
90 {
91  dim_print_date_time();
92  printf("Bad ID received from server -> Packet received:\n");
93  printf("\tpacket->size = %d\n",vtohl(packet->size));
94  printf("\tpacket->service_id = %d\n",vtohl(packet->service_id));
95 }
96 
97 void dic_set_debug_on()
98 {
99  Debug_on = 1;
100 }
101 
102 void dic_set_debug_off()
103 {
104  Debug_on = 0;
105 }
106 
107 void dic_no_threads()
108 {
109  Threads_off = 1;
110 }
111 
112 void dic_add_error_handler( void (*user_routine)())
113 {
114 
115  DISABLE_AST
116  Error_user_routine = user_routine;
117  ENABLE_AST
118 }
119 
120 static void error_handler(int conn_id, int severity, int errcode, char *reason)
121 {
122  int last_conn_id;
123 
124  if(Error_user_routine)
125  {
126  Error_conn_id = conn_id;
127  last_conn_id = Curr_conn_id;
128  (Error_user_routine)(severity, errcode, reason);
129  Error_conn_id = 0;
130  Curr_conn_id = last_conn_id;
131  }
132  else
133  {
134  dim_print_msg(reason, severity);
135  if(severity == 3)
136  {
137  printf("Exiting!\n");
138  exit(2);
139  }
140  }
141 }
142 
143 static void recv_rout( int conn_id, DIS_PACKET *packet, int size, int status )
144 {
145  register DIC_SERVICE *servp, *auxp;
146  register DIC_CONNECTION *dic_connp;
147  int service_id, once_only, found = 0;
148  char node[MAX_NODE_NAME], task[MAX_TASK_NAME];
149  void move_to_notok_service();
150  void do_cmnd_callback();
151  void dim_panic(char *);
152 
153  dic_connp = &Dic_conns[conn_id] ;
154  switch( status )
155  {
156  case STA_DISC:
157  if(Debug_on)
158  {
159  dna_get_node_task(conn_id, node, task);
160  dim_print_date_time();
161  printf("Conn %d: Server %s on node %s Disconnected\n",
162  conn_id, task, node);
163  fflush(stdout);
164  }
165  if( !(servp = (DIC_SERVICE *) dic_connp->service_head) )
166  {
167  release_conn( conn_id );
168  break;
169  }
170  while( (servp = (DIC_SERVICE *) dll_get_next(
171  (DLL *) dic_connp->service_head,
172  (DLL *) servp)) )
173  {
174 #ifdef DEBUG
175  printf("\t %s was in the service list\n",servp->serv_name);
176  fflush(stdout);
177 #endif
178 /*
179  Will be done later by the DNS answer
180  service_tmout( servp->serv_id );
181 */
182  if(!strcmp(dic_connp->task_name,"DIS_DNS"))
183  {
184  service_tmout( servp->serv_id );
185  }
186  else if(Dns_dic_conn_id <= 0)
187  {
188  service_tmout( servp->serv_id );
189  }
190 /*
191  servp->pending = WAITING_DNS_UP;
192  servp->conn_id = 0;
193 */
194  auxp = servp->prev;
195  move_to_notok_service( servp );
196  servp = auxp;
197  }
198  if( (servp = (DIC_SERVICE *) Cmnd_head) )
199  {
200  while( (servp = (DIC_SERVICE *) dll_get_next(
201  (DLL *) Cmnd_head,
202  (DLL *) servp)) )
203  {
204  if( servp->conn_id == conn_id )
205  {
206 #ifdef DEBUG
207  printf("\t%s was in the Command list\n", servp->serv_name);
208  printf("servp = %x, type = %d, pending = %d\n",servp, servp->type, servp->pending);
209  fflush(stdout);
210 #endif
211  auxp = servp->prev;
212  if( (servp->type == ONCE_ONLY ) &&
213  (servp->pending == WAITING_SERVER_UP))
214  {
215  service_tmout( servp->serv_id );
216  }
217  else if( (servp->type == COMMAND ) &&
218  (servp->pending == WAITING_CMND_ANSWER))
219  {
220  service_tmout( servp->serv_id );
221  }
222  else
223  {
224  servp->pending = WAITING_DNS_UP;
225  dic_release_service( (unsigned)servp->serv_id );
226  }
227  servp = auxp;
228  }
229  }
230  }
231  release_conn( conn_id );
232  request_dns_info(0);
233  break;
234  case STA_DATA:
235  if( !(DIC_SERVICE *) dic_connp->service_head )
236  break;
237  service_id = vtohl(packet->service_id);
238  if((unsigned)service_id & 0x80000000) /* Service removed by server */
239  {
240  service_id &= 0x7fffffff;
241  if( (servp = (DIC_SERVICE *) id_get_ptr(service_id, SRC_DIC)))
242  {
243  if( servp->type != COMMAND )
244  {
245  service_tmout( servp->serv_id );
246 /*
247  servp->pending = WAITING_DNS_UP;
248  servp->conn_id = 0;
249 */
250  move_to_notok_service( servp );
251  }
252  else
253  {
254  service_tmout( servp->serv_id );
255  break;
256  }
257  }
258  else
259  {
260 /*
261  print_packet(packet);
262 */
263  if( (servp = (DIC_SERVICE *) Cmnd_head) )
264  {
265  while( (servp = (DIC_SERVICE *) dll_get_next(
266  (DLL *) Cmnd_head,
267  (DLL *) servp)) )
268  {
269  if( servp->conn_id == conn_id )
270  {
271 #ifdef DEBUG
272  printf("\t%s was in the Command list\n", servp->serv_name);
273  fflush(stdout);
274 #endif
275  auxp = servp->prev;
276  if( (servp->type == ONCE_ONLY ) &&
277  (servp->pending == WAITING_SERVER_UP))
278  {
279  service_tmout( servp->serv_id );
280  }
281  else if( (servp->type == COMMAND ) &&
282  (servp->pending == WAITING_CMND_ANSWER))
283  {
284  service_tmout( servp->serv_id );
285  }
286  else
287  {
288  servp->pending = WAITING_DNS_UP;
289  dic_release_service( (unsigned)servp->serv_id );
290  }
291  servp = auxp;
292  }
293  }
294  }
295  }
296  if( dll_empty((DLL *)dic_connp->service_head) ) {
297  if( (servp = (DIC_SERVICE *) Cmnd_head) ) {
298  while( (servp = (DIC_SERVICE *) dll_get_next(
299  (DLL *) Cmnd_head,
300  (DLL *) servp)) )
301  {
302  if( servp->conn_id == conn_id)
303  found = 1;
304  }
305  }
306  if( !found)
307  {
308  release_conn( conn_id );
309  }
310  }
311  request_dns_info(0);
312  break;
313  }
314  if( (servp = (DIC_SERVICE *) id_get_ptr(service_id, SRC_DIC)))
315  {
316  if(servp->serv_id == service_id)
317  {
318  once_only = 0;
319  if(servp->type == ONCE_ONLY)
320  once_only = 1;
321  else
322  {
323  if( servp->timeout > 0 )
324  {
325  if(servp->timer_ent)
326  dtq_clear_entry( servp->timer_ent );
327  }
328  }
329  Curr_conn_id = conn_id;
330  execute_service(packet, servp, size);
331  Curr_conn_id = 0;
332  if( once_only )
333  {
334  auxp = locate_command(servp->serv_name);
335  if((auxp) && (auxp != servp))
336  {
337  servp->pending = WAITING_DNS_UP;
338  dic_release_service( (unsigned)servp->serv_id );
339  }
340  else
341  {
342  servp->pending = NOT_PENDING;
343  servp->tmout_done = 0;
344  if( servp->timer_ent )
345  {
346  dtq_rem_entry( Dic_timer_q, servp->timer_ent );
347  servp->timer_ent = 0;
348  }
349  }
350  }
351  }
352  }
353 /*
354  else
355  {
356  print_packet(packet);
357  if(Error_user_routine)
358  (Error_user_routine)( packet->buffer );
359  }
360 */
361  break;
362  case STA_CONN:
363  if(Debug_on)
364  {
365  dna_get_node_task(conn_id, node, task);
366  dim_print_date_time();
367  printf("Conn %d: Server %s on node %s Connected\n",
368  conn_id, task, node);
369  fflush(stdout);
370  }
371  break;
372  default: dim_panic( "recv_rout(): Bad switch" );
373  }
374 }
375 
376 static void execute_service(DIS_PACKET *packet, DIC_SERVICE *servp, int size)
377 {
378  int format;
379  FORMAT_STR format_data_cp[MAX_NAME/4], *formatp;
380  static int *buffer;
381  static int buffer_size = 0;
382  int add_size;
383  int *pkt_buffer, header_size;
384 
385  Current_server = servp;
386  format = servp->format;
387  memcpy(format_data_cp, servp->format_data, sizeof(format_data_cp));
388  if((format & 0xF) == ((MY_FORMAT) & 0xF))
389  {
390  for(formatp = format_data_cp; formatp->par_bytes; formatp++)
391  formatp->flags &= (short)0xFFF0; /* NOSWAP */
392  }
393  if( servp->stamped)
394  {
395  pkt_buffer = ((DIS_STAMPED_PACKET *)packet)->buffer;
396  header_size = DIS_STAMPED_HEADER;
397  servp->time_stamp[0] = vtohl(((DIS_STAMPED_PACKET *)packet)->time_stamp[0]);
398  if(((unsigned)servp->time_stamp[0] & 0xFFFF0000) == 0xc0de0000)
399  {
400 /*
401  servp->time_stamp[0] &= 0x0000FFFF;
402 */
403  servp->time_stamp[1] = vtohl(((DIS_STAMPED_PACKET *)packet)->time_stamp[1]);
404  servp->quality = vtohl(((DIS_STAMPED_PACKET *)packet)->quality);
405  }
406  else if((vtohl(((DIS_STAMPED_PACKET *)packet)->reserved[0])) == (int)0xc0dec0de)
407  {
408 /*
409  servp->time_stamp[0] &= 0x0000FFFF;
410 */
411  servp->time_stamp[1] = vtohl(((DIS_STAMPED_PACKET *)packet)->time_stamp[1]);
412  servp->quality = vtohl(((DIS_STAMPED_PACKET *)packet)->quality);
413  }
414  else
415  {
416  pkt_buffer = ((DIS_PACKET *)packet)->buffer;
417  header_size = DIS_HEADER;
418  }
419  }
420  else
421  {
422  pkt_buffer = ((DIS_PACKET *)packet)->buffer;
423  header_size = DIS_HEADER;
424  }
425  size -= header_size;
426  if( servp->serv_address )
427  {
428  if( size > servp->serv_size )
429  size = servp->serv_size;
430  add_size = copy_swap_buffer_in(format_data_cp,
431  servp->serv_address,
432  pkt_buffer, size);
433  if( servp->user_routine )
434  (servp->user_routine)(&servp->tag, servp->serv_address, &add_size );
435  }
436  else
437  {
438  if( servp->user_routine )
439  {
440  add_size = size + (size/2);
441  if(!buffer_size)
442  {
443  buffer = (int *)malloc((size_t)add_size);
444  buffer_size = add_size;
445  }
446  else
447  {
448  if( add_size > buffer_size )
449  {
450  free(buffer);
451  buffer = (int *)malloc((size_t)add_size);
452  buffer_size = add_size;
453  }
454  }
455  add_size = copy_swap_buffer_in(format_data_cp,
456  buffer,
457  pkt_buffer, size);
458  (servp->user_routine)( &servp->tag, buffer, &add_size );
459  }
460  }
461  Current_server = 0;
462 }
463 
464 static void recv_dns_dic_rout( int conn_id, DNS_DIC_PACKET *packet, int size, int status )
465 {
466  register DIC_SERVICE *servp, *auxp;
467  void dim_panic(char *);
468 
469  if(size){}
470  switch( status )
471  {
472  case STA_DISC: /* connection broken */
473  servp = Service_pend_head;
474  while( (servp = (DIC_SERVICE *) dll_get_next(
475  (DLL *) Service_pend_head,
476  (DLL *) servp)) )
477  {
478  if( (servp->pending == WAITING_DNS_ANSWER) ||
479  (servp->pending == WAITING_SERVER_UP))
480  {
481  if(( servp->type == COMMAND )||( servp->type == ONCE_ONLY ))
482  {
483  auxp = servp->prev;
484  servp->pending = WAITING_DNS_UP;
485  service_tmout( servp->serv_id );
486  servp = auxp;
487  }
488  else
489  {
490  servp->pending = WAITING_DNS_UP;
491  }
492  }
493  }
494  dna_close( Dns_dic_conn_id );
495  Dns_dic_conn_id = 0;
496  request_dns_info(0);
497  break;
498  case STA_CONN: /* connection received */
499  dna_set_test_write(conn_id, 2*(dim_get_keepalive_timeout()));
500  if(Dns_dic_conn_id < 0)
501  {
502  Dns_dic_conn_id = conn_id;
503  request_dns_info(0);
504 
505  }
506  break;
507  case STA_DATA: /* normal packet */
508  if( vtohl(packet->size) == DNS_DIC_HEADER )
509  {
510  handle_dns_info( packet );
511  }
512  break;
513  default: dim_panic( "recv_dns_dic_rout(): Bad switch" );
514  }
515 }
516 
517 
518 void service_tmout( int serv_id )
519 {
520  int once_only, size = 0;
521  register DIC_SERVICE *servp;
522 
523 /*
524 dim_print_date_time();
525 printf("In service tmout\n");
526 */
527  servp=(DIC_SERVICE *)id_get_ptr(serv_id, SRC_DIC);
528  if(!servp)
529  return;
530  if(servp->tmout_done)
531  return;
532 /*
533 dim_print_date_time();
534 printf("In service tmout %s\n", servp->serv_name);
535 */
536  servp->tmout_done = 1;
537  Curr_conn_id = servp->conn_id;
538 /*
539  if( servp->type == UPDATE )
540  return;
541 */
542  if( servp->type == COMMAND )
543  {
544  if( servp->user_routine )
545  {
546  if(servp->pending == WAITING_CMND_ANSWER)
547  size = 1;
548  else
549  size = 0;
550  (servp->user_routine)( &servp->tag, &size );
551  }
552  else
553  {
554  if((servp->pending == WAITING_DNS_UP) || (servp->pending == WAITING_DNS_ANSWER))
555  {
556  dim_print_date_time();
557  printf(" Client Sending Command: Command %s discarded, no DNS answer\n", servp->serv_name);
558  fflush(stdout);
559  }
560 /*
561  else if(servp->pending == WAITING_SERVER_UP)
562  {
563  }
564 */
565  }
566  dic_release_service( (unsigned)servp->serv_id );
567  Curr_conn_id = 0;
568  return;
569  }
570  once_only = 0;
571  if(servp->type == ONCE_ONLY)
572  once_only = 1;
573 /*
574  if( servp->fill_address )
575 */
576  if( servp->fill_size >= 0 )
577  {
578  size = servp->fill_size;
579  if( servp->serv_address )
580  {
581  if( size > servp->serv_size )
582  size = servp->serv_size;
583  memcpy(servp->serv_address, servp->fill_address, (size_t)size);
584  if( servp->user_routine )
585  (servp->user_routine)( &servp->tag, servp->serv_address, &size);
586  }
587  else
588  {
589  if( servp->user_routine )
590  (servp->user_routine)( &servp->tag, servp->fill_address, &size);
591  }
592  }
593  if( once_only )
594  {
595  dic_release_service( (unsigned)servp->serv_id );
596  }
597  Curr_conn_id = 0;
598 }
599 
600 
601 unsigned dic_info_service( char *serv_name, int req_type, int req_timeout, void *serv_address,
602  int serv_size, void (*usr_routine)(), dim_long tag, void *fill_addr, int fill_size )
603 {
604  unsigned ret;
605 
606  ret = request_service( serv_name, req_type, req_timeout,
607  serv_address, serv_size, usr_routine, tag,
608  fill_addr, fill_size, 0 );
609 
610  return(ret);
611 }
612 
613 unsigned dic_info_service_stamped( char *serv_name, int req_type, int req_timeout, void *serv_address,
614  int serv_size, void (*usr_routine)(), dim_long tag, void *fill_addr, int fill_size )
615 {
616  unsigned ret;
617 
618  ret = request_service( serv_name, req_type, req_timeout,
619  serv_address, serv_size, usr_routine, tag,
620  fill_addr, fill_size, 1 );
621 
622  return(ret);
623 }
624 
625 unsigned request_service( char *serv_name, int req_type, int req_timeout, void *serv_address,
626  int serv_size, void (*usr_routine)(), dim_long tag, void *fill_addr, int fill_size, int stamped )
627 {
628  register DIC_SERVICE *servp;
629  int conn_id;
630  int send_service();
631  int locate_service();
632  void dim_init_threads(void);
633 
634  if(!Threads_off)
635  {
636  dim_init_threads();
637  }
638  {
639  DISABLE_AST
640  /* create a timer queue for timeouts if not yet done */
641  if( !Dic_timer_q ) {
642  conn_arr_create( SRC_DIC );
643  Dic_timer_q = dtq_create();
644  }
645 
646  /* store_service */
647  if(req_timeout < 0)
648  req_timeout = 0;
649  if(req_type == ONCE_ONLY)
650  {
651  if( !Cmnd_head ) {
652  Cmnd_head = (DIC_SERVICE *) malloc(sizeof(DIC_SERVICE) );
653  dll_init( (DLL *) Cmnd_head );
654  Cmnd_head->serv_id = 0;
655  }
656  if( (servp = locate_command(serv_name)) )
657  {
658  if( (conn_id = servp->conn_id) )
659  {
660  if(servp->pending == NOT_PENDING)
661  {
662  modify_service( servp, req_timeout,
663  (int *)serv_address, serv_size, usr_routine, tag,
664  (int *)fill_addr, fill_size, stamped);
665  servp->pending = WAITING_SERVER_UP;
666  if(send_service(conn_id, servp))
667  {
668  ENABLE_AST
669  return(1);
670  }
671  }
672  }
673  }
674  }
675  servp = insert_service( req_type, req_timeout,
676  serv_name, (int *)serv_address, serv_size, usr_routine, tag,
677  (int *)fill_addr, fill_size, WAITING_DNS_UP, stamped );
678 
679  /* get_address of server from name_server */
680 
681  if( locate_service(servp) <= 0)
682  {
683 /*
684  service_tmout( servp->serv_id );
685 */
686  dtq_start_timer( 0, service_tmout, servp->serv_id);
687  }
688  ENABLE_AST
689  }
690  return((unsigned) servp->serv_id);
691 }
692 
693 
694 int dic_cmnd_service( char *serv_name, void *serv_address, int serv_size )
695 {
696  int ret;
697 
698  ret = request_command( serv_name, serv_address, serv_size,
699  0, 0, 0 );
700 
701  return(ret ? 1 : 0);
702 
703 }
704 
705 int dic_cmnd_service_stamped( char *serv_name, void *serv_address, int serv_size )
706 {
707  int ret;
708 
709  ret = request_command( serv_name, serv_address, serv_size,
710  0, 0, 1 );
711 
712  return(ret ? 1 : 0);
713 
714 }
715 
716 int dic_cmnd_callback( char *serv_name, void *serv_address, int serv_size,
717  void (*usr_routine)(), dim_long tag )
718 {
719  int ret;
720 
721  ret = request_command( serv_name, serv_address, serv_size,
722  usr_routine, tag, 0 );
723  return(ret ? 1 : 0);
724 }
725 
726 int dic_cmnd_callback_stamped( char *serv_name, void *serv_address, int serv_size,
727  void (*usr_routine)(), dim_long tag )
728 {
729  int ret;
730 
731  ret = request_command( serv_name, serv_address, serv_size,
732  usr_routine, tag, 1 );
733  return(ret ? 1 : 0);
734 }
735 
736 int request_command(char *serv_name, void *serv_address, int serv_size,
737  void (*usr_routine)(), dim_long tag, int stamped)
738 {
739  int conn_id, ret;
740  register DIC_SERVICE *servp, *testp;
741  int *fillp;
742  int send_command();
743  int end_command();
744  void dim_init_threads(void);
745  int locate_service();
746 
747  if(!Threads_off)
748  {
749  dim_init_threads();
750  }
751  {
752  DISABLE_AST
753  /* create a timer queue for timeouts if not yet done */
754  if( !Dic_timer_q ) {
755  conn_arr_create( SRC_DIC );
756  Dic_timer_q = dtq_create();
757  }
758 
759  /* store_service */
760  if( !Cmnd_head ) {
761  Cmnd_head = (DIC_SERVICE *) malloc(sizeof(DIC_SERVICE) );
762  dll_init( (DLL *) Cmnd_head );
763  Cmnd_head->serv_id = 0;
764  }
765  if( (servp = locate_command(serv_name)) )
766  {
767  if(!(testp = locate_pending(serv_name)))
768  {
769  if( (conn_id = servp->conn_id) )
770  {
771  if(servp->fill_size > 0)
772  free( servp->fill_address );
773  fillp = serv_address;
774  if(serv_size > 0)
775  {
776  fillp = (int *)malloc((size_t)serv_size);
777  memcpy( (char *)fillp, (char *)serv_address, (size_t)serv_size );
778  }
779  servp->fill_address = fillp;
780  servp->fill_size = serv_size;
781 /*
782  servp->fill_address = (int *)serv_address;
783  servp->fill_size = serv_size;
784 */
785  servp->user_routine = usr_routine;
786  servp->tag = tag;
787  ret = send_command(conn_id, servp);
788  end_command(servp, ret);
789  ENABLE_AST
790  return(1);
791  }
792  }
793  }
794  servp = insert_service( COMMAND, 0,
795  serv_name, 0, 0, usr_routine, tag,
796  (int *)serv_address, serv_size,
797  WAITING_DNS_UP, stamped );
798  if( locate_service(servp) <= 0)
799  {
800 /*
801  service_tmout( servp->serv_id );
802 */
803  dtq_start_timer( 0, service_tmout, servp->serv_id);
804  }
805  ENABLE_AST
806  }
807  return(-1);
808 }
809 
810 DIC_SERVICE *insert_service( int type, int timeout, char *name, int *address, int size,
811  void (*routine)(), dim_long tag, int *fill_addr, int fill_size,
812  int pending, int stamped)
813 {
814  register DIC_SERVICE *newp;
815  int *fillp;
816  int service_id;
817  int tout;
818  float ftout;
819 
820  DISABLE_AST
821  newp = (DIC_SERVICE *) malloc(sizeof(DIC_SERVICE));
822  newp->pending = 0;
823  strncpy( newp->serv_name, name, (size_t)MAX_NAME );
824  newp->type = type;
825  newp->timeout = timeout;
826  newp->serv_address = address;
827  newp->serv_size = size;
828  newp->user_routine = routine;
829  newp->tag = tag;
830  fillp = fill_addr;
831  if(fill_size > 0)
832  {
833  fillp = (int *)malloc((size_t)fill_size);
834  memcpy( (char *) fillp, (char *) fill_addr, (size_t)fill_size );
835  }
836  newp->fill_address = fillp;
837  newp->fill_size = fill_size;
838  newp->conn_id = 0;
839  newp->format_data[0].par_bytes = 0;
840  newp->next = (DIC_SERVICE *)0;
841  service_id = id_get((void *)newp, SRC_DIC);
842  newp->serv_id = service_id;
843  if( !Service_pend_head )
844  {
845  Service_pend_head = (DIC_SERVICE *) malloc(sizeof(DIC_SERVICE));
846  dll_init( (DLL *) Service_pend_head );
847  Service_pend_head->serv_id = 0;
848  }
849  dll_insert_queue( (DLL *) Service_pend_head, (DLL *)newp );
850  newp->timer_ent = NULL;
851  if(type != MONIT_FIRST)
852  {
853  if( timeout )
854  {
855  tout = timeout;
856  if(type != ONCE_ONLY)
857  {
858  if(tout < 10)
859  tout = 10;
860  ftout = (float)tout * (float)1.5;
861  tout = (int)ftout;
862  }
863  newp->curr_timeout = tout;
864  newp->timer_ent = dtq_add_entry( Dic_timer_q,
865  newp->curr_timeout,
866  service_tmout, newp->serv_id );
867  }
868  }
869  newp->pending = pending;
870  newp->tmout_done = 0;
871  newp->stamped = stamped;
872  newp->time_stamp[0] = 0;
873  newp->time_stamp[1] = 0;
874  newp->quality = 0;
875  newp->def[0] = '\0';
876 #ifdef VxWorks
877  newp->tid = taskIdSelf();
878 #endif
879  ENABLE_AST
880  return(newp);
881 }
882 
883 
884 void modify_service( DIC_SERVICE *servp, int timeout, int *address, int size, void (*routine)(),
885  dim_long tag, int *fill_addr, int fill_size, int stamped)
886 {
887  int *fillp;
888 
889  if( servp->timer_ent )
890  {
891  dtq_rem_entry( Dic_timer_q, servp->timer_ent );
892  servp->timer_ent = 0;
893  }
894  servp->timeout = timeout;
895  servp->serv_address = address;
896  servp->serv_size = size;
897  servp->user_routine = routine;
898  servp->tag = tag;
899  if(servp->fill_size > 0)
900  free( servp->fill_address );
901  fillp = fill_addr;
902  if(fill_size > 0)
903  {
904  fillp = (int *)malloc((size_t)fill_size);
905  memcpy( (char *) fillp, (char *) fill_addr, (size_t)fill_size );
906  }
907  servp->fill_address = fillp;
908  servp->fill_size = fill_size;
909  servp->stamped = stamped;
910  if(timeout)
911  {
912  servp->curr_timeout = timeout;
913  servp->timer_ent = dtq_add_entry( Dic_timer_q,
914  servp->curr_timeout,
915  service_tmout, servp->serv_id );
916  }
917  else
918  servp->timer_ent = NULL;
919 }
920 
921 void dic_change_address( unsigned serv_id, void *serv_address, int serv_size)
922 {
923  register DIC_SERVICE *servp;
924 
925  DISABLE_AST
926  if( serv_id == 0 )
927  {
928  ENABLE_AST
929  return;
930  }
931  servp = (DIC_SERVICE *)id_get_ptr(serv_id, SRC_DIC);
932  servp->serv_address = (int *)serv_address;
933  servp->serv_size = serv_size;
934  ENABLE_AST
935 }
936 
937 int dic_get_quality( unsigned serv_id )
938 {
939  register DIC_SERVICE *servp;
940 
941  DISABLE_AST
942  if( serv_id == 0 )
943  {
944  if(Current_server)
945  servp = Current_server;
946  else
947  {
948 
949  ENABLE_AST
950  return(-1);
951  }
952  }
953  else
954  {
955  servp = (DIC_SERVICE *)id_get_ptr(serv_id, SRC_DIC);
956  }
957  ENABLE_AST
958  return(servp->quality);
959 }
960 
961 char *dic_get_format( unsigned serv_id )
962 {
963  register DIC_SERVICE *servp;
964 
965  DISABLE_AST
966  if( serv_id == 0 )
967  {
968  if(Current_server)
969  servp = Current_server;
970  else
971  {
972  ENABLE_AST
973  return((char *) 0);
974  }
975  }
976  else
977  {
978  servp = (DIC_SERVICE *)id_get_ptr(serv_id, SRC_DIC);
979  }
980  ENABLE_AST
981  return(servp->def);
982 }
983 
984 int dic_get_timestamp( unsigned serv_id, int *secs, int *milisecs )
985 {
986  register DIC_SERVICE *servp;
987 
988  DISABLE_AST
989  *secs = 0;
990  *milisecs = 0;
991  if( serv_id == 0 )
992  {
993  if(Current_server)
994  servp = Current_server;
995  else
996  {
997  ENABLE_AST
998  return(-1);
999  }
1000  }
1001  else
1002  {
1003  servp = (DIC_SERVICE *)id_get_ptr(serv_id, SRC_DIC);
1004  }
1005  ENABLE_AST
1006  if(servp->time_stamp[1])
1007  {
1008  *secs = servp->time_stamp[1];
1009  if(((unsigned)servp->time_stamp[0] & 0xFFFF0000) == 0xc0de0000)
1010  *milisecs = servp->time_stamp[0] & 0x0000FFFF;
1011  else
1012  *milisecs = servp->time_stamp[0];
1013  return(1);
1014  }
1015  else
1016  {
1017 /*
1018  *secs = 0;
1019  *milisecs = 0;
1020 */
1021  return(0);
1022  }
1023 }
1024 
1025 void dic_release_service( unsigned service_id )
1026 {
1027  register DIC_SERVICE *servp;
1028  register int conn_id, pending;
1029  static DIC_PACKET *dic_packet;
1030  static int packet_size = 0;
1031  DIC_DNS_PACKET dic_dns_packet;
1032  register DIC_DNS_PACKET *dic_dns_p = &dic_dns_packet;
1033  SERVICE_REQ *serv_reqp;
1034  int release_service();
1035 
1036  DISABLE_AST
1037  if( !packet_size ) {
1038  dic_packet = (DIC_PACKET *)malloc((size_t)DIC_HEADER);
1039  packet_size = DIC_HEADER;
1040  }
1041  if( service_id == 0 )
1042  {
1043  ENABLE_AST
1044  return;
1045  }
1046  servp = (DIC_SERVICE *)id_get_ptr(service_id, SRC_DIC);
1047  if( servp == 0 )
1048  {
1049  ENABLE_AST
1050  return;
1051  }
1052  if(servp->serv_id != (int)service_id)
1053  {
1054  ENABLE_AST
1055  return;
1056  }
1057  pending = servp->pending;
1058  switch( pending )
1059  {
1060  case NOT_PENDING :
1061  conn_id = servp->conn_id;
1062  strncpy(dic_packet->service_name, servp->serv_name, (size_t)MAX_NAME);
1063  dic_packet->type = htovl(DIM_DELETE);
1064  dic_packet->service_id = (int)htovl(service_id);
1065  dic_packet->size = htovl(DIC_HEADER);
1066  dna_write_nowait( conn_id, dic_packet, DIC_HEADER );
1067  release_service( servp );
1068  break;
1069  case WAITING_SERVER_UP :
1070  if( ( servp->type == COMMAND )||( servp->type == ONCE_ONLY ) )
1071  {
1072  servp->pending = DELETED;
1073  break;
1074  }
1075  if( Dns_dic_conn_id > 0) {
1076  dic_dns_p->size = htovl(sizeof(DIC_DNS_PACKET));
1077  dic_dns_p->src_type = htovl(SRC_DIC);
1078  serv_reqp = &dic_dns_p->service;
1079  strcpy( serv_reqp->service_name, servp->serv_name );
1080  serv_reqp->service_id = (int)htovl((unsigned)servp->serv_id | 0x80000000);
1081  dna_write( Dns_dic_conn_id, dic_dns_p,
1082  sizeof(DIC_DNS_PACKET) );
1083  }
1084  release_service( servp );
1085  break;
1086  case WAITING_CMND_ANSWER :
1087  case WAITING_DNS_UP :
1088  release_service( servp );
1089  break;
1090  case WAITING_DNS_ANSWER :
1091  servp->pending = DELETED;
1092  break;
1093  }
1094  ENABLE_AST
1095 }
1096 
1097 
1098 int release_service( DIC_SERVICE *servicep )
1099 {
1100  register DIC_SERVICE *servp;
1101  register int conn_id = 0;
1102  register int found = 0;
1103  register DIC_CONNECTION *dic_connp;
1104  char name[MAX_NAME], *ptr;
1105  int id;
1106 
1107  id = servicep->serv_id;
1108  servicep->serv_id = 0;
1109  conn_id = servicep->conn_id;
1110  dic_connp = &Dic_conns[conn_id] ;
1111  dll_remove( (DLL *) servicep );
1112  if( servicep->timer_ent )
1113  {
1114  dtq_rem_entry( Dic_timer_q, servicep->timer_ent );
1115  }
1116 /*
1117  if(servicep->type != COMMAND)
1118 */
1119  if(servicep->fill_size > 0)
1120  free( servicep->fill_address );
1121  if(strstr(servicep->serv_name,"/RpcOut"))
1122  {
1123  strcpy(name, servicep->serv_name);
1124  }
1125  else
1126  name[0] = '\0';
1127  free( servicep );
1128  if( conn_id && dic_connp->service_head )
1129  {
1130  if( dll_empty((DLL *)dic_connp->service_head) )
1131  {
1132  if( (servp = (DIC_SERVICE *) Cmnd_head) )
1133  {
1134  while( (servp = (DIC_SERVICE *) dll_get_next(
1135  (DLL *) Cmnd_head,
1136  (DLL *) servp)) )
1137  {
1138  if( servp->conn_id == conn_id)
1139  found = 1;
1140  }
1141  }
1142  if( !found)
1143  {
1144  if(Debug_on)
1145  {
1146  dim_print_date_time();
1147  printf("Conn %d, Server %s on node %s released\n",
1148  conn_id, dic_connp->task_name, dic_connp->node_name);
1149  fflush(stdout);
1150  }
1151  release_conn( conn_id );
1152  }
1153  }
1154  }
1155  if(name[0])
1156  {
1157  ptr = strstr(name,"/RpcOut");
1158  strcpy(ptr + 4, "In");
1159  if( (servp = locate_command(name)) )
1160  release_service(servp);
1161  }
1162  id_free(id, SRC_DIC);
1163  return(1);
1164 }
1165 
1166 
1167 int locate_service( DIC_SERVICE *servp )
1168 {
1169  extern int open_dns(dim_long, void (*)(), void (*)(), int, int, int);
1170 
1171  if(!strcmp(servp->serv_name,"DIS_DNS/SERVER_INFO"))
1172  {
1173  Tmout_min = DID_DNS_TMOUT_MIN;
1174  Tmout_max = DID_DNS_TMOUT_MAX;
1175  }
1176  if(Tmout_min == 0)
1177  {
1178  Tmout_min = DIC_DNS_TMOUT_MIN;
1179  Tmout_max = DIC_DNS_TMOUT_MAX;
1180  }
1181  if( !Dns_dic_conn_id )
1182  {
1183  DISABLE_AST;
1184  Dns_dic_conn_id = open_dns( 0, recv_dns_dic_rout, error_handler,
1185  Tmout_min,
1186  Tmout_max,
1187  SRC_DIC);
1188  if(Dns_dic_conn_id == -2)
1189  error_handler(0, DIM_FATAL, DIMDNSUNDEF, "DIM_DNS_NODE undefined");
1190  ENABLE_AST;
1191  }
1192  if( Dns_dic_conn_id > 0)
1193  {
1194  DISABLE_AST;
1195  request_dns_info(servp->prev->serv_id);
1196  ENABLE_AST;
1197  }
1198 
1199  return(Dns_dic_conn_id);
1200 }
1201 
1202 DIC_SERVICE *locate_command( char *serv_name )
1203 {
1204  register DIC_SERVICE *servp;
1205 
1206  if(!Cmnd_head)
1207  return((DIC_SERVICE *)0);
1208  if( (servp = (DIC_SERVICE *) dll_search( (DLL *) Cmnd_head, serv_name,
1209  (int)strlen(serv_name)+1)) )
1210  return(servp);
1211  return((DIC_SERVICE *)0);
1212 }
1213 
1214 DIC_SERVICE *locate_pending( char *serv_name )
1215 {
1216  register DIC_SERVICE *servp;
1217 
1218  if(!Service_pend_head)
1219  return((DIC_SERVICE *)0);
1220  if( (servp = (DIC_SERVICE *) dll_search( (DLL *) Service_pend_head, serv_name,
1221  (int)strlen(serv_name)+1)) )
1222  return(servp);
1223  return((DIC_SERVICE *)0);
1224 }
1225 
1226 DIC_BAD_CONNECTION *locate_bad(char *node, char *task, int port)
1227 {
1228  DIC_BAD_CONNECTION *bad_connp;
1229 
1230  if(!Bad_connection_head)
1231  return((DIC_BAD_CONNECTION *)0);
1232  bad_connp = Bad_connection_head;
1233  while( (bad_connp = (DIC_BAD_CONNECTION *) dll_get_next(
1234  (DLL *) Bad_connection_head,
1235  (DLL *) bad_connp)) )
1236  {
1237  if((!strcmp(bad_connp->conn.node_name, node)) &&
1238  (!strcmp(bad_connp->conn.task_name, task)) &&
1239  (bad_connp->conn.port == port) )
1240  return(bad_connp);
1241  }
1242  return((DIC_BAD_CONNECTION *)0);
1243 }
1244 
1245 static void request_dns_info(int id)
1246 {
1247  DIC_SERVICE *servp, *ptr;
1248  int n_pend = 0;
1249  int request_dns_single_info();
1250  extern int open_dns();
1251 
1252  DISABLE_AST
1253  if( Dns_dic_conn_id <= 0)
1254  {
1255  Dns_dic_conn_id = open_dns( 0, recv_dns_dic_rout, error_handler,
1256  Tmout_min,
1257  Tmout_max,
1258  SRC_DIC);
1259  if(Dns_dic_conn_id == -2)
1260  error_handler(0, DIM_FATAL, DIMDNSUNDEF, "DIM_DNS_NODE undefined");
1261  }
1262  if( Dns_dic_conn_id > 0)
1263  {
1264  servp = Service_pend_head;
1265  if(id > 0)
1266  {
1267  ptr = (DIC_SERVICE *)id_get_ptr(id, SRC_DIC);
1268  if(ptr)
1269  {
1270  if((ptr->serv_id == id) && (ptr->pending != NOT_PENDING))
1271  servp = ptr;
1272  }
1273  }
1274 
1275  while( (servp = (DIC_SERVICE *) dll_get_next(
1276  (DLL *) Service_pend_head,
1277  (DLL *) servp)) )
1278  {
1279  if( servp->pending == WAITING_DNS_UP)
1280  {
1281  if(!request_dns_single_info( servp ))
1282  {
1283  ENABLE_AST
1284  return;
1285  }
1286  n_pend++;
1287  }
1288  if(n_pend == 1000)
1289  {
1290  dtq_start_timer( 0, request_dns_info, servp->serv_id);
1291  ENABLE_AST
1292  return;
1293  }
1294  }
1295  }
1296  else
1297  {
1298  servp = Service_pend_head;
1299  while( (servp = (DIC_SERVICE *) dll_get_next(
1300  (DLL *) Service_pend_head,
1301  (DLL *) servp)) )
1302  {
1303  if( servp->pending == WAITING_DNS_UP)
1304  {
1305  if(( servp->type != COMMAND )&&( servp->type != ONCE_ONLY ))
1306  service_tmout( servp->serv_id );
1307  }
1308  }
1309  }
1310  ENABLE_AST
1311 }
1312 
1313 
1314 int request_dns_single_info( DIC_SERVICE *servp )
1315 {
1316  static DIC_DNS_PACKET Dic_dns_packet;
1317  static SERVICE_REQ *serv_reqp;
1318  int ret = 1;
1319 
1320  if( Dns_dic_conn_id > 0)
1321  {
1322  if(Debug_on)
1323  {
1324  dim_print_date_time();
1325  printf("Requesting DNS Info for %s, id %d\n",
1326  servp->serv_name, servp->serv_id);
1327  }
1328 
1329  Dic_dns_packet.src_type = htovl(SRC_DIC);
1330  serv_reqp = &Dic_dns_packet.service;
1331  strcpy( serv_reqp->service_name, servp->serv_name );
1332  serv_reqp->service_id = htovl(servp->serv_id);
1333  servp->pending = WAITING_DNS_ANSWER;
1334  Dic_dns_packet.size = htovl(sizeof(DIC_DNS_PACKET));
1335  if(!dna_write( Dns_dic_conn_id, &Dic_dns_packet,
1336  sizeof(DIC_DNS_PACKET) ) )
1337  {
1338  ret = 0;
1339  }
1340 
1341  }
1342  return ret;
1343 }
1344 
1345 
1346 static int handle_dns_info( DNS_DIC_PACKET *packet )
1347 {
1348  int conn_id, service_id;
1349  DIC_SERVICE *servp;
1350  char *node_name, *task_name;
1351  char node_info[MAX_NODE_NAME+4];
1352  int i, port, protocol, format, pid;
1353  register DIC_CONNECTION *dic_connp ;
1354  DIC_DNS_PACKET dic_dns_packet;
1355  register DIC_DNS_PACKET *dic_dns_p = &dic_dns_packet;
1356  SERVICE_REQ *serv_reqp;
1357  DIC_BAD_CONNECTION *bad_connp;
1358  int retrying = 0;
1359  int tmout;
1360  int send_service_command();
1361  int find_connection();
1362  void move_to_bad_service();
1363  void retry_bad_connection();
1364 
1365  service_id = vtohl(packet->service_id);
1366 
1367  servp = (DIC_SERVICE *)id_get_ptr(service_id, SRC_DIC);
1368  if(!servp)
1369  return(0);
1370  if(servp->serv_id != service_id)
1371  return(0);
1372  if(Debug_on)
1373  {
1374  dim_print_date_time();
1375  printf("Receiving DNS Info for service %s, id %d\n",servp->serv_name,
1376  vtohl(packet->service_id));
1377  }
1378  node_name = packet->node_name;
1379  if(node_name[0] == (char)0xFF)
1380  {
1381  error_handler(0, DIM_FATAL, DIMDNSREFUS, "DIM_DNS refuses connection");
1382  return(0);
1383  }
1384 
1385  task_name = packet->task_name;
1386  strcpy(node_info,node_name);
1387  for(i = 0; i < 4; i ++)
1388  node_info[(int)strlen(node_name)+i+1] = packet->node_addr[i];
1389  port = vtohl(packet->port);
1390  pid = vtohl(packet->pid);
1391  protocol = vtohl(packet->protocol);
1392  format = vtohl(packet->format);
1393 
1394  if( Dns_dic_timr )
1395  dtq_clear_entry( Dns_dic_timr );
1396  if( servp->pending == DELETED ) {
1397  if( Dns_dic_conn_id > 0) {
1398  dic_dns_p->size = htovl(sizeof(DIC_DNS_PACKET));
1399  dic_dns_p->src_type = htovl(SRC_DIC);
1400  serv_reqp = &dic_dns_p->service;
1401  strcpy( serv_reqp->service_name, servp->serv_name );
1402  serv_reqp->service_id = (int)htovl((unsigned)servp->serv_id | 0x80000000);
1403  dna_write( Dns_dic_conn_id, dic_dns_p,
1404  sizeof(DIC_DNS_PACKET) );
1405  }
1406  release_service( servp );
1407  return(0);
1408  }
1409  if( !node_name[0] )
1410  {
1411  servp->pending = WAITING_SERVER_UP;
1412  service_tmout( servp->serv_id );
1413  if( servp->pending == DELETED )
1414  {
1415  if( Dns_dic_conn_id > 0)
1416  {
1417  dic_dns_p->size = htovl(sizeof(DIC_DNS_PACKET));
1418  dic_dns_p->src_type = htovl(SRC_DIC);
1419  serv_reqp = &dic_dns_p->service;
1420  strcpy( serv_reqp->service_name, servp->serv_name );
1421  serv_reqp->service_id = (int)htovl((unsigned)servp->serv_id | 0x80000000);
1422  dna_write( Dns_dic_conn_id, dic_dns_p,
1423  sizeof(DIC_DNS_PACKET) );
1424  }
1425  release_service( servp );
1426  }
1427  return(0);
1428  }
1429 #ifdef OSK
1430  {
1431  register char *ptr;
1432 
1433  if(strncmp(node_name,"fidel",5))
1434  {
1435  for(ptr = node_name; *ptr; ptr++)
1436  {
1437  if(*ptr == '.')
1438  {
1439  *ptr = '\0';
1440  break;
1441  }
1442  }
1443  }
1444  }
1445 #endif
1446  if( !(conn_id = find_connection(node_name, task_name, port)) )
1447  {
1448  bad_connp = locate_bad(node_name, task_name, port);
1449  if(bad_connp)
1450  retrying = bad_connp->retrying;
1451  if((!bad_connp) || (retrying))
1452  {
1453  if( (conn_id = dna_open_client(node_info, task_name, port,
1454  protocol, recv_rout, error_handler, SRC_DIC)) )
1455  {
1456 /*
1457 #ifndef VxWorks
1458  if(format & MY_OS9)
1459  {
1460  dna_set_test_write(conn_id, TEST_TIME_OSK);
1461  format &= 0xfffff7ff;
1462  }
1463  else
1464  {
1465  dna_set_test_write(conn_id, TEST_TIME_VMS);
1466  }
1467 #endif
1468 */
1469  dna_set_test_write(conn_id, dim_get_keepalive_timeout());
1470  dic_connp = &Dic_conns[conn_id];
1471  strncpy( dic_connp->node_name, node_name,
1472  (size_t)MAX_NODE_NAME);
1473  strncpy( dic_connp->task_name, task_name,
1474  (size_t)MAX_TASK_NAME);
1475  dic_connp->port = port;
1476  dic_connp->pid = pid;
1477  if(Debug_on)
1478  {
1479  dim_print_date_time();
1480  printf("Conn %d, Server %s on node %s Connecting\n",
1481  conn_id, dic_connp->task_name, dic_connp->node_name);
1482  fflush(stdout);
1483  }
1484 
1485  dic_connp->service_head =
1486  malloc(sizeof(DIC_SERVICE));
1487  dll_init( (DLL *) dic_connp->service_head);
1488  ((DIC_SERVICE *)(dic_connp->service_head))->serv_id = 0;
1489  if(retrying)
1490  {
1491  dll_remove((DLL *)bad_connp->conn.service_head);
1492  free(bad_connp->conn.service_head);
1493  dll_remove((DLL *)bad_connp);
1494  free(bad_connp);
1495  }
1496  }
1497  else
1498  {
1499  if(!retrying)
1500  {
1501  if( !Bad_connection_head )
1502  {
1503  Bad_connection_head = (DIC_BAD_CONNECTION *) malloc(sizeof(DIC_BAD_CONNECTION));
1504  dll_init( (DLL *) Bad_connection_head );
1505  Bad_connection_head->conn.service_head = 0;
1506  }
1507  bad_connp = (DIC_BAD_CONNECTION *) malloc(sizeof(DIC_BAD_CONNECTION));
1508  bad_connp->n_retries = 0;
1509  bad_connp->conn.service_head = malloc(sizeof(DIC_SERVICE));
1510  dll_init( (DLL *) bad_connp->conn.service_head);
1511 
1512  dll_insert_queue( (DLL *) Bad_connection_head, (DLL *) bad_connp );
1513  if(Debug_on)
1514  {
1515  dim_print_date_time();
1516  printf("Failed connecting to Server %s on node %s port %d\n",
1517  task_name, node_name, port);
1518  fflush(stdout);
1519  }
1520  service_tmout( servp->serv_id );
1521  }
1522  bad_connp->n_retries++;
1523  bad_connp->retrying = 0;
1524  strncpy( bad_connp->conn.node_name, node_name, (size_t)MAX_NODE_NAME);
1525  strncpy( bad_connp->conn.task_name, task_name, (size_t)MAX_TASK_NAME);
1526  bad_connp->conn.port = port;
1527  tmout = BAD_CONN_TIMEOUT * (bad_connp->n_retries - 1);
1528  if(tmout > 120)
1529  tmout = 120;
1530 /* Can not be 0, the callback of dtq_start_timer(0) is not protected */
1531  if(tmout == 0)
1532  tmout = 1;
1533  dtq_start_timer(tmout, retry_bad_connection, (dim_long)bad_connp);
1534  if(( servp->type == COMMAND )||( servp->type == ONCE_ONLY ))
1535  return(0);
1536  move_to_bad_service(servp, bad_connp);
1537 /*
1538  ((DIC_SERVICE *)(dic_connp->service_head))->serv_id = 0;
1539 
1540  servp = Service_pend_head;
1541  while( (servp = (DIC_SERVICE *) dll_get_next(
1542  (DLL *) Service_pend_head,
1543  (DLL *) servp)) )
1544  {
1545  if( (servp->pending == WAITING_DNS_ANSWER) ||
1546  (servp->pending == WAITING_SERVER_UP))
1547  servp->pending = WAITING_DNS_UP;
1548  }
1549  dna_close( Dns_dic_conn_id );
1550  Dns_dic_conn_id = 0;
1551  request_dns_info(0);
1552 */
1553  return(0);
1554  }
1555  }
1556  else
1557  {
1558  if(!retrying)
1559  service_tmout( servp->serv_id );
1560  if(( servp->type == COMMAND )||( servp->type == ONCE_ONLY ))
1561  return(0);
1562  move_to_bad_service(servp, bad_connp);
1563  return(0);
1564  }
1565  }
1566  strcpy(servp->def, packet->service_def);
1567  get_format_data(format, servp->format_data, servp->def);
1568  servp->format = format;
1569  servp->conn_id = conn_id;
1570 
1571  send_service_command( servp );
1572 /*
1573  if( ret == 1)
1574  {
1575  if(servp->pending != WAITING_CMND_ANSWER)
1576  servp->pending = NOT_PENDING;
1577  servp->tmout_done = 0;
1578  }
1579 */
1580  return(1);
1581 }
1582 
1583 void retry_bad_connection(DIC_BAD_CONNECTION *bad_connp)
1584 {
1585 DIC_SERVICE *servp, *auxp;
1586 int found = 0;
1587 void move_to_notok_service();
1588 
1589  if(!bad_connp)
1590  return;
1591  servp = (DIC_SERVICE *)bad_connp->conn.service_head;
1592  while( (servp = (DIC_SERVICE *) dll_get_next(
1593  (DLL *) bad_connp->conn.service_head,
1594  (DLL *) servp)) )
1595  {
1596 /*
1597  servp->pending = WAITING_DNS_UP;
1598  servp->conn_id = 0;
1599 */
1600  auxp = servp->prev;
1601  move_to_notok_service( servp );
1602  servp = auxp;
1603  found = 1;
1604  }
1605  bad_connp->retrying = 1;
1606  if(found)
1607  request_dns_info(0);
1608 }
1609 
1610 void move_to_ok_service( DIC_SERVICE *servp, int conn_id )
1611 {
1612  if(Dic_conns[conn_id].service_head)
1613  {
1614  DISABLE_AST
1615 /*
1616 printf("move_to_ok %s\n",servp->serv_name);
1617 */
1618  servp->pending = NOT_PENDING;
1619  servp->tmout_done = 0;
1620  dll_remove( (DLL *) servp );
1621  dll_insert_queue( (DLL *) Dic_conns[conn_id].service_head,
1622  (DLL *) servp );
1623  ENABLE_AST
1624  }
1625 }
1626 
1627 void move_to_bad_service( DIC_SERVICE *servp, DIC_BAD_CONNECTION *bad_connp)
1628 {
1629  DISABLE_AST
1630 /*
1631 printf("move_to_bad %s\n",servp->serv_name);
1632 */
1633  servp->pending = WAITING_DNS_UP;
1634  dll_remove( (DLL *) servp );
1635  dll_insert_queue( (DLL *) bad_connp->conn.service_head, (DLL *) servp );
1636  ENABLE_AST
1637 }
1638 
1639 void move_to_cmnd_service( DIC_SERVICE *servp )
1640 {
1641 /*
1642  if(servp->pending != WAITING_CMND_ANSWER)
1643 */
1644  DISABLE_AST
1645 /*
1646 printf("move_to_cmnd %s\n",servp->serv_name);
1647 */
1648  servp->pending = NOT_PENDING;
1649  servp->tmout_done = 0;
1650  dll_remove( (DLL *) servp );
1651  dll_insert_queue( (DLL *) Cmnd_head, (DLL *) servp );
1652  ENABLE_AST
1653 }
1654 
1655 void move_to_notok_service(DIC_SERVICE *servp )
1656 {
1657  DISABLE_AST
1658 /*
1659 printf("move_to_notok %s\n",servp->serv_name);
1660 */
1661  servp->pending = WAITING_DNS_UP;
1662  servp->conn_id = 0;
1663  dll_remove( (DLL *) servp );
1664  dll_insert_queue( (DLL *) Service_pend_head, (DLL *) servp );
1665  ENABLE_AST
1666 }
1667 
1668 static void get_format_data(int format, FORMAT_STR *format_data, char *def)
1669 {
1670  register FORMAT_STR *formatp = format_data;
1671  register char code, last_code = 0;
1672  int num;
1673  char *ptr = def;
1674 
1675  if(format){}
1676  while(*ptr)
1677  {
1678  switch(*ptr)
1679  {
1680  case 'i':
1681  case 'I':
1682  case 'l':
1683  case 'L':
1684  *ptr = 'I';
1685  break;
1686  case 'x':
1687  case 'X':
1688  *ptr = 'X';
1689  break;
1690  case 's':
1691  case 'S':
1692  *ptr = 'S';
1693  break;
1694  case 'f':
1695  case 'F':
1696  *ptr = 'F';
1697  break;
1698  case 'd':
1699  case 'D':
1700  *ptr = 'D';
1701  break;
1702  case 'c':
1703  case 'C':
1704  *ptr = 'C';
1705  break;
1706  }
1707  ptr++;
1708  }
1709  code = *def;
1710  while(*def)
1711  {
1712  if(code != last_code)
1713  {
1714  formatp->par_num = 0;
1715  formatp->flags = 0;
1716  switch(code)
1717  {
1718  case 'i':
1719  case 'I':
1720  case 'l':
1721  case 'L':
1722  formatp->par_bytes = SIZEOF_LONG;
1723  formatp->flags |= SWAPL;
1724  break;
1725  case 'x':
1726  case 'X':
1727  formatp->par_bytes = SIZEOF_DOUBLE;
1728  formatp->flags |= SWAPD;
1729  break;
1730  case 's':
1731  case 'S':
1732  formatp->par_bytes = SIZEOF_SHORT;
1733  formatp->flags |= SWAPS;
1734  break;
1735  case 'f':
1736  case 'F':
1737  formatp->par_bytes = SIZEOF_LONG;
1738  formatp->flags |= SWAPL;
1739 #ifdef vms
1740 /*
1741  if((format & 0xF0) != (MY_FORMAT & 0xF0))
1742 */
1743  formatp->flags |= (format & 0xF0);
1744  formatp->flags |= IT_IS_FLOAT;
1745 #endif
1746  break;
1747  case 'd':
1748  case 'D':
1749  formatp->par_bytes = SIZEOF_DOUBLE;
1750  formatp->flags |= SWAPD;
1751 #ifdef vms
1752 /*
1753  if((format & 0xF0) != (MY_FORMAT & 0xF0))
1754 */
1755  formatp->flags |= (format & 0xF0);
1756  formatp->flags |= IT_IS_FLOAT;
1757 #endif
1758  break;
1759  case 'c':
1760  case 'C':
1761  case 'b':
1762  case 'B':
1763  case 'v':
1764  case 'V':
1765  formatp->par_bytes = SIZEOF_CHAR;
1766  formatp->flags |= NOSWAP;
1767  break;
1768  }
1769  }
1770  def++;
1771  if(*def != ':')
1772  {
1773 /* tested by the server
1774  if(*def)
1775  {
1776  printf("Bad service definition parsing\n");
1777  fflush(stdout);
1778  }
1779  else
1780 */
1781  formatp->par_num = 0;
1782  }
1783  else
1784  {
1785  def++;
1786  sscanf(def,"%d",&num);
1787  formatp->par_num += num;
1788  while((*def != ';') && (*def != '\0'))
1789  def++;
1790  if(*def)
1791  def++;
1792  }
1793  last_code = code;
1794  code = *def;
1795  if(code != last_code)
1796  formatp++;
1797  }
1798  formatp->par_bytes = 0;
1799 /*
1800  if((format & 0xF) == (MY_FORMAT & 0xF))
1801  {
1802  for(i = 0, formatp = format_data; i<index;i++, formatp++)
1803  formatp->flags &= 0xF0;
1804  }
1805 */
1806 }
1807 
1808 int end_command(DIC_SERVICE *servp, int ret)
1809 {
1810  DIC_SERVICE *aux_servp;
1811  DIC_CONNECTION *dic_connp;
1812 
1813  DISABLE_AST
1814  dic_connp = &Dic_conns[servp->conn_id];
1815  if(servp->pending != WAITING_CMND_ANSWER)
1816  {
1817  if((!ret) || (!dic_connp->service_head))
1818  {
1819  servp->pending = WAITING_DNS_UP;
1820  dic_release_service( (unsigned)servp->serv_id );
1821  }
1822  else
1823  {
1824  aux_servp = locate_command(servp->serv_name);
1825  if( !aux_servp )
1826  {
1827  move_to_cmnd_service( servp );
1828  }
1829  else
1830  {
1831  if(aux_servp != servp)
1832  {
1833  servp->pending = WAITING_DNS_UP;
1834  dic_release_service( (unsigned)servp->serv_id );
1835  }
1836  }
1837  }
1838  }
1839  ENABLE_AST
1840  return(ret);
1841 }
1842 
1843 int send_service_command(DIC_SERVICE *servp)
1844 {
1845  int ret = 1;
1846  int conn_id;
1847  int send_command();
1848  int send_service();
1849 
1850  conn_id = servp->conn_id;
1851  if( servp->type == COMMAND )
1852  {
1853  ret = send_command(conn_id, servp);
1854  end_command(servp, ret);
1855  }
1856  else
1857  {
1858  if( send_service(conn_id, servp))
1859  {
1860  if( servp->type == ONCE_ONLY )
1861  {
1862  if( !locate_command(servp->serv_name) )
1863  {
1864  move_to_cmnd_service( servp );
1865  }
1866  }
1867  else
1868  move_to_ok_service( servp, conn_id );
1869  }
1870  else
1871  {
1872  if( servp->type == ONCE_ONLY )
1873  {
1874  servp->pending = WAITING_DNS_UP;
1875  dic_release_service( (unsigned)servp->serv_id );
1876  }
1877  else
1878  {
1879  servp->pending = WAITING_DNS_UP;
1880  servp->conn_id = 0;
1881 /*
1882  release_conn(conn_id);
1883 */
1884  request_dns_info(0);
1885  }
1886  }
1887  }
1888  return(ret);
1889 }
1890 
1891 int send_service(int conn_id, DIC_SERVICE *servp)
1892 {
1893  static DIC_PACKET *dic_packet;
1894  static int serv_packet_size = 0;
1895  int type, ret;
1896 
1897  if( !serv_packet_size ) {
1898  dic_packet = (DIC_PACKET *)malloc((size_t)DIC_HEADER);
1899  serv_packet_size = DIC_HEADER;
1900  }
1901 
1902  strncpy( dic_packet->service_name, servp->serv_name, (size_t)MAX_NAME );
1903  type = servp->type;
1904  if(servp->stamped)
1905  type |= STAMPED;
1906  dic_packet->type = htovl(type);
1907  dic_packet->timeout = htovl(servp->timeout);
1908  dic_packet->service_id = htovl(servp->serv_id);
1909  dic_packet->format = htovl(MY_FORMAT);
1910  dic_packet->size = htovl(DIC_HEADER);
1911  ret = dna_write_nowait(conn_id, dic_packet, DIC_HEADER);
1912  if(!ret)
1913  {
1914  dim_print_date_time();
1915  printf(" Client Sending Service Request: Couldn't write to Conn %3d : Server %s@%s service %s\n",
1916  conn_id, Net_conns[conn_id].task, Net_conns[conn_id].node, servp->serv_name);
1917  fflush(stdout);
1918  }
1919  return(ret);
1920 }
1921 
1922 typedef struct
1923 {
1924  int ret_code;
1925  int serv_id;
1926 } CMNDCB_ITEM;
1927 
1928 void do_cmnd_callback(CMNDCB_ITEM *itemp)
1929 {
1930 
1931  DIC_SERVICE *servp;
1932  int ret, serv_id;
1933 /*
1934  itemp = (CMNDCB_ITEM *)id_get_ptr(id, SRC_DIC);
1935 */
1936  serv_id = itemp->serv_id;
1937  ret = itemp->ret_code;
1938  servp = (DIC_SERVICE *)id_get_ptr(serv_id, SRC_DIC);
1939  if(servp)
1940  {
1941  if(servp->serv_id == serv_id)
1942  {
1943  Curr_conn_id = servp->conn_id;
1944  (servp->user_routine)( &servp->tag, &ret );
1945  servp->pending = NOT_PENDING;
1946  end_command(servp, ret);
1947  Curr_conn_id = 0;
1948  }
1949  }
1950 /*
1951  id_free(id, SRC_DIC);
1952 */
1953  free(itemp);
1954 }
1955 
1956 int send_command(int conn_id, DIC_SERVICE *servp)
1957 {
1958  static DIC_PACKET *dic_packet;
1959  static int cmnd_packet_size = 0;
1960  register int size;
1961  int ret;
1962  CMNDCB_ITEM *itemp;
1963 
1964  size = servp->fill_size;
1965 
1966  if(size < 0)
1967  return(1);
1968 
1969  if( !cmnd_packet_size ) {
1970  dic_packet = (DIC_PACKET *)malloc((size_t)(DIC_HEADER + size));
1971  cmnd_packet_size = DIC_HEADER + size;
1972  }
1973  else
1974  {
1975  if( DIC_HEADER + size > cmnd_packet_size ) {
1976  free( dic_packet );
1977  dic_packet = (DIC_PACKET *)malloc((size_t)(DIC_HEADER + size));
1978  cmnd_packet_size = DIC_HEADER + size;
1979  }
1980  }
1981 
1982  strncpy(dic_packet->service_name, servp->serv_name, (size_t)MAX_NAME);
1983  dic_packet->type = htovl(COMMAND);
1984  dic_packet->timeout = htovl(0);
1985  dic_packet->format = htovl(MY_FORMAT);
1986 
1987  dic_packet->service_id = /*id_get((void *)servp)*/servp->serv_id;
1988 
1989  size = copy_swap_buffer_out(servp->format, servp->format_data,
1990  dic_packet->buffer, servp->fill_address,
1991  size);
1992  dic_packet->size = htovl( size + DIC_HEADER);
1993  if( servp->user_routine )
1994  {
1995  servp->pending = WAITING_CMND_ANSWER;
1996  ret = dna_write_nowait(conn_id, dic_packet, DIC_HEADER + size);
1997  itemp = (CMNDCB_ITEM *)malloc(sizeof(CMNDCB_ITEM));
1998  itemp->serv_id = servp->serv_id;
1999  itemp->ret_code = ret;
2000 /*
2001  id = id_get((void *)itemp, SRC_DIC);
2002 */
2003  dtq_start_timer(0, do_cmnd_callback, (dim_long)itemp);
2004 /*
2005  (servp->user_routine)( &servp->tag, &ret );
2006 */
2007  }
2008  else
2009  {
2010  ret = dna_write_nowait(conn_id, dic_packet, DIC_HEADER + size);
2011  }
2012 /*
2013  if(!ret)
2014  {
2015  servp->pending = WAITING_DNS_UP;
2016  dic_release_service( (unsigned)servp->serv_id );
2017  }
2018 */
2019  /*
2020  ret = dna_write_nowait(conn_id, dic_packet, DIC_HEADER + size);
2021  if(!ret)
2022  {
2023  servp->pending = WAITING_DNS_UP;
2024  dic_release_service( (unsigned)servp->serv_id );
2025  }
2026  else
2027  {
2028  dim_usleep(5000);
2029  if( servp->user_routine )
2030  (servp->user_routine)( &servp->tag, &ret );
2031  }
2032 */
2033  if(!ret)
2034  {
2035  dim_print_date_time();
2036  printf(" Client Sending Command: Couldn't write to Conn %3d : Server %s@%s\n",conn_id,
2037  Net_conns[conn_id].task, Net_conns[conn_id].node);
2038  fflush(stdout);
2039  }
2040  return(ret);
2041 }
2042 
2043 int find_connection(char *node, char *task, int port)
2044 {
2045  register int i;
2046  register DIC_CONNECTION *dic_connp;
2047 
2048  if(task){}
2049  for( i=0, dic_connp = Dic_conns; i<Curr_N_Conns; i++, dic_connp++ )
2050  {
2051 /*
2052  if((!strcmp(dic_connp->task_name, task))
2053  &&(!strcmp(dic_connp->node_name, node)))
2054 */
2055  if((!strcmp(dic_connp->node_name, node))
2056  && (dic_connp->port == port))
2057  return(i);
2058  }
2059  return(0);
2060 }
2061 
2062 int dic_get_id(char *name)
2063 {
2064  extern int get_proc_name(char *name);
2065 
2066  get_proc_name(name);
2067  strcat(name,"@");
2068  get_node_name(&name[(int)strlen(name)]);
2069  return(1);
2070 }
2071 
2072 #ifdef VxWorks
2073 void dic_destroy(int tid)
2074 {
2075  register int i;
2076  register DIC_CONNECTION *dic_connp;
2077  register DIC_SERVICE *servp, *auxp;
2078  int found = 0;
2079 
2080  if(!Dic_conns)
2081  return;
2082  for( i=0, dic_connp = Dic_conns; i<Curr_N_Conns; i++, dic_connp++ )
2083  {
2084  if(servp = (DIC_SERVICE *) dic_connp->service_head)
2085  {
2086  while( servp = (DIC_SERVICE *) dll_get_next(
2087  (DLL *) dic_connp->service_head,
2088  (DLL *) servp) )
2089  {
2090  if( servp->tid == tid )
2091  {
2092  auxp = servp->prev;
2093  dic_release_service( (unsigned)servp->serv_id );
2094  servp = auxp;
2095  if(!dic_connp->service_head)
2096  break;
2097  }
2098  else
2099  found = 1;
2100  }
2101  }
2102  }
2103  if(!found)
2104  {
2105  if(Dns_dic_conn_id > 0)
2106  {
2107  dna_close( Dns_dic_conn_id );
2108  Dns_dic_conn_id = 0;
2109  }
2110  }
2111 }
2112 
2113 void DIMDestroy(int tid)
2114 {
2115  dis_destroy(tid);
2116  dic_destroy(tid);
2117 }
2118 
2119 #endif
2120 
2121 static void release_conn(int conn_id)
2122 {
2123  register DIC_CONNECTION *dic_connp = &Dic_conns[conn_id];
2124 
2125  if(Debug_on)
2126  {
2127  dim_print_date_time();
2128  printf("Conn %d, Server %s on node %s completely released\n",
2129  conn_id, dic_connp->task_name, dic_connp->node_name);
2130  fflush(stdout);
2131  }
2132  dic_connp->task_name[0] = '\0';
2133  dic_connp->port = 0;
2134  if(dic_connp->service_head)
2135  {
2136  free((DIC_SERVICE *)dic_connp->service_head);
2137  dic_connp->service_head = (char *)0;
2138  }
2139  dna_close(conn_id);
2140 }
2141 
2142 void dic_close_dns()
2143 {
2144  register DIC_SERVICE *servp, *auxp;
2145 
2146  if(Dns_dic_conn_id > 0)
2147  {
2148  if( (servp = (DIC_SERVICE *) Cmnd_head) )
2149  {
2150  while( (servp = (DIC_SERVICE *) dll_get_next(
2151  (DLL *) Cmnd_head,
2152  (DLL *) servp)) )
2153  {
2154 #ifdef DEBUG
2155  printf("\t%s was in the Command list\n", servp->serv_name);
2156  printf("type = %d, pending = %d\n",servp->type, servp->pending);
2157  fflush(stdout);
2158 #endif
2159  auxp = servp->prev;
2160  if( (servp->type == ONCE_ONLY ) &&
2161  (servp->pending == WAITING_SERVER_UP))
2162  {
2163  service_tmout( servp->serv_id );
2164  }
2165  else if( (servp->type == COMMAND ) &&
2166  (servp->pending == WAITING_CMND_ANSWER))
2167  {
2168  service_tmout( servp->serv_id );
2169  }
2170  else
2171  {
2172  servp->pending = WAITING_DNS_UP;
2173  dic_release_service( (unsigned)servp->serv_id );
2174  }
2175  servp = auxp;
2176  }
2177  }
2178  dna_close( Dns_dic_conn_id );
2179  Dns_dic_conn_id = 0;
2180  }
2181 }
2182 /*
2183 append_service(service_info_buffer, servp)
2184 char *service_info_buffer;
2185 SERVICE *servp;
2186 {
2187  char name[MAX_NAME], *ptr;
2188 
2189  if(strstr(servp->name,"/RpcIn"))
2190  {
2191  strcpy(name,servp->name);
2192  ptr = (char *)strstr(name,"/RpcIn");
2193  *ptr = 0;
2194  strcat(service_info_buffer, name);
2195  strcat(service_info_buffer, "|");
2196  if(servp->def[0])
2197  {
2198  strcat(service_info_buffer, servp->def);
2199  }
2200  strcat(name,"/RpcOut");
2201  if(servp = find_service(name))
2202  {
2203  strcat(service_info_buffer, ",");
2204  if(servp->def[0])
2205  {
2206  strcat(service_info_buffer, servp->def);
2207  }
2208  }
2209  strcat(service_info_buffer, "|RPC");
2210  strcat(service_info_buffer, "\n");
2211  }
2212  else if(strstr(servp->name,"/RpcOut"))
2213  {
2214  }
2215  else
2216  {
2217  strcat(service_info_buffer, servp->name);
2218  strcat(service_info_buffer, "|");
2219  if(servp->def[0])
2220  {
2221  strcat(service_info_buffer, servp->def);
2222  }
2223  strcat(service_info_buffer, "|");
2224  if(servp->type == COMMAND)
2225  {
2226  strcat(service_info_buffer, "CMD");
2227  }
2228  strcat(service_info_buffer, "\n");
2229  }
2230 }
2231 */
2232 
2233 char *dic_get_error_services()
2234 {
2235  return(dic_get_server_services(Error_conn_id));
2236 }
2237 
2238 char *dic_get_server_services(int conn_id)
2239 {
2240  DIC_SERVICE *servp;
2241  DIC_CONNECTION *dic_connp;
2242  int n_services = 0;
2243  int max_size;
2244  static int curr_allocated_size = 0;
2245  static char *service_info_buffer;
2246  char *buff_ptr;
2247 
2248 
2249  if(!conn_id)
2250  return((char *)0);
2251  dic_connp = &Dic_conns[conn_id];
2252  if( (servp = (DIC_SERVICE *) dic_connp->service_head) )
2253  {
2254  while( (servp = (DIC_SERVICE *) dll_get_next(
2255  (DLL *) dic_connp->service_head,
2256  (DLL *) servp)) )
2257  {
2258  n_services++;
2259  }
2260  if(!n_services)
2261  return((char *)0);
2262  max_size = n_services * MAX_NAME;
2263  if(!curr_allocated_size)
2264  {
2265  service_info_buffer = (char *)malloc((size_t)max_size);
2266  curr_allocated_size = max_size;
2267  }
2268  else if (max_size > curr_allocated_size)
2269  {
2270  free(service_info_buffer);
2271  service_info_buffer = (char *)malloc((size_t)max_size);
2272  curr_allocated_size = max_size;
2273  }
2274  service_info_buffer[0] = '\0';
2275  buff_ptr = service_info_buffer;
2276 
2277  servp = (DIC_SERVICE *) dic_connp->service_head;
2278  while( (servp = (DIC_SERVICE *) dll_get_next(
2279  (DLL *) dic_connp->service_head,
2280  (DLL *) servp)) )
2281  {
2282  strcat(buff_ptr, servp->serv_name);
2283  strcat(buff_ptr, "\n");
2284  buff_ptr += (int)strlen(buff_ptr);
2285  }
2286  }
2287  else
2288  {
2289  return((char *)0);
2290  }
2291 /*
2292  dim_print_date_time();
2293  printf("Server %s@%s provides services:\n",
2294  dic_connp->task_name, dic_connp->node_name);
2295  printf("%s\n",service_info_buffer);
2296 */
2297  return(service_info_buffer);
2298 }
2299 
2300 int dic_get_conn_id()
2301 {
2302  return(Curr_conn_id);
2303 }
2304 
2305 int dic_get_server(char *name)
2306 {
2307  int ret = 0;
2308  char node[MAX_NODE_NAME], task[MAX_TASK_NAME];
2309 
2310  DISABLE_AST
2311 
2312  if(Curr_conn_id)
2313  {
2314  dna_get_node_task(Curr_conn_id, node, task);
2315  strcpy(name,task);
2316  strcat(name,"@");
2317  strcat(name,node);
2318  ret = Curr_conn_id;
2319  }
2320  ENABLE_AST
2321  return(ret);
2322 }
2323 
2324 int dic_get_server_pid(int *pid)
2325 {
2326  int ret = 0;
2327 
2328  DISABLE_AST
2329 
2330  *pid = 0;
2331  if(Curr_conn_id)
2332  {
2333  *pid = Dic_conns[Curr_conn_id].pid;
2334  ret = Curr_conn_id;
2335  }
2336  ENABLE_AST
2337  return(ret);
2338 }
2339 
2340 void dic_stop()
2341 {
2342  int dic_find_server_conns();
2343 
2344  dtq_delete(Dic_timer_q);
2345  dic_close_dns();
2346  if(!dic_find_server_conns())
2347  dim_stop();
2348 }
2349 
2350 int dic_find_server_conns()
2351 {
2352  int i;
2353  int n = 0;
2354 
2355  for( i = 0; i< Curr_N_Conns; i++ )
2356  {
2357  if(Net_conns[i].channel != 0)
2358  {
2359  if(Dna_conns[i].read_ast == recv_rout)
2360  {
2361  dna_close(i);
2362  }
2363  else
2364  {
2365  n++;
2366  }
2367  }
2368  }
2369  return(n);
2370 }
2371 
2372 #ifdef VMS
2373 /* CFORTRAN WRAPPERS */
2374 FCALLSCFUN9(INT, dic_info_service, DIC_INFO_SERVICE, dic_info_service,
2375  STRING, INT, INT, PVOID, INT, PVOID, INT, PVOID, INT)
2376 FCALLSCFUN9(INT, dic_info_service_stamped, DIC_INFO_SERVICE_STAMPED,
2377  dic_info_service_stamped,
2378  STRING, INT, INT, PVOID, INT, PVOID, INT, PVOID, INT)
2379 FCALLSCFUN3(INT, dic_cmnd_service, DIC_CMND_SERVICE, dic_cmnd_service,
2380  STRING, PVOID, INT)
2381 FCALLSCFUN5(INT, dic_cmnd_callback, DIC_CMND_CALLBACK, dic_cmnd_callback,
2382  STRING, PVOID, INT, PVOID, INT)
2383 FCALLSCFUN3(INT, dic_cmnd_service_stamped, DIC_CMND_SERVICE_STAMPED,
2384  dic_cmnd_service_stamped,
2385  STRING, PVOID, INT)
2386 FCALLSCFUN5(INT, dic_cmnd_callback_stamped, DIC_CMND_CALLBACK_STAMPED,
2387  dic_cmnd_callback_stamped,
2388  STRING, PVOID, INT, PVOID, INT)
2389 FCALLSCSUB3( dic_change_address, DIC_CHANGE_ADDRESS, dic_change_address,
2390  INT, PVOID, INT)
2391 FCALLSCSUB1( dic_release_service, DIC_RELEASE_SERVICE, dic_release_service,
2392  INT)
2393 FCALLSCFUN1(INT, dic_get_quality, DIC_GET_QUALITY, dic_get_quality,
2394  INT)
2395 FCALLSCFUN3(INT, dic_get_timestamp, DIC_GET_TIMESTAMP, dic_get_timestamp,
2396  INT,PINT,PINT)
2397 FCALLSCFUN1(INT, dic_get_id, DIC_GET_ID, dic_get_id,
2398  PSTRING)
2399 FCALLSCFUN1(STRING, dic_get_format, DIC_GET_FORMAT, dic_get_format,
2400  INT)
2401 #endif
STA_DATA
#define STA_DATA
Definition: dim.h:198
dim_stop
void dim_stop()
Definition: dim_thr.c:186
SWAPS
Definition: dim.h:191
end_command
int end_command(DIC_SERVICE *servp, int ret)
Definition: dic.c:1808
MAX_NAME
#define MAX_NAME
Definition: dim.h:182
find_connection
int find_connection(char *node, char *task, int port)
Definition: dic.c:2043
error_handler
static void error_handler(int conn_id, int severity, int errcode, char *reason)
Definition: dic.c:120
node
Definition: dns.c:26
dic_serv::fill_address
int * fill_address
Definition: dim.h:470
dim_get_keepalive_timeout
int dim_get_keepalive_timeout()
Definition: tcpip.c:128
DIC_PACKET
Definition: dim.h:230
Dic_conns
DIM_NOSHARE DIC_CONNECTION * Dic_conns
Definition: conn_handler.c:30
dtq_delete
int dtq_delete(int queue_id)
Definition: dtq.c:378
DELETED
Definition: dim.h:454
dic_serv::stamped
int stamped
Definition: dim.h:478
Curr_N_Conns
DllExp DIM_NOSHARE int Curr_N_Conns
Definition: conn_handler.c:33
Dns_dic_conn_id
static int Dns_dic_conn_id
Definition: dic.c:46
dic_info_service_stamped
unsigned dic_info_service_stamped(char *serv_name, int req_type, int req_timeout, void *serv_address, int serv_size, void(*usr_routine)(), dim_long tag, void *fill_addr, int fill_size)
Definition: dic.c:613
DIC_PACKET::type
int type
Definition: dim.h:234
dic_add_error_handler
void dic_add_error_handler(void(*user_routine)())
Definition: dic.c:112
locate_pending
DIC_SERVICE * locate_pending(char *serv_name)
Definition: dic.c:1214
dic_info_service
unsigned dic_info_service(char *serv_name, int req_type, int req_timeout, void *serv_address, int serv_size, void(*usr_routine)(), dim_long tag, void *fill_addr, int fill_size)
Definition: dic.c:601
send_service
int send_service(int conn_id, DIC_SERVICE *servp)
Definition: dic.c:1891
dna_write
int dna_write(int conn_id, void *buffer, int size)
Definition: dna.c:455
dic_serv::tmout_done
int tmout_done
Definition: dim.h:477
MONIT_FIRST
#define MONIT_FIRST
Definition: dim_common.h:15
move_to_notok_service
void move_to_notok_service(DIC_SERVICE *servp)
Definition: dic.c:1655
service_id
unsigned service_id
Definition: db_dim_client.c:22
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
dic_get_id
int dic_get_id(char *name)
Definition: dic.c:2062
Dns_dic_timr
static TIMR_ENT * Dns_dic_timr
Definition: dic.c:47
DIC_PACKET::service_name
char service_name[MAX_NAME]
Definition: dim.h:232
release_service
int release_service(DIC_SERVICE *servicep)
Definition: dic.c:1098
CMNDCB_ITEM
Definition: dic.c:1922
Tmout_min
static int Tmout_min
Definition: dic.c:49
dic_serv::time_stamp
int time_stamp[2]
Definition: dim.h:479
DIC_DNS_PACKET::service
SERVICE_REQ service
Definition: dim.h:302
STA_DISC
#define STA_DISC
Definition: dim.h:197
dic_set_debug_on
void dic_set_debug_on()
Definition: dic.c:97
dna_open_client
int dna_open_client(char *server_node, char *server_task, int port, int server_protocol, void(*read_ast)(), void(*error_ast)(), SRC_TYPES src_type)
Definition: dna.c:733
i
int i
Definition: db_dim_client.c:21
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
Bad_connection_head
static DIC_BAD_CONNECTION * Bad_connection_head
Definition: dic.c:44
COMMAND
#define COMMAND
Definition: dim_common.h:10
DIC_CONNECTION::service_head
char * service_head
Definition: dim.h:424
id_get_ptr
void * id_get_ptr(int id, SRC_TYPES type)
Definition: conn_handler.c:184
dll_insert_queue
void dll_insert_queue(DLL *head, DLL *item)
Definition: dll.c:23
recv_dns_dic_rout
static void recv_dns_dic_rout(int conn_id, DNS_DIC_PACKET *packet, int size, int status)
Definition: dic.c:464
dic_set_debug_off
void dic_set_debug_off()
Definition: dic.c:102
locate_command
DIC_SERVICE * locate_command(char *serv_name)
Definition: dic.c:1202
handle_dns_info
static int handle_dns_info(DNS_DIC_PACKET *packet)
Definition: dic.c:1346
FORMAT_STR::flags
short flags
Definition: dim.h:219
CMNDCB_ITEM::serv_id
int serv_id
Definition: dic.c:1925
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
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
SERVICE_REQ::service_id
int service_id
Definition: dim.h:296
Memory::malloc
void * malloc()
Definition: EventBuilder.cc:99
DNS_DIC_PACKET::node_addr
char node_addr[4]
Definition: dim.h:312
SWAPD
Definition: dim.h:191
BAD_CONN_TIMEOUT
#define BAD_CONN_TIMEOUT
Definition: dic.c:31
modify_service
void modify_service(DIC_SERVICE *servp, int timeout, int *address, int size, void(*routine)(), dim_long tag, int *fill_addr, int fill_size, int stamped)
Definition: dic.c:884
DNS_DIC_PACKET::service_def
char service_def[MAX_NAME]
Definition: dim.h:309
id
char id[4]
Definition: FITS.h:71
do_cmnd_callback
void do_cmnd_callback(CMNDCB_ITEM *itemp)
Definition: dic.c:1928
DIS_STAMPED_HEADER
#define DIS_STAMPED_HEADER
Definition: dim.h:260
timer_entry
Definition: dim.h:370
dic_get_server
int dic_get_server(char *name)
Definition: dic.c:2305
DIC_DNS_TMOUT_MIN
#define DIC_DNS_TMOUT_MIN
Definition: dim.h:158
bad_conn::prev
struct bad_conn * prev
Definition: dic.c:35
dna_set_test_write
void dna_set_test_write(int conn_id, int time)
Definition: dna.c:606
dic_serv::def
char def[MAX_NAME]
Definition: dim.h:463
dll_init
void dll_init(DLL *head)
Definition: dll.c:14
recv_rout
static void recv_rout(int conn_id, DIS_PACKET *packet, int size, int status)
Definition: dic.c:143
STAMPED
#define STAMPED
Definition: dim_common.h:17
request_service
unsigned request_service(char *serv_name, int req_type, int req_timeout, void *serv_address, int serv_size, void(*usr_routine)(), dim_long tag, void *fill_addr, int fill_size, int stamped)
Definition: dic.c:625
dic_serv::quality
int quality
Definition: dim.h:480
SRC_DIC
Definition: dim_common.h:19
dic_get_quality
int dic_get_quality(unsigned serv_id)
Definition: dic.c:937
DIC_HEADER
#define DIC_HEADER
Definition: dim.h:240
DNS_DIC_PACKET::node_name
char node_name[MAX_NODE_NAME]
Definition: dim.h:310
release_conn
static void release_conn(int conn_id)
Definition: dic.c:2121
SIZEOF_CHAR
#define SIZEOF_CHAR
Definition: dim.h:596
move_to_ok_service
void move_to_ok_service(DIC_SERVICE *servp, int conn_id)
Definition: dic.c:1610
execute_service
static void execute_service(DIS_PACKET *packet, DIC_SERVICE *servp, int size)
Definition: dic.c:376
dll_remove
void dll_remove(DLL *item)
Definition: dll.c:100
dic_change_address
void dic_change_address(unsigned serv_id, void *serv_address, int serv_size)
Definition: dic.c:921
retry_bad_connection
void retry_bad_connection(DIC_BAD_CONNECTION *bad_connp)
Definition: dic.c:1583
DNS_DIC_PACKET::protocol
int protocol
Definition: dim.h:315
dic_serv::pending
PENDING_STATES pending
Definition: dim.h:476
FORMAT_STR::par_bytes
short par_bytes
Definition: dim.h:218
DNS_DIC_HEADER
#define DNS_DIC_HEADER
Definition: dim.h:319
DIC_DNS_PACKET::src_type
SRC_TYPES src_type
Definition: dim.h:301
dic_get_server_pid
int dic_get_server_pid(int *pid)
Definition: dic.c:2324
DNS_DIC_PACKET::format
int format
Definition: dim.h:316
conn_arr_create
void conn_arr_create(SRC_TYPES type)
Definition: conn_handler.c:49
dic_get_server_services
char * dic_get_server_services(int conn_id)
Definition: dic.c:2238
DIMDNSUNDEF
#define DIMDNSUNDEF
Definition: dim_common.h:282
dic_serv::user_routine
void(* user_routine)()
Definition: dim.h:472
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
dic_serv::tag
dim_long tag
Definition: dim.h:473
Threads_off
static int Threads_off
Definition: dic.c:50
DID_DNS_TMOUT_MIN
#define DID_DNS_TMOUT_MIN
Definition: dim.h:168
dim_init_threads
void dim_init_threads()
Definition: dim_thr.c:399
dic_serv::serv_address
int * serv_address
Definition: dim.h:468
SIZEOF_DOUBLE
#define SIZEOF_DOUBLE
Definition: dim.h:600
dic_serv::type
int type
Definition: dim.h:465
dll
Definition: dim.h:530
dtq_start_timer
void dtq_start_timer(int time, void(*user_routine)(), dim_long tag)
Definition: dtq.c:790
dic_serv::prev
struct dic_serv * prev
Definition: dim.h:459
dic_cmnd_service
int dic_cmnd_service(char *serv_name, void *serv_address, int serv_size)
Definition: dic.c:694
Error_user_routine
static void(* Error_user_routine)()=0
Definition: dic.c:52
bad_conn::n_retries
int n_retries
Definition: dic.c:37
print_packet
void print_packet(DIS_PACKET *packet)
Definition: dic.c:89
send_service_command
int send_service_command(DIC_SERVICE *servp)
Definition: dic.c:1843
locate_service
int locate_service(DIC_SERVICE *servp)
Definition: dic.c:1167
Current_server
static DIC_SERVICE * Current_server
Definition: dic.c:43
type
int type
Definition: dim_get_service.c:9
dic_get_error_services
char * dic_get_error_services()
Definition: dic.c:2233
DID_DNS_TMOUT_MAX
#define DID_DNS_TMOUT_MAX
Definition: dim.h:169
SERVICE_REQ
Definition: dim.h:294
dim_panic
void dim_panic(char *s)
Definition: utilities.c:198
dtq_clear_entry
int dtq_clear_entry(TIMR_ENT *entry)
Definition: dtq.c:490
dtq_rem_entry
int dtq_rem_entry(int queue_id, TIMR_ENT *entry)
Definition: dtq.c:503
dic_serv::conn_id
int conn_id
Definition: dim.h:475
Cmnd_head
static DIC_SERVICE * Cmnd_head
Definition: dic.c:42
dic_serv
Definition: dim.h:457
Tmout_max
static int Tmout_max
Definition: dic.c:48
MAX_TASK_NAME
#define MAX_TASK_NAME
Definition: dim.h:181
FORMAT_STR::par_num
int par_num
Definition: dim.h:217
request_dns_single_info
int request_dns_single_info(DIC_SERVICE *servp)
Definition: dic.c:1314
DIS_PACKET::size
int size
Definition: dim.h:244
dim_long
long dim_long
Definition: dim_common.h:57
send_command
int send_command(int conn_id, DIC_SERVICE *servp)
Definition: dic.c:1956
DIM_FATAL
Definition: dim_common.h:280
SIZEOF_LONG
#define SIZEOF_LONG
Definition: dim.h:598
Curr_conn_id
static int Curr_conn_id
Definition: dic.c:54
DIS_PACKET::service_id
int service_id
Definition: dim.h:245
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
DIC_DNS_PACKET::size
int size
Definition: dim.h:300
move_to_bad_service
void move_to_bad_service(DIC_SERVICE *servp, DIC_BAD_CONNECTION *bad_connp)
Definition: dic.c:1627
get_format_data
static void get_format_data(int format, FORMAT_STR *format_data, char *def)
Definition: dic.c:1668
DIC_CONNECTION::port
int port
Definition: dim.h:422
DIC_CONNECTION::pid
int pid
Definition: dim.h:423
DIC_CONNECTION::node_name
char node_name[MAX_NODE_NAME]
Definition: dim.h:420
serv_id
int serv_id
Definition: demo_server.c:5
dic_find_server_conns
int dic_find_server_conns()
Definition: dic.c:2350
DIC_DNS_PACKET
Definition: dim.h:299
dic_serv::format_data
FORMAT_STR format_data[MAX_NAME/4]
Definition: dim.h:462
dic_serv::serv_id
int serv_id
Definition: dim.h:461
dic_cmnd_callback_stamped
int dic_cmnd_callback_stamped(char *serv_name, void *serv_address, int serv_size, void(*usr_routine)(), dim_long tag)
Definition: dic.c:726
dna_write_nowait
int dna_write_nowait(int conn_id, void *buffer, int size)
Definition: dna.c:412
DIC_DNS_TMOUT_MAX
#define DIC_DNS_TMOUT_MAX
Definition: dim.h:159
buffer
int buffer[BUFFSIZE]
Definition: db_dim_client.c:14
dll_empty
int dll_empty(DLL *head)
Definition: dll.c:88
DIC_PACKET::size
int size
Definition: dim.h:231
bad_conn::retrying
int retrying
Definition: dic.c:38
bad_conn
Definition: dic.c:33
dic_close_dns
void dic_close_dns()
Definition: dic.c:2142
SERVICE_REQ::service_name
char service_name[MAX_NAME]
Definition: dim.h:295
request_dns_info
static void request_dns_info(int id)
Definition: dic.c:1245
size
int size
Definition: db_dim_server.c:17
id_free
void id_free(int id, SRC_TYPES type)
Definition: conn_handler.c:206
move_to_cmnd_service
void move_to_cmnd_service(DIC_SERVICE *servp)
Definition: dic.c:1639
bad_conn::conn
DIC_CONNECTION conn
Definition: dic.c:36
DIC_PACKET::buffer
int buffer[1]
Definition: dim.h:237
DIC_PACKET::format
int format
Definition: dim.h:236
dic_no_threads
void dic_no_threads()
Definition: dic.c:107
Memory::free
void free(void *mem)
Definition: EventBuilder.cc:126
dtq_add_entry
TIMR_ENT * dtq_add_entry(int queue_id, int time, void(*user_routine)(), dim_long tag)
Definition: dtq.c:399
CMNDCB_ITEM::ret_code
int ret_code
Definition: dic.c:1924
DIC_CONNECTION
Definition: dim.h:419
Dna_conns
DllExp DIM_NOSHARE DNA_CONNECTION * Dna_conns
Definition: conn_handler.c:31
dll_get_next
DLL * dll_get_next(DLL *head, DLL *item)
Definition: dll.c:66
dic_serv::curr_timeout
int curr_timeout
Definition: dim.h:467
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
dic_serv::timer_ent
TIMR_ENT * timer_ent
Definition: dim.h:474
bad_conn::next
struct bad_conn * next
Definition: dic.c:34
dic_serv::serv_name
char serv_name[MAX_NAME]
Definition: dim.h:460
service_tmout
void service_tmout(int serv_id)
Definition: dic.c:518
dim_print_date_time
void dim_print_date_time()
Definition: utilities.c:134
dic_cmnd_service_stamped
int dic_cmnd_service_stamped(char *serv_name, void *serv_address, int serv_size)
Definition: dic.c:705
dim_print_msg
void dim_print_msg(char *msg, int severity)
Definition: utilities.c:180
DIC_CONNECTION::task_name
char task_name[MAX_TASK_NAME]
Definition: dim.h:421
dic_get_conn_id
int dic_get_conn_id()
Definition: dic.c:2300
SIZEOF_SHORT
#define SIZEOF_SHORT
Definition: dim.h:597
dic_serv::format
int format
Definition: dim.h:464
dic_serv::timeout
int timeout
Definition: dim.h:466
dic_serv::fill_size
int fill_size
Definition: dim.h:471
FORMAT_STR
Definition: dim.h:216
DNS_DIC_PACKET::service_id
int service_id
Definition: dim.h:308
ONCE_ONLY
#define ONCE_ONLY
Definition: dim_common.h:7
DIS_HEADER
#define DIS_HEADER
Definition: dim.h:249
locate_bad
DIC_BAD_CONNECTION * locate_bad(char *node, char *task, int port)
Definition: dic.c:1226
get_proc_name
int get_proc_name(char *proc_name)
Definition: utilities.c:22
dic_serv::serv_size
int serv_size
Definition: dim.h:469
request_command
int request_command(char *serv_name, void *serv_address, int serv_size, void(*usr_routine)(), dim_long tag, int stamped)
Definition: dic.c:736
dic_stop
void dic_stop()
Definition: dic.c:2340
DNS_DIC_PACKET::task_name
char task_name[MAX_TASK_NAME-4]
Definition: dim.h:311
dic_release_service
void dic_release_service(unsigned service_id)
Definition: dic.c:1025
get_node_name
int get_node_name(char *node_name)
Definition: utilities.c:33
_DIM_PROTO
_DIM_PROTO(unsigned request_service,(char *service_name, int req_type, int req_timeout, void *service_address, int service_size, void(*usr_routine)(void *, void *, int *), dim_long tag, void *fill_addr, int fill_size, int stamped))
DNS_DIC_PACKET::pid
int pid
Definition: dim.h:313
DIC_BAD_CONNECTION
struct bad_conn DIC_BAD_CONNECTION
dic_serv::tid
int tid
Definition: dim.h:481
dic_get_format
char * dic_get_format(unsigned serv_id)
Definition: dic.c:961
DNS_DIC_PACKET
Definition: dim.h:306
DIM_DELETE
#define DIM_DELETE
Definition: dim_common.h:11
Dic_timer_q
static int Dic_timer_q
Definition: dic.c:45
DIMDNSREFUS
#define DIMDNSREFUS
Definition: dim_common.h:283
STA_CONN
#define STA_CONN
Definition: dim.h:199
user_routine
static void user_routine(void *tagp, void *bufp, int *size)
Definition: diccpp.cxx:11
Error_conn_id
static int Error_conn_id
Definition: dic.c:53
dll_search
DLL * dll_search(DLL *head, char *data, int size)
Definition: dll.c:49
DIS_STAMPED_PACKET
Definition: dim.h:251
NOSWAP
Definition: dim.h:191
DIS_PACKET
Definition: dim.h:243
DNS_DIC_PACKET::port
int port
Definition: dim.h:314
Debug_on
static int Debug_on
Definition: dic.c:59
DNS_DIC_PACKET::size
int size
Definition: dim.h:307
dic_cmnd_callback
int dic_cmnd_callback(char *serv_name, void *serv_address, int serv_size, void(*usr_routine)(), dim_long tag)
Definition: dic.c:716
insert_service
DIC_SERVICE * insert_service(int type, int timeout, char *name, int *address, int size, void(*routine)(), dim_long tag, int *fill_addr, int fill_size, int pending, int stamped)
Definition: dic.c:810
Service_pend_head
static DIC_SERVICE * Service_pend_head
Definition: dic.c:41
dic_get_timestamp
int dic_get_timestamp(unsigned serv_id, int *secs, int *milisecs)
Definition: dic.c:984