1 /* 2 * Copyright (c) 1997 - 1999 Kungliga Tekniska Högskolan 3 * (Royal Institute of Technology, Stockholm, Sweden). 4 * All rights reserved. 5 * 6 * Redistribution and use in source and binary forms, with or without 7 * modification, are permitted provided that the following conditions 8 * are met: 9 * 10 * 1. Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer. 12 * 13 * 2. Redistributions in binary form must reproduce the above copyright 14 * notice, this list of conditions and the following disclaimer in the 15 * documentation and/or other materials provided with the distribution. 16 * 17 * 3. Neither the name of the Institute nor the names of its contributors 18 * may be used to endorse or promote products derived from this software 19 * without specific prior written permission. 20 * 21 * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND 22 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 23 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 24 * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE 25 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 26 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 27 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 28 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 29 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 30 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 31 * SUCH DAMAGE. 32 */ 33 34 #include "kadm5_locl.h" 35 36 RCSID("$Id$"); 37 38 kadm5_ret_t 39 kadm5_store_key_data(krb5_storage *sp, 40 krb5_key_data *key) 41 { 42 krb5_data c; 43 krb5_store_int32(sp, key->key_data_ver); 44 krb5_store_int32(sp, key->key_data_kvno); 45 krb5_store_int32(sp, key->key_data_type[0]); 46 c.length = key->key_data_length[0]; 47 c.data = key->key_data_contents[0]; 48 krb5_store_data(sp, c); 49 krb5_store_int32(sp, key->key_data_type[1]); 50 c.length = key->key_data_length[1]; 51 c.data = key->key_data_contents[1]; 52 krb5_store_data(sp, c); 53 return 0; 54 } 55 56 kadm5_ret_t 57 kadm5_ret_key_data(krb5_storage *sp, 58 krb5_key_data *key) 59 { 60 krb5_data c; 61 int32_t tmp; 62 krb5_ret_int32(sp, &tmp); 63 key->key_data_ver = tmp; 64 krb5_ret_int32(sp, &tmp); 65 key->key_data_kvno = tmp; 66 krb5_ret_int32(sp, &tmp); 67 key->key_data_type[0] = tmp; 68 krb5_ret_data(sp, &c); 69 key->key_data_length[0] = c.length; 70 key->key_data_contents[0] = c.data; 71 krb5_ret_int32(sp, &tmp); 72 key->key_data_type[1] = tmp; 73 krb5_ret_data(sp, &c); 74 key->key_data_length[1] = c.length; 75 key->key_data_contents[1] = c.data; 76 return 0; 77 } 78 79 kadm5_ret_t 80 kadm5_store_tl_data(krb5_storage *sp, 81 krb5_tl_data *tl) 82 { 83 krb5_data c; 84 krb5_store_int32(sp, tl->tl_data_type); 85 c.length = tl->tl_data_length; 86 c.data = tl->tl_data_contents; 87 krb5_store_data(sp, c); 88 return 0; 89 } 90 91 kadm5_ret_t 92 kadm5_ret_tl_data(krb5_storage *sp, 93 krb5_tl_data *tl) 94 { 95 krb5_data c; 96 int32_t tmp; 97 krb5_ret_int32(sp, &tmp); 98 tl->tl_data_type = tmp; 99 krb5_ret_data(sp, &c); 100 tl->tl_data_length = c.length; 101 tl->tl_data_contents = c.data; 102 return 0; 103 } 104 105 static kadm5_ret_t 106 store_principal_ent(krb5_storage *sp, 107 kadm5_principal_ent_t princ, 108 uint32_t mask) 109 { 110 int i; 111 112 if (mask & KADM5_PRINCIPAL) 113 krb5_store_principal(sp, princ->principal); 114 if (mask & KADM5_PRINC_EXPIRE_TIME) 115 krb5_store_int32(sp, princ->princ_expire_time); 116 if (mask & KADM5_PW_EXPIRATION) 117 krb5_store_int32(sp, princ->pw_expiration); 118 if (mask & KADM5_LAST_PWD_CHANGE) 119 krb5_store_int32(sp, princ->last_pwd_change); 120 if (mask & KADM5_MAX_LIFE) 121 krb5_store_int32(sp, princ->max_life); 122 if (mask & KADM5_MOD_NAME) { 123 krb5_store_int32(sp, princ->mod_name != NULL); 124 if(princ->mod_name) 125 krb5_store_principal(sp, princ->mod_name); 126 } 127 if (mask & KADM5_MOD_TIME) 128 krb5_store_int32(sp, princ->mod_date); 129 if (mask & KADM5_ATTRIBUTES) 130 krb5_store_int32(sp, princ->attributes); 131 if (mask & KADM5_KVNO) 132 krb5_store_int32(sp, princ->kvno); 133 if (mask & KADM5_MKVNO) 134 krb5_store_int32(sp, princ->mkvno); 135 if (mask & KADM5_POLICY) { 136 krb5_store_int32(sp, princ->policy != NULL); 137 if(princ->policy) 138 krb5_store_string(sp, princ->policy); 139 } 140 if (mask & KADM5_AUX_ATTRIBUTES) 141 krb5_store_int32(sp, princ->aux_attributes); 142 if (mask & KADM5_MAX_RLIFE) 143 krb5_store_int32(sp, princ->max_renewable_life); 144 if (mask & KADM5_LAST_SUCCESS) 145 krb5_store_int32(sp, princ->last_success); 146 if (mask & KADM5_LAST_FAILED) 147 krb5_store_int32(sp, princ->last_failed); 148 if (mask & KADM5_FAIL_AUTH_COUNT) 149 krb5_store_int32(sp, princ->fail_auth_count); 150 if (mask & KADM5_KEY_DATA) { 151 krb5_store_int32(sp, princ->n_key_data); 152 for(i = 0; i < princ->n_key_data; i++) 153 kadm5_store_key_data(sp, &princ->key_data[i]); 154 } 155 if (mask & KADM5_TL_DATA) { 156 krb5_tl_data *tp; 157 158 krb5_store_int32(sp, princ->n_tl_data); 159 for(tp = princ->tl_data; tp; tp = tp->tl_data_next) 160 kadm5_store_tl_data(sp, tp); 161 } 162 return 0; 163 } 164 165 166 kadm5_ret_t 167 kadm5_store_principal_ent(krb5_storage *sp, 168 kadm5_principal_ent_t princ) 169 { 170 return store_principal_ent (sp, princ, ~0); 171 } 172 173 kadm5_ret_t 174 kadm5_store_principal_ent_mask(krb5_storage *sp, 175 kadm5_principal_ent_t princ, 176 uint32_t mask) 177 { 178 krb5_store_int32(sp, mask); 179 return store_principal_ent (sp, princ, mask); 180 } 181 182 static kadm5_ret_t 183 ret_principal_ent(krb5_storage *sp, 184 kadm5_principal_ent_t princ, 185 uint32_t mask) 186 { 187 int i; 188 int32_t tmp; 189 190 if (mask & KADM5_PRINCIPAL) 191 krb5_ret_principal(sp, &princ->principal); 192 193 if (mask & KADM5_PRINC_EXPIRE_TIME) { 194 krb5_ret_int32(sp, &tmp); 195 princ->princ_expire_time = tmp; 196 } 197 if (mask & KADM5_PW_EXPIRATION) { 198 krb5_ret_int32(sp, &tmp); 199 princ->pw_expiration = tmp; 200 } 201 if (mask & KADM5_LAST_PWD_CHANGE) { 202 krb5_ret_int32(sp, &tmp); 203 princ->last_pwd_change = tmp; 204 } 205 if (mask & KADM5_MAX_LIFE) { 206 krb5_ret_int32(sp, &tmp); 207 princ->max_life = tmp; 208 } 209 if (mask & KADM5_MOD_NAME) { 210 krb5_ret_int32(sp, &tmp); 211 if(tmp) 212 krb5_ret_principal(sp, &princ->mod_name); 213 else 214 princ->mod_name = NULL; 215 } 216 if (mask & KADM5_MOD_TIME) { 217 krb5_ret_int32(sp, &tmp); 218 princ->mod_date = tmp; 219 } 220 if (mask & KADM5_ATTRIBUTES) { 221 krb5_ret_int32(sp, &tmp); 222 princ->attributes = tmp; 223 } 224 if (mask & KADM5_KVNO) { 225 krb5_ret_int32(sp, &tmp); 226 princ->kvno = tmp; 227 } 228 if (mask & KADM5_MKVNO) { 229 krb5_ret_int32(sp, &tmp); 230 princ->mkvno = tmp; 231 } 232 if (mask & KADM5_POLICY) { 233 krb5_ret_int32(sp, &tmp); 234 if(tmp) 235 krb5_ret_string(sp, &princ->policy); 236 else 237 princ->policy = NULL; 238 } 239 if (mask & KADM5_AUX_ATTRIBUTES) { 240 krb5_ret_int32(sp, &tmp); 241 princ->aux_attributes = tmp; 242 } 243 if (mask & KADM5_MAX_RLIFE) { 244 krb5_ret_int32(sp, &tmp); 245 princ->max_renewable_life = tmp; 246 } 247 if (mask & KADM5_LAST_SUCCESS) { 248 krb5_ret_int32(sp, &tmp); 249 princ->last_success = tmp; 250 } 251 if (mask & KADM5_LAST_FAILED) { 252 krb5_ret_int32(sp, &tmp); 253 princ->last_failed = tmp; 254 } 255 if (mask & KADM5_FAIL_AUTH_COUNT) { 256 krb5_ret_int32(sp, &tmp); 257 princ->fail_auth_count = tmp; 258 } 259 if (mask & KADM5_KEY_DATA) { 260 krb5_ret_int32(sp, &tmp); 261 princ->n_key_data = tmp; 262 princ->key_data = malloc(princ->n_key_data * sizeof(*princ->key_data)); 263 if (princ->key_data == NULL && princ->n_key_data != 0) 264 return ENOMEM; 265 for(i = 0; i < princ->n_key_data; i++) 266 kadm5_ret_key_data(sp, &princ->key_data[i]); 267 } 268 if (mask & KADM5_TL_DATA) { 269 krb5_ret_int32(sp, &tmp); 270 princ->n_tl_data = tmp; 271 princ->tl_data = NULL; 272 for(i = 0; i < princ->n_tl_data; i++){ 273 krb5_tl_data *tp = malloc(sizeof(*tp)); 274 if (tp == NULL) 275 return ENOMEM; 276 kadm5_ret_tl_data(sp, tp); 277 tp->tl_data_next = princ->tl_data; 278 princ->tl_data = tp; 279 } 280 } 281 return 0; 282 } 283 284 kadm5_ret_t 285 kadm5_ret_principal_ent(krb5_storage *sp, 286 kadm5_principal_ent_t princ) 287 { 288 return ret_principal_ent (sp, princ, ~0); 289 } 290 291 kadm5_ret_t 292 kadm5_ret_principal_ent_mask(krb5_storage *sp, 293 kadm5_principal_ent_t princ, 294 uint32_t *mask) 295 { 296 int32_t tmp; 297 298 krb5_ret_int32 (sp, &tmp); 299 *mask = tmp; 300 return ret_principal_ent (sp, princ, *mask); 301 } 302 303 kadm5_ret_t 304 _kadm5_marshal_params(krb5_context context, 305 kadm5_config_params *params, 306 krb5_data *out) 307 { 308 krb5_storage *sp = krb5_storage_emem(); 309 310 krb5_store_int32(sp, params->mask & (KADM5_CONFIG_REALM)); 311 312 if(params->mask & KADM5_CONFIG_REALM) 313 krb5_store_string(sp, params->realm); 314 krb5_storage_to_data(sp, out); 315 krb5_storage_free(sp); 316 317 return 0; 318 } 319 320 kadm5_ret_t 321 _kadm5_unmarshal_params(krb5_context context, 322 krb5_data *in, 323 kadm5_config_params *params) 324 { 325 krb5_error_code ret; 326 krb5_storage *sp; 327 int32_t mask; 328 329 sp = krb5_storage_from_data(in); 330 if (sp == NULL) 331 return ENOMEM; 332 333 ret = krb5_ret_int32(sp, &mask); 334 if (ret) 335 goto out; 336 params->mask = mask; 337 338 if(params->mask & KADM5_CONFIG_REALM) 339 ret = krb5_ret_string(sp, ¶ms->realm); 340 out: 341 krb5_storage_free(sp); 342 343 return ret; 344 } 345