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 = {
 113                 .sem_op = -1,
 114                 .sem_flag = SEM_UNDO
 115         };
 116         int rc;
 117
 118         rc = semop(semid, &op, 1);
 119         if (rc != 0) {
 120                 printerr(0, "exit on mutex_get err %d: %s\n",
 121                          rc, strerror(errno));
 122                 exit(1);
 123         }
 124 }
 125
 126 void lgssd_mutex_put(int semid)
 127 {
 128         struct sembuf op = {
 129                 .sem_op = 1
 130         };
 131         int rc;
 132
 133         rc = semop(semid, &op, 1);
 134         if (rc != 0) {
 135                 printerr(0, "ignore mutex_put err %d: %s\n",
 136                          rc, strerror(errno));
 137         }
 138 }
 139
 140 static void lgssd_cleanup(void)
 141 {
 142         pid_t   child_pid;
 143
 144         /* make sure all children finished */
 145         while (1) {
 146                 child_pid = waitpid(-1, NULL, 0);
 147                 if (child_pid < 0)
 148                         break;
 149
 150                 printerr(3, "cleanup: child %d terminated\n", child_pid);
 151         }
 152
 153         lgssd_fini_mutexs();
 154
 155         /* destroy krb5 machine creds */
 156         gssd_destroy_krb5_machine_creds();
 157 }
 158
 159 void
 160 sig_die(int signal)
 161 {
 162         printerr(1, "exiting on signal %d\n", signal);
 163         lgssd_cleanup();
 164         exit(1);
 165 }
 166
 167 void
 168 sig_hup(int signal)
 169 {
 170         /* don't exit on SIGHUP */
 171         printerr(1, "Received SIGHUP... Ignoring.\n");
 172         return;
 173 }
 174
 175 static void
 176 usage(char *progname)
 177 {
 178         fprintf(stderr, "usage: %s [-f] [-v] [-p pipefsdir] [-k keytab] [-d ccachedir]\n",
 179                 progname);
 180         exit(1);
 181 }
 182
 183 int
 184 main(int argc, char *argv[])
 185 {
 186         int fg = 0;
 187         int verbosity = 0;
 188         int opt;
 189         extern char *optarg;
 190         char *progname;
 191
 192         while ((opt = getopt(argc, argv, "fvrmMp:k:d:")) != -1) {
 193                 switch (opt) {
 194                         case 'f':
 195                                 fg = 1;
 196                                 break;
 197                         case 'M':
 198                                 use_memcache = 1;
 199                                 break;
 200                         case 'v':
 201                                 verbosity++;
 202                                 break;
 203                         case 'p':
 204                                 strlcpy(pipefs_dir, optarg, sizeof(pipefs_dir));
 205                                 if (pipefs_dir[sizeof(pipefs_dir)-1] != '\0')
 206                                         errx(1, "pipefs path name too long");
 207                                 break;
 208                         case 'k':
 209                                 strlcpy(keytabfile, optarg, sizeof(keytabfile));
 210                                 if (keytabfile[sizeof(keytabfile)-1] != '\0')
 211                                         errx(1, "keytab path name too long");
 212                                 break;
 213                         case 'd':
 214                                 strlcpy(ccachedir, optarg, sizeof(ccachedir));
 215                                 if (ccachedir[sizeof(ccachedir)-1] != '\0')
 216                                         errx(1, "ccachedir path name too long");
 217                                 break;
 218                         default:
 219                                 usage(argv[0]);
 220                                 break;
 221                 }
 222         }
 223
 224         if ((progname = strrchr(argv[0], '/')))
 225                 progname++;
 226         else
 227                 progname = argv[0];
 228
 229         initerr(progname, verbosity, fg);
 230
 231         if (gssd_check_mechs() != 0)
 232                 errx(1, "Problem with gssapi library");
 233
 234         if (gssd_get_local_realm())
 235                 errx(1, "get local realm");
 236
 237         if (!fg && daemon(0, 0) < 0)
 238                 errx(1, "fork");
 239
 240         /* This should be checked _after_ daemon(), because we need to own
 241          * the undo-able semaphore by this process
 242          */
 243         gssd_init_unique(GSSD_CLI);
 244
 245         /* Process keytab file and get machine credentials. This will modify
 246          * disk status so do it after we are sure we are the only instance
 247          */
 248         if (gssd_refresh_krb5_machine_creds())
 249                 return -1;
 250
 251         signal(SIGINT, sig_die);
 252         signal(SIGTERM, sig_die);
 253         signal(SIGHUP, sig_hup);
 254
 255         lgssd_init_mutexs();
 256
 257         printerr(0, "lgssd initialized and ready to serve\n");
 258         lgssd_run();
 259
 260         lgssd_cleanup();
 261         printerr(0, "lgssd exiting\n");
 262         return 0;
 263 }