wifi_provisioning : Wi-Fi Provisioning Manager added

components/wifi_provisioning/CMakeLists.txt

@@ -1,10 +1,21 @@
 set(COMPONENT_ADD_INCLUDEDIRS include)
-set(COMPONENT_PRIV_INCLUDEDIRS proto-c ../protocomm/proto-c)
+set(COMPONENT_PRIV_INCLUDEDIRS src proto-c ../protocomm/proto-c)
 set(COMPONENT_SRCS  "src/wifi_config.c"
+                    "src/manager.c"
+                    "src/handlers.c"
+                    "src/scheme_softap.c"
+                    "src/scheme_console.c"
                     "proto-c/wifi_config.pb-c.c"
                     "proto-c/wifi_constants.pb-c.c")
 
-set(COMPONENT_REQUIRES lwip)
-set(COMPONENT_PRIV_REQUIRES protobuf-c protocomm)
+set(COMPONENT_REQUIRES lwip protocomm)
+set(COMPONENT_PRIV_REQUIRES protobuf-c bt mdns json)
+
+if(CONFIG_BT_ENABLED)
+    if(CONFIG_BLUEDROID_ENABLED)
+        list(APPEND COMPONENT_SRCS
+            "src/scheme_ble.c")
+    endif()
+endif()
 
 register_component()

components/wifi_provisioning/component.mk

@@ -1,3 +1,7 @@
 COMPONENT_SRCDIRS := src proto-c
 COMPONENT_ADD_INCLUDEDIRS := include
-COMPONENT_PRIV_INCLUDEDIRS := proto-c ../protocomm/proto-c/
+COMPONENT_PRIV_INCLUDEDIRS := src proto-c ../protocomm/proto-c/
+
+ifneq ($(filter y, $(CONFIG_BT_ENABLED) $(CONFIG_BLUEDROID_ENABLED)),y y)
+	COMPONENT_OBJEXCLUDE := src/scheme_ble.o
+endif

components/wifi_provisioning/include/wifi_provisioning/manager.h

@@ -0,0 +1,553 @@
+// Copyright 2019 Espressif Systems (Shanghai) PTE LTD
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#pragma once
+
+#include <esp_event_loop.h>
+#include <protocomm.h>
+
+#include "wifi_provisioning/wifi_config.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @brief   Events generated by manager
+ *
+ * These events are generated in order of declaration and, for the
+ * stretch of time between initialization and de-initialization of
+ * the manager, each event is signaled only once
+ */
+typedef enum {
+    /**
+     * Emitted when the manager is initialized
+     */
+    WIFI_PROV_INIT,
+
+    /**
+     * Indicates that provisioning has started
+     */
+    WIFI_PROV_START,
+
+    /**
+     * Emitted when Wi-Fi AP credentials are received via `protocomm`
+     * endpoint `wifi_config`. The event data in this case is a pointer
+     * to the corresponding `wifi_sta_config_t` structure
+     */
+    WIFI_PROV_CRED_RECV,
+
+    /**
+     * Emitted when device fails to connect to the AP of which the
+     * credentials were received earlier on event `WIFI_PROV_CRED_RECV`.
+     * The event data in this case is a pointer to the disconnection
+     * reason code with type `wifi_prov_sta_fail_reason_t`
+     */
+    WIFI_PROV_CRED_FAIL,
+
+    /**
+     * Emitted when device successfully connects to the AP of which the
+     * credentials were received earlier on event `WIFI_PROV_CRED_RECV`
+     */
+    WIFI_PROV_CRED_SUCCESS,
+
+    /**
+     * Signals that provisioning service has stopped
+     */
+    WIFI_PROV_END,
+
+    /**
+     * Signals that manager has been de-initialized
+     */
+    WIFI_PROV_DEINIT,
+} wifi_prov_cb_event_t;
+
+typedef void (*wifi_prov_cb_func_t)(void *user_data, wifi_prov_cb_event_t event, void *event_data);
+
+/**
+ * @brief   Event handler that is used by the manager while
+ *          provisioning service is active
+ */
+typedef struct {
+    /**
+     * Callback function to be executed on provisioning events
+     */
+    wifi_prov_cb_func_t event_cb;
+
+    /**
+     * User context data to pass as parameter to callback function
+     */
+    void *user_data;
+} wifi_prov_event_handler_t;
+
+/**
+ * @brief Event handler can be set to none if not used
+ */
+#define WIFI_PROV_EVENT_HANDLER_NONE { \
+    .event_cb  = NULL,                 \
+    .user_data = NULL                  \
+}
+
+/**
+ * @brief   Structure for specifying the provisioning scheme to be
+ *          followed by the manager
+ *
+ * @note    Ready to use schemes are available:
+ *              - wifi_prov_scheme_ble     : for provisioning over BLE transport + GATT server
+ *              - wifi_prov_scheme_softap  : for provisioning over SoftAP transport + HTTP server
+ *              - wifi_prov_scheme_console : for provisioning over Serial UART transport + Console (for debugging)
+ */
+typedef struct wifi_prov_scheme {
+    /**
+     * Function which is to be called by the manager when it is to
+     * start the provisioning service associated with a protocomm instance
+     * and a scheme specific configuration
+     */
+    esp_err_t (*prov_start) (protocomm_t *pc, void *config);
+
+    /**
+     * Function which is to be called by the manager to stop the
+     * provisioning service previously associated with a protocomm instance
+     */
+    esp_err_t (*prov_stop) (protocomm_t *pc);
+
+    /**
+     * Function which is to be called by the manager to generate
+     * a new configuration for the provisioning service, that is
+     * to be passed to prov_start()
+     */
+    void *(*new_config) (void);
+
+    /**
+     * Function which is to be called by the manager to delete a
+     * configuration generated using new_config()
+     */
+    void (*delete_config) (void *config);
+
+    /**
+     * Function which is to be called by the manager to set the
+     * service name and key values in the configuration structure
+     */
+    esp_err_t (*set_config_service) (void *config, const char *service_name, const char *service_key);
+
+    /**
+     * Function which is to be called by the manager to set a protocomm endpoint
+     * with an identifying name and UUID in the configuration structure
+     */
+    esp_err_t (*set_config_endpoint) (void *config, const char *endpoint_name, uint16_t uuid);
+
+    /**
+     * Sets mode of operation of Wi-Fi during provisioning
+     * This is set to :
+     * - WIFI_MODE_APSTA for SoftAP transport
+     * - WIFI_MODE_STA for BLE transport
+     */
+    wifi_mode_t wifi_mode;
+} wifi_prov_scheme_t;
+
+/**
+ * @brief   Structure for specifying the manager configuration
+ */
+typedef struct {
+    /**
+     * Provisioning scheme to use. Following schemes are already available:
+     *     - wifi_prov_scheme_ble     : for provisioning over BLE transport + GATT server
+     *     - wifi_prov_scheme_softap  : for provisioning over SoftAP transport + HTTP server + mDNS (optional)
+     *     - wifi_prov_scheme_console : for provisioning over Serial UART transport + Console (for debugging)
+     */
+    wifi_prov_scheme_t scheme;
+
+    /**
+     * Event handler required by the scheme for incorporating scheme specific
+     * behavior while provisioning manager is running. Various options may be
+     * provided by the scheme for setting this field. Use WIFI_PROV_EVENT_HANDLER_NONE
+     * when not used. When using scheme wifi_prov_scheme_ble, the following
+     * options are available:
+     *     - WIFI_PROV_SCHEME_BLE_EVENT_HANDLER_FREE_BTDM
+     *     - WIFI_PROV_SCHEME_BLE_EVENT_HANDLER_FREE_BLE
+     *     - WIFI_PROV_SCHEME_BLE_EVENT_HANDLER_FREE_BT
+     */
+    wifi_prov_event_handler_t scheme_event_handler;
+
+    /**
+     * Event handler that can be set for the purpose of incorporating application
+     * specific behavior. Use WIFI_PROV_EVENT_HANDLER_NONE when not used.
+     */
+    wifi_prov_event_handler_t app_event_handler;
+} wifi_prov_mgr_config_t;
+
+/**
+ * @brief   Security modes supported by the Provisioning Manager.
+ *
+ * These are same as the security modes provided by protocomm
+ */
+typedef enum wifi_prov_security {
+    /**
+     * No security (plain-text communication)
+     */
+    WIFI_PROV_SECURITY_0 = 0,
+
+    /**
+     * This secure communication mode consists of
+     *   X25519 key exchange
+     * + proof of possession (pop) based authentication
+     * + AES-CTR encryption
+     */
+    WIFI_PROV_SECURITY_1
+} wifi_prov_security_t;
+
+/**
+ * @brief   Initialize provisioning manager instance
+ *
+ * Configures the manager and allocates internal resources
+ *
+ * Configuration specifies the provisioning scheme (transport)
+ * and event handlers
+ *
+ * Event WIFI_PROV_INIT is emitted right after initialization
+ * is complete
+ *
+ * @param[in] config Configuration structure
+ *
+ * @return
+ *  - ESP_OK      : Success
+ *  - ESP_FAIL    : Fail
+ */
+esp_err_t wifi_prov_mgr_init(wifi_prov_mgr_config_t config);
+
+/**
+ * @brief   Stop provisioning (if running) and release
+ *          resource used by the manager
+ *
+ * Event WIFI_PROV_DEINIT is emitted right after de-initialization
+ * is finished
+ *
+ * If provisioning service is  still active when this API is called,
+ * it first stops the service, hence emitting WIFI_PROV_END, and
+ * then performs the de-initialization
+ */
+void wifi_prov_mgr_deinit(void);
+
+/**
+ * @brief   Checks if device is provisioned
+ *
+ * This checks if Wi-Fi credentials are present on the NVS
+ *
+ * The Wi-Fi credentials are assumed to be kept in the same
+ * NVS namespace as used by esp_wifi component
+ *
+ * If one were to call esp_wifi_set_config() directly instead
+ * of going through the provisioning process, this function will
+ * still yield true (i.e. device will be found to be provisioned)
+ *
+ * @note    Calling wifi_prov_mgr_start_provisioning() automatically
+ *          resets the provision state, irrespective of what the
+ *          state was prior to making the call.
+ *
+ * @param[out] provisioned  True if provisioned, else false
+ *
+ * @return
+ *  - ESP_OK      : Retrieved provision state successfully
+ *  - ESP_FAIL    : Wi-Fi not initialized
+ *  - ESP_ERR_INVALID_ARG   : Null argument supplied
+ *  - ESP_ERR_INVALID_STATE : Manager not initialized
+ */
+esp_err_t wifi_prov_mgr_is_provisioned(bool *provisioned);
+
+/**
+ * @brief   Start provisioning service
+ *
+ * This starts the provisioning service according to the scheme
+ * configured at the time of initialization. For scheme :
+ * - wifi_prov_scheme_ble : This starts protocomm_ble, which internally initializes
+ *                          BLE transport and starts GATT server for handling
+ *                          provisioning requests
+ * - wifi_prov_scheme_softap : This activates SoftAP mode of Wi-Fi and starts
+ *                          protocomm_httpd, which internally starts an HTTP
+ *                          server for handling provisioning requests (If mDNS is
+ *                          active it also starts advertising service with type
+ *                          _esp_wifi_prov._tcp)
+ *
+ * Event WIFI_PROV_START is emitted right after provisioning starts without failure
+ *
+ * @note   This API will start provisioning service even if device is found to be
+ *         already provisioned, i.e. wifi_prov_mgr_is_provisioned() yields true
+ *
+ * @param[in] security      Specify which protocomm security scheme to use :
+ *                              - WIFI_PROV_SECURITY_0 : For no security
+ *                              - WIFI_PROV_SECURITY_1 : x25519 secure handshake for session
+ *                                establishment followed by AES-CTR encryption of provisioning messages
+ * @param[in] pop           Pointer to proof of possession string (NULL if not needed). This
+ *                          is relevant only for protocomm security 1, in which case it is used
+ *                          for authenticating secure session
+ * @param[in] service_name  Unique name of the service. This translates to:
+ *                              - Wi-Fi SSID when provisioning mode is softAP
+ *                              - Device name when provisioning mode is BLE
+ * @param[in] service_key   Key required by client to access the service (NULL if not needed).
+ *                          This translates to:
+ *                              - Wi-Fi password when provisioning mode is softAP
+ *                              - ignored when provisioning mode is BLE
+ *
+ * @return
+ *  - ESP_OK      : Provisioning started successfully
+ *  - ESP_FAIL    : Failed to start provisioning service
+ *  - ESP_ERR_INVALID_STATE : Provisioning manager not initialized or already started
+ */
+esp_err_t wifi_prov_mgr_start_provisioning(wifi_prov_security_t security, const char *pop,
+                                           const char *service_name, const char *service_key);
+
+/**
+ * @brief   Stop provisioning service
+ *
+ * If provisioning service is active, this API will initiate a process to stop
+ * the service and return. Once the service actually stops, the event WIFI_PROV_END
+ * will be emitted.
+ *
+ * If wifi_prov_mgr_deinit() is called without calling this API first, it will
+ * automatically stop the provisioning service and emit the WIFI_PROV_END, followed
+ * by WIFI_PROV_DEINIT, before returning.
+ *
+ * This API will generally be used along with wifi_prov_mgr_disable_auto_stop()
+ * in the scenario when the main application has registered its own endpoints,
+ * and wishes that the provisioning service is stopped only when some protocomm
+ * command from the client side application is received.
+ *
+ * Calling this API inside an endpoint handler, with sufficient cleanup_delay,
+ * will allow the response / acknowledgment to be sent successfully before the
+ * underlying protocomm service is stopped.
+ *
+ * Cleaup_delay is set when calling wifi_prov_mgr_disable_auto_stop().
+ * If not specified, it defaults to 1000ms.
+ *
+ * For straightforward cases, using this API is usually not necessary as
+ * provisioning is stopped automatically once WIFI_PROV_CRED_SUCCESS is emitted.
+ * Stopping is delayed (maximum 30 seconds) thus allowing the client side
+ * application to query for Wi-Fi state, i.e. after receiving the first query
+ * and sending `Wi-Fi state connected` response the service is stopped immediately.
+ */
+void wifi_prov_mgr_stop_provisioning(void);
+
+/**
+ * @brief   Wait for provisioning service to finish
+ *
+ * Calling this API will block until provisioning service is stopped
+ * i.e. till event WIFI_PROV_END is emitted.
+ *
+ * This will not block if provisioning is not started or not initialized.
+ */
+void wifi_prov_mgr_wait(void);
+
+/**
+ * @brief   Disable auto stopping of provisioning service upon completion
+ *
+ * By default, once provisioning is complete, the provisioning service is automatically
+ * stopped, and all endpoints (along with those registered by main application) are
+ * deactivated.
+ *
+ * This API is useful in the case when main application wishes to close provisioning service
+ * only after it receives some protocomm command from the client side app. For example, after
+ * connecting to Wi-Fi, the device may want to connect to the cloud, and only once that is
+ * successfully, the device is said to be fully configured. But, then it is upto the main
+ * application to explicitly call wifi_prov_mgr_stop_provisioning() later when the device is
+ * fully configured and the provisioning service is no longer required.
+ *
+ * @note    This must be called before executing wifi_prov_mgr_start_provisioning()
+ *
+ * @param[in] cleanup_delay Sets the delay after which the actual cleanup of transport related
+ *                          resources is done after a call to wifi_prov_mgr_stop_provisioning()
+ *                          returns. Minimum allowed value is 100ms. If not specified, this will
+ *                          default to 1000ms.
+ *
+ * @return
+ *  - ESP_OK : Success
+ *  - ESP_ERR_INVALID_STATE : Manager not initialized or
+ *                            provisioning service already started
+ */
+esp_err_t wifi_prov_mgr_disable_auto_stop(uint32_t cleanup_delay);
+
+/**
+ * @brief   Set application version and capabilities in the JSON data returned by
+ *          proto-ver endpoint
+ *
+ * This function can be called multiple times, to specify information about the various
+ * application specific services running on the device, identified by unique labels.
+ *
+ * The provisioning service itself registers an entry in the JSON data, by the label "prov",
+ * containing only provisioning service version and capabilities. Application services should
+ * use a label other than "prov" so as not to overwrite this.
+ *
+ * @note    This must be called before executing wifi_prov_mgr_start_provisioning()
+ *
+ * @param[in] label   String indicating the application name.
+ *
+ * @param[in] version String indicating the application version.
+ *                    There is no constraint on format.
+ *
+ * @param[in] capabilities  Array of strings with capabilities.
+ *                          These could be used by the client side app to know
+ *                          the application registered endpoint capabilities
+ *
+ * @param[in] total_capabilities  Size of capabilities array
+ *
+ * @return
+ *  - ESP_OK : Success
+ *  - ESP_ERR_INVALID_STATE : Manager not initialized or
+ *                            provisioning service already started
+ *  - ESP_ERR_NO_MEM : Failed to allocate memory for version string
+ *  - ESP_ERR_INVALID_ARG : Null argument
+ */
+esp_err_t wifi_prov_mgr_set_app_info(const char *label, const char *version,
+                                     const char**capabilities, size_t total_capabilities);
+
+/**
+ * @brief   Create an additional endpoint and allocate internal resources for it
+ *
+ * This API is to be called by the application if it wants to create an additional
+ * endpoint. All additional endpoints will be assigned UUIDs starting from 0xFF54
+ * and so on in the order of execution.
+ *
+ * protocomm handler for the created endpoint is to be registered later using
+ * wifi_prov_mgr_endpoint_register() after provisioning has started.
+ *
+ * @note    This API can only be called BEFORE provisioning is started
+ *
+ * @note    Additional endpoints can be used for configuring client provided
+ *          parameters other than Wi-Fi credentials, that are necessary for the
+ *          main application and hence must be set prior to starting the application
+ *
+ * @note    After session establishment, the additional endpoints must be targeted
+ *          first by the client side application before sending Wi-Fi configuration,
+ *          because once Wi-Fi configuration finishes the provisioning service is
+ *          stopped and hence all endpoints are unregistered
+ *
+ * @param[in] ep_name  unique name of the endpoint
+ *
+ * @return
+ *  - ESP_OK      : Success
+ *  - ESP_FAIL    : Failure
+ */
+esp_err_t wifi_prov_mgr_endpoint_create(const char *ep_name);
+
+/**
+ * @brief   Register a handler for the previously created endpoint
+ *
+ * This API can be called by the application to register a protocomm handler
+ * to any endpoint that was created using wifi_prov_mgr_endpoint_create().
+ *
+ * @note    This API can only be called AFTER provisioning has started
+ *
+ * @note    Additional endpoints can be used for configuring client provided
+ *          parameters other than Wi-Fi credentials, that are necessary for the
+ *          main application and hence must be set prior to starting the application
+ *
+ * @note    After session establishment, the additional endpoints must be targeted
+ *          first by the client side application before sending Wi-Fi configuration,
+ *          because once Wi-Fi configuration finishes the provisioning service is
+ *          stopped and hence all endpoints are unregistered
+ *
+ * @param[in] ep_name   Name of the endpoint
+ * @param[in] handler   Endpoint handler function
+ * @param[in] user_ctx  User data
+ *
+ * @return
+ *  - ESP_OK      : Success
+ *  - ESP_FAIL    : Failure
+ */
+esp_err_t wifi_prov_mgr_endpoint_register(const char *ep_name,
+                                          protocomm_req_handler_t handler,
+                                          void *user_ctx);
+
+/**
+ * @brief   Unregister the handler for an endpoint
+ *
+ * This API can be called if the application wants to selectively
+ * unregister the handler of an endpoint while the provisioning
+ * is still in progress.
+ *
+ * All the endpoint handlers are unregistered automatically when
+ * the provisioning stops.
+ *
+ * @param[in] ep_name  Name of the endpoint
+ */
+void wifi_prov_mgr_endpoint_unregister(const char *ep_name);
+
+/**
+ * @brief   Event handler for provisioning manager
+ *
+ * This is called from the main event handler and controls the
+ * provisioning manager's internal state machine depending on
+ * incoming Wi-Fi events
+ *
+ * @param[in] ctx   Event context data
+ * @param[in] event Event info
+ *
+ * @return
+ *  - ESP_OK       : Event handled successfully
+ *  - ESP_ERR_FAIL : This event cannot be handled
+ */
+esp_err_t wifi_prov_mgr_event_handler(void *ctx, system_event_t *event);
+
+/**
+ * @brief   Get state of Wi-Fi Station during provisioning
+ *
+ * @param[out] state    Pointer to wifi_prov_sta_state_t
+ *                      variable to be filled
+ *
+ * @return
+ *  - ESP_OK    : Successfully retrieved Wi-Fi state
+ *  - ESP_FAIL  : Provisioning app not running
+ */
+esp_err_t wifi_prov_mgr_get_wifi_state(wifi_prov_sta_state_t *state);
+
+/**
+ * @brief   Get reason code in case of Wi-Fi station
+ *          disconnection during provisioning
+ *
+* @param[out] reason    Pointer to wifi_prov_sta_fail_reason_t
+*                       variable to be filled
+ *
+ * @return
+ *  - ESP_OK    : Successfully retrieved Wi-Fi disconnect reason
+ *  - ESP_FAIL  : Provisioning app not running
+ */
+esp_err_t wifi_prov_mgr_get_wifi_disconnect_reason(wifi_prov_sta_fail_reason_t *reason);
+
+/**
+ * @brief   Runs Wi-Fi as Station with the supplied configuration
+ *
+ * Configures the Wi-Fi station mode to connect to the AP with
+ * SSID and password specified in config structure and sets
+ * Wi-Fi to run as station.
+ *
+ * This is automatically called by provisioning service upon
+ * receiving new credentials.
+ *
+ * If credentials are to be supplied to the manager via a
+ * different mode other than through protocomm, then this
+ * API needs to be called.
+ *
+ * Event WIFI_PROV_CRED_RECV is emitted after credentials have
+ * been applied and Wi-Fi station started
+ *
+ * @param[in] wifi_cfg  Pointer to Wi-Fi configuration structure
+ *
+ * @return
+ *  - ESP_OK      : Wi-Fi configured and started successfully
+ *  - ESP_FAIL    : Failed to set configuration
+ */
+esp_err_t wifi_prov_mgr_configure_sta(wifi_config_t *wifi_cfg);
+
+#ifdef __cplusplus
+}
+#endif

components/wifi_provisioning/include/wifi_provisioning/scheme_ble.h

@@ -0,0 +1,82 @@
+// Copyright 2019 Espressif Systems (Shanghai) PTE LTD
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#pragma once
+
+#include <protocomm.h>
+#include <protocomm_ble.h>
+
+#include "wifi_provisioning/manager.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @brief   Scheme that can be used by manager for provisioning
+ *          over BLE transport with GATT server
+ */
+extern const wifi_prov_scheme_t wifi_prov_scheme_ble;
+
+/* This scheme specific event handler is to be used when application
+ * doesn't require BT and BLE after provisioning has finished */
+#define WIFI_PROV_SCHEME_BLE_EVENT_HANDLER_FREE_BTDM {    \
+    .event_cb  = wifi_prov_scheme_ble_event_cb_free_btdm, \
+    .user_data = NULL                                     \
+}
+
+/* This scheme specific event handler is to be used when application
+ * doesn't require BLE to be active after provisioning has finished */
+#define WIFI_PROV_SCHEME_BLE_EVENT_HANDLER_FREE_BLE {    \
+    .event_cb  = wifi_prov_scheme_ble_event_cb_free_ble, \
+    .user_data = NULL                                    \
+}
+
+/* This scheme specific event handler is to be used when application
+ * doesn't require BT to be active after provisioning has finished */
+#define WIFI_PROV_SCHEME_BLE_EVENT_HANDLER_FREE_BT {    \
+    .event_cb  = wifi_prov_scheme_ble_event_cb_free_bt, \
+    .user_data = NULL                                   \
+}
+
+void wifi_prov_scheme_ble_event_cb_free_btdm(void *user_data, wifi_prov_cb_event_t event, void *event_data);
+void wifi_prov_scheme_ble_event_cb_free_ble (void *user_data, wifi_prov_cb_event_t event, void *event_data);
+void wifi_prov_scheme_ble_event_cb_free_bt  (void *user_data, wifi_prov_cb_event_t event, void *event_data);
+
+/**
+ * @brief   Set the 128 bit GATT service UUID used for provisioning
+ *
+ * This API is used to override the default 128 bit provisioning
+ * service UUID, which is 0000ffff-0000-1000-8000-00805f9b34fb.
+ *
+ * This must be called before starting provisioning, i.e. before
+ * making a call to wifi_prov_mgr_start_provisioning(), otherwise
+ * the default UUID will be used.
+ *
+ * @note    The data being pointed to by the argument must be valid
+ *          atleast till provisioning is started. Upon start, the
+ *          manager will store an internal copy of this UUID, and
+ *          this data can be freed or invalidated afterwords.
+ *
+ * @param[in] uuid128  A custom 128 bit UUID
+ *
+ * @return
+ *  - ESP_OK              : Success
+ *  - ESP_ERR_INVALID_ARG : Null argument
+ */
+esp_err_t wifi_prov_scheme_ble_set_service_uuid(uint8_t *uuid128);
+
+#ifdef __cplusplus
+}
+#endif

components/wifi_provisioning/include/wifi_provisioning/scheme_console.h

@@ -0,0 +1,34 @@
+// Copyright 2019 Espressif Systems (Shanghai) PTE LTD
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#pragma once
+
+#include <protocomm.h>
+#include <protocomm_console.h>
+
+#include "wifi_provisioning/manager.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @brief   Scheme that can be used by manager for provisioning
+ *          over console (Serial UART)
+ */
+extern const wifi_prov_scheme_t wifi_prov_scheme_console;
+
+#ifdef __cplusplus
+}
+#endif

components/wifi_provisioning/include/wifi_provisioning/scheme_softap.h

@@ -0,0 +1,34 @@
+// Copyright 2019 Espressif Systems (Shanghai) PTE LTD
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#pragma once
+
+#include <protocomm.h>
+#include <protocomm_httpd.h>
+
+#include "wifi_provisioning/manager.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @brief   Scheme that can be used by manager for provisioning
+ *          over SoftAP transport with HTTP server
+ */
+extern const wifi_prov_scheme_t wifi_prov_scheme_softap;
+
+#ifdef __cplusplus
+}
+#endif

components/wifi_provisioning/src/handlers.c

@@ -0,0 +1,146 @@
+// Copyright 2019 Espressif Systems (Shanghai) PTE LTD
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include <stdio.h>
+#include <string.h>
+#include <esp_err.h>
+#include <esp_log.h>
+
+#include <esp_wifi.h>
+#include <tcpip_adapter.h>
+
+#include "wifi_provisioning/wifi_config.h"
+#include "wifi_provisioning/manager.h"
+#include "wifi_provisioning_priv.h"
+
+static const char *TAG = "wifi_prov_handlers";
+
+/* Provide definition of wifi_prov_ctx_t */
+struct wifi_prov_ctx {
+    wifi_config_t wifi_cfg;
+};
+
+static wifi_config_t *get_config(wifi_prov_ctx_t **ctx)
+{
+    return (*ctx ? & (*ctx)->wifi_cfg : NULL);
+}
+
+static wifi_config_t *new_config(wifi_prov_ctx_t **ctx)
+{
+    free(*ctx);
+    (*ctx) = (wifi_prov_ctx_t *) calloc(1, sizeof(wifi_prov_ctx_t));
+    return get_config(ctx);
+}
+
+static void free_config(wifi_prov_ctx_t **ctx)
+{
+    free(*ctx);
+    *ctx = NULL;
+}
+
+static esp_err_t get_status_handler(wifi_prov_config_get_data_t *resp_data, wifi_prov_ctx_t **ctx)
+{
+    /* Initialize to zero */
+    memset(resp_data, 0, sizeof(wifi_prov_config_get_data_t));
+
+    if (wifi_prov_mgr_get_wifi_state(&resp_data->wifi_state) != ESP_OK) {
+        ESP_LOGW(TAG, "Wi-Fi provisioning manager not running");
+        return ESP_ERR_INVALID_STATE;
+    }
+
+    if (resp_data->wifi_state == WIFI_PROV_STA_CONNECTED) {
+        ESP_LOGD(TAG, "Got state : connected");
+
+        /* IP Addr assigned to STA */
+        tcpip_adapter_ip_info_t ip_info;
+        tcpip_adapter_get_ip_info(TCPIP_ADAPTER_IF_STA, &ip_info);
+        char *ip_addr = ip4addr_ntoa(&ip_info.ip);
+        strcpy(resp_data->conn_info.ip_addr, ip_addr);
+
+        /* AP information to which STA is connected */
+        wifi_ap_record_t ap_info;
+        esp_wifi_sta_get_ap_info(&ap_info);
+        memcpy(resp_data->conn_info.bssid, (char *)ap_info.bssid, sizeof(ap_info.bssid));
+        memcpy(resp_data->conn_info.ssid,  (char *)ap_info.ssid,  sizeof(ap_info.ssid));
+        resp_data->conn_info.channel   = ap_info.primary;
+        resp_data->conn_info.auth_mode = ap_info.authmode;
+
+        /* Tell manager to stop provisioning service */
+        wifi_prov_mgr_done();
+    } else if (resp_data->wifi_state == WIFI_PROV_STA_DISCONNECTED) {
+        ESP_LOGD(TAG, "Got state : disconnected");
+
+        /* If disconnected, convey reason */
+        wifi_prov_mgr_get_wifi_disconnect_reason(&resp_data->fail_reason);
+    } else {
+        ESP_LOGD(TAG, "Got state : connecting");
+    }
+    return ESP_OK;
+}
+
+static esp_err_t set_config_handler(const wifi_prov_config_set_data_t *req_data, wifi_prov_ctx_t **ctx)
+{
+    wifi_config_t *wifi_cfg = get_config(ctx);
+    if (wifi_cfg) {
+        free_config(ctx);
+    }
+
+    wifi_cfg = new_config(ctx);
+    if (!wifi_cfg) {
+        ESP_LOGE(TAG, "Unable to allocate Wi-Fi config");
+        return ESP_ERR_NO_MEM;
+    }
+
+    ESP_LOGD(TAG, "Wi-Fi Credentials Received");
+
+    /* Using strncpy allows the max SSID length to be 32 bytes (as per 802.11 standard).
+     * But this doesn't guarantee that the saved SSID will be null terminated, because
+     * wifi_cfg->sta.ssid is also 32 bytes long (without extra 1 byte for null character) */
+    strncpy((char *) wifi_cfg->sta.ssid, req_data->ssid, sizeof(wifi_cfg->sta.ssid));
+
+    /* Using strlcpy allows both max passphrase length (63 bytes) and ensures null termination
+     * because size of wifi_cfg->sta.password is 64 bytes (1 extra byte for null character) */
+    strlcpy((char *) wifi_cfg->sta.password, req_data->password, sizeof(wifi_cfg->sta.password));
+    return ESP_OK;
+}
+
+static esp_err_t apply_config_handler(wifi_prov_ctx_t **ctx)
+{
+    wifi_config_t *wifi_cfg = get_config(ctx);
+    if (!wifi_cfg) {
+        ESP_LOGE(TAG, "Wi-Fi config not set");
+        return ESP_ERR_INVALID_STATE;
+    }
+
+    esp_err_t ret = wifi_prov_mgr_configure_sta(wifi_cfg);
+    if (ret == ESP_OK) {
+        ESP_LOGD(TAG, "Wi-Fi Credentials Applied");
+    } else {
+        ESP_LOGE(TAG, "Failed to apply Wi-Fi Credentials");
+    }
+
+    free_config(ctx);
+    return ret;
+}
+
+wifi_prov_config_handlers_t get_wifi_prov_handlers(void)
+{
+    wifi_prov_config_handlers_t wifi_prov_handlers = {
+        .get_status_handler   = get_status_handler,
+        .set_config_handler   = set_config_handler,
+        .apply_config_handler = apply_config_handler,
+        .ctx = NULL
+    };
+    return wifi_prov_handlers;
+}

components/wifi_provisioning/src/manager.c

@@ -0,0 +1,1117 @@
+// Copyright 2019 Espressif Systems (Shanghai) PTE LTD
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include <string.h>
+
+#include <freertos/FreeRTOS.h>
+#include <freertos/semphr.h>
+#include <freertos/task.h>
+
+#include <cJSON.h>
+
+#include <esp_log.h>
+#include <esp_err.h>
+#include <esp_wifi.h>
+#include <esp_timer.h>
+
+#include <protocomm.h>
+#include <protocomm_security0.h>
+#include <protocomm_security1.h>
+
+#include "wifi_provisioning_priv.h"
+
+#define WIFI_PROV_MGR_VERSION      "v1.0"
+
+static const char *TAG = "wifi_prov_mgr";
+
+typedef enum {
+    WIFI_PROV_STATE_IDLE,
+    WIFI_PROV_STATE_STARTING,
+    WIFI_PROV_STATE_STARTED,
+    WIFI_PROV_STATE_CRED_RECV,
+    WIFI_PROV_STATE_FAIL,
+    WIFI_PROV_STATE_SUCCESS,
+    WIFI_PROV_STATE_STOPPING
+} wifi_prov_mgr_state_t;
+
+/**
+ * @brief  Structure for storing capabilities supported by
+ *         the provisioning service
+ */
+struct wifi_prov_capabilities {
+    /* Proof of Possession is not required for establishing session */
+    bool no_pop;
+
+    /* Provisioning doesn't stop on it's own after receiving Wi-Fi credentials
+     * instead application has to explicitly call wifi_prov_mgr_stop_provisioning() */
+    bool no_auto_stop;
+};
+
+/**
+ * @brief  Structure for storing miscellaneous information about
+ *         provisioning service that will be conveyed to clients
+ */
+struct wifi_prov_info {
+    const char *version;
+    struct wifi_prov_capabilities capabilities;
+};
+
+/**
+ * @brief  Context data for provisioning manager
+ */
+struct wifi_prov_mgr_ctx {
+    /* Provisioning manager configuration */
+    wifi_prov_mgr_config_t mgr_config;
+
+    /* State of the provisioning service */
+    wifi_prov_mgr_state_t prov_state;
+
+    /* Provisioning scheme configuration */
+    void *prov_scheme_config;
+
+    /* Protocomm handle */
+    protocomm_t *pc;
+
+    /* Type of security to use with protocomm */
+    int security;
+
+    /* Pointer to proof of possession */
+    protocomm_security_pop_t pop;
+
+    /* Handle to timer */
+    esp_timer_handle_t timer;
+
+    /* State of Wi-Fi Station */
+    wifi_prov_sta_state_t wifi_state;
+
+    /* Code for Wi-Fi station disconnection (if disconnected) */
+    wifi_prov_sta_fail_reason_t wifi_disconnect_reason;
+
+    /* Protocomm handlers for Wi-Fi configuration endpoint */
+    wifi_prov_config_handlers_t *wifi_prov_handlers;
+
+    /* Count of used endpoint UUIDs */
+    unsigned int endpoint_uuid_used;
+
+    /* Provisioning service information */
+    struct wifi_prov_info mgr_info;
+
+    /* Application related information in JSON format */
+    cJSON *app_info_json;
+
+    /* Delay after which resources will be cleaned up asynchronously
+     * upon execution of wifi_prov_mgr_stop_provisioning() */
+    uint32_t cleanup_delay;
+};
+
+/* Mutex to lock/unlock access to provisioning singleton
+ * context data. This is allocated only once on first init
+ * and never deleted as wifi_prov_mgr is a singleton */
+static SemaphoreHandle_t prov_ctx_lock = NULL;
+
+/* Pointer to provisioning context data */
+static struct wifi_prov_mgr_ctx *prov_ctx;
+
+/* This executes registered app_event_callback for a particular event
+ *
+ * NOTE : By the time this fucntion returns, it is possible that
+ * the manager got de-initialized due to a call to wifi_prov_mgr_deinit()
+ * either inside the event callbacks or from another thread. Therefore
+ * post execution of execute_event_cb(), the validity of prov_ctx must
+ * always be checked. A cleaner way, to avoid this pitfall safely, would
+ * be to limit the usage of this function to only public APIs, and that
+ * too at the very end, just before returning.
+ *
+ * NOTE: This function should be called only after ensuring that the
+ * context is valid and the control mutex is locked. */
+static void execute_event_cb(wifi_prov_cb_event_t event_id, void *event_data)
+{
+    ESP_LOGD(TAG, "execute_event_cb : %d", event_id);
+
+    if (prov_ctx) {
+        wifi_prov_cb_func_t app_cb = prov_ctx->mgr_config.app_event_handler.event_cb;
+        void *app_data = prov_ctx->mgr_config.app_event_handler.user_data;
+
+        wifi_prov_cb_func_t scheme_cb = prov_ctx->mgr_config.scheme_event_handler.event_cb;
+        void *scheme_data = prov_ctx->mgr_config.scheme_event_handler.user_data;
+
+        /* Release the mutex before executing the callbacks. This is done so that
+         * wifi_prov_mgr_event_handler() doesn't stay blocked for the duration */
+        xSemaphoreGiveRecursive(prov_ctx_lock);
+
+        if (scheme_cb) {
+            /* Call scheme specific event handler */
+            scheme_cb(scheme_data, event_id, event_data);
+        }
+
+        if (app_cb) {
+            /* Call application specific event handler */
+            app_cb(app_data, event_id, event_data);
+        }
+
+        xSemaphoreTakeRecursive(prov_ctx_lock, portMAX_DELAY);
+    }
+}
+
+esp_err_t wifi_prov_mgr_set_app_info(const char *label, const char *version,
+                                     const char**capabilities, size_t total_capabilities)
+{
+    if (!label || !version || !capabilities) {
+        return ESP_ERR_INVALID_ARG;
+    }
+
+    if (!prov_ctx_lock) {
+        ESP_LOGE(TAG, "Provisioning manager not initialized");
+        return ESP_ERR_INVALID_STATE;
+    }
+
+    esp_err_t ret = ESP_FAIL;
+    xSemaphoreTakeRecursive(prov_ctx_lock, portMAX_DELAY);
+
+    if (prov_ctx && prov_ctx->prov_state == WIFI_PROV_STATE_IDLE) {
+        if (!prov_ctx->app_info_json) {
+            prov_ctx->app_info_json = cJSON_CreateObject();
+        }
+
+        cJSON *new_entry_json = cJSON_CreateObject();
+        cJSON *capabilities_json = cJSON_CreateArray();
+        cJSON_AddItemToObject(prov_ctx->app_info_json, label, new_entry_json);
+
+        /* Version ("ver") */
+        cJSON_AddStringToObject(new_entry_json, "ver", version);
+
+        /* List of capabilities ("cap") */
+        cJSON_AddItemToObject(new_entry_json, "cap", capabilities_json);
+        for (unsigned int i = 0; i < total_capabilities; i++) {
+            if (capabilities[i]) {
+                cJSON_AddItemToArray(capabilities_json, cJSON_CreateString(capabilities[i]));
+            }
+        }
+
+    } else {
+        ret = ESP_ERR_INVALID_STATE;
+    }
+
+    xSemaphoreGiveRecursive(prov_ctx_lock);
+    return ret;
+}
+
+static cJSON* wifi_prov_get_info_json(void)
+{
+    cJSON *full_info_json = prov_ctx->app_info_json ?
+                                cJSON_Duplicate(prov_ctx->app_info_json, 1) : cJSON_CreateObject();
+    cJSON *prov_info_json = cJSON_CreateObject();
+    cJSON *prov_capabilities = cJSON_CreateArray();
+
+    /* Use label "prov" to indicate provisioning related information */
+    cJSON_AddItemToObject(full_info_json, "prov", prov_info_json);
+
+    /* Version field */
+    cJSON_AddStringToObject(prov_info_json, "ver", prov_ctx->mgr_info.version);
+
+    /* Capabilities field */
+    cJSON_AddItemToObject(prov_info_json, "cap", prov_capabilities);
+
+    /* If Proof of Possession is not used, indicate in capabilities */
+    if (prov_ctx->mgr_info.capabilities.no_pop) {
+        cJSON_AddItemToArray(prov_capabilities, cJSON_CreateString("no_pop"));
+    }
+    return full_info_json;
+}
+
+static esp_err_t wifi_prov_mgr_start_service(const char *service_name, const char *service_key)
+{
+    const wifi_prov_scheme_t *scheme = &prov_ctx->mgr_config.scheme;
+    esp_err_t ret;
+
+    /* Create new protocomm instance */
+    prov_ctx->pc = protocomm_new();
+    if (prov_ctx->pc == NULL) {
+        ESP_LOGE(TAG, "Failed to create new protocomm instance");
+        return ESP_FAIL;
+    }
+
+    ret = scheme->set_config_service(prov_ctx->prov_scheme_config, service_name, service_key);
+    if (ret != ESP_OK) {
+        ESP_LOGE(TAG, "Failed to configure service");
+        protocomm_delete(prov_ctx->pc);
+        return ret;
+    }
+
+    /* Start provisioning */
+    ret = scheme->prov_start(prov_ctx->pc, prov_ctx->prov_scheme_config);
+    if (ret != ESP_OK) {
+        ESP_LOGE(TAG, "Failed to start service");
+        protocomm_delete(prov_ctx->pc);
+        return ret;
+    }
+
+    /* Set version information / capabilities of provisioning service and application */
+    cJSON *version_json = wifi_prov_get_info_json();
+    ret = protocomm_set_version(prov_ctx->pc, "proto-ver", cJSON_Print(version_json));
+    cJSON_Delete(version_json);
+    if (ret != ESP_OK) {
+        ESP_LOGE(TAG, "Failed to set version endpoint");
+        scheme->prov_stop(prov_ctx->pc);
+        protocomm_delete(prov_ctx->pc);
+        return ret;
+    }
+
+    /* Set protocomm security type for endpoint */
+    if (prov_ctx->security == 0) {
+        ret = protocomm_set_security(prov_ctx->pc, "prov-session",
+                                     &protocomm_security0, NULL);
+    } else if (prov_ctx->security == 1) {
+        ret = protocomm_set_security(prov_ctx->pc, "prov-session",
+                                     &protocomm_security1, &prov_ctx->pop);
+    } else {
+        ESP_LOGE(TAG, "Unsupported protocomm security version %d", prov_ctx->security);
+        ret = ESP_ERR_INVALID_ARG;
+    }
+    if (ret != ESP_OK) {
+        ESP_LOGE(TAG, "Failed to set security endpoint");
+        scheme->prov_stop(prov_ctx->pc);
+        protocomm_delete(prov_ctx->pc);
+        return ret;
+    }
+
+    prov_ctx->wifi_prov_handlers = malloc(sizeof(wifi_prov_config_handlers_t));
+    if (!prov_ctx->wifi_prov_handlers) {
+        ESP_LOGD(TAG, "Failed to allocate memory for provisioning handlers");
+        scheme->prov_stop(prov_ctx->pc);
+        protocomm_delete(prov_ctx->pc);
+    }
+    *prov_ctx->wifi_prov_handlers = get_wifi_prov_handlers();
+
+    /* Add protocomm endpoint for Wi-Fi station configuration */
+    ret = protocomm_add_endpoint(prov_ctx->pc, "prov-config",
+                                 wifi_prov_config_data_handler,
+                                 prov_ctx->wifi_prov_handlers);
+    if (ret != ESP_OK) {
+        ESP_LOGE(TAG, "Failed to set provisioning endpoint");
+        free(prov_ctx->wifi_prov_handlers);
+        scheme->prov_stop(prov_ctx->pc);
+        protocomm_delete(prov_ctx->pc);
+        return ret;
+    }
+
+    ESP_LOGI(TAG, "Provisioning started with service name : %s ",
+             service_name ? service_name : "<NULL>");
+    return ESP_OK;
+}
+
+esp_err_t wifi_prov_mgr_endpoint_create(const char *ep_name)
+{
+    if (!prov_ctx_lock) {
+        ESP_LOGE(TAG, "Provisioning manager not initialized");
+        return ESP_ERR_INVALID_STATE;
+    }
+
+    esp_err_t err = ESP_FAIL;
+
+    xSemaphoreTakeRecursive(prov_ctx_lock, portMAX_DELAY);
+    if (prov_ctx &&
+        prov_ctx->prov_state == WIFI_PROV_STATE_IDLE) {
+        err = prov_ctx->mgr_config.scheme.set_config_endpoint(
+                prov_ctx->prov_scheme_config, ep_name,
+                prov_ctx->endpoint_uuid_used + 1);
+    }
+    if (err != ESP_OK) {
+        ESP_LOGE(TAG, "Failed to create additional endpoint");
+    } else {
+        prov_ctx->endpoint_uuid_used++;
+    }
+    xSemaphoreGiveRecursive(prov_ctx_lock);
+    return err;
+}
+
+esp_err_t wifi_prov_mgr_endpoint_register(const char *ep_name, protocomm_req_handler_t handler, void *user_ctx)
+{
+    if (!prov_ctx_lock) {
+        ESP_LOGE(TAG, "Provisioning manager not initialized");
+        return ESP_ERR_INVALID_STATE;
+    }
+
+    esp_err_t err = ESP_FAIL;
+
+    xSemaphoreTakeRecursive(prov_ctx_lock, portMAX_DELAY);
+    if (prov_ctx &&
+        prov_ctx->prov_state > WIFI_PROV_STATE_STARTING &&
+        prov_ctx->prov_state < WIFI_PROV_STATE_STOPPING) {
+        err = protocomm_add_endpoint(prov_ctx->pc, ep_name, handler, user_ctx);
+    }
+    xSemaphoreGiveRecursive(prov_ctx_lock);
+
+    if (err != ESP_OK) {
+        ESP_LOGE(TAG, "Failed to register handler for endpoint");
+    }
+    return err;
+}
+
+void wifi_prov_mgr_endpoint_unregister(const char *ep_name)
+{
+    if (!prov_ctx_lock) {
+        ESP_LOGE(TAG, "Provisioning manager not initialized");
+        return;
+    }
+
+    xSemaphoreTakeRecursive(prov_ctx_lock, portMAX_DELAY);
+    if (prov_ctx &&
+        prov_ctx->prov_state > WIFI_PROV_STATE_STARTING &&
+        prov_ctx->prov_state < WIFI_PROV_STATE_STOPPING) {
+        protocomm_remove_endpoint(prov_ctx->pc, ep_name);
+    }
+    xSemaphoreGiveRecursive(prov_ctx_lock);
+}
+
+static void prov_stop_task(void *arg)
+{
+    bool is_this_a_task = (bool) arg;
+
+    wifi_prov_cb_func_t app_cb = prov_ctx->mgr_config.app_event_handler.event_cb;
+    void *app_data = prov_ctx->mgr_config.app_event_handler.user_data;
+
+    wifi_prov_cb_func_t scheme_cb = prov_ctx->mgr_config.scheme_event_handler.event_cb;
+    void *scheme_data = prov_ctx->mgr_config.scheme_event_handler.user_data;
+
+    /* This delay is so that the client side app is notified first
+     * and then the provisioning is stopped. Generally 1000ms is enough. */
+    uint32_t cleanup_delay = prov_ctx->cleanup_delay > 100 ? prov_ctx->cleanup_delay : 100;
+    vTaskDelay(cleanup_delay / portTICK_PERIOD_MS);
+
+    /* All the extra application added endpoints are also
+     * removed automatically when prov_stop is called */
+    prov_ctx->mgr_config.scheme.prov_stop(prov_ctx->pc);
+
+    /* Delete protocomm instance */
+    protocomm_delete(prov_ctx->pc);
+    prov_ctx->pc = NULL;
+
+    /* Free provisioning handlers */
+    free(prov_ctx->wifi_prov_handlers->ctx);
+    free(prov_ctx->wifi_prov_handlers);
+    prov_ctx->wifi_prov_handlers = NULL;
+
+    /* Switch device to Wi-Fi STA mode irrespective of
+     * whether provisioning was completed or not */
+    esp_wifi_set_mode(WIFI_MODE_STA);
+    ESP_LOGI(TAG, "Provisioning stopped");
+
+    if (is_this_a_task) {
+        xSemaphoreTakeRecursive(prov_ctx_lock, portMAX_DELAY);
+        prov_ctx->prov_state = WIFI_PROV_STATE_IDLE;
+        xSemaphoreGiveRecursive(prov_ctx_lock);
+
+        ESP_LOGD(TAG, "execute_event_cb : %d", WIFI_PROV_END);
+        if (scheme_cb) {
+            scheme_cb(scheme_data, WIFI_PROV_END, NULL);
+        }
+        if (app_cb) {
+            app_cb(app_data, WIFI_PROV_END, NULL);
+        }
+        vTaskDelete(NULL);
+    }
+}
+
+/* This will do one of these:
+ * 1) if blocking is false, start a task for stopping the provisioning service (returns true)
+ * 2) if blocking is true, stop provisioning service immediately (returns true)
+ * 3) if service was already in the process of termination, in blocking mode this will
+ *    wait till the service is stopped (returns false)
+ * 4) if service was not running, this will return immediately (returns false)
+ *
+ * NOTE: This function should be called only after ensuring that the context
+ * is valid and the control mutex is locked
+ *
+ * NOTE: When blocking mode is selected, the event callbacks are not executed.
+ * This help with de-initialization.
+ */
+static bool wifi_prov_mgr_stop_service(bool blocking)
+{
+    if (blocking) {
+        /* Wait for any ongoing calls to wifi_prov_mgr_start_service() or
+         * wifi_prov_mgr_stop_service() from another thread to finish */
+        while (prov_ctx && (
+            prov_ctx->prov_state == WIFI_PROV_STATE_STARTING ||
+            prov_ctx->prov_state == WIFI_PROV_STATE_STOPPING)) {
+            xSemaphoreGiveRecursive(prov_ctx_lock);
+            vTaskDelay(100 / portTICK_PERIOD_MS);
+            xSemaphoreTakeRecursive(prov_ctx_lock, portMAX_DELAY);
+        }
+    } else {
+        /* Wait for any ongoing call to wifi_prov_mgr_start_service()
+         * from another thread to finish */
+        while (prov_ctx &&
+            prov_ctx->prov_state == WIFI_PROV_STATE_STARTING) {
+            xSemaphoreGiveRecursive(prov_ctx_lock);
+            vTaskDelay(100 / portTICK_PERIOD_MS);
+            xSemaphoreTakeRecursive(prov_ctx_lock, portMAX_DELAY);
+        }
+
+        if (prov_ctx && prov_ctx->prov_state == WIFI_PROV_STATE_STOPPING) {
+            ESP_LOGD(TAG, "Provisioning is already stopping");
+            return false;
+        }
+    }
+
+    if (!prov_ctx || prov_ctx->prov_state == WIFI_PROV_STATE_IDLE) {
+        ESP_LOGD(TAG, "Provisioning not running");
+        return false;
+    }
+
+    /* Timer not needed anymore */
+    if (prov_ctx->timer) {
+        esp_timer_stop(prov_ctx->timer);
+        esp_timer_delete(prov_ctx->timer);
+        prov_ctx->timer = NULL;
+    }
+
+    ESP_LOGD(TAG, "Stopping provisioning");
+    prov_ctx->prov_state = WIFI_PROV_STATE_STOPPING;
+
+    /* Free proof of possession */
+    if (prov_ctx->pop.data) {
+        free((void *)prov_ctx->pop.data);
+        prov_ctx->pop.data = NULL;
+    }
+
+    if (blocking) {
+        /* Run the cleanup without launching a separate task. Also the
+         * WIFI_PROV_END event is not emitted in this case */
+        xSemaphoreGiveRecursive(prov_ctx_lock);
+        prov_stop_task((void *)0);
+        xSemaphoreTakeRecursive(prov_ctx_lock, portMAX_DELAY);
+        prov_ctx->prov_state = WIFI_PROV_STATE_IDLE;
+    } else {
+        /* Launch cleanup task to perform the cleanup asynchronously.
+         * It is important to do this asynchronously because, there are
+         * situations in which the transport level resources have to be
+         * released - some duration after - returning from a call to
+         * wifi_prov_mgr_stop_provisioning(), like when it is called
+         * inside a protocomm handler */
+        assert(xTaskCreate(prov_stop_task, "prov_stop_task", 4096, (void *)1,
+                           tskIDLE_PRIORITY, NULL) == pdPASS);
+        ESP_LOGD(TAG, "Provisioning scheduled for stopping");
+    }
+    return true;
+}
+
+/* Task spawned by timer callback */
+static void stop_prov_timer_cb(void *arg)
+{
+    wifi_prov_mgr_stop_provisioning();
+}
+
+esp_err_t wifi_prov_mgr_disable_auto_stop(uint32_t cleanup_delay)
+{
+    if (!prov_ctx_lock) {
+        ESP_LOGE(TAG, "Provisioning manager not initialized");
+        return ESP_ERR_INVALID_STATE;
+    }
+
+    esp_err_t ret = ESP_FAIL;
+    xSemaphoreTakeRecursive(prov_ctx_lock, portMAX_DELAY);
+
+    if (prov_ctx && prov_ctx->prov_state == WIFI_PROV_STATE_IDLE) {
+        prov_ctx->mgr_info.capabilities.no_auto_stop = true;
+        prov_ctx->cleanup_delay = cleanup_delay;
+    } else {
+        ret = ESP_ERR_INVALID_STATE;
+    }
+
+    xSemaphoreGiveRecursive(prov_ctx_lock);
+    return ret;
+}
+
+/* Call this if provisioning is completed before the timeout occurs */
+esp_err_t wifi_prov_mgr_done(void)
+{
+    if (!prov_ctx_lock) {
+        ESP_LOGE(TAG, "Provisioning manager not initialized");
+        return ESP_ERR_INVALID_STATE;
+    }
+
+    xSemaphoreTakeRecursive(prov_ctx_lock, portMAX_DELAY);
+    /* Stop provisioning if auto stop is not disabled */
+    if (prov_ctx && !prov_ctx->mgr_info.capabilities.no_auto_stop) {
+        wifi_prov_mgr_stop_provisioning();
+    }
+    xSemaphoreGiveRecursive(prov_ctx_lock);
+    return ESP_OK;
+}
+
+/* Event handler for starting/stopping provisioning.
+ * To be called from within the context of the main
+ * event handler */
+esp_err_t wifi_prov_mgr_event_handler(void *ctx, system_event_t *event)
+{
+    /* For accessing reason codes in case of disconnection */
+    system_event_info_t *info = &event->event_info;
+
+    if (!prov_ctx_lock) {
+        ESP_LOGE(TAG, "Provisioning manager not initialized");
+        return ESP_ERR_INVALID_STATE;
+    }
+    xSemaphoreTakeRecursive(prov_ctx_lock, portMAX_DELAY);
+
+    /* If pointer to provisioning application data is NULL
+     * then provisioning manager is not running, therefore
+     * return with error to allow the global handler to act */
+    if (!prov_ctx) {
+        xSemaphoreGiveRecursive(prov_ctx_lock);
+        return ESP_ERR_INVALID_STATE;
+    }
+
+    /* Only handle events when credential is received and
+     * Wi-Fi STA is yet to complete trying the connection */
+    if (prov_ctx->prov_state != WIFI_PROV_STATE_CRED_RECV) {
+        xSemaphoreGiveRecursive(prov_ctx_lock);
+        return ESP_OK;
+    }
+
+    esp_err_t ret = ESP_OK;
+    switch (event->event_id) {
+    case SYSTEM_EVENT_STA_START:
+        ESP_LOGD(TAG, "STA Start");
+        /* Once configuration is received through protocomm,
+         * device is started as station. Once station starts,
+         * wait for connection to establish with configured
+         * host SSID and password */
+        prov_ctx->wifi_state = WIFI_PROV_STA_CONNECTING;
+        break;
+
+    case SYSTEM_EVENT_STA_GOT_IP:
+        ESP_LOGD(TAG, "STA Got IP");
+        /* Station got IP. That means configuration is successful. */
+        prov_ctx->wifi_state = WIFI_PROV_STA_CONNECTED;
+        prov_ctx->prov_state = WIFI_PROV_STATE_SUCCESS;
+
+        /* If auto stop is enabled (default), schedule timer to
+         * stop provisioning app after 30 seconds. */
+        if (!prov_ctx->mgr_info.capabilities.no_auto_stop) {
+            ESP_LOGD(TAG, "Starting 30s timer for stop_prov_timer_cb()");
+            esp_timer_start_once(prov_ctx->timer, 30000 * 1000U);
+        }
+
+        /* Execute user registered callback handler */
+        execute_event_cb(WIFI_PROV_CRED_SUCCESS, NULL);
+        break;
+
+    case SYSTEM_EVENT_STA_DISCONNECTED:
+        ESP_LOGD(TAG, "STA Disconnected");
+        /* Station couldn't connect to configured host SSID */
+        prov_ctx->wifi_state = WIFI_PROV_STA_DISCONNECTED;
+        ESP_LOGD(TAG, "Disconnect reason : %d", info->disconnected.reason);
+
+        /* Set code corresponding to the reason for disconnection */
+        switch (info->disconnected.reason) {
+        case WIFI_REASON_AUTH_EXPIRE:
+        case WIFI_REASON_4WAY_HANDSHAKE_TIMEOUT:
+        case WIFI_REASON_BEACON_TIMEOUT:
+        case WIFI_REASON_AUTH_FAIL:
+        case WIFI_REASON_ASSOC_FAIL:
+        case WIFI_REASON_HANDSHAKE_TIMEOUT:
+            ESP_LOGD(TAG, "STA Auth Error");
+            prov_ctx->wifi_disconnect_reason = WIFI_PROV_STA_AUTH_ERROR;
+            break;
+        case WIFI_REASON_NO_AP_FOUND:
+            ESP_LOGD(TAG, "STA AP Not found");
+            prov_ctx->wifi_disconnect_reason = WIFI_PROV_STA_AP_NOT_FOUND;
+            break;
+        default:
+            /* If none of the expected reasons,
+             * retry connecting to host SSID */
+            prov_ctx->wifi_state = WIFI_PROV_STA_CONNECTING;
+            esp_wifi_connect();
+        }
+
+        /* In case of disconnection, update state of service and
+         * run the event handler with disconnection reason as data */
+        if (prov_ctx->wifi_state == WIFI_PROV_STA_DISCONNECTED) {
+            prov_ctx->prov_state = WIFI_PROV_STATE_FAIL;
+            wifi_prov_sta_fail_reason_t reason = prov_ctx->wifi_disconnect_reason;
+            /* Execute user registered callback handler */
+            execute_event_cb(WIFI_PROV_CRED_FAIL, (void *)&reason);
+        }
+        break;
+
+    default:
+        /* This event is not intended to be handled by this handler.
+         * Return ESP_FAIL to signal global event handler to take
+         * control */
+        ret = ESP_FAIL;
+        break;
+    }
+
+    xSemaphoreGiveRecursive(prov_ctx_lock);
+    return ret;
+}
+
+esp_err_t wifi_prov_mgr_get_wifi_state(wifi_prov_sta_state_t *state)
+{
+    if (!prov_ctx_lock) {
+        ESP_LOGE(TAG, "Provisioning manager not initialized");
+        return ESP_ERR_INVALID_STATE;
+    }
+
+    xSemaphoreTakeRecursive(prov_ctx_lock, portMAX_DELAY);
+    if (prov_ctx == NULL || state == NULL) {
+        xSemaphoreGiveRecursive(prov_ctx_lock);
+        return ESP_FAIL;
+    }
+
+    *state = prov_ctx->wifi_state;
+    xSemaphoreGiveRecursive(prov_ctx_lock);
+    return ESP_OK;
+}
+
+esp_err_t wifi_prov_mgr_get_wifi_disconnect_reason(wifi_prov_sta_fail_reason_t *reason)
+{
+    if (!prov_ctx_lock) {
+        ESP_LOGE(TAG, "Provisioning manager not initialized");
+        return ESP_ERR_INVALID_STATE;
+    }
+
+    xSemaphoreTakeRecursive(prov_ctx_lock, portMAX_DELAY);
+    if (prov_ctx == NULL || reason == NULL) {
+        xSemaphoreGiveRecursive(prov_ctx_lock);
+        return ESP_FAIL;
+    }
+
+    if (prov_ctx->wifi_state != WIFI_PROV_STA_DISCONNECTED) {
+        xSemaphoreGiveRecursive(prov_ctx_lock);
+        return ESP_FAIL;
+    }
+
+    *reason = prov_ctx->wifi_disconnect_reason;
+    xSemaphoreGiveRecursive(prov_ctx_lock);
+    return ESP_OK;
+}
+
+static void debug_print_wifi_credentials(wifi_sta_config_t sta, const char* pretext)
+{
+    size_t passlen = strlen((const char*) sta.password);
+    ESP_LOGD(TAG, "%s Wi-Fi SSID     : %.*s", pretext,
+             strnlen((const char *) sta.ssid, sizeof(sta.ssid)), (const char *) sta.ssid);
+
+    if (passlen) {
+        /* Mask password partially if longer than 3, else mask it completely */
+        memset(sta.password + (passlen > 3), '*', passlen - 2*(passlen > 3));
+        ESP_LOGD(TAG, "%s Wi-Fi Password : %s", pretext, (const char *) sta.password);
+    }
+}
+
+esp_err_t wifi_prov_mgr_is_provisioned(bool *provisioned)
+{
+    if (!provisioned) {
+        return ESP_ERR_INVALID_ARG;
+    }
+
+    *provisioned = false;
+
+    if (!prov_ctx_lock) {
+        ESP_LOGE(TAG, "Provisioning manager not initialized");
+        return ESP_ERR_INVALID_STATE;
+    }
+
+    /* Get Wi-Fi Station configuration */
+    wifi_config_t wifi_cfg;
+    if (esp_wifi_get_config(ESP_IF_WIFI_STA, &wifi_cfg) != ESP_OK) {
+        return ESP_FAIL;
+    }
+
+    if (strlen((const char *) wifi_cfg.sta.ssid)) {
+        *provisioned = true;
+        debug_print_wifi_credentials(wifi_cfg.sta, "Found");
+    }
+    return ESP_OK;
+}
+
+esp_err_t wifi_prov_mgr_configure_sta(wifi_config_t *wifi_cfg)
+{
+    if (!prov_ctx_lock) {
+        ESP_LOGE(TAG, "Provisioning manager not initialized");
+        return ESP_ERR_INVALID_STATE;
+    }
+
+    xSemaphoreTakeRecursive(prov_ctx_lock, portMAX_DELAY);
+    if (!prov_ctx) {
+        ESP_LOGE(TAG, "Invalid state of Provisioning app");
+        xSemaphoreGiveRecursive(prov_ctx_lock);
+        return ESP_FAIL;
+    }
+    if (prov_ctx->prov_state >= WIFI_PROV_STATE_CRED_RECV) {
+        ESP_LOGE(TAG, "Wi-Fi credentials already received by provisioning app");
+        xSemaphoreGiveRecursive(prov_ctx_lock);
+        return ESP_FAIL;
+    }
+    debug_print_wifi_credentials(wifi_cfg->sta, "Received");
+
+    /* Configure Wi-Fi as both AP and/or Station */
+    if (esp_wifi_set_mode(prov_ctx->mgr_config.scheme.wifi_mode) != ESP_OK) {
+        ESP_LOGE(TAG, "Failed to set Wi-Fi mode");
+        xSemaphoreGiveRecursive(prov_ctx_lock);
+        return ESP_FAIL;
+    }
+
+    /* Don't release mutex yet as it is possible that right after
+     * esp_wifi_connect()  is called below, the related Wi-Fi event
+     * happens even before manager state is updated in the next
+     * few lines causing the internal event handler to miss */
+
+    /* Set Wi-Fi storage again to flash to keep the newly
+     * provided credentials on NVS */
+    if (esp_wifi_set_storage(WIFI_STORAGE_FLASH) != ESP_OK) {
+        ESP_LOGE(TAG, "Failed to set storage Wi-Fi");
+        xSemaphoreGiveRecursive(prov_ctx_lock);
+        return ESP_FAIL;
+    }
+    /* Configure Wi-Fi station with host credentials
+     * provided during provisioning */
+    if (esp_wifi_set_config(ESP_IF_WIFI_STA, wifi_cfg) != ESP_OK) {
+        ESP_LOGE(TAG, "Failed to set Wi-Fi configuration");
+        xSemaphoreGiveRecursive(prov_ctx_lock);
+        return ESP_FAIL;
+    }
+    /* (Re)Start Wi-Fi */
+    if (esp_wifi_start() != ESP_OK) {
+        ESP_LOGE(TAG, "Failed to set Wi-Fi configuration");
+        xSemaphoreGiveRecursive(prov_ctx_lock);
+        return ESP_FAIL;
+    }
+    /* Connect to AP */
+    if (esp_wifi_connect() != ESP_OK) {
+        ESP_LOGE(TAG, "Failed to connect Wi-Fi");
+        xSemaphoreGiveRecursive(prov_ctx_lock);
+        return ESP_FAIL;
+    }
+    /* This delay allows channel change to complete */
+    vTaskDelay(1000 / portTICK_PERIOD_MS);
+
+    /* Reset Wi-Fi station state for provisioning app */
+    prov_ctx->wifi_state = WIFI_PROV_STA_CONNECTING;
+    prov_ctx->prov_state = WIFI_PROV_STATE_CRED_RECV;
+    /* Execute user registered callback handler */
+    execute_event_cb(WIFI_PROV_CRED_RECV, (void *)&wifi_cfg->sta);
+    xSemaphoreGiveRecursive(prov_ctx_lock);
+
+    return ESP_OK;
+}
+
+esp_err_t wifi_prov_mgr_init(wifi_prov_mgr_config_t config)
+{
+    if (!prov_ctx_lock) {
+       /* Create mutex if this is the first time init is being called.
+        * This is created only once and never deleted because if some
+        * other thread is trying to take this mutex while it is being
+        * deleted from another thread then the reference may become
+        * invalid and cause exception */
+        prov_ctx_lock = xSemaphoreCreateRecursiveMutex();
+        if (!prov_ctx_lock) {
+            ESP_LOGE(TAG, "Failed to create mutex");
+            return ESP_ERR_NO_MEM;
+        }
+    }
+
+    void *fn_ptrs[] = {
+        config.scheme.prov_stop,
+        config.scheme.prov_start,
+        config.scheme.new_config,
+        config.scheme.delete_config,
+        config.scheme.set_config_service,
+        config.scheme.set_config_endpoint
+    };
+
+    /* All function pointers in the scheme structure must be non-null */
+    for (int i = 0; i < sizeof(fn_ptrs)/sizeof(fn_ptrs[0]); i++) {
+        if (!fn_ptrs[i]) {
+            return ESP_ERR_INVALID_ARG;
+        }
+    }
+
+    xSemaphoreTakeRecursive(prov_ctx_lock, portMAX_DELAY);
+    if (prov_ctx) {
+        ESP_LOGE(TAG, "Provisioning manager already initialized");
+        xSemaphoreGiveRecursive(prov_ctx_lock);
+        return ESP_ERR_INVALID_STATE;
+    }
+
+    /* Allocate memory for provisioning app data */
+    prov_ctx = (struct wifi_prov_mgr_ctx *) calloc(1, sizeof(struct wifi_prov_mgr_ctx));
+    if (!prov_ctx) {
+        ESP_LOGE(TAG, "Error allocating memory for singleton instance");
+        xSemaphoreGiveRecursive(prov_ctx_lock);
+        return ESP_ERR_NO_MEM;
+    }
+
+    prov_ctx->mgr_config = config;
+    prov_ctx->prov_state = WIFI_PROV_STATE_IDLE;
+    prov_ctx->mgr_info.version = WIFI_PROV_MGR_VERSION;
+
+    /* Allocate memory for provisioning scheme configuration */
+    const wifi_prov_scheme_t *scheme = &prov_ctx->mgr_config.scheme;
+    esp_err_t ret = ESP_OK;
+    prov_ctx->prov_scheme_config = scheme->new_config();
+    if (!prov_ctx->prov_scheme_config) {
+        ESP_LOGE(TAG, "failed to allocate provisioning scheme configuration");
+        ret = ESP_ERR_NO_MEM;
+        goto exit;
+    }
+
+    ret = scheme->set_config_endpoint(prov_ctx->prov_scheme_config, "prov-session", 0xFF51);
+    if (ret != ESP_OK) {
+        ESP_LOGE(TAG, "failed to configure security endpoint");
+        goto exit;
+    }
+
+    ret = scheme->set_config_endpoint(prov_ctx->prov_scheme_config, "prov-config", 0xFF52);
+    if (ret != ESP_OK) {
+        ESP_LOGE(TAG, "failed to configure Wi-Fi configuration endpoint");
+        goto exit;
+    }
+
+    ret = scheme->set_config_endpoint(prov_ctx->prov_scheme_config, "proto-ver", 0xFF53);
+    if (ret != ESP_OK) {
+        ESP_LOGE(TAG, "failed to configure version endpoint");
+        goto exit;
+    }
+
+    /* Application specific custom endpoints will be assigned
+     * incremental UUIDs starting after this value */
+    prov_ctx->endpoint_uuid_used = 0xFF53;
+
+    /* This delay is so that the client side app is notified first
+     * and then the provisioning is stopped. Default is 1000ms. */
+    prov_ctx->cleanup_delay = 1000;
+
+exit:
+    if (ret != ESP_OK) {
+        if (prov_ctx->prov_scheme_config) {
+            config.scheme.delete_config(prov_ctx->prov_scheme_config);
+        }
+        free(prov_ctx);
+    } else {
+        execute_event_cb(WIFI_PROV_INIT, NULL);
+    }
+    xSemaphoreGiveRecursive(prov_ctx_lock);
+    return ret;
+}
+
+void wifi_prov_mgr_wait(void)
+{
+    if (!prov_ctx_lock) {
+        ESP_LOGE(TAG, "Provisioning manager not initialized");
+        return;
+    }
+
+    while (1) {
+        xSemaphoreTakeRecursive(prov_ctx_lock, portMAX_DELAY);
+        if (prov_ctx &&
+            prov_ctx->prov_state != WIFI_PROV_STATE_IDLE) {
+            xSemaphoreGiveRecursive(prov_ctx_lock);
+            vTaskDelay(1000 / portTICK_PERIOD_MS);
+            continue;
+        }
+        break;
+    }
+    xSemaphoreGiveRecursive(prov_ctx_lock);
+}
+
+void wifi_prov_mgr_deinit(void)
+{
+    if (!prov_ctx_lock) {
+        ESP_LOGE(TAG, "Provisioning manager not initialized");
+        return;
+    }
+
+    xSemaphoreTakeRecursive(prov_ctx_lock, portMAX_DELAY);
+
+    /* This will do one of these:
+     * 1) if found running, stop the provisioning service (returns true)
+     * 2) if service was already in the process of termination, this will
+     *    wait till the service is stopped (returns false)
+     * 3) if service was not running, this will return immediately (returns false)
+     */
+    bool service_was_running = wifi_prov_mgr_stop_service(1);
+
+     /* If service was not running, its also possible that manager
+      * was not even initialized */
+    if (!service_was_running && !prov_ctx) {
+        ESP_LOGD(TAG, "Manager already de-initialized");
+        xSemaphoreGiveRecursive(prov_ctx_lock);
+        return;
+    }
+
+    if (prov_ctx->app_info_json) {
+        cJSON_Delete(prov_ctx->app_info_json);
+    }
+
+    if (prov_ctx->prov_scheme_config) {
+        prov_ctx->mgr_config.scheme.delete_config(prov_ctx->prov_scheme_config);
+    }
+
+    /* Extract the callbacks to be called post deinit */
+    wifi_prov_cb_func_t app_cb = prov_ctx->mgr_config.app_event_handler.event_cb;
+    void *app_data = prov_ctx->mgr_config.app_event_handler.user_data;
+
+    wifi_prov_cb_func_t scheme_cb = prov_ctx->mgr_config.scheme_event_handler.event_cb;
+    void *scheme_data = prov_ctx->mgr_config.scheme_event_handler.user_data;
+
+    /* Free manager context */
+    free(prov_ctx);
+    prov_ctx = NULL;
+    xSemaphoreGiveRecursive(prov_ctx_lock);
+
+    /* If a running service was also stopped during de-initialization
+     * then WIFI_PROV_END event also needs to be emitted before deinit */
+    if (service_was_running) {
+        ESP_LOGD(TAG, "execute_event_cb : %d", WIFI_PROV_END);
+        if (scheme_cb) {
+            scheme_cb(scheme_data, WIFI_PROV_END, NULL);
+        }
+        if (app_cb) {
+            app_cb(app_data, WIFI_PROV_END, NULL);
+        }
+    }
+
+    ESP_LOGD(TAG, "execute_event_cb : %d", WIFI_PROV_DEINIT);
+
+    /* Execute deinit event callbacks */
+    if (scheme_cb) {
+        scheme_cb(scheme_data, WIFI_PROV_DEINIT, NULL);
+    }
+    if (app_cb) {
+        app_cb(app_data, WIFI_PROV_DEINIT, NULL);
+    }
+}
+
+esp_err_t wifi_prov_mgr_start_provisioning(wifi_prov_security_t security, const char *pop,
+                                           const char *service_name, const char *service_key)
+{
+    if (!prov_ctx_lock) {
+        ESP_LOGE(TAG, "Provisioning manager not initialized");
+        return ESP_ERR_INVALID_STATE;
+    }
+
+    xSemaphoreTakeRecursive(prov_ctx_lock, portMAX_DELAY);
+    if (!prov_ctx) {
+        ESP_LOGE(TAG, "Provisioning manager not initialized");
+        xSemaphoreGiveRecursive(prov_ctx_lock);
+        return ESP_ERR_INVALID_STATE;
+    }
+
+    if (prov_ctx->prov_state != WIFI_PROV_STATE_IDLE) {
+        ESP_LOGE(TAG, "Provisioning service already started");
+        xSemaphoreGiveRecursive(prov_ctx_lock);
+        return ESP_ERR_INVALID_STATE;
+    }
+
+    esp_err_t ret = ESP_OK;
+    /* Update state so that parallel call to wifi_prov_mgr_start_provisioning()
+     * or wifi_prov_mgr_stop_provisioning() or wifi_prov_mgr_deinit() from another
+     * thread doesn't interfere with this process */
+    prov_ctx->prov_state = WIFI_PROV_STATE_STARTING;
+
+    /* Change Wi-Fi storage to RAM temporarily and erase any old
+     * credentials (i.e. without erasing the copy on NVS). Also
+     * call disconnect to make sure device doesn't remain connected
+     * to the AP whose credentials were present earlier */
+    wifi_config_t wifi_cfg_empty, wifi_cfg_old;
+    memset(&wifi_cfg_empty, 0, sizeof(wifi_config_t));
+    esp_wifi_get_config(ESP_IF_WIFI_STA, &wifi_cfg_old);
+    esp_wifi_set_storage(WIFI_STORAGE_RAM);
+    esp_wifi_set_config(ESP_IF_WIFI_STA, &wifi_cfg_empty);
+    esp_wifi_disconnect();
+
+    /* Initialize app data */
+    if (pop) {
+        prov_ctx->pop.len = strlen(pop);
+        prov_ctx->pop.data = malloc(prov_ctx->pop.len);
+        if (!prov_ctx->pop.data) {
+            ESP_LOGE(TAG, "Unable to allocate PoP data");
+            ret = ESP_ERR_NO_MEM;
+            goto err;
+        }
+        memcpy((void *)prov_ctx->pop.data, pop, prov_ctx->pop.len);
+    } else {
+        prov_ctx->mgr_info.capabilities.no_pop = true;
+    }
+    prov_ctx->security = security;
+
+    /* If auto stop on completion is enabled (default) create the stopping timer */
+    if (!prov_ctx->mgr_info.capabilities.no_auto_stop) {
+        /* Create timer object as a member of app data */
+        esp_timer_create_args_t timer_conf = {
+            .callback = stop_prov_timer_cb,
+            .arg = NULL,
+            .dispatch_method = ESP_TIMER_TASK,
+            .name = "wifi_prov_mgr_tm"
+        };
+        ret = esp_timer_create(&timer_conf, &prov_ctx->timer);
+        if (ret != ESP_OK) {
+            ESP_LOGE(TAG, "Failed to create timer");
+            free((void *)prov_ctx->pop.data);
+            goto err;
+        }
+    }
+
+    /* System APIs for BLE / Wi-Fi will be called inside wifi_prov_mgr_start_service(),
+     * which may trigger system level events. Hence, releasing the context lock will
+     * ensure that wifi_prov_mgr_event_handler() doesn't block the global event_loop
+     * handler when system events need to be handled */
+    xSemaphoreGiveRecursive(prov_ctx_lock);
+
+    /* Start provisioning service */
+    ret = wifi_prov_mgr_start_service(service_name, service_key);
+    if (ret != ESP_OK) {
+        esp_timer_delete(prov_ctx->timer);
+        free((void *)prov_ctx->pop.data);
+    }
+    xSemaphoreTakeRecursive(prov_ctx_lock, portMAX_DELAY);
+    if (ret == ESP_OK) {
+        prov_ctx->prov_state = WIFI_PROV_STATE_STARTED;
+        /* Execute user registered callback handler */
+        execute_event_cb(WIFI_PROV_START, NULL);
+        goto exit;
+    }
+
+err:
+    prov_ctx->prov_state = WIFI_PROV_STATE_IDLE;
+    esp_wifi_set_storage(WIFI_STORAGE_FLASH);
+    esp_wifi_set_config(ESP_IF_WIFI_STA, &wifi_cfg_old);
+
+exit:
+    xSemaphoreGiveRecursive(prov_ctx_lock);
+    return ret;
+}
+
+void wifi_prov_mgr_stop_provisioning(void)
+{
+    if (!prov_ctx_lock) {
+        ESP_LOGE(TAG, "Provisioning manager not initialized");
+        return;
+    }
+
+    xSemaphoreTakeRecursive(prov_ctx_lock, portMAX_DELAY);
+
+    /* Launches task for stopping the provisioning service. This will do one of these:
+     * 1) start a task for stopping the provisioning service (returns true)
+     * 2) if service was already in the process of termination, this will
+     *    wait till the service is stopped (returns false)
+     * 3) if service was not running, this will return immediately (returns false)
+     */
+    wifi_prov_mgr_stop_service(0);
+
+    xSemaphoreGiveRecursive(prov_ctx_lock);
+}

components/wifi_provisioning/src/scheme_ble.c

@@ -0,0 +1,232 @@
+// Copyright 2019 Espressif Systems (Shanghai) PTE LTD
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include <string.h>
+#include <esp_log.h>
+#include <esp_err.h>
+#include <esp_bt.h>
+
+#include <protocomm.h>
+#include <protocomm_ble.h>
+
+#include "wifi_provisioning/scheme_ble.h"
+#include "wifi_provisioning_priv.h"
+
+static const char *TAG = "wifi_prov_scheme_ble";
+
+extern const wifi_prov_scheme_t wifi_prov_scheme_ble;
+
+static uint8_t *custom_service_uuid;
+
+static esp_err_t prov_start(protocomm_t *pc, void *config)
+{
+    if (!pc) {
+        ESP_LOGE(TAG, "Protocomm handle cannot be null");
+        return ESP_ERR_INVALID_ARG;
+    }
+
+    if (!config) {
+        ESP_LOGE(TAG, "Cannot start with null configuration");
+        return ESP_ERR_INVALID_ARG;
+    }
+
+    protocomm_ble_config_t *ble_config = (protocomm_ble_config_t *) config;
+
+    /* Start protocomm as BLE service */
+    if (protocomm_ble_start(pc, ble_config) != ESP_OK) {
+        ESP_LOGE(TAG, "Failed to start protocomm BLE service");
+        return ESP_FAIL;
+    }
+    return ESP_OK;
+}
+
+esp_err_t wifi_prov_scheme_ble_set_service_uuid(uint8_t *uuid128)
+{
+    if (!uuid128) {
+        return ESP_ERR_INVALID_ARG;
+    }
+    custom_service_uuid = uuid128;
+    return ESP_OK;
+}
+
+static void *new_config(void)
+{
+    protocomm_ble_config_t *ble_config = calloc(1, sizeof(protocomm_ble_config_t));
+    if (!ble_config) {
+        ESP_LOGE(TAG, "Error allocating memory for new configuration");
+        return NULL;
+    }
+
+    /* The default provisioning service UUID */
+    const uint8_t service_uuid[16] = {
+        /* LSB <---------------------------------------
+         * ---------------------------------------> MSB */
+        0xfb, 0x34, 0x9b, 0x5f, 0x80, 0x00, 0x00, 0x80,
+        0x00, 0x10, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00,
+    };
+
+    memcpy(ble_config->service_uuid, service_uuid, sizeof(ble_config->service_uuid));
+    return ble_config;
+}
+
+static void delete_config(void *config)
+{
+    if (!config) {
+        ESP_LOGE(TAG, "Cannot delete null configuration");
+        return;
+    }
+
+    protocomm_ble_config_t *ble_config = (protocomm_ble_config_t *) config;
+    for (unsigned int i = 0; i < ble_config->nu_lookup_count; i++) {
+        free((void *)ble_config->nu_lookup[i].name);
+    }
+    free(ble_config->nu_lookup);
+    free(ble_config);
+}
+
+static esp_err_t set_config_service(void *config, const char *service_name, const char *service_key)
+{
+    if (!config) {
+        ESP_LOGE(TAG, "Cannot set null configuration");
+        return ESP_ERR_INVALID_ARG;
+    }
+
+    if (!service_name) {
+        ESP_LOGE(TAG, "Service name cannot be NULL");
+        return ESP_ERR_INVALID_ARG;
+    }
+
+    protocomm_ble_config_t *ble_config = (protocomm_ble_config_t *) config;
+    strlcpy(ble_config->device_name,  service_name, sizeof(ble_config->device_name));
+
+    /* If a custom service UUID has been provided, override the default one */
+    if (custom_service_uuid) {
+        memcpy(ble_config->service_uuid, custom_service_uuid, sizeof(ble_config->service_uuid));
+    }
+    return ESP_OK;
+}
+
+static esp_err_t set_config_endpoint(void *config, const char *endpoint_name, uint16_t uuid)
+{
+    if (!config) {
+        ESP_LOGE(TAG, "Cannot set null configuration");
+        return ESP_ERR_INVALID_ARG;
+    }
+
+    if (!endpoint_name) {
+        ESP_LOGE(TAG, "EP name cannot be null");
+        return ESP_ERR_INVALID_ARG;
+    }
+
+    protocomm_ble_config_t *ble_config = (protocomm_ble_config_t *) config;
+
+    char *copy_ep_name = strdup(endpoint_name);
+    if (!copy_ep_name) {
+        ESP_LOGE(TAG, "Error allocating memory for EP name");
+        return ESP_ERR_NO_MEM;
+    }
+
+    protocomm_ble_name_uuid_t *lookup_table = (
+                realloc(ble_config->nu_lookup, (ble_config->nu_lookup_count + 1) * sizeof(protocomm_ble_name_uuid_t)));
+    if (!lookup_table) {
+        ESP_LOGE(TAG, "Error allocating memory for EP-UUID lookup table");
+        return ESP_ERR_NO_MEM;
+    }
+
+    lookup_table[ble_config->nu_lookup_count].name = copy_ep_name;
+    lookup_table[ble_config->nu_lookup_count].uuid = uuid;
+    ble_config->nu_lookup = lookup_table;
+    ble_config->nu_lookup_count += 1;
+    return ESP_OK;
+}
+
+/* Used when both BT and BLE are not needed by application */
+void wifi_prov_scheme_ble_event_cb_free_btdm(void *user_data, wifi_prov_cb_event_t event, void *event_data)
+{
+    esp_err_t err;
+    switch (event) {
+        case WIFI_PROV_INIT:
+            /* Release BT memory, as we need only BLE */
+            err = esp_bt_mem_release(ESP_BT_MODE_CLASSIC_BT);
+            if (err != ESP_OK) {
+                ESP_LOGE(TAG, "bt_mem_release of classic BT failed %d", err);
+            } else {
+                ESP_LOGI(TAG, "BT memory released");
+            }
+            break;
+
+        case WIFI_PROV_DEINIT:
+            /* Release memory used by BLE and Bluedroid host stack */
+            err = esp_bt_mem_release(ESP_BT_MODE_BTDM);
+            if (err != ESP_OK) {
+                ESP_LOGE(TAG, "bt_mem_release of BTDM failed %d", err);
+            } else {
+                ESP_LOGI(TAG, "BTDM memory released");
+            }
+            break;
+
+        default:
+            break;
+    }
+}
+
+/* Used when BT is not needed by application */
+void wifi_prov_scheme_ble_event_cb_free_bt(void *user_data, wifi_prov_cb_event_t event, void *event_data)
+{
+    esp_err_t err;
+    switch (event) {
+        case WIFI_PROV_INIT:
+            /* Release BT memory, as we need only BLE */
+            err = esp_bt_mem_release(ESP_BT_MODE_CLASSIC_BT);
+            if (err != ESP_OK) {
+                ESP_LOGE(TAG, "bt_mem_release of classic BT failed %d", err);
+            } else {
+                ESP_LOGI(TAG, "BT memory released");
+            }
+            break;
+
+        default:
+            break;
+    }
+}
+
+/* Used when BLE is not needed by application */
+void wifi_prov_scheme_ble_event_cb_free_ble(void *user_data, wifi_prov_cb_event_t event, void *event_data)
+{
+    esp_err_t err;
+    switch (event) {
+        case WIFI_PROV_DEINIT:
+            /* Release memory used by BLE stack */
+            err = esp_bt_mem_release(ESP_BT_MODE_BLE);
+            if (err != ESP_OK) {
+                ESP_LOGE(TAG, "bt_mem_release of BLE failed %d", err);
+            } else {
+                ESP_LOGI(TAG, "BLE memory released");
+            }
+            break;
+
+        default:
+            break;
+    }
+}
+
+const wifi_prov_scheme_t wifi_prov_scheme_ble = {
+    .prov_start          = prov_start,
+    .prov_stop           = protocomm_ble_stop,
+    .new_config          = new_config,
+    .delete_config       = delete_config,
+    .set_config_service  = set_config_service,
+    .set_config_endpoint = set_config_endpoint,
+    .wifi_mode           = WIFI_MODE_STA
+};

components/wifi_provisioning/src/scheme_console.c

@@ -0,0 +1,92 @@
+// Copyright 2019 Espressif Systems (Shanghai) PTE LTD
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include <string.h>
+#include <esp_log.h>
+#include <esp_err.h>
+#include <esp_wifi.h>
+
+#include <protocomm.h>
+#include <protocomm_console.h>
+
+#include "wifi_provisioning/scheme_console.h"
+#include "wifi_provisioning_priv.h"
+
+static const char *TAG = "wifi_prov_scheme_console";
+
+extern const wifi_prov_scheme_t wifi_prov_scheme_console;
+
+static esp_err_t prov_start(protocomm_t *pc, void *config)
+{
+    if (!pc) {
+        ESP_LOGE(TAG, "Protocomm handle cannot be null");
+        return ESP_ERR_INVALID_ARG;
+    }
+
+    if (!config) {
+        ESP_LOGE(TAG, "Cannot start with null configuration");
+        return ESP_ERR_INVALID_ARG;
+    }
+
+    protocomm_console_config_t *console_config = (protocomm_console_config_t *) config;
+
+    /* Start protocomm console */
+    esp_err_t err = protocomm_console_start(pc, console_config);
+    if (err != ESP_OK) {
+        ESP_LOGE(TAG, "Failed to start protocomm HTTP server");
+        return ESP_FAIL;
+    }
+    return ESP_OK;
+}
+
+static void *new_config(void)
+{
+    protocomm_console_config_t *console_config = malloc(sizeof(protocomm_console_config_t));
+    if (!console_config) {
+        ESP_LOGE(TAG, "Error allocating memory for new configuration");
+        return NULL;
+    }
+    protocomm_console_config_t default_config = PROTOCOMM_CONSOLE_DEFAULT_CONFIG();
+    memcpy(console_config, &default_config, sizeof(default_config));
+    return console_config;
+}
+
+static void delete_config(void *config)
+{
+    if (!config) {
+        ESP_LOGE(TAG, "Cannot delete null configuration");
+        return;
+    }
+    free(config);
+}
+
+static esp_err_t set_config_service(void *config, const char *service_name, const char *service_key)
+{
+    return ESP_OK;
+}
+
+static esp_err_t set_config_endpoint(void *config, const char *endpoint_name, uint16_t uuid)
+{
+    return ESP_OK;
+}
+
+const wifi_prov_scheme_t wifi_prov_scheme_console = {
+    .prov_start          = prov_start,
+    .prov_stop           = protocomm_console_stop,
+    .new_config          = new_config,
+    .delete_config       = delete_config,
+    .set_config_service  = set_config_service,
+    .set_config_endpoint = set_config_endpoint,
+    .wifi_mode           = WIFI_MODE_STA
+};

components/wifi_provisioning/src/scheme_softap.c

@@ -0,0 +1,202 @@
+// Copyright 2019 Espressif Systems (Shanghai) PTE LTD
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include <string.h>
+#include <esp_log.h>
+#include <esp_err.h>
+#include <esp_wifi.h>
+
+#include <mdns.h>
+#include <protocomm.h>
+#include <protocomm_httpd.h>
+
+#include "wifi_provisioning/scheme_softap.h"
+#include "wifi_provisioning_priv.h"
+
+typedef struct softap_config {
+    protocomm_httpd_config_t httpd_config;
+    char ssid[33];
+    char password[65];
+} wifi_prov_softap_config_t;
+
+static const char *TAG = "wifi_prov_scheme_softap";
+
+extern const wifi_prov_scheme_t wifi_prov_scheme_softap;
+
+static esp_err_t start_wifi_ap(const char *ssid, const char *pass)
+{
+    /* Build Wi-Fi configuration for AP mode */
+    wifi_config_t wifi_config = {
+        .ap = {
+            .max_connection = 5,
+        },
+    };
+
+    strncpy((char *) wifi_config.ap.ssid, ssid, sizeof(wifi_config.ap.ssid));
+    wifi_config.ap.ssid_len = strnlen(ssid, sizeof(wifi_config.ap.ssid));
+
+    if (strlen(pass) == 0) {
+        memset(wifi_config.ap.password, 0, sizeof(wifi_config.ap.password));
+        wifi_config.ap.authmode = WIFI_AUTH_OPEN;
+    } else {
+        strlcpy((char *) wifi_config.ap.password, pass, sizeof(wifi_config.ap.password));
+        wifi_config.ap.authmode = WIFI_AUTH_WPA_WPA2_PSK;
+    }
+
+    /* Start Wi-Fi in AP mode with configuration built above */
+    esp_err_t err = esp_wifi_set_mode(WIFI_MODE_AP);
+    if (err != ESP_OK) {
+        ESP_LOGE(TAG, "Failed to set Wi-Fi mode : %d", err);
+        return err;
+    }
+    err = esp_wifi_set_config(ESP_IF_WIFI_AP, &wifi_config);
+    if (err != ESP_OK) {
+        ESP_LOGE(TAG, "Failed to set Wi-Fi config : %d", err);
+        return err;
+    }
+    err = esp_wifi_start();
+    if (err != ESP_OK) {
+        ESP_LOGE(TAG, "Failed to start Wi-Fi : %d", err);
+        return err;
+    }
+    ESP_LOGD(TAG, "Wi-Fi SoftAP started");
+    return ESP_OK;
+}
+
+static esp_err_t prov_start(protocomm_t *pc, void *config)
+{
+    if (!pc) {
+        ESP_LOGE(TAG, "Protocomm handle cannot be null");
+        return ESP_ERR_INVALID_ARG;
+    }
+
+    if (!config) {
+        ESP_LOGE(TAG, "Cannot start with null configuration");
+        return ESP_ERR_INVALID_ARG;
+    }
+
+    wifi_prov_softap_config_t *softap_config = (wifi_prov_softap_config_t *) config;
+
+    protocomm_httpd_config_t *httpd_config = &softap_config->httpd_config;
+
+    /* Start protocomm server on top of HTTP */
+    esp_err_t err = protocomm_httpd_start(pc, httpd_config);
+    if (err != ESP_OK) {
+        ESP_LOGE(TAG, "Failed to start protocomm HTTP server");
+        return err;
+    }
+
+    /* Start Wi-Fi softAP with specified ssid and password */
+    err = start_wifi_ap(softap_config->ssid, softap_config->password);
+    if (err != ESP_OK) {
+        ESP_LOGE(TAG, "Failed to start Wi-Fi AP");
+        protocomm_httpd_stop(pc);
+        return err;
+    }
+
+    /* Add mDNS service for allowing discovery of provisioning
+     * service on the SoftAP network (Optional). Even though
+     * this is an http service we identify it by _esp_wifi_prov so
+     * that application is free to use _http without conflict */
+    err = mdns_service_add("Wi-Fi Provisioning Service", "_esp_wifi_prov", "_tcp",
+                           softap_config->httpd_config.data.config.port, NULL, 0);
+    if (err != ESP_OK) {
+        /* mDNS is not mandatory for provisioning to work,
+         * so print warning and return without failure */
+        ESP_LOGW(TAG, "Error adding mDNS service! Check if mDNS is running");
+    } else {
+        /* Information to identify the roles of the various
+         * protocomm endpoint URIs provided by the service */
+        err |= mdns_service_txt_item_set("_esp_wifi_prov", "_tcp", "version_endpoint", "/proto-ver");
+        err |= mdns_service_txt_item_set("_esp_wifi_prov", "_tcp", "session_endpoint", "/prov-session");
+        err |= mdns_service_txt_item_set("_esp_wifi_prov", "_tcp", "config_endpoint", "/prov-config");
+        if (err != ESP_OK) {
+            ESP_LOGE(TAG, "Error adding mDNS service text item");
+        }
+    }
+    return ESP_OK;
+}
+
+static esp_err_t prov_stop(protocomm_t *pc)
+{
+    esp_err_t err = protocomm_httpd_stop(pc);
+    if (err != ESP_OK) {
+        ESP_LOGW(TAG, "Error occurred while stopping protocomm_httpd");
+    }
+
+    mdns_service_remove("_esp_wifi_prov", "_tcp");
+    return err;
+}
+
+static void *new_config(void)
+{
+    wifi_prov_softap_config_t *softap_config = calloc(1, sizeof(wifi_prov_softap_config_t));
+    if (!softap_config) {
+        ESP_LOGE(TAG, "Error allocating memory for new configuration");
+        return NULL;
+    }
+    protocomm_httpd_config_t default_config = {
+        .data = {
+            .config = PROTOCOMM_HTTPD_DEFAULT_CONFIG()
+        }
+    };
+    softap_config->httpd_config = default_config;
+    return softap_config;
+}
+
+static void delete_config(void *config)
+{
+    if (!config) {
+        ESP_LOGE(TAG, "Cannot delete null configuration");
+        return;
+    }
+
+    wifi_prov_softap_config_t *softap_config = (wifi_prov_softap_config_t *) config;
+    free(softap_config);
+}
+
+static esp_err_t set_config_service(void *config, const char *service_name, const char *service_key)
+{
+    if (!config) {
+        ESP_LOGE(TAG, "Cannot set null configuration");
+        return ESP_ERR_INVALID_ARG;
+    }
+
+    if (!service_name) {
+        ESP_LOGE(TAG, "Service name cannot be NULL");
+        return ESP_ERR_INVALID_ARG;
+    }
+
+    wifi_prov_softap_config_t *softap_config = (wifi_prov_softap_config_t *) config;
+    strlcpy(softap_config->ssid, service_name, sizeof(softap_config->ssid));
+    if (service_key) {
+        strlcpy(softap_config->password, service_key,  sizeof(softap_config->password));
+    }
+    return ESP_OK;
+}
+
+static esp_err_t set_config_endpoint(void *config, const char *endpoint_name, uint16_t uuid)
+{
+    return ESP_OK;
+}
+
+const wifi_prov_scheme_t wifi_prov_scheme_softap = {
+    .prov_start          = prov_start,
+    .prov_stop           = prov_stop,
+    .new_config          = new_config,
+    .delete_config       = delete_config,
+    .set_config_service  = set_config_service,
+    .set_config_endpoint = set_config_endpoint,
+    .wifi_mode           = WIFI_MODE_APSTA
+};

components/wifi_provisioning/src/wifi_provisioning_priv.h

@@ -0,0 +1,44 @@
+// Copyright 2019 Espressif Systems (Shanghai) PTE LTD
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#pragma once
+
+#include <esp_event_loop.h>
+
+#include <protocomm.h>
+#include <protocomm_security.h>
+
+#include "wifi_provisioning/manager.h"
+#include "wifi_provisioning/wifi_config.h"
+
+/**
+ * @brief   Notify manager that provisioning is done
+ *
+ * Stops the provisioning. This is called by the get_status_handler()
+ * when the status is connected. This has no effect if main application
+ * has disabled auto stop on completion by calling
+ * wifi_prov_mgr_disable_auto_stop()
+ *
+ * @return
+ *  - ESP_OK      : Provisioning will be stopped
+ *  - ESP_FAIL    : Failed to stop provisioning
+ */
+esp_err_t wifi_prov_mgr_done(void);
+
+/**
+ * @brief   Get protocomm handlers for wifi_config provisioning endpoint
+ *
+ * @return  wifi_prov_config_handlers_t structure
+ */
+wifi_prov_config_handlers_t get_wifi_prov_handlers(void);