?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge remote-tracking branch 'origin/master'
[unleashed/lotheac.git] / usr / src / lib / libima / common / ima-lib.c
blob2c8c70576d56e8d8060ff456a86511c753ef320a
1 /*
2 * Description
3 * ImaLib.c - Implements a sample common IMA library
4 *
5 * License:
6 * The contents of this file are subject to the SNIA Public License
7 * Version 1.0(the "License"); you may not use this file except in
8 * compliance with the License. You may obtain a copy of the License at
9 *
10 * /http://www.snia.org/English/Resources/Code/OpenSource.html
11 *
12 * Software distributed under the License is distributed on an "AS IS"
13 * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
14 * the License for the specific language governing rights and limitations
15 * under the License.
16 *
17 * The Original Code is SNIA HBA API and IMA general header file
18 *
19 * The Initial Developer of the Original Code is:
20 * Benjamin F. Kuo, Troika Networks, Inc. (benk@troikanetworks.com)
21 * David Dillard VERITAS Software david.dillard@veritas.com
22 *
23 * Contributor(s):
24 * Jeff Ding, Adaptec, Inc. (jding@corp.adaptec.com)
25 *
26 * Changes:
27 * 09/24/2003 Initial Draft
28 * (for other changes... see the CVS logs)
29 *
30 * 12/15/2003 corrected the defined parameter in IMA_SetPhbaIsnsDiscovery().
31 * lower case the computer name as iscsi name in IMA_GenerateNodeName().
32 *
33 * 01/21/2005 Updated to support IMA 1.1.3.
34 */
35
36 #ifdef WIN32
37 #include <windows.h>
38 #else
39 #include <sys/sem.h>
40 #include <dlfcn.h>
41 #include <stdarg.h>
42 #endif
43
44 #include <string.h>
45 #include <strings.h>
46 #include <stdlib.h>
47 // #include <sys/sem.h>
48 #include <unistd.h>
49 #include <time.h>
50 #include <stdio.h>
51 #include <sys/types.h>
52 // #include <sys/ipc.h>
53 #include <netdb.h>
54
55 #include "libsun_ima.h"
56 #include "ima.h"
57 #include "ima-plugin.h"
58
59
60 #define LIBRARY_PROPERTY_SUPPORTED_IMA_VERSION 1
61 #define LIBRARY_PROPERTY_IMPLEMENTATION_VERSION L"1.0.2"
62 #define LIBRARY_PROPERTY_VENDOR L"QLogic, Inc."
63 #define DEFAULT_NODE_NAME_FORMAT "iqn.1986-03.com.sun.central.%s"
64
65 /* Linux only */
66 #define LIBRARY_FILE_NAME L"libima.so"
67
68 #define EUOS_ERROR IMA_ERROR_UNEXPECTED_OS_ERROR
69
70 IMA_PLUGIN_INFO plugintable[IMA_MAX_NUM_PLUGINS];
71 int number_of_plugins = -1;
72 static IMA_NODE_NAME sharedNodeName;
73 static IMA_NODE_ALIAS sharedNodeAlias;
74
75 #ifdef WIN32
76 static HANDLE libMutex = NULL;
77 #else
78 int libMutex = -1;
79 #endif
80
81 void InitLibrary();
82 void ExitLibrary();
83
84 static void libSwprintf(wchar_t *wcs, const wchar_t *lpszFormat, ...) {
85 va_list args;
86 va_start(args, lpszFormat);
87
88 #ifdef WIN32
89 vswprintf(wcs, lpszFormat, args);
90 #else
91 vswprintf(wcs, 255, lpszFormat, args);
92 #endif
93 va_end(args);
94 }
95
96
97 #ifdef WIN32
98 /* Begin implementation */
99 BOOL APIENTRY DllMain(HANDLE hModule,
100 DWORD ul_reason_for_call,
101 LPVOID lpReserved) {
102 switch (ul_reason_for_call) {
103
104 case DLL_PROCESS_ATTACH:
105 // InitLibrary();
106 break;
107 case DLL_PROCESS_DETACH:
108 ExitLibrary();
109 break;
110 case DLL_THREAD_ATTACH:
111 case DLL_THREAD_DETACH:
112 break;
113 }
114 return (TRUE);
115 }
116 #elif defined(SOLARIS)
117
118 void so_init(void);
119 void so_fini(void);
120 static int os_createmutex(int *semid);
121 static void os_obtainmutex(int semid);
122 static void os_releasemutex(int semid);
123 static void os_destroymutex(int semid);
124 static IMA_STATUS getSolarisNodeProps(IMA_NODE_PROPERTIES *nodeProps);
125 static IMA_STATUS getSolarisSharedNodeName(IMA_NODE_NAME name);
126 static IMA_STATUS getSolarisSharedNodeAlias(IMA_NODE_ALIAS alias);
127 static IMA_STATUS setSolarisSharedNodeName(const IMA_NODE_NAME name);
128 static IMA_STATUS setSolarisSharedNodeAlias(const IMA_NODE_ALIAS alias);
129
130 #pragma init(so_init)
131 #pragma fini(so_fini)
132
133 void so_init() {
134 InitLibrary();
135 }
136 void so_fini() {
137 ExitLibrary();
138 }
139
140 static IMA_STATUS getSolarisNodeProps(IMA_NODE_PROPERTIES *nodeProps) {
141 int ret;
142 int i;
143 IMA_STATUS status = IMA_ERROR_UNKNOWN_ERROR;
144 IMA_GetNodePropertiesFn PassFunc;
145 IMA_OID nodeOid;
146
147 if (number_of_plugins == -1)
148 InitLibrary();
149
150 os_obtainmutex(libMutex);
151 status = IMA_ERROR_OBJECT_NOT_FOUND;
152
153 for (i = 0; i < number_of_plugins; i++) {
154 if (strstr(plugintable[i].PluginPath,
155 "libsun_ima.so") == NULL) {
156 continue;
157 }
158 status = IMA_ERROR_UNEXPECTED_OS_ERROR;
159 if (plugintable[i].hPlugin != NULL) {
160 os_obtainmutex(plugintable[i].pluginMutex);
161 PassFunc =
162 (IMA_GetNodePropertiesFn) dlsym(
163 plugintable[i].hPlugin,
164 "IMA_GetNodeProperties");
165 if (PassFunc != NULL) {
166 status = PassFunc(nodeOid, nodeProps);
167 }
168 os_releasemutex(plugintable[i].pluginMutex);
169 }
170 break;
171 }
172
173 os_releasemutex(libMutex);
174 return (status);
175 }
176
177 static IMA_STATUS getSolarisSharedNodeName(IMA_NODE_NAME name) {
178 IMA_STATUS status = IMA_ERROR_UNKNOWN_ERROR;
179 IMA_NODE_PROPERTIES nodeProps;
180
181 status = getSolarisNodeProps(&nodeProps);
182 if (status != IMA_STATUS_SUCCESS) {
183 return (status);
184 }
185 bcopy(&nodeProps.name, name, sizeof (IMA_NODE_NAME));
186 return (status);
187 }
188
189 static IMA_STATUS getSolarisSharedNodeAlias(IMA_NODE_ALIAS alias) {
190 IMA_STATUS status = IMA_ERROR_UNKNOWN_ERROR;
191 IMA_NODE_PROPERTIES nodeProps;
192
193 status = getSolarisNodeProps(&nodeProps);
194 if (status != IMA_STATUS_SUCCESS) {
195 return (status);
196 }
197 bcopy(&nodeProps.alias, alias, sizeof (IMA_NODE_ALIAS));
198 return (status);
199 }
200
201 static IMA_STATUS setSolarisSharedNodeName(const IMA_NODE_NAME name) {
202 int ret;
203 int i;
204 IMA_STATUS status = IMA_ERROR_UNKNOWN_ERROR;
205 IMA_NODE_PROPERTIES nodeProps;
206 IMA_SetNodeNameFn PassFunc;
207 IMA_OID nodeOid;
208
209 if (number_of_plugins == -1)
210 InitLibrary();
211
212 os_obtainmutex(libMutex);
213 status = IMA_ERROR_OBJECT_NOT_FOUND;
214
215 for (i = 0; i < number_of_plugins; i++) {
216 if (strstr(plugintable[i].PluginPath,
217 "libsun_ima.so") == NULL) {
218 continue;
219 }
220 status = IMA_ERROR_UNEXPECTED_OS_ERROR;
221 if (plugintable[i].hPlugin != NULL) {
222 os_obtainmutex(plugintable[i].pluginMutex);
223 PassFunc =
224 (IMA_SetNodeNameFn) dlsym(plugintable[i].hPlugin,
225 "IMA_SetNodeName");
226 if (PassFunc != NULL) {
227 status = PassFunc(nodeOid, name);
228 }
229 os_releasemutex(plugintable[i].pluginMutex);
230 }
231 break;
232 }
233
234 os_releasemutex(libMutex);
235 return (status);
236 }
237
238 static IMA_STATUS setSolarisSharedNodeAlias(const IMA_NODE_ALIAS alias) {
239 int ret;
240 int i;
241 IMA_STATUS status = IMA_ERROR_UNKNOWN_ERROR;
242 IMA_NODE_PROPERTIES nodeProps;
243 IMA_SetNodeAliasFn PassFunc;
244 IMA_OID nodeOid;
245
246 if (number_of_plugins == -1)
247 InitLibrary();
248
249 os_obtainmutex(libMutex);
250 status = IMA_ERROR_OBJECT_NOT_FOUND;
251
252 for (i = 0; i < number_of_plugins; i++) {
253 if (strstr(plugintable[i].PluginPath,
254 "libsun_ima.so") == NULL) {
255 continue;
256 }
257 status = IMA_ERROR_UNEXPECTED_OS_ERROR;
258 if (plugintable[i].hPlugin != NULL) {
259 os_obtainmutex(plugintable[i].pluginMutex);
260 PassFunc =
261 (IMA_SetNodeAliasFn) dlsym(plugintable[i].hPlugin,
262 "IMA_SetNodeAlias");
263 if (PassFunc != NULL) {
264 status = PassFunc(nodeOid, alias);
265 }
266 os_releasemutex(plugintable[i].pluginMutex);
267 }
268 break;
269 }
270
271 os_releasemutex(libMutex);
272 return (status);
273 }
274
275 #else
276 /*
277 * add code in .init and .fini,
278 * "__attribute__ ((constructor))" and "__attribute__ ((destructor))"
279 * are used with gcc
280 */
281 __attribute__((constructor)) void init()
282 {
283 InitLibrary();
284 }
285
286 __attribute__((destructor)) void fini()
287 {
288 ExitLibrary();
289 }
290
291 #endif
292
293
294 #ifdef WIN32
295
296 static BOOL os_createmutex(HANDLE Mutex) {
297 Mutex = CreateMutex(NULL, FALSE, NULL);
298
299 if (Mutex == NULL) {
300 return (FALSE);
301 }
302
303 return (TRUE);
304 }
305
306 static void os_destroymutex(HANDLE Mutex) {
307 if (Mutex != NULL) {
308 CloseHandle(Mutex);
309 }
310 }
311
312
313 static void os_obtainmutex(HANDLE Mutex) {
314 WaitForSingleObject(Mutex, INFINITE);
315 }
316
317 static void os_releasemutex(HANDLE Mutex) {
318 ReleaseMutex(Mutex);
319 }
320
321 #else
322 #if defined(__GNU_LIBRARY__) && !defined(_SEM_SEMUN_UNDEFINED)
323 /* <sys/sem.h> */
324 #else
325 union semun {
326 int val; /* value for SETVAL */
327 struct semid_ds *bf; /* buffer for IPC_STAT, IPC_SET */
328 unsigned short int *array; /* array for GETALL, SETALL */
329 struct seminfo *__buf; /* buffer for IPC_INFO */
330 };
331 #endif
332
333 /* Create the semaphore. Return 1 if successful, 0 otherwise */
334 static int os_createmutex(int *semid) {
335 int retVal;
336 union semun sem_union;
337
338 if (semid == NULL) {
339 return (0);
340 }
341
342 retVal = semget(IPC_PRIVATE, 1, IPC_CREAT);
343 if (retVal == -1) {
344 return (0);
345 }
346
347 *semid = retVal; /* save key of created semaphore */
348 sem_union.val = 1; /* start semaphore off signaled */
349 retVal = semctl(*semid, 0, SETVAL, sem_union);
350 if (retVal == -1) {
351 return (0);
352 }
353
354 return (1);
355 }
356
357 static void
358 os_obtainmutex(int semid)
359 {
360 struct sembuf sem_b;
361
362 sem_b.sem_num = 0;
363 sem_b.sem_op = -1;
364 sem_b.sem_flg = SEM_UNDO;
365 (void) semop(semid, &sem_b, 1);
366 }
367
368 static void
369 os_releasemutex(int semid)
370 {
371 struct sembuf sem_b;
372
373 sem_b.sem_num = 0;
374 sem_b.sem_op = 1;
375 sem_b.sem_flg = SEM_UNDO;
376 (void) semop(semid, &sem_b, 1);
377 }
378
379 /* Destroy the SNMP semaphore. */
380 static void
381 os_destroymutex(int semid)
382 {
383 union semun sem_union;
384
385 (void) semctl(semid, 0, IPC_RMID, sem_union);
386 }
387 #endif
388
389
390 void InitLibrary() {
391
392 FILE *imaconf;
393 char fullline[512]; /* Full line read in from IMA.conf */
394 char pluginname[64]; /* Read in from file IMA.conf */
395 char pluginpath[256]; /* Read in from file IMA.conf */
396 char imaConfFilePath[256];
397 char systemPath[256];
398 char *charPtr;
399 IMA_UINT i = 0;
400
401 if (number_of_plugins != -1)
402 return;
403
404 number_of_plugins = 0;
405
406 if (os_createmutex(&libMutex) == 0) {
407 return;
408 }
409 os_obtainmutex(libMutex);
410
411 sharedNodeAlias[0] = 0;
412
413 /* Open configuration file from known location */
414 #ifdef WIN32
415 if (GetSystemDirectory(systemPath, sizeof (systemPath)))
416 sprintf(imaConfFilePath, "%s\\drivers\\etc\\ima.conf",
417 systemPath);
418 else
419 strcpy(imaConfFilePath, "ima.conf");
420 #else
421 strcpy(imaConfFilePath, "/etc/ima.conf");
422 #endif
423
424 if ((imaconf = fopen(imaConfFilePath, "r")) == NULL) {
425 os_releasemutex(libMutex);
426 return;
427 }
428 /* Read in each line and load library */
429 while ((imaconf != NULL) &&
430 (fgets(fullline, sizeof (fullline), imaconf))) {
431 if ((fullline[0] != '#') && (fullline[0] != '\n')) {
432 /* Take out the '\n' */
433 if ((charPtr = (char *)strchr(fullline, '\n')) != NULL)
434 *charPtr = '\0';
435
436 /* look for the first tab */
437 if ((charPtr = (char *)strchr(fullline, '\t')) == NULL)
438 charPtr = (char *)strchr(fullline, ' ');
439
440 /* Set Null termination for library name if found */
441 if (charPtr != NULL) {
442 *charPtr++ = '\0';
443 /*
444 * Skip spaces and tabs until
445 * the next character found
446 */
447 while ((*charPtr == ' ') || (*charPtr == '\t'))
448 charPtr++;
449 }
450 else
451 continue; /* May be invalid entry */
452
453 /* Copy library name and path */
454 strcpy(pluginname, fullline);
455 strcpy(pluginpath, charPtr);
456
457 /*
458 * Continue to the next line if library name or
459 * path is invalid
460 */
461 if ((strlen(pluginname) == 0) ||
462 (strlen(pluginpath) == 0))
463 continue;
464
465 #ifdef WIN32
466 /* Load the DLL now */
467 plugintable[i].hPlugin = LoadLibrary(pluginpath);
468 #else
469 /* Load the DLL now */
470 plugintable[i].hPlugin = dlopen(pluginpath, RTLD_LAZY);
471 #endif
472 if (plugintable[i].hPlugin != NULL) {
473 typedef int (*InitializeFn)();
474 InitializeFn PassFunc;
475
476 memcpy((char *)&plugintable[i].PluginName,
477 (char *)&pluginname, 64);
478 memcpy((char *)
479 &plugintable[i].PluginPath,
480 (char *)&pluginpath, 256);
481 plugintable[i].ownerId = i + 1;
482
483 #ifdef WIN32
484 PassFunc = (InitializeFn)
485 GetProcAddress(
486 plugintable[i].hPlugin, "Initialize");
487 #else
488 PassFunc = (InitializeFn)
489 dlsym(
490 plugintable[i].hPlugin, "Initialize");
491 #endif
492 if (PassFunc != NULL) {
493 (void) PassFunc(plugintable[i].ownerId);
494 }
495
496 plugintable[i].number_of_vbcallbacks = 0;
497 plugintable[i].number_of_pccallbacks = 0;
498 os_createmutex(&(plugintable[i].pluginMutex));
499 i++;
500 }
501 }
502 }
503 number_of_plugins = i;
504 os_releasemutex(libMutex);
505 }
506
507
508 void ExitLibrary() {
509 IMA_UINT j;
510 IMA_UINT i;
511
512 if (number_of_plugins == -1)
513 return;
514
515 os_obtainmutex(libMutex);
516 for (i = 0; i < number_of_plugins; i++) {
517 if (plugintable[i].hPlugin != NULL) {
518 TerminateFn ExitPassFunc;
519
520 os_obtainmutex(plugintable[i].pluginMutex);
521 for (j = 0; j < plugintable[i].number_of_vbcallbacks;
522 j++) {
523 #define IMA_DFOBC_STR "IMA_DeregisterForObjectVisibilityChangesFn"
524 IMA_DeregisterForObjectVisibilityChangesFn
525 PassFunc;
526 #ifdef WIN32
527 PassFunc =
528 (IMA_DeregisterForObjectVisibilityChangesFn)
529 GetProcAddress(plugintable[i].hPlugin,
530 IMA_DFOBC_STR);
531 #else
532 PassFunc =
533 (IMA_DeregisterForObjectVisibilityChangesFn)
534 dlsym(plugintable[i].hPlugin,
535 IMA_DFOBC_STR);
536 #endif
537 if (PassFunc != NULL) {
538 PassFunc(plugintable[i].vbcallback[j]);
539 }
540 #undef IMA_DFOBC_STR
541 }
542 plugintable[i].number_of_vbcallbacks = 0;
543
544 for (j = 0; j < plugintable[i].number_of_pccallbacks;
545 j++) {
546 IMA_DeregisterForObjectPropertyChangesFn
547 PassFunc;
548 #ifdef WIN32
549 PassFunc =
550 (IMA_DeregisterForObjectPropertyChangesFn)
551 GetProcAddress(plugintable[i].hPlugin,
552 "IMA_DeregisterForObjectPropertyChangesFn");
553 #else
554 PassFunc =
555 (IMA_DeregisterForObjectPropertyChangesFn)
556 dlsym(plugintable[i].hPlugin,
557 "IMA_DeregisterForObjectPropertyChangesFn");
558 #endif
559 if (PassFunc != NULL) {
560 PassFunc(plugintable[i].pccallback[j]);
561 }
562 }
563 plugintable[i].number_of_pccallbacks = 0;
564
565 #ifdef WIN32
566 ExitPassFunc =
567 (TerminateFn) GetProcAddress
568 (plugintable[i].hPlugin, "Terminate");
569 #else
570 ExitPassFunc = (TerminateFn)
571 dlsym(plugintable[i].hPlugin, "Terminate");
572 #endif
573 if (ExitPassFunc != NULL) {
574 ExitPassFunc();
575 }
576 #ifdef WIN32
577 /* Unload DLL from memory */
578 FreeLibrary(plugintable[i].hPlugin);
579 #else
580 /* Unload DLL from memory */
581 dlclose(plugintable[i].hPlugin);
582 #endif
583 os_releasemutex(plugintable[i].pluginMutex);
584 os_destroymutex(plugintable[i].pluginMutex);
585 }
586 }
587 number_of_plugins = -1;
588 os_releasemutex(libMutex);
589 os_destroymutex(libMutex);
590 }
591
592
593 static void VisibilityCallback(
594 IMA_BOOL becomingVisible,
595 IMA_OID objectId) {
596 IMA_UINT i, j;
597 os_obtainmutex(libMutex);
598 for (i = 0; i < number_of_plugins; i++) {
599 if ((plugintable[i].hPlugin != NULL) &&
600 (objectId.ownerId == plugintable[i].ownerId)) {
601 os_obtainmutex(plugintable[i].pluginMutex);
602 for (j = 0;
603 j < plugintable[i].number_of_vbcallbacks;
604 j++) {
605 (plugintable[i].vbcallback[j])
606 (becomingVisible, objectId);
607 }
608 os_releasemutex(plugintable[i].pluginMutex);
609 }
610 }
611 os_releasemutex(libMutex);
612
613 }
614
615 static void PropertyCallback(
616 IMA_OID objectId) {
617 IMA_UINT i, j;
618
619 os_obtainmutex(libMutex);
620 for (i = 0; i < number_of_plugins; i++) {
621 if ((plugintable[i].hPlugin != NULL) &&
622 (objectId.ownerId == plugintable[i].ownerId)) {
623 os_obtainmutex(plugintable[i].pluginMutex);
624 for (j = 0;
625 j < plugintable[i].number_of_pccallbacks;
626 j++) {
627 (plugintable[i].pccallback[j])(objectId);
628 }
629 os_releasemutex(plugintable[i].pluginMutex);
630 }
631 }
632 os_releasemutex(libMutex);
633 }
634
635 /*
636 * Gets the date and time, in the form of an IMA_DATETIME, from the build
637 * script when compiled.
638 */
639 static void GetBuildTime(IMA_DATETIME* pdatetime) {
640
641 #ifdef WIN32
642 char *dayToken[] = {"Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"};
643 char *monthToken[] = {"Jan", "Feb", "Mar", "Apr", "May", "Jun",
644 "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"};
645 char monthString[4];
646 char dayString[4];
647 int i;
648
649 sscanf(__TIME__, "%u:%u:%u", &pdatetime->tm_hour,
650 &pdatetime->tm_min, &pdatetime->tm_sec);
651 sscanf(__DATE__, "%s %u %u", monthString,
652 &pdatetime->tm_mday, &pdatetime->tm_year);
653 sscanf(__TIMESTAMP__, "%s", dayString);
654
655 pdatetime->tm_year -= 1900;
656 pdatetime->tm_isdst = -1;
657
658 pdatetime->tm_wday = 0;
659 for (i = 0; i < 7; i++) {
660 if (strcmp(dayToken[i], dayString) == 0) {
661 pdatetime->tm_wday = i;
662 break;
663 }
664 }
665
666 pdatetime->tm_mon = 0;
667 for (i = 0; i < 12; i++) {
668 if (strcmp(monthToken[i], monthString) == 0) {
669 pdatetime->tm_mon = i;
670 break;
671 }
672 }
673
674 #else
675 #if defined(BUILD_DATE)
676 if (strptime(BUILD_DATE, "%Y/%m/%d %T %Z", pdatetime) == NULL) {
677 memset(pdatetime, 0, sizeof (IMA_DATETIME));
678 }
679 #else
680 memset(pdatetime, 0, sizeof (IMA_DATETIME));
681 #endif
682 #endif
683
684 }
685
686
687
688 /*
689 * Gets the properties of the IMA library that is being used.
690 *
691 * @param pProps A pointer to an @ref IMA_LIBRARY_PROPERTIES structure
692 * allocated by the caller. On successful return this structure will
693 * contain the properties of the IMA library.
694 * @return An IMA_STATUS indicating if the operation was successful or if
695 * an error occurred.
696 * @retval IMA_SUCCESS Returned if the library properties were successfully
697 * returned.
698 * @retval IMA_ERROR_INVALID_PARAMETER Returned if @a pProps is NULL or
699 * specifies a memory area to which data cannot be written.
700 */
701 IMA_API IMA_STATUS IMA_GetLibraryProperties(
702 IMA_LIBRARY_PROPERTIES *pProps) {
703
704 char imaPath[256];
705 #ifdef WIN32
706 HMODULE imaHandle;
707 #endif
708
709 if (number_of_plugins == -1)
710 InitLibrary();
711
712 if (pProps == NULL)
713 return (IMA_ERROR_INVALID_PARAMETER);
714
715 // Fill in the library properties.
716 GetBuildTime(&pProps->buildTime);
717 pProps->supportedImaVersion = LIBRARY_PROPERTY_SUPPORTED_IMA_VERSION;
718 libSwprintf(pProps->implementationVersion, L"%ls",
719 LIBRARY_PROPERTY_IMPLEMENTATION_VERSION);
720 libSwprintf(pProps->vendor, L"%ls", LIBRARY_PROPERTY_VENDOR);
721
722
723 #ifdef WIN32
724 imaHandle = GetModuleHandleA("ima");
725 imaPath[0] = 0;
726 if (imaHandle != NULL) {
727 GetModuleFileNameA(imaHandle, imaPath, 256);
728 }
729 MultiByteToWideChar(CP_ACP, 0, imaPath, -1,
730 pProps->fileName, 256);
731 #else
732 libSwprintf(pProps->fileName, LIBRARY_FILE_NAME);
733
734 // mbstowcs(pProps->fileName, imaPath, 256);
735 #endif
736
737 return (IMA_STATUS_SUCCESS);
738 }
739
740
741 /*
742 * Gets a list of the object IDs of all currently loaded plugins.
743 *
744 * @param ppList A pointer to a pointer to an @ref IMA_OID_LIST.
745 * On successful return this will contain a pointer to an @ref
746 * IMA_OID_LIST which contains the object IDs of all of the plugins
747 * currently loaded by the library.
748 * @return An IMA_STATUS indicating if the operation was successful
749 * or if an error occurred.
750 * @retval IMA_SUCCESS Returned if the plugin ID list was successfully
751 * returned.
752 * @retval IMA_ERROR_INVALID_PARAMETER Returned if @a ppList is NULL or
753 * specifies a memory area to which data cannot be written.
754 */
755 IMA_API IMA_STATUS IMA_GetPluginOidList(
756 IMA_OID_LIST **ppList) {
757 IMA_UINT i;
758
759
760 if (number_of_plugins == -1)
761 InitLibrary();
762
763 if (ppList == NULL)
764 return (IMA_ERROR_INVALID_PARAMETER);
765
766 os_obtainmutex(libMutex);
767
768 *ppList = (IMA_OID_LIST*)calloc(1, sizeof (IMA_OID_LIST) +
769 (number_of_plugins - 1) * sizeof (IMA_OID));
770
771 if ((*ppList) == NULL)
772 return (IMA_ERROR_UNEXPECTED_OS_ERROR);
773
774 (*ppList)->oidCount = number_of_plugins;
775
776 for (i = 0; i < number_of_plugins; i++) {
777
778 (*ppList)->oids[i].objectType = IMA_OBJECT_TYPE_PLUGIN;
779 (*ppList)->oids[i].ownerId = plugintable[i].ownerId;
780 (*ppList)->oids[i].objectSequenceNumber = 0;
781
782 }
783 os_releasemutex(libMutex);
784 return (IMA_STATUS_SUCCESS);
785 }
786
787
788
789
790 /*
791 * Gets the properties of the specified vendor plugin.
792 *
793 * @param pluginId The ID of the plugin whose properties are being retrieved.
794 * @param pProps A pointer to an @ref IMA_PLUGIN_PROPERTIES structure
795 * allocated by the caller. On successful return this will contain the
796 * properties of the plugin specified by pluginId.
797 * @return An IMA_STATUS indicating if the operation was successful or if
798 * an error occurred.
799 * @retval IMA_SUCCESS Returned if the plugin properties were successfully
800 * returned.
801 * @retval IMA_ERROR_INVALID_OBJECT_TYPE Returned if @a pluginId does not
802 * specify any valid object type.
803 * @retval IMA_ERROR_INCORRECT_OBJECT_TYPE Returned if @a pluginId does not
804 * specify a plugin object.
805 * @retval IMA_ERROR_OBJECT_NOT_FOUND Returned if @a pluginId refers to a
806 * plugin, but not one that is currently loaded.
807 * @retval IMA_ERROR_INVALID_PARAMETER Returned if @a pProps is NULL or
808 * specify a memory area to which data cannot be written.
809 */
810 IMA_API IMA_STATUS IMA_GetPluginProperties(
811 IMA_OID pluginOid,
812 IMA_PLUGIN_PROPERTIES *pProps) {
813 IMA_GetPluginPropertiesFn PassFunc;
814 IMA_UINT i;
815 IMA_STATUS status;
816
817 if (number_of_plugins == -1)
818 InitLibrary();
819
820 if (pProps == NULL)
821 return (IMA_ERROR_INVALID_PARAMETER);
822
823 if ((pluginOid.objectType != IMA_OBJECT_TYPE_PLUGIN) ||
824 (pluginOid.objectSequenceNumber != 0))
825 return (IMA_ERROR_INVALID_PARAMETER);
826
827 os_obtainmutex(libMutex);
828 status = IMA_ERROR_OBJECT_NOT_FOUND;
829
830 for (i = 0; i < number_of_plugins; i++) {
831 if (plugintable[i].ownerId == pluginOid.ownerId) {
832 status = IMA_ERROR_UNEXPECTED_OS_ERROR;
833 if (plugintable[i].hPlugin != NULL) {
834 os_obtainmutex(plugintable[i].pluginMutex);
835 #ifdef WIN32
836 PassFunc = (IMA_GetPluginPropertiesFn)
837 GetProcAddress(plugintable[i].hPlugin,
838 "IMA_GetPluginProperties");
839 #else
840 PassFunc = (IMA_GetPluginPropertiesFn)
841 dlsym(plugintable[i].hPlugin,
842 "IMA_GetPluginProperties");
843 #endif
844 if (PassFunc != NULL) {
845 status = PassFunc(pluginOid, pProps);
846 }
847 os_releasemutex(plugintable[i].pluginMutex);
848 }
849
850 break;
851 }
852 }
853 os_releasemutex(libMutex);
854 return (status);
855
856 }
857
858
859
860
861 /*
862 * Gets the object ID for the plugin associated with the specified object ID.
863 *
864 * @param objectId The object ID of an object that has been received from
865 * a previous library call.
866 * @param pPluginId A pointer to an @ref IMA_OID structure allocated by the
867 * caller. On successful return this will contain the object ID of the
868 * plugin associated with the object specified by @a objectId. This
869 * can then be used to work with the plugin, e.g., to get the
870 * properties of the plugin or the send the plugin an IOCtl.
871 * @return An IMA_STATUS indicating if the operation was successful or if
872 * an error occurred.
873 * @retval IMA_SUCCESS Returned if the associated plugin ID was
874 * successfully returned.
875 * @retval IMA_ERROR_INVALID_PARAMETER Returned if @a pPluginId is NULL
876 * or specifes a memory area to which data cannot be written.
877 * @retval IMA_ERROR_INVALID_PARAMETER Returned if @a objectId specifies
878 * an object not owned by a plugin, but instead one that is owned by
879 * the library.
880 * @retval IMA_ERROR_INVALID_OBJECT_TYPE Returned if @a objectId specifies
881 * an object with an invalid type.
882 */
883 IMA_API IMA_STATUS IMA_GetAssociatedPluginOid(
884 IMA_OID objectId,
885 IMA_OID *pPluginId) {
886 IMA_UINT i;
887 IMA_STATUS status;
888
889
890 if (number_of_plugins == -1)
891 InitLibrary();
892
893 if (pPluginId == NULL || objectId.ownerId == RL_LIBRARY_SEQNUM)
894 return (IMA_ERROR_INVALID_PARAMETER);
895
896 if (objectId.objectType != IMA_OBJECT_TYPE_UNKNOWN &&
897 objectId.objectType != IMA_OBJECT_TYPE_PLUGIN &&
898 objectId.objectType != IMA_OBJECT_TYPE_NODE &&
899 objectId.objectType != IMA_OBJECT_TYPE_LHBA &&
900 objectId.objectType != IMA_OBJECT_TYPE_PHBA &&
901 objectId.objectType != IMA_OBJECT_TYPE_NETWORK_PORTAL &&
902 objectId.objectType != IMA_OBJECT_TYPE_PORTAL_GROUP &&
903 objectId.objectType != IMA_OBJECT_TYPE_LNP &&
904 objectId.objectType != IMA_OBJECT_TYPE_PNP &&
905 objectId.objectType != IMA_OBJECT_TYPE_TARGET &&
906 objectId.objectType != IMA_OBJECT_TYPE_LU &&
907 objectId.objectType != IMA_OBJECT_TYPE_DISCOVERY_ADDRESS &&
908 objectId.objectType != IMA_OBJECT_TYPE_STATIC_DISCOVERY_TARGET)
909 return (IMA_ERROR_INVALID_OBJECT_TYPE);
910
911 os_obtainmutex(libMutex);
912
913 status = IMA_ERROR_OBJECT_NOT_FOUND;
914 for (i = 0; i < number_of_plugins; i++) {
915 if (objectId.ownerId == plugintable[i].ownerId) {
916 pPluginId->objectType = IMA_OBJECT_TYPE_PLUGIN;
917 pPluginId->ownerId = plugintable[i].ownerId;
918 pPluginId->objectSequenceNumber = 0;
919 status = IMA_STATUS_SUCCESS;
920 }
921
922 }
923 os_releasemutex(libMutex);
924 return (status);
925 }
926
927
928
929
930 /*
931 * Gets the object ID of the shared node.
932 *
933 * @param pSharedNodeId A pointer to an @ref IMA_OID structure allocated by
934 * the caller. On successful return it will contain the object ID of the
935 * shared node of the currently executing system is placed.
936 * @return An IMA_STATUS indicating if the operation was successful or if
937 * an error occurred.
938 * @retval IMA_SUCCESS Returned if the shared node ID has been successfully
939 * retrieved.
940 * @retval IMA_ERROR_INVALID_PARAMETER Returned if @a pSharedNodeId is NULL
941 * or specifies a memory area to which data cannot be written.
942 */
943 IMA_API IMA_STATUS IMA_GetSharedNodeOid(
944 IMA_OID *pSharedNodeId) {
945 if (pSharedNodeId == NULL)
946 return (IMA_ERROR_INVALID_PARAMETER);
947
948 pSharedNodeId->objectType = IMA_OBJECT_TYPE_NODE;
949 pSharedNodeId->ownerId = RL_LIBRARY_SEQNUM;
950 pSharedNodeId->objectSequenceNumber = RL_SHARED_NODE_SEQNUM;
951 return (IMA_STATUS_SUCCESS);
952 }
953
954
955 IMA_API IMA_STATUS IMA_GetObjectType(
956 IMA_OID oid,
957 IMA_OBJECT_TYPE *pObjectType) {
958 IMA_STATUS status;
959 IMA_UINT i;
960
961 if (pObjectType == NULL)
962 return (IMA_ERROR_INVALID_PARAMETER);
963
964 if (oid.objectType != IMA_OBJECT_TYPE_UNKNOWN &&
965 oid.objectType != IMA_OBJECT_TYPE_PLUGIN &&
966 oid.objectType != IMA_OBJECT_TYPE_NODE &&
967 oid.objectType != IMA_OBJECT_TYPE_LHBA &&
968 oid.objectType != IMA_OBJECT_TYPE_PHBA &&
969 oid.objectType != IMA_OBJECT_TYPE_NETWORK_PORTAL &&
970 oid.objectType != IMA_OBJECT_TYPE_PORTAL_GROUP &&
971 oid.objectType != IMA_OBJECT_TYPE_LNP &&
972 oid.objectType != IMA_OBJECT_TYPE_PNP &&
973 oid.objectType != IMA_OBJECT_TYPE_TARGET &&
974 oid.objectType != IMA_OBJECT_TYPE_LU &&
975 oid.objectType != IMA_OBJECT_TYPE_DISCOVERY_ADDRESS &&
976 oid.objectType != IMA_OBJECT_TYPE_STATIC_DISCOVERY_TARGET)
977 return (IMA_ERROR_INVALID_OBJECT_TYPE);
978
979 os_obtainmutex(libMutex);
980 status = IMA_ERROR_OBJECT_NOT_FOUND;
981
982 for (i = 0; i < number_of_plugins; i++) {
983 if (plugintable[i].ownerId == oid.ownerId) {
984 *pObjectType = oid.objectType;
985 status = IMA_STATUS_SUCCESS;
986 }
987 }
988 os_releasemutex(libMutex);
989 return (status);
990 }
991
992
993
994 /*
995 * Gets the properties of the specified iSCSI node.
996 * @param nodeId The ID of the node to get the properties of.
997 * @param pProps A pointer to an @ref IMA_NODE_PROPERTIES structure
998 * which on successfully return
999 * will contain the properties of the specified node.
1000 * @return An IMA_STATUS indicating if the operation was successful or
1001 * if an error occurred.
1002 * @retval IMA_SUCCESS Returned if the node properties have been
1003 * successfully retrieved.
1004 * @retval IMA_ERROR_INVALID_PARAMETER Returned if @a pProps is NULL
1005 * or specifies a memory area to which data cannot be written.
1006 * @retval IMA_ERROR_INVALID_OBJECT_TYPE Returned if @a nodeId does
1007 * not specify any valid object type.
1008 * @retval IMA_ERROR_INCORRECT_OBJECT_TYPE Returned if @a nodeId does
1009 * not specify a node object.
1010 * @retval IMA_ERROR_OBJECT_NOT_FOUND Returned if @a nodeId does not
1011 * specify a node which is currently known to the system.
1012 */
1013 IMA_API IMA_STATUS IMA_GetNodeProperties(
1014 IMA_OID nodeOid,
1015 IMA_NODE_PROPERTIES *pProps) {
1016 IMA_GetNodePropertiesFn PassFunc;
1017 IMA_UINT i;
1018 IMA_STATUS status;
1019 char fullline[512]; /* Full line read in from IMA.conf */
1020 char nodename[MAXHOSTNAMELEN];
1021
1022 #if defined(_WINDOWS)
1023 IMA_UINT dwStrLength;
1024 #endif
1025
1026 if (number_of_plugins == -1)
1027 InitLibrary();
1028
1029 if (pProps == NULL)
1030 return (IMA_ERROR_INVALID_PARAMETER);
1031
1032 if (nodeOid.objectType != IMA_OBJECT_TYPE_NODE)
1033 return (IMA_ERROR_INCORRECT_OBJECT_TYPE);
1034
1035 if ((nodeOid.ownerId == RL_LIBRARY_SEQNUM) &&
1036 (nodeOid.objectSequenceNumber == RL_SHARED_NODE_SEQNUM)) {
1037 pProps->runningInInitiatorMode = IMA_TRUE;
1038 pProps->runningInTargetMode = IMA_TRUE;
1039 pProps->nameAndAliasSettable = IMA_TRUE;
1040
1041 if (sharedNodeName[0] == 0) {
1042 #if defined(_WINDOWS)
1043 GetComputerName((char *)fullline,
1044 (LPDWORD)&dwStrLength);
1045 sprintf(nodename, DEFAULT_NODE_NAME_FORMAT, fullline);
1046 MultiByteToWideChar(CP_ACP, 0, nodename, -1,
1047 sharedNodeName, 256);
1048 #elif defined(SOLARIS)
1049
1050 if (getSolarisSharedNodeName(sharedNodeName) !=
1051 IMA_STATUS_SUCCESS) {
1052 gethostname((char *)fullline,
1053 sizeof (fullline));
1054 sprintf(nodename,
1055 DEFAULT_NODE_NAME_FORMAT, fullline);
1056 mbstowcs(sharedNodeName, nodename, 256);
1057 }
1058 #else
1059 gethostname((char *)fullline, sizeof (fullline));
1060 sprintf(nodename, DEFAULT_NODE_NAME_FORMAT, fullline);
1061 mbstowcs(sharedNodeName, nodename, 256);
1062 #endif
1063 }
1064
1065 if (sharedNodeName[0] != 0) {
1066 libSwprintf(pProps->name, L"%ls", sharedNodeName);
1067 pProps->nameValid = IMA_TRUE;
1068 }
1069 else
1070 pProps->nameValid = IMA_FALSE;
1071
1072 #if defined(SOLARIS)
1073 if (sharedNodeAlias[0] == 0) {
1074 getSolarisSharedNodeAlias(sharedNodeAlias);
1075 }
1076 #endif
1077
1078 if (sharedNodeAlias[0] != 0) {
1079 libSwprintf(pProps->alias, L"%ls", sharedNodeAlias);
1080 pProps->aliasValid = IMA_TRUE;
1081 }
1082 else
1083 pProps->aliasValid = IMA_FALSE;
1084
1085 return (IMA_STATUS_SUCCESS);
1086 }
1087
1088 os_obtainmutex(libMutex);
1089 status = IMA_ERROR_OBJECT_NOT_FOUND;
1090
1091 for (i = 0; i < number_of_plugins; i++) {
1092 if (plugintable[i].ownerId == nodeOid.ownerId) {
1093 status = IMA_ERROR_UNEXPECTED_OS_ERROR;
1094 if (plugintable[i].hPlugin != NULL) {
1095 os_obtainmutex(plugintable[i].pluginMutex);
1096 #ifdef WIN32
1097 PassFunc = (IMA_GetNodePropertiesFn)
1098 GetProcAddress(plugintable[i].hPlugin,
1099 "IMA_GetNodeProperties");
1100 #else
1101 PassFunc = (IMA_GetNodePropertiesFn)
1102 dlsym(plugintable[i].hPlugin,
1103 "IMA_GetNodeProperties");
1104 #endif
1105
1106 if (PassFunc != NULL) {
1107 status = PassFunc(nodeOid, pProps);
1108 }
1109 os_releasemutex(plugintable[i].pluginMutex);
1110 }
1111
1112 break;
1113 }
1114 }
1115 os_releasemutex(libMutex);
1116 return (status);
1117
1118 }
1119
1120
1121
1122
1123 /*
1124 * Sets the name of the specified node.
1125 *
1126 * @param nodeId The object ID of the node whose name is being set.
1127 * @param newName The new name of the node.
1128 * @return An IMA_STATUS indicating if the operation was successful or if
1129 * an error occurred.
1130 * @retval IMA_SUCCESS Returned if the node name was successfully changed.
1131 * @retval IMA_STATUS_REBOOT_NECESSARY Returned if a reboot is necessary
1132 * before the setting of the name actually takes affect.
1133 * @retval IMA_ERROR_INVALID_PARAMETER Returned if @a newname is NULL, or
1134 * specifies a memory area to which data cannot be written, or has a
1135 * length of 0.
1136 * @retval IMA_ERROR_INVALID_OBJECT_TYPE Returned if @a nodeId does not
1137 * specify any valid object type.
1138 * @retval IMA_ERROR_INCORRECT_OBJECT_TYPE Returned if @a nodeId does not
1139 * specify a node object.
1140 * @retval IMA_ERROR_OBJECT_NOT_FOUND Returned if @a nodeId does not specify a
1141 * node which is currently known to the system.
1142 * @retval IMA_ERROR_NAME_TOO_LONG Returned if @a newName contains too many
1143 * characters.
1144 */
1145 IMA_API IMA_STATUS IMA_SetNodeName(
1146 IMA_OID nodeOid,
1147 const IMA_NODE_NAME newName) {
1148 IMA_SetNodeNameFn PassFunc;
1149 IMA_UINT i;
1150 IMA_STATUS status;
1151
1152 if (number_of_plugins == -1)
1153 InitLibrary();
1154
1155 if (newName == NULL || wcslen(newName) == 0)
1156 return (IMA_ERROR_INVALID_PARAMETER);
1157
1158 if (wcslen(newName) > IMA_NODE_NAME_LEN - 1)
1159 return (IMA_ERROR_NAME_TOO_LONG);
1160
1161 if (nodeOid.objectType != IMA_OBJECT_TYPE_NODE)
1162 return (IMA_ERROR_INCORRECT_OBJECT_TYPE);
1163
1164 if ((nodeOid.ownerId == RL_LIBRARY_SEQNUM) &&
1165 (nodeOid.objectSequenceNumber == RL_SHARED_NODE_SEQNUM)) {
1166 #if defined(SOLARIS)
1167 if (setSolarisSharedNodeName(newName) != IMA_STATUS_SUCCESS) {
1168 return (IMA_ERROR_UNKNOWN_ERROR);
1169 }
1170 #endif
1171 os_obtainmutex(libMutex);
1172 libSwprintf(sharedNodeName, L"%ls", newName);
1173 os_releasemutex(libMutex);
1174 return (IMA_STATUS_SUCCESS);
1175 }
1176
1177 os_obtainmutex(libMutex);
1178 status = IMA_ERROR_OBJECT_NOT_FOUND;
1179
1180 for (i = 0; i < number_of_plugins; i++) {
1181 if (plugintable[i].ownerId == nodeOid.ownerId) {
1182 status = IMA_ERROR_UNEXPECTED_OS_ERROR;
1183 if (plugintable[i].hPlugin != NULL) {
1184 os_obtainmutex(plugintable[i].pluginMutex);
1185 #ifdef WIN32
1186 PassFunc = (IMA_SetNodeNameFn)
1187 GetProcAddress(plugintable[i].hPlugin,
1188 "IMA_SetNodeName");
1189 #else
1190 PassFunc = (IMA_SetNodeNameFn)
1191 dlsym(plugintable[i].hPlugin,
1192 "IMA_SetNodeName");
1193 #endif
1194
1195 if (PassFunc != NULL) {
1196 status = PassFunc(nodeOid, newName);
1197 }
1198 os_releasemutex(plugintable[i].pluginMutex);
1199 }
1200
1201 break;
1202 }
1203 }
1204 os_releasemutex(libMutex);
1205 return (status);
1206
1207 }
1208
1209
1210
1211
1212 /*
1213 * Generates an unique node name for the currently running system.
1214 *
1215 * @param generatedname On successful return contains the generated node
1216 * name.
1217 * @return An IMA_STATUS indicating if the operation was successful or if
1218 * an error occurred.
1219 * @retval IMA_ERROR_INVALID_PARAMETER Returned if @a generatedname is NULL
1220 * or specifies a memory area to which data cannot be written.
1221 */
1222 IMA_API IMA_STATUS IMA_GenerateNodeName(
1223 IMA_NODE_NAME generatedname) {
1224 char computername[256];
1225 char nodename[MAXHOSTNAMELEN];
1226
1227 #if defined(_WINDOWS)
1228 IMA_UINT dwStrLength = 255;
1229 #endif
1230
1231 #ifndef _WINDOWS
1232 #ifndef SOLARIS
1233 int i;
1234 #endif
1235 #endif
1236
1237 if (generatedname == NULL)
1238 return (IMA_ERROR_INVALID_PARAMETER);
1239
1240 #if defined(_WINDOWS)
1241 GetComputerName((char *)computername, (LPDWORD)&dwStrLength);
1242 _strlwr(computername);
1243 _snprintf(nodename, 256, DEFAULT_NODE_NAME_FORMAT, computername);
1244 MultiByteToWideChar(CP_ACP, 0, nodename, -1,
1245 generatedname, 256);
1246 #elif defined(SOLARIS)
1247 if (getSolarisSharedNodeName(generatedname) != IMA_STATUS_SUCCESS) {
1248 gethostname(computername, sizeof (computername));
1249 sprintf(nodename, DEFAULT_NODE_NAME_FORMAT, generatedname);
1250 mbstowcs(generatedname, nodename, 256);
1251 }
1252 #else
1253 gethostname((char *)computername, sizeof (computername));
1254 i = 0;
1255 while (computername[i] != '\0') {
1256 computername[i] = tolower(computername[i]);
1257 i++;
1258 }
1259 snprintf(nodename, 256, DEFAULT_NODE_NAME_FORMAT, computername);
1260 mbstowcs(generatedname, nodename, 256);
1261 #endif
1262
1263 return (IMA_STATUS_SUCCESS);
1264 }
1265
1266
1267 /*
1268 * Sets the alias of the specified node.
1269 *
1270 * @param nodeId The object ID of the node whose alias is being set.
1271 * @param newAlias A pointer to a Unicode string which contains the new node
1272 * alias.If this parameter is NULL then the current alias is deleted, in
1273 * which case the specified node no longer has an alias.
1274 * @return An IMA_STATUS indicating if the operation was successful or if
1275 * an error occurred.
1276 * @retval IMA_SUCCESS Returned if the node's alias has been successfully set.
1277 * @retval IMA_STATUS_REBOOT_NECESSARY A reboot is necessary before
1278 * the setting of the
1279 * alias actually takes affect.
1280 * @retval IMA_ERROR_INVALID_OBJECT_TYPE Returned if @a nodeId does not
1281 * specify any valid object type.
1282 * @retval IMA_ERROR_INCORRECT_OBJECT_TYPE Returned if @a nodeId does not
1283 * specify a node object.
1284 * @retval IMA_ERROR_OBJECT_NOT_FOUND Returned if @a nodeId does not specify
1285 * a node which is currently known to the system.
1286 * @retval IMA_ERROR_NAME_TOO_LONG Returned if @a newAlias contains too many
1287 * characters.
1288 */
1289 IMA_API IMA_STATUS IMA_SetNodeAlias(
1290 IMA_OID nodeOid,
1291 const IMA_NODE_ALIAS newAlias) {
1292 IMA_SetNodeAliasFn PassFunc;
1293 IMA_UINT i;
1294 IMA_STATUS status;
1295
1296 if (number_of_plugins == -1)
1297 InitLibrary();
1298
1299 if (newAlias == NULL)
1300 return (IMA_ERROR_INVALID_PARAMETER);
1301
1302 if (wcslen(newAlias) > IMA_NODE_ALIAS_LEN - 1)
1303 return (IMA_ERROR_NAME_TOO_LONG);
1304
1305 if (nodeOid.objectType != IMA_OBJECT_TYPE_NODE)
1306 return (IMA_ERROR_INCORRECT_OBJECT_TYPE);
1307
1308 if ((nodeOid.ownerId == RL_LIBRARY_SEQNUM) &&
1309 (nodeOid.objectSequenceNumber == RL_SHARED_NODE_SEQNUM)) {
1310 #if defined(SOLARIS)
1311 if (setSolarisSharedNodeAlias(newAlias) != IMA_STATUS_SUCCESS) {
1312 return (IMA_ERROR_UNKNOWN_ERROR);
1313 }
1314 #endif
1315 os_obtainmutex(libMutex);
1316 if (wcslen(newAlias) > 0 && newAlias != NULL)
1317 libSwprintf(sharedNodeAlias, L"%ls", newAlias);
1318 else
1319 libSwprintf(sharedNodeAlias, L"%ls", "");
1320
1321 os_releasemutex(libMutex);
1322 return (IMA_STATUS_SUCCESS);
1323 }
1324
1325 os_obtainmutex(libMutex);
1326 status = IMA_ERROR_OBJECT_NOT_FOUND;
1327
1328 for (i = 0; i < number_of_plugins; i++) {
1329 if (plugintable[i].ownerId == nodeOid.ownerId) {
1330 status = IMA_ERROR_UNEXPECTED_OS_ERROR;
1331 if (plugintable[i].hPlugin != NULL) {
1332 os_obtainmutex(plugintable[i].pluginMutex);
1333 #ifdef WIN32
1334 PassFunc = (IMA_SetNodeAliasFn)
1335 GetProcAddress(plugintable[i].hPlugin,
1336 "IMA_SetNodeAlias");
1337 #else
1338 PassFunc = (IMA_SetNodeAliasFn)
1339 dlsym(
1340 plugintable[i].hPlugin,
1341 "IMA_SetNodeAlias");
1342 #endif
1343
1344 if (PassFunc != NULL) {
1345 status = PassFunc(nodeOid, newAlias);
1346 }
1347 os_releasemutex(plugintable[i].pluginMutex);
1348 }
1349
1350 break;
1351 }
1352 }
1353 os_releasemutex(libMutex);
1354 return (status);
1355 }
1356
1357
1358
1359
1360 /*
1361 * Gets a list of the object IDs of all the logical HBAs in the system.
1362 *
1363 * @param ppList A pointer to a pointer to an @ref IMA_OID_LIST structure.
1364 * on successful return this will contain a pointer to an
1365 * @ref IMA_OID_LIST which contains the object IDs of all of the
1366 * LHBAs currently in the system.
1367 * @return An IMA_STATUS indicating if the operation was successful or if
1368 * an error occurred.
1369 * @retval IMA_SUCCESS Returned if the LHBA ID list has been successfully
1370 * returned.
1371 * @retval IMA_ERROR_INVALID_PARAMETER Returned if @a ppList is NULL or
1372 * specifies a
1373 * memory area to which data cannot be written.
1374 */
1375 IMA_API IMA_STATUS IMA_GetLhbaOidList(
1376 IMA_OID_LIST **ppList) {
1377 IMA_GetLhbaOidListFn PassFunc;
1378 IMA_FreeMemoryFn FreeFunc;
1379
1380 IMA_UINT i;
1381 IMA_UINT j;
1382 IMA_UINT totalIdCount;
1383 IMA_STATUS status;
1384
1385 if (number_of_plugins == -1)
1386 InitLibrary();
1387
1388 if (ppList == NULL)
1389 return (IMA_ERROR_INVALID_PARAMETER);
1390
1391 os_obtainmutex(libMutex);
1392 // Get total id count first
1393 totalIdCount = 0;
1394
1395 for (i = 0; i < number_of_plugins; i++) {
1396 status = IMA_ERROR_UNEXPECTED_OS_ERROR;
1397 if (plugintable[i].hPlugin != NULL) {
1398 os_obtainmutex(plugintable[i].pluginMutex);
1399 #ifdef WIN32
1400 PassFunc = (IMA_GetLhbaOidListFn)
1401 GetProcAddress(plugintable[i].hPlugin,
1402 "IMA_GetLhbaOidList");
1403 #else
1404 PassFunc = (IMA_GetLhbaOidListFn)
1405 dlsym(plugintable[i].hPlugin,
1406 "IMA_GetLhbaOidList");
1407 #endif
1408 if (PassFunc != NULL) {
1409 IMA_OID_LIST *ppOidList;
1410 status = PassFunc(&ppOidList);
1411 if (status == IMA_STATUS_SUCCESS) {
1412 totalIdCount += ppOidList->oidCount;
1413 #ifdef WIN32
1414 FreeFunc = (IMA_FreeMemoryFn)
1415 GetProcAddress(
1416 plugintable[i].hPlugin,
1417 "IMA_FreeMemory");
1418 #else
1419 FreeFunc = (IMA_FreeMemoryFn)
1420 dlsym(plugintable[i].hPlugin,
1421 "IMA_FreeMemory");
1422 #endif
1423 if (FreeFunc != NULL) {
1424 FreeFunc(ppOidList);
1425 }
1426 }
1427
1428 }
1429 os_releasemutex(plugintable[i].pluginMutex);
1430 }
1431 if (status != IMA_STATUS_SUCCESS) {
1432 break;
1433 }
1434 }
1435
1436
1437 *ppList = (IMA_OID_LIST*)calloc(1, sizeof (IMA_OID_LIST) +
1438 (totalIdCount - 1) * sizeof (IMA_OID));
1439
1440 if ((*ppList) == NULL) {
1441 os_releasemutex(libMutex);
1442 return (IMA_ERROR_UNEXPECTED_OS_ERROR);
1443 }
1444 (*ppList)->oidCount = totalIdCount;
1445
1446 // 2nd pass to copy the id lists
1447 totalIdCount = 0;
1448 status = IMA_STATUS_SUCCESS;
1449 for (i = 0; i < number_of_plugins; i++) {
1450 status = IMA_ERROR_UNEXPECTED_OS_ERROR;
1451 if (plugintable[i].hPlugin != NULL) {
1452 os_obtainmutex(plugintable[i].pluginMutex);
1453 #ifdef WIN32
1454 PassFunc = (IMA_GetLhbaOidListFn)
1455 GetProcAddress(plugintable[i].hPlugin,
1456 "IMA_GetLhbaOidList");
1457 #else
1458 PassFunc = (IMA_GetLhbaOidListFn)
1459 dlsym(plugintable[i].hPlugin,
1460 "IMA_GetLhbaOidList");
1461 #endif
1462 if (PassFunc != NULL) {
1463 IMA_OID_LIST *ppOidList;
1464 status = PassFunc(&ppOidList);
1465 if (status == IMA_STATUS_SUCCESS) {
1466 for (j = 0;
1467 (j < ppOidList->oidCount) &&
1468 (totalIdCount <
1469 (*ppList)->oidCount);
1470 j++) {
1471 (*ppList)->oids[totalIdCount].
1472 objectType
1473 = ppOidList->oids[j].
1474 objectType;
1475 (*ppList)->oids[totalIdCount].
1476 objectSequenceNumber =
1477 ppOidList->oids[j].
1478 objectSequenceNumber;
1479 (*ppList)->oids[totalIdCount].
1480 ownerId =
1481 ppOidList->oids[j].ownerId;
1482 totalIdCount++;
1483 }
1484 #ifdef WIN32
1485 FreeFunc = (IMA_FreeMemoryFn)
1486 GetProcAddress(
1487 plugintable[i].hPlugin,
1488 "IMA_FreeMemory");
1489 #else
1490 FreeFunc = (IMA_FreeMemoryFn)
1491 dlsym(plugintable[i].hPlugin,
1492 "IMA_FreeMemory");
1493 #endif
1494 if (FreeFunc != NULL) {
1495 FreeFunc(ppOidList);
1496 }
1497 }
1498 }
1499 os_releasemutex(plugintable[i].pluginMutex);
1500 }
1501 if (status != IMA_STATUS_SUCCESS) {
1502 free(*ppList);
1503 break;
1504 }
1505
1506 }
1507 os_releasemutex(libMutex);
1508 return (status);
1509 }
1510
1511
1512
1513
1514 /*
1515 * Gets the properties of the specified logical HBA.
1516 *
1517 * @param lhbaId The object ID of the LHBA whose properties are being
1518 * retrieved.
1519 * @param pProps A pointer to an @ref IMA_LHBA_PROPERTIES structure.
1520 * On successful
1521 * return this will contain the properties of the LHBA specified by
1522 * @a lhbaId.
1523 * @return An IMA_STATUS indicating if the operation was successful or if
1524 * an error occurred.
1525 * @retval IMA_SUCCESS Returned if the properties of the specified LHBA
1526 * have been successfully retrieved.
1527 * @retval IMA_ERROR_INVALID_PARAMETER Returned if @a pProps is NULL or
1528 * specify a memory area to which data cannot be written.
1529 * @retval IMA_ERROR_INVALID_OBJECT_TYPE Returned if @a lhbaId does not
1530 * specify any valid object type.
1531 * @retval IMA_ERROR_INCORRECT_OBJECT_TYPE Returned if @a lhbaId does not
1532 * specify a LHBA.
1533 * @retval IMA_ERROR_OBJECT_NOT_FOUND Returned if @a lhbaId does not
1534 * specify a LHBA which is currently known to the system.
1535 */
1536 IMA_API IMA_STATUS IMA_GetLhbaProperties(
1537 IMA_OID lhbaId,
1538 IMA_LHBA_PROPERTIES *pProps) {
1539 IMA_GetLhbaPropertiesFn PassFunc;
1540 IMA_UINT i;
1541 IMA_STATUS status;
1542
1543 if (number_of_plugins == -1)
1544 InitLibrary();
1545
1546 if (pProps == NULL)
1547 return (IMA_ERROR_INVALID_PARAMETER);
1548
1549 if (lhbaId.objectType != IMA_OBJECT_TYPE_LHBA)
1550 return (IMA_ERROR_INCORRECT_OBJECT_TYPE);
1551
1552 os_obtainmutex(libMutex);
1553 status = IMA_ERROR_OBJECT_NOT_FOUND;
1554
1555 for (i = 0; i < number_of_plugins; i++) {
1556 if (plugintable[i].ownerId == lhbaId.ownerId) {
1557 status = IMA_ERROR_UNEXPECTED_OS_ERROR;
1558 if (plugintable[i].hPlugin != NULL) {
1559 os_obtainmutex(plugintable[i].pluginMutex);
1560 #ifdef WIN32
1561 PassFunc = (IMA_GetLhbaPropertiesFn)
1562 GetProcAddress(plugintable[i].hPlugin,
1563 "IMA_GetLhbaProperties");
1564 #else
1565 PassFunc = (IMA_GetLhbaPropertiesFn)
1566 dlsym(plugintable[i].hPlugin,
1567 "IMA_GetLhbaProperties");
1568 #endif
1569
1570 if (PassFunc != NULL) {
1571 status = PassFunc(lhbaId, pProps);
1572 }
1573 os_releasemutex(plugintable[i].pluginMutex);
1574 }
1575
1576 break;
1577 }
1578 }
1579 os_releasemutex(libMutex);
1580 return (status);
1581 }
1582
1583
1584
1585
1586 /*
1587 * Gets a list of the object IDs of all the physical HBAs in the system.
1588 *
1589 * @param ppList A pointer to a pointer to an @ref IMA_OID_LIST structure.
1590 * on successful return this will contain a pointer to an
1591 * @ref IMA_OID_LIST which contains the object IDs of all of the
1592 * PHBAs currently in the system.
1593 * @return An IMA_STATUS indicating if the operation was successful or if
1594 * an error occurred.
1595 * @retval IMA_SUCCESS Returned if the PHBA ID list has been successfully
1596 * returned.
1597 * @retval IMA_ERROR_INVALID_PARAMETER Returned if @a ppList is NULL or
1598 * specify a memory area to which data cannot be written.
1599 * @retval IMA_SUCCESS Returned if the properties of the specified PHBA
1600 * have been successfully retrieved.
1601 * @retval IMA_ERROR_OBJECT_NOT_FOUND Returned if @a phbaId does not
1602 * specify a PHBA which is currently known to the system.
1603 * @retval IMA_ERROR_INVALID_PARAMETER Returned if @a ppList is NULL or
1604 * specify a memory area to which data cannot be written.
1605 */
1606 IMA_API IMA_STATUS IMA_GetPhbaOidList(
1607 IMA_OID_LIST **ppList) {
1608 IMA_GetPhbaOidListFn PassFunc;
1609 IMA_FreeMemoryFn FreeFunc;
1610
1611 IMA_UINT i;
1612 IMA_UINT j;
1613 IMA_UINT totalIdCount;
1614 IMA_STATUS status;
1615
1616 if (number_of_plugins == -1)
1617 InitLibrary();
1618
1619 if (ppList == NULL)
1620 return (IMA_ERROR_INVALID_PARAMETER);
1621
1622 os_obtainmutex(libMutex);
1623 // Get total id count first
1624 totalIdCount = 0;
1625
1626 for (i = 0; i < number_of_plugins; i++) {
1627 status = IMA_ERROR_UNEXPECTED_OS_ERROR;
1628 if (plugintable[i].hPlugin != NULL) {
1629 os_obtainmutex(plugintable[i].pluginMutex);
1630 #ifdef WIN32
1631 PassFunc = (IMA_GetPhbaOidListFn)
1632 GetProcAddress(plugintable[i].hPlugin,
1633 "IMA_GetPhbaOidList");
1634 #else
1635 PassFunc = (IMA_GetPhbaOidListFn)
1636 dlsym(plugintable[i].hPlugin,
1637 "IMA_GetPhbaOidList");
1638 #endif
1639 if (PassFunc != NULL) {
1640 IMA_OID_LIST *ppOidList;
1641 status = PassFunc(&ppOidList);
1642 if (status == IMA_STATUS_SUCCESS) {
1643 totalIdCount += ppOidList->oidCount;
1644 #ifdef WIN32
1645 FreeFunc = (IMA_FreeMemoryFn)
1646 GetProcAddress(
1647 plugintable[i].hPlugin,
1648 "IMA_FreeMemory");
1649 #else
1650 FreeFunc = (IMA_FreeMemoryFn)
1651 dlsym(plugintable[i].hPlugin,
1652 "IMA_FreeMemory");
1653 #endif
1654 if (FreeFunc != NULL) {
1655 FreeFunc(ppOidList);
1656 }
1657 }
1658 }
1659 os_releasemutex(plugintable[i].pluginMutex);
1660 }
1661 if (status != IMA_STATUS_SUCCESS) {
1662 break;
1663 }
1664
1665 }
1666
1667
1668 *ppList = (IMA_OID_LIST*)calloc(1, sizeof (IMA_OID_LIST) +
1669 (totalIdCount - 1) * sizeof (IMA_OID));
1670
1671 if ((*ppList) == NULL) {
1672 os_releasemutex(libMutex);
1673 return (IMA_ERROR_UNEXPECTED_OS_ERROR);
1674 }
1675
1676 (*ppList)->oidCount = totalIdCount;
1677
1678 // 2nd pass to copy the id lists
1679 totalIdCount = 0;
1680 status = IMA_STATUS_SUCCESS;
1681 for (i = 0; i < number_of_plugins; i++) {
1682 status = IMA_ERROR_UNEXPECTED_OS_ERROR;
1683 if (plugintable[i].hPlugin != NULL) {
1684 os_obtainmutex(plugintable[i].pluginMutex);
1685 #ifdef WIN32
1686 PassFunc = (IMA_GetPhbaOidListFn)
1687 GetProcAddress(plugintable[i].hPlugin,
1688 "IMA_GetPhbaOidList");
1689 #else
1690 PassFunc = (IMA_GetPhbaOidListFn)
1691 dlsym(plugintable[i].hPlugin,
1692 "IMA_GetPhbaOidList");
1693 #endif
1694 if (PassFunc != NULL) {
1695 IMA_OID_LIST *ppOidList;
1696 status = PassFunc(&ppOidList);
1697 if (status == IMA_STATUS_SUCCESS) {
1698 for (j = 0;
1699 (j < ppOidList->oidCount) &&
1700 (totalIdCount <
1701 (*ppList)->oidCount);
1702 j++) {
1703 (*ppList)->oids[totalIdCount].
1704 objectType =
1705 ppOidList->oids[j].
1706 objectType;
1707 (*ppList)->oids[totalIdCount].
1708 objectSequenceNumber =
1709 ppOidList->oids[j].
1710 objectSequenceNumber;
1711 (*ppList)->oids[totalIdCount].
1712 ownerId =
1713 ppOidList->oids[j].ownerId;
1714 totalIdCount++;
1715 }
1716 #ifdef WIN32
1717 FreeFunc = (IMA_FreeMemoryFn)
1718 GetProcAddress
1719 (plugintable[i].hPlugin,
1720 "IMA_FreeMemory");
1721 #else
1722 FreeFunc = (IMA_FreeMemoryFn)
1723 dlsym(plugintable[i].hPlugin,
1724 "IMA_FreeMemory");
1725 #endif
1726 if (FreeFunc != NULL) {
1727 FreeFunc(ppOidList);
1728 }
1729 }
1730 }
1731 os_releasemutex(plugintable[i].pluginMutex);
1732 }
1733 if (status != IMA_STATUS_SUCCESS) {
1734 free(*ppList);
1735 break;
1736 }
1737 }
1738 os_releasemutex(libMutex);
1739 return (status);
1740 }
1741
1742
1743 /*
1744 * Gets the general properties of a physical HBA.
1745 *
1746 * @param phbaId The object ID of the PHBA whose
1747 * properties are being queried.
1748 * @param pProps A pointer to an @ref
1749 * IMA_PHBA_PROPERTIES structure. On successful
1750 * return this will contain the properties of
1751 * the PHBA specified by @a phbaId.
1752 * @return An IMA_STATUS indicating if the
1753 * operation was successful or if an error
1754 * occurred.
1755 * @retval IMA_SUCCESS Returned if the properties
1756 * of the specified PHBA have been
1757 * successfully retrieved.
1758 * @retval IMA_ERROR_INVALID_PARAMETER Returned
1759 * if @a pProps is NULL or specifies a
1760 * memory area to which data cannot be written.
1761 * @retval IMA_ERROR_INVALID_OBJECT_TYPE Returned
1762 * if @a phbaId does not specify any
1763 * valid object type.
1764 * @retval IMA_ERROR_INCORRECT_OBJECT_TYPE Returned
1765 * if @a phbaId does not specify a
1766 * PHBA.
1767 * @retval IMA_ERROR_OBJECT_NOT_FOUND Returned
1768 * if @a phbaId does not specify a PHBA
1769 * which is currently known to the system.
1770 */
1771 IMA_API IMA_STATUS IMA_GetPhbaProperties(
1772 IMA_OID phbaId,
1773 IMA_PHBA_PROPERTIES *pProps) {
1774 IMA_GetPhbaPropertiesFn PassFunc;
1775 IMA_UINT i;
1776 IMA_STATUS status;
1777
1778 if (number_of_plugins == -1)
1779 InitLibrary();
1780
1781 if (pProps == NULL)
1782 return (IMA_ERROR_INVALID_PARAMETER);
1783
1784 if (phbaId.objectType != IMA_OBJECT_TYPE_PHBA)
1785 return (IMA_ERROR_INCORRECT_OBJECT_TYPE);
1786
1787 os_obtainmutex(libMutex);
1788 status = IMA_ERROR_OBJECT_NOT_FOUND;
1789
1790 for (i = 0; i < number_of_plugins; i++) {
1791 if (plugintable[i].ownerId == phbaId.ownerId) {
1792 status = IMA_ERROR_UNEXPECTED_OS_ERROR;
1793 if (plugintable[i].hPlugin != NULL) {
1794 os_obtainmutex(plugintable[i].pluginMutex);
1795 #ifdef WIN32
1796 PassFunc = (IMA_GetPhbaPropertiesFn)
1797 GetProcAddress(plugintable[i].hPlugin,
1798 "IMA_GetPhbaProperties");
1799 #else
1800 PassFunc = (IMA_GetPhbaPropertiesFn)
1801 dlsym(plugintable[i].hPlugin,
1802 "IMA_GetPhbaProperties");
1803 #endif
1804
1805 if (PassFunc != NULL) {
1806 status = PassFunc(phbaId, pProps);
1807 }
1808 os_releasemutex(plugintable[i].pluginMutex);
1809 }
1810
1811 break;
1812 }
1813 }
1814 os_releasemutex(libMutex);
1815 return (status);
1816 }
1817
1818 /*
1819 * Frees a previously allocated IMA_OID_LIST structure.
1820 *
1821 * @param pList A pointer to an @ref IMA_OID_LIST
1822 * structure allocated by the
1823 * library. On successful return the memory
1824 * allocated by the list is freed.
1825 * @return An IMA_STATUS indicating if the operation
1826 * was successful or if an error occurred.
1827 * @retval IMA_SUCCESS Returned if the specified object
1828 * ID list was successfully freed.
1829 * @retval IMA_ERROR_INVALID_PARAMETER Returned
1830 * if @a pList is NULL or specifies a
1831 * memory area from which data cannot be read.
1832 */
1833 IMA_API IMA_STATUS IMA_FreeMemory(
1834 void *pMemory) {
1835 if (pMemory == NULL)
1836 return (IMA_ERROR_INVALID_PARAMETER);
1837 free(pMemory);
1838 return (IMA_STATUS_SUCCESS);
1839 }
1840
1841
1842
1843
1844 IMA_API IMA_STATUS IMA_GetNonSharedNodeOidList(
1845 IMA_OID_LIST **ppList) {
1846 IMA_GetNonSharedNodeOidListFn PassFunc;
1847 IMA_FreeMemoryFn FreeFunc;
1848
1849 IMA_UINT i;
1850 IMA_UINT j;
1851 IMA_UINT totalIdCount;
1852 IMA_STATUS status;
1853
1854 if (number_of_plugins == -1)
1855 InitLibrary();
1856
1857 if (ppList == NULL)
1858 return (IMA_ERROR_INVALID_PARAMETER);
1859
1860 os_obtainmutex(libMutex);
1861 // Get total id count first
1862 totalIdCount = 0;
1863
1864 for (i = 0; i < number_of_plugins; i++) {
1865 status = IMA_ERROR_UNEXPECTED_OS_ERROR;
1866 if (plugintable[i].hPlugin != NULL) {
1867 os_obtainmutex(plugintable[i].pluginMutex);
1868 #ifdef WIN32
1869 PassFunc = (IMA_GetNonSharedNodeOidListFn)
1870 GetProcAddress(plugintable[i].hPlugin,
1871 "IMA_GetNonSharedNodeOidList");
1872 #else
1873 PassFunc = (IMA_GetNonSharedNodeOidListFn)
1874 dlsym(plugintable[i].hPlugin,
1875 "IMA_GetNonSharedNodeOidList");
1876 #endif
1877 if (PassFunc != NULL) {
1878 IMA_OID_LIST *ppOidList;
1879 status = PassFunc(&ppOidList);
1880 if (status == IMA_STATUS_SUCCESS) {
1881 totalIdCount += ppOidList->oidCount;
1882 #ifdef WIN32
1883 FreeFunc = (IMA_FreeMemoryFn)
1884 GetProcAddress(
1885 plugintable[i].hPlugin,
1886 "IMA_FreeMemory");
1887 #else
1888 FreeFunc = (IMA_FreeMemoryFn)
1889 dlsym(plugintable[i].hPlugin,
1890 "IMA_FreeMemory");
1891 #endif
1892 if (FreeFunc != NULL) {
1893 FreeFunc(ppOidList);
1894 }
1895 }
1896 }
1897 os_releasemutex(plugintable[i].pluginMutex);
1898 }
1899 if (status != IMA_STATUS_SUCCESS) {
1900 break;
1901 }
1902
1903 }
1904
1905 *ppList = (IMA_OID_LIST*)calloc(1, sizeof (IMA_OID_LIST) +
1906 (totalIdCount - 1) * sizeof (IMA_OID));
1907
1908 if ((*ppList) == NULL) {
1909 os_releasemutex(libMutex);
1910 return (IMA_ERROR_UNEXPECTED_OS_ERROR);
1911 }
1912
1913 (*ppList)->oidCount = totalIdCount;
1914
1915 // 2nd pass to copy the id lists
1916 totalIdCount = 0;
1917 status = IMA_STATUS_SUCCESS;
1918 for (i = 0; i < number_of_plugins; i++) {
1919 status = IMA_ERROR_UNEXPECTED_OS_ERROR;
1920 if (plugintable[i].hPlugin != NULL) {
1921 os_obtainmutex(plugintable[i].pluginMutex);
1922 #ifdef WIN32
1923 PassFunc = (IMA_GetNonSharedNodeOidListFn)
1924 GetProcAddress(plugintable[i].hPlugin,
1925 "IMA_GetNonSharedNodeOidList");
1926 #else
1927 PassFunc = (IMA_GetNonSharedNodeOidListFn)
1928 dlsym(plugintable[i].hPlugin,
1929 "IMA_GetNonSharedNodeOidList");
1930 #endif
1931 if (PassFunc != NULL) {
1932 IMA_OID_LIST *ppOidList;
1933 status = PassFunc(&ppOidList);
1934 if (status == IMA_STATUS_SUCCESS) {
1935 for (j = 0;
1936 (j < ppOidList->oidCount) &&
1937 (totalIdCount < (
1938 *ppList)->oidCount);
1939 j++) {
1940 (*ppList)->oids[
1941 totalIdCount].objectType =
1942 ppOidList->oids[j].
1943 objectType;
1944 (*ppList)->oids[totalIdCount].
1945 objectSequenceNumber =
1946 ppOidList->oids[j].
1947 objectSequenceNumber;
1948 (*ppList)->oids[
1949 totalIdCount].
1950 ownerId =
1951 ppOidList->oids[j].
1952 ownerId;
1953 totalIdCount++;
1954 }
1955 #ifdef WIN32
1956 FreeFunc = (IMA_FreeMemoryFn)
1957 GetProcAddress(
1958 plugintable[i].hPlugin,
1959 "IMA_FreeMemory");
1960 #else
1961 FreeFunc = (IMA_FreeMemoryFn)
1962 dlsym(plugintable[i].hPlugin,
1963 "IMA_FreeMemory");
1964 #endif
1965 if (FreeFunc != NULL) {
1966 FreeFunc(ppOidList);
1967 }
1968 }
1969 }
1970 os_releasemutex(plugintable[i].pluginMutex);
1971 }
1972 if (status != IMA_STATUS_SUCCESS) {
1973 free(*ppList);
1974 break;
1975 }
1976 }
1977 os_releasemutex(libMutex);
1978 return (status);
1979 }
1980
1981
1982
1983 /*
1984 * Gets the first burst length properties of
1985 * the specified logical HBA.
1986 *
1987 * @param lhbaId The object ID of the logical HBA
1988 * to get the first burst length
1989 * properties of.
1990 * @param pProps A pointer to a min/max values
1991 * structure.
1992 * @return An IMA_STATUS indicating if the operation
1993 * was successful or if an error
1994 * occurred.
1995 * @retval IMA_SUCCESS Returned if the first burst
1996 * length properties have been
1997 * successfully retrieved.
1998 * @retval IMA_ERROR_INVALID_PARAMETER Returned
1999 * if @a pProps is NULL or specifies a
2000 * memory area to which data cannot be written.
2001 * @retval IMA_ERROR_INVALID_OBJECT_TYPE Returned
2002 * if @a lhbaId does not specify any
2003 * valid object type.
2004 * @retval IMA_ERROR_INCORRECT_OBJECT_TYPE Returned
2005 * if @a lhbaId does not specify a LHBA.
2006 * @retval IMA_ERROR_OBJECT_NOT_FOUND Returned
2007 * @a lhbaId does not specify a LHBA
2008 * which is currently known to the system.
2009 */
2010 IMA_API IMA_STATUS IMA_GetFirstBurstLengthProperties(
2011 IMA_OID Oid,
2012 IMA_MIN_MAX_VALUE *pProps) {
2013 IMA_GetFirstBurstLengthPropertiesFn PassFunc;
2014 IMA_UINT i;
2015 IMA_STATUS status;
2016
2017 if (number_of_plugins == -1)
2018 InitLibrary();
2019
2020 if (pProps == NULL)
2021 return (IMA_ERROR_INVALID_PARAMETER);
2022
2023 if (Oid.objectType != IMA_OBJECT_TYPE_LHBA &&
2024 Oid.objectType != IMA_OBJECT_TYPE_TARGET)
2025 return (IMA_ERROR_INCORRECT_OBJECT_TYPE);
2026
2027 os_obtainmutex(libMutex);
2028 status = IMA_ERROR_OBJECT_NOT_FOUND;
2029
2030 for (i = 0; i < number_of_plugins; i++) {
2031 if (plugintable[i].ownerId == Oid.ownerId) {
2032 status = IMA_ERROR_UNEXPECTED_OS_ERROR;
2033 if (plugintable[i].hPlugin != NULL) {
2034 os_obtainmutex(plugintable[i].pluginMutex);
2035 #ifdef WIN32
2036 PassFunc =
2037 (IMA_GetFirstBurstLengthPropertiesFn)
2038 GetProcAddress(plugintable[i].hPlugin,
2039 "IMA_GetFirstBurstLengthProperties");
2040 #else
2041 PassFunc =
2042 (IMA_GetFirstBurstLengthPropertiesFn)
2043 dlsym(plugintable[i].hPlugin,
2044 "IMA_GetFirstBurstLengthProperties");
2045 #endif
2046
2047 if (PassFunc != NULL) {
2048 status = PassFunc(Oid, pProps);
2049 }
2050 os_releasemutex(plugintable[i].pluginMutex);
2051 }
2052
2053 break;
2054 }
2055 }
2056 os_releasemutex(libMutex);
2057 return (status);
2058 }
2059
2060 /*
2061 * Gets the max burst length properties of the
2062 * specified logical HBA.
2063 *
2064 * @param lhbaId The object ID of the logical HBA to
2065 * get the max burst length properties of.
2066 * @param pProps A pointer to an @ref IMA_MIN_MAX_VALUE
2067 * structure allocated by the
2068 * caller. On successful return this structure
2069 * will contain the max
2070 * burst length properties of this LHBA.
2071 * @return An IMA_STATUS indicating if the operation
2072 * was successful or if an error occurred.
2073 * @retval IMA_SUCCESS Returned if the max burst
2074 * length properties have been
2075 * successfully retrieved.
2076 * @retval IMA_ERROR_INVALID_PARAMETER Returned
2077 * if @a pProps is NULL or specifies a
2078 * memory area to which data cannot be written.
2079 * @retval IMA_ERROR_INVALID_OBJECT_TYPE Returned
2080 * if @a lhbaId does not specify any
2081 * valid object type.
2082 * @retval IMA_ERROR_INCORRECT_OBJECT_TYPE Returned
2083 * if @a lhbaId does not specify a HBA.
2084 * @retval IMA_ERROR_OBJECT_NOT_FOUND Returned
2085 * if @a lhbaId does not specify a LHBA
2086 * which is currently known to the system.
2087 */
2088 IMA_API IMA_STATUS IMA_GetMaxBurstLengthProperties(
2089 IMA_OID Oid,
2090 IMA_MIN_MAX_VALUE *pProps) {
2091 IMA_GetMaxBurstLengthPropertiesFn PassFunc;
2092 IMA_UINT i;
2093 IMA_STATUS status;
2094
2095 if (number_of_plugins == -1)
2096 InitLibrary();
2097
2098 if (pProps == NULL)
2099 return (IMA_ERROR_INVALID_PARAMETER);
2100
2101 if (Oid.objectType != IMA_OBJECT_TYPE_LHBA &&
2102 Oid.objectType != IMA_OBJECT_TYPE_TARGET)
2103 return (IMA_ERROR_INCORRECT_OBJECT_TYPE);
2104
2105 os_obtainmutex(libMutex);
2106 status = IMA_ERROR_OBJECT_NOT_FOUND;
2107
2108 for (i = 0; i < number_of_plugins; i++) {
2109 if (plugintable[i].ownerId == Oid.ownerId) {
2110 status = IMA_ERROR_UNEXPECTED_OS_ERROR;
2111 if (plugintable[i].hPlugin != NULL) {
2112 os_obtainmutex(plugintable[i].pluginMutex);
2113 #ifdef WIN32
2114 PassFunc =
2115 (IMA_GetMaxBurstLengthPropertiesFn)
2116 GetProcAddress(plugintable[i].hPlugin,
2117 "IMA_GetMaxBurstLengthProperties");
2118 #else
2119 PassFunc =
2120 (IMA_GetMaxBurstLengthPropertiesFn)
2121 dlsym(plugintable[i].hPlugin,
2122 "IMA_GetMaxBurstLengthProperties");
2123 #endif
2124 if (PassFunc != NULL) {
2125 status = PassFunc(Oid, pProps);
2126 }
2127 os_releasemutex(plugintable[i].pluginMutex);
2128 }
2129
2130 break;
2131 }
2132 }
2133 os_releasemutex(libMutex);
2134 return (status);
2135 }
2136
2137
2138 /*
2139 * Gets the maximum receive data segment length properties
2140 * of the specified logical HBA.
2141 *
2142 * @param lhbaId The object ID of the logical HBA to
2143 * get the max receive data
2144 * segment length properties of.
2145 * @param pProps A pointer to an @ref IMA_MIN_MAX_VALUE
2146 * structure allocated by the caller.
2147 * On successful return this structure will contain the max
2148 * receive data segment length properties of this LHBA.
2149 * @return An IMA_STATUS indicating if the operation
2150 * was successful or if an error occurred.
2151 * @retval IMA_SUCCESS Returned if the max receive
2152 * data segment length properties
2153 * have been successfully retrieved.
2154 * @retval IMA_ERROR_INVALID_PARAMETER Returned if
2155 * @a pProps is NULL or specifies a
2156 * memory area to which data cannot be written.
2157 * @retval IMA_ERROR_INVALID_OBJECT_TYPE Returned if
2158 * @a lhbaId does not specify any
2159 * valid object type.
2160 * @retval IMA_ERROR_INCORRECT_OBJECT_TYPE Returned if
2161 * a lhbaId does not specify a LHBA.
2162 * @retval IMA_ERROR_OBJECT_NOT_FOUND Returned if @a
2163 * lhbaId does not specify a LHBA
2164 * which is currently known to the system.
2165 */
2166 IMA_API IMA_STATUS IMA_GetMaxRecvDataSegmentLengthProperties(
2167 IMA_OID Oid,
2168 IMA_MIN_MAX_VALUE *pProps) {
2169 IMA_GetMaxRecvDataSegmentLengthPropertiesFn PassFunc;
2170 IMA_UINT i;
2171 IMA_STATUS status;
2172 #define IMA_GMRDSLPFN IMA_GetMaxRecvDataSegmentLengthPropertiesFn
2173 #define IMA_GMRDSLP "IMA_GetMaxRecvDataSegmentLengthProperties"
2174
2175 if (number_of_plugins == -1)
2176 InitLibrary();
2177
2178 if (pProps == NULL)
2179 return (IMA_ERROR_INVALID_PARAMETER);
2180
2181 if (Oid.objectType != IMA_OBJECT_TYPE_LHBA &&
2182 Oid.objectType != IMA_OBJECT_TYPE_TARGET)
2183 return (IMA_ERROR_INCORRECT_OBJECT_TYPE);
2184
2185 os_obtainmutex(libMutex);
2186 status = IMA_ERROR_OBJECT_NOT_FOUND;
2187
2188 for (i = 0; i < number_of_plugins; i++) {
2189 if (plugintable[i].ownerId == Oid.ownerId) {
2190 status = IMA_ERROR_UNEXPECTED_OS_ERROR;
2191 if (plugintable[i].hPlugin != NULL) {
2192 os_obtainmutex(plugintable[i].pluginMutex);
2193 #ifdef WIN32
2194 PassFunc =
2195 (IMA_GMRDSLPFN)
2196 GetProcAddress(plugintable[i].hPlugin,
2197 IMA_GMRDSLP);
2198 #else
2199 PassFunc =
2200 (IMA_GMRDSLPFN)
2201 dlsym(plugintable[i].hPlugin,
2202 IMA_GMRDSLP);
2203 #endif
2204
2205 if (PassFunc != NULL) {
2206 status = PassFunc(Oid, pProps);
2207 }
2208 os_releasemutex(plugintable[i].pluginMutex);
2209 }
2210
2211 break;
2212 }
2213 }
2214 os_releasemutex(libMutex);
2215 #undef IMA_GMRDSLPFN
2216 #undef IMA_GMRDSLP
2217 return (status);
2218 }
2219
2220
2221
2222 /* --------------------------------------------- */
2223 IMA_API IMA_STATUS IMA_PluginIOCtl(
2224 IMA_OID pluginOid,
2225 IMA_UINT command,
2226 const void *pInputBuffer,
2227 IMA_UINT inputBufferLength,
2228 void *pOutputBuffer,
2229 IMA_UINT *pOutputBufferLength) {
2230 IMA_PluginIOCtlFn PassFunc;
2231 IMA_UINT i;
2232 IMA_STATUS status;
2233
2234 if (number_of_plugins == -1)
2235 InitLibrary();
2236
2237 if (pInputBuffer == NULL || inputBufferLength == 0 ||
2238 pOutputBuffer == NULL || pOutputBufferLength == NULL ||
2239 *pOutputBufferLength == 0)
2240 return (IMA_ERROR_INVALID_PARAMETER);
2241
2242 if (pluginOid.objectType != IMA_OBJECT_TYPE_PLUGIN)
2243 return (IMA_ERROR_INCORRECT_OBJECT_TYPE);
2244
2245 os_obtainmutex(libMutex);
2246 status = IMA_ERROR_OBJECT_NOT_FOUND;
2247
2248 for (i = 0; i < number_of_plugins; i++) {
2249 if (plugintable[i].ownerId == pluginOid.ownerId) {
2250 status = IMA_ERROR_UNEXPECTED_OS_ERROR;
2251 if (plugintable[i].hPlugin != NULL) {
2252 os_obtainmutex(plugintable[i].pluginMutex);
2253 #ifdef WIN32
2254 PassFunc = (IMA_PluginIOCtlFn)
2255 GetProcAddress(plugintable[i].hPlugin,
2256 "IMA_PluginIOCtl");
2257 #else
2258 PassFunc = (IMA_PluginIOCtlFn)
2259 dlsym(plugintable[i].hPlugin,
2260 "IMA_PluginIOCtl");
2261 #endif
2262
2263 if (PassFunc != NULL) {
2264 status = PassFunc(
2265 pluginOid, command,
2266 pInputBuffer, inputBufferLength,
2267 pOutputBuffer, pOutputBufferLength);
2268 }
2269 os_releasemutex(plugintable[i].pluginMutex);
2270 }
2271
2272 break;
2273 }
2274 }
2275 os_releasemutex(libMutex);
2276 return (status);
2277 }
2278
2279
2280
2281
2282 IMA_API IMA_STATUS IMA_GetNetworkPortalOidList(
2283 IMA_OID lnpId,
2284 IMA_OID_LIST **ppList) {
2285 IMA_GetNetworkPortalOidListFn PassFunc;
2286 IMA_FreeMemoryFn FreeFunc;
2287 IMA_UINT i;
2288 IMA_STATUS status;
2289
2290 if (number_of_plugins == -1)
2291 InitLibrary();
2292
2293 if (ppList == NULL)
2294 return (IMA_ERROR_INVALID_PARAMETER);
2295
2296 if (lnpId.objectType != IMA_OBJECT_TYPE_LNP)
2297 return (IMA_ERROR_INCORRECT_OBJECT_TYPE);
2298
2299 os_obtainmutex(libMutex);
2300 status = IMA_ERROR_OBJECT_NOT_FOUND;
2301
2302 for (i = 0; i < number_of_plugins; i++) {
2303 if (plugintable[i].ownerId == lnpId.ownerId) {
2304 status = IMA_ERROR_UNEXPECTED_OS_ERROR;
2305 if (plugintable[i].hPlugin != NULL) {
2306 os_obtainmutex(plugintable[i].pluginMutex);
2307 #ifdef WIN32
2308 PassFunc = (IMA_GetNetworkPortalOidListFn)
2309 GetProcAddress(plugintable[i].hPlugin,
2310 "IMA_GetNetworkPortalOidList");
2311 #else
2312 PassFunc = (IMA_GetNetworkPortalOidListFn)
2313 dlsym(plugintable[i].hPlugin,
2314 "IMA_GetNetworkPortalOidList");
2315 #endif
2316
2317 if (PassFunc != NULL) {
2318 IMA_OID_LIST *ppOidList;
2319 IMA_UINT listSize;
2320 listSize = sizeof (IMA_OID_LIST);
2321 status = PassFunc(lnpId, &ppOidList);
2322 if (IMA_SUCCESS(status)) {
2323
2324 *ppList = (IMA_OID_LIST*)
2325 calloc(1,
2326 sizeof (IMA_OID_LIST)
2327 + (ppOidList->
2328 oidCount - 1)*
2329 sizeof (IMA_OID));
2330
2331 if ((*ppList) == NULL) {
2332 return (EUOS_ERROR);
2333 }
2334 else
2335 memcpy((*ppList),
2336 ppOidList,
2337 listSize
2338 + (ppOidList->
2339 oidCount - 1)*
2340 sizeof (IMA_OID));
2341 #ifdef WIN32
2342 FreeFunc = (IMA_FreeMemoryFn)
2343 GetProcAddress(
2344 plugintable[i].hPlugin,
2345 "IMA_FreeMemory");
2346 #else
2347 FreeFunc = (IMA_FreeMemoryFn)
2348 dlsym(
2349 plugintable[i].hPlugin,
2350 "IMA_FreeMemory");
2351 #endif
2352 if (FreeFunc != NULL) {
2353 FreeFunc(ppOidList);
2354 }
2355 }
2356 }
2357 os_releasemutex(plugintable[i].pluginMutex);
2358 }
2359
2360 break;
2361 }
2362 }
2363 os_releasemutex(libMutex);
2364 return (status);
2365 }
2366
2367
2368 IMA_API IMA_STATUS IMA_SetFirstBurstLength(
2369 IMA_OID lhbaId,
2370 IMA_UINT firstBurstLength) {
2371 IMA_SetFirstBurstLengthFn PassFunc;
2372 IMA_UINT i;
2373 IMA_STATUS status;
2374
2375 if (number_of_plugins == -1)
2376 InitLibrary();
2377
2378 if (lhbaId.objectType != IMA_OBJECT_TYPE_LHBA &&
2379 lhbaId.objectType != IMA_OBJECT_TYPE_TARGET)
2380 return (IMA_ERROR_INCORRECT_OBJECT_TYPE);
2381
2382 os_obtainmutex(libMutex);
2383 status = IMA_ERROR_OBJECT_NOT_FOUND;
2384
2385 for (i = 0; i < number_of_plugins; i++) {
2386 if (plugintable[i].ownerId == lhbaId.ownerId) {
2387 status = IMA_ERROR_UNEXPECTED_OS_ERROR;
2388 if (plugintable[i].hPlugin != NULL) {
2389 os_obtainmutex(plugintable[i].pluginMutex);
2390 #ifdef WIN32
2391 PassFunc = (IMA_SetFirstBurstLengthFn)
2392 GetProcAddress(plugintable[i].hPlugin,
2393 "IMA_SetFirstBurstLength");
2394 #else
2395 PassFunc = (IMA_SetFirstBurstLengthFn)
2396 dlsym(
2397 plugintable[i].hPlugin,
2398 "IMA_SetFirstBurstLength");
2399 #endif
2400
2401 if (PassFunc != NULL) {
2402 status = PassFunc(
2403 lhbaId, firstBurstLength);
2404 }
2405 os_releasemutex(plugintable[i].pluginMutex);
2406 }
2407
2408 break;
2409 }
2410 }
2411 os_releasemutex(libMutex);
2412 return (status);
2413 }
2414
2415
2416 IMA_API IMA_STATUS IMA_SetMaxBurstLength(
2417 IMA_OID lhbaId,
2418 IMA_UINT maxBurstLength) {
2419 IMA_SetMaxBurstLengthFn PassFunc;
2420 IMA_UINT i;
2421 IMA_STATUS status;
2422
2423 if (number_of_plugins == -1)
2424 InitLibrary();
2425
2426 if (lhbaId.objectType != IMA_OBJECT_TYPE_LHBA &&
2427 lhbaId.objectType != IMA_OBJECT_TYPE_TARGET)
2428 return (IMA_ERROR_INCORRECT_OBJECT_TYPE);
2429
2430 os_obtainmutex(libMutex);
2431 status = IMA_ERROR_OBJECT_NOT_FOUND;
2432
2433 for (i = 0; i < number_of_plugins; i++) {
2434 if (plugintable[i].ownerId == lhbaId.ownerId) {
2435 status = IMA_ERROR_UNEXPECTED_OS_ERROR;
2436 if (plugintable[i].hPlugin != NULL) {
2437 os_obtainmutex(plugintable[i].pluginMutex);
2438 #ifdef WIN32
2439 PassFunc = (IMA_SetMaxBurstLengthFn)
2440 GetProcAddress(plugintable[i].hPlugin,
2441 "IMA_SetMaxBurstLength");
2442 #else
2443 PassFunc = (IMA_SetMaxBurstLengthFn)
2444 dlsym(plugintable[i].hPlugin,
2445 "IMA_SetMaxBurstLength");
2446 #endif
2447
2448 if (PassFunc != NULL) {
2449 status = PassFunc(
2450 lhbaId, maxBurstLength);
2451 }
2452 os_releasemutex(plugintable[i].pluginMutex);
2453 }
2454
2455 break;
2456 }
2457 }
2458 os_releasemutex(libMutex);
2459 return (status);
2460 }
2461
2462
2463 IMA_API IMA_STATUS IMA_SetMaxRecvDataSegmentLength(
2464 IMA_OID lhbaId,
2465 IMA_UINT maxRecvDataSegmentLength) {
2466 IMA_SetMaxRecvDataSegmentLengthFn PassFunc;
2467 IMA_UINT i;
2468 IMA_STATUS status;
2469
2470 if (number_of_plugins == -1)
2471 InitLibrary();
2472
2473 if (lhbaId.objectType != IMA_OBJECT_TYPE_LHBA &&
2474 lhbaId.objectType != IMA_OBJECT_TYPE_TARGET)
2475 return (IMA_ERROR_INCORRECT_OBJECT_TYPE);
2476
2477 os_obtainmutex(libMutex);
2478 status = IMA_ERROR_OBJECT_NOT_FOUND;
2479
2480 for (i = 0; i < number_of_plugins; i++) {
2481 if (plugintable[i].ownerId == lhbaId.ownerId) {
2482 status = IMA_ERROR_UNEXPECTED_OS_ERROR;
2483 if (plugintable[i].hPlugin != NULL) {
2484 os_obtainmutex(plugintable[i].pluginMutex);
2485 #ifdef WIN32
2486 PassFunc =
2487 (IMA_SetMaxRecvDataSegmentLengthFn)
2488 GetProcAddress(plugintable[i].hPlugin,
2489 "IMA_SetMaxRecvDataSegmentLength");
2490 #else
2491 PassFunc =
2492 (IMA_SetMaxRecvDataSegmentLengthFn)
2493 dlsym(plugintable[i].hPlugin,
2494 "IMA_SetMaxRecvDataSegmentLength");
2495 #endif
2496
2497 if (PassFunc != NULL) {
2498 status = PassFunc(
2499 lhbaId,
2500 maxRecvDataSegmentLength);
2501 }
2502 os_releasemutex(plugintable[i].pluginMutex);
2503 }
2504
2505 break;
2506 }
2507 }
2508 os_releasemutex(libMutex);
2509 return (status);
2510 }
2511
2512
2513 IMA_API IMA_STATUS IMA_GetMaxConnectionsProperties(
2514 IMA_OID Oid,
2515 IMA_MIN_MAX_VALUE *pProps) {
2516 IMA_GetMaxConnectionsPropertiesFn PassFunc;
2517 IMA_UINT i;
2518 IMA_STATUS status;
2519
2520 if (number_of_plugins == -1)
2521 InitLibrary();
2522
2523 if (pProps == NULL)
2524 return (IMA_ERROR_INVALID_PARAMETER);
2525
2526 if (Oid.objectType != IMA_OBJECT_TYPE_LHBA &&
2527 Oid.objectType != IMA_OBJECT_TYPE_TARGET)
2528 return (IMA_ERROR_INCORRECT_OBJECT_TYPE);
2529
2530 os_obtainmutex(libMutex);
2531 status = IMA_ERROR_OBJECT_NOT_FOUND;
2532
2533 for (i = 0; i < number_of_plugins; i++) {
2534 if (plugintable[i].ownerId == Oid.ownerId) {
2535 status = IMA_ERROR_UNEXPECTED_OS_ERROR;
2536 if (plugintable[i].hPlugin != NULL) {
2537 os_obtainmutex(plugintable[i].pluginMutex);
2538 #ifdef WIN32
2539 PassFunc =
2540 (IMA_GetMaxConnectionsPropertiesFn)
2541 GetProcAddress(plugintable[i].hPlugin,
2542 "IMA_GetMaxConnectionsProperties");
2543 #else
2544 PassFunc =
2545 (IMA_GetMaxConnectionsPropertiesFn)
2546 dlsym(plugintable[i].hPlugin,
2547 "IMA_GetMaxConnectionsProperties");
2548 #endif
2549
2550 if (PassFunc != NULL) {
2551 status = PassFunc(Oid, pProps);
2552 }
2553 os_releasemutex(plugintable[i].pluginMutex);
2554 }
2555
2556 break;
2557 }
2558 }
2559 os_releasemutex(libMutex);
2560 return (status);
2561 }
2562
2563
2564 IMA_API IMA_STATUS IMA_SetMaxConnections(
2565 IMA_OID lhbaId,
2566 IMA_UINT maxConnections) {
2567 IMA_SetMaxConnectionsFn PassFunc;
2568 IMA_UINT i;
2569 IMA_STATUS status;
2570
2571 if (number_of_plugins == -1)
2572 InitLibrary();
2573
2574 if (lhbaId.objectType != IMA_OBJECT_TYPE_LHBA &&
2575 lhbaId.objectType != IMA_OBJECT_TYPE_TARGET)
2576 return (IMA_ERROR_INCORRECT_OBJECT_TYPE);
2577
2578 os_obtainmutex(libMutex);
2579 status = IMA_ERROR_OBJECT_NOT_FOUND;
2580
2581 for (i = 0; i < number_of_plugins; i++) {
2582 if (plugintable[i].ownerId == lhbaId.ownerId) {
2583 status = IMA_ERROR_UNEXPECTED_OS_ERROR;
2584 if (plugintable[i].hPlugin != NULL) {
2585 os_obtainmutex(plugintable[i].pluginMutex);
2586 #ifdef WIN32
2587 PassFunc = (IMA_SetMaxConnectionsFn)
2588 GetProcAddress(plugintable[i].hPlugin,
2589 "IMA_SetMaxConnections");
2590 #else
2591 PassFunc = (IMA_SetMaxConnectionsFn)
2592 dlsym(plugintable[i].hPlugin,
2593 "IMA_SetMaxConnections");
2594 #endif
2595
2596 if (PassFunc != NULL) {
2597 status = PassFunc(
2598 lhbaId, maxConnections);
2599 }
2600 os_releasemutex(plugintable[i].pluginMutex);
2601 }
2602
2603 break;
2604 }
2605 }
2606 os_releasemutex(libMutex);
2607 return (status);
2608 }
2609
2610
2611 IMA_API IMA_STATUS IMA_GetDefaultTime2RetainProperties(
2612 IMA_OID lhbaId,
2613 IMA_MIN_MAX_VALUE *pProps) {
2614 IMA_GetDefaultTime2RetainPropertiesFn PassFunc;
2615 IMA_UINT i;
2616 IMA_STATUS status;
2617
2618 if (number_of_plugins == -1)
2619 InitLibrary();
2620
2621 if (pProps == NULL)
2622 return (IMA_ERROR_INVALID_PARAMETER);
2623
2624 if (lhbaId.objectType != IMA_OBJECT_TYPE_LHBA &&
2625 lhbaId.objectType != IMA_OBJECT_TYPE_TARGET)
2626 return (IMA_ERROR_INCORRECT_OBJECT_TYPE);
2627
2628 os_obtainmutex(libMutex);
2629 status = IMA_ERROR_OBJECT_NOT_FOUND;
2630
2631 for (i = 0; i < number_of_plugins; i++) {
2632 if (plugintable[i].ownerId == lhbaId.ownerId) {
2633 status = IMA_ERROR_UNEXPECTED_OS_ERROR;
2634 if (plugintable[i].hPlugin != NULL) {
2635 os_obtainmutex(plugintable[i].pluginMutex);
2636 #ifdef WIN32
2637 PassFunc =
2638 (IMA_GetDefaultTime2RetainPropertiesFn)
2639 GetProcAddress(plugintable[i].hPlugin,
2640 "IMA_GetDefaultTime2RetainProperties");
2641 #else
2642 PassFunc =
2643 (IMA_GetDefaultTime2RetainPropertiesFn)
2644 dlsym(plugintable[i].hPlugin,
2645 "IMA_GetDefaultTime2RetainProperties");
2646 #endif
2647
2648 if (PassFunc != NULL) {
2649 status = PassFunc(lhbaId, pProps);
2650 }
2651 os_releasemutex(plugintable[i].pluginMutex);
2652 }
2653
2654 break;
2655 }
2656 }
2657 os_releasemutex(libMutex);
2658 return (status);
2659 }
2660
2661
2662 IMA_API IMA_STATUS IMA_SetDefaultTime2Retain(
2663 IMA_OID lhbaId,
2664 IMA_UINT defaultTime2Retain) {
2665 IMA_SetDefaultTime2RetainFn PassFunc;
2666 IMA_UINT i;
2667 IMA_STATUS status;
2668
2669 if (number_of_plugins == -1)
2670 InitLibrary();
2671
2672 if (lhbaId.objectType != IMA_OBJECT_TYPE_LHBA &&
2673 lhbaId.objectType != IMA_OBJECT_TYPE_TARGET)
2674 return (IMA_ERROR_INCORRECT_OBJECT_TYPE);
2675
2676 os_obtainmutex(libMutex);
2677 status = IMA_ERROR_OBJECT_NOT_FOUND;
2678
2679 for (i = 0; i < number_of_plugins; i++) {
2680 if (plugintable[i].ownerId == lhbaId.ownerId) {
2681 status = IMA_ERROR_UNEXPECTED_OS_ERROR;
2682 if (plugintable[i].hPlugin != NULL) {
2683 os_obtainmutex(plugintable[i].pluginMutex);
2684 #ifdef WIN32
2685 PassFunc =
2686 (IMA_SetDefaultTime2RetainFn)
2687 GetProcAddress(plugintable[i].hPlugin,
2688 "IMA_SetDefaultTime2Retain");
2689 #else
2690 PassFunc =
2691 (IMA_SetDefaultTime2RetainFn)
2692 dlsym(plugintable[i].hPlugin,
2693 "IMA_SetDefaultTime2Retain");
2694 #endif
2695
2696 if (PassFunc != NULL) {
2697 status = PassFunc(
2698 lhbaId, defaultTime2Retain);
2699 }
2700 os_releasemutex(plugintable[i].pluginMutex);
2701 }
2702
2703 break;
2704 }
2705 }
2706 os_releasemutex(libMutex);
2707 return (status);
2708 }
2709
2710
2711 IMA_API IMA_STATUS IMA_GetDefaultTime2WaitProperties(
2712 IMA_OID lhbaId,
2713 IMA_MIN_MAX_VALUE *pProps) {
2714 IMA_GetDefaultTime2WaitPropertiesFn PassFunc;
2715 IMA_UINT i;
2716 IMA_STATUS status;
2717
2718 if (number_of_plugins == -1)
2719 InitLibrary();
2720
2721 if (pProps == NULL)
2722 return (IMA_ERROR_INVALID_PARAMETER);
2723
2724 if (lhbaId.objectType != IMA_OBJECT_TYPE_LHBA &&
2725 lhbaId.objectType != IMA_OBJECT_TYPE_TARGET)
2726 return (IMA_ERROR_INCORRECT_OBJECT_TYPE);
2727
2728 os_obtainmutex(libMutex);
2729 status = IMA_ERROR_OBJECT_NOT_FOUND;
2730
2731 for (i = 0; i < number_of_plugins; i++) {
2732 if (plugintable[i].ownerId == lhbaId.ownerId) {
2733 status = IMA_ERROR_UNEXPECTED_OS_ERROR;
2734 if (plugintable[i].hPlugin != NULL) {
2735 os_obtainmutex(plugintable[i].pluginMutex);
2736 #ifdef WIN32
2737 PassFunc =
2738 (IMA_GetDefaultTime2WaitPropertiesFn)
2739 GetProcAddress(plugintable[i].hPlugin,
2740 "IMA_GetDefaultTime2WaitProperties");
2741 #else
2742 PassFunc =
2743 (IMA_GetDefaultTime2WaitPropertiesFn)
2744 dlsym(plugintable[i].hPlugin,
2745 "IMA_GetDefaultTime2WaitProperties");
2746 #endif
2747
2748 if (PassFunc != NULL) {
2749 status = PassFunc(lhbaId, pProps);
2750 }
2751 os_releasemutex(plugintable[i].pluginMutex);
2752 }
2753
2754 break;
2755 }
2756 }
2757 os_releasemutex(libMutex);
2758 return (status);
2759 }
2760
2761
2762 IMA_API IMA_STATUS IMA_SetDefaultTime2Wait(
2763 IMA_OID lhbaId,
2764 IMA_UINT defaultTime2Wait) {
2765 IMA_SetDefaultTime2WaitFn PassFunc;
2766 IMA_UINT i;
2767 IMA_STATUS status;
2768
2769 if (number_of_plugins == -1)
2770 InitLibrary();
2771
2772 if (lhbaId.objectType != IMA_OBJECT_TYPE_LHBA &&
2773 lhbaId.objectType != IMA_OBJECT_TYPE_TARGET)
2774 return (IMA_ERROR_INCORRECT_OBJECT_TYPE);
2775
2776 os_obtainmutex(libMutex);
2777 status = IMA_ERROR_OBJECT_NOT_FOUND;
2778
2779 for (i = 0; i < number_of_plugins; i++) {
2780 if (plugintable[i].ownerId == lhbaId.ownerId) {
2781 status = IMA_ERROR_UNEXPECTED_OS_ERROR;
2782 if (plugintable[i].hPlugin != NULL) {
2783 os_obtainmutex(plugintable[i].pluginMutex);
2784 #ifdef WIN32
2785 PassFunc =
2786 (IMA_SetDefaultTime2WaitFn)
2787 GetProcAddress(plugintable[i].hPlugin,
2788 "IMA_SetDefaultTime2Wait");
2789 #else
2790 PassFunc =
2791 (IMA_SetDefaultTime2WaitFn)
2792 dlsym(plugintable[i].hPlugin,
2793 "IMA_SetDefaultTime2Wait");
2794 #endif
2795
2796 if (PassFunc != NULL) {
2797 status = PassFunc(
2798 lhbaId, defaultTime2Wait);
2799 }
2800 os_releasemutex(plugintable[i].pluginMutex);
2801 }
2802
2803 break;
2804 }
2805 }
2806 os_releasemutex(libMutex);
2807 return (status);
2808 }
2809
2810
2811 IMA_API IMA_STATUS IMA_GetMaxOutstandingR2TProperties(
2812 IMA_OID Oid,
2813 IMA_MIN_MAX_VALUE *pProps) {
2814 IMA_GetMaxOutstandingR2TPropertiesFn PassFunc;
2815 IMA_UINT i;
2816 IMA_STATUS status;
2817
2818 if (number_of_plugins == -1)
2819 InitLibrary();
2820
2821 if (pProps == NULL)
2822 return (IMA_ERROR_INVALID_PARAMETER);
2823
2824 if (Oid.objectType != IMA_OBJECT_TYPE_LHBA &&
2825 Oid.objectType != IMA_OBJECT_TYPE_TARGET)
2826 return (IMA_ERROR_INCORRECT_OBJECT_TYPE);
2827
2828 os_obtainmutex(libMutex);
2829 status = IMA_ERROR_OBJECT_NOT_FOUND;
2830
2831 for (i = 0; i < number_of_plugins; i++) {
2832 if (plugintable[i].ownerId == Oid.ownerId) {
2833 status = IMA_ERROR_UNEXPECTED_OS_ERROR;
2834 if (plugintable[i].hPlugin != NULL) {
2835 os_obtainmutex(plugintable[i].pluginMutex);
2836 #ifdef WIN32
2837 PassFunc =
2838 (IMA_GetMaxOutstandingR2TPropertiesFn)
2839 GetProcAddress(plugintable[i].hPlugin,
2840 "IMA_GetMaxOutstandingR2TProperties");
2841 #else
2842 PassFunc =
2843 (IMA_GetMaxOutstandingR2TPropertiesFn)
2844 dlsym(plugintable[i].hPlugin,
2845 "IMA_GetMaxOutstandingR2TProperties");
2846 #endif
2847
2848 if (PassFunc != NULL) {
2849 status = PassFunc(Oid, pProps);
2850 }
2851 os_releasemutex(plugintable[i].pluginMutex);
2852 }
2853
2854 break;
2855 }
2856 }
2857 os_releasemutex(libMutex);
2858 return (status);
2859 }
2860
2861
2862 IMA_API IMA_STATUS IMA_SetMaxOutstandingR2T(
2863 IMA_OID lhbaId,
2864 IMA_UINT maxOutstandingR2T) {
2865 IMA_SetMaxOutstandingR2TFn PassFunc;
2866 IMA_UINT i;
2867 IMA_STATUS status;
2868
2869 if (number_of_plugins == -1)
2870 InitLibrary();
2871
2872 if (lhbaId.objectType != IMA_OBJECT_TYPE_LHBA &&
2873 lhbaId.objectType != IMA_OBJECT_TYPE_TARGET)
2874 return (IMA_ERROR_INCORRECT_OBJECT_TYPE);
2875
2876 os_obtainmutex(libMutex);
2877 status = IMA_ERROR_OBJECT_NOT_FOUND;
2878
2879 for (i = 0; i < number_of_plugins; i++) {
2880 if (plugintable[i].ownerId == lhbaId.ownerId) {
2881 status = IMA_ERROR_UNEXPECTED_OS_ERROR;
2882 if (plugintable[i].hPlugin != NULL) {
2883 os_obtainmutex(plugintable[i].pluginMutex);
2884 #ifdef WIN32
2885 PassFunc =
2886 (IMA_SetMaxOutstandingR2TFn)
2887 GetProcAddress(plugintable[i].hPlugin,
2888 "IMA_SetMaxOutstandingR2T");
2889 #else
2890 PassFunc =
2891 (IMA_SetMaxOutstandingR2TFn)
2892 dlsym(plugintable[i].hPlugin,
2893 "IMA_SetMaxOutstandingR2T");
2894 #endif
2895
2896 if (PassFunc != NULL) {
2897 status = PassFunc(
2898 lhbaId, maxOutstandingR2T);
2899 }
2900 os_releasemutex(plugintable[i].pluginMutex);
2901 }
2902
2903 break;
2904 }
2905 }
2906 os_releasemutex(libMutex);
2907 return (status);
2908 }
2909
2910
2911 IMA_API IMA_STATUS IMA_GetErrorRecoveryLevelProperties(
2912 IMA_OID Oid,
2913 IMA_MIN_MAX_VALUE *pProps) {
2914 IMA_GetMaxOutstandingR2TPropertiesFn PassFunc;
2915 IMA_UINT i;
2916 IMA_STATUS status;
2917
2918 if (number_of_plugins == -1)
2919 InitLibrary();
2920
2921 if (pProps == NULL)
2922 return (IMA_ERROR_INVALID_PARAMETER);
2923
2924 if (Oid.objectType != IMA_OBJECT_TYPE_LHBA &&
2925 Oid.objectType != IMA_OBJECT_TYPE_TARGET)
2926 return (IMA_ERROR_INCORRECT_OBJECT_TYPE);
2927
2928 os_obtainmutex(libMutex);
2929 status = IMA_ERROR_OBJECT_NOT_FOUND;
2930
2931 for (i = 0; i < number_of_plugins; i++) {
2932 if (plugintable[i].ownerId == Oid.ownerId) {
2933 status = IMA_ERROR_UNEXPECTED_OS_ERROR;
2934 if (plugintable[i].hPlugin != NULL) {
2935 os_obtainmutex(plugintable[i].pluginMutex);
2936 #ifdef WIN32
2937 PassFunc =
2938 (IMA_GetErrorRecoveryLevelPropertiesFn)
2939 GetProcAddress(plugintable[i].hPlugin,
2940 "IMA_GetErrorRecoveryLevelProperties");
2941 #else
2942 PassFunc =
2943 (IMA_GetErrorRecoveryLevelPropertiesFn)
2944 dlsym(plugintable[i].hPlugin,
2945 "IMA_GetErrorRecoveryLevelProperties");
2946 #endif
2947
2948 if (PassFunc != NULL) {
2949 status = PassFunc(Oid, pProps);
2950 }
2951 os_releasemutex(plugintable[i].pluginMutex);
2952 }
2953
2954 break;
2955 }
2956 }
2957 os_releasemutex(libMutex);
2958 return (status);
2959 }
2960
2961
2962 IMA_API IMA_STATUS IMA_SetErrorRecoveryLevel(
2963 IMA_OID Oid,
2964 IMA_UINT errorRecoveryLevel) {
2965 IMA_SetErrorRecoveryLevelFn PassFunc;
2966 IMA_UINT i;
2967 IMA_STATUS status;
2968
2969 if (number_of_plugins == -1)
2970 InitLibrary();
2971
2972 if (Oid.objectType != IMA_OBJECT_TYPE_LHBA &&
2973 Oid.objectType != IMA_OBJECT_TYPE_TARGET)
2974 return (IMA_ERROR_INCORRECT_OBJECT_TYPE);
2975
2976 os_obtainmutex(libMutex);
2977 status = IMA_ERROR_OBJECT_NOT_FOUND;
2978
2979 for (i = 0; i < number_of_plugins; i++) {
2980 if (plugintable[i].ownerId == Oid.ownerId) {
2981 status = IMA_ERROR_UNEXPECTED_OS_ERROR;
2982 if (plugintable[i].hPlugin != NULL) {
2983 os_obtainmutex(plugintable[i].pluginMutex);
2984 #ifdef WIN32
2985 PassFunc =
2986 (IMA_SetErrorRecoveryLevelFn)
2987 GetProcAddress(plugintable[i].hPlugin,
2988 "IMA_SetErrorRecoveryLevel");
2989 #else
2990 PassFunc =
2991 (IMA_SetErrorRecoveryLevelFn)
2992 dlsym(plugintable[i].hPlugin,
2993 "IMA_SetErrorRecoveryLevel");
2994 #endif
2995
2996 if (PassFunc != NULL) {
2997 status = PassFunc(
2998 Oid, errorRecoveryLevel);
2999 }
3000 os_releasemutex(plugintable[i].pluginMutex);
3001 }
3002
3003 break;
3004 }
3005 }
3006 os_releasemutex(libMutex);
3007 return (status);
3008 }
3009
3010
3011 IMA_API IMA_STATUS IMA_GetInitialR2TProperties(
3012 IMA_OID Oid,
3013 IMA_BOOL_VALUE *pProps) {
3014 IMA_GetInitialR2TPropertiesFn PassFunc;
3015 IMA_UINT i;
3016 IMA_STATUS status;
3017
3018 if (number_of_plugins == -1)
3019 InitLibrary();
3020
3021 if (pProps == NULL)
3022 return (IMA_ERROR_INVALID_PARAMETER);
3023
3024 if (Oid.objectType != IMA_OBJECT_TYPE_LHBA &&
3025 Oid.objectType != IMA_OBJECT_TYPE_TARGET)
3026 return (IMA_ERROR_INCORRECT_OBJECT_TYPE);
3027
3028 os_obtainmutex(libMutex);
3029 status = IMA_ERROR_OBJECT_NOT_FOUND;
3030
3031 for (i = 0; i < number_of_plugins; i++) {
3032 if (plugintable[i].ownerId == Oid.ownerId) {
3033 status = IMA_ERROR_UNEXPECTED_OS_ERROR;
3034 if (plugintable[i].hPlugin != NULL) {
3035 os_obtainmutex(plugintable[i].pluginMutex);
3036 #ifdef WIN32
3037 PassFunc =
3038 (IMA_GetInitialR2TPropertiesFn)
3039 GetProcAddress(plugintable[i].hPlugin,
3040 "IMA_GetInitialR2TProperties");
3041 #else
3042 PassFunc =
3043 (IMA_GetInitialR2TPropertiesFn)
3044 dlsym(plugintable[i].hPlugin,
3045 "IMA_GetInitialR2TProperties");
3046 #endif
3047
3048 if (PassFunc != NULL) {
3049 status = PassFunc(Oid, pProps);
3050 }
3051 os_releasemutex(plugintable[i].pluginMutex);
3052 }
3053
3054 break;
3055 }
3056 }
3057 os_releasemutex(libMutex);
3058 return (status);
3059 }
3060
3061
3062 IMA_API IMA_STATUS IMA_SetInitialR2T(
3063 IMA_OID Oid,
3064 IMA_BOOL initialR2T)
3065 {
3066 IMA_SetInitialR2TFn PassFunc;
3067 IMA_UINT i;
3068 IMA_STATUS status;
3069
3070 if (number_of_plugins == -1)
3071 InitLibrary();
3072
3073 if (initialR2T != IMA_TRUE &&
3074 initialR2T != IMA_FALSE)
3075 return (IMA_ERROR_INVALID_PARAMETER);
3076
3077 if (Oid.objectType != IMA_OBJECT_TYPE_LHBA &&
3078 Oid.objectType != IMA_OBJECT_TYPE_TARGET)
3079 return (IMA_ERROR_INCORRECT_OBJECT_TYPE);
3080
3081 os_obtainmutex(libMutex);
3082 status = IMA_ERROR_OBJECT_NOT_FOUND;
3083
3084 for (i = 0; i < number_of_plugins; i++) {
3085 if (plugintable[i].ownerId == Oid.ownerId) {
3086 status = IMA_ERROR_UNEXPECTED_OS_ERROR;
3087 if (plugintable[i].hPlugin != NULL) {
3088 os_obtainmutex(plugintable[i].pluginMutex);
3089 #ifdef WIN32
3090 PassFunc =
3091 (IMA_SetInitialR2TFn) GetProcAddress(
3092 plugintable[i].hPlugin,
3093 "IMA_SetInitialR2T");
3094 #else
3095 PassFunc =
3096 (IMA_SetInitialR2TFn)
3097 dlsym(plugintable[i].hPlugin,
3098 "IMA_SetInitialR2T");
3099 #endif
3100
3101 if (PassFunc != NULL) {
3102 status = PassFunc(Oid, initialR2T);
3103 }
3104 os_releasemutex(plugintable[i].pluginMutex);
3105 }
3106
3107 break;
3108 }
3109 }
3110 os_releasemutex(libMutex);
3111 return (status);
3112 }
3113
3114
3115 IMA_API IMA_STATUS IMA_GetImmediateDataProperties(
3116 IMA_OID Oid,
3117 IMA_BOOL_VALUE *pProps) {
3118 IMA_GetImmediateDataPropertiesFn PassFunc;
3119 IMA_UINT i;
3120 IMA_STATUS status;
3121
3122 if (number_of_plugins == -1)
3123 InitLibrary();
3124
3125 if (pProps == NULL)
3126 return (IMA_ERROR_INVALID_PARAMETER);
3127
3128 if (Oid.objectType != IMA_OBJECT_TYPE_LHBA &&
3129 Oid.objectType != IMA_OBJECT_TYPE_TARGET)
3130 return (IMA_ERROR_INCORRECT_OBJECT_TYPE);
3131
3132 os_obtainmutex(libMutex);
3133 status = IMA_ERROR_OBJECT_NOT_FOUND;
3134
3135 for (i = 0; i < number_of_plugins; i++) {
3136 if (plugintable[i].ownerId == Oid.ownerId) {
3137 status = IMA_ERROR_UNEXPECTED_OS_ERROR;
3138 if (plugintable[i].hPlugin != NULL) {
3139 os_obtainmutex(plugintable[i].pluginMutex);
3140 #ifdef WIN32
3141 PassFunc =
3142 (IMA_GetImmediateDataPropertiesFn)
3143 GetProcAddress(plugintable[i].hPlugin,
3144 "IMA_GetImmediateDataProperties");
3145 #else
3146 PassFunc =
3147 (IMA_GetImmediateDataPropertiesFn)
3148 dlsym(plugintable[i].hPlugin,
3149 "IMA_GetImmediateDataProperties");
3150 #endif
3151
3152 if (PassFunc != NULL) {
3153 status = PassFunc(Oid, pProps);
3154 }
3155 os_releasemutex(plugintable[i].pluginMutex);
3156 }
3157
3158 break;
3159 }
3160 }
3161 os_releasemutex(libMutex);
3162 return (status);
3163 }
3164
3165
3166 IMA_API IMA_STATUS IMA_SetImmediateData(
3167 IMA_OID Oid,
3168 IMA_BOOL immediateData) {
3169 IMA_SetImmediateDataFn PassFunc;
3170 IMA_UINT i;
3171 IMA_STATUS status;
3172
3173 if (number_of_plugins == -1)
3174 InitLibrary();
3175
3176 if (immediateData != IMA_TRUE &&
3177 immediateData != IMA_FALSE)
3178 return (IMA_ERROR_INVALID_PARAMETER);
3179
3180 if (Oid.objectType != IMA_OBJECT_TYPE_LHBA &&
3181 Oid.objectType != IMA_OBJECT_TYPE_TARGET)
3182 return (IMA_ERROR_INCORRECT_OBJECT_TYPE);
3183
3184 os_obtainmutex(libMutex);
3185 status = IMA_ERROR_OBJECT_NOT_FOUND;
3186
3187 for (i = 0; i < number_of_plugins; i++) {
3188 if (plugintable[i].ownerId == Oid.ownerId) {
3189 status = IMA_ERROR_UNEXPECTED_OS_ERROR;
3190 if (plugintable[i].hPlugin != NULL) {
3191 os_obtainmutex(plugintable[i].pluginMutex);
3192 #ifdef WIN32
3193 PassFunc =
3194 (IMA_SetImmediateDataFn)
3195 GetProcAddress(plugintable[i].hPlugin,
3196 "IMA_SetImmediateData");
3197 #else
3198 PassFunc =
3199 (IMA_SetImmediateDataFn)
3200 dlsym(plugintable[i].hPlugin,
3201 "IMA_SetImmediateData");
3202 #endif
3203
3204 if (PassFunc != NULL) {
3205 status = PassFunc(Oid, immediateData);
3206 }
3207 os_releasemutex(plugintable[i].pluginMutex);
3208 }
3209
3210 break;
3211 }
3212 }
3213 os_releasemutex(libMutex);
3214 return (status);
3215 }
3216
3217
3218 IMA_API IMA_STATUS IMA_GetDataPduInOrderProperties(
3219 IMA_OID Oid,
3220 IMA_BOOL_VALUE *pProps) {
3221 IMA_GetDataPduInOrderPropertiesFn PassFunc;
3222 IMA_UINT i;
3223 IMA_STATUS status;
3224
3225 if (number_of_plugins == -1)
3226 InitLibrary();
3227
3228 if (pProps == NULL)
3229 return (IMA_ERROR_INVALID_PARAMETER);
3230
3231 if (Oid.objectType != IMA_OBJECT_TYPE_LHBA &&
3232 Oid.objectType != IMA_OBJECT_TYPE_TARGET)
3233 return (IMA_ERROR_INCORRECT_OBJECT_TYPE);
3234
3235 os_obtainmutex(libMutex);
3236 status = IMA_ERROR_OBJECT_NOT_FOUND;
3237
3238 for (i = 0; i < number_of_plugins; i++) {
3239 if (plugintable[i].ownerId == Oid.ownerId) {
3240 status = IMA_ERROR_UNEXPECTED_OS_ERROR;
3241 if (plugintable[i].hPlugin != NULL) {
3242 os_obtainmutex(plugintable[i].pluginMutex);
3243 #ifdef WIN32
3244 PassFunc =
3245 (IMA_GetDataPduInOrderPropertiesFn)
3246 GetProcAddress(plugintable[i].hPlugin,
3247 "IMA_GetDataPduInOrderProperties");
3248 #else
3249 PassFunc =
3250 (IMA_GetDataPduInOrderPropertiesFn)
3251 dlsym(plugintable[i].hPlugin,
3252 "IMA_GetDataPduInOrderProperties");
3253 #endif
3254
3255 if (PassFunc != NULL) {
3256 status = PassFunc(Oid, pProps);
3257 }
3258 os_releasemutex(plugintable[i].pluginMutex);
3259 }
3260
3261 break;
3262 }
3263 }
3264 os_releasemutex(libMutex);
3265 return (status);
3266 }
3267
3268
3269 IMA_API IMA_STATUS IMA_SetDataPduInOrder(
3270 IMA_OID Oid,
3271 IMA_BOOL dataPduInOrder) {
3272 IMA_SetDataPduInOrderFn PassFunc;
3273 IMA_UINT i;
3274 IMA_STATUS status;
3275
3276 if (number_of_plugins == -1)
3277 InitLibrary();
3278
3279 if (dataPduInOrder != IMA_TRUE &&
3280 dataPduInOrder != IMA_FALSE)
3281 return (IMA_ERROR_INVALID_PARAMETER);
3282
3283 if (Oid.objectType != IMA_OBJECT_TYPE_LHBA &&
3284 Oid.objectType != IMA_OBJECT_TYPE_TARGET)
3285 return (IMA_ERROR_INCORRECT_OBJECT_TYPE);
3286
3287 os_obtainmutex(libMutex);
3288 status = IMA_ERROR_OBJECT_NOT_FOUND;
3289
3290 for (i = 0; i < number_of_plugins; i++) {
3291 if (plugintable[i].ownerId == Oid.ownerId) {
3292 status = IMA_ERROR_UNEXPECTED_OS_ERROR;
3293 if (plugintable[i].hPlugin != NULL) {
3294 os_obtainmutex(plugintable[i].pluginMutex);
3295 #ifdef WIN32
3296 PassFunc =
3297 (IMA_SetDataPduInOrderFn)
3298 GetProcAddress(plugintable[i].hPlugin,
3299 "IMA_SetDataPduInOrder");
3300 #else
3301 PassFunc =
3302 (IMA_SetDataPduInOrderFn)
3303 dlsym(plugintable[i].hPlugin,
3304 "IMA_SetDataPduInOrder");
3305 #endif
3306
3307 if (PassFunc != NULL) {
3308 status = PassFunc(Oid, dataPduInOrder);
3309 }
3310 os_releasemutex(plugintable[i].pluginMutex);
3311 }
3312
3313 break;
3314 }
3315 }
3316 os_releasemutex(libMutex);
3317 return (status);
3318 }
3319
3320
3321 IMA_API IMA_STATUS IMA_GetDataSequenceInOrderProperties(
3322 IMA_OID Oid,
3323 IMA_BOOL_VALUE *pProps) {
3324 IMA_GetDataSequenceInOrderPropertiesFn PassFunc;
3325 IMA_UINT i;
3326 IMA_STATUS status;
3327
3328 if (number_of_plugins == -1)
3329 InitLibrary();
3330
3331 if (pProps == NULL)
3332 return (IMA_ERROR_INVALID_PARAMETER);
3333
3334 if (Oid.objectType != IMA_OBJECT_TYPE_LHBA &&
3335 Oid.objectType != IMA_OBJECT_TYPE_TARGET)
3336 return (IMA_ERROR_INCORRECT_OBJECT_TYPE);
3337
3338 os_obtainmutex(libMutex);
3339 status = IMA_ERROR_OBJECT_NOT_FOUND;
3340
3341 for (i = 0; i < number_of_plugins; i++) {
3342 if (plugintable[i].ownerId == Oid.ownerId) {
3343 status = IMA_ERROR_UNEXPECTED_OS_ERROR;
3344 if (plugintable[i].hPlugin != NULL) {
3345 os_obtainmutex(plugintable[i].pluginMutex);
3346 #ifdef WIN32
3347 PassFunc =
3348 (IMA_GetDataSequenceInOrderPropertiesFn)
3349 GetProcAddress(plugintable[i].hPlugin,
3350 "IMA_GetDataSequenceInOrderProperties");
3351 #else
3352 PassFunc =
3353 (IMA_GetDataSequenceInOrderPropertiesFn)
3354 dlsym(plugintable[i].hPlugin,
3355 "IMA_GetDataSequenceInOrderProperties");
3356 #endif
3357
3358 if (PassFunc != NULL) {
3359 status = PassFunc(Oid, pProps);
3360 }
3361 os_releasemutex(plugintable[i].pluginMutex);
3362 }
3363
3364 break;
3365 }
3366 }
3367 os_releasemutex(libMutex);
3368 return (status);
3369 }
3370
3371
3372 IMA_API IMA_STATUS IMA_SetDataSequenceInOrder(
3373 IMA_OID Oid,
3374 IMA_BOOL dataSequenceInOrder) {
3375 IMA_SetDataSequenceInOrderFn PassFunc;
3376 IMA_UINT i;
3377 IMA_STATUS status;
3378
3379 if (number_of_plugins == -1)
3380 InitLibrary();
3381
3382 if (dataSequenceInOrder != IMA_TRUE &&
3383 dataSequenceInOrder != IMA_FALSE)
3384 return (IMA_ERROR_INVALID_PARAMETER);
3385
3386 if (Oid.objectType != IMA_OBJECT_TYPE_LHBA &&
3387 Oid.objectType != IMA_OBJECT_TYPE_TARGET)
3388 return (IMA_ERROR_INCORRECT_OBJECT_TYPE);
3389
3390 os_obtainmutex(libMutex);
3391 status = IMA_ERROR_OBJECT_NOT_FOUND;
3392
3393 for (i = 0; i < number_of_plugins; i++) {
3394 if (plugintable[i].ownerId == Oid.ownerId) {
3395 status = IMA_ERROR_UNEXPECTED_OS_ERROR;
3396 if (plugintable[i].hPlugin != NULL) {
3397 os_obtainmutex(plugintable[i].pluginMutex);
3398 #ifdef WIN32
3399 PassFunc =
3400 (IMA_SetDataSequenceInOrderFn)
3401 GetProcAddress(plugintable[i].hPlugin,
3402 "IMA_SetDataSequenceInOrder");
3403 #else
3404 PassFunc =
3405 (IMA_SetDataSequenceInOrderFn)
3406 dlsym(plugintable[i].hPlugin,
3407 "IMA_SetDataSequenceInOrder");
3408 #endif
3409
3410 if (PassFunc != NULL) {
3411 status = PassFunc(
3412 Oid, dataSequenceInOrder);
3413 }
3414 os_releasemutex(plugintable[i].pluginMutex);
3415 }
3416
3417 break;
3418 }
3419 }
3420 os_releasemutex(libMutex);
3421 return (status);
3422 }
3423
3424
3425 IMA_API IMA_STATUS IMA_SetStatisticsCollection(
3426 IMA_OID Oid,
3427 IMA_BOOL enableStatisticsCollection) {
3428 IMA_SetStatisticsCollectionFn PassFunc;
3429 IMA_UINT i;
3430 IMA_STATUS status;
3431
3432 if (number_of_plugins == -1)
3433 InitLibrary();
3434
3435 if (enableStatisticsCollection != IMA_TRUE &&
3436 enableStatisticsCollection != IMA_FALSE)
3437 return (IMA_ERROR_INVALID_PARAMETER);
3438
3439 if (Oid.objectType != IMA_OBJECT_TYPE_PHBA &&
3440 Oid.objectType != IMA_OBJECT_TYPE_TARGET)
3441 return (IMA_ERROR_INCORRECT_OBJECT_TYPE);
3442
3443 os_obtainmutex(libMutex);
3444 status = IMA_ERROR_OBJECT_NOT_FOUND;
3445
3446 for (i = 0; i < number_of_plugins; i++) {
3447 if (plugintable[i].ownerId == Oid.ownerId) {
3448 status = IMA_ERROR_UNEXPECTED_OS_ERROR;
3449 if (plugintable[i].hPlugin != NULL) {
3450 os_obtainmutex(plugintable[i].pluginMutex);
3451 #ifdef WIN32
3452 PassFunc =
3453 (IMA_SetStatisticsCollectionFn)
3454 GetProcAddress(plugintable[i].hPlugin,
3455 "IMA_SetStatisticsCollection");
3456 #else
3457 PassFunc =
3458 (IMA_SetStatisticsCollectionFn)
3459 dlsym(plugintable[i].hPlugin,
3460 "IMA_SetStatisticsCollection");
3461 #endif
3462
3463 if (PassFunc != NULL) {
3464 status = PassFunc(
3465 Oid, enableStatisticsCollection);
3466 }
3467 os_releasemutex(plugintable[i].pluginMutex);
3468 }
3469
3470 break;
3471 }
3472 }
3473 os_releasemutex(libMutex);
3474 return (status);
3475 }
3476
3477
3478 IMA_API IMA_STATUS IMA_GetNetworkPortStatus(
3479 IMA_OID portOid,
3480 IMA_NETWORK_PORT_STATUS *pStatus) {
3481 IMA_GetNetworkPortStatusFn PassFunc;
3482 IMA_UINT i;
3483 IMA_STATUS status;
3484
3485 if (number_of_plugins == -1)
3486 InitLibrary();
3487
3488 if (pStatus == NULL)
3489 return (IMA_ERROR_INVALID_PARAMETER);
3490
3491 if (portOid.objectType != IMA_OBJECT_TYPE_PNP &&
3492 portOid.objectType != IMA_OBJECT_TYPE_LNP)
3493 return (IMA_ERROR_INCORRECT_OBJECT_TYPE);
3494
3495 os_obtainmutex(libMutex);
3496 status = IMA_ERROR_OBJECT_NOT_FOUND;
3497
3498 for (i = 0; i < number_of_plugins; i++) {
3499 if (plugintable[i].ownerId == portOid.ownerId) {
3500 status = IMA_ERROR_UNEXPECTED_OS_ERROR;
3501 if (plugintable[i].hPlugin != NULL) {
3502 os_obtainmutex(plugintable[i].pluginMutex);
3503 #ifdef WIN32
3504 PassFunc =
3505 (IMA_GetNetworkPortStatusFn)
3506 GetProcAddress(plugintable[i].hPlugin,
3507 "IMA_GetNetworkPortStatus");
3508 #else
3509 PassFunc =
3510 (IMA_GetNetworkPortStatusFn)
3511 dlsym(plugintable[i].hPlugin,
3512 "IMA_GetNetworkPortStatus");
3513 #endif
3514
3515 if (PassFunc != NULL) {
3516 status = PassFunc(portOid, pStatus);
3517 }
3518 os_releasemutex(plugintable[i].pluginMutex);
3519 }
3520
3521 break;
3522 }
3523 }
3524 os_releasemutex(libMutex);
3525 return (status);
3526 }
3527
3528
3529 IMA_API IMA_STATUS IMA_GetTargetOidList(
3530 IMA_OID Oid,
3531 IMA_OID_LIST **ppList) {
3532 IMA_GetTargetOidListFn PassFunc;
3533 IMA_FreeMemoryFn FreeFunc;
3534 IMA_UINT i;
3535 IMA_STATUS status;
3536
3537 if (number_of_plugins == -1)
3538 InitLibrary();
3539
3540 if (ppList == NULL)
3541 return (IMA_ERROR_INVALID_PARAMETER);
3542
3543 if (Oid.objectType != IMA_OBJECT_TYPE_LHBA &&
3544 Oid.objectType != IMA_OBJECT_TYPE_LNP)
3545 return (IMA_ERROR_INCORRECT_OBJECT_TYPE);
3546
3547 os_obtainmutex(libMutex);
3548 status = IMA_ERROR_OBJECT_NOT_FOUND;
3549
3550 for (i = 0; i < number_of_plugins; i++) {
3551 if (plugintable[i].ownerId == Oid.ownerId) {
3552 status = IMA_ERROR_UNEXPECTED_OS_ERROR;
3553 if (plugintable[i].hPlugin != NULL) {
3554 os_obtainmutex(plugintable[i].pluginMutex);
3555 #ifdef WIN32
3556 PassFunc =
3557 (IMA_GetTargetOidListFn)
3558 GetProcAddress(plugintable[i].hPlugin,
3559 "IMA_GetTargetOidList");
3560 #else
3561 PassFunc =
3562 (IMA_GetTargetOidListFn)
3563 dlsym(plugintable[i].hPlugin,
3564 "IMA_GetTargetOidList");
3565 #endif
3566
3567 if (PassFunc != NULL) {
3568 IMA_OID_LIST *ppOidList;
3569 IMA_UINT listSize;
3570 listSize = sizeof (IMA_OID_LIST);
3571 status = PassFunc(Oid, &ppOidList);
3572 if (IMA_SUCCESS(status)) {
3573 *ppList =
3574 (IMA_OID_LIST*)calloc(1,
3575 sizeof (IMA_OID_LIST) +
3576 ((ppOidList->oidCount - 1)*
3577 sizeof (IMA_OID)));
3578
3579 if ((*ppList) == NULL) {
3580 return (EUOS_ERROR);
3581 }
3582 else
3583 memcpy((*ppList),
3584 ppOidList, listSize
3585 + (ppOidList->
3586 oidCount - 1)*
3587 sizeof (IMA_OID));
3588 #ifdef WIN32
3589 FreeFunc = (IMA_FreeMemoryFn)
3590 GetProcAddress(
3591 plugintable[i].hPlugin,
3592 "IMA_FreeMemory");
3593 #else
3594 FreeFunc = (IMA_FreeMemoryFn)
3595 dlsym(
3596 plugintable[i].hPlugin,
3597 "IMA_FreeMemory");
3598 #endif
3599 if (FreeFunc != NULL) {
3600 FreeFunc(ppOidList);
3601 }
3602 }
3603 }
3604 os_releasemutex(plugintable[i].pluginMutex);
3605 }
3606
3607 break;
3608 }
3609 }
3610 os_releasemutex(libMutex);
3611 return (status);
3612 }
3613
3614
3615 IMA_API IMA_STATUS IMA_RemoveStaleData(
3616 IMA_OID lhbaId) {
3617 IMA_RemoveStaleDataFn PassFunc;
3618 IMA_UINT i;
3619 IMA_STATUS status;
3620
3621 if (number_of_plugins == -1)
3622 InitLibrary();
3623
3624 if (lhbaId.objectType != IMA_OBJECT_TYPE_LHBA)
3625 return (IMA_ERROR_INCORRECT_OBJECT_TYPE);
3626
3627 os_obtainmutex(libMutex);
3628 status = IMA_ERROR_OBJECT_NOT_FOUND;
3629
3630 for (i = 0; i < number_of_plugins; i++) {
3631 if (plugintable[i].ownerId == lhbaId.ownerId) {
3632 status = IMA_ERROR_UNEXPECTED_OS_ERROR;
3633 if (plugintable[i].hPlugin != NULL) {
3634 os_obtainmutex(plugintable[i].pluginMutex);
3635 #ifdef WIN32
3636 PassFunc = (IMA_RemoveStaleDataFn)
3637 GetProcAddress(plugintable[i].hPlugin,
3638 "IMA_RemoveStaleData");
3639 #else
3640 PassFunc = (IMA_RemoveStaleDataFn)
3641 dlsym(plugintable[i].hPlugin,
3642 "IMA_RemoveStaleData");
3643 #endif
3644
3645 if (PassFunc != NULL) {
3646 status = PassFunc(lhbaId);
3647 }
3648 os_releasemutex(plugintable[i].pluginMutex);
3649 }
3650
3651 break;
3652 }
3653 }
3654 os_releasemutex(libMutex);
3655 return (status);
3656 }
3657
3658
3659 IMA_API IMA_STATUS IMA_SetIsnsDiscovery(
3660 IMA_OID phbaId,
3661 IMA_BOOL enableIsnsDiscovery,
3662 IMA_ISNS_DISCOVERY_METHOD discoveryMethod,
3663 const IMA_HOST_ID *iSnsHost) {
3664 IMA_SetIsnsDiscoveryFn PassFunc;
3665 IMA_UINT i;
3666 IMA_STATUS status;
3667
3668 if (number_of_plugins == -1)
3669 InitLibrary();
3670
3671 if (enableIsnsDiscovery != IMA_TRUE &&
3672 enableIsnsDiscovery != IMA_FALSE)
3673 return (IMA_ERROR_INVALID_PARAMETER);
3674
3675 if (enableIsnsDiscovery == IMA_TRUE && iSnsHost == NULL)
3676 return (IMA_ERROR_INVALID_PARAMETER);
3677
3678 if (discoveryMethod != IMA_ISNS_DISCOVERY_METHOD_STATIC &&
3679 discoveryMethod != IMA_ISNS_DISCOVERY_METHOD_DHCP &&
3680 discoveryMethod != IMA_ISNS_DISCOVERY_METHOD_SLP)
3681 return (IMA_ERROR_INVALID_PARAMETER);
3682
3683 if (phbaId.objectType != IMA_OBJECT_TYPE_PHBA &&
3684 phbaId.objectType != IMA_OBJECT_TYPE_LHBA) {
3685 return (IMA_ERROR_INCORRECT_OBJECT_TYPE);
3686 }
3687
3688 os_obtainmutex(libMutex);
3689 status = IMA_ERROR_OBJECT_NOT_FOUND;
3690
3691 for (i = 0; i < number_of_plugins; i++) {
3692 if (plugintable[i].ownerId == phbaId.ownerId) {
3693 status = IMA_ERROR_UNEXPECTED_OS_ERROR;
3694 if (plugintable[i].hPlugin != NULL) {
3695 os_obtainmutex(plugintable[i].pluginMutex);
3696 #ifdef WIN32
3697 PassFunc =
3698 (IMA_SetIsnsDiscoveryFn)
3699 GetProcAddress(plugintable[i].hPlugin,
3700 "IMA_SetIsnsDiscovery");
3701 #else
3702 PassFunc =
3703 (IMA_SetIsnsDiscoveryFn)
3704 dlsym(plugintable[i].hPlugin,
3705 "IMA_SetIsnsDiscovery");
3706 #endif
3707
3708 if (PassFunc != NULL) {
3709 status = PassFunc(phbaId,
3710 enableIsnsDiscovery,
3711 discoveryMethod, iSnsHost);
3712 }
3713 os_releasemutex(plugintable[i].pluginMutex);
3714 }
3715
3716 break;
3717 }
3718 }
3719 os_releasemutex(libMutex);
3720 return (status);
3721 }
3722
3723
3724 IMA_API IMA_STATUS IMA_SetSlpDiscovery(
3725 IMA_OID phbaId,
3726 IMA_BOOL enableSlpDiscovery) {
3727 IMA_SetSlpDiscoveryFn PassFunc;
3728 IMA_UINT i;
3729 IMA_STATUS status;
3730
3731 if (number_of_plugins == -1)
3732 InitLibrary();
3733
3734 if (enableSlpDiscovery != IMA_TRUE &&
3735 enableSlpDiscovery != IMA_FALSE)
3736 return (IMA_ERROR_INVALID_PARAMETER);
3737
3738 if (phbaId.objectType != IMA_OBJECT_TYPE_PHBA &&
3739 phbaId.objectType != IMA_OBJECT_TYPE_LHBA)
3740 return (IMA_ERROR_INCORRECT_OBJECT_TYPE);
3741
3742 os_obtainmutex(libMutex);
3743 status = IMA_ERROR_OBJECT_NOT_FOUND;
3744
3745 for (i = 0; i < number_of_plugins; i++) {
3746 if (plugintable[i].ownerId == phbaId.ownerId) {
3747 status = IMA_ERROR_UNEXPECTED_OS_ERROR;
3748 if (plugintable[i].hPlugin != NULL) {
3749 os_obtainmutex(plugintable[i].pluginMutex);
3750 #ifdef WIN32
3751 PassFunc =
3752 (IMA_SetSlpDiscoveryFn)
3753 GetProcAddress(plugintable[i].hPlugin,
3754 "IMA_SetSlpDiscovery");
3755 #else
3756 PassFunc = (IMA_SetSlpDiscoveryFn)
3757 dlsym(plugintable[i].hPlugin,
3758 "IMA_SetSlpDiscovery");
3759 #endif
3760
3761 if (PassFunc != NULL) {
3762 status = PassFunc(
3763 phbaId,
3764 enableSlpDiscovery);
3765 }
3766 os_releasemutex(plugintable[i].pluginMutex);
3767 }
3768
3769 break;
3770 }
3771 }
3772 os_releasemutex(libMutex);
3773 return (status);
3774 }
3775
3776
3777 IMA_API IMA_STATUS IMA_SetStaticDiscovery(
3778 IMA_OID phbaId,
3779 IMA_BOOL enableStaticDiscovery) {
3780 IMA_SetStaticDiscoveryFn PassFunc;
3781 IMA_UINT i;
3782 IMA_STATUS status;
3783
3784 if (number_of_plugins == -1)
3785 InitLibrary();
3786
3787 if (enableStaticDiscovery != IMA_TRUE &&
3788 enableStaticDiscovery != IMA_FALSE)
3789 return (IMA_ERROR_INVALID_PARAMETER);
3790
3791 if (phbaId.objectType != IMA_OBJECT_TYPE_PHBA &&
3792 phbaId.objectType != IMA_OBJECT_TYPE_LHBA)
3793 return (IMA_ERROR_INCORRECT_OBJECT_TYPE);
3794
3795 os_obtainmutex(libMutex);
3796 status = IMA_ERROR_OBJECT_NOT_FOUND;
3797
3798 for (i = 0; i < number_of_plugins; i++) {
3799 if (plugintable[i].ownerId == phbaId.ownerId) {
3800 status = IMA_ERROR_UNEXPECTED_OS_ERROR;
3801 if (plugintable[i].hPlugin != NULL) {
3802 os_obtainmutex(plugintable[i].pluginMutex);
3803 #ifdef WIN32
3804 PassFunc = (IMA_SetStaticDiscoveryFn)
3805 GetProcAddress(plugintable[i].hPlugin,
3806 "IMA_SetStaticDiscovery");
3807 #else
3808 PassFunc = (IMA_SetStaticDiscoveryFn)
3809 dlsym(plugintable[i].hPlugin,
3810 "IMA_SetStaticDiscovery");
3811 #endif
3812
3813 if (PassFunc != NULL) {
3814 status = PassFunc(
3815 phbaId,
3816 enableStaticDiscovery);
3817 }
3818 os_releasemutex(plugintable[i].pluginMutex);
3819 }
3820
3821 break;
3822 }
3823 }
3824 os_releasemutex(libMutex);
3825 return (status);
3826 }
3827
3828
3829 IMA_API IMA_STATUS IMA_SetSendTargetsDiscovery(
3830 IMA_OID phbaId,
3831 IMA_BOOL enableSendTargetsDiscovery) {
3832 IMA_SetSendTargetsDiscoveryFn PassFunc;
3833 IMA_UINT i;
3834 IMA_STATUS status;
3835
3836 if (number_of_plugins == -1)
3837 InitLibrary();
3838
3839 if (enableSendTargetsDiscovery != IMA_TRUE &&
3840 enableSendTargetsDiscovery != IMA_FALSE)
3841 return (IMA_ERROR_INVALID_PARAMETER);
3842
3843 if (phbaId.objectType != IMA_OBJECT_TYPE_PHBA &&
3844 phbaId.objectType != IMA_OBJECT_TYPE_LHBA) {
3845 return (IMA_ERROR_INCORRECT_OBJECT_TYPE);
3846 }
3847
3848 os_obtainmutex(libMutex);
3849 status = IMA_ERROR_OBJECT_NOT_FOUND;
3850
3851 for (i = 0; i < number_of_plugins; i++) {
3852 if (plugintable[i].ownerId == phbaId.ownerId) {
3853 status = IMA_ERROR_UNEXPECTED_OS_ERROR;
3854 if (plugintable[i].hPlugin != NULL) {
3855 os_obtainmutex(plugintable[i].pluginMutex);
3856 #ifdef WIN32
3857 PassFunc = (IMA_SetSendTargetsDiscoveryFn)
3858 GetProcAddress(plugintable[i].hPlugin,
3859 "IMA_SetSendTargetsDiscovery");
3860 #else
3861 PassFunc = (IMA_SetSendTargetsDiscoveryFn)
3862 dlsym(plugintable[i].hPlugin,
3863 "IMA_SetSendTargetsDiscovery");
3864 #endif
3865
3866 if (PassFunc != NULL) {
3867 status = PassFunc(
3868 phbaId,
3869 enableSendTargetsDiscovery);
3870 }
3871 os_releasemutex(
3872 plugintable[i].pluginMutex);
3873 }
3874
3875 break;
3876 }
3877 }
3878 os_releasemutex(libMutex);
3879 return (status);
3880 }
3881
3882 /*
3883 * this forces plugins to rescan all iscsi targets on this
3884 * ipaddress/port and return a
3885 * list of discovered targets.
3886 * ERROR/todo:
3887 * according to IMA spec., pTargetOidList is allocated by
3888 * the caller for library to return data,
3889 * how does a caller know how much space it will be?
3890 * pTargetOidList should be allocated by the library/plugin
3891 * like IMA_GetLnpOidList
3892 */
3893 IMA_API IMA_STATUS IMA_AddPhbaStaticDiscoveryTarget(
3894 IMA_OID phbaOid,
3895 const IMA_TARGET_ADDRESS targetAddress,
3896 IMA_OID_LIST **pTargetOidList) {
3897 IMA_AddPhbaStaticDiscoveryTargetFn PassFunc;
3898 IMA_FreeMemoryFn FreeFunc;
3899 IMA_UINT i;
3900 IMA_STATUS status;
3901
3902 if (number_of_plugins == -1)
3903 InitLibrary();
3904
3905 os_obtainmutex(libMutex);
3906 status = IMA_ERROR_OBJECT_NOT_FOUND;
3907
3908 for (i = 0; i < number_of_plugins; i++) {
3909
3910 if (plugintable[i].ownerId == phbaOid.ownerId) {
3911 status = IMA_ERROR_UNEXPECTED_OS_ERROR;
3912 if (plugintable[i].hPlugin != NULL) {
3913 os_obtainmutex(plugintable[i].pluginMutex);
3914 #ifdef WIN32
3915 PassFunc =
3916 (IMA_AddPhbaStaticDiscoveryTargetFn)
3917 GetProcAddress(plugintable[i].hPlugin,
3918 "IMA_AddPhbaStaticDiscoveryTarget");
3919 #else
3920 PassFunc =
3921 (IMA_AddPhbaStaticDiscoveryTargetFn)
3922 dlsym(plugintable[i].hPlugin,
3923 "IMA_AddPhbaStaticDiscoveryTarget");
3924 #endif
3925
3926 if (PassFunc != NULL) {
3927 IMA_OID_LIST *ppOidList;
3928 IMA_UINT listSize;
3929 listSize =
3930 sizeof (IMA_OID_LIST);
3931 status = PassFunc(phbaOid,
3932 targetAddress, &ppOidList);
3933 if (IMA_SUCCESS(status)) {
3934
3935 (*pTargetOidList) =
3936 (IMA_OID_LIST*)
3937 calloc(1, listSize +
3938 (ppOidList->oidCount-1)*
3939 sizeof (IMA_OID));
3940
3941 if ((*pTargetOidList) == NULL) {
3942 status =
3943 EUOS_ERROR;
3944 }
3945 memcpy((*pTargetOidList),
3946 ppOidList,
3947 listSize +
3948 (ppOidList->oidCount-1)*
3949 sizeof (IMA_OID));
3950 #ifdef WIN32
3951 FreeFunc = (IMA_FreeMemoryFn)
3952 GetProcAddress(
3953 plugintable[i].hPlugin,
3954 "IMA_FreeMemory");
3955 #else
3956 FreeFunc = (IMA_FreeMemoryFn)
3957 dlsym(
3958 plugintable[i].hPlugin,
3959 "IMA_FreeMemory");
3960 #endif
3961 if (FreeFunc != NULL) {
3962 FreeFunc(ppOidList);
3963 }
3964 }
3965 }
3966 os_releasemutex(plugintable[i].pluginMutex);
3967 }
3968
3969 break;
3970 }
3971 }
3972 os_releasemutex(libMutex);
3973 return (status);
3974 }
3975
3976
3977 IMA_API IMA_STATUS IMA_RemovePhbaStaticDiscoveryTarget(
3978 IMA_OID phbaOid,
3979 IMA_OID targetOid) {
3980 IMA_RemovePhbaStaticDiscoveryTargetFn PassFunc;
3981 IMA_UINT i;
3982 IMA_STATUS status;
3983
3984 if (number_of_plugins == -1)
3985 InitLibrary();
3986
3987 os_obtainmutex(libMutex);
3988 status = IMA_ERROR_OBJECT_NOT_FOUND;
3989
3990 for (i = 0; i < number_of_plugins; i++) {
3991 if (plugintable[i].ownerId == targetOid.ownerId) {
3992 status = IMA_ERROR_UNEXPECTED_OS_ERROR;
3993 if (plugintable[i].hPlugin != NULL) {
3994 os_obtainmutex(plugintable[i].pluginMutex);
3995 #ifdef WIN32
3996 PassFunc =
3997 (IMA_RemovePhbaStaticDiscoveryTargetFn)
3998 GetProcAddress(plugintable[i].hPlugin,
3999 "IMA_RemovePhbaStaticDiscoveryTarget");
4000 #else
4001 PassFunc =
4002 (IMA_RemovePhbaStaticDiscoveryTargetFn)
4003 dlsym(plugintable[i].hPlugin,
4004 "IMA_RemovePhbaStaticDiscoveryTarget");
4005 #endif
4006
4007 if (PassFunc != NULL) {
4008 status = PassFunc(phbaOid, targetOid);
4009 }
4010 os_releasemutex(plugintable[i].pluginMutex);
4011 }
4012
4013 break;
4014 }
4015 }
4016 os_releasemutex(libMutex);
4017 return (status);
4018 }
4019
4020
4021 IMA_API IMA_STATUS IMA_GetPnpOidList(
4022 IMA_OID Oid,
4023 IMA_OID_LIST **ppList) {
4024 IMA_GetPnpOidListFn PassFunc;
4025 IMA_FreeMemoryFn FreeFunc;
4026 IMA_UINT i;
4027 IMA_STATUS status;
4028
4029 if (number_of_plugins == -1)
4030 InitLibrary();
4031
4032 if (ppList == NULL)
4033 return (IMA_ERROR_INVALID_PARAMETER);
4034
4035 if (Oid.objectType != IMA_OBJECT_TYPE_PHBA &&
4036 Oid.objectType != IMA_OBJECT_TYPE_LNP)
4037 return (IMA_ERROR_INCORRECT_OBJECT_TYPE);
4038
4039 os_obtainmutex(libMutex);
4040 status = IMA_ERROR_OBJECT_NOT_FOUND;
4041 for (i = 0; i < number_of_plugins; i++) {
4042
4043 if (plugintable[i].ownerId == Oid.ownerId) {
4044 status = IMA_ERROR_UNEXPECTED_OS_ERROR;
4045 if (plugintable[i].hPlugin != NULL) {
4046 os_obtainmutex(plugintable[i].pluginMutex);
4047 #ifdef WIN32
4048 PassFunc = (IMA_GetPnpOidListFn)
4049 GetProcAddress(plugintable[i].hPlugin,
4050 "IMA_GetPnpOidList");
4051 #else
4052 PassFunc = (IMA_GetPnpOidListFn)
4053 dlsym(plugintable[i].hPlugin,
4054 "IMA_GetPnpOidList");
4055 #endif
4056
4057 if (PassFunc != NULL) {
4058 IMA_OID_LIST *ppOidList;
4059
4060 status = PassFunc(Oid, &ppOidList);
4061 if (IMA_SUCCESS(status)) {
4062 IMA_UINT listSize;
4063 listSize =
4064 sizeof (IMA_OID_LIST);
4065 *ppList = (IMA_OID_LIST*)
4066 calloc(1, listSize +
4067 (ppOidList->oidCount-1)*
4068 sizeof (IMA_OID));
4069
4070 if ((*ppList) == NULL) {
4071 status =
4072 EUOS_ERROR;
4073 }
4074 else
4075 memcpy((*ppList),
4076 ppOidList,
4077 listSize +
4078 (ppOidList->
4079 oidCount - 1)*
4080 sizeof (IMA_OID));
4081 #ifdef WIN32
4082 FreeFunc = (IMA_FreeMemoryFn)
4083 GetProcAddress(
4084 plugintable[i].hPlugin,
4085 "IMA_FreeMemory");
4086 #else
4087 FreeFunc = (IMA_FreeMemoryFn)
4088 dlsym(
4089 plugintable[i].hPlugin,
4090 "IMA_FreeMemory");
4091 #endif
4092 if (FreeFunc != NULL) {
4093 FreeFunc(ppOidList);
4094 }
4095 }
4096 }
4097 os_releasemutex(plugintable[i].pluginMutex);
4098 }
4099
4100 break;
4101 }
4102 }
4103 os_releasemutex(libMutex);
4104 return (status);
4105 }
4106
4107
4108 IMA_API IMA_STATUS IMA_GetPhbaDownloadProperties(
4109 IMA_OID phbaId,
4110 IMA_PHBA_DOWNLOAD_PROPERTIES *pProps) {
4111 IMA_GetPhbaDownloadPropertiesFn PassFunc;
4112 IMA_UINT i;
4113 IMA_STATUS status;
4114
4115 if (number_of_plugins == -1)
4116 InitLibrary();
4117
4118 if (pProps == NULL)
4119 return (IMA_ERROR_INVALID_PARAMETER);
4120
4121 if (phbaId.objectType != IMA_OBJECT_TYPE_PHBA)
4122 return (IMA_ERROR_INCORRECT_OBJECT_TYPE);
4123
4124 os_obtainmutex(libMutex);
4125 status = IMA_ERROR_OBJECT_NOT_FOUND;
4126
4127 for (i = 0; i < number_of_plugins; i++) {
4128 if (plugintable[i].ownerId == phbaId.ownerId) {
4129 status = IMA_ERROR_UNEXPECTED_OS_ERROR;
4130 if (plugintable[i].hPlugin != NULL) {
4131 os_obtainmutex(plugintable[i].pluginMutex);
4132 #ifdef WIN32
4133 PassFunc =
4134 (IMA_GetPhbaDownloadPropertiesFn)
4135 GetProcAddress(plugintable[i].hPlugin,
4136 "IMA_GetPhbaDownloadProperties");
4137 #else
4138 PassFunc = (IMA_GetPhbaDownloadPropertiesFn)
4139 dlsym(plugintable[i].hPlugin,
4140 "IMA_GetPhbaDownloadProperties");
4141 #endif
4142
4143 if (PassFunc != NULL) {
4144 status = PassFunc(phbaId, pProps);
4145 }
4146 os_releasemutex(plugintable[i].pluginMutex);
4147 }
4148
4149 break;
4150 }
4151 }
4152 os_releasemutex(libMutex);
4153 return (status);
4154 }
4155
4156
4157 IMA_API IMA_STATUS IMA_IsPhbaDownloadFile(
4158 IMA_OID phbaId,
4159 const IMA_WCHAR *pFileName,
4160 IMA_PHBA_DOWNLOAD_IMAGE_PROPERTIES *pProps) {
4161 IMA_IsPhbaDownloadFileFn PassFunc;
4162 IMA_UINT i;
4163 IMA_STATUS status;
4164
4165 if (number_of_plugins == -1)
4166 InitLibrary();
4167
4168 if (pFileName == NULL || pProps == NULL)
4169 return (IMA_ERROR_INVALID_PARAMETER);
4170
4171 if (phbaId.objectType != IMA_OBJECT_TYPE_PHBA)
4172 return (IMA_ERROR_INCORRECT_OBJECT_TYPE);
4173
4174 os_obtainmutex(libMutex);
4175 status = IMA_ERROR_OBJECT_NOT_FOUND;
4176
4177 for (i = 0; i < number_of_plugins; i++) {
4178 if (plugintable[i].ownerId == phbaId.ownerId) {
4179 status = IMA_ERROR_UNEXPECTED_OS_ERROR;
4180 if (plugintable[i].hPlugin != NULL) {
4181 os_obtainmutex(plugintable[i].pluginMutex);
4182 #ifdef WIN32
4183 PassFunc = (IMA_IsPhbaDownloadFileFn)
4184 GetProcAddress(plugintable[i].hPlugin,
4185 "IMA_IsPhbaDownloadFile");
4186 #else
4187 PassFunc = (IMA_IsPhbaDownloadFileFn)
4188 dlsym(plugintable[i].hPlugin,
4189 "IMA_IsPhbaDownloadFile");
4190 #endif
4191
4192 if (PassFunc != NULL) {
4193 status = PassFunc(
4194 phbaId, pFileName, pProps);
4195 }
4196 os_releasemutex(plugintable[i].pluginMutex);
4197 }
4198
4199 break;
4200 }
4201 }
4202 os_releasemutex(libMutex);
4203 return (status);
4204 }
4205
4206
4207 IMA_API IMA_STATUS IMA_PhbaDownload(
4208 IMA_OID phbaId,
4209 IMA_PHBA_DOWNLOAD_IMAGE_TYPE imageType,
4210 const IMA_WCHAR *pFileName) {
4211 IMA_PhbaDownloadFn PassFunc;
4212 IMA_UINT i;
4213 IMA_STATUS status;
4214
4215 if (number_of_plugins == -1)
4216 InitLibrary();
4217
4218 if (phbaId.objectType != IMA_OBJECT_TYPE_PHBA)
4219 return (IMA_ERROR_INCORRECT_OBJECT_TYPE);
4220
4221 if (imageType != IMA_DOWNLOAD_IMAGE_TYPE_FIRMWARE &&
4222 imageType != IMA_DOWNLOAD_IMAGE_TYPE_OPTION_ROM &&
4223 imageType != IMA_DOWNLOAD_IMAGE_TYPE_ALL &&
4224 imageType != IMA_DOWNLOAD_IMAGE_TYPE_BOOTCODE)
4225 return (IMA_ERROR_INVALID_PARAMETER);
4226
4227 if (pFileName == NULL)
4228 return (IMA_ERROR_INVALID_PARAMETER);
4229
4230 os_obtainmutex(libMutex);
4231 status = IMA_ERROR_OBJECT_NOT_FOUND;
4232
4233 for (i = 0; i < number_of_plugins; i++) {
4234 if (plugintable[i].ownerId == phbaId.ownerId) {
4235 status = IMA_ERROR_UNEXPECTED_OS_ERROR;
4236 if (plugintable[i].hPlugin != NULL) {
4237 os_obtainmutex(plugintable[i].pluginMutex);
4238 #ifdef WIN32
4239 PassFunc = (IMA_PhbaDownloadFn)
4240 GetProcAddress(plugintable[i].hPlugin,
4241 "IMA_PhbaDownload");
4242 #else
4243 PassFunc = (IMA_PhbaDownloadFn)
4244 dlsym(plugintable[i].hPlugin,
4245 "IMA_PhbaDownload");
4246 #endif
4247
4248 if (PassFunc != NULL) {
4249 status = PassFunc(
4250 phbaId, imageType, pFileName);
4251 }
4252 os_releasemutex(plugintable[i].pluginMutex);
4253 }
4254
4255 break;
4256 }
4257 }
4258 os_releasemutex(libMutex);
4259 return (status);
4260 }
4261
4262
4263 IMA_API IMA_STATUS IMA_GetNetworkPortalProperties(
4264 IMA_OID networkPortalId,
4265 IMA_NETWORK_PORTAL_PROPERTIES *pProps) {
4266 IMA_GetNetworkPortalPropertiesFn PassFunc;
4267 IMA_UINT i;
4268 IMA_STATUS status;
4269
4270 if (number_of_plugins == -1)
4271 InitLibrary();
4272
4273 if (pProps == NULL)
4274 return (IMA_ERROR_INVALID_PARAMETER);
4275
4276 if (networkPortalId.objectType != IMA_OBJECT_TYPE_NETWORK_PORTAL)
4277 return (IMA_ERROR_INCORRECT_OBJECT_TYPE);
4278
4279 os_obtainmutex(libMutex);
4280 status = IMA_ERROR_OBJECT_NOT_FOUND;
4281
4282 for (i = 0; i < number_of_plugins; i++) {
4283 if (plugintable[i].ownerId == networkPortalId.ownerId) {
4284 status = IMA_ERROR_UNEXPECTED_OS_ERROR;
4285 if (plugintable[i].hPlugin != NULL) {
4286 os_obtainmutex(plugintable[i].pluginMutex);
4287 #ifdef WIN32
4288 PassFunc =
4289 (IMA_GetNetworkPortalPropertiesFn)
4290 GetProcAddress(plugintable[i].hPlugin,
4291 "IMA_GetNetworkPortalProperties");
4292 #else
4293 PassFunc =
4294 (IMA_GetNetworkPortalPropertiesFn)
4295 dlsym(plugintable[i].hPlugin,
4296 "IMA_GetNetworkPortalProperties");
4297 #endif
4298
4299 if (PassFunc != NULL) {
4300 status = PassFunc(
4301 networkPortalId, pProps);
4302 }
4303 os_releasemutex(plugintable[i].pluginMutex);
4304 }
4305
4306 break;
4307 }
4308 }
4309 os_releasemutex(libMutex);
4310 return (status);
4311 }
4312
4313
4314 IMA_API IMA_STATUS IMA_SetNetworkPortalIpAddress(
4315 IMA_OID networkPortalId,
4316 const IMA_IP_ADDRESS NewIpAddress) {
4317 IMA_SetNetworkPortalIpAddressFn PassFunc;
4318 IMA_UINT i;
4319 IMA_STATUS status;
4320
4321 if (number_of_plugins == -1)
4322 InitLibrary();
4323
4324 if (networkPortalId.objectType != IMA_OBJECT_TYPE_NETWORK_PORTAL)
4325 return (IMA_ERROR_INCORRECT_OBJECT_TYPE);
4326
4327 os_obtainmutex(libMutex);
4328 status = IMA_ERROR_OBJECT_NOT_FOUND;
4329
4330 for (i = 0; i < number_of_plugins; i++) {
4331 if (plugintable[i].ownerId == networkPortalId.ownerId) {
4332 status = IMA_ERROR_UNEXPECTED_OS_ERROR;
4333 if (plugintable[i].hPlugin != NULL) {
4334 os_obtainmutex(plugintable[i].pluginMutex);
4335 #ifdef WIN32
4336 PassFunc =
4337 (IMA_SetNetworkPortalIpAddressFn)
4338 GetProcAddress(plugintable[i].hPlugin,
4339 "IMA_SetNetworkPortalIpAddress");
4340 #else
4341 PassFunc = (IMA_SetNetworkPortalIpAddressFn)
4342 dlsym(plugintable[i].hPlugin,
4343 "IMA_SetNetworkPortalIpAddress");
4344 #endif
4345
4346 if (PassFunc != NULL) {
4347 status = PassFunc(
4348 networkPortalId, NewIpAddress);
4349 }
4350 os_releasemutex(plugintable[i].pluginMutex);
4351 }
4352
4353 break;
4354 }
4355 }
4356 os_releasemutex(libMutex);
4357 return (status);
4358 }
4359
4360
4361 IMA_API IMA_STATUS IMA_GetLnpOidList(
4362 IMA_OID_LIST **ppList) {
4363 IMA_GetLnpOidListFn PassFunc;
4364 IMA_FreeMemoryFn FreeFunc;
4365
4366 IMA_UINT i;
4367 IMA_UINT j;
4368 IMA_UINT totalIdCount;
4369 IMA_STATUS status;
4370
4371 if (number_of_plugins == -1)
4372 InitLibrary();
4373
4374 if (ppList == NULL)
4375 return (IMA_ERROR_INVALID_PARAMETER);
4376
4377 os_obtainmutex(libMutex);
4378 // Get total id count first
4379 totalIdCount = 0;
4380
4381 for (i = 0; i < number_of_plugins; i++) {
4382 status = IMA_ERROR_UNEXPECTED_OS_ERROR;
4383 if (plugintable[i].hPlugin != NULL) {
4384 os_obtainmutex(plugintable[i].pluginMutex);
4385 #ifdef WIN32
4386 PassFunc = (IMA_GetLnpOidListFn)
4387 GetProcAddress(plugintable[i].hPlugin,
4388 "IMA_GetLnpOidList");
4389 #else
4390 PassFunc = (IMA_GetLnpOidListFn)
4391 dlsym(plugintable[i].hPlugin,
4392 "IMA_GetLnpOidList");
4393 #endif
4394 if (PassFunc != NULL) {
4395 IMA_OID_LIST *ppOidList;
4396 status = PassFunc(&ppOidList);
4397 if (status == IMA_STATUS_SUCCESS) {
4398 totalIdCount += ppOidList->oidCount;
4399 #ifdef WIN32
4400 FreeFunc = (IMA_FreeMemoryFn)
4401 GetProcAddress(
4402 plugintable[i].hPlugin,
4403 "IMA_FreeMemory");
4404 #else
4405 FreeFunc = (IMA_FreeMemoryFn)
4406 dlsym(plugintable[i].hPlugin,
4407 "IMA_FreeMemory");
4408 #endif
4409 if (FreeFunc != NULL) {
4410 FreeFunc(ppOidList);
4411 }
4412 }
4413 }
4414 os_releasemutex(plugintable[i].pluginMutex);
4415 }
4416 if (status != IMA_STATUS_SUCCESS) {
4417 break;
4418 }
4419
4420 }
4421
4422
4423 *ppList = (IMA_OID_LIST*)calloc(1,
4424 sizeof (IMA_OID_LIST) + (totalIdCount - 1)* sizeof (IMA_OID));
4425
4426 if ((*ppList) == NULL) {
4427 os_releasemutex(libMutex);
4428 return (IMA_ERROR_UNEXPECTED_OS_ERROR);
4429 }
4430
4431 (*ppList)->oidCount = totalIdCount;
4432
4433 // 2nd pass to copy the id lists
4434 totalIdCount = 0;
4435 status = IMA_STATUS_SUCCESS;
4436 for (i = 0; i < number_of_plugins; i++) {
4437 status = IMA_ERROR_UNEXPECTED_OS_ERROR;
4438 if (plugintable[i].hPlugin != NULL) {
4439 os_obtainmutex(plugintable[i].pluginMutex);
4440 #ifdef WIN32
4441 PassFunc = (IMA_GetLnpOidListFn)
4442 GetProcAddress(plugintable[i].hPlugin,
4443 "IMA_GetLnpOidList");
4444 #else
4445 PassFunc = (IMA_GetLnpOidListFn)
4446 dlsym(plugintable[i].hPlugin,
4447 "IMA_GetLnpOidList");
4448 #endif
4449 if (PassFunc != NULL) {
4450 IMA_OID_LIST *ppOidList;
4451 status = PassFunc(&ppOidList);
4452 if (status == IMA_STATUS_SUCCESS) {
4453 for (j = 0; (j < ppOidList->oidCount) &&
4454 (totalIdCount <
4455 (*ppList)->oidCount);
4456 j++) {
4457 (*ppList)->oids[totalIdCount].
4458 objectType =
4459 ppOidList->oids[j].
4460 objectType;
4461 (*ppList)->oids[totalIdCount].
4462 objectSequenceNumber =
4463 ppOidList->oids[j].
4464 objectSequenceNumber;
4465
4466 (*ppList)->oids[totalIdCount].
4467 ownerId =
4468 ppOidList->oids[j].ownerId;
4469 totalIdCount++;
4470 }
4471 #ifdef WIN32
4472 FreeFunc = (IMA_FreeMemoryFn)
4473 GetProcAddress(
4474 plugintable[i].hPlugin,
4475 "IMA_FreeMemory");
4476 #else
4477 FreeFunc = (IMA_FreeMemoryFn)
4478 dlsym(plugintable[i].hPlugin,
4479 "IMA_FreeMemory");
4480 #endif
4481 if (FreeFunc != NULL) {
4482 FreeFunc(ppOidList);
4483 }
4484 }
4485 }
4486 os_releasemutex(plugintable[i].pluginMutex);
4487 }
4488 if (status != IMA_STATUS_SUCCESS) {
4489 free(*ppList);
4490 break;
4491 }
4492
4493 }
4494 os_releasemutex(libMutex);
4495 return (status);
4496 }
4497
4498
4499 IMA_API IMA_STATUS IMA_GetLnpProperties(
4500 IMA_OID lnpId,
4501 IMA_LNP_PROPERTIES *pProps) {
4502 IMA_GetLnpPropertiesFn PassFunc;
4503 IMA_UINT i;
4504 IMA_STATUS status;
4505
4506 if (number_of_plugins == -1)
4507 InitLibrary();
4508
4509 if (pProps == NULL)
4510 return (IMA_ERROR_INVALID_PARAMETER);
4511
4512 if (lnpId.objectType != IMA_OBJECT_TYPE_LNP)
4513 return (IMA_ERROR_INCORRECT_OBJECT_TYPE);
4514
4515 os_obtainmutex(libMutex);
4516 status = IMA_ERROR_OBJECT_NOT_FOUND;
4517
4518 for (i = 0; i < number_of_plugins; i++) {
4519 if (plugintable[i].ownerId == lnpId.ownerId) {
4520 status = IMA_ERROR_UNEXPECTED_OS_ERROR;
4521 if (plugintable[i].hPlugin != NULL) {
4522 os_obtainmutex(plugintable[i].pluginMutex);
4523 #ifdef WIN32
4524 PassFunc = (IMA_GetLnpPropertiesFn)
4525 GetProcAddress(plugintable[i].hPlugin,
4526 "IMA_GetLnpProperties");
4527 #else
4528 PassFunc = (IMA_GetLnpPropertiesFn)
4529 dlsym(plugintable[i].hPlugin,
4530 "IMA_GetLnpProperties");
4531 #endif
4532
4533 if (PassFunc != NULL) {
4534 status = PassFunc(lnpId, pProps);
4535 }
4536 os_releasemutex(plugintable[i].pluginMutex);
4537 }
4538
4539 break;
4540 }
4541 }
4542 os_releasemutex(libMutex);
4543 return (status);
4544 }
4545
4546
4547 IMA_API IMA_STATUS IMA_GetPnpProperties(
4548 IMA_OID pnpId,
4549 IMA_PNP_PROPERTIES *pProps) {
4550 IMA_GetPnpPropertiesFn PassFunc;
4551 IMA_UINT i;
4552 IMA_STATUS status;
4553
4554 if (number_of_plugins == -1)
4555 InitLibrary();
4556
4557 if (pProps == NULL)
4558 return (IMA_ERROR_INVALID_PARAMETER);
4559
4560 if (pnpId.objectType != IMA_OBJECT_TYPE_PNP)
4561 return (IMA_ERROR_INCORRECT_OBJECT_TYPE);
4562
4563 os_obtainmutex(libMutex);
4564 status = IMA_ERROR_OBJECT_NOT_FOUND;
4565
4566 for (i = 0; i < number_of_plugins; i++) {
4567 if (plugintable[i].ownerId == pnpId.ownerId) {
4568 status = IMA_ERROR_UNEXPECTED_OS_ERROR;
4569 if (plugintable[i].hPlugin != NULL) {
4570 os_obtainmutex(plugintable[i].pluginMutex);
4571 #ifdef WIN32
4572 PassFunc = (IMA_GetPnpPropertiesFn)
4573 GetProcAddress(plugintable[i].hPlugin,
4574 "IMA_GetPnpProperties");
4575 #else
4576 PassFunc = (IMA_GetPnpPropertiesFn)
4577 dlsym(plugintable[i].hPlugin,
4578 "IMA_GetPnpProperties");
4579 #endif
4580
4581 if (PassFunc != NULL) {
4582 status = PassFunc(pnpId, pProps);
4583 }
4584 os_releasemutex(plugintable[i].pluginMutex);
4585 }
4586
4587 break;
4588 }
4589 }
4590 os_releasemutex(libMutex);
4591 return (status);
4592 }
4593
4594
4595 IMA_API IMA_STATUS IMA_GetPnpStatistics(
4596 IMA_OID pnpId,
4597 IMA_PNP_STATISTICS *pStats) {
4598 IMA_GetPnpStatisticsFn PassFunc;
4599 IMA_UINT i;
4600 IMA_STATUS status;
4601
4602 if (number_of_plugins == -1)
4603 InitLibrary();
4604
4605 if (pStats == NULL)
4606 return (IMA_ERROR_INVALID_PARAMETER);
4607
4608 if (pnpId.objectType != IMA_OBJECT_TYPE_PNP)
4609 return (IMA_ERROR_INCORRECT_OBJECT_TYPE);
4610
4611 os_obtainmutex(libMutex);
4612 status = IMA_ERROR_OBJECT_NOT_FOUND;
4613
4614 for (i = 0; i < number_of_plugins; i++) {
4615 if (plugintable[i].ownerId == pnpId.ownerId) {
4616 status = IMA_ERROR_UNEXPECTED_OS_ERROR;
4617 if (plugintable[i].hPlugin != NULL) {
4618 os_obtainmutex(plugintable[i].pluginMutex);
4619 #ifdef WIN32
4620 PassFunc = (IMA_GetPnpStatisticsFn)
4621 GetProcAddress(plugintable[i].hPlugin,
4622 "IMA_GetPnpStatistics");
4623 #else
4624 PassFunc = (IMA_GetPnpStatisticsFn)
4625 dlsym(plugintable[i].hPlugin,
4626 "IMA_GetPnpStatistics");
4627 #endif
4628
4629 if (PassFunc != NULL) {
4630 status = PassFunc(pnpId, pStats);
4631 }
4632 os_releasemutex(plugintable[i].pluginMutex);
4633 }
4634
4635 break;
4636 }
4637 }
4638 os_releasemutex(libMutex);
4639 return (status);
4640 }
4641
4642
4643 IMA_API IMA_STATUS IMA_GetTargetProperties(
4644 IMA_OID targetId,
4645 IMA_TARGET_PROPERTIES *pProps) {
4646 IMA_GetTargetPropertiesFn PassFunc;
4647 IMA_UINT i;
4648 IMA_STATUS status;
4649
4650 if (number_of_plugins == -1)
4651 InitLibrary();
4652
4653 if (pProps == NULL)
4654 return (IMA_ERROR_INVALID_PARAMETER);
4655
4656 if (targetId.objectType != IMA_OBJECT_TYPE_TARGET)
4657 return (IMA_ERROR_INCORRECT_OBJECT_TYPE);
4658
4659 os_obtainmutex(libMutex);
4660 status = IMA_ERROR_OBJECT_NOT_FOUND;
4661
4662 for (i = 0; i < number_of_plugins; i++) {
4663 if (plugintable[i].ownerId == targetId.ownerId) {
4664 status = IMA_ERROR_UNEXPECTED_OS_ERROR;
4665 if (plugintable[i].hPlugin != NULL) {
4666 os_obtainmutex(plugintable[i].pluginMutex);
4667 #ifdef WIN32
4668 PassFunc = (IMA_GetTargetPropertiesFn)
4669 GetProcAddress(plugintable[i].hPlugin,
4670 "IMA_GetTargetProperties");
4671 #else
4672 PassFunc = (IMA_GetTargetPropertiesFn)
4673 dlsym(plugintable[i].hPlugin,
4674 "IMA_GetTargetProperties");
4675 #endif
4676
4677 if (PassFunc != NULL) {
4678 status = PassFunc(targetId, pProps);
4679 }
4680 os_releasemutex(plugintable[i].pluginMutex);
4681 }
4682
4683 break;
4684 }
4685 }
4686 os_releasemutex(libMutex);
4687 return (status);
4688 }
4689
4690 IMA_API IMA_STATUS IMA_GetSessionProperties(
4691 IMA_OID sessionId,
4692 IMA_SESSION_PROPERTIES *pProps) {
4693 IMA_GetSessionPropertiesFn PassFunc;
4694 IMA_UINT i;
4695 IMA_STATUS status;
4696
4697 if (number_of_plugins == -1)
4698 InitLibrary();
4699
4700 if (pProps == NULL)
4701 return (IMA_ERROR_INVALID_PARAMETER);
4702
4703 if (sessionId.objectType != IMA_OBJECT_TYPE_SESSION)
4704 return (IMA_ERROR_INCORRECT_OBJECT_TYPE);
4705
4706 os_obtainmutex(libMutex);
4707 status = IMA_ERROR_OBJECT_NOT_FOUND;
4708
4709 for (i = 0; i < number_of_plugins; i++) {
4710 if (plugintable[i].ownerId == sessionId.ownerId) {
4711 status = IMA_ERROR_UNEXPECTED_OS_ERROR;
4712 if (plugintable[i].hPlugin != NULL) {
4713 os_obtainmutex(plugintable[i].pluginMutex);
4714 #ifdef WIN32
4715 PassFunc = (IMA_GetSessionPropertiesFn)
4716 GetProcAddress(plugintable[i].hPlugin,
4717 "IMA_GetSessionProperties");
4718 #else
4719 PassFunc = (IMA_GetSessionPropertiesFn)
4720 dlsym(plugintable[i].hPlugin,
4721 "IMA_GetSessionProperties");
4722 #endif
4723
4724 if (PassFunc != NULL) {
4725 status = PassFunc(sessionId, pProps);
4726 }
4727 os_releasemutex(plugintable[i].pluginMutex);
4728 }
4729
4730 break;
4731 }
4732 }
4733 os_releasemutex(libMutex);
4734 return (status);
4735 }
4736
4737
4738 IMA_API IMA_STATUS IMA_GetConnectionProperties(
4739 IMA_OID connectionId,
4740 IMA_CONNECTION_PROPERTIES *pProps) {
4741 IMA_GetConnectionPropertiesFn PassFunc;
4742 IMA_UINT i;
4743 IMA_STATUS status;
4744
4745 if (number_of_plugins == -1)
4746 InitLibrary();
4747
4748 if (pProps == NULL)
4749 return (IMA_ERROR_INVALID_PARAMETER);
4750
4751 if (connectionId.objectType != IMA_OBJECT_TYPE_CONNECTION)
4752 return (IMA_ERROR_INCORRECT_OBJECT_TYPE);
4753
4754 os_obtainmutex(libMutex);
4755 status = IMA_ERROR_OBJECT_NOT_FOUND;
4756
4757 for (i = 0; i < number_of_plugins; i++) {
4758 if (plugintable[i].ownerId == connectionId.ownerId) {
4759 status = IMA_ERROR_UNEXPECTED_OS_ERROR;
4760 if (plugintable[i].hPlugin != NULL) {
4761 os_obtainmutex(plugintable[i].pluginMutex);
4762 #ifdef WIN32
4763 PassFunc = (IMA_GetConnectionPropertiesFn)
4764 GetProcAddress(plugintable[i].hPlugin,
4765 "IMA_GetConnectionProperties");
4766 #else
4767 PassFunc = (IMA_GetConnectionPropertiesFn)
4768 dlsym(plugintable[i].hPlugin,
4769 "IMA_GetConnectionProperties");
4770 #endif
4771
4772 if (PassFunc != NULL) {
4773 status = PassFunc(connectionId, pProps);
4774 }
4775 os_releasemutex(plugintable[i].pluginMutex);
4776 }
4777
4778 break;
4779 }
4780 }
4781 os_releasemutex(libMutex);
4782 return (status);
4783 }
4784
4785
4786 IMA_API IMA_STATUS IMA_GetTargetErrorStatistics(
4787 IMA_OID targetId,
4788 IMA_TARGET_ERROR_STATISTICS *pStats) {
4789 IMA_GetTargetErrorStatisticsFn PassFunc;
4790 IMA_UINT i;
4791 IMA_STATUS status;
4792
4793 if (number_of_plugins == -1)
4794 InitLibrary();
4795
4796 if (pStats == NULL)
4797 return (IMA_ERROR_INVALID_PARAMETER);
4798
4799 if (targetId.objectType != IMA_OBJECT_TYPE_TARGET)
4800 return (IMA_ERROR_INCORRECT_OBJECT_TYPE);
4801
4802 os_obtainmutex(libMutex);
4803 status = IMA_ERROR_OBJECT_NOT_FOUND;
4804
4805 for (i = 0; i < number_of_plugins; i++) {
4806 if (plugintable[i].ownerId == targetId.ownerId) {
4807 status = IMA_ERROR_UNEXPECTED_OS_ERROR;
4808 if (plugintable[i].hPlugin != NULL) {
4809 os_obtainmutex(plugintable[i].pluginMutex);
4810 #ifdef WIN32
4811 PassFunc = (IMA_GetTargetErrorStatisticsFn)
4812 GetProcAddress(plugintable[i].hPlugin,
4813 "IMA_GetTargetErrorStatistics");
4814 #else
4815 PassFunc = (IMA_GetTargetErrorStatisticsFn)
4816 dlsym(plugintable[i].hPlugin,
4817 "IMA_GetTargetErrorStatistics");
4818 #endif
4819
4820 if (PassFunc != NULL) {
4821 status = PassFunc(targetId, pStats);
4822 }
4823 os_releasemutex(plugintable[i].pluginMutex);
4824 }
4825
4826 break;
4827 }
4828 }
4829 os_releasemutex(libMutex);
4830 return (status);
4831 }
4832
4833
4834 IMA_API IMA_STATUS IMA_GetLuOidList(
4835 IMA_OID Oid,
4836 IMA_OID_LIST **ppList) {
4837 IMA_GetLuOidListFn PassFunc;
4838 IMA_FreeMemoryFn FreeFunc;
4839 IMA_UINT i;
4840 IMA_STATUS status;
4841
4842 if (number_of_plugins == -1)
4843 InitLibrary();
4844
4845 if (ppList == NULL)
4846 return (IMA_ERROR_INVALID_PARAMETER);
4847
4848 if (Oid.objectType != IMA_OBJECT_TYPE_LHBA &&
4849 Oid.objectType != IMA_OBJECT_TYPE_TARGET)
4850 return (IMA_ERROR_INCORRECT_OBJECT_TYPE);
4851
4852 os_obtainmutex(libMutex);
4853 status = IMA_ERROR_OBJECT_NOT_FOUND;
4854
4855 for (i = 0; i < number_of_plugins; i++) {
4856
4857 if (plugintable[i].ownerId == Oid.ownerId) {
4858 status = IMA_ERROR_UNEXPECTED_OS_ERROR;
4859 if (plugintable[i].hPlugin != NULL) {
4860 os_obtainmutex(plugintable[i].pluginMutex);
4861 #ifdef WIN32
4862 PassFunc = (IMA_GetLuOidListFn)
4863 GetProcAddress(plugintable[i].hPlugin,
4864 "IMA_GetLuOidList");
4865 #else
4866 PassFunc = (IMA_GetLuOidListFn)
4867 dlsym(plugintable[i].hPlugin,
4868 "IMA_GetLuOidList");
4869 #endif
4870
4871 if (PassFunc != NULL) {
4872 IMA_OID_LIST *ppOidList;
4873
4874 status = PassFunc(Oid, &ppOidList);
4875 if (IMA_SUCCESS(status)) {
4876 IMA_UINT listSize;
4877 listSize =
4878 sizeof (IMA_OID_LIST);
4879 *ppList = (IMA_OID_LIST*)
4880 calloc(1, listSize +
4881 (ppOidList->oidCount - 1)*
4882 sizeof (IMA_OID));
4883
4884 if ((*ppList) == NULL) {
4885 status = EUOS_ERROR;
4886 }
4887 else
4888 memcpy((*ppList),
4889 ppOidList,
4890 listSize +
4891 (ppOidList->
4892 oidCount - 1)*
4893 sizeof (IMA_OID));
4894 #ifdef WIN32
4895 FreeFunc = (IMA_FreeMemoryFn)
4896 GetProcAddress(
4897 plugintable[i].hPlugin,
4898 "IMA_FreeMemory");
4899 #else
4900 FreeFunc = (IMA_FreeMemoryFn)
4901 dlsym(
4902 plugintable[i].hPlugin,
4903 "IMA_FreeMemory");
4904 #endif
4905 if (FreeFunc != NULL) {
4906 FreeFunc(ppOidList);
4907 }
4908 }
4909 }
4910 os_releasemutex(plugintable[i].pluginMutex);
4911 }
4912
4913 break;
4914 }
4915 }
4916 os_releasemutex(libMutex);
4917 return (status);
4918 }
4919
4920
4921 IMA_API IMA_STATUS IMA_GetLuOid(
4922 IMA_OID targetId,
4923 IMA_UINT64 lun,
4924 IMA_OID *pluId) {
4925 IMA_GetLuOidFn PassFunc;
4926 IMA_UINT i;
4927 IMA_STATUS status;
4928
4929 if (number_of_plugins == -1)
4930 InitLibrary();
4931
4932 if (pluId == NULL)
4933 return (IMA_ERROR_INVALID_PARAMETER);
4934
4935
4936 if (targetId.objectType != IMA_OBJECT_TYPE_TARGET)
4937 return (IMA_ERROR_INCORRECT_OBJECT_TYPE);
4938
4939 os_obtainmutex(libMutex);
4940 status = IMA_ERROR_OBJECT_NOT_FOUND;
4941
4942 for (i = 0; i < number_of_plugins; i++) {
4943 if (plugintable[i].ownerId == targetId.ownerId) {
4944 status = IMA_ERROR_UNEXPECTED_OS_ERROR;
4945 if (plugintable[i].hPlugin != NULL) {
4946 os_obtainmutex(
4947 plugintable[i].pluginMutex);
4948 #ifdef WIN32
4949 PassFunc = (IMA_GetLuOidFn)
4950 GetProcAddress(
4951 plugintable[i].hPlugin,
4952 "IMA_GetLuOid");
4953 #else
4954 PassFunc = (IMA_GetLuOidFn)
4955 dlsym(plugintable[i].hPlugin,
4956 "IMA_GetLuOid");
4957 #endif
4958
4959 if (PassFunc != NULL) {
4960 status =
4961 PassFunc(targetId, lun, pluId);
4962 }
4963 os_releasemutex(plugintable[i].pluginMutex);
4964 }
4965
4966 break;
4967 }
4968 }
4969 os_releasemutex(libMutex);
4970 return (status);
4971 }
4972
4973
4974 IMA_API IMA_STATUS IMA_GetLuProperties(
4975 IMA_OID luId,
4976 IMA_LU_PROPERTIES *pProps) {
4977 IMA_GetLuPropertiesFn PassFunc;
4978 IMA_UINT i;
4979 IMA_STATUS status;
4980
4981 if (number_of_plugins == -1)
4982 InitLibrary();
4983
4984 if (pProps == NULL)
4985 return (IMA_ERROR_INVALID_PARAMETER);
4986
4987 if (luId.objectType != IMA_OBJECT_TYPE_LU)
4988 return (IMA_ERROR_INCORRECT_OBJECT_TYPE);
4989
4990 os_obtainmutex(libMutex);
4991 status = IMA_ERROR_OBJECT_NOT_FOUND;
4992
4993 for (i = 0; i < number_of_plugins; i++) {
4994 if (plugintable[i].ownerId == luId.ownerId) {
4995 status = IMA_ERROR_UNEXPECTED_OS_ERROR;
4996 if (plugintable[i].hPlugin != NULL) {
4997 os_obtainmutex(plugintable[i].pluginMutex);
4998 #ifdef WIN32
4999 PassFunc = (IMA_GetLuPropertiesFn)
5000 GetProcAddress(plugintable[i].hPlugin,
5001 "IMA_GetLuProperties");
5002 #else
5003 PassFunc = (IMA_GetLuPropertiesFn)
5004 dlsym(plugintable[i].hPlugin,
5005 "IMA_GetLuProperties");
5006 #endif
5007
5008 if (PassFunc != NULL) {
5009 status = PassFunc(luId, pProps);
5010 }
5011 os_releasemutex(plugintable[i].pluginMutex);
5012 }
5013
5014 break;
5015 }
5016 }
5017 os_releasemutex(libMutex);
5018 return (status);
5019 }
5020
5021
5022 IMA_API IMA_STATUS IMA_GetStatisticsProperties(
5023 IMA_OID oid,
5024 IMA_STATISTICS_PROPERTIES *pProps) {
5025 IMA_GetStatisticsPropertiesFn PassFunc;
5026 IMA_UINT i;
5027 IMA_STATUS status;
5028
5029 if (number_of_plugins == -1)
5030 InitLibrary();
5031
5032 if (pProps == NULL)
5033 return (IMA_ERROR_INVALID_PARAMETER);
5034
5035 if (oid.objectType != IMA_OBJECT_TYPE_TARGET &&
5036 oid.objectType != IMA_OBJECT_TYPE_LU &&
5037 oid.objectType != IMA_OBJECT_TYPE_PNP)
5038 return (IMA_ERROR_INCORRECT_OBJECT_TYPE);
5039
5040
5041 os_obtainmutex(libMutex);
5042 status = IMA_ERROR_OBJECT_NOT_FOUND;
5043
5044 for (i = 0; i < number_of_plugins; i++) {
5045 if (plugintable[i].ownerId == oid.ownerId) {
5046 status = IMA_ERROR_UNEXPECTED_OS_ERROR;
5047 if (plugintable[i].hPlugin != NULL) {
5048 os_obtainmutex(plugintable[i].pluginMutex);
5049 #ifdef WIN32
5050 PassFunc =
5051 (IMA_GetStatisticsPropertiesFn)
5052 GetProcAddress(plugintable[i].hPlugin,
5053 "IMA_GetStatisticsProperties");
5054 #else
5055 PassFunc =
5056 (IMA_GetStatisticsPropertiesFn)
5057 dlsym(plugintable[i].hPlugin,
5058 "IMA_GetStatisticsProperties");
5059 #endif
5060
5061 if (PassFunc != NULL) {
5062 status = PassFunc(oid, pProps);
5063 }
5064 os_releasemutex(plugintable[i].pluginMutex);
5065 }
5066
5067 break;
5068 }
5069 }
5070 os_releasemutex(libMutex);
5071 return (status);
5072 }
5073
5074
5075 IMA_API IMA_STATUS IMA_GetDeviceStatistics(
5076 IMA_OID oid,
5077 IMA_DEVICE_STATISTICS *pStats) {
5078 IMA_GetDeviceStatisticsFn PassFunc;
5079 IMA_UINT i;
5080 IMA_STATUS status;
5081
5082 if (number_of_plugins == -1)
5083 InitLibrary();
5084
5085 if (pStats == NULL)
5086 return (IMA_ERROR_INVALID_PARAMETER);
5087
5088 if (oid.objectType != IMA_OBJECT_TYPE_LU &&
5089 oid.objectType != IMA_OBJECT_TYPE_TARGET)
5090 return (IMA_ERROR_INCORRECT_OBJECT_TYPE);
5091
5092 os_obtainmutex(libMutex);
5093 status = IMA_ERROR_OBJECT_NOT_FOUND;
5094
5095 for (i = 0; i < number_of_plugins; i++) {
5096 if (plugintable[i].ownerId == oid.ownerId) {
5097 status = IMA_ERROR_UNEXPECTED_OS_ERROR;
5098 if (plugintable[i].hPlugin != NULL) {
5099 os_obtainmutex(plugintable[i].pluginMutex);
5100 #ifdef WIN32
5101 PassFunc =
5102 (IMA_GetDeviceStatisticsFn)
5103 GetProcAddress(plugintable[i].hPlugin,
5104 "IMA_GetDeviceStatistics");
5105 #else
5106 PassFunc =
5107 (IMA_GetDeviceStatisticsFn)
5108 dlsym(plugintable[i].hPlugin,
5109 "IMA_GetDeviceStatistics");
5110 #endif
5111
5112 if (PassFunc != NULL) {
5113 status = PassFunc(oid, pStats);
5114 }
5115 os_releasemutex(plugintable[i].pluginMutex);
5116 }
5117
5118 break;
5119 }
5120 }
5121 os_releasemutex(libMutex);
5122 return (status);
5123 }
5124
5125
5126 IMA_API IMA_STATUS IMA_LuInquiry(
5127 IMA_OID deviceId,
5128 IMA_BOOL evpd,
5129 IMA_BOOL cmddt,
5130 IMA_BYTE pageCode,
5131
5132 IMA_BYTE *pOutputBuffer,
5133 IMA_UINT *pOutputBufferLength,
5134
5135 IMA_BYTE *pSenseBuffer,
5136 IMA_UINT *pSenseBufferLength) {
5137 IMA_LuInquiryFn PassFunc;
5138 IMA_UINT i;
5139 IMA_STATUS status;
5140
5141 if (number_of_plugins == -1)
5142 InitLibrary();
5143
5144 if (pOutputBuffer == NULL || pOutputBufferLength == NULL ||
5145 *pOutputBufferLength == 0 ||
5146 (pSenseBuffer == NULL && pSenseBufferLength != NULL &&
5147 *pSenseBufferLength != 0))
5148 return (IMA_ERROR_INVALID_PARAMETER);
5149
5150 if ((evpd != IMA_TRUE && evpd != IMA_FALSE) ||
5151 (cmddt != IMA_TRUE && cmddt != IMA_FALSE))
5152 return (IMA_ERROR_INVALID_PARAMETER);
5153
5154 if (deviceId.objectType != IMA_OBJECT_TYPE_TARGET &&
5155 deviceId.objectType != IMA_OBJECT_TYPE_LU)
5156 return (IMA_ERROR_INCORRECT_OBJECT_TYPE);
5157
5158 os_obtainmutex(libMutex);
5159 status = IMA_ERROR_OBJECT_NOT_FOUND;
5160
5161 for (i = 0; i < number_of_plugins; i++) {
5162 if (plugintable[i].ownerId == deviceId.ownerId) {
5163 status = IMA_ERROR_UNEXPECTED_OS_ERROR;
5164 if (plugintable[i].hPlugin != NULL) {
5165 os_obtainmutex(plugintable[i].pluginMutex);
5166 #ifdef WIN32
5167 PassFunc = (IMA_LuInquiryFn)
5168 GetProcAddress(plugintable[i].hPlugin,
5169 "IMA_LuInquiry");
5170 #else
5171 PassFunc = (IMA_LuInquiryFn)
5172 dlsym(plugintable[i].hPlugin,
5173 "IMA_LuInquiry");
5174 #endif
5175
5176 if (PassFunc != NULL) {
5177 status =
5178 PassFunc(deviceId, evpd,
5179 cmddt, pageCode,
5180 pOutputBuffer, pOutputBufferLength,
5181 pSenseBuffer, pSenseBufferLength);
5182 }
5183 os_releasemutex(plugintable[i].pluginMutex);
5184 }
5185
5186 break;
5187 }
5188 }
5189 os_releasemutex(libMutex);
5190 return (status);
5191 }
5192
5193
5194 IMA_API IMA_STATUS IMA_LuReadCapacity(
5195 IMA_OID deviceId,
5196 IMA_UINT cdbLength,
5197 IMA_BYTE *pOutputBuffer,
5198 IMA_UINT *pOutputBufferLength,
5199
5200 IMA_BYTE *pSenseBuffer,
5201 IMA_UINT *pSenseBufferLength) {
5202 IMA_LuReadCapacityFn PassFunc;
5203 IMA_UINT i;
5204 IMA_STATUS status;
5205
5206 if (number_of_plugins == -1)
5207 InitLibrary();
5208
5209 if (cdbLength != 10 && cdbLength != 16)
5210 return (IMA_ERROR_INVALID_PARAMETER);
5211
5212 if ((pOutputBuffer == NULL || pOutputBufferLength == NULL ||
5213 *pOutputBufferLength == 0) ||
5214 (pSenseBuffer == NULL && pSenseBufferLength != NULL &&
5215 *pSenseBufferLength != 0))
5216 return (IMA_ERROR_INVALID_PARAMETER);
5217
5218 if (deviceId.objectType != IMA_OBJECT_TYPE_TARGET &&
5219 deviceId.objectType != IMA_OBJECT_TYPE_LU)
5220 return (IMA_ERROR_INCORRECT_OBJECT_TYPE);
5221
5222 os_obtainmutex(libMutex);
5223 status = IMA_ERROR_OBJECT_NOT_FOUND;
5224
5225 for (i = 0; i < number_of_plugins; i++) {
5226 if (plugintable[i].ownerId == deviceId.ownerId) {
5227 status = IMA_ERROR_UNEXPECTED_OS_ERROR;
5228 if (plugintable[i].hPlugin != NULL) {
5229 os_obtainmutex(plugintable[i].pluginMutex);
5230 #ifdef WIN32
5231 PassFunc = (IMA_LuReadCapacityFn)
5232 GetProcAddress(plugintable[i].hPlugin,
5233 "IMA_LuReadCapacity");
5234 #else
5235 PassFunc = (IMA_LuReadCapacityFn)
5236 dlsym(plugintable[i].hPlugin,
5237 "IMA_LuReadCapacity");
5238 #endif
5239
5240 if (PassFunc != NULL) {
5241 status = PassFunc(deviceId, cdbLength,
5242 pOutputBuffer, pOutputBufferLength,
5243 pSenseBuffer, pSenseBufferLength);
5244 }
5245 os_releasemutex(plugintable[i].pluginMutex);
5246 }
5247
5248 break;
5249 }
5250 }
5251 os_releasemutex(libMutex);
5252 return (status);
5253 }
5254
5255
5256 IMA_API IMA_STATUS IMA_LuReportLuns(
5257 IMA_OID deviceId,
5258 IMA_BOOL sendToWellKnownLun,
5259 IMA_BYTE selectReport,
5260
5261 IMA_BYTE *pOutputBuffer,
5262 IMA_UINT *pOutputBufferLength,
5263
5264 IMA_BYTE *pSenseBuffer,
5265 IMA_UINT *pSenseBufferLength) {
5266 IMA_LuReportLunsFn PassFunc;
5267 IMA_UINT i;
5268 IMA_STATUS status;
5269
5270 if (number_of_plugins == -1)
5271 InitLibrary();
5272
5273 if ((pOutputBuffer == NULL || pOutputBufferLength == NULL ||
5274 *pOutputBufferLength == 0) ||
5275 (pSenseBuffer == NULL && pSenseBufferLength != NULL &&
5276 *pSenseBufferLength != 0))
5277 return (IMA_ERROR_INVALID_PARAMETER);
5278
5279 if (sendToWellKnownLun != IMA_TRUE && sendToWellKnownLun != IMA_FALSE)
5280 return (IMA_ERROR_INVALID_PARAMETER);
5281
5282 if (deviceId.objectType != IMA_OBJECT_TYPE_TARGET &&
5283 deviceId.objectType != IMA_OBJECT_TYPE_LU)
5284 return (IMA_ERROR_INCORRECT_OBJECT_TYPE);
5285
5286 os_obtainmutex(libMutex);
5287 status = IMA_ERROR_OBJECT_NOT_FOUND;
5288
5289 for (i = 0; i < number_of_plugins; i++) {
5290 if (plugintable[i].ownerId == deviceId.ownerId) {
5291 status = IMA_ERROR_UNEXPECTED_OS_ERROR;
5292 if (plugintable[i].hPlugin != NULL) {
5293 os_obtainmutex(plugintable[i].pluginMutex);
5294 #ifdef WIN32
5295 PassFunc = (IMA_LuReportLunsFn)
5296 GetProcAddress(plugintable[i].hPlugin,
5297 "IMA_LuReportLuns");
5298 #else
5299 PassFunc = (IMA_LuReportLunsFn)
5300 dlsym(plugintable[i].hPlugin,
5301 "IMA_LuReportLuns");
5302 #endif
5303
5304 if (PassFunc != NULL) {
5305 status = PassFunc(deviceId,
5306 sendToWellKnownLun, selectReport,
5307 pOutputBuffer, pOutputBufferLength,
5308 pSenseBuffer, pSenseBufferLength);
5309 }
5310 os_releasemutex(plugintable[i].pluginMutex);
5311 }
5312
5313 break;
5314 }
5315 }
5316 os_releasemutex(libMutex);
5317 return (status);
5318 }
5319
5320 IMA_API IMA_STATUS IMA_ExposeLu(
5321 IMA_OID luId) {
5322 IMA_ExposeLuFn PassFunc;
5323 IMA_UINT i;
5324 IMA_STATUS status;
5325
5326 if (number_of_plugins == -1)
5327 InitLibrary();
5328
5329 if (luId.objectType != IMA_OBJECT_TYPE_LU)
5330 return (IMA_ERROR_INVALID_OBJECT_TYPE);
5331
5332 os_obtainmutex(libMutex);
5333 status = IMA_ERROR_OBJECT_NOT_FOUND;
5334
5335 for (i = 0; i < number_of_plugins; i++) {
5336 if (plugintable[i].ownerId == luId.ownerId) {
5337 status = IMA_ERROR_UNEXPECTED_OS_ERROR;
5338 if (plugintable[i].hPlugin != NULL) {
5339 os_obtainmutex(plugintable[i].pluginMutex);
5340 #ifdef WIN32
5341 PassFunc = (IMA_ExposeLuFn)
5342 GetProcAddress(plugintable[i].hPlugin,
5343 "IMA_ExposeLu");
5344
5345 #else
5346 PassFunc = (IMA_ExposeLuFn)
5347 dlsym(plugintable[i].hPlugin,
5348 "IMA_ExposeLu");
5349 #endif
5350
5351 if (PassFunc != NULL) {
5352 status = PassFunc(luId);
5353 }
5354 os_releasemutex(plugintable[i].pluginMutex);
5355 }
5356
5357 break;
5358 }
5359 }
5360 os_releasemutex(libMutex);
5361 return (status);
5362 }
5363
5364
5365 IMA_API IMA_STATUS IMA_UnexposeLu(
5366 IMA_OID luId) {
5367 IMA_UnexposeLuFn PassFunc;
5368 IMA_UINT i;
5369 IMA_STATUS status;
5370
5371 if (number_of_plugins == -1)
5372 InitLibrary();
5373
5374 if (luId.objectType != IMA_OBJECT_TYPE_LU)
5375 return (IMA_ERROR_INCORRECT_OBJECT_TYPE);
5376
5377 os_obtainmutex(libMutex);
5378 status = IMA_ERROR_OBJECT_NOT_FOUND;
5379
5380 for (i = 0; i < number_of_plugins; i++) {
5381 if (plugintable[i].ownerId == luId.ownerId) {
5382 status = IMA_ERROR_UNEXPECTED_OS_ERROR;
5383 if (plugintable[i].hPlugin != NULL) {
5384 os_obtainmutex(plugintable[i].pluginMutex);
5385 #ifdef WIN32
5386 PassFunc = (IMA_UnexposeLuFn)
5387 GetProcAddress(plugintable[i].hPlugin,
5388 "IMA_UnexposeLu");
5389 #else
5390 PassFunc = (IMA_UnexposeLuFn)
5391 dlsym(plugintable[i].hPlugin,
5392 "IMA_UnexposeLu");
5393 #endif
5394
5395 if (PassFunc != NULL) {
5396 status = PassFunc(luId);
5397 }
5398 os_releasemutex(plugintable[i].pluginMutex);
5399 }
5400
5401 break;
5402 }
5403 }
5404 os_releasemutex(libMutex);
5405 return (status);
5406 }
5407
5408
5409 IMA_API IMA_STATUS IMA_GetPhbaStatus(
5410 IMA_OID hbaId,
5411 IMA_PHBA_STATUS *pStatus) {
5412 IMA_GetPhbaStatusFn PassFunc;
5413 IMA_UINT i;
5414 IMA_STATUS status;
5415
5416 if (number_of_plugins == -1)
5417 InitLibrary();
5418
5419 if (pStatus == NULL)
5420 return (IMA_ERROR_INVALID_PARAMETER);
5421
5422 if (hbaId.objectType != IMA_OBJECT_TYPE_PHBA)
5423 return (IMA_ERROR_INCORRECT_OBJECT_TYPE);
5424
5425 os_obtainmutex(libMutex);
5426 status = IMA_ERROR_OBJECT_NOT_FOUND;
5427
5428 for (i = 0; i < number_of_plugins; i++) {
5429 if (plugintable[i].ownerId == hbaId.ownerId) {
5430 status = IMA_ERROR_UNEXPECTED_OS_ERROR;
5431 if (plugintable[i].hPlugin != NULL) {
5432 os_obtainmutex(plugintable[i].pluginMutex);
5433 #ifdef WIN32
5434 PassFunc = (IMA_GetPhbaStatusFn)
5435 GetProcAddress(plugintable[i].hPlugin,
5436 "IMA_GetPhbaStatus");
5437 #else
5438 PassFunc = (IMA_GetPhbaStatusFn)
5439 dlsym(plugintable[i].hPlugin,
5440 "IMA_GetPhbaStatus");
5441 #endif
5442
5443 if (PassFunc != NULL) {
5444 status = PassFunc(hbaId, pStatus);
5445 }
5446 os_releasemutex(plugintable[i].pluginMutex);
5447 }
5448
5449 break;
5450 }
5451 }
5452 os_releasemutex(libMutex);
5453 return (status);
5454 }
5455
5456
5457 IMA_API IMA_STATUS IMA_RegisterForObjectVisibilityChanges(
5458 IMA_OBJECT_VISIBILITY_FN pClientFn) {
5459 IMA_RegisterForObjectVisibilityChangesFn PassFunc;
5460 IMA_UINT i;
5461 IMA_UINT j;
5462 IMA_STATUS status;
5463
5464 if (number_of_plugins == -1)
5465 InitLibrary();
5466
5467 if (pClientFn == NULL)
5468 return (IMA_ERROR_INVALID_PARAMETER);
5469
5470 os_obtainmutex(libMutex);
5471
5472 status = IMA_STATUS_SUCCESS;
5473 for (i = 0; i < number_of_plugins; i++) {
5474 status = IMA_ERROR_UNEXPECTED_OS_ERROR;
5475 if (plugintable[i].hPlugin != NULL) {
5476 os_obtainmutex(plugintable[i].pluginMutex);
5477 if (plugintable[i].number_of_vbcallbacks >=
5478 IMA_MAX_CALLBACK_PER_PLUGIN) {
5479 os_releasemutex(plugintable[i].pluginMutex);
5480 continue;
5481 }
5482
5483 /* check if registered already */
5484 for (j = 0;
5485 j < plugintable[i].number_of_vbcallbacks; j++) {
5486 if (plugintable[i].vbcallback[j] == pClientFn) {
5487 status = IMA_STATUS_SUCCESS;
5488 break;
5489 }
5490 }
5491 if (status != IMA_STATUS_SUCCESS) {
5492
5493 #ifdef WIN32
5494 PassFunc =
5495 (IMA_RegisterForObjectVisibilityChangesFn)
5496 GetProcAddress(plugintable[i].hPlugin,
5497 "IMA_RegisterForObjectVisibilityChanges");
5498 #else
5499 PassFunc =
5500 (IMA_RegisterForObjectVisibilityChangesFn)
5501 dlsym(plugintable[i].hPlugin,
5502 "IMA_RegisterForObjectVisibilityChanges");
5503 #endif
5504
5505 if (PassFunc != NULL) {
5506 status = PassFunc(VisibilityCallback);
5507 if (status == IMA_STATUS_SUCCESS) {
5508 j = plugintable[i].
5509 number_of_vbcallbacks;
5510 plugintable[i].vbcallback[j] =
5511 pClientFn;
5512 plugintable[i].
5513 number_of_vbcallbacks++;
5514 }
5515
5516 }
5517 }
5518 os_releasemutex(plugintable[i].pluginMutex);
5519 }
5520 if (status != IMA_STATUS_SUCCESS)
5521 break;
5522
5523 }
5524 os_releasemutex(libMutex);
5525 return (status);
5526
5527 }
5528
5529
5530 IMA_API IMA_STATUS IMA_DeregisterForObjectVisibilityChanges(
5531 IMA_OBJECT_VISIBILITY_FN pClientFn) {
5532 IMA_DeregisterForObjectVisibilityChangesFn PassFunc;
5533 IMA_UINT i;
5534 IMA_UINT j;
5535 IMA_STATUS status;
5536
5537 if (number_of_plugins == -1)
5538 InitLibrary();
5539
5540 if (pClientFn == NULL)
5541 return (IMA_ERROR_INVALID_PARAMETER);
5542
5543 os_obtainmutex(libMutex);
5544
5545 status = IMA_STATUS_SUCCESS;
5546 for (i = 0; i < number_of_plugins; i++) {
5547 status = IMA_ERROR_UNEXPECTED_OS_ERROR;
5548 if (plugintable[i].hPlugin != NULL) {
5549 os_obtainmutex(plugintable[i].pluginMutex);
5550 /* check if deregistered already */
5551 status = IMA_STATUS_SUCCESS;
5552 for (j = 0;
5553 j < plugintable[i].number_of_vbcallbacks; j++) {
5554 if (plugintable[i].vbcallback[j] == pClientFn) {
5555 /*
5556 * use IMA_ERROR_UNKNOWN_ERROR
5557 * as a flag
5558 */
5559 status = IMA_ERROR_UNKNOWN_ERROR;
5560 break;
5561 }
5562 }
5563
5564 if (status != IMA_STATUS_SUCCESS) {
5565
5566 #ifdef WIN32
5567 PassFunc =
5568 (IMA_DeregisterForObjectVisibilityChangesFn)
5569 GetProcAddress(plugintable[i].hPlugin,
5570 "IMA_DeregisterForObjectVisibilityChanges");
5571 #else
5572 PassFunc =
5573 (IMA_DeregisterForObjectVisibilityChangesFn)
5574 dlsym(plugintable[i].hPlugin,
5575 "IMA_DeregisterForObjectVisibilityChanges");
5576 #endif
5577 if (PassFunc != NULL) {
5578 status = PassFunc(VisibilityCallback);
5579 if (status == IMA_STATUS_SUCCESS) {
5580 /*
5581 * where plugintable[i].
5582 * vbcallback[j] == pClientFn
5583 */
5584 for (; j <
5585 plugintable[i].
5586 number_of_vbcallbacks;
5587 j++) {
5588 plugintable[i].
5589 vbcallback[j] =
5590 plugintable[i].
5591 vbcallback[j+1];
5592
5593 }
5594 plugintable[i].
5595 number_of_vbcallbacks--;
5596 }
5597 }
5598 }
5599 os_releasemutex(plugintable[i].pluginMutex);
5600 }
5601 if (status != IMA_STATUS_SUCCESS)
5602 break;
5603 }
5604 os_releasemutex(libMutex);
5605 return (status);
5606
5607 }
5608
5609
5610 IMA_API IMA_STATUS IMA_RegisterForObjectPropertyChanges(
5611 IMA_OBJECT_PROPERTY_FN pClientFn) {
5612 IMA_RegisterForObjectPropertyChangesFn PassFunc;
5613 IMA_UINT i;
5614 IMA_UINT j;
5615 IMA_STATUS status;
5616
5617 if (number_of_plugins == -1)
5618 InitLibrary();
5619
5620 if (pClientFn == NULL)
5621 return (IMA_ERROR_INVALID_PARAMETER);
5622
5623 os_obtainmutex(libMutex);
5624
5625 status = IMA_STATUS_SUCCESS;
5626 for (i = 0; i < number_of_plugins; i++) {
5627 status = IMA_ERROR_UNEXPECTED_OS_ERROR;
5628 if (plugintable[i].hPlugin != NULL) {
5629 os_obtainmutex(plugintable[i].pluginMutex);
5630 if (plugintable[i].number_of_pccallbacks >=
5631 IMA_MAX_CALLBACK_PER_PLUGIN) {
5632 os_releasemutex(plugintable[i].pluginMutex);
5633 continue;
5634 }
5635
5636 /* check if registered already */
5637 for (j = 0;
5638 j < plugintable[i].number_of_pccallbacks;
5639 j++) {
5640 if (plugintable[i].pccallback[j] ==
5641 pClientFn) {
5642 status = IMA_STATUS_SUCCESS;
5643 break;
5644 }
5645 }
5646 if (status != IMA_STATUS_SUCCESS) {
5647
5648 #ifdef WIN32
5649 PassFunc =
5650 (IMA_RegisterForObjectPropertyChangesFn)
5651 GetProcAddress(plugintable[i].hPlugin,
5652 "IMA_RegisterForObjectPropertyChanges");
5653 #else
5654 PassFunc =
5655 (IMA_RegisterForObjectPropertyChangesFn)
5656 dlsym(plugintable[i].hPlugin,
5657 "IMA_RegisterForObjectPropertyChanges");
5658 #endif
5659
5660 if (PassFunc != NULL) {
5661 status = PassFunc(PropertyCallback);
5662 if (status == IMA_STATUS_SUCCESS) {
5663 j = plugintable[i].
5664 number_of_pccallbacks;
5665 plugintable[i].pccallback[j] =
5666 pClientFn;
5667 plugintable[i].
5668 number_of_pccallbacks++;
5669 }
5670
5671 }
5672 }
5673 os_releasemutex(plugintable[i].pluginMutex);
5674 }
5675 if (status != IMA_STATUS_SUCCESS)
5676 break;
5677
5678 }
5679 os_releasemutex(libMutex);
5680 return (status);
5681
5682 }
5683
5684
5685 IMA_API IMA_STATUS IMA_DeregisterForObjectPropertyChanges(
5686 IMA_OBJECT_PROPERTY_FN pClientFn) {
5687 IMA_DeregisterForObjectPropertyChangesFn PassFunc;
5688 IMA_UINT i;
5689 IMA_UINT j;
5690 IMA_STATUS status;
5691
5692 if (number_of_plugins == -1)
5693 InitLibrary();
5694
5695 if (pClientFn == NULL)
5696 return (IMA_ERROR_INVALID_PARAMETER);
5697
5698 os_obtainmutex(libMutex);
5699 status = IMA_STATUS_SUCCESS;
5700 for (i = 0; i < number_of_plugins; i++) {
5701 status = IMA_ERROR_UNEXPECTED_OS_ERROR;
5702 if (plugintable[i].hPlugin != NULL) {
5703 os_obtainmutex(plugintable[i].pluginMutex);
5704 /* check if deregistered already */
5705 status = IMA_STATUS_SUCCESS;
5706 for (j = 0;
5707 j < plugintable[i].number_of_pccallbacks;
5708 j++) {
5709 if (plugintable[i].pccallback[j] ==
5710 pClientFn) {
5711 /*
5712 * use IMA_ERROR_UNKNOWN_ERROR
5713 * as a flag
5714 */
5715 status = IMA_ERROR_UNKNOWN_ERROR;
5716 break;
5717 }
5718 }
5719
5720 if (status != IMA_STATUS_SUCCESS) {
5721
5722 #ifdef WIN32
5723 PassFunc =
5724 (IMA_DeregisterForObjectPropertyChangesFn)
5725 GetProcAddress(plugintable[i].hPlugin,
5726 "IMA_DeregisterForObjectPropertyChanges");
5727
5728 #else
5729 PassFunc =
5730 (IMA_DeregisterForObjectPropertyChangesFn)
5731 dlsym(plugintable[i].hPlugin,
5732 "IMA_DeregisterForObjectPropertyChanges");
5733 #endif
5734
5735 if (PassFunc != NULL) {
5736 status = PassFunc(PropertyCallback);
5737 if (status == IMA_STATUS_SUCCESS) {
5738 /*
5739 * where plugintable[i].vbcallback[
5740 * j] == pClientFn
5741 */
5742 for (; j < plugintable[i].
5743 number_of_pccallbacks;
5744 j++) {
5745 plugintable[i].
5746 pccallback[j]
5747 = plugintable[i].
5748 pccallback[j+1];
5749
5750 }
5751 plugintable[i].
5752 number_of_pccallbacks--;
5753 }
5754
5755 }
5756 }
5757 os_releasemutex(plugintable[i].pluginMutex);
5758 }
5759 if (status != IMA_STATUS_SUCCESS)
5760 break;
5761
5762 }
5763 os_releasemutex(libMutex);
5764 return (status);
5765
5766 }
5767
5768
5769 IMA_API IMA_STATUS IMA_GetIpProperties(
5770 IMA_OID oid,
5771 IMA_IP_PROPERTIES *pProps) {
5772 IMA_GetIpPropertiesFn PassFunc;
5773 IMA_UINT i;
5774 IMA_STATUS status;
5775
5776 if (number_of_plugins == -1)
5777 InitLibrary();
5778
5779 if (pProps == NULL)
5780 return (IMA_ERROR_INVALID_PARAMETER);
5781
5782 if (oid.objectType != IMA_OBJECT_TYPE_PNP)
5783 return (IMA_ERROR_INCORRECT_OBJECT_TYPE);
5784
5785 os_obtainmutex(libMutex);
5786 status = IMA_ERROR_OBJECT_NOT_FOUND;
5787
5788 for (i = 0; i < number_of_plugins; i++) {
5789 if (plugintable[i].ownerId == oid.ownerId) {
5790 status = IMA_ERROR_UNEXPECTED_OS_ERROR;
5791 if (plugintable[i].hPlugin != NULL) {
5792 os_obtainmutex(plugintable[i].pluginMutex);
5793 #ifdef WIN32
5794 PassFunc = (IMA_GetIpPropertiesFn)
5795 GetProcAddress(plugintable[i].hPlugin,
5796 "IMA_GetIpProperties");
5797 #else
5798 PassFunc = (IMA_GetIpPropertiesFn)
5799 dlsym(plugintable[i].hPlugin,
5800 "IMA_GetIpProperties");
5801 #endif
5802 if (PassFunc != NULL) {
5803 status = PassFunc(oid, pProps);
5804 }
5805 os_releasemutex(plugintable[i].pluginMutex);
5806 }
5807
5808 break;
5809 }
5810 }
5811 os_releasemutex(libMutex);
5812 return (status);
5813 }
5814
5815
5816 IMA_API IMA_STATUS IMA_SetIpConfigMethod(
5817 IMA_OID oid,
5818 IMA_BOOL enableDhcpIpConfiguration) {
5819 IMA_SetIpConfigMethodFn PassFunc;
5820 IMA_UINT i;
5821 IMA_STATUS status;
5822
5823 if (number_of_plugins == -1)
5824 InitLibrary();
5825
5826 if (enableDhcpIpConfiguration != IMA_TRUE &&
5827 enableDhcpIpConfiguration != IMA_FALSE)
5828 return (IMA_ERROR_INVALID_PARAMETER);
5829
5830 if (oid.objectType != IMA_OBJECT_TYPE_PNP)
5831 return (IMA_ERROR_INCORRECT_OBJECT_TYPE);
5832
5833 os_obtainmutex(libMutex);
5834 status = IMA_ERROR_OBJECT_NOT_FOUND;
5835
5836 for (i = 0; i < number_of_plugins; i++) {
5837 if (plugintable[i].ownerId == oid.ownerId) {
5838 status = IMA_ERROR_UNEXPECTED_OS_ERROR;
5839 if (plugintable[i].hPlugin != NULL) {
5840 os_obtainmutex(plugintable[i].pluginMutex);
5841 #ifdef WIN32
5842 PassFunc = (IMA_SetIpConfigMethodFn)
5843 GetProcAddress(plugintable[i].hPlugin,
5844 "IMA_SetIpConfigMethod");
5845 #else
5846 PassFunc = (IMA_SetIpConfigMethodFn)
5847 dlsym(plugintable[i].hPlugin,
5848 "IMA_SetIpConfigMethod");
5849 #endif
5850
5851 if (PassFunc != NULL) {
5852 status = PassFunc(oid,
5853 enableDhcpIpConfiguration);
5854 }
5855 os_releasemutex(plugintable[i].pluginMutex);
5856 }
5857
5858 break;
5859 }
5860 }
5861 os_releasemutex(libMutex);
5862 return (status);
5863 }
5864
5865 IMA_API IMA_STATUS IMA_SetSubnetMask(
5866 IMA_OID oid,
5867 IMA_IP_ADDRESS subnetMask) {
5868 IMA_SetSubnetMaskFn PassFunc;
5869 IMA_UINT i;
5870 IMA_STATUS status;
5871
5872 if (number_of_plugins == -1)
5873 InitLibrary();
5874
5875 if (oid.objectType != IMA_OBJECT_TYPE_PNP)
5876 return (IMA_ERROR_INCORRECT_OBJECT_TYPE);
5877
5878 os_obtainmutex(libMutex);
5879 status = IMA_ERROR_OBJECT_NOT_FOUND;
5880
5881 for (i = 0; i < number_of_plugins; i++) {
5882 if (plugintable[i].ownerId == oid.ownerId) {
5883 status = IMA_ERROR_UNEXPECTED_OS_ERROR;
5884 if (plugintable[i].hPlugin != NULL) {
5885 os_obtainmutex(plugintable[i].pluginMutex);
5886 #ifdef WIN32
5887 PassFunc = (IMA_SetSubnetMaskFn)
5888 GetProcAddress(plugintable[i].hPlugin,
5889 "IMA_SetSubnetMask");
5890 #else
5891 PassFunc = (IMA_SetSubnetMaskFn)
5892 dlsym(plugintable[i].hPlugin,
5893 "IMA_SetSubnetMask");
5894 #endif
5895
5896 if (PassFunc != NULL) {
5897 status = PassFunc(oid, subnetMask);
5898 }
5899 os_releasemutex(plugintable[i].pluginMutex);
5900 }
5901
5902 break;
5903 }
5904 }
5905 os_releasemutex(libMutex);
5906 return (status);
5907 }
5908
5909
5910 IMA_API IMA_STATUS IMA_SetDnsServerAddress(
5911 IMA_OID oid,
5912 const IMA_IP_ADDRESS *primaryDnsServerAddress,
5913 const IMA_IP_ADDRESS *alternateDnsServerAddress) {
5914 IMA_SetDnsServerAddressFn PassFunc;
5915 IMA_UINT i;
5916 IMA_STATUS status;
5917
5918 if (number_of_plugins == -1)
5919 InitLibrary();
5920
5921 if (primaryDnsServerAddress == NULL &&
5922 alternateDnsServerAddress != NULL)
5923 return (IMA_ERROR_INVALID_PARAMETER);
5924
5925 if (primaryDnsServerAddress != NULL &&
5926 alternateDnsServerAddress != NULL &&
5927 memcmp(primaryDnsServerAddress->ipAddress,
5928 alternateDnsServerAddress->ipAddress,
5929 sizeof (primaryDnsServerAddress->ipAddress)) == 0)
5930 return (IMA_ERROR_INVALID_PARAMETER);
5931
5932 if (oid.objectType != IMA_OBJECT_TYPE_PNP)
5933 return (IMA_ERROR_INCORRECT_OBJECT_TYPE);
5934
5935 os_obtainmutex(libMutex);
5936 status = IMA_ERROR_OBJECT_NOT_FOUND;
5937
5938 for (i = 0; i < number_of_plugins; i++) {
5939 if (plugintable[i].ownerId == oid.ownerId) {
5940 status = IMA_ERROR_UNEXPECTED_OS_ERROR;
5941 if (plugintable[i].hPlugin != NULL) {
5942 os_obtainmutex(plugintable[i].pluginMutex);
5943 #ifdef WIN32
5944 PassFunc = (IMA_SetDnsServerAddressFn)
5945 GetProcAddress(plugintable[i].hPlugin,
5946 "IMA_SetDnsServerAddress");
5947 #else
5948 PassFunc = (IMA_SetDnsServerAddressFn)
5949 dlsym(plugintable[i].hPlugin,
5950 "IMA_SetDnsServerAddress");
5951 #endif
5952
5953 if (PassFunc != NULL) {
5954 status = PassFunc(oid,
5955 primaryDnsServerAddress,
5956 alternateDnsServerAddress);
5957 }
5958 os_releasemutex(plugintable[i].pluginMutex);
5959 }
5960
5961 break;
5962 }
5963 }
5964 os_releasemutex(libMutex);
5965 return (status);
5966 }
5967
5968
5969 IMA_API IMA_STATUS IMA_SetDefaultGateway(
5970 IMA_OID oid,
5971 IMA_IP_ADDRESS defaultGateway) {
5972 IMA_SetDefaultGatewayFn PassFunc;
5973 IMA_UINT i;
5974 IMA_STATUS status;
5975
5976 if (number_of_plugins == -1)
5977 InitLibrary();
5978
5979 if (oid.objectType != IMA_OBJECT_TYPE_PNP)
5980 return (IMA_ERROR_INCORRECT_OBJECT_TYPE);
5981
5982 os_obtainmutex(libMutex);
5983 status = IMA_ERROR_OBJECT_NOT_FOUND;
5984
5985 for (i = 0; i < number_of_plugins; i++) {
5986 if (plugintable[i].ownerId == oid.ownerId) {
5987 status = IMA_ERROR_UNEXPECTED_OS_ERROR;
5988 if (plugintable[i].hPlugin != NULL) {
5989 os_obtainmutex(plugintable[i].pluginMutex);
5990 #ifdef WIN32
5991 PassFunc = (IMA_SetDefaultGatewayFn)
5992 GetProcAddress(plugintable[i].hPlugin,
5993 "IMA_SetDefaultGateway");
5994 #else
5995 PassFunc = (IMA_SetDefaultGatewayFn)
5996 dlsym(plugintable[i].hPlugin,
5997 "IMA_SetDefaultGateway");
5998 #endif
5999
6000 if (PassFunc != NULL) {
6001 status = PassFunc(oid, defaultGateway);
6002 }
6003 os_releasemutex(plugintable[i].pluginMutex);
6004 }
6005
6006 break;
6007 }
6008 }
6009 os_releasemutex(libMutex);
6010 return (status);
6011 }
6012
6013
6014 IMA_API IMA_STATUS IMA_GetSupportedAuthMethods(
6015 IMA_OID lhbaOid,
6016 IMA_BOOL getSettableMethods,
6017 IMA_UINT *pMethodCount,
6018 IMA_AUTHMETHOD *pMethodList) {
6019 IMA_GetSupportedAuthMethodsFn PassFunc;
6020 IMA_UINT i;
6021 IMA_STATUS status;
6022
6023 if (number_of_plugins == -1)
6024 InitLibrary();
6025
6026 if (pMethodCount == NULL)
6027 return (IMA_ERROR_INVALID_PARAMETER);
6028
6029 if (lhbaOid.objectType != IMA_OBJECT_TYPE_LHBA)
6030 return (IMA_ERROR_INCORRECT_OBJECT_TYPE);
6031
6032 os_obtainmutex(libMutex);
6033 status = IMA_ERROR_OBJECT_NOT_FOUND;
6034
6035 for (i = 0; i < number_of_plugins; i++) {
6036 if (plugintable[i].ownerId == lhbaOid.ownerId) {
6037 status = IMA_ERROR_UNEXPECTED_OS_ERROR;
6038 if (plugintable[i].hPlugin != NULL) {
6039 os_obtainmutex(plugintable[i].pluginMutex);
6040 #ifdef WIN32
6041 PassFunc = (IMA_GetSupportedAuthMethodsFn)
6042 GetProcAddress(plugintable[i].hPlugin,
6043 "IMA_GetSupportedAuthMethods");
6044 #else
6045 PassFunc = (IMA_GetSupportedAuthMethodsFn)
6046 dlsym(plugintable[i].hPlugin,
6047 "IMA_GetSupportedAuthMethods");
6048 #endif
6049
6050 if (PassFunc != NULL) {
6051 status = PassFunc(lhbaOid,
6052 getSettableMethods,
6053 pMethodCount, pMethodList);
6054 }
6055 os_releasemutex(plugintable[i].pluginMutex);
6056 }
6057
6058 break;
6059 }
6060 }
6061 os_releasemutex(libMutex);
6062 return (status);
6063 }
6064
6065
6066 IMA_API IMA_STATUS IMA_GetInUseInitiatorAuthMethods(
6067 IMA_OID lhbaOid,
6068 IMA_UINT *pMethodCount,
6069 IMA_AUTHMETHOD *pMethodList) {
6070 IMA_GetInUseInitiatorAuthMethodsFn PassFunc;
6071 IMA_UINT i;
6072 IMA_STATUS status;
6073
6074 if (number_of_plugins == -1)
6075 InitLibrary();
6076
6077 if (pMethodCount == NULL)
6078 return (IMA_ERROR_INVALID_PARAMETER);
6079
6080 if (lhbaOid.objectType != IMA_OBJECT_TYPE_LHBA)
6081 return (IMA_ERROR_INCORRECT_OBJECT_TYPE);
6082
6083 os_obtainmutex(libMutex);
6084 status = IMA_ERROR_OBJECT_NOT_FOUND;
6085
6086 for (i = 0; i < number_of_plugins; i++) {
6087 if (plugintable[i].ownerId == lhbaOid.ownerId) {
6088 status = IMA_ERROR_UNEXPECTED_OS_ERROR;
6089 if (plugintable[i].hPlugin != NULL) {
6090 os_obtainmutex(plugintable[i].pluginMutex);
6091 #ifdef WIN32
6092 PassFunc = (IMA_GetInUseInitiatorAuthMethodsFn)
6093 GetProcAddress(plugintable[i].hPlugin,
6094 "IMA_GetInUseInitiatorAuthMethods");
6095 #else
6096 PassFunc = (IMA_GetInUseInitiatorAuthMethodsFn)
6097 dlsym(plugintable[i].hPlugin,
6098 "IMA_GetInUseInitiatorAuthMethods");
6099 #endif
6100
6101 if (PassFunc != NULL) {
6102 status = PassFunc(lhbaOid,
6103 pMethodCount, pMethodList);
6104 }
6105 os_releasemutex(plugintable[i].pluginMutex);
6106 }
6107
6108 break;
6109 }
6110 }
6111 os_releasemutex(libMutex);
6112 return (status);
6113 }
6114
6115
6116 IMA_API IMA_STATUS IMA_GetInitiatorAuthParms(
6117 IMA_OID lhbaOid,
6118 IMA_AUTHMETHOD method,
6119 IMA_INITIATOR_AUTHPARMS *pParms) {
6120 IMA_GetInitiatorAuthParmsFn PassFunc;
6121 IMA_UINT i;
6122 IMA_STATUS status;
6123
6124 if (number_of_plugins == -1)
6125 InitLibrary();
6126
6127 if (pParms == NULL)
6128 return (IMA_ERROR_INVALID_PARAMETER);
6129
6130 if (lhbaOid.objectType != IMA_OBJECT_TYPE_LHBA)
6131 return (IMA_ERROR_INCORRECT_OBJECT_TYPE);
6132
6133 if (method != IMA_AUTHMETHOD_NONE &&
6134 method != IMA_AUTHMETHOD_CHAP &&
6135 method != IMA_AUTHMETHOD_SRP &&
6136 method != IMA_AUTHMETHOD_KRB5 &&
6137 method != IMA_AUTHMETHOD_SPKM1 &&
6138 method != IMA_AUTHMETHOD_SPKM2)
6139 return (IMA_ERROR_INVALID_PARAMETER);
6140
6141 os_obtainmutex(libMutex);
6142 status = IMA_ERROR_OBJECT_NOT_FOUND;
6143
6144 for (i = 0; i < number_of_plugins; i++) {
6145 if (plugintable[i].ownerId == lhbaOid.ownerId) {
6146 status = IMA_ERROR_UNEXPECTED_OS_ERROR;
6147 if (plugintable[i].hPlugin != NULL) {
6148 os_obtainmutex(plugintable[i].pluginMutex);
6149 #ifdef WIN32
6150 PassFunc = (IMA_GetInitiatorAuthParmsFn)
6151 GetProcAddress(plugintable[i].hPlugin,
6152 "IMA_GetInitiatorAuthParms");
6153 #else
6154 PassFunc = (IMA_GetInitiatorAuthParmsFn)
6155 dlsym(plugintable[i].hPlugin,
6156 "IMA_GetInitiatorAuthParms");
6157 #endif
6158
6159 if (PassFunc != NULL) {
6160 status = PassFunc(lhbaOid,
6161 method, pParms);
6162 }
6163 os_releasemutex(plugintable[i].pluginMutex);
6164 }
6165
6166 break;
6167 }
6168 }
6169 os_releasemutex(libMutex);
6170 return (status);
6171 }
6172
6173 IMA_API IMA_STATUS IMA_SetInitiatorAuthMethods(
6174 IMA_OID lhbaOid,
6175 IMA_UINT methodCount,
6176 const IMA_AUTHMETHOD *pMethodList) {
6177 IMA_SetInitiatorAuthMethodsFn PassFunc;
6178 IMA_UINT i;
6179 IMA_STATUS status;
6180
6181 if (number_of_plugins == -1)
6182 InitLibrary();
6183
6184 if (methodCount == 0 || pMethodList == NULL)
6185 return (IMA_ERROR_INVALID_PARAMETER);
6186
6187 if (lhbaOid.objectType != IMA_OBJECT_TYPE_LHBA)
6188 return (IMA_ERROR_INCORRECT_OBJECT_TYPE);
6189
6190 os_obtainmutex(libMutex);
6191 status = IMA_ERROR_OBJECT_NOT_FOUND;
6192
6193 for (i = 0; i < number_of_plugins; i++) {
6194 if (plugintable[i].ownerId == lhbaOid.ownerId) {
6195 status = IMA_ERROR_UNEXPECTED_OS_ERROR;
6196 if (plugintable[i].hPlugin != NULL) {
6197 os_obtainmutex(plugintable[i].pluginMutex);
6198 #ifdef WIN32
6199 PassFunc = (IMA_SetInitiatorAuthMethodsFn)
6200 GetProcAddress(plugintable[i].hPlugin,
6201 "IMA_SetInitiatorAuthMethods");
6202 #else
6203 PassFunc = (IMA_SetInitiatorAuthMethodsFn)
6204 dlsym(plugintable[i].hPlugin,
6205 "IMA_SetInitiatorAuthMethods");
6206 #endif
6207
6208 if (PassFunc != NULL) {
6209 status = PassFunc(lhbaOid,
6210 methodCount, pMethodList);
6211 }
6212 os_releasemutex(plugintable[i].pluginMutex);
6213 }
6214
6215 break;
6216 }
6217 }
6218 os_releasemutex(libMutex);
6219 return (status);
6220 }
6221
6222 IMA_API IMA_STATUS IMA_SetInitiatorAuthParms(
6223 IMA_OID lhbaOid,
6224 IMA_AUTHMETHOD method,
6225 const IMA_INITIATOR_AUTHPARMS *pParms) {
6226
6227 IMA_SetInitiatorAuthParmsFn PassFunc;
6228 IMA_UINT i;
6229 IMA_STATUS status;
6230
6231 if (number_of_plugins == -1)
6232 InitLibrary();
6233
6234 if (pParms == NULL)
6235 return (IMA_ERROR_INVALID_PARAMETER);
6236
6237 if (method != IMA_AUTHMETHOD_NONE &&
6238 method != IMA_AUTHMETHOD_CHAP &&
6239 method != IMA_AUTHMETHOD_SRP &&
6240 method != IMA_AUTHMETHOD_KRB5 &&
6241 method != IMA_AUTHMETHOD_SPKM1 &&
6242 method != IMA_AUTHMETHOD_SPKM2)
6243 return (IMA_ERROR_INVALID_PARAMETER);
6244
6245 if (lhbaOid.objectType != IMA_OBJECT_TYPE_LHBA)
6246 return (IMA_ERROR_INCORRECT_OBJECT_TYPE);
6247
6248 os_obtainmutex(libMutex);
6249 status = IMA_ERROR_OBJECT_NOT_FOUND;
6250
6251 for (i = 0; i < number_of_plugins; i++) {
6252 if (plugintable[i].ownerId == lhbaOid.ownerId) {
6253 status = IMA_ERROR_UNEXPECTED_OS_ERROR;
6254 if (plugintable[i].hPlugin != NULL) {
6255 os_obtainmutex(plugintable[i].pluginMutex);
6256 #ifdef WIN32
6257 PassFunc = (IMA_SetInitiatorAuthParmsFn)
6258 GetProcAddress(plugintable[i].hPlugin,
6259 "IMA_SetInitiatorAuthParms");
6260 #else
6261 PassFunc = (IMA_SetInitiatorAuthParmsFn)
6262 dlsym(plugintable[i].hPlugin,
6263 "IMA_SetInitiatorAuthParms");
6264 #endif
6265
6266 if (PassFunc != NULL) {
6267 status =
6268 PassFunc(
6269 lhbaOid, method, pParms);
6270 }
6271 os_releasemutex(plugintable[i].pluginMutex);
6272 }
6273
6274 break;
6275 }
6276 }
6277 os_releasemutex(libMutex);
6278 return (status);
6279 }
6280
6281 IMA_API IMA_STATUS IMA_GetStaticDiscoveryTargetOidList(
6282 IMA_OID oid,
6283 IMA_OID_LIST **ppList) {
6284 IMA_GetStaticDiscoveryTargetOidListFn PassFunc;
6285 IMA_UINT i;
6286 IMA_STATUS status;
6287
6288 if (number_of_plugins == -1)
6289 InitLibrary();
6290
6291 if (ppList == NULL)
6292 return (IMA_ERROR_INVALID_PARAMETER);
6293
6294 if (oid.objectType != IMA_OBJECT_TYPE_LHBA &&
6295 oid.objectType != IMA_OBJECT_TYPE_PNP)
6296 return (IMA_ERROR_INCORRECT_OBJECT_TYPE);
6297
6298 os_obtainmutex(libMutex);
6299 status = IMA_ERROR_OBJECT_NOT_FOUND;
6300 for (i = 0; i < number_of_plugins; i++) {
6301 if (plugintable[i].ownerId == oid.ownerId) {
6302 status = IMA_ERROR_UNEXPECTED_OS_ERROR;
6303 if (plugintable[i].hPlugin != NULL) {
6304 os_obtainmutex(plugintable[i].pluginMutex);
6305 #ifdef WIN32
6306 PassFunc =
6307 (IMA_GetStaticDiscoveryTargetOidListFn)
6308 GetProcAddress(plugintable[i].hPlugin,
6309 "IMA_GetStaticDiscoveryTargetOidList");
6310 #else
6311 PassFunc =
6312 (IMA_GetStaticDiscoveryTargetOidListFn)
6313 dlsym(plugintable[i].hPlugin,
6314 "IMA_GetStaticDiscoveryTargetOidList");
6315 #endif
6316 if (PassFunc != NULL) {
6317 status = PassFunc(oid, ppList);
6318 }
6319
6320 os_releasemutex(plugintable[i].pluginMutex);
6321 }
6322
6323 break;
6324 }
6325 }
6326 os_releasemutex(libMutex);
6327 return (status);
6328 }
6329
6330 IMA_API IMA_STATUS IMA_GetDiscoveryProperties(
6331 IMA_OID oid,
6332 IMA_DISCOVERY_PROPERTIES *pProps) {
6333 IMA_GetDiscoveryPropertiesFn PassFunc;
6334 IMA_UINT i;
6335 IMA_STATUS status;
6336
6337 if (number_of_plugins == -1)
6338 InitLibrary();
6339
6340 if (pProps == NULL)
6341 return (IMA_ERROR_INVALID_PARAMETER);
6342
6343 if (oid.objectType != IMA_OBJECT_TYPE_PHBA &&
6344 oid.objectType != IMA_OBJECT_TYPE_LHBA)
6345 return (IMA_ERROR_INCORRECT_OBJECT_TYPE);
6346
6347 os_obtainmutex(libMutex);
6348 status = IMA_ERROR_OBJECT_NOT_FOUND;
6349 for (i = 0; i < number_of_plugins; i++) {
6350 if (plugintable[i].ownerId == oid.ownerId) {
6351 status = IMA_ERROR_UNEXPECTED_OS_ERROR;
6352 if (plugintable[i].hPlugin != NULL) {
6353 os_obtainmutex(plugintable[i].pluginMutex);
6354 #ifdef WIN32
6355 PassFunc = (IMA_GetDiscoveryPropertiesFn)
6356 GetProcAddress(plugintable[i].hPlugin,
6357 "IMA_GetDiscoveryProperties");
6358 #else
6359 PassFunc = (IMA_GetDiscoveryPropertiesFn)
6360 dlsym(plugintable[i].hPlugin,
6361 "IMA_GetDiscoveryProperties");
6362 #endif
6363
6364 if (PassFunc != NULL) {
6365 status = PassFunc(oid, pProps);
6366 }
6367 os_releasemutex(plugintable[i].pluginMutex);
6368 }
6369
6370 break;
6371 }
6372 }
6373 os_releasemutex(libMutex);
6374 return (status);
6375 }
6376
6377 IMA_API IMA_STATUS IMA_AddDiscoveryAddress(
6378 IMA_OID oid,
6379 const IMA_TARGET_ADDRESS discoveryAddress,
6380 IMA_OID *pDiscoveryAddressOid) {
6381 IMA_AddDiscoveryAddressFn PassFunc;
6382 IMA_UINT i;
6383 IMA_STATUS status;
6384
6385 if (number_of_plugins == -1)
6386 InitLibrary();
6387
6388 if (oid.objectType != IMA_OBJECT_TYPE_LHBA &&
6389 oid.objectType != IMA_OBJECT_TYPE_PNP)
6390 return (IMA_ERROR_INCORRECT_OBJECT_TYPE);
6391
6392 os_obtainmutex(libMutex);
6393 status = IMA_ERROR_OBJECT_NOT_FOUND;
6394 for (i = 0; i < number_of_plugins; i++) {
6395 if (plugintable[i].ownerId == oid.ownerId) {
6396 status = IMA_ERROR_UNEXPECTED_OS_ERROR;
6397 if (plugintable[i].hPlugin != NULL) {
6398 os_obtainmutex(plugintable[i].pluginMutex);
6399 #ifdef WIN32
6400 PassFunc = (IMA_AddDiscoveryAddressFn)
6401 GetProcAddress(plugintable[i].hPlugin,
6402 "IMA_AddDiscoveryAddress");
6403 #else
6404 PassFunc = (IMA_AddDiscoveryAddressFn)
6405 dlsym(plugintable[i].hPlugin,
6406 "IMA_AddDiscoveryAddress");
6407 #endif
6408
6409 if (PassFunc != NULL) {
6410 status = PassFunc(oid,
6411 discoveryAddress,
6412 pDiscoveryAddressOid);
6413 }
6414 os_releasemutex(plugintable[i].pluginMutex);
6415 }
6416
6417 break;
6418 }
6419 }
6420 os_releasemutex(libMutex);
6421 return (status);
6422 }
6423
6424 IMA_API IMA_STATUS IMA_AddStaticDiscoveryTarget(
6425 IMA_OID oid,
6426 const IMA_STATIC_DISCOVERY_TARGET staticDiscoveryTarget,
6427 IMA_OID *pStaticDiscoveryTargetOid) {
6428 IMA_AddStaticDiscoveryTargetFn PassFunc;
6429 IMA_UINT i;
6430 IMA_STATUS status;
6431
6432 if (number_of_plugins == -1)
6433 InitLibrary();
6434
6435 if (oid.objectType != IMA_OBJECT_TYPE_LHBA &&
6436 oid.objectType != IMA_OBJECT_TYPE_PNP)
6437 return (IMA_ERROR_INCORRECT_OBJECT_TYPE);
6438
6439 os_obtainmutex(libMutex);
6440 status = IMA_ERROR_OBJECT_NOT_FOUND;
6441 for (i = 0; i < number_of_plugins; i++) {
6442 if (plugintable[i].ownerId == oid.ownerId) {
6443 status = IMA_ERROR_UNEXPECTED_OS_ERROR;
6444 if (plugintable[i].hPlugin != NULL) {
6445 os_obtainmutex(plugintable[i].pluginMutex);
6446 #ifdef WIN32
6447 PassFunc = (IMA_AddStaticDiscoveryTargetFn)
6448 GetProcAddress(plugintable[i].hPlugin,
6449 "IMA_AddStaticDiscoveryTarget");
6450
6451 #else
6452 PassFunc = (IMA_AddStaticDiscoveryTargetFn)
6453 dlsym(plugintable[i].hPlugin,
6454 "IMA_AddStaticDiscoveryTarget");
6455 #endif
6456
6457 if (PassFunc != NULL) {
6458 status = PassFunc(oid,
6459 staticDiscoveryTarget,
6460 pStaticDiscoveryTargetOid);
6461 }
6462 os_releasemutex(plugintable[i].pluginMutex);
6463 }
6464
6465 break;
6466 }
6467 }
6468 os_releasemutex(libMutex);
6469 return (status);
6470 }
6471
6472 IMA_API IMA_STATUS IMA_CommitHbaParameters(IMA_OID oid,
6473 IMA_COMMIT_LEVEL commitLevel)
6474 {
6475 IMA_CommitHbaParametersFn PassFunc;
6476 IMA_UINT i;
6477 IMA_STATUS status;
6478
6479 if (number_of_plugins == -1)
6480 InitLibrary();
6481
6482 if (oid.objectType != IMA_OBJECT_TYPE_LHBA &&
6483 oid.objectType != IMA_OBJECT_TYPE_PHBA)
6484 return (IMA_ERROR_INCORRECT_OBJECT_TYPE);
6485
6486 os_obtainmutex(libMutex);
6487 status = IMA_ERROR_OBJECT_NOT_FOUND;
6488 for (i = 0; i < number_of_plugins; i++) {
6489 if (plugintable[i].ownerId == oid.ownerId) {
6490 status = IMA_ERROR_UNEXPECTED_OS_ERROR;
6491 if (plugintable[i].hPlugin != NULL) {
6492 os_obtainmutex(plugintable[i].pluginMutex);
6493 #ifdef WIN32
6494 PassFunc = (IMA_CommitHbaParametersFn)
6495 GetProcAddress(plugintable[i].hPlugin,
6496 "IMA_CommitHbaParameters");
6497 #else
6498 PassFunc = (IMA_CommitHbaParametersFn)
6499 dlsym(plugintable[i].hPlugin,
6500 "IMA_CommitHbaParameters");
6501 #endif
6502
6503 if (PassFunc != NULL) {
6504 status = PassFunc(oid, commitLevel);
6505 }
6506 os_releasemutex(plugintable[i].pluginMutex);
6507 }
6508
6509 break;
6510 }
6511 }
6512 os_releasemutex(libMutex);
6513 return (status);
6514 }
6515
6516 IMA_API IMA_STATUS IMA_RemoveStaticDiscoveryTarget(
6517 IMA_OID oid) {
6518 IMA_RemoveStaticDiscoveryTargetFn PassFunc;
6519 IMA_UINT i;
6520 IMA_STATUS status;
6521
6522 if (number_of_plugins == -1)
6523 InitLibrary();
6524
6525 if (oid.objectType != IMA_OBJECT_TYPE_STATIC_DISCOVERY_TARGET)
6526 return (IMA_ERROR_INCORRECT_OBJECT_TYPE);
6527
6528 os_obtainmutex(libMutex);
6529 status = IMA_ERROR_OBJECT_NOT_FOUND;
6530
6531 for (i = 0; i < number_of_plugins; i++) {
6532 if (plugintable[i].ownerId == oid.ownerId) {
6533 status = IMA_ERROR_UNEXPECTED_OS_ERROR;
6534 if (plugintable[i].hPlugin != NULL) {
6535 os_obtainmutex(plugintable[i].pluginMutex);
6536 #ifdef WIN32
6537 PassFunc = (IMA_RemoveStaticDiscoveryTargetFn)
6538 GetProcAddress(plugintable[i].hPlugin,
6539 "IMA_RemoveStaticDiscoveryTarget");
6540 #else
6541 PassFunc = (IMA_RemoveStaticDiscoveryTargetFn)
6542 dlsym(plugintable[i].hPlugin,
6543 "IMA_RemoveStaticDiscoveryTarget");
6544 #endif
6545
6546 if (PassFunc != NULL) {
6547 status = PassFunc(oid);
6548 }
6549 os_releasemutex(plugintable[i].pluginMutex);
6550 }
6551
6552 break;
6553 }
6554 }
6555 os_releasemutex(libMutex);
6556 return (status);
6557 }
6558
6559 IMA_API IMA_STATUS IMA_GetStaticDiscoveryTargetProperties(
6560 IMA_OID staticDiscoveryTargetOid,
6561 IMA_STATIC_DISCOVERY_TARGET_PROPERTIES *pProps) {
6562 IMA_GetStaticDiscoveryTargetPropertiesFn PassFunc;
6563 IMA_UINT i;
6564 IMA_STATUS status;
6565
6566 if (number_of_plugins == -1)
6567 InitLibrary();
6568
6569 if (pProps == NULL)
6570 return (IMA_ERROR_INVALID_PARAMETER);
6571
6572 if (staticDiscoveryTargetOid.objectType !=
6573 IMA_OBJECT_TYPE_STATIC_DISCOVERY_TARGET)
6574 return (IMA_ERROR_INCORRECT_OBJECT_TYPE);
6575
6576 os_obtainmutex(libMutex);
6577 status = IMA_ERROR_OBJECT_NOT_FOUND;
6578
6579 for (i = 0; i < number_of_plugins; i++) {
6580 if (plugintable[i].ownerId ==
6581 staticDiscoveryTargetOid.ownerId) {
6582
6583 status = IMA_ERROR_UNEXPECTED_OS_ERROR;
6584 if (plugintable[i].hPlugin != NULL) {
6585 os_obtainmutex(plugintable[i].pluginMutex);
6586 #ifdef WIN32
6587 PassFunc =
6588 (IMA_GetStaticDiscoveryTargetPropertiesFn)
6589 GetProcAddress(plugintable[i].hPlugin,
6590 "IMA_GetStaticDiscoveryTargetProperties");
6591 #else
6592 PassFunc =
6593 (IMA_GetStaticDiscoveryTargetPropertiesFn)
6594 dlsym(plugintable[i].hPlugin,
6595 "IMA_GetStaticDiscoveryTargetProperties");
6596 #endif
6597
6598 if (PassFunc != NULL) {
6599 status = PassFunc(
6600 staticDiscoveryTargetOid, pProps);
6601 }
6602 os_releasemutex(plugintable[i].pluginMutex);
6603 }
6604
6605 break;
6606 }
6607 }
6608 os_releasemutex(libMutex);
6609 return (status);
6610 }
6611
6612 IMA_API IMA_STATUS IMA_GetDiscoveryAddressOidList(
6613 IMA_OID Oid,
6614 IMA_OID_LIST **ppList) {
6615
6616 IMA_GetDiscoveryAddressOidListFn PassFunc;
6617 IMA_FreeMemoryFn FreeFunc;
6618
6619 IMA_UINT i;
6620 IMA_UINT j;
6621 IMA_UINT totalIdCount;
6622 IMA_STATUS status;
6623
6624 if (number_of_plugins == -1)
6625 InitLibrary();
6626
6627 if (ppList == NULL)
6628 return (IMA_ERROR_INVALID_PARAMETER);
6629
6630 if ((Oid.objectType != IMA_OBJECT_TYPE_LHBA) &&
6631 (Oid.objectType != IMA_OBJECT_TYPE_PNP)) {
6632 return (IMA_ERROR_INCORRECT_OBJECT_TYPE);
6633 }
6634
6635 os_obtainmutex(libMutex);
6636 // Get total id count first
6637 totalIdCount = 0;
6638
6639 status = IMA_ERROR_OBJECT_NOT_FOUND;
6640 for (i = 0; i < number_of_plugins; i++) {
6641 if (plugintable[i].ownerId == Oid.ownerId) {
6642 status = IMA_ERROR_UNEXPECTED_OS_ERROR;
6643 if (plugintable[i].hPlugin != NULL) {
6644 os_obtainmutex(plugintable[i].pluginMutex);
6645 #ifdef WIN32
6646 PassFunc = (IMA_GetDiscoveryAddressOidListFn)
6647 GetProcAddress(plugintable[i].hPlugin,
6648 "IMA_GetDiscoveryAddressOidList");
6649 #else
6650 PassFunc = (IMA_GetDiscoveryAddressOidListFn)
6651 dlsym(plugintable[i].hPlugin,
6652 "IMA_GetDiscoveryAddressOidList");
6653 #endif
6654 if (PassFunc != NULL) {
6655 IMA_OID_LIST *ppOidList;
6656 status = PassFunc(Oid, &ppOidList);
6657 if (status == IMA_STATUS_SUCCESS) {
6658 totalIdCount +=
6659 ppOidList->oidCount;
6660 #ifdef WIN32
6661 FreeFunc = (IMA_FreeMemoryFn)
6662 GetProcAddress(
6663 plugintable[i].hPlugin,
6664 "IMA_FreeMemory");
6665 #else
6666 FreeFunc = (IMA_FreeMemoryFn)
6667 dlsym(
6668 plugintable[i].hPlugin,
6669 "IMA_FreeMemory");
6670 #endif
6671 if (FreeFunc != NULL) {
6672 FreeFunc(ppOidList);
6673 }
6674 }
6675 }
6676 os_releasemutex(plugintable[i].pluginMutex);
6677 }
6678 if (status != IMA_STATUS_SUCCESS) {
6679 break;
6680 }
6681 }
6682 }
6683
6684 *ppList = (IMA_OID_LIST*)calloc(1, sizeof (IMA_OID_LIST) +
6685 (totalIdCount - 1)* sizeof (IMA_OID));
6686
6687 if ((*ppList) == NULL) {
6688 os_releasemutex(libMutex);
6689 return (IMA_ERROR_UNEXPECTED_OS_ERROR);
6690 }
6691 (*ppList)->oidCount = totalIdCount;
6692
6693 // 2nd pass to copy the id lists
6694 totalIdCount = 0;
6695 status = IMA_ERROR_OBJECT_NOT_FOUND;
6696 for (i = 0; i < number_of_plugins; i++) {
6697 if (plugintable[i].ownerId == Oid.ownerId) {
6698 status = IMA_ERROR_UNEXPECTED_OS_ERROR;
6699 if (plugintable[i].hPlugin != NULL) {
6700 os_obtainmutex(plugintable[i].pluginMutex);
6701 #ifdef WIN32
6702 PassFunc = (IMA_GetDiscoveryAddressOidListFn)
6703 GetProcAddress(plugintable[i].hPlugin,
6704 "IMA_GetDiscoveryAddressOidList");
6705 #else
6706 PassFunc = (IMA_GetDiscoveryAddressOidListFn)
6707 dlsym(plugintable[i].hPlugin,
6708 "IMA_GetDiscoveryAddressOidList");
6709 #endif
6710 if (PassFunc != NULL) {
6711 IMA_OID_LIST *ppOidList;
6712 status = PassFunc(Oid, &ppOidList);
6713 if (status == IMA_STATUS_SUCCESS) {
6714 for (j = 0;
6715 (j < ppOidList->oidCount) &&
6716 (totalIdCount <
6717 (*ppList)->oidCount);
6718 j++) {
6719 #define OBJ_SEQ_NUM ppOidList->oids[j].objectSequenceNumber
6720 (*ppList)->oids
6721 [totalIdCount].
6722 objectType =
6723 ppOidList->oids[j].
6724 objectType;
6725 (*ppList)->oids[
6726 totalIdCount].
6727 objectSequenceNumber
6728 = OBJ_SEQ_NUM;
6729 (*ppList)->oids[
6730 totalIdCount].
6731 ownerId =
6732 ppOidList->
6733 oids[j].ownerId;
6734 totalIdCount++;
6735 #undef OBJ_SEQ_NUM
6736 }
6737 #ifdef WIN32
6738 FreeFunc = (IMA_FreeMemoryFn)
6739 GetProcAddress(
6740 plugintable[i].hPlugin,
6741 "IMA_FreeMemory");
6742 #else
6743 FreeFunc = (IMA_FreeMemoryFn)
6744 dlsym(
6745 plugintable[i].hPlugin,
6746 "IMA_FreeMemory");
6747 #endif
6748 if (FreeFunc != NULL) {
6749 FreeFunc(ppOidList);
6750 }
6751 }
6752 }
6753 os_releasemutex(plugintable[i].pluginMutex);
6754 }
6755 if (status != IMA_STATUS_SUCCESS) {
6756 free(*ppList);
6757 break;
6758 }
6759 }
6760 }
6761
6762 os_releasemutex(libMutex);
6763 return (status);
6764
6765 }
6766
6767 IMA_API IMA_STATUS IMA_GetSessionOidList(
6768 IMA_OID Oid,
6769 IMA_OID_LIST **ppList) {
6770
6771 IMA_GetSessionOidListFn PassFunc;
6772 IMA_FreeMemoryFn FreeFunc;
6773
6774 IMA_UINT i;
6775 IMA_UINT j;
6776 IMA_UINT totalIdCount;
6777 IMA_STATUS status;
6778
6779 if (number_of_plugins == -1)
6780 InitLibrary();
6781
6782 if (ppList == NULL)
6783 return (IMA_ERROR_INVALID_PARAMETER);
6784
6785 if ((Oid.objectType != IMA_OBJECT_TYPE_LHBA) &&
6786 (Oid.objectType != IMA_OBJECT_TYPE_TARGET)) {
6787 return (IMA_ERROR_INCORRECT_OBJECT_TYPE);
6788 }
6789
6790 os_obtainmutex(libMutex);
6791 // Get total id count first
6792 totalIdCount = 0;
6793
6794 status = IMA_ERROR_OBJECT_NOT_FOUND;
6795 for (i = 0; i < number_of_plugins; i++) {
6796 if (plugintable[i].ownerId == Oid.ownerId) {
6797 status = IMA_ERROR_UNEXPECTED_OS_ERROR;
6798 if (plugintable[i].hPlugin != NULL) {
6799 os_obtainmutex(plugintable[i].pluginMutex);
6800 #ifdef WIN32
6801 PassFunc = (IMA_GetSessionOidListFn)
6802 GetProcAddress(plugintable[i].hPlugin,
6803 "IMA_GetSessionOidList");
6804 #else
6805 PassFunc = (IMA_GetSessionOidListFn)
6806 dlsym(plugintable[i].hPlugin,
6807 "IMA_GetSessionOidList");
6808 #endif
6809 if (PassFunc != NULL) {
6810 IMA_OID_LIST *ppOidList;
6811 status = PassFunc(Oid, &ppOidList);
6812 if (status == IMA_STATUS_SUCCESS) {
6813 totalIdCount +=
6814 ppOidList->oidCount;
6815 #ifdef WIN32
6816 FreeFunc = (IMA_FreeMemoryFn)
6817 GetProcAddress(
6818 plugintable[i].hPlugin,
6819 "IMA_FreeMemory");
6820 #else
6821 FreeFunc = (IMA_FreeMemoryFn)
6822 dlsym(
6823 plugintable[i].hPlugin,
6824 "IMA_FreeMemory");
6825 #endif
6826 if (FreeFunc != NULL) {
6827 FreeFunc(ppOidList);
6828 }
6829 }
6830
6831 }
6832 os_releasemutex(plugintable[i].pluginMutex);
6833 }
6834 if (status != IMA_STATUS_SUCCESS) {
6835 break;
6836 }
6837 }
6838 }
6839
6840 *ppList = (IMA_OID_LIST*)calloc(1, sizeof (IMA_OID_LIST) +
6841 (totalIdCount - 1)* sizeof (IMA_OID));
6842
6843 if ((*ppList) == NULL) {
6844 os_releasemutex(libMutex);
6845 return (IMA_ERROR_UNEXPECTED_OS_ERROR);
6846 }
6847 (*ppList)->oidCount = totalIdCount;
6848
6849 // 2nd pass to copy the id lists
6850 totalIdCount = 0;
6851 status = IMA_ERROR_OBJECT_NOT_FOUND;
6852 for (i = 0; i < number_of_plugins; i++) {
6853 if (plugintable[i].ownerId == Oid.ownerId) {
6854 status = IMA_ERROR_UNEXPECTED_OS_ERROR;
6855 if (plugintable[i].hPlugin != NULL) {
6856 os_obtainmutex(plugintable[i].pluginMutex);
6857 #ifdef WIN32
6858 PassFunc = (IMA_GetSessionOidListFn)
6859 GetProcAddress(plugintable[i].hPlugin,
6860 "IMA_GetSessionOidList");
6861 #else
6862 PassFunc = (IMA_GetSessionOidListFn)
6863 dlsym(plugintable[i].hPlugin,
6864 "IMA_GetSessionOidList");
6865 #endif
6866 if (PassFunc != NULL) {
6867 IMA_OID_LIST *ppOidList;
6868 status = PassFunc(Oid, &ppOidList);
6869 if (status == IMA_STATUS_SUCCESS) {
6870 for (j = 0;
6871 (j < ppOidList->oidCount) &&
6872 (totalIdCount <
6873 (*ppList)->oidCount);
6874 j++) {
6875
6876 #define OBJ_SEQ_NUM ppOidList->oids[j].objectSequenceNumber
6877 (*ppList)->oids[
6878 totalIdCount].
6879 objectType =
6880 ppOidList->oids[j].
6881 objectType;
6882 (*ppList)->oids[
6883 totalIdCount].
6884 objectSequenceNumber
6885 = OBJ_SEQ_NUM;
6886 (*ppList)->oids[
6887 totalIdCount].
6888 ownerId =
6889 ppOidList->oids[j].
6890 ownerId;
6891 totalIdCount++;
6892 #undef OBJ_SEQ_NUM
6893 }
6894 #ifdef WIN32
6895 FreeFunc = (IMA_FreeMemoryFn)
6896 GetProcAddress(
6897 plugintable[i].hPlugin,
6898 "IMA_FreeMemory");
6899 #else
6900 FreeFunc = (IMA_FreeMemoryFn)
6901 dlsym(
6902 plugintable[i].hPlugin,
6903 "IMA_FreeMemory");
6904 #endif
6905 if (FreeFunc != NULL) {
6906 FreeFunc(ppOidList);
6907 }
6908 }
6909 }
6910 os_releasemutex(plugintable[i].pluginMutex);
6911 }
6912 if (status != IMA_STATUS_SUCCESS) {
6913 free(*ppList);
6914 break;
6915 }
6916 }
6917 }
6918
6919 os_releasemutex(libMutex);
6920 return (status);
6921
6922 }
6923
6924 IMA_API IMA_STATUS IMA_GetConnectionOidList(
6925 IMA_OID Oid,
6926 IMA_OID_LIST **ppList) {
6927
6928 IMA_GetSessionOidListFn PassFunc;
6929 IMA_FreeMemoryFn FreeFunc;
6930
6931 IMA_UINT i;
6932 IMA_UINT j;
6933 IMA_UINT totalIdCount;
6934 IMA_STATUS status;
6935
6936 if (number_of_plugins == -1)
6937 InitLibrary();
6938
6939 if (ppList == NULL)
6940 return (IMA_ERROR_INVALID_PARAMETER);
6941
6942 if (Oid.objectType != IMA_OBJECT_TYPE_SESSION) {
6943 return (IMA_ERROR_INCORRECT_OBJECT_TYPE);
6944 }
6945
6946 os_obtainmutex(libMutex);
6947 // Get total id count first
6948 totalIdCount = 0;
6949
6950 status = IMA_ERROR_OBJECT_NOT_FOUND;
6951 for (i = 0; i < number_of_plugins; i++) {
6952 if (plugintable[i].ownerId == Oid.ownerId) {
6953 status = IMA_ERROR_UNEXPECTED_OS_ERROR;
6954 if (plugintable[i].hPlugin != NULL) {
6955 os_obtainmutex(plugintable[i].pluginMutex);
6956 #ifdef WIN32
6957 PassFunc = (IMA_GetConnectionOidListFn)
6958 GetProcAddress(plugintable[i].hPlugin,
6959 "IMA_GetConnectionOidList");
6960 #else
6961 PassFunc = (IMA_GetConnectionOidListFn)
6962 dlsym(plugintable[i].hPlugin,
6963 "IMA_GetConnectionOidList");
6964 #endif
6965 if (PassFunc != NULL) {
6966 IMA_OID_LIST *ppOidList;
6967 status = PassFunc(Oid, &ppOidList);
6968 if (status == IMA_STATUS_SUCCESS) {
6969 totalIdCount +=
6970 ppOidList->oidCount;
6971 #ifdef WIN32
6972 FreeFunc = (IMA_FreeMemoryFn)
6973 GetProcAddress(
6974 plugintable[i].hPlugin,
6975 "IMA_FreeMemory");
6976 #else
6977 FreeFunc = (IMA_FreeMemoryFn)
6978 dlsym(
6979 plugintable[i].hPlugin,
6980 "IMA_FreeMemory");
6981 #endif
6982 if (FreeFunc != NULL) {
6983 FreeFunc(ppOidList);
6984 }
6985 }
6986
6987 }
6988 os_releasemutex(plugintable[i].pluginMutex);
6989 }
6990 if (status != IMA_STATUS_SUCCESS) {
6991 break;
6992 }
6993 }
6994 }
6995
6996
6997 *ppList = (IMA_OID_LIST*)calloc(1, sizeof (IMA_OID_LIST)
6998 + (totalIdCount - 1)* sizeof (IMA_OID));
6999
7000 if ((*ppList) == NULL) {
7001 os_releasemutex(libMutex);
7002 return (IMA_ERROR_UNEXPECTED_OS_ERROR);
7003 }
7004 (*ppList)->oidCount = totalIdCount;
7005
7006 // 2nd pass to copy the id lists
7007 totalIdCount = 0;
7008 status = IMA_ERROR_OBJECT_NOT_FOUND;
7009 for (i = 0; i < number_of_plugins; i++) {
7010 if (plugintable[i].ownerId == Oid.ownerId) {
7011 status = IMA_ERROR_UNEXPECTED_OS_ERROR;
7012 if (plugintable[i].hPlugin != NULL) {
7013 os_obtainmutex(plugintable[i].pluginMutex);
7014 #ifdef WIN32
7015 PassFunc = (IMA_GetConnectionOidListFn)
7016 GetProcAddress(plugintable[i].hPlugin,
7017 "IMA_GetConnectionOidList");
7018 #else
7019 PassFunc = (IMA_GetConnectionOidListFn)
7020 dlsym(plugintable[i].hPlugin,
7021 "IMA_GetConnectionOidList");
7022 #endif
7023 if (PassFunc != NULL) {
7024 IMA_OID_LIST *ppOidList;
7025 status = PassFunc(Oid, &ppOidList);
7026 if (status == IMA_STATUS_SUCCESS) {
7027 for (j = 0; (
7028 j < ppOidList->oidCount) &&
7029 (totalIdCount <
7030 (*ppList)->oidCount);
7031 j++) {
7032 #define OBJ_SEQ_NUM ppOidList->oids[j].objectSequenceNumber
7033 (*ppList)->
7034 oids[totalIdCount].
7035 objectType =
7036 ppOidList->
7037 oids[j].objectType;
7038 (*ppList)->
7039 oids[totalIdCount].
7040 objectSequenceNumber
7041 = OBJ_SEQ_NUM;
7042 (*ppList)->
7043 oids[totalIdCount].
7044 ownerId =
7045 ppOidList->oids[j].
7046 ownerId;
7047 totalIdCount++;
7048 #undef OBJ_SEQ_NUM
7049 }
7050 #ifdef WIN32
7051 FreeFunc = (IMA_FreeMemoryFn)
7052 GetProcAddress(
7053 plugintable[i].hPlugin,
7054 "IMA_FreeMemory");
7055 #else
7056 FreeFunc = (IMA_FreeMemoryFn)
7057 dlsym(
7058 plugintable[i].hPlugin,
7059 "IMA_FreeMemory");
7060 #endif
7061 if (FreeFunc != NULL) {
7062 FreeFunc(ppOidList);
7063 }
7064 }
7065 }
7066 os_releasemutex(plugintable[i].pluginMutex);
7067 }
7068 if (status != IMA_STATUS_SUCCESS) {
7069 free(*ppList);
7070 break;
7071 }
7072 }
7073 }
7074 os_releasemutex(libMutex);
7075 return (status);
7076
7077 }
7078
7079 IMA_API IMA_STATUS IMA_RemoveDiscoveryAddress(
7080 IMA_OID discoveryAddressOid) {
7081
7082 IMA_RemoveDiscoveryAddressFn PassFunc;
7083 IMA_UINT i;
7084 IMA_STATUS status;
7085
7086 if (number_of_plugins == -1)
7087 InitLibrary();
7088
7089 if (discoveryAddressOid.objectType !=
7090 IMA_OBJECT_TYPE_DISCOVERY_ADDRESS) {
7091 return (IMA_ERROR_INCORRECT_OBJECT_TYPE);
7092 }
7093
7094 os_obtainmutex(libMutex);
7095 status = IMA_ERROR_OBJECT_NOT_FOUND;
7096
7097 for (i = 0; i < number_of_plugins; i++) {
7098 if (plugintable[i].ownerId == discoveryAddressOid.ownerId) {
7099 status = IMA_ERROR_UNEXPECTED_OS_ERROR;
7100 if (plugintable[i].hPlugin != NULL) {
7101 os_obtainmutex(plugintable[i].pluginMutex);
7102 #ifdef WIN32
7103 PassFunc = (IMA_RemoveDiscoveryAddressFn)
7104 GetProcAddress(plugintable[i].hPlugin,
7105 "IMA_RemoveDiscoveryAddress");
7106 #else
7107 PassFunc = (IMA_RemoveDiscoveryAddressFn)
7108 dlsym(plugintable[i].hPlugin,
7109 "IMA_RemoveDiscoveryAddress");
7110 #endif
7111
7112 if (PassFunc != NULL) {
7113 status = PassFunc(discoveryAddressOid);
7114 }
7115 os_releasemutex(plugintable[i].pluginMutex);
7116 }
7117
7118 break;
7119 }
7120 }
7121 os_releasemutex(libMutex);
7122 return (status);
7123 }
7124
7125 IMA_API IMA_STATUS IMA_GetIpsecProperties(
7126 IMA_OID oid,
7127 IMA_IPSEC_PROPERTIES *pProps) {
7128 IMA_GetIpsecPropertiesFn PassFunc;
7129 IMA_UINT i;
7130 IMA_STATUS status;
7131
7132 if (number_of_plugins == -1)
7133 InitLibrary();
7134
7135 if (pProps == NULL)
7136 return (IMA_ERROR_INVALID_PARAMETER);
7137
7138 if (oid.objectType != IMA_OBJECT_TYPE_PNP &&
7139 oid.objectType != IMA_OBJECT_TYPE_LHBA) {
7140 return (IMA_ERROR_INCORRECT_OBJECT_TYPE);
7141 }
7142
7143 os_obtainmutex(libMutex);
7144 status = IMA_ERROR_OBJECT_NOT_FOUND;
7145
7146 for (i = 0; i < number_of_plugins; i++) {
7147 if (plugintable[i].ownerId == oid.ownerId) {
7148 status = IMA_ERROR_UNEXPECTED_OS_ERROR;
7149 if (plugintable[i].hPlugin != NULL) {
7150 os_obtainmutex(plugintable[i].pluginMutex);
7151 #ifdef WIN32
7152 PassFunc = (IMA_GetIpsecPropertiesFn)
7153 GetProcAddress(plugintable[i].hPlugin,
7154 "IMA_GetIpsecProperties");
7155 #else
7156 PassFunc = (IMA_GetIpsecPropertiesFn)
7157 dlsym(plugintable[i].hPlugin,
7158 "IMA_GetIpsecProperties");
7159 #endif
7160
7161 if (PassFunc != NULL) {
7162 status = PassFunc(oid, pProps);
7163 }
7164 os_releasemutex(plugintable[i].pluginMutex);
7165 }
7166
7167 break;
7168 }
7169 }
7170 os_releasemutex(libMutex);
7171 return (status);
7172 }
7173
7174 IMA_API IMA_STATUS IMA_GetAddressKeys(
7175 IMA_OID targetOid,
7176 IMA_ADDRESS_KEYS **ppKeys) {
7177 IMA_GetAddressKeysFn PassFunc;
7178 IMA_FreeMemoryFn FreeFunc;
7179
7180 IMA_STATUS status;
7181 IMA_UINT i;
7182
7183
7184 if (number_of_plugins == -1)
7185 InitLibrary();
7186
7187 if (ppKeys == NULL)
7188 return (IMA_ERROR_INVALID_PARAMETER);
7189
7190 if (targetOid.objectType != IMA_OBJECT_TYPE_TARGET)
7191 return (IMA_ERROR_INCORRECT_OBJECT_TYPE);
7192
7193 os_obtainmutex(libMutex);
7194
7195 status = IMA_ERROR_OBJECT_NOT_FOUND;
7196 for (i = 0; i < number_of_plugins; i++) {
7197
7198 if (plugintable[i].ownerId == targetOid.ownerId) {
7199 status = IMA_ERROR_UNEXPECTED_OS_ERROR;
7200 if (plugintable[i].hPlugin != NULL) {
7201 os_obtainmutex(plugintable[i].pluginMutex);
7202 #ifdef WIN32
7203 PassFunc =
7204 (IMA_GetAddressKeysFn) GetProcAddress(
7205 plugintable[i].hPlugin,
7206 "IMA_GetAddressKeys");
7207 #else
7208 PassFunc = (IMA_GetAddressKeysFn) dlsym(
7209 plugintable[i].hPlugin,
7210 "IMA_GetAddressKeys");
7211 #endif
7212
7213 if (PassFunc != NULL) {
7214 IMA_ADDRESS_KEYS *ppKeysList;
7215 IMA_UINT addrSize;
7216 addrSize = sizeof (IMA_ADDRESS_KEYS);
7217 status =
7218 PassFunc(targetOid, &ppKeysList);
7219 if (IMA_SUCCESS(status)) {
7220
7221 *ppKeys =
7222 (IMA_ADDRESS_KEYS*)calloc(1,
7223 addrSize +
7224 (ppKeysList->addressKeyCount
7225 - 1) * addrSize);
7226 if ((*ppKeys) == NULL) {
7227 status = EUOS_ERROR;
7228 } else {
7229 memcpy((*ppKeys),
7230 ppKeysList,
7231 addrSize +
7232 (ppKeysList->
7233 addressKeyCount-1)*
7234 addrSize);
7235
7236 }
7237 #ifdef WIN32
7238 FreeFunc = (IMA_FreeMemoryFn)
7239 GetProcAddress(
7240 plugintable[i].hPlugin,
7241 "IMA_FreeMemory");
7242 #else
7243 FreeFunc = (IMA_FreeMemoryFn)
7244 dlsym(
7245 plugintable[i].hPlugin,
7246 "IMA_FreeMemory");
7247 #endif
7248 if (FreeFunc != NULL) {
7249 FreeFunc(ppKeysList);
7250 }
7251 }
7252 }
7253 os_releasemutex(plugintable[i].pluginMutex);
7254 }
7255
7256 break;
7257 }
7258 }
7259 os_releasemutex(libMutex);
7260 return (status);
7261 }
7262
7263 IMA_API IMA_STATUS IMA_GetDiscoveryAddressProperties(
7264 IMA_OID oid,
7265 IMA_DISCOVERY_ADDRESS_PROPERTIES *pProps) {
7266
7267 IMA_GetDiscoveryAddressPropertiesFn PassFunc;
7268 IMA_UINT i;
7269 IMA_STATUS status;
7270
7271 if (number_of_plugins == -1)
7272 InitLibrary();
7273
7274 if (pProps == NULL)
7275 return (IMA_ERROR_INVALID_PARAMETER);
7276
7277 if (oid.objectType != IMA_OBJECT_TYPE_DISCOVERY_ADDRESS)
7278 return (IMA_ERROR_INCORRECT_OBJECT_TYPE);
7279
7280 os_obtainmutex(libMutex);
7281 status = IMA_ERROR_OBJECT_NOT_FOUND;
7282
7283 for (i = 0; i < number_of_plugins; i++) {
7284 if (plugintable[i].ownerId == oid.ownerId) {
7285 status = IMA_ERROR_UNEXPECTED_OS_ERROR;
7286 if (plugintable[i].hPlugin != NULL) {
7287 os_obtainmutex(plugintable[i].pluginMutex);
7288 #ifdef WIN32
7289 PassFunc =
7290 (IMA_GetDiscoveryAddressPropertiesFn)
7291 GetProcAddress(
7292 plugintable[i].hPlugin,
7293 "IMA_GetDiscoveryAddressProperties");
7294 #else
7295 PassFunc =
7296 (IMA_GetDiscoveryAddressPropertiesFn) dlsym(
7297 plugintable[i].hPlugin,
7298 "IMA_GetDiscoveryAddressProperties");
7299 #endif
7300
7301 if (PassFunc != NULL) {
7302 status = PassFunc(oid, pProps);
7303 }
7304 os_releasemutex(plugintable[i].pluginMutex);
7305 }
7306
7307 break;
7308 }
7309 }
7310 os_releasemutex(libMutex);
7311 return (status);
7312 }
7313
7314 IMA_API IMA_STATUS QIMA_SetUpdateInterval(
7315 IMA_OID pluginOid, time_t interval) {
7316 QIMA_SetUpdateIntervalFn updFunc;
7317 IMA_UINT i;
7318 IMA_STATUS status;
7319
7320 if (number_of_plugins == -1)
7321 InitLibrary();
7322
7323 if (interval <= 1)
7324 return (IMA_ERROR_INVALID_PARAMETER);
7325
7326 if ((pluginOid.objectType != IMA_OBJECT_TYPE_PLUGIN) ||
7327 (pluginOid.objectSequenceNumber != 0))
7328 return (IMA_ERROR_INVALID_PARAMETER);
7329
7330 os_obtainmutex(libMutex);
7331 status = IMA_ERROR_OBJECT_NOT_FOUND;
7332
7333 for (i = 0; i < number_of_plugins; i++) {
7334 if (plugintable[i].ownerId == pluginOid.ownerId) {
7335 status = IMA_ERROR_UNEXPECTED_OS_ERROR;
7336 if (plugintable[i].hPlugin != NULL) {
7337 os_obtainmutex(plugintable[i].pluginMutex);
7338 #ifdef WIN32
7339 updFunc = (QIMA_SetUpdateIntervalFn)
7340 GetProcAddress(
7341 plugintable[i].hPlugin,
7342 "QIMA_SetUpdateInterval");
7343 #else
7344 updFunc = (QIMA_SetUpdateIntervalFn) dlsym(
7345 plugintable[i].hPlugin,
7346 "QIMA_SetUpdateInterval");
7347 #endif
7348
7349 if (updFunc != NULL) {
7350 status = updFunc(pluginOid, interval);
7351 }
7352 os_releasemutex(plugintable[i].pluginMutex);
7353 }
7354
7355 break;
7356 }
7357 }
7358 os_releasemutex(libMutex);
7359 return (status);
7360
7361 }