utils/gssd/gssd_main_loop.c

   1 /*
   2   Copyright (c) 2004 The Regents of the University of Michigan.
   3   All rights reserved.
   4
   5   Redistribution and use in source and binary forms, with or without
   6   modification, are permitted provided that the following conditions
   7   are met:
   8
   9   1. Redistributions of source code must retain the above copyright
  10      notice, this list of conditions and the following disclaimer.
  11   2. Redistributions in binary form must reproduce the above copyright
  12      notice, this list of conditions and the following disclaimer in the
  13      documentation and/or other materials provided with the distribution.
  14   3. Neither the name of the University nor the names of its
  15      contributors may be used to endorse or promote products derived
  16      from this software without specific prior written permission.
  17
  18   THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
  19   WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
  20   MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  21   DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  22   FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  23   CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  24   SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
  25   BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
  26   LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
  27   NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  28   SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  29 */
  30
  31 #ifdef HAVE_CONFIG_H
  32 #include <config.h>
  33 #endif  /* HAVE_CONFIG_H */
  34
  35 #ifndef _GNU_SOURCE
  36 #define _GNU_SOURCE
  37 #endif
  38
  39 #include <sys/param.h>
  40 #include <sys/socket.h>
  41 #include <sys/poll.h>
  42 #include <netinet/in.h>
  43
  44 #include <stdio.h>
  45 #include <stdlib.h>
  46 #include <string.h>
  47 #include <memory.h>
  48 #include <errno.h>
  49 #include <fcntl.h>
  50 #include <signal.h>
  51 #include <unistd.h>
  52 #include <dirent.h>
  53
  54 #include "gssd.h"
  55 #include "err_util.h"
  56
  57 extern struct pollfd *pollarray;
  58 extern int pollsize;
  59
  60 #define POLL_MILLISECS  500
  61
  62 static volatile int dir_changed = 1;
  63
  64 static void dir_notify_handler(int sig, siginfo_t *si, void *data)
  65 {
  66         dir_changed = 1;
  67 }
  68
  69 static void
  70 scan_poll_results(int ret)
  71 {
  72         int                     i;
  73         struct clnt_info        *clp;
  74
  75         for (clp = clnt_list.tqh_first; clp != NULL; clp = clp->list.tqe_next)
  76         {
  77                 i = clp->gssd_poll_index;
  78                 if (i >= 0 && pollarray[i].revents) {
  79                         if (pollarray[i].revents & POLLHUP)
  80                                 dir_changed = 1;
  81                         if (pollarray[i].revents & POLLIN)
  82                                 handle_gssd_upcall(clp);
  83                         pollarray[clp->gssd_poll_index].revents = 0;
  84                         ret--;
  85                         if (!ret)
  86                                 break;
  87                 }
  88                 i = clp->krb5_poll_index;
  89                 if (i >= 0 && pollarray[i].revents) {
  90                         if (pollarray[i].revents & POLLHUP)
  91                                 dir_changed = 1;
  92                         if (pollarray[i].revents & POLLIN)
  93                                 handle_krb5_upcall(clp);
  94                         pollarray[clp->krb5_poll_index].revents = 0;
  95                         ret--;
  96                         if (!ret)
  97                                 break;
  98                 }
  99                 i = clp->spkm3_poll_index;
 100                 if (i >= 0 && pollarray[i].revents) {
 101                         if (pollarray[i].revents & POLLHUP)
 102                                 dir_changed = 1;
 103                         if (pollarray[i].revents & POLLIN)
 104                                 handle_spkm3_upcall(clp);
 105                         pollarray[clp->spkm3_poll_index].revents = 0;
 106                         ret--;
 107                         if (!ret)
 108                                 break;
 109                 }
 110         }
 111 };
 112
 113 static int
 114 topdirs_add_entry(struct dirent *dent)
 115 {
 116         struct topdirs_info *tdi;
 117
 118         tdi = calloc(sizeof(struct topdirs_info), 1);
 119         if (tdi == NULL) {
 120                 printerr(0, "ERROR: Couldn't allocate struct topdirs_info\n");
 121                 return -1;
 122         }
 123         tdi->dirname = malloc(PATH_MAX);
 124         if (tdi->dirname == NULL) {
 125                 printerr(0, "ERROR: Couldn't allocate directory name\n");
 126                 free(tdi);
 127                 return -1;
 128         }
 129         snprintf(tdi->dirname, PATH_MAX, "%s/%s", pipefs_dir, dent->d_name);
 130         tdi->fd = open(tdi->dirname, O_RDONLY);
 131         if (tdi->fd != -1) {
 132                 fcntl(tdi->fd, F_SETSIG, DNOTIFY_SIGNAL);
 133                 fcntl(tdi->fd, F_NOTIFY,
 134                       DN_CREATE|DN_DELETE|DN_MODIFY|DN_MULTISHOT);
 135         }
 136
 137         TAILQ_INSERT_HEAD(&topdirs_list, tdi, list);
 138         return 0;
 139 }
 140
 141 static void
 142 topdirs_free_list(void)
 143 {
 144         struct topdirs_info *tdi;
 145
 146         TAILQ_FOREACH(tdi, &topdirs_list, list) {
 147                 free(tdi->dirname);
 148                 if (tdi->fd != -1)
 149                         close(tdi->fd);
 150                 TAILQ_REMOVE(&topdirs_list, tdi, list);
 151                 free(tdi);
 152         }
 153 }
 154
 155 static int
 156 topdirs_init_list(void)
 157 {
 158         DIR             *pipedir;
 159         struct dirent   *dent;
 160         int             ret;
 161
 162         TAILQ_INIT(&topdirs_list);
 163
 164         pipedir = opendir(pipefs_dir);
 165         if (pipedir == NULL) {
 166                 printerr(0, "ERROR: could not open rpc_pipefs directory '%s': "
 167                          "%s\n", pipefs_dir, strerror(errno));
 168                 return -1;
 169         }
 170         for (dent = readdir(pipedir); dent != NULL; dent = readdir(pipedir)) {
 171                 if (dent->d_type != DT_DIR ||
 172                     strcmp(dent->d_name, ".") == 0  ||
 173                     strcmp(dent->d_name, "..") == 0) {
 174                         continue;
 175                 }
 176                 ret = topdirs_add_entry(dent);
 177                 if (ret)
 178                         goto out_err;
 179         }
 180         closedir(pipedir);
 181         return 0;
 182 out_err:
 183         topdirs_free_list();
 184         return -1;
 185 }
 186
 187 void
 188 gssd_run()
 189 {
 190         int                     ret;
 191         struct sigaction        dn_act;
 192         sigset_t                set;
 193
 194         /* Taken from linux/Documentation/dnotify.txt: */
 195         dn_act.sa_sigaction = dir_notify_handler;
 196         sigemptyset(&dn_act.sa_mask);
 197         dn_act.sa_flags = SA_SIGINFO;
 198         sigaction(DNOTIFY_SIGNAL, &dn_act, NULL);
 199
 200         /* just in case the signal is blocked... */
 201         sigemptyset(&set);
 202         sigaddset(&set, DNOTIFY_SIGNAL);
 203         sigprocmask(SIG_UNBLOCK, &set, NULL);
 204
 205         if (topdirs_init_list() != 0)
 206                 return;
 207
 208         init_client_list();
 209
 210         printerr(1, "beginning poll\n");
 211         while (1) {
 212                 while (dir_changed) {
 213                         dir_changed = 0;
 214                         if (update_client_list()) {
 215                                 /* Error msg is already printed */
 216                                 exit(1);
 217                         }
 218                 }
 219                 /* race condition here: dir_changed could be set before we
 220                  * enter the poll, and we'd never notice if it weren't for the
 221                  * timeout. */
 222                 ret = poll(pollarray, pollsize, POLL_MILLISECS);
 223                 if (ret < 0) {
 224                         if (errno != EINTR)
 225                                 printerr(0,
 226                                          "WARNING: error return from poll\n");
 227                 } else if (ret == 0) {
 228                         /* timeout */
 229                 } else { /* ret > 0 */
 230                         scan_poll_results(ret);
 231                 }
 232         }
 233         topdirs_free_list();
 234
 235         return;
 236 }