lustre/utils/gss/lsupport.c

   1 /* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*-
   2  * vim:expandtab:shiftwidth=8:tabstop=8:
   3  *
   4  * GPL HEADER START
   5  *
   6  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License version 2 only,
  10  * as published by the Free Software Foundation.
  11  *
  12  * This program is distributed in the hope that it will be useful, but
  13  * WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * General Public License version 2 for more details (a copy is included
  16  * in the LICENSE file that accompanied this code).
  17  *
  18  * You should have received a copy of the GNU General Public License
  19  * version 2 along with this program; If not, see
  20  * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
  21  *
  22  * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
  23  * CA 95054 USA or visit www.sun.com if you need additional information or
  24  * have any questions.
  25  *
  26  * GPL HEADER END
  27  */
  28 /*
  29  * Copyright  2008 Sun Microsystems, Inc. All rights reserved
  30  * Use is subject to license terms.
  31  */
  32 /*
  33  * This file is part of Lustre, http://www.lustre.org/
  34  * Lustre is a trademark of Sun Microsystems, Inc.
  35  */
  36
  37 #ifndef _GNU_SOURCE
  38 #define _GNU_SOURCE
  39 #endif
  40 #include "config.h"
  41 #include <sys/param.h>
  42 #include <sys/utsname.h>
  43 #include <sys/stat.h>
  44 #include <sys/socket.h>
  45 #include <arpa/inet.h>
  46 #include <sys/types.h>
  47 #include <sys/ipc.h>
  48 #include <sys/sem.h>
  49
  50 #include <stdio.h>
  51 #include <stdlib.h>
  52 #include <pwd.h>
  53 #include <grp.h>
  54 #include <string.h>
  55 #include <dirent.h>
  56 #include <poll.h>
  57 #include <fcntl.h>
  58 #include <signal.h>
  59 #include <unistd.h>
  60 #include <errno.h>
  61 #include <assert.h>
  62 #ifdef HAVE_GETHOSTBYNAME
  63 # include <netdb.h>
  64 #endif
  65
  66 #ifdef _NEW_BUILD_
  67 # include "lgss_utils.h"
  68 #else
  69 # include "err_util.h"
  70 # include "gssd.h"
  71 #endif
  72 #include "lsupport.h"
  73
  74 const char * lustre_svc_name[] =
  75 {
  76         [LUSTRE_GSS_SVC_MDS]    = "MDS",
  77         [LUSTRE_GSS_SVC_OSS]    = "OSS",
  78 };
  79
  80 /****************************************
  81  * exclusive startup                    *
  82  ****************************************/
  83
  84 static struct __sem_s {
  85         char           *name;
  86         key_t           sem_key;
  87         int             sem_id;
  88 } sems[2] = {
  89         [GSSD_CLI] = { "client",  0x3a92d473, 0 },
  90         [GSSD_SVC] = { "server",  0x3b92d473, 0 },
  91 };
  92
  93 void gssd_init_unique(int type)
  94 {
  95         struct __sem_s *sem = &sems[type];
  96         struct sembuf   sembuf;
  97
  98         assert(type == GSSD_CLI || type == GSSD_SVC);
  99
 100 again:
 101         sem->sem_id = semget(sem->sem_key, 1, IPC_CREAT | IPC_EXCL | 0700);
 102         if (sem->sem_id == -1) {
 103                 if (errno != EEXIST) {
 104                         printerr(0, "Create sem: %s\n", strerror(errno));
 105                         exit(-1);
 106                 }
 107
 108                 /* already exist. Note there's still a small window racing
 109                  * with other processes, due to the stupid semaphore semantics.
 110                  */
 111                 sem->sem_id = semget(sem->sem_key, 0, 0700);
 112                 if (sem->sem_id == -1) {
 113                         if (errno == ENOENT) {
 114                                 printerr(0, "another instance just exit, "
 115                                          "try again\n");
 116                                 goto again;
 117                         }
 118
 119                         printerr(0, "Obtain sem: %s\n", strerror(errno));
 120                         exit(-1);
 121                 }
 122         } else {
 123                 int val = 1;
 124
 125                 if (semctl(sem->sem_id, 0, SETVAL, val) == -1) {
 126                         printerr(0, "Initialize sem: %s\n",
 127                                  strerror(errno));
 128                         exit(-1);
 129                 }
 130         }
 131
 132         sembuf.sem_num = 0;
 133         sembuf.sem_op = -1;
 134         sembuf.sem_flg = IPC_NOWAIT | SEM_UNDO;
 135
 136         if (semop(sem->sem_id, &sembuf, 1) != 0) {
 137                 if (errno == EAGAIN) {
 138                         printerr(0, "Another instance is running, exit\n");
 139                         exit(0);
 140                 }
 141                 printerr(0, "Grab sem: %s\n", strerror(errno));
 142                 exit(0);
 143         }
 144
 145         printerr(2, "Successfully created %s global identity\n", sem->name);
 146 }
 147
 148 void gssd_exit_unique(int type)
 149 {
 150         assert(type == GSSD_CLI || type == GSSD_SVC);
 151
 152         /*
 153          * do nothing. we can't remove the sem here, otherwise the race
 154          * window would be much bigger. So it's sad we have to leave the
 155          * sem in the system forever.
 156          */
 157 }
 158
 159 /****************************************
 160  * client side resolvation:             *
 161  *    lnd/netid/nid => hostname         *
 162  ****************************************/
 163
 164 char gethostname_ex[PATH_MAX] = GSSD_DEFAULT_GETHOSTNAME_EX;
 165
 166 typedef int lnd_nid2hostname_t(char *lnd, uint32_t net, uint32_t addr,
 167                                char *buf, int buflen);
 168
 169 /* FIXME what about IPv6? */
 170 static
 171 int ipv4_nid2hostname(char *lnd, uint32_t net, uint32_t addr,
 172                       char *buf, int buflen)
 173 {
 174         struct hostent  *ent;
 175
 176         addr = htonl(addr);
 177         ent = gethostbyaddr(&addr, sizeof(addr), AF_INET);
 178         if (!ent) {
 179                 printerr(0, "%s: can't resolve 0x%x\n", lnd, addr);
 180                 return -1;
 181         }
 182         if (strlen(ent->h_name) >= buflen) {
 183                 printerr(0, "%s: name too long: %s\n", lnd, ent->h_name);
 184                 return -1;
 185         }
 186         strcpy(buf, ent->h_name);
 187
 188         printerr(2, "%s: net 0x%x, addr 0x%x => %s\n",
 189                  lnd, net, addr, buf);
 190         return 0;
 191 }
 192
 193 static
 194 int lolnd_nid2hostname(char *lnd, uint32_t net, uint32_t addr,
 195                        char *buf, int buflen)
 196 {
 197         struct utsname   uts;
 198         struct hostent  *ent;
 199
 200         if (addr) {
 201                 printerr(0, "%s: addr is 0x%x, we expect 0\n", lnd, addr);
 202                 return -1;
 203         }
 204
 205         if (uname(&uts)) {
 206                 printerr(0, "%s: failed obtain local machine name\n", lnd);
 207                 return -1;
 208         }
 209
 210         ent = gethostbyname(uts.nodename);
 211         if (!ent) {
 212                 printerr(0, "%s: failed obtain canonical name of %s\n",
 213                          lnd, uts.nodename);
 214                 return -1;
 215         }
 216
 217         if (strlen(ent->h_name) >= buflen) {
 218                 printerr(0, "%s: name too long: %s\n", lnd, ent->h_name);
 219                 return -1;
 220         }
 221         strcpy(buf, ent->h_name);
 222
 223         printerr(3, "%s: addr 0x%x => %s\n", lnd, addr, buf);
 224         return 0;
 225 }
 226
 227 static int is_space(char c)
 228 {
 229         return (c == ' ' || c == '\t' || c == '\n');
 230 }
 231
 232 static
 233 int external_nid2hostname(char *lnd, uint32_t net, uint32_t addr,
 234                           char *namebuf, int namebuflen)
 235 {
 236         const int bufsize = PATH_MAX + 256;
 237         char buf[bufsize], *head, *tail;
 238         FILE *fghn;
 239
 240         sprintf(buf, "%s %s 0x%x 0x%x", gethostname_ex, lnd, net, addr);
 241         printerr(2, "cmd: %s\n", buf);
 242
 243         fghn = popen(buf, "r");
 244         if (fghn == NULL) {
 245                 printerr(0, "failed to call %s\n", gethostname_ex);
 246                 return -1;
 247         }
 248
 249         head = fgets(buf, bufsize, fghn);
 250         if (head == NULL) {
 251                 printerr(0, "can't read from %s\n", gethostname_ex);
 252                 return -1;
 253         }
 254         if (pclose(fghn) == -1)
 255                 printerr(1, "pclose failed, continue\n");
 256
 257         /* trim head/tail space */
 258         while (is_space(*head))
 259                 head++;
 260
 261         tail = head + strlen(head);
 262         if (tail <= head) {
 263                 printerr(0, "no output from %s\n", gethostname_ex);
 264                 return -1;
 265         }
 266         while (is_space(*(tail - 1)))
 267                 tail--;
 268         if (tail <= head) {
 269                 printerr(0, "output are all space from %s\n", gethostname_ex);
 270                 return -1;
 271         }
 272         *tail = '\0';
 273
 274         /* start with '@' means error msg */
 275         if (head[0] == '@') {
 276                 printerr(0, "error from %s: %s\n", gethostname_ex, &head[1]);
 277                 return -1;
 278         }
 279
 280         if (tail - head > namebuflen) {
 281                 printerr(0, "external hostname too long: %s\n", head);
 282                 return -1;
 283         }
 284
 285         printerr(2, "%s: net 0x%x, addr 0x%x => %s\n",
 286                  lnd, net, addr, head);
 287         strcpy(namebuf, head);
 288         return 0;
 289 }
 290
 291 struct convert_struct {
 292         char                    *name;
 293         lnd_nid2hostname_t      *nid2name;
 294 };
 295
 296 static struct convert_struct converter[] = {
 297         [0]             = { "UNUSED0",  NULL},
 298         [QSWLND]        = { "QSWLND",   external_nid2hostname},
 299         [SOCKLND]       = { "SOCKLND",  ipv4_nid2hostname },
 300         [GMLND]         = { "GMLND",    external_nid2hostname},
 301         [PTLLND]        = { "PTLLND",   external_nid2hostname },
 302         [O2IBLND]       = { "O2IBLND",  ipv4_nid2hostname },
 303         [CIBLND]        = { "CIBLND",   external_nid2hostname },
 304         [OPENIBLND]     = { "OPENIBLND",external_nid2hostname },
 305         [IIBLND]        = { "IIBLND",   external_nid2hostname },
 306         [LOLND]         = { "LOLND",    lolnd_nid2hostname },
 307         [RALND]         = { "RALND",    external_nid2hostname },
 308         [VIBLND]        = { "VIBLND",   external_nid2hostname },
 309         [MXLND]         = { "MXLND",    external_nid2hostname },
 310 };
 311
 312 #define LND_MAX         (sizeof(converter) / sizeof(converter[0]))
 313
 314 int lnet_nid2hostname(lnet_nid_t nid, char *buf, int buflen)
 315 {
 316         uint32_t lnd, net, addr;
 317
 318         addr = LNET_NIDADDR(nid);
 319         net = LNET_NIDNET(nid);
 320         lnd = LNET_NETTYP(net);
 321
 322         if (lnd >= LND_MAX) {
 323                 printerr(0, "ERROR: Unrecognized LND %u\n", lnd);
 324                 return -1;
 325         }
 326
 327         if (converter[lnd].nid2name == NULL) {
 328                 printerr(0, "ERROR: %s converter not ready\n",
 329                         converter[lnd].name);
 330                 return -1;
 331         }
 332
 333         return converter[lnd].nid2name(converter[lnd].name, net, addr,
 334                                        buf, buflen);
 335 }
 336
 337
 338 /****************************************
 339  * user mapping database handling       *
 340  * (very rudiment)                      *
 341  ****************************************/
 342
 343 #define MAPPING_GROW_SIZE       512
 344 #define MAX_LINE_LEN            256
 345
 346 struct user_map_item {
 347         char        *principal; /* NULL means match all */
 348         lnet_nid_t   nid;
 349         uid_t        uid;
 350 };
 351
 352 struct user_mapping {
 353         int                   nitems;
 354         struct user_map_item *items;
 355 };
 356
 357 static struct user_mapping mapping = {0, NULL};
 358 /* FIXME to be finished: monitor change of mapping database */
 359 static int mapping_mtime = 0;
 360
 361 void cleanup_mapping(void)
 362 {
 363         if (mapping.items) {
 364                 for (; mapping.nitems > 0; mapping.nitems--)
 365                         if (mapping.items[mapping.nitems-1].principal)
 366                                 free(mapping.items[mapping.nitems-1].principal);
 367
 368                 free(mapping.items);
 369                 mapping.items = NULL;
 370         }
 371 }
 372
 373 static int grow_mapping(int nitems)
 374 {
 375         struct user_map_item *new;
 376         int oldsize, newsize;
 377
 378         oldsize = (mapping.nitems * sizeof(struct user_map_item) +
 379                    MAPPING_GROW_SIZE - 1) / MAPPING_GROW_SIZE;
 380         newsize = (nitems * sizeof(struct user_map_item) +
 381                    MAPPING_GROW_SIZE - 1) / MAPPING_GROW_SIZE;
 382         while (newsize <= oldsize)
 383                 return 0;
 384
 385         newsize *= MAPPING_GROW_SIZE;
 386         new = malloc(newsize);
 387         if (!new) {
 388                 printerr(0, "can't alloc mapping size %d\n", newsize);
 389                 return -1;
 390         }
 391
 392         if (mapping.items) {
 393                 memcpy(new, mapping.items,
 394                        mapping.nitems * sizeof(struct user_map_item));
 395                 free(mapping.items);
 396         }
 397         mapping.items = new;
 398         return 0;
 399 }
 400
 401 uid_t parse_uid(char *uidstr)
 402 {
 403         struct passwd *pw;
 404         char *p = NULL;
 405         long uid;
 406
 407         pw = getpwnam(uidstr);
 408         if (pw)
 409                 return pw->pw_uid;
 410
 411         uid = strtol(uidstr, &p, 0);
 412         if (*p == '\0')
 413                 return (uid_t) uid;
 414
 415         return -1;
 416 }
 417
 418 static int read_mapping_db(void)
 419 {
 420         char princ[MAX_LINE_LEN];
 421         char nid_str[MAX_LINE_LEN];
 422         char dest[MAX_LINE_LEN];
 423         char linebuf[MAX_LINE_LEN];
 424         char *line;
 425         lnet_nid_t nid;
 426         uid_t dest_uid;
 427         FILE *f;
 428
 429         /* cleanup old mappings */
 430         cleanup_mapping();
 431
 432         f = fopen(MAPPING_DATABASE_FILE, "r");
 433         if (!f) {
 434                 printerr(0, "can't open mapping database: %s\n",
 435                          MAPPING_DATABASE_FILE);
 436                 return -1;
 437         }
 438
 439         while ((line = fgets(linebuf, MAX_LINE_LEN, f)) != NULL) {
 440                 char *name;
 441
 442                 if (strlen(line) >= MAX_LINE_LEN) {
 443                         printerr(0, "invalid mapping db: line too long (%d)\n",
 444                                  strlen(line));
 445                         continue;
 446                 }
 447
 448                 if (sscanf(line, "%s %s %s", princ, nid_str, dest) != 3) {
 449                         printerr(0, "mapping db: syntax error\n");
 450                         continue;
 451                 }
 452
 453                 if (!strcmp(princ, "*")) {
 454                         name = NULL;
 455                 } else {
 456                         name = strdup(princ);
 457                         if (!name) {
 458                                 printerr(0, "fail to dup str %s\n", princ);
 459                                 continue;
 460                         }
 461                 }
 462
 463                 if (!strcmp(nid_str, "*")) {
 464                         nid = LNET_NID_ANY;
 465                 } else {
 466                         nid = libcfs_str2nid(nid_str);
 467                         if (nid == LNET_NID_ANY) {
 468                                 printerr(0, "fail to parse nid %s\n", nid_str);
 469                                 if (name)
 470                                 free(name);
 471                                 continue;
 472                         }
 473                 }
 474
 475                 dest_uid = parse_uid(dest);
 476                 if (dest_uid == -1) {
 477                         printerr(0, "no valid user: %s\n", dest);
 478                         if (name)
 479                         free(name);
 480                         continue;
 481                 }
 482
 483                 if (grow_mapping(mapping.nitems + 1)) {
 484                         printerr(0, "fail to grow mapping to %d\n",
 485                                  mapping.nitems + 1);
 486                         if (name)
 487                         free(name);
 488                         fclose(f);
 489                         return -1;
 490                 }
 491
 492                 mapping.items[mapping.nitems].principal = name;
 493                 mapping.items[mapping.nitems].nid = nid;
 494                 mapping.items[mapping.nitems].uid = dest_uid;
 495                 mapping.nitems++;
 496                 printerr(1, "add mapping: %s(%s/0x%llx) ==> %d\n",
 497                          name, nid_str, nid, dest_uid);
 498         }
 499
 500         fclose(f);
 501         return 0;
 502 }
 503
 504 static inline int mapping_changed(void)
 505 {
 506         struct stat st;
 507
 508         if (stat(MAPPING_DATABASE_FILE, &st) == -1) {
 509                 /* stat failed, treat it like doesn't exist or be removed */
 510                 if (mapping_mtime == 0) {
 511                         return 0;
 512                 } else {
 513                         printerr(0, "Warning: stat %s failed: %s\n",
 514                                  MAPPING_DATABASE_FILE, strerror(errno));
 515
 516                         mapping_mtime = 0;
 517                         return 1;
 518                 }
 519         }
 520
 521         if (st.st_mtime != mapping_mtime) {
 522                 mapping_mtime = st.st_mtime;
 523                 return 1;
 524         }
 525
 526         return 0;
 527 }
 528
 529 int lookup_mapping(char *princ, lnet_nid_t nid, uid_t *uid)
 530 {
 531         int n;
 532
 533         *uid = -1;
 534
 535         /* FIXME race condition here */
 536         if (mapping_changed()) {
 537                 if (read_mapping_db())
 538                         printerr(0, "all remote users will be denied\n");
 539         }
 540
 541         for (n = 0; n < mapping.nitems; n++) {
 542                 struct user_map_item *entry = &mapping.items[n];
 543
 544                 if (entry->nid != LNET_NID_ANY && entry->nid != nid)
 545                         continue;
 546                 if (!entry->principal || !strcasecmp(entry->principal, princ)) {
 547                         printerr(1, "found mapping: %s ==> %d\n",
 548                                  princ, entry->uid);
 549                         *uid = entry->uid;
 550                         return 0;
 551                 }
 552         }
 553
 554         printerr(2, "no mapping for %s/%#Lx\n", princ, nid);
 555         return -1;
 556 }