le_wifiClient_interface.h

    1 
    2 
    3 /*
    4  * ====================== WARNING ======================
    5  *
    6  * THE CONTENTS OF THIS FILE HAVE BEEN AUTO-GENERATED.
    7  * DO NOT MODIFY IN ANY WAY.
    8  *
    9  * ====================== WARNING ======================
   10  */
   11 
   12 /**
   13  * @page c_le_wifi_client WiFi Client Service
   14  *
   15  * @ref le_wifiClient_interface.h "API Reference"
   16  *
   17  * <HR>
   18  *
   19  * This API provides WiFi Client setup.
   20  * Please note that the WiFi Client cannot be used at the same time as the WiFi Access Points
   21  * service, due to the sharing of same wifi hardware.
   22  *
   23  * @section le_wifi_binding IPC interfaces binding
   24  *
   25  *
   26  * Here's a code sample binding to WiFi service:
   27  * @verbatim
   28    bindings:
   29    {
   30       clientExe.clientComponent.le_wifiClient -> wifiService.le_wifiClient
   31    }
   32    @endverbatim
   33  *
   34  * @section le_wifiClient_Start Starting the WiFi Client
   35  *
   36  * First of all the function le_wifiClient_Start() must be called to start the WiFi Service.
   37  * - le_wifiClient_Start(): returns LE_OK if the call went ok.
   38  *   If WiFi Access Point is active, this will fail.
   39  *
   40  *
   41  * To subscribe to wifi events le_wifiClient_AddNewEventHandler() is to be called.
   42  * - le_wifiClient_AddNewEventHandler(): returns the handler reference if the call went ok.
   43  *
   44  * @code
   45  *
   46  * static void EventHandler
   47  * (
   48  *     le_wifiClient_Event_t clientEvent,
   49  *     void *contextPtr
   50  * )
   51  * {
   52  *     switch( clientEvent )
   53  *     {
   54  *          case LE_WIFICLIENT_EVENT_CONNECTED:
   55  *          {
   56  *              LE_INFO("WiFi Client Connected.");
   57  *          }
   58  *          break;
   59  *          case LE_WIFICLIENT_EVENT_DISCONNECTED:
   60  *          {
   61  *              LE_INFO("WiFi Client Disconnected.");
   62  *          }
   63  *          break;
   64  *          case LE_WIFICLIENT_EVENT_SCAN_DONE:
   65  *          {
   66  *              LE_INFO("WiFi Client Scan is done.");
   67  *              MyHandleScanResult();
   68  *          }
   69  *          break;
   70  *     }
   71  * }
   72  *
   73  * le_wifiClient_NewEventHandler WiFiEventHandlerRef = NULL;
   74  *
   75  * static void MyInit
   76  * (
   77  *     void
   78  * )
   79  * {
   80  *     le_result_t result = le_wifiClient_start();
   81  *
   82  *     if ( LE_OK == result )
   83  *     {
   84  *         LE_INFO("WiFi Client started.");
   85  *         WiFiEventHandlerRef = le_wifiClient_AddNewEventHandler( EventHandler, NULL );
   86  *     }
   87  *     else if ( LE_DUPLICATE == result )
   88  *     {
   89  *         LE_INFO("ERROR: WiFi Client already started.");
   90  *     }
   91  *     else
   92  *     {
   93  *         LE_INFO("ERROR: WiFi Client not started.");
   94  *     }
   95  *
   96  * }
   97  *
   98  * @endcode
   99  *
  100  *
  101  * @section le_wifiClient_scan Scanning Access Points with WiFi Client
  102  *
  103  * To start a scan for Access Points, the le_wifiClient_Scan() should be called.
  104  * - le_wifiClient_Scan(): returns the LE_OK if the call went ok.
  105  *
  106  *
  107  * @section le_wifiClient_scan_result Processing the WiFi scan results
  108  *
  109  * Once the scan results are available, the event LE_WIFICLIENT_EVENT_SCAN_DONE is received.
  110  * The found Access Points can then be gotten with
  111  * - le_wifiClient_GetFirstAccessPoint():  returns the Access Point if found. Else NULL.
  112  * - le_wifiClient_GetNextAccessPoint(): returns the next Access Point if found. Else NULL.
  113  *
  114  * The Access Points SSID, Service Set Identifier, is not a string.
  115  * It does however often contain human readable ASCII values.
  116  * It can be read with the following function:
  117  * - le_wifiClient_GetSsid() : returns the LE_OK if the SSID was read ok.
  118  *
  119  * The Access Points signal strength can be read with the following function:
  120  * - le_wifiClient_GetSignalStrength() : returns the signal strength in dBm of the AccessPoint
  121  *
  122  * @code
  123  *
  124  * static void MyHandleScanResult
  125  * (
  126  *     void
  127  * )
  128  * {
  129  *     uint8 ssid[MAX_SSID_BYTES];
  130  *     le_wifiClient_AccessPointRef_t accessPointRef = le_wifiClient_GetFirstAccessPoint();
  131  *
  132  *     while( NULL != accessPointRef )
  133  *     {
  134  *          result = le_wifiClient_GetSsid( accessPointRef, ssid, MAX_SSID_BYTES );
  135  *          if (( result == LE_OK ) && ( memcmp( ssid, "MySSID", 6) == 0 ))
  136  *          {
  137  *               LE_INFO("WiFi Client found.");
  138  *               break;
  139  *          }
  140  *          accessPointRef = le_wifiClient_GetNextAccessPoint();
  141  *     }
  142  * }
  143  *
  144  * @endcode
  145  *
  146  * @section le_wifiClient_connect_to_ap Connecting to Access Point
  147  *
  148  * First of all, an Access Point reference should be created using the SSID of the target Access
  149  * Point. Use the following function to create a reference:
  150  * - le_wifiClient_Create(): returns Access Point reference
  151  *
  152  * To set the pass phrase prior for the Access Point use the function:
  153  * - le_wifiClient_SetPassphrase(): returns the function execution status.
  154  *
  155  * WPA-Enterprise requires a username and password to authenticate.
  156  * To set them use the function:
  157  * - le_wifiClient_SetUserCredentials():  returns the function execution status.
  158  *
  159  * If an Access Point is hidden, it does not announce its presence and will not show up in scan.
  160  * So, the SSID of this Access Point must be known in advance. Then, use the following function to
  161  * allow connections to hidden Access Points:
  162  * le_wifiClient_SetHiddenNetworkAttribute(): returns the function execution status.
  163  *
  164  * Finally and when the Access Point parameters have been configured, use the following function to
  165  * attempt a connection:
  166  * - le_wifiClient_Connect():  returns the function execution status.
  167  *
  168  * @code
  169  *
  170  * static void MyConnectTo
  171  * (
  172  *     le_wifiClient_AccessPointRef_t accessPointRef
  173  * )
  174  * {
  175  *     le_result_t result;
  176  *     le_wifiClient_SetPassphrase ( accessPointRef, "Secret1" );
  177  *     result = le_wifiClient_Connect( accessPointRef );
  178  *     if (result == LE_OK)
  179  *     {
  180  *          LE_INFO("Connecting to AP.");
  181  *     }
  182  * }
  183  *
  184  * @endcode
  185  *
  186  * <HR>
  187  *
  188  * Copyright (C) Sierra Wireless Inc.
  189  */
  190 /**
  191  * @file le_wifiClient_interface.h
  192  *
  193  * Legato @ref c_le_wifi_client include file.
  194  *
  195  * Copyright (C) Sierra Wireless Inc.
  196  */
  197 
  198 #ifndef LE_WIFICLIENT_INTERFACE_H_INCLUDE_GUARD
  199 #define LE_WIFICLIENT_INTERFACE_H_INCLUDE_GUARD
  200 
  201 
  202 #include "legato.h"
  203 
  204 // Interface specific includes
  205 #include "le_wifiDefs_interface.h"
  206 
  207 
  208 //--------------------------------------------------------------------------------------------------
  209 /**
  210  * Type for handler called when a server disconnects.
  211  */
  212 //--------------------------------------------------------------------------------------------------
  213 typedef void (*le_wifiClient_DisconnectHandler_t)(void *);
  214 
  215 //--------------------------------------------------------------------------------------------------
  216 /**
  217  *
  218  * Connect the current client thread to the service providing this API. Block until the service is
  219  * available.
  220  *
  221  * For each thread that wants to use this API, either ConnectService or TryConnectService must be
  222  * called before any other functions in this API.  Normally, ConnectService is automatically called
  223  * for the main thread, but not for any other thread. For details, see @ref apiFilesC_client.
  224  *
  225  * This function is created automatically.
  226  */
  227 //--------------------------------------------------------------------------------------------------
  228 void le_wifiClient_ConnectService
  229 (
  230     void
  231 );
  232 
  233 //--------------------------------------------------------------------------------------------------
  234 /**
  235  *
  236  * Try to connect the current client thread to the service providing this API. Return with an error
  237  * if the service is not available.
  238  *
  239  * For each thread that wants to use this API, either ConnectService or TryConnectService must be
  240  * called before any other functions in this API.  Normally, ConnectService is automatically called
  241  * for the main thread, but not for any other thread. For details, see @ref apiFilesC_client.
  242  *
  243  * This function is created automatically.
  244  *
  245  * @return
  246  *  - LE_OK if the client connected successfully to the service.
  247  *  - LE_UNAVAILABLE if the server is not currently offering the service to which the client is
  248  *    bound.
  249  *  - LE_NOT_PERMITTED if the client interface is not bound to any service (doesn't have a binding).
  250  *  - LE_COMM_ERROR if the Service Directory cannot be reached.
  251  */
  252 //--------------------------------------------------------------------------------------------------
  253 le_result_t le_wifiClient_TryConnectService
  254 (
  255     void
  256 );
  257 
  258 //--------------------------------------------------------------------------------------------------
  259 /**
  260  * Set handler called when server disconnection is detected.
  261  *
  262  * When a server connection is lost, call this handler then exit with LE_FATAL.  If a program wants
  263  * to continue without exiting, it should call longjmp() from inside the handler.
  264  */
  265 //--------------------------------------------------------------------------------------------------
  266 void le_wifiClient_SetServerDisconnectHandler
  267 (
  268     le_wifiClient_DisconnectHandler_t disconnectHandler,
  269     void *contextPtr
  270 );
  271 
  272 //--------------------------------------------------------------------------------------------------
  273 /**
  274  *
  275  * Disconnect the current client thread from the service providing this API.
  276  *
  277  * Normally, this function doesn't need to be called. After this function is called, there's no
  278  * longer a connection to the service, and the functions in this API can't be used. For details, see
  279  * @ref apiFilesC_client.
  280  *
  281  * This function is created automatically.
  282  */
  283 //--------------------------------------------------------------------------------------------------
  284 void le_wifiClient_DisconnectService
  285 (
  286     void
  287 );
  288 
  289 
  290 //--------------------------------------------------------------------------------------------------
  291 /**
  292  * Value for no signal strength.
  293  */
  294 //--------------------------------------------------------------------------------------------------
  295 #define LE_WIFICLIENT_NO_SIGNAL_STRENGTH 32767
  296 
  297 //--------------------------------------------------------------------------------------------------
  298 /**
  299  * Reference type for AccessPoint that is returned by the WiFi Scan.
  300  */
  301 //--------------------------------------------------------------------------------------------------
  302 typedef struct le_wifiClient_AccessPoint* le_wifiClient_AccessPointRef_t;
  303 
  304 
  305 //--------------------------------------------------------------------------------------------------
  306 /**
  307  * WiFi Client Events.
  308  */
  309 //--------------------------------------------------------------------------------------------------
  310 typedef enum
  311 {
  312     LE_WIFICLIENT_EVENT_CONNECTED = 0,
  313         ///< WiFi Client Connected
  314     LE_WIFICLIENT_EVENT_DISCONNECTED = 1,
  315         ///< WiFi Client Disconnected
  316     LE_WIFICLIENT_EVENT_SCAN_DONE = 2,
  317         ///< WiFi Scan result for available Access Points available
  318     LE_WIFICLIENT_EVENT_SCAN_FAILED = 3
  319         ///< WiFi Scan failed
  320 }
  321 le_wifiClient_Event_t;
  322 
  323 
  324 //--------------------------------------------------------------------------------------------------
  325 /**
  326  * WiFi Client Security Protocol for connection
  327  */
  328 //--------------------------------------------------------------------------------------------------
  329 typedef enum
  330 {
  331     LE_WIFICLIENT_SECURITY_NONE = 0,
  332         ///< no security.
  333     LE_WIFICLIENT_SECURITY_WEP = 1,
  334         ///< Using WEP.
  335     LE_WIFICLIENT_SECURITY_WPA_PSK_PERSONAL = 2,
  336         ///< Using WPA
  337     LE_WIFICLIENT_SECURITY_WPA2_PSK_PERSONAL = 3,
  338         ///< Using WPA2
  339     LE_WIFICLIENT_SECURITY_WPA_EAP_PEAP0_ENTERPRISE = 4,
  340         ///< Using WPA Enterprise
  341     LE_WIFICLIENT_SECURITY_WPA2_EAP_PEAP0_ENTERPRISE = 5
  342         ///< Using WPA2 Enterprise
  343 }
  344 le_wifiClient_SecurityProtocol_t;
  345 
  346 
  347 //--------------------------------------------------------------------------------------------------
  348 /**
  349  * Reference type used by Add/Remove functions for EVENT 'le_wifiClient_NewEvent'
  350  */
  351 //--------------------------------------------------------------------------------------------------
  352 typedef struct le_wifiClient_NewEventHandler* le_wifiClient_NewEventHandlerRef_t;
  353 
  354 
  355 //--------------------------------------------------------------------------------------------------
  356 /**
  357  * Handler for WiFi Client changes
  358  */
  359 //--------------------------------------------------------------------------------------------------
  360 typedef void (*le_wifiClient_NewEventHandlerFunc_t)
  361 (
  362     le_wifiClient_Event_t event,
  363         ///< Handles the wifi events
  364     void* contextPtr
  365         ///<
  366 );
  367 
  368 //--------------------------------------------------------------------------------------------------
  369 /**
  370  * Add handler function for EVENT 'le_wifiClient_NewEvent'
  371  *
  372  * This event provide information on WiFi Client event changes.
  373  *
  374  */
  375 //--------------------------------------------------------------------------------------------------
  376 le_wifiClient_NewEventHandlerRef_t le_wifiClient_AddNewEventHandler
  377 (
  378     le_wifiClient_NewEventHandlerFunc_t handlerPtr,
  379         ///< [IN]
  380     void* contextPtr
  381         ///< [IN]
  382 );
  383 
  384 //--------------------------------------------------------------------------------------------------
  385 /**
  386  * Remove handler function for EVENT 'le_wifiClient_NewEvent'
  387  */
  388 //--------------------------------------------------------------------------------------------------
  389 void le_wifiClient_RemoveNewEventHandler
  390 (
  391     le_wifiClient_NewEventHandlerRef_t handlerRef
  392         ///< [IN]
  393 );
  394 
  395 //--------------------------------------------------------------------------------------------------
  396 /**
  397  * Start the WIFI device.
  398  *
  399  * @return
  400  *      - LE_OK          Function succeeded.
  401  *      - LE_FAULT       Function failed.
  402  *      - LE_DUPLICATE   The WIFI device is already started.
  403  */
  404 //--------------------------------------------------------------------------------------------------
  405 le_result_t le_wifiClient_Start
  406 (
  407     void
  408 );
  409 
  410 //--------------------------------------------------------------------------------------------------
  411 /**
  412  * Stop the WIFI device.
  413  *
  414  * @return
  415  *      - LE_OK        Function succeeded.
  416  *      - LE_FAULT     Function failed.
  417  *      - LE_DUPLICATE The WIFI device is already stopped.
  418  */
  419 //--------------------------------------------------------------------------------------------------
  420 le_result_t le_wifiClient_Stop
  421 (
  422     void
  423 );
  424 
  425 //--------------------------------------------------------------------------------------------------
  426 /**
  427  * Start Scanning for WiFi Access points
  428  * Will result in event LE_WIFICLIENT_EVENT_SCAN_DONE when the scan results are available.
  429  *
  430  * @return
  431  *      - LE_OK     Function succeeded.
  432  *      - LE_FAULT  Function failed.
  433  *      - LE_BUSY   Scan already running.
  434  */
  435 //--------------------------------------------------------------------------------------------------
  436 le_result_t le_wifiClient_Scan
  437 (
  438     void
  439 );
  440 
  441 //--------------------------------------------------------------------------------------------------
  442 /**
  443  * Get the first WiFi Access Point found.
  444  *
  445  * @return
  446  *      - WiFi  Access Point reference if ok.
  447  *      - NULL  If no Access Point reference available.
  448  */
  449 //--------------------------------------------------------------------------------------------------
  450 le_wifiClient_AccessPointRef_t le_wifiClient_GetFirstAccessPoint
  451 (
  452     void
  453 );
  454 
  455 //--------------------------------------------------------------------------------------------------
  456 /**
  457  * Get the next WiFi Access Point.
  458  * Will return the Access Points in the order of found.
  459  * This function must be called in the same context as the GetFirstAccessPoint
  460  *
  461  * @return
  462  *      - WiFi  Access Point reference if ok.
  463  *      - NULL  If no Access Point reference available.
  464  */
  465 //--------------------------------------------------------------------------------------------------
  466 le_wifiClient_AccessPointRef_t le_wifiClient_GetNextAccessPoint
  467 (
  468     void
  469 );
  470 
  471 //--------------------------------------------------------------------------------------------------
  472 /**
  473  * Get the signal strength of the AccessPoint
  474  *
  475  * @return
  476  *      - Signal strength in dBm. Example -30 = -30dBm
  477  *      - If no signal available it will return LE_WIFICLIENT_NO_SIGNAL_STRENGTH
  478  *
  479  * @note The function returns the signal strength as reported at the time of the scan.
  480  */
  481 //--------------------------------------------------------------------------------------------------
  482 int16_t le_wifiClient_GetSignalStrength
  483 (
  484     le_wifiClient_AccessPointRef_t accessPointRef
  485         ///< [IN] WiFi Access Point reference.
  486 );
  487 
  488 //--------------------------------------------------------------------------------------------------
  489 /**
  490  * Get the Basic Service set identifier (BSSID) of the AccessPoint
  491  *
  492  * @return
  493  *         LE_OK            Function succeeded.
  494  *         LE_FAULT         Function failed.
  495  *         LE_BAD_PARAMETER Invalid parameter.
  496  *         LE_OVERFLOW      bssid buffer is too small to contain the BSSID.
  497  */
  498 //--------------------------------------------------------------------------------------------------
  499 le_result_t le_wifiClient_GetBssid
  500 (
  501     le_wifiClient_AccessPointRef_t accessPointRef,
  502         ///< [IN] WiFi Access Point reference.
  503     char* bssid,
  504         ///< [OUT] The BSSID
  505     size_t bssidSize
  506         ///< [IN]
  507 );
  508 
  509 //--------------------------------------------------------------------------------------------------
  510 /**
  511  * Get the Service set identification (SSID) of the AccessPoint
  512  *
  513  * @return
  514  *        LE_OK            Function succeeded.
  515  *        LE_FAULT         Function failed.
  516  *        LE_BAD_PARAMETER Invalid parameter.
  517  *        LE_OVERFLOW      ssid buffer is too small to contain the SSID.
  518  *
  519  * @note The SSID does not have to be human readable ASCII values, but often is.
  520  */
  521 //--------------------------------------------------------------------------------------------------
  522 le_result_t le_wifiClient_GetSsid
  523 (
  524     le_wifiClient_AccessPointRef_t accessPointRef,
  525         ///< [IN] WiFi Access Point reference.
  526     uint8_t* ssidPtr,
  527         ///< [OUT] The SSID returned as a octet array.
  528     size_t* ssidSizePtr
  529         ///< [INOUT]
  530 );
  531 
  532 //--------------------------------------------------------------------------------------------------
  533 /**
  534  * Set the passphrase used to generate the PSK.
  535  *
  536  * @return
  537  *      - LE_OK            Function succeeded.
  538  *      - LE_FAULT         Function failed.
  539  *      - LE_BAD_PARAMETER Invalid parameter.
  540  *
  541  * @note The difference between le_wifiClient_SetPreSharedKey() and this function
  542  */
  543 //--------------------------------------------------------------------------------------------------
  544 le_result_t le_wifiClient_SetPassphrase
  545 (
  546     le_wifiClient_AccessPointRef_t accessPointRef,
  547         ///< [IN] WiFi Access Point reference.
  548     const char* LE_NONNULL PassPhrase
  549         ///< [IN] pass-phrase for PSK
  550 );
  551 
  552 //--------------------------------------------------------------------------------------------------
  553 /**
  554  * Set the Pre Shared Key, PSK.
  555  *
  556  * @return
  557  *      - LE_OK             Function succeeded.
  558  *      - LE_FAULT          Function failed.
  559  *      - LE_BAD_PARAMETER  Invalid parameter.
  560  *
  561  * @note This is one way to authenticate against the access point. The other one is provided by the
  562  * le_wifiClient_SetPassPhrase() function. Both ways are exclusive and are effective only when used
  563  * with WPA-personal authentication.
  564  */
  565 //--------------------------------------------------------------------------------------------------
  566 le_result_t le_wifiClient_SetPreSharedKey
  567 (
  568     le_wifiClient_AccessPointRef_t accessPointRef,
  569         ///< [IN] WiFi Access Point reference.
  570     const char* LE_NONNULL PreSharedKey
  571         ///< [IN] PSK. Note the difference between PSK and
  572         ///< Pass Phrase.
  573 );
  574 
  575 //--------------------------------------------------------------------------------------------------
  576 /**
  577  * Set the security protocol for connection
  578  *
  579  * @return
  580  *      - LE_OK             Function succeeded.
  581  *      - LE_FAULT          Function failed.
  582  *      - LE_BAD_PARAMETER  Invalid parameter.
  583  */
  584 //--------------------------------------------------------------------------------------------------
  585 le_result_t le_wifiClient_SetSecurityProtocol
  586 (
  587     le_wifiClient_AccessPointRef_t accessPointRef,
  588         ///< [IN] WiFi Access Point reference.
  589     le_wifiClient_SecurityProtocol_t securityProtocol
  590         ///< [IN] Security Mode
  591 );
  592 
  593 //--------------------------------------------------------------------------------------------------
  594 /**
  595  * WPA-Enterprise requires a username and password to authenticate.
  596  * This function sets these parameters.
  597  *
  598  * @return
  599  *      - LE_OK             Function succeeded.
  600  *      - LE_FAULT          Function failed.
  601  *      - LE_BAD_PARAMETER  Invalid parameter.
  602  */
  603 //--------------------------------------------------------------------------------------------------
  604 le_result_t le_wifiClient_SetUserCredentials
  605 (
  606     le_wifiClient_AccessPointRef_t accessPointRef,
  607         ///< [IN] WiFi Access Point reference.
  608     const char* LE_NONNULL userName,
  609         ///< [IN] UserName used for WPA-Enterprise.
  610     const char* LE_NONNULL password
  611         ///< [IN] Password used for WPA-Enterprise.
  612 );
  613 
  614 //--------------------------------------------------------------------------------------------------
  615 /**
  616  * Set the WEP key (WEP)
  617  *
  618  * @return
  619  *      - LE_OK     Function succeeded.
  620  *      - LE_FAULT  Function failed.
  621  */
  622 //--------------------------------------------------------------------------------------------------
  623 le_result_t le_wifiClient_SetWepKey
  624 (
  625     le_wifiClient_AccessPointRef_t accessPointRef,
  626         ///< [IN] WiFi Access Point reference.
  627     const char* LE_NONNULL wepKey
  628         ///< [IN] The WEP key
  629 );
  630 
  631 //--------------------------------------------------------------------------------------------------
  632 /**
  633  * This function specifies whether the target Access Point is hiding its presence from clients or
  634  * not. When an Access Point is hidden, it cannot be discovered by a scan process.
  635  *
  636  * @return
  637  *      - LE_OK             Function succeeded.
  638  *      - LE_BAD_PARAMETER  Invalid parameter.
  639  *
  640  * @note By default, this attribute is not set which means that the client is unable to connect to
  641  * a hidden access point. When enabled, the client will be able to connect to the access point
  642  * whether it is hidden or not.
  643  */
  644 //--------------------------------------------------------------------------------------------------
  645 le_result_t le_wifiClient_SetHiddenNetworkAttribute
  646 (
  647     le_wifiClient_AccessPointRef_t accessPointRef,
  648         ///< [IN] WiFi Access Point reference.
  649     bool hidden
  650         ///< [IN] If TRUE, the WIFI client will be able to connect to a hidden access point.
  651 );
  652 
  653 //--------------------------------------------------------------------------------------------------
  654 /**
  655  * This function creates a reference to an Access Point given its SSID.
  656  * If an Access Point is hidden, it will not show up in the scan. So, its SSID must be known
  657  * in advance in order to create a reference.
  658  *
  659  * @return
  660  *      - AccessPoint reference to the current Access Point.
  661  *
  662  * @note This function fails if called while scan is running.
  663  */
  664 //--------------------------------------------------------------------------------------------------
  665 le_wifiClient_AccessPointRef_t le_wifiClient_Create
  666 (
  667     const uint8_t* SsidPtr,
  668         ///< [IN] The SSID as a octet array.
  669     size_t SsidSize
  670         ///< [IN]
  671 );
  672 
  673 //--------------------------------------------------------------------------------------------------
  674 /**
  675  * Deletes an accessPointRef.
  676  *
  677  * @return
  678  *      - LE_OK             Function succeeded.
  679  *      - LE_BAD_PARAMETER  Invalid parameter.
  680  *      - LE_BUSY           Function called during scan.
  681  *
  682  * @note The handle becomes invalid after it has been deleted.
  683  */
  684 //--------------------------------------------------------------------------------------------------
  685 le_result_t le_wifiClient_Delete
  686 (
  687     le_wifiClient_AccessPointRef_t accessPointRef
  688         ///< [IN] WiFi Access Point reference.
  689 );
  690 
  691 //--------------------------------------------------------------------------------------------------
  692 /**
  693  * Connect to the WiFi Access Point.
  694  * All authentication must be set prior to calling this function.
  695  *
  696  * @return
  697  *      - LE_OK             Function succeeded.
  698  *      - LE_BAD_PARAMETER  Invalid parameter.
  699  *
  700  * @note For PSK credentials see le_wifiClient_SetPassphrase() or le_wifiClient_SetPreSharedKey() .
  701  * @note For WPA-Enterprise credentials see le_wifiClient_SetUserCredentials()
  702  */
  703 //--------------------------------------------------------------------------------------------------
  704 le_result_t le_wifiClient_Connect
  705 (
  706     le_wifiClient_AccessPointRef_t accessPointRef
  707         ///< [IN] WiFi Access Point reference.
  708 );
  709 
  710 //--------------------------------------------------------------------------------------------------
  711 /**
  712  * Disconnect from the current connected WiFi Access Point.
  713  *
  714  * @return
  715  *      - LE_OK     Function succeeded.
  716  *      - LE_FAULT  Function failed.
  717  */
  718 //--------------------------------------------------------------------------------------------------
  719 le_result_t le_wifiClient_Disconnect
  720 (
  721     void
  722 );
  723 
  724 #endif // LE_WIFICLIENT_INTERFACE_H_INCLUDE_GUARD
le_wifiClient_NewEventHandlerRef_t
struct le_wifiClient_NewEventHandler * le_wifiClient_NewEventHandlerRef_t
Definition: le_wifiClient_interface.h:352
le_wifiClient_GetNextAccessPoint
le_wifiClient_AccessPointRef_t le_wifiClient_GetNextAccessPoint(void)
le_wifiClient_DisconnectHandler_t
void(* le_wifiClient_DisconnectHandler_t)(void *)
Definition: le_wifiClient_interface.h:213
le_wifiClient_ConnectService
void le_wifiClient_ConnectService(void)
le_wifiClient_GetBssid
le_result_t le_wifiClient_GetBssid(le_wifiClient_AccessPointRef_t accessPointRef, char *bssid, size_t bssidSize)
le_wifiClient_SetUserCredentials
le_result_t le_wifiClient_SetUserCredentials(le_wifiClient_AccessPointRef_t accessPointRef, const char *LE_NONNULL userName, const char *LE_NONNULL password)
le_wifiClient_GetSsid
le_result_t le_wifiClient_GetSsid(le_wifiClient_AccessPointRef_t accessPointRef, uint8_t *ssidPtr, size_t *ssidSizePtr)
le_result_t
le_result_t
Definition: le_basics.h:35
le_wifiClient_Start
le_result_t le_wifiClient_Start(void)
le_wifiDefs_interface.h
LE_WIFICLIENT_EVENT_SCAN_DONE
WiFi Scan result for available Access Points available. 
Definition: le_wifiClient_interface.h:316
le_wifiClient_Stop
le_result_t le_wifiClient_Stop(void)
LE_WIFICLIENT_EVENT_DISCONNECTED
WiFi Client Disconnected. 
Definition: le_wifiClient_interface.h:314
le_wifiClient_GetSignalStrength
int16_t le_wifiClient_GetSignalStrength(le_wifiClient_AccessPointRef_t accessPointRef)
le_wifiClient_SetSecurityProtocol
le_result_t le_wifiClient_SetSecurityProtocol(le_wifiClient_AccessPointRef_t accessPointRef, le_wifiClient_SecurityProtocol_t securityProtocol)
LE_WIFICLIENT_SECURITY_NONE
no security. 
Definition: le_wifiClient_interface.h:331
le_wifiClient_SetServerDisconnectHandler
void le_wifiClient_SetServerDisconnectHandler(le_wifiClient_DisconnectHandler_t disconnectHandler, void *contextPtr)
le_wifiClient_Event_t
le_wifiClient_Event_t
Definition: le_wifiClient_interface.h:310
le_wifiClient_SecurityProtocol_t
le_wifiClient_SecurityProtocol_t
Definition: le_wifiClient_interface.h:329
le_wifiClient_SetWepKey
le_result_t le_wifiClient_SetWepKey(le_wifiClient_AccessPointRef_t accessPointRef, const char *LE_NONNULL wepKey)
LE_WIFICLIENT_SECURITY_WPA2_PSK_PERSONAL
Using WPA2. 
Definition: le_wifiClient_interface.h:337
le_wifiClient_SetHiddenNetworkAttribute
le_result_t le_wifiClient_SetHiddenNetworkAttribute(le_wifiClient_AccessPointRef_t accessPointRef, bool hidden)
le_wifiClient_Delete
le_result_t le_wifiClient_Delete(le_wifiClient_AccessPointRef_t accessPointRef)
LE_WIFICLIENT_EVENT_CONNECTED
WiFi Client Connected. 
Definition: le_wifiClient_interface.h:312
le_wifiClient_SetPreSharedKey
le_result_t le_wifiClient_SetPreSharedKey(le_wifiClient_AccessPointRef_t accessPointRef, const char *LE_NONNULL PreSharedKey)
LE_WIFICLIENT_SECURITY_WPA_PSK_PERSONAL
Using WPA. 
Definition: le_wifiClient_interface.h:335
le_wifiClient_Disconnect
le_result_t le_wifiClient_Disconnect(void)
le_wifiClient_RemoveNewEventHandler
void le_wifiClient_RemoveNewEventHandler(le_wifiClient_NewEventHandlerRef_t handlerRef)
legato.h
le_wifiClient_Create
le_wifiClient_AccessPointRef_t le_wifiClient_Create(const uint8_t *SsidPtr, size_t SsidSize)
LE_WIFICLIENT_SECURITY_WPA_EAP_PEAP0_ENTERPRISE
Using WPA Enterprise. 
Definition: le_wifiClient_interface.h:339
LE_WIFICLIENT_SECURITY_WPA2_EAP_PEAP0_ENTERPRISE
Using WPA2 Enterprise. 
Definition: le_wifiClient_interface.h:341
le_wifiClient_NewEventHandlerFunc_t
void(* le_wifiClient_NewEventHandlerFunc_t)(le_wifiClient_Event_t event, void *contextPtr)
Definition: le_wifiClient_interface.h:361
le_wifiClient_TryConnectService
le_result_t le_wifiClient_TryConnectService(void)
LE_WIFICLIENT_EVENT_SCAN_FAILED
WiFi Scan failed. 
Definition: le_wifiClient_interface.h:318
le_wifiClient_AccessPointRef_t
struct le_wifiClient_AccessPoint * le_wifiClient_AccessPointRef_t
Definition: le_wifiClient_interface.h:302
le_wifiClient_Scan
le_result_t le_wifiClient_Scan(void)
le_wifiClient_Connect
le_result_t le_wifiClient_Connect(le_wifiClient_AccessPointRef_t accessPointRef)
le_wifiClient_DisconnectService
void le_wifiClient_DisconnectService(void)
le_wifiClient_GetFirstAccessPoint
le_wifiClient_AccessPointRef_t le_wifiClient_GetFirstAccessPoint(void)
le_wifiClient_AddNewEventHandler
le_wifiClient_NewEventHandlerRef_t le_wifiClient_AddNewEventHandler(le_wifiClient_NewEventHandlerFunc_t handlerPtr, void *contextPtr)
le_wifiClient_SetPassphrase
le_result_t le_wifiClient_SetPassphrase(le_wifiClient_AccessPointRef_t accessPointRef, const char *LE_NONNULL PassPhrase)
LE_WIFICLIENT_SECURITY_WEP
Using WEP. 
Definition: le_wifiClient_interface.h:333