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