3 * $Id: key-io.c,v 1.5 2003/10/17 16:30:46 mdw Exp $
5 * Adding new keys to a key file
7 * (c) 1999 Straylight/Edgeware
10 /*----- Licensing notice --------------------------------------------------*
12 * This file is part of Catacomb.
14 * Catacomb is free software; you can redistribute it and/or modify
15 * it under the terms of the GNU Library General Public License as
16 * published by the Free Software Foundation; either version 2 of the
17 * License, or (at your option) any later version.
19 * Catacomb is distributed in the hope that it will be useful,
20 * but WITHOUT ANY WARRANTY; without even the implied warranty of
21 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
22 * GNU Library General Public License for more details.
24 * You should have received a copy of the GNU Library General Public
25 * License along with Catacomb; if not, write to the Free
26 * Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
30 /*----- Revision history --------------------------------------------------*
33 * Revision 1.5 2003/10/17 16:30:46 mdw
34 * Report errors if key files don't exist!
36 * Revision 1.4 2001/02/03 11:57:38 mdw
37 * Allow creating keyfiles with no file attached.
39 * Revision 1.3 2001/01/20 11:56:48 mdw
40 * Use mLib exported tuning parameters for hashtable.
42 * Revision 1.2 2000/02/12 18:21:02 mdw
43 * Overhaul of key management (again).
45 * Revision 1.1 1999/12/22 15:47:48 mdw
46 * Major key-management revision.
50 /*----- Header files ------------------------------------------------------*/
59 #include <mLib/bits.h>
60 #include <mLib/crc32.h>
61 #include <mLib/dstr.h>
62 #include <mLib/hash.h>
70 /*----- Tweakable macros --------------------------------------------------*/
74 /*----- Low-level functions -----------------------------------------------*/
78 * Arguments: @key_file *f@ = pointer to file structure
79 * @key *k@ = pointer to key block to insert
81 * Returns: Error code (one of the @KERR@ code).
83 * Use: Links a new key block into the complicated data structure
84 * which is a keyring file.
87 static int insert(key_file *f, key *k)
92 /* --- Sanity preservatives --- */
94 if (key_chkident(k->type))
95 return (KERR_BADTYPE);
96 else if (k->tag && key_chkident(k->tag))
99 /* --- Insert into the tag table --- */
102 kr = sym_find(&f->bytag, k->tag, -1, sizeof(*kr), &found);
104 return (KERR_DUPTAG);
108 /* --- Insert into the id table --- */
113 bin = HASH_BIN(&f->byid, k->id);
114 for (b = *bin; b; b = b->next) {
115 if (b->hash == k->id) {
117 sym_remove(&f->bytag, kr);
127 /* --- Extend the table --- */
131 else if (hash_extend(&f->byid))
132 f->idload = SYM_LIMIT(f->byid.mask / 2);
134 /* --- Insert into the type table --- */
136 kr = sym_find(&f->bytype, k->type, -1, sizeof(*kr), &found);
142 if (k->exp != KEXP_FOREVER) {
143 while (*p && (*p)->exp != KEXP_EXPIRE && (*p)->exp > k->exp)
153 /*----- Reading and writing keys ------------------------------------------*/
155 /* --- @exptime@ --- *
157 * Arguments: @const char *p@ = pointer to string
159 * Returns: Time value.
161 * Use: Translates an expiry or deletion time.
164 time_t exptime(const char *p)
166 size_t sz = strlen(p);
167 if (strncmp(p, "expired", sz) == 0)
168 return (KEXP_EXPIRE);
169 else if (strncmp(p, "forever", sz) == 0)
170 return (KEXP_FOREVER);
175 /* --- @key_merge@ --- *
177 * Arguments: @key_file *f@ = pointer to file structure
178 * @const char *file@ = name of file (for error messages)
179 * @FILE *fp@ = file handle to read from
180 * @key_reporter *rep@ = error reporting function
181 * @void *arg@ = argument for function
183 * Returns: Error code (one of the @KERR@ constants).
185 * Use: Reads keys from a file, and inserts them into the file.
188 int key_merge(key_file *f, const char *file, FILE *fp,
189 key_reporter *rep, void *arg)
193 dstr n = DSTR_INIT, v = DSTR_INIT;
195 if (!(f->f & KF_WRITE))
196 return (KERR_READONLY);
198 for (; dstr_putline(&l, fp) != EOF; DRESET(&l)) {
203 /* --- Skip blank lines and comments --- *
205 * Quite what they're doing in what ought to be an automatically-
206 * maintained file I don't know.
210 while (isspace((unsigned char)*p))
212 if (!*p || *p == '#')
215 /* --- Break the line into fields --- *
217 * There are currently six fields of interest:
219 * * The key's identification (id, tag and type).
220 * * The actual key data itself.
221 * * The key expiry time.
222 * * The key deletion time.
223 * * The attributes field.
224 * * Any further comments.
226 * All but the last field can contain no spaces.
230 int n = str_split(p, vf, 5, &vf[5]);
233 rep(file, line, "too few fields", arg);
238 /* --- Allocate a new key block --- */
242 /* --- Extract the key data into the block --- */
244 if (key_read(vf[1], &k->k, 0)) {
246 rep(file, line, "bad key data", arg);
250 /* --- Decode the identification field --- *
252 * For compatibility, derive a keyid from the key data. This can only be
253 * done if the key encoding is binary (and presumably old-encoding binary
258 char *q = strchr(vf[0], ':');
262 if (k->k.e != KENC_BINARY) {
264 rep(file, line, "new-style key encoding but no keyid", arg);
267 k->id = crc32(0, k->k.u.k.k, k->k.u.k.sz);
268 k->type = xstrdup(vf[0]);
272 k->id = strtoul(p, 0, 16);
273 if ((qq = strchr(q, ':')) == 0 || !qq[1]) {
279 k->tag = xstrdup(qq);
281 k->type = xstrdup(q);
285 /* --- Get a key block for the new key --- */
287 k->exp = exptime(vf[2]);
288 k->del = exptime(vf[3]);
290 /* --- Insert the key block into the table --- */
296 if ((err = insert(f, k)) < 0) {
297 if (err == KERR_DUPTAG) {
299 rep(file, line, "duplicate key tag stripped", arg);
305 rep(file, line, key_strerror(err), arg);
310 /* --- Parse up the attributes, if specified --- */
313 if (vf[4] && strcmp(vf[4], "-") != 0) {
315 for (url_initdec(&uc, vf[4]); url_dec(&uc, &n, &v); ) {
316 key_putattr(f, k, n.buf, v.buf);
317 DRESET(&n); DRESET(&v);
321 /* --- Insert the comment --- */
324 k->c = xstrdup(vf[5]);
329 /* --- Tidy up after something going wrong --- */
342 /* --- Extensive tidying up now required --- */
351 /* --- @key_extract@ --- *
353 * Arguments: @key_file *f@ = pointer to file structure
354 * @key *k@ = key to extract
355 * @FILE *fp@ = file to write on
356 * @const key_filter *kf@ = pointer to key selection block
358 * Returns: Zero if OK, EOF on error.
360 * Use: Extracts a key to an ouptut file.
363 int key_extract(key_file *f, key *k, FILE *fp, const key_filter *kf)
368 /* --- Skip the key if it's deleted or unselected--- */
370 if (KEY_EXPIRED(t, k->del) || !key_match(&k->k, kf))
373 /* --- Encode the key and write the easy stuff --- */
377 key_write(&k->k, &d, kf);
382 /* --- Write out the expiry and deletion times --- */
384 if (KEY_EXPIRED(t, k->exp))
385 fputs("expired ", fp);
386 else if (k->exp == KEXP_FOREVER)
387 fputs("forever ", fp);
389 fprintf(fp, "%li ", (long)k->exp);
391 if (k->del == KEXP_FOREVER)
392 fputs("forever ", fp);
394 fprintf(fp, "%li ", (long)k->del);
396 /* --- Output the attributes --- */
405 for (sym_mkiter(&i, &k->a); (a = sym_next(&i)) != 0; ) {
407 url_enc(&uc, &d, SYM_NAME(a), a->p);
420 return (ferror(fp) ? EOF : 0);
423 /*----- Opening and closing files -----------------------------------------*/
425 /* --- @key_open@ --- *
427 * Arguments: @key_file *f@ = pointer to file structure to initialize
428 * @const char *file@ = pointer to the file name
429 * @unsigned how@ = opening options (@KOPEN_*@).
430 * @key_reporter *rep@ = error reporting function
431 * @void *arg@ = argument for function
433 * Returns: Zero if it worked, nonzero otherwise.
435 * Use: Opens a key file, reads its contents, and stores them in a
436 * structure. The file is locked appropriately until closed
437 * using @key_close@. On an error, everything is cleared away
438 * tidily. If the file is opened with @KOPEN_WRITE@, it's
439 * created if necessary, with read and write permissions for its
443 int key_open(key_file *f, const char *file, unsigned how,
444 key_reporter *rep, void *arg)
446 if (key_lockfile(f, file, how)) {
447 rep(file, 0, strerror(errno), arg);
451 f->name = xstrdup(file);
453 hash_create(&f->byid, KEY_INITSZ);
454 f->idload = SYM_LIMIT(KEY_INITSZ);
455 sym_create(&f->bytype);
456 sym_create(&f->bytag);
459 key_merge(f, file, f->fp, rep, arg);
460 f->f &= ~KF_MODIFIED;
462 if ((how & KOPEN_MASK) == KOPEN_READ) {
471 /* --- @key_close@ --- *
473 * Arguments: @key_file *f@ = pointer to key file block
475 * Returns: A @KWRITE_@ code indicating how it went.
477 * Use: Frees all the key data, writes any changes. Make sure that
478 * all hell breaks loose if this returns @KWRITE_BROKEN@.
481 int key_close(key_file *f)
487 if (f->fp && (e = key_save(f)) != KWRITE_OK)
490 /* --- Free all the individual keys --- */
492 for (hash_mkiter(&i, &f->byid); (b = hash_next(&i)) != 0; ) {
502 for (sym_mkiter(&j, &k->a); (a = sym_next(&j)) != 0; )
507 hash_destroy(&f->byid);
508 sym_destroy(&f->bytype);
509 sym_destroy(&f->bytag);
519 * Arguments: @key_file *f@ = pointer to key file
520 * @uint32 id@ = keyid to set
521 * @const char *type@ = the type of this key
522 * @time_t exp@ = when the key expires
523 * @int *err@ = where to store the error condition
525 * Returns: Key block containing new data, or null if it couldn't be
528 * Use: Attaches a new key to a key file. You must have a writable
529 * key file for this to work.
531 * The type is a key type string. This interface doesn't care
532 * about how type strings are formatted: it just treats them as
533 * opaque gobs of text. Clients are advised to choose some
534 * standard for representing key types, though.
536 * The expiry time should either be a time in the future, or the
537 * magic value @KEXP_FOREVER@ which means `never expire this
538 * key'. Be careful with `forever' keys. If I were you, I'd
539 * use a more sophisticated key management system than this for
542 * You have to set the actual key yourself.
545 key *key_new(key_file *f, uint32 id, const char *type, time_t exp, int *err)
551 /* --- Make sure the file is writable --- */
553 if (!(f->f & KF_WRITE))
555 else if (KEY_EXPIRED(t, exp))
557 else if (key_chkident(type))
563 k->type = xstrdup(type);
564 k->exp = k->del = exp;
568 if ((e = insert(f, k)) == 0)
579 /*----- That's all, folks -------------------------------------------------*/