source: trunk/FACT++/dim_v19r19/src/diccpp.cxx@ 10544

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