1b528cefcSMark Murray /* 213e3f4d6SMark Murray * Copyright (c) 1997 - 2000 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" 35b528cefcSMark Murray #include <kadm5/private.h> 36b528cefcSMark Murray 3713e3f4d6SMark Murray RCSID("$Id: load.c,v 1.35 2000/01/25 22:59:27 assar Exp $"); 38b528cefcSMark Murray 39b528cefcSMark Murray struct entry { 40b528cefcSMark Murray char *principal; 41b528cefcSMark Murray char *key; 42b528cefcSMark Murray char *max_life; 43b528cefcSMark Murray char *max_renew; 44b528cefcSMark Murray char *created; 45b528cefcSMark Murray char *modified; 46b528cefcSMark Murray char *valid_start; 47b528cefcSMark Murray char *valid_end; 48b528cefcSMark Murray char *pw_end; 49b528cefcSMark Murray char *flags; 50b528cefcSMark Murray char *etypes; 51b528cefcSMark Murray }; 52b528cefcSMark Murray 53b528cefcSMark Murray static char * 54b528cefcSMark Murray skip_next(char *p) 55b528cefcSMark Murray { 56b528cefcSMark Murray while(*p && !isspace((unsigned char)*p)) 57b528cefcSMark Murray p++; 58b528cefcSMark Murray *p++ = 0; 5913e3f4d6SMark Murray while(*p && isspace((unsigned char)*p)) 6013e3f4d6SMark Murray p++; 61b528cefcSMark Murray return p; 62b528cefcSMark Murray } 63b528cefcSMark Murray 6413e3f4d6SMark Murray /* 6513e3f4d6SMark 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 7213e3f4d6SMark Murray parse_time_string(time_t *t, const char *s) 73b528cefcSMark Murray { 74b528cefcSMark Murray int year, month, date, hour, minute, second; 75b528cefcSMark Murray struct tm tm; 7613e3f4d6SMark Murray 77b528cefcSMark Murray if(strcmp(s, "-") == 0) 7813e3f4d6SMark Murray return 0; 7913e3f4d6SMark Murray if(sscanf(s, "%04d%02d%02d%02d%02d%02d", 8013e3f4d6SMark Murray &year, &month, &date, &hour, &minute, &second) != 6) 8113e3f4d6SMark Murray return -1; 82b528cefcSMark Murray tm.tm_year = year - 1900; 83b528cefcSMark 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); 9013e3f4d6SMark Murray return 1; 91b528cefcSMark Murray } 92b528cefcSMark Murray 9313e3f4d6SMark Murray /* 9413e3f4d6SMark Murray * parse time, allocating space in *t if it's there 9513e3f4d6SMark Murray */ 9613e3f4d6SMark Murray 9713e3f4d6SMark Murray static int 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 11913e3f4d6SMark Murray parse_integer(unsigned *u, const char *s) 120b528cefcSMark Murray { 121b528cefcSMark Murray if(strcmp(s, "-") == 0) 12213e3f4d6SMark Murray return 0; 12313e3f4d6SMark Murray if (sscanf(s, "%u", u) != 1) 12413e3f4d6SMark Murray return -1; 12513e3f4d6SMark Murray return 1; 126b528cefcSMark Murray } 127b528cefcSMark Murray 12813e3f4d6SMark Murray static int 12913e3f4d6SMark Murray parse_integer_alloc (int **u, const char *s) 13013e3f4d6SMark Murray { 13113e3f4d6SMark Murray unsigned tmp; 13213e3f4d6SMark Murray int ret; 13313e3f4d6SMark Murray 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 151b528cefcSMark Murray parse_keys(hdb_entry *ent, char *str) 152b528cefcSMark Murray { 15313e3f4d6SMark Murray krb5_error_code ret; 154b528cefcSMark Murray int tmp; 155b528cefcSMark Murray char *p; 156b528cefcSMark Murray int i; 157b528cefcSMark Murray 158b528cefcSMark Murray p = strsep(&str, ":"); 15913e3f4d6SMark Murray if (sscanf(p, "%d", &tmp) != 1) 16013e3f4d6SMark Murray return 1; 161b528cefcSMark Murray ent->kvno = tmp; 162b528cefcSMark 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) 16813e3f4d6SMark Murray krb5_errx (context, 1, "realloc: out of memory"); 169b528cefcSMark Murray ent->keys.val = key; 170b528cefcSMark 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, ":"); 17913e3f4d6SMark Murray if (sscanf(p, "%d", &tmp) != 1) 18013e3f4d6SMark Murray return 1; 181b528cefcSMark Murray key->key.keytype = tmp; 182b528cefcSMark Murray p = strsep(&str, ":"); 18313e3f4d6SMark Murray ret = krb5_data_alloc(&key->key.keyvalue, (strlen(p) - 1) / 2 + 1); 18413e3f4d6SMark Murray if (ret) 18513e3f4d6SMark Murray krb5_err (context, 1, ret, "krb5_data_alloc"); 186b528cefcSMark Murray for(i = 0; i < strlen(p); i += 2) { 18713e3f4d6SMark Murray if(sscanf(p + i, "%02x", &tmp) != 1) 18813e3f4d6SMark Murray return 1; 189b528cefcSMark Murray ((u_char*)key->key.keyvalue.data)[i / 2] = tmp; 190b528cefcSMark Murray } 191b528cefcSMark Murray p = strsep(&str, ":"); 192b528cefcSMark Murray if(strcmp(p, "-") != 0){ 193b528cefcSMark Murray unsigned type; 194b528cefcSMark Murray size_t p_len; 19513e3f4d6SMark Murray 19613e3f4d6SMark Murray if(sscanf(p, "%u/", &type) != 1) 19713e3f4d6SMark Murray return 1; 198b528cefcSMark Murray p = strchr(p, '/'); 199b528cefcSMark Murray if(p == NULL) 20013e3f4d6SMark Murray return 1; 201b528cefcSMark Murray p++; 202b528cefcSMark Murray p_len = strlen(p); 203b528cefcSMark Murray 204b528cefcSMark Murray key->salt = malloc(sizeof(*key->salt)); 20513e3f4d6SMark Murray if (key->salt == NULL) 20613e3f4d6SMark Murray krb5_errx (context, 1, "malloc: out of memory"); 207b528cefcSMark Murray key->salt->type = type; 208b528cefcSMark Murray 209b528cefcSMark Murray if (p_len) { 210b528cefcSMark Murray if(*p == '\"') { 21113e3f4d6SMark Murray ret = krb5_data_copy(&key->salt->salt, p + 1, p_len - 2); 21213e3f4d6SMark Murray if (ret) 21313e3f4d6SMark Murray krb5_err (context, 1, ret, "krb5_data_copy"); 214b528cefcSMark Murray } else { 21513e3f4d6SMark Murray ret = krb5_data_alloc(&key->salt->salt, 21613e3f4d6SMark Murray (p_len - 1) / 2 + 1); 21713e3f4d6SMark Murray if (ret) 21813e3f4d6SMark Murray krb5_err (context, 1, ret, "krb5_data_alloc"); 219b528cefcSMark Murray for(i = 0; i < p_len; i += 2){ 22013e3f4d6SMark Murray if (sscanf(p + i, "%02x", &tmp) != 1) 22113e3f4d6SMark Murray return 1; 222b528cefcSMark Murray ((u_char*)key->salt->salt.data)[i / 2] = tmp; 223b528cefcSMark Murray } 224b528cefcSMark Murray } 225b528cefcSMark Murray } else 226b528cefcSMark Murray krb5_data_zero (&key->salt->salt); 227b528cefcSMark Murray } 228b528cefcSMark Murray p = strsep(&str, ":"); 229b528cefcSMark Murray } 23013e3f4d6SMark Murray return 0; 231b528cefcSMark Murray } 232b528cefcSMark Murray 23313e3f4d6SMark Murray /* 23413e3f4d6SMark Murray * see parse_time_string for calling convention 23513e3f4d6SMark Murray */ 23613e3f4d6SMark Murray 23713e3f4d6SMark Murray static int 23813e3f4d6SMark Murray parse_event(Event *ev, char *s) 239b528cefcSMark Murray { 24013e3f4d6SMark Murray krb5_error_code ret; 241b528cefcSMark Murray char *p; 24213e3f4d6SMark Murray 24313e3f4d6SMark Murray if(strcmp(s, "-") == 0) 24413e3f4d6SMark Murray return 0; 245b528cefcSMark Murray memset(ev, 0, sizeof(*ev)); 24613e3f4d6SMark Murray p = strsep(&s, ":"); 24713e3f4d6SMark 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; 254b528cefcSMark Murray } 255b528cefcSMark Murray 25613e3f4d6SMark Murray static int 25713e3f4d6SMark Murray parse_event_alloc (Event **ev, char *s) 258b528cefcSMark Murray { 25913e3f4d6SMark Murray Event tmp; 26013e3f4d6SMark Murray int ret; 261b528cefcSMark Murray 26213e3f4d6SMark Murray *ev = NULL; 26313e3f4d6SMark 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 27413e3f4d6SMark Murray parse_hdbflags2int(HDBFlags *f, const char *s) 27513e3f4d6SMark Murray { 27613e3f4d6SMark Murray int ret; 27713e3f4d6SMark Murray unsigned tmp; 27813e3f4d6SMark Murray 27913e3f4d6SMark Murray ret = parse_integer (&tmp, s); 28013e3f4d6SMark Murray if (ret == 1) 28113e3f4d6SMark Murray *f = int2HDBFlags (tmp); 28213e3f4d6SMark Murray return ret; 283b528cefcSMark Murray } 284b528cefcSMark Murray 285b528cefcSMark Murray #if 0 286b528cefcSMark Murray static void 287b528cefcSMark Murray parse_etypes(char *str, unsigned **val, unsigned *len) 288b528cefcSMark Murray { 289b528cefcSMark Murray unsigned v; 290b528cefcSMark Murray 291b528cefcSMark Murray *val = NULL; 292b528cefcSMark Murray *len = 0; 293b528cefcSMark Murray while(sscanf(str, "%u", &v) == 1) { 294b528cefcSMark Murray *val = realloc(*val, (*len+1) * sizeof(**val)); 295b528cefcSMark Murray (*val)[(*len)++] = v; 296b528cefcSMark Murray str = strchr(str, ':'); 297b528cefcSMark Murray if(str == NULL) 298b528cefcSMark Murray break; 299b528cefcSMark Murray str++; 300b528cefcSMark Murray } 301b528cefcSMark Murray } 302b528cefcSMark Murray #endif 303b528cefcSMark Murray 30413e3f4d6SMark Murray /* 30513e3f4d6SMark Murray * Parse the dump file in `filename' and create the database (merging 30613e3f4d6SMark Murray * iff merge) 30713e3f4d6SMark Murray */ 30813e3f4d6SMark Murray 30913e3f4d6SMark Murray static int 31013e3f4d6SMark Murray doit(const char *filename, int merge) 311b528cefcSMark Murray { 312b528cefcSMark Murray krb5_error_code ret; 313b528cefcSMark Murray FILE *f; 314b528cefcSMark Murray char s[1024]; 315b528cefcSMark Murray char *p; 316b528cefcSMark Murray int line; 317b528cefcSMark Murray int flags = O_RDWR; 318b528cefcSMark Murray struct entry e; 319b528cefcSMark Murray hdb_entry ent; 320b528cefcSMark Murray HDB *db = _kadm5_s_get_db(kadm_handle); 321b528cefcSMark Murray 322b528cefcSMark Murray f = fopen(filename, "r"); 323b528cefcSMark Murray if(f == NULL){ 324b528cefcSMark Murray krb5_warn(context, errno, "fopen(%s)", filename); 32513e3f4d6SMark Murray return 1; 326b528cefcSMark Murray } 327b528cefcSMark Murray if(!merge) 328b528cefcSMark Murray flags |= O_CREAT | O_TRUNC; 329b528cefcSMark Murray ret = db->open(context, db, flags, 0600); 330b528cefcSMark Murray if(ret){ 331b528cefcSMark Murray krb5_warn(context, ret, "hdb_open"); 332b528cefcSMark Murray fclose(f); 33313e3f4d6SMark Murray return 1; 334b528cefcSMark Murray } 335b528cefcSMark Murray line = 0; 336b528cefcSMark Murray while(fgets(s, sizeof(s), f)){ 337b528cefcSMark Murray line++; 338b528cefcSMark Murray e.principal = s; 339b528cefcSMark Murray for(p = s; *p; p++){ 340b528cefcSMark Murray if(*p == '\\') 341b528cefcSMark Murray p++; 342b528cefcSMark Murray else if(isspace((unsigned char)*p)) { 343b528cefcSMark Murray *p = 0; 344b528cefcSMark Murray break; 345b528cefcSMark Murray } 346b528cefcSMark Murray } 347b528cefcSMark Murray p = skip_next(p); 348b528cefcSMark Murray 349b528cefcSMark Murray e.key = p; 350b528cefcSMark Murray p = skip_next(p); 351b528cefcSMark Murray 352b528cefcSMark Murray e.created = p; 353b528cefcSMark Murray p = skip_next(p); 354b528cefcSMark Murray 355b528cefcSMark Murray e.modified = p; 356b528cefcSMark Murray p = skip_next(p); 357b528cefcSMark Murray 358b528cefcSMark Murray e.valid_start = p; 359b528cefcSMark Murray p = skip_next(p); 360b528cefcSMark Murray 361b528cefcSMark Murray e.valid_end = p; 362b528cefcSMark Murray p = skip_next(p); 363b528cefcSMark Murray 364b528cefcSMark Murray e.pw_end = p; 365b528cefcSMark Murray p = skip_next(p); 366b528cefcSMark Murray 367b528cefcSMark Murray e.max_life = p; 368b528cefcSMark Murray p = skip_next(p); 369b528cefcSMark Murray 370b528cefcSMark Murray e.max_renew = p; 371b528cefcSMark Murray p = skip_next(p); 372b528cefcSMark Murray 373b528cefcSMark Murray e.flags = p; 374b528cefcSMark Murray p = skip_next(p); 375b528cefcSMark Murray 376b528cefcSMark Murray e.etypes = p; 377b528cefcSMark Murray p = skip_next(p); 378b528cefcSMark Murray 379b528cefcSMark Murray memset(&ent, 0, sizeof(ent)); 380b528cefcSMark Murray ret = krb5_parse_name(context, e.principal, &ent.principal); 381b528cefcSMark Murray if(ret) { 382b528cefcSMark Murray fprintf(stderr, "%s:%d:%s (%s)\n", 383b528cefcSMark Murray filename, 384b528cefcSMark Murray line, 385b528cefcSMark Murray krb5_get_err_text(context, ret), 386b528cefcSMark Murray e.principal); 387b528cefcSMark Murray continue; 388b528cefcSMark Murray } 389b528cefcSMark Murray 39013e3f4d6SMark Murray if (parse_keys(&ent, e.key)) { 39113e3f4d6SMark Murray fprintf (stderr, "%s:%d:error parsing keys (%s)\n", 39213e3f4d6SMark Murray filename, line, e.key); 39313e3f4d6SMark Murray hdb_free_entry (context, &ent); 39413e3f4d6SMark Murray continue; 39513e3f4d6SMark Murray } 396b528cefcSMark Murray 39713e3f4d6SMark Murray if (parse_event(&ent.created_by, e.created) == -1) { 39813e3f4d6SMark Murray fprintf (stderr, "%s:%d:error parsing created event (%s)\n", 39913e3f4d6SMark Murray filename, line, e.created); 40013e3f4d6SMark Murray hdb_free_entry (context, &ent); 40113e3f4d6SMark Murray continue; 40213e3f4d6SMark Murray } 40313e3f4d6SMark Murray if (parse_event_alloc (&ent.modified_by, e.modified) == -1) { 40413e3f4d6SMark Murray fprintf (stderr, "%s:%d:error parsing event (%s)\n", 40513e3f4d6SMark Murray filename, line, e.modified); 40613e3f4d6SMark Murray hdb_free_entry (context, &ent); 40713e3f4d6SMark Murray continue; 40813e3f4d6SMark Murray } 40913e3f4d6SMark Murray if (parse_time_string_alloc (&ent.valid_start, e.valid_start) == -1) { 41013e3f4d6SMark Murray fprintf (stderr, "%s:%d:error parsing time (%s)\n", 41113e3f4d6SMark Murray filename, line, e.valid_start); 41213e3f4d6SMark Murray hdb_free_entry (context, &ent); 41313e3f4d6SMark Murray continue; 41413e3f4d6SMark Murray } 41513e3f4d6SMark Murray if (parse_time_string_alloc (&ent.valid_end, e.valid_end) == -1) { 41613e3f4d6SMark Murray fprintf (stderr, "%s:%d:error parsing time (%s)\n", 41713e3f4d6SMark Murray filename, line, e.valid_end); 41813e3f4d6SMark Murray hdb_free_entry (context, &ent); 41913e3f4d6SMark Murray continue; 42013e3f4d6SMark Murray } 42113e3f4d6SMark Murray if (parse_time_string_alloc (&ent.pw_end, e.pw_end) == -1) { 42213e3f4d6SMark Murray fprintf (stderr, "%s:%d:error parsing time (%s)\n", 42313e3f4d6SMark Murray filename, line, e.pw_end); 42413e3f4d6SMark Murray hdb_free_entry (context, &ent); 42513e3f4d6SMark Murray continue; 42613e3f4d6SMark Murray } 42713e3f4d6SMark Murray 42813e3f4d6SMark Murray if (parse_integer_alloc (&ent.max_life, e.max_life) == -1) { 42913e3f4d6SMark Murray fprintf (stderr, "%s:%d:error parsing lifetime (%s)\n", 43013e3f4d6SMark Murray filename, line, e.max_life); 43113e3f4d6SMark Murray hdb_free_entry (context, &ent); 43213e3f4d6SMark Murray continue; 43313e3f4d6SMark Murray 43413e3f4d6SMark Murray } 43513e3f4d6SMark Murray if (parse_integer_alloc (&ent.max_renew, e.max_renew) == -1) { 43613e3f4d6SMark Murray fprintf (stderr, "%s:%d:error parsing lifetime (%s)\n", 43713e3f4d6SMark Murray filename, line, e.max_renew); 43813e3f4d6SMark Murray hdb_free_entry (context, &ent); 43913e3f4d6SMark Murray continue; 44013e3f4d6SMark Murray } 44113e3f4d6SMark Murray 44213e3f4d6SMark Murray if (parse_hdbflags2int (&ent.flags, e.flags) != 0) { 44313e3f4d6SMark Murray fprintf (stderr, "%s:%d:error parsing flags (%s)\n", 44413e3f4d6SMark Murray filename, line, e.flags); 44513e3f4d6SMark Murray hdb_free_entry (context, &ent); 44613e3f4d6SMark Murray continue; 44713e3f4d6SMark Murray } 448b528cefcSMark Murray #if 0 449b528cefcSMark Murray ALLOC(ent.etypes); 450b528cefcSMark Murray parse_etypes(e.etypes, &ent.etypes->val, &ent.etypes->len); 451b528cefcSMark Murray if(ent.etypes->len == 0) { 452b528cefcSMark Murray free(ent.etypes); 453b528cefcSMark Murray ent.etypes = NULL; 454b528cefcSMark Murray } 455b528cefcSMark Murray #endif 456b528cefcSMark Murray 457b528cefcSMark Murray db->store(context, db, HDB_F_REPLACE, &ent); 458b528cefcSMark Murray hdb_free_entry (context, &ent); 459b528cefcSMark Murray } 460b528cefcSMark Murray db->close(context, db); 461b528cefcSMark Murray fclose(f); 46213e3f4d6SMark Murray return 0; 463b528cefcSMark Murray } 464b528cefcSMark Murray 465b528cefcSMark Murray int 466b528cefcSMark Murray load(int argc, char **argv) 467b528cefcSMark Murray { 468b528cefcSMark Murray if(argc < 2){ 469b528cefcSMark Murray krb5_warnx(context, "Usage: load filename"); 470b528cefcSMark Murray return 0; 471b528cefcSMark Murray } 472b528cefcSMark Murray doit(argv[1], 0); 473b528cefcSMark Murray return 0; 474b528cefcSMark Murray } 475b528cefcSMark Murray 476b528cefcSMark Murray int 477b528cefcSMark Murray merge(int argc, char **argv) 478b528cefcSMark Murray { 479b528cefcSMark Murray if(argc < 2){ 480b528cefcSMark Murray krb5_warnx(context, "Usage: merge filename"); 481b528cefcSMark Murray return 0; 482b528cefcSMark Murray } 483b528cefcSMark Murray doit(argv[1], 1); 484b528cefcSMark Murray return 0; 485b528cefcSMark Murray } 486