1 karl 1.18 //%2006////////////////////////////////////////////////////////////////////////
|
2 schuur 1.1 //
|
3 karl 1.11 // Copyright (c) 2000, 2001, 2002 BMC Software; Hewlett-Packard Development
4 // Company, L.P.; IBM Corp.; The Open Group; Tivoli Systems.
5 // Copyright (c) 2003 BMC Software; Hewlett-Packard Development Company, L.P.;
|
6 schuur 1.1 // IBM Corp.; EMC Corporation, The Open Group.
|
7 karl 1.11 // Copyright (c) 2004 BMC Software; Hewlett-Packard Development Company, L.P.;
8 // IBM Corp.; EMC Corporation; VERITAS Software Corporation; The Open Group.
|
9 karl 1.13 // Copyright (c) 2005 Hewlett-Packard Development Company, L.P.; IBM Corp.;
10 // EMC Corporation; VERITAS Software Corporation; The Open Group.
|
11 karl 1.18 // Copyright (c) 2006 Hewlett-Packard Development Company, L.P.; IBM Corp.;
12 // EMC Corporation; Symantec Corporation; The Open Group.
|
13 schuur 1.1 //
14 // Permission is hereby granted, free of charge, to any person obtaining a copy
15 // of this software and associated documentation files (the "Software"), to
16 // deal in the Software without restriction, including without limitation the
17 // rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
18 // sell copies of the Software, and to permit persons to whom the Software is
19 // furnished to do so, subject to the following conditions:
|
20 venkat.puvvada 1.23 //
|
21 schuur 1.1 // THE ABOVE COPYRIGHT NOTICE AND THIS PERMISSION NOTICE SHALL BE INCLUDED IN
22 // ALL COPIES OR SUBSTANTIAL PORTIONS OF THE SOFTWARE. THE SOFTWARE IS PROVIDED
23 // "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT
24 // LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
25 // PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
26 // HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
27 // ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
28 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
29 //
30 //==============================================================================
31 //
32 //%/////////////////////////////////////////////////////////////////////////////
33
|
34 schuur 1.5 #include "CMPI_Version.h"
|
35 schuur 1.3
|
36 schuur 1.1 #include "CMPI_ObjectPath.h"
37
38 #include "CMPI_Ftabs.h"
39 #include "CMPI_Value.h"
40 #include "CMPI_String.h"
|
41 ms.aruran 1.24 #include <Pegasus/Common/Tracer.h>
|
42 schuur 1.1
43 PEGASUS_USING_STD;
44 PEGASUS_NAMESPACE_BEGIN
45
|
46 venkat.puvvada 1.23 extern "C"
47 {
48 static CMPIStatus refRelease(CMPIObjectPath* eRef)
49 {
50 CIMObjectPath* ref = (CIMObjectPath*)eRef->hdl;
51 if (ref)
52 {
53 delete ref;
54 (reinterpret_cast<CMPI_Object*>(eRef))->unlinkAndDelete();
55 CMReturn(CMPI_RC_OK);
56 }
57 CMReturn(CMPI_RC_ERR_INVALID_HANDLE);
58 }
59
60 static CMPIStatus refReleaseNop(CMPIObjectPath* eRef)
61 {
62 CMReturn(CMPI_RC_OK);
63 }
64
65 static CMPIObjectPath* refClone(const CMPIObjectPath* eRef, CMPIStatus* rc)
66 {
67 venkat.puvvada 1.23 CIMObjectPath *ref=(CIMObjectPath*)eRef->hdl;
68 if (!ref)
69 {
|
70 ms.aruran 1.24 PEG_TRACE_CSTRING(
71 TRC_CMPIPROVIDERINTERFACE,
72 Tracer::LEVEL2,
73 "Received invalid handle in CMPIObjectPath:refClone");
|
74 venkat.puvvada 1.23 CMSetStatus(rc, CMPI_RC_ERR_INVALID_HANDLE);
75 return NULL;
76 }
77 CIMObjectPath *nRef = new CIMObjectPath(
78 ref->getHost(),
79 ref->getNameSpace(),
80 ref->getClassName());
81
82 Array<CIMKeyBinding> kb = ref->getKeyBindings();
83 nRef->setKeyBindings(kb);
84 CMPI_Object* obj = new CMPI_Object(nRef);
85 obj->unlink();
86 CMPIObjectPath* neRef = reinterpret_cast<CMPIObjectPath*>(obj);
87 CMSetStatus(rc, CMPI_RC_OK);
88 return neRef;
89 }
90
91 static CMPIStatus refSetNameSpace(CMPIObjectPath* eRef, const char *ns)
92 {
93 CIMObjectPath* ref = (CIMObjectPath*)eRef->hdl;
94 if (!ref)
95 venkat.puvvada 1.23 {
|
96 ms.aruran 1.24 PEG_TRACE_CSTRING(
97 TRC_CMPIPROVIDERINTERFACE,
98 Tracer::LEVEL2,
99 "Received invalid handle in CMPIObjectPath:refSetNameSpace");
|
100 venkat.puvvada 1.23 CMReturn(CMPI_RC_ERR_INVALID_HANDLE);
101 }
102 if (!ns)
103 {
|
104 ms.aruran 1.24 PEG_TRACE_CSTRING(
105 TRC_CMPIPROVIDERINTERFACE,
106 Tracer::LEVEL2,
107 "Received invalid Parameter in \
108 CMPIObjectPath:refSetNameSpace");
|
109 venkat.puvvada 1.23 CMReturn(CMPI_RC_ERR_INVALID_PARAMETER);
110 }
111 ref->setNameSpace(String(ns));
112 CMReturn(CMPI_RC_OK);
113 }
114
115 static CMPIString* refGetNameSpace(
116 const CMPIObjectPath* eRef,
117 CMPIStatus* rc)
118 {
119 CIMObjectPath* ref = (CIMObjectPath*)eRef->hdl;
120 if (!ref)
121 {
|
122 ms.aruran 1.24 PEG_TRACE_CSTRING(
123 TRC_CMPIPROVIDERINTERFACE,
124 Tracer::LEVEL2,
125 "Received invalid handle in CMPIObjectPath:refGetNameSpace");
|
126 venkat.puvvada 1.23 CMSetStatus(rc, CMPI_RC_ERR_INVALID_HANDLE);
127 return NULL;
128 }
129 const CIMNamespaceName &ns = ref->getNameSpace();
130 CMPIString *eNs = (CMPIString*)string2CMPIString(ns.getString());
131 CMSetStatus(rc, CMPI_RC_OK);
132 return eNs;
133 }
134
135 static CMPIStatus refSetHostname(CMPIObjectPath* eRef, const char *hn)
136 {
137 CIMObjectPath* ref = (CIMObjectPath*)eRef->hdl;
138 if (!ref)
139 {
|
140 ms.aruran 1.24 PEG_TRACE_CSTRING(
141 TRC_CMPIPROVIDERINTERFACE,
142 Tracer::LEVEL2,
143 "Received invalid handle in CMPIObjectPath:refSetHostName");
|
144 venkat.puvvada 1.23 CMReturn(CMPI_RC_ERR_INVALID_HANDLE);
145 }
146 if (!hn)
147 {
|
148 ms.aruran 1.24 PEG_TRACE((
149 TRC_CMPIPROVIDERINTERFACE,
150 Tracer::LEVEL2,
151 "Received invalid parameter %s in \
|
152 kamal.locahana 1.25 CMPIObjectPath:refSetHostName", hn));
|
153 venkat.puvvada 1.23 CMReturn(CMPI_RC_ERR_INVALID_PARAMETER);
154 }
155 ref->setHost(String(hn));
156 CMReturn(CMPI_RC_OK);
157 }
158
159 static CMPIString* refGetHostname(
160 const CMPIObjectPath* eRef,
161 CMPIStatus* rc)
162 {
163 CIMObjectPath* ref = (CIMObjectPath*)eRef->hdl;
164 if (!ref)
165 {
|
166 ms.aruran 1.24 PEG_TRACE_CSTRING(
167 TRC_CMPIPROVIDERINTERFACE,
168 Tracer::LEVEL2,
169 "Received invalid handle in CMPIObjectPath:refGetHostName");
|
170 venkat.puvvada 1.23 CMSetStatus(rc, CMPI_RC_ERR_INVALID_HANDLE);
171 return NULL;
172 }
173 const String &hn = ref->getHost();
174 CMPIString *eHn = (CMPIString*)string2CMPIString(hn);
175 CMSetStatus(rc, CMPI_RC_OK);
176 return eHn;
177 }
178
179 static CMPIStatus refSetClassName(CMPIObjectPath* eRef, const char *cn)
180 {
181 CIMObjectPath* ref = (CIMObjectPath*)eRef->hdl;
182 if (!ref)
183 {
|
184 ms.aruran 1.24 PEG_TRACE_CSTRING(
185 TRC_CMPIPROVIDERINTERFACE,
186 Tracer::LEVEL2,
187 "Received invalid handle in CMPIObjectPath:refSetClassName");
|
188 venkat.puvvada 1.23 CMReturn(CMPI_RC_ERR_INVALID_HANDLE);
189 }
190 if (!cn)
191 {
|
192 ms.aruran 1.24 PEG_TRACE((
193 TRC_CMPIPROVIDERINTERFACE,
194 Tracer::LEVEL2,
195 "Received invalid parameter %s in \
|
196 kamal.locahana 1.25 CMPIObjectPath:refSetClassName", cn));
|
197 venkat.puvvada 1.23 CMReturn(CMPI_RC_ERR_INVALID_PARAMETER);
198 }
199 ref->setClassName(String(cn));
200 CMReturn(CMPI_RC_OK);
201 }
202
203 static CMPIString* refGetClassName(
204 const CMPIObjectPath* eRef,
205 CMPIStatus* rc)
206 {
207 CIMObjectPath* ref = (CIMObjectPath*)eRef->hdl;
208 if (!ref)
209 {
|
210 ms.aruran 1.24 PEG_TRACE_CSTRING(
211 TRC_CMPIPROVIDERINTERFACE,
212 Tracer::LEVEL2,
213 "Received invalid handle in CMPIObjectPath:refGetClassName");
|
214 venkat.puvvada 1.23 CMSetStatus(rc, CMPI_RC_ERR_INVALID_HANDLE);
215 return NULL;
216 }
217 const CIMName &cn = ref->getClassName();
218 CMPIString* eCn = (CMPIString*)string2CMPIString(cn.getString());
219 CMSetStatus(rc, CMPI_RC_OK);
220 return eCn;
221 }
222
223
224 static long locateKey(const Array<CIMKeyBinding> &kb, const CIMName &eName)
225 {
226 for (unsigned long i=0,s=kb.size(); i<s; i++)
227 {
228 const String &n = kb[i].getName().getString();
229 if (String::equalNoCase(n,eName.getString()))
230 {
231 return i;
232 }
233 }
234 return -1;
235 venkat.puvvada 1.23 }
236
237 static CMPIStatus refAddKey(
238 CMPIObjectPath* eRef,
239 const char *name,
240 const CMPIValue* data,
241 const CMPIType type)
242 {
243 CIMObjectPath* ref = (CIMObjectPath*)eRef->hdl;
244 if (!ref)
245 {
|
246 ms.aruran 1.24 PEG_TRACE_CSTRING(
247 TRC_CMPIPROVIDERINTERFACE,
248 Tracer::LEVEL2,
249 "Received invalid handle in CMPIObjectPath:refAddKey");
|
250 venkat.puvvada 1.23 CMReturn(CMPI_RC_ERR_INVALID_HANDLE);
251 }
252 if (!name)
253 {
|
254 ms.aruran 1.24 PEG_TRACE((
255 TRC_CMPIPROVIDERINTERFACE,
256 Tracer::LEVEL2,
257 "Received invalid parameter %s in \
|
258 kamal.locahana 1.25 CMPIObjectPath:refAddKey", name));
|
259 venkat.puvvada 1.23 CMReturn(CMPI_RC_ERR_INVALID_PARAMETER);
260 }
261 Array<CIMKeyBinding> keyBindings = ref->getKeyBindings();
262 CIMName key(name);
263 CMPIrc rc;
264
265 long i = locateKey(keyBindings,key);
266 if (i >= 0)
267 {
268 keyBindings.remove(i);
269 }
270
271 CIMValue val = value2CIMValue(data,type,&rc);
272 keyBindings.append(CIMKeyBinding(key,val));
273 ref->setKeyBindings(Array<CIMKeyBinding>(keyBindings));
274 CMReturn(CMPI_RC_OK);
275 }
276
277 static CMPIData refGetKey(
278 const CMPIObjectPath* eRef,
279 const char *name,
280 venkat.puvvada 1.23 CMPIStatus* rc)
281 {
282 CIMObjectPath* ref = (CIMObjectPath*)eRef->hdl;
283 CMPIData data = {0, CMPI_nullValue | CMPI_notFound, {0}};
284
285 if (!ref)
286 {
|
287 ms.aruran 1.24 PEG_TRACE_CSTRING(
288 TRC_CMPIPROVIDERINTERFACE,
289 Tracer::LEVEL2,
290 "Received invalid handle in CMPIObjectPath:refGetKey");
|
291 venkat.puvvada 1.23 CMSetStatus(rc, CMPI_RC_ERR_INVALID_HANDLE);
292 return data;
293 }
294 if (!name)
295 {
|
296 ms.aruran 1.24 PEG_TRACE((
297 TRC_CMPIPROVIDERINTERFACE,
298 Tracer::LEVEL2,
299 "Received invalid parameter %s in \
|
300 kamal.locahana 1.25 CMPIObjectPath:refGetKey", name));
|
301 venkat.puvvada 1.23 CMSetStatus(rc, CMPI_RC_ERR_INVALID_PARAMETER);
302 return data;
303 }
304 const CIMName eName(name);
305 const Array<CIMKeyBinding> &akb = ref->getKeyBindings();
306 CMSetStatus(rc, CMPI_RC_OK);
307
308 long i = locateKey(akb,eName);
309 if (i >= 0)
310 {
311 key2CMPIData(akb[i].getValue(),akb[i].getType(),&data);
312 return data;
313 }
314 CMSetStatus(rc, CMPI_RC_ERR_NOT_FOUND);
315 return data;
316 }
317
318 static CMPIData refGetKeyAt(
319 const CMPIObjectPath* eRef,
320 unsigned pos,
321 CMPIString** name,
322 venkat.puvvada 1.23 CMPIStatus* rc)
323 {
324 CIMObjectPath* ref = (CIMObjectPath*)eRef->hdl;
325 CMPIData data = {0, CMPI_nullValue | CMPI_notFound, {0}};
326
327 if (!ref)
328 {
|
329 ms.aruran 1.24 PEG_TRACE_CSTRING(
330 TRC_CMPIPROVIDERINTERFACE,
331 Tracer::LEVEL2,
332 "Received invalid handle in CMPIObjectPath:refGetKeyAt");
|
333 venkat.puvvada 1.23 CMSetStatus(rc, CMPI_RC_ERR_INVALID_HANDLE);
334 return data;
335 }
336
337 const Array<CIMKeyBinding> &akb = ref->getKeyBindings();
338 CMSetStatus(rc, CMPI_RC_OK);
339
340 if (pos >= akb.size())
341 {
|
342 ms.aruran 1.24 PEG_TRACE_CSTRING(
343 TRC_CMPIPROVIDERINTERFACE,
344 Tracer::LEVEL2,
345 "Property Not Found - CMPIObjectPath:refGetKeyAt");
|
346 venkat.puvvada 1.23 CMSetStatus(rc, CMPI_RC_ERR_NO_SUCH_PROPERTY);
347 return data;
348 }
349
350 key2CMPIData(akb[pos].getValue(),akb[pos].getType(),&data);
351
352 if (name)
353 {
354 const String &n = akb[pos].getName().getString();
355 *name = (CMPIString*)string2CMPIString(n);
356 }
357 return data;
358 }
359
360 static CMPICount refGetKeyCount(const CMPIObjectPath* eRef, CMPIStatus* rc)
361 {
362 CIMObjectPath* ref = (CIMObjectPath*)eRef->hdl;
363 if (!ref)
364 {
|
365 ms.aruran 1.24 PEG_TRACE_CSTRING(
366 TRC_CMPIPROVIDERINTERFACE,
367 Tracer::LEVEL2,
368 "Received invalid handle in CMPIObjectPath:refGetKeyCount");
|
369 venkat.puvvada 1.23 CMSetStatus(rc, CMPI_RC_ERR_INVALID_HANDLE);
370 return 0;
371 }
372 const Array<CIMKeyBinding> &akb = ref->getKeyBindings();
373 CMSetStatus(rc, CMPI_RC_OK);
374 return akb.size();
375 }
376
377 static CMPIStatus refSetNameSpaceFromObjectPath(
378 CMPIObjectPath* eRef,
379 const CMPIObjectPath* eSrc)
380 {
381 CIMObjectPath* ref = (CIMObjectPath*)eRef->hdl;
382 CIMObjectPath* src = (CIMObjectPath*)eSrc->hdl;
383 if (!ref || !src)
384 {
|
385 ms.aruran 1.24 PEG_TRACE_CSTRING(
386 TRC_CMPIPROVIDERINTERFACE,
387 Tracer::LEVEL2,
388 "Received invalid handle in \
389 CMPIObjectPath:refSetNameSpaceFromObjectPath");
|
390 venkat.puvvada 1.23 CMReturn(CMPI_RC_ERR_INVALID_HANDLE);
391 }
392 ref->setNameSpace(src->getNameSpace());
393 CMReturn(CMPI_RC_OK);
394 }
395
396 static CMPIStatus refSetHostAndNameSpaceFromObjectPath(
397 CMPIObjectPath* eRef,
398 const CMPIObjectPath* eSrc)
399 {
400 CIMObjectPath* ref = (CIMObjectPath*)eRef->hdl;
401 CIMObjectPath* src = (CIMObjectPath*)eSrc->hdl;
402 if (!ref || !src)
403 {
|
404 ms.aruran 1.24 PEG_TRACE_CSTRING(
405 TRC_CMPIPROVIDERINTERFACE,
406 Tracer::LEVEL2,
407 "Received invalid handle in \
408 CMPIObjectPath:refSetHostAndNameSpaceFromObjectPath");
|
409 venkat.puvvada 1.23 CMReturn(CMPI_RC_ERR_INVALID_HANDLE);
410 }
411 ref->setNameSpace(src->getNameSpace());
412 ref->setHost(src->getHost());
413 CMReturn(CMPI_RC_OK);
414 }
415
416 static CMPIString *refToString(const CMPIObjectPath* eRef, CMPIStatus* rc)
417 {
418 CIMObjectPath* ref = (CIMObjectPath*)eRef->hdl;
419 if (!ref)
420 {
|
421 ms.aruran 1.24 PEG_TRACE_CSTRING(
422 TRC_CMPIPROVIDERINTERFACE,
423 Tracer::LEVEL2,
424 "Received invalid handle in CMPIObjectPath:refToString");
|
425 venkat.puvvada 1.23 CMSetStatus(rc, CMPI_RC_ERR_INVALID_HANDLE);
426 return NULL;
427 }
428 String str = ref->toString();
429 CMSetStatus(rc, CMPI_RC_OK);
430 return reinterpret_cast<CMPIString*>(new CMPI_Object(str));
431 }
|
432 schuur 1.1
433 }
434
|
435 venkat.puvvada 1.23 CMPIObjectPathFT objectPath_FT =
436 {
437 CMPICurrentVersion,
438 refRelease,
439 refClone,
440 refSetNameSpace,
441 refGetNameSpace,
442 refSetHostname,
443 refGetHostname,
444 refSetClassName,
445 refGetClassName,
446 refAddKey,
447 refGetKey,
448 refGetKeyAt,
449 refGetKeyCount,
450 refSetNameSpaceFromObjectPath,
451 refSetHostAndNameSpaceFromObjectPath,
452 NULL,
453 NULL,
454 NULL,
455 NULL,
456 venkat.puvvada 1.23 refToString
|
457 schuur 1.1 };
458
|
459 venkat.puvvada 1.23 CMPIObjectPathFT *CMPI_ObjectPath_Ftab = &objectPath_FT;
|
460 schuur 1.1
|
461 venkat.puvvada 1.23 CMPIObjectPathFT objectPathOnStack_FT =
462 {
463 CMPICurrentVersion,
464 refReleaseNop,
465 refClone,
466 refSetNameSpace,
467 refGetNameSpace,
468 refSetHostname,
469 refGetHostname,
470 refSetClassName,
471 refGetClassName,
472 refAddKey,
473 refGetKey,
474 refGetKeyAt,
475 refGetKeyCount,
476 refSetNameSpaceFromObjectPath,
477 refSetHostAndNameSpaceFromObjectPath,
478 NULL,
479 NULL,
480 NULL,
481 NULL,
482 venkat.puvvada 1.23 refToString
|
483 schuur 1.1 };
484
|
485 venkat.puvvada 1.23 CMPIObjectPathFT *CMPI_ObjectPathOnStack_Ftab = &objectPathOnStack_FT;
|
486 schuur 1.1
487
|
488 venkat.puvvada 1.23 CMPI_ObjectPathOnStack::CMPI_ObjectPathOnStack(const CIMObjectPath& cop)
489 {
490 hdl = (void*)&cop;
491 ft = CMPI_ObjectPathOnStack_Ftab;
492 }
|
493 schuur 1.1
494
495 PEGASUS_NAMESPACE_END
496
|
Return to
CMPI_ObjectPath.cpp
CVS log
Up to [Pegasus] / pegasus / src / Pegasus / ProviderManager2 / CMPI