cs.c 32 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611161216131614161516161617161816191620162116221623162416251626162716281629163016311632163316341635163616371638163916401641164216431644164516461647164816491650165116521653165416551656165716581659166016611662166316641665166616671668166916701671167216731674167516761677167816791680168116821683168416851686168716881689169016911692169316941695169616971698169917001701170217031704170517061707170817091710171117121713171417151716171717181719172017211722172317241725172617271728172917301731173217331734173517361737173817391740174117421743174417451746174717481749175017511752175317541755175617571758175917601761176217631764176517661767176817691770177117721773177417751776177717781779178017811782178317841785178617871788178917901791179217931794179517961797179817991800180118021803180418051806180718081809181018111812181318141815181618171818181918201821182218231824182518261827182818291830183118321833183418351836
  1. #include <u.h>
  2. #include <libc.h>
  3. #include <auth.h>
  4. #include <fcall.h>
  5. #include <bio.h>
  6. #include <ctype.h>
  7. #include <ndb.h>
  8. #include <ip.h>
  9. #include <String.h>
  10. enum
  11. {
  12. Nreply= 20,
  13. Maxreply= 256,
  14. Maxrequest= 128,
  15. Maxpath= 128,
  16. Maxfdata= 8192,
  17. Maxhost= 64, /* maximum host name size */
  18. Maxservice= 64, /* maximum service name size */
  19. Qdir= 0,
  20. Qcs= 1,
  21. };
  22. typedef struct Mfile Mfile;
  23. typedef struct Mlist Mlist;
  24. typedef struct Network Network;
  25. typedef struct Flushreq Flushreq;
  26. typedef struct Job Job;
  27. int vers; /* incremented each clone/attach */
  28. struct Mfile
  29. {
  30. int busy;
  31. char *user;
  32. Qid qid;
  33. int fid;
  34. /*
  35. * current request
  36. */
  37. char *net;
  38. char *host;
  39. char *serv;
  40. char *rem;
  41. /*
  42. * result of the last lookup
  43. */
  44. Network *nextnet;
  45. int nreply;
  46. char *reply[Nreply];
  47. int replylen[Nreply];
  48. };
  49. struct Mlist
  50. {
  51. Mlist *next;
  52. Mfile mf;
  53. };
  54. /*
  55. * active requests
  56. */
  57. struct Job
  58. {
  59. Job *next;
  60. int flushed;
  61. Fcall request;
  62. Fcall reply;
  63. };
  64. Lock joblock;
  65. Job *joblist;
  66. Mlist *mlist;
  67. int mfd[2];
  68. int debug;
  69. int paranoia;
  70. jmp_buf masterjmp; /* return through here after a slave process has been created */
  71. int *isslave; /* *isslave non-zero means this is a slave process */
  72. char *dbfile;
  73. Ndb *db, *netdb;
  74. void rversion(Job*);
  75. void rflush(Job*);
  76. void rattach(Job*, Mfile*);
  77. char* rwalk(Job*, Mfile*);
  78. void ropen(Job*, Mfile*);
  79. void rcreate(Job*, Mfile*);
  80. void rread(Job*, Mfile*);
  81. void rwrite(Job*, Mfile*);
  82. void rclunk(Job*, Mfile*);
  83. void rremove(Job*, Mfile*);
  84. void rstat(Job*, Mfile*);
  85. void rwstat(Job*, Mfile*);
  86. void rauth(Job*);
  87. void sendmsg(Job*, char*);
  88. void error(char*);
  89. void mountinit(char*, char*);
  90. void io(void);
  91. void ndbinit(void);
  92. void netinit(int);
  93. void netadd(char*);
  94. char *genquery(Mfile*, char*);
  95. char* ipinfoquery(Mfile*, char**, int);
  96. int needproto(Network*, Ndbtuple*);
  97. int lookup(Mfile*);
  98. Ndbtuple* reorder(Ndbtuple*, Ndbtuple*);
  99. void ipid(void);
  100. void readipinterfaces(void);
  101. void* emalloc(int);
  102. char* estrdup(char*);
  103. Job* newjob(void);
  104. void freejob(Job*);
  105. void setext(char*, int, char*);
  106. void cleanmf(Mfile*);
  107. extern void paralloc(void);
  108. Lock dblock; /* mutex on database operations */
  109. Lock netlock; /* mutex for netinit() */
  110. char *logfile = "cs";
  111. char *paranoiafile = "cs.paranoia";
  112. char mntpt[Maxpath];
  113. char netndb[Maxpath];
  114. /*
  115. * Network specific translators
  116. */
  117. Ndbtuple* iplookup(Network*, char*, char*, int);
  118. char* iptrans(Ndbtuple*, Network*, char*, char*, int);
  119. Ndbtuple* telcolookup(Network*, char*, char*, int);
  120. char* telcotrans(Ndbtuple*, Network*, char*, char*, int);
  121. Ndbtuple* dnsiplookup(char*, Ndbs*);
  122. struct Network
  123. {
  124. char *net;
  125. Ndbtuple *(*lookup)(Network*, char*, char*, int);
  126. char *(*trans)(Ndbtuple*, Network*, char*, char*, int);
  127. int considered; /* flag: ignored for "net!"? */
  128. int fasttimeouthack; /* flag. was for IL */
  129. Network *next;
  130. };
  131. enum
  132. {
  133. Ntcp = 0,
  134. };
  135. /*
  136. * net doesn't apply to (r)udp, icmp(v6), or telco (for speed).
  137. */
  138. Network network[] = {
  139. [Ntcp] { "tcp", iplookup, iptrans, 0 },
  140. { "udp", iplookup, iptrans, 1 },
  141. { "icmp", iplookup, iptrans, 1 },
  142. { "icmpv6", iplookup, iptrans, 1 },
  143. { "rudp", iplookup, iptrans, 1 },
  144. { "telco", telcolookup, telcotrans, 1 },
  145. { 0 },
  146. };
  147. Lock ipifclock;
  148. Ipifc *ipifcs;
  149. char eaddr[16]; /* ascii ethernet address */
  150. char ipaddr[64]; /* ascii internet address */
  151. uchar ipa[IPaddrlen]; /* binary internet address */
  152. char *mysysname;
  153. Network *netlist; /* networks ordered by preference */
  154. Network *last;
  155. static void
  156. nstrcpy(char *to, char *from, int len)
  157. {
  158. strncpy(to, from, len);
  159. to[len-1] = 0;
  160. }
  161. void
  162. usage(void)
  163. {
  164. fprint(2, "usage: %s [-dn] [-f ndb-file] [-x netmtpt]\n", argv0);
  165. exits("usage");
  166. }
  167. void
  168. main(int argc, char *argv[])
  169. {
  170. int justsetname;
  171. char ext[Maxpath], servefile[Maxpath];
  172. justsetname = 0;
  173. setnetmtpt(mntpt, sizeof(mntpt), nil);
  174. ext[0] = 0;
  175. ARGBEGIN{
  176. case 'd':
  177. debug = 1;
  178. break;
  179. case 'f':
  180. dbfile = EARGF(usage());
  181. break;
  182. case 'n':
  183. justsetname = 1;
  184. break;
  185. case 'x':
  186. setnetmtpt(mntpt, sizeof(mntpt), EARGF(usage()));
  187. setext(ext, sizeof(ext), mntpt);
  188. break;
  189. }ARGEND
  190. USED(argc);
  191. USED(argv);
  192. rfork(RFREND|RFNOTEG);
  193. snprint(servefile, sizeof(servefile), "#s/cs%s", ext);
  194. snprint(netndb, sizeof(netndb), "%s/ndb", mntpt);
  195. unmount(servefile, mntpt);
  196. remove(servefile);
  197. fmtinstall('E', eipfmt);
  198. fmtinstall('I', eipfmt);
  199. fmtinstall('M', eipfmt);
  200. fmtinstall('F', fcallfmt);
  201. ndbinit();
  202. netinit(0);
  203. if(!justsetname){
  204. mountinit(servefile, mntpt);
  205. io();
  206. }
  207. exits(0);
  208. }
  209. /*
  210. * if a mount point is specified, set the cs extention to be the mount point
  211. * with '_'s replacing '/'s
  212. */
  213. void
  214. setext(char *ext, int n, char *p)
  215. {
  216. int i, c;
  217. n--;
  218. for(i = 0; i < n; i++){
  219. c = p[i];
  220. if(c == 0)
  221. break;
  222. if(c == '/')
  223. c = '_';
  224. ext[i] = c;
  225. }
  226. ext[i] = 0;
  227. }
  228. void
  229. mountinit(char *service, char *mntpt)
  230. {
  231. int f;
  232. int p[2];
  233. char buf[32];
  234. if(pipe(p) < 0)
  235. error("pipe failed");
  236. /*
  237. * make a /srv/cs
  238. */
  239. f = create(service, OWRITE|ORCLOSE, 0666);
  240. if(f < 0)
  241. error(service);
  242. snprint(buf, sizeof(buf), "%d", p[1]);
  243. if(write(f, buf, strlen(buf)) != strlen(buf))
  244. error("write /srv/cs");
  245. switch(rfork(RFFDG|RFPROC|RFNAMEG)){
  246. case 0:
  247. close(p[1]);
  248. break;
  249. case -1:
  250. error("fork failed\n");
  251. default:
  252. /*
  253. * put ourselves into the file system
  254. */
  255. close(p[0]);
  256. if(mount(p[1], -1, mntpt, MAFTER, "") < 0)
  257. error("mount failed\n");
  258. _exits(0);
  259. }
  260. mfd[0] = mfd[1] = p[0];
  261. }
  262. void
  263. ndbinit(void)
  264. {
  265. db = ndbopen(dbfile);
  266. if(db == nil)
  267. error("can't open network database");
  268. netdb = ndbopen(netndb);
  269. if(netdb != nil){
  270. netdb->nohash = 1;
  271. db = ndbcat(netdb, db);
  272. }
  273. }
  274. Mfile*
  275. newfid(int fid)
  276. {
  277. Mlist *f, *ff;
  278. Mfile *mf;
  279. ff = 0;
  280. for(f = mlist; f; f = f->next)
  281. if(f->mf.busy && f->mf.fid == fid)
  282. return &f->mf;
  283. else if(!ff && !f->mf.busy)
  284. ff = f;
  285. if(ff == 0){
  286. ff = emalloc(sizeof *f);
  287. ff->next = mlist;
  288. mlist = ff;
  289. }
  290. mf = &ff->mf;
  291. memset(mf, 0, sizeof *mf);
  292. mf->fid = fid;
  293. return mf;
  294. }
  295. Job*
  296. newjob(void)
  297. {
  298. Job *job;
  299. job = mallocz(sizeof(Job), 1);
  300. lock(&joblock);
  301. job->next = joblist;
  302. joblist = job;
  303. job->request.tag = -1;
  304. unlock(&joblock);
  305. return job;
  306. }
  307. void
  308. freejob(Job *job)
  309. {
  310. Job **l;
  311. lock(&joblock);
  312. for(l = &joblist; *l; l = &(*l)->next){
  313. if((*l) == job){
  314. *l = job->next;
  315. free(job);
  316. break;
  317. }
  318. }
  319. unlock(&joblock);
  320. }
  321. void
  322. flushjob(int tag)
  323. {
  324. Job *job;
  325. lock(&joblock);
  326. for(job = joblist; job; job = job->next){
  327. if(job->request.tag == tag && job->request.type != Tflush){
  328. job->flushed = 1;
  329. break;
  330. }
  331. }
  332. unlock(&joblock);
  333. }
  334. void
  335. io(void)
  336. {
  337. long n;
  338. Mfile *mf;
  339. int slaveflag;
  340. uchar mdata[IOHDRSZ + Maxfdata];
  341. Job *job;
  342. /*
  343. * if we ask dns to fulfill requests,
  344. * a slave process is created to wait for replies. The
  345. * master process returns immediately via a longjmp
  346. * through 'masterjmp'.
  347. *
  348. * *isslave is a pointer into the call stack to a variable
  349. * that tells whether or not the current process is a slave.
  350. */
  351. slaveflag = 0; /* init slave variable */
  352. isslave = &slaveflag;
  353. setjmp(masterjmp);
  354. for(;;){
  355. n = read9pmsg(mfd[0], mdata, sizeof mdata);
  356. if(n<=0)
  357. error("mount read");
  358. job = newjob();
  359. if(convM2S(mdata, n, &job->request) != n){
  360. syslog(1, logfile, "format error %ux %ux %ux %ux %ux",
  361. mdata[0], mdata[1], mdata[2], mdata[3], mdata[4]);
  362. freejob(job);
  363. continue;
  364. }
  365. lock(&dblock);
  366. mf = newfid(job->request.fid);
  367. if(debug)
  368. syslog(0, logfile, "%F", &job->request);
  369. switch(job->request.type){
  370. default:
  371. syslog(1, logfile, "unknown request type %d", job->request.type);
  372. break;
  373. case Tversion:
  374. rversion(job);
  375. break;
  376. case Tauth:
  377. rauth(job);
  378. break;
  379. case Tflush:
  380. rflush(job);
  381. break;
  382. case Tattach:
  383. rattach(job, mf);
  384. break;
  385. case Twalk:
  386. rwalk(job, mf);
  387. break;
  388. case Topen:
  389. ropen(job, mf);
  390. break;
  391. case Tcreate:
  392. rcreate(job, mf);
  393. break;
  394. case Tread:
  395. rread(job, mf);
  396. break;
  397. case Twrite:
  398. rwrite(job, mf);
  399. break;
  400. case Tclunk:
  401. rclunk(job, mf);
  402. break;
  403. case Tremove:
  404. rremove(job, mf);
  405. break;
  406. case Tstat:
  407. rstat(job, mf);
  408. break;
  409. case Twstat:
  410. rwstat(job, mf);
  411. break;
  412. }
  413. unlock(&dblock);
  414. freejob(job);
  415. /*
  416. * slave processes die after replying
  417. */
  418. if(*isslave){
  419. if(debug)
  420. syslog(0, logfile, "slave death %d", getpid());
  421. _exits(0);
  422. }
  423. }
  424. }
  425. void
  426. rversion(Job *job)
  427. {
  428. if(job->request.msize > IOHDRSZ + Maxfdata)
  429. job->reply.msize = IOHDRSZ + Maxfdata;
  430. else
  431. job->reply.msize = job->request.msize;
  432. if(strncmp(job->request.version, "9P2000", 6) != 0)
  433. sendmsg(job, "unknown 9P version");
  434. else{
  435. job->reply.version = "9P2000";
  436. sendmsg(job, 0);
  437. }
  438. }
  439. void
  440. rauth(Job *job)
  441. {
  442. sendmsg(job, "cs: authentication not required");
  443. }
  444. /*
  445. * don't flush till all the slaves are done
  446. */
  447. void
  448. rflush(Job *job)
  449. {
  450. flushjob(job->request.oldtag);
  451. sendmsg(job, 0);
  452. }
  453. void
  454. rattach(Job *job, Mfile *mf)
  455. {
  456. if(mf->busy == 0){
  457. mf->busy = 1;
  458. mf->user = estrdup(job->request.uname);
  459. }
  460. mf->qid.vers = vers++;
  461. mf->qid.type = QTDIR;
  462. mf->qid.path = 0LL;
  463. job->reply.qid = mf->qid;
  464. sendmsg(job, 0);
  465. }
  466. char*
  467. rwalk(Job *job, Mfile *mf)
  468. {
  469. char *err;
  470. char **elems;
  471. int nelems;
  472. int i;
  473. Mfile *nmf;
  474. Qid qid;
  475. err = 0;
  476. nmf = nil;
  477. elems = job->request.wname;
  478. nelems = job->request.nwname;
  479. job->reply.nwqid = 0;
  480. if(job->request.newfid != job->request.fid){
  481. /* clone fid */
  482. nmf = newfid(job->request.newfid);
  483. if(nmf->busy){
  484. nmf = nil;
  485. err = "clone to used channel";
  486. goto send;
  487. }
  488. *nmf = *mf;
  489. nmf->user = estrdup(mf->user);
  490. nmf->fid = job->request.newfid;
  491. nmf->qid.vers = vers++;
  492. mf = nmf;
  493. }
  494. /* else nmf will be nil */
  495. qid = mf->qid;
  496. if(nelems > 0){
  497. /* walk fid */
  498. for(i=0; i<nelems && i<MAXWELEM; i++){
  499. if((qid.type & QTDIR) == 0){
  500. err = "not a directory";
  501. break;
  502. }
  503. if(strcmp(elems[i], "..") == 0 || strcmp(elems[i], ".") == 0){
  504. qid.type = QTDIR;
  505. qid.path = Qdir;
  506. Found:
  507. job->reply.wqid[i] = qid;
  508. job->reply.nwqid++;
  509. continue;
  510. }
  511. if(strcmp(elems[i], "cs") == 0){
  512. qid.type = QTFILE;
  513. qid.path = Qcs;
  514. goto Found;
  515. }
  516. err = "file does not exist";
  517. break;
  518. }
  519. }
  520. send:
  521. if(nmf != nil && (err!=nil || job->reply.nwqid<nelems)){
  522. cleanmf(nmf);
  523. free(nmf->user);
  524. nmf->user = 0;
  525. nmf->busy = 0;
  526. nmf->fid = 0;
  527. }
  528. if(err == nil)
  529. mf->qid = qid;
  530. sendmsg(job, err);
  531. return err;
  532. }
  533. void
  534. ropen(Job *job, Mfile *mf)
  535. {
  536. int mode;
  537. char *err;
  538. err = 0;
  539. mode = job->request.mode;
  540. if(mf->qid.type & QTDIR){
  541. if(mode)
  542. err = "permission denied";
  543. }
  544. job->reply.qid = mf->qid;
  545. job->reply.iounit = 0;
  546. sendmsg(job, err);
  547. }
  548. void
  549. rcreate(Job *job, Mfile *mf)
  550. {
  551. USED(mf);
  552. sendmsg(job, "creation permission denied");
  553. }
  554. void
  555. rread(Job *job, Mfile *mf)
  556. {
  557. int i, n, cnt;
  558. long off, toff, clock;
  559. Dir dir;
  560. uchar buf[IOHDRSZ+Maxfdata];
  561. char *err;
  562. n = 0;
  563. err = 0;
  564. off = job->request.offset;
  565. cnt = job->request.count;
  566. if(mf->qid.type & QTDIR){
  567. clock = time(0);
  568. if(off == 0){
  569. memset(&dir, 0, sizeof dir);
  570. dir.name = "cs";
  571. dir.qid.type = QTFILE;
  572. dir.qid.vers = vers;
  573. dir.qid.path = Qcs;
  574. dir.mode = 0666;
  575. dir.length = 0;
  576. dir.uid = mf->user;
  577. dir.gid = mf->user;
  578. dir.muid = mf->user;
  579. dir.atime = clock; /* wrong */
  580. dir.mtime = clock; /* wrong */
  581. n = convD2M(&dir, buf, sizeof buf);
  582. }
  583. job->reply.data = (char*)buf;
  584. } else {
  585. for(;;){
  586. /* look for an answer at the right offset */
  587. toff = 0;
  588. for(i = 0; mf->reply[i] && i < mf->nreply; i++){
  589. n = mf->replylen[i];
  590. if(off < toff + n)
  591. break;
  592. toff += n;
  593. }
  594. if(i < mf->nreply)
  595. break; /* got something to return */
  596. /* try looking up more answers */
  597. if(lookup(mf) == 0){
  598. /* no more */
  599. n = 0;
  600. goto send;
  601. }
  602. }
  603. /* give back a single reply (or part of one) */
  604. job->reply.data = mf->reply[i] + (off - toff);
  605. if(cnt > toff - off + n)
  606. n = toff - off + n;
  607. else
  608. n = cnt;
  609. }
  610. send:
  611. job->reply.count = n;
  612. sendmsg(job, err);
  613. }
  614. void
  615. cleanmf(Mfile *mf)
  616. {
  617. int i;
  618. if(mf->net != nil){
  619. free(mf->net);
  620. mf->net = nil;
  621. }
  622. if(mf->host != nil){
  623. free(mf->host);
  624. mf->host = nil;
  625. }
  626. if(mf->serv != nil){
  627. free(mf->serv);
  628. mf->serv = nil;
  629. }
  630. if(mf->rem != nil){
  631. free(mf->rem);
  632. mf->rem = nil;
  633. }
  634. for(i = 0; i < mf->nreply; i++){
  635. free(mf->reply[i]);
  636. mf->reply[i] = nil;
  637. mf->replylen[i] = 0;
  638. }
  639. mf->nreply = 0;
  640. mf->nextnet = netlist;
  641. }
  642. void
  643. rwrite(Job *job, Mfile *mf)
  644. {
  645. int cnt, n;
  646. char *err;
  647. char *field[4];
  648. char curerr[64];
  649. err = 0;
  650. cnt = job->request.count;
  651. if(mf->qid.type & QTDIR){
  652. err = "can't write directory";
  653. goto send;
  654. }
  655. if(cnt >= Maxrequest){
  656. err = "request too long";
  657. goto send;
  658. }
  659. job->request.data[cnt] = 0;
  660. /*
  661. * toggle debugging
  662. */
  663. if(strncmp(job->request.data, "debug", 5)==0){
  664. debug ^= 1;
  665. syslog(1, logfile, "debug %d", debug);
  666. goto send;
  667. }
  668. /*
  669. * toggle debugging
  670. */
  671. if(strncmp(job->request.data, "paranoia", 8)==0){
  672. paranoia ^= 1;
  673. syslog(1, logfile, "paranoia %d", paranoia);
  674. goto send;
  675. }
  676. /*
  677. * add networks to the default list
  678. */
  679. if(strncmp(job->request.data, "add ", 4)==0){
  680. if(job->request.data[cnt-1] == '\n')
  681. job->request.data[cnt-1] = 0;
  682. netadd(job->request.data+4);
  683. readipinterfaces();
  684. goto send;
  685. }
  686. /*
  687. * refresh all state
  688. */
  689. if(strncmp(job->request.data, "refresh", 7)==0){
  690. netinit(1);
  691. goto send;
  692. }
  693. /* start transaction with a clean slate */
  694. cleanmf(mf);
  695. /*
  696. * look for a general query
  697. */
  698. if(*job->request.data == '!'){
  699. err = genquery(mf, job->request.data+1);
  700. goto send;
  701. }
  702. if(debug)
  703. syslog(0, logfile, "write %s", job->request.data);
  704. if(paranoia)
  705. syslog(0, paranoiafile, "write %s by %s", job->request.data, mf->user);
  706. /*
  707. * break up name
  708. */
  709. n = getfields(job->request.data, field, 4, 1, "!");
  710. switch(n){
  711. case 1:
  712. mf->net = strdup("net");
  713. mf->host = strdup(field[0]);
  714. break;
  715. case 4:
  716. mf->rem = strdup(field[3]);
  717. /* fall through */
  718. case 3:
  719. mf->serv = strdup(field[2]);
  720. /* fall through */
  721. case 2:
  722. mf->host = strdup(field[1]);
  723. mf->net = strdup(field[0]);
  724. break;
  725. }
  726. /*
  727. * do the first net worth of lookup
  728. */
  729. if(lookup(mf) == 0){
  730. rerrstr(curerr, sizeof curerr);
  731. err = curerr;
  732. }
  733. send:
  734. job->reply.count = cnt;
  735. sendmsg(job, err);
  736. }
  737. void
  738. rclunk(Job *job, Mfile *mf)
  739. {
  740. cleanmf(mf);
  741. free(mf->user);
  742. mf->user = 0;
  743. mf->busy = 0;
  744. mf->fid = 0;
  745. sendmsg(job, 0);
  746. }
  747. void
  748. rremove(Job *job, Mfile *mf)
  749. {
  750. USED(mf);
  751. sendmsg(job, "remove permission denied");
  752. }
  753. void
  754. rstat(Job *job, Mfile *mf)
  755. {
  756. Dir dir;
  757. uchar buf[IOHDRSZ+Maxfdata];
  758. memset(&dir, 0, sizeof dir);
  759. if(mf->qid.type & QTDIR){
  760. dir.name = ".";
  761. dir.mode = DMDIR|0555;
  762. } else {
  763. dir.name = "cs";
  764. dir.mode = 0666;
  765. }
  766. dir.qid = mf->qid;
  767. dir.length = 0;
  768. dir.uid = mf->user;
  769. dir.gid = mf->user;
  770. dir.muid = mf->user;
  771. dir.atime = dir.mtime = time(0);
  772. job->reply.nstat = convD2M(&dir, buf, sizeof buf);
  773. job->reply.stat = buf;
  774. sendmsg(job, 0);
  775. }
  776. void
  777. rwstat(Job *job, Mfile *mf)
  778. {
  779. USED(mf);
  780. sendmsg(job, "wstat permission denied");
  781. }
  782. void
  783. sendmsg(Job *job, char *err)
  784. {
  785. int n;
  786. uchar mdata[IOHDRSZ + Maxfdata];
  787. char ename[ERRMAX];
  788. if(err){
  789. job->reply.type = Rerror;
  790. snprint(ename, sizeof(ename), "cs: %s", err);
  791. job->reply.ename = ename;
  792. }else{
  793. job->reply.type = job->request.type+1;
  794. }
  795. job->reply.tag = job->request.tag;
  796. n = convS2M(&job->reply, mdata, sizeof mdata);
  797. if(n == 0){
  798. syslog(1, logfile, "sendmsg convS2M of %F returns 0", &job->reply);
  799. abort();
  800. }
  801. lock(&joblock);
  802. if(job->flushed == 0)
  803. if(write(mfd[1], mdata, n)!=n)
  804. error("mount write");
  805. unlock(&joblock);
  806. if(debug)
  807. syslog(0, logfile, "%F %d", &job->reply, n);
  808. }
  809. void
  810. error(char *s)
  811. {
  812. syslog(1, "cs", "%s: %r", s);
  813. _exits(0);
  814. }
  815. static int
  816. isvalidip(uchar *ip)
  817. {
  818. return ipcmp(ip, IPnoaddr) != 0 && ipcmp(ip, v4prefix) != 0;
  819. }
  820. static uchar loopbacknet[IPaddrlen] = {
  821. 0, 0, 0, 0,
  822. 0, 0, 0, 0,
  823. 0, 0, 0xff, 0xff,
  824. 127, 0, 0, 0
  825. };
  826. static uchar loopbackmask[IPaddrlen] = {
  827. 0xff, 0xff, 0xff, 0xff,
  828. 0xff, 0xff, 0xff, 0xff,
  829. 0xff, 0xff, 0xff, 0xff,
  830. 0xff, 0, 0, 0
  831. };
  832. void
  833. readipinterfaces(void)
  834. {
  835. if(myipaddr(ipa, mntpt) != 0)
  836. ipmove(ipa, IPnoaddr);
  837. sprint(ipaddr, "%I", ipa);
  838. if (debug)
  839. syslog(0, "dns", "ipaddr is %s\n", ipaddr);
  840. }
  841. /*
  842. * get the system name
  843. */
  844. void
  845. ipid(void)
  846. {
  847. uchar addr[6];
  848. Ndbtuple *t, *tt;
  849. char *p, *attr;
  850. Ndbs s;
  851. int f;
  852. char buf[Maxpath];
  853. /* use environment, ether addr, or ipaddr to get system name */
  854. if(mysysname == 0){
  855. /*
  856. * environment has priority.
  857. *
  858. * on the sgi power the default system name
  859. * is the ip address. ignore that.
  860. *
  861. */
  862. p = getenv("sysname");
  863. if(p && *p){
  864. attr = ipattr(p);
  865. if(strcmp(attr, "ip") != 0)
  866. mysysname = strdup(p);
  867. }
  868. /*
  869. * the /net/ndb contains what the network
  870. * figured out from DHCP. use that name if
  871. * there is one.
  872. */
  873. if(mysysname == 0 && netdb != nil){
  874. ndbreopen(netdb);
  875. for(tt = t = ndbparse(netdb); t != nil; t = t->entry){
  876. if(strcmp(t->attr, "sys") == 0){
  877. mysysname = strdup(t->val);
  878. break;
  879. }
  880. }
  881. ndbfree(tt);
  882. }
  883. /* next network database, ip address, and ether address to find a name */
  884. if(mysysname == 0){
  885. t = nil;
  886. if(isvalidip(ipa))
  887. free(ndbgetvalue(db, &s, "ip", ipaddr, "sys", &t));
  888. if(t == nil){
  889. for(f = 0; f < 3; f++){
  890. snprint(buf, sizeof buf, "%s/ether%d", mntpt, f);
  891. if(myetheraddr(addr, buf) >= 0){
  892. snprint(eaddr, sizeof(eaddr), "%E", addr);
  893. free(ndbgetvalue(db, &s, "ether", eaddr, "sys", &t));
  894. if(t != nil)
  895. break;
  896. }
  897. }
  898. }
  899. for(tt = t; tt != nil; tt = tt->entry){
  900. if(strcmp(tt->attr, "sys") == 0){
  901. mysysname = strdup(tt->val);
  902. break;
  903. }
  904. }
  905. ndbfree(t);
  906. }
  907. /* nothing else worked, use the ip address */
  908. if(mysysname == 0 && isvalidip(ipa))
  909. mysysname = strdup(ipaddr);
  910. /* set /dev/sysname if we now know it */
  911. if(mysysname){
  912. f = open("/dev/sysname", OWRITE);
  913. if(f >= 0){
  914. write(f, mysysname, strlen(mysysname));
  915. close(f);
  916. }
  917. }
  918. }
  919. }
  920. /*
  921. * Set up a list of default networks by looking for
  922. * /net/ * /clone.
  923. */
  924. void
  925. netinit(int background)
  926. {
  927. char clone[Maxpath];
  928. Network *np;
  929. static int working;
  930. if(background){
  931. switch(rfork(RFPROC|RFNOTEG|RFMEM|RFNOWAIT)){
  932. case 0:
  933. break;
  934. default:
  935. return;
  936. }
  937. lock(&netlock);
  938. }
  939. /* add the mounted networks to the default list */
  940. for(np = network; np->net; np++){
  941. if(np->considered)
  942. continue;
  943. snprint(clone, sizeof(clone), "%s/%s/clone", mntpt, np->net);
  944. if(access(clone, AEXIST) < 0)
  945. continue;
  946. if(netlist)
  947. last->next = np;
  948. else
  949. netlist = np;
  950. last = np;
  951. np->next = 0;
  952. np->considered = 1;
  953. }
  954. /* find out what our ip address is */
  955. readipinterfaces();
  956. /* set the system name if we need to, these says ip is all we have */
  957. ipid();
  958. if(debug)
  959. syslog(0, logfile, "mysysname %s eaddr %s ipaddr %s ipa %I\n",
  960. mysysname?mysysname:"???", eaddr, ipaddr, ipa);
  961. if(background){
  962. unlock(&netlock);
  963. _exits(0);
  964. }
  965. }
  966. /*
  967. * add networks to the standard list
  968. */
  969. void
  970. netadd(char *p)
  971. {
  972. Network *np;
  973. char *field[12];
  974. int i, n;
  975. n = getfields(p, field, 12, 1, " ");
  976. for(i = 0; i < n; i++){
  977. for(np = network; np->net; np++){
  978. if(strcmp(field[i], np->net) != 0)
  979. continue;
  980. if(np->considered)
  981. break;
  982. if(netlist)
  983. last->next = np;
  984. else
  985. netlist = np;
  986. last = np;
  987. np->next = 0;
  988. np->considered = 1;
  989. }
  990. }
  991. }
  992. int
  993. lookforproto(Ndbtuple *t, char *proto)
  994. {
  995. for(; t != nil; t = t->entry)
  996. if(strcmp(t->attr, "proto") == 0 && strcmp(t->val, proto) == 0)
  997. return 1;
  998. return 0;
  999. }
  1000. /*
  1001. * lookup a request. the network "net" means we should pick the
  1002. * best network to get there.
  1003. */
  1004. int
  1005. lookup(Mfile *mf)
  1006. {
  1007. Network *np;
  1008. char *cp;
  1009. Ndbtuple *nt, *t;
  1010. char reply[Maxreply];
  1011. int i, rv;
  1012. int hack;
  1013. /* open up the standard db files */
  1014. if(db == 0)
  1015. ndbinit();
  1016. if(db == 0)
  1017. error("can't open mf->network database\n");
  1018. rv = 0;
  1019. if(mf->net == nil)
  1020. return 0; /* must have been a genquery */
  1021. if(strcmp(mf->net, "net") == 0){
  1022. /*
  1023. * go through set of default nets
  1024. */
  1025. for(np = mf->nextnet; np; np = np->next){
  1026. nt = (*np->lookup)(np, mf->host, mf->serv, 1);
  1027. if(nt == nil)
  1028. continue;
  1029. hack = np->fasttimeouthack && !lookforproto(nt, np->net);
  1030. for(t = nt; mf->nreply < Nreply && t; t = t->entry){
  1031. cp = (*np->trans)(t, np, mf->serv, mf->rem, hack);
  1032. if(cp){
  1033. /* avoid duplicates */
  1034. for(i = 0; i < mf->nreply; i++)
  1035. if(strcmp(mf->reply[i], cp) == 0)
  1036. break;
  1037. if(i == mf->nreply){
  1038. /* save the reply */
  1039. mf->replylen[mf->nreply] = strlen(cp);
  1040. mf->reply[mf->nreply++] = cp;
  1041. rv++;
  1042. }
  1043. }
  1044. }
  1045. ndbfree(nt);
  1046. np = np->next;
  1047. break;
  1048. }
  1049. mf->nextnet = np;
  1050. return rv;
  1051. }
  1052. /*
  1053. * if not /net, we only get one lookup
  1054. */
  1055. if(mf->nreply != 0)
  1056. return 0;
  1057. /*
  1058. * look for a specific network
  1059. */
  1060. for(np = netlist; np && np->net != nil; np++){
  1061. if(np->fasttimeouthack)
  1062. continue;
  1063. if(strcmp(np->net, mf->net) == 0)
  1064. break;
  1065. }
  1066. if(np && np->net != nil){
  1067. /*
  1068. * known network
  1069. */
  1070. nt = (*np->lookup)(np, mf->host, mf->serv, 1);
  1071. for(t = nt; mf->nreply < Nreply && t; t = t->entry){
  1072. cp = (*np->trans)(t, np, mf->serv, mf->rem, 0);
  1073. if(cp){
  1074. mf->replylen[mf->nreply] = strlen(cp);
  1075. mf->reply[mf->nreply++] = cp;
  1076. rv++;
  1077. }
  1078. }
  1079. ndbfree(nt);
  1080. return rv;
  1081. } else {
  1082. /*
  1083. * not a known network, don't translate host or service
  1084. */
  1085. if(mf->serv)
  1086. snprint(reply, sizeof(reply), "%s/%s/clone %s!%s",
  1087. mntpt, mf->net, mf->host, mf->serv);
  1088. else
  1089. snprint(reply, sizeof(reply), "%s/%s/clone %s",
  1090. mntpt, mf->net, mf->host);
  1091. mf->reply[0] = strdup(reply);
  1092. mf->replylen[0] = strlen(reply);
  1093. mf->nreply = 1;
  1094. return 1;
  1095. }
  1096. }
  1097. /*
  1098. * translate an ip service name into a port number. If it's a numeric port
  1099. * number, look for restricted access.
  1100. *
  1101. * the service '*' needs no translation.
  1102. */
  1103. char*
  1104. ipserv(Network *np, char *name, char *buf, int blen)
  1105. {
  1106. char *p;
  1107. int alpha = 0;
  1108. int restr = 0;
  1109. char port[10];
  1110. Ndbtuple *t, *nt;
  1111. Ndbs s;
  1112. /* '*' means any service */
  1113. if(strcmp(name, "*")==0){
  1114. strcpy(buf, name);
  1115. return buf;
  1116. }
  1117. /* see if it's numeric or symbolic */
  1118. port[0] = 0;
  1119. for(p = name; *p; p++){
  1120. if(isdigit(*p))
  1121. {}
  1122. else if(isalpha(*p) || *p == '-' || *p == '$')
  1123. alpha = 1;
  1124. else
  1125. return 0;
  1126. }
  1127. t = nil;
  1128. p = nil;
  1129. if(alpha){
  1130. p = ndbgetvalue(db, &s, np->net, name, "port", &t);
  1131. if(p == nil)
  1132. return 0;
  1133. } else {
  1134. /* look up only for tcp ports < 1024 to get the restricted
  1135. * attribute
  1136. */
  1137. if(atoi(name) < 1024 && strcmp(np->net, "tcp") == 0)
  1138. p = ndbgetvalue(db, &s, "port", name, "port", &t);
  1139. if(p == nil)
  1140. p = strdup(name);
  1141. }
  1142. if(t){
  1143. for(nt = t; nt; nt = nt->entry)
  1144. if(strcmp(nt->attr, "restricted") == 0)
  1145. restr = 1;
  1146. ndbfree(t);
  1147. }
  1148. snprint(buf, blen, "%s%s", p, restr ? "!r" : "");
  1149. free(p);
  1150. return buf;
  1151. }
  1152. /*
  1153. * lookup an ip attribute
  1154. */
  1155. int
  1156. ipattrlookup(Ndb *db, char *ipa, char *attr, char *val, int vlen)
  1157. {
  1158. Ndbtuple *t, *nt;
  1159. char *alist[2];
  1160. alist[0] = attr;
  1161. t = ndbipinfo(db, "ip", ipa, alist, 1);
  1162. if(t == nil)
  1163. return 0;
  1164. for(nt = t; nt != nil; nt = nt->entry){
  1165. if(strcmp(nt->attr, attr) == 0){
  1166. nstrcpy(val, nt->val, vlen);
  1167. ndbfree(t);
  1168. return 1;
  1169. }
  1170. }
  1171. /* we shouldn't get here */
  1172. ndbfree(t);
  1173. return 0;
  1174. }
  1175. /*
  1176. * lookup (and translate) an ip destination
  1177. */
  1178. Ndbtuple*
  1179. iplookup(Network *np, char *host, char *serv, int nolookup)
  1180. {
  1181. char *attr, *dnsname;
  1182. Ndbtuple *t, *nt;
  1183. Ndbs s;
  1184. char ts[Maxservice];
  1185. char dollar[Maxhost];
  1186. uchar ip[IPaddrlen];
  1187. uchar net[IPaddrlen];
  1188. uchar tnet[IPaddrlen];
  1189. Ipifc *ifc;
  1190. Iplifc *lifc;
  1191. USED(nolookup);
  1192. /*
  1193. * start with the service since it's the most likely to fail
  1194. * and costs the least
  1195. */
  1196. werrstr("can't translate address");
  1197. if(serv==0 || ipserv(np, serv, ts, sizeof ts) == 0){
  1198. werrstr("can't translate service");
  1199. return 0;
  1200. }
  1201. /* for dial strings with no host */
  1202. if(strcmp(host, "*") == 0)
  1203. return ndbnew("ip", "*");
  1204. /*
  1205. * hack till we go v6 :: = 0.0.0.0
  1206. */
  1207. if(strcmp("::", host) == 0)
  1208. return ndbnew("ip", "*");
  1209. /*
  1210. * '$' means the rest of the name is an attribute that we
  1211. * need to search for
  1212. */
  1213. if(*host == '$'){
  1214. if(ipattrlookup(db, ipaddr, host+1, dollar, sizeof dollar))
  1215. host = dollar;
  1216. }
  1217. /*
  1218. * turn '[ip address]' into just 'ip address'
  1219. */
  1220. if(*host == '[' && host[strlen(host)-1] == ']'){
  1221. host++;
  1222. host[strlen(host)-1] = 0;
  1223. }
  1224. /*
  1225. * just accept addresses
  1226. */
  1227. attr = ipattr(host);
  1228. if(strcmp(attr, "ip") == 0)
  1229. return ndbnew("ip", host);
  1230. /*
  1231. * give the domain name server the first opportunity to
  1232. * resolve domain names. if that fails try the database.
  1233. */
  1234. t = 0;
  1235. werrstr("can't translate address");
  1236. if(strcmp(attr, "dom") == 0)
  1237. t = dnsiplookup(host, &s);
  1238. if(t == 0)
  1239. free(ndbgetvalue(db, &s, attr, host, "ip", &t));
  1240. if(t == 0){
  1241. dnsname = ndbgetvalue(db, &s, attr, host, "dom", nil);
  1242. if(dnsname){
  1243. t = dnsiplookup(dnsname, &s);
  1244. free(dnsname);
  1245. }
  1246. }
  1247. if(t == 0)
  1248. t = dnsiplookup(host, &s);
  1249. if(t == 0)
  1250. return 0;
  1251. /*
  1252. * reorder the tuple to have the matched line first and
  1253. * save that in the request structure.
  1254. */
  1255. t = reorder(t, s.t);
  1256. /*
  1257. * reorder according to our interfaces
  1258. */
  1259. lock(&ipifclock);
  1260. for(ifc = ipifcs; ifc != nil; ifc = ifc->next){
  1261. for(lifc = ifc->lifc; lifc != nil; lifc = lifc->next){
  1262. maskip(lifc->ip, lifc->mask, net);
  1263. for(nt = t; nt; nt = nt->entry){
  1264. if(strcmp(nt->attr, "ip") != 0)
  1265. continue;
  1266. parseip(ip, nt->val);
  1267. maskip(ip, lifc->mask, tnet);
  1268. if(memcmp(net, tnet, IPaddrlen) == 0){
  1269. t = reorder(t, nt);
  1270. unlock(&ipifclock);
  1271. return t;
  1272. }
  1273. }
  1274. }
  1275. }
  1276. unlock(&ipifclock);
  1277. return t;
  1278. }
  1279. /*
  1280. * translate an ip address
  1281. */
  1282. char*
  1283. iptrans(Ndbtuple *t, Network *np, char *serv, char *rem, int hack)
  1284. {
  1285. char ts[Maxservice];
  1286. char reply[Maxreply];
  1287. char x[Maxservice];
  1288. if(strcmp(t->attr, "ip") != 0)
  1289. return 0;
  1290. if(serv == 0 || ipserv(np, serv, ts, sizeof ts) == 0){
  1291. werrstr("can't translate service");
  1292. return 0;
  1293. }
  1294. if(rem != nil)
  1295. snprint(x, sizeof(x), "!%s", rem);
  1296. else
  1297. *x = 0;
  1298. if(*t->val == '*')
  1299. snprint(reply, sizeof(reply), "%s/%s/clone %s%s",
  1300. mntpt, np->net, ts, x);
  1301. else
  1302. snprint(reply, sizeof(reply), "%s/%s/clone %s!%s%s%s",
  1303. mntpt, np->net, t->val, ts, x, hack? "!fasttimeout": "");
  1304. return strdup(reply);
  1305. }
  1306. /*
  1307. * lookup a telephone number
  1308. */
  1309. Ndbtuple*
  1310. telcolookup(Network *np, char *host, char *serv, int nolookup)
  1311. {
  1312. Ndbtuple *t;
  1313. Ndbs s;
  1314. USED(np, nolookup, serv);
  1315. werrstr("can't translate address");
  1316. free(ndbgetvalue(db, &s, "sys", host, "telco", &t));
  1317. if(t == 0)
  1318. return ndbnew("telco", host);
  1319. return reorder(t, s.t);
  1320. }
  1321. /*
  1322. * translate a telephone address
  1323. */
  1324. char*
  1325. telcotrans(Ndbtuple *t, Network *np, char *serv, char *rem, int)
  1326. {
  1327. char reply[Maxreply];
  1328. char x[Maxservice];
  1329. if(strcmp(t->attr, "telco") != 0)
  1330. return 0;
  1331. if(rem != nil)
  1332. snprint(x, sizeof(x), "!%s", rem);
  1333. else
  1334. *x = 0;
  1335. if(serv)
  1336. snprint(reply, sizeof(reply), "%s/%s/clone %s!%s%s", mntpt, np->net,
  1337. t->val, serv, x);
  1338. else
  1339. snprint(reply, sizeof(reply), "%s/%s/clone %s%s", mntpt, np->net,
  1340. t->val, x);
  1341. return strdup(reply);
  1342. }
  1343. /*
  1344. * reorder the tuple to put x's line first in the entry
  1345. */
  1346. Ndbtuple*
  1347. reorder(Ndbtuple *t, Ndbtuple *x)
  1348. {
  1349. Ndbtuple *nt;
  1350. Ndbtuple *line;
  1351. /* find start of this entry's line */
  1352. for(line = x; line->entry == line->line; line = line->line)
  1353. ;
  1354. line = line->line;
  1355. if(line == t)
  1356. return t; /* already the first line */
  1357. /* remove this line and everything after it from the entry */
  1358. for(nt = t; nt->entry != line; nt = nt->entry)
  1359. ;
  1360. nt->entry = 0;
  1361. /* make that the start of the entry */
  1362. for(nt = line; nt->entry; nt = nt->entry)
  1363. ;
  1364. nt->entry = t;
  1365. return line;
  1366. }
  1367. /*
  1368. * create a slave process to handle a request to avoid one request blocking
  1369. * another. parent returns to job loop.
  1370. */
  1371. void
  1372. slave(void)
  1373. {
  1374. if(*isslave)
  1375. return; /* we're already a slave process */
  1376. switch(rfork(RFPROC|RFNOTEG|RFMEM|RFNOWAIT)){
  1377. case -1:
  1378. break;
  1379. case 0:
  1380. if(debug)
  1381. syslog(0, logfile, "slave %d", getpid());
  1382. *isslave = 1;
  1383. break;
  1384. default:
  1385. longjmp(masterjmp, 1);
  1386. }
  1387. }
  1388. /*
  1389. * call the dns process and have it try to translate a name
  1390. */
  1391. Ndbtuple*
  1392. dnsiplookup(char *host, Ndbs *s)
  1393. {
  1394. char buf[Maxreply];
  1395. Ndbtuple *t;
  1396. unlock(&dblock);
  1397. /* save the name before starting a slave */
  1398. snprint(buf, sizeof(buf), "%s", host);
  1399. slave();
  1400. if(strcmp(ipattr(buf), "ip") == 0)
  1401. t = dnsquery(mntpt, buf, "ptr");
  1402. else
  1403. t = dnsquery(mntpt, buf, "ip");
  1404. s->t = t;
  1405. if(t == nil){
  1406. rerrstr(buf, sizeof buf);
  1407. if(strstr(buf, "exist"))
  1408. werrstr("can't translate address: %s", buf);
  1409. else if(strstr(buf, "dns failure"))
  1410. werrstr("temporary problem: %s", buf);
  1411. }
  1412. lock(&dblock);
  1413. return t;
  1414. }
  1415. int
  1416. qmatch(Ndbtuple *t, char **attr, char **val, int n)
  1417. {
  1418. int i, found;
  1419. Ndbtuple *nt;
  1420. for(i = 1; i < n; i++){
  1421. found = 0;
  1422. for(nt = t; nt; nt = nt->entry)
  1423. if(strcmp(attr[i], nt->attr) == 0)
  1424. if(strcmp(val[i], "*") == 0
  1425. || strcmp(val[i], nt->val) == 0){
  1426. found = 1;
  1427. break;
  1428. }
  1429. if(found == 0)
  1430. break;
  1431. }
  1432. return i == n;
  1433. }
  1434. void
  1435. qreply(Mfile *mf, Ndbtuple *t)
  1436. {
  1437. Ndbtuple *nt;
  1438. String *s;
  1439. s = s_new();
  1440. for(nt = t; mf->nreply < Nreply && nt; nt = nt->entry){
  1441. s_append(s, nt->attr);
  1442. s_append(s, "=");
  1443. s_append(s, nt->val);
  1444. if(nt->line != nt->entry){
  1445. mf->replylen[mf->nreply] = s_len(s);
  1446. mf->reply[mf->nreply++] = strdup(s_to_c(s));
  1447. s_restart(s);
  1448. } else
  1449. s_append(s, " ");
  1450. }
  1451. s_free(s);
  1452. }
  1453. enum
  1454. {
  1455. Maxattr= 32,
  1456. };
  1457. /*
  1458. * generic query lookup. The query is of one of the following
  1459. * forms:
  1460. *
  1461. * attr1=val1 attr2=val2 attr3=val3 ...
  1462. *
  1463. * returns the matching tuple
  1464. *
  1465. * ipinfo attr=val attr1 attr2 attr3 ...
  1466. *
  1467. * is like ipinfo and returns the attr{1-n}
  1468. * associated with the ip address.
  1469. */
  1470. char*
  1471. genquery(Mfile *mf, char *query)
  1472. {
  1473. int i, n;
  1474. char *p;
  1475. char *attr[Maxattr];
  1476. char *val[Maxattr];
  1477. Ndbtuple *t;
  1478. Ndbs s;
  1479. n = getfields(query, attr, 32, 1, " ");
  1480. if(n == 0)
  1481. return "bad query";
  1482. if(strcmp(attr[0], "ipinfo") == 0)
  1483. return ipinfoquery(mf, attr, n);
  1484. /* parse pairs */
  1485. for(i = 0; i < n; i++){
  1486. p = strchr(attr[i], '=');
  1487. if(p == 0)
  1488. return "bad query";
  1489. *p++ = 0;
  1490. val[i] = p;
  1491. }
  1492. /* give dns a chance */
  1493. if((strcmp(attr[0], "dom") == 0 || strcmp(attr[0], "ip") == 0) && val[0]){
  1494. t = dnsiplookup(val[0], &s);
  1495. if(t){
  1496. if(qmatch(t, attr, val, n)){
  1497. qreply(mf, t);
  1498. ndbfree(t);
  1499. return 0;
  1500. }
  1501. ndbfree(t);
  1502. }
  1503. }
  1504. /* first pair is always the key. It can't be a '*' */
  1505. t = ndbsearch(db, &s, attr[0], val[0]);
  1506. /* search is the and of all the pairs */
  1507. while(t){
  1508. if(qmatch(t, attr, val, n)){
  1509. qreply(mf, t);
  1510. ndbfree(t);
  1511. return 0;
  1512. }
  1513. ndbfree(t);
  1514. t = ndbsnext(&s, attr[0], val[0]);
  1515. }
  1516. return "no match";
  1517. }
  1518. /*
  1519. * resolve an ip address
  1520. */
  1521. static Ndbtuple*
  1522. ipresolve(char *attr, char *host)
  1523. {
  1524. Ndbtuple *t, *nt, **l;
  1525. t = iplookup(&network[Ntcp], host, "*", 0);
  1526. for(l = &t; *l != nil; ){
  1527. nt = *l;
  1528. if(strcmp(nt->attr, "ip") != 0){
  1529. *l = nt->entry;
  1530. nt->entry = nil;
  1531. ndbfree(nt);
  1532. continue;
  1533. }
  1534. strcpy(nt->attr, attr);
  1535. l = &nt->entry;
  1536. }
  1537. return t;
  1538. }
  1539. char*
  1540. ipinfoquery(Mfile *mf, char **list, int n)
  1541. {
  1542. int i, nresolve;
  1543. int resolve[Maxattr];
  1544. Ndbtuple *t, *nt, **l;
  1545. char *attr, *val;
  1546. /* skip 'ipinfo' */
  1547. list++; n--;
  1548. if(n < 1)
  1549. return "bad query";
  1550. /* get search attribute=value, or assume ip=myipaddr */
  1551. attr = *list;
  1552. if((val = strchr(attr, '=')) != nil){
  1553. *val++ = 0;
  1554. list++;
  1555. n--;
  1556. }else{
  1557. attr = "ip";
  1558. val = ipaddr;
  1559. }
  1560. if(n < 1)
  1561. return "bad query";
  1562. /*
  1563. * don't let ndbipinfo resolve the addresses, we're
  1564. * better at it.
  1565. */
  1566. nresolve = 0;
  1567. for(i = 0; i < n; i++)
  1568. if(*list[i] == '@'){ /* @attr=val ? */
  1569. list[i]++;
  1570. resolve[i] = 1; /* we'll resolve it */
  1571. nresolve++;
  1572. } else
  1573. resolve[i] = 0;
  1574. t = ndbipinfo(db, attr, val, list, n);
  1575. if(t == nil)
  1576. return "no match";
  1577. if(nresolve != 0){
  1578. for(l = &t; *l != nil;){
  1579. nt = *l;
  1580. /* already an address? */
  1581. if(strcmp(ipattr(nt->val), "ip") == 0){
  1582. l = &(*l)->entry;
  1583. continue;
  1584. }
  1585. /* user wants it resolved? */
  1586. for(i = 0; i < n; i++)
  1587. if(strcmp(list[i], nt->attr) == 0)
  1588. break;
  1589. if(i >= n || resolve[i] == 0){
  1590. l = &(*l)->entry;
  1591. continue;
  1592. }
  1593. /* resolve address and replace entry */
  1594. *l = ipresolve(nt->attr, nt->val);
  1595. while(*l != nil)
  1596. l = &(*l)->entry;
  1597. *l = nt->entry;
  1598. nt->entry = nil;
  1599. ndbfree(nt);
  1600. }
  1601. }
  1602. /* make it all one line */
  1603. for(nt = t; nt != nil; nt = nt->entry){
  1604. if(nt->entry == nil)
  1605. nt->line = t;
  1606. else
  1607. nt->line = nt->entry;
  1608. }
  1609. qreply(mf, t);
  1610. return nil;
  1611. }
  1612. void*
  1613. emalloc(int size)
  1614. {
  1615. void *x;
  1616. x = malloc(size);
  1617. if(x == nil)
  1618. abort();
  1619. memset(x, 0, size);
  1620. return x;
  1621. }
  1622. char*
  1623. estrdup(char *s)
  1624. {
  1625. int size;
  1626. char *p;
  1627. size = strlen(s)+1;
  1628. p = malloc(size);
  1629. if(p == nil)
  1630. abort();
  1631. memmove(p, s, size);
  1632. return p;
  1633. }