mirrors
/
FreeRDP
mirror of https://github.com/FreeRDP/FreeRDP
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

hardening 

Start to add missing checks for:
* *alloc
* *_New
This commit is contained in:
Bernhard Miklautz 2015-03-23 17:25:23 +01:00
parent 90579ae16f
commit 3c7662517c
29 changed files with 510 additions and 237 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
channels/audin/client/opensles/opensl_io.c
View File

@ -234,7 +234,9 @@ OPENSL_STREAM *android_OpenRecDevice(char *name, int sr, int inchannels,
OPENSL_STREAM *p;
p = (OPENSL_STREAM *) calloc(sizeof(OPENSL_STREAM),1);
memset(p, 0, sizeof(OPENSL_STREAM));
if (!p)
return NULL;
memset(p, 0, sizeof(OPENSL_STREAM));
p->inchannels = inchannels;
p->sr = sr;
@ -314,7 +316,14 @@ void bqRecorderCallback(SLAndroidSimpleBufferQueueItf bq, void *context)
assert(p->queue);
e = calloc(1, sizeof(queue_element));
if (!e)
return;
e->data = calloc(p->buffersize, p->bits_per_sample / 8);
if (!e->data)
{
free(e);
return;
}
e->size = p->buffersize * p->bits_per_sample / 8;
Queue_Enqueue(p->queue, p->next);
@ -340,6 +349,7 @@ int android_RecIn(OPENSL_STREAM *p,short *buffer,int size)
if (!p->prep)
{
p->prep = calloc(1, sizeof(queue_element));
p->prep->data = calloc(p->buffersize, p->bits_per_sample / 8);
p->prep->size = p->buffersize * p->bits_per_sample / 8;

11
client/Sample/freerdp.c
View File

@ -324,13 +324,22 @@ int main(int argc, char* argv[])
rdpChannels* channels;
instance = freerdp_new();
if (!instance)
{
WLog_ERR(TAG, "Couldn't create instance");
exit(1);
}
instance->PreConnect = tf_pre_connect;
instance->PostConnect = tf_post_connect;
instance->ContextSize = sizeof(tfContext);
instance->ContextNew = tf_context_new;
instance->ContextFree = tf_context_free;
freerdp_context_new(instance);
if (freerdp_context_new(instance) != 0)
{
WLog_ERR(TAG, "Couldn't create context");
exit(1);
}
channels = instance->context->channels;

2
client/X11/cli/xfreerdp.c
View File

@ -49,6 +49,8 @@ int main(int argc, char* argv[])
RdpClientEntry(&clientEntryPoints);
context = freerdp_client_context_new(&clientEntryPoints);
if (!context)
return 1;
settings = context->settings;
xfc = (xfContext*) context;

16
client/common/client.c
View File

@ -51,13 +51,21 @@ rdpContext* freerdp_client_context_new(RDP_CLIENT_ENTRY_POINTS* pEntryPoints)
pEntryPoints->GlobalInit();
instance = freerdp_new();
if (!instance)
return NULL;
instance->settings = pEntryPoints->settings;
instance->ContextSize = pEntryPoints->ContextSize;
instance->ContextNew = freerdp_client_common_new;
instance->ContextFree = freerdp_client_common_free;
instance->pClientEntryPoints = (RDP_CLIENT_ENTRY_POINTS*) malloc(pEntryPoints->Size);
if (!instance->pClientEntryPoints)
goto out_fail;
CopyMemory(instance->pClientEntryPoints, pEntryPoints, pEntryPoints->Size);
freerdp_context_new(instance);
if (freerdp_context_new(instance) != 0)
goto out_fail2;
context = instance->context;
context->instance = instance;
@ -66,6 +74,12 @@ rdpContext* freerdp_client_context_new(RDP_CLIENT_ENTRY_POINTS* pEntryPoints)
freerdp_register_addin_provider(freerdp_channels_load_static_addin_entry, 0);
return context;
out_fail2:
free(instance->pClientEntryPoints);
out_fail:
freerdp_free(instance);
return NULL;
}
void freerdp_client_context_free(rdpContext* context)

4
libfreerdp/codec/rfx_encode.c
View File

@ -226,12 +226,14 @@ void rfx_encode_rgb(RFX_CONTEXT* context, RFX_TILE* tile)
primitives_t* prims = primitives_get();
static const prim_size_t roi_64x64 = { 64, 64 };
if (!(pBuffer = (BYTE*) BufferPool_Take(context->priv->BufferPool, -1)))
return;
YLen = CbLen = CrLen = 0;
YQuant = context->quants + (tile->quantIdxY * 10);
CbQuant = context->quants + (tile->quantIdxCb * 10);
CrQuant = context->quants + (tile->quantIdxCr * 10);
pBuffer = (BYTE*) BufferPool_Take(context->priv->BufferPool, -1);
pSrcDst[0] = (INT16*)((BYTE*)(&pBuffer[((8192 + 32) * 0) + 16])); /* y_r_buffer */
pSrcDst[1] = (INT16*)((BYTE*)(&pBuffer[((8192 + 32) * 1) + 16])); /* cb_g_buffer */
pSrcDst[2] = (INT16*)((BYTE*)(&pBuffer[((8192 + 32) * 2) + 16])); /* cr_b_buffer */

4
libfreerdp/codec/rfx_rlgr.c
View File

@ -580,8 +580,8 @@ int rfx_rlgr_encode(RLGR_MODE mode, const INT16* data, int data_size, BYTE* buff
RFX_BITSTREAM* bs;
int processed_size;
bs = (RFX_BITSTREAM*) malloc(sizeof(RFX_BITSTREAM));
ZeroMemory(bs, sizeof(RFX_BITSTREAM));
if (!(bs = (RFX_BITSTREAM*) calloc(1, sizeof(RFX_BITSTREAM))))
return 0;
rfx_bitstream_attach(bs, buffer, buffer_size);

4
libfreerdp/core/activation.c
View File

@ -330,7 +330,9 @@ BOOL rdp_send_deactivate_all(rdpRdp* rdp)
wStream* s;
BOOL status;
s = Stream_New(NULL, 1024);
if (!(s = Stream_New(NULL, 1024)))
return FALSE;
rdp_init_stream_pdu(rdp, s);
Stream_Write_UINT32(s, rdp->settings->ShareId); /* shareId (4 bytes) */

8
libfreerdp/core/capabilities.c
View File

@ -3687,7 +3687,9 @@ BOOL rdp_send_demand_active(rdpRdp* rdp)
wStream* s;
BOOL status;
s = Stream_New(NULL, 4096);
if (!(s = Stream_New(NULL, 4096)))
return FALSE;
rdp_init_stream_pdu(rdp, s);
rdp->settings->ShareId = 0x10000 + rdp->mcs->userId;
@ -3903,7 +3905,9 @@ BOOL rdp_send_confirm_active(rdpRdp* rdp)
wStream* s;
BOOL status;
s = Stream_New(NULL, 4096);
if (!(s = Stream_New(NULL, 4096)))
return FALSE;
rdp_init_stream_pdu(rdp, s);
rdp_write_confirm_active(s, rdp->settings);

7
libfreerdp/core/fastpath.c
View File

@ -389,7 +389,8 @@ static int fastpath_recv_update_data(rdpFastPath* fastpath, wStream* s)
/* data was compressed, copy from decompression buffer */
size = DstSize;
cs = StreamPool_Take(transport->ReceivePool, DstSize);
if (!(cs = StreamPool_Take(transport->ReceivePool, DstSize)))
return -1;
Stream_SetPosition(cs, 0);
Stream_Write(cs, pDstData, DstSize);
@ -432,7 +433,9 @@ static int fastpath_recv_update_data(rdpFastPath* fastpath, wStream* s)
return -1;
}
fastpath->updateData = StreamPool_Take(transport->ReceivePool, size);
if (!(fastpath->updateData = StreamPool_Take(transport->ReceivePool, size)))
return -1;
Stream_SetPosition(fastpath->updateData, 0);
Stream_Copy(fastpath->updateData, cs, size);

46
libfreerdp/core/freerdp.c
View File

@ -148,7 +148,9 @@ BOOL freerdp_connect(freerdp* instance)
pcap_get_next_record_header(update->pcap_rfx, &record);
s = StreamPool_Take(rdp->transport->ReceivePool, record.length);
if (!(s = StreamPool_Take(rdp->transport->ReceivePool, record.length)))
break;
record.data = Stream_Buffer(s);
pcap_get_next_record_content(update->pcap_rfx, &record);
@ -421,8 +423,9 @@ int freerdp_context_new(freerdp* instance)
rdpRdp* rdp;
rdpContext* context;
instance->context = (rdpContext*) malloc(instance->ContextSize);
ZeroMemory(instance->context, instance->ContextSize);
instance->context = (rdpContext*) calloc(1, instance->ContextSize);
if (!instance->context)
return -1;
context = instance->context;
context->instance = instance;
@ -431,16 +434,27 @@ int freerdp_context_new(freerdp* instance)
context->settings = instance->settings;
context->pubSub = PubSub_New(TRUE);
if(!context->pubSub)
goto out_error_pubsub;
PubSub_AddEventTypes(context->pubSub, FreeRDP_Events, sizeof(FreeRDP_Events) / sizeof(wEventType));
context->metrics = metrics_new(context);
if (!context->metrics)
goto out_error_metrics_new;
rdp = rdp_new(context);
if (!rdp)
goto out_error_rdp_new;
instance->input = rdp->input;
instance->update = rdp->update;
instance->settings = rdp->settings;
instance->autodetect = rdp->autodetect;
context->graphics = graphics_new(context);
if(!context->graphics)
goto out_error_graphics_new;
context->rdp = rdp;
context->input = instance->input;
@ -461,8 +475,17 @@ int freerdp_context_new(freerdp* instance)
update_register_client_callbacks(rdp->update);
IFCALL(instance->ContextNew, instance, instance->context);
return 0;
out_error_graphics_new:
rdp_free(rdp);
out_error_rdp_new:
metrics_free(context->metrics);
out_error_metrics_new:
PubSub_Free(context->pubSub);
out_error_pubsub:
free(instance->context);
return -1;
}
/** Deallocator function for a rdp context.
@ -581,15 +604,14 @@ freerdp* freerdp_new()
{
freerdp* instance;
instance = (freerdp*) malloc(sizeof(freerdp));
instance = (freerdp*) calloc(1, sizeof(freerdp));
if (instance)
{
ZeroMemory(instance, sizeof(freerdp));
instance->ContextSize = sizeof(rdpContext);
instance->SendChannelData = freerdp_send_channel_data;
instance->ReceiveChannelData = freerdp_channels_data;
}
if (!instance)
return NULL;
instance->ContextSize = sizeof(rdpContext);
instance->SendChannelData = freerdp_send_channel_data;
instance->ReceiveChannelData = freerdp_channels_data;
return instance;
}

5
libfreerdp/core/listener.c
View File

@ -311,6 +311,11 @@ static BOOL freerdp_listener_check_fds(freerdp_listener* instance)
}
client = freerdp_peer_new(peer_sockfd);
if (!client)
{
closesocket((SOCKET) peer_sockfd);
return FALSE;
}
sin_addr = NULL;
if (peer_addr.ss_family == AF_INET)

23
libfreerdp/core/peer.c
View File

@ -632,8 +632,23 @@ void freerdp_peer_context_new(freerdp_peer* client)
context->metrics = metrics_new(context);
if (!context->metrics)
{
client->context = NULL;
free(context);
return;
}
rdp = rdp_new(context);
if (!rdp)
{
metrics_free(context->metrics);
free(context);
client->context = NULL;
return;
}
client->input = rdp->input;
client->update = rdp->update;
client->settings = rdp->settings;
@ -663,6 +678,7 @@ void freerdp_peer_context_new(freerdp_peer* client)
client->DrainOutputBuffer = freerdp_peer_drain_output_buffer;
IFCALL(client->ContextNew, client, client->context);
}
void freerdp_peer_context_free(freerdp_peer* client)
@ -717,7 +733,10 @@ void freerdp_peer_free(freerdp_peer* client)
if (!client)
return;
rdp_free(client->context->rdp);
free(client->context);
if (client->context)
{
rdp_free(client->context->rdp);
free(client->context);
}
free(client);
}

3
libfreerdp/core/rdp.c
View File

@ -754,7 +754,8 @@ int rdp_recv_data_pdu(rdpRdp* rdp, wStream* s)
if (bulk_decompress(rdp->bulk, Stream_Pointer(s), SrcSize, &pDstData, &DstSize, compressedType))
{
cs = StreamPool_Take(rdp->transport->ReceivePool, DstSize);
if (!(cs = StreamPool_Take(rdp->transport->ReceivePool, DstSize)))
return -1;
Stream_SetPosition(cs, 0);
Stream_Write(cs, pDstData, DstSize);

233
libfreerdp/core/settings.c
View File

@ -195,6 +195,8 @@ void settings_get_computer_name(rdpSettings* settings)
GetComputerNameExA(ComputerNameNetBIOS, NULL, &nSize);
settings->ComputerName = (char*) malloc(nSize);
if (!settings->ComputerName)
return;
GetComputerNameExA(ComputerNameNetBIOS, settings->ComputerName, &nSize);
}
@ -202,11 +204,9 @@ rdpSettings* freerdp_settings_new(DWORD flags)
{
rdpSettings* settings;
settings = (rdpSettings*) malloc(sizeof(rdpSettings));
if (settings)
{
ZeroMemory(settings, sizeof(rdpSettings));
settings = (rdpSettings*) calloc(1, sizeof(rdpSettings));
if (!settings)
return NULL;
settings->ServerMode = (flags & FREERDP_SETTINGS_SERVER_MODE) ? TRUE : FALSE;
settings->WaitForOutputBufferFlush = TRUE;
@ -256,9 +256,9 @@ rdpSettings* freerdp_settings_new(DWORD flags)
settings->CompressionEnabled = TRUE;
if (settings->ServerMode)
settings->CompressionLevel = PACKET_COMPR_TYPE_RDP61;
settings->CompressionLevel = PACKET_COMPR_TYPE_RDP61;
else
settings->CompressionLevel = PACKET_COMPR_TYPE_RDP61;
settings->CompressionLevel = PACKET_COMPR_TYPE_RDP61;
settings->Authentication = TRUE;
settings->AuthenticationOnly = FALSE;
@ -269,21 +269,31 @@ rdpSettings* freerdp_settings_new(DWORD flags)
settings->ChannelCount = 0;
settings->ChannelDefArraySize = 32;
settings->ChannelDefArray = (CHANNEL_DEF*) calloc(settings->ChannelDefArraySize, sizeof(CHANNEL_DEF));
if (!settings->ChannelDefArray)
goto out_fail;
settings->MonitorCount = 0;
settings->MonitorDefArraySize = 32;
settings->MonitorDefArray = (rdpMonitor*) calloc(settings->MonitorDefArraySize, sizeof(rdpMonitor));
if (!settings->MonitorDefArray)
goto out_fail;
settings->MonitorLocalShiftX = 0;
settings->MonitorLocalShiftY = 0;
settings->MonitorIds = (UINT32*) calloc(16, sizeof(UINT32));
if(!settings->MonitorIds)
goto out_fail;
settings_get_computer_name(settings);
settings->ReceivedCapabilities = malloc(32);
settings->OrderSupport = malloc(32);
ZeroMemory(settings->ReceivedCapabilities, 32);
ZeroMemory(settings->OrderSupport, 32);
settings->ReceivedCapabilities = calloc(1, 32);
if (!settings->ReceivedCapabilities)
goto out_fail;
settings->OrderSupport = calloc(1, 32);
if (!settings->OrderSupport)
goto out_fail;
settings->OrderSupport[NEG_DSTBLT_INDEX] = TRUE;
settings->OrderSupport[NEG_PATBLT_INDEX] = TRUE;
@ -308,11 +318,13 @@ rdpSettings* freerdp_settings_new(DWORD flags)
settings->OrderSupport[NEG_ELLIPSE_SC_INDEX] = TRUE;
settings->OrderSupport[NEG_ELLIPSE_CB_INDEX] = TRUE;
settings->ClientHostname = malloc(32);
settings->ClientProductId = malloc(32);
ZeroMemory(settings->ClientHostname, 32);
ZeroMemory(settings->ClientProductId, 32);
settings->ClientProductId = calloc(1, 32);
if (!settings->ClientProductId)
goto out_fail;
settings->ClientHostname = calloc(1, 32);
if (!settings->ClientHostname)
goto out_fail;
gethostname(settings->ClientHostname, 31);
settings->ClientHostname[31] = 0;
@ -337,6 +349,8 @@ rdpSettings* freerdp_settings_new(DWORD flags)
settings->BitmapCacheV2NumCells = 5;
settings->BitmapCacheV2CellInfo = (BITMAP_CACHE_V2_CELL_INFO*) malloc(sizeof(BITMAP_CACHE_V2_CELL_INFO) * 6);
if (!settings->BitmapCacheV2CellInfo)
goto out_fail;
settings->BitmapCacheV2CellInfo[0].numEntries = 600;
settings->BitmapCacheV2CellInfo[0].persistent = FALSE;
settings->BitmapCacheV2CellInfo[1].numEntries = 600;
@ -355,7 +369,11 @@ rdpSettings* freerdp_settings_new(DWORD flags)
settings->GlyphSupportLevel = GLYPH_SUPPORT_FULL;
settings->GlyphCache = malloc(sizeof(GLYPH_CACHE_DEFINITION) * 10);
if(!settings->GlyphCache)
goto out_fail;
settings->FragCache = malloc(sizeof(GLYPH_CACHE_DEFINITION));
if(!settings->FragCache)
goto out_fail;
settings->GlyphCache[0].cacheEntries = 254;
settings->GlyphCache[0].cacheMaximumCellSize = 4;
settings->GlyphCache[1].cacheEntries = 254;
@ -387,6 +405,8 @@ rdpSettings* freerdp_settings_new(DWORD flags)
settings->DrawNineGridCacheEntries = 256;
settings->ClientDir = _strdup(client_dll);
if (!settings->ClientDir)
goto out_fail;
settings->RemoteAppNumIconCaches = 3;
settings->RemoteAppNumIconCacheEntries = 12;
@ -420,38 +440,72 @@ rdpSettings* freerdp_settings_new(DWORD flags)
settings->GfxProgressiveV2 = FALSE;
settings->GfxH264 = FALSE;
settings->ClientAutoReconnectCookie = (ARC_CS_PRIVATE_PACKET*) malloc(sizeof(ARC_CS_PRIVATE_PACKET));
settings->ServerAutoReconnectCookie = (ARC_SC_PRIVATE_PACKET*) malloc(sizeof(ARC_SC_PRIVATE_PACKET));
ZeroMemory(settings->ClientAutoReconnectCookie, sizeof(ARC_CS_PRIVATE_PACKET));
ZeroMemory(settings->ServerAutoReconnectCookie, sizeof(ARC_SC_PRIVATE_PACKET));
settings->ClientAutoReconnectCookie = (ARC_CS_PRIVATE_PACKET*) calloc(1, sizeof(ARC_CS_PRIVATE_PACKET));
if (!settings->ClientAutoReconnectCookie)
goto out_fail;
settings->ServerAutoReconnectCookie = (ARC_SC_PRIVATE_PACKET*) calloc(1, sizeof(ARC_SC_PRIVATE_PACKET));
if (!settings->ServerAutoReconnectCookie)
goto out_fail;
settings->ClientTimeZone = (TIME_ZONE_INFO*) malloc(sizeof(TIME_ZONE_INFO));
ZeroMemory(settings->ClientTimeZone, sizeof(TIME_ZONE_INFO));
settings->ClientTimeZone = (TIME_ZONE_INFO*) calloc(1,sizeof(TIME_ZONE_INFO));
if (!settings->ClientTimeZone)
goto out_fail;
settings->DeviceArraySize = 16;
settings->DeviceArray = (RDPDR_DEVICE**) malloc(sizeof(RDPDR_DEVICE*) * settings->DeviceArraySize);
ZeroMemory(settings->DeviceArray, sizeof(RDPDR_DEVICE*) * settings->DeviceArraySize);
settings->DeviceArray = (RDPDR_DEVICE**) calloc(1, sizeof(RDPDR_DEVICE*) * settings->DeviceArraySize);
if (!settings->DeviceArray)
goto out_fail;
settings->StaticChannelArraySize = 16;
settings->StaticChannelArray = (ADDIN_ARGV**)
malloc(sizeof(ADDIN_ARGV*) * settings->StaticChannelArraySize);
ZeroMemory(settings->StaticChannelArray, sizeof(ADDIN_ARGV*) * settings->StaticChannelArraySize);
calloc(1, sizeof(ADDIN_ARGV*) * settings->StaticChannelArraySize);
if (!settings->StaticChannelArray)
goto out_fail;
settings->DynamicChannelArraySize = 16;
settings->DynamicChannelArray = (ADDIN_ARGV**)
malloc(sizeof(ADDIN_ARGV*) * settings->DynamicChannelArraySize);
ZeroMemory(settings->DynamicChannelArray, sizeof(ADDIN_ARGV*) * settings->DynamicChannelArraySize);
calloc(1, sizeof(ADDIN_ARGV*) * settings->DynamicChannelArraySize);
if(!settings->DynamicChannelArray)
goto out_fail;
settings->HomePath = GetKnownPath(KNOWN_PATH_HOME);
if (!settings->HomePath)
goto out_fail;
settings->ConfigPath = GetKnownSubPath(KNOWN_PATH_XDG_CONFIG_HOME, "freerdp");
if (!settings->ConfigPath)
goto out_fail;
settings_load_hkey_local_machine(settings);
settings->SettingsModified = (BYTE*) malloc(sizeof(rdpSettings) / 8 );
ZeroMemory(settings->SettingsModified, sizeof(rdpSettings) / 8);
}
settings->SettingsModified = (BYTE*) calloc(1, sizeof(rdpSettings) / 8 );
if(!settings->SettingsModified)
goto out_fail;
return settings;
out_fail:
free(settings->HomePath);
free(settings->ConfigPath);
free(settings->DynamicChannelArray);
free(settings->StaticChannelArray);
free(settings->DeviceArray);
free(settings->ClientTimeZone);
free(settings->ServerAutoReconnectCookie);
free(settings->ClientAutoReconnectCookie);
free(settings->ClientDir);
free(settings->FragCache);
free(settings->GlyphCache);
free(settings->BitmapCacheV2CellInfo);
free(settings->ClientProductId);
free(settings->ClientHostname);
free(settings->OrderSupport);
free(settings->ReceivedCapabilities);
free(settings->ComputerName);
free(settings->MonitorIds);
free(settings->MonitorDefArray);
free(settings->ChannelDefArray);
free(settings);
return NULL;
}
rdpSettings* freerdp_settings_clone(rdpSettings* settings)
@ -649,66 +703,65 @@ rdpSettings* freerdp_settings_clone(rdpSettings* settings)
void freerdp_settings_free(rdpSettings* settings)
{
if (settings)
{
free(settings->ServerHostname);
free(settings->Username);
free(settings->Password);
free(settings->Domain);
free(settings->PasswordHash);
free(settings->AlternateShell);
free(settings->ShellWorkingDirectory);
free(settings->ComputerName);
free(settings->ChannelDefArray);
free(settings->MonitorDefArray);
free(settings->MonitorIds);
free(settings->ClientAddress);
free(settings->ClientDir);
free(settings->AllowedTlsCiphers);
free(settings->CertificateFile);
free(settings->PrivateKeyFile);
free(settings->ConnectionFile);
free(settings->AssistanceFile);
free(settings->ReceivedCapabilities);
free(settings->OrderSupport);
free(settings->ClientHostname);
free(settings->ClientProductId);
free(settings->ServerRandom);
free(settings->ClientRandom);
free(settings->ServerCertificate);
free(settings->RdpKeyFile);
certificate_free(settings->RdpServerCertificate);
free(settings->ClientAutoReconnectCookie);
free(settings->ServerAutoReconnectCookie);
free(settings->ClientTimeZone);
free(settings->BitmapCacheV2CellInfo);
free(settings->GlyphCache);
free(settings->FragCache);
key_free(settings->RdpServerRsaKey);
free(settings->ConfigPath);
free(settings->CurrentPath);
free(settings->HomePath);
free(settings->LoadBalanceInfo);
free(settings->TargetNetAddress);
free(settings->RedirectionTargetFQDN);
free(settings->RedirectionTargetNetBiosName);
free(settings->RedirectionUsername);
free(settings->RedirectionDomain);
free(settings->RedirectionPassword);
free(settings->RedirectionTsvUrl);
free(settings->RemoteAssistanceSessionId);
free(settings->AuthenticationServiceClass);
free(settings->GatewayHostname);
free(settings->GatewayUsername);
free(settings->GatewayPassword);
free(settings->GatewayDomain);
freerdp_target_net_addresses_free(settings);
freerdp_device_collection_free(settings);
freerdp_static_channel_collection_free(settings);
freerdp_dynamic_channel_collection_free(settings);
free(settings->SettingsModified);
free(settings);
}
if (!settings)
return;
free(settings->ServerHostname);
free(settings->Username);
free(settings->Password);
free(settings->Domain);
free(settings->PasswordHash);
free(settings->AlternateShell);
free(settings->ShellWorkingDirectory);
free(settings->ComputerName);
free(settings->ChannelDefArray);
free(settings->MonitorDefArray);
free(settings->MonitorIds);
free(settings->ClientAddress);
free(settings->ClientDir);
free(settings->AllowedTlsCiphers);
free(settings->CertificateFile);
free(settings->PrivateKeyFile);
free(settings->ConnectionFile);
free(settings->AssistanceFile);
free(settings->ReceivedCapabilities);
free(settings->OrderSupport);
free(settings->ClientHostname);
free(settings->ClientProductId);
free(settings->ServerRandom);
free(settings->ClientRandom);
free(settings->ServerCertificate);
free(settings->RdpKeyFile);
certificate_free(settings->RdpServerCertificate);
free(settings->ClientAutoReconnectCookie);
free(settings->ServerAutoReconnectCookie);
free(settings->ClientTimeZone);
free(settings->BitmapCacheV2CellInfo);
free(settings->GlyphCache);
free(settings->FragCache);
key_free(settings->RdpServerRsaKey);
free(settings->ConfigPath);
free(settings->CurrentPath);
free(settings->HomePath);
free(settings->LoadBalanceInfo);
free(settings->TargetNetAddress);
free(settings->RedirectionTargetFQDN);
free(settings->RedirectionTargetNetBiosName);
free(settings->RedirectionUsername);
free(settings->RedirectionDomain);
free(settings->RedirectionPassword);
free(settings->RedirectionTsvUrl);
free(settings->RemoteAssistanceSessionId);
free(settings->AuthenticationServiceClass);
free(settings->GatewayHostname);
free(settings->GatewayUsername);
free(settings->GatewayPassword);
free(settings->GatewayDomain);
freerdp_target_net_addresses_free(settings);
freerdp_device_collection_free(settings);
freerdp_static_channel_collection_free(settings);
freerdp_dynamic_channel_collection_free(settings);
free(settings->SettingsModified);
free(settings);
}
#ifdef _WIN32

8
libfreerdp/core/transport.c
View File

@ -61,7 +61,8 @@ static void* transport_client_thread(void* arg);
wStream* transport_send_stream_init(rdpTransport* transport, int size)
{
wStream* s;
s = StreamPool_Take(transport->ReceivePool, size);
if (!(s = StreamPool_Take(transport->ReceivePool, size)))
return NULL;
Stream_EnsureCapacity(s, size);
Stream_SetPosition(s, 0);
return s;
@ -734,7 +735,10 @@ int transport_check_fds(rdpTransport* transport)
}
received = transport->ReceiveBuffer;
transport->ReceiveBuffer = StreamPool_Take(transport->ReceivePool, 0);
if (!(transport->ReceiveBuffer = StreamPool_Take(transport->ReceivePool, 0)))
{
return -1;
}
/**
* status:
* -1: error

12
winpr/include/winpr/wlog.h
View File

@ -233,7 +233,7 @@ WINPR_API int WLog_PrintMessageVA(wLog* log, wLogMessage* message, va_list args)
#define WLog_Print(_log, _log_level, _fmt, ...) \
do { \
if (_log_level >= WLog_GetLogLevel(_log)) { \
if (_log && _log_level >= WLog_GetLogLevel(_log)) { \
wLogMessage _log_message; \
_log_message.Type = WLOG_MESSAGE_TEXT; \
_log_message.Level = _log_level; \
@ -247,7 +247,7 @@ WINPR_API int WLog_PrintMessageVA(wLog* log, wLogMessage* message, va_list args)
#define WLog_PrintVA(_log, _log_level, _fmt, _args) \
do { \
if (_log_level >= WLog_GetLogLevel(_log)) { \
if (_log && _log_level >= WLog_GetLogLevel(_log)) { \
wLogMessage _log_message; \
_log_message.Type = WLOG_MESSAGE_TEXT; \
_log_message.Level = _log_level; \
@ -261,7 +261,7 @@ WINPR_API int WLog_PrintMessageVA(wLog* log, wLogMessage* message, va_list args)
#define WLog_Data(_log, _log_level, ...) \
do { \
if (_log_level >= WLog_GetLogLevel(_log)) { \
if (_log && _log_level >= WLog_GetLogLevel(_log)) { \
wLogMessage _log_message; \
_log_message.Type = WLOG_MESSAGE_DATA; \
_log_message.Level = _log_level; \
@ -275,7 +275,7 @@ WINPR_API int WLog_PrintMessageVA(wLog* log, wLogMessage* message, va_list args)
#define WLog_Image(_log, _log_level, ...) \
do { \
if (_log_level >= WLog_GetLogLevel(_log)) { \
if (_log && _log_level >= WLog_GetLogLevel(_log)) { \
wLogMessage _log_message; \
_log_message.Type = WLOG_MESSAGE_IMAGE; \
_log_message.Level = _log_level; \
@ -289,7 +289,7 @@ WINPR_API int WLog_PrintMessageVA(wLog* log, wLogMessage* message, va_list args)
#define WLog_Packet(_log, _log_level, ...) \
do { \
if (_log_level >= WLog_GetLogLevel(_log)) { \
if (_log && _log_level >= WLog_GetLogLevel(_log)) { \
wLogMessage _log_message; \
_log_message.Type = WLOG_MESSAGE_PACKET; \
_log_message.Level = _log_level; \
@ -302,7 +302,7 @@ WINPR_API int WLog_PrintMessageVA(wLog* log, wLogMessage* message, va_list args)
} while (0)
#define WLog_IsLevelActive(_log, _log_level) \
(_log_level >= WLog_GetLogLevel(_log))
(_log ? _log_level >= WLog_GetLogLevel(_log) : FALSE)
#define WLog_LVL(tag, lvl, fmt, ...) WLog_Print(WLog_Get(tag), lvl, fmt, ## __VA_ARGS__)
#define WLog_VRB(tag, fmt, ...) WLog_Print(WLog_Get(tag), WLOG_TRACE, fmt, ## __VA_ARGS__)

13
winpr/libwinpr/error/error.c
View File

@ -41,12 +41,21 @@ UINT SetErrorMode(UINT uMode)
DWORD GetLastError(VOID)
{
return NtCurrentTeb()->LastErrorValue;
PTEB pt = NtCurrentTeb();
if (pt)
{
return NtCurrentTeb()->LastErrorValue;
}
return ERROR_OUTOFMEMORY;
}
VOID SetLastError(DWORD dwErrCode)
{
NtCurrentTeb()->LastErrorValue = dwErrCode;
PTEB pt = NtCurrentTeb();
if (pt)
{
pt->LastErrorValue = dwErrCode;
}
}
VOID RestoreLastError(DWORD dwErrCode)

32
winpr/libwinpr/file/file.c
View File

@ -271,8 +271,14 @@ static void _HandleCreatorsInit()
/* NB: error management to be done outside of this function */
assert(_HandleCreators == NULL);
_HandleCreators = (HANDLE_CREATOR**)calloc(HANDLE_CREATOR_MAX+1, sizeof(HANDLE_CREATOR*));
InitializeCriticalSection(&_HandleCreatorsLock);
assert(_HandleCreators != NULL);
if (!_HandleCreators)
return;
if(!InitializeCriticalSectionEx(&_HandleCreatorsLock, 0, 0))
{
free(_HandleCreators);
_HandleCreators = NULL;
}
}
/**
@ -407,9 +413,16 @@ HANDLE CreateFileA(LPCSTR lpFileName, DWORD dwDesiredAccess, DWORD dwShareMode,
free(name);
pNamedPipe = (WINPR_NAMED_PIPE*) calloc(1, sizeof(WINPR_NAMED_PIPE));
if (!pNamedPipe)
return INVALID_HANDLE_VALUE;
hNamedPipe = (HANDLE) pNamedPipe;
WINPR_HANDLE_SET_TYPE(pNamedPipe, HANDLE_TYPE_NAMED_PIPE);
pNamedPipe->name = _strdup(lpFileName);
if (!pNamedPipe->name)
{
free(pNamedPipe);
return INVALID_HANDLE_VALUE;
}
pNamedPipe->dwOpenMode = 0;
pNamedPipe->dwPipeMode = 0;
pNamedPipe->nMaxInstances = 0;
@ -418,7 +431,22 @@ HANDLE CreateFileA(LPCSTR lpFileName, DWORD dwDesiredAccess, DWORD dwShareMode,
pNamedPipe->nDefaultTimeOut = 0;
pNamedPipe->dwFlagsAndAttributes = dwFlagsAndAttributes;
pNamedPipe->lpFileName = GetNamedPipeNameWithoutPrefixA(lpFileName);
if (!pNamedPipe->lpFileName)
{
free((void *)pNamedPipe->name);
free(pNamedPipe);
return INVALID_HANDLE_VALUE;
}
pNamedPipe->lpFilePath = GetNamedPipeUnixDomainSocketFilePathA(lpFileName);
if (!pNamedPipe->lpFilePath)
{
free((void *)pNamedPipe->lpFileName);
free((void *)pNamedPipe->name);
free(pNamedPipe);
return INVALID_HANDLE_VALUE;
}
pNamedPipe->clientfd = socket(PF_LOCAL, SOCK_STREAM, 0);
pNamedPipe->serverfd = -1;
pNamedPipe->ServerMode = FALSE;

11
winpr/libwinpr/path/shell.c
View File

@ -53,6 +53,8 @@ char* GetEnvAlloc(LPCSTR lpName)
if (length > 0)
{
env = malloc(length + 1);
if (!env)
return NULL;
GetEnvironmentVariableA(lpName, env, length + 1);
env[length] = '\0';
}
@ -68,6 +70,8 @@ char* GetPath_HOME()
path = GetEnvAlloc("UserProfile");
#elif defined(ANDROID)
path = malloc(2);
if (!path)
return NULL;
strcpy(path, "/");
#else
path = GetEnvAlloc("HOME");
@ -144,6 +148,11 @@ char* GetPath_XDG_CONFIG_HOME()
home = GetPath_TEMP();
path = (char*) malloc(strlen(home) + strlen("/.config") + 1);
if (!path)
{
free(home);
return NULL;
}
sprintf(path, "%s%s", home, "/.config");
free(home);
@ -264,6 +273,8 @@ char* GetKnownSubPath(int id, const char* path)
char* knownPath;
knownPath = GetKnownPath(id);
if (!knownPath)
return NULL;
subPath = GetCombinedPath(knownPath, path);
free(knownPath);

2
winpr/libwinpr/pipe/pipe.c
View File

@ -760,6 +760,8 @@ BOOL WaitNamedPipeA(LPCSTR lpNamedPipeName, DWORD nTimeOut)
return FALSE;
lpFilePath = GetNamedPipeUnixDomainSocketFilePathA(lpNamedPipeName);
if (!lpFilePath)
return FALSE;
if (nTimeOut == NMPWAIT_USE_DEFAULT_WAIT)
nTimeOut = 50;

66
winpr/libwinpr/registry/registry_reg.c
View File

@ -88,6 +88,8 @@ static void reg_load_start(Reg* reg)
return;
reg->buffer = (char*) malloc(file_size + 2);
if (!reg->buffer)
return ;
if (fread(reg->buffer, file_size, 1, reg->fp) != 1)
{
@ -135,6 +137,8 @@ static RegVal* reg_load_value(Reg* reg, RegKey* key)
data = p[3] + 1;
length = p[1] - p[0];
name = (char*) malloc(length + 1);
if (!name)
return 0;
memcpy(name, p[0], length);
name[length] = '\0';
value = (RegVal*) malloc(sizeof(RegVal));
@ -243,6 +247,8 @@ static RegKey* reg_load_key(Reg* reg, RegKey* key)
p[0] = reg->line + 1;
p[1] = strrchr(p[0], ']');
subkey = (RegKey*) malloc(sizeof(RegKey));
if (!subkey)
return NULL;
subkey->values = NULL;
subkey->prev = subkey->next = NULL;
length = p[1] - p[0];
@ -359,35 +365,41 @@ Reg* reg_open(BOOL read_only)
Reg* reg;
reg = (Reg*) malloc(sizeof(Reg));
if (reg)
if (!reg)
return NULL;
reg->read_only = read_only;
reg->filename = WINPR_HKLM_HIVE;
if (reg->read_only)
{
reg->fp = fopen(reg->filename, "r");
}
else
{
reg->fp = fopen(reg->filename, "r+");
if (!reg->fp)
reg->fp = fopen(reg->filename, "w+");
}
if (!reg->fp)
{
free(reg);
return NULL;
}
reg->root_key = (RegKey*) malloc(sizeof(RegKey));
if (!reg->root_key)
{
reg->read_only = read_only;
reg->filename = WINPR_HKLM_HIVE;
if (reg->read_only)
{
reg->fp = fopen(reg->filename, "r");
}
else
{
reg->fp = fopen(reg->filename, "r+");
if (!reg->fp)
reg->fp = fopen(reg->filename, "w+");
}
if (!reg->fp)
{
free(reg);
return NULL;
}
reg->root_key = (RegKey*) malloc(sizeof(RegKey));
reg->root_key->values = NULL;
reg->root_key->subkeys = NULL;
reg->root_key->name = "HKEY_LOCAL_MACHINE";
reg_load(reg);
fclose(reg->fp);
free(reg);
return NULL;
}
reg->root_key->values = NULL;
reg->root_key->subkeys = NULL;
reg->root_key->name = "HKEY_LOCAL_MACHINE";
reg_load(reg);
return reg;
}

12
winpr/libwinpr/synch/critical.c
View File

@ -67,13 +67,21 @@ BOOL InitializeCriticalSectionEx(LPCRITICAL_SECTION lpCriticalSection, DWORD dwS
lpCriticalSection->RecursionCount = 0;
lpCriticalSection->OwningThread = NULL;
lpCriticalSection->LockSemaphore = (winpr_sem_t*) malloc(sizeof(winpr_sem_t));
if (!lpCriticalSection->LockSemaphore)
return FALSE;
#if defined(__APPLE__)
semaphore_create(mach_task_self(), lpCriticalSection->LockSemaphore, SYNC_POLICY_FIFO, 0);
if (semaphore_create(mach_task_self(), lpCriticalSection->LockSemaphore, SYNC_POLICY_FIFO, 0) != KERN_SUCCESS)
goto out_fail;
#else
sem_init(lpCriticalSection->LockSemaphore, 0, 0);
if(sem_init(lpCriticalSection->LockSemaphore, 0, 0) != 0)
goto out_fail;
#endif
SetCriticalSectionSpinCount(lpCriticalSection, dwSpinCount);
return TRUE;
out_fail:
free(lpCriticalSection->LockSemaphore);
return FALSE;
}
BOOL InitializeCriticalSectionAndSpinCount(LPCRITICAL_SECTION lpCriticalSection, DWORD dwSpinCount)

16
winpr/libwinpr/thread/thread.c
View File

@ -377,13 +377,27 @@ HANDLE CreateThread(LPSECURITY_ATTRIBUTES lpThreadAttributes, SIZE_T dwStackSize
}
#endif
pthread_mutex_init(&thread->mutex, 0);
if(pthread_mutex_init(&thread->mutex, 0) != 0)
{
WLog_ERR(TAG, "failed to initialize thread mutex");
close(thread->pipe_fd[0]);
free(thread);
return NULL;
}
WINPR_HANDLE_SET_TYPE(thread, HANDLE_TYPE_THREAD);
handle = (HANDLE) thread;
if (!thread_list)
{
thread_list = ListDictionary_New(TRUE);
if (!thread_list)
{
WLog_ERR(TAG, "Couldn't create global thread list");
close(thread->pipe_fd[0]);
free(thread);
return NULL;
}
thread_list->objectKey.fnObjectEquals = thread_compare;
}

30
winpr/libwinpr/utils/collections/PubSub.c
View File

@ -204,18 +204,28 @@ wPubSub* PubSub_New(BOOL synchronized)
pubSub = (wPubSub*) malloc(sizeof(wPubSub));
if (pubSub)
if (!pubSub)
return NULL;
pubSub->synchronized = synchronized;
if (pubSub->synchronized)
if (!InitializeCriticalSectionAndSpinCount(&pubSub->lock, 4000))
{
free(pubSub);
return NULL;
}
pubSub->count = 0;
pubSub->size = 64;
pubSub->events = (wEventType*) calloc(1, sizeof(wEventType) * pubSub->size);
if (!pubSub->events)
{
pubSub->synchronized = synchronized;
if (pubSub->synchronized)
InitializeCriticalSectionAndSpinCount(&pubSub->lock, 4000);
pubSub->count = 0;
pubSub->size = 64;
pubSub->events = (wEventType*) malloc(sizeof(wEventType) * pubSub->size);
ZeroMemory(pubSub->events, sizeof(wEventType) * pubSub->size);
DeleteCriticalSection(&pubSub->lock);
free(pubSub);
return NULL;
}
return pubSub;

10
winpr/libwinpr/utils/collections/StreamPool.c
View File

@ -178,10 +178,12 @@ wStream* StreamPool_Take(wStreamPool* pool, size_t size)
Stream_EnsureCapacity(s, size);
}
s->pool = pool;
s->count = 1;
StreamPool_AddUsed(pool, s);
if (s)
{
s->pool = pool;
s->count = 1;
StreamPool_AddUsed(pool, s);
}
if (pool->synchronized)
LeaveCriticalSection(&pool->lock);

3
winpr/libwinpr/utils/ssl.c
View File

@ -119,7 +119,8 @@ static BOOL _winpr_openssl_initialize_locking(void)
while (i--)
{
CloseHandle(g_winpr_openssl_locks[i]);
if (locks[i])
CloseHandle(locks[i]);
}
free(locks);

11
winpr/libwinpr/utils/wlog/Appender.c
View File

@ -30,6 +30,8 @@
wLogAppender* WLog_Appender_New(wLog* log, DWORD logAppenderType)
{
wLogAppender* appender = NULL;
if (!log)
return NULL;
if (logAppenderType == WLOG_APPENDER_CONSOLE)
{
@ -51,7 +53,14 @@ wLogAppender* WLog_Appender_New(wLog* log, DWORD logAppenderType)
if (!appender)
appender = (wLogAppender*) WLog_ConsoleAppender_New(log);
appender->Layout = WLog_Layout_New(log);
if (!appender)
return NULL;
if (!(appender->Layout = WLog_Layout_New(log)))
{
WLog_Appender_Free(log, appender);
return NULL;
}
InitializeCriticalSectionAndSpinCount(&appender->lock, 4000);

36
winpr/libwinpr/utils/wlog/ConsoleAppender.c
View File

@ -192,33 +192,31 @@ wLogConsoleAppender* WLog_ConsoleAppender_New(wLog* log)
{
wLogConsoleAppender* ConsoleAppender;
ConsoleAppender = (wLogConsoleAppender*) malloc(sizeof(wLogConsoleAppender));
ConsoleAppender = (wLogConsoleAppender*) calloc(1, sizeof(wLogConsoleAppender));
if (ConsoleAppender)
{
ZeroMemory(ConsoleAppender, sizeof(wLogConsoleAppender));
if (!ConsoleAppender)
return NULL;
ConsoleAppender->Type = WLOG_APPENDER_CONSOLE;
ConsoleAppender->Type = WLOG_APPENDER_CONSOLE;
ConsoleAppender->Open = (WLOG_APPENDER_OPEN_FN) WLog_ConsoleAppender_Open;
ConsoleAppender->Close = (WLOG_APPENDER_OPEN_FN) WLog_ConsoleAppender_Close;
ConsoleAppender->Open = (WLOG_APPENDER_OPEN_FN) WLog_ConsoleAppender_Open;
ConsoleAppender->Close = (WLOG_APPENDER_OPEN_FN) WLog_ConsoleAppender_Close;
ConsoleAppender->WriteMessage =
(WLOG_APPENDER_WRITE_MESSAGE_FN) WLog_ConsoleAppender_WriteMessage;
ConsoleAppender->WriteDataMessage =
(WLOG_APPENDER_WRITE_DATA_MESSAGE_FN) WLog_ConsoleAppender_WriteDataMessage;
ConsoleAppender->WriteImageMessage =
(WLOG_APPENDER_WRITE_IMAGE_MESSAGE_FN) WLog_ConsoleAppender_WriteImageMessage;
ConsoleAppender->WritePacketMessage =
(WLOG_APPENDER_WRITE_PACKET_MESSAGE_FN) WLog_ConsoleAppender_WritePacketMessage;
ConsoleAppender->WriteMessage =
(WLOG_APPENDER_WRITE_MESSAGE_FN) WLog_ConsoleAppender_WriteMessage;
ConsoleAppender->WriteDataMessage =
(WLOG_APPENDER_WRITE_DATA_MESSAGE_FN) WLog_ConsoleAppender_WriteDataMessage;
ConsoleAppender->WriteImageMessage =
(WLOG_APPENDER_WRITE_IMAGE_MESSAGE_FN) WLog_ConsoleAppender_WriteImageMessage;
ConsoleAppender->WritePacketMessage =
(WLOG_APPENDER_WRITE_PACKET_MESSAGE_FN) WLog_ConsoleAppender_WritePacketMessage;
ConsoleAppender->outputStream = WLOG_CONSOLE_STDOUT;
ConsoleAppender->outputStream = WLOG_CONSOLE_STDOUT;
#ifdef _WIN32
if (IsDebuggerPresent())
ConsoleAppender->outputStream = WLOG_CONSOLE_DEBUG;
if (IsDebuggerPresent())
ConsoleAppender->outputStream = WLOG_CONSOLE_DEBUG;
#endif
}
return ConsoleAppender;
}

107
winpr/libwinpr/utils/wlog/wlog.c
View File

@ -493,8 +493,14 @@ int WLog_ParseName(wLog* log, LPCSTR name)
}
names = _strdup(name);
if (!names)
return -1;
log->NameCount = count;
log->Names = (LPSTR*) malloc(sizeof(LPSTR) * (count + 1));
if(!(log->Names = (LPSTR*) malloc(sizeof(LPSTR) * (count + 1))))
{
free(names);
return -1;
}
log->Names[count] = NULL;
count = 0;
p = (char*) names;
@ -512,49 +518,46 @@ int WLog_ParseName(wLog* log, LPCSTR name)
wLog* WLog_New(LPCSTR name, wLog* rootLogger)
{
wLog* log;
char* env;
wLog* log = NULL;
char* env = NULL;
DWORD nSize;
int iLevel;
log = (wLog*) calloc(1, sizeof(wLog));
if (log)
{
log->Name = _strdup(name);
if (!log)
return 0;
if (!log->Name)
{
free (log);
return NULL;
}
log->Name = _strdup(name);
WLog_ParseName(log, name);
log->Parent = rootLogger;
log->ChildrenCount = 0;
log->ChildrenSize = 16;
log->Children = (wLog**) calloc(log->ChildrenSize, sizeof(wLog*));
if (!log->Name)
goto out_fail;
if (!log->Children)
{
free (log->Name);
free (log);
return NULL;
}
if (WLog_ParseName(log, name) != 0)
goto out_fail;
log->Appender = NULL;
log->Parent = rootLogger;
log->ChildrenCount = 0;
log->ChildrenSize = 16;
if (rootLogger)
{
log->Level = WLOG_LEVEL_INHERIT;
}
else
{
log->Level = WLOG_INFO;
nSize = GetEnvironmentVariableA("WLOG_LEVEL", NULL, 0);
if (!(log->Children = (wLog**) calloc(log->ChildrenSize, sizeof(wLog*))))
goto out_fail;
if (nSize)
log->Appender = NULL;
if (rootLogger)
{
log->Level = WLOG_LEVEL_INHERIT;
}
else
{
log->Level = WLOG_INFO;
nSize = GetEnvironmentVariableA("WLOG_LEVEL", NULL, 0);
if (nSize)
{
env = (LPSTR) malloc(nSize);
if (env)
{
env = (LPSTR) malloc(nSize);
nSize = GetEnvironmentVariableA("WLOG_LEVEL", env, nSize);
iLevel = WLog_ParseLogLevel(env);
@ -563,15 +566,21 @@ wLog* WLog_New(LPCSTR name, wLog* rootLogger)
free(env);
}
}
}
}
iLevel = WLog_GetFilterLogLevel(log);
iLevel = WLog_GetFilterLogLevel(log);
if (iLevel >= 0)
log->Level = (DWORD) iLevel;
}
if (iLevel >= 0)
log->Level = (DWORD) iLevel;
return log;
out_fail:
free (log->Children);
free (log->Name);
free (log);
return NULL;
}
void WLog_Free(wLog* log)
@ -602,7 +611,9 @@ wLog* WLog_GetRoot()
if (!g_RootLog)
{
g_RootLog = WLog_New("", NULL);
if (!(g_RootLog = WLog_New("", NULL)))
return NULL;
g_RootLog->IsRoot = TRUE;
WLog_ParseFilters();
logAppenderType = WLOG_APPENDER_CONSOLE;
@ -693,13 +704,18 @@ wLog* WLog_Get(LPCSTR name)
{
wLog* log;
wLog* root;
root = WLog_GetRoot();
log = WLog_FindChild(name);
if (!(root = WLog_GetRoot()))
return NULL;
if (!log)
if (!(log = WLog_FindChild(name)))
{
log = WLog_New(name,root);
WLog_AddChild(root, log);
if (!(log = WLog_New(name, root)))
return NULL;
if (WLog_AddChild(root, log))
{
WLog_Free(log);
return NULL;
}
}
return log;
@ -716,6 +732,9 @@ void WLog_Uninit()
wLog* child = NULL;
wLog* root = WLog_GetRoot();
if (!root)
return;
for (index = 0; index < root->ChildrenCount; index++)
{
child = root->Children[index];