/************************************************************************
* 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);
}
