util.c 18 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002
  1. #include "dat.h"
  2. static char secstore[100]; /* server name */
  3. /* bind in the default network and cs */
  4. static int
  5. bindnetcs(void)
  6. {
  7. int srvfd;
  8. if(access("/net/tcp", AEXIST) < 0)
  9. bind("#I", "/net", MBEFORE);
  10. if(access("/net/cs", AEXIST) < 0){
  11. if((srvfd = open("#s/cs", ORDWR)) >= 0){
  12. if(mount(srvfd, -1, "/net", MBEFORE, "") >= 0)
  13. return 0;
  14. close(srvfd);
  15. }
  16. return -1;
  17. }
  18. return 0;
  19. }
  20. int
  21. _authdial(char *net, char *authdom)
  22. {
  23. int fd, vanilla;
  24. vanilla = net==nil || strcmp(net, "/net")==0;
  25. if(!vanilla || bindnetcs()>=0)
  26. return authdial(net, authdom);
  27. /*
  28. * If we failed to mount /srv/cs, assume that
  29. * we're still bootstrapping the system and dial
  30. * the one auth server passed to us on the command line.
  31. * In normal operation, it is important *not* to do this,
  32. * because the bootstrap auth server is only good for
  33. * a single auth domain.
  34. *
  35. * The ticket request code should really check the
  36. * remote authentication domain too.
  37. */
  38. /* use the auth server passed to us as an arg */
  39. if(authaddr == nil)
  40. return -1;
  41. fd = dial(netmkaddr(authaddr, "tcp", "567"), 0, 0, 0);
  42. if(fd >= 0)
  43. return fd;
  44. return dial(netmkaddr(authaddr, "il", "566"), 0, 0, 0);
  45. }
  46. int
  47. secdial(void)
  48. {
  49. char *p, buf[80], *f[3];
  50. int fd, nf;
  51. p = secstore; /* take it from writehostowner, if set there */
  52. if(*p == 0) /* else use the authserver */
  53. p = "$auth";
  54. if(bindnetcs() >= 0)
  55. return dial(netmkaddr(p, "net", "secstore"), 0, 0, 0);
  56. /* translate $auth ourselves.
  57. * authaddr is something like il!host!566 or tcp!host!567.
  58. * extract host, accounting for a change of format to something
  59. * like il!host or tcp!host or host.
  60. */
  61. if(strcmp(p, "$auth")==0){
  62. if(authaddr == nil)
  63. return -1;
  64. safecpy(buf, authaddr, sizeof buf);
  65. nf = getfields(buf, f, nelem(f), 0, "!");
  66. switch(nf){
  67. default:
  68. return -1;
  69. case 1:
  70. p = f[0];
  71. break;
  72. case 2:
  73. case 3:
  74. p = f[1];
  75. break;
  76. }
  77. }
  78. fd = dial(netmkaddr(p, "tcp", "5356"), 0, 0, 0);
  79. if(fd >= 0)
  80. return fd;
  81. return -1;
  82. }
  83. /*
  84. * prompt user for a key. don't care about memory leaks, runs standalone
  85. */
  86. static Attr*
  87. promptforkey(char *params)
  88. {
  89. char *v;
  90. int fd;
  91. Attr *a, *attr;
  92. char *def;
  93. fd = open("/dev/cons", ORDWR);
  94. if(fd < 0)
  95. sysfatal("opening /dev/cons: %r");
  96. attr = _parseattr(params);
  97. fprint(fd, "\n!Adding key:");
  98. for(a=attr; a; a=a->next)
  99. if(a->type != AttrQuery && a->name[0] != '!')
  100. fprint(fd, " %q=%q", a->name, a->val);
  101. fprint(fd, "\n");
  102. for(a=attr; a; a=a->next){
  103. v = a->name;
  104. if(a->type != AttrQuery || v[0]=='!')
  105. continue;
  106. def = nil;
  107. if(strcmp(v, "user") == 0)
  108. def = getuser();
  109. a->val = readcons(v, def, 0);
  110. if(a->val == nil)
  111. sysfatal("user terminated key input");
  112. a->type = AttrNameval;
  113. }
  114. for(a=attr; a; a=a->next){
  115. v = a->name;
  116. if(a->type != AttrQuery || v[0]!='!')
  117. continue;
  118. def = nil;
  119. if(strcmp(v+1, "user") == 0)
  120. def = getuser();
  121. a->val = readcons(v+1, def, 1);
  122. if(a->val == nil)
  123. sysfatal("user terminated key input");
  124. a->type = AttrNameval;
  125. }
  126. fprint(fd, "!\n");
  127. close(fd);
  128. return attr;
  129. }
  130. /*
  131. * send a key to the mounted factotum
  132. */
  133. static int
  134. sendkey(Attr *attr)
  135. {
  136. int fd, rv;
  137. char buf[1024];
  138. fd = open("/mnt/factotum/ctl", ORDWR);
  139. if(fd < 0)
  140. sysfatal("opening /mnt/factotum/ctl: %r");
  141. rv = fprint(fd, "key %A\n", attr);
  142. read(fd, buf, sizeof buf);
  143. close(fd);
  144. return rv;
  145. }
  146. /* askuser */
  147. void
  148. askuser(char *params)
  149. {
  150. Attr *attr;
  151. attr = promptforkey(params);
  152. if(attr == nil)
  153. sysfatal("no key supplied");
  154. if(sendkey(attr) < 0)
  155. sysfatal("sending key to factotum: %r");
  156. }
  157. ulong conftaggen;
  158. int
  159. canusekey(Fsstate *fss, Key *k)
  160. {
  161. int i;
  162. if(_strfindattr(k->attr, "confirm")){
  163. for(i=0; i<fss->nconf; i++)
  164. if(fss->conf[i].key == k)
  165. return fss->conf[i].canuse;
  166. if(fss->nconf%16 == 0)
  167. fss->conf = erealloc(fss->conf, (fss->nconf+16)*(sizeof(fss->conf[0])));
  168. fss->conf[fss->nconf].key = k;
  169. k->ref++;
  170. fss->conf[fss->nconf].canuse = -1;
  171. fss->conf[fss->nconf].tag = conftaggen++;
  172. fss->nconf++;
  173. return -1;
  174. }
  175. return 1;
  176. }
  177. /* closekey */
  178. void
  179. closekey(Key *k)
  180. {
  181. if(k == nil)
  182. return;
  183. if(--k->ref != 0)
  184. return;
  185. if(k->proto && k->proto->closekey)
  186. (*k->proto->closekey)(k);
  187. _freeattr(k->attr);
  188. _freeattr(k->privattr);
  189. k->attr = (void*)~1;
  190. k->privattr = (void*)~1;
  191. k->proto = nil;
  192. free(k);
  193. }
  194. static uchar*
  195. pstring(uchar *p, uchar *e, char *s)
  196. {
  197. uint n;
  198. if(p == nil)
  199. return nil;
  200. if(s == nil)
  201. s = "";
  202. n = strlen(s);
  203. if(p+n+BIT16SZ >= e)
  204. return nil;
  205. PBIT16(p, n);
  206. p += BIT16SZ;
  207. memmove(p, s, n);
  208. p += n;
  209. return p;
  210. }
  211. static uchar*
  212. pcarray(uchar *p, uchar *e, uchar *s, uint n)
  213. {
  214. if(p == nil)
  215. return nil;
  216. if(s == nil){
  217. if(n > 0)
  218. sysfatal("pcarray");
  219. s = (uchar*)"";
  220. }
  221. if(p+n+BIT16SZ >= e)
  222. return nil;
  223. PBIT16(p, n);
  224. p += BIT16SZ;
  225. memmove(p, s, n);
  226. p += n;
  227. return p;
  228. }
  229. uchar*
  230. convAI2M(AuthInfo *ai, uchar *p, int n)
  231. {
  232. uchar *e = p+n;
  233. p = pstring(p, e, ai->cuid);
  234. p = pstring(p, e, ai->suid);
  235. p = pstring(p, e, ai->cap);
  236. p = pcarray(p, e, ai->secret, ai->nsecret);
  237. return p;
  238. }
  239. int
  240. failure(Fsstate *s, char *fmt, ...)
  241. {
  242. char e[ERRMAX];
  243. va_list arg;
  244. if(fmt == nil)
  245. rerrstr(s->err, sizeof(s->err));
  246. else {
  247. va_start(arg, fmt);
  248. vsnprint(e, sizeof e, fmt, arg);
  249. va_end(arg);
  250. strecpy(s->err, s->err+sizeof(s->err), e);
  251. werrstr(e);
  252. }
  253. flog("%d: failure %s", s->seqnum, s->err);
  254. return RpcFailure;
  255. }
  256. static int
  257. hasqueries(Attr *a)
  258. {
  259. for(; a; a=a->next)
  260. if(a->type == AttrQuery)
  261. return 1;
  262. return 0;
  263. }
  264. char *ignored[] = {
  265. "role",
  266. "disabled",
  267. };
  268. static int
  269. ignoreattr(char *s)
  270. {
  271. int i;
  272. for(i=0; i<nelem(ignored); i++)
  273. if(strcmp(ignored[i], s)==0)
  274. return 1;
  275. return 0;
  276. }
  277. Keyinfo*
  278. mkkeyinfo(Keyinfo *k, Fsstate *fss, Attr *attr)
  279. {
  280. memset(k, 0, sizeof *k);
  281. k->fss = fss;
  282. k->user = fss->sysuser;
  283. if(attr)
  284. k->attr = attr;
  285. else
  286. k->attr = fss->attr;
  287. return k;
  288. }
  289. int
  290. findkey(Key **ret, Keyinfo *ki, char *fmt, ...)
  291. {
  292. int i, s, nmatch;
  293. char buf[1024], *p, *who;
  294. va_list arg;
  295. Attr *a, *attr0, *attr1, *attr2, *attr3, **l;
  296. Key *k;
  297. *ret = nil;
  298. who = ki->user;
  299. attr0 = ki->attr;
  300. if(fmt){
  301. va_start(arg, fmt);
  302. vseprint(buf, buf+sizeof buf, fmt, arg);
  303. va_end(arg);
  304. attr1 = _parseattr(buf);
  305. }else
  306. attr1 = nil;
  307. if(who && strcmp(who, owner) == 0)
  308. who = nil;
  309. if(who){
  310. snprint(buf, sizeof buf, "owner=%q", who);
  311. attr2 = _parseattr(buf);
  312. attr3 = _parseattr("owner=*");
  313. }else
  314. attr2 = attr3 = nil;
  315. p = _strfindattr(attr0, "proto");
  316. if(p == nil)
  317. p = _strfindattr(attr1, "proto");
  318. if(p && findproto(p) == nil){
  319. werrstr("unknown protocol %s", p);
  320. _freeattr(attr1);
  321. _freeattr(attr2);
  322. _freeattr(attr3);
  323. return failure(ki->fss, nil);
  324. }
  325. nmatch = 0;
  326. for(i=0; i<ring->nkey; i++){
  327. k = ring->key[i];
  328. if(_strfindattr(k->attr, "disabled") && !ki->usedisabled)
  329. continue;
  330. if(matchattr(attr0, k->attr, k->privattr) && matchattr(attr1, k->attr, k->privattr)){
  331. /* check ownership */
  332. if(!matchattr(attr2, k->attr, nil) && !matchattr(attr3, k->attr, nil))
  333. continue;
  334. if(nmatch++ < ki->skip)
  335. continue;
  336. if(!ki->noconf){
  337. switch(canusekey(ki->fss, k)){
  338. case -1:
  339. _freeattr(attr1);
  340. return RpcConfirm;
  341. case 0:
  342. continue;
  343. case 1:
  344. break;
  345. }
  346. }
  347. _freeattr(attr1);
  348. _freeattr(attr2);
  349. _freeattr(attr3);
  350. k->ref++;
  351. *ret = k;
  352. return RpcOk;
  353. }
  354. }
  355. flog("%d: no key matches %A %A %A %A", ki->fss->seqnum, attr0, attr1, attr2, attr3);
  356. werrstr("no key matches %A %A", attr0, attr1);
  357. _freeattr(attr2);
  358. _freeattr(attr3);
  359. s = RpcFailure;
  360. if(askforkeys && who==nil && (hasqueries(attr0) || hasqueries(attr1))){
  361. if(nmatch == 0){
  362. attr0 = _copyattr(attr0);
  363. for(l=&attr0; *l; l=&(*l)->next)
  364. ;
  365. *l = attr1;
  366. for(l=&attr0; *l; ){
  367. if(ignoreattr((*l)->name)){
  368. a = *l;
  369. *l = (*l)->next;
  370. a->next = nil;
  371. _freeattr(a);
  372. }else
  373. l = &(*l)->next;
  374. }
  375. attr0 = sortattr(attr0);
  376. snprint(ki->fss->keyinfo, sizeof ki->fss->keyinfo, "%A", attr0);
  377. _freeattr(attr0);
  378. attr1 = nil; /* attr1 was linked to attr0 */
  379. }else
  380. ki->fss->keyinfo[0] = '\0';
  381. s = RpcNeedkey;
  382. }
  383. _freeattr(attr1);
  384. if(s == RpcFailure)
  385. return failure(ki->fss, nil); /* loads error string */
  386. return s;
  387. }
  388. int
  389. findp9authkey(Key **k, Fsstate *fss)
  390. {
  391. char *dom;
  392. Keyinfo ki;
  393. /*
  394. * We don't use fss->attr here because we don't
  395. * care about what the user name is set to, for instance.
  396. */
  397. mkkeyinfo(&ki, fss, nil);
  398. ki.attr = nil;
  399. ki.user = nil;
  400. if(dom = _strfindattr(fss->attr, "dom"))
  401. return findkey(k, &ki, "proto=p9sk1 dom=%q role=server user?", dom);
  402. else
  403. return findkey(k, &ki, "proto=p9sk1 role=server dom? user?");
  404. }
  405. Proto*
  406. findproto(char *name)
  407. {
  408. int i;
  409. for(i=0; prototab[i]; i++)
  410. if(strcmp(name, prototab[i]->name) == 0)
  411. return prototab[i];
  412. return nil;
  413. }
  414. char*
  415. getnvramkey(int flag, char **secstorepw)
  416. {
  417. char *s;
  418. Nvrsafe safe;
  419. char spw[CONFIGLEN+1];
  420. int i;
  421. memset(&safe, 0, sizeof safe);
  422. /*
  423. * readnvram can return -1 meaning nvram wasn't written,
  424. * but safe still holds good data.
  425. */
  426. if(readnvram(&safe, flag)<0 && safe.authid[0]==0)
  427. return nil;
  428. /*
  429. * we're using the config area to hold the secstore
  430. * password. if there's anything there, return it.
  431. */
  432. memmove(spw, safe.config, CONFIGLEN);
  433. spw[CONFIGLEN] = 0;
  434. if(spw[0] != 0)
  435. *secstorepw = estrdup(spw);
  436. /*
  437. * only use nvram key if it is non-zero
  438. */
  439. for(i = 0; i < DESKEYLEN; i++)
  440. if(safe.machkey[i] != 0)
  441. break;
  442. if(i == DESKEYLEN)
  443. return nil;
  444. s = emalloc(512);
  445. fmtinstall('H', encodefmt);
  446. sprint(s, "key proto=p9sk1 user=%q dom=%q !hex=%.*H !password=______",
  447. safe.authid, safe.authdom, DESKEYLEN, safe.machkey);
  448. writehostowner(safe.authid);
  449. return s;
  450. }
  451. int
  452. isclient(char *role)
  453. {
  454. if(role == nil){
  455. werrstr("role not specified");
  456. return -1;
  457. }
  458. if(strcmp(role, "server") == 0)
  459. return 0;
  460. if(strcmp(role, "client") == 0)
  461. return 1;
  462. werrstr("unknown role %q", role);
  463. return -1;
  464. }
  465. static int
  466. hasname(Attr *a0, Attr *a1, char *name)
  467. {
  468. return _findattr(a0, name) || _findattr(a1, name);
  469. }
  470. static int
  471. hasnameval(Attr *a0, Attr *a1, char *name, char *val)
  472. {
  473. Attr *a;
  474. for(a=_findattr(a0, name); a; a=_findattr(a->next, name))
  475. if(strcmp(a->val, val) == 0)
  476. return 1;
  477. for(a=_findattr(a1, name); a; a=_findattr(a->next, name))
  478. if(strcmp(a->val, val) == 0)
  479. return 1;
  480. return 0;
  481. }
  482. int
  483. matchattr(Attr *pat, Attr *a0, Attr *a1)
  484. {
  485. int type;
  486. for(; pat; pat=pat->next){
  487. type = pat->type;
  488. if(ignoreattr(pat->name))
  489. type = AttrDefault;
  490. switch(type){
  491. case AttrQuery: /* name=something be present */
  492. if(!hasname(a0, a1, pat->name))
  493. return 0;
  494. break;
  495. case AttrNameval: /* name=val must be present */
  496. if(!hasnameval(a0, a1, pat->name, pat->val))
  497. return 0;
  498. break;
  499. case AttrDefault: /* name=val must be present if name=anything is present */
  500. if(hasname(a0, a1, pat->name) && !hasnameval(a0, a1, pat->name, pat->val))
  501. return 0;
  502. break;
  503. }
  504. }
  505. return 1;
  506. }
  507. void
  508. memrandom(void *p, int n)
  509. {
  510. uchar *cp;
  511. for(cp = (uchar*)p; n > 0; n--)
  512. *cp++ = fastrand();
  513. }
  514. /*
  515. * keep caphash fd open since opens of it could be disabled
  516. */
  517. static int caphashfd;
  518. void
  519. initcap(void)
  520. {
  521. caphashfd = open("#¤/caphash", OWRITE);
  522. // if(caphashfd < 0)
  523. // fprint(2, "%s: opening #¤/caphash: %r\n", argv0);
  524. }
  525. /*
  526. * create a change uid capability
  527. */
  528. char*
  529. mkcap(char *from, char *to)
  530. {
  531. uchar rand[20];
  532. char *cap;
  533. char *key;
  534. int nfrom, nto;
  535. uchar hash[SHA1dlen];
  536. if(caphashfd < 0)
  537. return nil;
  538. /* create the capability */
  539. nto = strlen(to);
  540. nfrom = strlen(from);
  541. cap = emalloc(nfrom+1+nto+1+sizeof(rand)*3+1);
  542. sprint(cap, "%s@%s", from, to);
  543. memrandom(rand, sizeof(rand));
  544. key = cap+nfrom+1+nto+1;
  545. enc64(key, sizeof(rand)*3, rand, sizeof(rand));
  546. /* hash the capability */
  547. hmac_sha1((uchar*)cap, strlen(cap), (uchar*)key, strlen(key), hash, nil);
  548. /* give the kernel the hash */
  549. key[-1] = '@';
  550. if(write(caphashfd, hash, SHA1dlen) < 0){
  551. free(cap);
  552. return nil;
  553. }
  554. return cap;
  555. }
  556. int
  557. phaseerror(Fsstate *s, char *op)
  558. {
  559. char tmp[32];
  560. werrstr("protocol phase error: %s in state %s", op, phasename(s, s->phase, tmp));
  561. return RpcPhase;
  562. }
  563. char*
  564. phasename(Fsstate *fss, int phase, char *tmp)
  565. {
  566. char *name;
  567. if(fss->phase == Broken)
  568. name = "Broken";
  569. else if(phase == Established)
  570. name = "Established";
  571. else if(phase == Notstarted)
  572. name = "Notstarted";
  573. else if(phase < 0 || phase >= fss->maxphase
  574. || (name = fss->phasename[phase]) == nil){
  575. sprint(tmp, "%d", phase);
  576. name = tmp;
  577. }
  578. return name;
  579. }
  580. static int
  581. outin(char *prompt, char *def, int len)
  582. {
  583. char *s;
  584. s = readcons(prompt, def, 0);
  585. if(s == nil)
  586. return -1;
  587. if(s == nil)
  588. sysfatal("s==nil???");
  589. strncpy(def, s, len);
  590. def[len-1] = 0;
  591. free(s);
  592. return strlen(def);
  593. }
  594. /*
  595. * get host owner and set it
  596. */
  597. void
  598. promptforhostowner(void)
  599. {
  600. char owner[64], *p;
  601. /* hack for bitsy; can't prompt during boot */
  602. if(p = getenv("user")){
  603. writehostowner(p);
  604. free(p);
  605. return;
  606. }
  607. free(p);
  608. strcpy(owner, "none");
  609. do{
  610. outin("user", owner, sizeof(owner));
  611. } while(*owner == 0);
  612. writehostowner(owner);
  613. }
  614. char*
  615. estrappend(char *s, char *fmt, ...)
  616. {
  617. char *t;
  618. va_list arg;
  619. va_start(arg, fmt);
  620. t = vsmprint(fmt, arg);
  621. if(t == nil)
  622. sysfatal("out of memory");
  623. va_end(arg);
  624. s = erealloc(s, strlen(s)+strlen(t)+1);
  625. strcat(s, t);
  626. free(t);
  627. return s;
  628. }
  629. /*
  630. * prompt for a string with a possible default response
  631. */
  632. char*
  633. readcons(char *prompt, char *def, int raw)
  634. {
  635. int fdin, fdout, ctl, n;
  636. char line[10];
  637. char *s;
  638. fdin = open("/dev/cons", OREAD);
  639. if(fdin < 0)
  640. fdin = 0;
  641. fdout = open("/dev/cons", OWRITE);
  642. if(fdout < 0)
  643. fdout = 1;
  644. if(def != nil)
  645. fprint(fdout, "%s[%s]: ", prompt, def);
  646. else
  647. fprint(fdout, "%s: ", prompt);
  648. if(raw){
  649. ctl = open("/dev/consctl", OWRITE);
  650. if(ctl >= 0)
  651. write(ctl, "rawon", 5);
  652. } else
  653. ctl = -1;
  654. s = estrdup("");
  655. for(;;){
  656. n = read(fdin, line, 1);
  657. if(n == 0){
  658. Error:
  659. close(fdin);
  660. close(fdout);
  661. if(ctl >= 0)
  662. close(ctl);
  663. free(s);
  664. return nil;
  665. }
  666. if(n < 0)
  667. goto Error;
  668. if(line[0] == 0x7f)
  669. goto Error;
  670. if(n == 0 || line[0] == '\n' || line[0] == '\r'){
  671. if(raw){
  672. write(ctl, "rawoff", 6);
  673. write(fdout, "\n", 1);
  674. }
  675. close(ctl);
  676. close(fdin);
  677. close(fdout);
  678. if(*s == 0 && def != nil)
  679. s = estrappend(s, "%s", def);
  680. return s;
  681. }
  682. if(line[0] == '\b'){
  683. if(strlen(s) > 0)
  684. s[strlen(s)-1] = 0;
  685. } else if(line[0] == 0x15) { /* ^U: line kill */
  686. if(def != nil)
  687. fprint(fdout, "\n%s[%s]: ", prompt, def);
  688. else
  689. fprint(fdout, "\n%s: ", prompt);
  690. s[0] = 0;
  691. } else {
  692. s = estrappend(s, "%c", line[0]);
  693. }
  694. }
  695. }
  696. /*
  697. * Insert a key into the keyring.
  698. * If the public attributes are identical to some other key, replace that one.
  699. */
  700. int
  701. replacekey(Key *kn, int before)
  702. {
  703. int i;
  704. Key *k;
  705. for(i=0; i<ring->nkey; i++){
  706. k = ring->key[i];
  707. if(matchattr(kn->attr, k->attr, nil) && matchattr(k->attr, kn->attr, nil)){
  708. closekey(k);
  709. kn->ref++;
  710. ring->key[i] = kn;
  711. return 0;
  712. }
  713. }
  714. if(ring->nkey%16 == 0)
  715. ring->key = erealloc(ring->key, (ring->nkey+16)*sizeof(ring->key[0]));
  716. kn->ref++;
  717. if(before){
  718. memmove(ring->key+1, ring->key, ring->nkey*sizeof ring->key[0]);
  719. ring->key[0] = kn;
  720. ring->nkey++;
  721. }else
  722. ring->key[ring->nkey++] = kn;
  723. return 0;
  724. }
  725. char*
  726. safecpy(char *to, char *from, int n)
  727. {
  728. memset(to, 0, n);
  729. if(n == 1)
  730. return to;
  731. if(from==nil)
  732. sysfatal("safecpy called with from==nil, pc=%#p",
  733. getcallerpc(&to));
  734. strncpy(to, from, n-1);
  735. return to;
  736. }
  737. Attr*
  738. setattr(Attr *a, char *fmt, ...)
  739. {
  740. char buf[1024];
  741. va_list arg;
  742. Attr *b;
  743. va_start(arg, fmt);
  744. vseprint(buf, buf+sizeof buf, fmt, arg);
  745. va_end(arg);
  746. b = _parseattr(buf);
  747. a = setattrs(a, b);
  748. setmalloctag(a, getcallerpc(&a));
  749. _freeattr(b);
  750. return a;
  751. }
  752. /*
  753. * add attributes in list b to list a. If any attributes are in
  754. * both lists, replace those in a by those in b.
  755. */
  756. Attr*
  757. setattrs(Attr *a, Attr *b)
  758. {
  759. int found;
  760. Attr **l, *freea;
  761. for(; b; b=b->next){
  762. found = 0;
  763. for(l=&a; *l; ){
  764. if(strcmp(b->name, (*l)->name) == 0){
  765. switch(b->type){
  766. case AttrNameval:
  767. if(!found){
  768. found = 1;
  769. free((*l)->val);
  770. (*l)->val = estrdup(b->val);
  771. (*l)->type = AttrNameval;
  772. l = &(*l)->next;
  773. }else{
  774. freea = *l;
  775. *l = (*l)->next;
  776. freea->next = nil;
  777. _freeattr(freea);
  778. }
  779. break;
  780. case AttrQuery:
  781. goto continue2;
  782. }
  783. }else
  784. l = &(*l)->next;
  785. }
  786. if(found == 0){
  787. *l = _mkattr(b->type, b->name, b->val, nil);
  788. setmalloctag(*l, getcallerpc(&a));
  789. }
  790. continue2:;
  791. }
  792. return a;
  793. }
  794. void
  795. setmalloctaghere(void *v)
  796. {
  797. setmalloctag(v, getcallerpc(&v));
  798. }
  799. Attr*
  800. sortattr(Attr *a)
  801. {
  802. int i;
  803. Attr *anext, *a0, *a1, **l;
  804. if(a == nil || a->next == nil)
  805. return a;
  806. /* cut list in halves */
  807. a0 = nil;
  808. a1 = nil;
  809. i = 0;
  810. for(; a; a=anext){
  811. anext = a->next;
  812. if(i++%2){
  813. a->next = a0;
  814. a0 = a;
  815. }else{
  816. a->next = a1;
  817. a1 = a;
  818. }
  819. }
  820. /* sort */
  821. a0 = sortattr(a0);
  822. a1 = sortattr(a1);
  823. /* merge */
  824. l = &a;
  825. while(a0 || a1){
  826. if(a1==nil){
  827. anext = a0;
  828. a0 = a0->next;
  829. }else if(a0==nil){
  830. anext = a1;
  831. a1 = a1->next;
  832. }else if(strcmp(a0->name, a1->name) < 0){
  833. anext = a0;
  834. a0 = a0->next;
  835. }else{
  836. anext = a1;
  837. a1 = a1->next;
  838. }
  839. *l = anext;
  840. l = &(*l)->next;
  841. }
  842. *l = nil;
  843. return a;
  844. }
  845. int
  846. toosmall(Fsstate *fss, uint n)
  847. {
  848. fss->rpc.nwant = n;
  849. return RpcToosmall;
  850. }
  851. void
  852. writehostowner(char *owner)
  853. {
  854. int fd;
  855. char *s;
  856. if((s = strchr(owner,'@')) != nil){
  857. *s++ = 0;
  858. strncpy(secstore, s, (sizeof secstore)-1);
  859. }
  860. fd = open("#c/hostowner", OWRITE);
  861. if(fd >= 0){
  862. if(fprint(fd, "%s", owner) < 0)
  863. fprint(2, "factotum: setting #c/hostowner to %q: %r\n",
  864. owner);
  865. close(fd);
  866. }
  867. }
  868. int
  869. attrnamefmt(Fmt *fmt)
  870. {
  871. char *b, buf[1024], *ebuf;
  872. Attr *a;
  873. ebuf = buf+sizeof buf;
  874. b = buf;
  875. strcpy(buf, " ");
  876. for(a=va_arg(fmt->args, Attr*); a; a=a->next){
  877. if(a->name == nil)
  878. continue;
  879. b = seprint(b, ebuf, " %q?", a->name);
  880. }
  881. return fmtstrcpy(fmt, buf+1);
  882. }
  883. void
  884. disablekey(Key *k)
  885. {
  886. Attr *a;
  887. if(sflag) /* not on servers */
  888. return;
  889. for(a=k->attr; a; a=a->next){
  890. if(a->type==AttrNameval && strcmp(a->name, "disabled") == 0)
  891. return;
  892. if(a->next == nil)
  893. break;
  894. }
  895. if(a)
  896. a->next = _mkattr(AttrNameval, "disabled", "by.factotum", nil);
  897. else
  898. k->attr = _mkattr(AttrNameval, "disabled", "by.factotum", nil); /* not reached: always a proto attribute */
  899. }