indy-crypto 0.0.2

This is the shared crypto libirary for Hyperledger Indy components.
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

use std::mem;

pub struct CTypesUtils {}

impl CTypesUtils {
    // Returns vector len and data pointer and forces Rust to unmanage vector memory.
    // It can be used only for vector with len == capacity. Otherwise
    // it will be impossible to free this memory correctly
    // Returned pointer is valid only before first vector modification
    // De-allocation must be performed by calling c_byte_array_to_vec only!
    pub fn vec_to_c_byte_array(vec: Vec<u8>) -> (*const u8, usize) {
        assert!(vec.len() == vec.capacity());
        let res = (vec.as_ptr(), vec.len());
        mem::forget(vec);
        res
    }

    // It works only with pointers crated by vec_to_c_byte_array!
    pub fn c_byte_array_to_vec(ptr: *mut u8, len: usize) -> Vec<u8> {
        unsafe { Vec::from_raw_parts(ptr, len, len) }
    }
}

macro_rules! check_useful_c_byte_array {
    ($ptr:ident, $len:expr, $err1:expr, $err2:expr) => {
        if $ptr.is_null() {
            return $err1
        }

        if $len <= 0 {
            return $err2
        }

        let $ptr = unsafe { slice::from_raw_parts($ptr, $len) };
    }
}

macro_rules! check_useful_opt_c_byte_array {
    ($ptr:ident, $len:expr, $err1:expr, $err2:expr) => {
        if !$ptr.is_null() && $len <= 0 {
            return $err2
        }

        let $ptr = if $ptr.is_null() {
            None
        } else {
            unsafe { Some(slice::from_raw_parts($ptr, $len)) }
        };
    }
}

macro_rules! check_useful_c_byte_arrays {
    ($ptrs:ident, $ptr_lens:ident, $ptrs_len:ident, $err1:expr, $err2:expr, $err3:expr) => {
        if $ptrs.is_null() {
            return $err1
        }

        if $ptr_lens.is_null() {
            return $err2
        }

        if $ptrs_len <= 0 {
            return $err3
        }

        let $ptrs: &[*const u8] = unsafe { slice::from_raw_parts($ptrs, $ptrs_len) };
        let $ptr_lens: &[usize] = unsafe { slice::from_raw_parts($ptr_lens, $ptrs_len) };
        let $ptrs: Vec<&[u8]> =
        (0..$ptrs_len)
            .map(|i| unsafe { slice::from_raw_parts($ptrs[i], $ptr_lens[i]) })
            .collect();
    }
}

macro_rules! check_useful_c_byte_array_ptr {
    ($ptr_p:ident, $len_p:expr, $err1:expr, $err2:expr) => {
        if $ptr_p.is_null() {
            return $err1
        }

        if $len_p.is_null() {
            return $err2
        }
    }
}

macro_rules! check_useful_c_ptr {
    ($ptr:ident, $err1:expr) => {
        if $ptr.is_null() {
            return $err1
        }
    }
}