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; }
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); } } }
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); }
/* 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; }
/*@ 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); } } } }
/** * 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; }
// 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; }
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 }
//发送函数 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 } } }
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; }
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; }
/* 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; }
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; }
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; }
// [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; }
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; }
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; }
/* 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()); } } }
//////////////////////////////////////////////////////////////////////////////// // // 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 }
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); }
//////////////////////////////////////////////////////////////////////////////// // // 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 }
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; }