// Copyright 2021 The Fuchsia Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
library fuchsia.wlan.sme;

using fuchsia.wlan.common.security;
using fuchsia.wlan.common;
using fuchsia.wlan.ieee80211 as ieee80211;
using fuchsia.wlan.internal;
using fuchsia.wlan.stats;
using zx;

/// Security protection which should mirror the Protection enum defined in wlan lib common
type Protection = strict enum {
    UNKNOWN = 0;
    OPEN = 1;
    WEP = 2;
    WPA1 = 3;
    WPA1_WPA2_PERSONAL_TKIP_ONLY = 4;
    WPA2_PERSONAL_TKIP_ONLY = 5;
    WPA1_WPA2_PERSONAL = 6;
    WPA2_PERSONAL = 7;
    WPA2_WPA3_PERSONAL = 8;
    WPA3_PERSONAL = 9;
    WPA2_ENTERPRISE = 10;
    WPA3_ENTERPRISE = 11;
};

type UserDisconnectReason = strict enum {
    UNKNOWN = 0;
    FAILED_TO_CONNECT = 1;
    FIDL_CONNECT_REQUEST = 2;
    FIDL_STOP_CLIENT_CONNECTIONS_REQUEST = 3;
    PROACTIVE_NETWORK_SWITCH = 4;
    DISCONNECT_DETECTED_FROM_SME = 5;
    REGULATORY_REGION_CHANGE = 6;
    STARTUP = 7;
    NETWORK_UNSAVED = 8;
    NETWORK_CONFIG_UPDATED = 9;
    RECOVERY = 10;

    // The following reasons should only be used for development and testing.
    WLANSTACK_UNIT_TESTING = 124;
    WLAN_SME_UNIT_TESTING = 125;
    WLAN_SERVICE_UTIL_TESTING = 126;
    WLAN_DEV_TOOL = 127;
};

type DisconnectCause = struct {
    mlme_event_name DisconnectMlmeEventName;
    reason_code ieee80211.ReasonCode;
};

type DisconnectMlmeEventName = strict enum {
    DEAUTHENTICATE_INDICATION = 1;
    DISASSOCIATE_INDICATION = 2;
};

type DisconnectSource = strict union {
    1: ap DisconnectCause;
    2: user UserDisconnectReason;
    3: mlme DisconnectCause;
};

// Compatibility of a BSS with respect to a scanning interface.
//
// When a BSS is compatible with a scanning interface, this type describes the
// mutually supported modes of operation than can be used to establish a
// connection, such as the compatible set of security protocols.
//
// The data provided by this type is only applicable or meaningful when the
// local scanning interface is compatible with a BSS. As such, it is a logic
// error to construct or transmit this type with data that implies
// incompatibility.
//
// See `ScanResult`.
type Compatibility = struct {
    // Mutually supported security protocols.
    //
    // This field describes the intersection of security protocols supported by
    // a remote BSS and a local scanning interface. In this context an empty set
    // is a logic error (implies incompatibility) and so this field must never
    // be empty.
    mutual_security_protocols vector<fuchsia.wlan.common.security.Protocol>:16;
};

// Describes a BSS detected by a scan.
type ScanResult = struct {
    // The compatibility of the scanning interface and a BSS.
    //
    // If this field is absent, then the scanning interface and BSS are
    // incompatible and will not be able to establish a connection.
    compatibility box<Compatibility>;
    // Time of the scan result relative to when the system was powered on.
    // See https://fuchsia.dev/fuchsia-src/concepts/time/language_support#monotonic_time
    timestamp_nanos zx.Time;
    // Describes the BSS detected by the scan.
    bss_description fuchsia.wlan.internal.BssDescription;
};

type ScanResultVector = struct {
    results vector<ScanResult>;
};

type ScanErrorCode = strict enum {
    NOT_SUPPORTED = 1;
    INTERNAL_ERROR = 2;
    INTERNAL_MLME_ERROR = 3;
    SHOULD_WAIT = 4;
    CANCELED_BY_DRIVER_OR_FIRMWARE = 5;
};

type ScanRequest = strict union {
    1: active ActiveScanRequest;
    2: passive PassiveScanRequest;
};

type PassiveScanRequest = struct {};

type ActiveScanRequest = struct {
    /// List of SSIDs to scan for. An empty list of ssids is the same as specifying
    /// a list containing only the wildcard SSID.
    ///
    /// There is no limit on the number of SSIDs specified, but a large number of
    /// SSIDs may result in extended scan times or the error ZX_ERR_INVALID_ARGS to be
    /// returned.
    ssids vector<ieee80211.Ssid>:MAX;
    // TODO(https://fxbug.dev/42170679): SME should instead require the higher layer to specify
    // which channels to scan and return an error if the list is empty.
    /// Channels to scan on. Leave empty for all supported channels.
    channels vector<uint8>:500;
};

type ConnectResult = struct {
    code ieee80211.StatusCode;
    /// `is_credential_rejected` is true if connect failure is likely due to wrong credential.
    /// Policy uses this to determine whether to retry with the same password.
    is_credential_rejected bool;
    /// If `is_reconnect` is false, the result comes from the initial connection request.
    /// If it's true, the result comes from an SME-initiated reconnection.
    is_reconnect bool;
};

type DisconnectInfo = struct {
    /// Whether SME is attempting to reconnect by itself
    is_sme_reconnecting bool;
    /// Where the disconnect originated and associated reason
    disconnect_source DisconnectSource;
};

closed protocol ConnectTransaction {
    /// Return the result of the initial connection request or later SME-initiated reconnection.
    strict -> OnConnectResult(struct {
        result ConnectResult;
    });

    /// Notify that the client has disconnected. If DisconnectInfo indicates that SME is
    /// attempting to reconnect by itself, there's not need for caller to intervene for now.
    strict -> OnDisconnect(struct {
        info DisconnectInfo;
    });

    /// Give an update of the latest signal report.
    strict -> OnSignalReport(struct {
        ind fuchsia.wlan.internal.SignalReportIndication;
    });

    /// Give an update of the channel switching.
    strict -> OnChannelSwitched(struct {
        info fuchsia.wlan.internal.ChannelSwitchInfo;
    });
};

type RadioConfig = struct {
    phy fuchsia.wlan.common.WlanPhyType;
    channel fuchsia.wlan.common.WlanChannel;
};

/// Empty struct used for union variants with no associated data.
type Empty = struct {};

type ConnectRequest = struct {
    ssid ieee80211.Ssid;
    bss_description fuchsia.wlan.internal.BssDescription;
    /// Informs SME whether multiple candidates were available, for metrics.
    multiple_bss_candidates bool;
    /// Authentication method.
    ///
    /// Describes how SME authenticates when connecting to the target network.
    authentication fuchsia.wlan.common.security.Authentication;

    /// Deprecated. SME makes internal decision on whether to perform a passive or active
    /// scan during connect. Setting this field will not affect anything for FullMAC, but
    /// currently SoftMAC still honor this argument.
    deprecated_scan_type fuchsia.wlan.common.ScanType;
};

type ServingApInfo = struct {
    bssid ieee80211.MacAddr;
    ssid ieee80211.Ssid;
    rssi_dbm int8;
    snr_db int8;
    channel fuchsia.wlan.common.WlanChannel;
    protection Protection;
};

type ClientStatusResponse = strict union {
    1: connected ServingApInfo;
    2: connecting ieee80211.Ssid;
    3: idle Empty;
};

closed protocol ClientSme {
    strict Scan(resource struct {
        req ScanRequest;
    }) -> (resource struct {
        // The VMO encodes ScanResultVector with RFC-0120 FIDL persistence.
        scan_results zx.Handle:VMO;
    }) error ScanErrorCode;
    strict Connect(resource struct {
        req ConnectRequest;
        txn server_end:<ConnectTransaction, optional>;
    });
    strict Disconnect(struct {
        reason UserDisconnectReason;
    }) -> ();
    strict Status() -> (struct {
        resp ClientStatusResponse;
    });
    strict WmmStatus() -> (struct {
        resp fuchsia.wlan.internal.WmmStatusResponse;
    }) error int32;

    // This API is for Fuchsia Controller only.
    // This call will fail if scan results exceed the maximum FIDL message size.
    // This provides no functionality over the `Scan` API, and should only be
    // used by Fuchsia Controller where VMO return values are not permitted.
    // TODO(b/334937123): Remove this API when VMO messages are supported.
    strict ScanForController(resource struct {
        req ScanRequest;
    }) -> (resource struct {
        scan_results vector<ScanResult>;
    }) error ScanErrorCode;
};

type ApConfig = struct {
    ssid ieee80211.Ssid;
    password vector<uint8>:64;
    radio_cfg RadioConfig;
};

type StartApResultCode = strict enum {
    SUCCESS = 0;
    ALREADY_STARTED = 1;
    INTERNAL_ERROR = 2;
    CANCELED = 3;
    TIMED_OUT = 4;
    PREVIOUS_START_IN_PROGRESS = 5;
    INVALID_ARGUMENTS = 6;
};

type StopApResultCode = strict enum {
    SUCCESS = 0;
    INTERNAL_ERROR = 1;
    TIMED_OUT = 2;
};

type Ap = struct {
    ssid ieee80211.Ssid;
    channel uint8;
    num_clients uint16;
};

type ApStatusResponse = struct {
    running_ap box<Ap>;
};

closed protocol ApSme {
    strict Start(struct {
        config ApConfig;
    }) -> (struct {
        code StartApResultCode;
    });
    strict Stop() -> (struct {
        code StopApResultCode;
    });
    strict Status() -> (struct {
        resp ApStatusResponse;
    });
};

closed protocol Telemetry {
    strict GetCounterStats() -> (struct {
        stats fuchsia.wlan.stats.IfaceCounterStats;
    }) error zx.Status;
    strict GetHistogramStats() -> (struct {
        stats fuchsia.wlan.stats.IfaceHistogramStats;
    }) error zx.Status;
};

closed protocol FeatureSupport {
    /// Return support for features related to discovery of potential BSSs.
    /// * see [`fuchsia.wlan.common/DiscoverySupport`]
    strict QueryDiscoverySupport() -> (struct {
        resp fuchsia.wlan.common.DiscoverySupport;
    }) error zx.Status;

    /// Return support for features related to the MAC sublayer.
    /// * see [`fuchsia.wlan.common/MacSublayerSupport`]
    strict QueryMacSublayerSupport() -> (struct {
        resp fuchsia.wlan.common.MacSublayerSupport;
    }) error zx.Status;

    /// Return support for features related to security/access control
    /// and data confidentiality.
    /// * see [`fuchsia.wlan.common/SecuritySupport`]
    strict QuerySecuritySupport() -> (struct {
        resp fuchsia.wlan.common.SecuritySupport;
    }) error zx.Status;

    /// Return support for features related to spectrum management.
    /// * see [`fuchsia.wlan.common/SpectrumManagementSupport`]
    strict QuerySpectrumManagementSupport() -> (struct {
        resp fuchsia.wlan.common.SpectrumManagementSupport;
    }) error zx.Status;
};

type LegacyPrivacySupport = struct {
    wep_supported bool;
    wpa1_supported bool;
};

closed protocol UsmeBootstrap {
    strict Start(resource struct {
        generic_sme_server server_end:GenericSme;
        legacy_privacy_support LegacyPrivacySupport;
    }) -> (resource struct {
        inspect_vmo zx.Handle:VMO;
    });
};

// High level SME info independent of the current MAC role.
type GenericSmeQuery = struct {
    role fuchsia.wlan.common.WlanMacRole;
    sta_addr ieee80211.MacAddr;
};

closed protocol GenericSme {
    /// Query the underlying SME to determine basic properties. This should
    /// generally be called first to determine which SME protocol to request
    /// for the SME.
    strict Query() -> (resource struct {
        resp GenericSmeQuery;
    });
    /// Attempt to establish a new connection to an underlying Client SME.
    /// Connections may be established for the whole lifetime of the SME,
    /// but concurrent connections might lead to unexpected behavior.
    /// Likely errors include:
    ///     * NOT_SUPPORTED: The underlying SME is not a Client SME.
    ///     * PEER_CLOSED: The underlying SME is shutting down.
    strict GetClientSme(resource struct {
        sme_server server_end:ClientSme;
    }) -> () error zx.Status;
    /// Attempt to establish a new connection to an underlying AP SME.
    /// Connections may be established for the whole lifetime of the SME,
    /// but concurrent connections might lead to unexpected behavior.
    /// Likely errors include:
    ///     * NOT_SUPPORTED: The underlying SME is not an AP SME.
    ///     * PEER_CLOSED: The underlying SME is shutting down.
    strict GetApSme(resource struct {
        sme_server server_end:ApSme;
    }) -> () error zx.Status;
    /// Attempt to establish a new connection to telemetry information for the
    /// underlying SME.
    /// Connections may be established for the whole lifetime of the SME, and
    /// concurrent connections are safe since this is a read-only API.
    /// Likely errors include:
    ///     * NOT_SUPPORTED: The underlying SME does not support telemetry.
    ///     * PEER_CLOSED: The underlying SME is shutting down.
    strict GetSmeTelemetry(resource struct {
        telemetry_server server_end:Telemetry;
    }) -> () error zx.Status;
    /// Attempt to establish a new connection to feature support information for
    /// the underlying SME.
    /// Connections may be established for the whole lifetime of the SME, and
    /// concurrent connections are safe since this is a read-only API.
    /// Likely errors include:
    ///     * PEER_CLOSED: The underlying SME is shutting down.
    strict GetFeatureSupport(resource struct {
        feature_support_server server_end:FeatureSupport;
    }) -> () error zx.Status;
};