/*------------------------------------------------------------------------------------------------------------------
-- FUNCTION: init_udp_recieve
--
-- DATE: Febuary 6 2014
-- REVISIONS: none
--
-- DESIGNER: Ramzi Chennafi
-- PROGRAMMER: Ramzi Chennafi
--
-- INTERFACE: int init_udp_receive(HWND hwnd)
--
-- RETURNS: int, returns values that are dealt with by read_udp. Positive values deem a transfer as over.
--
-- NOTES:
-- Takes a HWND to the parent window.
--
-- Sets up the system to accept a UDP data transfer, reads the packet, acknowledges it and adds it to the main buffer. Once the transfer
-- has been completed a message is printed or the data is saved, based on the specified mode.
----------------------------------------------------------------------------------------------------------------------*/
int init_udp_receive(HWND hwnd){
DWORD Flags = 0;
int status;
char msg[MAX_SIZE];
SETTINGS * st = (SETTINGS*)GetClassLongPtr(hwnd, 0);
char ack[6] = ";ACK;";
char * tempBuffer = (char*)malloc(sizeof(char)* SocketInfo->packet_size);
SocketInfo->DataBuf.len = SocketInfo->packet_size;
SocketInfo->DataBuf.buf = tempBuffer;
if ((status = WSARecvFrom(st->server_socket, &SocketInfo->DataBuf, 1, &SocketInfo->BytesRECV, &Flags, NULL, NULL, NULL, NULL)) == SOCKET_ERROR){
sprintf_s(msg, "Error %d in TCP WSARecv(data) with return of %d\n", WSAGetLastError(), status);
activity(msg, EB_STATUSBOX);
return 0;
}
acknowledge(hwnd);
if (SocketInfo->mode == 0){
SocketInfo->DataBuf.buf[SocketInfo->BytesRECV - 1] = '\0';
strcat_s(buffer + SocketInfo->totalRecv, SocketInfo->BytesRECV, SocketInfo->DataBuf.buf);
}
SocketInfo->packets -= 1;
SocketInfo->totalRecv += SocketInfo->BytesRECV;
if (SocketInfo->totalRecv == SocketInfo->total_size || SocketInfo->packets == 0){
endTime = GetTickCount();
seconds = endTime - startTime;
return transfer_completion(hwnd, SocketInfo->mode);
}
return -2; // packets remaining
}
std::string SocketUdp::Recv(void)
{
SOCKADDR_IN sin;
int len = sizeof(sin);
char* buff = new char[sizeof(UDPPacket)];
DWORD flags = 0;
DWORD ret = 0;
WSABUF* fb = new WSABUF();
fb->buf = buff;
fb->len = sizeof(UDPPacket);
DWORD error = WSARecvFrom(this->socket_, fb, 1, &ret, &flags, reinterpret_cast<struct sockaddr*>(&sin), &len, 0, 0);
if (error == SOCKET_ERROR && WSAGetLastError() != WSAEMSGSIZE)
throw ErrorInOut("Cannot recv data");
DEBUG << "Receiving complete" << std::endl;
std::string pack = std::string(buff, ret);
delete fb;
delete buff;
return (pack);
}
CHANNEL channel(ENDPOINT ep, QUEUE que) {
SOCKET s = socket(AF_INET, SOCK_DGRAM, 0);
unsigned long ul = 1;
if (ioctlsocket(s, FIONBIO, (unsigned long *)&ul) == SOCKET_ERROR){
}
channelimpl * ch = pool::objpool<channelimpl>::allocator(1);
new (ch) channelimpl(que, s, ep);
if (ch->que != 0){
CreateIoCompletionPort((HANDLE)ch->s, ((queueimpl*)((handle*)ch->que))->iocp, 0, 0);
WSABUF * wsabuf = pool::objpool<WSABUF>::allocator(1);
wsabuf->buf = ch->buf;
wsabuf->len = 0;
DWORD bytes = 0;
DWORD flags = 0;
overlappedex * ovp = pool::objpool<overlappedex>::allocator(1);
new (ovp)overlappedex();
ovp->h = (handle*)ch;
ovp->com_type = iocp_type_ipv4_udp;
ovp->event_type = type_recv;
OVERLAPPED * ovp_ = static_cast<OVERLAPPED *>(ovp);
memset(ovp_, 0, sizeof(OVERLAPPED));
if (WSARecvFrom(ch->s, wsabuf, 1, &bytes, &flags, (sockaddr*)(&((endpointimpl*)ch->from)->addr), &((endpointimpl*)ch->from)->len, ovp_, 0) == SOCKET_ERROR){
if (WSAGetLastError() != WSA_IO_PENDING){
return false;
}
}
}
return (CHANNEL)((handle*)ch);
}
bool UDPWinSocket::Receive_data(ServerMessage *recv_msg)
{
DWORD recv_flags = 0;
DWORD recv_bytes = 0;
WSABUF recvbuff[1];
char buff[8192];
int server_length;
recvbuff[0].len = 8192;
recvbuff[0].buf = buff;
server_length = (int)sizeof(struct sockaddr_in);
memset(buff, '\0', 8192);
/* Receive bytes from client */
if ((WSARecvFrom(_socket, recvbuff, 1, &recv_bytes, &recv_flags, (struct sockaddr *)&_server, &server_length, NULL, NULL)) == SOCKET_ERROR)
{
if (WSAGetLastError() == WSAEWOULDBLOCK)
return (true);
else
{
std::cerr << "couldn't recv from" << std::endl;
return (true);
}
}
memcpy(recv_msg, (void *)buff, sizeof(ServerMessage));
std::cout << "Nom du j1: " << recv_msg->name[J1] << std::endl;
std::cout << "Nom du j2: " << recv_msg->name[J2] << std::endl;
std::cout << "Nom du j3: " << recv_msg->name[J3] << std::endl;
std::cout << "Nom du j4: " << recv_msg->name[J4] << std::endl;
return (true);
}
net_ssize_t net_recvfrom( NET_SOCKET s, void *buf, size_t len, int flags, struct sockaddr* from, socklen_t *fromlen, int timeout )
{
DWORD readbytes = 0;
DWORD rflags = ( DWORD )flags;
BOOL dwRes;
DWORD selflags;
WSABUF datadesc = { len, buf };
ResetEvent( s->o.hEvent );
if( WSARecvFrom( s->s, &datadesc, 1, &readbytes, &rflags, from, fromlen, &s->o, NULL ) == SOCKET_ERROR )
{
if( WSAGetLastError() != WSA_IO_PENDING )
return 0;
}
else
return readbytes;
dwRes = WaitForSingleObject( s->o.hEvent, timeout == NET_INF_TIMEOUT ? INFINITE : timeout );
if( dwRes == WAIT_OBJECT_0 )
{
if( !WSAGetOverlappedResult( s->s, &s->o, &readbytes, TRUE, &selflags ) )
readbytes = 0;
}
else if( dwRes == WAIT_TIMEOUT )
{
WSAGetOverlappedResult( s->s, &s->o, &readbytes, TRUE, &selflags );
readbytes = 0;
}
return readbytes;
}
void UDPSocket::receive(PMSG pMsg) {
int err = 0;
DWORD flags = 0;
DWORD numReceived = 0;
WSABUF winsockBuff;
winsockBuff.len = 1024 * 8 + 44;
winsockBuff.buf = (char*) calloc(winsockBuff.len, sizeof(char));
if (WSARecvFrom(pMsg->wParam, &(winsockBuff), 1, &numReceived, &flags,
NULL, NULL, NULL, NULL) == SOCKET_ERROR) {
if ((err = WSAGetLastError()) != WSA_IO_PENDING) {
qDebug("UDPSocket::receive(): WSARecv() failed with error %d",
err);
return;
}
}
if (numReceived == 0) {
return;
}
QByteArray writeData(winsockBuff.buf, numReceived);
// CRITICAL SECTION: Lock mutex here.
QMutexLocker locker(receiveLock_);
inputBuffer_->write(writeData);
locker.unlock();
// END CRITICAL SECTION: Unlock mutex.
delete[] winsockBuff.buf;
emit readyRead();
emit signalDataReceived(this);
}
DWORD WINAPI RecvUDPPack(PVOID)
{
DWORD dFlag, cbRet;
int iLen;
int nRet;
char achInBuf [BUFSIZE]="";
WSABUF stWSABuf;
while(!g_bStop)
{
stWSABuf.buf = achInBuf;
stWSABuf.len = BUFSIZE;
cbRet = 0;
iLen = sizeof(g_stSrcAddr);
dFlag = 0;
nRet = WSARecvFrom(g_hSock,&stWSABuf,1,&cbRet,&dFlag,(struct sockaddr *)&g_stSrcAddr,&iLen,NULL,NULL);
if(nRet == SOCKET_ERROR)
{
printf("WSARecvFrom() failed, Err:%d\n", WSAGetLastError());
}
else
{
g_poMem->InsertUDPData(*(UDP_PACK *)stWSABuf.buf);
}
}
return 0;
}
int CChannel::recvfrom(sockaddr* addr, CPacket& packet) const
{
#ifndef WIN32
msghdr mh;
mh.msg_name = addr;
mh.msg_namelen = m_iSockAddrSize;
mh.msg_iov = packet.m_PacketVector;
mh.msg_iovlen = 2;
mh.msg_control = NULL;
mh.msg_controllen = 0;
mh.msg_flags = 0;
#ifdef UNIX
fd_set set;
timeval tv;
FD_ZERO(&set);
FD_SET(m_iSocket, &set);
tv.tv_sec = 0;
tv.tv_usec = 10000;
select(m_iSocket+1, &set, NULL, &set, &tv);
#endif
int res = (int)recvmsg(m_iSocket, &mh, 0);
#else
DWORD size = CPacket::m_iPktHdrSize + packet.getLength();
DWORD flag = 0;
int addrsize = m_iSockAddrSize;
int res = WSARecvFrom(m_iSocket, (LPWSABUF)packet.m_PacketVector, 2, &size, &flag, addr, &addrsize, NULL, NULL);
res = (0 == res) ? size : -1;
#endif
if (res <= 0)
{
packet.setLength(-1);
return -1;
}
packet.setLength(res - CPacket::m_iPktHdrSize);
// convert back into local host order
//for (int i = 0; i < 4; ++ i)
// packet.m_nHeader[i] = ntohl(packet.m_nHeader[i]);
uint32_t* p = packet.m_nHeader;
for (int i = 0; i < 4; ++ i)
{
*p = ntohl(*p);
++ p;
}
if (packet.getFlag())
{
for (int j = 0, n = packet.getLength() / 4; j < n; ++ j)
*((uint32_t *)packet.m_pcData + j) = ntohl(*((uint32_t *)packet.m_pcData + j));
}
return packet.getLength();
}
static AJ_Status AJ_ARDP_UDP_Recv(void* context, uint8_t** data, uint32_t* recved, uint32_t timeout)
{
NetContext* ctx = (NetContext*) context;
DWORD ret = SOCKET_ERROR;
WSAEVENT events[2];
DWORD flags = 0;
static uint8_t buffer[UDP_SEGBMAX];
*data = NULL;
if (wsaOverlapped.hEvent == INVALID_HANDLE_VALUE) {
wsbuf.len = sizeof(buffer);
wsbuf.buf = buffer;
memset(&wsaOverlapped, 0, sizeof(WSAOVERLAPPED));
wsaOverlapped.hEvent = recvEvent;
ret = WSARecvFrom(ctx->udpSock, &wsbuf, 1, NULL, &flags, NULL, NULL, &wsaOverlapped, NULL);
if ((ret == SOCKET_ERROR) && (WSAGetLastError() != WSA_IO_PENDING)) {
AJ_ErrPrintf(("WSARecvFrom(): failed WSAGetLastError()=%d\n", WSAGetLastError()));
return AJ_ERR_READ;
}
}
events[0] = wsaOverlapped.hEvent;
events[1] = interruptEvent;
ret = WSAWaitForMultipleEvents(2, events, FALSE, timeout, TRUE);
switch (ret) {
case WSA_WAIT_EVENT_0:
flags = 0;
if (WSAGetOverlappedResult(ctx->udpSock, &wsaOverlapped, recved, TRUE, &flags)) {
WSAResetEvent(wsaOverlapped.hEvent);
wsaOverlapped.hEvent = INVALID_HANDLE_VALUE;
*data = buffer;
return AJ_OK;
} else {
AJ_ErrPrintf(("AJ_ARDP_UDP_Recv(): WSAGetOverlappedResult error; WSAGetLastError()=%d\n", WSAGetLastError()));
return AJ_ERR_READ;
}
break;
case WSA_WAIT_EVENT_0 + 1:
WSAResetEvent(interruptEvent);
return AJ_ERR_INTERRUPTED;
case WSA_WAIT_TIMEOUT:
return AJ_ERR_TIMEOUT;
break;
default:
AJ_ErrPrintf(("AJ_ARDP_UDP_Recv(): WSAWaitForMultipleEvents error; WSAGetLastError()=%d\n", WSAGetLastError()));
return AJ_ERR_READ;
}
}
/*------------------------------------------------------------------------------------------------------------------
-- FUNCTION: receiveUDP
-- DATE: 14/04/16
-- REVISIONS: (V1.0)
-- DESIGNER: Martin Minkov
-- PROGRAMMER: Martin Minkov
-- INTERFACE: int receiveUDP(LPSOCKET_INFORMATION SI, sockaddr_in server, DWORD RecvBytes, DWORD Flags)
--
--
-- RETURNS: int
- 1 if the function is successfull, otherwise 0 if it fails
-- NOTES: Call to initialize the circular buffer.
----------------------------------------------------------------------------------------------------------------------*/
int receiveUDP(LPSOCKET_INFORMATION SI, sockaddr_in server, DWORD RecvBytes, DWORD Flags)
{
int server_len;
server_len = sizeof(streamServer);
if (WSARecvFrom(SI->Socket, &(SI->DataBuf), 1, &RecvBytes, &Flags, (struct sockaddr *)&streamServer, &server_len, &(SI->Overlapped), ServerRoutine) == SOCKET_ERROR)
{
if (WSAGetLastError() != WSA_IO_PENDING)
{
return FALSE;
}
}
return TRUE;
}
void async_recvfrom(SOCKET s, char * buff, const uint32_t buflen, boost::function<void(char * buff, uint32_t len, const address & addr) > recvfromcallback){
WSABUF * pWSABUF = GetWSABUF(1);
pWSABUF->buf = buff;
pWSABUF->len = buflen;
overlappedrecvfrom * poverlappedrecvfrom = static_cast<overlappedrecvfrom*>(GetOverlapped(event_recv));
poverlappedrecvfrom->fncallback = boost::bind(recvfromcallback, buff, _1, _2);
DWORD bytes = 0;
if (SOCKET_ERROR == WSARecvFrom(s, pWSABUF, 1, &bytes, 0, (sockaddr*)&poverlappedrecvfrom->remoteaddr, &poverlappedrecvfrom->addrlen, &poverlappedrecvfrom->ovlap, 0)){
int err = WSAGetLastError();
if (err != ERROR_IO_PENDING){
throw exception::RecvfromException("Recvfrom fail", err);
}
}
}
/* read operation on common fd (udp)
* @Handle -- the common fd
* @Dst -- destination address information
* @DstLen -- sizeof Dst
* @Buffer -- data buffer
* @BufferSize -- buffer size in bytes
* @Callback -- callback function when read successful
* @Args -- argument to callback
* return TRUE -- success, else error
*/
BOOL
CommIOCPUdpRead(
COMMFD_HANDLE Handle,
PSOCKADDR Dst,
PINT DstLen,
PBYTE Buffer,
DWORD BufferSize,
READ_CALLBACK Callback,
PVOID Args
)
{
INT Ret;
PCOMMIOCP CommIOCP;
DWORD Flags = MSG_PARTIAL, Bytes = 0;
PCOMM_SOCKET_IO_CTX IOData;
PCOMMFD Commfd = (PCOMMFD)Handle;
if (!Callback || !Commfd || Commfd->Type != COMM_UDP || Commfd->Handle.Socket == INVALID_SOCKET) {
LOG_ERROR("bad args");
return (FALSE);
}
CommIOCP = Commfd->CommIOCP;
IOData = (PCOMM_SOCKET_IO_CTX)CommIOCPIOCtxCreate(Commfd->CommIOCP, IO_SOCK_READ);
if (IOData == NULL) {
LOG_ERROR("create socket IO context failed");
return (FALSE);
}
IOData->WSABuffer.buf = (CHAR *)Buffer;
IOData->WSABuffer.len = BufferSize;
IOData->Data.Callback.Read = Callback;
IOData->Data.Args = Args;
CommIOCPFDAddRef(Commfd);
Ret = WSARecvFrom(Commfd->Handle.Socket, &IOData->WSABuffer, 1, &Bytes, &Flags, Dst, DstLen, &IOData->Data.OL, NULL);
if (Ret == SOCKET_ERROR && WSAGetLastError() != WSA_IO_PENDING) {
LOG_ERROR("WSARecvFrom failed [%d]", WSAGetLastError());
CommIOCPIOCtxDestroy(Commfd->CommIOCP, &IOData->Data);
CommIOCPFDRelease(Commfd);
return (FALSE);
}
return (TRUE);
}
int WinSocket::recDataFrom(std::string & buffer , int blocksize)
{
WSABUF Databuf;
DWORD receive;
struct sockaddr_in in;
char buf[1024];
int len;
Databuf.len = blocksize + 1;
Databuf.buf = buf;
receive = blocksize;
int size = sizeof(in);
if ((len = WSARecvFrom(this->sock, &Databuf, 1, &receive, 0, (SOCKADDR *)& in, &size, 0, 0)) == SOCKET_ERROR)
return (-1);
buffer = Databuf.buf;
return len;
}
Network::Packet* Network::UDPSocketWindows::recvPacket(struct sockaddr *sockAddr) const
{
Network::Content content;
int addrlen;
WSABUF buf;
DWORD bytes;
DWORD flags = 0;
buf.buf = reinterpret_cast<char *>(&content);
memset((void*)&content, 0, 256);
buf.len = 256;
addrlen = sizeof(*((struct sockaddr_in*)sockAddr));
if (WSARecvFrom(this->fd_, &buf, 1, &bytes, &flags, sockAddr, &addrlen, NULL, NULL) == SOCKET_ERROR || bytes <= 0)
return (NULL);
Packet *packet = new Packet(content);
return packet;
}
int aio_socket_recvfrom_v(aio_socket_t socket, socket_bufvec_t* vec, int n, aio_onrecvfrom proc, void* param)
{
DWORD flags = 0;
struct aio_context *ctx = (struct aio_context*)socket;
struct aio_context_action *aio;
aio = util_alloc(ctx);
aio->action = iocp_recvfrom;
aio->recvfrom.proc = proc;
aio->recvfrom.param = param;
aio->recvfrom.addrlen = sizeof(aio->recvfrom.addr);
assert(0 == (AIO_READ & InterlockedOr(&ctx->flags, AIO_READ)));
if(SOCKET_ERROR == WSARecvFrom(ctx->socket, vec, (DWORD)n, NULL/*&dwBytes*/, &flags, (struct sockaddr *)&aio->recvfrom.addr, &aio->recvfrom.addrlen, &aio->overlapped, NULL))
{
return aio_socket_result(aio, AIO_READ);
}
return 0;
}
int
enet_socket_receive (ENetSocket socket,
ENetAddress * address,
ENetBuffer * buffers,
size_t bufferCount)
{
INT sinLength = sizeof (struct sockaddr_in);
DWORD flags = 0,
recvLength;
struct sockaddr_in sin;
memset(&sin, 0, sizeof sin);
if (WSARecvFrom (socket,
(LPWSABUF) buffers,
(DWORD) bufferCount,
& recvLength,
& flags,
address != NULL ? (struct sockaddr *) & sin : NULL,
address != NULL ? & sinLength : NULL,
NULL,
NULL) == SOCKET_ERROR)
{
switch (WSAGetLastError ())
{
case WSAEWOULDBLOCK:
case WSAECONNRESET:
return 0;
}
return -1;
}
if (flags & MSG_PARTIAL)
return -1;
if (address != NULL)
{
address -> host = (enet_uint32) sin.sin_addr.s_addr;
address -> port = ENET_NET_TO_HOST_16 (sin.sin_port);
}
return (int) recvLength;
}
/*
* Threaded recvfrom
*/
static
ssize_t
Nrecvfrom(int fd, void* buf, size_t len, int flags,
struct sockaddr* from, int* fromlen)
{
ssize_t r;
int ret;
WSABUF wbuf;
wbuf.len = (u_long)len;
wbuf.buf = (char FAR*)buf;
ret = WSARecvFrom(fhand[fd].sock, &wbuf, 1, &r, &flags,
from, fromlen, NULL, NULL);
if (ret == SOCKET_ERROR) {
return (-1);
}
return (r);
}
ISocket *CWSocket::receivUdp(char *message, int size, int *received)
{
sockaddr_in tmpInfo;
int sizeTmp = sizeof(tmpInfo);
DWORD flags;
WSABUF dataBuf;
if ((this->_type != ISocket::UDP) || (this->_sock == -1) || (this->_func == ISocket::CLIENT))
throw Exception("This socket type isn't valid.");
if (this->_func == ISocket::NONE)
throw Exception("This socket type isn't initialized.");
CWSocket *newSocket = new CWSocket(this);
dataBuf.buf = message;
dataBuf.len = size;
flags = 0;
if (WSARecvFrom(this->_sock, &dataBuf, 1, (DWORD *)received, &flags, (SOCKADDR*)&tmpInfo, &sizeTmp, NULL, NULL) != 0)
throw Exception("WSARecvFrom has failed.");
newSocket->setInfo(tmpInfo);
return (newSocket);
}
int UDPClientSocketWindows::SNRead(char *msg, unsigned int size)
{
WSABUF DataBuff;
DWORD BytesReceived;
struct sockaddr_in from;
DWORD Flags = 0;
int structsize;
structsize = sizeof(from);
DataBuff.buf = (msg);
DataBuff.len = size;
if (WSARecvFrom(this->_socket, &DataBuff, 1, &BytesReceived, &Flags, (SOCKADDR *)&(from), &structsize, NULL, NULL) == SOCKET_ERROR)
// if (WSARecvFrom(this->_socket, &DataBuff, 1, &BytesReceived, &Flags, (SOCKADDR *)&(from), &structsize, NULL, NULL) == SOCKET_ERROR)
{
this->_error = CANTREAD;
return (-1);
}
this->_error = NOERRORSOCKET;
return (BytesReceived);
}
// Receives an UDP packet. Returns length of received message, or 0 if nothing is received.
int ioHelperRecvFrom(struct s_io_handle *handle, unsigned char *recv_buf, const int recv_buf_size, struct sockaddr *source_sockaddr, socklen_t *source_sockaddr_len) {
int len;
#if defined(IO_LINUX) || defined(IO_BSD)
len = recvfrom(handle->fd, recv_buf, recv_buf_size, 0, source_sockaddr, source_sockaddr_len);
#elif defined(IO_WINDOWS)
WSABUF wsabuf;
DWORD flags;
len = 0;
wsabuf.buf = (char *)recv_buf;
wsabuf.len = recv_buf_size;
flags = 0;
if(!(handle->ovlr_used)) {
if(WSARecvFrom(handle->fd, &wsabuf, 1, NULL, &flags, source_sockaddr, source_sockaddr_len, &handle->ovlr, NULL) == 0) {
handle->ovlr_used = 1;
}
else {
if(WSAGetLastError() == WSA_IO_PENDING) {
handle->ovlr_used = 1;
}
}
}
#else
#error not implemented
len = 0;
#endif
if(len > 0) {
return len;
}
else {
return 0;
}
}
static ngx_int_t
ngx_event_post_one_udp_recv(ngx_listening_t *ls, ngx_udp_recv_event_t *event)
{
int rc;
DWORD flags;
WSABUF wsabuf;
ngx_err_t err;
event->pool = ngx_create_pool(ls->pool_size, ngx_cycle->log);
if (event->pool == NULL) {
return NGX_ERROR;
}
event->buffer = ngx_create_temp_buf(event->pool, ls->udp_recv_buffer_size);
if (event->buffer == NULL) {
ngx_destroy_pool(event->pool);
return NGX_ERROR;
}
wsabuf.buf = (CHAR *) event->buffer->last;
wsabuf.len = (DWORD) (event->buffer->end - event->buffer->last);
flags = 0;
event->socklen = NGX_SOCKADDRLEN;
rc = WSARecvFrom(ls->connection->fd, &wsabuf, 1, NULL, &flags,
(struct sockaddr *) event->sockaddr,
(LPINT) &event->socklen,
(LPWSAOVERLAPPED) &event->event.ovlp, NULL);
err = ngx_socket_errno;
if (rc == SOCKET_ERROR && err != WSA_IO_PENDING) {
ngx_log_error(NGX_LOG_ALERT, ngx_cycle->log, err,
"WSARecvFrom() failed");
return NGX_ERROR;
}
return NGX_OK;
}
return len;
}
int WinSocket::sendBinary(void *point, int len)
{
WSABUF Databuf;
Databuf.len = len;
Databuf.buf = (CHAR * )point;
if (WSASend(this->sock, &Databuf, 1, &Databuf.len, 0,0,0) == SOCKET_ERROR)
return NULL;
return 0;
}
int WinSocket::recBinaryFrom(void* buffer , int blocksize, std::string &ip)
{
WSABUF Databuf;
DWORD receive;
struct sockaddr_in in;
int len;
void GSocketUdpServer::Receive(void *s, unsigned int size)
{
#if defined (GWIN)
int ret;
int len = sizeof(this->_sockaddr);
DWORD dwBytesRet, dwFlags;
WSABUF wbuf;
wbuf.len = size;
wbuf.buf = (char *)s;
dwFlags = 0;
ret = WSARecvFrom(this->_socket, &wbuf, 1, &dwBytesRet, &dwFlags, reinterpret_cast <sockaddr*> (&this->_sockaddr), &len, NULL, NULL);
if (ret == 0)
return ;
throw GException("GSocketUdpSever", "Error WSARecvFrom");
#else
int li = 0;
li = recvfrom(this->_socket, s, size, 0, 0, 0);
if (li <= 0)
throw GException("GSocketUdpServer", "Error recvfrom");
#endif
}
void SessionUDP::DoAsyncRecv()
{
#ifdef VHWD_WINDOWS
TempPtrT<MyOverLappedEx> q=lkfq_recv.getq();
if(!q)
{
return;
}
MyOverLappedEx &idat(*q);
int bRet=WSARecvFrom(sk_local.sock,
&idat.dbuf[0],
idat.dbuf[1].buf?2:1,
&idat.size,
&iocp_flag_recv,
idat.peer,
idat.peer,
&idat.olap,
NULL);
if(bRet!=0 && WSAGetLastError()!=WSA_IO_PENDING)
{
--m_nPendingRecv;
Disconnect();
return;
}
else
{
q.release();
}
#else
ep_ctl(EPOLLIN);
#endif
}
bool socket_t::b_recfrom()
{
bool result;
int ret = WSARecvFrom();
if(ret == SOCKET_ERROR) {
int socket_error = _WSAGetLastError();
if(socket_error == WSA_IO_PENDING) {
D(bug("WSARecvFrom() i/o pending\r\n"));
result = true;
} else {
D(bug("_WSAGetLastError() returned %d\r\n", socket_error));
result = false;
}
} else /*if(ret == 0) */ {
D(bug("WSARecvFrom() ok\r\n"));
// Completion routine call is already scheduled.
result = true;
}
return result;
}
int
enet_socket_receive (ENetSocket socket,
ENetAddress * address,
ENetBuffer * buffers,
size_t bufferCount)
{
INT length = sizeof (struct sockaddr_in6);
DWORD flags = 0,
recvLength;
if (WSARecvFrom (socket,
(LPWSABUF) buffers,
(DWORD) bufferCount,
& recvLength,
& flags,
address != NULL ? (struct sockaddr *) address : NULL,
address != NULL ? & length : NULL,
NULL,
NULL) == SOCKET_ERROR)
{
switch (WSAGetLastError ())
{
case WSAEWOULDBLOCK:
case WSAECONNRESET:
return 0;
}
return -1;
}
if (flags & MSG_PARTIAL)
return -1;
if (address != NULL)
address -> port = ENET_NET_TO_HOST_16 (address -> port);
return (int) recvLength;
}
void CWin32Socket::ReceiveFrom(TWin32Message& aMessage)
{
__ASSERT_DEBUG(iReceiveMessage == NULL, Panic(EWinSockPrtCWin32SocketMultipleReceiveFromRequests));
iReceiveMessage = &aMessage;
WSP_LOG(WspLog::Printf(_L("CWin32Socket::ReceiveFrom: this: 0x%x, bytes to get: %d"), this, iReceiveMessage->WriteBuffer().MaxLength()));
iReceiveBuffer.buf = reinterpret_cast<char*>(const_cast<TUint8*>(iReceiveMessage->WriteBuffer().Ptr()));
iReceiveBuffer.len = iReceiveMessage->WriteBuffer().MaxLength();
iFlags = 0;
iReceiveOverlapped.hEvent = (void*) this;
iReceiveFromAddressLength = sizeof(struct sockaddr_in);
iReceiveFromClientAddress = (TInetAddr*)iReceiveMessage->ReadBuffer().Ptr();
DWORD numberOfBytesReceived;
TInt ret = WSARecvFrom(iSocket, &iReceiveBuffer, 1, &numberOfBytesReceived, &iFlags, (LPSOCKADDR)&iReceiveFromAddress, &iReceiveFromAddressLength, &iReceiveOverlapped, &ReceiveFromCompletion);
if (ret == SOCKET_ERROR)
{
TInt err = WSAGetLastError();
if (err != WSA_IO_PENDING)
{
WSP_LOG(WspLog::Printf(_L("\tsocket error: %d"), err));
Complete(iReceiveMessage, MapWinSockError(err));
}
}
}
virtual result_t process()
{
int32_t nError;
m_DataBuf.len = (DWORD)m_buf.length();
m_DataBuf.buf = &m_buf[0];
m_dwFlags = 0;
sz = sizeof(addr_info);
if (WSARecvFrom(m_s, &m_DataBuf, 1, NULL, &m_dwFlags,
(sockaddr*)&addr_info, &sz, this, NULL) != SOCKET_ERROR)
return CHECK_ERROR(CALL_E_PENDDING);
nError = GetLastError();
if (nError == ERROR_BROKEN_PIPE)
return CALL_RETURN_NULL;
if (nError == ERROR_IO_PENDING)
return CHECK_ERROR(CALL_E_PENDDING);
return CHECK_ERROR(-nError);
}
/**
* \brief The Windows implementation of readv() socket helper function.
* \param fd the socket descriptor to read the data.
* \param iov the iovector to store the data.
* \param iovcnt number of element that should be filled.
* \param addr if not NULL it considers using a UDP socket, otherwise it
* considers using a TCP one.
* \param addr_size pointer on address size, will be filled by this function.
* \return number of bytes read or -1 if error.
* \warning this function work only with socket!
*/
static ssize_t net_sock_readv_win(int fd, const struct iovec *iov,
size_t iovcnt, const struct sockaddr* addr, socklen_t* addr_size)
{
WSABUF winiov[iovcnt];
DWORD winiov_len = iovcnt;
size_t i = 0;
DWORD ret = 0;
if(iovcnt > sizeof(winiov))
{
return -1;
}
for(i = 0 ; i < iovcnt ; i++)
{
winiov[i].len = iov[i].iov_len;
winiov[i].buf = iov[i].iov_base;
}
if(addr) /* UDP case */
{
if(WSARecvFrom(fd, winiov, winiov_len, &ret, NULL, (struct sockaddr*)addr,
addr_size, NULL, NULL) != 0)
{
return -1;
}
}
else /* TCP case */
{
if(WSARecv(fd, winiov, winiov_len, &ret, NULL, NULL, NULL) != 0)
{
return -1;
}
}
return (ssize_t)ret;
}
/*------------------------------------------------------------------------------------------------------------------
-- FUNCTION: process_header
--
-- DATE: Febuary 6 2014
-- REVISIONS: none
--
-- DESIGNER: Ramzi Chennafi
-- PROGRAMMER: Ramzi Chennafi
--
-- INTERFACE: int process_header(HWND hwnd, SOCKET recv), takes the parent HWND as an argument and the socket the header was sent to.
--
-- RETURNS: void
--
-- NOTES:
-- Retrieves the header datagram from the passed in socket. If using TCP, just grabs it. If on UDP, the header is grabbed then
-- acknowledged. If no header is successfully grabbed, the function is called on every WM_SOCKET message until it is.
----------------------------------------------------------------------------------------------------------------------*/
int process_header(HWND hwnd, SOCKET recv){
SETTINGS * st = (SETTINGS*)GetClassLongPtr(hwnd, 0);
DWORD RecvBytes = 0, Flags = 0;
int status, server_len;
struct sockaddr_in server;
char msg[MAX_SIZE];
char * hdBuffer = (char*)malloc(sizeof(char)* HEADER_SIZE);
memset(hdBuffer, 0, HEADER_SIZE);
LPWSABUF wsaBuffer = (LPWSABUF)malloc(sizeof(WSABUF));
wsaBuffer->len = HEADER_SIZE;
wsaBuffer->buf = hdBuffer;
if (st->protocol == TCP){
if ((status = WSARecv(recv, wsaBuffer, 1, &RecvBytes, &Flags, NULL, NULL)) == SOCKET_ERROR){
sprintf_s(msg, "Error %d in TCP WSARecv(header) with return of %d\n", WSAGetLastError(), status);
activity(msg, EB_STATUSBOX);
}
if (wsaBuffer->buf[0] != ';'){ // I really should have used an uncommon character here
return -1;
}
}
else{
server_len = sizeof(server);
if ((status = WSARecvFrom(st->server_socket, wsaBuffer, 1, &RecvBytes, &Flags, (struct sockaddr *)&server, &server_len, NULL, NULL)) == SOCKET_ERROR){
return -1;
}
acknowledge(hwnd);
}
grab_header_info(hdBuffer);
return 1;
}
