bool ClientSession::PostSend()
{
	if (!IsConnected())
		return false;

	FastSpinlockGuard criticalSection(mBufferLock);

	if ( 0 == mBuffer.GetContiguiousBytes() )
		return true;

	OverlappedSendContext* sendContext = new OverlappedSendContext(this);

	DWORD sendbytes = 0;
	DWORD flags = 0;
	sendContext->mWsaBuf.len = (ULONG) mBuffer.GetContiguiousBytes(); 
	sendContext->mWsaBuf.buf = mBuffer.GetBufferStart();

	/// start async send
	if (SOCKET_ERROR == WSASend(mSocket, &sendContext->mWsaBuf, 1, &sendbytes, flags, (LPWSAOVERLAPPED)sendContext, NULL))
	{
		if (WSAGetLastError() != WSA_IO_PENDING)
		{
			DeleteIoContext(sendContext);
			printf_s("ClientSession::PostSend Error : %d\n", GetLastError());

			return false;
		}
			
	}

	return true;
}
Beispiel #2
0
void CGateInfo::SendToGate(SOCKET cSock, char *pszPacket)
{
	char	szData[256];
	WSABUF	buf;
	DWORD	dwSendBytes;
	
	int nLen = memlen(pszPacket) - 1;

	szData[0] = '%';
	
	char *pszNext = ValToAnsiStr((int)cSock, &szData[1]);
	
	*pszNext++ = '/';
	*pszNext++ = '#';

	memmove(pszNext, pszPacket, nLen);

	pszNext += nLen;

	*pszNext++ = '!';
	*pszNext++ = '$';
	*pszNext++ = '\0';

	buf.len = pszNext - szData;
	buf.buf = szData;

	WSASend(sock, &buf, 1, &dwSendBytes, 0, NULL, NULL);
}
void NetworkConnection::sendData(const char* data, const int length)
{
	if (!closed && !sendError)	// Ignore call if something is wrong
	{
		// To-do: Make mutex

		// Set send information 
		sendInfo.buf = (char*)data;
		sendInfo.len = length;
			// Make winsock start sending
		if (WSASend(connection, &sendInfo, 1, 
			&bytesSent, 0, &sendOverlapped, NULL) 
				== SOCKET_ERROR)
		{			// If the error returned by the winsock was not a 
					// IO pending error
			if (WSAGetLastError() != WSA_IO_PENDING)
			{
				this->sendError = true;	// Set error flag
				// The send error bool makes sure that the close function 
				// doesn't get called before data processing/the current 
				// thread is done, as closing the socket and terminating 
				// the socket could possibly lead to a handfull of 
				// nullreffies during packet processing which could lead 
				// to a lot of null reffernce exceptions.
			}
		}
	}
}
bool WSAS(SOCKET sd, char * message, int size, int timeout){
    WSABUF buf;
    WSAOVERLAPPED ov;
    ov.hEvent = WSACreateEvent();
    buf.buf = message;
    buf.len = size;
    DWORD sendBytes;
    DWORD sendErr;
    sendErr = WSASend(sd, &buf, 1, &sendBytes, 0, &ov,0);
    if((sendErr == SOCKET_ERROR) && (WSA_IO_PENDING != WSAGetLastError())) {
        sendErr = WSAGetLastError();
        WSACleanup();
        exit(0);
     }

    fflush(stdout);
    sendErr = WSAGetLastError();

    if (sendErr == WSA_IO_PENDING) {

        sendErr = WSAWaitForMultipleEvents(1, &ov.hEvent, FALSE, 1000, FALSE);
        if (sendErr == WSA_WAIT_FAILED) {
            printf("WSAWaitForMultipleEvents failed with error: %d\n",
                WSAGetLastError());
            exit(0);
        }
    }

}
Beispiel #5
0
static void
win32iocr_set_handle (struct win32iocr_thread *iocr_thr,
                      struct win32overlapped *ov)
{
    static WSABUF buf = {0, 0};

    struct event *ev = ov->e.ev;
    unsigned int rw_flags;
    sd_t sd;

    if (!ev) goto ready;

    sd = (sd_t) ev->fd;
    rw_flags = ov->ih.rw_flags;
    ov->ih.rw_flags = 0;

    if (rw_flags == EVENT_READ) {
        DWORD flags = 0;

        if (!WSARecv(sd, &buf, 1, NULL, &flags, (OVERLAPPED *) ov,
                     (LPWSAOVERLAPPED_COMPLETION_ROUTINE) win32iocr_completion)
                || WSAGetLastError() == WSA_IO_PENDING)
            return;
    } else {
        if (!WSASend(sd, &buf, 1, NULL, 0, (OVERLAPPED *) ov,
                     (LPWSAOVERLAPPED_COMPLETION_ROUTINE) win32iocr_completion)
                || WSAGetLastError() == WSA_IO_PENDING)
            return;
    }
    ov->il.err = WSAGetLastError();
ready:
    win32iocr_list_put(iocr_thr->ov_list, ov);
}
Beispiel #6
0
/* send a message after connected */
static void  on_connected(PER_HANDLE_DATA* handle_data)
{
    int error;
    DWORD bytes;
    const char* msg = "GET /index.html HTTP/1.0\r\n\r\n";
    size_t len = strlen(msg) + 1;

    assert(handle_data);
    fprintf(stdout, ("socket %d connected at %s.\n"), handle_data->socket, Now());

    memcpy_s(handle_data->buffer, kDefaultBufferSize, msg, len);
    memset(&handle_data->overlap, 0, sizeof(handle_data->overlap));
    handle_data->wsbuf.len = len;
    handle_data->opertype = OperSend;

    error = WSASend(handle_data->socket, &handle_data->wsbuf, 1, &bytes,
        0, &handle_data->overlap, NULL);
    if (error == SOCKET_ERROR)
    {
        error = WSAGetLastError();
        if (error != WSA_IO_PENDING)
        {
            fprintf(stderr, "WSASend() failed, socket: %d, %d: %s", handle_data->socket,
                error, LAST_ERROR_MSG);
            on_close(handle_data);
        }
        on_close(handle_data);
    }
}
bool IocpTransmitStrategy::PostSend() {
    auto& socketBuffer = m_transmitSocket.TheSocketBuffer();

    const auto sendLength = socketBuffer.PrepareSendPlan();
    if (sendLength < 1) {
        m_sendOperation.SetBusy(false);
        return true;
    }

    const auto count = socketBuffer.SetupSendIov(m_sendOperation.m_iov);

    DWORD bytesSent = 0;
    const auto& transmitSockId = m_transmitSocket.GetSockId();
    const auto ret = WSASend(transmitSockId
        , m_sendOperation.m_iov
        , count
        , &bytesSent
        , 0
        , &m_sendOperation.m_overlapped
        , NULL);
    if (ret != 0) {
        const auto error = WSAGetLastError();
        if (error != ERROR_IO_PENDING) {
            HandleFailure(&m_sendOperation, 0, error);
            return false;
        }
    }

    return true;
}
Beispiel #8
0
/*@
   bwritev - writev

   Parameters:
+  int bfd - bsocket
.  B_VECTOR *pIOVec - iovec structure
-  int n - length of iovec

   Notes:
@*/
int bwritev(int bfd, B_VECTOR *pIOVec, int n)
{
#ifdef HAVE_WINSOCK2_H
#ifdef DBG_BWRITEV
    int i;
#endif
    DWORD dwNumSent = 0;
    if (n == 0)
	return 0;
#ifdef DBG_BWRITEV
    printf("(bwritev");
    for (i=0; i<n; i++)
	printf(":%d", pIOVec[i].B_VECTOR_LEN);
#endif
    if (WSASend(bfd, pIOVec, n, &dwNumSent, 0, NULL/*overlapped*/, NULL/*completion routine*/) == SOCKET_ERROR)
    {
	if (WSAGetLastError() != WSAEWOULDBLOCK)
	{
	    return SOCKET_ERROR;
	}
    }
    DBG_BWRITEV_PRINT(("->%d)", dwNumSent));
    return dwNumSent;
#else
    return writev(bfd, pIOVec, n);
#endif
}
// sendPacket ( sizeof( data ), type 값 , data 의 주소값 );
void AsynchronousClientClass::sendPacket(const BYTE data_size, const BYTE type, BYTE* data_start_pointer) {
	// 실제 최대 버퍼 사이즈 보다 데이터 길이가 커지면 안된다.
	if (MAX_BUF_SIZE < (data_size + 2)) {
#ifdef _DEBUG
		// 아래와 같은 에러가 발생하게 된다면, 버퍼 사이즈를 건드리기 보다 실제 데이터 크기를 압축해 줄여 보낼 수 있도록 하자
		printf("[ code LINE %d ] [ code FUNCTION %s ] SendPacket class ERROR :: data size overed MAX_BUF_SIZE\n", __LINE__, __FUNCTION__);
#endif
	}
	else {
		// 패킷 안의 실제 내용 생성
		m_sendbuf[0] = data_size + 2;
		m_sendbuf[1] = type;

		if (nullptr != data_start_pointer) { memcpy(&m_sendbuf[2], data_start_pointer, m_sendbuf[0]); }

		m_wsa_sendbuf.len = m_sendbuf[0];
		DWORD ioByteSize;
		m_retval = WSASend(m_sock, &m_wsa_sendbuf, 1, &ioByteSize, 0, NULL, NULL);
		if (SOCKET_ERROR == m_retval) {
			// 비동기 소켓이라 그냥 리턴, 검사 해주어야 함
			if (WSAGetLastError() != WSAEWOULDBLOCK) {
				int err_no = WSAGetLastError();
				error_quit(L"sendPacket()", err_no);
			}
		}
	}
}
Beispiel #10
0
/**
 *  Attempts to write a series of iovec buffers to a socket in *one* system call so that
 *  they are sent as one packet.
 *  @param socket the socket to write to
 *  @param iovecs an array of buffers to write
 *  @param count number of buffers in iovecs
 *  @param bytes number of bytes actually written returned
 *  @return completion code, especially TCPSOCKET_INTERRUPTED
 */
int Socket_writev(int socket, iobuf* iovecs, int count, unsigned long* bytes)
{
	int rc;

	FUNC_ENTRY;
#if defined(WIN32) || defined(WIN64)
	rc = WSASend(socket, iovecs, count, (LPDWORD)bytes, 0, NULL, NULL);
	if (rc == SOCKET_ERROR)
	{
		int err = Socket_error("WSASend - putdatas", socket);
		if (err == EWOULDBLOCK || err == EAGAIN)
			rc = TCPSOCKET_INTERRUPTED;
	}
#else
	*bytes = 0L;
	rc = writev(socket, iovecs, count);
	if (rc == SOCKET_ERROR)
	{
		int err = Socket_error("writev - putdatas", socket);
		if (err == EWOULDBLOCK || err == EAGAIN)
			rc = TCPSOCKET_INTERRUPTED;
	}
	else
		*bytes = rc;
#endif
	FUNC_EXIT_RC(rc);
	return rc;
}
Beispiel #11
0
// SendExec Method
bool cIocpServer::SendExec(PerIoContext* perIoContext)
{
	WSABUF wsaBuf;
	DWORD  sendBytes = 0;
	DWORD  flags     = 0;
	int    retcode;

	wsaBuf.len = perIoContext->offset;
	wsaBuf.buf = perIoContext->buffer;

	retcode = WSASend( perIoContext->socket,
					   &wsaBuf,
					   1,
					   &sendBytes,
					   flags,
					   &(perIoContext->wsaOverlapped),
					   NULL );

	if ( (retcode == SOCKET_ERROR) && (WSAGetLastError() != WSA_IO_PENDING) )
	{
		mIoContextPool->ReleaseIoContext( perIoContext );
		return false;
	}
	return true;
}
Beispiel #12
0
BOOL sock_send_raw(SOCKET sock, char *hdr, int nhdr, char *buf, int nbuf)
{
#ifdef WIN32
    DWORD n_sent = 0;
    WSABUF bufs[2] = {0};
    if(!hdr || !buf || sock == INVALID_SOCKET)
        return FALSE;
    bufs[0].len = nhdr;
    bufs[0].buf = hdr;
    bufs[1].len = nbuf;
    bufs[1].buf = buf;
    if(0!=WSASend(sock,bufs,ARRAY_SIZE(bufs),&n_sent,0,NULL,NULL))
        return FALSE;
    if((int)n_sent != nhdr + nbuf)
        return FALSE;
    return TRUE;
#else
#       error "not defined for non win32 yet"
    int n;
    if(sock == INVALID_SOCKET || !hbuf)
        return FALSE;
    n = achr_size(hbuf);
    return n == send(sock,*hbuf,n,0); // don't worry about partial sends and sends failing
#endif // WIN32
}
Beispiel #13
0
//发送函数
bool CServerSocketItem::SendData(WORD wMainCmdID, WORD wSubCmdID, WORD wRountID)
{
	//效验状态
	if (m_bCloseIng==true) return false;
	if (m_wRountID!=wRountID) return false;
	if (m_dwRecvPacketCount==0) return false;
	if (IsValidSocket()==false) return false;

	//寻找发送结构
	COverLappedSend * pOverLappedSend=GetSendOverLapped();
	ASSERT(pOverLappedSend!=NULL);
	if (pOverLappedSend==NULL) return false;

	//构造数据
	CMD_Head * pHead=(CMD_Head *)pOverLappedSend->m_cbBuffer;
	pHead->CommandInfo.wMainCmdID=wMainCmdID;
	pHead->CommandInfo.wSubCmdID=wSubCmdID;
	WORD wSendSize=EncryptBuffer(pOverLappedSend->m_cbBuffer,sizeof(CMD_Head),sizeof(pOverLappedSend->m_cbBuffer));
	pOverLappedSend->m_WSABuffer.len=wSendSize;

	//发送数据
	if (m_OverLappedSendActive.GetCount()==1)
	{
		DWORD dwThancferred=0;
		int iRetCode=WSASend(m_hSocket,&pOverLappedSend->m_WSABuffer,1,&dwThancferred,0,&pOverLappedSend->m_OverLapped,NULL);
		if ((iRetCode==SOCKET_ERROR)&&(WSAGetLastError()!=WSA_IO_PENDING))
		{
			OnSendCompleted(pOverLappedSend,0L);
			return false;
		}
	}

	return true;
}
void CSocketTcpServer::SendMsg(CString msg)
{
    char buf[MAX_BUFFER]= {0};
    m_convert.CStringToChar(msg,buf);
    for(int i=0; i<m_index; i++)
    {
        m_ol[i]->nOpType = OP_WRITE;
        memset(&m_ol[i]->ol, 0, sizeof(m_ol[i]->ol));
        strcpy_s(m_ol[i]->szBuf,MAX_BUFFER,buf);
        m_ol[i]->wsaBuf.buf=m_ol[i]->szBuf;
        m_ol[i]->wsaBuf.len = MAX_BUFFER;
        if(SOCKET_ERROR==WSASend(m_ol[i]->sock,&(m_ol[i]->wsaBuf), 1,
                                 &(m_ol[i]->dwTrans), m_ol[i]->dwFlags,
                                 &(m_ol[i]->ol), CompleteRoutine))
        {
#ifdef _DEBUG
            CString ipAddress;
            m_convert.CharToCstring(ipAddress,inet_ntoa(m_ol[i]->addr.sin_addr));
            CString errcode;
            errcode.AppendFormat(_T("client %s socket broken"),ipAddress);
            MyWriteConsole(ipAddress);
#endif
        }
    }
}
Beispiel #15
0
BOOL playerInfo::SendPacket(CHAR *packet, WORD size)
{
	SEND_STRUCT *Send = new SEND_STRUCT;

	CopyMemory(Send->m_SendBuffer, packet, size);

	Send->m_SendWSABuf.buf = Send->m_SendBuffer;
	Send->m_SendWSABuf.len = size;

	ZeroMemory(&Send->m_OverExSend, sizeof(OVERLAPPED_EX));
	Send->m_OverExSend.m_io_type = IO_SEND;

	DWORD SendBytes;

	INT Result = WSASend(	m_socket,
							&Send->m_SendWSABuf,
							1,
							&SendBytes,
							0,
							reinterpret_cast<LPWSAOVERLAPPED> (&Send->m_OverExSend),
							NULL);

	if (Result == SOCKET_ERROR) {
		if (WSAGetLastError() != WSA_IO_PENDING) {
			printf("send() error!!\n");
			return FALSE;
		}
	}

	return TRUE;
}
Beispiel #16
0
APR_DECLARE(apr_status_t) apr_socket_send(apr_socket_t *sock, const char *buf,
                                          apr_size_t *len)
{
    apr_ssize_t rv;
    WSABUF wsaData;
    int lasterror;
    DWORD dwBytes = 0;

    wsaData.len = (u_long)*len;
    wsaData.buf = (char*) buf;

#ifndef _WIN32_WCE
    rv = WSASend(sock->socketdes, &wsaData, 1, &dwBytes, 0, NULL, NULL);
#else
    rv = send(sock->socketdes, wsaData.buf, wsaData.len, 0);
    dwBytes = rv;
#endif
    if (rv == SOCKET_ERROR) {
        lasterror = apr_get_netos_error();
        *len = 0;
        return lasterror;
    }

    *len = dwBytes;

    return APR_SUCCESS;
}
Beispiel #17
0
/* send message back after recieved */
static void  on_recv(PER_HANDLE_DATA* handle_data)
{
    int error;
    DWORD bytes;

    assert(handle_data);

    /* pause */
    Sleep(200);

    bytes = handle_data->overlap.InternalHigh;
    memset(&handle_data->overlap, 0, sizeof(handle_data->overlap));
    handle_data->wsbuf.len = bytes;
    handle_data->wsbuf.buf[bytes] = '\0';
    handle_data->opertype =  OperSend;

    error = WSASend(handle_data->socket, &handle_data->wsbuf, 1, &bytes,
        0, &handle_data->overlap, NULL);
    if (error == SOCKET_ERROR)
    {
        error = WSAGetLastError();
        if (error != WSA_IO_PENDING)
        {
            fprintf(stderr, "WSASend() failed, socket: %d, %d: %s", handle_data->socket,
                error, LAST_ERROR_MSG);
            on_close(handle_data);
        }
    }
}
// Function name	: SendBlocking
// Description	    : 
// Return type		: int 
// Argument         : SOCKET sock
// Argument         : char *buffer
// Argument         : int length
// Argument         : int flags
int SendBlocking(SOCKET sock, char *buffer, int length, int flags)
{
	WSABUF buf;
	int error;
	DWORD num_sent;

	buf.buf = buffer;
	buf.len = length;

	while (WSASend(sock, &buf, 1, &num_sent, flags, NULL, NULL) == SOCKET_ERROR)
	{
		error = WSAGetLastError();
		if (error == WSAEWOULDBLOCK)
		{
            //Sleep(0);
			continue;
		}
		if (error == WSAENOBUFS)
		{
			// If there is no buffer space available then split the buffer in half and send each piece separately.
			SendBlocking(sock, buf.buf, buf.len/2, flags);
			SendBlocking(sock, buf.buf+(buf.len/2), buf.len - (buf.len/2), flags);
			return length;
		}
		WSASetLastError(error);
		return SOCKET_ERROR;
	}

	return length;
}
int ClientManager::packet_send_msg_proc(ObjectUser::User* p_user)
{
	ObjectUser *pObjectUser = FindUser(p_user->id);

	if (pObjectUser != NULL)
	{
		p_user->id = pObjectUser->sUser_info.id;
		pObjectUser->Set_Msg("org\n");

#if 1
		DWORD writen = 0;

		/* return message by send socket */
		if (WSASend(p_user->id,
			(WSABUF*)&pc_socket_info->dataBuf,
			1,
			(DWORD *)&writen,
			0,
			&pc_socket_info->overlapped,
			NULL) == SOCKET_ERROR) {
			if (WSAGetLastError() != WSA_IO_PENDING) {
				printf("WSASend Error.. [%d] \n", WSAGetLastError());
			}
		}
#endif
		broadcast_userinfo(p_user->id, &pObjectUser->sUser_info);
	}
	return true;
}
Beispiel #20
0
static AJ_Status AJ_Net_Send(AJ_IOBuffer* buf)
{
    DWORD ret;
    DWORD tx = AJ_IO_BUF_AVAIL(buf);

    AJ_InfoPrintf(("AJ_Net_Send(buf=0x%p)\n", buf));

    assert(buf->direction == AJ_IO_BUF_TX);

    if (tx > 0) {
        NetContext* ctx = (NetContext*) buf->context;
        WSAOVERLAPPED ov;
        DWORD flags = 0;
        WSABUF wsbuf;

        memset(&ov, 0, sizeof(ov));
        ov.hEvent = sendEvent;
        wsbuf.len = tx;
        wsbuf.buf = buf->readPtr;

        ret = WSASend(ctx->tcpSock, &wsbuf, 1, NULL, flags, &ov, NULL);
        if (!WSAGetOverlappedResult(ctx->tcpSock, &ov, &tx, TRUE, &flags)) {
            AJ_ErrPrintf(("AJ_Net_Send(): send() failed. WSAGetLastError()=0x%x, status=AJ_ERR_WRITE\n", WSAGetLastError()));
            return AJ_ERR_WRITE;
        }
        buf->readPtr += tx;
    }
    if (AJ_IO_BUF_AVAIL(buf) == 0) {
        AJ_IO_BUF_RESET(buf);
    }
    AJ_InfoPrintf(("AJ_Net_Send(): status=AJ_OK\n"));
    return AJ_OK;
}
Beispiel #21
0
static AJ_Status AJ_ARDP_UDP_Send(void* context, uint8_t* buf, size_t len, size_t* sent)
{
    AJ_Status status = AJ_OK;
    DWORD ret;
    NetContext* ctx = (NetContext*) context;
    WSAOVERLAPPED ov;
    DWORD flags = 0;
    WSABUF wsbuf;

    memset(&ov, 0, sizeof(ov));
    ov.hEvent = sendEvent;
    wsbuf.len = len;
    wsbuf.buf = buf;

    AJ_InfoPrintf(("AJ_ARDP_UDP_Send(buf=0x%p, len=%lu)\n", buf, len));

    ret = WSASend(ctx->udpSock, &wsbuf, 1, NULL, flags, &ov, NULL);
    if (ret == SOCKET_ERROR) {
        AJ_ErrPrintf(("AJ_ARDP_UDP_Send(): WSASend() failed. WSAGetLastError()=0x%x, status=AJ_ERR_WRITE\n", WSAGetLastError()));
        *sent = 0;
        return AJ_ERR_WRITE;
    }

    if (!WSAGetOverlappedResult(ctx->udpSock, &ov, sent, TRUE, &flags)) {
        AJ_ErrPrintf(("AJ_ARDP_UDP_Send(): WSAGetOverlappedResult() failed. WSAGetLastError()=0x%x, status=AJ_ERR_WRITE\n", WSAGetLastError()));
        return AJ_ERR_WRITE;
    }

    return status;
}
ssize_t socket_send_buffers(cutils_socket_t sock,
                            const cutils_socket_buffer_t* buffers,
                            size_t num_buffers) {
    if (num_buffers > SOCKET_SEND_BUFFERS_MAX_BUFFERS) {
        return -1;
    }

    WSABUF wsa_buffers[SOCKET_SEND_BUFFERS_MAX_BUFFERS];
    for (size_t i = 0; i < num_buffers; ++i) {
        // It's safe to cast away const here; WSABUF declares non-const
        // void* because it's used for both send and receive, but since
        // we're only sending, the data won't be modified.
        wsa_buffers[i].buf =
                reinterpret_cast<char*>(const_cast<void*>(buffers[i].data));
        wsa_buffers[i].len = buffers[i].length;
    }

    DWORD bytes_sent = 0;
    if (WSASend(sock, wsa_buffers, num_buffers, &bytes_sent, 0, nullptr,
                nullptr) != SOCKET_ERROR) {
        return bytes_sent;
    }

    return -1;
}
Beispiel #23
0
// [ranqd] 通过Iocp发送数据
int CSocket::SendData( DWORD dwNum = 0 )
{
	BOOL    bresult;
	int     err;
	DWORD   numRead;

	// [ranqd] 记录发送数据量
	InterlockedExchangeAdd(&g_SendSize, (long)dwNum);

	tQueue.rd_flip( dwNum );

	m_dwSendCount += dwNum;

	int size = tQueue.rd_size();

	// 没有数据可发送了,返回
	if( size == 0 )
	{
		return dwNum;
	}

	if( sock == INVALID_SOCKET ) return -1;

	tQueue.Lock();

	bresult = WSASend(sock,(LPWSABUF)tQueue.rd_buf(),1,&numRead,0,(LPOVERLAPPED)&m_ovOut,NULL);
	/*bresult = WriteFile(
	(HANDLE)sock,
	tQueue.rd_buf(),
	size,
	&numRead,
	(LPOVERLAPPED)&m_ovOut );*/

	tQueue.UnLock();

	// 这里,等待一个信息包.
	if (bresult) return size;

	if(bresult==SOCKET_ERROR && (ERROR_IO_PENDING != WSAGetLastError())) 
	{
		printf( "发送数据时重叠I/O操作发生错误: %s\n",GetErrMsg(err) );
		return -1;		
	}
	//err = GetLastError();

	//if( err == 64 )//连接已关闭
	//{
	//	CIocp::getInstance().PostStatus(this,&m_ovOut);//发送写数据失败的完成信息
	//	return -1;
	//}

	//if( err != 997 )
	//{
	//	printf( "发送数据时重叠I/O操作发生错误: %s\n",GetErrMsg(err) );
	//	return -1;
	//}

	return size;
}
Beispiel #24
0
bool NetSocket::PostSend()
{
    int status = _netStatus.load();
    int expected = status | NET_STATUS_CONNECTED & NET_STATUS_RECV_PENDING & (!NET_STATUS_SEND_PENDING);
    int desired = expected | NET_STATUS_SEND_PENDING;

    if (!_netStatus.compare_exchange_strong(expected, desired))
    {
        DebugPrint("PostSend: netStatus exchange failed: current(0x%x)", status);
        return false;
    }

    size_t sendQueueSize = _sendQueue.unsafe_size();
    if (sendQueueSize == 0)
    {
        DebugPrint("PostSend: send queue is empty.");
        return false;
    }

    NetIoBuffer* sendOP = new NetIoBuffer(NetCompletionOP::OP_WRITE);
    sendOP->Reset(GetSocket());

    std::vector<WSABUF> wbufs;
    wbufs.resize(sendQueueSize);

    MemoryBlock* buffer = nullptr;
    int idx = 0;
    while (_sendQueue.try_pop(buffer))
    {
        wbufs[idx].buf = buffer->GetData();
        wbufs[idx].len = buffer->GetDataLen();
        sendOP->PushData(buffer);
        idx++;
    }

    int rc = WSASend(
        GetSocket(),
        &(wbufs[0]),
        static_cast<DWORD>(wbufs.size()),
        NULL,
        0,
        &(sendOP->ol),
        NULL
    );

    if (rc == SOCKET_ERROR)
    {
        if (WSAGetLastError() != WSA_IO_PENDING)
        {
            DebugPrint("PostSend: WSASend* failed: %s", SocketGetLastErrorString().c_str());
            Disconnect(NET_CTYPE_SYSTEM);
            delete sendOP;

            return false;
        }
    }

    return true;
}
Beispiel #25
0
int uv_tcp_write(uv_loop_t* loop, uv_write_t* req, uv_tcp_t* handle,
    uv_buf_t bufs[], int bufcnt, uv_write_cb cb) {
  int result;
  DWORD bytes;

  uv_req_init(loop, (uv_req_t*) req);
  req->type = UV_WRITE;
  req->handle = (uv_stream_t*) handle;
  req->cb = cb;
  memset(&req->overlapped, 0, sizeof(req->overlapped));

  /* Prepare the overlapped structure. */
  memset(&(req->overlapped), 0, sizeof(req->overlapped));
  if (handle->flags & UV_HANDLE_EMULATE_IOCP) {
    req->event_handle = CreateEvent(NULL, 0, 0, NULL);
    if (!req->event_handle) {
      uv_fatal_error(GetLastError(), "CreateEvent");
    }
    req->overlapped.hEvent = (HANDLE) ((ULONG_PTR) req->event_handle | 1);
    req->wait_handle = INVALID_HANDLE_VALUE;
  }

  result = WSASend(handle->socket,
                   (WSABUF*)bufs,
                   bufcnt,
                   &bytes,
                   0,
                   &req->overlapped,
                   NULL);

  if (UV_SUCCEEDED_WITHOUT_IOCP(result == 0)) {
    /* Request completed immediately. */
    req->queued_bytes = 0;
    handle->reqs_pending++;
    handle->write_reqs_pending++;
    REGISTER_HANDLE_REQ(loop, handle, req);
    uv_insert_pending_req(loop, (uv_req_t*) req);
  } else if (UV_SUCCEEDED_WITH_IOCP(result == 0)) {
    /* Request queued by the kernel. */
    req->queued_bytes = uv_count_bufs(bufs, bufcnt);
    handle->reqs_pending++;
    handle->write_reqs_pending++;
    REGISTER_HANDLE_REQ(loop, handle, req);
    handle->write_queue_size += req->queued_bytes;
    if (handle->flags & UV_HANDLE_EMULATE_IOCP &&
        !RegisterWaitForSingleObject(&req->wait_handle,
          req->event_handle, post_write_completion, (void*) req,
          INFINITE, WT_EXECUTEINWAITTHREAD | WT_EXECUTEONLYONCE)) {
      SET_REQ_ERROR(req, GetLastError());
      uv_insert_pending_req(loop, (uv_req_t*)req);
    }
  } else {
    /* Send failed due to an error. */
    uv__set_sys_error(loop, WSAGetLastError());
    return -1;
  }

  return 0;
}
Beispiel #26
0
/* 2016.05.24 */
void ClientManager::recv_packet_user_exit_room(ObjectUser* info, CStreamSP* pStreamSP)
{
	bool b_success = false;

	if (pRoommanager == NULL)
	{
		pRoommanager = new Croom_manager;
	}

#if 1
	//16.06.07 by lsy
	pRoommanager->exit_room(info->sUser_info.room_num, info->sUser_info.id);

	//16.06.07 by lsy RPC send/return test

	p_mysql->rpc_send("30");

	pRoommanager->broadcast_room(info, pStreamSP, 1);

	//16.06.07

#endif
	/**********************/
	/* packet return      */
	/**********************/
	CStream* p_wStream = *pStreamSP;
	BYTE send_packet[24];
	USHORT p_Head = P_LOBBY_MSG;
	USHORT p_s_Head = P_S_QUIT_ROOM;

	/****************/
	/* Open Stream  */
	/****************/
	memset(send_packet, 0, sizeof(send_packet));
	p_wStream->StartWrite(send_packet);
	p_wStream->WriteData(&p_Head);
	p_wStream->WriteData(&p_s_Head);
	/****************/
	/* Close Stream */
	/****************/
	p_wStream->EndWrite();
	memcpy(pc_socket_info->dataBuf.buf, send_packet, sizeof(send_packet));

	DWORD writen = 0;
	/* return message by send socket */
	if (WSASend(info->sUser_info.id,
		(WSABUF*)&pc_socket_info->dataBuf,
		1,
		(DWORD *)&writen,
		0,
		&pc_socket_info->overlapped,
		NULL) == SOCKET_ERROR) {
		if (WSAGetLastError() != WSA_IO_PENDING) {
			printf("WSASend Error.. [%d] \n", WSAGetLastError());
		}
	}

}
Beispiel #27
0
////////////////////////////////////////////////////////////////////////////////
// 
// FUNCTION:	CIOCPServer::OnClientWriting
// 
// DESCRIPTION:	Called when client is writing
// 
// INPUTS:		
// 
// NOTES:	
// 
// MODIFICATIONS:
// 
// Name                  Date       Version    Comments
// N T ALMOND            06042001	1.0        Origin
// Ulf Hedlund           09062001		       Changes for OVERLAPPEDPLUS
////////////////////////////////////////////////////////////////////////////////
bool CIOCPServer::OnClientWriting(ClientContext* pContext, DWORD dwIoSize)
{
	try
	{
		//////////////////////////////////////////////////////////////////////////
		static DWORD nLastTick = GetTickCount();
		static DWORD nBytes = 0;
		
		nBytes += dwIoSize;
		
		InterlockedExchangeT pInterlockedExchange=(InterlockedExchangeT)GetProcAddress(LoadLibrary("KERNEL32.dll"),"InterlockedExchange");
		if (GetTickCount() - nLastTick >= 1000)
		{
			nLastTick = GetTickCount();
			pInterlockedExchange((LPLONG)&(m_nSendKbps), nBytes);
			nBytes = 0;
		}
		//////////////////////////////////////////////////////////////////////////

		ULONG ulFlags = MSG_PARTIAL;

		// Finished writing - tidy up
		pContext->m_WriteBuffer.Delete(dwIoSize);
		if (pContext->m_WriteBuffer.GetBufferLen() == 0)
		{
			pContext->m_WriteBuffer.ClearBuffer();
			// Write complete
			SetEvent(pContext->m_hWriteComplete);
			return true;			// issue new read after this one
		}
		else
		{
			OVERLAPPEDPLUS * pOverlap = new OVERLAPPEDPLUS(IOWrite);

			m_pNotifyProc((LPVOID) m_pFrame, pContext, NC_TRANSMIT);


			pContext->m_wsaOutBuffer.buf = (char*) pContext->m_WriteBuffer.GetBuffer();
			pContext->m_wsaOutBuffer.len = pContext->m_WriteBuffer.GetBufferLen();

			int nRetVal = WSASend(pContext->m_Socket, 
							&pContext->m_wsaOutBuffer,
							1,
							&pContext->m_wsaOutBuffer.len, 
							ulFlags,
							&pOverlap->m_ol, 
							NULL);


			if ( nRetVal == SOCKET_ERROR && WSAGetLastError() != WSA_IO_PENDING )
			{
				RemoveStaleClient( pContext, FALSE );
			}

		}
	}catch(...){}
	return false;			// issue new read after this one
}
Beispiel #28
0
static int submit_write(write_result_t *result, const void *buf, size_t len)
{
  WSABUF wsabuf;
  wsabuf.buf = (char *) buf;
  wsabuf.len = len;
  memset(&result->base.overlapped, 0, sizeof (OVERLAPPED));
  return WSASend(result->base.iocpd->socket, &wsabuf, 1, NULL, 0,
                 (LPOVERLAPPED) result, 0);
}
Beispiel #29
0
////////////////////////////////////////////////////////////////////////////////
// 
// FUNCTION:	CIOCPServer::OnClientWriting
// 
// DESCRIPTION:	Called when client is writing
// 
// INPUTS:		
// 
// NOTES:	
// 
// MODIFICATIONS:
// 
// Name                  Date       Version    Comments
// N T ALMOND            06042001	1.0        Origin
// Ulf Hedlund           09062001		       Changes for OVERLAPPEDPLUS
////////////////////////////////////////////////////////////////////////////////
bool CIOCPServer::OnClientWriting(ClientContext* pContext, DWORD dwIoSize)
{
	try
	{
		//////////////////////////////////////////////////////////////////////////
		static DWORD nLastTick = GetTickCount();
		static DWORD nBytes = 0;
		
		nBytes += dwIoSize;
		
		if (GetTickCount() - nLastTick >= 1000)
		{
			nLastTick = GetTickCount();
			InterlockedExchange((LPLONG)&(m_nSendKbps), nBytes);
			nBytes = 0;
		}
		//////////////////////////////////////////////////////////////////////////

		ULONG ulFlags = MSG_PARTIAL;

		//send 时候的PostQueuedCompletionStatus 的第二个参数始终为0,所以这里的参数dwIoSize(上层获取的)也是0,所以永远也进不去if。
		// Finished writing - tidy up
		//pContext->m_WriteBuf.Delete(dwIoSize);
		//if (pContext->m_WriteBuf.GetBufferLen() == 0)
		//{
		//	pContext->m_WriteBuf.ClearBuffer();
		//	// Write complete
		//	SetEvent(pContext->m_hWriteComplete);
		//	return true;			// issue new read after this one
		//}
		//else
		{
			OVERLAPPEDPLUS * pOverlap = new OVERLAPPEDPLUS(IOWrite);

			m_pNotifyProc((LPVOID) m_pFrame, pContext, NC_TRANSMIT);

			pContext->m_wsaOutBuffer.buf = (char*) pContext->m_WriteBuf.GetBuffer();
			pContext->m_wsaOutBuffer.len = pContext->m_WriteBuf.GetBufferLen();

			int nRetVal = WSASend(pContext->m_Socket, 
							&pContext->m_wsaOutBuffer,
							1,
							&pContext->m_wsaOutBuffer.len, 
							ulFlags,
							&pOverlap->m_ol, 
							NULL);


			if ( nRetVal == SOCKET_ERROR && WSAGetLastError() != WSA_IO_PENDING )
			{
				RemoveStaleClient( pContext, FALSE );
			}

		}
	}catch(...){}
	return false;			// issue new read after this one
}
Beispiel #30
0
EVQ_API int
win32iocp_set (struct event *ev, const unsigned int rw_flags)
{
    static WSABUF buf = {0, 0};

    struct event_queue *evq = ev->wth->evq;
    const sd_t sd = (sd_t) ev->fd;

    if ((rw_flags & EVENT_READ) && !ev->w.iocp.rov) {
	struct win32overlapped *ov = win32iocp_new_overlapped(evq);
	DWORD flags = 0;

	if (!ov) return -1;
	if (!WSARecv(sd, &buf, 1, NULL, &flags, (OVERLAPPED *) ov, NULL)) {
	    if (ev->flags & EVENT_AIO_SKIP) {
		win32iocp_del_overlapped(evq, ov);
		ev->flags |= EVENT_READ_RES | EVENT_ACTIVE;
		goto ready;
	    }
	} else if (WSAGetLastError() != WSA_IO_PENDING) {
	    win32iocp_del_overlapped(evq, ov);
	    return -1;
	}
	ov->ev = ev;
	ev->w.iocp.rov = ov;
	ev->flags |= EVENT_RPENDING;  /* IOCP read request is installed */
    }
    if ((rw_flags & EVENT_WRITE) && !ev->w.iocp.wov) {
	struct win32overlapped *ov = win32iocp_new_overlapped(evq);

	if (!ov) return -1;
	if (!WSASend(sd, &buf, 1, NULL, 0, (OVERLAPPED *) ov, NULL)) {
	    if (ev->flags & EVENT_AIO_SKIP) {
		win32iocp_del_overlapped(evq, ov);
		ev->flags |= EVENT_WRITE_RES | EVENT_ACTIVE;
		goto ready;
	    }
	} else if (WSAGetLastError() != WSA_IO_PENDING) {
	    win32iocp_del_overlapped(evq, ov);
	    return -1;
	}
	ov->ev = ev;
	ev->w.iocp.wov = ov;
	ev->flags |= EVENT_WPENDING;  /* IOCP write request is installed */
    }
    return 0;
 ready:
    if (ev->flags & EVENT_ONESHOT)
	evq_del(ev, 1);
    else if (ev->tq && !(ev->flags & EVENT_TIMEOUT_MANUAL))
	timeout_reset(ev, evq->now);

    ev->next_ready = evq->ev_ready;
    evq->ev_ready = ev;
    return 0;
}