sys/src/9/ip/rudp.c

   1 /*
   2  *  Reliable User Datagram Protocol, currently only for IPv4.
   3  *  This protocol is compatible with UDP's packet format.
   4  *  It could be done over UDP if need be.
   5  */
   6 #include        "u.h"
   7 #include        "../port/lib.h"
   8 #include        "mem.h"
   9 #include        "dat.h"
  10 #include        "fns.h"
  11 #include        "../port/error.h"
  12
  13 #include        "ip.h"
  14
  15 #define DEBUG   0
  16 #define DPRINT if(DEBUG)print
  17
  18 #define SEQDIFF(a,b) ( (a)>=(b)?\
  19                         (a)-(b):\
  20                         0xffffffffUL-((b)-(a)) )
  21 #define INSEQ(a,start,end) ( (start)<=(end)?\
  22                                 ((a)>(start)&&(a)<=(end)):\
  23                                 ((a)>(start)||(a)<=(end)) )
  24 #define UNACKED(r) SEQDIFF(r->sndseq, r->ackrcvd)
  25 #define NEXTSEQ(a) ( (a)+1 == 0 ? 1 : (a)+1 )
  26
  27 enum
  28 {
  29         UDP_PHDRSIZE    = 12,   /* pseudo header */
  30 //      UDP_HDRSIZE     = 20,   /* pseudo header + udp header */
  31         UDP_RHDRSIZE    = 36,   /* pseudo header + udp header + rudp header */
  32         UDP_IPHDR       = 8,    /* ip header */
  33         IP_UDPPROTO     = 254,
  34         UDP_USEAD7      = 52,   /* size of new ipv6 headers struct */
  35
  36         Rudprxms        = 200,
  37         Rudptickms      = 50,
  38         Rudpmaxxmit     = 10,
  39         Maxunacked      = 100,
  40 };
  41
  42 #define Hangupgen       0xffffffff      /* used only in hangup messages */
  43
  44 typedef struct Udphdr Udphdr;
  45 struct Udphdr
  46 {
  47         /* ip header */
  48         uchar   vihl;           /* Version and header length */
  49         uchar   tos;            /* Type of service */
  50         uchar   length[2];      /* packet length */
  51         uchar   id[2];          /* Identification */
  52         uchar   frag[2];        /* Fragment information */
  53
  54         /* pseudo header starts here */
  55         uchar   Unused;
  56         uchar   udpproto;       /* Protocol */
  57         uchar   udpplen[2];     /* Header plus data length */
  58         uchar   udpsrc[4];      /* Ip source */
  59         uchar   udpdst[4];      /* Ip destination */
  60
  61         /* udp header */
  62         uchar   udpsport[2];    /* Source port */
  63         uchar   udpdport[2];    /* Destination port */
  64         uchar   udplen[2];      /* data length */
  65         uchar   udpcksum[2];    /* Checksum */
  66 };
  67
  68 typedef struct Rudphdr Rudphdr;
  69 struct Rudphdr
  70 {
  71         /* ip header */
  72         uchar   vihl;           /* Version and header length */
  73         uchar   tos;            /* Type of service */
  74         uchar   length[2];      /* packet length */
  75         uchar   id[2];          /* Identification */
  76         uchar   frag[2];        /* Fragment information */
  77
  78         /* pseudo header starts here */
  79         uchar   Unused;
  80         uchar   udpproto;       /* Protocol */
  81         uchar   udpplen[2];     /* Header plus data length */
  82         uchar   udpsrc[4];      /* Ip source */
  83         uchar   udpdst[4];      /* Ip destination */
  84
  85         /* udp header */
  86         uchar   udpsport[2];    /* Source port */
  87         uchar   udpdport[2];    /* Destination port */
  88         uchar   udplen[2];      /* data length (includes rudp header) */
  89         uchar   udpcksum[2];    /* Checksum */
  90
  91         /* rudp header */
  92         uchar   relseq[4];      /* id of this packet (or 0) */
  93         uchar   relsgen[4];     /* generation/time stamp */
  94         uchar   relack[4];      /* packet being acked (or 0) */
  95         uchar   relagen[4];     /* generation/time stamp */
  96 };
  97
  98
  99 /*
 100  *  one state structure per destination
 101  */
 102 typedef struct Reliable Reliable;
 103 struct Reliable
 104 {
 105         Ref;
 106
 107         Reliable *next;
 108
 109         uchar   addr[IPaddrlen];        /* always V6 when put here */
 110         ushort  port;
 111
 112         Block   *unacked;       /* unacked msg list */
 113         Block   *unackedtail;   /*  and its tail */
 114
 115         int     timeout;        /* time since first unacked msg sent */
 116         int     xmits;          /* number of times first unacked msg sent */
 117
 118         ulong   sndseq;         /* next packet to be sent */
 119         ulong   sndgen;         /*  and its generation */
 120
 121         ulong   rcvseq;         /* last packet received */
 122         ulong   rcvgen;         /*  and its generation */
 123
 124         ulong   acksent;        /* last ack sent */
 125         ulong   ackrcvd;        /* last msg for which ack was rcvd */
 126
 127         /* flow control */
 128         QLock   lock;
 129         Rendez  vous;
 130         int     blocked;
 131 };
 132
 133
 134
 135 /* MIB II counters */
 136 typedef struct Rudpstats Rudpstats;
 137 struct Rudpstats
 138 {
 139         ulong   rudpInDatagrams;
 140         ulong   rudpNoPorts;
 141         ulong   rudpInErrors;
 142         ulong   rudpOutDatagrams;
 143 };
 144
 145 typedef struct Rudppriv Rudppriv;
 146 struct Rudppriv
 147 {
 148         Ipht    ht;
 149
 150         /* MIB counters */
 151         Rudpstats       ustats;
 152
 153         /* non-MIB stats */
 154         ulong   csumerr;                /* checksum errors */
 155         ulong   lenerr;                 /* short packet */
 156         ulong   rxmits;                 /* # of retransmissions */
 157         ulong   orders;                 /* # of out of order pkts */
 158
 159         /* keeping track of the ack kproc */
 160         int     ackprocstarted;
 161         QLock   apl;
 162 };
 163
 164
 165 static ulong generation = 0;
 166 static Rendez rend;
 167
 168 /*
 169  *  protocol specific part of Conv
 170  */
 171 typedef struct Rudpcb Rudpcb;
 172 struct Rudpcb
 173 {
 174         QLock;
 175         uchar   headers;
 176         uchar   randdrop;
 177         Reliable *r;
 178 };
 179
 180 /*
 181  * local functions
 182  */
 183 void    relsendack(Conv*, Reliable*, int);
 184 int     reliput(Conv*, Block*, uchar*, ushort);
 185 Reliable *relstate(Rudpcb*, uchar*, ushort, char*);
 186 void    relput(Reliable*);
 187 void    relforget(Conv *, uchar*, int, int);
 188 void    relackproc(void *);
 189 void    relackq(Reliable *, Block*);
 190 void    relhangup(Conv *, Reliable*);
 191 void    relrexmit(Conv *, Reliable*);
 192 void    relput(Reliable*);
 193 void    rudpkick(void *x);
 194
 195 static void
 196 rudpstartackproc(Proto *rudp)
 197 {
 198         Rudppriv *rpriv;
 199         char kpname[KNAMELEN];
 200
 201         rpriv = rudp->priv;
 202         if(rpriv->ackprocstarted == 0){
 203                 qlock(&rpriv->apl);
 204                 if(rpriv->ackprocstarted == 0){
 205                         sprint(kpname, "#I%drudpack", rudp->f->dev);
 206                         kproc(kpname, relackproc, rudp);
 207                         rpriv->ackprocstarted = 1;
 208                 }
 209                 qunlock(&rpriv->apl);
 210         }
 211 }
 212
 213 static char*
 214 rudpconnect(Conv *c, char **argv, int argc)
 215 {
 216         char *e;
 217         Rudppriv *upriv;
 218
 219         upriv = c->p->priv;
 220         rudpstartackproc(c->p);
 221         e = Fsstdconnect(c, argv, argc);
 222         Fsconnected(c, e);
 223         iphtadd(&upriv->ht, c);
 224
 225         return e;
 226 }
 227
 228
 229 static int
 230 rudpstate(Conv *c, char *state, int n)
 231 {
 232         Rudpcb *ucb;
 233         Reliable *r;
 234         int m;
 235
 236         m = snprint(state, n, "%s", c->inuse?"Open":"Closed");
 237         ucb = (Rudpcb*)c->ptcl;
 238         qlock(ucb);
 239         for(r = ucb->r; r; r = r->next)
 240                 m += snprint(state+m, n-m, " %I/%ld", r->addr, UNACKED(r));
 241         m += snprint(state+m, n-m, "\n");
 242         qunlock(ucb);
 243         return m;
 244 }
 245
 246 static char*
 247 rudpannounce(Conv *c, char** argv, int argc)
 248 {
 249         char *e;
 250         Rudppriv *upriv;
 251
 252         upriv = c->p->priv;
 253         rudpstartackproc(c->p);
 254         e = Fsstdannounce(c, argv, argc);
 255         if(e != nil)
 256                 return e;
 257         Fsconnected(c, nil);
 258         iphtadd(&upriv->ht, c);
 259
 260         return nil;
 261 }
 262
 263 static void
 264 rudpcreate(Conv *c)
 265 {
 266         c->rq = qopen(64*1024, Qmsg, 0, 0);
 267         c->wq = qopen(64*1024, Qkick, rudpkick, c);
 268 }
 269
 270 static void
 271 rudpclose(Conv *c)
 272 {
 273         Rudpcb *ucb;
 274         Reliable *r, *nr;
 275         Rudppriv *upriv;
 276
 277         upriv = c->p->priv;
 278         iphtrem(&upriv->ht, c);
 279
 280         /* force out any delayed acks */
 281         ucb = (Rudpcb*)c->ptcl;
 282         qlock(ucb);
 283         for(r = ucb->r; r; r = r->next){
 284                 if(r->acksent != r->rcvseq)
 285                         relsendack(c, r, 0);
 286         }
 287         qunlock(ucb);
 288
 289         qclose(c->rq);
 290         qclose(c->wq);
 291         qclose(c->eq);
 292         ipmove(c->laddr, IPnoaddr);
 293         ipmove(c->raddr, IPnoaddr);
 294         c->lport = 0;
 295         c->rport = 0;
 296
 297         ucb->headers = 0;
 298         ucb->randdrop = 0;
 299         qlock(ucb);
 300         for(r = ucb->r; r; r = nr){
 301                 if(r->acksent != r->rcvseq)
 302                         relsendack(c, r, 0);
 303                 nr = r->next;
 304                 relhangup(c, r);
 305                 relput(r);
 306         }
 307         ucb->r = 0;
 308
 309         qunlock(ucb);
 310 }
 311
 312 /*
 313  *  randomly don't send packets
 314  */
 315 static void
 316 doipoput(Conv *c, Fs *f, Block *bp, int x, int ttl, int tos)
 317 {
 318         Rudpcb *ucb;
 319
 320         ucb = (Rudpcb*)c->ptcl;
 321         if(ucb->randdrop && nrand(100) < ucb->randdrop)
 322                 freeblist(bp);
 323         else
 324                 ipoput4(f, bp, x, ttl, tos, nil);
 325 }
 326
 327 int
 328 flow(void *v)
 329 {
 330         Reliable *r = v;
 331
 332         return UNACKED(r) <= Maxunacked;
 333 }
 334
 335 void
 336 rudpkick(void *x)
 337 {
 338         Conv *c = x;
 339         Udphdr *uh;
 340         ushort rport;
 341         uchar laddr[IPaddrlen], raddr[IPaddrlen];
 342         Block *bp;
 343         Rudpcb *ucb;
 344         Rudphdr *rh;
 345         Reliable *r;
 346         int dlen, ptcllen;
 347         Rudppriv *upriv;
 348         Fs *f;
 349
 350         upriv = c->p->priv;
 351         f = c->p->f;
 352
 353         netlog(c->p->f, Logrudp, "rudp: kick\n");
 354         bp = qget(c->wq);
 355         if(bp == nil)
 356                 return;
 357
 358         ucb = (Rudpcb*)c->ptcl;
 359         switch(ucb->headers) {
 360         case 7:
 361                 /* get user specified addresses */
 362                 bp = pullupblock(bp, UDP_USEAD7);
 363                 if(bp == nil)
 364                         return;
 365                 ipmove(raddr, bp->rp);
 366                 bp->rp += IPaddrlen;
 367                 ipmove(laddr, bp->rp);
 368                 bp->rp += IPaddrlen;
 369                 /* pick interface closest to dest */
 370                 if(ipforme(f, laddr) != Runi)
 371                         findlocalip(f, laddr, raddr);
 372                 bp->rp += IPaddrlen;            /* Ignore ifc address */
 373                 rport = nhgets(bp->rp);
 374                 bp->rp += 2+2;                  /* Ignore local port */
 375                 break;
 376         default:
 377                 ipmove(raddr, c->raddr);
 378                 ipmove(laddr, c->laddr);
 379                 rport = c->rport;
 380                 break;
 381         }
 382
 383         dlen = blocklen(bp);
 384
 385         /* Make space to fit rudp & ip header */
 386         bp = padblock(bp, UDP_IPHDR+UDP_RHDRSIZE);
 387         if(bp == nil)
 388                 return;
 389
 390         uh = (Udphdr *)(bp->rp);
 391         uh->vihl = IP_VER4;
 392
 393         rh = (Rudphdr*)uh;
 394
 395         ptcllen = dlen + (UDP_RHDRSIZE-UDP_PHDRSIZE);
 396         uh->Unused = 0;
 397         uh->udpproto = IP_UDPPROTO;
 398         uh->frag[0] = 0;
 399         uh->frag[1] = 0;
 400         hnputs(uh->udpplen, ptcllen);
 401         switch(ucb->headers){
 402         case 7:
 403                 v6tov4(uh->udpdst, raddr);
 404                 hnputs(uh->udpdport, rport);
 405                 v6tov4(uh->udpsrc, laddr);
 406                 break;
 407         default:
 408                 v6tov4(uh->udpdst, c->raddr);
 409                 hnputs(uh->udpdport, c->rport);
 410                 if(ipcmp(c->laddr, IPnoaddr) == 0)
 411                         findlocalip(f, c->laddr, c->raddr);
 412                 v6tov4(uh->udpsrc, c->laddr);
 413                 break;
 414         }
 415         hnputs(uh->udpsport, c->lport);
 416         hnputs(uh->udplen, ptcllen);
 417         uh->udpcksum[0] = 0;
 418         uh->udpcksum[1] = 0;
 419
 420         qlock(ucb);
 421         r = relstate(ucb, raddr, rport, "kick");
 422         r->sndseq = NEXTSEQ(r->sndseq);
 423         hnputl(rh->relseq, r->sndseq);
 424         hnputl(rh->relsgen, r->sndgen);
 425
 426         hnputl(rh->relack, r->rcvseq);  /* ACK last rcvd packet */
 427         hnputl(rh->relagen, r->rcvgen);
 428
 429         if(r->rcvseq != r->acksent)
 430                 r->acksent = r->rcvseq;
 431
 432         hnputs(uh->udpcksum, ptclcsum(bp, UDP_IPHDR, dlen+UDP_RHDRSIZE));
 433
 434         relackq(r, bp);
 435         qunlock(ucb);
 436
 437         upriv->ustats.rudpOutDatagrams++;
 438
 439         DPRINT("sent: %lud/%lud, %lud/%lud\n",
 440                 r->sndseq, r->sndgen, r->rcvseq, r->rcvgen);
 441
 442         doipoput(c, f, bp, 0, c->ttl, c->tos);
 443
 444         if(waserror()) {
 445                 relput(r);
 446                 qunlock(&r->lock);
 447                 nexterror();
 448         }
 449
 450         /* flow control of sorts */
 451         qlock(&r->lock);
 452         if(UNACKED(r) > Maxunacked){
 453                 r->blocked = 1;
 454                 sleep(&r->vous, flow, r);
 455                 r->blocked = 0;
 456         }
 457
 458         qunlock(&r->lock);
 459         relput(r);
 460         poperror();
 461 }
 462
 463 void
 464 rudpiput(Proto *rudp, Ipifc *ifc, Block *bp)
 465 {
 466         int len, olen, ottl;
 467         Udphdr *uh;
 468         Conv *c;
 469         Rudpcb *ucb;
 470         uchar raddr[IPaddrlen], laddr[IPaddrlen];
 471         ushort rport, lport;
 472         Rudppriv *upriv;
 473         Fs *f;
 474         uchar *p;
 475
 476         upriv = rudp->priv;
 477         f = rudp->f;
 478
 479         upriv->ustats.rudpInDatagrams++;
 480
 481         uh = (Udphdr*)(bp->rp);
 482
 483         /* Put back pseudo header for checksum
 484          * (remember old values for icmpnoconv())
 485          */
 486         ottl = uh->Unused;
 487         uh->Unused = 0;
 488         len = nhgets(uh->udplen);
 489         olen = nhgets(uh->udpplen);
 490         hnputs(uh->udpplen, len);
 491
 492         v4tov6(raddr, uh->udpsrc);
 493         v4tov6(laddr, uh->udpdst);
 494         lport = nhgets(uh->udpdport);
 495         rport = nhgets(uh->udpsport);
 496
 497         if(nhgets(uh->udpcksum)) {
 498                 if(ptclcsum(bp, UDP_IPHDR, len+UDP_PHDRSIZE)) {
 499                         upriv->ustats.rudpInErrors++;
 500                         upriv->csumerr++;
 501                         netlog(f, Logrudp, "rudp: checksum error %I\n", raddr);
 502                         DPRINT("rudp: checksum error %I\n", raddr);
 503                         freeblist(bp);
 504                         return;
 505                 }
 506         }
 507
 508         qlock(rudp);
 509
 510         c = iphtlook(&upriv->ht, raddr, rport, laddr, lport);
 511         if(c == nil){
 512                 /* no conversation found */
 513                 upriv->ustats.rudpNoPorts++;
 514                 qunlock(rudp);
 515                 netlog(f, Logudp, "udp: no conv %I!%d -> %I!%d\n", raddr, rport,
 516                         laddr, lport);
 517                 uh->Unused = ottl;
 518                 hnputs(uh->udpplen, olen);
 519                 icmpnoconv(f, bp);
 520                 freeblist(bp);
 521                 return;
 522         }
 523         ucb = (Rudpcb*)c->ptcl;
 524         qlock(ucb);
 525         qunlock(rudp);
 526
 527         if(reliput(c, bp, raddr, rport) < 0){
 528                 qunlock(ucb);
 529                 freeb(bp);
 530                 return;
 531         }
 532
 533         /*
 534          * Trim the packet down to data size
 535          */
 536
 537         len -= (UDP_RHDRSIZE-UDP_PHDRSIZE);
 538         bp = trimblock(bp, UDP_IPHDR+UDP_RHDRSIZE, len);
 539         if(bp == nil) {
 540                 netlog(f, Logrudp, "rudp: len err %I.%d -> %I.%d\n",
 541                         raddr, rport, laddr, lport);
 542                 DPRINT("rudp: len err %I.%d -> %I.%d\n",
 543                         raddr, rport, laddr, lport);
 544                 upriv->lenerr++;
 545                 return;
 546         }
 547
 548         netlog(f, Logrudpmsg, "rudp: %I.%d -> %I.%d l %d\n",
 549                 raddr, rport, laddr, lport, len);
 550
 551         switch(ucb->headers){
 552         case 7:
 553                 /* pass the src address */
 554                 bp = padblock(bp, UDP_USEAD7);
 555                 p = bp->rp;
 556                 ipmove(p, raddr); p += IPaddrlen;
 557                 ipmove(p, laddr); p += IPaddrlen;
 558                 ipmove(p, ifc->lifc->local); p += IPaddrlen;
 559                 hnputs(p, rport); p += 2;
 560                 hnputs(p, lport);
 561                 break;
 562         default:
 563                 /* connection oriented rudp */
 564                 if(ipcmp(c->raddr, IPnoaddr) == 0){
 565                         /* save the src address in the conversation */
 566                         ipmove(c->raddr, raddr);
 567                         c->rport = rport;
 568
 569                         /* reply with the same ip address (if not broadcast) */
 570                         if(ipforme(f, laddr) == Runi)
 571                                 ipmove(c->laddr, laddr);
 572                         else
 573                                 v4tov6(c->laddr, ifc->lifc->local);
 574                 }
 575                 break;
 576         }
 577         if(bp->next)
 578                 bp = concatblock(bp);
 579
 580         if(qfull(c->rq)) {
 581                 netlog(f, Logrudp, "rudp: qfull %I.%d -> %I.%d\n", raddr, rport,
 582                         laddr, lport);
 583                 freeblist(bp);
 584         }
 585         else
 586                 qpass(c->rq, bp);
 587
 588         qunlock(ucb);
 589 }
 590
 591 static char *rudpunknown = "unknown rudp ctl request";
 592
 593 char*
 594 rudpctl(Conv *c, char **f, int n)
 595 {
 596         Rudpcb *ucb;
 597         uchar ip[IPaddrlen];
 598         int x;
 599
 600         ucb = (Rudpcb*)c->ptcl;
 601         if(n < 1)
 602                 return rudpunknown;
 603
 604         if(strcmp(f[0], "headers") == 0){
 605                 ucb->headers = 7;               /* new headers format */
 606                 return nil;
 607         } else if(strcmp(f[0], "hangup") == 0){
 608                 if(n < 3)
 609                         return "bad syntax";
 610                 if (parseip(ip, f[1]) == -1)
 611                         return Ebadip;
 612                 x = atoi(f[2]);
 613                 qlock(ucb);
 614                 relforget(c, ip, x, 1);
 615                 qunlock(ucb);
 616                 return nil;
 617         } else if(strcmp(f[0], "randdrop") == 0){
 618                 x = 10;                 /* default is 10% */
 619                 if(n > 1)
 620                         x = atoi(f[1]);
 621                 if(x > 100 || x < 0)
 622                         return "illegal rudp drop rate";
 623                 ucb->randdrop = x;
 624                 return nil;
 625         }
 626         return rudpunknown;
 627 }
 628
 629 void
 630 rudpadvise(Proto *rudp, Block *bp, char *msg)
 631 {
 632         Udphdr *h;
 633         uchar source[IPaddrlen], dest[IPaddrlen];
 634         ushort psource, pdest;
 635         Conv *s, **p;
 636
 637         h = (Udphdr*)(bp->rp);
 638
 639         v4tov6(dest, h->udpdst);
 640         v4tov6(source, h->udpsrc);
 641         psource = nhgets(h->udpsport);
 642         pdest = nhgets(h->udpdport);
 643
 644         /* Look for a connection */
 645         for(p = rudp->conv; *p; p++) {
 646                 s = *p;
 647                 if(s->rport == pdest)
 648                 if(s->lport == psource)
 649                 if(ipcmp(s->raddr, dest) == 0)
 650                 if(ipcmp(s->laddr, source) == 0){
 651                         qhangup(s->rq, msg);
 652                         qhangup(s->wq, msg);
 653                         break;
 654                 }
 655         }
 656         freeblist(bp);
 657 }
 658
 659 int
 660 rudpstats(Proto *rudp, char *buf, int len)
 661 {
 662         Rudppriv *upriv;
 663
 664         upriv = rudp->priv;
 665         return snprint(buf, len, "%lud %lud %lud %lud %lud %lud\n",
 666                 upriv->ustats.rudpInDatagrams,
 667                 upriv->ustats.rudpNoPorts,
 668                 upriv->ustats.rudpInErrors,
 669                 upriv->ustats.rudpOutDatagrams,
 670                 upriv->rxmits,
 671                 upriv->orders);
 672 }
 673
 674 void
 675 rudpinit(Fs *fs)
 676 {
 677
 678         Proto *rudp;
 679
 680         rudp = smalloc(sizeof(Proto));
 681         rudp->priv = smalloc(sizeof(Rudppriv));
 682         rudp->name = "rudp";
 683         rudp->connect = rudpconnect;
 684         rudp->announce = rudpannounce;
 685         rudp->ctl = rudpctl;
 686         rudp->state = rudpstate;
 687         rudp->create = rudpcreate;
 688         rudp->close = rudpclose;
 689         rudp->rcv = rudpiput;
 690         rudp->advise = rudpadvise;
 691         rudp->stats = rudpstats;
 692         rudp->ipproto = IP_UDPPROTO;
 693         rudp->nc = 32;
 694         rudp->ptclsize = sizeof(Rudpcb);
 695
 696         Fsproto(fs, rudp);
 697 }
 698
 699 /*********************************************/
 700 /* Here starts the reliable helper functions */
 701 /*********************************************/
 702 /*
 703  *  Enqueue a copy of an unacked block for possible retransmissions
 704  */
 705 void
 706 relackq(Reliable *r, Block *bp)
 707 {
 708         Block *np;
 709
 710         np = copyblock(bp, blocklen(bp));
 711         if(r->unacked)
 712                 r->unackedtail->list = np;
 713         else {
 714                 /* restart timer */
 715                 r->timeout = 0;
 716                 r->xmits = 1;
 717                 r->unacked = np;
 718         }
 719         r->unackedtail = np;
 720         np->list = nil;
 721 }
 722
 723 /*
 724  *  retransmit unacked blocks
 725  */
 726 void
 727 relackproc(void *a)
 728 {
 729         Rudpcb *ucb;
 730         Proto *rudp;
 731         Reliable *r;
 732         Conv **s, *c;
 733
 734         rudp = (Proto *)a;
 735
 736 loop:
 737         tsleep(&up->sleep, return0, 0, Rudptickms);
 738
 739         for(s = rudp->conv; *s; s++) {
 740                 c = *s;
 741                 ucb = (Rudpcb*)c->ptcl;
 742                 qlock(ucb);
 743
 744                 for(r = ucb->r; r; r = r->next) {
 745                         if(r->unacked != nil){
 746                                 r->timeout += Rudptickms;
 747                                 if(r->timeout > Rudprxms*r->xmits)
 748                                         relrexmit(c, r);
 749                         }
 750                         if(r->acksent != r->rcvseq)
 751                                 relsendack(c, r, 0);
 752                 }
 753                 qunlock(ucb);
 754         }
 755         goto loop;
 756 }
 757
 758 /*
 759  *  get the state record for a conversation
 760  */
 761 Reliable*
 762 relstate(Rudpcb *ucb, uchar *addr, ushort port, char *from)
 763 {
 764         Reliable *r, **l;
 765
 766         l = &ucb->r;
 767         for(r = *l; r; r = *l){
 768                 if(memcmp(addr, r->addr, IPaddrlen) == 0 &&
 769                     port == r->port)
 770                         break;
 771                 l = &r->next;
 772         }
 773
 774         /* no state for this addr/port, create some */
 775         if(r == nil){
 776                 while(generation == 0)
 777                         generation = rand();
 778
 779                 DPRINT("from %s new state %lud for %I!%ud\n",
 780                         from, generation, addr, port);
 781
 782                 r = smalloc(sizeof(Reliable));
 783                 memmove(r->addr, addr, IPaddrlen);
 784                 r->port = port;
 785                 r->unacked = 0;
 786                 if(generation == Hangupgen)
 787                         generation++;
 788                 r->sndgen = generation++;
 789                 r->sndseq = 0;
 790                 r->ackrcvd = 0;
 791                 r->rcvgen = 0;
 792                 r->rcvseq = 0;
 793                 r->acksent = 0;
 794                 r->xmits = 0;
 795                 r->timeout = 0;
 796                 r->ref = 0;
 797                 incref(r);      /* one reference for being in the list */
 798
 799                 *l = r;
 800         }
 801
 802         incref(r);
 803         return r;
 804 }
 805
 806 void
 807 relput(Reliable *r)
 808 {
 809         if(decref(r) == 0)
 810                 free(r);
 811 }
 812
 813 /*
 814  *  forget a Reliable state
 815  */
 816 void
 817 relforget(Conv *c, uchar *ip, int port, int originator)
 818 {
 819         Rudpcb *ucb;
 820         Reliable *r, **l;
 821
 822         ucb = (Rudpcb*)c->ptcl;
 823
 824         l = &ucb->r;
 825         for(r = *l; r; r = *l){
 826                 if(ipcmp(ip, r->addr) == 0 && port == r->port){
 827                         *l = r->next;
 828                         if(originator)
 829                                 relsendack(c, r, 1);
 830                         relhangup(c, r);
 831                         relput(r);      /* remove from the list */
 832                         break;
 833                 }
 834                 l = &r->next;
 835         }
 836 }
 837
 838 /*
 839  *  process a rcvd reliable packet. return -1 if not to be passed to user process,
 840  *  0 therwise.
 841  *
 842  *  called with ucb locked.
 843  */
 844 int
 845 reliput(Conv *c, Block *bp, uchar *addr, ushort port)
 846 {
 847         Block *nbp;
 848         Rudpcb *ucb;
 849         Rudppriv *upriv;
 850         Udphdr *uh;
 851         Reliable *r;
 852         Rudphdr *rh;
 853         ulong seq, ack, sgen, agen, ackreal;
 854         int rv = -1;
 855
 856         /* get fields */
 857         uh = (Udphdr*)(bp->rp);
 858         rh = (Rudphdr*)uh;
 859         seq = nhgetl(rh->relseq);
 860         sgen = nhgetl(rh->relsgen);
 861         ack = nhgetl(rh->relack);
 862         agen = nhgetl(rh->relagen);
 863
 864         upriv = c->p->priv;
 865         ucb = (Rudpcb*)c->ptcl;
 866         r = relstate(ucb, addr, port, "input");
 867
 868         DPRINT("rcvd %lud/%lud, %lud/%lud, r->sndgen = %lud\n",
 869                 seq, sgen, ack, agen, r->sndgen);
 870
 871         /* if acking an incorrect generation, ignore */
 872         if(ack && agen != r->sndgen)
 873                 goto out;
 874
 875         /* Look for a hangup */
 876         if(sgen == Hangupgen) {
 877                 if(agen == r->sndgen)
 878                         relforget(c, addr, port, 0);
 879                 goto out;
 880         }
 881
 882         /* make sure we're not talking to a new remote side */
 883         if(r->rcvgen != sgen){
 884                 if(seq != 0 && seq != 1)
 885                         goto out;
 886
 887                 /* new connection */
 888                 if(r->rcvgen != 0){
 889                         DPRINT("new con r->rcvgen = %lud, sgen = %lud\n", r->rcvgen, sgen);
 890                         relhangup(c, r);
 891                 }
 892                 r->rcvgen = sgen;
 893         }
 894
 895         /* dequeue acked packets */
 896         if(ack && agen == r->sndgen){
 897                 ackreal = 0;
 898                 while(r->unacked != nil && INSEQ(ack, r->ackrcvd, r->sndseq)){
 899                         nbp = r->unacked;
 900                         r->unacked = nbp->list;
 901                         DPRINT("%lud/%lud acked, r->sndgen = %lud\n",
 902                                ack, agen, r->sndgen);
 903                         freeb(nbp);
 904                         r->ackrcvd = NEXTSEQ(r->ackrcvd);
 905                         ackreal = 1;
 906                 }
 907
 908                 /* flow control */
 909                 if(UNACKED(r) < Maxunacked/8 && r->blocked)
 910                         wakeup(&r->vous);
 911
 912                 /*
 913                  *  retransmit next packet if the acked packet
 914                  *  was transmitted more than once
 915                  */
 916                 if(ackreal && r->unacked != nil){
 917                         r->timeout = 0;
 918                         if(r->xmits > 1){
 919                                 r->xmits = 1;
 920                                 relrexmit(c, r);
 921                         }
 922                 }
 923
 924         }
 925
 926         /* no message or input queue full */
 927         if(seq == 0 || qfull(c->rq))
 928                 goto out;
 929
 930         /* refuse out of order delivery */
 931         if(seq != NEXTSEQ(r->rcvseq)){
 932                 relsendack(c, r, 0);    /* tell him we got it already */
 933                 upriv->orders++;
 934                 DPRINT("out of sequence %lud not %lud\n", seq, NEXTSEQ(r->rcvseq));
 935                 goto out;
 936         }
 937         r->rcvseq = seq;
 938
 939         rv = 0;
 940 out:
 941         relput(r);
 942         return rv;
 943 }
 944
 945 void
 946 relsendack(Conv *c, Reliable *r, int hangup)
 947 {
 948         Udphdr *uh;
 949         Block *bp;
 950         Rudphdr *rh;
 951         int ptcllen;
 952         Fs *f;
 953
 954         bp = allocb(UDP_IPHDR + UDP_RHDRSIZE);
 955         if(bp == nil)
 956                 return;
 957         bp->wp += UDP_IPHDR + UDP_RHDRSIZE;
 958         f = c->p->f;
 959         uh = (Udphdr *)(bp->rp);
 960         uh->vihl = IP_VER4;
 961         rh = (Rudphdr*)uh;
 962
 963         ptcllen = (UDP_RHDRSIZE-UDP_PHDRSIZE);
 964         uh->Unused = 0;
 965         uh->udpproto = IP_UDPPROTO;
 966         uh->frag[0] = 0;
 967         uh->frag[1] = 0;
 968         hnputs(uh->udpplen, ptcllen);
 969
 970         v6tov4(uh->udpdst, r->addr);
 971         hnputs(uh->udpdport, r->port);
 972         hnputs(uh->udpsport, c->lport);
 973         if(ipcmp(c->laddr, IPnoaddr) == 0)
 974                 findlocalip(f, c->laddr, c->raddr);
 975         v6tov4(uh->udpsrc, c->laddr);
 976         hnputs(uh->udplen, ptcllen);
 977
 978         if(hangup)
 979                 hnputl(rh->relsgen, Hangupgen);
 980         else
 981                 hnputl(rh->relsgen, r->sndgen);
 982         hnputl(rh->relseq, 0);
 983         hnputl(rh->relagen, r->rcvgen);
 984         hnputl(rh->relack, r->rcvseq);
 985
 986         if(r->acksent < r->rcvseq)
 987                 r->acksent = r->rcvseq;
 988
 989         uh->udpcksum[0] = 0;
 990         uh->udpcksum[1] = 0;
 991         hnputs(uh->udpcksum, ptclcsum(bp, UDP_IPHDR, UDP_RHDRSIZE));
 992
 993         DPRINT("sendack: %lud/%lud, %lud/%lud\n", 0L, r->sndgen, r->rcvseq, r->rcvgen);
 994         doipoput(c, f, bp, 0, c->ttl, c->tos);
 995 }
 996
 997
 998 /*
 999  *  called with ucb locked (and c locked if user initiated close)
1000  */
1001 void
1002 relhangup(Conv *c, Reliable *r)
1003 {
1004         int n;
1005         Block *bp;
1006         char hup[ERRMAX];
1007
1008         n = snprint(hup, sizeof(hup), "hangup %I!%d", r->addr, r->port);
1009         qproduce(c->eq, hup, n);
1010
1011         /*
1012          *  dump any unacked outgoing messages
1013          */
1014         for(bp = r->unacked; bp != nil; bp = r->unacked){
1015                 r->unacked = bp->list;
1016                 bp->list = nil;
1017                 freeb(bp);
1018         }
1019
1020         r->rcvgen = 0;
1021         r->rcvseq = 0;
1022         r->acksent = 0;
1023         if(generation == Hangupgen)
1024                 generation++;
1025         r->sndgen = generation++;
1026         r->sndseq = 0;
1027         r->ackrcvd = 0;
1028         r->xmits = 0;
1029         r->timeout = 0;
1030         wakeup(&r->vous);
1031 }
1032
1033 /*
1034  *  called with ucb locked
1035  */
1036 void
1037 relrexmit(Conv *c, Reliable *r)
1038 {
1039         Rudppriv *upriv;
1040         Block *np;
1041         Fs *f;
1042
1043         upriv = c->p->priv;
1044         f = c->p->f;
1045         r->timeout = 0;
1046         if(r->xmits++ > Rudpmaxxmit){
1047                 relhangup(c, r);
1048                 return;
1049         }
1050
1051         upriv->rxmits++;
1052         np = copyblock(r->unacked, blocklen(r->unacked));
1053         DPRINT("rxmit r->ackrvcd+1 = %lud\n", r->ackrcvd+1);
1054         doipoput(c, f, np, 0, c->ttl, c->tos);
1055 }