cookie.h

Go to the documentation of this file.

 
#ifndef COOKIE_H
#define COOKIE_H
 
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
#include <time.h>
 
typedef struct cookie cookie_t;
 
typedef struct cookie_jar cookie_jar_t;
 
typedef struct cookie_iterator cookie_iterator_t;
 
typedef enum {
  COOKIE_FLAG_SECURE = 1 << 0,    
  COOKIE_FLAG_HTTP_ONLY = 1 << 1, 
  COOKIE_FLAG_HOST_ONLY = 1 << 2, 
  COOKIE_FLAG_SESSION = 1 << 3,   
  COOKIE_FLAG_PERSISTENT = 1 << 4 
} cookie_flags_t;
 
typedef enum {
  COOKIE_SAMESITE_NONE = 0, 
  COOKIE_SAMESITE_LAX,      
  COOKIE_SAMESITE_STRICT    
} cookie_samesite_t;
 
typedef enum {
  COOKIE_PRIORITY_LOW = 0, 
  COOKIE_PRIORITY_MEDIUM,  
  COOKIE_PRIORITY_HIGH     
} cookie_priority_t;
 
typedef struct cookie {
  char *name;
  char *value;
  char *domain;
  char *path;
 
  time_t expires;
  time_t creation_time;
  time_t last_access_time;
 
  cookie_flags_t flags;
  cookie_samesite_t samesite;
  cookie_priority_t priority;
 
  struct cookie *next;
  struct cookie *prev;
} cookie_t;
 
typedef struct {
  size_t max_cookies_total;       
  size_t max_cookies_per_domain;  
  size_t max_cookie_size;         
  bool accept_session_cookies;    
  bool accept_persistent_cookies; 
  bool accept_third_party;        
  time_t max_age_seconds;         
  const char *persistent_file;    
} cookie_jar_config_t;
 
typedef struct cookie_domain_bucket {
  char *domain;                      
  cookie_t *cookies;                 
  size_t count;                      
  struct cookie_domain_bucket *next; 
} cookie_domain_bucket_t;
 
typedef struct cookie_jar {
  cookie_jar_config_t config;              
  cookie_domain_bucket_t **domain_buckets; 
  size_t bucket_count;                     
  size_t total_cookies;                    
  bool dirty;                              
  time_t last_cleanup;                     
} cookie_jar_t;
 
typedef enum {
  COOKIE_PARSE_SUCCESS = 0,           
  COOKIE_PARSE_ERROR_INVALID_FORMAT,  
  COOKIE_PARSE_ERROR_INVALID_NAME,    
  COOKIE_PARSE_ERROR_INVALID_VALUE,   
  COOKIE_PARSE_ERROR_INVALID_DOMAIN,  
  COOKIE_PARSE_ERROR_INVALID_PATH,    
  COOKIE_PARSE_ERROR_INVALID_EXPIRES, 
  COOKIE_PARSE_ERROR_MEMORY           
} cookie_parse_result_t;
 
typedef struct cookie_match {
  cookie_t *cookie;          
  struct cookie_match *next; 
} cookie_match_t;
 
typedef struct cookie_iterator {
  cookie_jar_t *jar;                      
  size_t bucket_index;                    
  cookie_domain_bucket_t *current_bucket; 
  cookie_t *current_cookie;               
  const char *domain_filter;              
  bool include_http_only;                 
} cookie_iterator_t;
 
cookie_jar_t *cookie_jar_new(void);
 
cookie_jar_t *cookie_jar_new_with_config(const cookie_jar_config_t *config);
 
void cookie_jar_free(cookie_jar_t *jar);
 
cookie_jar_config_t cookie_jar_default_config(void);
 
void cookie_jar_clear(cookie_jar_t *jar);
 
size_t cookie_jar_count(const cookie_jar_t *jar);
 
size_t cookie_jar_count_for_domain(const cookie_jar_t *jar, const char *domain);
 
cookie_t *cookie_new(const char *name, const char *value, const char *domain,
                     const char *path);
 
cookie_parse_result_t cookie_parse_set_cookie(const char *header_value,
                                              const char *request_url,
                                              cookie_t **cookie);
 
cookie_parse_result_t
cookie_parse_set_cookie_headers(const char **header_values, size_t count,
                                const char *request_url, cookie_t ***cookies,
                                size_t *cookie_count);
 
cookie_t *cookie_clone(const cookie_t *cookie);
 
void cookie_free(cookie_t *cookie);
 
void cookie_set_expires(cookie_t *cookie, time_t expires);
 
void cookie_set_max_age(cookie_t *cookie, int64_t max_age_seconds);
 
void cookie_set_secure(cookie_t *cookie, bool secure);
 
void cookie_set_http_only(cookie_t *cookie, bool http_only);
 
void cookie_set_samesite(cookie_t *cookie, cookie_samesite_t samesite);
 
void cookie_set_priority(cookie_t *cookie, cookie_priority_t priority);
 
bool cookie_is_secure(const cookie_t *cookie);
 
bool cookie_is_http_only(const cookie_t *cookie);
 
bool cookie_is_session(const cookie_t *cookie);
 
bool cookie_is_expired(const cookie_t *cookie, time_t current_time);
 
bool cookie_is_host_only(const cookie_t *cookie);
 
cookie_samesite_t cookie_get_samesite(const cookie_t *cookie);
 
cookie_priority_t cookie_get_priority(const cookie_t *cookie);
 
void cookie_touch(cookie_t *cookie);
 
bool cookie_jar_add(cookie_jar_t *jar, cookie_t *cookie);
 
bool cookie_jar_remove(cookie_jar_t *jar, const char *name, const char *domain,
                       const char *path);
 
size_t cookie_jar_remove_domain(cookie_jar_t *jar, const char *domain);
 
size_t cookie_jar_cleanup_expired(cookie_jar_t *jar);
 
size_t cookie_jar_remove_session(cookie_jar_t *jar);
 
cookie_match_t *cookie_jar_get_cookies_for_url(cookie_jar_t *jar,
                                               const char *url,
                                               bool include_http_only);
 
cookie_match_t *cookie_jar_get_cookies(cookie_jar_t *jar, const char *domain,
                                       const char *path, bool secure_only,
                                       bool include_http_only);
 
void cookie_match_free(cookie_match_t *matches);
 
char *cookie_match_to_header(const cookie_match_t *matches);
 
cookie_iterator_t cookie_jar_iterator(cookie_jar_t *jar);
 
cookie_iterator_t cookie_jar_iterator_domain(cookie_jar_t *jar,
                                             const char *domain);
 
cookie_t *cookie_iterator_next(cookie_iterator_t *iter);
 
bool cookie_iterator_has_next(const cookie_iterator_t *iter);
 
void cookie_iterator_reset(cookie_iterator_t *iter);
 
bool cookie_jar_load_binary(cookie_jar_t *jar, const char *filename);
 
bool cookie_jar_save_binary(const cookie_jar_t *jar, const char *filename);
 
char *cookie_jar_save_binary_buffer(const cookie_jar_t *jar,
                                    size_t *buffer_size);
 
bool cookie_jar_load_binary_buffer(cookie_jar_t *jar, const char *buffer,
                                   size_t buffer_size);
 
bool cookie_domain_matches(const char *cookie_domain,
                           const char *request_domain);
 
bool cookie_path_matches(const char *cookie_path, const char *request_path);
 
char *cookie_canonicalize_domain(const char *domain);
 
char *cookie_default_path(const char *url);
 
bool cookie_is_public_suffix(const char *domain);
 
bool cookie_is_valid_name(const char *name);
 
bool cookie_is_valid_value(const char *value);
 
char *cookie_url_decode(const char *encoded);
 
char *cookie_url_encode(const char *decoded);
 
const char *cookie_samesite_to_string(cookie_samesite_t samesite);
 
cookie_samesite_t cookie_samesite_from_string(const char *str);
 
const char *cookie_priority_to_string(cookie_priority_t priority);
 
cookie_priority_t cookie_priority_from_string(const char *str);
 
const char *cookie_parse_error_string(cookie_parse_result_t result);
 
#define COOKIE_MAX_NAME_LENGTH 256
 
#define COOKIE_MAX_VALUE_LENGTH 4096
 
#define COOKIE_MAX_DOMAIN_LENGTH 253
 
#define COOKIE_MAX_PATH_LENGTH 1024
 
#define COOKIE_DEFAULT_MAX_COOKIES 3000
 
#define COOKIE_DEFAULT_MAX_PER_DOMAIN 50
 
#define COOKIE_DEFAULT_MAX_AGE_SECONDS (365 * 24 * 60 * 60)
 
#define COOKIE_IS_VALID_FOR_HTTP(cookie)                                       \
  ((cookie) != NULL && !cookie_is_expired((cookie), time(NULL)))
 
#define COOKIE_IS_VALID_FOR_HTTPS(cookie)                                      \
  (COOKIE_IS_VALID_FOR_HTTP(cookie) && (!cookie_is_secure(cookie) || true))
 
#endif /* COOKIE_H */