lib/keys.c

   1 /* keys.c --- Functions for managing keys sets, and keys stored in files.
   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 struct Shishi_keys
  25 {
  26   Shishi *handle;
  27   Shishi_key **keys;
  28   int nkeys;
  29 };
  30
  31 /**
  32  * shishi_keys:
  33  * @handle: shishi handle as allocated by shishi_init().
  34  * @keys: output pointer to newly allocated keys handle.
  35  *
  36  * Get a new key set handle.
  37  *
  38  * Return value: Returns %SHISHI_OK iff successful.
  39  **/
  40 int
  41 shishi_keys (Shishi * handle, Shishi_keys ** keys)
  42 {
  43   *keys = xmalloc (sizeof (**keys));
  44
  45   (*keys)->handle = handle;
  46   (*keys)->keys = NULL;
  47   (*keys)->nkeys = 0;
  48
  49   return SHISHI_OK;
  50 }
  51
  52 /**
  53  * shishi_keys_done:
  54  * @keys: key set handle as allocated by shishi_keys().
  55  *
  56  * Deallocates all resources associated with key set.  The key set
  57  * handle must not be used in calls to other shishi_keys_*() functions
  58  * after this.
  59  **/
  60 void
  61 shishi_keys_done (Shishi_keys ** keys)
  62 {
  63   size_t i;
  64
  65   if (!keys || !*keys)
  66     return;
  67
  68   if ((*keys)->nkeys > 0)
  69     for (i = (*keys)->nkeys; i > 0; i--)
  70       shishi_key_done ((*keys)->keys[i - 1]);
  71
  72   if ((*keys)->keys)
  73     free ((*keys)->keys);
  74
  75   free (*keys);
  76
  77   *keys = NULL;
  78
  79   return;
  80 }
  81
  82 /**
  83  * shishi_keys_size:
  84  * @keys: key set handle as allocated by shishi_keys().
  85  *
  86  * Get size of key set.
  87  *
  88  * Return value: Returns number of keys stored in key set.
  89  **/
  90 int
  91 shishi_keys_size (Shishi_keys * keys)
  92 {
  93   return keys->nkeys;
  94 }
  95
  96 /**
  97  * shishi_keys_nth:
  98  * @keys: key set handle as allocated by shishi_keys().
  99  * @keyno: integer indicating requested key in key set.
 100  *
 101  * Get the n:th ticket in key set.
 102  *
 103  * Return value: Returns a key handle to the keyno:th key in the key
 104  *   set, or NULL if @keys is invalid or @keyno is out of bounds.  The
 105  *   first key is @keyno 0, the second key @keyno 1, and so on.
 106  **/
 107 const Shishi_key *
 108 shishi_keys_nth (Shishi_keys * keys, int keyno)
 109 {
 110   if (keys == NULL || keyno >= keys->nkeys)
 111     return NULL;
 112
 113   return keys->keys[keyno];
 114 }
 115
 116 /**
 117  * shishi_keys_remove:
 118  * @keys: key set handle as allocated by shishi_keys().
 119  * @keyno: key number of key in the set to remove.  The first
 120  *   key is key number 0.
 121  *
 122  * Remove a key, indexed by @keyno, in given key set.
 123  **/
 124 void
 125 shishi_keys_remove (Shishi_keys * keys, int keyno)
 126 {
 127   shishi_key_done (keys->keys[keyno]);
 128
 129   if (keyno < keys->nkeys)
 130     memmove (&keys->keys[keyno], &keys->keys[keyno + 1],
 131              sizeof (*keys->keys) * (keys->nkeys - keyno - 1));
 132
 133   --keys->nkeys;
 134
 135   keys->keys = xrealloc (keys->keys, sizeof (*keys->keys) * keys->nkeys);
 136 }
 137
 138 /**
 139  * shishi_keys_add:
 140  * @keys: key set handle as allocated by shishi_keys().
 141  * @key: key to be added to key set.
 142  *
 143  * Add a key to the key set.  A deep copy of the key is stored, so
 144  * changing @key, or deallocating it, will not modify the value stored
 145  * in the key set.
 146  *
 147  * Return value: Returns SHISHI_OK iff succesful.
 148  **/
 149 int
 150 shishi_keys_add (Shishi_keys * keys, Shishi_key * key)
 151 {
 152   int rc;
 153
 154   if (!key)
 155     return SHISHI_INVALID_KEY;
 156
 157   keys->nkeys++;
 158
 159   keys->keys = xrealloc (keys->keys, sizeof (*keys->keys) * keys->nkeys);
 160
 161   rc = shishi_key (keys->handle, &(keys->keys[keys->nkeys - 1]));
 162   if (rc != SHISHI_OK)
 163     return rc;
 164
 165   shishi_key_copy (keys->keys[keys->nkeys - 1], key);
 166
 167   return SHISHI_OK;
 168 }
 169
 170 /**
 171  * shishi_keys_print:
 172  * @keys: key set to print.
 173  * @fh: file handle, open for writing, to print keys to.
 174  *
 175  * Print all keys in set using shishi_key_print.
 176  *
 177  * Returns: Returns %SHISHI_OK on success.
 178  **/
 179 int
 180 shishi_keys_print (Shishi_keys * keys, FILE *fh)
 181 {
 182   int rc;
 183   size_t i;
 184
 185   for (i = 0; i < keys->nkeys; i++)
 186     {
 187       rc = shishi_key_print (keys->handle, fh, shishi_keys_nth (keys, i));
 188       if (rc != SHISHI_OK)
 189         return rc;
 190
 191       fprintf (fh, "\n");
 192     }
 193
 194   return SHISHI_OK;
 195 }
 196
 197 /**
 198  * shishi_keys_to_file:
 199  * @handle: shishi handle as allocated by shishi_init().
 200  * @filename: filename to append key to.
 201  * @keys: set of keys to print.
 202  *
 203  * Print an ASCII representation of a key structure to a file, for
 204  * each key in the key set.  The file is appended to if it exists.
 205  * See shishi_key_print() for the format of the output.
 206  *
 207  * Return value: Returns %SHISHI_OK iff successful.
 208  **/
 209 int
 210 shishi_keys_to_file (Shishi * handle,
 211                      const char *filename,
 212                      Shishi_keys * keys)
 213 {
 214   FILE *fh;
 215   int res;
 216
 217   if (VERBOSE (handle))
 218     printf (_("Writing KEYS to %s...\n"), filename);
 219
 220   fh = fopen (filename, "a");
 221   if (fh == NULL)
 222     return SHISHI_FOPEN_ERROR;
 223
 224   res = shishi_keys_print (keys, fh);
 225   if (res != SHISHI_OK)
 226     return res;
 227
 228   res = fclose (fh);
 229   if (res != 0)
 230     return SHISHI_IO_ERROR;
 231
 232   if (VERBOSE (handle))
 233     printf (_("Writing KEYS to %s...done\n"), filename);
 234
 235   return SHISHI_OK;
 236 }
 237
 238 /**
 239  * shishi_keys_for_serverrealm_in_file
 240  * @handle: Shishi library handle create by shishi_init().
 241  * @filename: file to read keys from.
 242  * @server: server name to get key for.
 243  * @realm: realm of server to get key for.
 244  *
 245  * Get keys that match specified @server and @realm from the key set
 246  * file @filename.
 247  *
 248  * Return value: Returns the key for specific server and realm, read
 249  *   from the indicated file, or NULL if no key could be found or an
 250  *   error encountered.
 251  **/
 252 Shishi_key *
 253 shishi_keys_for_serverrealm_in_file (Shishi * handle,
 254                                      const char *filename,
 255                                      const char *server, const char *realm)
 256 {
 257   Shishi_key *key = NULL;
 258   FILE *fh;
 259   int res;
 260
 261   fh = fopen (filename, "r");
 262   if (fh == NULL)
 263     return NULL;
 264
 265   res = SHISHI_OK;
 266   while (!feof (fh))
 267     {
 268       res = shishi_key_parse (handle, fh, &key);
 269       if (res != SHISHI_OK || key == NULL)
 270         break;
 271
 272       if (VERBOSENOISE (handle))
 273         {
 274           printf ("Read key:\n");
 275           shishi_key_print (handle, stdout, key);
 276         }
 277
 278       if ((!server ||
 279            (shishi_key_principal (key) &&
 280             strcmp (server, shishi_key_principal (key)) == 0)) &&
 281           (!realm ||
 282            (shishi_key_realm (key) &&
 283             strcmp (realm, shishi_key_realm (key)) == 0)))
 284         break;
 285
 286       shishi_key_done (key);
 287       key = NULL;
 288     }
 289
 290   res = fclose (fh);
 291   if (res != 0)
 292     return NULL;
 293
 294   return key;
 295 }
 296
 297 /**
 298  * shishi_keys_for_server_in_file
 299  * @handle: Shishi library handle create by shishi_init().
 300  * @filename: file to read keys from.
 301  * @server: server name to get key for.
 302  *
 303  * Get key for specified @server from @filename.
 304  *
 305  * Return value: Returns the key for specific server, read from the
 306  *   indicated file, or NULL if no key could be found or an error
 307  *   encountered.
 308  **/
 309 Shishi_key *
 310 shishi_keys_for_server_in_file (Shishi * handle,
 311                                 const char *filename, const char *server)
 312 {
 313   return shishi_keys_for_serverrealm_in_file (handle, filename, server, NULL);
 314 }
 315
 316 /**
 317  * shishi_keys_for_localservicerealm_in_file:
 318  * @handle: Shishi library handle create by shishi_init().
 319  * @filename: file to read keys from.
 320  * @service: service to get key for.
 321  * @realm: realm of server to get key for, or NULL for default realm.
 322  *
 323  * Get key for specified @service and @realm from @filename.
 324  *
 325  * Return value: Returns the key for the server
 326  * "SERVICE/HOSTNAME@REALM" (where HOSTNAME is the current system's
 327  * hostname), read from the default host keys file (see
 328  * shishi_hostkeys_default_file()), or NULL if no key could be found
 329  * or an error encountered.
 330  **/
 331 Shishi_key *
 332 shishi_keys_for_localservicerealm_in_file (Shishi * handle,
 333                                            const char *filename,
 334                                            const char *service,
 335                                            const char *realm)
 336 {
 337   char *hostname;
 338   char *server;
 339   Shishi_key *key;
 340
 341   hostname = xgethostname ();
 342
 343   asprintf (&server, "%s/%s", service, hostname);
 344
 345   key = shishi_keys_for_serverrealm_in_file (handle, filename, server, realm);
 346
 347   free (server);
 348   free (hostname);
 349
 350   return key;
 351 }