esp_idf_mdl_compat_internal.h

Go to the documentation of this file.

 
#pragma once
 
#ifdef ESP_PLATFORM
 
#include "esp_crt_bundle.h"
#include "esp_err.h"
#include "esp_http_client.h"
#include "mbedtls/sha256.h"
 
#else
 
#include <stddef.h>
#include <stdint.h>
 
#include "esp_err.h"
#include "ra8_attributes.h"
 
/* Every name below IS the ESP-IDF ABI spelling. This branch of the header
 * exists so the annotation walker and clang-tidy can parse mdl_service.c
 * without the SDK installed, which only works if the mirror declares exactly
 * the vendor identifiers the adapter calls -- renaming them to the project
 * conventions would make the mirror wrong rather than compliant.            */
// NOLINTBEGIN(readability-identifier-naming) -- ESP-IDF compatibility symbols retain upstream spellings.
typedef struct esp_http_client* esp_http_client_handle_t;

typedef esp_err_t (*esp_crt_bundle_attach_fn_t)(void* conf);

typedef enum esp_http_client_event_id_t : int32_t {
  HTTP_EVENT_ERROR = 0,    
  HTTP_EVENT_ON_CONNECTED, 
  HTTP_EVENT_HEADERS_SENT, 
  HTTP_EVENT_ON_HEADER,    
  HTTP_EVENT_ON_DATA,      
  HTTP_EVENT_ON_FINISH,    
  HTTP_EVENT_DISCONNECTED, 
  HTTP_EVENT_REDIRECT,     
} esp_http_client_event_id_t;

typedef struct esp_http_client_event_t {
  esp_http_client_event_id_t event_id;     
  esp_http_client_handle_t   client;       
  void*                      data;         
  int                        data_len;     
  void*                      user_data;    
  char*                      header_key;   
  char*                      header_value; 
} esp_http_client_event_t;

typedef esp_err_t (*esp_http_client_event_cb_t)(esp_http_client_event_t* event);

typedef struct esp_http_client_config_t {
  const char*                url;                   
  int                        timeout_ms;            
  int                        buffer_size;           
  esp_crt_bundle_attach_fn_t crt_bundle_attach;     
  bool                       disable_auto_redirect; 
  esp_http_client_event_cb_t event_handler;         
  void*                      user_data;             
} esp_http_client_config_t;

typedef struct mbedtls_sha256_context {
  uint64_t opaque[32]; 
} mbedtls_sha256_context;
 
/*
 * The host parser/test build supplies cross-TU stand-ins for the vendor APIs.
 * Give those first-party stand-ins private identities while leaving the real
 * ESP-IDF build's symbol spellings and ABI untouched.
 */
#define esp_crt_bundle_attach                     priv_esp_crt_bundle_attach
#define esp_http_client_init                      priv_esp_http_client_init
#define esp_http_client_close                     priv_esp_http_client_close
#define esp_http_client_set_url                   priv_esp_http_client_set_url
#define esp_http_client_set_header                priv_esp_http_client_set_header
#define esp_http_client_delete_header             priv_esp_http_client_delete_header
#define esp_http_client_set_timeout_ms            priv_esp_http_client_set_timeout_ms
#define esp_http_client_open                      priv_esp_http_client_open
#define esp_http_client_fetch_headers             priv_esp_http_client_fetch_headers
#define esp_http_client_get_status_code           priv_esp_http_client_get_status_code
#define esp_http_client_read                      priv_esp_http_client_read
#define esp_http_client_is_complete_data_received priv_esp_http_client_is_complete_data_received
#define mbedtls_sha256_init                       priv_mbedtls_sha256_init
#define mbedtls_sha256_starts                     priv_mbedtls_sha256_starts
#define mbedtls_sha256_update                     priv_mbedtls_sha256_update
#define mbedtls_sha256_finish                     priv_mbedtls_sha256_finish

RA8_PRIV esp_err_t esp_crt_bundle_attach(void* conf);

RA8_PRIV esp_http_client_handle_t esp_http_client_init(const esp_http_client_config_t* config);

RA8_PRIV esp_err_t esp_http_client_close(esp_http_client_handle_t client);

RA8_PRIV esp_err_t esp_http_client_set_url(esp_http_client_handle_t client, const char* url);

RA8_PRIV esp_err_t esp_http_client_set_header(esp_http_client_handle_t client,
                                              const char*              key,
                                              const char*              value);

RA8_PRIV esp_err_t esp_http_client_delete_header(esp_http_client_handle_t client, const char* key);

RA8_PRIV esp_err_t esp_http_client_set_timeout_ms(esp_http_client_handle_t client, int timeout_ms);

RA8_PRIV esp_err_t esp_http_client_open(esp_http_client_handle_t client, int64_t write_len);

RA8_PRIV int64_t esp_http_client_fetch_headers(esp_http_client_handle_t client);

RA8_PRIV int esp_http_client_get_status_code(esp_http_client_handle_t client);

RA8_PRIV int esp_http_client_read(esp_http_client_handle_t client, char* buffer, int len);

RA8_PRIV bool esp_http_client_is_complete_data_received(esp_http_client_handle_t client);

RA8_PRIV void mbedtls_sha256_init(mbedtls_sha256_context* ctx);

RA8_PRIV int mbedtls_sha256_starts(mbedtls_sha256_context* ctx, int is224);

RA8_PRIV int
mbedtls_sha256_update(mbedtls_sha256_context* ctx, const unsigned char* input, size_t ilen);

RA8_PRIV int mbedtls_sha256_finish(mbedtls_sha256_context* ctx, unsigned char output[32]);
// NOLINTEND(readability-identifier-naming)
 
#endif