/************************************************************************ * Function : membuffer_insert * * Parameters : * INOUT membuffer* m ; buffer whose memory size is to be increased * and appended. * IN const void* buf ; source buffer whose contents will be * copied * IN size_t buf_len ; size of the source buffer * int index ; index to determine the bounds while movinf the data * * Description : Allocates memory for the new data to be inserted. Does * memory management by moving the data from the existing memory to * the newly allocated memory and then appending the new data. * * Return : int ; * * Note : ************************************************************************/ int membuffer_insert( INOUT membuffer * m, IN const void *buf, IN size_t buf_len, int index ) { int return_code; assert( m != NULL ); if( index < 0 || index > ( int )m->length ) return UPNP_E_OUTOF_BOUNDS; if( buf == NULL || buf_len == 0 ) { return 0; } // alloc mem return_code = membuffer_set_size( m, m->length + buf_len ); if( return_code != 0 ) { return return_code; } // insert data // move data to right of insertion point memmove( m->buf + index + buf_len, m->buf + index, m->length - index ); memcpy( m->buf + index, buf, buf_len ); m->length += buf_len; m->buf[m->length] = 0; // null-terminate return 0; }
/************************************************************************ * Function : membuffer_assign * * Parameters : * INOUT membuffer* m ; buffer whose memory is to be allocated and * assigned. * IN const void* buf ; source buffer whose contents will be copied * IN size_t buf_len ; length of the source buffer * * Description : Allocate memory to membuffer* m and copy the contents * of the in parameter IN const void* buf. * * Return : int ; * UPNP_E_SUCCESS * UPNP_E_OUTOF_MEMORY * * Note : ************************************************************************/ int membuffer_assign( INOUT membuffer * m, IN const void *buf, IN size_t buf_len ) { int return_code; assert( m != NULL ); // set value to null if( buf == NULL ) { membuffer_destroy( m ); return 0; } // alloc mem return_code = membuffer_set_size( m, buf_len ); if( return_code != 0 ) { return return_code; } // copy memcpy( m->buf, buf, buf_len ); m->buf[buf_len] = 0; // null-terminate m->length = buf_len; return 0; }
void membuffer_delete(membuffer * m, size_t index, size_t num_bytes) { int return_value; size_t new_length; size_t copy_len; assert(m != NULL); if (!m || !m->length) return; /* shrink count if it goes beyond buffer */ if (index + num_bytes > m->length) { num_bytes = m->length - index; /* every thing at and after index purged */ copy_len = (size_t)0; } else { /* calc num bytes after deleted string */ copy_len = m->length - (index + num_bytes); } memmove(m->buf + index, m->buf + index + num_bytes, copy_len); new_length = m->length - num_bytes; /* trim buffer */ return_value = membuffer_set_size(m, new_length); /* shrinking should always work */ assert(return_value == 0); if (return_value != 0) return; /* don't modify until buffer is set */ m->length = new_length; m->buf[new_length] = 0; }
int membuffer_insert(membuffer * m, const void *buf, size_t buf_len, size_t index) { int return_code; assert(m != NULL); if (index > m->length) return UPNP_E_OUTOF_BOUNDS; if (!buf || !buf_len) { return 0; } /* alloc mem */ return_code = membuffer_set_size(m, m->length + buf_len); if (return_code) { return return_code; } /* insert data */ /* move data to right of insertion point */ memmove(m->buf + index + buf_len, m->buf + index, m->length - index); memcpy(m->buf + index, buf, buf_len); m->length += buf_len; /* null-terminate */ m->buf[m->length] = 0; return 0; }
/************************************************************************ * Function : membuffer_delete * * Parameters : * INOUT membuffer* m ; buffer whose memory size is to be decreased * and copied to the odified location * IN int index ; index to determine bounds while moving data * IN size_t num_bytes ; number of bytes that the data needs to * shrink by * * Description : Shrink the size of the buffer depending on the current * size of the bufer and te input parameters. Move contents from the * old buffer to the new sized buffer. * * Return : void ; * * Note : ************************************************************************/ void membuffer_delete( INOUT membuffer * m, IN int index, IN size_t num_bytes ) { int return_value; int new_length; size_t copy_len; assert( m != NULL ); if( m->length == 0 ) { return; } assert( index >= 0 && index < ( int )m->length ); // shrink count if it goes beyond buffer if( index + num_bytes > m->length ) { num_bytes = m->length - ( size_t ) index; copy_len = 0; // every thing at and after index purged } else { // calc num bytes after deleted string copy_len = m->length - ( index + num_bytes ); } memmove( m->buf + index, m->buf + index + num_bytes, copy_len ); new_length = m->length - num_bytes; return_value = membuffer_set_size( m, new_length ); // trim buffer assert( return_value == 0 ); // shrinking should always work // don't modify until buffer is set m->length = new_length; m->buf[new_length] = 0; }
int membuffer_assign(membuffer *m, const void *buf, size_t buf_len) { int return_code; assert(m != NULL); /* set value to null */ if (buf == NULL) { membuffer_destroy(m); return 0; } /* alloc mem */ return_code = membuffer_set_size(m, buf_len); if (return_code != 0) return return_code; /* copy */ if (buf_len) { memcpy(m->buf, buf, buf_len); m->buf[buf_len] = 0; /* null-terminate */ } m->length = buf_len; return 0; }
void readFromSSDPSocket(SOCKET socket) { char *requestBuf = NULL; char staticBuf[BUFSIZE]; struct sockaddr_storage __ss; ThreadPoolJob job; ssdp_thread_data *data = NULL; socklen_t socklen = sizeof(__ss); ssize_t byteReceived = 0; char ntop_buf[INET6_ADDRSTRLEN]; memset(&job, 0, sizeof(job)); requestBuf = staticBuf; /* in case memory can't be allocated, still drain the socket using a * static buffer. */ data = malloc(sizeof(ssdp_thread_data)); if (data) { /* initialize parser */ #ifdef INCLUDE_CLIENT_APIS if (socket == gSsdpReqSocket4 #ifdef UPNP_ENABLE_IPV6 || socket == gSsdpReqSocket6 #endif /* UPNP_ENABLE_IPV6 */ ) parser_response_init(&data->parser, HTTPMETHOD_MSEARCH); else parser_request_init(&data->parser); #else /* INCLUDE_CLIENT_APIS */ parser_request_init(&data->parser); #endif /* INCLUDE_CLIENT_APIS */ /* set size of parser buffer */ if (membuffer_set_size(&data->parser.msg.msg, BUFSIZE) == 0) /* use this as the buffer for recv */ requestBuf = data->parser.msg.msg.buf; else { free(data); data = NULL; } } byteReceived = recvfrom(socket, requestBuf, BUFSIZE - (size_t)1, 0, (struct sockaddr *)&__ss, &socklen); if ((byteReceived > 0) && IsBoundAddress(((struct sockaddr_in *)&__ss)->sin_addr.s_addr)) { requestBuf[byteReceived] = '\0'; switch (__ss.ss_family) { case AF_INET: inet_ntop(AF_INET, &((struct sockaddr_in *)&__ss)->sin_addr, ntop_buf, sizeof(ntop_buf)); break; #ifdef UPNP_ENABLE_IPV6 case AF_INET6: inet_ntop(AF_INET6, &((struct sockaddr_in6 *)&__ss)->sin6_addr, ntop_buf, sizeof(ntop_buf)); break; #endif /* UPNP_ENABLE_IPV6 */ default: memset(ntop_buf, 0, sizeof(ntop_buf)); strncpy(ntop_buf, "<Invalid address family>", sizeof(ntop_buf) - 1); } UpnpPrintf(UPNP_INFO, SSDP, __FILE__, __LINE__, "Start of received response ----------------------------------------------------\n" "%s\n" "End of received response ------------------------------------------------------\n" "From host %s\n", requestBuf, ntop_buf); /* add thread pool job to handle request */ if (data != NULL) { data->parser.msg.msg.length += (size_t) byteReceived; /* null-terminate */ data->parser.msg.msg.buf[byteReceived] = 0; memcpy(&data->dest_addr, &__ss, sizeof(__ss)); TPJobInit(&job, (start_routine) ssdp_event_handler_thread, data); TPJobSetFreeFunction(&job, free_ssdp_event_handler_data); TPJobSetPriority(&job, MED_PRIORITY); if (ThreadPoolAdd(&gRecvThreadPool, &job, NULL) != 0) free_ssdp_event_handler_data(data); } } else free_ssdp_event_handler_data(data); }