source: trunk/FACT++/dim/src/diccpp.cxx@ 14575

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