Integrate GapString and a few tweaks

__init__.py

@@ -10,12 +10,20 @@ def unpack(fmt, buf):
     """Unpack buf based on fmt, return the rest as a string."""
 
     size = struct.calcsize(fmt)
-    vals = struct.unpack(fmt, buf[:size])
+    vals = struct.unpack(fmt, str(buf[:size]))
     return vals + (buf[size:],)
 
 
-def to_printable(c):
+class HexDumper:
-    if c in printable:
+    def __init__(self, fd=sys.stdout):
+        self.fd = fd
+        self.offset = 0
+        self.buf = []
+
+    def _to_printable(self, c):
+        if not c:
+            return '◆'
+        elif c in printable:
             return c
         elif c == '\0':
             return '␀'
@@ -27,30 +35,57 @@ def to_printable(c):
             return '·'
 
 
+    def _flush(self):
+        if not self.buf:
+            return
+
+        o = []
+        for c in self.buf:
+            if c:
+                o.append('%02x' % ord(c))
+            else:
+                o.append('--')
+        o +=  (['  '] * (16 - len(self.buf)))
+        p = [self._to_printable(c) for c in self.buf]
+
+        self.fd.write('%08x  ' % self.offset)
+
+        self.fd.write(' '.join(o[:8]))
+        self.fd.write('  ')
+        self.fd.write(' '.join(o[8:]))
+
+        self.fd.write('  ║')
+
+        self.fd.write(''.join(p))
+
+        self.fd.write('║\n')
+
+        self.buf = []
+        self.offset += 16
+
+    def dump_chr(self, c):
+        self.buf.append(c)
+        if len(self.buf) == 16:
+            self._flush()
+
+    def dump_drop(self):
+        self.buf.append(None)
+        if len(self.buf) == 16:
+            self._flush()
+
+    def finish(self):
+        self._flush()
+        self.fd.write('%08x\n' % self.offset)
+
+
 def hexdump(buf, f=sys.stdout):
     "Print a hex dump of buf"
 
-    offset = 0
+    d = HexDumper()
 
-    while buf:
+    for c in buf:
-        s = buf[:16]
+        d.dump_chr(c)
-        o = [('%02x' % ord(c)) for c in s] + (['  '] * (16 - len(s)))
+    d.finish()
-        p = [to_printable(c) for c in s]
-
-        f.write('%08x  ' % offset)
-
-        f.write(' '.join(o[:8]))
-        f.write('  ')
-        f.write(' '.join(o[8:]))
-
-        f.write('  ║')
-
-        f.write(''.join(p))
-
-        f.write('║\n')
-
-        buf = buf[16:]
-        offset += 16
 
 
 def cstring(buf):

crypto.py

@@ -186,11 +186,10 @@ tabula_recta = caesars('ABCDEFGHIJKLMNOPQRSTUVWXYZ')
 
 
 def xor(n, txt):
-    out = ''
+    if n == 0:
-    for c in txt:
+        return txt
-        o = ord(c) ^ n
+    out = [(chr(ord(c) ^ n)) for c in txt]
-        out += chr(o)
+    return ''.join(out)
-    return out
 
 def xors(txt):
     ret = []

gapstr.py

@@ -48,7 +48,7 @@ class GapString:
             else:
                 for c in i:
                     d.dump_chr(c)
-        d.flush()
+        d.finish()
 
     def extend(self, other):
         self.contents += other.contents
@@ -56,10 +56,14 @@ class GapString:
 
     def __getslice__(self, start, end):
         end = min(self.length, end)
+        start = min(self.length, start)
 
         new = self.__class__(self.drop)
         new.contents = self.contents[:]
         new.length = end - start
+        if new.length == 0:
+            return new
+
         l = self.length - new.length - start
 
         # Trim off the beginning

ip.py

@@ -5,6 +5,7 @@ import struct
 import socket
 import warnings
 import heapq
+import gapstr
 
 
 def unpack(fmt, buf):
@@ -110,18 +111,13 @@ class Frame:
                                                         self.dst_addr, self.dport,
                                                         len(self.payload))
 
+
 class Chunk:
     """Chunk of frames, possibly with gaps.
 
-    Currently, gaps show up as a string of 0x33, ascii '3'.
-
     """
 
-    def __init__(self, seq=None, drop='3'):
+    def __init__(self, seq=None):
-        # chr(0x33) == '3'.  If you see a bunch of 3s, in the ascii or
-        # the hex view, suspect a drop.
-        assert len(drop) == 1, "Don't yet support len(drop) > 1"
-        self.drop = drop
         self.collection = {}
         self.length = 0
         self.seq = seq
@@ -150,25 +146,35 @@ class Chunk:
         else:
             return '<Chunk (no frames)>'
 
-    def __str__(self):
+    def gapstr(self, drop='?'):
-        s = ''
+        """Return contents as a GapString"""
-        while len(s) < self.length:
+
-            f = self.collection.get(self.seq + len(s))
+        ret = gapstr.GapString(drop)
+        while len(ret) < self.length:
+            f = self.collection.get(self.seq + len(ret))
             if f:
-                s += f.payload
+                ret.append(f.payload)
             else:
-                # This is where to fix it for len(drop) > 1.
+                # This is where to fix big inefficiency for dropped packets.
-                # This is also where to fix big inefficiency for dropped packets.
+                l = 1
-                s += self.drop
+                while ((len(ret) + l < self.length) and
-        return s
+                       (not (self.seq + len(ret) + l) in self.collection)):
+                    l += 1
+                ret.append(l)
+        return ret
+
+    def __str__(self):
+        return str(self.gapstr())
 
     def extend(self, other):
         self.seq = min(self.seq or other.seq, other.seq)
-        for frame in other.collection.itervalues():
+        self.length = self.length + other.length
-            self.add(frame)
+        if not self.first:
+            self.first = other.first
+        self.collection.update(other.collection)
 
     def __add__(self, next):
-        new = self.__class__(self.seq, self.drop)
+        new = self.__class__(self.seq)
         new.extend(self)
         new.extend(next)
         return new