Correct Python2 b'..' comparisons

Author: pjkundert

automata.py

@@ -279,13 +279,12 @@ def __repr__( self ):
         return '<%s>' % ( self )
 
     def __call__( self, machine=None, source=None, path=None, data=None ):
-        return self.execute(
-            truth=self.predicate( machine=machine, source=source, path=path, data=data ),
-            machine=machine, source=source, path=path, data=data )
+        truth			= self.predicate( machine=machine, source=source, path=path, data=data )
+        return self.execute( truth, machine=machine, source=source, path=path, data=data )
 
     def execute( self, truth, machine=None, source=None, path=None, data=None ):
         target			= self.state if truth else None
-        #log.debug( "%s %-13.13s -> %10s w/ data: %r", machine.name_centered(), self, target, data )
+        #log.debug( "%s %-13.13s -> %10s w/ truth: %r data: %r", machine.name_centered(), self, target, truth, data )
         return target
 
 
@@ -777,7 +776,7 @@ def transition( self, source, machine=None, path=None, data=None, ending=None ):
         """
         limited			= ending is not None and source.sent >= ending
         while not self.terminal or self.greedy:
-            inp			= None if limited else source.peek()# raise TypeError to force stoppage
+            inp			= None if limited else source.peek()  # raise TypeError to force stoppage
             try:
                 choice		= self.__getitem__( inp )
             except KeyError:
@@ -792,25 +791,25 @@ def transition( self, source, machine=None, path=None, data=None, ending=None ):
                     yield machine,None			# 0+ non-transitions...
                     continue
                 break					# No other transition possible; done
+            if type( choice ) is not list:
+                choice		= [ choice ]
 
             # Found the transition or choice list (could be a state, a decide or decide, ...,
             # decide[, state]). Evaluate each target state/decide instance, 'til we find a
             # state/None.  Even decides could end up yielding None, if all decide evaluate to None,
             # and no non-None default state .
-            for potential in ( choice if type( choice ) is list else [ choice ] ):
+            for potential in choice:
                 if potential is None or isinstance( potential, state ):
                     target	= potential
                     break
                 try:
-                    #log.debug( "%s <selfdecide> on %s", self.name_centered(), choice )
+                    #log.debug( "%s <selfdecide> on %s", self.name_centered(), potential )
                     target	= potential( # this decision is made in our parent machine's context
                         source=source, machine=machine, path=path, data=data )
                 except Exception as exc:
-                    log.warning( "%s <selfdecide> on %s failed: %r", self.name_centered(),
-                                 potential, exc )
+                    log.warning( "%s <selfdecide> on %s failed: %r", self.name_centered(), potential, exc )
                     raise
-                #log.debug( "%s <selfdecide> on %s == %s", self.name_centered(),
-                #           potential, target )
+                #log.debug( "%s <selfdecide> on %s == %s", self.name_centered(), potential, target )
                 if target:
                     break
 

server/enip/parser.py

@@ -1246,36 +1246,36 @@ def __init__( self, name=None, **kwds ):
         # carry the same server == 0xD2 and status coded.
         def is_uerr( path=None, data=None, source=None, **kwds ):
             log.isEnabledFor( logging.INFO ) and log.info(
-                "%s -- checking data[%r] (kwds %r) for unconnected_send error (%5s): %s",
-                self, path, kwds, data[path+'..length'] <= 6, enip_format( data ),
+                "{} -- checking data[{!r}] (kwds {!r}) for unconnected_send error ({:5}) ({}, next {!r}): {}".format(
+                self, path, kwds, data[path+'..length'] <= 6, source, source.peek(), enip_format( data ) )
             )
-            if data[path+'..length'] > 6:
-                return False
-            # Might be a Unconnected Send error, perhaps with a remaining path size; peek at the
-            # error code and extended status; if the code is < 0x10 and there is NO extended status,
-            # then it must *not* be a Read Tag Fragmented error code, as ALL of its <0x10 status
-            # codes are required to have an extended status (which may be 0x0000, but must be
-            # there).  HOWEVER, there are many (many) devices that DO NOT comply with the subtleties
-            # of the ODVA EtherNet/IP CIP spec -- and simply return eg. a status = 0x05 WITHOUT a
-            # 0x0000 extended status code.  This makes it *impossible* to determine whether or not a
-            # Read Tag Fragmented response status belongs to the encapsulating Unconnected Send, or
-            # not.  The only possible option is for the CLIENT to avoid sending Read Tag Fragmented
-            # requests in an Unconnected Send, or use a Multiple Service packet to encapsulate them.
-            svc			= next( source )
-            pad			= next( source )
-            sts			= next( source )
-            ext_siz		= next( source )
-            source.push( ext_siz )
-            source.push( sts )
-            source.push( pad )
-            source.push( svc )
-            log.isEnabledFor( logging.DETAIL ) and log.detail(
-                "{} -- found an Unconnected Send response error status 0x{:02x}: {}".format(
-                    self, sts, enip_format( data ))
-            )
-            return sts < 0x10 and ext_siz == 0
+            if data[path+'..length'] <= 6:
+                # Might be a Unconnected Send error, perhaps with a remaining path size; peek at the
+                # error code and extended status; if the code is < 0x10 and there is NO extended status,
+                # then it must *not* be a Read Tag Fragmented error code, as ALL of its <0x10 status
+                # codes are required to have an extended status (which may be 0x0000, but must be
+                # there).  HOWEVER, there are many (many) devices that DO NOT comply with the subtleties
+                # of the ODVA EtherNet/IP CIP spec -- and simply return eg. a status = 0x05 WITHOUT a
+                # 0x0000 extended status code.  This makes it *impossible* to determine whether or not a
+                # Read Tag Fragmented response status belongs to the encapsulating Unconnected Send, or
+                # not.  The only possible option is for the CLIENT to avoid sending Read Tag Fragmented
+                # requests in an Unconnected Send, or use a Multiple Service packet to encapsulate them.
+                svc		= next( source )
+                pad		= next( source )
+                sts		= next( source )
+                ext_siz		= next( source )
+                source.push( ext_siz )
+                source.push( sts )
+                source.push( pad )
+                source.push( svc )
+                log.isEnabledFor( logging.DETAIL ) and log.detail(
+                    "{} -- found an Unconnected Send response error status {!r} ({}, next {!r}): {}".format(
+                        self, sts, source, source.peek(), enip_format( data ) )
+                )
+                if sts < b'\x10'[0] and ext_siz == b'\x00'[0]:  # Python 2/3 compatible b'..' comparisons
+                    return True
 
-        othr			= octets(	context='request', terminal=True )
+        othr			= octets( 'usnd_req', context='request', terminal=True )
         othr[True]		= othr
 
         slct[b'\x52'[0]]	= usnd