int CTcpHandler::OnRead(const char *pData, int iLength) { int iNeed = m_pProtocol->Need(pData, iLength); NsqLogPrintf(LOG_DEBUG, "OnRead iNeed = %d", iNeed); if (iLength == 0) { } int i = 0; while (iNeed == 0) { m_pProtocol->Decode(); if (ProcessRead() != 0) { return -1; } m_pProtocol->NextPkg(); iNeed = m_pProtocol->Need(NULL, 0); } return iNeed; }
void SecureBaseServer::HandleHandshake(SecureSocket* nsock, const boost::system::error_code& error){ if(!error) { ProcessRead(nsock, error); }else { delete nsock; } }
int SerialThread::Run() { // Check signal controlling and status to open serial communication. // enter if there is command of openning and port has be closed before. // 先打开 COM1 端口 if (! OpenCOM1Port()) return -1; m_dwToDo = SMS_READ; char *mess = new char[MAX_MESSAGE]; unsigned int lenBuff; unsigned long lenMessage; while(ptrDlg->m_bSMSActiveProccess) { ProcessWrite(); // 别太急,先等等 Sleep(1888); lenMessage = 0; memset(mess, 0, MAX_MESSAGE); lenBuff = MAX_MESSAGE; // ptrDlg->AddErrorInfo("reading"); if (SCC::serialCtl().read_scc(mess,lenBuff,lenMessage)) { if (lenMessage > 0) { ProcessRead(mess); } else // 超时 { // ReadTimeOut(mess); } } else { ptrDlg->m_bSMSActiveProccess = FALSE; } } // while(ptrDlg->activeProccess == TRUE) delete [] mess; return 0; }
void XPump::OnReadEvent(base::Socket *sock) { // Read the socket Assert(sock == sock_); ProcessRead(); // If there are messages, notify that there are messages. This allows the // notifyee to do per-message procesing. if (Peek()) { if (!notify_->OnMessages()) { // OnMessages returning false means execute the default, // which is to dispatch them all. while (Dispatch()) { ; } } } }
void CListener::ProcessSocketMsg(WPARAM wParam, LPARAM lParam) { if (WSAGETSELECTERROR(lParam)) { // Display the error and close the socket CloseConnection(wParam); return; } switch(WSAGETSELECTEVENT(lParam)) { case FD_ACCEPT: { SOCKADDR_IN ClientAddr = {0}; int iLen = sizeof(ClientAddr); accept(wParam, (LPSOCKADDR)&ClientAddr, &iLen); break; } case FD_READ: { // Receive data from the socket in // wParam ProcessRead(wParam); break; } case FD_WRITE: { // The socket in wParam is ready // for sending data break; } case FD_CLOSE: { // The connection is now closed CloseConnection(wParam); break; } } }
int main(int argc, char ** argv) { if(argc < 2) { printf("Usage: init_execve <filename> [args]\n"); return 1; } if (ptrace(PTRACE_ATTACH, INIT_PID, NULL, NULL)) { printf("ERROR: Couldn't attach to /init.\n"); return 1; } wait(NULL); //Why do i need this? void * initBase; unsigned long initSize; ProcessGetCodeSectionInfo(INIT_PID, &initBase, &initSize); if (!initBase || initSize == 0) { printf("ERROR: Couldn't get the image base of /init.\n"); printf("Detaching...\n"); ptrace(PTRACE_DETACH, INIT_PID, NULL, NULL); return 1; } printf("initBase: %X.\n", initBase); printf("initSize: %X.\n", initSize); unsigned char* initCodeSection = new unsigned char[initSize]; ProcessRead(INIT_PID, initBase, initCodeSection, initSize); void * execvePtr = (void *) memfindpos(initCodeSection, initSize, execve_code, sizeof(execve_code)); delete [] initCodeSection; if (((unsigned long) execvePtr) == 0xFFFFFFFF) { printf("ERROR: Failed locating execve.\n"); printf("Detaching...\n"); ptrace(PTRACE_DETACH, INIT_PID, NULL, NULL); return 5; } execvePtr = (void *) (((unsigned long) execvePtr) + ((unsigned long) initBase)); printf("execvePtr: %X\n", execvePtr); struct pt_regs regs; memset(®s, 0, sizeof(regs)); ptrace(PTRACE_GETREGS, INIT_PID, NULL, ®s); printf("R0: %X\n", regs.ARM_r0); printf("R1: %X\n", regs.ARM_r1); printf("R2: %X\n", regs.ARM_r2); printf("R3: %X\n", regs.ARM_r3); printf("R4: %X\n", regs.ARM_r4); printf("R5: %X\n", regs.ARM_r5); printf("R6: %X\n", regs.ARM_r6); printf("R7: %X\n", regs.ARM_r7); printf("R8: %X\n", regs.ARM_r8); printf("R9: %X\n", regs.ARM_r9); printf("R10: %X\n", regs.ARM_r10); printf("FP: %X\n", regs.ARM_fp); // R11 printf("IP: %X\n", regs.ARM_ip); // R12 printf("SP: %X\n", regs.ARM_sp); // R13 printf("LR: %X\n", regs.ARM_lr); // R14 printf("PC: %X\n", regs.ARM_pc); // R15 printf("CPSR: %X\n", regs.ARM_cpsr); // R16 printf("ORIG_R0: %X\n", regs.ARM_ORIG_r0); // R17 pushRegistersToStack(®s); // START - This part is wrong, awful and crap! execvePtr = (void *) (((unsigned long) execvePtr) + sizeof(execve_code)); unsigned long POP_R0_PC = 0xE8DBFFFF; //POP {R0 - PC} - LDMFD SP!, {R0-PC} ProcessWrite(INIT_PID, execvePtr, &POP_R0_PC, 4); //Then execve gets called in /init, it will crash, and kenel will panic. regs.ARM_pc = ((unsigned long) execvePtr); // END - This part is wrong, awful and crap! printf("new PC: %X.\n", regs.ARM_pc); ptrace(PTRACE_SETREGS, INIT_PID, NULL, ®s); printf("Detaching...\n"); ptrace(PTRACE_DETACH, INIT_PID, NULL, NULL); return 0; }
/*------------------------------------------------------------------------------ -- FUNCTION: ReadFromPort -- -- DATE: Nov 29, 2010 -- -- REVISIONS: (Date and Description) -- -- DESIGNER: Dean Morin -- -- PROGRAMMER: Dean Morin -- -- INTERFACE: VOID ReadFromPort(HWND hWnd, PSTATEINFO psi, OVERLAPPED ol, -- DWORD cbInQue) -- hWnd - a handle to the window -- psi - contains info about the current state of the -- communication -- ol - the overlapped structure used to wait for -- characters at the serial port -- cbinQue - the number of characters that are at the port -- -- RETURNS: VOID. -- -- NOTES: -- Reads from the serial port and calls ProcessRead(). If -- ProcessRead() returns a zero, it means that only a partial -- frame was passed. In that case, it waits for more characters -- to arrive at the port, then appends these new characters to the -- the partial frame, and calls ProcessRead() again. ------------------------------------------------------------------------------*/ VOID ReadFromPort(HWND hWnd, PSTATEINFO psi, OVERLAPPED ol, DWORD cbInQue) { static DWORD dwQueueSize = 0; PWNDDATA pwd = NULL; BYTE pReadBuf[READ_BUFSIZE] = {0}; PBYTE pQueue = NULL; DWORD dwBytesRead = 0; DWORD i = 0; pwd = (PWNDDATA) GetWindowLongPtr(hWnd, 0); if (!ReadFile(pwd->hPort, pReadBuf, READ_BUFSIZE, &dwBytesRead, &ol)) { // read is incomplete or had an error ProcessCommError(pwd->hPort); GetOverlappedResult(pwd->hThread, &ol, &dwBytesRead, TRUE); } if (dwQueueSize == 0) { // the last port read sent an entire frame to ProcessRead() if (dwBytesRead >= CTRL_FRAME_SIZE && ProcessRead(hWnd, psi, pReadBuf, dwBytesRead)) { // read completed successfully return; } else { // a full frame is not yet at the port for (i = 0; i < dwBytesRead; i++) { AddToByteQueue(&pwd->pReadBufHead, &pwd->pReadBufTail, pReadBuf[i]); dwQueueSize++; } if (dwQueueSize != dwBytesRead) { DISPLAY_ERROR("Port read is out of sync"); } } } else { // the previous port read was not finished for (i = 0; i < dwBytesRead; i++) { AddToByteQueue(&pwd->pReadBufHead, &pwd->pReadBufTail, pReadBuf[i]); dwQueueSize++; } // checks for 1 byte read, in case the tx side is out of sync if (dwQueueSize >= FRAME_SIZE || dwBytesRead == CTRL_FRAME_SIZE) { pQueue = RemoveFromByteQueue(&pwd->pReadBufHead, dwQueueSize); ProcessRead(hWnd, psi, pQueue, dwQueueSize); // read completed successfully dwQueueSize = 0; DeleteByteQueue(pwd->pReadBufHead); pwd->pReadBufHead = NULL; pwd->pReadBufTail = NULL; for (i = 0; i < dwQueueSize; i++) { free(pQueue); } } } }