types.h

/*
 * types.h
 *
 * Version: 2.2.5
 *
 * -----------------------------------------------------------------------------
 *
 * SPDX-License-Identifier: MIT
 *
 * Copyright (c) 2018-2024 Ryan M. Lederman <lederman@gmail.com>
 * Copyright (c) 2018-2024 Jeffrey H. Johnson <trnsz@pobox.com>
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy of
 * this software and associated documentation files (the "Software"), to deal in
 * the Software without restriction, including without limitation the rights to
 * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
 * the Software, and to permit persons to whom the Software is furnished to do so,
 * subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
 * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
 * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
 * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 *
 * -----------------------------------------------------------------------------
 */
 
#ifndef _SIR_TYPES_H_INCLUDED
# define _SIR_TYPES_H_INCLUDED
 
# include "sir/platform.h"
# include "sir/config.h"
# include "sir/ansimacros.h"
 
typedef uint32_t sirfileid;
 
typedef uint32_t sirpluginid;
 
/*
 * The following define the available levels of logging output.
 */
 
# define SIRL_NONE    0x0000U 
# define SIRL_EMERG   0x0001U 
# define SIRL_ALERT   0x0002U 
# define SIRL_CRIT    0x0004U 
# define SIRL_ERROR   0x0008U 
# define SIRL_WARN    0x0010U 
# define SIRL_NOTICE  0x0020U 
# define SIRL_INFO    0x0040U 
# define SIRL_DEBUG   0x0080U 
# define SIRL_ALL     0x00ffU 
# define SIRL_DEFAULT 0x0100U 
typedef uint16_t sir_level;
 
typedef uint16_t sir_levels;
 
/*
 * Formatting options for a destination.
 */
 
# define SIRO_ALL     0x00000000U 
# define SIRO_NOTIME  0x00000100U 
# define SIRO_NOMSEC  0x00000200U 
# define SIRO_NOHOST  0x00000400U 
# define SIRO_NOLEVEL 0x00000800U 
# define SIRO_NONAME  0x00001000U 
# define SIRO_NOPID   0x00002000U 
# define SIRO_NOTID   0x00004000U 
# define SIRO_NOHDR   0x00010000U 
# define SIRO_MSGONLY 0x00007f00U 
# define SIRO_DEFAULT 0x00100000U 
typedef uint32_t sir_option;
 
typedef uint32_t sir_options;
 
typedef enum {
    SIRCM_16      = 0, 
    SIRCM_256     = 1, 
    SIRCM_RGB     = 2, 
    SIRCM_INVALID = 3  
} sir_colormode;
 
typedef enum {
    SIRTA_NORMAL  = 0, 
    SIRTA_BOLD    = 1, 
    SIRTA_DIM     = 2, 
    SIRTA_EMPH    = 3, 
    SIRTA_ULINE   = 4, 
} sir_textattr;
 
enum {
    /* 4-bit (16-color). */
    SIRTC_BLACK    = 0,  
    SIRTC_RED      = 1,  
    SIRTC_GREEN    = 2,  
    SIRTC_YELLOW   = 3,  
    SIRTC_BLUE     = 4,  
    SIRTC_MAGENTA  = 5,  
    SIRTC_CYAN     = 6,  
    SIRTC_LGRAY    = 7,  
    SIRTC_DGRAY    = 8,  
    SIRTC_BRED     = 9,  
    SIRTC_BGREEN   = 10, 
    SIRTC_BYELLOW  = 11, 
    SIRTC_BBLUE    = 12, 
    SIRTC_BMAGENTA = 13, 
    SIRTC_BCYAN    = 14, 
    SIRTC_WHITE    = 15, 
    /* 8-bit (256-color) and 24-bit (RGB color) modes:
     * use the numeric representation (16..255) instead of an enum.
     * these colors do not have defined names like the above. */
    SIRTC_DEFAULT  = 256 
};
 
typedef uint32_t sir_textcolor;
 
typedef struct {
    const char* func;          
    const char* file;          
    uint32_t line;             
    int os_code;               
    char os_msg[SIR_MAXERROR]; 
    uint16_t code;             
    char msg[SIR_MAXERROR];    
} sir_errorinfo;
 
typedef struct {
    sir_textattr attr; 
    sir_textcolor fg;  
    sir_textcolor bg;  
} sir_textstyle;
 
typedef struct {
    sir_levels levels;
 
    sir_options opts;
} sir_stdio_dest;
 
typedef struct {
    sir_levels levels; 
    sir_options opts;
 
    struct {
        uint32_t mask; 
        void* logger;  
    } _state;
 
    char identity[SIR_MAX_SYSLOG_ID];
 
    char category[SIR_MAX_SYSLOG_CAT];
} sir_syslog_dest;
 
typedef struct {
    sir_stdio_dest d_stdout;  
    sir_stdio_dest d_stderr;  
    sir_syslog_dest d_syslog; 
    char name[SIR_MAXNAME];
} sirinit;
 
# define _SIR_MAGIC 0x60906090U
 
# define SIRSL_IS_OPEN  0x00000001U 
# define SIRSL_LEVELS   0x00000002U 
# define SIRSL_OPTIONS  0x00000004U 
# define SIRSL_CATEGORY 0x00000008U 
# define SIRSL_IDENTITY 0x00000010U 
# define SIRSL_UPDATED  0x00000020U 
# define SIRSL_IS_INIT  0x00000040U 
# if defined(__WIN__)
typedef void (*invalparamfn)(const wchar_t*, const wchar_t*, const wchar_t*,
    unsigned int, uintptr_t);
# endif
 
typedef struct {
# if !defined(__WIN__)
    time_t sec;
    long msec;
# else /* __WIN__ */
    LARGE_INTEGER counter;
# endif
} sir_time;
 
typedef struct {
    sirinit si;
    struct {
        char hostname[SIR_MAXHOST];
        time_t last_hname_chk;
        char pidbuf[SIR_MAXPID];
        pid_t pid;
        char timestamp[SIR_MAXTIME];
 
        struct {
            bool squelch;
            uint64_t hash;
            char prefix[2];
            sir_level level;
            size_t counter;
            size_t threshold;
        } last;
    } state;
} sirconfig;
 
typedef struct {
    const char* path;
    sir_levels levels;
    sir_options opts;
    FILE* f;
    sirfileid id;
    int writes_since_size_chk;
} sirfile;
 
typedef struct {
    sirfile* files[SIR_MAXFILES];
    size_t count;
} sirfcache;
 
typedef struct {
    uint8_t iface_ver;  
    uint8_t maj_ver;    
    uint8_t min_ver;    
    uint8_t bld_ver;    
    sir_levels levels;  
    sir_options opts;   
    const char* author; 
    const char* desc;   
    uint64_t caps;      
} sir_plugininfo;
 
# define SIR_PLUGIN_V1 1
# define SIR_PLUGIN_VCURRENT SIR_PLUGIN_V1
 
# define SIR_PLUGIN_EXPORT_QUERY   "sir_plugin_query"
# define SIR_PLUGIN_EXPORT_INIT    "sir_plugin_init"
# define SIR_PLUGIN_EXPORT_WRITE   "sir_plugin_write"
# define SIR_PLUGIN_EXPORT_CLEANUP "sir_plugin_cleanup"
 
typedef bool (*sir_plugin_queryfn)(sir_plugininfo*);
typedef bool (*sir_plugin_initfn)(void);
typedef bool (*sir_plugin_writefn)(sir_level, const char*);
typedef bool (*sir_plugin_cleanupfn)(void);
 
typedef struct {
    sir_plugin_queryfn query;     
    sir_plugin_initfn init;       
    sir_plugin_writefn write;     
    sir_plugin_cleanupfn cleanup; 
} sir_pluginifacev1;
 
typedef sir_pluginifacev1 sir_pluginiface;
 
typedef struct {
    const char* path;
    sir_pluginhandle handle;
    sir_plugininfo info;
    bool loaded;
    bool valid;
    sir_pluginiface iface;
    sirpluginid id;
} sir_plugin;
 
typedef struct {
    sir_plugin* plugins[SIR_MAXPLUGINS];
    size_t count;
} sir_plugincache;
 
typedef struct _sir_queue_node {
    struct _sir_queue_node* next;
    void* data;
} sir_queue_node;
 
typedef struct {
    sir_queue_node* head; 
} sir_queue;
 
typedef struct {
    bool (*fn)(void*); 
    void* data;        
} sir_threadpool_job;
 
typedef struct {
    sir_thread* threads; 
    size_t num_threads;  
    sir_queue* jobs;     
    sir_condition cond;  
    sir_mutex mutex;     
    bool cancel;         
} sir_threadpool;
 
typedef struct {
    char style[SIR_MAXSTYLE];
    char* timestamp;
    char msec[SIR_MAXMSEC];
    const char* hostname;
    const char* pid;
    const char* level;
    const char* name;
    char tid[SIR_MAXPID];
    char message[SIR_MAXMESSAGE];
    char output[SIR_MAXOUTPUT];
    size_t output_len;
} sirbuf;
 
typedef struct {
    const sir_level level;  
    sir_textstyle style;    
    char str[SIR_MAXSTYLE]; 
} sir_level_style_tuple;
 
typedef struct {
    sir_level_style_tuple* map;
    sir_colormode* color_mode;
} sir_text_style_data;
 
typedef struct {
    const sir_level level; 
    const char* fmt;       
} sir_level_str_pair;
 
typedef enum {
    SIRMI_CONFIG = 0,  
    SIRMI_FILECACHE,   
    SIRMI_PLUGINCACHE, 
# if !defined(SIR_NO_TEXT_STYLING)
    SIRMI_TEXTSTYLE,   
# endif
} sir_mutex_id;
 
typedef struct {
    uint32_t lasterror;
    int os_code;
    char os_msg[SIR_MAXERROR];
 
    struct {
        const char* func;
        const char* file;
        uint32_t line;
    } loc;
} sir_thread_err;
 
typedef uint32_t sir_config_data_field;
 
# define SIRU_LEVELS     0x00000001U 
# define SIRU_OPTIONS    0x00000002U 
# define SIRU_SYSLOG_ID  0x00000004U 
# define SIRU_SYSLOG_CAT 0x00000008U 
# define SIRU_ALL        0x0000000fU 
typedef struct {
    uint32_t fields;         
    sir_levels* levels;      
    sir_options* opts;       
    const char* sl_identity; 
    const char* sl_category; 
} sir_update_config_data;
 
#endif /* !_SIR_TYPES_H_INCLUDED */