static pmix_status_t syslog_register(void)
{
pmix_status_t rc = PMIX_SUCCESS;
(void) pmix_mca_base_component_var_register(&mca_plog_syslog_component.super.base, "console",
"Write directly to system console if there is an error while sending to system logger",
PMIX_MCA_BASE_VAR_TYPE_BOOL, NULL, 0, 0,
PMIX_INFO_LVL_2,
PMIX_MCA_BASE_VAR_SCOPE_READONLY,
&mca_plog_syslog_component.console);
(void) pmix_mca_base_component_var_register(&mca_plog_syslog_component.super.base, "level",
"Default syslog logging level (err, alert, crit, emerg, warning, notice, info[default], or debug)",
PMIX_MCA_BASE_VAR_TYPE_STRING, NULL, 0, 0,
PMIX_INFO_LVL_2,
PMIX_MCA_BASE_VAR_SCOPE_READONLY,
&level);
if (0 == strncasecmp(level, "err", 3)) {
mca_plog_syslog_component.level = LOG_ERR;
} else if (0 == strcasecmp(level, "alert")) {
mca_plog_syslog_component.level = LOG_ALERT;
} else if (0 == strncasecmp(level, "crit", 4)) {
mca_plog_syslog_component.level = LOG_CRIT;
} else if (0 == strncasecmp(level, "emerg", 5)) {
mca_plog_syslog_component.level = LOG_EMERG;
} else if (0 == strncasecmp(level, "warn", 4)) {
mca_plog_syslog_component.level = LOG_WARNING;
} else if (0 == strncasecmp(level, "not", 3)) {
mca_plog_syslog_component.level = LOG_NOTICE;
} else if (0 == strcasecmp(level, "info")) {
mca_plog_syslog_component.level = LOG_INFO;
} else if (0 == strcasecmp(level, "debug") || 0 == strcasecmp(level, "dbg")) {
mca_plog_syslog_component.level = LOG_DEBUG;
} else {
pmix_show_help("help-pmix-plog.txt", "syslog:unrec-level", true, level);
rc = PMIX_ERR_NOT_SUPPORTED;
}
(void) pmix_mca_base_component_var_register(&mca_plog_syslog_component.super.base, "facility",
"Specify what type of program is logging the message "
"(only \"auth\", \"priv\", \"daemon\", and \"user\" are supported)",
PMIX_MCA_BASE_VAR_TYPE_STRING, NULL, 0, 0,
PMIX_INFO_LVL_2,
PMIX_MCA_BASE_VAR_SCOPE_READONLY,
&facility);
if (0 == strncasecmp(facility, "auth", 4)) {
mca_plog_syslog_component.facility = LOG_AUTH;
} else if (0 == strncasecmp(facility, "priv", 4)) {
mca_plog_syslog_component.facility = LOG_AUTHPRIV;
} else if (0 == strcasecmp(facility, "daemon")) {
mca_plog_syslog_component.facility = LOG_DAEMON;
} else if (0 == strcasecmp(facility, "user")) {
mca_plog_syslog_component.facility = LOG_USER;
} else {
pmix_show_help("help-pmix-plog.txt", "syslog:unrec-facility", true, facility);
rc = PMIX_ERR_NOT_SUPPORTED;
}
return rc;
}
/* Ensure that *all* requested components exist. Print a warning
and abort if they do not. */
static int component_find_check (pmix_mca_base_framework_t *framework, char **requested_component_names)
{
pmix_list_t *components = &framework->framework_components;
pmix_mca_base_component_list_item_t *cli;
if (NULL == requested_component_names) {
return PMIX_SUCCESS;
}
for (int i = 0; NULL != requested_component_names[i]; ++i) {
bool found = false;
PMIX_LIST_FOREACH(cli, components, pmix_mca_base_component_list_item_t) {
if (0 == strcmp(requested_component_names[i],
cli->cli_component->pmix_mca_component_name)) {
found = true;
break;
}
}
if (!found) {
char h[MAXHOSTNAMELEN];
gethostname(h, sizeof(h));
pmix_show_help("help-mca-base.txt",
"find-available:not-valid", true,
h, framework->framework_name, requested_component_names[i]);
return PMIX_ERR_NOT_FOUND;
}
}
return PMIX_SUCCESS;
}
int
pmix_net_init(void)
{
char **args, *arg;
uint32_t a, b, c, d, bits, addr;
int i, count, found_bad = 0;
args = pmix_argv_split(pmix_net_private_ipv4, ';');
if( NULL != args ) {
count = pmix_argv_count(args);
private_ipv4 = (private_ipv4_t*)malloc( (count + 1) * sizeof(private_ipv4_t));
if( NULL == private_ipv4 ) {
pmix_output(0, "Unable to allocate memory for the private addresses array" );
pmix_argv_free(args);
goto do_local_init;
}
for( i = 0; i < count; i++ ) {
arg = args[i];
(void)sscanf( arg, "%u.%u.%u.%u/%u", &a, &b, &c, &d, &bits );
if( (a > 255) || (b > 255) || (c > 255) ||
(d > 255) || (bits > 32) ) {
if (0 == found_bad) {
pmix_show_help("help-pmix-runtime.txt",
"malformed net_private_ipv4",
true, args[i]);
found_bad = 1;
}
continue;
}
addr = (a << 24) | (b << 16) | (c << 8) | d;
private_ipv4[i].addr = htonl(addr);
private_ipv4[i].netmask_bits = bits;
}
private_ipv4[i].addr = 0;
private_ipv4[i].netmask_bits = 0;
pmix_argv_free(args);
}
do_local_init:
return pmix_tsd_key_create(&hostname_tsd_key, hostname_cleanup);
}
int pmix_mca_base_component_parse_requested (const char *requested, bool *include_mode,
char ***requested_component_names)
{
const char *requested_orig = requested;
*requested_component_names = NULL;
*include_mode = true;
/* See if the user requested anything */
if (NULL == requested || 0 == strlen (requested)) {
return PMIX_SUCCESS;
}
/* Are we including or excluding? We only allow the negate
character to be the *first* character of the value (but be nice
and allow any number of negate characters in the beginning). */
*include_mode = requested[0] != negate[0];
/* skip over all negate symbols at the beginning */
requested += strspn (requested, negate);
/* Double check to ensure that the user did not specify the negate
character anywhere else in the value. */
if (NULL != strstr (requested, negate)) {
pmix_show_help("help-mca-base.txt",
"framework-param:too-many-negates",
true, requested_orig);
return PMIX_ERROR;
}
/* Split up the value into individual component names */
*requested_component_names = pmix_argv_split(requested, ',');
/* All done */
return PMIX_SUCCESS;
}
int pmix_rte_init(pmix_proc_type_t type,
pmix_info_t info[], size_t ninfo,
pmix_ptl_cbfunc_t cbfunc)
{
int ret, debug_level;
char *error = NULL, *evar;
size_t n;
char hostname[PMIX_MAXHOSTNAMELEN];
if( ++pmix_initialized != 1 ) {
if( pmix_initialized < 1 ) {
return PMIX_ERROR;
}
return PMIX_SUCCESS;
}
#if PMIX_NO_LIB_DESTRUCTOR
if (pmix_init_called) {
/* can't use show_help here */
fprintf (stderr, "pmix_init: attempted to initialize after finalize without compiler "
"support for either __attribute__(destructor) or linker support for -fini -- process "
"will likely abort\n");
return PMIX_ERR_NOT_SUPPORTED;
}
#endif
pmix_init_called = true;
/* initialize the output system */
if (!pmix_output_init()) {
return PMIX_ERROR;
}
/* initialize install dirs code */
if (PMIX_SUCCESS != (ret = pmix_mca_base_framework_open(&pmix_pinstalldirs_base_framework, 0))) {
fprintf(stderr, "pmix_pinstalldirs_base_open() failed -- process will likely abort (%s:%d, returned %d instead of PMIX_SUCCESS)\n",
__FILE__, __LINE__, ret);
return ret;
}
/* initialize the help system */
pmix_show_help_init();
/* keyval lex-based parser */
if (PMIX_SUCCESS != (ret = pmix_util_keyval_parse_init())) {
error = "pmix_util_keyval_parse_init";
goto return_error;
}
/* Setup the parameter system */
if (PMIX_SUCCESS != (ret = pmix_mca_base_var_init())) {
error = "mca_base_var_init";
goto return_error;
}
/* register params for pmix */
if (PMIX_SUCCESS != (ret = pmix_register_params())) {
error = "pmix_register_params";
goto return_error;
}
/* initialize the mca */
if (PMIX_SUCCESS != (ret = pmix_mca_base_open())) {
error = "mca_base_open";
goto return_error;
}
/* setup the globals structure */
gethostname(hostname, PMIX_MAXHOSTNAMELEN);
pmix_globals.hostname = strdup(hostname);
memset(&pmix_globals.myid.nspace, 0, PMIX_MAX_NSLEN+1);
pmix_globals.myid.rank = PMIX_RANK_INVALID;
PMIX_CONSTRUCT(&pmix_globals.events, pmix_events_t);
pmix_globals.event_window.tv_sec = pmix_event_caching_window;
pmix_globals.event_window.tv_usec = 0;
PMIX_CONSTRUCT(&pmix_globals.cached_events, pmix_list_t);
/* construct the global notification ring buffer */
PMIX_CONSTRUCT(&pmix_globals.notifications, pmix_hotel_t);
ret = pmix_hotel_init(&pmix_globals.notifications, pmix_globals.max_events,
pmix_globals.evbase, pmix_globals.event_eviction_time,
_notification_eviction_cbfunc);
if (PMIX_SUCCESS != ret) {
error = "notification hotel init";
goto return_error;
}
/* and setup the iof request tracking list */
PMIX_CONSTRUCT(&pmix_globals.iof_requests, pmix_list_t);
/* Setup client verbosities as all procs are allowed to
* access client APIs */
if (0 < pmix_client_globals.get_verbose) {
/* set default output */
pmix_client_globals.get_output = pmix_output_open(NULL);
pmix_output_set_verbosity(pmix_client_globals.get_output,
pmix_client_globals.get_verbose);
}
if (0 < pmix_client_globals.connect_verbose) {
/* set default output */
pmix_client_globals.connect_output = pmix_output_open(NULL);
pmix_output_set_verbosity(pmix_client_globals.connect_output,
pmix_client_globals.connect_verbose);
}
if (0 < pmix_client_globals.fence_verbose) {
/* set default output */
pmix_client_globals.fence_output = pmix_output_open(NULL);
pmix_output_set_verbosity(pmix_client_globals.fence_output,
pmix_client_globals.fence_verbose);
}
if (0 < pmix_client_globals.pub_verbose) {
/* set default output */
pmix_client_globals.pub_output = pmix_output_open(NULL);
pmix_output_set_verbosity(pmix_client_globals.pub_output,
pmix_client_globals.pub_verbose);
}
if (0 < pmix_client_globals.spawn_verbose) {
/* set default output */
pmix_client_globals.spawn_output = pmix_output_open(NULL);
pmix_output_set_verbosity(pmix_client_globals.spawn_output,
pmix_client_globals.spawn_verbose);
}
if (0 < pmix_client_globals.event_verbose) {
/* set default output */
pmix_client_globals.event_output = pmix_output_open(NULL);
pmix_output_set_verbosity(pmix_client_globals.event_output,
pmix_client_globals.event_verbose);
}
if (0 < pmix_client_globals.iof_verbose) {
/* set default output */
pmix_client_globals.iof_output = pmix_output_open(NULL);
pmix_output_set_verbosity(pmix_client_globals.iof_output,
pmix_client_globals.iof_verbose);
}
/* get our effective id's */
pmix_globals.uid = geteuid();
pmix_globals.gid = getegid();
/* see if debug is requested */
if (NULL != (evar = getenv("PMIX_DEBUG"))) {
debug_level = strtol(evar, NULL, 10);
pmix_globals.debug_output = pmix_output_open(NULL);
pmix_output_set_verbosity(pmix_globals.debug_output, debug_level);
}
/* create our peer object */
pmix_globals.mypeer = PMIX_NEW(pmix_peer_t);
if (NULL == pmix_globals.mypeer) {
ret = PMIX_ERR_NOMEM;
goto return_error;
}
/* whatever our declared proc type, we are definitely v3.0 */
pmix_globals.mypeer->proc_type = type | PMIX_PROC_V3;
/* create an nspace object for ourselves - we will
* fill in the nspace name later */
pmix_globals.mypeer->nptr = PMIX_NEW(pmix_namespace_t);
if (NULL == pmix_globals.mypeer->nptr) {
PMIX_RELEASE(pmix_globals.mypeer);
ret = PMIX_ERR_NOMEM;
goto return_error;
}
/* scan incoming info for directives */
if (NULL != info) {
for (n=0; n < ninfo; n++) {
if (PMIX_CHECK_KEY(&info[n], PMIX_EVENT_BASE)) {
pmix_globals.evbase = (pmix_event_base_t*)info[n].value.data.ptr;
pmix_globals.external_evbase = true;
} else if (PMIX_CHECK_KEY(&info[n], PMIX_HOSTNAME)) {
if (NULL != pmix_globals.hostname) {
free(pmix_globals.hostname);
}
pmix_globals.hostname = strdup(info[n].value.data.string);
} else if (PMIX_CHECK_KEY(&info[n], PMIX_NODEID)) {
PMIX_VALUE_GET_NUMBER(ret, &info[n].value, pmix_globals.nodeid, uint32_t);
if (PMIX_SUCCESS != ret) {
goto return_error;
}
}
}
}
/* the choice of modules to use when communicating with a peer
* will be done by the individual init functions and at the
* time of connection to that peer */
/* open the bfrops and select the active plugins */
if (PMIX_SUCCESS != (ret = pmix_mca_base_framework_open(&pmix_bfrops_base_framework, 0)) ) {
error = "pmix_bfrops_base_open";
goto return_error;
}
if (PMIX_SUCCESS != (ret = pmix_bfrop_base_select()) ) {
error = "pmix_bfrops_base_select";
goto return_error;
}
/* open the ptl and select the active plugins */
if (PMIX_SUCCESS != (ret = pmix_mca_base_framework_open(&pmix_ptl_base_framework, 0)) ) {
error = "pmix_ptl_base_open";
goto return_error;
}
if (PMIX_SUCCESS != (ret = pmix_ptl_base_select()) ) {
error = "pmix_ptl_base_select";
goto return_error;
}
/* set the notification callback function */
if (PMIX_SUCCESS != (ret = pmix_ptl_base_set_notification_cbfunc(cbfunc))) {
error = "pmix_ptl_set_notification_cbfunc";
goto return_error;
}
/* open the psec and select the active plugins */
if (PMIX_SUCCESS != (ret = pmix_mca_base_framework_open(&pmix_psec_base_framework, 0))) {
error = "pmix_psec_base_open";
goto return_error;
}
if (PMIX_SUCCESS != (ret = pmix_psec_base_select())) {
error = "pmix_psec_base_select";
goto return_error;
}
/* open the gds and select the active plugins */
if (PMIX_SUCCESS != (ret = pmix_mca_base_framework_open(&pmix_gds_base_framework, 0)) ) {
error = "pmix_gds_base_open";
goto return_error;
}
if (PMIX_SUCCESS != (ret = pmix_gds_base_select(info, ninfo)) ) {
error = "pmix_gds_base_select";
goto return_error;
}
/* initialize pif framework */
if (PMIX_SUCCESS != (ret = pmix_mca_base_framework_open(&pmix_pif_base_framework, 0))) {
error = "pmix_pif_base_open";
return ret;
}
/* open the preg and select the active plugins */
if (PMIX_SUCCESS != (ret = pmix_mca_base_framework_open(&pmix_preg_base_framework, 0)) ) {
error = "pmix_preg_base_open";
goto return_error;
}
if (PMIX_SUCCESS != (ret = pmix_preg_base_select()) ) {
error = "pmix_preg_base_select";
goto return_error;
}
/* open the plog and select the active plugins */
if (PMIX_SUCCESS != (ret = pmix_mca_base_framework_open(&pmix_plog_base_framework, 0)) ) {
error = "pmix_plog_base_open";
goto return_error;
}
if (PMIX_SUCCESS != (ret = pmix_plog_base_select()) ) {
error = "pmix_plog_base_select";
goto return_error;
}
/* if an external event base wasn't provide, create one */
if (!pmix_globals.external_evbase) {
/* tell libevent that we need thread support */
pmix_event_use_threads();
/* create an event base and progress thread for us */
if (NULL == (pmix_globals.evbase = pmix_progress_thread_init(NULL))) {
error = "progress thread";
ret = PMIX_ERROR;
goto return_error;
}
}
return PMIX_SUCCESS;
return_error:
if (PMIX_ERR_SILENT != ret) {
pmix_show_help( "help-pmix-runtime.txt",
"pmix_init:startup:internal-failure", true,
error, ret );
}
return ret;
}
/*
* Back-end function to actually send the email
*/
static int send_email(char *msg)
{
int i, err = PMIX_SUCCESS;
char *str = NULL;
char *errmsg = NULL;
struct sigaction sig, oldsig;
bool set_oldsig = false;
smtp_session_t session = NULL;
smtp_message_t message = NULL;
message_status_t ms;
pmix_plog_smtp_component_t *c = &mca_plog_smtp_component;
if (NULL == c->to_argv) {
c->to_argv = pmix_argv_split(c->to, ',');
if (NULL == c->to_argv ||
NULL == c->to_argv[0]) {
return PMIX_ERR_OUT_OF_RESOURCE;
}
}
ms.sent_flag = SENT_NONE;
ms.prev_string = NULL;
ms.msg = msg;
/* Temporarily disable SIGPIPE so that if remote servers timeout
or hang up on us, it doesn't kill this application. We'll
restore the original SIGPIPE handler when we're done. */
sig.sa_handler = SIG_IGN;
sigemptyset(&sig.sa_mask);
sig.sa_flags = 0;
sigaction(SIGPIPE, &sig, &oldsig);
set_oldsig = true;
/* Try to get a libesmtp session. If so, assume that libesmtp is
happy and proceeed */
session = smtp_create_session();
if (NULL == session) {
err = PMIX_ERR_NOT_SUPPORTED;
errmsg = "stmp_create_session";
goto error;
}
/* Create the message */
message = smtp_add_message(session);
if (NULL == message) {
err = PMIX_ERROR;
errmsg = "stmp_add_message";
goto error;
}
/* Set the SMTP server (yes, it's a weird return status!) */
asprintf(&str, "%s:%d", c->server, c->port);
if (0 == smtp_set_server(session, str)) {
err = PMIX_ERROR;
errmsg = "stmp_set_server";
goto error;
}
free(str);
str = NULL;
/* Add the sender */
if (0 == smtp_set_reverse_path(message, c->from_addr)) {
err = PMIX_ERROR;
errmsg = "stmp_set_reverse_path";
goto error;
}
/* Set the subject and some headers */
asprintf(&str, "PMIx SMTP Plog v%d.%d.%d",
c->super.base.pmix_mca_component_major_version,
c->super.base.pmix_mca_component_minor_version,
c->super.base.pmix_mca_component_release_version);
if (0 == smtp_set_header(message, "Subject", c->subject) ||
0 == smtp_set_header_option(message, "Subject", Hdr_OVERRIDE, 1) ||
0 == smtp_set_header(message, "To", NULL, NULL) ||
0 == smtp_set_header(message, "From",
(NULL != c->from_name ?
c->from_name : c->from_addr),
c->from_addr) ||
0 == smtp_set_header(message, "X-Mailer", str) ||
0 == smtp_set_header_option(message, "Subject", Hdr_OVERRIDE, 1)) {
err = PMIX_ERROR;
errmsg = "smtp_set_header";
goto error;
}
free(str);
str = NULL;
/* Add the recipients */
for (i = 0; NULL != c->to_argv[i]; ++i) {
if (NULL == smtp_add_recipient(message, c->to_argv[i])) {
err = PMIX_ERR_OUT_OF_RESOURCE;
errmsg = "stmp_add_recipient";
goto error;
}
}
/* Set the callback to get the message */
if (0 == smtp_set_messagecb(message, message_cb, &ms)) {
err = PMIX_ERROR;
errmsg = "smtp_set_messagecb";
goto error;
}
/* Send it! */
if (0 == smtp_start_session(session)) {
err = PMIX_ERROR;
errmsg = "smtp_start_session";
goto error;
}
/* Fall through */
error:
if (NULL != str) {
free(str);
}
if (NULL != session) {
smtp_destroy_session(session);
}
/* Restore the SIGPIPE handler */
if (set_oldsig) {
sigaction(SIGPIPE, &oldsig, NULL);
}
if (PMIX_SUCCESS != err) {
int e;
char em[256];
e = smtp_errno();
smtp_strerror(e, em, sizeof(em));
pmix_show_help("help-pmix-plog-smtp.txt",
"send_email failed",
true, "libesmtp library call failed",
errmsg, em, e, msg);
}
return err;
}
