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

libfreerdp-utils: removing mutex util in favor of WinPR mutex API

This commit is contained in:
Marc-André Moreau 2012-09-18 17:33:52 -04:00
parent 78723f019f
commit 13dbbb9513
22 changed files with 259 additions and 317 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

48
channels/drdynvc/tsmf/tsmf_media.c
View File

@ -39,11 +39,12 @@
#include <freerdp/utils/stream.h> #include <freerdp/utils/stream.h>
#include <freerdp/utils/list.h> #include <freerdp/utils/list.h>
#include <freerdp/utils/thread.h> #include <freerdp/utils/thread.h>
#include <freerdp/utils/mutex.h>
#include <freerdp/utils/event.h> #include <freerdp/utils/event.h>
#include <freerdp/utils/sleep.h> #include <freerdp/utils/sleep.h>
#include <freerdp/plugins/tsmf.h> #include <freerdp/plugins/tsmf.h>
#include <winpr/synch.h>
#include "drdynvc_types.h" #include "drdynvc_types.h"
#include "tsmf_constants.h" #include "tsmf_constants.h"
#include "tsmf_types.h" #include "tsmf_types.h"
@ -82,8 +83,8 @@ struct _TSMF_PRESENTATION
uint64 audio_start_time; uint64 audio_start_time;
uint64 audio_end_time; uint64 audio_end_time;
/* The stream list could be accessed by differnt threads and need to be protected. */ /* The stream list could be accessed by different threads and need to be protected. */
freerdp_mutex mutex; HANDLE mutex;
LIST* stream_list; LIST* stream_list;
}; };
@ -138,7 +139,7 @@ struct _TSMF_SAMPLE
static LIST* presentation_list = NULL; static LIST* presentation_list = NULL;
static uint64 last_played_audio_time = 0; static uint64 last_played_audio_time = 0;
static pthread_mutex_t tsmf_mutex = PTHREAD_MUTEX_INITIALIZER; static HANDLE tsmf_mutex = NULL;
static int TERMINATING = 0; static int TERMINATING = 0;
static uint64 get_current_time(void) static uint64 get_current_time(void)
@ -171,10 +172,12 @@ static TSMF_SAMPLE* tsmf_stream_pop_sample(TSMF_STREAM* stream, int sync)
/* Check if some other stream has earlier sample that needs to be played first */ /* Check if some other stream has earlier sample that needs to be played first */
if (stream->last_end_time > AUDIO_TOLERANCE) if (stream->last_end_time > AUDIO_TOLERANCE)
{ {
freerdp_mutex_lock(presentation->mutex); WaitForSingleObject(presentation->mutex, INFINITE);
for (item = presentation->stream_list->head; item; item = item->next) for (item = presentation->stream_list->head; item; item = item->next)
{ {
s = (TSMF_STREAM*) item->data; s = (TSMF_STREAM*) item->data;
if (s != stream && !s->eos && s->last_end_time && if (s != stream && !s->eos && s->last_end_time &&
s->last_end_time < stream->last_end_time - AUDIO_TOLERANCE) s->last_end_time < stream->last_end_time - AUDIO_TOLERANCE)
{ {
@ -182,7 +185,8 @@ static TSMF_SAMPLE* tsmf_stream_pop_sample(TSMF_STREAM* stream, int sync)
break; break;
} }
} }
freerdp_mutex_unlock(presentation->mutex);
ReleaseMutex(presentation->mutex);
} }
} }
else else
@ -273,7 +277,7 @@ TSMF_PRESENTATION* tsmf_presentation_new(const uint8* guid, IWTSVirtualChannelCa
memcpy(presentation->presentation_id, guid, GUID_SIZE); memcpy(presentation->presentation_id, guid, GUID_SIZE);
presentation->channel_callback = pChannelCallback; presentation->channel_callback = pChannelCallback;
presentation->mutex = freerdp_mutex_new(); presentation->mutex = CreateMutex(NULL, FALSE, NULL);
presentation->stream_list = list_new(); presentation->stream_list = list_new();
list_enqueue(presentation_list, presentation); list_enqueue(presentation_list, presentation);
@ -891,9 +895,9 @@ void tsmf_presentation_free(TSMF_PRESENTATION* presentation)
TSMF_STREAM* stream; TSMF_STREAM* stream;
tsmf_presentation_stop(presentation); tsmf_presentation_stop(presentation);
freerdp_mutex_lock(presentation->mutex); WaitForSingleObject(presentation->mutex, INFINITE);
list_remove(presentation_list, presentation); list_remove(presentation_list, presentation);
freerdp_mutex_unlock(presentation->mutex); ReleaseMutex(presentation->mutex);
while (list_size(presentation->stream_list) > 0) while (list_size(presentation->stream_list) > 0)
{ {
@ -902,7 +906,7 @@ void tsmf_presentation_free(TSMF_PRESENTATION* presentation)
} }
list_free(presentation->stream_list); list_free(presentation->stream_list);
freerdp_mutex_free(presentation->mutex); CloseHandle(presentation->mutex);
xfree(presentation); xfree(presentation);
} }
@ -926,9 +930,9 @@ TSMF_STREAM* tsmf_stream_new(TSMF_PRESENTATION* presentation, uint32 stream_id)
stream->sample_list = list_new(); stream->sample_list = list_new();
stream->sample_ack_list = list_new(); stream->sample_ack_list = list_new();
freerdp_mutex_lock(presentation->mutex); WaitForSingleObject(presentation->mutex, INFINITE);
list_enqueue(presentation->stream_list, stream); list_enqueue(presentation->stream_list, stream);
freerdp_mutex_unlock(presentation->mutex); ReleaseMutex(presentation->mutex);
return stream; return stream;
} }
@ -997,9 +1001,9 @@ void tsmf_stream_free(TSMF_STREAM* stream)
tsmf_stream_stop(stream); tsmf_stream_stop(stream);
tsmf_stream_flush(stream); tsmf_stream_flush(stream);
freerdp_mutex_lock(presentation->mutex); WaitForSingleObject(presentation->mutex, INFINITE);
list_remove(presentation->stream_list, stream); list_remove(presentation->stream_list, stream);
freerdp_mutex_unlock(presentation->mutex); ReleaseMutex(presentation->mutex);
list_free(stream->sample_list); list_free(stream->sample_list);
list_free(stream->sample_ack_list); list_free(stream->sample_ack_list);
@ -1022,15 +1026,15 @@ void tsmf_stream_push_sample(TSMF_STREAM* stream, IWTSVirtualChannelCallback* pC
{ {
TSMF_SAMPLE* sample; TSMF_SAMPLE* sample;
pthread_mutex_lock(&tsmf_mutex); WaitForSingleObject(tsmf_mutex, INFINITE);
if (TERMINATING) if (TERMINATING)
{ {
pthread_mutex_unlock(&tsmf_mutex); ReleaseMutex(tsmf_mutex);
return; return;
} }
pthread_mutex_unlock(&tsmf_mutex); ReleaseMutex(tsmf_mutex);
sample = xnew(TSMF_SAMPLE); sample = xnew(TSMF_SAMPLE);
@ -1054,13 +1058,15 @@ void tsmf_stream_push_sample(TSMF_STREAM* stream, IWTSVirtualChannelCallback* pC
static void tsmf_signal_handler(int s) static void tsmf_signal_handler(int s)
{ {
pthread_mutex_lock(&tsmf_mutex);
TERMINATING = 1;
pthread_mutex_unlock(&tsmf_mutex);
LIST_ITEM* p_item; LIST_ITEM* p_item;
TSMF_PRESENTATION* presentation; TSMF_PRESENTATION* presentation;
LIST_ITEM* s_item; LIST_ITEM* s_item;
TSMF_STREAM* _stream; TSMF_STREAM* _stream;
WaitForSingleObject(tsmf_mutex, INFINITE);
TERMINATING = 1;
ReleaseMutex(tsmf_mutex);
if (presentation_list) if (presentation_list)
{ {
for (p_item = presentation_list->head; p_item; p_item = p_item->next) for (p_item = presentation_list->head; p_item; p_item = p_item->next)
@ -1101,6 +1107,8 @@ void tsmf_media_init(void)
sigaction(SIGUSR1, &sigtrap, 0); sigaction(SIGUSR1, &sigtrap, 0);
#endif #endif
tsmf_mutex = CreateMutex(NULL, FALSE, NULL);
if (presentation_list == NULL) if (presentation_list == NULL)
presentation_list = list_new(); presentation_list = list_new();
} }

20
channels/rdpdr/smartcard/scard_main.c
View File

@ -30,7 +30,6 @@
#include <freerdp/utils/list.h> #include <freerdp/utils/list.h>
#include <freerdp/utils/thread.h> #include <freerdp/utils/thread.h>
#include <freerdp/utils/svc_plugin.h> #include <freerdp/utils/svc_plugin.h>
#include <freerdp/utils/mutex.h>
#include <freerdp/utils/debug.h> #include <freerdp/utils/debug.h>
#include "rdpdr_types.h" #include "rdpdr_types.h"
@ -223,12 +222,12 @@ scard_irp_complete(IRP* irp)
stream_set_pos(irp->output, pos); stream_set_pos(irp->output, pos);
/* Begin TS Client defect workaround. */ /* Begin TS Client defect workaround. */
freerdp_mutex_lock(scard->CompletionIdsMutex); WaitForSingleObject(scard->CompletionIdsMutex, INFINITE);
/* Remove from the list the item identified by the CompletionID. /* Remove from the list the item identified by the CompletionID.
* The function returns whether or not it was a duplicate CompletionID. * The function returns whether or not it was a duplicate CompletionID.
*/ */
duplicate = scard_check_for_duplicate_id(scard, irp->CompletionId); duplicate = scard_check_for_duplicate_id(scard, irp->CompletionId);
freerdp_mutex_unlock(scard->CompletionIdsMutex); ReleaseMutex(scard->CompletionIdsMutex);
if (false == duplicate) if (false == duplicate)
{ {
@ -261,10 +260,10 @@ scard_irp_request(DEVICE* device, IRP* irp)
CompletionIdInfo->ID = irp->CompletionId;/* "duplicate" member is set CompletionIdInfo->ID = irp->CompletionId;/* "duplicate" member is set
* to false by "xnew()" * to false by "xnew()"
*/ */
freerdp_mutex_lock(scard->CompletionIdsMutex); WaitForSingleObject(scard->CompletionIdsMutex, INFINITE);
scard_mark_duplicate_id(scard, irp->CompletionId); scard_mark_duplicate_id(scard, irp->CompletionId);
list_enqueue(scard->CompletionIds, CompletionIdInfo); list_enqueue(scard->CompletionIds, CompletionIdInfo);
freerdp_mutex_unlock(scard->CompletionIdsMutex); ReleaseMutex(scard->CompletionIdsMutex);
irp->Complete = scard_irp_complete; /* Overwrite the previous irp->Complete = scard_irp_complete; /* Overwrite the previous
* assignment made in * assignment made in
@ -298,16 +297,15 @@ scard_irp_request(DEVICE* device, IRP* irp)
freerdp_thread_signal(scard->thread); freerdp_thread_signal(scard->thread);
} }
int int DeviceServiceEntry(PDEVICE_SERVICE_ENTRY_POINTS pEntryPoints)
DeviceServiceEntry(PDEVICE_SERVICE_ENTRY_POINTS pEntryPoints)
{ {
SCARD_DEVICE* scard;
char* name; char* name;
char* path; char* path;
int i, length; int i, length;
SCARD_DEVICE* scard;
name = (char *)pEntryPoints->plugin_data->data[1]; name = (char*) pEntryPoints->plugin_data->data[1];
path = (char *)pEntryPoints->plugin_data->data[2]; path = (char*) pEntryPoints->plugin_data->data[2];
if (name) if (name)
{ {
@ -332,7 +330,7 @@ DeviceServiceEntry(PDEVICE_SERVICE_ENTRY_POINTS pEntryPoints)
scard->thread = freerdp_thread_new(); scard->thread = freerdp_thread_new();
scard->CompletionIds = list_new(); scard->CompletionIds = list_new();
scard->CompletionIdsMutex = freerdp_mutex_new(); scard->CompletionIdsMutex = CreateMutex(NULL, FALSE, NULL);
pEntryPoints->RegisterDevice(pEntryPoints->devman, (DEVICE *)scard); pEntryPoints->RegisterDevice(pEntryPoints->devman, (DEVICE *)scard);

6
channels/rdpdr/smartcard/scard_main.h
View File

@ -25,10 +25,12 @@
#include "devman.h" #include "devman.h"
#include "rdpdr_types.h" #include "rdpdr_types.h"
#include <freerdp/utils/mutex.h> /* For CompletionIdsMutex */
#include <freerdp/utils/list.h> #include <freerdp/utils/list.h>
#include <freerdp/utils/debug.h> #include <freerdp/utils/debug.h>
#include <winpr/synch.h>
/* /*
* When using Windows Server 2008 R2 as the Terminal Services (TS) * When using Windows Server 2008 R2 as the Terminal Services (TS)
* server, and with a smart card reader connected to the TS client machine * server, and with a smart card reader connected to the TS client machine
@ -105,7 +107,7 @@ struct _SCARD_DEVICE
freerdp_thread* thread; freerdp_thread* thread;
LIST* CompletionIds; LIST* CompletionIds;
freerdp_mutex CompletionIdsMutex; /* Protect the LIST from HANDLE CompletionIdsMutex; /* Protect the LIST from
* multiple thread writers. * multiple thread writers.
*/ */
}; };

12
cunit/test_utils.c
View File

@ -29,7 +29,6 @@
#include <termios.h> #include <termios.h>
#include <unistd.h> #include <unistd.h>
#include <freerdp/freerdp.h> #include <freerdp/freerdp.h>
#include <freerdp/utils/mutex.h>
#include <freerdp/utils/semaphore.h> #include <freerdp/utils/semaphore.h>
#include <freerdp/utils/load_plugin.h> #include <freerdp/utils/load_plugin.h>
#include <freerdp/utils/wait_obj.h> #include <freerdp/utils/wait_obj.h>
@ -54,7 +53,6 @@ int add_utils_suite(void)
{ {
add_test_suite(utils); add_test_suite(utils);
add_test_function(mutex);
add_test_function(semaphore); add_test_function(semaphore);
add_test_function(load_plugin); add_test_function(load_plugin);
add_test_function(wait_obj); add_test_function(wait_obj);
@ -65,16 +63,6 @@ int add_utils_suite(void)
return 0; return 0;
} }
void test_mutex(void)
{
freerdp_mutex mutex;
mutex = freerdp_mutex_new();
freerdp_mutex_lock(mutex);
freerdp_mutex_unlock(mutex);
freerdp_mutex_free(mutex);
}
void test_semaphore(void) void test_semaphore(void)
{ {
freerdp_sem sem; freerdp_sem sem;

1
cunit/test_utils.h
View File

@ -23,7 +23,6 @@ int init_utils_suite(void);
int clean_utils_suite(void); int clean_utils_suite(void);
int add_utils_suite(void); int add_utils_suite(void);
void test_mutex(void);
void test_semaphore(void); void test_semaphore(void);
void test_load_plugin(void); void test_load_plugin(void);
void test_wait_obj(void); void test_wait_obj(void);

32
include/freerdp/utils/mutex.h
View File

@ -1,32 +0,0 @@
/**
* FreeRDP: A Remote Desktop Protocol Client
* Mutex Utils
*
* Copyright 2011 Vic Lee
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef __MUTEX_UTILS_H
#define __MUTEX_UTILS_H
#include <freerdp/api.h>
typedef void* freerdp_mutex;
FREERDP_API freerdp_mutex freerdp_mutex_new(void);
FREERDP_API void freerdp_mutex_free(freerdp_mutex mutex);
FREERDP_API void freerdp_mutex_lock(freerdp_mutex mutex);
FREERDP_API void freerdp_mutex_unlock(freerdp_mutex mutex);
#endif /* __MUTEX_UTILS_H */

9
include/freerdp/utils/thread.h
View File

@ -22,17 +22,18 @@
#include <freerdp/api.h> #include <freerdp/api.h>
#include <freerdp/types.h> #include <freerdp/types.h>
#include <freerdp/utils/mutex.h>
#include <freerdp/utils/wait_obj.h> #include <freerdp/utils/wait_obj.h>
#ifndef _WIN32 #ifndef _WIN32
#include <pthread.h> #include <pthread.h>
#endif #endif
#include <winpr/synch.h>
typedef struct _freerdp_thread freerdp_thread; typedef struct _freerdp_thread freerdp_thread;
struct _freerdp_thread struct _freerdp_thread
{ {
freerdp_mutex* mutex; HANDLE mutex;
struct wait_obj* signals[5]; struct wait_obj* signals[5];
int num_signals; int num_signals;
@ -54,7 +55,7 @@ FREERDP_API void freerdp_thread_free(freerdp_thread* thread);
wait_obj_clear(_t->signals[0]); } while (0) wait_obj_clear(_t->signals[0]); } while (0)
#define freerdp_thread_signal(_t) wait_obj_set(_t->signals[1]) #define freerdp_thread_signal(_t) wait_obj_set(_t->signals[1])
#define freerdp_thread_reset(_t) wait_obj_clear(_t->signals[1]) #define freerdp_thread_reset(_t) wait_obj_clear(_t->signals[1])
#define freerdp_thread_lock(_t) freerdp_mutex_lock(_t->mutex) #define freerdp_thread_lock(_t) WaitForSingleObject(_t->mutex, INFINITE)
#define freerdp_thread_unlock(_t) freerdp_mutex_unlock(_t->mutex) #define freerdp_thread_unlock(_t) ReleaseMutex(_t->mutex)
#endif /* __THREAD_UTILS_H */ #endif /* __THREAD_UTILS_H */

4
libfreerdp/channels/CMakeLists.txt
View File

@ -34,11 +34,15 @@ set_target_properties(freerdp-channels PROPERTIES VERSION ${FREERDP_VERSION_FULL
set(FREERDP_CHANNELS_LIBS) set(FREERDP_CHANNELS_LIBS)
if(WITH_MONOLITHIC_BUILD) if(WITH_MONOLITHIC_BUILD)
set(FREERDP_CHANNELS_LIBS ${FREERDP_CHANNELS_LIBS} winpr)
set(FREERDP_LIBS ${FREERDP_LIBS} ${FREERDP_CHANNELS_LIBS} PARENT_SCOPE) set(FREERDP_LIBS ${FREERDP_LIBS} ${FREERDP_CHANNELS_LIBS} PARENT_SCOPE)
else() else()
set(FREERDP_CHANNELS_LIBS ${FREERDP_CHANNELS_LIBS} set(FREERDP_CHANNELS_LIBS ${FREERDP_CHANNELS_LIBS}
freerdp-utils) freerdp-utils)
set(FREERDP_CHANNELS_LIBS ${FREERDP_CHANNELS_LIBS}
winpr-synch)
target_link_libraries(freerdp-channels ${FREERDP_CHANNELS_LIBS}) target_link_libraries(freerdp-channels ${FREERDP_CHANNELS_LIBS})
install(TARGETS freerdp-channels DESTINATION ${CMAKE_INSTALL_LIBDIR}) install(TARGETS freerdp-channels DESTINATION ${CMAKE_INSTALL_LIBDIR})
endif() endif()

63
libfreerdp/channels/libchannels.c
View File

@ -47,11 +47,12 @@
#include <freerdp/utils/memory.h> #include <freerdp/utils/memory.h>
#include <freerdp/utils/list.h> #include <freerdp/utils/list.h>
#include <freerdp/utils/semaphore.h> #include <freerdp/utils/semaphore.h>
#include <freerdp/utils/mutex.h>
#include <freerdp/utils/wait_obj.h> #include <freerdp/utils/wait_obj.h>
#include <freerdp/utils/load_plugin.h> #include <freerdp/utils/load_plugin.h>
#include <freerdp/utils/event.h> #include <freerdp/utils/event.h>
#include <winpr/synch.h>
#include "libchannels.h" #include "libchannels.h"
#define CHANNEL_MAX_COUNT 30 #define CHANNEL_MAX_COUNT 30
@ -120,7 +121,7 @@ struct rdp_channels
struct wait_obj* signal; struct wait_obj* signal;
/* used for sync write */ /* used for sync write */
freerdp_mutex sync_data_mutex; HANDLE sync_data_mutex;
LIST* sync_data_list; LIST* sync_data_list;
/* used for sync event */ /* used for sync event */
@ -148,8 +149,8 @@ static rdpChannelsList* g_channels_list;
static int g_open_handle_sequence; static int g_open_handle_sequence;
/* For locking the global resources */ /* For locking the global resources */
static freerdp_mutex g_mutex_init; static HANDLE g_mutex_init;
static freerdp_mutex g_mutex_list; static HANDLE g_mutex_list;
/* returns the channels for the open handle passed in */ /* returns the channels for the open handle passed in */
static rdpChannels* freerdp_channels_find_by_open_handle(int open_handle, int* pindex) static rdpChannels* freerdp_channels_find_by_open_handle(int open_handle, int* pindex)
@ -158,7 +159,7 @@ static rdpChannels* freerdp_channels_find_by_open_handle(int open_handle, int* p
rdpChannels* channels; rdpChannels* channels;
rdpChannelsList* channels_list; rdpChannelsList* channels_list;
freerdp_mutex_lock(g_mutex_list); WaitForSingleObject(g_mutex_list, INFINITE);
for (channels_list = g_channels_list; channels_list; channels_list = channels_list->next) for (channels_list = g_channels_list; channels_list; channels_list = channels_list->next)
{ {
@ -168,14 +169,14 @@ static rdpChannels* freerdp_channels_find_by_open_handle(int open_handle, int* p
{ {
if (channels->channels_data[lindex].open_handle == open_handle) if (channels->channels_data[lindex].open_handle == open_handle)
{ {
freerdp_mutex_unlock(g_mutex_list); ReleaseMutex(g_mutex_list);
*pindex = lindex; *pindex = lindex;
return channels; return channels;
} }
} }
} }
freerdp_mutex_unlock(g_mutex_list); ReleaseMutex(g_mutex_list);
return NULL; return NULL;
} }
@ -186,19 +187,19 @@ static rdpChannels* freerdp_channels_find_by_instance(freerdp* instance)
rdpChannels* channels; rdpChannels* channels;
rdpChannelsList* channels_list; rdpChannelsList* channels_list;
freerdp_mutex_lock(g_mutex_list); WaitForSingleObject(g_mutex_list, INFINITE);
for (channels_list = g_channels_list; channels_list; channels_list = channels_list->next) for (channels_list = g_channels_list; channels_list; channels_list = channels_list->next)
{ {
channels = channels_list->channels; channels = channels_list->channels;
if (channels->instance == instance) if (channels->instance == instance)
{ {
freerdp_mutex_unlock(g_mutex_list); ReleaseMutex(g_mutex_list);
return channels; return channels;
} }
} }
freerdp_mutex_unlock(g_mutex_list); ReleaseMutex(g_mutex_list);
return NULL; return NULL;
} }
@ -353,9 +354,9 @@ static uint32 FREERDP_CC MyVirtualChannelInit(void** ppInitHandle, PCHANNEL_DEF
lchannel_def = pChannel + index; lchannel_def = pChannel + index;
lchannel_data = channels->channels_data + channels->num_channels_data; lchannel_data = channels->channels_data + channels->num_channels_data;
freerdp_mutex_lock(g_mutex_list); WaitForSingleObject(g_mutex_list, INFINITE);
lchannel_data->open_handle = g_open_handle_sequence++; lchannel_data->open_handle = g_open_handle_sequence++;
freerdp_mutex_unlock(g_mutex_list); ReleaseMutex(g_mutex_list);
lchannel_data->flags = 1; /* init */ lchannel_data->flags = 1; /* init */
strncpy(lchannel_data->name, lchannel_def->name, CHANNEL_NAME_LEN); strncpy(lchannel_data->name, lchannel_def->name, CHANNEL_NAME_LEN);
@ -508,11 +509,11 @@ static uint32 FREERDP_CC MyVirtualChannelWrite(uint32 openHandle, void* pData, u
return CHANNEL_RC_NOT_OPEN; return CHANNEL_RC_NOT_OPEN;
} }
freerdp_mutex_lock(channels->sync_data_mutex); /* lock channels->sync* vars */ WaitForSingleObject(channels->sync_data_mutex, INFINITE); /* lock channels->sync* vars */
if (!channels->is_connected) if (!channels->is_connected)
{ {
freerdp_mutex_unlock(channels->sync_data_mutex); ReleaseMutex(channels->sync_data_mutex);
DEBUG_CHANNELS("error not connected"); DEBUG_CHANNELS("error not connected");
return CHANNEL_RC_NOT_CONNECTED; return CHANNEL_RC_NOT_CONNECTED;
} }
@ -523,7 +524,7 @@ static uint32 FREERDP_CC MyVirtualChannelWrite(uint32 openHandle, void* pData, u
item->user_data = pUserData; item->user_data = pUserData;
item->index = index; item->index = index;
list_enqueue(channels->sync_data_list, item); list_enqueue(channels->sync_data_list, item);
freerdp_mutex_unlock(channels->sync_data_mutex); ReleaseMutex(channels->sync_data_mutex);
/* set the event */ /* set the event */
wait_obj_set(channels->signal); wait_obj_set(channels->signal);
@ -591,8 +592,8 @@ int freerdp_channels_global_init(void)
g_init_channels = NULL; g_init_channels = NULL;
g_channels_list = NULL; g_channels_list = NULL;
g_open_handle_sequence = 1; g_open_handle_sequence = 1;
g_mutex_init = freerdp_mutex_new(); g_mutex_init = CreateMutex(NULL, FALSE, NULL);
g_mutex_list = freerdp_mutex_new(); g_mutex_list = CreateMutex(NULL, FALSE, NULL);
return 0; return 0;
} }
@ -602,8 +603,8 @@ int freerdp_channels_global_uninit(void)
while (g_channels_list) while (g_channels_list)
freerdp_channels_free(g_channels_list->channels); freerdp_channels_free(g_channels_list->channels);
freerdp_mutex_free(g_mutex_init); CloseHandle(g_mutex_init);
freerdp_mutex_free(g_mutex_list); CloseHandle(g_mutex_list);
return 0; return 0;
} }
@ -615,7 +616,7 @@ rdpChannels* freerdp_channels_new(void)
channels = xnew(rdpChannels); channels = xnew(rdpChannels);
channels->sync_data_mutex = freerdp_mutex_new(); channels->sync_data_mutex = CreateMutex(NULL, FALSE, NULL);
channels->sync_data_list = list_new(); channels->sync_data_list = list_new();
channels->event_sem = freerdp_sem_new(1); channels->event_sem = freerdp_sem_new(1);
@ -625,10 +626,10 @@ rdpChannels* freerdp_channels_new(void)
channels_list = xnew(rdpChannelsList); channels_list = xnew(rdpChannelsList);
channels_list->channels = channels; channels_list->channels = channels;
freerdp_mutex_lock(g_mutex_list); WaitForSingleObject(g_mutex_list, INFINITE);
channels_list->next = g_channels_list; channels_list->next = g_channels_list;
g_channels_list = channels_list; g_channels_list = channels_list;
freerdp_mutex_unlock(g_mutex_list); ReleaseMutex(g_mutex_list);
return channels; return channels;
} }
@ -638,7 +639,7 @@ void freerdp_channels_free(rdpChannels* channels)
rdpChannelsList* list; rdpChannelsList* list;
rdpChannelsList* prev; rdpChannelsList* prev;
freerdp_mutex_free(channels->sync_data_mutex); CloseHandle(channels->sync_data_mutex);
list_free(channels->sync_data_list); list_free(channels->sync_data_list);
freerdp_sem_free(channels->event_sem); freerdp_sem_free(channels->event_sem);
@ -646,7 +647,7 @@ void freerdp_channels_free(rdpChannels* channels)
/* Remove from global list */ /* Remove from global list */
freerdp_mutex_lock(g_mutex_list); WaitForSingleObject(g_mutex_list, INFINITE);
for (prev = NULL, list = g_channels_list; list; prev = list, list = list->next) for (prev = NULL, list = g_channels_list; list; prev = list, list = list->next)
{ {
@ -663,7 +664,7 @@ void freerdp_channels_free(rdpChannels* channels)
xfree(list); xfree(list);
} }
freerdp_mutex_unlock(g_mutex_list); ReleaseMutex(g_mutex_list);
xfree(channels); xfree(channels);
} }
@ -709,13 +710,13 @@ int freerdp_channels_load_plugin(rdpChannels* channels, rdpSettings* settings, c
channels->can_call_init = 1; channels->can_call_init = 1;
channels->settings = settings; channels->settings = settings;
freerdp_mutex_lock(g_mutex_init); WaitForSingleObject(g_mutex_init, INFINITE);
g_init_channels = channels; g_init_channels = channels;
ok = lib->entry((PCHANNEL_ENTRY_POINTS) &ep); ok = lib->entry((PCHANNEL_ENTRY_POINTS) &ep);
g_init_channels = NULL; g_init_channels = NULL;
freerdp_mutex_unlock(g_mutex_init); ReleaseMutex(g_mutex_init);
/* disable MyVirtualChannelInit */ /* disable MyVirtualChannelInit */
channels->settings = 0; channels->settings = 0;
@ -757,12 +758,12 @@ int freerdp_channels_pre_connect(rdpChannels* channels, freerdp* instance)
strcpy(lchannel_def.name, "rdpdr"); strcpy(lchannel_def.name, "rdpdr");
channels->can_call_init = 1; channels->can_call_init = 1;
channels->settings = instance->settings; channels->settings = instance->settings;
freerdp_mutex_lock(g_mutex_init); WaitForSingleObject(g_mutex_init, INFINITE);
g_init_channels = channels; g_init_channels = channels;
MyVirtualChannelInit(&dummy, &lchannel_def, 1, MyVirtualChannelInit(&dummy, &lchannel_def, 1,
VIRTUAL_CHANNEL_VERSION_WIN2000, 0); VIRTUAL_CHANNEL_VERSION_WIN2000, 0);
g_init_channels = NULL; g_init_channels = NULL;
freerdp_mutex_unlock(g_mutex_init); ReleaseMutex(g_mutex_init);
channels->can_call_init = 0; channels->can_call_init = 0;
channels->settings = 0; channels->settings = 0;
DEBUG_CHANNELS("registered fake rdpdr for rdpsnd."); DEBUG_CHANNELS("registered fake rdpdr for rdpsnd.");
@ -912,9 +913,9 @@ static void freerdp_channels_process_sync(rdpChannels* channels, freerdp* instan
while (list_size(channels->sync_data_list) > 0) while (list_size(channels->sync_data_list) > 0)
{ {
freerdp_mutex_lock(channels->sync_data_mutex); WaitForSingleObject(channels->sync_data_mutex, INFINITE);
item = (struct sync_data*)list_dequeue(channels->sync_data_list); item = (struct sync_data*)list_dequeue(channels->sync_data_list);
freerdp_mutex_unlock(channels->sync_data_mutex); ReleaseMutex(channels->sync_data_mutex);
if (!item) if (!item)
break ; break ;

52
libfreerdp/channels/wtsvc.c
View File

@ -24,9 +24,12 @@
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>
#include <freerdp/constants.h> #include <freerdp/constants.h>
#include <freerdp/utils/memory.h> #include <freerdp/utils/memory.h>
#include <winpr/synch.h>
#include "wtsvc.h" #include "wtsvc.h"
#define CREATE_REQUEST_PDU 0x01 #define CREATE_REQUEST_PDU 0x01
@ -56,6 +59,7 @@ static rdpPeerChannel* wts_get_dvc_channel_by_id(WTSVirtualChannelManager* vcm,
for (item = vcm->dvc_channel_list->head; item; item = item->next) for (item = vcm->dvc_channel_list->head; item; item = item->next)
{ {
channel = (rdpPeerChannel*) item->data; channel = (rdpPeerChannel*) item->data;
if (channel->channel_id == ChannelId) if (channel->channel_id == ChannelId)
break; break;
} }
@ -72,9 +76,9 @@ static void wts_queue_receive_data(rdpPeerChannel* channel, const uint8* buffer,
item->buffer = xmalloc(length); item->buffer = xmalloc(length);
memcpy(item->buffer, buffer, length); memcpy(item->buffer, buffer, length);
freerdp_mutex_lock(channel->mutex); WaitForSingleObject(channel->mutex, INFINITE);
list_enqueue(channel->receive_queue, item); list_enqueue(channel->receive_queue, item);
freerdp_mutex_unlock(channel->mutex); ReleaseMutex(channel->mutex);
wait_obj_set(channel->receive_event); wait_obj_set(channel->receive_event);
} }
@ -87,9 +91,9 @@ static void wts_queue_send_item(rdpPeerChannel* channel, wts_data_item* item)
item->channel_id = channel->channel_id; item->channel_id = channel->channel_id;
freerdp_mutex_lock(vcm->mutex); WaitForSingleObject(vcm->mutex, INFINITE);
list_enqueue(vcm->send_queue, item); list_enqueue(vcm->send_queue, item);
freerdp_mutex_unlock(vcm->mutex); ReleaseMutex(vcm->mutex);
wait_obj_set(vcm->send_event); wait_obj_set(vcm->send_event);
} }
@ -122,6 +126,7 @@ static void wts_read_drdynvc_capabilities_response(rdpPeerChannel* channel, uint
if (length < 3) if (length < 3)
return; return;
stream_seek_uint8(channel->receive_data); /* Pad (1 byte) */ stream_seek_uint8(channel->receive_data); /* Pad (1 byte) */
stream_read_uint16(channel->receive_data, Version); stream_read_uint16(channel->receive_data, Version);
@ -364,12 +369,13 @@ WTSVirtualChannelManager* WTSCreateVirtualChannelManager(freerdp_peer* client)
WTSVirtualChannelManager* vcm; WTSVirtualChannelManager* vcm;
vcm = xnew(WTSVirtualChannelManager); vcm = xnew(WTSVirtualChannelManager);
if (vcm != NULL) if (vcm != NULL)
{ {
vcm->client = client; vcm->client = client;
vcm->send_event = wait_obj_new(); vcm->send_event = wait_obj_new();
vcm->send_queue = list_new(); vcm->send_queue = list_new();
vcm->mutex = freerdp_mutex_new(); vcm->mutex = CreateMutex(NULL, FALSE, NULL);
vcm->dvc_channel_id_seq = 1; vcm->dvc_channel_id_seq = 1;
vcm->dvc_channel_list = list_new(); vcm->dvc_channel_list = list_new();
@ -403,7 +409,7 @@ void WTSDestroyVirtualChannelManager(WTSVirtualChannelManager* vcm)
wts_data_item_free(item); wts_data_item_free(item);
} }
list_free(vcm->send_queue); list_free(vcm->send_queue);
freerdp_mutex_free(vcm->mutex); CloseHandle(vcm->mutex);
xfree(vcm); xfree(vcm);
} }
} }
@ -441,18 +447,22 @@ boolean WTSVirtualChannelManagerCheckFileDescriptor(WTSVirtualChannelManager* vc
wait_obj_clear(vcm->send_event); wait_obj_clear(vcm->send_event);
freerdp_mutex_lock(vcm->mutex); WaitForSingleObject(vcm->mutex, INFINITE);
while ((item = (wts_data_item*) list_dequeue(vcm->send_queue)) != NULL) while ((item = (wts_data_item*) list_dequeue(vcm->send_queue)) != NULL)
{ {
if (vcm->client->SendChannelData(vcm->client, item->channel_id, item->buffer, item->length) == false) if (vcm->client->SendChannelData(vcm->client, item->channel_id, item->buffer, item->length) == false)
{ {
result = false; result = false;
} }
wts_data_item_free(item); wts_data_item_free(item);
if (result == false) if (result == false)
break; break;
} }
freerdp_mutex_unlock(vcm->mutex);
ReleaseMutex(vcm->mutex);
return result; return result;
} }
@ -483,12 +493,12 @@ void* WTSVirtualChannelOpenEx(
channel->receive_data = stream_new(client->settings->vc_chunk_size); channel->receive_data = stream_new(client->settings->vc_chunk_size);
channel->receive_event = wait_obj_new(); channel->receive_event = wait_obj_new();
channel->receive_queue = list_new(); channel->receive_queue = list_new();
channel->mutex = freerdp_mutex_new(); channel->mutex = CreateMutex(NULL, FALSE, NULL);
freerdp_mutex_lock(vcm->mutex); WaitForSingleObject(vcm->mutex, INFINITE);
channel->channel_id = vcm->dvc_channel_id_seq++; channel->channel_id = vcm->dvc_channel_id_seq++;
list_enqueue(vcm->dvc_channel_list, channel); list_enqueue(vcm->dvc_channel_list, channel);
freerdp_mutex_unlock(vcm->mutex); ReleaseMutex(vcm->mutex);
s = stream_new(64); s = stream_new(64);
wts_write_drdynvc_create_request(s, channel->channel_id, pVirtualName); wts_write_drdynvc_create_request(s, channel->channel_id, pVirtualName);
@ -500,6 +510,7 @@ void* WTSVirtualChannelOpenEx(
else else
{ {
len = strlen(pVirtualName); len = strlen(pVirtualName);
if (len > 8) if (len > 8)
return NULL; return NULL;
@ -511,10 +522,12 @@ void* WTSVirtualChannelOpenEx(
break; break;
} }
} }
if (i >= client->settings->num_channels) if (i >= client->settings->num_channels)
return NULL; return NULL;
channel = (rdpPeerChannel*) client->settings->channels[i].handle; channel = (rdpPeerChannel*) client->settings->channels[i].handle;
if (channel == NULL) if (channel == NULL)
{ {
channel = xnew(rdpPeerChannel); channel = xnew(rdpPeerChannel);
@ -526,7 +539,7 @@ void* WTSVirtualChannelOpenEx(
channel->receive_data = stream_new(client->settings->vc_chunk_size); channel->receive_data = stream_new(client->settings->vc_chunk_size);
channel->receive_event = wait_obj_new(); channel->receive_event = wait_obj_new();
channel->receive_queue = list_new(); channel->receive_queue = list_new();
channel->mutex = freerdp_mutex_new(); channel->mutex = CreateMutex(NULL, FALSE, NULL);
client->settings->channels[i].handle = channel; client->settings->channels[i].handle = channel;
} }
@ -609,22 +622,27 @@ boolean WTSVirtualChannelRead(
rdpPeerChannel* channel = (rdpPeerChannel*) hChannelHandle; rdpPeerChannel* channel = (rdpPeerChannel*) hChannelHandle;
item = (wts_data_item*) list_peek(channel->receive_queue); item = (wts_data_item*) list_peek(channel->receive_queue);
if (item == NULL) if (item == NULL)
{ {
wait_obj_clear(channel->receive_event); wait_obj_clear(channel->receive_event);
*pBytesRead = 0; *pBytesRead = 0;
return true; return true;
} }
*pBytesRead = item->length; *pBytesRead = item->length;
if (item->length > BufferSize) if (item->length > BufferSize)
return false; return false;
/* remove the first element (same as what we just peek) */ /* remove the first element (same as what we just peek) */
freerdp_mutex_lock(channel->mutex); WaitForSingleObject(channel->mutex, INFINITE);
list_dequeue(channel->receive_queue); list_dequeue(channel->receive_queue);
if (list_size(channel->receive_queue) == 0) if (list_size(channel->receive_queue) == 0)
wait_obj_clear(channel->receive_event); wait_obj_clear(channel->receive_event);
freerdp_mutex_unlock(channel->mutex);
ReleaseMutex(channel->mutex);
memcpy(Buffer, item->buffer, item->length); memcpy(Buffer, item->buffer, item->length);
wts_data_item_free(item) ; wts_data_item_free(item) ;
@ -725,9 +743,9 @@ boolean WTSVirtualChannelClose(
} }
else else
{ {
freerdp_mutex_lock(vcm->mutex); WaitForSingleObject(vcm->mutex, INFINITE);
list_remove(vcm->dvc_channel_list, channel); list_remove(vcm->dvc_channel_list, channel);
freerdp_mutex_unlock(vcm->mutex); ReleaseMutex(vcm->mutex);
if (channel->dvc_open_state == DVC_OPEN_STATE_SUCCEEDED) if (channel->dvc_open_state == DVC_OPEN_STATE_SUCCEEDED)
{ {
@ -750,7 +768,7 @@ boolean WTSVirtualChannelClose(
list_free(channel->receive_queue); list_free(channel->receive_queue);
} }
if (channel->mutex) if (channel->mutex)
freerdp_mutex_free(channel->mutex); CloseHandle(channel->mutex);
xfree(channel); xfree(channel);
} }
return true; return true;

7
libfreerdp/channels/wtsvc.h
View File

@ -23,11 +23,12 @@
#include <freerdp/freerdp.h> #include <freerdp/freerdp.h>
#include <freerdp/utils/stream.h> #include <freerdp/utils/stream.h>
#include <freerdp/utils/list.h> #include <freerdp/utils/list.h>
#include <freerdp/utils/mutex.h>
#include <freerdp/utils/debug.h> #include <freerdp/utils/debug.h>
#include <freerdp/utils/wait_obj.h> #include <freerdp/utils/wait_obj.h>
#include <freerdp/channels/wtsvc.h> #include <freerdp/channels/wtsvc.h>
#include <winpr/synch.h>
#ifdef WITH_DEBUG_DVC #ifdef WITH_DEBUG_DVC
#define DEBUG_DVC(fmt, ...) DEBUG_CLASS(DVC, fmt, ## __VA_ARGS__) #define DEBUG_DVC(fmt, ...) DEBUG_CLASS(DVC, fmt, ## __VA_ARGS__)
#else #else
@ -67,7 +68,7 @@ struct rdp_peer_channel
STREAM* receive_data; STREAM* receive_data;
struct wait_obj* receive_event; struct wait_obj* receive_event;
LIST* receive_queue; LIST* receive_queue;
freerdp_mutex mutex; HANDLE mutex;
uint8 dvc_open_state; uint8 dvc_open_state;
uint32 dvc_total_length; uint32 dvc_total_length;
@ -78,7 +79,7 @@ struct WTSVirtualChannelManager
freerdp_peer* client; freerdp_peer* client;
struct wait_obj* send_event; struct wait_obj* send_event;
LIST* send_queue; LIST* send_queue;
freerdp_mutex mutex; HANDLE mutex;
rdpPeerChannel* drdynvc_channel; rdpPeerChannel* drdynvc_channel;
uint8 drdynvc_state; uint8 drdynvc_state;

3
libfreerdp/utils/CMakeLists.txt
View File

@ -31,7 +31,6 @@ set(FREERDP_UTILS_SRCS
file.c file.c
load_plugin.c load_plugin.c
memory.c memory.c
mutex.c
passphrase.c passphrase.c
pcap.c pcap.c
profiler.c profiler.c
@ -72,8 +71,10 @@ if(${CMAKE_SYSTEM_NAME} MATCHES SunOS)
endif() endif()
if(WITH_MONOLITHIC_BUILD) if(WITH_MONOLITHIC_BUILD)
set(FREERDP_UTILS_LIBS ${FREERDP_UTILS_LIBS} winpr)
set(FREERDP_LIBS ${FREERDP_LIBS} ${FREERDP_UTILS_LIBS} PARENT_SCOPE) set(FREERDP_LIBS ${FREERDP_LIBS} ${FREERDP_UTILS_LIBS} PARENT_SCOPE)
else() else()
set(FREERDP_UTILS_LIBS ${FREERDP_UTILS_LIBS} winpr-synch)
target_link_libraries(freerdp-utils ${FREERDP_UTILS_LIBS}) target_link_libraries(freerdp-utils ${FREERDP_UTILS_LIBS})
install(TARGETS freerdp-utils DESTINATION ${CMAKE_INSTALL_LIBDIR}) install(TARGETS freerdp-utils DESTINATION ${CMAKE_INSTALL_LIBDIR})
endif() endif()

114
libfreerdp/utils/mutex.c
View File

@ -1,114 +0,0 @@
/*
* FreeRDP: A Remote Desktop Protocol Client
* Mutex Utils
*
* Copyright 2011 Vic Lee
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include <winpr/windows.h>
#include <freerdp/utils/memory.h>
#include <freerdp/utils/mutex.h>
#ifdef _WIN32
#define freerdp_mutex_t HANDLE
#else
#include <pthread.h>
#define freerdp_mutex_t pthread_mutex_t
#endif
/**
* Mutex are used to prevent concurrent accesses to specific portions of code.
* This funciton and the other freerdp_mutex_*() function are defining a portable API
* to get mutex for both Windows and Linux, where the lower level implementation is very different.
*
* This function creates a new freerdp_mutex object.
* Use freerdp_mutex_lock() to get exclusive ownership of the mutex, and lock a given (protected) portion of code.
* Use freerdp_mutex_unlock() to release your ownership on a mutex.
* Use freerdp_mutex_free() to release the resources associated with the mutex when it is no longer needed.
*
* @return a freerdp_mutex pointer. This should be considered opaque, as the implementation is platform dependent.
* NULL is returned if an allocation or initialization error occurred.
*
* @see pthread documentation for Linux implementation of mutexes
* @see MSDN http://msdn.microsoft.com/en-us/library/windows/desktop/ms682411%28v=vs.85%29.aspx for Windows implementation
*/
freerdp_mutex freerdp_mutex_new(void)
{
#ifdef _WIN32
freerdp_mutex_t mutex;
mutex = CreateMutex(NULL, FALSE, NULL);
return (freerdp_mutex) mutex;
#else
freerdp_mutex_t* mutex;
mutex = xnew(freerdp_mutex_t);
if (mutex)
pthread_mutex_init(mutex, 0);
return mutex;
#endif
}
/**
* This function is used to deallocate all resources associated with a freerdp_mutex object.
*
* @param mutex [in] - Pointer to the mutex that needs to be deallocated.
* On return, this object is not valid anymore.
*/
void freerdp_mutex_free(freerdp_mutex mutex)
{
#ifdef _WIN32
CloseHandle((freerdp_mutex_t) mutex);
#else
pthread_mutex_destroy((freerdp_mutex_t*) mutex);
xfree(mutex);
#endif
}
/**
* Use this function to get exclusive ownership of the mutex.
* This should be called before entering a portion of code that needs to be protected against concurrent accesses.
* Use the freerdp_mutex_unlock() call to release ownership when you leave this protected code.
*
* @param mutex [in] - An initialized freerdp_mutex object, as returned from a call to freerdp_mutex_new().
* This function will suspend the running thread when called, until the mutex is available.
* Only one thread at a time will be allowed to continue execution.
*/
void freerdp_mutex_lock(freerdp_mutex mutex)
{
#ifdef _WIN32
WaitForSingleObject((freerdp_mutex_t) mutex, INFINITE);
#else
pthread_mutex_lock(mutex);
#endif
}
/**
* Use this function to release your ownership on a mutex.
* This should be called when leaving a portion of code that needs to be protected against concurrent accesses.
* DO NOT use this call on a mutex that you do not own. See freerdp_mutex_lock() for getting ownership on a mutex.
*
* @param mutex [in] - Pointer to a mutex that was locked by a call to freerdp_mutex_lock().
*/
void freerdp_mutex_unlock(freerdp_mutex mutex)
{
#ifdef _WIN32
ReleaseMutex((freerdp_mutex_t) mutex);
#else
pthread_mutex_unlock(mutex);
#endif
}

33
libfreerdp/utils/svc_plugin.c
View File

@ -28,7 +28,6 @@
#include <freerdp/constants.h> #include <freerdp/constants.h>
#include <freerdp/utils/memory.h> #include <freerdp/utils/memory.h>
#include <freerdp/utils/mutex.h>
#include <freerdp/utils/debug.h> #include <freerdp/utils/debug.h>
#include <freerdp/utils/stream.h> #include <freerdp/utils/stream.h>
#include <freerdp/utils/list.h> #include <freerdp/utils/list.h>
@ -47,7 +46,7 @@ struct rdp_svc_plugin_list
static rdpSvcPluginList* g_svc_plugin_list = NULL; static rdpSvcPluginList* g_svc_plugin_list = NULL;
/* For locking the global resources */ /* For locking the global resources */
static freerdp_mutex g_mutex = NULL; static HANDLE g_mutex = NULL;
/* Queue for receiving packets */ /* Queue for receiving packets */
struct _svc_data_in_item struct _svc_data_in_item
@ -84,20 +83,24 @@ struct rdp_svc_plugin_private
static rdpSvcPlugin* svc_plugin_find_by_init_handle(void* init_handle) static rdpSvcPlugin* svc_plugin_find_by_init_handle(void* init_handle)
{ {
rdpSvcPluginList * list; rdpSvcPluginList* list;
rdpSvcPlugin * plugin; rdpSvcPlugin* plugin;
WaitForSingleObject(g_mutex, INFINITE);
freerdp_mutex_lock(g_mutex);
for (list = g_svc_plugin_list; list; list = list->next) for (list = g_svc_plugin_list; list; list = list->next)
{ {
plugin = list->plugin; plugin = list->plugin;
if (plugin->priv->init_handle == init_handle) if (plugin->priv->init_handle == init_handle)
{ {
freerdp_mutex_unlock(g_mutex); ReleaseMutex(g_mutex);
return plugin; return plugin;
} }
} }
freerdp_mutex_unlock(g_mutex);
ReleaseMutex(g_mutex);
return NULL; return NULL;
} }
@ -106,17 +109,17 @@ static rdpSvcPlugin* svc_plugin_find_by_open_handle(uint32 open_handle)
rdpSvcPluginList * list; rdpSvcPluginList * list;
rdpSvcPlugin * plugin; rdpSvcPlugin * plugin;
freerdp_mutex_lock(g_mutex); WaitForSingleObject(g_mutex, INFINITE);
for (list = g_svc_plugin_list; list; list = list->next) for (list = g_svc_plugin_list; list; list = list->next)
{ {
plugin = list->plugin; plugin = list->plugin;
if (plugin->priv->open_handle == open_handle) if (plugin->priv->open_handle == open_handle)
{ {
freerdp_mutex_unlock(g_mutex); ReleaseMutex(g_mutex);
return plugin; return plugin;
} }
} }
freerdp_mutex_unlock(g_mutex); ReleaseMutex(g_mutex);
return NULL; return NULL;
} }
@ -126,7 +129,7 @@ static void svc_plugin_remove(rdpSvcPlugin* plugin)
rdpSvcPluginList* prev; rdpSvcPluginList* prev;
/* Remove from global list */ /* Remove from global list */
freerdp_mutex_lock(g_mutex); WaitForSingleObject(g_mutex, INFINITE);
for (prev = NULL, list = g_svc_plugin_list; list; prev = list, list = list->next) for (prev = NULL, list = g_svc_plugin_list; list; prev = list, list = list->next)
{ {
if (list->plugin == plugin) if (list->plugin == plugin)
@ -140,7 +143,7 @@ static void svc_plugin_remove(rdpSvcPlugin* plugin)
g_svc_plugin_list = list->next; g_svc_plugin_list = list->next;
xfree(list); xfree(list);
} }
freerdp_mutex_unlock(g_mutex); ReleaseMutex(g_mutex);
} }
static void svc_plugin_process_received(rdpSvcPlugin* plugin, void* pData, uint32 dataLength, static void svc_plugin_process_received(rdpSvcPlugin* plugin, void* pData, uint32 dataLength,
@ -372,7 +375,7 @@ void svc_plugin_init(rdpSvcPlugin* plugin, CHANNEL_ENTRY_POINTS* pEntryPoints)
* VirtualChannelInit at a time. So this should be safe. * VirtualChannelInit at a time. So this should be safe.
*/ */
if (g_mutex == NULL) if (g_mutex == NULL)
g_mutex = freerdp_mutex_new(); g_mutex = CreateMutex(NULL, FALSE, NULL);
memcpy(&plugin->channel_entry_points, pEntryPoints, pEntryPoints->cbSize); memcpy(&plugin->channel_entry_points, pEntryPoints, pEntryPoints->cbSize);
@ -382,10 +385,10 @@ void svc_plugin_init(rdpSvcPlugin* plugin, CHANNEL_ENTRY_POINTS* pEntryPoints)
list = xnew(rdpSvcPluginList); list = xnew(rdpSvcPluginList);
list->plugin = plugin; list->plugin = plugin;
freerdp_mutex_lock(g_mutex); WaitForSingleObject(g_mutex, INFINITE);
list->next = g_svc_plugin_list; list->next = g_svc_plugin_list;
g_svc_plugin_list = list; g_svc_plugin_list = list;
freerdp_mutex_unlock(g_mutex); ReleaseMutex(g_mutex);
plugin->channel_entry_points.pVirtualChannelInit(&plugin->priv->init_handle, plugin->channel_entry_points.pVirtualChannelInit(&plugin->priv->init_handle,
&plugin->channel_def, 1, VIRTUAL_CHANNEL_VERSION_WIN2000, svc_plugin_init_event); &plugin->channel_def, 1, VIRTUAL_CHANNEL_VERSION_WIN2000, svc_plugin_init_event);

5
libfreerdp/utils/thread.c
View File

@ -43,7 +43,7 @@ freerdp_thread* freerdp_thread_new(void)
freerdp_thread* thread; freerdp_thread* thread;
thread = xnew(freerdp_thread); thread = xnew(freerdp_thread);
thread->mutex = freerdp_mutex_new(); thread->mutex = CreateMutex(NULL, FALSE, NULL);
thread->signals[0] = wait_obj_new(); thread->signals[0] = wait_obj_new();
thread->signals[1] = wait_obj_new(); thread->signals[1] = wait_obj_new();
thread->num_signals = 2; thread->num_signals = 2;
@ -87,9 +87,10 @@ void freerdp_thread_free(freerdp_thread* thread)
for (i = 0; i < thread->num_signals; i++) for (i = 0; i < thread->num_signals; i++)
wait_obj_free(thread->signals[i]); wait_obj_free(thread->signals[i]);
thread->num_signals = 0; thread->num_signals = 0;
freerdp_mutex_free(thread->mutex); CloseHandle(thread->mutex);
thread->mutex = NULL; thread->mutex = NULL;
xfree(thread); xfree(thread);

1
winpr/include/winpr/handle.h
View File

@ -39,6 +39,7 @@ WINPR_API BOOL winpr_Handle_Remove(HANDLE handle);
WINPR_API ULONG winpr_Handle_GetType(HANDLE handle); WINPR_API ULONG winpr_Handle_GetType(HANDLE handle);
WINPR_API PVOID winpr_Handle_GetObject(HANDLE handle); WINPR_API PVOID winpr_Handle_GetObject(HANDLE handle);
WINPR_API BOOL winpr_Handle_GetInfo(HANDLE handle, ULONG* pType, PVOID* pObject);
#ifndef _WIN32 #ifndef _WIN32

13
winpr/include/winpr/synch.h
View File

@ -71,11 +71,6 @@ WINPR_API HANDLE OpenSemaphoreW(DWORD dwDesiredAccess, BOOL bInheritHandle, LPCW
WINPR_API BOOL ReleaseSemaphore(HANDLE hSemaphore, LONG lReleaseCount, LPLONG lpPreviousCount); WINPR_API BOOL ReleaseSemaphore(HANDLE hSemaphore, LONG lReleaseCount, LPLONG lpPreviousCount);
#define WAIT_OBJECT_0 0x00000000L
#define WAIT_ABANDONED 0x00000080L
#define WAIT_TIMEOUT 0x00000102L
#define WAIT_FAILED ((DWORD) 0xFFFFFFFF)
/* Event */ /* Event */
WINPR_API HANDLE CreateEventA(LPSECURITY_ATTRIBUTES lpEventAttributes, BOOL bManualReset, BOOL bInitialState, LPCSTR lpName); WINPR_API HANDLE CreateEventA(LPSECURITY_ATTRIBUTES lpEventAttributes, BOOL bManualReset, BOOL bInitialState, LPCSTR lpName);
@ -180,7 +175,15 @@ WINPR_API BOOL WaitOnAddress(VOID volatile *Address, PVOID CompareAddress, SIZE_
/* Wait */ /* Wait */
#define INFINITE 0xFFFFFFFF
#define WAIT_OBJECT_0 0x00000000L
#define WAIT_ABANDONED 0x00000080L
#define WAIT_TIMEOUT 0x00000102L
#define WAIT_FAILED ((DWORD) 0xFFFFFFFF)
WINPR_API DWORD WaitForSingleObject(HANDLE hHandle, DWORD dwMilliseconds); WINPR_API DWORD WaitForSingleObject(HANDLE hHandle, DWORD dwMilliseconds);
WINPR_API DWORD WaitForSingleObjectEx(HANDLE hHandle, DWORD dwMilliseconds, BOOL bAlertable);
WINPR_API DWORD WaitForMultipleObjects(DWORD nCount, const HANDLE* lpHandles, BOOL bWaitAll, DWORD dwMilliseconds); WINPR_API DWORD WaitForMultipleObjects(DWORD nCount, const HANDLE* lpHandles, BOOL bWaitAll, DWORD dwMilliseconds);
WINPR_API DWORD WaitForMultipleObjectsEx(DWORD nCount, const HANDLE* lpHandles, BOOL bWaitAll, DWORD dwMilliseconds, BOOL bAlertable); WINPR_API DWORD WaitForMultipleObjectsEx(DWORD nCount, const HANDLE* lpHandles, BOOL bWaitAll, DWORD dwMilliseconds, BOOL bAlertable);

38
winpr/libwinpr/handle/handle.c
View File

@ -25,46 +25,40 @@
#ifndef _WIN32 #ifndef _WIN32
#if defined __APPLE__ #include "../synch/synch.h"
#include <pthread.h>
#include <semaphore.h>
#include <mach/mach.h>
#include <mach/semaphore.h>
#include <mach/task.h>
#define winpr_sem_t semaphore_t
#else
#include <pthread.h>
#include <semaphore.h>
#define winpr_sem_t sem_t
#endif
BOOL CloseHandle(HANDLE hObject) BOOL CloseHandle(HANDLE hObject)
{ {
#if defined __APPLE__ ULONG Type;
semaphore_destroy(mach_task_self(), *((winpr_sem_t*) hObject)); PVOID Object;
#else
sem_destroy((winpr_sem_t*) hObject);
#endif
free(hObject); if (!winpr_Handle_GetInfo(hObject, &Type, &Object))
return FALSE;
return 1; if (Type == HANDLE_TYPE_MUTEX)
{
pthread_mutex_destroy((pthread_mutex_t*) Object);
free(Object);
return TRUE;
}
return FALSE;
} }
BOOL DuplicateHandle(HANDLE hSourceProcessHandle, HANDLE hSourceHandle, HANDLE hTargetProcessHandle, BOOL DuplicateHandle(HANDLE hSourceProcessHandle, HANDLE hSourceHandle, HANDLE hTargetProcessHandle,
LPHANDLE lpTargetHandle, DWORD dwDesiredAccess, BOOL bInheritHandle, DWORD dwOptions) LPHANDLE lpTargetHandle, DWORD dwDesiredAccess, BOOL bInheritHandle, DWORD dwOptions)
{ {
return 1; return TRUE;
} }
BOOL GetHandleInformation(HANDLE hObject, LPDWORD lpdwFlags) BOOL GetHandleInformation(HANDLE hObject, LPDWORD lpdwFlags)
{ {
return 1; return TRUE;
} }
BOOL SetHandleInformation(HANDLE hObject, DWORD dwMask, DWORD dwFlags) BOOL SetHandleInformation(HANDLE hObject, DWORD dwMask, DWORD dwFlags)
{ {
return 1; return TRUE;
} }
#endif #endif

41
winpr/libwinpr/handle/table.c
View File

@ -36,7 +36,7 @@ typedef struct _HANDLE_TABLE
{ {
LONG Count; LONG Count;
LONG MaxCount; LONG MaxCount;
PHANDLE_TABLE_ENTRY* Entries; PHANDLE_TABLE_ENTRY Entries;
} HANDLE_TABLE, *PHANDLE_TABLE; } HANDLE_TABLE, *PHANDLE_TABLE;
static HANDLE_TABLE HandleTable = { 0, 0, NULL }; static HANDLE_TABLE HandleTable = { 0, 0, NULL };
@ -54,7 +54,7 @@ void winpr_HandleTable_New()
size = sizeof(HANDLE_TABLE_ENTRY) * HandleTable.MaxCount; size = sizeof(HANDLE_TABLE_ENTRY) * HandleTable.MaxCount;
HandleTable.Entries = (PHANDLE_TABLE_ENTRY*) malloc(size); HandleTable.Entries = (PHANDLE_TABLE_ENTRY) malloc(size);
ZeroMemory(HandleTable.Entries, size); ZeroMemory(HandleTable.Entries, size);
} }
@ -65,7 +65,7 @@ void winpr_HandleTable_Grow()
size = sizeof(HANDLE_TABLE_ENTRY) * HandleTable.MaxCount; size = sizeof(HANDLE_TABLE_ENTRY) * HandleTable.MaxCount;
HandleTable.Entries = (PHANDLE_TABLE_ENTRY*) realloc(HandleTable.Entries, size); HandleTable.Entries = (PHANDLE_TABLE_ENTRY) realloc(HandleTable.Entries, size);
ZeroMemory((void*) &HandleTable.Entries[HandleTable.MaxCount / 2], size / 2); ZeroMemory((void*) &HandleTable.Entries[HandleTable.MaxCount / 2], size / 2);
} }
@ -86,12 +86,12 @@ HANDLE winpr_Handle_Insert(ULONG Type, PVOID Object)
for (index = 0; index < (int) HandleTable.MaxCount; index++) for (index = 0; index < (int) HandleTable.MaxCount; index++)
{ {
if (HandleTable.Entries[index]->Object == NULL) if (HandleTable.Entries[index].Object == NULL)
{ {
HandleTable.Count++; HandleTable.Count++;
HandleTable.Entries[index]->Type = Type; HandleTable.Entries[index].Type = Type;
HandleTable.Entries[index]->Object = Object; HandleTable.Entries[index].Object = Object;
return Object; return Object;
} }
@ -114,10 +114,10 @@ BOOL winpr_Handle_Remove(HANDLE handle)
for (index = 0; index < (int) HandleTable.MaxCount; index++) for (index = 0; index < (int) HandleTable.MaxCount; index++)
{ {
if (HandleTable.Entries[index]->Object == handle) if (HandleTable.Entries[index].Object == handle)
{ {
HandleTable.Entries[index]->Type = HANDLE_TYPE_NONE; HandleTable.Entries[index].Type = HANDLE_TYPE_NONE;
HandleTable.Entries[index]->Object = NULL; HandleTable.Entries[index].Object = NULL;
HandleTable.Count--; HandleTable.Count--;
return TRUE; return TRUE;
@ -135,8 +135,8 @@ ULONG winpr_Handle_GetType(HANDLE handle)
for (index = 0; index < (int) HandleTable.MaxCount; index++) for (index = 0; index < (int) HandleTable.MaxCount; index++)
{ {
if (HandleTable.Entries[index]->Object == handle) if (HandleTable.Entries[index].Object == handle)
return HandleTable.Entries[index]->Type; return HandleTable.Entries[index].Type;
} }
return HANDLE_TYPE_NONE; return HANDLE_TYPE_NONE;
@ -149,5 +149,24 @@ PVOID winpr_Handle_GetObject(HANDLE handle)
return handle; return handle;
} }
BOOL winpr_Handle_GetInfo(HANDLE handle, ULONG* pType, PVOID* pObject)
{
int index;
HandleTable_GetInstance();
for (index = 0; index < (int) HandleTable.MaxCount; index++)
{
if (HandleTable.Entries[index].Object == handle)
{
*pType = HandleTable.Entries[index].Type;
*pObject = HandleTable.Entries[index].Object;
return TRUE;
}
}
return FALSE;
}
#endif #endif

44
winpr/libwinpr/synch/mutex.c
View File

@ -23,6 +23,8 @@
#include <winpr/synch.h> #include <winpr/synch.h>
#include "synch.h"
/** /**
* CreateMutexA * CreateMutexA
* CreateMutexW * CreateMutexW
@ -33,24 +35,36 @@
* ReleaseMutex * ReleaseMutex
*/ */
HANDLE CreateMutexA(LPSECURITY_ATTRIBUTES lpMutexAttributes, BOOL bInitialOwner, LPCSTR lpName) #ifndef _WIN32
{
return NULL;
}
HANDLE CreateMutexW(LPSECURITY_ATTRIBUTES lpMutexAttributes, BOOL bInitialOwner, LPCWSTR lpName) HANDLE CreateMutexW(LPSECURITY_ATTRIBUTES lpMutexAttributes, BOOL bInitialOwner, LPCWSTR lpName)
{ {
return NULL; HANDLE handle;
pthread_mutex_t* pMutex;
pMutex = (pthread_mutex_t*) malloc(sizeof(pthread_mutex_t));
if (pMutex)
pthread_mutex_init(pMutex, 0);
handle = winpr_Handle_Insert(HANDLE_TYPE_MUTEX, pMutex);
return handle;
}
HANDLE CreateMutexA(LPSECURITY_ATTRIBUTES lpMutexAttributes, BOOL bInitialOwner, LPCSTR lpName)
{
return CreateMutexW(lpMutexAttributes, bInitialOwner, NULL);
} }
HANDLE CreateMutexExA(LPSECURITY_ATTRIBUTES lpMutexAttributes, LPCTSTR lpName, DWORD dwFlags, DWORD dwDesiredAccess) HANDLE CreateMutexExA(LPSECURITY_ATTRIBUTES lpMutexAttributes, LPCTSTR lpName, DWORD dwFlags, DWORD dwDesiredAccess)
{ {
return NULL; return CreateMutexW(lpMutexAttributes, FALSE, NULL);
} }
HANDLE CreateMutexExW(LPSECURITY_ATTRIBUTES lpMutexAttributes, LPCWSTR lpName, DWORD dwFlags, DWORD dwDesiredAccess) HANDLE CreateMutexExW(LPSECURITY_ATTRIBUTES lpMutexAttributes, LPCWSTR lpName, DWORD dwFlags, DWORD dwDesiredAccess)
{ {
return NULL; return CreateMutexW(lpMutexAttributes, FALSE, NULL);
} }
HANDLE OpenMutexA(DWORD dwDesiredAccess, BOOL bInheritHandle,LPCSTR lpName) HANDLE OpenMutexA(DWORD dwDesiredAccess, BOOL bInheritHandle,LPCSTR lpName)
@ -65,5 +79,19 @@ HANDLE OpenMutexW(DWORD dwDesiredAccess, BOOL bInheritHandle,LPCWSTR lpName)
BOOL ReleaseMutex(HANDLE hMutex) BOOL ReleaseMutex(HANDLE hMutex)
{ {
return TRUE; ULONG Type;
PVOID Object;
if (!winpr_Handle_GetInfo(hMutex, &Type, &Object))
return FALSE;
if (Type == HANDLE_TYPE_MUTEX)
{
pthread_mutex_unlock((pthread_mutex_t*) Object);
return TRUE;
}
return FALSE;
} }
#endif

4
winpr/libwinpr/synch/synch.h
View File

@ -22,6 +22,8 @@
#include <winpr/synch.h> #include <winpr/synch.h>
#ifndef _WIN32
#if defined __APPLE__ #if defined __APPLE__
#include <pthread.h> #include <pthread.h>
#include <semaphore.h> #include <semaphore.h>
@ -35,4 +37,6 @@
#define winpr_sem_t sem_t #define winpr_sem_t sem_t
#endif #endif
#endif
#endif /* WINPR_SYNCH_PRIVATE_H */ #endif /* WINPR_SYNCH_PRIVATE_H */

24
winpr/libwinpr/synch/wait.c
View File

@ -32,14 +32,26 @@
* SignalObjectAndWait * SignalObjectAndWait
*/ */
#ifndef _WIN32
DWORD WaitForSingleObject(HANDLE hHandle, DWORD dwMilliseconds) DWORD WaitForSingleObject(HANDLE hHandle, DWORD dwMilliseconds)
{ {
#if defined __APPLE__ ULONG Type;
semaphore_wait(*((winpr_sem_t*) hHandle)); PVOID Object;
#else
sem_wait((winpr_sem_t*) hHandle);
#endif
if (!winpr_Handle_GetInfo(hHandle, &Type, &Object))
return WAIT_FAILED;
if (Type == HANDLE_TYPE_MUTEX)
{
pthread_mutex_lock((pthread_mutex_t*) Object);
}
return WAIT_OBJECT_0;
}
DWORD WaitForSingleObjectEx(HANDLE hHandle, DWORD dwMilliseconds, BOOL bAlertable)
{
return WAIT_OBJECT_0; return WAIT_OBJECT_0;
} }
@ -57,3 +69,5 @@ DWORD SignalObjectAndWait(HANDLE hObjectToSignal, HANDLE hObjectToWaitOn, DWORD
{ {
return 0; return 0;
} }
#endif