lustre/utils/gss/gssd.c

   1 /*
   2   gssd.c
   3
   4   Copyright (c) 2000 The Regents of the University of Michigan.
   5   All rights reserved.
   6
   7   Copyright (c) 2000 Dug Song <dugsong@UMICH.EDU>.
   8   Copyright (c) 2002 Andy Adamson <andros@UMICH.EDU>.
   9   Copyright (c) 2002 Marius Aamodt Eriksen <marius@UMICH.EDU>.
  10   All rights reserved, all wrongs reversed.
  11
  12   Copyright (c) 2014, Intel Corporation.
  13
  14   Redistribution and use in source and binary forms, with or without
  15   modification, are permitted provided that the following conditions
  16   are met:
  17
  18   1. Redistributions of source code must retain the above copyright
  19      notice, this list of conditions and the following disclaimer.
  20   2. Redistributions in binary form must reproduce the above copyright
  21      notice, this list of conditions and the following disclaimer in the
  22      documentation and/or other materials provided with the distribution.
  23   3. Neither the name of the University nor the names of its
  24      contributors may be used to endorse or promote products derived
  25      from this software without specific prior written permission.
  26
  27   THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
  28   WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
  29   MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  30   DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  31   FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  32   CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  33   SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
  34   BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
  35   LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
  36   NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  37   SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  38
  39 */
  40
  41 #include "config.h"
  42
  43 #include <sys/types.h>
  44 #include <sys/param.h>
  45 #include <sys/socket.h>
  46 #include <sys/wait.h>
  47 #include <sys/ipc.h>
  48 #include <sys/sem.h>
  49
  50 #include <unistd.h>
  51 #include <err.h>
  52 #include <stdio.h>
  53 #include <stdlib.h>
  54 #include <string.h>
  55 #include <signal.h>
  56 #include <errno.h>
  57 #include <libcfs/util/string.h>
  58
  59 #include "gssd.h"
  60 #include "err_util.h"
  61 #include "gss_util.h"
  62 #include "krb5_util.h"
  63 #include "lsupport.h"
  64
  65 char pipefs_dir[PATH_MAX] = GSSD_PIPEFS_DIR;
  66 char pipefs_nfsdir[PATH_MAX] = GSSD_PIPEFS_DIR;
  67 char keytabfile[PATH_MAX] = GSSD_DEFAULT_KEYTAB_FILE;
  68 char ccachedir[PATH_MAX] = GSSD_DEFAULT_CRED_DIR;
  69 int  use_memcache = 0;
  70 int  lgssd_mutex_downcall = -1;
  71
  72 static int lgssd_create_mutex(int *semid)
  73 {
  74         int             id;
  75         int             arg;
  76
  77         id = semget(IPC_PRIVATE, 1, IPC_CREAT);
  78         if (id == -1) {
  79                 printerr(0, "semget: %s\n", strerror(errno));
  80                 return -1;
  81         }
  82
  83         arg = 1;
  84         if (semctl(id, 0, SETVAL, arg) != 0) {
  85                 printerr(0, "semctl: %s\n", strerror(errno));
  86                 semctl(id, 1, IPC_RMID, arg);
  87                 return -1;
  88         }
  89
  90         *semid = id;
  91         return 0;
  92 }
  93
  94 void lgssd_init_mutexs(void)
  95 {
  96         if (lgssd_create_mutex(&lgssd_mutex_downcall)) {
  97                 printerr(0, "can't create downcall mutex\n");
  98                 exit(1);
  99         }
 100 }
 101
 102 void lgssd_fini_mutexs(void)
 103 {
 104         int     arg = 0;
 105
 106         if (lgssd_mutex_downcall != -1)
 107                 semctl(lgssd_mutex_downcall, 1, IPC_RMID, arg);
 108 }
 109
 110 void lgssd_mutex_get(int semid)
 111 {
 112         struct sembuf   op[1] = { {0, -1, SEM_UNDO} };
 113         int             rc;
 114
 115         rc = semop(semid, op, 1);
 116         if (rc != 0) {
 117                 printerr(0, "exit on mutex_get err %d: %s\n",
 118                          rc, strerror(errno));
 119                 exit(1);
 120         }
 121 }
 122
 123 void lgssd_mutex_put(int semid)
 124 {
 125         struct sembuf   op[1] = { {0, 1, 0} };
 126         int             rc;
 127
 128         rc = semop(semid, op, 1);
 129         if (rc != 0) {
 130                 printerr(0, "ignore mutex_put err %d: %s\n",
 131                          rc, strerror(errno));
 132         }
 133 }
 134
 135 static void lgssd_cleanup(void)
 136 {
 137         pid_t   child_pid;
 138
 139         /* make sure all children finished */
 140         while (1) {
 141                 child_pid = waitpid(-1, NULL, 0);
 142                 if (child_pid < 0)
 143                         break;
 144
 145                 printerr(3, "cleanup: child %d terminated\n", child_pid);
 146         }
 147
 148         lgssd_fini_mutexs();
 149
 150         /* destroy krb5 machine creds */
 151         gssd_destroy_krb5_machine_creds();
 152 }
 153
 154 void
 155 sig_die(int signal)
 156 {
 157         printerr(1, "exiting on signal %d\n", signal);
 158         lgssd_cleanup();
 159         exit(1);
 160 }
 161
 162 void
 163 sig_hup(int signal)
 164 {
 165         /* don't exit on SIGHUP */
 166         printerr(1, "Received SIGHUP... Ignoring.\n");
 167         return;
 168 }
 169
 170 static void
 171 usage(char *progname)
 172 {
 173         fprintf(stderr, "usage: %s [-f] [-v] [-p pipefsdir] [-k keytab] [-d ccachedir]\n",
 174                 progname);
 175         exit(1);
 176 }
 177
 178 int
 179 main(int argc, char *argv[])
 180 {
 181         int fg = 0;
 182         int verbosity = 0;
 183         int opt;
 184         extern char *optarg;
 185         char *progname;
 186
 187         while ((opt = getopt(argc, argv, "fvrmMp:k:d:")) != -1) {
 188                 switch (opt) {
 189                         case 'f':
 190                                 fg = 1;
 191                                 break;
 192                         case 'M':
 193                                 use_memcache = 1;
 194                                 break;
 195                         case 'v':
 196                                 verbosity++;
 197                                 break;
 198                         case 'p':
 199                                 strlcpy(pipefs_dir, optarg, sizeof(pipefs_dir));
 200                                 if (pipefs_dir[sizeof(pipefs_dir)-1] != '\0')
 201                                         errx(1, "pipefs path name too long");
 202                                 break;
 203                         case 'k':
 204                                 strlcpy(keytabfile, optarg, sizeof(keytabfile));
 205                                 if (keytabfile[sizeof(keytabfile)-1] != '\0')
 206                                         errx(1, "keytab path name too long");
 207                                 break;
 208                         case 'd':
 209                                 strlcpy(ccachedir, optarg, sizeof(ccachedir));
 210                                 if (ccachedir[sizeof(ccachedir)-1] != '\0')
 211                                         errx(1, "ccachedir path name too long");
 212                                 break;
 213                         default:
 214                                 usage(argv[0]);
 215                                 break;
 216                 }
 217         }
 218
 219         if ((progname = strrchr(argv[0], '/')))
 220                 progname++;
 221         else
 222                 progname = argv[0];
 223
 224         initerr(progname, verbosity, fg);
 225
 226         if (gssd_check_mechs() != 0)
 227                 errx(1, "Problem with gssapi library");
 228
 229         if (gssd_get_local_realm())
 230                 errx(1, "get local realm");
 231
 232         if (!fg && daemon(0, 0) < 0)
 233                 errx(1, "fork");
 234
 235         /* This should be checked _after_ daemon(), because we need to own
 236          * the undo-able semaphore by this process
 237          */
 238         gssd_init_unique(GSSD_CLI);
 239
 240         /* Process keytab file and get machine credentials. This will modify
 241          * disk status so do it after we are sure we are the only instance
 242          */
 243         if (gssd_refresh_krb5_machine_creds())
 244                 return -1;
 245
 246         signal(SIGINT, sig_die);
 247         signal(SIGTERM, sig_die);
 248         signal(SIGHUP, sig_hup);
 249
 250         lgssd_init_mutexs();
 251
 252         printerr(0, "lgssd initialized and ready to serve\n");
 253         lgssd_run();
 254
 255         lgssd_cleanup();
 256         printerr(0, "lgssd exiting\n");
 257         return 0;
 258 }