dirmngr/ldap-wrapper-ce.c

   1 /* ldap-wrapper-ce.c - LDAP access via W32 threads
   2  * Copyright (C) 2010 Free Software Foundation, Inc.
   3  *
   4  * This file is part of GnuPG.
   5  *
   6  * GnuPG is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 3 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * GnuPG is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program; if not, see <https://www.gnu.org/licenses/>.
  18  */
  19
  20 /*
  21    Alternative wrapper for use with WindowsCE.  Under WindowsCE the
  22    number of processes is strongly limited (32 processes including the
  23    kernel processes) and thus we don't use the process approach but
  24    implement a wrapper based on native threads.
  25
  26    See ldap-wrapper.c for  the standard wrapper interface.
  27  */
  28
  29 #include <config.h>
  30
  31 #include <stdio.h>
  32 #include <stdlib.h>
  33 #include <string.h>
  34 #include <errno.h>
  35 #include <unistd.h>
  36 #include <fcntl.h>
  37 #include <time.h>
  38 #include <npth.h>
  39 #include <assert.h>
  40
  41 #include "dirmngr.h"
  42 #include "misc.h"
  43 #include "ldap-wrapper.h"
  44
  45 #ifdef USE_LDAPWRAPPER
  46 # error This module is not expected to be build.
  47 #endif
  48
  49
  50
  51 /* Read a fixed amount of data from READER into BUFFER.  */
  52 static gpg_error_t
  53 read_buffer (ksba_reader_t reader, unsigned char *buffer, size_t count)
  54 {
  55   gpg_error_t err;
  56   size_t nread;
  57
  58   while (count)
  59     {
  60       err = ksba_reader_read (reader, buffer, count, &nread);
  61       if (err)
  62         return err;
  63       buffer += nread;
  64       count -= nread;
  65     }
  66   return 0;
  67 }
  68
  69
  70
  71
  72 /* Start the reaper thread for this wrapper.  */
  73 void
  74 ldap_wrapper_launch_thread (void)
  75 {
  76   /* Not required.  */
  77 }
  78
  79
  80
  81
  82
  83 /* Wait until all ldap wrappers have terminated.  We assume that the
  84    kill has already been sent to all of them.  */
  85 void
  86 ldap_wrapper_wait_connections ()
  87 {
  88   /* Not required.  */
  89 }
  90
  91
  92 /* Cleanup all resources held by the connection associated with
  93    CTRL.  This is used after a cancel to kill running wrappers.  */
  94 void
  95 ldap_wrapper_connection_cleanup (ctrl_t ctrl)
  96 {
  97   (void)ctrl;
  98
  99   /* Not required.  */
 100 }
 101
 102
 103 \f
 104 /* The cookie we use to implement the outstream of the wrapper thread.  */
 105 struct outstream_cookie_s
 106 {
 107   int refcount; /* Reference counter - possible values are 1 and 2.  */
 108
 109   /* We don't need a mutex for the conditions, as npth provides a
 110      simpler condition interface that relies on the global lock.  This
 111      can be used if we never yield between testing the condition and
 112      waiting on it.  */
 113   npth_cond_t wait_data; /* Condition that data is available.  */
 114   npth_cond_t wait_space; /* Condition that space is available.  */
 115
 116   int eof_seen;       /* EOF indicator.  */
 117   char buffer[4000];  /* Data ring buffer.  */
 118   size_t buffer_len;  /* The amount of data in the BUFFER.  */
 119   size_t buffer_pos;  /* The next read position of the BUFFER.  */
 120 };
 121
 122 #define BUFFER_EMPTY(c) ((c)->buffer_len == 0)
 123 #define BUFFER_FULL(c) ((c)->buffer_len == DIM((c)->buffer))
 124 #define BUFFER_DATA_AVAILABLE(c) ((c)->buffer_len)
 125 #define BUFFER_SPACE_AVAILABLE(c) (DIM((c)->buffer) - (c)->buffer_len)
 126 #define BUFFER_INC_POS(c,n) (c)->buffer_pos = ((c)->buffer_pos + (n)) % DIM((c)->buffer)
 127 #define BUFFER_CUR_POS(c) (&(c)->buffer[(c)->buffer_pos])
 128
 129 static int
 130 buffer_get_data (struct outstream_cookie_s *cookie, char *dst, int cnt)
 131 {
 132   int amount;
 133   int left;
 134   int chunk;
 135
 136   amount = cnt;
 137   if (BUFFER_DATA_AVAILABLE (cookie) < amount)
 138     amount = BUFFER_DATA_AVAILABLE (cookie);
 139   left = amount;
 140
 141   /* How large is the part up to the end of the buffer array?  */
 142   chunk = DIM(cookie->buffer) - cookie->buffer_pos;
 143   if (chunk > left)
 144     chunk = left;
 145
 146   memcpy (dst, BUFFER_CUR_POS (cookie), chunk);
 147   BUFFER_INC_POS (cookie, chunk);
 148   left -= chunk;
 149   dst += chunk;
 150
 151   if (left)
 152     {
 153       memcpy (dst, BUFFER_CUR_POS (cookie), left);
 154       BUFFER_INC_POS (cookie, left);
 155     }
 156
 157   return amount;
 158 }
 159
 160
 161 static int
 162 buffer_put_data (struct outstream_cookie_s *cookie, const char *src, int cnt)
 163 {
 164   int amount;
 165   int remain;
 166   int left;
 167   int chunk;
 168
 169   remain = DIM(cookie->buffer) - cookie->buffer_len;
 170
 171   amount = cnt;
 172   if (remain < amount)
 173     amount = remain;
 174   left = amount;
 175
 176   /* How large is the part up to the end of the buffer array?  */
 177   chunk = DIM(cookie->buffer) - cookie->buffer_pos;
 178   if (chunk > left)
 179     chunk = left;
 180
 181   memcpy (BUFFER_CUR_POS (cookie), src, chunk);
 182   BUFFER_INC_POS (cookie, chunk);
 183   left -= chunk;
 184   src += chunk;
 185
 186   if (left)
 187     {
 188       memcpy (BUFFER_CUR_POS (cookie), src, left);
 189       BUFFER_INC_POS (cookie, left);
 190     }
 191
 192   cookie->buffer_len -= amount;
 193   return amount;
 194 }
 195
 196
 197 /* The writer function for the outstream.  This is used to transfer
 198    the output of the ldap wrapper thread to the ksba reader object.  */
 199 static ssize_t
 200 outstream_cookie_writer (void *cookie_arg, const void *buffer, size_t size)
 201 {
 202   struct outstream_cookie_s *cookie = cookie_arg;
 203   const char *src;
 204   ssize_t nwritten = 0;
 205   int res;
 206   ssize_t amount = 0;
 207
 208   src = buffer;
 209   do
 210     {
 211       int was_empty = 0;
 212
 213       /* Wait for free space.  */
 214       while (BUFFER_FULL(cookie))
 215         {
 216           /* Buffer is full:  Wait for space.  */
 217           res = npth_cond_wait (&cookie->wait_space, NULL);
 218           if (res)
 219             {
 220               gpg_err_set_errno (res);
 221               return -1;
 222             }
 223         }
 224
 225       if (BUFFER_EMPTY(cookie))
 226         was_empty = 1;
 227
 228       /* Copy data.  */
 229       nwritten = buffer_put_data (cookie, buffer, size);
 230       size -= nwritten;
 231       src += nwritten;
 232       amount += nwritten;
 233
 234       if (was_empty)
 235         npth_cond_signal (&cookie->wait_data);
 236     }
 237   while (size);  /* Until done.  */
 238
 239   return amount;
 240 }
 241
 242
 243 static void
 244 outstream_release_cookie (struct outstream_cookie_s *cookie)
 245 {
 246   cookie->refcount--;
 247   if (!cookie->refcount)
 248     {
 249       npth_cond_destroy (&cookie->wait_data);
 250       npth_cond_destroy (&cookie->wait_space);
 251       xfree (cookie);
 252     }
 253 }
 254
 255
 256 /* Closer function for the outstream.  This deallocates the cookie if
 257    it won't be used anymore.  */
 258 static int
 259 outstream_cookie_closer (void *cookie_arg)
 260 {
 261   struct outstream_cookie_s *cookie = cookie_arg;
 262
 263   if (!cookie)
 264     return 0;  /* Nothing to do.  */
 265
 266   cookie->eof_seen = 1; /* (only useful if refcount > 1)  */
 267
 268   assert (cookie->refcount > 0);
 269   outstream_release_cookie (cookie);
 270   return 0;
 271 }
 272
 273
 274 /* The KSBA reader callback which takes the output of the ldap thread
 275    form the outstream_cookie_writer and make it available to the ksba
 276    reader.  */
 277 static int
 278 outstream_reader_cb (void *cb_value, char *buffer, size_t count,
 279                      size_t *r_nread)
 280 {
 281   struct outstream_cookie_s *cookie = cb_value;
 282   size_t nread = 0;
 283   int was_full = 0;
 284
 285   if (!buffer && !count && !r_nread)
 286     return gpg_error (GPG_ERR_NOT_SUPPORTED); /* Rewind is not supported.  */
 287
 288   *r_nread = 0;
 289
 290   while (BUFFER_EMPTY(cookie))
 291     {
 292       if (cookie->eof_seen)
 293         return gpg_error (GPG_ERR_EOF);
 294
 295       /* Wait for data to become available.  */
 296       npth_cond_wait (&cookie->wait_data, NULL);
 297     }
 298
 299   if (BUFFER_FULL(cookie))
 300     was_full = 1;
 301
 302   nread = buffer_get_data (cookie, buffer, count);
 303
 304   if (was_full)
 305     {
 306       npth_cond_signal (&cookie->wait_space);
 307     }
 308
 309   *r_nread = nread;
 310   return 0; /* Success.  */
 311 }
 312
 313
 314 /* This function is called by ksba_reader_release.  */
 315 static void
 316 outstream_reader_released (void *cb_value, ksba_reader_t r)
 317 {
 318   struct outstream_cookie_s *cookie = cb_value;
 319
 320   (void)r;
 321
 322   assert (cookie->refcount > 0);
 323   outstream_release_cookie (cookie);
 324 }
 325
 326
 327
 328 /* This function is to be used to release a context associated with the
 329    given reader object.  This does not release the reader object, though. */
 330 void
 331 ldap_wrapper_release_context (ksba_reader_t reader)
 332 {
 333   (void)reader;
 334   /* Nothing to do.  */
 335 }
 336
 337
 338 \f
 339 /* Free a NULL terminated array of malloced strings and the array
 340    itself.  */
 341 static void
 342 free_arg_list (char **arg_list)
 343 {
 344   int i;
 345
 346   if (arg_list)
 347     {
 348       for (i=0; arg_list[i]; i++)
 349         xfree (arg_list[i]);
 350       xfree (arg_list);
 351     }
 352 }
 353
 354
 355 /* Copy ARGV into a new array and prepend one element as name of the
 356    program (which is more or less a stub).  We need to allocate all
 357    the strings to get ownership of them.  */
 358 static gpg_error_t
 359 create_arg_list (const char *argv[], char ***r_arg_list)
 360 {
 361   gpg_error_t err;
 362   char **arg_list;
 363   int i, j;
 364
 365   for (i = 0; argv[i]; i++)
 366     ;
 367   arg_list = xtrycalloc (i + 2, sizeof *arg_list);
 368   if (!arg_list)
 369     goto outofcore;
 370
 371   i = 0;
 372   arg_list[i] = xtrystrdup ("<ldap-wrapper-thread>");
 373   if (!arg_list[i])
 374     goto outofcore;
 375   i++;
 376   for (j=0; argv[j]; j++)
 377     {
 378       arg_list[i] = xtrystrdup (argv[j]);
 379       if (!arg_list[i])
 380         goto outofcore;
 381       i++;
 382     }
 383   arg_list[i] = NULL;
 384   *r_arg_list = arg_list;
 385   return 0;
 386
 387  outofcore:
 388   err = gpg_error_from_syserror ();
 389   log_error (_("error allocating memory: %s\n"), strerror (errno));
 390   free_arg_list (arg_list);
 391   *r_arg_list = NULL;
 392   return err;
 393
 394 }
 395
 396
 397 /* Parameters passed to the wrapper thread. */
 398 struct ldap_wrapper_thread_parms
 399 {
 400   char **arg_list;
 401   estream_t outstream;
 402 };
 403
 404 /* The thread which runs the LDAP wrapper.  */
 405 static void *
 406 ldap_wrapper_thread (void *opaque)
 407 {
 408   struct ldap_wrapper_thread_parms *parms = opaque;
 409
 410   /*err =*/ ldap_wrapper_main (parms->arg_list, parms->outstream);
 411
 412   /* FIXME: Do we need to return ERR?  */
 413
 414   free_arg_list (parms->arg_list);
 415   es_fclose (parms->outstream);
 416   xfree (parms);
 417   return NULL;
 418 }
 419
 420
 421
 422 /* Start a new LDAP thread and returns a new libksba reader
 423    object at READER.  ARGV is a NULL terminated list of arguments for
 424    the wrapper.  The function returns 0 on success or an error code.  */
 425 gpg_error_t
 426 ldap_wrapper (ctrl_t ctrl, ksba_reader_t *r_reader, const char *argv[])
 427 {
 428   gpg_error_t err;
 429   struct ldap_wrapper_thread_parms *parms;
 430   npth_attr_t tattr;
 431   es_cookie_io_functions_t outstream_func = { NULL };
 432   struct outstream_cookie_s *outstream_cookie;
 433   ksba_reader_t reader;
 434   int res;
 435   npth_t thread;
 436
 437   (void)ctrl;
 438
 439   *r_reader = NULL;
 440
 441   parms = xtrycalloc (1, sizeof *parms);
 442   if (!parms)
 443     return gpg_error_from_syserror ();
 444
 445   err = create_arg_list (argv, &parms->arg_list);
 446   if (err)
 447     {
 448       xfree (parms);
 449       return err;
 450     }
 451
 452   outstream_cookie = xtrycalloc (1, sizeof *outstream_cookie);
 453   if (!outstream_cookie)
 454     {
 455       err = gpg_error_from_syserror ();
 456       free_arg_list (parms->arg_list);
 457       xfree (parms);
 458       return err;
 459     }
 460   outstream_cookie->refcount++;
 461
 462   res = npth_cond_init (&outstream_cookie->wait_data, NULL);
 463   if (res)
 464     {
 465       free_arg_list (parms->arg_list);
 466       xfree (parms);
 467       return gpg_error_from_errno (res);
 468     }
 469   res = npth_cond_init (&outstream_cookie->wait_space, NULL);
 470   if (res)
 471     {
 472       npth_cond_destroy (&outstream_cookie->wait_data);
 473       free_arg_list (parms->arg_list);
 474       xfree (parms);
 475       return gpg_error_from_errno (res);
 476     }
 477
 478   err = ksba_reader_new (&reader);
 479   if (!err)
 480     err = ksba_reader_set_release_notify (reader,
 481                                           outstream_reader_released,
 482                                           outstream_cookie);
 483   if (!err)
 484     err = ksba_reader_set_cb (reader,
 485                               outstream_reader_cb, outstream_cookie);
 486   if (err)
 487     {
 488       log_error (_("error initializing reader object: %s\n"),
 489                  gpg_strerror (err));
 490       ksba_reader_release (reader);
 491       outstream_release_cookie (outstream_cookie);
 492       free_arg_list (parms->arg_list);
 493       xfree (parms);
 494       return err;
 495     }
 496
 497
 498   outstream_func.func_write = outstream_cookie_writer;
 499   outstream_func.func_close = outstream_cookie_closer;
 500   parms->outstream = es_fopencookie (outstream_cookie, "wb", outstream_func);
 501   if (!parms->outstream)
 502     {
 503       err = gpg_error_from_syserror ();
 504       ksba_reader_release (reader);
 505       outstream_release_cookie (outstream_cookie);
 506       free_arg_list (parms->arg_list);
 507       xfree (parms);
 508       return err;
 509     }
 510   outstream_cookie->refcount++;
 511
 512   res = npth_attr_init(&tattr);
 513   if (res)
 514     {
 515       err = gpg_error_from_errno (res);
 516       ksba_reader_release (reader);
 517       free_arg_list (parms->arg_list);
 518       es_fclose (parms->outstream);
 519       xfree (parms);
 520       return err;
 521     }
 522   npth_attr_setdetachstate (&tattr, NPTH_CREATE_DETACHED);
 523
 524   res = npth_create (&thread, &tattr, ldap_wrapper_thread, parms);
 525   npth_attr_destroy (&tattr);
 526   if (res)
 527     {
 528       err = gpg_error_from_errno (res);
 529       log_error ("error spawning ldap wrapper thread: %s\n",
 530                  strerror (res) );
 531     }
 532   else
 533     parms = NULL; /* Now owned by the thread.  */
 534
 535   if (parms)
 536     {
 537       free_arg_list (parms->arg_list);
 538       es_fclose (parms->outstream);
 539       xfree (parms);
 540     }
 541   if (err)
 542     {
 543       ksba_reader_release (reader);
 544       return err;
 545     }
 546
 547   /* Need to wait for the first byte so we are able to detect an empty
 548      output and not let the consumer see an EOF without further error
 549      indications.  The CRL loading logic assumes that after return
 550      from this function, a failed search (e.g. host not found ) is
 551      indicated right away. */
 552   {
 553     unsigned char c;
 554
 555     err = read_buffer (reader, &c, 1);
 556     if (err)
 557       {
 558         ksba_reader_release (reader);
 559         reader = NULL;
 560         if (gpg_err_code (err) == GPG_ERR_EOF)
 561           return gpg_error (GPG_ERR_NO_DATA);
 562         else
 563           return err;
 564       }
 565     ksba_reader_unread (reader, &c, 1);
 566   }
 567
 568   *r_reader = reader;
 569
 570   return 0;
 571 }