/*
* Service Control Handler. This is called when the SCM sends the "Stop" signal
*/
void ServiceCtrlHandler(DWORD ctrl)
{
BOOL stop_service = FALSE;
TCHAR szMsg[COMMON_VALUE_LEN];
s_snprintf(szMsg, COMMON_VALUE_LEN, "%s service stopping.", g_serviceName);
switch (ctrl)
{
case SERVICE_CONTROL_STOP:
log_system_event(SYSTEM_EVENT_TYPE_INFO, szMsg,
"Received SERVICE_CONTROL_STOP.");
stop_service = TRUE;
break;
case SERVICE_CONTROL_SHUTDOWN:
log_system_event(SYSTEM_EVENT_TYPE_INFO, szMsg,
"Received SERVICE_CONTROL_SHUTDOWN.");
stop_service = TRUE;
break;
case SERVICE_CONTROL_INTERROGATE:
break;
default:
break;
}
if (stop_service == TRUE)
{
setServiceStatus(SERVICE_STOP_PENDING, true, NO_ERROR, 0);
// signal threads to stop
SetEvent(g_serviceStopEvent);
}
}
// ----------------------------------------------------------------------------
// the callback used to format data (into text, json, html, etc.) for clients
// ----------------------------------------------------------------------------
// HTTP/1.1 200 OK
// Content-type:text/plain
// Transfer-Encoding: chunked
//
// 3c;
// KEY:time VAL:Mon, 12 Mar 2012 13:11:49 GMT|KEY:00 VAL:14.03
// 3c;
// KEY:time VAL:Mon, 12 Mar 2012 13:11:49 GMT|KEY:00 VAL:40.75
// 3c;
// KEY:time VAL:Mon, 12 Mar 2012 13:11:49 GMT|KEY:00 VAL:45.02
// 0
//
static int push_fn(char *argv[], xbuf_t *reply)
{
reply->len = 0; // empty buffer
xbuf_xcat(reply, " \r\n" // room for chunck size: "1a; "
"KEY:time VAL:%s|", (char*)get_env(argv, SERVER_DATE));
// fill the 2D HTML <table> cells with our 1D array
// (we randomly skip some cells to avoid updating all of them)
{
int i = 0, r = 0, c = 0;
while(i < CELLS)
{
if(!(sw_rand(&rnd) & 3)) // skip some cells
xbuf_xcat(reply, "KEY:%c%c VAL:%.02f|",
'0' + r, '0' + c, s_data[i++]);
if(c + 1 < COLS) c++;
else
{
c = 0;
if(r + 1 < ROWS) r++; else r = 0;
}
}
}
reply->ptr[--reply->len] = 0; // remove the ending '|'
// now we know it, setup the chunk size
char *p = reply->ptr;
int i = s_snprintf(p, 8, "%x;", reply->len - (sizeof(" \r\n") - 2));
p[i] = ' '; // useful for tracing, when we puts(reply->ptr); later
xbuf_ncat(reply, "\r\n", sizeof("\r\n") - 1); // close this chunk
return 1;
}
std::string wbem::support::DiagnosticLogFactory::buildDiagnosticResultMessage(
struct event *p_event)
{
std::string msg_str;
char msg[NVM_EVENT_MSG_LEN];
s_snprintf(msg, (NVM_EVENT_MSG_LEN + (3 * NVM_EVENT_ARG_LEN)),
p_event->message, p_event->args[0], p_event->args[1], p_event->args[2]);
msg_str = msg;
return msg_str;
}
/*
* Constructor
*/
wbem::exception::NvmExceptionNotManageable::NvmExceptionNotManageable(const char *pUnmanageableDimm)
: wbem::framework::Exception()
{
m_unmanageableDimm = pUnmanageableDimm != NULL ? pUnmanageableDimm : "";
char description[ERROR_MESSAGE_LEN];
s_snprintf(description, ERROR_MESSAGE_LEN, EXCEPTION_NOTMANAGEABLE_MSG.c_str(),
pUnmanageableDimm);
m_Message = description;
logDebugMessage();
}
/*
** Get the OS name and version number
*/
char *
osinfo_get(char *buf,
int bufsize)
{
#ifdef HAVE_UNAME
struct utsname ub;
if (uname(&ub) < 0)
return NULL;
#ifndef _AIX
s_snprintf(buf, bufsize, "%s %s", ub.sysname, ub.release);
#else
s_snprintf(buf, bufsize, "%s %s.%s", ub.sysname, ub.version, ub.release);
#endif
#else
if (strlcpy(buf, "<unknown>", bufsize) >= bufsize)
return NULL;
#endif
return buf;
}
// ----------------------------------------------------------------------------
int main(int argc, char *argv[])
{
xbuf_t *reply = get_reply(argv);
// encode string
char buf[80], user[80] = "*****@*****.**";
int ret = s_snprintf(buf, 255, "%B", user);
xbuf_xcat(reply, "<p>plain text %s to base64:<br> %s (len: %d)</p>",
user, buf, ret);
// decode string
ret = s_snprintf(user, 255, "%-B", buf);
xbuf_xcat(reply, "<p>base64 %s to plain text:<br> %s (len: %d)</p>",
buf, user, ret);
// encode binary data
memset(user, 0, 8);
ret = s_snprintf(buf, 255, "%8B", user);
xbuf_xcat(reply, "<p>8 null bytes to base64:<br> %s (len: %d)</p>",
buf, ret);
// decode binary data
memset(user, 'A', 16);
ret = s_snprintf(user, 255, "%-B", buf);
xbuf_xcat(reply, "<p>base64 %s to binary:<br> %s (len: %d)</p>",
buf,
memcmp(user, "\0\0\0\0\0\0\0", 8) ? "mismatch" : "OK, match",
ret);
// dump binary data
int i = 0;
while(i < 16)
xbuf_xcat(reply, "user[%d] = %d<br>", i, user[i]), i++;
return 200; // return an HTTP code (200:'OK')
}
char *
strerror(int err)
{
#ifdef NEED_SYS_ERRLIST
extern int sys_nerr;
extern char *sys_errlist[];
#endif
static char errbuf[64];
if (err < 0 || err >= sys_nerr)
{
if (s_snprintf(errbuf, sizeof(errbuf), "#%d", err) < 0)
return "<unknown>";
return errbuf;
}
else
return sys_errlist[err];
}
/*
* Run the security check diagnostic algorithm
*/
int diag_security_check(const struct diagnostic *p_diagnostic, NVM_UINT32 *p_results)
{
COMMON_LOG_ENTRY();
int rc = NVM_SUCCESS;
int dev_count = 0;
*p_results = 0;
// clear previous results
diag_clear_results(EVENT_TYPE_DIAG_SECURITY, 0, NULL);
if ((rc = IS_NVM_FEATURE_SUPPORTED(security_diagnostic)) != NVM_SUCCESS)
{
COMMON_LOG_ERROR("The security diagnostic is not supported.");
}
else
{
dev_count = nvm_get_device_count();
if (dev_count == 0)
{
store_event_by_parts(EVENT_TYPE_DIAG_SECURITY, EVENT_SEVERITY_WARN,
EVENT_CODE_DIAG_SECURITY_NO_DIMMS, NULL, 0, NULL, NULL, NULL,
DIAGNOSTIC_RESULT_ABORTED);
(*p_results)++;
}
else if (dev_count > 0)
{
// get device_discovery information of all dimms
struct device_discovery dimms[dev_count];
int manageable_dev_count = 0;
dev_count = nvm_get_devices(dimms, dev_count);
if (dev_count > 0)
{
rc = NVM_SUCCESS;
// count the number of dimms in each security state.
int security_state_count = (int)LOCK_STATE_NOT_SUPPORTED;
int count[security_state_count+1];
memset(count, 0, sizeof (int) * (security_state_count + 1));
for (int i = 0; i < dev_count; i++)
{
// only take dimms that are manageable into account
if (dimms[i].manageability == MANAGEMENT_VALIDCONFIG)
{
count[dimms[i].lock_state]++;
manageable_dev_count++;
}
}
// check if all manageable dimms are security not supported
if ((count[LOCK_STATE_NOT_SUPPORTED] == manageable_dev_count) &&
(!(p_diagnostic->excludes &
DIAG_THRESHOLD_SECURITY_ALL_NOTSUPPORTED)))
{
store_event_by_parts(EVENT_TYPE_DIAG_SECURITY,
EVENT_SEVERITY_WARN,
EVENT_CODE_DIAG_SECURITY_ALL_NOTSUPPORTED, NULL, 0, NULL,
NULL, NULL, DIAGNOSTIC_RESULT_FAILED);
(*p_results)++;
}
// check if all manageable dimms are disabled
else if ((count[LOCK_STATE_DISABLED] == manageable_dev_count) &&
(!(p_diagnostic->excludes & DIAG_THRESHOLD_SECURITY_ALL_DISABLED)))
{
store_event_by_parts(EVENT_TYPE_DIAG_SECURITY,
EVENT_SEVERITY_WARN,
EVENT_CODE_DIAG_SECURITY_ALL_DISABLED, NULL, 0, NULL,
NULL, NULL, DIAGNOSTIC_RESULT_FAILED);
(*p_results)++;
}
if (*p_results == 0)
{
// check if all manageable dimms have the same security state
if (!(p_diagnostic->excludes & DIAG_THRESHOLD_SECURITY_CONSISTENT))
{
char inconsistent_security_state_event_arg_str[NVM_EVENT_ARG_LEN];
NVM_BOOL inconsistent_flag = 0;
for (int j = 0; j < security_state_count; j++)
{
// check if security settings are inconsistent
if (count[j] > 0 && count[j] != manageable_dev_count)
{
// appending to the argument
if (inconsistent_flag)
{
s_strcat(inconsistent_security_state_event_arg_str,
NVM_EVENT_ARG_LEN, ", ");
}
char arg_str_security_state[NVM_EVENT_ARG_LEN];
s_snprintf(arg_str_security_state, NVM_EVENT_ARG_LEN,
"%d %s", count[j], lock_state_strings[j]);
s_strcat(inconsistent_security_state_event_arg_str,
NVM_EVENT_ARG_LEN, arg_str_security_state);
inconsistent_flag = 1;
}
}
if (inconsistent_flag)
{
store_event_by_parts(EVENT_TYPE_DIAG_SECURITY,
EVENT_SEVERITY_WARN,
EVENT_CODE_DIAG_SECURITY_INCONSISTENT, NULL, 0,
inconsistent_security_state_event_arg_str, NULL,
NULL, DIAGNOSTIC_RESULT_FAILED);
(*p_results)++;
}
}
}
} // nvm_get_devices failed
else
{
rc = dev_count;
}
} // nvm_get_device_count failed
else
{
rc = dev_count;
}
// add success message
if ((rc == NVM_SUCCESS) && (*p_results == 0)) // No errors/warnings
{
// store success event
store_event_by_parts(
EVENT_TYPE_DIAG_SECURITY,
EVENT_SEVERITY_INFO,
EVENT_CODE_DIAG_SECURITY_SUCCESS,
NULL,
0,
NULL,
NULL,
NULL,
DIAGNOSTIC_RESULT_OK);
(*p_results)++;
}
}
COMMON_LOG_EXIT_RETURN_I(rc);
return rc;
}
