Debian Codegraph @

lib/kadm5/ipropd_slave.c

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