/* Must be called after cmdline parsed */ static void _init_bmc_watchdog (void) { unsigned int workaround_flags = 0; unsigned int flags = 0; if (!ipmi_is_root ()) err_exit ("Permission denied, must be root."); parse_get_freeipmi_inband_flags (cmd_args.common_args.workaround_flags_inband, &workaround_flags); flags = IPMI_FLAGS_NONBLOCKING; if (cmd_args.common_args.debug) flags |= IPMI_FLAGS_DEBUG_DUMP; if (!(ipmi_ctx = ipmi_ctx_create ())) err_exit ("ipmi_ctx_create: %s", strerror (errno)); if (cmd_args.common_args.driver_type == IPMI_DEVICE_UNKNOWN) { int ret; if ((ret = ipmi_ctx_find_inband (ipmi_ctx, NULL, cmd_args.common_args.disable_auto_probe, cmd_args.common_args.driver_address, cmd_args.common_args.register_spacing, cmd_args.common_args.driver_device, workaround_flags, flags)) < 0) err_exit ("ipmi_ctx_find_inband: %s", ipmi_ctx_errormsg (ipmi_ctx)); if (!ret) err_exit ("could not find inband device"); } else { if (ipmi_ctx_open_inband (ipmi_ctx, cmd_args.common_args.driver_type, cmd_args.common_args.disable_auto_probe, cmd_args.common_args.driver_address, cmd_args.common_args.register_spacing, cmd_args.common_args.driver_device, workaround_flags, flags) < 0) err_exit ("ipmi_ctx_open_inband: %s", ipmi_ctx_errormsg (ipmi_ctx)); } }
/* * _init_ipmi_config initializes parameters for freeipmi library */ static int _init_ipmi_config (void) { int ret = 0; unsigned int workaround_flags_mask = (IPMI_WORKAROUND_FLAGS_INBAND_ASSUME_IO_BASE_ADDRESS | IPMI_WORKAROUND_FLAGS_INBAND_SPIN_POLL); if (ipmi_ctx) { debug("ipmi_ctx already initialized\n"); return SLURM_SUCCESS; } if (!(ipmi_ctx = ipmi_ctx_create())) { error("ipmi_ctx_create: %s\n", strerror(errno)); goto cleanup; } if (getuid() != 0) { error ("%s: error : must be root to open ipmi devices\n", __func__); goto cleanup; } /* XCC OEM commands always require to use in-band communication */ if (((slurm_ipmi_conf.driver_type > 0) && (slurm_ipmi_conf.driver_type != NO_VAL) && (slurm_ipmi_conf.driver_type != IPMI_DEVICE_KCS) && (slurm_ipmi_conf.driver_type != IPMI_DEVICE_SSIF) && (slurm_ipmi_conf.driver_type != IPMI_DEVICE_OPENIPMI) && (slurm_ipmi_conf.driver_type != IPMI_DEVICE_SUNBMC)) || (slurm_ipmi_conf.workaround_flags & ~workaround_flags_mask)) { /* IPMI ERROR PARAMETERS */ error ("%s: error: XCC Lenovo plugin only supports in-band communication, incorrect driver type or workaround flags", __func__); debug("slurm_ipmi_conf.driver_type=%u slurm_ipmi_conf.workaround_flags=%u", slurm_ipmi_conf.driver_type, slurm_ipmi_conf.workaround_flags); goto cleanup; } if (slurm_ipmi_conf.driver_type == NO_VAL) { if ((ret = ipmi_ctx_find_inband( ipmi_ctx, NULL, slurm_ipmi_conf.disable_auto_probe, slurm_ipmi_conf.driver_address, slurm_ipmi_conf.register_spacing, slurm_ipmi_conf.driver_device, slurm_ipmi_conf.workaround_flags, slurm_ipmi_conf.ipmi_flags)) <= 0) { error("%s: error on ipmi_ctx_find_inband: %s", __func__, ipmi_ctx_errormsg(ipmi_ctx)); debug("slurm_ipmi_conf.driver_type=%u\n" "slurm_ipmi_conf.disable_auto_probe=%u\n" "slurm_ipmi_conf.driver_address=%u\n" "slurm_ipmi_conf.register_spacing=%u\n" "slurm_ipmi_conf.driver_device=%s\n" "slurm_ipmi_conf.workaround_flags=%u\n" "slurm_ipmi_conf.ipmi_flags=%u", slurm_ipmi_conf.driver_type, slurm_ipmi_conf.disable_auto_probe, slurm_ipmi_conf.driver_address, slurm_ipmi_conf.register_spacing, slurm_ipmi_conf.driver_device, slurm_ipmi_conf.workaround_flags, slurm_ipmi_conf.ipmi_flags); goto cleanup; } } else { if ((ipmi_ctx_open_inband(ipmi_ctx, slurm_ipmi_conf.driver_type, slurm_ipmi_conf.disable_auto_probe, slurm_ipmi_conf.driver_address, slurm_ipmi_conf.register_spacing, slurm_ipmi_conf.driver_device, slurm_ipmi_conf.workaround_flags, slurm_ipmi_conf.ipmi_flags) < 0)) { error ("%s: error on ipmi_ctx_open_inband: %s", __func__, ipmi_ctx_errormsg (ipmi_ctx)); debug("slurm_ipmi_conf.driver_type=%u\n" "slurm_ipmi_conf.disable_auto_probe=%u\n" "slurm_ipmi_conf.driver_address=%u\n" "slurm_ipmi_conf.register_spacing=%u\n" "slurm_ipmi_conf.driver_device=%s\n" "slurm_ipmi_conf.workaround_flags=%u\n" "slurm_ipmi_conf.ipmi_flags=%u", slurm_ipmi_conf.driver_type, slurm_ipmi_conf.disable_auto_probe, slurm_ipmi_conf.driver_address, slurm_ipmi_conf.register_spacing, slurm_ipmi_conf.driver_device, slurm_ipmi_conf.workaround_flags, slurm_ipmi_conf.ipmi_flags); goto cleanup; } } if (slurm_ipmi_conf.target_channel_number_is_set || slurm_ipmi_conf.target_slave_address_is_set) { if (ipmi_ctx_set_target( ipmi_ctx, slurm_ipmi_conf.target_channel_number_is_set ? &slurm_ipmi_conf.target_channel_number : NULL, slurm_ipmi_conf.target_slave_address_is_set ? &slurm_ipmi_conf.target_slave_address : NULL) < 0) { error ("%s: error on ipmi_ctx_set_target: %s", __func__, ipmi_ctx_errormsg (ipmi_ctx)); goto cleanup; } } return SLURM_SUCCESS; cleanup: ipmi_ctx_close(ipmi_ctx); ipmi_ctx_destroy(ipmi_ctx); return SLURM_ERROR; }
static int ipmi_free_open(struct ipmi_intf * intf) { if (getuid() != 0) { fprintf(stderr, "Permission denied, must be root\n"); return -1; } #if IPMI_INTF_FREE_0_3_0 if (!(dev = ipmi_open_inband (IPMI_DEVICE_KCS, 0, 0, 0, NULL, IPMI_FLAGS_DEFAULT))) { if (!(dev = ipmi_open_inband (IPMI_DEVICE_SSIF, 0, 0, 0, NULL, IPMI_FLAGS_DEFAULT))) { perror("ipmi_open_inband()"); goto cleanup; } } #elif IPMI_INTF_FREE_0_4_0 if (!(dev = ipmi_device_create())) { perror("ipmi_device_create"); goto cleanup; } if (ipmi_open_inband (dev, IPMI_DEVICE_KCS, 0, 0, 0, NULL, IPMI_FLAGS_DEFAULT) < 0) { if (ipmi_open_inband (dev, IPMI_DEVICE_SSIF, 0, 0, 0, NULL, IPMI_FLAGS_DEFAULT) < 0) { fprintf(stderr, "ipmi_open_inband(): %s\n", ipmi_device_strerror(ipmi_device_errnum(dev))); goto cleanup; } } #elif IPMI_INTF_FREE_0_5_0 if (!(dev = ipmi_device_create())) { perror("ipmi_device_create"); goto cleanup; } if (ipmi_open_inband (dev, IPMI_DEVICE_KCS, 0, 0, 0, NULL, 0, IPMI_FLAGS_DEFAULT) < 0) { if (ipmi_open_inband (dev, IPMI_DEVICE_SSIF, 0, 0, 0, NULL, 0, IPMI_FLAGS_DEFAULT) < 0) { fprintf(stderr, "ipmi_open_inband(): %s\n", ipmi_device_strerror(ipmi_device_errnum(dev))); goto cleanup; } } #elif IPMI_INTF_FREE_0_6_0 if (!(dev = ipmi_ctx_create())) { perror("ipmi_ctx_create"); goto cleanup; } if (ipmi_ctx_open_inband (dev, IPMI_DEVICE_KCS, 0, 0, 0, NULL, 0, IPMI_FLAGS_DEFAULT) < 0) { if (ipmi_ctx_open_inband (dev, IPMI_DEVICE_SSIF, 0, 0, 0, NULL, 0, IPMI_FLAGS_DEFAULT) < 0) { fprintf(stderr, "ipmi_open_inband(): %s\n", ipmi_ctx_strerror(ipmi_ctx_errnum(dev))); goto cleanup; } } #endif intf->opened = 1; return 0; cleanup: if (dev) { #if IPMI_INTF_FREE_0_3_0 ipmi_close_device(dev); #elif IPMI_INTF_FREE_0_4_0 || IPMI_INTF_FREE_0_5_0 ipmi_close_device(dev); ipmi_device_destroy(dev); #elif IPMI_INTF_FREE_0_6_0 ipmi_ctx_close(dev); ipmi_ctx_destroy(dev); #endif } return -1; }
ipmi_ctx_t ipmi_open (const char *progname, const char *hostname, struct common_cmd_args *common_args, pstdout_state_t pstate) { ipmi_ctx_t ipmi_ctx = NULL; unsigned int workaround_flags = 0; assert (progname); assert (common_args); if (!(ipmi_ctx = ipmi_ctx_create ())) { PSTDOUT_FPRINTF (pstate, stderr, "ipmi_ctx_create: %s", strerror (errno)); goto cleanup; } if (hostname && strcasecmp (hostname, "localhost") != 0 && strcmp (hostname, "127.0.0.1") != 0) { if (common_args->driver_type == IPMI_DEVICE_LAN_2_0) { parse_get_freeipmi_outofband_2_0_flags (common_args->workaround_flags_outofband_2_0, &workaround_flags); if (ipmi_ctx_open_outofband_2_0 (ipmi_ctx, hostname, common_args->username, common_args->password, (common_args->k_g_len) ? common_args->k_g : NULL, (common_args->k_g_len) ? common_args->k_g_len : 0, common_args->privilege_level, common_args->cipher_suite_id, common_args->session_timeout, common_args->retransmission_timeout, workaround_flags, (common_args->debug) ? IPMI_FLAGS_DEBUG_DUMP : IPMI_FLAGS_DEFAULT) < 0) { if (ipmi_ctx_errnum (ipmi_ctx) == IPMI_ERR_USERNAME_INVALID || ipmi_ctx_errnum (ipmi_ctx) == IPMI_ERR_PASSWORD_INVALID || ipmi_ctx_errnum (ipmi_ctx) == IPMI_ERR_K_G_INVALID || ipmi_ctx_errnum (ipmi_ctx) == IPMI_ERR_PRIVILEGE_LEVEL_INSUFFICIENT || ipmi_ctx_errnum (ipmi_ctx) == IPMI_ERR_PRIVILEGE_LEVEL_CANNOT_BE_OBTAINED || ipmi_ctx_errnum (ipmi_ctx) == IPMI_ERR_AUTHENTICATION_TYPE_UNAVAILABLE || ipmi_ctx_errnum (ipmi_ctx) == IPMI_ERR_CIPHER_SUITE_ID_UNAVAILABLE || ipmi_ctx_errnum (ipmi_ctx) == IPMI_ERR_PASSWORD_VERIFICATION_TIMEOUT || ipmi_ctx_errnum (ipmi_ctx) == IPMI_ERR_HOSTNAME_INVALID || ipmi_ctx_errnum (ipmi_ctx) == IPMI_ERR_IPMI_2_0_UNAVAILABLE || ipmi_ctx_errnum (ipmi_ctx) == IPMI_ERR_CONNECTION_TIMEOUT) PSTDOUT_FPRINTF (pstate, stderr, "%s: %s\n", progname, ipmi_ctx_errormsg (ipmi_ctx)); else PSTDOUT_FPRINTF (pstate, stderr, "ipmi_ctx_open_outofband_2_0: %s\n", ipmi_ctx_errormsg (ipmi_ctx)); goto cleanup; } } else { parse_get_freeipmi_outofband_flags (common_args->workaround_flags_outofband, &workaround_flags); if (ipmi_ctx_open_outofband (ipmi_ctx, hostname, common_args->username, common_args->password, common_args->authentication_type, common_args->privilege_level, common_args->session_timeout, common_args->retransmission_timeout, workaround_flags, (common_args->debug) ? IPMI_FLAGS_DEBUG_DUMP : IPMI_FLAGS_DEFAULT) < 0) { if (ipmi_ctx_errnum (ipmi_ctx) == IPMI_ERR_USERNAME_INVALID || ipmi_ctx_errnum (ipmi_ctx) == IPMI_ERR_PASSWORD_INVALID || ipmi_ctx_errnum (ipmi_ctx) == IPMI_ERR_PRIVILEGE_LEVEL_INSUFFICIENT || ipmi_ctx_errnum (ipmi_ctx) == IPMI_ERR_PRIVILEGE_LEVEL_CANNOT_BE_OBTAINED || ipmi_ctx_errnum (ipmi_ctx) == IPMI_ERR_AUTHENTICATION_TYPE_UNAVAILABLE || ipmi_ctx_errnum (ipmi_ctx) == IPMI_ERR_PASSWORD_VERIFICATION_TIMEOUT || ipmi_ctx_errnum (ipmi_ctx) == IPMI_ERR_HOSTNAME_INVALID || ipmi_ctx_errnum (ipmi_ctx) == IPMI_ERR_CONNECTION_TIMEOUT) PSTDOUT_FPRINTF (pstate, stderr, "%s: %s\n", progname, ipmi_ctx_errormsg (ipmi_ctx)); else PSTDOUT_FPRINTF (pstate, stderr, "ipmi_ctx_open_outofband: %s\n", ipmi_ctx_errormsg (ipmi_ctx)); goto cleanup; } } } else { if (!ipmi_is_root ()) { PSTDOUT_FPRINTF (pstate, stderr, "%s: %s\n", progname, ipmi_ctx_strerror (IPMI_ERR_PERMISSION)); goto cleanup; } parse_get_freeipmi_inband_flags (common_args->workaround_flags_inband, &workaround_flags); if (common_args->driver_type == IPMI_DEVICE_UNKNOWN) { int ret; if ((ret = ipmi_ctx_find_inband (ipmi_ctx, NULL, common_args->disable_auto_probe, common_args->driver_address, common_args->register_spacing, common_args->driver_device, workaround_flags, (common_args->debug) ? IPMI_FLAGS_DEBUG_DUMP : IPMI_FLAGS_DEFAULT)) < 0) { PSTDOUT_FPRINTF (pstate, stderr, "ipmi_ctx_find_inband: %s\n", ipmi_ctx_errormsg (ipmi_ctx)); goto cleanup; } if (!ret) { PSTDOUT_FPRINTF (pstate, stderr, "could not find inband device"); goto cleanup; } } else { if (ipmi_ctx_open_inband (ipmi_ctx, common_args->driver_type, common_args->disable_auto_probe, common_args->driver_address, common_args->register_spacing, common_args->driver_device, workaround_flags, (common_args->debug) ? IPMI_FLAGS_DEBUG_DUMP : IPMI_FLAGS_DEFAULT) < 0) { if (ipmi_ctx_errnum (ipmi_ctx) == IPMI_ERR_DEVICE_NOT_FOUND) PSTDOUT_FPRINTF (pstate, stderr, "%s: %s\n", progname, ipmi_ctx_errormsg (ipmi_ctx)); else PSTDOUT_FPRINTF (pstate, stderr, "ipmi_ctx_open_inband: %s\n", ipmi_ctx_errormsg (ipmi_ctx)); goto cleanup; } } } if (common_args->target_channel_number_is_set || common_args->target_slave_address_is_set) { if (ipmi_ctx_set_target (ipmi_ctx, common_args->target_channel_number_is_set ? &common_args->target_channel_number : NULL, common_args->target_slave_address_is_set ? &common_args->target_slave_address : NULL) < 0) { PSTDOUT_FPRINTF (pstate, stderr, "ipmi_ctx_set_target: %s\n", ipmi_ctx_errormsg (ipmi_ctx)); goto cleanup; } } return (ipmi_ctx); cleanup: ipmi_ctx_close (ipmi_ctx); ipmi_ctx_destroy (ipmi_ctx); return (NULL); }
int main(int argc, char *argv[]) { uint8_t threadid_main = 0; pthread_key_create(&threadid_key, NULL); pthread_setspecific(threadid_key, &threadid_main); mprintf("University of Wisconsin IPMI MicroTCA System Manager\n"); if (argc > 1 && strcmp(argv[1], "--version") == 0) { mprintf("\nCompiled from %s@%s\n", (GIT_BRANCH[0] ? GIT_BRANCH : "git-archive"), (GIT_COMMIT[0] ? GIT_COMMIT : "27868b9b800d107fbb53b68c2fce207144f97a98")); if (strlen(GIT_DIRTY) > 1) mprintf("%s", GIT_DIRTY); mprintf("\n"); return 0; } /* * Parse Configuration */ cfg_opt_t opts_auth[] = { CFG_STR_LIST(const_cast<char *>("raw"), const_cast<char *>("{}"), CFGF_NONE), CFG_STR_LIST(const_cast<char *>("manage"), const_cast<char *>("{}"), CFGF_NONE), CFG_STR_LIST(const_cast<char *>("read"), const_cast<char *>("{}"), CFGF_NONE), CFG_END() }; cfg_opt_t opts_crate[] = { CFG_STR(const_cast<char *>("host"), const_cast<char *>(""), CFGF_NONE), CFG_STR(const_cast<char *>("description"), const_cast<char *>(""), CFGF_NONE), CFG_STR(const_cast<char *>("username"), const_cast<char *>(""), CFGF_NONE), CFG_STR(const_cast<char *>("password"), const_cast<char *>(""), CFGF_NONE), CFG_INT_CB(const_cast<char *>("authtype"), 0, CFGF_NONE, cfg_parse_authtype), CFG_INT_CB(const_cast<char *>("mch"), 0, CFGF_NONE, cfg_parse_MCH), CFG_BOOL(const_cast<char *>("enabled"), cfg_true, CFGF_NONE), CFG_END() }; cfg_opt_t opts_cardmodule[] = { CFG_STR(const_cast<char *>("module"), const_cast<char *>(""), CFGF_NONE), CFG_STR_LIST(const_cast<char *>("config"), const_cast<char *>("{}"), CFGF_NONE), CFG_END() }; cfg_opt_t opts[] = { CFG_SEC(const_cast<char *>("authentication"), opts_auth, CFGF_NONE), CFG_SEC(const_cast<char *>("crate"), opts_crate, CFGF_MULTI), CFG_SEC(const_cast<char *>("cardmodule"), opts_cardmodule, CFGF_MULTI), CFG_INT(const_cast<char *>("socket_port"), 4681, CFGF_NONE), CFG_INT(const_cast<char *>("ratelimit_delay"), 0, CFGF_NONE), CFG_BOOL(const_cast<char *>("daemonize"), cfg_false, CFGF_NONE), CFG_END() }; cfg_t *cfg = cfg_init(opts, CFGF_NONE); cfg_set_validate_func(cfg, "crate|host", &cfg_validate_hostname); cfg_set_validate_func(cfg, "socket_port", &cfg_validate_port); if (argc >= 2 && access(argv[1], R_OK) == 0) { if(cfg_parse(cfg, argv[1]) == CFG_PARSE_ERROR) exit(1); } else if (access(CONFIG_PATH "/" CONFIG_FILE, R_OK) == 0) { if(cfg_parse(cfg, CONFIG_PATH "/" CONFIG_FILE) == CFG_PARSE_ERROR) exit(1); } else { printf("Config file %s not found, and no argument supplied.\n", CONFIG_PATH "/" CONFIG_FILE); printf("Try: %s sysmgr.conf\n", argv[0]); exit(1); } bool crate_found = false; bool crate_enabled = false; cfg_t *cfgauth = cfg_getsec(cfg, "authentication"); for(unsigned int i = 0; i < cfg_size(cfgauth, "raw"); i++) config_authdata.raw.push_back(std::string(cfg_getnstr(cfgauth, "raw", i))); for(unsigned int i = 0; i < cfg_size(cfgauth, "manage"); i++) config_authdata.manage.push_back(std::string(cfg_getnstr(cfgauth, "manage", i))); for(unsigned int i = 0; i < cfg_size(cfgauth, "read"); i++) config_authdata.read.push_back(std::string(cfg_getnstr(cfgauth, "read", i))); for(unsigned int i = 0; i < cfg_size(cfg, "crate"); i++) { cfg_t *cfgcrate = cfg_getnsec(cfg, "crate", i); crate_found = true; enum Crate::Mfgr MCH; switch (cfg_getint(cfgcrate, "mch")) { case Crate::VADATECH: MCH = Crate::VADATECH; break; case Crate::NAT: MCH = Crate::NAT; break; } const char *user = cfg_getstr(cfgcrate, "username"); const char *pass = cfg_getstr(cfgcrate, "password"); Crate *crate = new Crate(i+1, MCH, cfg_getstr(cfgcrate, "host"), (user[0] ? user : NULL), (pass[0] ? pass : NULL), cfg_getint(cfgcrate, "authtype"), cfg_getstr(cfgcrate, "description")); bool enabled = (cfg_getbool(cfgcrate, "enabled") == cfg_true); if (enabled) crate_enabled = true; threadlocal.push_back(threadlocaldata_t(crate, enabled)); } for(unsigned int i = 0; i < cfg_size(cfg, "cardmodule"); i++) { cfg_t *cfgmodule = cfg_getnsec(cfg, "cardmodule", i); const char *module = cfg_getstr(cfgmodule, "module"); std::vector<std::string> configdata; for(unsigned int i = 0; i < cfg_size(cfgmodule, "config"); i++) configdata.push_back(std::string(cfg_getnstr(cfgmodule, "config", i))); std::string default_module_path = DEFAULT_MODULE_PATH; if (getenv("SYSMGR_MODULE_PATH") != NULL) default_module_path = getenv("SYSMGR_MODULE_PATH"); std::string modulepath = module; if (modulepath.find("/") == std::string::npos) modulepath = default_module_path +"/"+ modulepath; cardmodule_t cm; cm.dl_addr = dlopen(modulepath.c_str(), RTLD_NOW|RTLD_GLOBAL); if (cm.dl_addr == NULL) { printf("Error loading module %s:\n\t%s\n", module, dlerror()); exit(2); } void *sym; #define LOAD_SYM(name, type) \ sym = dlsym(cm.dl_addr, #name); \ if (sym == NULL) { \ mprintf("Error loading module %s " type " " #name ":\n\t%s\n", module, dlerror()); \ exit(2); \ } LOAD_SYM(APIVER, "variable"); cm.APIVER = *reinterpret_cast<uint32_t*>(sym); LOAD_SYM(MIN_APIVER, "variable"); cm.MIN_APIVER = *reinterpret_cast<uint32_t*>(sym); if (cm.APIVER < 2 || cm.MIN_APIVER > 2) { mprintf("Error loading module %s: Incompatible API version %u\n", module, cm.APIVER); } LOAD_SYM(initialize_module, "function"); cm.initialize_module = reinterpret_cast<bool (*)(std::vector<std::string>)>(sym); LOAD_SYM(instantiate_card, "function"); cm.instantiate_card = reinterpret_cast<Card* (*)(Crate*, std::string, void*, uint8_t)>(sym); #undef LOAD_SYM if (!cm.initialize_module(configdata)) { printf("Error loading module %s: initialize_module() returned false\n", module); exit(2); } card_modules.insert(card_modules.begin(), cm); } uint16_t port = cfg_getint(cfg, "socket_port"); config_ratelimit_delay = cfg_getint(cfg, "ratelimit_delay"); bool daemonize = (cfg_getbool(cfg, "daemonize") == cfg_true); cfg_free(cfg); if (!crate_found) { printf("No crate specified in the configuration file.\n"); exit(1); } if (!crate_enabled) { printf("No crates are enabled in the configuration file.\n"); printf("No crates to service.\n"); exit(1); } if (daemonize) { do_fork(); stdout_use_syslog = true; mprintf("University of Wisconsin IPMI MicroTCA System Manager\n"); } /* * Initialize library crypto routines before spawning threads. * This connect will fail due to hostname too long, after running the crypt init functions. * * Max Hostname Limit: 64 */ ipmi_ctx_t dummy_ipmi_ctx = ipmi_ctx_create(); if (ipmi_ctx_open_outofband_2_0(dummy_ipmi_ctx, ".................................................................", // hostname NULL, // username NULL, // password NULL, // k_g 0, // k_g_len, 4, // privilege_level 0, // cipher_suite_id 0, // session_timeout 5, // retransmission_timeout IPMI_WORKAROUND_FLAGS_OUTOFBAND_2_0_OPEN_SESSION_PRIVILEGE, // workaround_flags IPMI_FLAGS_DEFAULT // flags ) == 0) { ipmi_ctx_close(dummy_ipmi_ctx); } ipmi_ctx_destroy(dummy_ipmi_ctx); /* * Instantiate Worker Threads */ for (std::vector<threadlocaldata_t>::iterator it = threadlocal.begin(); it != threadlocal.end(); it++) if (it->enabled) pthread_create(&it->thread, NULL, crate_monitor, (void *)it->crate->get_number()); #ifndef DEBUG_ONESHOT protocol_server(port); #endif for (std::vector<threadlocaldata_t>::iterator it = threadlocal.begin(); it != threadlocal.end(); it++) if (it->enabled) pthread_join(it->thread, NULL); }