ipset 0.9.0

A wrapper for libipset
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113

use std::fs;
use std::net::IpAddr;

use ipset::types::{AddOption, BitmapIp, EnvOption, Error, HashIp, IpDataType, ListResult};
use ipset::{IPSet, Session};

fn test_hash_ip() -> Result<(), Error> {
    let mut session: Session<HashIp> = Session::new("test".to_string());
    if session.exists()? {
        println!("already exists destroy now");
        session.destroy()?;
    }

    let ip: IpAddr = "192.168.3.1".parse()?;
    session.create(|builder| {
        builder
            .with_ipv6(false)?
            .with_forceadd()?
            .with_counters()?
            .with_skbinfo()?
            .with_comment()?
            .build()
    })?;

    let ret = session.add(ip, &[])?;
    println!("add {}", ret);

    session.set_option(EnvOption::Exist);
    let ret = session.add(
        ip,
        &[
            AddOption::Bytes(10),
            AddOption::Packets(20),
            AddOption::SkbMark(1, u32::MAX),
            AddOption::SkbPrio(10, 1),
            AddOption::SkbQueue(3),
            AddOption::Comment("hello".to_string()),
        ],
    )?;
    session.unset_option(EnvOption::Exist);
    println!("add {}", ret);

    let exists = session.test(ip)?;
    println!("test {}", exists);

    let ips = session.list()?;
    match ips {
        ListResult::Normal(ret) => {
            println!("name:{}, type:{}, revision:{}, size_in_memory:{}, references:{}, entry_size:{}, header:{:?}",
                     ret.name, ret.typ, ret.revision, ret.size_in_memory, ret.references, ret.entry_size, ret.header)
        }
        ListResult::Terse(names) => {
            println!("{:?}", names);
        }
    }
    session.set_option(EnvOption::ListSetName);
    let ips = session.list()?;
    session.unset_option(EnvOption::ListSetName);
    match ips {
        ListResult::Normal(ret) => {
            println!("name:{}, type:{}, revision:{}, size_in_memory:{}, references:{}, entry_size:{}, header:{:?}",
                     ret.name, ret.typ, ret.revision, ret.size_in_memory, ret.references, ret.entry_size, ret.header)
        }
        ListResult::Terse(names) => {
            println!("{:?}", names);
        }
    }

    let ret = session.save("test.ipset".to_string())?;
    println!("save {}", ret);

    let ret = session.del(ip)?;
    println!("del {}", ret);

    let ret = session.flush()?;
    println!("flush {}", ret);

    let ret = session.destroy()?;
    println!("destroy {}", ret);

    Ok(())
}

fn test_bitmap_ip() -> Result<(), Error> {
    let mut session: Session<BitmapIp> = Session::new("test".into());
    let _ = session.destroy();
    let from: IpAddr = "192.168.3.1".parse()?;
    let to: IpAddr = "192.168.3.255".parse()?;
    let from: IpDataType = from.into();
    let to: IpDataType = to.into();
    session.create(|builder| builder.with_range(&from, &to)?.build())?;
    session.destroy()?;
    Ok(())
}

fn main() {
    if let Err(err) = test_hash_ip() {
        println!("test hash ip failed:{:?}", err);
    }

    if let Err(err) = test_bitmap_ip() {
        println!("test bitmap failed:{:?}", err);
    }

    if fs::metadata("test.ipset").is_ok() {
        let set = IPSet::new();
        set.restore("test.ipset".to_string()).unwrap();
        println!("restore ok");
        fs::remove_file("test.ipset").unwrap();
    } else {
        println!("test.ipset not found");
    }
}