lib/silcutil/win32/silcwin32thread.c

   1 /*
   2
   3   silcwin32thread.c
   4
   5   Author: Pekka Riikonen <priikone@silcnet.org>
   6
   7   Copyright (C) 2001 - 2006 Pekka Riikonen
   8
   9   This program is free software; you can redistribute it and/or modify
  10   it under the terms of the GNU General Public License as published by
  11   the Free Software Foundation; version 2 of the License.
  12
  13   This program is distributed in the hope that it will be useful,
  14   but WITHOUT ANY WARRANTY; without even the implied warranty of
  15   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16   GNU General Public License for more details.
  17
  18 */
  19 /* $Id$ */
  20
  21 #include "silc.h"
  22
  23 /**************************** SILC Thread API *******************************/
  24
  25 #ifdef SILC_THREADS
  26
  27 /* Thread structure for WIN32 */
  28 typedef struct {
  29   HANDLE thread;
  30   SilcThreadStart start_func;
  31   void *context;
  32   SilcBool waitable;
  33 } *SilcWin32Thread;
  34
  35 static DWORD silc_thread_tls;
  36
  37 /* Actual routine that is called by WIN32 when the thread is created.
  38    We will call the start_func from here. When this returns the thread
  39    is destroyed. */
  40
  41 unsigned __stdcall silc_thread_win32_start(void *context)
  42 {
  43   SilcWin32Thread thread = (SilcWin32Thread)context;
  44
  45   TlsSetValue(silc_thread_tls, context);
  46   silc_thread_exit(thread->start_func(thread->context));
  47
  48   return 0;
  49 }
  50 #endif
  51
  52 SilcThread silc_thread_create(SilcThreadStart start_func, void *context,
  53                               SilcBool waitable)
  54 {
  55 #ifdef SILC_THREADS
  56   SilcWin32Thread thread;
  57   unsigned id;
  58
  59   SILC_LOG_DEBUG(("Creating new thread"));
  60
  61   thread = silc_calloc(1, sizeof(*thread));
  62   thread->start_func = start_func;
  63   thread->context = context;
  64   thread->waitable = waitable;
  65   thread->thread =
  66     CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)silc_thread_win32_start,
  67                  (void *)thread, 0, &id);
  68
  69   if (!thread->thread) {
  70     SILC_LOG_ERROR(("Could not create new thread"));
  71     silc_free(thread);
  72     return NULL;
  73   }
  74
  75   return (SilcThread)thread;
  76 #else
  77   /* Call thread callback immediately */
  78   (*start_func)(context);
  79   return NULL;
  80 #endif
  81 }
  82
  83 void silc_thread_exit(void *exit_value)
  84 {
  85 #ifdef SILC_THREADS
  86   SilcWin32Thread thread = TlsGetValue(silc_thread_tls);
  87
  88   if (thread) {
  89     /* If the thread is waitable the memory is freed only in silc_thread_wait
  90        by another thread. If not waitable, free it now. */
  91     if (!thread->waitable) {
  92       TerminateThread(thread->thread, 0);
  93       silc_free(thread);
  94     }
  95
  96     TlsSetValue(silc_thread_tls, NULL);
  97   }
  98   ExitThread(0);
  99 #endif
 100 }
 101
 102 SilcThread silc_thread_self(void)
 103 {
 104 #ifdef SILC_THREADS
 105   SilcWin32Thread self = TlsGetValue(silc_thread_tls);
 106
 107   if (!self) {
 108     /* This should only happen for the main thread! */
 109     HANDLE handle = GetCurrentThread ();
 110     HANDLE process = GetCurrentProcess ();
 111     self = silc_calloc(1, sizeof(*self));
 112     DuplicateHandle(process, handle, process,
 113                     &self->thread, 0, FALSE,
 114                     DUPLICATE_SAME_ACCESS);
 115     TlsSetValue(silc_thread_tls, self);
 116   }
 117
 118   return (SilcThread)self;
 119         #else
 120   return NULL;
 121 #endif
 122 }
 123
 124 SilcBool silc_thread_wait(SilcThread thread, void **exit_value)
 125 {
 126 #ifdef SILC_THREADS
 127   SilcWin32Thread self = (SilcWin32Thread)thread;
 128
 129   SILC_LOG_DEBUG(("Waiting for thread %p", self));
 130
 131   if (!self->waitable)
 132     return FALSE;
 133
 134   /* The thread is waitable thus we will free all memory after the
 135      WaitForSingleObject returns, the thread is destroyed after that. */
 136   if (WaitForSingleObject(self->thread, 2500) == WAIT_TIMEOUT)
 137     TerminateThread(self->thread, 0);
 138
 139   silc_free(self);
 140   if (exit_value)
 141     *exit_value = NULL;
 142
 143   return TRUE;
 144 #else
 145   return FALSE;
 146 #endif
 147 }
 148
 149
 150 /***************************** SILC Mutex API *******************************/
 151
 152 /* SILC Mutex structure */
 153 struct SilcMutexStruct {
 154 #ifdef SILC_THREADS
 155   CRITICAL_SECTION mutex;
 156   BOOL locked;
 157 #else
 158   void *tmp;
 159 #endif /* SILC_THREADS */
 160 };
 161
 162 SilcBool silc_mutex_alloc(SilcMutex *mutex)
 163 {
 164 #ifdef SILC_THREADS
 165   *mutex = silc_calloc(1, sizeof(**mutex));
 166   if (!(*mutex))
 167     return FALSE;
 168   InitializeCriticalSection(&((*mutex)->mutex));
 169   return TRUE;
 170 #else
 171   return FALSE;
 172 #endif /* SILC_THREADS */
 173 }
 174
 175 void silc_mutex_free(SilcMutex mutex)
 176 {
 177 #ifdef SILC_THREADS
 178   if (mutex) {
 179     DeleteCriticalSection(&mutex->mutex);
 180     silc_free(mutex);
 181   }
 182 #endif /* SILC_THREADS */
 183 }
 184
 185 void silc_mutex_lock(SilcMutex mutex)
 186 {
 187 #ifdef SILC_THREADS
 188   if (mutex) {
 189     EnterCriticalSection(&mutex->mutex);
 190     assert(mutex->locked == FALSE);
 191     mutex->locked = TRUE;
 192   }
 193 #endif /* SILC_THREADS */
 194 }
 195
 196 void silc_mutex_unlock(SilcMutex mutex)
 197 {
 198 #ifdef SILC_THREADS
 199   if (mutex) {
 200     assert(mutex->locked == TRUE);
 201     mutex->locked = FALSE;
 202     LeaveCriticalSection(&mutex->mutex);
 203   }
 204 #endif /* SILC_THREADS */
 205 }
 206
 207
 208 /**************************** SILC CondVar API ******************************/
 209
 210 /* SILC Conditional Variable context */
 211 struct SilcCondVarStruct {
 212 #ifdef SILC_THREADS
 213   HANDLE event;
 214 #endif /* SILC_THREADS*/
 215   unsigned int waiters : 23;
 216   unsigned int signal  : 1;
 217 };
 218
 219 SilcBool silc_condvar_alloc(SilcCondVar *cond)
 220 {
 221 #ifdef SILC_THREADS
 222   *cond = silc_calloc(1, sizeof(**cond));
 223   if (*cond == NULL)
 224     return FALSE;
 225   (*cond)->event = CreateEvent(NULL, TRUE, FALSE, NULL);
 226   return TRUE;
 227 #else
 228   return FALSE;
 229 #endif /* SILC_THREADS*/
 230 }
 231
 232 void silc_condvar_free(SilcCondVar cond)
 233 {
 234 #ifdef SILC_THREADS
 235   CloseHandle(cond->event);
 236   silc_free(cond);
 237 #endif /* SILC_THREADS*/
 238 }
 239
 240 void silc_condvar_signal(SilcCondVar cond)
 241 {
 242 #ifdef SILC_THREADS
 243   cond->signal = TRUE;
 244   SetEvent(cond->event);
 245 #endif /* SILC_THREADS*/
 246 }
 247
 248 void silc_condvar_broadcast(SilcCondVar cond)
 249 {
 250 #ifdef SILC_THREADS
 251   cond->signal = TRUE;
 252   SetEvent(cond->event);
 253 #endif /* SILC_THREADS*/
 254 }
 255
 256 void silc_condvar_wait(SilcCondVar cond, SilcMutex mutex)
 257 {
 258 #ifdef SILC_THREADS
 259   silc_condvar_timedwait(cond, mutex, NULL);
 260 #endif /* SILC_THREADS*/
 261 }
 262
 263 SilcBool silc_condvar_timedwait(SilcCondVar cond, SilcMutex mutex,
 264                                 int timeout)
 265 {
 266 #ifdef SILC_THREADS
 267   DWORD ret, t = INFINITE;
 268
 269   if (timeout)
 270     t = timeout;
 271
 272   while (TRUE) {
 273     cond->waiters++;
 274     silc_mutex_unlock(mutex);
 275
 276     ret = WaitForSingleObject(cond->event, t);
 277
 278     silc_mutex_lock(mutex);
 279     cond->waiters--;
 280
 281     if (ret != WAIT_OBJECT_0)
 282       return FALSE;
 283
 284     if (cond->signal) {
 285       cond->signal = FALSE;
 286       ResetEvent(cond->event);
 287       break;
 288     }
 289   }
 290 #endif /* SILC_THREADS*/
 291 }