Esempio n. 1
0
def test3():
    sys.path.append('../')
    from hexdump import dump
    data, params = load('test.wav')
    print dump(data)
    enc = speex.Encoder()
    spx_data = enc.encode(data)
    print dump(spx_data)
Esempio n. 2
0
 def rx(self, xbeedev, srcaddr, data):
     self.last_activity = datetime.datetime.now()        
     logging.debug("RX [{:x}<-{:x}]: {} -- {}".format(self.xbee.address,
                                                         srcaddr,
                                                  data, 
                                                  hexdump.dump(data)))
     
     if data[0:1] in self.have_response:
         self.have_response[data[0:1]]['rsp'] = (srcaddr, data)
         self.have_response[data[0:1]]['e'].set()                   
     elif data[0:1] == xTP.HELLO:
         self.remote = srcaddr
         self.have_remote.set()    
     elif data[0:1] == xTP.SEND32_BEGIN:
         self.begin_transfer.set()
     elif data[0:1] == xTP.SEND32_ACKS:
         l = struct.unpack(">L", data[1:5])[0]
         self.acks = bitarray()            
         self.acks.setall(0)
         self.acks.frombytes(data[5:])
         # mark extra bits as received so all() works
         for z in range(l, len(self.acks)):
             self.acks[z] = True
         logging.debug("mask is [{}]: {}".format( l, self.acks ))
         
         self.have_acks.set()
     else:
         logging.warn("RX -- unknown message format ({:x})".format(data[0]))        
Esempio n. 3
0
def advance_dump(data, base):
    PY3K = sys.version_info >= (3, 0)
    generator = hexdump.genchunks(data, 16)
    retstr = ''
    for addr, d in enumerate(generator):
        # 00000000:
        line = '%08X: ' % (base + addr * 16)
        # 00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00
        dumpstr = hexdump.dump(d)
        line += dumpstr[:8 * 3]
        if len(d) > 8:  # insert separator if needed
            line += ' ' + dumpstr[8 * 3:]
        # ................
        # calculate indentation, which may be different for the last line
        pad = 2
        if len(d) < 16:
            pad += 3 * (16 - len(d))
        if len(d) <= 8:
            pad += 1
        line += ' ' * pad

        for byte in d:
            # printable ASCII range 0x20 to 0x7E
            if not PY3K:
                byte = ord(byte)
            if 0x20 <= byte <= 0x7E:
                line += chr(byte)
            else:
                line += '.'
        retstr += line + '\n'
    return retstr
Esempio n. 4
0
    def _send_packet(self, data, recipient=1):
        """
        according to the documentation:

        |------packet (3-16 bytes)---------|

         header     message      terminator
         (1 byte)  (1-14 bytes)  (1 byte)

        | X | X . . . . .  . . . . . X | X |

        header:                  terminator:
        1 s2 s1 s0 0 r2 r1 r0     0xff

        with r,s = recipient, sender msb first

        for broadcast the header is 0x88!

        we use -1 as recipient to send a broadcast!
        """
        # we are the controller with id=0
        sender = 0
        if recipient == -1:
            #broadcast:
            rbits = 0x8
        else:
            # the recipient (address = 3 bits)
            rbits = recipient & 0b111

        sbits = (sender & 0b111) << 4
        header = 0b10000000 | sbits | rbits
        terminator = 0xff
        packet = chr(header) + data + chr(terminator)
        logging.debug("Send: %s", hexdump.dump(packet))
        self.serial.mutex.acquire()
        self.serial._write_packet(packet)
        reply = self.serial.recv_packet()
        logging.debug("Received: %s", hexdump.dump(reply))
        if reply:
            if reply[-1:] != '\xff':
                logging.debug("received packet not terminated correctly: %s",
                              reply.encode('hex'))
                reply = None
            self.serial.mutex.release()
            return reply
        else:
            return None
Esempio n. 5
0
def read_idn(stream) -> hex:
    """Read an identifier of a chunk.

    An identifier is an unsigned short integer.
    """
    b = stream.read(SHORT_S)
    print(pad(), hexdump.dump(b))
    return hex(unpack('H', b)[0])
Esempio n. 6
0
def main():
    while True:
        print('## Iniciando ciclo de testes... ##')
        for k, v in tests.items():
            cmd = (*v, calcSum(v), int(0x16))
            ser.write(cmd)
            ser.flushInput()
            print('Enviei[t_{0}]: {1}'.format(k, dump(bytearray(cmd))))
            if v[-1] == 0x54:
                rcv = ser.read(9)
            else:
                rcv = ser.read(7)

            print('Recebi:         ' + dump(rcv))
            sleep(3)
        print('---')
        print()
Esempio n. 7
0
def get_samples(
):  #collect abt 1000 samples for each channel for rate at 200k samples and
    #axis distance of 15 cm
    samples_count = 0
    samples_x_tx_sensor = []
    samples_x_rx_sensor = []
    temp1 = 0
    temp2 = 0
    while (samples_count < 800):
        temp1 = zmq_sample_subscriber_ch1.recv()
        temp1 = hx.dump(temp1[::-1], size=4, sep=' ')
        samples_x_tx_sensor.append(int(temp1, 16))
        temp2 = zmq_sample_subscriber_ch2.recv()
        temp2 = hx.dump(temp2[::-1], size=4, sep=' ')
        samples_x_rx_sensor.append(int(temp2, 16))
        samples_count = samples_count + 1
    return samples_x_rx_sensor, samples_x_tx_sensor
Esempio n. 8
0
def dump(byts,hdr="",indent="",string=False):
    if hdr:
        s="%s%s\n" % (indent,hdr)
    else:
        s=""
    s="%s%s\n" % (s,hexdump.dump(byts,indent=indent))
    if string:
        return s
    print(s)
Esempio n. 9
0
def outout_data(data, output, show_addresses=False):
    if output:
        output.write(data)
        print('Saved {} bytes to {}'.format(output.tell(), output.name))
        output.close()
    else:
        if show_addresses:
            hexdump.hexdump(data)
        else:
            print(hexdump.dump(data))
Esempio n. 10
0
def handleAttr(attr_name, attr_val):

    if ("com.apple.lastuseddate#PS" in attr_name):

        # Convert hexdump to timestamp
        ret = hexdump.dump(attr_val)
        ret = ret.replace(" ", "")
        ret = ret[:8]
        ret = "".join(reversed([ret[i:i + 2] for i in range(0, len(ret), 2)]))
        ret = float.fromhex(ret)
        ret = time.localtime(ret)
        ret = time.strftime('%Y-%m-%d %H:%M:%S', ret)
        return ret

    elif ("com.apple.quarantine" in attr_name):
        t = attr_val[5:13]
        t = float.fromhex(t)
        t = time.localtime(t)

        ret = attr_val[:5] + time.strftime("%Y-%m-%d %H:%M:%S",
                                           t) + attr_val[13:]
        return ret

    elif ("com.apple.diskimages.fsck" in attr_name):
        ret = hexdump.dump(attr_val)

    elif ("com.apple.metadata:com_apple_mail_dateReceived" in attr_name):
        ret = hexdump.dump(attr_val)

    elif ("com.apple.metadata:com_apple_mail_dateSent" in attr_name):
        ret = hexdump.dump(attr_val)

    elif ("com.apple.metadata:com_apple_mail_isRemoteAttachment" in attr_name):
        ret = hexdump.dump(attr_val)

    elif ("metadata" in attr_name):
        ret = sanitize(attr_val)

    else:
        ret = sanitize(attr_val)

    return ret
def get_hexdump_output(exe_file_path):
    exe_file = open(exe_file_path, "rb")
    exe_file_bytes = hexdump.dump(exe_file.read())
    ans = ""
    splitted = exe_file_bytes.split()
    i = 0
    while i < len(splitted) - 16:
        ans += ' '.join(splitted[i:i + 16]) + "\n"
        i += 16
    exe_file.close()
    with open(exe_file_path + "exe_hexdump.bytes", "w") as exe_hexdump:
        exe_hexdump.write(ans)
Esempio n. 12
0
def getAppLayerClassification(data):
    if (data[0] != '\x20'):
        return "Unknown protocol version!"
    service = ord(data[1])
    if (SERVICE_CLASSIFIER.has_key(service)):
        command = bytesToCommandNumber(data[2:4])
        if SERVICE_CLASSIFIER[service].has_key(command):
            return SERVICE_CLASSIFIER[service][command]
        else:
            return "Unknown command: " + hexdump.dump(data[2:4])
    else:
        return "Unknown service id"
Esempio n. 13
0
    def onMessage(self, payload, isBinary):
       # received = None;

        if isBinary:
            print("Binary message received from client: {0} bytes: ".format(len(payload)) + hexdump.dump(payload, sep=" "))
            
            try:
                if payload[0] == 0x10:
                    received = updateMotors(payload[1], payload[2], payload[3], payload[4])
                elif payload[0] == 0x30:
                    received = readBatteryVoltage()
                elif payload[0] == 0x40:
                    #f = os.popen('iw wlan1 station dump | grep "signal avg" | grep -ohP "signal avg:\t-[0-9]*" | grep -ohP "[0-9]*" | tail -1')
                    #signal = f.read()
                    #signal = signal[:len(signal)-1]
                    signal = link_quality.link_quality_var
                    received = [0x41, int(signal)]
                elif payload[0] == 0x50:
                    f = os.popen('v4l2-ctl --set-ctrl brightness=' + str(np.int8(payload[1])) + ' --set-ctrl contrast=' + str(np.int8(payload[2])) + ' --set-ctrl saturation=' + str(np.uint8(payload[3])) + \
                    ' --set-ctrl hue=' + str(np.int8(payload[4])) + ' --set-ctrl gamma=' + str( np.uint16((np.uint8(payload[5]) << 8) + np.uint(payload[6])) ) + ' --set-ctrl gain=' + str(np.uint8(payload[7])) + \
                    ' --set-ctrl sharpness=' + str(np.uint8(payload[8])) )
                    received = [0x51]
                elif payload[0] == 0x60:
                    f = os.popen('vcgencmd measure_temp | grep -ohP "=[0-9]*" | cut -c 2-')
                    temperature = f.read()
                    temperature = temperature[:len(temperature)-1]
                    received = [0x61, int(temperature)]
                elif payload[0] == 0x84:
                    setNewManiPosition(payload[1], payload[2], payload[3], payload[4])
                    #   add CRC
                    received = [0x85, 0x00]
                elif payload[0] == 0x94:
                    setNewGripperPosition(payload[1], payload[2])
                    #   add CRC
                    received = [0x95, 0x00]
                elif payload[0] == 0xA4:
                    setNewCameraPosition(payload[1], payload[2])
                    received = [0xA5, 0x00]

                print("Received from Motor Module: " + hexdump.dump(bytes(received), sep=" "))
            except OSError:
                received = None
                print("Communication error has occured")

        else:
            print("Text message received: {0}".format(payload.decode('utf8')))
        
        # echo back message verbatim
        if received != None:
            self.sendMessage(bytes(received), True)
        else:
            self.sendMessage(bytes(0x00), False)
Esempio n. 14
0
def get_hexdump_output(exe_file_path):
    time.sleep(1)
    exe_file = open(exe_file_path, "rb")
    exe_file_bytes = hexdump.dump(exe_file.read())
    ans = ""
    splitted = exe_file_bytes.split()
    i = 0
    while i < len(splitted) - 16:
        ans += ' '.join(splitted[i:i + 16]) + "\n"
        i += 16
    exe_file.close()
    with open('bytes_from_exe.bytes', "w") as exe_hexdump:
        exe_hexdump.write(ans)
    return 'bytes_from_exe.bytes'
Esempio n. 15
0
def test(loops=10, key_len=32):
    """ local tests """
    print("ARC4 test")
    plaintext_org = str(23.5)

    for index in range(0, loops):
        encround = MQTTARC4("TTKS0600", key_len)
        start = time()
        ciphertext = encround.encrypt(plaintext_org)

        print("Encrypted " + " " + str(len(ciphertext)) + " in " +
              str(round((time() - start), 5)) + "\t" +
              hexdump.dump(ciphertext, size=2, sep=' '))
        start = time()
        plaintext = encround.decrypt(ciphertext)
        print("Decrypted " + " " + str(len(plaintext)) + " in " +
              str(round((time() - start), 5)) + "\t" +
              hexdump.dump(plaintext.encode(), size=2, sep=' '))
        if plaintext != plaintext_org:
            print("FAILED")
            print("\t" + str(plaintext_org))
            print("\t" + str(plaintext))
        index = index
Esempio n. 16
0
    def send(self, data, dest=0xffff):
        "send (no fragmentation)"

        self.last_activity = datetime.datetime.now()
        e = self.xbee.send(data, dest)

        logging.debug("TX [{:x}->{:x}][{}]: {}".format(self.xbee.address,
                                                       dest, e.fid,
                                                       hexdump.dump(data)))

        if e.wait(self.xbee._timeout.total_seconds()):
            logging.debug("TX [{}] complete: {}".format(e.fid, e.pkt))
        else:
            logging.debug("TX [{}] timeout".format(e.fid))
Esempio n. 17
0
def run_makefile_string(in_string, expected_string):
    # parse a Makefile from a string.
    # Compare resulting makefile to expected string.
    makefile = pymake.parse_makefile_string(in_string)
    m = makefile.makefile()

    print("# start makefile")
    print(m)
    print("# end makefile")

    print(hexdump.dump(in_string, 16), end="")
    print(hexdump.dump(expected_string, 16), end="")
    print(hexdump.dump(m, 16), end="")

    print("m=\"{0}\"".format(printable_string(m)))
    print("e=\"{0}\"".format(printable_string(expected_string)))
    assert m == expected_string

    # round trip
    expr = str(makefile)
    print(expr)
    m2 = eval(expr).makefile()
    print(m2)
    assert m2 == expected_string, m2
Esempio n. 18
0
def test(loops=10):
    """ local tests """
    print("SALSA20 test")
    plaintext_org = str(23.5)

    for index in range(0, loops):
        cipher = MQTTSALSA20(secret="TTKS0600")
        start = time()
        ciphertext = cipher.encrypt(plaintext_org)

        print("Encrypted " + " " + str(len(ciphertext)) + " in " +
              str(round((time() - start), 5)).ljust(4) + "\t" +
              hexdump.dump(ciphertext, size=2, sep=' '))
        start = time()
        plaintext = cipher.decrypt(ciphertext)
        print("Decrypted " + " " + str(len(plaintext)) + " in " +
              str(round((time() - start), 5)).ljust(6) + "\t" +
              hexdump.dump(plaintext.encode(), size=2, sep=' '))

        if plaintext != plaintext_org:
            print("FAILED")
            print("\t" + str(plaintext_org))
            print("\t" + str(plaintext))
        index = index
Esempio n. 19
0
    def value_in_same_location(self, value_length, weight_same_row,
                               weight_in_row):
        test = []
        ret = 0
        for val in self.container:
            tst = hexdump.dump(bytes(val), value_length * 2, " ")
            test.append(tst.split(" "))  # Create chunks of desired length

        for rows in range(0, len(test)):
            ret += self.test_values(test[rows:], weight_same_row, True)

        for rows in range(0, len(test)):
            ret += self.test_values(test[rows:], weight_in_row, False)

        return ret
Esempio n. 20
0
def sniff_random_value(host=None, counts=10):
    s = sniff(count=counts, filter=host)

    out_type_protocol = []
    out_source_port = []
    out_header_checksum = []
    out_sequence_number = []
    out_total_length = []
    out_payload_length = []

    for i in range(counts):
        packet = bytes(s[i])
        mm = hexdump.dump(packet).split(' ')
        if mm[12] + mm[13] == '0800':
            if mm[23] == '11':
                out_type_protocol.append('IPv4, UDP')
                out_payload_length.append(None)
                out_sequence_number.append(None)
                out_header_checksum.append(mm[24] + ' ' + mm[25])
                out_source_port.append(mm[34] + ' ' + mm[35])
                out_total_length.append(mm[16] + ' ' + mm[17])
            elif mm[23] == '06':
                out_type_protocol.append('IPv4, TCP')
                out_payload_length.append(None)
                out_sequence_number.append(mm[38] + ' ' + mm[39] + ' ' +
                                           mm[40] + ' ' + mm[41])
                out_header_checksum.append(mm[24] + ' ' + mm[25])
                out_source_port.append(mm[34] + ' ' + mm[35])
                out_total_length.append(mm[16] + ' ' + mm[17])
        else:
            out_type_protocol.append('IPv6')
            out_payload_length.append(mm[18] + ' ' + mm[19])
            out_sequence_number.append(None)
            out_header_checksum.append(None)
            out_source_port.append(None)
            out_total_length.append(None)

    for j in range(len(out_type_protocol)):
        print(
            f'\nNumer pakietu: {j}. Zarejestrowano nastepujace losowe wartosci:'
        )
        print(f'1. Typ protokolu: {out_type_protocol[j]}')
        print(f'2. Payload length (only IPv6): {out_payload_length[j]}')
        print(f'3. Sequence number (only TCP): {out_sequence_number[j]}')
        print(f'4. Header checksum: {out_header_checksum[j]}')
        print(f'5. Source port: {out_source_port[j]}')
        print(f'6. Total length: {out_total_length[j]}')
Esempio n. 21
0
    def send_pkt_retry(self, msg, waitfor_msg):
        self.have_response[waitfor_msg] = {'e': threading.Event(), 'rsp': None}
        for i in range(self.retries):

            logging.debug("TX -{:02x}- {}/{} [{:x}->{:x}]: {}".format(
                msg[0], i, self.retries, self.xbee.address, self.remote,
                hexdump.dump(msg)))

            try:
                self.xbee.sendwait(data=msg, dest=self.remote)
            except TimeoutError:
                continue
            if self.have_response[waitfor_msg]['e'].wait(
                    self.xbee._timeout.total_seconds()):
                return self.have_response[waitfor_msg]['rsp']

        return None, None
Esempio n. 22
0
 def _dump(self, command):
     """Dumps the layer bytes in different formats."""
     if len(command) == 1:
         Interface.color_dump(self._l.raw, self._l.slice.start)
         return
     # Parsing the arguments
     cp = CommandParser(LayerInterface._dump_opts())
     args = cp.parse(command)
     if not args:
         Interface._argument_error()
         return
     if args["-hex"]:
         Interface.color_dump(self._l.raw, self._l.slice.start)
     elif args["-b"]:
         print(str(self._l.raw[self._l.slice.start:]), '\n')
     elif args["-hexstr"]:
         d = hexdump.dump(self._l.raw).split(" ")
         print(" ".join(d[self._l.slice.start:]), '\n')
     elif args["-h"]:
         Interface.print_help(LayerInterface._dump_help())
Esempio n. 23
0
 def _dump(self, command):
     """Dumps the packet/template bytes in different formats."""
     if len(command) == 1:
         hexdump.hexdump(self._t.raw)
         print("")
         return
     # Parsing the arguments
     cp = CommandParser(TemplateInterface._dump_opts())
     args = cp.parse(command)
     if not args:
         Interface._argument_error()
         return
     if args["-hex"]:
         hexdump.hexdump(self._t.raw)
         print("")
     elif args["-b"]:
         print(str(self._t.raw), "\n")
     elif args["-hexstr"]:
         print(hexdump.dump(self._t.raw), "\n")
     elif args["-h"]:
         Interface.print_help(TemplateInterface._dump_help())
Esempio n. 24
0
def scan_network(q, r, port):
    sleep(random() * 5)  # Spread them out.

    while True:
        try:
            group = q.get(timeout=10)


#			print "======> " + str(group)
        except gevent.queue.Empty:
            break
        logging.info("Joining %s" % group)
        sock = join(str(group), port)
        try:
            data = sock.recv(16)
            logging.info("[%s]. Data: %s", group, dump(data, 2))
            r.put(group)
        except socket.timeout:
            logging.info("[%s] Timeout", group)
        sleep(PER_GROUP_LISTEN_TIME)
        sock.close()
        q.task_done()
Esempio n. 25
0
def on_message(client, userdata, message):
    """ MQTT - receive messages """
    client = client
    userdata = userdata
    global DUMP
    try:
        DUMP.delete('1.0', tk.END)
        cont = mcont.MCONT(None, mfile.pw)
        package = cont.destruct(message.payload, message.topic)
        print(package)

        if isinstance(package["Ciphertext"], str):
            hx_value = package["Ciphertext"].encode()
        else:
            hx_value = package["Ciphertext"]

        hx_value = hexdump.dump(hx_value, size=4, sep=' ')
        DUMP.insert(tk.INSERT, "MQTT msg received\n")
        DUMP.insert(tk.INSERT, "Ciphertext\n")
        DUMP.insert(tk.INSERT, hx_value)
        DUMP.insert(tk.INSERT, "\n\nPlaintext\n")
        DUMP.insert(tk.INSERT, package["Plaintext"])
        DUMP.insert(tk.INSERT, "\n\nPath\n")
        DUMP.insert(tk.INSERT, package["Path"])
        DUMP.insert(tk.INSERT, "\n\nDecrypt duration\n")
        DUMP.insert(tk.END, str(round(package["Duration"], 8)) + "\n")

    except ValueError:
        DUMP.delete('1.0', tk.END)
        DUMP.insert(tk.INSERT, "Hash failure\n")
        #DUMP.insert(tk.INSERT, "\nBacktrace\n")
        #DUMP.insert(tk.INSERT, str(traceback.format_exc()))

    except Exception as failure:
        DUMP.delete('1.0', tk.END)
        DUMP.insert(tk.INSERT, str(failure))
        DUMP.insert(tk.INSERT, "\nBacktrace\n")
        DUMP.insert(tk.INSERT, str(traceback.format_exc()))
Esempio n. 26
0
    def dump_file(self, file_name):
        with open(file_name, "rb") as f:

            chunk = f.read(self.chunks_size)
            chunk_counter = 0
            actual_line = str_to_bytes("")

            while chunk:
                actual_line += chunk

                self.bytes_dump += hexdump.dump(chunk, self.chunks_size,
                                                self.chunks_separator)

                chunk_counter += 1
                chunk = f.read(self.chunks_size)

                if chunk_counter == self.bytes_per_line:
                    self.bytes_dump += "\n"
                    print(self.dump_string(actual_line))

                    actual_line = str_to_bytes("")
                    chunk_counter = 0

        return self.bytes_dump
Esempio n. 27
0
import hexdump
from pytun import TunTapDevice, IFF_TAP

tun = TunTapDevice(name='rfc6214')

with open("captured_in.hex", "r") as the_file:
    hex = the_file.readline()

buf = hexdump.dehex(hex)

tun.write(buf)

buf = tun.read(tun.mtu)
hex = hexdump.dump(buf, 2, '')

print(hex)

with open('captured_out.hex', 'w') as the_file:
    the_file.write(hex)
Esempio n. 28
0
def test_vline():
    test_list = (
        # single line
        ("foo : bar ; baz\n", "foo : bar ; baz\n"),
        ("backslash=\ \n", "backslash=\ \n"),

        # backslash then blank line then end-of-string
        (r"""space=\

""", "space= \n"),

        # backslash joining rule + recipe
        (r"""foo\
:\
bar\
;\
baz
""", "foo : bar ; baz\n"),

        # another way to write the previous test
        ("foo2\\\n:\\\nbar\\\n;\\\nbaz\n", "foo2 : bar ; baz\n"),

        # from ffmpeg
        (r"""SUBDIR_VARS := CLEANFILES EXAMPLES FFLIBS HOSTPROGS TESTPROGS TOOLS	  \
			   HEADERS ARCH_HEADERS BUILT_HEADERS SKIPHEADERS			\
			   ARMV5TE-OBJS ARMV6-OBJS VFP-OBJS NEON-OBJS				\
			   ALTIVEC-OBJS VIS-OBJS									 \
			   MMX-OBJS YASM-OBJS										\
			   MIPSFPU-OBJS MIPSDSPR2-OBJS MIPSDSPR1-OBJS MIPS32R2-OBJS  \
			   OBJS HOSTOBJS TESTOBJS
""", "SUBDIR_VARS := CLEANFILES EXAMPLES FFLIBS HOSTPROGS TESTPROGS TOOLS HEADERS ARCH_HEADERS BUILT_HEADERS SKIPHEADERS ARMV5TE-OBJS ARMV6-OBJS VFP-OBJS NEON-OBJS ALTIVEC-OBJS VIS-OBJS MMX-OBJS YASM-OBJS MIPSFPU-OBJS MIPSDSPR2-OBJS MIPSDSPR1-OBJS MIPS32R2-OBJS OBJS HOSTOBJS TESTOBJS\n"
         ),

        # stupid DOS \r\n 0x0d0a <cr><lf>
        #	( """supid-dos:\\\r\nis\\\r\nstupid\r\n""", () ),
        (r"""more-fun-in-assign\
=		   \
	the	 \
	leading \
	and	 \
	trailing\
	white   \
	space   \
	should  \
	be	  \
	eliminated\
	\
	\
	\
	including \
	\
	\
	blank\
	\
	\
	lines
""", "more-fun-in-assign = the leading and trailing white space should be eliminated including blank lines\n"
         ),

        # This is a weird one. Why doesn't GNU Make give me two \\ here? I only get
        # one. Disable the test for now. Need to dig into make
        #	( r"""literal-backslash-2 = \\\
        #		q
        #""", "literal-backslash-2 = \\ q\n" ),
        #
        ("foo : # this comment\\\ncontinues on this line\n",
         "foo : # this comment continues on this line\n"),

        # end of the tests list
    )

    for test in test_list:
        # string, validation
        s, v = test
        #		print(s,end="")
        #		print("s={0}".format(hexdump.dump(s,16)),end="")

        # VirtualLine needs an array of lines from a file.  The EOLs must be
        # preserved. But I want a nice easy way to make test strings (one
        # single string).
        #
        # The incoming string will be one single string with embedded \n's
        # (rather than trying to create an array of strings by hand).
        # Split the test string by \n into an array. Then restore \n on each line.
        # The [:-1] skips the empty string after the final \n
        file_lines = s.split("\n")[:-1]
        lines = [line + "\n" for line in file_lines]

        #		print( "split={0}".format(s.split("\n")))
        #		print( "lines={0} len={1}".format(lines,len(lines)),end="")

        vline = VirtualLine(lines, 0)
        for line in vline.virt_lines:
            print(line)
        print(vline)

        s = str(vline)
        print("s={0}".format(hexdump.dump(s, 16)))
        print("v={0}".format(hexdump.dump(v, 16)))
        assert s == v
Esempio n. 29
0
    def send(self, data, remote_filename, filesize, offset=0, dest=0xffff):
        "send with fragmentation, returns true on success"

        start = datetime.datetime.now()
        self.last_activity = datetime.datetime.now()

        # mtu seems imprecise. (does not include headers)
        frags = list(
            frag.make_frags(data, threshold=self.xbee.mtu - 8, encode=False))

        self.begin_transfer.clear()
        self.have_acks.clear()
        ok_begin = False
        for i in range(self.retries):
            msg = xTP.SEND32_REQ + struct.pack(">LLLL",
                              offset, filesize, frags[0].total, frags[0].crc) + \
                              remote_filename.encode("utf-8")

            logging.debug("TX SEND32_REQ {}/{} [{:x}->{:x}]: {}".format(
                i, self.retries, self.xbee.address, dest, hexdump.dump(msg)))

            try:
                self.xbee.sendwait(data=msg, dest=dest)
            except TimeoutError:
                continue

            if (self.begin_transfer.wait(self.xbee._timeout.total_seconds())):
                logging.info("Begin transfer at {} of {} for file {}.".format(
                    offset, filesize, remote_filename))
                ok_begin = True
                break
            else:
                logging.info("Failed to begin transfer.")
                return False

        if ok_begin == False:
            return False

        #initial set of acks
        self.acks = bitarray(len(frags))
        self.acks.setall(0)
        for j in range(self.retries):
            txcnt = 0
            for i, f in enumerate(frags):
                if self.acks[i] == False:
                    txcnt += 1
                    d = xTP.SEND32_DATA + struct.pack(">L", i) + f.data
                    e = self.xbee.send(data=d, dest=dest)

                    logging.debug(
                        "TX SEND32_DATA {}/{} [{:x}->{:x}][{}]: {}".format(
                            i, len(frags), self.xbee.address, dest, e.fid,
                            hexdump.dump(d)))
            if txcnt == 0:
                logging.warn("TX complete due to no packets to send")
                return True  # must have worked.

            # block until all packets go out...
            self.xbee.flush()

            got_acks = False
            for k in range(self.retries):
                msg = xTP.SEND32_GETACKS
                self.have_acks.clear()

                logging.debug(
                    "TX SEND32_GETACKS {}/{} [{:x}->{:x}][{}]: {}".format(
                        k, self.retries, self.xbee.address, dest, e.fid,
                        hexdump.dump(msg)))

                try:
                    self.xbee.sendwait(data=msg, dest=dest)
                except TimeoutError:
                    continue

                if self.have_acks.wait(self.xbee._timeout.total_seconds()):
                    logging.debug("Got acks. [all=={}]".format(
                        self.acks.all()))
                    got_acks = True
                    tm = datetime.datetime.now() - start
                    if self.acks.all():
                        logging.info(
                            "Finish transfer at {} of {} for file {} in {} = {:.2f} kbps."
                            .format(offset, filesize, remote_filename, tm,
                                    (8 * len(data) / 1024) /
                                    tm.total_seconds()))
                        return True
                    break

            if got_acks == False:
                loggin.warn("Failed because remote didn't send acks.")
                return False

        return False
Esempio n. 30
0
    def true_sendall(self, data, *args, **kwargs):
        req = decode_from_bytes(data)
        # make request unique again
        req_signature = hashlib.md5(encode_to_bytes(''.join(sorted(req.split('\r\n'))))).hexdigest()
        # port should be always a string
        port = text_type(self._port)

        # prepare responses dictionary
        responses = dict()

        if Mocket.get_truesocket_recording_dir():
            path = os.path.join(
                Mocket.get_truesocket_recording_dir(),
                Mocket.get_namespace() + '.json',
            )
            # check if there's already a recorded session dumped to a JSON file
            try:
                with io.open(path) as f:
                    responses = json.load(f)
            # if not, create a new dictionary
            except (FileNotFoundError, JSONDecodeError):
                pass

        try:
            response_dict = responses[self._host][port][req_signature]
        except KeyError:
            # preventing next KeyError exceptions
            responses.setdefault(self._host, dict())
            responses[self._host].setdefault(port, dict())
            responses[self._host][port].setdefault(req_signature, dict())
            response_dict = responses[self._host][port][req_signature]

        # try to get the response from the dictionary
        try:
            try:
                encoded_response = hexdump.dehex(response_dict['response'])
            except TypeError:  # pragma: no cover
                # Python 2
                encoded_response = hexdump.restore(encode_to_bytes(response_dict['response']))
        # if not available, call the real sendall
        except KeyError:
            self._connect()
            self.true_socket.sendall(data, *args, **kwargs)
            encoded_response = b''
            # https://github.com/kennethreitz/requests/blob/master/tests/testserver/server.py#L13
            while select.select([self.true_socket], [], [], 0.5)[0]:
                recv = self.true_socket.recv(self._buflen)
                if recv:
                    encoded_response += recv
                else:
                    break

            # dump the resulting dictionary to a JSON file
            if Mocket.get_truesocket_recording_dir():

                # update the dictionary with request and response lines
                response_dict['request'] = req
                response_dict['response'] = hexdump.dump(encoded_response)

                with io.open(path, mode='w') as f:
                    f.write(decode_from_bytes(json.dumps(responses, indent=4, sort_keys=True)))

        # response back to .sendall() which writes it to the mocket socket and flush the BytesIO
        return encoded_response
Esempio n. 31
0
async def hvacConnected(deviceSession, firstState):
    global devConnected
    print("Device connected! " +
          hexdump.dump(deviceSession.device.deviceData) + " state: ")
    print(firstState.toString())
    devConnected = True
Esempio n. 32
0
 def _transmit(_from, _to):
     content = _from.recv_all()
     if content:
         print(dump(bytes(content, ENCODE)))
         _to.send(content)
     return content