def add_payload(self, payload):
     if self.underlayer and isinstance(self.underlayer, TCP):
         if isinstance(payload, (SOCKS5Request, SOCKS4Request)):
             self.underlayer.dport = 1080
         elif isinstance(payload, (SOCKS5Reply, SOCKS4Reply)):
             self.underlayer.sport = 1080
     Packet.add_payload(self, payload)

 def __init__(self, *args, **fields):
     try:
         self.tls_ctx = fields["ctx"]
         del(fields["ctx"])
     except KeyError:
         self.tls_ctx = None
     Packet.__init__(self, *args, **fields)

    def __process_packets(self, packets, out_writer, drop_writer, validation_file):
        """
        :type packets: list[Packet]
        :return A tuple with the number of packets anonymized and the number of packets dropped
        :rtype (int, int)
        """

        for index, packet in enumerate(packets):

            if index and (index % 10000) == 0:
                self.app.log.info("pcap:{}: Process packet id = '{}'".format(self.file, index))

            packet_id = index + 1  # packet id start with 1

            # packet_backup = Packet(str(packet))
            packet_backup = packet.original
            packet_backup_time = packet.time

            try:
                try:
                    if self.app.phase is Phase.phase_1:
                        self.app.packet.discover(packet)
                    elif self.app.phase is Phase.phase_3:
                        self.app.packet.anonymize(packet)
                    elif self.app.phase is Phase.phase_4:
                        validation = self.app.packet.validate(packet)
                        if validation is not None:
                            validation_file.write("\n\nPacket id {}:\n  ".format(packet_id))
                            validation = validation.replace('\n', '\n  ')  # Indent
                            validation_file.write(validation)

                except Exception as e:
                    if isinstance(e, ExplicitDropException):
                        self.app.log.debug("file:pcap:{}: Packet explicitly dropped: id = '{}', {}, {}".format(
                            self.file, packet_id, e.message, repr(packet.summary())))
                    elif isinstance(e, ImplicitDropException):
                        self.app.log.warning("file:pcap:{}: Packet implicitly dropped: id = '{}', {}, {}".format(
                            self.file, packet_id, e.message, repr(packet.summary())))
                    elif isinstance(e, ErrorDropException):
                        self.app.log.error("file:pcap:{}: Error packet dropped: id = '{}', {}, {}".format(
                            self.file, packet_id, e.message, repr(packet.summary())))
                    else:
                        self.app.log.critical("file:pcap:{}: Unexpected error packet dropped: id = '{}', {}, {}".format(
                            self.file, packet_id, e.message, repr(packet.summary())))

                    if self.app.phase is Phase.phase_3:
                        packet_backup = Packet(packet_backup)
                        packet_backup.time = packet_backup_time
                        drop_writer.write(packet_backup)

                else:
                    if self.app.phase is Phase.phase_3:
                        out_writer.write(packet)

            except Exception as e:
                self.app.log.critical(
                    "sirano:file:pcap:{}: Unexpected error: id = '{}', exception = '{}', message = '{}', {}".format(
                        self.file, packet_id, type(e), e.message, repr(packet.summary())))

 def __init__(self, *args, **fields):
     try:
         self.tls_ctx = fields["ctx"]
         del(fields["ctx"])
         self.above_tls10 = self.tls_ctx.params.negotiated.version > TLSVersion.TLS_1_0
         if self.explicit_iv_field not in self.fields_desc and self.above_tls10:
             self.fields_desc.append(self.explicit_iv_field)
         for field in self.decryptable_fields:
             if field not in self.fields_desc:
                 self.fields_desc.append(field)
     except KeyError:
         self.tls_ctx = None
     Packet.__init__(self, *args, **fields)

    def guess_payload_class(self, payload):

        try:
            dlpdu_type = payload[0]
            return EtherCat.ETHERCAT_TYPE12_DLPDU_TYPES[dlpdu_type]

        except KeyError:
            log_runtime.error(
                '{}.guess_payload_class() - unknown or invalid '
                'DLPDU type'.format(self.__class__.__name__))
            return Packet.guess_payload_class(self, payload)

        return Packet.guess_payload_class(self, payload)

    def do_build(self):
        if not isinstance(self.payload, IPv6):
            return Packet.do_build(self)
        ipv6 = self.payload

        self._reserved = 0x03

        # NEW COMPRESSION TECHNIQUE!
        # a ) Compression Techniques

        # 1. Set Traffic Class
        if self.tf == 0x0:
            self.tc_ecn = ipv6.tc >> 6
            self.tc_dscp = ipv6.tc & 0x3F
            self.flowlabel = ipv6.fl
        elif self.tf == 0x1:
            self.tc_ecn = ipv6.tc >> 6
            self.flowlabel = ipv6.fl
        elif self.tf == 0x2:
            self.tc_ecn = ipv6.tc >> 6
            self.tc_dscp = ipv6.tc & 0x3F
        else:  # self.tf == 0x3:
            pass  # no field is set

        # 2. Next Header
        if self.nh == 0x0:
            self.nh = 0  # ipv6.nh
        elif self.nh == 0x1:
            self.nh = 0  # disable compression
            # The Next Header field is compressed and the next header is encoded using LOWPAN_NHC, which is discussed in Section 4.1.  # noqa: E501
            warning('Next header compression is not implemented yet ! Will be ignored')  # noqa: E501

        # 3. HLim
        if self.hlim == 0x0:
            self._hopLimit = ipv6.hlim
        else:  # if hlim is 1, 2 or 3, there are nothing to do!
            pass

        # 4. Context (which context to use...)
        if self.cid == 0x0:
            pass
        else:
            # TODO: Context Unimplemented yet in my class
            self._contextIdentifierExtension = 0

        # 5. Compress Source Addr
        self.compressSourceAddr(ipv6)
        self.compressDestinyAddr(ipv6)

        return Packet.do_build(self)

    def post_build(self, p, pay):
        # patch the update of block_length, as requests field must not be
        # included. block_length is always 60
        if self.block_length is None:
            p = p[:2] + struct.pack("!H", 60) + p[4:]

        return Packet.post_build(self, p, pay)

 def guess_payload_class(self, payload):
     if self.type == 0x02 and (0x08 <= self.subtype <= 0xF and self.subtype != 0xD):  # noqa: E501
         return Dot11QoS
     elif self.FCfield & 0x40:
         return Dot11WEP
     else:
         return Packet.guess_payload_class(self, payload)

 def guess_payload_class(self, payload):
     if self.frame_control & 0x02: # we have a security header
         return ZigbeeSecurityHeader
     elif self.aps_frametype == 0: # data
         return ZigbeeClusterLibrary # TODO might also be another frame
     elif self.aps_frametype == 1: # command
         return ZigbeeAppCommandPayload
     else:
         return Packet.guess_payload_class(self, payload)

 def guess_payload_class(self, payload):
     if self.flags & 0x02:
         return ZigbeeSecurityHeader
     elif self.frametype == 0:
         return ZigbeeAppDataPayload
     elif self.frametype == 1:
         return ZigbeeNWKCommandPayload
     else:
         return Packet.guess_payload_class(self, payload)

 def build(self):
     # update fields that depend on values in SCSI layer
     if SCSICmd in self:
         scsicmd = self[SCSICmd].payload
         if scsicmd.default_fields.has_key("AllocationLength"):
             self.overloaded_fields.update({"ExpectedDataSize": scsicmd.AllocationLength})
         if scsicmd.default_fields.has_key("TransferLength"):
             self.overloaded_fields.update({"ExpectedDataSize": scsicmd.TransferLength * self.BLOCK_SIZE})
     return Packet.build(self)

    def guess_payload_class(self, payload):
        if len(payload) < self._min_ieo_len:
            return Packet.guess_payload_class(self, payload)

        # Look at fields of the generic ICMPExtensionObject to determine which
        # bound extension type to use.
        ieo = ICMPExtensionObject(payload)
        if ieo.len < self._min_ieo_len:
            return Packet.guess_payload_class(self, payload)

        for fval, cls in self.payload_guess:
            ok = 1
            for k, v in fval.iteritems():
                if not hasattr(ieo, k) or v != ieo.getfieldval(k):
                    ok = 0
                    break
            if ok:
                return cls
        return ICMPExtensionObject

 def getlayer(self, cls, nb=1, _track=None):
     layer = None
     if cls == EAP:
         for eap_class in EAP.registered_methods.values():
             if isinstance(self, eap_class):
                 layer = self
                 break
     else:
         layer = Packet.getlayer(self, cls, nb, _track)
     return layer

 def getlayer(self, cls, nb=1, _track=None):
     layer = None
     if cls == RadiusAttribute:
         for attr_class in RadiusAttribute.registered_attributes.values():
             if isinstance(self, attr_class):
                 layer = self
                 break
     else:
         layer = Packet.getlayer(self, cls, nb, _track)
     return layer

 def pre_dissect(self, s):
     if self.firstlayer().name == TLSRecord.name:
         # Go get the underlaying records context
         # Will allow us to differentiate Ephemeral RSA (Freak)
         # From DHE (Logjam) and ECDHE
         try:
             self.tls_ctx = self.firstlayer().tls_ctx
         except AttributeError:
             self.tls_ctx = None
     return Packet.pre_dissect(self, s)

    def guess_payload_class(self, payload):

        start_line = payload.splitlines(True)[0]

        if self.re_request_line.match(start_line) is not None:
            return SIPRequest
        elif self.re_status_line.match(start_line) is not None:
            return SIPResponse

        return Packet.guess_payload_class(self, payload)

    def __init__(self, _pkt="", post_transform=None, _internal=0,
                 _underlayer=None, tls_session=None, **fields):
        try:
            setme = self.tls_session is None
        except:
            setme = True

        if setme:
            if tls_session is None:
                self.tls_session = tlsSession()
            else:
                self.tls_session = tls_session

        self.rcs_snap_init = self.tls_session.rcs.snapshot()
        self.wcs_snap_init = self.tls_session.wcs.snapshot()

        Packet.__init__(self, _pkt=_pkt, post_transform=post_transform,
                        _internal=_internal, _underlayer=_underlayer,
                        **fields)

 def guess_payload_class(self, payload):
     if self.fcf_frametype == 0x00:
         return Dot15d4Beacon
     elif self.fcf_frametype == 0x01:
         return Dot15d4Data
     elif self.fcf_frametype == 0x02:
         return Dot15d4Ack
     elif self.fcf_frametype == 0x03:
         return Dot15d4Cmd
     else:
         return Packet.guess_payload_class(self, payload)

 def guess_payload_class(self, payload):
     # Profile-wide commands
     if self.zcl_frametype == 0x00 and self.command_identifier == 0x00:
         return ZCLGeneralReadAttributes
     elif self.zcl_frametype == 0x00 and self.command_identifier == 0x01:
         return ZCLGeneralReadAttributesResponse
     # Cluster-specific commands
     elif self.zcl_frametype == 0x01 and self.command_identifier == 0x00 and self.direction == 0 and self.underlayer.cluster == 0x0700:  # "price"  # noqa: E501
         return ZCLPriceGetCurrentPrice
     elif self.zcl_frametype == 0x01 and self.command_identifier == 0x01 and self.direction == 0 and self.underlayer.cluster == 0x0700:  # "price"  # noqa: E501
         return ZCLPriceGetScheduledPrices
     elif self.zcl_frametype == 0x01 and self.command_identifier == 0x00 and self.direction == 1 and self.underlayer.cluster == 0x0700:  # "price"  # noqa: E501
         return ZCLPricePublishPrice
     else:
         return Packet.guess_payload_class(self, payload)

 def guess_payload_class(self, payload):
     """ Decides if the payload is an HTTP Request or Response, or
         something else """
     try:
         prog = re.compile(r"^(?:OPTIONS|GET|HEAD|POST|PUT|DELETE|TRACE|CONNECT) " r"(?:.+?) " r"HTTP/\d\.\d$")
         req = payload[: payload.index("\r\n")]
         result = prog.match(req)
         if result:
             return HTTPRequest
         else:
             prog = re.compile(r"^HTTP/\d\.\d \d\d\d .*$")
             result = prog.match(req)
             if result:
                 return HTTPResponse
     except:
         pass
     return Packet.guess_payload_class(self, payload)