tools/gdb-helpers.py

#
# Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements.  See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership.  The ASF licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not use this file except in compliance
# with the License.  You may obtain a copy of the License at
##
# http://www.apache.org/licenses/LICENSE-2.0
##
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

#
# This script will add a command to help print out ATS data structures in gdb.
#
# In a .gdbinit file or from the gdb command prompt:
#   source <path to this file>.py
#
# Then you can type:  `atspr sm this`  Where this is a HttpSM* and it will print some information about it.
#
#  For the expression you should be able to put anything that can be cast to the appropriate type.
#
# Type `atspr` by itself for a list of printables.
#

import gdb
import socket
import struct
from curses.ascii import isgraph

# return memory for an ats string address and length


def ats_str(addr, addr_len):
    if addr_len == 0:
        return ''
    #print("addr {} len {}".format(addr, addr_len))
    inferior = gdb.selected_inferior()
    try:
        buff = inferior.read_memory(addr, addr_len)
        if buff[0] == '\x00':
            return 'null'
        else:
            return buff
    except BaseException:
        return 'unreadable({:x})'.format(int(addr))


def hdrtoken(idx):
    hdrtokens = gdb.parse_and_eval('hdrtoken_strs')
    return hdrtokens[idx].string()


def wks_or_str(idx, addr, addr_len):
    if idx >= 0:
        return hdrtoken(idx)
    else:
        return ats_str(addr, addr_len)


class URL:

    def __init__(self, val):
        self.impl = val['m_url_impl'].dereference()

    def __str__(self):
        return "{}://{}/{}".format(self.scheme(), self.host(), self.path())

    def scheme(self):
        return ats_str(self.impl['m_ptr_scheme'], self.impl['m_len_scheme'])

    def host(self):
        return ats_str(self.impl['m_ptr_host'], self.impl['m_len_host'])

    def path(self):
        return ats_str(self.impl['m_ptr_path'], self.impl['m_len_path'])


class HTTPHdr:

    def __init__(self, val):
        self.impl = val['m_http']
        self.val = val

    def url(self):
        return URL(self.val['m_url_cached'])

    def is_request(self):
        pol = self.impl['m_polarity']
        return pol == 1

    def is_response(self):
        pol = self.impl['m_polarity']
        return pol == 2

    def is_valid(self):
        if self.impl == 0:
            return None
        pol = self.impl['m_polarity']
        return pol > 0

    def method(self):
        idx = self.impl['u']['req']['m_method_wks_idx']
        if idx >= 0:
            return hdrtoken(idx)
        else:
            return ats_str(self.impl['u']['req']['m_ptr_method'], self.impl['u']['req']['m_len_method'])

    def status(self):
        return self.impl['u']['resp']['m_status']

    def headers(self):
        mime = self.val['m_mime'].dereference()
        fblock_ptr = mime['m_first_fblock'].address
        while fblock_ptr != 0:
            fblock = fblock_ptr.dereference()
            slots = fblock['m_field_slots']
            #print("slots type {} address {} size {}".format(slots.type, slots.address, slots.type.sizeof))
            #print("next idx {} len {} next {}".format(fblock['m_freetop'], fblock['m_length'], fblock['m_next']))

            for slot_idx in range(fblock['m_freetop']):
                fld = slots[slot_idx]
                wks = fld['m_wks_idx']
                name = wks_or_str(wks, fld['m_ptr_name'], fld['m_len_name'])
                yield (name, ats_str(fld['m_ptr_value'], fld['m_len_value']))

            fblock_ptr = fblock['m_next']

    def pr(self):
        if self.is_valid():
            if self.is_request():
                print("{} {}".format(self.method(), self.url()))
            if self.is_response():
                print("status: {}".format(self.status()))
            for key, val in self.headers():
                print("{}: {}".format(key, val))
        else:
            print("invalid")


class ConnectionAttributes:

    def __init__(self, val):
        self.val = val

    def http_version(self):
        v = self.val['http_version']['m_version']
        return (v >> 16, v & 0xffff)

    def src_addr(self):
        ip = self.val['src_addr']
        s = struct.pack('!I', socket.ntohl(int(ip['sin']['sin_addr']['s_addr'])))
        return socket.inet_ntoa(s)

    def dst_addr(self):
        ip = self.val['dst_addr']
        s = struct.pack('!I', socket.ntohl(int(ip['sin']['sin_addr']['s_addr'])))
        return socket.inet_ntoa(s)


class HttpSM:

    def __init__(self, val):
        ptr_type = gdb.lookup_type('struct HttpSM').pointer()
        self.val = None

        if val.type != ptr_type:
            self.val = val.cast(ptr_type)
        else:
            self.val = val

    def id(self):
        return self.val['sm_id']

    def client_request(self):
        return HTTPHdr(self.val['t_state']['hdr_info']['client_request'])

    def client_response(self):
        return HTTPHdr(self.val['t_state']['hdr_info']['client_response'])

    def server_request(self):
        return HTTPHdr(self.val['t_state']['hdr_info']['server_request'])

    def server_response(self):
        return HTTPHdr(self.val['t_state']['hdr_info']['server_response'])

    def transform_response(self):
        return HTTPHdr(self.val['t_state']['hdr_info']['transform_response'])

    def cache_response(self):
        return HTTPHdr(self.val['t_state']['hdr_info']['cache_response'])

    def client_info(self):
        return ConnectionAttributes(self.val['t_state']['client_info'])

    def parent_info(self):
        return ConnectionAttributes(self.val['t_state']['client_info'])

    def server_info(self):
        return ConnectionAttributes(self.val['t_state']['client_info'])


def sm_command(val):
    sm = HttpSM(val)

    print('smid = %s' % sm.id())
    print('---- request ----')
    sm.client_request().pr()
    print('---- response ----')
    sm.client_response().pr()
    print('---- server_request  ----')
    sm.server_request().pr()
    print('---- server_response  ----')
    sm.server_response().pr()
    print('---- transform_response  ----')
    sm.transform_response().pr()
    print('---- cache_response  ----')
    sm.cache_response().pr()
    print('---- client_info  ----')
    info = sm.client_info()
    major, minor = info.http_version()
    print("HTTP {}.{} ({} -> {})".format(major, minor, info.src_addr(), info.dst_addr()))
    print('---- server_info  ----')
    info = sm.server_info()
    major, minor = info.http_version()
    print("HTTP {}.{} ({} -> {})".format(major, minor, info.src_addr(), info.dst_addr()))
    print('---- parent_info  ----')
    info = sm.parent_info()
    major, minor = info.http_version()
    print("HTTP {}.{} ({} -> {})".format(major, minor, info.src_addr(), info.dst_addr()))


def hdrs_command(val):
    HTTPHdr(val).pr()


def url_command(val):
    print(URL(val))


commands = [
    ("sm", sm_command, "Print HttpSM details (type HttpSM*)"),
    ("hdrs", hdrs_command, "Print HttpHdr details (type HTTPHdr)"),
    ("url", url_command, "Print URL"),
]


def usage():
    print("Usage: atspr <command> <expr>")
    print("commands:")
    for cmd, f, desc in commands:
        print("  {}: {}".format(cmd, desc))


class ATSPrintCommand(gdb.Command):

    def __init__(self):
        super(ATSPrintCommand, self).__init__('atspr', gdb.COMMAND_DATA)

    def invoke(self, arg, from_tty):
        argv = gdb.string_to_argv(arg)
        if len(argv) < 2:
            usage()
            return

        what = argv[0]
        expr = argv[1]
        val = gdb.parse_and_eval(expr)

        for cmd, f, _ in commands:
            if cmd == what:
                f(val)
                return

        usage()


ATSPrintCommand()

# vim: tabstop=4 expandtab shiftwidth=4 softtabstop=4