Branch data Line data Source code
1 : : #define DIMLIB
2 : : #include <dic.hxx>
3 : : #include <stdio.h>
4 : :
5 : : char *DimClient::dimDnsNode = 0;
6 : : DimErrorHandler *DimClient::itsCltError = 0;
7 : : char *DimClient::serverName = 0;
8 : : int DimClient::dicNoCopy = 0;
9 : :
10 : : extern "C" {
11 : 4 : static void user_routine(void *tagp, void *bufp, int *size)
12 : : {
13 : : // int *tag = (int *)tagp;
14 : 4 : char *buf = (char *)bufp;
15 : : // int id = *tag;
16 : : DimInfo *t;
17 : :
18 : : // t = (DimInfo *)id_get_ptr(id, SRC_DIC);
19 : 4 : t = * (DimInfo **)tagp;
20 : 4 : if(DimClient::getNoDataCopy() == 0)
21 : : {
22 : 4 : if(*size > 0)
23 : : {
24 : 4 : if(!t->itsDataSize)
25 : : {
26 : 2 : t->itsData = new char[*size];
27 : 2 : t->itsDataSize = *size;
28 : : }
29 : 2 : else if(t->itsDataSize < *size)
30 : : {
31 : 0 : delete[] (char *)(t->itsData);
32 : 0 : t->itsData = new char[*size];
33 : 0 : t->itsDataSize = *size;
34 : : }
35 : 4 : memcpy(t->itsData, buf, (size_t)*size);
36 : : }
37 : 0 : else if (*size == 0)
38 : : {
39 : 0 : if(t->itsDataSize)
40 : : {
41 : 0 : delete[] (char *)(t->itsData);
42 : 0 : t->itsDataSize = 0;
43 : : }
44 : 0 : t->itsData = buf;
45 : : }
46 : : }
47 : : else
48 : : {
49 : 0 : t->itsData = buf;
50 : : }
51 : 4 : t->itsSize = *size;
52 : 4 : if(t->itsHandler)
53 : : {
54 : 0 : t->itsHandler->itsService = t;
55 : 0 : DimCore::inCallback = 1;
56 : 0 : t->itsHandler->infoHandler();
57 : 0 : DimCore::inCallback = 0;
58 : : }
59 : : else
60 : : {
61 : 4 : DimCore::inCallback = 1;
62 : 4 : t->infoHandler();
63 : 4 : DimCore::inCallback = 0;
64 : : }
65 : 4 : }
66 : : }
67 : :
68 : 4 : void DimInfo::infoHandler()
69 : : {
70 : : char *data;
71 : 4 : if(DimClient::getNoDataCopy() == 1)
72 : : {
73 : 0 : data = (char *)itsData;
74 : 0 : if(!itsDataSize)
75 : : {
76 : 0 : itsData = new char[itsSize];
77 : 0 : itsDataSize = itsSize;
78 : : }
79 : 0 : else if(itsDataSize < itsSize)
80 : : {
81 : 0 : delete[] (char *)(itsData);
82 : 0 : itsData = new char[itsSize];
83 : 0 : itsDataSize = itsSize;
84 : : }
85 : 0 : memcpy(itsData, data, (size_t)itsSize);
86 : : }
87 : 4 : }
88 : :
89 : 10 : void DimInfo::doIt()
90 : : {
91 : 10 : dim_init();
92 : 10 : DISABLE_AST
93 : :
94 : : // itsTagId = id_get((void *)this, SRC_DIC);
95 : 10 : itsId = dic_info_service(itsName,itsType,itsTime, 0, 0,
96 : : // user_routine, itsTagId,
97 : : user_routine, (dim_long)this,
98 : : itsNolinkBuf, itsNolinkSize);
99 : 10 : ENABLE_AST
100 : 10 : }
101 : :
102 : 0 : int DimInfo::getQuality()
103 : : {
104 : 0 : return dic_get_quality(itsId);
105 : : }
106 : :
107 : 0 : int DimInfo::getTimestamp()
108 : : {
109 : :
110 : 0 : dic_get_timestamp(itsId, &secs, &millisecs);
111 : 0 : return(secs);
112 : : }
113 : :
114 : 0 : int DimInfo::getTimestampMillisecs()
115 : : {
116 : 0 : return(millisecs);
117 : : }
118 : :
119 : :
120 : 0 : char *DimInfo::getFormat()
121 : : {
122 : : char *def;
123 : 0 : int len = 0, new_len;
124 : :
125 : 0 : if(itsFormat)
126 : : {
127 : 0 : len = (int)strlen(itsFormat)+1;
128 : 0 : if(len > 1)
129 : 0 : return itsFormat;
130 : : }
131 : 0 : def = dic_get_format(itsId);
132 : 0 : new_len = (int)strlen(def)+1;
133 : 0 : if(new_len > len)
134 : : {
135 : 0 : if(itsFormat)
136 : 0 : delete[] itsFormat;
137 : 0 : itsFormat = new char[(int)strlen(def)+1];
138 : : }
139 : 0 : strcpy(itsFormat, def);
140 : 0 : return itsFormat;
141 : : }
142 : :
143 : 0 : void DimInfo::timerHandler()
144 : : {
145 : : // itsTagId = id_get((void *)this, SRC_DIC);
146 : 0 : itsId = dic_info_service(itsName,itsType,itsTime, 0, 0,
147 : : // user_routine, itsTagId,
148 : : user_routine, (dim_long)this,
149 : : itsNolinkBuf, itsNolinkSize);
150 : 0 : }
151 : :
152 : 10 : void DimInfo::subscribe(char *name, int time, void *nolink, int nolinksize,
153 : : DimInfoHandler *handler)
154 : : {
155 : 10 : itsId = 0;
156 : 10 : itsData = 0;
157 : 10 : itsFormat = 0;
158 : 10 : itsHandler = handler;
159 : 10 : itsDataSize = 0;
160 : 10 : itsSize = 0;
161 : 10 : itsNolinkBuf = 0;
162 : 10 : itsNolinkSize = 0;
163 : 10 : itsName = 0;
164 : 10 : if(!name)
165 : : {
166 : 0 : return;
167 : : }
168 : 10 : itsName = new char[(int)strlen(name)+1];
169 : 10 : strcpy(itsName,name);
170 : 10 : itsNolinkBuf = nolink;
171 : 10 : itsNolinkSize = nolinksize;
172 : 10 : if(nolinksize > 0)
173 : : {
174 : 9 : itsNolinkBuf = new char[nolinksize];
175 : 9 : itsNolinkSize = nolinksize;
176 : 9 : memcpy(itsNolinkBuf, nolink, (size_t)nolinksize);
177 : : }
178 : 10 : if(!time)
179 : : {
180 : 10 : itsType = MONITORED;
181 : 10 : itsTime = 0;
182 : : }
183 : 0 : else if(time > 0)
184 : : {
185 : 0 : itsType = MONITORED;
186 : 0 : itsTime = time;
187 : : }
188 : : else
189 : : {
190 : : // time is negative, oneshot, use abs of time as timeout
191 : 0 : itsType = ONCE_ONLY;
192 : 0 : itsTime = abs(time);
193 : : }
194 : 10 : doIt();
195 : : }
196 : :
197 : :
198 : 10 : DimInfo::~DimInfo()
199 : : {
200 : : // if(itsTagId)
201 : : // id_free(itsTagId, SRC_DIC);
202 : 10 : if(itsId)
203 : 10 : dic_release_service(itsId);
204 : 10 : if(itsNolinkSize)
205 : 9 : delete[] (char *)itsNolinkBuf;
206 : 10 : if(itsDataSize)
207 : 2 : delete[] (char *)itsData;
208 : 10 : if(itsName)
209 : 10 : delete[] itsName;
210 : 10 : if(itsFormat)
211 : 0 : delete[] itsFormat;
212 : 10 : }
213 : :
214 : 12 : void *DimInfo::getData()
215 : : {
216 : 12 : if(!this->itsSize)
217 : 8 : return itsNolinkBuf;
218 : : /*
219 : : if(DimClient::getNoDataCopy() == 1)
220 : : {
221 : : if(!DimCore::inCallback)
222 : : return (void *)0;
223 : : }
224 : : */
225 : 4 : return this->itsData;
226 : : }
227 : :
228 : 0 : void DimStampedInfo::doIt()
229 : : {
230 : 0 : dim_init();
231 : 0 : DISABLE_AST
232 : : // itsTagId = id_get((void *)this, SRC_DIC);
233 : 0 : itsId = dic_info_service_stamped(itsName,itsType,itsTime, 0, 0,
234 : : // user_routine, itsTagId,
235 : : user_routine, (dim_long)this,
236 : : itsNolinkBuf, itsNolinkSize);
237 : 0 : ENABLE_AST
238 : 0 : }
239 : :
240 : 0 : void DimStampedInfo::subscribe(char *name, int time, void *nolink, int nolinksize,
241 : : DimInfoHandler *handler)
242 : : {
243 : 0 : itsId = 0;
244 : 0 : itsData = 0;
245 : 0 : itsFormat = 0;
246 : 0 : itsHandler = handler;
247 : 0 : itsDataSize = 0;
248 : 0 : itsSize = 0;
249 : 0 : itsNolinkBuf = 0;
250 : 0 : itsNolinkSize = 0;
251 : 0 : itsName = 0;
252 : 0 : if(!name)
253 : : {
254 : 0 : return;
255 : : }
256 : 0 : itsName = new char[(int)strlen(name)+1];
257 : 0 : strcpy(itsName,name);
258 : 0 : itsNolinkBuf = nolink;
259 : 0 : itsNolinkSize = nolinksize;
260 : 0 : if(nolinksize > 0)
261 : : {
262 : 0 : itsNolinkBuf = new char[nolinksize];
263 : 0 : itsNolinkSize = nolinksize;
264 : 0 : memcpy(itsNolinkBuf, nolink, (size_t)nolinksize);
265 : : }
266 : 0 : if(!time)
267 : : {
268 : 0 : itsType = MONITORED;
269 : 0 : itsTime = 0;
270 : : }
271 : 0 : else if(time > 0)
272 : : {
273 : 0 : itsType = MONITORED;
274 : 0 : itsTime = time;
275 : : }
276 : : else
277 : : {
278 : 0 : itsType = ONCE_ONLY;
279 : 0 : itsTime = 30;
280 : : }
281 : 0 : doIt();
282 : : }
283 : :
284 : 0 : DimStampedInfo::~DimStampedInfo()
285 : : {
286 : 0 : }
287 : :
288 : 0 : void DimUpdatedInfo::doIt()
289 : : {
290 : 0 : dim_init();
291 : 0 : DISABLE_AST
292 : : // itsTagId = id_get((void *)this, SRC_DIC);
293 : 0 : itsId = dic_info_service_stamped(itsName,itsType,itsTime, 0, 0,
294 : : // user_routine, itsTagId,
295 : : user_routine, (dim_long)this,
296 : : itsNolinkBuf, itsNolinkSize);
297 : 0 : ENABLE_AST
298 : 0 : }
299 : :
300 : 0 : void DimUpdatedInfo::subscribe(char *name, int time, void *nolink, int nolinksize,
301 : : DimInfoHandler *handler)
302 : : {
303 : 0 : itsId = 0;
304 : 0 : itsData = 0;
305 : 0 : itsFormat = 0;
306 : 0 : itsHandler = handler;
307 : 0 : itsDataSize = 0;
308 : 0 : itsSize = 0;
309 : 0 : itsNolinkBuf = 0;
310 : 0 : itsNolinkSize = 0;
311 : 0 : itsName = 0;
312 : 0 : if(!name)
313 : : {
314 : 0 : return;
315 : : }
316 : 0 : itsName = new char[(int)strlen(name)+1];
317 : 0 : strcpy(itsName,name);
318 : 0 : itsNolinkBuf = nolink;
319 : 0 : itsNolinkSize = nolinksize;
320 : 0 : if(nolinksize > 0)
321 : : {
322 : 0 : itsNolinkBuf = new char[nolinksize];
323 : 0 : itsNolinkSize = nolinksize;
324 : 0 : memcpy(itsNolinkBuf, nolink, (size_t)nolinksize);
325 : : }
326 : 0 : if(!time)
327 : : {
328 : 0 : itsType = MONIT_ONLY;
329 : 0 : itsTime = 0;
330 : : }
331 : 0 : else if(time > 0)
332 : : {
333 : 0 : itsType = UPDATE;
334 : 0 : itsTime = time;
335 : : }
336 : 0 : doIt();
337 : : }
338 : :
339 : 0 : DimUpdatedInfo::~DimUpdatedInfo()
340 : : {
341 : 0 : }
342 : :
343 : : extern "C" {
344 : 2 : static void data_user_routine(void *tagp, void *bufp, int *size)
345 : : {
346 : : // int *tag = (int *)tagp;
347 : 2 : char *buf = (char *)bufp;
348 : : // int id = *tag;
349 : : DimCurrentInfo *t;
350 : :
351 : : // t = (DimCurrentInfo *)id_get_ptr(id, SRC_DIC);
352 : 2 : t = * (DimCurrentInfo **)tagp;
353 : 2 : if(*size > 0)
354 : : {
355 : 2 : if(!t->itsDataSize)
356 : : {
357 : 2 : t->itsData = new char[*size];
358 : 2 : t->itsDataSize = *size;
359 : : }
360 : 0 : else if(t->itsDataSize < *size)
361 : : {
362 : 0 : delete[] (char *)(t->itsData);
363 : 0 : t->itsData = new char[*size];
364 : 0 : t->itsDataSize = *size;
365 : : }
366 : 2 : memcpy(t->itsData, buf, (size_t)*size);
367 : : }
368 : 0 : else if (*size == 0)
369 : : {
370 : 0 : if(t->itsDataSize)
371 : : {
372 : 0 : delete[] (char *)(t->itsData);
373 : 0 : t->itsDataSize = 0;
374 : : }
375 : 0 : t->itsData = buf;
376 : : }
377 : 2 : t->itsSize = *size;
378 : 2 : t->wakeUp = 1;
379 : : #ifdef __VMS
380 : : sys$wake(0,0);
381 : : #endif
382 : : #ifdef WIN32
383 : : wake_up();
384 : : #endif
385 : 2 : }
386 : : }
387 : :
388 : 2 : void DimCurrentInfo::subscribe(char *name, int time, void *nolink, int nolinksize)
389 : : {
390 : :
391 : : int timeout;
392 : :
393 : : // itsTagId = 0;
394 : : // itsId = 0;
395 : 2 : itsData = 0;
396 : : // itsFormat = 0;
397 : : // itsHandler = handler;
398 : 2 : itsDataSize = 0;
399 : 2 : itsSize = 0;
400 : 2 : itsNolinkBuf = 0;
401 : 2 : itsNolinkSize = 0;
402 : 2 : itsName = 0;
403 : 2 : if(!name)
404 : : {
405 : 0 : return;
406 : : }
407 : 2 : itsName = new char[(int)strlen(name)+1];
408 : 2 : strcpy(itsName,name);
409 : 2 : itsNolinkBuf = nolink;
410 : 2 : itsNolinkSize = nolinksize;
411 : 2 : if(nolinksize > 0)
412 : : {
413 : 2 : itsNolinkBuf = new char[nolinksize];
414 : 2 : itsNolinkSize = nolinksize;
415 : 2 : memcpy(itsNolinkBuf, nolink, (size_t)nolinksize);
416 : : }
417 : 2 : if(!time)
418 : 2 : timeout = 10;
419 : : else
420 : 0 : timeout = time;
421 : 2 : wakeUp = 0;
422 : : // itsTagId = id_get((void *)this, SRC_DIC);
423 : 2 : dic_info_service(itsName,ONCE_ONLY,timeout, 0, 0,
424 : : // data_user_routine, itsTagId,
425 : : data_user_routine, (dim_long)this,
426 : : itsNolinkBuf, itsNolinkSize);
427 : : }
428 : :
429 : 2 : DimCurrentInfo::~DimCurrentInfo()
430 : : {
431 : : // if(itsId)
432 : : // dic_release_service(itsId);
433 : 2 : if(itsNolinkSize)
434 : 2 : delete[] (char *)itsNolinkBuf;
435 : 2 : if(itsDataSize)
436 : 2 : delete[] (char *)itsData;
437 : 2 : if(itsName)
438 : 2 : delete[] itsName;
439 : : // if(itsFormat)
440 : : // delete[] itsFormat;
441 : : /*
442 : : delete[] (char *)itsNolinkBuf;
443 : :
444 : : // if(itsTagId)
445 : : // id_free(itsTagId, SRC_DIC);
446 : : if(itsDataSize)
447 : : delete[] (char *)itsData;
448 : : delete[] itsName;
449 : : */
450 : 2 : }
451 : :
452 : 2 : void *DimCurrentInfo::getData()
453 : : {
454 : 11 : while(!wakeUp)
455 : : {
456 : : #ifdef __VMS
457 : : sys$hiber();
458 : : #else
459 : 9 : dim_wait();
460 : : #endif
461 : : }
462 : 2 : if (this->itsSize == 0)
463 : 0 : return this->itsNolinkBuf;
464 : 2 : return this->itsData;
465 : : }
466 : :
467 : : extern "C" {
468 : 0 : static void cmnd_done(void *tagp, int *result)
469 : : {
470 : : // int *tag = (int *)tagp;
471 : : // int id = *tag;
472 : : DimCmnd *t;
473 : :
474 : : // t = (DimCmnd *)id_get_ptr(id, SRC_DIC);
475 : 0 : t = *(DimCmnd **)tagp;
476 : 0 : t->result = *result;
477 : 0 : t->wakeUp = 1;
478 : : #ifdef __VMS
479 : : sys$wake(0,0);
480 : : #endif
481 : : #ifdef WIN32
482 : : wake_up();
483 : : #endif
484 : 0 : }
485 : : }
486 : :
487 : 0 : int DimCmnd::send(char *name, void *data, int datasize)
488 : : {
489 : : // int id;
490 : 0 : if(DimCore::inCallback)
491 : : {
492 : 0 : dic_cmnd_service(name, data, datasize);
493 : 0 : return(1);
494 : : }
495 : : else
496 : : {
497 : 0 : wakeUp = 0;
498 : : // id = id_get((void *)this, SRC_DIC);
499 : 0 : dic_cmnd_callback(name, data, datasize,
500 : : // cmnd_done, id);
501 : : cmnd_done, (dim_long)this);
502 : 0 : while(!wakeUp)
503 : : {
504 : : #ifdef __VMS
505 : : sys$hiber();
506 : : #else
507 : 0 : dim_wait();
508 : : #endif
509 : : }
510 : : // id_free(id, SRC_DIC);
511 : 0 : return(result);
512 : : }
513 : : }
514 : :
515 : 0 : void DimCmnd::sendNB(char *name, void *data, int datasize)
516 : : {
517 : 0 : dic_cmnd_service(name, data, datasize);
518 : 0 : }
519 : :
520 : : extern "C" {
521 : 0 : static void rpc_user_routine(void *tagp, void *bufp, int *sizep)
522 : : {
523 : : // int *tag = (int *)tagp;
524 : 0 : char *buf = (char *)bufp;
525 : 0 : int size = *sizep;
526 : : // int id = *tag;
527 : : DimRpcInfo *t;
528 : : int quality;
529 : :
530 : : // t = (DimRpcInfo *)id_get_ptr(id, SRC_DIC);
531 : 0 : t = *(DimRpcInfo **)tagp;
532 : 0 : quality = dic_get_quality(0);
533 : 0 : if(quality == -1)
534 : : {
535 : 0 : buf = (char *)t->itsNolinkBuf;
536 : 0 : size = t->itsNolinkSize;
537 : : }
538 : 0 : if(DimClient::getNoDataCopy() == 0)
539 : : {
540 : 0 : if(size > 0)
541 : : {
542 : 0 : if(!t->itsDataSize)
543 : : {
544 : 0 : t->itsData = new char[size];
545 : 0 : t->itsDataSize = size;
546 : : }
547 : 0 : else if(t->itsDataSize < size)
548 : : {
549 : 0 : delete[] (char *)(t->itsData);
550 : 0 : t->itsData = new char[size];
551 : 0 : t->itsDataSize = size;
552 : : }
553 : : }
554 : 0 : else if (size == 0)
555 : : {
556 : 0 : if(t->itsDataSize)
557 : : {
558 : 0 : delete[] (char *)(t->itsData);
559 : 0 : t->itsDataSize = 0;
560 : : }
561 : : }
562 : : }
563 : 0 : if(!t->itsConnected)
564 : : {
565 : 0 : t->itsConnected = 1;
566 : : }
567 : 0 : if(t->itsWaiting)
568 : : {
569 : 0 : t->stop();
570 : : //dim_print_date_time();
571 : : //printf("DIM RPC: Stopped Timer, Data Received for %s\n", t->getName());
572 : 0 : if(DimClient::getNoDataCopy() == 0)
573 : : {
574 : 0 : if(size > 0)
575 : 0 : memcpy(t->itsData, buf, (size_t)size);
576 : : else
577 : 0 : t->itsData = buf;
578 : : }
579 : : else
580 : 0 : t->itsData = buf;
581 : 0 : t->itsSize = size;
582 : 0 : t->wakeUp = 1;
583 : 0 : if(t->itsInit)
584 : : {
585 : 0 : t->itsWaiting = 1;
586 : 0 : t->itsHandler->rpcInfoHandler();
587 : : }
588 : 0 : if(t->itsWaiting != 2)
589 : 0 : t->itsWaiting = 0;
590 : : }
591 : : #ifdef __VMS
592 : : sys$wake(0,0);
593 : : #endif
594 : : #ifdef WIN32
595 : : wake_up();
596 : : #endif
597 : 0 : }
598 : : }
599 : :
600 : 0 : void DimRpcInfo::timerHandler()
601 : : {
602 : : char *buf;
603 : : int size;
604 : :
605 : 0 : buf = (char *)itsNolinkBuf;
606 : 0 : size = itsNolinkSize;
607 : :
608 : 0 : if(DimClient::getNoDataCopy() == 0)
609 : : {
610 : 0 : if(size > 0)
611 : : {
612 : 0 : if(!itsDataSize)
613 : : {
614 : 0 : itsData = new char[size];
615 : 0 : itsDataSize = size;
616 : : }
617 : 0 : else if(itsDataSize < size)
618 : : {
619 : 0 : delete[] (char *)(itsData);
620 : 0 : itsData = new char[size];
621 : 0 : itsDataSize = size;
622 : : }
623 : : }
624 : 0 : else if (size == 0)
625 : : {
626 : 0 : if(itsDataSize)
627 : : {
628 : 0 : delete[] (char *)(itsData);
629 : 0 : itsDataSize = 0;
630 : : }
631 : : }
632 : : }
633 : 0 : if(itsWaiting)
634 : : {
635 : 0 : if(DimClient::getNoDataCopy() == 0)
636 : : {
637 : 0 : if(size > 0)
638 : 0 : memcpy(itsData, buf, (size_t)size);
639 : : else
640 : 0 : itsData = buf;
641 : : }
642 : : else
643 : 0 : itsData = buf;
644 : 0 : itsSize = size;
645 : : //dim_print_date_time();
646 : : //printf("DIM RPC: Timer fired, No Data Received for %s\n", itsName);
647 : 0 : wakeUp = 1;
648 : 0 : if(itsInit)
649 : : {
650 : 0 : itsWaiting = 1;
651 : 0 : itsHandler->rpcInfoHandler();
652 : : }
653 : 0 : if(itsWaiting != 2)
654 : 0 : itsWaiting = 0;
655 : : }
656 : : #ifdef __VMS
657 : : sys$wake(0,0);
658 : : #endif
659 : : #ifdef WIN32
660 : : wake_up();
661 : : #endif
662 : 0 : }
663 : :
664 : 0 : void DimRpcInfo::rpcInfoHandler()
665 : : {
666 : : char *data;
667 : 0 : if(DimClient::getNoDataCopy() == 1)
668 : : {
669 : 0 : data = (char *)itsData;
670 : 0 : if(!itsDataSize)
671 : : {
672 : 0 : itsData = new char[itsSize];
673 : 0 : itsDataSize = itsSize;
674 : : }
675 : 0 : else if(itsDataSize < itsSize)
676 : : {
677 : 0 : delete[] (char *)(itsData);
678 : 0 : itsData = new char[itsSize];
679 : 0 : itsDataSize = itsSize;
680 : : }
681 : 0 : memcpy(itsData, data, (size_t)itsSize);
682 : : }
683 : 0 : }
684 : :
685 : 0 : void DimRpcInfo::subscribe(char *name, void *data, int size,
686 : : void *nolink, int nolinksize, int timeout)
687 : : {
688 : :
689 : 0 : itsId = 0;
690 : : // itsTagId = 0;
691 : 0 : itsInit = 0;
692 : 0 : itsWaiting = 0;
693 : 0 : itsName = new char[(int)strlen(name)+1];
694 : 0 : strcpy(itsName,name);
695 : 0 : itsHandler = this;
696 : 0 : itsDataSize = 0;
697 : 0 : itsData = 0;
698 : 0 : itsDataOutSize = 0;
699 : 0 : itsDataOut = 0;
700 : 0 : itsNolinkBuf = nolink;
701 : 0 : itsNolinkSize = nolinksize;
702 : 0 : if(nolinksize > 0)
703 : : {
704 : 0 : itsNolinkBuf = new char[nolinksize];
705 : 0 : itsNolinkSize = nolinksize;
706 : 0 : memcpy(itsNolinkBuf, nolink, (size_t)nolinksize);
707 : : }
708 : 0 : itsNameOut = new char[(int)strlen(name)+1+10];
709 : 0 : strcpy(itsNameOut,name);
710 : 0 : strcat(itsNameOut,(char *)"/RpcIn");
711 : 0 : itsNameIn = new char[(int)strlen(name)+1+10];
712 : 0 : strcpy(itsNameIn,name);
713 : 0 : strcat(itsNameIn,(char *)"/RpcOut");
714 : 0 : itsTimeout = timeout;
715 : 0 : dim_init();
716 : : {
717 : 0 : if(!itsId)
718 : : {
719 : : // itsTagId = id_get((void *)itsHandler, SRC_DIC);
720 : :
721 : : // itsId = dic_info_service_stamped(itsNameIn,MONIT_ONLY,itsTimeout,
722 : 0 : itsConnected = 0;
723 : : // itsId = dic_info_service_stamped(itsNameIn,MONITORED,itsTimeout,
724 : 0 : itsId = dic_info_service_stamped(itsNameIn,MONIT_FIRST,itsTimeout,
725 : : 0, 0,
726 : : // rpc_user_routine, itsTagId,
727 : 0 : rpc_user_routine, (dim_long)itsHandler,
728 : : itsNolinkBuf, itsNolinkSize);
729 : : // dim_usleep(200000);
730 : 0 : itsInit = 1;
731 : : }
732 : : }
733 : 0 : if(size)
734 : : {
735 : 0 : doIt(data, size);
736 : : }
737 : 0 : }
738 : :
739 : 0 : void DimRpcInfo::doIt(void *data, int size)
740 : : {
741 : : int ret;
742 : :
743 : 0 : wakeUp = 0;
744 : 0 : if(DimClient::getNoDataCopy() == 0)
745 : : {
746 : 0 : if(!itsDataOut)
747 : : {
748 : 0 : itsDataOut = new char[size];
749 : 0 : itsDataOutSize = size;
750 : : }
751 : 0 : else if(itsDataOutSize < size)
752 : : {
753 : 0 : delete[] (char *)itsDataOut;
754 : 0 : itsDataOut = new char[size];
755 : 0 : itsDataOutSize = size;
756 : : }
757 : 0 : memcpy(itsDataOut, data, (size_t)size);
758 : : }
759 : : else
760 : : {
761 : 0 : itsDataOut = data;
762 : : }
763 : 0 : while(!itsConnected)
764 : 0 : dim_wait();
765 : 0 : itsWaiting = 1;
766 : 0 : if(itsTimeout)
767 : 0 : start(itsTimeout);
768 : : //dim_print_date_time();
769 : : //printf("DIM RPC: Started Timer for %s - %d secs\n", itsName, itsTimeout);
770 : 0 : ret = DimClient::sendCommand(itsNameOut, itsDataOut, size);
771 : 0 : if(!ret)
772 : : {
773 : 0 : if(itsTimeout)
774 : 0 : stop();
775 : : //dim_print_date_time();
776 : : //printf("DIM RPC: Stopped Timer, Command failed for %s\n", itsName);
777 : : // rpc_user_routine((int *)&itsTagId, itsNolinkBuf, &itsNolinkSize);
778 : 0 : rpc_user_routine((dim_long *)&itsHandler, itsNolinkBuf, &itsNolinkSize);
779 : : }
780 : : /*
781 : : else
782 : : {
783 : : if(itsTimeout)
784 : : start(itsTimeout);
785 : : }
786 : : */
787 : 0 : }
788 : :
789 : 0 : void *DimRpcInfo::getData()
790 : : {
791 : 0 : while(!wakeUp)
792 : : {
793 : : #ifdef __VMS
794 : : sys$hiber();
795 : : #else
796 : 0 : dim_wait();
797 : : #endif
798 : : }
799 : : /*
800 : : if(DimClient::getNoDataCopy() == 1)
801 : : {
802 : : if(!DimCore::inCallback)
803 : : return (void *)0;
804 : : }
805 : : */
806 : 0 : return this->itsData;
807 : : }
808 : :
809 : 0 : DimRpcInfo::~DimRpcInfo()
810 : : {
811 : : // if(itsTagId)
812 : : // id_free(itsTagId, SRC_DIC);
813 : : //dim_print_date_time();
814 : : //printf("DIM RPC: Deleting RPC and Timer for %s\n", itsName);
815 : 0 : if(itsId)
816 : 0 : dic_release_service(itsId);
817 : 0 : delete[] (char *)itsNolinkBuf;
818 : 0 : if(itsDataSize)
819 : 0 : delete[] (char *)itsData;
820 : 0 : if(itsDataOutSize)
821 : 0 : delete[] (char *)itsDataOut;
822 : 0 : delete[] itsName;
823 : 0 : delete[] itsNameIn;
824 : 0 : delete[] itsNameOut;
825 : 0 : }
826 : :
827 : 0 : DimBrowser::DimBrowser()
828 : : {
829 : : int i;
830 : 0 : for(i = 0; i<5; i++)
831 : : {
832 : 0 : itsData[i] = 0;
833 : 0 : itsData[i] = 0;
834 : : }
835 : 0 : currIndex = -1;
836 : 0 : none = 0;
837 : 0 : browserRpc = 0;
838 : 0 : }
839 : :
840 : 0 : DimBrowser::~DimBrowser()
841 : : {
842 : : int i;
843 : 0 : for(i = 0; i<5; i++)
844 : : {
845 : 0 : if(itsData[i])
846 : 0 : delete itsData[i];
847 : : }
848 : 0 : if(browserRpc)
849 : 0 : delete browserRpc;
850 : 0 : }
851 : :
852 : 0 : int DimBrowser::getServices(const char * serviceName)
853 : : {
854 : 0 : return getServices(serviceName, 0);
855 : : }
856 : :
857 : 0 : int DimBrowser::getServices(const char * serviceName, int timeout)
858 : : {
859 : : char *str;
860 : :
861 : : // DimRpcInfo rpc((char *)"DIS_DNS/SERVICE_INFO",(char *)"\0");
862 : : // rpc.setData((char *)serviceName);
863 : : // str = rpc.getString();
864 : 0 : if(!browserRpc)
865 : 0 : browserRpc = new DimRpcInfo((char *)"DIS_DNS/SERVICE_INFO",timeout,(char *)"\0");
866 : 0 : browserRpc->setData((char *)serviceName);
867 : 0 : str = browserRpc->getString();
868 : 0 : if(itsData[0])
869 : 0 : delete itsData[0];
870 : 0 : itsData[0] = new TokenString(str,(char *)"|\n");
871 : 0 : currIndex = 0;
872 : 0 : if(!itsData[0]->getNTokens())
873 : 0 : return(0);
874 : 0 : return( itsData[0]->getNTokens((char *)"\n") + 1);
875 : : }
876 : :
877 : 0 : int DimBrowser::getServers()
878 : : {
879 : 0 : return getServers(0);
880 : : }
881 : :
882 : 0 : int DimBrowser::getServers(int timeout)
883 : : {
884 : : char *str, *pid_str;
885 : : int size, totsize;
886 : 0 : DimCurrentInfo srv((char *)"DIS_DNS/SERVER_LIST", timeout, (char *)"\0");
887 : 0 : str = srv.getString();
888 : 0 : size = (int)strlen(str)+1;
889 : 0 : totsize = srv.getSize();
890 : :
891 : 0 : if(itsData[1])
892 : 0 : delete itsData[1];
893 : 0 : itsData[1] = new TokenString(str,(char *)"|@\n");
894 : 0 : currIndex = 1;
895 : 0 : if(!str[0])
896 : 0 : return(0);
897 : 0 : if(totsize > size)
898 : : {
899 : 0 : pid_str = str + (int)strlen(str) + 1;
900 : 0 : if(itsData[4])
901 : 0 : delete itsData[4];
902 : 0 : itsData[4] = new TokenString(pid_str,(char *)"|");
903 : : }
904 : 0 : return(itsData[1]->getNTokens((char *)"|") +1);
905 : 0 : }
906 : :
907 : 0 : int DimBrowser::getServerServices(const char *serverName)
908 : : {
909 : 0 : return getServerServices(serverName, 0);
910 : : }
911 : :
912 : 0 : int DimBrowser::getServerServices(const char *serverName, int timeout)
913 : : {
914 : : char *str;
915 : 0 : char *name = new char[(int)strlen(serverName) + 20];
916 : 0 : strcpy(name,(char *)serverName);
917 : 0 : strcat(name,(char *)"/SERVICE_LIST");
918 : 0 : DimCurrentInfo srv(name, timeout, (char *)"\0");
919 : 0 : delete[] name;
920 : 0 : str = srv.getString();
921 : 0 : if(itsData[2])
922 : 0 : delete itsData[2];
923 : 0 : itsData[2] = new TokenString(str,(char *)"|\n");
924 : 0 : currIndex = 2;
925 : 0 : if(!itsData[2]->getNTokens())
926 : 0 : return(0);
927 : 0 : return(itsData[2]->getNTokens((char *)"\n") + 1);
928 : 0 : }
929 : :
930 : 0 : int DimBrowser::getServerClients(const char *serverName)
931 : : {
932 : 0 : return getServerClients(serverName, 0);
933 : : }
934 : :
935 : 0 : int DimBrowser::getServerClients(const char *serverName, int timeout)
936 : : {
937 : : char *str;
938 : 0 : char *name = new char[(int)strlen(serverName) + 20];
939 : 0 : strcpy(name,(char *)serverName);
940 : 0 : strcat(name,(char *)"/CLIENT_LIST");
941 : 0 : DimCurrentInfo srv(name, timeout, (char *)"\0");
942 : 0 : delete[] name;
943 : 0 : str = srv.getString();
944 : 0 : if(itsData[3])
945 : 0 : delete itsData[3];
946 : 0 : itsData[3] = new TokenString(str,(char *)"|@\n");
947 : 0 : currIndex = 3;
948 : 0 : return(itsData[3]->getNTokens((char *)"@") );
949 : 0 : }
950 : :
951 : 0 : int DimBrowser::getNextService(char *&service, char *&format)
952 : : {
953 : : int ret, type;
954 : :
955 : 0 : service = format = &none;
956 : 0 : ret = itsData[0]->getToken(currToken);
957 : 0 : if(!ret) return 0;
958 : 0 : service = currToken;
959 : 0 : ret = itsData[0]->getToken(currToken);
960 : 0 : if(!itsData[0]->cmpToken((char *)"|"))
961 : 0 : return 0;
962 : 0 : ret = itsData[0]->getToken(currToken);
963 : 0 : if(!itsData[0]->cmpToken((char *)"|"))
964 : : {
965 : 0 : format = currToken;
966 : 0 : ret = itsData[0]->getToken(currToken);
967 : 0 : if(!itsData[0]->cmpToken((char *)"|"))
968 : 0 : return 0;
969 : : }
970 : 0 : ret = itsData[0]->getToken(currToken);
971 : 0 : type = DimSERVICE;
972 : 0 : if(!itsData[0]->cmpToken((char *)"\n"))
973 : : {
974 : 0 : if(itsData[0]->cmpToken((char *)"CMD"))
975 : 0 : type = DimCOMMAND;
976 : 0 : if(itsData[0]->cmpToken((char *)"RPC"))
977 : 0 : type = DimRPC;
978 : 0 : ret = itsData[0]->getToken(currToken);
979 : 0 : if(!itsData[0]->cmpToken((char *)"\n"))
980 : 0 : return 0;
981 : : }
982 : 0 : return type;
983 : : }
984 : :
985 : 0 : int DimBrowser::getNextServer(char *&server, char *&node)
986 : : {
987 : : int ret;
988 : :
989 : 0 : server = node = &none;
990 : 0 : ret = itsData[1]->getToken(currToken);
991 : 0 : if(!ret) return 0;
992 : 0 : if(!itsData[1]->cmpToken((char *)"@"))
993 : : {
994 : 0 : server = currToken;
995 : 0 : ret = itsData[1]->getToken(currToken);
996 : : }
997 : 0 : if(!itsData[1]->cmpToken((char *)"@"))
998 : 0 : return 0;
999 : : while(1)
1000 : : {
1001 : 0 : ret = itsData[1]->getToken(currToken);
1002 : 0 : node = currToken;
1003 : 0 : itsData[1]->pushToken();
1004 : 0 : ret = itsData[1]->getToken(currToken);
1005 : 0 : if(itsData[1]->cmpToken((char *)"@"))
1006 : : {
1007 : 0 : strcat(server,"@");
1008 : 0 : strcat(server,node);
1009 : : }
1010 : : else
1011 : 0 : break;
1012 : : }
1013 : 0 : if(!itsData[1]->cmpToken((char *)"|"))
1014 : 0 : itsData[1]->popToken();
1015 : 0 : return 1;
1016 : : }
1017 : :
1018 : 0 : int DimBrowser::getNextServer(char *&server, char *&node, int &pid)
1019 : : {
1020 : 0 : int ret, lpid = 0;
1021 : : char *tok;
1022 : :
1023 : 0 : ret = getNextServer(server, node);
1024 : 0 : if(ret && itsData[4])
1025 : : {
1026 : 0 : ret = itsData[4]->getToken(tok);
1027 : 0 : if(ret)
1028 : : {
1029 : 0 : sscanf(tok,"%d",&lpid);
1030 : 0 : pid = lpid;
1031 : : }
1032 : : }
1033 : 0 : if(!ret)
1034 : 0 : return 0;
1035 : 0 : ret = itsData[4]->getToken(tok);
1036 : 0 : return 1;
1037 : : }
1038 : :
1039 : 0 : int DimBrowser::getNextServerService(char *&service, char *&format)
1040 : : {
1041 : : int ret, type;
1042 : :
1043 : 0 : service = format = &none;
1044 : 0 : ret = itsData[2]->getToken(currToken);
1045 : 0 : if(!ret) return 0;
1046 : 0 : service = currToken;
1047 : 0 : ret = itsData[2]->getToken(currToken);
1048 : 0 : if(!itsData[2]->cmpToken((char *)"|"))
1049 : 0 : return 0;
1050 : 0 : ret = itsData[2]->getToken(currToken);
1051 : 0 : if(!itsData[2]->cmpToken((char *)"|"))
1052 : : {
1053 : 0 : format = currToken;
1054 : 0 : ret = itsData[2]->getToken(currToken);
1055 : 0 : if(!itsData[2]->cmpToken((char *)"|"))
1056 : 0 : return 0;
1057 : : }
1058 : 0 : ret = itsData[2]->getToken(currToken);
1059 : 0 : type = DimSERVICE;
1060 : 0 : if(!itsData[2]->cmpToken((char *)"\n"))
1061 : : {
1062 : 0 : if(itsData[2]->cmpToken((char *)"CMD"))
1063 : 0 : type = DimCOMMAND;
1064 : 0 : if(itsData[2]->cmpToken((char *)"RPC"))
1065 : 0 : type = DimRPC;
1066 : 0 : ret = itsData[2]->getToken(currToken);
1067 : 0 : if(!itsData[2]->cmpToken((char *)"\n"))
1068 : 0 : return 0;
1069 : : }
1070 : 0 : return type;
1071 : : }
1072 : :
1073 : 0 : int DimBrowser::getNextServerClient(char *&client, char *&node)
1074 : : {
1075 : : int ret;
1076 : :
1077 : 0 : client = node = &none;
1078 : 0 : ret = itsData[3]->getToken(currToken);
1079 : 0 : if(!ret) return 0;
1080 : 0 : client = currToken;
1081 : 0 : ret = itsData[3]->getToken(currToken);
1082 : 0 : if(!itsData[3]->cmpToken((char *)"@"))
1083 : 0 : return 0;
1084 : 0 : ret = itsData[3]->getToken(currToken);
1085 : 0 : node = currToken;
1086 : 0 : itsData[3]->pushToken();
1087 : 0 : ret = itsData[3]->getToken(currToken);
1088 : 0 : if(!itsData[3]->cmpToken((char *)"|"))
1089 : 0 : itsData[3]->popToken();
1090 : 0 : return 1;
1091 : : }
1092 : :
1093 : 0 : DimClient::DimClient()
1094 : : {
1095 : 0 : itsCltError = this;
1096 : 0 : }
1097 : :
1098 : 0 : DimClient::~DimClient()
1099 : : {
1100 : 0 : if(dimDnsNode)
1101 : 0 : delete[] dimDnsNode;
1102 : 0 : }
1103 : :
1104 : 0 : int DimClient::sendCommand(const char *name, int data)
1105 : : {
1106 : 0 : DimCmnd a;
1107 : 0 : return a.send((char *)name, &data, sizeof(int));
1108 : : }
1109 : :
1110 : 0 : int DimClient::sendCommand(const char *name, float data)
1111 : : {
1112 : 0 : DimCmnd a;
1113 : 0 : return a.send((char *)name, &data, sizeof(float));
1114 : : }
1115 : :
1116 : 0 : int DimClient::sendCommand(const char *name, double data)
1117 : : {
1118 : 0 : DimCmnd a;
1119 : 0 : return a.send((char *)name, &data, sizeof(double));
1120 : : }
1121 : :
1122 : 0 : int DimClient::sendCommand(const char *name, longlong data)
1123 : : {
1124 : 0 : DimCmnd a;
1125 : 0 : return a.send((char *)name, &data, sizeof(longlong));
1126 : : }
1127 : :
1128 : 0 : int DimClient::sendCommand(const char *name, short data)
1129 : : {
1130 : 0 : DimCmnd a;
1131 : 0 : return a.send((char *)name, &data, sizeof(short));
1132 : : }
1133 : :
1134 : 0 : int DimClient::sendCommand(const char *name, const char *data)
1135 : : {
1136 : 0 : DimCmnd a;
1137 : 0 : return a.send((char *)name, (char *)data, (int)strlen(data)+1);
1138 : : }
1139 : :
1140 : 0 : int DimClient::sendCommand(const char *name, void *data, int datasize)
1141 : : {
1142 : 0 : DimCmnd a;
1143 : 0 : return a.send((char *)name, data, datasize);
1144 : : }
1145 : :
1146 : 0 : void DimClient::sendCommandNB(const char *name, int data)
1147 : : {
1148 : 0 : DimCmnd a;
1149 : 0 : a.sendNB((char *)name, &data, sizeof(int));
1150 : 0 : }
1151 : :
1152 : 0 : void DimClient::sendCommandNB(const char *name, float data)
1153 : : {
1154 : 0 : DimCmnd a;
1155 : 0 : a.sendNB((char *)name, &data, sizeof(float));
1156 : 0 : }
1157 : :
1158 : 0 : void DimClient::sendCommandNB(const char *name, double data)
1159 : : {
1160 : 0 : DimCmnd a;
1161 : 0 : a.sendNB((char *)name, &data, sizeof(double));
1162 : 0 : }
1163 : :
1164 : 0 : void DimClient::sendCommandNB(const char *name, longlong data)
1165 : : {
1166 : 0 : DimCmnd a;
1167 : 0 : a.sendNB((char *)name, &data, sizeof(longlong));
1168 : 0 : }
1169 : :
1170 : 0 : void DimClient::sendCommandNB(const char *name, short data)
1171 : : {
1172 : 0 : DimCmnd a;
1173 : 0 : a.sendNB((char *)name, &data, sizeof(short));
1174 : 0 : }
1175 : :
1176 : 0 : void DimClient::sendCommandNB(const char *name, char *data)
1177 : : {
1178 : 0 : DimCmnd a;
1179 : 0 : a.sendNB((char *)name, data, (int)strlen(data)+1);
1180 : 0 : }
1181 : :
1182 : 0 : void DimClient::sendCommandNB(const char *name, void *data, int datasize)
1183 : : {
1184 : 0 : DimCmnd a;
1185 : 0 : a.sendNB((char *)name, data, datasize);
1186 : 0 : }
1187 : :
1188 : 0 : int DimClient::setExitHandler(const char *srvName)
1189 : : {
1190 : 0 : DimCmnd a;
1191 : 0 : int ret, tag = 1;
1192 : 0 : char *name = new char[(int)strlen(srvName) + 20];
1193 : 0 : strcpy(name,(char *)srvName);
1194 : 0 : strcat(name,"/SET_EXIT_HANDLER");
1195 : 0 : ret = a.send(name, &tag, sizeof(int));
1196 : 0 : delete[] name;
1197 : 0 : return ret;
1198 : : }
1199 : :
1200 : 0 : int DimClient::killServer(const char *srvName)
1201 : : {
1202 : 0 : DimCmnd a;
1203 : 0 : int ret, tag = 1;
1204 : 0 : char *name = new char[(int)strlen(srvName) + 20];
1205 : 0 : strcpy(name,(char *)srvName);
1206 : 0 : strcat(name,"/EXIT");
1207 : 0 : ret = a.send(name, &tag, sizeof(int));
1208 : 0 : delete[] name;
1209 : 0 : return ret;
1210 : : }
1211 : :
1212 : 0 : int DimClient::setDnsNode(const char *node)
1213 : : {
1214 : 0 : dic_set_dns_node((char *)node);
1215 : 0 : dic_close_dns();
1216 : 0 : return 1;
1217 : : }
1218 : :
1219 : 0 : int DimClient::setDnsNode(const char *node, int port)
1220 : : {
1221 : 0 : dic_set_dns_port(port);
1222 : 0 : dic_set_dns_node((char *)node);
1223 : 0 : dic_close_dns();
1224 : 0 : return 1;
1225 : : }
1226 : :
1227 : 0 : char *DimClient::getDnsNode()
1228 : : {
1229 : 0 : if(!dimDnsNode)
1230 : 0 : dimDnsNode = new char[256];
1231 : 0 : if(dic_get_dns_node(dimDnsNode))
1232 : 0 : return dimDnsNode;
1233 : : else
1234 : 0 : return 0;
1235 : : }
1236 : :
1237 : 0 : int DimClient::getDnsPort()
1238 : : {
1239 : 0 : return dic_get_dns_port();
1240 : : }
1241 : :
1242 : 0 : void DimClient::setNoDataCopy()
1243 : : {
1244 : 0 : dicNoCopy = 1;
1245 : 0 : }
1246 : :
1247 : 8 : int DimClient::getNoDataCopy()
1248 : : {
1249 : 8 : return dicNoCopy;
1250 : : }
1251 : :
1252 : : extern "C" {
1253 : : //static void clt_error_user_routine(char*, int);
1254 : 0 : static void clt_error_user_routine(int severity, int code, char *msg)
1255 : : {
1256 : :
1257 : 0 : DimCore::inCallback = 2;
1258 : 0 : if(DimClient::itsCltError != 0)
1259 : 0 : DimClient::itsCltError->errorHandler(severity, code, msg);
1260 : 0 : DimCore::inCallback = 0;
1261 : 0 : }
1262 : : }
1263 : :
1264 : 0 : void DimClient::addErrorHandler(DimErrorHandler *handler)
1265 : : {
1266 : 0 : if(handler == 0)
1267 : : {
1268 : 0 : dic_add_error_handler(0);
1269 : 0 : DimClient::itsCltError = 0;
1270 : : }
1271 : : else
1272 : : {
1273 : 0 : DimClient::itsCltError = handler;
1274 : 0 : dic_add_error_handler(clt_error_user_routine);
1275 : : }
1276 : 0 : }
1277 : :
1278 : 0 : void DimClient::addErrorHandler()
1279 : : {
1280 : 0 : DimClient::itsCltError = this;
1281 : 0 : dic_add_error_handler(clt_error_user_routine);
1282 : 0 : }
1283 : :
1284 : 0 : int DimClient::getServerId()
1285 : : {
1286 : 0 : if(!serverName)
1287 : 0 : serverName = new char[128];
1288 : 0 : serverName[0] = '\0';
1289 : 0 : return dic_get_server(serverName);
1290 : : }
1291 : :
1292 : 0 : int DimClient::getServerPid()
1293 : : {
1294 : : int pid, ret;
1295 : :
1296 : 0 : ret = dic_get_server_pid(&pid);
1297 : 0 : if(!ret)
1298 : 0 : return 0;
1299 : 0 : return pid;
1300 : : }
1301 : :
1302 : 0 : char *DimClient::getServerName()
1303 : : {
1304 : 0 : if(!serverName)
1305 : 0 : serverName = new char[128];
1306 : 0 : serverName[0] = '\0';
1307 : 0 : dic_get_server(serverName);
1308 : 0 : return(serverName);
1309 : : }
1310 : :
1311 : : /*
1312 : : char *DimClient::getServerServices(int serverId)
1313 : : {
1314 : : return dic_get_server_services(serverId);
1315 : : }
1316 : :
1317 : : char *DimClient::getServerServices()
1318 : : {
1319 : : int id;
1320 : : if((id = dic_get_conn_id()))
1321 : : return dic_get_server_services(id);
1322 : : return (char *)0;
1323 : : }
1324 : : */
1325 : 0 : char **DimClient::getServerServices()
1326 : : {
1327 : : static TokenString *data = 0;
1328 : 0 : int id, len = 0, index = 0;
1329 : : char *services;
1330 : : static char** list = 0;
1331 : : char *sep;
1332 : :
1333 : 0 : if(data)
1334 : : {
1335 : 0 : delete data;
1336 : 0 : data = 0;
1337 : : }
1338 : 0 : if(list)
1339 : : {
1340 : 0 : delete[] list;
1341 : 0 : list = 0;
1342 : : }
1343 : 0 : if((id = dic_get_conn_id()))
1344 : : {
1345 : 0 : services = dic_get_server_services(id);
1346 : 0 : if(services)
1347 : : {
1348 : 0 : data = new TokenString(services,(char *)"\n");
1349 : 0 : len = data->getNTokens();
1350 : 0 : list = new char*[len];
1351 : 0 : while(data->getToken(list[index]))
1352 : : {
1353 : 0 : data->getToken(sep);
1354 : 0 : index++;
1355 : : }
1356 : : }
1357 : : }
1358 : 0 : if(!len)
1359 : 0 : list = new char*[1];
1360 : 0 : list[index] = 0;
1361 : 0 : return list;
1362 : : }
1363 : :
1364 : 0 : int DimClient::inCallback()
1365 : : {
1366 : 0 : if(DimCore::inCallback)
1367 : 0 : return 1;
1368 : 0 : return 0;
1369 : : }
|
