opensipscli 0.3.1__py3-none-any.whl

opensipscli/modules/trace.py

@@ -0,0 +1,292 @@
+#!/usr/bin/env python
+##
+## This file is part of OpenSIPS CLI
+## (see https://github.com/OpenSIPS/opensips-cli).
+##
+## This program is free software: you can redistribute it and/or modify
+## it under the terms of the GNU General Public License as published by
+## the Free Software Foundation, either version 3 of the License, or
+## (at your option) any later version.
+##
+## This program is distributed in the hope that it will be useful,
+## but WITHOUT ANY WARRANTY; without even the implied warranty of
+## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+## GNU General Public License for more details.
+##
+## You should have received a copy of the GNU General Public License
+## along with this program. If not, see <http://www.gnu.org/licenses/>.
+##
+
+from datetime import datetime
+from time import time
+import random
+import socket
+from opensipscli import comm
+from opensipscli.config import cfg
+from opensipscli.logger import logger
+from opensipscli.module import Module
+
+TRACE_BUFFER_SIZE = 65535
+
+'''
+find out more information here:
+* https://github.com/sipcapture/HEP/blob/master/docs/HEP3NetworkProtocolSpecification_REV26.pdf
+'''
+
+protocol_types = {
+    0x00: "UNKNOWN",
+    0x01: "SIP",
+    0x02: "XMPP",
+    0x03: "SDP",
+    0x04: "RTP",
+    0x05: "RTCP JSON",
+    0x56: "LOG",
+    0x57: "MI",
+    0x58: "REST",
+    0x59: "NET",
+    0x60: "CONTROL",
+}
+
+protocol_ids = {
+    num:name[8:] for name,num in vars(socket).items() if name.startswith("IPPROTO")
+}
+
+class HEPpacketException(Exception):
+    pass
+
+class HEPpacket(object):
+
+    def __init__(self, payloads):
+        self.payloads = payloads
+        self.family = socket.AF_INET
+        self.protocol = "UNKNOWN"
+        self.src_addr = None
+        self.dst_addr = None
+        self.src_port = None
+        self.dst_port = None
+        self.data = None
+        self.correlation = None
+        self.ts = time()
+        self.tms = datetime.now().microsecond
+
+    def __str__(self):
+        time_str = "{}.{}".format(
+                self.ts,
+                self.tms)
+        protocol_str = " {}/{}".format(
+                self.protocol,
+                self.type)
+
+        if self.type == "SIP":
+            ip_str = " {}:{} -> {}:{}".format(
+                socket.inet_ntop(self.family, self.src_addr),
+                self.src_port,
+                socket.inet_ntop(self.family, self.dst_addr),
+                self.dst_port)
+        else:
+            ip_str = ""
+        if self.data:
+            data_str = self.data.decode()
+        else:
+            data_str = ""
+
+        return logger.color(logger.BLUE, time_str) + \
+                logger.color(logger.CYAN, protocol_str + ip_str) + \
+                "\n" + data_str
+
+    def parse(self):
+        length = len(self.payloads)
+        payloads = self.payloads
+        while length > 0:
+            if length < 6:
+                logger.error("payload too small {}".format(length))
+                return None
+            chunk_vendor_id = int.from_bytes(payloads[0:2],
+                    byteorder="big", signed=False)
+            chunk_type_id = int.from_bytes(payloads[2:4],
+                    byteorder="big", signed=False)
+            chunk_len = int.from_bytes(payloads[4:6],
+                    byteorder="big", signed=False)
+            if chunk_len < 6:
+                logger.error("chunk too small {}".format(chunk_len))
+                return None
+            payload = payloads[6:chunk_len]
+            payloads = payloads[chunk_len:]
+            length = length - chunk_len
+            self.push_chunk(chunk_vendor_id, chunk_type_id, payload)
+
+    def push_chunk(self, vendor_id, type_id, payload):
+
+        if vendor_id != 0:
+            logger.warning("Unknown vendor id {}".format(vendor_id))
+            raise HEPpacketException
+        if type_id == 0x0001:
+            if len(payload) != 1:
+                raise HEPpacketException
+            self.family = payload[0]
+        elif type_id == 0x0002:
+            if len(payload) != 1:
+                raise HEPpacketException
+            if not payload[0] in protocol_ids:
+                self.protocol = str(payload[0])
+            else:
+                self.protocol = protocol_ids[payload[0]]
+        elif type_id >= 0x0003 and type_id <= 0x0006:
+            expected_payload_len = 4 if type_id <= 0x0004 else 16
+            if len(payload) != expected_payload_len:
+                raise HEPpacketException
+            if type_id == 0x0003 or type_id == 0x0005:
+                self.src_addr = payload
+            else:
+                self.dst_addr = payload
+        elif type_id == 0x0007 or type_id == 0x0008:
+            if len(payload) != 2:
+                raise HEPpacketException
+            port = int.from_bytes(payload,
+                        byteorder="big", signed=False)
+            if type_id == 7:
+                self.src_port = port
+            else:
+                self.dst_port = port
+        elif type_id == 0x0009 or type_id == 0x000a:
+            if len(payload) != 4:
+                raise HEPpacketException
+            timespec = int.from_bytes(payload,
+                        byteorder="big", signed=False)
+            if type_id == 0x0009:
+                self.ts = timespec
+            else:
+                self.tms = timespec
+        elif type_id == 0x000b:
+            if len(payload) != 1:
+                raise HEPpacketException
+            if not payload[0] in protocol_types:
+                self.type = str(payload[0])
+            else:
+                self.type = protocol_types[payload[0]]
+        elif type_id == 0x000c:
+            pass # capture id not used now
+        elif type_id == 0x000f:
+            self.data = payload
+        elif type_id == 0x0011:
+            self.correlation = payload
+        else:
+            logger.warning("unhandled payload type {}".format(type_id))
+
+class trace(Module):
+
+    def __print_hep(self, packet):
+        # this works as a HEP parser
+        logger.debug("initial packet size is {}".format(len(packet)))
+
+        while len(packet) > 0:
+            if len(packet) < 4:
+                return packet
+            # currently only HEPv3 is accepted
+            if packet[0:4] != b'HEP3':
+                logger.warning("packet not HEPv3: [{}]".format(packet[0:4]))
+                return None
+            length = int.from_bytes(packet[4:6], byteorder="big", signed=False)
+            if length > len(packet):
+                logger.debug("partial packet: {} out of {}".
+                        format(len(packet), length))
+                # wait for entire packet to parse it
+                return packet
+            logger.debug("packet size is {}".format(length))
+            # skip the header
+            hep_packet = HEPpacket(packet[6:length])
+            try:
+                hep_packet.parse()
+            except HEPpacketException:
+                return None
+            packet = packet[length:]
+            print(hep_packet)
+
+        return packet
+
+    def __complete__(self, command, text, line, begidx, endidx):
+        filters = [ "caller", "callee", "ip" ]
+
+        # remove the filters already used
+        filters = [f for f in filters if line.find(f + "=") == -1]
+        if not command:
+            return filters
+
+        if (not text or text == "") and line[-1] == "=":
+            return [""]
+
+        ret = [f for f in filters if (f.startswith(text) and line.find(f + "=") == -1)]
+        if len(ret) == 1 :
+            ret[0] = ret[0] + "="
+        return ret
+
+    def __get_methods__(self):
+        return None
+
+    def do_trace(self, params, modifiers):
+
+        filters = []
+
+        if params is None:
+            caller_f = input("Caller filter: ")
+            if caller_f != "":
+                filters.append("caller={}".format(caller_f))
+            callee_f = input("Callee filter: ")
+            if callee_f != "":
+                filters.append("callee={}".format(callee_f))
+            ip_f = input("Source IP filter: ")
+            if ip_f != "":
+                filters.append("ip={}".format(ip_f))
+            if len(filters) == 0:
+                ans = cfg.read_param(None, "No filter specified! "\
+                        "Continue without a filter?", False, True)
+                if not ans:
+                    return False
+                filters = None
+        else:
+            filters = params
+
+        s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+        s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+        trace_ip = cfg.get("trace_listen_ip")
+        trace_port = int(cfg.get("trace_listen_port"))
+        s.bind((trace_ip, trace_port))
+        if trace_port == 0:
+            trace_port = s.getsockname()[1]
+        s.listen(1)
+        conn = None
+        trace_name = "opensips-cli.{}".format(random.randint(0, 65536))
+        trace_socket = "hep:{}:{};transport=tcp;version=3".format(
+                trace_ip, trace_port)
+        args = {
+            'id': trace_name,
+            'uri': trace_socket,
+        }
+        if filters:
+            args['filter'] = filters
+
+        logger.debug("filters are {}".format(filters))
+        trace_started = comm.execute('trace_start', args)
+        if not trace_started:
+            return False
+
+        try:
+            conn, addr = s.accept()
+            logger.debug("New TCP connection from {}:{}".
+                    format(addr[0], addr[1]))
+            remaining = b''
+            while True:
+                data = conn.recv(TRACE_BUFFER_SIZE)
+                if not data:
+                    break
+                remaining = self.__print_hep(remaining + data)
+                if remaining is None:
+                    break
+        except KeyboardInterrupt:
+            comm.execute('trace_stop', {'id' : trace_name }, True)
+            if conn is not None:
+                conn.close()
+
+    def __exclude__(self):
+        valid = comm.valid()
+        return (not valid[0], valid[1])

opensipscli/modules/trap.py

@@ -0,0 +1,138 @@
+#!/usr/bin/env python
+##
+## This file is part of OpenSIPS CLI
+## (see https://github.com/OpenSIPS/opensips-cli).
+##
+## This program is free software: you can redistribute it and/or modify
+## it under the terms of the GNU General Public License as published by
+## the Free Software Foundation, either version 3 of the License, or
+## (at your option) any later version.
+##
+## This program is distributed in the hope that it will be useful,
+## but WITHOUT ANY WARRANTY; without even the implied warranty of
+## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+## GNU General Public License for more details.
+##
+## You should have received a copy of the GNU General Public License
+## along with this program. If not, see <http://www.gnu.org/licenses/>.
+##
+
+from opensipscli.module import Module
+from opensipscli.logger import logger
+from opensipscli.config import cfg
+from opensipscli import comm
+from threading import Thread
+import subprocess
+import shutil
+import os
+
+DEFAULT_PROCESS_NAME = 'opensips'
+
+class trap(Module):
+
+    def get_process_name(self):
+        if cfg.exists("process_name"):
+            return cfg.get("process_name")
+        else:
+            return DEFAULT_PROCESS_NAME
+
+    def get_pids(self):
+        try:
+            mi_pids = comm.execute('ps')
+            self.pids = [str(pid['PID']) for pid in mi_pids['Processes']]
+            info = ["Process ID={} PID={} Type={}".
+                format(pid['ID'], pid['PID'], pid['Type'])
+                for pid in mi_pids['Processes']]
+            self.process_info = "\n".join(info)
+        except:
+            self.pids = []
+
+    def get_gdb_output(self, pid):
+        if os.path.islink("/proc/{}/exe".format(pid)):
+            # get process line of pid
+            process = os.readlink("/proc/{}/exe".format(pid))
+        else:
+            logger.error("could not find OpenSIPS process {} running on local machine".format(pid))
+            return -1
+        # Check if process is opensips (can be different if CLI is running on another host)
+        path, filename = os.path.split(process)
+        process_name = self.get_process_name()
+        if filename != process_name:
+            logger.error("process ID {}/{} is not OpenSIPS process".format(pid, filename))
+            return -1
+        logger.debug("Dumping backtrace for {} pid {}".format(process, pid))
+        cmd = ["gdb", process, pid, "-batch", "--eval-command", "bt full"]
+        out = subprocess.check_output(cmd)
+        if len(out) != 0:
+            self.gdb_outputs[pid] = out.decode()
+
+    def do_trap(self, params, modifiers):
+
+        self.pids = []
+        self.gdb_outputs = {}
+        self.process_info = ""
+
+        trap_file = cfg.get("trap_file")
+        process_name = self.get_process_name()
+
+        logger.info("Trapping {} in {}".format(process_name, trap_file))
+        if params and len(params) > 0:
+            self.pids = params
+        else:
+            thread = Thread(target=self.get_pids)
+            thread.start()
+            thread.join(timeout=1)
+            if len(self.pids) == 0:
+                logger.warning("could not get OpenSIPS pids through MI!")
+                try:
+                    ps_pids = subprocess.check_output(["pidof", process_name])
+                    self.pids = ps_pids.decode().split()
+                except:
+                    logger.warning("could not find any OpenSIPS running!")
+                    self.pids = []
+
+        if len(self.pids) < 1:
+            logger.error("could not find OpenSIPS' pids")
+            return -1
+
+        logger.debug("Dumping PIDs: {}".format(", ".join(self.pids)))
+
+        threads = []
+        for pid in self.pids:
+            thread = Thread(target=self.get_gdb_output, args=(pid,))
+            thread.start()
+            threads.append(thread)
+
+        for thread in threads:
+            thread.join()
+
+        if len(self.gdb_outputs) == 0:
+            logger.error("could not get output of gdb")
+            return -1
+
+        with open(trap_file, "w") as tf:
+            tf.write(self.process_info)
+            for pid in self.pids:
+                if pid not in self.gdb_outputs:
+                    logger.warning("No output from pid {}".format(pid))
+                    continue
+                try:
+                    procinfo = subprocess.check_output(
+                        ["ps", "--no-headers", "-ww", "-fp", pid]).decode()[:-1]
+                except:
+                    procinfo = "UNKNOWN"
+
+                tf.write("\n\n---start {} ({})\n{}".
+                        format(pid, procinfo, self.gdb_outputs[pid]))
+
+        print("Trap file: {}".format(trap_file))
+
+    def __get_methods__(self):
+        return None
+
+    def __exclude__(self):
+        valid = comm.valid()
+        if not valid[0]:
+            return False, valid[1]
+        # check to see if we have gdb installed
+        return (shutil.which("gdb") is None, None)