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