utils/mountd/cache.c

   1
   2 /*
   3  * Handle communication with knfsd internal cache
   4  *
   5  * We open /proc/net/rpc/{auth.unix.ip,nfsd.export,nfsd.fh}/channel
   6  * and listen for requests (using my_svc_run)
   7  *
   8  */
   9
  10 #ifdef HAVE_CONFIG_H
  11 #include <config.h>
  12 #endif
  13
  14 #include <sys/types.h>
  15 #include <sys/select.h>
  16 #include <sys/stat.h>
  17 #include <time.h>
  18 #include <netinet/in.h>
  19 #include <arpa/inet.h>
  20 #include <unistd.h>
  21 #include <fcntl.h>
  22 #include <errno.h>
  23 #include <ctype.h>
  24 #include "misc.h"
  25 #include "nfslib.h"
  26 #include "exportfs.h"
  27 #include "mountd.h"
  28 #include "xmalloc.h"
  29
  30 /*
  31  * Support routines for text-based upcalls.
  32  * Fields are separated by spaces.
  33  * Fields are either mangled to quote space tab newline slosh with slosh
  34  * or a hexified with a leading \x
  35  * Record is terminated with newline.
  36  *
  37  */
  38 void cache_export_ent(char *domain, struct exportent *exp);
  39
  40
  41 char *lbuf  = NULL;
  42 int lbuflen = 0;
  43
  44 void auth_unix_ip(FILE *f)
  45 {
  46         /* requests are
  47          *  class IP-ADDR
  48          * Ignore if class != "nfsd"
  49          * Otherwise find domainname and write back:
  50          *
  51          *  "nfsd" IP-ADDR expiry domainname
  52          */
  53         char *cp;
  54         char class[20];
  55         char ipaddr[20];
  56         char *client;
  57         struct in_addr addr;
  58         if (readline(fileno(f), &lbuf, &lbuflen) != 1)
  59                 return;
  60
  61         cp = lbuf;
  62
  63         if (qword_get(&cp, class, 20) <= 0 ||
  64             strcmp(class, "nfsd") != 0)
  65                 return;
  66
  67         if (qword_get(&cp, ipaddr, 20) <= 0)
  68                 return;
  69
  70         if (inet_aton(ipaddr, &addr)==0)
  71                 return;
  72
  73         auth_reload();
  74
  75         /* addr is a valid, interesting address, find the domain name... */
  76         client = client_compose(addr);
  77
  78
  79         qword_print(f, "nfsd");
  80         qword_print(f, ipaddr);
  81         qword_printint(f, time(0)+30*60);
  82         if (client)
  83                 qword_print(f, *client?client:"DEFAULT");
  84         qword_eol(f);
  85
  86         if (client && strcmp(ipaddr, client))
  87                 mountlist_add(ipaddr, *client?client:"DEFAULT");
  88
  89         if (client) free(client);
  90
  91 }
  92
  93 void nfsd_fh(FILE *f)
  94 {
  95         /* request are:
  96          *  domain fsidtype fsid
  97          * interpret fsid, find export point and options, and write:
  98          *  domain fsidtype fsid expiry path
  99          */
 100         char *cp;
 101         char *dom;
 102         int fsidtype;
 103         int fsidlen;
 104         unsigned int dev, major=0, minor=0;
 105         unsigned int inode=0;
 106         unsigned int fsidnum=0;
 107         char fsid[32];
 108         struct exportent *found = NULL;
 109         nfs_export *exp;
 110         int i;
 111         int dev_missing = 0;
 112
 113         if (readline(fileno(f), &lbuf, &lbuflen) != 1)
 114                 return;
 115
 116         cp = lbuf;
 117
 118         dom = malloc(strlen(cp));
 119         if (dom == NULL)
 120                 return;
 121         if (qword_get(&cp, dom, strlen(cp)) <= 0)
 122                 goto out;
 123         if (qword_get_int(&cp, &fsidtype) != 0)
 124                 goto out;
 125         if (fsidtype < 0 || fsidtype > 3)
 126                 goto out; /* unknown type */
 127         if ((fsidlen = qword_get(&cp, fsid, 32)) <= 0)
 128                 goto out;
 129         switch(fsidtype) {
 130         case 0: /* 4 bytes: 2 major, 2 minor, 4 inode */
 131                 if (fsidlen != 8)
 132                         goto out;
 133                 memcpy(&dev, fsid, 4);
 134                 memcpy(&inode, fsid+4, 4);
 135                 major = ntohl(dev)>>16;
 136                 minor = ntohl(dev) & 0xFFFF;
 137                 break;
 138
 139         case 1: /* 4 bytes - fsid */
 140                 if (fsidlen != 4)
 141                         goto out;
 142                 memcpy(&fsidnum, fsid, 4);
 143                 break;
 144
 145         case 2: /* 12 bytes: 4 major, 4 minor, 4 inode
 146                  * This format is never actually used but was
 147                  * an historical accident
 148                  */
 149                 if (fsidlen != 12)
 150                         goto out;
 151                 memcpy(&dev, fsid, 4); major = ntohl(dev);
 152                 memcpy(&dev, fsid+4, 4); minor = ntohl(dev);
 153                 memcpy(&inode, fsid+8, 4);
 154                 break;
 155
 156         case 3: /* 8 bytes: 4 byte packed device number, 4 inode */
 157                 /* This is *host* endian, not net-byte-order, because
 158                  * no-one outside this host has any business interpreting it
 159                  */
 160                 if (fsidlen != 8)
 161                         goto out;
 162                 memcpy(&dev, fsid, 4);
 163                 memcpy(&inode, fsid+4, 4);
 164                 major = (dev & 0xfff00) >> 8;
 165                 minor = (dev & 0xff) | ((dev >> 12) & 0xfff00);
 166                 break;
 167
 168         }
 169
 170         auth_reload();
 171
 172         /* Now determine export point for this fsid/domain */
 173         for (i=0 ; i < MCL_MAXTYPES; i++) {
 174                 for (exp = exportlist[i]; exp; exp = exp->m_next) {
 175                         struct stat stb;
 176
 177                         if (!client_member(dom, exp->m_client->m_hostname))
 178                                 continue;
 179                         if (exp->m_export.e_mountpoint &&
 180                             !is_mountpoint(exp->m_export.e_mountpoint[0]?
 181                                            exp->m_export.e_mountpoint:
 182                                            exp->m_export.e_path))
 183                                 dev_missing ++;
 184                         if (stat(exp->m_export.e_path, &stb) != 0)
 185                                 continue;
 186                         if (fsidtype == 1 &&
 187                             ((exp->m_export.e_flags & NFSEXP_FSID) == 0 ||
 188                              exp->m_export.e_fsid != fsidnum))
 189                                 continue;
 190                         if (fsidtype != 1) {
 191                                 if (stb.st_ino != inode)
 192                                         continue;
 193                                 if (major != major(stb.st_dev) ||
 194                                     minor != minor(stb.st_dev))
 195                                         continue;
 196                         }
 197                         /* It's a match !! */
 198                         if (!found)
 199                                 found = &exp->m_export;
 200                         else if (strcmp(found->e_path, exp->m_export.e_path)!= 0)
 201                         {
 202                                 xlog(L_WARNING, "%s and %s have same filehandle for %s, using first",
 203                                      found->e_path, exp->m_export.e_path, dom);
 204                         }
 205                 }
 206         }
 207         if (found &&
 208             found->e_mountpoint &&
 209             !is_mountpoint(found->e_mountpoint[0]?
 210                            found->e_mountpoint:
 211                            found->e_path)) {
 212                 /* Cannot export this yet
 213                  * should log a warning, but need to rate limit
 214                    xlog(L_WARNING, "%s not exported as %d not a mountpoint",
 215                    found->e_path, found->e_mountpoint);
 216                  */
 217                 /* FIXME we need to make sure we re-visit this later */
 218                 goto out;
 219         }
 220         if (!found && dev_missing) {
 221                 /* The missing dev could be what we want, so just be
 222                  * quite rather than returning stale yet
 223                  */
 224                 goto out;
 225         }
 226
 227         if (found)
 228                 cache_export_ent(dom, found);
 229
 230         qword_print(f, dom);
 231         qword_printint(f, fsidtype);
 232         qword_printhex(f, fsid, fsidlen);
 233         qword_printint(f, time(0)+30*60);
 234         if (found)
 235                 qword_print(f, found->e_path);
 236         qword_eol(f);
 237  out:
 238         free(dom);
 239         return;
 240 }
 241
 242 void nfsd_export(FILE *f)
 243 {
 244         /* requests are:
 245          *  domain path
 246          * determine export options and return:
 247          *  domain path expiry flags anonuid anongid fsid
 248          */
 249
 250         char *cp;
 251         int i;
 252         char *dom, *path;
 253         nfs_export *exp, *found = NULL;
 254
 255
 256         if (readline(fileno(f), &lbuf, &lbuflen) != 1)
 257                 return;
 258
 259         cp = lbuf;
 260         dom = malloc(strlen(cp));
 261         path = malloc(strlen(cp));
 262
 263         if (!dom || !path)
 264                 goto out;
 265
 266         if (qword_get(&cp, dom, strlen(lbuf)) <= 0)
 267                 goto out;
 268         if (qword_get(&cp, path, strlen(lbuf)) <= 0)
 269                 goto out;
 270
 271         auth_reload();
 272
 273         /* now find flags for this export point in this domain */
 274         for (i=0 ; i < MCL_MAXTYPES; i++) {
 275                 for (exp = exportlist[i]; exp; exp = exp->m_next) {
 276                         if (!client_member(dom, exp->m_client->m_hostname))
 277                                 continue;
 278                         if (strcmp(path, exp->m_export.e_path))
 279                                 continue;
 280                         if (!found)
 281                                 found = exp;
 282                         else {
 283                                 xlog(L_WARNING, "%s exported to both %s and %s in %s",
 284                                      path, exp->m_client->m_hostname, found->m_client->m_hostname,
 285                                      dom);
 286                         }
 287                 }
 288         }
 289
 290         qword_print(f, dom);
 291         qword_print(f, path);
 292         qword_printint(f, time(0)+30*60);
 293         if (found) {
 294                 qword_printint(f, found->m_export.e_flags);
 295                 qword_printint(f, found->m_export.e_anonuid);
 296                 qword_printint(f, found->m_export.e_anongid);
 297                 qword_printint(f, found->m_export.e_fsid);
 298                 mountlist_add(dom, path);
 299         }
 300         qword_eol(f);
 301  out:
 302         if (dom) free(dom);
 303         if (path) free(path);
 304 }
 305
 306
 307 struct {
 308         char *cache_name;
 309         void (*cache_handle)(FILE *f);
 310         FILE *f;
 311 } cachelist[] = {
 312         { "auth.unix.ip", auth_unix_ip},
 313         { "nfsd.export", nfsd_export},
 314         { "nfsd.fh", nfsd_fh},
 315         { NULL, NULL }
 316 };
 317
 318 void cache_open(void)
 319 {
 320         int i;
 321         for (i=0; cachelist[i].cache_name; i++ ){
 322                 char path[100];
 323                 sprintf(path, "/proc/net/rpc/%s/channel", cachelist[i].cache_name);
 324                 cachelist[i].f = fopen(path, "r+");
 325         }
 326 }
 327
 328 void cache_set_fds(fd_set *fdset)
 329 {
 330         int i;
 331         for (i=0; cachelist[i].cache_name; i++) {
 332                 if (cachelist[i].f)
 333                         FD_SET(fileno(cachelist[i].f), fdset);
 334         }
 335 }
 336
 337 int cache_process_req(fd_set *readfds)
 338 {
 339         int i;
 340         int cnt = 0;
 341         for (i=0; cachelist[i].cache_name; i++) {
 342                 if (cachelist[i].f != NULL &&
 343                     FD_ISSET(fileno(cachelist[i].f), readfds)) {
 344                         cnt++;
 345                         cachelist[i].cache_handle(cachelist[i].f);
 346                         FD_CLR(fileno(cachelist[i].f), readfds);
 347                 }
 348         }
 349         return cnt;
 350 }
 351
 352
 353 /*
 354  * Give IP->domain and domain+path->options to kernel
 355  * % echo nfsd $IP  $[now+30*60] $domain > /proc/net/rpc/auth.unix.ip/channel
 356  * % echo $domain $path $[now+30*60] $options $anonuid $anongid $fsid > /proc/net/rpc/nfsd.export/channel
 357  */
 358
 359 void cache_export_ent(char *domain, struct exportent *exp)
 360 {
 361
 362         FILE *f = fopen("/proc/net/rpc/nfsd.export/channel", "w");
 363         if (!f)
 364                 return;
 365
 366         qword_print(f, domain);
 367         qword_print(f, exp->e_path);
 368         qword_printint(f, time(0)+30*60);
 369         qword_printint(f, exp->e_flags);
 370         qword_printint(f, exp->e_anonuid);
 371         qword_printint(f, exp->e_anongid);
 372         qword_printint(f, exp->e_fsid);
 373         qword_eol(f);
 374
 375         fclose(f);
 376
 377         mountlist_add(domain, exp->e_path);
 378 }
 379
 380 void cache_export(nfs_export *exp)
 381 {
 382         FILE *f;
 383
 384         f = fopen("/proc/net/rpc/auth.unix.ip/channel", "w");
 385         if (!f)
 386                 return;
 387
 388         qword_print(f, "nfsd");
 389         qword_print(f, inet_ntoa(exp->m_client->m_addrlist[0]));
 390         qword_printint(f, time(0)+30*60);
 391         qword_print(f, exp->m_client->m_hostname);
 392         qword_eol(f);
 393
 394         fclose(f);
 395
 396         if (strcmp(inet_ntoa(exp->m_client->m_addrlist[0]), exp->m_client->m_hostname))
 397                 mountlist_add(inet_ntoa(exp->m_client->m_addrlist[0]), exp->m_client->m_hostname);
 398
 399         cache_export_ent(exp->m_client->m_hostname, &exp->m_export);
 400 }
 401
 402 /* Get a filehandle.
 403  * {
 404  *   echo $domain $path $length
 405  *   read filehandle <&0
 406  * } <> /proc/fs/nfsd/filehandle
 407  */
 408 struct nfs_fh_len *
 409 cache_get_filehandle(nfs_export *exp, int len, char *p)
 410 {
 411         FILE *f = fopen("/proc/fs/nfsd/filehandle", "r+");
 412         char buf[200];
 413         char *bp = buf;
 414         int failed;
 415         static struct nfs_fh_len fh;
 416
 417         if (!f)
 418                 f = fopen("/proc/fs/nfs/filehandle", "r+");
 419         if (!f)
 420                 return NULL;
 421
 422         qword_print(f, exp->m_client->m_hostname);
 423         qword_print(f, p);
 424         qword_printint(f, len);
 425         qword_eol(f);
 426
 427         failed = (fgets(buf, sizeof(buf), f) == NULL);
 428         fclose(f);
 429         if (failed)
 430                 return NULL;
 431         memset(fh.fh_handle, 0, sizeof(fh.fh_handle));
 432         fh.fh_size = qword_get(&bp, (char *)fh.fh_handle, NFS3_FHSIZE);
 433         return &fh;
 434 }
 435