def init_parser(): """Set up the parser with the grammar to be recognized. """ # CORE digit = h.ch_range(0x30, 0x39) alpha = h.choice(h.ch_range(0x41, 0x5a), h.ch_range(0x61, 0x7a)) space = h.in_(" \t\n\r\f\v") # AUX. plus = h.ch('+') slash = h.ch('/') equals = h.ch('=') bsfdig = h.choice(alpha, digit, plus, slash) bsfdig_4bit = h.in_("AEIMQUYcgkosw048") bsfdig_2bit = h.in_("AQgw") base64_3 = h.repeat_n(bsfdig, 4) base64_2 = h.sequence(bsfdig, bsfdig, bsfdig_4bit, equals) base64_1 = h.sequence(bsfdig, bsfdig_2bit, equals, equals) base64 = h.action(h.sequence(h.many(base64_3), h.optional(h.choice(base64_2, base64_1))), act_base64) # TODO This is not quite the same as the C example, with uses act_ignore. # But I can't get hammer to filter any value returned by act_ignore. ws = h.ignore(h.many(space)) document = h.action(h.sequence(ws, base64, ws, h.end_p()), act_document) # BUG sometimes inputs that should just don't parse. # It *seemed* to happen mostly with things like "bbbbaaaaBA==". # Using less actions seemed to make it less likely. return document
def init_parser(): """Set up the parser with the grammar to be recognized. """ # CORE digit = h.ch_range(0x30, 0x39) alpha = h.choice(h.ch_range(0x41, 0x5a), h.ch_range(0x61, 0x7a)) space = h.in_(b" \t\n\r\f\v") # AUX. plus = h.ch(b'+') slash = h.ch(b'/') equals = h.ch(b'=') bsfdig = h.choice(alpha, digit, plus, slash) bsfdig_4bit = h.in_(b"AEIMQUYcgkosw048") bsfdig_2bit = h.in_(b"AQgw") base64_3 = h.repeat_n(bsfdig, 4) base64_2 = h.sequence(bsfdig, bsfdig, bsfdig_4bit, equals) base64_1 = h.sequence(bsfdig, bsfdig_2bit, equals, equals) base64 = h.action( h.sequence(h.many(base64_3), h.optional(h.choice(base64_2, base64_1))), act_base64) # TODO This is not quite the same as the C example, with uses act_ignore. # But I can't get hammer to filter any value returned by act_ignore. ws = h.ignore(h.many(space)) document = h.action(h.sequence(ws, base64, ws, h.end_p()), act_document) # BUG sometimes inputs that should just don't parse. # It *seemed* to happen mostly with things like "bbbbaaaaBA==". # Using less actions seemed to make it less likely. return document
def relay_operate_configuration(): header = h.token('\xa5\xce') length = h.uint8() breaker_bits = h.uint8() remote_bits = h.uint16() remote_pulse = h.uint8() reserved = h.uint8() parser = h.sequence( header, length, breaker_bits, remote_bits, remote_pulse, reserved, h.repeat_n(h.uint8(), 2), h.repeat_n(h.sequence(h.uint8(), h.uint8(), h.uint8()), 32), h.uint8()) return parser
def fast_meter_message(): header = h.token('\xa5\xd1') any_char = h.ch_range('\x00', '\xff') parser = h.sequence(header, h.uint8(), h.ch('\x00'), h.repeat_n(h.uint32(), 7), h.uint64(), h.repeat_n(any_char, 167), any_char) return parser
def relay_definition_message(): header = h.token('\xa5\xc0') any_char = h.ch_range('\x00', '\xff') parser = h.sequence(header, h.uint8(), h.uint8(), h.uint8(), h.uint8(), h.many1(any_char)) return parser
def init_parser(): return h.sequence( h.many1( h.choice(relay_definition_message(), fast_meter_configuration_block(), fast_meter_message(), demand_fast_meter_configuration_block(), peak_fast_meter_configuration_block(), fast_message_block(), relay_operate_configuration())), h.end_p())
def init_parser(): """Return a parser with the grammar to be recognized. """ # CORE # This is a direct translation of the C example. In C the literal 0x30 # is interchangable with the char literal '0' (note the single quotes). # This is not the case in Python. # TODO In the interests of being more Pythonic settle on either string # literals, or integers digit = h.ch_range(0x30, 0x39) alpha = h.choice(h.ch_range(0x41, 0x5a), h.ch_range(0x61, 0x7a)) space = h.in_(" \t\n\r\f\v") # AUX. plus = h.ch('+') slash = h.ch('/') equals = h.action(h.ch('='), act_equals) bsfdig = h.action(h.choice(alpha, digit, plus, slash), act_bsfdig) bsfdig_4bit = h.action(h.in_("AEIMQUYcgkosw048"), act_bsfdig_4bit) bsfdig_2bit = h.action(h.in_("AQgw"), act_bsfdig_2bit) base64_3 = h.action(h.repeat_n(bsfdig, 4), act_base64_3) base64_2 = h.action(h.sequence(bsfdig, bsfdig, bsfdig_4bit, equals), act_base64_2) base64_1 = h.action(h.sequence(bsfdig, bsfdig_2bit, equals, equals), act_base64_1) base64 = h.action(h.sequence(h.many(base64_3), h.optional(h.choice(base64_2, base64_1))), act_base64) # TODO This is not quite the same as the C example, with uses act_ignore. # But I can't get hammer to filter any value returned by act_ignore. ws = h.ignore(h.many(space)) document = h.action(h.sequence(ws, base64, ws, h.end_p()), act_document) # BUG sometimes inputs that should just don't parse. # It *seemed* to happen mostly with things like "bbbbaaaaBA==". # Using less actions seemed to make it less likely. return document
def init_parser(): return h.sequence( h.many1( h.choice( #sampleEvents_parser, #pollingEngine_parser, #envelope_parser, #measurementDevice_parser, #sensors_parser, schemaVersion_parser())))
def connection_start_ok_parser(): parser = h.sequence( h.ch('\x01'), # type h.uint16(), # Channel h.uint32(), # Length h.token("\x00\x0a"), # Class h.token("\x00\x0b"), # Method h.end_p() ) return parser
def basic_deliver_parser(): parser = h.sequence( h.ch('\x01'), # type h.uint16(), # Channel h.uint32(), # Length h.token("\x00\x3c"), # Class h.token("\x00\x3c"), # Method h.end_p() ) return parser
def init_parser(): # CORE digit = h.ch_range(0x30, 0x39) alpha = h.choice(h.ch_range(0x41, 0x5a), h.ch_range(0x61, 0x7a)) # AUX. plus = h.ch('+') slash = h.ch('/') equals = h.ch('=') bsfdig = h.choice(alpha, digit, plus, slash) bsfdig_4bit = h.in_('AEIMQUYcgkosw048') bsfdig_2bit = h.in_('AQgw') base64_3 = h.repeat_n(bsfdig, 4) base64_2 = h.sequence(bsfdig, bsfdig, bsfdig_4bit, equals) base64_1 = h.sequence(bsfdig, bsfdig_2bit, equals, equals) base64 = h.sequence(h.many(base64_3), h.optional(h.choice(base64_2, base64_1))) return h.sequence(h.whitespace(base64), h.whitespace(h.end_p()))
def init_parser(): # CORE digit = h.ch_range(0x30, 0x39) alpha = h.choice(h.ch_range(0x41, 0x5a), h.ch_range(0x61, 0x7a)) # AUX. plus = h.ch(b'+') slash = h.ch(b'/') equals = h.ch(b'=') bsfdig = h.choice(alpha, digit, plus, slash) bsfdig_4bit = h.in_(b'AEIMQUYcgkosw048') bsfdig_2bit = h.in_(b'AQgw') base64_3 = h.repeat_n(bsfdig, 4) base64_2 = h.sequence(bsfdig, bsfdig, bsfdig_4bit, equals) base64_1 = h.sequence(bsfdig, bsfdig_2bit, equals, equals) base64 = h.sequence(h.many(base64_3), h.optional(h.choice(base64_2, base64_1))) return h.sequence(h.whitespace(base64), h.whitespace(h.end_p()))
def length_block(): parser = h.sequence( h.ch('\x01'), h.uint16(), h.and_(h._h_length_value(h.uint32(), h.ch_range('\x00', '\xff'))), h.uint32(), h.many(h.ch_range('\x00', '\xff')), h.end_p()) return parser
def connection_close_ok_parser(): parser = h.sequence( h.ch('\x01'), # type h.uint16(), # Channel h.uint32(), # Length h.token("\x00\x0a"), # Class h.token("\x00\x33"), # Method # No arguments h.end_p() ) return parser
def connection_open_vhost_ok_parser(): parser = h.sequence( h.ch('\x01'), # type h.uint16(), # Channel h.uint32(), # Length h.token("\x00\x0a"), # Class h.token("\x00\x29"), # Method # Arguments h.ch('\x00'),# Known-Host # most likely going to change this according to the message h.end_p() ) return parser
def basic_consume_ok_parser(): parser = h.sequence( h.ch('\x01'), # type h.uint16(), # Channel h.uint32(), # Length h.token("\x00\x3c"), # Class h.token("\x00\x15"), # Method # Arguments # consumer-tag h.end_p() ) return parser
def channel_open_parser(): parser = h.sequence( h.ch('\x01'), # type h.uint16(), # Channel h.uint32(), # Length h.token("\x00\x14"), # Class h.token("\x00\x0a"), # Method # Arguments h.ch('\x00'), # Out-of-bounds h.end_p() ) return parser
def channel_open_ok_parser(): parser = h.sequence( h.ch('\x01'), # type h.uint16(), # Channel h.uint32(), # Length h.token("\x16\x28"), # Class h.token("\x00\x0b"), # Method # Arguments h.uint32(), # Channel-Id h.end_p() ) return parser
def fast_message_block(): header = h.token('\xa5\x46') length = h.uint8() routing_address = h.repeat_n(h.uint8(), 5) status = h.uint8() function_code = h.uint8() sequence_byte = h.uint8() response_number = h.uint8() any_value = h.many1(h.ch_range('\x00', '\xff')) crc = h.uint16() parser = h.sequence(header, length, routing_address, status, function_code, sequence_byte, response_number, any_value) return parser
def connection_tune_ok_parser(): parser = h.sequence( h.ch('\x01'), # type h.uint16(), # Channel h.uint32(), # Length h.token("\x00\x0a"), # Class h.token("\x00\x1f"), # Method # Arguments h.uint16(), # Channel max h.uint32(), # Frame max h.uint16(), # Heartbeat h.end_p() ) return parser
def connection_close_parser(): parser = h.sequence( h.ch('\x01'), # type h.uint16(), # Channel h.uint32(), # Length h.token("\x00\x0a"), # Class h.token("\x00\x32"), # Method # Arguments h.uint16(), # Replay-code #Replay-text h.uint16(), # Class-Id h.uint16(), # Method-Id h.end_p() ) return parser
def queue_declare_parser(): parser = h.sequence( h.ch('\x01'), # type h.uint16(), # Channel h.uint32(), # Length h.token("\x00\x32"), # Class h.token("\x00\x0a"), # Method # Arguments h.uint16(), # Ticket # how do you parse that long message?#Queue h.many(h.ch_range('\x00', '\xff')), #When you parse this out... (, ,, , 0L, ('','','','')) h.end_p() ) return parser
def basic_consume_parser(): parser = h.sequence( h.ch('\x01'), # type h.uint16(), # Channel h.uint32(), # Length h.token("\x00\x3c"), # Class h.token("\x00\x14"), # Method # Arguments h.uint16(), # Ticket # how do you parse that long message? #Queue h.many(h.ch_range('\x00', '\xff')), # consumer-tag h.end_p() ) return parser
def queue_declare_ok_parser(): parser = h.sequence( h.ch('\x01'), # type h.uint16(), # Channel h.uint32(), # Length h.token("\x00\x32"), # Class h.token("\x00\x0b"), # Method # Arguments #how do you parse that long message? #Queue h.many(h.ch_range('\x00', '\xff')), #h.uint32(), # message-count #h.uint32(), # consumer-count h.end_p() ) return parser
def peak_fast_meter_configuration_block(): header = h.token("\xa5\xc3") length = h.uint8() scale_factors = h.uint8() analog = h.uint8() samples = h.uint8() digital = h.uint8() analog_offset = h.uint16() timestamp_offset = h.uint16() digital_offset = h.uint16() analog_signal = h.repeat_n(h.uint8(), 10) all_signals = h.repeat_n(analog_signal, 5) checksum = h.ch_range('\x00', '\xff') calculation_blocks = h.uint8() parser = h.sequence(header, length, h.uint8(), h.uint8(), scale_factors, analog, samples, digital, calculation_blocks, analog_offset, timestamp_offset, digital_offset, all_signals, checksum) return parser
def init_parser(): return h.sequence(h.many1(h.choice( length_block(), connection_start_parser(), connection_start_ok_parser(), connection_tune_parser(), connection_tune_ok_parser(), connection_open_vhost_parser(), channel_open_parser(), channel_open_ok_parser(), queue_declare_parser(), queue_declare_ok_parser(), basic_consume_parser(), basic_consume_ok_parser(), basic_publish_parser(), basic_deliver_parser(), channel_close_parser(), channel_close_ok_parser(), connection_close_parser(), connection_close_ok_parser() )))
def setUpClass(cls): cls.parser = h.sequence(h.ch("a"), h.epsilon_p())
def setUpClass(cls): cls.parser = h.sequence(h.ch("a"), h.ignore(h.ch("b")), h.ch("c"))
def setUpClass(cls): cls.parser = h.sequence(h.ch("a"), h.optional(h.choice(h.ch("b"), h.ch("c"))), h.ch("d"))
def setUpClass(cls): cls.parser = h.sequence(h.ch("a"), h.whitespace(h.ch("b")))
def setUpClass(cls): cls.parser = h.action(h.sequence(h.choice(h.ch("a"), h.ch("A")), h.choice(h.ch("b"), h.ch("B"))), lambda x: [y.upper() for y in x])
def setUpClass(cls): #raise unittest.SkipTest("Bind doesn't work right now") cls.parser = h.indirect() a = h.ch("a") cls.parser.bind(h.choice(h.sequence(a, cls.parser), h.epsilon_p()))
def setUpClass(cls): cls.parser = h.sequence(h.ch(b"a"), h.epsilon_p())
def setUpClass(cls): cls.parser = h.sequence(h.ch(b"a"), h.ignore(h.ch(b"b")), h.ch(b"c"))
def setUpClass(cls): cls.parser = h.sequence(h.ch(b"a"), h.optional(h.choice(h.ch(b"b"), h.ch(b"c"))), h.ch(b"d"))
def setUpClass(cls): cls.parser = h.sequence(h.ch("1"), h.and_(h.ch("2")))
def setUpClass(cls): cls.parser = h.sequence(h.ch("a"), h.choice(h.sequence(h.ch("+"), h.not_(h.ch("+"))), h.token("++")), h.ch("b"))
def setUpClass(cls): cls.parser = h.sequence( h.ch(b"a"), h.choice(h.sequence(h.ch(b"+"), h.not_(h.ch(b"+"))), h.token(b"++")), h.ch(b"b"))
def setUpClass(cls): cls.parser = h.sequence(h.ch(b"1"), h.and_(h.ch(b"2")))
def setUpClass(cls): #raise unittest.SkipTest(b"Bind doesn't work right now") cls.parser = h.indirect() a = h.ch(b"a") cls.parser.bind(h.choice(h.sequence(a, cls.parser), h.epsilon_p()))