1 .\" Copyright (c) 1996-1999 Whistle Communications, Inc.
2 .\" All rights reserved.
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.
15 .\" THIS SOFTWARE IS BEING PROVIDED BY WHISTLE COMMUNICATIONS "AS IS", AND
16 .\" TO THE MAXIMUM EXTENT PERMITTED BY LAW, WHISTLE COMMUNICATIONS MAKES NO
17 .\" REPRESENTATIONS OR WARRANTIES, EXPRESS OR IMPLIED, REGARDING THIS SOFTWARE,
18 .\" INCLUDING WITHOUT LIMITATION, ANY AND ALL IMPLIED WARRANTIES OF
19 .\" MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, OR NON-INFRINGEMENT.
20 .\" WHISTLE COMMUNICATIONS DOES NOT WARRANT, GUARANTEE, OR MAKE ANY
21 .\" REPRESENTATIONS REGARDING THE USE OF, OR THE RESULTS OF THE USE OF THIS
22 .\" SOFTWARE IN TERMS OF ITS CORRECTNESS, ACCURACY, RELIABILITY OR OTHERWISE.
23 .\" IN NO EVENT SHALL WHISTLE COMMUNICATIONS BE LIABLE FOR ANY DAMAGES
24 .\" RESULTING FROM OR ARISING OUT OF ANY USE OF THIS SOFTWARE, INCLUDING
25 .\" WITHOUT LIMITATION, ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY,
26 .\" PUNITIVE, OR CONSEQUENTIAL DAMAGES, PROCUREMENT OF SUBSTITUTE GOODS OR
27 .\" SERVICES, LOSS OF USE, DATA OR PROFITS, HOWEVER CAUSED AND UNDER ANY
28 .\" THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
29 .\" (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
30 .\" THIS SOFTWARE, EVEN IF WHISTLE COMMUNICATIONS IS ADVISED OF THE POSSIBILITY
33 .\" Authors: Julian Elischer <julian@FreeBSD.org>
34 .\" Archie Cobbs <archie@FreeBSD.org>
36 .\" $FreeBSD: src/share/man/man4/netgraph.4,v 1.39.2.1 2001/12/21 09:00:50 ru Exp $
37 .\" $DragonFly: src/share/man/man4/netgraph.4,v 1.2 2003/06/17 04:36:59 dillon Exp $
38 .\" $Whistle: netgraph.4,v 1.7 1999/01/28 23:54:52 julian Exp $
45 .Nd graph based kernel networking subsystem
49 system provides a uniform and modular system for the implementation
50 of kernel objects which perform various networking functions. The objects,
53 can be arranged into arbitrarily complicated graphs. Nodes have
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.
60 is to supplement rather than replace the existing kernel networking
61 infrastructure. It provides:
63 .Bl -bullet -compact -offset 2n
65 A flexible way of combining protocol and link level drivers
67 A modular way to implement new protocols
69 A common framework for kernel entities to inter-communicate
71 A reasonably fast, kernel-based implementation
74 The most fundamental concept in
78 All nodes implement a number of predefined methods which allow them
79 to interact with other nodes in a well defined manner.
83 which is a static property of the node determined at node creation time.
84 A node's type is described by a unique
87 The type implies what the node does and how it may be connected
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
97 Nodes may be assigned a globally unique
100 used to refer to the node.
101 The name must not contain the characters
107 characters (including NUL byte).
109 Each node instance has a unique
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
116 Nodes are connected to other nodes by connecting a pair of
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.
122 Hooks have these properties:
124 .Bl -bullet -compact -offset 2n
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
137 characters (including NUL byte).
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.
144 A node may decide to assign special meaning to some hooks.
145 For example, connecting to the hook named
148 the node to start sending debugging information to that hook.
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
154 flag set. Each node decides how to handle data coming in on its hooks.
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
162 for debugging and human interface purposes (see the
166 generic control messages below). Nodes are not required to support
169 There are two ways to address a control message. If
170 there is a sequence of edges connecting the two nodes, the message
173 by specifying the corresponding sequence
174 of hooks as the destination address for the message (relative
175 addressing). Otherwise, the recipient node global
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
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
187 that is suitable for addressing a reply.
189 Each control message contains a 32 bit value called a
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
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
204 data delivery function. This function in turn locates
207 method. While this mode of operation
208 results in good performance, it has a few implications for node
211 .Bl -bullet -compact -offset 2n
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.
217 Netgraph nodes and support routines generally run at
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 to
223 Note that messages are always received at
226 It's possible for an infinite loop to occur if the graph contains cycles.
229 So far, these issues have not proven problematical in practice.
230 .Sh Interaction With Other Parts of the Kernel
231 A node may have a hidden interaction with other components of the
232 kernel outside of the
234 subsystem, such as device hardware,
235 kernel protocol stacks, etc. In fact, one of the benefits of
237 is the ability to join disparate kernel networking entities together in a
238 consistent communication framework.
240 An example is the node type
242 which is both a netgraph node and a
245 socket in the protocol family
247 Socket nodes allow user processes to participate in
249 Other nodes communicate with socket nodes using the usual methods, and the
250 node hides the fact that it is also passing information to and from a
251 cooperating user process.
253 Another example is a device driver that presents
254 a node interface to the hardware.
256 Nodes are notified of the following actions via function calls
257 to the following node methods (all at
259 and may accept or reject that action (by returning the appropriate
262 .It Creation of a new node
263 The constructor for the type is called. If creation of a new node is
264 allowed, the constructor must call the generic node creation
265 function (in object-oriented terms, the superclass constructor)
266 and then allocate any special resources it needs. For nodes that
267 correspond to hardware, this is typically done during the device
268 attach routine. Often a global
270 name corresponding to the
271 device name is assigned here as well.
272 .It Creation of a new hook
273 The hook is created and tentatively
274 linked to the node, and the node is told about the name that will be
275 used to describe this hook. The node sets up any special data structures
276 it needs, or may reject the connection, based on the name of the hook.
277 .It Successful connection of two hooks
278 After both ends have accepted their
279 hooks, and the links have been made, the nodes get a chance to
280 find out who their peer is across the link and can then decide to reject
281 the connection. Tear-down is automatic.
282 .It Destruction of a hook
283 The node is notified of a broken connection. The node may consider some hooks
284 to be critical to operation and others to be expendable: the disconnection
285 of one hook may be an acceptable event while for another it
286 may affect a total shutdown for the node.
287 .It Shutdown of a node
288 This method allows a node to clean up
289 and to ensure that any actions that need to be performed
290 at this time are taken. The method must call the generic (i.e., superclass)
291 node destructor to get rid of the generic components of the node.
292 Some nodes (usually associated with a piece of hardware) may be
294 in that a shutdown breaks all edges and resets the node,
295 but doesn't remove it, in which case the generic destructor is not called.
297 .Sh Sending and Receiving Data
298 Three other methods are also supported by all nodes:
300 .It Receive data message
301 An mbuf chain is passed to the node.
302 The node is notified on which hook the data arrived,
303 and can use this information in its processing decision.
304 The node must must always
306 the mbuf chain on completion or error, or pass it on to another node
307 (or kernel module) which will then be responsible for freeing it.
309 In addition to the mbuf chain itself there is also a pointer to a
310 structure describing meta-data about the message
311 (e.g. priority information). This pointer may be
313 if there is no additional information. The format for this information is
315 .Pa sys/netgraph/netgraph.h .
316 The memory for meta-data must allocated via
320 As with the data itself, it is the receiver's responsibility to
322 the meta-data. If the mbuf chain is freed the meta-data must
323 be freed at the same time. If the meta-data is freed but the
324 real data on is passed on, then a
326 pointer must be substituted.
328 The receiving node may decide to defer the data by queueing it in the
330 NETISR system (see below).
332 The structure and use of meta-data is still experimental, but is
333 presently used in frame-relay to indicate that management packets
334 should be queued for transmission
335 at a higher priority than data packets. This is required for
336 conformance with Frame Relay standards.
338 .It Receive queued data message
339 Usually this will be the same function as
340 .Em Receive data message.
341 This is the entry point called when a data message is being handed to
342 the node after having been queued in the NETISR system.
343 This allows a node to decide in the
344 .Em Receive data message
345 method that a message should be deferred and queued,
346 and be sure that when it is processed from the queue,
347 it will not be queued again.
348 .It Receive control message
349 This method is called when a control message is addressed to the node.
350 A return address is always supplied, giving the address of the node
351 that originated the message so a reply message can be sent anytime later.
353 It is possible for a synchronous reply to be made, and in fact this
354 is more common in practice.
355 This is done by setting a pointer (supplied as an extra function parameter)
356 to point to the reply.
357 Then when the control message delivery function returns,
358 the caller can check if this pointer has been made non-NULL,
359 and if so then it points to the reply message allocated via
361 and containing the synchronous response. In both directions,
362 (request and response) it is up to the
363 receiver of that message to
365 the control message buffer. All control messages and replies are
372 Much use has been made of reference counts, so that nodes being
373 free'd of all references are automatically freed, and this behaviour
374 has been tested and debugged to present a consistent and trustworthy
381 framework provides an unambiguous and simple to use method of specifically
382 addressing any single node in the graph. The naming of a node is
383 independent of its type, in that another node, or external component
384 need not know anything about the node's type in order to address it so as
385 to send it a generic message type. Node and hook names should be
386 chosen so as to make addresses meaningful.
388 Addresses are either absolute or relative. An absolute address begins
389 with a node name, (or ID), followed by a colon, followed by a sequence of hook
390 names separated by periods. This addresses the node reached by starting
391 at the named node and following the specified sequence of hooks.
392 A relative address includes only the sequence of hook names, implicitly
393 starting hook traversal at the local node.
395 There are a couple of special possibilities for the node name.
400 always refers to the local node.
401 Also, nodes that have no global name may be addressed by their ID numbers,
402 by enclosing the hex representation of the ID number within square brackets.
403 Here are some examples of valid netgraph addresses:
404 .Bd -literal -offset 4n -compact
413 Consider the following set of nodes might be created for a site with
414 a single physical frame relay line having two active logical DLCI channels,
415 with RFC-1490 frames on DLCI 16 and PPP frames over DLCI 20:
418 [type SYNC ] [type FRAME] [type RFC1490]
419 [ "Frame1" ](uplink)<-->(data)[<un-named>](dlci16)<-->(mux)[<un-named> ]
420 [ A ] [ B ](dlci20)<---+ [ C ]
427 One could always send a control message to node C from anywhere
429 .Em "Frame1:uplink.dlci16" .
431 .Em "Frame1:uplink.dlci20"
432 could reliably be used to reach node D, and node A could refer
437 Conversely, B can refer to A as
441 could be used by both nodes C and D to address a message to node A.
443 Note that this is only for
444 .Em control messages .
445 Data messages are routed one hop at a time, by specifying the departing
446 hook, with each node making the next routing decision. So when B
447 receives a frame on hook
449 it decodes the frame relay header to determine the DLCI,
450 and then forwards the unwrapped frame to either C or D.
452 A similar graph might be used to represent multi-link PPP running
456 [ type BRI ](B1)<--->(link1)[ type MPP ]
457 [ "ISDN1" ](B2)<--->(link2)[ (no name) ]
462 +->(switch)[ type Q.921 ](term1)<---->(datalink)[ type Q.931 ]
463 [ (no name) ] [ (no name) ]
465 .Sh Netgraph Structures
466 Interesting members of the node and hook structures are shown below:
469 char *name; /* Optional globally unique name */
470 void *private; /* Node implementation private info */
471 struct ng_type *type; /* The type of this node */
472 int refs; /* Number of references to this struct */
473 int numhooks; /* Number of connected hooks */
474 hook_p hooks; /* Linked list of (connected) hooks */
476 typedef struct ng_node *node_p;
479 char *name; /* This node's name for this hook */
480 void *private; /* Node implementation private info */
481 int refs; /* Number of references to this struct */
482 struct ng_node *node; /* The node this hook is attached to */
483 struct ng_hook *peer; /* The other hook in this connected pair */
484 struct ng_hook *next; /* Next in list of hooks for this node */
486 typedef struct ng_hook *hook_p;
489 The maintenance of the name pointers, reference counts, and linked list
490 of hooks for each node is handled automatically by the
493 Typically a node's private info contains a back-pointer to the node or hook
494 structure, which counts as a new reference that must be registered by
498 From a hook you can obtain the corresponding node, and from
499 a node the list of all active hooks.
501 Node types are described by these structures:
503 /** How to convert a control message from binary <-> ASCII */
505 u_int32_t cookie; /* typecookie */
506 int cmd; /* command number */
507 const char *name; /* command name */
508 const struct ng_parse_type *mesgType; /* args if !NGF_RESP */
509 const struct ng_parse_type *respType; /* args if NGF_RESP */
513 u_int32_t version; /* Must equal NG_VERSION */
514 const char *name; /* Unique type name */
516 /* Module event handler */
517 modeventhand_t mod_event; /* Handle load/unload (optional) */
520 int (*constructor)(node_p *node); /* Create a new node */
522 /** Methods using the node **/
523 int (*rcvmsg)(node_p node, /* Receive control message */
524 struct ng_mesg *msg, /* The message */
525 const char *retaddr, /* Return address */
526 struct ng_mesg **resp); /* Synchronous response */
527 int (*shutdown)(node_p node); /* Shutdown this node */
528 int (*newhook)(node_p node, /* create a new hook */
529 hook_p hook, /* Pre-allocated struct */
530 const char *name); /* Name for new hook */
532 /** Methods using the hook **/
533 int (*connect)(hook_p hook); /* Confirm new hook attachment */
534 int (*rcvdata)(hook_p hook, /* Receive data on a hook */
535 struct mbuf *m, /* The data in an mbuf */
536 meta_p meta); /* Meta-data, if any */
537 int (*disconnect)(hook_p hook); /* Notify disconnection of hook */
539 /** How to convert control messages binary <-> ASCII */
540 const struct ng_cmdlist *cmdlist; /* Optional; may be NULL */
544 Control messages have the following structure:
546 #define NG_CMDSTRLEN 15 /* Max command string (16 with null) */
550 u_char version; /* Must equal NG_VERSION */
551 u_char spare; /* Pad to 2 bytes */
552 u_short arglen; /* Length of cmd/resp data */
553 u_long flags; /* Message status flags */
554 u_long token; /* Reply should have the same token */
555 u_long typecookie; /* Node type understanding this message */
556 u_long cmd; /* Command identifier */
557 u_char cmdstr[NG_CMDSTRLEN+1]; /* Cmd string (for debug) */
559 char data[0]; /* Start of cmd/resp data */
562 #define NG_VERSION 1 /* Netgraph version */
563 #define NGF_ORIG 0x0000 /* Command */
564 #define NGF_RESP 0x0001 /* Response */
567 Control messages have the fixed header shown above, followed by a
568 variable length data section which depends on the type cookie
569 and the command. Each field is explained below:
572 Indicates the version of netgraph itself. The current version is
575 This is the length of any extra arguments, which begin at
578 Indicates whether this is a command or a response control message.
582 is a means by which a sender can match a reply message to the
583 corresponding command message; the reply always has the same token.
586 The corresponding node type's unique 32-bit value.
587 If a node doesn't recognize the type cookie it must reject the message
591 Each type should have an include file that defines the commands,
592 argument format, and cookie for its own messages.
594 insures that the same header file was included by both sender and
595 receiver; when an incompatible change in the header file is made,
599 The de facto method for generating unique type cookies is to take the
600 seconds from the epoch at the time the header file is written
602 .Dv "date -u +'%s'" ) .
604 There is a predefined typecookie
605 .Dv NGM_GENERIC_COOKIE
609 a corresponding set of generic messages which all nodes understand.
610 The handling of these messages is automatic.
612 The identifier for the message command. This is type specific,
613 and is defined in the same header file as the typecookie.
615 Room for a short human readable version of
617 (for debugging purposes only).
620 Some modules may choose to implement messages from more than one
621 of the header files and thus recognize more than one type cookie.
622 .Sh Control Message ASCII Form
623 Control messages are in binary format for efficiency. However, for
624 debugging and human interface purposes, and if the node type supports
625 it, control messages may be converted to and from an equivalent
629 form is similar to the binary form, with two exceptions:
631 .Bl -tag -compact -width xxx
635 header field must contain the
637 name of the command, corresponding to the
643 field contains a NUL-terminated
645 string version of the message arguments.
648 In general, the arguments field of a control messgage can be any
649 arbitrary C data type. Netgraph includes parsing routines to support
650 some pre-defined datatypes in
652 with this simple syntax:
654 .Bl -tag -compact -width xxx
656 Integer types are represented by base 8, 10, or 16 numbers.
658 Strings are enclosed in double quotes and respect the normal
659 C language backslash escapes.
661 IP addresses have the obvious form.
663 Arrays are enclosed in square brackets, with the elements listed
664 consecutively starting at index zero. An element may have an optional
665 index and equals sign preceding it. Whenever an element
666 does not have an explicit index, the index is implicitly the previous
667 element's index plus one.
669 Structures are enclosed in curly braces, and each field is specified
671 .Dq fieldname=value .
673 Any array element or structure field whose value is equal to its
675 may be omitted. For integer types, the default value
676 is usually zero; for string types, the empty string.
678 Array elements and structure fields may be specified in any order.
681 Each node type may define its own arbitrary types by providing
682 the necessary routines to parse and unparse.
685 for a specific node type are documented in the documentation for
687 .Sh Generic Control Messages
688 There are a number of standard predefined messages that will work
689 for any node, as they are supported directly by the framework itself.
692 along with the basic layout of messages and other similar information.
695 Connect to another node, using the supplied hook names on either end.
697 Construct a node of the given type and then connect to it using the
700 The target node should disconnect from all its neighbours and shut down.
701 Persistent nodes such as those representing physical hardware
702 might not disappear from the node namespace, but only reset themselves.
703 The node must disconnect all of its hooks.
704 This may result in neighbors shutting themselves down, and possibly a
705 cascading shutdown of the entire connected graph.
707 Assign a name to a node. Nodes can exist without having a name, and this
708 is the default for nodes created using the
710 method. Such nodes can only be addressed relatively or by their ID number.
712 Ask the node to break a hook connection to one of its neighbours.
713 Both nodes will have their
716 Either node may elect to totally shut down as a result.
718 Asks the target node to describe itself. The four returned fields
719 are the node name (if named), the node type, the node ID and the
720 number of hooks attached. The ID is an internal number unique to that node.
722 This returns the information given by
725 includes an array of fields describing each link, and the description for
726 the node at the far end of that link.
728 This returns an array of node descriptions (as for
730 where each entry of the array describes a named node.
731 All named nodes will be described.
735 except that all nodes are listed regardless of whether they have a name or not.
737 This returns a list of all currently installed netgraph types.
738 .It Dv NGM_TEXT_STATUS
739 The node may return a text formatted status message.
740 The status information is determined entirely by the node type.
741 It is the only "generic" message
742 that requires any support within the node itself and as such the node may
743 elect to not support this message. The text response must be less than
745 bytes in length (presently 1024). This can be used to return general
746 status information in human readable form.
747 .It Dv NGM_BINARY2ASCII
748 This message converts a binary control message to its
751 The entire control message to be converted is contained within the
752 arguments field of the
754 message itself. If successful, the reply will contain the same control
758 A node will typically only know how to translate messages that it
759 itself understands, so the target node of the
761 is often the same node that would actually receive that message.
762 .It Dv NGM_ASCII2BINARY
764 .Dv NGM_BINARY2ASCII .
765 The entire control message to be converted, in
768 in the arguments section of the
770 and need only have the
775 header fields filled in, plus the NUL-terminated string version of
776 the arguments in the arguments field. If successful, the reply
777 contains the binary version of the control message.
780 Data moving through the
782 system can be accompanied by meta-data that describes some
783 aspect of that data. The form of the meta-data is a fixed header,
784 which contains enough information for most uses, and can optionally
785 be supplemented by trailing
787 structures, which contain a
789 (see the section on control messages), an identifier, a length and optional
790 data. If a node does not recognize the cookie associated with an option,
791 it should ignore that option.
793 Meta data might include such things as priority, discard eligibility,
794 or special processing requirements. It might also mark a packet for
795 debug status, etc. The use of meta-data is still experimental.
799 code may either be statically compiled
800 into the kernel or else loaded dynamically as a KLD via
802 In the former case, include
806 in your kernel configuration file. You may also include selected
807 node types in the kernel compilation, for example:
808 .Bd -literal -offset indent
810 options NETGRAPH_SOCKET
811 options NETGRAPH_ECHO
816 subsystem is loaded, individual node types may be loaded at any time
821 knows how to automatically do this; when a request to create a new
826 will attempt to load the KLD module
829 Types can also be installed at boot time, as certain device drivers
830 may want to export each instance of the device as a netgraph node.
832 In general, new types can be installed at any time from within the
835 supplying a pointer to the type's
841 macro automates this process by using a linker set.
842 .Sh EXISTING NODE TYPES
843 Several node types currently exist. Each is fully documented
847 The socket type implements two new sockets in the new protocol domain
849 The new sockets protocols are
855 Typically one of each is associated with a socket node.
856 When both sockets have closed, the node will shut down. The
858 socket is used for sending and receiving data, while the
860 socket is used for sending and receiving control messages.
861 Data and control messages are passed using the
866 .Dv struct sockaddr_ng
870 Responds only to generic messages and is a
872 for data, Useful for testing. Always accepts new hooks.
875 Responds only to generic messages and always echoes data back through the
876 hook from which it arrived. Returns any non generic messages as their
877 own response. Useful for testing. Always accepts new hooks.
880 This node is useful for
888 Data entering from the right is passed to the left and duplicated on
890 and data entering from the left is passed to the right and
895 is sent to the right and data from
900 Encapsulates/de-encapsulates frames encoded according to RFC 1490.
901 Has a hook for the encapsulated packets
904 for each protocol (i.e., IP, PPP, etc.).
907 Encapsulates/de-encapsulates Frame Relay frames.
908 Has a hook for the encapsulated packets
914 Automatically handles frame relay
916 (link management interface) operations and packets.
917 Automatically probes and detects which of several LMI standards
918 is in use at the exchange.
921 This node is also a line discipline. It simply converts between mbuf
922 frames and sequential serial data, allowing a tty to appear as a netgraph
923 node. It has a programmable
928 This node encapsulates and de-encapsulates asynchronous frames
929 according to RFC 1662. This is used in conjunction with the TTY node
930 type for supporting PPP links over asynchronous serial lines.
933 This node is also a system networking interface. It has hooks representing
934 each protocol family (IP, AppleTalk, IPX, etc.) and appears in the output of
936 The interfaces are named
942 Whether a named node exists can be checked by trying to send a control message
945 If it does not exist,
949 All data messages are mbuf chains with the M_PKTHDR flag set.
951 Nodes are responsible for freeing what they allocate.
952 There are three exceptions:
955 Mbufs sent across a data link are never to be freed by the sender.
957 Any meta-data information traveling with the data has the same restriction.
958 It might be freed by any node the data passes through, and a
960 passed onwards, but the caller will never free it.
962 .Fn NG_FREE_META "meta"
964 .Fn NG_FREE_DATA "m" "meta"
965 should be used if possible to free data and meta data (see
970 are freed by the callee. As in the case above, the addresses
971 associated with the message are freed by whatever allocated them so the
972 recipient should copy them if it wants to keep that information.
975 .Bl -tag -width xxxxx -compact
976 .It Pa /sys/netgraph/netgraph.h
977 Definitions for use solely within the kernel by
980 .It Pa /sys/netgraph/ng_message.h
981 Definitions needed by any file that needs to deal with
984 .It Pa /sys/netgraph/ng_socket.h
985 Definitions needed to use
988 .It Pa /sys/netgraph/ng_{type}.h
989 Definitions needed to use
992 nodes, including the type cookie definition.
993 .It Pa /modules/netgraph.ko
994 Netgraph subsystem loadable KLD module.
995 .It Pa /modules/ng_{type}.ko
996 Loadable KLD module for node type {type}.
998 .Sh USER MODE SUPPORT
999 There is a library for supporting user-mode programs that wish
1000 to interact with the netgraph system. See
1004 Two user-mode support programs,
1008 are available to assist manual configuration and debugging.
1010 There are a few useful techniques for debugging new node types.
1011 First, implementing new node types in user-mode first
1012 makes debugging easier.
1015 node type is also useful for debugging, especially in conjunction with
1027 .Xr ng_frame_relay 4 ,
1046 system was designed and first implemented at Whistle Communications, Inc.\&
1049 customized for the Whistle InterJet.
1050 It first made its debut in the main tree in
1054 .An Julian Elischer Aq julian@FreeBSD.org ,
1055 with contributions by
1056 .An Archie Cobbs Aq archie@FreeBSD.org .