static int pantheios_be_WindowsDebugger_init_(
pan_char_t const* processIdentity
, int backEndId
, pan_be_WindowsDebugger_init_t const* init
, void* reserved
, void** ptoken
)
{
PANTHEIOS_CONTRACT_ENFORCE_PRECONDITION_PARAMS_API(NULL != processIdentity, "process identity may not be the null string");
PANTHEIOS_CONTRACT_ENFORCE_PRECONDITION_PARAMS_API('\0' != 0[processIdentity], "process identity may not be the empty string");
STLSOFT_SUPPRESS_UNUSED(reserved);
PANTHEIOS_CONTRACT_ENFORCE_PRECONDITION_PARAMS_API(NULL != ptoken, "token pointer may not be null");
/* (i) apply Null Object (Variable) pattern */
pan_be_WindowsDebugger_init_t init_;
if(NULL == init)
{
pantheios_be_WindowsDebugger_getDefaultAppInit(&init_);
init = &init_;
#ifdef PANTHEIOS_BE_USE_CALLBACK
pantheios_be_WindowsDebugger_getAppInit(backEndId, &init_);
#endif /* PANTHEIOS_BE_USE_CALLBACK */
}
/* (ii) verify the version */
if(init->version < 0x010001b8)
{
return PANTHEIOS_BE_INIT_RC_OLD_VERSION_NOT_SUPPORTED;
}
else if(init->version > PANTHEIOS_VER)
{
return PANTHEIOS_BE_INIT_RC_FUTURE_VERSION_REQUESTED;
}
/* (iii) create the context */
WindowsDebugger_Context* ctxt = new WindowsDebugger_Context(processIdentity, backEndId, init);
#ifndef STLSOFT_CF_THROW_BAD_ALLOC
if( NULL == ctxt ||
NULL == ctxt->getProcessIdentity())
{
delete ctxt;
return PANTHEIOS_INIT_RC_OUT_OF_MEMORY;
}
#endif /* !STLSOFT_CF_THROW_BAD_ALLOC */
*ptoken = ctxt;
return 0;
}
PANTHEIOS_CALL(void) pantheios_fe_uninit(
void* token
)
{
PANTHEIOS_CONTRACT_ENFORCE_PRECONDITION_PARAMS_API(NULL == token, "token must be null");
STLSOFT_SUPPRESS_UNUSED(token);
}
PANTHEIOS_CALL(void) pantheios_be_WindowsDebugger_getDefaultAppInit(pan_be_WindowsDebugger_init_t* init) /* throw() */
{
PANTHEIOS_CONTRACT_ENFORCE_PRECONDITION_PARAMS_API(NULL != init, "initialisation structure pointer may not be null");
init->version = PANTHEIOS_VER;
init->flags = 0;
}
interval::interval(int interval, interval::units units)
: m_interval(interval)
, m_units(units)
, m_result()
{
PANTHEIOS_CONTRACT_ENFORCE_PRECONDITION_PARAMS_API(units >= microseconds && units <= days, "unrecognised units");
}
PANTHEIOS_CALL(void) pantheios_be_WindowsDebugger_uninit(void* token)
{
PANTHEIOS_CONTRACT_ENFORCE_PRECONDITION_PARAMS_API(NULL != token, "token must be non-null");
WindowsDebugger_Context* ctxt = static_cast<WindowsDebugger_Context*>(token);
delete ctxt;
}
PANTHEIOS_CALL(void) pantheios_be_uninit(void* token)
{
pan_lr_tokens_t* tokens = (pan_lr_tokens_t*)token;
PANTHEIOS_CONTRACT_ENFORCE_PRECONDITION_PARAMS_API(NULL != token, "token may not be null");
pantheios_be_local_uninit(tokens->localToken);
pantheios_be_remote_uninit(tokens->remoteToken);
free(tokens);
}
PANTHEIOS_CALL(void) pantheios_be_speech_getDefaultAppInit(pan_be_speech_init_t* init) /* throw() */
{
PANTHEIOS_CONTRACT_ENFORCE_PRECONDITION_PARAMS_API(NULL != init, "initialisation structure pointer may not be null");
init->version = PANTHEIOS_VER;
init->flags = 0;
init->flags |= PANTHEIOS_BE_INIT_F_NO_PROCESS_ID;
init->flags |= PANTHEIOS_BE_INIT_F_NO_THREAD_ID;
init->flags |= PANTHEIOS_BE_INIT_F_NO_DATETIME;
}
PANTHEIOS_CALL(void) pantheios_be_WindowsSyslog_uninit(void* token)
{
WindowsSysLog_Context* ctxt = static_cast<WindowsSysLog_Context*>(token);
PANTHEIOS_CONTRACT_ENFORCE_PRECONDITION_PARAMS_API(NULL != token, "token must be non-null");
pantheios_util_strfree_m(ctxt->hostIdentity);
pantheios_util_strfree_m(ctxt->processIdentity);
::closesocket(ctxt->sk);
::WSACleanup();
::free(ctxt);
}
PANTHEIOS_CALL(int) pantheios_be_speech_parseArgs(
size_t numArgs
, pan_slice_t* const args
, pan_be_speech_init_t* init
)
{
PANTHEIOS_CONTRACT_ENFORCE_PRECONDITION_PARAMS_API((NULL != args || 0 == numArgs), "argument pointer must be non-null, or number of arguments must be 0");
PANTHEIOS_CONTRACT_ENFORCE_PRECONDITION_PARAMS_API(NULL != init, "initialisation structure pointer may not be null");
pantheios_be_speech_getDefaultAppInit(init);
// 1. Parse the stock arguments
int res = pantheios_be_parseStockArgs(numArgs, args, &init->flags);
if(res >= 0)
{
// 2.a Parse the custom argument: "synchronous"
res = pantheios_be_parseBooleanArg(numArgs, args, PANTHEIOS_LITERAL_STRING("synchronous"), true, PANTHEIOS_BE_SPEECH_F_SYNCHRONOUS, &init->flags);
}
if(res >= 0)
{
// 2.b Parse the custom argument: "purgeBeforeSpeak"
res = pantheios_be_parseBooleanArg(numArgs, args, PANTHEIOS_LITERAL_STRING("purgeBeforeSpeak"), true, PANTHEIOS_BE_SPEECH_F_PURGE_BEFORE_SPEAK, &init->flags);
}
if(res >= 0)
{
// 2.c Parse the custom argument: "speakPunctuation"
res = pantheios_be_parseBooleanArg(numArgs, args, PANTHEIOS_LITERAL_STRING("speakPunctuation"), true, PANTHEIOS_BE_SPEECH_F_SPEAK_PUNCTUATION, &init->flags);
}
if(res >= 0)
{
// 2.d Parse the custom argument: "synchronousOnCritical"
res = pantheios_be_parseBooleanArg(numArgs, args, PANTHEIOS_LITERAL_STRING("synchronousOnCritical"), true, PANTHEIOS_BE_SPEECH_F_SYNCHRONOUS_ON_CRITICAL, &init->flags);
}
return res;
}
static int pantheios_be_speech_logEntry_(
void* /* feToken */
, void* beToken
, int severity
, pan_char_t const* entry
, size_t cchEntry
)
{
PANTHEIOS_CONTRACT_ENFORCE_PRECONDITION_PARAMS_API(NULL != beToken, "back-end token must be non-null");
be_speech_context* ctxt = static_cast<be_speech_context*>(beToken);
return ctxt->logEntry(severity, entry, cchEntry);
}
PANTHEIOS_CALL(int) pantheios_fe_init(
void* reserved
, void** ptoken
)
{
PANTHEIOS_CONTRACT_ENFORCE_PRECONDITION_PARAMS_API(NULL != ptoken, "token pointer may not be null");
/* PANTHEIOS_CONTRACT_ENFORCE_PRECONDITION_STATE_API(pantheios_isInitialising(), "This can only be called when Pantheios is initialising"); */
STLSOFT_SUPPRESS_UNUSED(reserved);
*ptoken = NULL;
return 0;
}
PANTHEIOS_CALL(void) pantheios_be_WindowsSyslog_getDefaultAppInit(pan_be_WindowsSyslog_init_t* init) /* throw() */
{
PANTHEIOS_CONTRACT_ENFORCE_PRECONDITION_PARAMS_API(NULL != init, "initialisation structure pointer may not be null");
init->version = PANTHEIOS_VER;
init->flags = 0;
init->addrSize = 4;
init->bytes[0] = 255;
init->bytes[1] = 255;
init->bytes[2] = 255;
init->bytes[3] = 255;
init->hostName = NULL;
init->port = 514;
init->facility = PANTHEIOS_SYSLOG_FAC_USER;
}
PANTHEIOS_CALL(PAN_CHAR_T const*) pantheios_fe_getProcessIdentity(
void* token
)
{
PANTHEIOS_CONTRACT_ENFORCE_PRECONDITION_PARAMS_API(NULL == token, "token must be null");
/* PANTHEIOS_CONTRACT_ENFORCE_PRECONDITION_STATE_API(pantheios_isInitialising(), "This can only be called when Pantheios is initialising"); */
STLSOFT_SUPPRESS_UNUSED(token);
#ifdef PANTHEIOS_BE_USE_CALLBACK
return pantheios_fe_getAppProcessIdentity();
#else /* ? PANTHEIOS_BE_USE_CALLBACK */
return PANTHEIOS_FE_PROCESS_IDENTITY;
#endif /* PANTHEIOS_BE_USE_CALLBACK */
}
static int pantheios_be_fprintf_logEntry_(
void* feToken
, void* beToken
, int severity
, pan_char_t const* entry
, size_t cchEntry
)
{
PANTHEIOS_CONTRACT_ENFORCE_PRECONDITION_PARAMS_API(NULL != beToken, "back-end token must be non-null");
STLSOFT_SUPPRESS_UNUSED(feToken);
Context* ctxt = static_cast<Context*>(beToken);
return ctxt->logEntry(severity, entry, cchEntry);
}
PANTHEIOS_CALL(int) pantheios_fe_isSeverityLogged(
void* token
, int severity
, int backEndId
)
{
PANTHEIOS_CONTRACT_ENFORCE_PRECONDITION_PARAMS_API(NULL == token, "token must be null");
/* PANTHEIOS_CONTRACT_ENFORCE_PRECONDITION_STATE_API(!pantheios_isInitialising(), "This cannot be called when Pantheios is initialising"); */
/* PANTHEIOS_CONTRACT_ENFORCE_PRECONDITION_STATE_API(pantheios_isInitialised(), "This can only be called when Pantheios is initialised"); */
STLSOFT_SUPPRESS_UNUSED(token);
STLSOFT_SUPPRESS_UNUSED(severity);
STLSOFT_SUPPRESS_UNUSED(backEndId);
return (severity & 0x0f) <= pantheios_fe_severity_ceiling_;
}
size_t pantheios_getHostName(pan_char_t* buffer, size_t cchBuffer)
{
size_t res;
/* Preconditions */
PANTHEIOS_CONTRACT_ENFORCE_PRECONDITION_PARAMS_API((0 == cchBuffer || NULL != buffer), "character buffer pointer may only be null if the indicated size is 0");
/* Body */
res = pantheios_getHostName_body_(buffer, cchBuffer);
/* Postconditions */
PANTHEIOS_CONTRACT_ENFORCE_POSTCONDITION_STATE_API(res <= cchBuffer, "the result must not exceed the buffer length");
PANTHEIOS_CONTRACT_ENFORCE_POSTCONDITION_STATE_API((0 == res || cchBuffer == res || pan_strlen_(buffer) < cchBuffer), "the result must be 0, or the buffer must be zero, or the length of the written string is less than the buffer length");
return res;
}
int WindowsEventLog_Context::ReportEvent(
int severity
, pan_char_t const* entry
, size_t /* cchEntry */
)
{
WORD wType;
pan_uint16_t category = 0xFFFF;
pan_uint32_t eventId = 0xFFFFFFFF;
PSID lpUserSid = NULL;
WORD wNumStrings = 1;
DWORD dwDataSize = 0;
LPCTSTR* lpStrings = &entry;
LPVOID lpRawData = NULL;
PANTHEIOS_CONTRACT_ENFORCE_PRECONDITION_PARAMS_API(0 == (severity & 0x08), "be.WindowsEventLog can only be used with the stock severity levels in the range [0, 8). Levels in the range [8, 16) are not allowed");
pantheios_be_WindowsEventLog_calcCategoryAndEventId(this->id, severity, &category, &eventId);
if( 0xFFFF == category &&
0xFFFFFFFF == eventId)
{
return 0;
}
severity &= 0x7; /* This stock back-end ignores any custom severity information. */
wType = pantheios_severity_to_WindowsEventLog_type(severity);
if(!pan_ReportEvent_(
hEvLog
, wType
, category
, eventId
, lpUserSid
, wNumStrings
, dwDataSize
, lpStrings
, lpRawData
))
{
return PANTHEIOS_INIT_RC_UNSPECIFIED_FAILURE;
}
return 0;
}
PANTHEIOS_CALL(int) pantheios_be_null_init(
pan_char_t const* processIdentity
, int id
, void* unused
, void* reserved
, void** ptoken
)
{
STLSOFT_SUPPRESS_UNUSED(processIdentity);
STLSOFT_SUPPRESS_UNUSED(id);
STLSOFT_SUPPRESS_UNUSED(unused);
STLSOFT_SUPPRESS_UNUSED(reserved);
PANTHEIOS_CONTRACT_ENFORCE_PRECONDITION_PARAMS_API(NULL != ptoken, "token pointer may not be null");
*ptoken = NULL;
return 0;
}
static int pantheios_be_WindowsEventLog_init_(
pan_char_t const* processIdentity
, int id
, void const* unused
, void* reserved
, void** ptoken
)
{
PANTHEIOS_CONTRACT_ENFORCE_PRECONDITION_PARAMS_API(NULL != processIdentity, "process identity may not be NULL");
STLSOFT_SUPPRESS_UNUSED(unused);
STLSOFT_SUPPRESS_UNUSED(reserved);
// (iii) create the context
WindowsEventLog_Context* ctxt = new WindowsEventLog_Context(id);
#ifndef STLSOFT_CF_THROW_BAD_ALLOC
if(NULL == ctxt)
{
delete ctxt;
return PANTHEIOS_INIT_RC_OUT_OF_MEMORY;
}
else
#endif /* !STLSOFT_CF_THROW_BAD_ALLOC */
{
int res = ctxt->Register(processIdentity);
if(0 != res)
{
delete ctxt;
return res;
}
}
*ptoken = ctxt;
return 0;
}
PANTHEIOS_CALL(int) pantheios_be_logEntry(
void* feToken
, void* beToken
, int severity
, PAN_CHAR_T const* entry
, size_t cchEntry
)
{
pan_lr_tokens_t* tokens = (pan_lr_tokens_t*)beToken;
int r1;
int r2;
/* Pre-condition testing. */
PANTHEIOS_CONTRACT_ENFORCE_PRECONDITION_PARAMS_API(NULL != tokens, "back-end token pointer may not be null");
r1 = pantheios_fe_isSeverityLogged(feToken, severity, PANTHEIOS_BEID_LOCAL)
? pantheios_be_local_logEntry(feToken, tokens->localToken, severity, entry, cchEntry)
: 0;
r2 = pantheios_fe_isSeverityLogged(feToken, severity, PANTHEIOS_BEID_REMOTE)
? pantheios_be_remote_logEntry(feToken, tokens->remoteToken, severity, entry, cchEntry)
: 0;
/* Remote is given priority in failure stakes. It's probably of little significance,
* but a choice was demanded.
*/
if(r2 < 0)
{
return r2;
}
else if(r1 < 0)
{
return r1;
}
else
{
return r2;
}
}
int WindowsMessageBox_Context::ReportEvent(
int severity
, pan_char_t const* entry
, size_t cchEntry
)
{
HWND hwnd = NULL;
UINT type = MB_OK;
PANTHEIOS_CONTRACT_ENFORCE_PRECONDITION_PARAMS_API(0 == (severity & 0x08), "be.WindowsMessageBox can only be used with the stock severity levels in the range [0, 8). Levels in the range [8, 16) are not allowed");
switch(severity & 0x0f)
{
case PANTHEIOS_SEV_EMERGENCY:
case PANTHEIOS_SEV_ALERT:
case PANTHEIOS_SEV_CRITICAL:
case PANTHEIOS_SEV_ERROR:
type |= MB_ICONERROR;
break;
case PANTHEIOS_SEV_WARNING:
type |= MB_ICONWARNING;
break;
case PANTHEIOS_SEV_NOTICE:
case PANTHEIOS_SEV_INFORMATIONAL:
case PANTHEIOS_SEV_DEBUG:
type |= MB_ICONINFORMATION;
break;
default:
type |= MB_ICONINFORMATION;
break;
}
pan_MessageBox_(hwnd, entry, m_processIdentity, type);
return static_cast<int>(cchEntry);
}
PANTHEIOS_CALL(int) pantheios_be_WindowsSyslog_parseArgs(
size_t numArgs
, pan_slice_t* const args
, pan_be_WindowsSyslog_init_t* init
)
{
PANTHEIOS_CONTRACT_ENFORCE_PRECONDITION_PARAMS_API((NULL != args || 0 == numArgs), "argument pointer must be non-null, or number of arguments must be 0");
PANTHEIOS_CONTRACT_ENFORCE_PRECONDITION_PARAMS_API(NULL != init, "initialisation structure pointer may not be null");
pantheios_be_WindowsSyslog_getDefaultAppInit(init);
// 1. Parse the stock arguments
int res = pantheios_be_parseStockArgs(numArgs, args, &init->flags);
if(res >= 0)
{
pan_slice_t address;
pan_slice_t port;
pan_slice_t facility;
// 2.a Parse the custom argument: "address"
res = pantheios_be_parseStringArg(numArgs, args, PANTHEIOS_LITERAL_STRING("address"), &address);
if(res > 0)
{
if(address.len > sizeof(init->hostNameBuff) - 1)
{
res = PANTHEIOS_BE_INIT_RC_ARGUMENT_TOO_LONG;
}
else
{
::memcpy(&init->hostNameBuff[0], address.ptr, sizeof(pan_char_t) * STLSOFT_NUM_ELEMENTS(init->hostNameBuff));
init->hostNameBuff[address.len] = '\0';
init->hostName = &init->hostNameBuff[0];
init->addrSize = 0;
}
}
if(res >= 0)
{
// 2.b Parse the custom argument: "port"
res = pantheios_be_parseStringArg(numArgs, args, PANTHEIOS_LITERAL_STRING("port"), &port);
if(res > 0)
{
char sz[21];
int portNum;
::memcpy(&sz[0], port.ptr, stlsoft::minimum(port.len, sizeof(pan_char_t) * STLSOFT_NUM_ELEMENTS(sz) - 1));
sz[stlsoft::minimum(port.len, STLSOFT_NUM_ELEMENTS(sz) - 1)] = '\0';
portNum = ::atoi(sz);
if( portNum > 0 &&
portNum < 65536)
{
init->port = static_cast<pan_uint16_t>(portNum);
}
else
{
res = PANTHEIOS_BE_INIT_RC_ARGUMENT_OUT_OF_RANGE;
}
}
}
if(res >= 0)
{
// 2.b Parse the custom argument: "facility"
res = pantheios_be_parseStringArg(numArgs, args, PANTHEIOS_LITERAL_STRING("facility"), &facility);
if(res > 0)
{
char sz[21];
int facilityNum;
::memcpy(&sz[0], facility.ptr, stlsoft::minimum(facility.len, sizeof(pan_char_t) * STLSOFT_NUM_ELEMENTS(sz) - 1));
sz[stlsoft::minimum(facility.len, STLSOFT_NUM_ELEMENTS(sz) - 1)] = '\0';
facilityNum = ::atoi(sz);
if( facilityNum >= 0 &&
facilityNum < 24)
{
init->facility = static_cast<pan_uint8_t>(facilityNum);
}
else
{
res = PANTHEIOS_BE_INIT_RC_ARGUMENT_OUT_OF_RANGE;
}
}
}
}
if(res >= 0)
{
// 2.d Parse the custom argument: "useStderr"
res = pantheios_be_parseBooleanArg(numArgs, args, PANTHEIOS_LITERAL_STRING("useStderr"), false, PANTHEIOS_BE_WINDOWSSYSLOG_F_PERROR, &init->flags);
}
if(res >= 0)
{
// 2.e Parse the custom argument: "useConsole"
res = pantheios_be_parseBooleanArg(numArgs, args, PANTHEIOS_LITERAL_STRING("useConsole"), false, PANTHEIOS_BE_WINDOWSSYSLOG_F_CONS, &init->flags);
}
if(res >= 0)
{
// 2.f Parse the custom argument: "showPid"
res = pantheios_be_parseBooleanArg(numArgs, args, PANTHEIOS_LITERAL_STRING("showPid"), false, PANTHEIOS_BE_WINDOWSSYSLOG_F_PID, &init->flags);
}
if(res >= 0)
{
// 2.g Parse the custom argument: "connectImmediately"
res = pantheios_be_parseBooleanArg(numArgs, args, PANTHEIOS_LITERAL_STRING("connectImmediately"), false, PANTHEIOS_BE_WINDOWSSYSLOG_F_NDELAY, &init->flags);
}
return res;
}
static int pantheios_be_WindowsSyslog_logEntry_a_(
void* feToken
, void* beToken
, int severity
, char const* entry
, size_t cchEntry
)
{
STLSOFT_SUPPRESS_UNUSED(feToken);
PANTHEIOS_CONTRACT_ENFORCE_PRECONDITION_PARAMS_API(NULL != beToken, "back-end token must be non-null");
static const char tm_fmt[] = "%b %d %I:%M:%S";
# ifdef PANTHEIOS_USING_SAFE_STR_FUNCTIONS
static errno_t (*fns[2])(struct tm*, const time_t*) = { ::localtime_s, ::gmtime_s };
# else /* ? PANTHEIOS_USING_SAFE_STR_FUNCTIONS */
static struct tm* (*fns[2])(const time_t*) = { ::localtime, ::gmtime };
# endif /* PANTHEIOS_USING_SAFE_STR_FUNCTIONS */
WindowsSysLog_Context* ctxt = static_cast<WindowsSysLog_Context*>(beToken);
char szPri_[6];
char* szPri;
char szTime[31];
const int priority = (ctxt->facility * 8) + (severity % 8); /* This stock back-end ignores any custom severity information. */
time_t t = time(NULL);
# ifdef PANTHEIOS_USING_SAFE_STR_FUNCTIONS
struct tm tm_;
struct tm* tm = &tm_;
errno_t err = fns[0 != (ctxt->flags & PANTHEIOS_BE_WINDOWSSYSLOG_F_USE_SYSTEM_TIME)](tm, &t);
if(0 != err)
{
char msg[1001];
if(0 != ::strerror_s(&msg[0], STLSOFT_NUM_ELEMENTS(msg), err))
{
msg[0] = '\0';
}
pantheios_onBailOut3(pantheios::critical, "failed to elicit time", msg);
return 0;
}
# else /* ? PANTHEIOS_USING_SAFE_STR_FUNCTIONS */
struct tm* tm = fns[0 != (ctxt->flags & PANTHEIOS_BE_WINDOWSSYSLOG_F_USE_SYSTEM_TIME)](&t);
# endif /* PANTHEIOS_USING_SAFE_STR_FUNCTIONS */
size_t cchPriority;
size_t cchTime;
size_t cchTotal;
PANTHEIOS_CONTRACT_ENFORCE_ASSUMPTION(priority < 1000);
szPri = pri_print_(&szPri_[0], STLSOFT_NUM_ELEMENTS(szPri_), priority, cchPriority);
cchTime = ::strftime(&szTime[0], STLSOFT_NUM_ELEMENTS(szTime), tm_fmt, tm);
cchTotal = cchPriority + cchTime + 1 + ctxt->cchHostIdentity + 1 + ctxt->cchProcessIdentity + 1 + cchEntry;
buffer_a_t buffer(1 + cchTotal);
#ifndef STLSOFT_CF_THROW_BAD_ALLOC
if(0 == buffer.size())
{
return PANTHEIOS_INIT_RC_OUT_OF_MEMORY;
}
else
#endif /* !STLSOFT_CF_THROW_BAD_ALLOC */
{
// === "%s%s %s %s %s", szPri, szTime, ctxt->hostIdentity, ctxt->processIdentity, entry
size_t cchWritten = 0;
char* p = &buffer[0];
::memcpy(p, szPri, cchPriority * sizeof(char));
cchWritten += cchPriority;
p += cchPriority;
::memcpy(p, szTime, cchTime * sizeof(char));
cchWritten += cchTime;
p += cchTime;
*p++ = ' ';
++cchWritten;
::memcpy(p, ctxt->hostIdentity, ctxt->cchHostIdentity * sizeof(char));
cchWritten += ctxt->cchHostIdentity;
p += ctxt->cchHostIdentity;
*p++ = ' ';
++cchWritten;
::memcpy(p, ctxt->processIdentity, ctxt->cchProcessIdentity * sizeof(char));
cchWritten += ctxt->cchProcessIdentity;
p += ctxt->cchProcessIdentity;
*p++ = ' ';
++cchWritten;
::memcpy(p, entry, cchEntry * sizeof(char));
cchWritten += cchEntry;
p += cchEntry;
PANTHEIOS_CONTRACT_ENFORCE_ASSUMPTION(cchWritten == size_t(p - buffer.data()));
PANTHEIOS_CONTRACT_ENFORCE_ASSUMPTION(cchWritten == cchTotal);
STLSOFT_SUPPRESS_UNUSED(p);
return ::send(ctxt->sk, buffer.data(), (int)cchWritten, 0);
}
}
static int pantheios_be_WindowsSyslog_init_a_(
char const* processIdentity
, int id
, pan_be_WindowsSyslog_init_t const* init
, void* reserved
, void** ptoken
)
{
WindowsSysLog_Context* ctxt = static_cast<WindowsSysLog_Context*>(::calloc(1, sizeof(WindowsSysLog_Context)));
PANTHEIOS_CONTRACT_ENFORCE_PRECONDITION_PARAMS_API(NULL != processIdentity, "process identity may not be the null string");
PANTHEIOS_CONTRACT_ENFORCE_PRECONDITION_PARAMS_API('\0' != 0[processIdentity], "process identity may not be the empty string");
STLSOFT_SUPPRESS_UNUSED(reserved);
PANTHEIOS_CONTRACT_ENFORCE_PRECONDITION_PARAMS_API(NULL != ptoken, "token pointer may not be null");
*ptoken = NULL;
if(NULL == ctxt)
{
return PANTHEIOS_INIT_RC_OUT_OF_MEMORY;
}
else if(NULL != ::strpbrk(processIdentity, " \t\r\n\b\v"))
{
return PANTHEIOS_BE_INIT_RC_INVALID_PROCESSID;
}
else
{
WSADATA wsadata;
pan_be_WindowsSyslog_init_t init_;
struct sockaddr_in addr_in;
const unsigned long ADDR_BROADCAST = INADDR_BROADCAST;
BOOL bBroadcast = TRUE;
if(0 != ::WSAStartup(0x0202, &wsadata))
{
goto error_startup;
}
/* (i) apply Null Object (Variable) pattern */
if(NULL == init)
{
pantheios_be_WindowsSyslog_getDefaultAppInit(&init_);
#ifdef PANTHEIOS_BE_USE_CALLBACK
pantheios_be_WindowsSyslog_getAppInit(id, &init_);
#endif /* PANTHEIOS_BE_USE_CALLBACK */
init = &init_;
}
ctxt->id = id;
ctxt->flags = init->flags;
memset(&addr_in, 0, sizeof(addr_in));
if( 0 == init->addrSize &&
NULL != init->hostName)
{
unsigned long addr = ::inet_addr(init->hostName);
struct hostent* he;
if( INADDR_BROADCAST == addr &&
0 != ::strcmp(init->hostName, "255.255.255.255") &&
NULL != (he = ::gethostbyname(init->hostName)))
{
memcpy(&addr_in.sin_addr, he->h_addr, he->h_length);
}
else
{
memcpy(&addr_in.sin_addr, &addr, sizeof(addr));
}
}
else
{
switch(init->addrSize)
{
case 16:
default:
OutputDebugStringA("Invalid/unsupported address size: currently only 4 (IPv4) is supported\n");
memcpy(&addr_in.sin_addr, &ADDR_BROADCAST, sizeof(ADDR_BROADCAST));
break;
case 4:
addr_in.sin_addr.S_un.S_un_b.s_b1 = init->bytes[0];
addr_in.sin_addr.S_un.S_un_b.s_b2 = init->bytes[1];
addr_in.sin_addr.S_un.S_un_b.s_b3 = init->bytes[2];
addr_in.sin_addr.S_un.S_un_b.s_b4 = init->bytes[3];
if(addr_in.sin_addr.s_addr != 0xffffffff)
{
bBroadcast = FALSE;
}
break;
}
}
addr_in.sin_family = AF_INET;
addr_in.sin_port = ::htons(init->port);
ctxt->sk = ::socket(AF_INET, SOCK_DGRAM, 0);
if(stlsoft_static_cast(SOCKET, SOCKET_ERROR) == ctxt->sk)
{
goto error_sock;
}
ctxt->processIdentity = pantheios_util_strdup_nothrow_m(processIdentity);
if(NULL == ctxt->processIdentity)
{
goto error_procId;
}
ctxt->cchProcessIdentity = ::strlen(ctxt->processIdentity);
ctxt->hostIdentity = pan_make_hostIdentity_();
if(NULL == ctxt->hostIdentity)
{
goto error_hostId;
}
ctxt->cchHostIdentity = ::strlen(ctxt->hostIdentity);
if(bBroadcast)
{
::setsockopt(ctxt->sk, SOL_SOCKET, SO_BROADCAST, (char const*)&bBroadcast, sizeof(bBroadcast));
}
if(SOCKET_ERROR == ::connect(ctxt->sk, (struct sockaddr const*)&addr_in, sizeof(addr_in)))
{
goto error_connect;
}
ctxt->facility = static_cast<unsigned char>(init->facility % 124); // Any more than 124 will overflow priority of <999>
*ptoken = ctxt;
return PANTHEIOS_INIT_RC_SUCCESS;
// NOTE: This goto lark is a vestige of the original C implementation.
error_connect:
pantheios_util_strfree_m(ctxt->hostIdentity);
error_hostId:
pantheios_util_strfree_m(ctxt->processIdentity);
error_procId:
::closesocket(ctxt->sk);
error_sock:
::WSACleanup();
error_startup:
::free(ctxt);
return PANTHEIOS_INIT_RC_UNSPECIFIED_FAILURE;
}
}
pantheios_be_init(
PAN_CHAR_T const* processIdentity
, void* reserved
, void** ptoken
)
{
size_t const numBackEnds = pantheios_be_N_countBackEnds_();
size_t n;
size_t numSucceeded = 0;
int res;
pan_be_N_t* terminalBackEnd = &PAN_BE_N_BACKEND_LIST[numBackEnds];
STLSOFT_SUPPRESS_UNUSED(reserved);
PANTHEIOS_CONTRACT_ENFORCE_PRECONDITION_PARAMS_API(NULL != ptoken, "token pointer may not be null");
*ptoken = NULL;
if(0 == numBackEnds)
{
res = PANTHEIOS_BE_INIT_RC_NO_BACKENDS_SPECIFIED;
}
else
{
res = 0;
for(n = 0; n < numBackEnds; ++n)
{
pan_be_N_t* backEnd = &PAN_BE_N_BACKEND_LIST[n];
PANTHEIOS_CONTRACT_ENFORCE_STATIC_DATA_APPL_DEF(0 != backEnd->backEndId, "be.N requires non-0 backEndId for all back-ends");
if(-1 == backEnd->backEndId)
{
backEnd->backEndId = pantheios_getNextBackEndId();
}
if( PANTHEIOS_BE_N_F_INIT_ONLY_IF_PREVIOUS_FAILED == (PANTHEIOS_BE_N_F_INIT_ONLY_IF_PREVIOUS_FAILED & backEnd->flags) &&
0 != numSucceeded)
{
backEnd->flags |= PANTHEIOS_BE_N_F_IGNORE_INIT_FAILURE;
continue;
}
else
{
res = (*backEnd->pfnInit)(processIdentity, backEnd->backEndId, NULL, NULL, &backEnd->token);
}
if(0 == res)
{
/* Initialisation of the given back-end has succeeded, so
* remove PANTHEIOS_BE_N_F_IGNORE_INIT_FAILURE, if present.
*/
backEnd->flags &= ~(PANTHEIOS_BE_N_F_IGNORE_INIT_FAILURE);
++numSucceeded;
if(terminalBackEnd->severityCeiling < backEnd->severityCeiling)
{
terminalBackEnd->severityCeiling = backEnd->severityCeiling;
}
}
else
{
if(PANTHEIOS_BE_N_F_IGNORE_INIT_FAILURE & backEnd->flags)
{
/* Ignore failure. */
res = 0;
}
else
{
break;
}
}
}
if(0 != res)
{
for(; 0 != n; --n)
{
pan_be_N_t* backEnd = &PAN_BE_N_BACKEND_LIST[n - 1];
if(PANTHEIOS_BE_N_F_IGNORE_INIT_FAILURE & backEnd->flags)
{
/* Was not initialised. */
}
else
{
(*backEnd->pfnUninit)(backEnd->token);
}
}
}
else if(0 == numSucceeded)
{
res = PANTHEIOS_BE_INIT_RC_ALL_BACKEND_INITS_FAILED;
}
}
return res;
}
int pantheios_be_speech_init__cpp(
pan_char_t const* processIdentity
, int backEndId
, pan_be_speech_init_t const* init
, void* reserved
, void** ptoken
)
#endif /* _PANTHEIOS_COMPILER_REQUIRES_EXTERNCPP_DEFINITIONS */
{
STLSOFT_SUPPRESS_UNUSED(reserved);
PANTHEIOS_CONTRACT_ENFORCE_PRECONDITION_PARAMS_API(NULL != ptoken, "token pointer may not be null");
#ifdef STLSOFT_CF_EXCEPTION_SUPPORT
try
{
#endif /* STLSOFT_CF_EXCEPTION_SUPPORT */
/* (i) apply Null Object (Variable) pattern */
pan_be_speech_init_t init_;
if(NULL == init)
{
pantheios_be_speech_getDefaultAppInit(&init_);
init = &init_;
#ifdef PANTHEIOS_BE_USE_CALLBACK
pantheios_be_speech_getAppInit(backEndId, &init_);
#endif /* PANTHEIOS_BE_USE_CALLBACK */
}
/* (ii) verify the version */
if(init->version < 0x010001b8)
{
return PANTHEIOS_BE_INIT_RC_OLD_VERSION_NOT_SUPPORTED;
}
else if(init->version > PANTHEIOS_VER)
{
return PANTHEIOS_BE_INIT_RC_FUTURE_VERSION_REQUESTED;
}
/* (iii) create the context */
*ptoken = NULL;
comstl::com_initializer coinit;
be_speech_context::voice_type voice;
HRESULT hr = comstl::co_create_instance(CLSID_SpVoice, voice);
if(E_OUTOFMEMORY == hr)
{
return PANTHEIOS_INIT_RC_OUT_OF_MEMORY;
}
else if(FAILED(hr))
{
std::string msg("Failed to create the speech server component: ");
msg += winstl::error_desc_a(hr).c_str();
pantheios_onBailOut3(PANTHEIOS_SEV_CRITICAL, msg.c_str(), NULL);
return PANTHEIOS_INIT_RC_UNSPECIFIED_EXCEPTION;
}
else
{
be_speech_context* ctxt = new be_speech_context(processIdentity, backEndId, init->flags, voice);
if(NULL == ctxt)
{
return PANTHEIOS_INIT_RC_UNSPECIFIED_EXCEPTION;
}
*ptoken = ctxt;
return 0;
}
#ifdef STLSOFT_CF_EXCEPTION_SUPPORT
}
catch(std::bad_alloc&)
{
return PANTHEIOS_INIT_RC_OUT_OF_MEMORY;
}
catch(std::exception&)
{
return PANTHEIOS_INIT_RC_UNSPECIFIED_EXCEPTION;
}
#endif /* STLSOFT_CF_EXCEPTION_SUPPORT */
}
void slice_inserter::construct_()
{
PANTHEIOS_CONTRACT_ENFORCE_PRECONDITION_PARAMS_API(0u == m_buffer.size(), "cannot construct if value is non-empty");
pan_slice_t slices[7];
pan_slice_t const equals(-1, (NULL != m_equals) ? m_equals : PANTHEIOS_LITERAL_STRING("="));
pan_char_t num[21];
slices[0] = pan_slice_t(-1, m_strName); // 0: str name
slices[2] = pan_slice_t(m_str, m_len); // 2: str
slices[4] = pan_slice_t(-1, m_lenName); // 4: len name
if(0u != slices[0].len)
{
slices[1] = equals; // 1: equals (for str)
}
if(0u != slices[4].len)
{
pan_char_t const* separator = (NULL != m_separator) ? m_separator : PANTHEIOS_LITERAL_STRING(", ");
slices[3] = pan_slice_t(-1, separator); // 3: separator
slices[5] = equals; // 5: equals (for len)
size_t lenLen;
pan_char_t const* lenPtr = stlsoft::integer_to_string(&num[0], STLSOFT_NUM_ELEMENTS(num), m_len, &lenLen);
slices[6] = pan_slice_t(lenPtr, lenLen);
}
// calc buffer size, resize, and write all slices into buffer
#if !defined(STLSOFT_COMPILER_IS_BORLAND)
const size_t n = std::accumulate( stlsoft::member_selector(slices, &pan_slice_t::len)
, stlsoft::member_selector(slices + STLSOFT_NUM_ELEMENTS(slices), &pan_slice_t::len)
, size_t(0));
#else /* ? compiler */
// The crappy way, for less-than compilers
size_t n = 0;
{ for(size_t i = 0; i != STLSOFT_NUM_ELEMENTS(slices); ++i)
{
n += slices[i].len;
}}
#endif /* compiler */
m_buffer.resize(n);
size_t nWritten = 0;
std::copy( slices
, slices + STLSOFT_NUM_ELEMENTS(slices)
, stlsoft::cstring_concatenator(&m_buffer[0], &nWritten));
PANTHEIOS_CONTRACT_ENFORCE_POSTCONDITION_RETURN_INTERNAL(nWritten == n, "Written length differs from allocated length");
PANTHEIOS_CONTRACT_ENFORCE_PRECONDITION_PARAMS_API(0 != m_buffer[0], "failed to set value to non-empty");
}
void pointer::construct_()
{
PANTHEIOS_CONTRACT_ENFORCE_PRECONDITION_PARAMS_API(0 == m_sz[0], "cannot construct if value is non-empty");
PANTHEIOS_CONTRACT_ENFORCE_PRECONDITION_PARAMS_API(0 == m_len, "cannot construct if length is non-0");
if(static_cast<void const*>(0) == m_value)
{
static const pan_char_t s_null[] = PANTHEIOS_LITERAL_STRING("(null)");
STLSOFT_STATIC_ASSERT(sizeof(m_sz) >= sizeof(s_null));
::memcpy(&m_sz[0], &s_null[0], sizeof(s_null));
m_len = STLSOFT_NUM_ELEMENTS(s_null) - 1;
}
else
{
pan_char_t szFmt[101];
int width;
pan_char_t const* zeroX;
pan_char_t const* leadingMinus;
pan_char_t const* zeroPad;
if(m_minWidth < 0)
{
width = -m_minWidth;
leadingMinus = PANTHEIOS_LITERAL_STRING("-");
}
else
{
width = m_minWidth;
leadingMinus = PANTHEIOS_LITERAL_STRING("");
}
zeroX = (m_format & fmt::zeroXPrefix) ? PANTHEIOS_LITERAL_STRING("0x") : PANTHEIOS_LITERAL_STRING("");
zeroPad = (m_format & fmt::zeroPad) ? PANTHEIOS_LITERAL_STRING("0") : PANTHEIOS_LITERAL_STRING("");
if( 0 != width &&
fmt::zeroXPrefix == (m_format & (fmt::zeroXPrefix | fmt::zeroPad)))
{
// Special case
pan_char_t szTemp[23]; // 23 is always big enough, since the width is 21
PANTHEIOS_CONTRACT_ENFORCE_ASSUMPTION(0 == (m_format & fmt::zeroPad));
// Determine ptr-sized integer type
#if defined(STLSOFT_COMPILER_IS_GCC)
typedef unsigned long intptr_t_;
#else /* ? compiler */
typedef stlsoft::int_size_traits<sizeof(void*)>::unsigned_type intptr_t_;
#endif /* compiler */
int r = pantheios_util_snprintf(
&szTemp[0]
, STLSOFT_NUM_ELEMENTS(szTemp)
, PANTHEIOS_LITERAL_STRING("0x%lx")
, static_cast<intptr_t_>(stlsoft::union_cast<intptr_t_>(m_value))
);
if(r < 0)
{
return;
}
else
{
size_t n = static_cast<size_t>(r);
PANTHEIOS_CONTRACT_ENFORCE_POSTCONDITION_RETURN_INTERNAL((n + 2) <= STLSOFT_NUM_ELEMENTS(szTemp), "snprintf() overwrote the local buffer capacity");
width += 2;
if(static_cast<size_t>(width) > n)
{
if(m_minWidth < 0)
{
PANTHEIOS_char_copy(&m_sz[0], szTemp, n);
std::fill_n(&m_sz[0] + n, size_t(width - n), ' ');
m_sz[width] = '\0';
}
else
{
std::fill_n(&m_sz[0], size_t(width - n), ' ');
PANTHEIOS_char_copy(&m_sz[0] + (size_t(width) - n), szTemp, (n + 1));
}
m_len = static_cast<size_t>(width);
}
else
{
PANTHEIOS_char_copy(&m_sz[0], szTemp, (n + 1));
m_len = n;
}
}
}
else
{
pantheios_util_snprintf(&szFmt[0]
, STLSOFT_NUM_ELEMENTS(szFmt)
, PANTHEIOS_LITERAL_STRING("%s%%%s%s%dx")
, zeroX
, leadingMinus
, zeroPad
, width);
m_len = static_cast<size_t>(pantheios_util_snprintf(&m_sz[0], STLSOFT_NUM_ELEMENTS(m_sz), szFmt, m_value));
}
}
PANTHEIOS_CONTRACT_ENFORCE_PRECONDITION_PARAMS_API(0 != m_sz[0], "failed to set value to non-empty");
PANTHEIOS_CONTRACT_ENFORCE_PRECONDITION_PARAMS_API(m_len > 0, "failed to set length");
PANTHEIOS_CONTRACT_ENFORCE_PRECONDITION_PARAMS_API(m_len < 23, "pantheios::pointer string too long");
}
PANTHEIOS_CALL(void) pantheios_be_speech_uninit(void* token)
{
PANTHEIOS_CONTRACT_ENFORCE_PRECONDITION_PARAMS_API(NULL != token, "token must be non-null");
delete static_cast<be_speech_context*>(token);
}
