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