lib/init.c

   1 /* init.c       initialization functions
   2  * Copyright (C) 2002  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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  *
  20  */
  21
  22 #include "internal.h"
  23 #include <gcrypt.h>
  24
  25 #define WARNSTR "libshishi: warning: "
  26
  27 #if ENABLE_NLS
  28 char *
  29 _shishi_gettext (const char *str)
  30 {
  31   return dgettext (PACKAGE, str);
  32 }
  33
  34 void
  35 _shishi_gettext_init ()
  36 {
  37   bindtextdomain (PACKAGE, LOCALEDIR);
  38 #ifdef HAVE_BIND_TEXTDOMAIN_CODESET
  39   bind_textdomain_codeset (PACKAGE, "UTF-8");
  40 #endif
  41   textdomain (PACKAGE);
  42 }
  43 #endif /* ENABLE_NLS */
  44
  45 extern const ASN1_ARRAY_TYPE shishi_asn1_tab[];
  46
  47 static ASN1_TYPE
  48 read_asn1 ()
  49 {
  50   ASN1_TYPE definitions = ASN1_TYPE_EMPTY;
  51   int asn1_result = ASN1_SUCCESS;
  52   char errorDescription[MAX_ERROR_DESCRIPTION_SIZE];
  53
  54   asn1_result = asn1_array2tree (shishi_asn1_tab,
  55                                  &definitions, errorDescription);
  56   if (asn1_result != ASN1_SUCCESS)
  57     {
  58       fprintf (stderr, "libshishi: error: %s\n", errorDescription);
  59       fprintf (stderr, "libshishi: error: %s\n",
  60                libtasn1_strerror (asn1_result));
  61       return ASN1_TYPE_EMPTY;
  62     }
  63
  64   return definitions;
  65 }
  66
  67 /**
  68  * shishi_init:
  69  *
  70  * Initializes the Shishi library.  If this function fails, it may print
  71  * diagnostic errors to stderr.
  72  *
  73  * Return Value: Returns Shishi library handle, or %NULL on error.
  74  **/
  75 Shishi *
  76 shishi (void)
  77 {
  78   Shishi *handle;
  79   char *value;
  80   char *tmp;
  81   int res;
  82
  83   handle = (Shishi *) malloc (sizeof (*handle));
  84   if (handle == NULL)
  85     {
  86       fprintf(stderr, "libshishi: error: %s\n",
  87               shishi_strerror (SHISHI_MALLOC_ERROR));
  88       return NULL;
  89     }
  90   memset ((void *) handle, 0, sizeof (*handle));
  91
  92 #if 0
  93   res = gcry_control (GCRYCTL_INIT_SECMEM, 512, 0);
  94   if (res != GCRYERR_SUCCESS)
  95     {
  96       fprintf(stderr, "libshishi: error: %s\n",
  97               shishi_strerror (SHISHI_GCRYPT_ERROR));
  98       return NULL;
  99     }
 100 #else
 101   gcry_control (GCRYCTL_DISABLE_SECMEM, NULL, 0);
 102 #endif
 103
 104   handle->asn1 = read_asn1 ();
 105   if (handle->asn1 == ASN1_TYPE_EMPTY)
 106     {
 107       fprintf(stderr, "libshishi: error: %s\n",
 108               shishi_strerror (SHISHI_ASN1_ERROR));
 109       return NULL;
 110     }
 111
 112   handle->kdctimeout = 5;
 113   handle->kdcretries = 3;
 114
 115   handle->nclientkdcetypes = 1;
 116   handle->clientkdcetypes = malloc (sizeof (*handle->clientkdcetypes) *
 117                                     handle->nclientkdcetypes);
 118   if (handle->clientkdcetypes == NULL)
 119     {
 120       fprintf(stderr, "libshishi: error: %s\n",
 121               shishi_strerror (SHISHI_MALLOC_ERROR));
 122       return NULL;
 123     }
 124   handle->clientkdcetypes[0] = SHISHI_AES256_CTS_HMAC_SHA1_96;
 125
 126   tmp = shishi_realm_default_guess ();
 127   shishi_realm_default_set (handle, tmp);
 128   free (tmp);
 129
 130   tmp = shishi_principal_default_guess ();
 131   if (tmp != NULL)
 132     {
 133       shishi_principal_default_set (handle, tmp);
 134       free (tmp);
 135     }
 136
 137   return handle;
 138 }
 139
 140 int
 141 _shishi_init_read (Shishi * handle,
 142                    const char *ticketsetfile,
 143                    const char *systemcfgfile,
 144                    const char *usercfgfile)
 145 {
 146   int rc = SHISHI_OK;
 147
 148   if (!ticketsetfile)
 149     ticketsetfile = shishi_ticketset_default_file (handle);
 150
 151   if (!systemcfgfile)
 152     systemcfgfile = shishi_cfg_default_systemfile (handle);
 153
 154   if (!usercfgfile)
 155     usercfgfile = shishi_cfg_default_userfile (handle);
 156
 157   if (!handle->ticketset)
 158     rc = shishi_ticketset_init (handle, &handle->ticketset);
 159   if (rc != SHISHI_OK)
 160     return rc;
 161
 162   if (*ticketsetfile)
 163     rc =
 164       shishi_ticketset_from_file (handle, handle->ticketset, ticketsetfile);
 165   if (rc == SHISHI_FOPEN_ERROR)
 166     fprintf (stderr, WARNSTR "%s: %s\n", ticketsetfile, strerror(errno));
 167   if (rc != SHISHI_OK && rc != SHISHI_FOPEN_ERROR)
 168     return rc;
 169
 170   if (*systemcfgfile)
 171     rc = shishi_cfg_from_file (handle, systemcfgfile);
 172   if (rc == SHISHI_FOPEN_ERROR)
 173     fprintf (stderr, WARNSTR "%s: %s\n", systemcfgfile, strerror(errno));
 174   if (rc != SHISHI_OK && rc != SHISHI_FOPEN_ERROR)
 175     return rc;
 176
 177   if (*usercfgfile)
 178     rc = shishi_cfg_from_file (handle, usercfgfile);
 179   if (rc == SHISHI_FOPEN_ERROR)
 180     fprintf (stderr, WARNSTR "%s: %s\n", usercfgfile, strerror(errno));
 181   if (rc != SHISHI_OK && rc != SHISHI_FOPEN_ERROR)
 182     return rc;
 183
 184   if (VERBOSE (handle))
 185     shishi_cfg_print (handle, stdout);
 186
 187   return SHISHI_OK;
 188 }
 189
 190 /**
 191  * shishi_init:
 192  * @handle: pointer to handle to be created.
 193  *
 194  * Create a Shishi library handle and read the system configuration
 195  * file, user configuration file and user tickets from the defaul
 196  * paths.  The paths to the system configuration file is decided at
 197  * compile time, and is $sysconfdir/shishi.conf.  The user
 198  * configuration file is $HOME/.shishi/config, and the user ticket
 199  * file is $HOME/.shishi/ticket.  The handle is allocated regardless
 200  * of return values, except for SHISHI_HANDLE_ERROR which indicates a
 201  * problem allocating the handle.  (The other error conditions comes
 202  * from reading the files.)
 203  *
 204  * Return value: Returns SHISHI_OK iff successful.
 205  **/
 206 int
 207 shishi_init (Shishi ** handle)
 208 {
 209   if (!handle || !(*handle = shishi ()))
 210     return SHISHI_HANDLE_ERROR;
 211
 212   return _shishi_init_read (*handle, shishi_ticketset_default_file (*handle),
 213                             shishi_cfg_default_systemfile (*handle),
 214                             shishi_cfg_default_userfile (*handle));
 215 }
 216
 217 /**
 218  * shishi_init_with_paths:
 219  * @handle: pointer to handle to be created.
 220  * @ticketsetfile: Filename of ticket file, or NULL.
 221  * @systemcfgfile: Filename of system configuration, or NULL.
 222  * @usercfgfile: Filename of user configuration, or NULL.
 223  *
 224  * Like shishi_init() but use explicit paths.  Like shishi_init(), the
 225  * handle is allocated regardless of return values, except for
 226  * SHISHI_HANDLE_ERROR which indicates a problem allocating the
 227  * handle.  (The other error conditions comes from reading the files.)
 228  *
 229  * Return value: Returns SHISHI_OK iff successful.
 230  **/
 231 int
 232 shishi_init_with_paths (Shishi ** handle,
 233                         const char *ticketsetfile,
 234                         const char *systemcfgfile,
 235                         const char *usercfgfile)
 236 {
 237   if (!handle || !(*handle = shishi ()))
 238     return SHISHI_HANDLE_ERROR;
 239
 240   shishi_ticketset_default_file_set (*handle, ticketsetfile);
 241
 242   return _shishi_init_read (*handle, ticketsetfile,
 243                             systemcfgfile, usercfgfile);
 244 }
 245
 246 /* XXX remove these: */
 247
 248 ASN1_TYPE
 249 shishi_last_authenticator (Shishi * handle)
 250 {
 251   return handle->lastauthenticator;
 252 }
 253
 254 ASN1_TYPE
 255 shishi_last_apreq (Shishi * handle)
 256 {
 257   return handle->lastapreq;
 258 }
 259
 260 ASN1_TYPE
 261 shishi_last_aprep (Shishi * handle)
 262 {
 263   return handle->lastaprep;
 264 }
 265
 266 ASN1_TYPE
 267 shishi_last_encapreppart (Shishi * handle)
 268 {
 269   return handle->lastencapreppart;
 270 }
 271
 272 void
 273 shishi_warn (Shishi * handle, char *fmt, ...)
 274 {
 275   va_list ap;
 276   va_start (ap, fmt);
 277   if (VERBOSE (handle))
 278     {
 279       fprintf (stderr, WARNSTR);
 280       vfprintf (stderr, fmt, ap);
 281       fprintf (stderr, "\n");
 282     }
 283   va_end (ap);
 284 }