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 <errno.h> /* for the errno variable */
42 #include "sockutils.h"
43 #include "portability.h"
44 #include "rpcap-protocol.h"
45 #include <pcap/pcap.h>
46
47 /*
48 * This file contains functions used both by the rpcap client and the
49 * rpcap daemon.
50 */
51
52 /*
53 * This function sends a RPCAP error to our peer.
54 *
55 * It has to be called when the main program detects an error.
56 * It will send to our peer the 'buffer' specified by the user.
57 * This function *does not* request a RPCAP CLOSE connection. A CLOSE
58 * command must be sent explicitly by the program, since we do not know
59 * whether the error can be recovered in some way or if it is a
60 * non-recoverable one.
61 *
62 * \param sock: the socket we are currently using.
63 *
64 * \param ssl: if compiled with openssl, the optional ssl handler to use with the above socket.
65 *
66 * \param ver: the protocol version we want to put in the reply.
67 *
68 * \param errcode: a integer which tells the other party the type of error
69 * we had.
70 *
71 * \param error: an user-allocated (and '0' terminated) buffer that contains
72 * the error description that has to be transmitted to our peer. The
73 * error message cannot be longer than PCAP_ERRBUF_SIZE.
74 *
75 * \param errbuf: a pointer to a user-allocated buffer (of size
76 * PCAP_ERRBUF_SIZE) that will contain the error message (in case there
77 * is one). It could be network problem.
78 *
79 * \return '0' if everything is fine, '-1' if some errors occurred. The
80 * error message is returned in the 'errbuf' variable.
81 */
82 int
rpcap_senderror(SOCKET sock,SSL * ssl,uint8 ver,unsigned short errcode,const char * error,char * errbuf)83 rpcap_senderror(SOCKET sock, SSL *ssl, uint8 ver, unsigned short errcode, const char *error, char *errbuf)
84 {
85 char sendbuf[RPCAP_NETBUF_SIZE]; /* temporary buffer in which data to be sent is buffered */
86 int sendbufidx = 0; /* index which keeps the number of bytes currently buffered */
87 uint16 length;
88
89 length = (uint16)strlen(error);
90
91 if (length > PCAP_ERRBUF_SIZE)
92 length = PCAP_ERRBUF_SIZE;
93
94 rpcap_createhdr((struct rpcap_header *) sendbuf, ver, RPCAP_MSG_ERROR, errcode, length);
95
96 if (sock_bufferize(NULL, sizeof(struct rpcap_header), NULL, &sendbufidx,
97 RPCAP_NETBUF_SIZE, SOCKBUF_CHECKONLY, errbuf, PCAP_ERRBUF_SIZE))
98 return -1;
99
100 if (sock_bufferize(error, length, sendbuf, &sendbufidx,
101 RPCAP_NETBUF_SIZE, SOCKBUF_BUFFERIZE, errbuf, PCAP_ERRBUF_SIZE))
102 return -1;
103
104 if (sock_send(sock, ssl, sendbuf, sendbufidx, errbuf, PCAP_ERRBUF_SIZE) < 0)
105 return -1;
106
107 return 0;
108 }
109
110 /*
111 * This function fills in a structure of type rpcap_header.
112 *
113 * It is provided just because the creation of an rpcap header is a common
114 * task. It accepts all the values that appears into an rpcap_header, and
115 * it puts them in place using the proper hton() calls.
116 *
117 * \param header: a pointer to a user-allocated buffer which will contain
118 * the serialized header, ready to be sent on the network.
119 *
120 * \param ver: a value (in the host byte order) which will be placed into the
121 * header.ver field and that represents the protocol version number of the
122 * current message.
123 *
124 * \param type: a value (in the host byte order) which will be placed into the
125 * header.type field and that represents the type of the current message.
126 *
127 * \param value: a value (in the host byte order) which will be placed into
128 * the header.value field and that has a message-dependent meaning.
129 *
130 * \param length: a value (in the host by order) which will be placed into
131 * the header.length field, representing the payload length of the message.
132 *
133 * \return Nothing. The serialized header is returned into the 'header'
134 * variable.
135 */
136 void
rpcap_createhdr(struct rpcap_header * header,uint8 ver,uint8 type,uint16 value,uint32 length)137 rpcap_createhdr(struct rpcap_header *header, uint8 ver, uint8 type, uint16 value, uint32 length)
138 {
139 memset(header, 0, sizeof(struct rpcap_header));
140
141 header->ver = ver;
142 header->type = type;
143 header->value = htons(value);
144 header->plen = htonl(length);
145 }
146
147 /*
148 * Convert a message type to a string containing the type name.
149 */
150 static const char *requests[] =
151 {
152 NULL, /* not a valid message type */
153 "RPCAP_MSG_ERROR",
154 "RPCAP_MSG_FINDALLIF_REQ",
155 "RPCAP_MSG_OPEN_REQ",
156 "RPCAP_MSG_STARTCAP_REQ",
157 "RPCAP_MSG_UPDATEFILTER_REQ",
158 "RPCAP_MSG_CLOSE",
159 "RPCAP_MSG_PACKET",
160 "RPCAP_MSG_AUTH_REQ",
161 "RPCAP_MSG_STATS_REQ",
162 "RPCAP_MSG_ENDCAP_REQ",
163 "RPCAP_MSG_SETSAMPLING_REQ",
164 };
165 #define NUM_REQ_TYPES (sizeof requests / sizeof requests[0])
166
167 static const char *replies[] =
168 {
169 NULL,
170 NULL, /* this would be a reply to RPCAP_MSG_ERROR */
171 "RPCAP_MSG_FINDALLIF_REPLY",
172 "RPCAP_MSG_OPEN_REPLY",
173 "RPCAP_MSG_STARTCAP_REPLY",
174 "RPCAP_MSG_UPDATEFILTER_REPLY",
175 NULL, /* this would be a reply to RPCAP_MSG_CLOSE */
176 NULL, /* this would be a reply to RPCAP_MSG_PACKET */
177 "RPCAP_MSG_AUTH_REPLY",
178 "RPCAP_MSG_STATS_REPLY",
179 "RPCAP_MSG_ENDCAP_REPLY",
180 "RPCAP_MSG_SETSAMPLING_REPLY",
181 };
182 #define NUM_REPLY_TYPES (sizeof replies / sizeof replies[0])
183
184 const char *
rpcap_msg_type_string(uint8 type)185 rpcap_msg_type_string(uint8 type)
186 {
187 if (type & RPCAP_MSG_IS_REPLY) {
188 type &= ~RPCAP_MSG_IS_REPLY;
189 if (type >= NUM_REPLY_TYPES)
190 return NULL;
191 return replies[type];
192 } else {
193 if (type >= NUM_REQ_TYPES)
194 return NULL;
195 return requests[type];
196 }
197 }
198