lib/kadm5/ipropd_slave.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 "iprop.h"
  35
  36 RCSID("$Id$");
  37
  38 static const char *config_name = "ipropd-slave";
  39
  40 static int verbose;
  41 static int async_hdb = 0;
  42 static int no_keytab_flag;
  43 static char *ccache_str;
  44 static char *keytab_str;
  45
  46 static krb5_log_facility *log_facility;
  47 static char five_min[] = "5 min";
  48 static char *server_time_lost = five_min;
  49 static int time_before_lost;
  50 static const char *slave_str;
  51 static const char *pidfile_basename;
  52 static char *realm;
  53
  54 static int
  55 connect_to_master (krb5_context context, const char *master,
  56                    const char *port_str)
  57 {
  58     char port[NI_MAXSERV];
  59     struct addrinfo *ai, *a;
  60     struct addrinfo hints;
  61     int error;
  62     int one = 1;
  63     int s = -1;
  64
  65     memset(&hints, 0, sizeof(hints));
  66     hints.ai_socktype = SOCK_STREAM;
  67
  68     if (port_str == NULL) {
  69         snprintf(port, sizeof(port), "%u", IPROP_PORT);
  70         port_str = port;
  71     }
  72
  73     if (krb5_config_get_bool(context, NULL, "libdefaults", "block_dns",
  74             NULL)) {
  75         hints.ai_flags &= ~AI_CANONNAME;
  76         hints.ai_flags |= AI_NUMERICHOST|AI_NUMERICSERV;
  77     }
  78     error = getaddrinfo(master, port_str, &hints, &ai);
  79     if (error) {
  80         krb5_warnx(context, "Failed to get address of to %s: %s",
  81                    master, gai_strerror(error));
  82         return -1;
  83     }
  84
  85     for (a = ai; a != NULL; a = a->ai_next) {
  86         char node[NI_MAXHOST];
  87         error = getnameinfo(a->ai_addr, a->ai_addrlen,
  88                             node, sizeof(node), NULL, 0,
  89                             NI_NUMERICHOST|NI_NUMERICSERV|NI_NUMERICSCOPE);
  90         if (error)
  91             strlcpy(node, "[unknown-addr]", sizeof(node));
  92
  93         s = socket(a->ai_family, a->ai_socktype, a->ai_protocol);
  94         if (s < 0)
  95             continue;
  96         if (connect(s, a->ai_addr, a->ai_addrlen) < 0) {
  97             krb5_warn(context, errno, "connection failed to %s[%s]",
  98                       master, node);
  99             close(s);
 100             continue;
 101         }
 102         krb5_warnx(context, "connection successful "
 103                    "to master: %s[%s]", master, node);
 104         break;
 105     }
 106     freeaddrinfo(ai);
 107
 108     if (a == NULL)
 109         return -1;
 110
 111     if (setsockopt(s, SOL_SOCKET, SO_KEEPALIVE, &one, sizeof(one)) < 0)
 112         krb5_warn(context, errno, "setsockopt(SO_KEEPALIVE) failed");
 113
 114     /*
 115      * We write message lengths separately from the payload, avoid Nagle
 116      * delays.
 117      */
 118 #if defined(IPPROTO_TCP) && defined(TCP_NODELAY)
 119     (void) setsockopt(s, IPPROTO_TCP, TCP_NODELAY,
 120                       (void *)&one, sizeof(one));
 121 #endif
 122
 123     return s;
 124 }
 125
 126 static void
 127 get_creds(krb5_context context, krb5_ccache *cache, const char *serverhost)
 128 {
 129     krb5_keytab keytab;
 130     krb5_principal client;
 131     krb5_error_code ret;
 132     krb5_get_init_creds_opt *init_opts;
 133     krb5_creds creds;
 134     char *server;
 135     char keytab_buf[256];
 136     int aret;
 137
 138     if (no_keytab_flag) {
 139         /* We're using an externally refreshed ccache */
 140         if (*cache == NULL) {
 141             if (ccache_str == NULL)
 142                 ret = krb5_cc_default(context, cache);
 143             else
 144                 ret = krb5_cc_resolve(context, ccache_str, cache);
 145             if (ret)
 146                 krb5_err(context, 1, ret, "Could not resolve the default cache");
 147         }
 148         return;
 149     }
 150
 151     if (keytab_str == NULL) {
 152         ret = krb5_kt_default_name (context, keytab_buf, sizeof(keytab_buf));
 153         if (ret == 0) {
 154             keytab_str = keytab_buf;
 155         } else {
 156             krb5_warn(context, ret, "Using HDBGET: as the default keytab");
 157             keytab_str = "HDBGET:";
 158         }
 159     }
 160
 161     if (*cache)
 162         krb5_cc_destroy(context, *cache);
 163     *cache = NULL;
 164
 165     ret = krb5_kt_resolve(context, keytab_str, &keytab);
 166     if(ret)
 167         krb5_err(context, 1, ret, "%s", keytab_str);
 168
 169     ret = krb5_sname_to_principal(context, slave_str, IPROP_NAME,
 170                                   KRB5_NT_SRV_HST, &client);
 171     if (ret) krb5_err(context, 1, ret, "krb5_sname_to_principal");
 172     if (realm)
 173         ret = krb5_principal_set_realm(context, client, realm);
 174     if (ret) krb5_err(context, 1, ret, "krb5_principal_set_realm");
 175
 176     ret = krb5_get_init_creds_opt_alloc(context, &init_opts);
 177     if (ret) krb5_err(context, 1, ret, "krb5_get_init_creds_opt_alloc");
 178
 179     aret = asprintf (&server, "%s/%s", IPROP_NAME, serverhost);
 180     if (aret == -1 || server == NULL)
 181         krb5_errx (context, 1, "malloc: no memory");
 182
 183     ret = krb5_get_init_creds_keytab(context, &creds, client, keytab,
 184                                      0, server, init_opts);
 185     free (server);
 186     krb5_get_init_creds_opt_free(context, init_opts);
 187     if(ret) krb5_err(context, 1, ret, "krb5_get_init_creds");
 188
 189     ret = krb5_kt_close(context, keytab);
 190     if(ret) krb5_err(context, 1, ret, "krb5_kt_close");
 191
 192     ret = krb5_cc_new_unique(context, krb5_cc_type_memory, NULL, cache);
 193     if(ret) krb5_err(context, 1, ret, "krb5_cc_new_unique");
 194
 195     ret = krb5_cc_initialize(context, *cache, creds.client);
 196     if(ret) krb5_err(context, 1, ret, "krb5_cc_initialize");
 197
 198     ret = krb5_cc_store_cred(context, *cache, &creds);
 199     if(ret) krb5_err(context, 1, ret, "krb5_cc_store_cred");
 200
 201     krb5_free_cred_contents(context, &creds);
 202     krb5_free_principal(context, client);
 203 }
 204
 205 static krb5_error_code
 206 ihave(krb5_context context, krb5_auth_context auth_context,
 207       int fd, uint32_t version)
 208 {
 209     int ret;
 210     u_char buf[8];
 211     krb5_storage *sp;
 212     krb5_data data;
 213
 214     sp = krb5_storage_from_mem(buf, 8);
 215     if (sp == NULL)
 216         krb5_err(context, IPROPD_RESTART_SLOW, ENOMEM, "Out of memory");
 217     ret = krb5_store_uint32(sp, I_HAVE);
 218     if (ret == 0)
 219         ret = krb5_store_uint32(sp, version);
 220     krb5_storage_free(sp);
 221     data.length = 8;
 222     data.data   = buf;
 223
 224     if (ret == 0) {
 225         if (verbose)
 226             krb5_warnx(context, "telling master we are at %u", version);
 227
 228         ret = krb5_write_priv_message(context, auth_context, &fd, &data);
 229         if (ret)
 230             krb5_warn(context, ret, "krb5_write_message");
 231     }
 232     return ret;
 233 }
 234
 235 #ifndef EDQUOT
 236 /* There's no EDQUOT on WIN32, for example */
 237 #define EDQUOT ENOSPC
 238 #endif
 239
 240 static int
 241 append_to_log_file(krb5_context context,
 242                    kadm5_server_context *server_context,
 243                    krb5_storage *sp, off_t start, ssize_t slen)
 244 {
 245     size_t len;
 246     ssize_t sret;
 247     off_t log_off;
 248     int ret, ret2;
 249     void *buf;
 250
 251     if (verbose)
 252         krb5_warnx(context, "appending diffs to log");
 253
 254     if (slen == 0)
 255         return 0;
 256     if (slen < 0)
 257         return EINVAL;
 258     len = slen;
 259     if (len != slen)
 260         return EOVERFLOW;
 261
 262     buf = malloc(len);
 263     if (buf == NULL && len != 0)
 264         return krb5_enomem(context);
 265
 266     if (krb5_storage_seek(sp, start, SEEK_SET) != start) {
 267         krb5_errx(context, IPROPD_RESTART,
 268                   "krb5_storage_seek() failed"); /* can't happen */
 269     }
 270     sret = krb5_storage_read(sp, buf, len);
 271     if (sret < 0)
 272         return errno;
 273     if (len != (size_t)sret) {
 274         /* Can't happen */
 275         krb5_errx(context, IPROPD_RESTART,
 276                   "short krb5_storage_read() from memory buffer");
 277     }
 278     log_off = lseek(server_context->log_context.log_fd, 0, SEEK_CUR);
 279     if (log_off == -1)
 280         return errno;
 281
 282     /*
 283      * Use net_write() so we get an errno if less that len bytes were
 284      * written.
 285      */
 286     sret = net_write(server_context->log_context.log_fd, buf, len);
 287     free(buf);
 288     if (sret != slen)
 289         ret = errno;
 290     else
 291         ret = fsync(server_context->log_context.log_fd);
 292     if (ret == 0)
 293         return 0;
 294     krb5_warn(context, ret,
 295               "Failed to write iprop log fd %d %llu bytes at offset %lld: %d",
 296               server_context->log_context.log_fd, (unsigned long long)len,
 297               (long long)log_off, ret);
 298
 299     /*
 300      * Attempt to recover from this.  First, truncate the log file
 301      * and reset the fd offset.  Failure to do this -> unlink the
 302      * log file and re-create it.  Since we're the slave, we ought to be
 303      * able to recover from the log being unlinked...
 304      */
 305     if (ftruncate(server_context->log_context.log_fd, log_off) == -1 ||
 306         lseek(server_context->log_context.log_fd, log_off, SEEK_SET) == -1) {
 307         (void) kadm5_log_end(server_context);
 308         if (unlink(server_context->log_context.log_file) == -1) {
 309             krb5_err(context, IPROPD_FATAL, errno,
 310                      "Failed to recover from failure to write log "
 311                      "entries from master to disk");
 312         }
 313         ret2 = kadm5_log_init(server_context);
 314         if (ret2) {
 315             krb5_err(context, IPROPD_RESTART_SLOW, ret2,
 316                      "Failed to initialize log to recover from "
 317                      "failure to write log entries from master to disk");
 318         }
 319     }
 320     if (ret == ENOSPC || ret == EDQUOT || ret == EFBIG) {
 321         /* Unlink the file in these cases. */
 322         krb5_warn(context, IPROPD_RESTART_SLOW,
 323                   "Failed to write log entries from master to disk");
 324         (void) kadm5_log_end(server_context);
 325         if (unlink(server_context->log_context.log_file) == -1) {
 326             krb5_err(context, IPROPD_FATAL, errno,
 327                      "Failed to recover from failure to write log "
 328                      "entries from master to disk");
 329         }
 330         ret2 = kadm5_log_init(server_context);
 331         if (ret2) {
 332             krb5_err(context, IPROPD_RESTART_SLOW, ret2,
 333                      "Failed to initialize log to recover from "
 334                      "failure to write log entries from master to disk");
 335         }
 336         return ret;
 337     }
 338     /*
 339      * All other errors we treat as fatal here.  This includes, for
 340      * example, EIO and EPIPE (sorry, can't log to pipes nor sockets).
 341      */
 342     krb5_err(context, IPROPD_FATAL, ret,
 343              "Failed to write log entries from master to disk");
 344 }
 345
 346 static int
 347 receive_loop(krb5_context context,
 348              krb5_storage *sp,
 349              kadm5_server_context *server_context)
 350 {
 351     int ret;
 352     off_t left, right, off;
 353     uint32_t len, vers;
 354
 355     if (verbose)
 356         krb5_warnx(context, "receiving diffs");
 357
 358     ret = kadm5_log_exclusivelock(server_context);
 359     if (ret)
 360         krb5_err(context, IPROPD_RESTART, ret,
 361                  "Failed to lock iprop log for writes");
 362
 363     /*
 364      * Seek to the first entry in the message from the master that is
 365      * past the current version of the local database.
 366      */
 367     do {
 368         uint32_t timestamp;
 369         uint32_t op;
 370
 371         if ((ret = krb5_ret_uint32(sp, &vers)) == HEIM_ERR_EOF) {
 372             krb5_warnx(context, "master sent no new iprop entries");
 373             return 0;
 374         }
 375
 376         /*
 377          * TODO We could do more to validate the entries from the master
 378          * here.  And we could use/reuse more kadm5_log_*() code here.
 379          *
 380          * Alternatively we should trust that the master sent us exactly
 381          * what we needed and just write this to the log file and let
 382          * kadm5_log_recover() do the rest.
 383          */
 384         if (ret || krb5_ret_uint32(sp, &timestamp) != 0 ||
 385             krb5_ret_uint32(sp, &op) != 0 ||
 386             krb5_ret_uint32(sp, &len) != 0) {
 387
 388             /*
 389              * This shouldn't happen.  Reconnecting probably won't help
 390              * if it does happen, but by reconnecting we get a chance to
 391              * connect to a new master if a new one is configured.
 392              */
 393             krb5_warnx(context, "iprop entries from master were truncated");
 394             return EINVAL;
 395         }
 396         if (vers > server_context->log_context.version) {
 397             break;
 398         }
 399         off = krb5_storage_seek(sp, 0, SEEK_CUR);
 400         if (krb5_storage_seek(sp, len + 8, SEEK_CUR) != off + len + 8) {
 401             krb5_warnx(context, "iprop entries from master were truncated");
 402             return EINVAL;
 403         }
 404         if (verbose) {
 405             krb5_warnx(context, "diff contains old log record version "
 406                        "%u %lld %u length %u",
 407                        vers, (long long)timestamp, op, len);
 408         }
 409     } while(vers <= server_context->log_context.version);
 410
 411     /*
 412      * Read the remaining entries into memory...
 413      */
 414     /* SEEK_CUR is a header into the first entry we care about */
 415     left  = krb5_storage_seek(sp, -16, SEEK_CUR);
 416     right = krb5_storage_seek(sp, 0, SEEK_END);
 417     if (right - left < 24 + len) {
 418         krb5_warnx(context, "iprop entries from master were truncated");
 419         return EINVAL;
 420     }
 421
 422     /*
 423      * ...and then write them out to the on-disk log.
 424      */
 425
 426     ret = append_to_log_file(context, server_context, sp, left, right - left);
 427     if (ret)
 428         return ret;
 429
 430     /*
 431      * Replay the new entries.
 432      */
 433     if (verbose)
 434         krb5_warnx(context, "replaying entries from master");
 435     ret = kadm5_log_recover(server_context, kadm_recover_replay);
 436     if (ret) {
 437         krb5_warn(context, ret, "replay failed");
 438         return ret;
 439     }
 440
 441     ret = kadm5_log_get_version(server_context, &vers);
 442     if (ret) {
 443         krb5_warn(context, ret,
 444                   "could not get log version after applying diffs!");
 445         return ret;
 446     }
 447     if (verbose)
 448         krb5_warnx(context, "slave at version %u", vers);
 449
 450     if (vers != server_context->log_context.version) {
 451         krb5_warnx(context, "slave's log_context version (%u) is "
 452                    "inconsistent with log's version (%u)",
 453                    server_context->log_context.version, vers);
 454     }
 455
 456     return 0;
 457 }
 458
 459 static int
 460 receive(krb5_context context,
 461         krb5_storage *sp,
 462         kadm5_server_context *server_context)
 463 {
 464     krb5_error_code ret, ret2;
 465     HDB *mydb = server_context->db;
 466
 467     ret = mydb->hdb_open(context, server_context->db, O_RDWR | O_CREAT, 0600);
 468     if (ret)
 469         krb5_err(context, IPROPD_RESTART_SLOW, ret, "db->open");
 470
 471     (void) mydb->hdb_set_sync(context, mydb, !async_hdb);
 472     ret2 = receive_loop(context, sp, server_context);
 473     if (ret2)
 474         krb5_warn(context, ret2, "receive from ipropd-master had errors");
 475
 476     ret = mydb->hdb_close(context, server_context->db);
 477     if (ret)
 478         krb5_err(context, IPROPD_RESTART_SLOW, ret, "db->close");
 479
 480     (void) kadm5_log_sharedlock(server_context);
 481     if (verbose)
 482         krb5_warnx(context, "downgraded iprop log lock to shared");
 483     kadm5_log_signal_master(server_context);
 484     if (verbose)
 485         krb5_warnx(context, "signaled master for hierarchical iprop");
 486     return ret2;
 487 }
 488
 489 static void
 490 send_im_here(krb5_context context, int fd,
 491              krb5_auth_context auth_context)
 492 {
 493     krb5_storage *sp;
 494     krb5_data data;
 495     krb5_error_code ret;
 496
 497     ret = krb5_data_alloc(&data, 4);
 498     if (ret)
 499         krb5_err(context, IPROPD_RESTART, ret, "send_im_here");
 500
 501     sp = krb5_storage_from_data (&data);
 502     if (sp == NULL)
 503         krb5_errx(context, IPROPD_RESTART, "krb5_storage_from_data");
 504     ret = krb5_store_uint32(sp, I_AM_HERE);
 505     krb5_storage_free(sp);
 506
 507     if (ret == 0) {
 508         ret = krb5_write_priv_message(context, auth_context, &fd, &data);
 509         krb5_data_free(&data);
 510
 511         if (ret)
 512             krb5_err(context, IPROPD_RESTART, ret, "krb5_write_priv_message");
 513
 514         if (verbose)
 515             krb5_warnx(context, "pinged master");
 516     }
 517
 518     return;
 519 }
 520
 521 static void
 522 reinit_log(krb5_context context,
 523            kadm5_server_context *server_context,
 524            uint32_t vno)
 525 {
 526     krb5_error_code ret;
 527
 528     if (verbose)
 529         krb5_warnx(context, "truncating log on slave");
 530
 531     ret = kadm5_log_reinit(server_context, vno);
 532     if (ret)
 533         krb5_err(context, IPROPD_RESTART_SLOW, ret, "kadm5_log_reinit");
 534     (void) kadm5_log_sharedlock(server_context);
 535     if (verbose)
 536         krb5_warnx(context, "downgraded iprop log lock to shared");
 537 }
 538
 539
 540 static krb5_error_code
 541 receive_everything(krb5_context context, int fd,
 542                    kadm5_server_context *server_context,
 543                    krb5_auth_context auth_context)
 544 {
 545     int ret;
 546     krb5_data data;
 547     uint32_t vno = 0;
 548     uint32_t opcode;
 549     krb5_storage *sp;
 550
 551     char *dbname;
 552     HDB *mydb;
 553
 554     krb5_warnx(context, "receive complete database");
 555
 556     ret = kadm5_log_exclusivelock(server_context);
 557     if (ret)
 558         krb5_err(context, IPROPD_RESTART, ret,
 559                  "Failed to lock iprop log for writes");
 560     if (server_context->db->hdb_method_name) {
 561         ret = asprintf(&dbname, "%.*s:%s-NEW",
 562                        (int) strlen(server_context->db->hdb_method_name) - 1,
 563                        server_context->db->hdb_method_name,
 564                        server_context->db->hdb_name);
 565     } else {
 566         ret = asprintf(&dbname, "%s-NEW", server_context->db->hdb_name);
 567     }
 568     if (ret == -1)
 569         krb5_err(context, IPROPD_RESTART, ENOMEM, "asprintf");
 570     ret = hdb_create(context, &mydb, dbname);
 571     if(ret)
 572         krb5_err(context, IPROPD_RESTART, ret, "hdb_create");
 573     free(dbname);
 574
 575     ret = hdb_set_master_keyfile(context,
 576                                  mydb, server_context->config.stash_file);
 577     if(ret)
 578         krb5_err(context, IPROPD_RESTART, ret, "hdb_set_master_keyfile");
 579
 580     /* I really want to use O_EXCL here, but given that I can't easily clean
 581        up on error, I won't */
 582     ret = mydb->hdb_open(context, mydb, O_RDWR | O_CREAT | O_TRUNC, 0600);
 583     if (ret)
 584         krb5_err(context, IPROPD_RESTART, ret, "db->open");
 585
 586     (void) mydb->hdb_set_sync(context, mydb, 0);
 587
 588     sp = NULL;
 589     krb5_data_zero(&data);
 590     do {
 591         ret = krb5_read_priv_message(context, auth_context, &fd, &data);
 592
 593         if (ret) {
 594             krb5_warn(context, ret, "krb5_read_priv_message");
 595             goto cleanup;
 596         }
 597
 598         sp = krb5_storage_from_data(&data);
 599         if (sp == NULL)
 600             krb5_errx(context, IPROPD_RESTART, "krb5_storage_from_data");
 601         krb5_ret_uint32(sp, &opcode);
 602         if (opcode == ONE_PRINC) {
 603             krb5_data fake_data;
 604             hdb_entry entry;
 605
 606             krb5_storage_free(sp);
 607
 608             fake_data.data   = (char *)data.data + 4;
 609             fake_data.length = data.length - 4;
 610
 611             memset(&entry, 0, sizeof(entry));
 612
 613             ret = hdb_value2entry(context, &fake_data, &entry);
 614             if (ret)
 615                 krb5_err(context, IPROPD_RESTART, ret, "hdb_value2entry");
 616             ret = mydb->hdb_store(server_context->context,
 617                                   mydb,
 618                                   0, &entry);
 619             if (ret)
 620                 krb5_err(context, IPROPD_RESTART_SLOW, ret, "hdb_store");
 621
 622             hdb_free_entry(context, mydb, &entry);
 623             krb5_data_free(&data);
 624         } else if (opcode == NOW_YOU_HAVE)
 625             ;
 626         else
 627             krb5_errx(context, 1, "strange opcode %d", opcode);
 628     } while (opcode == ONE_PRINC);
 629
 630     if (opcode != NOW_YOU_HAVE)
 631         krb5_errx(context, IPROPD_RESTART_SLOW,
 632                   "receive_everything: strange %d", opcode);
 633
 634     krb5_ret_uint32(sp, &vno);
 635     krb5_storage_free(sp);
 636
 637     reinit_log(context, server_context, vno);
 638
 639     ret = mydb->hdb_set_sync(context, mydb, !async_hdb);
 640     if (ret)
 641         krb5_err(context, IPROPD_RESTART_SLOW, ret, "failed to sync the received HDB");
 642     ret = mydb->hdb_close(context, mydb);
 643     if (ret)
 644         krb5_err(context, IPROPD_RESTART_SLOW, ret, "db->close");
 645
 646     ret = mydb->hdb_rename(context, mydb, server_context->db->hdb_name);
 647     if (ret)
 648         krb5_err(context, IPROPD_RESTART_SLOW, ret, "db->rename");
 649
 650
 651     return 0;
 652
 653  cleanup:
 654     krb5_data_free(&data);
 655
 656     if (ret)
 657         krb5_err(context, IPROPD_RESTART_SLOW, ret, "db->close");
 658
 659     ret = mydb->hdb_destroy(context, mydb);
 660     if (ret)
 661         krb5_err(context, IPROPD_RESTART, ret, "db->destroy");
 662
 663     krb5_warnx(context, "receive complete database, version %ld", (long)vno);
 664     return ret;
 665 }
 666
 667 static void
 668 slave_status(krb5_context context,
 669              const char *file,
 670              const char *status, ...)
 671      __attribute__ ((__format__ (__printf__, 3, 4)));
 672
 673
 674 static void
 675 slave_status(krb5_context context,
 676              const char *file,
 677              const char *fmt, ...)
 678 {
 679     char *status;
 680     char *fmt2;
 681     va_list args;
 682     int len;
 683
 684     if (asprintf(&fmt2, "%s\n", fmt) == -1 || fmt2 == NULL) {
 685         (void) unlink(file);
 686         return;
 687     }
 688     va_start(args, fmt);
 689     len = vasprintf(&status, fmt2, args);
 690     free(fmt2);
 691     va_end(args);
 692     if (len < 0 || status == NULL) {
 693         (void) unlink(file);
 694         return;
 695     }
 696     rk_dumpdata(file, status, len);
 697     krb5_warnx(context, "slave status change: %s", status);
 698     free(status);
 699 }
 700
 701 static void
 702 is_up_to_date(krb5_context context, const char *file,
 703               kadm5_server_context *server_context)
 704 {
 705     krb5_error_code ret;
 706     char buf[80];
 707     ret = krb5_format_time(context, time(NULL), buf, sizeof(buf), 1);
 708     if (ret) {
 709         unlink(file);
 710         return;
 711     }
 712     slave_status(context, file, "up-to-date with version: %lu at %s",
 713                  (unsigned long)server_context->log_context.version, buf);
 714 }
 715
 716 static char *database;
 717 static char *status_file;
 718 static char *config_file;
 719 static int version_flag;
 720 static int help_flag;
 721 static char *port_str;
 722 static int detach_from_console;
 723 static int daemon_child = -1;
 724
 725 static struct getargs args[] = {
 726     { "config-file", 'c', arg_string, &config_file, NULL, NULL },
 727     { "realm", 'r', arg_string, &realm, NULL, NULL },
 728     { "database", 'd', arg_string, &database, "database", "file"},
 729     { "no-keytab", 0, arg_flag, &no_keytab_flag,
 730       "use externally refreshed cache", NULL },
 731     { "ccache", 0, arg_string, &ccache_str,
 732       "client credentials", "CCACHE" },
 733     { "keytab", 'k', arg_string, &keytab_str,
 734       "client credentials keytab", "KEYTAB" },
 735     { "time-lost", 0, arg_string, &server_time_lost,
 736       "time before server is considered lost", "time" },
 737     { "status-file", 0, arg_string, &status_file,
 738       "file to write out status into", "file" },
 739     { "port", 0, arg_string, &port_str,
 740       "port ipropd-slave will connect to", "port"},
 741     { "detach", 0, arg_flag, &detach_from_console,
 742       "detach from console", NULL },
 743     { "daemon-child", 0, arg_integer, &daemon_child,
 744       "private argument, do not use", NULL },
 745     { "pidfile-basename", 0, arg_string, &pidfile_basename,
 746       "basename of pidfile; private argument for testing", "NAME" },
 747     { "async-hdb", 'a', arg_flag, &async_hdb, NULL, NULL },
 748     { "hostname", 0, arg_string, rk_UNCONST(&slave_str),
 749       "hostname of slave (if not same as hostname)", "hostname" },
 750     { "verbose", 0, arg_flag, &verbose, NULL, NULL },
 751     { "version", 0, arg_flag, &version_flag, NULL, NULL },
 752     { "help", 0, arg_flag, &help_flag, NULL, NULL }
 753 };
 754
 755 static int num_args = sizeof(args) / sizeof(args[0]);
 756
 757 static void
 758 usage(int status)
 759 {
 760     arg_printusage(args, num_args, NULL, "master");
 761     exit(status);
 762 }
 763
 764 int
 765 main(int argc, char **argv)
 766 {
 767     krb5_error_code ret, ret2;
 768     krb5_context context;
 769     krb5_auth_context auth_context;
 770     void *kadm_handle;
 771     kadm5_server_context *server_context;
 772     kadm5_config_params conf;
 773     int master_fd;
 774     krb5_ccache ccache = NULL;
 775     krb5_principal server;
 776     char **files;
 777     int optidx = 0;
 778     time_t reconnect_min;
 779     time_t backoff;
 780     time_t reconnect_max;
 781     time_t reconnect;
 782     time_t before = 0;
 783     int restarter_fd = -1;
 784
 785     const char *master;
 786
 787     setprogname(argv[0]);
 788
 789     if (getarg(args, num_args, argc, argv, &optidx))
 790         usage(1);
 791
 792     if (help_flag)
 793         usage(0);
 794
 795     if (version_flag) {
 796         print_version(NULL);
 797         exit(0);
 798     }
 799
 800     if (detach_from_console && daemon_child == -1)
 801         daemon_child = roken_detach_prep(argc, argv, "--daemon-child");
 802     rk_pidfile(pidfile_basename);
 803
 804     ret = krb5_init_context(&context);
 805     if (ret)
 806         errx (1, "krb5_init_context failed: %d", ret);
 807
 808     setup_signal();
 809
 810     if (config_file == NULL) {
 811         if (asprintf(&config_file, "%s/kdc.conf", hdb_db_dir(context)) == -1
 812             || config_file == NULL)
 813             errx(1, "out of memory");
 814     }
 815
 816     ret = krb5_prepend_config_files_default(config_file, &files);
 817     if (ret)
 818         krb5_err(context, 1, ret, "getting configuration files");
 819
 820     ret = krb5_set_config_files(context, files);
 821     krb5_free_config_files(files);
 822     if (ret)
 823         krb5_err(context, 1, ret, "reading configuration files");
 824
 825     argc -= optidx;
 826     argv += optidx;
 827
 828     if (argc != 1)
 829         usage(1);
 830
 831     master = argv[0];
 832
 833     if (status_file == NULL) {
 834         if (asprintf(&status_file,  "%s/ipropd-slave-status", hdb_db_dir(context)) < 0 || status_file == NULL)
 835             krb5_errx(context, 1, "can't allocate status file buffer");
 836     }
 837
 838     krb5_openlog(context, "ipropd-slave", &log_facility);
 839     krb5_set_warn_dest(context, log_facility);
 840
 841     slave_status(context, status_file, "bootstrapping");
 842
 843     ret = krb5_kt_register(context, &hdb_get_kt_ops);
 844     if(ret)
 845         krb5_err(context, 1, ret, "krb5_kt_register");
 846
 847     time_before_lost = parse_time (server_time_lost,  "s");
 848     if (time_before_lost < 0)
 849         krb5_errx (context, 1, "couldn't parse time: %s", server_time_lost);
 850
 851     slave_status(context, status_file, "getting credentials from keytab/database");
 852
 853     memset(&conf, 0, sizeof(conf));
 854     if(realm) {
 855         conf.mask |= KADM5_CONFIG_REALM;
 856         conf.realm = realm;
 857     }
 858     if (database) {
 859         conf.mask |= KADM5_CONFIG_DBNAME;
 860         conf.dbname = database;
 861     }
 862     ret = kadm5_init_with_password_ctx (context,
 863                                         KADM5_ADMIN_SERVICE,
 864                                         NULL,
 865                                         KADM5_ADMIN_SERVICE,
 866                                         &conf, 0, 0,
 867                                         &kadm_handle);
 868     if (ret)
 869         krb5_err (context, 1, ret, "kadm5_init_with_password_ctx");
 870
 871     server_context = (kadm5_server_context *)kadm_handle;
 872
 873     slave_status(context, status_file, "creating log file");
 874
 875     ret = server_context->db->hdb_open(context,
 876                                        server_context->db,
 877                                        O_RDWR | O_CREAT, 0600);
 878     if (ret)
 879         krb5_err (context, 1, ret, "db->open");
 880
 881     ret = kadm5_log_init(server_context);
 882     if (ret)
 883         krb5_err(context, 1, ret, "kadm5_log_init");
 884     (void) kadm5_log_sharedlock(server_context);
 885     if (verbose)
 886         krb5_warnx(context, "downgraded iprop log lock to shared");
 887
 888     ret = server_context->db->hdb_close(context, server_context->db);
 889     if (ret)
 890         krb5_err(context, 1, ret, "db->close");
 891
 892     get_creds(context, &ccache, master);
 893
 894     ret = krb5_sname_to_principal (context, master, IPROP_NAME,
 895                                    KRB5_NT_SRV_HST, &server);
 896     if (ret)
 897         krb5_err (context, 1, ret, "krb5_sname_to_principal");
 898
 899     auth_context = NULL;
 900     master_fd = -1;
 901
 902     krb5_appdefault_time(context, config_name, NULL, "reconnect-min",
 903                          10, &reconnect_min);
 904     krb5_appdefault_time(context, config_name, NULL, "reconnect-max",
 905                          300, &reconnect_max);
 906     krb5_appdefault_time(context, config_name, NULL, "reconnect-backoff",
 907                          10, &backoff);
 908     reconnect = reconnect_min;
 909
 910     slave_status(context, status_file, "ipropd-slave started");
 911
 912     roken_detach_finish(NULL, daemon_child);
 913     restarter_fd = restarter(context, NULL);
 914
 915     while (!exit_flag) {
 916         struct timeval to;
 917         time_t now, elapsed;
 918         fd_set readset;
 919         int connected = FALSE;
 920
 921 #ifndef NO_LIMIT_FD_SETSIZE
 922         if (restarter_fd >= FD_SETSIZE)
 923             krb5_errx(context, IPROPD_RESTART, "fd too large");
 924 #endif
 925
 926         FD_ZERO(&readset);
 927         if (restarter_fd > -1)
 928             FD_SET(restarter_fd, &readset);
 929
 930         now = time(NULL);
 931         elapsed = now - before;
 932
 933         if (elapsed < reconnect) {
 934             time_t left = reconnect - elapsed;
 935             krb5_warnx(context, "sleeping %d seconds before "
 936                        "retrying to connect", (int)left);
 937             to.tv_sec = left;
 938             to.tv_usec = 0;
 939             if (select(restarter_fd + 1, &readset, NULL, NULL, &to) == 1) {
 940                 exit_flag = SIGTERM;
 941                 continue;
 942             }
 943         }
 944         before = now;
 945
 946         slave_status(context, status_file, "connecting to master: %s\n", master);
 947
 948         master_fd = connect_to_master (context, master, port_str);
 949         if (master_fd < 0)
 950             goto retry;
 951
 952         reconnect = reconnect_min;
 953
 954         if (auth_context) {
 955             krb5_auth_con_free(context, auth_context);
 956             auth_context = NULL;
 957         }
 958         get_creds(context, &ccache, master);
 959         if (verbose)
 960             krb5_warnx(context, "authenticating to master");
 961         ret = krb5_sendauth (context, &auth_context, &master_fd,
 962                              IPROP_VERSION, NULL, server,
 963                              AP_OPTS_MUTUAL_REQUIRED, NULL, NULL,
 964                              ccache, NULL, NULL, NULL);
 965         if (ret) {
 966             krb5_warn (context, ret, "krb5_sendauth");
 967             goto retry;
 968         }
 969
 970         krb5_warnx(context, "ipropd-slave started at version: %ld",
 971                    (long)server_context->log_context.version);
 972
 973         ret = ihave(context, auth_context, master_fd,
 974                     server_context->log_context.version);
 975         if (ret)
 976             goto retry;
 977
 978         connected = TRUE;
 979
 980         if (verbose)
 981             krb5_warnx(context, "connected to master");
 982
 983         slave_status(context, status_file, "connected to master, waiting instructions");
 984
 985         while (connected && !exit_flag) {
 986             krb5_data out;
 987             krb5_storage *sp;
 988             uint32_t tmp;
 989             int max_fd;
 990
 991 #ifndef NO_LIMIT_FD_SETSIZE
 992             if (master_fd >= FD_SETSIZE)
 993                 krb5_errx(context, IPROPD_RESTART, "fd too large");
 994             if (restarter_fd >= FD_SETSIZE)
 995                 krb5_errx(context, IPROPD_RESTART, "fd too large");
 996             max_fd = max(restarter_fd, master_fd);
 997 #endif
 998
 999             FD_ZERO(&readset);
1000             FD_SET(master_fd, &readset);
1001             if (restarter_fd != -1)
1002                 FD_SET(restarter_fd, &readset);
1003
1004             to.tv_sec = time_before_lost;
1005             to.tv_usec = 0;
1006
1007             ret = select (max_fd + 1,
1008                           &readset, NULL, NULL, &to);
1009             if (ret < 0) {
1010                 if (errno == EINTR)
1011                     continue;
1012                 else
1013                     krb5_err (context, 1, errno, "select");
1014             }
1015             if (ret == 0) {
1016                 krb5_warnx(context, "server didn't send a message "
1017                            "in %d seconds", time_before_lost);
1018                 connected = FALSE;
1019                 continue;
1020             }
1021
1022             if (restarter_fd > -1 && FD_ISSET(restarter_fd, &readset)) {
1023                 if (verbose)
1024                     krb5_warnx(context, "slave restarter exited");
1025                 exit_flag = SIGTERM;
1026             }
1027
1028             if (!FD_ISSET(master_fd, &readset))
1029                 continue;
1030
1031             if (verbose)
1032                 krb5_warnx(context, "message from master");
1033
1034             ret = krb5_read_priv_message(context, auth_context, &master_fd, &out);
1035             if (ret) {
1036                 krb5_warn(context, ret, "krb5_read_priv_message");
1037                 connected = FALSE;
1038                 continue;
1039             }
1040
1041             sp = krb5_storage_from_mem (out.data, out.length);
1042             if (sp == NULL)
1043                 krb5_err(context, IPROPD_RESTART, errno, "krb5_storage_from_mem");
1044             ret = krb5_ret_uint32(sp, &tmp);
1045             if (ret == HEIM_ERR_EOF) {
1046                 krb5_warn(context, ret, "master sent zero-length message");
1047                 connected = FALSE;
1048                 continue;
1049             }
1050             if (ret != 0) {
1051                 krb5_warn(context, ret, "couldn't read master's message");
1052                 connected = FALSE;
1053                 continue;
1054             }
1055
1056             /*
1057              * It's unclear why we open th HDB and call kadm5_log_init() here.
1058              *
1059              * We don't need it to process the log entries we receive in the
1060              * FOR_YOU case: we already call kadm5_log_recover() in receive() /
1061              * receive_loop().  Maybe it's just just in case, though at the
1062              * cost of synchronization with ipropd-master if we're running one
1063              * for hierarchical iprop.
1064              */
1065             ret = server_context->db->hdb_open(context,
1066                                                server_context->db,
1067                                                O_RDWR | O_CREAT, 0600);
1068             if (ret)
1069                 krb5_err (context, 1, ret, "db->open while handling a "
1070                           "message from the master");
1071             ret = kadm5_log_init(server_context);
1072             if (ret) {
1073                 krb5_err(context, IPROPD_RESTART, ret, "kadm5_log_init while "
1074                          "handling a message from the master");
1075             }
1076             (void) kadm5_log_sharedlock(server_context);
1077             if (verbose)
1078                 krb5_warnx(context, "downgraded iprop log lock to shared");
1079
1080             ret = server_context->db->hdb_close (context, server_context->db);
1081             if (ret)
1082                 krb5_err (context, 1, ret, "db->close while handling a "
1083                           "message from the master");
1084
1085             switch (tmp) {
1086             case FOR_YOU :
1087                 if (verbose)
1088                     krb5_warnx(context, "master sent us diffs");
1089                 ret2 = receive(context, sp, server_context);
1090                 if (ret2)
1091                     krb5_warn(context, ret2,
1092                               "receive from ipropd-master had errors");
1093                 ret = ihave(context, auth_context, master_fd,
1094                             server_context->log_context.version);
1095                 if (ret || ret2)
1096                     connected = FALSE;
1097
1098                 /*
1099                  * If it returns an error, receive() may nonetheless
1100                  * have committed some entries successfully, so we must
1101                  * update the slave_status even if there were errors.
1102                  */
1103                 is_up_to_date(context, status_file, server_context);
1104                 break;
1105             case TELL_YOU_EVERYTHING :
1106                 if (verbose)
1107                     krb5_warnx(context, "master sent us a full dump");
1108                 ret = receive_everything(context, master_fd, server_context,
1109                                          auth_context);
1110                 (void) kadm5_log_sharedlock(server_context);
1111                 if (ret == 0) {
1112                     ret = ihave(context, auth_context, master_fd,
1113                                 server_context->log_context.version);
1114                 }
1115                 if (ret)
1116                     connected = FALSE;
1117                 else
1118                     is_up_to_date(context, status_file, server_context);
1119                 if (verbose)
1120                     krb5_warnx(context, "downgraded iprop log lock to shared");
1121                 kadm5_log_signal_master(server_context);
1122                 if (verbose)
1123                     krb5_warnx(context, "signaled master for hierarchical iprop");
1124                 break;
1125             case ARE_YOU_THERE :
1126                 if (verbose)
1127                     krb5_warnx(context, "master sent us a ping");
1128                 is_up_to_date(context, status_file, server_context);
1129                 /*
1130                  * We used to send an I_HAVE here.  But the master may send
1131                  * ARE_YOU_THERE messages in response to local, possibly-
1132                  * transient errors, and if that happens and we respond with an
1133                  * I_HAVE then we'll loop hard if the error was not transient.
1134                  *
1135                  * So we don't ihave() here.
1136                  */
1137                 send_im_here(context, master_fd, auth_context);
1138                 break;
1139             case YOU_HAVE_LAST_VERSION:
1140                 if (verbose)
1141                     krb5_warnx(context, "master tells us we are up to date");
1142                 is_up_to_date(context, status_file, server_context);
1143                 break;
1144             case NOW_YOU_HAVE :
1145             case I_HAVE :
1146             case ONE_PRINC :
1147             case I_AM_HERE :
1148             default :
1149                 krb5_warnx (context, "Ignoring command %d", tmp);
1150                 break;
1151             }
1152             krb5_storage_free (sp);
1153             krb5_data_free (&out);
1154
1155         }
1156
1157         slave_status(context, status_file, "disconnected from master");
1158     retry:
1159         if (connected == FALSE)
1160             krb5_warnx (context, "disconnected for server");
1161
1162         if (exit_flag)
1163             krb5_warnx (context, "got an exit signal");
1164
1165         if (master_fd >= 0)
1166             close(master_fd);
1167
1168         reconnect += backoff;
1169         if (reconnect > reconnect_max) {
1170             slave_status(context, status_file, "disconnected from master for a long time");
1171             reconnect = reconnect_max;
1172         }
1173     }
1174
1175     if (status_file) {
1176         /* XXX It'd be better to leave it saying we're not here */
1177         unlink(status_file);
1178     }
1179
1180     if (0);
1181 #ifndef NO_SIGXCPU
1182     else if(exit_flag == SIGXCPU)
1183         krb5_warnx(context, "%s CPU time limit exceeded", getprogname());
1184 #endif
1185     else if(exit_flag == SIGINT || exit_flag == SIGTERM)
1186         krb5_warnx(context, "%s terminated", getprogname());
1187     else
1188         krb5_warnx(context, "%s unexpected exit reason: %ld",
1189                        getprogname(), (long)exit_flag);
1190
1191     return 0;
1192 }