listen.c 7.9 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454
  1. #include <u.h>
  2. #include <libc.h>
  3. #include <auth.h>
  4. #define NAMELEN 64 /* reasonable upper limit for name elements */
  5. typedef struct Service Service;
  6. struct Service
  7. {
  8. char serv[NAMELEN]; /* name of the service */
  9. char remote[3*NAMELEN]; /* address of remote system */
  10. char prog[5*NAMELEN+1]; /* program to execute */
  11. };
  12. typedef struct Announce Announce;
  13. struct Announce
  14. {
  15. Announce *next;
  16. char *a;
  17. int announced;
  18. };
  19. int readstr(char*, char*, char*, int);
  20. void dolisten(char*, char*, int, char*);
  21. void newcall(int, char*, char*, Service*);
  22. int findserv(char*, char*, Service*, char*);
  23. int getserv(char*, char*, Service*);
  24. void error(char*);
  25. void scandir(char*, char*, char*);
  26. void becomenone(void);
  27. void listendir(char*, char*, int);
  28. char listenlog[] = "listen";
  29. int quiet;
  30. char *cpu;
  31. char *proto;
  32. Announce *announcements;
  33. #define SEC 1000
  34. char *namespace;
  35. void
  36. main(int argc, char *argv[])
  37. {
  38. Service *s;
  39. char *protodir;
  40. char *trustdir;
  41. char *servdir;
  42. servdir = 0;
  43. trustdir = 0;
  44. proto = "il";
  45. quiet = 0;
  46. argv0 = argv[0];
  47. cpu = getenv("cputype");
  48. if(cpu == 0)
  49. error("can't get cputype");
  50. ARGBEGIN{
  51. case 'd':
  52. servdir = ARGF();
  53. break;
  54. case 'q':
  55. quiet = 1;
  56. break;
  57. case 't':
  58. trustdir = ARGF();
  59. break;
  60. case 'n':
  61. namespace = ARGF();
  62. break;
  63. default:
  64. error("usage: listen [-d servdir] [-t trustdir] [proto]");
  65. }ARGEND;
  66. if(!servdir && !trustdir)
  67. servdir = "/bin/service";
  68. if(servdir && strlen(servdir) + NAMELEN >= sizeof(s->prog))
  69. error("service directory too long");
  70. if(trustdir && strlen(trustdir) + NAMELEN >= sizeof(s->prog))
  71. error("trusted service directory too long");
  72. switch(argc){
  73. case 1:
  74. proto = argv[0];
  75. break;
  76. case 0:
  77. break;
  78. default:
  79. error("usage: listen [-d servdir] [-t trustdir] [proto]");
  80. }
  81. syslog(0, listenlog, "started");
  82. protodir = proto;
  83. proto = strrchr(proto, '/');
  84. if(proto == 0)
  85. proto = protodir;
  86. else
  87. proto++;
  88. listendir(protodir, servdir, 0);
  89. listendir(protodir, trustdir, 1);
  90. /* command returns */
  91. exits(0);
  92. }
  93. static void
  94. dingdong(void*, char *msg)
  95. {
  96. if(strstr(msg, "alarm") != nil)
  97. noted(NCONT);
  98. noted(NDFLT);
  99. }
  100. void
  101. listendir(char *protodir, char *srvdir, int trusted)
  102. {
  103. int ctl, pid, start;
  104. Announce *a;
  105. char dir[40];
  106. if (srvdir == 0)
  107. return;
  108. /*
  109. * insulate ourselves from later
  110. * changing of console environment variables
  111. * erase privileged crypt state
  112. */
  113. switch(rfork(RFNOTEG|RFPROC|RFFDG|RFNOWAIT|RFENVG|RFNAMEG)) {
  114. case -1:
  115. error("fork");
  116. case 0:
  117. break;
  118. default:
  119. return;
  120. }
  121. if (!trusted)
  122. becomenone();
  123. notify(dingdong);
  124. pid = getpid();
  125. for(;;){
  126. /*
  127. * loop through announcements and process trusted services in
  128. * invoker's ns and untrusted in none's.
  129. */
  130. scandir(proto, protodir, srvdir);
  131. for(a = announcements; a; a = a->next){
  132. if(a->announced > 0)
  133. continue;
  134. sleep((pid*10)%200);
  135. /* a process per service */
  136. switch(pid = rfork(RFFDG|RFPROC)){
  137. case -1:
  138. syslog(1, listenlog, "couldn't fork for %s", a->a);
  139. break;
  140. case 0:
  141. for(;;){
  142. ctl = announce(a->a, dir);
  143. if(ctl < 0) {
  144. syslog(1, listenlog, "giving up on %s: %r", a->a);
  145. exits("ctl");
  146. }
  147. dolisten(proto, dir, ctl, srvdir);
  148. close(ctl);
  149. }
  150. break;
  151. default:
  152. a->announced = pid;
  153. break;
  154. }
  155. }
  156. /* pick up any children that gave up and sleep for at least 60 seconds */
  157. start = time(0);
  158. alarm(60*1000);
  159. while((pid = waitpid()) > 0)
  160. for(a = announcements; a; a = a->next)
  161. if(a->announced == pid)
  162. a->announced = 0;
  163. alarm(0);
  164. start = 60 - (time(0)-start);
  165. if(start > 0)
  166. sleep(start*1000);
  167. }
  168. exits(0);
  169. }
  170. /*
  171. * make a list of all services to announce for
  172. */
  173. void
  174. addannounce(char *fmt, ...)
  175. {
  176. Announce *a, **l;
  177. char str[128];
  178. va_list arg;
  179. va_start(arg, fmt);
  180. vseprint(str, str+sizeof(str), fmt, arg);
  181. va_end(arg);
  182. /* look for duplicate */
  183. l = &announcements;
  184. for(a = announcements; a; a = a->next){
  185. if(strcmp(str, a->a) == 0)
  186. return;
  187. l = &a->next;
  188. }
  189. /* accept it */
  190. a = mallocz(sizeof(*a) + strlen(str) + 1, 1);
  191. if(a == 0)
  192. return;
  193. a->a = ((char*)a)+sizeof(*a);
  194. strcpy(a->a, str);
  195. a->announced = 0;
  196. *l = a;
  197. }
  198. void
  199. scandir(char *proto, char *protodir, char *dname)
  200. {
  201. int fd, i, n, nlen;
  202. Dir *db;
  203. fd = open(dname, OREAD);
  204. if(fd < 0)
  205. return;
  206. nlen = strlen(proto);
  207. while((n=dirread(fd, &db)) > 0){
  208. for(i=0; i<n; i++){
  209. if(db[i].qid.type&QTDIR)
  210. continue;
  211. if(strncmp(db[i].name, proto, nlen) != 0)
  212. continue;
  213. addannounce("%s!*!%s", protodir, db[i].name+nlen);
  214. }
  215. free(db);
  216. }
  217. close(fd);
  218. }
  219. void
  220. becomenone(void)
  221. {
  222. int fd;
  223. fd = open("#c/user", OWRITE);
  224. if(fd < 0 || write(fd, "none", strlen("none")) < 0)
  225. error("can't become none");
  226. close(fd);
  227. if(newns("none", namespace) < 0)
  228. error("can't build namespace");
  229. }
  230. void
  231. dolisten(char *proto, char *dir, int ctl, char *srvdir)
  232. {
  233. Service s;
  234. char ndir[40];
  235. int nctl, data;
  236. for(;;){
  237. /*
  238. * wait for a call (or an error)
  239. */
  240. nctl = listen(dir, ndir);
  241. if(nctl < 0){
  242. if(!quiet)
  243. syslog(1, listenlog, "listen: %r");
  244. return;
  245. }
  246. /*
  247. * start a subprocess for the connection
  248. */
  249. switch(rfork(RFFDG|RFPROC|RFNOWAIT|RFENVG|RFNAMEG|RFNOTEG)){
  250. case -1:
  251. reject(ctl, ndir, "host overloaded");
  252. close(nctl);
  253. continue;
  254. case 0:
  255. /*
  256. * see if we know the service requested
  257. */
  258. memset(&s, 0, sizeof s);
  259. if(!findserv(proto, ndir, &s, srvdir)){
  260. if(!quiet)
  261. syslog(1, listenlog, "%s: unknown service '%s' from '%s': %r",
  262. proto, s.serv, s.remote);
  263. reject(ctl, ndir, "connection refused");
  264. exits(0);
  265. }
  266. data = accept(ctl, ndir);
  267. if(data < 0){
  268. syslog(1, listenlog, "can't open %s/data: %r", ndir);
  269. exits(0);
  270. }
  271. fprint(nctl, "keepalive");
  272. close(ctl);
  273. close(nctl);
  274. newcall(data, proto, ndir, &s);
  275. exits(0);
  276. default:
  277. close(nctl);
  278. break;
  279. }
  280. }
  281. }
  282. /*
  283. * look in the service directory for the service
  284. */
  285. int
  286. findserv(char *proto, char *dir, Service *s, char *srvdir)
  287. {
  288. if(!getserv(proto, dir, s))
  289. return 0;
  290. sprint(s->prog, "%s/%s", srvdir, s->serv);
  291. if(access(s->prog, AEXIST) >= 0)
  292. return 1;
  293. return 0;
  294. }
  295. /*
  296. * get the service name out of the local address
  297. */
  298. int
  299. getserv(char *proto, char *dir, Service *s)
  300. {
  301. char addr[128], *serv, *p;
  302. long n;
  303. readstr(dir, "remote", s->remote, sizeof(s->remote)-1);
  304. if(p = utfrune(s->remote, L'\n'))
  305. *p = '\0';
  306. n = readstr(dir, "local", addr, sizeof(addr)-1);
  307. if(n <= 0)
  308. return 0;
  309. if(p = utfrune(addr, L'\n'))
  310. *p = '\0';
  311. serv = utfrune(addr, L'!');
  312. if(!serv)
  313. serv = "login";
  314. else
  315. serv++;
  316. /*
  317. * disallow service names like
  318. * ../../usr/user/bin/rc/su
  319. */
  320. if(strlen(serv) +strlen(proto) >= NAMELEN || utfrune(serv, L'/') || *serv == '.')
  321. return 0;
  322. sprint(s->serv, "%s%s", proto, serv);
  323. return 1;
  324. }
  325. char *
  326. remoteaddr(char *dir)
  327. {
  328. char buf[128], *p;
  329. int n, fd;
  330. snprint(buf, sizeof buf, "%s/remote", dir);
  331. fd = open(buf, OREAD);
  332. if(fd < 0)
  333. return strdup("");
  334. n = read(fd, buf, sizeof(buf));
  335. close(fd);
  336. if(n > 0){
  337. buf[n] = 0;
  338. p = strchr(buf, '!');
  339. if(p)
  340. *p = 0;
  341. return strdup(buf);
  342. }
  343. return strdup("");
  344. }
  345. void
  346. newcall(int fd, char *proto, char *dir, Service *s)
  347. {
  348. char data[4*NAMELEN];
  349. char *p;
  350. if(!quiet){
  351. if(dir != nil){
  352. p = remoteaddr(dir);
  353. syslog(0, listenlog, "%s call for %s on chan %s (%s)", proto, s->serv, dir, p);
  354. free(p);
  355. } else
  356. syslog(0, listenlog, "%s call for %s on chan %s", proto, s->serv, dir);
  357. }
  358. sprint(data, "%s/data", dir);
  359. bind(data, "/dev/cons", MREPL);
  360. dup(fd, 0);
  361. dup(fd, 1);
  362. dup(fd, 2);
  363. close(fd);
  364. /*
  365. * close all the fds
  366. */
  367. for(fd=3; fd<20; fd++)
  368. close(fd);
  369. execl(s->prog, s->prog, s->serv, proto, dir, 0);
  370. error(s->prog);
  371. }
  372. void
  373. error(char *s)
  374. {
  375. syslog(1, listenlog, "%s: %s: %r", proto, s);
  376. exits(0);
  377. }
  378. /*
  379. * read a string from a device
  380. */
  381. int
  382. readstr(char *dir, char *info, char *s, int len)
  383. {
  384. int n, fd;
  385. char buf[3*NAMELEN+4];
  386. snprint(buf, sizeof buf, "%s/%s", dir, info);
  387. fd = open(buf, OREAD);
  388. if(fd<0)
  389. return 0;
  390. n = read(fd, s, len-1);
  391. if(n<=0){
  392. close(fd);
  393. return -1;
  394. }
  395. s[n] = 0;
  396. close(fd);
  397. return n+1;
  398. }