def read_board_id(bus, i2cbus, mux, mux_val): print "Should read 0x57 to ID the board type"; board_type=[]; board_type_read = -1; while board_type_read < 128: try: if (board_type_read == -1): board_type_tmp = bus.read_i2c_block_data(0x57, 0, 32); else: board_type_tmp = bus.read_i2c_block_data(0x57, board_type_read, 32); for member in board_type_tmp: board_type.append(member); board_type_read = len(board_type); # print "board_type_read=%d, %d" % (board_type_read, len(board_type)); except IOError: print "Error reading board ID"; break; print "Read %d bytes checking board_type" % board_type_read; if (board_type_read >= 128): board_name =""; board_sub_type =""; board_mfg_date=""; board_test_time=""; board_sn=""; for byte in range (0, 0x10): if (isprint(chr(board_type[byte]))): board_name += "%c" % board_type[byte]; for byte in range (0x10, 0x20): if (isprint(chr(board_type[byte]))): board_sub_type += "%c" % board_type[byte]; for byte in range (0x20, 0x30): if (isprint(chr(board_type[byte]))): board_mfg_date += "%c" % board_type[byte]; for byte in range (0x30, 0x40): if (isprint(chr(board_type[byte]))): board_test_time += "%c" % board_type[byte]; for byte in range (0x50, 0x60): if (isprint(chr(board_type[byte]))): board_sn += "%c" % board_type[byte]; print "--> BOARD INFO <--"; print "NAME: %s" % board_name; print "SUB_TYPE: %s" % board_sub_type; print "MFG_DATE: %s" % board_mfg_date; print "TEST_TIME: %s" % board_test_time; print "SERIAL: %s" % board_sn;
return start + g_bytesPerHalfRow
def hexdump(data):
g_bytesPerRow = 16
pos = 0
size = len(data)
while pos < size:
row_start = pos
print '%.4X: ' % pos,
pos = hexdump_half_row(data, pos)
pos = hexdump_half_row(data, pos)
sys.stdout.write("|")
i = row_start
while i < row_start + g_bytesPerRow and i < size:
c = data[i]
if isprint(c):
sys.stdout.write("%c" % c)
else:
sys.stdout.write("%c" % '.')
i = i + 1
for i in range(i, row_start + g_bytesPerRow):
sys.stdout.write(" ")
def getAttributes(self, path):
attributes = {}
sys_path = "/sys%s" % path
try:
names = os.listdir(sys_path)
except OSError:
return attributes
for name in names:
name_path = posixpath.join(sys_path, name)
if name[0] == "." \
or name in ["dev", "uevent"] \
or posixpath.isdir(name_path) \
or posixpath.islink(name_path):
continue
try:
value = open(name_path, "r").read().strip()
except IOError:
continue
value = value.split("\n")[0]
if [c for c in value if not isprint(c)]:
continue
attributes[name] = value
return attributes
def doRead(self):
""" Input is ready! """
curses.noecho()
c = self.stdscr.getch() # read a character
if c == curses.KEY_BACKSPACE:
self.searchText = self.searchText[:-1]
elif c == curses.KEY_ENTER or c == 10:
text = self.searchText
self.searchText = ''
self.print_line(">> %s" % text)
try:
if self.callback:
self.callback.on_line(text)
except Exception as e:
self.print_line(str(e))
self.stdscr.refresh()
elif isprint(c):
if len(self.searchText) == self.cols - 2:
return
self.searchText = self.searchText + chr(c)
self.stdscr.addstr(self.rows - 1, 0,
self.searchText + (' ' * (
self.cols - len(self.searchText) - 2)))
self.paintStatus(self.statusText + ' %d' % len(self.searchText))
self.stdscr.move(self.rows - 1, len(self.searchText))
self.stdscr.refresh()
def handle_input(self, input):
input = self.translate_input(input)
if input in range(curses.KEY_F0, curses.KEY_F10) or \
input == curses.KEY_UP or input == curses.KEY_DOWN:
logging.debug("Got special key, breaking")
self.input = input
return ord(ctrl('g'))
else:
self.input = None
if input is not None and isprint(input):
self.text_buff.append(chr(input))
self.text.append(input)
if not self.is_valid():
if len(self.text) > 0:
self.text.pop()
length = len(self.text_buff)
temp_buff = self.text_buff[:length-49]
self.set_repo(self.text_buff[length-49:])
length = len(self.text_buff)
self.text_buff = temp_buff + self.text_buff[length-49:]
if self.masked:
input = self.masked_char
elif input == curses.KEY_BACKSPACE or input == ord(ctrl('H')):
if len(self.text) > 0:
self.text.pop()
self.text_buff.pop()
return input
async def _get_packet(self) -> Tuple[str, str]:
"""Get the next valid packet, along with an isoformat datetime string."""
try:
raw_packet = await self.reader.readline()
raw_packet = raw_packet.decode("ascii").strip()
except (serial.SerialException, UnicodeDecodeError):
return
raw_packet = "".join(char for char in raw_packet if isprint(char))
if not raw_packet:
return
packet_dt = dt.now().isoformat()
if self._packet_log: # TODO: make this async
self._packet_log.write(f"{packet_dt} {raw_packet}\r\n")
if not MESSAGE_REGEX.match(raw_packet):
_LOGGER.warning("Packet structure is not valid, >> %s <<",
raw_packet)
return
if len(raw_packet[50:]) != 2 * int(raw_packet[46:49]):
_LOGGER.warning("Packet payload length not valid, >> %s <<",
raw_packet)
return
if int(raw_packet[46:49]) > 48: # TODO: a ?corrupt pkt of 55 seen
_LOGGER.warning("Packet payload length excessive, >> %s <<",
raw_packet)
return
return f"{packet_dt} {raw_packet}"
def process(self, key):
if key == ENTER:
self.selected = self.vis_items[self.highlighted]
return Response.enter
elif key == ESCAPE:
return Response.escape
elif key in BACKSPACE and self.letters:
self.highlighted = 0
self.letters.pop(-1)
return Response.keepon
elif key in UP:
self.highlighted = max([0, self.highlighted - 1])
return Response.keepon
elif key in DOWN:
self.highlighted = min([self.max_items - 1, self.highlighted + 1])
return Response.keepon
elif ascii.isprint(key):
val = chr(key)
self.highlighted = 0
self.letters.append(val)
return Response.keepon
else:
return Response.keepon
def key_event(self, key):
if ca.isprint(key):
self.value.insert(self._offset + self.cursor, chr(key))
self.cursor += 1
self._fix_single_move()
self.changed()
elif key == curses.KEY_LEFT:
if self.cursor + self._offset > 0:
self.cursor -= 1
self._fix_single_move()
elif key == curses.KEY_RIGHT:
if self.cursor + self._offset < len(self.value):
self.cursor += 1
self._fix_single_move()
elif key == ca.BS or key == curses.KEY_BACKSPACE:
if self.cursor + self._offset > 0:
del self.value[self._offset + self.cursor - 1]
self.cursor -= 1
if self.cursor == 0:
self._shift_cursor_to_middle()
self.changed()
else:
return False
self.touch()
return True
def doRead(self):
""" Input is ready! """
curses.noecho()
c = self.stdscr.getch() # read a character
if c == curses.KEY_BACKSPACE:
self.searchText = self.searchText[:-1]
elif c == curses.KEY_ENTER or c == 10:
text = self.searchText
self.searchText = ''
self.print_line(">> %s" % text)
try:
if self.callback:
self.callback.on_line(text)
except Exception as e:
self.print_line(str(e))
self.stdscr.refresh()
elif isprint(c):
if len(self.searchText) == self.cols - 2:
return
self.searchText = self.searchText + chr(c)
self.stdscr.addstr(
self.rows - 1, 0,
self.searchText + (' ' * (self.cols - len(self.searchText) - 2)))
self.paintStatus(self.statusText + ' %d' % len(self.searchText))
self.stdscr.move(self.rows - 1, len(self.searchText))
self.stdscr.refresh()
def main_loop(stdscr):
(screen_h, screen_w) = stdscr.getmaxyx()
win = curses.newwin(1, screen_w, screen_h - 1, 0)
locale.setlocale(locale.LC_ALL, "")
code = locale.getpreferredencoding()
#print group_setup[0]
#print group_setup1[0]
ch = win.getch()
#print ch
stdscr.addstr(0, 0, group_setup[0].encode(code))
#stdscr.addstr(group_setup1[0])
stdscr.refresh()
ch = win.getch()
stdscr.addstr(1, 0, group_setup[1].encode(code))
stdscr.addstr(2, 50, group_setup[1].encode(code))
stdscr.addstr(3, 50, group_setup1[1].encode(code))
stdscr.addstr(4, 50, a.encode(code))
stdscr.addstr(5, 50, b.encode(code))
stdscr.addstr(6, 50, "b[0].isprint: " + str(ascii.isprint(ord(b[0]))))
stdscr.addstr(7, 50, b)
stdscr.refresh()
win.nodelay(False)
#print(ch)
x = 50
y = 8
while True:
ch = win.get_wch()
stdscr.addstr(y, x, ch)
x = x + 1
if x > 100:
x = 50
y = y + 1
stdscr.refresh()
def run( self ):
print ''.join(["Listening for input on ", self.tty.port, " in new thread."])
while(1):
self.ttylock.acquire()
#wait for a single character
char = self.tty.read()
#if no input, just wait
if( char == '' ):
pass
# if user hit ctrl-c, erase buffer
elif( char == '\x03'):
self.clearbuffer()
self.tty.write('\r\n')
#if user hit enter, send message
elif( char == '\r' ):
self.tty.write('\r\n')
self.notify( self.textbuffer )
self.clearbuffer()
#if buffer is full, beep
elif( self._maxbuf > 0 and len( self.textbuffer ) >= self._maxbuf ):
self.tty.write('\x07')
#if character is printable and buffer not full, echo it and add to buffer
elif( isprint( char ) ):
self.textbuffer = ''.join( [ self.textbuffer, char ] )
self.tty.write( char )
self.ttylock.release()
time.sleep(0.01)
class ttcp_t():
def __init__(self,
length,
udp,
port,
numblocks,
ipaddr,
verbose=False):
self.ipaddr = ipaddr
self.port = port
self.length = length
self.udp = udp
self.numblocks = numblocks
self.conn = -1
self.status = -1
self.address = (self.ipaddr, self.port)
if udp:
self.s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
else:
self.s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.s.settimeout(3)
self.msg = ""
self.usewheel = verbose
def start(self):
index = 0
wheel = ["\\\b", "|\b", "/\b", "-\b"]
self.status = -1
try:
self.s.connect(self.address)
except socket.timeout, e:
self.msg = "failed to connect"
return
j = 0
buf = ''
for i in range(0, self.length):
while not isprint(j & 0x7F):
j = j + 1
buf = buf + chr(j & 0x7F)
j = j + 1
if self.usewheel:
sys.stdout.write(wheel[index])
if (self.udp):
self.s.send(' !"#')
for i in range(0, self.numblocks):
try:
self.s.send(buf)
except socket.timeout, e:
self.msg = "Data socket timed out sending block %d." % i
return
index = (index + 1) & 0x3
if self.usewheel:
sys.stdout.write(wheel[index])
sys.stdout.flush()
def processInput(self,key): if(ascii.isprint(key) or ascii.isspace(key)): self.text=self.text + chr(key) return True if(key==ascii.DEL): self.text=self.text[:-1] return True return False
def unicode_to_alpha(uni):
'''
Convert a six-dot Unicode Braille character to a SimBraille one.
Printable ASCII is returned unchanged. Unprintable ASCII not allowed.
'''
if ASCII.isprint(uni):
return uni
return mapping[ord(uni) - UNICODE_BRAILLE_BASE]
def printable(input):
r = []
for char in input:
if isprint(char):
r += char
else:
r += "."
return ''.join(r)
def processInput(self, key):
if (ascii.isprint(key) or ascii.isspace(key)):
self.text = self.text + chr(key)
return True
if (key == ascii.DEL):
self.text = self.text[:-1]
return True
return False
def printable(input):
r = []
for char in input:
if isprint(char):
r += char
else:
r += "."
return ''.join(r)
def rawText(i):
s = ""
while not isControl(x[i]):
if ca.isprint(x[i]):
s += x[i]
else:
s += '\\x%02x' % ord(x[i])
i += 1
return (s, i)
def sfdisk_escape_string(value: str):
chars = []
for char in map(chr, value.encode("utf-8")):
if not isprint(char) or iscntrl(char) or char in ['"', "\\", "`", "$"]:
hex_val = hex(int(char))
chars.append(f"\\x{hex_val}")
else:
chars.append(char)
return '"' + "".join(chars) + '"'
def is_printable(c):
'''see if a character is printable'''
global have_ascii
if have_ascii:
return ascii.isprint(c)
if isinstance(c, int):
ic = c
else:
ic = ord(c)
return ic >= 32 and ic <= 126
def is_printable(c):
'''see if a character is printable'''
global have_ascii
if have_ascii:
return ascii.isprint(c)
if isinstance(c, int):
ic = c
else:
ic = ord(c)
return ic >= 32 and ic <= 126
def main(self, scr):
self.init_colors()
self.scr = scr
for song in self.songs:
self.filename = song
self.selected_line = 0
self.song = irank.Song(song)
self.draw()
logging.debug("editing song: %s" % (song,))
def save():
logging.debug("Saving file %s with comment: %s" % (
self.filename, self.song.values.flatten()))
self.song.save()
while True:
ch = self.scr.getch()
if ch == ascii.NL:
save()
break
elif ch == curses.KEY_UP or ch == ord('k'):
self.select(PREVIOUS)
elif ch == curses.KEY_DOWN or ch == ord('j'):
self.select(NEXT)
elif ch == curses.KEY_LEFT or ch == ord(' ') or ch == ord('h'):
self.add_rating(-1)
elif ch == curses.KEY_RIGHT or ch == ord('l'):
self.add_rating(1)
elif ch == curses.KEY_HOME or ch == ord('g'):
self.move_to(0)
elif ch == curses.KEY_END or ch == ord('G'):
self.move_to(len(self.song.values)-1)
elif ch == ascii.ESC:
break
elif ch == ascii.EOT: # ctrl-D
return
elif ascii.isprint(ch) and ascii.unctrl(ch) in "12345":
self.set_rating(int(ascii.unctrl(ch)))
elif ascii.isprint(ch) and ascii.unctrl(ch) == '`':
self.set_rating(0)
self.draw()
def main(self, scr):
self.init_colors()
self.scr = scr
for song in self.songs:
self.filename = song
self.selected_line = 0
self.song = irank.Song(song)
self.draw()
logging.debug("editing song: %s" % (song, ))
def save():
logging.debug("Saving file %s with comment: %s" %
(self.filename, self.song.values.flatten()))
self.song.save()
while True:
ch = self.scr.getch()
if ch == ascii.NL:
save()
break
elif ch == curses.KEY_UP or ch == ord('k'):
self.select(PREVIOUS)
elif ch == curses.KEY_DOWN or ch == ord('j'):
self.select(NEXT)
elif ch == curses.KEY_LEFT or ch == ord(' ') or ch == ord('h'):
self.add_rating(-1)
elif ch == curses.KEY_RIGHT or ch == ord('l'):
self.add_rating(1)
elif ch == curses.KEY_HOME or ch == ord('g'):
self.move_to(0)
elif ch == curses.KEY_END or ch == ord('G'):
self.move_to(len(self.song.values) - 1)
elif ch == ascii.ESC:
break
elif ch == ascii.EOT: # ctrl-D
return
elif ascii.isprint(ch) and ascii.unctrl(ch) in "12345":
self.set_rating(int(ascii.unctrl(ch)))
elif ascii.isprint(ch) and ascii.unctrl(ch) == '`':
self.set_rating(0)
self.draw()
def operate(self, c):
# Add a character.
if ascii.isprint(c):
self.tag_redraw()
self._text += chr(c)
# Delete a character.
elif c in {ascii.BS, ascii.DEL, curses.KEY_BACKSPACE}:
self.tag_redraw()
self._text = self._text[:-1]
return 'CONTINUE'
def event(self, ev, c):
if ascii.isprint(ev):
self.text += c
elif ev in [curses.KEY_BACKSPACE, KEY_BACKSPACE]:
self.text = self.text[:-1]
elif ev in [curses.KEY_ENTER, KEY_ENTER]:
curses.curs_set(0)
logging.debug("LineInput: Enter pressed, {} callbacks".format(len(self.ready_callbacks)))
for cb in self.ready_callbacks:
cb(self.text)
else:
self.text += c
def event(self, ev, c):
if ascii.isprint(ev):
self.text += c
elif ev in [curses.KEY_BACKSPACE, KEY_BACKSPACE]:
self.text = self.text[:-1]
elif ev in [curses.KEY_ENTER, KEY_ENTER]:
curses.curs_set(0)
logging.debug("LineInput: Enter pressed, {} callbacks".format(len(self.ready_callbacks)))
for cb in self.ready_callbacks:
cb(self.text)
else:
self.text += c
def getPrintable(line, keepNewlines = True):
"""
Provides the line back with non-printable characters stripped.
Arguments:
line - string to be processed
stripNewlines - retains newlines if true, stripped otherwise
"""
line = line.replace('\xc2', "'")
line = "".join([char for char in line if (isprint(char) or (keepNewlines and char == "\n"))])
return line
def getPrintable(line, keepNewlines = True):
"""
Provides the line back with non-printable characters stripped.
Arguments:
line - string to be processed
stripNewlines - retains newlines if true, stripped otherwise
"""
line = line.replace('\xc2', "'")
line = "".join([char for char in line if (isprint(char) or (keepNewlines and char == "\n"))])
return line
def printable(input):
'''!
Filter out non-printable characters from an input string
@param input (str) Input string
@return String with non-printable characters removed
None if invalid input data type
'''
if input is not None and isString(input):
return ''.join(char for char in input if isprint(char))
else:
return None
def clean(text):
try:
clean_text = str(''.join(
(ascii.isprint(c) and c) or
((c == '\n' or c == '\r') and '\n') or
'?' for c in text
))
# curses.unctrl(c) for c in text
return clean_text
except Exception as ex:
print ('WARNING: Unexpected error encountered in %s' %
inspect.stack()[0][3])
raise # Don't catch all without raising
def DumpHex(str, fmt, address, size):
out_fmt = {
'B' : '{:02x} ',
'H' : '{:04x} ',
'I' : '{:08x} ',
'Q' : '{:16x} '
}
out_unknown = {
'B' : 'xx ',
'H' : 'xxxx ',
'I' : 'xxxxxxxx ',
'Q' : 'xxxxxxxxxxxxxxxx '
}
out_size = {
'B' : 1,
'H' : 2,
'I' : 4,
'Q' : 8
}
#Adjust size to have enough for the type of data requested.
if (size%out_size[fmt] != 0):
size += out_size[fmt]-(size%out_size[fmt])
mem = ReadMemory(address, size)
j = 0
hex_str = "{:08x}: ".format(address);
chr_str = ""
# Output the data read from memory
while (size > j):
# Print the data
if (j%out_size[fmt] == 0):
hex_str += out_fmt[fmt].format(unpack_from(fmt, mem, j)[0])
byte = chr(unpack_from("B", mem, j)[0])
if (isprint(byte)):
chr_str += byte
else:
chr_str += '.'
j += 1
if (j%16 == 0):
print str + hex_str + chr_str
hex_str = "{:08x}: ".format(address+j);
chr_str = ""
#Take care of any trailing data.
if (j%16 != 0):
while (j%16 != 0):
if (j%out_size[fmt] == 0):
hex_str += out_unknown[fmt]
chr_str += "."
j += 1;
print str + hex_str + chr_str
def alpha_to_unicode(alpha):
'''
Convert an alpha to a Unicode character.
'''
alpha = alpha.upper()
try:
if ASCII.isprint(alpha): # includes ASCII space, 0x20
return chr(UNICODE_BRAILLE_BASE + mapping.index(alpha))
elif ASCII.isspace(alpha):
return alpha
else:
return chr(UNICODE_BRAILLE_BASE)
except ValueError:
return 0
def run(self, text, text2 = ''):
text = VLength.run(self, text, text2)
if text is None:
return None
try:
if all(isprint(str(x)) for x in text):
return str(text)
except UnicodeEncodeError:
pass
self.set_error(errors.BAD_STRING)
return None
def get_printable(line, keep_newlines = True):
"""
Provides the line back with non-printable characters stripped.
:param str line: string to be processed
:param str keep_newlines: retains newlines if **True**, stripped otherwise
:returns: **str** of the line with only printable content
"""
line = line.replace('\xc2', "'")
line = filter(lambda char: isprint(char) or (keep_newlines and char == '\n'), line)
return line
def parse(self):
def tab(white_count, line):
self.space(white_count, line)
if not self.allow_tabs:
self.error.incr('tab')
def carriage_return(white_count, line):
self.error.incr('eol-cr')
self.eol(white_count, line)
def line_feed(white_count, line):
if not self.window.matches('\r\n'):
self.eol(white_count, line)
class line():
def invalidate(self, string):
remove = -len(string)
if (string == ''.join(self.content[remove:])):
del self.content[remove:]
line = line()
line.number = 1
line.content = []
white_count = 0
whitespace = {
' ': self.space,
'\t': tab,
'\r': carriage_return,
'\n': line_feed
}
for char in open(self.path, 'rb').read():
self.window.add(char)
try:
whitespace[char](white_count, line)
self.in_url = False
except KeyError:
if not isprint(char):
self.error.incr('non-ascii')
if self.window.matches(self.url_preface):
line.invalidate(self.url_preface[:-1])
self.in_url = True
if not self.in_url and self.is_valid(self.window):
line.content.append(char)
white_count = 0
if line.content:
self.eol(white_count, line)
return self.report()
def _get_packet(self, timeout=0.1) -> Tuple[str, str]:
"""Get the next packet, along with an isoformat dt string."""
if self.fake_port:
raw_packet = self.fake_port.readline().strip()
if raw_packet:
packet_dt = raw_packet[:26]
raw_packet = raw_packet[27:]
else:
return "EOF", None
else:
self.ser.timeout = timeout
try:
raw_packet = self.ser.readline().decode("ascii").strip()
except UnicodeDecodeError:
return None, None
raw_packet = "".join(char for char in raw_packet if isprint(char))
if not raw_packet:
return None, None
if not isinstance(raw_packet, str):
_LOGGER.warning("Packet datatype is not a string, >> %s <<", raw_packet)
return None, None
packet_dt = dt.now().isoformat()
if self._packet_log:
self._packet_log.write(f"{packet_dt} {raw_packet}\r\n")
if not MESSAGE_REGEX.match(raw_packet):
_LOGGER.warning("Packet structure is not valid, >> %s <<", raw_packet)
return None, None
if len(raw_packet[50:]) != 2 * int(raw_packet[46:49]):
_LOGGER.warning("Packet payload length is not valid, >> %s <<", raw_packet)
return None, None
if int(raw_packet[46:49]) > 48:
_LOGGER.warning("Packet payload length is excessive, >> %s <<", raw_packet)
return None, None
return raw_packet, packet_dt
def __init__(self, *args, **kwargs):
super(DhcpOptionToDhcpGroupAdminForm, self).__init__(*args, **kwargs)
if self.instance:
printable = True
if self.instance.value:
for c in self.instance.value:
if not isprint(c):
printable = False
break
if printable:
self.fields['readable_value'].initial = self.instance.value
else:
self.fields['readable_value'].initial = '0x' + binascii.hexlify(self.instance.value)
self.original_value = self.fields['readable_value'].initial
def hexdump(data, indent):
res = ''
for i in range(0, len(data), 16):
if i:
for k in range(0, indent):
res += ' '
for j in range(i, min(i + 16, len(data))):
res += '{0:02x} '.format(ord(data[j]))
for k in range(min(i + 16, len(data)), i + 16):
res += ' '
for j in range(i, min(i + 16, len(data))):
if ascii.isprint(data[j]):
res += data[j]
else:
res += '.'
res += '\n'
return res
def handle_input(self, input_key):
'''
For each keystroke, determine if it's a special character (and needs
to end editing), printable character, or backspace.
For special characters, send the return the done-editing code (CTRL-G),
and store the special character for processing by parent window
objects.
If printable, append it to self.text, and try to validate. If
validation fails, reject the character.
'''
input_key = self.translate_input(input_key)
if self.is_special_char(input_key):
self.input_key = input_key
return EditField.CMD_DONE_EDIT
else:
self.input_key = None
if isprint(input_key) or (ismeta(input_key) and
input_key < curses.KEY_MIN):
# isprint: ASCII characters
# ismeta and < curses.KEY_MIN: Remaining UTF-8 characters
# > curses.KEY_MIN: Special key such as down arrow, backspace, etc.
self.text.append(unichr(input_key))
if not self.is_valid():
if len(self.text) > 0:
self.text.pop()
return None
self._modified = True
if self.masked:
input_key = self.masked_char
elif input_key == curses.KEY_BACKSPACE:
if len(self.text) > 0:
del_char = self.text.pop()
self._modified = True
del_width = charwidth(del_char)
if textwidth(self.get_text()) >= self.area.columns:
self.scroll(columns=-del_width)
self.is_valid()
# Run self.is_valid here so that any functional side effects can
# occur, but don't check the return value (removing a character
# from a valid string should never be invalid, and even if it were,
# it would not make sense to add the deleted character back in)
return input_key
def run(self):
while 1:
ch = self.screen.getch()
if ch != -1:
if ch == ord('\n'):
msg = self.input_line.data
self.add_line(Line('chat', msg, timestamp=True))
self.server.privmsg(self.room, msg)
self.input_line.clear_data()
self._draw_input()
elif ch == 127: #backspace
self.input_line.backspace()
self._draw_input()
elif isprint(ch):
self.input_line.add_ch(chr(ch))
self.irc.process_once()
def display(self):
for i in range(len(self.data)):
if i % 10 == 0:
self.disp_cols_helper()
u = xorpad(self.data[i], self.pad)
sanitized = bytearray()
for c in u:
if not isprint(c):
sanitized.append(ord('?'))
else:
sanitized.append(c)
print('{row:{width}d}{space:{space_width}}{content}'.format(
width=self.left_margin - 2,
space_width=2,
space='',
row=i,
content=sanitized.decode()))
def check_payload(self, test):
from curses.ascii import isprint
if os.path.isfile(test):
with open(test, "r") as ins:
for line in ins:
result = self.browser_socket_handler.query(''.join(
[x for x in line if isprint(x)]))
if result:
self.result = self.result + "\n" + line
elif os.path.exists(self.configuration['INPUT']):
for name in os.listdir(self.configuration['INPUT']):
self.check_payload(self.configuration['INPUT'] + "/" + name)
else:
self.result = self.browser_socket_handler.query(
self.configuration['INPUT'])
pass
def process_input(self, ch):
if isprint(ch):
self._set_term(self._term + chr(ch))
elif ch in (BS, KEY_BACKSPACE):
self._set_term(self._term[:-1])
elif unctrl(ch) == "^W":
self._set_term(self._strip_last_word(self._term))
elif unctrl(ch) == "^N":
self._set_match_highlight(self._match_highlight + 1)
elif unctrl(ch) == "^P":
self._set_match_highlight(self._match_highlight - 1)
elif ch in (KEY_ENTER, CR, LF):
return ("select", self._get_selected_item())
elif ch in (ESC, ) or unctrl(ch) in ("^C", "^G"):
return ("abort", self._get_selected_item())
elif ch == TAB and self._tab_exits:
return ("tab", self._get_selected_item())
def handle_input(self, input_key):
'''
For each keystroke, determine if it's a special character (and needs
to end editing), printable character, or backspace.
For special characters, send the return the done-editing code (CTRL-G),
and store the special character for processing by parent window
objects.
If printable, append it to self.text, and try to validate. If
validation fails, reject the character.
'''
input_key = self.translate_input(input_key)
if self.is_special_char(input_key):
self.input_key = input_key
return EditField.CMD_DONE_EDIT
else:
self.input_key = None
if isprint(input_key) or (ismeta(input_key)
and input_key < curses.KEY_MIN):
# isprint: ASCII characters
# ismeta and < curses.KEY_MIN: Remaining UTF-8 characters
# > curses.KEY_MIN: Special key such as down arrow, backspace, etc.
self.text.append(unichr(input_key))
if not self.is_valid():
if len(self.text) > 0:
self.text.pop()
return None
self._modified = True
if self.masked:
input_key = self.masked_char
elif input_key == curses.KEY_BACKSPACE:
if len(self.text) > 0:
del_char = self.text.pop()
self._modified = True
del_width = charwidth(del_char)
if textwidth(self.get_text()) >= self.area.columns:
self.scroll(columns=-del_width)
self.is_valid()
# Run self.is_valid here so that any functional side effects can
# occur, but don't check the return value (removing a character
# from a valid string should never be invalid, and even if it were,
# it would not make sense to add the deleted character back in)
return input_key
def hexdump(data, indent):
res = ''
for i in range(0, len(data), 16):
if i:
for k in range(0, indent):
res += ' '
for j in range(i, min(i + 16, len(data))):
res += '{0:02x} '.format(ord(data[j]))
for k in range(min(i + 16, len(data)), i + 16):
res += ' '
for j in range(i, min(i + 16, len(data))):
if ascii.isprint(data[j]):
res += data[j]
else:
res += '.'
res += '\n'
return res
def on_key(self, ch) -> bool:
if self is self.container.focus:
cmd = self.cmd.get(ch)
if cmd is not None:
cmd()
self._cursor_refresh()
return True
elif isinstance(ch, str):
if _ascii.isascii(ch):
if _ascii.isprint(ch):
self.add_char(ch)
self._cursor_refresh()
return True
else:
self.add_char(ch)
self._cursor_refresh()
return True
return False
def dump_vendor():
# SFF-8472 Table 4-1
# bytes 96-127
vendor_hex = ""
vendor_isprint = ""
for byte in range (96, 128):
vendor_hex=vendor_hex +('%-2.2x' % sff_data[byte])
v_char = '%c' % sff_data[byte];
if (isprint(v_char)):
vendor_isprint = vendor_isprint + v_char;
else:
vendor_isprint = vendor_isprint + ' ';
print vendor_hex
print vendor_isprint
def add_data(self, data, color = None):
global Colors
newdata = ""
for ch in str(data):
#printable characters and \t \n and are output to the screen
#all others are hexlified
if ascii.isprint(ch) or ch == "\t" or ch == "\n":
newdata += ch
else:
newdata += "\\" + str(hex(ord(ch)))[1:]
if color is None:
dcolor = Colors.YELLOW
if self.evencolor:
dcolor = Colors.CYAN
self.evencolor = not self.evencolor
else:
dcolor = Colors.get_color(color)
self.data.append([newdata, dcolor])
def run( self ):
print ''.join(["Listening for input on ", self.tty.ser.port, " in new thread."])
while(1):
self.ttylock.acquire()
#wait for a single character
char = self.tty.read()
#if no input, just wait
if( char == '' ):
pass
# if user hit ctrl-c, erase buffer
elif( char == '\x03'):
self.clearbuffer()
self.tty.write('\r\n')
self.linepos = 0
#if user hit enter, send message
elif( char == '\r' ):
self.tty.write('\r\n')
self.notify( self.textbuffer )
self.clearbuffer()
self.linepos = 0
#if buffer is full, beep
elif( self._maxbuf > 0 and len( self.textbuffer ) >= self._maxbuf ):
self.tty.write('\x07')
#if character is printable and buffer not full, echo it and add to buffer
elif( isprint( char ) ):
self.textbuffer = ''.join( [ self.textbuffer, char ] )
self.tty.write( char )
self.linepos += 1
# Wrap input lines if they are greater than
# 60 columns. This wan't necessary on the TI-745
# because it would wrap automatically
if self.linepos > self._columns:
self.tty.write( '\r\n' )
self.linepos = 0
self.ttylock.release()
time.sleep(0.01)
def _XMLContentFilter (self, content, was_array_typecode=None) :
result = "" # RVO
typecode = { float:'d', complex:'D' }
type_content = type(content)
if was_array_typecode != None :
t = pretty.NumericString_(was_array_typecode, content)
elif type_content in [float, complex] :
t = pretty.NumericString_(typecode[type_content], content)
elif type_content == long :
t = repr(content)
else :
t = str(content)
for ii in xrange(0,len(t)) :
c = t[ii]
if not isprint(c) :
result += "&#"+hex(ord(c))[1:]+";"
else :
if c in self.specialCharToEscapeSeq_ :
esc_seq = self.specialCharToEscapeSeq_[t[ii]]
result = result + esc_seq
else :
result = result + t[ii]
return result
def M2Image (s) :
'''code from m2k to output a string with m2k understanding of literals'''
global M2ImageLookup
# The final result
result = ""
ender = ""
# Start of with a quote
result += '"'
# Go through, looking for special sequences and output
for c in s :
if c in M2ImageLookup :
ender = M2ImageLookup[c]
elif isprint(c) :
ender = c
else :
# Build a hexadecimal escape sequence. The output is always
# going to be a \x followed by 2 hex digits
ender = hex(ord(c))
result += ender
# End with a quote
result += '"'
return result
def _input_iteration(self):
ch = self.mainscr.getch()
if QUITTING_TIME.isSet(): return False
logging.debug("input: %r (%s / %s, ctrl=%s)" % (ch, ascii.unctrl(ch), ascii.ctrl(ch), ascii.isctrl(ch)))
if ascii.isprint(ch):
self.add_char(chr(ch))
elif ch in (ascii.BS, ascii.DEL, curses.KEY_BACKSPACE):
self.remove_char()
elif ch == ascii.NL:
self.open_selected()
elif ch == curses.KEY_UP or (ascii.ismeta(ch) and ascii.unctrl(ch) == 'a'): # shift+tab???
self.select(PREVIOUS)
elif ch == curses.KEY_DOWN or ch == curses.ascii.TAB:
self.select(NEXT)
elif ch == curses.KEY_LEFT:
self.move_cursor(backwards=True)
elif ch == curses.KEY_RIGHT:
self.move_cursor()
elif ch == curses.KEY_HOME:
self.move_cursor_to(0)
elif ch == curses.KEY_END:
self.move_cursor_to(len(self.query))
elif ascii.isctrl(ch) and ascii.ctrl(ch) in (ascii.STX, ascii.ETX, ascii.CAN, ascii.ETX): # ctrl-c, variously o_O
logging.debug("copy to clipboard")
self.copy_selected_path_to_clipboard()
elif ch == ascii.ESC:
self.set_query("")
elif ch == ascii.EOT: # ctrl-D
logging.debug("EOF")
return False
else:
logging.debug("not handled...")
self.ui_lock.acquire()
self.update()
self.ui_lock.release()
return True
def printable(self,theinput): return ''.join([char for char in theinput if isprint(char)])
return 'e'
else:
#print "Mode of list:", maxitem
return maxitem
lcase = range(ord('a'), ord('z')+1)
print map(chr, lcase)
inums = []
with open('cipher1.txt', 'r') as f:
for line in f:
snums = line.split(',')
inums.extend(map(int, snums))
print inums
for key1 in lcase:
for key2 in lcase:
for key3 in lcase:
xorkey = [key1, key2, key3]
newstring = []
for i,inum in enumerate(inums):
newstring.append(chr(inum ^ xorkey[i % 3]))
# mode = print_mode(newstring)
# if (mode == 'e'):
printable = map(lambda x: isprint(x) or (x == '\n'), newstring)
if (all(printable)):
mode = print_mode(newstring)
if (mode == 'e' or mode == ' ' or mode == 't' or mode == 'a'):
print map(chr,xorkey), ''.join(newstring)
print 'Sum:', sum(map(ord, newstring))
def get_utf8_string (self):
# This method replaces curses getstr in case of utf8
# encoding. The problem with original getstr is that
# it treats multi-byte utf8 character as {2-6} bytes,
# which leads to the wrong behaviour when handling
# backspace key. Backspace key deletes exactly one
# byte, so user has to press the key 2-6 times.
#
# In this method we analyze if a character starts
# a multi-byte, and read the correct number of bytes
# for the symbol. We adjust backspace to delete the
# last utf8 character we read. We reject any ascii
# service symbol like ESC, F1, etc, by applying
# ascii.isprint.
# FIXME: Is it a valid check for utf-8 encoding?
assert default_charset == 'UTF-8'
ss = []
while True:
c = self.screen.getch ()
# xterm passes backspace hit as curses.KEY_BACKSPACE,
# other terminals pass it as ascii.BS or ascii.DEL.
# So here we unify backspace to ascii.BS and
# Skip any other service symbol, like F1, KEY_UP, etc
if c == curses.KEY_BACKSPACE:
c = ascii.BS
elif c > 0xff:
continue
# In utf8 every multi-byte symbol starts with a byte
# that encodes the number of symbols. Here is a table:
# Bytes Max value First byte (binary)
# 1 0x7f 0xxxxxxx
# 2 0x7ff 110xxxxx
# 3 0xffff 1110xxxx
# 4 0x1fffff 11110xxx
# 5 0x3ffffff 111110xx
# 6 0x7fffffff 1111110x
#
# So in essence, the first position of '0' bit if
# counting from the left hand side is a number of
# bytes in a utf8 multi-char.
byte_count = 0
for i in xrange (8):
if not bool (c & (1 << (7 - i))):
byte_count = i;
break;
# Now when we know a number of bytes, we have to call
# getch() byte_count - 1 times, in order to read the
# whole character.
if byte_count > 6 or byte_count == 1:
raise Exception ("invalid utf8 leading character")
c = [c]
if byte_count >= 2:
for i in xrange (byte_count - 1):
c.append (self.screen.getch ())
# Create a string from the list of bytes.
cc = "".join ([chr (x) for x in c])
# String is done, if user hit ENTER.
if cc == chr (ascii.NL):
break
# In case of backspace, delete the last character
# or continue if input is empty.
if cc in (chr (ascii.DEL), chr (ascii.BS)):
if len (ss) == 0:
continue
ss.pop ()
y, x = curses.getsyx ()
self.screen.move (y, x - 1)
self.screen.delch ()
continue
# Do not save character, if it is something
# non-printable, like ESC or similar.
if len (cc) == 1 and not ascii.isprint (ord (cc)):
continue
# Append symbol to the list of symbols and put
# it on the screen.
ss.append (cc)
self.screen.addstr (cc)
# Combine characters from list `ss' into a string
return "".join (ss)
def _needescape(c):
"""
Return True if character needs escaping, else False.
"""
return not ascii.isprint(c) or c == '"' or c == '\\' or ascii.isctrl(c)
def printable (str):
from curses.ascii import isprint
return ''.join([char for char in str if isprint(char)])
