Come filtrare e intercettare i pacchetti Linux usando l'API net_dev_add()?

Question

Sto scrivendo il driver di rete ethernet per linux. Voglio ricevere pacchetti, modificarli e inviarli nuovamente. So come modificare il pacchetto nella funzione packet_interceptor, ma come posso eliminare i pacchetti in entrata in questa funzione ??

#include <linux/netdevice.h> 
#include <linux/skbuff.h> 
#include <linux/ip.h> 
#include <net/sock.h> 

struct packet_type my_proto; 

int packet_interceptor(struct sk_buff *skb, 
    struct net_device *dev, 
    struct packet_type *pt, 
    struct net_device *orig_dev) { 

    // I dont want certain packets go to upper in net_devices for further processing. 
    // How can I drop sk_buff here?! 

    return 0; 
} 

static int hello_init(void) { 
    printk(KERN_INFO "Hello, world!\n"); 

    my_proto.type = htons(ETH_P_ALL); 
    my_proto.dev = NULL; 
    my_proto.func = packet_interceptor; 

    dev_add_pack(&my_proto); 
    return 0; 
}  

static void hello_exit(void) { 
    dev_remove_pack(&my_proto); 
    printk(KERN_INFO "Bye, world\n"); 
} 

module_init(hello_init); 
module_exit(hello_exit); 

Answer 1

Si sta facendo in modo che il modulo gestisca tutti i pacchetti Ethernet. Linux invierà pacchetti a tutti i gestori di protocollo corrispondenti. Poiché IP è già registrato nel tuo kernel, sia il tuo modulo che ip_rcv riceveranno tutti gli SKB con intestazioni IP.

Non è possibile modificare questo comportamento senza modificare il codice del kernel. Una possibilità è creare invece un modulo netfilter. In questo modo, è possibile intercettare il pacchetto dopo la funzione ip_rcv e rilasciarlo se si desidera (in Netfilters PREROUTING hook).

Ecco un piccolo modulo Netfilter che ho estratto da un codice che avevo già scritto. Questo modulo è incompleto, ma le cose principali sono a posto.

#include <linux/netfilter.h> 
#include <linux/netfilter_ipv4.h> 

// Handler function 
static unsigned int my_handler (
    unsigned int hook, 
    struct sk_buff *skb, 
    const struct net_device *in, 
    const struct net_device *out, 
    int (*okfn)(struct sk_buff *)) 
{ 
    return NF_ACCEPT; 
// or 
    return NF_DROP; 
} 

// Handler registering struct 
static struct nf_hook_ops my_hook __read_mostly = { 
    .hook = my_handler, 
    .pf = NFPROTO_IPV4, 
    .hooknum = (1 << NF_INET_PRE_ROUTING), 
    .priority = NF_IP_PRI_FIRST // My hook will be run before any other netfilter hook 
}; 

int my_init() { 
    int err = nf_register_hook (&my_hook); 
    if (err) { 
      printk (KERN_ERR "Could not register hook\n"); 
    } 
    return err; 
} 

Answer 2

ho passato il Kernel codice di rete (un anno da quando ho fatto nulla all'interno lì), e credo che si dovrebbe fare essere in grado di fare questo senza perdite nulla:

kfree_skb(skb); 
return NET_RX_DROP; 

Modifica

Questo viene eseguito in altri gestori di protocollo come ip_rcv e arp_rcv (l'ultimo restituisce 0 invece di NET_RX_DROP, ma non penso che il valore restituito sia molto importante). Ricorda di non chiamare nessun altro gestore se lasci cadere il skb.

guardare il codice per ip_rcv a ip.c (in basso): http://lxr.free-electrons.com/source/net/ipv4/ip_input.c#L375

Se tutto va bene, passa lo skb a Netfilter che poi chiama ip_rcv_finish (se non cadere). Se qualcosa va storto, libera lo skb e ritorna.

Modifica

Se più di un gestore di protocollo corrisponde a una SKB, il kernel lo invierà a tutti loro. Quando si kfree_skb() in uno dei moduli, lo SKB continuerà a vivere negli altri gestori.