← Back to branch summary

~ubuntu-branches/ubuntu/utopic/sblim-sfcc/utopic-proposed

« back to all changes in this revision

Viewing changes to backend/cimxml/parserUtil.c

  • Committer: Bazaar Package Importer
  • Author(s): Thierry Carrez
  • Date: 2009-08-19 14:41:55 UTC
  • mfrom: (1.1.1 upstream)
  • Revision ID: james.westby@ubuntu.com-20090819144155-jb46y5kmluacii70
Tags: 2.2.0-0ubuntu1
* New upstream version.
* debian/libcimcclient0.install: Ship missing libcmpisfcc library
* debian/control:
  - Switch to libcurl4-openssl-dev to match the rest of the SBLIM stack
  - Bump debhelper depend to >=5 to match debian/compat
  - Fix section names, add missing ${misc:Depends}
* debian/copyright: Add missing copyright notice
* debian/rules: Removed spurious DH_MAKESHLIBS argument

Show diffs side-by-side

added added

removed removed

Lines of Context:
backend/cimxml/parserUtil.c
 
1
/*
 
2
 * $id$
 
3
 *
 
4
 *  © Copyright IBM Corp. 2007
 
5
 *
 
6
 * THIS FILE IS PROVIDED UNDER THE TERMS OF THE ECLIPSE PUBLIC LICENSE
 
7
 * ("AGREEMENT"). ANY USE, REPRODUCTION OR DISTRIBUTION OF THIS FILE
 
8
 * CONSTITUTES RECIPIENTS ACCEPTANCE OF THE AGREEMENT.
 
9
 *
 
10
 * You can obtain a current copy of the Eclipse Public License from
 
11
 * http://www.opensource.org/licenses/eclipse-1.0.php
 
12
 *
 
13
 * Author:       Sven Schuetz <sven@de.ibm.com> (created file)
 
14
 *               all content by Adrian Schuur
 
15
 *
 
16
 * Description:
 
17
 *
 
18
 * CIM XML parser helper functions
 
19
 *
 
20
*/
 
21
 
 
22
#include <string.h>
 
23
#include <stdlib.h>
 
24
#include <ctype.h>
 
25
 
 
26
#include "parserUtil.h"
 
27
#include "cimXmlParser.h"
 
28
#include "sfcUtil/utilft.h"
 
29
 
 
30
static int ct = 0;
 
31
static int dontLex = 0;
 
32
 
 
33
extern CMPIConstClass * native_new_CMPIConstClass ( char  *cn, CMPIStatus * rc );
 
34
extern int addClassProperty( CMPIConstClass * ccls, char * name,
 
35
                 CMPIValue * value, CMPIType type,
 
36
                 CMPIValueState state);
 
37
extern CMPIType guessType(char *val);
 
38
extern int addInstPropertyQualifier( CMPIInstance* ci, char * pname,
 
39
                     char *qname, CMPIValue * value,
 
40
                     CMPIType type);
 
41
extern int addClassPropertyQualifier( CMPIConstClass* cc, char * pname,
 
42
                      char *qname, CMPIValue * value,
 
43
                      CMPIType type);
 
44
extern int addClassQualifier( CMPIConstClass* cc, char * name,
 
45
                      CMPIValue * value,
 
46
                      CMPIType type);
 
47
extern char *XmlToAsciiStr(char *XmlStr);
 
48
 
 
49
#if DEBUG
 
50
extern int do_debug;
 
51
#endif
 
52
 
 
53
static inline int isBoolean(CMPIData data)
 
54
{
 
55
   if (data.type == CMPI_chars) {
 
56
      if (strcasecmp(data.value.chars,"true") == 0) return 0xffff;
 
57
      if (strcasecmp(data.value.chars,"false") == 0) return 0;
 
58
   }
 
59
   return -1;
 
60
}
 
61
 
 
62
void createPath(CMPIObjectPath **op, XtokInstanceName *p)
 
63
{
 
64
   int i;
 
65
   CMPIValue val,*valp;
 
66
   CMPIType type;
 
67
   XtokKeyBinding *b;
 
68
 
 
69
   *op = newCMPIObjectPath(NULL, p->className, NULL);
 
70
   for (b = p->bindings.first; b; b = b->next) {
 
71
      valp = getKeyValueTypePtr(b->type,
 
72
                              b->val.keyValue.value,
 
73
                              &b->val.ref,
 
74
                              &val, &type);
 
75
      CMAddKey(*op, b->name, valp, type);
 
76
      if (type == CMPI_ref) {
 
77
    CMRelease(valp->ref);
 
78
      }
 
79
   }
 
80
}
 
81
 
 
82
void setInstProperties(CMPIInstance *ci, XtokProperties *ps)
 
83
{
 
84
   XtokProperty *np = NULL,*p = ps ? ps->first : NULL;
 
85
   CMPIValue val;
 
86
   CMPIObjectPath *op;
 
87
   CMPIStatus status;
 
88
   CMPIType   type;
 
89
   XtokQualifier *nq = NULL,*q;
 
90
   XtokQualifiers *qs;
 
91
   int rc, n, setq;
 
92
 
 
93
   while (p) {
 
94
      setq=1;
 
95
      switch (p->propType) {
 
96
      case typeProperty_Value:
 
97
         type = p->valueType;
 
98
         if (p->val.value.data.value != NULL && p->val.null==0) {
 
99
            if (type == CMPI_string || type == CMPI_chars) {
 
100
                char *charsStr = XmlToAsciiStr(p->val.value.data.value);
 
101
                val = str2CMPIValue(type, charsStr, NULL);
 
102
                free (charsStr);
 
103
            }
 
104
            else
 
105
                val = str2CMPIValue(type, p->val.value.data.value, NULL);
 
106
            CMSetProperty(ci, p->name, &val, type);
 
107
        native_release_CMPIValue(type, &val);
 
108
         }
 
109
         else {
 
110
            CMSetProperty(ci, p->name, NULL, type);
 
111
            setq = 0;
 
112
         }
 
113
         break;
 
114
      case typeProperty_Reference: 
 
115
         val=str2CMPIValue(CMPI_ref, NULL, &p->val.ref);
 
116
         CMSetProperty(ci, p->name, &val.ref, CMPI_ref);
 
117
     CMRelease(val.ref);
 
118
         break;
 
119
      case typeProperty_Array:
 
120
         type = p->valueType;
 
121
         if (p->val.array.next > 0) {
 
122
            CMPIArray *arr = newCMPIArray(0, type, &status);
 
123
            if (p->val.array.max > 0) {
 
124
            int i;
 
125
               for (i = 0; i < p->val.array.next; ++i)
 
126
               {
 
127
                   char *valStr = p->val.array.values[i];
 
128
                   if (type == CMPI_string || type == CMPI_chars) {
 
129
                       char *charsStr = XmlToAsciiStr(valStr);
 
130
                       val = str2CMPIValue(type, charsStr, NULL);
 
131
                       free (charsStr);
 
132
                   }
 
133
                   else
 
134
                       val = str2CMPIValue(type, valStr, NULL);
 
135
                   CMSetArrayElementAt(arr, i, &val, type);
 
136
               native_release_CMPIValue(type, &val);
 
137
               }
 
138
            }
 
139
            val.array = arr;
 
140
            CMSetProperty(ci, p->name, &val, type | CMPI_ARRAY);
 
141
            CMRelease(arr);         /* cloned in property */
 
142
         }
 
143
         else {
 
144
            CMSetProperty(ci, p->name, NULL, p->valueType | CMPI_ARRAY);
 
145
            setq = 0;
 
146
         }
 
147
         break;
 
148
      }
 
149
 
 
150
      if (setq) {
 
151
         qs=&p->val.qualifiers;
 
152
         q=qs ? qs->first : NULL;  
 
153
         n=0;   
 
154
         while (q) {
 
155
            if (q->type & CMPI_ARRAY) {
 
156
               CMPIArray *arr = NULL;
 
157
               arr = newCMPIArray(0, type, NULL);
 
158
               type  = q->type & ~CMPI_ARRAY;
 
159
               int i;
 
160
               if (q->data.array.max) {
 
161
                   for (i = 0; i < q->data.array.next; ++i) {
 
162
                  val = str2CMPIValue(type, q->data.array.values[i], NULL);
 
163
                  CMSetArrayElementAt(arr, i, &val, type);
 
164
                  native_release_CMPIValue(type,&val);
 
165
               }
 
166
               }
 
167
               rc = addInstPropertyQualifier(ci, p->name, q->name,
 
168
                         (CMPIValue *)&arr, q->type); 
 
169
               native_release_CMPIValue(q->type,(CMPIValue*)&arr);
 
170
            }
 
171
            else {
 
172
               val = str2CMPIValue(q->type, q->data.value.data.value, NULL);
 
173
               rc= addInstPropertyQualifier(ci, p->name, q->name, &val, q->type);
 
174
               native_release_CMPIValue(q->type,&val);
 
175
            }   
 
176
            nq = q->next; 
 
177
            q = nq;
 
178
         }
 
179
      }
 
180
 
 
181
      np = p->next;
 
182
      p = np;
 
183
 
 
184
   }
 
185
 
 
186
   if (ps)
 
187
      ps->first = ps->last =  NULL;
 
188
}
 
189
 
 
190
void setInstQualifiers(CMPIInstance *ci, XtokQualifiers *qs)
 
191
{
 
192
   XtokQualifier *nq = NULL,*q = qs ? qs->first : NULL;
 
193
   CMPIValue val;
 
194
   int rc;
 
195
   
 
196
   while (q) {
 
197
      if (q->type & CMPI_ARRAY) {
 
198
               CMPIType type=q->type&~CMPI_ARRAY;
 
199
               CMPIArray *arr = newCMPIArray(0, type, NULL);
 
200
               int i;
 
201
          if (q->data.array.max) {
 
202
              for (i = 0; i < q->data.array.next; ++i) {
 
203
                  val = str2CMPIValue(type, q->data.array.values[i], NULL);
 
204
                  CMSetArrayElementAt(arr, i, &val, type);
 
205
                  native_release_CMPIValue(type,&val);
 
206
               }
 
207
               rc = addInstQualifier(ci, q->name, (CMPIValue*)&arr, q->type);
 
208
               native_release_CMPIValue(q->type,(CMPIValue*)&arr);
 
209
      }
 
210
      }
 
211
      else {
 
212
         val = str2CMPIValue(q->type, q->data.value.data.value, NULL);
 
213
         rc = addInstQualifier(ci, q->name, &val, q->type);
 
214
         native_release_CMPIValue( q->type,&val);
 
215
      }
 
216
      nq = q->next;
 
217
      q = nq;
 
218
   }
 
219
   if (qs) {
 
220
      qs->first = qs->last = NULL;
 
221
   }
 
222
}
 
223
 
 
224
void setClassProperties(CMPIConstClass *cls, XtokProperties *ps)
 
225
{
 
226
   XtokProperty *np = NULL,*p = ps ? ps->first : NULL;
 
227
   CMPIValue val;
 
228
   CMPIArray       *arr;
 
229
   XtokQualifier   *nq,*q;
 
230
   XtokQualifiers *qs;
 
231
   int rc, n;
 
232
 
 
233
      val.uint64=0l;
 
234
   while (p) {
 
235
      switch (p->propType) {
 
236
      case typeProperty_Value:
 
237
         addClassProperty(cls, p->name, &val, p->valueType, CMPI_nullValue);
 
238
         break;
 
239
      case typeProperty_Reference:
 
240
         addClassProperty(cls, p->name, &val, CMPI_ref, CMPI_nullValue);
 
241
     break;
 
242
      case typeProperty_Array:
 
243
         val.array = arr;
 
244
     addClassProperty(cls, p->name, &val,
 
245
                               p->valueType | CMPI_ARRAY, CMPI_nullValue);
 
246
         break;
 
247
      }
 
248
 
 
249
      qs=&p->val.qualifiers;
 
250
      q=qs ? qs->first : NULL;  
 
251
      n=0;   
 
252
      while (q) {
 
253
         if (q->type & CMPI_ARRAY) {
 
254
            CMPIType type=q->type&~CMPI_ARRAY;
 
255
            arr = newCMPIArray(0, type, NULL);
 
256
            int i;
 
257
            if (q->data.array.max) {
 
258
                for (i = 0; i < q->data.array.next; ++i) {
 
259
               val = str2CMPIValue(type, q->data.array.values[i], NULL);
 
260
               CMSetArrayElementAt(arr, i, &val, type);
 
261
               native_release_CMPIValue(type,&val);
 
262
            }
 
263
            }
 
264
            val.array = arr;
 
265
            rc = addClassPropertyQualifier(cls, p->name, q->name, &val, q->type); 
 
266
            native_release_CMPIValue(q->type,(CMPIValue*)&arr);
 
267
         }
 
268
         else {
 
269
            val = str2CMPIValue(q->type, q->data.value.data.value, NULL);
 
270
            rc= addClassPropertyQualifier(cls, p->name, q->name, &val, q->type);
 
271
            native_release_CMPIValue(q->type,&val);
 
272
         }   
 
273
         nq = q->next; 
 
274
         q = nq;
 
275
      }
 
276
 
 
277
      np = p->next;
 
278
      p = np;
 
279
   }
 
280
   if (ps) ps->first = ps->last = NULL;
 
281
}
 
282
 
 
283
void setClassQualifiers(CMPIConstClass *cls, XtokQualifiers *qs)
 
284
{
 
285
   XtokQualifier *nq = NULL,*q = qs ? qs->first : NULL;
 
286
   CMPIValue val;
 
287
   int rc;
 
288
   
 
289
   while (q) {
 
290
      if (q->type & CMPI_ARRAY) {
 
291
               CMPIType type=q->type&~CMPI_ARRAY;
 
292
               CMPIArray *arr = newCMPIArray(0, type, NULL);
 
293
               int i;
 
294
          if (q->data.array.max > 0) {
 
295
              for (i = 0; i < q->data.array.next; ++i) {
 
296
                   char *valStr = q->data.array.values[i];
 
297
                   if (type == CMPI_string || type == CMPI_chars)
 
298
                   {
 
299
                       char *charsStr = XmlToAsciiStr(valStr);
 
300
                       val = str2CMPIValue(type, charsStr, NULL);
 
301
                       free (charsStr);
 
302
                   }
 
303
                   else
 
304
                       val = str2CMPIValue(type, valStr, NULL);
 
305
                  CMSetArrayElementAt(arr, i, &val, type);
 
306
                  native_release_CMPIValue(type,&val);
 
307
               }
 
308
               rc = addClassQualifier(cls, q->name, (CMPIValue*)&arr, q->type);
 
309
               native_release_CMPIValue(q->type,(CMPIValue*)&arr);
 
310
      }
 
311
      }
 
312
      else {
 
313
          char *valStr = q->data.value.data.value;
 
314
          if (q->type == CMPI_string || q->type == CMPI_chars)
 
315
          {
 
316
              char *charsStr = XmlToAsciiStr(valStr);
 
317
              val = str2CMPIValue(q->type, charsStr, NULL);
 
318
              free (charsStr);
 
319
          }
 
320
          else
 
321
              val = str2CMPIValue(q->type, valStr, NULL);
 
322
         rc = addClassQualifier(cls, q->name, &val, q->type);
 
323
         native_release_CMPIValue( q->type,&val);
 
324
      }
 
325
      nq = q->next;
 
326
      q = nq;
 
327
   }
 
328
   if (qs) {
 
329
      qs->first = qs->last = NULL;
 
330
   }
 
331
}
 
332
 
 
333
 
 
334
void addProperty(ParserControl *parm, XtokProperties *ps, XtokProperty *p)
 
335
{
 
336
   XtokProperty *np;
 
337
   np = (XtokProperty*)PARSER_MALLOC(sizeof(XtokProperty));
 
338
   memcpy(np, p, sizeof(XtokProperty));
 
339
   np->next = NULL;
 
340
   if (ps->last) ps->last->next = np;
 
341
   else ps->first = np;
 
342
   ps->last = np;
 
343
}
 
344
 
 
345
void addParamValue(ParserControl *parm, XtokParamValues *vs, XtokParamValue *v)
 
346
{
 
347
   XtokParamValue *nv;
 
348
   nv = (XtokParamValue*)PARSER_MALLOC(sizeof(XtokParamValue));
 
349
   memcpy(nv, v, sizeof(XtokParamValue));
 
350
   nv->next = NULL;
 
351
   if (vs->last)
 
352
      vs->last->next = nv;
 
353
   else
 
354
      vs->first = nv;
 
355
   vs->last = nv;
 
356
}
 
357
 
 
358
void addKeyBinding(ParserControl *parm, XtokKeyBindings *ks, XtokKeyBinding *k)
 
359
{
 
360
   XtokKeyBinding *nk;
 
361
   nk = (XtokKeyBinding*)PARSER_MALLOC(sizeof(XtokKeyBinding));
 
362
   memcpy(nk, k, sizeof(XtokKeyBinding));
 
363
   nk->next = NULL;
 
364
   if (ks->last) ks->last->next = nk;
 
365
   else ks->first = nk;
 
366
   ks->last = nk;
 
367
}
 
368
 
 
369
void addQualifier(ParserControl *parm, XtokQualifiers *qs, XtokQualifier *q)
 
370
{
 
371
   XtokQualifier *nq;
 
372
   nq = (XtokQualifier*)PARSER_MALLOC(sizeof(XtokQualifier));
 
373
   memcpy(nq, q, sizeof(XtokQualifier));
 
374
   nq->next = NULL;
 
375
   if (qs->last) qs->last->next = nq;
 
376
   else qs->first = nq;
 
377
   qs->last = nq;
 
378
}
 
379
 
 
380
void addMethod(ParserControl *parm, XtokMethods *ms, XtokMethod *m)
 
381
{
 
382
   XtokMethod *nm;
 
383
   nm = (XtokMethod*)PARSER_MALLOC(sizeof(XtokMethod));
 
384
   memcpy(nm, m, sizeof(XtokMethod));
 
385
   nm->next = NULL;
 
386
   if (ms->last)
 
387
      ms->last->next = nm;
 
388
   else
 
389
      ms->first = nm;
 
390
   ms->last = nm;
 
391
}
 
392
 
 
393
void addParam(ParserControl *parm, XtokParams *ps, XtokParam *p)
 
394
{
 
395
   XtokParam *np;
 
396
   np = (XtokParam*)PARSER_MALLOC(sizeof(XtokParam));
 
397
   memcpy(np, p, sizeof(XtokParam));
 
398
   np->next = NULL;
 
399
   if (ps->last)
 
400
      ps->last->next = np;
 
401
   else
 
402
      ps->first = np;
 
403
   ps->last = np;
 
404
}
 
405
 
 
406
void setError(ParserControl *parm, XtokErrorResp *e)
 
407
{
 
408
#if DEBUG
 
409
   if (do_debug)
 
410
       fprintf(stderr, "error:: code:%s description:%s\n", 
 
411
                                 e->code, e->description);
 
412
#endif
 
413
   parm->respHdr.errCode = atoi(e->code);
 
414
   parm->respHdr.description = XmlToAsciiStr(e->description);
 
415
}
 
416
 
 
417
void setReturnArgs(ParserControl *parm, XtokParamValues *ps)
 
418
{
 
419
    CMPIValue value;
 
420
    XtokParamValue *outParam=NULL;
 
421
    CMPIArgs *args = NULL;
 
422
   
 
423
    /* Process OUT parameters */
 
424
    outParam = ps->first;
 
425
 
 
426
    if (outParam) { 
 
427
        args = newCMPIArgs(NULL);
 
428
 
 
429
        while (outParam) {
 
430
            value = str2CMPIValue(outParam->type, outParam->data.value.data.value, &outParam->data.valueRef);
 
431
 
 
432
            /* Add it to the args list */
 
433
            args->ft->addArg ( args, outParam->name, &value, outParam->type);
 
434
            native_release_CMPIValue(outParam->type,&value);
 
435
            outParam = outParam->next;
 
436
        }
 
437
        parm->respHdr.outArgs = args;
 
438
        /* Note : Freeing of list will be done by
 
439
        * parser_heap_term() routine.
 
440
        */
 
441
    }
 
442
}