kadmin/kadmind.c

   1 /*
   2  * Copyright (c) 1997-2004 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 "kadmin_locl.h"
  35
  36 static char *check_library  = NULL;
  37 static char *check_function = NULL;
  38 static getarg_strings policy_libraries = { 0, NULL };
  39 static char *config_file;
  40 static char sHDB[] = "HDBGET:";
  41 static char *keytab_str = sHDB;
  42 static int help_flag;
  43 static int version_flag;
  44 static int debug_flag;
  45 static char *port_str;
  46 char *realm;
  47
  48 static int detach_from_console = -1;
  49 int daemon_child = -1;
  50
  51 static struct getargs args[] = {
  52     {
  53         "config-file",  'c',    arg_string,     &config_file,
  54         "location of config file",      "file"
  55     },
  56     {
  57         "keytab",       0,      arg_string, &keytab_str,
  58         "what keytab to use", "keytab"
  59     },
  60     {   "realm",        'r',    arg_string,   &realm,
  61         "realm to use", "realm"
  62     },
  63 #ifdef HAVE_DLOPEN
  64     { "check-library", 0, arg_string, &check_library,
  65       "library to load password check function from", "library" },
  66     { "check-function", 0, arg_string, &check_function,
  67       "password check function to load", "function" },
  68     { "policy-libraries", 0, arg_strings, &policy_libraries,
  69       "password check function to load", "function" },
  70 #endif
  71     {   "debug",        'd',    arg_flag,   &debug_flag,
  72         "enable debugging", NULL
  73     },
  74     {
  75         "detach",       0 ,      arg_flag, &detach_from_console,
  76         "detach from console", NULL
  77     },
  78     {
  79         "daemon-child",       0 ,      arg_integer, &daemon_child,
  80         "private argument, do not use", NULL
  81     },
  82     {   "ports",        'p',    arg_string, &port_str,
  83         "ports to listen to", "port" },
  84     {   "help",         'h',    arg_flag,   &help_flag, NULL, NULL },
  85     {   "version",      'v',    arg_flag,   &version_flag, NULL, NULL }
  86 };
  87
  88 static int num_args = sizeof(args) / sizeof(args[0]);
  89
  90 krb5_context context;
  91
  92 static void
  93 usage(int ret)
  94 {
  95     arg_printusage (args, num_args, NULL, "");
  96     exit (ret);
  97 }
  98
  99 int
 100 main(int argc, char **argv)
 101 {
 102     krb5_error_code ret;
 103     char **files;
 104     int optidx = 0;
 105     int i;
 106     krb5_log_facility *logfacility;
 107     krb5_keytab keytab;
 108     krb5_socket_t sfd = rk_INVALID_SOCKET;
 109
 110     setprogname(argv[0]);
 111
 112     if (getarg(args, num_args, argc, argv, &optidx)) {
 113         warnx("error at argument `%s'", argv[optidx]);
 114         usage(1);
 115     }
 116
 117     if (help_flag)
 118         usage (0);
 119
 120     if (version_flag) {
 121         print_version(NULL);
 122         exit(0);
 123     }
 124
 125     if (detach_from_console > 0 && daemon_child == -1)
 126         roken_detach_prep(argc, argv, "--daemon-child");
 127
 128     ret = krb5_init_context(&context);
 129     if (ret)
 130         errx (1, "krb5_init_context failed: %d", ret);
 131
 132     argc -= optidx;
 133     argv += optidx;
 134
 135     if (config_file == NULL) {
 136         int aret;
 137
 138         aret = asprintf(&config_file, "%s/kdc.conf", hdb_db_dir(context));
 139         if (aret == -1)
 140             errx(1, "out of memory");
 141     }
 142
 143     ret = krb5_prepend_config_files_default(config_file, &files);
 144     if (ret)
 145         krb5_err(context, 1, ret, "getting configuration files");
 146
 147     ret = krb5_set_config_files(context, files);
 148     krb5_free_config_files(files);
 149     if(ret)
 150         krb5_err(context, 1, ret, "reading configuration files");
 151
 152     ret = krb5_openlog(context, "kadmind", &logfacility);
 153     if (ret)
 154         krb5_err(context, 1, ret, "krb5_openlog");
 155     ret = krb5_set_warn_dest(context, logfacility);
 156     if (ret)
 157         krb5_err(context, 1, ret, "krb5_set_warn_dest");
 158
 159     ret = krb5_kt_register(context, &hdb_get_kt_ops);
 160     if(ret)
 161         krb5_err(context, 1, ret, "krb5_kt_register");
 162
 163     ret = krb5_kt_resolve(context, keytab_str, &keytab);
 164     if(ret)
 165         krb5_err(context, 1, ret, "krb5_kt_resolve");
 166
 167     kadm5_setup_passwd_quality_check (context, check_library, check_function);
 168
 169     for (i = 0; i < policy_libraries.num_strings; i++) {
 170         ret = kadm5_add_passwd_quality_verifier(context,
 171                                                 policy_libraries.strings[i]);
 172         if (ret)
 173             krb5_err(context, 1, ret, "kadm5_add_passwd_quality_verifier");
 174     }
 175     ret = kadm5_add_passwd_quality_verifier(context, NULL);
 176     if (ret)
 177         krb5_err(context, 1, ret, "kadm5_add_passwd_quality_verifier");
 178
 179     if(debug_flag) {
 180         int debug_port;
 181
 182         if(port_str == NULL)
 183             debug_port = krb5_getportbyname (context, "kerberos-adm",
 184                                              "tcp", 749);
 185         else
 186             debug_port = htons(atoi(port_str));
 187         mini_inetd(debug_port, &sfd);
 188     } else {
 189 #ifdef _WIN32
 190         start_server(context, port_str);
 191 #else
 192         struct sockaddr_storage __ss;
 193         struct sockaddr *sa = (struct sockaddr *)&__ss;
 194         socklen_t sa_size = sizeof(__ss);
 195
 196         /*
 197          * Check if we are running inside inetd or not, if not, start
 198          * our own server.
 199          */
 200
 201         if(roken_getsockname(STDIN_FILENO, sa, &sa_size) < 0 &&
 202            rk_SOCK_ERRNO == ENOTSOCK) {
 203             start_server(context, port_str);
 204         }
 205 #endif /* _WIN32 */
 206         sfd = STDIN_FILENO;
 207     }
 208
 209     if(realm)
 210         krb5_set_default_realm(context, realm); /* XXX */
 211
 212     kadmind_loop(context, keytab, sfd);
 213
 214     return 0;
 215 }