dirmngr/dirmngr_ldap.c

   1 /* dirmngr-ldap.c  -  The LDAP helper for dirmngr.
   2  *      Copyright (C) 2004 g10 Code GmbH
   3  *
   4  * This file is part of DirMngr.
   5  *
   6  * DirMngr 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 2 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * DirMngr 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, write to the Free Software
  18  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
  19  */
  20
  21 #include <config.h>
  22
  23 #include <stdio.h>
  24 #include <stdlib.h>
  25 #include <stddef.h>
  26 #include <stdarg.h>
  27 #include <string.h>
  28 #include <signal.h>
  29 #include <errno.h>
  30 #include <assert.h>
  31 #include <sys/time.h>
  32 #include <unistd.h>
  33
  34 #ifdef HAVE_W32_SYSTEM
  35 #include <winsock2.h>
  36 #include <winldap.h>
  37 #include <fcntl.h>
  38 #include "ldap-url.h"
  39 #else
  40 /* For OpenLDAP, to enable the API that we're using. */
  41 #define LDAP_DEPRECATED 1
  42 #include <ldap.h>
  43 #endif
  44
  45
  46 #define JNLIB_NEED_LOG_LOGV
  47 #include "../common/logging.h"
  48 #include "../common/argparse.h"
  49 #include "../common/stringhelp.h"
  50 #include "../common/mischelp.h"
  51 #include "../common/strlist.h"
  52
  53 #include "i18n.h"
  54 #include "util.h"
  55
  56 #define DEFAULT_LDAP_TIMEOUT 100 /* Arbitrary long timeout. */
  57
  58
  59 /* Constants for the options.  */
  60 enum
  61   {
  62     oQuiet        = 'q',
  63     oVerbose      = 'v',
  64
  65     oTimeout      = 500,
  66     oMulti,
  67     oProxy,
  68     oHost,
  69     oPort,
  70     oUser,
  71     oPass,
  72     oEnvPass,
  73     oDN,
  74     oFilter,
  75     oAttr,
  76
  77     oOnlySearchTimeout,
  78     oLogWithPID
  79   };
  80
  81
  82 /* The list of options as used by the argparse.c code.  */
  83 static ARGPARSE_OPTS opts[] = {
  84   { oVerbose,  "verbose",   0, N_("verbose") },
  85   { oQuiet,    "quiet",     0, N_("be somewhat more quiet") },
  86   { oTimeout,  "timeout",   1, N_("|N|set LDAP timeout to N seconds")},
  87   { oMulti,    "multi",     0, N_("return all values in"
  88                                   " a record oriented format")},
  89   { oProxy,    "proxy",     2,
  90     N_("|NAME|ignore host part and connect through NAME")},
  91   { oHost,     "host",      2, N_("|NAME|connect to host NAME")},
  92   { oPort,     "port",      1, N_("|N|connect to port N")},
  93   { oUser,     "user",      2, N_("|NAME|use user NAME for authentication")},
  94   { oPass,     "pass",      2, N_("|PASS|use password PASS"
  95                                   " for authentication")},
  96   { oEnvPass,  "env-pass",  0, N_("take password from $DIRMNGR_LDAP_PASS")},
  97   { oDN,       "dn",        2, N_("|STRING|query DN STRING")},
  98   { oFilter,   "filter",    2, N_("|STRING|use STRING as filter expression")},
  99   { oAttr,     "attr",      2, N_("|STRING|return the attribute STRING")},
 100   { oOnlySearchTimeout, "only-search-timeout", 0, "@"},
 101   { oLogWithPID,"log-with-pid", 0, "@"},
 102   { 0, NULL, 0, NULL }
 103 };
 104
 105
 106 /* The usual structure for the program flags.  */
 107 static struct
 108 {
 109   int quiet;
 110   int verbose;
 111   struct timeval timeout; /* Timeout for the LDAP search functions.  */
 112   unsigned int alarm_timeout; /* And for the alarm based timeout.  */
 113   int multi;
 114
 115   /* Note that we can't use const for the strings because ldap_* are
 116      not defined that way.  */
 117   char *proxy; /* Host and Port override.  */
 118   char *user;  /* Authentication user.  */
 119   char *pass;  /* Authentication password.  */
 120   char *host;  /* Override host.  */
 121   int port;    /* Override port.  */
 122   char *dn;    /* Override DN.  */
 123   char *filter;/* Override filter.  */
 124   char *attr;  /* Override attribute.  */
 125 } opt;
 126
 127
 128 /* Prototypes.  */
 129 static void catch_alarm (int dummy);
 130 static int process_url (const char *url);
 131
 132
 133
 134 /* Function called by argparse.c to display information.  */
 135 static const char *
 136 my_strusage (int level)
 137 {
 138   const char *p;
 139
 140   switch(level)
 141     {
 142     case 11: p = "dirmngr_ldap (GnuPG)";
 143       break;
 144     case 13: p = VERSION; break;
 145     case 17: p = PRINTABLE_OS_NAME; break;
 146     case 19: p = _("Please report bugs to <@EMAIL@>.\n"); break;
 147     case 49: p = PACKAGE_BUGREPORT; break;
 148     case 1:
 149     case 40: p =
 150                _("Usage: dirmngr_ldap [options] [URL] (-h for help)\n");
 151       break;
 152     case 41: p =
 153           _("Syntax: dirmngr_ldap [options] [URL]\n"
 154             "Internal LDAP helper for Dirmngr.\n"
 155             "Interface and options may change without notice.\n");
 156       break;
 157
 158     default: p = NULL;
 159     }
 160   return p;
 161 }
 162
 163
 164 int
 165 main (int argc, char **argv )
 166 {
 167   ARGPARSE_ARGS pargs;
 168   int any_err = 0;
 169   char *p;
 170   int only_search_timeout = 0;
 171
 172 #ifdef HAVE_W32_SYSTEM
 173   /* Yeah, right.  Sigh.  */
 174   _setmode (_fileno (stdout), _O_BINARY);
 175 #endif
 176
 177   set_strusage (my_strusage);
 178   log_set_prefix ("dirmngr_ldap", JNLIB_LOG_WITH_PREFIX);
 179
 180   /* Setup I18N. */
 181   i18n_init();
 182
 183   /* LDAP defaults */
 184   opt.timeout.tv_sec = DEFAULT_LDAP_TIMEOUT;
 185   opt.timeout.tv_usec = 0;
 186   opt.alarm_timeout = 0;
 187
 188   /* Parse the command line.  */
 189   pargs.argc = &argc;
 190   pargs.argv = &argv;
 191   pargs.flags= 1;  /* Do not remove the args. */
 192   while (arg_parse (&pargs, opts) )
 193     {
 194       switch (pargs.r_opt)
 195         {
 196         case oVerbose: opt.verbose++; break;
 197         case oQuiet: opt.quiet++; break;
 198         case oTimeout:
 199           opt.timeout.tv_sec = pargs.r.ret_int;
 200           opt.timeout.tv_usec = 0;
 201           opt.alarm_timeout = pargs.r.ret_int;
 202           break;
 203         case oOnlySearchTimeout: only_search_timeout = 1; break;
 204         case oMulti: opt.multi = 1; break;
 205         case oUser: opt.user = pargs.r.ret_str; break;
 206         case oPass: opt.pass = pargs.r.ret_str; break;
 207         case oEnvPass:
 208           opt.pass = getenv ("DIRMNGR_LDAP_PASS");
 209           break;
 210         case oProxy: opt.proxy = pargs.r.ret_str; break;
 211         case oHost: opt.host = pargs.r.ret_str; break;
 212         case oPort: opt.port = pargs.r.ret_int; break;
 213         case oDN:   opt.dn = pargs.r.ret_str; break;
 214         case oFilter: opt.filter = pargs.r.ret_str; break;
 215         case oAttr: opt.attr = pargs.r.ret_str; break;
 216         case oLogWithPID:
 217           {
 218             unsigned int oldflags;
 219             log_get_prefix (&oldflags);
 220             log_set_prefix (NULL, oldflags | JNLIB_LOG_WITH_PID);
 221           }
 222           break;
 223
 224         default : pargs.err = 2; break;
 225         }
 226     }
 227
 228   if (only_search_timeout)
 229     opt.alarm_timeout = 0;
 230
 231   if (opt.proxy)
 232     {
 233       opt.host = xstrdup (opt.proxy);
 234       p = strchr (opt.host, ':');
 235       if (p)
 236         {
 237           *p++ = 0;
 238           opt.port = atoi (p);
 239         }
 240       if (!opt.port)
 241         opt.port = 389;  /* make sure ports gets overridden.  */
 242     }
 243
 244   if (opt.port < 0 || opt.port > 65535)
 245     log_error (_("invalid port number %d\n"), opt.port);
 246
 247   if (log_get_errorcount (0))
 248     exit (2);
 249
 250   if (argc < 1)
 251     usage (1);
 252
 253   if (opt.alarm_timeout)
 254     {
 255 #ifndef HAVE_W32_SYSTEM
 256 # if defined(HAVE_SIGACTION) && defined(HAVE_STRUCT_SIGACTION)
 257       struct sigaction act;
 258
 259       act.sa_handler = catch_alarm;
 260       sigemptyset (&act.sa_mask);
 261       act.sa_flags = 0;
 262       if (sigaction (SIGALRM,&act,NULL))
 263 # else
 264       if (signal (SIGALRM, catch_alarm) == SIG_ERR)
 265 # endif
 266           log_fatal ("unable to register timeout handler\n");
 267 #endif
 268     }
 269
 270   for (; argc; argc--, argv++)
 271     if (process_url (*argv))
 272       any_err = 1;
 273
 274   return any_err;
 275 }
 276
 277
 278 static void
 279 catch_alarm (int dummy)
 280 {
 281   (void)dummy;
 282   _exit (10);
 283 }
 284
 285
 286 static void
 287 set_timeout (void)
 288 {
 289 #ifndef HAVE_W32_SYSTEM
 290   /* FIXME for W32.  */
 291   if (opt.alarm_timeout)
 292     alarm (opt.alarm_timeout);
 293 #endif
 294 }
 295
 296
 297 /* Helper for fetch_ldap().  */
 298 static int
 299 print_ldap_entries (LDAP *ld, LDAPMessage *msg, char *want_attr)
 300 {
 301   LDAPMessage *item;
 302   int any = 0;
 303
 304   for (item = ldap_first_entry (ld, msg); item;
 305        item = ldap_next_entry (ld, item))
 306     {
 307       BerElement *berctx;
 308       char *attr;
 309
 310       if (opt.verbose > 1)
 311         log_info (_("scanning result for attribute `%s'\n"),
 312                   want_attr? want_attr : "[all]");
 313
 314       if (opt.multi)
 315         { /*  Write item marker. */
 316           if (fwrite ("I\0\0\0\0", 5, 1, stdout) != 1)
 317             {
 318               log_error (_("error writing to stdout: %s\n"),
 319                          strerror (errno));
 320               return -1;
 321             }
 322         }
 323
 324
 325       for (attr = ldap_first_attribute (ld, item, &berctx); attr;
 326            attr = ldap_next_attribute (ld, item, berctx))
 327         {
 328           struct berval **values;
 329           int idx;
 330
 331           if (opt.verbose > 1)
 332             log_info (_("          available attribute `%s'\n"), attr);
 333
 334           set_timeout ();
 335
 336           /* I case we want only one attribute we do a case
 337              insensitive compare without the optional extension
 338              (i.e. ";binary").  Case insensitive is not really correct
 339              but the best we can do.  */
 340           if (want_attr)
 341             {
 342               char *cp1, *cp2;
 343               int cmpres;
 344
 345               cp1 = strchr (want_attr, ';');
 346               if (cp1)
 347                 *cp1 = 0;
 348               cp2 = strchr (attr, ';');
 349               if (cp2)
 350                 *cp2 = 0;
 351               cmpres = ascii_strcasecmp (want_attr, attr);
 352               if (cp1)
 353                 *cp1 = ';';
 354               if (cp2)
 355                 *cp2 = ';';
 356               if (cmpres)
 357                 {
 358                   ldap_memfree (attr);
 359                   continue; /* Not found:  Try next attribute.  */
 360                 }
 361             }
 362
 363           values = ldap_get_values_len (ld, item, attr);
 364
 365           if (!values)
 366             {
 367               if (opt.verbose)
 368                 log_info (_("attribute `%s' not found\n"), attr);
 369               ldap_memfree (attr);
 370               continue;
 371             }
 372
 373           if (opt.verbose)
 374             {
 375               log_info (_("found attribute `%s'\n"), attr);
 376               if (opt.verbose > 1)
 377                 for (idx=0; values[idx]; idx++)
 378                   log_info ("         length[%d]=%d\n",
 379                             idx, (int)values[0]->bv_len);
 380
 381             }
 382
 383           if (opt.multi)
 384             { /*  Write attribute marker. */
 385               unsigned char tmp[5];
 386               size_t n = strlen (attr);
 387
 388               tmp[0] = 'A';
 389               tmp[1] = (n >> 24);
 390               tmp[2] = (n >> 16);
 391               tmp[3] = (n >> 8);
 392               tmp[4] = (n);
 393               if (fwrite (tmp, 5, 1, stdout) != 1
 394                   || fwrite (attr, n, 1, stdout) != 1)
 395                 {
 396                   log_error (_("error writing to stdout: %s\n"),
 397                              strerror (errno));
 398                   ldap_value_free_len (values);
 399                   ldap_memfree (attr);
 400                   ber_free (berctx, 0);
 401                   return -1;
 402                 }
 403             }
 404
 405           for (idx=0; values[idx]; idx++)
 406             {
 407               if (opt.multi)
 408                 { /* Write value marker.  */
 409                   unsigned char tmp[5];
 410                   size_t n = values[0]->bv_len;
 411
 412                   tmp[0] = 'V';
 413                   tmp[1] = (n >> 24);
 414                   tmp[2] = (n >> 16);
 415                   tmp[3] = (n >> 8);
 416                   tmp[4] = (n);
 417
 418                   if (fwrite (tmp, 5, 1, stdout) != 1)
 419                     {
 420                       log_error (_("error writing to stdout: %s\n"),
 421                                  strerror (errno));
 422                       ldap_value_free_len (values);
 423                       ldap_memfree (attr);
 424                       ber_free (berctx, 0);
 425                       return -1;
 426                     }
 427                 }
 428 #if 1
 429               /* Note: this does not work for STDOUT on a Windows
 430                  console, where it fails with "Not enough space" for
 431                  CRLs which are 52 KB or larger.  */
 432               if (fwrite (values[0]->bv_val, values[0]->bv_len,
 433                           1, stdout) != 1)
 434                 {
 435                   log_error (_("error writing to stdout: %s\n"),
 436                              strerror (errno));
 437                   ldap_value_free_len (values);
 438                   ldap_memfree (attr);
 439                   ber_free (berctx, 0);
 440                   return -1;
 441                 }
 442 #else
 443               /* On Windows console STDOUT, we have to break up the
 444                  writes into small parts.  */
 445               {
 446                 int n = 0;
 447                 while (n < values[0]->bv_len)
 448                   {
 449                     int cnt = values[0]->bv_len - n;
 450                     /* The actual limit is (52 * 1024 - 1) on Windows XP SP2.  */
 451 #define MAX_CNT (32*1024)
 452                     if (cnt > MAX_CNT)
 453                       cnt = MAX_CNT;
 454
 455                     if (fwrite (((char *) values[0]->bv_val) + n, cnt, 1,
 456                                 stdout) != 1)
 457                       {
 458                         log_error (_("error writing to stdout: %s\n"),
 459                                    strerror (errno));
 460                         ldap_value_free_len (values);
 461                         ldap_memfree (attr);
 462                         ber_free (berctx, 0);
 463                         return -1;
 464                       }
 465                     n += cnt;
 466                   }
 467               }
 468 #endif
 469               any = 1;
 470               if (!opt.multi)
 471                 break; /* Print only the first value.  */
 472             }
 473           ldap_value_free_len (values);
 474           ldap_memfree (attr);
 475           if (want_attr || !opt.multi)
 476             break; /* We only want to return the first attribute.  */
 477         }
 478       ber_free (berctx, 0);
 479     }
 480
 481   if (opt.verbose > 1 && any)
 482     log_info ("result has been printed\n");
 483
 484   return any?0:-1;
 485 }
 486
 487
 488
 489 /* Helper for the URL based LDAP query. */
 490 static int
 491 fetch_ldap (const char *url, const LDAPURLDesc *ludp)
 492 {
 493   LDAP *ld;
 494   LDAPMessage *msg;
 495   int rc = 0;
 496   char *host, *dn, *filter, *attrs[2], *attr;
 497   int port;
 498
 499   host     = opt.host?   opt.host   : ludp->lud_host;
 500   port     = opt.port?   opt.port   : ludp->lud_port;
 501   dn       = opt.dn?     opt.dn     : ludp->lud_dn;
 502   filter   = opt.filter? opt.filter : ludp->lud_filter;
 503   attrs[0] = opt.attr?   opt.attr   : ludp->lud_attrs? ludp->lud_attrs[0]:NULL;
 504   attrs[1] = NULL;
 505   attr = attrs[0];
 506
 507   if (!port)
 508     port = (ludp->lud_scheme && !strcmp (ludp->lud_scheme, "ldaps"))? 636:389;
 509
 510   if (opt.verbose)
 511     {
 512       log_info (_("processing url `%s'\n"), url);
 513       if (opt.user)
 514         log_info (_("          user `%s'\n"), opt.user);
 515       if (opt.pass)
 516         log_info (_("          pass `%s'\n"), *opt.pass?"*****":"");
 517       if (host)
 518         log_info (_("          host `%s'\n"), host);
 519       log_info (_("          port %d\n"), port);
 520       if (dn)
 521         log_info (_("            DN `%s'\n"), dn);
 522       if (filter)
 523         log_info (_("        filter `%s'\n"), filter);
 524       if (opt.multi && !opt.attr && ludp->lud_attrs)
 525         {
 526           int i;
 527           for (i=0; ludp->lud_attrs[i]; i++)
 528             log_info (_("          attr `%s'\n"), ludp->lud_attrs[i]);
 529         }
 530       else if (attr)
 531         log_info (_("          attr `%s'\n"), attr);
 532     }
 533
 534
 535   if (!host || !*host)
 536     {
 537       log_error (_("no host name in `%s'\n"), url);
 538       return -1;
 539     }
 540   if (!opt.multi && !attr)
 541     {
 542       log_error (_("no attribute given for query `%s'\n"), url);
 543       return -1;
 544     }
 545
 546   if (!opt.multi && !opt.attr
 547       && ludp->lud_attrs && ludp->lud_attrs[0] && ludp->lud_attrs[1])
 548     log_info (_("WARNING: using first attribute only\n"));
 549
 550
 551   set_timeout ();
 552   ld = ldap_init (host, port);
 553   if (!ld)
 554     {
 555       log_error (_("LDAP init to `%s:%d' failed: %s\n"),
 556                  host, port, strerror (errno));
 557       return -1;
 558     }
 559   if (ldap_simple_bind_s (ld, opt.user, opt.pass))
 560     {
 561       log_error (_("binding to `%s:%d' failed: %s\n"),
 562                  host, port, strerror (errno));
 563       /* FIXME: Need deinit (ld)?  */
 564       return -1;
 565     }
 566
 567   set_timeout ();
 568   rc = ldap_search_st (ld, dn, ludp->lud_scope, filter,
 569                        opt.multi && !opt.attr && ludp->lud_attrs?
 570                        ludp->lud_attrs:attrs,
 571                        0,
 572                        &opt.timeout, &msg);
 573   if (rc == LDAP_SIZELIMIT_EXCEEDED && opt.multi)
 574     {
 575       if (fwrite ("E\0\0\0\x09truncated", 14, 1, stdout) != 1)
 576         {
 577           log_error (_("error writing to stdout: %s\n"),
 578                      strerror (errno));
 579           return -1;
 580         }
 581     }
 582   else if (rc)
 583     {
 584       log_error (_("searching `%s' failed: %s\n"),
 585                  url, ldap_err2string (rc));
 586       if (rc != LDAP_NO_SUCH_OBJECT)
 587         {
 588           /* FIXME: Need deinit (ld)?  */
 589           /* Hmmm: Do we need to released MSG in case of an error? */
 590           return -1;
 591         }
 592     }
 593
 594   rc = print_ldap_entries (ld, msg, opt.multi? NULL:attr);
 595
 596   ldap_msgfree (msg);
 597   /* FIXME: Need deinit (ld)?  */
 598   return rc;
 599 }
 600
 601
 602
 603
 604 /* Main processing.  Take the URL and run the LDAP query. The result
 605    is printed to stdout, errors are logged to the log stream. */
 606 static int
 607 process_url (const char *url)
 608 {
 609   int rc;
 610   LDAPURLDesc *ludp = NULL;
 611
 612
 613   if (!ldap_is_ldap_url (url))
 614     {
 615       log_error (_("`%s' is not an LDAP URL\n"), url);
 616       return -1;
 617     }
 618
 619   if (ldap_url_parse (url, &ludp))
 620     {
 621       log_error (_("`%s' is an invalid LDAP URL\n"), url);
 622       return -1;
 623     }
 624
 625   rc = fetch_ldap (url, ludp);
 626
 627   ldap_free_urldesc (ludp);
 628   return rc;
 629 }
 630