TcpServer * TcpServer_New(void)
{
TcpServer *thiz = NULL;
do
{
TinyRet ret = TINY_RET_OK;
thiz = (TcpServer *)tiny_malloc(sizeof(TcpServer));
if (thiz == NULL)
{
break;
}
ret = TcpServer_Construct(thiz);
if (RET_FAILED(ret))
{
TcpServer_Delete(thiz);
thiz = NULL;
break;
}
}
while (0);
return thiz;
}
TinyMutex * TinyMutex_New(void)
{
TinyMutex *thiz = NULL;
do
{
TinyRet ret = TINY_RET_OK;
thiz = (TinyMutex *)tiny_malloc(sizeof(TinyMutex));
if (thiz == NULL)
{
break;
}
ret = TinyMutex_Construct(thiz);
if (RET_FAILED(ret))
{
TinyMutex_Delete(thiz);
thiz = NULL;
break;
}
}
while (0);
return thiz;
}
UpnpObjectList * UpnpObjectList_New(void)
{
UpnpObjectList *thiz = NULL;
do
{
TinyRet ret = TINY_RET_OK;
thiz = (UpnpObjectList *)tiny_malloc(sizeof(UpnpObjectList));
if (thiz == NULL)
{
break;
}
ret = UpnpObjectList_Construct(thiz);
if (RET_FAILED(ret))
{
UpnpObjectList_Delete(thiz);
thiz = NULL;
break;
}
} while (0);
return thiz;
}
static TinyRet udp_join_multicast_group_with_all_ip(int fd, const char *group)
{
IP_ADAPTER_INFO * pNextAdapter = NULL;
IP_ADAPTER_INFO * ipAdaptersInfo = NULL;
ULONG infolen = sizeof(IP_ADAPTER_INFO);
ipAdaptersInfo = (IP_ADAPTER_INFO *)tiny_malloc(infolen);
if (GetAdaptersInfo(ipAdaptersInfo, &infolen) == ERROR_BUFFER_OVERFLOW)
{
tiny_free(ipAdaptersInfo);
ipAdaptersInfo = (IP_ADAPTER_INFO *)tiny_malloc(infolen);
}
if (GetAdaptersInfo(ipAdaptersInfo, &infolen))
{
tiny_free(ipAdaptersInfo);
return TINY_RET_E_INTERNAL;
}
for (pNextAdapter = ipAdaptersInfo; pNextAdapter; pNextAdapter = pNextAdapter->Next)
{
IP_ADDR_STRING *pNextIp = NULL;
for (pNextIp = &(pNextAdapter->IpAddressList); pNextIp; pNextIp = pNextIp->Next)
{
unsigned long ip = inet_addr(pNextIp->IpAddress.String);
if (ip == 0)
{
break;
}
LOG_D(TAG, "join MultiGroup ip: %s", pNextIp->IpAddress.String);
udp_join_multicast_group_with_ip(fd, group, ip);
}
}
tiny_free(ipAdaptersInfo);
return TINY_RET_OK;
}
void *malloc(size_t size)
{
void *ptr;
if (size <= TINY_N)
ptr = tiny_malloc(size);
else if (size <= SMALL_N)
ptr = small_malloc(size);
else
ptr = large_malloc(size);
return (ptr);
}
TinyRet TcpClient_StartRecv(TcpClient *thiz, TcpClientReceiveListener listener, void *ctx, uint32_t timeout)
{
TinyRet ret = TINY_RET_OK;
char * buf = NULL;
int size = 0;
RETURN_VAL_IF_FAIL(thiz, TINY_RET_E_ARG_NULL);
RETURN_VAL_IF_FAIL(listener, TINY_RET_E_ARG_NULL);
do
{
if (thiz->status != TCP_CLIENT_CONNECTED)
{
ret = TINY_RET_E_SOCKET_DISCONNECTED;
break;
}
ret = tiny_tcp_waiting_for_read(thiz->socket_fd, timeout);
if (RET_FAILED(ret))
{
break;
}
buf = (char *)tiny_malloc(thiz->recv_buf_size);
if (buf == NULL)
{
ret = TINY_RET_E_OUT_OF_MEMORY;
break;
}
while (true)
{
memset(buf, 0, thiz->recv_buf_size);
size = tiny_tcp_read(thiz->socket_fd, buf, thiz->recv_buf_size);
if (size <= 0)
{
ret = TINY_RET_E_SOCKET_READ;
break;
}
listener(thiz, buf, size, ctx);
}
}
while (false);
if (buf != NULL)
{
tiny_free(buf);
}
return ret;
}
void *malloc(size_t size)
{
static char flag = 0;
if (size <= 0)
return (NULL);
if (!flag)
{
g_pool.tiny_m = NULL;
g_pool.small_m = NULL;
g_pool.large_m = NULL;
flag = 1;
}
if (size <= TINY_M)
return (tiny_malloc(size));
else if (size <= SMALL_M)
return (small_malloc(size));
else
return (large_malloc(size));
return (NULL);
}
UpnpActionInvoker * UpnpActionInvoker_New(UpnpHttpManager *http)
{
UpnpActionInvoker *thiz = NULL;
do
{
thiz = (UpnpActionInvoker *)tiny_malloc(sizeof(UpnpActionInvoker));
if (thiz == NULL)
{
break;
}
if (RET_FAILED(UpnpActionInvoker_Construct(thiz, http)))
{
UpnpActionInvoker_Delete(thiz);
thiz = NULL;
break;
}
} while (0);
return thiz;
}
TinyRet TcpClient_Recv(TcpClient *thiz, char **bytes, uint32_t *size, uint32_t timeout)
{
TinyRet ret = TINY_RET_OK;
RETURN_VAL_IF_FAIL(thiz, TINY_RET_E_ARG_NULL);
do
{
if (thiz->status != TCP_CLIENT_CONNECTED)
{
ret = TINY_RET_E_SOCKET_DISCONNECTED;
break;
}
ret = tiny_tcp_waiting_for_read(thiz->socket_fd, timeout);
if (RET_FAILED(ret))
{
break;
}
*bytes = (char *)tiny_malloc(thiz->recv_buf_size);
if (*bytes == NULL)
{
ret = TINY_RET_E_OUT_OF_MEMORY;
break;
}
memset(*bytes, 0, thiz->recv_buf_size);
*size = tiny_tcp_read(thiz->socket_fd, *bytes, thiz->recv_buf_size);
if (*size <= 0)
{
ret = TINY_RET_E_SOCKET_READ;
break;
}
} while (false);
return ret;
}
