browser_protocol/smartcardemulation/
mod.rs

1use serde::{Serialize, Deserialize};
2use serde_json::Value as JsonValue;
3use std::borrow::Cow;
4
5/// Indicates the PC/SC error code.
6/// 
7/// This maps to:
8/// PC/SC Lite: https://pcsclite.apdu.fr/api/group__ErrorCodes.html
9/// Microsoft: https://learn.microsoft.com/en-us/windows/win32/secauthn/authentication-return-values
10
11#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Default)]
12pub enum ResultCode {
13    #[default]
14    #[serde(rename = "success")]
15    Success,
16    #[serde(rename = "removed-card")]
17    RemovedCard,
18    #[serde(rename = "reset-card")]
19    ResetCard,
20    #[serde(rename = "unpowered-card")]
21    UnpoweredCard,
22    #[serde(rename = "unresponsive-card")]
23    UnresponsiveCard,
24    #[serde(rename = "unsupported-card")]
25    UnsupportedCard,
26    #[serde(rename = "reader-unavailable")]
27    ReaderUnavailable,
28    #[serde(rename = "sharing-violation")]
29    SharingViolation,
30    #[serde(rename = "not-transacted")]
31    NotTransacted,
32    #[serde(rename = "no-smartcard")]
33    NoSmartcard,
34    #[serde(rename = "proto-mismatch")]
35    ProtoMismatch,
36    #[serde(rename = "system-cancelled")]
37    SystemCancelled,
38    #[serde(rename = "not-ready")]
39    NotReady,
40    #[serde(rename = "cancelled")]
41    Cancelled,
42    #[serde(rename = "insufficient-buffer")]
43    InsufficientBuffer,
44    #[serde(rename = "invalid-handle")]
45    InvalidHandle,
46    #[serde(rename = "invalid-parameter")]
47    InvalidParameter,
48    #[serde(rename = "invalid-value")]
49    InvalidValue,
50    #[serde(rename = "no-memory")]
51    NoMemory,
52    #[serde(rename = "timeout")]
53    Timeout,
54    #[serde(rename = "unknown-reader")]
55    UnknownReader,
56    #[serde(rename = "unsupported-feature")]
57    UnsupportedFeature,
58    #[serde(rename = "no-readers-available")]
59    NoReadersAvailable,
60    #[serde(rename = "service-stopped")]
61    ServiceStopped,
62    #[serde(rename = "no-service")]
63    NoService,
64    #[serde(rename = "comm-error")]
65    CommError,
66    #[serde(rename = "internal-error")]
67    InternalError,
68    #[serde(rename = "server-too-busy")]
69    ServerTooBusy,
70    #[serde(rename = "unexpected")]
71    Unexpected,
72    #[serde(rename = "shutdown")]
73    Shutdown,
74    #[serde(rename = "unknown-card")]
75    UnknownCard,
76    #[serde(rename = "unknown")]
77    Unknown,
78}
79
80/// Maps to the |SCARD_SHARE_*| values.
81
82#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Default)]
83pub enum ShareMode {
84    #[default]
85    #[serde(rename = "shared")]
86    Shared,
87    #[serde(rename = "exclusive")]
88    Exclusive,
89    #[serde(rename = "direct")]
90    Direct,
91}
92
93/// Indicates what the reader should do with the card.
94
95#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Default)]
96pub enum Disposition {
97    #[default]
98    #[serde(rename = "leave-card")]
99    LeaveCard,
100    #[serde(rename = "reset-card")]
101    ResetCard,
102    #[serde(rename = "unpower-card")]
103    UnpowerCard,
104    #[serde(rename = "eject-card")]
105    EjectCard,
106}
107
108/// Maps to |SCARD_*| connection state values.
109
110#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Default)]
111pub enum ConnectionState {
112    #[default]
113    #[serde(rename = "absent")]
114    Absent,
115    #[serde(rename = "present")]
116    Present,
117    #[serde(rename = "swallowed")]
118    Swallowed,
119    #[serde(rename = "powered")]
120    Powered,
121    #[serde(rename = "negotiable")]
122    Negotiable,
123    #[serde(rename = "specific")]
124    Specific,
125}
126
127/// Maps to the |SCARD_STATE_*| flags.
128
129#[derive(Debug, Clone, Serialize, Deserialize, Default)]
130#[serde(rename_all = "camelCase")]
131pub struct ReaderStateFlags {
132    #[serde(skip_serializing_if = "Option::is_none")]
133    unaware: Option<bool>,
134    #[serde(skip_serializing_if = "Option::is_none")]
135    ignore: Option<bool>,
136    #[serde(skip_serializing_if = "Option::is_none")]
137    changed: Option<bool>,
138    #[serde(skip_serializing_if = "Option::is_none")]
139    unknown: Option<bool>,
140    #[serde(skip_serializing_if = "Option::is_none")]
141    unavailable: Option<bool>,
142    #[serde(skip_serializing_if = "Option::is_none")]
143    empty: Option<bool>,
144    #[serde(skip_serializing_if = "Option::is_none")]
145    present: Option<bool>,
146    #[serde(skip_serializing_if = "Option::is_none")]
147    exclusive: Option<bool>,
148    #[serde(skip_serializing_if = "Option::is_none")]
149    inuse: Option<bool>,
150    #[serde(skip_serializing_if = "Option::is_none")]
151    mute: Option<bool>,
152    #[serde(skip_serializing_if = "Option::is_none")]
153    unpowered: Option<bool>,
154}
155
156impl ReaderStateFlags {
157    pub fn builder() -> ReaderStateFlagsBuilder {
158        ReaderStateFlagsBuilder {
159            unaware: None,
160            ignore: None,
161            changed: None,
162            unknown: None,
163            unavailable: None,
164            empty: None,
165            present: None,
166            exclusive: None,
167            inuse: None,
168            mute: None,
169            unpowered: None,
170        }
171    }
172    pub fn unaware(&self) -> Option<bool> { self.unaware }
173    pub fn ignore(&self) -> Option<bool> { self.ignore }
174    pub fn changed(&self) -> Option<bool> { self.changed }
175    pub fn unknown(&self) -> Option<bool> { self.unknown }
176    pub fn unavailable(&self) -> Option<bool> { self.unavailable }
177    pub fn empty(&self) -> Option<bool> { self.empty }
178    pub fn present(&self) -> Option<bool> { self.present }
179    pub fn exclusive(&self) -> Option<bool> { self.exclusive }
180    pub fn inuse(&self) -> Option<bool> { self.inuse }
181    pub fn mute(&self) -> Option<bool> { self.mute }
182    pub fn unpowered(&self) -> Option<bool> { self.unpowered }
183}
184
185#[derive(Default)]
186pub struct ReaderStateFlagsBuilder {
187    unaware: Option<bool>,
188    ignore: Option<bool>,
189    changed: Option<bool>,
190    unknown: Option<bool>,
191    unavailable: Option<bool>,
192    empty: Option<bool>,
193    present: Option<bool>,
194    exclusive: Option<bool>,
195    inuse: Option<bool>,
196    mute: Option<bool>,
197    unpowered: Option<bool>,
198}
199
200impl ReaderStateFlagsBuilder {
201    pub fn unaware(mut self, unaware: bool) -> Self { self.unaware = Some(unaware); self }
202    pub fn ignore(mut self, ignore: bool) -> Self { self.ignore = Some(ignore); self }
203    pub fn changed(mut self, changed: bool) -> Self { self.changed = Some(changed); self }
204    pub fn unknown(mut self, unknown: bool) -> Self { self.unknown = Some(unknown); self }
205    pub fn unavailable(mut self, unavailable: bool) -> Self { self.unavailable = Some(unavailable); self }
206    pub fn empty(mut self, empty: bool) -> Self { self.empty = Some(empty); self }
207    pub fn present(mut self, present: bool) -> Self { self.present = Some(present); self }
208    pub fn exclusive(mut self, exclusive: bool) -> Self { self.exclusive = Some(exclusive); self }
209    pub fn inuse(mut self, inuse: bool) -> Self { self.inuse = Some(inuse); self }
210    pub fn mute(mut self, mute: bool) -> Self { self.mute = Some(mute); self }
211    pub fn unpowered(mut self, unpowered: bool) -> Self { self.unpowered = Some(unpowered); self }
212    pub fn build(self) -> ReaderStateFlags {
213        ReaderStateFlags {
214            unaware: self.unaware,
215            ignore: self.ignore,
216            changed: self.changed,
217            unknown: self.unknown,
218            unavailable: self.unavailable,
219            empty: self.empty,
220            present: self.present,
221            exclusive: self.exclusive,
222            inuse: self.inuse,
223            mute: self.mute,
224            unpowered: self.unpowered,
225        }
226    }
227}
228
229/// Maps to the |SCARD_PROTOCOL_*| flags.
230
231#[derive(Debug, Clone, Serialize, Deserialize, Default)]
232#[serde(rename_all = "camelCase")]
233pub struct ProtocolSet {
234    #[serde(skip_serializing_if = "Option::is_none")]
235    t0: Option<bool>,
236    #[serde(skip_serializing_if = "Option::is_none")]
237    t1: Option<bool>,
238    #[serde(skip_serializing_if = "Option::is_none")]
239    raw: Option<bool>,
240}
241
242impl ProtocolSet {
243    pub fn builder() -> ProtocolSetBuilder {
244        ProtocolSetBuilder {
245            t0: None,
246            t1: None,
247            raw: None,
248        }
249    }
250    pub fn t0(&self) -> Option<bool> { self.t0 }
251    pub fn t1(&self) -> Option<bool> { self.t1 }
252    pub fn raw(&self) -> Option<bool> { self.raw }
253}
254
255#[derive(Default)]
256pub struct ProtocolSetBuilder {
257    t0: Option<bool>,
258    t1: Option<bool>,
259    raw: Option<bool>,
260}
261
262impl ProtocolSetBuilder {
263    pub fn t0(mut self, t0: bool) -> Self { self.t0 = Some(t0); self }
264    pub fn t1(mut self, t1: bool) -> Self { self.t1 = Some(t1); self }
265    pub fn raw(mut self, raw: bool) -> Self { self.raw = Some(raw); self }
266    pub fn build(self) -> ProtocolSet {
267        ProtocolSet {
268            t0: self.t0,
269            t1: self.t1,
270            raw: self.raw,
271        }
272    }
273}
274
275/// Maps to the |SCARD_PROTOCOL_*| values.
276
277#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Default)]
278pub enum Protocol {
279    #[default]
280    #[serde(rename = "t0")]
281    T0,
282    #[serde(rename = "t1")]
283    T1,
284    #[serde(rename = "raw")]
285    Raw,
286}
287
288
289#[derive(Debug, Clone, Serialize, Deserialize, Default)]
290#[serde(rename_all = "camelCase")]
291pub struct ReaderStateIn<'a> {
292    reader: Cow<'a, str>,
293    currentState: ReaderStateFlags,
294    currentInsertionCount: u64,
295}
296
297impl<'a> ReaderStateIn<'a> {
298    pub fn builder(reader: impl Into<Cow<'a, str>>, currentState: ReaderStateFlags, currentInsertionCount: u64) -> ReaderStateInBuilder<'a> {
299        ReaderStateInBuilder {
300            reader: reader.into(),
301            currentState: currentState,
302            currentInsertionCount: currentInsertionCount,
303        }
304    }
305    pub fn reader(&self) -> &str { self.reader.as_ref() }
306    pub fn currentState(&self) -> &ReaderStateFlags { &self.currentState }
307    pub fn currentInsertionCount(&self) -> u64 { self.currentInsertionCount }
308}
309
310
311pub struct ReaderStateInBuilder<'a> {
312    reader: Cow<'a, str>,
313    currentState: ReaderStateFlags,
314    currentInsertionCount: u64,
315}
316
317impl<'a> ReaderStateInBuilder<'a> {
318    pub fn build(self) -> ReaderStateIn<'a> {
319        ReaderStateIn {
320            reader: self.reader,
321            currentState: self.currentState,
322            currentInsertionCount: self.currentInsertionCount,
323        }
324    }
325}
326
327
328#[derive(Debug, Clone, Serialize, Deserialize, Default)]
329#[serde(rename_all = "camelCase")]
330pub struct ReaderStateOut<'a> {
331    reader: Cow<'a, str>,
332    eventState: ReaderStateFlags,
333    eventCount: u64,
334    atr: Cow<'a, str>,
335}
336
337impl<'a> ReaderStateOut<'a> {
338    pub fn builder(reader: impl Into<Cow<'a, str>>, eventState: ReaderStateFlags, eventCount: u64, atr: impl Into<Cow<'a, str>>) -> ReaderStateOutBuilder<'a> {
339        ReaderStateOutBuilder {
340            reader: reader.into(),
341            eventState: eventState,
342            eventCount: eventCount,
343            atr: atr.into(),
344        }
345    }
346    pub fn reader(&self) -> &str { self.reader.as_ref() }
347    pub fn eventState(&self) -> &ReaderStateFlags { &self.eventState }
348    pub fn eventCount(&self) -> u64 { self.eventCount }
349    pub fn atr(&self) -> &str { self.atr.as_ref() }
350}
351
352
353pub struct ReaderStateOutBuilder<'a> {
354    reader: Cow<'a, str>,
355    eventState: ReaderStateFlags,
356    eventCount: u64,
357    atr: Cow<'a, str>,
358}
359
360impl<'a> ReaderStateOutBuilder<'a> {
361    pub fn build(self) -> ReaderStateOut<'a> {
362        ReaderStateOut {
363            reader: self.reader,
364            eventState: self.eventState,
365            eventCount: self.eventCount,
366            atr: self.atr,
367        }
368    }
369}
370
371#[derive(Debug, Clone, Serialize, Deserialize, Default)]
372pub struct EnableParams {}
373
374impl EnableParams { pub const METHOD: &'static str = "SmartCardEmulation.enable"; }
375
376impl<'a> crate::CdpCommand<'a> for EnableParams {
377    const METHOD: &'static str = "SmartCardEmulation.enable";
378    type Response = crate::EmptyReturns;
379}
380
381#[derive(Debug, Clone, Serialize, Deserialize, Default)]
382pub struct DisableParams {}
383
384impl DisableParams { pub const METHOD: &'static str = "SmartCardEmulation.disable"; }
385
386impl<'a> crate::CdpCommand<'a> for DisableParams {
387    const METHOD: &'static str = "SmartCardEmulation.disable";
388    type Response = crate::EmptyReturns;
389}
390
391/// Reports the successful result of a |SCardEstablishContext| call.
392/// 
393/// This maps to:
394/// PC/SC Lite: https://pcsclite.apdu.fr/api/group__API.html#gaa1b8970169fd4883a6dc4a8f43f19b67
395/// Microsoft: https://learn.microsoft.com/en-us/windows/win32/api/winscard/nf-winscard-scardestablishcontext
396
397#[derive(Debug, Clone, Serialize, Deserialize, Default)]
398#[serde(rename_all = "camelCase")]
399pub struct ReportEstablishContextResultParams<'a> {
400    requestId: Cow<'a, str>,
401    contextId: u64,
402}
403
404impl<'a> ReportEstablishContextResultParams<'a> {
405    pub fn builder(requestId: impl Into<Cow<'a, str>>, contextId: u64) -> ReportEstablishContextResultParamsBuilder<'a> {
406        ReportEstablishContextResultParamsBuilder {
407            requestId: requestId.into(),
408            contextId: contextId,
409        }
410    }
411    pub fn requestId(&self) -> &str { self.requestId.as_ref() }
412    pub fn contextId(&self) -> u64 { self.contextId }
413}
414
415
416pub struct ReportEstablishContextResultParamsBuilder<'a> {
417    requestId: Cow<'a, str>,
418    contextId: u64,
419}
420
421impl<'a> ReportEstablishContextResultParamsBuilder<'a> {
422    pub fn build(self) -> ReportEstablishContextResultParams<'a> {
423        ReportEstablishContextResultParams {
424            requestId: self.requestId,
425            contextId: self.contextId,
426        }
427    }
428}
429
430impl<'a> ReportEstablishContextResultParams<'a> { pub const METHOD: &'static str = "SmartCardEmulation.reportEstablishContextResult"; }
431
432impl<'a> crate::CdpCommand<'a> for ReportEstablishContextResultParams<'a> {
433    const METHOD: &'static str = "SmartCardEmulation.reportEstablishContextResult";
434    type Response = crate::EmptyReturns;
435}
436
437/// Reports the successful result of a |SCardReleaseContext| call.
438/// 
439/// This maps to:
440/// PC/SC Lite: https://pcsclite.apdu.fr/api/group__API.html#ga6aabcba7744c5c9419fdd6404f73a934
441/// Microsoft: https://learn.microsoft.com/en-us/windows/win32/api/winscard/nf-winscard-scardreleasecontext
442
443#[derive(Debug, Clone, Serialize, Deserialize, Default)]
444#[serde(rename_all = "camelCase")]
445pub struct ReportReleaseContextResultParams<'a> {
446    requestId: Cow<'a, str>,
447}
448
449impl<'a> ReportReleaseContextResultParams<'a> {
450    pub fn builder(requestId: impl Into<Cow<'a, str>>) -> ReportReleaseContextResultParamsBuilder<'a> {
451        ReportReleaseContextResultParamsBuilder {
452            requestId: requestId.into(),
453        }
454    }
455    pub fn requestId(&self) -> &str { self.requestId.as_ref() }
456}
457
458
459pub struct ReportReleaseContextResultParamsBuilder<'a> {
460    requestId: Cow<'a, str>,
461}
462
463impl<'a> ReportReleaseContextResultParamsBuilder<'a> {
464    pub fn build(self) -> ReportReleaseContextResultParams<'a> {
465        ReportReleaseContextResultParams {
466            requestId: self.requestId,
467        }
468    }
469}
470
471impl<'a> ReportReleaseContextResultParams<'a> { pub const METHOD: &'static str = "SmartCardEmulation.reportReleaseContextResult"; }
472
473impl<'a> crate::CdpCommand<'a> for ReportReleaseContextResultParams<'a> {
474    const METHOD: &'static str = "SmartCardEmulation.reportReleaseContextResult";
475    type Response = crate::EmptyReturns;
476}
477
478/// Reports the successful result of a |SCardListReaders| call.
479/// 
480/// This maps to:
481/// PC/SC Lite: https://pcsclite.apdu.fr/api/group__API.html#ga93b07815789b3cf2629d439ecf20f0d9
482/// Microsoft: https://learn.microsoft.com/en-us/windows/win32/api/winscard/nf-winscard-scardlistreadersa
483
484#[derive(Debug, Clone, Serialize, Deserialize, Default)]
485#[serde(rename_all = "camelCase")]
486pub struct ReportListReadersResultParams<'a> {
487    requestId: Cow<'a, str>,
488    readers: Vec<Cow<'a, str>>,
489}
490
491impl<'a> ReportListReadersResultParams<'a> {
492    pub fn builder(requestId: impl Into<Cow<'a, str>>, readers: Vec<Cow<'a, str>>) -> ReportListReadersResultParamsBuilder<'a> {
493        ReportListReadersResultParamsBuilder {
494            requestId: requestId.into(),
495            readers: readers,
496        }
497    }
498    pub fn requestId(&self) -> &str { self.requestId.as_ref() }
499    pub fn readers(&self) -> &[Cow<'a, str>] { &self.readers }
500}
501
502
503pub struct ReportListReadersResultParamsBuilder<'a> {
504    requestId: Cow<'a, str>,
505    readers: Vec<Cow<'a, str>>,
506}
507
508impl<'a> ReportListReadersResultParamsBuilder<'a> {
509    pub fn build(self) -> ReportListReadersResultParams<'a> {
510        ReportListReadersResultParams {
511            requestId: self.requestId,
512            readers: self.readers,
513        }
514    }
515}
516
517impl<'a> ReportListReadersResultParams<'a> { pub const METHOD: &'static str = "SmartCardEmulation.reportListReadersResult"; }
518
519impl<'a> crate::CdpCommand<'a> for ReportListReadersResultParams<'a> {
520    const METHOD: &'static str = "SmartCardEmulation.reportListReadersResult";
521    type Response = crate::EmptyReturns;
522}
523
524/// Reports the successful result of a |SCardGetStatusChange| call.
525/// 
526/// This maps to:
527/// PC/SC Lite: https://pcsclite.apdu.fr/api/group__API.html#ga33247d5d1257d59e55647c3bb717db24
528/// Microsoft: https://learn.microsoft.com/en-us/windows/win32/api/winscard/nf-winscard-scardgetstatuschangea
529
530#[derive(Debug, Clone, Serialize, Deserialize, Default)]
531#[serde(rename_all = "camelCase")]
532pub struct ReportGetStatusChangeResultParams<'a> {
533    requestId: Cow<'a, str>,
534    readerStates: Vec<ReaderStateOut<'a>>,
535}
536
537impl<'a> ReportGetStatusChangeResultParams<'a> {
538    pub fn builder(requestId: impl Into<Cow<'a, str>>, readerStates: Vec<ReaderStateOut<'a>>) -> ReportGetStatusChangeResultParamsBuilder<'a> {
539        ReportGetStatusChangeResultParamsBuilder {
540            requestId: requestId.into(),
541            readerStates: readerStates,
542        }
543    }
544    pub fn requestId(&self) -> &str { self.requestId.as_ref() }
545    pub fn readerStates(&self) -> &[ReaderStateOut<'a>] { &self.readerStates }
546}
547
548
549pub struct ReportGetStatusChangeResultParamsBuilder<'a> {
550    requestId: Cow<'a, str>,
551    readerStates: Vec<ReaderStateOut<'a>>,
552}
553
554impl<'a> ReportGetStatusChangeResultParamsBuilder<'a> {
555    pub fn build(self) -> ReportGetStatusChangeResultParams<'a> {
556        ReportGetStatusChangeResultParams {
557            requestId: self.requestId,
558            readerStates: self.readerStates,
559        }
560    }
561}
562
563impl<'a> ReportGetStatusChangeResultParams<'a> { pub const METHOD: &'static str = "SmartCardEmulation.reportGetStatusChangeResult"; }
564
565impl<'a> crate::CdpCommand<'a> for ReportGetStatusChangeResultParams<'a> {
566    const METHOD: &'static str = "SmartCardEmulation.reportGetStatusChangeResult";
567    type Response = crate::EmptyReturns;
568}
569
570/// Reports the result of a |SCardBeginTransaction| call.
571/// On success, this creates a new transaction object.
572/// 
573/// This maps to:
574/// PC/SC Lite: https://pcsclite.apdu.fr/api/group__API.html#gaddb835dce01a0da1d6ca02d33ee7d861
575/// Microsoft: https://learn.microsoft.com/en-us/windows/win32/api/winscard/nf-winscard-scardbegintransaction
576
577#[derive(Debug, Clone, Serialize, Deserialize, Default)]
578#[serde(rename_all = "camelCase")]
579pub struct ReportBeginTransactionResultParams<'a> {
580    requestId: Cow<'a, str>,
581    handle: i64,
582}
583
584impl<'a> ReportBeginTransactionResultParams<'a> {
585    pub fn builder(requestId: impl Into<Cow<'a, str>>, handle: i64) -> ReportBeginTransactionResultParamsBuilder<'a> {
586        ReportBeginTransactionResultParamsBuilder {
587            requestId: requestId.into(),
588            handle: handle,
589        }
590    }
591    pub fn requestId(&self) -> &str { self.requestId.as_ref() }
592    pub fn handle(&self) -> i64 { self.handle }
593}
594
595
596pub struct ReportBeginTransactionResultParamsBuilder<'a> {
597    requestId: Cow<'a, str>,
598    handle: i64,
599}
600
601impl<'a> ReportBeginTransactionResultParamsBuilder<'a> {
602    pub fn build(self) -> ReportBeginTransactionResultParams<'a> {
603        ReportBeginTransactionResultParams {
604            requestId: self.requestId,
605            handle: self.handle,
606        }
607    }
608}
609
610impl<'a> ReportBeginTransactionResultParams<'a> { pub const METHOD: &'static str = "SmartCardEmulation.reportBeginTransactionResult"; }
611
612impl<'a> crate::CdpCommand<'a> for ReportBeginTransactionResultParams<'a> {
613    const METHOD: &'static str = "SmartCardEmulation.reportBeginTransactionResult";
614    type Response = crate::EmptyReturns;
615}
616
617/// Reports the successful result of a call that returns only a result code.
618/// Used for: |SCardCancel|, |SCardDisconnect|, |SCardSetAttrib|, |SCardEndTransaction|.
619/// 
620/// This maps to:
621/// 1. SCardCancel
622/// PC/SC Lite: https://pcsclite.apdu.fr/api/group__API.html#gaacbbc0c6d6c0cbbeb4f4debf6fbeeee6
623/// Microsoft: https://learn.microsoft.com/en-us/windows/win32/api/winscard/nf-winscard-scardcancel
624/// 
625/// 2. SCardDisconnect
626/// PC/SC Lite: https://pcsclite.apdu.fr/api/group__API.html#ga4be198045c73ec0deb79e66c0ca1738a
627/// Microsoft: https://learn.microsoft.com/en-us/windows/win32/api/winscard/nf-winscard-scarddisconnect
628/// 
629/// 3. SCardSetAttrib
630/// PC/SC Lite: https://pcsclite.apdu.fr/api/group__API.html#ga060f0038a4ddfd5dd2b8fadf3c3a2e4f
631/// Microsoft: https://learn.microsoft.com/en-us/windows/win32/api/winscard/nf-winscard-scardsetattrib
632/// 
633/// 4. SCardEndTransaction
634/// PC/SC Lite: https://pcsclite.apdu.fr/api/group__API.html#gae8742473b404363e5c587f570d7e2f3b
635/// Microsoft: https://learn.microsoft.com/en-us/windows/win32/api/winscard/nf-winscard-scardendtransaction
636
637#[derive(Debug, Clone, Serialize, Deserialize, Default)]
638#[serde(rename_all = "camelCase")]
639pub struct ReportPlainResultParams<'a> {
640    requestId: Cow<'a, str>,
641}
642
643impl<'a> ReportPlainResultParams<'a> {
644    pub fn builder(requestId: impl Into<Cow<'a, str>>) -> ReportPlainResultParamsBuilder<'a> {
645        ReportPlainResultParamsBuilder {
646            requestId: requestId.into(),
647        }
648    }
649    pub fn requestId(&self) -> &str { self.requestId.as_ref() }
650}
651
652
653pub struct ReportPlainResultParamsBuilder<'a> {
654    requestId: Cow<'a, str>,
655}
656
657impl<'a> ReportPlainResultParamsBuilder<'a> {
658    pub fn build(self) -> ReportPlainResultParams<'a> {
659        ReportPlainResultParams {
660            requestId: self.requestId,
661        }
662    }
663}
664
665impl<'a> ReportPlainResultParams<'a> { pub const METHOD: &'static str = "SmartCardEmulation.reportPlainResult"; }
666
667impl<'a> crate::CdpCommand<'a> for ReportPlainResultParams<'a> {
668    const METHOD: &'static str = "SmartCardEmulation.reportPlainResult";
669    type Response = crate::EmptyReturns;
670}
671
672/// Reports the successful result of a |SCardConnect| call.
673/// 
674/// This maps to:
675/// PC/SC Lite: https://pcsclite.apdu.fr/api/group__API.html#ga4e515829752e0a8dbc4d630696a8d6a5
676/// Microsoft: https://learn.microsoft.com/en-us/windows/win32/api/winscard/nf-winscard-scardconnecta
677
678#[derive(Debug, Clone, Serialize, Deserialize, Default)]
679#[serde(rename_all = "camelCase")]
680pub struct ReportConnectResultParams<'a> {
681    requestId: Cow<'a, str>,
682    handle: i64,
683    #[serde(skip_serializing_if = "Option::is_none")]
684    activeProtocol: Option<Protocol>,
685}
686
687impl<'a> ReportConnectResultParams<'a> {
688    pub fn builder(requestId: impl Into<Cow<'a, str>>, handle: i64) -> ReportConnectResultParamsBuilder<'a> {
689        ReportConnectResultParamsBuilder {
690            requestId: requestId.into(),
691            handle: handle,
692            activeProtocol: None,
693        }
694    }
695    pub fn requestId(&self) -> &str { self.requestId.as_ref() }
696    pub fn handle(&self) -> i64 { self.handle }
697    pub fn activeProtocol(&self) -> Option<&Protocol> { self.activeProtocol.as_ref() }
698}
699
700
701pub struct ReportConnectResultParamsBuilder<'a> {
702    requestId: Cow<'a, str>,
703    handle: i64,
704    activeProtocol: Option<Protocol>,
705}
706
707impl<'a> ReportConnectResultParamsBuilder<'a> {
708    pub fn activeProtocol(mut self, activeProtocol: Protocol) -> Self { self.activeProtocol = Some(activeProtocol); self }
709    pub fn build(self) -> ReportConnectResultParams<'a> {
710        ReportConnectResultParams {
711            requestId: self.requestId,
712            handle: self.handle,
713            activeProtocol: self.activeProtocol,
714        }
715    }
716}
717
718impl<'a> ReportConnectResultParams<'a> { pub const METHOD: &'static str = "SmartCardEmulation.reportConnectResult"; }
719
720impl<'a> crate::CdpCommand<'a> for ReportConnectResultParams<'a> {
721    const METHOD: &'static str = "SmartCardEmulation.reportConnectResult";
722    type Response = crate::EmptyReturns;
723}
724
725/// Reports the successful result of a call that sends back data on success.
726/// Used for |SCardTransmit|, |SCardControl|, and |SCardGetAttrib|.
727/// 
728/// This maps to:
729/// 1. SCardTransmit
730/// PC/SC Lite: https://pcsclite.apdu.fr/api/group__API.html#ga9a2d77242a271310269065e64633ab99
731/// Microsoft: https://learn.microsoft.com/en-us/windows/win32/api/winscard/nf-winscard-scardtransmit
732/// 
733/// 2. SCardControl
734/// PC/SC Lite: https://pcsclite.apdu.fr/api/group__API.html#gac3454d4657110fd7f753b2d3d8f4e32f
735/// Microsoft: https://learn.microsoft.com/en-us/windows/win32/api/winscard/nf-winscard-scardcontrol
736/// 
737/// 3. SCardGetAttrib
738/// PC/SC Lite: https://pcsclite.apdu.fr/api/group__API.html#gaacfec51917255b7a25b94c5104961602
739/// Microsoft: https://learn.microsoft.com/en-us/windows/win32/api/winscard/nf-winscard-scardgetattrib
740
741#[derive(Debug, Clone, Serialize, Deserialize, Default)]
742#[serde(rename_all = "camelCase")]
743pub struct ReportDataResultParams<'a> {
744    requestId: Cow<'a, str>,
745    data: Cow<'a, str>,
746}
747
748impl<'a> ReportDataResultParams<'a> {
749    pub fn builder(requestId: impl Into<Cow<'a, str>>, data: impl Into<Cow<'a, str>>) -> ReportDataResultParamsBuilder<'a> {
750        ReportDataResultParamsBuilder {
751            requestId: requestId.into(),
752            data: data.into(),
753        }
754    }
755    pub fn requestId(&self) -> &str { self.requestId.as_ref() }
756    pub fn data(&self) -> &str { self.data.as_ref() }
757}
758
759
760pub struct ReportDataResultParamsBuilder<'a> {
761    requestId: Cow<'a, str>,
762    data: Cow<'a, str>,
763}
764
765impl<'a> ReportDataResultParamsBuilder<'a> {
766    pub fn build(self) -> ReportDataResultParams<'a> {
767        ReportDataResultParams {
768            requestId: self.requestId,
769            data: self.data,
770        }
771    }
772}
773
774impl<'a> ReportDataResultParams<'a> { pub const METHOD: &'static str = "SmartCardEmulation.reportDataResult"; }
775
776impl<'a> crate::CdpCommand<'a> for ReportDataResultParams<'a> {
777    const METHOD: &'static str = "SmartCardEmulation.reportDataResult";
778    type Response = crate::EmptyReturns;
779}
780
781/// Reports the successful result of a |SCardStatus| call.
782/// 
783/// This maps to:
784/// PC/SC Lite: https://pcsclite.apdu.fr/api/group__API.html#gae49c3c894ad7ac12a5b896bde70d0382
785/// Microsoft: https://learn.microsoft.com/en-us/windows/win32/api/winscard/nf-winscard-scardstatusa
786
787#[derive(Debug, Clone, Serialize, Deserialize, Default)]
788#[serde(rename_all = "camelCase")]
789pub struct ReportStatusResultParams<'a> {
790    requestId: Cow<'a, str>,
791    readerName: Cow<'a, str>,
792    state: ConnectionState,
793    atr: Cow<'a, str>,
794    #[serde(skip_serializing_if = "Option::is_none")]
795    protocol: Option<Protocol>,
796}
797
798impl<'a> ReportStatusResultParams<'a> {
799    pub fn builder(requestId: impl Into<Cow<'a, str>>, readerName: impl Into<Cow<'a, str>>, state: ConnectionState, atr: impl Into<Cow<'a, str>>) -> ReportStatusResultParamsBuilder<'a> {
800        ReportStatusResultParamsBuilder {
801            requestId: requestId.into(),
802            readerName: readerName.into(),
803            state: state,
804            atr: atr.into(),
805            protocol: None,
806        }
807    }
808    pub fn requestId(&self) -> &str { self.requestId.as_ref() }
809    pub fn readerName(&self) -> &str { self.readerName.as_ref() }
810    pub fn state(&self) -> &ConnectionState { &self.state }
811    pub fn atr(&self) -> &str { self.atr.as_ref() }
812    pub fn protocol(&self) -> Option<&Protocol> { self.protocol.as_ref() }
813}
814
815
816pub struct ReportStatusResultParamsBuilder<'a> {
817    requestId: Cow<'a, str>,
818    readerName: Cow<'a, str>,
819    state: ConnectionState,
820    atr: Cow<'a, str>,
821    protocol: Option<Protocol>,
822}
823
824impl<'a> ReportStatusResultParamsBuilder<'a> {
825    pub fn protocol(mut self, protocol: Protocol) -> Self { self.protocol = Some(protocol); self }
826    pub fn build(self) -> ReportStatusResultParams<'a> {
827        ReportStatusResultParams {
828            requestId: self.requestId,
829            readerName: self.readerName,
830            state: self.state,
831            atr: self.atr,
832            protocol: self.protocol,
833        }
834    }
835}
836
837impl<'a> ReportStatusResultParams<'a> { pub const METHOD: &'static str = "SmartCardEmulation.reportStatusResult"; }
838
839impl<'a> crate::CdpCommand<'a> for ReportStatusResultParams<'a> {
840    const METHOD: &'static str = "SmartCardEmulation.reportStatusResult";
841    type Response = crate::EmptyReturns;
842}
843
844/// Reports an error result for the given request.
845
846#[derive(Debug, Clone, Serialize, Deserialize, Default)]
847#[serde(rename_all = "camelCase")]
848pub struct ReportErrorParams<'a> {
849    requestId: Cow<'a, str>,
850    resultCode: ResultCode,
851}
852
853impl<'a> ReportErrorParams<'a> {
854    pub fn builder(requestId: impl Into<Cow<'a, str>>, resultCode: ResultCode) -> ReportErrorParamsBuilder<'a> {
855        ReportErrorParamsBuilder {
856            requestId: requestId.into(),
857            resultCode: resultCode,
858        }
859    }
860    pub fn requestId(&self) -> &str { self.requestId.as_ref() }
861    pub fn resultCode(&self) -> &ResultCode { &self.resultCode }
862}
863
864
865pub struct ReportErrorParamsBuilder<'a> {
866    requestId: Cow<'a, str>,
867    resultCode: ResultCode,
868}
869
870impl<'a> ReportErrorParamsBuilder<'a> {
871    pub fn build(self) -> ReportErrorParams<'a> {
872        ReportErrorParams {
873            requestId: self.requestId,
874            resultCode: self.resultCode,
875        }
876    }
877}
878
879impl<'a> ReportErrorParams<'a> { pub const METHOD: &'static str = "SmartCardEmulation.reportError"; }
880
881impl<'a> crate::CdpCommand<'a> for ReportErrorParams<'a> {
882    const METHOD: &'static str = "SmartCardEmulation.reportError";
883    type Response = crate::EmptyReturns;
884}
browser_protocol/smartcardemulation/mod.rs

browser_protocol/smartcardemulation/
mod.rs
