wa_session.h

Go to the documentation of this file.

 
#ifndef RCBENCH_WA_SESSION_H
#define RCBENCH_WA_SESSION_H
 
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
 
#ifdef __cplusplus
extern "C" {
#endif

#define WA_SECRET_LEN   8u
#define WA_SECRET_CHARS "abcdefghjkmnpqrstuvwxyz23456789"
#define WA_NAME_MAX     13u

#define WA_SSID_MAX     32u
#define WA_PASS_MIN     8u
#define WA_PASS_MAX     63u

#define WA_IDLE_MS      (10u * 60u * 1000u)
#define WA_JOIN_MS      20000u
#define WA_AUTH_TRIES   3u
#define WA_ADDRESS_MS   15000u
#define WA_START_MS     10000u
#define WA_SCAN_TRIES   3u
#define WA_GUESS_MAX    16u
 
/* ------------------------------------------------------------- names */

typedef uint32_t (*wa_rand_fn)(void *ctx);

void wa_secret_make(char out[WA_SECRET_LEN + 1u], wa_rand_fn rand, void *ctx);

void wa_name(const uint8_t mac[6], char out[WA_NAME_MAX]);
 
/* ------------------------------------------------------- what is kept */

typedef struct {
    bool have_net;                    
    char ssid[WA_SSID_MAX + 1u];      
    char pass[WA_PASS_MAX + 1u];      
    bool code_on;                     
} wa_conf_t;

typedef enum {
    WA_CONF_OK = 0,        
    WA_CONF_SSID_EMPTY,    
    WA_CONF_SSID_LONG,     
    WA_CONF_SSID_CHAR,     
    WA_CONF_PASS_SHORT,    
    WA_CONF_PASS_LONG,     
    WA_CONF_PASS_CHAR,     
} wa_conf_err_t;

void wa_conf_defaults(wa_conf_t *c);

wa_conf_err_t wa_conf_set_net(wa_conf_t *c, const char *ssid, size_t ssid_len,
                              const char *pass, size_t pass_len);

typedef struct {
    bool (*load)(void *ctx, wa_conf_t *out);
    bool (*save)(void *ctx, const wa_conf_t *c);
    bool (*erase)(void *ctx);
    void *ctx;   
} wa_store_t;

void wa_conf_load(const wa_store_t *s, wa_conf_t *out);

bool wa_conf_save(const wa_store_t *s, const wa_conf_t *c);

bool wa_conf_forget(const wa_store_t *s, wa_conf_t *c);

#define WA_PENDING_RETRIES   3u
#define WA_PENDING_RETRY_MS  10000u

typedef struct {
    bool     erase;     
    bool     save;      
    bool     failed;    
    uint8_t  left;      
    uint32_t next_ms;   
    uint32_t gen;       
} wa_pending_t;

void wa_pending_init(wa_pending_t *p);

void wa_pending_change(wa_pending_t *p);

void wa_pending_forget(wa_pending_t *p);

bool wa_pending_due(const wa_pending_t *p, bool may_write, uint32_t now_ms);

void wa_pending_write(const wa_store_t *st, const wa_pending_t *snap,
                      const wa_conf_t *c, bool *erase_ok, bool *save_ok);

void wa_pending_done(wa_pending_t *p, const wa_pending_t *snap,
                     bool erase_ok, bool save_ok, uint32_t now_ms);

#define WA_CAN_AP    0x1u
#define WA_CAN_JOIN  0x2u

unsigned wa_modes(const wa_conf_t *c);
 
/* ------------------------------------------------------- the scan list */

#define WA_SCAN_MAX 16u

typedef struct {
    char   ssid[WA_SSID_MAX + 1u];   
    int8_t rssi;                     
} wa_net_t;

typedef struct {
    wa_net_t net[WA_SCAN_MAX];   
    unsigned n;                  
    unsigned dropped;            
} wa_scan_t;

void wa_scan_clear(wa_scan_t *s);

void wa_scan_add(wa_scan_t *s, const uint8_t *ssid, size_t len, int8_t rssi,
                 bool usable);

const char *wa_scan_pick(const wa_scan_t *s, unsigned i);
 
/* ------------------------------------------------------- the session */

typedef enum {
    WA_MODE_AP = 0,    
    WA_MODE_JOIN,      
    WA_MODE_SCAN,      
    WA_MODE_FETCH,
} wa_mode_t;

typedef enum {
    WA_ST_OFF = 0,     
    WA_ST_STARTING,    
    WA_ST_AP,          
    WA_ST_SCANNING,    
    WA_ST_JOINING,     
    WA_ST_ADDRESS,     
    WA_ST_JOINED,      
} wa_state_t;

typedef enum {
    WA_OFF_NONE = 0,   
    WA_OFF_ARMED,      
    WA_OFF_SUPPLY,     
    WA_OFF_RUN,        
    WA_OFF_STOP,       
    WA_OFF_IDLE,       
    WA_OFF_GUESSES,    
    WA_OFF_ASKED,      
    WA_OFF_INSTALL,    
    WA_OFF_FAILED,     
    WA_OFF_JOIN,       
} wa_off_t;

typedef enum {
    WA_JOIN_OK = 0,      
    WA_JOIN_PASSWORD,    
    WA_JOIN_NOT_FOUND,   
    WA_JOIN_NO_ADDRESS,  
    WA_JOIN_LOST,        
} wa_join_err_t;

typedef struct {
    wa_state_t    state;      
    wa_mode_t     mode;       
    wa_off_t      off;        
    wa_join_err_t join_err;   
    uint32_t      since_ms;   
    uint32_t      last_ms;    
    unsigned      busy;       
    unsigned      guesses;    
    unsigned      auth_drops; 
    uint32_t      ip;         
    unsigned      scan_runs;  
    uint32_t      scan_tok;   
    uint32_t      scan_seq;   
    bool          linger;     
    char          pass[WA_SECRET_LEN + 1u];   
    char          code[WA_SECRET_LEN + 1u];   
} wa_t;

void wa_init(wa_t *w);

wa_off_t wa_gate(bool armed, bool supply, bool run);

wa_off_t wa_start(wa_t *w, wa_mode_t mode, wa_off_t gate, uint32_t now_ms,
                  wa_rand_fn rand, void *ctx);

void wa_close(wa_t *w, wa_off_t why);

bool wa_radio(const wa_t *w);

bool wa_lingers(const wa_t *w);

void wa_unlinger(wa_t *w);

bool wa_serving(const wa_t *w);

void wa_on_ap_up(wa_t *w, uint32_t now_ms);

void wa_on_scan_done(wa_t *w);

void wa_on_associated(wa_t *w, uint32_t now_ms);

void wa_on_address(wa_t *w, uint32_t ip, uint32_t now_ms);

void wa_on_join_failed(wa_t *w, wa_join_err_t why);

bool wa_on_drop(wa_t *w, bool auth);

void wa_on_failed(wa_t *w);
 
/* ------------------------------------------------------- the scan */

typedef enum {
    WA_SCAN_IGNORE = 0, 
    WA_SCAN_TAKE,       
    WA_SCAN_AGAIN,      
    WA_SCAN_FAILED,     
} wa_scan_step_t;

uint32_t wa_scan_begin(wa_t *w);

uint32_t wa_scan_pending(const wa_t *w);

bool wa_scan_is(const wa_t *w, uint32_t tok);

bool wa_scan_refused(wa_t *w, uint32_t tok);

bool wa_scan_read_ok(uint32_t status, unsigned reported, bool read_ok,
                     unsigned read, unsigned room);

wa_scan_step_t wa_on_scan_end(wa_t *w, uint32_t tok, bool ok,
                              uint32_t *next);

bool wa_tick(wa_t *w, uint32_t now_ms, wa_off_t gate, bool stop);

void wa_request_begin(wa_t *w, uint32_t now_ms);

void wa_request_end(wa_t *w, uint32_t now_ms);

uint32_t wa_idle_left(const wa_t *w, uint32_t now_ms);

typedef enum {
    WA_CODE_OK = 0,    
    WA_CODE_MISSING,   
    WA_CODE_WRONG,     
    WA_CODE_CLOSED,    
} wa_code_t;

wa_code_t wa_code_check(wa_t *w, const char *given, bool code_on);
 
#ifdef __cplusplus
}
#endif
 
#endif /* RCBENCH_WA_SESSION_H */