lib/libnetgraph/msg.c

   1
   2 /*
   3  * msg.c
   4  *
   5  * Copyright (c) 1996-1999 Whistle Communications, Inc.
   6  * All rights reserved.
   7  *
   8  * Subject to the following obligations and disclaimer of warranty, use and
   9  * redistribution of this software, in source or object code forms, with or
  10  * without modifications are expressly permitted by Whistle Communications;
  11  * provided, however, that:
  12  * 1. Any and all reproductions of the source or object code must include the
  13  *    copyright notice above and the following disclaimer of warranties; and
  14  * 2. No rights are granted, in any manner or form, to use Whistle
  15  *    Communications, Inc. trademarks, including the mark "WHISTLE
  16  *    COMMUNICATIONS" on advertising, endorsements, or otherwise except as
  17  *    such appears in the above copyright notice or in the software.
  18  *
  19  * THIS SOFTWARE IS BEING PROVIDED BY WHISTLE COMMUNICATIONS "AS IS", AND
  20  * TO THE MAXIMUM EXTENT PERMITTED BY LAW, WHISTLE COMMUNICATIONS MAKES NO
  21  * REPRESENTATIONS OR WARRANTIES, EXPRESS OR IMPLIED, REGARDING THIS SOFTWARE,
  22  * INCLUDING WITHOUT LIMITATION, ANY AND ALL IMPLIED WARRANTIES OF
  23  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, OR NON-INFRINGEMENT.
  24  * WHISTLE COMMUNICATIONS DOES NOT WARRANT, GUARANTEE, OR MAKE ANY
  25  * REPRESENTATIONS REGARDING THE USE OF, OR THE RESULTS OF THE USE OF THIS
  26  * SOFTWARE IN TERMS OF ITS CORRECTNESS, ACCURACY, RELIABILITY OR OTHERWISE.
  27  * IN NO EVENT SHALL WHISTLE COMMUNICATIONS BE LIABLE FOR ANY DAMAGES
  28  * RESULTING FROM OR ARISING OUT OF ANY USE OF THIS SOFTWARE, INCLUDING
  29  * WITHOUT LIMITATION, ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY,
  30  * PUNITIVE, OR CONSEQUENTIAL DAMAGES, PROCUREMENT OF SUBSTITUTE GOODS OR
  31  * SERVICES, LOSS OF USE, DATA OR PROFITS, HOWEVER CAUSED AND UNDER ANY
  32  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  33  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  34  * THIS SOFTWARE, EVEN IF WHISTLE COMMUNICATIONS IS ADVISED OF THE POSSIBILITY
  35  * OF SUCH DAMAGE.
  36  *
  37  * Author: Archie Cobbs <archie@whistle.com>
  38  *
  39  * $FreeBSD: src/lib/libnetgraph/msg.c,v 1.2.2.3 2001/10/29 18:36:30 archie Exp $
  40  * $DragonFly: src/lib/libnetgraph/msg.c,v 1.4 2007/06/03 23:41:25 swildner Exp $
  41  * $Whistle: msg.c,v 1.9 1999/01/20 00:57:23 archie Exp $
  42  */
  43
  44 #include <sys/types.h>
  45 #include <stdarg.h>
  46 #include <netgraph/ng_message.h>
  47 #include <netgraph/socket/ng_socket.h>
  48
  49 #include "netgraph.h"
  50 #include "internal.h"
  51
  52 /* Next message token value */
  53 static int      gMsgId;
  54
  55 /* For delivering both messages and replies */
  56 static int      NgDeliverMsg(int cs, const char *path,
  57                   const struct ng_mesg *hdr, const void *args, size_t arglen);
  58
  59 /*
  60  * Send a message to a node using control socket node "cs".
  61  * Returns -1 if error and sets errno appropriately.
  62  * If successful, returns the message ID (token) used.
  63  */
  64 int
  65 NgSendMsg(int cs, const char *path,
  66           int cookie, int cmd, const void *args, size_t arglen)
  67 {
  68         struct ng_mesg msg;
  69
  70         /* Prepare message header */
  71         memset(&msg, 0, sizeof(msg));
  72         msg.header.version = NG_VERSION;
  73         msg.header.typecookie = cookie;
  74         if (++gMsgId < 0)
  75                 gMsgId = 1;
  76         msg.header.token = gMsgId;
  77         msg.header.flags = NGF_ORIG;
  78         msg.header.cmd = cmd;
  79         snprintf(msg.header.cmdstr, NG_CMDSTRSIZ, "cmd%d", cmd);
  80
  81         /* Deliver message */
  82         if (NgDeliverMsg(cs, path, &msg, args, arglen) < 0)
  83                 return (-1);
  84         return (msg.header.token);
  85 }
  86
  87 /*
  88  * Send a message given in ASCII format. We first ask the node to translate
  89  * the command into binary, and then we send the binary.
  90  */
  91 int
  92 NgSendAsciiMsg(int cs, const char *path, const char *fmt, ...)
  93 {
  94         const int bufSize = 1024;
  95         char replybuf[2 * sizeof(struct ng_mesg) + bufSize];
  96         struct ng_mesg *const reply = (struct ng_mesg *)replybuf;
  97         struct ng_mesg *const binary = (struct ng_mesg *)reply->data;
  98         struct ng_mesg *ascii;
  99         char *buf, *cmd, *args;
 100         va_list fmtargs;
 101
 102         /* Parse out command and arguments */
 103         va_start(fmtargs, fmt);
 104         vasprintf(&buf, fmt, fmtargs);
 105         va_end(fmtargs);
 106         if (buf == NULL)
 107                 return (-1);
 108
 109         /* Parse out command, arguments */
 110         for (cmd = buf; isspace(*cmd); cmd++)
 111                 ;
 112         for (args = cmd; *args != '\0' && !isspace(*args); args++)
 113                 ;
 114         if (*args != '\0') {
 115                 while (isspace(*args))
 116                         *args++ = '\0';
 117         }
 118
 119         /* Get a bigger buffer to hold inner message header plus arg string */
 120         if ((ascii = malloc(sizeof(struct ng_mesg)
 121             + strlen(args) + 1)) == NULL) {
 122                 free(buf);
 123                 return (-1);
 124         }
 125         memset(ascii, 0, sizeof(*ascii));
 126
 127         /* Build inner header (only need cmdstr, arglen, and data fields) */
 128         strncpy(ascii->header.cmdstr, cmd, sizeof(ascii->header.cmdstr) - 1);
 129         strcpy(ascii->data, args);
 130         ascii->header.arglen = strlen(ascii->data) + 1;
 131         free(buf);
 132
 133         /* Send node a request to convert ASCII to binary */
 134         if (NgSendMsg(cs, path, NGM_GENERIC_COOKIE, NGM_ASCII2BINARY,
 135             (u_char *)ascii, sizeof(*ascii) + ascii->header.arglen) < 0)
 136                 return (-1);
 137
 138         /* Get reply */
 139         if (NgRecvMsg(cs, reply, sizeof(replybuf), NULL) < 0)
 140                 return (-1);
 141
 142         /* Now send binary version */
 143         if (++gMsgId < 0)
 144                 gMsgId = 1;
 145         binary->header.token = gMsgId;
 146         if (NgDeliverMsg(cs,
 147             path, binary, binary->data, binary->header.arglen) < 0)
 148                 return (-1);
 149         return (binary->header.token);
 150 }
 151
 152 /*
 153  * Send a message that is a reply to a previously received message.
 154  * Returns -1 and sets errno on error, otherwise returns zero.
 155  */
 156 int
 157 NgSendReplyMsg(int cs, const char *path,
 158         const struct ng_mesg *msg, const void *args, size_t arglen)
 159 {
 160         struct ng_mesg rep;
 161
 162         /* Prepare message header */
 163         rep = *msg;
 164         rep.header.flags = NGF_RESP;
 165
 166         /* Deliver message */
 167         return (NgDeliverMsg(cs, path, &rep, args, arglen));
 168 }
 169
 170 /*
 171  * Send a message to a node using control socket node "cs".
 172  * Returns -1 if error and sets errno appropriately, otherwise zero.
 173  */
 174 static int
 175 NgDeliverMsg(int cs, const char *path,
 176         const struct ng_mesg *hdr, const void *args, size_t arglen)
 177 {
 178         u_char sgbuf[NG_PATHSIZ + 2];
 179         struct sockaddr_ng *const sg = (struct sockaddr_ng *) sgbuf;
 180         u_char *buf = NULL;
 181         struct ng_mesg *msg;
 182         int errnosv = 0;
 183         int rtn = 0;
 184
 185         /* Sanity check */
 186         if (args == NULL)
 187                 arglen = 0;
 188
 189         /* Get buffer */
 190         if ((buf = malloc(sizeof(*msg) + arglen)) == NULL) {
 191                 errnosv = errno;
 192                 if (_gNgDebugLevel >= 1)
 193                         NGLOG("malloc");
 194                 rtn = -1;
 195                 goto done;
 196         }
 197         msg = (struct ng_mesg *) buf;
 198
 199         /* Finalize message */
 200         *msg = *hdr;
 201         msg->header.arglen = arglen;
 202         memcpy(msg->data, args, arglen);
 203
 204         /* Prepare socket address */
 205         sg->sg_family = AF_NETGRAPH;
 206         snprintf(sg->sg_data, NG_PATHSIZ, "%s", path);
 207         sg->sg_len = strlen(sg->sg_data) + 3;
 208
 209         /* Debugging */
 210         if (_gNgDebugLevel >= 2) {
 211                 NGLOGX("SENDING %s:",
 212                     (msg->header.flags & NGF_RESP) ? "RESPONSE" : "MESSAGE");
 213                 _NgDebugSockaddr(sg);
 214                 _NgDebugMsg(msg, sg->sg_data);
 215         }
 216
 217         /* Send it */
 218         if (sendto(cs, msg, sizeof(*msg) + arglen,
 219                    0, (struct sockaddr *) sg, sg->sg_len) < 0) {
 220                 errnosv = errno;
 221                 if (_gNgDebugLevel >= 1)
 222                         NGLOG("sendto(%s)", sg->sg_data);
 223                 rtn = -1;
 224                 goto done;
 225         }
 226
 227 done:
 228         /* Done */
 229         free(buf);              /* OK if buf is NULL */
 230         errno = errnosv;
 231         return (rtn);
 232 }
 233
 234 /*
 235  * Receive a control message.
 236  *
 237  * On error, this returns -1 and sets errno.
 238  * Otherwise, it returns the length of the received reply.
 239  */
 240 int
 241 NgRecvMsg(int cs, struct ng_mesg *rep, size_t replen, char *path)
 242 {
 243         u_char sgbuf[NG_PATHSIZ - 1 + sizeof(struct sockaddr_ng)];
 244         struct sockaddr_ng *const sg = (struct sockaddr_ng *) sgbuf;
 245         int len, sglen = sizeof(sgbuf);
 246         int errnosv;
 247
 248         /* Read reply */
 249         len = recvfrom(cs, rep, replen, 0, (struct sockaddr *) sg, &sglen);
 250         if (len < 0) {
 251                 errnosv = errno;
 252                 if (_gNgDebugLevel >= 1)
 253                         NGLOG("recvfrom");
 254                 goto errout;
 255         }
 256         if (path != NULL)
 257                 snprintf(path, NG_PATHSIZ, "%s", sg->sg_data);
 258
 259         /* Debugging */
 260         if (_gNgDebugLevel >= 2) {
 261                 NGLOGX("RECEIVED %s:",
 262                     (rep->header.flags & NGF_RESP) ? "RESPONSE" : "MESSAGE");
 263                 _NgDebugSockaddr(sg);
 264                 _NgDebugMsg(rep, sg->sg_data);
 265         }
 266
 267         /* Done */
 268         return (len);
 269
 270 errout:
 271         errno = errnosv;
 272         return (-1);
 273 }
 274
 275 /*
 276  * Receive a control message and convert the arguments to ASCII
 277  */
 278 int
 279 NgRecvAsciiMsg(int cs, struct ng_mesg *reply, size_t replen, char *path)
 280 {
 281         struct ng_mesg *msg, *ascii;
 282         int bufSize, errnosv;
 283         u_char *buf;
 284
 285         /* Allocate buffer */
 286         bufSize = 2 * sizeof(*reply) + replen;
 287         if ((buf = malloc(bufSize)) == NULL)
 288                 return (-1);
 289         msg = (struct ng_mesg *)buf;
 290         ascii = (struct ng_mesg *)msg->data;
 291
 292         /* Get binary message */
 293         if (NgRecvMsg(cs, msg, bufSize, path) < 0)
 294                 goto fail;
 295         memcpy(reply, msg, sizeof(*msg));
 296
 297         /* Ask originating node to convert the arguments to ASCII */
 298         if (NgSendMsg(cs, path, NGM_GENERIC_COOKIE,
 299             NGM_BINARY2ASCII, msg, sizeof(*msg) + msg->header.arglen) < 0)
 300                 goto fail;
 301         if (NgRecvMsg(cs, msg, bufSize, NULL) < 0)
 302                 goto fail;
 303
 304         /* Copy result to client buffer */
 305         if (sizeof(*ascii) + ascii->header.arglen > replen) {
 306                 errno = ERANGE;
 307 fail:
 308                 errnosv = errno;
 309                 free(buf);
 310                 errno = errnosv;
 311                 return (-1);
 312         }
 313         strncpy(reply->data, ascii->data, ascii->header.arglen);
 314
 315         /* Done */
 316         free(buf);
 317         return (0);
 318 }
 319