static void printReasons(AvoidanceReasonFlags reasons, TextStream& stream) { bool first = true; for (auto reasonItem = EndOfReasons >> 1; reasonItem != NoReason; reasonItem >>= 1) { if (!(reasons & reasonItem)) continue; stream << (first ? " " : ", "); first = false; printReason(reasonItem, stream); } }
void modifySpin1(Widget w, XtPointer client, XtPointer call) { XmSpinBoxCallbackStruct *user; user = (XmSpinBoxCallbackStruct *)call; if (user->position > SPIN1_MAX) user->doit = False; else /***** Print string description of reason *****/ printReason(user->reason); }
void changedSpin0(Widget w, XtPointer client, XtPointer call) { XmSpinBoxCallbackStruct *user; static int thisYear = 1994; user = (XmSpinBoxCallbackStruct *)call; /***** Print string description of reason *****/ printReason(user->reason); if (user->crossed_boundary) { if (user->reason == XmCR_SPIN_NEXT) thisYear++; else thisYear--; printf("Year Now: %d\n", thisYear); } }
void printSimpleLineLayoutCoverage() { HashSet<const RenderBlockFlow*> leafRenderers; collectNonEmptyLeafRenderBlockFlowsForCurrentPage(leafRenderers); if (!leafRenderers.size()) { WTFLogAlways("No text found in this document\n"); return; } TextStream stream; HashMap<AvoidanceReason, unsigned> flowStatistics; unsigned textLength = 0; unsigned unsupportedTextLength = 0; unsigned numberOfUnsupportedLeafBlocks = 0; for (const auto* flow : leafRenderers) { auto flowLength = textLengthForSubtree(*flow); textLength += flowLength; auto reasons = canUseForWithReason(*flow, FallThrough::Yes); if (reasons == NoReason) continue; ++numberOfUnsupportedLeafBlocks; unsupportedTextLength += flowLength; for (auto reasonItem = EndOfReasons >> 1; reasonItem != NoReason; reasonItem >>= 1) { if (!(reasons & reasonItem)) continue; auto result = flowStatistics.add(reasonItem, flowLength); if (!result.isNewEntry) result.iterator->value += flowLength; } } stream << "---------------------------------------------------\n"; stream << "Number of text blocks: total(" << leafRenderers.size() << ") non-simple(" << numberOfUnsupportedLeafBlocks << ")\nText length: total(" << textLength << ") non-simple(" << unsupportedTextLength << ")\n"; for (const auto reasonEntry : flowStatistics) { printReason(reasonEntry.key, stream); stream << ": " << (float)reasonEntry.value / (float)textLength * 100 << "%\n"; } stream << "simple line layout coverage: " << (float)(textLength - unsupportedTextLength) / (float)textLength * 100 << "%\n"; stream << "---------------------------------------------------\n"; WTFLogAlways("%s", stream.release().utf8().data()); }
/** * New RM * * 4. generate RM * * * ./src/ptsc -i -c tests/data/Fedora12/ptscd.conf * * Return * PTS_SUCCESS * PTS_INTERNAL_ERROR */ int newrm(OPENPTS_CONFIG *conf, int prop_count, OPENPTS_PROPERTY *prop_start, OPENPTS_PROPERTY *prop_end) { int rc = PTS_SUCCESS; OPENPTS_CONTEXT *ctx; int i; OPENPTS_PROPERTY *prop; /* ctx for init */ ctx = newPtsContext(conf); if (ctx == NULL) { LOG(LOG_ERR, "newPtsContext() fail. no memory?"); return PTS_FATAL; } #if 1 /* copy properties */ prop = prop_start; for (i = 0; i < prop_count; i++) { if (prop == NULL) { LOG(LOG_ERR, "prop == NULL"); rc = PTS_FATAL; goto free; } addProperty(ctx, prop->name, prop->value); prop = prop->next; } #else /* add property */ if (prop_count > 0) { ctx->prop_start = prop_start; ctx->prop_end = prop_end; ctx->prop_count = prop_count; } #endif addPropertiesFromConfig(conf, ctx); /* read FSM */ rc = readFsmFromPropFile(ctx, conf->config_file); if (rc != PTS_SUCCESS) { ERROR(NLS(MS_OPENPTS, OPENPTS_COLLECTOR_FAILED_READ_FSM, "Failed to read the FSM file.\n")); rc = PTS_FATAL; goto free; } /* UUID for RM */ if (conf->rm_uuid == NULL) { LOG(LOG_ERR, "conf->rm_uuid == NULL"); } else if (conf->rm_uuid->status == OPENPTS_UUID_FILENAME_ONLY) { rc = genOpenptsUuid(conf->rm_uuid); if (rc != PTS_SUCCESS) { LOG(LOG_ERR, "genOpenptsUuid() fail\n"); rc = PTS_FATAL; goto free; } } else { DEBUG("init() - use given RM UUID %s\n", conf->rm_uuid->str); } /* save/update rm_uuid file */ rc = writeOpenptsUuidFile(conf->rm_uuid, 1); // TODO overwite? if (rc != PTS_SUCCESS) { LOG(LOG_ERR, "writeOpenptsUuidFile() fail\n"); rc = PTS_FATAL; goto free; } /* RM set DIR */ rc = makeRmSetDir(conf); if (rc != PTS_SUCCESS) { ERROR(NLS(MS_OPENPTS, OPENPTS_COLLECTOR_MKDIR_RM_SET_FAILED, "Failed to create the reference manifest set directory\n")); rc = PTS_FATAL; goto free; } /* print rm uuid */ OUTPUT(NLS(MS_OPENPTS, OPENPTS_NEW_RM_UUID, "Generate UUID (for RM): %s \n"), conf->rm_uuid->str); /* read IML to fill the BIOS binary measurement, and translate BHV->BIN FSM */ /* load current IML using FSMs */ if (conf->iml_mode == 0) { // TODO use def #ifdef CONFIG_NO_TSS LOG(LOG_ERR, "Build with --without-tss. iml.mode=tss is not supported\n"); #else rc = getIml(ctx, 0); rc = getPcr(ctx); #endif } else if (conf->iml_mode == 1) { // TODO change to generic name? conf->iml_filename[0] conf->iml_filename[1] /* from securityfs */ /* BIOS IML */ rc = readBiosImlFile( ctx, conf->bios_iml_filename, conf->iml_endian); if (rc != PTS_SUCCESS) { DEBUG("getBiosImlFile() was failed\n"); LOG(LOG_ERR, "Oops! Something is wrong. Please see the reason below\n"); printReason(ctx, 0); rc = PTS_FATAL; goto free; } /* RUNTIME IML (Linux-IMA) */ if (ctx->conf->runtime_iml_filename != NULL) { int count; rc = readImaImlFile( ctx, conf->runtime_iml_filename, conf->runtime_iml_type, 0, &count); // TODO endian? if (rc != PTS_SUCCESS) { LOG(LOG_ERR, "read IMA IML, %s was failed\n", conf->runtime_iml_filename); rc = PTS_FATAL; goto free; } } } else { LOG(LOG_ERR, "unknown IML mode, %d\n", conf->iml_mode); } /* get SMBIOS data */ // TODO /* create Reference Manifest */ for (i = 0; i < conf->rm_num; i++) { if (conf->rm_filename[i] != NULL) { rc = writeRm(ctx, conf->rm_filename[i], i); if (rc != PTS_SUCCESS) { LOG(LOG_ERR, "write RM, %s was failed\n", conf->rm_filename[i]); rc = PTS_FATAL; goto free; } OUTPUT(NLS(MS_OPENPTS, OPENPTS_NEW_RM_RM, "level %d Reference Manifest: %s\n"), i, conf->rm_filename[i]); } else { LOG(LOG_ERR, "missing RM file for level %d\n", i); // continue } } free: /* free */ freePtsContext(ctx); if ( rc == PTS_FATAL ) { OUTPUT(NLS(MS_OPENPTS, OPENPTS_NEW_RM_FAILED, "Failed to generate Reference Manifest. See log for details.\n")); } return rc; }
/** * * Selftest * - Find right RM for this boot * * Check RM set by rm_uuid file * OK-> OPENPTS_SELFTEST_SUCCESS * NG -> next * Check RM set by newrm_uuid file * OK -> OPENPTS_SELFTEST_RENEWED * NG -> next * Check RM set by oldrm_uuid file * OK -> OPENPTS_SELFTEST_FALLBACK * NG -> OPENPTS_SELFTEST_FAILED * * * Return * OPENPTS_SELFTEST_SUCCESS stable:-) * OPENPTS_SELFTEST_RENEWED update/reboot -> success * OPENPTS_SELFTEST_FALLBACK * OPENPTS_SELFTEST_FAILED * PTS_FATAL something wrong:-( */ int selftest(OPENPTS_CONFIG *conf, int prop_count, OPENPTS_PROPERTY *prop_start, OPENPTS_PROPERTY *prop_end) { int rc = PTS_INTERNAL_ERROR; int result; OPENPTS_CONTEXT *ctx; int i; OPENPTS_PROPERTY *prop; char * ir_filename; DEBUG_CAL("selftest() start\n"); /* Step 1 - Generate IR --------------------------------------------------*/ /* new CTX for generation */ ctx = newPtsContext(conf); if (ctx == NULL) { LOG(LOG_ERR, "newPtsContext() fail. no memory?"); return PTS_FATAL; } /* copy properties */ prop = prop_start; for (i = 0; i < prop_count; i++) { if (prop == NULL) { LOG(LOG_ERR, "prop == NULL"); rc = PTS_FATAL; goto free; } addProperty(ctx, prop->name, prop->value); prop = prop->next; } /* additional properties from the pts config file */ addPropertiesFromConfig(conf, ctx); /* set dummy nonce for IR gen */ ctx->nonce->nonce_length = 20; ctx->nonce->nonce = xmalloc_assert(20); if (ctx->nonce->nonce == NULL) { LOG(LOG_ERR, "no memory"); rc = PTS_FATAL; goto free; } memset(ctx->nonce->nonce, 0x5A, 20); /* set dummy target uuid */ ctx->str_uuid = smalloc("SELFTEST"); if (ctx->str_uuid == NULL) { LOG(LOG_ERR, "no memory"); rc = PTS_FATAL; goto free; } /* gen IR */ rc = genIr(ctx, NULL); if (rc != PTS_SUCCESS) { LOG(LOG_ERR, "selftest() - genIR failed\n"); rc = PTS_FATAL; goto free; } /* hold the IR filename */ ir_filename = ctx->ir_filename; ctx->ir_filename = NULL; /* free CTX */ freePtsContext(ctx); ctx = NULL; DEBUG("selftest() - generate IR - done (ir file = %s)\n", ir_filename); /* Step 2 - Validate IR --------------------------------------------------*/ /* Keep conf but reset some flags in conf */ #ifdef CONFIG_AUTO_RM_UPDATE /* clear ARU */ conf->update_exist = 0; #endif /* new CTX for validation */ ctx = newPtsContext(conf); if (ctx == NULL) { LOG(LOG_ERR, "newPtsContext() fail. no memory?"); return PTS_FATAL; } /* set generated IR */ ctx->ir_filename = ir_filename; /* setup RMs */ rc = getRmSetDir(conf); if (rc != PTS_SUCCESS) { LOG(LOG_ERR, "selftest() - getRmSetDir() failed\n"); LOG(LOG_TODO, "conf->rm_uuid->filename %s\n", conf->rm_uuid->filename); LOG(LOG_TODO, "conf->rm_uuid->str %s\n", conf->rm_uuid->str); rc = PTS_FATAL; goto free; } /* load RMs */ for (i = 0; i < conf->rm_num; i++) { rc = readRmFile(ctx, conf->rm_filename[i], i); if (rc < 0) { LOG(LOG_ERR, "readRmFile fail\n"); rc = PTS_FATAL; goto free; } } /* verify */ DEBUG("selftest() - validate IR - start\n"); // TODO 2011-01-21 SM just use same conf ctx->target_conf = ctx->conf; // Disable Quote // 2011-01-28 SM, If FSM did not covers all PCRs Quote validation will fail? // iml_mode = ctx->conf->iml_mode; // ir_without_quote = ctx->conf->ir_without_quote; // ctx->conf->iml_mode = 1; // ctx->conf->ir_without_quote = 1; result = validateIr(ctx); /* ir.c */ /* check RM integrity status */ DEBUG("selftest() - validate IR - done (rc = %d)\n", result); if ((result != OPENPTS_RESULT_VALID) && (getVerbosity() > 0)) { ERROR(NLS(MS_OPENPTS, OPENPTS_COLLECTOR_SELFTEST_FAILED_4, "The self test has failed")); printReason(ctx, 0); } if (result != OPENPTS_RESULT_VALID) { addReason(ctx, -1, NLS(MS_OPENPTS, OPENPTS_COLLECTOR_SELFTEST_FAILED, "[SELFTEST] The self test failed")); if ((conf->newrm_uuid != NULL) && (conf->newrm_uuid->uuid != NULL)) { /* New RM exist (for reboot after the update), Try the new RM */ /* chenge the UUID */ // TODO add exchange func conf->rm_uuid->uuid = conf->newrm_uuid->uuid; conf->rm_uuid->str = conf->newrm_uuid->str; conf->rm_uuid->time = conf->newrm_uuid->time; // del newrm conf->newrm_uuid->uuid = NULL; conf->newrm_uuid->str = NULL; conf->newrm_uuid->time = NULL; // TODO free /* try selftest again */ DEBUG("selftest again UUID=%s\n", conf->rm_uuid->str); rc = selftest(conf, prop_count, prop_start, prop_end); if (rc == OPENPTS_SELFTEST_SUCCESS) { /* Update the RM UUID by NEWRM_UUID */ DEBUG("use UUID=%s\n", conf->rm_uuid->str); /* update rm_uuid */ rc = writeOpenptsUuidFile(conf->rm_uuid, 1); if (rc != PTS_SUCCESS) { LOG(LOG_ERR, "writeOpenptsUuidFile fail\n"); rc = PTS_FATAL; goto free; } /* delete newrm_uuid */ rc = remove(conf->newrm_uuid->filename); if (rc != 0) { LOG(LOG_ERR, "remove(%s) fail\n", conf->newrm_uuid->filename); rc = PTS_FATAL; goto free; } rc = OPENPTS_SELFTEST_RENEWED; } else { /* fail */ LOG(LOG_ERR, "2nd selftest with NEWRM also fail\n"); addReason(ctx, -1, NLS(MS_OPENPTS, OPENPTS_COLLECTOR_SELFTEST_FAILED_2, "[SELFTEST] The self test using both current and new UUIDs has failed")); printReason(ctx, 0); rc = OPENPTS_SELFTEST_FAILED; } } else { /* Missing NEWRM */ printReason(ctx, 0); rc = OPENPTS_SELFTEST_FAILED; } } else { /* valid :-) */ rc = OPENPTS_SELFTEST_SUCCESS; } /* leaving lots of temp 100K+ files lying around quickly fills up certain filesystems, i.e. on AIX /tmp is typically small, so we unlink them after use */ if (NULL != conf->ir_filename) { unlink(conf->ir_filename); } free: /* free */ freePtsContext(ctx); if (rc == PTS_FATAL) { ERROR(NLS(MS_OPENPTS, OPENPTS_COLLECTOR_SELFTEST_FAILED_3, "The self test has failed. See log for details.")); } return rc; }
/** * initialize ptsc * * 1. generate UUID * 2. generate Sign Key (NA) * 3. get platform information, call dmidecode or BIOS IML? (NA) * 4. generate RM * * * ./src/ptsc -i -c tests/data/Fedora12/ptscd.conf * * Return * PTS_SUCCESS * OPENPTS_IML_MISSING * PTS_FATAL */ int init( OPENPTS_CONFIG *conf, int prop_count, OPENPTS_PROPERTY *prop_start, OPENPTS_PROPERTY *prop_end) { int rc = PTS_SUCCESS; OPENPTS_CONTEXT *ctx = NULL; int i; int keygen = 1; TSS_VERSION tpm_version; /* check */ if (conf == NULL) { LOG(LOG_ERR, "FATAL"); return PTS_FATAL; } if (conf->uuid == NULL) { LOG(LOG_ERR, "FATAL"); return PTS_FATAL; } if (conf->uuid->filename == NULL) { LOG(LOG_ERR, "FATAL"); return PTS_FATAL; } /* * Common misconfigulations * * 1) cannot access the IML through TSS. * default /etc/tcsd.conf does not configured to access the IML file at * securityfs. * => ERROR : OPENPTS_MISSING_IML * * 2) TPM not taken ownership. * in this case, Keygen was failed * 3) Missing TCS Daemon * So ptsc can not access TPM/TSS, may got tspi 0x0311 error. * 4) /etc/ptsc.conf did not configured for this platform yet * missing PCR - Model convination */ /* Check the existing configulation */ rc = checkFile(conf->uuid->filename); if (rc == OPENPTS_FILE_EXISTS) { char *str_uuid; PTS_DateTime *time; /* if UUID file exist => exit, admin must delete the UUID file, then init again */ /* check existing UUID */ rc = readOpenptsUuidFile(conf->uuid); str_uuid = getStringOfUuid(conf->uuid->uuid); time = getDateTimeOfUuid(conf->uuid->uuid); OUTPUT(NLS(MS_OPENPTS, OPENPTS_COLLECTOR_UUID_FILE_EXISTS, "The ptsc has been initialized. " "If you want to re-intialize the platform, please clear the collector. " "To see the detail of current ptsc, use ptsc -D. " "To clear the ptsc, use ptsc -e\n")); OUTPUT(" existing uuid = %s\n", str_uuid); OUTPUT(" creation date = %d-%d-%d\n", time->year + 1900, time->mon + 1, time->mday); /* free */ xfree(str_uuid); xfree(time); return PTS_FATAL; // TODO assign error code } /* ctx for init */ ctx = newPtsContext(conf); if (ctx == NULL) { LOG(LOG_ERR, "no memory?"); return PTS_FATAL; } /* add property */ if (prop_count > 0) { ctx->prop_start = prop_start; ctx->prop_end = prop_end; ctx->prop_count = prop_count; } addPropertiesFromConfig(conf, ctx); /* get TPM and TSS version */ rc = getTpmVersion(&tpm_version); if (rc != PTS_SUCCESS) { addReason(ctx, -1, "[PTSC-INIT] Couldn't get the TPM version. Check the TSS and TPM driver."); rc = PTS_FATAL; goto error; } /* read FSM */ rc = readFsmFromPropFile(ctx, conf->config_file); if (rc != PTS_SUCCESS) { addReason(ctx, -1, "[PTSC-INIT] Couldn't load validation models. Check the ptsc configlation, %s.", conf->config_file); rc = PTS_FATAL; goto error; } /* read IML to fill the BIOS binary measurement, and translate BHV->BIN FSM */ /* load current IML using FSMs */ if (conf->iml_mode == 0) { // TODO use def rc = getIml(ctx, 0); // iml.c, return event num if (rc == 0) { addReason(ctx, -1, "[PTSC-INIT] Couldn't access IML through TSS. " "Check the TSS configuration /etc/tcsd.conf"); rc = OPENPTS_IML_MISSING; goto error; } rc = getPcr(ctx); // iml.c, return pcr num if (rc == 0) { addReason(ctx, -1, "[PTSC-INIT] Couldn't get the PCR value"); rc = PTS_FATAL; goto error; } } else if (conf->iml_mode == 1) { // TODO change to generic name? conf->iml_filename[0] conf->iml_filename[1] /* from securityfs */ /* BIOS IML */ rc = readBiosImlFile( ctx, conf->bios_iml_filename, conf->iml_endian); if (rc != PTS_SUCCESS) { addReason(ctx, -1, "[PTSC-INIT] Couldn't read the IML file, %s. Check the ptsc configuration, %s.", conf->bios_iml_filename, conf->config_file); rc = PTS_FATAL; goto error; } /* RUNTIME IML (Linux-IMA) */ if (ctx->conf->runtime_iml_filename != NULL) { int count; rc = readImaImlFile( ctx, conf->runtime_iml_filename, conf->runtime_iml_type, 0, &count); // TODO endian? if (rc != PTS_SUCCESS) { addReason(ctx, -1, "[PTSC-INIT] Couldn't read IML file, %s. Check the ptsc configuration, %s.", conf->runtime_iml_filename, conf->config_file); rc = PTS_FATAL; goto error; } } } else { addReason(ctx, -1, "[PTSC-INIT] Unknown IML mode, %d, Check the ptsc configuration (iml.mode), %s .", conf->iml_mode, conf->config_file); rc = PTS_FATAL; goto error; } /* config dir, /var/lib/openpts */ if (conf->config_dir == NULL) { addReason(ctx, -1, NLS(MS_OPENPTS, OPENPTS_COLLECTOR_MISSING_CONFIG_DIR, "[PTSC-INIT] Configuration directory is not defined. Check the ptsc configuration file, %s"), conf->config_file); rc = PTS_FATAL; goto error; } else { /* check */ rc = checkDir(conf->config_dir); if (rc == PTS_SUCCESS) { /* OK */ } else { /* Missing */ struct group *ptsc_grp; VERBOSE(1, NLS(MS_OPENPTS, OPENPTS_COLLECTOR_NEW_CONFIG_DIR, "Creating new configuration directory '%s'\n"), conf->config_dir); makeDir(conf->config_dir); // TODO Consider using getgrnam_r(...) if ((ptsc_grp = getgrnam(PTSC_GROUP_NAME)) != NULL) { if (-1 == chown(conf->config_dir, 0, ptsc_grp->gr_gid)) { addReason(ctx, -1, NLS(MS_OPENPTS, OPENPTS_COLLECTOR_CHANGE_OWNSHIP_FAIL, "[PTSC-INIT] Could not change ownership of %s to " PTSC_GROUP_NAME "\n"), conf->config_dir); rc = PTS_FATAL; goto error; } if (-1 == chmod(conf->config_dir, S_IRUSR | S_IWUSR | S_IXUSR | S_IRGRP | S_IXGRP)) { addReason(ctx, -1, NLS(MS_OPENPTS, OPENPTS_COLLECTOR_CHANGE_MODE_FAIL, "[PTSC-INIT] Could not change file mode of %s (rwxr-w---)\n"), conf->config_dir); rc = PTS_FATAL; goto error; } } else { addReason(ctx, -1, NLS(MS_OPENPTS, OPENPTS_COLLECTOR_FIND_GROUP_FAIL, "[PTSC-INIT] Failed to look up group '%s'\n"), PTSC_GROUP_NAME); rc = PTS_FATAL; goto error; } } } /* Generate UUID of this platform */ if (conf->uuid == NULL) { LOG(LOG_ERR, "conf->uuid == NULL"); addReason(ctx, -1, NLS(MS_OPENPTS, OPENPTS_COLLECTOR_BAD_CONFIG_FILE, "[PTSC-INIT] Bad configuration file, %s. Check 'uuid.file' option"), conf->config_file); rc = PTS_FATAL; goto error; } else if (conf->uuid->status == OPENPTS_UUID_FILENAME_ONLY) { /* gen new UUID */ rc = genOpenptsUuid(conf->uuid); if (rc != PTS_SUCCESS) { LOG(LOG_ERR, "genOpenptsUuid() fail"); addReason(ctx, -1, "[PTSC-INIT] Generation of UUID was failed"); rc = PTS_FATAL; goto error; } } else { DEBUG("init() - use given UUID %s (for TEST)\n", conf->uuid->str); keygen = 0; } /* Create TPM Sign Key */ // TODO we use single sign key for all verifiers // it depends on the onwer of key, now ptscd is the owner of sign key. // if verifier take the ownership of sign key, we needs the key for each verifier. // auth can be transferd by IF-M (DH excnage) if (keygen == 1) { rc = createTssSignKey( conf->uuid->uuid, conf->aik_storage_type, conf->aik_storage_filename, conf->aik_auth_type, 0, conf->srk_password_mode); if (rc == 0x0001) { // 0x0001 DEBUG("createTssSignKey() failed"); addReason(ctx, -1, NLS(MS_OPENPTS, OPENPTS_COLLECTOR_SIGN_KEY_FAIL, "[PTSC-INIT] Failed to create the signed key. " "If you are using the well known SRK secret key (all zeroes) " "then please try again with the '-z' option\n")); rc = PTS_FATAL; goto error; } else if (rc != PTS_SUCCESS) { DEBUG("createTssSignKey() failed"); addReason(ctx, -1, "[PTSC-INIT] Could not create the Key (rc = 0x%x).", rc); rc = PTS_FATAL; goto error; } OUTPUT(NLS(MS_OPENPTS, OPENPTS_INIT_PTSCD, "Sign key location: SYSTEM\n")); } else { DEBUG("init() - skip key gen for the given UUID\n"); } /* print uuid */ OUTPUT(NLS(MS_OPENPTS, OPENPTS_INIT_GEN_UUID, "Generate uuid: %s \n"), conf->uuid->str); /* UUID for RM */ if (conf->rm_uuid == NULL) { // init/set by readPtsConf LOG(LOG_ERR, "conf->rm_uuid == NULL\n"); addReason(ctx, -1, "[PTSC-INIT] RM_UUID file is not defined (rm.uuid.file) in the ptsc configulation, %s", conf->config_file); rc = PTS_FATAL; goto error; } else if (conf->rm_uuid->status == OPENPTS_UUID_FILENAME_ONLY) { rc = genOpenptsUuid(conf->rm_uuid); if (rc != PTS_SUCCESS) { addReason(ctx, -1, "[PTSC-INIT] Generation of RM UUID was failed"); rc = PTS_FATAL; goto error; } } else { DEBUG("init() - use given RM UUID %s\n", conf->rm_uuid->str); } /* RM set DIR */ rc = makeRmSetDir(conf); if (rc != PTS_SUCCESS) { addReason(ctx, -1, "[PTSC-INIT] Couldn't create Reference Maniferst directory"); rc = PTS_FATAL; goto error; } /* print rm uuid */ OUTPUT(NLS(MS_OPENPTS, OPENPTS_INIT_GEN_RM_UUID, "Generate UUID (for RM): %s \n"), conf->rm_uuid->str); /* get SMBIOS data */ // TODO Platform information - TBD // Use ptsc.conf to set the platform info, malually /* create Reference Manifest */ for (i = 0; i < conf->rm_num; i++) { if (conf->rm_filename[i] != NULL) { rc = writeRm(ctx, conf->rm_filename[i], i); if (rc != PTS_SUCCESS) { LOG(LOG_ERR, "ERROR, initialization was failed\n"); // WORK NEEDED: Reason need putting in NLS addReason(ctx, -1, "[PTSC-INIT] Couldn't create the manifest file, %s", conf->rm_filename[i]); rc = PTS_FATAL; goto error; } OUTPUT(NLS(MS_OPENPTS, OPENPTS_INIT_RM, "level %d Reference Manifest : %s\n"), i, conf->rm_filename[i]); } else { addReason(ctx, -1, NLS(MS_OPENPTS, OPENPTS_COLLECTOR_MISSING_RM_FILE, "[PTSC-INIT] Missing reference manifest file for level %d\n"), i); rc = PTS_FATAL; goto error; } } /* Finaly wrote the UUID files */ /* Write UUID file */ rc = writeOpenptsUuidFile(conf->uuid, 0); if (rc != PTS_SUCCESS) { /* internal error */ addReason(ctx, -1, "[PTSC-INIT] Couldn't write the uuid file, '%s'.\n", conf->uuid->filename); rc = PTS_FATAL; goto error; } /* save to rm_uuid file */ rc = writeOpenptsUuidFile(conf->rm_uuid, 0); if (rc != PTS_SUCCESS) { addReason(ctx, -1, "[PTSC-INIT] Couldn't write the UUID file, %s", conf->rm_uuid->filename); rc = PTS_FATAL; goto error; } LOG(LOG_INFO, "ptsc has successfully initialized!\n"); OUTPUT(NLS(MS_OPENPTS, OPENPTS_INIT_SUCCESS, "\nptsc has successfully initialized!\n\n")); goto free; error: /* initialization was faild */ LOG(LOG_INFO, "ptsc initialization was failed\n"); ERROR(NLS(MS_OPENPTS, OPENPTS_INIT_FAIL, "ptsc initialization was failed\n\n")); printReason(ctx, 0); free: /* free */ if (ctx != NULL) freePtsContext(ctx); return rc; }