crypto/dist/heimdal/lib/krb5/fcache.c

   1 /*
   2  * Copyright (c) 1997 - 2008 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
  36 __RCSID("$Heimdal: fcache.c 22522 2008-01-24 11:56:25Z lha $"
  37         "$NetBSD$");
  38
  39 typedef struct krb5_fcache{
  40     char *filename;
  41     int version;
  42 }krb5_fcache;
  43
  44 struct fcc_cursor {
  45     int fd;
  46     krb5_storage *sp;
  47 };
  48
  49 #define KRB5_FCC_FVNO_1 1
  50 #define KRB5_FCC_FVNO_2 2
  51 #define KRB5_FCC_FVNO_3 3
  52 #define KRB5_FCC_FVNO_4 4
  53
  54 #define FCC_TAG_DELTATIME 1
  55
  56 #define FCACHE(X) ((krb5_fcache*)(X)->data.data)
  57
  58 #define FILENAME(X) (FCACHE(X)->filename)
  59
  60 #define FCC_CURSOR(C) ((struct fcc_cursor*)(C))
  61
  62 static const char*
  63 fcc_get_name(krb5_context context,
  64              krb5_ccache id)
  65 {
  66     return FILENAME(id);
  67 }
  68
  69 int
  70 _krb5_xlock(krb5_context context, int fd, krb5_boolean exclusive,
  71             const char *filename)
  72 {
  73     int ret;
  74 #ifdef HAVE_FCNTL
  75     struct flock l;
  76
  77     l.l_start = 0;
  78     l.l_len = 0;
  79     l.l_type = exclusive ? F_WRLCK : F_RDLCK;
  80     l.l_whence = SEEK_SET;
  81     ret = fcntl(fd, F_SETLKW, &l);
  82 #else
  83     ret = flock(fd, exclusive ? LOCK_EX : LOCK_SH);
  84 #endif
  85     if(ret < 0)
  86         ret = errno;
  87     if(ret == EACCES) /* fcntl can return EACCES instead of EAGAIN */
  88         ret = EAGAIN;
  89
  90     switch (ret) {
  91     case 0:
  92         break;
  93     case EINVAL: /* filesystem doesn't support locking, let the user have it */
  94         ret = 0;
  95         break;
  96     case EAGAIN:
  97         krb5_set_error_string(context, "timed out locking cache file %s",
  98                               filename);
  99         break;
 100     default:
 101         krb5_set_error_string(context, "error locking cache file %s: %s",
 102                               filename, strerror(ret));
 103         break;
 104     }
 105     return ret;
 106 }
 107
 108 int
 109 _krb5_xunlock(krb5_context context, int fd)
 110 {
 111     int ret;
 112 #ifdef HAVE_FCNTL
 113     struct flock l;
 114     l.l_start = 0;
 115     l.l_len = 0;
 116     l.l_type = F_UNLCK;
 117     l.l_whence = SEEK_SET;
 118     ret = fcntl(fd, F_SETLKW, &l);
 119 #else
 120     ret = flock(fd, LOCK_UN);
 121 #endif
 122     if (ret < 0)
 123         ret = errno;
 124     switch (ret) {
 125     case 0:
 126         break;
 127     case EINVAL: /* filesystem doesn't support locking, let the user have it */
 128         ret = 0;
 129         break;
 130     default:
 131         krb5_set_error_string(context,
 132                               "Failed to unlock file: %s", strerror(ret));
 133         break;
 134     }
 135     return ret;
 136 }
 137
 138 static krb5_error_code
 139 fcc_lock(krb5_context context, krb5_ccache id,
 140          int fd, krb5_boolean exclusive)
 141 {
 142     return _krb5_xlock(context, fd, exclusive, fcc_get_name(context, id));
 143 }
 144
 145 static krb5_error_code
 146 fcc_unlock(krb5_context context, int fd)
 147 {
 148     return _krb5_xunlock(context, fd);
 149 }
 150
 151 static krb5_error_code
 152 fcc_resolve(krb5_context context, krb5_ccache *id, const char *res)
 153 {
 154     krb5_fcache *f;
 155     f = malloc(sizeof(*f));
 156     if(f == NULL) {
 157         krb5_set_error_string(context, "malloc: out of memory");
 158         return KRB5_CC_NOMEM;
 159     }
 160     f->filename = strdup(res);
 161     if(f->filename == NULL){
 162         free(f);
 163         krb5_set_error_string(context, "malloc: out of memory");
 164         return KRB5_CC_NOMEM;
 165     }
 166     f->version = 0;
 167     (*id)->data.data = f;
 168     (*id)->data.length = sizeof(*f);
 169     return 0;
 170 }
 171
 172 /*
 173  * Try to scrub the contents of `filename' safely.
 174  */
 175
 176 static int
 177 scrub_file (int fd)
 178 {
 179     off_t pos;
 180     char buf[128];
 181
 182     pos = lseek(fd, 0, SEEK_END);
 183     if (pos < 0)
 184         return errno;
 185     if (lseek(fd, 0, SEEK_SET) < 0)
 186         return errno;
 187     memset(buf, 0, sizeof(buf));
 188     while(pos > 0) {
 189         ssize_t tmp = write(fd, buf, min(sizeof(buf), pos));
 190
 191         if (tmp < 0)
 192             return errno;
 193         pos -= tmp;
 194     }
 195     fsync (fd);
 196     return 0;
 197 }
 198
 199 /*
 200  * Erase `filename' if it exists, trying to remove the contents if
 201  * it's `safe'.  We always try to remove the file, it it exists.  It's
 202  * only overwritten if it's a regular file (not a symlink and not a
 203  * hardlink)
 204  */
 205
 206 static krb5_error_code
 207 erase_file(const char *filename)
 208 {
 209     int fd;
 210     struct stat sb1, sb2;
 211     int ret;
 212
 213     ret = lstat (filename, &sb1);
 214     if (ret < 0)
 215         return errno;
 216
 217     fd = open(filename, O_RDWR | O_BINARY);
 218     if(fd < 0) {
 219         if(errno == ENOENT)
 220             return 0;
 221         else
 222             return errno;
 223     }
 224     if (unlink(filename) < 0) {
 225         close (fd);
 226         return errno;
 227     }
 228     ret = fstat (fd, &sb2);
 229     if (ret < 0) {
 230         close (fd);
 231         return errno;
 232     }
 233
 234     /* check if someone was playing with symlinks */
 235
 236     if (sb1.st_dev != sb2.st_dev || sb1.st_ino != sb2.st_ino) {
 237         close (fd);
 238         return EPERM;
 239     }
 240
 241     /* there are still hard links to this file */
 242
 243     if (sb2.st_nlink != 0) {
 244         close (fd);
 245         return 0;
 246     }
 247
 248     ret = scrub_file (fd);
 249     close (fd);
 250     return ret;
 251 }
 252
 253 static krb5_error_code
 254 fcc_gen_new(krb5_context context, krb5_ccache *id)
 255 {
 256     krb5_fcache *f;
 257     int fd;
 258     char *file;
 259
 260     f = malloc(sizeof(*f));
 261     if(f == NULL) {
 262         krb5_set_error_string(context, "malloc: out of memory");
 263         return KRB5_CC_NOMEM;
 264     }
 265     asprintf (&file, "%sXXXXXX", KRB5_DEFAULT_CCFILE_ROOT);
 266     if(file == NULL) {
 267         free(f);
 268         krb5_set_error_string(context, "malloc: out of memory");
 269         return KRB5_CC_NOMEM;
 270     }
 271     fd = mkstemp(file);
 272     if(fd < 0) {
 273         int ret = errno;
 274         krb5_set_error_string(context, "mkstemp %s", file);
 275         free(f);
 276         free(file);
 277         return ret;
 278     }
 279     close(fd);
 280     f->filename = file;
 281     f->version = 0;
 282     (*id)->data.data = f;
 283     (*id)->data.length = sizeof(*f);
 284     return 0;
 285 }
 286
 287 static void
 288 storage_set_flags(krb5_context context, krb5_storage *sp, int vno)
 289 {
 290     int flags = 0;
 291     switch(vno) {
 292     case KRB5_FCC_FVNO_1:
 293         flags |= KRB5_STORAGE_PRINCIPAL_WRONG_NUM_COMPONENTS;
 294         flags |= KRB5_STORAGE_PRINCIPAL_NO_NAME_TYPE;
 295         flags |= KRB5_STORAGE_HOST_BYTEORDER;
 296         break;
 297     case KRB5_FCC_FVNO_2:
 298         flags |= KRB5_STORAGE_HOST_BYTEORDER;
 299         break;
 300     case KRB5_FCC_FVNO_3:
 301         flags |= KRB5_STORAGE_KEYBLOCK_KEYTYPE_TWICE;
 302         break;
 303     case KRB5_FCC_FVNO_4:
 304         break;
 305     default:
 306         krb5_abortx(context,
 307                     "storage_set_flags called with bad vno (%x)", vno);
 308     }
 309     krb5_storage_set_flags(sp, flags);
 310 }
 311
 312 static krb5_error_code
 313 fcc_open(krb5_context context,
 314          krb5_ccache id,
 315          int *fd_ret,
 316          int flags,
 317          mode_t mode)
 318 {
 319     krb5_boolean exclusive = ((flags | O_WRONLY) == flags ||
 320                               (flags | O_RDWR) == flags);
 321     krb5_error_code ret;
 322     const char *filename = FILENAME(id);
 323     int fd;
 324     fd = open(filename, flags, mode);
 325     if(fd < 0) {
 326         ret = errno;
 327         krb5_set_error_string(context, "open(%s): %s", filename,
 328                               strerror(ret));
 329         return ret;
 330     }
 331
 332     if((ret = fcc_lock(context, id, fd, exclusive)) != 0) {
 333         close(fd);
 334         return ret;
 335     }
 336     *fd_ret = fd;
 337     return 0;
 338 }
 339
 340 static krb5_error_code
 341 fcc_initialize(krb5_context context,
 342                krb5_ccache id,
 343                krb5_principal primary_principal)
 344 {
 345     krb5_fcache *f = FCACHE(id);
 346     int ret = 0;
 347     int fd;
 348     char *filename = f->filename;
 349
 350     unlink (filename);
 351
 352     ret = fcc_open(context, id, &fd, O_RDWR | O_CREAT | O_EXCL | O_BINARY, 0600);
 353     if(ret)
 354         return ret;
 355     {
 356         krb5_storage *sp;
 357         sp = krb5_storage_from_fd(fd);
 358         krb5_storage_set_eof_code(sp, KRB5_CC_END);
 359         if(context->fcache_vno != 0)
 360             f->version = context->fcache_vno;
 361         else
 362             f->version = KRB5_FCC_FVNO_4;
 363         ret |= krb5_store_int8(sp, 5);
 364         ret |= krb5_store_int8(sp, f->version);
 365         storage_set_flags(context, sp, f->version);
 366         if(f->version == KRB5_FCC_FVNO_4 && ret == 0) {
 367             /* V4 stuff */
 368             if (context->kdc_sec_offset) {
 369                 ret |= krb5_store_int16 (sp, 12); /* length */
 370                 ret |= krb5_store_int16 (sp, FCC_TAG_DELTATIME); /* Tag */
 371                 ret |= krb5_store_int16 (sp, 8); /* length of data */
 372                 ret |= krb5_store_int32 (sp, context->kdc_sec_offset);
 373                 ret |= krb5_store_int32 (sp, context->kdc_usec_offset);
 374             } else {
 375                 ret |= krb5_store_int16 (sp, 0);
 376             }
 377         }
 378         ret |= krb5_store_principal(sp, primary_principal);
 379
 380         krb5_storage_free(sp);
 381     }
 382     fcc_unlock(context, fd);
 383     if (close(fd) < 0)
 384         if (ret == 0) {
 385             ret = errno;
 386             krb5_set_error_string (context, "close %s: %s",
 387                                    FILENAME(id), strerror(ret));
 388         }
 389     return ret;
 390 }
 391
 392 static krb5_error_code
 393 fcc_close(krb5_context context,
 394           krb5_ccache id)
 395 {
 396     free (FILENAME(id));
 397     krb5_data_free(&id->data);
 398     return 0;
 399 }
 400
 401 static krb5_error_code
 402 fcc_destroy(krb5_context context,
 403             krb5_ccache id)
 404 {
 405     erase_file(FILENAME(id));
 406     return 0;
 407 }
 408
 409 static krb5_error_code
 410 fcc_store_cred(krb5_context context,
 411                krb5_ccache id,
 412                krb5_creds *creds)
 413 {
 414     int ret;
 415     int fd;
 416
 417     ret = fcc_open(context, id, &fd, O_WRONLY | O_APPEND | O_BINARY, 0);
 418     if(ret)
 419         return ret;
 420     {
 421         krb5_storage *sp;
 422         sp = krb5_storage_from_fd(fd);
 423         krb5_storage_set_eof_code(sp, KRB5_CC_END);
 424         storage_set_flags(context, sp, FCACHE(id)->version);
 425         if (!krb5_config_get_bool_default(context, NULL, TRUE,
 426                                           "libdefaults",
 427                                           "fcc-mit-ticketflags",
 428                                           NULL))
 429             krb5_storage_set_flags(sp, KRB5_STORAGE_CREDS_FLAGS_WRONG_BITORDER);
 430         ret = krb5_store_creds(sp, creds);
 431         krb5_storage_free(sp);
 432     }
 433     fcc_unlock(context, fd);
 434     if (close(fd) < 0)
 435         if (ret == 0) {
 436             ret = errno;
 437             krb5_set_error_string (context, "close %s: %s",
 438                                    FILENAME(id), strerror(ret));
 439         }
 440     return ret;
 441 }
 442
 443 static krb5_error_code
 444 init_fcc (krb5_context context,
 445           krb5_ccache id,
 446           krb5_storage **ret_sp,
 447           int *ret_fd)
 448 {
 449     int fd;
 450     int8_t pvno, tag;
 451     krb5_storage *sp;
 452     krb5_error_code ret;
 453
 454     ret = fcc_open(context, id, &fd, O_RDONLY | O_BINARY, 0);
 455     if(ret)
 456         return ret;
 457
 458     sp = krb5_storage_from_fd(fd);
 459     if(sp == NULL) {
 460         krb5_clear_error_string(context);
 461         ret = ENOMEM;
 462         goto out;
 463     }
 464     krb5_storage_set_eof_code(sp, KRB5_CC_END);
 465     ret = krb5_ret_int8(sp, &pvno);
 466     if(ret != 0) {
 467         if(ret == KRB5_CC_END) {
 468             krb5_set_error_string(context, "Empty credential cache file: %s",
 469                                   FILENAME(id));
 470             ret = ENOENT;
 471         } else
 472             krb5_set_error_string(context, "Error reading pvno in "
 473                                   "cache file: %s", FILENAME(id));
 474         goto out;
 475     }
 476     if(pvno != 5) {
 477         krb5_set_error_string(context, "Bad version number in credential "
 478                               "cache file: %s", FILENAME(id));
 479         ret = KRB5_CCACHE_BADVNO;
 480         goto out;
 481     }
 482     ret = krb5_ret_int8(sp, &tag); /* should not be host byte order */
 483     if(ret != 0) {
 484         krb5_set_error_string(context, "Error reading tag in "
 485                               "cache file: %s", FILENAME(id));
 486         ret = KRB5_CC_FORMAT;
 487         goto out;
 488     }
 489     FCACHE(id)->version = tag;
 490     storage_set_flags(context, sp, FCACHE(id)->version);
 491     switch (tag) {
 492     case KRB5_FCC_FVNO_4: {
 493         int16_t length;
 494
 495         ret = krb5_ret_int16 (sp, &length);
 496         if(ret) {
 497             ret = KRB5_CC_FORMAT;
 498             krb5_set_error_string(context, "Error reading tag length in "
 499                               "cache file: %s", FILENAME(id));
 500             goto out;
 501         }
 502         while(length > 0) {
 503             int16_t dtag, data_len;
 504             int i;
 505             int8_t dummy;
 506
 507             ret = krb5_ret_int16 (sp, &dtag);
 508             if(ret) {
 509                 krb5_set_error_string(context, "Error reading dtag in "
 510                                       "cache file: %s", FILENAME(id));
 511                 ret = KRB5_CC_FORMAT;
 512                 goto out;
 513             }
 514             ret = krb5_ret_int16 (sp, &data_len);
 515             if(ret) {
 516                 krb5_set_error_string(context, "Error reading dlength in "
 517                                       "cache file: %s", FILENAME(id));
 518                 ret = KRB5_CC_FORMAT;
 519                 goto out;
 520             }
 521             switch (dtag) {
 522             case FCC_TAG_DELTATIME :
 523                 ret = krb5_ret_int32 (sp, &context->kdc_sec_offset);
 524                 if(ret) {
 525                     krb5_set_error_string(context, "Error reading kdc_sec in "
 526                                           "cache file: %s", FILENAME(id));
 527                     ret = KRB5_CC_FORMAT;
 528                     goto out;
 529                 }
 530                 ret = krb5_ret_int32 (sp, &context->kdc_usec_offset);
 531                 if(ret) {
 532                     krb5_set_error_string(context, "Error reading kdc_usec in "
 533                                           "cache file: %s", FILENAME(id));
 534                     ret = KRB5_CC_FORMAT;
 535                     goto out;
 536                 }
 537                 break;
 538             default :
 539                 for (i = 0; i < data_len; ++i) {
 540                     ret = krb5_ret_int8 (sp, &dummy);
 541                     if(ret) {
 542                         krb5_set_error_string(context, "Error reading unknown "
 543                                               "tag in cache file: %s",
 544                                               FILENAME(id));
 545                         ret = KRB5_CC_FORMAT;
 546                         goto out;
 547                     }
 548                 }
 549                 break;
 550             }
 551             length -= 4 + data_len;
 552         }
 553         break;
 554     }
 555     case KRB5_FCC_FVNO_3:
 556     case KRB5_FCC_FVNO_2:
 557     case KRB5_FCC_FVNO_1:
 558         break;
 559     default :
 560         ret = KRB5_CCACHE_BADVNO;
 561         krb5_set_error_string(context, "Unknown version number (%d) in "
 562                               "credential cache file: %s",
 563                               (int)tag, FILENAME(id));
 564         goto out;
 565     }
 566     *ret_sp = sp;
 567     *ret_fd = fd;
 568
 569     return 0;
 570   out:
 571     if(sp != NULL)
 572         krb5_storage_free(sp);
 573     fcc_unlock(context, fd);
 574     close(fd);
 575     return ret;
 576 }
 577
 578 static krb5_error_code
 579 fcc_get_principal(krb5_context context,
 580                   krb5_ccache id,
 581                   krb5_principal *principal)
 582 {
 583     krb5_error_code ret;
 584     int fd;
 585     krb5_storage *sp;
 586
 587     ret = init_fcc (context, id, &sp, &fd);
 588     if (ret)
 589         return ret;
 590     ret = krb5_ret_principal(sp, principal);
 591     if (ret)
 592         krb5_clear_error_string(context);
 593     krb5_storage_free(sp);
 594     fcc_unlock(context, fd);
 595     close(fd);
 596     return ret;
 597 }
 598
 599 static krb5_error_code
 600 fcc_end_get (krb5_context context,
 601              krb5_ccache id,
 602              krb5_cc_cursor *cursor);
 603
 604 static krb5_error_code
 605 fcc_get_first (krb5_context context,
 606                krb5_ccache id,
 607                krb5_cc_cursor *cursor)
 608 {
 609     krb5_error_code ret;
 610     krb5_principal principal;
 611
 612     *cursor = malloc(sizeof(struct fcc_cursor));
 613     if (*cursor == NULL) {
 614         krb5_set_error_string (context, "malloc: out of memory");
 615         return ENOMEM;
 616     }
 617     memset(*cursor, 0, sizeof(struct fcc_cursor));
 618
 619     ret = init_fcc (context, id, &FCC_CURSOR(*cursor)->sp,
 620                     &FCC_CURSOR(*cursor)->fd);
 621     if (ret) {
 622         free(*cursor);
 623         *cursor = NULL;
 624         return ret;
 625     }
 626     ret = krb5_ret_principal (FCC_CURSOR(*cursor)->sp, &principal);
 627     if(ret) {
 628         krb5_clear_error_string(context);
 629         fcc_end_get(context, id, cursor);
 630         return ret;
 631     }
 632     krb5_free_principal (context, principal);
 633     fcc_unlock(context, FCC_CURSOR(*cursor)->fd);
 634     return 0;
 635 }
 636
 637 static krb5_error_code
 638 fcc_get_next (krb5_context context,
 639               krb5_ccache id,
 640               krb5_cc_cursor *cursor,
 641               krb5_creds *creds)
 642 {
 643     krb5_error_code ret;
 644     if((ret = fcc_lock(context, id, FCC_CURSOR(*cursor)->fd, FALSE)) != 0)
 645         return ret;
 646
 647     ret = krb5_ret_creds(FCC_CURSOR(*cursor)->sp, creds);
 648     if (ret)
 649         krb5_clear_error_string(context);
 650
 651     fcc_unlock(context, FCC_CURSOR(*cursor)->fd);
 652     return ret;
 653 }
 654
 655 static krb5_error_code
 656 fcc_end_get (krb5_context context,
 657              krb5_ccache id,
 658              krb5_cc_cursor *cursor)
 659 {
 660     krb5_storage_free(FCC_CURSOR(*cursor)->sp);
 661     close (FCC_CURSOR(*cursor)->fd);
 662     free(*cursor);
 663     *cursor = NULL;
 664     return 0;
 665 }
 666
 667 static krb5_error_code
 668 fcc_remove_cred(krb5_context context,
 669                  krb5_ccache id,
 670                  krb5_flags which,
 671                  krb5_creds *cred)
 672 {
 673     krb5_error_code ret;
 674     krb5_ccache copy;
 675
 676     ret = krb5_cc_gen_new(context, &krb5_mcc_ops, &copy);
 677     if (ret)
 678         return ret;
 679
 680     ret = krb5_cc_copy_cache(context, id, copy);
 681     if (ret) {
 682         krb5_cc_destroy(context, copy);
 683         return ret;
 684     }
 685
 686     ret = krb5_cc_remove_cred(context, copy, which, cred);
 687     if (ret) {
 688         krb5_cc_destroy(context, copy);
 689         return ret;
 690     }
 691
 692     fcc_destroy(context, id);
 693
 694     ret = krb5_cc_copy_cache(context, copy, id);
 695     krb5_cc_destroy(context, copy);
 696
 697     return ret;
 698 }
 699
 700 static krb5_error_code
 701 fcc_set_flags(krb5_context context,
 702               krb5_ccache id,
 703               krb5_flags flags)
 704 {
 705     return 0; /* XXX */
 706 }
 707
 708 static krb5_error_code
 709 fcc_get_version(krb5_context context,
 710                 krb5_ccache id)
 711 {
 712     return FCACHE(id)->version;
 713 }
 714
 715 struct fcache_iter {
 716     int first;
 717 };
 718
 719 static krb5_error_code
 720 fcc_get_cache_first(krb5_context context, krb5_cc_cursor *cursor)
 721 {
 722     struct fcache_iter *iter;
 723
 724     iter = calloc(1, sizeof(*iter));
 725     if (iter == NULL) {
 726         krb5_set_error_string(context, "malloc - out of memory");
 727         return ENOMEM;
 728     }
 729     iter->first = 1;
 730     *cursor = iter;
 731     return 0;
 732 }
 733
 734 static krb5_error_code
 735 fcc_get_cache_next(krb5_context context, krb5_cc_cursor cursor, krb5_ccache *id)
 736 {
 737     struct fcache_iter *iter = cursor;
 738     krb5_error_code ret;
 739     const char *fn;
 740     char *expandedfn = NULL;
 741
 742     if (!iter->first) {
 743         krb5_clear_error_string(context);
 744         return KRB5_CC_END;
 745     }
 746     iter->first = 0;
 747
 748     fn = krb5_cc_default_name(context);
 749     if (strncasecmp(fn, "FILE:", 5) != 0) {
 750         ret = _krb5_expand_default_cc_name(context,
 751                                            KRB5_DEFAULT_CCNAME_FILE,
 752                                            &expandedfn);
 753         if (ret)
 754             return ret;
 755     }
 756     ret = krb5_cc_resolve(context, fn, id);
 757     if (expandedfn)
 758         free(expandedfn);
 759
 760     return ret;
 761 }
 762
 763 static krb5_error_code
 764 fcc_end_cache_get(krb5_context context, krb5_cc_cursor cursor)
 765 {
 766     struct fcache_iter *iter = cursor;
 767     free(iter);
 768     return 0;
 769 }
 770
 771 static krb5_error_code
 772 fcc_move(krb5_context context, krb5_ccache from, krb5_ccache to)
 773 {
 774     krb5_error_code ret = 0;
 775
 776     ret = rename(FILENAME(from), FILENAME(to));
 777     if (ret && errno != EXDEV) {
 778         ret = errno;
 779         krb5_set_error_string(context,
 780                               "Rename of file from %s to %s failed: %s",
 781                               FILENAME(from), FILENAME(to),
 782                               strerror(ret));
 783         return ret;
 784     } else if (ret && errno == EXDEV) {
 785         /* make a copy and delete the orignal */
 786         krb5_ssize_t sz1, sz2;
 787         int fd1, fd2;
 788         char buf[BUFSIZ];
 789
 790         ret = fcc_open(context, from, &fd1, O_RDONLY | O_BINARY, 0);
 791         if(ret)
 792             return ret;
 793
 794         unlink(FILENAME(to));
 795
 796         ret = fcc_open(context, to, &fd2,
 797                        O_WRONLY | O_CREAT | O_EXCL | O_BINARY, 0600);
 798         if(ret)
 799             goto out1;
 800
 801         while((sz1 = read(fd1, buf, sizeof(buf))) > 0) {
 802             sz2 = write(fd2, buf, sz1);
 803             if (sz1 != sz2) {
 804                 ret = EIO;
 805                 krb5_set_error_string(context,
 806                                       "Failed to write data from one file "
 807                                       "credential cache to the other");
 808                 goto out2;
 809             }
 810         }
 811         if (sz1 < 0) {
 812             ret = EIO;
 813             krb5_set_error_string(context,
 814                                   "Failed to read data from one file "
 815                                   "credential cache to the other");
 816             goto out2;
 817         }
 818         erase_file(FILENAME(from));
 819
 820     out2:
 821         fcc_unlock(context, fd2);
 822         close(fd2);
 823
 824     out1:
 825         fcc_unlock(context, fd1);
 826         close(fd1);
 827
 828         if (ret) {
 829             erase_file(FILENAME(to));
 830             return ret;
 831         }
 832     }
 833
 834     /* make sure ->version is uptodate */
 835     {
 836         krb5_storage *sp;
 837         int fd;
 838         ret = init_fcc (context, to, &sp, &fd);
 839         krb5_storage_free(sp);
 840         fcc_unlock(context, fd);
 841         close(fd);
 842     }
 843     return ret;
 844 }
 845
 846 static krb5_error_code
 847 fcc_default_name(krb5_context context, char **str)
 848 {
 849     return _krb5_expand_default_cc_name(context,
 850                                         KRB5_DEFAULT_CCNAME_FILE,
 851                                         str);
 852 }
 853
 854 /**
 855  * Variable containing the FILE based credential cache implemention.
 856  *
 857  * @ingroup krb5_ccache
 858  */
 859
 860 const krb5_cc_ops krb5_fcc_ops = {
 861     "FILE",
 862     fcc_get_name,
 863     fcc_resolve,
 864     fcc_gen_new,
 865     fcc_initialize,
 866     fcc_destroy,
 867     fcc_close,
 868     fcc_store_cred,
 869     NULL, /* fcc_retrieve */
 870     fcc_get_principal,
 871     fcc_get_first,
 872     fcc_get_next,
 873     fcc_end_get,
 874     fcc_remove_cred,
 875     fcc_set_flags,
 876     fcc_get_version,
 877     fcc_get_cache_first,
 878     fcc_get_cache_next,
 879     fcc_end_cache_get,
 880     fcc_move,
 881     fcc_default_name
 882 };