net/sunrpc/svcauth_unix.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 #include <linux/types.h>
   3 #include <linux/sched.h>
   4 #include <linux/module.h>
   5 #include <linux/sunrpc/types.h>
   6 #include <linux/sunrpc/xdr.h>
   7 #include <linux/sunrpc/svcsock.h>
   8 #include <linux/sunrpc/svcauth.h>
   9 #include <linux/sunrpc/gss_api.h>
  10 #include <linux/sunrpc/addr.h>
  11 #include <linux/err.h>
  12 #include <linux/seq_file.h>
  13 #include <linux/hash.h>
  14 #include <linux/string.h>
  15 #include <linux/slab.h>
  16 #include <net/sock.h>
  17 #include <net/ipv6.h>
  18 #include <linux/kernel.h>
  19 #include <linux/user_namespace.h>
  20 #define RPCDBG_FACILITY RPCDBG_AUTH
  21
  22
  23 #include "netns.h"
  24
  25 /*
  26  * AUTHUNIX and AUTHNULL credentials are both handled here.
  27  * AUTHNULL is treated just like AUTHUNIX except that the uid/gid
  28  * are always nobody (-2).  i.e. we do the same IP address checks for
  29  * AUTHNULL as for AUTHUNIX, and that is done here.
  30  */
  31
  32
  33 struct unix_domain {
  34         struct auth_domain      h;
  35         /* other stuff later */
  36 };
  37
  38 extern struct auth_ops svcauth_null;
  39 extern struct auth_ops svcauth_unix;
  40
  41 static void svcauth_unix_domain_release_rcu(struct rcu_head *head)
  42 {
  43         struct auth_domain *dom = container_of(head, struct auth_domain, rcu_head);
  44         struct unix_domain *ud = container_of(dom, struct unix_domain, h);
  45
  46         kfree(dom->name);
  47         kfree(ud);
  48 }
  49
  50 static void svcauth_unix_domain_release(struct auth_domain *dom)
  51 {
  52         call_rcu(&dom->rcu_head, svcauth_unix_domain_release_rcu);
  53 }
  54
  55 struct auth_domain *unix_domain_find(char *name)
  56 {
  57         struct auth_domain *rv;
  58         struct unix_domain *new = NULL;
  59
  60         rv = auth_domain_find(name);
  61         while(1) {
  62                 if (rv) {
  63                         if (new && rv != &new->h)
  64                                 svcauth_unix_domain_release(&new->h);
  65
  66                         if (rv->flavour != &svcauth_unix) {
  67                                 auth_domain_put(rv);
  68                                 return NULL;
  69                         }
  70                         return rv;
  71                 }
  72
  73                 new = kmalloc(sizeof(*new), GFP_KERNEL);
  74                 if (new == NULL)
  75                         return NULL;
  76                 kref_init(&new->h.ref);
  77                 new->h.name = kstrdup(name, GFP_KERNEL);
  78                 if (new->h.name == NULL) {
  79                         kfree(new);
  80                         return NULL;
  81                 }
  82                 new->h.flavour = &svcauth_unix;
  83                 rv = auth_domain_lookup(name, &new->h);
  84         }
  85 }
  86 EXPORT_SYMBOL_GPL(unix_domain_find);
  87
  88
  89 /**************************************************
  90  * cache for IP address to unix_domain
  91  * as needed by AUTH_UNIX
  92  */
  93 #define IP_HASHBITS     8
  94 #define IP_HASHMAX      (1<<IP_HASHBITS)
  95
  96 struct ip_map {
  97         struct cache_head       h;
  98         char                    m_class[8]; /* e.g. "nfsd" */
  99         struct in6_addr         m_addr;
 100         struct unix_domain      *m_client;
 101         struct rcu_head         m_rcu;
 102 };
 103
 104 static void ip_map_put(struct kref *kref)
 105 {
 106         struct cache_head *item = container_of(kref, struct cache_head, ref);
 107         struct ip_map *im = container_of(item, struct ip_map,h);
 108
 109         if (test_bit(CACHE_VALID, &item->flags) &&
 110             !test_bit(CACHE_NEGATIVE, &item->flags))
 111                 auth_domain_put(&im->m_client->h);
 112         kfree_rcu(im, m_rcu);
 113 }
 114
 115 static inline int hash_ip6(const struct in6_addr *ip)
 116 {
 117         return hash_32(ipv6_addr_hash(ip), IP_HASHBITS);
 118 }
 119 static int ip_map_match(struct cache_head *corig, struct cache_head *cnew)
 120 {
 121         struct ip_map *orig = container_of(corig, struct ip_map, h);
 122         struct ip_map *new = container_of(cnew, struct ip_map, h);
 123         return strcmp(orig->m_class, new->m_class) == 0 &&
 124                ipv6_addr_equal(&orig->m_addr, &new->m_addr);
 125 }
 126 static void ip_map_init(struct cache_head *cnew, struct cache_head *citem)
 127 {
 128         struct ip_map *new = container_of(cnew, struct ip_map, h);
 129         struct ip_map *item = container_of(citem, struct ip_map, h);
 130
 131         strcpy(new->m_class, item->m_class);
 132         new->m_addr = item->m_addr;
 133 }
 134 static void update(struct cache_head *cnew, struct cache_head *citem)
 135 {
 136         struct ip_map *new = container_of(cnew, struct ip_map, h);
 137         struct ip_map *item = container_of(citem, struct ip_map, h);
 138
 139         kref_get(&item->m_client->h.ref);
 140         new->m_client = item->m_client;
 141 }
 142 static struct cache_head *ip_map_alloc(void)
 143 {
 144         struct ip_map *i = kmalloc(sizeof(*i), GFP_KERNEL);
 145         if (i)
 146                 return &i->h;
 147         else
 148                 return NULL;
 149 }
 150
 151 static void ip_map_request(struct cache_detail *cd,
 152                                   struct cache_head *h,
 153                                   char **bpp, int *blen)
 154 {
 155         char text_addr[40];
 156         struct ip_map *im = container_of(h, struct ip_map, h);
 157
 158         if (ipv6_addr_v4mapped(&(im->m_addr))) {
 159                 snprintf(text_addr, 20, "%pI4", &im->m_addr.s6_addr32[3]);
 160         } else {
 161                 snprintf(text_addr, 40, "%pI6", &im->m_addr);
 162         }
 163         qword_add(bpp, blen, im->m_class);
 164         qword_add(bpp, blen, text_addr);
 165         (*bpp)[-1] = '\n';
 166 }
 167
 168 static struct ip_map *__ip_map_lookup(struct cache_detail *cd, char *class, struct in6_addr *addr);
 169 static int __ip_map_update(struct cache_detail *cd, struct ip_map *ipm, struct unix_domain *udom, time_t expiry);
 170
 171 static int ip_map_parse(struct cache_detail *cd,
 172                           char *mesg, int mlen)
 173 {
 174         /* class ipaddress [domainname] */
 175         /* should be safe just to use the start of the input buffer
 176          * for scratch: */
 177         char *buf = mesg;
 178         int len;
 179         char class[8];
 180         union {
 181                 struct sockaddr         sa;
 182                 struct sockaddr_in      s4;
 183                 struct sockaddr_in6     s6;
 184         } address;
 185         struct sockaddr_in6 sin6;
 186         int err;
 187
 188         struct ip_map *ipmp;
 189         struct auth_domain *dom;
 190         time_t expiry;
 191
 192         if (mesg[mlen-1] != '\n')
 193                 return -EINVAL;
 194         mesg[mlen-1] = 0;
 195
 196         /* class */
 197         len = qword_get(&mesg, class, sizeof(class));
 198         if (len <= 0) return -EINVAL;
 199
 200         /* ip address */
 201         len = qword_get(&mesg, buf, mlen);
 202         if (len <= 0) return -EINVAL;
 203
 204         if (rpc_pton(cd->net, buf, len, &address.sa, sizeof(address)) == 0)
 205                 return -EINVAL;
 206         switch (address.sa.sa_family) {
 207         case AF_INET:
 208                 /* Form a mapped IPv4 address in sin6 */
 209                 sin6.sin6_family = AF_INET6;
 210                 ipv6_addr_set_v4mapped(address.s4.sin_addr.s_addr,
 211                                 &sin6.sin6_addr);
 212                 break;
 213 #if IS_ENABLED(CONFIG_IPV6)
 214         case AF_INET6:
 215                 memcpy(&sin6, &address.s6, sizeof(sin6));
 216                 break;
 217 #endif
 218         default:
 219                 return -EINVAL;
 220         }
 221
 222         expiry = get_expiry(&mesg);
 223         if (expiry ==0)
 224                 return -EINVAL;
 225
 226         /* domainname, or empty for NEGATIVE */
 227         len = qword_get(&mesg, buf, mlen);
 228         if (len < 0) return -EINVAL;
 229
 230         if (len) {
 231                 dom = unix_domain_find(buf);
 232                 if (dom == NULL)
 233                         return -ENOENT;
 234         } else
 235                 dom = NULL;
 236
 237         /* IPv6 scope IDs are ignored for now */
 238         ipmp = __ip_map_lookup(cd, class, &sin6.sin6_addr);
 239         if (ipmp) {
 240                 err = __ip_map_update(cd, ipmp,
 241                              container_of(dom, struct unix_domain, h),
 242                              expiry);
 243         } else
 244                 err = -ENOMEM;
 245
 246         if (dom)
 247                 auth_domain_put(dom);
 248
 249         cache_flush();
 250         return err;
 251 }
 252
 253 static int ip_map_show(struct seq_file *m,
 254                        struct cache_detail *cd,
 255                        struct cache_head *h)
 256 {
 257         struct ip_map *im;
 258         struct in6_addr addr;
 259         char *dom = "-no-domain-";
 260
 261         if (h == NULL) {
 262                 seq_puts(m, "#class IP domain\n");
 263                 return 0;
 264         }
 265         im = container_of(h, struct ip_map, h);
 266         /* class addr domain */
 267         addr = im->m_addr;
 268
 269         if (test_bit(CACHE_VALID, &h->flags) &&
 270             !test_bit(CACHE_NEGATIVE, &h->flags))
 271                 dom = im->m_client->h.name;
 272
 273         if (ipv6_addr_v4mapped(&addr)) {
 274                 seq_printf(m, "%s %pI4 %s\n",
 275                         im->m_class, &addr.s6_addr32[3], dom);
 276         } else {
 277                 seq_printf(m, "%s %pI6 %s\n", im->m_class, &addr, dom);
 278         }
 279         return 0;
 280 }
 281
 282
 283 static struct ip_map *__ip_map_lookup(struct cache_detail *cd, char *class,
 284                 struct in6_addr *addr)
 285 {
 286         struct ip_map ip;
 287         struct cache_head *ch;
 288
 289         strcpy(ip.m_class, class);
 290         ip.m_addr = *addr;
 291         ch = sunrpc_cache_lookup_rcu(cd, &ip.h,
 292                                      hash_str(class, IP_HASHBITS) ^
 293                                      hash_ip6(addr));
 294
 295         if (ch)
 296                 return container_of(ch, struct ip_map, h);
 297         else
 298                 return NULL;
 299 }
 300
 301 static inline struct ip_map *ip_map_lookup(struct net *net, char *class,
 302                 struct in6_addr *addr)
 303 {
 304         struct sunrpc_net *sn;
 305
 306         sn = net_generic(net, sunrpc_net_id);
 307         return __ip_map_lookup(sn->ip_map_cache, class, addr);
 308 }
 309
 310 static int __ip_map_update(struct cache_detail *cd, struct ip_map *ipm,
 311                 struct unix_domain *udom, time_t expiry)
 312 {
 313         struct ip_map ip;
 314         struct cache_head *ch;
 315
 316         ip.m_client = udom;
 317         ip.h.flags = 0;
 318         if (!udom)
 319                 set_bit(CACHE_NEGATIVE, &ip.h.flags);
 320         ip.h.expiry_time = expiry;
 321         ch = sunrpc_cache_update(cd, &ip.h, &ipm->h,
 322                                  hash_str(ipm->m_class, IP_HASHBITS) ^
 323                                  hash_ip6(&ipm->m_addr));
 324         if (!ch)
 325                 return -ENOMEM;
 326         cache_put(ch, cd);
 327         return 0;
 328 }
 329
 330 static inline int ip_map_update(struct net *net, struct ip_map *ipm,
 331                 struct unix_domain *udom, time_t expiry)
 332 {
 333         struct sunrpc_net *sn;
 334
 335         sn = net_generic(net, sunrpc_net_id);
 336         return __ip_map_update(sn->ip_map_cache, ipm, udom, expiry);
 337 }
 338
 339 void svcauth_unix_purge(struct net *net)
 340 {
 341         struct sunrpc_net *sn;
 342
 343         sn = net_generic(net, sunrpc_net_id);
 344         cache_purge(sn->ip_map_cache);
 345 }
 346 EXPORT_SYMBOL_GPL(svcauth_unix_purge);
 347
 348 static inline struct ip_map *
 349 ip_map_cached_get(struct svc_xprt *xprt)
 350 {
 351         struct ip_map *ipm = NULL;
 352         struct sunrpc_net *sn;
 353
 354         if (test_bit(XPT_CACHE_AUTH, &xprt->xpt_flags)) {
 355                 spin_lock(&xprt->xpt_lock);
 356                 ipm = xprt->xpt_auth_cache;
 357                 if (ipm != NULL) {
 358                         sn = net_generic(xprt->xpt_net, sunrpc_net_id);
 359                         if (cache_is_expired(sn->ip_map_cache, &ipm->h)) {
 360                                 /*
 361                                  * The entry has been invalidated since it was
 362                                  * remembered, e.g. by a second mount from the
 363                                  * same IP address.
 364                                  */
 365                                 xprt->xpt_auth_cache = NULL;
 366                                 spin_unlock(&xprt->xpt_lock);
 367                                 cache_put(&ipm->h, sn->ip_map_cache);
 368                                 return NULL;
 369                         }
 370                         cache_get(&ipm->h);
 371                 }
 372                 spin_unlock(&xprt->xpt_lock);
 373         }
 374         return ipm;
 375 }
 376
 377 static inline void
 378 ip_map_cached_put(struct svc_xprt *xprt, struct ip_map *ipm)
 379 {
 380         if (test_bit(XPT_CACHE_AUTH, &xprt->xpt_flags)) {
 381                 spin_lock(&xprt->xpt_lock);
 382                 if (xprt->xpt_auth_cache == NULL) {
 383                         /* newly cached, keep the reference */
 384                         xprt->xpt_auth_cache = ipm;
 385                         ipm = NULL;
 386                 }
 387                 spin_unlock(&xprt->xpt_lock);
 388         }
 389         if (ipm) {
 390                 struct sunrpc_net *sn;
 391
 392                 sn = net_generic(xprt->xpt_net, sunrpc_net_id);
 393                 cache_put(&ipm->h, sn->ip_map_cache);
 394         }
 395 }
 396
 397 void
 398 svcauth_unix_info_release(struct svc_xprt *xpt)
 399 {
 400         struct ip_map *ipm;
 401
 402         ipm = xpt->xpt_auth_cache;
 403         if (ipm != NULL) {
 404                 struct sunrpc_net *sn;
 405
 406                 sn = net_generic(xpt->xpt_net, sunrpc_net_id);
 407                 cache_put(&ipm->h, sn->ip_map_cache);
 408         }
 409 }
 410
 411 /****************************************************************************
 412  * auth.unix.gid cache
 413  * simple cache to map a UID to a list of GIDs
 414  * because AUTH_UNIX aka AUTH_SYS has a max of UNX_NGROUPS
 415  */
 416 #define GID_HASHBITS    8
 417 #define GID_HASHMAX     (1<<GID_HASHBITS)
 418
 419 struct unix_gid {
 420         struct cache_head       h;
 421         kuid_t                  uid;
 422         struct group_info       *gi;
 423         struct rcu_head         rcu;
 424 };
 425
 426 static int unix_gid_hash(kuid_t uid)
 427 {
 428         return hash_long(from_kuid(&init_user_ns, uid), GID_HASHBITS);
 429 }
 430
 431 static void unix_gid_free(struct rcu_head *rcu)
 432 {
 433         struct unix_gid *ug = container_of(rcu, struct unix_gid, rcu);
 434         struct cache_head *item = &ug->h;
 435
 436         if (test_bit(CACHE_VALID, &item->flags) &&
 437             !test_bit(CACHE_NEGATIVE, &item->flags))
 438                 put_group_info(ug->gi);
 439         kfree(ug);
 440 }
 441
 442 static void unix_gid_put(struct kref *kref)
 443 {
 444         struct cache_head *item = container_of(kref, struct cache_head, ref);
 445         struct unix_gid *ug = container_of(item, struct unix_gid, h);
 446
 447         call_rcu(&ug->rcu, unix_gid_free);
 448 }
 449
 450 static int unix_gid_match(struct cache_head *corig, struct cache_head *cnew)
 451 {
 452         struct unix_gid *orig = container_of(corig, struct unix_gid, h);
 453         struct unix_gid *new = container_of(cnew, struct unix_gid, h);
 454         return uid_eq(orig->uid, new->uid);
 455 }
 456 static void unix_gid_init(struct cache_head *cnew, struct cache_head *citem)
 457 {
 458         struct unix_gid *new = container_of(cnew, struct unix_gid, h);
 459         struct unix_gid *item = container_of(citem, struct unix_gid, h);
 460         new->uid = item->uid;
 461 }
 462 static void unix_gid_update(struct cache_head *cnew, struct cache_head *citem)
 463 {
 464         struct unix_gid *new = container_of(cnew, struct unix_gid, h);
 465         struct unix_gid *item = container_of(citem, struct unix_gid, h);
 466
 467         get_group_info(item->gi);
 468         new->gi = item->gi;
 469 }
 470 static struct cache_head *unix_gid_alloc(void)
 471 {
 472         struct unix_gid *g = kmalloc(sizeof(*g), GFP_KERNEL);
 473         if (g)
 474                 return &g->h;
 475         else
 476                 return NULL;
 477 }
 478
 479 static void unix_gid_request(struct cache_detail *cd,
 480                              struct cache_head *h,
 481                              char **bpp, int *blen)
 482 {
 483         char tuid[20];
 484         struct unix_gid *ug = container_of(h, struct unix_gid, h);
 485
 486         snprintf(tuid, 20, "%u", from_kuid(&init_user_ns, ug->uid));
 487         qword_add(bpp, blen, tuid);
 488         (*bpp)[-1] = '\n';
 489 }
 490
 491 static struct unix_gid *unix_gid_lookup(struct cache_detail *cd, kuid_t uid);
 492
 493 static int unix_gid_parse(struct cache_detail *cd,
 494                         char *mesg, int mlen)
 495 {
 496         /* uid expiry Ngid gid0 gid1 ... gidN-1 */
 497         int id;
 498         kuid_t uid;
 499         int gids;
 500         int rv;
 501         int i;
 502         int err;
 503         time_t expiry;
 504         struct unix_gid ug, *ugp;
 505
 506         if (mesg[mlen - 1] != '\n')
 507                 return -EINVAL;
 508         mesg[mlen-1] = 0;
 509
 510         rv = get_int(&mesg, &id);
 511         if (rv)
 512                 return -EINVAL;
 513         uid = make_kuid(current_user_ns(), id);
 514         ug.uid = uid;
 515
 516         expiry = get_expiry(&mesg);
 517         if (expiry == 0)
 518                 return -EINVAL;
 519
 520         rv = get_int(&mesg, &gids);
 521         if (rv || gids < 0 || gids > 8192)
 522                 return -EINVAL;
 523
 524         ug.gi = groups_alloc(gids);
 525         if (!ug.gi)
 526                 return -ENOMEM;
 527
 528         for (i = 0 ; i < gids ; i++) {
 529                 int gid;
 530                 kgid_t kgid;
 531                 rv = get_int(&mesg, &gid);
 532                 err = -EINVAL;
 533                 if (rv)
 534                         goto out;
 535                 kgid = make_kgid(current_user_ns(), gid);
 536                 if (!gid_valid(kgid))
 537                         goto out;
 538                 ug.gi->gid[i] = kgid;
 539         }
 540
 541         groups_sort(ug.gi);
 542         ugp = unix_gid_lookup(cd, uid);
 543         if (ugp) {
 544                 struct cache_head *ch;
 545                 ug.h.flags = 0;
 546                 ug.h.expiry_time = expiry;
 547                 ch = sunrpc_cache_update(cd,
 548                                          &ug.h, &ugp->h,
 549                                          unix_gid_hash(uid));
 550                 if (!ch)
 551                         err = -ENOMEM;
 552                 else {
 553                         err = 0;
 554                         cache_put(ch, cd);
 555                 }
 556         } else
 557                 err = -ENOMEM;
 558  out:
 559         if (ug.gi)
 560                 put_group_info(ug.gi);
 561         return err;
 562 }
 563
 564 static int unix_gid_show(struct seq_file *m,
 565                          struct cache_detail *cd,
 566                          struct cache_head *h)
 567 {
 568         struct user_namespace *user_ns = m->file->f_cred->user_ns;
 569         struct unix_gid *ug;
 570         int i;
 571         int glen;
 572
 573         if (h == NULL) {
 574                 seq_puts(m, "#uid cnt: gids...\n");
 575                 return 0;
 576         }
 577         ug = container_of(h, struct unix_gid, h);
 578         if (test_bit(CACHE_VALID, &h->flags) &&
 579             !test_bit(CACHE_NEGATIVE, &h->flags))
 580                 glen = ug->gi->ngroups;
 581         else
 582                 glen = 0;
 583
 584         seq_printf(m, "%u %d:", from_kuid_munged(user_ns, ug->uid), glen);
 585         for (i = 0; i < glen; i++)
 586                 seq_printf(m, " %d", from_kgid_munged(user_ns, ug->gi->gid[i]));
 587         seq_printf(m, "\n");
 588         return 0;
 589 }
 590
 591 static const struct cache_detail unix_gid_cache_template = {
 592         .owner          = THIS_MODULE,
 593         .hash_size      = GID_HASHMAX,
 594         .name           = "auth.unix.gid",
 595         .cache_put      = unix_gid_put,
 596         .cache_request  = unix_gid_request,
 597         .cache_parse    = unix_gid_parse,
 598         .cache_show     = unix_gid_show,
 599         .match          = unix_gid_match,
 600         .init           = unix_gid_init,
 601         .update         = unix_gid_update,
 602         .alloc          = unix_gid_alloc,
 603 };
 604
 605 int unix_gid_cache_create(struct net *net)
 606 {
 607         struct sunrpc_net *sn = net_generic(net, sunrpc_net_id);
 608         struct cache_detail *cd;
 609         int err;
 610
 611         cd = cache_create_net(&unix_gid_cache_template, net);
 612         if (IS_ERR(cd))
 613                 return PTR_ERR(cd);
 614         err = cache_register_net(cd, net);
 615         if (err) {
 616                 cache_destroy_net(cd, net);
 617                 return err;
 618         }
 619         sn->unix_gid_cache = cd;
 620         return 0;
 621 }
 622
 623 void unix_gid_cache_destroy(struct net *net)
 624 {
 625         struct sunrpc_net *sn = net_generic(net, sunrpc_net_id);
 626         struct cache_detail *cd = sn->unix_gid_cache;
 627
 628         sn->unix_gid_cache = NULL;
 629         cache_purge(cd);
 630         cache_unregister_net(cd, net);
 631         cache_destroy_net(cd, net);
 632 }
 633
 634 static struct unix_gid *unix_gid_lookup(struct cache_detail *cd, kuid_t uid)
 635 {
 636         struct unix_gid ug;
 637         struct cache_head *ch;
 638
 639         ug.uid = uid;
 640         ch = sunrpc_cache_lookup_rcu(cd, &ug.h, unix_gid_hash(uid));
 641         if (ch)
 642                 return container_of(ch, struct unix_gid, h);
 643         else
 644                 return NULL;
 645 }
 646
 647 static struct group_info *unix_gid_find(kuid_t uid, struct svc_rqst *rqstp)
 648 {
 649         struct unix_gid *ug;
 650         struct group_info *gi;
 651         int ret;
 652         struct sunrpc_net *sn = net_generic(rqstp->rq_xprt->xpt_net,
 653                                             sunrpc_net_id);
 654
 655         ug = unix_gid_lookup(sn->unix_gid_cache, uid);
 656         if (!ug)
 657                 return ERR_PTR(-EAGAIN);
 658         ret = cache_check(sn->unix_gid_cache, &ug->h, &rqstp->rq_chandle);
 659         switch (ret) {
 660         case -ENOENT:
 661                 return ERR_PTR(-ENOENT);
 662         case -ETIMEDOUT:
 663                 return ERR_PTR(-ESHUTDOWN);
 664         case 0:
 665                 gi = get_group_info(ug->gi);
 666                 cache_put(&ug->h, sn->unix_gid_cache);
 667                 return gi;
 668         default:
 669                 return ERR_PTR(-EAGAIN);
 670         }
 671 }
 672
 673 int
 674 svcauth_unix_set_client(struct svc_rqst *rqstp)
 675 {
 676         struct sockaddr_in *sin;
 677         struct sockaddr_in6 *sin6, sin6_storage;
 678         struct ip_map *ipm;
 679         struct group_info *gi;
 680         struct svc_cred *cred = &rqstp->rq_cred;
 681         struct svc_xprt *xprt = rqstp->rq_xprt;
 682         struct net *net = xprt->xpt_net;
 683         struct sunrpc_net *sn = net_generic(net, sunrpc_net_id);
 684
 685         switch (rqstp->rq_addr.ss_family) {
 686         case AF_INET:
 687                 sin = svc_addr_in(rqstp);
 688                 sin6 = &sin6_storage;
 689                 ipv6_addr_set_v4mapped(sin->sin_addr.s_addr, &sin6->sin6_addr);
 690                 break;
 691         case AF_INET6:
 692                 sin6 = svc_addr_in6(rqstp);
 693                 break;
 694         default:
 695                 BUG();
 696         }
 697
 698         rqstp->rq_client = NULL;
 699         if (rqstp->rq_proc == 0)
 700                 return SVC_OK;
 701
 702         ipm = ip_map_cached_get(xprt);
 703         if (ipm == NULL)
 704                 ipm = __ip_map_lookup(sn->ip_map_cache, rqstp->rq_server->sv_program->pg_class,
 705                                     &sin6->sin6_addr);
 706
 707         if (ipm == NULL)
 708                 return SVC_DENIED;
 709
 710         switch (cache_check(sn->ip_map_cache, &ipm->h, &rqstp->rq_chandle)) {
 711                 default:
 712                         BUG();
 713                 case -ETIMEDOUT:
 714                         return SVC_CLOSE;
 715                 case -EAGAIN:
 716                         return SVC_DROP;
 717                 case -ENOENT:
 718                         return SVC_DENIED;
 719                 case 0:
 720                         rqstp->rq_client = &ipm->m_client->h;
 721                         kref_get(&rqstp->rq_client->ref);
 722                         ip_map_cached_put(xprt, ipm);
 723                         break;
 724         }
 725
 726         gi = unix_gid_find(cred->cr_uid, rqstp);
 727         switch (PTR_ERR(gi)) {
 728         case -EAGAIN:
 729                 return SVC_DROP;
 730         case -ESHUTDOWN:
 731                 return SVC_CLOSE;
 732         case -ENOENT:
 733                 break;
 734         default:
 735                 put_group_info(cred->cr_group_info);
 736                 cred->cr_group_info = gi;
 737         }
 738         return SVC_OK;
 739 }
 740
 741 EXPORT_SYMBOL_GPL(svcauth_unix_set_client);
 742
 743 static int
 744 svcauth_null_accept(struct svc_rqst *rqstp, __be32 *authp)
 745 {
 746         struct kvec     *argv = &rqstp->rq_arg.head[0];
 747         struct kvec     *resv = &rqstp->rq_res.head[0];
 748         struct svc_cred *cred = &rqstp->rq_cred;
 749
 750         if (argv->iov_len < 3*4)
 751                 return SVC_GARBAGE;
 752
 753         if (svc_getu32(argv) != 0) {
 754                 dprintk("svc: bad null cred\n");
 755                 *authp = rpc_autherr_badcred;
 756                 return SVC_DENIED;
 757         }
 758         if (svc_getu32(argv) != htonl(RPC_AUTH_NULL) || svc_getu32(argv) != 0) {
 759                 dprintk("svc: bad null verf\n");
 760                 *authp = rpc_autherr_badverf;
 761                 return SVC_DENIED;
 762         }
 763
 764         /* Signal that mapping to nobody uid/gid is required */
 765         cred->cr_uid = INVALID_UID;
 766         cred->cr_gid = INVALID_GID;
 767         cred->cr_group_info = groups_alloc(0);
 768         if (cred->cr_group_info == NULL)
 769                 return SVC_CLOSE; /* kmalloc failure - client must retry */
 770
 771         /* Put NULL verifier */
 772         svc_putnl(resv, RPC_AUTH_NULL);
 773         svc_putnl(resv, 0);
 774
 775         rqstp->rq_cred.cr_flavor = RPC_AUTH_NULL;
 776         return SVC_OK;
 777 }
 778
 779 static int
 780 svcauth_null_release(struct svc_rqst *rqstp)
 781 {
 782         if (rqstp->rq_client)
 783                 auth_domain_put(rqstp->rq_client);
 784         rqstp->rq_client = NULL;
 785         if (rqstp->rq_cred.cr_group_info)
 786                 put_group_info(rqstp->rq_cred.cr_group_info);
 787         rqstp->rq_cred.cr_group_info = NULL;
 788
 789         return 0; /* don't drop */
 790 }
 791
 792
 793 struct auth_ops svcauth_null = {
 794         .name           = "null",
 795         .owner          = THIS_MODULE,
 796         .flavour        = RPC_AUTH_NULL,
 797         .accept         = svcauth_null_accept,
 798         .release        = svcauth_null_release,
 799         .set_client     = svcauth_unix_set_client,
 800 };
 801
 802
 803 static int
 804 svcauth_unix_accept(struct svc_rqst *rqstp, __be32 *authp)
 805 {
 806         struct kvec     *argv = &rqstp->rq_arg.head[0];
 807         struct kvec     *resv = &rqstp->rq_res.head[0];
 808         struct svc_cred *cred = &rqstp->rq_cred;
 809         struct user_namespace *userns;
 810         u32             slen, i;
 811         int             len   = argv->iov_len;
 812
 813         if ((len -= 3*4) < 0)
 814                 return SVC_GARBAGE;
 815
 816         svc_getu32(argv);                       /* length */
 817         svc_getu32(argv);                       /* time stamp */
 818         slen = XDR_QUADLEN(svc_getnl(argv));    /* machname length */
 819         if (slen > 64 || (len -= (slen + 3)*4) < 0)
 820                 goto badcred;
 821         argv->iov_base = (void*)((__be32*)argv->iov_base + slen);       /* skip machname */
 822         argv->iov_len -= slen*4;
 823         /*
 824          * Note: we skip uid_valid()/gid_valid() checks here for
 825          * backwards compatibility with clients that use -1 id's.
 826          * Instead, -1 uid or gid is later mapped to the
 827          * (export-specific) anonymous id by nfsd_setuser.
 828          * Supplementary gid's will be left alone.
 829          */
 830         userns = (rqstp->rq_xprt && rqstp->rq_xprt->xpt_cred) ?
 831                 rqstp->rq_xprt->xpt_cred->user_ns : &init_user_ns;
 832         cred->cr_uid = make_kuid(userns, svc_getnl(argv)); /* uid */
 833         cred->cr_gid = make_kgid(userns, svc_getnl(argv)); /* gid */
 834         slen = svc_getnl(argv);                 /* gids length */
 835         if (slen > UNX_NGROUPS || (len -= (slen + 2)*4) < 0)
 836                 goto badcred;
 837         cred->cr_group_info = groups_alloc(slen);
 838         if (cred->cr_group_info == NULL)
 839                 return SVC_CLOSE;
 840         for (i = 0; i < slen; i++) {
 841                 kgid_t kgid = make_kgid(userns, svc_getnl(argv));
 842                 cred->cr_group_info->gid[i] = kgid;
 843         }
 844         groups_sort(cred->cr_group_info);
 845         if (svc_getu32(argv) != htonl(RPC_AUTH_NULL) || svc_getu32(argv) != 0) {
 846                 *authp = rpc_autherr_badverf;
 847                 return SVC_DENIED;
 848         }
 849
 850         /* Put NULL verifier */
 851         svc_putnl(resv, RPC_AUTH_NULL);
 852         svc_putnl(resv, 0);
 853
 854         rqstp->rq_cred.cr_flavor = RPC_AUTH_UNIX;
 855         return SVC_OK;
 856
 857 badcred:
 858         *authp = rpc_autherr_badcred;
 859         return SVC_DENIED;
 860 }
 861
 862 static int
 863 svcauth_unix_release(struct svc_rqst *rqstp)
 864 {
 865         /* Verifier (such as it is) is already in place.
 866          */
 867         if (rqstp->rq_client)
 868                 auth_domain_put(rqstp->rq_client);
 869         rqstp->rq_client = NULL;
 870         if (rqstp->rq_cred.cr_group_info)
 871                 put_group_info(rqstp->rq_cred.cr_group_info);
 872         rqstp->rq_cred.cr_group_info = NULL;
 873
 874         return 0;
 875 }
 876
 877
 878 struct auth_ops svcauth_unix = {
 879         .name           = "unix",
 880         .owner          = THIS_MODULE,
 881         .flavour        = RPC_AUTH_UNIX,
 882         .accept         = svcauth_unix_accept,
 883         .release        = svcauth_unix_release,
 884         .domain_release = svcauth_unix_domain_release,
 885         .set_client     = svcauth_unix_set_client,
 886 };
 887
 888 static const struct cache_detail ip_map_cache_template = {
 889         .owner          = THIS_MODULE,
 890         .hash_size      = IP_HASHMAX,
 891         .name           = "auth.unix.ip",
 892         .cache_put      = ip_map_put,
 893         .cache_request  = ip_map_request,
 894         .cache_parse    = ip_map_parse,
 895         .cache_show     = ip_map_show,
 896         .match          = ip_map_match,
 897         .init           = ip_map_init,
 898         .update         = update,
 899         .alloc          = ip_map_alloc,
 900 };
 901
 902 int ip_map_cache_create(struct net *net)
 903 {
 904         struct sunrpc_net *sn = net_generic(net, sunrpc_net_id);
 905         struct cache_detail *cd;
 906         int err;
 907
 908         cd = cache_create_net(&ip_map_cache_template, net);
 909         if (IS_ERR(cd))
 910                 return PTR_ERR(cd);
 911         err = cache_register_net(cd, net);
 912         if (err) {
 913                 cache_destroy_net(cd, net);
 914                 return err;
 915         }
 916         sn->ip_map_cache = cd;
 917         return 0;
 918 }
 919
 920 void ip_map_cache_destroy(struct net *net)
 921 {
 922         struct sunrpc_net *sn = net_generic(net, sunrpc_net_id);
 923         struct cache_detail *cd = sn->ip_map_cache;
 924
 925         sn->ip_map_cache = NULL;
 926         cache_purge(cd);
 927         cache_unregister_net(cd, net);
 928         cache_destroy_net(cd, net);
 929 }