source4/heimdal/lib/krb5/store.c

   1 /*
   2  * Copyright (c) 1997-2004 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 "krb5_locl.h"
  35 #include "store-int.h"
  36
  37 RCSID("$Id: store.c,v 1.51 2006/04/07 22:23:20 lha Exp $");
  38
  39 #define BYTEORDER_IS(SP, V) (((SP)->flags & KRB5_STORAGE_BYTEORDER_MASK) == (V))
  40 #define BYTEORDER_IS_LE(SP) BYTEORDER_IS((SP), KRB5_STORAGE_BYTEORDER_LE)
  41 #define BYTEORDER_IS_BE(SP) BYTEORDER_IS((SP), KRB5_STORAGE_BYTEORDER_BE)
  42 #define BYTEORDER_IS_HOST(SP) (BYTEORDER_IS((SP), KRB5_STORAGE_BYTEORDER_HOST) || \
  43                                krb5_storage_is_flags((SP), KRB5_STORAGE_HOST_BYTEORDER))
  44
  45 void KRB5_LIB_FUNCTION
  46 krb5_storage_set_flags(krb5_storage *sp, krb5_flags flags)
  47 {
  48     sp->flags |= flags;
  49 }
  50
  51 void KRB5_LIB_FUNCTION
  52 krb5_storage_clear_flags(krb5_storage *sp, krb5_flags flags)
  53 {
  54     sp->flags &= ~flags;
  55 }
  56
  57 krb5_boolean KRB5_LIB_FUNCTION
  58 krb5_storage_is_flags(krb5_storage *sp, krb5_flags flags)
  59 {
  60     return (sp->flags & flags) == flags;
  61 }
  62
  63 void KRB5_LIB_FUNCTION
  64 krb5_storage_set_byteorder(krb5_storage *sp, krb5_flags byteorder)
  65 {
  66     sp->flags &= ~KRB5_STORAGE_BYTEORDER_MASK;
  67     sp->flags |= byteorder;
  68 }
  69
  70 krb5_flags KRB5_LIB_FUNCTION
  71 krb5_storage_get_byteorder(krb5_storage *sp, krb5_flags byteorder)
  72 {
  73     return sp->flags & KRB5_STORAGE_BYTEORDER_MASK;
  74 }
  75
  76 off_t KRB5_LIB_FUNCTION
  77 krb5_storage_seek(krb5_storage *sp, off_t offset, int whence)
  78 {
  79     return (*sp->seek)(sp, offset, whence);
  80 }
  81
  82 krb5_ssize_t KRB5_LIB_FUNCTION
  83 krb5_storage_read(krb5_storage *sp, void *buf, size_t len)
  84 {
  85     return sp->fetch(sp, buf, len);
  86 }
  87
  88 krb5_ssize_t KRB5_LIB_FUNCTION
  89 krb5_storage_write(krb5_storage *sp, const void *buf, size_t len)
  90 {
  91     return sp->store(sp, buf, len);
  92 }
  93
  94 void KRB5_LIB_FUNCTION
  95 krb5_storage_set_eof_code(krb5_storage *sp, int code)
  96 {
  97     sp->eof_code = code;
  98 }
  99
 100 krb5_ssize_t KRB5_LIB_FUNCTION
 101 _krb5_put_int(void *buffer, unsigned long value, size_t size)
 102 {
 103     unsigned char *p = buffer;
 104     int i;
 105     for (i = size - 1; i >= 0; i--) {
 106         p[i] = value & 0xff;
 107         value >>= 8;
 108     }
 109     return size;
 110 }
 111
 112 krb5_ssize_t KRB5_LIB_FUNCTION
 113 _krb5_get_int(void *buffer, unsigned long *value, size_t size)
 114 {
 115     unsigned char *p = buffer;
 116     unsigned long v = 0;
 117     int i;
 118     for (i = 0; i < size; i++)
 119         v = (v << 8) + p[i];
 120     *value = v;
 121     return size;
 122 }
 123
 124 krb5_error_code KRB5_LIB_FUNCTION
 125 krb5_storage_free(krb5_storage *sp)
 126 {
 127     if(sp->free)
 128         (*sp->free)(sp);
 129     free(sp->data);
 130     free(sp);
 131     return 0;
 132 }
 133
 134 krb5_error_code KRB5_LIB_FUNCTION
 135 krb5_storage_to_data(krb5_storage *sp, krb5_data *data)
 136 {
 137     off_t pos;
 138     size_t size;
 139     krb5_error_code ret;
 140
 141     pos = sp->seek(sp, 0, SEEK_CUR);
 142     size = (size_t)sp->seek(sp, 0, SEEK_END);
 143     ret = krb5_data_alloc (data, size);
 144     if (ret) {
 145         sp->seek(sp, pos, SEEK_SET);
 146         return ret;
 147     }
 148     if (size) {
 149         sp->seek(sp, 0, SEEK_SET);
 150         sp->fetch(sp, data->data, data->length);
 151         sp->seek(sp, pos, SEEK_SET);
 152     }
 153     return 0;
 154 }
 155
 156 static krb5_error_code
 157 krb5_store_int(krb5_storage *sp,
 158                int32_t value,
 159                size_t len)
 160 {
 161     int ret;
 162     unsigned char v[16];
 163
 164     if(len > sizeof(v))
 165         return EINVAL;
 166     _krb5_put_int(v, value, len);
 167     ret = sp->store(sp, v, len);
 168     if (ret != len)
 169         return (ret<0)?errno:sp->eof_code;
 170     return 0;
 171 }
 172
 173 krb5_error_code KRB5_LIB_FUNCTION
 174 krb5_store_int32(krb5_storage *sp,
 175                  int32_t value)
 176 {
 177     if(BYTEORDER_IS_HOST(sp))
 178         value = htonl(value);
 179     else if(BYTEORDER_IS_LE(sp))
 180         value = bswap32(value);
 181     return krb5_store_int(sp, value, 4);
 182 }
 183
 184 static krb5_error_code
 185 krb5_ret_int(krb5_storage *sp,
 186              int32_t *value,
 187              size_t len)
 188 {
 189     int ret;
 190     unsigned char v[4];
 191     unsigned long w;
 192     ret = sp->fetch(sp, v, len);
 193     if(ret != len)
 194         return (ret<0)?errno:sp->eof_code;
 195     _krb5_get_int(v, &w, len);
 196     *value = w;
 197     return 0;
 198 }
 199
 200 krb5_error_code KRB5_LIB_FUNCTION
 201 krb5_ret_int32(krb5_storage *sp,
 202                int32_t *value)
 203 {
 204     krb5_error_code ret = krb5_ret_int(sp, value, 4);
 205     if(ret)
 206         return ret;
 207     if(BYTEORDER_IS_HOST(sp))
 208         *value = htonl(*value);
 209     else if(BYTEORDER_IS_LE(sp))
 210         *value = bswap32(*value);
 211     return 0;
 212 }
 213
 214 krb5_error_code KRB5_LIB_FUNCTION
 215 krb5_store_int16(krb5_storage *sp,
 216                  int16_t value)
 217 {
 218     if(BYTEORDER_IS_HOST(sp))
 219         value = htons(value);
 220     else if(BYTEORDER_IS_LE(sp))
 221         value = bswap16(value);
 222     return krb5_store_int(sp, value, 2);
 223 }
 224
 225 krb5_error_code KRB5_LIB_FUNCTION
 226 krb5_ret_int16(krb5_storage *sp,
 227                int16_t *value)
 228 {
 229     int32_t v;
 230     int ret;
 231     ret = krb5_ret_int(sp, &v, 2);
 232     if(ret)
 233         return ret;
 234     *value = v;
 235     if(BYTEORDER_IS_HOST(sp))
 236         *value = htons(*value);
 237     else if(BYTEORDER_IS_LE(sp))
 238         *value = bswap16(*value);
 239     return 0;
 240 }
 241
 242 krb5_error_code KRB5_LIB_FUNCTION
 243 krb5_store_int8(krb5_storage *sp,
 244                 int8_t value)
 245 {
 246     int ret;
 247
 248     ret = sp->store(sp, &value, sizeof(value));
 249     if (ret != sizeof(value))
 250         return (ret<0)?errno:sp->eof_code;
 251     return 0;
 252 }
 253
 254 krb5_error_code KRB5_LIB_FUNCTION
 255 krb5_ret_int8(krb5_storage *sp,
 256               int8_t *value)
 257 {
 258     int ret;
 259
 260     ret = sp->fetch(sp, value, sizeof(*value));
 261     if (ret != sizeof(*value))
 262         return (ret<0)?errno:sp->eof_code;
 263     return 0;
 264 }
 265
 266 krb5_error_code KRB5_LIB_FUNCTION
 267 krb5_store_data(krb5_storage *sp,
 268                 krb5_data data)
 269 {
 270     int ret;
 271     ret = krb5_store_int32(sp, data.length);
 272     if(ret < 0)
 273         return ret;
 274     ret = sp->store(sp, data.data, data.length);
 275     if(ret != data.length){
 276         if(ret < 0)
 277             return errno;
 278         return sp->eof_code;
 279     }
 280     return 0;
 281 }
 282
 283 krb5_error_code KRB5_LIB_FUNCTION
 284 krb5_ret_data(krb5_storage *sp,
 285               krb5_data *data)
 286 {
 287     int ret;
 288     int32_t size;
 289
 290     ret = krb5_ret_int32(sp, &size);
 291     if(ret)
 292         return ret;
 293     ret = krb5_data_alloc (data, size);
 294     if (ret)
 295         return ret;
 296     if (size) {
 297         ret = sp->fetch(sp, data->data, size);
 298         if(ret != size)
 299             return (ret < 0)? errno : sp->eof_code;
 300     }
 301     return 0;
 302 }
 303
 304 krb5_error_code KRB5_LIB_FUNCTION
 305 krb5_store_string(krb5_storage *sp, const char *s)
 306 {
 307     krb5_data data;
 308     data.length = strlen(s);
 309     data.data = rk_UNCONST(s);
 310     return krb5_store_data(sp, data);
 311 }
 312
 313 krb5_error_code KRB5_LIB_FUNCTION
 314 krb5_ret_string(krb5_storage *sp,
 315                 char **string)
 316 {
 317     int ret;
 318     krb5_data data;
 319     ret = krb5_ret_data(sp, &data);
 320     if(ret)
 321         return ret;
 322     *string = realloc(data.data, data.length + 1);
 323     if(*string == NULL){
 324         free(data.data);
 325         return ENOMEM;
 326     }
 327     (*string)[data.length] = 0;
 328     return 0;
 329 }
 330
 331 krb5_error_code KRB5_LIB_FUNCTION
 332 krb5_store_stringz(krb5_storage *sp, const char *s)
 333 {
 334     size_t len = strlen(s) + 1;
 335     ssize_t ret;
 336
 337     ret = sp->store(sp, s, len);
 338     if(ret != len) {
 339         if(ret < 0)
 340             return ret;
 341         else
 342             return sp->eof_code;
 343     }
 344     return 0;
 345 }
 346
 347 krb5_error_code KRB5_LIB_FUNCTION
 348 krb5_ret_stringz(krb5_storage *sp,
 349                 char **string)
 350 {
 351     char c;
 352     char *s = NULL;
 353     size_t len = 0;
 354     ssize_t ret;
 355
 356     while((ret = sp->fetch(sp, &c, 1)) == 1){
 357         char *tmp;
 358
 359         len++;
 360         tmp = realloc (s, len);
 361         if (tmp == NULL) {
 362             free (s);
 363             return ENOMEM;
 364         }
 365         s = tmp;
 366         s[len - 1] = c;
 367         if(c == 0)
 368             break;
 369     }
 370     if(ret != 1){
 371         free(s);
 372         if(ret == 0)
 373             return sp->eof_code;
 374         return ret;
 375     }
 376     *string = s;
 377     return 0;
 378 }
 379
 380
 381 krb5_error_code KRB5_LIB_FUNCTION
 382 krb5_store_principal(krb5_storage *sp,
 383                      krb5_principal p)
 384 {
 385     int i;
 386     int ret;
 387
 388     if(!krb5_storage_is_flags(sp, KRB5_STORAGE_PRINCIPAL_NO_NAME_TYPE)) {
 389     ret = krb5_store_int32(sp, p->name.name_type);
 390     if(ret) return ret;
 391     }
 392     if(krb5_storage_is_flags(sp, KRB5_STORAGE_PRINCIPAL_WRONG_NUM_COMPONENTS))
 393         ret = krb5_store_int32(sp, p->name.name_string.len + 1);
 394     else
 395     ret = krb5_store_int32(sp, p->name.name_string.len);
 396
 397     if(ret) return ret;
 398     ret = krb5_store_string(sp, p->realm);
 399     if(ret) return ret;
 400     for(i = 0; i < p->name.name_string.len; i++){
 401         ret = krb5_store_string(sp, p->name.name_string.val[i]);
 402         if(ret) return ret;
 403     }
 404     return 0;
 405 }
 406
 407 krb5_error_code KRB5_LIB_FUNCTION
 408 krb5_ret_principal(krb5_storage *sp,
 409                    krb5_principal *princ)
 410 {
 411     int i;
 412     int ret;
 413     krb5_principal p;
 414     int32_t type;
 415     int32_t ncomp;
 416
 417     p = calloc(1, sizeof(*p));
 418     if(p == NULL)
 419         return ENOMEM;
 420
 421     if(krb5_storage_is_flags(sp, KRB5_STORAGE_PRINCIPAL_NO_NAME_TYPE))
 422         type = KRB5_NT_UNKNOWN;
 423     else if((ret = krb5_ret_int32(sp, &type))){
 424         free(p);
 425         return ret;
 426     }
 427     if((ret = krb5_ret_int32(sp, &ncomp))){
 428         free(p);
 429         return ret;
 430     }
 431     if(krb5_storage_is_flags(sp, KRB5_STORAGE_PRINCIPAL_WRONG_NUM_COMPONENTS))
 432         ncomp--;
 433     if (ncomp < 0) {
 434         free(p);
 435         return EINVAL;
 436     }
 437     p->name.name_type = type;
 438     p->name.name_string.len = ncomp;
 439     ret = krb5_ret_string(sp, &p->realm);
 440     if(ret) {
 441         free(p);
 442         return ret;
 443     }
 444     p->name.name_string.val = calloc(ncomp, sizeof(*p->name.name_string.val));
 445     if(p->name.name_string.val == NULL && ncomp != 0){
 446         free(p->realm);
 447         return ENOMEM;
 448     }
 449     for(i = 0; i < ncomp; i++){
 450         ret = krb5_ret_string(sp, &p->name.name_string.val[i]);
 451         if(ret) {
 452             while (i >= 0)
 453                 free(p->name.name_string.val[i--]);
 454             free(p->realm);
 455             free(p);
 456             return ret;
 457         }
 458     }
 459     *princ = p;
 460     return 0;
 461 }
 462
 463 krb5_error_code KRB5_LIB_FUNCTION
 464 krb5_store_keyblock(krb5_storage *sp, krb5_keyblock p)
 465 {
 466     int ret;
 467     ret = krb5_store_int16(sp, p.keytype);
 468     if(ret) return ret;
 469
 470     if(krb5_storage_is_flags(sp, KRB5_STORAGE_KEYBLOCK_KEYTYPE_TWICE)){
 471         /* this should really be enctype, but it is the same as
 472            keytype nowadays */
 473     ret = krb5_store_int16(sp, p.keytype);
 474     if(ret) return ret;
 475     }
 476
 477     ret = krb5_store_data(sp, p.keyvalue);
 478     return ret;
 479 }
 480
 481 krb5_error_code KRB5_LIB_FUNCTION
 482 krb5_ret_keyblock(krb5_storage *sp, krb5_keyblock *p)
 483 {
 484     int ret;
 485     int16_t tmp;
 486
 487     ret = krb5_ret_int16(sp, &tmp);
 488     if(ret) return ret;
 489     p->keytype = tmp;
 490
 491     if(krb5_storage_is_flags(sp, KRB5_STORAGE_KEYBLOCK_KEYTYPE_TWICE)){
 492     ret = krb5_ret_int16(sp, &tmp);
 493     if(ret) return ret;
 494     }
 495
 496     ret = krb5_ret_data(sp, &p->keyvalue);
 497     return ret;
 498 }
 499
 500 krb5_error_code KRB5_LIB_FUNCTION
 501 krb5_store_times(krb5_storage *sp, krb5_times times)
 502 {
 503     int ret;
 504     ret = krb5_store_int32(sp, times.authtime);
 505     if(ret) return ret;
 506     ret = krb5_store_int32(sp, times.starttime);
 507     if(ret) return ret;
 508     ret = krb5_store_int32(sp, times.endtime);
 509     if(ret) return ret;
 510     ret = krb5_store_int32(sp, times.renew_till);
 511     return ret;
 512 }
 513
 514 krb5_error_code KRB5_LIB_FUNCTION
 515 krb5_ret_times(krb5_storage *sp, krb5_times *times)
 516 {
 517     int ret;
 518     int32_t tmp;
 519     ret = krb5_ret_int32(sp, &tmp);
 520     times->authtime = tmp;
 521     if(ret) return ret;
 522     ret = krb5_ret_int32(sp, &tmp);
 523     times->starttime = tmp;
 524     if(ret) return ret;
 525     ret = krb5_ret_int32(sp, &tmp);
 526     times->endtime = tmp;
 527     if(ret) return ret;
 528     ret = krb5_ret_int32(sp, &tmp);
 529     times->renew_till = tmp;
 530     return ret;
 531 }
 532
 533 krb5_error_code KRB5_LIB_FUNCTION
 534 krb5_store_address(krb5_storage *sp, krb5_address p)
 535 {
 536     int ret;
 537     ret = krb5_store_int16(sp, p.addr_type);
 538     if(ret) return ret;
 539     ret = krb5_store_data(sp, p.address);
 540     return ret;
 541 }
 542
 543 krb5_error_code KRB5_LIB_FUNCTION
 544 krb5_ret_address(krb5_storage *sp, krb5_address *adr)
 545 {
 546     int16_t t;
 547     int ret;
 548     ret = krb5_ret_int16(sp, &t);
 549     if(ret) return ret;
 550     adr->addr_type = t;
 551     ret = krb5_ret_data(sp, &adr->address);
 552     return ret;
 553 }
 554
 555 krb5_error_code KRB5_LIB_FUNCTION
 556 krb5_store_addrs(krb5_storage *sp, krb5_addresses p)
 557 {
 558     int i;
 559     int ret;
 560     ret = krb5_store_int32(sp, p.len);
 561     if(ret) return ret;
 562     for(i = 0; i<p.len; i++){
 563         ret = krb5_store_address(sp, p.val[i]);
 564         if(ret) break;
 565     }
 566     return ret;
 567 }
 568
 569 krb5_error_code KRB5_LIB_FUNCTION
 570 krb5_ret_addrs(krb5_storage *sp, krb5_addresses *adr)
 571 {
 572     int i;
 573     int ret;
 574     int32_t tmp;
 575
 576     ret = krb5_ret_int32(sp, &tmp);
 577     if(ret) return ret;
 578     adr->len = tmp;
 579     ALLOC(adr->val, adr->len);
 580     if (adr->val == NULL && adr->len != 0)
 581         return ENOMEM;
 582     for(i = 0; i < adr->len; i++){
 583         ret = krb5_ret_address(sp, &adr->val[i]);
 584         if(ret) break;
 585     }
 586     return ret;
 587 }
 588
 589 krb5_error_code KRB5_LIB_FUNCTION
 590 krb5_store_authdata(krb5_storage *sp, krb5_authdata auth)
 591 {
 592     krb5_error_code ret;
 593     int i;
 594     ret = krb5_store_int32(sp, auth.len);
 595     if(ret) return ret;
 596     for(i = 0; i < auth.len; i++){
 597         ret = krb5_store_int16(sp, auth.val[i].ad_type);
 598         if(ret) break;
 599         ret = krb5_store_data(sp, auth.val[i].ad_data);
 600         if(ret) break;
 601     }
 602     return 0;
 603 }
 604
 605 krb5_error_code KRB5_LIB_FUNCTION
 606 krb5_ret_authdata(krb5_storage *sp, krb5_authdata *auth)
 607 {
 608     krb5_error_code ret;
 609     int32_t tmp;
 610     int16_t tmp2;
 611     int i;
 612     ret = krb5_ret_int32(sp, &tmp);
 613     if(ret) return ret;
 614     ALLOC_SEQ(auth, tmp);
 615     if (auth->val == NULL && tmp != 0)
 616         return ENOMEM;
 617     for(i = 0; i < tmp; i++){
 618         ret = krb5_ret_int16(sp, &tmp2);
 619         if(ret) break;
 620         auth->val[i].ad_type = tmp2;
 621         ret = krb5_ret_data(sp, &auth->val[i].ad_data);
 622         if(ret) break;
 623     }
 624     return ret;
 625 }
 626
 627 static int32_t
 628 bitswap32(int32_t b)
 629 {
 630     int32_t r = 0;
 631     int i;
 632     for (i = 0; i < 32; i++) {
 633         r = r << 1 | (b & 1);
 634         b = b >> 1;
 635     }
 636     return r;
 637 }
 638
 639
 640 /*
 641  *
 642  */
 643
 644 krb5_error_code KRB5_LIB_FUNCTION
 645 krb5_store_creds(krb5_storage *sp, krb5_creds *creds)
 646 {
 647     int ret;
 648
 649     ret = krb5_store_principal(sp, creds->client);
 650     if(ret)
 651         return ret;
 652     ret = krb5_store_principal(sp, creds->server);
 653     if(ret)
 654         return ret;
 655     ret = krb5_store_keyblock(sp, creds->session);
 656     if(ret)
 657         return ret;
 658     ret = krb5_store_times(sp, creds->times);
 659     if(ret)
 660         return ret;
 661     ret = krb5_store_int8(sp, creds->second_ticket.length != 0); /* is_skey */
 662     if(ret)
 663         return ret;
 664
 665     if(krb5_storage_is_flags(sp, KRB5_STORAGE_CREDS_FLAGS_WRONG_BITORDER))
 666         ret = krb5_store_int32(sp, creds->flags.i);
 667     else
 668         ret = krb5_store_int32(sp, bitswap32(TicketFlags2int(creds->flags.b)));
 669     if(ret)
 670         return ret;
 671
 672     ret = krb5_store_addrs(sp, creds->addresses);
 673     if(ret)
 674         return ret;
 675     ret = krb5_store_authdata(sp, creds->authdata);
 676     if(ret)
 677         return ret;
 678     ret = krb5_store_data(sp, creds->ticket);
 679     if(ret)
 680         return ret;
 681     ret = krb5_store_data(sp, creds->second_ticket);
 682     return ret;
 683 }
 684
 685 krb5_error_code KRB5_LIB_FUNCTION
 686 krb5_ret_creds(krb5_storage *sp, krb5_creds *creds)
 687 {
 688     krb5_error_code ret;
 689     int8_t dummy8;
 690     int32_t dummy32;
 691
 692     memset(creds, 0, sizeof(*creds));
 693     ret = krb5_ret_principal (sp,  &creds->client);
 694     if(ret) goto cleanup;
 695     ret = krb5_ret_principal (sp,  &creds->server);
 696     if(ret) goto cleanup;
 697     ret = krb5_ret_keyblock (sp,  &creds->session);
 698     if(ret) goto cleanup;
 699     ret = krb5_ret_times (sp,  &creds->times);
 700     if(ret) goto cleanup;
 701     ret = krb5_ret_int8 (sp,  &dummy8);
 702     if(ret) goto cleanup;
 703     ret = krb5_ret_int32 (sp,  &dummy32);
 704     if(ret) goto cleanup;
 705     /*
 706      * Runtime detect the what is the higher bits of the bitfield. If
 707      * any of the higher bits are set in the input data, its either a
 708      * new ticket flag (and this code need to be removed), or its a
 709      * MIT cache (or new Heimdal cache), lets change it to our current
 710      * format.
 711      */
 712     {
 713         u_int32_t mask = 0xffff0000;
 714         creds->flags.i = 0;
 715         creds->flags.b.anonymous = 1;
 716         if (creds->flags.i & mask)
 717             mask = ~mask;
 718         if (dummy32 & mask)
 719             dummy32 = bitswap32(dummy32);
 720     }
 721     creds->flags.i = dummy32;
 722     ret = krb5_ret_addrs (sp,  &creds->addresses);
 723     if(ret) goto cleanup;
 724     ret = krb5_ret_authdata (sp,  &creds->authdata);
 725     if(ret) goto cleanup;
 726     ret = krb5_ret_data (sp,  &creds->ticket);
 727     if(ret) goto cleanup;
 728     ret = krb5_ret_data (sp,  &creds->second_ticket);
 729 cleanup:
 730     if(ret) {
 731 #if 0
 732         krb5_free_cred_contents(context, creds); /* XXX */
 733 #endif
 734     }
 735     return ret;
 736 }
 737
 738 #define SC_CLIENT_PRINCIPAL         0x0001
 739 #define SC_SERVER_PRINCIPAL         0x0002
 740 #define SC_SESSION_KEY              0x0004
 741 #define SC_TICKET                   0x0008
 742 #define SC_SECOND_TICKET            0x0010
 743 #define SC_AUTHDATA                 0x0020
 744 #define SC_ADDRESSES                0x0040
 745
 746 /*
 747  *
 748  */
 749
 750 krb5_error_code KRB5_LIB_FUNCTION
 751 krb5_store_creds_tag(krb5_storage *sp, krb5_creds *creds)
 752 {
 753     int ret;
 754     int32_t header = 0;
 755
 756     if (creds->client)
 757         header |= SC_CLIENT_PRINCIPAL;
 758     if (creds->server)
 759         header |= SC_SERVER_PRINCIPAL;
 760     if (creds->session.keyvalue.data)
 761         header |= SC_SESSION_KEY;
 762     if (creds->ticket.data)
 763         header |= SC_TICKET;
 764     if (creds->second_ticket.length)
 765         header |= SC_SECOND_TICKET;
 766     if (creds->authdata.len)
 767         header |= SC_AUTHDATA;
 768     if (creds->addresses.len)
 769         header |= SC_ADDRESSES;
 770
 771     ret = krb5_store_int32(sp, header);
 772
 773     if (creds->client) {
 774         ret = krb5_store_principal(sp, creds->client);
 775         if(ret)
 776             return ret;
 777     }
 778
 779     if (creds->server) {
 780         ret = krb5_store_principal(sp, creds->server);
 781         if(ret)
 782             return ret;
 783     }
 784
 785     if (creds->session.keyvalue.data) {
 786         ret = krb5_store_keyblock(sp, creds->session);
 787         if(ret)
 788             return ret;
 789     }
 790
 791     ret = krb5_store_times(sp, creds->times);
 792     if(ret)
 793         return ret;
 794     ret = krb5_store_int8(sp, creds->second_ticket.length != 0); /* is_skey */
 795     if(ret)
 796         return ret;
 797
 798     ret = krb5_store_int32(sp, bitswap32(TicketFlags2int(creds->flags.b)));
 799     if(ret)
 800         return ret;
 801
 802     if (creds->addresses.len) {
 803         ret = krb5_store_addrs(sp, creds->addresses);
 804         if(ret)
 805             return ret;
 806     }
 807
 808     if (creds->authdata.len) {
 809         ret = krb5_store_authdata(sp, creds->authdata);
 810         if(ret)
 811             return ret;
 812     }
 813
 814     if (creds->ticket.data) {
 815         ret = krb5_store_data(sp, creds->ticket);
 816         if(ret)
 817             return ret;
 818     }
 819
 820     if (creds->second_ticket.data) {
 821         ret = krb5_store_data(sp, creds->second_ticket);
 822         if (ret)
 823             return ret;
 824     }
 825
 826     return ret;
 827 }
 828
 829 krb5_error_code KRB5_LIB_FUNCTION
 830 krb5_ret_creds_tag(krb5_storage *sp,
 831                    krb5_creds *creds)
 832 {
 833     krb5_error_code ret;
 834     int8_t dummy8;
 835     int32_t dummy32, header;
 836
 837     memset(creds, 0, sizeof(*creds));
 838
 839     ret = krb5_ret_int32 (sp, &header);
 840     if (ret) goto cleanup;
 841
 842     if (header & SC_CLIENT_PRINCIPAL) {
 843         ret = krb5_ret_principal (sp,  &creds->client);
 844         if(ret) goto cleanup;
 845     }
 846     if (header & SC_SERVER_PRINCIPAL) {
 847         ret = krb5_ret_principal (sp,  &creds->server);
 848         if(ret) goto cleanup;
 849     }
 850     if (header & SC_SESSION_KEY) {
 851         ret = krb5_ret_keyblock (sp,  &creds->session);
 852         if(ret) goto cleanup;
 853     }
 854     ret = krb5_ret_times (sp,  &creds->times);
 855     if(ret) goto cleanup;
 856     ret = krb5_ret_int8 (sp,  &dummy8);
 857     if(ret) goto cleanup;
 858     ret = krb5_ret_int32 (sp,  &dummy32);
 859     if(ret) goto cleanup;
 860     /*
 861      * Runtime detect the what is the higher bits of the bitfield. If
 862      * any of the higher bits are set in the input data, its either a
 863      * new ticket flag (and this code need to be removed), or its a
 864      * MIT cache (or new Heimdal cache), lets change it to our current
 865      * format.
 866      */
 867     {
 868         u_int32_t mask = 0xffff0000;
 869         creds->flags.i = 0;
 870         creds->flags.b.anonymous = 1;
 871         if (creds->flags.i & mask)
 872             mask = ~mask;
 873         if (dummy32 & mask)
 874             dummy32 = bitswap32(dummy32);
 875     }
 876     creds->flags.i = dummy32;
 877     if (header & SC_ADDRESSES) {
 878         ret = krb5_ret_addrs (sp,  &creds->addresses);
 879         if(ret) goto cleanup;
 880     }
 881     if (header & SC_AUTHDATA) {
 882         ret = krb5_ret_authdata (sp,  &creds->authdata);
 883         if(ret) goto cleanup;
 884     }
 885     if (header & SC_TICKET) {
 886         ret = krb5_ret_data (sp,  &creds->ticket);
 887         if(ret) goto cleanup;
 888     }
 889     if (header & SC_SECOND_TICKET) {
 890         ret = krb5_ret_data (sp,  &creds->second_ticket);
 891         if(ret) goto cleanup;
 892     }
 893
 894 cleanup:
 895     if(ret) {
 896 #if 0
 897         krb5_free_cred_contents(context, creds); /* XXX */
 898 #endif
 899     }
 900     return ret;
 901 }