Use .Cd for kernel options.
[dragonfly.git] / share / man / man4 / netgraph.4
1 .\" Copyright (c) 1996-1999 Whistle Communications, Inc.
2 .\" All rights reserved.
3 .\"
4 .\" Subject to the following obligations and disclaimer of warranty, use and
5 .\" redistribution of this software, in source or object code forms, with or
6 .\" without modifications are expressly permitted by Whistle Communications;
7 .\" provided, however, that:
8 .\" 1. Any and all reproductions of the source or object code must include the
9 .\"    copyright notice above and the following disclaimer of warranties; and
10 .\" 2. No rights are granted, in any manner or form, to use Whistle
11 .\"    Communications, Inc. trademarks, including the mark "WHISTLE
12 .\"    COMMUNICATIONS" on advertising, endorsements, or otherwise except as
13 .\"    such appears in the above copyright notice or in the software.
14 .\"
32 .\"
33 .\" Authors: Julian Elischer <>
34 .\"          Archie Cobbs <>
35 .\"
36 .\" $FreeBSD: src/share/man/man4/netgraph.4,v 2001/12/21 09:00:50 ru Exp $
37 .\" $DragonFly: src/share/man/man4/netgraph.4,v 1.5 2006/04/02 16:50:05 swildner Exp $
38 .\" $Whistle: netgraph.4,v 1.7 1999/01/28 23:54:52 julian Exp $
39 .\"
40 .Dd January 19, 1999
42 .Os
43 .Sh NAME
44 .Nm netgraph
45 .Nd graph based kernel networking subsystem
47 The
48 .Nm
49 system provides a uniform and modular system for the implementation
50 of kernel objects which perform various networking functions. The objects,
51 known as
52 .Em nodes ,
53 can be arranged into arbitrarily complicated graphs. Nodes have
54 .Em hooks
55 which are used to connect two nodes together, forming the edges in the graph.
56 Nodes communicate along the edges to process data, implement protocols, etc.
57 .Pp
58 The aim of
59 .Nm
60 is to supplement rather than replace the existing kernel networking
61 infrastructure.  It provides:
62 .Pp
63 .Bl -bullet -compact -offset 2n
64 .It
65 A flexible way of combining protocol and link level drivers
66 .It
67 A modular way to implement new protocols
68 .It
69 A common framework for kernel entities to inter-communicate
70 .It
71 A reasonably fast, kernel-based implementation
72 .El
73 .Sh Nodes and Types
74 The most fundamental concept in
75 .Nm
76 is that of a
77 .Em node .
78 All nodes implement a number of predefined methods which allow them
79 to interact with other nodes in a well defined manner.
80 .Pp
81 Each node has a
82 .Em type ,
83 which is a static property of the node determined at node creation time.
84 A node's type is described by a unique
85 .Tn ASCII
86 type name.
87 The type implies what the node does and how it may be connected
88 to other nodes.
89 .Pp
90 In object-oriented language, types are classes and nodes are instances
91 of their respective class. All node types are subclasses of the generic node
92 type, and hence inherit certain common functionality and capabilities
93 (e.g., the ability to have an
94 .Tn ASCII
95 name).
96 .Pp
97 Nodes may be assigned a globally unique
98 .Tn ASCII
99 name which can be
100 used to refer to the node.
101 The name must not contain the characters
102 .Dq .\&
103 or
104 .Dq \&:
105 and is limited to
106 .Dv "NG_NODELEN + 1"
107 characters (including NUL byte).
108 .Pp
109 Each node instance has a unique
110 .Em ID number
111 which is expressed as a 32-bit hex value. This value may be used to
112 refer to a node when there is no
113 .Tn ASCII
114 name assigned to it.
115 .Sh Hooks
116 Nodes are connected to other nodes by connecting a pair of
117 .Em hooks ,
118 one from each node. Data flows bidirectionally between nodes along
119 connected pairs of hooks.  A node may have as many hooks as it
120 needs, and may assign whatever meaning it wants to a hook.
121 .Pp
122 Hooks have these properties:
123 .Pp
124 .Bl -bullet -compact -offset 2n
125 .It
126 A hook has an
127 .Tn ASCII
128 name which is unique among all hooks
129 on that node (other hooks on other nodes may have the same name).
130 The name must not contain a
131 .Dq .\&
132 or a
133 .Dq \&:
134 and is
135 limited to
136 .Dv "NG_HOOKLEN + 1"
137 characters (including NUL byte).
138 .It
139 A hook is always connected to another hook. That is, hooks are
140 created at the time they are connected, and breaking an edge by
141 removing either hook destroys both hooks.
142 .El
143 .Pp
144 A node may decide to assign special meaning to some hooks.
145 For example, connecting to the hook named
146 .Dq debug
147 might trigger
148 the node to start sending debugging information to that hook.
149 .Sh Data Flow
150 Two types of information flow between nodes: data messages and
151 control messages. Data messages are passed in mbuf chains along the edges
152 in the graph, one edge at a time. The first mbuf in a chain must have the
153 .Dv M_PKTHDR
154 flag set. Each node decides how to handle data coming in on its hooks.
155 .Pp
156 Control messages are type-specific C structures sent from one node
157 directly to some arbitrary other node.  Control messages have a common
158 header format, followed by type-specific data, and are binary structures
159 for efficiency.  However, node types also may support conversion of the
160 type specific data between binary and
161 .Tn ASCII
162 for debugging and human interface purposes (see the
164 and
166 generic control messages below).  Nodes are not required to support
167 these conversions.
168 .Pp
169 There are two ways to address a control message. If
170 there is a sequence of edges connecting the two nodes, the message
171 may be
172 .Dq source routed
173 by specifying the corresponding sequence
174 of hooks as the destination address for the message (relative
175 addressing).  Otherwise, the recipient node global
176 .Tn ASCII
177 name
178 (or equivalent ID based name) is used as the destination address
179 for the message (absolute addressing).  The two types of addressing
180 may be combined, by specifying an absolute start node and a sequence
181 of hooks.
182 .Pp
183 Messages often represent commands that are followed by a reply message
184 in the reverse direction. To facilitate this, the recipient of a
185 control message is supplied with a
186 .Dq return address
187 that is suitable for addressing a reply.
188 .Pp
189 Each control message contains a 32 bit value called a
190 .Em typecookie
191 indicating the type of the message, i.e., how to interpret it.
192 Typically each type defines a unique typecookie for the messages
193 that it understands.  However, a node may choose to recognize and
194 implement more than one type of message.
195 .Sh Netgraph is Functional
196 In order to minimize latency, most
197 .Nm
198 operations are functional.
199 That is, data and control messages are delivered by making function
200 calls rather than by using queues and mailboxes.  For example, if node
201 A wishes to send a data mbuf to neighboring node B, it calls the
202 generic
203 .Nm
204 data delivery function. This function in turn locates
205 node B and calls B's
206 .Dq receive data
207 method. While this mode of operation
208 results in good performance, it has a few implications for node
209 developers:
210 .Pp
211 .Bl -bullet -compact -offset 2n
212 .It
213 Whenever a node delivers a data or control message, the node
214 may need to allow for the possibility of receiving a returning
215 message before the original delivery function call returns.
216 .It
217 Netgraph nodes and support routines generally run inside critical
218 sections.
219 However, some nodes may want to send data and control messages
220 from a different priority level. Netgraph supplies queueing routines which
221 utilize the NETISR system to move message delivery inside a critical
222 section.
223 Note that messages are always received from inside a critical section.
224 .It
225 It's possible for an infinite loop to occur if the graph contains cycles.
226 .El
227 .Pp
228 So far, these issues have not proven problematical in practice.
229 .Sh Interaction With Other Parts of the Kernel
230 A node may have a hidden interaction with other components of the
231 kernel outside of the
232 .Nm
233 subsystem, such as device hardware,
234 kernel protocol stacks, etc.  In fact, one of the benefits of
235 .Nm
236 is the ability to join disparate kernel networking entities together in a
237 consistent communication framework.
238 .Pp
239 An example is the node type
240 .Em socket
241 which is both a netgraph node and a
242 .Xr socket 2
243 .Bx
244 socket in the protocol family
246 Socket nodes allow user processes to participate in
247 .Nm .
248 Other nodes communicate with socket nodes using the usual methods, and the
249 node hides the fact that it is also passing information to and from a
250 cooperating user process.
251 .Pp
252 Another example is a device driver that presents
253 a node interface to the hardware.
254 .Sh Node Methods
255 Nodes are notified of the following actions via function calls
256 to the following node methods (all from inside critical sections)
257 and may accept or reject that action (by returning the appropriate
258 error code):
259 .Bl -tag -width xxx
260 .It Creation of a new node
261 The constructor for the type is called. If creation of a new node is
262 allowed, the constructor must call the generic node creation
263 function (in object-oriented terms, the superclass constructor)
264 and then allocate any special resources it needs. For nodes that
265 correspond to hardware, this is typically done during the device
266 attach routine. Often a global
267 .Tn ASCII
268 name corresponding to the
269 device name is assigned here as well.
270 .It Creation of a new hook
271 The hook is created and tentatively
272 linked to the node, and the node is told about the name that will be
273 used to describe this hook. The node sets up any special data structures
274 it needs, or may reject the connection, based on the name of the hook.
275 .It Successful connection of two hooks
276 After both ends have accepted their
277 hooks, and the links have been made, the nodes get a chance to
278 find out who their peer is across the link and can then decide to reject
279 the connection. Tear-down is automatic.
280 .It Destruction of a hook
281 The node is notified of a broken connection. The node may consider some hooks
282 to be critical to operation and others to be expendable: the disconnection
283 of one hook may be an acceptable event while for another it
284 may affect a total shutdown for the node.
285 .It Shutdown of a node
286 This method allows a node to clean up
287 and to ensure that any actions that need to be performed
288 at this time are taken. The method must call the generic (i.e., superclass)
289 node destructor to get rid of the generic components of the node.
290 Some nodes (usually associated with a piece of hardware) may be
291 .Em persistent
292 in that a shutdown breaks all edges and resets the node,
293 but doesn't remove it, in which case the generic destructor is not called.
294 .El
295 .Sh Sending and Receiving Data
296 Three other methods are also supported by all nodes:
297 .Bl -tag -width xxx
298 .It Receive data message
299 An mbuf chain is passed to the node.
300 The node is notified on which hook the data arrived,
301 and can use this information in its processing decision.
302 The node must must always
303 .Fn m_freem
304 the mbuf chain on completion or error, or pass it on to another node
305 (or kernel module) which will then be responsible for freeing it.
306 .Pp
307 In addition to the mbuf chain itself there is also a pointer to a
308 structure describing meta-data about the message
309 (e.g. priority information). This pointer may be
310 .Dv NULL
311 if there is no additional information. The format for this information is
312 described in
313 .Pa sys/netgraph/netgraph.h .
314 The memory for meta-data must allocated via
315 .Fn malloc
316 with type
317 .Dv M_NETGRAPH .
318 As with the data itself, it is the receiver's responsibility to
319 .Fn free
320 the meta-data. If the mbuf chain is freed the meta-data must
321 be freed at the same time. If the meta-data is freed but the
322 real data on is passed on, then a
323 .Dv NULL
324 pointer must be substituted.
325 .Pp
326 The receiving node may decide to defer the data by queueing it in the
327 .Nm
328 NETISR system (see below).
329 .Pp
330 The structure and use of meta-data is still experimental, but is
331 presently used in frame-relay to indicate that management packets
332 should be queued for transmission
333 at a higher priority than data packets. This is required for
334 conformance with Frame Relay standards.
335 .Pp
336 .It Receive queued data message
337 Usually this will be the same function as
338 .Em Receive data message.
339 This is the entry point called when a data message is being handed to
340 the node after having been queued in the NETISR system.
341 This allows a node to decide in the
342 .Em Receive data message
343 method that a message should be deferred and queued,
344 and be sure that when it is processed from the queue,
345 it will not be queued again.
346 .It Receive control message
347 This method is called when a control message is addressed to the node.
348 A return address is always supplied, giving the address of the node
349 that originated the message so a reply message can be sent anytime later.
350 .Pp
351 It is possible for a synchronous reply to be made, and in fact this
352 is more common in practice.
353 This is done by setting a pointer (supplied as an extra function parameter)
354 to point to the reply.
355 Then when the control message delivery function returns,
356 the caller can check if this pointer has been made non-NULL,
357 and if so then it points to the reply message allocated via
358 .Fn malloc
359 and containing the synchronous response. In both directions,
360 (request and response) it is up to the
361 receiver of that message to
362 .Fn free
363 the control message buffer. All control messages and replies are
364 allocated with
365 .Fn malloc
366 type
367 .Dv M_NETGRAPH .
368 .El
369 .Pp
370 Much use has been made of reference counts, so that nodes being
371 free'd of all references are automatically freed, and this behaviour
372 has been tested and debugged to present a consistent and trustworthy
373 framework for the
374 .Dq type module
375 writer to use.
376 .Sh Addressing
377 The
378 .Nm
379 framework provides an unambiguous and simple to use method of specifically
380 addressing any single node in the graph. The naming of a node is
381 independent of its type, in that another node, or external component
382 need not know anything about the node's type in order to address it so as
383 to send it a generic message type. Node and hook names should be
384 chosen so as to make addresses meaningful.
385 .Pp
386 Addresses are either absolute or relative. An absolute address begins
387 with a node name, (or ID), followed by a colon, followed by a sequence of hook
388 names separated by periods. This addresses the node reached by starting
389 at the named node and following the specified sequence of hooks.
390 A relative address includes only the sequence of hook names, implicitly
391 starting hook traversal at the local node.
392 .Pp
393 There are a couple of special possibilities for the node name.
394 The name
395 .Dq .\&
396 (referred to as
397 .Dq \&.: )
398 always refers to the local node.
399 Also, nodes that have no global name may be addressed by their ID numbers,
400 by enclosing the hex representation of the ID number within square brackets.
401 Here are some examples of valid netgraph addresses:
402 .Bd -literal -offset 4n -compact
404   .:
405   foo:
406   .:hook1
407   foo:hook1.hook2
408   [f057cd80]:hook1
409 .Ed
410 .Pp
411 Consider the following set of nodes might be created for a site with
412 a single physical frame relay line having two active logical DLCI channels,
413 with RFC-1490 frames on DLCI 16 and PPP frames over DLCI 20:
414 .Pp
415 .Bd -literal
416 [type SYNC ]                  [type FRAME]                 [type RFC1490]
417 [ "Frame1" ](uplink)<-->(data)[<un-named>](dlci16)<-->(mux)[<un-named>  ]
418 [    A     ]                  [    B     ](dlci20)<---+    [     C      ]
419                                                       |
420                                                       |      [ type PPP ]
421                                                       +>(mux)[<un-named>]
422                                                              [    D     ]
423 .Ed
424 .Pp
425 One could always send a control message to node C from anywhere
426 by using the name
427 .Em "Frame1:uplink.dlci16" .
428 Similarly,
429 .Em "Frame1:uplink.dlci20"
430 could reliably be used to reach node D, and node A could refer
431 to node B as
432 .Em ".:uplink" ,
433 or simply
434 .Em "uplink" .
435 Conversely, B can refer to A as
436 .Em "data" .
437 The address
438 .Em ""
439 could be used by both nodes C and D to address a message to node A.
440 .Pp
441 Note that this is only for
442 .Em control messages .
443 Data messages are routed one hop at a time, by specifying the departing
444 hook, with each node making the next routing decision. So when B
445 receives a frame on hook
446 .Em data
447 it decodes the frame relay header to determine the DLCI,
448 and then forwards the unwrapped frame to either C or D.
449 .Pp
450 A similar graph might be used to represent multi-link PPP running
451 over an ISDN line:
452 .Pp
453 .Bd -literal
454 [ type BRI ](B1)<--->(link1)[ type MPP  ]
455 [  "ISDN1" ](B2)<--->(link2)[ (no name) ]
456 [          ](D) <-+
457                   |
458  +----------------+
459  |
460  +->(switch)[ type Q.921 ](term1)<---->(datalink)[ type Q.931 ]
461             [ (no name)  ]                       [ (no name)  ]
462 .Ed
463 .Sh Netgraph Structures
464 Interesting members of the node and hook structures are shown below:
465 .Bd -literal
466 struct  ng_node {
467   char    *name;                /* Optional globally unique name */
468   void    *private;             /* Node implementation private info */
469   struct  ng_type *type;        /* The type of this node */
470   int     refs;                 /* Number of references to this struct */
471   int     numhooks;             /* Number of connected hooks */
472   hook_p  hooks;                /* Linked list of (connected) hooks */
473 };
474 typedef struct ng_node *node_p;
476 struct  ng_hook {
477   char           *name;         /* This node's name for this hook */
478   void           *private;      /* Node implementation private info */
479   int            refs;          /* Number of references to this struct */
480   struct ng_node *node;         /* The node this hook is attached to */
481   struct ng_hook *peer;         /* The other hook in this connected pair */
482   struct ng_hook *next;         /* Next in list of hooks for this node */
483 };
484 typedef struct ng_hook *hook_p;
485 .Ed
486 .Pp
487 The maintenance of the name pointers, reference counts, and linked list
488 of hooks for each node is handled automatically by the
489 .Nm
490 subsystem.
491 Typically a node's private info contains a back-pointer to the node or hook
492 structure, which counts as a new reference that must be registered by
493 incrementing
494 .Dv "node->refs" .
495 .Pp
496 From a hook you can obtain the corresponding node, and from
497 a node the list of all active hooks.
498 .Pp
499 Node types are described by these structures:
500 .Bd -literal
501 /** How to convert a control message from binary <-> ASCII */
502 struct ng_cmdlist {
503   u_int32_t                  cookie;     /* typecookie */
504   int                        cmd;        /* command number */
505   const char                 *name;      /* command name */
506   const struct ng_parse_type *mesgType;  /* args if !NGF_RESP */
507   const struct ng_parse_type *respType;  /* args if NGF_RESP */
508 };
510 struct ng_type {
511   u_int32_t version;                    /* Must equal NG_VERSION */
512   const  char *name;                    /* Unique type name */
514   /* Module event handler */
515   modeventhand_t  mod_event;            /* Handle load/unload (optional) */
517   /* Constructor */
518   int    (*constructor)(node_p *node);  /* Create a new node */
520   /** Methods using the node **/
521   int    (*rcvmsg)(node_p node,         /* Receive control message */
522             struct ng_mesg *msg,                /* The message */
523             const char *retaddr,                /* Return address */
524             struct ng_mesg **resp);             /* Synchronous response */
525   int    (*shutdown)(node_p node);      /* Shutdown this node */
526   int    (*newhook)(node_p node,        /* create a new hook */
527             hook_p hook,                        /* Pre-allocated struct */
528             const char *name);                  /* Name for new hook */
530   /** Methods using the hook **/
531   int    (*connect)(hook_p hook);       /* Confirm new hook attachment */
532   int    (*rcvdata)(hook_p hook,        /* Receive data on a hook */
533             struct mbuf *m,                     /* The data in an mbuf */
534             meta_p meta);                       /* Meta-data, if any */
535   int    (*disconnect)(hook_p hook);    /* Notify disconnection of hook */
537   /** How to convert control messages binary <-> ASCII */
538   const struct ng_cmdlist *cmdlist;     /* Optional; may be NULL */
539 };
540 .Ed
541 .Pp
542 Control messages have the following structure:
543 .Bd -literal
544 #define NG_CMDSTRLEN    15      /* Max command string (16 with null) */
546 struct ng_mesg {
547   struct ng_msghdr {
548     u_char      version;        /* Must equal NG_VERSION */
549     u_char      spare;          /* Pad to 2 bytes */
550     u_short     arglen;         /* Length of cmd/resp data */
551     u_long      flags;          /* Message status flags */
552     u_long      token;          /* Reply should have the same token */
553     u_long      typecookie;     /* Node type understanding this message */
554     u_long      cmd;            /* Command identifier */
555     u_char      cmdstr[NG_CMDSTRLEN+1]; /* Cmd string (for debug) */
556   } header;
557   char  data[0];                /* Start of cmd/resp data */
558 };
560 #define NG_VERSION      1               /* Netgraph version */
561 #define NGF_ORIG        0x0000          /* Command */
562 #define NGF_RESP        0x0001          /* Response */
563 .Ed
564 .Pp
565 Control messages have the fixed header shown above, followed by a
566 variable length data section which depends on the type cookie
567 and the command. Each field is explained below:
568 .Bl -tag -width xxx
569 .It Dv version
570 Indicates the version of netgraph itself. The current version is
571 .Dv NG_VERSION .
572 .It Dv arglen
573 This is the length of any extra arguments, which begin at
574 .Dv data .
575 .It Dv flags
576 Indicates whether this is a command or a response control message.
577 .It Dv token
578 The
579 .Dv token
580 is a means by which a sender can match a reply message to the
581 corresponding command message; the reply always has the same token.
582 .Pp
583 .It Dv typecookie
584 The corresponding node type's unique 32-bit value.
585 If a node doesn't recognize the type cookie it must reject the message
586 by returning
587 .Er EINVAL .
588 .Pp
589 Each type should have an include file that defines the commands,
590 argument format, and cookie for its own messages.
591 The typecookie
592 insures that the same header file was included by both sender and
593 receiver; when an incompatible change in the header file is made,
594 the typecookie
595 .Em must
596 be changed.
597 The de facto method for generating unique type cookies is to take the
598 seconds from the epoch at the time the header file is written
599 (i.e., the output of
600 .Dv "date -u +'%s'" ) .
601 .Pp
602 There is a predefined typecookie
604 for the
605 .Dq generic
606 node type, and
607 a corresponding set of generic messages which all nodes understand.
608 The handling of these messages is automatic.
609 .It Dv command
610 The identifier for the message command. This is type specific,
611 and is defined in the same header file as the typecookie.
612 .It Dv cmdstr
613 Room for a short human readable version of
614 .Dq command
615 (for debugging purposes only).
616 .El
617 .Pp
618 Some modules may choose to implement messages from more than one
619 of the header files and thus recognize more than one type cookie.
620 .Sh Control Message ASCII Form
621 Control messages are in binary format for efficiency.  However, for
622 debugging and human interface purposes, and if the node type supports
623 it, control messages may be converted to and from an equivalent
624 .Tn ASCII
625 form.  The
626 .Tn ASCII
627 form is similar to the binary form, with two exceptions:
628 .Pp
629 .Bl -tag -compact -width xxx
630 .It o
631 The
632 .Dv cmdstr
633 header field must contain the
634 .Tn ASCII
635 name of the command, corresponding to the
636 .Dv cmd
637 header field.
638 .It o
639 The
640 .Dv args
641 field contains a NUL-terminated
642 .Tn ASCII
643 string version of the message arguments.
644 .El
645 .Pp
646 In general, the arguments field of a control messgage can be any
647 arbitrary C data type.  Netgraph includes parsing routines to support
648 some pre-defined datatypes in
649 .Tn ASCII
650 with this simple syntax:
651 .Pp
652 .Bl -tag -compact -width xxx
653 .It o
654 Integer types are represented by base 8, 10, or 16 numbers.
655 .It o
656 Strings are enclosed in double quotes and respect the normal
657 C language backslash escapes.
658 .It o
659 IP addresses have the obvious form.
660 .It o
661 Arrays are enclosed in square brackets, with the elements listed
662 consecutively starting at index zero.  An element may have an optional
663 index and equals sign preceding it.  Whenever an element
664 does not have an explicit index, the index is implicitly the previous
665 element's index plus one.
666 .It o
667 Structures are enclosed in curly braces, and each field is specified
668 in the form
669 .Dq fieldname=value .
670 .It o
671 Any array element or structure field whose value is equal to its
672 .Dq default value
673 may be omitted. For integer types, the default value
674 is usually zero; for string types, the empty string.
675 .It o
676 Array elements and structure fields may be specified in any order.
677 .El
678 .Pp
679 Each node type may define its own arbitrary types by providing
680 the necessary routines to parse and unparse.
681 .Tn ASCII
682 forms defined
683 for a specific node type are documented in the documentation for
684 that node type.
685 .Sh Generic Control Messages
686 There are a number of standard predefined messages that will work
687 for any node, as they are supported directly by the framework itself.
688 These are defined in
689 .Pa ng_message.h
690 along with the basic layout of messages and other similar information.
691 .Bl -tag -width xxx
693 Connect to another node, using the supplied hook names on either end.
695 Construct a node of the given type and then connect to it using the
696 supplied hook names.
698 The target node should disconnect from all its neighbours and shut down.
699 Persistent nodes such as those representing physical hardware
700 might not disappear from the node namespace, but only reset themselves.
701 The node must disconnect all of its hooks.
702 This may result in neighbors shutting themselves down, and possibly a
703 cascading shutdown of the entire connected graph.
704 .It Dv NGM_NAME
705 Assign a name to a node. Nodes can exist without having a name, and this
706 is the default for nodes created using the
708 method. Such nodes can only be addressed relatively or by their ID number.
710 Ask the node to break a hook connection to one of its neighbours.
711 Both nodes will have their
712 .Dq disconnect
713 method invoked.
714 Either node may elect to totally shut down as a result.
716 Asks the target node to describe itself. The four returned fields
717 are the node name (if named), the node type, the node ID and the
718 number of hooks attached. The ID is an internal number unique to that node.
720 This returns the information given by
722 but in addition
723 includes an array of fields describing each link, and the description for
724 the node at the far end of that link.
726 This returns an array of node descriptions (as for
727 .Dv NGM_NODEINFO ")"
728 where each entry of the array describes a named node.
729 All named nodes will be described.
731 This is the same as
733 except that all nodes are listed regardless of whether they have a name or not.
735 This returns a list of all currently installed netgraph types.
737 The node may return a text formatted status message.
738 The status information is determined entirely by the node type.
739 It is the only "generic" message
740 that requires any support within the node itself and as such the node may
741 elect to not support this message. The text response must be less than
743 bytes in length (presently 1024). This can be used to return general
744 status information in human readable form.
746 This message converts a binary control message to its
747 .Tn ASCII
748 form.
749 The entire control message to be converted is contained within the
750 arguments field of the
752 message itself.  If successful, the reply will contain the same control
753 message in
754 .Tn ASCII
755 form.
756 A node will typically only know how to translate messages that it
757 itself understands, so the target node of the
759 is often the same node that would actually receive that message.
761 The opposite of
763 The entire control message to be converted, in
764 .Tn ASCII
765 form, is contained
766 in the arguments section of the
768 and need only have the
769 .Dv flags ,
770 .Dv cmdstr ,
771 and
772 .Dv arglen
773 header fields filled in, plus the NUL-terminated string version of
774 the arguments in the arguments field.  If successful, the reply
775 contains the binary version of the control message.
776 .El
777 .Sh Metadata
778 Data moving through the
779 .Nm
780 system can be accompanied by meta-data that describes some
781 aspect of that data. The form of the meta-data is a fixed header,
782 which contains enough information for most uses, and can optionally
783 be supplemented by trailing
784 .Em option
785 structures, which contain a
786 .Em cookie
787 (see the section on control messages), an identifier, a length and optional
788 data. If a node does not recognize the cookie associated with an option,
789 it should ignore that option.
790 .Pp
791 Meta data might include such things as priority, discard eligibility,
792 or special processing requirements. It might also mark a packet for
793 debug status, etc. The use of meta-data is still experimental.
795 The base
796 .Nm
797 code may either be statically compiled
798 into the kernel or else loaded dynamically as a KLD via
799 .Xr kldload 8 .
800 In the former case, include
801 .Pp
802 .D1 Cd options NETGRAPH
803 .Pp
804 in your kernel configuration file. You may also include selected
805 node types in the kernel compilation, for example:
806 .Bd -unfilled -offset indent
807 .Cd options NETGRAPH
808 .Cd options NETGRAPH_SOCKET
809 .Cd options NETGRAPH_ECHO
810 .Ed
811 .Pp
812 Once the
813 .Nm
814 subsystem is loaded, individual node types may be loaded at any time
815 as KLD modules via
816 .Xr kldload 8 .
817 Moreover,
818 .Nm
819 knows how to automatically do this; when a request to create a new
820 node of unknown type
821 .Em type
822 is made,
823 .Nm
824 will attempt to load the KLD module
825 .Pa ng_type.ko .
826 .Pp
827 Types can also be installed at boot time, as certain device drivers
828 may want to export each instance of the device as a netgraph node.
829 .Pp
830 In general, new types can be installed at any time from within the
831 kernel by calling
832 .Fn ng_newtype ,
833 supplying a pointer to the type's
834 .Dv struct ng_type
835 structure.
836 .Pp
837 The
839 macro automates this process by using a linker set.
841 Several node types currently exist. Each is fully documented
842 in its own man page:
843 .Bl -tag -width xxx
844 .It SOCKET
845 The socket type implements two new sockets in the new protocol domain
847 The new sockets protocols are
848 .Dv NG_DATA
849 and
850 .Dv NG_CONTROL ,
851 both of type
852 .Dv SOCK_DGRAM .
853 Typically one of each is associated with a socket node.
854 When both sockets have closed, the node will shut down. The
855 .Dv NG_DATA
856 socket is used for sending and receiving data, while the
858 socket is used for sending and receiving control messages.
859 Data and control messages are passed using the
860 .Xr sendto 2
861 and
862 .Xr recvfrom 2
863 calls, using a
864 .Dv struct sockaddr_ng
865 socket address.
866 .Pp
867 .It HOLE
868 Responds only to generic messages and is a
869 .Dq black hole
870 for data, Useful for testing. Always accepts new hooks.
871 .Pp
872 .It ECHO
873 Responds only to generic messages and always echoes data back through the
874 hook from which it arrived. Returns any non generic messages as their
875 own response. Useful for testing.  Always accepts new hooks.
876 .Pp
877 .It TEE
878 This node is useful for
879 .Dq snooping .
880 It has 4 hooks:
881 .Dv left ,
882 .Dv right ,
883 .Dv left2right ,
884 and
885 .Dv right2left .
886 Data entering from the right is passed to the left and duplicated on
887 .Dv right2left ,
888 and data entering from the left is passed to the right and
889 duplicated on
890 .Dv left2right .
891 Data entering from
892 .Dv left2right
893 is sent to the right and data from
894 .Dv right2left
895 to left.
896 .Pp
897 .It RFC1490 MUX
898 Encapsulates/de-encapsulates frames encoded according to RFC 1490.
899 Has a hook for the encapsulated packets
900 .Pq Dq downstream
901 and one hook
902 for each protocol (i.e., IP, PPP, etc.).
903 .Pp
905 Encapsulates/de-encapsulates Frame Relay frames.
906 Has a hook for the encapsulated packets
907 .Pq Dq downstream
908 and one hook
909 for each DLCI.
910 .Pp
912 Automatically handles frame relay
913 .Dq LMI
914 (link management interface) operations and packets.
915 Automatically probes and detects which of several LMI standards
916 is in use at the exchange.
917 .Pp
918 .It TTY
919 This node is also a line discipline. It simply converts between mbuf
920 frames and sequential serial data, allowing a tty to appear as a netgraph
921 node. It has a programmable
922 .Dq hotkey
923 character.
924 .Pp
925 .It ASYNC
926 This node encapsulates and de-encapsulates asynchronous frames
927 according to RFC 1662. This is used in conjunction with the TTY node
928 type for supporting PPP links over asynchronous serial lines.
929 .Pp
931 This node is also a system networking interface. It has hooks representing
932 each protocol family (IP, AppleTalk, IPX, etc.) and appears in the output of
933 .Xr ifconfig 8 .
934 The interfaces are named
935 .Em ng0 ,
936 .Em ng1 ,
937 etc.
938 .El
939 .Sh NOTES
940 Whether a named node exists can be checked by trying to send a control message
941 to it (e.g.,
942 .Dv NGM_NODEINFO ) .
943 If it does not exist,
944 .Er ENOENT
945 will be returned.
946 .Pp
947 All data messages are mbuf chains with the M_PKTHDR flag set.
948 .Pp
949 Nodes are responsible for freeing what they allocate.
950 There are three exceptions:
951 .Bl -tag -width xxxx
952 .It 1
953 Mbufs sent across a data link are never to be freed by the sender.
954 .It 2
955 Any meta-data information traveling with the data has the same restriction.
956 It might be freed by any node the data passes through, and a
957 .Dv NULL
958 passed onwards, but the caller will never free it.
959 Two macros
960 .Fn NG_FREE_META "meta"
961 and
962 .Fn NG_FREE_DATA "m" "meta"
963 should be used if possible to free data and meta data (see
964 .Pa netgraph.h ) .
965 .It 3
966 Messages sent using
967 .Fn ng_send_message
968 are freed by the callee. As in the case above, the addresses
969 associated with the message are freed by whatever allocated them so the
970 recipient should copy them if it wants to keep that information.
971 .El
972 .Sh FILES
973 .Bl -tag -width xxxxx -compact
974 .It Pa /sys/netgraph/netgraph.h
975 Definitions for use solely within the kernel by
976 .Nm
977 nodes.
978 .It Pa /sys/netgraph/ng_message.h
979 Definitions needed by any file that needs to deal with
980 .Nm
981 messages.
982 .It Pa /sys/netgraph/ng_socket.h
983 Definitions needed to use
984 .Nm
985 socket type nodes.
986 .It Pa /sys/netgraph/ng_{type}.h
987 Definitions needed to use
988 .Nm
989 {type}
990 nodes, including the type cookie definition.
991 .It Pa /modules/netgraph.ko
992 Netgraph subsystem loadable KLD module.
993 .It Pa /modules/ng_{type}.ko
994 Loadable KLD module for node type {type}.
995 .El
997 There is a library for supporting user-mode programs that wish
998 to interact with the netgraph system. See
999 .Xr netgraph 3
1000 for details.
1001 .Pp
1002 Two user-mode support programs,
1003 .Xr ngctl 8
1004 and
1005 .Xr nghook 8 ,
1006 are available to assist manual configuration and debugging.
1007 .Pp
1008 There are a few useful techniques for debugging new node types.
1009 First, implementing new node types in user-mode first
1010 makes debugging easier.
1011 The
1012 .Em tee
1013 node type is also useful for debugging, especially in conjunction with
1014 .Xr ngctl 8
1015 and
1016 .Xr nghook 8 .
1017 .Sh SEE ALSO
1018 .Xr socket 2 ,
1019 .Xr netgraph 3 ,
1020 .Xr ng_async 4 ,
1021 .Xr ng_bpf 4 ,
1022 .Xr ng_cisco 4 ,
1023 .Xr ng_echo 4 ,
1024 .Xr ng_ether 4 ,
1025 .Xr ng_frame_relay 4 ,
1026 .Xr ng_hole 4 ,
1027 .Xr ng_iface 4 ,
1028 .Xr ng_ksocket 4 ,
1029 .Xr ng_lmi 4 ,
1030 .Xr ng_mppc 4 ,
1031 .Xr ng_ppp 4 ,
1032 .Xr ng_pppoe 4 ,
1033 .Xr ng_rfc1490 4 ,
1034 .Xr ng_socket 4 ,
1035 .Xr ng_tee 4 ,
1036 .Xr ng_tty 4 ,
1037 .Xr ng_UI 4 ,
1038 .Xr ng_vjc 4 ,
1039 .Xr ngctl 8 ,
1040 .Xr nghook 8
1041 .Sh HISTORY
1042 The
1043 .Nm
1044 system was designed and first implemented at Whistle Communications, Inc.\&
1045 in a version of
1046 .Fx 2.2
1047 customized for the Whistle InterJet.
1048 It first made its debut in the main tree in
1049 .Fx 3.4 .
1050 .Sh AUTHORS
1051 .An -nosplit
1052 .An Julian Elischer Aq ,
1053 with contributions by
1054 .An Archie Cobbs Aq .