source: BAORadio/libindi/v1.0.1/libs/indibase/basedriver.cpp @ 614

Last change on this file since 614 was 502, checked in by frichard, 14 years ago

-BAOControl : petite interface permettant de contrôler les antennes via le pilote indi_BAO
-Le pilote indi_BAO utilise désormais indilib v 0.7
File size: 24.7 KB
Line 
1#include <stdlib.h>
2#include <string.h>
3#include <errno.h>
4#include <zlib.h>
5
6#include "basedriver.h"
7#include "baseclient.h"
8#include "indicom.h"
9#include "base64.h"
10
11INDI::BaseDriver::BaseDriver()
12{
13    mediator = NULL;
14    lp = newLilXML();
15}
16
17
18INDI::BaseDriver::~BaseDriver()
19{
20    std::vector<INumberVectorProperty *>::const_iterator numi;
21    std::vector<ISwitchVectorProperty *>::const_iterator switchi;
22    std::vector<ITextVectorProperty *>::const_iterator texti;
23    std::vector<ILightVectorProperty *>::const_iterator lighti;
24    std::vector<IBLOBVectorProperty *>::const_iterator blobi;
25
26    delLilXML (lp);
27    pAll.clear();
28
29    for ( numi = pNumbers.begin(); numi != pNumbers.end(); numi++)
30        delete (*numi);
31
32   for ( switchi = pSwitches.begin(); switchi != pSwitches.end(); switchi++)
33        delete (*switchi);
34
35   for ( texti = pTexts.begin(); texti != pTexts.end(); texti++)
36        delete (*texti);
37
38   for ( lighti = pLights.begin(); lighti != pLights.end(); lighti++)
39        delete (*lighti);
40
41   for ( blobi = pBlobs.begin(); blobi != pBlobs.end(); blobi++)
42        delete (*blobi);
43}
44
45INumberVectorProperty * INDI::BaseDriver::getNumber(const char *name)
46{
47    std::vector<INumberVectorProperty *>::const_iterator numi;
48
49    for ( numi = pNumbers.begin(); numi != pNumbers.end(); numi++)
50        if (!strcmp(name, (*numi)->name))
51            return *numi;
52
53    return NULL;
54
55}
56
57ITextVectorProperty * INDI::BaseDriver::getText(const char *name)
58{
59    std::vector<ITextVectorProperty *>::const_iterator texti;
60
61    for ( texti = pTexts.begin(); texti != pTexts.end(); texti++)
62        if (!strcmp(name, (*texti)->name))
63            return *texti;
64
65    return NULL;
66}
67
68ISwitchVectorProperty * INDI::BaseDriver::getSwitch(const char *name)
69{
70    std::vector<ISwitchVectorProperty *>::const_iterator switchi;
71
72    for ( switchi = pSwitches.begin(); switchi != pSwitches.end(); switchi++)
73        if (!strcmp(name, (*switchi)->name))
74            return *switchi;
75
76    return NULL;
77
78}
79
80ILightVectorProperty * INDI::BaseDriver::getLight(const char *name)
81{
82    std::vector<ILightVectorProperty *>::const_iterator lighti;
83
84    for ( lighti = pLights.begin(); lighti != pLights.end(); lighti++)
85        if (!strcmp(name, (*lighti)->name))
86            return *lighti;
87
88    return NULL;
89
90}
91
92IBLOBVectorProperty * INDI::BaseDriver::getBLOB(const char *name)
93{
94    std::vector<IBLOBVectorProperty *>::const_iterator blobi;
95
96    for ( blobi = pBlobs.begin(); blobi != pBlobs.end(); blobi++)
97        if (!strcmp(name, (*blobi)->name))
98            return *blobi;
99
100    return NULL;
101}
102
103void * INDI::BaseDriver::getProperty(const char *name, INDI_TYPE & type)
104{
105    std::vector<pOrder>::const_iterator orderi;
106
107    INumberVectorProperty *nvp;
108    ITextVectorProperty *tvp;
109    ISwitchVectorProperty *svp;
110    ILightVectorProperty *lvp;
111    IBLOBVectorProperty *bvp;
112    int i=0;
113
114    for (i=0, orderi = pAll.begin(); orderi != pAll.end(); orderi++, i++)
115    {
116        switch ( (*orderi).type)
117        {
118        case INDI_NUMBER:
119            nvp = static_cast<INumberVectorProperty *>((*orderi).p);
120            if (!strcmp(name, nvp->name))
121            {
122                type = INDI_NUMBER;
123                return (*orderi).p;
124            }
125
126             break;
127        case INDI_TEXT:
128             tvp = static_cast<ITextVectorProperty *>((*orderi).p);
129             if (!strcmp(name, tvp->name))
130             {
131                 type = INDI_TEXT;
132                 return (*orderi).p;
133             }
134             break;
135        case INDI_SWITCH:
136             svp = static_cast<ISwitchVectorProperty *>((*orderi).p);
137             if (!strcmp(name, svp->name))
138             {
139                 type = INDI_SWITCH;
140                 return (*orderi).p;
141             }
142             break;
143        case INDI_LIGHT:
144             lvp = static_cast<ILightVectorProperty *>((*orderi).p);
145             if (!strcmp(name, lvp->name))
146             {
147                 type = INDI_LIGHT;
148                 return (*orderi).p;
149             }
150             break;
151        case INDI_BLOB:
152             bvp = static_cast<IBLOBVectorProperty *>((*orderi).p);
153             if (!strcmp(name, bvp->name))
154             {
155                 type = INDI_BLOB;
156                 return (*orderi).p;
157             }
158             break;
159        }
160    }
161
162    return NULL;
163}
164
165int INDI::BaseDriver::removeProperty(const char *name)
166{
167    std::vector<pOrder>::iterator orderi;
168
169    INumberVectorProperty *nvp;
170    ITextVectorProperty *tvp;
171    ISwitchVectorProperty *svp;
172    ILightVectorProperty *lvp;
173    IBLOBVectorProperty *bvp;
174
175    for (orderi = pAll.begin(); orderi != pAll.end(); orderi++)
176    {
177        switch ( (*orderi).type)
178        {
179        case INDI_NUMBER:
180            nvp = static_cast<INumberVectorProperty *>((*orderi).p);
181            if (!strcmp(name, nvp->name))
182            {
183                 pAll.erase(orderi);
184                 delete (nvp);
185                 return 0;
186             }
187             break;
188        case INDI_TEXT:
189             tvp = static_cast<ITextVectorProperty *>((*orderi).p);
190             if (!strcmp(name, tvp->name))
191             {
192                  pAll.erase(orderi);
193                  delete (tvp);
194                  return 0;
195              }
196             break;
197        case INDI_SWITCH:
198             svp = static_cast<ISwitchVectorProperty *>((*orderi).p);
199             if (!strcmp(name, svp->name))
200             {
201                  pAll.erase(orderi);
202                  delete (svp);
203                  return 0;
204              }
205             break;
206        case INDI_LIGHT:
207             lvp = static_cast<ILightVectorProperty *>((*orderi).p);
208             if (!strcmp(name, lvp->name))
209             {
210                  pAll.erase(orderi);
211                  delete (lvp);
212                  return 0;
213              }
214             break;
215        case INDI_BLOB:
216             bvp = static_cast<IBLOBVectorProperty *>((*orderi).p);
217             if (!strcmp(name, bvp->name))
218             {
219                  pAll.erase(orderi);
220                  delete (bvp);
221                  return 0;
222              }
223             break;
224        }
225    }
226
227    return INDI_PROPERTY_INVALID;
228}
229
230void INDI::BaseDriver::buildSkeleton(const char *filename)
231{
232    char errmsg[MAXRBUF];
233    FILE *fp = NULL;
234    XMLEle *root = NULL, *fproot = NULL;
235
236    fp = fopen(filename, "r");
237
238    if (fp == NULL)
239    {
240        IDLog("Unable to build skeleton. Error loading file %s: %s\n", filename, strerror(errno));
241        return;
242    }
243
244    fproot = readXMLFile(fp, lp, errmsg);
245
246    if (fproot == NULL)
247    {
248        IDLog("Unable to parse skeleton XML: %s", errmsg);
249        return;
250    }
251
252    //prXMLEle(stderr, fproot, 0);
253
254    for (root = nextXMLEle (fproot, 1); root != NULL; root = nextXMLEle (fproot, 0))
255            buildProp(root, errmsg);
256
257
258
259    /**************************************************************************/
260
261}
262
263int INDI::BaseDriver::buildProp(XMLEle *root, char *errmsg)
264{
265    IPerm perm;
266    IPState state;
267    ISRule rule;
268    XMLEle *ep = NULL;
269    char *rtag, *rname, *rdev;
270    INDI_TYPE type;
271    double timeout=0;
272
273    rtag = tagXMLEle(root);
274
275    /* pull out device and name */
276    if (crackDN (root, &rdev, &rname, errmsg) < 0)
277        return -1;
278
279    if (!deviceID[0])
280    {
281        if (getenv("INDIDEV"))
282            strncpy(deviceID, getenv("INDIDEV"), MAXINDINAME);
283        else
284            strncpy(deviceID, rdev, MAXINDINAME);
285    }
286
287    if (getProperty(rname, type) != NULL)
288        return INDI::BaseClient::INDI_PROPERTY_DUPLICATED;
289
290    if (crackIPerm(findXMLAttValu(root, "perm"), &perm) < 0)
291    {
292        IDLog("Error extracting %s permission (%s)", rname, findXMLAttValu(root, "perm"));
293        return -1;
294    }
295
296    timeout = atoi(findXMLAttValu(root, "timeout"));
297
298    if (crackIPState (findXMLAttValu(root, "state"), &state) < 0)
299    {
300        IDLog("Error extracting %s state (%s)", rname, findXMLAttValu(root, "state"));
301        return -1;
302    }
303
304    if (!strcmp (rtag, "defNumberVector"))
305    {
306
307        INumberVectorProperty *nvp = new INumberVectorProperty;
308        INumber *np = NULL;
309        int n=0;
310
311        strncpy(nvp->device, deviceID, MAXINDIDEVICE);
312        strncpy(nvp->name, rname, MAXINDINAME);
313        strncpy(nvp->label, findXMLAttValu(root, "label"), MAXINDILABEL);
314        strncpy(nvp->group, findXMLAttValu(root, "group"), MAXINDIGROUP);
315
316        nvp->p       = perm;
317        nvp->s       = state;
318        nvp->timeout = timeout;
319
320    /* pull out each name/value pair */
321    for (n = 0, ep = nextXMLEle(root,1); ep != NULL; ep = nextXMLEle(root,0), n++)
322    {
323        if (!strcmp (tagXMLEle(ep), "defNumber"))
324        {
325            np = (INumber *) realloc(np, (n+1) * sizeof(INumber));
326
327            np[n].nvp = nvp;
328
329            XMLAtt *na = findXMLAtt (ep, "name");
330
331            if (na)
332            {
333                if (f_scansexa (pcdataXMLEle(ep), &(np[n].value)) < 0)
334                    IDLog("%s: Bad format %s\n", rname, pcdataXMLEle(ep));
335                else
336                {
337
338                    strncpy(np[n].name, valuXMLAtt(na), MAXINDINAME);
339
340                    na = findXMLAtt (ep, "label");
341                    if (na)
342                      strncpy(np[n].label, valuXMLAtt(na),MAXINDILABEL);
343                    na = findXMLAtt (ep, "format");
344                    if (na)
345                        strncpy(np[n].format, valuXMLAtt(na), MAXINDIFORMAT);
346
347                   na = findXMLAtt (ep, "min");
348                   if (na)
349                       np[n].min = atof(valuXMLAtt(na));
350                   na = findXMLAtt (ep, "max");
351                   if (na)
352                       np[n].max = atof(valuXMLAtt(na));
353                   na = findXMLAtt (ep, "step");
354                   if (na)
355                       np[n].step = atof(valuXMLAtt(na));
356
357                }
358            }
359        }
360    }
361
362    if (n > 0)
363    {
364        nvp->nnp = n;
365        nvp->np  = np;
366        pNumbers.push_back(nvp);
367        pOrder o = { INDI_NUMBER, nvp };
368        pAll.push_back(o);
369        IDLog("Adding number property %s to list.\n", nvp->name);
370    }
371    else
372        IDLog("%s: newNumberVector with no valid members\n",rname);
373}
374  else if (!strcmp (rtag, "defSwitchVector"))
375        {
376            ISwitchVectorProperty *svp = new ISwitchVectorProperty;
377            ISwitch *sp = NULL;
378            int n=0;
379
380            strncpy(svp->device, deviceID, MAXINDIDEVICE);
381            strncpy(svp->name, rname, MAXINDINAME);
382            strncpy(svp->label, findXMLAttValu(root, "label"), MAXINDILABEL);
383            strncpy(svp->group, findXMLAttValu(root, "group"), MAXINDIGROUP);
384
385            if (crackISRule(findXMLAttValu(root, "rule"), (&svp->r)) < 0)
386                svp->r = ISR_1OFMANY;
387
388            svp->p       = perm;
389            svp->s       = state;
390            svp->timeout = timeout;
391
392
393        /* pull out each name/value pair */
394        for (n = 0, ep = nextXMLEle(root,1); ep != NULL; ep = nextXMLEle(root,0), n++)
395        {
396            if (!strcmp (tagXMLEle(ep), "defSwitch"))
397            {
398                sp = (ISwitch *) realloc(sp, (n+1) * sizeof(ISwitch));
399
400                sp[n].svp = svp;
401
402                XMLAtt *na = findXMLAtt (ep, "name");
403
404                if (na)
405                {
406                    crackISState(pcdataXMLEle(ep), &(sp[n].s));
407                    strncpy(sp[n].name, valuXMLAtt(na), MAXINDINAME);
408
409                    na = findXMLAtt (ep, "label");
410                    if (na)
411                        strncpy(sp[n].label, valuXMLAtt(na),MAXINDILABEL);
412                 }
413            }
414        }
415
416        if (n > 0)
417        {
418            svp->nsp = n;
419            svp->sp  = sp;
420            pSwitches.push_back(svp);
421            pOrder o = { INDI_SWITCH, svp };
422            pAll.push_back(o);
423            IDLog("Adding Switch property %s to list.\n", svp->name);
424        }
425        else
426            IDLog("%s: newSwitchVector with no valid members\n",rname);
427    }
428
429else if (!strcmp (rtag, "defTextVector"))
430    {
431
432        ITextVectorProperty *tvp = new ITextVectorProperty;
433        IText *tp = NULL;
434        int n=0;
435
436        strncpy(tvp->device, deviceID, MAXINDIDEVICE);
437        strncpy(tvp->name, rname, MAXINDINAME);
438        strncpy(tvp->label, findXMLAttValu(root, "label"), MAXINDILABEL);
439        strncpy(tvp->group, findXMLAttValu(root, "group"), MAXINDIGROUP);
440
441        tvp->p       = perm;
442        tvp->s       = state;
443        tvp->timeout = timeout;
444
445    /* pull out each name/value pair */
446    for (n = 0, ep = nextXMLEle(root,1); ep != NULL; ep = nextXMLEle(root,0), n++)
447    {
448        if (!strcmp (tagXMLEle(ep), "defText"))
449        {
450            tp = (IText *) realloc(tp, (n+1) * sizeof(IText));
451
452            tp[n].tvp = tvp;
453
454            XMLAtt *na = findXMLAtt (ep, "name");
455
456            if (na)
457            {
458                tp[n].text = (char *) malloc(pcdatalenXMLEle(ep)*sizeof(char));
459                strncpy(tp[n].text, pcdataXMLEle(ep), pcdatalenXMLEle(ep));
460                strncpy(tp[n].name, valuXMLAtt(na), MAXINDINAME);
461
462                na = findXMLAtt (ep, "label");
463                if (na)
464                    strncpy(tp[n].label, valuXMLAtt(na),MAXINDILABEL);
465             }
466        }
467    }
468
469    if (n > 0)
470    {
471        tvp->ntp = n;
472        tvp->tp  = tp;
473        pTexts.push_back(tvp);
474        pOrder o = { INDI_TEXT, tvp };
475        pAll.push_back(o);
476        IDLog("Adding Text property %s to list.\n", tvp->name);
477    }
478    else
479        IDLog("%s: newTextVector with no valid members\n",rname);
480}
481else if (!strcmp (rtag, "defLightVector"))
482    {
483
484        ILightVectorProperty *lvp = new ILightVectorProperty;
485        ILight *lp = NULL;
486        int n=0;
487
488        strncpy(lvp->device, deviceID, MAXINDIDEVICE);
489        strncpy(lvp->name, rname, MAXINDINAME);
490        strncpy(lvp->label, findXMLAttValu(root, "label"), MAXINDILABEL);
491        strncpy(lvp->group, findXMLAttValu(root, "group"), MAXINDIGROUP);
492
493        lvp->s       = state;
494
495    /* pull out each name/value pair */
496    for (n = 0, ep = nextXMLEle(root,1); ep != NULL; ep = nextXMLEle(root,0), n++)
497    {
498        if (!strcmp (tagXMLEle(ep), "defLight"))
499        {
500            lp = (ILight *) realloc(lp, (n+1) * sizeof(ILight));
501
502            lp[n].lvp = lvp;
503
504            XMLAtt *na = findXMLAtt (ep, "name");
505
506            if (na)
507            {
508                crackIPState(pcdataXMLEle(ep), &(lp[n].s));
509                strncpy(lp[n].name, valuXMLAtt(na), MAXINDINAME);
510
511                na = findXMLAtt (ep, "label");
512                if (na)
513                    strncpy(lp[n].label, valuXMLAtt(na),MAXINDILABEL);
514
515             }
516        }
517    }
518
519    if (n > 0)
520    {
521        lvp->nlp = n;
522        lvp->lp  = lp;
523        pLights.push_back(lvp);
524        pOrder o = { INDI_LIGHT, lvp };
525        pAll.push_back(o);
526        IDLog("Adding Light property %s to list.\n", lvp->name);
527    }
528    else
529        IDLog("%s: newLightVector with no valid members\n",rname);
530}
531else if (!strcmp (rtag, "defBLOBVector"))
532    {
533
534        IBLOBVectorProperty *bvp = new IBLOBVectorProperty;
535        IBLOB *bp = NULL;
536        int n=0;
537
538        strncpy(bvp->device, deviceID, MAXINDIDEVICE);
539        strncpy(bvp->name, rname, MAXINDINAME);
540        strncpy(bvp->label, findXMLAttValu(root, "label"), MAXINDILABEL);
541        strncpy(bvp->group, findXMLAttValu(root, "group"), MAXINDIGROUP);
542
543        bvp->s       = state;
544
545    /* pull out each name/value pair */
546    for (n = 0, ep = nextXMLEle(root,1); ep != NULL; ep = nextXMLEle(root,0), n++)
547    {
548        if (!strcmp (tagXMLEle(ep), "defBLOB"))
549        {
550            bp = (IBLOB *) realloc(bp, (n+1) * sizeof(IBLOB));
551
552            bp[n].bvp = bvp;
553
554            XMLAtt *na = findXMLAtt (ep, "name");
555
556            if (na)
557            {
558                strncpy(bp[n].name, valuXMLAtt(na), MAXINDINAME);
559
560                na = findXMLAtt (ep, "label");
561                if (na)
562                    strncpy(bp[n].label, valuXMLAtt(na),MAXINDILABEL);
563
564                na = findXMLAtt (ep, "format");
565                if (na)
566                    strncpy(bp[n].label, valuXMLAtt(na),MAXINDIBLOBFMT);
567
568                // Initialize everything to zero
569
570                bp[n].blob    = NULL;
571                bp[n].size    = 0;
572                bp[n].bloblen = 0;
573             }
574
575        }
576    }
577
578    if (n > 0)
579    {
580        bvp->nbp = n;
581        bvp->bp  = bp;
582        pBlobs.push_back(bvp);
583        pOrder o = { INDI_BLOB, bvp };
584        pAll.push_back(o);
585        IDLog("Adding BLOB property %s to list.\n", bvp->name);
586    }
587    else
588        IDLog("%s: newBLOBVector with no valid members\n",rname);
589 }
590
591return (0);
592
593}
594
595bool INDI::BaseDriver::isConnected()
596{
597    ISwitchVectorProperty *svp = getSwitch("CONNECTION");
598    if (!svp)
599        return false;
600
601    ISwitch * sp = IUFindSwitch(svp, "CONNECT");
602
603    if (!sp)
604        return false;
605
606    if (sp->s == ISS_ON)
607        return true;
608    else
609        return false;
610
611}
612
613void INDI::BaseDriver::setConnected(bool status)
614{
615    ISwitch *sp = NULL;
616    ISwitchVectorProperty *svp = getSwitch("CONNECTION");
617    if (!svp)
618        return;
619
620    IUResetSwitch(svp);
621
622    // Connect
623    if (status)
624    {
625        sp = IUFindSwitch(svp, "CONNECT");
626        if (!sp)
627            return;
628        sp->s = ISS_ON;
629    }
630    // Disconnect
631    else
632    {
633        sp = IUFindSwitch(svp, "DISCONNECT");
634        if (!sp)
635            return;
636        sp->s = ISS_ON;
637    }
638
639    svp->s = IPS_OK;
640}
641
642/*
643 * return 0 if ok else -1 with reason in errmsg
644 */
645int INDI::BaseDriver::setValue (XMLEle *root, char * errmsg)
646{
647    XMLAtt *ap;
648    XMLEle *ep;
649    char *rtag, *name;
650    double timeout;
651    IPState state;
652    bool stateSet=false, timeoutSet=false;
653
654    rtag = tagXMLEle(root);
655
656    ap = findXMLAtt (root, "name");
657    if (!ap)
658    {
659        snprintf(errmsg, MAXRBUF, "INDI: <%s> unable to find name attribute", tagXMLEle(root));
660        return (-1);
661    }
662
663    name = valuXMLAtt(ap);
664
665    /* set overall property state, if any */
666    ap = findXMLAtt (root, "state");
667    if (ap)
668    {
669        if (crackIPState(valuXMLAtt(ap), &state) != 0)
670        {
671            snprintf(errmsg, MAXRBUF, "INDI: <%s> bogus state %s for %s", tagXMLEle(root),
672                     valuXMLAtt(ap), name);
673            return (-1);
674        }
675
676        stateSet = true;
677    }
678
679    /* allow changing the timeout */
680    ap = findXMLAtt (root, "timeout");
681    if (ap)
682    {
683        timeout = atof(valuXMLAtt(ap));
684        timeoutSet = true;
685    }
686
687    if (!strcmp(rtag, "setNumberVector"))
688    {
689        INumberVectorProperty *nvp = getNumber(name);
690        if (nvp == NULL)
691        {
692            snprintf(errmsg, MAXRBUF, "INDI: Could not find property %s in %s", name, deviceID);
693            return -1;
694        }
695
696        if (stateSet)
697            nvp->s = state;
698
699        if (timeoutSet)
700            nvp->timeout = timeout;
701
702       for (ep = nextXMLEle (root, 1); ep != NULL; ep = nextXMLEle (root, 0))
703        {
704           INumber *np =  IUFindNumber(nvp, findXMLAttValu(ep, "name"));
705           if (!np)
706               continue;
707
708          np->value = atof(pcdataXMLEle(ep));
709
710          // Permit changing of min/max
711          if (findXMLAtt(ep, "min"))
712              np->min = atof(findXMLAttValu(ep, "min"));
713          if (findXMLAtt(ep, "max"))
714              np->max = atof(findXMLAttValu(ep, "max"));
715       }
716
717       if (mediator)
718           mediator->newNumber(nvp);
719
720       return 0;
721    }
722    else if (!strcmp(rtag, "setTextVector"))
723    {
724        ITextVectorProperty *tvp = getText(name);
725        if (tvp == NULL)
726            return -1;
727
728        if (stateSet)
729            tvp->s = state;
730
731        if (timeoutSet)
732            tvp->timeout = timeout;
733
734       for (ep = nextXMLEle (root, 1); ep != NULL; ep = nextXMLEle (root, 0))
735        {
736           IText *tp =  IUFindText(tvp, findXMLAttValu(ep, "name"));
737           if (!tp)
738               continue;
739
740           IUSaveText(tp, pcdataXMLEle(ep));
741       }
742
743       if (mediator)
744           mediator->newText(tvp);
745
746       return 0;
747    }
748    else if (!strcmp(rtag, "setSwitchVector"))
749    {
750        ISState swState;
751        ISwitchVectorProperty *svp = getSwitch(name);
752        if (svp == NULL)
753            return -1;
754
755        if (stateSet)
756            svp->s = state;
757
758        if (timeoutSet)
759            svp->timeout = timeout;
760
761       for (ep = nextXMLEle (root, 1); ep != NULL; ep = nextXMLEle (root, 0))
762        {
763           ISwitch *sp =  IUFindSwitch(svp, findXMLAttValu(ep, "name"));
764           if (!sp)
765               continue;
766
767           if (crackISState(pcdataXMLEle(ep), &swState) == 0)
768               sp->s = swState;
769        }
770
771       if (mediator)
772           mediator->newSwitch(svp);
773
774       return 0;
775    }
776    else if (!strcmp(rtag, "setLightVector"))
777    {
778        IPState lState;
779        ILightVectorProperty *lvp = getLight(name);
780        if (lvp == NULL)
781            return -1;
782
783        if (stateSet)
784            lvp->s = state;
785
786       for (ep = nextXMLEle (root, 1); ep != NULL; ep = nextXMLEle (root, 0))
787        {
788           ILight *lp =  IUFindLight(lvp, findXMLAttValu(ep, "name"));
789           if (!lp)
790               continue;
791
792           if (crackIPState(pcdataXMLEle(ep), &lState) == 0)
793               lp->s = lState;
794        }
795
796       if (mediator)
797           mediator->newLight(lvp);
798
799       return 0;
800
801    }
802    else if (!strcmp(rtag, "setBLOBVector"))
803    {
804        IBLOBVectorProperty *bvp = getBLOB(name);
805        if (bvp == NULL)
806            return -1;
807
808        if (stateSet)
809            bvp->s = state;
810
811        if (timeoutSet)
812            bvp->timeout = timeout;
813
814        return setBLOB(bvp, root, errmsg);
815    }
816
817    snprintf(errmsg, MAXRBUF, "INDI: <%s> Unable to process tag", tagXMLEle(root));
818    return -1;
819}
820
821/* Set BLOB vector. Process incoming data stream
822 * Return 0 if okay, -1 if error
823*/
824int INDI::BaseDriver::setBLOB(IBLOBVectorProperty *bvp, XMLEle * root, char * errmsg)
825{
826
827    XMLEle *ep;
828    IBLOB *blobEL;
829
830    for (ep = nextXMLEle(root,1); ep; ep = nextXMLEle(root,0))
831    {
832        if (strcmp(tagXMLEle(ep), "oneBLOB") == 0)
833        {
834            blobEL = IUFindBLOB(bvp, findXMLAttValu (ep, "name"));
835
836            if (blobEL)
837                return processBLOB(blobEL, ep, errmsg);
838            else
839            {
840                snprintf(errmsg, MAXRBUF, "INDI: set %s.%s.%s not found", bvp->device, bvp->name,
841                         findXMLAttValu (ep, "name"));
842                return (-1);
843            }
844        }
845    }
846
847    return -1;
848}
849
850/* Process incoming data stream
851 * Return 0 if okay, -1 if error
852*/
853int INDI::BaseDriver::processBLOB(IBLOB *blobEL, XMLEle *ep, char * errmsg)
854{
855    XMLAtt *ap = NULL;
856    int blobSize=0, r=0;
857    uLongf dataSize=0;
858    char *baseBuffer=NULL, *dataFormat;
859    unsigned char *blobBuffer(NULL), *dataBuffer(NULL);
860    bool iscomp(false);
861
862    ap = findXMLAtt(ep, "size");
863    if (!ap)
864    {
865        snprintf(errmsg, MAXRBUF, "INDI: set %s size not found", blobEL->name);
866        return (-1);
867    }
868
869    dataSize = atoi(valuXMLAtt(ap));
870
871    ap = findXMLAtt(ep, "format");
872    if (!ap)
873    {
874        snprintf(errmsg, MAXRBUF, "INDI: set %s format not found",blobEL->name);
875        return (-1);
876    }
877
878    dataFormat = valuXMLAtt(ap);
879
880    strncpy(blobEL->format, dataFormat, MAXINDIFORMAT);
881
882    baseBuffer = (char *) malloc ( (3*pcdatalenXMLEle(ep)/4) * sizeof (char));
883
884    if (baseBuffer == NULL)
885    {
886        strncpy(errmsg, "Unable to allocate memory for base buffer", MAXRBUF);
887        return (-1);
888    }
889
890    blobSize   = from64tobits (baseBuffer, pcdataXMLEle(ep));
891    blobBuffer = (unsigned char *) baseBuffer;
892
893    /* Blob size = 0 when only state changes */
894    if (dataSize == 0)
895    {
896        free (blobBuffer);
897        return (0);
898    }
899    else if (blobSize < 0)
900    {
901        free (blobBuffer);
902        snprintf(errmsg, MAXRBUF, "INDI: %s.%s.%s bad base64", blobEL->bvp->device, blobEL->bvp->name, blobEL->name);
903        return (-1);
904    }
905
906    if (strstr(dataFormat, ".z"))
907    {
908        dataFormat[strlen(dataFormat)-2] = '\0';
909        dataBuffer = (unsigned char *) realloc (dataBuffer,  (dataSize * sizeof(unsigned char)));
910
911        if (baseBuffer == NULL)
912        {
913                free (blobBuffer);
914                strncpy(errmsg, "Unable to allocate memory for data buffer", MAXRBUF);
915                return (-1);
916        }
917
918        r = uncompress(dataBuffer, &dataSize, blobBuffer, (uLong) blobSize);
919        if (r != Z_OK)
920        {
921            snprintf(errmsg, MAXRBUF, "INDI: %s.%s.%s compression error: %d", blobEL->bvp->device, blobEL->bvp->name, blobEL->name, r);
922            free (blobBuffer);
923            return -1;
924        }
925        blobEL->size = dataSize;
926    }
927    else
928    {
929        dataBuffer = (unsigned char *) realloc (dataBuffer,  (dataSize * sizeof(unsigned char)));
930        memcpy(dataBuffer, blobBuffer, dataSize);
931        blobEL->size = dataSize;
932    }
933
934    blobEL->blob = dataBuffer;
935
936    if (mediator)
937        mediator->newBLOB(blobEL);
938
939   // newBLOB(dataBuffer, dataSize, dataFormat);
940
941    free (blobBuffer);
942    return (0);
943}
944
945void INDI::BaseDriver::setDeviceName(const char *dev)
946{
947    strncpy(deviceID, dev, MAXINDINAME);
948}
949
950const char * INDI::BaseDriver::deviceName()
951{
952    return deviceID;
953}
954
955void INDI::BaseDriver::addMessage(const char *msg)
956{
957    messageQueue.append(msg);
958}
959
Note: See TracBrowser for help on using the repository browser.