pppoe.c 12 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693
  1. /*
  2. * User-level PPP over Ethernet (PPPoE) client.
  3. * See RFC 2516
  4. */
  5. #include <u.h>
  6. #include <libc.h>
  7. #include <ip.h>
  8. void dumppkt(uchar*);
  9. uchar *findtag(uchar*, int, int*, int);
  10. void hexdump(uchar*, int);
  11. int malformed(uchar*, int, int);
  12. int pppoe(char*);
  13. void execppp(int);
  14. int alarmed;
  15. int debug;
  16. int sessid;
  17. char *keyspec;
  18. int primary;
  19. char *pppnetmtpt;
  20. char *acname;
  21. char *pppname = "/bin/ip/ppp";
  22. char *srvname = "";
  23. char *wantac;
  24. uchar *cookie;
  25. int cookielen;
  26. uchar etherdst[6];
  27. int mtu = 1492;
  28. void
  29. usage(void)
  30. {
  31. fprint(2, "usage: pppoe [-Pd] [-A acname] [-S srvname] [-k keyspec] [-m mtu] [-x pppnet] [ether0]\n");
  32. exits("usage");
  33. }
  34. int
  35. catchalarm(void *a, char *msg)
  36. {
  37. USED(a);
  38. if(strstr(msg, "alarm")){
  39. alarmed = 1;
  40. return 1;
  41. }
  42. if(debug)
  43. fprint(2, "note rcved: %s\n", msg);
  44. return 0;
  45. }
  46. void
  47. main(int argc, char **argv)
  48. {
  49. int fd;
  50. char *dev;
  51. ARGBEGIN{
  52. case 'A':
  53. wantac = EARGF(usage());
  54. break;
  55. case 'P':
  56. primary = 1;
  57. break;
  58. case 'S':
  59. srvname = EARGF(usage());
  60. break;
  61. case 'd':
  62. debug++;
  63. break;
  64. case 'm':
  65. mtu = atoi(EARGF(usage()));
  66. break;
  67. case 'k':
  68. keyspec = EARGF(usage());
  69. break;
  70. case 'x':
  71. pppnetmtpt = EARGF(usage());
  72. break;
  73. default:
  74. usage();
  75. }ARGEND
  76. switch(argc){
  77. default:
  78. usage();
  79. case 0:
  80. dev = "ether0";
  81. break;
  82. case 1:
  83. dev = argv[0];
  84. break;
  85. }
  86. fmtinstall('E', eipfmt);
  87. atnotify(catchalarm, 1);
  88. fd = pppoe(dev);
  89. execppp(fd);
  90. }
  91. typedef struct Etherhdr Etherhdr;
  92. struct Etherhdr {
  93. uchar dst[6];
  94. uchar src[6];
  95. uchar type[2];
  96. };
  97. enum {
  98. EtherHdrSz = 6+6+2,
  99. EtherMintu = 60,
  100. EtherPppoeDiscovery = 0x8863,
  101. EtherPppoeSession = 0x8864,
  102. };
  103. uchar etherbcast[6] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};
  104. int
  105. etherhdr(uchar *pkt, uchar *dst, int type)
  106. {
  107. Etherhdr *eh;
  108. eh = (Etherhdr*)pkt;
  109. memmove(eh->dst, dst, sizeof(eh->dst));
  110. hnputs(eh->type, type);
  111. return EtherHdrSz;
  112. }
  113. typedef struct Pppoehdr Pppoehdr;
  114. struct Pppoehdr {
  115. uchar verstype;
  116. uchar code;
  117. uchar sessid[2];
  118. uchar length[2]; /* of payload */
  119. };
  120. enum {
  121. PppoeHdrSz = 1+1+2+2,
  122. Hdr = EtherHdrSz+PppoeHdrSz,
  123. };
  124. enum {
  125. VersType = 0x11,
  126. /* Discovery codes */
  127. CodeDiscInit = 0x09, /* discovery init */
  128. CodeDiscOffer = 0x07, /* discovery offer */
  129. CodeDiscReq = 0x19, /* discovery request */
  130. CodeDiscSess = 0x65, /* session confirmation */
  131. /* Session codes */
  132. CodeSession = 0x00,
  133. };
  134. int
  135. pppoehdr(uchar *pkt, int code, int sessid)
  136. {
  137. Pppoehdr *ph;
  138. ph = (Pppoehdr*)pkt;
  139. ph->verstype = VersType;
  140. ph->code = code;
  141. hnputs(ph->sessid, sessid);
  142. return PppoeHdrSz;
  143. }
  144. typedef struct Taghdr Taghdr;
  145. struct Taghdr {
  146. uchar type[2];
  147. uchar length[2]; /* of value */
  148. };
  149. enum {
  150. TagEnd = 0x0000, /* end of tag list */
  151. TagSrvName = 0x0101, /* service name */
  152. TagAcName = 0x0102, /* access concentrator name */
  153. TagHostUniq = 0x0103, /* nonce */
  154. TagAcCookie = 0x0104, /* a.c. cookie */
  155. TagVendSpec = 0x0105, /* vendor specific */
  156. TagRelaySessId = 0x0110, /* relay session id */
  157. TagSrvNameErr = 0x0201, /* service name error (ascii) */
  158. TagAcSysErr = 0x0202, /* a.c. system error */
  159. };
  160. int
  161. tag(uchar *pkt, int type, void *value, int nvalue)
  162. {
  163. Taghdr *h;
  164. h = (Taghdr*)pkt;
  165. hnputs(h->type, type);
  166. hnputs(h->length, nvalue);
  167. memmove(pkt+4, value, nvalue);
  168. return 4+nvalue;
  169. }
  170. /* PPPoE Active Discovery Initiation */
  171. int
  172. padi(uchar *pkt)
  173. {
  174. int sz, tagoff;
  175. uchar *length;
  176. sz = 0;
  177. sz += etherhdr(pkt+sz, etherbcast, EtherPppoeDiscovery);
  178. sz += pppoehdr(pkt+sz, CodeDiscInit, 0x0000);
  179. length = pkt+sz-2;
  180. tagoff = sz;
  181. sz += tag(pkt+sz, TagSrvName, srvname, strlen(srvname));
  182. hnputs(length, sz-tagoff);
  183. return sz;
  184. }
  185. /* PPPoE Active Discovery Request */
  186. int
  187. padr(uchar *pkt)
  188. {
  189. int sz, tagoff;
  190. uchar *length;
  191. sz = 0;
  192. sz += etherhdr(pkt+sz, etherdst, EtherPppoeDiscovery);
  193. sz += pppoehdr(pkt+sz, CodeDiscReq, 0x0000);
  194. length = pkt+sz-2;
  195. tagoff = sz;
  196. sz += tag(pkt+sz, TagSrvName, srvname, strlen(srvname));
  197. sz += tag(pkt+sz, TagAcName, acname, strlen(acname));
  198. if(cookie)
  199. sz += tag(pkt+sz, TagAcCookie, cookie, cookielen);
  200. hnputs(length, sz-tagoff);
  201. return sz;
  202. }
  203. void
  204. ewrite(int fd, void *buf, int nbuf)
  205. {
  206. char e[ERRMAX], path[64];
  207. if(write(fd, buf, nbuf) != nbuf){
  208. rerrstr(e, sizeof e);
  209. strcpy(path, "unknown");
  210. fd2path(fd, path, sizeof path);
  211. sysfatal("write %d to %s: %s", nbuf, path, e);
  212. }
  213. }
  214. void*
  215. emalloc(long n)
  216. {
  217. void *v;
  218. v = malloc(n);
  219. if(v == nil)
  220. sysfatal("out of memory");
  221. return v;
  222. }
  223. int
  224. aread(int timeout, int fd, void *buf, int nbuf)
  225. {
  226. int n;
  227. alarmed = 0;
  228. alarm(timeout);
  229. n = read(fd, buf, nbuf);
  230. alarm(0);
  231. if(alarmed)
  232. return -1;
  233. if(n < 0)
  234. sysfatal("read: %r");
  235. if(n == 0)
  236. sysfatal("short read");
  237. return n;
  238. }
  239. int
  240. pktread(int timeout, int fd, void *buf, int nbuf, int (*want)(uchar*))
  241. {
  242. int n, t2;
  243. n = -1;
  244. for(t2=timeout; t2<16000; t2*=2){
  245. while((n = aread(t2, fd, buf, nbuf)) > 0){
  246. if(malformed(buf, n, EtherPppoeDiscovery)){
  247. if(debug)
  248. fprint(2, "dropping pkt: %r\n");
  249. continue;
  250. }
  251. if(debug)
  252. dumppkt(buf);
  253. if(!want(buf)){
  254. if(debug)
  255. fprint(2, "dropping unwanted pkt: %r\n");
  256. continue;
  257. }
  258. break;
  259. }
  260. if(n > 0)
  261. break;
  262. }
  263. return n;
  264. }
  265. int
  266. bad(char *reason)
  267. {
  268. werrstr(reason);
  269. return 0;
  270. }
  271. void*
  272. copy(uchar *s, int len)
  273. {
  274. uchar *v;
  275. v = emalloc(len+1);
  276. memmove(v, s, len);
  277. v[len] = '\0';
  278. return v;
  279. }
  280. void
  281. clearstate(void)
  282. {
  283. sessid = -1;
  284. free(acname);
  285. acname = nil;
  286. free(cookie);
  287. cookie = nil;
  288. }
  289. int
  290. wantoffer(uchar *pkt)
  291. {
  292. int i, len;
  293. uchar *s;
  294. Etherhdr *eh;
  295. Pppoehdr *ph;
  296. eh = (Etherhdr*)pkt;
  297. ph = (Pppoehdr*)(pkt+EtherHdrSz);
  298. if(ph->code != CodeDiscOffer)
  299. return bad("not an offer");
  300. if(nhgets(ph->sessid) != 0x0000)
  301. return bad("bad session id");
  302. for(i=0;; i++){
  303. if((s = findtag(pkt, TagSrvName, &len, i)) == nil)
  304. return bad("no matching service name");
  305. if(len == strlen(srvname) && memcmp(s, srvname, len) == 0)
  306. break;
  307. }
  308. if((s = findtag(pkt, TagAcName, &len, 0)) == nil)
  309. return bad("no ac name");
  310. acname = copy(s, len);
  311. if(wantac && strcmp(acname, wantac) != 0){
  312. free(acname);
  313. return bad("wrong ac name");
  314. }
  315. if(s = findtag(pkt, TagAcCookie, &len, 0)){
  316. cookie = copy(s, len);
  317. cookielen = len;
  318. }
  319. memmove(etherdst, eh->src, sizeof etherdst);
  320. return 1;
  321. }
  322. int
  323. wantsession(uchar *pkt)
  324. {
  325. int len;
  326. uchar *s;
  327. Pppoehdr *ph;
  328. ph = (Pppoehdr*)(pkt+EtherHdrSz);
  329. if(ph->code != CodeDiscSess)
  330. return bad("not a session confirmation");
  331. if(nhgets(ph->sessid) == 0x0000)
  332. return bad("bad session id");
  333. if(findtag(pkt, TagSrvName, &len, 0) == nil)
  334. return bad("no service name");
  335. if(findtag(pkt, TagSrvNameErr, &len, 0))
  336. return bad("service name error");
  337. if(findtag(pkt, TagAcSysErr, &len, 0))
  338. return bad("ac system error");
  339. if((s = findtag(pkt, TagSrvName, &len, 0)) == nil)
  340. return bad("no matching service name");
  341. if(len != strlen(srvname) || memcmp(s, srvname, len) != 0)
  342. return bad("no matching service name");
  343. sessid = nhgets(ph->sessid);
  344. return 1;
  345. }
  346. int
  347. pppoe(char *ether)
  348. {
  349. char buf[64];
  350. uchar pkt[1520];
  351. int dfd, p[2], n, sfd, sz, timeout;
  352. Pppoehdr *ph;
  353. ph = (Pppoehdr*)(pkt+EtherHdrSz);
  354. snprint(buf, sizeof buf, "%s!%d", ether, EtherPppoeDiscovery);
  355. if((dfd = dial(buf, nil, nil, nil)) < 0)
  356. sysfatal("dial %s: %r", buf);
  357. snprint(buf, sizeof buf, "%s!%d", ether, EtherPppoeSession);
  358. if((sfd = dial(buf, nil, nil, nil)) < 0)
  359. sysfatal("dial %s: %r", buf);
  360. for(timeout=250; timeout<16000; timeout*=2){
  361. clearstate();
  362. memset(pkt, 0, sizeof pkt);
  363. sz = padi(pkt);
  364. if(debug)
  365. dumppkt(pkt);
  366. if(sz < EtherMintu)
  367. sz = EtherMintu;
  368. ewrite(dfd, pkt, sz);
  369. if(pktread(timeout, dfd, pkt, sizeof pkt, wantoffer) < 0)
  370. continue;
  371. memset(pkt, 0, sizeof pkt);
  372. sz = padr(pkt);
  373. if(debug)
  374. dumppkt(pkt);
  375. if(sz < EtherMintu)
  376. sz = EtherMintu;
  377. ewrite(dfd, pkt, sz);
  378. if(pktread(timeout, dfd, pkt, sizeof pkt, wantsession) < 0)
  379. continue;
  380. break;
  381. }
  382. if(sessid < 0)
  383. sysfatal("could not establish session");
  384. rfork(RFNOTEG);
  385. if(pipe(p) < 0)
  386. sysfatal("pipe: %r");
  387. switch(fork()){
  388. case -1:
  389. sysfatal("fork: %r");
  390. default:
  391. break;
  392. case 0:
  393. close(p[1]);
  394. while((n = read(p[0], pkt+Hdr, sizeof pkt-Hdr)) > 0){
  395. etherhdr(pkt, etherdst, EtherPppoeSession);
  396. pppoehdr(pkt+EtherHdrSz, 0x00, sessid);
  397. hnputs(pkt+Hdr-2, n);
  398. sz = Hdr+n;
  399. if(debug > 1){
  400. dumppkt(pkt);
  401. hexdump(pkt, sz);
  402. }
  403. if(sz < EtherMintu)
  404. sz = EtherMintu;
  405. if(write(sfd, pkt, sz) < 0){
  406. if(debug)
  407. fprint(2, "write to ether failed: %r");
  408. _exits(nil);
  409. }
  410. }
  411. _exits(nil);
  412. }
  413. switch(fork()){
  414. case -1:
  415. sysfatal("fork: %r");
  416. default:
  417. break;
  418. case 0:
  419. close(p[1]);
  420. while((n = read(sfd, pkt, sizeof pkt)) > 0){
  421. if(malformed(pkt, n, EtherPppoeSession)
  422. || ph->code != 0x00 || nhgets(ph->sessid) != sessid){
  423. if(debug)
  424. fprint(2, "malformed session pkt: %r\n");
  425. if(debug)
  426. dumppkt(pkt);
  427. continue;
  428. }
  429. if(write(p[0], pkt+Hdr, nhgets(ph->length)) < 0){
  430. if(debug)
  431. fprint(2, "write to ppp failed: %r\n");
  432. _exits(nil);
  433. }
  434. }
  435. _exits(nil);
  436. }
  437. close(p[0]);
  438. return p[1];
  439. }
  440. void
  441. execppp(int fd)
  442. {
  443. char *argv[16];
  444. int argc;
  445. char smtu[10];
  446. argc = 0;
  447. argv[argc++] = pppname;
  448. snprint(smtu, sizeof(smtu), "-m%d", mtu);
  449. argv[argc++] = smtu;
  450. argv[argc++] = "-F";
  451. if(debug)
  452. argv[argc++] = "-d";
  453. if(primary)
  454. argv[argc++] = "-P";
  455. if(pppnetmtpt){
  456. argv[argc++] = "-x";
  457. argv[argc++] = pppnetmtpt;
  458. }
  459. if(keyspec){
  460. argv[argc++] = "-k";
  461. argv[argc++] = keyspec;
  462. }
  463. argv[argc] = nil;
  464. dup(fd, 0);
  465. dup(fd, 1);
  466. exec(pppname, argv);
  467. sysfatal("exec: %r");
  468. }
  469. uchar*
  470. findtag(uchar *pkt, int tagtype, int *plen, int skip)
  471. {
  472. int len, sz, totlen;
  473. uchar *tagdat, *v;
  474. Etherhdr *eh;
  475. Pppoehdr *ph;
  476. Taghdr *t;
  477. eh = (Etherhdr*)pkt;
  478. ph = (Pppoehdr*)(pkt+EtherHdrSz);
  479. tagdat = pkt+Hdr;
  480. if(nhgets(eh->type) != EtherPppoeDiscovery)
  481. return nil;
  482. totlen = nhgets(ph->length);
  483. sz = 0;
  484. while(sz+4 <= totlen){
  485. t = (Taghdr*)(tagdat+sz);
  486. v = tagdat+sz+4;
  487. len = nhgets(t->length);
  488. if(sz+4+len > totlen)
  489. break;
  490. if(nhgets(t->type) == tagtype && skip-- == 0){
  491. *plen = len;
  492. return v;
  493. }
  494. sz += 2+2+len;
  495. }
  496. return nil;
  497. }
  498. void
  499. dumptags(uchar *tagdat, int ntagdat)
  500. {
  501. int i,len, sz;
  502. uchar *v;
  503. Taghdr *t;
  504. sz = 0;
  505. while(sz+4 <= ntagdat){
  506. t = (Taghdr*)(tagdat+sz);
  507. v = tagdat+sz+2+2;
  508. len = nhgets(t->length);
  509. if(sz+4+len > ntagdat)
  510. break;
  511. fprint(2, "\t0x%x %d: ", nhgets(t->type), len);
  512. switch(nhgets(t->type)){
  513. case TagEnd:
  514. fprint(2, "end of tag list\n");
  515. break;
  516. case TagSrvName:
  517. fprint(2, "service '%.*s'\n", len, (char*)v);
  518. break;
  519. case TagAcName:
  520. fprint(2, "ac '%.*s'\n", len, (char*)v);
  521. break;
  522. case TagHostUniq:
  523. fprint(2, "nonce ");
  524. Hex:
  525. for(i=0; i<len; i++)
  526. fprint(2, "%.2ux", v[i]);
  527. fprint(2, "\n");
  528. break;
  529. case TagAcCookie:
  530. fprint(2, "ac cookie ");
  531. goto Hex;
  532. case TagVendSpec:
  533. fprint(2, "vend spec ");
  534. goto Hex;
  535. case TagRelaySessId:
  536. fprint(2, "relay ");
  537. goto Hex;
  538. case TagSrvNameErr:
  539. fprint(2, "srverr '%.*s'\n", len, (char*)v);
  540. break;
  541. case TagAcSysErr:
  542. fprint(2, "syserr '%.*s'\n", len, (char*)v);
  543. break;
  544. }
  545. sz += 2+2+len;
  546. }
  547. if(sz != ntagdat)
  548. fprint(2, "warning: only dumped %d of %d bytes\n", sz, ntagdat);
  549. }
  550. void
  551. dumppkt(uchar *pkt)
  552. {
  553. int et;
  554. Etherhdr *eh;
  555. Pppoehdr *ph;
  556. eh = (Etherhdr*)pkt;
  557. ph = (Pppoehdr*)(pkt+EtherHdrSz);
  558. et = nhgets(eh->type);
  559. fprint(2, "%E -> %E type 0x%x\n",
  560. eh->src, eh->dst, et);
  561. switch(et){
  562. case EtherPppoeDiscovery:
  563. case EtherPppoeSession:
  564. fprint(2, "\tvers %d type %d code 0x%x sessid 0x%x length %d\n",
  565. ph->verstype>>4, ph->verstype&15,
  566. ph->code, nhgets(ph->sessid), nhgets(ph->length));
  567. if(et == EtherPppoeDiscovery)
  568. dumptags(pkt+Hdr, nhgets(ph->length));
  569. }
  570. }
  571. int
  572. malformed(uchar *pkt, int n, int wantet)
  573. {
  574. int et;
  575. Etherhdr *eh;
  576. Pppoehdr *ph;
  577. eh = (Etherhdr*)pkt;
  578. ph = (Pppoehdr*)(pkt+EtherHdrSz);
  579. if(n < Hdr || n < Hdr+nhgets(ph->length)){
  580. werrstr("packet too short %d != %d", n, Hdr+nhgets(ph->length));
  581. return 1;
  582. }
  583. et = nhgets(eh->type);
  584. if(et != wantet){
  585. werrstr("wrong ethernet packet type 0x%x != 0x%x", et, wantet);
  586. return 1;
  587. }
  588. return 0;
  589. }
  590. void
  591. hexdump(uchar *a, int na)
  592. {
  593. int i;
  594. char buf[80];
  595. buf[0] = '\0';
  596. for(i=0; i<na; i++){
  597. sprint(buf+strlen(buf), " %.2ux", a[i]);
  598. if(i%16 == 7)
  599. sprint(buf+strlen(buf), " --");
  600. if(i%16==15){
  601. sprint(buf+strlen(buf), "\n");
  602. write(2, buf, strlen(buf));
  603. buf[0] = 0;
  604. }
  605. }
  606. if(i%16){
  607. sprint(buf+strlen(buf), "\n");
  608. write(2, buf, strlen(buf));
  609. }
  610. }