PANTHEIOS_CALL(int) pantheios_be_init(
PAN_CHAR_T const* processIdentity
, void* reserved
, void** ptoken
)
{
pan_lr_tokens_t tokens = { NULL, NULL };
int res;
/* Initialise the local first */
res = pantheios_be_local_init(processIdentity, reserved, &tokens.localToken);
if(0 != res)
{
pantheios_onBailOut3(PANTHEIOS_SEV_ALERT, "local back-end did not initialise", NULL);
return res;
}
else
{
res = pantheios_be_remote_init(processIdentity, reserved, &tokens.remoteToken);
if(0 != res)
{
pantheios_onBailOut3(PANTHEIOS_SEV_ALERT, "remote back-end did not initialise", NULL);
pantheios_be_local_uninit(tokens.localToken);
return res;
}
else
{
pan_lr_tokens_t* ptokens = (pan_lr_tokens_t*)malloc(sizeof(pan_lr_tokens_t));
if(NULL == ptokens)
{
pantheios_be_remote_uninit(tokens.remoteToken);
pantheios_be_local_uninit(tokens.localToken);
return PANTHEIOS_INIT_RC_OUT_OF_MEMORY;
}
else
{
*ptokens = tokens;
*ptoken = ptokens;
return 0;
}
}
}
}
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);
}
}
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 */
}