1b528cefcSMark Murray /*
2c19800e8SDoug Rabson * Copyright (c) 1997-2005 Kungliga Tekniska Högskolan
3b528cefcSMark Murray * (Royal Institute of Technology, Stockholm, Sweden).
4b528cefcSMark Murray * All rights reserved.
5b528cefcSMark Murray *
6b528cefcSMark Murray * Redistribution and use in source and binary forms, with or without
7b528cefcSMark Murray * modification, are permitted provided that the following conditions
8b528cefcSMark Murray * are met:
9b528cefcSMark Murray *
10b528cefcSMark Murray * 1. Redistributions of source code must retain the above copyright
11b528cefcSMark Murray * notice, this list of conditions and the following disclaimer.
12b528cefcSMark Murray *
13b528cefcSMark Murray * 2. Redistributions in binary form must reproduce the above copyright
14b528cefcSMark Murray * notice, this list of conditions and the following disclaimer in the
15b528cefcSMark Murray * documentation and/or other materials provided with the distribution.
16b528cefcSMark Murray *
17b528cefcSMark Murray * 3. Neither the name of the Institute nor the names of its contributors
18b528cefcSMark Murray * may be used to endorse or promote products derived from this software
19b528cefcSMark Murray * without specific prior written permission.
20b528cefcSMark Murray *
21b528cefcSMark Murray * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
22b528cefcSMark Murray * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
23b528cefcSMark Murray * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
24b528cefcSMark Murray * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
25b528cefcSMark Murray * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
26b528cefcSMark Murray * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
27b528cefcSMark Murray * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
28b528cefcSMark Murray * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
29b528cefcSMark Murray * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
30b528cefcSMark Murray * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
31b528cefcSMark Murray * SUCH DAMAGE.
32b528cefcSMark Murray */
33b528cefcSMark Murray
34b528cefcSMark Murray #include "kadmin_locl.h"
35c19800e8SDoug Rabson #include "kadmin-commands.h"
36b528cefcSMark Murray #include <kadm5/private.h>
37b528cefcSMark Murray
38c19800e8SDoug Rabson struct entry {
39b528cefcSMark Murray char *principal;
40b528cefcSMark Murray char *key;
41b528cefcSMark Murray char *max_life;
42b528cefcSMark Murray char *max_renew;
43b528cefcSMark Murray char *created;
44b528cefcSMark Murray char *modified;
45b528cefcSMark Murray char *valid_start;
46b528cefcSMark Murray char *valid_end;
47b528cefcSMark Murray char *pw_end;
48b528cefcSMark Murray char *flags;
49b528cefcSMark Murray char *generation;
50b528cefcSMark Murray char *extensions;
514137ff4cSJacques Vidrine };
52c19800e8SDoug Rabson
53b528cefcSMark Murray static char *
skip_next(char * p)54b528cefcSMark Murray skip_next(char *p)
55b528cefcSMark Murray {
56b528cefcSMark Murray while(*p && !isspace((unsigned char)*p))
57b528cefcSMark Murray p++;
58b528cefcSMark Murray *p++ = 0;
59b528cefcSMark Murray while(*p && isspace((unsigned char)*p))
60b528cefcSMark Murray p++;
6113e3f4d6SMark Murray return p;
6213e3f4d6SMark Murray }
63b528cefcSMark Murray
64b528cefcSMark Murray /*
65b528cefcSMark Murray * Parse the time in `s', returning:
6613e3f4d6SMark Murray * -1 if error parsing
6713e3f4d6SMark Murray * 0 if none present
6813e3f4d6SMark Murray * 1 if parsed ok
6913e3f4d6SMark Murray */
7013e3f4d6SMark Murray
7113e3f4d6SMark Murray static int
parse_time_string(time_t * t,const char * s)7213e3f4d6SMark Murray parse_time_string(time_t *t, const char *s)
7313e3f4d6SMark Murray {
7413e3f4d6SMark Murray int year, month, date, hour, minute, second;
75b528cefcSMark Murray struct tm tm;
76b528cefcSMark Murray
77b528cefcSMark Murray if(strcmp(s, "-") == 0)
7813e3f4d6SMark Murray return 0;
79b528cefcSMark Murray if(sscanf(s, "%04d%02d%02d%02d%02d%02d",
8013e3f4d6SMark Murray &year, &month, &date, &hour, &minute, &second) != 6)
8113e3f4d6SMark Murray return -1;
8213e3f4d6SMark Murray tm.tm_year = year - 1900;
8313e3f4d6SMark Murray tm.tm_mon = month - 1;
84b528cefcSMark Murray tm.tm_mday = date;
85b528cefcSMark Murray tm.tm_hour = hour;
86b528cefcSMark Murray tm.tm_min = minute;
87b528cefcSMark Murray tm.tm_sec = second;
88b528cefcSMark Murray tm.tm_isdst = 0;
89b528cefcSMark Murray *t = timegm(&tm);
90b528cefcSMark Murray return 1;
91b528cefcSMark Murray }
9213e3f4d6SMark Murray
93b528cefcSMark Murray /*
94b528cefcSMark Murray * parse time, allocating space in *t if it's there
9513e3f4d6SMark Murray */
9613e3f4d6SMark Murray
9713e3f4d6SMark Murray static int
parse_time_string_alloc(time_t ** t,const char * s)9813e3f4d6SMark Murray parse_time_string_alloc (time_t **t, const char *s)
9913e3f4d6SMark Murray {
10013e3f4d6SMark Murray time_t tmp;
10113e3f4d6SMark Murray int ret;
10213e3f4d6SMark Murray
10313e3f4d6SMark Murray *t = NULL;
10413e3f4d6SMark Murray ret = parse_time_string (&tmp, s);
10513e3f4d6SMark Murray if (ret == 1) {
10613e3f4d6SMark Murray *t = malloc (sizeof (**t));
10713e3f4d6SMark Murray if (*t == NULL)
10813e3f4d6SMark Murray krb5_errx (context, 1, "malloc: out of memory");
10913e3f4d6SMark Murray **t = tmp;
11013e3f4d6SMark Murray }
11113e3f4d6SMark Murray return ret;
11213e3f4d6SMark Murray }
11313e3f4d6SMark Murray
11413e3f4d6SMark Murray /*
11513e3f4d6SMark Murray * see parse_time_string for calling convention
11613e3f4d6SMark Murray */
11713e3f4d6SMark Murray
11813e3f4d6SMark Murray static int
parse_integer(unsigned int * u,const char * s)11913e3f4d6SMark Murray parse_integer(unsigned int *u, const char *s)
12013e3f4d6SMark Murray {
121c19800e8SDoug Rabson if(strcmp(s, "-") == 0)
122b528cefcSMark Murray return 0;
123b528cefcSMark Murray if (sscanf(s, "%u", u) != 1)
12413e3f4d6SMark Murray return -1;
12513e3f4d6SMark Murray return 1;
12613e3f4d6SMark Murray }
12713e3f4d6SMark Murray
128b528cefcSMark Murray static int
parse_integer_alloc(unsigned int ** u,const char * s)129b528cefcSMark Murray parse_integer_alloc (unsigned int **u, const char *s)
13013e3f4d6SMark Murray {
131c19800e8SDoug Rabson unsigned int tmp;
13213e3f4d6SMark Murray int ret;
133c19800e8SDoug Rabson
13413e3f4d6SMark Murray *u = NULL;
13513e3f4d6SMark Murray ret = parse_integer (&tmp, s);
13613e3f4d6SMark Murray if (ret == 1) {
13713e3f4d6SMark Murray *u = malloc (sizeof (**u));
13813e3f4d6SMark Murray if (*u == NULL)
13913e3f4d6SMark Murray krb5_errx (context, 1, "malloc: out of memory");
14013e3f4d6SMark Murray **u = tmp;
14113e3f4d6SMark Murray }
14213e3f4d6SMark Murray return ret;
14313e3f4d6SMark Murray }
14413e3f4d6SMark Murray
14513e3f4d6SMark Murray /*
14613e3f4d6SMark Murray * Parse dumped keys in `str' and store them in `ent'
14713e3f4d6SMark Murray * return -1 if parsing failed
14813e3f4d6SMark Murray */
14913e3f4d6SMark Murray
15013e3f4d6SMark Murray static int
parse_keys(hdb_entry * ent,char * str)15113e3f4d6SMark Murray parse_keys(hdb_entry *ent, char *str)
15213e3f4d6SMark Murray {
153b528cefcSMark Murray krb5_error_code ret;
154b528cefcSMark Murray int tmp;
15513e3f4d6SMark Murray char *p;
156b528cefcSMark Murray size_t i;
157b528cefcSMark Murray
158b528cefcSMark Murray p = strsep(&str, ":");
159b528cefcSMark Murray if (sscanf(p, "%d", &tmp) != 1)
160b528cefcSMark Murray return 1;
16113e3f4d6SMark Murray ent->kvno = tmp;
16213e3f4d6SMark Murray p = strsep(&str, ":");
163b528cefcSMark Murray while(p){
164b528cefcSMark Murray Key *key;
165b528cefcSMark Murray key = realloc(ent->keys.val,
166b528cefcSMark Murray (ent->keys.len + 1) * sizeof(*ent->keys.val));
167b528cefcSMark Murray if(key == NULL)
168b528cefcSMark Murray krb5_errx (context, 1, "realloc: out of memory");
169b528cefcSMark Murray ent->keys.val = key;
17013e3f4d6SMark Murray key = ent->keys.val + ent->keys.len;
171b528cefcSMark Murray ent->keys.len++;
172b528cefcSMark Murray memset(key, 0, sizeof(*key));
173b528cefcSMark Murray if(sscanf(p, "%d", &tmp) == 1) {
174b528cefcSMark Murray key->mkvno = malloc(sizeof(*key->mkvno));
175b528cefcSMark Murray *key->mkvno = tmp;
176b528cefcSMark Murray } else
177b528cefcSMark Murray key->mkvno = NULL;
178b528cefcSMark Murray p = strsep(&str, ":");
179b528cefcSMark Murray if (sscanf(p, "%d", &tmp) != 1)
180b528cefcSMark Murray return 1;
18113e3f4d6SMark Murray key->key.keytype = tmp;
18213e3f4d6SMark Murray p = strsep(&str, ":");
183b528cefcSMark Murray ret = krb5_data_alloc(&key->key.keyvalue, (strlen(p) - 1) / 2 + 1);
184b528cefcSMark Murray if (ret)
18513e3f4d6SMark Murray krb5_err (context, 1, ret, "krb5_data_alloc");
18613e3f4d6SMark Murray for(i = 0; i < strlen(p); i += 2) {
18713e3f4d6SMark Murray if(sscanf(p + i, "%02x", &tmp) != 1)
188b528cefcSMark Murray return 1;
18913e3f4d6SMark Murray ((u_char*)key->key.keyvalue.data)[i / 2] = tmp;
19013e3f4d6SMark Murray }
191b528cefcSMark Murray p = strsep(&str, ":");
192b528cefcSMark Murray if(strcmp(p, "-") != 0){
193b528cefcSMark Murray unsigned type;
194b528cefcSMark Murray size_t p_len;
195b528cefcSMark Murray
196b528cefcSMark Murray if(sscanf(p, "%u/", &type) != 1)
19713e3f4d6SMark Murray return 1;
19813e3f4d6SMark Murray p = strchr(p, '/');
19913e3f4d6SMark Murray if(p == NULL)
200b528cefcSMark Murray return 1;
201b528cefcSMark Murray p++;
20213e3f4d6SMark Murray p_len = strlen(p);
203b528cefcSMark Murray
204b528cefcSMark Murray key->salt = calloc(1, sizeof(*key->salt));
205b528cefcSMark Murray if (key->salt == NULL)
206b528cefcSMark Murray krb5_errx (context, 1, "malloc: out of memory");
20713e3f4d6SMark Murray key->salt->type = type;
20813e3f4d6SMark Murray
209b528cefcSMark Murray if (p_len) {
210b528cefcSMark Murray if(*p == '\"') {
211b528cefcSMark Murray ret = krb5_data_copy(&key->salt->salt, p + 1, p_len - 2);
212b528cefcSMark Murray if (ret)
21313e3f4d6SMark Murray krb5_err (context, 1, ret, "krb5_data_copy");
21413e3f4d6SMark Murray } else {
21513e3f4d6SMark Murray ret = krb5_data_alloc(&key->salt->salt,
216b528cefcSMark Murray (p_len - 1) / 2 + 1);
21713e3f4d6SMark Murray if (ret)
21813e3f4d6SMark Murray krb5_err (context, 1, ret, "krb5_data_alloc");
21913e3f4d6SMark Murray for(i = 0; i < p_len; i += 2){
22013e3f4d6SMark Murray if (sscanf(p + i, "%02x", &tmp) != 1)
221b528cefcSMark Murray return 1;
22213e3f4d6SMark Murray ((u_char*)key->salt->salt.data)[i / 2] = tmp;
22313e3f4d6SMark Murray }
224b528cefcSMark Murray }
225b528cefcSMark Murray } else
226b528cefcSMark Murray krb5_data_zero (&key->salt->salt);
227b528cefcSMark Murray }
228b528cefcSMark Murray p = strsep(&str, ":");
229b528cefcSMark Murray }
230b528cefcSMark Murray return 0;
231b528cefcSMark Murray }
23213e3f4d6SMark Murray
233b528cefcSMark Murray /*
234b528cefcSMark Murray * see parse_time_string for calling convention
23513e3f4d6SMark Murray */
23613e3f4d6SMark Murray
23713e3f4d6SMark Murray static int
parse_event(Event * ev,char * s)23813e3f4d6SMark Murray parse_event(Event *ev, char *s)
23913e3f4d6SMark Murray {
24013e3f4d6SMark Murray krb5_error_code ret;
241b528cefcSMark Murray char *p;
24213e3f4d6SMark Murray
243b528cefcSMark Murray if(strcmp(s, "-") == 0)
24413e3f4d6SMark Murray return 0;
24513e3f4d6SMark Murray memset(ev, 0, sizeof(*ev));
24613e3f4d6SMark Murray p = strsep(&s, ":");
247b528cefcSMark Murray if(parse_time_string(&ev->time, p) != 1)
24813e3f4d6SMark Murray return -1;
24913e3f4d6SMark Murray p = strsep(&s, ":");
25013e3f4d6SMark Murray ret = krb5_parse_name(context, p, &ev->principal);
25113e3f4d6SMark Murray if (ret)
25213e3f4d6SMark Murray return -1;
25313e3f4d6SMark Murray return 1;
25413e3f4d6SMark Murray }
25513e3f4d6SMark Murray
256b528cefcSMark Murray static int
parse_event_alloc(Event ** ev,char * s)257b528cefcSMark Murray parse_event_alloc (Event **ev, char *s)
25813e3f4d6SMark Murray {
25913e3f4d6SMark Murray Event tmp;
260b528cefcSMark Murray int ret;
26113e3f4d6SMark Murray
26213e3f4d6SMark Murray *ev = NULL;
263b528cefcSMark Murray ret = parse_event (&tmp, s);
26413e3f4d6SMark Murray if (ret == 1) {
26513e3f4d6SMark Murray *ev = malloc (sizeof (**ev));
26613e3f4d6SMark Murray if (*ev == NULL)
26713e3f4d6SMark Murray krb5_errx (context, 1, "malloc: out of memory");
26813e3f4d6SMark Murray **ev = tmp;
26913e3f4d6SMark Murray }
27013e3f4d6SMark Murray return ret;
27113e3f4d6SMark Murray }
27213e3f4d6SMark Murray
27313e3f4d6SMark Murray static int
parse_hdbflags2int(HDBFlags * f,const char * s)27413e3f4d6SMark Murray parse_hdbflags2int(HDBFlags *f, const char *s)
27513e3f4d6SMark Murray {
27613e3f4d6SMark Murray int ret;
27713e3f4d6SMark Murray unsigned int tmp;
27813e3f4d6SMark Murray
279c19800e8SDoug Rabson ret = parse_integer (&tmp, s);
28013e3f4d6SMark Murray if (ret == 1)
28113e3f4d6SMark Murray *f = int2HDBFlags (tmp);
28213e3f4d6SMark Murray return ret;
28313e3f4d6SMark Murray }
28413e3f4d6SMark Murray
285b528cefcSMark Murray static int
parse_generation(char * str,GENERATION ** gen)286b528cefcSMark Murray parse_generation(char *str, GENERATION **gen)
2874137ff4cSJacques Vidrine {
2884137ff4cSJacques Vidrine char *p;
289b528cefcSMark Murray int v;
2904137ff4cSJacques Vidrine
2914137ff4cSJacques Vidrine if(strcmp(str, "-") == 0 || *str == '\0') {
292b528cefcSMark Murray *gen = NULL;
2930cadf2f4SJacques Vidrine return 0;
2944137ff4cSJacques Vidrine }
2950cadf2f4SJacques Vidrine *gen = calloc(1, sizeof(**gen));
2960cadf2f4SJacques Vidrine
2974137ff4cSJacques Vidrine p = strsep(&str, ":");
2984137ff4cSJacques Vidrine if(parse_time_string(&(*gen)->time, p) != 1)
2994137ff4cSJacques Vidrine return -1;
3004137ff4cSJacques Vidrine p = strsep(&str, ":");
3014137ff4cSJacques Vidrine if(sscanf(p, "%d", &v) != 1)
3024137ff4cSJacques Vidrine return -1;
3034137ff4cSJacques Vidrine (*gen)->usec = v;
3044137ff4cSJacques Vidrine p = strsep(&str, ":");
3054137ff4cSJacques Vidrine if(sscanf(p, "%d", &v) != 1)
3064137ff4cSJacques Vidrine return -1;
3074137ff4cSJacques Vidrine (*gen)->gen = v - 1; /* XXX gets bumped in _hdb_store */
3084137ff4cSJacques Vidrine return 0;
3094137ff4cSJacques Vidrine }
3104137ff4cSJacques Vidrine
311b528cefcSMark Murray static int
parse_extensions(char * str,HDB_extensions ** e)3124137ff4cSJacques Vidrine parse_extensions(char *str, HDB_extensions **e)
313c19800e8SDoug Rabson {
314c19800e8SDoug Rabson char *p;
315c19800e8SDoug Rabson int ret;
316c19800e8SDoug Rabson
317c19800e8SDoug Rabson if(strcmp(str, "-") == 0 || *str == '\0') {
318c19800e8SDoug Rabson *e = NULL;
319c19800e8SDoug Rabson return 0;
320c19800e8SDoug Rabson }
321c19800e8SDoug Rabson *e = calloc(1, sizeof(**e));
322c19800e8SDoug Rabson
323c19800e8SDoug Rabson p = strsep(&str, ":");
324c19800e8SDoug Rabson
325c19800e8SDoug Rabson while (p) {
326c19800e8SDoug Rabson HDB_extension ext;
327c19800e8SDoug Rabson ssize_t len;
328c19800e8SDoug Rabson void *d;
329c19800e8SDoug Rabson
330c19800e8SDoug Rabson len = strlen(p);
331c19800e8SDoug Rabson d = malloc(len);
332c19800e8SDoug Rabson
333c19800e8SDoug Rabson len = hex_decode(p, d, len);
334c19800e8SDoug Rabson if (len < 0) {
335c19800e8SDoug Rabson free(d);
336c19800e8SDoug Rabson return -1;
337c19800e8SDoug Rabson }
338c19800e8SDoug Rabson
339c19800e8SDoug Rabson ret = decode_HDB_extension(d, len, &ext, NULL);
340c19800e8SDoug Rabson free(d);
341c19800e8SDoug Rabson if (ret)
342c19800e8SDoug Rabson return -1;
343c19800e8SDoug Rabson d = realloc((*e)->val, ((*e)->len + 1) * sizeof((*e)->val[0]));
344c19800e8SDoug Rabson if (d == NULL)
345c19800e8SDoug Rabson abort();
346c19800e8SDoug Rabson (*e)->val = d;
347c19800e8SDoug Rabson (*e)->val[(*e)->len] = ext;
348c19800e8SDoug Rabson (*e)->len++;
349c19800e8SDoug Rabson
350c19800e8SDoug Rabson p = strsep(&str, ":");
351c19800e8SDoug Rabson }
352c19800e8SDoug Rabson
353c19800e8SDoug Rabson return 0;
354c19800e8SDoug Rabson }
355c19800e8SDoug Rabson
356b528cefcSMark Murray
35713e3f4d6SMark Murray /*
35813e3f4d6SMark Murray * Parse the dump file in `filename' and create the database (merging
35913e3f4d6SMark Murray * iff merge)
36013e3f4d6SMark Murray */
36113e3f4d6SMark Murray
36213e3f4d6SMark Murray static int
doit(const char * filename,int mergep)363c19800e8SDoug Rabson doit(const char *filename, int mergep)
364b528cefcSMark Murray {
365b528cefcSMark Murray krb5_error_code ret;
366b528cefcSMark Murray FILE *f;
3674137ff4cSJacques Vidrine char s[8192]; /* XXX should fix this properly */
368b528cefcSMark Murray char *p;
369b528cefcSMark Murray int line;
370b528cefcSMark Murray int flags = O_RDWR;
371b528cefcSMark Murray struct entry e;
372c19800e8SDoug Rabson hdb_entry_ex ent;
373b528cefcSMark Murray HDB *db = _kadm5_s_get_db(kadm_handle);
374b528cefcSMark Murray
375b528cefcSMark Murray f = fopen(filename, "r");
376b528cefcSMark Murray if(f == NULL){
377b528cefcSMark Murray krb5_warn(context, errno, "fopen(%s)", filename);
37813e3f4d6SMark Murray return 1;
379b528cefcSMark Murray }
3805e9cd1aeSAssar Westerlund ret = kadm5_log_truncate (kadm_handle);
3815e9cd1aeSAssar Westerlund if (ret) {
3825e9cd1aeSAssar Westerlund fclose (f);
3835e9cd1aeSAssar Westerlund krb5_warn(context, ret, "kadm5_log_truncate");
3845e9cd1aeSAssar Westerlund return 1;
3855e9cd1aeSAssar Westerlund }
3865e9cd1aeSAssar Westerlund
387c19800e8SDoug Rabson if(!mergep)
388b528cefcSMark Murray flags |= O_CREAT | O_TRUNC;
389c19800e8SDoug Rabson ret = db->hdb_open(context, db, flags, 0600);
390b528cefcSMark Murray if(ret){
391b528cefcSMark Murray krb5_warn(context, ret, "hdb_open");
392b528cefcSMark Murray fclose(f);
39313e3f4d6SMark Murray return 1;
394b528cefcSMark Murray }
395b528cefcSMark Murray line = 0;
3965e9cd1aeSAssar Westerlund ret = 0;
3975e9cd1aeSAssar Westerlund while(fgets(s, sizeof(s), f) != NULL) {
3985e9cd1aeSAssar Westerlund line++;
399b528cefcSMark Murray
400c19800e8SDoug Rabson p = s;
401c19800e8SDoug Rabson while (isspace((unsigned char)*p))
402c19800e8SDoug Rabson p++;
403c19800e8SDoug Rabson
404c19800e8SDoug Rabson e.principal = p;
405c19800e8SDoug Rabson for(p = s; *p; p++){
406b528cefcSMark Murray if(*p == '\\')
407b528cefcSMark Murray p++;
408b528cefcSMark Murray else if(isspace((unsigned char)*p)) {
409b528cefcSMark Murray *p = 0;
410b528cefcSMark Murray break;
411b528cefcSMark Murray }
412b528cefcSMark Murray }
413b528cefcSMark Murray p = skip_next(p);
414b528cefcSMark Murray
415b528cefcSMark Murray e.key = p;
416b528cefcSMark Murray p = skip_next(p);
417b528cefcSMark Murray
418b528cefcSMark Murray e.created = p;
419b528cefcSMark Murray p = skip_next(p);
420b528cefcSMark Murray
421b528cefcSMark Murray e.modified = p;
422b528cefcSMark Murray p = skip_next(p);
423b528cefcSMark Murray
424b528cefcSMark Murray e.valid_start = p;
425b528cefcSMark Murray p = skip_next(p);
426b528cefcSMark Murray
427b528cefcSMark Murray e.valid_end = p;
428b528cefcSMark Murray p = skip_next(p);
429b528cefcSMark Murray
430b528cefcSMark Murray e.pw_end = p;
431b528cefcSMark Murray p = skip_next(p);
432b528cefcSMark Murray
433b528cefcSMark Murray e.max_life = p;
434b528cefcSMark Murray p = skip_next(p);
435b528cefcSMark Murray
436b528cefcSMark Murray e.max_renew = p;
437b528cefcSMark Murray p = skip_next(p);
438b528cefcSMark Murray
439b528cefcSMark Murray e.flags = p;
440b528cefcSMark Murray p = skip_next(p);
441b528cefcSMark Murray
442b528cefcSMark Murray e.generation = p;
4434137ff4cSJacques Vidrine p = skip_next(p);
444b528cefcSMark Murray
445b528cefcSMark Murray e.extensions = p;
446c19800e8SDoug Rabson skip_next(p);
447c19800e8SDoug Rabson
448c19800e8SDoug Rabson memset(&ent, 0, sizeof(ent));
449b528cefcSMark Murray ret = krb5_parse_name(context, e.principal, &ent.entry.principal);
450c19800e8SDoug Rabson if(ret) {
451b528cefcSMark Murray const char *msg = krb5_get_error_message(context, ret);
452b528cefcSMark Murray fprintf(stderr, "%s:%d:%s (%s)\n",
453b528cefcSMark Murray filename, line, msg, e.principal);
454b528cefcSMark Murray krb5_free_error_message(context, msg);
455b528cefcSMark Murray continue;
456b528cefcSMark Murray }
457b528cefcSMark Murray
458b528cefcSMark Murray if (parse_keys(&ent.entry, e.key)) {
459b528cefcSMark Murray fprintf (stderr, "%s:%d:error parsing keys (%s)\n",
460c19800e8SDoug Rabson filename, line, e.key);
46113e3f4d6SMark Murray hdb_free_entry (context, &ent);
46213e3f4d6SMark Murray continue;
46313e3f4d6SMark Murray }
46413e3f4d6SMark Murray
46513e3f4d6SMark Murray if (parse_event(&ent.entry.created_by, e.created) == -1) {
466b528cefcSMark Murray fprintf (stderr, "%s:%d:error parsing created event (%s)\n",
467c19800e8SDoug Rabson filename, line, e.created);
46813e3f4d6SMark Murray hdb_free_entry (context, &ent);
46913e3f4d6SMark Murray continue;
47013e3f4d6SMark Murray }
47113e3f4d6SMark Murray if (parse_event_alloc (&ent.entry.modified_by, e.modified) == -1) {
47213e3f4d6SMark Murray fprintf (stderr, "%s:%d:error parsing event (%s)\n",
473c19800e8SDoug Rabson filename, line, e.modified);
47413e3f4d6SMark Murray hdb_free_entry (context, &ent);
47513e3f4d6SMark Murray continue;
47613e3f4d6SMark Murray }
47713e3f4d6SMark Murray if (parse_time_string_alloc (&ent.entry.valid_start, e.valid_start) == -1) {
47813e3f4d6SMark Murray fprintf (stderr, "%s:%d:error parsing time (%s)\n",
479c19800e8SDoug Rabson filename, line, e.valid_start);
48013e3f4d6SMark Murray hdb_free_entry (context, &ent);
48113e3f4d6SMark Murray continue;
48213e3f4d6SMark Murray }
48313e3f4d6SMark Murray if (parse_time_string_alloc (&ent.entry.valid_end, e.valid_end) == -1) {
48413e3f4d6SMark Murray fprintf (stderr, "%s:%d:error parsing time (%s)\n",
485c19800e8SDoug Rabson filename, line, e.valid_end);
48613e3f4d6SMark Murray hdb_free_entry (context, &ent);
48713e3f4d6SMark Murray continue;
48813e3f4d6SMark Murray }
48913e3f4d6SMark Murray if (parse_time_string_alloc (&ent.entry.pw_end, e.pw_end) == -1) {
49013e3f4d6SMark Murray fprintf (stderr, "%s:%d:error parsing time (%s)\n",
491c19800e8SDoug Rabson filename, line, e.pw_end);
49213e3f4d6SMark Murray hdb_free_entry (context, &ent);
49313e3f4d6SMark Murray continue;
49413e3f4d6SMark Murray }
49513e3f4d6SMark Murray
49613e3f4d6SMark Murray if (parse_integer_alloc (&ent.entry.max_life, e.max_life) == -1) {
49713e3f4d6SMark Murray fprintf (stderr, "%s:%d:error parsing lifetime (%s)\n",
498c19800e8SDoug Rabson filename, line, e.max_life);
49913e3f4d6SMark Murray hdb_free_entry (context, &ent);
50013e3f4d6SMark Murray continue;
50113e3f4d6SMark Murray
50213e3f4d6SMark Murray }
50313e3f4d6SMark Murray if (parse_integer_alloc (&ent.entry.max_renew, e.max_renew) == -1) {
50413e3f4d6SMark Murray fprintf (stderr, "%s:%d:error parsing lifetime (%s)\n",
505c19800e8SDoug Rabson filename, line, e.max_renew);
50613e3f4d6SMark Murray hdb_free_entry (context, &ent);
50713e3f4d6SMark Murray continue;
50813e3f4d6SMark Murray }
50913e3f4d6SMark Murray
51013e3f4d6SMark Murray if (parse_hdbflags2int (&ent.entry.flags, e.flags) != 1) {
51113e3f4d6SMark Murray fprintf (stderr, "%s:%d:error parsing flags (%s)\n",
512c19800e8SDoug Rabson filename, line, e.flags);
51313e3f4d6SMark Murray hdb_free_entry (context, &ent);
51413e3f4d6SMark Murray continue;
51513e3f4d6SMark Murray }
51613e3f4d6SMark Murray
51713e3f4d6SMark Murray if(parse_generation(e.generation, &ent.entry.generation) == -1) {
5184137ff4cSJacques Vidrine fprintf (stderr, "%s:%d:error parsing generation (%s)\n",
519c19800e8SDoug Rabson filename, line, e.generation);
5204137ff4cSJacques Vidrine hdb_free_entry (context, &ent);
5214137ff4cSJacques Vidrine continue;
5224137ff4cSJacques Vidrine }
5234137ff4cSJacques Vidrine
524b528cefcSMark Murray if(parse_extensions(e.extensions, &ent.entry.extensions) == -1) {
525b528cefcSMark Murray fprintf (stderr, "%s:%d:error parsing extension (%s)\n",
526c19800e8SDoug Rabson filename, line, e.extensions);
527c19800e8SDoug Rabson hdb_free_entry (context, &ent);
528c19800e8SDoug Rabson continue;
529c19800e8SDoug Rabson }
530c19800e8SDoug Rabson
531c19800e8SDoug Rabson ret = db->hdb_store(context, db, HDB_F_REPLACE, &ent);
532c19800e8SDoug Rabson hdb_free_entry (context, &ent);
533c19800e8SDoug Rabson if (ret) {
534b528cefcSMark Murray krb5_warn(context, ret, "db_store");
5355e9cd1aeSAssar Westerlund break;
5365e9cd1aeSAssar Westerlund }
5375e9cd1aeSAssar Westerlund }
5385e9cd1aeSAssar Westerlund db->hdb_close(context, db);
539b528cefcSMark Murray fclose(f);
540c19800e8SDoug Rabson return ret != 0;
541b528cefcSMark Murray }
5425e9cd1aeSAssar Westerlund
543b528cefcSMark Murray
544b528cefcSMark Murray extern int local_flag;
5455e9cd1aeSAssar Westerlund
546c19800e8SDoug Rabson static int
loadit(int mergep,const char * name,int argc,char ** argv)5475e9cd1aeSAssar Westerlund loadit(int mergep, const char *name, int argc, char **argv)
548c19800e8SDoug Rabson {
549c19800e8SDoug Rabson if(!local_flag) {
5505e9cd1aeSAssar Westerlund krb5_warnx(context, "%s is only available in local (-l) mode", name);
551c19800e8SDoug Rabson return 0;
552c19800e8SDoug Rabson }
5535e9cd1aeSAssar Westerlund
5545e9cd1aeSAssar Westerlund return doit(argv[0], mergep);
5555e9cd1aeSAssar Westerlund }
556c19800e8SDoug Rabson
557b528cefcSMark Murray int
load(void * opt,int argc,char ** argv)558b528cefcSMark Murray load(void *opt, int argc, char **argv)
559b528cefcSMark Murray {
560c19800e8SDoug Rabson return loadit(0, "load", argc, argv);
561b528cefcSMark Murray }
562c19800e8SDoug Rabson
5635e9cd1aeSAssar Westerlund int
merge(void * opt,int argc,char ** argv)5645e9cd1aeSAssar Westerlund merge(void *opt, int argc, char **argv)
565c19800e8SDoug Rabson {
566c19800e8SDoug Rabson return loadit(1, "merge", argc, argv);
567c19800e8SDoug Rabson }
568c19800e8SDoug Rabson