plugins.h

Go to the documentation of this file.

#ifndef __INCLUDE_IRCBOT_PLUGINS_H__
#define __INCLUDE_IRCBOT_PLUGINS_H__

#define IRCBOT_PLUGIN_VERSION                   0x0E
#define IRCBOT_VERSION_FLAG_DEBUG               0x00000001
#define IRCBOT_VERSION_FLAG_LITE                0x00000002
//#define IRCBOT_VERSION_FLAG_BASIC             0x00000004
//#define IRCBOT_VERSION_FLAG_FULL              0x00000008
//#define IRCBOT_VERSION_FLAG_STANDALONE        0x00000010

//#define _USE_32BIT_TIME_T
#ifndef NO_DSL
#include "../../Common/ircbot-config.h"
#include <drift/dsl.h>
#else
        // DSL types
        #if defined(WIN32) || defined(XBOX)
                #include <winsock2.h>
                #include <windows.h>
                typedef int socklen_t;
                typedef signed __int64 int64;
                typedef unsigned __int64 uint64;
                typedef signed __int32 int32;
                typedef unsigned __int32 uint32;
                typedef signed __int16 int16;
                typedef unsigned __int16 uint16;
                typedef signed __int8 int8;
                typedef unsigned __int8 uint8;
                #define DL_HANDLE HINSTANCE
                #define DSL_CC __stdcall
        #else
                #define VOID void
                #ifndef SOCKET
                        #define SOCKET int
                #endif
                #define BYTE unsigned char
                #ifndef HANDLE
                        #define HANDLE void *
                #endif
                #define DL_HANDLE HANDLE
                typedef signed long long int64;
                typedef unsigned long long uint64;
                typedef signed int int32;
                typedef unsigned int uint32;
                typedef signed short int16;
                typedef unsigned short uint16;
                typedef signed char int8;
                typedef unsigned char uint8;
                #define DSL_CC
        #endif
        typedef void * T_SOCKET;
        typedef void * DS_CONFIG_SECTION;
#endif
#define SQLITE3_DLL
#include <sqlite3.h>
#include <curl/curl.h>
//#include <tcl.h>
#include <string>
#include <map>
#include <iostream>
using namespace std;
#undef SendMessage

#if defined(WIN32)
        #define PLUGIN_EXPORT extern "C" __declspec(dllexport)
        #define DEPRECATE __declspec(deprecated)
#else
        #if defined(HAVE_VIS)
                #define PLUGIN_EXPORT extern "C" __attribute__ ((visibility("default")))
        #else
                #define PLUGIN_EXPORT extern "C"
        #endif
        #if (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 1))
                #define DEPRECATE  __attribute__((__deprecated__))
        #else
                #define DEPRECATE
        #endif /* __GNUC__ */
#endif
#define PLUGIN_EXPORT_NAME GetIRCBotPlugin
#define PLUGIN_EXPORT_FULL PLUGIN_EXPORT PLUGIN_PUBLIC * PLUGIN_EXPORT_NAME() { return &plugin; }

#define MAX_IRC_SERVERS 16
#define MAX_IRC_CHANNELS 16
#define MAX_PLUGINS 32
#define MAX_SOUND_SERVERS 32
#define MAX_HOSTMASKS 16
#define MAX_TIMERS 32

#include "common_messages.h"
#include "user_flags.h"
#include "../../Common/remote_protocol.h"

enum SS_TYPES {
        SS_TYPE_SHOUTCAST = 0x00, 
        SS_TYPE_SHOUTCAST2 = 0x01, 
        SS_TYPE_ICECAST = 0x02, 
        SS_TYPE_STEAMCAST       = 0x03,
        SS_TYPE_SP2P = 0x04
};

#define REF_TRACKING_DEPTH 16

#if !defined(DEBUG)
#define RefUser(x) (x)->ref(x)
#define UnrefUser(x) (x)->unref(x)
#else
#define RefUser(x) (x)->ref(x, nopathA(__FILE__), __LINE__)
#define UnrefUser(x) (x)->unref(x, nopathA(__FILE__), __LINE__)
#endif

struct USER {
        char Nick[128]; 
        char Pass[128]; 
        char LastHostmask[256]; 

        uint32 Flags; 
        bool Temporary; 
        time_t Created; 
        time_t Seen; 

        int32 NumHostmasks;
        char Hostmasks[MAX_HOSTMASKS][128]; 

#if !defined(DEBUG)

        void (*ref)(USER * user);
        void (*unref)(USER * user);
#else
        void (*ref)(USER *, const char * fn, int line);
        void (*unref)(USER *, const char * fn, int line);

        char * fn[REF_TRACKING_DEPTH];
        int line[REF_TRACKING_DEPTH];
#endif
        uint32 ref_cnt; 
};

struct USER_PRESENCE {
        USER * User; 

        /* Some duplication of data here, but necessary for cases where User == NULL and for times when a persons nick != their username */
        const char * Nick; 
        const char * Hostmask; 
        uint32 Flags; 
        int NetNo; 
        const char * Channel; 
                 
        const char * Desc; 

        union {
                T_SOCKET * Sock; 
                void * Ptr1; 
        };

        typedef bool (*userPresSendFunc)(USER_PRESENCE *, const char *); 
        userPresSendFunc std_reply; 
        userPresSendFunc send_chan; 
        userPresSendFunc send_chan_notice; 
        userPresSendFunc send_msg; 
        userPresSendFunc send_notice; 

#if !defined(DEBUG)

        void (*ref)(USER_PRESENCE * pres);
        void (*unref)(USER_PRESENCE * pres);
#else
        void (*ref)(USER_PRESENCE *, const char * fn, int line);
        void (*unref)(USER_PRESENCE *, const char * fn, int line);
#endif
        uint32 ref_cnt; 
};

#ifndef SWIG

typedef int (*CommandProcType)(const char * command, const char * parms, USER_PRESENCE * ut, uint32 type); 

struct COMMAND_ACL {
        uint32 flags_all; 
        uint32 flags_any; 
        uint32 flags_not; 
};

struct COMMAND {
        const char * command; 
#if defined(OLD_COMTRACK)
        COMMAND *Prev,*Next;
#endif
        const char * desc; 
        CommandProcType help_proc; 
        union {
                const char * action; 
                CommandProcType proc; 
        };
        uint32 proc_type; 
        COMMAND_ACL acl; 
        uint32 mask; 
        int plugin; 
        uint32 ref_cnt; 
};
#endif

#define COMMAND_ACTION 0x00
#define COMMAND_PROC 0x01
#define CM_ALLOW_IRC_PUBLIC                     0x00000001 
#define CM_ALLOW_IRC_PRIVATE            0x00000002 
#define CM_ALLOW_CONSOLE_PUBLIC         0x00000004 
#define CM_ALLOW_CONSOLE_PRIVATE        0x00000008 
#define CM_FLAG_FROM_TEXT                       0x20000000 
#define CM_FLAG_SLOW                            0x10000000 
#define CM_FLAG_ASYNC                           0x40000000 
#define CM_FLAG_NOHANG                          0x80000000 
#define CM_NO_FLAGS(x) (x & 0x0000000F)

#define CM_ALLOW_ALL_PUBLIC                     CM_ALLOW_IRC_PUBLIC|CM_ALLOW_CONSOLE_PUBLIC
#define CM_ALLOW_ALL_PRIVATE                    CM_ALLOW_IRC_PRIVATE|CM_ALLOW_CONSOLE_PRIVATE
#define CM_ALLOW_ALL                                    CM_ALLOW_ALL_PUBLIC|CM_ALLOW_ALL_PRIVATE

#ifndef SWIG

struct REMOTE_HEADER {
        REMOTE_COMMANDS cmd; 
        uint32 datalen; 
};
#endif

#ifdef SWIG
%immutable;
#endif

typedef struct {
        char host[128];
        char mount[128];
        char admin_pass[128];
        int32 port, streamid;
        SS_TYPES type; 
        bool has_source; 
} SOUND_SERVER;

typedef struct {
        bool online; 
        bool title_changed; 
        int bitrate;
        int listeners;
        int peak;
        int maxusers;

        char curdj[128]; 
        char lastdj[128]; 
        char cursong[512]; 
} STATS;

struct SONG_RATING {
        uint32 Rating; 
        uint32 Votes; 
};

#define MAX_FIND_RESULTS 100

struct FIND_RESULT {
        char * fn; 
        uint32 id; 
};
struct FIND_RESULTS {
        char query[128];
        int start;

        FIND_RESULT songs[MAX_FIND_RESULTS];
        int num_songs;
        bool have_more;

        int plugin;
        void (*free)(FIND_RESULTS * res); 
};
typedef void (*find_finish_type)(USER_PRESENCE * ut, FIND_RESULTS * qRes, int max);
struct REQUEST_INTERFACE {
        void (*find)(const char * fn, int max_results, int start, USER_PRESENCE * ut, find_finish_type find_finish); 
        bool (*request_from_find)(USER_PRESENCE * pres, FIND_RESULT * res, char * reply, size_t replySize); 
        bool (*request)(USER_PRESENCE * pres, const char * txt, char * reply, size_t replySize); 
};

#ifdef SWIG
%mutable;
#endif

#ifndef SWIG
#ifndef DOXYGEN_SKIP

#endif // DOXYGEN_SKIP

typedef struct {
        int (*replace)(char * str, int32 bufsize, const char *findstr, const char * replstr);
        char * (*trim)(char *buf, const char * strtrim); 
        char * (*duration)(uint32 num, char * buf); 
        int32 (*decode_duration)(const char * buf); 
        int (*wildcmp)(const char *wild, const char *string); 
        int (*wildicmp)(const char *wild, const char *string); 
        bool (*get_range)(const char * buf, int32 * imin, int32 * imax); 
} API_textfunc;

typedef struct {
        COMMAND * (*FindCommand)(const char * command); 
        COMMAND * (*RegisterCommand_Action)(int pluginnum, const char * command, const COMMAND_ACL * acl, uint32 mask, const char * action, const char * desc); 

        COMMAND * (*RegisterCommand_Proc)(int pluginnum, const char * command, const COMMAND_ACL * acl, uint32 mask, CommandProcType proc, const char * desc);
        void (*UnregisterCommandsByPlugin)(int pluginnum); 
        void (*UnregisterCommandByName)(const char * command); 
        void (*UnregisterCommand)(COMMAND * command); 

        char (*PrimaryCommandPrefix)(); 
        bool (*IsCommandPrefix)(char ch); 
        COMMAND_ACL * (*FillACL)(COMMAND_ACL * acl, uint32 flags_have_all, uint32 flags_have_any, uint32 flags_not); 
        COMMAND_ACL (*MakeACL)(uint32 flags_have_all, uint32 flags_have_any, uint32 flags_not); 

        int (*ExecuteProc)(COMMAND * com, const char * parms, USER_PRESENCE * ut, uint32 type); 
        void (*RegisterCommandHook)(const char * command, CommandProcType hook_func); 
        void (*UnregisterCommandHook)(const char * command, CommandProcType hook_func); 
} API_commands;

#ifndef DOXYGEN_SKIP
// case-independent (ci) string less_than
// returns true if s1 < s2
struct ci_less : binary_function<string, string, bool> {

  // case-independent (ci) compare_less binary function
  struct nocase_compare : public binary_function<unsigned char,unsigned char,bool> 
    {
    bool operator() (const unsigned char& c1, const unsigned char& c2) const 
      { return tolower (c1) < tolower (c2); }
    };

  bool operator() (const string & s1, const string & s2) const
    {
  
    return lexicographical_compare 
          (s1.begin (), s1.end (),   // source range
           s2.begin (), s2.end (),   // dest range
                nocase_compare ());  // comparison
    }
}; // end of ci_less

typedef std::map<std::string, std::string, ci_less> sql_row;
typedef std::map<int, sql_row> sql_rows;
#endif /* DOXYGEN_SKIP */

typedef struct {
        sqlite3 * (*GetHandle)(); 
        int (*Query)(const char * query, sqlite3_callback cb, void * parm, char ** error);
        void (*Free)(char * ptr);
        int (*GetTable)(const char * query, char ***resultp, int *nrow, int *ncolumn, char **errmsg);
        const char * (*GetTableEntry)(int row, int col, char **result, int nrow, int ncol);
        void (*FreeTable)(char **result);
        char * (*MPrintf)(const char* fmt,...); 
        void (*Lock)(); 
        void (*Release)(); 
        int64 (*InsertID)(); 
} API_db;

typedef struct {
        CURL * (*easy_init)(void);
        CURLcode (*easy_setopt)(CURL *curl, CURLoption option, ...);
        CURLcode (*easy_perform)(CURL *curl);
        void (*easy_cleanup)(CURL *curl);
        const char * (*easy_strerror)(CURLcode);
        CURLcode (*easy_getinfo)(CURL *curl, CURLINFO info, ...);

        CURLM * (*multi_init)(void);
        CURLMcode (*multi_add_handle)(CURLM *multi_handle, CURL *curl_handle);
        CURLMcode (*multi_remove_handle)(CURLM *multi_handle, CURL *curl_handle);
        CURLMcode (*multi_perform)(CURLM *multi_handle, int *running_handles);
        CURLMcode (*multi_cleanup)(CURLM *multi_handle);
        CURLMsg * (*multi_info_read)(CURLM *multi_handle, int *msgs_in_queue);
        const char * (*multi_strerror)(CURLMcode);

        CURLFORMcode (*formadd)(struct curl_httppost **httppost, struct curl_httppost **last_post, ...);
        void (*formfree)(struct curl_httppost *form);

        struct curl_slist * (*slist_append)(struct curl_slist *, const char *);
        void (*slist_free_all)(struct curl_slist *);

        char * (*escape)(const char *string, int length);
        char * (*unescape)(const char *string, int length);

        void (*free)(void *p);
} API_curl;

typedef struct {
        void * (DSL_CC * alloc)(uint32 lSize, const char * file, int line);
        void * (DSL_CC *realloc)(void * ptr, uint32 lSize, const char * file, int line);
        char * (DSL_CC *strdup)(const char * ptr, const char * file, int line);
        wchar_t * (DSL_CC *wcsdup)(const wchar_t * ptr, const char * file, int line);
        void (DSL_CC *free)(void * ptr, const char * file, int line);
        char * (DSL_CC *mprintf)(const char * ptr, ...); 
} API_memory;

typedef struct {
        bool (*is_nick_in_chan)(int netno, const char * chan, const char * nick);
        bool (*is_bot_in_chan)(int netno, const char * chan);
        int (*num_nicks_in_chan)(int netno, const char * chan);
        bool (*get_nick_in_chan)(int netno, const char * chan, int num, char * nick, int nickSize);
} API_ial;


typedef bool (*EnumUsersByLastHostmaskCallback)(USER * user, void * ptr);

typedef struct {
        USER * (*GetUser)(const char * hostmask);
        USER * (*GetUserByNick)(const char * nick);
        bool (*IsValidUserName)(const char * nick); 
        uint32 (*GetUserCount)(); 

        void (*EnumUsersByLastHostmask)(EnumUsersByLastHostmaskCallback callback, const char * hostmask, void * ptr);

        uint32 (*GetUserFlags)(const char * hostmask); 
        USER * (*AddUser)(const char * nick, const char * pass, uint32 flags, bool temp);
        void (*SetUserFlags)(USER * user, uint32 flags); 
        void (*AddUserFlags)(USER * user, uint32 flags); 
        void (*DelUserFlags)(USER * user, uint32 flags); 

        uint32 (*GetDefaultFlags)(); 

        bool (*uflag_have_any_of)(uint32 flags, uint32 wanted);
        int (*uflag_compare)(uint32 flags1, uint32 flags2);
        void (*uflag_to_string)(uint32 flags, char * buf, size_t bufSize);
        uint32 (*string_to_uflag)(const char * buf, uint32 cur);

        bool (*Mask)(const char * hostmask, char * msgbuf, size_t bufSize, int type);

        uint32 (*GetLevelFlags)(int level); 
        void (*SetLevelFlags)(int level, uint32  flags); 
} API_user;

typedef struct {
        DS_CONFIG_SECTION * (*GetConfigSection)(DS_CONFIG_SECTION * parent, const char * name);
        bool (*GetConfigSectionValueBuf)(DS_CONFIG_SECTION * section, const char * name, char * buf, size_t bufSize);
        char * (*GetConfigSectionValue)(DS_CONFIG_SECTION * section, const char * name);
        long (*GetConfigSectionLong)(DS_CONFIG_SECTION * section, const char * name);
        double (*GetConfigSectionFloat)(DS_CONFIG_SECTION * section, const char * name);
        bool (*IsConfigSectionValue)(DS_CONFIG_SECTION * section, const char * name);
} API_config;

typedef struct {
        uint32 yp_id;
        char key[68];
} YP_HANDLE;

typedef struct {
        const char * source_name;
        const char * mime_type;
        const char * cur_playing;
        const char * genre;
} YP_CREATE_INFO;

typedef struct {
        bool (*AddToYP)(YP_HANDLE * yp, SOUND_SERVER * sc, YP_CREATE_INFO * ypinfo);
        int (*TouchYP)(YP_HANDLE * yp, const char * cur_playing);
        void (*DelFromYP)(YP_HANDLE * yp);
} API_yp;

enum {
        PRIORITY_LOWEST                 =  0,
        PRIORITY_SPAM                   =  1,
        PRIORITY_DEFAULT                = 10,
        PRIORITY_INTERACTIVE    = 60,
        PRIORITY_IMMEDIATE              = 99
};

typedef struct {
        bool (*LogToChan)(const char * buf); 

        int (*SendIRC_Priority)(int32 netno, const char * buf, int32 datalen, uint8 priority);
        int (*SendIRC_Delay)(int32 netno, const char * buf, int32 datalen, uint8 priority, uint32 delay);
        int DEPRECATE (*SendSock_Priority)(T_SOCKET * sock, const char * buf, int32 datalen, uint8 priority, uint32 delay);
        void DEPRECATE (*ClearSockEntries)(T_SOCKET * sock); 
        // ^- I don't think anything uses these 2 anymore in plugins, but they could potentially be used in command handlers as long as you verify they are IRC connections.

        bool (*GetDoSpam)(); 
        void (*SetDoSpam)(bool dospam); 
        void (*SetDoSpamChannel)(bool dospam, int netno, const char * chan); 
        void (*SetDoOnJoin)(bool doonjoin);
        void (*SetDoOnJoinChannel)(bool doonjoin, int netno, const char * chan);

        const char *(*GetCurrentNick)(int32 net);
        const char *(*GetDefaultNick)(int32 net);
        int (*NumNetworks)(); 
        bool (*IsNetworkReady)(int32 num); 
} API_irc;

enum REQUEST_MODES {
        REQ_MODE_OFF            = 0,
        REQ_MODE_DJ_NOREQ       = 1,
        REQ_MODE_NORMAL         = 2,
        REQ_MODE_REMOTE         = 3,
        REQ_MODE_HOOKED         = 4
};
#define REQUESTS_ON(x) (x >= REQ_MODE_NORMAL)
#define HAVE_DJ(x) (x >= REQ_MODE_DJ_NOREQ)

typedef struct {
        int (*GetSSInfo)(int32 ssnum, SOUND_SERVER * ss);
        STATS * (*GetStreamInfo)(); 
        REQUEST_MODES (*GetRequestMode)();
        void (*EnableRequests)(bool activate); 
        void (*EnableRequestsHooked)(REQUEST_INTERFACE *); 

        bool (*AreRatingsEnabled)();
        int (*GetMaxRating)();
        void (*RateSongByID)(uint32 id, const char * nick, uint32 rating); 
        void (*RateSong)(const char * song, const char * nick, uint32 rating);
        void (*GetSongRatingByID)(uint32 id, SONG_RATING * r); 
        void (*GetSongRating)(const char * song, SONG_RATING * r);
} API_ss;

struct BOTAPI;
typedef struct {
        unsigned char plugin_ver; 

        char * guid; 
        char * plugin_name_short; 
        char * plugin_name_long; 
        char * plugin_author; 

        int (*init)(int num, BOTAPI * BotAPI);

        void (*quit)();

        int (*message)(unsigned int msg, char * data, int datalen);

        int (*on_text)(USER_PRESENCE * ut, const char * msg);

        int (*on_notice)(USER_PRESENCE * ut, const char * msg);

        int (*raw)(int netno, char * msg);

        int (*remote)(USER_PRESENCE * ut, unsigned char cliversion, REMOTE_HEADER * head, char * data);

        //filled in by IRCBot for you
        DL_HANDLE hInstance;

        //for use only by IRCBot
        void * private_struct;
} PLUGIN_PUBLIC;

struct BOTAPI {
        uint32 (*GetVersion)(); 
        const char * (*GetVersionString)(); 
        const char * (*GetIP)(); 
        const char * platform; 
#if defined(WIN32)
        HWND hWnd; 
#else
        void * unused;
#endif

        const char * (*GetBasePath)(); 
        char * (*GetBindIP)(char * buf, size_t bufSize); 
        int (*get_argc)(); 
        const char * (*get_argv)(int i); 
        int64 (*get_cycles)(); 
        void (*ib_printf2)(int pluginnum, const char * fmt, ...); 
        void (*Rehash)(const char * fn); 

        int (*NumPlugins)(); 
        PLUGIN_PUBLIC * (*GetPlugin)(int32 plugnum); 
        bool (*LoadPlugin)(const char * fn); 

        bool (*LoadMessage)(const char * name, char * msgbuf, int32 bufSize);
        void (*ProcText)(char * text, int32 bufSize);
        void (*SetCustomVar)(const char * name, const char * val);
        void (*DeleteCustomVar)(const char * name);
        void (*BroadcastMsg)(USER_PRESENCE * ut, const char * buf); 

        const char * (*GetLangString)(const char * str);

        void (*safe_sleep_seconds)(int32 sleepfor); 
        void (*safe_sleep_milli)(int32 sleepfor); 
        uint32 (*genrand_int32)(); 
        int (*get_rand)(int min, int max); 

        void (*SendRemoteReply)(T_SOCKET * socket, REMOTE_HEADER * rHead, const char * data); 
        int (*SendMessage)(int toplug, uint32 MsgID, char * data, int32 datalen); 

        API_irc                 * irc; 
        API_ial                 * ial; 
        API_textfunc    * textfunc; 
        API_commands    * commands; 
        API_user                * user; 
        API_config              * config; 
        API_db                  * db; 
        API_curl                * curl; 
        API_memory              * mem; 

#if !defined(IRCBOT_LITE)
        API_yp                  * yp; 
        API_ss                  * ss; 
#else
        void * unused_lite[2];
#endif
};

#define SendIRC(x,y,z) SendIRC_Priority(x,y,z,PRIORITY_DEFAULT)

#define SendSock(x,y,z) SendSock_Priority(x,y,z,PRIORITY_DEFAULT)

#if !defined(__INCLUDE_IRCBOT_MAIN_H__)
        #define BOTAPI_DEF BOTAPI
        #define API_SS SOUND_SERVER
        #if defined(_ADJ_PLUGIN_H_) && !defined(_AUTODJ_)
                #define _(x) api->botapi->GetLangString(x)
                #define ib_printf(x, ...) ib_printf2(api->GetPluginNum(), x, ##__VA_ARGS__)
        #elif defined(_SDJ_PLUGIN_H_) && !defined(_SIMPLEDJ_)
                #define _(x) api->botapi->GetLangString(x)
                #define ib_printf(x, ...) ib_printf2(api->GetPluginNum(), x, ##__VA_ARGS__)
        #else
                #define _(x) api->GetLangString(x)
                #define ib_printf(x, ...) ib_printf2(pluginnum, x, ##__VA_ARGS__)
        #endif

        /*
        #define zmalloc(x) api->mem->alloc(x,__FILE__,__LINE__)
        #define zrealloc(x,y) api->mem->realloc(x,y,__FILE__,__LINE__)
        #define zfree(x) api->mem->free(x,__FILE__,__LINE__)
        #define zstrdup(x) api->mem->strdup(x,__FILE__,__LINE__)
        #define znew(x) (x *)api->mem->alloc(sizeof(x), __FILE__, __LINE__)
        #define zfreenn(ptr) if (ptr) { api->mem->free(ptr, __FILE__, __LINE__); }
        #define zmprintf api->mem->mprintf
        */
#endif

#endif // SWIG

#endif // __INCLUDE_IRCBOT_PLUGINS_H__