3 * $Id: key-io.c,v 1.3 2001/01/20 11:56:48 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.3 2001/01/20 11:56:48 mdw
34 * Use mLib exported tuning parameters for hashtable.
36 * Revision 1.2 2000/02/12 18:21:02 mdw
37 * Overhaul of key management (again).
39 * Revision 1.1 1999/12/22 15:47:48 mdw
40 * Major key-management revision.
44 /*----- Header files ------------------------------------------------------*/
53 #include <mLib/bits.h>
54 #include <mLib/crc32.h>
55 #include <mLib/dstr.h>
56 #include <mLib/hash.h>
64 /*----- Tweakable macros --------------------------------------------------*/
68 /*----- Low-level functions -----------------------------------------------*/
72 * Arguments: @key_file *f@ = pointer to file structure
73 * @key *k@ = pointer to key block to insert
75 * Returns: Error code (one of the @KERR@ code).
77 * Use: Links a new key block into the complicated data structure
78 * which is a keyring file.
81 static int insert(key_file
*f
, key
*k
)
86 /* --- Sanity preservatives --- */
88 if (key_chkident(k
->type
))
89 return (KERR_BADTYPE
);
90 else if (k
->tag
&& key_chkident(k
->tag
))
93 /* --- Insert into the tag table --- */
96 kr
= sym_find(&f
->bytag
, k
->tag
, -1, sizeof(*kr
), &found
);
102 /* --- Insert into the id table --- */
107 bin
= HASH_BIN(&f
->byid
, k
->id
);
108 for (b
= *bin
; b
; b
= b
->next
) {
109 if (b
->hash
== k
->id
) {
111 sym_remove(&f
->bytag
, kr
);
121 /* --- Extend the table --- */
125 else if (hash_extend(&f
->byid
))
126 f
->idload
= SYM_LIMIT(f
->byid
.mask
/ 2);
128 /* --- Insert into the type table --- */
130 kr
= sym_find(&f
->bytype
, k
->type
, -1, sizeof(*kr
), &found
);
136 if (k
->exp
!= KEXP_FOREVER
) {
137 while (*p
&& (*p
)->exp
!= KEXP_EXPIRE
&& (*p
)->exp
> k
->exp
)
147 /*----- Reading and writing keys ------------------------------------------*/
149 /* --- @exptime@ --- *
151 * Arguments: @const char *p@ = pointer to string
153 * Returns: Time value.
155 * Use: Translates an expiry or deletion time.
158 time_t exptime(const char *p
)
160 size_t sz
= strlen(p
);
161 if (strncmp(p
, "expired", sz
) == 0)
162 return (KEXP_EXPIRE
);
163 else if (strncmp(p
, "forever", sz
) == 0)
164 return (KEXP_FOREVER
);
169 /* --- @key_merge@ --- *
171 * Arguments: @key_file *f@ = pointer to file structure
172 * @const char *file@ = name of file (for error messages)
173 * @FILE *fp@ = file handle to read from
174 * @key_reporter *rep@ = error reporting function
175 * @void *arg@ = argument for function
177 * Returns: Error code (one of the @KERR@ constants).
179 * Use: Reads keys from a file, and inserts them into the file.
182 int key_merge(key_file
*f
, const char *file
, FILE *fp
,
183 key_reporter
*rep
, void *arg
)
187 dstr n
= DSTR_INIT
, v
= DSTR_INIT
;
189 if (!(f
->f
& KF_WRITE
))
190 return (KERR_READONLY
);
192 for (; dstr_putline(&l
, fp
) != EOF
; DRESET(&l
)) {
197 /* --- Skip blank lines and comments --- *
199 * Quite what they're doing in what ought to be an automatically-
200 * maintained file I don't know.
204 while (isspace((unsigned char)*p
))
206 if (!*p
|| *p
== '#')
209 /* --- Break the line into fields --- *
211 * There are currently six fields of interest:
213 * * The key's identification (id, tag and type).
214 * * The actual key data itself.
215 * * The key expiry time.
216 * * The key deletion time.
217 * * The attributes field.
218 * * Any further comments.
220 * All but the last field can contain no spaces.
224 int n
= str_split(p
, vf
, 5, &vf
[5]);
227 rep(file
, line
, "too few fields", arg
);
232 /* --- Allocate a new key block --- */
236 /* --- Extract the key data into the block --- */
238 if (key_read(vf
[1], &k
->k
, 0)) {
240 rep(file
, line
, "bad key data", arg
);
244 /* --- Decode the identification field --- *
246 * For compatibility, derive a keyid from the key data. This can only be
247 * done if the key encoding is binary (and presumably old-encoding binary
252 char *q
= strchr(vf
[0], ':');
256 if (k
->k
.e
!= KENC_BINARY
) {
258 rep(file
, line
, "new-style key encoding but no keyid", arg
);
261 k
->id
= crc32(0, k
->k
.u
.k
.k
, k
->k
.u
.k
.sz
);
262 k
->type
= xstrdup(vf
[0]);
266 k
->id
= strtoul(p
, 0, 16);
267 if ((qq
= strchr(q
, ':')) == 0 || !qq
[1]) {
273 k
->tag
= xstrdup(qq
);
275 k
->type
= xstrdup(q
);
279 /* --- Get a key block for the new key --- */
281 k
->exp
= exptime(vf
[2]);
282 k
->del
= exptime(vf
[3]);
284 /* --- Insert the key block into the table --- */
290 if ((err
= insert(f
, k
)) < 0) {
291 if (err
== KERR_DUPTAG
) {
293 rep(file
, line
, "duplicate key tag stripped", arg
);
299 rep(file
, line
, key_strerror(err
), arg
);
304 /* --- Parse up the attributes, if specified --- */
307 if (vf
[4] && strcmp(vf
[4], "-") != 0) {
309 for (url_initdec(&uc
, vf
[4]); url_dec(&uc
, &n
, &v
); ) {
310 key_putattr(f
, k
, n
.buf
, v
.buf
);
311 DRESET(&n
); DRESET(&v
);
315 /* --- Insert the comment --- */
318 k
->c
= xstrdup(vf
[5]);
323 /* --- Tidy up after something going wrong --- */
336 /* --- Extensive tidying up now required --- */
345 /* --- @key_extract@ --- *
347 * Arguments: @key_file *f@ = pointer to file structure
348 * @key *k@ = key to extract
349 * @FILE *fp@ = file to write on
350 * @const key_filter *kf@ = pointer to key selection block
352 * Returns: Zero if OK, EOF on error.
354 * Use: Extracts a key to an ouptut file.
357 int key_extract(key_file
*f
, key
*k
, FILE *fp
, const key_filter
*kf
)
362 /* --- Skip the key if it's deleted or unselected--- */
364 if (KEY_EXPIRED(t
, k
->del
) || !key_match(&k
->k
, kf
))
367 /* --- Encode the key and write the easy stuff --- */
371 key_write(&k
->k
, &d
, kf
);
376 /* --- Write out the expiry and deletion times --- */
378 if (KEY_EXPIRED(t
, k
->exp
))
379 fputs("expired ", fp
);
380 else if (k
->exp
== KEXP_FOREVER
)
381 fputs("forever ", fp
);
383 fprintf(fp
, "%li ", (long)k
->exp
);
385 if (k
->del
== KEXP_FOREVER
)
386 fputs("forever ", fp
);
388 fprintf(fp
, "%li ", (long)k
->del
);
390 /* --- Output the attributes --- */
399 for (sym_mkiter(&i
, &k
->a
); (a
= sym_next(&i
)) != 0; ) {
401 url_enc(&uc
, &d
, SYM_NAME(a
), a
->p
);
414 return (ferror(fp
) ? EOF
: 0);
417 /*----- Opening and closing files -----------------------------------------*/
419 /* --- @key_open@ --- *
421 * Arguments: @key_file *f@ = pointer to file structure to initialize
422 * @const char *file@ = pointer to the file name
423 * @int how@ = opening options (@KOPEN_*@).
424 * @key_reporter *rep@ = error reporting function
425 * @void *arg@ = argument for function
427 * Returns: Zero if it worked, nonzero otherwise.
429 * Use: Opens a key file, reads its contents, and stores them in a
430 * structure. The file is locked appropriately until closed
431 * using @key_close@. On an error, everything is cleared away
432 * tidily. If the file is opened with @KOPEN_WRITE@, it's
433 * created if necessary, with read and write permissions for its
437 int key_open(key_file
*f
, const char *file
, int how
,
438 key_reporter
*rep
, void *arg
)
440 if (key_lockfile(f
, file
, how
))
443 /* --- Trivial bits of initialization --- */
446 f
->name
= xstrdup(file
);
448 /* --- Read the file of keys into the table --- */
450 hash_create(&f
->byid
, KEY_INITSZ
);
451 f
->idload
= SYM_LIMIT(KEY_INITSZ
);
452 sym_create(&f
->bytype
);
453 sym_create(&f
->bytag
);
455 key_merge(f
, file
, f
->fp
, rep
, arg
);
456 if (how
== KOPEN_READ
)
457 f
->f
&= ~(KF_WRITE
| KF_MODIFIED
);
459 f
->f
&= ~KF_MODIFIED
;
461 /* --- Close the file if only needed for reading --- */
463 if (how
== 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 ((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 -------------------------------------------------*/