Annotation of embedaddon/libpdel/ppp/ppp_node.c, revision 1.1
1.1 ! misho 1:
! 2: /*
! 3: * Copyright (c) 2001-2002 Packet Design, LLC.
! 4: * All rights reserved.
! 5: *
! 6: * Subject to the following obligations and disclaimer of warranty,
! 7: * use and redistribution of this software, in source or object code
! 8: * forms, with or without modifications are expressly permitted by
! 9: * Packet Design; provided, however, that:
! 10: *
! 11: * (i) Any and all reproductions of the source or object code
! 12: * must include the copyright notice above and the following
! 13: * disclaimer of warranties; and
! 14: * (ii) No rights are granted, in any manner or form, to use
! 15: * Packet Design trademarks, including the mark "PACKET DESIGN"
! 16: * on advertising, endorsements, or otherwise except as such
! 17: * appears in the above copyright notice or in the software.
! 18: *
! 19: * THIS SOFTWARE IS BEING PROVIDED BY PACKET DESIGN "AS IS", AND
! 20: * TO THE MAXIMUM EXTENT PERMITTED BY LAW, PACKET DESIGN MAKES NO
! 21: * REPRESENTATIONS OR WARRANTIES, EXPRESS OR IMPLIED, REGARDING
! 22: * THIS SOFTWARE, INCLUDING WITHOUT LIMITATION, ANY AND ALL IMPLIED
! 23: * WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE,
! 24: * OR NON-INFRINGEMENT. PACKET DESIGN DOES NOT WARRANT, GUARANTEE,
! 25: * OR MAKE ANY REPRESENTATIONS REGARDING THE USE OF, OR THE RESULTS
! 26: * OF THE USE OF THIS SOFTWARE IN TERMS OF ITS CORRECTNESS, ACCURACY,
! 27: * RELIABILITY OR OTHERWISE. IN NO EVENT SHALL PACKET DESIGN BE
! 28: * LIABLE FOR ANY DAMAGES RESULTING FROM OR ARISING OUT OF ANY USE
! 29: * OF THIS SOFTWARE, INCLUDING WITHOUT LIMITATION, ANY DIRECT,
! 30: * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, PUNITIVE, OR CONSEQUENTIAL
! 31: * DAMAGES, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, LOSS OF
! 32: * USE, DATA OR PROFITS, HOWEVER CAUSED AND UNDER ANY THEORY OF
! 33: * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
! 34: * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
! 35: * THE USE OF THIS SOFTWARE, EVEN IF PACKET DESIGN IS ADVISED OF
! 36: * THE POSSIBILITY OF SUCH DAMAGE.
! 37: *
! 38: * Author: Archie Cobbs <archie@freebsd.org>
! 39: */
! 40:
! 41: #include "ppp/ppp_defs.h"
! 42: #include "ppp/ppp_log.h"
! 43: #include "ppp/ppp_node.h"
! 44:
! 45: #include <sys/queue.h>
! 46: #include <netgraph/ng_socket.h>
! 47:
! 48: /*
! 49: * This manages an ng_ppp(4) netgraph node.
! 50: */
! 51:
! 52: #define NODE_MTYPE "ppp_node"
! 53: #define PKTBUFLEN 2000
! 54: #define NODE_HOOK "ppp"
! 55:
! 56: /* One recipient for incoming control messages */
! 57: struct ppp_node_recvmsg {
! 58: u_int32_t cookie;
! 59: u_int32_t cmd;
! 60: ppp_node_recvmsg_t *recvmsg;
! 61: void *arg;
! 62: TAILQ_ENTRY(ppp_node_recvmsg) next;
! 63: };
! 64:
! 65: /* PPP node structure */
! 66: struct ppp_node {
! 67: int csock; /* ng_socket ctrl socket */
! 68: int dsock; /* ng_socket data socket */
! 69: struct pevent_ctx *ev_ctx; /* event context */
! 70: pthread_mutex_t *mutex; /* mutex */
! 71: struct pevent *cevent; /* incoming ctrl msg event */
! 72: struct pevent *devent; /* incoming packet event */
! 73: struct ppp_log *log; /* log */
! 74: ppp_node_recv_t *recv; /* handler for packets */
! 75: void *rarg; /* recv() function arg */
! 76: struct ng_ppp_node_conf conf; /* ng_ppp(4) node config */
! 77: char path[32]; /* netgraph path to node */
! 78: u_char got_conf; /* "conf" is valid */
! 79: u_char connected[NG_PPP_MAX_LINKS];
! 80: TAILQ_HEAD(,ppp_node_recvmsg) rmlist; /* ng_mesg recipient list */
! 81: };
! 82:
! 83: /* Internal functions */
! 84: static pevent_handler_t ppp_node_read_packet;
! 85: static pevent_handler_t ppp_node_read_message;
! 86:
! 87: /* Macro for logging */
! 88: #define LOG(sev, fmt, args...) PPP_LOG(node->log, sev, fmt , ## args)
! 89:
! 90: /***********************************************************************
! 91: PUBLIC FUNCTIONS
! 92: ***********************************************************************/
! 93:
! 94: /*
! 95: * Create a new PPP node from a newly created link.
! 96: *
! 97: * The "log" is consumed.
! 98: */
! 99: struct ppp_node *
! 100: ppp_node_create(struct pevent_ctx *ev_ctx,
! 101: pthread_mutex_t *mutex, struct ppp_log *log)
! 102: {
! 103: union {
! 104: u_char buf[sizeof(struct ng_mesg) + sizeof(struct nodeinfo)];
! 105: struct ng_mesg reply;
! 106: } repbuf;
! 107: struct ng_mesg *reply = &repbuf.reply;
! 108: struct nodeinfo ninfo;
! 109: struct ngm_mkpeer mkpeer;
! 110: struct ppp_node *node;
! 111:
! 112: /* Create new node structure */
! 113: if ((node = MALLOC(NODE_MTYPE, sizeof(*node))) == NULL)
! 114: return (NULL);
! 115: memset(node, 0, sizeof(*node));
! 116: node->ev_ctx = ev_ctx;
! 117: node->mutex = mutex;
! 118: node->log = log;
! 119: node->csock = -1;
! 120: node->dsock = -1;
! 121: TAILQ_INIT(&node->rmlist);
! 122:
! 123: /* Create netgraph socket node */
! 124: if (NgMkSockNode(NULL, &node->csock, &node->dsock) == -1) {
! 125: LOG(LOG_ERR, "%s: %m", "creating socket node");
! 126: goto fail;
! 127: }
! 128: (void)fcntl(node->csock, F_SETFD, 1);
! 129: (void)fcntl(node->dsock, F_SETFD, 1);
! 130:
! 131: /* Attach a new ng_ppp(4) node to the socket node via "bypass" hook */
! 132: memset(&mkpeer, 0, sizeof(mkpeer));
! 133: strlcpy(mkpeer.type, NG_PPP_NODE_TYPE, sizeof(mkpeer.type));
! 134: strlcpy(mkpeer.ourhook, NODE_HOOK, sizeof(mkpeer.ourhook));
! 135: strlcpy(mkpeer.peerhook, NG_PPP_HOOK_BYPASS, sizeof(mkpeer.peerhook));
! 136: if (NgSendMsg(node->csock, ".",
! 137: NGM_GENERIC_COOKIE, NGM_MKPEER, &mkpeer, sizeof(mkpeer)) == -1) {
! 138: LOG(LOG_ERR, "%s: %m", "attaching ppp node");
! 139: goto fail;
! 140: }
! 141:
! 142: /* Get node info including 'id' and create absolute path for node */
! 143: if (NgSendMsg(node->csock, NODE_HOOK,
! 144: NGM_GENERIC_COOKIE, NGM_NODEINFO, NULL, 0) == -1) {
! 145: LOG(LOG_ERR, "can't get node info: %m");
! 146: goto fail;
! 147: }
! 148: memset(&repbuf, 0, sizeof(repbuf));
! 149: if (NgRecvMsg(node->csock, reply, sizeof(repbuf), NULL) == -1) {
! 150: LOG(LOG_ERR, "can't read node info: %m");
! 151: goto fail;
! 152: }
! 153: memcpy(&ninfo, reply->data, sizeof(ninfo));
! 154: snprintf(node->path, sizeof(node->path), "[%lx]:", (long)ninfo.id);
! 155:
! 156: /* Register event for reading incoming packets from bypass hook */
! 157: if (pevent_register(node->ev_ctx, &node->devent, PEVENT_RECURRING,
! 158: node->mutex, ppp_node_read_packet, node, PEVENT_READ,
! 159: node->dsock) == -1) {
! 160: LOG(LOG_ERR, "%s: %m", "adding read event");
! 161: goto fail;
! 162: }
! 163:
! 164: /* Register event for reading incoming control messages */
! 165: if (pevent_register(node->ev_ctx, &node->cevent, PEVENT_RECURRING,
! 166: node->mutex, ppp_node_read_message, node, PEVENT_READ,
! 167: node->csock) == -1) {
! 168: LOG(LOG_ERR, "%s: %m", "adding read event");
! 169: goto fail;
! 170: }
! 171:
! 172: /* Done */
! 173: return (node);
! 174:
! 175: fail:
! 176: /* Clean up */
! 177: if (node->csock != -1) {
! 178: (void)NgSendMsg(node->csock, NODE_HOOK,
! 179: NGM_GENERIC_COOKIE, NGM_SHUTDOWN, NULL, 0);
! 180: (void)close(node->csock);
! 181: (void)close(node->dsock);
! 182: }
! 183: FREE(NODE_MTYPE, node);
! 184: return (NULL);
! 185: }
! 186:
! 187: /*
! 188: * Destroy a node.
! 189: */
! 190: void
! 191: ppp_node_destroy(struct ppp_node **nodep)
! 192: {
! 193: struct ppp_node *const node = *nodep;
! 194: const int esave = errno;
! 195:
! 196: if (node == NULL)
! 197: return;
! 198: *nodep = NULL;
! 199: while (!TAILQ_EMPTY(&node->rmlist)) {
! 200: struct ppp_node_recvmsg *const rm = TAILQ_FIRST(&node->rmlist);
! 201:
! 202: ppp_node_set_recvmsg(node, rm->cookie, rm->cmd, NULL, NULL);
! 203: }
! 204: (void)NgSendMsg(node->csock, NODE_HOOK,
! 205: NGM_GENERIC_COOKIE, NGM_SHUTDOWN, NULL, 0);
! 206: (void)close(node->csock);
! 207: (void)close(node->dsock);
! 208: pevent_unregister(&node->devent);
! 209: pevent_unregister(&node->cevent);
! 210: ppp_log_close(&node->log);
! 211: FREE(NODE_MTYPE, node);
! 212: errno = esave;
! 213: }
! 214:
! 215: /*
! 216: * Write to bypass hook.
! 217: */
! 218: int
! 219: ppp_node_write(struct ppp_node *node, u_int link_num,
! 220: u_int16_t proto, const void *data, size_t len)
! 221: {
! 222: struct sockaddr_ng sag;
! 223: u_int16_t hdr[2];
! 224: u_char *buf;
! 225:
! 226: /* Build ng_ppp(4) bypass header */
! 227: hdr[0] = htons(link_num);
! 228: hdr[1] = htons(proto);
! 229:
! 230: /* Set destination hook */
! 231: memset(&sag, 0, sizeof(sag));
! 232: sag.sg_len = 2 + sizeof(NODE_HOOK);
! 233: sag.sg_family = AF_NETGRAPH;
! 234: strlcpy(sag.sg_data, NODE_HOOK, sizeof(sag.sg_data));
! 235:
! 236: /* Write packet */
! 237: if ((buf = MALLOC(TYPED_MEM_TEMP, len + 4)) == NULL)
! 238: return (-1);
! 239: memcpy(buf, hdr, 4);
! 240: memcpy(buf + 4, data, len);
! 241: if (sendto(node->dsock, buf, len + 4, 0,
! 242: (struct sockaddr *)&sag, sag.sg_len) == -1
! 243: && errno != ENOBUFS) {
! 244: FREE(TYPED_MEM_TEMP, buf);
! 245: return (-1);
! 246: }
! 247: FREE(TYPED_MEM_TEMP, buf);
! 248:
! 249: /* Done */
! 250: return (len);
! 251: }
! 252:
! 253: /*
! 254: * Connect a link.
! 255: */
! 256: int
! 257: ppp_node_connect(struct ppp_node *node, u_int link_num,
! 258: const char *path, const char *hook)
! 259: {
! 260: struct ngm_connect connect;
! 261:
! 262: /* Sanity checks */
! 263: if (link_num >= NG_PPP_MAX_LINKS) {
! 264: errno = EINVAL;
! 265: return (-1);
! 266: }
! 267: if (node->connected[link_num])
! 268: ppp_node_disconnect(node, link_num);
! 269:
! 270: /* Connect ng_ppp(4) device hook */
! 271: memset(&connect, 0, sizeof(connect));
! 272: strlcpy(connect.path, path, sizeof(connect.path));
! 273: snprintf(connect.ourhook, sizeof(connect.ourhook),
! 274: "%s%u", NG_PPP_HOOK_LINK_PREFIX, link_num);
! 275: strlcpy(connect.peerhook, hook, sizeof(connect.peerhook));
! 276: if (NgSendMsg(node->csock, NODE_HOOK,
! 277: NGM_GENERIC_COOKIE, NGM_CONNECT, &connect, sizeof(connect)) == -1) {
! 278: LOG(LOG_ERR, "connecting %s%u: %m",
! 279: NG_PPP_HOOK_LINK_PREFIX, link_num);
! 280: return (-1);
! 281: }
! 282:
! 283: /* Done */
! 284: node->connected[link_num] = 1;
! 285: return (0);
! 286: }
! 287:
! 288: /*
! 289: * Disonnect a link.
! 290: */
! 291: int
! 292: ppp_node_disconnect(struct ppp_node *node, u_int link_num)
! 293: {
! 294: struct ngm_rmhook rmhook;
! 295:
! 296: /* Sanity check */
! 297: if (link_num >= NG_PPP_MAX_LINKS) {
! 298: errno = EINVAL;
! 299: return (-1);
! 300: }
! 301:
! 302: /* Remove hook */
! 303: memset(&rmhook, 0, sizeof(rmhook));
! 304: snprintf(rmhook.ourhook, sizeof(rmhook.ourhook),
! 305: "%s%u", NG_PPP_HOOK_LINK_PREFIX, link_num);
! 306: if (NgSendMsg(node->csock, NODE_HOOK, NGM_GENERIC_COOKIE,
! 307: NGM_RMHOOK, &rmhook, sizeof(rmhook)) == -1
! 308: && errno != ENOENT) {
! 309: LOG(LOG_ERR, "disconnecting %s%u: %m",
! 310: NG_PPP_HOOK_LINK_PREFIX, link_num);
! 311: return (-1);
! 312: }
! 313:
! 314: /* Done */
! 315: node->connected[link_num] = 0;
! 316: return (0);
! 317: }
! 318:
! 319: /*
! 320: * Get absolute path to node.
! 321: */
! 322: const char *
! 323: ppp_node_get_path(struct ppp_node *node)
! 324: {
! 325: return (node->path);
! 326: }
! 327:
! 328: /***********************************************************************
! 329: CONTROL MESSAGE FUNCTIONS
! 330: ***********************************************************************/
! 331:
! 332: /*
! 333: * Get node configuration.
! 334: */
! 335: int
! 336: ppp_node_get_config(struct ppp_node *node, struct ng_ppp_node_conf *conf)
! 337: {
! 338: union {
! 339: u_char buf[sizeof(struct ng_mesg) + sizeof(*conf)];
! 340: struct ng_mesg reply;
! 341: } buf;
! 342: struct ng_mesg *const reply = &buf.reply;
! 343:
! 344: if (!node->got_conf) {
! 345: memset(&buf, 0, sizeof(buf));
! 346: if (NgSendMsg(node->csock, NODE_HOOK,
! 347: NGM_PPP_COOKIE, NGM_PPP_GET_CONFIG, NULL, 0) < 0) {
! 348: LOG(LOG_ERR, "%s: %m", "getting node configuration");
! 349: return (-1);
! 350: }
! 351: if (NgRecvMsg(node->csock, reply, sizeof(buf), NULL) == -1) {
! 352: LOG(LOG_ERR, "%s: %m", "receiving node configuration");
! 353: return (-1);
! 354: }
! 355: memcpy(&node->conf, reply->data, sizeof(node->conf));
! 356: node->got_conf = 1;
! 357: }
! 358: *conf = node->conf;
! 359: return (0);
! 360: }
! 361:
! 362: /*
! 363: * Set node configuration.
! 364: */
! 365: int
! 366: ppp_node_set_config(struct ppp_node *node, const struct ng_ppp_node_conf *conf)
! 367: {
! 368: if (NgSendMsg(node->csock, NODE_HOOK, NGM_PPP_COOKIE,
! 369: NGM_PPP_SET_CONFIG, conf, sizeof(*conf)) < 0) {
! 370: LOG(LOG_ERR, "%s: %m", "configuring node");
! 371: return (-1);
! 372: }
! 373: node->got_conf = 1;
! 374: node->conf = *conf;
! 375: return (0);
! 376: }
! 377:
! 378: /*
! 379: * Set incoming packet recipient.
! 380: */
! 381: void
! 382: ppp_node_set_recv(struct ppp_node *node, ppp_node_recv_t *recv, void *arg)
! 383: {
! 384: node->recv = recv;
! 385: node->rarg = arg;
! 386: }
! 387:
! 388: /*
! 389: * Set incoming message recipient.
! 390: */
! 391: int
! 392: ppp_node_set_recvmsg(struct ppp_node *node, u_int32_t cookie,
! 393: u_int32_t cmd, ppp_node_recvmsg_t *recvmsg, void *arg)
! 394: {
! 395: struct ppp_node_recvmsg *rm;
! 396: int found = 0;
! 397:
! 398: /* Check if already exists */
! 399: TAILQ_FOREACH(rm, &node->rmlist, next) {
! 400: if (rm->cookie == cookie && rm->cmd == cmd) {
! 401: found = 1;
! 402: break;
! 403: }
! 404: }
! 405:
! 406: /* Removing it? */
! 407: if (recvmsg == NULL) {
! 408: if (found) {
! 409: TAILQ_REMOVE(&node->rmlist, rm, next);
! 410: FREE(NODE_MTYPE, rm);
! 411: }
! 412: return (0);
! 413: } else if (found) {
! 414: errno = EALREADY;
! 415: return (-1);
! 416: }
! 417:
! 418: /* Add new message receiver */
! 419: if ((rm = MALLOC(NODE_MTYPE, sizeof(*rm))) == NULL)
! 420: return (-1);
! 421: memset(rm, 0, sizeof(*rm));
! 422: rm->cookie = cookie;
! 423: rm->cmd = cmd;
! 424: rm->recvmsg = recvmsg;
! 425: rm->arg = arg;
! 426: TAILQ_INSERT_TAIL(&node->rmlist, rm, next);
! 427: return (0);
! 428: }
! 429:
! 430: int
! 431: ppp_node_send_msg(struct ppp_node *node, const char *relpath,
! 432: u_int32_t cookie, u_int32_t cmd, const void *payload, size_t plen)
! 433: {
! 434: char path[NG_PATHSIZ];
! 435:
! 436: if (relpath == NULL)
! 437: strlcpy(path, NODE_HOOK, sizeof(path));
! 438: else
! 439: snprintf(path, sizeof(path), "%s.%s", NODE_HOOK, relpath);
! 440: if (NgSendMsg(node->csock, path, cookie, cmd, payload, plen) == -1)
! 441: return (-1);
! 442: return (0);
! 443: }
! 444:
! 445: int
! 446: ppp_node_recv_msg(struct ppp_node *node,
! 447: struct ng_mesg *msg, size_t mlen, char *raddr)
! 448: {
! 449: return (NgRecvMsg(node->csock, msg, mlen, raddr));
! 450: }
! 451:
! 452: /***********************************************************************
! 453: INTERNAL FUNCTIONS
! 454: ***********************************************************************/
! 455:
! 456: /*
! 457: * Handle incoming data on the ng_ppp(4) bypass hook.
! 458: */
! 459: static void
! 460: ppp_node_read_packet(void *arg)
! 461: {
! 462: struct ppp_node *const node = arg;
! 463: u_char buf[4 + PKTBUFLEN];
! 464: u_int16_t link_num;
! 465: u_int16_t proto;
! 466: int len;
! 467:
! 468: /* Read packet */
! 469: if ((len = read(node->dsock, buf, sizeof(buf))) == -1) {
! 470: LOG(LOG_ERR, "error reading bypass hook: %m");
! 471: return;
! 472: }
! 473:
! 474: /* Extract protocol and link number */
! 475: if (len < 4) {
! 476: LOG(LOG_ERR, "read len %d bypass packet", len);
! 477: return;
! 478: }
! 479: memcpy(&link_num, buf, 2);
! 480: link_num = ntohs(link_num);
! 481: memcpy(&proto, buf + 2, 2);
! 482: proto = ntohs(proto);
! 483:
! 484: /* Deliver packet */
! 485: if (node->recv != NULL)
! 486: (*node->recv)(node->rarg, link_num, proto, buf + 4, len - 4);
! 487: }
! 488:
! 489: /*
! 490: * Handle incoming control message on the netgraph socket.
! 491: */
! 492: static void
! 493: ppp_node_read_message(void *arg)
! 494: {
! 495: struct ppp_node *const node = arg;
! 496: const size_t max_msglen = 4096;
! 497: char raddr[NG_PATHSIZ];
! 498: struct ppp_node_recvmsg *rm;
! 499: struct ng_mesg *msg;
! 500: int found = 0;
! 501: int len;
! 502:
! 503: /* Allocate buffer */
! 504: if ((msg = MALLOC(TYPED_MEM_TEMP, max_msglen)) == NULL) {
! 505: LOG(LOG_ERR, "malloc: %m");
! 506: return;
! 507: }
! 508:
! 509: /* Read incoming message */
! 510: if ((len = NgRecvMsg(node->csock, msg, max_msglen, raddr)) == -1) {
! 511: LOG(LOG_ERR, "reading ctrl message: %m");
! 512: goto done;
! 513: }
! 514:
! 515: /* Search for handler */
! 516: TAILQ_FOREACH(rm, &node->rmlist, next) {
! 517: if (rm->cookie == msg->header.typecookie
! 518: && rm->cmd == msg->header.cmd) {
! 519: found = 1;
! 520: break;
! 521: }
! 522: }
! 523: if (!found)
! 524: goto done;
! 525:
! 526: /* Invoke handler */
! 527: (*rm->recvmsg)(rm->arg, msg);
! 528:
! 529: done:
! 530: /* Clean up */
! 531: FREE(TYPED_MEM_TEMP, msg);
! 532: }
! 533:
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to ppp_node.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / libpdel / ppp