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 } 7367