9ns: change parsecmd()'s size arg's type to size_t
[akaros.git] / kern / include / net / ip.h
1 /* Copyright © 1994-1999 Lucent Technologies Inc.  All rights reserved.
2  * Portions Copyright © 1997-1999 Vita Nuova Limited
3  * Portions Copyright © 2000-2007 Vita Nuova Holdings Limited
4  *                                (www.vitanuova.com)
5  * Revisions Copyright © 2000-2007 Lucent Technologies Inc. and others
6  *
7  * Modified for the Akaros operating system:
8  * Copyright (c) 2013-2014 The Regents of the University of California
9  * Copyright (c) 2013-2015 Google Inc.
10  *
11  * Permission is hereby granted, free of charge, to any person obtaining a copy
12  * of this software and associated documentation files (the "Software"), to deal
13  * in the Software without restriction, including without limitation the rights
14  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
15  * copies of the Software, and to permit persons to whom the Software is
16  * furnished to do so, subject to the following conditions:
17  *
18  * The above copyright notice and this permission notice shall be included in
19  * all copies or substantial portions of the Software.
20  *
21  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
22  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
23  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
24  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
25  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
26  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
27  * SOFTWARE. */
28
29
30 #pragma once
31 #include <ns.h>
32
33 enum {
34         Addrlen = 64,
35         Maxproto = 20,
36         Nhash = 64,
37         Maxincall = 500,
38         Nchans = 256,
39         MAClen = 16,    /* longest mac address */
40
41         MAXTTL = 255,
42         DFLTTOS = 0,
43
44         IPaddrlen = 16,
45         IPv4addrlen = 4,
46         IPv4off = 12,
47         IPllen = 4,
48
49         /* ip versions */
50         V4 = 4,
51         V6 = 6,
52         IP_VER4 = 0x40,
53         IP_VER6 = 0x60,
54
55         /* 2^Lroot trees in the root table */
56         Lroot = 10,
57
58         Maxpath = 64,
59 };
60
61 enum {
62         Idle = 0,
63         Announcing = 1,
64         Announced = 2,
65         Connecting = 3,
66         Connected = 4,
67         Bypass = 5,
68 };
69
70 enum {
71         SHUT_RD = 0,
72         SHUT_WR = 1,
73         SHUT_RDWR = 2,
74 };
75
76 /*
77  *  one per conversation directory
78  */
79 struct Proto;
80 struct conv {
81         qlock_t qlock;
82
83         int x;                  /* conversation index */
84         struct Proto *p;
85
86         int restricted;         /* remote port is restricted */
87         uint32_t ttl;           /* max time to live */
88         uint32_t tos;           /* type of service */
89         int ignoreadvice;       /* don't terminate connection on icmp errors */
90
91         uint8_t ipversion;
92         uint8_t laddr[IPaddrlen];/* local IP address */
93         uint8_t raddr[IPaddrlen];/* remote IP address */
94         uint16_t lport;         /* local port number */
95         uint16_t rport;         /* remote port number */
96
97         char *owner;            /* protections */
98         int perm;
99         int inuse;              /* opens of listen/data/ctl */
100         int length;
101         int state;
102         struct queue *rq_save;  /* rq created by proto, saved during bypass */
103         struct queue *wq_save;  /* wq created by proto, saved during bypass */
104
105         /* udp specific */
106         int headers;            /* data src/dst headers in udp */
107         int reliable;           /* true if reliable udp */
108
109         struct conv *incall;    /* calls waiting to be listened for */
110         struct conv *next;
111
112         struct queue *rq;       /* queued data waiting to be read */
113         struct queue *wq;       /* queued data waiting to be written */
114         struct queue *eq;       /* returned error packets */
115         struct queue *sq;       /* snooping queue */
116         atomic_t snoopers;      /* number of processes with snoop open */
117
118         struct fdtap_slist data_taps;
119         struct fdtap_slist listen_taps;
120         spinlock_t tap_lock;
121
122         struct rendez cr;
123         char cerr[ERRMAX];
124
125         qlock_t listenq;
126         struct rendez listenr;
127
128         struct Ipmulti *multi;  /* multicast bindings for this interface */
129
130         void *ptcl;             /* Protocol specific stuff */
131
132         struct route *r;        /* last route used */
133         uint32_t rgen;          /* routetable generation for *r */
134 };
135
136 struct Ipifc;
137 struct Fs;
138
139 struct medium {
140         char *name;
141         int hsize;              /* medium header size */
142         int mintu;              /* default min mtu */
143         int maxtu;              /* default max mtu */
144         int maclen;             /* mac address length  */
145         void (*bind) (struct Ipifc * unused_Ipifc, int unused_int,
146                       char **unused_char_pp_t);
147         void (*unbind) (struct Ipifc * unused_Ipifc);
148         void (*bwrite) (struct Ipifc * ifc, struct block * b, int version,
149                         uint8_t * ip);
150
151         /* for arming interfaces to receive multicast */
152         void (*addmulti) (struct Ipifc * ifc, uint8_t * a, uint8_t * ia);
153         void (*remmulti) (struct Ipifc * ifc, uint8_t * a, uint8_t * ia);
154
155         /* process packets written to 'data' */
156         void (*pktin) (struct Fs * f, struct Ipifc * ifc, struct block * bp);
157
158         /* routes for router boards */
159         void (*addroute) (struct Ipifc * ifc, int unused_int, uint8_t * u8p,
160                           uint8_t *, uint8_t * u8p2, int);
161         void (*remroute) (struct Ipifc * ifc, int i, uint8_t * u8p,
162                           uint8_t * uu8p2);
163         void (*flushroutes) (struct Ipifc * ifc);
164
165         /* for routing multicast groups */
166         void (*joinmulti) (struct Ipifc * ifc, uint8_t * a, uint8_t * ia);
167         void (*leavemulti) (struct Ipifc * ifc, uint8_t * a, uint8_t * ia);
168
169         /* address resolution */
170         void (*ares) (struct Fs *, int unused_int, uint8_t * unused_uint8_p_t,
171                       uint8_t *, int, int);     /* resolve */
172         void (*areg) (struct Ipifc * unused_Ipifc,
173                       uint8_t * unused_uint8_p_t);      /* register */
174
175         /* v6 address generation */
176         void (*pref2addr) (uint8_t * pref, uint8_t * ea);
177
178         int unbindonclose;      /* if non-zero, unbind on last close */
179 };
180
181 /* logical interface associated with a physical one */
182 struct Iplifc {
183         uint8_t local[IPaddrlen];
184         uint8_t mask[IPaddrlen];
185         uint8_t remote[IPaddrlen];
186         uint8_t net[IPaddrlen];
187         uint8_t tentative; /* =1 => v6 dup disc on, =0 => confirmed unique */
188         uint8_t onlink;                 /* =1 => onlink, =0 offlink. */
189         uint8_t autoflag;               /* v6 autonomous flag */
190         uint64_t validlt;               /* v6 valid lifetime */
191         uint64_t preflt;                /* v6 preferred lifetime */
192         uint64_t origint;               /* time when addr was added */
193         struct Iplink *link;            /* addresses linked to this lifc */
194         struct Iplifc *next;
195 };
196
197 /* binding twixt Ipself and Iplifc */
198 struct Iplink {
199         struct Ipself *self;
200         struct Iplifc *lifc;
201         struct Iplink *selflink;        /* next link for this local address */
202         struct Iplink *lifclink;        /* next link for this ifc */
203         uint64_t expire;
204         struct Iplink *next;            /* free list */
205         struct kref ref;
206 };
207
208 /* rfc 2461, pp.40--43. */
209
210 /* default values, one per stack */
211 struct routerparams {
212         int mflag;
213         int oflag;
214         int maxraint;
215         int minraint;
216         int linkmtu;
217         int reachtime;
218         int rxmitra;
219         int ttl;
220         int routerlt;
221 };
222
223 struct Ipifc {
224         rwlock_t rwlock;
225
226         struct conv *conv;      /* link to its conversation structure */
227         char dev[64];           /* device we're attached to */
228         struct medium *m;       /* Media pointer */
229         int maxtu;              /* Maximum transfer unit */
230         int mintu;              /* Minumum tranfer unit */
231         unsigned int feat;      /* Offload features */
232         void *arg;              /* medium specific */
233         int reassemble;         /* reassemble IP packets before forwarding */
234
235         /* these are used so that we can unbind on the fly */
236         spinlock_t idlock;
237         uint8_t ifcid;          /* incremented each 'bind/unbind/add/remove' */
238         int ref;                /* number of proc's using this Ipifc */
239         struct rendez wait;     /* where unbinder waits for ref == 0 */
240         int unbinding;
241
242         uint8_t mac[MAClen];    /* MAC address */
243
244         struct Iplifc *lifc;    /* logical interfaces on this physical one */
245
246         uint32_t in, out;       /* message statistics */
247         uint32_t inerr, outerr; /* ... */
248         uint32_t tracedrop;
249
250         uint8_t sendra6;        /* == 1 => send router advs on this ifc */
251         uint8_t recvra6;        /* == 1 => recv router advs on this ifc */
252         struct routerparams rp; /* router parameters as in RFC 2461, pp.40--43.
253                                    used only if node is router */
254 };
255
256 /*
257  *  one per multicast-lifc pair used by a struct conv
258  */
259 struct Ipmulti {
260         uint8_t ma[IPaddrlen];
261         uint8_t ia[IPaddrlen];
262         struct Ipmulti *next;
263 };
264
265 /*
266  *  hash table for 2 ip addresses + 2 ports
267  */
268 enum {
269         Nipht = 521,            /* convenient prime */
270
271         IPmatchexact = 0,       /* match on 4 tuple */
272         IPmatchany,     /* *!* */
273         IPmatchport,    /* *!port */
274         IPmatchaddr,    /* addr!* */
275         IPmatchpa,      /* addr!port */
276 };
277 struct Iphash {
278         struct Iphash *next;
279         struct conv *c;
280         int match;
281 };
282
283 struct Iphash;
284 struct Ipht {
285         spinlock_t lock;
286         struct Iphash *tab[Nipht];
287 };
288 void iphtadd(struct Ipht *, struct conv *);
289 void iphtrem(struct Ipht *, struct conv *);
290 struct conv *iphtlook(struct Ipht *ht, uint8_t * sa, uint16_t sp, uint8_t * da,
291                       uint16_t dp);
292 void dump_ipht(struct Ipht *ht);
293
294 /*
295  *  one per multiplexed Protocol
296  */
297 struct Proto {
298         qlock_t qlock;
299         char *name;             /* protocol name */
300         int x;                  /* protocol index */
301         int ipproto;            /* ip protocol type */
302
303         void (*connect)(struct conv *, char **, int);
304         void (*announce)(struct conv *, char **, int);
305         void (*bind)(struct conv *, char **, int);
306         void (*bypass)(struct conv *, char **, int);
307         int (*state) (struct conv *, char *unused_char_p_t, int);
308         void (*create) (struct conv *);
309         void (*close) (struct conv *);
310         void (*shutdown)(struct conv *, int);
311         void (*rcv) (struct Proto *, struct Ipifc *, struct block *);
312         void (*ctl)(struct conv *, char **, int);
313         void (*advise) (struct Proto *, struct block *, char *unused_char_p_t);
314         int (*stats) (struct Proto *, char *unused_char_p_t, int);
315         int (*local) (struct conv *, char *unused_char_p_t, int);
316         int (*remote) (struct conv *, char *unused_char_p_t, int);
317         int (*inuse) (struct conv *);
318         /* returns true if any conversations are freed */
319         int (*gc) (struct Proto *);
320
321         struct Fs *f;           /* file system this proto is part of */
322         struct conv **conv;     /* array of conversations */
323         int ptclsize;           /* size of per protocol ctl block */
324         int nc;                 /* number of conversations */
325         int ac;
326         struct qid qid;         /* qid for protocol directory */
327         uint16_t nextport;
328         uint16_t nextrport;
329
330         void *priv;
331 };
332
333 /*
334  *  Stream for sending packets to user level
335  */
336 struct IProuter {
337         qlock_t qlock;
338         int opens;
339         struct queue *q;
340 };
341
342 /*
343  *  one per IP protocol stack
344  */
345 struct Fs {
346         rwlock_t rwlock;
347         int dev;
348
349         int np;
350         struct Proto *p[Maxproto + 1];  /* list of supported protocols */
351         struct Proto *t2p[256];         /* vector of all protocols */
352         struct Proto *ipifc;    /* kludge for ipifcremroute & ipifcaddroute */
353         struct Proto *ipmux;    /* kludge for finding an ip multiplexor */
354
355         struct IP *ip;
356         struct Ipselftab *self;
357         struct arp *arp;
358         struct V6params *v6p;
359         struct IProuter iprouter;
360
361         struct route *v4root[1 << Lroot];       /* v4 routing forest */
362         struct route *v6root[1 << Lroot];       /* v6 routing forest */
363         struct route *queue;    /* used as temp when reinjecting routes */
364
365         struct Netlog *alog;
366         struct Ifclog *ilog;
367
368         char ndb[1024];         /* an ndb entry for this interface */
369         int ndbvers;
370         long ndbmtime;
371 };
372
373 /* one per default router known to host */
374 struct V6router {
375         uint8_t inuse;
376         struct Ipifc *ifc;
377         int ifcid;
378         uint8_t routeraddr[IPaddrlen];
379         long ltorigin;
380         struct routerparams rp;
381 };
382
383 struct hostparams {
384         int rxmithost;
385 };
386
387 struct V6params {
388         struct routerparams rp;         /* v6 params, one copy per node now */
389         struct hostparams hp;
390         struct V6router v6rlist[3];     /* max 3 default routers, currently */
391         int cdrouter;                   /* uses only v6rlist[cdrouter] if   */
392         /* cdrouter >= 0. */
393 };
394
395 int Fsconnected(struct conv *, char *unused_char_p_t);
396 struct conv *Fsnewcall(struct conv *, uint8_t * unused_uint8_p_t, uint16_t,
397                        uint8_t *, uint16_t, uint8_t unused_uint8_t);
398 int Fspcolstats(char *unused_char_p_t, int);
399 int Fsproto(struct Fs *, struct Proto *);
400 int Fsbuiltinproto(struct Fs *, uint8_t unused_uint8_t);
401 struct conv *Fsprotoclone(struct Proto *, char *unused_char_p_t);
402 struct Proto *Fsrcvpcol(struct Fs *, uint8_t unused_uint8_t);
403 struct Proto *Fsrcvpcolx(struct Fs *, uint8_t unused_uint8_t);
404 void Fsstdconnect(struct conv *, char **, int);
405 void Fsstdannounce(struct conv *, char **, int);
406 void Fsstdbypass(struct conv *, char **, int);
407 void Fsstdbind(struct conv *, char **, int);
408 uint32_t scalednconv(void);
409 void bypass_or_drop(struct conv *cv, struct block *bp);
410
411 /*
412  *  logging
413  */
414 enum {
415         Logip = 1 << 1,
416         Logtcp = 1 << 2,
417         Logfs = 1 << 3,
418         Logil = 1 << 4,
419         Logicmp = 1 << 5,
420         Logudp = 1 << 6,
421         Logcompress = 1 << 7,
422         Logilmsg = 1 << 8,
423         Loggre = 1 << 9,
424         Logppp = 1 << 10,
425         Logtcprxmt = 1 << 11,
426         Logigmp = 1 << 12,
427         Logudpmsg = 1 << 13,
428         Logipmsg = 1 << 14,
429         Logrudp = 1 << 15,
430         Logrudpmsg = 1 << 16,
431         Logesp = 1 << 17,
432         Logtcpreset = 1 << 18,
433         Logtcpverbose = 1 << 19,
434 };
435
436 void netloginit(struct Fs *);
437 void netlogopen(struct Fs *);
438 void netlogclose(struct Fs *);
439 void netlogctl(struct Fs *, char *unused_char_p_t, size_t);
440 long netlogread(struct Fs *, void *, uint32_t, long);
441 void netlog(struct Fs *, int unused_int, char *unused_char_p_t, ...);
442 void ifcloginit(struct Fs *);
443 long ifclogread(struct Fs *, struct chan *, void *, uint32_t, long);
444 void ifclog(struct Fs *, uint8_t *, int);
445 void ifclogopen(struct Fs *, struct chan *);
446 void ifclogclose(struct Fs *, struct chan *);
447
448 /*
449  *  iproute.c
450  */
451
452 enum {
453
454         /* type bits */
455         Rv4 = (1 << 0),         /* this is a version 4 route */
456         Rifc = (1 << 1),        /* route is a directly connected interface */
457         Rptpt = (1 << 2),       /* this route is a pt to pt interface */
458         Runi = (1 << 3),        /* a unicast self address */
459         Rbcast = (1 << 4),      /* a broadcast self address */
460         Rmulti = (1 << 5),      /* a multicast self address */
461         Rproxy = (1 << 6),      /* this route should be proxied */
462 };
463
464 struct routewalk {
465         int o;
466         int h;
467         char *p;
468         char *e;
469         void *state;
470         void (*walk) (struct route *, struct routewalk *);
471 };
472
473 struct RouteTree {
474         struct route *right;
475         struct route *left;
476         struct route *mid;
477         uint8_t depth;
478         uint8_t type;
479         uint8_t ifcid;          /* must match ifc->id */
480         struct Ipifc *ifc;
481         char tag[4];
482         struct kref kref;
483 };
484
485 struct V4route {
486         uint32_t address;
487         uint32_t endaddress;
488         uint8_t gate[IPv4addrlen];
489 };
490
491 struct V6route {
492         uint32_t address[IPllen];
493         uint32_t endaddress[IPllen];
494         uint8_t gate[IPaddrlen];
495 };
496
497 struct route {
498         struct RouteTree rt;
499
500         union {
501                 struct V6route v6;
502                 struct V4route v4;
503         };
504 };
505 extern void v4addroute(struct Fs *f, char *tag, uint8_t * a, uint8_t * mask,
506                        uint8_t * gate, int type);
507 extern void v6addroute(struct Fs *f, char *tag, uint8_t * a, uint8_t * mask,
508                        uint8_t * gate, int type);
509 extern void v4delroute(struct Fs *f, uint8_t * a, uint8_t * mask, int dolock);
510 extern void v6delroute(struct Fs *f, uint8_t * a, uint8_t * mask, int dolock);
511 extern struct route *v4lookup(struct Fs *f, uint8_t * a, struct conv *c);
512 extern struct route *v6lookup(struct Fs *f, uint8_t * a, struct conv *c);
513 extern long routeread(struct Fs *f, char *unused_char_p_t, uint32_t, int);
514 extern long routewrite(struct Fs *f, struct chan *, char *unused_char_p_t,
515                        size_t);
516 extern void routetype(int unused_int, char *unused_char_p_t);
517 extern void ipwalkroutes(struct Fs *, struct routewalk *);
518 extern void convroute(struct route *r, uint8_t * u8pt, uint8_t * u8pt1,
519                       uint8_t * u8pt2, char *unused_char_p_t, int *intp);
520
521 /*
522  *  devip.c
523  */
524
525 /*
526  *  Hanging off every ip channel's ->aux is the following structure.
527  *  It maintains the state used by devip and iproute.
528  */
529 struct IPaux {
530         char *owner;            /* the user that did the attach */
531         char tag[4];
532 };
533
534 extern struct IPaux *newipaux(char *unused_char_p_t, char *);
535
536 /*
537  *  arp.c
538  */
539 struct arpent {
540         uint8_t ip[IPaddrlen];
541         uint8_t mac[MAClen];
542         struct medium *type;    /* media type */
543         struct arpent *hash;
544         struct block *hold;
545         struct block *last;
546         uint64_t ctime;         /* time entry was created or refreshed */
547         uint64_t utime;         /* time entry was last used */
548         uint8_t state;
549         struct arpent *nextrxt; /* re-transmit chain */
550         uint64_t rtime;         /* time for next retransmission */
551         uint8_t rxtsrem;
552         struct Ipifc *ifc;
553         uint8_t ifcid;          /* must match ifc->id */
554 };
555
556 extern void arpinit(struct Fs *);
557 extern int arpread(struct arp *, char *unused_char_p_t, uint32_t, int);
558 extern int arpwrite(struct Fs *, char *unused_char_p_t, long);
559 extern struct arpent *arpget(struct arp *, struct block *bp, int version,
560                              struct Ipifc *ifc, uint8_t * ip, uint8_t * h);
561 extern void arprelease(struct arp *, struct arpent *a);
562 extern struct block *arpresolve(struct arp *, struct arpent *a,
563                                 struct medium *type, uint8_t * mac);
564 extern void arpenter(struct Fs *, int version, uint8_t * ip, uint8_t * mac,
565                      int len, int norefresh);
566
567 /*
568  * ipaux.c
569  */
570
571 extern int myetheraddr(uint8_t * unused_uint8_p_t, char *unused_char_p_t);
572 extern uint32_t parseip(uint8_t * unused_uint8_p_t, char *unused_char_p_t);
573 extern uint32_t parseipmask(uint8_t * unused_uint8_p_t, char *unused_char_p_t);
574 extern char *v4parseip(uint8_t * unused_uint8_p_t, char *unused_char_p_t);
575 extern void maskip(uint8_t * from, uint8_t * mask, uint8_t * to);
576 extern int parsemac(uint8_t * to, char *from, int len);
577 extern uint8_t *defmask(uint8_t * unused_uint8_p_t);
578 extern int isv4(uint8_t * unused_uint8_p_t);
579 extern void v4tov6(uint8_t * v6, uint8_t * v4);
580 extern int v6tov4(uint8_t * v4, uint8_t * v6);
581 //extern int    eipfmt(Fmt*);
582
583
584 #ifdef CONFIG_RISCV
585 #warning "Potentially unaligned IP addrs!"
586 #endif
587 static inline void ipmove(unsigned char *x, unsigned char *y)
588 {
589         uint32_t *a = (uint32_t *)x;
590         uint32_t *b = (uint32_t *)y;
591
592         a[0] = b[0];
593         a[1] = b[1];
594         a[2] = b[2];
595         a[3] = b[3];
596 }
597
598 static inline long ipcmp(unsigned char *x, unsigned char *y)
599 {
600         uint32_t *a = (uint32_t *)x;
601         uint32_t *b = (uint32_t *)y;
602
603         return (a[0] ^ b[0]) | (a[1] ^ b[1]) |
604                 (a[2] ^ b[2]) | (a[3] ^ b[3]);
605 }
606
607
608 extern uint8_t IPv4_loopback[IPaddrlen];
609 extern uint8_t IPv4_zeroes[IPaddrlen];
610 extern uint8_t IPv4bcast[IPaddrlen];
611 extern uint8_t IPv4bcastobs[IPaddrlen];
612 extern uint8_t IPv4allsys[IPaddrlen];
613 extern uint8_t IPv4allrouter[IPaddrlen];
614 extern uint8_t IPnoaddr[IPaddrlen];
615 extern uint8_t v4prefix[IPaddrlen];
616 extern uint8_t IPallbits[IPaddrlen];
617
618 /*
619  *  media
620  */
621 extern struct medium ethermedium;
622 extern struct medium nullmedium;
623 extern struct medium pktmedium;
624 extern struct medium tripmedium;
625
626 /*
627  *  ipifc.c
628  */
629 extern struct medium *ipfindmedium(char *name);
630 extern void addipmedium(struct medium *med);
631 extern int ipforme(struct Fs *, uint8_t * addr);
632 extern int iptentative(struct Fs *, uint8_t * addr);
633 extern int ipisbm(uint8_t *);
634 extern int ipismulticast(uint8_t *);
635 extern struct Ipifc *findipifc(struct Fs *, uint8_t * remote, int type);
636 extern void findprimaryip(struct Fs *, uint8_t * unused_uint8_p_t);
637 extern void findlocalip(struct Fs *, uint8_t * local, uint8_t * remote);
638 extern int ipv4local(struct Ipifc *ifc, uint8_t * addr);
639 extern int ipv6local(struct Ipifc *ifc, uint8_t * addr);
640 extern int ipv6anylocal(struct Ipifc *ifc, uint8_t * addr);
641 extern struct Iplifc *iplocalonifc(struct Ipifc *ifc, uint8_t * ip);
642 extern int ipproxyifc(struct Fs *f, struct Ipifc *ifc, uint8_t * ip);
643 extern int ipismulticast(uint8_t * ip);
644 extern int ipisbooting(void);
645 extern int ipifccheckin(struct Ipifc *ifc, struct medium *med);
646 extern void ipifccheckout(struct Ipifc *ifc);
647 extern int ipifcgrab(struct Ipifc *ifc);
648 extern void ipifcaddroute(struct Fs *, int unused_int,
649                           uint8_t * unused_uint8_p_t, uint8_t *, uint8_t *,
650                                                   int);
651 extern void ipifcremroute(struct Fs *, int unused_int, uint8_t * u8pt,
652                           uint8_t * u8pt2);
653 extern void ipifcremmulti(struct conv *c, uint8_t * ma, uint8_t * ia);
654 extern void ipifcaddmulti(struct conv *c, uint8_t * ma, uint8_t * ia);
655 extern void ipifc_trace_block(struct Ipifc *ifc, struct block *bp);
656 extern long ipselftabread(struct Fs *, char *a, uint32_t offset, int n);
657 extern void ipsendra6(struct Fs *f, int on);
658
659 /*
660  *  ip.c
661  */
662 extern void iprouting(struct Fs *, int);
663 extern void icmpnoconv(struct Fs *, struct block *);
664 extern void icmpcantfrag(struct Fs *, struct block *, int);
665 extern void icmpttlexceeded(struct Fs *, uint8_t * unused_uint8_p_t,
666                             struct block *);
667
668 uint16_t ipchecksum(uint8_t *addr, int len);
669 extern uint16_t ipcsum(uint8_t * unused_uint8_p_t);
670 extern void ipiput4(struct Fs *, struct Ipifc *unused_ipifc, struct block *);
671 extern void ipiput6(struct Fs *, struct Ipifc *unused_ipifc, struct block *);
672 extern int ipoput4(struct Fs *, struct block *, int unused_int, int, int,
673                    struct conv *);
674 extern int ipoput6(struct Fs *, struct block *, int unused_int, int, int,
675                    struct conv *);
676 extern int ipstats(struct Fs *, char *unused_char_p_t, int);
677 extern uint16_t ptclbsum(uint8_t * unused_uint8_p_t, int);
678 extern uint16_t ptclcsum(struct block *, int unused_int, int);
679 extern void ip_init(struct Fs *);
680 extern void update_mtucache(uint8_t * unused_uint8_p_t, uint32_t);
681 extern uint32_t restrict_mtu(uint8_t * unused_uint8_p_t, uint32_t);
682
683 /* We support transport layer checksum offloading.  If a NIC doesn't support
684  * it, we'll finish it in software here.
685  *
686  * We've checksummed pseudo header in advance.  The remaining bits that need to
687  * be csummed is the entire transport layer (header + data).  The NICs (and
688  * this function) expect the PH to be done already and stored in the transport
689  * layer's csum location.  This function wants to know where that is in a
690  * protocol-independent manner, hence the tx_csum_offset. */
691 static inline void ptclcsum_finalize(struct block *bp, unsigned int feat)
692 {
693         unsigned int flag = bp->flag & BLOCK_TRANS_TX_CSUM;
694         uint8_t *csum_store;
695
696         if (flag && (flag & feat) != flag) {
697                 csum_store = bp->rp + bp->transport_offset + bp->tx_csum_offset;
698                 /* NOTE pseudo-header partial checksum (if any) is already
699                  * placed at csum_store (e.g. tcpcksum), and the ptclcsum()
700                  * below will include that partial checksum as part of the
701                  * calculation.
702                  */
703                 hnputs((uint16_t *)csum_store,
704                        ptclcsum(bp, bp->transport_offset,
705                                 BLEN(bp) - bp->transport_offset));
706                 bp->flag &= ~BLOCK_TRANS_TX_CSUM;
707         }
708 }
709
710 /*
711  *  iprouter.c
712  */
713 void useriprouter(struct Fs *, struct Ipifc *unused_ipifc, struct block *);
714 void iprouteropen(struct Fs *);
715 void iprouterclose(struct Fs *);
716 long iprouterread(struct Fs *, void *, int);
717
718 /*
719  *  resolving inferno/plan9 differences
720  */
721 struct chan *commonfdtochan(int unused_int, int, int, int);
722 char *commonuser(void);
723 char *commonerror(void);
724
725 /*
726  * chandial.c
727  */
728 extern struct chan *chandial(char *u1, char *u2, char *u3, struct chan **c);
729
730 /*
731  *  global to all of the stack
732  */
733 extern void (*igmpreportfn) (struct Ipifc * unused_ipifc,
734                              uint8_t * unused_uint8_p_t);
735
736 /* IPV6 */
737 /* rfc 3513 defines the address prefices */
738 #define isv6mcast(addr)   ((addr)[0] == 0xff)
739 #define islinklocal(addr) ((addr)[0] == 0xfe && ((addr)[1] & 0xc0) == 0x80)
740 #define issitelocal(addr) ((addr)[0] == 0xfe && ((addr)[1] & 0xc0) == 0xc0)
741 #define isv6global(addr) (((addr)[0] & 0xe0) == 0x20)
742
743 #define optexsts(np) (nhgets((np)->ploadlen) > 24)
744 #define issmcast(addr) (memcmp((addr), v6solicitednode, 13) == 0)
745
746 /* from RFC 2460 */
747
748 typedef struct Ip4hdr Ip4hdr;
749 typedef struct ip6hdr Ip6hdr;
750 typedef struct Opthdr Opthdr;
751 typedef struct Routinghdr Routinghdr;
752 typedef struct Fraghdr6 Fraghdr6;
753
754 struct Ip4hdr {
755         uint8_t vihl;                   /* Version and header length */
756         uint8_t tos;                    /* Type of service */
757         uint8_t length[2];              /* packet length */
758         uint8_t id[2];                  /* ip->identification */
759         uint8_t frag[2];                /* Fragment information */
760         uint8_t ttl;                    /* Time to live */
761         uint8_t proto;                  /* Protocol */
762         uint8_t cksum[2];               /* Header checksum */
763         uint8_t src[4];                 /* IP source */
764         uint8_t dst[4];                 /* IP destination */
765 };
766
767 struct ip6hdr {
768         uint8_t vcf[4];         // version:4, traffic class:8, flow label:20
769         uint8_t ploadlen[2];    // payload length: packet length - 40
770         uint8_t proto;          // next header type
771         uint8_t ttl;            // hop limit
772         uint8_t src[IPaddrlen];
773         uint8_t dst[IPaddrlen];
774 };
775
776 struct Opthdr {
777         uint8_t nexthdr;
778         uint8_t len;
779 };
780
781 struct Routinghdr {
782         uint8_t nexthdr;
783         uint8_t len;
784         uint8_t rtetype;
785         uint8_t segrem;
786 };
787
788 struct fraghdr6 {
789         uint8_t nexthdr;
790         uint8_t res;
791         uint8_t offsetRM[2];            // Offset, Res, M flag
792         uint8_t id[4];
793 };
794
795 enum {                                  /* Header Types */
796         HBH = 0,
797         ICMP = 1,
798         IGMP = 2,
799         GGP = 3,
800         IPINIP = 4,
801         ST = 5,
802         TCP = 6,
803         UDP = 17,
804         ISO_TP4 = 29,
805         RH = 43,
806         FH = 44,
807         IDRP = 45,
808         RSVP = 46,
809         AH = 51,
810         ESP = 52,
811         ICMPv6 = 58,
812         NNH = 59,
813         DOH = 60,
814         ISO_IP = 80,
815         IGRP = 88,
816         OSPF = 89,
817
818         Maxhdrtype = 256,
819 };
820
821 enum {
822         //  multicast flgs and scop
823
824         well_known_flg = 0,
825         transient_flg = 1,
826
827         node_local_scop = 1,
828         link_local_scop = 2,
829         site_local_scop = 5,
830         org_local_scop = 8,
831         global_scop = 14,
832
833         //  various prefix lengths
834
835         SOLN_PREF_LEN = 13,
836
837         //  icmpv6 unreach codes
838         icmp6_no_route = 0,
839         icmp6_ad_prohib = 1,
840         icmp6_unassigned = 2,
841         icmp6_adr_unreach = 3,
842         icmp6_port_unreach = 4,
843         icmp6_unkn_code = 5,
844
845         //  various flags & constants
846
847         v6MINTU = 1280,
848         HOP_LIMIT = 255,
849         ETHERHDR_LEN = 14,
850         IPV6HDR_LEN = 40,
851         IPV4HDR_LEN = 20,
852
853         //  option types
854
855         SRC_LLADDRESS = 1,
856         TARGET_LLADDRESS = 2,
857         PREFIX_INFO = 3,
858         REDIR_HEADER = 4,
859         MTU_OPTION = 5,
860
861         SRC_UNSPEC = 0,
862         SRC_UNI = 1,
863         TARG_UNI = 2,
864         TARG_MULTI = 3,
865
866         t_unitent = 1,
867         t_uniproxy = 2,
868         t_unirany = 3,
869
870         //  Router constants (all times in milliseconds)
871
872         MAX_INITIAL_RTR_ADVERT_INTERVAL = 16000,
873         MAX_INITIAL_RTR_ADVERTISEMENTS = 3,
874         MAX_FINAL_RTR_ADVERTISEMENTS = 3,
875         MIN_DELAY_BETWEEN_RAS = 3000,
876         MAX_RA_DELAY_TIME = 500,
877
878         //  Host constants
879
880         MAX_RTR_SOLICITATION_DELAY = 1000,
881         RTR_SOLICITATION_INTERVAL = 4000,
882         MAX_RTR_SOLICITATIONS = 3,
883
884         //  Node constants
885
886         MAX_MULTICAST_SOLICIT = 3,
887         MAX_UNICAST_SOLICIT = 3,
888         MAX_ANYCAST_DELAY_TIME = 1000,
889         MAX_NEIGHBOR_ADVERTISEMENT = 3,
890         REACHABLE_TIME = 30000,
891         RETRANS_TIMER = 1000,
892         DELAY_FIRST_PROBE_TIME = 5000,
893
894 };
895
896 static inline struct Ip4hdr *ipv4_hdr(struct block *bp)
897 {
898         return (struct Ip4hdr*)(bp->rp + bp->network_offset);
899 }
900
901 static inline struct ip6hdr *ipv6_hdr(struct block *bp)
902 {
903         return (struct ip6hdr*)(bp->rp + bp->network_offset);
904 }
905
906 static inline unsigned int ip_version(struct block *bp)
907 {
908         struct Ip4hdr *hdr = ipv4_hdr(bp);
909
910         return hdr->vihl >> 4;
911 }
912
913 extern void ipv62smcast(uint8_t *, uint8_t *);
914 extern void icmpns(struct Fs *f, uint8_t * src, int suni, uint8_t * targ,
915                    int tuni, uint8_t * mac);
916 extern void icmpna(struct Fs *f, uint8_t * src, uint8_t * dst, uint8_t * targ,
917                    uint8_t * mac, uint8_t flags);
918 extern void icmpttlexceeded6(struct Fs *f, struct Ipifc *ifc, struct block *bp);
919 extern void icmppkttoobig6(struct Fs *f, struct Ipifc *ifc, struct block *bp);
920 extern void icmphostunr(struct Fs *f, struct Ipifc *ifc, struct block *bp,
921                         int code, int free);
922
923 extern uint8_t v6allnodesN[IPaddrlen];
924 extern uint8_t v6allnodesL[IPaddrlen];
925 extern uint8_t v6allroutersN[IPaddrlen];
926 extern uint8_t v6allroutersL[IPaddrlen];
927 extern uint8_t v6allnodesNmask[IPaddrlen];
928 extern uint8_t v6allnodesLmask[IPaddrlen];
929 extern uint8_t v6allroutersS[IPaddrlen];
930 extern uint8_t v6solicitednode[IPaddrlen];
931 extern uint8_t v6solicitednodemask[IPaddrlen];
932 extern uint8_t v6Unspecified[IPaddrlen];
933 extern uint8_t v6loopback[IPaddrlen];
934 extern uint8_t v6loopbackmask[IPaddrlen];
935 extern uint8_t v6linklocal[IPaddrlen];
936 extern uint8_t v6linklocalmask[IPaddrlen];
937 extern uint8_t v6sitelocal[IPaddrlen];
938 extern uint8_t v6sitelocalmask[IPaddrlen];
939 extern uint8_t v6glunicast[IPaddrlen];
940 extern uint8_t v6multicast[IPaddrlen];
941 extern uint8_t v6multicastmask[IPaddrlen];
942
943 extern int v6llpreflen;
944 extern int v6slpreflen;
945 extern int v6lbpreflen;
946 extern int v6mcpreflen;
947 extern int v6snpreflen;
948 extern int v6aNpreflen;
949 extern int v6aLpreflen;
950
951 extern int ReTransTimer;
952
953 int kdial(char *dest, char *local, char *dir, int *cfdp);
954
955 /* network interfaces and ethernet */
956
957 enum {
958         Nmaxaddr = 64,
959         Nmhash = 31,
960
961         Ncloneqid = 1,
962         Naddrqid,
963         N2ndqid,
964         N3rdqid,
965         Ndataqid,
966         Nctlqid,
967         Nstatqid,
968         Ntypeqid,
969         Nifstatqid,
970 };
971
972 /*
973  *  Macros to manage Qid's used for multiplexed devices
974  */
975 #define NETTYPE(x)      (((uint32_t)x)&0x1f)
976 /* The net's ID + 1 is stored starting at 1 << 5.  So ID 0 = 32, ID 1 = 64, and
977  * NETID == -1 means no netid */
978 #define NETID(x)        (((uint32_t)(x) >> 5) - 1)
979 #define NETQID(i,t)     ((((uint32_t)(i) + 1) << 5) | (t))
980
981 /*
982  *  one per multiplexed connection
983  */
984 struct netfile {
985         qlock_t qlock;
986
987         int inuse;
988         uint32_t mode;
989         char owner[KNAMELEN];
990
991         int type;               /* multiplexor type */
992         int prom;               /* promiscuous mode */
993         int scan;               /* base station scanning interval */
994         int bridge;             /* bridge mode */
995         int headersonly;        /* headers only - no data */
996         uint8_t maddr[8];       /* bitmask of multicast addresses requested */
997         int nmaddr;             /* number of multicast addresses */
998
999         struct queue *in;       /* input buffer */
1000 };
1001
1002 /*
1003  *  a network address
1004  */
1005 struct netaddr {
1006         struct netaddr *next;   /* allocation chain */
1007         struct netaddr *hnext;
1008         uint8_t addr[Nmaxaddr];
1009         int ref; /* leaving this as an int, not a kref.  no reaping, yet. */
1010 };
1011
1012 /*
1013  * These flags overlap with block flags, to make detecting unsupported
1014  * offloads efficient.
1015  */
1016 #define NETF_BASE_SHIFT         (NS_SHIFT_MAX + 1)
1017 #define NETF_PADMIN_SHIFT       (NETF_BASE_SHIFT + 0)
1018 #define NETF_SG_SHIFT           (NETF_BASE_SHIFT + 1)
1019 #define NETF_LRO_SHIFT          (NETF_BASE_SHIFT + 2)
1020 #define NETF_RXCSUM_SHIFT       (NETF_BASE_SHIFT + 3)
1021 enum {
1022         NETF_IPCK = (1 << NS_IPCK_SHIFT),       /* xmit ip checksum */
1023         NETF_UDPCK = (1 << NS_UDPCK_SHIFT),     /* xmit udp checksum */
1024         NETF_TCPCK = (1 << NS_TCPCK_SHIFT),     /* xmit tcp checksum */
1025         NETF_PADMIN = (1 << NETF_PADMIN_SHIFT), /* device pads to mintu */
1026         NETF_SG = (1 << NETF_SG_SHIFT),         /* can do scatter/gather */
1027         NETF_TSO = (1 << NS_TSO_SHIFT),         /* device can do TSO */
1028         NETF_LRO = (1 << NETF_LRO_SHIFT),       /* device can do LRO */
1029         NETF_RXCSUM = (1 << NETF_RXCSUM_SHIFT), /* device can do rx checksums */
1030 };
1031
1032 /* Linux's rtnl_link_stats64 */
1033 struct netif_stats {
1034         uint64_t                rx_packets;     /* total packets received */
1035         uint64_t                tx_packets;     /* total packets transmitted */
1036         uint64_t                rx_bytes;       /* total bytes received */
1037         uint64_t                tx_bytes;       /* total bytes transmitted */
1038         uint64_t                rx_errors;      /* bad packets received */
1039         uint64_t                tx_errors;      /* packet transmit problems */
1040         uint64_t                rx_dropped;     /* no space in linux buffers */
1041         uint64_t                tx_dropped;     /* no space available in linux*/
1042         uint64_t                multicast;      /* multicast packets received */
1043         uint64_t                collisions;
1044
1045         /* detailed rx_errors: */
1046         uint64_t                rx_length_errors;
1047         uint64_t                rx_over_errors; /* recv'r ring buff overflow */
1048         uint64_t                rx_crc_errors;  /* recv'd pkt with crc error */
1049         uint64_t                rx_frame_errors;/* recv'd frame alignment err */
1050         uint64_t                rx_fifo_errors; /* recv'r fifo overrun */
1051         uint64_t                rx_missed_errors; /* receiver missed packet */
1052
1053         /* detailed tx_errors */
1054         uint64_t                tx_aborted_errors;
1055         uint64_t                tx_carrier_errors;
1056         uint64_t                tx_fifo_errors;
1057         uint64_t                tx_heartbeat_errors;
1058         uint64_t                tx_window_errors;
1059
1060         /* for cslip etc */
1061         uint64_t                rx_compressed;
1062         uint64_t                tx_compressed;
1063         uint64_t                rx_nohandler;   /* dropped, no handler found */
1064 };
1065
1066 /*
1067  *  a network interface
1068  */
1069 struct ether;
1070 struct netif {
1071         qlock_t qlock;
1072
1073         /* multiplexing */
1074         char name[KNAMELEN];    /* for top level directory */
1075         char drv_name[KNAMELEN];/* device driver name */
1076         int nfile;              /* max number of Netfiles */
1077         struct netfile **f;
1078
1079         /* about net */
1080         int limit;              /* flow control */
1081         int alen;               /* address length */
1082         int mbps;               /* megabits per sec */
1083         int link;               /* link status (seems to be driver specific) */
1084         struct rendez link_rz;
1085         bool link_is_up;
1086         unsigned int feat;      /* dev features turned on */
1087         unsigned int hw_features;       /* dev features available */
1088         uint8_t addr[Nmaxaddr];
1089         uint8_t bcast[Nmaxaddr];
1090         struct netaddr *maddr;  /* known multicast addresses */
1091         int nmaddr;             /* number of known multicast addresses */
1092         struct netaddr *mhash[Nmhash];  /* hash table of multicast addresses */
1093         int prom;               /* number of promiscuous opens */
1094         int scan;               /* number of base station scanners */
1095         int all;                /* number of -1 multiplexors */
1096         /* Analogous to linux's IFF_PROMISC flags, currently used by linux
1097          * drivers, pending a rewrite of ow promiscuous works */
1098         int rx_mode;
1099
1100         /* 9ns statistics */
1101         int misses;
1102         int inpackets;
1103         int outpackets;
1104         int crcs;                       /* input crc errors */
1105         int oerrs;                      /* output errors */
1106         int frames;                     /* framing errors */
1107         int overflows;                  /* packet overflows */
1108         int buffs;                      /* buffering errors */
1109         int soverflows;                 /* software overflow */
1110         /* Linux-style statistics */
1111         struct netif_stats stats;
1112
1113         /* routines for touching the hardware */
1114         void *arg;
1115         void (*promiscuous) (void *, int);
1116         void (*multicast) (void *, uint8_t * unused_uint8_p_t, int);
1117         void (*scanbs) (void *, unsigned nt);   /* scan for base stations */
1118 };
1119
1120 void netifinit(struct ether *, char *, int, uint32_t);
1121 struct walkqid *netifwalk(struct ether *, struct chan *, struct chan *, char **,
1122                           int);
1123 struct chan *netifopen(struct ether *, struct chan *, int);
1124 void netifclose(struct ether *, struct chan *);
1125 long netifread(struct ether *, struct chan *, void *, long, uint32_t);
1126 struct block *netifbread(struct ether *, struct chan *, long, uint32_t);
1127 long netifwrite(struct ether *, struct chan *, void *, long);
1128 int netifwstat(struct ether *, struct chan *, uint8_t *, int);
1129 int netifstat(struct ether *, struct chan *, uint8_t *, int);
1130 ssize_t linux_ifstat(struct netif_stats *stats, void *va, size_t amt,
1131                      off_t offset);
1132 int activemulti(struct ether *, uint8_t *, int);
1133
1134 /*
1135  *  Ethernet specific
1136  */
1137 enum {
1138         Eaddrlen = 6,
1139         ETHERMINTU = 60,        /* minimum transmit size */
1140         ETHERMAXTU = 1500,      /* maximum transmit size */
1141         ETHERHDRSIZE = 14,      /* size of an ethernet header */
1142 };
1143
1144 struct etherpkt {
1145         uint8_t d[Eaddrlen];
1146         uint8_t s[Eaddrlen];
1147         uint8_t type[2];
1148         uint8_t data[1500];
1149 };
1150 enum {
1151         MaxEther = 32,
1152         MaxFID = 16,
1153         Ntypes = 8,
1154 };
1155
1156 struct ether {
1157         rwlock_t rwlock;
1158         int ctlrno;
1159         char *type;
1160         int irq;
1161         unsigned int tbdf;
1162         int port;
1163         int mtu;
1164         int min_mtu;
1165         int max_mtu;
1166         uint8_t ea[Eaddrlen];
1167         int encry;
1168
1169         void (*attach) (struct ether *);        /* filled in by reset routine */
1170         void (*closed) (struct ether *);
1171         void (*detach) (struct ether *);
1172         void (*transmit) (struct ether *);
1173         long (*ifstat) (struct ether *, void *, long, uint32_t);
1174         long (*ctl) (struct ether *, void *, size_t); /* custom ctl messages */
1175         void (*power) (struct ether *, int);    /* power on/off */
1176         void (*shutdown) (struct ether *); /* shutdown hardware before reboot */
1177         void *ctlr;
1178         int pcmslot;                            /* PCMCIA */
1179         int fullduplex;                         /* non-zero if full duplex */
1180         int vlanid;                             /* non-zero if vlan */
1181
1182         struct queue *oq;
1183
1184         qlock_t vlq;                            /* array change */
1185         int nvlan;
1186         struct ether *vlans[MaxFID];
1187
1188         struct netif;
1189 };
1190
1191 static inline void netif_carrier_on(struct ether *edev)
1192 {
1193         edev->link_is_up = TRUE;
1194         rendez_wakeup(&edev->link_rz);
1195 }
1196
1197 static inline bool netif_carrier_ok(struct ether *edev)
1198 {
1199         return edev->link_is_up;
1200 }
1201
1202 static inline void netif_carrier_off(struct ether *edev)
1203 {
1204         edev->link_is_up = FALSE;
1205 }
1206
1207 static void netif_wait_for_carrier(struct ether *edev)
1208 {
1209         rendez_sleep(&edev->link_rz, (rendez_cond_t)netif_carrier_ok, edev);
1210 }
1211
1212 extern struct block *etheriq(struct ether *, struct block *, int);
1213 extern void addethercard(char *unused_char_p_t, int (*)(struct ether *));
1214 extern int archether(int unused_int, struct ether *);
1215
1216 #define NEXT_RING(x, len) (((x) + 1) % (len))
1217 #define PREV_RING(x, len) (((x) == 0) ? (len) - 1: (x) - 1)