udp.c 13 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651
  1. #include "u.h"
  2. #include "../port/lib.h"
  3. #include "mem.h"
  4. #include "dat.h"
  5. #include "fns.h"
  6. #include "../port/error.h"
  7. #include "ip.h"
  8. #include "ipv6.h"
  9. #define DPRINT if(0)print
  10. enum
  11. {
  12. UDP_UDPHDR_SZ = 8,
  13. UDP4_PHDR_OFF = 8,
  14. UDP4_PHDR_SZ = 12,
  15. UDP4_IPHDR_SZ = 20,
  16. UDP6_IPHDR_SZ = 40,
  17. UDP6_PHDR_SZ = 40,
  18. UDP6_PHDR_OFF = 0,
  19. IP_UDPPROTO = 17,
  20. UDP_USEAD7 = 52,
  21. UDP_USEAD6 = 36,
  22. Udprxms = 200,
  23. Udptickms = 100,
  24. Udpmaxxmit = 10,
  25. };
  26. typedef struct Udp4hdr Udp4hdr;
  27. struct Udp4hdr
  28. {
  29. /* ip header */
  30. uchar vihl; /* Version and header length */
  31. uchar tos; /* Type of service */
  32. uchar length[2]; /* packet length */
  33. uchar id[2]; /* Identification */
  34. uchar frag[2]; /* Fragment information */
  35. uchar Unused;
  36. uchar udpproto; /* Protocol */
  37. uchar udpplen[2]; /* Header plus data length */
  38. uchar udpsrc[IPv4addrlen]; /* Ip source */
  39. uchar udpdst[IPv4addrlen]; /* Ip destination */
  40. /* udp header */
  41. uchar udpsport[2]; /* Source port */
  42. uchar udpdport[2]; /* Destination port */
  43. uchar udplen[2]; /* data length */
  44. uchar udpcksum[2]; /* Checksum */
  45. };
  46. typedef struct Udp6hdr Udp6hdr;
  47. struct Udp6hdr {
  48. uchar viclfl[4];
  49. uchar len[2];
  50. uchar nextheader;
  51. uchar hoplimit;
  52. uchar udpsrc[IPaddrlen];
  53. uchar udpdst[IPaddrlen];
  54. /* udp header */
  55. uchar udpsport[2]; /* Source port */
  56. uchar udpdport[2]; /* Destination port */
  57. uchar udplen[2]; /* data length */
  58. uchar udpcksum[2]; /* Checksum */
  59. };
  60. /* MIB II counters */
  61. typedef struct Udpstats Udpstats;
  62. struct Udpstats
  63. {
  64. ulong udpInDatagrams;
  65. ulong udpNoPorts;
  66. ulong udpInErrors;
  67. ulong udpOutDatagrams;
  68. };
  69. typedef struct Udppriv Udppriv;
  70. struct Udppriv
  71. {
  72. Ipht ht;
  73. /* MIB counters */
  74. Udpstats ustats;
  75. /* non-MIB stats */
  76. ulong csumerr; /* checksum errors */
  77. ulong lenerr; /* short packet */
  78. };
  79. void (*etherprofiler)(char *name, int qlen);
  80. void udpkick(void *x, Block *bp);
  81. /*
  82. * protocol specific part of Conv
  83. */
  84. typedef struct Udpcb Udpcb;
  85. struct Udpcb
  86. {
  87. QLock;
  88. uchar headers;
  89. };
  90. static char*
  91. udpconnect(Conv *c, char **argv, int argc)
  92. {
  93. char *e;
  94. Udppriv *upriv;
  95. upriv = c->p->priv;
  96. e = Fsstdconnect(c, argv, argc);
  97. Fsconnected(c, e);
  98. if(e != nil)
  99. return e;
  100. iphtadd(&upriv->ht, c);
  101. return nil;
  102. }
  103. static int
  104. udpstate(Conv *c, char *state, int n)
  105. {
  106. return snprint(state, n, "%s qin %d qout %d",
  107. c->inuse ? "Open" : "Closed",
  108. c->rq ? qlen(c->rq) : 0,
  109. c->wq ? qlen(c->wq) : 0
  110. );
  111. }
  112. static char*
  113. udpannounce(Conv *c, char** argv, int argc)
  114. {
  115. char *e;
  116. Udppriv *upriv;
  117. upriv = c->p->priv;
  118. e = Fsstdannounce(c, argv, argc);
  119. if(e != nil)
  120. return e;
  121. Fsconnected(c, nil);
  122. iphtadd(&upriv->ht, c);
  123. return nil;
  124. }
  125. static void
  126. udpcreate(Conv *c)
  127. {
  128. c->rq = qopen(128*1024, Qmsg, 0, 0);
  129. c->wq = qbypass(udpkick, c);
  130. }
  131. static void
  132. udpclose(Conv *c)
  133. {
  134. Udpcb *ucb;
  135. Udppriv *upriv;
  136. upriv = c->p->priv;
  137. iphtrem(&upriv->ht, c);
  138. c->state = 0;
  139. qclose(c->rq);
  140. qclose(c->wq);
  141. qclose(c->eq);
  142. ipmove(c->laddr, IPnoaddr);
  143. ipmove(c->raddr, IPnoaddr);
  144. c->lport = 0;
  145. c->rport = 0;
  146. ucb = (Udpcb*)c->ptcl;
  147. ucb->headers = 0;
  148. }
  149. void
  150. udpkick(void *x, Block *bp)
  151. {
  152. Conv *c = x;
  153. Udp4hdr *uh4;
  154. Udp6hdr *uh6;
  155. ushort rport;
  156. uchar laddr[IPaddrlen], raddr[IPaddrlen];
  157. Udpcb *ucb;
  158. int dlen, ptcllen;
  159. Udppriv *upriv;
  160. Fs *f;
  161. int version;
  162. Conv *rc;
  163. upriv = c->p->priv;
  164. f = c->p->f;
  165. netlog(c->p->f, Logudp, "udp: kick\n");
  166. if(bp == nil)
  167. return;
  168. ucb = (Udpcb*)c->ptcl;
  169. switch(ucb->headers) {
  170. case 7:
  171. /* get user specified addresses */
  172. bp = pullupblock(bp, UDP_USEAD7);
  173. if(bp == nil)
  174. return;
  175. ipmove(raddr, bp->rp);
  176. bp->rp += IPaddrlen;
  177. ipmove(laddr, bp->rp);
  178. bp->rp += IPaddrlen;
  179. /* pick interface closest to dest */
  180. if(ipforme(f, laddr) != Runi)
  181. findlocalip(f, laddr, raddr);
  182. bp->rp += IPaddrlen; /* Ignore ifc address */
  183. rport = nhgets(bp->rp);
  184. bp->rp += 2+2; /* Ignore local port */
  185. break;
  186. case 6: /* OBS */
  187. /* get user specified addresses */
  188. bp = pullupblock(bp, UDP_USEAD6);
  189. if(bp == nil)
  190. return;
  191. ipmove(raddr, bp->rp);
  192. bp->rp += IPaddrlen;
  193. ipmove(laddr, bp->rp);
  194. bp->rp += IPaddrlen;
  195. /* pick interface closest to dest */
  196. if(ipforme(f, laddr) != Runi)
  197. findlocalip(f, laddr, raddr);
  198. rport = nhgets(bp->rp);
  199. bp->rp += 2+2; /* Ignore local port */
  200. break;
  201. default:
  202. rport = 0;
  203. break;
  204. }
  205. if(ucb->headers) {
  206. if(memcmp(laddr, v4prefix, IPv4off) == 0
  207. || ipcmp(laddr, IPnoaddr) == 0)
  208. version = 4;
  209. else
  210. version = 6;
  211. } else {
  212. if( (memcmp(c->raddr, v4prefix, IPv4off) == 0 &&
  213. memcmp(c->laddr, v4prefix, IPv4off) == 0)
  214. || ipcmp(c->raddr, IPnoaddr) == 0)
  215. version = 4;
  216. else
  217. version = 6;
  218. }
  219. dlen = blocklen(bp);
  220. /* fill in pseudo header and compute checksum */
  221. switch(version){
  222. case V4:
  223. bp = padblock(bp, UDP4_IPHDR_SZ+UDP_UDPHDR_SZ);
  224. if(bp == nil)
  225. return;
  226. uh4 = (Udp4hdr *)(bp->rp);
  227. ptcllen = dlen + UDP_UDPHDR_SZ;
  228. uh4->Unused = 0;
  229. uh4->udpproto = IP_UDPPROTO;
  230. uh4->frag[0] = 0;
  231. uh4->frag[1] = 0;
  232. hnputs(uh4->udpplen, ptcllen);
  233. if(ucb->headers) {
  234. v6tov4(uh4->udpdst, raddr);
  235. hnputs(uh4->udpdport, rport);
  236. v6tov4(uh4->udpsrc, laddr);
  237. rc = nil;
  238. } else {
  239. v6tov4(uh4->udpdst, c->raddr);
  240. hnputs(uh4->udpdport, c->rport);
  241. if(ipcmp(c->laddr, IPnoaddr) == 0)
  242. findlocalip(f, c->laddr, c->raddr);
  243. v6tov4(uh4->udpsrc, c->laddr);
  244. rc = c;
  245. }
  246. hnputs(uh4->udpsport, c->lport);
  247. hnputs(uh4->udplen, ptcllen);
  248. uh4->udpcksum[0] = 0;
  249. uh4->udpcksum[1] = 0;
  250. hnputs(uh4->udpcksum,
  251. ptclcsum(bp, UDP4_PHDR_OFF, dlen+UDP_UDPHDR_SZ+UDP4_PHDR_SZ));
  252. uh4->vihl = IP_VER4;
  253. ipoput4(f, bp, 0, c->ttl, c->tos, rc);
  254. break;
  255. case V6:
  256. bp = padblock(bp, UDP6_IPHDR_SZ+UDP_UDPHDR_SZ);
  257. if(bp == nil)
  258. return;
  259. /*
  260. * using the v6 ip header to create pseudo header
  261. * first then reset it to the normal ip header
  262. */
  263. uh6 = (Udp6hdr *)(bp->rp);
  264. memset(uh6, 0, 8);
  265. ptcllen = dlen + UDP_UDPHDR_SZ;
  266. hnputl(uh6->viclfl, ptcllen);
  267. uh6->hoplimit = IP_UDPPROTO;
  268. if(ucb->headers) {
  269. ipmove(uh6->udpdst, raddr);
  270. hnputs(uh6->udpdport, rport);
  271. ipmove(uh6->udpsrc, laddr);
  272. rc = nil;
  273. } else {
  274. ipmove(uh6->udpdst, c->raddr);
  275. hnputs(uh6->udpdport, c->rport);
  276. if(ipcmp(c->laddr, IPnoaddr) == 0)
  277. findlocalip(f, c->laddr, c->raddr);
  278. ipmove(uh6->udpsrc, c->laddr);
  279. rc = c;
  280. }
  281. hnputs(uh6->udpsport, c->lport);
  282. hnputs(uh6->udplen, ptcllen);
  283. uh6->udpcksum[0] = 0;
  284. uh6->udpcksum[1] = 0;
  285. hnputs(uh6->udpcksum,
  286. ptclcsum(bp, UDP6_PHDR_OFF, dlen+UDP_UDPHDR_SZ+UDP6_PHDR_SZ));
  287. memset(uh6, 0, 8);
  288. uh6->viclfl[0] = IP_VER6;
  289. hnputs(uh6->len, ptcllen);
  290. uh6->nextheader = IP_UDPPROTO;
  291. ipoput6(f, bp, 0, c->ttl, c->tos, rc);
  292. break;
  293. default:
  294. panic("udpkick: version %d", version);
  295. }
  296. upriv->ustats.udpOutDatagrams++;
  297. }
  298. void
  299. udpiput(Proto *udp, Ipifc *ifc, Block *bp)
  300. {
  301. int len;
  302. Udp4hdr *uh4;
  303. Udp6hdr *uh6;
  304. Conv *c;
  305. Udpcb *ucb;
  306. uchar raddr[IPaddrlen], laddr[IPaddrlen];
  307. ushort rport, lport;
  308. Udppriv *upriv;
  309. Fs *f;
  310. int version;
  311. int ottl, oviclfl, olen;
  312. uchar *p;
  313. upriv = udp->priv;
  314. f = udp->f;
  315. upriv->ustats.udpInDatagrams++;
  316. uh4 = (Udp4hdr*)(bp->rp);
  317. version = ((uh4->vihl&0xF0)==IP_VER6) ? 6 : 4;
  318. /* Put back pseudo header for checksum
  319. * (remember old values for icmpnoconv()) */
  320. switch(version) {
  321. case V4:
  322. ottl = uh4->Unused;
  323. uh4->Unused = 0;
  324. len = nhgets(uh4->udplen);
  325. olen = nhgets(uh4->udpplen);
  326. hnputs(uh4->udpplen, len);
  327. v4tov6(raddr, uh4->udpsrc);
  328. v4tov6(laddr, uh4->udpdst);
  329. lport = nhgets(uh4->udpdport);
  330. rport = nhgets(uh4->udpsport);
  331. if(nhgets(uh4->udpcksum)) {
  332. if(ptclcsum(bp, UDP4_PHDR_OFF, len+UDP4_PHDR_SZ)) {
  333. upriv->ustats.udpInErrors++;
  334. netlog(f, Logudp, "udp: checksum error %I\n", raddr);
  335. DPRINT("udp: checksum error %I\n", raddr);
  336. freeblist(bp);
  337. return;
  338. }
  339. }
  340. uh4->Unused = ottl;
  341. hnputs(uh4->udpplen, olen);
  342. break;
  343. case V6:
  344. uh6 = (Udp6hdr*)(bp->rp);
  345. len = nhgets(uh6->udplen);
  346. oviclfl = nhgetl(uh6->viclfl);
  347. olen = nhgets(uh6->len);
  348. ottl = uh6->hoplimit;
  349. ipmove(raddr, uh6->udpsrc);
  350. ipmove(laddr, uh6->udpdst);
  351. lport = nhgets(uh6->udpdport);
  352. rport = nhgets(uh6->udpsport);
  353. memset(uh6, 0, 8);
  354. hnputl(uh6->viclfl, len);
  355. uh6->hoplimit = IP_UDPPROTO;
  356. if(ptclcsum(bp, UDP6_PHDR_OFF, len+UDP6_PHDR_SZ)) {
  357. upriv->ustats.udpInErrors++;
  358. netlog(f, Logudp, "udp: checksum error %I\n", raddr);
  359. DPRINT("udp: checksum error %I\n", raddr);
  360. freeblist(bp);
  361. return;
  362. }
  363. hnputl(uh6->viclfl, oviclfl);
  364. hnputs(uh6->len, olen);
  365. uh6->nextheader = IP_UDPPROTO;
  366. uh6->hoplimit = ottl;
  367. break;
  368. default:
  369. panic("udpiput: version %d", version);
  370. return; /* to avoid a warning */
  371. }
  372. qlock(udp);
  373. c = iphtlook(&upriv->ht, raddr, rport, laddr, lport);
  374. if(c == nil){
  375. /* no converstation found */
  376. upriv->ustats.udpNoPorts++;
  377. qunlock(udp);
  378. netlog(f, Logudp, "udp: no conv %I!%d -> %I!%d\n", raddr, rport,
  379. laddr, lport);
  380. switch(version){
  381. case V4:
  382. icmpnoconv(f, bp);
  383. break;
  384. case V6:
  385. icmphostunr(f, ifc, bp, Icmp6_port_unreach, 0);
  386. break;
  387. default:
  388. panic("udpiput2: version %d", version);
  389. }
  390. freeblist(bp);
  391. return;
  392. }
  393. ucb = (Udpcb*)c->ptcl;
  394. if(c->state == Announced){
  395. if(ucb->headers == 0){
  396. /* create a new conversation */
  397. if(ipforme(f, laddr) != Runi) {
  398. switch(version){
  399. case V4:
  400. v4tov6(laddr, ifc->lifc->local);
  401. break;
  402. case V6:
  403. ipmove(laddr, ifc->lifc->local);
  404. break;
  405. default:
  406. panic("udpiput3: version %d", version);
  407. }
  408. }
  409. c = Fsnewcall(c, raddr, rport, laddr, lport, version);
  410. if(c == nil){
  411. qunlock(udp);
  412. freeblist(bp);
  413. return;
  414. }
  415. iphtadd(&upriv->ht, c);
  416. ucb = (Udpcb*)c->ptcl;
  417. }
  418. }
  419. qlock(c);
  420. qunlock(udp);
  421. /*
  422. * Trim the packet down to data size
  423. */
  424. len -= UDP_UDPHDR_SZ;
  425. switch(version){
  426. case V4:
  427. bp = trimblock(bp, UDP4_IPHDR_SZ+UDP_UDPHDR_SZ, len);
  428. break;
  429. case V6:
  430. bp = trimblock(bp, UDP6_IPHDR_SZ+UDP_UDPHDR_SZ, len);
  431. break;
  432. default:
  433. bp = nil;
  434. panic("udpiput4: version %d", version);
  435. }
  436. if(bp == nil){
  437. qunlock(c);
  438. netlog(f, Logudp, "udp: len err %I.%d -> %I.%d\n", raddr, rport,
  439. laddr, lport);
  440. upriv->lenerr++;
  441. return;
  442. }
  443. netlog(f, Logudpmsg, "udp: %I.%d -> %I.%d l %d\n", raddr, rport,
  444. laddr, lport, len);
  445. switch(ucb->headers){
  446. case 7:
  447. /* pass the src address */
  448. bp = padblock(bp, UDP_USEAD7);
  449. p = bp->rp;
  450. ipmove(p, raddr); p += IPaddrlen;
  451. ipmove(p, laddr); p += IPaddrlen;
  452. ipmove(p, ifc->lifc->local); p += IPaddrlen;
  453. hnputs(p, rport); p += 2;
  454. hnputs(p, lport);
  455. break;
  456. case 6: /* OBS */
  457. /* pass the src address */
  458. bp = padblock(bp, UDP_USEAD6);
  459. p = bp->rp;
  460. ipmove(p, raddr); p += IPaddrlen;
  461. ipmove(p, ipforme(f, laddr)==Runi ? laddr : ifc->lifc->local); p += IPaddrlen;
  462. hnputs(p, rport); p += 2;
  463. hnputs(p, lport);
  464. break;
  465. }
  466. if(bp->next)
  467. bp = concatblock(bp);
  468. if(qfull(c->rq)){
  469. qunlock(c);
  470. netlog(f, Logudp, "udp: qfull %I.%d -> %I.%d\n", raddr, rport,
  471. laddr, lport);
  472. freeblist(bp);
  473. return;
  474. }
  475. qpass(c->rq, bp);
  476. qunlock(c);
  477. }
  478. char*
  479. udpctl(Conv *c, char **f, int n)
  480. {
  481. Udpcb *ucb;
  482. ucb = (Udpcb*)c->ptcl;
  483. if(n == 1){
  484. if(strcmp(f[0], "oldheaders") == 0){ /* OBS */
  485. ucb->headers = 6;
  486. if (up)
  487. print("program %s wrote `oldheaders' to udp "
  488. "ctl file; fix or recompile it\n",
  489. up->text);
  490. return nil;
  491. } else if(strcmp(f[0], "headers") == 0){
  492. ucb->headers = 7; /* new headers format */
  493. return nil;
  494. }
  495. }
  496. return "unknown control request";
  497. }
  498. void
  499. udpadvise(Proto *udp, Block *bp, char *msg)
  500. {
  501. Udp4hdr *h4;
  502. Udp6hdr *h6;
  503. uchar source[IPaddrlen], dest[IPaddrlen];
  504. ushort psource, pdest;
  505. Conv *s, **p;
  506. int version;
  507. h4 = (Udp4hdr*)(bp->rp);
  508. version = ((h4->vihl&0xF0)==IP_VER6) ? 6 : 4;
  509. switch(version) {
  510. case V4:
  511. v4tov6(dest, h4->udpdst);
  512. v4tov6(source, h4->udpsrc);
  513. psource = nhgets(h4->udpsport);
  514. pdest = nhgets(h4->udpdport);
  515. break;
  516. case V6:
  517. h6 = (Udp6hdr*)(bp->rp);
  518. ipmove(dest, h6->udpdst);
  519. ipmove(source, h6->udpsrc);
  520. psource = nhgets(h6->udpsport);
  521. pdest = nhgets(h6->udpdport);
  522. break;
  523. default:
  524. panic("udpadvise: version %d", version);
  525. return; /* to avoid a warning */
  526. }
  527. /* Look for a connection */
  528. qlock(udp);
  529. for(p = udp->conv; *p; p++) {
  530. s = *p;
  531. if(s->rport == pdest)
  532. if(s->lport == psource)
  533. if(ipcmp(s->raddr, dest) == 0)
  534. if(ipcmp(s->laddr, source) == 0){
  535. if(s->ignoreadvice)
  536. break;
  537. qlock(s);
  538. qunlock(udp);
  539. qhangup(s->rq, msg);
  540. qhangup(s->wq, msg);
  541. qunlock(s);
  542. freeblist(bp);
  543. return;
  544. }
  545. }
  546. qunlock(udp);
  547. freeblist(bp);
  548. }
  549. int
  550. udpstats(Proto *udp, char *buf, int len)
  551. {
  552. Udppriv *upriv;
  553. upriv = udp->priv;
  554. return snprint(buf, len, "InDatagrams: %lud\nNoPorts: %lud\nInErrors: %lud\nOutDatagrams: %lud\n",
  555. upriv->ustats.udpInDatagrams,
  556. upriv->ustats.udpNoPorts,
  557. upriv->ustats.udpInErrors,
  558. upriv->ustats.udpOutDatagrams);
  559. }
  560. void
  561. udpinit(Fs *fs)
  562. {
  563. Proto *udp;
  564. udp = smalloc(sizeof(Proto));
  565. udp->priv = smalloc(sizeof(Udppriv));
  566. udp->name = "udp";
  567. udp->connect = udpconnect;
  568. udp->announce = udpannounce;
  569. udp->ctl = udpctl;
  570. udp->state = udpstate;
  571. udp->create = udpcreate;
  572. udp->close = udpclose;
  573. udp->rcv = udpiput;
  574. udp->advise = udpadvise;
  575. udp->stats = udpstats;
  576. udp->ipproto = IP_UDPPROTO;
  577. udp->nc = Nchans;
  578. udp->ptclsize = sizeof(Udpcb);
  579. Fsproto(fs, udp);
  580. }