sys/src/cmd/rc/plan9.c

   1 /*
   2  * Plan 9 versions of system-specific functions
   3  *      By convention, exported routines herein have names beginning with an
   4  *      upper case letter.
   5  */
   6 #include "rc.h"
   7 #include "exec.h"
   8 #include "io.h"
   9 #include "fns.h"
  10 #include "getflags.h"
  11
  12 enum {
  13         Maxenvname = 128,       /* undocumented limit */
  14 };
  15
  16 char *Signame[] = {
  17         "sigexit",      "sighup",       "sigint",       "sigquit",
  18         "sigalrm",      "sigkill",      "sigfpe",       "sigterm",
  19         0
  20 };
  21 char *syssigname[] = {
  22         "exit",         /* can't happen */
  23         "hangup",
  24         "interrupt",
  25         "quit",         /* can't happen */
  26         "alarm",
  27         "kill",
  28         "sys: fp: ",
  29         "term",
  30         0
  31 };
  32 char Rcmain[]="/rc/lib/rcmain";
  33 char Fdprefix[]="/fd/";
  34 void execfinit(void);
  35 void execbind(void);
  36 void execmount(void);
  37 void execnewpgrp(void);
  38 builtin Builtin[] = {
  39         "cd",           execcd,
  40         "whatis",       execwhatis,
  41         "eval",         execeval,
  42         "exec",         execexec,       /* but with popword first */
  43         "exit",         execexit,
  44         "shift",        execshift,
  45         "wait",         execwait,
  46         ".",            execdot,
  47         "finit",        execfinit,
  48         "flag",         execflag,
  49         "rfork",        execnewpgrp,
  50         0
  51 };
  52
  53 void
  54 execnewpgrp(void)
  55 {
  56         int arg;
  57         char *s;
  58         switch(count(runq->argv->words)){
  59         case 1:
  60                 arg = RFENVG|RFNAMEG|RFNOTEG;
  61                 break;
  62         case 2:
  63                 arg = 0;
  64                 for(s = runq->argv->words->next->word;*s;s++) switch(*s){
  65                 default:
  66                         goto Usage;
  67                 case 'n':
  68                         arg|=RFNAMEG;  break;
  69                 case 'N':
  70                         arg|=RFCNAMEG;
  71                         break;
  72                 case 'm':
  73                         arg|=RFNOMNT;  break;
  74                 case 'e':
  75                         arg|=RFENVG;   break;
  76                 case 'E':
  77                         arg|=RFCENVG;  break;
  78                 case 's':
  79                         arg|=RFNOTEG;  break;
  80                 case 'f':
  81                         arg|=RFFDG;    break;
  82                 case 'F':
  83                         arg|=RFCFDG;   break;
  84                 }
  85                 break;
  86         default:
  87         Usage:
  88                 pfmt(err, "Usage: %s [fnesFNEm]\n", runq->argv->words->word);
  89                 setstatus("rfork usage");
  90                 poplist();
  91                 return;
  92         }
  93         if(rfork(arg)==-1){
  94                 pfmt(err, "rc: %s failed\n", runq->argv->words->word);
  95                 setstatus("rfork failed");
  96         } else {
  97                 if(arg & RFCFDG){
  98                         struct redir *rp;
  99                         for(rp = runq->redir; rp; rp = rp->next)
 100                                 rp->type = 0;
 101                 }
 102                 setstatus("");
 103         }
 104         poplist();
 105 }
 106
 107 void
 108 Vinit(void)
 109 {
 110         int dir, f, len, i, n, nent;
 111         char *buf, *s;
 112         char envname[Maxenvname];
 113         word *val;
 114         Dir *ent;
 115
 116         dir = open("/env", OREAD);
 117         if(dir<0){
 118                 pfmt(err, "rc: can't open /env: %r\n");
 119                 return;
 120         }
 121         ent = nil;
 122         for(;;){
 123                 nent = dirread(dir, &ent);
 124                 if(nent <= 0)
 125                         break;
 126                 for(i = 0; i<nent; i++){
 127                         len = ent[i].length;
 128                         if(len && strncmp(ent[i].name, "fn#", 3)!=0){
 129                                 snprint(envname, sizeof envname, "/env/%s", ent[i].name);
 130                                 if((f = open(envname, 0))>=0){
 131                                         buf = emalloc(len+1);
 132                                         n = readn(f, buf, len);
 133                                         if (n <= 0)
 134                                                 buf[0] = '\0';
 135                                         else
 136                                                 buf[n] = '\0';
 137                                         val = 0;
 138                                         /* Charitably add a 0 at the end if need be */
 139                                         if(buf[len-1])
 140                                                 buf[len++]='\0';
 141                                         s = buf+len-1;
 142                                         for(;;){
 143                                                 while(s!=buf && s[-1]!='\0') --s;
 144                                                 val = newword(s, val);
 145                                                 if(s==buf)
 146                                                         break;
 147                                                 --s;
 148                                         }
 149                                         setvar(ent[i].name, val);
 150                                         vlook(ent[i].name)->changed = 0;
 151                                         close(f);
 152                                         free(buf);
 153                                 }
 154                         }
 155                 }
 156                 free(ent);
 157         }
 158         close(dir);
 159 }
 160
 161 void
 162 Xrdfn(void)
 163 {
 164         if(runq->argv->words == 0)
 165                 poplist();
 166         else {
 167                 free(runq->cmdfile);
 168                 int f = open(runq->argv->words->word, 0);
 169                 lexline = 0;
 170                 runq->cmdfile = strdup(runq->argv->words->word);
 171                 runq->pc--;
 172                 popword();
 173                 if(f>=0) execcmds(openfd(f));
 174         }
 175 }
 176 union code rdfns[8];
 177
 178 void
 179 execfinit(void)
 180 {
 181         static int first = 1;
 182         if(first){
 183                 rdfns[0].i = 1;
 184                 rdfns[1].f = Xmark;
 185                 rdfns[2].f = Xglobs;
 186                 rdfns[4].i = Globsize(rdfns[3].s = "/env/fn#\001*");
 187                 rdfns[5].f = Xglob;
 188                 rdfns[6].f = Xrdfn;
 189                 rdfns[7].f = Xreturn;
 190                 first = 0;
 191         }
 192         poplist();
 193         start(rdfns, 1, runq->local);
 194 }
 195
 196 int
 197 Waitfor(int pid, int)
 198 {
 199         thread *p;
 200         Waitmsg *w;
 201         char errbuf[ERRMAX];
 202
 203         if(pid >= 0 && !havewaitpid(pid))
 204                 return 0;
 205
 206         while((w = wait()) != nil){
 207                 delwaitpid(w->pid);
 208                 if(w->pid==pid){
 209                         setstatus(w->msg);
 210                         free(w);
 211                         return 0;
 212                 }
 213                 for(p = runq->ret;p;p = p->ret)
 214                         if(p->pid==w->pid){
 215                                 p->pid=-1;
 216                                 strcpy(p->status, w->msg);
 217                         }
 218                 free(w);
 219         }
 220
 221         errstr(errbuf, sizeof errbuf);
 222         if(strcmp(errbuf, "interrupted")==0) return -1;
 223         return 0;
 224 }
 225
 226 char **
 227 mkargv(word *a)
 228 {
 229         char **argv = (char **)emalloc((count(a)+2)*sizeof(char *));
 230         char **argp = argv+1;   /* leave one at front for runcoms */
 231         for(;a;a = a->next) *argp++=a->word;
 232         *argp = 0;
 233         return argv;
 234 }
 235
 236 void
 237 addenv(var *v)
 238 {
 239         char envname[Maxenvname];
 240         word *w;
 241         int f;
 242         io *fd;
 243         if(v->changed){
 244                 v->changed = 0;
 245                 snprint(envname, sizeof envname, "/env/%s", v->name);
 246                 if((f = Creat(envname))<0)
 247                         pfmt(err, "rc: can't open %s: %r\n", envname);
 248                 else{
 249                         for(w = v->val;w;w = w->next)
 250                                 write(f, w->word, strlen(w->word)+1L);
 251                         close(f);
 252                 }
 253         }
 254         if(v->fnchanged){
 255                 v->fnchanged = 0;
 256                 snprint(envname, sizeof envname, "/env/fn#%s", v->name);
 257                 if((f = Creat(envname))<0)
 258                         pfmt(err, "rc: can't open %s: %r\n", envname);
 259                 else{
 260                         fd = openfd(f);
 261                         if(v->fn)
 262                                 pfmt(fd, "fn %q %s\n", v->name, v->fn[v->pc-1].s);
 263                         closeio(fd);
 264                 }
 265         }
 266 }
 267
 268 void
 269 updenvlocal(var *v)
 270 {
 271         if(v){
 272                 updenvlocal(v->next);
 273                 addenv(v);
 274         }
 275 }
 276
 277 void
 278 Updenv(void)
 279 {
 280         var *v, **h;
 281         for(h = gvar;h!=&gvar[NVAR];h++)
 282                 for(v=*h;v;v = v->next)
 283                         addenv(v);
 284         if(runq)
 285                 updenvlocal(runq->local);
 286 }
 287
 288 /* not used on plan 9 */
 289 int
 290 ForkExecute(char *, char **, int, int, int)
 291 {
 292         return -1;
 293 }
 294
 295 void
 296 Execute(word *args, word *path)
 297 {
 298         char **argv = mkargv(args);
 299         char file[1024];
 300         int nc, mc;
 301
 302         Updenv();
 303         mc = strlen(argv[1])+1;
 304         for(;path;path = path->next){
 305                 nc = strlen(path->word);
 306                 if(nc + mc >= sizeof file - 1){ /* 1 for / */
 307                         werrstr("command path name too long");
 308                         continue;
 309                 }
 310                 if(nc > 0){
 311                         memmove(file, path->word, nc);
 312                         file[nc++] = '/';
 313                 }
 314                 memmove(file+nc, argv[1], mc);
 315                 exec(file, argv+1);
 316         }
 317         rerrstr(file, sizeof file);
 318         setstatus(file);
 319         pfmt(err, "%s: %s\n", argv[1], file);
 320         free(argv);
 321 }
 322 #define NDIR    256             /* shoud be a better way */
 323
 324 int
 325 Globsize(char *p)
 326 {
 327         int isglob = 0, globlen = NDIR+1;
 328         for(;*p;p++){
 329                 if(*p==GLOB){
 330                         p++;
 331                         if(*p!=GLOB)
 332                                 isglob++;
 333                         globlen+=*p=='*'?NDIR:1;
 334                 }
 335                 else
 336                         globlen++;
 337         }
 338         return isglob?globlen:0;
 339 }
 340 #define NFD     50
 341
 342 struct{
 343         Dir     *dbuf;
 344         int     i;
 345         int     n;
 346 }dir[NFD];
 347
 348 int
 349 Opendir(char *name)
 350 {
 351         int f;
 352
 353         if((f = open(name, 0)) < 0)
 354                 return f;
 355         if(f<NFD){
 356                 dir[f].i = 0;
 357                 dir[f].n = 0;
 358         }
 359         return f;
 360 }
 361
 362 static int
 363 trimdirs(Dir *d, int nd)
 364 {
 365         int r, w;
 366
 367         for(r=w=0; r<nd; r++)
 368                 if(d[r].mode&DMDIR)
 369                         d[w++] = d[r];
 370         return w;
 371 }
 372
 373 int
 374 Readdir(int f, void *p, int onlydirs)
 375 {
 376         int n;
 377
 378         if(f<0 || f>=NFD)
 379                 return 0;
 380 Again:
 381         if(dir[f].i==dir[f].n){ /* read */
 382                 free(dir[f].dbuf);
 383                 dir[f].dbuf = 0;
 384                 n = dirread(f, &dir[f].dbuf);
 385                 if(n>0){
 386                         if(onlydirs){
 387                                 n = trimdirs(dir[f].dbuf, n);
 388                                 if(n == 0)
 389                                         goto Again;
 390                         }
 391                         dir[f].n = n;
 392                 }else
 393                         dir[f].n = 0;
 394                 dir[f].i = 0;
 395         }
 396         if(dir[f].i == dir[f].n)
 397                 return 0;
 398         strncpy((char*)p, dir[f].dbuf[dir[f].i].name, NDIR);
 399         dir[f].i++;
 400         return 1;
 401 }
 402
 403 void
 404 Closedir(int f)
 405 {
 406         if(f>=0 && f<NFD){
 407                 free(dir[f].dbuf);
 408                 dir[f].i = 0;
 409                 dir[f].n = 0;
 410                 dir[f].dbuf = 0;
 411         }
 412         close(f);
 413 }
 414 int interrupted = 0;
 415 void
 416 notifyf(void*, char *s)
 417 {
 418         int i;
 419         for(i = 0;syssigname[i];i++) if(strncmp(s, syssigname[i], strlen(syssigname[i]))==0){
 420                 if(strncmp(s, "sys: ", 5)!=0) interrupted = 1;
 421                 goto Out;
 422         }
 423         pfmt(err, "rc: note: %s\n", s);
 424         noted(NDFLT);
 425         return;
 426 Out:
 427         if(strcmp(s, "interrupt")!=0 || trap[i]==0){
 428                 trap[i]++;
 429                 ntrap++;
 430         }
 431         if(ntrap>=32){  /* rc is probably in a trap loop */
 432                 pfmt(err, "rc: Too many traps (trap %s), aborting\n", s);
 433                 abort();
 434         }
 435         noted(NCONT);
 436 }
 437
 438 void
 439 Trapinit(void)
 440 {
 441         notify(notifyf);
 442 }
 443
 444 void
 445 Unlink(char *name)
 446 {
 447         remove(name);
 448 }
 449
 450 long
 451 Write(int fd, void *buf, long cnt)
 452 {
 453         return write(fd, buf, cnt);
 454 }
 455
 456 long
 457 Read(int fd, void *buf, long cnt)
 458 {
 459         return read(fd, buf, cnt);
 460 }
 461
 462 long
 463 Seek(int fd, long cnt, long whence)
 464 {
 465         return seek(fd, cnt, whence);
 466 }
 467
 468 int
 469 Executable(char *file)
 470 {
 471         Dir *statbuf;
 472         int ret;
 473
 474         statbuf = dirstat(file);
 475         if(statbuf == nil)
 476                 return 0;
 477         ret = ((statbuf->mode&0111)!=0 && (statbuf->mode&DMDIR)==0);
 478         free(statbuf);
 479         return ret;
 480 }
 481
 482 int
 483 Creat(char *file)
 484 {
 485         return create(file, 1, 0666L);
 486 }
 487
 488 int
 489 Dup(int a, int b)
 490 {
 491         return dup(a, b);
 492 }
 493
 494 int
 495 Dup1(int)
 496 {
 497         return -1;
 498 }
 499
 500 void
 501 Exit(char *stat)
 502 {
 503         Updenv();
 504         setstatus(stat);
 505         exits(truestatus()?"":getstatus());
 506 }
 507
 508 int
 509 Eintr(void)
 510 {
 511         return interrupted;
 512 }
 513
 514 void
 515 Noerror(void)
 516 {
 517         interrupted = 0;
 518 }
 519
 520 int
 521 Isatty(int fd)
 522 {
 523         char buf[64];
 524
 525         if(fd2path(fd, buf, sizeof buf) != 0)
 526                 return 0;
 527
 528         /* might be #c/cons during boot - fixed 22 april 2005, remove this later */
 529         if(strcmp(buf, "#c/cons") == 0)
 530                 return 1;
 531
 532         /* might be /mnt/term/dev/cons */
 533         return strlen(buf) >= 9 && strcmp(buf+strlen(buf)-9, "/dev/cons") == 0;
 534 }
 535
 536 void
 537 Abort(void)
 538 {
 539         pfmt(err, "aborting\n");
 540         flush(err);
 541         Exit("aborting");
 542 }
 543
 544 int *waitpids;
 545 int nwaitpids;
 546
 547 void
 548 addwaitpid(int pid)
 549 {
 550         waitpids = erealloc(waitpids, (nwaitpids+1)*sizeof waitpids[0]);
 551         waitpids[nwaitpids++] = pid;
 552 }
 553
 554 void
 555 delwaitpid(int pid)
 556 {
 557         int r, w;
 558
 559         for(r=w=0; r<nwaitpids; r++)
 560                 if(waitpids[r] != pid)
 561                         waitpids[w++] = waitpids[r];
 562         nwaitpids = w;
 563 }
 564
 565 void
 566 clearwaitpids(void)
 567 {
 568         nwaitpids = 0;
 569 }
 570
 571 int
 572 havewaitpid(int pid)
 573 {
 574         int i;
 575
 576         for(i=0; i<nwaitpids; i++)
 577                 if(waitpids[i] == pid)
 578                         return 1;
 579         return 0;
 580 }
 581
 582 /* avoid loading any floating-point library code */
 583 int
 584 _efgfmt(Fmt *)
 585 {
 586         return -1;
 587 }