/**
* \brief 向套接口发送原始数据,没有打包的数据,一般发送数据的时候需要加入额外的包头
* \param pBuffer 待发送的原始数据
* \param nSize 待发送的原始数据大小
* \return 实际发送的字节数
* 返回-1,表示发送错误
* 返回0,表示发送超时
* 返回整数,表示实际发送的字节数
*/
int CSocket::sendRawData(const void *pBuffer,const int nSize)
{
if (isset_flag(INCOMPLETE_WRITE))
{
clear_flag(INCOMPLETE_WRITE);
goto do_select;
}
if( nSize > 10000 )
{
int iii = 0;
}
int retcode = Send(sock,(const char*)pBuffer,nSize,MSG_NOSIGNAL);
if (retcode == -1 && (errno == EAGAIN || errno == EWOULDBLOCK))
{
do_select:
retcode = waitForWrite();
if (1 == retcode)
{
mutex.lock();
retcode = Send(sock,(const char*)pBuffer,nSize,MSG_NOSIGNAL);
mutex.unlock();
}
else
return retcode;
}
if (retcode > 0 && retcode < nSize)
set_flag(INCOMPLETE_WRITE);
return retcode;
}
/**
* \brief 向套接口发送原始数据，没有打包的数据，一般发送数据的时候需要加入额外的包头
* \param pBuffer 待发送的原始数据
* \param nSize 待发送的原始数据大小
* \return 实际发送的字节数
* 返回-1，表示发送错误
* 返回0，表示发送超时
* 返回整数，表示实际发送的字节数
*/
int zSocket::sendRawData(const void *pBuffer, const int nSize)
{
int retcode = 0;
//Zebra::logger->trace("zSocket::sendRawData");
if (isset_flag(INCOMPLETE_WRITE))
{
clear_flag(INCOMPLETE_WRITE);
goto do_select;
}
retcode = TEMP_FAILURE_RETRY(::send(sock, pBuffer, nSize, MSG_NOSIGNAL));
if (retcode == -1 && (errno == EAGAIN || errno == EWOULDBLOCK))
{
do_select:
retcode = waitForWrite();
if (1 == retcode)
retcode = TEMP_FAILURE_RETRY(::send(sock, pBuffer, nSize, MSG_NOSIGNAL));
else
return retcode;
}
if (retcode > 0 && retcode < nSize)
set_flag(INCOMPLETE_WRITE);
return retcode;
}
int GuestFile::writeDataAt(uint64_t uOffset, uint32_t uTimeoutMS,
void *pvData, uint32_t cbData, uint32_t *pcbWritten)
{
AssertPtrReturn(pvData, VERR_INVALID_POINTER);
AssertReturn(cbData, VERR_INVALID_PARAMETER);
LogFlowThisFunc(("uOffset=%RU64, uTimeoutMS=%RU32, pvData=%p, cbData=%zu\n",
uOffset, uTimeoutMS, pvData, cbData));
AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
int vrc;
GuestWaitEvent *pEvent = NULL;
GuestEventTypes eventTypes;
try
{
eventTypes.push_back(VBoxEventType_OnGuestFileStateChanged);
eventTypes.push_back(VBoxEventType_OnGuestFileWrite);
vrc = registerWaitEvent(eventTypes, &pEvent);
}
catch (std::bad_alloc)
{
vrc = VERR_NO_MEMORY;
}
if (RT_FAILURE(vrc))
return vrc;
/* Prepare HGCM call. */
VBOXHGCMSVCPARM paParms[8];
int i = 0;
paParms[i++].setUInt32(pEvent->ContextID());
paParms[i++].setUInt32(mData.mID /* File handle */);
paParms[i++].setUInt64(uOffset /* Offset where to starting writing */);
paParms[i++].setUInt32(cbData /* Size (in bytes) to write */);
paParms[i++].setPointer(pvData, cbData);
alock.release(); /* Drop write lock before sending. */
uint32_t cbWritten;
vrc = sendCommand(HOST_FILE_WRITE_AT, i, paParms);
if (RT_SUCCESS(vrc))
vrc = waitForWrite(pEvent, uTimeoutMS, &cbWritten);
if (RT_SUCCESS(vrc))
{
LogFlowThisFunc(("cbWritten=%RU32\n", cbWritten));
if (cbWritten)
*pcbWritten = cbWritten;
}
unregisterWaitEvent(pEvent);
LogFlowFuncLeaveRC(vrc);
return vrc;
}
void flash25spi::clearMem() {
enableWrite();
_enable->write(0);
wait_us(1);
_spi->write(0xc7);
wait_us(1);
_enable->write(1);
waitForWrite();
}
void flash25spi::clearBlock(unsigned int addr) {
addr &= ~(_blockSize-1);
enableWrite();
_enable->write(0);
wait_us(1);
_spi->write(0xd8);
_spi->write(HIGH(addr));
_spi->write(MID(addr));
_spi->write(LOW(addr));
wait_us(1);
_enable->write(1);
waitForWrite();
}
void PreWrite0() {
while (1) {
TUint bits;
TInt err = poll(bits);
if (err != KErrNone) {
return;
}
if ((bits & KSockSelectWrite) != 0) {
break;
} else {
#if 0
fprintf(stderr, "write with status %x\n", bits);
#endif
}
waitForWrite();
}
//CancelAll();
}
void flash25spi::clearSector(unsigned int addr) {
if (_sectorSize == 0) {
clearBlock(addr);
return;
}
addr &= ~(_sectorSize-1);
enableWrite();
_enable->write(0);
wait_us(1);
_spi->write(0x20);
_spi->write(HIGH(addr));
_spi->write(MID(addr));
_spi->write(LOW(addr));
wait_us(1);
_enable->write(1);
waitForWrite();
}
bool QHttpSocketEngine::waitForReadOrWrite(bool *readyToRead, bool *readyToWrite,
bool checkRead, bool checkWrite,
int msecs, bool *timedOut)
{
Q_UNUSED(checkRead);
if (!checkWrite) {
// Not interested in writing? Then we wait for read notifications.
bool canRead = waitForRead(msecs, timedOut);
if (readyToRead)
*readyToRead = canRead;
return canRead;
}
// Interested in writing? Then we wait for write notifications.
bool canWrite = waitForWrite(msecs, timedOut);
if (readyToWrite)
*readyToWrite = canWrite;
return canWrite;
}
bool flash25spi::writePage(unsigned int startAdr, unsigned int len, const char* data) {
enableWrite();
_enable->write(0);
wait_us(1);
_spi->write(0x02);
_spi->write(HIGH(startAdr));
_spi->write(MID(startAdr));
_spi->write(LOW(startAdr));
// do real write
for (unsigned int i=0;i<len;i++) {
_spi->write(data[i]);
}
wait_us(1);
// disable to start physical write
_enable->write(1);
waitForWrite();
return true;
}
SWORD Socket::sendRawData(const void *pBuffer,const DWORD size)
{
SWORD retcode = -1;
if(isSetFlag(s_incompleteWrite))
{
clearFlag(s_incompleteWrite);
goto do_select;
}
retcode = TEMP_FAILURE_RETRY(::send(m_sock,pBuffer,size,MSG_NOSIGNAL));
//套接字出错且阻塞或者再试
if(retcode == -1 && (errno == EAGAIN || errno == EWOULDBLOCK))
{
do_select:
retcode = waitForWrite();
CheckConditonReturn(retcode==1,retcode);
retcode = TEMP_FAILURE_RETRY(::send(m_sock,pBuffer,size,MSG_NOSIGNAL));
}
//没有发送完毕
if(retcode > 0 && retcode < size)
{
setFlag(s_incompleteWrite);
}
return retcode;
}
//! [0]
socketLayer = QNativeSocketEngine()
socketLayer.initialize(QAbstractSocket.TcpSocket, QAbstractSocket.IPv4Protocol)
socketLayer.connectToHost(QHostAddress.LocalHost, 22)
# returns False
socketLayer.waitForWrite()
socketLayer.connectToHost(QHostAddress.LocalHost, 22)
# returns True
//! [0]
//! [1]
socketLayer = QNativeSocketEngine()
socketLayer.bind(QHostAddress.Any, 4000)
socketLayer.listen()
if socketLayer.waitForRead():
clientSocket = socketLayer.accept()
# a client is connected
//! [1]
