void CWin32Socket::SendTo(TWin32Message& aMessage) { __ASSERT_DEBUG((iSendMessage == NULL) && (iBytesSent == 0), Panic(EWinSockPrtCWin32SocketMultipleSendToRequests)); iSendMessage = &aMessage; WSP_LOG(WspLog::Printf(_L("CWin32Socket::SendTo: this: 0x%x, bytes to send: %d"), this, iSendMessage->ReadBuffer().Length())); TPtrC8 bufPtr(iSendMessage->ReadBuffer()); iSendBuffer.buf = reinterpret_cast<char*>(const_cast<TUint8*>(bufPtr.Ptr())); iSendBuffer.len = bufPtr.Length(); iSendOverlapped.hEvent = (void*) this; TInetAddr address; address.Copy(iSendMessage->WriteBuffer()); SOCKADDR_IN winSockAddress; ConvertAddress(address, winSockAddress); DWORD numberOfBytesSent; TInt ret = WSASendTo(iSocket, &iSendBuffer, 1, &numberOfBytesSent, 0, (LPSOCKADDR)&winSockAddress, sizeof(struct sockaddr_in), &iSendOverlapped, &SendToCompletion); if (ret == SOCKET_ERROR) { TInt err = WSAGetLastError(); if (err != WSA_IO_PENDING) { WSP_LOG(WspLog::Printf(_L("\tsocket error: %d"), err)); Complete(iSendMessage, MapWinSockError(err)); } } }
void CWin32Socket::Connect(TWin32Message& aMessage) { __ASSERT_DEBUG(iConnectMessage == NULL, Panic(EWinSockPrtCWin32SocketMultipleConnectRequests)); iConnectMessage = &aMessage; WSP_LOG(WspLog::Printf(_L("CWin32Socket::Connect: this: 0x%x"), this)); if (WSAEventSelect(iSocket, iEvent, FD_CONNECT) == SOCKET_ERROR) { TInt err = MapWinSockError(WSAGetLastError()); CloseSocket(); Complete(iConnectMessage, err); return; } const TInetAddr& address = static_cast<const TInetAddr&>(iConnectMessage->ReadBuffer()); SOCKADDR_IN winSockAddress; ConvertAddress(address, winSockAddress); if (WSAConnect(iSocket, (LPSOCKADDR)&winSockAddress, sizeof(struct sockaddr_in), NULL, NULL, NULL, NULL) == SOCKET_ERROR) { TInt nError = WSAGetLastError(); if (nError != WSAEWOULDBLOCK) { CloseSocket(); Complete(iConnectMessage, MapWinSockError(nError)); } } else { Complete(iConnectMessage, KErrNone); } }
void CWin32Socket::Bind(TWin32Message& aMessage) { const TInetAddr& address = static_cast<const TInetAddr&>(aMessage.ReadBuffer()); SOCKADDR_IN winSockAddress; ConvertAddress(address, winSockAddress); if (bind(iSocket, (LPSOCKADDR)&winSockAddress, sizeof(struct sockaddr_in))) { aMessage.Complete(MapWinSockError(WSAGetLastError())); } else { aMessage.Complete(KErrNone); } }
void CWin32Socket::GetPeerName(TWin32Message& aMessage) const { SOCKADDR_IN winSockAddress; TInt length = sizeof(struct sockaddr_in); if (getpeername(iSocket, (LPSOCKADDR)&winSockAddress, &length)) { aMessage.Complete(MapWinSockError(WSAGetLastError())); } else { __ASSERT_DEBUG(length == sizeof(struct sockaddr_in), Panic(EWinSockPrtCWin32SocketGetPeerNameInvalidSocketAddress)); TInetAddr& address = static_cast<TInetAddr&>(aMessage.WriteBuffer()); ConvertAddress(winSockAddress, address); aMessage.Complete(KErrNone); } }
// /// This function sets the network address. // void TINetSocketAddress::SetNetworkAddress(const char* addressDottedDecimal) { SetNetworkAddress(ConvertAddress(addressDottedDecimal)); }
// /// This function constructs an object. All arguments should be in network byte /// ordering. nNewFamily is an enumeration, so there is no specific byte ordering. /// \note The address can also be INADDR_ANY, INADDR_LOOPBACK, INADDR_BROADCAST, or /// INADDR_NONE. /// /// Also note that in Windows Sockets, Microsoft defines these addresses using /// network byte ordering format. Therefore, you don't need to convert to network /// byte ordering upon passing to this function, or when passing to any other /// function that expects network byte ordering. /// /// newPort should be passed in network byte ordering. newAddress is in the /// format of numerical IP addressing (e.g. "132.212.43.1"). It cannot be in /// the form of "user\@place" nFamily is in the form of AF_INET, etc. // TINetSocketAddress::TINetSocketAddress(ushort newPort, const char* newAddressStr, ushort newFamily) { ulong newAddress = ConvertAddress(newAddressStr); SetAddress(newFamily, newPort, newAddress); }
bool Cws_machineEx::doStartStop(IEspContext &context, StringArray& addresses, char* userName, char* password, bool bStop, IEspStartStopResponse &resp) { bool containCluster = false; double version = context.getClientVersion(); const int ordinality= addresses.ordinality(); UnsignedArray threadHandles; IArrayOf<IEspStartStopResult> resultsArray; for (int index=0; index<ordinality; index++) { const char* address0 = addresses.item(index); //address passed in is of the form "192.168.1.4:EspProcess:2:path1" StringArray sArray; sArray.appendList(addresses.item(index), ":"); if (sArray.ordinality() < 4) throw MakeStringException(ECLWATCH_MISSING_PARAMS, "Incomplete arguments"); Owned<IEspStartStopResult> pResult = static_cast<IEspStartStopResult*>(new CStartStopResult("")); const char* address = sArray.item(0); const char* compType= sArray.item(1); const char* OS = sArray.item(3);//index 2 is component name const char* path = sArray.item(4); if (!(address && *address && compType && *compType && OS && *OS && path && *path)) throw MakeStringExceptionDirect(ECLWATCH_INVALID_INPUT, "Invalid input"); if (!stricmp(compType, "ThorCluster") || !stricmp(compType, "RoxieCluster")) containCluster = true; #ifndef OLD_START_STOP { char* configAddress = NULL; char* props1 = (char*) strchr(address, '|'); if (props1) { configAddress = props1+1; *props1 = '\0'; } else { configAddress = (char*) address; } StringBuffer newAddress; ConvertAddress(address0, newAddress); pResult->setAddressOrig ( newAddress.str() );//can be either IP or name of component pResult->setAddress ( address );//can be either IP or name of component pResult->setCompType( compType ); if (version > 1.04) { pResult->setName( path ); const char* pStr2 = strstr(path, "LexisNexis"); if (pStr2) { char name[256]; const char* pStr1 = strchr(pStr2, '|'); if (!pStr1) { strcpy(name, pStr2+11); } else { strncpy(name, pStr2+11, pStr1 - pStr2 -11); name[pStr1 - pStr2 -11] = 0; } pResult->setName( name ); } } pResult->setOS( atoi(OS) ); pResult->setPath( path ); resultsArray.append(*pResult.getLink()); CStartStopThreadParam* pThreadReq; pThreadReq = new CStartStopThreadParam(address, configAddress, bStop, m_useDefaultHPCCInit, this, context); pThreadReq->setResultObject( pResult ); if (userName && *userName) pThreadReq->setUserID( userName ); if (password && *password) pThreadReq->setPassword( password ); PooledThreadHandle handle = m_threadPool->start( pThreadReq ); threadHandles.append(handle); } #else { StringBuffer newAddress; ConvertAddress(address0, newAddress); char* pStr = (char*) strchr(address, '|');; if (pStr) pStr[0] = 0; pResult->setAddressOrig ( newAddress.str() );//can be either IP or name of component pResult->setAddress ( address );//can be either IP or name of component pResult->setCompType( compType ); pResult->setOS( atoi(OS) ); pResult->setPath( path ); resultsArray.append(*pResult.getLink()); CStartStopThreadParam* pThreadReq; pThreadReq = new CStartStopThreadParam(address, bStop, this, context); pThreadReq->setResultObject( pResult ); if (userName && *userName) pThreadReq->setUserID( userName ); if (password && *password) pThreadReq->setPassword( password ); PooledThreadHandle handle = m_threadPool->start( pThreadReq ); threadHandles.append(handle); } #endif } //block for worker theads to finish, if necessary, and then collect results // PooledThreadHandle* pThreadHandle = threadHandles.getArray(); unsigned i=threadHandles.ordinality(); while (i--) { m_threadPool->join(*pThreadHandle, 30000);//abort after 30 secs in remote possibility that the command blocks pThreadHandle++; } resp.setStartStopResults(resultsArray); resp.setStop(bStop); if (version > 1.08) { resp.setContainCluster(containCluster); } return true; }
/// /// \brief Get stack trace /// /// \return Stack trace /// LIBALT_API altStr altRuntime::GetStackTrace() { #ifdef ALT_WIN HANDLE hProcess = ::GetCurrentProcess(); HANDLE hThread = ::GetCurrentThread(); #if 0 DWORD dwOpts = ::SymGetOptions(); ::SymSetOptions (dwOpts | SYMOPT_LOAD_LINES); #endif if (! ::SymInitialize (hProcess, NULL, TRUE)) { return (""); } CONTEXT ctx; ctx.ContextFlags = CONTEXT_FULL; ctx.ContextFlags = CONTEXT_ALL; std::vector<DWORD> vAddrs; if (::GetThreadContext (hThread, & ctx)) { STACKFRAME frame; DWORD dwMachine; memset (& frame, 0x00, sizeof (frame)); frame.AddrPC.Mode = AddrModeFlat; dwMachine = IMAGE_FILE_MACHINE_I386; frame.AddrPC.Offset = ctx.Eip; frame.AddrStack.Offset = ctx.Esp; frame.AddrFrame.Offset = ctx.Ebp; frame.AddrPC.Mode = AddrModeFlat; frame.AddrStack.Mode = AddrModeFlat; frame.AddrFrame.Mode = AddrModeFlat; #if 0 BOOL bRet = SymLoadModule (hProcess, NULL, (PSTR)sImageName.GetCStr(), NULL, 0, 0); #endif for (DWORD dw = 0; dw < 512; dw++) { if (! ::StackWalk (dwMachine, hProcess, hThread, & frame, & ctx, NULL, SymFunctionTableAccess, SymGetModuleBase, NULL)) { break; } if (frame.AddrPC.Offset != 0) { vAddrs.push_back (frame.AddrPC.Offset); } } } altStr sStackTrace; altStr sSym; for (altUInt i = 0; i < vAddrs.size(); i++) { ConvertAddress (hProcess, vAddrs[i], sSym); sStackTrace += sSym; } SymCleanup (hProcess); return (sStackTrace); #endif #ifdef ALT_LINUX void * ar[100]; altInt nSize = 0; altChar ** ppStrings; altStr sStackTrace; nSize = backtrace (ar,100); ppStrings = backtrace_symbols (ar, nSize); for (altInt i = 1; i < nSize; i++) { sStackTrace += "\t"; sStackTrace += ppStrings[i]; sStackTrace += "\n"; } free (ppStrings); return (sStackTrace); #endif }
void DoStackTrace ( LPTSTR szString , DWORD dwSize , DWORD dwNumSkip ) { HANDLE hProcess = GetCurrentProcess ( ) ; // If the symbol engine is not initialized, do it now. if ( FALSE == g_bSymIsInit ) { DWORD dwOpts = SymGetOptions ( ) ; // Turn on load lines. SymSetOptions ( dwOpts | SYMOPT_LOAD_LINES ) ; if ( FALSE == g_cSym.SymInitialize ( hProcess , NULL , FALSE ) ) { //dsi_PrintToConsole("DoStackTrace : Unable to initialize the symbol engine!!!"); } else { g_bSymIsInit = TRUE ; } } // The symbol engine is initialized so do the stack walk. // The array of addresses. ADDRVECTOR vAddrs ; // The thread information. CONTEXT stCtx ; stCtx.ContextFlags = CONTEXT_FULL ; if ( GetThreadContext ( GetCurrentThread ( ) , &stCtx ) ) { STACKFRAME stFrame ; DWORD dwMachine ; ZeroMemory ( &stFrame , sizeof ( STACKFRAME ) ) ; stFrame.AddrPC.Mode = AddrModeFlat ; #ifdef _M_IX86 dwMachine = IMAGE_FILE_MACHINE_I386 ; #else dwMachine = IMAGE_FILE_MACHINE_AMD64; #endif #ifdef _M_IX86 stFrame.AddrPC.Offset = stCtx.Eip ; stFrame.AddrStack.Offset = stCtx.Esp ; #else stFrame.AddrPC.Offset = stCtx.Rip ; stFrame.AddrStack.Offset = stCtx.Rsp ; #endif stFrame.AddrStack.Mode = AddrModeFlat ; #ifdef _M_IX86 stFrame.AddrFrame.Offset = stCtx.Ebp ; #else stFrame.AddrFrame.Offset = stCtx.Rbp ; #endif stFrame.AddrFrame.Mode = AddrModeFlat ; // Loop for the first 512 stack elements. for ( DWORD i = 0 ; i < 512 ; i++ ) { if ( FALSE == StackWalk ( dwMachine , hProcess , hProcess , &stFrame , &stCtx , NULL , SymFunctionTableAccess , GetModBase , NULL ) ) { // [KLS 4/5/02] The optimization bug doesn't occur if you touch the // variable "i" here (e.g., call dsi_PrintToConsole("i = %d", i); ) // ...I love compiler bugs ;) break ; } if ( i > dwNumSkip ) { // Also check that the address is not zero. Sometimes // StackWalk returns TRUE with a frame of zero. if ( 0 != stFrame.AddrPC.Offset ) { vAddrs.push_back ( stFrame.AddrPC.Offset ) ; } } } // Now start converting the addresses. DWORD dwSizeLeft = dwSize ; DWORD dwSymSize ; TCHAR szSym [ MAX_PATH * 2 ] ; LPTSTR szCurrPos = szString ; ADDRVECTOR::iterator loop ; for ( loop = vAddrs.begin ( ) ; loop != vAddrs.end ( ) ; loop++ ) { dwSymSize = ConvertAddress ( *loop , szSym ) ; if ( dwSizeLeft < dwSymSize ) { break ; } _tcscpy ( szCurrPos , szSym ) ; szCurrPos += dwSymSize ; dwSizeLeft -= dwSymSize ; } } }