lib/init.c

   1 /* init.c --- Initialization functions.
   2  * Copyright (C) 2002, 2003, 2004, 2006  Simon Josefsson
   3  *
   4  * This file is part of Shishi.
   5  *
   6  * Shishi 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  * Shishi 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 Shishi; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
  19  *
  20  */
  21
  22 #include "internal.h"
  23
  24 /* Get _shishi_tls_init. */
  25 #include "starttls.h"
  26
  27 /* Get _shishi_crypto_init. */
  28 #include "crypto.h"
  29
  30 /* Get _shishi_asn1_init. */
  31 #include "asn1.h"
  32
  33 static Shishi *
  34 init_handle (int outputtype)
  35 {
  36   Shishi *handle;
  37   int rc;
  38
  39   handle = xcalloc (1, sizeof (*handle));
  40
  41   shishi_error_set_outputtype (handle, outputtype);
  42
  43   if (!shishi_check_version (SHISHI_VERSION))
  44     {
  45       shishi_warn (handle, "Library and header version missmatch (%s vs %s).",
  46                    shishi_check_version (NULL), SHISHI_VERSION);
  47       free (handle);
  48       return NULL;
  49     }
  50
  51   rc = _shishi_crypto_init (handle);
  52   if (rc != SHISHI_OK)
  53     {
  54       shishi_warn (handle, "Cannot initialize crypto library");
  55       free (handle);
  56       return NULL;
  57     }
  58
  59 #ifdef USE_STARTTLS
  60   rc = _shishi_tls_init (handle);
  61   if (rc != SHISHI_OK)
  62     {
  63       shishi_warn (handle, "Cannot initialize TLS library");
  64       free (handle);
  65       return NULL;
  66     }
  67 #endif
  68
  69   rc = _shishi_asn1_init (handle);
  70   if (rc != SHISHI_OK)
  71     {
  72       shishi_warn (handle, "%s", shishi_strerror (SHISHI_ASN1_ERROR));
  73       free (handle);
  74       return NULL;
  75     }
  76
  77   bindtextdomain (PACKAGE, LOCALEDIR);
  78   textdomain (PACKAGE);
  79
  80   handle->kdctimeout = 5;
  81   handle->kdcretries = 3;
  82
  83   handle->ticketlife = TICKETLIFE;
  84   handle->renewlife = RENEWLIFE;
  85
  86   handle->nclientkdcetypes = 1;
  87   handle->clientkdcetypes = xmalloc (sizeof (*handle->clientkdcetypes) *
  88                                      handle->nclientkdcetypes);
  89   handle->clientkdcetypes[0] = SHISHI_AES256_CTS_HMAC_SHA1_96;
  90
  91   handle->nauthorizationtypes = 1;
  92   handle->authorizationtypes = xmalloc (sizeof (*handle->authorizationtypes) *
  93                                         handle->nauthorizationtypes);
  94   handle->authorizationtypes[0] = SHISHI_AUTHORIZATION_BASIC;
  95
  96   return handle;
  97 }
  98
  99 /**
 100  * shishi:
 101  *
 102  * Initializes the Shishi library, and set up, using
 103  * shishi_error_set_outputtype(), the library so that future warnings
 104  * and informational messages are printed to stderr.  If this function
 105  * fails, it may print diagnostic errors to stderr.
 106  *
 107  * Return value: Returns Shishi library handle, or %NULL on error.
 108  **/
 109 Shishi *
 110 shishi (void)
 111 {
 112   return init_handle (SHISHI_OUTPUTTYPE_STDERR);
 113 }
 114
 115 /**
 116  * shishi_server:
 117  *
 118  * Initializes the Shishi library, and set up, using
 119  * shishi_error_set_outputtype(), the library so that future warnings
 120  * and informational messages are printed to the syslog.  If this
 121  * function fails, it may print diagnostic errors to the syslog.
 122  *
 123  * Return value: Returns Shishi library handle, or %NULL on error.
 124  **/
 125 Shishi *
 126 shishi_server (void)
 127 {
 128   return init_handle (SHISHI_OUTPUTTYPE_SYSLOG);
 129 }
 130
 131 /**
 132  * shishi_done:
 133  * @handle: shishi handle as allocated by shishi_init().
 134  *
 135  * Deallocates the shishi library handle.  The handle must not be used
 136  * in any calls to shishi functions after this.
 137  *
 138  * If there is a default tkts, it is written to the default tkts file
 139  * (call shishi_tkts_default_file_set() to change the default tkts
 140  * file). If you do not wish to write the default tkts file, close the
 141  * default tkts with shishi_tkts_done(handle, NULL) before calling
 142  * this function.
 143  **/
 144 void
 145 shishi_done (Shishi * handle)
 146 {
 147   int rc;
 148
 149   if (handle->tkts)
 150     {
 151       shishi_tkts_to_file (handle->tkts, shishi_tkts_default_file (handle));
 152       shishi_tkts_done (&handle->tkts);
 153     }
 154
 155   shishi_principal_default_set (handle, NULL);
 156   shishi_tkts_default_file_set (handle, NULL);
 157
 158 #ifdef USE_STARTTLS
 159   rc = _shishi_tls_done (handle);
 160   if (rc != SHISHI_OK)
 161     shishi_warn (handle, "Cannot deinitialize TLS library");
 162 #endif
 163
 164   if (handle->realminfos)
 165     {
 166       size_t i;
 167
 168       for (i= 0; i < handle->nrealminfos; i++)
 169         {
 170           size_t j;
 171
 172           if (handle->realminfos[i].kdcaddresses)
 173             free (handle->realminfos[i].kdcaddresses);
 174
 175           if (handle->realminfos[i].name)
 176             free (handle->realminfos[i].name);
 177         }
 178     }
 179
 180   if (handle->default_realm)
 181     free (handle->default_realm);
 182   if (handle->usercfgfile)
 183     free (handle->usercfgfile);
 184   if (handle->hostkeysdefaultfile)
 185     free (handle->hostkeysdefaultfile);
 186   if (handle->clientkdcetypes)
 187     free (handle->clientkdcetypes);
 188   if (handle->authorizationtypes)
 189     free (handle->authorizationtypes);
 190   if (handle->stringprocess)
 191     free (handle->stringprocess);
 192   if (handle->userdirectory)
 193     free (handle->userdirectory);
 194
 195   if (handle->asn1)
 196     shishi_asn1_done (handle, handle->asn1);
 197
 198   free (handle);
 199 }
 200
 201 static void
 202 maybe_install_usercfg (Shishi * handle)
 203 {
 204   const char *usercfg = shishi_cfg_default_userfile (handle);
 205   const char *userdir = shishi_cfg_default_userdirectory (handle);
 206   struct stat buf;
 207   FILE *fh;
 208   FILE *src, *dst;
 209   int rc;
 210   int c;
 211
 212   /* Don't create anything if non-standard home is used. */
 213   if (getenv ("SHISHI_HOME"))
 214     return;
 215
 216   fh = fopen (usercfg, "r");
 217   if (fh)
 218     {
 219       fclose (fh);
 220       return;
 221     }
 222
 223   rc = stat (userdir, &buf);
 224   if (rc == -1 && errno == ENOENT)
 225     {
 226       rc = mkdir (userdir, S_IRUSR | S_IWUSR | S_IXUSR);
 227       if (rc != 0)
 228         shishi_info (handle, "mkdir %s: %s", userdir, strerror (errno));
 229     }
 230   else if (rc != 0)
 231     shishi_info (handle, "stat %s: %s", userdir, strerror (errno));
 232
 233   src = fopen (SKELCFGFILE, "r");
 234   if (!src)
 235     {
 236       shishi_info (handle, "open %s: %s", SKELCFGFILE, strerror (errno));
 237       return;
 238     }
 239
 240   dst = fopen (usercfg, "w");
 241   if (!dst)
 242     {
 243       fclose (src);
 244       shishi_info (handle, "open %s: %s", usercfg, strerror (errno));
 245       return;
 246     }
 247
 248   while ((c = getc (src)) != EOF)
 249     putc (c, dst);
 250
 251   fclose (dst);
 252   fclose (src);
 253
 254   shishi_info (handle, "created `%s'", usercfg);
 255 }
 256
 257 static int
 258 init_read (Shishi * handle,
 259            const char *tktsfile,
 260            const char *systemcfgfile, const char *usercfgfile)
 261 {
 262   int rc = SHISHI_OK;
 263
 264   /* XXX Is this the correct place for this? */
 265   maybe_install_usercfg (handle);
 266
 267   if (!tktsfile)
 268     tktsfile = shishi_tkts_default_file (handle);
 269
 270   if (!systemcfgfile)
 271     systemcfgfile = shishi_cfg_default_systemfile (handle);
 272
 273   if (!usercfgfile)
 274     usercfgfile = shishi_cfg_default_userfile (handle);
 275
 276   if (!handle->tkts)
 277     rc = shishi_tkts (handle, &handle->tkts);
 278   if (rc != SHISHI_OK)
 279     return rc;
 280
 281   if (*tktsfile)
 282     rc = shishi_tkts_from_file (handle->tkts, tktsfile);
 283   if (rc == SHISHI_FOPEN_ERROR)
 284     shishi_warn (handle, "%s: %s", tktsfile, strerror (errno));
 285   if (rc != SHISHI_OK && rc != SHISHI_FOPEN_ERROR)
 286     return rc;
 287
 288   if (*systemcfgfile)
 289     rc = shishi_cfg_from_file (handle, systemcfgfile);
 290   if (rc == SHISHI_FOPEN_ERROR)
 291     shishi_warn (handle, "%s: %s", systemcfgfile, strerror (errno));
 292   if (rc != SHISHI_OK && rc != SHISHI_FOPEN_ERROR)
 293     return rc;
 294
 295   if (*usercfgfile)
 296     rc = shishi_cfg_from_file (handle, usercfgfile);
 297   if (rc == SHISHI_FOPEN_ERROR)
 298     shishi_warn (handle, "%s: %s", usercfgfile, strerror (errno));
 299   if (rc != SHISHI_OK && rc != SHISHI_FOPEN_ERROR)
 300     return rc;
 301
 302   if (VERBOSENOISE (handle))
 303     shishi_cfg_print (handle, stderr);
 304
 305   return SHISHI_OK;
 306 }
 307
 308 /**
 309  * shishi_init:
 310  * @handle: pointer to handle to be created.
 311  *
 312  * Create a Shishi library handle, using shishi(), and read the system
 313  * configuration file, user configuration file and user tickets from
 314  * their default locations.  The paths to the system configuration
 315  * file is decided at compile time, and is $sysconfdir/shishi.conf.
 316  * The user configuration file is $HOME/.shishi/config, and the user
 317  * ticket file is $HOME/.shishi/ticket.
 318  *
 319  * The handle is allocated regardless of return values, except for
 320  * SHISHI_HANDLE_ERROR which indicates a problem allocating the
 321  * handle.  (The other error conditions comes from reading the files.)
 322  *
 323  * Return value: Returns SHISHI_OK iff successful.
 324  **/
 325 int
 326 shishi_init (Shishi ** handle)
 327 {
 328   if (!handle || !(*handle = shishi ()))
 329     return SHISHI_HANDLE_ERROR;
 330
 331   return init_read (*handle, shishi_tkts_default_file (*handle),
 332                     shishi_cfg_default_systemfile (*handle),
 333                     shishi_cfg_default_userfile (*handle));
 334 }
 335
 336 /**
 337  * shishi_init_with_paths:
 338  * @handle: pointer to handle to be created.
 339  * @tktsfile: Filename of ticket file, or NULL.
 340  * @systemcfgfile: Filename of system configuration, or NULL.
 341  * @usercfgfile: Filename of user configuration, or NULL.
 342  *
 343  * Create a Shishi library handle, using shishi(), and read the system
 344  * configuration file, user configuration file, and user tickets from
 345  * the specified locations.  If any of @usercfgfile or @systemcfgfile
 346  * is NULL, the file is read from its default location, which for the
 347  * system configuration file is decided at compile time, and is
 348  * $sysconfdir/shishi.conf, and for the user configuration file is
 349  * $HOME/.shishi/config.  If the ticket file is NULL, a ticket file is
 350  * not read at all.
 351  *
 352  * The handle is allocated regardless of return values, except for
 353  * SHISHI_HANDLE_ERROR which indicates a problem allocating the
 354  * handle.  (The other error conditions comes from reading the files.)
 355  *
 356  * Return value: Returns SHISHI_OK iff successful.
 357  **/
 358 int
 359 shishi_init_with_paths (Shishi ** handle,
 360                         const char *tktsfile,
 361                         const char *systemcfgfile, const char *usercfgfile)
 362 {
 363   if (!handle || !(*handle = shishi ()))
 364     return SHISHI_HANDLE_ERROR;
 365
 366   shishi_tkts_default_file_set (*handle, tktsfile);
 367
 368   return init_read (*handle, tktsfile, systemcfgfile, usercfgfile);
 369 }
 370
 371 /**
 372  * shishi_init_server:
 373  * @handle: pointer to handle to be created.
 374  *
 375  * Create a Shishi library handle, using shishi_server(), and read the
 376  * system configuration file.  The paths to the system configuration
 377  * file is decided at compile time, and is $sysconfdir/shishi.conf.
 378  *
 379  * The handle is allocated regardless of return values, except for
 380  * SHISHI_HANDLE_ERROR which indicates a problem allocating the
 381  * handle.  (The other error conditions comes from reading the file.)
 382  *
 383  * Return value: Returns SHISHI_OK iff successful.
 384  **/
 385 int
 386 shishi_init_server (Shishi ** handle)
 387 {
 388   int rc;
 389
 390   if (!handle || !(*handle = shishi_server ()))
 391     return SHISHI_HANDLE_ERROR;
 392
 393   rc = shishi_cfg_from_file (*handle,
 394                              shishi_cfg_default_systemfile (*handle));
 395   if (rc == SHISHI_FOPEN_ERROR)
 396     shishi_warn (*handle, "%s: %s", shishi_cfg_default_systemfile (*handle),
 397                  strerror (errno));
 398   if (rc != SHISHI_OK && rc != SHISHI_FOPEN_ERROR)
 399     return rc;
 400
 401   return SHISHI_OK;
 402 }
 403
 404 /**
 405  * shishi_init_server_with_paths:
 406  * @handle: pointer to handle to be created.
 407  * @systemcfgfile: Filename of system configuration, or NULL.
 408  *
 409  * Create a Shishi library handle, using shishi_server(), and read the
 410  * system configuration file from specified location.  The paths to
 411  * the system configuration file is decided at compile time, and is
 412  * $sysconfdir/shishi.conf.  The handle is allocated regardless of
 413  * return values, except for SHISHI_HANDLE_ERROR which indicates a
 414  * problem allocating the handle.  (The other error conditions comes
 415  * from reading the file.)
 416  *
 417  * Return value: Returns SHISHI_OK iff successful.
 418  **/
 419 int
 420 shishi_init_server_with_paths (Shishi ** handle, const char *systemcfgfile)
 421 {
 422   int rc;
 423
 424   if (!handle || !(*handle = shishi_server ()))
 425     return SHISHI_HANDLE_ERROR;
 426
 427   if (!systemcfgfile)
 428     systemcfgfile = shishi_cfg_default_systemfile (*handle);
 429
 430   rc = shishi_cfg_from_file (*handle, systemcfgfile);
 431   if (rc == SHISHI_FOPEN_ERROR)
 432     shishi_warn (*handle, "%s: %s", systemcfgfile, strerror (errno));
 433   if (rc != SHISHI_OK && rc != SHISHI_FOPEN_ERROR)
 434     return rc;
 435
 436   return SHISHI_OK;
 437 }