libpcap回调函数调用报错：invalid use of non-static member function求助

Hey there, let's break down why you're hitting this error and how to fix it step by step. The core issue here is a mismatch between how C++ handles non-static member functions and the function pointer type that pcap_loop expects.

Why the error happens #

Libpcap's pcap_loop requires a callback function with this strict signature:

void (*)(u_char*, const struct pcap_pkthdr*, const u_char*)

But a non-static member function in C++ has an implicit this pointer as its first hidden parameter. This changes its actual signature to something like:

void (YourClass::*)(u_char*, const struct pcap_pkthdr*, const u_char*)

These two types are incompatible—so the compiler throws that "invalid use of non-static member function" error when you try to pass a non-static member directly to pcap_loop.

Solutions to fix this #

1. Use a static member function + pass your class instance as user data #

This is the cleanest, most common approach for class-based code. We'll create a static member function (which has no implicit this pointer) to act as the callback, then use the last parameter of pcap_loop to pass your class instance—letting us access non-static members from within the callback.

Here's a complete example:

#include <pcap.h>
#include <iostream>

class PacketSniffer {
private:
    pcap_t* handle;

    // Your actual packet processing logic (non-static, can access class members)
    void processPacket(const struct pcap_pkthdr* header, const u_char* packet) {
        std::cout << "Got a packet with length: " << header->len << std::endl;
        // Add your packet parsing/processing code here
    }

public:
    // Static callback function compatible with pcap_loop's requirements
    static void got_packet(u_char* user_data, const struct pcap_pkthdr* header, const u_char* packet) {
        // Convert the user data back to your class instance pointer
        PacketSniffer* sniffer = reinterpret_cast<PacketSniffer*>(user_data);
        // Call the non-static processing function
        sniffer->processPacket(header, packet);
    }

    void startSniffing() {
        // Assume `handle` is already initialized (e.g., via pcap_open_live)
        if (pcap_loop(handle, 1, got_packet, reinterpret_cast<u_char*>(this)) < 0) {
            std::cerr << "pcap_loop failed: " << pcap_geterr(handle) << std::endl;
        }
    }
};

2. Use a lambda (C++11+) #

If you're using C++11 or later, you can use a lambda expression that captures nothing (so it can be converted to a function pointer). Like the static member approach, we'll pass the class instance via the user data parameter:

void startSniffing() {
    // Lambda with no captures can be cast to pcap_handler
    auto callback = [](u_char* user_data, const struct pcap_pkthdr* header, const u_char* packet) {
        PacketSniffer* sniffer = reinterpret_cast<PacketSniffer*>(user_data);
        sniffer->processPacket(header, packet);
    };

    if (pcap_loop(handle, 1, reinterpret_cast<pcap_handler>(callback), reinterpret_cast<u_char*>(this)) < 0) {
        std::cerr << "pcap_loop failed: " << pcap_geterr(handle) << std::endl;
    }
}

Note: This only works if the lambda has no captures. If you try to capture variables (like this directly), it can't be converted to a plain function pointer.

3. Use a global function (not recommended) #

You could use a global function as the callback, but this breaks encapsulation. If you go this route, you'll need to make the function a friend of your class or expose public methods to access internal data:

// Global callback function
void got_packet(u_char* user_data, const struct pcap_pkthdr* header, const u_char* packet) {
    PacketSniffer* sniffer = reinterpret_cast<PacketSniffer*>(user_data);
    sniffer->processPacket(header, packet);
}

class PacketSniffer {
private:
    pcap_t* handle;
    void processPacket(const struct pcap_pkthdr* header, const u_char* packet) { /* ... */ }

    // Make the global function a friend to access private members
    friend void got_packet(u_char*, const struct pcap_pkthdr*, const u_char*);
public:
    void startSniffing() {
        if (pcap_loop(handle, 1, got_packet, reinterpret_cast<u_char*>(this)) < 0) {
            std::cerr << "pcap_loop failed: " << pcap_geterr(handle) << std::endl;
        }
    }
};

Avoid this unless you have a specific reason—global functions can lead to tighter coupling and harder-to-maintain code.

Quick extra tips #

• Make sure you're including the right header: #include <pcap.h>
• When compiling, don't forget to link against the libpcap library with the -lpcap flag (e.g., g++ your_code.cpp -o sniffer -lpcap)

内容的提问来源于stack exchange，提问作者dave