plan9.c 9.8 KB

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