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
114
115
116
117
118
119
120
121
122
123
124
125
126

extern crate proc_macro;
use proc_macro::{Span, TokenStream};
use syn::{parse_macro_input, Error, LitInt};

#[proc_macro]
pub fn encode_oid(input: TokenStream) -> TokenStream {
    let token_stream = input.to_string();
    let (s, relative) = if token_stream.starts_with("rel ") {
        (&token_stream[4..], true)
    } else {
        (token_stream.as_ref(), false)
    };
    let items: Result<Vec<_>, _> = s.split('.').map(|x| x.trim().parse::<u128>()).collect();
    let mut items: &[_] = match items.as_ref() {
        Ok(v) => v.as_ref(),
        Err(_) => return create_error("Could not parse OID"),
    };
    let mut v = Vec::new();
    if !relative {
        if items.len() < 2 {
            if items.len() == 1 && items[0] == 0 {
                return "[0]".parse().unwrap();
            }
            return create_error("Need at least two components for non-relative oid");
        }
        if items[0] > 2 || items[1] > 39 {
            return create_error("First components are too big");
        }
        let first_byte = (items[0] * 40 + items[1]) as u8;
        v.push(first_byte);
        items = &items[2..];
    }
    for &int in items {
        let enc = encode_base128(int);
        v.extend_from_slice(&enc);
    }
    // "fn answer() -> u32 { 42 }".parse().unwrap()
    let mut s = String::with_capacity(2 + 6 * v.len());
    s.push('[');
    for byte in v.iter() {
        s.insert_str(s.len(), &format!("0x{:02x}, ", byte));
    }
    s.push(']');
    s.parse().unwrap()
}

#[inline]
fn create_error(msg: &str) -> TokenStream {
    let s = format!("Invalid OID({})", msg);
    Error::new(Span::call_site().into(), &s)
        .to_compile_error()
        .into()
}

// encode int as base128
fn encode_base128(int: u128) -> Vec<u8> {
    let mut val = int;
    let mut base128 = Vec::new();
    let lo = val & 0x7f;
    base128.push(lo as u8);
    val >>= 7;
    loop {
        if val == 0 {
            base128.reverse();
            return base128;
        }
        let lo = val & 0x7f;
        base128.push(lo as u8 | 0x80);
        val >>= 7;
    }
}

#[proc_macro]
pub fn encode_int(input: TokenStream) -> TokenStream {
    let lit = parse_macro_input!(input as LitInt);

    match impl_encode_int(lit) {
        Ok(ts) => ts,
        Err(e) => e.to_compile_error().into(),
    }

    // let token_stream = input.to_string();
    // let items: Result<Vec<_>, _> = token_stream
    //     .split('.')
    //     .map(|x| x.trim().parse::<u64>())
    //     .collect();
    // let err = Error::new(Span::call_site().into(), "invalid OID");
    // if let Ok(items) = items {
    //     let mut v = Vec::new();
    //     if items.len() < 2 || items[0] > 2 || items[1] > 39 {
    //         return err.to_compile_error().into();
    //     }
    //     let first_byte = (items[0] * 40 + items[1]) as u8;
    //     v.push(first_byte);
    //     for &int in &items[2..] {
    //         let enc = encode_base128(int);
    //         v.extend_from_slice(&enc);
    //     }
    //     // "fn answer() -> u32 { 42 }".parse().unwrap()
    //     let mut s = String::with_capacity(2 + 6 * v.len());
    //     s.push('[');
    //     for byte in v.iter() {
    //         s.insert_str(s.len(), &format!("0x{:02x}, ", byte));
    //     }
    //     s.push(']');
    //     s.parse().unwrap()
    // } else {
    //     eprintln!("could not parse OID '{}'", token_stream);
    //     err.to_compile_error().into()
    // }
}

fn impl_encode_int(lit: LitInt) -> Result<TokenStream, Error> {
    let value = lit.base10_parse::<u64>()?;

    let bytes = value.to_be_bytes();
    let v: Vec<_> = bytes.iter().skip_while(|&c| *c == 0).collect();

    let mut s = String::with_capacity(2 + 6 * v.len());
    s.push('[');
    for byte in v.iter() {
        s.insert_str(s.len(), &format!("0x{:02x}, ", byte));
    }
    s.push(']');
    Ok(s.parse().unwrap())
}