1 /* 2 * Copyright (C) 2008 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 package android.net.wifi; 18 19 import android.os.Parcel; 20 import android.os.Parcelable; 21 22 /** 23 * From <code>defs.h</code> in <code>wpa_supplicant</code>. 24 * <p/> 25 * These enumeration values are used to indicate the current wpa_supplicant 26 * state. This is more fine-grained than most users will be interested in. 27 * In general, it is better to use 28 * {@link android.net.NetworkInfo.State NetworkInfo.State}. 29 * <p/> 30 * Note, the order of these enum constants must match the numerical values of the 31 * state constants in <code>defs.h</code> in <code>wpa_supplicant</code>. 32 */ 33 public enum SupplicantState implements Parcelable { 34 /** 35 * This state indicates that client is not associated, but is likely to 36 * start looking for an access point. This state is entered when a 37 * connection is lost. 38 */ 39 DISCONNECTED, 40 41 /** 42 * Interface is disabled 43 * <p/> 44 * This state is entered if the network interface is disabled. 45 * wpa_supplicant refuses any new operations that would 46 * use the radio until the interface has been enabled. 47 */ 48 INTERFACE_DISABLED, 49 50 /** 51 * Inactive state (wpa_supplicant disabled). 52 * <p/> 53 * This state is entered if there are no enabled networks in the 54 * configuration. wpa_supplicant is not trying to associate with a new 55 * network and external interaction (e.g., ctrl_iface call to add or 56 * enable a network) is needed to start association. 57 */ 58 INACTIVE, 59 60 /** 61 * Scanning for a network. 62 * <p/> 63 * This state is entered when wpa_supplicant starts scanning for a 64 * network. 65 */ 66 SCANNING, 67 68 /** 69 * Trying to authenticate with a BSS/SSID 70 * <p/> 71 * This state is entered when wpa_supplicant has found a suitable BSS 72 * to authenticate with and the driver is configured to try to 73 * authenticate with this BSS. 74 */ 75 AUTHENTICATING, 76 77 /** 78 * Trying to associate with a BSS/SSID. 79 * <p/> 80 * This state is entered when wpa_supplicant has found a suitable BSS 81 * to associate with and the driver is configured to try to associate 82 * with this BSS in ap_scan=1 mode. When using ap_scan=2 mode, this 83 * state is entered when the driver is configured to try to associate 84 * with a network using the configured SSID and security policy. 85 */ 86 ASSOCIATING, 87 88 /** 89 * Association completed. 90 * <p/> 91 * This state is entered when the driver reports that association has 92 * been successfully completed with an AP. If IEEE 802.1X is used 93 * (with or without WPA/WPA2), wpa_supplicant remains in this state 94 * until the IEEE 802.1X/EAPOL authentication has been completed. 95 */ 96 ASSOCIATED, 97 98 /** 99 * WPA 4-Way Key Handshake in progress. 100 * <p/> 101 * This state is entered when WPA/WPA2 4-Way Handshake is started. In 102 * case of WPA-PSK, this happens when receiving the first EAPOL-Key 103 * frame after association. In case of WPA-EAP, this state is entered 104 * when the IEEE 802.1X/EAPOL authentication has been completed. 105 */ 106 FOUR_WAY_HANDSHAKE, 107 108 /** 109 * WPA Group Key Handshake in progress. 110 * <p/> 111 * This state is entered when 4-Way Key Handshake has been completed 112 * (i.e., when the supplicant sends out message 4/4) and when Group 113 * Key rekeying is started by the AP (i.e., when supplicant receives 114 * message 1/2). 115 */ 116 GROUP_HANDSHAKE, 117 118 /** 119 * All authentication completed. 120 * <p/> 121 * This state is entered when the full authentication process is 122 * completed. In case of WPA2, this happens when the 4-Way Handshake is 123 * successfully completed. With WPA, this state is entered after the 124 * Group Key Handshake; with IEEE 802.1X (non-WPA) connection is 125 * completed after dynamic keys are received (or if not used, after 126 * the EAP authentication has been completed). With static WEP keys and 127 * plaintext connections, this state is entered when an association 128 * has been completed. 129 * <p/> 130 * This state indicates that the supplicant has completed its 131 * processing for the association phase and that data connection is 132 * fully configured. Note, however, that there may not be any IP 133 * address associated with the connection yet. Typically, a DHCP 134 * request needs to be sent at this point to obtain an address. 135 */ 136 COMPLETED, 137 138 /** 139 * An Android-added state that is reported when a client issues an 140 * explicit DISCONNECT command. In such a case, the supplicant is 141 * not only dissociated from the current access point (as for the 142 * DISCONNECTED state above), but it also does not attempt to connect 143 * to any access point until a RECONNECT or REASSOCIATE command 144 * is issued by the client. 145 */ 146 DORMANT, 147 148 /** 149 * No connection to wpa_supplicant. 150 * <p/> 151 * This is an additional pseudo-state to handle the case where 152 * wpa_supplicant is not running and/or we have not been able 153 * to establish a connection to it. 154 */ 155 UNINITIALIZED, 156 157 /** 158 * A pseudo-state that should normally never be seen. 159 */ 160 INVALID; 161 162 /** 163 * Returns {@code true} if the supplicant state is valid and {@code false} 164 * otherwise. 165 * @param state The supplicant state 166 * @return {@code true} if the supplicant state is valid and {@code false} 167 * otherwise. 168 */ isValidState(SupplicantState state)169 public static boolean isValidState(SupplicantState state) { 170 return state != UNINITIALIZED && state != INVALID; 171 } 172 173 174 /** Supplicant associating or authenticating is considered a handshake state {@hide} */ isHandshakeState(SupplicantState state)175 public static boolean isHandshakeState(SupplicantState state) { 176 switch(state) { 177 case AUTHENTICATING: 178 case ASSOCIATING: 179 case ASSOCIATED: 180 case FOUR_WAY_HANDSHAKE: 181 case GROUP_HANDSHAKE: 182 return true; 183 case COMPLETED: 184 case DISCONNECTED: 185 case INTERFACE_DISABLED: 186 case INACTIVE: 187 case SCANNING: 188 case DORMANT: 189 case UNINITIALIZED: 190 case INVALID: 191 return false; 192 default: 193 throw new IllegalArgumentException("Unknown supplicant state"); 194 } 195 } 196 197 /** @hide */ isConnecting(SupplicantState state)198 public static boolean isConnecting(SupplicantState state) { 199 switch(state) { 200 case AUTHENTICATING: 201 case ASSOCIATING: 202 case ASSOCIATED: 203 case FOUR_WAY_HANDSHAKE: 204 case GROUP_HANDSHAKE: 205 case COMPLETED: 206 return true; 207 case DISCONNECTED: 208 case INTERFACE_DISABLED: 209 case INACTIVE: 210 case SCANNING: 211 case DORMANT: 212 case UNINITIALIZED: 213 case INVALID: 214 return false; 215 default: 216 throw new IllegalArgumentException("Unknown supplicant state"); 217 } 218 } 219 220 /** @hide */ isDriverActive(SupplicantState state)221 public static boolean isDriverActive(SupplicantState state) { 222 switch(state) { 223 case DISCONNECTED: 224 case DORMANT: 225 case INACTIVE: 226 case AUTHENTICATING: 227 case ASSOCIATING: 228 case ASSOCIATED: 229 case SCANNING: 230 case FOUR_WAY_HANDSHAKE: 231 case GROUP_HANDSHAKE: 232 case COMPLETED: 233 return true; 234 case INTERFACE_DISABLED: 235 case UNINITIALIZED: 236 case INVALID: 237 return false; 238 default: 239 throw new IllegalArgumentException("Unknown supplicant state"); 240 } 241 } 242 243 /** Implement the Parcelable interface {@hide} */ describeContents()244 public int describeContents() { 245 return 0; 246 } 247 248 /** Implement the Parcelable interface {@hide} */ writeToParcel(Parcel dest, int flags)249 public void writeToParcel(Parcel dest, int flags) { 250 dest.writeString(name()); 251 } 252 253 /** Implement the Parcelable interface {@hide} */ 254 public static final Creator<SupplicantState> CREATOR = 255 new Creator<SupplicantState>() { 256 public SupplicantState createFromParcel(Parcel in) { 257 return SupplicantState.valueOf(in.readString()); 258 } 259 260 public SupplicantState[] newArray(int size) { 261 return new SupplicantState[size]; 262 } 263 }; 264 265 } 266