Update dependencies

Use edition 2018

version: 0.3.0

Author: yaa110

.travis.yml

@@ -1,7 +1,6 @@
 language: rust
 sudo: true
 rust:
-  - 1.13.0
   - stable
   - beta
   - nightly

Cargo.toml

@@ -1,8 +1,8 @@
 [package]
 name = "iptables"
-version = "0.2.2"
+version = "0.3.0"
 authors = ["Navid Fathollahzade <yaa110@gmail.com>", "Pit Kleyersburg <pitkley@googlemail.com>"]
-
+edition = "2018"
 description = "Rust bindings for iptables"
 homepage = "https://github.com/yaa110/rust-iptables"
 documentation = "https://github.com/yaa110/rust-iptables"
@@ -16,6 +16,6 @@ license = "MIT"
 name = "iptables"
 
 [dependencies]
-lazy_static = "0.2.8"
-regex = "0.2"
-nix = "0.7.0"
+lazy_static = "1.4"
+regex = "1.4"
+nix = "0.19"

README.md

@@ -1,24 +1,19 @@
 Rust iptables
 =============
 
-[![crates.io](https://img.shields.io/crates/v/iptables.svg)](https://crates.io/crates/iptables) [![Documentation](https://img.shields.io/badge/Docs-iptables-blue.svg)](https://docs.rs/iptables/0.2.2/iptables) [![Build Status](https://travis-ci.org/yaa110/rust-iptables.svg)](https://travis-ci.org/yaa110/rust-iptables) [![License](http://img.shields.io/:license-mit-blue.svg)](https://github.com/yaa110/rust-iptables/blob/master/LICENSE)
+[![crates.io](https://img.shields.io/crates/v/iptables.svg)](https://crates.io/crates/iptables) [![Documentation](https://img.shields.io/badge/Docs-iptables-blue.svg)](https://docs.rs/iptables) [![Build Status](https://travis-ci.org/yaa110/rust-iptables.svg)](https://travis-ci.org/yaa110/rust-iptables) [![License](http://img.shields.io/:license-mit-blue.svg)](https://github.com/yaa110/rust-iptables/blob/master/LICENSE)
 
-**Rust iptables v0.2.2** provides bindings for [iptables](https://www.netfilter.org/projects/iptables/index.html) application in Linux (inspired by [go-iptables](https://github.com/coreos/go-iptables)). This crate uses iptables binary to manipulate chains and tables. This source code is licensed under MIT license that can be found in the LICENSE file.
-
-## Installation
-The minimum required Rust version is `1.13.0` which supports `?` operator. Add `iptables = "0.2"` to `dependencies` section of `Cargo.toml`:
+This crate provides bindings for [iptables](https://www.netfilter.org/projects/iptables/index.html) application in Linux (inspired by [go-iptables](https://github.com/coreos/go-iptables)). This crate uses iptables binary to manipulate chains and tables. This source code is licensed under MIT license that can be found in the LICENSE file.
 
 ```toml
 [dependencies]
-iptables = "0.2"
+iptables = "0.3"
 ```
 
 ## Getting started
 1- Import the crate `iptables` and manipulate chains:
 
 ```rust
-extern crate iptables;
-
 let ipt = iptables::new(false).unwrap();
 
 assert_eq!(ipt.new_chain("nat", "NEWCHAINNAME").unwrap(), true);

src/error.rs

@@ -1,7 +1,4 @@
-extern crate regex;
-extern crate nix;
-
-use std::{fmt, error, io, convert, num};
+use std::{convert, error, fmt, io, num};
 
 /// Defines the general error type of iptables crate
 #[derive(Debug)]
@@ -39,7 +36,7 @@ impl error::Error for IPTError {
         }
     }
 
-    fn cause(&self) -> Option<&error::Error> {
+    fn cause(&self) -> Option<&dyn error::Error> {
         match *self {
             IPTError::Io(ref err) => Some(err),
             IPTError::Regex(ref err) => Some(err),

src/lib.rs

@@ -6,8 +6,6 @@
 //!
 //! # Example
 //! ```
-//! extern crate iptables;
-//!
 //! fn main() {
 //!     let ipt = iptables::new(false).unwrap();
 //!     assert_eq!(ipt.new_chain("nat", "NEWCHAINNAME").unwrap(), true);
@@ -18,21 +16,17 @@
 //! }
 //! ```
 
-#[macro_use]
-extern crate lazy_static;
-extern crate regex;
-extern crate nix;
-
 pub mod error;
 
-use std::process::{Command, Output};
+use error::{IPTError, IPTResult};
+use lazy_static::lazy_static;
+use nix::fcntl::{flock, FlockArg};
 use regex::{Match, Regex};
-use error::{IPTResult, IPTError};
+use std::ffi::OsStr;
 use std::fs::File;
 use std::os::unix::io::AsRawFd;
-use nix::fcntl::{flock, FlockArg};
+use std::process::{Command, Output};
 use std::vec::Vec;
-use std::ffi::OsStr;
 
 // List of built-in chains taken from: man 8 iptables
 const BUILTIN_CHAINS_FILTER: &'static [&'static str] = &["INPUT", "FORWARD", "OUTPUT"];
@@ -97,24 +91,38 @@ pub fn new(is_ipv6: bool) -> IPTResult<IPTables> {
 /// Creates a new `IPTables` Result with the command of 'iptables' if `is_ipv6` is `false`, otherwise the command is 'ip6tables'.
 #[cfg(target_os = "linux")]
 pub fn new(is_ipv6: bool) -> IPTResult<IPTables> {
-    let cmd = if is_ipv6 {
-        "ip6tables"
-    } else {
-        "iptables"
-    };
+    let cmd = if is_ipv6 { "ip6tables" } else { "iptables" };
 
     let version_output = Command::new(cmd).arg("--version").output()?;
     let re = Regex::new(r"v(\d+)\.(\d+)\.(\d+)")?;
     let version_string = String::from_utf8_lossy(&version_output.stdout).into_owned();
-    let versions = re.captures(&version_string).ok_or("invalid version number")?;
-    let v_major = versions.get(1).ok_or("unable to get major version number")?.as_str().parse::<i32>()?;
-    let v_minor = versions.get(2).ok_or("unable to get minor version number")?.as_str().parse::<i32>()?;
-    let v_patch = versions.get(3).ok_or("unable to get patch version number")?.as_str().parse::<i32>()?;
+    let versions = re
+        .captures(&version_string)
+        .ok_or("invalid version number")?;
+    let v_major = versions
+        .get(1)
+        .ok_or("unable to get major version number")?
+        .as_str()
+        .parse::<i32>()?;
+    let v_minor = versions
+        .get(2)
+        .ok_or("unable to get minor version number")?
+        .as_str()
+        .parse::<i32>()?;
+    let v_patch = versions
+        .get(3)
+        .ok_or("unable to get patch version number")?
+        .as_str()
+        .parse::<i32>()?;
 
     Ok(IPTables {
         cmd: cmd,
-        has_check: (v_major > 1) || (v_major == 1 && v_minor > 4) || (v_major == 1 && v_minor == 4 && v_patch > 10),
-        has_wait: (v_major > 1) || (v_major == 1 && v_minor > 4) || (v_major == 1 && v_minor == 4 && v_patch > 19),
+        has_check: (v_major > 1)
+            || (v_major == 1 && v_minor > 4)
+            || (v_major == 1 && v_minor == 4 && v_patch > 10),
+        has_wait: (v_major > 1)
+            || (v_major == 1 && v_minor > 4)
+            || (v_major == 1 && v_minor == 4 && v_patch > 19),
     })
 }
 
@@ -123,25 +131,31 @@ impl IPTables {
     pub fn get_policy(&self, table: &str, chain: &str) -> IPTResult<String> {
         let builtin_chains = get_builtin_chains(table)?;
         if !builtin_chains.iter().as_slice().contains(&chain) {
-            return Err(IPTError::Other("given chain is not a default chain in the given table, can't get policy"));
+            return Err(IPTError::Other(
+                "given chain is not a default chain in the given table, can't get policy",
+            ));
         }
 
-        let output = String::from_utf8_lossy(&self.run(&["-t", table, "-L", chain])?.stdout)
-            .into_owned();
+        let output =
+            String::from_utf8_lossy(&self.run(&["-t", table, "-L", chain])?.stdout).into_owned();
         for item in output.trim().split("\n") {
             let fields = item.split(" ").collect::<Vec<&str>>();
             if fields.len() > 1 && fields[0] == "Chain" && fields[1] == chain {
                 return Ok(fields[3].replace(")", ""));
             }
         }
-        Err(IPTError::Other("could not find the default policy for table and chain"))
+        Err(IPTError::Other(
+            "could not find the default policy for table and chain",
+        ))
     }
 
     /// Set the default policy for a table/chain.
     pub fn set_policy(&self, table: &str, chain: &str, policy: &str) -> IPTResult<bool> {
         let builtin_chains = get_builtin_chains(table)?;
         if !builtin_chains.iter().as_slice().contains(&chain) {
-            return Err(IPTError::Other("given chain is not a default chain in the given table, can't set policy"));
+            return Err(IPTError::Other(
+                "given chain is not a default chain in the given table, can't set policy",
+            ));
         }
 
         match self.run(&["-t", table, "-P", chain, policy]) {
@@ -183,17 +197,29 @@ impl IPTables {
     /// Inserts `rule` in the `position` to the table/chain.
     /// Returns `true` if the rule is inserted.
     pub fn insert(&self, table: &str, chain: &str, rule: &str, position: i32) -> IPTResult<bool> {
-        match self.run(&[&["-t", table, "-I", chain, &position.to_string()], rule.split_quoted().as_slice()].concat()) {
+        match self.run(
+            &[
+                &["-t", table, "-I", chain, &position.to_string()],
+                rule.split_quoted().as_slice(),
+            ]
+            .concat(),
+        ) {
             Ok(output) => Ok(output.status.success()),
             Err(err) => Err(err),
         }
     }
 
     /// Inserts `rule` in the `position` to the table/chain if it does not exist.
     /// Returns `true` if the rule is inserted.
-    pub fn insert_unique(&self, table: &str, chain: &str, rule: &str, position: i32) -> IPTResult<bool> {
+    pub fn insert_unique(
+        &self,
+        table: &str,
+        chain: &str,
+        rule: &str,
+        position: i32,
+    ) -> IPTResult<bool> {
         if self.exists(table, chain, rule)? {
-            return Err(IPTError::Other("the rule exists in the table/chain"))
+            return Err(IPTError::Other("the rule exists in the table/chain"));
         }
 
         self.insert(table, chain, rule, position)
@@ -202,7 +228,13 @@ impl IPTables {
     /// Replaces `rule` in the `position` to the table/chain.
     /// Returns `true` if the rule is replaced.
     pub fn replace(&self, table: &str, chain: &str, rule: &str, position: i32) -> IPTResult<bool> {
-        match self.run(&[&["-t", table, "-R", chain, &position.to_string()], rule.split_quoted().as_slice()].concat()) {
+        match self.run(
+            &[
+                &["-t", table, "-R", chain, &position.to_string()],
+                rule.split_quoted().as_slice(),
+            ]
+            .concat(),
+        ) {
             Ok(output) => Ok(output.status.success()),
             Err(err) => Err(err),
         }
@@ -221,7 +253,7 @@ impl IPTables {
     /// Returns `true` if the rule is appended.
     pub fn append_unique(&self, table: &str, chain: &str, rule: &str) -> IPTResult<bool> {
         if self.exists(table, chain, rule)? {
-            return Err(IPTError::Other("the rule exists in the table/chain"))
+            return Err(IPTError::Other("the rule exists in the table/chain"));
         }
 
         self.append(table, chain, rule)
@@ -325,7 +357,9 @@ impl IPTables {
 
     fn exists_old_version(&self, table: &str, chain: &str, rule: &str) -> IPTResult<bool> {
         match self.run(&["-t", table, "-S"]) {
-            Ok(output) => Ok(String::from_utf8_lossy(&output.stdout).into_owned().contains(&format!("-A {} {}", chain, rule))),
+            Ok(output) => Ok(String::from_utf8_lossy(&output.stdout)
+                .into_owned()
+                .contains(&format!("-A {} {}", chain, rule))),
             Err(err) => Err(err),
         }
     }
@@ -352,14 +386,18 @@ impl IPTables {
 
             let mut need_retry = true;
             while need_retry {
-                match flock(file_lock.as_ref().unwrap().as_raw_fd(), FlockArg::LockExclusiveNonblock) {
+                match flock(
+                    file_lock.as_ref().unwrap().as_raw_fd(),
+                    FlockArg::LockExclusiveNonblock,
+                ) {
                     Ok(_) => need_retry = false,
-                    Err(e) => if e.errno() == nix::errno::EAGAIN {
+                    Err(nix::Error::Sys(en)) if en == nix::errno::Errno::EAGAIN => {
                         // FIXME: may cause infinite loop
                         need_retry = true;
-                    } else {
+                    }
+                    Err(e) => {
                         return Err(IPTError::Nix(e));
-                    },
+                    }
                 }
             }
             output = output_cmd.args(args).output()?;