static void generate_pop(range_obj_t* rootObj, SaImmCcbHandleT ccbHandle, const SaImmClassNameT className,
SaImmAttrNameT rdnAttName, SaImmValueTypeT rdnAttType, SaImmAdminOwnerHandleT ownerHandle)
{
SaAisErrorT err = SA_AIS_OK;
unsigned int ix;
unsigned int rdn = rootObj->botRdn;
SaNameT rdnAttrVal;
unsigned int retries = 0;
const SaNameT* objectNames[] = {&(rootObj->parentDn), NULL};
for (ix = 0; ix < 100 && rdn <= rootObj->topRdn; ++ix, ++rdn) {
rdnAttrVal.length = snprintf((char *) rdnAttrVal.value,
sizeof(rdnAttrVal.value), "%s=%u", rdnAttName, rdn);
ccb_create_obj(&rootObj->parentDn, &rdnAttrVal, ccbHandle, className, rdnAttName, rdnAttType);
}
do {
err = saImmOmCcbApply(ccbHandle);
if(err == SA_AIS_ERR_TRY_AGAIN) {
usleep(250 * 1000);
}
} while ((err == SA_AIS_ERR_TRY_AGAIN) && (retries < 15));
if (err != SA_AIS_OK) {
fprintf(stderr, "error - Failed to apply ccb for parent:%s range %u<->%u, error:%s\n",
(char *) rootObj->parentDn.value, rootObj->botRdn, rootObj->topRdn, saf_error(err));
exit(1);
}
VERBOSE_INFO("successfull Apply for parent %s range %u<->%u\n",
(char *) rootObj->parentDn.value, rootObj->botRdn, rootObj->topRdn);
for (ix = 0; ix < 100 && rootObj->sublevel[ix]; ++ix) {
generate_pop(rootObj->sublevel[ix], ccbHandle, className, rdnAttName, rdnAttType, ownerHandle);
}
err = saImmOmAdminOwnerRelease(ownerHandle, objectNames, SA_IMM_ONE);
if (err != SA_AIS_OK) {
fprintf(stderr, "error - Failed to release admo - ignoring\n");
}
}
/**
* Clears the special applier name
*
*/
void ntfimcn_special_applier_clear(void)
{
SaAisErrorT rc;
int msecs_waited;
msecs_waited = 0;
rc = saImmOiImplementerClear(ntfimcn_cb.immOiHandle);
while (((rc == SA_AIS_ERR_TRY_AGAIN) ||
(rc == SA_AIS_ERR_TIMEOUT)) &&
(msecs_waited < max_waiting_time_3s)) {
usleep(sleep_delay_ms * 1000);
msecs_waited += sleep_delay_ms;
rc = saImmOiImplementerClear(ntfimcn_cb.immOiHandle);
}
if (rc != SA_AIS_OK) {
if (rc == SA_AIS_ERR_BAD_HANDLE) {
TRACE("%s saImmOiImplementerClear failed %s",__FUNCTION__,saf_error(rc));
}
}
}
/**
* Get name of rdn attribute from IMM
*
* Note:
* A valid ntf_cb.immOmHandle must exist
* Uses in file global struct s_get_rdn_attr_name
*
* @param className[in]
*
* @return String with name
*/
static char *get_rdn_attr_name(const SaImmClassNameT className)
{
SaAisErrorT rc;
int msecs_waited;
int i = 0;
SaImmClassCategoryT classCategory;
SaImmAttrDefinitionT_2 **attrDescr;
TRACE_ENTER();
/* Just return the name if already looked up */
if (strcmp(className, s_get_rdn_attr_name.saved_className) == 0) {
goto done;
}
strncpy(s_get_rdn_attr_name.saved_className, className, SA_MAX_NAME_LENGTH-1);
/* Get class description */
msecs_waited = 0;
rc = saImmOmClassDescriptionGet_2(ntfimcn_cb.immOmHandle,
className,
&classCategory,
&attrDescr);
while ((rc == SA_AIS_ERR_TRY_AGAIN) && (msecs_waited < max_waiting_time_7s)) {
usleep(sleep_delay_ms * 1000);
msecs_waited += sleep_delay_ms;
rc = saImmOmClassDescriptionGet_2(ntfimcn_cb.immOmHandle,
className,
&classCategory,
&attrDescr);
}
if (rc != SA_AIS_OK) {
LOG_ER("saImmOmClassDescriptionGet_2 failed %s", saf_error(rc));
goto error;
}
/* Find the name of the attribute with the RDN flag set */
s_get_rdn_attr_name.attrName[0] = '\0';
for (i=0; attrDescr[i] != NULL; i++) {
if (attrDescr[i]->attrFlags & SA_IMM_ATTR_RDN) {
strncpy(s_get_rdn_attr_name.attrName,attrDescr[i]->attrName,SA_MAX_NAME_LENGTH);
s_get_rdn_attr_name.attrName[SA_MAX_NAME_LENGTH-1] = '\0';
break;
}
}
/* Free memory allocated for attribute descriptions */
msecs_waited = 0;
rc = saImmOmClassDescriptionMemoryFree_2(ntfimcn_cb.immOmHandle,attrDescr);
while ((rc == SA_AIS_ERR_TRY_AGAIN) && (msecs_waited < max_waiting_time_7s)) {
usleep(sleep_delay_ms * 1000);
msecs_waited += sleep_delay_ms;
rc = saImmOmClassDescriptionMemoryFree_2(ntfimcn_cb.immOmHandle,attrDescr);
}
if (rc != SA_AIS_OK) {
LOG_ER("saImmOmClassDescriptionMemoryFree_2 failed %s", saf_error(rc));
goto error;
}
done:
TRACE_LEAVE();
return s_get_rdn_attr_name.attrName;
error:
osafassert(0);
return 0; /* Dummy */
}
/**
* Initialize the OI interface, get a selection object and become applier
*
* @global_param max_waiting_time_ms: Wait max time for each operation.
* @global_param applier_name: The name of the "configuration change" applier
* @param *cb[out]
*
* @return (-1) if init fail
*/
int ntfimcn_imm_init(ntfimcn_cb_t *cb)
{
SaAisErrorT rc;
int internal_rc = 0;
int msecs_waited;
TRACE_ENTER();
/*
* Set IMM environment variable for synchronous timeout to 1 sec
*/
setenv("IMMA_SYNCR_TIMEOUT","100",1);
/*
* Initialize the IMM OI API
* -------------------------
*/
msecs_waited = 0;
rc = saImmOiInitialize_2(&cb->immOiHandle, &callbacks, &imm_version);
while ((rc == SA_AIS_ERR_TRY_AGAIN) && (msecs_waited < max_waiting_time_60s)) {
usleep(sleep_delay_ms * 1000);
msecs_waited += sleep_delay_ms;
rc = saImmOiInitialize_2(&cb->immOiHandle, &callbacks, &imm_version);
}
if (rc != SA_AIS_OK) {
LOG_ER("%s saImmOiInitialize_2 failed %s",__FUNCTION__,saf_error(rc));
internal_rc = NTFIMCN_INTERNAL_ERROR;
goto done;
}
/*
* Get a selection object for the IMM OI
* -------------------------------------
*/
msecs_waited = 0;
rc = saImmOiSelectionObjectGet(cb->immOiHandle, &cb->immSelectionObject);
while ((rc == SA_AIS_ERR_TRY_AGAIN) && (msecs_waited < max_waiting_time_60s)) {
usleep(sleep_delay_ms * 1000);
msecs_waited += sleep_delay_ms;
rc = saImmOiSelectionObjectGet(cb->immOiHandle, &cb->immSelectionObject);
}
if (rc != SA_AIS_OK) {
LOG_ER("%s saImmOiSelectionObjectGet failed %s",__FUNCTION__,saf_error(rc));
internal_rc = NTFIMCN_INTERNAL_ERROR;
goto done;
}
/*
* Become the "configuration change" applier
* -----------------------------------------
*/
SaImmOiImplementerNameT applier_name = applier_nameA;
msecs_waited = 0;
rc = saImmOiImplementerSet(cb->immOiHandle, applier_name);
while (((rc == SA_AIS_ERR_TRY_AGAIN) ||
(rc == SA_AIS_ERR_EXIST)) &&
(msecs_waited < max_waiting_time_60s)) {
usleep(sleep_delay_ms * 1000);
msecs_waited += sleep_delay_ms;
if (rc == SA_AIS_ERR_EXIST) {
if (strcmp( applier_name, applier_nameA) == 0) {
applier_name = applier_nameB;
} else {
applier_name = applier_nameA;
}
}
rc = saImmOiImplementerSet(cb->immOiHandle, applier_name);
}
if (rc != SA_AIS_OK) {
LOG_ER("%s Becoming an applier failed %s",__FUNCTION__,saf_error(rc));
internal_rc = NTFIMCN_INTERNAL_ERROR;
goto done;
}
/*
* Initialize the IMM OM API
* -------------------------
*/
msecs_waited = 0;
rc = saImmOmInitialize(&cb->immOmHandle, &omCallbacks, &imm_version);
while ((rc == SA_AIS_ERR_TRY_AGAIN) && (msecs_waited < max_waiting_time_60s)) {
usleep(sleep_delay_ms * 1000);
msecs_waited += sleep_delay_ms;
rc = saImmOmInitialize(&cb->immOmHandle, &omCallbacks, &imm_version);
}
if (rc != SA_AIS_OK) {
LOG_ER("%s saImmOmInitialize failed %s",__FUNCTION__,saf_error(rc));
internal_rc = NTFIMCN_INTERNAL_ERROR;
goto done;
}
done:
TRACE_LEAVE();
return internal_rc;
}
/*
* Exit if anything fails. This will cause ntfs to restart ntfimcn
*/
int main(int argc, char** argv)
{
const char* logPath;
const char* trace_label = "osafntfimcnd";
SaAisErrorT ais_error = SA_AIS_OK;
/*
* Activate Log Trace
*/
openlog(basename(argv[0]), LOG_PID, LOG_LOCAL0);
if ((logPath = getenv("NTFSCN_TRACE_PATHNAME"))) {
category_mask = 0xffffffff;
} else {
logPath = PKGLOGDIR "/" NTFIMCN_DEFAULT_LOG;
}
if (logtrace_init(trace_label, logPath, category_mask) == -1)
{
syslog(LOG_ERR, "osafntfimcnd logtrace_init FAILED");
/* We allow to execute anyway. */
}
/*
* Initiate HA state
*/
if (strcmp(argv[1],"active") == 0) {
ntfimcn_cb.haState = SA_AMF_HA_ACTIVE;
} else {
ntfimcn_cb.haState = SA_AMF_HA_STANDBY;
}
/*
* Initiate external functionallity
* Exit on fail. This will cause ntfs to restart ntfimcn
*/
if (ntfimcn_ntf_init(&ntfimcn_cb) == NTFIMCN_INTERNAL_ERROR) {
LOG_ER("ntfimcn_ntf_init() Fail");
_Exit(EXIT_FAILURE);
}
if (ntfimcn_imm_init(&ntfimcn_cb) == NTFIMCN_INTERNAL_ERROR) {
LOG_ER("ntfimcn_imm_init() Fail");
imcn_exit(EXIT_FAILURE);
}
/* Signal for TRACE on/off */
if (signal(SIGUSR2, sigusr2_handler) == SIG_ERR) {
LOG_ER("signal USR2 failed: %s", strerror(errno));
/* We allow to execute anyway. */
}
if (ntfimcn_send_lost_cm_notification() == NTFIMCN_INTERNAL_ERROR) {
LOG_ER("send_lost_cm_notification() Fail");
imcn_exit(EXIT_FAILURE);
}
/* Termination signal with handler */
if (ncs_sel_obj_create(&term_sel_obj) != NCSCC_RC_SUCCESS) {
LOG_ER("ncs_sel_obj_create failed");
_Exit(EXIT_FAILURE);
}
if (signal(SIGTERM, sigterm_handler) == SIG_ERR) {
LOG_ER("signal TERM failed: %s", strerror(errno));
_Exit(EXIT_FAILURE);
}
/*
* Initiate polling
*/
fds[FD_IMM].fd = ntfimcn_cb.immSelectionObject;
fds[FD_IMM].events = POLLIN;
fds[FD_TERM].fd = term_sel_obj.rmv_obj;
fds[FD_TERM].events = POLLIN;
LOG_NO("Started");
while (1) {
if (poll(fds, nfds, -1) == (-1)) {
if (errno == EINTR) {
continue;
}
LOG_ER("poll Fail - %s", strerror(errno));
imcn_exit(EXIT_FAILURE);
}
if (fds[FD_TERM].revents & POLLIN) {
handle_sigterm_event();
}
if (fds[FD_IMM].revents & POLLIN) {
ais_error = saImmOiDispatch(ntfimcn_cb.immOiHandle, SA_DISPATCH_ALL);
if (ais_error != SA_AIS_OK) {
LOG_NO("saImmOiDispatch() Fail %s",saf_error(ais_error));
imcn_exit(EXIT_FAILURE);
}
}
}
return 0; /* Dummy */
}
int main(int argc, char *argv[])
{
int c;
struct option long_options[] = {
{"disable-tryagain", no_argument, 0, 'd'},
{"parameter", required_argument, 0, 'p'},
{"operation-id", required_argument, 0, 'o'},
{"operation-name", required_argument, 0, 'O'},
{"admin-owner", required_argument, 0, 'a'},
{"help", no_argument, 0, 'h'},
{"timeout", required_argument, 0, 't'},
{"verbose", no_argument, 0, 'v'},
{0, 0, 0, 0}
};
SaAisErrorT error;
SaImmHandleT immHandle;
SaImmAdminOwnerNameT adminOwnerName = basename(argv[0]);
bool releaseAdmo=true;
bool explicitAdmo=false;
SaImmAdminOwnerHandleT ownerHandle;
SaNameT objectName;
const SaNameT *objectNames[] = { &objectName, NULL };
SaAisErrorT operationReturnValue = -1;
SaImmAdminOperationParamsT_2 *param;
const SaImmAdminOperationParamsT_2 **params;
SaImmAdminOperationParamsT_2 **out_params=NULL;
SaImmAdminOperationIdT operationId = -1;
unsigned long timeoutVal = 60; /* Default timeout value */
int disable_tryagain = false;
int isFirst = 1;
int verbose = 0;
int params_len = 0;
/* Support for long DN */
setenv("SA_ENABLE_EXTENDED_NAMES", "1", 1);
/* osaf_extended_name_init() is added to prevent future safe use of
* osaf_extended_name_* before saImmOmInitialize and saImmOiInitialize */
osaf_extended_name_init();
params = realloc(NULL, sizeof(SaImmAdminOperationParamsT_2 *));
params[0] = NULL;
SaStringT opName = NULL;
while (1) {
c = getopt_long(argc, argv, "dp:o:O:a:t:hv", long_options, NULL);
if (c == -1) /* have all command-line options have been parsed? */
break;
switch (c) {
case 'd':
disable_tryagain = true;
break;
case 'o':
if(operationId != -1) {
fprintf(stderr, "Cannot set admin operation more then once");
exit(EXIT_FAILURE);
}
operationId = strtoll(optarg, (char **)NULL, 10);
if ((operationId == 0) && ((errno == EINVAL) || (errno == ERANGE))) {
fprintf(stderr, "Illegal operation ID\n");
exit(EXIT_FAILURE);
}
break;
case 'O':
if(operationId != -1) {
fprintf(stderr, "Cannot set admin operation more then once");
exit(EXIT_FAILURE);
}
operationId = SA_IMM_PARAM_ADMOP_ID_ESC;
params_len++;
params = realloc(params, (params_len + 1) * sizeof(SaImmAdminOperationParamsT_2 *));
param = malloc(sizeof(SaImmAdminOperationParamsT_2));
params[params_len - 1] = param;
params[params_len] = NULL;
param->paramName = strdup(SA_IMM_PARAM_ADMOP_NAME);
param->paramType = SA_IMM_ATTR_SASTRINGT;
param->paramBuffer = malloc(sizeof(SaStringT));
*((SaStringT *)(param->paramBuffer)) = strdup(optarg);
opName = strdup(optarg);
break;
case 'p':
params_len++;
params = realloc(params, (params_len + 1) * sizeof(SaImmAdminOperationParamsT_2 *));
param = malloc(sizeof(SaImmAdminOperationParamsT_2));
params[params_len - 1] = param;
params[params_len] = NULL;
if (init_param(param, optarg) == -1) {
fprintf(stderr, "Illegal parameter: %s\n", optarg);
exit(EXIT_FAILURE);
}
break;
case 't':
timeoutVal = strtoll(optarg, (char **)NULL, 10);
if ((timeoutVal == 0) || (errno == EINVAL) || (errno == ERANGE)) {
fprintf(stderr, "Illegal timeout value\n");
exit(EXIT_FAILURE);
}
break;
case 'a':
adminOwnerName = (SaImmAdminOwnerNameT)malloc(strlen(optarg) + 1);
strcpy(adminOwnerName, optarg);
releaseAdmo=false;
explicitAdmo=true;
break;
case 'h':
usage(basename(argv[0]));
exit(EXIT_SUCCESS);
break;
case 'v':
verbose = 1;
break;
default:
fprintf(stderr, "Try '%s --help' for more information\n", argv[0]);
exit(EXIT_FAILURE);
break;
}
}
if (operationId == -1) {
fprintf(stderr, "error - must specify admin operation ID %llx\n", operationId);
exit(EXIT_FAILURE);
}
/* Need at least one object to operate on */
if ((argc - optind) == 0) {
fprintf(stderr, "error - wrong number of arguments\n");
exit(EXIT_FAILURE);
}
signal(SIGALRM, sigalarmh);
(void) alarm(timeoutVal);
immutilWrapperProfile.errorsAreFatal = 0;
immutilWrapperProfile.nTries = disable_tryagain ? 0 : timeoutVal;
immutilWrapperProfile.retryInterval = 1000;
error = immutil_saImmOmInitialize(&immHandle, NULL, &immVersion);
if (error != SA_AIS_OK) {
fprintf(stderr, "error - saImmOmInitialize FAILED: %s\n", saf_error(error));
exit(EXIT_FAILURE);
}
if((optind < argc) && (!explicitAdmo)) {
saAisNameLend(argv[optind], &objectName);
if(strcmp(saAisNameBorrow(&objectName), OPENSAF_IMM_OBJECT_DN)==0) {
releaseAdmo=false;
adminOwnerName = (SaImmAdminOwnerNameT) malloc(strlen(OPENSAF_IMM_SERVICE_NAME) + 1);
strcpy(adminOwnerName, OPENSAF_IMM_SERVICE_NAME);
printf("[using admin-owner: '%s']\n", adminOwnerName);
}
}
error = immutil_saImmOmAdminOwnerInitialize(immHandle, adminOwnerName, releaseAdmo?SA_TRUE:SA_FALSE, &ownerHandle);
if (error != SA_AIS_OK) {
fprintf(stderr, "error - saImmOmAdminOwnerInitialize FAILED: %s\n", saf_error(error));
exit(EXIT_FAILURE);
}
/* Remaining arguments should be object names on which the admin op should be performed. */
while (optind < argc) {
saAisNameLend(argv[optind], &objectName);
error = immutil_saImmOmAdminOwnerSet(ownerHandle, objectNames, SA_IMM_ONE);
if (error != SA_AIS_OK) {
if (error == SA_AIS_ERR_NOT_EXIST) {
if(strcmp(adminOwnerName, saAisNameBorrow(&objectName))==0) {
/* AdminOwnerName == ImplementerName - Could be direct admin-op on OI */
goto retry;
}
fprintf(stderr, "error - saImmOmAdminOwnerSet - object '%s' does not exist\n",
saAisNameBorrow(&objectName));
}
else
fprintf(stderr, "error - saImmOmAdminOwnerSet FAILED: %s\n", saf_error(error));
exit(EXIT_FAILURE);
}
retry:
error = immutil_saImmOmAdminOperationInvoke_o2(ownerHandle, &objectName, 0, operationId,
params, &operationReturnValue, SA_TIME_ONE_SECOND * timeoutVal, &out_params);
if (error != SA_AIS_OK) {
fprintf(stderr, "error - saImmOmAdminOperationInvoke_2 FAILED: %s\n",
saf_error(error));
exit(EXIT_FAILURE);
}
if (operationReturnValue != SA_AIS_OK ) {
unsigned int ix = 0;
if ((operationReturnValue == SA_AIS_ERR_TRY_AGAIN) && !disable_tryagain) {
sleep(1);
goto retry;
}
fprintf(stderr, "error - saImmOmAdminOperationInvoke_2 admin-op RETURNED: %s\n",
saf_error(operationReturnValue));
while(out_params && out_params[ix]) {
if(strcmp(out_params[ix]->paramName, SA_IMM_PARAM_ADMOP_ERROR) == 0) {
assert(out_params[ix]->paramType == SA_IMM_ATTR_SASTRINGT);
SaStringT errStr = (*((SaStringT *) out_params[ix]->paramBuffer));
fprintf(stderr, "error-string: %s\n", errStr);
}
++ix;
}
/* After printing error string, print all returned parameters */
if (verbose && out_params && out_params[0]) {
if(!isFirst)
printf("\n");
print_params(argv[optind], out_params);
}
exit(EXIT_FAILURE);
}
if (((opName && (strncmp(opName,"display",7)==0))||verbose) &&out_params && out_params[0]) {
if(!isFirst)
printf("\n");
else
isFirst = 0;
print_params(argv[optind], out_params);
}
error = saImmOmAdminOperationMemoryFree(ownerHandle, out_params);
if (error != SA_AIS_OK) {
fprintf(stderr, "error - saImmOmAdminOperationMemoryFree FAILED: %s\n", saf_error(error));
exit(EXIT_FAILURE);
}
if(releaseAdmo) {
error = immutil_saImmOmAdminOwnerRelease(ownerHandle, objectNames, SA_IMM_ONE);
if (error != SA_AIS_OK) {
fprintf(stderr, "error - saImmOmAdminOwnerRelease FAILED: %s\n", saf_error(error));
exit(EXIT_FAILURE);
}
}
optind++;
}
error = immutil_saImmOmAdminOwnerFinalize(ownerHandle);
if (SA_AIS_OK != error) {
fprintf(stderr, "error - saImmOmAdminOwnerFinalize FAILED: %s\n", saf_error(error));
exit(EXIT_FAILURE);
}
error = immutil_saImmOmFinalize(immHandle);
if (SA_AIS_OK != error) {
fprintf(stderr, "error - saImmOmFinalize FAILED: %s\n", saf_error(error));
exit(EXIT_FAILURE);
}
exit(EXIT_SUCCESS);
}
int main(int argc, char *argv[])
{
int rc = EXIT_SUCCESS;
int c;
struct option long_options[] = {
{"class", no_argument, NULL, 'c'},
{"help", no_argument, NULL, 'h'},
{"populate", required_argument, NULL, 'p'},
{"verbose", no_argument, NULL, 'v'},
{0, 0, 0, 0}
};
SaAisErrorT error;
SaImmHandleT immHandle;
SaImmAdminOwnerNameT adminOwnerName = create_adminOwnerName(basename(argv[0]));
SaImmAdminOwnerHandleT ownerHandle;
SaImmClassNameT className = NULL;
static SaVersionT immVersion = { 'A', 2, 11 };
int population = 0;
while (1) {
int option_index = 0;
c = getopt_long(argc, argv, "chp:v", long_options, &option_index);
if (c == -1) /* have all command-line options have been parsed? */
break;
switch (c) {
case 'c':
output_testclass();
exit(EXIT_SUCCESS);
break;
case 'h':
usage(basename(argv[0]));
exit(EXIT_SUCCESS);
break;
case 'p':
population = atol(optarg);
break;
case 'v':
verbose = 1;
break;
default:
fprintf(stderr, "Try '%s --help' for more information\n", argv[0]);
exit(EXIT_FAILURE);
break;
}
}
/* The remaining argument needs to be a class name */
if ((argc - optind) != 1) {
fprintf(stderr, "error - need to specify a class name\n");
exit(EXIT_FAILURE);
}
className = strdup(argv[optind]);
(void)immutil_saImmOmInitialize(&immHandle, NULL, &immVersion);
error = saImmOmAdminOwnerInitialize(immHandle, adminOwnerName, SA_TRUE, &ownerHandle);
if (error != SA_AIS_OK) {
fprintf(stderr, "error - saImmOmAdminOwnerInitialize FAILED: %s\n", saf_error(error));
rc = EXIT_FAILURE;
goto done_om_finalize;
}
rc = populate_imm(className, population, ownerHandle, immHandle);
error = saImmOmAdminOwnerFinalize(ownerHandle);
if (SA_AIS_OK != error) {
fprintf(stderr, "error - saImmOmAdminOwnerFinalize FAILED: %s\n", saf_error(error));
rc = EXIT_FAILURE;
}
done_om_finalize:
(void)immutil_saImmOmFinalize(immHandle);
exit(rc);
}
static int populate_imm(const SaImmClassNameT className,
unsigned int pop, SaImmAdminOwnerHandleT ownerHandle, SaImmHandleT immHandle)
{
SaAisErrorT error;
int i;
int rc = EXIT_FAILURE;
SaImmCcbHandleT ccbHandle;
SaImmClassCategoryT classCategory;
SaImmAttrDefinitionT_2 **attrDefinitions;
SaImmAttrDefinitionT_2 *att;
SaImmAttrNameT rdnAttName = NULL;
SaImmValueTypeT rdnAttType = SA_IMM_ATTR_SAANYT;
range_obj_t *rootObj = NULL;
if ((error = saImmOmClassDescriptionGet_2(immHandle, className, &classCategory, &attrDefinitions)) != SA_AIS_OK) {
fprintf(stderr, "error - saImmOmClassDescriptionGet_2 FAILED: %s\n", saf_error(error));
goto done;
}
if (classCategory == SA_IMM_CLASS_RUNTIME) {
fprintf(stderr, "error - Class %s is a runtime class\n", className);
goto done;
}
for (i = 0, att = attrDefinitions[i]; att != NULL; att = attrDefinitions[++i]) {
if (att->attrFlags & SA_IMM_ATTR_RDN) {
rdnAttName = att->attrName;
rdnAttType = att->attrValueType;
} else if (att->attrFlags & SA_IMM_ATTR_INITIALIZED) {
fprintf(stderr, "error - Attribute %s has INITIALIZED flag, cant handle\n", att->attrName);
goto done;
}
VERBOSE_INFO("attrName: %s\n", att->attrName);
}
if (!rdnAttName) {
fprintf(stderr, "error - Could not find any RDN attribure\n");
goto done;
}
VERBOSE_INFO("Rdn attrName:%s type:%s\n", rdnAttName, (rdnAttType==SA_IMM_ATTR_SASTRINGT)?"SA_STRINGT":
(rdnAttType==SA_IMM_ATTR_SANAMET)?"SA_NAMET":"WRONG");
if ((error = saImmOmCcbInitialize(ownerHandle, (ccb_safe ? SA_IMM_CCB_REGISTERED_OI : 0x0), &ccbHandle))
!= SA_AIS_OK) {
fprintf(stderr, "error - saImmOmCcbInitialize FAILED: %s\n", saf_error(error));
goto done;
}
VERBOSE_INFO("className: %s po:%u\n", className, pop);
rootObj = gen_pop_tree(0, NULL, 0, 1, pop, rdnAttName);
ccb_create_obj(NULL, &rootObj->parentDn, ccbHandle, className, rdnAttName, rdnAttType);
generate_pop(rootObj, ccbHandle, className, rdnAttName, rdnAttType, ownerHandle);
if ((error = saImmOmCcbFinalize(ccbHandle)) != SA_AIS_OK) {
fprintf(stderr, "error - saImmOmCcbFinalize FAILED: %s\n", saf_error(error));
goto done;
}
rc = 0;
done:
return rc;
}
