send() and sendp() not working on PPPoE interface #4964

Activity

1. cinit commented on Apr 11, 2026

   

   cinit

   on Apr 11, 2026

   Author

   More actions

   Here's a workaround. socket.socket(socket.AF_PACKET, socket.SOCK_DGRAM) + s.bind((iface, socket.ETHERTYPE_IPV6)) + s.send(raw(pkt[IPv6])) can be used to send IPv6 packets on PPP link.

       def _native_send_ipv6(self, pkt: Packet, iface: str, is_multicast: bool) -> None:
           # make sure it's IPv6 packet
           if not pkt.haslayer(IPv6):
               LOG.warning("attempted to send non-IPv6 packet: %s", pkt.summary())
               return
           # 1. chek interface link type, raw IP or Ethernet
           ifarphdr = self._arphdr_type(iface)
           is_ethernet = ifarphdr == ArphrdType.ARPHRD_ETHER
           # 2. if raw IP, sendp as is; if Ethernet, add an Ethernet header with proper src and dst MAC addresses
           ret = None
           if is_ethernet:
               # ... skipped here
               ret = sendp(ether, iface=iface, verbose=False)
           elif ifarphdr == ArphrdType.ARPHRD_PPP:
               # PPP workaround, scapy has bug transmitting AF_PACKET on PPP link
               # We need to use scapy to build the L3 IPv4 packet
               # and manually send with AF_PACKET sll_proto=ETH_P_IPV6(0x86DD)
               l3_payload = raw(pkt[IPv6])
               # The addresses are represented by the tuple (ifname, proto[, pkttype[, hatype[, addr]]])
               sll = (iface, socket.ETHERTYPE_IPV6)
               with socket.socket(socket.AF_PACKET, socket.SOCK_DGRAM) as s:
                   s.bind(sll)
                   s.send(l3_payload)
           # elif other cases ...
   
       def _arphdr_type(self, ifname: str) -> Optional[ArphrdType]:
           try:
               with open(f"/sys/class/net/{ifname}/type", "r", encoding="utf-8") as f:
                   t = int(f.read().strip())
                   if t == ArphrdType.ARPHRD_ETHER.value:
                       return ArphrdType.ARPHRD_ETHER
                   elif t == ArphrdType.ARPHRD_PPP.value:
                       return ArphrdType.ARPHRD_PPP
                   elif t == ArphrdType.ARPHRD_VOID.value:
                       return ArphrdType.ARPHRD_VOID
                   else:
                       raise ValueError(f"unsupported ARPHRD type {t} for interface {ifname}")
           except OSError as e:
               # unexpected
               LOG.error("failed to read ARPHRD type for interface %s: %s", ifname, e)
               raise e
2. gpotter2

   added the

   Bug

   issue type on Apr 11, 2026
3. mohamedsolaiman commented on May 1, 2026

   

   mohamedsolaiman

   on May 1, 2026

   Contributor

   More actions

   I ran into a similar issue with PPPoE interfaces. The problem is that when Scapy sends via AF_PACKET on PPPoE, it does not set sll_protocol correctly for the PPP driver. A workaround that worked for me was to use conf.L2socket = L2ListenTcpdump and set the protocol field manually. Not a perfect fix but it gets packets through. Would love to see proper PPPoE support in Scapy!
4. cinit

   added 2 commits that reference this issue on Jun 15, 2026

   Fix AF_PACKET protocol on raw L3 sends

   ...

   This issue will close once commit b09dfbf is merged into the 'master' branch.

   b09dfbf

   Fix AF_PACKET protocol on raw L3 sends

   ...

   This issue will close once commit f02b611 is merged into the 'master' branch.

   f02b611
5. gpotter2

   added this to the next milestone on Jul 22, 2026
6. DresslerFrank commented on Oct 11, 2026

   

   DresslerFrank

   on Oct 11, 2026

   Last edited by DresslerFrank

   Contributor

   More actions

   I have done some research on this issue, looking at the kernel source and debugging the kernel. See the description below. My private notes are more comprehensive. I am not describing everything below but I hope it is sufficient to help you fix the problem. If you want, I can actually work more on it and fix it. At least I want to share my findings here because they might actually help others fix the issue properly.

   Quick workaround

   Explicitly pass the protocol to send(). This allows you to send packets via PPPoE and similar devices:

   • send(IP()/..., type=ETH_P_IP)
   • send(IPv6()/..., type=ETH_P_IPV6)
   • ...

   Explicitly specifying the protocol helps because it makes Scapy create the socket with that type/protocol instead of ETH_P_ALL. The ETH_P_ALL only works with some netdev types, e.g. Ethernet ones, but not others, e.g. PPP ones. See below for details.

   Issue is more general

   The issue is not PPPoE specific. It applies to all kinds of PPP netdevs and also to other kinds of netdevs such as GRE ones. In general, it applies to all netdevs that require you to pass the protocol to the kernel via e.g. socket(), bind(), or sendto(). Details below.

   Importance of the Protocol in AF_PACKET, SOCK_RAW sockets

   When you have a (AF_PACKET, SOCK_RAW) socket, what you need to pass to the kernel depends on the kind of netdev. Independent of the netdev the kernel needs to know the protocol (same numbers as ethertype) of the packet you are sending in. The kernel takes that information from either socket(), bind(), or sendto(). If that protocol is ETH_P_ALL or 0, the kernel tries to help you out by taking a look at the packet but this depends on the specific netdev type.

   • For Ethernet devices, the kernel expects you to pass Ether()/... to the kernel. And because the Ether() contains the ether type, the kernel will just extract the protocol from the packet, if none was passed explicitly via socket()/bind()/sendto().

   • For PPP devices, the kernel expects you to pass IP()/..., IPv6()/... to it, i.e. no header from which it could extract the protocol. Because of that, the kernel cannot help you out. So, if your socket was created with ETH_P_ALL or bind() to ETH_P_ALL, and you do not specify a protocol explicitly in sendto(), the kernel has no way to know the protocol. It'll rewrite the protocol from ETH_P_ALL (3) to 0. The PPP code, however, needs to know the protocol because the protocol ID must be translated to another kind of protocol ID and placed in the PPP header the kernel adds to the packet before sending it. Since 0 is not a valid protocol, the kernel rejects the packet. The reason for why the kenrel cannot help you detect the protocol automatically is that PPP can carry not just IP and IPv6, but also IPX and other protocols.

   • For GRE devices, it is similar to PPP devices but a bit less restrictive. GRE devices also expect you to pass IP()/..., IPv6() and because of that cannot extract the protocol ID from the packet. But for GRE, the protocol ID is simply copied 1:1 to a 16 bit field in the GRE header with no translation. This means, if you do not pass a protocol to the kernel, the kernel will turn the ETH_P_ALL to 0 and, while that 0 is wrong, the kernel does not care and just puts this 0 into the GRE header. It should be ETH_P_IP or ETH_P_IPV6 instead but the kernel does not care. 0 is a valid value for GRE. The kernel would not drop the packet, it'd be sent.

   • For SIT devices, we have a case similar to PPP and GRE, where again you pass IP()/..., IPV6()/... or whatever to the kernel, i.e. no protocol as part of what you pass to it. However, SIT is limited to carry IPv4 or IPv6. Because of that, the kernel can actually help you autoamtically detect the protocol. Both, IPv4 and IPv6, have the protocol version in the top nibble of their first byte. So what the kernel does is look at that nibble and if it is 4, it has detected an IPv4 packet, and if it is 6, it has detected an IPv6 packet.

   Device Type Property Overview

   netdev type	expected input	auto detect protocol	permitted protocols restricted	works properly with scapy
   Ethernet, IPVLAN, MACVLAN	Ether()/...	yes, from ether type	no	yes
   PPP	IP()/..., IPV6()/..., ...	no	yes: ETH_P_IP, ETH_P_IPV6, ETH_P_IPX, ETH_P_PPPTALK, ETH_P_ATALK, ETH_P_MPLS_UC, ETH_P_MPLS_MC	no
   GRE	IP()/..., IPV6()/..., ...	no	no	no
   SIT, Wireguard, TUN	IP()/..., IPV6()/...	yes for IPv4/IPv6	I don't know	yes

   The ones not working properly with Scapy are the ones that do not have automatic protocol detection. GRE seems to work because packets are sent and received, but they will be sent with the wrong protocol (0).

   Scapy

   Currently, usually, Scapy does not pass the protocol to the kernel explicitly but instead uses ETH_P_ALL and send(). Because of that, only netdevs for which the kernel supports automatic protocol detections work, i.e. regular Ethernet devices, but also SIT or Wireguard would work, for example. See table above.

   However, when you specify the protocol explicitly, i.e.send(..., type=PROTOCOL), Scapy does bind(..., PROTOCOL) which is why it then works: The kernel does not need to automatically detect the protocol and so it works for netdevs that do not support automatic protocol detection.

   Fixing the Issue

   bind()ing the socket to the desired protocol would be one way of solving the issue. However, that'd restrict the socket a bit too much. It'd then be restricted to just that protocol, e.g. IPv4 or IPv6. You could not use one socket for multiple protocols anymore. Limiting a socket to a specific protocol would be unnecessarily restrictive and it is unnecessary as the following paragraph shows.

   What you can do instead is to use sendto() instead of send(). sendto() allows you to pass the struct sockaddr_ll to the kernel with the packet data. This struct contains the desitnation address, the device to use, but also the protocol and some other fields. For the (AF_PACKET, SOCK_RAW) sockets Scapy uses, the kernel actually ignores all fields except for the interface and protocol. And Python already supports this by allowing you to pass just these two instead of forcing you to make up values for all the other fields. You can just do a s.sendto(bytes(pkt), ("ppp0", ETH_P_IP)) or s.sendto(bytes(pkt), ("ppp0", ETH_P_IPV6)) instead of a s.send() that Scapy currently does. To help the user, we can extract the protocol ID from the pkt.

   So you'd get the following change in code.

   Before:

   sock.send(bytes(pkt))

   After:

   protocol = ethertype_from_pkt(pkt)
   interface = sock.getsockname()[0]
   sock.sendto(bytes(pkt), (interface, protocol))

   This would basically move the protocol detection to Scapy. The kernel would not need to do it anymore. But, I wonder, if that might be slow and sometimes undesired. So maybe it should be restricted to when the socket sock is bound to ETH_P_ALL or 0 which is when the kernel would do the auto-detection and potentially further restricted to only those kinds of sockets which are bound to device types that do not support automatic protocol detection. The solution above is just one that probably always works for as long as ethertype_from_pkt(pkt) works which requires pkt to be a Packet, e.g. IP()/... or similar, i.e.it could not be a bytes() thing already. In that situation, you could have ethertype_from_pkt implemented as follows:

   def ethertype_from_pkt(pkt):
       import scapy.layers.l2
       try: return pkt._overload_fields[scapy.layers.l2.Ether]["type"
       except: pass

   Since that function could fail and restricts the pkt to actual Packets, excluding bytes(), it might make sense to really restrict it to netdevs for which the kernel has no protocol auto detection. That'd then allow users to still pass bytes(). For send() specifically, the user currently cannot pass bytes(), so the given code would not be restrictive.

   Sample Patch

   The following diff/patch shows a potential change that makes send() work for PPP and similar devices that require you to pass down the protocol explicitly. It is still flawed because it would not work with the auto-fragmentation code just below. Use it only as an example to prove the concept. Bascially, all sock.send()s need to be replaced by a conditional sock.sendto() where necessary (netdev does not support protocol auto detection and user did not explicitly specify a protocol) with a fallback to sock.send() where the kernel can detect the protocol explicitly.

   diff --git a/scapy/arch/linux/__init__.py b/scapy/arch/linux/__init__.py
   index 29ad12cd..3ad6f1f2 100644
   --- a/scapy/arch/linux/__init__.py
   +++ b/scapy/arch/linux/__init__.py
   @@ -51,6 +51,11 @@ from scapy.arch.linux.rtnetlink import (  # noqa: F401
        _get_if_list,
    )
    
   +def getethertype(pkt):
   +    import scapy.layers.l2
   +    try: return pkt._overload_fields[scapy.layers.l2.Ether]["type"]
   +    except: pass
   +
    # Typing imports
    from typing import (
        Any,
   @@ -374,8 +379,18 @@ class L3PacketSocket(L2Socket):
                x.sent_time = time.time()
            except AttributeError:
                pass
   +        socknam = fd.getsockname()
   +        if socknam[1] == ETH_P_ALL:
   +            protocol = getethertype(x)
   +            if protocol is not None:
   +                socknam = (socknam[0], protocol)
   +            else:
   +                socknam = None
            try:
   -            return fd.send(sx)
   +            if socknam is not None:
   +                return fd.sendto(sx, socknam)
   +            else:
   +                return fd.send(sx)
            except socket.error as msg:
                if msg.errno == 22 and len(sx) < conf.min_pkt_size:
                    return fd.send(
7. DresslerFrank commented on Oct 11, 2026

   

   DresslerFrank

   on Oct 11, 2026

   Last edited by DresslerFrank

   Contributor

   More actions

   Here are two helper scripts that allow you to create a test environment for the issue.

   The first script creates two network name spaces, scapy_L (L for left) and scapy_R (R for right) with different kinds of netdev types of the ones described above between them. Enter the network name spaces via ip netns exec scapy_L bash and ip netns exec scapy_R bash, then use the devices, e.g. via send(IP(dst="10.102.0.2")/...) from scapy_L with tcpdump running in scapy_R.

   The second script injects packets in various ways to demonstrate the effects of bind() vs sendto() and the different netdev types (eth, ppp, gre, ...). Run it from spectral_L like ./inject.py veth1, ./inject.py gre1, ... and have tcpdump -lXnni gre1 udp, tcpdump -lXnni veth1 udp, ... running in spectral_R. The tcpdump output will prove which ones work.

   Of course, with that test env, you can test whether the approach in my shared patch above works. Do a send(IP(src="10.103.0.1", dst="10.103.0.2")/UDP()/(128*b"x")) from the scapy CLI running in spectral_L with and without the patch. With the patch it'll work. Without it it wont. But if you add type=ETH_P_IP to the send(...) it'll work even without the patch.

   SetupTest Env

   Run as root, then enter the name spaces via ip netns exec scapy_L bash and ip netns exec scapy_R bash

   #!/bin/bash                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                              
   NETNS_PREFIX=${NETNS_PREFIX:-scapy}                                                                                                                                                                                                                                                        
   NETNS_L=${NETNS_PREFIX}_L                                                                                                                                                                                                                                                                  
   NETNS_R=${NETNS_PREFIX}_R                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                              
   check_command() {                                                                                                                                                                                                                                                                          
     local CMD=$1 STR=$2                                                                                                                                                                                                                                                                      
     command -v "$CMD" >/dev/null 2>&1                                                                                                                                                                                                                                                        
   }                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                              
   exit_with() {                                                                                                                                                                                                                                                                              
     local RET=$1 MSG=$2                                                                                                                                                                                                                                                                      
     printf "ERROR: %s\n" "$MSG" >&2                                                                                                                                                                                                                                                          
     exit "$RET"                                                                                                                                                                                                                                                                              
   }                                                                                                                                                                                                                                                                                          
   
   check_command ip || exit_with 1 "ip missing. install iproute2"
   check_command socat || exit_with 1 "socat missing. install socat"
   check_command pppd || exit_with 1 "pppd missing. install ppp"
   
   # reset
   netns_reset() {
     ip netns del "$NETNS_L" 2>/dev/null || true
     ip netns del "$NETNS_R" 2>/dev/null || true
   }                                                                     
   
   # setup                                                               
   netns_setup() {                                                       
     ip netns add "$NETNS_L"                                             
     ip netns add "$NETNS_R"                                             
     ip -n "$NETNS_L" l s lo up                                          
     ip -n "$NETNS_R" l s lo up                                          
   }                                                                     
   
   # veth                                                                
   veth() {                                                              
     ip -n "$NETNS_L" l a veth1 type veth peer netns "$NETNS_R" name veth1
     ip -n "$NETNS_L" l s veth1 up                                       
     ip -n "$NETNS_R" l s veth1 up                                       
     ip -n "$NETNS_L" a a 10.100.0.1/24 dev veth1
     ip -n "$NETNS_R" a a 10.100.0.2/24 dev veth1
   }                                                                     
   
   # gre                                                                 
   gre() {                                                               
     ip -n "$NETNS_L" l a gre1 type gre local 10.100.0.1 remote 10.100.0.2
     ip -n "$NETNS_R" l a gre1 type gre local 10.100.0.2 remote 10.100.0.1
     ip -n "$NETNS_L" l s gre1 up                                        
     ip -n "$NETNS_R" l s gre1 up                                        
     ip -n "$NETNS_L" a a 10.101.0.1/24 dev gre1
     ip -n "$NETNS_R" a a 10.101.0.2/24 dev gre1
   }                                                                     
   
   # sit                                                                 
   sit() {                                                               
     ip -n "$NETNS_L" l a sit1 type sit local 10.100.0.1 remote 10.100.0.2
     ip -n "$NETNS_R" l a sit1 type sit local 10.100.0.2 remote 10.100.0.1
     ip -n "$NETNS_L" l s sit1 up                                        
     ip -n "$NETNS_R" l s sit1 up                                        
     ip -n "$NETNS_L" a a 10.102.0.1/24 dev sit1
     ip -n "$NETNS_R" a a 10.102.0.2/24 dev sit1
   }                                                                     
   
   # ppp                                                                 
   ppp() {                                                               
     trap 'jobs -pr | xargs kill 2>/dev/null' EXIT
     socat PTY,link=/run/ppp-"$NETNS_L",rawer,echo=0 PTY,link=/run/ppp-"$NETNS_R",rawer,echo=0 &
     ip netns exec "$NETNS_L" pppd /run/ppp-"$NETNS_L" 115200 noauth local nodetach 10.103.0.1:10.103.0.2 &
     ip netns exec "$NETNS_R" pppd /run/ppp-"$NETNS_R" 115200 noauth local nodetach &
     wait                                                                
   }                                                                     
   
   netns_reset                                                           
   netns_setup                                                           
   veth                                                                  
   gre                                                                   
   sit                                                                   
   ppp                                                                   

   Inject packets

   Run from scapy_L netns via ./inject.py veth1, ./inject.py gre1, ... and run tcpdump from scapy_R while doing so.

   #!/usr/bin/python3
   
   import socket
   from scapy.all import *
   
   def bind_all_send(iface, pkt):
       s = socket.socket(socket.AF_PACKET, socket.SOCK_RAW, socket.htons(socket.ETH_P_ALL))
       s.bind((iface, socket.ETH_P_ALL))
       s.send(bytes(pkt)) # <- ETH_P_ALL from the `bind` above
   
   def bind_ip_send(iface, pkt):
       s = socket.socket(socket.AF_PACKET, socket.SOCK_RAW, socket.htons(socket.ETH_P_ALL))
       s.bind((iface, ETH_P_IP))
       s.send(bytes(pkt)) # <- ETH_P_IP from `bind` above
   
   def bind_all_sendto(iface, pkt):
       s = socket.socket(socket.AF_PACKET, socket.SOCK_RAW, socket.htons(socket.ETH_P_ALL))
       s.bind((iface, socket.ETH_P_ALL))
       s.sendto(bytes(pkt), (iface, ETH_P_IP)) # <- ETH_P_IP because it is passed here
   
   def nobind_sendto(iface, pkt):
       s = socket.socket(socket.AF_PACKET, socket.SOCK_RAW, socket.htons(socket.ETH_P_ALL))
       s.sendto(bytes(pkt), (iface, ETH_P_IP)) # <- ETH_P_IP because it is passed here
   
   def build_l2_pkt(sip, dip, payload):
       return Ether()/IP(src=sip, dst=dip)/UDP()/payload
   
   def build_l3_pkt(sip, dip, payload):
       return IP(src=sip, dst=dip)/UDP()/payload
   
   def veth1():
       # veth devices are ethernet devices
       # ethernet (AF_PACKET, SOCK_RAW) sockets expect you to pass the ethernet header as in
       # which includes the ethertype field from which Linux extracts the protocol if it was
       # not already specified in socket()/bind()/sendto()
       # because of this the first case works. the kernel will just extract the protocol from
       # the ethertype field.
       bind_all_send("veth1", build_l2_pkt("10.100.0.1", "10.100.0.2", b"veth1_bind_all_send"))
       bind_all_sendto("veth1", build_l2_pkt("10.100.0.1", "10.100.0.2", b"veth1_bind_all_sendto"))
       bind_ip_send("veth1", build_l2_pkt("10.100.0.1", "10.100.0.2", b"veth1_bind_ip_send"))
       nobind_sendto("veth1", build_l2_pkt("10.100.0.1", "10.100.0.2", b"veth1_nobind_sendto"))
   
   def gre1():
       # GRE (AF_PACKET, SOCK_RAW) sockets just expect you to pass the IP/IPXv6/whatever packet
       # in without the GRE header or any other header that could indicate the protocol of
       # what you are passing in. because of that, the kernel cannot extract the protocol from
       # what you pass in. you need to expclitly pass that information to the kernel via
       # socket()/bind()/sendto(). That is why the `bind_all_send()` below does not work:
       #  The protocol is not specified (it is ETH_P_ALL) and it is not explicitly passed
       #  in the send() call.
       # All others work because they define the protocol in bind() or sendto()
       # The kernel constructs the GRE header itself and copies the protocol to the header
       # unchanged. That is why you can pass any protocol you like to it, nothing is rejected
       # or translated based on it.
       bind_all_send("gre1", build_l3_pkt("10.101.0.1", "10.101.0.2", b"gre1_bind_all_send"))
       bind_all_sendto("gre1", build_l3_pkt("10.101.0.1", "10.101.0.2", b"gre1_bind_all_sendto"))
       bind_ip_send("gre1", build_l3_pkt("10.101.0.1", "10.101.0.2", b"gre1_bind_ip_send"))
       nobind_sendto("gre1", build_l3_pkt("10.101.0.1", "10.101.0.2", b"gre1_nobind_sendto"))
   
   def sit1():
       # SIT (Af_PACKET, SOCK_RAW) sockets, like GRE, expect you to pass IP/IPv6/...
       # Since SIT can only carry IPv4 and IPv6, the kernel does not need you to pass
       # the protocol to it. Both IPv4 and IPv6 headers start with the version number in the top
       # nibble of the first byte. It is 4 for IPv4 and 6 for IPv6. That is what the kernel uses
       # to help you out. This is different from GRE where, because you transport anything over GRE,
       # the kernel has no way to reliably automatically detect the protocol ID of the packet you
       # send.
       bind_all_send("sit1", build_l3_pkt("10.102.0.1", "10.102.0.2", b"sit1_bind_all_send"))
       bind_all_sendto("sit1", build_l3_pkt("10.102.0.1", "10.102.0.2", b"sit1_bind_all_sendto"))
       bind_ip_send("sit1", build_l3_pkt("10.102.0.1", "10.102.0.2", b"sit1_bind_ip_send"))
       nobind_sendto("sit1", build_l3_pkt("10.102.0.1", "10.102.0.2", b"sit1_nobind_sendto"))
   
   def ppp0():
       # PPP (AF_PACKET, SOCK_RAW) sockets, like GRE and SIT, expect just the packet without the
       # PPP header to be passed to the kernel. Like with GRE and unlike SIT it cannot help you
       # detect the protocol, you need to pass it down. This is because PPP supports IPv4, IPv6,
       # but also IPX and other protocols to be carried over it and needs to translate the protocol
       # IDs. Because that translation table is limited, only a specific set of protocol numbers
       # are supported. You can issue a sendto with protocl ID 0x1234 but the PPP code will drop
       # that packet because it does not know how to translate 0x1234 to the PPP protocol ID.
       # In GRE, 0x1234 would work since it just copies the 0x1234 to the GRE header unchanged.
       # Because of that, the `bind_all_send` won't work, since the kernel has no automatic
       # detection of the protocol, just like with GRE.
       bind_all_send("ppp0", build_l3_pkt("10.103.0.1", "10.103.0.2", b"ppp0_bind_all_send"))
       bind_all_sendto("ppp0", build_l3_pkt("10.103.0.1", "10.103.0.2", b"ppp0_bind_all_sendto"))
       bind_ip_send("ppp0", build_l3_pkt("10.103.0.1", "10.103.0.2", b"ppp0_bind_ip_send"))
       nobind_sendto("ppp0", build_l3_pkt("10.103.0.1", "10.103.0.2", b"ppp0_nobind_sendto"))
   
   import sys
   funcs = {
       "veth1": veth1,
       "gre1": gre1,
       "sit1": sit1,
       "ppp0": ppp0
   }
   name = sys.argv[1]
   if name in funcs:
       funcs[name]()
8. gpotter2 commented on Oct 12, 2026

   

   gpotter2

   on Oct 12, 2026

   Last edited by gpotter2

   Member

   More actions

   @DresslerFrank I encourage you to read the CONTRIBUTING.md guidelines. You may NOT comment using AI on the Scapy repo. Comments are for talking to humans, please don't be rude.
9. DresslerFrank commented on Oct 12, 2026

   

   DresslerFrank

   on Oct 12, 2026

   Contributor

   More actions

   [Conslidated my previous comments into one.]

   @gpotter2 I did not use AI. I have done that research myself. Let me share my notes (research_notes.md). It is really not nice of you to just accuse me of it. I have spent many hours, over 2 days doing the research.

   I also started working on solving the problem. But with your accusation I am now really demotivated. Here is the test I have written so far (scapy_gre_test.py) that I was still working on, to test that GRE works. Because if that works, PPP also works.

   What makes you believe that I created my comments using AI? I can share my screen and show you how I kernel debugged it. AI won't be able to do that. Let me know where you want me to share my screen. Would you take back the accusation then?

   You can contact me on LinkedIn (https://www.linkedin.com/in/frank-dressler-5a0b391a2) or via email frank@dressler.pro I'll find a way to share my screen then and prove to you I actually did the research.

   I have sent you an email using the email address I found in the source code of Scapy. Jitsi seems to be a working way I can use to share my screen.
10. gpotter2 commented on Oct 12, 2026

    

    gpotter2

    on Oct 12, 2026

    Member

    More actions

    Hi @DresslerFrank, apologies if I misattributed your comments to AI. We almost never get answers this long and with heavy formatting that aren't AI-slop. (and trust me right now we're flooded with it..)
    Thank you, of course, for contributing to the understanding of this issue and sorry for the confusion

    👍React with 👍1Reacted by Frank Dressler