The Tcpdump Group git mirrors - libpcap/blob - rpcap-protocol.c

   1 /*
   2  * Copyright (c) 2002 - 2005 NetGroup, Politecnico di Torino (Italy)
   3  * Copyright (c) 2005 - 2008 CACE Technologies, Davis (California)
   4  * All rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  *
  10  * 1. Redistributions of source code must retain the above copyright
  11  * notice, this list of conditions and the following disclaimer.
  12  * 2. Redistributions in binary form must reproduce the above copyright
  13  * notice, this list of conditions and the following disclaimer in the
  14  * documentation and/or other materials provided with the distribution.
  15  * 3. Neither the name of the Politecnico di Torino, CACE Technologies
  16  * nor the names of its contributors may be used to endorse or promote
  17  * products derived from this software without specific prior written
  18  * permission.
  19  *
  20  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  21  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  22  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  23  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  24  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  25  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  26  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  27  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON 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
  30  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  31  *
  32  */
  33
  34 #ifdef HAVE_CONFIG_H
  35 #include <config.h>
  36 #endif
  37
  38 #include <string.h>             /* for strlen(), ... */
  39 #include <stdlib.h>             /* for malloc(), free(), ... */
  40 #include <stdarg.h>             /* for functions with variable number of arguments */
  41 #include <stdint.h>             /* for intN_t and uintN_t types */
  42 #include <errno.h>              /* for the errno variable */
  43 #include "sockutils.h"
  44 #include "portability.h"
  45 #include "rpcap-protocol.h"
  46 #include <pcap/pcap.h>
  47
  48 /*
  49  * This file contains functions used both by the rpcap client and the
  50  * rpcap daemon.
  51  */
  52
  53 /*
  54  * This function sends a RPCAP error to our peer.
  55  *
  56  * It has to be called when the main program detects an error.
  57  * It will send to our peer the 'buffer' specified by the user.
  58  * This function *does not* request a RPCAP CLOSE connection. A CLOSE
  59  * command must be sent explicitly by the program, since we do not know
  60  * whether the error can be recovered in some way or if it is a
  61  * non-recoverable one.
  62  *
  63  * \param sock: the socket we are currently using.
  64  *
  65  * \param ssl: if compiled with openssl, the optional ssl handler to use with the above socket.
  66  *
  67  * \param ver: the protocol version we want to put in the reply.
  68  *
  69  * \param errcode: a integer which tells the other party the type of error
  70  * we had.
  71  *
  72  * \param error: an user-allocated (and '0' terminated) buffer that contains
  73  * the error description that has to be transmitted to our peer. The
  74  * error message cannot be longer than PCAP_ERRBUF_SIZE.
  75  *
  76  * \param errbuf: a pointer to a user-allocated buffer (of size
  77  * PCAP_ERRBUF_SIZE) that will contain the error message (in case there
  78  * is one). It could be network problem.
  79  *
  80  * \return '0' if everything is fine, '-1' if some errors occurred. The
  81  * error message is returned in the 'errbuf' variable.
  82  */
  83 int
  84 rpcap_senderror(SOCKET sock, SSL *ssl, uint8_t ver, unsigned short errcode, const char *error, char *errbuf)
  85 {
  86         char sendbuf[RPCAP_NETBUF_SIZE];        /* temporary buffer in which data to be sent is buffered */
  87         int sendbufidx = 0;                     /* index which keeps the number of bytes currently buffered */
  88         uint16_t length;
  89
  90         length = (uint16_t)strlen(error);
  91
  92         if (length > PCAP_ERRBUF_SIZE)
  93                 length = PCAP_ERRBUF_SIZE;
  94
  95         rpcap_createhdr((struct rpcap_header *) sendbuf, ver, RPCAP_MSG_ERROR, errcode, length);
  96
  97         if (sock_bufferize(NULL, sizeof(struct rpcap_header), NULL, &sendbufidx,
  98                 RPCAP_NETBUF_SIZE, SOCKBUF_CHECKONLY, errbuf, PCAP_ERRBUF_SIZE))
  99                 return -1;
 100
 101         if (sock_bufferize(error, length, sendbuf, &sendbufidx,
 102                 RPCAP_NETBUF_SIZE, SOCKBUF_BUFFERIZE, errbuf, PCAP_ERRBUF_SIZE))
 103                 return -1;
 104
 105         if (sock_send(sock, ssl, sendbuf, sendbufidx, errbuf, PCAP_ERRBUF_SIZE) < 0)
 106                 return -1;
 107
 108         return 0;
 109 }
 110
 111 /*
 112  * This function fills in a structure of type rpcap_header.
 113  *
 114  * It is provided just because the creation of an rpcap header is a common
 115  * task. It accepts all the values that appears into an rpcap_header, and
 116  * it puts them in place using the proper hton() calls.
 117  *
 118  * \param header: a pointer to a user-allocated buffer which will contain
 119  * the serialized header, ready to be sent on the network.
 120  *
 121  * \param ver: a value (in the host byte order) which will be placed into the
 122  * header.ver field and that represents the protocol version number of the
 123  * current message.
 124  *
 125  * \param type: a value (in the host byte order) which will be placed into the
 126  * header.type field and that represents the type of the current message.
 127  *
 128  * \param value: a value (in the host byte order) which will be placed into
 129  * the header.value field and that has a message-dependent meaning.
 130  *
 131  * \param length: a value (in the host by order) which will be placed into
 132  * the header.length field, representing the payload length of the message.
 133  *
 134  * \return Nothing. The serialized header is returned into the 'header'
 135  * variable.
 136  */
 137 void
 138 rpcap_createhdr(struct rpcap_header *header, uint8_t ver, uint8_t type, uint16_t value, uint32_t length)
 139 {
 140         memset(header, 0, sizeof(struct rpcap_header));
 141
 142         header->ver = ver;
 143         header->type = type;
 144         header->value = htons(value);
 145         header->plen = htonl(length);
 146 }
 147
 148 /*
 149  * Convert a message type to a string containing the type name.
 150  */
 151 static const char *requests[] =
 152 {
 153         NULL,                           /* not a valid message type */
 154         "RPCAP_MSG_ERROR",
 155         "RPCAP_MSG_FINDALLIF_REQ",
 156         "RPCAP_MSG_OPEN_REQ",
 157         "RPCAP_MSG_STARTCAP_REQ",
 158         "RPCAP_MSG_UPDATEFILTER_REQ",
 159         "RPCAP_MSG_CLOSE",
 160         "RPCAP_MSG_PACKET",
 161         "RPCAP_MSG_AUTH_REQ",
 162         "RPCAP_MSG_STATS_REQ",
 163         "RPCAP_MSG_ENDCAP_REQ",
 164         "RPCAP_MSG_SETSAMPLING_REQ",
 165 };
 166 #define NUM_REQ_TYPES   (sizeof requests / sizeof requests[0])
 167
 168 static const char *replies[] =
 169 {
 170         NULL,
 171         NULL,                   /* this would be a reply to RPCAP_MSG_ERROR */
 172         "RPCAP_MSG_FINDALLIF_REPLY",
 173         "RPCAP_MSG_OPEN_REPLY",
 174         "RPCAP_MSG_STARTCAP_REPLY",
 175         "RPCAP_MSG_UPDATEFILTER_REPLY",
 176         NULL,                   /* this would be a reply to RPCAP_MSG_CLOSE */
 177         NULL,                   /* this would be a reply to RPCAP_MSG_PACKET */
 178         "RPCAP_MSG_AUTH_REPLY",
 179         "RPCAP_MSG_STATS_REPLY",
 180         "RPCAP_MSG_ENDCAP_REPLY",
 181         "RPCAP_MSG_SETSAMPLING_REPLY",
 182 };
 183 #define NUM_REPLY_TYPES (sizeof replies / sizeof replies[0])
 184
 185 const char *
 186 rpcap_msg_type_string(uint8_t type)
 187 {
 188         if (type & RPCAP_MSG_IS_REPLY) {
 189                 type &= ~RPCAP_MSG_IS_REPLY;
 190                 if (type >= NUM_REPLY_TYPES)
 191                         return NULL;
 192                 return replies[type];
 193         } else {
 194                 if (type >= NUM_REQ_TYPES)
 195                         return NULL;
 196                 return requests[type];
 197         }
 198 }