el_utils.h

Go to the documentation of this file.

 
#ifndef EL_UTILS_H_
#define EL_UTILS_H_
 
#define _GNU_SOURCE
 
#include <stdint.h>     
#include <stdbool.h>    
#include <byteswap.h>   
#include <unistd.h>     
#include <time.h>       //struct timeval for modbus_t //for logging
#include <malloc.h>
#include <time.h>
#include <linux/limits.h>   
#include <arpa/inet.h>  //inet_ntop()
#include <errno.h>
#include <netdb.h>
#include <stdio.h>  //for logging
#include <signal.h> //kill()
#include <pthread.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <fcntl.h>
#include <json-c/json.h>
#include <stdarg.h>
 
#ifdef IN_BUILD
 //string exists during real build
#else
#   pragma message ("in IDE")
#endif
 
#ifndef  gettid
#include <sys/syscall.h>      /* Definition of SYS_* constants */
#include <unistd.h>     /* gettid() */
//static inline pid_t gettid(void)
//{
//    return syscall(SYS_gettid);
//}
#endif /* ifndef  gettid */
 
 
#include "elutils/pslist.h"
#include "elutils/psl_ndx.h"
 
//#ifdef MIPSEL_24KC
//#pragma message "MIPSEL_24KC build"
//#else
//#  include <sys/cdefs.h>
//#  define EL_DBG 1
//#endif
//#ifndef __BEGIN_DECLS
//#  if defined(__cplusplus)
//#    define __BEGIN_DECLS   extern "C" {
//#    define __END_DECLS     }
//#  else
//#    define __BEGIN_DECLS
//#    define __END_DECLS
//#  endif
//#endif /* ifndef __BEGIN_DECLS */
#include "elutils/c_decls.h"
__BEGIN_DECLS /* till __END_DECLS */
 
#define NAME_BUF_SZ_MAX (NAME_MAX + 1)
#define UNUSED(x) (void)(x)
#define PUT_ERR(ERR,ERRN) if (ERR) *ERR = ERRN
#define ERROR_FD -1
#define CLOSE_FD(FD) close(FD); FD = ERROR_FD
 
#ifndef  gettid
#include <sys/syscall.h>      /* Definition of SYS_* constants */
#include <unistd.h>     /* gettid() */
//static inline pid_t gettid(void)
//{
//    return syscall(SYS_gettid);
//}
#endif /* ifndef  gettid */
 
//time measure ----------------------------------------------------------------
 
//#define EL_WRONG_PTR (void*)(-1LL)
#define EL_WRONG_PTR (void*)(0)
 
#ifndef NOERROR
#   define NOERROR (0)
#endif
 
//for static compiled array
#ifndef ARRAY_SIZE
#  define ARRAY_SIZE(foo) (sizeof(foo)/sizeof(foo[0]))
#endif
 
//defines for big tens used with timeouts in nanoseconds in 'struct timespec'
#define TENS_KILO 1000LL
#define TENS_MEGA 1000000LL
#define TENS_GIGA 1000000000LL
 
//return ts2 - ts1 in nanosec//static inline pid_t gettid(void)
//{
//    return syscall(SYS_gettid);
//}
 
static inline uint64_t timespec_diff(struct timespec *ts1, struct timespec *ts2)
{
    return ((uint64_t) ts2->tv_sec - (uint64_t) ts1->tv_sec) * TENS_GIGA + (uint64_t) ts2->tv_nsec - (uint64_t) ts1->tv_nsec;
}
 
static inline uint64_t get_time_nano(void)
{
    struct timespec ts;
    clock_gettime(CLOCK_REALTIME, &ts);
    return (uint64_t) ts.tv_sec * TENS_GIGA + (uint64_t) ts.tv_nsec;
}
 
#define EL_DBG 1
 
#if EL_DBG > 0 
//date as //20221212010203.123456789 with nanosecs
#ifndef MB_DBG
#define MB_DBG(fmt, ...) do {                                                           \
        struct timespec DBG_ts;                                                         \
        clock_gettime(CLOCK_REALTIME, &DBG_ts);                                         \
        struct tm DBG_loc_time;                                                         \
                                                                                        \
        localtime_r(&DBG_ts.tv_sec, &DBG_loc_time);                                     \
        char DBG_dt_str[16];                                                            \
        strftime(DBG_dt_str, 16, "%Y%m%d_%H%M%S", &DBG_loc_time);                       \
        dprintf(STDERR_FILENO, "%s.%09lu [%i]%s(%s):%u:\t" fmt, DBG_dt_str, DBG_ts.tv_nsec, gettid(), __FILE__, __FUNCTION__, __LINE__, ## __VA_ARGS__);   \
    } while (0)
 
#define MB_DBG_IMM(fmt, ...) do {                                                       \
        struct timespec DBG_IMM_ts;                                                         \
        clock_gettime(CLOCK_REALTIME, &DBG_IMM_ts);                                         \
        struct tm DBG_IMM_loc_time;                                                         \
                                                \
        localtime_r(&DBG_IMM_ts.tv_sec, &DBG_IMM_loc_time);                                 \
        char DBG_IMM_dt_str[16];                                                            \
        strftime(DBG_IMM_dt_str, 16, "%Y%m%d_%H%M%S", &DBG_IMM_loc_time);                   \
        int DBG_IMM_def_tty = open("/dev/tty", O_RDWR);                     \
        dprintf(DBG_IMM_def_tty, "%s.%09lu [%i]%s(%s):%u:\t" fmt, DBG_IMM_dt_str, DBG_IMM_ts.tv_nsec, gettid(), __FILE__, __FUNCTION__, __LINE__, ## __VA_ARGS__);   \
        close(DBG_IMM_def_tty);                                 \
    } while (0)
 
#define MB_DUMP_BUF_SZ 120
 
#define MB_DUMP_BUF(DATA_PTR, DATA_SZ, fmt, ...)                                                                \
    do {                                                                                                        \
        void *DUMP_BUF_st_addr = DATA_PTR;                                                         \
        int DUMP_BUF_i = 0, DUMP_BUF_j = 0, DUMP_BUF_buf_offs_char = 70;                                        \
        int DUMP_BUF_buf_offs = 0;                                                                              \
        char DUMP_BUF_t_buf[MB_DUMP_BUF_SZ];                                                                    \
        MB_DBG(fmt, ## __VA_ARGS__);                                                                            \
        MB_DBG("address   +  00 01 02 03 04 05 06 07  08 09 0a 0b 0c 0d 0e 0f         01234567 89abcdef\n");    \
        MB_DBG("-------------------------------------------------------------------   -----------------\n");    \
        while (DUMP_BUF_i < DATA_SZ) {                                                                          \
            memset(DUMP_BUF_t_buf, 0x20, MB_DUMP_BUF_SZ);                                                       \
            DUMP_BUF_buf_offs = 0;                                                                              \
            DUMP_BUF_j = 0;                                                                                     \
            DUMP_BUF_buf_offs_char = 70;                                                                        \
            DUMP_BUF_buf_offs += snprintf(&DUMP_BUF_t_buf[DUMP_BUF_buf_offs], MB_DUMP_BUF_SZ - DUMP_BUF_buf_offs , "%16p  ", DUMP_BUF_st_addr + DUMP_BUF_i);     \
            while (DUMP_BUF_i < DATA_SZ && DUMP_BUF_j < 16) {                                                                                                       \
                DUMP_BUF_buf_offs += snprintf(&DUMP_BUF_t_buf[DUMP_BUF_buf_offs], MB_DUMP_BUF_SZ - DUMP_BUF_buf_offs , " %02x", ((uint8_t*)DATA_PTR)[DUMP_BUF_i]);  \
                DUMP_BUF_t_buf[DUMP_BUF_buf_offs] = ' ';                                                                                                            \
                DUMP_BUF_t_buf[DUMP_BUF_buf_offs_char] = ((uint8_t*)DATA_PTR)[DUMP_BUF_i] < 0x20 || ((uint8_t*)DATA_PTR)[DUMP_BUF_i] > 0x7f? '.' : ((uint8_t*)DATA_PTR)[DUMP_BUF_i];  \
                DUMP_BUF_i++; DUMP_BUF_j++; DUMP_BUF_buf_offs_char++;                                                                              \
                if ((DUMP_BUF_j & 0x7) == 0) {                                                                   \
                    DUMP_BUF_buf_offs += snprintf(&DUMP_BUF_t_buf[DUMP_BUF_buf_offs], MB_DUMP_BUF_SZ - DUMP_BUF_buf_offs , " ");               \
                    DUMP_BUF_t_buf[DUMP_BUF_buf_offs] = ' ';                                                     \
                    DUMP_BUF_buf_offs_char++;                                                                    \
                }                                                                                                \
            }                                                                                                    \
            /*DUMP_BUF_buf_offs += snprintf(&DUMP_BUF_t_buf[DUMP_BUF_buf_offs], DUMP_BUF_SZ - DUMP_BUF_buf_offs , "\n");*/                      \
            /*DUMP_BUF_t_buf[DUMP_BUF_buf_offs++] = ' ';*/      \
            /*DUMP_BUF_t_buf[DUMP_BUF_buf_offs++] = ' ';*/      \
            /*DUMP_BUF_t_buf[DUMP_BUF_buf_offs++] = ' ';*/      \
            DUMP_BUF_t_buf[DUMP_BUF_buf_offs_char++] = '\n';    \
            DUMP_BUF_t_buf[DUMP_BUF_buf_offs_char++] = 0;       \
            MB_DBG("%s",DUMP_BUF_t_buf);                        \
            DUMP_BUF_buf_offs = 0;                              \
            DUMP_BUF_j = 0;                                     \
        }                                                                                               \
        MB_DBG("===================================================================\n");                \
    } while (0)
#endif /* #ifndef MB_DBG */
 
#else /* EL_DBG */
#   define MB_DBG(x, ...)
#   define MB_DUMP_BUF(DATA_PTR, DATA_SZ, fmt, ...)
#endif /* EL_DBG */
 
#define MB_DEBUG(DBG_FLAG,FMT, ...) if (DBG_FLAG) {     \
        MB_DBG(FMT, ## __VA_ARGS__);        \
    }
 
#ifndef _HAVE_STRLCPY   //strlcpy
#  define NO_HAVE_STRLCPY
size_t strlcpy(char *dst, const char *src, size_t dstSize);
#else 
#  undef NO_HAVE_STRLCPY
#endif
 
#define MALLOC_ARG(ARG_IS, ERR) if (ARG_IS == NULL) {ARG_IS = malloc(sizeof(*ARG_IS)); if (ARG_IS == NULL) { if (ERR != NULL) { *ERR = errno; } return NULL; } }
 
pthread_rwlockattr_t* el_get_rw_shared_attr(void);
 
int set_stdin_nowait_cr(int nowait);
void set_restore_stdin_cr(void);
 
typedef void (*el_ctrlc_call_t)(void *ar);
void el_set_ctrlc_exit(int ex);
void el_set_ctrlc_param(void *arg);
void el_set_ctrlc_call(el_ctrlc_call_t arg);
 
void termination_handler(int signum);
void termination_sigaction(int signum, siginfo_t *siginfo, void *param);
void set_termination_action(void);
 
int get_serial_stat(int fd);
void set_serial_stat(int fd, int serial);
int get_serial_dtr(int fd);
char* get_serial_dtr_s(int fd);
int get_serial_dsr(int fd);
char* get_serial_dsr_s(int fd);
int get_serial_rts(int fd);
char* get_serial_rts_s(int fd);
int get_serial_cts(int fd);
char* get_serial_cts_s(int fd);
 
void show_serial_stat(int fd);
 
void set_serial_stat_ln(int fd, int ln_bt, int val);
#define SET_CD(FD, VAL) set_serial_stat_ln(FD, TIOCM_CD, VAL)
#define SET_DTR(FD, VAL) set_serial_stat_ln(FD, TIOCM_DTR, VAL)
#define SET_DSR(FD, VAL) set_serial_stat_ln(FD, TIOCM_LE, VAL)
#define SET_RTS(FD, VAL) set_serial_stat_ln(FD, TIOCM_RTS, VAL)
#define SET_CTS(FD, VAL) set_serial_stat_ln(FD, TIOCM_CTS, VAL)
 
char** split_string(char *str, char delem, int *number);
int cnt_splited_strings(char **ss);
void dbg_string_list(char **string_list);
 
char* get_family_name(int family);
char* get_sock_type_name(int sock_type);
 
typedef enum _IP_TYPES_T
{
    IT_NOT_IP = AF_UNSPEC, IT_IPV4 = AF_INET, IT_IPV6 = AF_INET6
} IP_TYPES_T;
int validate_ip_addr(const char *ip_addr);
 
int test_connect(struct addrinfo *ai_ptr, int *err);
int test_bind(struct addrinfo *ai_ptr, int *err);
 
typedef union _sau_t
{
    struct sockaddr *sa;
    struct sockaddr_in *sin;
    struct sockaddr_in6 *sin6;
    struct sockaddr_storage *ss;
} sau_t;
 
typedef union _sau_static_t
{
    struct sockaddr sa;
    struct sockaddr_in sin;
    struct sockaddr_in6 sin6;
    struct sockaddr_storage ss;
} sau_static_t;
 
void show_sa(struct sockaddr *sa, char *buf, int buf_sz);
void show_ai_list(struct addrinfo *ai_list);
 
struct addrinfo* tcp_get_addr_info(char *addr, char *service, int family, int slave, int *err);    //struct addrinfo in #include <netdb.h>
 
int max_sockadddr_sz(void);
int conn_nonb(int fd, struct sockaddr *sa, int sa_len, uint64_t timeout, int *err);
 
int check_rs_speed(int sp);
 
//types and prototypes for configure TCP/RTU connection -------------------------
typedef enum _CONN_ROLE_T
{
    CR_NOTHING = 0, CR_MASTER, CR_SLAVE, CR_GATE, CR_NODE
} CONN_ROLE_T;
typedef enum _CONN_TYPE_T
{
    CT_TCP = 0, CT_RTU
} CONN_TYPE_T;
 
typedef struct _conn_param_t
{
    char *id;    
    CONN_ROLE_T cn_role;        
    int slave_id;
    CONN_TYPE_T cn_type;    
    union
    {
    struct
    {
        char *node;         
        char *serv;         
        IP_TYPES_T ip_type;    //IT_NOT_IP, IT_IPV4, IT_IPV6
        int family;
        int sa_len;
        sau_static_t sau;
    } tcp;
    struct
    {
        char *dev;          
        int speed;          
        //int err;
        int cd;     
        int dtr;        
        int dsr;        
        int cts;        
        int rts;        
    } rtu;
    };
} conn_params_t;
 
conn_params_t* parse_conn_params(char *params);
void free_conn_param(conn_params_t *c_p);
int fill_sockaddr_sinx(conn_params_t *c_p, int *err);
//types and prototypes for configure TCP/RTU connection ==============================
 
#ifndef ARGP_KEY_ARG
#define ARGP_KEY_ARG          0
#define ARGP_KEY_ARGS         0x1000006
#define ARGP_KEY_END          0x1000001
#define ARGP_KEY_NO_ARGS      0x1000002
#define ARGP_KEY_INIT         0x1000003
#define ARGP_KEY_FINI         0x1000007
#define ARGP_KEY_SUCCESS      0x1000004
#define ARGP_KEY_ERROR        0x1000005
#endif
 
const char* argp_std_key_name(int par);
 
int wait_read_fd(int fd, uint64_t timeout, int *err);
int wait_write_fd(int fd, uint64_t timeout, int *err);
 
int bytes_of_bits(int bits);
 
char* conn_role_name(int cr);
 
void setnonblocking(int sock);
void set_fd_cloexec(int fd);
int set_reuseaddr(int fd);
 
#define DATA_STR_SZ (64)
char* time64_to_str(uint64_t tm, char *buf);
 
const char* ps_error_text(int error);
 
int press_enter(char *msg, char *cmp_str);
 
int file_check_exist(char *fl_name);
int64_t file_fd_size(int fd);
int64_t file_size(const char *filename);
 
int parse_array(void *dst, void *src, int cnt, int sz);
 
#define ARGP_FIRST_LONG_OPT (0x100)
 
#define ARGP_PARAM_NOMEM(PCFG, VAR, MSG) \
    do { if (VAR == NULL) { \
        MB_DBG(" param error: " MSG); \
        PCFG->err = 1; \
        return ARGP_ERR_UNKNOWN; \
    }} while (0)
 
int pid_exist(pid_t pid);
 
void* el_compare_mem_prepare(void *mem, int mem_sz);
int el_compare_mem_do(void *mem, int mem_sz, void *copy);
#define COMPARE_MEM_PREPARE(MEMAS) el_compare_mem_prepare(MEMAS, sizeof(MEMAS))
#define COMPARE_MEM_DO(MEMAS, COPY) el_compare_mem_do(MEMAS, sizeof(*MEMAS), COPY)
 
long ps_pagesize(void);
 
typedef struct
{
    unsigned long size, resident, share, text, lib, data, dt;
} statm_t;
void read_off_memory_status(statm_t *result);
#define MB_MEMORY_STATUS() do { statm_t stm = { 0 }; read_off_memory_status(&stm); \
        MB_DBG("MemStat: virt %lu(%luk), resident %lu(%luk), share %lu(%luk), text %lu(%luk), lib %lu(%luk), data %lu(%luk), dt %lu(%luk)\n", \
            stm.size, stm.size/1024, stm.resident, stm.resident/1024, stm.share, stm.share/1024, stm.text, stm.text/1024,                 \
            stm.lib, stm.lib/1024, stm.data, stm.data/1024, stm.dt, stm.dt/1024); \
} while (0)
 
//MODBUS CRC16
uint16_t modbus_crc16(uint8_t *buffer, uint16_t buffer_length);
int ps_put_mem(char *file_name, void *mem_ptr, int mem_sz);
char* get_n_bytes(const char *str, int pos, int cnt);
 
char* find_free_name_num(char *name);
 
//ryba fish
//#pragma GCC diagnostic ignored "-Wpointer-to-int-cast"
//#pragma GCC diagnostic ignored "-Wformat="
//comment: do ignored "-Wpointer-to-int-cast"
//#pragma GCC diagnostic pop
 
#define CHECK_GET_OBJ_STRING(FROM, NAME, OBJ, TARGET, FIELD, EXIT)  \
{                               \
    struct json_object *OBJ;                    \
    if (!json_object_object_get_ex(FROM, NAME, &OBJ)) {     \
        MB_DBG("Cannot get '%s' object\n", NAME);       \
        goto EXIT;                      \
    }                               \
    if (json_object_get_type(OBJ) != json_type_string) {    \
        MB_DBG("Bad type of object '%s': '%s'\n", NAME, json_object_to_json_string(OBJ));   \
        goto EXIT;                      \
    }                               \
    TARGET->FIELD = strdup(json_object_get_string(OBJ));    \
    if (TARGET->FIELD == NULL) {                \
    goto EXIT;                      \
    }                               \
}
#define CHECK_GET_OBJ_STRING_NULL(FROM, NAME, OBJ, TARGET, FIELD, EXIT)     \
{                               \
    TARGET->FIELD = NULL;                   \
    struct json_object *OBJ;                    \
    if (json_object_object_get_ex(FROM, NAME, &OBJ)) {      \
    if (json_object_get_type(OBJ) != json_type_string) {    \
        MB_DBG("Bad type of object '%s': '%s'\n", NAME, json_object_to_json_string(OBJ));   \
        goto EXIT;                      \
    }                           \
    const char *t_str = json_object_get_string(OBJ);    \
    if (t_str == NULL) {                    \
        TARGET->FIELD = NULL;               \
    }                           \
    else {                          \
        TARGET->FIELD = strdup(t_str);          \
        if (TARGET->FIELD == NULL) {            \
        MB_DBG("Can't dup '%s'\n", NAME);       \
        goto EXIT;                  \
        }                           \
    }                           \
    }                               \
}
#define CHECK_GET_OBJ_INT(FROM, NAME, OBJ, TARGET, FIELD, EXIT)     \
{                               \
    struct json_object *OBJ;                    \
    if (!json_object_object_get_ex(FROM, NAME, &OBJ)) {     \
        MB_DBG("Cannot get '%s' object\n", NAME);       \
        goto EXIT;                      \
    }                               \
    if (json_object_get_type(OBJ) != json_type_int) {       \
        MB_DBG("Bad type of object '%s': '%s'\n", NAME, json_object_to_json_string(OBJ));   \
        goto EXIT;                      \
    }                               \
    TARGET->FIELD = json_object_get_int(OBJ);           \
}
 
char* mk_indent(int level);
void free_array(void **arr, int cnt);
 
char* build_msg_with_prev(const char *prev_msg, const char *format, ...);
 
#define BUILD_MSG_WITH_PREV(PREV, SHOW, FORMAT, ...) do {           \
    char *t_str = NULL;                             \
    t_str = build_msg_with_prev(PREV, FORMAT, ## __VA_ARGS__);          \
    if (SHOW) {                                 \
    MB_DBG("%s\n", t_str);                          \
    }                                       \
    if (PREV) free(PREV);                           \
    if (err_msg) {                              \
    *err_msg = t_str;                           \
    }                                       \
    else {                                  \
    free(t_str);                                \
    }                                       \
} while (0)
 
__END_DECLS
#endif /* EL_UTILS_H_ */