sys/src/cmd/aux/listen1.c

   1 #include <u.h>
   2 #include <libc.h>
   3 #include <auth.h>
   4
   5 int maxprocs;
   6 int verbose;
   7 int trusted;
   8 char *nsfile;
   9
  10 void
  11 usage(void)
  12 {
  13         fprint(2, "usage: listen1 [-tv] [-p maxprocs] [-n namespace] address cmd args...\n");
  14         exits("usage");
  15 }
  16
  17 void
  18 becomenone(void)
  19 {
  20         int fd;
  21
  22         fd = open("#c/user", OWRITE);
  23         if(fd < 0 || write(fd, "none", strlen("none")) < 0)
  24                 sysfatal("can't become none: %r");
  25         close(fd);
  26         if(newns("none", nsfile) < 0)
  27                 sysfatal("can't build namespace: %r");
  28 }
  29
  30 char*
  31 remoteaddr(char *dir)
  32 {
  33         static char buf[128];
  34         char *p;
  35         int n, fd;
  36
  37         snprint(buf, sizeof buf, "%s/remote", dir);
  38         fd = open(buf, OREAD);
  39         if(fd < 0)
  40                 return "";
  41         n = read(fd, buf, sizeof(buf));
  42         close(fd);
  43         if(n > 0){
  44                 buf[n] = 0;
  45                 p = strchr(buf, '!');
  46                 if(p)
  47                         *p = 0;
  48                 return buf;
  49         }
  50         return "";
  51 }
  52
  53 void
  54 main(int argc, char **argv)
  55 {
  56         char data[60], dir[40], ndir[40], wbuf[64];
  57         int ctl, nctl, fd;
  58         int wfd, nowait, procs;
  59         Dir *d;
  60
  61         ARGBEGIN{
  62         default:
  63                 usage();
  64         case 't':
  65                 trusted = 1;
  66                 break;
  67         case 'v':
  68                 verbose = 1;
  69                 break;
  70         case 'p':
  71                 maxprocs = atoi(EARGF(usage()));
  72                 break;
  73         case 'n':
  74                 nsfile = EARGF(usage());
  75                 break;
  76         }ARGEND
  77
  78         if(argc < 2)
  79                 usage();
  80
  81         if(!verbose){
  82                 close(1);
  83                 fd = open("/dev/null", OWRITE);
  84                 if(fd != 1){
  85                         dup(fd, 1);
  86                         close(fd);
  87                 }
  88         }
  89
  90         if(!trusted)
  91                 becomenone();
  92
  93         print("listen started\n");
  94         ctl = announce(argv[0], dir);
  95         if(ctl < 0)
  96                 sysfatal("announce %s: %r", argv[0]);
  97
  98         wfd = -1;
  99         nowait = RFNOWAIT;
 100         if(maxprocs > 0){
 101                 snprint(wbuf, sizeof(wbuf), "/proc/%d/wait", getpid());
 102                 if((wfd = open(wbuf, OREAD)) >= 0)
 103                         nowait = 0;
 104         }
 105         procs = 0;
 106         for(;;){
 107                 if(nowait == 0 && (procs >= maxprocs || (procs % 8) == 0))
 108                         while(procs > 0){
 109                                 if(procs < maxprocs){
 110                                         d = dirfstat(wfd);
 111                                         if(d == nil || d->length == 0){
 112                                                 free(d);
 113                                                 break;
 114                                         }
 115                                         free(d);
 116                                 }
 117                                 if(read(wfd, wbuf, sizeof(wbuf)) > 0)
 118                                         procs--;
 119                         }
 120
 121                 nctl = listen(dir, ndir);
 122                 if(nctl < 0)
 123                         sysfatal("listen %s: %r", argv[0]);
 124
 125                 switch(rfork(RFFDG|RFPROC|RFMEM|RFENVG|RFNAMEG|RFNOTEG|RFREND|nowait)){
 126                 case -1:
 127                         reject(nctl, ndir, "host overloaded");
 128                         close(nctl);
 129                         continue;
 130                 case 0:
 131                         fd = accept(nctl, ndir);
 132                         if(fd < 0){
 133                                 fprint(2, "accept %s: can't open  %s/data: %r\n",
 134                                         argv[0], ndir);
 135                                 _exits(0);
 136                         }
 137                         print("incoming call for %s from %s in %s\n", argv[0],
 138                                 remoteaddr(ndir), ndir);
 139                         fprint(nctl, "keepalive");
 140                         close(ctl);
 141                         close(nctl);
 142                         if(wfd >= 0)
 143                                 close(wfd);
 144                         putenv("net", ndir);
 145                         snprint(data, sizeof data, "%s/data", ndir);
 146                         bind(data, "/dev/cons", MREPL);
 147                         dup(fd, 0);
 148                         dup(fd, 1);
 149                         /* dup(fd, 2); keep stderr */
 150                         close(fd);
 151                         exec(argv[1], argv+1);
 152                         if(argv[1][0] != '/')
 153                                 exec(smprint("/bin/%s", argv[1]), argv+1);
 154                         fprint(2, "%s: exec: %r\n", argv0);
 155                         exits(nil);
 156                 default:
 157                         close(nctl);
 158                         procs++;
 159                         break;
 160                 }
 161         }
 162 }