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