| 1 | /* |
| 2 | * ng_frame_relay.c |
| 3 | */ |
| 4 | |
| 5 | /*- |
| 6 | * Copyright (c) 1996-1999 Whistle Communications, Inc. |
| 7 | * All rights reserved. |
| 8 | * |
| 9 | * Subject to the following obligations and disclaimer of warranty, use and |
| 10 | * redistribution of this software, in source or object code forms, with or |
| 11 | * without modifications are expressly permitted by Whistle Communications; |
| 12 | * provided, however, that: |
| 13 | * 1. Any and all reproductions of the source or object code must include the |
| 14 | * copyright notice above and the following disclaimer of warranties; and |
| 15 | * 2. No rights are granted, in any manner or form, to use Whistle |
| 16 | * Communications, Inc. trademarks, including the mark "WHISTLE |
| 17 | * COMMUNICATIONS" on advertising, endorsements, or otherwise except as |
| 18 | * such appears in the above copyright notice or in the software. |
| 19 | * |
| 20 | * THIS SOFTWARE IS BEING PROVIDED BY WHISTLE COMMUNICATIONS "AS IS", AND |
| 21 | * TO THE MAXIMUM EXTENT PERMITTED BY LAW, WHISTLE COMMUNICATIONS MAKES NO |
| 22 | * REPRESENTATIONS OR WARRANTIES, EXPRESS OR IMPLIED, REGARDING THIS SOFTWARE, |
| 23 | * INCLUDING WITHOUT LIMITATION, ANY AND ALL IMPLIED WARRANTIES OF |
| 24 | * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, OR NON-INFRINGEMENT. |
| 25 | * WHISTLE COMMUNICATIONS DOES NOT WARRANT, GUARANTEE, OR MAKE ANY |
| 26 | * REPRESENTATIONS REGARDING THE USE OF, OR THE RESULTS OF THE USE OF THIS |
| 27 | * SOFTWARE IN TERMS OF ITS CORRECTNESS, ACCURACY, RELIABILITY OR OTHERWISE. |
| 28 | * IN NO EVENT SHALL WHISTLE COMMUNICATIONS BE LIABLE FOR ANY DAMAGES |
| 29 | * RESULTING FROM OR ARISING OUT OF ANY USE OF THIS SOFTWARE, INCLUDING |
| 30 | * WITHOUT LIMITATION, ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, |
| 31 | * PUNITIVE, OR CONSEQUENTIAL DAMAGES, PROCUREMENT OF SUBSTITUTE GOODS OR |
| 32 | * SERVICES, LOSS OF USE, DATA OR PROFITS, HOWEVER CAUSED AND UNDER ANY |
| 33 | * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| 34 | * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| 35 | * THIS SOFTWARE, EVEN IF WHISTLE COMMUNICATIONS IS ADVISED OF THE POSSIBILITY |
| 36 | * OF SUCH DAMAGE. |
| 37 | * |
| 38 | * Author: Julian Elischer <julian@freebsd.org> |
| 39 | * |
| 40 | * $FreeBSD: src/sys/netgraph/ng_frame_relay.c,v 1.25 2006/01/14 21:49:31 glebius Exp $ |
| 41 | * $Whistle: ng_frame_relay.c,v 1.20 1999/11/01 09:24:51 julian Exp $ |
| 42 | */ |
| 43 | |
| 44 | /* |
| 45 | * This node implements the frame relay protocol, not including |
| 46 | * the LMI line management. This means basically keeping track |
| 47 | * of which DLCI's are active, doing frame (de)multiplexing, etc. |
| 48 | * |
| 49 | * It has a 'downstream' hook that goes to the line, and a |
| 50 | * hook for each DLCI (eg, 'dlci16'). |
| 51 | */ |
| 52 | |
| 53 | #include <sys/param.h> |
| 54 | #include <sys/systm.h> |
| 55 | #include <sys/kernel.h> |
| 56 | #include <sys/errno.h> |
| 57 | #include <sys/malloc.h> |
| 58 | #include <sys/mbuf.h> |
| 59 | #include <sys/syslog.h> |
| 60 | #include <sys/ctype.h> |
| 61 | |
| 62 | #include <netgraph/ng_message.h> |
| 63 | #include <netgraph/netgraph.h> |
| 64 | #include <netgraph/ng_frame_relay.h> |
| 65 | |
| 66 | /* |
| 67 | * Line info, and status per channel. |
| 68 | */ |
| 69 | struct ctxinfo { /* one per active hook */ |
| 70 | u_int flags; |
| 71 | #define CHAN_VALID 0x01 /* assigned to a channel */ |
| 72 | #define CHAN_ACTIVE 0x02 /* bottom level active */ |
| 73 | int dlci; /* the dlci assigned to this context */ |
| 74 | hook_p hook; /* if there's a hook assigned.. */ |
| 75 | }; |
| 76 | |
| 77 | #define MAX_CT 16 /* # of dlci's active at a time (POWER OF 2!) */ |
| 78 | struct frmrel_softc { |
| 79 | int unit; /* which card are we? */ |
| 80 | int datahooks; /* number of data hooks attached */ |
| 81 | node_p node; /* netgraph node */ |
| 82 | int addrlen; /* address header length */ |
| 83 | int flags; /* state */ |
| 84 | int mtu; /* guess */ |
| 85 | u_char remote_seq; /* sequence number the remote sent */ |
| 86 | u_char local_seq; /* sequence number the remote rcvd */ |
| 87 | u_short ALT[1024]; /* map DLCIs to CTX */ |
| 88 | #define CTX_VALID 0x8000 /* this bit means it's a valid CTX */ |
| 89 | #define CTX_VALUE (MAX_CT - 1) /* mask for context part */ |
| 90 | struct ctxinfo channel[MAX_CT]; |
| 91 | struct ctxinfo downstream; |
| 92 | }; |
| 93 | typedef struct frmrel_softc *sc_p; |
| 94 | |
| 95 | #define BYTEX_EA 0x01 /* End Address. Always 0 on byte1 */ |
| 96 | #define BYTE1_C_R 0x02 |
| 97 | #define BYTE2_FECN 0x08 /* forwards congestion notification */ |
| 98 | #define BYTE2_BECN 0x04 /* Backward congestion notification */ |
| 99 | #define BYTE2_DE 0x02 /* Discard elligability */ |
| 100 | #define LASTBYTE_D_C 0x02 /* last byte is dl_core or dlci info */ |
| 101 | |
| 102 | /* Used to do headers */ |
| 103 | const static struct segment { |
| 104 | u_char mask; |
| 105 | u_char shift; |
| 106 | u_char width; |
| 107 | } makeup[] = { |
| 108 | { 0xfc, 2, 6 }, |
| 109 | { 0xf0, 4, 4 }, |
| 110 | { 0xfe, 1, 7 }, |
| 111 | { 0xfc, 2, 6 } |
| 112 | }; |
| 113 | |
| 114 | #define SHIFTIN(segment, byte, dlci) \ |
| 115 | { \ |
| 116 | (dlci) <<= (segment)->width; \ |
| 117 | (dlci) |= \ |
| 118 | (((byte) & (segment)->mask) >> (segment)->shift); \ |
| 119 | } |
| 120 | |
| 121 | #define SHIFTOUT(segment, byte, dlci) \ |
| 122 | { \ |
| 123 | (byte) |= (((dlci) << (segment)->shift) & (segment)->mask); \ |
| 124 | (dlci) >>= (segment)->width; \ |
| 125 | } |
| 126 | |
| 127 | /* Netgraph methods */ |
| 128 | static ng_constructor_t ngfrm_constructor; |
| 129 | static ng_shutdown_t ngfrm_shutdown; |
| 130 | static ng_newhook_t ngfrm_newhook; |
| 131 | static ng_rcvdata_t ngfrm_rcvdata; |
| 132 | static ng_disconnect_t ngfrm_disconnect; |
| 133 | |
| 134 | /* Other internal functions */ |
| 135 | static int ngfrm_decode(node_p node, item_p item); |
| 136 | static int ngfrm_addrlen(char *hdr); |
| 137 | static int ngfrm_allocate_CTX(sc_p sc, int dlci); |
| 138 | |
| 139 | /* Netgraph type */ |
| 140 | static struct ng_type typestruct = { |
| 141 | .version = NG_ABI_VERSION, |
| 142 | .name = NG_FRAMERELAY_NODE_TYPE, |
| 143 | .constructor = ngfrm_constructor, |
| 144 | .shutdown = ngfrm_shutdown, |
| 145 | .newhook = ngfrm_newhook, |
| 146 | .rcvdata = ngfrm_rcvdata, |
| 147 | .disconnect = ngfrm_disconnect, |
| 148 | }; |
| 149 | NETGRAPH_INIT(framerelay, &typestruct); |
| 150 | |
| 151 | /* |
| 152 | * Given a DLCI, return the index of the context table entry for it, |
| 153 | * Allocating a new one if needs be, or -1 if none available. |
| 154 | */ |
| 155 | static int |
| 156 | ngfrm_allocate_CTX(sc_p sc, int dlci) |
| 157 | { |
| 158 | u_int ctxnum = -1; /* what ctx number we are using */ |
| 159 | volatile struct ctxinfo *CTXp = NULL; |
| 160 | |
| 161 | /* Sanity check the dlci value */ |
| 162 | if (dlci > 1023) |
| 163 | return (-1); |
| 164 | |
| 165 | /* Check to see if we already have an entry for this DLCI */ |
| 166 | if (sc->ALT[dlci]) { |
| 167 | if ((ctxnum = sc->ALT[dlci] & CTX_VALUE) < MAX_CT) { |
| 168 | CTXp = sc->channel + ctxnum; |
| 169 | } else { |
| 170 | ctxnum = -1; |
| 171 | sc->ALT[dlci] = 0; /* paranoid but... */ |
| 172 | } |
| 173 | } |
| 174 | |
| 175 | /* |
| 176 | * If the index has no valid entry yet, then we need to allocate a |
| 177 | * CTX number to it |
| 178 | */ |
| 179 | if (CTXp == NULL) { |
| 180 | for (ctxnum = 0; ctxnum < MAX_CT; ctxnum++) { |
| 181 | /* |
| 182 | * If the VALID flag is empty it is unused |
| 183 | */ |
| 184 | if ((sc->channel[ctxnum].flags & CHAN_VALID) == 0) { |
| 185 | bzero(sc->channel + ctxnum, |
| 186 | sizeof(struct ctxinfo)); |
| 187 | CTXp = sc->channel + ctxnum; |
| 188 | sc->ALT[dlci] = ctxnum | CTX_VALID; |
| 189 | sc->channel[ctxnum].dlci = dlci; |
| 190 | sc->channel[ctxnum].flags = CHAN_VALID; |
| 191 | break; |
| 192 | } |
| 193 | } |
| 194 | } |
| 195 | |
| 196 | /* |
| 197 | * If we still don't have a CTX pointer, then we never found a free |
| 198 | * spot so give up now.. |
| 199 | */ |
| 200 | if (!CTXp) { |
| 201 | log(LOG_ERR, "No CTX available for dlci %d\n", dlci); |
| 202 | return (-1); |
| 203 | } |
| 204 | return (ctxnum); |
| 205 | } |
| 206 | |
| 207 | /* |
| 208 | * Node constructor |
| 209 | */ |
| 210 | static int |
| 211 | ngfrm_constructor(node_p node) |
| 212 | { |
| 213 | sc_p sc; |
| 214 | |
| 215 | MALLOC(sc, sc_p, sizeof(*sc), M_NETGRAPH, M_NOWAIT | M_ZERO); |
| 216 | if (!sc) |
| 217 | return (ENOMEM); |
| 218 | sc->addrlen = 2; /* default */ |
| 219 | |
| 220 | /* Link the node and our private info */ |
| 221 | NG_NODE_SET_PRIVATE(node, sc); |
| 222 | sc->node = node; |
| 223 | return (0); |
| 224 | } |
| 225 | |
| 226 | /* |
| 227 | * Add a new hook |
| 228 | * |
| 229 | * We allow hooks called "debug", "downstream" and dlci[0-1023] |
| 230 | * The hook's private info points to our stash of info about that |
| 231 | * channel. A NULL pointer is debug and a DLCI of -1 means downstream. |
| 232 | */ |
| 233 | static int |
| 234 | ngfrm_newhook(node_p node, hook_p hook, const char *name) |
| 235 | { |
| 236 | const sc_p sc = NG_NODE_PRIVATE(node); |
| 237 | const char *cp; |
| 238 | char *eptr; |
| 239 | int dlci = 0; |
| 240 | int ctxnum; |
| 241 | |
| 242 | /* Check if it's our friend the control hook */ |
| 243 | if (strcmp(name, NG_FRAMERELAY_HOOK_DEBUG) == 0) { |
| 244 | NG_HOOK_SET_PRIVATE(hook, NULL); /* paranoid */ |
| 245 | return (0); |
| 246 | } |
| 247 | |
| 248 | /* |
| 249 | * All other hooks either start with 'dlci' and have a decimal |
| 250 | * trailing channel number up to 4 digits, or are the downstream |
| 251 | * hook. |
| 252 | */ |
| 253 | if (strncmp(name, NG_FRAMERELAY_HOOK_DLCI, |
| 254 | strlen(NG_FRAMERELAY_HOOK_DLCI)) != 0) { |
| 255 | |
| 256 | /* It must be the downstream connection */ |
| 257 | if (strcmp(name, NG_FRAMERELAY_HOOK_DOWNSTREAM) != 0) |
| 258 | return EINVAL; |
| 259 | |
| 260 | /* Make sure we haven't already got one (paranoid) */ |
| 261 | if (sc->downstream.hook) |
| 262 | return (EADDRINUSE); |
| 263 | |
| 264 | /* OK add it */ |
| 265 | NG_HOOK_SET_PRIVATE(hook, &sc->downstream); |
| 266 | sc->downstream.hook = hook; |
| 267 | sc->downstream.dlci = -1; |
| 268 | sc->downstream.flags |= CHAN_ACTIVE; |
| 269 | sc->datahooks++; |
| 270 | return (0); |
| 271 | } |
| 272 | |
| 273 | /* Must be a dlci hook at this point */ |
| 274 | cp = name + strlen(NG_FRAMERELAY_HOOK_DLCI); |
| 275 | if (!isdigit(*cp) || (cp[0] == '0' && cp[1] != '\0')) |
| 276 | return (EINVAL); |
| 277 | dlci = (int)strtoul(cp, &eptr, 10); |
| 278 | if (*eptr != '\0' || dlci < 0 || dlci > 1023) |
| 279 | return (EINVAL); |
| 280 | |
| 281 | /* |
| 282 | * We have a dlci, now either find it, or allocate it. It's possible |
| 283 | * that we might have seen packets for it already and made an entry |
| 284 | * for it. |
| 285 | */ |
| 286 | ctxnum = ngfrm_allocate_CTX(sc, dlci); |
| 287 | if (ctxnum == -1) |
| 288 | return (ENOBUFS); |
| 289 | |
| 290 | /* |
| 291 | * Be paranoid: if it's got a hook already, that dlci is in use . |
| 292 | * Generic code can not catch all the synonyms (e.g. dlci016 vs |
| 293 | * dlci16) |
| 294 | */ |
| 295 | if (sc->channel[ctxnum].hook != NULL) |
| 296 | return (EADDRINUSE); |
| 297 | |
| 298 | /* |
| 299 | * Put our hooks into it (pun not intended) |
| 300 | */ |
| 301 | sc->channel[ctxnum].flags |= CHAN_ACTIVE; |
| 302 | NG_HOOK_SET_PRIVATE(hook, sc->channel + ctxnum); |
| 303 | sc->channel[ctxnum].hook = hook; |
| 304 | sc->datahooks++; |
| 305 | return (0); |
| 306 | } |
| 307 | |
| 308 | /* |
| 309 | * Count up the size of the address header if we don't already know |
| 310 | */ |
| 311 | int |
| 312 | ngfrm_addrlen(char *hdr) |
| 313 | { |
| 314 | if (hdr[0] & BYTEX_EA) |
| 315 | return 0; |
| 316 | if (hdr[1] & BYTEX_EA) |
| 317 | return 2; |
| 318 | if (hdr[2] & BYTEX_EA) |
| 319 | return 3; |
| 320 | if (hdr[3] & BYTEX_EA) |
| 321 | return 4; |
| 322 | return 0; |
| 323 | } |
| 324 | |
| 325 | /* |
| 326 | * Receive data packet |
| 327 | */ |
| 328 | static int |
| 329 | ngfrm_rcvdata(hook_p hook, item_p item) |
| 330 | { |
| 331 | struct ctxinfo *const ctxp = NG_HOOK_PRIVATE(hook); |
| 332 | struct mbuf *m = NULL; |
| 333 | int error = 0; |
| 334 | int dlci; |
| 335 | sc_p sc; |
| 336 | int alen; |
| 337 | char *data; |
| 338 | |
| 339 | /* Data doesn't come in from just anywhere (e.g debug hook) */ |
| 340 | if (ctxp == NULL) { |
| 341 | error = ENETDOWN; |
| 342 | goto bad; |
| 343 | } |
| 344 | |
| 345 | /* If coming from downstream, decode it to a channel */ |
| 346 | dlci = ctxp->dlci; |
| 347 | if (dlci == -1) |
| 348 | return (ngfrm_decode(NG_HOOK_NODE(hook), item)); |
| 349 | |
| 350 | NGI_GET_M(item, m); |
| 351 | /* Derive the softc we will need */ |
| 352 | sc = NG_NODE_PRIVATE(NG_HOOK_NODE(hook)); |
| 353 | |
| 354 | /* If there is no live channel, throw it away */ |
| 355 | if ((sc->downstream.hook == NULL) |
| 356 | || ((ctxp->flags & CHAN_ACTIVE) == 0)) { |
| 357 | error = ENETDOWN; |
| 358 | goto bad; |
| 359 | } |
| 360 | |
| 361 | /* Store the DLCI on the front of the packet */ |
| 362 | alen = sc->addrlen; |
| 363 | if (alen == 0) |
| 364 | alen = 2; /* default value for transmit */ |
| 365 | M_PREPEND(m, alen, M_DONTWAIT); |
| 366 | if (m == NULL) { |
| 367 | error = ENOBUFS; |
| 368 | goto bad; |
| 369 | } |
| 370 | data = mtod(m, char *); |
| 371 | |
| 372 | /* |
| 373 | * Shift the lowest bits into the address field untill we are done. |
| 374 | * First byte is MSBits of addr so work backwards. |
| 375 | */ |
| 376 | switch (alen) { |
| 377 | case 2: |
| 378 | data[0] = data[1] = '\0'; |
| 379 | SHIFTOUT(makeup + 1, data[1], dlci); |
| 380 | SHIFTOUT(makeup + 0, data[0], dlci); |
| 381 | data[1] |= BYTEX_EA; |
| 382 | break; |
| 383 | case 3: |
| 384 | data[0] = data[1] = data[2] = '\0'; |
| 385 | SHIFTOUT(makeup + 3, data[2], dlci); /* 3 and 2 is correct */ |
| 386 | SHIFTOUT(makeup + 1, data[1], dlci); |
| 387 | SHIFTOUT(makeup + 0, data[0], dlci); |
| 388 | data[2] |= BYTEX_EA; |
| 389 | break; |
| 390 | case 4: |
| 391 | data[0] = data[1] = data[2] = data[3] = '\0'; |
| 392 | SHIFTOUT(makeup + 3, data[3], dlci); |
| 393 | SHIFTOUT(makeup + 2, data[2], dlci); |
| 394 | SHIFTOUT(makeup + 1, data[1], dlci); |
| 395 | SHIFTOUT(makeup + 0, data[0], dlci); |
| 396 | data[3] |= BYTEX_EA; |
| 397 | break; |
| 398 | default: |
| 399 | panic(__func__); |
| 400 | } |
| 401 | |
| 402 | /* Send it */ |
| 403 | NG_FWD_NEW_DATA(error, item, sc->downstream.hook, m); |
| 404 | return (error); |
| 405 | |
| 406 | bad: |
| 407 | NG_FREE_ITEM(item); |
| 408 | NG_FREE_M(m); |
| 409 | return (error); |
| 410 | } |
| 411 | |
| 412 | /* |
| 413 | * Decode an incoming frame coming from the switch |
| 414 | */ |
| 415 | static int |
| 416 | ngfrm_decode(node_p node, item_p item) |
| 417 | { |
| 418 | const sc_p sc = NG_NODE_PRIVATE(node); |
| 419 | char *data; |
| 420 | int alen; |
| 421 | u_int dlci = 0; |
| 422 | int error = 0; |
| 423 | int ctxnum; |
| 424 | struct mbuf *m; |
| 425 | |
| 426 | NGI_GET_M(item, m); |
| 427 | if (m->m_len < 4 && (m = m_pullup(m, 4)) == NULL) { |
| 428 | error = ENOBUFS; |
| 429 | goto out; |
| 430 | } |
| 431 | data = mtod(m, char *); |
| 432 | if ((alen = sc->addrlen) == 0) { |
| 433 | sc->addrlen = alen = ngfrm_addrlen(data); |
| 434 | } |
| 435 | switch (alen) { |
| 436 | case 2: |
| 437 | SHIFTIN(makeup + 0, data[0], dlci); |
| 438 | SHIFTIN(makeup + 1, data[1], dlci); |
| 439 | break; |
| 440 | case 3: |
| 441 | SHIFTIN(makeup + 0, data[0], dlci); |
| 442 | SHIFTIN(makeup + 1, data[1], dlci); |
| 443 | SHIFTIN(makeup + 3, data[2], dlci); /* 3 and 2 is correct */ |
| 444 | break; |
| 445 | case 4: |
| 446 | SHIFTIN(makeup + 0, data[0], dlci); |
| 447 | SHIFTIN(makeup + 1, data[1], dlci); |
| 448 | SHIFTIN(makeup + 2, data[2], dlci); |
| 449 | SHIFTIN(makeup + 3, data[3], dlci); |
| 450 | break; |
| 451 | default: |
| 452 | error = EINVAL; |
| 453 | goto out; |
| 454 | } |
| 455 | |
| 456 | if (dlci > 1023) { |
| 457 | error = EINVAL; |
| 458 | goto out; |
| 459 | } |
| 460 | ctxnum = sc->ALT[dlci]; |
| 461 | if ((ctxnum & CTX_VALID) && sc->channel[ctxnum &= CTX_VALUE].hook) { |
| 462 | /* Send it */ |
| 463 | m_adj(m, alen); |
| 464 | NG_FWD_NEW_DATA(error, item, sc->channel[ctxnum].hook, m); |
| 465 | return (error); |
| 466 | } else { |
| 467 | error = ENETDOWN; |
| 468 | } |
| 469 | out: |
| 470 | NG_FREE_ITEM(item); |
| 471 | NG_FREE_M(m); |
| 472 | return (error); |
| 473 | } |
| 474 | |
| 475 | /* |
| 476 | * Shutdown node |
| 477 | */ |
| 478 | static int |
| 479 | ngfrm_shutdown(node_p node) |
| 480 | { |
| 481 | const sc_p sc = NG_NODE_PRIVATE(node); |
| 482 | |
| 483 | NG_NODE_SET_PRIVATE(node, NULL); |
| 484 | FREE(sc, M_NETGRAPH); |
| 485 | NG_NODE_UNREF(node); |
| 486 | return (0); |
| 487 | } |
| 488 | |
| 489 | /* |
| 490 | * Hook disconnection |
| 491 | * |
| 492 | * Invalidate the private data associated with this dlci. |
| 493 | * For this type, removal of the last link resets tries to destroy the node. |
| 494 | */ |
| 495 | static int |
| 496 | ngfrm_disconnect(hook_p hook) |
| 497 | { |
| 498 | const sc_p sc = NG_NODE_PRIVATE(NG_HOOK_NODE(hook)); |
| 499 | struct ctxinfo *const cp = NG_HOOK_PRIVATE(hook); |
| 500 | int dlci; |
| 501 | |
| 502 | /* If it's a regular dlci hook, then free resources etc.. */ |
| 503 | if (cp != NULL) { |
| 504 | cp->hook = NULL; |
| 505 | dlci = cp->dlci; |
| 506 | if (dlci != -1) |
| 507 | sc->ALT[dlci] = 0; |
| 508 | cp->flags = 0; |
| 509 | sc->datahooks--; |
| 510 | } |
| 511 | if ((NG_NODE_NUMHOOKS(NG_HOOK_NODE(hook)) == 0) |
| 512 | && (NG_NODE_IS_VALID(NG_HOOK_NODE(hook)))) |
| 513 | ng_rmnode_self(NG_HOOK_NODE(hook)); |
| 514 | return (0); |
| 515 | } |