Annotation of mqtt/src/dl.c, revision 1.2.2.1

1.2       misho       1: #include "global.h"
                      2: #include "rtlm.h"
                      3: 
                      4: 
                      5: static void *acc_rtlm, *pub_rtlm, *log_rtlm;
                      6: 
                      7: struct tagCallbacks call;
                      8: 
                      9: 
                     10: /*
                     11:  * mqttLog() Log message to syslog
                     12:  *
                     13:  * @fmt = format string
                     14:  * @... = argument list
                     15:  * return: none
                     16:  */
                     17: void
                     18: mqttLog(const char *fmt, ...)
                     19: {
                     20:        va_list lst;
                     21: 
                     22:        va_start(lst, fmt);
                     23:        vsyslog(LOG_ERR, fmt, lst);
                     24:        va_end(lst);
                     25: }
                     26: 
                     27: void *
                     28: mqttLoadRTLM(sl_config *cfg, int modtype)
                     29: {
                     30:        const char *str, *attr;
                     31:        void *rtlm = NULL;
                     32:        void *(*mqttOpenRTLM)(sl_config *);
                     33:        void (*mqttCloseRTLM)(void *);
                     34: 
                     35:        if (!cfg)
                     36:                return NULL;
                     37: 
                     38:        switch (modtype) {
                     39:                case 0:
                     40:                        attr = "acc_file";
                     41:                        break;
                     42:                case 1:
                     43:                        attr = "pub_file";
                     44:                        break;
                     45:                default:
                     46:                        attr = "log_file";
                     47:                        break;
                     48:        }
                     49: 
                     50:        str = (const char*) CFG(cfg_GetAttribute(cfg, CFG("mqttd"), CFG(attr)));
                     51:        if (!str) {
                     52:                mqttLog("Error:: RTL module not found\n");
                     53:                return NULL;
                     54:        }
                     55: 
                     56:        rtlm = dlopen(str, RTLD_LAZY);
                     57:        if (!rtlm) {
                     58:                mqttLog("Error:: RTL module %s not found %s\n", str, dlerror());
                     59:                return NULL;
                     60:        }
                     61: 
                     62:        mqttOpenRTLM = dlsym(rtlm, "mqtt_rtlm_open");
                     63:        if (!mqttOpenRTLM) {
                     64:                mqttLog("Error:: Can't found mqtt_db_open call\n");
                     65:                dlclose(rtlm);
                     66:                return NULL;
                     67:        }
                     68:        mqttCloseRTLM = dlsym(rtlm, "mqtt_rtlm_close");
                     69:        if (!mqttCloseRTLM) {
                     70:                mqttLog("Error:: Can't found mqtt_db_close call\n");
                     71:                dlclose(rtlm);
                     72:                return NULL;
                     73:        }
                     74: 
                     75:        switch (modtype) {
                     76:                case 0:
                     77:                        acc_rtlm = rtlm;
                     78:                        call.OpenACC = mqttOpenRTLM;
                     79:                        call.CloseACC = mqttCloseRTLM;
                     80:                        call.LoginACC = dlsym(rtlm, "mqtt_rtlm_login");
                     81:                        if (!call.LoginACC) {
                     82:                                mqttLog("Error:: incorrect module ...\n");
                     83:                                dlclose(rtlm);
                     84:                                return NULL;
                     85:                        }
                     86:                        break;
                     87:                case 1:
                     88:                        pub_rtlm = rtlm;
                     89:                        call.OpenPUB = mqttOpenRTLM;
                     90:                        call.ClosePUB = mqttCloseRTLM;
                     91:                        call.InitSessPUB = dlsym(rtlm, "mqtt_rtlm_init_session");
                     92:                        call.FiniSessPUB = dlsym(rtlm, "mqtt_rtlm_fini_session");
                     93:                        call.ChkSessPUB = dlsym(rtlm, "mqtt_rtlm_chk_session");
1.2.2.1 ! misho      94:                        call.WritePUB_topic = dlsym(rtlm, "mqtt_rtlm_write_topic");
        !            95:                        call.ReadPUB_topic = dlsym(rtlm, "mqtt_rtlm_read_topic");
        !            96:                        call.DeletePUB_topic = dlsym(rtlm, "mqtt_rtlm_delete_topic");
        !            97:                        call.WritePUB_subscribe = dlsym(rtlm, "mqtt_rtlm_write_subscribe");
        !            98:                        call.ReadPUB_subscribe = dlsym(rtlm, "mqtt_rtlm_read_subscribe");
        !            99:                        call.DeletePUB_subscribe = dlsym(rtlm, "mqtt_rtlm_delete_subscribe");
1.2       misho     100:                        if (!call.InitSessPUB || !call.FiniSessPUB || !call.ChkSessPUB || 
1.2.2.1 ! misho     101:                                        !call.WritePUB_topic || !call.ReadPUB_topic || 
        !           102:                                        !call.DeletePUB_topic) {
1.2       misho     103:                                mqttLog("Error:: incorrect module ...\n");
                    104:                                dlclose(rtlm);
                    105:                                return NULL;
                    106:                        }
                    107:                        break;
                    108:                default:
                    109:                        log_rtlm = rtlm;
                    110:                        call.OpenLOG = mqttOpenRTLM;
                    111:                        call.CloseLOG = mqttCloseRTLM;
                    112:                        call.LOG = dlsym(rtlm, "mqtt_rtlm_logger");
                    113:                        if (!call.LOG) {
                    114:                                mqttLog("Error:: incorrect module ...\n");
                    115:                                dlclose(rtlm);
                    116:                                return NULL;
                    117:                        }
                    118:                        break;
                    119:        }
                    120: 
                    121:        return rtlm;
                    122: }
                    123: 
                    124: void
                    125: mqttUnloadRTLM(int modtype)
                    126: {
                    127:        switch (modtype) {
                    128:                case 0:
                    129:                        dlclose(acc_rtlm);
                    130:                        break;
                    131:                case 1:
                    132:                        dlclose(pub_rtlm);
                    133:                        break;
                    134:                default:
                    135:                        dlclose(log_rtlm);
                    136:                        break;
                    137:        }
                    138: }
                    139: 
                    140: inline int
                    141: mqttMkDir(sl_config *cfg)
                    142: {
                    143:        const char *str;
                    144: 
                    145:        if (!cfg)
                    146:                return -1;
                    147: 
                    148:        str = (const char*) cfg_GetAttribute(cfg, CFG("mqttd"), CFG("statedir"));
                    149:        if (!str)
                    150:                return -1;
                    151: 
                    152:        if (mkdir(str, 0600) == -1 && errno != EEXIST)
                    153:                return -1;
                    154: 
                    155:        return 0;
                    156: }

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>