Question

I have some machines running on the same network. One node is the control node which distributes traffic coming to it to the other nodes. The thing is that I want to have a custom protocol header between MAC header and IP(or whatever) payload incoming to the control node.

Control node receives this any packet like this:

------------------------------------------------
| Layer 2 | IP(or whatever protocol) | Payload |
------------------------------------------------

This packet should be distributed like this to other nodes

----------------------------------------------------------------
| Layer 2 | Custom Header | IP(or whatever protocol) | Payload |
----------------------------------------------------------------

I want some directions to do such a thing, Is there any current solution which I can use and I have to hack kernel for it from the scratch. A similar approach is to use L2TP but that runs over IP layer so I dont want that.

I also want this communication to be appeared as a seperate interface in linux like tun0 apart from physical eth0 interface.

Any help or ideas would be highly appreciated.

I dont know in what stack-exchange website this question belongs to so directions to correct website are also appreciated.

Answer 1

Your case is very similar to VLAN, where VLAN header also sits between L2 header and IP header. You can take a look at VLAN code, especially net/8021q/vlan_dev.c.

The key here is you need to construct your own L2 header, so you need to register your own header_ops like what VLAN does:

static const struct header_ops vlan_header_ops = {
        .create  = vlan_dev_hard_header,
        .rebuild = vlan_dev_rebuild_header,
        .parse   = eth_header_parse,
};

and register it during initialization:

dev->header_ops      = &vlan_header_ops;
dev->hard_header_len = real_dev->hard_header_len + VLAN_HLEN;

The ->create() function pointer here is used to create the custom header:

static int vlan_dev_hard_header(struct sk_buff *skb, struct net_device *dev,
                unsigned short type,
                const void *daddr, const void *saddr,
                unsigned int len)
{
    struct vlan_hdr *vhdr;
    unsigned int vhdrlen = 0;
    u16 vlan_tci = 0;
    int rc;

    if (!(vlan_dev_priv(dev)->flags & VLAN_FLAG_REORDER_HDR)) {
        vhdr = (struct vlan_hdr *) skb_push(skb, VLAN_HLEN);

        vlan_tci = vlan_dev_priv(dev)->vlan_id;
        vlan_tci |= vlan_dev_get_egress_qos_mask(dev, skb);
        vhdr->h_vlan_TCI = htons(vlan_tci);

        /*
         *  Set the protocol type. For a packet of type ETH_P_802_3/2 we
         *  put the length in here instead.
         */
        if (type != ETH_P_802_3 && type != ETH_P_802_2)
            vhdr->h_vlan_encapsulated_proto = htons(type);
        else
            vhdr->h_vlan_encapsulated_proto = htons(len);

        skb->protocol = htons(ETH_P_8021Q);
        type = ETH_P_8021Q;
        vhdrlen = VLAN_HLEN;
    }

    /* Before delegating work to the lower layer, enter our MAC-address */
    if (saddr == NULL)
        saddr = dev->dev_addr;

    /* Now make the underlying real hard header */
    dev = vlan_dev_priv(dev)->real_dev;
    rc = dev_hard_header(skb, dev, type, daddr, saddr, len + vhdrlen);
    if (rc > 0)
        rc += vhdrlen;
    return rc;
}