src/lib/krb5/keytab/ktbase.c

   1 /*
   2  * lib/krb5/keytab/ktbase.c
   3  *
   4  * Copyright 1990 by the Massachusetts Institute of Technology.
   5  * All Rights Reserved.
   6  *
   7  * Export of this software from the United States of America may
   8  *   require a specific license from the United States Government.
   9  *   It is the responsibility of any person or organization contemplating
  10  *   export to obtain such a license before exporting.
  11  *
  12  * WITHIN THAT CONSTRAINT, permission to use, copy, modify, and
  13  * distribute this software and its documentation for any purpose and
  14  * without fee is hereby granted, provided that the above copyright
  15  * notice appear in all copies and that both that copyright notice and
  16  * this permission notice appear in supporting documentation, and that
  17  * the name of M.I.T. not be used in advertising or publicity pertaining
  18  * to distribution of the software without specific, written prior
  19  * permission.  Furthermore if you modify this software you must label
  20  * your software as modified software and not distribute it in such a
  21  * fashion that it might be confused with the original M.I.T. software.
  22  * M.I.T. makes no representations about the suitability of
  23  * this software for any purpose.  It is provided "as is" without express
  24  * or implied warranty.
  25  *
  26  *
  27  * Registration functions for keytab.
  28  */
  29
  30 #include "k5-int.h"
  31
  32 extern krb5_kt_ops krb5_ktf_ops;
  33 extern krb5_kt_ops krb5_kts_ops;
  34
  35 struct krb5_kt_typelist {
  36     krb5_kt_ops *ops;
  37     struct krb5_kt_typelist *next;
  38 };
  39 static struct krb5_kt_typelist krb5_kt_typelist_file  = {
  40     &krb5_ktf_ops,
  41     0
  42 };
  43 static struct krb5_kt_typelist krb5_kt_typelist_srvtab = {
  44     &krb5_kts_ops,
  45     &krb5_kt_typelist_file
  46 };
  47 static struct krb5_kt_typelist *kt_typehead = &krb5_kt_typelist_srvtab;
  48
  49
  50 /*
  51  * Register a new key table type
  52  * don't replace if it already exists; return an error instead.
  53  */
  54
  55 krb5_error_code KRB5_CALLCONV
  56 krb5_kt_register(krb5_context context, krb5_kt_ops *ops)
  57 {
  58     struct krb5_kt_typelist *t;
  59     for (t = kt_typehead;t && strcmp(t->ops->prefix,ops->prefix);t = t->next)
  60         ;
  61     if (t) {
  62         return KRB5_KT_TYPE_EXISTS;
  63     }
  64     if (!(t = (struct krb5_kt_typelist *) malloc(sizeof(*t))))
  65         return ENOMEM;
  66     t->next = kt_typehead;
  67     t->ops = ops;
  68     kt_typehead = t;
  69     return 0;
  70 }
  71
  72 /*
  73  * Resolve a key table name into a keytab object.
  74  *
  75  * The name is currently constrained to be of the form "type:residual";
  76  *
  77  * The "type" portion corresponds to one of the registered key table
  78  * types, while the "residual" portion is specific to the
  79  * particular keytab type.
  80  */
  81
  82 krb5_error_code KRB5_CALLCONV
  83 krb5_kt_resolve (krb5_context context, const char *name, krb5_keytab *ktid)
  84 {
  85     struct krb5_kt_typelist *tlist;
  86     char *pfx;
  87     unsigned int pfxlen;
  88     const char *cp, *resid;
  89
  90     cp = strchr (name, ':');
  91     if (!cp) {
  92             return (*krb5_kt_dfl_ops.resolve)(context, name, ktid);
  93     }
  94
  95     pfxlen = cp - name;
  96     resid = name + pfxlen + 1;
  97
  98     pfx = malloc (pfxlen+1);
  99     if (!pfx)
 100         return ENOMEM;
 101
 102     memcpy (pfx, name, pfxlen);
 103     pfx[pfxlen] = '\0';
 104
 105     *ktid = (krb5_keytab) 0;
 106
 107     for (tlist = kt_typehead; tlist; tlist = tlist->next) {
 108         if (strcmp (tlist->ops->prefix, pfx) == 0) {
 109             free(pfx);
 110             return (*tlist->ops->resolve)(context, resid, ktid);
 111         }
 112     }
 113     free(pfx);
 114     return KRB5_KT_UNKNOWN_TYPE;
 115 }
 116
 117 /*
 118  * Routines to deal with externalizingt krb5_keytab.
 119  *      krb5_keytab_size();
 120  *      krb5_keytab_externalize();
 121  *      krb5_keytab_internalize();
 122  */
 123 static krb5_error_code krb5_keytab_size
 124         (krb5_context, krb5_pointer, size_t *);
 125 static krb5_error_code krb5_keytab_externalize
 126         (krb5_context, krb5_pointer, krb5_octet **, size_t *);
 127 static krb5_error_code krb5_keytab_internalize
 128         (krb5_context,krb5_pointer *, krb5_octet **, size_t *);
 129
 130 /*
 131  * Serialization entry for this type.
 132  */
 133 static const krb5_ser_entry krb5_keytab_ser_entry = {
 134     KV5M_KEYTAB,                        /* Type                 */
 135     krb5_keytab_size,                   /* Sizer routine        */
 136     krb5_keytab_externalize,            /* Externalize routine  */
 137     krb5_keytab_internalize             /* Internalize routine  */
 138 };
 139
 140 static krb5_error_code
 141 krb5_keytab_size(krb5_context kcontext, krb5_pointer arg, size_t *sizep)
 142 {
 143     krb5_error_code     kret;
 144     krb5_keytab         keytab;
 145     krb5_ser_handle     shandle;
 146
 147     kret = EINVAL;
 148     if ((keytab = (krb5_keytab) arg) &&
 149         keytab->ops &&
 150         (shandle = (krb5_ser_handle) keytab->ops->serializer) &&
 151         shandle->sizer)
 152         kret = (*shandle->sizer)(kcontext, arg, sizep);
 153     return(kret);
 154 }
 155
 156 static krb5_error_code
 157 krb5_keytab_externalize(krb5_context kcontext, krb5_pointer arg, krb5_octet **buffer, size_t *lenremain)
 158 {
 159     krb5_error_code     kret;
 160     krb5_keytab         keytab;
 161     krb5_ser_handle     shandle;
 162
 163     kret = EINVAL;
 164     if ((keytab = (krb5_keytab) arg) &&
 165         keytab->ops &&
 166         (shandle = (krb5_ser_handle) keytab->ops->serializer) &&
 167         shandle->externalizer)
 168         kret = (*shandle->externalizer)(kcontext, arg, buffer, lenremain);
 169     return(kret);
 170 }
 171
 172 static krb5_error_code
 173 krb5_keytab_internalize(krb5_context kcontext, krb5_pointer *argp, krb5_octet **buffer, size_t *lenremain)
 174 {
 175     krb5_error_code     kret;
 176     krb5_ser_handle     shandle;
 177
 178     kret = EINVAL;
 179     if ((shandle = (krb5_ser_handle) krb5_kt_dfl_ops.serializer) &&
 180         shandle->internalizer)
 181         kret = (*shandle->internalizer)(kcontext, argp, buffer, lenremain);
 182     return(kret);
 183 }
 184
 185 krb5_error_code KRB5_CALLCONV
 186 krb5_ser_keytab_init(krb5_context kcontext)
 187 {
 188     return(krb5_register_serializer(kcontext, &krb5_keytab_ser_entry));
 189 }