The Tcpdump Group git mirrors - tcpdump/blob - print-resp.c

   1 /*
   2  * This file implements decoding of the REdis Serialization Protocol.
   3  *
   4  *
   5  * Copyright (c) 2015 The TCPDUMP project
   6  * All rights reserved.
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted provided that the following conditions
  10  * are met:
  11  * 1. Redistributions of source code must retain the above copyright
  12  *    notice, this list of conditions and the following disclaimer.
  13  * 2. Redistributions in binary form must reproduce the above copyright
  14  *    notice, this list of conditions and the following disclaimer in the
  15  *    documentation and/or other materials provided with the distribution.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  18  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  19  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
  20  * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
  21  * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
  22  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
  23  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  24  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
  25  * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  26  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
  27  * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  28  * POSSIBILITY OF SUCH DAMAGE.
  29  *
  30  * Initial contribution by Andrew Darqui (andrew.darqui@gmail.com).
  31  */
  32
  33 #define NETDISSECT_REWORKED
  34 #ifdef HAVE_CONFIG_H
  35 #include "config.h"
  36 #endif
  37
  38 #include <netdissect-stdinc.h>
  39 #include "netdissect.h"
  40
  41 #include <string.h>
  42 #include <stdlib.h>
  43
  44 #include "extract.h"
  45
  46 static const char tstr[] = " [|RESP]";
  47
  48 /*
  49  * For information regarding RESP, see: http://redis.io/topics/protocol
  50  */
  51
  52 #define RESP_SIMPLE_STRING    '+'
  53 #define RESP_ERROR            '-'
  54 #define RESP_INTEGER          ':'
  55 #define RESP_BULK_STRING      '$'
  56 #define RESP_ARRAY            '*'
  57
  58 #define resp_print_empty(ndo)      ND_PRINT((ndo, " empty"))
  59 #define resp_print_null(ndo)       ND_PRINT((ndo, " null"))
  60 #define resp_print_invalid(ndo)    ND_PRINT((ndo, " invalid"))
  61
  62 void       resp_print(netdissect_options *, const u_char *, u_int);
  63 static int resp_parse(netdissect_options *, register const u_char *, int);
  64 static int resp_print_string_error_integer(netdissect_options *, register const u_char *, int);
  65 static int resp_print_simple_string(netdissect_options *, register const u_char *, int);
  66 static int resp_print_integer(netdissect_options *, register const u_char *, int);
  67 static int resp_print_error(netdissect_options *, register const u_char *, int);
  68 static int resp_print_bulk_string(netdissect_options *, register const u_char *, int);
  69 static int resp_print_bulk_array(netdissect_options *, register const u_char *, int);
  70 static int resp_print_inline(netdissect_options *, register const u_char *, int);
  71
  72 /*
  73  * MOVE_FORWARD:
  74  * Attempts to move our 'ptr' forward until a \r\n is found,
  75  * while also making sure we don't exceed the buffer 'len'.
  76  * If we exceed, jump to trunc.
  77  */
  78 #define MOVE_FORWARD(ptr, len) \
  79     while(*ptr != '\r' && *(ptr+1) != '\n') { ND_TCHECK2(*ptr, 2); ptr++; len--; }
  80
  81 /*
  82  * MOVE_FORWARD_CR_OR_LF
  83  * Attempts to move our 'ptr' forward until a \r or \n is found,
  84  * while also making sure we don't exceed the buffer 'len'.
  85  * If we exceed, jump to trunc.
  86  */
  87 #define MOVE_FORWARD_CR_OR_LF(ptr, len) \
  88     while(*ptr != '\r' && *ptr != '\n') { ND_TCHECK(*ptr); ptr++; len--; }
  89
  90 /*
  91  * CONSUME_CR_OR_LF
  92  * Consume all consecutive \r and \n bytes.
  93  * If we exceed 'len', jump to trunc.
  94  */
  95 #define CONSUME_CR_OR_LF(ptr, len) \
  96     while (*ptr == '\r' || *ptr == '\n') { ND_TCHECK(*ptr); ptr++; len--; }
  97
  98 /*
  99  * INCBY
 100  * Attempts to increment our 'ptr' by 'increment' bytes.
 101  * If our increment exceeds the buffer length (len - increment),
 102  * bail out by jumping to the trunc goto tag.
 103  */
 104 #define INCBY(ptr, increment, len) \
 105     { ND_TCHECK2(*ptr, increment); ptr+=increment; len-=increment; }
 106
 107 /*
 108  * INC1
 109  * Increment our ptr by 1 byte.
 110  * Most often used to skip an opcode (+-:*$ etc)
 111  */
 112 #define INC1(ptr, len) INCBY(ptr, 1, len)
 113
 114 /*
 115  * INC2
 116  * Increment our ptr by 2 bytes.
 117  * Most often used to skip CRLF (\r\n).
 118  */
 119 #define INC2(ptr, len) INCBY(ptr, 2, len)
 120
 121 /*
 122  * TEST_RET_LEN
 123  * If ret_len is < 0, jump to the trunc tag which returns (-1)
 124  * and 'bubbles up' to printing tstr. Otherwise, return ret_len.
 125  */
 126 #define TEST_RET_LEN(rl) \
 127     if (rl < 0) { goto trunc; } else { return rl; }
 128
 129 /*
 130  * TEST_RET_LEN_NORETURN
 131  * If ret_len is < 0, jump to the trunc tag which returns (-1)
 132  * and 'bubbles up' to printing tstr. Otherwise, continue onward.
 133  */
 134 #define TEST_RET_LEN_NORETURN(rl) \
 135     if (rl < 0) { goto trunc; }
 136
 137 /*
 138  * RESP_PRINT_SEGMENT
 139  * Prints a segment in the form of: ' "<stuff>"\n"
 140  */
 141 #define RESP_PRINT_SEGMENT(_ndo, _bp, _len)            \
 142         ND_PRINT((_ndo, " \""));                       \
 143         fn_printn(_ndo, _bp, _len, _ndo->ndo_snapend); \
 144         fn_print_char(_ndo, '"');
 145
 146 void
 147 resp_print(netdissect_options *ndo, const u_char *bp, u_int length)
 148 {
 149     int ret_len = 0, length_cur = length;
 150
 151     if(!bp || length <= 0)
 152         return;
 153
 154     ND_PRINT((ndo, ": RESP"));
 155     while (length_cur > 0) {
 156         /*
 157          * This block supports redis pipelining.
 158          * For example, multiple operations can be pipelined within the same string:
 159          * "*2\r\n\$4\r\nINCR\r\n\$1\r\nz\r\n*2\r\n\$4\r\nINCR\r\n\$1\r\nz\r\n*2\r\n\$4\r\nINCR\r\n\$1\r\nz\r\n"
 160          * or
 161          * "PING\r\nPING\r\nPING\r\n"
 162          * In order to handle this case, we must try and parse 'bp' until
 163          * 'length' bytes have been processed or we reach a trunc condition.
 164          */
 165         ret_len = resp_parse(ndo, bp, length_cur);
 166         TEST_RET_LEN_NORETURN(ret_len);
 167         bp += ret_len;
 168         length_cur -= ret_len;
 169     }
 170
 171     return;
 172
 173 trunc:
 174     ND_PRINT((ndo, "%s", tstr));
 175 }
 176
 177 static int
 178 resp_parse(netdissect_options *ndo, register const u_char *bp, int length)
 179 {
 180     int ret_len = 0;
 181     u_char op = *bp;
 182
 183     ND_TCHECK(*bp);
 184
 185     switch(op) {
 186         case RESP_SIMPLE_STRING:  ret_len = resp_print_simple_string(ndo, bp, length);   break;
 187         case RESP_INTEGER:        ret_len = resp_print_integer(ndo, bp, length);         break;
 188         case RESP_ERROR:          ret_len = resp_print_error(ndo, bp, length);           break;
 189         case RESP_BULK_STRING:    ret_len = resp_print_bulk_string(ndo, bp, length);     break;
 190         case RESP_ARRAY:          ret_len = resp_print_bulk_array(ndo, bp, length);      break;
 191         default:                  ret_len = resp_print_inline(ndo, bp, length);          break;
 192     }
 193
 194     TEST_RET_LEN(ret_len);
 195
 196 trunc:
 197     return (-1);
 198 }
 199
 200 static int
 201 resp_print_simple_string(netdissect_options *ndo, register const u_char *bp, int length) {
 202     return resp_print_string_error_integer(ndo, bp, length);
 203 }
 204
 205 static int
 206 resp_print_integer(netdissect_options *ndo, register const u_char *bp, int length) {
 207     return resp_print_string_error_integer(ndo, bp, length);
 208 }
 209
 210 static int
 211 resp_print_error(netdissect_options *ndo, register const u_char *bp, int length) {
 212     return resp_print_string_error_integer(ndo, bp, length);
 213 }
 214
 215 static int
 216 resp_print_string_error_integer(netdissect_options *ndo, register const u_char *bp, int length) {
 217     int length_cur = length, len, ret_len = 0;
 218     const u_char *bp_ptr = bp;
 219
 220     /*
 221      * MOVE_FORWARD moves past the string that follows the (+-;) opcodes
 222      * +OK\r\n
 223      * -ERR ...\r\n
 224      * :02912309\r\n
 225      */
 226     MOVE_FORWARD(bp_ptr, length_cur);
 227     len = (bp_ptr - bp);
 228     ND_TCHECK2(*bp, len);
 229     RESP_PRINT_SEGMENT(ndo, bp+1, len-1);
 230     ret_len = len /*<1byte>+<string>*/ + 2 /*<CRLF>*/;
 231
 232     TEST_RET_LEN(ret_len);
 233
 234 trunc:
 235     return (-1);
 236 }
 237
 238 static int
 239 resp_print_bulk_string(netdissect_options *ndo, register const u_char *bp, int length) {
 240     int length_cur = length, string_len;
 241
 242     ND_TCHECK(*bp);
 243
 244     /* opcode: '$' */
 245     INC1(bp, length_cur);
 246     ND_TCHECK(*bp);
 247
 248     /* <length> */
 249     string_len = atoi((const char *)bp);
 250
 251     /* move to \r\n */
 252     MOVE_FORWARD(bp, length_cur);
 253
 254     /* \r\n */
 255     INC2(bp, length_cur);
 256
 257     if (string_len > 0) {
 258         /* Byte string of length string_len */
 259         ND_TCHECK2(*bp, string_len);
 260         RESP_PRINT_SEGMENT(ndo, bp, string_len);
 261     } else {
 262         switch(string_len) {
 263             case 0: resp_print_empty(ndo); break;
 264             case (-1): {
 265                 /* This is the NULL response. It follows a different pattern: $-1\r\n */
 266                 resp_print_null(ndo);
 267                 TEST_RET_LEN(length - length_cur);
 268                 /* returned ret_len or jumped to trunc */
 269             }
 270             default: resp_print_invalid(ndo); break;
 271         }
 272     }
 273
 274     /* <string> */
 275     INCBY(bp, string_len, length_cur);
 276
 277     /* \r\n */
 278     INC2(bp, length_cur);
 279
 280     TEST_RET_LEN(length - length_cur);
 281
 282 trunc:
 283     return (-1);
 284 }
 285
 286 static int
 287 resp_print_bulk_array(netdissect_options *ndo, register const u_char *bp, int length) {
 288     int length_cur = length, array_len, i, ret_len = 0;
 289
 290     ND_TCHECK(*bp);
 291
 292     /* opcode: '*' */
 293     INC1(bp, length_cur);
 294     ND_TCHECK(*bp);
 295
 296     /* <array_length> */
 297     array_len = atoi((const char *)bp);
 298
 299     /* move to \r\n */
 300     MOVE_FORWARD(bp, length_cur);
 301
 302     /* \r\n */
 303     INC2(bp, length_cur);
 304
 305     if (array_len > 0) {
 306         /* non empty array */
 307         for (i = 0; i < array_len; i++) {
 308             ret_len = resp_parse(ndo, bp, length_cur);
 309
 310             TEST_RET_LEN_NORETURN(ret_len);
 311
 312             bp += ret_len;
 313             length_cur -= ret_len;
 314
 315             TEST_RET_LEN_NORETURN(length - length_cur);
 316         }
 317     } else {
 318         /* empty, null, or invalid */
 319         switch(array_len) {
 320             case 0:     resp_print_empty(ndo);   break;
 321             case (-1):  resp_print_null(ndo);    break;
 322             default:    resp_print_invalid(ndo); break;
 323         }
 324     }
 325
 326     TEST_RET_LEN(length - length_cur);
 327
 328 trunc:
 329     return (-1);
 330 }
 331
 332 static int
 333 resp_print_inline(netdissect_options *ndo, register const u_char *bp, int length) {
 334     int length_cur = length, len;
 335     const u_char *bp_ptr;
 336
 337     /*
 338      * Inline commands are simply 'strings' followed by \r or \n or both.
 339      * Redis will do it's best to split/parse these strings.
 340      * This feature of redis is implemented to support the ability of
 341      * command parsing from telnet/nc sessions etc.
 342      *
 343      * <string><\r||\n||\r\n...>
 344      */
 345     CONSUME_CR_OR_LF(bp, length_cur);
 346     bp_ptr = bp;
 347     MOVE_FORWARD_CR_OR_LF(bp_ptr, length_cur);
 348     len = (bp_ptr - bp);
 349     ND_TCHECK2(*bp, len);
 350     RESP_PRINT_SEGMENT(ndo, bp, len);
 351     CONSUME_CR_OR_LF(bp_ptr, length_cur);
 352
 353     TEST_RET_LEN(length - length_cur);
 354
 355 trunc:
 356     return (-1);
 357 }