File Manager

003 File Manager

Current Path: /usr/src/contrib/tcpdump

📁 ..
📄 CHANGES(57.87 KB)
📄 CONTRIBUTING(5.93 KB)
📄 CREDITS(14.57 KB)
📄 INSTALL.txt(5.25 KB)
📄 LICENSE(873 B)
📄 Makefile-devel-adds(614 B)
📄 Makefile.in(9.96 KB)
📄 PLATFORMS(567 B)
📄 README(9.04 KB)
📄 README.md(9.04 KB)
📄 VERSION(6 B)
📄 addrtoname.c(33.19 KB)
📄 addrtoname.h(2.78 KB)
📄 addrtostr.c(5.64 KB)
📄 addrtostr.h(2.03 KB)
📄 af.c(1.96 KB)
📄 af.h(1.81 KB)
📄 ah.h(2.34 KB)
📄 appletalk.h(4.06 KB)
📄 ascii_strcasecmp.c(3.5 KB)
📄 ascii_strcasecmp.h(1.49 KB)
📄 atime.awk(529 B)
📄 atm.h(1.14 KB)
📄 bpf_dump.c(1.9 KB)
📄 chdlc.h(1.31 KB)
📄 checksum.c(5.25 KB)
📄 config.guess(43.17 KB)
📄 config.h.in(11.19 KB)
📄 config.sub(34.93 KB)
📄 configure(255.88 KB)
📄 configure.ac(25.05 KB)
📄 configure.in(25.66 KB)
📄 cpack.c(3.92 KB)
📄 cpack.h(2.37 KB)
📄 ether.h(2.34 KB)
📄 ethertype.h(5.58 KB)
📄 extract.h(11.48 KB)
📄 funcattrs.h(4.42 KB)
📄 getopt_long.h(2.52 KB)
📄 gmpls.c(5.82 KB)
📄 gmpls.h(1.38 KB)
📄 gmt2local.c(2.01 KB)
📄 gmt2local.h(1.21 KB)
📄 in_cksum.c(6.44 KB)
📄 install-sh(5.45 KB)
📄 interface.h(2.29 KB)
📄 ip.h(5.75 KB)
📄 ip6.h(7.6 KB)
📄 ipproto.c(16.49 KB)
📄 ipproto.h(4.72 KB)
📄 l2vpn.c(3.36 KB)
📄 l2vpn.h(781 B)
📁 lbl
📄 llc.h(3.72 KB)
📄 machdep.c(2.58 KB)
📄 machdep.h(1.24 KB)
📄 makemib(6.41 KB)
📄 mib.h(26.33 KB)
📁 missing
📄 mkdep(2.43 KB)
📄 mpls.h(1.93 KB)
📄 nameser.h(10.8 KB)
📄 netdissect-stdinc.h(9.93 KB)
📄 netdissect.c(3.38 KB)
📄 netdissect.h(30.13 KB)
📄 nfs.h(13.37 KB)
📄 nfsfh.h(2.57 KB)
📄 nlpid.c(1.27 KB)
📄 nlpid.h(1.3 KB)
📄 openflow.h(2.14 KB)
📄 ospf.h(10.21 KB)
📄 oui.c(3.83 KB)
📄 oui.h(4.06 KB)
📄 packetdat.awk(1.39 KB)
📄 parsenfsfh.c(12.87 KB)
📄 pcap-missing.h(1.8 KB)
📄 pcap_dump_ftell.c(1.29 KB)
📄 ppp.h(3.07 KB)
📄 print-802_11.c(91.47 KB)
📄 print-802_15_4.c(5.5 KB)
📄 print-ah.c(2.02 KB)
📄 print-ahcp.c(10.73 KB)
📄 print-aodv.c(15.98 KB)
📄 print-aoe.c(11.13 KB)
📄 print-ap1394.c(4 KB)
📄 print-arcnet.c(8.83 KB)
📄 print-arp.c(14.57 KB)
📄 print-ascii.c(6.23 KB)
📄 print-atalk.c(16.76 KB)
📄 print-atm.c(16.81 KB)
📄 print-babel.c(23.79 KB)
📄 print-beep.c(1.71 KB)
📄 print-bfd.c(16.5 KB)
📄 print-bgp.c(99.77 KB)
📄 print-bootp.c(30.07 KB)
📄 print-bt.c(2.21 KB)
📄 print-calm-fast.c(1.81 KB)
📄 print-carp.c(2.43 KB)
📄 print-cdp.c(11.16 KB)
📄 print-cfm.c(24.19 KB)
📄 print-chdlc.c(5.88 KB)
📄 print-cip.c(2.5 KB)
📄 print-cnfp.c(13.69 KB)
📄 print-dccp.c(17.75 KB)
📄 print-decnet.c(37.63 KB)
📄 print-dhcp6.c(23.22 KB)
📄 print-domain.c(18.44 KB)
📄 print-dtp.c(3.03 KB)
📄 print-dvmrp.c(8.98 KB)
📄 print-eap.c(9.26 KB)
📄 print-egp.c(8.69 KB)
📄 print-eigrp.c(19.49 KB)
📄 print-enc.c(4.2 KB)
📄 print-esp.c(21.46 KB)
📄 print-ether.c(12.91 KB)
📄 print-fddi.c(10.51 KB)
📄 print-forces.c(45.01 KB)
📄 print-fr.c(31.99 KB)
📄 print-frag6.c(2.36 KB)
📄 print-ftp.c(973 B)
📄 print-geneve.c(6.13 KB)
📄 print-geonet.c(6.72 KB)
📄 print-gre.c(9.72 KB)
📄 print-hncp.c(26.39 KB)
📄 print-hsrp.c(4.57 KB)
📄 print-http.c(1.51 KB)
📄 print-icmp.c(22.7 KB)
📄 print-icmp6.c(59.81 KB)
📄 print-igmp.c(10.05 KB)
📄 print-igrp.c(4.64 KB)
📄 print-ip.c(17.04 KB)
📄 print-ip6.c(10.57 KB)
📄 print-ip6opts.c(5.53 KB)
📄 print-ipcomp.c(2.32 KB)
📄 print-ipfc.c(4.41 KB)
📄 print-ipnet.c(2.78 KB)
📄 print-ipx.c(6.42 KB)
📄 print-isakmp.c(81.72 KB)
📄 print-isoclns.c(107.61 KB)
📄 print-juniper.c(48.42 KB)
📄 print-krb.c(6.26 KB)
📄 print-l2tp.c(23.94 KB)
📄 print-lane.c(3.04 KB)
📄 print-ldp.c(24.35 KB)
📄 print-lisp.c(15.23 KB)
📄 print-llc.c(16.68 KB)
📄 print-lldp.c(57.26 KB)
📄 print-lmp.c(38.11 KB)
📄 print-loopback.c(3.63 KB)
📄 print-lspping.c(51.64 KB)
📄 print-lwapp.c(13.01 KB)
📄 print-lwres.c(14.08 KB)
📄 print-m3ua.c(10.92 KB)
📄 print-medsa.c(5.57 KB)
📄 print-mobile.c(3.28 KB)
📄 print-mobility.c(9.74 KB)
📄 print-mpcp.c(7.87 KB)
📄 print-mpls.c(5.31 KB)
📄 print-mptcp.c(13.68 KB)
📄 print-msdp.c(2.69 KB)
📄 print-msnlb.c(2.39 KB)
📄 print-nflog.c(4.4 KB)
📄 print-nfs.c(42.84 KB)
📄 print-nsh.c(5.39 KB)
📄 print-ntp.c(13.34 KB)
📄 print-null.c(4.01 KB)
📄 print-olsr.c(23.42 KB)
📄 print-openflow-1.0.c(76.63 KB)
📄 print-openflow.c(4.77 KB)
📄 print-ospf.c(39.49 KB)
📄 print-ospf6.c(29.86 KB)
📄 print-otv.c(2.1 KB)
📄 print-pflog.c(4.86 KB)
📄 print-pfsync.c(12.53 KB)
📄 print-pgm.c(22.17 KB)
📄 print-pim.c(32.59 KB)
📄 print-pktap.c(5.18 KB)
📄 print-ppi.c(2.68 KB)
📄 print-ppp.c(46.16 KB)
📄 print-pppoe.c(5.65 KB)
📄 print-pptp.c(25.9 KB)
📄 print-radius.c(35.1 KB)
📄 print-raw.c(1.52 KB)
📄 print-resp.c(16.5 KB)
📄 print-rip.c(9.19 KB)
📄 print-ripng.c(6 KB)
📄 print-rpki-rtr.c(10.83 KB)
📄 print-rrcp.c(4.56 KB)
📄 print-rsvp.c(78.61 KB)
📄 print-rt6.c(2.66 KB)
📄 print-rtsp.c(1.16 KB)
📄 print-rx.c(66.92 KB)
📄 print-sctp.c(23.13 KB)
📄 print-sflow.c(31.91 KB)
📄 print-sip.c(1.29 KB)
📄 print-sl.c(6.95 KB)
📄 print-sll.c(9.2 KB)
📄 print-slow.c(25.17 KB)
📄 print-smb.c(43.19 KB)
📄 print-smtp.c(983 B)
📄 print-snmp.c(43.17 KB)
📄 print-stp.c(17.18 KB)
📄 print-sunatm.c(3.27 KB)
📄 print-sunrpc.c(7.85 KB)
📄 print-symantec.c(3.78 KB)
📄 print-syslog.c(3.96 KB)
📄 print-tcp.c(35.84 KB)
📄 print-telnet.c(15.02 KB)
📄 print-tftp.c(5.2 KB)
📄 print-timed.c(4.74 KB)
📄 print-tipc.c(11.53 KB)
📄 print-token.c(7.96 KB)
📄 print-udld.c(5.47 KB)
📄 print-udp.c(21.28 KB)
📄 print-usb.c(4.18 KB)
📄 print-vjc.c(4.45 KB)
📄 print-vqp.c(6.8 KB)
📄 print-vrrp.c(6.37 KB)
📄 print-vtp.c(13.56 KB)
📄 print-vxlan-gpe.c(3.46 KB)
📄 print-vxlan.c(2.21 KB)
📄 print-wb.c(10.93 KB)
📄 print-zephyr.c(8.03 KB)
📄 print-zeromq.c(7.5 KB)
📄 print.c(11.54 KB)
📄 print.h(1.78 KB)
📄 rpc_auth.h(2.77 KB)
📄 rpc_msg.h(3.19 KB)
📄 rpl.h(4.88 KB)
📄 send-ack.awk(1.56 KB)
📄 setsignal.c(3.27 KB)
📄 setsignal.h(1.24 KB)
📄 signature.c(5.58 KB)
📄 signature.h(1.12 KB)
📄 slcompress.h(3.55 KB)
📄 smb.h(5.38 KB)
📄 smbutil.c(63.88 KB)
📄 stime.awk(567 B)
📄 strtoaddr.c(5.34 KB)
📄 strtoaddr.h(992 B)
📄 tcp.h(5.02 KB)
📄 tcpdump.1.in(60.82 KB)
📄 tcpdump.c(69.76 KB)
📄 timeval-operations.h(3.19 KB)
📄 udp.h(8.25 KB)
📄 util-print.c(23.75 KB)
📄 vfprintf.c(1.62 KB)

Editing: print-resp.c

/*
 * Copyright (c) 2015 The TCPDUMP project
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
 * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
 * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 *
 * Initial contribution by Andrew Darqui (andrew.darqui@gmail.com).
 */

/* \summary: REdis Serialization Protocol (RESP) printer */

#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

#include <netdissect-stdinc.h>
#include "netdissect.h"
#include <limits.h>
#include <string.h>
#include <stdlib.h>
#include <errno.h>

#include "extract.h"

static const char tstr[] = " [|RESP]";

/*
 * For information regarding RESP, see: http://redis.io/topics/protocol
 */

#define RESP_SIMPLE_STRING    '+'
#define RESP_ERROR            '-'
#define RESP_INTEGER          ':'
#define RESP_BULK_STRING      '$'
#define RESP_ARRAY            '*'

#define resp_print_empty(ndo)            ND_PRINT((ndo, " empty"))
#define resp_print_null(ndo)             ND_PRINT((ndo, " null"))
#define resp_print_length_too_large(ndo) ND_PRINT((ndo, " length too large"))
#define resp_print_length_negative(ndo)  ND_PRINT((ndo, " length negative and not -1"))
#define resp_print_invalid(ndo)          ND_PRINT((ndo, " invalid"))

void       resp_print(netdissect_options *, const u_char *, u_int);
static int resp_parse(netdissect_options *, register const u_char *, int);
static int resp_print_string_error_integer(netdissect_options *, register const u_char *, int);
static int resp_print_simple_string(netdissect_options *, register const u_char *, int);
static int resp_print_integer(netdissect_options *, register const u_char *, int);
static int resp_print_error(netdissect_options *, register const u_char *, int);
static int resp_print_bulk_string(netdissect_options *, register const u_char *, int);
static int resp_print_bulk_array(netdissect_options *, register const u_char *, int);
static int resp_print_inline(netdissect_options *, register const u_char *, int);
static int resp_get_length(netdissect_options *, register const u_char *, int, const u_char **);

#define LCHECK2(_tot_len, _len) \
    {                           \
        if (_tot_len < _len)    \
            goto trunc;         \
    }

#define LCHECK(_tot_len) LCHECK2(_tot_len, 1)

/*
 * FIND_CRLF:
 * Attempts to move our 'ptr' forward until a \r\n is found,
 * while also making sure we don't exceed the buffer '_len'
 * or go past the end of the captured data.
 * If we exceed or go past the end of the captured data,
 * jump to trunc.
 */
#define FIND_CRLF(_ptr, _len)                   \
    for (;;) {                                  \
        LCHECK2(_len, 2);                       \
        ND_TCHECK2(*_ptr, 2);                   \
        if (*_ptr == '\r' && *(_ptr+1) == '\n') \
            break;                              \
        _ptr++;                                 \
        _len--;                                 \
    }

/*
 * CONSUME_CRLF
 * Consume a CRLF that we've just found.
 */
#define CONSUME_CRLF(_ptr, _len) \
    _ptr += 2;                   \
    _len -= 2;

/*
 * FIND_CR_OR_LF
 * Attempts to move our '_ptr' forward until a \r or \n is found,
 * while also making sure we don't exceed the buffer '_len'
 * or go past the end of the captured data.
 * If we exceed or go past the end of the captured data,
 * jump to trunc.
 */
#define FIND_CR_OR_LF(_ptr, _len)           \
    for (;;) {                              \
        LCHECK(_len);                       \
        ND_TCHECK(*_ptr);                   \
        if (*_ptr == '\r' || *_ptr == '\n') \
            break;                          \
        _ptr++;                             \
        _len--;                             \
    }

/*
 * CONSUME_CR_OR_LF
 * Consume all consecutive \r and \n bytes.
 * If we exceed '_len' or go past the end of the captured data,
 * jump to trunc.
 */
#define CONSUME_CR_OR_LF(_ptr, _len)             \
    {                                            \
        int _found_cr_or_lf = 0;                 \
        for (;;) {                               \
            /*                                   \
             * Have we hit the end of data?      \
             */                                  \
            if (_len == 0 || !ND_TTEST(*_ptr)) { \
                /*                               \
                 * Yes.  Have we seen a \r       \
                 * or \n?                        \
                 */                              \
                if (_found_cr_or_lf) {           \
                    /*                           \
                     * Yes.  Just stop.          \
                     */                          \
                    break;                       \
                }                                \
                /*                               \
                 * No.  We ran out of packet.    \
                 */                              \
                goto trunc;                      \
            }                                    \
            if (*_ptr != '\r' && *_ptr != '\n')  \
                break;                           \
            _found_cr_or_lf = 1;                 \
            _ptr++;                              \
            _len--;                              \
        }                                        \
    }

/*
 * SKIP_OPCODE
 * Skip over the opcode character.
 * The opcode has already been fetched, so we know it's there, and don't
 * need to do any checks.
 */
#define SKIP_OPCODE(_ptr, _tot_len) \
    _ptr++;                         \
    _tot_len--;

/*
 * GET_LENGTH
 * Get a bulk string or array length.
 */
#define GET_LENGTH(_ndo, _tot_len, _ptr, _len)                \
    {                                                         \
        const u_char *_endp;                                  \
        _len = resp_get_length(_ndo, _ptr, _tot_len, &_endp); \
        _tot_len -= (_endp - _ptr);                           \
        _ptr = _endp;                                         \
    }

/*
 * TEST_RET_LEN
 * If ret_len is < 0, jump to the trunc tag which returns (-1)
 * and 'bubbles up' to printing tstr. Otherwise, return ret_len.
 */
#define TEST_RET_LEN(rl) \
    if (rl < 0) { goto trunc; } else { return rl; }

/*
 * TEST_RET_LEN_NORETURN
 * If ret_len is < 0, jump to the trunc tag which returns (-1)
 * and 'bubbles up' to printing tstr. Otherwise, continue onward.
 */
#define TEST_RET_LEN_NORETURN(rl) \
    if (rl < 0) { goto trunc; }

/*
 * RESP_PRINT_SEGMENT
 * Prints a segment in the form of: ' "<stuff>"\n"
 * Assumes the data has already been verified as present.
 */
#define RESP_PRINT_SEGMENT(_ndo, _bp, _len)            \
    ND_PRINT((_ndo, " \""));                           \
    if (fn_printn(_ndo, _bp, _len, _ndo->ndo_snapend)) \
        goto trunc;                                    \
    fn_print_char(_ndo, '"');

void
resp_print(netdissect_options *ndo, const u_char *bp, u_int length)
{
    int ret_len = 0, length_cur = length;

if(!bp || length <= 0)
        return;

ND_PRINT((ndo, ": RESP"));
    while (length_cur > 0) {
        /*
         * This block supports redis pipelining.
         * For example, multiple operations can be pipelined within the same string:
         * "*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"
         * or
         * "PING\r\nPING\r\nPING\r\n"
         * In order to handle this case, we must try and parse 'bp' until
         * 'length' bytes have been processed or we reach a trunc condition.
         */
        ret_len = resp_parse(ndo, bp, length_cur);
        TEST_RET_LEN_NORETURN(ret_len);
        bp += ret_len;
        length_cur -= ret_len;
    }

return;

trunc:
    ND_PRINT((ndo, "%s", tstr));
}

static int
resp_parse(netdissect_options *ndo, register const u_char *bp, int length)
{
    u_char op;
    int ret_len;

LCHECK2(length, 1);
    ND_TCHECK(*bp);
    op = *bp;

/* bp now points to the op, so these routines must skip it */
    switch(op) {
        case RESP_SIMPLE_STRING:  ret_len = resp_print_simple_string(ndo, bp, length);   break;
        case RESP_INTEGER:        ret_len = resp_print_integer(ndo, bp, length);         break;
        case RESP_ERROR:          ret_len = resp_print_error(ndo, bp, length);           break;
        case RESP_BULK_STRING:    ret_len = resp_print_bulk_string(ndo, bp, length);     break;
        case RESP_ARRAY:          ret_len = resp_print_bulk_array(ndo, bp, length);      break;
        default:                  ret_len = resp_print_inline(ndo, bp, length);          break;
    }

/*
     * This gives up with a "truncated" indicator for all errors,
     * including invalid packet errors; that's what we want, as
     * we have to give up on further parsing in that case.
     */
    TEST_RET_LEN(ret_len);

trunc:
    return (-1);
}

static int
resp_print_simple_string(netdissect_options *ndo, register const u_char *bp, int length) {
    return resp_print_string_error_integer(ndo, bp, length);
}

static int
resp_print_integer(netdissect_options *ndo, register const u_char *bp, int length) {
    return resp_print_string_error_integer(ndo, bp, length);
}

static int
resp_print_error(netdissect_options *ndo, register const u_char *bp, int length) {
    return resp_print_string_error_integer(ndo, bp, length);
}

static int
resp_print_string_error_integer(netdissect_options *ndo, register const u_char *bp, int length) {
    int length_cur = length, len, ret_len;
    const u_char *bp_ptr;

/* bp points to the op; skip it */
    SKIP_OPCODE(bp, length_cur);
    bp_ptr = bp;

/*
     * bp now prints past the (+-;) opcode, so it's pointing to the first
     * character of the string (which could be numeric).
     * +OK\r\n
     * -ERR ...\r\n
     * :02912309\r\n
     *
     * Find the \r\n with FIND_CRLF().
     */
    FIND_CRLF(bp_ptr, length_cur);

/*
     * bp_ptr points to the \r\n, so bp_ptr - bp is the length of text
     * preceding the \r\n.  That includes the opcode, so don't print
     * that.
     */
    len = (bp_ptr - bp);
    RESP_PRINT_SEGMENT(ndo, bp, len);
    ret_len = 1 /*<opcode>*/ + len /*<string>*/ + 2 /*<CRLF>*/;

TEST_RET_LEN(ret_len);

trunc:
    return (-1);
}

static int
resp_print_bulk_string(netdissect_options *ndo, register const u_char *bp, int length) {
    int length_cur = length, string_len;

/* bp points to the op; skip it */
    SKIP_OPCODE(bp, length_cur);

/* <length>\r\n */
    GET_LENGTH(ndo, length_cur, bp, string_len);

if (string_len >= 0) {
        /* Byte string of length string_len, starting at bp */
        if (string_len == 0)
            resp_print_empty(ndo);
        else {
            LCHECK2(length_cur, string_len);
            ND_TCHECK2(*bp, string_len);
            RESP_PRINT_SEGMENT(ndo, bp, string_len);
            bp += string_len;
            length_cur -= string_len;
        }

/*
         * Find the \r\n at the end of the string and skip past it.
         * XXX - report an error if the \r\n isn't immediately after
         * the item?
         */
        FIND_CRLF(bp, length_cur);
        CONSUME_CRLF(bp, length_cur);
    } else {
        /* null, truncated, or invalid for some reason */
        switch(string_len) {
            case (-1):  resp_print_null(ndo);             break;
            case (-2):  goto trunc;
            case (-3):  resp_print_length_too_large(ndo); break;
            case (-4):  resp_print_length_negative(ndo);  break;
            default:    resp_print_invalid(ndo);          break;
        }
    }

return (length - length_cur);

trunc:
    return (-1);
}

static int
resp_print_bulk_array(netdissect_options *ndo, register const u_char *bp, int length) {
    u_int length_cur = length;
    int array_len, i, ret_len;

/* bp points to the op; skip it */
    SKIP_OPCODE(bp, length_cur);

/* <array_length>\r\n */
    GET_LENGTH(ndo, length_cur, bp, array_len);

if (array_len > 0) {
        /* non empty array */
        for (i = 0; i < array_len; i++) {
            ret_len = resp_parse(ndo, bp, length_cur);

TEST_RET_LEN_NORETURN(ret_len);

bp += ret_len;
            length_cur -= ret_len;
        }
    } else {
        /* empty, null, truncated, or invalid */
        switch(array_len) {
            case 0:     resp_print_empty(ndo);            break;
            case (-1):  resp_print_null(ndo);             break;
            case (-2):  goto trunc;
            case (-3):  resp_print_length_too_large(ndo); break;
            case (-4):  resp_print_length_negative(ndo);  break;
            default:    resp_print_invalid(ndo);          break;
        }
    }

return (length - length_cur);

trunc:
    return (-1);
}

static int
resp_print_inline(netdissect_options *ndo, register const u_char *bp, int length) {
    int length_cur = length;
    int len;
    const u_char *bp_ptr;

/*
     * Inline commands are simply 'strings' followed by \r or \n or both.
     * Redis will do its best to split/parse these strings.
     * This feature of redis is implemented to support the ability of
     * command parsing from telnet/nc sessions etc.
     *
     * <string><\r||\n||\r\n...>
     */

/*
     * Skip forward past any leading \r, \n, or \r\n.
     */
    CONSUME_CR_OR_LF(bp, length_cur);
    bp_ptr = bp;

/*
     * Scan forward looking for \r or \n.
     */
    FIND_CR_OR_LF(bp_ptr, length_cur);

/*
     * Found it; bp_ptr points to the \r or \n, so bp_ptr - bp is the
     * Length of the line text that preceeds it.  Print it.
     */
    len = (bp_ptr - bp);
    RESP_PRINT_SEGMENT(ndo, bp, len);

/*
     * Skip forward past the \r, \n, or \r\n.
     */
    CONSUME_CR_OR_LF(bp_ptr, length_cur);

/*
     * Return the number of bytes we processed.
     */
    return (length - length_cur);

trunc:
    return (-1);
}

static int
resp_get_length(netdissect_options *ndo, register const u_char *bp, int len, const u_char **endp)
{
    int result;
    u_char c;
    int saw_digit;
    int neg;
    int too_large;

if (len == 0)
        goto trunc;
    ND_TCHECK(*bp);
    too_large = 0;
    neg = 0;
    if (*bp == '-') {
        neg = 1;
        bp++;
        len--;
    }
    result = 0;
    saw_digit = 0;

for (;;) {
        if (len == 0)
            goto trunc;
        ND_TCHECK(*bp);
        c = *bp;
        if (!(c >= '0' && c <= '9')) {
            if (!saw_digit) {
                bp++;
                goto invalid;
            }
            break;
        }
        c -= '0';
        if (result > (INT_MAX / 10)) {
            /* This will overflow an int when we multiply it by 10. */
            too_large = 1;
        } else {
            result *= 10;
            if (result == ((INT_MAX / 10) * 10) && c > (INT_MAX % 10)) {
                /* This will overflow an int when we add c */
                too_large = 1;
            } else
                result += c;
        }
        bp++;
        len--;
        saw_digit = 1;
    }

/*
     * OK, we found a non-digit character.  It should be a \r, followed
     * by a \n.
     */
    if (*bp != '\r') {
        bp++;
        goto invalid;
    }
    bp++;
    len--;
    if (len == 0)
        goto trunc;
    ND_TCHECK(*bp);
    if (*bp != '\n') {
        bp++;
        goto invalid;
    }
    bp++;
    len--;
    *endp = bp;
    if (neg) {
        /* -1 means "null", anything else is invalid */
        if (too_large || result != 1)
            return (-4);
        result = -1;
    }
    return (too_large ? -3 : result);

trunc:
    *endp = bp;
    return (-2);

invalid:
    *endp = bp;
    return (-5);
}

003 File Manager

Editing: print-resp.c

Upload File

Create Folder