internal.h

Go to the documentation of this file.

 
#ifndef CSILK_INTERNAL_H
#define CSILK_INTERNAL_H
 
#include <setjmp.h>
#include <stddef.h>
#include <stdint.h>
#include <uv.h>
 
#include "csilk/csilk.h"
#include "csilk/test/test.h"
 
typedef struct {
    uint32_t state[5];  
    uint32_t count[2];  
    uint8_t buffer[64]; 
} csilk_sha1_ctx;
 
void csilk_sha1_init(csilk_sha1_ctx* context);
 
void csilk_sha1_update(csilk_sha1_ctx* context, const uint8_t* data, size_t len);
 
void csilk_sha1_final(csilk_sha1_ctx* context, uint8_t digest[20]);
 
typedef struct {
    uint32_t state[8];  
    uint64_t count;     
    uint8_t buffer[64]; 
} csilk_sha256_ctx;
 
void csilk_sha256_init(csilk_sha256_ctx* context);
 
void csilk_sha256_update(csilk_sha256_ctx* context, const uint8_t* data, size_t len);
 
void csilk_sha256_final(csilk_sha256_ctx* context, uint8_t digest[32]);
 
void csilk_hmac_sha256(
    const uint8_t* key, size_t key_len, const uint8_t* data, size_t data_len, uint8_t out[32]);
 
void csilk_base64_encode(const uint8_t* src, size_t len, char* out);
 
void csilk_base64url_encode(const uint8_t* src, size_t len, char* out);
 
int csilk_base64url_decode(const char* src, uint8_t* out);
 
void csilk_ws_parse_frame(csilk_ctx_t* c, const uint8_t* buf, size_t nread);
 
void _csilk_send_response(csilk_ctx_t* c) __attribute__((weak));
 
void _csilk_send_data(csilk_ctx_t* c, const uint8_t* data, size_t len);
 
void _csilk_hmac_sha256(csilk_ctx_t* c,
            const uint8_t* key,
            size_t key_len,
            const uint8_t* data,
            size_t data_len,
            uint8_t out[32]);
 
void _csilk_generate_uuid(csilk_ctx_t* c, char buf[37]);
 
void* _csilk_get_internal_client(csilk_ctx_t* c);
 
void _csilk_set_internal_client(csilk_ctx_t* c, void* client);
 
int _csilk_symmetric_encrypt(csilk_ctx_t* c,
                 const uint8_t* key,
                 size_t key_len,
                 const uint8_t* plaintext,
                 size_t plaintext_len,
                 const uint8_t* iv,
                 size_t iv_len,
                 uint8_t* ciphertext,
                 size_t* ciphertext_len,
                 uint8_t* tag,
                 size_t tag_len);
 
int _csilk_symmetric_decrypt(csilk_ctx_t* c,
                 const uint8_t* key,
                 size_t key_len,
                 const uint8_t* ciphertext,
                 size_t ciphertext_len,
                 const uint8_t* iv,
                 size_t iv_len,
                 const uint8_t* tag,
                 size_t tag_len,
                 uint8_t* plaintext,
                 size_t* plaintext_len);
 
int _csilk_generate_keypair(
    csilk_ctx_t* c, char* public_key, size_t* pub_len, char* private_key, size_t* priv_len);
 
int _csilk_asymmetric_encrypt(csilk_ctx_t* c,
                  const char* public_key,
                  size_t pub_len,
                  const uint8_t* plaintext,
                  size_t plaintext_len,
                  uint8_t* ciphertext,
                  size_t* ciphertext_len);
 
int _csilk_asymmetric_decrypt(csilk_ctx_t* c,
                  const char* private_key,
                  size_t priv_len,
                  const uint8_t* ciphertext,
                  size_t ciphertext_len,
                  uint8_t* plaintext,
                  size_t* plaintext_len);
 
int _csilk_sign(csilk_ctx_t* c,
        const char* private_key,
        size_t priv_len,
        const uint8_t* data,
        size_t data_len,
        uint8_t* signature,
        size_t* sig_len);
 
int _csilk_verify(csilk_ctx_t* c,
          const char* public_key,
          size_t pub_len,
          const uint8_t* data,
          size_t data_len,
          const uint8_t* signature,
          size_t sig_len);
 
size_t csilk_url_decode(char* str);
 
void csilk_generate_uuid(char* buf);
 
typedef struct csilk_mq_msg_s {
    char* topic;   
    void* payload; 
    size_t len;    
    struct csilk_mq_msg_s*
        next; 
} csilk_mq_msg_t;
 
typedef struct csilk_mq_topic_s {
    char* name;            
    csilk_mq_handler_t* handlers;  
    size_t handler_count;          
    size_t handler_capacity;       
    struct csilk_mq_topic_s* next; 
} csilk_mq_topic_t;
 
struct csilk_mq_s {
    uv_async_t async_handle;    
    uv_mutex_t queue_mutex;     
    csilk_mq_msg_t* queue_head; 
    csilk_mq_msg_t* queue_tail; 
    csilk_mq_topic_t* topics; 
    /* Global middlewares */
    csilk_mq_handler_t* global_middlewares; 
    size_t global_mw_count;    
    size_t global_mw_capacity; 
    /* Persistence (WAL) */
    uv_file wal_fd;       
    char* wal_path;       
    uv_mutex_t wal_mutex; 
    /* Monitoring */
    uint64_t published_total; 
    uint64_t delivered_total; 
    uint64_t failed_total;    
    uint32_t queue_depth;     
    csilk_ctx_t** monitors;   
    size_t monitor_count;     
    size_t monitor_capacity;  
    uv_mutex_t monitor_mutex; 
};
 
struct csilk_mq_ctx_s {
    csilk_mq_t* mq;           
    csilk_mq_msg_t* msg;          
    csilk_mq_handler_t* handlers; 
    size_t handler_count;         
    int handler_index;        
    int aborted;              
};
 
typedef struct {
    uv_work_t req;         
    csilk_mq_worker_t handler; 
    char* topic;           
    void* payload;         
    size_t len;        
} csilk_mq_work_ctx_t;
 
csilk_mq_t* _csilk_mq_new(uv_loop_t* loop);
 
void _csilk_mq_free(csilk_mq_t* mq);
 
#endif