wincwifi 0.3.0

WINC1500 Wifi chip embedded driver
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

use core::net::SocketAddrV4;

use super::op::OpImpl;
use crate::client::ClientSocketOp;
use crate::manager::SocketError;
use crate::stack::sock_holder::SocketStore;
use crate::stack::socket_callbacks::SocketCallbacks;
use crate::stack::socket_callbacks::{AsyncOp, AsyncState, ConnectResult};
use crate::transfer::Xfer;
use crate::Handle;
use crate::StackError;

#[derive(Debug)]
pub struct TcpConnectOp {
    handle: Handle,
    addr: SocketAddrV4,
}

impl TcpConnectOp {
    pub fn new(handle: Handle, addr: SocketAddrV4) -> Self {
        Self { handle, addr }
    }
}

impl<X: Xfer> OpImpl<X> for TcpConnectOp {
    type Output = ();
    type Error = StackError;

    fn poll_impl(
        &mut self,
        manager: &mut crate::manager::Manager<X>,
        callbacks: &mut SocketCallbacks,
    ) -> Result<Option<Self::Output>, Self::Error> {
        let (sock, op) = callbacks
            .tcp_sockets
            .get(self.handle)
            .ok_or(StackError::SocketNotFound)?;
        let socket = *sock;

        match op {
            ClientSocketOp::AsyncOp(AsyncOp::Connect(Some(ConnectResult { error })), _) => {
                let error = *error;
                *op = ClientSocketOp::None;
                match error {
                    SocketError::NoError => Ok(Some(())),
                    _ => Err(StackError::OpFailed(error)),
                }
            }
            ClientSocketOp::AsyncOp(AsyncOp::Connect(None), AsyncState::Pending(_)) => Ok(None),
            _ => {
                // Set operation state BEFORE calling send_socket_connect to avoid reentrancy races
                let prev_op = core::mem::replace(
                    op,
                    ClientSocketOp::AsyncOp(AsyncOp::Connect(None), AsyncState::Pending(None)),
                );

                // Now call send_socket_connect - if it fails, revert to previous state
                match manager.send_socket_connect(socket, self.addr) {
                    Ok(()) => Ok(None),
                    Err(e) => {
                        // Revert to previous state on failure
                        *op = prev_op;
                        Err(StackError::ConnectSendFailed(e))
                    }
                }
            }
        }
    }
}