x
[heimdal.git] / kpasswd / kpasswdd.c
blobed98e21db5d7a168c8b812bce9852debdf84e52b
1 /*
2 * Copyright (c) 1997-2005 Kungliga Tekniska Högskolan
3 * (Royal Institute of Technology, Stockholm, Sweden).
4 * All rights reserved.
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
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.
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.
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.
34 #include "kpasswd_locl.h"
35 RCSID("$Id$");
37 #include <kadm5/admin.h>
38 #ifdef HAVE_SYS_UN_H
39 #include <sys/un.h>
40 #endif
41 #include <hdb.h>
42 #include <kadm5/private.h>
44 static krb5_context context;
45 static krb5_log_facility *log_facility;
47 static struct getarg_strings addresses_str;
48 krb5_addresses explicit_addresses;
50 static sig_atomic_t exit_flag = 0;
52 static void
53 add_one_address (const char *str, int first)
55 krb5_error_code ret;
56 krb5_addresses tmp;
58 ret = krb5_parse_address (context, str, &tmp);
59 if (ret)
60 krb5_err (context, 1, ret, "parse_address `%s'", str);
61 if (first)
62 krb5_copy_addresses(context, &tmp, &explicit_addresses);
63 else
64 krb5_append_addresses(context, &explicit_addresses, &tmp);
65 krb5_free_addresses (context, &tmp);
68 static void
69 send_reply (int s,
70 struct sockaddr *sa,
71 int sa_size,
72 krb5_data *ap_rep,
73 krb5_data *rest)
75 struct msghdr msghdr;
76 struct iovec iov[3];
77 uint16_t len, ap_rep_len;
78 u_char header[6];
79 u_char *p;
81 if (ap_rep)
82 ap_rep_len = ap_rep->length;
83 else
84 ap_rep_len = 0;
86 len = 6 + ap_rep_len + rest->length;
87 p = header;
88 *p++ = (len >> 8) & 0xFF;
89 *p++ = (len >> 0) & 0xFF;
90 *p++ = 0;
91 *p++ = 1;
92 *p++ = (ap_rep_len >> 8) & 0xFF;
93 *p++ = (ap_rep_len >> 0) & 0xFF;
95 memset (&msghdr, 0, sizeof(msghdr));
96 msghdr.msg_name = (void *)sa;
97 msghdr.msg_namelen = sa_size;
98 msghdr.msg_iov = iov;
99 msghdr.msg_iovlen = sizeof(iov)/sizeof(*iov);
100 #if 0
101 msghdr.msg_control = NULL;
102 msghdr.msg_controllen = 0;
103 #endif
105 iov[0].iov_base = (char *)header;
106 iov[0].iov_len = 6;
107 if (ap_rep_len) {
108 iov[1].iov_base = ap_rep->data;
109 iov[1].iov_len = ap_rep->length;
110 } else {
111 iov[1].iov_base = NULL;
112 iov[1].iov_len = 0;
114 iov[2].iov_base = rest->data;
115 iov[2].iov_len = rest->length;
117 if (sendmsg (s, &msghdr, 0) < 0)
118 krb5_warn (context, errno, "sendmsg");
121 static int
122 make_result (krb5_data *data,
123 uint16_t result_code,
124 const char *expl)
126 char *str;
127 krb5_data_zero (data);
129 data->length = asprintf (&str,
130 "%c%c%s",
131 (result_code >> 8) & 0xFF,
132 result_code & 0xFF,
133 expl);
135 if (str == NULL) {
136 krb5_warnx (context, "Out of memory generating error reply");
137 return 1;
139 data->data = str;
140 return 0;
143 static void
144 reply_error (krb5_realm realm,
145 int s,
146 struct sockaddr *sa,
147 int sa_size,
148 krb5_error_code error_code,
149 uint16_t result_code,
150 const char *expl)
152 krb5_error_code ret;
153 krb5_data error_data;
154 krb5_data e_data;
155 krb5_principal server = NULL;
157 if (make_result(&e_data, result_code, expl))
158 return;
160 if (realm) {
161 ret = krb5_make_principal (context, &server, realm,
162 "kadmin", "changepw", NULL);
163 if (ret) {
164 krb5_data_free (&e_data);
165 return;
169 ret = krb5_mk_error (context,
170 error_code,
171 NULL,
172 &e_data,
173 NULL,
174 server,
175 NULL,
176 NULL,
177 &error_data);
178 if (server)
179 krb5_free_principal(context, server);
180 krb5_data_free (&e_data);
181 if (ret) {
182 krb5_warn (context, ret, "Could not even generate error reply");
183 return;
185 send_reply (s, sa, sa_size, NULL, &error_data);
186 krb5_data_free (&error_data);
189 static void
190 reply_priv (krb5_auth_context auth_context,
191 int s,
192 struct sockaddr *sa,
193 int sa_size,
194 uint16_t result_code,
195 const char *expl)
197 krb5_error_code ret;
198 krb5_data krb_priv_data;
199 krb5_data ap_rep_data;
200 krb5_data e_data;
202 ret = krb5_mk_rep (context,
203 auth_context,
204 &ap_rep_data);
205 if (ret) {
206 krb5_warn (context, ret, "Could not even generate error reply");
207 return;
210 if (make_result(&e_data, result_code, expl))
211 return;
213 ret = krb5_mk_priv (context,
214 auth_context,
215 &e_data,
216 &krb_priv_data,
217 NULL);
218 krb5_data_free (&e_data);
219 if (ret) {
220 krb5_warn (context, ret, "Could not even generate error reply");
221 return;
223 send_reply (s, sa, sa_size, &ap_rep_data, &krb_priv_data);
224 krb5_data_free (&ap_rep_data);
225 krb5_data_free (&krb_priv_data);
229 * Change the password for `principal', sending the reply back on `s'
230 * (`sa', `sa_size') to `pwd_data'.
233 static void
234 change (krb5_auth_context auth_context,
235 krb5_principal admin_principal,
236 uint16_t version,
237 int s,
238 struct sockaddr *sa,
239 int sa_size,
240 krb5_data *in_data)
242 krb5_error_code ret;
243 char *client = NULL, *admin = NULL;
244 const char *pwd_reason;
245 kadm5_config_params conf;
246 void *kadm5_handle = NULL;
247 krb5_principal principal;
248 krb5_data *pwd_data = NULL;
249 char *tmp;
250 ChangePasswdDataMS chpw;
252 memset (&conf, 0, sizeof(conf));
253 memset(&chpw, 0, sizeof(chpw));
255 if (version == KRB5_KPASSWD_VERS_CHANGEPW) {
256 ret = krb5_copy_data(context, in_data, &pwd_data);
257 if (ret) {
258 krb5_warn (context, ret, "krb5_copy_data");
259 reply_priv (auth_context, s, sa, sa_size, KRB5_KPASSWD_MALFORMED,
260 "out out memory copying password");
261 return;
263 principal = admin_principal;
264 } else if (version == KRB5_KPASSWD_VERS_SETPW) {
265 size_t len;
267 ret = decode_ChangePasswdDataMS(in_data->data, in_data->length,
268 &chpw, &len);
269 if (ret) {
270 krb5_warn (context, ret, "decode_ChangePasswdDataMS");
271 reply_priv (auth_context, s, sa, sa_size, KRB5_KPASSWD_MALFORMED,
272 "malformed ChangePasswdData");
273 return;
277 ret = krb5_copy_data(context, &chpw.newpasswd, &pwd_data);
278 if (ret) {
279 krb5_warn (context, ret, "krb5_copy_data");
280 reply_priv (auth_context, s, sa, sa_size, KRB5_KPASSWD_MALFORMED,
281 "out out memory copying password");
282 goto out;
285 if (chpw.targname == NULL && chpw.targrealm != NULL) {
286 krb5_warn (context, ret, "kadm5_init_with_password_ctx");
287 reply_priv (auth_context, s, sa, sa_size,
288 KRB5_KPASSWD_MALFORMED,
289 "targrealm but not targname");
290 goto out;
293 if (chpw.targname) {
294 krb5_principal_data princ;
296 princ.name = *chpw.targname;
297 princ.realm = *chpw.targrealm;
298 if (princ.realm == NULL) {
299 ret = krb5_get_default_realm(context, &princ.realm);
301 if (ret) {
302 krb5_warnx (context,
303 "kadm5_init_with_password_ctx: "
304 "failed to allocate realm");
305 reply_priv (auth_context, s, sa, sa_size,
306 KRB5_KPASSWD_SOFTERROR,
307 "failed to allocate realm");
308 goto out;
311 ret = krb5_copy_principal(context, &princ, &principal);
312 if (*chpw.targrealm == NULL)
313 free(princ.realm);
314 if (ret) {
315 krb5_warn(context, ret, "krb5_copy_principal");
316 reply_priv(auth_context, s, sa, sa_size,
317 KRB5_KPASSWD_HARDERROR,
318 "failed to allocate principal");
319 goto out;
321 } else
322 principal = admin_principal;
323 } else {
324 krb5_warnx (context, "kadm5_init_with_password_ctx: unknown proto");
325 reply_priv (auth_context, s, sa, sa_size,
326 KRB5_KPASSWD_HARDERROR,
327 "Unknown protocol used");
328 return;
331 ret = krb5_unparse_name (context, admin_principal, &admin);
332 if (ret) {
333 krb5_warn (context, ret, "unparse_name failed");
334 reply_priv (auth_context, s, sa, sa_size,
335 KRB5_KPASSWD_HARDERROR, "out of memory error");
336 goto out;
339 conf.realm = principal->realm;
340 conf.mask |= KADM5_CONFIG_REALM;
342 ret = kadm5_init_with_password_ctx(context,
343 admin,
344 NULL,
345 KADM5_ADMIN_SERVICE,
346 &conf, 0, 0,
347 &kadm5_handle);
348 if (ret) {
349 krb5_warn (context, ret, "kadm5_init_with_password_ctx");
350 reply_priv (auth_context, s, sa, sa_size, 2,
351 "Internal error");
352 goto out;
355 ret = krb5_unparse_name(context, principal, &client);
356 if (ret) {
357 krb5_warn (context, ret, "unparse_name failed");
358 reply_priv (auth_context, s, sa, sa_size,
359 KRB5_KPASSWD_HARDERROR, "out of memory error");
360 goto out;
364 * Check password quality if not changing as administrator
367 if (krb5_principal_compare(context, admin_principal, principal) == TRUE) {
369 pwd_reason = kadm5_check_password_quality (context, principal,
370 pwd_data);
371 if (pwd_reason != NULL ) {
372 krb5_warnx (context,
373 "%s didn't pass password quality check with error: %s",
374 client, pwd_reason);
375 reply_priv (auth_context, s, sa, sa_size,
376 KRB5_KPASSWD_SOFTERROR, pwd_reason);
377 goto out;
379 krb5_warnx (context, "Changing password for %s", client);
380 } else {
381 ret = _kadm5_acl_check_permission(kadm5_handle, KADM5_PRIV_CPW,
382 principal);
383 if (ret) {
384 krb5_warn (context, ret,
385 "Check ACL failed for %s for changing %s password",
386 admin, client);
387 reply_priv (auth_context, s, sa, sa_size,
388 KRB5_KPASSWD_HARDERROR, "permission denied");
389 goto out;
391 krb5_warnx (context, "%s is changing password for %s", admin, client);
394 ret = krb5_data_realloc(pwd_data, pwd_data->length + 1);
395 if (ret) {
396 krb5_warn (context, ret, "malloc: out of memory");
397 reply_priv (auth_context, s, sa, sa_size, KRB5_KPASSWD_HARDERROR,
398 "Internal error");
399 goto out;
401 tmp = pwd_data->data;
402 tmp[pwd_data->length - 1] = '\0';
404 ret = kadm5_s_chpass_principal_cond (kadm5_handle, principal, tmp);
405 krb5_free_data (context, pwd_data);
406 pwd_data = NULL;
407 if (ret) {
408 char *str = krb5_get_error_message(context, ret);
409 krb5_warnx(context, "kadm5_s_chpass_principal_cond: %s", str);
410 reply_priv (auth_context, s, sa, sa_size, KRB5_KPASSWD_SOFTERROR,
411 str ? str : "Internal error");
412 krb5_free_error_string(context, str);
413 goto out;
415 reply_priv (auth_context, s, sa, sa_size, KRB5_KPASSWD_SUCCESS,
416 "Password changed");
417 out:
418 free_ChangePasswdDataMS(&chpw);
419 if (admin)
420 free(admin);
421 if (client)
422 free(client);
423 if (pwd_data)
424 krb5_free_data(context, pwd_data);
425 if (kadm5_handle)
426 kadm5_destroy (kadm5_handle);
429 static int
430 verify (krb5_auth_context *auth_context,
431 krb5_realm *realms,
432 krb5_keytab keytab,
433 krb5_ticket **ticket,
434 krb5_data *out_data,
435 uint16_t *version,
436 int s,
437 struct sockaddr *sa,
438 int sa_size,
439 u_char *msg,
440 size_t len)
442 krb5_error_code ret;
443 uint16_t pkt_len, pkt_ver, ap_req_len;
444 krb5_data ap_req_data;
445 krb5_data krb_priv_data;
446 krb5_realm *r;
448 pkt_len = (msg[0] << 8) | (msg[1]);
449 pkt_ver = (msg[2] << 8) | (msg[3]);
450 ap_req_len = (msg[4] << 8) | (msg[5]);
451 if (pkt_len != len) {
452 krb5_warnx (context, "Strange len: %ld != %ld",
453 (long)pkt_len, (long)len);
454 reply_error (NULL, s, sa, sa_size, 0, 1, "Bad request");
455 return 1;
457 if (pkt_ver != KRB5_KPASSWD_VERS_CHANGEPW &&
458 pkt_ver != KRB5_KPASSWD_VERS_SETPW) {
459 krb5_warnx (context, "Bad version (%d)", pkt_ver);
460 reply_error (NULL, s, sa, sa_size, 0, 1, "Wrong program version");
461 return 1;
463 *version = pkt_ver;
465 ap_req_data.data = msg + 6;
466 ap_req_data.length = ap_req_len;
468 ret = krb5_rd_req (context,
469 auth_context,
470 &ap_req_data,
471 NULL,
472 keytab,
473 NULL,
474 ticket);
475 if (ret) {
476 krb5_warn (context, ret, "krb5_rd_req");
477 reply_error (NULL, s, sa, sa_size, ret, 3, "Authentication failed");
478 return 1;
481 /* verify realm and principal */
482 for (r = realms; *r != NULL; r++) {
483 krb5_principal principal;
484 krb5_boolean same;
486 ret = krb5_make_principal (context,
487 &principal,
489 "kadmin",
490 "changepw",
491 NULL);
492 if (ret)
493 krb5_err (context, 1, ret, "krb5_make_principal");
495 same = krb5_principal_compare(context, principal, (*ticket)->server);
496 krb5_free_principal(context, principal);
497 if (same == TRUE)
498 break;
500 if (*r == NULL) {
501 char *str;
502 krb5_unparse_name(context, (*ticket)->server, &str);
503 krb5_warnx (context, "client used not valid principal %s", str);
504 free(str);
505 reply_error (NULL, s, sa, sa_size, ret, 1,
506 "Bad request");
507 goto out;
510 if (strcmp((*ticket)->server->realm, (*ticket)->client->realm) != 0) {
511 krb5_warnx (context, "server realm (%s) not same a client realm (%s)",
512 (*ticket)->server->realm, (*ticket)->client->realm);
513 reply_error ((*ticket)->server->realm, s, sa, sa_size, ret, 1,
514 "Bad request");
515 goto out;
518 if (!(*ticket)->ticket.flags.initial) {
519 krb5_warnx (context, "initial flag not set");
520 reply_error ((*ticket)->server->realm, s, sa, sa_size, ret, 1,
521 "Bad request");
522 goto out;
524 krb_priv_data.data = msg + 6 + ap_req_len;
525 krb_priv_data.length = len - 6 - ap_req_len;
527 ret = krb5_rd_priv (context,
528 *auth_context,
529 &krb_priv_data,
530 out_data,
531 NULL);
533 if (ret) {
534 krb5_warn (context, ret, "krb5_rd_priv");
535 reply_error ((*ticket)->server->realm, s, sa, sa_size, ret, 3,
536 "Bad request");
537 goto out;
539 return 0;
540 out:
541 krb5_free_ticket (context, *ticket);
542 ticket = NULL;
543 return 1;
546 static void
547 process (krb5_realm *realms,
548 krb5_keytab keytab,
549 int s,
550 krb5_address *this_addr,
551 struct sockaddr *sa,
552 int sa_size,
553 u_char *msg,
554 int len)
556 krb5_error_code ret;
557 krb5_auth_context auth_context = NULL;
558 krb5_data out_data;
559 krb5_ticket *ticket;
560 krb5_address other_addr;
561 uint16_t version;
564 krb5_data_zero (&out_data);
566 ret = krb5_auth_con_init (context, &auth_context);
567 if (ret) {
568 krb5_warn (context, ret, "krb5_auth_con_init");
569 return;
572 krb5_auth_con_setflags (context, auth_context,
573 KRB5_AUTH_CONTEXT_DO_SEQUENCE);
575 ret = krb5_sockaddr2address (context, sa, &other_addr);
576 if (ret) {
577 krb5_warn (context, ret, "krb5_sockaddr2address");
578 goto out;
581 ret = krb5_auth_con_setaddrs (context,
582 auth_context,
583 this_addr,
584 &other_addr);
585 krb5_free_address (context, &other_addr);
586 if (ret) {
587 krb5_warn (context, ret, "krb5_auth_con_setaddr");
588 goto out;
591 if (verify (&auth_context, realms, keytab, &ticket, &out_data,
592 &version, s, sa, sa_size, msg, len) == 0) {
593 change (auth_context,
594 ticket->client,
595 version,
597 sa, sa_size,
598 &out_data);
599 memset (out_data.data, 0, out_data.length);
600 krb5_free_ticket (context, ticket);
603 out:
604 krb5_data_free (&out_data);
605 krb5_auth_con_free (context, auth_context);
608 static int
609 doit (krb5_keytab keytab, int port)
611 krb5_error_code ret;
612 int *sockets;
613 int maxfd;
614 krb5_realm *realms;
615 krb5_addresses addrs;
616 unsigned n, i;
617 fd_set real_fdset;
618 struct sockaddr_storage __ss;
619 struct sockaddr *sa = (struct sockaddr *)&__ss;
621 ret = krb5_get_default_realms(context, &realms);
622 if (ret)
623 krb5_err (context, 1, ret, "krb5_get_default_realms");
625 if (explicit_addresses.len) {
626 addrs = explicit_addresses;
627 } else {
628 ret = krb5_get_all_server_addrs (context, &addrs);
629 if (ret)
630 krb5_err (context, 1, ret, "krb5_get_all_server_addrs");
632 n = addrs.len;
634 sockets = malloc (n * sizeof(*sockets));
635 if (sockets == NULL)
636 krb5_errx (context, 1, "out of memory");
637 maxfd = -1;
638 FD_ZERO(&real_fdset);
639 for (i = 0; i < n; ++i) {
640 krb5_socklen_t sa_size = sizeof(__ss);
642 krb5_addr2sockaddr (context, &addrs.val[i], sa, &sa_size, port);
644 sockets[i] = socket (sa->sa_family, SOCK_DGRAM, 0);
645 if (sockets[i] < 0)
646 krb5_err (context, 1, errno, "socket");
647 if (bind (sockets[i], sa, sa_size) < 0) {
648 char str[128];
649 size_t len;
650 int save_errno = errno;
652 ret = krb5_print_address (&addrs.val[i], str, sizeof(str), &len);
653 if (ret)
654 strlcpy(str, "unknown address", sizeof(str));
655 krb5_warn (context, save_errno, "bind(%s)", str);
656 continue;
658 maxfd = max (maxfd, sockets[i]);
659 if (maxfd >= FD_SETSIZE)
660 krb5_errx (context, 1, "fd too large");
661 FD_SET(sockets[i], &real_fdset);
663 if (maxfd == -1)
664 krb5_errx (context, 1, "No sockets!");
666 while(exit_flag == 0) {
667 int ret;
668 fd_set fdset = real_fdset;
670 ret = select (maxfd + 1, &fdset, NULL, NULL, NULL);
671 if (ret < 0) {
672 if (errno == EINTR)
673 continue;
674 else
675 krb5_err (context, 1, errno, "select");
677 for (i = 0; i < n; ++i)
678 if (FD_ISSET(sockets[i], &fdset)) {
679 u_char buf[BUFSIZ];
680 socklen_t addrlen = sizeof(__ss);
682 ret = recvfrom (sockets[i], buf, sizeof(buf), 0,
683 sa, &addrlen);
684 if (ret < 0) {
685 if(errno == EINTR)
686 break;
687 else
688 krb5_err (context, 1, errno, "recvfrom");
691 process (realms, keytab, sockets[i],
692 &addrs.val[i],
693 sa, addrlen,
694 buf, ret);
698 for (i = 0; i < n; ++i)
699 close(sockets[i]);
700 free(sockets);
702 krb5_free_addresses (context, &addrs);
703 krb5_free_host_realm (context, realms);
704 krb5_free_context (context);
705 return 0;
708 static RETSIGTYPE
709 sigterm(int sig)
711 exit_flag = 1;
714 static const char *check_library = NULL;
715 static const char *check_function = NULL;
716 static getarg_strings policy_libraries = { 0, NULL };
717 static char *keytab_str = "HDB:";
718 static char *realm_str;
719 static int version_flag;
720 static int help_flag;
721 static char *port_str;
722 static char *config_file;
724 struct getargs args[] = {
725 #ifdef HAVE_DLOPEN
726 { "check-library", 0, arg_string, &check_library,
727 "library to load password check function from", "library" },
728 { "check-function", 0, arg_string, &check_function,
729 "password check function to load", "function" },
730 { "policy-libraries", 0, arg_strings, &policy_libraries,
731 "password check function to load", "function" },
732 #endif
733 { "addresses", 0, arg_strings, &addresses_str,
734 "addresses to listen on", "list of addresses" },
735 { "keytab", 'k', arg_string, &keytab_str,
736 "keytab to get authentication key from", "kspec" },
737 { "config-file", 'c', arg_string, &config_file },
738 { "realm", 'r', arg_string, &realm_str, "default realm", "realm" },
739 { "port", 'p', arg_string, &port_str, "port" },
740 { "version", 0, arg_flag, &version_flag },
741 { "help", 0, arg_flag, &help_flag }
743 int num_args = sizeof(args) / sizeof(args[0]);
746 main (int argc, char **argv)
748 int optind;
749 krb5_keytab keytab;
750 krb5_error_code ret;
751 char **files;
752 int port, i;
754 optind = krb5_program_setup(&context, argc, argv, args, num_args, NULL);
756 if(help_flag)
757 krb5_std_usage(0, args, num_args);
758 if(version_flag) {
759 print_version(NULL);
760 exit(0);
763 if (config_file == NULL) {
764 asprintf(&config_file, "%s/kdc.conf", hdb_db_dir(context));
765 if (config_file == NULL)
766 errx(1, "out of memory");
769 ret = krb5_prepend_config_files_default(config_file, &files);
770 if (ret)
771 krb5_err(context, 1, ret, "getting configuration files");
773 ret = krb5_set_config_files(context, files);
774 krb5_free_config_files(files);
775 if (ret)
776 krb5_err(context, 1, ret, "reading configuration files");
778 if(realm_str)
779 krb5_set_default_realm(context, realm_str);
781 krb5_openlog (context, "kpasswdd", &log_facility);
782 krb5_set_warn_dest(context, log_facility);
784 if (port_str != NULL) {
785 struct servent *s = roken_getservbyname (port_str, "udp");
787 if (s != NULL)
788 port = s->s_port;
789 else {
790 char *ptr;
792 port = strtol (port_str, &ptr, 10);
793 if (port == 0 && ptr == port_str)
794 krb5_errx (context, 1, "bad port `%s'", port_str);
795 port = htons(port);
797 } else
798 port = krb5_getportbyname (context, "kpasswd", "udp", KPASSWD_PORT);
800 ret = krb5_kt_register(context, &hdb_kt_ops);
801 if(ret)
802 krb5_err(context, 1, ret, "krb5_kt_register");
804 ret = krb5_kt_resolve(context, keytab_str, &keytab);
805 if(ret)
806 krb5_err(context, 1, ret, "%s", keytab_str);
808 kadm5_setup_passwd_quality_check (context, check_library, check_function);
810 for (i = 0; i < policy_libraries.num_strings; i++) {
811 ret = kadm5_add_passwd_quality_verifier(context,
812 policy_libraries.strings[i]);
813 if (ret)
814 krb5_err(context, 1, ret, "kadm5_add_passwd_quality_verifier");
816 ret = kadm5_add_passwd_quality_verifier(context, NULL);
817 if (ret)
818 krb5_err(context, 1, ret, "kadm5_add_passwd_quality_verifier");
821 explicit_addresses.len = 0;
823 if (addresses_str.num_strings) {
824 int i;
826 for (i = 0; i < addresses_str.num_strings; ++i)
827 add_one_address (addresses_str.strings[i], i == 0);
828 free_getarg_strings (&addresses_str);
829 } else {
830 char **foo = krb5_config_get_strings (context, NULL,
831 "kdc", "addresses", NULL);
833 if (foo != NULL) {
834 add_one_address (*foo++, TRUE);
835 while (*foo)
836 add_one_address (*foo++, FALSE);
840 #ifdef HAVE_SIGACTION
842 struct sigaction sa;
844 sa.sa_flags = 0;
845 sa.sa_handler = sigterm;
846 sigemptyset(&sa.sa_mask);
848 sigaction(SIGINT, &sa, NULL);
849 sigaction(SIGTERM, &sa, NULL);
851 #else
852 signal(SIGINT, sigterm);
853 signal(SIGTERM, sigterm);
854 #endif
856 pidfile(NULL);
858 return doit (keytab, port);