// --------------------------------------------------------------------------- // CUpnpHttpFileTransferWriter::SendNextWriteRequestL // Function checks if there are any write requests left and if there are then // issues writing and removes this request from queue. // --------------------------------------------------------------------------- // void CUpnpHttpFileTransferWriter::SendNextPortionL() { LOGS2( "%i, CUpnpHttpFileTransferWriter::SendNextPortionL(), iState %i", iSession.Id() , iState ); if( iSession.FileAccess() ) { if( iState == EContent ) if( !IsActive() ) { iSendPointer.Set( (TUint8*)iSendBuffer.Ptr(),0,iSendBuffer.MaxLength() ); if( iSession.FileAccess()->GetL(iSendPointer,iSendBuffer.MaxLength()) ) { iState = EFinished; } iSession.TimerCancel(); WriteToSocket(); iSession.StartTimeoutTimer(ETrue); } } else { Cancel(); } }
LRESULT BTCtcp::ProcessNotifications(HWND hWnd, LPARAM lParam) { int wsaErr = WSAGETSELECTERROR(lParam); unsigned int ui=0; TCHAR szText[MAX_LOADSTRING]; switch (WSAGETSELECTEVENT(lParam)) { case FD_ACCEPT: break; case FD_CONNECT: // connect() operation terminated if (wsaErr == ERROR_SUCCESS) { // and no error --> we are connected :) iBTCSocketStatus = 5; iBTCError = ERROR_SUCCESS; ui=IDS_SS_CONNECTED; } else { iBTCSocketStatus = 3; // "connecting..." status did not complete successfully iBTCError = wsaErr; // save error information iBTCNodeStatus=0; // no connection ui=IDS_SS_FAILED; ShowError(IDS_Err_Socket, iBTCError); } break; case FD_WRITE: bWriteReady = true; // we are notified we can send (again) WriteToSocket(); // try to send data if something is waiting in our buffer break; case FD_READ: ReadFromSocket(hWnd); // data is awaiting break; case FD_CLOSE: // connection has been closed closesocket(skBTC); // release the socket iBTCSocketStatus=1; iBTCNodeStatus=0; ui=IDS_SS_NOTHING; break; } if (ui) { // show something to user LoadString(hInst, ui, szText, MAX_LOADSTRING); SetWindowText(hStaticSocketStatus, szText); // update status window related to our TCP connection InvalidateRect(hWnd, &rcSocketStatus, true); LoadString(hInst, (iBTCSocketStatus>3) ? IDS_DISCONNECT:IDS_CONNECT, szText, MAX_LOADSTRING); SetDlgItemText(hWnd, IDC_BTNBTCCONNECT, szText); EnableWindow(GetDlgItem(hWnd, IDC_BTNSQLCONNECT), iBTCSocketStatus<2); } return 0; }
void SocksConnection::WriteSocksReply(SocksReplyCode reason, const QHostAddress &addr, quint16 port) { QByteArray reply(4, 0); reply[0] = (uchar)SocksVersion_5; // Protocol version reply[1] = reason; // Reply reply[2] = 0x00; // Reserved reply[3] = SocksAddress_IPv4; // Address type QDataStream stream(&reply, QIODevice::Append); stream.setByteOrder(QDataStream::BigEndian); stream << addr.toIPv4Address(); stream << port; WriteToSocket(reply); }
// --------------------------------------------------------------------------- // CUpnpHttpFileTransferWriter::RetryWriteSucceed // // --------------------------------------------------------------------------- // void CUpnpHttpFileTransferWriter::RetryWriteSucceed() { WriteToSocket(); }
// --------------------------------------------------------------------------- // CUpnpHttpFileTransferWriter::StartL // Sends the HTTP headers of the content // --------------------------------------------------------------------------- // void CUpnpHttpFileTransferWriter::SendHeadersL() { if(iState == EHeaders) if( iSession.FileAccess() ) if(!IsActive()) { //in case session not connected,waiting... if(!iSession.IsConnected()) { iWaiting = ETrue; return; } iSendBuffer.Zero(); if ( ( iSession.FileAccess()->GetHeaders().Length() - iSession.FileAccess()->TransferredBytes()) <= iSendBuffer.MaxLength() ) { TPtrC8 headerPointer; headerPointer.Set(iSession.FileAccess()->GetHeaders()); headerPointer.Set( headerPointer.Right( iSession.FileAccess()->GetHeaders().Length()- iSession.FileAccess()->TransferredBytes()) ); iSendBuffer.Append( headerPointer ); iSession.FileAccess()->SetHeadersSent(); // Adding file content to the header TInt length = iSendBuffer.MaxLength()-iSendBuffer.Length(); HBufC8* tmpBuffer = HBufC8::NewLC(length); iSendPointer.Set(tmpBuffer->Des()); if( iSession.FileAccess()->GetL(iSendPointer,length) ) { iState = EFinished; } iSendBuffer.Append(iSendPointer); CleanupStack::PopAndDestroy( tmpBuffer ); } else { TPtrC8 headerPointer; headerPointer.Set( iSession.FileAccess()->GetHeaders() ); headerPointer.Set( headerPointer.Right( iSession.FileAccess()->GetHeaders().Length() - iSession.FileAccess()->TransferredBytes() ) ); headerPointer.Set( headerPointer.Left( iSendBuffer.Length() ) ); iSendBuffer.Append( headerPointer ); iSession.FileAccess()->SetPosOfHeader( iSession.FileAccess()->TransferredBytes() + headerPointer.Length() ); } iSendPointer.Set((TUint8*)iSendBuffer.Ptr(),iSendBuffer.Length(),iSendBuffer.MaxLength()); iSession.TimerCancel(); WriteToSocket(); iSession.StartTimeoutTimer(ETrue); if(!iHttpPostStarted) { iSession.NotifyUpperLayersOnPostL(); iHttpPostStarted = ETrue; } } }
int CSTATEngine::SendCommand(CSTATScriptCommand *pSendCommand, CSTATScriptCommand **ppRecvCommand) { int ret = GENERAL_FAILURE; CSTATScriptCommand tempCommand; tempCommand.cCommandID = pSendCommand->cCommandID; // the first instance of a 'R' or 'T' command, it could set a data socket instead of a file if(pSendCommand->cCommandID=='T' || pSendCommand->cCommandID=='R') { if(dataSocket==NULL && settingSocket && pSendCommand->Command()!=NULL) { char *comma = strchr(pSendCommand->Command(),','); if(!(comma > pSendCommand->Command() + pSendCommand->Length())) { switch(pSendCommand->cCommandID) { case 'R': { char *colon = strchr(comma,':'); if(colon==NULL) break; comma += 1; std::string ipAdd( comma, colon - comma ); colon += 1; std::string ipPort( colon ); ret = SetSocket(ipAdd.c_str() , atoi( ipPort.c_str() )); if(ret!=ITS_OK) { return ret; } break; } case 'T': { char *colon = strchr( pSendCommand->Command() , ':' ); if(colon==NULL) break; std::string ipAdd( pSendCommand->Command() , colon - pSendCommand->Command() ); colon += 1; if(comma < colon) break; std::string ipPort( colon , comma - colon ); ret = SetSocket(ipAdd.c_str() , atoi(ipPort.c_str())); if(ret!=ITS_OK) { return ret; } break; } } } } settingSocket=false; } // send the first command if ((ret = SendSingleCommand(pSendCommand, ppRecvCommand)) == ITS_OK) { // check our response - if Serial/Infra-red, need to break it down if (pComms->GetMaxPacketSize() != 0) { // break up the command into buffer-sized chunks if (pSendCommand->Length() > pComms->GetMaxPacketSize() || (dataSocket!=NULL && pSendCommand->cCommandID=='T')) { int i = 0; unsigned long offset = 0; unsigned long ulTotalWritten = 0; unsigned long AmountToWrite = pComms->GetMaxPacketSize(); unsigned long OriginalLength = pSendCommand->Length(); if(dataSocket==NULL) { int iWrites = pSendCommand->Length() / pComms->GetMaxPacketSize() + 1; Message("Writing %d bytes of data in %d separate writes...", OriginalLength, iWrites); for (i=0;i<iWrites;i++) { offset = i * pComms->GetMaxPacketSize(); if ((pSendCommand->Length() - offset) < pComms->GetMaxPacketSize()) AmountToWrite = (pSendCommand->Length() - offset); if (AmountToWrite) { //Sleep(100); // pause a bit for slower machines - probably doesn't need it but it can't hurt... // now send the command Message("Writing %d bytes from offset %d", AmountToWrite, offset); tempCommand.SetData(pSendCommand->Command() + ulTotalWritten, AmountToWrite); if ((ret = SendSingleCommand(&tempCommand, ppRecvCommand)) == ITS_OK) { //Message("%d bytes successfully written", AmountToWrite); } else return ret; ulTotalWritten += AmountToWrite; } } } else { //uses socket transmission char *pData = new char[AmountToWrite]; tempCommand.ulLength = (unsigned long) -1; if((ret = SendSingleCommand(&tempCommand, ppRecvCommand)) != ITS_OK) { delete [] pData; return ret; } while(true){ int AmountToWrite = pComms->GetMaxPacketSize(); ReadFromSocket(pData, &AmountToWrite ); if(AmountToWrite>=0) { Message("Writing %d bytes", AmountToWrite); tempCommand.SetData(pData , AmountToWrite); if ((ret = SendSingleCommand(&tempCommand, ppRecvCommand)) == ITS_OK) { //Message("%d bytes successfully written", AmountToWrite); } else { settingSocket=true; delete [] pData; return ret; } ulTotalWritten +=AmountToWrite; } else { eStopProcessing = STAT_PAUSE; break; } if(AmountToWrite==0) { break; } } delete [] pData; } // once completely sent, send an empty command to show that we've finished if(dataSocket == NULL ) { if (ulTotalWritten == OriginalLength) { // send the command that signals the end of our transmission Message("Sending completion command %c", tempCommand.cCommandID); tempCommand.SetData(NULL, 0); if ((ret = SendSingleCommand(&tempCommand, ppRecvCommand)) == ITS_OK) { //Message("Completion command successfully written"); } } else { Message("Incorrect number of bytes written - expected %ld got %ld", ulTotalWritten, OriginalLength); ret = E_BADNUMBERBYTES; } } } } } if (ret == ITS_OK) { // check our response - if Serial/Infra-red, need to break it down // if < STAT_BUFFERSIZE, nothing more to do // if not, we need to read in as many times as it takes to // assemble our complete command response if (pComms->GetMaxPacketSize() != 0) { if (ppRecvCommand && (*ppRecvCommand)->Length() > pComms->GetMaxPacketSize()) { unsigned long TotalLength = (*ppRecvCommand)->Length(); Message("%s: About to read %d bytes of data", GetConnection(eConnectType), TotalLength); // allocate memory to hold entire command char *pTemp = new char [TotalLength]; if (pTemp) { unsigned long ulTotalRead = 0; // empty packets tempCommand.SetData(NULL, 0); // now read data until we get an empty packet while((*ppRecvCommand)->Length()) { //Sleep(100); // pause a bit for slower machines - probably doesn't need it but it can't hurt... //Message("Sending continuation command %c", tempCommand.cCommandID); if ((ret = SendSingleCommand(&tempCommand, ppRecvCommand)) == ITS_OK) { if ((*ppRecvCommand)->Length()) { Message("%s to offset %d", pComms->Error(), ulTotalRead); //copy the data into the buffer memcpy(pTemp + ulTotalRead, (*ppRecvCommand)->Command(), (*ppRecvCommand)->Length()); if(dataSocket!=NULL) { int bytesSent = (int)(*ppRecvCommand)->Length(); WriteToSocket((*ppRecvCommand)->Command() , &bytesSent); if(bytesSent <= 0) { eStopProcessing = STAT_PAUSE; } } //increment the pointer to the end of the first chunk received ulTotalRead += (*ppRecvCommand)->Length(); } } else { settingSocket=true; delete [] pTemp; return ret; } } // make sure we got what we expected if (ulTotalRead == TotalLength) { // set our final response to the complete data transmission (*ppRecvCommand)->SetData(pTemp, ulTotalRead); //Message("Received successfully %ld bytes", ulTotalRead); } else { Message("Incorrect number of bytes read - expected %ld got %ld", ulTotalRead, TotalLength); ret = E_BADNUMBERBYTES; } // finished with it delete [] pTemp; } else { Message("Could not allocate %d bytes of memory", TotalLength); ret = E_OUTOFMEM; } } else if(dataSocket!=NULL && pSendCommand->cCommandID=='R') { int bytesSent = (int)(*ppRecvCommand)->Length(); WriteToSocket((*ppRecvCommand)->Command(), &bytesSent); } } } return ret; }
PRStatus nsSOCKSSocketInfo::DoHandshake(PRFileDesc *fd, int16_t oflags) { LOGDEBUG(("socks: DoHandshake(), state = %d", mState)); switch (mState) { case SOCKS_INITIAL: return StartDNS(fd); case SOCKS_DNS_IN_PROGRESS: PR_SetError(PR_IN_PROGRESS_ERROR, 0); return PR_FAILURE; case SOCKS_DNS_COMPLETE: return ConnectToProxy(fd); case SOCKS_CONNECTING_TO_PROXY: return ContinueConnectingToProxy(fd, oflags); case SOCKS4_WRITE_CONNECT_REQUEST: if (WriteToSocket(fd) != PR_SUCCESS) return PR_FAILURE; WantRead(8); mState = SOCKS4_READ_CONNECT_RESPONSE; return PR_SUCCESS; case SOCKS4_READ_CONNECT_RESPONSE: if (ReadFromSocket(fd) != PR_SUCCESS) return PR_FAILURE; return ReadV4ConnectResponse(); case SOCKS5_WRITE_AUTH_REQUEST: if (WriteToSocket(fd) != PR_SUCCESS) return PR_FAILURE; WantRead(2); mState = SOCKS5_READ_AUTH_RESPONSE; return PR_SUCCESS; case SOCKS5_READ_AUTH_RESPONSE: if (ReadFromSocket(fd) != PR_SUCCESS) return PR_FAILURE; return ReadV5AuthResponse(); case SOCKS5_WRITE_CONNECT_REQUEST: if (WriteToSocket(fd) != PR_SUCCESS) return PR_FAILURE; // The SOCKS 5 response to the connection request is variable // length. First, we'll read enough to tell how long the response // is, and will read the rest later. WantRead(5); mState = SOCKS5_READ_CONNECT_RESPONSE_TOP; return PR_SUCCESS; case SOCKS5_READ_CONNECT_RESPONSE_TOP: if (ReadFromSocket(fd) != PR_SUCCESS) return PR_FAILURE; return ReadV5ConnectResponseTop(); case SOCKS5_READ_CONNECT_RESPONSE_BOTTOM: if (ReadFromSocket(fd) != PR_SUCCESS) return PR_FAILURE; return ReadV5ConnectResponseBottom(); case SOCKS_CONNECTED: LOGERROR(("socks: already connected")); HandshakeFinished(PR_IS_CONNECTED_ERROR); return PR_FAILURE; case SOCKS_FAILED: LOGERROR(("socks: already failed")); return PR_FAILURE; } LOGERROR(("socks: executing handshake in invalid state, %d", mState)); HandshakeFinished(PR_INVALID_STATE_ERROR); return PR_FAILURE; }
void SocksConnection::HandleTcpResponse(const TunnelPacket &packet) { qDebug() << "SOCKS response : " << packet.GetMessage().count(); WriteToSocket(packet.GetMessage()); }