std::string GetStdStringFromAITextFrame(AIArtHandle textFrame) {
short type = 0;
sAIArt->GetArtType(textFrame, &type);
if ( type == kTextFrameArt ) {
ATE::TextRangeRef currRangeRef = NULL;
sAITextFrame->GetATETextRange(textFrame, &currRangeRef);
ATE::ITextRange currRange(currRangeRef);
int size = currRange.GetSize();
char* buffer = new char[size];
currRange.GetContents(buffer, size);
buffer[size] = '\0';
string sbuffer(buffer);
delete[] buffer;
return sbuffer;
} else {
return NULL;
}
}
CSmartPtr<CLoopBuffer> COfRecvWorker::createRecvBuffer(INT4 sockfd)
{
#if 0
CSmartPtr<CLoopBuffer>* recvBuffer = m_recvBuffers.find(sockfd);
if (NULL == recvBuffer)
#else
CSmartPtr<CLoopBuffer>& recvBuffer = m_recvBuffer[sockfd];
if (recvBuffer.isNull())
#endif
{
CLoopBuffer* buffer = new CLoopBuffer(recv_buffer_size);
if (NULL == buffer)
{
LOG_ERROR_FMT("new CLoopBuffer with %u buffer size failed !", recv_buffer_size);
return CSmartPtr<CLoopBuffer>(NULL);
}
#if 0
CSmartPtr<CLoopBuffer> sbuffer(buffer);
recvBuffer = m_recvBuffers.insert(sockfd, sbuffer);
if (NULL == recvBuffer)
{
LOG_WARN_FMT("CHashMap insert CSmartPtr<CLoopBuffer> failed !");
return CSmartPtr<CLoopBuffer>(NULL);
}
#else
recvBuffer = CSmartPtr<CLoopBuffer>(buffer);
#endif
}
else
{
recvBuffer->reset();
}
return recvBuffer;
}
static void tioServer(void) {
Create(TIO_NOTIFIER_PRIORITY, tioNotifier);
int rx_tid = -1;
struct String rx_buffer;
sinit(&rx_buffer);
while (true) {
int tid;
struct String req;
sinit(&req);
if (g_tio_quit) {
break;
}
Receive(&tid, (char *) &req, sizeof(struct String));
switch (stag(&req)) {
default:
assert(0);
case CMD_NOTIFIER_RX:
sconcat(&rx_buffer, &req);
Reply(tid, (char *) 0, 0);
break;
case CMD_USER_TX: {
char *buf = sbuffer(&req);
for (unsigned int i = 0; i < slen(&req); ++i) {
g_tio_tx_buffer.buffer[g_tio_tx_buffer.tail] = buf[i];
g_tio_tx_buffer.tail =
(g_tio_tx_buffer.tail + 1) % TIO_TX_BUFFER_LEN;
}
Reply(tid, (char *) 0, 0);
/* raise a software interrupt to inform the notifier */
*((volatile unsigned int *)
(SOFTINT_BASE + VIC_SOFTWARE_INT)) = SOFTINT_POS;
break;
}
case CMD_USER_RX:
assert(rx_tid == -1);
rx_tid = tid;
break;
case CMD_QUIT:
g_tio_quit = true;
Reply(tid, (char *) 0, 0);
/* raise a software interrupt to quit the notifier */
*((volatile unsigned int *)
(SOFTINT_BASE + VIC_SOFTWARE_INT)) = SOFTINT_POS;
break;
}
if (slen(&rx_buffer) > 0 && rx_tid >= 0) {
Reply(rx_tid, (char *) &rx_buffer, sizeof(struct String));
sinit(&rx_buffer);
rx_tid = -1;
}
}
Exit();
}
void SslSocketCpServer::Dispatch(HttpRequest *httpRequest, HttpResponse *httpResponse)
{
if (httpRequest->GetMethod() == MethodType::HTTP_GET)
{
EvalGet(httpRequest, httpResponse);
}
if (httpRequest->GetMethod() == MethodType::HTTP_POST)
{
EvalPost(httpRequest, httpResponse);
}
if (IsStatic(httpRequest->GetUrl()))
{
printf("Static Directory\n");
EvalStatic(httpRequest, httpResponse);
return;
}
if (HasUrlParams(httpRequest->GetUrl()))
{
printf("Has URL Params\n");
LPSTATICFUNC lpFunc = (LPSTATICFUNC)GetUrlParamHandler(httpRequest->GetUrl());
httpRequest->urlParams.assign(urlParams.begin(), urlParams.end());
if (lpFunc != NULL)
{
(*lpFunc)(httpRequest, httpResponse);
}
else
{
UrlNotFound(httpRequest, httpResponse);
}
return;
}
LPSTATICFUNC lpFunc = (LPSTATICFUNC)GetRoute(httpRequest->GetUrl());
if (lpFunc != NULL)
{
(*lpFunc)(httpRequest, httpResponse);
}
else
{
WCHAR buffer[BUFSIZMIN];
char *url = httpRequest->GetUrl();
std::string surl;
surl.append("./");
surl.append(url);
std::wstring wsurl(surl.begin(), surl.end());
DWORD dwres = GetFullPathName(wsurl.c_str(), BUFSIZMIN, buffer, NULL);
if (dwres > 0)
{
PTSTR str = GetPathExtension(buffer);
std::wstring wsbuffer(buffer);
std::string sbuffer(wsbuffer.begin(), wsbuffer.end());
if (FileExist(wsbuffer.c_str()))
{
httpResponse->SetStaticFileName(sbuffer.c_str());
httpResponse->WriteStatic(sbuffer.c_str());
return;
}
else
{
printf("File not found: %s \n", sbuffer.c_str());
}
}
UrlNotFound(httpRequest, httpResponse);
}
}
static void internal_pthread_backtrace(pthread_t thread, void** buffer, size_t max, size_t* depth, size_t skip)
{
*depth = 0;
//! Get information about the stack (pos & size).
uint8_t* stackbot;
size_t stack_size; //! in bytes
size_t guard_size; //! in bytes
#if defined(__FreeBSD__)
pthread_attr_t attr;
pthread_attr_init(&attr);
pthread_attr_get_np(thread, &attr);
pthread_attr_getstack(&attr, (void**)&stackbot, &stack_size);
pthread_attr_getguardsize(&attr, &guard_size);
pthread_attr_destroy(&attr);
#elif defined(__APPLE__)
stackbot = (uint8_t*)pthread_get_stackaddr_np(thread);
stack_size = pthread_get_stacksize_np(thread);
guard_size = 0; //FIXME anyway to get that?
#else
pthread_attr_t attr;
pthread_getattr_np(thread, &attr);
pthread_attr_getstack(&attr, (void**)&stackbot, &stack_size);
pthread_attr_getguardsize(&attr, &guard_size);
pthread_attr_destroy(&attr);
#endif
stack_size -= guard_size;
//! The thread is is still running!!!
//! So make a buffer copy of the stack, else it gets changed while we reading from it!
std::vector<uint8_t> sbuffer(stack_size);
uint8_t* stack_buffer = &sbuffer[0];
memcpy(stack_buffer, stackbot, stack_size);
//! It is impossible to get the current frame (the current function pos) on the stack
//! for other pthreads, so we need to find it ourself. The beneath method is very naive
//! and just searchs for the starting address that gives us the longest stackdepth.
unsigned longest_stack = 0;
unsigned longest_offset = 0;
int check_area = MAX(0, stack_size - 1024*sizeof(uintptr_t));
check_area *= 0.8f; //! only check ~20% from the top of the stack
for (int offset = stack_size - sizeof(uintptr_t); offset >= check_area; offset -= sizeof(uintptr_t)) {
unsigned stack_depth = 0;
uint8_t* frame = stack_buffer + offset;
frame = TranslateStackAddrToBufferAddr(frame, stackbot, stack_buffer);
uint8_t* last_frame = frame;
while (INSTACK(frame) && (frame > last_frame)) {
last_frame = frame;
frame = TranslateStackAddrToBufferAddr(frame, stackbot, stack_buffer);
stack_depth++;
}
if (stack_depth > longest_stack) {
longest_stack = stack_depth;
longest_offset = offset;
}
}
//! Now get the list of function addresses from the stack.
uint8_t* frame = stack_buffer + longest_offset;
if(!INSTACK(frame))
return;
while (skip--) {
uint8_t* next = TranslateStackAddrToBufferAddr(frame, stackbot, stack_buffer);
if(!INSTACK(next))
return;
frame = next;
}
while (max--) {
uint8_t* next = TranslateStackAddrToBufferAddr(frame, stackbot, stack_buffer);
buffer[*depth] = (void*)*((uintptr_t*)frame + FP_OFFSET);
(*depth)++;
if(!INSTACK(next))
return;
frame = next;
}
}
