enh(generic-snmp): work on bulk snmp get

experimental/src/generic/mod.rs

@@ -1,8 +1,10 @@
 extern crate serde;
 extern crate serde_json;
 
-use snmp::{r_snmp_bulk_walk, SnmpResult};
 use serde::Deserialize;
+use snmp::{r_snmp_bulk_walk, SnmpResult, SnmpValue};
+
+use std::collections::BTreeMap;
 
 #[derive(Copy, Clone, PartialEq)]
 pub enum Status {
@@ -177,9 +179,37 @@ impl Command {
         target: &str,
         version: &str,
         community: &str,
-        ext: &CommandExt,
+        //ext: &CommandExt,
     ) -> CmdResult {
-//        let mut agregation = ("", 0, Operation::None);
+        let mut res: BTreeMap<String, i64> = BTreeMap::new();
+        for s in self.collect.snmp.iter() {
+            match s.query {
+                QueryType::Walk => {
+                    let r = r_snmp_bulk_walk(target, version, community, &s.oid);
+                    match r.variables.len() {
+                        1 => {
+                            let result = r.variables.get(0).unwrap();
+                            if let SnmpValue::Integer(v) = result.value {
+                                res.insert(s.name.clone(), v);
+                            }
+                        }
+                        _ => {
+                            for (idx, result) in r.variables.iter().enumerate() {
+                                if let SnmpValue::Integer(v) = result.value {
+                                    res.insert(format!("{}_{}", &s.name, idx), v);
+                                }
+                            }
+                        }
+                    }
+                }
+                QueryType::Get => {
+                    //                    let r = r_snmp_bulk_get(target, version, community, &s.oid);
+                    //                    res.insert(&s.name, r);
+                }
+            }
+        }
+        println!("{:?}", res);
+        //        let mut aggregation = ("", 0, Operation::None);
         //        let mut res: Option<(&str, SnmpResult)> = None;
         //        for (idx, entry) in self.leaf.entries.iter().enumerate() {
         //            match entry {

experimental/src/main.rs

@@ -71,6 +71,8 @@ fn main() {
     let mut parser = lexopt::Parser::from_env();
     let mut hostname = "localhost".to_string();
     let mut port = 161;
+    let mut snmp_version = "2c".to_string();
+    let mut snmp_community = "public".to_string();
     let mut json = None;
     loop {
         let arg = parser.next();
@@ -91,6 +93,14 @@ fn main() {
                                 json = Some(parser.value().unwrap().into_string().unwrap());
                                 println!("json: {:?}", json);
                             },
+                            Short('v') | Long("snmp-version") => {
+                                snmp_version = parser.value().unwrap().into_string().unwrap();
+                                println!("snmp_version: {}", snmp_version);
+                            },
+                            Short('c') | Long("snmp-community") => {
+                                snmp_community = parser.value().unwrap().into_string().unwrap();
+                                println!("snmp_community: {}", snmp_community);
+                            },
                             _ => {
                                 println!("other");
                             }
@@ -123,7 +133,7 @@ fn main() {
     //    warning_agregation: cli.warning_agregation,
     //    critical_agregation: cli.critical_agregation,
     //};
-    //let result = cmd.execute(&url, &cli.snmp_version, &cli.community, &ext);
+    let result = cmd.execute(&url, &snmp_version, &snmp_community);
     //println!("{}", result.output);
     //std::process::exit(result.status as i32);
 }

experimental/src/snmp/mod.rs

@@ -4,6 +4,7 @@ extern crate rasn_smi;
 extern crate rasn_snmp;
 
 use log::{info, trace, warn};
+use rasn::types::IntegerType;
 use rasn::types::ObjectIdentifier;
 use rasn_snmp::v2::Pdus;
 use rasn_snmp::v2::VarBind;
@@ -11,6 +12,7 @@ use rasn_snmp::v2::VarBindValue;
 use rasn_snmp::v2::{BulkPdu, Pdu};
 use rasn_snmp::v2::{GetBulkRequest, GetNextRequest, GetRequest};
 use rasn_snmp::v2c::Message;
+use std::convert::TryInto;
 use std::ffi::CStr;
 use std::ffi::CString;
 use std::net::UdpSocket;
@@ -23,14 +25,20 @@ pub struct SnmpResult {
 
 type CSnmpVariable = c_void;
 
+#[derive(Debug, PartialEq)]
+pub enum SnmpValue {
+    Integer(i64),
+    String(String),
+}
+
 #[derive(Debug, PartialEq)]
 pub struct SnmpVariable {
     pub name: String,
-    pub value: String,
+    pub value: SnmpValue,
 }
 
 impl SnmpVariable {
-    fn new(name: String, value: String) -> SnmpVariable {
+    fn new(name: String, value: SnmpValue) -> SnmpVariable {
         SnmpVariable { name, value }
     }
 }
@@ -44,7 +52,7 @@ impl SnmpResult {
         }
     }
 
-    fn add_variable(&mut self, name: String, value: String) {
+    fn add_variable(&mut self, name: String, value: SnmpValue) {
         self.variables.push(SnmpVariable::new(name, value));
     }
 
@@ -53,83 +61,83 @@ impl SnmpResult {
     }
 }
 
-#[allow(non_snake_case)]
+//#[allow(non_snake_case)]
-#[no_mangle]
+//#[no_mangle]
-pub extern "C" fn snmpresult_DESTROY(p: *mut CSnmpResult) {
+//pub extern "C" fn snmpresult_DESTROY(p: *mut CSnmpResult) {
-    unsafe { Box::from_raw(p as *mut SnmpResult) };
+//    unsafe { Box::from_raw(p as *mut SnmpResult) };
-}
+//}
 
-#[allow(non_snake_case)]
+//#[allow(non_snake_case)]
-#[no_mangle]
+//#[no_mangle]
-pub extern "C" fn snmpresult_get_variable(p: *mut CSnmpResult, index: usize) -> *mut CSnmpVariable {
+//pub extern "C" fn snmpresult_get_variable(p: *mut CSnmpResult, index: usize) -> *mut CSnmpVariable {
-    trace!("snmpresult_get_variable {}", index);
+//    trace!("snmpresult_get_variable {}", index);
-    let p = p as *mut SnmpResult;
+//    let p = p as *mut SnmpResult;
-    let p = unsafe { &mut *p };
+//    let p = unsafe { &mut *p };
-    if index >= p.variables.len() {
+//    if index >= p.variables.len() {
-        return Box::into_raw(Box::new(SnmpVariable::new("".to_string(), "".to_string())))
+//        return Box::into_raw(Box::new(SnmpVariable::new("".to_string(), "".to_string())))
-            as *mut CSnmpVariable;
+//            as *mut CSnmpVariable;
-    }
+//    }
-    let v = &p.variables[index];
+//    let v = &p.variables[index];
-    Box::into_raw(Box::new(SnmpVariable {
+//    Box::into_raw(Box::new(SnmpVariable {
-        name: v.name.clone(),
+//        name: v.name.clone(),
-        value: v.value.clone(),
+//        value: v.value.clone(),
-    })) as *mut CSnmpVariable
+//    })) as *mut CSnmpVariable
-}
+//}
+//
+//#[allow(non_snake_case)]
+//#[no_mangle]
+//pub extern "C" fn snmpresult_variables_count(p: *mut CSnmpResult) -> usize {
+//    let p = p as *mut SnmpResult;
+//    let p = unsafe { &mut *p };
+//    p.variables.len()
+//}
+//
+//#[allow(non_snake_case)]
+//#[no_mangle]
+//pub extern "C" fn snmpvariable_DESTROY(p: *mut CSnmpVariable) {
+//    unsafe { Box::from_raw(p as *mut SnmpVariable) };
+//}
 
-#[allow(non_snake_case)]
+//#[allow(non_snake_case)]
-#[no_mangle]
+//#[no_mangle]
-pub extern "C" fn snmpresult_variables_count(p: *mut CSnmpResult) -> usize {
+//pub extern "C" fn snmpvariable_get_name(p: *mut CSnmpVariable) -> *mut c_char {
-    let p = p as *mut SnmpResult;
+//    let p = p as *mut SnmpVariable;
-    let p = unsafe { &mut *p };
+//    let p = unsafe { &mut *p };
-    p.variables.len()
+//    let c = CString::new(p.name.clone()).unwrap();
-}
+//    c.into_raw()
+//}
+//
+//#[allow(non_snake_case)]
+//#[no_mangle]
+//pub extern "C" fn snmpvariable_get_value(p: *mut CSnmpVariable) -> *mut c_char {
+//    let p = p as *mut SnmpVariable;
+//    let p = unsafe { &mut *p };
+//    let c = CString::new(p.value.clone()).unwrap();
+//    c.into_raw()
+//}
 
-#[allow(non_snake_case)]
+//#[no_mangle]
-#[no_mangle]
+//pub extern "C" fn snmp_get(target: *const c_char, oid: *const c_char) -> *mut CSnmpResult {
-pub extern "C" fn snmpvariable_DESTROY(p: *mut CSnmpVariable) {
+//    if target.is_null() {
-    unsafe { Box::from_raw(p as *mut SnmpVariable) };
+//        return Box::into_raw(Box::new(SnmpResult::new())) as *mut CSnmpResult;
-}
+//    }
-
+//    let target = unsafe { CStr::from_ptr(target) };
-#[allow(non_snake_case)]
+//    let target = match target.to_str() {
-#[no_mangle]
+//        Ok(s) => s,
-pub extern "C" fn snmpvariable_get_name(p: *mut CSnmpVariable) -> *mut c_char {
+//        Err(_) => "",
-    let p = p as *mut SnmpVariable;
+//    };
-    let p = unsafe { &mut *p };
+//
-    let c = CString::new(p.name.clone()).unwrap();
+//    if oid.is_null() {
-    c.into_raw()
+//        return Box::into_raw(Box::new(SnmpResult::new())) as *mut CSnmpResult;
-}
+//    }
-
+//    let oid = unsafe { CStr::from_ptr(oid) };
-#[allow(non_snake_case)]
+//    let oid = match oid.to_str() {
-#[no_mangle]
+//        Ok(s) => s,
-pub extern "C" fn snmpvariable_get_value(p: *mut CSnmpVariable) -> *mut c_char {
+//        Err(_) => "",
-    let p = p as *mut SnmpVariable;
+//    };
-    let p = unsafe { &mut *p };
+//
-    let c = CString::new(p.value.clone()).unwrap();
+//    Box::into_raw(Box::new(r_snmp_get(target, oid, "public"))) as *mut CSnmpResult
-    c.into_raw()
+//}
-}
-
-#[no_mangle]
-pub extern "C" fn snmp_get(target: *const c_char, oid: *const c_char) -> *mut CSnmpResult {
-    if target.is_null() {
-        return Box::into_raw(Box::new(SnmpResult::new())) as *mut CSnmpResult;
-    }
-    let target = unsafe { CStr::from_ptr(target) };
-    let target = match target.to_str() {
-        Ok(s) => s,
-        Err(_) => "",
-    };
-
-    if oid.is_null() {
-        return Box::into_raw(Box::new(SnmpResult::new())) as *mut CSnmpResult;
-    }
-    let oid = unsafe { CStr::from_ptr(oid) };
-    let oid = match oid.to_str() {
-        Ok(s) => s,
-        Err(_) => "",
-    };
-
-    Box::into_raw(Box::new(r_snmp_get(target, oid, "public"))) as *mut CSnmpResult
-}
 
 pub fn r_snmp_get(target: &str, oid: &str, community: &str) -> SnmpResult {
     let oid_tab = oid
@@ -175,27 +183,27 @@ pub fn r_snmp_get(target: &str, oid: &str, community: &str) -> SnmpResult {
     build_response(decoded, false).0
 }
 
-#[no_mangle]
+//#[no_mangle]
-pub extern "C" fn snmp_walk(target: *const c_char, oid: *const c_char) -> *mut CSnmpResult {
+//pub extern "C" fn snmp_walk(target: *const c_char, oid: *const c_char) -> *mut CSnmpResult {
-    if target.is_null() {
+//    if target.is_null() {
-        return Box::into_raw(Box::new(SnmpResult::new())) as *mut CSnmpResult;
+//        return Box::into_raw(Box::new(SnmpResult::new())) as *mut CSnmpResult;
-    }
+//    }
-    let target = unsafe { CStr::from_ptr(target) };
+//    let target = unsafe { CStr::from_ptr(target) };
-    let target = match target.to_str() {
+//    let target = match target.to_str() {
-        Ok(s) => s,
+//        Ok(s) => s,
-        Err(_) => "",
+//        Err(_) => "",
-    };
+//    };
-
+//
-    if oid.is_null() {
+//    if oid.is_null() {
-        return Box::into_raw(Box::new(SnmpResult::new())) as *mut CSnmpResult;
+//        return Box::into_raw(Box::new(SnmpResult::new())) as *mut CSnmpResult;
-    }
+//    }
-    let oid = unsafe { CStr::from_ptr(oid) };
+//    let oid = unsafe { CStr::from_ptr(oid) };
-    let oid = match oid.to_str() {
+//    let oid = match oid.to_str() {
-        Ok(s) => s,
+//        Ok(s) => s,
-        Err(_) => "",
+//        Err(_) => "",
-    };
+//    };
-    Box::into_raw(Box::new(r_snmp_walk(target, oid))) as *mut CSnmpResult
+//    Box::into_raw(Box::new(r_snmp_walk(target, oid))) as *mut CSnmpResult
-}
+//}
 
 pub fn r_snmp_walk(target: &str, oid: &str) -> SnmpResult {
     let community = "public";
@@ -258,6 +266,87 @@ pub fn r_snmp_walk(target: &str, oid: &str) -> SnmpResult {
     retval
 }
 
+///
+/// Bulk get
+/// This function is similar to the get function but it uses the GetBulkRequest PDU
+/// to retrieve multiple values at once.
+///
+/// # Arguments
+/// * `target` - The target IP address and port
+/// * `oid` - The OID to walk
+/// # Returns
+/// An SnmpResult structure containing the variables
+///
+/// # Example
+/// ```
+/// use snmp_rust::r_snmp_bulk_get;
+/// let result = r_snmp_bulk_get("127.0.0.1:161", "2c", "public", "1.3.6.1.2.1.25.3.3.1.2");
+/// ```
+pub fn r_snmp_bulk_get(target: &str, _version: &str, community: &str, oid: &str) -> SnmpResult {
+    let mut oid_tab = oid
+        .split('.')
+        .map(|x| x.parse::<u32>().unwrap())
+        .collect::<Vec<u32>>();
+
+    let mut retval = SnmpResult::new();
+    let mut request_id: i32 = 1;
+
+    let socket = UdpSocket::bind("0.0.0.0:0").unwrap();
+    socket.connect(target).expect("connect function failed");
+
+    loop {
+        let variable_bindings = vec![VarBind {
+            name: ObjectIdentifier::new_unchecked(oid_tab.to_vec().into()),
+            value: VarBindValue::Unspecified,
+        }];
+
+        let pdu = BulkPdu {
+            request_id,
+            non_repeaters: 0,
+            max_repetitions: 10,
+            variable_bindings,
+        };
+
+        let get_request: GetBulkRequest = GetBulkRequest(pdu);
+
+        let message: Message<GetBulkRequest> = Message {
+            version: 1.into(),
+            community: community.to_string().into(),
+            data: get_request.into(),
+        };
+
+        // Send the message through an UDP socket
+        let encoded: Vec<u8> = rasn::der::encode(&message).unwrap();
+        let res: usize = socket.send(&encoded).unwrap();
+        assert!(res == encoded.len());
+
+        let mut buf: [u8; 1024] = [0; 1024];
+        let resp: (usize, std::net::SocketAddr) = socket.recv_from(buf.as_mut_slice()).unwrap();
+
+        trace!("Received {} bytes", resp.0);
+        assert!(resp.0 > 0);
+        let decoded: Message<Pdus> = rasn::ber::decode(&buf[0..resp.0]).unwrap();
+        if let Pdus::Response(resp) = &decoded.data {
+            let resp_oid = &resp.0.variable_bindings[0].name;
+            let n = resp_oid.len() - 1;
+        }
+        let (result, completed) = build_response(decoded, true);
+        retval.concat(result);
+        if completed {
+            break;
+        }
+        oid_tab = retval
+            .variables
+            .last()
+            .unwrap()
+            .name
+            .split('.')
+            .map(|x| x.parse::<u32>().unwrap())
+            .collect::<Vec<u32>>();
+    }
+    retval
+}
+
 ///
 /// Bulk walk
 /// This function is similar to the walk function but it uses the GetBulkRequest PDU
@@ -378,17 +467,18 @@ fn build_response(decoded: Message<Pdus>, walk: bool) -> (SnmpResult, bool) {
                             info!("Simple {:?}", value);
                             match value {
                                 rasn_smi::v2::SimpleSyntax::Integer(value) => {
-                                    retval.add_variable(name, value.to_string());
+                                    let v = value.try_into().unwrap();
+                                    retval.add_variable(name, SnmpValue::Integer(v));
                                 }
                                 rasn_smi::v2::SimpleSyntax::String(value) => {
                                     // We transform the value into a rust String
                                     retval.add_variable(
                                         name,
-                                        String::from_utf8(value.to_vec()).unwrap(),
+                                        SnmpValue::String(String::from_utf8(value.to_vec()).unwrap()),
                                     );
                                 }
                                 _ => {
-                                    retval.add_variable(name, String::from("Other"));
+                                    retval.add_variable(name, SnmpValue::String("Other".to_string()));
                                 }
                             };
                         }