source4/heimdal/lib/krb5/store.c

   1 /*
   2  * Copyright (c) 1997-2006 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.59 2006/08/18 08:39:13 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 krb5_error_code KRB5_LIB_FUNCTION
 185 krb5_store_uint32(krb5_storage *sp,
 186                   uint32_t value)
 187 {
 188     return krb5_store_int32(sp, (int32_t)value);
 189 }
 190
 191 static krb5_error_code
 192 krb5_ret_int(krb5_storage *sp,
 193              int32_t *value,
 194              size_t len)
 195 {
 196     int ret;
 197     unsigned char v[4];
 198     unsigned long w;
 199     ret = sp->fetch(sp, v, len);
 200     if(ret != len)
 201         return (ret<0)?errno:sp->eof_code;
 202     _krb5_get_int(v, &w, len);
 203     *value = w;
 204     return 0;
 205 }
 206
 207 krb5_error_code KRB5_LIB_FUNCTION
 208 krb5_ret_int32(krb5_storage *sp,
 209                int32_t *value)
 210 {
 211     krb5_error_code ret = krb5_ret_int(sp, value, 4);
 212     if(ret)
 213         return ret;
 214     if(BYTEORDER_IS_HOST(sp))
 215         *value = htonl(*value);
 216     else if(BYTEORDER_IS_LE(sp))
 217         *value = bswap32(*value);
 218     return 0;
 219 }
 220
 221 krb5_error_code KRB5_LIB_FUNCTION
 222 krb5_ret_uint32(krb5_storage *sp,
 223                 uint32_t *value)
 224 {
 225     krb5_error_code ret;
 226     int32_t v;
 227
 228     ret = krb5_ret_int32(sp, &v);
 229     if (ret == 0)
 230         *value = (uint32_t)v;
 231
 232     return ret;
 233 }
 234
 235 krb5_error_code KRB5_LIB_FUNCTION
 236 krb5_store_int16(krb5_storage *sp,
 237                  int16_t value)
 238 {
 239     if(BYTEORDER_IS_HOST(sp))
 240         value = htons(value);
 241     else if(BYTEORDER_IS_LE(sp))
 242         value = bswap16(value);
 243     return krb5_store_int(sp, value, 2);
 244 }
 245
 246 krb5_error_code KRB5_LIB_FUNCTION
 247 krb5_store_uint16(krb5_storage *sp,
 248                   uint16_t value)
 249 {
 250     return krb5_store_int16(sp, (int16_t)value);
 251 }
 252
 253 krb5_error_code KRB5_LIB_FUNCTION
 254 krb5_ret_int16(krb5_storage *sp,
 255                int16_t *value)
 256 {
 257     int32_t v;
 258     int ret;
 259     ret = krb5_ret_int(sp, &v, 2);
 260     if(ret)
 261         return ret;
 262     *value = v;
 263     if(BYTEORDER_IS_HOST(sp))
 264         *value = htons(*value);
 265     else if(BYTEORDER_IS_LE(sp))
 266         *value = bswap16(*value);
 267     return 0;
 268 }
 269
 270 krb5_error_code KRB5_LIB_FUNCTION
 271 krb5_ret_uint16(krb5_storage *sp,
 272                 uint16_t *value)
 273 {
 274     krb5_error_code ret;
 275     int16_t v;
 276
 277     ret = krb5_ret_int16(sp, &v);
 278     if (ret == 0)
 279         *value = (uint16_t)v;
 280
 281     return ret;
 282 }
 283
 284 krb5_error_code KRB5_LIB_FUNCTION
 285 krb5_store_int8(krb5_storage *sp,
 286                 int8_t value)
 287 {
 288     int ret;
 289
 290     ret = sp->store(sp, &value, sizeof(value));
 291     if (ret != sizeof(value))
 292         return (ret<0)?errno:sp->eof_code;
 293     return 0;
 294 }
 295
 296 krb5_error_code KRB5_LIB_FUNCTION
 297 krb5_store_uint8(krb5_storage *sp,
 298                  uint8_t value)
 299 {
 300     return krb5_store_int8(sp, (int8_t)value);
 301 }
 302
 303 krb5_error_code KRB5_LIB_FUNCTION
 304 krb5_ret_int8(krb5_storage *sp,
 305               int8_t *value)
 306 {
 307     int ret;
 308
 309     ret = sp->fetch(sp, value, sizeof(*value));
 310     if (ret != sizeof(*value))
 311         return (ret<0)?errno:sp->eof_code;
 312     return 0;
 313 }
 314
 315 krb5_error_code KRB5_LIB_FUNCTION
 316 krb5_ret_uint8(krb5_storage *sp,
 317                uint8_t *value)
 318 {
 319     krb5_error_code ret;
 320     int8_t v;
 321
 322     ret = krb5_ret_int8(sp, &v);
 323     if (ret == 0)
 324         *value = (uint8_t)v;
 325
 326     return ret;
 327 }
 328
 329 krb5_error_code KRB5_LIB_FUNCTION
 330 krb5_store_data(krb5_storage *sp,
 331                 krb5_data data)
 332 {
 333     int ret;
 334     ret = krb5_store_int32(sp, data.length);
 335     if(ret < 0)
 336         return ret;
 337     ret = sp->store(sp, data.data, data.length);
 338     if(ret != data.length){
 339         if(ret < 0)
 340             return errno;
 341         return sp->eof_code;
 342     }
 343     return 0;
 344 }
 345
 346 krb5_error_code KRB5_LIB_FUNCTION
 347 krb5_ret_data(krb5_storage *sp,
 348               krb5_data *data)
 349 {
 350     int ret;
 351     int32_t size;
 352
 353     ret = krb5_ret_int32(sp, &size);
 354     if(ret)
 355         return ret;
 356     ret = krb5_data_alloc (data, size);
 357     if (ret)
 358         return ret;
 359     if (size) {
 360         ret = sp->fetch(sp, data->data, size);
 361         if(ret != size)
 362             return (ret < 0)? errno : sp->eof_code;
 363     }
 364     return 0;
 365 }
 366
 367 krb5_error_code KRB5_LIB_FUNCTION
 368 krb5_store_string(krb5_storage *sp, const char *s)
 369 {
 370     krb5_data data;
 371     data.length = strlen(s);
 372     data.data = rk_UNCONST(s);
 373     return krb5_store_data(sp, data);
 374 }
 375
 376 krb5_error_code KRB5_LIB_FUNCTION
 377 krb5_ret_string(krb5_storage *sp,
 378                 char **string)
 379 {
 380     int ret;
 381     krb5_data data;
 382     ret = krb5_ret_data(sp, &data);
 383     if(ret)
 384         return ret;
 385     *string = realloc(data.data, data.length + 1);
 386     if(*string == NULL){
 387         free(data.data);
 388         return ENOMEM;
 389     }
 390     (*string)[data.length] = 0;
 391     return 0;
 392 }
 393
 394 krb5_error_code KRB5_LIB_FUNCTION
 395 krb5_store_stringz(krb5_storage *sp, const char *s)
 396 {
 397     size_t len = strlen(s) + 1;
 398     ssize_t ret;
 399
 400     ret = sp->store(sp, s, len);
 401     if(ret != len) {
 402         if(ret < 0)
 403             return ret;
 404         else
 405             return sp->eof_code;
 406     }
 407     return 0;
 408 }
 409
 410 krb5_error_code KRB5_LIB_FUNCTION
 411 krb5_ret_stringz(krb5_storage *sp,
 412                 char **string)
 413 {
 414     char c;
 415     char *s = NULL;
 416     size_t len = 0;
 417     ssize_t ret;
 418
 419     while((ret = sp->fetch(sp, &c, 1)) == 1){
 420         char *tmp;
 421
 422         len++;
 423         tmp = realloc (s, len);
 424         if (tmp == NULL) {
 425             free (s);
 426             return ENOMEM;
 427         }
 428         s = tmp;
 429         s[len - 1] = c;
 430         if(c == 0)
 431             break;
 432     }
 433     if(ret != 1){
 434         free(s);
 435         if(ret == 0)
 436             return sp->eof_code;
 437         return ret;
 438     }
 439     *string = s;
 440     return 0;
 441 }
 442
 443 krb5_error_code KRB5_LIB_FUNCTION
 444 krb5_store_stringnl(krb5_storage *sp, const char *s)
 445 {
 446     size_t len = strlen(s);
 447     ssize_t ret;
 448
 449     ret = sp->store(sp, s, len);
 450     if(ret != len) {
 451         if(ret < 0)
 452             return ret;
 453         else
 454             return sp->eof_code;
 455     }
 456     ret = sp->store(sp, "\n", 1);
 457     if(ret != 1) {
 458         if(ret < 0)
 459             return ret;
 460         else
 461             return sp->eof_code;
 462     }
 463
 464     return 0;
 465
 466 }
 467
 468 krb5_error_code KRB5_LIB_FUNCTION
 469 krb5_ret_stringnl(krb5_storage *sp,
 470                   char **string)
 471 {
 472     int expect_nl = 0;
 473     char c;
 474     char *s = NULL;
 475     size_t len = 0;
 476     ssize_t ret;
 477
 478     while((ret = sp->fetch(sp, &c, 1)) == 1){
 479         char *tmp;
 480
 481         if (c == '\r') {
 482             expect_nl = 1;
 483             continue;
 484         }
 485         if (expect_nl && c != '\n') {
 486             free(s);
 487             return KRB5_BADMSGTYPE;
 488         }
 489
 490         len++;
 491         tmp = realloc (s, len);
 492         if (tmp == NULL) {
 493             free (s);
 494             return ENOMEM;
 495         }
 496         s = tmp;
 497         if(c == '\n') {
 498             s[len - 1] = '\0';
 499             break;
 500         }
 501         s[len - 1] = c;
 502     }
 503     if(ret != 1){
 504         free(s);
 505         if(ret == 0)
 506             return sp->eof_code;
 507         return ret;
 508     }
 509     *string = s;
 510     return 0;
 511 }
 512
 513
 514 krb5_error_code KRB5_LIB_FUNCTION
 515 krb5_store_principal(krb5_storage *sp,
 516                      krb5_const_principal p)
 517 {
 518     int i;
 519     int ret;
 520
 521     if(!krb5_storage_is_flags(sp, KRB5_STORAGE_PRINCIPAL_NO_NAME_TYPE)) {
 522         ret = krb5_store_int32(sp, p->name.name_type);
 523         if(ret) return ret;
 524     }
 525     if(krb5_storage_is_flags(sp, KRB5_STORAGE_PRINCIPAL_WRONG_NUM_COMPONENTS))
 526         ret = krb5_store_int32(sp, p->name.name_string.len + 1);
 527     else
 528         ret = krb5_store_int32(sp, p->name.name_string.len);
 529
 530     if(ret) return ret;
 531     ret = krb5_store_string(sp, p->realm);
 532     if(ret) return ret;
 533     for(i = 0; i < p->name.name_string.len; i++){
 534         ret = krb5_store_string(sp, p->name.name_string.val[i]);
 535         if(ret) return ret;
 536     }
 537     return 0;
 538 }
 539
 540 krb5_error_code KRB5_LIB_FUNCTION
 541 krb5_ret_principal(krb5_storage *sp,
 542                    krb5_principal *princ)
 543 {
 544     int i;
 545     int ret;
 546     krb5_principal p;
 547     int32_t type;
 548     int32_t ncomp;
 549
 550     p = calloc(1, sizeof(*p));
 551     if(p == NULL)
 552         return ENOMEM;
 553
 554     if(krb5_storage_is_flags(sp, KRB5_STORAGE_PRINCIPAL_NO_NAME_TYPE))
 555         type = KRB5_NT_UNKNOWN;
 556     else if((ret = krb5_ret_int32(sp, &type))){
 557         free(p);
 558         return ret;
 559     }
 560     if((ret = krb5_ret_int32(sp, &ncomp))){
 561         free(p);
 562         return ret;
 563     }
 564     if(krb5_storage_is_flags(sp, KRB5_STORAGE_PRINCIPAL_WRONG_NUM_COMPONENTS))
 565         ncomp--;
 566     if (ncomp < 0) {
 567         free(p);
 568         return EINVAL;
 569     }
 570     p->name.name_type = type;
 571     p->name.name_string.len = ncomp;
 572     ret = krb5_ret_string(sp, &p->realm);
 573     if(ret) {
 574         free(p);
 575         return ret;
 576     }
 577     p->name.name_string.val = calloc(ncomp, sizeof(*p->name.name_string.val));
 578     if(p->name.name_string.val == NULL && ncomp != 0){
 579         free(p->realm);
 580         return ENOMEM;
 581     }
 582     for(i = 0; i < ncomp; i++){
 583         ret = krb5_ret_string(sp, &p->name.name_string.val[i]);
 584         if(ret) {
 585             while (i >= 0)
 586                 free(p->name.name_string.val[i--]);
 587             free(p->realm);
 588             free(p);
 589             return ret;
 590         }
 591     }
 592     *princ = p;
 593     return 0;
 594 }
 595
 596 krb5_error_code KRB5_LIB_FUNCTION
 597 krb5_store_keyblock(krb5_storage *sp, krb5_keyblock p)
 598 {
 599     int ret;
 600     ret = krb5_store_int16(sp, p.keytype);
 601     if(ret) return ret;
 602
 603     if(krb5_storage_is_flags(sp, KRB5_STORAGE_KEYBLOCK_KEYTYPE_TWICE)){
 604         /* this should really be enctype, but it is the same as
 605            keytype nowadays */
 606     ret = krb5_store_int16(sp, p.keytype);
 607     if(ret) return ret;
 608     }
 609
 610     ret = krb5_store_data(sp, p.keyvalue);
 611     return ret;
 612 }
 613
 614 krb5_error_code KRB5_LIB_FUNCTION
 615 krb5_ret_keyblock(krb5_storage *sp, krb5_keyblock *p)
 616 {
 617     int ret;
 618     int16_t tmp;
 619
 620     ret = krb5_ret_int16(sp, &tmp);
 621     if(ret) return ret;
 622     p->keytype = tmp;
 623
 624     if(krb5_storage_is_flags(sp, KRB5_STORAGE_KEYBLOCK_KEYTYPE_TWICE)){
 625     ret = krb5_ret_int16(sp, &tmp);
 626     if(ret) return ret;
 627     }
 628
 629     ret = krb5_ret_data(sp, &p->keyvalue);
 630     return ret;
 631 }
 632
 633 krb5_error_code KRB5_LIB_FUNCTION
 634 krb5_store_times(krb5_storage *sp, krb5_times times)
 635 {
 636     int ret;
 637     ret = krb5_store_int32(sp, times.authtime);
 638     if(ret) return ret;
 639     ret = krb5_store_int32(sp, times.starttime);
 640     if(ret) return ret;
 641     ret = krb5_store_int32(sp, times.endtime);
 642     if(ret) return ret;
 643     ret = krb5_store_int32(sp, times.renew_till);
 644     return ret;
 645 }
 646
 647 krb5_error_code KRB5_LIB_FUNCTION
 648 krb5_ret_times(krb5_storage *sp, krb5_times *times)
 649 {
 650     int ret;
 651     int32_t tmp;
 652     ret = krb5_ret_int32(sp, &tmp);
 653     times->authtime = tmp;
 654     if(ret) return ret;
 655     ret = krb5_ret_int32(sp, &tmp);
 656     times->starttime = tmp;
 657     if(ret) return ret;
 658     ret = krb5_ret_int32(sp, &tmp);
 659     times->endtime = tmp;
 660     if(ret) return ret;
 661     ret = krb5_ret_int32(sp, &tmp);
 662     times->renew_till = tmp;
 663     return ret;
 664 }
 665
 666 krb5_error_code KRB5_LIB_FUNCTION
 667 krb5_store_address(krb5_storage *sp, krb5_address p)
 668 {
 669     int ret;
 670     ret = krb5_store_int16(sp, p.addr_type);
 671     if(ret) return ret;
 672     ret = krb5_store_data(sp, p.address);
 673     return ret;
 674 }
 675
 676 krb5_error_code KRB5_LIB_FUNCTION
 677 krb5_ret_address(krb5_storage *sp, krb5_address *adr)
 678 {
 679     int16_t t;
 680     int ret;
 681     ret = krb5_ret_int16(sp, &t);
 682     if(ret) return ret;
 683     adr->addr_type = t;
 684     ret = krb5_ret_data(sp, &adr->address);
 685     return ret;
 686 }
 687
 688 krb5_error_code KRB5_LIB_FUNCTION
 689 krb5_store_addrs(krb5_storage *sp, krb5_addresses p)
 690 {
 691     int i;
 692     int ret;
 693     ret = krb5_store_int32(sp, p.len);
 694     if(ret) return ret;
 695     for(i = 0; i<p.len; i++){
 696         ret = krb5_store_address(sp, p.val[i]);
 697         if(ret) break;
 698     }
 699     return ret;
 700 }
 701
 702 krb5_error_code KRB5_LIB_FUNCTION
 703 krb5_ret_addrs(krb5_storage *sp, krb5_addresses *adr)
 704 {
 705     int i;
 706     int ret;
 707     int32_t tmp;
 708
 709     ret = krb5_ret_int32(sp, &tmp);
 710     if(ret) return ret;
 711     adr->len = tmp;
 712     ALLOC(adr->val, adr->len);
 713     if (adr->val == NULL && adr->len != 0)
 714         return ENOMEM;
 715     for(i = 0; i < adr->len; i++){
 716         ret = krb5_ret_address(sp, &adr->val[i]);
 717         if(ret) break;
 718     }
 719     return ret;
 720 }
 721
 722 krb5_error_code KRB5_LIB_FUNCTION
 723 krb5_store_authdata(krb5_storage *sp, krb5_authdata auth)
 724 {
 725     krb5_error_code ret;
 726     int i;
 727     ret = krb5_store_int32(sp, auth.len);
 728     if(ret) return ret;
 729     for(i = 0; i < auth.len; i++){
 730         ret = krb5_store_int16(sp, auth.val[i].ad_type);
 731         if(ret) break;
 732         ret = krb5_store_data(sp, auth.val[i].ad_data);
 733         if(ret) break;
 734     }
 735     return 0;
 736 }
 737
 738 krb5_error_code KRB5_LIB_FUNCTION
 739 krb5_ret_authdata(krb5_storage *sp, krb5_authdata *auth)
 740 {
 741     krb5_error_code ret;
 742     int32_t tmp;
 743     int16_t tmp2;
 744     int i;
 745     ret = krb5_ret_int32(sp, &tmp);
 746     if(ret) return ret;
 747     ALLOC_SEQ(auth, tmp);
 748     if (auth->val == NULL && tmp != 0)
 749         return ENOMEM;
 750     for(i = 0; i < tmp; i++){
 751         ret = krb5_ret_int16(sp, &tmp2);
 752         if(ret) break;
 753         auth->val[i].ad_type = tmp2;
 754         ret = krb5_ret_data(sp, &auth->val[i].ad_data);
 755         if(ret) break;
 756     }
 757     return ret;
 758 }
 759
 760 static int32_t
 761 bitswap32(int32_t b)
 762 {
 763     int32_t r = 0;
 764     int i;
 765     for (i = 0; i < 32; i++) {
 766         r = r << 1 | (b & 1);
 767         b = b >> 1;
 768     }
 769     return r;
 770 }
 771
 772
 773 /*
 774  *
 775  */
 776
 777 krb5_error_code KRB5_LIB_FUNCTION
 778 krb5_store_creds(krb5_storage *sp, krb5_creds *creds)
 779 {
 780     int ret;
 781
 782     ret = krb5_store_principal(sp, creds->client);
 783     if(ret)
 784         return ret;
 785     ret = krb5_store_principal(sp, creds->server);
 786     if(ret)
 787         return ret;
 788     ret = krb5_store_keyblock(sp, creds->session);
 789     if(ret)
 790         return ret;
 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     if(krb5_storage_is_flags(sp, KRB5_STORAGE_CREDS_FLAGS_WRONG_BITORDER))
 799         ret = krb5_store_int32(sp, creds->flags.i);
 800     else
 801         ret = krb5_store_int32(sp, bitswap32(TicketFlags2int(creds->flags.b)));
 802     if(ret)
 803         return ret;
 804
 805     ret = krb5_store_addrs(sp, creds->addresses);
 806     if(ret)
 807         return ret;
 808     ret = krb5_store_authdata(sp, creds->authdata);
 809     if(ret)
 810         return ret;
 811     ret = krb5_store_data(sp, creds->ticket);
 812     if(ret)
 813         return ret;
 814     ret = krb5_store_data(sp, creds->second_ticket);
 815     return ret;
 816 }
 817
 818 krb5_error_code KRB5_LIB_FUNCTION
 819 krb5_ret_creds(krb5_storage *sp, krb5_creds *creds)
 820 {
 821     krb5_error_code ret;
 822     int8_t dummy8;
 823     int32_t dummy32;
 824
 825     memset(creds, 0, sizeof(*creds));
 826     ret = krb5_ret_principal (sp,  &creds->client);
 827     if(ret) goto cleanup;
 828     ret = krb5_ret_principal (sp,  &creds->server);
 829     if(ret) goto cleanup;
 830     ret = krb5_ret_keyblock (sp,  &creds->session);
 831     if(ret) goto cleanup;
 832     ret = krb5_ret_times (sp,  &creds->times);
 833     if(ret) goto cleanup;
 834     ret = krb5_ret_int8 (sp,  &dummy8);
 835     if(ret) goto cleanup;
 836     ret = krb5_ret_int32 (sp,  &dummy32);
 837     if(ret) goto cleanup;
 838     /*
 839      * Runtime detect the what is the higher bits of the bitfield. If
 840      * any of the higher bits are set in the input data, its either a
 841      * new ticket flag (and this code need to be removed), or its a
 842      * MIT cache (or new Heimdal cache), lets change it to our current
 843      * format.
 844      */
 845     {
 846         uint32_t mask = 0xffff0000;
 847         creds->flags.i = 0;
 848         creds->flags.b.anonymous = 1;
 849         if (creds->flags.i & mask)
 850             mask = ~mask;
 851         if (dummy32 & mask)
 852             dummy32 = bitswap32(dummy32);
 853     }
 854     creds->flags.i = dummy32;
 855     ret = krb5_ret_addrs (sp,  &creds->addresses);
 856     if(ret) goto cleanup;
 857     ret = krb5_ret_authdata (sp,  &creds->authdata);
 858     if(ret) goto cleanup;
 859     ret = krb5_ret_data (sp,  &creds->ticket);
 860     if(ret) goto cleanup;
 861     ret = krb5_ret_data (sp,  &creds->second_ticket);
 862 cleanup:
 863     if(ret) {
 864 #if 0
 865         krb5_free_cred_contents(context, creds); /* XXX */
 866 #endif
 867     }
 868     return ret;
 869 }
 870
 871 #define SC_CLIENT_PRINCIPAL         0x0001
 872 #define SC_SERVER_PRINCIPAL         0x0002
 873 #define SC_SESSION_KEY              0x0004
 874 #define SC_TICKET                   0x0008
 875 #define SC_SECOND_TICKET            0x0010
 876 #define SC_AUTHDATA                 0x0020
 877 #define SC_ADDRESSES                0x0040
 878
 879 /*
 880  *
 881  */
 882
 883 krb5_error_code KRB5_LIB_FUNCTION
 884 krb5_store_creds_tag(krb5_storage *sp, krb5_creds *creds)
 885 {
 886     int ret;
 887     int32_t header = 0;
 888
 889     if (creds->client)
 890         header |= SC_CLIENT_PRINCIPAL;
 891     if (creds->server)
 892         header |= SC_SERVER_PRINCIPAL;
 893     if (creds->session.keyvalue.data)
 894         header |= SC_SESSION_KEY;
 895     if (creds->ticket.data)
 896         header |= SC_TICKET;
 897     if (creds->second_ticket.length)
 898         header |= SC_SECOND_TICKET;
 899     if (creds->authdata.len)
 900         header |= SC_AUTHDATA;
 901     if (creds->addresses.len)
 902         header |= SC_ADDRESSES;
 903
 904     ret = krb5_store_int32(sp, header);
 905
 906     if (creds->client) {
 907         ret = krb5_store_principal(sp, creds->client);
 908         if(ret)
 909             return ret;
 910     }
 911
 912     if (creds->server) {
 913         ret = krb5_store_principal(sp, creds->server);
 914         if(ret)
 915             return ret;
 916     }
 917
 918     if (creds->session.keyvalue.data) {
 919         ret = krb5_store_keyblock(sp, creds->session);
 920         if(ret)
 921             return ret;
 922     }
 923
 924     ret = krb5_store_times(sp, creds->times);
 925     if(ret)
 926         return ret;
 927     ret = krb5_store_int8(sp, creds->second_ticket.length != 0); /* is_skey */
 928     if(ret)
 929         return ret;
 930
 931     ret = krb5_store_int32(sp, bitswap32(TicketFlags2int(creds->flags.b)));
 932     if(ret)
 933         return ret;
 934
 935     if (creds->addresses.len) {
 936         ret = krb5_store_addrs(sp, creds->addresses);
 937         if(ret)
 938             return ret;
 939     }
 940
 941     if (creds->authdata.len) {
 942         ret = krb5_store_authdata(sp, creds->authdata);
 943         if(ret)
 944             return ret;
 945     }
 946
 947     if (creds->ticket.data) {
 948         ret = krb5_store_data(sp, creds->ticket);
 949         if(ret)
 950             return ret;
 951     }
 952
 953     if (creds->second_ticket.data) {
 954         ret = krb5_store_data(sp, creds->second_ticket);
 955         if (ret)
 956             return ret;
 957     }
 958
 959     return ret;
 960 }
 961
 962 krb5_error_code KRB5_LIB_FUNCTION
 963 krb5_ret_creds_tag(krb5_storage *sp,
 964                    krb5_creds *creds)
 965 {
 966     krb5_error_code ret;
 967     int8_t dummy8;
 968     int32_t dummy32, header;
 969
 970     memset(creds, 0, sizeof(*creds));
 971
 972     ret = krb5_ret_int32 (sp, &header);
 973     if (ret) goto cleanup;
 974
 975     if (header & SC_CLIENT_PRINCIPAL) {
 976         ret = krb5_ret_principal (sp,  &creds->client);
 977         if(ret) goto cleanup;
 978     }
 979     if (header & SC_SERVER_PRINCIPAL) {
 980         ret = krb5_ret_principal (sp,  &creds->server);
 981         if(ret) goto cleanup;
 982     }
 983     if (header & SC_SESSION_KEY) {
 984         ret = krb5_ret_keyblock (sp,  &creds->session);
 985         if(ret) goto cleanup;
 986     }
 987     ret = krb5_ret_times (sp,  &creds->times);
 988     if(ret) goto cleanup;
 989     ret = krb5_ret_int8 (sp,  &dummy8);
 990     if(ret) goto cleanup;
 991     ret = krb5_ret_int32 (sp,  &dummy32);
 992     if(ret) goto cleanup;
 993     /*
 994      * Runtime detect the what is the higher bits of the bitfield. If
 995      * any of the higher bits are set in the input data, its either a
 996      * new ticket flag (and this code need to be removed), or its a
 997      * MIT cache (or new Heimdal cache), lets change it to our current
 998      * format.
 999      */
1000     {
1001         uint32_t mask = 0xffff0000;
1002         creds->flags.i = 0;
1003         creds->flags.b.anonymous = 1;
1004         if (creds->flags.i & mask)
1005             mask = ~mask;
1006         if (dummy32 & mask)
1007             dummy32 = bitswap32(dummy32);
1008     }
1009     creds->flags.i = dummy32;
1010     if (header & SC_ADDRESSES) {
1011         ret = krb5_ret_addrs (sp,  &creds->addresses);
1012         if(ret) goto cleanup;
1013     }
1014     if (header & SC_AUTHDATA) {
1015         ret = krb5_ret_authdata (sp,  &creds->authdata);
1016         if(ret) goto cleanup;
1017     }
1018     if (header & SC_TICKET) {
1019         ret = krb5_ret_data (sp,  &creds->ticket);
1020         if(ret) goto cleanup;
1021     }
1022     if (header & SC_SECOND_TICKET) {
1023         ret = krb5_ret_data (sp,  &creds->second_ticket);
1024         if(ret) goto cleanup;
1025     }
1026
1027 cleanup:
1028     if(ret) {
1029 #if 0
1030         krb5_free_cred_contents(context, creds); /* XXX */
1031 #endif
1032     }
1033     return ret;
1034 }