`cap` does not live long enough

[kracekumar]

I'm using pcap library to capture wifi packet in a thread and transferring the packet to an another thread using channels. While moving packet via sender to receiver thread, I get the error message cap does not live long enough. I have attached the code snippet. There is some extra piece of code to match error line numbers.

I have installed source from the latest master branch.

extern crate pcap;
extern crate argparse;

use std::sync::{Arc, Mutex};
use std::thread;
use std::sync::mpsc;


fn start_hub(){
    println!("starting the pcap")
}


fn sniff(sender: &mpsc::Sender<pcap::Packet>){
    println!("Sniff");
    for device in pcap::Device::list().unwrap() {
        println!("device");
        if device.name == "wlan0" {
            println!("Found device! {:?}", device);
            let mut cap = device.open().unwrap();
            loop{
                while let Ok(packet) = cap.next() {
                    println!("got packet! {:?}", packet.data);
                    let c = packet.clone();
                    sender.send(c).unwrap();
                }
            }
        }
    }
}


fn depositer(receiver: &mpsc::Receiver<pcap::Packet>){
    loop{
        println!("Received: {:?}", receiver.recv().unwrap());
    }
}

fn hub(){
    println!("Hub");
}


fn fetcher(){
    println!("Fetcher");
}


fn start(){
    println!("Start");
    // ZMQ socket
    // Pcap library capture
    let data = Arc::new(Mutex::new(0));

    let (sender, receiver) = mpsc::channel();

    let sniffer_handle: thread::JoinHandle<()>;
    let depositer_handle: thread::JoinHandle<()>;
    let hub_handle: thread::JoinHandle<()>;
    let fetcher_handle: thread::JoinHandle<()>;
    // Start sniffer
    sniffer_handle = thread::spawn(move || {
        sniff(&sender);
    });
    // Start depositer
    depositer_handle = thread::spawn(move || {
        depositer(&receiver);
    });
    // Start Hub
    hub_handle = thread::spawn(|| hub());
    // Start fetcher
    fetcher_handle = thread::spawn(|| fetcher());
    // Join all threads
    sniffer_handle.join().unwrap();
    depositer_handle.join().unwrap();
    hub_handle.join().unwrap();
    fetcher_handle.join().unwrap();
}


fn top(){
    println!("top");
}


fn invalid(){
    println!("Invalid args")
}


pub fn parse_arguments(){
    // Attach all commands
    let mut verbose = false;
    let mut command = "".to_string();
    {
        let mut parser = argparse::ArgumentParser::new();
        parser.set_description("imon is a command line utility to monitor internet data consumption");
        parser.refer(&mut verbose)
            .add_option(&["-v", "--verbose"], argparse::StoreTrue,
                        "Be verbose");
        parser.refer(&mut command).required()
            .add_argument("command", argparse::Store,
                          r#"Command to run (either "start" or "top")"#);
        parser.parse_args_or_exit();
    }
    // Get all commands from user
    match command.as_ref() {
        "start" => start(),
        "top" => top(),
        _ => invalid(),
    }
}

Output:

user@user-ThinkPad-T400 ~/c/imon> sudo ~/.cargo/bin/cargo run  --bin imon -- start
[sudo] password for user: 
   Compiling imon v0.1.0 (file:///home/user/code/imon)
error: `cap` does not live long enough
  --> src/cli.rs:24:40
   |
24 |                 while let Ok(packet) = cap.next() {
   |                                        ^^^
   |
note: reference must be valid for the anonymous lifetime #2 defined on the block at 16:45...
  --> src/cli.rs:16:46
   |
16 | fn sniff(sender: &mpsc::Sender<pcap::Packet>){
   |                                              ^
note: ...but borrowed value is only valid for the block suffix following statement 1 at 22:49
  --> src/cli.rs:22:50
   |
22 |             let mut cap = device.open().unwrap();
   |                                                  ^

error: aborting due to previous error

error: Could not compile `imon`.

To learn more, run the command again with --verbose.
user@user-ThinkPad-T400 ~/c/imon> 

[k4rtik]

@kracekumar came here from your blog post. This is not an issue with pcap crate but with how lifetimes work in Rust. The problem is that you are trying to send a reference with a limited lifetime across a thread boundary, which is not allowed.

In your current code at https://github.com/kracekumar/imon/blob/master/src/cli.rs#L16, when you say:

                    let data = packet.data.clone();
                    sender.send(data).unwrap();

the clone is for a slice (a reference to a byte array), you probably want to do a clone_from_slice as shown here into a static byte array, then you should be able to talk across a thread (though this technique requires using unsafe). I wrote some similar code at https://gist.github.com/k4rtik/a03c4be123734b396e3db7451b7bce4f#file-datalink-rs-L166-L182

[k4rtik]

Of course, I would love to learn a better technique to share byte arrays across threads, if maintainers or someone else who knows better looks at this.

[kracekumar]

Thank You @k4rtik. Your solution worked. I modified a little bit to make it work.

fn sniff(sender: &mpsc::Sender<Vec<u8>>){
    for device in pcap::Device::list().unwrap() {
        if device.name == "wlan0" {
            let mut cap = device.open().unwrap();
            loop{
                while let Ok(packet) = cap.next() {
                    let len = (&packet.data).len();
                    let mut data = Vec::new();
                    data.resize(len, 0);
                    data.clone_from_slice(&packet);
                    sender.send(data).unwrap();
                }
            }
        }
    }
}

fn depositer(receiver: &mpsc::Receiver<Vec<u8>>){
    loop{
        let packet = receiver.recv().unwrap();
        decode_packet(packet);
    }
}

I overlooked clone. I was under impression clone will clone underlying elements.

I am closing the issue. If there is a better way, I am happy to hear.