Simplify principal access within libkrb5

For conciseness, directly use fields of krb5_principal objects instead
of using the accessor macros.

src/lib/krb5/ccache/cc_file.c

@@ -509,22 +509,22 @@ krb5_fcc_read_principal(krb5_context context, krb5_ccache id, krb5_principal *pr
     tmpprinc->length = length;
     tmpprinc->type = type;
 
-    kret = krb5_fcc_read_data(context, id, krb5_princ_realm(context, tmpprinc));
+    kret = krb5_fcc_read_data(context, id, &tmpprinc->realm);
 
     i = 0;
     CHECK(kret);
 
     for (i=0; i < length; i++) {
-        kret = krb5_fcc_read_data(context, id, krb5_princ_component(context, tmpprinc, i));
+        kret = krb5_fcc_read_data(context, id, &tmpprinc->data[i]);
         CHECK(kret);
     }
     *princ = tmpprinc;
     return KRB5_OK;
 
 errout:
     while(--i >= 0)
-        free(krb5_princ_component(context, tmpprinc, i)->data);
-    free(krb5_princ_realm(context, tmpprinc)->data);
+        free(tmpprinc->data[i].data);
+    free(tmpprinc->realm.data);
     free(tmpprinc->data);
     free(tmpprinc);
     return kret;
@@ -949,8 +949,8 @@ krb5_fcc_store_principal(krb5_context context, krb5_ccache id, krb5_principal pr
 
     k5_cc_mutex_assert_locked(context, &((krb5_fcc_data *) id->data)->lock);
 
-    type = krb5_princ_type(context, princ);
-    tmp = length = krb5_princ_size(context, princ);
+    type = princ->type;
+    tmp = length = princ->length;
 
     if (data->version == KRB5_FCC_FVNO_1) {
         /*
@@ -967,11 +967,11 @@ krb5_fcc_store_principal(krb5_context context, krb5_ccache id, krb5_principal pr
     ret = krb5_fcc_store_int32(context, id, tmp);
     CHECK(ret);
 
-    ret = krb5_fcc_store_data(context, id, krb5_princ_realm(context, princ));
+    ret = krb5_fcc_store_data(context, id, &princ->realm);
     CHECK(ret);
 
     for (i=0; i < length; i++) {
-        ret = krb5_fcc_store_data(context, id, krb5_princ_component(context, princ, i));
+        ret = krb5_fcc_store_data(context, id, &princ->data[i]);
         CHECK(ret);
     }
 

src/lib/krb5/ccache/cc_keyring.c

@@ -1396,24 +1396,21 @@ krb5_krcc_parse_principal(krb5_context context, krb5_ccache id,
     tmpprinc->length = length;
     tmpprinc->type = type;
 
-    kret = krb5_krcc_parse_krb5data(context, id,
-                                    krb5_princ_realm(context, tmpprinc), bc);
+    kret = krb5_krcc_parse_krb5data(context, id, &tmpprinc->realm, bc);
     i = 0;
     CHECK(kret);
 
     for (i = 0; i < length; i++) {
-        kret = krb5_krcc_parse_krb5data(context, id,
-                                        krb5_princ_component(context, tmpprinc,
-                                                             i), bc);
+        kret = krb5_krcc_parse_krb5data(context, id, &tmpprinc->data[i], bc);
         CHECK(kret);
     }
     *princ = tmpprinc;
     return KRB5_OK;
 
 errout:
     while (--i >= 0)
-        free(krb5_princ_component(context, tmpprinc, i)->data);
-    free(krb5_princ_realm(context, tmpprinc)->data);
+        free(tmpprinc->data[i].data);
+    free(tmpprinc->realm.data);
     free(tmpprinc->data);
     free(tmpprinc);
     return kret;
@@ -1775,23 +1772,20 @@ krb5_krcc_unparse_principal(krb5_context context, krb5_ccache id,
     krb5_error_code kret;
     krb5_int32 i, length, tmp, type;
 
-    type = krb5_princ_type(context, princ);
-    tmp = length = krb5_princ_size(context, princ);
+    type = princ->type;
+    tmp = length = princ->length;
 
     kret = krb5_krcc_unparse_int32(context, id, type, bc);
     CHECK_OUT(kret);
 
     kret = krb5_krcc_unparse_int32(context, id, tmp, bc);
     CHECK_OUT(kret);
 
-    kret = krb5_krcc_unparse_krb5data(context, id,
-                                      krb5_princ_realm(context, princ), bc);
+    kret = krb5_krcc_unparse_krb5data(context, id, &princ->realm, bc);
     CHECK_OUT(kret);
 
     for (i = 0; i < length; i++) {
-        kret = krb5_krcc_unparse_krb5data(context, id,
-                                          krb5_princ_component(context, princ,
-                                                               i), bc);
+        kret = krb5_krcc_unparse_krb5data(context, id, &princ->data[i], bc);
         CHECK_OUT(kret);
     }
 

src/lib/krb5/ccache/ccfns.c

@@ -252,9 +252,7 @@ krb5_boolean KRB5_CALLCONV
 krb5_is_config_principal(krb5_context context,
                          krb5_const_principal principal)
 {
-    const krb5_data *realm;
-
-    realm = krb5_princ_realm(context, principal);
+    const krb5_data *realm = &principal->realm;
 
     if (realm->length != sizeof(conf_realm) - 1 ||
         memcmp(realm->data, conf_realm, sizeof(conf_realm) - 1) != 0)

src/lib/krb5/keytab/kt_file.c

@@ -1279,7 +1279,7 @@ krb5_ktfileint_internal_read_entry(krb5_context context, krb5_keytab id, krb5_ke
     }
     u_princ_size = princ_size;
 
-    krb5_princ_set_realm_length(context, ret_entry->principal, u_princ_size);
+    ret_entry->principal->realm.length = u_princ_size;
     tmpdata = malloc(u_princ_size+1);
     if (!tmpdata) {
         error = ENOMEM;
@@ -1293,10 +1293,10 @@ krb5_ktfileint_internal_read_entry(krb5_context context, krb5_keytab id, krb5_ke
     tmpdata[princ_size] = 0;    /* Some things might be expecting null */
                                 /* termination...  ``Be conservative in */
                                 /* what you send out'' */
-    krb5_princ_set_realm_data(context, ret_entry->principal, tmpdata);
+    ret_entry->principal->realm.data = tmpdata;
 
     for (i = 0; i < count; i++) {
-        princ = krb5_princ_component(context, ret_entry->principal, i);
+        princ = &ret_entry->principal->data[i];
         if (!fread(&princ_size, sizeof(princ_size), 1, KTFILEP(id))) {
             error = KRB5_KT_END;
             goto fail;
@@ -1395,11 +1395,8 @@ krb5_ktfileint_internal_read_entry(krb5_context context, krb5_keytab id, krb5_ke
     return 0;
 fail:
 
-    for (i = 0; i < krb5_princ_size(context, ret_entry->principal); i++) {
-        princ = krb5_princ_component(context, ret_entry->principal, i);
-        if (princ->data)
-            free(princ->data);
-    }
+    for (i = 0; i < ret_entry->principal->length; i++)
+        free(ret_entry->principal->data[i].data);
     free(ret_entry->principal->data);
     ret_entry->principal->data = 0;
     free(ret_entry->principal);
@@ -1444,29 +1441,29 @@ krb5_ktfileint_write_entry(krb5_context context, krb5_keytab id, krb5_keytab_ent
     }
 
     if (KTVERSION(id) == KRB5_KT_VNO_1) {
-        count = (krb5_int16) krb5_princ_size(context, entry->principal) + 1;
+        count = (krb5_int16)entry->principal->length + 1;
     } else {
-        count = htons((u_short) krb5_princ_size(context, entry->principal));
+        count = htons((u_short)entry->principal->length);
     }
 
     if (!fwrite(&count, sizeof(count), 1, KTFILEP(id))) {
     abend:
         return KRB5_KT_IOERR;
     }
-    size = krb5_princ_realm(context, entry->principal)->length;
+    size = entry->principal->realm.length;
     if (KTVERSION(id) != KRB5_KT_VNO_1)
         size = htons(size);
     if (!fwrite(&size, sizeof(size), 1, KTFILEP(id))) {
         goto abend;
     }
-    if (!fwrite(krb5_princ_realm(context, entry->principal)->data, sizeof(char),
-                krb5_princ_realm(context, entry->principal)->length, KTFILEP(id))) {
+    if (!fwrite(entry->principal->realm.data, sizeof(char),
+                entry->principal->realm.length, KTFILEP(id))) {
         goto abend;
     }
 
-    count = (krb5_int16) krb5_princ_size(context, entry->principal);
+    count = (krb5_int16)entry->principal->length;
     for (i = 0; i < count; i++) {
-        princ = krb5_princ_component(context, entry->principal, i);
+        princ = &entry->principal->data[i];
         size = princ->length;
         if (KTVERSION(id) != KRB5_KT_VNO_1)
             size = htons(size);
@@ -1482,7 +1479,7 @@ krb5_ktfileint_write_entry(krb5_context context, krb5_keytab id, krb5_keytab_ent
      * Write out the principal type
      */
     if (KTVERSION(id) != KRB5_KT_VNO_1) {
-        princ_type = htonl(krb5_princ_type(context, entry->principal));
+        princ_type = htonl(entry->principal->type);
         if (!fwrite(&princ_type, sizeof(princ_type), 1, KTFILEP(id))) {
             goto abend;
         }
@@ -1563,15 +1560,13 @@ krb5_ktfileint_size_entry(krb5_context context, krb5_keytab_entry *entry, krb5_i
     krb5_int32 total_size, i;
     krb5_error_code retval = 0;
 
-    count = (krb5_int16) krb5_princ_size(context, entry->principal);
+    count = (krb5_int16)entry->principal->length;
 
     total_size = sizeof(count);
-    total_size += krb5_princ_realm(context, entry->principal)->length + (sizeof(krb5_int16));
+    total_size += entry->principal->realm.length + sizeof(krb5_int16);
 
-    for (i = 0; i < count; i++) {
-        total_size += krb5_princ_component(context, entry->principal,i)->length
-            + (sizeof(krb5_int16));
-    }
+    for (i = 0; i < count; i++)
+        total_size += entry->principal->data[i].length + sizeof(krb5_int16);
 
     total_size += sizeof(entry->principal->type);
     total_size += sizeof(entry->timestamp);

src/lib/krb5/krb/bld_pr_ext.c

@@ -83,7 +83,7 @@ krb5_build_principal_ext(krb5_context context,  krb5_principal * princ,
     }
     va_end(ap);
     *princ = princ_ret;
-    krb5_princ_type(context, princ_ret) = KRB5_NT_UNKNOWN;
+    princ_ret->type = KRB5_NT_UNKNOWN;
     return 0;
 
 free_out:

src/lib/krb5/krb/bld_princ.c

@@ -70,8 +70,7 @@ build_principal_va(krb5_context context, krb5_principal princ,
     if (!retval) {
         princ->type = KRB5_NT_UNKNOWN;
         princ->magic = KV5M_PRINCIPAL;
-        krb5_princ_set_realm_data(context, princ, r);
-        krb5_princ_set_realm_length(context, princ, rlen);
+        princ->realm = make_data(r, rlen);
         princ->data = data;
         princ->length = count;
         r = NULL;    /* take ownership */

src/lib/krb5/krb/chk_trans.c

@@ -298,7 +298,7 @@ check_realm_in_list (krb5_data *realm, void *data)
 
     Tprintf ((".. checking '%.*s'\n", (int) realm->length, realm->data));
     for (i = 0; cdata->tgs[i]; i++) {
-        if (data_eq (*krb5_princ_realm (cdata->ctx, cdata->tgs[i]), *realm))
+        if (data_eq (cdata->tgs[i]->realm, *realm))
             return 0;
     }
     Tprintf (("BAD!\n"));

src/lib/krb5/krb/conv_princ.c

@@ -162,10 +162,10 @@ krb5_524_conv_principal(krb5_context context, krb5_const_principal princ,
         return KRB5_CONFIG_CANTOPEN;
 
     *name = *inst = '\0';
-    switch (krb5_princ_size(context, princ)) {
+    switch (princ->length) {
     case 2:
         /* Check if this principal is listed in the table */
-        compo = krb5_princ_component(context, princ, 0);
+        compo = &princ->data[0];
         p = sconv_list;
         while (p->v4_str) {
             if (p->len == compo->length
@@ -177,7 +177,7 @@ krb5_524_conv_principal(krb5_context context, krb5_const_principal princ,
                 if (strlcpy(name, p->v4_str, ANAME_SZ) >= ANAME_SZ)
                     return KRB5_INVALID_PRINCIPAL;
                 if (p->flags & DO_REALM_CONVERSION) {
-                    compo = krb5_princ_component(context, princ, 1);
+                    compo = &princ->data[1];
                     c = strnchr(compo->data, '.', compo->length);
                     if (!c || (c - compo->data) >= INST_SZ - 1)
                         return KRB5_INVALID_PRINCIPAL;
@@ -191,7 +191,7 @@ krb5_524_conv_principal(krb5_context context, krb5_const_principal princ,
         /* If inst isn't set, the service isn't listed in the table, */
         /* so just copy it. */
         if (*inst == '\0') {
-            compo = krb5_princ_component(context, princ, 1);
+            compo = &princ->data[1];
             if (compo->length >= INST_SZ - 1)
                 return KRB5_INVALID_PRINCIPAL;
             memcpy(inst, compo->data, compo->length);
@@ -201,7 +201,7 @@ krb5_524_conv_principal(krb5_context context, krb5_const_principal princ,
     case 1:
         /* name may have been set above; otherwise, just copy it */
         if (*name == '\0') {
-            compo = krb5_princ_component(context, princ, 0);
+            compo = &princ->data[0];
             if (compo->length >= ANAME_SZ)
                 return KRB5_INVALID_PRINCIPAL;
             memcpy(name, compo->data, compo->length);
@@ -212,7 +212,7 @@ krb5_524_conv_principal(krb5_context context, krb5_const_principal princ,
         return KRB5_INVALID_PRINCIPAL;
     }
 
-    compo = krb5_princ_realm(context, princ);
+    compo = &princ->realm;
 
     tmp_prealm = malloc(compo->length + 1);
     if (tmp_prealm == NULL)

src/lib/krb5/krb/copy_princ.c

@@ -33,7 +33,7 @@ krb5_error_code KRB5_CALLCONV
 krb5_copy_principal(krb5_context context, krb5_const_principal inprinc, krb5_principal *outprinc)
 {
     register krb5_principal tempprinc;
-    register int i, nelems;
+    krb5_int32 i;
 
     tempprinc = (krb5_principal)malloc(sizeof(krb5_principal_data));
 
@@ -42,20 +42,18 @@ krb5_copy_principal(krb5_context context, krb5_const_principal inprinc, krb5_pri
 
     *tempprinc = *inprinc;
 
-    nelems = (int) krb5_princ_size(context, inprinc);
-    tempprinc->data = malloc(nelems * sizeof(krb5_data));
+    tempprinc->data = malloc(inprinc->length * sizeof(krb5_data));
 
     if (tempprinc->data == 0) {
         free(tempprinc);
         return ENOMEM;
     }
 
-    for (i = 0; i < nelems; i++) {
-        if (krb5int_copy_data_contents(context,
-                                       krb5_princ_component(context, inprinc, i),
-                                       krb5_princ_component(context, tempprinc, i)) != 0) {
+    for (i = 0; i < inprinc->length; i++) {
+        if (krb5int_copy_data_contents(context, &inprinc->data[i],
+                                       &tempprinc->data[i]) != 0) {
             while (--i >= 0)
-                free(krb5_princ_component(context, tempprinc, i)->data);
+                free(tempprinc->data[i].data);
             free (tempprinc->data);
             free (tempprinc);
             return ENOMEM;
@@ -64,8 +62,8 @@ krb5_copy_principal(krb5_context context, krb5_const_principal inprinc, krb5_pri
 
     if (krb5int_copy_data_contents_add0(context, &inprinc->realm,
                                         &tempprinc->realm) != 0) {
-        for (i = 0; i < nelems; i++)
-            free(krb5_princ_component(context, tempprinc, i)->data);
+        for (i = 0; i < inprinc->length; i++)
+            free(tempprinc->data[i].data);
         free(tempprinc->data);
         free(tempprinc);
         return ENOMEM;

src/lib/krb5/krb/fast.c

@@ -180,7 +180,7 @@ krb5int_fast_as_armor(krb5_context context,
     krb5_data *target_realm;
 
     krb5_clear_error_message(context);
-    target_realm = krb5_princ_realm(context, request->server);
+    target_realm = &request->server->realm;
     if (opte->opt_private->fast_ccache_name) {
         TRACE_FAST_ARMOR_CCACHE(context, opte->opt_private->fast_ccache_name);
         state->fast_state_flags |= KRB5INT_FAST_ARMOR_AVAIL;

src/lib/krb5/krb/fwd_tgt.c

@@ -121,12 +121,12 @@ krb5_fwd_tgt_creds(krb5_context context, krb5_auth_context auth_context,
 
     if (tgt.addresses && *tgt.addresses) {
         if (rhost == NULL) {
-            if (krb5_princ_type(context, server) != KRB5_NT_SRV_HST) {
+            if (server->type != KRB5_NT_SRV_HST) {
                 retval = KRB5_FWD_BAD_PRINCIPAL;
                 goto errout;
             }
 
-            if (krb5_princ_size(context, server) < 2){
+            if (server->length < 2){
                 retval = KRB5_CC_BADNAME;
                 goto errout;
             }

src/lib/krb5/krb/gc_via_tkt.c

@@ -126,8 +126,8 @@ check_reply_server(krb5_context context, krb5_flags kdcoptions,
 
     /* We didn't request canonicalization. */
 
-    if (!IS_TGS_PRINC(context, in_cred->server) ||
-        !IS_TGS_PRINC(context, dec_rep->ticket->server)) {
+    if (!IS_TGS_PRINC(in_cred->server) ||
+        !IS_TGS_PRINC(dec_rep->ticket->server)) {
         /* Canonicalization not requested, and not a TGS referral. */
         return KRB5_KDCREP_MODIFIED;
     }
@@ -264,7 +264,7 @@ krb5int_process_tgs_reply(krb5_context context,
     /* make sure the response hasn't been tampered with..... */
     retval = 0;
 
-    if (s4u2self && !IS_TGS_PRINC(context, dec_rep->ticket->server)) {
+    if (s4u2self && !IS_TGS_PRINC(dec_rep->ticket->server)) {
         /* Final hop, check whether KDC supports S4U2Self */
         if (krb5_principal_compare(context, dec_rep->client, in_cred->server))
             retval = KRB5KDC_ERR_PADATA_TYPE_NOSUPP;
@@ -374,8 +374,7 @@ krb5_get_cred_via_tkt_ext(krb5_context context, krb5_creds *tkt,
 
 send_again:
     use_master = 0;
-    retval = krb5_sendto_kdc(context, &request_data,
-                             krb5_princ_realm(context, in_cred->server),
+    retval = krb5_sendto_kdc(context, &request_data, &in_cred->server->realm,
                              &response_data, &use_master, tcp_only);
     if (retval == 0) {
         if (krb5_is_krb_error(&response_data)) {