3 * Adding new keys to a key file
5 * (c) 1999 Straylight/Edgeware
8 /*----- Licensing notice --------------------------------------------------*
10 * This file is part of Catacomb.
12 * Catacomb is free software; you can redistribute it and/or modify
13 * it under the terms of the GNU Library General Public License as
14 * published by the Free Software Foundation; either version 2 of the
15 * License, or (at your option) any later version.
17 * Catacomb is distributed in the hope that it will be useful,
18 * but WITHOUT ANY WARRANTY; without even the implied warranty of
19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20 * GNU Library General Public License for more details.
22 * You should have received a copy of the GNU Library General Public
23 * License along with Catacomb; if not, write to the Free
24 * Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
28 /*----- Header files ------------------------------------------------------*/
37 #include <mLib/bits.h>
38 #include <mLib/crc32.h>
39 #include <mLib/dstr.h>
40 #include <mLib/hash.h>
48 /*----- Tweakable macros --------------------------------------------------*/
52 /*----- Low-level functions -----------------------------------------------*/
56 * Arguments: @key_file *f@ = pointer to file structure
57 * @key *k@ = pointer to key block to insert
59 * Returns: Error code (one of the @KERR@ code).
61 * Use: Links a new key block into the complicated data structure
62 * which is a keyring file.
65 static int insert(key_file
*f
, key
*k
)
70 /* --- Sanity preservatives --- */
72 if (key_chkident(k
->type
))
73 return (KERR_BADTYPE
);
74 else if (k
->tag
&& key_chkident(k
->tag
))
77 /* --- Insert into the tag table --- */
80 kr
= sym_find(&f
->bytag
, k
->tag
, -1, sizeof(*kr
), &found
);
86 /* --- Insert into the id table --- */
91 bin
= HASH_BIN(&f
->byid
, k
->id
);
92 for (b
= *bin
; b
; b
= b
->next
) {
93 if (b
->hash
== k
->id
) {
95 sym_remove(&f
->bytag
, kr
);
105 /* --- Extend the table --- */
109 else if (hash_extend(&f
->byid
))
110 f
->idload
= SYM_LIMIT(f
->byid
.mask
/ 2);
112 /* --- Insert into the type table --- */
114 kr
= sym_find(&f
->bytype
, k
->type
, -1, sizeof(*kr
), &found
);
120 if (k
->exp
!= KEXP_FOREVER
) {
121 while (*p
&& (*p
)->exp
!= KEXP_EXPIRE
&& (*p
)->exp
> k
->exp
)
131 /*----- Reading and writing keys ------------------------------------------*/
133 /* --- @exptime@ --- *
135 * Arguments: @const char *p@ = pointer to string
137 * Returns: Time value.
139 * Use: Translates an expiry or deletion time.
142 static time_t exptime(const char *p
)
144 size_t sz
= strlen(p
);
145 if (strncmp(p
, "expired", sz
) == 0)
146 return (KEXP_EXPIRE
);
147 else if (strncmp(p
, "forever", sz
) == 0)
148 return (KEXP_FOREVER
);
153 /* --- @merge_core@ --- *
155 * Arguments: @key_file *f@ = pointer to file structure
156 * @const char *file@ = name of file (for error messages)
157 * @int lno@ = line number
158 * @char *p@ = pointer into the line buffer (which will be
160 * @key_reporter *rep@ = error reporting function
161 * @void *arg@ = argument for function
162 * @dstr *n, *v@ = scratch dynamic strings, which must be empty
163 * on entry and are left empty on exit
167 * Use: This is the common core of @key_merge@ and @key_mergeline@.
169 * It is assumed that the caller has already verified that the
170 * keyring is writable.
173 static void merge_core(key_file
*f
, const char *file
, int lno
, char *p
,
174 key_reporter
*rep
, void *arg
, dstr
*n
, dstr
*v
)
179 /* --- Skip blank lines and comments --- *
181 * Quite what they're doing in what ought to be an automatically-
182 * maintained file I don't know.
185 while (isspace((unsigned char)*p
))
187 if (!*p
|| *p
== '#')
190 /* --- Break the line into fields --- *
192 * There are currently six fields of interest:
194 * * The key's identification (id, tag and type).
195 * * The actual key data itself.
196 * * The key expiry time.
197 * * The key deletion time.
198 * * The attributes field.
199 * * Any further comments.
201 * All but the last field can contain no spaces.
205 int n
= str_split(p
, vf
, 5, &vf
[5]);
208 rep(file
, lno
, "too few fields", arg
);
213 /* --- Allocate a new key block --- */
220 /* --- Extract the key data into the block --- */
222 if ((k
->k
= key_read(vf
[1], 0)) == 0) {
224 rep(file
, lno
, "bad key data", arg
);
228 /* --- Decode the identification field --- *
230 * For compatibility, derive a keyid from the key data. This can only be
231 * done if the key encoding is binary (and presumably old-encoding binary
236 char *q
= strchr(vf
[0], ':');
240 if (k
->k
->e
!= KENC_BINARY
) {
242 rep(file
, lno
, "new-style key encoding but no keyid", arg
);
245 k
->id
= crc32(0, k
->k
->u
.k
.k
, k
->k
->u
.k
.sz
);
246 k
->type
= xstrdup(vf
[0]);
250 k
->id
= strtoul(p
, 0, 16);
251 if ((qq
= strchr(q
, ':')) == 0 || !qq
[1]) {
257 k
->tag
= xstrdup(qq
);
259 k
->type
= xstrdup(q
);
263 /* --- Get a key block for the new key --- */
265 k
->exp
= exptime(vf
[2]);
266 k
->del
= exptime(vf
[3]);
268 /* --- Insert the key block into the table --- */
274 if ((err
= insert(f
, k
)) < 0) {
275 if (err
== KERR_DUPTAG
) {
277 rep(file
, lno
, "duplicate key tag stripped", arg
);
283 rep(file
, lno
, key_strerror(err
), arg
);
288 /* --- Parse up the attributes, if specified --- */
291 if (vf
[4] && strcmp(vf
[4], "-") != 0) {
293 for (url_initdec(&uc
, vf
[4]); url_dec(&uc
, n
, v
); ) {
294 key_putattr(f
, k
, n
->buf
, v
->buf
);
295 DRESET(n
); DRESET(v
);
299 /* --- Insert the comment --- */
302 k
->c
= xstrdup(vf
[5]);
311 /* --- Tidy up after something going wrong --- */
315 if (k
->tag
) xfree(k
->tag
);
316 if (k
->type
) xfree(k
->type
);
317 if (k
->k
) key_drop(k
->k
);
322 /* --- @key_merge@, @key_mergeline@ --- *
324 * Arguments: @key_file *f@ = pointer to file structure
325 * @const char *file@ = name of file (for error messages)
326 * @int lno@ = line number (for error messages, @key_mergeline@)
327 * @FILE *fp@ = file handle to read from (@key_merge@)
328 * @const char *line@ = line from the input (@key_mergeline@)
329 * @key_reporter *rep@ = error reporting function
330 * @void *arg@ = argument for function
332 * Returns: Error code (one of the @KERR@ constants).
334 * Use: The @key_merge@ function reads keys from a file, and inserts
335 * them into the keyring.
337 * The @key_mergeline@ function reads a key from a single input
338 * line (which may, but need not, have a final newline), and
339 * adds it to the keyring.
341 * The @key_mergeline@ function is intended to help with
342 * interfacing Catacomb to runtimes which don't use C's @stdio@
343 * streams, rather than as a general-purpose service, though if
344 * it turns out to be useful in other ways then so much the
348 int key_merge(key_file
*f
, const char *file
, FILE *fp
,
349 key_reporter
*rep
, void *arg
)
351 dstr n
= DSTR_INIT
, v
= DSTR_INIT
;
355 if (!(f
->f
& KF_WRITE
))
356 return (KERR_READONLY
);
358 for (; dstr_putline(&l
, fp
) != EOF
; DRESET(&l
))
359 merge_core(f
, file
, lno
++, l
.buf
, rep
, arg
, &n
, &v
);
362 dstr_destroy(&n
); dstr_destroy(&v
);
366 int key_mergeline(key_file
*f
, const char *file
, int lno
, const char *line
,
367 key_reporter
*rep
, void *arg
)
369 dstr n
= DSTR_INIT
, v
= DSTR_INIT
;
370 size_t len
= strlen(line
);
373 if (!(f
->f
& KF_WRITE
)) return (KERR_READONLY
);
375 if (len
&& line
[len
- 1] == '\n') len
--;
376 p
= xmalloc(len
); memcpy(p
, line
, len
); p
[len
] = 0;
377 merge_core(f
, file
, lno
, p
, rep
, arg
, &n
, &v
);
378 xfree(p
); dstr_destroy(&n
); dstr_destroy(&v
);
382 /* --- @key_extract@, @key_extractline@ --- *
384 * Arguments: @key_file *f@ = pointer to file structure
385 * @key *k@ = key to extract
386 * @FILE *fp@ = file to write on (@key_extract@)
387 * @dstr *d@ = string to write on (@key_extractline@)
388 * @const key_filter *kf@ = pointer to key selection block
390 * Returns: @key_extract@ returns zero if OK, EOF on error.
391 * @key_extractline@ does not return a value.
393 * Use: Extracts a key to an ouptut file or buffer.
395 * The @key_extractline@ includes a final newline in its output.
397 * The @key_extractline@ function is intended to help with
398 * interfacing Catacomb to runtimes which don't use C's @stdio@
399 * streams, rather than as a general-purpose service, though if
400 * it turns out to be useful in other ways then so much the
404 void key_extractline(key_file
*f
, key
*k
, dstr
*d
, const key_filter
*kf
)
408 /* --- Skip the key if it's deleted or unselected--- */
410 if (KEY_EXPIRED(t
, k
->del
) || !key_match(k
->k
, kf
))
413 /* --- Encode the key and write the easy stuff --- */
417 if (!key_write(k
->k
, d
, kf
)) dstr_puts(d
, "struct:[]");
420 /* --- Write out the expiry and deletion times --- */
422 if (KEY_EXPIRED(t
, k
->exp
))
423 dstr_puts(d
, "expired ");
424 else if (k
->exp
== KEXP_FOREVER
)
425 dstr_puts(d
, "forever ");
427 dstr_putf(d
, "%li ", (long)k
->exp
);
429 if (k
->del
== KEXP_FOREVER
)
430 dstr_puts(d
, "forever ");
432 dstr_putf(d
, "%li ", (long)k
->del
);
434 /* --- Output the attributes --- */
443 for (sym_mkiter(&i
, &k
->a
); (a
= sym_next(&i
)) != 0; ) {
445 url_enc(&uc
, d
, SYM_NAME(a
), a
->p
);
452 dstr_putf(d
, " %s", k
->c
);
454 DPUTC(d
, '\n'); DPUTZ(d
);
457 int key_extract(key_file
*f
, key
*k
, FILE *fp
, const key_filter
*kf
)
461 key_extractline(f
, k
, &d
, kf
);
463 return (ferror(fp
) ? EOF
: 0);
466 /*----- Opening and closing files -----------------------------------------*/
468 /* --- @key_open@ --- *
470 * Arguments: @key_file *f@ = pointer to file structure to initialize
471 * @const char *file@ = pointer to the file name
472 * @unsigned how@ = opening options (@KOPEN_*@).
473 * @key_reporter *rep@ = error reporting function
474 * @void *arg@ = argument for function
476 * Returns: Zero if it worked, nonzero otherwise.
478 * Use: Opens a key file, reads its contents, and stores them in a
479 * structure. The file is locked appropriately until closed
480 * using @key_close@. On an error, everything is cleared away
481 * tidily. If the file is opened with @KOPEN_WRITE@, it's
482 * created if necessary, with read and write permissions for its
486 int key_open(key_file
*f
, const char *file
, unsigned how
,
487 key_reporter
*rep
, void *arg
)
489 if (key_lockfile(f
, file
, how
)) {
490 rep(file
, 0, strerror(errno
), arg
);
494 f
->name
= xstrdup(file
);
496 hash_create(&f
->byid
, KEY_INITSZ
);
497 f
->idload
= SYM_LIMIT(KEY_INITSZ
);
498 sym_create(&f
->bytype
);
499 sym_create(&f
->bytag
);
502 key_merge(f
, file
, f
->fp
, rep
, arg
);
503 f
->f
&= ~KF_MODIFIED
;
505 if ((how
& KOPEN_MASK
) == KOPEN_READ
) {
507 if (f
->fp
) fclose(f
->fp
);
514 /* --- @key_discard@ --- *
516 * Arguments: @key_file *f@ = pointer to key file block
520 * Use: Frees all the key data, without writing changes.
523 void key_discard(key_file
*f
)
528 /* --- Free all the individual keys --- */
530 for (hash_mkiter(&i
, &f
->byid
); (b
= hash_next(&i
)) != 0; ) {
535 if (k
->k
) key_drop(k
->k
);
540 for (sym_mkiter(&j
, &k
->a
); (a
= sym_next(&j
)) != 0; )
545 hash_destroy(&f
->byid
);
546 sym_destroy(&f
->bytype
);
547 sym_destroy(&f
->bytag
);
554 /* --- @key_close@ --- *
556 * Arguments: @key_file *f@ = pointer to key file block
558 * Returns: A @KWRITE_@ code indicating how it went.
560 * Use: Frees all the key data, writes any changes. Make sure that
561 * all hell breaks loose if this returns @KWRITE_BROKEN@.
564 int key_close(key_file
*f
)
568 if (f
->fp
&& (e
= key_save(f
)) != KWRITE_OK
)
576 * Arguments: @key_file *f@ = pointer to key file
577 * @uint32 id@ = keyid to set
578 * @const char *type@ = the type of this key
579 * @time_t exp@ = when the key expires
580 * @key *kk@ = where to put the key pointer
582 * Returns: Error code (one of the @KERR@ constants).
584 * Use: Attaches a new key to a key file. You must have a writable
585 * key file for this to work.
587 * The type is a key type string. This interface doesn't care
588 * about how type strings are formatted: it just treats them as
589 * opaque gobs of text. Clients are advised to choose some
590 * standard for representing key types, though.
592 * The expiry time should either be a time in the future, or the
593 * magic value @KEXP_FOREVER@ which means `never expire this
594 * key'. Be careful with `forever' keys. If I were you, I'd
595 * use a more sophisticated key management system than this for
599 int key_new(key_file
*f
, uint32 id
, const char *type
, time_t exp
, key
**kk
)
605 /* --- Make sure the file is writable --- */
607 if (!(f
->f
& KF_WRITE
))
609 else if (KEY_EXPIRED(t
, exp
))
611 else if (key_chkident(type
))
617 k
->exp
= k
->del
= exp
;
619 k
->type
= (char *)type
; /* temporarily */
620 if ((e
= insert(f
, k
)) != 0)
623 k
->k
= key_newstring(KCAT_SHARE
, "<unset>");
624 k
->type
= xstrdup(type
);
634 /*----- That's all, folks -------------------------------------------------*/