utils/nfsdcld/nfsdcld.c

   1 /*
   2  * nfsdcld.c -- NFSv4 client name tracking daemon
   3  *
   4  * Copyright (C) 2011  Red Hat, Jeff Layton <jlayton@redhat.com>
   5  *
   6  * This program is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU General Public License
   8  * as published by the Free Software Foundation; either version 2
   9  * of the License, or (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin Street, Fifth Floor,
  19  * Boston, MA 02110-1301, USA.
  20  */
  21
  22 #ifdef HAVE_CONFIG_H
  23 #include "config.h"
  24 #endif /* HAVE_CONFIG_H */
  25
  26 #include <errno.h>
  27 #include <event.h>
  28 #include <stdbool.h>
  29 #include <getopt.h>
  30 #include <string.h>
  31 #include <sys/stat.h>
  32 #include <sys/types.h>
  33 #include <fcntl.h>
  34 #include <unistd.h>
  35
  36 #include "xlog.h"
  37 #include "nfslib.h"
  38 #include "cld.h"
  39
  40 #ifndef PIPEFS_DIR
  41 #define PIPEFS_DIR NFS_STATEDIR "/rpc_pipefs"
  42 #endif
  43
  44 #define DEFAULT_CLD_PATH        PIPEFS_DIR "/nfsd/cld"
  45
  46 #define UPCALL_VERSION          1
  47
  48 /* private data structures */
  49 struct cld_client {
  50         int                     cl_fd;
  51         struct event            cl_event;
  52         struct cld_msg  cl_msg;
  53 };
  54
  55 /* global variables */
  56 static char *pipepath = DEFAULT_CLD_PATH;
  57
  58 static struct option longopts[] =
  59 {
  60         { "help", 0, NULL, 'h' },
  61         { "foreground", 0, NULL, 'F' },
  62         { "debug", 0, NULL, 'd' },
  63         { "pipe", 1, NULL, 'p' },
  64         { NULL, 0, 0, 0 },
  65 };
  66
  67 /* forward declarations */
  68 static void cldcb(int UNUSED(fd), short which, void *data);
  69
  70 static void
  71 usage(char *progname)
  72 {
  73         printf("Usage: %s [ -hFd ] [ -p pipe ]\n", progname);
  74 }
  75
  76 static int
  77 cld_pipe_open(struct cld_client *clnt)
  78 {
  79         int fd;
  80
  81         xlog(D_GENERAL, "%s: opening upcall pipe %s", __func__, pipepath);
  82         fd = open(pipepath, O_RDWR, 0);
  83         if (fd < 0) {
  84                 xlog(L_ERROR, "%s: open of %s failed: %m", __func__, pipepath);
  85                 return -errno;
  86         }
  87
  88         if (clnt->cl_event.ev_flags & EVLIST_INIT)
  89                 event_del(&clnt->cl_event);
  90         if (clnt->cl_fd >= 0)
  91                 close(clnt->cl_fd);
  92
  93         clnt->cl_fd = fd;
  94         event_set(&clnt->cl_event, clnt->cl_fd, EV_READ, cldcb, clnt);
  95         /* event_add is done by the caller */
  96         return 0;
  97 }
  98
  99 static int
 100 cld_pipe_init(struct cld_client *clnt)
 101 {
 102         int ret;
 103
 104         clnt->cl_fd = -1;
 105         ret = cld_pipe_open(clnt);
 106         if (ret)
 107                 return ret;
 108
 109         event_add(&clnt->cl_event, NULL);
 110         return 0;
 111 }
 112
 113 static void
 114 cld_not_implemented(struct cld_client *clnt)
 115 {
 116         int ret;
 117         ssize_t bsize, wsize;
 118         struct cld_msg *cmsg = &clnt->cl_msg;
 119
 120         xlog(D_GENERAL, "%s: downcalling with not implemented error", __func__);
 121
 122         /* set up reply */
 123         cmsg->cm_status = -EOPNOTSUPP;
 124
 125         bsize = sizeof(*cmsg);
 126
 127         wsize = atomicio((void *)write, clnt->cl_fd, cmsg, bsize);
 128         if (wsize != bsize)
 129                 xlog(L_ERROR, "%s: problem writing to cld pipe (%ld): %m",
 130                          __func__, wsize);
 131
 132         /* reopen pipe, just to be sure */
 133         ret = cld_pipe_open(clnt);
 134         if (ret) {
 135                 xlog(L_FATAL, "%s: unable to reopen pipe: %d", __func__, ret);
 136                 exit(ret);
 137         }
 138 }
 139
 140 static void
 141 cld_create(struct cld_client *clnt)
 142 {
 143         int ret;
 144         ssize_t bsize, wsize;
 145         struct cld_msg *cmsg = &clnt->cl_msg;
 146
 147         xlog(D_GENERAL, "%s: create client record", __func__);
 148
 149         /* FIXME: create client record on storage here */
 150
 151         /* set up reply */
 152         cmsg->cm_status = 0;
 153
 154         bsize = sizeof(*cmsg);
 155
 156         wsize = atomicio((void *)write, clnt->cl_fd, cmsg, bsize);
 157         if (wsize != bsize) {
 158                 xlog(L_ERROR, "%s: problem writing to cld pipe (%ld): %m",
 159                          __func__, wsize);
 160                 ret = cld_pipe_open(clnt);
 161                 if (ret) {
 162                         xlog(L_FATAL, "%s: unable to reopen pipe: %d",
 163                                         __func__, ret);
 164                         exit(ret);
 165                 }
 166         }
 167 }
 168
 169 static void
 170 cldcb(int UNUSED(fd), short which, void *data)
 171 {
 172         ssize_t len;
 173         struct cld_client *clnt = data;
 174         struct cld_msg *cmsg = &clnt->cl_msg;
 175
 176         if (which != EV_READ)
 177                 goto out;
 178
 179         len = atomicio(read, clnt->cl_fd, cmsg, sizeof(*cmsg));
 180         if (len <= 0) {
 181                 xlog(L_ERROR, "%s: pipe read failed: %m", __func__);
 182                 cld_pipe_open(clnt);
 183                 goto out;
 184         }
 185
 186         if (cmsg->cm_vers != UPCALL_VERSION) {
 187                 xlog(L_ERROR, "%s: unsupported upcall version: %hu",
 188                                 cmsg->cm_vers);
 189                 cld_pipe_open(clnt);
 190                 goto out;
 191         }
 192
 193         switch(cmsg->cm_cmd) {
 194         case Cld_Create:
 195                 cld_create(clnt);
 196                 break;
 197         default:
 198                 xlog(L_WARNING, "%s: command %u is not yet implemented",
 199                                 __func__, cmsg->cm_cmd);
 200                 cld_not_implemented(clnt);
 201         }
 202 out:
 203         event_add(&clnt->cl_event, NULL);
 204 }
 205
 206 int
 207 main(int argc, char **argv)
 208 {
 209         char arg;
 210         int rc = 0;
 211         bool foreground = false;
 212         char *progname;
 213         struct cld_client clnt;
 214
 215         memset(&clnt, 0, sizeof(clnt));
 216
 217         progname = strdup(basename(argv[0]));
 218         if (!progname) {
 219                 fprintf(stderr, "%s: unable to allocate memory.\n", argv[0]);
 220                 return 1;
 221         }
 222
 223         event_init();
 224         xlog_syslog(0);
 225         xlog_stderr(1);
 226
 227         /* process command-line options */
 228         while ((arg = getopt_long(argc, argv, "hdFp:", longopts,
 229                                   NULL)) != EOF) {
 230                 switch (arg) {
 231                 case 'd':
 232                         xlog_config(D_ALL, 1);
 233                         break;
 234                 case 'F':
 235                         foreground = true;
 236                         break;
 237                 case 'p':
 238                         pipepath = optarg;
 239                         break;
 240                 default:
 241                         usage(progname);
 242                         return 0;
 243                 }
 244         }
 245
 246
 247         xlog_open(progname);
 248         if (!foreground) {
 249                 xlog_syslog(1);
 250                 xlog_stderr(0);
 251                 rc = daemon(0, 0);
 252                 if (rc) {
 253                         xlog(L_ERROR, "Unable to daemonize: %m");
 254                         goto out;
 255                 }
 256         }
 257
 258         /* set up storage db */
 259
 260         /* set up event handler */
 261         rc = cld_pipe_init(&clnt);
 262         if (rc)
 263                 goto out;
 264
 265         xlog(D_GENERAL, "%s: Starting event dispatch handler.", __func__);
 266         rc = event_dispatch();
 267         if (rc < 0)
 268                 xlog(L_ERROR, "%s: event_dispatch failed: %m", __func__);
 269
 270         close(clnt.cl_fd);
 271 out:
 272         free(progname);
 273         return rc;
 274 }