#include <stdio.h>

#include <errno.h>

#include <stdlib.h>

#include <unistd.h>

#include <string.h>

#include <inttypes.h>

#include <freeipmi/freeipmi.h>

#include <fcntl.h>

#include <pthread.h>

#include <time.h>

#include <exception>

#include <typeinfo>

#include <confuse.h>

#include <limits.h>

#include <dlfcn.h>

#include "sysmgr.h"

#include "scope_lock.h"

#include "Crate.h"

pthread_key_t threadid_key;

std::vector<threadlocaldata_t> threadlocal;

config_authdata_t config_authdata;

std::vector<cardmodule_t> card_modules;

uint32_t config_ratelimit_delay;

void fiid_dump(fiid_obj_t obj)

}

void start_crate(void *cb_crate)

}

typedef struct {

uint8_t *backoff;

uint8_t *curlaunchserial;

uint8_t launchserial;

} reset_backoff_data_t;

void reset_backoff(void *cb_reset_backoff_data_t)

}

void *crate_monitor(void *arg)

{

uint8_t crate_no = (uintptr_t)arg;

pthread_setspecific(threadid_key, &crate_no);

Crate *crate = THREADLOCAL.crate;

#ifdef DEBUG_ONESHOT // NAT DEBUG

crate->ipmi_connect();

fiid_template_t tmpl_set_clock_rq =

{

{ 8, "cmd", FIID_FIELD_REQUIRED | FIID_FIELD_LENGTH_FIXED},

{ 32, "time", FIID_FIELD_REQUIRED | FIID_FIELD_LENGTH_FIXED},

{ 0, "", 0}

};

fiid_obj_t set_clock_rq = fiid_obj_create(tmpl_set_clock_rq);

fiid_obj_set(set_clock_rq, "cmd", 0x29);

fiid_obj_set(set_clock_rq, "time", 0x01010101);

mprintf("\n\n\n");

crate->send_bridged(0, 0x82, 7, 0x70+(2*10), 0x32, set_clock_rq, NULL);

fiid_obj_destroy(set_clock_rq);

fiid_template_t tmpl_get_clock_rq =

{

{ 8, "cmd", FIID_FIELD_REQUIRED | FIID_FIELD_LENGTH_FIXED},

{ 0, "", 0}

};

fiid_template_t tmpl_get_clock_rs =

{

{ 32, "time", FIID_FIELD_REQUIRED | FIID_FIELD_LENGTH_FIXED},

{ 0, "", 0}

};

fiid_obj_t get_clock_rs = fiid_obj_create(tmpl_get_clock_rs);

fiid_obj_t get_clock_rq = fiid_obj_create(tmpl_get_clock_rq);

fiid_obj_set(get_clock_rq, "cmd", 0x2a);

mprintf("\n\n\n");

crate->send_bridged(0, 0x82, 3, 0x70+(2*10), 0x32, get_clock_rq, get_clock_rs);

mprintf("\n\n\n");

fiid_dump(get_clock_rs);

fiid_obj_destroy(get_clock_rq);

return NULL;

#endif

THREADLOCAL.taskqueue.schedule(0, callback<void>::create<start_crate>(), crate);

#ifndef EXCEPTION_GUARD

THREADLOCAL.taskqueue.run_forever();

#else

uint8_t launchserial = 0;

uint8_t backoff = 1;

while (1) {

try {

THREADLOCAL.taskqueue.run_forever();

}

catch (std::exception& e) {

// System Exception: Lower backoff cap.

if (backoff < 6)

backoff++;

mprintf("C%d: Caught System Exception: %s. Restarting Crate %d monitoring in %d seconds.\n", crate_no, typeid(typeof(e)).name(), crate_no, (1 << (backoff-1)));

}

catch (SDRRepositoryNotPopulatedException& e) {

if (backoff < 8)

backoff++;

mprintf("C%d: The SDR repository is not yet populated. Restarting Crate %d monitoring in %d seconds.\n", crate_no, crate_no, (1 << (backoff-1)));

}

catch (IPMI_ConnectionFailedException& e) {

if (backoff < 8)

backoff++;

mprintf("C%d: Unable to connect to Crate %d: \"%s\". Restarting Crate %d monitoring in %d seconds.\n", crate_no, crate_no, e.get_message().c_str(), crate_no, (1 << (backoff-1)));

}

catch (Sysmgr_Exception& e) {

// Local Exception

if (backoff < 8)

backoff++;

if (e.get_message().c_str()[0] != '\0')

mprintf("C%d: Caught %s on %s:%d in %s(): %s\n", crate_no, e.get_type().c_str(), e.get_file().c_str(), e.get_line(), e.get_func().c_str(), e.get_message().c_str());

else

mprintf("C%d: Caught %s on %s:%d in %s()\n", crate_no, e.get_type().c_str(), e.get_file().c_str(), e.get_line(), e.get_func().c_str());

mprintf("C%d: Restarting Crate %d monitoring in %d seconds.\n", crate_no, crate_no, (1 << (backoff-1)));

}

crate->ipmi_disconnect();

launchserial++;

time_t next = time(NULL) + (1 << (backoff-1));

THREADLOCAL.taskqueue.schedule(next, callback<void>::create<start_crate>(), crate);

reset_backoff_data_t *backoffdata = new reset_backoff_data_t;

backoffdata->backoff = &backoff;

backoffdata->curlaunchserial = &launchserial;

backoffdata->launchserial = launchserial;

THREADLOCAL.taskqueue.schedule(time(NULL)+(1 << (backoff-1+1)), callback<void>::create<reset_backoff>(), backoffdata);

}

#endif

return NULL;

}

void protocol_server(uint16_t port); // From mgmt_protocol.cpp

static int cfg_validate_hostname(cfg_t *cfg, cfg_opt_t *opt)

}

static int cfg_validate_port(cfg_t *cfg, cfg_opt_t *opt)

}

static int cfg_parse_authtype(cfg_t *cfg, cfg_opt_t *opt, const char *value, void *result)

}

static int cfg_parse_MCH(cfg_t *cfg, cfg_opt_t *opt, const char *value, void *result)

}

void do_fork() {

}

extern const char *GIT_BRANCH, *GIT_COMMIT, *GIT_DIRTY;

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 : "$Format:%H$"));

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);

}