mirrors/FreeRDP
0
0
Fork 0
mirror of https://github.com/FreeRDP/FreeRDP.git synced 2024-11-23 18:03:30 +08:00
Code Issues Packages Projects Releases Wiki Activity

libfreerdp-utils: get rid of xmalloc, xrealloc and xfree

Browse Source
This commit is contained in:
Marc-André Moreau 2012-10-08 23:21:26 -04:00
parent e60a092d81
commit 9909a12af5
135 changed files with 802 additions and 852 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
channels/audin/client/alsa/audin_alsa.c
View File

@ -217,8 +217,8 @@ static void* audin_alsa_thread_func(void* arg)
}
} while (0);
xfree(buffer);
xfree(alsa->buffer);
free(buffer);
free(alsa->buffer);
alsa->buffer = NULL;
if (capture_handle)
snd_pcm_close(capture_handle);
@ -236,7 +236,7 @@ static void audin_alsa_free(IAudinDevice* device)
freerdp_thread_free(alsa->thread);
freerdp_dsp_context_free(alsa->dsp_context);
xfree(alsa);
free(alsa);
}
static boolean audin_alsa_format_supported(IAudinDevice* device, audinFormat* format)

10
channels/audin/client/audin_main.c
View File

@ -358,8 +358,8 @@ static int audin_on_close(IWTSVirtualChannelCallback* pChannelCallback)
if (audin->device)
IFCALL(audin->device->Close, audin->device);
xfree(callback->formats);
xfree(callback);
free(callback->formats);
free(callback);
return 0;
}
@ -415,8 +415,8 @@ static int audin_plugin_terminated(IWTSPlugin* pPlugin)
audin->device = NULL;
}
xfree(audin->listener_callback);
xfree(audin);
free(audin->listener_callback);
free(audin);
return 0;
}
@ -452,7 +452,7 @@ static boolean audin_load_device_plugin(IWTSPlugin* pPlugin, const char* name, R
strcpy(fullname, "audin_");
strcat(fullname, name);
entry = (PFREERDP_AUDIN_DEVICE_ENTRY) freerdp_load_plugin(fullname, AUDIN_DEVICE_EXPORT_FUNC_NAME);
xfree(fullname);
free(fullname);
}
if (entry == NULL)

4
channels/audin/client/pulse/audin_pulse.c
View File

@ -152,7 +152,7 @@ static void audin_pulse_free(IAudinDevice* device)
pulse->mainloop = NULL;
}
freerdp_dsp_context_free(pulse->dsp_context);
xfree(pulse);
free(pulse);
}
static boolean audin_pulse_format_supported(IAudinDevice* device, audinFormat* format)
@ -350,7 +350,7 @@ static void audin_pulse_close(IAudinDevice* device)
pulse->user_data = NULL;
if (pulse->buffer)
{
xfree(pulse->buffer);
free(pulse->buffer);
pulse->buffer = NULL;
pulse->buffer_frames = 0;
}

6
channels/audin/server/audin.c
View File

@ -139,7 +139,7 @@ static boolean audin_server_recv_formats(audin_server* audin, STREAM* s, uint32
{
if (length < 18)
{
xfree(audin->context.client_formats);
free(audin->context.client_formats);
audin->context.client_formats = NULL;
return false;
}
@ -431,6 +431,6 @@ void audin_server_context_free(audin_server_context* context)
if (audin->dsp_context)
freerdp_dsp_context_free(audin->dsp_context);
if (audin->context.client_formats)
xfree(audin->context.client_formats);
xfree(audin);
free(audin->context.client_formats);
free(audin);
}

16
channels/cliprdr/client/cliprdr_format.c
View File

@ -127,7 +127,7 @@ void cliprdr_process_short_format_names(cliprdrPlugin* cliprdr, STREAM* s, uint3
ascii = (flags & CB_ASCII_NAMES) ? true : false;
cliprdr->format_names = (CLIPRDR_FORMAT_NAME*) xmalloc(sizeof(CLIPRDR_FORMAT_NAME) * num_formats);
cliprdr->format_names = (CLIPRDR_FORMAT_NAME*) malloc(sizeof(CLIPRDR_FORMAT_NAME) * num_formats);
cliprdr->num_format_names = num_formats;
for (i = 0; i < num_formats; i++)
@ -159,7 +159,7 @@ void cliprdr_process_long_format_names(cliprdrPlugin* cliprdr, STREAM* s, uint32
stream_get_mark(s, end_mark);
end_mark += length;
cliprdr->format_names = (CLIPRDR_FORMAT_NAME*) xmalloc(sizeof(CLIPRDR_FORMAT_NAME) * allocated_formats);
cliprdr->format_names = (CLIPRDR_FORMAT_NAME*) malloc(sizeof(CLIPRDR_FORMAT_NAME) * allocated_formats);
cliprdr->num_format_names = 0;
while (stream_get_left(s) >= 6)
@ -170,7 +170,7 @@ void cliprdr_process_long_format_names(cliprdrPlugin* cliprdr, STREAM* s, uint32
if (cliprdr->num_format_names >= allocated_formats)
{
allocated_formats *= 2;
cliprdr->format_names = (CLIPRDR_FORMAT_NAME*) xrealloc(cliprdr->format_names,
cliprdr->format_names = (CLIPRDR_FORMAT_NAME*) realloc(cliprdr->format_names,
sizeof(CLIPRDR_FORMAT_NAME) * allocated_formats);
}
@ -204,7 +204,7 @@ void cliprdr_process_format_list(cliprdrPlugin* cliprdr, STREAM* s, uint32 dataL
if (dataLen > 0)
{
cb_event->raw_format_data = (uint8*) xmalloc(dataLen);
cb_event->raw_format_data = (uint8*) malloc(dataLen);
memcpy(cb_event->raw_format_data, stream_get_tail(s), dataLen);
cb_event->raw_format_data_size = dataLen;
}
@ -215,7 +215,7 @@ void cliprdr_process_format_list(cliprdrPlugin* cliprdr, STREAM* s, uint32 dataL
cliprdr_process_short_format_names(cliprdr, s, dataLen, msgFlags);
if (cliprdr->num_format_names > 0)
cb_event->formats = (uint32*) xmalloc(sizeof(uint32) * cliprdr->num_format_names);
cb_event->formats = (uint32*) malloc(sizeof(uint32) * cliprdr->num_format_names);
cb_event->num_formats = 0;
@ -271,10 +271,10 @@ void cliprdr_process_format_list(cliprdrPlugin* cliprdr, STREAM* s, uint32 dataL
cb_event->formats[cb_event->num_formats++] = format;
if (format_name->length > 0)
xfree(format_name->name);
free(format_name->name);
}
xfree(cliprdr->format_names);
free(cliprdr->format_names);
cliprdr->format_names = NULL;
cliprdr->num_format_names = 0;
@ -348,7 +348,7 @@ void cliprdr_process_format_data_response(cliprdrPlugin* cliprdr, STREAM* s, uin
if (dataLen > 0)
{
cb_event->size = dataLen;
cb_event->data = (uint8*) xmalloc(dataLen);
cb_event->data = (uint8*) malloc(dataLen);
memcpy(cb_event->data, stream_get_tail(s), dataLen);
}

2
channels/cliprdr/client/cliprdr_main.c
View File

@ -268,7 +268,7 @@ static void cliprdr_process_event(rdpSvcPlugin* plugin, RDP_EVENT* event)
static void cliprdr_process_terminate(rdpSvcPlugin* plugin)
{
xfree(plugin);
free(plugin);
}
/* cliprdr is always built-in */

16
channels/disk/client/disk_file.c
View File

@ -190,7 +190,7 @@ static boolean disk_file_remove_dir(const char* path)
static void disk_file_set_fullpath(DISK_FILE* file, char* fullpath)
{
xfree(file->fullpath);
free(file->fullpath);
file->fullpath = fullpath;
file->filename = strrchr(file->fullpath, '/');
@ -341,9 +341,9 @@ void disk_file_free(DISK_FILE* file)
unlink(file->fullpath);
}
xfree(file->pattern);
xfree(file->fullpath);
xfree(file);
free(file->pattern);
free(file->fullpath);
free(file);
}
boolean disk_file_seek(DISK_FILE* file, uint64 Offset)
@ -516,7 +516,7 @@ boolean disk_file_set_information(DISK_FILE* file, uint32 FsInformationClass, ui
freerdp_UnicodeToAsciiAlloc((WCHAR*) stream_get_tail(input), &s, FileNameLength / 2);
fullpath = disk_file_combine_fullpath(file->basepath, s);
xfree(s);
free(s);
/* TODO rename does not work on win32 */
if (rename(file->fullpath, fullpath) == 0)
@ -562,7 +562,7 @@ boolean disk_file_query_directory(DISK_FILE* file, uint32 FsInformationClass, ui
if (InitialQuery != 0)
{
rewinddir(file->dir);
xfree(file->pattern);
free(file->pattern);
if (path[0])
file->pattern = _strdup(strrchr(path, '\\') + 1);
@ -606,7 +606,7 @@ boolean disk_file_query_directory(DISK_FILE* file, uint32 FsInformationClass, ui
}
DEBUG_SVC(" pattern %s matched %s", file->pattern, ent_path);
xfree(ent_path);
free(ent_path);
length = freerdp_AsciiToUnicodeAlloc(ent->d_name, &ent_path, 0) * 2;
@ -688,7 +688,7 @@ boolean disk_file_query_directory(DISK_FILE* file, uint32 FsInformationClass, ui
break;
}
xfree(ent_path);
free(ent_path);
return ret;
}

16
channels/disk/client/disk_main.c
View File

@ -186,7 +186,7 @@ static void disk_process_irp_create(DISK_DEVICE* disk, IRP* irp)
stream_write_uint32(irp->output, FileId);
stream_write_uint8(irp->output, Information);
xfree(path);
free(path);
irp->Complete(irp);
}
@ -244,11 +244,11 @@ static void disk_process_irp_read(DISK_DEVICE* disk, IRP* irp)
}
else
{
buffer = (uint8*) xmalloc(Length);
buffer = (uint8*) malloc(Length);
if (!disk_file_read(file, buffer, &Length))
{
irp->IoStatus = STATUS_UNSUCCESSFUL;
xfree(buffer);
free(buffer);
buffer = NULL;
Length = 0;
@ -268,7 +268,7 @@ static void disk_process_irp_read(DISK_DEVICE* disk, IRP* irp)
stream_write(irp->output, buffer, Length);
}
xfree(buffer);
free(buffer);
irp->Complete(irp);
}
@ -409,7 +409,7 @@ static void disk_process_irp_query_volume_information(DISK_DEVICE* disk, IRP* ir
stream_write_uint8(output, 0); /* SupportsObjects */
/* Reserved(1), MUST NOT be added! */
stream_write(output, outStr, length); /* VolumeLabel (Unicode) */
xfree(outStr);
free(outStr);
break;
case FileFsSizeInformation:
@ -434,7 +434,7 @@ static void disk_process_irp_query_volume_information(DISK_DEVICE* disk, IRP* ir
stream_write_uint32(output, svfst.f_namemax/*510*/); /* MaximumComponentNameLength */
stream_write_uint32(output, length); /* FileSystemNameLength */
stream_write(output, outStr, length); /* FileSystemName (Unicode) */
xfree(outStr);
free(outStr);
break;
case FileFsFullSizeInformation:
@ -494,7 +494,7 @@ static void disk_process_irp_query_directory(DISK_DEVICE* disk, IRP* irp)
irp->IoStatus = STATUS_NO_MORE_FILES;
}
xfree(path);
free(path);
irp->Complete(irp);
}
@ -640,7 +640,7 @@ static void disk_free(DEVICE* device)
disk_file_free(file);
list_free(disk->files);
xfree(disk);
free(disk);
}
void disk_register_disk_path(PDEVICE_SERVICE_ENTRY_POINTS pEntryPoints, char* name, char* path)

2
channels/drdynvc/client/drdynvc_main.c
View File

@ -362,7 +362,7 @@ static void drdynvc_process_terminate(rdpSvcPlugin* plugin)
if (drdynvc->channel_mgr != NULL)
dvcman_free(drdynvc->channel_mgr);
xfree(drdynvc);
free(drdynvc);
}
/* drdynvc is always built-in */

8
channels/drdynvc/client/dvcman.c
View File

@ -251,7 +251,7 @@ static void dvcman_channel_free(DVCMAN_CHANNEL* channel)
if (channel->channel_callback)
channel->channel_callback->OnClose(channel->channel_callback);
xfree(channel);
free(channel);
}
void dvcman_free(IWTSVirtualChannelManager* pChannelMgr)
@ -270,8 +270,8 @@ void dvcman_free(IWTSVirtualChannelManager* pChannelMgr)
for (i = 0; i < dvcman->num_listeners; i++)
{
listener = (DVCMAN_LISTENER*) dvcman->listeners[i];
xfree(listener->channel_name);
xfree(listener);
free(listener->channel_name);
free(listener);
}
for (i = 0; i < dvcman->num_plugins; i++)
@ -282,7 +282,7 @@ void dvcman_free(IWTSVirtualChannelManager* pChannelMgr)
pPlugin->Terminated(pPlugin);
}
xfree(dvcman);
free(dvcman);
}
int dvcman_init(IWTSVirtualChannelManager* pChannelMgr)

10
channels/parallel/client/parallel_main.c
View File

@ -106,7 +106,7 @@ static void parallel_process_irp_create(PARALLEL_DEVICE* parallel, IRP* irp)
stream_write_uint32(irp->output, parallel->id);
stream_write_uint8(irp->output, 0);
xfree(path);
free(path);
irp->Complete(irp);
}
@ -133,14 +133,14 @@ static void parallel_process_irp_read(PARALLEL_DEVICE* parallel, IRP* irp)
stream_read_uint32(irp->input, Length);
stream_read_uint64(irp->input, Offset);
buffer = (uint8*) xmalloc(Length);
buffer = (uint8*) malloc(Length);
status = read(parallel->file, irp->output->p, Length);
if (status < 0)
{
irp->IoStatus = STATUS_UNSUCCESSFUL;
xfree(buffer);
free(buffer);
buffer = NULL;
Length = 0;
@ -157,7 +157,7 @@ static void parallel_process_irp_read(PARALLEL_DEVICE* parallel, IRP* irp)
stream_check_size(irp->output, Length);
stream_write(irp->output, buffer, Length);
}
xfree(buffer);
free(buffer);
irp->Complete(irp);
}
@ -304,7 +304,7 @@ static void parallel_free(DEVICE* device)
_aligned_free(parallel->pIrpList);
xfree(parallel);
free(parallel);
}
int DeviceServiceEntry(PDEVICE_SERVICE_ENTRY_POINTS pEntryPoints)

12
channels/printer/client/printer_cups.c
View File

@ -119,7 +119,7 @@ static void printer_cups_close_printjob(rdpPrintJob* printjob)
DEBUG_WARN("cupsPrintFile: %s", cupsLastErrorString());
}
unlink(cups_printjob->printjob_object);
xfree(cups_printjob->printjob_object);
free(cups_printjob->printjob_object);
}
#else
@ -131,7 +131,7 @@ static void printer_cups_close_printjob(rdpPrintJob* printjob)
#endif
((rdpCupsPrinter*)printjob->printer)->printjob = NULL;
xfree(cups_printjob) ;
free(cups_printjob) ;
}
static rdpPrintJob* printer_cups_create_printjob(rdpPrinter* printer, uint32 id)
@ -162,7 +162,7 @@ static rdpPrintJob* printer_cups_create_printjob(rdpPrinter* printer, uint32 id)
if (cups_printjob->printjob_object == NULL)
{
DEBUG_WARN("httpConnectEncrypt: %s", cupsLastErrorString());
xfree(cups_printjob);
free(cups_printjob);
return NULL;
}
@ -174,7 +174,7 @@ static rdpPrintJob* printer_cups_create_printjob(rdpPrinter* printer, uint32 id)
{
DEBUG_WARN("cupsCreateJob: %s", cupsLastErrorString());
httpClose((http_t*)cups_printjob->printjob_object);
xfree(cups_printjob);
free(cups_printjob);
return NULL;
}
cupsStartDocument((http_t*)cups_printjob->printjob_object,
@ -207,8 +207,8 @@ static void printer_cups_free_printer(rdpPrinter* printer)
if (cups_printer->printjob)
cups_printer->printjob->printjob.Close((rdpPrintJob*)cups_printer->printjob);
xfree(printer->name);
xfree(printer);
free(printer->name);
free(printer);
}
static rdpPrinter* printer_cups_new_printer(rdpCupsPrinterDriver* cups_driver, const char* name, boolean is_default)

12
channels/printer/client/printer_main.c
View File

@ -227,9 +227,9 @@ static void printer_free(DEVICE* device)
if (printer_dev->printer)
printer_dev->printer->Free(printer_dev->printer);
xfree(printer_dev->device.name);
free(printer_dev->device.name);
xfree(printer_dev);
free(printer_dev);
}
void printer_register(PDEVICE_SERVICE_ENTRY_POINTS pEntryPoints, rdpPrinter* printer)
@ -244,7 +244,7 @@ void printer_register(PDEVICE_SERVICE_ENTRY_POINTS pEntryPoints, rdpPrinter* pri
uint8* CachedPrinterConfigData;
PRINTER_DEVICE* printer_dev;
port = xmalloc(10);
port = malloc(10);
snprintf(port, 10, "PRN%d", printer->id);
printer_dev = xnew(PRINTER_DEVICE);
@ -287,8 +287,8 @@ void printer_register(PDEVICE_SERVICE_ENTRY_POINTS pEntryPoints, rdpPrinter* pri
stream_write(printer_dev->device.data, CachedPrinterConfigData, CachedFieldsLen);
}
xfree(DriverName);
xfree(PrintName);
free(DriverName);
free(PrintName);
printer_dev->pIrpList = (PSLIST_HEADER) _aligned_malloc(sizeof(SLIST_HEADER), MEMORY_ALLOCATION_ALIGNMENT);
InitializeSListHead(printer_dev->pIrpList);
@ -354,7 +354,7 @@ int DeviceServiceEntry(PDEVICE_SERVICE_ENTRY_POINTS pEntryPoints)
printer_register(pEntryPoints, printer);
}
xfree(printers);
free(printers);
}
return 0;

8
channels/printer/client/printer_win.c
View File

@ -104,7 +104,7 @@ static void printer_win_close_printjob(rdpPrintJob* printjob)
DEBUG_WINPR("ClosePrinter failed");;
((rdpWinPrinter*)printjob->printer)->printjob = NULL;
xfree(win_printjob) ;
free(win_printjob) ;
}
static rdpPrintJob* printer_win_create_printjob(rdpPrinter* printer, uint32 id)
@ -163,8 +163,8 @@ static void printer_win_free_printer(rdpPrinter* printer)
if (win_printer->printjob)
win_printer->printjob->printjob.Close((rdpPrintJob*)win_printer->printjob);
xfree(printer->name);
xfree(printer);
free(printer->name);
free(printer);
}
static rdpPrinter* printer_win_new_printer(rdpWinPrinterDriver* win_driver, const char* name, const wchar_t* drivername, boolean is_default)
@ -194,7 +194,7 @@ static rdpPrinter* printer_win_new_printer(rdpWinPrinterDriver* win_driver, cons
prninfo = (PRINTER_INFO_2*) GlobalAlloc(GPTR,needed);
GetPrinter(win_printer->hPrinter, 2, (LPBYTE) prninfo, needed, &needed);
win_printer->printer.driver = xmalloc(1000);
win_printer->printer.driver = malloc(1000);
wcstombs_s(&charsConverted, win_printer->printer.driver, 1000, prninfo->pDriverName, _TRUNCATE);
return (rdpPrinter*)win_printer;

15
channels/rail/client/rail_orders.c
View File

@ -22,8 +22,12 @@
#include "config.h"
#endif
#include <stdio.h>
#include <stdlib.h>
#include <winpr/crt.h>
#include <freerdp/utils/rail.h>
#include <freerdp/utils/memory.h>
#include <freerdp/utils/unicode.h>
#include "rail_orders.h"
@ -71,7 +75,7 @@ void rail_string_to_unicode_string(rdpRailOrder* rail_order, char* string, RAIL_
int length = 0;
if (unicode_string->string != NULL)
xfree(unicode_string->string);
free(unicode_string->string);
unicode_string->string = NULL;
unicode_string->length = 0;
@ -630,14 +634,15 @@ void rail_send_client_langbar_info_order(rdpRailOrder* rail_order)
s = rail_pdu_init(RAIL_LANGBAR_INFO_ORDER_LENGTH);
rail_write_langbar_info_order(s, &rail_order->langbar_info);
rail_send_pdu(rail_order, s, RAIL_ORDER_TYPE_LANGBAR_INFO);
stream_free(s) ;
stream_free(s);
}
rdpRailOrder* rail_order_new()
{
rdpRailOrder* rail_order;
rail_order = xnew(rdpRailOrder);
rail_order = (rdpRailOrder*) malloc(sizeof(rdpRailOrder));
ZeroMemory(rail_order, sizeof(rdpRailOrder));
if (rail_order != NULL)
{
@ -652,7 +657,7 @@ void rail_order_free(rdpRailOrder* rail_order)
if (rail_order != NULL)
{
xfree(rail_order);
free(rail_order);
}
}

2
channels/rdpdr/client/devman.c
View File

@ -58,7 +58,7 @@ void devman_free(DEVMAN* devman)
list_free(devman->devices);
xfree(devman);
free(devman);
}
static void devman_register_device(DEVMAN* devman, DEVICE* device)

4
channels/rdpdr/client/rdpdr_main.c
View File

@ -118,7 +118,7 @@ static void rdpdr_send_client_name_request(rdpdrPlugin* rdpdr)
stream_write(data_out, computerNameW, computerNameLenW);
stream_write_uint16(data_out, 0); /* null terminator */
xfree(computerNameW);
free(computerNameW);
svc_plugin_send((rdpSvcPlugin*) rdpdr, data_out);
}
@ -313,7 +313,7 @@ static void rdpdr_process_terminate(rdpSvcPlugin* plugin)
rdpdrPlugin* rdpdr = (rdpdrPlugin*) plugin;
devman_free(rdpdr->devman);
xfree(plugin);
free(plugin);
}
/* rdpdr is always built-in */

4
channels/rdpsnd/client/alsa/rdpsnd_alsa.c
View File

@ -257,9 +257,9 @@ static void rdpsnd_alsa_free(rdpsndDevicePlugin* device)
rdpsndAlsaPlugin* alsa = (rdpsndAlsaPlugin*)device;
rdpsnd_alsa_close(device);
xfree(alsa->device_name);
free(alsa->device_name);
freerdp_dsp_context_free(alsa->dsp_context);
xfree(alsa);
free(alsa);
}
static boolean rdpsnd_alsa_format_supported(rdpsndDevicePlugin* device, rdpsndFormat* format)

4
channels/rdpsnd/client/pulse/rdpsnd_pulse.c
View File

@ -357,9 +357,9 @@ static void rdpsnd_pulse_free(rdpsndDevicePlugin* device)
pulse->mainloop = NULL;
}
xfree(pulse->device_name);
free(pulse->device_name);
freerdp_dsp_context_free(pulse->dsp_context);
xfree(pulse);
free(pulse);
}
static boolean rdpsnd_pulse_format_supported(rdpsndDevicePlugin* device, rdpsndFormat* format)

16
channels/rdpsnd/client/rdpsnd_main.c
View File

@ -104,7 +104,7 @@ static void rdpsnd_process_interval(rdpSvcPlugin* plugin)
item = (struct data_out_item*) list_dequeue(rdpsnd->data_out_list);
svc_plugin_send(plugin, item->data_out);
xfree(item);
free(item);
DEBUG_SVC("processed data_out");
}
@ -135,8 +135,8 @@ static void rdpsnd_free_supported_formats(rdpsndPlugin* rdpsnd)
uint16 i;
for (i = 0; i < rdpsnd->n_supported_formats; i++)
xfree(rdpsnd->supported_formats[i].data);
xfree(rdpsnd->supported_formats);
free(rdpsnd->supported_formats[i].data);
free(rdpsnd->supported_formats);
rdpsnd->supported_formats = NULL;
rdpsnd->n_supported_formats = 0;
@ -224,7 +224,7 @@ static void rdpsnd_process_message_formats(rdpsndPlugin* rdpsnd, STREAM* data_in
stream_write(data_out, format_mark, 18 + format->cbSize);
if (format->cbSize > 0)
{
format->data = xmalloc(format->cbSize);
format->data = malloc(format->cbSize);
memcpy(format->data, data_mark, format->cbSize);
}
n_out_formats++;
@ -238,7 +238,7 @@ static void rdpsnd_process_message_formats(rdpsndPlugin* rdpsnd, STREAM* data_in
}
else
{
xfree(out_formats);
free(out_formats);
DEBUG_WARN("no formats supported");
}
@ -443,7 +443,7 @@ static boolean rdpsnd_load_device_plugin(rdpsndPlugin* rdpsnd, const char* name,
strcpy(fullname, "rdpsnd_");
strcat(fullname, name);
entry = (PFREERDP_RDPSND_DEVICE_ENTRY)freerdp_load_plugin(fullname, RDPSND_DEVICE_EXPORT_FUNC_NAME);
xfree(fullname);
free(fullname);
}
if (entry == NULL)
{
@ -556,13 +556,13 @@ static void rdpsnd_process_terminate(rdpSvcPlugin* plugin)
while ((item = list_dequeue(rdpsnd->data_out_list)) != NULL)
{
stream_free(item->data_out);
xfree(item);
free(item);
}
list_free(rdpsnd->data_out_list);
rdpsnd_free_supported_formats(rdpsnd);
xfree(plugin);
free(plugin);
}
/* rdpsnd is always built-in */

10
channels/rdpsnd/server/rdpsnd.c
View File

@ -133,7 +133,7 @@ static boolean rdpsnd_server_recv_formats(rdpsnd_server* rdpsnd, STREAM* s)
{
if (stream_get_left(s) < 18)
{
xfree(rdpsnd->context.client_formats);
free(rdpsnd->context.client_formats);
rdpsnd->context.client_formats = NULL;
return false;
}
@ -290,7 +290,7 @@ static void rdpsnd_server_select_format(rdpsnd_server_context* context, int clie
if (rdpsnd->out_buffer_size < out_buffer_size)
{
rdpsnd->out_buffer = xrealloc(rdpsnd->out_buffer, out_buffer_size);
rdpsnd->out_buffer = realloc(rdpsnd->out_buffer, out_buffer_size);
rdpsnd->out_buffer_size = out_buffer_size;
}
@ -479,13 +479,13 @@ void rdpsnd_server_context_free(rdpsnd_server_context* context)
stream_free(rdpsnd->rdpsnd_pdu);
if (rdpsnd->out_buffer)
xfree(rdpsnd->out_buffer);
free(rdpsnd->out_buffer);
if (rdpsnd->dsp_context)
freerdp_dsp_context_free(rdpsnd->dsp_context);
if (rdpsnd->context.client_formats)
xfree(rdpsnd->context.client_formats);
free(rdpsnd->context.client_formats);
xfree(rdpsnd);
free(rdpsnd);
}

2
channels/sample/client/skel_main.c
View File

@ -129,7 +129,7 @@ static void skel_process_terminate(rdpSvcPlugin* plugin)
/* put your cleanup here */
xfree(plugin);
free(plugin);
}
DEFINE_SVC_PLUGIN(skel, "skel",

10
channels/serial/client/serial_main.c
View File

@ -110,7 +110,7 @@ static void serial_process_irp_create(SERIAL_DEVICE* serial, IRP* irp)
stream_write_uint32(irp->output, FileId);
stream_write_uint8(irp->output, 0);
xfree(path);
free(path);
irp->Complete(irp);
}
@ -162,12 +162,12 @@ static void serial_process_irp_read(SERIAL_DEVICE* serial, IRP* irp)
}
else
{
buffer = (uint8*) xmalloc(Length);
buffer = (uint8*) malloc(Length);
if (!serial_tty_read(tty, buffer, &Length))
{
irp->IoStatus = STATUS_UNSUCCESSFUL;
xfree(buffer);
free(buffer);
buffer = NULL;
Length = 0;
@ -187,7 +187,7 @@ static void serial_process_irp_read(SERIAL_DEVICE* serial, IRP* irp)
stream_write(irp->output, buffer, Length);
}
xfree(buffer);
free(buffer);
irp->Complete(irp);
}
@ -394,7 +394,7 @@ static void serial_free(DEVICE* device)
list_free(serial->pending_irps);
xfree(serial);
free(serial);
}
int DeviceServiceEntry(PDEVICE_SERVICE_ENTRY_POINTS pEntryPoints)

6
channels/serial/client/serial_tty.c
View File

@ -457,9 +457,9 @@ void serial_tty_free(SERIAL_TTY* tty)
close(tty->fd);
}
xfree(tty->ptermios);
xfree(tty->pold_termios);
xfree(tty);
free(tty->ptermios);
free(tty->pold_termios);
free(tty);
}

10
channels/smartcard/client/scard_main.c
View File

@ -52,13 +52,13 @@ static void scard_free(DEVICE* dev)
/* Begin TS Client defect workaround. */
while ((CompletionIdInfo = (COMPLETIONIDINFO*) list_dequeue(scard->CompletionIds)) != NULL)
xfree(CompletionIdInfo);
free(CompletionIdInfo);
list_free(scard->CompletionIds);
/* End TS Client defect workaround. */
xfree(dev);
free(dev);
return;
}
@ -106,7 +106,7 @@ static void scard_process_irp_thread_func(struct scard_irp_thread_args* args)
scard_process_irp(args->scard, args->irp);
freerdp_thread_free(args->thread);
xfree(args);
free(args);
}
static void* scard_thread_func(void* arg)
@ -180,7 +180,7 @@ static boolean scard_check_for_duplicate_id(SCARD_DEVICE* scard, uint32 Complet
DEBUG_WARN("CompletionID number %u was previously marked as a duplicate. The response to the command is removed.", CompletionId);
}
list_remove(scard->CompletionIds, CompletionIdInfo);
xfree(CompletionIdInfo);
free(CompletionIdInfo);
return duplicate;
}
}
@ -266,7 +266,7 @@ static void scard_irp_request(DEVICE* device, IRP* irp)
* get their own thread
* TODO: revise this mechanism.. maybe worker pool
*/
struct scard_irp_thread_args *args = xmalloc(sizeof(struct scard_irp_thread_args));
struct scard_irp_thread_args *args = malloc(sizeof(struct scard_irp_thread_args));
args->thread = freerdp_thread_new();

44
channels/smartcard/client/scard_operations.c
View File

@ -185,7 +185,7 @@ static uint32 sc_input_string(IRP* irp, char **dest, uint32 dataLength, boolean
int bufferSize;
bufferSize = wide ? (2 * dataLength) : dataLength;
buffer = xmalloc(bufferSize + 2); /* reserve 2 bytes for the '\0' */
buffer = malloc(bufferSize + 2); /* reserve 2 bytes for the '\0' */
stream_read(irp->input, buffer, bufferSize);
@ -359,7 +359,7 @@ static uint32 handle_ListReaders(IRP* irp, boolean wide)
#else
rv = SCardListReaders(hContext, NULL, NULL, &dwReaders);
readerList = xmalloc(dwReaders);
readerList = malloc(dwReaders);
rv = SCardListReaders(hContext, NULL, readerList, &dwReaders);
#endif
if (rv != SCARD_S_SUCCESS)
@ -409,7 +409,7 @@ static uint32 handle_ListReaders(IRP* irp, boolean wide)
#ifdef SCARD_AUTOALLOCATE
SCardFreeMemory(hContext, readerList);
#else
xfree(readerList);
free(readerList);
#endif
return rv;
@ -517,12 +517,12 @@ static uint32 handle_GetStatusChange(IRP* irp, boolean wide)
stream_write_zero(irp->output, 4);
xfree((void *)cur->szReader);
free((void *)cur->szReader);
}
sc_output_alignment(irp, 8);
xfree(readerStates);
free(readerStates);
return rv;
}
@ -587,7 +587,7 @@ static uint32 handle_Connect(IRP* irp, boolean wide)
sc_output_alignment(irp, 8);
xfree(readerName);
free(readerName);
return rv;
}
@ -729,7 +729,7 @@ static uint32 handle_State(IRP* irp)
rv = SCardStatus(hCard, (LPSTR) &readerName, &readerLen, &state, &protocol, pbAtr, &atrLen);
#else
readerLen = 256;
readerName = xmalloc(readerLen);
readerName = malloc(readerLen);
rv = SCardStatus(hCard, (LPSTR) readerName, &readerLen, &state, &protocol, pbAtr, &atrLen);
#endif
@ -763,9 +763,9 @@ static uint32 handle_State(IRP* irp)
sc_output_alignment(irp, 8);
#ifdef SCARD_AUTOALLOCATE
xfree(readerName);
free(readerName);
#else
xfree(readerName);
free(readerName);
#endif
return rv;
@ -802,7 +802,7 @@ static DWORD handle_Status(IRP *irp, boolean wide)
rv = SCardStatus(hCard, (LPSTR) &readerName, &readerLen, &state, &protocol, pbAtr, &atrLen);
#else
readerLen = 256;
readerName = xmalloc(readerLen);
readerName = malloc(readerLen);
rv = SCardStatus(hCard, (LPSTR) readerName, &readerLen, &state, &protocol, pbAtr, &atrLen);
#endif
@ -856,7 +856,7 @@ static DWORD handle_Status(IRP *irp, boolean wide)
/* SCardFreeMemory(NULL, readerName); */
free(readerName);
#else
xfree(readerName);
free(readerName);
#endif
return rv;
@ -909,13 +909,13 @@ static uint32 handle_Transmit(IRP* irp)
/* send buffer */
stream_read_uint32(irp->input, linkedLen);
sendBuf = xmalloc(linkedLen);
sendBuf = malloc(linkedLen);
stream_read(irp->input, sendBuf, linkedLen);
sc_input_repos(irp, linkedLen);
}
if (cbRecvLength)
recvBuf = xmalloc(cbRecvLength);
recvBuf = malloc(cbRecvLength);
if (map[4] & SCARD_INPUT_LINKED)
{
@ -968,8 +968,8 @@ static uint32 handle_Transmit(IRP* irp)
sc_output_alignment(irp, 8);
xfree(sendBuf);
xfree(recvBuf);
free(sendBuf);
free(recvBuf);
return rv;
}
@ -1014,7 +1014,7 @@ static uint32 handle_Control(IRP* irp)
/* read real input size */
stream_read_uint32(irp->input, recvLength);
recvBuffer = xmalloc(recvLength);
recvBuffer = malloc(recvLength);
if (!recvBuffer)
return sc_output_return(irp, SCARD_E_NO_MEMORY);
@ -1023,7 +1023,7 @@ static uint32 handle_Control(IRP* irp)
}
nBytesReturned = outBufferSize;
sendBuffer = xmalloc(outBufferSize);
sendBuffer = malloc(outBufferSize);
if (!sendBuffer)
return sc_output_return(irp, SCARD_E_NO_MEMORY);
@ -1048,8 +1048,8 @@ static uint32 handle_Control(IRP* irp)
sc_output_alignment(irp, 8);
xfree(recvBuffer);
xfree(sendBuffer);
free(recvBuffer);
free(sendBuffer);
return rv;
}
@ -1165,7 +1165,7 @@ static uint32 handle_GetAttrib(IRP* irp)
}
sc_output_alignment(irp, 8);
xfree(pbAttr);
free(pbAttr);
return rv;
}
@ -1212,7 +1212,7 @@ static uint32 handle_LocateCardsByATR(IRP* irp, boolean wide)
stream_read_uint32(irp->input, hContext);
stream_read_uint32(irp->input, atrMaskCount);
pAtrMasks = xmalloc(atrMaskCount * sizeof(SERVER_SCARD_ATRMASK));
pAtrMasks = malloc(atrMaskCount * sizeof(SERVER_SCARD_ATRMASK));
if (!pAtrMasks)
return sc_output_return(irp, SCARD_E_NO_MEMORY);
@ -1317,7 +1317,7 @@ static uint32 handle_LocateCardsByATR(IRP* irp, boolean wide)
stream_write_zero(irp->output, 4);
xfree((void*) cur->szReader);
free((void*) cur->szReader);
}
sc_output_alignment(irp, 8);

4
channels/tsmf/client/alsa/tsmf_alsa.c
View File

@ -209,7 +209,7 @@ static boolean tsmf_alsa_play(ITSMFAudioDevice* audio, uint8* data, uint32 data_
pindex += error * rbytes_per_frame;
}
}
xfree(data);
free(data);
return true;
}
@ -245,7 +245,7 @@ static void tsmf_alsa_free(ITSMFAudioDevice* audio)
snd_pcm_close(alsa->out_handle);
}
freerdp_dsp_context_free(alsa->dsp_context);
xfree(alsa);
free(alsa);
}
ITSMFAudioDevice* TSMFAudioDeviceEntry(void)

12
channels/tsmf/client/ffmpeg/tsmf_ffmpeg.c
View File

@ -356,7 +356,7 @@ static boolean tsmf_ffmpeg_decode_audio(ITSMFDecoder* decoder, const uint8* data
if (mdecoder->decoded_size_max - mdecoder->decoded_size < AVCODEC_MAX_AUDIO_FRAME_SIZE)
{
mdecoder->decoded_size_max = mdecoder->decoded_size_max * 2 + 16;
mdecoder->decoded_data = xrealloc(mdecoder->decoded_data, mdecoder->decoded_size_max);
mdecoder->decoded_data = realloc(mdecoder->decoded_data, mdecoder->decoded_size_max);
dst = (uint8*) (((uintptr_t)mdecoder->decoded_data + 15) & ~ 0x0F);
if (dst - mdecoder->decoded_data != dst_offset)
{
@ -404,7 +404,7 @@ static boolean tsmf_ffmpeg_decode_audio(ITSMFDecoder* decoder, const uint8* data
if (mdecoder->decoded_size == 0)
{
xfree(mdecoder->decoded_data);
free(mdecoder->decoded_data);
mdecoder->decoded_data = NULL;
}
else if (dst_offset)
@ -425,7 +425,7 @@ static boolean tsmf_ffmpeg_decode(ITSMFDecoder* decoder, const uint8* data, uint
if (mdecoder->decoded_data)
{
xfree(mdecoder->decoded_data);
free(mdecoder->decoded_data);
mdecoder->decoded_data = NULL;
}
mdecoder->decoded_size = 0;
@ -493,16 +493,16 @@ static void tsmf_ffmpeg_free(ITSMFDecoder* decoder)
if (mdecoder->frame)
av_free(mdecoder->frame);
if (mdecoder->decoded_data)
xfree(mdecoder->decoded_data);
free(mdecoder->decoded_data);
if (mdecoder->codec_context)
{
if (mdecoder->prepared)
avcodec_close(mdecoder->codec_context);
if (mdecoder->codec_context->extradata)
xfree(mdecoder->codec_context->extradata);
free(mdecoder->codec_context->extradata);
av_free(mdecoder->codec_context);
}
xfree(decoder);
free(decoder);
}
static boolean initialized = false;

4
channels/tsmf/client/pulse/tsmf_pulse.c
View File

@ -336,7 +336,7 @@ static boolean tsmf_pulse_play(ITSMFAudioDevice* audio, uint8* data, uint32 data
pa_threaded_mainloop_unlock(pulse->mainloop);
}
xfree(data);
free(data);
return true;
}
@ -386,7 +386,7 @@ static void tsmf_pulse_free(ITSMFAudioDevice* audio)
pa_threaded_mainloop_free(pulse->mainloop);
pulse->mainloop = NULL;
}
xfree(pulse);
free(pulse);
}
ITSMFAudioDevice* TSMFAudioDeviceEntry(void)

2
channels/tsmf/client/tsmf_audio.c
View File

@ -44,7 +44,7 @@ static ITSMFAudioDevice* tsmf_load_audio_device_by_name(const char* name, const
strcpy(fullname, "tsmf_");
strcat(fullname, name);
entry = (TSMF_AUDIO_DEVICE_ENTRY) freerdp_load_plugin(fullname, TSMF_AUDIO_DEVICE_EXPORT_FUNC_NAME);
xfree(fullname);
free(fullname);
}
if (entry == NULL)
{

2
channels/tsmf/client/tsmf_decoder.c
View File

@ -46,7 +46,7 @@ static ITSMFDecoder* tsmf_load_decoder_by_name(const char* name, TS_AM_MEDIA_TYP
strcpy(fullname, "tsmf_");
strcat(fullname, name);
entry = (TSMF_DECODER_ENTRY) freerdp_load_plugin(fullname, TSMF_DECODER_EXPORT_FUNC_NAME);
xfree(fullname);
free(fullname);
}
if (entry == NULL)
{

6
channels/tsmf/client/tsmf_main.c
View File

@ -348,7 +348,7 @@ static int tsmf_on_close(IWTSVirtualChannelCallback* pChannelCallback)
tsmf_stream_free(stream);
}
}
xfree(pChannelCallback);
free(pChannelCallback);
return 0;
}
@ -396,8 +396,8 @@ static int tsmf_plugin_terminated(IWTSPlugin* pPlugin)
DEBUG_DVC("");
if (tsmf->listener_callback)
xfree(tsmf->listener_callback);
xfree(tsmf);
free(tsmf->listener_callback);
free(tsmf);
return 0;
}

20
channels/tsmf/client/tsmf_media.c
View File

@ -216,8 +216,8 @@ static TSMF_SAMPLE* tsmf_stream_pop_sample(TSMF_STREAM* stream, int sync)
static void tsmf_sample_free(TSMF_SAMPLE* sample)
{
if (sample->data)
xfree(sample->data);
xfree(sample);
free(sample->data);
free(sample);
}
static void tsmf_sample_ack(TSMF_SAMPLE* sample)
@ -361,7 +361,7 @@ static void tsmf_sample_playback_video(TSMF_SAMPLE* sample)
if (presentation->last_rects)
{
xfree(presentation->last_rects);
free(presentation->last_rects);
presentation->last_rects = NULL;
}
presentation->last_num_rects = presentation->output_num_rects;
@ -477,7 +477,7 @@ static void tsmf_sample_playback(TSMF_SAMPLE* sample)
return;
}
xfree(sample->data);
free(sample->data);
sample->data = NULL;
if (stream->major_type == TSMF_MAJOR_TYPE_VIDEO)
@ -564,7 +564,7 @@ static void tsmf_sample_playback(TSMF_SAMPLE* sample)
{
if (presentation->last_rects)
{
xfree(presentation->last_rects);
free(presentation->last_rects);
presentation->last_rects = NULL;
}
presentation->last_num_rects = presentation->output_num_rects;
@ -818,13 +818,13 @@ void tsmf_presentation_stop(TSMF_PRESENTATION* presentation)
tsmf_presentation_restore_last_video_frame(presentation);
if (presentation->last_rects)
{
xfree(presentation->last_rects);
free(presentation->last_rects);
presentation->last_rects = NULL;
}
presentation->last_num_rects = 0;
if (presentation->output_rects)
{
xfree(presentation->output_rects);
free(presentation->output_rects);
presentation->output_rects = NULL;
}
presentation->output_num_rects = 0;
@ -839,7 +839,7 @@ void tsmf_presentation_set_geometry_info(TSMF_PRESENTATION* presentation,
presentation->output_width = width;
presentation->output_height = height;
if (presentation->output_rects)
xfree(presentation->output_rects);
free(presentation->output_rects);
presentation->output_rects = rects;
presentation->output_num_rects = num_rects;
}
@ -907,7 +907,7 @@ void tsmf_presentation_free(TSMF_PRESENTATION* presentation)
CloseHandle(presentation->mutex);
xfree(presentation);
free(presentation);
}
TSMF_STREAM* tsmf_stream_new(TSMF_PRESENTATION* presentation, uint32 stream_id)
@ -1015,7 +1015,7 @@ void tsmf_stream_free(TSMF_STREAM* stream)
freerdp_thread_free(stream->thread);
xfree(stream);
free(stream);
stream = 0;
}

2
channels/urbdrc/client/urbdrc_main.c
View File

@ -1010,7 +1010,7 @@ static int urbdrc_load_udevman_plugin(IWTSPlugin* pPlugin, const char* name, RDP
strcpy(fullname, name);
strcat(fullname, "_udevman");
entry = (PFREERDP_URBDRC_DEVICE_ENTRY) freerdp_load_plugin(fullname, URBDRC_UDEVMAN_EXPORT_FUNC_NAME);
xfree(fullname);
free(fullname);
}
if (entry == NULL)

2
client/DirectFB/df_graphics.c
View File

@ -133,6 +133,6 @@ void df_register_graphics(rdpGraphics* graphics)
pointer->SetDefault = df_Pointer_SetDefault;
graphics_register_pointer(graphics, pointer);
xfree(pointer);
free(pointer);
}

4
client/DirectFB/dfreerdp.c
View File

@ -306,7 +306,7 @@ df_process_channel_event(rdpChannels* channels, freerdp* instance)
static void df_free(dfInfo* dfi)
{
dfi->dfb->Release(dfi->dfb);
xfree(dfi);
free(dfi);
}
int dfreerdp_run(freerdp* instance)
@ -421,7 +421,7 @@ void* thread_func(void* param)
dfreerdp_run(data->instance);
xfree(data);
free(data);
pthread_detach(pthread_self());

2
client/Sample/freerdp.c
View File

@ -292,7 +292,7 @@ void* thread_func(void* param)
tfreerdp_run(data->instance);
xfree(data);
free(data);
pthread_detach(pthread_self());

16
client/Windows/wf_gdi.c
View File

@ -96,7 +96,7 @@ uint8* wf_glyph_convert(wfInfo* wfi, int width, int height, uint8* data)
src_bytes_per_row = (width + 7) / 8;
dst_bytes_per_row = src_bytes_per_row + (src_bytes_per_row % 2);
cdata = (uint8 *) xmalloc(dst_bytes_per_row * height);
cdata = (uint8 *) malloc(dst_bytes_per_row * height);
src = data;
for (indexy = 0; indexy < height; indexy++)
@ -376,7 +376,7 @@ void wf_gdi_polyline(rdpContext* context, POLYLINE_ORDER* polyline)
if (polyline->numPoints > 0)
{
pts = (POINT*) xmalloc(sizeof(POINT) * polyline->numPoints);
pts = (POINT*) malloc(sizeof(POINT) * polyline->numPoints);
for (i = 0; i < (int) polyline->numPoints; i++)
{
@ -388,7 +388,7 @@ void wf_gdi_polyline(rdpContext* context, POLYLINE_ORDER* polyline)
}
Polyline(wfi->drawing->hdc, pts, polyline->numPoints);
xfree(pts);
free(pts);
}
SelectObject(wfi->drawing->hdc, org_hpen);
@ -466,7 +466,7 @@ void wf_gdi_surface_bits(rdpContext* context, SURFACE_BITS_COMMAND* surface_bits
wfi->image->_bitmap.width = surface_bits_command->width;
wfi->image->_bitmap.height = surface_bits_command->height;
wfi->image->_bitmap.bpp = surface_bits_command->bpp;
wfi->image->_bitmap.data = (uint8*) xrealloc(wfi->image->_bitmap.data, wfi->image->_bitmap.width * wfi->image->_bitmap.height * 4);
wfi->image->_bitmap.data = (uint8*) realloc(wfi->image->_bitmap.data, wfi->image->_bitmap.width * wfi->image->_bitmap.height * 4);
freerdp_image_flip(nsc_context->bmpdata, wfi->image->_bitmap.data, wfi->image->_bitmap.width, wfi->image->_bitmap.height, 32);
BitBlt(wfi->primary->hdc, surface_bits_command->destLeft, surface_bits_command->destTop, surface_bits_command->width, surface_bits_command->height, wfi->image->hdc, 0, 0, GDI_SRCCOPY);
}
@ -476,7 +476,7 @@ void wf_gdi_surface_bits(rdpContext* context, SURFACE_BITS_COMMAND* surface_bits
wfi->image->_bitmap.height = surface_bits_command->height;
wfi->image->_bitmap.bpp = surface_bits_command->bpp;
wfi->image->_bitmap.data = (uint8*) xrealloc(wfi->image->_bitmap.data,
wfi->image->_bitmap.data = (uint8*) realloc(wfi->image->_bitmap.data,
wfi->image->_bitmap.width * wfi->image->_bitmap.height * 4);
if ((surface_bits_command->bpp != 32) || (wfi->clrconv->alpha == true))
@ -490,9 +490,9 @@ void wf_gdi_surface_bits(rdpContext* context, SURFACE_BITS_COMMAND* surface_bits
surface_bits_command->bpp = 32;
surface_bits_command->bitmapData = wfi->image->_bitmap.data;
temp_image = (uint8*) xmalloc(wfi->image->_bitmap.width * wfi->image->_bitmap.height * 4);
temp_image = (uint8*) malloc(wfi->image->_bitmap.width * wfi->image->_bitmap.height * 4);
freerdp_image_flip(wfi->image->_bitmap.data, temp_image, wfi->image->_bitmap.width, wfi->image->_bitmap.height, 32);
xfree(wfi->image->_bitmap.data);
free(wfi->image->_bitmap.data);
wfi->image->_bitmap.data = temp_image;
}
else
@ -510,7 +510,7 @@ void wf_gdi_surface_bits(rdpContext* context, SURFACE_BITS_COMMAND* surface_bits
}
if (tile_bitmap != NULL)
xfree(tile_bitmap);
free(tile_bitmap);
}
void wf_gdi_register_update_callbacks(rdpUpdate* update)

6
client/Windows/wf_graphics.c
View File

@ -71,7 +71,7 @@ wfBitmap* wf_image_new(wfInfo* wfi, int width, int height, int bpp, uint8* data)
wfBitmap* image;
hdc = GetDC(NULL);
image = (wfBitmap*) xmalloc(sizeof(wfBitmap));
image = (wfBitmap*) malloc(sizeof(wfBitmap));
image->hdc = CreateCompatibleDC(hdc);
image->bitmap = wf_create_dib(wfi, width, height, bpp, data, &(image->pdata));
@ -150,9 +150,9 @@ void wf_Bitmap_Decompress(rdpContext* context, rdpBitmap* bitmap,
size = width * height * (bpp / 8);
if (bitmap->data == NULL)
bitmap->data = (uint8*) xmalloc(size);
bitmap->data = (uint8*) malloc(size);
else
bitmap->data = (uint8*) xrealloc(bitmap->data, size);
bitmap->data = (uint8*) realloc(bitmap->data, size);
if (compressed)
{

4
client/Windows/wfreerdp.c
View File

@ -303,12 +303,12 @@ boolean wf_post_connect(freerdp* instance)
wfi->hdc->alpha = wfi->clrconv->alpha;
wfi->hdc->invert = wfi->clrconv->invert;
wfi->hdc->hwnd = (HGDI_WND) xmalloc(sizeof(GDI_WND));
wfi->hdc->hwnd = (HGDI_WND) malloc(sizeof(GDI_WND));
wfi->hdc->hwnd->invalid = gdi_CreateRectRgn(0, 0, 0, 0);
wfi->hdc->hwnd->invalid->null = 1;
wfi->hdc->hwnd->count = 32;
wfi->hdc->hwnd->cinvalid = (HGDI_RGN) xmalloc(sizeof(GDI_RGN) * wfi->hdc->hwnd->count);
wfi->hdc->hwnd->cinvalid = (HGDI_RGN) malloc(sizeof(GDI_RGN) * wfi->hdc->hwnd->count);
wfi->hdc->hwnd->ninvalid = 0;
wfi->image = wf_image_new(wfi, 64, 64, 32, NULL);

42
client/X11/xf_cliprdr.c
View File

@ -149,11 +149,11 @@ void xf_cliprdr_uninit(xfInfo* xfi)
if (cb)
{
xfree(cb->formats);
xfree(cb->data);
xfree(cb->respond);
xfree(cb->incr_data);
xfree(cb);
free(cb->formats);
free(cb->data);
free(cb->respond);
free(cb->incr_data);
free(cb);
xfi->clipboard_context = NULL;
}
}
@ -325,7 +325,7 @@ static void xf_cliprdr_send_raw_format_list(xfInfo* xfi)
event = (RDP_CB_FORMAT_LIST_EVENT*) freerdp_event_new(RDP_EVENT_CLASS_CLIPRDR,
RDP_EVENT_TYPE_CB_FORMAT_LIST, NULL, NULL);
event->raw_format_data = (uint8*) xmalloc(length);
event->raw_format_data = (uint8*) malloc(length);
memcpy(event->raw_format_data, format_data, length);
event->raw_format_data_size = length;
XFree(format_data);
@ -355,7 +355,7 @@ static void xf_cliprdr_send_supported_format_list(xfInfo* xfi)
event = (RDP_CB_FORMAT_LIST_EVENT*) freerdp_event_new(RDP_EVENT_CLASS_CLIPRDR,
RDP_EVENT_TYPE_CB_FORMAT_LIST, NULL, NULL);
event->formats = (uint32*) xmalloc(sizeof(uint32) * cb->num_format_mappings);
event->formats = (uint32*) malloc(sizeof(uint32) * cb->num_format_mappings);
event->num_formats = cb->num_format_mappings;
for (i = 0; i < cb->num_format_mappings; i++)
@ -485,7 +485,7 @@ static void xf_cliprdr_get_requested_targets(xfInfo* xfi)
event = (RDP_CB_FORMAT_LIST_EVENT*) freerdp_event_new(RDP_EVENT_CLASS_CLIPRDR,
RDP_EVENT_TYPE_CB_FORMAT_LIST, NULL, NULL);
event->formats = (uint32*) xmalloc(sizeof(uint32) * cb->num_format_mappings);
event->formats = (uint32*) malloc(sizeof(uint32) * cb->num_format_mappings);
num = 0;
for (i = 0; i < length; i++)
{
@ -520,7 +520,7 @@ static uint8* xf_cliprdr_process_requested_raw(uint8* data, int* size)
{
uint8* outbuf;
outbuf = (uint8*) xmalloc(*size);
outbuf = (uint8*) malloc(*size);
memcpy(outbuf, data, *size);
return outbuf;
}
@ -533,7 +533,7 @@ static uint8* xf_cliprdr_process_requested_unicodetext(uint8* data, int* size)
inbuf = (char*) lf2crlf(data, size);
out_size = freerdp_AsciiToUnicodeAlloc(inbuf, &outbuf, 0);
xfree(inbuf);
free(inbuf);
*size = (int) ((out_size + 1) * 2);
@ -633,7 +633,7 @@ static uint8* xf_cliprdr_process_requested_html(uint8* data, int* size)
memcpy(outbuf + 43, num, 10);
*size = strlen((char*) outbuf) + 1;
xfree(inbuf);
free(inbuf);
return outbuf;
}
@ -730,7 +730,7 @@ static boolean xf_cliprdr_get_requested_data(xfInfo* xfi, Atom target)
cb->incr_starts = true;
if (cb->incr_data)
{
xfree(cb->incr_data);
free(cb->incr_data);
cb->incr_data = NULL;
}
cb->incr_data_length = 0;
@ -758,7 +758,7 @@ static boolean xf_cliprdr_get_requested_data(xfInfo* xfi, Atom target)
{
bytes_left = length * format / 8;
DEBUG_X11("%d bytes", (int)bytes_left);
cb->incr_data = (uint8*) xrealloc(cb->incr_data, cb->incr_data_length + bytes_left);
cb->incr_data = (uint8*) realloc(cb->incr_data, cb->incr_data_length + bytes_left);
memcpy(cb->incr_data + cb->incr_data_length, data, bytes_left);
cb->incr_data_length += bytes_left;
XFree(data);
@ -832,12 +832,12 @@ static void xf_cliprdr_process_cb_format_list_event(xfInfo* xfi, RDP_CB_FORMAT_L
if (cb->data)
{
xfree(cb->data);
free(cb->data);
cb->data = NULL;
}
if (cb->formats)
xfree(cb->formats);
free(cb->formats);
cb->formats = event->formats;
cb->num_formats = event->num_formats;
@ -870,7 +870,7 @@ static void xf_cliprdr_process_cb_format_list_event(xfInfo* xfi, RDP_CB_FORMAT_L
static void xf_cliprdr_process_text(clipboardContext* cb, uint8* data, int size)
{
cb->data = (uint8*) xmalloc(size);
cb->data = (uint8*) malloc(size);
memcpy(cb->data, data, size);
cb->data_length = size;
crlf2lf(cb->data, &cb->data_length);
@ -943,7 +943,7 @@ static void xf_cliprdr_process_html(clipboardContext* cb, uint8* data, int size)
return;
}
cb->data = (uint8*) xmalloc(size - start + 1);
cb->data = (uint8*) malloc(size - start + 1);
memcpy(cb->data, data + start, end - start);
cb->data_length = end - start;
crlf2lf(cb->data, &cb->data_length);
@ -969,7 +969,7 @@ static void xf_cliprdr_process_cb_data_response_event(xfInfo* xfi, RDP_CB_DATA_R
{
if (cb->data)
{
xfree(cb->data);
free(cb->data);
cb->data = NULL;
}
switch (cb->data_format)
@ -1009,7 +1009,7 @@ static void xf_cliprdr_process_cb_data_response_event(xfInfo* xfi, RDP_CB_DATA_R
XSendEvent(xfi->display, cb->respond->xselection.requestor, 0, 0, cb->respond);
XFlush(xfi->display);
xfree(cb->respond);
free(cb->respond);
cb->respond = NULL;
}
@ -1149,7 +1149,7 @@ boolean xf_cliprdr_process_selection_request(xfInfo* xfi, XEvent* xevent)
*/
if (cb->data)
{
xfree(cb->data);
free(cb->data);
cb->data = NULL;
}
@ -1168,7 +1168,7 @@ boolean xf_cliprdr_process_selection_request(xfInfo* xfi, XEvent* xevent)
{
XSendEvent(xfi->display, xevent->xselectionrequest.requestor, 0, 0, respond);
XFlush(xfi->display);
xfree(respond);
free(respond);
}
return true;

18
client/X11/xf_gdi.c
View File

@ -227,7 +227,7 @@ Pixmap xf_brush_new(xfInfo* xfi, int width, int height, int bpp, uint8* data)
XFree(image);
if (cdata != data)
xfree(cdata);
free(cdata);
XFreeGC(xfi->display, gc);
}
@ -568,7 +568,7 @@ void xf_gdi_polyline(rdpContext* context, POLYLINE_ORDER* polyline)
XSetForeground(xfi->display, xfi->gc, color);
npoints = polyline->numPoints + 1;
points = xmalloc(sizeof(XPoint) * npoints);
points = malloc(sizeof(XPoint) * npoints);
points[0].x = polyline->xStart;
points[0].y = polyline->yStart;
@ -608,7 +608,7 @@ void xf_gdi_polyline(rdpContext* context, POLYLINE_ORDER* polyline)
}
XSetFunction(xfi->display, xfi->gc, GXcopy);
xfree(points);
free(points);
}
void xf_gdi_memblt(rdpContext* context, MEMBLT_ORDER* memblt)
@ -724,7 +724,7 @@ void xf_gdi_polygon_sc(rdpContext* context, POLYGON_SC_ORDER* polygon_sc)
brush_color = freerdp_color_convert_var(polygon_sc->brushColor, ((xfContext*)context)->settings->color_depth, xfi->bpp, xfi->clrconv);
npoints = polygon_sc->numPoints + 1;
points = xmalloc(sizeof(XPoint) * npoints);
points = malloc(sizeof(XPoint) * npoints);
points[0].x = polygon_sc->xStart;
points[0].y = polygon_sc->yStart;
@ -763,7 +763,7 @@ void xf_gdi_polygon_sc(rdpContext* context, POLYGON_SC_ORDER* polygon_sc)
}
XSetFunction(xfi->display, xfi->gc, GXcopy);
xfree(points);
free(points);
}
void xf_gdi_polygon_cb(rdpContext* context, POLYGON_CB_ORDER* polygon_cb)
@ -782,7 +782,7 @@ void xf_gdi_polygon_cb(rdpContext* context, POLYGON_CB_ORDER* polygon_cb)
backColor = freerdp_color_convert_rgb(polygon_cb->backColor, ((xfContext*)context)->settings->color_depth, xfi->bpp, xfi->clrconv);
npoints = polygon_cb->numPoints + 1;
points = xmalloc(sizeof(XPoint) * npoints);
points = malloc(sizeof(XPoint) * npoints);
points[0].x = polygon_cb->xStart;
points[0].y = polygon_cb->yStart;
@ -866,7 +866,7 @@ void xf_gdi_polygon_cb(rdpContext* context, POLYGON_CB_ORDER* polygon_cb)
}
XSetFunction(xfi->display, xfi->gc, GXcopy);
xfree(points);
free(points);
}
void xf_gdi_ellipse_sc(rdpContext* context, ELLIPSE_SC_ORDER* ellipse_sc)
@ -998,7 +998,7 @@ void xf_gdi_surface_bits(rdpContext* context, SURFACE_BITS_COMMAND* surface_bits
XSetFunction(xfi->display, xfi->gc, GXcopy);
XSetFillStyle(xfi->display, xfi->gc, FillSolid);
xfi->bmp_codec_nsc = (uint8*) xrealloc(xfi->bmp_codec_nsc,
xfi->bmp_codec_nsc = (uint8*) realloc(xfi->bmp_codec_nsc,
surface_bits_command->width * surface_bits_command->height * 4);
freerdp_image_flip(nsc_context->bmpdata, xfi->bmp_codec_nsc,
@ -1026,7 +1026,7 @@ void xf_gdi_surface_bits(rdpContext* context, SURFACE_BITS_COMMAND* surface_bits
/* Validate that the data received is large enough */
if( surface_bits_command->width * surface_bits_command->height * surface_bits_command->bpp / 8 <= surface_bits_command->bitmapDataLength )
{
xfi->bmp_codec_none = (uint8*) xrealloc(xfi->bmp_codec_none,
xfi->bmp_codec_none = (uint8*) realloc(xfi->bmp_codec_none,
surface_bits_command->width * surface_bits_command->height * 4);
freerdp_image_flip(surface_bits_command->bitmapData, xfi->bmp_codec_none,

16
client/X11/xf_graphics.c
View File

@ -61,12 +61,12 @@ void xf_Bitmap_New(rdpContext* context, rdpBitmap* bitmap)
XFree(image);
if (data != bitmap->data)
xfree(data);
free(data);
}
else
{
if (data != bitmap->data)
xfree(bitmap->data);
free(bitmap->data);
bitmap->data = data;
}
@ -127,9 +127,9 @@ void xf_Bitmap_Decompress(rdpContext* context, rdpBitmap* bitmap,
size = width * height * (bpp + 7) / 8;
if (bitmap->data == NULL)
bitmap->data = (uint8*) xmalloc(size);
bitmap->data = (uint8*) malloc(size);
else
bitmap->data = (uint8*) xrealloc(bitmap->data, size);
bitmap->data = (uint8*) realloc(bitmap->data, size);
switch (codec_id)
{
@ -222,7 +222,7 @@ void xf_Pointer_New(rdpContext* context, rdpPointer* pointer)
}
((xfPointer*) pointer)->cursor = XcursorImageLoadCursor(xfi->display, &ci);
xfree(ci.pixels);
free(ci.pixels);
}
void xf_Pointer_Free(rdpContext* context, rdpPointer* pointer)
@ -376,7 +376,7 @@ void xf_register_graphics(rdpGraphics* graphics)
bitmap->SetSurface = xf_Bitmap_SetSurface;
graphics_register_bitmap(graphics, bitmap);
xfree(bitmap);
free(bitmap);
pointer = xnew(rdpPointer);
pointer->size = sizeof(xfPointer);
@ -388,7 +388,7 @@ void xf_register_graphics(rdpGraphics* graphics)
pointer->SetDefault = xf_Pointer_SetDefault;
graphics_register_pointer(graphics, pointer);
xfree(pointer);
free(pointer);
glyph = xnew(rdpGlyph);
glyph->size = sizeof(xfGlyph);
@ -400,5 +400,5 @@ void xf_register_graphics(rdpGraphics* graphics)
glyph->EndDraw = xf_Glyph_EndDraw;
graphics_register_glyph(graphics, glyph);
xfree(glyph);
free(glyph);
}

4
client/X11/xf_tsmf.c
View File

@ -172,10 +172,10 @@ void xf_tsmf_uninit(xfInfo* xfi)
}
if (xv->xv_pixfmts)
{
xfree(xv->xv_pixfmts);
free(xv->xv_pixfmts);
xv->xv_pixfmts = NULL;
}
xfree(xv);
free(xv);
xfi->xv_context = NULL;
}
}

22
client/X11/xf_window.c
View File

@ -173,7 +173,7 @@ boolean xf_GetCurrentDesktop(xfInfo* xfi)
}
xfi->current_desktop = (int) *prop;
xfree(prop);
free(prop);
return true;
}
@ -198,7 +198,7 @@ boolean xf_GetWorkArea(xfInfo* xfi)
return false;
if ((xfi->current_desktop * 4 + 3) >= nitems) {
xfree(prop);
free(prop);
return false;
}
@ -208,7 +208,7 @@ boolean xf_GetWorkArea(xfInfo* xfi)
xfi->workArea.y = plong[xfi->current_desktop * 4 + 1];
xfi->workArea.width = plong[xfi->current_desktop * 4 + 2];
xfi->workArea.height = plong[xfi->current_desktop * 4 + 3];
xfree(prop);
free(prop);
return true;
}
@ -511,13 +511,13 @@ xfWindow* xf_CreateWindow(xfInfo* xfi, rdpWindow* wnd, int x, int y, int width,
if (class_hints != NULL)
{
char* class;
class = xmalloc(sizeof(rail_window_class));
class = malloc(sizeof(rail_window_class));
snprintf(class, sizeof(rail_window_class), "RAIL:%08X", id);
class_hints->res_name = "RAIL";
class_hints->res_class = class;
XSetClassHint(xfi->display, window->handle, class_hints);
XFree(class_hints);
xfree(class);
free(class);
}
/* Set the input mode hint for the WM */
@ -761,7 +761,7 @@ void xf_SetWindowIcon(xfInfo* xfi, xfWindow* window, rdpIcon* icon)
pixels = icon->entry->width * icon->entry->height;
propsize = 2 + pixels;
propdata = xmalloc(propsize * sizeof(long));
propdata = malloc(propsize * sizeof(long));
propdata[0] = icon->entry->width;
propdata[1] = icon->entry->height;
@ -790,7 +790,7 @@ void xf_SetWindowRects(xfInfo* xfi, xfWindow* window, RECTANGLE_16* rects, int n
if (nrects == 0)
return;
xrects = xmalloc(sizeof(XRectangle) * nrects);
xrects = malloc(sizeof(XRectangle) * nrects);
for (i = 0; i < nrects; i++)
{
@ -807,7 +807,7 @@ void xf_SetWindowRects(xfInfo* xfi, xfWindow* window, RECTANGLE_16* rects, int n
*/
#endif
xfree(xrects);
free(xrects);
}
void xf_SetWindowVisibilityRects(xfInfo* xfi, xfWindow* window, RECTANGLE_16* rects, int nrects)
@ -818,7 +818,7 @@ void xf_SetWindowVisibilityRects(xfInfo* xfi, xfWindow* window, RECTANGLE_16* re
if (nrects == 0)
return;
xrects = xmalloc(sizeof(XRectangle) * nrects);
xrects = malloc(sizeof(XRectangle) * nrects);
for (i = 0; i < nrects; i++)
{
@ -835,7 +835,7 @@ void xf_SetWindowVisibilityRects(xfInfo* xfi, xfWindow* window, RECTANGLE_16* re
*/
#endif
xfree(xrects);
free(xrects);
}
void xf_UpdateWindowArea(xfInfo* xfi, xfWindow* window, int x, int y, int width, int height)
@ -917,7 +917,7 @@ void xf_DestroyWindow(xfInfo* xfi, xfWindow* window)
XDestroyWindow(xfi->display, window->handle);
}
xfree(window);
free(window);
}
rdpWindow* xf_rdpWindowFromWindow(xfInfo* xfi, Window wnd)

30
client/X11/xfreerdp.c
View File

@ -314,17 +314,17 @@ void xf_create_window(xfInfo* xfi)
}
else if (xfi->instance->settings->port == 3389)
{
win_title = xmalloc(1 + sizeof("FreeRDP: ") + strlen(xfi->instance->settings->hostname));
win_title = malloc(1 + sizeof("FreeRDP: ") + strlen(xfi->instance->settings->hostname));
sprintf(win_title, "FreeRDP: %s", xfi->instance->settings->hostname);
}
else
{
win_title = xmalloc(1 + sizeof("FreeRDP: ") + strlen(xfi->instance->settings->hostname) + sizeof(":00000"));
win_title = malloc(1 + sizeof("FreeRDP: ") + strlen(xfi->instance->settings->hostname) + sizeof(":00000"));
sprintf(win_title, "FreeRDP: %s:%i", xfi->instance->settings->hostname, xfi->instance->settings->port);
}
xfi->window = xf_CreateDesktopWindow(xfi, win_title, width, height, xfi->decorations);
xfree(win_title);
free(win_title);
if (xfi->fullscreen)
xf_SetWindowFullscreen(xfi, xfi->window, xfi->fullscreen);
@ -758,7 +758,7 @@ boolean xf_post_connect(freerdp* instance)
xfi->image = XCreateImage(xfi->display, xfi->visual, xfi->depth, ZPixmap, 0,
(char*) xfi->primary_buffer, xfi->width, xfi->height, xfi->scanline_pad, 0);
xfi->bmp_codec_none = (uint8*) xmalloc(64 * 64 * 4);
xfi->bmp_codec_none = (uint8*) malloc(64 * 64 * 4);
if (xfi->sw_gdi)
{
@ -805,7 +805,7 @@ boolean xf_post_connect(freerdp* instance)
* @param username - unused
* @param password - on return: pointer to a character string that will be filled by the password entered by the user.
* Note that this character string will be allocated inside the function, and needs to be deallocated by the caller
* using xfree(), even in case this function fails.
* using free(), even in case this function fails.
* @param domain - unused
* @return true if a password was successfully entered. See freerdp_passphrase_read() for more details.
*/
@ -813,7 +813,7 @@ boolean xf_authenticate(freerdp* instance, char** username, char** password, cha
{
// FIXME: seems this callback may be called when 'username' is not known.
// But it doesn't do anything to fix it...
*password = xmalloc(password_size * sizeof(char));
*password = malloc(password_size * sizeof(char));
if (freerdp_passphrase_read("Password: ", *password, password_size, instance->settings->from_stdin) == NULL)
return false;
@ -891,9 +891,9 @@ int xf_process_client_args(rdpSettings* settings, const char* opt, const char* v
for (i = 0; layouts[i].code; i++)
{
printf("0x%08X\t%s\n", layouts[i].code, layouts[i].name);
xfree(layouts[i].name);
free(layouts[i].name);
}
xfree(layouts);
free(layouts);
layouts = freerdp_keyboard_get_layouts(RDP_KEYBOARD_LAYOUT_TYPE_VARIANT);
@ -901,9 +901,9 @@ int xf_process_client_args(rdpSettings* settings, const char* opt, const char* v
for (i = 0; layouts[i].code; i++)
{
printf("0x%08X\t%s\n", layouts[i].code, layouts[i].name);
xfree(layouts[i].name);
free(layouts[i].name);
}
xfree(layouts);
free(layouts);
layouts = freerdp_keyboard_get_layouts(RDP_KEYBOARD_LAYOUT_TYPE_IME);
@ -911,9 +911,9 @@ int xf_process_client_args(rdpSettings* settings, const char* opt, const char* v
for (i = 0; layouts[i].code; i++)
{
printf("0x%08X\t%s\n", layouts[i].code, layouts[i].name);
xfree(layouts[i].name);
free(layouts[i].name);
}
xfree(layouts);
free(layouts);
exit(0);
}
@ -1081,11 +1081,11 @@ void xf_free(xfInfo* xfi)
{
xf_window_free(xfi);
xfree(xfi->bmp_codec_none);
free(xfi->bmp_codec_none);
XCloseDisplay(xfi->display);
xfree(xfi);
free(xfi);
}
/** Main loop for the rdp connection.
@ -1261,7 +1261,7 @@ void* thread_func(void* param)
g_disconnect_reason = xfreerdp_run(data->instance);
xfree(data);
free(data);
g_thread_count--;

4
cunit/test_cliprdr.c
View File

@ -143,7 +143,7 @@ void test_cliprdr(void)
event = freerdp_event_new(RDP_EVENT_CLASS_CLIPRDR, RDP_EVENT_TYPE_CB_FORMAT_LIST, event_process_callback, NULL);
format_list_event = (RDP_CB_FORMAT_LIST_EVENT*) event;
format_list_event->num_formats = 2;
format_list_event->formats = (uint32*) xmalloc(sizeof(uint32) * 2);
format_list_event->formats = (uint32*) malloc(sizeof(uint32) * 2);
format_list_event->formats[0] = CB_FORMAT_TEXT;
format_list_event->formats[1] = CB_FORMAT_HTML;
event_processed = 0;
@ -199,7 +199,7 @@ void test_cliprdr(void)
/* UI sends data response event to cliprdr */
event = freerdp_event_new(RDP_EVENT_CLASS_CLIPRDR, RDP_EVENT_TYPE_CB_DATA_RESPONSE, event_process_callback, NULL);
data_response_event = (RDP_CB_DATA_RESPONSE_EVENT*)event;
data_response_event->data = (uint8*)xmalloc(6);
data_response_event->data = (uint8*)malloc(6);
strcpy((char*)data_response_event->data, "hello");
data_response_event->size = 6;
event_processed = 0;

2
cunit/test_license.c
View File

@ -483,7 +483,7 @@ void test_license_decrypt_platform_challenge(void)
sizeof(test_licensing_encryption_key));
license->encrypted_platform_challenge->data =
(uint8*) xmalloc(sizeof(test_encrypted_platform_challenge));
(uint8*) malloc(sizeof(test_encrypted_platform_challenge));
license->encrypted_platform_challenge->length =
sizeof(test_encrypted_platform_challenge);

4
cunit/test_rfx.c
View File

@ -199,7 +199,7 @@ void test_bitstream(void)
(void) b;
//printf("%u ", b);
}
xfree(bs);
free(bs);
//printf("\n");
}
@ -221,7 +221,7 @@ void test_bitstream_enc(void)
{
printf("%X ", buffer[i]);
}*/
xfree(bs);
free(bs);
//printf("\n");
}

4
include/freerdp/utils/memory.h
View File

@ -25,10 +25,8 @@
#include <wchar.h>
#include <freerdp/api.h>
FREERDP_API void* xmalloc(size_t size);
FREERDP_API void* xzalloc(size_t size);
FREERDP_API void* xrealloc(void* ptr, size_t size);
FREERDP_API void xfree(void* ptr);
FREERDP_API char* xstrdup(const char* str);
FREERDP_API char* xstrtoup(const char* str);
FREERDP_API wchar_t* xwcsdup(const wchar_t* wstr);

6
libfreerdp/cache/bitmap.c vendored
View File

@ -327,13 +327,13 @@ void bitmap_cache_free(rdpBitmapCache* bitmap_cache)
}
}
xfree(bitmap_cache->cells[i].entries);
free(bitmap_cache->cells[i].entries);
}
if (bitmap_cache->bitmap != NULL)
Bitmap_Free(bitmap_cache->context, bitmap_cache->bitmap);
xfree(bitmap_cache->cells);
xfree(bitmap_cache);
free(bitmap_cache->cells);
free(bitmap_cache);
}
}

14
libfreerdp/cache/brush.c vendored
View File

@ -129,7 +129,7 @@ void brush_cache_put(rdpBrushCache* brush, uint32 index, void* entry, uint32 bpp
prevEntry = brush->monoEntries[index].entry;
if (prevEntry != NULL)
xfree(prevEntry);
free(prevEntry);
brush->monoEntries[index].bpp = bpp;
brush->monoEntries[index].entry = entry;
@ -145,7 +145,7 @@ void brush_cache_put(rdpBrushCache* brush, uint32 index, void* entry, uint32 bpp
prevEntry = brush->entries[index].entry;
if (prevEntry != NULL)
xfree(prevEntry);
free(prevEntry);
brush->entries[index].bpp = bpp;
brush->entries[index].entry = entry;
@ -197,10 +197,10 @@ void brush_cache_free(rdpBrushCache* brush)
for (i = 0; i < (int) brush->maxEntries; i++)
{
if (brush->entries[i].entry != NULL)
xfree(brush->entries[i].entry);
free(brush->entries[i].entry);
}
xfree(brush->entries);
free(brush->entries);
}
if (brush->monoEntries != NULL)
@ -208,12 +208,12 @@ void brush_cache_free(rdpBrushCache* brush)
for (i = 0; i < (int) brush->maxMonoEntries; i++)
{
if (brush->monoEntries[i].entry != NULL)
xfree(brush->monoEntries[i].entry);
free(brush->monoEntries[i].entry);
}
xfree(brush->monoEntries);
free(brush->monoEntries);
}
xfree(brush);
free(brush);
}
}

2
libfreerdp/cache/cache.c vendored
View File

@ -58,6 +58,6 @@ void cache_free(rdpCache* cache)
offscreen_cache_free(cache->offscreen);
palette_cache_free(cache->palette);
nine_grid_cache_free(cache->nine_grid);
xfree(cache);
free(cache);
}
}

26
libfreerdp/cache/glyph.c vendored
View File

@ -143,7 +143,7 @@ void update_process_glyph_fragments(rdpContext* context, uint8* data, uint32 len
id = data[index + 1];
size = data[index + 2];
fragments = (uint8*) xmalloc(size);
fragments = (uint8*) malloc(size);
memcpy(fragments, data, size);
glyph_cache_fragment_put(glyph_cache, id, size, fragments);
@ -286,7 +286,7 @@ void update_gdi_fast_glyph(rdpContext* context, FAST_GLYPH_ORDER* fast_glyph)
glyph->cb = glyph_data->cb;
Glyph_New(context, glyph);
glyph_cache_put(cache->glyph, fast_glyph->cacheId, fast_glyph->data[0], glyph);
xfree(fast_glyph->glyph_data);
free(fast_glyph->glyph_data);
fast_glyph->glyph_data = NULL;
}
@ -326,7 +326,7 @@ void update_gdi_cache_glyph(rdpContext* context, CACHE_GLYPH_ORDER* cache_glyph)
glyph_cache_put(cache->glyph, cache_glyph->cacheId, glyph_data->cacheIndex, glyph);
cache_glyph->glyphData[i] = NULL;
xfree(glyph_data);
free(glyph_data);
}
}
@ -354,7 +354,7 @@ void update_gdi_cache_glyph_v2(rdpContext* context, CACHE_GLYPH_V2_ORDER* cache_
glyph_cache_put(cache->glyph, cache_glyph_v2->cacheId, glyph_data->cacheIndex, glyph);
cache_glyph_v2->glyphData[i] = NULL;
xfree(glyph_data);
free(glyph_data);
}
}
@ -405,8 +405,8 @@ void glyph_cache_put(rdpGlyphCache* glyph_cache, uint32 id, uint32 index, rdpGly
if (prevGlyph != NULL)
{
Glyph_Free(glyph_cache->context, prevGlyph);
xfree(prevGlyph->aj);
xfree(prevGlyph);
free(prevGlyph->aj);
free(prevGlyph);
}
glyph_cache->glyphCache[id].entries[index] = glyph;
@ -438,7 +438,7 @@ void glyph_cache_fragment_put(rdpGlyphCache* glyph_cache, uint32 index, uint32 s
if (prevFragment != NULL)
{
xfree(prevFragment);
free(prevFragment);
}
}
@ -500,20 +500,20 @@ void glyph_cache_free(rdpGlyphCache* glyph_cache)
if (glyph != NULL)
{
Glyph_Free(glyph_cache->context, glyph);
xfree(glyph->aj);
xfree(glyph);
free(glyph->aj);
free(glyph);
}
}
xfree(glyph_cache->glyphCache[i].entries);
free(glyph_cache->glyphCache[i].entries);
}
for (i = 0; i < 255; i++)
{
fragment = glyph_cache->fragCache.entries[i].fragment;
xfree(fragment);
free(fragment);
}
xfree(glyph_cache->fragCache.entries);
xfree(glyph_cache);
free(glyph_cache->fragCache.entries);
free(glyph_cache);
}
}

8
libfreerdp/cache/nine_grid.c vendored
View File

@ -87,7 +87,7 @@ void nine_grid_cache_put(rdpNineGridCache* nine_grid, uint32 index, void* entry)
prevEntry = nine_grid->entries[index].entry;
if (prevEntry != NULL)
xfree(prevEntry);
free(prevEntry);
nine_grid->entries[index].entry = entry;
}
@ -125,12 +125,12 @@ void nine_grid_cache_free(rdpNineGridCache* nine_grid)
for (i = 0; i < (int) nine_grid->maxEntries; i++)
{
if (nine_grid->entries[i].entry != NULL)
xfree(nine_grid->entries[i].entry);
free(nine_grid->entries[i].entry);
}
xfree(nine_grid->entries);
free(nine_grid->entries);
}
xfree(nine_grid);
free(nine_grid);
}
}

4
libfreerdp/cache/offscreen.c vendored
View File

@ -169,7 +169,7 @@ void offscreen_cache_free(rdpOffscreenCache* offscreen_cache)
Bitmap_Free(offscreen_cache->update->context, bitmap);
}
xfree(offscreen_cache->entries);
xfree(offscreen_cache);
free(offscreen_cache->entries);
free(offscreen_cache);
}
}

4
libfreerdp/cache/palette.c vendored
View File

@ -91,8 +91,8 @@ void palette_cache_free(rdpPaletteCache* palette_cache)
{
if (palette_cache != NULL)
{
xfree(palette_cache->entries);
xfree(palette_cache);
free(palette_cache->entries);
free(palette_cache);
}
}

4
libfreerdp/cache/pointer.c vendored
View File

@ -187,7 +187,7 @@ void pointer_cache_free(rdpPointerCache* pointer_cache)
Pointer_Free(pointer_cache->update->context, pointer);
}
xfree(pointer_cache->entries);
xfree(pointer_cache);
free(pointer_cache->entries);
free(pointer_cache);
}
}

4
libfreerdp/channels/libchannels.c
View File

@ -663,12 +663,12 @@ void freerdp_channels_free(rdpChannels* channels)
prev->next = list->next;
else
g_channels_list = list->next;
xfree(list);
free(list);
}
ReleaseMutex(g_mutex_list);
xfree(channels);
free(channels);
}
int freerdp_channels_client_load(rdpChannels* channels, rdpSettings* settings, void* entry, void* data)

20
libfreerdp/channels/wtsvc.c
View File

@ -47,8 +47,8 @@ typedef struct wts_data_item
static void wts_data_item_free(wts_data_item* item)
{
xfree(item->buffer);
xfree(item);
free(item->buffer);
free(item);
}
static rdpPeerChannel* wts_get_dvc_channel_by_id(WTSVirtualChannelManager* vcm, uint32 ChannelId)
@ -73,7 +73,7 @@ static void wts_queue_receive_data(rdpPeerChannel* channel, const uint8* buffer,
item = xnew(wts_data_item);
item->length = length;
item->buffer = xmalloc(length);
item->buffer = malloc(length);
memcpy(item->buffer, buffer, length);
WaitForSingleObject(channel->mutex, INFINITE);
@ -429,7 +429,7 @@ void WTSDestroyVirtualChannelManager(WTSVirtualChannelManager* vcm)
list_free(vcm->send_queue);
CloseHandle(vcm->mutex);
xfree(vcm);
free(vcm);
}
}
@ -585,7 +585,7 @@ boolean WTSVirtualChannelQuery(
{
case WTSVirtualFileHandle:
wait_obj_get_fds(channel->receive_event, fds, &fds_count);
*ppBuffer = xmalloc(sizeof(void*));
*ppBuffer = malloc(sizeof(void*));
memcpy(*ppBuffer, &fds[0], sizeof(void*));
*pBytesReturned = sizeof(void*);
result = true;
@ -615,7 +615,7 @@ boolean WTSVirtualChannelQuery(
break;
}
}
*ppBuffer = xmalloc(sizeof(boolean));
*ppBuffer = malloc(sizeof(boolean));
memcpy(*ppBuffer, &bval, sizeof(boolean));
*pBytesReturned = sizeof(boolean);
break;
@ -629,7 +629,7 @@ boolean WTSVirtualChannelQuery(
void WTSFreeMemory(
/* __in */ void* pMemory)
{
xfree(pMemory);
free(pMemory);
}
boolean WTSVirtualChannelRead(
@ -691,7 +691,7 @@ boolean WTSVirtualChannelWrite(
if (channel->channel_type == RDP_PEER_CHANNEL_TYPE_SVC)
{
item = xnew(wts_data_item);
item->buffer = xmalloc(Length);
item->buffer = malloc(Length);
item->length = Length;
memcpy(item->buffer, Buffer, Length);
@ -710,7 +710,7 @@ boolean WTSVirtualChannelWrite(
while (Length > 0)
{
item = xnew(wts_data_item);
item->buffer = xmalloc(channel->client->settings->vc_chunk_size);
item->buffer = malloc(channel->client->settings->vc_chunk_size);
stream_attach(s, item->buffer, channel->client->settings->vc_chunk_size);
stream_seek_uint8(s);
@ -800,7 +800,7 @@ boolean WTSVirtualChannelClose(
if (channel->mutex)
CloseHandle(channel->mutex);
xfree(channel);
free(channel);
}
return true;

16
libfreerdp/codec/bitmap.c
View File

@ -445,10 +445,10 @@ boolean bitmap_decompress(uint8* srcData, uint8* dstData, int width, int height,
if (srcBpp == 16 && dstBpp == 16)
{
TmpBfr = (uint8*) xmalloc(width * height * 2);
TmpBfr = (uint8*) malloc(width * height * 2);
RleDecompress16to16(srcData, size, TmpBfr, width * 2, width, height);
freerdp_bitmap_flip(TmpBfr, dstData, width * 2, height);
xfree(TmpBfr);
free(TmpBfr);
}
else if (srcBpp == 32 && dstBpp == 32)
{
@ -457,24 +457,24 @@ boolean bitmap_decompress(uint8* srcData, uint8* dstData, int width, int height,
}
else if (srcBpp == 15 && dstBpp == 15)
{
TmpBfr = (uint8*) xmalloc(width * height * 2);
TmpBfr = (uint8*) malloc(width * height * 2);
RleDecompress16to16(srcData, size, TmpBfr, width * 2, width, height);
freerdp_bitmap_flip(TmpBfr, dstData, width * 2, height);
xfree(TmpBfr);
free(TmpBfr);
}
else if (srcBpp == 8 && dstBpp == 8)
{
TmpBfr = (uint8*) xmalloc(width * height);
TmpBfr = (uint8*) malloc(width * height);
RleDecompress8to8(srcData, size, TmpBfr, width, width, height);
freerdp_bitmap_flip(TmpBfr, dstData, width, height);
xfree(TmpBfr);
free(TmpBfr);
}
else if (srcBpp == 24 && dstBpp == 24)
{
TmpBfr = (uint8*) xmalloc(width * height * 3);
TmpBfr = (uint8*) malloc(width * height * 3);
RleDecompress24to24(srcData, size, TmpBfr, width * 3, width, height);
freerdp_bitmap_flip(TmpBfr, dstData, width * 3, height);
xfree(TmpBfr);
free(TmpBfr);
}
else
{

48
libfreerdp/codec/color.c
View File

@ -369,7 +369,7 @@ uint8* freerdp_image_convert_8bpp(uint8* srcData, uint8* dstData, int width, int
if (dstBpp == 8)
{
if (dstData == NULL)
dstData = (uint8*) xmalloc(width * height);
dstData = (uint8*) malloc(width * height);
memcpy(dstData, srcData, width * height);
return dstData;
@ -377,7 +377,7 @@ uint8* freerdp_image_convert_8bpp(uint8* srcData, uint8* dstData, int width, int
else if (dstBpp == 15 || (dstBpp == 16 && clrconv->rgb555))
{
if (dstData == NULL)
dstData = (uint8*) xmalloc(width * height * 2);
dstData = (uint8*) malloc(width * height * 2);
dst16 = (uint16 *) dstData;
for (i = width * height; i > 0; i--)
@ -396,7 +396,7 @@ uint8* freerdp_image_convert_8bpp(uint8* srcData, uint8* dstData, int width, int
else if (dstBpp == 16)
{
if (dstData == NULL)
dstData = (uint8*) xmalloc(width * height * 2);
dstData = (uint8*) malloc(width * height * 2);
dst16 = (uint16 *) dstData;
for (i = width * height; i > 0; i--)
@ -415,7 +415,7 @@ uint8* freerdp_image_convert_8bpp(uint8* srcData, uint8* dstData, int width, int
else if (dstBpp == 32)
{
if (dstData == NULL)
dstData = (uint8*) xmalloc(width * height * 4);
dstData = (uint8*) malloc(width * height * 4);
src8 = (uint8*) srcData;
dst32 = (uint32*) dstData;
@ -450,7 +450,7 @@ uint8* freerdp_image_convert_15bpp(uint8* srcData, uint8* dstData, int width, in
if (dstBpp == 15 || (dstBpp == 16 && clrconv->rgb555))
{
if (dstData == NULL)
dstData = (uint8*) xmalloc(width * height * 2);
dstData = (uint8*) malloc(width * height * 2);
memcpy(dstData, srcData, width * height * 2);
@ -459,7 +459,7 @@ uint8* freerdp_image_convert_15bpp(uint8* srcData, uint8* dstData, int width, in
else if (dstBpp == 32)
{
if (dstData == NULL)
dstData = (uint8*) xmalloc(width * height * 4);
dstData = (uint8*) malloc(width * height * 4);
src16 = (uint16 *) srcData;
dst32 = (uint32 *) dstData;
@ -477,7 +477,7 @@ uint8* freerdp_image_convert_15bpp(uint8* srcData, uint8* dstData, int width, in
else if (dstBpp == 16)
{
if (dstData == NULL)
dstData = (uint8*) xmalloc(width * height * 2);
dstData = (uint8*) malloc(width * height * 2);
src16 = (uint16 *) srcData;
dst16 = (uint16 *) dstData;
@ -505,7 +505,7 @@ uint8* freerdp_image_convert_16bpp(uint8* srcData, uint8* dstData, int width, in
if (dstBpp == 16)
{
if (dstData == NULL)
dstData = (uint8*) xmalloc(width * height * 2);
dstData = (uint8*) malloc(width * height * 2);
if (clrconv->rgb555)
{
@ -538,7 +538,7 @@ uint8* freerdp_image_convert_16bpp(uint8* srcData, uint8* dstData, int width, in
uint8 red, green, blue;
if (dstData == NULL)
dstData = (uint8*) xmalloc(width * height * 3);
dstData = (uint8*) malloc(width * height * 3);
dst8 = (uint8*) dstData;
src16 = (uint16*) srcData;
@ -572,7 +572,7 @@ uint8* freerdp_image_convert_16bpp(uint8* srcData, uint8* dstData, int width, in
uint8 red, green, blue;
if (dstData == NULL)
dstData = (uint8*) xmalloc(width * height * 4);
dstData = (uint8*) malloc(width * height * 4);
src16 = (uint16*) srcData;
dst32 = (uint32*) dstData;
@ -600,7 +600,7 @@ uint8* freerdp_image_convert_24bpp(uint8* srcData, uint8* dstData, int width, in
{
uint8 *dstp;
if (dstData == NULL)
dstData = (uint8*) xmalloc(width * height * 4);
dstData = (uint8*) malloc(width * height * 4);
dstp = dstData;
for (i = width * height; i > 0; i--)
@ -626,7 +626,7 @@ uint8* freerdp_image_convert_32bpp(uint8* srcData, uint8* dstData, int width, in
uint8 red, green, blue;
if (dstData == NULL)
dstData = (uint8*) xmalloc(width * height * 2);
dstData = (uint8*) malloc(width * height * 2);
dst16 = (uint16*) dstData;
src32 = (uint32*) srcData;
@ -647,7 +647,7 @@ uint8* freerdp_image_convert_32bpp(uint8* srcData, uint8* dstData, int width, in
uint8 red, green, blue;
if (dstData == NULL)
dstData = (uint8*) xmalloc(width * height * 3);
dstData = (uint8*) malloc(width * height * 3);
dstp = dstData;
for (index = 0; index < width * height; index++)
@ -681,7 +681,7 @@ uint8* freerdp_image_convert_32bpp(uint8* srcData, uint8* dstData, int width, in
uint8 *dstp;
if (dstData == NULL)
dstData = (uint8*) xmalloc(width * height * 4);
dstData = (uint8*) malloc(width * height * 4);
memcpy(dstData, srcData, width * height * 4);
@ -699,7 +699,7 @@ uint8* freerdp_image_convert_32bpp(uint8* srcData, uint8* dstData, int width, in
else
{
if (dstData == NULL)
dstData = (uint8*) xmalloc(width * height * 4);
dstData = (uint8*) malloc(width * height * 4);
memcpy(dstData, srcData, width * height * 4);
}
@ -740,12 +740,12 @@ void freerdp_bitmap_flip(uint8 * src, uint8 * dst, int scanLineSz, int height)
if (src == dst)
{
/* Allocate a scanline buffer.
* (FIXME: xmalloc / xfree below should be replaced by "get/put
* (FIXME: malloc / xfree below should be replaced by "get/put
* scanline buffer from a pool/Q of fixed buffers" to reuse
* fixed size buffers (of max scanline size (or adaptative?) )
* -- would be much faster).
*/
uint8 * tmpBfr = xmalloc(scanLineSz);
uint8 * tmpBfr = malloc(scanLineSz);
int half = height / 2;
/* Flip buffer in place by line permutations through the temp
* scan line buffer.
@ -765,7 +765,7 @@ void freerdp_bitmap_flip(uint8 * src, uint8 * dst, int scanLineSz, int height)
bottomLine -= scanLineSz;
height--;
}
xfree(tmpBfr);
free(tmpBfr);
}
/* Flip from source buffer to destination buffer. */
else
@ -788,7 +788,7 @@ uint8* freerdp_image_flip(uint8* srcData, uint8* dstData, int width, int height,
scanline = width * ((bpp + 7) / 8);
if (dstData == NULL)
dstData = (uint8*) xmalloc(width * height * ((bpp + 7) / 8));
dstData = (uint8*) malloc(width * height * ((bpp + 7) / 8));
freerdp_bitmap_flip(srcData, dstData, scanline, height);
return dstData;
@ -862,7 +862,7 @@ uint8* freerdp_glyph_convert(int width, int height, uint8* data)
*/
scanline = (width + 7) / 8;
dstData = (uint8*) xmalloc(width * height);
dstData = (uint8*) malloc(width * height);
memset(dstData, 0, width * height);
dstp = dstData;
@ -946,7 +946,7 @@ uint8* freerdp_mono_image_convert(uint8* srcData, int width, int height, int src
}
}
dstData = (uint8*) xmalloc(width * height * 2);
dstData = (uint8*) malloc(width * height * 2);
dst16 = (uint16*) dstData;
for (index = height; index > 0; index--)
@ -971,7 +971,7 @@ uint8* freerdp_mono_image_convert(uint8* srcData, int width, int height, int src
}
else if (dstBpp == 32)
{
dstData = (uint8*) xmalloc(width * height * 4);
dstData = (uint8*) malloc(width * height * 4);
dst32 = (uint32*) dstData;
for (index = height; index > 0; index--)
@ -1070,8 +1070,8 @@ void freerdp_clrconv_free(HCLRCONV clrconv)
if (clrconv != NULL)
{
if (clrconv->palette != NULL)
xfree(clrconv->palette);
free(clrconv->palette);
xfree(clrconv);
free(clrconv);
}
}

10
libfreerdp/codec/mppc_dec.c
View File

@ -1414,7 +1414,7 @@ struct rdp_mppc_dec* mppc_dec_new(void)
{
struct rdp_mppc_dec* ptr;
ptr = (struct rdp_mppc_dec*) xmalloc(sizeof(struct rdp_mppc_dec));
ptr = (struct rdp_mppc_dec*) malloc(sizeof(struct rdp_mppc_dec));
if (!ptr)
{
printf("mppc_new(): system out of memory\n");
@ -1426,7 +1426,7 @@ struct rdp_mppc_dec* mppc_dec_new(void)
if (!ptr->history_buf)
{
printf("mppc_new(): system out of memory\n");
xfree(ptr);
free(ptr);
return NULL;
}
@ -1450,14 +1450,14 @@ void mppc_dec_free(struct rdp_mppc_dec* dec)
if (dec->history_buf)
{
xfree(dec->history_buf);
free(dec->history_buf);
dec->history_buf = NULL;
dec->history_ptr = NULL;
}
if (dec->offset_cache)
{
xfree(dec->offset_cache);
free(dec->offset_cache);
dec->offset_cache = NULL;
}
xfree(dec);
free(dec);
}

22
libfreerdp/codec/mppc_enc.c
View File

@ -444,30 +444,30 @@ struct rdp_mppc_enc* mppc_enc_new(int protocol_type)
enc->buf_len = RDP_50_HIST_BUF_LEN;
break;
default:
xfree(enc);
free(enc);
return NULL;
}
enc->first_pkt = 1;
enc->historyBuffer = (char*) xzalloc(enc->buf_len);
if (enc->historyBuffer == NULL)
{
xfree(enc);
free(enc);
return NULL;
}
enc->outputBufferPlus = (char*) xzalloc(enc->buf_len + 64);
if (enc->outputBufferPlus == NULL)
{
xfree(enc->historyBuffer);
xfree(enc);
free(enc->historyBuffer);
free(enc);
return NULL;
}
enc->outputBuffer = enc->outputBufferPlus + 64;
enc->hash_table = (uint16*) xzalloc(enc->buf_len * 2);
if (enc->hash_table == NULL)
{
xfree(enc->historyBuffer);
xfree(enc->outputBufferPlus);
xfree(enc);
free(enc->historyBuffer);
free(enc->outputBufferPlus);
free(enc);
return NULL;
}
return enc;
@ -483,10 +483,10 @@ void mppc_enc_free(struct rdp_mppc_enc* enc)
{
if (enc == NULL)
return;
xfree(enc->historyBuffer);
xfree(enc->outputBufferPlus);
xfree(enc->hash_table);
xfree(enc);
free(enc->historyBuffer);
free(enc->outputBufferPlus);
free(enc->hash_table);
free(enc);
}
/**

12
libfreerdp/codec/nsc.c
View File

@ -199,7 +199,7 @@ static void nsc_context_initialize(NSC_CONTEXT* context, STREAM* s)
}
else if (length > context->bmpdata_length)
{
context->bmpdata = xrealloc(context->bmpdata, length + 16);
context->bmpdata = realloc(context->bmpdata, length + 16);
context->bmpdata_length = length;
}
@ -210,7 +210,7 @@ static void nsc_context_initialize(NSC_CONTEXT* context, STREAM* s)
if (length > context->priv->plane_buf_length)
{
for (i = 0; i < 4; i++)
context->priv->plane_buf[i] = (uint8*) xrealloc(context->priv->plane_buf[i], length);
context->priv->plane_buf[i] = (uint8*) realloc(context->priv->plane_buf[i], length);
context->priv->plane_buf_length = length;
}
@ -244,10 +244,10 @@ void nsc_context_free(NSC_CONTEXT* context)
for (i = 0; i < 4; i++)
{
if (context->priv->plane_buf[i])
xfree(context->priv->plane_buf[i]);
free(context->priv->plane_buf[i]);
}
if (context->bmpdata)
xfree(context->bmpdata);
free(context->bmpdata);
nsc_profiler_print(context);
PROFILER_FREE(context->priv->prof_nsc_rle_decompress_data);
@ -255,8 +255,8 @@ void nsc_context_free(NSC_CONTEXT* context)
PROFILER_FREE(context->priv->prof_nsc_rle_compress_data);
PROFILER_FREE(context->priv->prof_nsc_encode);
xfree(context->priv);
xfree(context);
free(context->priv);
free(context);
}
NSC_CONTEXT* nsc_context_new(void)

2
libfreerdp/codec/nsc_encode.c
View File

@ -48,7 +48,7 @@ static void nsc_context_initialize_encode(NSC_CONTEXT* context)
if (length > context->priv->plane_buf_length)
{
for (i = 0; i < 5; i++)
context->priv->plane_buf[i] = (uint8*) xrealloc(context->priv->plane_buf[i], length);
context->priv->plane_buf[i] = (uint8*) realloc(context->priv->plane_buf[i], length);
context->priv->plane_buf_length = length;
}

20
libfreerdp/codec/rfx.c
View File

@ -177,15 +177,15 @@ void rfx_context_set_cpu_opt(RFX_CONTEXT* context, uint32 cpu_opt)
void rfx_context_free(RFX_CONTEXT* context)
{
xfree(context->quants);
free(context->quants);
rfx_pool_free(context->priv->pool);
rfx_profiler_print(context);
rfx_profiler_free(context);
xfree(context->priv);
xfree(context);
free(context->priv);
free(context);
}
void rfx_context_set_pixel_format(RFX_CONTEXT* context, RDP_PIXEL_FORMAT pixel_format)
@ -362,9 +362,9 @@ static void rfx_process_message_region(RFX_CONTEXT* context, RFX_MESSAGE* messag
}
if (message->rects != NULL)
message->rects = (RFX_RECT*) xrealloc(message->rects, message->num_rects * sizeof(RFX_RECT));
message->rects = (RFX_RECT*) realloc(message->rects, message->num_rects * sizeof(RFX_RECT));
else
message->rects = (RFX_RECT*) xmalloc(message->num_rects * sizeof(RFX_RECT));
message->rects = (RFX_RECT*) malloc(message->num_rects * sizeof(RFX_RECT));
/* rects */
for (i = 0; i < message->num_rects; i++)
@ -453,9 +453,9 @@ static void rfx_process_message_tileset(RFX_CONTEXT* context, RFX_MESSAGE* messa
stream_read_uint32(s, tilesDataSize); /* tilesDataSize (4 bytes) */
if (context->quants != NULL)
context->quants = (uint32*) xrealloc((void*) context->quants, context->num_quants * 10 * sizeof(uint32));
context->quants = (uint32*) realloc((void*) context->quants, context->num_quants * 10 * sizeof(uint32));
else
context->quants = (uint32*) xmalloc(context->num_quants * 10 * sizeof(uint32));
context->quants = (uint32*) malloc(context->num_quants * 10 * sizeof(uint32));
quants = context->quants;
/* quantVals */
@ -617,15 +617,15 @@ void rfx_message_free(RFX_CONTEXT* context, RFX_MESSAGE* message)
{
if (message != NULL)
{
xfree(message->rects);
free(message->rects);
if (message->tiles != NULL)
{
rfx_pool_put_tiles(context->priv->pool, message->tiles, message->num_tiles);
xfree(message->tiles);
free(message->tiles);
}
xfree(message);
free(message);
}
}

14
libfreerdp/codec/rfx_pool.c
View File

@ -53,14 +53,14 @@ void rfx_pool_free(RFX_POOL* pool)
if (tile != NULL)
{
if (tile->data != NULL)
xfree(tile->data);
free(tile->data);
xfree(tile);
free(tile);
}
}
xfree(pool->tiles);
xfree(pool);
free(pool->tiles);
free(pool);
}
void rfx_pool_put_tile(RFX_POOL* pool, RFX_TILE* tile)
@ -68,7 +68,7 @@ void rfx_pool_put_tile(RFX_POOL* pool, RFX_TILE* tile)
if (pool->count >= pool->size)
{
pool->size *= 2;
pool->tiles = (RFX_TILE**) xrealloc((void*) pool->tiles, sizeof(RFX_TILE*) * pool->size);
pool->tiles = (RFX_TILE**) realloc((void*) pool->tiles, sizeof(RFX_TILE*) * pool->size);
}
pool->tiles[(pool->count)++] = tile;
@ -81,7 +81,7 @@ RFX_TILE* rfx_pool_get_tile(RFX_POOL* pool)
if (pool->count < 1)
{
tile = xnew(RFX_TILE);
tile->data = (uint8*) xmalloc(4096 * 4); /* 64x64 * 4 */
tile->data = (uint8*) malloc(4096 * 4); /* 64x64 * 4 */
}
else
{
@ -106,7 +106,7 @@ RFX_TILE** rfx_pool_get_tiles(RFX_POOL* pool, int count)
int i;
RFX_TILE** tiles;
tiles = (RFX_TILE**) xmalloc(sizeof(RFX_TILE*) * count);
tiles = (RFX_TILE**) malloc(sizeof(RFX_TILE*) * count);
for (i = 0; i < count; i++)
{

4
libfreerdp/codec/rfx_rlgr.c
View File

@ -234,7 +234,7 @@ int rfx_rlgr_decode(RLGR_MODE mode, const uint8* data, int data_size, sint16* bu
}
}
xfree(bs);
free(bs);
return (dst - buffer);
}
@ -431,7 +431,7 @@ int rfx_rlgr_encode(RLGR_MODE mode, const sint16* data, int data_size, uint8* bu
}
processed_size = rfx_bitstream_get_processed_bytes(bs);
xfree(bs);
free(bs);
return processed_size;
}

26
libfreerdp/core/certificate.c
View File

@ -218,7 +218,7 @@ rdpX509CertChain* certificate_new_x509_certificate_chain(uint32 count)
{
rdpX509CertChain* x509_cert_chain;
x509_cert_chain = (rdpX509CertChain*) xmalloc(sizeof(rdpX509CertChain));
x509_cert_chain = (rdpX509CertChain*) malloc(sizeof(rdpX509CertChain));
x509_cert_chain->count = count;
x509_cert_chain->array = (rdpCertBlob*) xzalloc(sizeof(rdpCertBlob) * count);
@ -240,11 +240,11 @@ void certificate_free_x509_certificate_chain(rdpX509CertChain* x509_cert_chain)
for (i = 0; i < (int) x509_cert_chain->count; i++)
{
if (x509_cert_chain->array[i].data != NULL)
xfree(x509_cert_chain->array[i].data);
free(x509_cert_chain->array[i].data);
}
xfree(x509_cert_chain->array);
xfree(x509_cert_chain);
free(x509_cert_chain->array);
free(x509_cert_chain);
}
}
@ -428,7 +428,7 @@ boolean certificate_read_server_x509_certificate_chain(rdpCertificate* certifica
DEBUG_CERTIFICATE("\nX.509 Certificate #%d, length:%d", i + 1, certLength);
certificate->x509_cert_chain->array[i].data = (uint8*) xmalloc(certLength);
certificate->x509_cert_chain->array[i].data = (uint8*) malloc(certLength);
stream_read(s, certificate->x509_cert_chain->array[i].data, certLength);
certificate->x509_cert_chain->array[i].length = certLength;
@ -489,7 +489,7 @@ boolean certificate_read_server_certificate(rdpCertificate* certificate, uint8*
break;
}
xfree(s);
free(s);
return true;
}
@ -509,7 +509,7 @@ rdpKey* key_new(const char* keyfile)
if (fp == NULL)
{
printf("unable to load RSA key from %s: %s.", keyfile, strerror(errno));
xfree(key) ;
free(key) ;
return NULL;
}
@ -519,7 +519,7 @@ rdpKey* key_new(const char* keyfile)
{
ERR_print_errors_fp(stdout);
fclose(fp);
xfree(key) ;
free(key) ;
return NULL;
}
@ -530,7 +530,7 @@ rdpKey* key_new(const char* keyfile)
case 0:
RSA_free(rsa);
printf("invalid RSA key in %s", keyfile);
xfree(key) ;
free(key) ;
return NULL;
case 1:
@ -540,7 +540,7 @@ rdpKey* key_new(const char* keyfile)
default:
ERR_print_errors_fp(stdout);
RSA_free(rsa);
xfree(key) ;
free(key) ;
return NULL;
}
@ -548,7 +548,7 @@ rdpKey* key_new(const char* keyfile)
{
RSA_free(rsa);
printf("RSA public exponent too large in %s", keyfile);
xfree(key) ;
free(key) ;
return NULL;
}
@ -577,7 +577,7 @@ void key_free(rdpKey* key)
{
free(key->Modulus);
free(key->PrivateExponent);
xfree(key);
free(key);
}
}
@ -615,6 +615,6 @@ void certificate_free(rdpCertificate* certificate)
if (certificate->cert_info.Modulus != NULL)
free(certificate->cert_info.Modulus);
xfree(certificate);
free(certificate);
}
}

12
libfreerdp/core/connection.c
View File

@ -146,7 +146,7 @@ boolean rdp_client_redirect(rdpRdp* rdp)
free(settings->server_random);
free(settings->server_certificate);
xfree(settings->ip_address);
free(settings->ip_address);
rdp->transport = transport_new(settings);
rdp->license = license_new(rdp);
@ -164,30 +164,30 @@ boolean rdp_client_redirect(rdpRdp* rdp)
{
if (redirection->flags & LB_TARGET_NET_ADDRESS)
{
xfree(settings->hostname);
free(settings->hostname);
settings->hostname = xstrdup(redirection->targetNetAddress.ascii);
}
else if (redirection->flags & LB_TARGET_FQDN)
{
xfree(settings->hostname);
free(settings->hostname);
settings->hostname = xstrdup(redirection->targetFQDN.ascii);
}
else if (redirection->flags & LB_TARGET_NETBIOS_NAME)
{
xfree(settings->hostname);
free(settings->hostname);
settings->hostname = xstrdup(redirection->targetNetBiosName.ascii);
}
}
if (redirection->flags & LB_USERNAME)
{
xfree(settings->username);
free(settings->username);
settings->username = xstrdup(redirection->username.ascii);
}
if (redirection->flags & LB_DOMAIN)
{
xfree(settings->domain);
free(settings->domain);
settings->domain = xstrdup(redirection->domain.ascii);
}

2
libfreerdp/core/extension.c
View File

@ -224,6 +224,6 @@ void extension_free(rdpExtension* extension)
if (extension != NULL)
{
extension_uninit_plugins(extension);
xfree(extension);
free(extension);
}
}

4
libfreerdp/core/fastpath.c
View File

@ -333,7 +333,7 @@ static boolean fastpath_recv_update_data(rdpFastPath* fastpath, STREAM* s)
stream_set_pos(s, next_pos);
if (comp_stream != s)
xfree(comp_stream);
free(comp_stream);
return true;
}
@ -774,5 +774,5 @@ rdpFastPath* fastpath_new(rdpRdp* rdp)
void fastpath_free(rdpFastPath* fastpath)
{
stream_free(fastpath->updateData);
xfree(fastpath);
free(fastpath);
}

8
libfreerdp/core/freerdp.c
View File

@ -132,7 +132,7 @@ boolean freerdp_connect(freerdp* instance)
{
pcap_get_next_record_header(update->pcap_rfx, &record);
s->data = (uint8*) xrealloc(s->data, record.length);
s->data = (uint8*) realloc(s->data, record.length);
record.data = s->data;
s->size = record.length;
@ -144,7 +144,7 @@ boolean freerdp_connect(freerdp* instance)
update->EndPaint(update->context);
}
xfree(s->data);
free(s->data);
return true;
}
}
@ -269,7 +269,7 @@ void freerdp_context_free(freerdp* instance)
rdp_free(instance->context->rdp);
graphics_free(instance->context->graphics);
xfree(instance->context);
free(instance->context);
instance->context = NULL;
}
@ -304,6 +304,6 @@ void freerdp_free(freerdp* instance)
{
if (instance)
{
xfree(instance);
free(instance);
}
}

8
libfreerdp/core/gcc.c
View File

@ -495,7 +495,7 @@ boolean gcc_read_client_core_data(STREAM* s, rdpSettings* settings, uint16 block
stream_seek(s, 32);
snprintf(settings->client_hostname, 31, "%s", str);
settings->client_hostname[31] = 0;
xfree(str);
free(str);
stream_read_uint32(s, settings->kbd_type); /* keyboardType */
stream_read_uint32(s, settings->kbd_subtype); /* keyboardSubType */
@ -550,7 +550,7 @@ boolean gcc_read_client_core_data(STREAM* s, rdpSettings* settings, uint16 block
freerdp_UnicodeToAsciiAlloc((WCHAR*) stream_get_tail(s), &str, 64 / 2);
stream_seek(s, 64);
snprintf(settings->client_product_id, 32, "%s", str);
xfree(str);
free(str);
blockLength -= 64;
if (blockLength < 1)
@ -666,7 +666,7 @@ void gcc_write_client_core_data(STREAM* s, rdpSettings* settings)
stream_write(s, clientName, ((clientNameLength + 1) * 2));
stream_write_zero(s, 32 - ((clientNameLength + 1) * 2));
xfree(clientName);
free(clientName);
stream_write_uint32(s, settings->kbd_type); /* keyboardType */
stream_write_uint32(s, settings->kbd_subtype); /* keyboardSubType */
@ -714,7 +714,7 @@ void gcc_write_client_core_data(STREAM* s, rdpSettings* settings)
}
stream_write(s, clientDigProductId, clientDigProductIdLength + 2);
stream_write_zero(s, 64 - clientDigProductIdLength - 2);
xfree(clientDigProductId);
free(clientDigProductId);
stream_write_uint8(s, connectionType); /* connectionType */
stream_write_uint8(s, 0); /* pad1octet */

24
libfreerdp/core/graphics.c
View File

@ -33,7 +33,7 @@ rdpBitmap* Bitmap_Alloc(rdpContext* context)
rdpGraphics* graphics;
graphics = context->graphics;
bitmap = (rdpBitmap*) xmalloc(graphics->Bitmap_Prototype->size);
bitmap = (rdpBitmap*) malloc(graphics->Bitmap_Prototype->size);
if (bitmap != NULL)
{
@ -56,9 +56,9 @@ void Bitmap_Free(rdpContext* context, rdpBitmap* bitmap)
bitmap->Free(context, bitmap);
if (bitmap->data != NULL)
xfree(bitmap->data);
free(bitmap->data);
xfree(bitmap);
free(bitmap);
}
}
@ -95,7 +95,7 @@ rdpPointer* Pointer_Alloc(rdpContext* context)
rdpGraphics* graphics;
graphics = context->graphics;
pointer = (rdpPointer*) xmalloc(graphics->Pointer_Prototype->size);
pointer = (rdpPointer*) malloc(graphics->Pointer_Prototype->size);
if (pointer != NULL)
{
@ -117,12 +117,12 @@ void Pointer_Free(rdpContext* context, rdpPointer* pointer)
pointer->Free(context, pointer);
if (pointer->xorMaskData)
xfree(pointer->xorMaskData);
free(pointer->xorMaskData);
if (pointer->andMaskData)
xfree(pointer->andMaskData);
free(pointer->andMaskData);
xfree(pointer);
free(pointer);
}
}
@ -155,7 +155,7 @@ rdpGlyph* Glyph_Alloc(rdpContext* context)
rdpGraphics* graphics;
graphics = context->graphics;
glyph = (rdpGlyph*) xmalloc(graphics->Glyph_Prototype->size);
glyph = (rdpGlyph*) malloc(graphics->Glyph_Prototype->size);
if (glyph != NULL)
{
@ -230,9 +230,9 @@ void graphics_free(rdpGraphics* graphics)
{
if (graphics != NULL)
{
xfree(graphics->Bitmap_Prototype);
xfree(graphics->Pointer_Prototype);
xfree(graphics->Glyph_Prototype);
xfree(graphics);
free(graphics->Bitmap_Prototype);
free(graphics->Pointer_Prototype);
free(graphics->Glyph_Prototype);
free(graphics);
}
}

72
libfreerdp/core/http.c
View File

@ -42,7 +42,7 @@ HttpContext* http_context_new()
void http_context_set_method(HttpContext* http_context, char* method)
{
if (http_context->Method)
xfree(http_context->Method);
free(http_context->Method);
http_context->Method = xstrdup(method);
}
@ -50,7 +50,7 @@ void http_context_set_method(HttpContext* http_context, char* method)
void http_context_set_uri(HttpContext* http_context, char* uri)
{
if (http_context->URI)
xfree(http_context->URI);
free(http_context->URI);
http_context->URI = xstrdup(uri);
}
@ -58,7 +58,7 @@ void http_context_set_uri(HttpContext* http_context, char* uri)
void http_context_set_user_agent(HttpContext* http_context, char* user_agent)
{
if (http_context->UserAgent)
xfree(http_context->UserAgent);
free(http_context->UserAgent);
http_context->UserAgent = xstrdup(user_agent);
}
@ -66,7 +66,7 @@ void http_context_set_user_agent(HttpContext* http_context, char* user_agent)
void http_context_set_host(HttpContext* http_context, char* host)
{
if (http_context->Host)
xfree(http_context->Host);
free(http_context->Host);
http_context->Host = xstrdup(host);
}
@ -74,7 +74,7 @@ void http_context_set_host(HttpContext* http_context, char* host)
void http_context_set_accept(HttpContext* http_context, char* accept)
{
if (http_context->Accept)
xfree(http_context->Accept);
free(http_context->Accept);
http_context->Accept = xstrdup(accept);
}
@ -82,7 +82,7 @@ void http_context_set_accept(HttpContext* http_context, char* accept)
void http_context_set_cache_control(HttpContext* http_context, char* cache_control)
{
if (http_context->CacheControl)
xfree(http_context->CacheControl);
free(http_context->CacheControl);
http_context->CacheControl = xstrdup(cache_control);
}
@ -90,7 +90,7 @@ void http_context_set_cache_control(HttpContext* http_context, char* cache_contr
void http_context_set_connection(HttpContext* http_context, char* connection)
{
if (http_context->Connection)
xfree(http_context->Connection);
free(http_context->Connection);
http_context->Connection = xstrdup(connection);
}
@ -98,7 +98,7 @@ void http_context_set_connection(HttpContext* http_context, char* connection)
void http_context_set_pragma(HttpContext* http_context, char* pragma)
{
if (http_context->Pragma)
xfree(http_context->Pragma);
free(http_context->Pragma);
http_context->Pragma = xstrdup(pragma);
}
@ -107,20 +107,20 @@ void http_context_free(HttpContext* http_context)
{
if (http_context != NULL)
{
xfree(http_context->UserAgent);
xfree(http_context->Host);
xfree(http_context->Accept);
xfree(http_context->CacheControl);
xfree(http_context->Connection);
xfree(http_context->Pragma);
xfree(http_context);
free(http_context->UserAgent);
free(http_context->Host);
free(http_context->Accept);
free(http_context->CacheControl);
free(http_context->Connection);
free(http_context->Pragma);
free(http_context);
}
}
void http_request_set_method(HttpRequest* http_request, char* method)
{
if (http_request->Method)
xfree(http_request->Method);
free(http_request->Method);
http_request->Method = xstrdup(method);
}
@ -128,7 +128,7 @@ void http_request_set_method(HttpRequest* http_request, char* method)
void http_request_set_uri(HttpRequest* http_request, char* uri)
{
if (http_request->URI)
xfree(http_request->URI);
free(http_request->URI);
http_request->URI = xstrdup(uri);
}
@ -136,7 +136,7 @@ void http_request_set_uri(HttpRequest* http_request, char* uri)
void http_request_set_auth_scheme(HttpRequest* http_request, char* auth_scheme)
{
if (http_request->AuthScheme)
xfree(http_request->AuthScheme);
free(http_request->AuthScheme);
http_request->AuthScheme = xstrdup(auth_scheme);
}
@ -144,7 +144,7 @@ void http_request_set_auth_scheme(HttpRequest* http_request, char* auth_scheme)
void http_request_set_auth_param(HttpRequest* http_request, char* auth_param)
{
if (http_request->AuthParam)
xfree(http_request->AuthParam);
free(http_request->AuthParam);
http_request->AuthParam = xstrdup(auth_param);
}
@ -261,11 +261,11 @@ STREAM* http_request_write(HttpContext* http_context, HttpRequest* http_request)
{
stream_write(s, http_request->lines[i], strlen(http_request->lines[i]));
stream_write(s, "\n", 1);
xfree(http_request->lines[i]);
free(http_request->lines[i]);
}
stream_write(s, "\n", 1);
xfree(http_request->lines);
free(http_request->lines);
stream_write(s, "\0", 1); /* append null terminator */
stream_rewind(s, 1); /* don't include null terminator in length */
@ -290,9 +290,9 @@ void http_request_free(HttpRequest* http_request)
{
if (http_request != NULL)
{
xfree(http_request->Method);
xfree(http_request->URI);
xfree(http_request);
free(http_request->Method);
free(http_request->URI);
free(http_request);
}
}
@ -420,7 +420,7 @@ HttpResponse* http_response_recv(rdpTls* tls)
nbytes = 0;
length = 10000;
buffer = xmalloc(length);
buffer = malloc(length);
http_response = http_response_new();
p = buffer;
@ -466,7 +466,7 @@ HttpResponse* http_response_recv(rdpTls* tls)
}
http_response->count = count;
http_response->lines = (char**) xmalloc(sizeof(char*) * http_response->count);
http_response->lines = (char**) malloc(sizeof(char*) * http_response->count);
count = 0;
line = strtok((char*) buffer, "\r\n");
@ -491,12 +491,12 @@ HttpResponse* http_response_recv(rdpTls* tls)
if ((length - nbytes) <= 0)
{
length *= 2;
buffer = xrealloc(buffer, length);
buffer = realloc(buffer, length);
p = (uint8*) &buffer[nbytes];
}
}
xfree(buffer);
free(buffer);
return http_response;
}
@ -520,19 +520,19 @@ void http_response_free(HttpResponse* http_response)
if (http_response != NULL)
{
for (i = 0; i < http_response->count; i++)
xfree(http_response->lines[i]);
free(http_response->lines[i]);
xfree(http_response->lines);
free(http_response->lines);
xfree(http_response->ReasonPhrase);
free(http_response->ReasonPhrase);
xfree(http_response->AuthParam);
xfree(http_response->AuthScheme);
xfree(http_response->Authorization);
free(http_response->AuthParam);
free(http_response->AuthScheme);
free(http_response->Authorization);
if (http_response->ContentLength > 0)
xfree(http_response->Content);
free(http_response->Content);
xfree(http_response);
free(http_response);
}
}

16
libfreerdp/core/info.c
View File

@ -132,7 +132,7 @@ boolean rdp_read_extended_info_packet(STREAM* s, rdpSettings* settings)
return false;
if (settings->client_dir)
xfree(settings->client_dir);
free(settings->client_dir);
freerdp_UnicodeToAsciiAlloc((WCHAR*) stream_get_tail(s), &settings->client_dir, cbClientDir / 2);
stream_seek(s, cbClientDir);
@ -205,8 +205,8 @@ void rdp_write_extended_info_packet(STREAM* s, rdpSettings* settings)
/* reserved1 (2 bytes) */
/* reserved2 (2 bytes) */
xfree(clientAddress);
xfree(clientDir);
free(clientAddress);
free(clientDir);
}
/**
@ -399,13 +399,13 @@ void rdp_write_info_packet(STREAM* s, rdpSettings* settings)
stream_write(s, workingDir, cbWorkingDir);
stream_write_uint16(s, 0);
xfree(domain);
xfree(userName);
xfree(alternateShell);
xfree(workingDir);
free(domain);
free(userName);
free(alternateShell);
free(workingDir);
if (!usedPasswordCookie)
xfree(password);
free(password);
if (settings->rdp_version >= 5)
rdp_write_extended_info_packet(s, settings); /* extraInfo */

2
libfreerdp/core/input.c
View File

@ -437,6 +437,6 @@ void input_free(rdpInput* input)
{
if (input != NULL)
{
xfree(input);
free(input);
}
}

48
libfreerdp/core/license.c
View File

@ -331,7 +331,7 @@ void license_encrypt_premaster_secret(rdpLicense* license)
freerdp_hexdump(exponent, 4);
#endif
encrypted_premaster_secret = (uint8*) xmalloc(MODULUS_MAX_SIZE);
encrypted_premaster_secret = (uint8*) malloc(MODULUS_MAX_SIZE);
memset(encrypted_premaster_secret, 0, MODULUS_MAX_SIZE);
crypto_rsa_public_encrypt(license->premaster_secret, PREMASTER_SECRET_LENGTH,
@ -341,7 +341,7 @@ void license_encrypt_premaster_secret(rdpLicense* license)
license->encrypted_premaster_secret->length = PREMASTER_SECRET_LENGTH;
license->encrypted_premaster_secret->data = encrypted_premaster_secret;
#else
encrypted_premaster_secret = (uint8*) xmalloc(MODULUS_MAX_SIZE);
encrypted_premaster_secret = (uint8*) malloc(MODULUS_MAX_SIZE);
memset(encrypted_premaster_secret, 0, MODULUS_MAX_SIZE);
license->encrypted_premaster_secret->type = BB_RANDOM_BLOB;
@ -355,7 +355,7 @@ void license_decrypt_platform_challenge(rdpLicense* license)
CryptoRc4 rc4;
license->platform_challenge->data =
(uint8*) xmalloc(license->encrypted_platform_challenge->length);
(uint8*) malloc(license->encrypted_platform_challenge->length);
license->platform_challenge->length =
license->encrypted_platform_challenge->length;
@ -390,12 +390,12 @@ void license_read_product_info(STREAM* s, PRODUCT_INFO* productInfo)
stream_read_uint32(s, productInfo->cbCompanyName); /* cbCompanyName (4 bytes) */
productInfo->pbCompanyName = (uint8*) xmalloc(productInfo->cbCompanyName);
productInfo->pbCompanyName = (uint8*) malloc(productInfo->cbCompanyName);
stream_read(s, productInfo->pbCompanyName, productInfo->cbCompanyName);
stream_read_uint32(s, productInfo->cbProductId); /* cbProductId (4 bytes) */
productInfo->pbProductId = (uint8*) xmalloc(productInfo->cbProductId);
productInfo->pbProductId = (uint8*) malloc(productInfo->cbProductId);
stream_read(s, productInfo->pbProductId, productInfo->cbProductId);
}
@ -409,7 +409,7 @@ PRODUCT_INFO* license_new_product_info()
{
PRODUCT_INFO* productInfo;
productInfo = (PRODUCT_INFO*) xmalloc(sizeof(PRODUCT_INFO));
productInfo = (PRODUCT_INFO*) malloc(sizeof(PRODUCT_INFO));
productInfo->dwVersion = 0;
productInfo->cbCompanyName = 0;
@ -429,12 +429,12 @@ PRODUCT_INFO* license_new_product_info()
void license_free_product_info(PRODUCT_INFO* productInfo)
{
if (productInfo->pbCompanyName != NULL)
xfree(productInfo->pbCompanyName);
free(productInfo->pbCompanyName);
if (productInfo->pbProductId != NULL)
xfree(productInfo->pbProductId);
free(productInfo->pbProductId);
xfree(productInfo);
free(productInfo);
}
/**
@ -464,7 +464,7 @@ void license_read_binary_blob(STREAM* s, LICENSE_BLOB* blob)
}
blob->type = wBlobType;
blob->data = (uint8*) xmalloc(blob->length);
blob->data = (uint8*) malloc(blob->length);
stream_read(s, blob->data, blob->length); /* blobData */
}
@ -509,7 +509,7 @@ LICENSE_BLOB* license_new_binary_blob(uint16 type)
{
LICENSE_BLOB* blob;
blob = (LICENSE_BLOB*) xmalloc(sizeof(LICENSE_BLOB));
blob = (LICENSE_BLOB*) malloc(sizeof(LICENSE_BLOB));
blob->type = type;
blob->length = 0;
blob->data = NULL;
@ -526,9 +526,9 @@ LICENSE_BLOB* license_new_binary_blob(uint16 type)
void license_free_binary_blob(LICENSE_BLOB* blob)
{
if (blob->data != NULL)
xfree(blob->data);
free(blob->data);
xfree(blob);
free(blob);
}
/**
@ -546,7 +546,7 @@ void license_read_scope_list(STREAM* s, SCOPE_LIST* scopeList)
stream_read_uint32(s, scopeCount); /* ScopeCount (4 bytes) */
scopeList->count = scopeCount;
scopeList->array = (LICENSE_BLOB*) xmalloc(sizeof(LICENSE_BLOB) * scopeCount);
scopeList->array = (LICENSE_BLOB*) malloc(sizeof(LICENSE_BLOB) * scopeCount);
/* ScopeArray */
for (i = 0; i < scopeCount; i++)
@ -566,7 +566,7 @@ SCOPE_LIST* license_new_scope_list()
{
SCOPE_LIST* scopeList;
scopeList = (SCOPE_LIST*) xmalloc(sizeof(SCOPE_LIST));
scopeList = (SCOPE_LIST*) malloc(sizeof(SCOPE_LIST));
scopeList->count = 0;
scopeList->array = NULL;
@ -585,18 +585,18 @@ void license_free_scope_list(SCOPE_LIST* scopeList)
/*
* We must NOT call license_free_binary_blob() on each scopelist->array[i] element,
* because scopelist->array was allocated at once, by a single call to xmalloc. The elements
* because scopelist->array was allocated at once, by a single call to malloc. The elements
* it contains cannot be deallocated separately then.
* To make things clean, we must deallocate each scopelist->array[].data,
* and finish by deallocating scopelist->array with a single call to xfree().
* and finish by deallocating scopelist->array with a single call to free().
*/
for (i = 0; i < scopeList->count; i++)
{
xfree(scopeList->array[i].data);
free(scopeList->array[i].data);
}
xfree(scopeList->array) ;
xfree(scopeList);
free(scopeList->array) ;
free(scopeList);
}
/**
@ -836,13 +836,13 @@ void license_send_platform_challenge_response_packet(rdpLicense* license)
license->encrypted_platform_challenge->type = BB_DATA_BLOB;
length = license->platform_challenge->length + HWID_LENGTH;
buffer = (uint8*) xmalloc(length);
buffer = (uint8*) malloc(length);
memcpy(buffer, license->platform_challenge->data, license->platform_challenge->length);
memcpy(&buffer[license->platform_challenge->length], license->hwid, HWID_LENGTH);
security_mac_data(license->mac_salt_key, buffer, length, mac_data);
xfree(buffer);
free(buffer);
buffer = (uint8*) xmalloc(HWID_LENGTH);
buffer = (uint8*) malloc(HWID_LENGTH);
rc4 = crypto_rc4_init(license->licensing_encryption_key, LICENSING_ENCRYPTION_KEY_LENGTH);
crypto_rc4(rc4, HWID_LENGTH, license->hwid, buffer);
crypto_rc4_free(rc4);
@ -945,7 +945,7 @@ void license_free(rdpLicense* license)
license_free_binary_blob(license->encrypted_premaster_secret);
license_free_binary_blob(license->encrypted_hwid);
license_free_scope_list(license->scope_list);
xfree(license);
free(license);
}
}

4
libfreerdp/core/listener.c
View File

@ -332,8 +332,8 @@ void freerdp_listener_free(freerdp_listener* instance)
rdpListener* listener;
listener = (rdpListener*) instance->listener;
xfree(listener);
free(listener);
xfree(instance);
free(instance);
}

2
libfreerdp/core/mcs.c
View File

@ -836,6 +836,6 @@ void mcs_free(rdpMcs* mcs)
{
if (mcs != NULL)
{
xfree(mcs);
free(mcs);
}
}

4
libfreerdp/core/nego.c
View File

@ -266,7 +266,7 @@ boolean nego_send_preconnection_pdu(rdpNego* nego)
if (wszPCB)
{
stream_write(s, wszPCB, cchPCB * 2); /* wszPCB */
xfree(wszPCB);
free(wszPCB);
}
if (transport_write(nego->transport, s) < 0)
@ -831,7 +831,7 @@ rdpNego* nego_new(struct rdp_transport * transport)
void nego_free(rdpNego* nego)
{
xfree(nego);
free(nego);
}
/**

36
libfreerdp/core/orders.c
View File

@ -779,9 +779,9 @@ void update_read_polyline_order(STREAM* s, ORDER_INFO* orderInfo, POLYLINE_ORDER
stream_read_uint8(s, polyline->cbData);
if (polyline->points == NULL)
polyline->points = (DELTA_POINT*) xmalloc(sizeof(DELTA_POINT) * polyline->numPoints);
polyline->points = (DELTA_POINT*) malloc(sizeof(DELTA_POINT) * polyline->numPoints);
else
polyline->points = (DELTA_POINT*) xrealloc(polyline->points, sizeof(DELTA_POINT) * polyline->numPoints);
polyline->points = (DELTA_POINT*) realloc(polyline->points, sizeof(DELTA_POINT) * polyline->numPoints);
update_read_delta_points(s, polyline->points, polyline->numPoints, polyline->xStart, polyline->yStart);
}
@ -1056,7 +1056,7 @@ void update_read_fast_glyph_order(STREAM* s, ORDER_INFO* orderInfo, FAST_GLYPH_O
if ((fast_glyph->cbData > 1) && (fast_glyph->glyph_data == NULL))
{
/* parse optional glyph data */
glyph = (GLYPH_DATA_V2*) xmalloc(sizeof(GLYPH_DATA_V2));
glyph = (GLYPH_DATA_V2*) malloc(sizeof(GLYPH_DATA_V2));
glyph->cacheIndex = fast_glyph->data[0];
update_read_2byte_signed(s, &glyph->x);
update_read_2byte_signed(s, &glyph->y);
@ -1064,7 +1064,7 @@ void update_read_fast_glyph_order(STREAM* s, ORDER_INFO* orderInfo, FAST_GLYPH_O
update_read_2byte_unsigned(s, &glyph->cy);
glyph->cb = ((glyph->cx + 7) / 8) * glyph->cy;
glyph->cb += ((glyph->cb % 4) > 0) ? 4 - (glyph->cb % 4) : 0;
glyph->aj = (uint8*) xmalloc(glyph->cb);
glyph->aj = (uint8*) malloc(glyph->cb);
stream_read(s, glyph->aj, glyph->cb);
fast_glyph->glyph_data = glyph;
}
@ -1097,9 +1097,9 @@ void update_read_polygon_sc_order(STREAM* s, ORDER_INFO* orderInfo, POLYGON_SC_O
stream_read_uint8(s, polygon_sc->cbData);
if (polygon_sc->points == NULL)
polygon_sc->points = (DELTA_POINT*) xmalloc(sizeof(DELTA_POINT) * polygon_sc->numPoints);
polygon_sc->points = (DELTA_POINT*) malloc(sizeof(DELTA_POINT) * polygon_sc->numPoints);
else
polygon_sc->points = (DELTA_POINT*) xrealloc(polygon_sc->points, sizeof(DELTA_POINT) * polygon_sc->numPoints);
polygon_sc->points = (DELTA_POINT*) realloc(polygon_sc->points, sizeof(DELTA_POINT) * polygon_sc->numPoints);
update_read_delta_points(s, polygon_sc->points, polygon_sc->numPoints, polygon_sc->xStart, polygon_sc->yStart);
}
@ -1135,9 +1135,9 @@ void update_read_polygon_cb_order(STREAM* s, ORDER_INFO* orderInfo, POLYGON_CB_O
stream_read_uint8(s, polygon_cb->cbData);
if (polygon_cb->points == NULL)
polygon_cb->points = (DELTA_POINT*) xmalloc(sizeof(DELTA_POINT) * polygon_cb->numPoints);
polygon_cb->points = (DELTA_POINT*) malloc(sizeof(DELTA_POINT) * polygon_cb->numPoints);
else
polygon_cb->points = (DELTA_POINT*) xrealloc(polygon_cb->points, sizeof(DELTA_POINT) * polygon_cb->numPoints);
polygon_cb->points = (DELTA_POINT*) realloc(polygon_cb->points, sizeof(DELTA_POINT) * polygon_cb->numPoints);
update_read_delta_points(s, polygon_cb->points, polygon_cb->numPoints, polygon_cb->xStart, polygon_cb->yStart);
}
@ -1311,9 +1311,9 @@ void update_read_cache_bitmap_v3_order(STREAM* s, CACHE_BITMAP_V3_ORDER* cache_b
stream_read_uint32(s, bitmapData->length); /* length (4 bytes) */
if (bitmapData->data == NULL)
bitmapData->data = (uint8*) xmalloc(bitmapData->length);
bitmapData->data = (uint8*) malloc(bitmapData->length);
else
bitmapData->data = (uint8*) xrealloc(bitmapData->data, bitmapData->length);
bitmapData->data = (uint8*) realloc(bitmapData->data, bitmapData->length);
stream_read(s, bitmapData->data, bitmapData->length);
}
@ -1329,9 +1329,9 @@ void update_read_cache_color_table_order(STREAM* s, CACHE_COLOR_TABLE_ORDER* cac
colorTable = cache_color_table_order->colorTable;
if (colorTable == NULL)
colorTable = (uint32*) xmalloc(cache_color_table_order->numberColors * 4);
colorTable = (uint32*) malloc(cache_color_table_order->numberColors * 4);
else
colorTable = (uint32*) xrealloc(colorTable, cache_color_table_order->numberColors * 4);
colorTable = (uint32*) realloc(colorTable, cache_color_table_order->numberColors * 4);
for (i = 0; i < (int) cache_color_table_order->numberColors; i++)
{
@ -1354,7 +1354,7 @@ void update_read_cache_glyph_order(STREAM* s, CACHE_GLYPH_ORDER* cache_glyph_ord
{
if (cache_glyph_order->glyphData[i] == NULL)
{
cache_glyph_order->glyphData[i] = (GLYPH_DATA*) xmalloc(sizeof(GLYPH_DATA));
cache_glyph_order->glyphData[i] = (GLYPH_DATA*) malloc(sizeof(GLYPH_DATA));
}
glyph = cache_glyph_order->glyphData[i];
@ -1369,7 +1369,7 @@ void update_read_cache_glyph_order(STREAM* s, CACHE_GLYPH_ORDER* cache_glyph_ord
glyph->cb = ((glyph->cx + 7) / 8) * glyph->cy;
glyph->cb += ((glyph->cb % 4) > 0) ? 4 - (glyph->cb % 4) : 0;
glyph->aj = (uint8*) xmalloc(glyph->cb);
glyph->aj = (uint8*) malloc(glyph->cb);
stream_read(s, glyph->aj, glyph->cb);
}
@ -1391,7 +1391,7 @@ void update_read_cache_glyph_v2_order(STREAM* s, CACHE_GLYPH_V2_ORDER* cache_gly
{
if (cache_glyph_v2_order->glyphData[i] == NULL)
{
cache_glyph_v2_order->glyphData[i] = (GLYPH_DATA_V2*) xmalloc(sizeof(GLYPH_DATA_V2));
cache_glyph_v2_order->glyphData[i] = (GLYPH_DATA_V2*) malloc(sizeof(GLYPH_DATA_V2));
}
glyph = cache_glyph_v2_order->glyphData[i];
@ -1404,7 +1404,7 @@ void update_read_cache_glyph_v2_order(STREAM* s, CACHE_GLYPH_V2_ORDER* cache_gly
glyph->cb = ((glyph->cx + 7) / 8) * glyph->cy;
glyph->cb += ((glyph->cb % 4) > 0) ? 4 - (glyph->cb % 4) : 0;
glyph->aj = (uint8*) xmalloc(glyph->cb);
glyph->aj = (uint8*) malloc(glyph->cb);
stream_read(s, glyph->aj, glyph->cb);
}
@ -1462,7 +1462,7 @@ void update_read_cache_brush_order(STREAM* s, CACHE_BRUSH_ORDER* cache_brush_ord
{
size = (cache_brush_order->bpp == 1) ? 8 : 8 * 8 * cache_brush_order->bpp;
cache_brush_order->data = (uint8*) xmalloc(size);
cache_brush_order->data = (uint8*) malloc(size);
if (cache_brush_order->bpp == 1)
{
@ -1532,7 +1532,7 @@ void update_read_create_offscreen_bitmap_order(STREAM* s, CREATE_OFFSCREEN_BITMA
if (deleteList->cIndices > deleteList->sIndices)
{
deleteList->sIndices = deleteList->cIndices;
deleteList->indices = xrealloc(deleteList->indices, deleteList->sIndices * 2);
deleteList->indices = realloc(deleteList->indices, deleteList->sIndices * 2);
}
for (i = 0; i < (int) deleteList->cIndices; i++)

4
libfreerdp/core/peer.c
View File

@ -415,7 +415,7 @@ void freerdp_peer_free(freerdp_peer* client)
if (client)
{
rdp_free(client->context->rdp);
xfree(client->context);
xfree(client);
free(client->context);
free(client);
}
}

2
libfreerdp/core/rdp.c
View File

@ -966,7 +966,7 @@ void rdp_free(rdpRdp* rdp)
redirection_free(rdp->redirection);
mppc_dec_free(rdp->mppc_dec);
mppc_enc_free(rdp->mppc_enc);
xfree(rdp);
free(rdp);
}
}

4
libfreerdp/core/redirection.c
View File

@ -216,10 +216,10 @@ void redirection_free(rdpRedirection* redirection)
for (i = 0; i < (int) redirection->targetNetAddressesCount; i++)
freerdp_string_free(&redirection->targetNetAddresses[i]);
xfree(redirection->targetNetAddresses);
free(redirection->targetNetAddresses);
}
xfree(redirection);
free(redirection);
}
}

66
libfreerdp/core/rpc.c
View File

@ -104,7 +104,7 @@ boolean ntlm_authenticate(rdpNtlm* ntlm)
ntlm->outputBufferDesc.pBuffers = &ntlm->outputBuffer;
ntlm->outputBuffer.BufferType = SECBUFFER_TOKEN;
ntlm->outputBuffer.cbBuffer = ntlm->cbMaxToken;
ntlm->outputBuffer.pvBuffer = xmalloc(ntlm->outputBuffer.cbBuffer);
ntlm->outputBuffer.pvBuffer = malloc(ntlm->outputBuffer.cbBuffer);
if (ntlm->haveInputBuffer)
{
@ -204,7 +204,7 @@ STREAM* rpc_ntlm_http_request(rdpRpc* rpc, SecBuffer* ntlm_token, int content_le
s = http_request_write(http_context, http_request);
http_request_free(http_request);
xfree(base64_ntlm_token);
free(base64_ntlm_token);
return s;
}
@ -392,7 +392,7 @@ boolean rpc_send_bind_pdu(rdpRpc* rpc)
bind_pdu->p_context_elem.n_context_elem = 2;
bind_pdu->p_context_elem.reserved = 0;
bind_pdu->p_context_elem.reserved2 = 0;
bind_pdu->p_context_elem.p_cont_elem = xmalloc(sizeof(p_cont_elem_t) * bind_pdu->p_context_elem.n_context_elem);
bind_pdu->p_context_elem.p_cont_elem = malloc(sizeof(p_cont_elem_t) * bind_pdu->p_context_elem.n_context_elem);
bind_pdu->p_context_elem.p_cont_elem[0].p_cont_id = 0;
bind_pdu->p_context_elem.p_cont_elem[0].n_transfer_syn = 1;
bind_pdu->p_context_elem.p_cont_elem[0].reserved = 0;
@ -408,7 +408,7 @@ boolean rpc_send_bind_pdu(rdpRpc* rpc)
bind_pdu->p_context_elem.p_cont_elem[0].abstract_syntax.if_uuid.node[4] = 0x27;
bind_pdu->p_context_elem.p_cont_elem[0].abstract_syntax.if_uuid.node[5] = 0x29;
bind_pdu->p_context_elem.p_cont_elem[0].abstract_syntax.if_version = 0x00030001;
bind_pdu->p_context_elem.p_cont_elem[0].transfer_syntaxes = xmalloc(sizeof(p_syntax_id_t));
bind_pdu->p_context_elem.p_cont_elem[0].transfer_syntaxes = malloc(sizeof(p_syntax_id_t));
bind_pdu->p_context_elem.p_cont_elem[0].transfer_syntaxes[0].if_uuid.time_low = 0x8a885d04;
bind_pdu->p_context_elem.p_cont_elem[0].transfer_syntaxes[0].if_uuid.time_mid = 0x1ceb;
bind_pdu->p_context_elem.p_cont_elem[0].transfer_syntaxes[0].if_uuid.time_hi_and_version = 0x11c9;
@ -436,7 +436,7 @@ boolean rpc_send_bind_pdu(rdpRpc* rpc)
bind_pdu->p_context_elem.p_cont_elem[1].abstract_syntax.if_uuid.node[4] = 0x27;
bind_pdu->p_context_elem.p_cont_elem[1].abstract_syntax.if_uuid.node[5] = 0x29;
bind_pdu->p_context_elem.p_cont_elem[1].abstract_syntax.if_version = 0x00030001;
bind_pdu->p_context_elem.p_cont_elem[1].transfer_syntaxes = xmalloc(sizeof(p_syntax_id_t));
bind_pdu->p_context_elem.p_cont_elem[1].transfer_syntaxes = malloc(sizeof(p_syntax_id_t));
bind_pdu->p_context_elem.p_cont_elem[1].transfer_syntaxes[0].if_uuid.time_low = 0x6cb71c2c;
bind_pdu->p_context_elem.p_cont_elem[1].transfer_syntaxes[0].if_uuid.time_mid = 0x9812;
bind_pdu->p_context_elem.p_cont_elem[1].transfer_syntaxes[0].if_uuid.time_hi_and_version = 0x4540;
@ -455,7 +455,7 @@ boolean rpc_send_bind_pdu(rdpRpc* rpc)
bind_pdu->auth_verifier.auth_pad_length = 0x00; /* :01 */
bind_pdu->auth_verifier.auth_reserved = 0x00; /* :01 reserved, m.b.z. */
bind_pdu->auth_verifier.auth_context_id = 0x00000000; /* :04 */
bind_pdu->auth_verifier.auth_value = xmalloc(bind_pdu->auth_length); /* credentials; size_is(auth_length) p*/;
bind_pdu->auth_verifier.auth_value = malloc(bind_pdu->auth_length); /* credentials; size_is(auth_length) p*/;
memcpy(bind_pdu->auth_verifier.auth_value, ntlm_stream->data, bind_pdu->auth_length);
stream_free(ntlm_stream);
@ -479,7 +479,7 @@ boolean rpc_send_bind_pdu(rdpRpc* rpc)
rpc_in_write(rpc, pdu->data, pdu->size);
stream_free(pdu) ;
xfree(bind_pdu);
free(bind_pdu);
return true;
}
@ -494,7 +494,7 @@ int rpc_recv_bind_ack_pdu(rdpRpc* rpc)
RPC_PDU_HEADER header;
int pdu_length = 0x8FFF;
pdu = xmalloc(pdu_length);
pdu = malloc(pdu_length);
if (pdu == NULL)
return -1;
@ -509,11 +509,11 @@ int rpc_recv_bind_ack_pdu(rdpRpc* rpc)
stream_detach(s);
stream_free(s);
auth_data = xmalloc(header.auth_length);
auth_data = malloc(header.auth_length);
if (auth_data == NULL)
{
xfree(pdu);
free(pdu);
return -1;
}
@ -526,7 +526,7 @@ int rpc_recv_bind_ack_pdu(rdpRpc* rpc)
ntlm_authenticate(rpc->ntlm);
}
xfree(pdu);
free(pdu);
return status;
}
@ -562,7 +562,7 @@ boolean rpc_send_rpc_auth_3_pdu(rdpRpc* rpc)
rpc_auth_3_pdu->auth_verifier.auth_pad_length = 0x00; /* :01 */
rpc_auth_3_pdu->auth_verifier.auth_reserved = 0x00; /* :01 reserved, m.b.z. */
rpc_auth_3_pdu->auth_verifier.auth_context_id = 0x00000000; /* :04 */
rpc_auth_3_pdu->auth_verifier.auth_value = xmalloc(rpc_auth_3_pdu->auth_length); /* credentials; size_is(auth_length) p */
rpc_auth_3_pdu->auth_verifier.auth_value = malloc(rpc_auth_3_pdu->auth_length); /* credentials; size_is(auth_length) p */
memcpy(rpc_auth_3_pdu->auth_verifier.auth_value, s->data, rpc_auth_3_pdu->auth_length);
stream_free(s);
@ -580,7 +580,7 @@ boolean rpc_send_rpc_auth_3_pdu(rdpRpc* rpc)
rpc_in_write(rpc, pdu->data, stream_get_length(pdu));
stream_free(pdu) ;
xfree(rpc_auth_3_pdu);
free(rpc_auth_3_pdu);
return true;
}
@ -596,7 +596,7 @@ int rpc_out_read(rdpRpc* rpc, uint8* data, int length)
if (rpc->VirtualConnection->DefaultOutChannel->ReceiverAvailableWindow < 0x00008FFF) /* Just a simple workaround */
rts_send_flow_control_ack_pdu(rpc); /* Send FlowControlAck every time AvailableWindow reaches the half */
pdu = xmalloc(0xFFFF);
pdu = malloc(0xFFFF);
if (pdu == NULL)
{
@ -608,7 +608,7 @@ int rpc_out_read(rdpRpc* rpc, uint8* data, int length)
if (status <= 0)
{
xfree(pdu);
free(pdu);
return status;
}
@ -625,14 +625,14 @@ int rpc_out_read(rdpRpc* rpc, uint8* data, int length)
if (status < 0)
{
xfree(pdu);
free(pdu);
return status;
}
if (header.ptype == PTYPE_RTS) /* RTS PDU */
{
printf("rpc_out_read error: Unexpected RTS PDU\n");
xfree(pdu);
free(pdu);
return -1;
}
else
@ -645,7 +645,7 @@ int rpc_out_read(rdpRpc* rpc, uint8* data, int length)
if (length < header.frag_length)
{
printf("rpc_out_read error! receive buffer is not large enough\n");
xfree(pdu);
free(pdu);
return -1;
}
@ -657,7 +657,7 @@ int rpc_out_read(rdpRpc* rpc, uint8* data, int length)
printf("\n");
#endif
xfree(pdu);
free(pdu);
return header.frag_length;
}
@ -704,7 +704,7 @@ int rpc_tsg_write(rdpRpc* rpc, uint8* data, int length, uint16 opnum)
request_pdu->auth_verifier.auth_type = 0x0A; /* :01 which authentication service */
request_pdu->auth_verifier.auth_level = 0x05; /* :01 which level within service */
request_pdu->auth_verifier.auth_pad_length = auth_pad_length; /* :01 */
request_pdu->auth_verifier.auth_pad = xmalloc(auth_pad_length); /* align(4); size_is(auth_pad_length) p */
request_pdu->auth_verifier.auth_pad = malloc(auth_pad_length); /* align(4); size_is(auth_pad_length) p */
for (i = 0; i < auth_pad_length; i++)
{
@ -713,7 +713,7 @@ int rpc_tsg_write(rdpRpc* rpc, uint8* data, int length, uint16 opnum)
request_pdu->auth_verifier.auth_reserved = 0x00; /* :01 reserved, m.b.z. */
request_pdu->auth_verifier.auth_context_id = 0x00000000; /* :04 */
request_pdu->auth_verifier.auth_value = xmalloc(request_pdu->auth_length); /* credentials; size_is(auth_length) p */
request_pdu->auth_verifier.auth_value = malloc(request_pdu->auth_length); /* credentials; size_is(auth_length) p */
pdu = stream_new(request_pdu->frag_length);
@ -725,9 +725,9 @@ int rpc_tsg_write(rdpRpc* rpc, uint8* data, int length, uint16 opnum)
stream_write(pdu, &request_pdu->auth_verifier.auth_type, 8);
xfree(request_pdu->auth_verifier.auth_value);
xfree(request_pdu->auth_verifier.auth_pad);
xfree(request_pdu);
free(request_pdu->auth_verifier.auth_value);
free(request_pdu->auth_verifier.auth_pad);
free(request_pdu);
if (ntlm->table->QueryContextAttributes(&ntlm->context, SECPKG_ATTR_SIZES, &ntlm->ContextSizes) != SEC_E_OK)
{
@ -783,7 +783,7 @@ int rpc_read(rdpRpc* rpc, uint8* data, int length)
uint8 auth_pad_length;
uint32 call_id = -1;
int rpc_length = length + 0xFF;
uint8* rpc_data = xmalloc(rpc_length);
uint8* rpc_data = malloc(rpc_length);
if (rpc_data == NULL)
{
@ -796,13 +796,13 @@ int rpc_read(rdpRpc* rpc, uint8* data, int length)
if (rpc->read_buffer_len > (uint32) length)
{
printf("rpc_read error: receiving buffer is not large enough\n");
xfree(rpc_data);
free(rpc_data);
return -1;
}
memcpy(data, rpc->read_buffer, rpc->read_buffer_len);
read += rpc->read_buffer_len;
xfree(rpc->read_buffer);
free(rpc->read_buffer);
rpc->read_buffer_len = 0;
}
@ -812,7 +812,7 @@ int rpc_read(rdpRpc* rpc, uint8* data, int length)
if (status == 0)
{
xfree(rpc_data);
free(rpc_data);
return read;
}
else if (status < 0)
@ -821,7 +821,7 @@ int rpc_read(rdpRpc* rpc, uint8* data, int length)
rpc->VirtualConnection->DefaultInChannel->BytesSent,
rpc->VirtualConnection->DefaultOutChannel->BytesReceived);
xfree(rpc_data);
free(rpc_data);
return status;
}
@ -840,7 +840,7 @@ int rpc_read(rdpRpc* rpc, uint8* data, int length)
if (read + data_length > length) /* if read data is greater then given buffer */
{
rpc->read_buffer_len = read + data_length - length;
rpc->read_buffer = xmalloc(rpc->read_buffer_len);
rpc->read_buffer = malloc(rpc->read_buffer_len);
data_length -= rpc->read_buffer_len;
@ -857,7 +857,7 @@ int rpc_read(rdpRpc* rpc, uint8* data, int length)
break;
}
xfree(rpc_data);
free(rpc_data);
return read;
}
@ -924,7 +924,7 @@ void rpc_client_virtual_connection_free(RpcVirtualConnection* virtual_connection
{
if (virtual_connection != NULL)
{
xfree(virtual_connection);
free(virtual_connection);
}
}
@ -1018,6 +1018,6 @@ void rpc_free(rdpRpc* rpc)
ntlm_http_free(rpc->ntlm_http_in);
ntlm_http_free(rpc->ntlm_http_out);
rpc_client_virtual_connection_free(rpc->VirtualConnection);
xfree(rpc);
free(rpc);
}
}

2
libfreerdp/core/rts.c
View File

@ -688,7 +688,7 @@ int rts_recv_pdu(rdpRpc* rpc, RTS_PDU* rts_pdu)
stream_free(s);
length = rts_pdu->header.frag_length - 20;
rts_pdu->content = (uint8*) xmalloc(length);
rts_pdu->content = (uint8*) malloc(length);
status = tls_read(tls_out, rts_pdu->content, length);

54
libfreerdp/core/settings.c
View File

@ -293,34 +293,34 @@ void settings_free(rdpSettings* settings)
{
if (settings != NULL)
{
xfree(settings->hostname);
xfree(settings->username);
xfree(settings->password);
xfree(settings->domain);
xfree(settings->shell);
xfree(settings->directory);
xfree(settings->ip_address);
xfree(settings->client_dir);
xfree(settings->cert_file);
xfree(settings->privatekey_file);
xfree(settings->received_caps);
xfree(settings->order_support);
xfree(settings->client_hostname);
xfree(settings->client_product_id);
xfree(settings->server_random);
xfree(settings->server_certificate);
xfree(settings->rdp_key_file);
free(settings->hostname);
free(settings->username);
free(settings->password);
free(settings->domain);
free(settings->shell);
free(settings->directory);
free(settings->ip_address);
free(settings->client_dir);
free(settings->cert_file);
free(settings->privatekey_file);
free(settings->received_caps);
free(settings->order_support);
free(settings->client_hostname);
free(settings->client_product_id);
free(settings->server_random);
free(settings->server_certificate);
free(settings->rdp_key_file);
certificate_free(settings->server_cert);
xfree(settings->client_auto_reconnect_cookie);
xfree(settings->server_auto_reconnect_cookie);
xfree(settings->client_time_zone);
xfree(settings->bitmapCacheV2CellInfo);
xfree(settings->glyphCache);
xfree(settings->fragCache);
free(settings->client_auto_reconnect_cookie);
free(settings->server_auto_reconnect_cookie);
free(settings->client_time_zone);
free(settings->bitmapCacheV2CellInfo);
free(settings->glyphCache);
free(settings->fragCache);
key_free(settings->server_key);
xfree(settings->config_path);
xfree(settings->current_path);
xfree(settings->development_path);
xfree(settings);
free(settings->config_path);
free(settings->current_path);
free(settings->development_path);
free(settings);
}
}

2
libfreerdp/core/tcp.c
View File

@ -257,6 +257,6 @@ void tcp_free(rdpTcp* tcp)
{
if (tcp != NULL)
{
xfree(tcp);
free(tcp);
}
}

8
libfreerdp/core/timezone.c
View File

@ -90,7 +90,7 @@ boolean rdp_read_client_time_zone(STREAM* s, rdpSettings* settings)
freerdp_UnicodeToAsciiAlloc((WCHAR*) stream_get_tail(s), &str, 64 / 2);
stream_seek(s, 64);
strncpy(clientTimeZone->standardName, str, sizeof(clientTimeZone->standardName));
xfree(str);
free(str);
rdp_read_system_time(s, &clientTimeZone->standardDate); /* StandardDate */
stream_read_uint32(s, clientTimeZone->standardBias); /* StandardBias */
@ -99,7 +99,7 @@ boolean rdp_read_client_time_zone(STREAM* s, rdpSettings* settings)
freerdp_UnicodeToAsciiAlloc((WCHAR*) stream_get_tail(s), &str, 64 / 2);
stream_seek(s, 64);
strncpy(clientTimeZone->daylightName, str, sizeof(clientTimeZone->daylightName));
xfree(str);
free(str);
rdp_read_system_time(s, &clientTimeZone->daylightDate); /* DaylightDate */
stream_read_uint32(s, clientTimeZone->daylightBias); /* DaylightBias */
@ -189,6 +189,6 @@ void rdp_write_client_time_zone(STREAM* s, rdpSettings* settings)
stream_write_uint32(s, bias2c); /* DaylightBias */
DEBUG_TIMEZONE("DaylightBias=%d", bias2c);
xfree(standardName);
xfree(daylightName);
free(standardName);
free(daylightName);
}

2
libfreerdp/core/transport.c
View File

@ -541,6 +541,6 @@ void transport_free(rdpTransport* transport)
tcp_free(transport->tcp_in);
tsg_free(transport->tsg);
xfree(transport);
free(transport);
}
}

22
libfreerdp/core/tsg.c
View File

@ -492,7 +492,7 @@ boolean tsg_connect(rdpTsg* tsg, const char* hostname, uint16 port)
}
length = 0x8FFF;
data = xmalloc(length);
data = malloc(length);
if (data == NULL)
{
printf("rpc_recv - memory allocation error\n") ;
@ -503,7 +503,7 @@ boolean tsg_connect(rdpTsg* tsg, const char* hostname, uint16 port)
if (status <= 0)
{
printf("rpc_recv failed!\n");
xfree(data) ;
free(data) ;
return false;
}
@ -534,7 +534,7 @@ boolean tsg_connect(rdpTsg* tsg, const char* hostname, uint16 port)
if (status <= 0)
{
printf("rpc_write opnum=2 failed!\n");
xfree(data) ;
free(data) ;
return false;
}
@ -543,7 +543,7 @@ boolean tsg_connect(rdpTsg* tsg, const char* hostname, uint16 port)
if (status <= 0)
{
printf("rpc_recv failed!\n");
xfree(data) ;
free(data) ;
return false;
}
@ -566,7 +566,7 @@ boolean tsg_connect(rdpTsg* tsg, const char* hostname, uint16 port)
if (status <= 0)
{
printf("rpc_write opnum=3 failed!\n");
xfree(data) ;
free(data) ;
return false;
}
status = -1;
@ -584,7 +584,7 @@ boolean tsg_connect(rdpTsg* tsg, const char* hostname, uint16 port)
stream_write(s_p4, dest_addr_unic, dest_addr_unic_len);
stream_write_uint16(s_p4, 0x0000); /* unicode zero to terminate hostname string */
xfree(dest_addr_unic);
free(dest_addr_unic);
/**
* OpNum = 4
@ -604,7 +604,7 @@ boolean tsg_connect(rdpTsg* tsg, const char* hostname, uint16 port)
{
printf("rpc_write opnum=4 failed!\n");
stream_free(s_p4);
xfree(data);
free(data);
return false;
}
@ -614,7 +614,7 @@ boolean tsg_connect(rdpTsg* tsg, const char* hostname, uint16 port)
{
printf("rpc_recv failed!\n");
stream_free(s_p4);
xfree(data);
free(data);
return false;
}
@ -643,12 +643,12 @@ boolean tsg_connect(rdpTsg* tsg, const char* hostname, uint16 port)
{
printf("rpc_write opnum=8 failed!\n");
stream_free(s_p4);
xfree(data);
free(data);
return false;
}
stream_free(s_p4);
xfree(data);
free(data);
return true;
}
@ -688,6 +688,6 @@ void tsg_free(rdpTsg* tsg)
if (tsg != NULL)
{
rpc_free(tsg->rpc);
xfree(tsg);
free(tsg);
}
}

28
libfreerdp/core/update.c
View File

@ -101,7 +101,7 @@ void update_read_bitmap(rdpUpdate* update, STREAM* s, BITMAP_UPDATE* bitmap_upda
count = bitmap_update->number * 2;
bitmap_update->rectangles = (BITMAP_DATA*) xrealloc(bitmap_update->rectangles,
bitmap_update->rectangles = (BITMAP_DATA*) realloc(bitmap_update->rectangles,
sizeof(BITMAP_DATA) * count);
memset(&bitmap_update->rectangles[bitmap_update->count], 0,
@ -195,13 +195,13 @@ void update_read_pointer_color(STREAM* s, POINTER_COLOR_UPDATE* pointer_color)
if (pointer_color->lengthXorMask > 0)
{
pointer_color->xorMaskData = (uint8*) xmalloc(pointer_color->lengthXorMask);
pointer_color->xorMaskData = (uint8*) malloc(pointer_color->lengthXorMask);
stream_read(s, pointer_color->xorMaskData, pointer_color->lengthXorMask);
}
if (pointer_color->lengthAndMask > 0)
{
pointer_color->andMaskData = (uint8*) xmalloc(pointer_color->lengthAndMask);
pointer_color->andMaskData = (uint8*) malloc(pointer_color->lengthAndMask);
stream_read(s, pointer_color->andMaskData, pointer_color->lengthAndMask);
}
@ -635,7 +635,7 @@ rdpUpdate* update_new(rdpRdp* rdp)
deleteList = &(update->altsec->create_offscreen_bitmap.deleteList);
deleteList->sIndices = 64;
deleteList->indices = xmalloc(deleteList->sIndices * 2);
deleteList->indices = malloc(deleteList->sIndices * 2);
deleteList->cIndices = 0;
update->SuppressOutput = update_send_suppress_output;
@ -650,17 +650,17 @@ void update_free(rdpUpdate* update)
{
OFFSCREEN_DELETE_LIST* deleteList;
deleteList = &(update->altsec->create_offscreen_bitmap.deleteList);
xfree(deleteList->indices);
free(deleteList->indices);
xfree(update->bitmap_update.rectangles);
xfree(update->pointer);
xfree(update->primary->polyline.points);
xfree(update->primary->polygon_sc.points);
xfree(update->primary);
xfree(update->secondary);
xfree(update->altsec);
xfree(update->window);
xfree(update);
free(update->bitmap_update.rectangles);
free(update->pointer);
free(update->primary->polyline.points);
free(update->primary->polygon_sc.points);
free(update->primary);
free(update->secondary);
free(update->altsec);
free(update->window);
free(update);
}
}

20
libfreerdp/core/window.c
View File

@ -46,23 +46,23 @@ void update_read_icon_info(STREAM* s, ICON_INFO* icon_info)
/* bitsMask */
if (icon_info->bitsMask == NULL)
icon_info->bitsMask = (uint8*) xmalloc(icon_info->cbBitsMask);
icon_info->bitsMask = (uint8*) malloc(icon_info->cbBitsMask);
else
icon_info->bitsMask = (uint8*) xrealloc(icon_info->bitsMask, icon_info->cbBitsMask);
icon_info->bitsMask = (uint8*) realloc(icon_info->bitsMask, icon_info->cbBitsMask);
stream_read(s, icon_info->bitsMask, icon_info->cbBitsMask);
/* colorTable */
if (icon_info->colorTable == NULL)
icon_info->colorTable = (uint8*) xmalloc(icon_info->cbColorTable);
icon_info->colorTable = (uint8*) malloc(icon_info->cbColorTable);
else
icon_info->colorTable = (uint8*) xrealloc(icon_info->colorTable, icon_info->cbColorTable);
icon_info->colorTable = (uint8*) realloc(icon_info->colorTable, icon_info->cbColorTable);
stream_read(s, icon_info->colorTable, icon_info->cbColorTable);
/* bitsColor */
if (icon_info->bitsColor == NULL)
icon_info->bitsColor = (uint8*) xmalloc(icon_info->cbBitsColor);
icon_info->bitsColor = (uint8*) malloc(icon_info->cbBitsColor);
else
icon_info->bitsColor = (uint8*) xrealloc(icon_info->bitsColor, icon_info->cbBitsColor);
icon_info->bitsColor = (uint8*) realloc(icon_info->bitsColor, icon_info->cbBitsColor);
stream_read(s, icon_info->bitsColor, icon_info->cbBitsColor);
}
@ -141,7 +141,7 @@ void update_read_window_state_order(STREAM* s, WINDOW_ORDER_INFO* orderInfo, WIN
stream_read_uint16(s, window_state->numWindowRects); /* numWindowRects (2 bytes) */
size = sizeof(RECTANGLE_16) * window_state->numWindowRects;
window_state->windowRects = (RECTANGLE_16*) xmalloc(size);
window_state->windowRects = (RECTANGLE_16*) malloc(size);
/* windowRects */
for (i = 0; i < (int) window_state->numWindowRects; i++)
@ -164,7 +164,7 @@ void update_read_window_state_order(STREAM* s, WINDOW_ORDER_INFO* orderInfo, WIN
stream_read_uint16(s, window_state->numVisibilityRects); /* numVisibilityRects (2 bytes) */
size = sizeof(RECTANGLE_16) * window_state->numVisibilityRects;
window_state->visibilityRects = (RECTANGLE_16*) xmalloc(size);
window_state->visibilityRects = (RECTANGLE_16*) malloc(size);
/* visibilityRects */
for (i = 0; i < (int) window_state->numVisibilityRects; i++)
@ -297,9 +297,9 @@ void update_read_desktop_actively_monitored_order(STREAM* s, WINDOW_ORDER_INFO*
size = sizeof(uint32) * monitored_desktop->numWindowIds;
if (monitored_desktop->windowIds == NULL)
monitored_desktop->windowIds = (uint32*) xmalloc(size);
monitored_desktop->windowIds = (uint32*) malloc(size);
else
monitored_desktop->windowIds = (uint32*) xrealloc(monitored_desktop->windowIds, size);
monitored_desktop->windowIds = (uint32*) realloc(monitored_desktop->windowIds, size);
/* windowIds */
for (i = 0; i < (int) monitored_desktop->numWindowIds; i++)

24
libfreerdp/crypto/certificate.c
View File

@ -93,11 +93,11 @@ int certificate_data_match(rdpCertificateStore* certificate_store, rdpCertificat
if (size < 1)
return match;
data = (char*) xmalloc(size + 2);
data = (char*) malloc(size + 2);
if (fread(data, size, 1, fp) != 1)
{
xfree(data);
free(data);
return match;
}
@ -128,7 +128,7 @@ int certificate_data_match(rdpCertificateStore* certificate_store, rdpCertificat
pline = strtok(NULL, "\n");
}
xfree(data);
free(data);
return match;
}
@ -154,11 +154,11 @@ void certificate_data_replace(rdpCertificateStore* certificate_store, rdpCertifi
if (size < 1)
return;
data = (char*) xmalloc(size + 2);
data = (char*) malloc(size + 2);
if (fread(data, size, 1, fp) != 1)
{
xfree(data);
free(data);
return;
}
@ -192,7 +192,7 @@ void certificate_data_replace(rdpCertificateStore* certificate_store, rdpCertifi
}
fclose(fp);
xfree(data);
free(data);
}
void certificate_data_print(rdpCertificateStore* certificate_store, rdpCertificateData* certificate_data)
@ -228,9 +228,9 @@ void certificate_data_free(rdpCertificateData* certificate_data)
{
if (certificate_data != NULL)
{
xfree(certificate_data->hostname);
xfree(certificate_data->fingerprint);
xfree(certificate_data);
free(certificate_data->hostname);
free(certificate_data->fingerprint);
free(certificate_data);
}
}
@ -256,8 +256,8 @@ void certificate_store_free(rdpCertificateStore* certstore)
if (certstore->fp != NULL)
fclose(certstore->fp);
xfree(certstore->path);
xfree(certstore->file);
xfree(certstore);
free(certstore->path);
free(certstore->file);
free(certstore);
}
}

50
libfreerdp/crypto/crypto.c
View File

@ -25,7 +25,7 @@
CryptoSha1 crypto_sha1_init(void)
{
CryptoSha1 sha1 = xmalloc(sizeof(*sha1));
CryptoSha1 sha1 = malloc(sizeof(*sha1));
SHA1_Init(&sha1->sha_ctx);
return sha1;
}
@ -38,12 +38,12 @@ void crypto_sha1_update(CryptoSha1 sha1, const uint8* data, uint32 length)
void crypto_sha1_final(CryptoSha1 sha1, uint8* out_data)
{
SHA1_Final(out_data, &sha1->sha_ctx);
xfree(sha1);
free(sha1);
}
CryptoMd5 crypto_md5_init(void)
{
CryptoMd5 md5 = xmalloc(sizeof(*md5));
CryptoMd5 md5 = malloc(sizeof(*md5));
MD5_Init(&md5->md5_ctx);
return md5;
}
@ -56,12 +56,12 @@ void crypto_md5_update(CryptoMd5 md5, const uint8* data, uint32 length)
void crypto_md5_final(CryptoMd5 md5, uint8* out_data)
{
MD5_Final(out_data, &md5->md5_ctx);
xfree(md5);
free(md5);
}
CryptoRc4 crypto_rc4_init(const uint8* key, uint32 length)
{
CryptoRc4 rc4 = xmalloc(sizeof(*rc4));
CryptoRc4 rc4 = malloc(sizeof(*rc4));
RC4_set_key(&rc4->rc4_key, length, key);
return rc4;
}
@ -74,12 +74,12 @@ void crypto_rc4(CryptoRc4 rc4, uint32 length, const uint8* in_data, uint8* out_d
void crypto_rc4_free(CryptoRc4 rc4)
{
if (rc4)
xfree(rc4);
free(rc4);
}
CryptoDes3 crypto_des3_encrypt_init(const uint8* key, const uint8* ivec)
{
CryptoDes3 des3 = xmalloc(sizeof(*des3));
CryptoDes3 des3 = malloc(sizeof(*des3));
EVP_CIPHER_CTX_init(&des3->des3_ctx);
EVP_EncryptInit_ex(&des3->des3_ctx, EVP_des_ede3_cbc(), NULL, key, ivec);
EVP_CIPHER_CTX_set_padding(&des3->des3_ctx, 0);
@ -88,7 +88,7 @@ CryptoDes3 crypto_des3_encrypt_init(const uint8* key, const uint8* ivec)
CryptoDes3 crypto_des3_decrypt_init(const uint8* key, const uint8* ivec)
{
CryptoDes3 des3 = xmalloc(sizeof(*des3));
CryptoDes3 des3 = malloc(sizeof(*des3));
EVP_CIPHER_CTX_init(&des3->des3_ctx);
EVP_DecryptInit_ex(&des3->des3_ctx, EVP_des_ede3_cbc(), NULL, key, ivec);
EVP_CIPHER_CTX_set_padding(&des3->des3_ctx, 0);
@ -115,12 +115,12 @@ void crypto_des3_free(CryptoDes3 des3)
if (des3 == NULL)
return;
EVP_CIPHER_CTX_cleanup(&des3->des3_ctx);
xfree(des3);
free(des3);
}
CryptoHmac crypto_hmac_new(void)
{
CryptoHmac hmac = xmalloc(sizeof(*hmac));
CryptoHmac hmac = malloc(sizeof(*hmac));
HMAC_CTX_init(&hmac->hmac_ctx);
return hmac;
}
@ -145,12 +145,12 @@ void crypto_hmac_free(CryptoHmac hmac)
if (hmac == NULL)
return;
HMAC_CTX_cleanup(&hmac->hmac_ctx);
xfree(hmac);
free(hmac);
}
CryptoCert crypto_cert_read(uint8* data, uint32 length)
{
CryptoCert cert = xmalloc(sizeof(*cert));
CryptoCert cert = malloc(sizeof(*cert));
/* this will move the data pointer but we don't care, we don't use it again */
cert->px509 = d2i_X509(NULL, (D2I_X509_CONST uint8 **) &data, length);
return cert;
@ -163,7 +163,7 @@ void crypto_cert_free(CryptoCert cert)
X509_free(cert->px509);
xfree(cert);
free(cert);
}
boolean crypto_cert_get_public_key(CryptoCert cert, BYTE** PublicKey, DWORD* PublicKeyLength)
@ -213,7 +213,7 @@ static void crypto_rsa_common(const uint8* input, int length, uint32 key_length,
uint8* exponent_reverse;
BIGNUM mod, exp, x, y;
input_reverse = (uint8*) xmalloc(2 * key_length + exponent_size);
input_reverse = (uint8*) malloc(2 * key_length + exponent_size);
modulus_reverse = input_reverse + key_length;
exponent_reverse = modulus_reverse + key_length;
@ -246,7 +246,7 @@ static void crypto_rsa_common(const uint8* input, int length, uint32 key_length,
BN_free(&exp);
BN_free(&mod);
BN_CTX_free(ctx);
xfree(input_reverse);
free(input_reverse);
}
static void crypto_rsa_public(const uint8* input, int length, uint32 key_length, const uint8* modulus, const uint8* exponent, uint8* output)
@ -407,8 +407,8 @@ char** crypto_cert_subject_alt_name(X509* xcert, int* count, int** lengths)
return NULL;
num_subject_alt_names = sk_GENERAL_NAME_num(subject_alt_names);
strings = (char**) xmalloc(sizeof(char*) * num_subject_alt_names);
*lengths = (int*) xmalloc(sizeof(int*) * num_subject_alt_names);
strings = (char**) malloc(sizeof(char*) * num_subject_alt_names);
*lengths = (int*) malloc(sizeof(int*) * num_subject_alt_names);
for (index = 0; index < num_subject_alt_names; ++index)
{
@ -425,8 +425,8 @@ char** crypto_cert_subject_alt_name(X509* xcert, int* count, int** lengths)
if (*count < 1)
{
xfree(strings) ;
xfree(*lengths) ;
free(strings) ;
free(*lengths) ;
*lengths = NULL ;
return NULL;
}
@ -497,7 +497,7 @@ rdpCertificateData* crypto_get_certificate_data(X509* xcert, char* hostname)
fp = crypto_cert_fingerprint(xcert);
certdata = certificate_data_new(hostname, fp);
xfree(fp);
free(fp);
return certdata;
}
@ -520,9 +520,9 @@ void crypto_cert_print_info(X509* xcert)
"the CA certificate in your certificate store, or the certificate has expired. "
"Please look at the documentation on how to create local certificate store for a private CA.\n");
xfree(subject);
xfree(issuer);
xfree(fp);
free(subject);
free(issuer);
free(fp);
}
char* crypto_base64_encode(uint8* data, int length)
@ -543,7 +543,7 @@ char* crypto_base64_encode(uint8* data, int length)
BIO_get_mem_ptr(b64, &bptr);
base64_string = xmalloc(bptr->length);
base64_string = malloc(bptr->length);
memcpy(base64_string, bptr->data, bptr->length - 1);
base64_string[bptr->length - 1] = '\0';
@ -556,7 +556,7 @@ void crypto_base64_decode(uint8* enc_data, int length, uint8** dec_data, int* re
{
BIO *b64, *bmem;
*dec_data = xmalloc(length);
*dec_data = malloc(length);
memset(*dec_data, 0, length);
b64 = BIO_new(BIO_f_base64());

22
libfreerdp/crypto/tls.c
View File

@ -43,7 +43,7 @@ static CryptoCert tls_get_certificate(rdpTls* tls, boolean peer)
}
else
{
cert = xmalloc(sizeof(*cert));
cert = malloc(sizeof(*cert));
cert->px509 = server_cert;
}
@ -53,7 +53,7 @@ static CryptoCert tls_get_certificate(rdpTls* tls, boolean peer)
static void tls_free_certificate(CryptoCert cert)
{
X509_free(cert->px509);
xfree(cert);
free(cert);
}
boolean tls_connect(rdpTls* tls)
@ -241,7 +241,7 @@ boolean tls_accept(rdpTls* tls, const char* cert_file, const char* privatekey_fi
return false;
}
xfree(cert);
free(cert);
if (SSL_set_fd(tls->ssl, tls->sockfd) < 1)
{
@ -476,7 +476,7 @@ boolean tls_verify_certificate(rdpTls* tls, CryptoCert cert, char* hostname)
{
if (common_name)
{
xfree(common_name);
free(common_name);
common_name = NULL;
}
@ -550,16 +550,16 @@ boolean tls_verify_certificate(rdpTls* tls, CryptoCert cert, char* hostname)
verification_status = true; /* success! */
}
xfree(issuer);
xfree(subject);
xfree(fingerprint);
free(issuer);
free(subject);
free(fingerprint);
}
if (certificate_data)
{
xfree(certificate_data->fingerprint);
xfree(certificate_data->hostname);
xfree(certificate_data);
free(certificate_data->fingerprint);
free(certificate_data->hostname);
free(certificate_data);
}
return verification_status;
@ -644,6 +644,6 @@ void tls_free(rdpTls* tls)
certificate_store_free(tls->certificate_store);
xfree(tls);
free(tls);
}
}

6
libfreerdp/gdi/bitmap.c
View File

@ -136,7 +136,7 @@ INLINE void gdi_SetPixel_32bpp(HGDI_BITMAP hBmp, int X, int Y, uint32 pixel)
HGDI_BITMAP gdi_CreateBitmap(int nWidth, int nHeight, int cBitsPerPixel, uint8* data)
{
HGDI_BITMAP hBitmap = (HGDI_BITMAP) xmalloc(sizeof(GDI_BITMAP));
HGDI_BITMAP hBitmap = (HGDI_BITMAP) malloc(sizeof(GDI_BITMAP));
hBitmap->objectType = GDIOBJECT_BITMAP;
hBitmap->bitsPerPixel = cBitsPerPixel;
hBitmap->bytesPerPixel = (cBitsPerPixel + 1) / 8;
@ -158,13 +158,13 @@ HGDI_BITMAP gdi_CreateBitmap(int nWidth, int nHeight, int cBitsPerPixel, uint8*
HGDI_BITMAP gdi_CreateCompatibleBitmap(HGDI_DC hdc, int nWidth, int nHeight)
{
HGDI_BITMAP hBitmap = (HGDI_BITMAP) xmalloc(sizeof(GDI_BITMAP));
HGDI_BITMAP hBitmap = (HGDI_BITMAP) malloc(sizeof(GDI_BITMAP));
hBitmap->objectType = GDIOBJECT_BITMAP;
hBitmap->bytesPerPixel = hdc->bytesPerPixel;
hBitmap->bitsPerPixel = hdc->bitsPerPixel;
hBitmap->width = nWidth;
hBitmap->height = nHeight;
hBitmap->data = xmalloc(nWidth * nHeight * hBitmap->bytesPerPixel);
hBitmap->data = malloc(nWidth * nHeight * hBitmap->bytesPerPixel);
hBitmap->scanline = nWidth * hBitmap->bytesPerPixel;
return hBitmap;
}

Some files were not shown because too many files have changed in this diff Show More