1/*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License, Version 1.0 only
6 * (the "License").  You may not use this file except in compliance
7 * with the License.
8 *
9 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
10 * or http://www.opensolaris.org/os/licensing.
11 * See the License for the specific language governing permissions
12 * and limitations under the License.
13 *
14 * When distributing Covered Code, include this CDDL HEADER in each
15 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
16 * If applicable, add the following below this CDDL HEADER, with the
17 * fields enclosed by brackets "[]" replaced with your own identifying
18 * information: Portions Copyright [yyyy] [name of copyright owner]
19 *
20 * CDDL HEADER END
21 */
22/*
23 * Copyright 2003 Sun Microsystems, Inc.  All rights reserved.
24 * Use is subject to license terms.
25 */
26
27#pragma ident	"%Z%%M%	%I%	%E% SMI"
28
29#include <pthread.h>
30
31#include "master.h"
32#include "util.h"
33#include "providerNames.h"
34#include "messageStrings.h"
35
36/* local function declarations */
37static int FindClassEntry(char *className);
38static int FindAssocClassEntry(char *className);
39
40
41/*
42 * Encodes the CIM schema and provider version
43 * into an unsigned long, use
44 * getProviderVersion & getCimVersion to decode
45 */
46
47unsigned long
48cp_getVersion()
49{
50	return (MAKEVERSION(1.0, 2.3));
51}
52
53
54/*
55 * The function will take CCIMObjectPath
56 * and search the classNameTable[]
57 * for a className match, and then
58 * call the corresponding cp_enumInstance
59 * for that provider
60 */
61
62CCIMInstanceList*
63cp_enumInstances(CCIMObjectPath* pOP)
64{
65	CCIMInstanceList	*instList = NULL;
66	int 			index = 0;
67	int    			error;
68
69	cim_logDebug("cp_enumInstances", "In libDispatch");
70	/* Check if ObjectPath is NULL before continuing */
71	if (pOP == NULL) {
72	    /* Set error exception with localized message */
73	    util_handleError(ENUM_INSTANCES, CIM_ERR_INVALID_PARAMETER,
74		NULL, NULL, &error);
75	    return (NULL);
76	}
77
78	/* Object path is NOT NULL, so find the entry in the table */
79	index = FindClassEntry(pOP->mName);
80
81	/* check for error (-1) */
82	if (index < 0) {
83	    util_handleError(ENUM_INSTANCES, CIM_ERR_INVALID_CLASS,
84		NULL, NULL, &error);
85	    return (NULL);
86	}
87
88	/* OK, Find enumInstance */
89	instList = (*enumInstanceTable[index])(pOP);
90	return ((CCIMInstanceList*)instList);
91
92}  /* cp_enumInstances */
93
94/* creates an instance */
95
96/*
97 * The function will take CCIMObjectPath & CCIMInstance
98 * and search the classNameTable[]
99 * for a className match, and then
100 * call the corresponding cp_createInstance
101 * for that provider
102 */
103
104CCIMObjectPath*
105cp_createInstance(CCIMObjectPath* pOP, CCIMInstance* pInst)
106{
107	CCIMObjectPath *objPath = NULL;
108	int index = 0;
109	int error;
110
111	/* check if NULL before finding the Instance to create */
112	if (pInst == NULL) {
113	    util_handleError(CREATE_INSTANCE,
114		CIM_ERR_INVALID_PARAMETER, NULL, NULL, &error);
115	    return (NULL);
116	}
117
118	/* find entry in the table */
119	index = FindClassEntry(pInst->mClassName);
120
121	/* check for error (-1) */
122	if (index < 0) {
123	    util_handleError(CREATE_INSTANCE,
124		CIM_ERR_INVALID_CLASS, NULL, NULL, &error);
125	    return (NULL);
126	}
127
128	objPath = (*createInstanceTable[index])(pOP, pInst);
129
130	return ((CCIMObjectPath*) objPath);
131
132} /* cp_createInstances */
133
134
135/*
136 * returns an array of CCIMObjectPaths for the class
137 * params:
138 * char* - the classname to enum
139 */
140
141CCIMObjectPathList*
142cp_enumInstanceNames(CCIMObjectPath* pOP)
143{
144	CCIMObjectPathList	*objList = NULL;
145	CCIMInstanceList	*instList = NULL;
146	int			error = 0;
147
148	/*
149	 * create an instance list which contains all of the
150	 * instances this provider will produce First check
151	 * for valid ObjectPath
152	 */
153	if (pOP == NULL) {
154	    util_handleError(ENUM_INSTANCENAMES,
155		CIM_ERR_INVALID_PARAMETER, NULL, NULL, &error);
156	    return (NULL);
157	}
158
159	instList = cp_enumInstances(pOP);
160
161	if (instList == NULL) {
162	    return ((CCIMObjectPathList *)NULL);
163	}
164
165	objList = cim_createObjectPathList(instList);
166
167	/*
168	 * we no longer need the instList so free
169	 * the memory allocated for it
170	 */
171
172	cim_freeInstanceList(instList);
173	return (objList);
174}
175
176/* get an instance */
177
178CCIMInstance*
179cp_getInstance(CCIMObjectPath* pOP)
180{
181	CCIMInstance* inst = NULL;
182	int	index = 0;
183	int	error;
184
185	/* Check if ObjectPath is NULL before continuing */
186	if (pOP == NULL) {
187	    util_handleError(GET_INSTANCE, CIM_ERR_INVALID_PARAMETER,
188		NULL, NULL, &error);
189	    return (NULL);
190	}
191
192	/* Object path is NOT NULL, so find the entry in the table */
193	index = FindClassEntry(pOP->mName);
194
195	/* check for error (-1) */
196	if (index < 0) {
197	    util_handleError(GET_INSTANCE, CIM_ERR_INVALID_CLASS, NULL,
198		NULL, &error);
199	    return (NULL);
200	}
201
202	inst = (*getInstanceTable[index])(pOP);
203	return ((CCIMInstance *)inst);
204}
205
206/*
207 * returns the specified property,
208 * should return NULL if not found
209 *
210 * params:
211 * CCIMObjectPath* - ObjectPath to get the property from
212 * char* - The property name to get
213 *
214 */
215
216CCIMProperty*
217cp_getProperty(CCIMObjectPath *pOP, char *pPropName)
218{
219	CCIMProperty*	prop = NULL;
220	CCIMInstance*	inst = NULL;
221	int		error;
222
223	/* See if ObjectPath is OK */
224	if (pOP == NULL) {
225	    util_handleError(GET_PROPERTY, CIM_ERR_INVALID_PARAMETER,
226		NULL, NULL, &error);
227	    return (NULL);
228	}
229
230	/* Make sure property name isn't NULL */
231	if (pPropName == NULL) {
232	    util_handleError(GET_PROPERTY, CIM_ERR_INVALID_CLASS,
233		NULL, NULL, &error);
234	    return (NULL);
235	}
236
237	/* see if we have any instances which match the obj path */
238	inst = cp_getInstance(pOP);
239
240	/* check for valid instance */
241	if (inst == NULL) {
242	    util_handleError(GET_PROPERTY, CIM_ERR_FAILED,
243		NULL, NULL, &error);
244	    return (NULL);
245	}
246
247	/* see if it has the specified property */
248	prop = cim_getProperty(inst, pPropName);
249
250	/* free memory allocated for the instance */
251	cim_freeInstance(inst);
252
253	/* return the property */
254	return ((CCIMProperty *)prop);
255}
256
257/*
258 * Sets the property in the passed in
259 * instance to the new values of the
260 * passed in property
261 *
262 * params:
263 * CCIMObjectPath* - the Object Path in which the property should be changed
264 * CCIMProperty* - a property structure which contains the new values
265 *
266 * return:
267 * cim_true if property was updated otherwise cim_false
268 *
269 *
270 * The function will take CCIMObjectPath & CCIMProperty
271 * and search the classNameTable[]
272 * for a className match, and then
273 * call the corresponding setProperty
274 * for that provider
275 */
276
277CIMBool
278cp_setProperty(CCIMObjectPath* pObjPath, CCIMProperty* pProp)
279{
280	CIMBool retVal;
281	int index = 0;
282	int	error;
283
284	if (pObjPath == NULL) {
285	    util_handleError(SET_PROPERTY, CIM_ERR_INVALID_PARAMETER,
286		NULL, NULL, &error);
287	    return (NULL);
288	}
289
290	index = FindClassEntry(pObjPath->mName);
291
292	/* check for error (-1) */
293	if (index < 0) {
294	    util_handleError(SET_PROPERTY, CIM_ERR_INVALID_CLASS,
295		NULL, NULL, &error);
296	    return (NULL);
297	}
298
299	retVal = (*setPropertyTable[index])(pObjPath, pProp);
300	return ((CIMBool)retVal);
301}
302
303
304/* sets an instance */
305
306/*
307 * The function will take CCIMObjectPath & CCIMInstance
308 * and search the classNameTable[]
309 * for a className match, and then
310 * call the corresponding cp_setInstance
311 * for that provider
312 */
313
314CIMBool
315cp_setInstance(CCIMObjectPath* pOP, CCIMInstance* pInst)
316{
317	CIMBool retVal;
318	int index = 0;
319	int	error;
320
321	if (pOP == NULL) {
322	    util_handleError(SET_INSTANCE, CIM_ERR_INVALID_PARAMETER,
323		NULL, NULL, &error);
324	    return (NULL);
325	}
326
327	if (pInst == NULL) {
328	    util_handleError(SET_INSTANCE, CIM_ERR_INVALID_CLASS,
329		NULL, NULL, &error);
330	    return (NULL);
331	}
332
333	/* get the index into the table */
334	index = FindClassEntry(pInst->mClassName);
335
336	/* check for error (-1) */
337	if (index < 0) {
338	    util_handleError(SET_INSTANCE, CIM_ERR_INVALID_CLASS,
339		NULL, NULL, &error);
340	    return (NULL);
341	}
342
343	retVal = (*setInstanceTable[index])(pOP, pInst);
344	return ((CIMBool)retVal);
345}
346
347
348/*
349 * deletes an instance
350 *
351 * The function will take CCIMObjectPath
352 * and search the classNameTable[]
353 * for a className match, and then
354 * call the corresponding cp_deleteInstance
355 * for that provider
356 */
357
358CIMBool
359cp_deleteInstance(CCIMObjectPath* pOP)
360{
361	CIMBool retVal;
362	int index = 0;
363	int	error;
364
365	/* Verify ObjectPath is NOT NULL */
366	if (pOP == NULL) {
367	    util_handleError(DELETE_INSTANCE, CIM_ERR_INVALID_PARAMETER,
368		NULL, NULL, &error);
369	    return (NULL);
370	}
371
372	/* find Entry in table */
373	index = FindClassEntry(pOP->mName);
374
375	/* check for error (-1) */
376	if (index < 0) {
377	    util_handleError(DELETE_INSTANCE, CIM_ERR_INVALID_CLASS,
378		NULL, NULL, &error);
379	    return (NULL);
380	}
381
382	retVal = (*deleteInstanceTable[index])(pOP);
383	return ((CIMBool)retVal);
384}
385
386/*
387 * Invokes the method and returns the results
388 *   The caller is responsible for freeing the
389 * memory allocated for the returned object
390 *
391 *  params:
392 * CCIMObjectPath* - An object path of the instance
393 *		to invoke the function on
394 *  char* - name of the method to invoke
395 * CCIMPropertyList* - input parameters to the function
396 * CCIMPropertyList* - input/output parameters to the function
397 *
398 * returns:
399 * NULL if it failed otherwise a CCIMProperty*
400 *    which represents the return value of the function
401 */
402
403CCIMProperty*
404cp_invokeMethod(CCIMObjectPath* pOP, cimchar* pName,
405    CCIMPropertyList* pInParams, CCIMPropertyList* pInOutParams)
406{
407	CCIMProperty *prop;
408	int index = 0;
409	int error;
410
411	/* First check for valid ObjectPath */
412	if (pOP == NULL) {
413	    util_handleError(INVOKE_METHOD, CIM_ERR_INVALID_PARAMETER,
414		NULL, NULL, &error);
415	    return (NULL);
416	}
417
418	/* find entry in the table */
419	index = FindClassEntry(pOP->mName);
420
421	/* check for error (-1) */
422	if (index < 0) {
423	    util_handleError(INVOKE_METHOD, CIM_ERR_INVALID_CLASS,
424		NULL, NULL, &error);
425	    return (NULL);
426	}
427
428	prop = (*cpInvokeMethodTable[index])
429	    (pOP, pName, pInParams, pInOutParams);
430
431	return ((CCIMProperty*)prop);
432}
433
434/*
435 * cp_execQuery
436 */
437
438CCIMInstanceList*
439cp_execQuery(CCIMObjectPath *pOP, char *selectList,
440    char *nonJoinExp, char *queryExp, char *queryType)
441{
442	CCIMInstanceList 	*instList = NULL;
443	int			index = 0;
444	int			error = 0;
445
446
447	/* First check for valid ObjectPath */
448	if (pOP == NULL) {
449	    util_handleError(EXEC_QUERY, CIM_ERR_INVALID_PARAMETER, NULL, NULL,
450		&error);
451	    return ((CCIMInstanceList *)NULL);
452	}
453
454	/* find entry in the table */
455	index = FindClassEntry(pOP->mName);
456
457	/* check for error (-1) */
458	if (index < 0) {
459	    /* Set error exception with localized message */
460	    util_handleError(EXEC_QUERY, CIM_ERR_INVALID_CLASS, NULL,
461		NULL, &error);
462	    return ((CCIMInstanceList *)NULL);
463	}
464	instList = (*execQueryTable[index])(pOP, selectList, nonJoinExp,
465	    queryExp, queryType);
466
467	return (instList);
468}
469
470/*
471 * cp_associators
472 */
473
474CCIMInstanceList*
475cp_associators(CCIMObjectPath *pAssocName, CCIMObjectPath *pObjectName,
476    char *pResultClass, char *pRole, char *pResultRole)
477{
478	CCIMInstanceList 	*instList;
479	int			index = 0;
480	int			error = 0;
481
482	/* First check for valid ObjectPath */
483	if (pAssocName == NULL) {
484	    /* Set error exception with localized message */
485	    util_handleError(ASSOCIATORS, CIM_ERR_INVALID_PARAMETER, NULL,
486		NULL, &error);
487	    return ((CCIMInstanceList *)NULL);
488	}
489
490	/* find entry in the table */
491	index = FindAssocClassEntry(pAssocName->mName);
492
493	/* check for error (-1) */
494	if (index < 0) {
495	    /* Set error exception with localized message */
496	    util_handleError(ASSOCIATORS, CIM_ERR_INVALID_CLASS, NULL,
497		NULL, &error);
498	    return ((CCIMInstanceList *)NULL);
499	}
500
501	/*
502	 * Call the appropriate associator function. Let the specific function
503	 * in the c provider handle the checking for correctness of the
504	 * other parameters.
505	 */
506
507	instList = (*associatorsTable[index])(pAssocName, pObjectName,
508	    pResultClass, pRole, pResultRole);
509	return ((CCIMInstanceList *)instList);
510}
511
512/*
513 * cp_associatorNames
514 */
515
516CCIMObjectPathList*
517cp_associatorNames(CCIMObjectPath *pAssocName, CCIMObjectPath *pObjectName,
518    char *pResultClass, char *pRole, char *pResultRole)
519{
520	CCIMObjectPathList 	*objList;
521	int			index = 0;
522	int			error = 0;
523
524	/* First check for valid ObjectPath */
525	if (pAssocName == NULL) {
526	    /* Set error exception with localized message */
527	    util_handleError(ASSOCIATORS, CIM_ERR_INVALID_PARAMETER, NULL,
528		NULL, &error);
529	    return ((CCIMObjectPathList *)NULL);
530	}
531
532	/* find entry in the table */
533	index = FindAssocClassEntry(pAssocName->mName);
534
535	/* check for error (-1) */
536	if (index < 0) {
537	    /* Set error exception with localized message */
538	    util_handleError(ASSOCIATORS, CIM_ERR_INVALID_CLASS, NULL,
539		NULL, &error);
540	    return ((CCIMObjectPathList *)NULL);
541	}
542
543	/*
544	 * Call the appropriate associatorName function. Let the specific
545	 * function in the c provider handle the checking for correctness of
546	 * the other parameters.
547	 */
548
549	objList = (*associatorNamesTable[index])(pAssocName, pObjectName,
550	    pResultClass, pRole, pResultRole);
551	return ((CCIMObjectPathList *)objList);
552}
553
554/*
555 * cp_references
556 */
557
558CCIMInstanceList*
559cp_references(CCIMObjectPath *pAssocName, CCIMObjectPath *pObjectName,
560    char *pRole)
561{
562	CCIMInstanceList 	*instList;
563	int			index = 0;
564	int			error = 0;
565
566	/* First check for valid ObjectPath */
567	if (pAssocName == NULL) {
568	    /* Set error exception with localized message */
569	    util_handleError(REFERENCES, CIM_ERR_INVALID_PARAMETER, NULL,
570		NULL, &error);
571	    return ((CCIMInstanceList *)NULL);
572	}
573
574	/* find entry in the table */
575	index = FindAssocClassEntry(pAssocName->mName);
576
577	/* check for error (-1) */
578	if (index < 0) {
579	    /* Set error exception with localized message */
580	    util_handleError(REFERENCES, CIM_ERR_INVALID_CLASS, NULL,
581		NULL, &error);
582	    return ((CCIMInstanceList *)NULL);
583	}
584
585	/*
586	 * Call the appropriate references function. Let the specific function
587	 * in the c provider handle the checking for correctness of the
588	 * other parameters.
589	 */
590
591	instList = (*referencesTable[index])(pAssocName, pObjectName, pRole);
592	return ((CCIMInstanceList *)instList);
593}
594
595/*
596 * InParam: Class Name
597 * Returns: Index into Name Table
598 * If it hit libWBEMnfs, then we
599 * have hit bottom, return err (-1)
600 */
601
602static int
603FindClassEntry(char *className)
604{
605	int i = 0;
606
607	while (strcasecmp(className, classNameTable[i])) {
608		if (!strcasecmp(classNameTable[i], "libWBEMnfs")) {
609			i = -1;
610			break;
611		}
612		i++;
613	}
614
615	return (i);
616}
617/*
618 * InParam: Class Name
619 * Returns: Index into Name Table
620 * If it hit libWBEMnfs, then we
621 * have hit bottom, return err (-1)
622 */
623
624static int
625FindAssocClassEntry(char *className)
626{
627	int i = 0;
628
629	while (strcasecmp(className, assocclassNameTable[i])) {
630		if (!strcasecmp(assocclassNameTable[i], "libWBEMnfs")) {
631			i = -1;
632			break;
633		}
634		i++;
635	}
636
637	return (i);
638}
639
640/*
641 * cp_referenceNames
642 */
643
644CCIMObjectPathList*
645cp_referenceNames(CCIMObjectPath *pAssocName, CCIMObjectPath *pObjectName,
646    char *pRole)
647{
648	CCIMObjectPathList 	*objList;
649	int			index = 0;
650	int			error = 0;
651
652	/* First check for valid ObjectPath */
653	if (pAssocName == NULL) {
654	    /* Set error exception with localized message */
655	    util_handleError(REFERENCE_NAMES, CIM_ERR_INVALID_PARAMETER,
656		NULL, NULL, &error);
657	    return ((CCIMObjectPathList *)NULL);
658	}
659
660	/* find entry in the table */
661	index = FindAssocClassEntry(pAssocName->mName);
662
663	/* check for error (-1) */
664	if (index < 0) {
665	    /* Set error exception with localized message */
666	    util_handleError(REFERENCE_NAMES, CIM_ERR_INVALID_CLASS,
667		NULL, NULL, &error);
668	    return ((CCIMObjectPathList *)NULL);
669	}
670
671	/*
672	 * Call the appropriate referenceName function. Let the specific
673	 * function in the c provider handle the checking for correctness of
674	 * the other parameters.
675	 */
676
677	objList = (*referenceNamesTable[index])(pAssocName, pObjectName, pRole);
678	return ((CCIMObjectPathList *)objList);
679}
680
681CIMBool
682cp_isAssociatorProvider(CCIMObjectPath *pOp)
683{
684
685	int 		index = 0;
686	int			error = 0;
687
688	/*
689	 * If the object path coming in matches any in the associator table,
690	 * return true, otherwise, return false.
691	 */
692
693	/* First check for valid ObjectPath */
694	if (pOp == NULL) {
695	    /* Set error exception with localized message */
696	    util_handleError(REFERENCE_NAMES, CIM_ERR_INVALID_PARAMETER,
697		NULL, NULL, &error);
698	    return (cim_false);
699	}
700
701	/* find entry in the table */
702	index = FindAssocClassEntry(pOp->mName);
703
704	if (index < 0) {
705	    return (cim_false);
706	}
707	return (cim_true);
708}
709