sys/src/cmd/exportfs/oexportfs.c

   1 /*
   2  * oexportfs - legacy exportfs for cpu and import
   3  */
   4 #include <u.h>
   5 #include <libc.h>
   6 #include <auth.h>
   7 #include <fcall.h>
   8 #include <libsec.h>
   9 #define Extern
  10 #include "exportfs.h"
  11
  12 enum {
  13         Encnone,
  14         Encssl,
  15         Enctls,
  16 };
  17
  18 int     srvfd = -1;
  19 int     nonone = 1;
  20 char    *filterp;
  21 char    *ealgs = "rc4_256 sha1";
  22 char    *aanfilter = "/bin/aan";
  23 int     encproto = Encnone;
  24 int     readonly;
  25
  26 static char *anstring  = "tcp!*!0";
  27
  28 static void
  29 filter(int fd, char *cmd, char *host)
  30 {
  31         char addr[128], buf[256], *s, *file, *argv[16];
  32         int lfd, p[2], len, argc;
  33
  34         if(host == nil){
  35                 /* Get a free port and post it to the client. */
  36                 if (announce(anstring, addr) < 0)
  37                         fatal("filter: Cannot announce %s: %r", anstring);
  38
  39                 snprint(buf, sizeof(buf), "%s/local", addr);
  40                 if ((lfd = open(buf, OREAD)) < 0)
  41                         fatal("filter: Cannot open %s: %r", buf);
  42                 if ((len = read(lfd, buf, sizeof buf - 1)) < 0)
  43                         fatal("filter: Cannot read %s: %r", buf);
  44                 close(lfd);
  45                 buf[len] = '\0';
  46                 if ((s = strchr(buf, '\n')) != nil)
  47                         len = s - buf;
  48                 if (write(fd, buf, len) != len)
  49                         fatal("filter: cannot write port; %r");
  50         } else {
  51                 /* Read address string from connection */
  52                 if ((len = read(fd, buf, sizeof buf - 1)) < 0)
  53                         sysfatal("filter: cannot write port; %r");
  54                 buf[len] = '\0';
  55
  56                 if ((s = strrchr(buf, '!')) == nil)
  57                         sysfatal("filter: illegally formatted port %s", buf);
  58                 strecpy(addr, addr+sizeof(addr), netmkaddr(host, "tcp", s+1));
  59                 strecpy(strrchr(addr, '!'), addr+sizeof(addr), s);
  60         }
  61
  62         DEBUG(DFD, "filter: %s\n", addr);
  63
  64         snprint(buf, sizeof(buf), "%s", cmd);
  65         argc = tokenize(buf, argv, nelem(argv)-3);
  66         if (argc == 0)
  67                 sysfatal("filter: empty command");
  68
  69         if(host != nil)
  70                 argv[argc++] = "-c";
  71         argv[argc++] = addr;
  72         argv[argc] = nil;
  73
  74         file = argv[0];
  75         if((s = strrchr(argv[0], '/')) != nil)
  76                 argv[0] = s+1;
  77
  78         if(pipe(p) < 0)
  79                 sysfatal("pipe: %r");
  80
  81         switch(rfork(RFNOWAIT|RFPROC|RFMEM|RFFDG|RFREND)) {
  82         case -1:
  83                 fatal("filter: rfork; %r\n");
  84         case 0:
  85                 close(fd);
  86                 if (dup(p[0], 1) < 0)
  87                         fatal("filter: Cannot dup to 1; %r");
  88                 if (dup(p[0], 0) < 0)
  89                         fatal("filter: Cannot dup to 0; %r");
  90                 close(p[0]);
  91                 close(p[1]);
  92                 exec(file, argv);
  93                 fatal("filter: exec; %r");
  94         default:
  95                 dup(p[1], fd);
  96                 close(p[0]);
  97                 close(p[1]);
  98         }
  99 }
 100
 101 static void
 102 mksecret(char *t, uchar *f)
 103 {
 104         sprint(t, "%2.2ux%2.2ux%2.2ux%2.2ux%2.2ux%2.2ux%2.2ux%2.2ux%2.2ux%2.2ux",
 105                 f[0], f[1], f[2], f[3], f[4], f[5], f[6], f[7], f[8], f[9]);
 106 }
 107
 108 void
 109 usage(void)
 110 {
 111         fprint(2, "usage: %s [-adnsR] [-f dbgfile] [-m msize] [-r root] "
 112                 "[-S srvfile] [-e 'crypt hash'] [-P exclusion-file] "
 113                 "[-A announce-string] [-B address]\n", argv0);
 114         fatal("usage");
 115 }
 116
 117 void
 118 main(int argc, char **argv)
 119 {
 120         char buf[ERRMAX], ebuf[ERRMAX], initial[4], *ini, *srvfdfile;
 121         char *dbfile, *srv, *na, *nsfile, *keyspec;
 122         int doauth, n, fd;
 123         AuthInfo *ai;
 124         Fsrpc *r;
 125
 126         dbfile = "/tmp/exportdb";
 127         srv = nil;
 128         srvfd = -1;
 129         srvfdfile = nil;
 130         na = nil;
 131         nsfile = nil;
 132         keyspec = "";
 133         doauth = 0;
 134
 135         ai = nil;
 136         ARGBEGIN{
 137         case 'a':
 138                 doauth = 1;
 139                 break;
 140
 141         case 'd':
 142                 dbg++;
 143                 break;
 144
 145         case 'e':
 146                 ealgs = EARGF(usage());
 147                 if(*ealgs == 0 || strcmp(ealgs, "clear") == 0)
 148                         ealgs = nil;
 149                 break;
 150
 151         case 'f':
 152                 dbfile = EARGF(usage());
 153                 break;
 154
 155         case 'k':
 156                 keyspec = EARGF(usage());
 157                 break;
 158
 159         case 'm':
 160                 messagesize = strtoul(EARGF(usage()), nil, 0);
 161                 break;
 162
 163         case 'n':
 164                 nonone = 0;
 165                 break;
 166
 167         case 'r':
 168                 srv = EARGF(usage());
 169                 break;
 170
 171         case 's':
 172                 srv = "/";
 173                 break;
 174
 175         case 'A':
 176                 anstring = EARGF(usage());
 177                 break;
 178
 179         case 'B':
 180                 na = EARGF(usage());
 181                 break;
 182
 183         case 'F':
 184                 /* accepted but ignored, for backwards compatibility */
 185                 break;
 186
 187         case 'N':
 188                 nsfile = EARGF(usage());
 189                 break;
 190
 191         case 'P':
 192                 patternfile = EARGF(usage());
 193                 break;
 194
 195         case 'R':
 196                 readonly = 1;
 197                 break;
 198
 199         case 'S':
 200                 if(srvfdfile != nil)
 201                         usage();
 202                 srvfdfile = EARGF(usage());
 203                 break;
 204
 205         default:
 206                 usage();
 207         }ARGEND
 208         USED(argc, argv);
 209
 210         if(na == nil && doauth){
 211                 /*
 212                  * We use p9any so we don't have to visit this code again, with the
 213                  * cost that this code is incompatible with the old world, which
 214                  * requires p9sk2. (The two differ in who talks first, so compatibility
 215                  * is awkward.)
 216                  */
 217                 ai = auth_proxy(0, auth_getkey, "proto=p9any role=server %s", keyspec);
 218                 if(ai == nil)
 219                         fatal("auth_proxy: %r");
 220                 if(nonone && strcmp(ai->cuid, "none") == 0)
 221                         fatal("exportfs by none disallowed");
 222                 if(auth_chuid(ai, nsfile) < 0)
 223                         fatal("auth_chuid: %r");
 224                 else {  /* chown network connection */
 225                         Dir nd;
 226                         nulldir(&nd);
 227                         nd.mode = 0660;
 228                         nd.uid = ai->cuid;
 229                         dirfwstat(0, &nd);
 230                 }
 231                 putenv("service", "exportfs");
 232         }
 233
 234         if(srvfdfile != nil){
 235                 if((srvfd = open(srvfdfile, ORDWR)) < 0)
 236                         fatal("open %s: %r", srvfdfile);
 237         }
 238
 239         if(na != nil){
 240                 if(srv == nil)
 241                         fatal("-B requires -s");
 242
 243                 if((fd = dial(netmkaddr(na, 0, "importfs"), 0, 0, 0)) < 0)
 244                         fatal("can't dial %s: %r", na);
 245
 246                 ai = auth_proxy(fd, auth_getkey, "proto=p9any role=client %s", keyspec);
 247                 if(ai == nil)
 248                         fatal("%r: %s", na);
 249
 250                 dup(fd, 0);
 251                 dup(fd, 1);
 252                 close(fd);
 253         }
 254
 255         exclusions();
 256
 257         if(dbg) {
 258                 n = create(dbfile, OWRITE|OTRUNC, 0666);
 259                 dup(n, DFD);
 260                 close(n);
 261         }
 262
 263         if(srvfd >= 0 && srv != nil){
 264                 fprint(2, "%s: -S cannot be used with -r or -s\n", argv0);
 265                 usage();
 266         }
 267
 268         DEBUG(DFD, "%s: started\n", argv0);
 269
 270         rfork(RFNOTEG|RFREND);
 271
 272         if(messagesize == 0){
 273                 messagesize = iounit(0);
 274                 if(messagesize == 0)
 275                         messagesize = 8192+IOHDRSZ;
 276         }
 277         fhash = emallocz(sizeof(Fid*)*FHASHSIZE);
 278
 279         fmtinstall('F', fcallfmt);
 280
 281         /*
 282          * Get tree to serve from network connection,
 283          * check we can get there and ack the connection
 284          */
 285         if(srvfd != -1) {
 286                 /* do nothing */
 287         }
 288         else if(srv != nil) {
 289                 if(chdir(srv) < 0) {
 290                         ebuf[0] = '\0';
 291                         errstr(ebuf, sizeof ebuf);
 292                         DEBUG(DFD, "chdir(\"%s\"): %s\n", srv, ebuf);
 293                         mounterror(ebuf);
 294                 }
 295                 DEBUG(DFD, "invoked as server for %s", srv);
 296                 strncpy(buf, srv, sizeof buf);
 297         }
 298         else {
 299                 buf[0] = 0;
 300                 n = read(0, buf, sizeof(buf)-1);
 301                 if(n < 0) {
 302                         errstr(buf, sizeof buf);
 303                         fprint(0, "read(0): %s\n", buf);
 304                         DEBUG(DFD, "read(0): %s\n", buf);
 305                         exits(buf);
 306                 }
 307                 buf[n] = 0;
 308                 if(chdir(buf) < 0) {
 309                         errstr(ebuf, sizeof ebuf);
 310                         fprint(0, "chdir(%d:\"%s\"): %s\n", n, buf, ebuf);
 311                         DEBUG(DFD, "chdir(%d:\"%s\"): %s\n", n, buf, ebuf);
 312                         exits(ebuf);
 313                 }
 314         }
 315
 316         DEBUG(DFD, "\niniting root\n");
 317         initroot();
 318
 319         DEBUG(DFD, "%s: %s\n", argv0, buf);
 320
 321         if(srv == nil && srvfd == -1 && write(0, "OK", 2) != 2)
 322                 fatal("open ack write");
 323
 324         ini = initial;
 325         n = readn(0, initial, sizeof(initial));
 326         if(n == 0)
 327                 fatal(nil);     /* port scan or spurious open/close on exported /srv file (unmount) */
 328         if(n < sizeof(initial))
 329                 fatal("can't read initial string: %r");
 330
 331         if(memcmp(ini, "impo", 4) == 0) {
 332                 char buf[128], *p, *args[3];
 333
 334                 ini = nil;
 335                 p = buf;
 336                 for(;;){
 337                         if((n = read(0, p, 1)) < 0)
 338                                 fatal("can't read impo arguments: %r");
 339                         if(n == 0)
 340                                 fatal("connection closed while reading arguments");
 341                         if(*p == '\n')
 342                                 *p = '\0';
 343                         if(*p++ == '\0')
 344                                 break;
 345                         if(p >= buf + sizeof(buf))
 346                                 fatal("import parameters too long");
 347                 }
 348
 349                 if(tokenize(buf, args, nelem(args)) != 2)
 350                         fatal("impo arguments invalid: impo%s...", buf);
 351
 352                 if(strcmp(args[0], "aan") == 0)
 353                         filterp = aanfilter;
 354                 else if(strcmp(args[0], "nofilter") != 0)
 355                         fatal("import filter argument unsupported: %s", args[0]);
 356
 357                 if(strcmp(args[1], "ssl") == 0)
 358                         encproto = Encssl;
 359                 else if(strcmp(args[1], "tls") == 0)
 360                         encproto = Enctls;
 361                 else if(strcmp(args[1], "clear") != 0)
 362                         fatal("import encryption proto unsupported: %s", args[1]);
 363
 364                 if(encproto == Enctls)
 365                         fatal("%s: tls has not yet been implemented", argv[0]);
 366         }
 367
 368         if(encproto != Encnone && ealgs != nil && ai != nil) {
 369                 uchar key[16], digest[SHA1dlen];
 370                 char fromclientsecret[21];
 371                 char fromserversecret[21];
 372                 int i;
 373
 374                 if(ai->nsecret < 8)
 375                         fatal("secret too small for ssl");
 376                 memmove(key+4, ai->secret, 8);
 377
 378                 /* exchange random numbers */
 379                 srand(truerand());
 380                 for(i = 0; i < 4; i++)
 381                         key[i+12] = rand();
 382
 383                 if(ini != nil)
 384                         fatal("Protocol botch: old import");
 385                 if(readn(0, key, 4) != 4)
 386                         fatal("can't read key part; %r");
 387
 388                 if(write(0, key+12, 4) != 4)
 389                         fatal("can't write key part; %r");
 390
 391                 /* scramble into two secrets */
 392                 sha1(key, sizeof(key), digest, nil);
 393                 mksecret(fromclientsecret, digest);
 394                 mksecret(fromserversecret, digest+10);
 395
 396                 if(filterp != nil)
 397                         filter(0, filterp, na);
 398
 399                 switch(encproto) {
 400                 case Encssl:
 401                         fd = pushssl(0, ealgs, fromserversecret, fromclientsecret, nil);
 402                         if(fd < 0)
 403                                 fatal("can't establish ssl connection: %r");
 404                         if(fd != 0){
 405                                 dup(fd, 0);
 406                                 close(fd);
 407                         }
 408                         break;
 409                 case Enctls:
 410                 default:
 411                         fatal("Unsupported encryption protocol");
 412                 }
 413         }
 414         else if(filterp != nil) {
 415                 if(ini != nil)
 416                         fatal("Protocol botch: don't know how to deal with this");
 417                 filter(0, filterp, na);
 418         }
 419         dup(0, 1);
 420
 421         if(ai != nil)
 422                 auth_freeAI(ai);
 423
 424         if(ini != nil){
 425                 extern void (*fcalls[])(Fsrpc*);
 426
 427                 r = getsbuf();
 428                 memmove(r->buf, ini, BIT32SZ);
 429                 n = GBIT32(r->buf);
 430                 if(n <= BIT32SZ || n > messagesize)
 431                         fatal("bad length in 9P2000 message header");
 432                 n -= BIT32SZ;
 433                 if(readn(0, r->buf+BIT32SZ, n) != n)
 434                         fatal(nil);
 435                 n += BIT32SZ;
 436
 437                 if(convM2S(r->buf, n, &r->work) != n)
 438                         fatal("convM2S format error");
 439                 DEBUG(DFD, "%F\n", &r->work);
 440                 (fcalls[r->work.type])(r);
 441         }
 442         io();
 443 }