freefare 0.3.0

Rust bindings for the libfreefare library
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
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155

use ::nfc_sys;
use ::freefare_sys;

use libc::size_t;

pub struct Felica;

impl Felica {
    /// Checks if the NFC target is a Felica card
    pub fn taste(device: *mut nfc_sys::nfc_device, target: nfc_sys::nfc_target) -> Result<bool, String> {
        if device.is_null() {
            return Err("Device is null. Cannot check Felica target.".to_string());
        }

        let result = unsafe { freefare_sys::felica_taste(device, target) };
        Ok(result != 0)
    }

    /// Creates a new Felica tag object
    pub fn tag_new(device: *mut nfc_sys::nfc_device, target: nfc_sys::nfc_target) -> Result<freefare_sys::FreefareTag, String> {
        if device.is_null() {
            return Err("Device is null. Cannot create Felica tag.".to_string());
        }

        let tag = unsafe { freefare_sys::felica_tag_new(device, target) };
        if tag.is_null() {
            Err("Failed to create Felica tag.".to_string())
        } else {
            Ok(tag)
        }
    }

    /// Frees a Felica tag object
    pub fn tag_free(tag: freefare_sys::FreefareTag) {
        if !tag.is_null() {
            unsafe { freefare_sys::felica_tag_free(tag) };
        }
    }

    /// Reads a block from the Felica card
    pub fn read(
        tag: freefare_sys::FreefareTag,
        service: u16,
        block: u8,
        buffer: &mut [u8],
    ) -> Result<usize, String> {
        if tag.is_null() {
            return Err("Tag is null. Cannot read Felica block.".to_string());
        }

        let length = buffer.len() as size_t;
        let result = unsafe {
            freefare_sys::felica_read(tag, service, block, buffer.as_mut_ptr(), length)
        };

        if result < 0 {
            Err("Failed to read Felica block.".to_string())
        } else {
            Ok(result as usize)
        }
    }

    /// Reads multiple blocks from the Felica card
    pub fn read_ex(
        tag: freefare_sys::FreefareTag,
        service: u16,
        block_count: u8,
        blocks: &mut [u8],
        buffer: &mut [u8],
    ) -> Result<usize, String> {
        if tag.is_null() {
            return Err("Tag is null. Cannot read Felica blocks.".to_string());
        }

        if blocks.len() < block_count as usize {
            return Err("Block buffer is too small for the specified block count.".to_string());
        }

        let length = buffer.len() as size_t;
        let result = unsafe {
            freefare_sys::felica_read_ex(
                tag,
                service,
                block_count,
                blocks.as_mut_ptr(),
                buffer.as_mut_ptr(),
                length,
            )
        };

        if result < 0 {
            Err("Failed to read Felica blocks.".to_string())
        } else {
            Ok(result as usize)
        }
    }

    /// Writes a block to the Felica card
    pub fn write(
        tag: freefare_sys::FreefareTag,
        service: u16,
        block: u8,
        buffer: &[u8],
    ) -> Result<usize, String> {
        if tag.is_null() {
            return Err("Tag is null. Cannot write Felica block.".to_string());
        }

        let length = buffer.len() as size_t;
        let result = unsafe {
            freefare_sys::felica_write(tag, service, block, buffer.as_ptr() as *mut u8, length)
        };

        if result < 0 {
            Err("Failed to write Felica block.".to_string())
        } else {
            Ok(result as usize)
        }
    }

    /// Writes multiple blocks to the Felica card
    pub fn write_ex(
        tag: freefare_sys::FreefareTag,
        service: u16,
        block_count: u8,
        blocks: &mut [u8],
        buffer: &[u8],
    ) -> Result<usize, String> {
        if tag.is_null() {
            return Err("Tag is null. Cannot write Felica blocks.".to_string());
        }

        if blocks.len() < block_count as usize {
            return Err("Block buffer is too small for the specified block count.".to_string());
        }

        let length = buffer.len() as size_t;
        let result = unsafe {
            freefare_sys::felica_write_ex(
                tag,
                service,
                block_count,
                blocks.as_mut_ptr(),
                buffer.as_ptr() as *mut u8,
                length,
            )
        };

        if result < 0 {
            Err("Failed to write Felica blocks.".to_string())
        } else {
            Ok(result as usize)
        }
    }
}