sys/src/cmd/import.c

   1 #include <u.h>
   2 #include <libc.h>
   3 #include <auth.h>
   4 #include <libsec.h>
   5
   6 enum {
   7         Encnone,
   8         Encssl,
   9         Enctls,
  10 };
  11
  12 static char *encprotos[] = {
  13         [Encnone] =     "clear",
  14         [Encssl] =      "ssl",
  15         [Enctls] =      "tls",
  16                         nil,
  17 };
  18
  19 char            *keyspec = "";
  20 char            *filterp;
  21 char            *ealgs = "rc4_256 sha1";
  22 int             encproto = Encnone;
  23 char            *aan = "/bin/aan";
  24 char            *anstring  = "tcp!*!0";
  25 AuthInfo        *ai;
  26 int             debug;
  27 int             doauth = 1;
  28 int             timedout;
  29 int             skiptree;
  30
  31 int     connect(char*, char*);
  32 int     passive(void);
  33 void    catcher(void*, char*);
  34 void    sysfatal(char*, ...);
  35 void    usage(void);
  36 int     filter(int, char *, char *);
  37
  38 static void     mksecret(char *, uchar *);
  39
  40 /*
  41  * based on libthread's threadsetname, but drags in less library code.
  42  * actually just sets the arguments displayed.
  43  */
  44 void
  45 procsetname(char *fmt, ...)
  46 {
  47         int fd;
  48         char *cmdname;
  49         char buf[128];
  50         va_list arg;
  51
  52         va_start(arg, fmt);
  53         cmdname = vsmprint(fmt, arg);
  54         va_end(arg);
  55         if (cmdname == nil)
  56                 return;
  57         snprint(buf, sizeof buf, "#p/%d/args", getpid());
  58         if((fd = open(buf, OWRITE)) >= 0){
  59                 write(fd, cmdname, strlen(cmdname)+1);
  60                 close(fd);
  61         }
  62         free(cmdname);
  63 }
  64
  65 void
  66 post(char *name, char *envname, int srvfd)
  67 {
  68         int fd;
  69         char buf[32];
  70
  71         fd = create(name, OWRITE, 0600);
  72         if(fd < 0)
  73                 return;
  74         snprint(buf, sizeof(buf), "%d", srvfd);
  75         if(write(fd, buf, strlen(buf)) != strlen(buf))
  76                 sysfatal("srv write: %r");
  77         close(fd);
  78         putenv(envname, name);
  79 }
  80
  81 static int
  82 lookup(char *s, char *l[])
  83 {
  84         int i;
  85
  86         for (i = 0; l[i] != 0; i++)
  87                 if (strcmp(l[i], s) == 0)
  88                         return i;
  89         return -1;
  90 }
  91
  92 void
  93 main(int argc, char **argv)
  94 {
  95         char *mntpt, *srvpost, srvfile[64];
  96         int backwards = 0, fd, mntflags;
  97
  98         quotefmtinstall();
  99         srvpost = nil;
 100         mntflags = MREPL;
 101         ARGBEGIN{
 102         case 'A':
 103                 doauth = 0;
 104                 break;
 105         case 'a':
 106                 mntflags = MAFTER;
 107                 break;
 108         case 'b':
 109                 mntflags = MBEFORE;
 110                 break;
 111         case 'c':
 112                 mntflags |= MCREATE;
 113                 break;
 114         case 'C':
 115                 mntflags |= MCACHE;
 116                 break;
 117         case 'd':
 118                 debug++;
 119                 break;
 120         case 'f':
 121                 /* ignored but allowed for compatibility */
 122                 break;
 123         case 'E':
 124                 if ((encproto = lookup(EARGF(usage()), encprotos)) < 0)
 125                         usage();
 126                 break;
 127         case 'e':
 128                 ealgs = EARGF(usage());
 129                 if(*ealgs == 0 || strcmp(ealgs, "clear") == 0)
 130                         ealgs = nil;
 131                 break;
 132         case 'k':
 133                 keyspec = EARGF(usage());
 134                 break;
 135         case 'p':
 136                 filterp = aan;
 137                 break;
 138         case 'n':
 139                 anstring = EARGF(usage());
 140                 break;
 141         case 's':
 142                 srvpost = EARGF(usage());
 143                 break;
 144         case 'B':
 145                 backwards = 1;
 146                 break;
 147         case 'z':
 148                 skiptree = 1;
 149                 break;
 150         default:
 151                 usage();
 152         }ARGEND;
 153
 154         mntpt = 0;              /* to shut up compiler */
 155         if(backwards){
 156                 switch(argc) {
 157                 default:
 158                         mntpt = argv[0];
 159                         break;
 160                 case 0:
 161                         usage();
 162                 }
 163         } else {
 164                 switch(argc) {
 165                 case 2:
 166                         mntpt = argv[1];
 167                         break;
 168                 case 3:
 169                         mntpt = argv[2];
 170                         break;
 171                 default:
 172                         usage();
 173                 }
 174         }
 175
 176         if (encproto == Enctls)
 177                 sysfatal("%s: tls has not yet been implemented", argv[0]);
 178
 179         notify(catcher);
 180         alarm(60*1000);
 181
 182         if (backwards)
 183                 fd = passive();
 184         else
 185                 fd = connect(argv[0], argv[1]);
 186
 187         fprint(fd, "impo %s %s\n", filterp? "aan": "nofilter", encprotos[encproto]);
 188
 189         if (encproto != Encnone && ealgs && ai) {
 190                 uchar key[16], digest[SHA1dlen];
 191                 char fromclientsecret[21];
 192                 char fromserversecret[21];
 193                 int i;
 194
 195                 if(ai->nsecret < 8)
 196                         sysfatal("secret too small to ssl");
 197                 memmove(key+4, ai->secret, 8);
 198
 199                 /* exchange random numbers */
 200                 srand(truerand());
 201                 for(i = 0; i < 4; i++)
 202                         key[i] = rand();
 203                 if(write(fd, key, 4) != 4)
 204                         sysfatal("can't write key part: %r");
 205                 if(readn(fd, key+12, 4) != 4)
 206                         sysfatal("can't read key part: %r");
 207
 208                 /* scramble into two secrets */
 209                 sha1(key, sizeof(key), digest, nil);
 210                 mksecret(fromclientsecret, digest);
 211                 mksecret(fromserversecret, digest+10);
 212
 213                 if (filterp)
 214                         fd = filter(fd, filterp, backwards ? nil : argv[0]);
 215
 216                 /* set up encryption */
 217                 procsetname("pushssl");
 218                 fd = pushssl(fd, ealgs, fromclientsecret, fromserversecret, nil);
 219                 if(fd < 0)
 220                         sysfatal("can't establish ssl connection: %r");
 221         }
 222         else if (filterp)
 223                 fd = filter(fd, filterp, backwards ? nil : argv[0]);
 224
 225         if(ai)
 226                 auth_freeAI(ai);
 227
 228         if(srvpost){
 229                 snprint(srvfile, sizeof(srvfile), "/srv/%s", srvpost);
 230                 remove(srvfile);
 231                 post(srvfile, srvpost, fd);
 232         }
 233         procsetname("mount on %s", mntpt);
 234         if(mount(fd, -1, mntpt, mntflags, "") < 0)
 235                 sysfatal("can't mount %s: %r", argv[1]);
 236         alarm(0);
 237
 238         if(backwards && argc > 1){
 239                 exec(argv[1], &argv[1]);
 240                 sysfatal("exec: %r");
 241         }
 242         exits(0);
 243 }
 244
 245 void
 246 catcher(void*, char *msg)
 247 {
 248         timedout = 1;
 249         if(strcmp(msg, "alarm") == 0)
 250                 noted(NCONT);
 251         noted(NDFLT);
 252 }
 253
 254 int
 255 connect(char *system, char *tree)
 256 {
 257         char buf[ERRMAX], dir[128], *na;
 258         int fd, n;
 259
 260         na = netmkaddr(system, 0, "exportfs");
 261         procsetname("dial %s", na);
 262         if((fd = dial(na, 0, dir, 0)) < 0)
 263                 sysfatal("can't dial %s: %r", system);
 264
 265         if(doauth){
 266                 procsetname("auth_proxy auth_getkey proto=p9any role=client %s", keyspec);
 267                 ai = auth_proxy(fd, auth_getkey, "proto=p9any role=client %s", keyspec);
 268                 if(ai == nil)
 269                         sysfatal("%r: %s", system);
 270         }
 271
 272         if(!skiptree){
 273                 procsetname("writing tree name %s", tree);
 274                 n = write(fd, tree, strlen(tree));
 275                 if(n < 0)
 276                         sysfatal("can't write tree: %r");
 277
 278                 strcpy(buf, "can't read tree");
 279
 280                 procsetname("awaiting OK for %s", tree);
 281                 n = read(fd, buf, sizeof buf - 1);
 282                 if(n!=2 || buf[0]!='O' || buf[1]!='K'){
 283                         if (timedout)
 284                                 sysfatal("timed out connecting to %s", na);
 285                         buf[sizeof buf - 1] = '\0';
 286                         sysfatal("bad remote tree: %s", buf);
 287                 }
 288         }
 289         return fd;
 290 }
 291
 292 int
 293 passive(void)
 294 {
 295         int fd;
 296
 297         /*
 298          * Ignore doauth==0 on purpose.  Is it useful here?
 299          */
 300
 301         procsetname("auth_proxy auth_getkey proto=p9any role=server");
 302         ai = auth_proxy(0, auth_getkey, "proto=p9any role=server");
 303         if(ai == nil)
 304                 sysfatal("auth_proxy: %r");
 305         if(auth_chuid(ai, nil) < 0)
 306                 sysfatal("auth_chuid: %r");
 307         putenv("service", "import");
 308
 309         fd = dup(0, -1);
 310         close(0);
 311         open("/dev/null", ORDWR);
 312         close(1);
 313         open("/dev/null", ORDWR);
 314
 315         return fd;
 316 }
 317
 318 void
 319 usage(void)
 320 {
 321         fprint(2, "usage: import [-abcC] [-A] [-E clear|ssl|tls] "
 322 "[-e 'crypt auth'|clear] [-k keypattern] [-p] [-n address ] [-z] host remotefs [mountpoint]\n");
 323         exits("usage");
 324 }
 325
 326 int
 327 filter(int fd, char *cmd, char *host)
 328 {
 329         char addr[128], buf[256], *s, *file, *argv[16];
 330         int lfd, p[2], len, argc;
 331
 332         if(host == nil){
 333                 /* Get a free port and post it to the client. */
 334                 if (announce(anstring, addr) < 0)
 335                         sysfatal("filter: Cannot announce %s: %r", anstring);
 336
 337                 snprint(buf, sizeof(buf), "%s/local", addr);
 338                 if ((lfd = open(buf, OREAD)) < 0)
 339                         sysfatal("filter: Cannot open %s: %r", buf);
 340                 if ((len = read(lfd, buf, sizeof buf - 1)) < 0)
 341                         sysfatal("filter: Cannot read %s: %r", buf);
 342                 close(lfd);
 343                 buf[len] = '\0';
 344                 if ((s = strchr(buf, '\n')) != nil)
 345                         len = s - buf;
 346                 if (write(fd, buf, len) != len)
 347                         sysfatal("filter: cannot write port; %r");
 348         } else {
 349                 /* Read address string from connection */
 350                 if ((len = read(fd, buf, sizeof buf - 1)) < 0)
 351                         sysfatal("filter: cannot write port; %r");
 352                 buf[len] = '\0';
 353
 354                 if ((s = strrchr(buf, '!')) == nil)
 355                         sysfatal("filter: illegally formatted port %s", buf);
 356                 strecpy(addr, addr+sizeof(addr), netmkaddr(host, "tcp", s+1));
 357                 strecpy(strrchr(addr, '!'), addr+sizeof(addr), s);
 358         }
 359
 360         if(debug)
 361                 fprint(2, "filter: %s\n", addr);
 362
 363         snprint(buf, sizeof(buf), "%s", cmd);
 364         argc = tokenize(buf, argv, nelem(argv)-3);
 365         if (argc == 0)
 366                 sysfatal("filter: empty command");
 367
 368         if(host != nil)
 369                 argv[argc++] = "-c";
 370         argv[argc++] = addr;
 371         argv[argc] = nil;
 372
 373         file = argv[0];
 374         if((s = strrchr(argv[0], '/')) != nil)
 375                 argv[0] = s+1;
 376
 377         if(pipe(p) < 0)
 378                 sysfatal("pipe: %r");
 379
 380         switch(rfork(RFNOWAIT|RFPROC|RFMEM|RFFDG|RFREND)) {
 381         case -1:
 382                 sysfatal("filter: rfork; %r\n");
 383         case 0:
 384                 close(fd);
 385                 if (dup(p[0], 1) < 0)
 386                         sysfatal("filter: Cannot dup to 1; %r");
 387                 if (dup(p[0], 0) < 0)
 388                         sysfatal("filter: Cannot dup to 0; %r");
 389                 close(p[0]);
 390                 close(p[1]);
 391                 exec(file, argv);
 392                 sysfatal("filter: exec; %r");
 393         default:
 394                 dup(p[1], fd);
 395                 close(p[0]);
 396                 close(p[1]);
 397         }
 398         return fd;
 399 }
 400
 401 static void
 402 mksecret(char *t, uchar *f)
 403 {
 404         sprint(t, "%2.2ux%2.2ux%2.2ux%2.2ux%2.2ux%2.2ux%2.2ux%2.2ux%2.2ux%2.2ux",
 405                 f[0], f[1], f[2], f[3], f[4], f[5], f[6], f[7], f[8], f[9]);
 406 }