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