int crFileRecv( void ) { CRMessage *msg; int i; if (!cr_file.num_conns) { return 0; } for ( i = 0; i < cr_file.num_conns; i++ ) { CRFileBuffer *file_buffer; unsigned int len; CRConnection *conn = cr_file.conns[i]; crFileReadExact( conn, &len, sizeof( len ) ); CRASSERT( len > 0 ); if ( len <= conn->buffer_size ) { file_buffer = (CRFileBuffer *) crFileAlloc( conn ) - 1; } else { file_buffer = (CRFileBuffer *) crAlloc( sizeof(*file_buffer) + len ); file_buffer->magic = CR_FILE_BUFFER_MAGIC; file_buffer->kind = CRFileMemoryBig; file_buffer->pad = 0; } file_buffer->len = len; crFileReadExact( conn, file_buffer + 1, len ); conn->recv_credits -= len; msg = (CRMessage *) (file_buffer + 1); crNetDispatchMessage( cr_file.recv_list, conn, msg, len ); /* CR_MESSAGE_OPCODES is freed in * crserverlib/server_stream.c * * OOB messages are the programmer's problem. -- Humper 12/17/01 */ if (msg->header.type != CR_MESSAGE_OPCODES && msg->header.type != CR_MESSAGE_OOB) { crFileFree( conn, file_buffer + 1 ); } } return 1; }
static void crSDPHandleNewMessage( CRConnection *conn, CRMessage *msg, unsigned int len ) { CRSDPBuffer *buf = ((CRSDPBuffer *) msg) - 1; /* build a header so we can delete the message later */ buf->magic = CR_SDP_BUFFER_MAGIC; buf->kind = CRSDPMemory; buf->len = len; buf->pad = 0; crNetDispatchMessage( cr_sdp.recv_list, conn, msg, len ); }
static void _crVBoxHGSMIReceiveMessage(CRConnection *conn, PCRVBOXHGSMI_CLIENT pClient) { uint32_t len; CRVBOXHGSMIBUFFER* pSysBuf; CRMessage *msg; CRMessageType cached_type; len = conn->cbBuffer; Assert(len > 0); Assert(conn->pBuffer); CRASSERT(len > 0); CRASSERT(conn->pBuffer); #ifndef IN_GUEST if (conn->allow_redir_ptr) { #endif //IN_GUEST CRASSERT(conn->buffer_size >= sizeof(CRMessageRedirPtr)); pSysBuf = _crVBoxHGSMISysMemAlloc( conn->buffer_size ); pSysBuf->u32Len = sizeof(CRMessageRedirPtr); msg = (CRMessage *)CRVBOXHGSMI_BUF_DATA(pSysBuf); msg->header.type = CR_MESSAGE_REDIR_PTR; msg->redirptr.pMessage = (CRMessageHeader*) (conn->pBuffer); msg->header.conn_id = msg->redirptr.pMessage->conn_id; cached_type = msg->redirptr.pMessage->type; conn->cbBuffer = 0; conn->pBuffer = NULL; #ifndef IN_GUEST } else { if ( len <= conn->buffer_size ) { /* put in pre-allocated buffer */ hgcm_buffer = (CRVBOXHGCMBUFFER *) crVBoxHGCMAlloc( conn ) - 1; } else { /* allocate new buffer, * not using pool here as it's most likely one time transfer of huge texture */ hgcm_buffer = (CRVBOXHGCMBUFFER *) crAlloc( sizeof(CRVBOXHGCMBUFFER) + len ); hgcm_buffer->magic = CR_VBOXHGCM_BUFFER_MAGIC; hgcm_buffer->kind = CR_VBOXHGCM_MEMORY_BIG; hgcm_buffer->allocated = sizeof(CRVBOXHGCMBUFFER) + len; # ifdef RT_OS_WINDOWS hgcm_buffer->pDDS = NULL; # endif } hgcm_buffer->len = len; _crVBoxHGCMReadBytes(conn, hgcm_buffer + 1, len); msg = (CRMessage *) (hgcm_buffer + 1); cached_type = msg->header.type; } #endif //IN_GUEST conn->recv_credits -= len; conn->total_bytes_recv += len; conn->recv_count++; crNetDispatchMessage( g_crvboxhgsmi.recv_list, conn, msg, len ); /* CR_MESSAGE_OPCODES is freed in crserverlib/server_stream.c with crNetFree. * OOB messages are the programmer's problem. -- Humper 12/17/01 */ if (cached_type != CR_MESSAGE_OPCODES && cached_type != CR_MESSAGE_OOB && cached_type != CR_MESSAGE_GATHER) { _crVBoxHGSMIFree(conn, msg); } }
/** * Receive the next message on the given connection. * If we're being called by crSDPRecv(), we already know there's * something to receive. */ static void crSDPReceiveMessage(CRConnection *conn) { CRMessage *msg; CRMessageType cached_type; CRSDPBuffer *sdp_buffer; unsigned int len, total, leftover; const CRSocket sock = conn->sdp_socket; /* this reads the length of the message */ if ( __sdp_read_exact( sock, &len, sizeof(len)) <= 0 ) { __sdp_dead_connection( conn ); return; } if (conn->swap) len = SWAP32(len); CRASSERT( len > 0 ); if ( len <= conn->buffer_size ) { sdp_buffer = (CRSDPBuffer *) crSDPAlloc( conn ) - 1; CRASSERT(sdp_buffer->magic == CR_SDP_BUFFER_MAGIC); CRASSERT(sdp_buffer->allocated > 0); } else { crWarning("Sending as BIG, the performance is going to tank!!!. You need larger buffers!!!"); sdp_buffer = (CRSDPBuffer *) crAlloc( sizeof(*sdp_buffer) + len ); sdp_buffer->magic = CR_SDP_BUFFER_MAGIC; sdp_buffer->kind = CRSDPMemoryBig; sdp_buffer->pad = 0; } sdp_buffer->len = len; /* if we have set a userbuf, and there is room in it, we probably * want to stick the message into that, instead of our allocated * buffer. */ leftover = 0; total = len; if ((conn->userbuf != NULL) && (conn->userbuf_len >= (int) sizeof(CRMessageHeader))) { leftover = len - sizeof(CRMessageHeader); total = sizeof(CRMessageHeader); } if ( __sdp_read_exact( sock, sdp_buffer + 1, total) <= 0 ) { crWarning( "Bad juju: %d %d on sock %x", sdp_buffer->allocated, total, sock ); crFree( sdp_buffer ); __sdp_dead_connection( conn ); return; } conn->recv_credits -= total; conn->total_bytes_recv += total; msg = (CRMessage *) (sdp_buffer + 1); cached_type = msg->header.type; if (conn->swap) { msg->header.type = (CRMessageType) SWAP32( msg->header.type ); msg->header.conn_id = (CRMessageType) SWAP32( msg->header.conn_id ); } /* if there is still data pending, it should go into the user buffer */ if (leftover) { unsigned int handled = crSDPUserbufRecv(conn, msg); /* if there is anything left, plop it into the recv_buffer */ if (leftover - handled) { if ( __sdp_read_exact( sock, sdp_buffer + 1 + total, leftover-handled) <= 0 ) { crWarning( "Bad juju: %d %d", sdp_buffer->allocated, leftover-handled); crFree( sdp_buffer ); __sdp_dead_connection( conn ); return; } } conn->recv_credits -= handled; conn->total_bytes_recv += handled; } crNetDispatchMessage( cr_sdp.recv_list, conn, msg, len ); /* CR_MESSAGE_OPCODES is freed in crserverlib/server_stream.c with crNetFree. * OOB messages are the programmer's problem. -- Humper 12/17/01 */ if (cached_type != CR_MESSAGE_OPCODES && cached_type != CR_MESSAGE_OOB && cached_type != CR_MESSAGE_GATHER) { crSDPFree( conn, sdp_buffer + 1 ); } }