oysteikt/heimdal
0
0
Fork 0
Code Issues 5 Pull Requests Releases Activity

Wrap hdb_entry with hdb_entry_ex, patch originally from Andrew Bartlet

Browse Source 
git-svn-id: svn://svn.h5l.se/heimdal/trunk/heimdal@16378 ec53bebd-3082-4978-b11e-865c3cabbd6b
This commit is contained in:
Love Hörnquist Åstrand
2005-12-12 12:40:12 +00:00
parent eb128f4928
commit 0c2369acd0
29 changed files with 445 additions and 409 deletions
Download Patch File Download Diff File Expand all files Collapse all files

26
kadmin/load.c
View File

@@ -369,7 +369,7 @@ doit(const char *filename, int mergep)
int line; int line;
int flags = O_RDWR; int flags = O_RDWR;
struct entry e; struct entry e;
hdb_entry ent; hdb_entry_ex ent;
HDB *db = _kadm5_s_get_db(kadm_handle); HDB *db = _kadm5_s_get_db(kadm_handle);
f = fopen(filename, "r"); f = fopen(filename, "r");
@@ -447,7 +447,7 @@ doit(const char *filename, int mergep)
p = skip_next(p); p = skip_next(p);
memset(&ent, 0, sizeof(ent)); memset(&ent, 0, sizeof(ent));
ret = krb5_parse_name(context, e.principal, &ent.principal); ret = krb5_parse_name(context, e.principal, &ent.entry.principal);
if(ret) { if(ret) {
fprintf(stderr, "%s:%d:%s (%s)\n", fprintf(stderr, "%s:%d:%s (%s)\n",
filename, filename,
@@ -457,73 +457,73 @@ doit(const char *filename, int mergep)
continue; continue;
} }
if (parse_keys(&ent, e.key)) { if (parse_keys(&ent.entry, e.key)) {
fprintf (stderr, "%s:%d:error parsing keys (%s)\n", fprintf (stderr, "%s:%d:error parsing keys (%s)\n",
filename, line, e.key); filename, line, e.key);
hdb_free_entry (context, &ent); hdb_free_entry (context, &ent);
continue; continue;
} }
if (parse_event(&ent.created_by, e.created) == -1) { if (parse_event(&ent.entry.created_by, e.created) == -1) {
fprintf (stderr, "%s:%d:error parsing created event (%s)\n", fprintf (stderr, "%s:%d:error parsing created event (%s)\n",
filename, line, e.created); filename, line, e.created);
hdb_free_entry (context, &ent); hdb_free_entry (context, &ent);
continue; continue;
} }
if (parse_event_alloc (&ent.modified_by, e.modified) == -1) { if (parse_event_alloc (&ent.entry.modified_by, e.modified) == -1) {
fprintf (stderr, "%s:%d:error parsing event (%s)\n", fprintf (stderr, "%s:%d:error parsing event (%s)\n",
filename, line, e.modified); filename, line, e.modified);
hdb_free_entry (context, &ent); hdb_free_entry (context, &ent);
continue; continue;
} }
if (parse_time_string_alloc (&ent.valid_start, e.valid_start) == -1) { if (parse_time_string_alloc (&ent.entry.valid_start, e.valid_start) == -1) {
fprintf (stderr, "%s:%d:error parsing time (%s)\n", fprintf (stderr, "%s:%d:error parsing time (%s)\n",
filename, line, e.valid_start); filename, line, e.valid_start);
hdb_free_entry (context, &ent); hdb_free_entry (context, &ent);
continue; continue;
} }
if (parse_time_string_alloc (&ent.valid_end, e.valid_end) == -1) { if (parse_time_string_alloc (&ent.entry.valid_end, e.valid_end) == -1) {
fprintf (stderr, "%s:%d:error parsing time (%s)\n", fprintf (stderr, "%s:%d:error parsing time (%s)\n",
filename, line, e.valid_end); filename, line, e.valid_end);
hdb_free_entry (context, &ent); hdb_free_entry (context, &ent);
continue; continue;
} }
if (parse_time_string_alloc (&ent.pw_end, e.pw_end) == -1) { if (parse_time_string_alloc (&ent.entry.pw_end, e.pw_end) == -1) {
fprintf (stderr, "%s:%d:error parsing time (%s)\n", fprintf (stderr, "%s:%d:error parsing time (%s)\n",
filename, line, e.pw_end); filename, line, e.pw_end);
hdb_free_entry (context, &ent); hdb_free_entry (context, &ent);
continue; continue;
} }
if (parse_integer_alloc (&ent.max_life, e.max_life) == -1) { if (parse_integer_alloc (&ent.entry.max_life, e.max_life) == -1) {
fprintf (stderr, "%s:%d:error parsing lifetime (%s)\n", fprintf (stderr, "%s:%d:error parsing lifetime (%s)\n",
filename, line, e.max_life); filename, line, e.max_life);
hdb_free_entry (context, &ent); hdb_free_entry (context, &ent);
continue; continue;
} }
if (parse_integer_alloc (&ent.max_renew, e.max_renew) == -1) { if (parse_integer_alloc (&ent.entry.max_renew, e.max_renew) == -1) {
fprintf (stderr, "%s:%d:error parsing lifetime (%s)\n", fprintf (stderr, "%s:%d:error parsing lifetime (%s)\n",
filename, line, e.max_renew); filename, line, e.max_renew);
hdb_free_entry (context, &ent); hdb_free_entry (context, &ent);
continue; continue;
} }
if (parse_hdbflags2int (&ent.flags, e.flags) != 1) { if (parse_hdbflags2int (&ent.entry.flags, e.flags) != 1) {
fprintf (stderr, "%s:%d:error parsing flags (%s)\n", fprintf (stderr, "%s:%d:error parsing flags (%s)\n",
filename, line, e.flags); filename, line, e.flags);
hdb_free_entry (context, &ent); hdb_free_entry (context, &ent);
continue; continue;
} }
if(parse_generation(e.generation, &ent.generation) == -1) { if(parse_generation(e.generation, &ent.entry.generation) == -1) {
fprintf (stderr, "%s:%d:error parsing generation (%s)\n", fprintf (stderr, "%s:%d:error parsing generation (%s)\n",
filename, line, e.generation); filename, line, e.generation);
hdb_free_entry (context, &ent); hdb_free_entry (context, &ent);
continue; continue;
} }
if(parse_extensions(e.extensions, &ent.extensions) == -1) { if(parse_extensions(e.extensions, &ent.entry.extensions) == -1) {
fprintf (stderr, "%s:%d:error parsing extension (%s)\n", fprintf (stderr, "%s:%d:error parsing extension (%s)\n",
filename, line, e.extensions); filename, line, e.extensions);
hdb_free_entry (context, &ent); hdb_free_entry (context, &ent);

169
kdc/hprop.c
View File

@@ -100,28 +100,28 @@ open_socket(krb5_context context, const char *hostname, const char *port)
} }
krb5_error_code krb5_error_code
v5_prop(krb5_context context, HDB *db, hdb_entry *entry, void *appdata) v5_prop(krb5_context context, HDB *db, hdb_entry_ex *entry, void *appdata)
{ {
krb5_error_code ret; krb5_error_code ret;
struct prop_data *pd = appdata; struct prop_data *pd = appdata;
krb5_data data; krb5_data data;
if(encrypt_flag) { if(encrypt_flag) {
ret = hdb_seal_keys_mkey(context, entry, mkey5); ret = hdb_seal_keys_mkey(context, &entry->entry, mkey5);
if (ret) { if (ret) {
krb5_warn(context, ret, "hdb_seal_keys_mkey"); krb5_warn(context, ret, "hdb_seal_keys_mkey");
return ret; return ret;
} }
} }
if(decrypt_flag) { if(decrypt_flag) {
ret = hdb_unseal_keys_mkey(context, entry, mkey5); ret = hdb_unseal_keys_mkey(context, &entry->entry, mkey5);
if (ret) { if (ret) {
krb5_warn(context, ret, "hdb_unseal_keys_mkey"); krb5_warn(context, ret, "hdb_unseal_keys_mkey");
return ret; return ret;
} }
} }
ret = hdb_entry2value(context, entry, &data); ret = hdb_entry2value(context, &entry->entry, &data);
if(ret) { if(ret) {
krb5_warn(context, ret, "hdb_entry2value"); krb5_warn(context, ret, "hdb_entry2value");
return ret; return ret;
@@ -176,13 +176,13 @@ int
v4_prop(void *arg, struct v4_principal *p) v4_prop(void *arg, struct v4_principal *p)
{ {
struct prop_data *pd = arg; struct prop_data *pd = arg;
hdb_entry ent; hdb_entry_ex ent;
krb5_error_code ret; krb5_error_code ret;
memset(&ent, 0, sizeof(ent)); memset(&ent, 0, sizeof(ent));
ret = krb5_425_conv_principal(pd->context, p->name, p->instance, v4_realm, ret = krb5_425_conv_principal(pd->context, p->name, p->instance, v4_realm,
&ent.principal); &ent.entry.principal);
if(ret) { if(ret) {
krb5_warn(pd->context, ret, krb5_warn(pd->context, ret,
"krb5_425_conv_principal %s.%s@%s", "krb5_425_conv_principal %s.%s@%s",
@@ -192,49 +192,49 @@ v4_prop(void *arg, struct v4_principal *p)
if(verbose_flag) { if(verbose_flag) {
char *s; char *s;
krb5_unparse_name_short(pd->context, ent.principal, &s); krb5_unparse_name_short(pd->context, ent.entry.principal, &s);
krb5_warnx(pd->context, "%s.%s -> %s", p->name, p->instance, s); krb5_warnx(pd->context, "%s.%s -> %s", p->name, p->instance, s);
free(s); free(s);
} }
ent.kvno = p->kvno; ent.entry.kvno = p->kvno;
ent.keys.len = 3; ent.entry.keys.len = 3;
ent.keys.val = malloc(ent.keys.len * sizeof(*ent.keys.val)); ent.entry.keys.val = malloc(ent.entry.keys.len * sizeof(*ent.entry.keys.val));
if(p->mkvno != -1) { if(p->mkvno != -1) {
ent.keys.val[0].mkvno = malloc (sizeof(*ent.keys.val[0].mkvno)); ent.entry.keys.val[0].mkvno = malloc (sizeof(*ent.entry.keys.val[0].mkvno));
*(ent.keys.val[0].mkvno) = p->mkvno; *(ent.entry.keys.val[0].mkvno) = p->mkvno;
} else } else
ent.keys.val[0].mkvno = NULL; ent.entry.keys.val[0].mkvno = NULL;
ent.keys.val[0].salt = calloc(1, sizeof(*ent.keys.val[0].salt)); ent.entry.keys.val[0].salt = calloc(1, sizeof(*ent.entry.keys.val[0].salt));
ent.keys.val[0].salt->type = KRB5_PADATA_PW_SALT; ent.entry.keys.val[0].salt->type = KRB5_PADATA_PW_SALT;
ent.keys.val[0].key.keytype = ETYPE_DES_CBC_MD5; ent.entry.keys.val[0].key.keytype = ETYPE_DES_CBC_MD5;
krb5_data_alloc(&ent.keys.val[0].key.keyvalue, DES_KEY_SZ); krb5_data_alloc(&ent.entry.keys.val[0].key.keyvalue, DES_KEY_SZ);
memcpy(ent.keys.val[0].key.keyvalue.data, p->key, 8); memcpy(ent.entry.keys.val[0].key.keyvalue.data, p->key, 8);
copy_Key(&ent.keys.val[0], &ent.keys.val[1]); copy_Key(&ent.entry.keys.val[0], &ent.entry.keys.val[1]);
ent.keys.val[1].key.keytype = ETYPE_DES_CBC_MD4; ent.entry.keys.val[1].key.keytype = ETYPE_DES_CBC_MD4;
copy_Key(&ent.keys.val[0], &ent.keys.val[2]); copy_Key(&ent.entry.keys.val[0], &ent.entry.keys.val[2]);
ent.keys.val[2].key.keytype = ETYPE_DES_CBC_CRC; ent.entry.keys.val[2].key.keytype = ETYPE_DES_CBC_CRC;
{ {
int life = _krb5_krb_life_to_time(0, p->max_life); int life = _krb5_krb_life_to_time(0, p->max_life);
if(life == NEVERDATE){ if(life == NEVERDATE){
ent.max_life = NULL; ent.entry.max_life = NULL;
} else { } else {
/* clean up lifetime a bit */ /* clean up lifetime a bit */
if(life > 86400) if(life > 86400)
life = (life + 86399) / 86400 * 86400; life = (life + 86399) / 86400 * 86400;
else if(life > 3600) else if(life > 3600)
life = (life + 3599) / 3600 * 3600; life = (life + 3599) / 3600 * 3600;
ALLOC(ent.max_life); ALLOC(ent.entry.max_life);
*ent.max_life = life; *ent.entry.max_life = life;
} }
} }
ALLOC(ent.valid_end); ALLOC(ent.entry.valid_end);
*ent.valid_end = p->exp_date; *ent.entry.valid_end = p->exp_date;
ret = krb5_make_principal(pd->context, &ent.created_by.principal, ret = krb5_make_principal(pd->context, &ent.entry.created_by.principal,
v4_realm, v4_realm,
"kadmin", "kadmin",
"hprop", "hprop",
@@ -244,44 +244,44 @@ v4_prop(void *arg, struct v4_principal *p)
ret = 0; ret = 0;
goto out; goto out;
} }
ent.created_by.time = time(NULL); ent.entry.created_by.time = time(NULL);
ALLOC(ent.modified_by); ALLOC(ent.entry.modified_by);
ret = krb5_425_conv_principal(pd->context, p->mod_name, p->mod_instance, ret = krb5_425_conv_principal(pd->context, p->mod_name, p->mod_instance,
v4_realm, &ent.modified_by->principal); v4_realm, &ent.entry.modified_by->principal);
if(ret){ if(ret){
krb5_warn(pd->context, ret, "%s.%s@%s", p->name, p->instance, v4_realm); krb5_warn(pd->context, ret, "%s.%s@%s", p->name, p->instance, v4_realm);
ent.modified_by->principal = NULL; ent.entry.modified_by->principal = NULL;
ret = 0; ret = 0;
goto out; goto out;
} }
ent.modified_by->time = p->mod_date; ent.entry.modified_by->time = p->mod_date;
ent.flags.forwardable = 1; ent.entry.flags.forwardable = 1;
ent.flags.renewable = 1; ent.entry.flags.renewable = 1;
ent.flags.proxiable = 1; ent.entry.flags.proxiable = 1;
ent.flags.postdate = 1; ent.entry.flags.postdate = 1;
ent.flags.client = 1; ent.entry.flags.client = 1;
ent.flags.server = 1; ent.entry.flags.server = 1;
/* special case password changing service */ /* special case password changing service */
if(strcmp(p->name, "changepw") == 0 && if(strcmp(p->name, "changepw") == 0 &&
strcmp(p->instance, "kerberos") == 0) { strcmp(p->instance, "kerberos") == 0) {
ent.flags.forwardable = 0; ent.entry.flags.forwardable = 0;
ent.flags.renewable = 0; ent.entry.flags.renewable = 0;
ent.flags.proxiable = 0; ent.entry.flags.proxiable = 0;
ent.flags.postdate = 0; ent.entry.flags.postdate = 0;
ent.flags.initial = 1; ent.entry.flags.initial = 1;
ent.flags.change_pw = 1; ent.entry.flags.change_pw = 1;
} }
ret = v5_prop(pd->context, NULL, &ent, pd); ret = v5_prop(pd->context, NULL, &ent, pd);
if (strcmp (p->name, "krbtgt") == 0 if (strcmp (p->name, "krbtgt") == 0
&& strcmp (v4_realm, p->instance) != 0) { && strcmp (v4_realm, p->instance) != 0) {
krb5_free_principal (pd->context, ent.principal); krb5_free_principal (pd->context, ent.entry.principal);
ret = krb5_425_conv_principal (pd->context, p->name, ret = krb5_425_conv_principal (pd->context, p->name,
v4_realm, p->instance, v4_realm, p->instance,
&ent.principal); &ent.entry.principal);
if (ret == 0) if (ret == 0)
ret = v5_prop (pd->context, NULL, &ent, pd); ret = v5_prop (pd->context, NULL, &ent, pd);
} }
@@ -317,87 +317,90 @@ ka_convert(struct prop_data *pd, int fd, struct ka_entry *ent)
{ {
int32_t flags = ntohl(ent->flags); int32_t flags = ntohl(ent->flags);
krb5_error_code ret; krb5_error_code ret;
hdb_entry hdb; hdb_entry_ex hdb;
if(!kaspecials_flag if(!kaspecials_flag
&& (flags & KAFNORMAL) == 0) /* remove special entries */ && (flags & KAFNORMAL) == 0) /* remove special entries */
return 0; return 0;
memset(&hdb, 0, sizeof(hdb)); memset(&hdb, 0, sizeof(hdb));
ret = krb5_425_conv_principal(pd->context, ent->name, ent->instance, ret = krb5_425_conv_principal(pd->context, ent->name, ent->instance,
v4_realm, &hdb.principal); v4_realm, &hdb.entry.principal);
if(ret) { if(ret) {
krb5_warn(pd->context, ret, krb5_warn(pd->context, ret,
"krb5_425_conv_principal (%s.%s@%s)", "krb5_425_conv_principal (%s.%s@%s)",
ent->name, ent->instance, v4_realm); ent->name, ent->instance, v4_realm);
return 0; return 0;
} }
hdb.kvno = ntohl(ent->kvno); hdb.entry.kvno = ntohl(ent->kvno);
hdb.keys.len = 3; hdb.entry.keys.len = 3;
hdb.keys.val = malloc(hdb.keys.len * sizeof(*hdb.keys.val)); hdb.entry.keys.val =
hdb.keys.val[0].mkvno = NULL; malloc(hdb.entry.keys.len * sizeof(*hdb.entry.keys.val));
hdb.keys.val[0].salt = calloc(1, sizeof(*hdb.keys.val[0].salt)); hdb.entry.keys.val[0].mkvno = NULL;
hdb.entry.keys.val[0].salt = calloc(1, sizeof(*hdb.entry.keys.val[0].salt));
if (ka_use_null_salt) { if (ka_use_null_salt) {
hdb.keys.val[0].salt->type = hdb_pw_salt; hdb.entry.keys.val[0].salt->type = hdb_pw_salt;
hdb.keys.val[0].salt->salt.data = NULL; hdb.entry.keys.val[0].salt->salt.data = NULL;
hdb.keys.val[0].salt->salt.length = 0; hdb.entry.keys.val[0].salt->salt.length = 0;
} else { } else {
hdb.keys.val[0].salt->type = hdb_afs3_salt; hdb.entry.keys.val[0].salt->type = hdb_afs3_salt;
hdb.keys.val[0].salt->salt.data = strdup(afs_cell); hdb.entry.keys.val[0].salt->salt.data = strdup(afs_cell);
hdb.keys.val[0].salt->salt.length = strlen(afs_cell); hdb.entry.keys.val[0].salt->salt.length = strlen(afs_cell);
} }
hdb.keys.val[0].key.keytype = ETYPE_DES_CBC_MD5; hdb.entry.keys.val[0].key.keytype = ETYPE_DES_CBC_MD5;
krb5_data_copy(&hdb.keys.val[0].key.keyvalue, ent->key, sizeof(ent->key)); krb5_data_copy(&hdb.entry.keys.val[0].key.keyvalue,
copy_Key(&hdb.keys.val[0], &hdb.keys.val[1]); ent->key,
hdb.keys.val[1].key.keytype = ETYPE_DES_CBC_MD4; sizeof(ent->key));
copy_Key(&hdb.keys.val[0], &hdb.keys.val[2]); copy_Key(&hdb.entry.keys.val[0], &hdb.entry.keys.val[1]);
hdb.keys.val[2].key.keytype = ETYPE_DES_CBC_CRC; hdb.entry.keys.val[1].key.keytype = ETYPE_DES_CBC_MD4;
copy_Key(&hdb.entry.keys.val[0], &hdb.entry.keys.val[2]);
hdb.entry.keys.val[2].key.keytype = ETYPE_DES_CBC_CRC;
ALLOC(hdb.max_life); ALLOC(hdb.entry.max_life);
*hdb.max_life = ntohl(ent->max_life); *hdb.entry.max_life = ntohl(ent->max_life);
if(ntohl(ent->valid_end) != NEVERDATE && ntohl(ent->valid_end) != 0xffffffff) { if(ntohl(ent->valid_end) != NEVERDATE && ntohl(ent->valid_end) != 0xffffffff) {
ALLOC(hdb.valid_end); ALLOC(hdb.entry.valid_end);
*hdb.valid_end = ntohl(ent->valid_end); *hdb.entry.valid_end = ntohl(ent->valid_end);
} }
if (ntohl(ent->pw_change) != NEVERDATE && if (ntohl(ent->pw_change) != NEVERDATE &&
ent->pw_expire != 255 && ent->pw_expire != 255 &&
ent->pw_expire != 0) { ent->pw_expire != 0) {
ALLOC(hdb.pw_end); ALLOC(hdb.entry.pw_end);
*hdb.pw_end = ntohl(ent->pw_change) *hdb.entry.pw_end = ntohl(ent->pw_change)
+ 24 * 60 * 60 * ent->pw_expire; + 24 * 60 * 60 * ent->pw_expire;
} }
ret = krb5_make_principal(pd->context, &hdb.created_by.principal, ret = krb5_make_principal(pd->context, &hdb.entry.created_by.principal,
v4_realm, v4_realm,
"kadmin", "kadmin",
"hprop", "hprop",
NULL); NULL);
hdb.created_by.time = time(NULL); hdb.entry.created_by.time = time(NULL);
if(ent->mod_ptr){ if(ent->mod_ptr){
struct ka_entry mod; struct ka_entry mod;
ALLOC(hdb.modified_by); ALLOC(hdb.entry.modified_by);
read_block(pd->context, fd, ntohl(ent->mod_ptr), &mod, sizeof(mod)); read_block(pd->context, fd, ntohl(ent->mod_ptr), &mod, sizeof(mod));
krb5_425_conv_principal(pd->context, mod.name, mod.instance, v4_realm, krb5_425_conv_principal(pd->context, mod.name, mod.instance, v4_realm,
&hdb.modified_by->principal); &hdb.entry.modified_by->principal);
hdb.modified_by->time = ntohl(ent->mod_time); hdb.entry.modified_by->time = ntohl(ent->mod_time);
memset(&mod, 0, sizeof(mod)); memset(&mod, 0, sizeof(mod));
} }
hdb.flags.forwardable = 1; hdb.entry.flags.forwardable = 1;
hdb.flags.renewable = 1; hdb.entry.flags.renewable = 1;
hdb.flags.proxiable = 1; hdb.entry.flags.proxiable = 1;
hdb.flags.postdate = 1; hdb.entry.flags.postdate = 1;
/* XXX - AFS 3.4a creates krbtgt.REALMOFCELL as NOTGS+NOSEAL */ /* XXX - AFS 3.4a creates krbtgt.REALMOFCELL as NOTGS+NOSEAL */
if (strcmp(ent->name, "krbtgt") == 0 && if (strcmp(ent->name, "krbtgt") == 0 &&
(flags & (KAFNOTGS|KAFNOSEAL)) == (KAFNOTGS|KAFNOSEAL)) (flags & (KAFNOTGS|KAFNOSEAL)) == (KAFNOTGS|KAFNOSEAL))
flags &= ~(KAFNOTGS|KAFNOSEAL); flags &= ~(KAFNOTGS|KAFNOSEAL);
hdb.flags.client = (flags & KAFNOTGS) == 0; hdb.entry.flags.client = (flags & KAFNOTGS) == 0;
hdb.flags.server = (flags & KAFNOSEAL) == 0; hdb.entry.flags.server = (flags & KAFNOSEAL) == 0;
ret = v5_prop(pd->context, NULL, &hdb, pd); ret = v5_prop(pd->context, NULL, &hdb, pd);
hdb_free_entry(pd->context, &hdb); hdb_free_entry(pd->context, &hdb);

2
kdc/hprop.h
View File

@@ -53,7 +53,7 @@ struct prop_data{
#define NEVERDATE ((1U << 31) - 1) #define NEVERDATE ((1U << 31) - 1)
#endif #endif
krb5_error_code v5_prop(krb5_context, HDB*, hdb_entry*, void*); krb5_error_code v5_prop(krb5_context, HDB*, hdb_entry_ex*, void*);
int mit_prop_dump(void*, const char*); int mit_prop_dump(void*, const char*);
struct v4_principal { struct v4_principal {

7
kdc/hpropd.c
View File

@@ -377,7 +377,7 @@ main(int argc, char **argv)
nprincs = 0; nprincs = 0;
while(1){ while(1){
krb5_data data; krb5_data data;
hdb_entry entry; hdb_entry_ex entry;
if(from_stdin) { if(from_stdin) {
ret = krb5_read_message(context, &fd, &data); ret = krb5_read_message(context, &fd, &data);
@@ -417,7 +417,8 @@ main(int argc, char **argv)
} }
break; break;
} }
ret = hdb_value2entry(context, &data, &entry); memset(&entry, 0, sizeof(entry));
ret = hdb_value2entry(context, &data, &entry.entry);
if(ret) if(ret)
krb5_err(context, 1, ret, "hdb_value2entry"); krb5_err(context, 1, ret, "hdb_value2entry");
if(print_dump) if(print_dump)
@@ -434,7 +435,7 @@ main(int argc, char **argv)
ret = db->hdb_store(context, db, 0, &entry); ret = db->hdb_store(context, db, 0, &entry);
if(ret == HDB_ERR_EXISTS) { if(ret == HDB_ERR_EXISTS) {
char *s; char *s;
ret = krb5_unparse_name(context, entry.principal, &s); ret = krb5_unparse_name(context, entry.entry.principal, &s);
if (ret) if (ret)
s = strdup("unparseable name"); s = strdup("unparseable name");
krb5_warnx(context, "Entry exists: %s", s); krb5_warnx(context, "Entry exists: %s", s);

2
kdc/kerberos4.c
View File

@@ -92,7 +92,7 @@ krb5_error_code
_kdc_db_fetch4(krb5_context context, _kdc_db_fetch4(krb5_context context,
krb5_kdc_configuration *config, krb5_kdc_configuration *config,
const char *name, const char *instance, const char *realm, const char *name, const char *instance, const char *realm,
hdb_entry **ent) hdb_entry_ex **ent)
{ {
krb5_principal p; krb5_principal p;
krb5_error_code ret; krb5_error_code ret;

8
kdc/misc.c
View File

@@ -41,16 +41,16 @@ krb5_error_code
_kdc_db_fetch(krb5_context context, _kdc_db_fetch(krb5_context context,
krb5_kdc_configuration *config, krb5_kdc_configuration *config,
krb5_principal principal, krb5_principal principal,
hdb_entry **h) hdb_entry_ex **h)
{ {
hdb_entry *ent; hdb_entry_ex *ent;
krb5_error_code ret = HDB_ERR_NOENTRY; krb5_error_code ret = HDB_ERR_NOENTRY;
int i; int i;
ent = malloc (sizeof (*ent)); ent = malloc (sizeof (*ent));
if (ent == NULL) if (ent == NULL)
return ENOMEM; return ENOMEM;
ent->principal = principal; ent->entry.principal = principal;
for(i = 0; i < config->num_db; i++) { for(i = 0; i < config->num_db; i++) {
ret = config->db[i]->hdb_open(context, config->db[i], O_RDONLY, 0); ret = config->db[i]->hdb_open(context, config->db[i], O_RDONLY, 0);
@@ -74,7 +74,7 @@ _kdc_db_fetch(krb5_context context,
} }
void void
_kdc_free_ent(krb5_context context, hdb_entry *ent) _kdc_free_ent(krb5_context context, hdb_entry_ex *ent)
{ {
hdb_free_entry (context, ent); hdb_free_entry (context, ent);
free (ent); free (ent);

57
kdc/mit_dump.c
View File

@@ -221,7 +221,7 @@ mit_prop_dump(void *arg, const char *file)
char line [2048]; char line [2048];
FILE *f; FILE *f;
int lineno = 0; int lineno = 0;
struct hdb_entry ent; struct hdb_entry_ex ent;
struct prop_data *pd = arg; struct prop_data *pd = arg;
@@ -274,28 +274,28 @@ mit_prop_dump(void *arg, const char *file)
num_key_data = getint(&p); /* number of key-data */ num_key_data = getint(&p); /* number of key-data */
extra_data_length = getint(&p); /* length of extra data */ extra_data_length = getint(&p); /* length of extra data */
q = nexttoken(&p); /* principal name */ q = nexttoken(&p); /* principal name */
krb5_parse_name(pd->context, q, &ent.principal); krb5_parse_name(pd->context, q, &ent.entry.principal);
attributes = getint(&p); /* attributes */ attributes = getint(&p); /* attributes */
attr_to_flags(attributes, &ent.flags); attr_to_flags(attributes, &ent.entry.flags);
tmp = getint(&p); /* max life */ tmp = getint(&p); /* max life */
if(tmp != 0) { if(tmp != 0) {
ALLOC(ent.max_life); ALLOC(ent.entry.max_life);
*ent.max_life = tmp; *ent.entry.max_life = tmp;
} }
tmp = getint(&p); /* max renewable life */ tmp = getint(&p); /* max renewable life */
if(tmp != 0) { if(tmp != 0) {
ALLOC(ent.max_renew); ALLOC(ent.entry.max_renew);
*ent.max_renew = tmp; *ent.entry.max_renew = tmp;
} }
tmp = getint(&p); /* expiration */ tmp = getint(&p); /* expiration */
if(tmp != 0 && tmp != 2145830400) { if(tmp != 0 && tmp != 2145830400) {
ALLOC(ent.valid_end); ALLOC(ent.entry.valid_end);
*ent.valid_end = tmp; *ent.entry.valid_end = tmp;
} }
tmp = getint(&p); /* pw expiration */ tmp = getint(&p); /* pw expiration */
if(tmp != 0) { if(tmp != 0) {
ALLOC(ent.pw_end); ALLOC(ent.entry.pw_end);
*ent.pw_end = tmp; *ent.entry.pw_end = tmp;
} }
q = nexttoken(&p); /* last auth */ q = nexttoken(&p); /* last auth */
q = nexttoken(&p); /* last failed auth */ q = nexttoken(&p); /* last failed auth */
@@ -318,48 +318,49 @@ mit_prop_dump(void *arg, const char *file)
val = buf[0] | (buf[1] << 8) | (buf[2] << 16) | (buf[3] << 24); val = buf[0] | (buf[1] << 8) | (buf[2] << 16) | (buf[3] << 24);
ret = krb5_parse_name(pd->context, (char *)buf + 4, &princ); ret = krb5_parse_name(pd->context, (char *)buf + 4, &princ);
free(buf); free(buf);
ALLOC(ent.modified_by); ALLOC(ent.entry.modified_by);
ent.modified_by->time = val; ent.entry.modified_by->time = val;
ent.modified_by->principal = princ; ent.entry.modified_by->principal = princ;
break; break;
default: default:
nexttoken(&p); nexttoken(&p);
break; break;
} }
} }
ALLOC_SEQ(&ent.keys, num_key_data); ALLOC_SEQ(&ent.entry.keys, num_key_data);
for(i = 0; i < num_key_data; i++) { for(i = 0; i < num_key_data; i++) {
int key_versions; int key_versions;
key_versions = getint(&p); /* key data version */ key_versions = getint(&p); /* key data version */
ent.kvno = getint(&p); /* XXX kvno */ ent.entry.kvno = getint(&p); /* XXX kvno */
ALLOC(ent.keys.val[i].mkvno); ALLOC(ent.entry.keys.val[i].mkvno);
*ent.keys.val[i].mkvno = 0; *ent.entry.keys.val[i].mkvno = 0;
/* key version 0 -- actual key */ /* key version 0 -- actual key */
ent.keys.val[i].key.keytype = getint(&p); /* key type */ ent.entry.keys.val[i].key.keytype = getint(&p); /* key type */
tmp = getint(&p); /* key length */ tmp = getint(&p); /* key length */
/* the first two bytes of the key is the key length -- /* the first two bytes of the key is the key length --
skip it */ skip it */
krb5_data_alloc(&ent.keys.val[i].key.keyvalue, tmp - 2); krb5_data_alloc(&ent.entry.keys.val[i].key.keyvalue, tmp - 2);
q = nexttoken(&p); /* key itself */ q = nexttoken(&p); /* key itself */
hex_to_octet_string(q + 4, &ent.keys.val[i].key.keyvalue); hex_to_octet_string(q + 4, &ent.entry.keys.val[i].key.keyvalue);
if(key_versions > 1) { if(key_versions > 1) {
/* key version 1 -- optional salt */ /* key version 1 -- optional salt */
ALLOC(ent.keys.val[i].salt); ALLOC(ent.entry.keys.val[i].salt);
ent.keys.val[i].salt->type = getint(&p); /* salt type */ ent.entry.keys.val[i].salt->type = getint(&p); /* salt type */
tmp = getint(&p); /* salt length */ tmp = getint(&p); /* salt length */
if(tmp > 0) { if(tmp > 0) {
krb5_data_alloc(&ent.keys.val[i].salt->salt, tmp - 2); krb5_data_alloc(&ent.entry.keys.val[i].salt->salt, tmp - 2);
q = nexttoken(&p); /* salt itself */ q = nexttoken(&p); /* salt itself */
hex_to_octet_string(q + 4, &ent.keys.val[i].salt->salt); hex_to_octet_string(q + 4,
&ent.entry.keys.val[i].salt->salt);
} else { } else {
ent.keys.val[i].salt->salt.length = 0; ent.entry.keys.val[i].salt->salt.length = 0;
ent.keys.val[i].salt->salt.data = NULL; ent.entry.keys.val[i].salt->salt.data = NULL;
tmp = getint(&p); /* -1, if no data. */ tmp = getint(&p); /* -1, if no data. */
} }
fix_salt(pd->context, &ent, i); fix_salt(pd->context, &ent.entry, i);
} }
} }
q = nexttoken(&p); /* extra data */ q = nexttoken(&p); /* extra data */

34
lib/hdb/common.c
View File

@@ -79,22 +79,22 @@ hdb_value2entry(krb5_context context, krb5_data *value, hdb_entry *ent)
} }
krb5_error_code krb5_error_code
_hdb_fetch(krb5_context context, HDB *db, unsigned flags, hdb_entry *entry) _hdb_fetch(krb5_context context, HDB *db, unsigned flags, hdb_entry_ex *entry)
{ {
krb5_data key, value; krb5_data key, value;
int code; int code;
hdb_principal2key(context, entry->principal, &key); hdb_principal2key(context, entry->entry.principal, &key);
code = db->hdb__get(context, db, key, &value); code = db->hdb__get(context, db, key, &value);
krb5_data_free(&key); krb5_data_free(&key);
if(code) if(code)
return code; return code;
code = hdb_value2entry(context, &value, entry); code = hdb_value2entry(context, &value, &entry->entry);
krb5_data_free(&value); krb5_data_free(&value);
if (code) if (code)
return code; return code;
if (db->hdb_master_key_set && (flags & HDB_F_DECRYPT)) { if (db->hdb_master_key_set && (flags & HDB_F_DECRYPT)) {
code = hdb_unseal_keys (context, db, entry); code = hdb_unseal_keys (context, db, &entry->entry);
if (code) if (code)
hdb_free_entry(context, entry); hdb_free_entry(context, entry);
} }
@@ -102,31 +102,31 @@ _hdb_fetch(krb5_context context, HDB *db, unsigned flags, hdb_entry *entry)
} }
krb5_error_code krb5_error_code
_hdb_store(krb5_context context, HDB *db, unsigned flags, hdb_entry *entry) _hdb_store(krb5_context context, HDB *db, unsigned flags, hdb_entry_ex *entry)
{ {
krb5_data key, value; krb5_data key, value;
int code; int code;
if(entry->generation == NULL) { if(entry->entry.generation == NULL) {
struct timeval t; struct timeval t;
entry->generation = malloc(sizeof(*entry->generation)); entry->entry.generation = malloc(sizeof(*entry->entry.generation));
if(entry->generation == NULL) { if(entry->entry.generation == NULL) {
krb5_set_error_string(context, "malloc: out of memory"); krb5_set_error_string(context, "malloc: out of memory");
return ENOMEM; return ENOMEM;
} }
gettimeofday(&t, NULL); gettimeofday(&t, NULL);
entry->generation->time = t.tv_sec; entry->entry.generation->time = t.tv_sec;
entry->generation->usec = t.tv_usec; entry->entry.generation->usec = t.tv_usec;
entry->generation->gen = 0; entry->entry.generation->gen = 0;
} else } else
entry->generation->gen++; entry->entry.generation->gen++;
hdb_principal2key(context, entry->principal, &key); hdb_principal2key(context, entry->entry.principal, &key);
code = hdb_seal_keys(context, db, entry); code = hdb_seal_keys(context, db, &entry->entry);
if (code) { if (code) {
krb5_data_free(&key); krb5_data_free(&key);
return code; return code;
} }
hdb_entry2value(context, entry, &value); hdb_entry2value(context, &entry->entry, &value);
code = db->hdb__put(context, db, flags & HDB_F_REPLACE, key, value); code = db->hdb__put(context, db, flags & HDB_F_REPLACE, key, value);
krb5_data_free(&value); krb5_data_free(&value);
krb5_data_free(&key); krb5_data_free(&key);
@@ -134,12 +134,12 @@ _hdb_store(krb5_context context, HDB *db, unsigned flags, hdb_entry *entry)
} }
krb5_error_code krb5_error_code
_hdb_remove(krb5_context context, HDB *db, hdb_entry *entry) _hdb_remove(krb5_context context, HDB *db, hdb_entry_ex *entry)
{ {
krb5_data key; krb5_data key;
int code; int code;
hdb_principal2key(context, entry->principal, &key); hdb_principal2key(context, entry->entry.principal, &key);
code = db->hdb__del(context, db, key); code = db->hdb__del(context, db, key);
krb5_data_free(&key); krb5_data_free(&key);
return code; return code;

18
lib/hdb/db.c
View File

@@ -85,7 +85,7 @@ DB_unlock(krb5_context context, HDB *db)
static krb5_error_code static krb5_error_code
DB_seq(krb5_context context, HDB *db, DB_seq(krb5_context context, HDB *db,
unsigned flags, hdb_entry *entry, int flag) unsigned flags, hdb_entry_ex *entry, int flag)
{ {
DB *d = (DB*)db->hdb_db; DB *d = (DB*)db->hdb_db;
DBT key, value; DBT key, value;
@@ -106,21 +106,21 @@ DB_seq(krb5_context context, HDB *db,
key_data.length = key.size; key_data.length = key.size;
data.data = value.data; data.data = value.data;
data.length = value.size; data.length = value.size;
if (hdb_value2entry(context, &data, entry)) if (hdb_value2entry(context, &data, &entry->entry))
return DB_seq(context, db, flags, entry, R_NEXT); return DB_seq(context, db, flags, entry, R_NEXT);
if (db->hdb_master_key_set && (flags & HDB_F_DECRYPT)) { if (db->hdb_master_key_set && (flags & HDB_F_DECRYPT)) {
code = hdb_unseal_keys (context, db, entry); code = hdb_unseal_keys (context, db, &entry->entry);
if (code) if (code)
hdb_free_entry (context, entry); hdb_free_entry (context, entry);
} }
if (code == 0 && entry->principal == NULL) { if (code == 0 && entry->entry.principal == NULL) {
entry->principal = malloc(sizeof(*entry->principal)); entry->entry.principal = malloc(sizeof(*entry->entry.principal));
if (entry->principal == NULL) { if (entry->entry.principal == NULL) {
krb5_set_error_string(context, "malloc: out of memory"); krb5_set_error_string(context, "malloc: out of memory");
code = ENOMEM; code = ENOMEM;
hdb_free_entry (context, entry); hdb_free_entry (context, entry);
} else { } else {
hdb_key2principal(context, &key_data, entry->principal); hdb_key2principal(context, &key_data, entry->entry.principal);
} }
} }
return code; return code;
@@ -128,14 +128,14 @@ DB_seq(krb5_context context, HDB *db,
static krb5_error_code static krb5_error_code
DB_firstkey(krb5_context context, HDB *db, unsigned flags, hdb_entry *entry) DB_firstkey(krb5_context context, HDB *db, unsigned flags, hdb_entry_ex *entry)
{ {
return DB_seq(context, db, flags, entry, R_FIRST); return DB_seq(context, db, flags, entry, R_FIRST);
} }
static krb5_error_code static krb5_error_code
DB_nextkey(krb5_context context, HDB *db, unsigned flags, hdb_entry *entry) DB_nextkey(krb5_context context, HDB *db, unsigned flags, hdb_entry_ex *entry)
{ {
return DB_seq(context, db, flags, entry, R_NEXT); return DB_seq(context, db, flags, entry, R_NEXT);
} }

18
lib/hdb/db3.c
View File

@@ -91,7 +91,7 @@ DB_unlock(krb5_context context, HDB *db)
static krb5_error_code static krb5_error_code
DB_seq(krb5_context context, HDB *db, DB_seq(krb5_context context, HDB *db,
unsigned flags, hdb_entry *entry, int flag) unsigned flags, hdb_entry_ex *entry, int flag)
{ {
DBT key, value; DBT key, value;
DBC *dbcp = db->hdb_dbc; DBC *dbcp = db->hdb_dbc;
@@ -113,21 +113,21 @@ DB_seq(krb5_context context, HDB *db,
key_data.length = key.size; key_data.length = key.size;
data.data = value.data; data.data = value.data;
data.length = value.size; data.length = value.size;
if (hdb_value2entry(context, &data, entry)) if (hdb_value2entry(context, &data, &entry->entry))
return DB_seq(context, db, flags, entry, DB_NEXT); return DB_seq(context, db, flags, entry, DB_NEXT);
if (db->hdb_master_key_set && (flags & HDB_F_DECRYPT)) { if (db->hdb_master_key_set && (flags & HDB_F_DECRYPT)) {
code = hdb_unseal_keys (context, db, entry); code = hdb_unseal_keys (context, db, &entry->entry);
if (code) if (code)
hdb_free_entry (context, entry); hdb_free_entry (context, entry);
} }
if (entry->principal == NULL) { if (entry->entry.principal == NULL) {
entry->principal = malloc(sizeof(*entry->principal)); entry->entry.principal = malloc(sizeof(*entry->entry.principal));
if (entry->principal == NULL) { if (entry->entry.principal == NULL) {
hdb_free_entry (context, entry); hdb_free_entry (context, entry);
krb5_set_error_string(context, "malloc: out of memory"); krb5_set_error_string(context, "malloc: out of memory");
return ENOMEM; return ENOMEM;
} else { } else {
hdb_key2principal(context, &key_data, entry->principal); hdb_key2principal(context, &key_data, entry->entry.principal);
} }
} }
return 0; return 0;
@@ -135,14 +135,14 @@ DB_seq(krb5_context context, HDB *db,
static krb5_error_code static krb5_error_code
DB_firstkey(krb5_context context, HDB *db, unsigned flags, hdb_entry *entry) DB_firstkey(krb5_context context, HDB *db, unsigned flags, hdb_entry_ex *entry)
{ {
return DB_seq(context, db, flags, entry, DB_FIRST); return DB_seq(context, db, flags, entry, DB_FIRST);
} }
static krb5_error_code static krb5_error_code
DB_nextkey(krb5_context context, HDB *db, unsigned flags, hdb_entry *entry) DB_nextkey(krb5_context context, HDB *db, unsigned flags, hdb_entry_ex *entry)
{ {
return DB_seq(context, db, flags, entry, DB_NEXT); return DB_seq(context, db, flags, entry, DB_NEXT);
} }

13
lib/hdb/hdb.c
View File

@@ -133,16 +133,19 @@ hdb_unlock(int fd)
} }
void void
hdb_free_entry(krb5_context context, hdb_entry *ent) hdb_free_entry(krb5_context context, hdb_entry_ex *ent)
{ {
int i; int i;
for(i = 0; i < ent->keys.len; ++i) { if (ent->free_entry)
Key *k = &ent->keys.val[i]; (*ent->free_entry)(context, ent);
for(i = 0; i < ent->entry.keys.len; ++i) {
Key *k = &ent->entry.keys.val[i];
memset (k->key.keyvalue.data, 0, k->key.keyvalue.length); memset (k->key.keyvalue.data, 0, k->key.keyvalue.length);
} }
free_hdb_entry(ent); free_hdb_entry(&ent->entry);
} }
krb5_error_code krb5_error_code
@@ -153,7 +156,7 @@ hdb_foreach(krb5_context context,
void *data) void *data)
{ {
krb5_error_code ret; krb5_error_code ret;
hdb_entry entry; hdb_entry_ex entry;
ret = db->hdb_firstkey(context, db, flags, &entry); ret = db->hdb_firstkey(context, db, flags, &entry);
while(ret == 0){ while(ret == 0){
ret = (*func)(context, db, &entry, data); ret = (*func)(context, db, &entry, data);

24
lib/hdb/hdb.h
View File

@@ -52,6 +52,13 @@ enum hdb_lockop{ HDB_RLOCK, HDB_WLOCK };
typedef struct hdb_master_key_data *hdb_master_key; typedef struct hdb_master_key_data *hdb_master_key;
typedef struct hdb_entry_ex {
void *ctx;
hdb_entry entry;
void (*free_entry)(krb5_context, struct hdb_entry_ex *);
} hdb_entry_ex;
typedef struct HDB{ typedef struct HDB{
void *hdb_db; void *hdb_db;
void *hdb_dbc; void *hdb_dbc;
@@ -62,13 +69,16 @@ typedef struct HDB{
krb5_error_code (*hdb_open)(krb5_context, struct HDB*, int, mode_t); krb5_error_code (*hdb_open)(krb5_context, struct HDB*, int, mode_t);
krb5_error_code (*hdb_close)(krb5_context, struct HDB*); krb5_error_code (*hdb_close)(krb5_context, struct HDB*);
krb5_error_code (*hdb_fetch)(krb5_context,struct HDB*,unsigned,hdb_entry*); void (*hdb_free)(krb5_context,struct HDB*,hdb_entry_ex*);
krb5_error_code (*hdb_store)(krb5_context,struct HDB*,unsigned,hdb_entry*); krb5_error_code (*hdb_fetch)(krb5_context,struct HDB*,
krb5_error_code (*hdb_remove)(krb5_context, struct HDB*, hdb_entry*); unsigned,hdb_entry_ex*);
krb5_error_code (*hdb_store)(krb5_context,struct HDB*,
unsigned,hdb_entry_ex*);
krb5_error_code (*hdb_remove)(krb5_context, struct HDB*, hdb_entry_ex*);
krb5_error_code (*hdb_firstkey)(krb5_context, struct HDB*, krb5_error_code (*hdb_firstkey)(krb5_context, struct HDB*,
unsigned, hdb_entry*); unsigned, hdb_entry_ex*);
krb5_error_code (*hdb_nextkey)(krb5_context, struct HDB*, krb5_error_code (*hdb_nextkey)(krb5_context, struct HDB*,
unsigned, hdb_entry*); unsigned, hdb_entry_ex*);
krb5_error_code (*hdb_lock)(krb5_context, struct HDB*, int operation); krb5_error_code (*hdb_lock)(krb5_context, struct HDB*, int operation);
krb5_error_code (*hdb_unlock)(krb5_context, struct HDB*); krb5_error_code (*hdb_unlock)(krb5_context, struct HDB*);
krb5_error_code (*hdb_rename)(krb5_context, struct HDB*, const char*); krb5_error_code (*hdb_rename)(krb5_context, struct HDB*, const char*);
@@ -79,7 +89,7 @@ typedef struct HDB{
krb5_error_code (*hdb_destroy)(krb5_context, struct HDB*); krb5_error_code (*hdb_destroy)(krb5_context, struct HDB*);
}HDB; }HDB;
#define HDB_INTERFACE_VERSION 2 #define HDB_INTERFACE_VERSION 3
struct hdb_so_method { struct hdb_so_method {
int version; int version;
@@ -92,7 +102,7 @@ struct hdb_so_method {
#define HDB_DB_FORMAT_ENTRY "hdb/db-format" #define HDB_DB_FORMAT_ENTRY "hdb/db-format"
typedef krb5_error_code (*hdb_foreach_func_t)(krb5_context, HDB*, typedef krb5_error_code (*hdb_foreach_func_t)(krb5_context, HDB*,
hdb_entry*, void*); hdb_entry_ex*, void*);
extern krb5_kt_ops hdb_kt_ops; extern krb5_kt_ops hdb_kt_ops;
#include <hdb-protos.h> #include <hdb-protos.h>

18
lib/hdb/keytab.c
View File

@@ -193,7 +193,7 @@ hdb_get_entry(krb5_context context,
krb5_enctype enctype, krb5_enctype enctype,
krb5_keytab_entry *entry) krb5_keytab_entry *entry)
{ {
hdb_entry ent; hdb_entry_ex ent;
krb5_error_code ret; krb5_error_code ret;
struct hdb_data *d = id->data; struct hdb_data *d = id->data;
int i; int i;
@@ -218,7 +218,7 @@ hdb_get_entry(krb5_context context,
(*db->hdb_destroy)(context, db); (*db->hdb_destroy)(context, db);
return ret; return ret;
} }
ent.principal = rk_UNCONST(principal); ent.entry.principal = rk_UNCONST(principal);
ret = (*db->hdb_fetch)(context, db, HDB_F_DECRYPT, &ent); ret = (*db->hdb_fetch)(context, db, HDB_F_DECRYPT, &ent);
(*db->hdb_close)(context, db); (*db->hdb_close)(context, db);
(*db->hdb_destroy)(context, db); (*db->hdb_destroy)(context, db);
@@ -227,20 +227,20 @@ hdb_get_entry(krb5_context context,
return KRB5_KT_NOTFOUND; return KRB5_KT_NOTFOUND;
else if(ret) else if(ret)
return ret; return ret;
if(kvno && ent.kvno != kvno) { if(kvno && ent.entry.kvno != kvno) {
hdb_free_entry(context, &ent); hdb_free_entry(context, &ent);
return KRB5_KT_NOTFOUND; return KRB5_KT_NOTFOUND;
} }
if(enctype == 0) if(enctype == 0)
if(ent.keys.len > 0) if(ent.entry.keys.len > 0)
enctype = ent.keys.val[0].key.keytype; enctype = ent.entry.keys.val[0].key.keytype;
ret = KRB5_KT_NOTFOUND; ret = KRB5_KT_NOTFOUND;
for(i = 0; i < ent.keys.len; i++) { for(i = 0; i < ent.entry.keys.len; i++) {
if(ent.keys.val[i].key.keytype == enctype) { if(ent.entry.keys.val[i].key.keytype == enctype) {
krb5_copy_principal(context, principal, &entry->principal); krb5_copy_principal(context, principal, &entry->principal);
entry->vno = ent.kvno; entry->vno = ent.entry.kvno;
krb5_copy_keyblock_contents(context, krb5_copy_keyblock_contents(context,
&ent.keys.val[i].key, &ent.entry.keys.val[i].key,
&entry->keyblock); &entry->keyblock);
ret = 0; ret = 0;
break; break;

18
lib/hdb/ndbm.c
View File

@@ -77,7 +77,7 @@ NDBM_unlock(krb5_context context, HDB *db)
static krb5_error_code static krb5_error_code
NDBM_seq(krb5_context context, HDB *db, NDBM_seq(krb5_context context, HDB *db,
unsigned flags, hdb_entry *entry, int first) unsigned flags, hdb_entry_ex *entry, int first)
{ {
struct ndbm_db *d = (struct ndbm_db *)db->hdb_db; struct ndbm_db *d = (struct ndbm_db *)db->hdb_db;
@@ -99,21 +99,21 @@ NDBM_seq(krb5_context context, HDB *db,
db->hdb_unlock(context, db); db->hdb_unlock(context, db);
data.data = value.dptr; data.data = value.dptr;
data.length = value.dsize; data.length = value.dsize;
if(hdb_value2entry(context, &data, entry)) if(hdb_value2entry(context, &data, &entry->entry))
return NDBM_seq(context, db, flags, entry, 0); return NDBM_seq(context, db, flags, entry, 0);
if (db->hdb_master_key_set && (flags & HDB_F_DECRYPT)) { if (db->hdb_master_key_set && (flags & HDB_F_DECRYPT)) {
ret = hdb_unseal_keys (context, db, entry); ret = hdb_unseal_keys (context, db, &entry->entry);
if (ret) if (ret)
hdb_free_entry (context, entry); hdb_free_entry (context, entry);
} }
if (entry->principal == NULL) { if (ret == 0 && entry->entry.principal == NULL) {
entry->principal = malloc (sizeof(*entry->principal)); entry->entry.principal = malloc (sizeof(*entry->entry.principal));
if (entry->principal == NULL) { if (entry->entry.principal == NULL) {
ret = ENOMEM; ret = ENOMEM;
hdb_free_entry (context, entry); hdb_free_entry (context, entry);
krb5_set_error_string(context, "malloc: out of memory"); krb5_set_error_string(context, "malloc: out of memory");
} else { } else {
hdb_key2principal (context, &key_data, entry->principal); hdb_key2principal (context, &key_data, entry->entry.principal);
} }
} }
return ret; return ret;
@@ -121,14 +121,14 @@ NDBM_seq(krb5_context context, HDB *db,
static krb5_error_code static krb5_error_code
NDBM_firstkey(krb5_context context, HDB *db, unsigned flags, hdb_entry *entry) NDBM_firstkey(krb5_context context, HDB *db,unsigned flags,hdb_entry_ex *entry)
{ {
return NDBM_seq(context, db, flags, entry, 1); return NDBM_seq(context, db, flags, entry, 1);
} }
static krb5_error_code static krb5_error_code
NDBM_nextkey(krb5_context context, HDB *db, unsigned flags, hdb_entry *entry) NDBM_nextkey(krb5_context context, HDB *db, unsigned flags,hdb_entry_ex *entry)
{ {
return NDBM_seq(context, db, flags, entry, 0); return NDBM_seq(context, db, flags, entry, 0);
} }

4
lib/hdb/print.c
View File

@@ -268,7 +268,7 @@ hdb_entry2string (krb5_context context, hdb_entry *ent, char **str)
/* print a hdb_entry to (FILE*)data; suitable for hdb_foreach */ /* print a hdb_entry to (FILE*)data; suitable for hdb_foreach */
krb5_error_code krb5_error_code
hdb_print_entry(krb5_context context, HDB *db, hdb_entry *entry, void *data) hdb_print_entry(krb5_context context, HDB *db, hdb_entry_ex *entry, void *data)
{ {
krb5_error_code ret; krb5_error_code ret;
krb5_storage *sp; krb5_storage *sp;
@@ -282,7 +282,7 @@ hdb_print_entry(krb5_context context, HDB *db, hdb_entry *entry, void *data)
return ENOMEM; return ENOMEM;
} }
ret = entry2string_int(context, sp, entry); ret = entry2string_int(context, sp, &entry->entry);
if(ret) { if(ret) {
krb5_storage_free(sp); krb5_storage_free(sp);
return ret; return ret;

9
lib/kadm5/ChangeLog
View File

@@ -1,4 +1,11 @@
2005-09-08 Love H<>rnquist <20>strand <lha@it.su.se> 2005-11-30 Love H<>rnquist <20>strand <lha@it.su.se>
* context_s.c (set_field): try another way to calculate the path
to the database/logfile/signal-socket
* log.c (kadm5_log_init): set error string on failures
2005-09-08 Love H<>rnquist <20>strand <lha@it.su.se>
* Constify password. * Constify password.

46
lib/kadm5/chpass_s.c
View File

@@ -42,13 +42,13 @@ change(void *server_handle,
int cond) int cond)
{ {
kadm5_server_context *context = server_handle; kadm5_server_context *context = server_handle;
hdb_entry ent; hdb_entry_ex ent;
kadm5_ret_t ret; kadm5_ret_t ret;
Key *keys; Key *keys;
size_t num_keys; size_t num_keys;
int cmp = 1; int cmp = 1;
ent.principal = princ; ent.entry.principal = princ;
ret = context->db->hdb_open(context->context, context->db, O_RDWR, 0); ret = context->db->hdb_open(context->context, context->db, O_RDWR, 0);
if(ret) if(ret)
return ret; return ret;
@@ -57,20 +57,20 @@ change(void *server_handle,
if(ret == HDB_ERR_NOENTRY) if(ret == HDB_ERR_NOENTRY)
goto out; goto out;
num_keys = ent.keys.len; num_keys = ent.entry.keys.len;
keys = ent.keys.val; keys = ent.entry.keys.val;
ent.keys.len = 0; ent.entry.keys.len = 0;
ent.keys.val = NULL; ent.entry.keys.val = NULL;
ret = _kadm5_set_keys(context, &ent, password); ret = _kadm5_set_keys(context, &ent.entry, password);
if(ret) { if(ret) {
_kadm5_free_keys (context->context, num_keys, keys); _kadm5_free_keys (context->context, num_keys, keys);
goto out2; goto out2;
} }
ent.kvno++; ent.entry.kvno++;
if (cond) if (cond)
cmp = _kadm5_cmp_keys (ent.keys.val, ent.keys.len, cmp = _kadm5_cmp_keys (ent.entry.keys.val, ent.entry.keys.len,
keys, num_keys); keys, num_keys);
_kadm5_free_keys (context->context, num_keys, keys); _kadm5_free_keys (context->context, num_keys, keys);
@@ -80,20 +80,20 @@ change(void *server_handle,
goto out2; goto out2;
} }
ret = _kadm5_set_modifier(context, &ent); ret = _kadm5_set_modifier(context, &ent.entry);
if(ret) if(ret)
goto out2; goto out2;
ret = _kadm5_bump_pw_expire(context, &ent); ret = _kadm5_bump_pw_expire(context, &ent.entry);
if (ret) if (ret)
goto out2; goto out2;
ret = hdb_seal_keys(context->context, context->db, &ent); ret = hdb_seal_keys(context->context, context->db, &ent.entry);
if (ret) if (ret)
goto out2; goto out2;
kadm5_log_modify (context, kadm5_log_modify (context,
&ent, &ent.entry,
KADM5_PRINCIPAL | KADM5_MOD_NAME | KADM5_MOD_TIME | KADM5_PRINCIPAL | KADM5_MOD_NAME | KADM5_MOD_TIME |
KADM5_KEY_DATA | KADM5_KVNO | KADM5_PW_EXPIRATION | KADM5_KEY_DATA | KADM5_KVNO | KADM5_PW_EXPIRATION |
KADM5_TL_DATA); KADM5_TL_DATA);
@@ -116,7 +116,7 @@ out:
kadm5_ret_t kadm5_ret_t
kadm5_s_chpass_principal_cond(void *server_handle, kadm5_s_chpass_principal_cond(void *server_handle,
krb5_principal princ, krb5_principal princ,
char *password) const char *password)
{ {
return change (server_handle, princ, password, 1); return change (server_handle, princ, password, 1);
} }
@@ -128,7 +128,7 @@ kadm5_s_chpass_principal_cond(void *server_handle,
kadm5_ret_t kadm5_ret_t
kadm5_s_chpass_principal(void *server_handle, kadm5_s_chpass_principal(void *server_handle,
krb5_principal princ, krb5_principal princ,
char *password) const char *password)
{ {
return change (server_handle, princ, password, 0); return change (server_handle, princ, password, 0);
} }
@@ -144,32 +144,32 @@ kadm5_s_chpass_principal_with_key(void *server_handle,
krb5_key_data *key_data) krb5_key_data *key_data)
{ {
kadm5_server_context *context = server_handle; kadm5_server_context *context = server_handle;
hdb_entry ent; hdb_entry_ex ent;
kadm5_ret_t ret; kadm5_ret_t ret;
ent.principal = princ; ent.entry.principal = princ;
ret = context->db->hdb_open(context->context, context->db, O_RDWR, 0); ret = context->db->hdb_open(context->context, context->db, O_RDWR, 0);
if(ret) if(ret)
return ret; return ret;
ret = context->db->hdb_fetch(context->context, context->db, 0, &ent); ret = context->db->hdb_fetch(context->context, context->db, 0, &ent);
if(ret == HDB_ERR_NOENTRY) if(ret == HDB_ERR_NOENTRY)
goto out; goto out;
ret = _kadm5_set_keys2(context, &ent, n_key_data, key_data); ret = _kadm5_set_keys2(context, &ent.entry, n_key_data, key_data);
if(ret) if(ret)
goto out2; goto out2;
ent.kvno++; ent.entry.kvno++;
ret = _kadm5_set_modifier(context, &ent); ret = _kadm5_set_modifier(context, &ent.entry);
if(ret) if(ret)
goto out2; goto out2;
ret = _kadm5_bump_pw_expire(context, &ent); ret = _kadm5_bump_pw_expire(context, &ent.entry);
if (ret) if (ret)
goto out2; goto out2;
ret = hdb_seal_keys(context->context, context->db, &ent); ret = hdb_seal_keys(context->context, context->db, &ent.entry);
if (ret) if (ret)
goto out2; goto out2;
kadm5_log_modify (context, kadm5_log_modify (context,
&ent, &ent.entry,
KADM5_PRINCIPAL | KADM5_MOD_NAME | KADM5_MOD_TIME | KADM5_PRINCIPAL | KADM5_MOD_NAME | KADM5_MOD_TIME |
KADM5_KEY_DATA | KADM5_KVNO | KADM5_PW_EXPIRATION | KADM5_KEY_DATA | KADM5_KVNO | KADM5_PW_EXPIRATION |
KADM5_TL_DATA); KADM5_TL_DATA);

30
lib/kadm5/create_s.c
View File

@@ -57,7 +57,7 @@ static kadm5_ret_t
create_principal(kadm5_server_context *context, create_principal(kadm5_server_context *context,
kadm5_principal_ent_t princ, kadm5_principal_ent_t princ,
u_int32_t mask, u_int32_t mask,
hdb_entry *ent, hdb_entry_ex *ent,
u_int32_t required_mask, u_int32_t required_mask,
u_int32_t forbidden_mask) u_int32_t forbidden_mask)
{ {
@@ -74,7 +74,7 @@ create_principal(kadm5_server_context *context,
return KADM5_UNK_POLICY; return KADM5_UNK_POLICY;
memset(ent, 0, sizeof(*ent)); memset(ent, 0, sizeof(*ent));
ret = krb5_copy_principal(context->context, princ->principal, ret = krb5_copy_principal(context->context, princ->principal,
&ent->principal); &ent->entry.principal);
if(ret) if(ret)
return ret; return ret;
@@ -94,9 +94,9 @@ create_principal(kadm5_server_context *context,
if(defent) if(defent)
kadm5_free_principal_ent(context, defent); kadm5_free_principal_ent(context, defent);
ent->created_by.time = time(NULL); ent->entry.created_by.time = time(NULL);
ret = krb5_copy_principal(context->context, context->caller, ret = krb5_copy_principal(context->context, context->caller,
&ent->created_by.principal); &ent->entry.created_by.principal);
return ret; return ret;
} }
@@ -107,7 +107,7 @@ kadm5_s_create_principal_with_key(void *server_handle,
u_int32_t mask) u_int32_t mask)
{ {
kadm5_ret_t ret; kadm5_ret_t ret;
hdb_entry ent; hdb_entry_ex ent;
kadm5_server_context *context = server_handle; kadm5_server_context *context = server_handle;
ret = create_principal(context, princ, mask, &ent, ret = create_principal(context, princ, mask, &ent,
@@ -120,13 +120,13 @@ kadm5_s_create_principal_with_key(void *server_handle,
if(ret) if(ret)
goto out; goto out;
ent.kvno = 1; ent.entry.kvno = 1;
ret = hdb_seal_keys(context->context, context->db, &ent); ret = hdb_seal_keys(context->context, context->db, &ent.entry);
if (ret) if (ret)
goto out; goto out;
kadm5_log_create (context, &ent); kadm5_log_create (context, &ent.entry);
ret = context->db->hdb_open(context->context, context->db, O_RDWR, 0); ret = context->db->hdb_open(context->context, context->db, O_RDWR, 0);
if(ret) if(ret)
@@ -143,10 +143,10 @@ kadm5_ret_t
kadm5_s_create_principal(void *server_handle, kadm5_s_create_principal(void *server_handle,
kadm5_principal_ent_t princ, kadm5_principal_ent_t princ,
u_int32_t mask, u_int32_t mask,
char *password) const char *password)
{ {
kadm5_ret_t ret; kadm5_ret_t ret;
hdb_entry ent; hdb_entry_ex ent;
kadm5_server_context *context = server_handle; kadm5_server_context *context = server_handle;
ret = create_principal(context, princ, mask, &ent, ret = create_principal(context, princ, mask, &ent,
@@ -159,18 +159,18 @@ kadm5_s_create_principal(void *server_handle,
if(ret) if(ret)
goto out; goto out;
ent.keys.len = 0; ent.entry.keys.len = 0;
ent.keys.val = NULL; ent.entry.keys.val = NULL;
ret = _kadm5_set_keys(context, &ent, password); ret = _kadm5_set_keys(context, &ent.entry, password);
if (ret) if (ret)
goto out; goto out;
ret = hdb_seal_keys(context->context, context->db, &ent); ret = hdb_seal_keys(context->context, context->db, &ent.entry);
if (ret) if (ret)
goto out; goto out;
kadm5_log_create (context, &ent); kadm5_log_create (context, &ent.entry);
ret = context->db->hdb_open(context->context, context->db, O_RDWR, 0); ret = context->db->hdb_open(context->context, context->db, O_RDWR, 0);
if(ret) if(ret)

8
lib/kadm5/delete_s.c
View File

@@ -40,9 +40,9 @@ kadm5_s_delete_principal(void *server_handle, krb5_principal princ)
{ {
kadm5_server_context *context = server_handle; kadm5_server_context *context = server_handle;
kadm5_ret_t ret; kadm5_ret_t ret;
hdb_entry ent; hdb_entry_ex ent;
ent.principal = princ; ent.entry.principal = princ;
ret = context->db->hdb_open(context->context, context->db, O_RDWR, 0); ret = context->db->hdb_open(context->context, context->db, O_RDWR, 0);
if(ret) { if(ret) {
krb5_warn(context->context, ret, "opening database"); krb5_warn(context->context, ret, "opening database");
@@ -52,12 +52,12 @@ kadm5_s_delete_principal(void *server_handle, krb5_principal princ)
HDB_F_DECRYPT, &ent); HDB_F_DECRYPT, &ent);
if(ret == HDB_ERR_NOENTRY) if(ret == HDB_ERR_NOENTRY)
goto out2; goto out2;
if(ent.flags.immutable) { if(ent.entry.flags.immutable) {
ret = KADM5_PROTECT_PRINCIPAL; ret = KADM5_PROTECT_PRINCIPAL;
goto out; goto out;
} }
ret = hdb_seal_keys(context->context, context->db, &ent); ret = hdb_seal_keys(context->context, context->db, &ent.entry);
if (ret) if (ret)
goto out; goto out;

57
lib/kadm5/ent_setup.c
View File

@@ -63,7 +63,7 @@ attr_to_flags(unsigned attr, HDBFlags *flags)
static kadm5_ret_t static kadm5_ret_t
perform_tl_data(krb5_context context, perform_tl_data(krb5_context context,
HDB *db, HDB *db,
hdb_entry *ent, hdb_entry_ex *ent,
const krb5_tl_data *tl_data) const krb5_tl_data *tl_data)
{ {
HDB_extension ext; HDB_extension ext;
@@ -75,7 +75,7 @@ perform_tl_data(krb5_context context,
if (pw[tl_data->tl_data_length] != '\0') if (pw[tl_data->tl_data_length] != '\0')
return KADM5_BAD_TL_TYPE; return KADM5_BAD_TL_TYPE;
ret = hdb_entry_set_password(context, db, ent, pw); ret = hdb_entry_set_password(context, db, &ent->entry, pw);
} else if (tl_data->tl_data_type == KRB5_TL_LAST_PWD_CHANGE) { } else if (tl_data->tl_data_type == KRB5_TL_LAST_PWD_CHANGE) {
unsigned char *s; unsigned char *s;
@@ -88,7 +88,7 @@ perform_tl_data(krb5_context context,
t = s[0] | (s[1] << 8) | (s[2] << 16) | (s[3] << 24); t = s[0] | (s[1] << 8) | (s[2] << 16) | (s[3] << 24);
ret = hdb_entry_set_pw_change_time(context, ent, t); ret = hdb_entry_set_pw_change_time(context, &ent->entry, t);
} else if (tl_data->tl_data_type == KRB5_TL_EXTENSION) { } else if (tl_data->tl_data_type == KRB5_TL_EXTENSION) {
ret = decode_HDB_extension(tl_data->tl_data_contents, ret = decode_HDB_extension(tl_data->tl_data_contents,
@@ -98,7 +98,7 @@ perform_tl_data(krb5_context context,
if (ret) if (ret)
return KADM5_BAD_TL_TYPE; return KADM5_BAD_TL_TYPE;
ret = hdb_replace_extension(context, ent, &ext); ret = hdb_replace_extension(context, &ent->entry, &ext);
} else { } else {
return KADM5_BAD_TL_TYPE; return KADM5_BAD_TL_TYPE;
@@ -115,7 +115,7 @@ perform_tl_data(krb5_context context,
kadm5_ret_t kadm5_ret_t
_kadm5_setup_entry(kadm5_server_context *context, _kadm5_setup_entry(kadm5_server_context *context,
hdb_entry *ent, hdb_entry_ex *ent,
u_int32_t mask, u_int32_t mask,
kadm5_principal_ent_t princ, kadm5_principal_ent_t princ,
u_int32_t princ_mask, u_int32_t princ_mask,
@@ -125,64 +125,65 @@ _kadm5_setup_entry(kadm5_server_context *context,
if(mask & KADM5_PRINC_EXPIRE_TIME if(mask & KADM5_PRINC_EXPIRE_TIME
&& princ_mask & KADM5_PRINC_EXPIRE_TIME) { && princ_mask & KADM5_PRINC_EXPIRE_TIME) {
if (princ->princ_expire_time) if (princ->princ_expire_time)
set_value(ent->valid_end, princ->princ_expire_time); set_value(ent->entry.valid_end, princ->princ_expire_time);
else else
set_null(ent->valid_end); set_null(ent->entry.valid_end);
} }
if(mask & KADM5_PW_EXPIRATION if(mask & KADM5_PW_EXPIRATION
&& princ_mask & KADM5_PW_EXPIRATION) { && princ_mask & KADM5_PW_EXPIRATION) {
if (princ->pw_expiration) if (princ->pw_expiration)
set_value(ent->pw_end, princ->pw_expiration); set_value(ent->entry.pw_end, princ->pw_expiration);
else else
set_null(ent->pw_end); set_null(ent->entry.pw_end);
} }
if(mask & KADM5_ATTRIBUTES) { if(mask & KADM5_ATTRIBUTES) {
if (princ_mask & KADM5_ATTRIBUTES) { if (princ_mask & KADM5_ATTRIBUTES) {
attr_to_flags(princ->attributes, &ent->flags); attr_to_flags(princ->attributes, &ent->entry.flags);
} else if(def_mask & KADM5_ATTRIBUTES) { } else if(def_mask & KADM5_ATTRIBUTES) {
attr_to_flags(def->attributes, &ent->flags); attr_to_flags(def->attributes, &ent->entry.flags);
ent->flags.invalid = 0; ent->entry.flags.invalid = 0;
} else { } else {
ent->flags.client = 1; ent->entry.flags.client = 1;
ent->flags.server = 1; ent->entry.flags.server = 1;
ent->flags.forwardable = 1; ent->entry.flags.forwardable = 1;
ent->flags.proxiable = 1; ent->entry.flags.proxiable = 1;
ent->flags.renewable = 1; ent->entry.flags.renewable = 1;
ent->flags.postdate = 1; ent->entry.flags.postdate = 1;
} }
} }
if(mask & KADM5_MAX_LIFE) { if(mask & KADM5_MAX_LIFE) {
if(princ_mask & KADM5_MAX_LIFE) { if(princ_mask & KADM5_MAX_LIFE) {
if(princ->max_life) if(princ->max_life)
set_value(ent->max_life, princ->max_life); set_value(ent->entry.max_life, princ->max_life);
else else
set_null(ent->max_life); set_null(ent->entry.max_life);
} else if(def_mask & KADM5_MAX_LIFE) { } else if(def_mask & KADM5_MAX_LIFE) {
if(def->max_life) if(def->max_life)
set_value(ent->max_life, def->max_life); set_value(ent->entry.max_life, def->max_life);
else else
set_null(ent->max_life); set_null(ent->entry.max_life);
} }
} }
if(mask & KADM5_KVNO if(mask & KADM5_KVNO
&& princ_mask & KADM5_KVNO) && princ_mask & KADM5_KVNO)
ent->kvno = princ->kvno; ent->entry.kvno = princ->kvno;
if(mask & KADM5_MAX_RLIFE) { if(mask & KADM5_MAX_RLIFE) {
if(princ_mask & KADM5_MAX_RLIFE) { if(princ_mask & KADM5_MAX_RLIFE) {
if(princ->max_renewable_life) if(princ->max_renewable_life)
set_value(ent->max_renew, princ->max_renewable_life); set_value(ent->entry.max_renew, princ->max_renewable_life);
else else
set_null(ent->max_renew); set_null(ent->entry.max_renew);
} else if(def_mask & KADM5_MAX_RLIFE) { } else if(def_mask & KADM5_MAX_RLIFE) {
if(def->max_renewable_life) if(def->max_renewable_life)
set_value(ent->max_renew, def->max_renewable_life); set_value(ent->entry.max_renew, def->max_renewable_life);
else else
set_null(ent->max_renew); set_null(ent->entry.max_renew);
} }
} }
if(mask & KADM5_KEY_DATA if(mask & KADM5_KEY_DATA
&& princ_mask & KADM5_KEY_DATA) { && princ_mask & KADM5_KEY_DATA) {
_kadm5_set_keys2(context, ent, princ->n_key_data, princ->key_data); _kadm5_set_keys2(context, &ent->entry,
princ->n_key_data, princ->key_data);
} }
if(mask & KADM5_TL_DATA) { if(mask & KADM5_TL_DATA) {
krb5_tl_data *tl; krb5_tl_data *tl;

4
lib/kadm5/get_princs_s.c
View File

@@ -55,12 +55,12 @@ add_princ(struct foreach_data *d, char *princ)
} }
static krb5_error_code static krb5_error_code
foreach(krb5_context context, HDB *db, hdb_entry *ent, void *data) foreach(krb5_context context, HDB *db, hdb_entry_ex *ent, void *data)
{ {
struct foreach_data *d = data; struct foreach_data *d = data;
char *princ; char *princ;
krb5_error_code ret; krb5_error_code ret;
ret = krb5_unparse_name(context, ent->principal, &princ); ret = krb5_unparse_name(context, ent->entry.principal, &princ);
if(ret) if(ret)
return ret; return ret;
if(d->exp){ if(d->exp){

82
lib/kadm5/get_s.c
View File

@@ -72,9 +72,9 @@ kadm5_s_get_principal(void *server_handle,
{ {
kadm5_server_context *context = server_handle; kadm5_server_context *context = server_handle;
kadm5_ret_t ret; kadm5_ret_t ret;
hdb_entry ent; hdb_entry_ex ent;
ent.principal = princ; ent.entry.principal = princ;
ret = context->db->hdb_open(context->context, context->db, O_RDONLY, 0); ret = context->db->hdb_open(context->context, context->db, O_RDONLY, 0);
if(ret) if(ret)
return ret; return ret;
@@ -86,49 +86,49 @@ kadm5_s_get_principal(void *server_handle,
memset(out, 0, sizeof(*out)); memset(out, 0, sizeof(*out));
if(mask & KADM5_PRINCIPAL) if(mask & KADM5_PRINCIPAL)
ret = krb5_copy_principal(context->context, ent.principal, ret = krb5_copy_principal(context->context, ent.entry.principal,
&out->principal); &out->principal);
if(ret) if(ret)
goto out; goto out;
if(mask & KADM5_PRINC_EXPIRE_TIME && ent.valid_end) if(mask & KADM5_PRINC_EXPIRE_TIME && ent.entry.valid_end)
out->princ_expire_time = *ent.valid_end; out->princ_expire_time = *ent.entry.valid_end;
if(mask & KADM5_PW_EXPIRATION && ent.pw_end) if(mask & KADM5_PW_EXPIRATION && ent.entry.pw_end)
out->pw_expiration = *ent.pw_end; out->pw_expiration = *ent.entry.pw_end;
if(mask & KADM5_LAST_PWD_CHANGE) if(mask & KADM5_LAST_PWD_CHANGE)
hdb_entry_get_pw_change_time(&ent, &out->last_pwd_change); hdb_entry_get_pw_change_time(&ent.entry, &out->last_pwd_change);
if(mask & KADM5_ATTRIBUTES){ if(mask & KADM5_ATTRIBUTES){
out->attributes |= ent.flags.postdate ? 0 : KRB5_KDB_DISALLOW_POSTDATED; out->attributes |= ent.entry.flags.postdate ? 0 : KRB5_KDB_DISALLOW_POSTDATED;
out->attributes |= ent.flags.forwardable ? 0 : KRB5_KDB_DISALLOW_FORWARDABLE; out->attributes |= ent.entry.flags.forwardable ? 0 : KRB5_KDB_DISALLOW_FORWARDABLE;
out->attributes |= ent.flags.initial ? KRB5_KDB_DISALLOW_TGT_BASED : 0; out->attributes |= ent.entry.flags.initial ? KRB5_KDB_DISALLOW_TGT_BASED : 0;
out->attributes |= ent.flags.renewable ? 0 : KRB5_KDB_DISALLOW_RENEWABLE; out->attributes |= ent.entry.flags.renewable ? 0 : KRB5_KDB_DISALLOW_RENEWABLE;
out->attributes |= ent.flags.proxiable ? 0 : KRB5_KDB_DISALLOW_PROXIABLE; out->attributes |= ent.entry.flags.proxiable ? 0 : KRB5_KDB_DISALLOW_PROXIABLE;
out->attributes |= ent.flags.invalid ? KRB5_KDB_DISALLOW_ALL_TIX : 0; out->attributes |= ent.entry.flags.invalid ? KRB5_KDB_DISALLOW_ALL_TIX : 0;
out->attributes |= ent.flags.require_preauth ? KRB5_KDB_REQUIRES_PRE_AUTH : 0; out->attributes |= ent.entry.flags.require_preauth ? KRB5_KDB_REQUIRES_PRE_AUTH : 0;
out->attributes |= ent.flags.server ? 0 : KRB5_KDB_DISALLOW_SVR; out->attributes |= ent.entry.flags.server ? 0 : KRB5_KDB_DISALLOW_SVR;
out->attributes |= ent.flags.change_pw ? KRB5_KDB_PWCHANGE_SERVICE : 0; out->attributes |= ent.entry.flags.change_pw ? KRB5_KDB_PWCHANGE_SERVICE : 0;
out->attributes |= ent.flags.ok_as_delegate ? KRB5_KDB_OK_AS_DELEGATE : 0; out->attributes |= ent.entry.flags.ok_as_delegate ? KRB5_KDB_OK_AS_DELEGATE : 0;
} }
if(mask & KADM5_MAX_LIFE) { if(mask & KADM5_MAX_LIFE) {
if(ent.max_life) if(ent.entry.max_life)
out->max_life = *ent.max_life; out->max_life = *ent.entry.max_life;
else else
out->max_life = INT_MAX; out->max_life = INT_MAX;
} }
if(mask & KADM5_MOD_TIME) { if(mask & KADM5_MOD_TIME) {
if(ent.modified_by) if(ent.entry.modified_by)
out->mod_date = ent.modified_by->time; out->mod_date = ent.entry.modified_by->time;
else else
out->mod_date = ent.created_by.time; out->mod_date = ent.entry.created_by.time;
} }
if(mask & KADM5_MOD_NAME) { if(mask & KADM5_MOD_NAME) {
if(ent.modified_by) { if(ent.entry.modified_by) {
if (ent.modified_by->principal != NULL) if (ent.entry.modified_by->principal != NULL)
ret = krb5_copy_principal(context->context, ret = krb5_copy_principal(context->context,
ent.modified_by->principal, ent.entry.modified_by->principal,
&out->mod_name); &out->mod_name);
} else if(ent.created_by.principal != NULL) } else if(ent.entry.created_by.principal != NULL)
ret = krb5_copy_principal(context->context, ret = krb5_copy_principal(context->context,
ent.created_by.principal, ent.entry.created_by.principal,
&out->mod_name); &out->mod_name);
else else
out->mod_name = NULL; out->mod_name = NULL;
@@ -137,13 +137,13 @@ kadm5_s_get_principal(void *server_handle,
goto out; goto out;
if(mask & KADM5_KVNO) if(mask & KADM5_KVNO)
out->kvno = ent.kvno; out->kvno = ent.entry.kvno;
if(mask & KADM5_MKVNO) { if(mask & KADM5_MKVNO) {
int n; int n;
out->mkvno = 0; /* XXX */ out->mkvno = 0; /* XXX */
for(n = 0; n < ent.keys.len; n++) for(n = 0; n < ent.entry.keys.len; n++)
if(ent.keys.val[n].mkvno) { if(ent.entry.keys.val[n].mkvno) {
out->mkvno = *ent.keys.val[n].mkvno; /* XXX this isn't right */ out->mkvno = *ent.entry.keys.val[n].mkvno; /* XXX this isn't right */
break; break;
} }
} }
@@ -152,8 +152,8 @@ kadm5_s_get_principal(void *server_handle,
if(mask & KADM5_POLICY) if(mask & KADM5_POLICY)
out->policy = NULL; out->policy = NULL;
if(mask & KADM5_MAX_RLIFE) { if(mask & KADM5_MAX_RLIFE) {
if(ent.max_renew) if(ent.entry.max_renew)
out->max_renewable_life = *ent.max_renew; out->max_renewable_life = *ent.entry.max_renew;
else else
out->max_renewable_life = INT_MAX; out->max_renewable_life = INT_MAX;
} }
@@ -169,13 +169,13 @@ kadm5_s_get_principal(void *server_handle,
krb5_key_data *kd; krb5_key_data *kd;
krb5_salt salt; krb5_salt salt;
krb5_data *sp; krb5_data *sp;
krb5_get_pw_salt(context->context, ent.principal, &salt); krb5_get_pw_salt(context->context, ent.entry.principal, &salt);
out->key_data = malloc(ent.keys.len * sizeof(*out->key_data)); out->key_data = malloc(ent.entry.keys.len * sizeof(*out->key_data));
for(i = 0; i < ent.keys.len; i++){ for(i = 0; i < ent.entry.keys.len; i++){
key = &ent.keys.val[i]; key = &ent.entry.keys.val[i];
kd = &out->key_data[i]; kd = &out->key_data[i];
kd->key_data_ver = 2; kd->key_data_ver = 2;
kd->key_data_kvno = ent.kvno; kd->key_data_kvno = ent.entry.kvno;
kd->key_data_type[0] = key->key.keytype; kd->key_data_type[0] = key->key.keytype;
if(key->salt) if(key->salt)
kd->key_data_type[1] = key->salt->type; kd->key_data_type[1] = key->salt->type;
@@ -215,7 +215,7 @@ kadm5_s_get_principal(void *server_handle,
if(mask & KADM5_TL_DATA) { if(mask & KADM5_TL_DATA) {
time_t last_pw_expire; time_t last_pw_expire;
ret = hdb_entry_get_pw_change_time(&ent, &last_pw_expire); ret = hdb_entry_get_pw_change_time(&ent.entry, &last_pw_expire);
if (ret == 0 && last_pw_expire) { if (ret == 0 && last_pw_expire) {
unsigned char buf[4]; unsigned char buf[4];
_krb5_put_int(buf, last_pw_expire, sizeof(buf)); _krb5_put_int(buf, last_pw_expire, sizeof(buf));
@@ -233,7 +233,7 @@ kadm5_s_get_principal(void *server_handle,
heim_utf8_string pw; heim_utf8_string pw;
ret = hdb_entry_get_password(context->context, ret = hdb_entry_get_password(context->context,
context->db, &ent, &pw); context->db, &ent.entry, &pw);
if (ret == 0) { if (ret == 0) {
ret = add_tl_data(out, KRB5_TL_PASSWORD, pw, strlen(pw) + 1); ret = add_tl_data(out, KRB5_TL_PASSWORD, pw, strlen(pw) + 1);
free(pw); free(pw);

4
lib/kadm5/iprop-log.c
View File

@@ -148,7 +148,7 @@ print_entry(kadm5_server_context *server_context,
free(name1); free(name1);
free(name2); free(name2);
krb5_free_principal(context, source); krb5_free_principal(context, source);
hdb_free_entry(context, &ent); free_hdb_entry(&ent);
break; break;
case kadm_create: case kadm_create:
ret = krb5_data_alloc(&data, len); ret = krb5_data_alloc(&data, len);
@@ -250,7 +250,7 @@ print_entry(kadm5_server_context *server_context,
if(mask & KADM5_TL_DATA) { if(mask & KADM5_TL_DATA) {
printf(" tl data\n"); printf(" tl data\n");
} }
hdb_free_entry(context, &ent); free_hdb_entry(&ent);
break; break;
case kadm_nop : case kadm_nop :
break; break;

4
lib/kadm5/ipropd_master.c
View File

@@ -279,14 +279,14 @@ struct prop_context {
}; };
static int static int
prop_one (krb5_context context, HDB *db, hdb_entry *entry, void *v) prop_one (krb5_context context, HDB *db, hdb_entry_ex *entry, void *v)
{ {
krb5_error_code ret; krb5_error_code ret;
krb5_storage *sp; krb5_storage *sp;
krb5_data data; krb5_data data;
struct slave *s = (struct slave *)v; struct slave *s = (struct slave *)v;
ret = hdb_entry2value (context, entry, &data); ret = hdb_entry2value (context, &entry->entry, &data);
if (ret) if (ret)
return ret; return ret;
ret = krb5_data_realloc (&data, data.length + 4); ret = krb5_data_realloc (&data, data.length + 4);

6
lib/kadm5/ipropd_slave.c
View File

@@ -302,14 +302,16 @@ receive_everything (krb5_context context, int fd,
krb5_ret_int32 (sp, &opcode); krb5_ret_int32 (sp, &opcode);
if (opcode == ONE_PRINC) { if (opcode == ONE_PRINC) {
krb5_data fake_data; krb5_data fake_data;
hdb_entry entry; hdb_entry_ex entry;
krb5_storage_free(sp); krb5_storage_free(sp);
fake_data.data = (char *)data.data + 4; fake_data.data = (char *)data.data + 4;
fake_data.length = data.length - 4; fake_data.length = data.length - 4;
ret = hdb_value2entry (context, &fake_data, &entry); memset(&entry, 0, sizeof(entry));
ret = hdb_value2entry (context, &fake_data, &entry.entry);
if (ret) if (ret)
krb5_err (context, 1, ret, "hdb_value2entry"); krb5_err (context, 1, ret, "hdb_value2entry");
ret = mydb->hdb_store(server_context->context, ret = mydb->hdb_store(server_context->context,

126
lib/kadm5/log.c
View File

@@ -271,13 +271,15 @@ kadm5_log_replay_create (kadm5_server_context *context,
{ {
krb5_error_code ret; krb5_error_code ret;
krb5_data data; krb5_data data;
hdb_entry ent; hdb_entry_ex ent;
memset(&ent, 0, sizeof(ent));
ret = krb5_data_alloc (&data, len); ret = krb5_data_alloc (&data, len);
if (ret) if (ret)
return ret; return ret;
krb5_storage_read (sp, data.data, len); krb5_storage_read (sp, data.data, len);
ret = hdb_value2entry (context->context, &data, &ent); ret = hdb_value2entry (context->context, &data, &ent.entry);
krb5_data_free(&data); krb5_data_free(&data);
if (ret) if (ret)
return ret; return ret;
@@ -342,12 +344,12 @@ kadm5_log_replay_delete (kadm5_server_context *context,
krb5_storage *sp) krb5_storage *sp)
{ {
krb5_error_code ret; krb5_error_code ret;
hdb_entry ent; hdb_entry_ex ent;
krb5_ret_principal (sp, &ent.principal); krb5_ret_principal (sp, &ent.entry.principal);
ret = context->db->hdb_remove(context->context, context->db, &ent); ret = context->db->hdb_remove(context->context, context->db, &ent);
krb5_free_principal (context->context, ent.principal); krb5_free_principal (context->context, ent.entry.principal);
return ret; return ret;
} }
@@ -419,11 +421,13 @@ kadm5_log_replay_rename (kadm5_server_context *context,
{ {
krb5_error_code ret; krb5_error_code ret;
krb5_principal source; krb5_principal source;
hdb_entry source_ent, target_ent; hdb_entry_ex source_ent, target_ent;
krb5_data value; krb5_data value;
off_t off; off_t off;
size_t princ_len, data_len; size_t princ_len, data_len;
memset(&target_ent, 0, sizeof(target_ent));
off = krb5_storage_seek(sp, 0, SEEK_CUR); off = krb5_storage_seek(sp, 0, SEEK_CUR);
krb5_ret_principal (sp, &source); krb5_ret_principal (sp, &source);
princ_len = krb5_storage_seek(sp, 0, SEEK_CUR) - off; princ_len = krb5_storage_seek(sp, 0, SEEK_CUR) - off;
@@ -434,7 +438,7 @@ kadm5_log_replay_rename (kadm5_server_context *context,
return ret; return ret;
} }
krb5_storage_read (sp, value.data, data_len); krb5_storage_read (sp, value.data, data_len);
ret = hdb_value2entry (context->context, &value, &target_ent); ret = hdb_value2entry (context->context, &value, &target_ent.entry);
krb5_data_free(&value); krb5_data_free(&value);
if (ret) { if (ret) {
krb5_free_principal (context->context, source); krb5_free_principal (context->context, source);
@@ -447,7 +451,7 @@ kadm5_log_replay_rename (kadm5_server_context *context,
krb5_free_principal (context->context, source); krb5_free_principal (context->context, source);
return ret; return ret;
} }
source_ent.principal = source; source_ent.entry.principal = source;
ret = context->db->hdb_remove (context->context, context->db, &source_ent); ret = context->db->hdb_remove (context->context, context->db, &source_ent);
krb5_free_principal (context->context, source); krb5_free_principal (context->context, source);
return ret; return ret;
@@ -517,7 +521,9 @@ kadm5_log_replay_modify (kadm5_server_context *context,
krb5_error_code ret; krb5_error_code ret;
int32_t mask; int32_t mask;
krb5_data value; krb5_data value;
hdb_entry ent, log_ent; hdb_entry_ex ent, log_ent;
memset(&log_ent, 0, sizeof(log_ent));
krb5_ret_int32 (sp, &mask); krb5_ret_int32 (sp, &mask);
len -= 4; len -= 4;
@@ -525,79 +531,79 @@ kadm5_log_replay_modify (kadm5_server_context *context,
if (ret) if (ret)
return ret; return ret;
krb5_storage_read (sp, value.data, len); krb5_storage_read (sp, value.data, len);
ret = hdb_value2entry (context->context, &value, &log_ent); ret = hdb_value2entry (context->context, &value, &log_ent.entry);
krb5_data_free(&value); krb5_data_free(&value);
if (ret) if (ret)
return ret; return ret;
ent.principal = log_ent.principal; ent.entry.principal = log_ent.entry.principal;
log_ent.principal = NULL; log_ent.entry.principal = NULL;
ret = context->db->hdb_fetch(context->context, context->db, ret = context->db->hdb_fetch(context->context, context->db,
HDB_F_DECRYPT, &ent); HDB_F_DECRYPT, &ent);
if (ret) if (ret)
goto out; goto out;
if (mask & KADM5_PRINC_EXPIRE_TIME) { if (mask & KADM5_PRINC_EXPIRE_TIME) {
if (log_ent.valid_end == NULL) { if (log_ent.entry.valid_end == NULL) {
ent.valid_end = NULL; ent.entry.valid_end = NULL;
} else { } else {
if (ent.valid_end == NULL) { if (ent.entry.valid_end == NULL) {
ent.valid_end = malloc(sizeof(*ent.valid_end)); ent.entry.valid_end = malloc(sizeof(*ent.entry.valid_end));
if (ent.valid_end == NULL) { if (ent.entry.valid_end == NULL) {
ret = ENOMEM; ret = ENOMEM;
goto out; goto out;
} }
} }
*ent.valid_end = *log_ent.valid_end; *ent.entry.valid_end = *log_ent.entry.valid_end;
} }
} }
if (mask & KADM5_PW_EXPIRATION) { if (mask & KADM5_PW_EXPIRATION) {
if (log_ent.pw_end == NULL) { if (log_ent.entry.pw_end == NULL) {
ent.pw_end = NULL; ent.entry.pw_end = NULL;
} else { } else {
if (ent.pw_end == NULL) { if (ent.entry.pw_end == NULL) {
ent.pw_end = malloc(sizeof(*ent.pw_end)); ent.entry.pw_end = malloc(sizeof(*ent.entry.pw_end));
if (ent.pw_end == NULL) { if (ent.entry.pw_end == NULL) {
ret = ENOMEM; ret = ENOMEM;
goto out; goto out;
} }
} }
*ent.pw_end = *log_ent.pw_end; *ent.entry.pw_end = *log_ent.entry.pw_end;
} }
} }
if (mask & KADM5_LAST_PWD_CHANGE) { if (mask & KADM5_LAST_PWD_CHANGE) {
abort (); /* XXX */ abort (); /* XXX */
} }
if (mask & KADM5_ATTRIBUTES) { if (mask & KADM5_ATTRIBUTES) {
ent.flags = log_ent.flags; ent.entry.flags = log_ent.entry.flags;
} }
if (mask & KADM5_MAX_LIFE) { if (mask & KADM5_MAX_LIFE) {
if (log_ent.max_life == NULL) { if (log_ent.entry.max_life == NULL) {
ent.max_life = NULL; ent.entry.max_life = NULL;
} else { } else {
if (ent.max_life == NULL) { if (ent.entry.max_life == NULL) {
ent.max_life = malloc (sizeof(*ent.max_life)); ent.entry.max_life = malloc (sizeof(*ent.entry.max_life));
if (ent.max_life == NULL) { if (ent.entry.max_life == NULL) {
ret = ENOMEM; ret = ENOMEM;
goto out; goto out;
} }
} }
*ent.max_life = *log_ent.max_life; *ent.entry.max_life = *log_ent.entry.max_life;
} }
} }
if ((mask & KADM5_MOD_TIME) && (mask & KADM5_MOD_NAME)) { if ((mask & KADM5_MOD_TIME) && (mask & KADM5_MOD_NAME)) {
if (ent.modified_by == NULL) { if (ent.entry.modified_by == NULL) {
ent.modified_by = malloc(sizeof(*ent.modified_by)); ent.entry.modified_by = malloc(sizeof(*ent.entry.modified_by));
if (ent.modified_by == NULL) { if (ent.entry.modified_by == NULL) {
ret = ENOMEM; ret = ENOMEM;
goto out; goto out;
} }
} else } else
free_Event(ent.modified_by); free_Event(ent.entry.modified_by);
ret = copy_Event(log_ent.modified_by, ent.modified_by); ret = copy_Event(log_ent.entry.modified_by, ent.entry.modified_by);
if (ret) if (ret)
goto out; goto out;
} }
if (mask & KADM5_KVNO) { if (mask & KADM5_KVNO) {
ent.kvno = log_ent.kvno; ent.entry.kvno = log_ent.entry.kvno;
} }
if (mask & KADM5_MKVNO) { if (mask & KADM5_MKVNO) {
abort (); /* XXX */ abort (); /* XXX */
@@ -612,17 +618,17 @@ kadm5_log_replay_modify (kadm5_server_context *context,
abort (); /* XXX */ abort (); /* XXX */
} }
if (mask & KADM5_MAX_RLIFE) { if (mask & KADM5_MAX_RLIFE) {
if (log_ent.max_renew == NULL) { if (log_ent.entry.max_renew == NULL) {
ent.max_renew = NULL; ent.entry.max_renew = NULL;
} else { } else {
if (ent.max_renew == NULL) { if (ent.entry.max_renew == NULL) {
ent.max_renew = malloc (sizeof(*ent.max_renew)); ent.entry.max_renew = malloc (sizeof(*ent.entry.max_renew));
if (ent.max_renew == NULL) { if (ent.entry.max_renew == NULL) {
ret = ENOMEM; ret = ENOMEM;
goto out; goto out;
} }
} }
*ent.max_renew = *log_ent.max_renew; *ent.entry.max_renew = *log_ent.entry.max_renew;
} }
} }
if (mask & KADM5_LAST_SUCCESS) { if (mask & KADM5_LAST_SUCCESS) {
@@ -638,34 +644,34 @@ kadm5_log_replay_modify (kadm5_server_context *context,
size_t num; size_t num;
int i; int i;
for (i = 0; i < ent.keys.len; ++i) for (i = 0; i < ent.entry.keys.len; ++i)
free_Key(&ent.keys.val[i]); free_Key(&ent.entry.keys.val[i]);
free (ent.keys.val); free (ent.entry.keys.val);
num = log_ent.keys.len; num = log_ent.entry.keys.len;
ent.keys.len = num; ent.entry.keys.len = num;
ent.keys.val = malloc(len * sizeof(*ent.keys.val)); ent.entry.keys.val = malloc(len * sizeof(*ent.entry.keys.val));
for (i = 0; i < ent.keys.len; ++i) { for (i = 0; i < ent.entry.keys.len; ++i) {
ret = copy_Key(&log_ent.keys.val[i], ret = copy_Key(&log_ent.entry.keys.val[i],
&ent.keys.val[i]); &ent.entry.keys.val[i]);
if (ret) if (ret)
goto out; goto out;
} }
} }
if ((mask & KADM5_TL_DATA) && log_ent.extensions) { if ((mask & KADM5_TL_DATA) && log_ent.entry.extensions) {
HDB_extensions *es = ent.extensions; HDB_extensions *es = ent.entry.extensions;
if (ent.extensions == NULL) { if (ent.entry.extensions == NULL) {
ent.extensions = calloc(1, sizeof(*ent.extensions)); ent.entry.extensions = calloc(1, sizeof(*ent.entry.extensions));
if (ent.extensions == NULL) if (ent.entry.extensions == NULL)
goto out; goto out;
} }
ret = copy_HDB_extensions(es, ent.extensions); ret = copy_HDB_extensions(es, ent.entry.extensions);
if (ret) { if (ret) {
free(ent.extensions); free(ent.entry.extensions);
ent.extensions = es; ent.entry.extensions = es;
goto out; goto out;
} }
if (es) { if (es) {

10
lib/kadm5/modify_s.c
View File

@@ -42,14 +42,14 @@ modify_principal(void *server_handle,
u_int32_t forbidden_mask) u_int32_t forbidden_mask)
{ {
kadm5_server_context *context = server_handle; kadm5_server_context *context = server_handle;
hdb_entry ent; hdb_entry_ex ent;
kadm5_ret_t ret; kadm5_ret_t ret;
if((mask & forbidden_mask)) if((mask & forbidden_mask))
return KADM5_BAD_MASK; return KADM5_BAD_MASK;
if((mask & KADM5_POLICY) && strcmp(princ->policy, "default")) if((mask & KADM5_POLICY) && strcmp(princ->policy, "default"))
return KADM5_UNK_POLICY; return KADM5_UNK_POLICY;
ent.principal = princ->principal; ent.entry.principal = princ->principal;
ret = context->db->hdb_open(context->context, context->db, O_RDWR, 0); ret = context->db->hdb_open(context->context, context->db, O_RDWR, 0);
if(ret) if(ret)
return ret; return ret;
@@ -59,16 +59,16 @@ modify_principal(void *server_handle,
ret = _kadm5_setup_entry(context, &ent, mask, princ, mask, NULL, 0); ret = _kadm5_setup_entry(context, &ent, mask, princ, mask, NULL, 0);
if(ret) if(ret)
goto out2; goto out2;
ret = _kadm5_set_modifier(context, &ent); ret = _kadm5_set_modifier(context, &ent.entry);
if(ret) if(ret)
goto out2; goto out2;
ret = hdb_seal_keys(context->context, context->db, &ent); ret = hdb_seal_keys(context->context, context->db, &ent.entry);
if (ret) if (ret)
goto out2; goto out2;
kadm5_log_modify (context, kadm5_log_modify (context,
&ent, &ent.entry,
mask | KADM5_MOD_NAME | KADM5_MOD_TIME); mask | KADM5_MOD_NAME | KADM5_MOD_TIME);
ret = context->db->hdb_store(context->context, context->db, ret = context->db->hdb_store(context->context, context->db,

16
lib/kadm5/randkey_s.c
View File

@@ -47,10 +47,10 @@ kadm5_s_randkey_principal(void *server_handle,
int *n_keys) int *n_keys)
{ {
kadm5_server_context *context = server_handle; kadm5_server_context *context = server_handle;
hdb_entry ent; hdb_entry_ex ent;
kadm5_ret_t ret; kadm5_ret_t ret;
ent.principal = princ; ent.entry.principal = princ;
ret = context->db->hdb_open(context->context, context->db, O_RDWR, 0); ret = context->db->hdb_open(context->context, context->db, O_RDWR, 0);
if(ret) if(ret)
return ret; return ret;
@@ -59,26 +59,26 @@ kadm5_s_randkey_principal(void *server_handle,
goto out; goto out;
ret = _kadm5_set_keys_randomly (context, ret = _kadm5_set_keys_randomly (context,
&ent, &ent.entry,
new_keys, new_keys,
n_keys); n_keys);
if (ret) if (ret)
goto out2; goto out2;
ent.kvno++; ent.entry.kvno++;
ret = _kadm5_set_modifier(context, &ent); ret = _kadm5_set_modifier(context, &ent.entry);
if(ret) if(ret)
goto out3; goto out3;
ret = _kadm5_bump_pw_expire(context, &ent); ret = _kadm5_bump_pw_expire(context, &ent.entry);
if (ret) if (ret)
goto out2; goto out2;
ret = hdb_seal_keys(context->context, context->db, &ent); ret = hdb_seal_keys(context->context, context->db, &ent.entry);
if (ret) if (ret)
goto out2; goto out2;
kadm5_log_modify (context, kadm5_log_modify (context,
&ent, &ent.entry,
KADM5_PRINCIPAL | KADM5_MOD_NAME | KADM5_MOD_TIME | KADM5_PRINCIPAL | KADM5_MOD_NAME | KADM5_MOD_TIME |
KADM5_KEY_DATA | KADM5_KVNO | KADM5_PW_EXPIRATION | KADM5_KEY_DATA | KADM5_KVNO | KADM5_PW_EXPIRATION |
KADM5_TL_DATA); KADM5_TL_DATA);

30
lib/kadm5/rename_s.c
View File

@@ -42,8 +42,9 @@ kadm5_s_rename_principal(void *server_handle,
{ {
kadm5_server_context *context = server_handle; kadm5_server_context *context = server_handle;
kadm5_ret_t ret; kadm5_ret_t ret;
hdb_entry ent, ent2; hdb_entry_ex ent, ent2;
ent.principal = source;
ent.entry.principal = source;
if(krb5_principal_compare(context->context, source, target)) if(krb5_principal_compare(context->context, source, target))
return KADM5_DUP; /* XXX is this right? */ return KADM5_DUP; /* XXX is this right? */
ret = context->db->hdb_open(context->context, context->db, O_RDWR, 0); ret = context->db->hdb_open(context->context, context->db, O_RDWR, 0);
@@ -54,7 +55,7 @@ kadm5_s_rename_principal(void *server_handle,
context->db->hdb_close(context->context, context->db); context->db->hdb_close(context->context, context->db);
goto out; goto out;
} }
ret = _kadm5_set_modifier(context, &ent); ret = _kadm5_set_modifier(context, &ent.entry);
if(ret) if(ret)
goto out2; goto out2;
{ {
@@ -65,10 +66,11 @@ kadm5_s_rename_principal(void *server_handle,
krb5_get_pw_salt(context->context, source, &salt2); krb5_get_pw_salt(context->context, source, &salt2);
salt.type = hdb_pw_salt; salt.type = hdb_pw_salt;
salt.salt = salt2.saltvalue; salt.salt = salt2.saltvalue;
for(i = 0; i < ent.keys.len; i++){ for(i = 0; i < ent.entry.keys.len; i++){
if(ent.keys.val[i].salt == NULL){ if(ent.entry.keys.val[i].salt == NULL){
ent.keys.val[i].salt = malloc(sizeof(*ent.keys.val[i].salt)); ent.entry.keys.val[i].salt =
ret = copy_Salt(&salt, ent.keys.val[i].salt); malloc(sizeof(*ent.entry.keys.val[i].salt));
ret = copy_Salt(&salt, ent.entry.keys.val[i].salt);
if(ret) if(ret)
break; break;
} }
@@ -77,26 +79,26 @@ kadm5_s_rename_principal(void *server_handle,
} }
if(ret) if(ret)
goto out2; goto out2;
ent2.principal = ent.principal; ent2.entry.principal = ent.entry.principal;
ent.principal = target; ent.entry.principal = target;
ret = hdb_seal_keys(context->context, context->db, &ent); ret = hdb_seal_keys(context->context, context->db, &ent.entry);
if (ret) { if (ret) {
ent.principal = ent2.principal; ent.entry.principal = ent2.entry.principal;
goto out2; goto out2;
} }
kadm5_log_rename (context, kadm5_log_rename (context,
source, source,
&ent); &ent.entry);
ret = context->db->hdb_store(context->context, context->db, 0, &ent); ret = context->db->hdb_store(context->context, context->db, 0, &ent);
if(ret){ if(ret){
ent.principal = ent2.principal; ent.entry.principal = ent2.entry.principal;
goto out2; goto out2;
} }
ret = context->db->hdb_remove(context->context, context->db, &ent2); ret = context->db->hdb_remove(context->context, context->db, &ent2);
ent.principal = ent2.principal; ent.entry.principal = ent2.entry.principal;
out2: out2:
context->db->hdb_close(context->context, context->db); context->db->hdb_close(context->context, context->db);
hdb_free_entry(context->context, &ent); hdb_free_entry(context->context, &ent);