1 /* $NetBSD: ipropd_master.c,v 1.3 2023/06/19 21:41:44 christos Exp $ */
2
3 /*
4 * Copyright (c) 1997 - 2008 Kungliga Tekniska Högskolan
5 * (Royal Institute of Technology, Stockholm, Sweden).
6 * All rights reserved.
7 *
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions
10 * are met:
11 *
12 * 1. Redistributions of source code must retain the above copyright
13 * notice, this list of conditions and the following disclaimer.
14 *
15 * 2. Redistributions in binary form must reproduce the above copyright
16 * notice, this list of conditions and the following disclaimer in the
17 * documentation and/or other materials provided with the distribution.
18 *
19 * 3. Neither the name of the Institute nor the names of its contributors
20 * may be used to endorse or promote products derived from this software
21 * without specific prior written permission.
22 *
23 * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
24 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
25 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
26 * ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
27 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
28 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
29 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
30 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
31 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
32 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
33 * SUCH DAMAGE.
34 */
35
36 #include "iprop.h"
37 #include <krb5/rtbl.h>
38
39 static krb5_log_facility *log_facility;
40
41 static int verbose;
42
43 const char *slave_stats_file;
44 const char *slave_time_missing = "2 min";
45 const char *slave_time_gone = "5 min";
46
47 static int time_before_missing;
48 static int time_before_gone;
49
50 const char *master_hostname;
51
52 static krb5_socket_t
make_signal_socket(krb5_context context)53 make_signal_socket (krb5_context context)
54 {
55 #ifndef NO_UNIX_SOCKETS
56 struct sockaddr_un addr;
57 const char *fn;
58 krb5_socket_t fd;
59
60 fn = kadm5_log_signal_socket(context);
61
62 fd = socket (AF_UNIX, SOCK_DGRAM, 0);
63 if (fd < 0)
64 krb5_err (context, 1, errno, "socket AF_UNIX");
65 memset (&addr, 0, sizeof(addr));
66 addr.sun_family = AF_UNIX;
67 strlcpy (addr.sun_path, fn, sizeof(addr.sun_path));
68 unlink (addr.sun_path);
69 if (bind (fd, (struct sockaddr *)&addr, sizeof(addr)) < 0)
70 krb5_err (context, 1, errno, "bind %s", addr.sun_path);
71 return fd;
72 #else
73 struct addrinfo *ai = NULL;
74 krb5_socket_t fd;
75
76 kadm5_log_signal_socket_info(context, 1, &ai);
77
78 fd = socket(ai->ai_family, ai->ai_socktype, ai->ai_protocol);
79 if (rk_IS_BAD_SOCKET(fd))
80 krb5_err (context, 1, rk_SOCK_ERRNO, "socket AF=%d", ai->ai_family);
81
82 if (rk_IS_SOCKET_ERROR( bind (fd, ai->ai_addr, ai->ai_addrlen) ))
83 krb5_err (context, 1, rk_SOCK_ERRNO, "bind");
84 return fd;
85 #endif
86 }
87
88 static krb5_socket_t
make_listen_socket(krb5_context context,const char * port_str)89 make_listen_socket (krb5_context context, const char *port_str)
90 {
91 krb5_socket_t fd;
92 int one = 1;
93 struct sockaddr_in addr;
94
95 fd = socket (AF_INET, SOCK_STREAM, 0);
96 if (rk_IS_BAD_SOCKET(fd))
97 krb5_err (context, 1, rk_SOCK_ERRNO, "socket AF_INET");
98 setsockopt (fd, SOL_SOCKET, SO_REUSEADDR, (void *)&one, sizeof(one));
99 memset (&addr, 0, sizeof(addr));
100 addr.sin_family = AF_INET;
101
102 if (port_str) {
103 addr.sin_port = krb5_getportbyname (context,
104 port_str, "tcp",
105 0);
106 if (addr.sin_port == 0) {
107 char *ptr;
108 long port;
109
110 port = strtol (port_str, &ptr, 10);
111 if (port == 0 && ptr == port_str)
112 krb5_errx (context, 1, "bad port `%s'", port_str);
113 addr.sin_port = htons(port);
114 }
115 } else {
116 addr.sin_port = krb5_getportbyname (context, IPROP_SERVICE,
117 "tcp", IPROP_PORT);
118 }
119 if(bind(fd, (struct sockaddr *)&addr, sizeof(addr)) < 0)
120 krb5_err (context, 1, errno, "bind");
121 if (listen(fd, SOMAXCONN) < 0)
122 krb5_err (context, 1, errno, "listen");
123 return fd;
124 }
125
126
127 struct slave {
128 krb5_socket_t fd;
129 struct sockaddr_in addr;
130 char *name;
131 krb5_auth_context ac;
132 uint32_t version;
133 uint32_t version_tstamp;
134 uint32_t version_ack;
135 time_t seen;
136 unsigned long flags;
137 #define SLAVE_F_DEAD 0x1
138 #define SLAVE_F_AYT 0x2
139 #define SLAVE_F_READY 0x4
140 /*
141 * We'll use non-blocking I/O so no slave can hold us back.
142 *
143 * We call the state left over from a partial write a "tail".
144 *
145 * The krb5_data holding an KRB-PRIV will be the write buffer.
146 */
147 struct {
148 /* Every message we send is a KRB-PRIV with a 4-byte length prefixed */
149 uint8_t header_buf[4];
150 krb5_data header;
151 krb5_data packet;
152 size_t packet_off;
153 /* For send_complete() we need an sp as part of the tail */
154 krb5_storage *dump;
155 uint32_t vno;
156 } tail;
157 struct {
158 uint8_t header_buf[4];
159 krb5_data packet;
160 size_t offset;
161 int hlen;
162 } input;
163 /*
164 * Continuation for fair diff sending we send N entries at a time.
165 */
166 struct {
167 off_t off_next_version; /* offset in log of next diff */
168 uint32_t initial_version; /* at time of previous diff */
169 uint32_t initial_tstamp; /* at time of previous diff */
170 uint32_t last_version_sent;
171 int more; /* need to send more diffs */
172 } next_diff;
173 struct slave *next;
174 };
175
176 typedef struct slave slave;
177
178 static int
check_acl(krb5_context context,const char * name)179 check_acl (krb5_context context, const char *name)
180 {
181 const char *fn;
182 FILE *fp;
183 char buf[256];
184 int ret = 1;
185 char *slavefile = NULL;
186
187 if (asprintf(&slavefile, "%s/slaves", hdb_db_dir(context)) == -1
188 || slavefile == NULL)
189 errx(1, "out of memory");
190
191 fn = krb5_config_get_string_default(context,
192 NULL,
193 slavefile,
194 "kdc",
195 "iprop-acl",
196 NULL);
197
198 fp = fopen (fn, "r");
199 free(slavefile);
200 if (fp == NULL)
201 return 1;
202 while (fgets(buf, sizeof(buf), fp) != NULL) {
203 buf[strcspn(buf, "\r\n")] = '\0';
204 if (strcmp (buf, name) == 0) {
205 ret = 0;
206 break;
207 }
208 }
209 fclose (fp);
210 return ret;
211 }
212
213 static void
slave_seen(slave * s)214 slave_seen(slave *s)
215 {
216 s->flags &= ~SLAVE_F_AYT;
217 s->seen = time(NULL);
218 }
219
220 static int
slave_missing_p(slave * s)221 slave_missing_p (slave *s)
222 {
223 if (time(NULL) > s->seen + time_before_missing)
224 return 1;
225 return 0;
226 }
227
228 static int
slave_gone_p(slave * s)229 slave_gone_p (slave *s)
230 {
231 if (time(NULL) > s->seen + time_before_gone)
232 return 1;
233 return 0;
234 }
235
236 static void
slave_dead(krb5_context context,slave * s)237 slave_dead(krb5_context context, slave *s)
238 {
239 krb5_warnx(context, "slave %s dead", s->name);
240
241 if (!rk_IS_BAD_SOCKET(s->fd)) {
242 rk_closesocket (s->fd);
243 s->fd = rk_INVALID_SOCKET;
244 }
245 s->flags |= SLAVE_F_DEAD;
246 slave_seen(s);
247 }
248
249 static void
remove_slave(krb5_context context,slave * s,slave ** root)250 remove_slave (krb5_context context, slave *s, slave **root)
251 {
252 slave **p;
253
254 if (!rk_IS_BAD_SOCKET(s->fd))
255 rk_closesocket (s->fd);
256 if (s->name)
257 free (s->name);
258 if (s->ac)
259 krb5_auth_con_free (context, s->ac);
260
261 /* Free any pending input/output state */
262 krb5_data_free(&s->input.packet);
263 krb5_data_free(&s->tail.packet);
264 krb5_storage_free(s->tail.dump);
265
266 for (p = root; *p; p = &(*p)->next)
267 if (*p == s) {
268 *p = s->next;
269 break;
270 }
271 free (s);
272 }
273
274 static void
add_slave(krb5_context context,krb5_keytab keytab,slave ** root,krb5_socket_t fd)275 add_slave (krb5_context context, krb5_keytab keytab, slave **root,
276 krb5_socket_t fd)
277 {
278 krb5_principal server;
279 krb5_error_code ret;
280 slave *s;
281 socklen_t addr_len;
282 krb5_ticket *ticket = NULL;
283 char hostname[128];
284
285 s = calloc(1, sizeof(*s));
286 if (s == NULL) {
287 krb5_warnx (context, "add_slave: no memory");
288 return;
289 }
290 s->name = NULL;
291 s->ac = NULL;
292 s->input.packet.data = NULL;
293 s->tail.header.data = NULL;
294 s->tail.packet.data = NULL;
295 s->tail.dump = NULL;
296
297 addr_len = sizeof(s->addr);
298 s->fd = accept (fd, (struct sockaddr *)&s->addr, &addr_len);
299 if (rk_IS_BAD_SOCKET(s->fd)) {
300 krb5_warn (context, rk_SOCK_ERRNO, "accept");
301 goto error;
302 }
303
304 if (master_hostname)
305 strlcpy(hostname, master_hostname, sizeof(hostname));
306 else
307 gethostname(hostname, sizeof(hostname));
308
309 ret = krb5_sname_to_principal (context, hostname, IPROP_NAME,
310 KRB5_NT_SRV_HST, &server);
311 if (ret) {
312 krb5_warn (context, ret, "krb5_sname_to_principal");
313 goto error;
314 }
315
316 ret = krb5_recvauth (context, &s->ac, &s->fd,
317 IPROP_VERSION, server, 0, keytab, &ticket);
318
319 /*
320 * We'll be doing non-blocking I/O only after authentication. We don't
321 * want to get stuck talking to any one slave.
322 *
323 * If we get a partial write, we'll finish writing when the socket becomes
324 * writable.
325 *
326 * Partial reads will be treated as EOF, causing the slave to be marked
327 * dead.
328 *
329 * To do non-blocking I/O for authentication we'll have to implement our
330 * own krb5_recvauth().
331 */
332 socket_set_nonblocking(s->fd, 1);
333
334 /*
335 * We write message lengths separately from the payload, and may do
336 * back-to-back small writes when flushing pending input and then a new
337 * update. Avoid Nagle delays.
338 */
339 #if defined(IPPROTO_TCP) && defined(TCP_NODELAY)
340 {
341 int nodelay = 1;
342 (void) setsockopt(s->fd, IPPROTO_TCP, TCP_NODELAY,
343 (void *)&nodelay, sizeof(nodelay));
344 }
345 #endif
346
347 krb5_free_principal (context, server);
348 if (ret) {
349 krb5_warn (context, ret, "krb5_recvauth");
350 goto error;
351 }
352 ret = krb5_unparse_name (context, ticket->client, &s->name);
353 krb5_free_ticket (context, ticket);
354 if (ret) {
355 krb5_warn (context, ret, "krb5_unparse_name");
356 goto error;
357 }
358 if (check_acl (context, s->name)) {
359 krb5_warnx (context, "%s not in acl", s->name);
360 goto error;
361 }
362
363 {
364 slave *l = *root;
365
366 while (l) {
367 if (strcmp(l->name, s->name) == 0)
368 break;
369 l = l->next;
370 }
371 if (l) {
372 if (l->flags & SLAVE_F_DEAD) {
373 remove_slave(context, l, root);
374 } else {
375 krb5_warnx (context, "second connection from %s", s->name);
376 goto error;
377 }
378 }
379 }
380
381 krb5_warnx (context, "connection from %s", s->name);
382
383 s->version = 0;
384 s->version_ack = 0;
385 s->flags = 0;
386 slave_seen(s);
387 s->next = *root;
388 *root = s;
389 return;
390 error:
391 remove_slave(context, s, root);
392 }
393
394 static int
dump_one(krb5_context context,HDB * db,hdb_entry_ex * entry,void * v)395 dump_one (krb5_context context, HDB *db, hdb_entry_ex *entry, void *v)
396 {
397 krb5_error_code ret;
398 krb5_storage *dump = (krb5_storage *)v;
399 krb5_storage *sp;
400 krb5_data data;
401
402 ret = hdb_entry2value (context, &entry->entry, &data);
403 if (ret)
404 return ret;
405 ret = krb5_data_realloc (&data, data.length + 4);
406 if (ret)
407 goto done;
408 memmove ((char *)data.data + 4, data.data, data.length - 4);
409 sp = krb5_storage_from_data(&data);
410 if (sp == NULL) {
411 ret = ENOMEM;
412 goto done;
413 }
414 ret = krb5_store_uint32(sp, ONE_PRINC);
415 krb5_storage_free(sp);
416
417 if (ret == 0)
418 ret = krb5_store_data(dump, data);
419
420 done:
421 krb5_data_free (&data);
422 return ret;
423 }
424
425 static int
write_dump(krb5_context context,krb5_storage * dump,const char * database,uint32_t current_version)426 write_dump (krb5_context context, krb5_storage *dump,
427 const char *database, uint32_t current_version)
428 {
429 krb5_error_code ret;
430 krb5_storage *sp;
431 HDB *db;
432 krb5_data data;
433 char buf[8];
434
435 /* we assume that the caller has obtained an exclusive lock */
436
437 ret = krb5_storage_truncate(dump, 0);
438 if (ret)
439 return ret;
440
441 if (krb5_storage_seek(dump, 0, SEEK_SET) != 0)
442 return errno;
443
444 /*
445 * First we store zero as the HDB version, this will indicate to a
446 * later reader that the dumpfile is invalid. We later write the
447 * correct version in the file after we have written all of the
448 * messages. A dump with a zero version will not be considered
449 * to be valid.
450 */
451
452 ret = krb5_store_uint32(dump, 0);
453 if (ret)
454 return ret;
455
456 ret = hdb_create (context, &db, database);
457 if (ret)
458 krb5_err (context, IPROPD_RESTART, ret, "hdb_create: %s", database);
459 ret = db->hdb_open (context, db, O_RDONLY, 0);
460 if (ret)
461 krb5_err (context, IPROPD_RESTART, ret, "db->open");
462
463 sp = krb5_storage_from_mem (buf, 4);
464 if (sp == NULL)
465 krb5_errx (context, IPROPD_RESTART, "krb5_storage_from_mem");
466 krb5_store_uint32 (sp, TELL_YOU_EVERYTHING);
467 krb5_storage_free (sp);
468
469 data.data = buf;
470 data.length = 4;
471
472 ret = krb5_store_data(dump, data);
473 if (ret) {
474 krb5_warn (context, ret, "write_dump");
475 return ret;
476 }
477
478 ret = hdb_foreach (context, db, HDB_F_ADMIN_DATA, dump_one, dump);
479 if (ret) {
480 krb5_warn (context, ret, "write_dump: hdb_foreach");
481 return ret;
482 }
483
484 (*db->hdb_close)(context, db);
485 (*db->hdb_destroy)(context, db);
486
487 sp = krb5_storage_from_mem (buf, 8);
488 if (sp == NULL)
489 krb5_errx (context, IPROPD_RESTART, "krb5_storage_from_mem");
490 ret = krb5_store_uint32(sp, NOW_YOU_HAVE);
491 if (ret == 0)
492 krb5_store_uint32(sp, current_version);
493 krb5_storage_free (sp);
494
495 data.length = 8;
496
497 if (ret == 0)
498 ret = krb5_store_data(dump, data);
499
500 /*
501 * We must ensure that the entire valid dump is written to disk
502 * before we write the current version at the front thus making
503 * it a valid dump file. If we crash around here, this can be
504 * important upon reboot.
505 */
506
507 if (ret == 0)
508 ret = krb5_storage_fsync(dump);
509
510 if (ret == 0 && krb5_storage_seek(dump, 0, SEEK_SET) == -1)
511 ret = errno;
512
513 /* Write current version at the front making the dump valid */
514
515 if (ret == 0)
516 ret = krb5_store_uint32(dump, current_version);
517
518 /*
519 * We don't need to fsync(2) after the real version is written as
520 * it is not a disaster if it doesn't make it to disk if we crash.
521 * After all, we'll just create a new dumpfile.
522 */
523
524 if (ret == 0)
525 krb5_warnx(context, "wrote new dumpfile (version %u)",
526 current_version);
527 else
528 krb5_warn(context, ret, "failed to write new dumpfile (version %u)",
529 current_version);
530
531 return ret;
532 }
533
534 static int
mk_priv_tail(krb5_context context,slave * s,krb5_data * data)535 mk_priv_tail(krb5_context context, slave *s, krb5_data *data)
536 {
537 uint32_t len;
538 int ret;
539
540 ret = krb5_mk_priv(context, s->ac, data, &s->tail.packet, NULL);
541 if (ret)
542 return ret;
543
544 len = s->tail.packet.length;
545 _krb5_put_int(s->tail.header_buf, len, sizeof(s->tail.header_buf));
546 s->tail.header.length = sizeof(s->tail.header_buf);
547 s->tail.header.data = s->tail.header_buf;
548 return 0;
549 }
550
551 static int
have_tail(slave * s)552 have_tail(slave *s)
553 {
554 return s->tail.header.length || s->tail.packet.length || s->tail.dump;
555 }
556
557 static int
more_diffs(slave * s)558 more_diffs(slave *s)
559 {
560 return s->next_diff.more;
561 }
562
563 #define SEND_COMPLETE_MAX_RECORDS 50
564 #define SEND_DIFFS_MAX_RECORDS 50
565
566 static int
send_tail(krb5_context context,slave * s)567 send_tail(krb5_context context, slave *s)
568 {
569 krb5_data data;
570 ssize_t bytes = 0;
571 size_t rem = 0;
572 size_t n;
573 int ret;
574
575 if (! have_tail(s))
576 return 0;
577
578 /*
579 * For the case where we're continuing a send_complete() send up to
580 * SEND_COMPLETE_MAX_RECORDS records now, and the rest asynchronously
581 * later. This ensures that sending a complete dump to a slow-to-drain
582 * client does not prevent others from getting serviced.
583 */
584 for (n = 0; n < SEND_COMPLETE_MAX_RECORDS; n++) {
585 if (! have_tail(s))
586 return 0;
587
588 if (s->tail.header.length) {
589 bytes = krb5_net_write(context, &s->fd,
590 s->tail.header.data,
591 s->tail.header.length);
592 if (bytes < 0)
593 goto err;
594
595 s->tail.header.length -= bytes;
596 s->tail.header.data = (char *)s->tail.header.data + bytes;
597 rem = s->tail.header.length;
598 if (rem)
599 goto ewouldblock;
600 }
601
602 if (s->tail.packet.length) {
603 bytes = krb5_net_write(context, &s->fd,
604 (char *)s->tail.packet.data + s->tail.packet_off,
605 s->tail.packet.length - s->tail.packet_off);
606 if (bytes < 0)
607 goto err;
608 s->tail.packet_off += bytes;
609 if (bytes)
610 slave_seen(s);
611 rem = s->tail.packet.length - s->tail.packet_off;
612 if (rem)
613 goto ewouldblock;
614
615 krb5_data_free(&s->tail.packet);
616 s->tail.packet_off = 0;
617 }
618
619 if (s->tail.dump == NULL)
620 return 0;
621
622 /*
623 * We're in the middle of a send_complete() that was interrupted by
624 * EWOULDBLOCK. Continue the sending of the dump.
625 */
626 ret = krb5_ret_data(s->tail.dump, &data);
627 if (ret == HEIM_ERR_EOF) {
628 krb5_storage_free(s->tail.dump);
629 s->tail.dump = NULL;
630 s->version = s->tail.vno;
631 return 0;
632 }
633
634 if (ret) {
635 krb5_warn(context, ret, "failed to read entry from dump!");
636 } else {
637 ret = mk_priv_tail(context, s, &data);
638 krb5_data_free(&data);
639 if (ret == 0)
640 continue;
641 krb5_warn(context, ret, "failed to make and send a KRB-PRIV to %s",
642 s->name);
643 }
644
645 slave_dead(context, s);
646 return ret;
647 }
648
649 if (ret == 0 && s->tail.dump != NULL)
650 return EWOULDBLOCK;
651
652 err:
653 if (errno != EAGAIN && errno != EWOULDBLOCK) {
654 krb5_warn(context, ret = errno,
655 "error sending diffs to now-dead slave %s", s->name);
656 slave_dead(context, s);
657 return ret;
658 }
659
660 ewouldblock:
661 if (verbose)
662 krb5_warnx(context, "would block writing %llu bytes to slave %s",
663 (unsigned long long)rem, s->name);
664 return EWOULDBLOCK;
665 }
666
667 static int
send_complete(krb5_context context,slave * s,const char * database,uint32_t current_version,uint32_t oldest_version,uint32_t initial_log_tstamp)668 send_complete(krb5_context context, slave *s, const char *database,
669 uint32_t current_version, uint32_t oldest_version,
670 uint32_t initial_log_tstamp)
671 {
672 krb5_error_code ret;
673 krb5_storage *dump = NULL;
674 uint32_t vno = 0;
675 int fd = -1;
676 struct stat st;
677 char *dfn;
678
679 ret = asprintf(&dfn, "%s/ipropd.dumpfile", hdb_db_dir(context));
680 if (ret == -1 || !dfn) {
681 krb5_warn(context, ENOMEM, "Cannot allocate memory");
682 return ENOMEM;
683 }
684
685 fd = open(dfn, O_CREAT|O_RDWR, 0600);
686 if (fd == -1) {
687 ret = errno;
688 krb5_warn(context, ret, "Cannot open/create iprop dumpfile %s", dfn);
689 free(dfn);
690 return ret;
691 }
692 free(dfn);
693
694 dump = krb5_storage_from_fd(fd);
695 if (!dump) {
696 ret = errno;
697 krb5_warn(context, ret, "krb5_storage_from_fd");
698 goto done;
699 }
700
701 for (;;) {
702 ret = flock(fd, LOCK_SH);
703 if (ret == -1) {
704 ret = errno;
705 krb5_warn(context, ret, "flock(fd, LOCK_SH)");
706 goto done;
707 }
708
709 if (krb5_storage_seek(dump, 0, SEEK_SET) == (off_t)-1) {
710 ret = errno;
711 krb5_warn(context, ret, "krb5_storage_seek(dump, 0, SEEK_SET)");
712 goto done;
713 }
714
715 vno = 0;
716 ret = krb5_ret_uint32(dump, &vno);
717 if (ret && ret != HEIM_ERR_EOF) {
718 krb5_warn(context, ret, "krb5_ret_uint32(dump, &vno)");
719 goto done;
720 }
721
722 if (fstat(fd, &st) == -1) {
723 ret = errno;
724 krb5_warn(context, ret, "send_complete: could not stat dump file");
725 goto done;
726 }
727
728 /*
729 * If the current dump has an appropriate version, then we can
730 * break out of the loop and send the file below.
731 */
732 if (ret == 0 && vno != 0 && st.st_mtime > initial_log_tstamp &&
733 vno >= oldest_version && vno <= current_version)
734 break;
735
736 if (verbose)
737 krb5_warnx(context, "send_complete: dumping HDB");
738
739 /*
740 * Otherwise, we may need to write a new dump file. We
741 * obtain an exclusive lock on the fd. Because this is
742 * not guaranteed to be an upgrade of our existing shared
743 * lock, someone else may have written a new dumpfile while
744 * we were waiting and so we must first check the vno of
745 * the dump to see if that happened. If it did, we need
746 * to go back to the top of the loop so that we can downgrade
747 * our lock to a shared one.
748 */
749
750 ret = flock(fd, LOCK_EX);
751 if (ret == -1) {
752 ret = errno;
753 krb5_warn(context, ret, "flock(fd, LOCK_EX)");
754 goto done;
755 }
756
757 ret = krb5_storage_seek(dump, 0, SEEK_SET);
758 if (ret == -1) {
759 ret = errno;
760 krb5_warn(context, ret, "krb5_storage_seek(dump, 0, SEEK_SET)");
761 goto done;
762 }
763
764 vno = 0;
765 ret = krb5_ret_uint32(dump, &vno);
766 if (ret && ret != HEIM_ERR_EOF) {
767 krb5_warn(context, ret, "krb5_ret_uint32(dump, &vno)");
768 goto done;
769 }
770
771 if (fstat(fd, &st) == -1) {
772 ret = errno;
773 krb5_warn(context, ret, "send_complete: could not stat dump file");
774 goto done;
775 }
776
777 /* check if someone wrote a better version for us */
778 if (ret == 0 && vno != 0 && st.st_mtime > initial_log_tstamp &&
779 vno >= oldest_version && vno <= current_version)
780 continue;
781
782 /* Now, we know that we must write a new dump file. */
783
784 ret = write_dump(context, dump, database, current_version);
785 if (ret)
786 goto done;
787
788 /*
789 * And we must continue to the top of the loop so that we can
790 * downgrade to a shared lock.
791 */
792 }
793
794 /*
795 * Leaving the above loop, dump should have a ptr right after the initial
796 * 4 byte DB version number and we should have a shared lock on the file
797 * (which we may have just created), so we are reading to start sending
798 * the data down the wire.
799 *
800 * Note: (krb5_storage_from_fd() dup()'s the fd)
801 */
802
803 s->tail.dump = dump;
804 s->tail.vno = vno;
805 dump = NULL;
806 ret = send_tail(context, s);
807
808 done:
809 if (fd != -1)
810 close(fd);
811 if (dump)
812 krb5_storage_free(dump);
813 return ret;
814 }
815
816 static int
send_are_you_there(krb5_context context,slave * s)817 send_are_you_there (krb5_context context, slave *s)
818 {
819 krb5_storage *sp;
820 krb5_data data;
821 char buf[4];
822 int ret;
823
824 if (s->flags & (SLAVE_F_DEAD|SLAVE_F_AYT))
825 return 0;
826
827 /*
828 * Write any remainder of previous write, if we can. If we'd block we'll
829 * return EWOULDBLOCK.
830 */
831 ret = send_tail(context, s);
832 if (ret)
833 return ret;
834
835 krb5_warnx(context, "slave %s missing, sending AYT", s->name);
836
837 s->flags |= SLAVE_F_AYT;
838
839 data.data = buf;
840 data.length = 4;
841
842 sp = krb5_storage_from_mem (buf, 4);
843 if (sp == NULL) {
844 krb5_warnx (context, "are_you_there: krb5_data_alloc");
845 slave_dead(context, s);
846 return ENOMEM;
847 }
848 ret = krb5_store_uint32(sp, ARE_YOU_THERE);
849 krb5_storage_free (sp);
850
851 if (ret == 0)
852 ret = mk_priv_tail(context, s, &data);
853 if (ret == 0)
854 ret = send_tail(context, s);
855 if (ret && ret != EWOULDBLOCK) {
856 krb5_warn(context, ret, "are_you_there");
857 slave_dead(context, s);
858 }
859 return ret;
860 }
861
862 static int
diffready(krb5_context context,slave * s)863 diffready(krb5_context context, slave *s)
864 {
865 /*
866 * Don't send any diffs until slave has sent an I_HAVE telling us the
867 * initial version number!
868 */
869 if ((s->flags & SLAVE_F_READY) == 0)
870 return 0;
871
872 if (s->flags & SLAVE_F_DEAD) {
873 if (verbose)
874 krb5_warnx(context, "not sending diffs to dead slave %s", s->name);
875 return 0;
876 }
877
878 /* Write any remainder of previous write, if we can. */
879 if (send_tail(context, s) != 0)
880 return 0;
881
882 return 1;
883 }
884
885 static int
nodiffs(krb5_context context,slave * s,uint32_t current_version)886 nodiffs(krb5_context context, slave *s, uint32_t current_version)
887 {
888 krb5_storage *sp;
889 krb5_data data;
890 int ret;
891
892 if (s->version < current_version)
893 return 0;
894
895 /*
896 * If we had sent a partial diff, and now they're caught up, then there's
897 * no more.
898 */
899 s->next_diff.more = 0;
900
901 if (verbose)
902 krb5_warnx(context, "slave %s version %ld already sent", s->name,
903 (long)s->version);
904 sp = krb5_storage_emem();
905 if (sp == NULL)
906 krb5_errx(context, IPROPD_RESTART, "krb5_storage_from_mem");
907
908 ret = krb5_store_uint32(sp, YOU_HAVE_LAST_VERSION);
909 if (ret == 0) {
910 krb5_data_zero(&data);
911 ret = krb5_storage_to_data(sp, &data);
912 }
913 krb5_storage_free(sp);
914 if (ret == 0) {
915 ret = mk_priv_tail(context, s, &data);
916 krb5_data_free(&data);
917 }
918 if (ret == 0)
919 send_tail(context, s);
920
921 return 1;
922 }
923
924 /*
925 * Lock the log and return initial version and timestamp
926 */
927 static int
get_first(kadm5_server_context * server_context,int log_fd,uint32_t * initial_verp,uint32_t * initial_timep)928 get_first(kadm5_server_context *server_context, int log_fd,
929 uint32_t *initial_verp, uint32_t *initial_timep)
930 {
931 krb5_context context = server_context->context;
932 int ret;
933
934 /*
935 * We don't want to perform tight retry loops on log access errors, so on
936 * error mark the slave dead. The slave reconnect after a delay...
937 */
938 if (flock(log_fd, LOCK_SH) == -1) {
939 krb5_warn(context, errno, "could not obtain shared lock on log file");
940 return -1;
941 }
942
943 ret = kadm5_log_get_version_fd(server_context, log_fd, LOG_VERSION_FIRST,
944 initial_verp, initial_timep);
945 if (ret != 0) {
946 flock(log_fd, LOCK_UN);
947 krb5_warnx(context, "could not read initial log entry");
948 return -1;
949 }
950
951 return 0;
952 }
953
954 /*-
955 * Find the left end of the diffs in the log we want to send.
956 *
957 * - On success, return a positive offset to the first new entry, retaining
958 * a read lock on the log file.
959 * - On error, return a negative offset, with the lock released.
960 * - If we simply find no successor entry in the log, return zero
961 * with the lock released, which indicates that fallback to send_complete()
962 * is needed.
963 */
964 static off_t
get_left(kadm5_server_context * server_context,slave * s,krb5_storage * sp,int log_fd,uint32_t current_version,uint32_t * initial_verp,uint32_t * initial_timep)965 get_left(kadm5_server_context *server_context, slave *s, krb5_storage *sp,
966 int log_fd, uint32_t current_version,
967 uint32_t *initial_verp, uint32_t *initial_timep)
968 {
969 krb5_context context = server_context->context;
970 off_t pos;
971 off_t left;
972 int ret;
973
974 for (;;) {
975 uint32_t ver = s->version;
976
977 /* This acquires a read lock on success */
978 ret = get_first(server_context, log_fd,
979 initial_verp, initial_timep);
980 if (ret != 0)
981 return -1;
982
983 /* When the slave version is out of range, send the whole database. */
984 if (ver == 0 || ver < *initial_verp || ver > current_version) {
985 flock(log_fd, LOCK_UN);
986 return 0;
987 }
988
989 /* Avoid seeking past the last committed record */
990 if (kadm5_log_goto_end(server_context, sp) != 0 ||
991 (pos = krb5_storage_seek(sp, 0, SEEK_CUR)) < 0)
992 goto err;
993
994 /*
995 * First try to see if we can find it quickly by seeking to the right
996 * end of the previous diff sent.
997 */
998 if (s->next_diff.last_version_sent > 0 &&
999 s->next_diff.off_next_version > 0 &&
1000 s->next_diff.off_next_version < pos &&
1001 s->next_diff.initial_version == *initial_verp &&
1002 s->next_diff.initial_tstamp == *initial_timep) {
1003 /*
1004 * Sanity check that the left version matches what we wanted, the
1005 * log may have been truncated since.
1006 */
1007 left = s->next_diff.off_next_version;
1008 if (krb5_storage_seek(sp, left, SEEK_SET) != left)
1009 goto err;
1010 if (kadm5_log_next(context, sp, &ver, NULL, NULL, NULL) == 0 &&
1011 ver == s->next_diff.last_version_sent + 1)
1012 return left;
1013 }
1014
1015 if (krb5_storage_seek(sp, pos, SEEK_SET) != pos)
1016 goto err;
1017
1018 /*
1019 * Drop the lock and try to find the left entry by seeking backward
1020 * from the end of the end of the log. If we succeed, re-acquire the
1021 * lock, update "next_diff", and retry the fast-path.
1022 */
1023 flock(log_fd, LOCK_UN);
1024
1025 /* Slow path: seek backwards, entry by entry, from the end */
1026 for (;;) {
1027 enum kadm_ops op;
1028 uint32_t len;
1029
1030 ret = kadm5_log_previous(context, sp, &ver, NULL, &op, &len);
1031 if (ret)
1032 return -1;
1033 left = krb5_storage_seek(sp, -16, SEEK_CUR);
1034 if (left < 0)
1035 return left;
1036 if (ver == s->version + 1)
1037 break;
1038
1039 /*
1040 * We don't expect to reach the slave's version, unless the log
1041 * has been modified after we released the lock.
1042 */
1043 if (ver == s->version) {
1044 krb5_warnx(context, "iprop log truncated while sending diffs "
1045 "to slave?? ver = %lu", (unsigned long)ver);
1046 return -1;
1047 }
1048
1049 /* If we've reached the uber record, send the complete database */
1050 if (left == 0 || (ver == 0 && op == kadm_nop))
1051 return 0;
1052 }
1053 assert(ver == s->version + 1);
1054
1055 /* Set up the fast-path pre-conditions */
1056 s->next_diff.last_version_sent = s->version;
1057 s->next_diff.off_next_version = left;
1058 s->next_diff.initial_version = *initial_verp;
1059 s->next_diff.initial_tstamp = *initial_timep;
1060
1061 /*
1062 * If we loop then we're hoping to hit the fast path so we can return a
1063 * non-zero, positive left offset with the lock held.
1064 *
1065 * We just updated the fast path pre-conditions, so unless a log
1066 * truncation event happens between the point where we dropped the lock
1067 * and the point where we rearcuire it above, we will hit the fast
1068 * path.
1069 */
1070 }
1071
1072 return left;
1073
1074 err:
1075 flock(log_fd, LOCK_UN);
1076 return -1;
1077 }
1078
1079 static off_t
get_right(krb5_context context,int log_fd,krb5_storage * sp,int lastver,slave * s,off_t left,uint32_t * verp)1080 get_right(krb5_context context, int log_fd, krb5_storage *sp,
1081 int lastver, slave *s, off_t left, uint32_t *verp)
1082 {
1083 int ret = 0;
1084 int i = 0;
1085 uint32_t ver = s->version;
1086 off_t right = krb5_storage_seek(sp, left, SEEK_SET);
1087
1088 if (right <= 0) {
1089 flock(log_fd, LOCK_UN);
1090 return -1;
1091 }
1092
1093 /* The "lastver" bound should preclude us reaching EOF */
1094 for (; ret == 0 && i < SEND_DIFFS_MAX_RECORDS && ver < lastver; ++i) {
1095 uint32_t logver;
1096
1097 ret = kadm5_log_next(context, sp, &logver, NULL, NULL, NULL);
1098 if (logver != ++ver)
1099 ret = KADM5_LOG_CORRUPT;
1100 }
1101
1102 if (ret == 0)
1103 right = krb5_storage_seek(sp, 0, SEEK_CUR);
1104 else
1105 right = -1;
1106 if (right <= 0) {
1107 flock(log_fd, LOCK_UN);
1108 return -1;
1109 }
1110 *verp = ver;
1111 return right;
1112 }
1113
1114 static void
send_diffs(kadm5_server_context * server_context,slave * s,int log_fd,const char * database,uint32_t current_version)1115 send_diffs(kadm5_server_context *server_context, slave *s, int log_fd,
1116 const char *database, uint32_t current_version)
1117 {
1118 krb5_context context = server_context->context;
1119 krb5_storage *sp;
1120 uint32_t initial_version;
1121 uint32_t initial_tstamp;
1122 uint32_t ver;
1123 off_t left = 0;
1124 off_t right = 0;
1125 krb5_ssize_t bytes;
1126 krb5_data data;
1127 int ret = 0;
1128
1129 if (!diffready(context, s) || nodiffs(context, s, current_version))
1130 return;
1131
1132 if (verbose)
1133 krb5_warnx(context, "sending diffs to live-seeming slave %s", s->name);
1134
1135 sp = krb5_storage_from_fd(log_fd);
1136 if (sp == NULL)
1137 krb5_err(context, IPROPD_RESTART_SLOW, ENOMEM,
1138 "send_diffs: out of memory");
1139
1140 left = get_left(server_context, s, sp, log_fd, current_version,
1141 &initial_version, &initial_tstamp);
1142 if (left < 0) {
1143 krb5_storage_free(sp);
1144 slave_dead(context, s);
1145 return;
1146 }
1147
1148 if (left == 0) {
1149 /* Slave's version is not in the log, fall back on send_complete() */
1150 krb5_storage_free(sp);
1151 send_complete(context, s, database, current_version,
1152 initial_version, initial_tstamp);
1153 return;
1154 }
1155
1156 /* We still hold the read lock, if right > 0 */
1157 right = get_right(server_context->context, log_fd, sp, current_version,
1158 s, left, &ver);
1159 if (right == left) {
1160 flock(log_fd, LOCK_UN);
1161 krb5_storage_free(sp);
1162 return;
1163 }
1164 if (right < left) {
1165 assert(right < 0);
1166 krb5_storage_free(sp);
1167 slave_dead(context, s);
1168 return;
1169 }
1170
1171 if (krb5_storage_seek(sp, left, SEEK_SET) != left) {
1172 ret = errno ? errno : EIO;
1173 flock(log_fd, LOCK_UN);
1174 krb5_warn(context, ret, "send_diffs: krb5_storage_seek");
1175 krb5_storage_free(sp);
1176 slave_dead(context, s);
1177 return;
1178 }
1179
1180 ret = krb5_data_alloc(&data, right - left + 4);
1181 if (ret) {
1182 flock(log_fd, LOCK_UN);
1183 krb5_warn(context, ret, "send_diffs: krb5_data_alloc");
1184 krb5_storage_free(sp);
1185 slave_dead(context, s);
1186 return;
1187 }
1188
1189 bytes = krb5_storage_read(sp, (char *)data.data + 4, data.length - 4);
1190 flock(log_fd, LOCK_UN);
1191 krb5_storage_free(sp);
1192 if (bytes != data.length - 4)
1193 krb5_errx(context, IPROPD_RESTART, "locked log truncated???");
1194
1195 sp = krb5_storage_from_data(&data);
1196 if (sp == NULL) {
1197 krb5_err(context, IPROPD_RESTART_SLOW, ENOMEM, "out of memory");
1198 krb5_warnx(context, "send_diffs: krb5_storage_from_data");
1199 return;
1200 }
1201 krb5_store_uint32(sp, FOR_YOU);
1202 krb5_storage_free(sp);
1203
1204 ret = mk_priv_tail(context, s, &data);
1205 krb5_data_free(&data);
1206 if (ret == 0) {
1207 /* Save the fast-path continuation */
1208 s->next_diff.last_version_sent = ver;
1209 s->next_diff.off_next_version = right;
1210 s->next_diff.initial_version = initial_version;
1211 s->next_diff.initial_tstamp = initial_tstamp;
1212 s->next_diff.more = ver < current_version;
1213 ret = send_tail(context, s);
1214
1215 krb5_warnx(context,
1216 "syncing slave %s from version %lu to version %lu",
1217 s->name, (unsigned long)s->version,
1218 (unsigned long)ver);
1219 s->version = ver;
1220 }
1221
1222 if (ret && ret != EWOULDBLOCK) {
1223 krb5_warn(context, ret, "send_diffs: making or sending "
1224 "KRB-PRIV message");
1225 slave_dead(context, s);
1226 return;
1227 }
1228 slave_seen(s);
1229 return;
1230 }
1231
1232 /* Sensible bound on slave message size */
1233 #define SLAVE_MSG_MAX 65536
1234
1235 static int
fill_input(krb5_context context,slave * s)1236 fill_input(krb5_context context, slave *s)
1237 {
1238 krb5_error_code ret;
1239
1240 if (s->input.hlen < 4) {
1241 uint8_t *buf = s->input.header_buf + s->input.hlen;
1242 size_t len = 4 - s->input.hlen;
1243 krb5_ssize_t bytes = krb5_net_read(context, &s->fd, buf, len);
1244
1245 if (bytes == 0)
1246 return HEIM_ERR_EOF;
1247 if (bytes < 0) {
1248 if (errno == EWOULDBLOCK || errno == EAGAIN)
1249 return EWOULDBLOCK;
1250 return errno ? errno : EIO;
1251 }
1252 s->input.hlen += bytes;
1253 if (bytes < len)
1254 return EWOULDBLOCK;
1255
1256 buf = s->input.header_buf;
1257 len = (buf[0] << 24) | (buf[1] << 16) | (buf[2] << 8) | buf[3];
1258 if (len > SLAVE_MSG_MAX)
1259 return EINVAL;
1260 ret = krb5_data_alloc(&s->input.packet, len);
1261 if (ret != 0)
1262 return ret;
1263 }
1264
1265 if (s->input.offset < s->input.packet.length) {
1266 u_char *buf = (u_char *)s->input.packet.data + s->input.offset;
1267 size_t len = s->input.packet.length - s->input.offset;
1268 krb5_ssize_t bytes = krb5_net_read(context, &s->fd, buf, len);
1269
1270 if (bytes == 0)
1271 return HEIM_ERR_EOF;
1272 if (bytes < 0) {
1273 if (errno == EWOULDBLOCK || errno == EAGAIN)
1274 return EWOULDBLOCK;
1275 return errno ? errno : EIO;
1276 }
1277 s->input.offset += bytes;
1278 if (bytes != len)
1279 return EWOULDBLOCK;
1280 }
1281 return 0;
1282 }
1283
1284 static int
read_msg(krb5_context context,slave * s,krb5_data * out)1285 read_msg(krb5_context context, slave *s, krb5_data *out)
1286 {
1287 int ret = fill_input(context, s);
1288
1289 if (ret != 0)
1290 return ret;
1291
1292 ret = krb5_rd_priv(context, s->ac, &s->input.packet, out, NULL);
1293
1294 /* Prepare for next packet */
1295 krb5_data_free(&s->input.packet);
1296 s->input.offset = 0;
1297 s->input.hlen = 0;
1298
1299 return ret;
1300 }
1301
1302 static int
process_msg(kadm5_server_context * server_context,slave * s,int log_fd,const char * database,uint32_t current_version)1303 process_msg(kadm5_server_context *server_context, slave *s, int log_fd,
1304 const char *database, uint32_t current_version)
1305 {
1306 krb5_context context = server_context->context;
1307 int ret = 0;
1308 krb5_data out;
1309 krb5_storage *sp;
1310 uint32_t tmp;
1311
1312 ret = read_msg(context, s, &out);
1313 if (ret) {
1314 if (ret != EWOULDBLOCK)
1315 krb5_warn(context, ret, "error reading message from %s", s->name);
1316 return ret;
1317 }
1318
1319 sp = krb5_storage_from_mem(out.data, out.length);
1320 if (sp == NULL) {
1321 krb5_warnx(context, "process_msg: no memory");
1322 krb5_data_free(&out);
1323 return 1;
1324 }
1325 if (krb5_ret_uint32(sp, &tmp) != 0) {
1326 krb5_warnx(context, "process_msg: client send too short command");
1327 krb5_data_free(&out);
1328 return 1;
1329 }
1330 switch (tmp) {
1331 case I_HAVE :
1332 ret = krb5_ret_uint32(sp, &tmp);
1333 if (ret != 0) {
1334 krb5_warnx(context, "process_msg: client send too little I_HAVE data");
1335 break;
1336 }
1337 /*
1338 * XXX Make the slave send the timestamp as well, and try to get it
1339 * here, and pass it to send_diffs().
1340 */
1341 /*
1342 * New slave whose version number we've not yet seen. If the version
1343 * number is zero, the slave has no data, and we'll send a complete
1344 * database (that happens in send_diffs()). Otherwise, we'll record a
1345 * non-zero initial version and attempt an incremental update.
1346 *
1347 * NOTE!: Once the slave is "ready" (its first I_HAVE has conveyed its
1348 * initial version), we MUST NOT update s->version to the slave's
1349 * I_HAVE version, since we may already have sent later updates, and
1350 * MUST NOT send them again, otherwise we can get further and further
1351 * out of sync resending larger and larger diffs. The "not yet ready"
1352 * is an essential precondition for setting s->version to the value
1353 * in the I_HAVE message. This happens only once when the slave
1354 * first connects.
1355 */
1356 if (!(s->flags & SLAVE_F_READY)) {
1357 if (current_version < tmp) {
1358 krb5_warnx(context, "Slave %s (version %u) has later version "
1359 "than the master (version %u) OUT OF SYNC",
1360 s->name, tmp, current_version);
1361 /* Force send_complete() */
1362 tmp = 0;
1363 }
1364 /*
1365 * Mark the slave as ready for updates based on incoming signals.
1366 * Prior to the initial I_HAVE, we don't know the slave's version
1367 * number, and MUST not send it anything, since we'll needlessly
1368 * attempt to send the whole database!
1369 */
1370 s->version = tmp;
1371 s->flags |= SLAVE_F_READY;
1372 if (verbose)
1373 krb5_warnx(context, "slave %s ready for updates from version %u",
1374 s->name, tmp);
1375 }
1376 if ((s->version_ack = tmp) < s->version)
1377 break;
1378 send_diffs(server_context, s, log_fd, database, current_version);
1379 break;
1380 case I_AM_HERE :
1381 if (verbose)
1382 krb5_warnx(context, "slave %s is there", s->name);
1383 break;
1384 case ARE_YOU_THERE:
1385 case FOR_YOU :
1386 default :
1387 krb5_warnx(context, "Ignoring command %d", tmp);
1388 break;
1389 }
1390
1391 krb5_data_free(&out);
1392 krb5_storage_free(sp);
1393
1394 slave_seen(s);
1395
1396 return ret;
1397 }
1398
1399 #define SLAVE_NAME "Name"
1400 #define SLAVE_ADDRESS "Address"
1401 #define SLAVE_VERSION "Version"
1402 #define SLAVE_STATUS "Status"
1403 #define SLAVE_SEEN "Last Seen"
1404
1405 static FILE *
open_stats(krb5_context context)1406 open_stats(krb5_context context)
1407 {
1408 char *statfile = NULL;
1409 const char *fn = NULL;
1410 FILE *out = NULL;
1411
1412 /*
1413 * krb5_config_get_string_default() returs default value as-is,
1414 * delay free() of "statfile" until we're done with "fn".
1415 */
1416 if (slave_stats_file)
1417 fn = slave_stats_file;
1418 else if (asprintf(&statfile, "%s/slaves-stats", hdb_db_dir(context)) != -1
1419 && statfile != NULL)
1420 fn = krb5_config_get_string_default(context,
1421 NULL,
1422 statfile,
1423 "kdc",
1424 "iprop-stats",
1425 NULL);
1426 if (fn != NULL)
1427 out = fopen(fn, "w");
1428 if (statfile != NULL)
1429 free(statfile);
1430 return out;
1431 }
1432
1433 static void
write_master_down(krb5_context context)1434 write_master_down(krb5_context context)
1435 {
1436 char str[100];
1437 time_t t = time(NULL);
1438 FILE *fp;
1439
1440 fp = open_stats(context);
1441 if (fp == NULL)
1442 return;
1443 krb5_format_time(context, t, str, sizeof(str), TRUE);
1444 fprintf(fp, "master down at %s\n", str);
1445
1446 fclose(fp);
1447 }
1448
1449 static void
write_stats(krb5_context context,slave * slaves,uint32_t current_version)1450 write_stats(krb5_context context, slave *slaves, uint32_t current_version)
1451 {
1452 char str[100];
1453 rtbl_t tbl;
1454 time_t t = time(NULL);
1455 FILE *fp;
1456
1457 fp = open_stats(context);
1458 if (fp == NULL)
1459 return;
1460
1461 krb5_format_time(context, t, str, sizeof(str), TRUE);
1462 fprintf(fp, "Status for slaves, last updated: %s\n\n", str);
1463
1464 fprintf(fp, "Master version: %lu\n\n", (unsigned long)current_version);
1465
1466 tbl = rtbl_create();
1467 if (tbl == NULL) {
1468 fclose(fp);
1469 return;
1470 }
1471
1472 rtbl_add_column(tbl, SLAVE_NAME, 0);
1473 rtbl_add_column(tbl, SLAVE_ADDRESS, 0);
1474 rtbl_add_column(tbl, SLAVE_VERSION, RTBL_ALIGN_RIGHT);
1475 rtbl_add_column(tbl, SLAVE_STATUS, 0);
1476 rtbl_add_column(tbl, SLAVE_SEEN, 0);
1477
1478 rtbl_set_prefix(tbl, " ");
1479 rtbl_set_column_prefix(tbl, SLAVE_NAME, "");
1480
1481 while (slaves) {
1482 krb5_address addr;
1483 krb5_error_code ret;
1484 rtbl_add_column_entry(tbl, SLAVE_NAME, slaves->name);
1485 ret = krb5_sockaddr2address (context,
1486 (struct sockaddr*)&slaves->addr, &addr);
1487 if(ret == 0) {
1488 krb5_print_address(&addr, str, sizeof(str), NULL);
1489 krb5_free_address(context, &addr);
1490 rtbl_add_column_entry(tbl, SLAVE_ADDRESS, str);
1491 } else
1492 rtbl_add_column_entry(tbl, SLAVE_ADDRESS, "<unknown>");
1493
1494 snprintf(str, sizeof(str), "%u", (unsigned)slaves->version_ack);
1495 rtbl_add_column_entry(tbl, SLAVE_VERSION, str);
1496
1497 if (slaves->flags & SLAVE_F_DEAD)
1498 rtbl_add_column_entry(tbl, SLAVE_STATUS, "Down");
1499 else
1500 rtbl_add_column_entry(tbl, SLAVE_STATUS, "Up");
1501
1502 ret = krb5_format_time(context, slaves->seen, str, sizeof(str), TRUE);
1503 if (ret)
1504 rtbl_add_column_entry(tbl, SLAVE_SEEN, "<error-formatting-time>");
1505 else
1506 rtbl_add_column_entry(tbl, SLAVE_SEEN, str);
1507
1508 slaves = slaves->next;
1509 }
1510
1511 rtbl_format(tbl, fp);
1512 rtbl_destroy(tbl);
1513
1514 fclose(fp);
1515 }
1516
1517
1518 static char sHDB[] = "HDBGET:";
1519 static char *realm;
1520 static int version_flag;
1521 static int help_flag;
1522 static char *keytab_str = sHDB;
1523 static char *database;
1524 static char *config_file;
1525 static char *port_str;
1526 static int detach_from_console;
1527 static int daemon_child = -1;
1528
1529 static struct getargs args[] = {
1530 { "config-file", 'c', arg_string, &config_file, NULL, NULL },
1531 { "realm", 'r', arg_string, &realm, NULL, NULL },
1532 { "keytab", 'k', arg_string, &keytab_str,
1533 "keytab to get authentication from", "kspec" },
1534 { "database", 'd', arg_string, &database, "database", "file"},
1535 { "slave-stats-file", 0, arg_string, rk_UNCONST(&slave_stats_file),
1536 "file for slave status information", "file"},
1537 { "time-missing", 0, arg_string, rk_UNCONST(&slave_time_missing),
1538 "time before slave is polled for presence", "time"},
1539 { "time-gone", 0, arg_string, rk_UNCONST(&slave_time_gone),
1540 "time of inactivity after which a slave is considered gone", "time"},
1541 { "port", 0, arg_string, &port_str,
1542 "port ipropd will listen to", "port"},
1543 { "detach", 0, arg_flag, &detach_from_console,
1544 "detach from console", NULL },
1545 { "daemon-child", 0 , arg_integer, &daemon_child,
1546 "private argument, do not use", NULL },
1547 { "hostname", 0, arg_string, rk_UNCONST(&master_hostname),
1548 "hostname of master (if not same as hostname)", "hostname" },
1549 { "verbose", 0, arg_flag, &verbose, NULL, NULL },
1550 { "version", 0, arg_flag, &version_flag, NULL, NULL },
1551 { "help", 0, arg_flag, &help_flag, NULL, NULL }
1552 };
1553 static int num_args = sizeof(args) / sizeof(args[0]);
1554
1555 int
main(int argc,char ** argv)1556 main(int argc, char **argv)
1557 {
1558 krb5_error_code ret;
1559 krb5_context context;
1560 void *kadm_handle;
1561 kadm5_server_context *server_context;
1562 kadm5_config_params conf;
1563 krb5_socket_t signal_fd, listen_fd;
1564 int log_fd;
1565 slave *slaves = NULL;
1566 uint32_t current_version = 0, old_version = 0;
1567 krb5_keytab keytab;
1568 char **files;
1569 int aret;
1570 int optidx = 0;
1571 int restarter_fd = -1;
1572 struct stat st;
1573
1574 setprogname(argv[0]);
1575
1576 if (getarg(args, num_args, argc, argv, &optidx))
1577 krb5_std_usage(1, args, num_args);
1578
1579 if (help_flag)
1580 krb5_std_usage(0, args, num_args);
1581
1582 if (version_flag) {
1583 print_version(NULL);
1584 exit(0);
1585 }
1586
1587 if (detach_from_console && daemon_child == -1)
1588 roken_detach_prep(argc, argv, "--daemon-child");
1589 rk_pidfile(NULL);
1590
1591 ret = krb5_init_context(&context);
1592 if (ret)
1593 errx(1, "krb5_init_context failed: %d", ret);
1594
1595 setup_signal();
1596
1597 if (config_file == NULL) {
1598 aret = asprintf(&config_file, "%s/kdc.conf", hdb_db_dir(context));
1599 if (aret == -1 || config_file == NULL)
1600 errx(1, "out of memory");
1601 }
1602
1603 ret = krb5_prepend_config_files_default(config_file, &files);
1604 if (ret)
1605 krb5_err(context, 1, ret, "getting configuration files");
1606
1607 ret = krb5_set_config_files(context, files);
1608 krb5_free_config_files(files);
1609 if (ret)
1610 krb5_err(context, 1, ret, "reading configuration files");
1611
1612 time_before_gone = parse_time (slave_time_gone, "s");
1613 if (time_before_gone < 0)
1614 krb5_errx (context, 1, "couldn't parse time: %s", slave_time_gone);
1615 time_before_missing = parse_time (slave_time_missing, "s");
1616 if (time_before_missing < 0)
1617 krb5_errx (context, 1, "couldn't parse time: %s", slave_time_missing);
1618
1619 krb5_openlog(context, "ipropd-master", &log_facility);
1620 krb5_set_warn_dest(context, log_facility);
1621
1622 ret = krb5_kt_register(context, &hdb_get_kt_ops);
1623 if(ret)
1624 krb5_err(context, 1, ret, "krb5_kt_register");
1625
1626 ret = krb5_kt_resolve(context, keytab_str, &keytab);
1627 if(ret)
1628 krb5_err(context, 1, ret, "krb5_kt_resolve: %s", keytab_str);
1629
1630 memset(&conf, 0, sizeof(conf));
1631 if(realm) {
1632 conf.mask |= KADM5_CONFIG_REALM;
1633 conf.realm = realm;
1634 }
1635 ret = kadm5_init_with_skey_ctx (context,
1636 KADM5_ADMIN_SERVICE,
1637 NULL,
1638 KADM5_ADMIN_SERVICE,
1639 &conf, 0, 0,
1640 &kadm_handle);
1641 if (ret)
1642 krb5_err (context, 1, ret, "kadm5_init_with_password_ctx");
1643
1644 server_context = (kadm5_server_context *)kadm_handle;
1645
1646 log_fd = open (server_context->log_context.log_file, O_RDONLY, 0);
1647 if (log_fd < 0)
1648 krb5_err (context, 1, errno, "open %s",
1649 server_context->log_context.log_file);
1650
1651 if (fstat(log_fd, &st) == -1)
1652 krb5_err(context, 1, errno, "stat %s",
1653 server_context->log_context.log_file);
1654
1655 if (flock(log_fd, LOCK_SH) == -1)
1656 krb5_err(context, 1, errno, "shared flock %s",
1657 server_context->log_context.log_file);
1658 kadm5_log_get_version_fd(server_context, log_fd, LOG_VERSION_LAST,
1659 ¤t_version, NULL);
1660 flock(log_fd, LOCK_UN);
1661
1662 signal_fd = make_signal_socket (context);
1663 listen_fd = make_listen_socket (context, port_str);
1664
1665 krb5_warnx(context, "ipropd-master started at version: %lu",
1666 (unsigned long)current_version);
1667
1668 roken_detach_finish(NULL, daemon_child);
1669 restarter_fd = restarter(context, NULL);
1670
1671 while (exit_flag == 0){
1672 slave *p;
1673 fd_set readset, writeset;
1674 int max_fd = 0;
1675 struct timeval to = {30, 0};
1676 uint32_t vers;
1677 struct stat st2;;
1678
1679 #ifndef NO_LIMIT_FD_SETSIZE
1680 if (signal_fd >= FD_SETSIZE || listen_fd >= FD_SETSIZE ||
1681 restarter_fd >= FD_SETSIZE)
1682 krb5_errx (context, IPROPD_RESTART, "fd too large");
1683 #endif
1684
1685 FD_ZERO(&readset);
1686 FD_ZERO(&writeset);
1687 FD_SET(signal_fd, &readset);
1688 max_fd = max(max_fd, signal_fd);
1689 FD_SET(listen_fd, &readset);
1690 max_fd = max(max_fd, listen_fd);
1691 if (restarter_fd > -1) {
1692 FD_SET(restarter_fd, &readset);
1693 max_fd = max(max_fd, restarter_fd);
1694 }
1695
1696 for (p = slaves; p != NULL; p = p->next) {
1697 if (p->flags & SLAVE_F_DEAD)
1698 continue;
1699 FD_SET(p->fd, &readset);
1700 if (have_tail(p) || more_diffs(p))
1701 FD_SET(p->fd, &writeset);
1702 max_fd = max(max_fd, p->fd);
1703 }
1704
1705 ret = select(max_fd + 1, &readset, &writeset, NULL, &to);
1706 if (ret < 0) {
1707 if (errno == EINTR)
1708 continue;
1709 else
1710 krb5_err (context, IPROPD_RESTART, errno, "select");
1711 }
1712
1713 if (stat(server_context->log_context.log_file, &st2) == -1) {
1714 krb5_warn(context, errno, "could not stat log file by path");
1715 st2 = st;
1716 }
1717
1718 if (st2.st_dev != st.st_dev || st2.st_ino != st.st_ino) {
1719 (void) close(log_fd);
1720
1721 log_fd = open(server_context->log_context.log_file, O_RDONLY, 0);
1722 if (log_fd < 0)
1723 krb5_err(context, IPROPD_RESTART_SLOW, errno, "open %s",
1724 server_context->log_context.log_file);
1725
1726 if (fstat(log_fd, &st) == -1)
1727 krb5_err(context, IPROPD_RESTART_SLOW, errno, "stat %s",
1728 server_context->log_context.log_file);
1729
1730 if (flock(log_fd, LOCK_SH) == -1)
1731 krb5_err(context, IPROPD_RESTART, errno, "shared flock %s",
1732 server_context->log_context.log_file);
1733 kadm5_log_get_version_fd(server_context, log_fd, LOG_VERSION_LAST,
1734 ¤t_version, NULL);
1735 flock(log_fd, LOCK_UN);
1736 }
1737
1738 if (ret == 0) {
1739 /* Recover from failed transactions */
1740 if (kadm5_log_init_nb(server_context) == 0)
1741 kadm5_log_end(server_context);
1742
1743 if (flock(log_fd, LOCK_SH) == -1)
1744 krb5_err(context, IPROPD_RESTART, errno,
1745 "could not lock log file");
1746 kadm5_log_get_version_fd(server_context, log_fd, LOG_VERSION_LAST,
1747 ¤t_version, NULL);
1748 flock(log_fd, LOCK_UN);
1749
1750 if (current_version > old_version) {
1751 if (verbose)
1752 krb5_warnx(context,
1753 "Missed a signal, updating slaves %lu to %lu",
1754 (unsigned long)old_version,
1755 (unsigned long)current_version);
1756 for (p = slaves; p != NULL; p = p->next) {
1757 if (p->flags & SLAVE_F_DEAD)
1758 continue;
1759 send_diffs(server_context, p, log_fd, database,
1760 current_version);
1761 }
1762 old_version = current_version;
1763 }
1764 }
1765
1766 if (ret && FD_ISSET(restarter_fd, &readset)) {
1767 exit_flag = SIGTERM;
1768 break;
1769 }
1770
1771 if (ret && FD_ISSET(signal_fd, &readset)) {
1772 #ifndef NO_UNIX_SOCKETS
1773 struct sockaddr_un peer_addr;
1774 #else
1775 struct sockaddr_storage peer_addr;
1776 #endif
1777 socklen_t peer_len = sizeof(peer_addr);
1778
1779 if(recvfrom(signal_fd, (void *)&vers, sizeof(vers), 0,
1780 (struct sockaddr *)&peer_addr, &peer_len) < 0) {
1781 krb5_warn (context, errno, "recvfrom");
1782 continue;
1783 }
1784 --ret;
1785 assert(ret >= 0);
1786 old_version = current_version;
1787 if (flock(log_fd, LOCK_SH) == -1)
1788 krb5_err(context, IPROPD_RESTART, errno, "shared flock %s",
1789 server_context->log_context.log_file);
1790 kadm5_log_get_version_fd(server_context, log_fd, LOG_VERSION_LAST,
1791 ¤t_version, NULL);
1792 flock(log_fd, LOCK_UN);
1793 if (current_version != old_version) {
1794 /*
1795 * If current_version < old_version then the log got
1796 * truncated and we'll end up doing full propagations.
1797 *
1798 * Truncating the log when the current version is
1799 * numerically small can lead to race conditions.
1800 * Ideally we should identify log versions as
1801 * {init_or_trunc_time, vno}, then we could not have any
1802 * such race conditions, but this would either require
1803 * breaking backwards compatibility for the protocol or
1804 * adding new messages to it.
1805 */
1806 if (verbose)
1807 krb5_warnx(context,
1808 "Got a signal, updating slaves %lu to %lu",
1809 (unsigned long)old_version,
1810 (unsigned long)current_version);
1811 for (p = slaves; p != NULL; p = p->next) {
1812 if (p->flags & SLAVE_F_DEAD)
1813 continue;
1814 send_diffs(server_context, p, log_fd, database,
1815 current_version);
1816 }
1817 } else {
1818 if (verbose)
1819 krb5_warnx(context,
1820 "Got a signal, but no update in log version %lu",
1821 (unsigned long)current_version);
1822 }
1823 }
1824
1825 for (p = slaves; p != NULL; p = p->next) {
1826 if (!(p->flags & SLAVE_F_DEAD) &&
1827 FD_ISSET(p->fd, &writeset) &&
1828 ((have_tail(p) && send_tail(context, p) == 0) ||
1829 (!have_tail(p) && more_diffs(p)))) {
1830 send_diffs(server_context, p, log_fd, database,
1831 current_version);
1832 }
1833 }
1834
1835 for(p = slaves; p != NULL; p = p->next) {
1836 if (p->flags & SLAVE_F_DEAD)
1837 continue;
1838 if (ret && FD_ISSET(p->fd, &readset)) {
1839 --ret;
1840 assert(ret >= 0);
1841 ret = process_msg(server_context, p, log_fd, database,
1842 current_version);
1843 if (ret && ret != EWOULDBLOCK)
1844 slave_dead(context, p);
1845 } else if (slave_gone_p (p))
1846 slave_dead(context, p);
1847 else if (slave_missing_p (p))
1848 send_are_you_there (context, p);
1849 }
1850
1851 if (ret && FD_ISSET(listen_fd, &readset)) {
1852 add_slave (context, keytab, &slaves, listen_fd);
1853 --ret;
1854 assert(ret >= 0);
1855 }
1856 write_stats(context, slaves, current_version);
1857 }
1858
1859 if(exit_flag == SIGINT || exit_flag == SIGTERM)
1860 krb5_warnx(context, "%s terminated", getprogname());
1861 #ifdef SIGXCPU
1862 else if(exit_flag == SIGXCPU)
1863 krb5_warnx(context, "%s CPU time limit exceeded", getprogname());
1864 #endif
1865 else
1866 krb5_warnx(context, "%s unexpected exit reason: %ld",
1867 getprogname(), (long)exit_flag);
1868
1869 write_master_down(context);
1870
1871 return 0;
1872 }
1873