bayonne.h

Go to the documentation of this file.

// Copyright (C) 2005 Open Source Telecom Corp.
//  
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software 
// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
// 
// As a special exception, you may use this file as part of a free software
// library without restriction.  Specifically, if other files instantiate
// templates or use macros or inline functions from this file, or you compile
// this file and link it with other files to produce an executable, this
// file does not by itself cause the resulting executable to be covered by
// the GNU General Public License.  This exception does not however
// invalidate any other reasons why the executable file might be covered by
// the GNU General Public License.
//
// This exception applies only to the code released under the name GNU
// ccScript.  If you copy code from other releases into a copy of GNU
// ccScript, as the General Public License permits, the exception does
// not apply to the code that you add in this way.  To avoid misleading
// anyone as to the status of such modified files, you must delete
// this exception notice from them.
//
// If you write modifications of your own for GNU ccScript, it is your choice
// whether to permit this exception to apply to your modifications.
// If you do not wish that, delete this exception notice.
//

#ifndef CCXX_BAYONNE_H_
#define CCXX_BAYONNE_H_

#ifndef CCXX_SCRIPT3_H_
#include <cc++/script3.h>
#endif

#ifndef CCXX_CCAUDIO2_H_
#include <cc++/audio2.h>
#endif

#ifndef CCXX_SOCKET_H_
#include <cc++/socket.h>
#endif

#define BAYONNE_RELEASE 1               // release check sequence
#define NO_TIMESLOT     0xffff
#define MAX_DTMF        32
#define MAX_LIST        256
#define MAX_LIBINPUT    256
#define MAX_PATHNAME    256
#define MIN_AUDIOFEED   (120 * 8)       // 120 millisecond starting
#define MAX_AUDIOFEED   (600 * 8)       // 600 millisecond buffer
#define RPC_MAX_PARAMS  96

#ifdef  WIN32
#define PFD_INVALID     INVALID_HANDLE_VALUE
#else
#define PFD_INVALID     -1
#endif

#if SCRIPT_RIPPLE_LEVEL < 2
#error "ccscript 3 0.8.0 or later required"
#endif

#ifdef  DEBUG
#define SLOG_DEBUG(x, ...)      slog.debug(x, __VA_ARGS__)
#else
#define SLOG_DEBUG(x, ...)
#endif

namespace ost {

class __EXPORT BayonneMsgport;
class __EXPORT BayonneDriver;
class __EXPORT BayonneSession;
class __EXPORT BayonneSpan;
class __EXPORT BayonneService;
class __EXPORT BayonneTranslator;
class __EXPORT BayonneRPC;
class __EXPORT ScriptEngine;

class __EXPORT StreamingBuffer : public Audio
{
private:
        static StreamingBuffer *first;
        StreamingBuffer *next;
        const char *id;
        Rate rate;

protected:
        unsigned long position, count;
        Linear data;

        void cleanup();

        StreamingBuffer(const char *id, timeout_t size = 600, Rate rate = rate8khz);
        virtual ~StreamingBuffer();

    virtual Linear putBuffer(timeout_t duration);
        virtual void clearBuffer(timeout_t duration);

public:
        static StreamingBuffer *get(const char *id, Rate rate);

        virtual bool isActive(void);

        virtual unsigned long getPosition(timeout_t framing);

        virtual Linear getBuffer(unsigned long *mark, timeout_t duration);
};
        

class __EXPORT StaticKeydata : public Keydata
{
public:
        StaticKeydata(const char *path, Keydata::Define *defkeys = NULL, const char *homepath = NULL);

        inline const char *getString(const char *id)
                {return getLast(id);};

        inline long getValue(const char *id)
                {return getLong(id);};

        inline bool getBoolean(const char *id)
                {return getBool(id);};
};

class __EXPORT DynamicKeydata : public ThreadLock
{
private:
        friend class __EXPORT BayonneConfig;
        friend class __EXPORT ReconfigKeydata;
        static DynamicKeydata *firstConfig;
        DynamicKeydata *nextConfig;
        const char *keypath;
        const char *homepath;
        Keydata *keys;
        Keydata::Define *defkeys;
        void loadConfig(void);

protected:
        virtual void updateConfig(Keydata *keydata);

public:
        DynamicKeydata(const char *keypath, Keydata::Define *def = NULL, const char *homepath = NULL);

        const char *getString(const char *key, char *buf, size_t size);
        long getValue(const char *key);
        bool isKey(const char *key);
        bool getBoolean(const char *key);

        static void reload(void);
};

class __EXPORT ReconfigKeydata : public StaticKeydata, protected DynamicKeydata
{
protected:
        // use only in updateConfig method...
        const char *updatedString(const char *id);
        long updatedValue(const char *id);
        timeout_t updatedSecTimer(const char *id);
        timeout_t updatedMsecTimer(const char *id);
        bool updatedBoolean(const char *id);

public:
        inline const char *getInitial(const char *id)
                {return StaticKeydata::getString(id);};
        inline void setInitial(const char *id, const char *val)
                {StaticKeydata::setValue(id, val);};

        ReconfigKeydata(const char *keypath, Keydata::Define *def = NULL);

        const char *getString(const char *key, char *buf, size_t size);
        timeout_t getSecTimer(const char *key);
        timeout_t getMsecTimer(const char *key);
        long getValue(const char *key);
        bool isKey(const char *key);
        bool getBoolean(const char *key);
};
          
class __EXPORT Bayonne : public Script
{
private:
        static SOCKET trap_so4;
        static unsigned trap_count4;
        static struct sockaddr_in trap_addr4[8];

#ifdef  CCXX_IPV6
        static SOCKET trap_so6;
        static unsigned trap_count6;
        static struct sockaddr_in6 trap_addr6[8];
#endif

public:
        static char dtmf_keymap[256];

        static void snmptrap(unsigned id, const char *descr = NULL);

#ifdef  WIN32
        typedef WORD    timeslot_t;
        typedef DWORD   rpcint_t;
#else
        typedef uint16_t timeslot_t;
        typedef int32_t rpcint_t;
#endif
        typedef rpcint_t rpcbool_t;

protected:
        static BayonneSession **timeslots;
        static ScriptImage **localimages;
        static char *status;
        static ScriptCommand *server;
        static unsigned ts_trk;
        static unsigned ts_ext;
        static timeslot_t ts_limit;
        static timeslot_t ts_count;
        static timeslot_t ts_used;
        static std::ostream *logging;
        static const char *path_prompts;
        static const char *path_tmpfs;
        static const char *path_tmp;
        static unsigned idle_count;
        static unsigned idle_limit;
        static bool shutdown_flag;
        static char sla[64];
        static time_t start_time;
        static time_t reload_time;

public:
        static timeout_t step_timer;
        static timeout_t reset_timer;
        static timeout_t exec_timer;
        static unsigned compile_count;
        static volatile bool image_loaded;

        static BayonneTranslator *init_translator;
        static const char *init_voicelib;
        static const char *trap_community;
        static AtomicCounter libexec_count;

        typedef enum
        {
                IF_PSTN,
                IF_SPAN,
                IF_ISDN,
                IF_SS7,
                IF_INET,
                IF_NONE,
                IF_POTS=IF_PSTN
        }       interface_t;

        typedef enum
        {
                NONE,           /* idle */
                INCOMING,       /* inbound call */
                OUTGOING,       /* outbound call */
                PICKUP,         /* station pickup */
                FORWARDED,      /* inbound forwarded call */
                RECALL,         /* inbound hold recall */
                DIRECT,         /* node/endpoint direct */
                RINGING,        /* ringing incoming join */
                VIRTUAL         /* virtual channel driver */
        }       calltype_t;

        typedef enum
        {
                BR_TDM,
                BR_INET,
                BR_SOFT,
                BR_GATE,
                BR_NONE
        }       bridge_t;

        typedef enum
        {
                STATE_INITIAL = 0,
                STATE_IDLE,
                STATE_RESET,
                STATE_RELEASE,
                STATE_BUSY,
                STATE_DOWN,
                STATE_RING,
                STATE_PICKUP,
                STATE_SEIZE,
                STATE_ANSWER,
                STATE_STEP,
                STATE_EXEC,
                STATE_THREAD,
                STATE_CLEAR,
                STATE_INKEY,
                STATE_INPUT,
                STATE_READ,
                STATE_COLLECT,
                STATE_DIAL,
                STATE_XFER,
                STATE_REFER,
                STATE_HOLD,
                STATE_RECALL,
                STATE_TONE,
                STATE_DTMF,
                STATE_PLAY,
                STATE_RECORD,
                STATE_JOIN,
                STATE_WAIT,
                STATE_CALLING,
                STATE_CONNECT,
                STATE_RECONNECT,
                STATE_HUNTING,
                STATE_SLEEP,
                STATE_START,
                STATE_HANGUP,
                STATE_LIBRESET,
                STATE_WAITKEY,
                STATE_LIBWAIT,
                STATE_IRESET,
                STATE_FINAL,

                STATE_SUSPEND = STATE_DOWN,
                STATE_STANDBY = STATE_DOWN,
                STATE_LIBEXEC = STATE_EXEC,
                STATE_RINGING = STATE_RING,
                STATE_RUNNING = STATE_STEP,
                STATE_THREADING = STATE_THREAD
        } state_t;

        typedef enum
        {
                SIGNAL_EXIT = 0,
                SIGNAL_ERROR,
                SIGNAL_TIMEOUT,
                SIGNAL_DTMF,
        
                SIGNAL_0,
                SIGNAL_1,
                SIGNAL_2,
                SIGNAL_3,
                SIGNAL_4,
                SIGNAL_5,
                SIGNAL_6,
                SIGNAL_7,
                SIGNAL_8,
                SIGNAL_9,
                SIGNAL_STAR,
                SIGNAL_POUND,
                SIGNAL_A,
                SIGNAL_OVERRIDE = SIGNAL_A,
                SIGNAL_B,
                SIGNAL_FLASH = SIGNAL_B,
                SIGNAL_C,
                SIGNAL_IMMEDIATE = SIGNAL_C,
                SIGNAL_D,
                SIGNAL_PRIORITY = SIGNAL_D,

                SIGNAL_RING,
                SIGNAL_TONE,
                SIGNAL_EVENT,
                SIGNAL_WINK,

                SIGNAL_CHILD,
                SIGNAL_FAIL,
                SIGNAL_PICKUP,
                SIGNAL_PART,

                SIGNAL_INVALID,
                SIGNAL_PARENT,
                SIGNAL_WAIT,

                SIGNAL_HANGUP = SIGNAL_EXIT
        } signal_t;

        typedef enum 
        {
                // msgport management events, server control...

                MSGPORT_WAKEUP = 0,     // wakeup a waiting message port
                MSGPORT_SHUTDOWN,       // notify msgport of server shutdown
                MSGPORT_LOGGING,        // enable driver event logging
                MSGPORT_REGISTER,       // update registrations

                // primary event identifiers

                ENTER_STATE = 100,      // newly entered state handler
                EXIT_STATE,
                EXIT_THREAD,            // thread death notify
                EXIT_TIMER,             // timer notified exit
                EXIT_PARTING,           // exit a join...
                NULL_EVENT,             // generic null event pusher
                ERROR_STATE,            // generic enter with error
                ENTER_HUNTING,
                EXIT_HUNTING,
                ENTER_RECONNECT,
                EXIT_RECONNECT,
                RECALL_RECONNECT,
                EXIT_SCRIPT,
                STEP_SCRIPT,

                // primary session control events

                START_DIRECT = 200,     // start a script, directed
                START_INCOMING,         // start an incoming script
                START_OUTGOING,         // start selected script, outbound
                START_RECALL,           // start a recalled call
                START_FORWARDED,        // start a forwarded call
                START_RINGING,          // start a ringing call
                START_HUNTING,          // start a hunting call
                START_REFER,            // start a refer session
                STOP_SCRIPT,
                STOP_DISCONNECT,
                STOP_PARENT,
                CANCEL_CHILD,
                DETACH_CHILD,
                CHILD_RUNNING,
                CHILD_FAILED,
                CHILD_INVALID,
                CHILD_EXPIRED,
                CHILD_BUSY,
                CHILD_FAX,
                CHILD_DND,
                CHILD_AWAY,
                CHILD_NOCODEC,
                CHILD_OFFLINE,

                START_SCRIPT = START_INCOMING,
                START_SELECTED = START_OUTGOING,
                START_TRANSFER = START_REFER,

                // libexec specific events

                ENTER_LIBEXEC = 300,
                EXIT_LIBEXEC,
                HEAD_LIBEXEC,
                ARGS_LIBEXEC,
                GOT_LIBEXEC,
                READ_LIBEXEC,
                DROP_LIBEXEC,
                STAT_LIBEXEC,
                PROMPT_LIBEXEC,
                CLEAR_LIBEXEC,
                WAIT_LIBEXEC,
                RECORD_LIBEXEC,
                REPLAY_LIBEXEC,
                RESTART_LIBEXEC,
                TONE_LIBEXEC,
                XFER_LIBEXEC,
                POST_LIBEXEC,
                ERROR_LIBEXEC,

                // primary driver events

                TIMER_EXPIRED = 400,    // trunk timer expired
                LINE_WINK,
                LINE_PICKUP,
                LINE_HANGUP,
                LINE_DISCONNECT,
                LINE_ON_HOOK,
                LINE_OFF_HOOK,
                RING_ON,
                RING_OFF,
                RING_STOP,
                LINE_CALLER_ID,
                RINGING_DID,
                DEVICE_BLOCKED,
                DEVICE_UNBLOCKED,
                DEVICE_OPEN,
                DEVICE_CLOSE,
                DSP_READY,
                RING_SYNC,

                // primary call processing events

                CALL_DETECT = 500,
                CALL_CONNECTED,
                CALL_RELEASED,
                CALL_ACCEPTED,
                CALL_ANSWERED,
                CALL_HOLD,
                CALL_HOLDING=CALL_HOLD,
                CALL_NOHOLD,
                CALL_DIGITS,
                CALL_OFFERED,
                CALL_ANI,
                CALL_ACTIVE,
                CALL_NOACTIVE,
                CALL_BILLING,
                CALL_RESTART,
                CALL_SETSTATE,
                CALL_FAILURE,
                CALL_ALERTING,
                CALL_INFO,
                CALL_BUSY,
                CALL_DIVERT,
                CALL_FACILITY,
                CALL_FRAME,
                CALL_NOTIFY,
                CALL_NSI,
                CALL_RINGING,
                CALL_DISCONNECT,
                CALL_CLEARED,
                CALL_PROCEEDING,
                RESTART_FAILED,
                RELEASE_FAILED,

                // some timeslot specific control and dial events

                START_RING = 600,
                STOP_RING,
                CLEAR_TIMESLOT, // garbage collect
                START_FLASH,
                STOP_FLASH,
                DIAL_CONNECT,
                DIAL_TIMEOUT,
                DIAL_FAILED,
                DIAL_INVALID,
                DIAL_BUSY,
                DIAL_FAX,
                DIAL_PAM,
                DIAL_DND,
                DIAL_AWAY,
                DIAL_OFFLINE,
                DIAL_NOCODEC,

                DIAL_MACHINE = DIAL_PAM,

                // basic audio stuff

                AUDIO_IDLE = 700,
                AUDIO_ACTIVE,
                AUDIO_EXPIRED,
                INPUT_PENDING,
                OUTPUT_PENDING,
                AUDIO_BUFFER,
                TONE_IDLE,
                DTMF_KEYDOWN,
                DTMF_KEYSYNC,   /* timing sync event */
                DTMF_KEYUP,
                TONE_START,
                TONE_STOP,
                AUDIO_START,
                AUDIO_STOP,
                DTMF_GENDOWN,   /* peer */
                DTMF_GENUP,     /* peer */
                AUDIO_SYNC,     /* peer */
                AUDIO_RECONNECT,        /* re-invite event... */
                AUDIO_DISCONNECT,       /* audio holding re-invite */
                PEER_RECONNECT,         /* peer re-invite notice */
                PEER_DISCONNECT,        /* peer holding notice */
                PEER_REFER,             /* referred by peer */
                DTMF_GENTONE = DTMF_GENUP,

                // make modes and special timeslot stuff

                MAKE_TEST = 800,
                MAKE_BUSY,
                MAKE_IDLE,
                MAKE_DOWN,
                MAKE_UP,
                MAKE_EXPIRED,
                ENABLE_LOGGING,
                DISABLE_LOGGING,
                PART_EXPIRED,
                PART_EXITING,
                PART_DISCONNECT,
                JOIN_PEER,
                PEER_WAITING,
                RELOCATE_REQUEST,       // queued event
                RELOCATE_ACCEPT,        // hunting reply
                RELOCATE_REJECT,        // a kind of disconnect
                START_RELOCATE,         // start timeslot for relocation
                STREAM_ACTIVE,
                STREAM_PASSIVE,
                JOIN_RECALL,
                DROP_RECALL,
                DROP_REFER,

                // aliasing

                ENTER_RESUME = MAKE_UP,
                ENTER_SUSPEND = MAKE_DOWN, 

                // master control events

                SYSTEM_DOWN = 900,      

                // driver specific events and anomalies

                DRIVER_SPECIFIC = 1000  // oddball events

        } event_t;

        typedef enum
        {
                RESULT_SUCCESS = 0,
                RESULT_TIMEOUT,
                RESULT_INVALID,
                RESULT_PENDING,
                RESULT_COMPLETE,
                RESULT_FAILED,
                RESULT_BADPATH = 254,
                RESULT_OFFLINE = 255
        }       result_t;

        typedef struct
        {
                Line line;
                char text[MAX_LIBINPUT];
                const char *list[MAX_LIBINPUT / 2];
        }       libaudio_t;

        typedef struct
        {
                const char *remote;
                const char *userid;
                const char *type;
                const char *status;
                unsigned short active_calls, call_limit;
                unsigned long attempts_iCount, attempts_oCount;
                unsigned long complete_iCount, complete_oCount;
                time_t updated;
        }       regauth_t;

        typedef struct
        {
                event_t id;
                timeslot_t timeslot;
                uint16 seq;

                union
                {
                        // used to invoke attach.  The image refcount
                        // is assumed to already be inc'd!  If no
                        // scr is passed, then uses default or search
                        // vars passed in sym, value pairs
                        struct
                        {
                                ScriptImage *img;
                                Script::Name *scr;
                                BayonneSession *parent;
                                const char *dialing;
                        }       start;

                        struct
                        {
                                ScriptImage *img;
                                Script::Name *scr;
                                BayonneSession *parent;
                                Line *select;
                        }       hunt;

                        struct
                        {
                                BayonneSession *current;
                                BayonneSession *replace;
                        }       relocate;

                        struct
                        {
                                const char *tid;
#ifdef  WIN32
                                HANDLE  pfd;
#else
                                const char *fname;
#endif
                                int pid, result;
                        }       libexec;

                        struct
                        {
                                const char *tid;
                                const char *errmsg;
                        }       liberror;

                        struct
                        {
                                timeout_t duration;
                                int digit;
                        }       dtmf;

                        struct
                        {
                                const char *err;
                                const char *msg;
                        }       cpa;

                        struct
                        {
                                const char *name;
                                bool exit;
                        }       tone;

                        struct
                        {
                                std::ostream *output;
                                const char *logstate;
                        }       debug;

                        struct
                        {
                                const char *encoding;
                                timeout_t framing;
                        }       reconnect;

                        const char *dialing;
                        const char *name;
                        const char *errmsg;
                        BayonneSession *pid;
                        BayonneSession *peer;
                        BayonneSession *child;
                        void *data;
                };

        }       Event;

        class __EXPORT Ring
        {
        private:
                static Mutex locker;
                static Ring *free;
                Ring *next;

                Ring() {};
        public:
                BayonneDriver *driver;
                const char *ring_id;
                unsigned count;
                BayonneSession *session;
                Script::Name *script;

                static Ring *attach(BayonneDriver *d, const char *id, Ring *list);
                static void detach(Ring *list);
                static Ring *find(Ring *list, BayonneSession *s);
                static void start(Ring *list, BayonneSession *s);
        };

        class __EXPORT Traffic
        {
        private:
                static unsigned long stamp;

        public:
                Traffic();

                static inline unsigned long getStamp(void)
                        {return stamp;};

                volatile unsigned long iCount, oCount;
        };

        typedef void (*rpcmethod_t)(BayonneRPC *rpc);

        typedef struct
        {
                const char *name;
                rpcmethod_t method;
                const char *help;
                const char *signature;
        }       RPCDefine;

        class __EXPORT RPCNode
        {
        private:
                friend class __EXPORT BayonneRPC;
                static RPCNode *first;
                static unsigned count;
                RPCNode *next;
                RPCDefine *methods;
                const char *prefix;

        public:
                static inline RPCNode *getFirst(void)
                        {return first;};

                inline RPCNode *getNext(void)
                        {return next;};

                inline const char *getPrefix(void)
                        {return prefix;};

                inline RPCDefine *getMethods(void)
                        {return methods;};

                static inline unsigned getCount(void)
                        {return count;};

                RPCNode(const char *prefix, RPCDefine *dispatch);
        };

        typedef bool (BayonneSession::*Handler)(Event *event);

        typedef struct
        {
                const char *name;
                Handler handler;
                char flag;
        }       statetab;

        typedef struct
        {
                Handler handler, logstate;
                const char *name;
                timeout_t timeout;
                bool peering;
                Name *menu;
                unsigned stack;
                Line *lib;
#ifdef  WIN32
                HANDLE pfd;
#else
                int pfd;
#endif
                result_t result;
                int pid;
                libaudio_t *libaudio;
                bool refer;

                union
                {
                        struct
                        {
                                unsigned count;
                                timeout_t interval;
                        }       wait;

                        struct
                        {
                                Audio::Mode mode;
                                Audio::Level level;
                                timeout_t total, silence, intersilence;
                                long lastnum;
                                bool exitkey;
                                bool compress;
                                bool trigger;
                                const char *pos;
                                const char *exit;
                                const char *menu;
                                const char *note;
                                union {
                                        const char *list[MAX_LIST];
                                        struct {
                                                const char *pathv[4];
                                                char path1[128];
                                                char path2[128];
                                                char meta[MAX_LIST * 2];
                                        };
                                };
                        }       audio;
                                
                        struct
                        {
                                timeout_t interdigit;
                                timeout_t lastdigit;
                                const char *var;
                                const char *exit;
                                const char *format;
                                const char *ignore;
                                const char *route;
                                unsigned count, size, required;
                        }       input;

                        struct
                        {
                                const char *var;
                                const char *menu;
                        }       inkey;

                        struct
                        {
                                const char *sequence;
                                bool flashing;
                                bool dialing, exiting, hangup, dtmf, refer;
                                char *syncdigit;
                                timeout_t synctimer;
                                timeout_t duration;
                                char digits[64];
                                char sessionid[16];
                        }       tone;

                        struct
                        {
                                timeout_t on, off, interdigit;
                                unsigned pos;
                                bool flashing;
                                bool dialing;
                                unsigned char digits[64];
                        }       pulse;  

                        struct
                        {
                                const char *dial;
                                const char *exit;
                                bool dtmf, drop, hangup, refer;
                                BayonneSession *peer;
                                timeout_t answer_timer, hunt_timer;
                                Line *select;
                                unsigned index;
                                char digits[64];
                        }       join;

                        struct
                        {
                                const char *ref;
                                char buf[MAX_LIST * sizeof(char *)];
                        }       url;
                };
                
        }       State;
        
        static statetab states[];

        static Mutex serialize;

        static ThreadLock reloading;

        static Traffic total_call_attempts;
        static Traffic total_call_complete;
        static volatile unsigned short total_active_calls;

        static void allocate(timeslot_t timeslots, ScriptCommand *pointer = NULL, timeslot_t overdraft = 0);

        static const char *getRegistryId(const char *id);

        static BayonneDriver *getDriverTag(const char *id);

        static Audio::Encoding getEncoding(const char *cp);

        static void allocateLocal(void);

        static void addConfig(const char *cfgfile);

        void md5_hash(char *out, const char *source);

        static void waitLoaded(void);
        
        static unsigned long uptime(void);

        static ScriptCompiler *reload(void);

        static void down(void);

        static bool service(const char *service);

        static const char *getRunLevel(void);

        static BayonneSession *getSession(timeslot_t timeslot);

        static ScriptImage **getLocalImage(timeslot_t timeslot);

        static BayonneSession *startDialing(const char *dial, 
                const char *name, const char *caller, const char *display, 
                BayonneSession *parent = NULL, const char *manager = NULL,
                const char *secret = NULL);

        static BayonneSession *getSid(const char *id);

        static timeslot_t toTimeslot(const char *id);

        static inline timeslot_t getTimeslotsUsed(void)
                {return Bayonne::ts_used;};

        static inline timeslot_t getTimeslotCount(void)
                {return Bayonne::ts_count;};    

        static inline timeslot_t getAvailTimeslots(void)
                {return Bayonne::ts_count - Bayonne::ts_used;};

        static Handler getState(const char *name);

        static int getDigit(char dtmf);

        static char getChar(int dtmf);

        static bool matchDigits(const char *digits, const char *match, bool partial = false);

        static ScriptImage *useImage(void);

        static void endImage(ScriptImage *image);

        static bool loadPlugin(const char *path);

        static bool loadMonitor(const char *path);  

        static bool loadAudio(const char *path);

        static void errlog(const char *level, const char *fmt, ...); 

        static bool getUserdata(void);

        static void addTrap4(const char *addr);
#ifdef  CCXX_IPV6
        static void addTrap6(const char *addr);
#endif
};

class __EXPORT BayonneZeroconf
{
protected:
        static BayonneZeroconf *zeroconf_first;
        BayonneZeroconf *zeroconf_next;
        const char *zeroconf_type;
        tpport_t zeroconf_port;

public:
        typedef enum 
        {
                ZEROCONF_IPANY,
                ZEROCONF_IPV6,
                ZEROCONF_IPV4
        }       zeroconf_family_t;

protected:
        zeroconf_family_t zeroconf_family;

        BayonneZeroconf(const char *type, zeroconf_family_t family = ZEROCONF_IPANY);

public:
        static inline BayonneZeroconf *getFirst(void)
                {return zeroconf_first;};

        inline BayonneZeroconf *getNext(void)
                {return zeroconf_next;};

        inline const char *getType(void)
                {return zeroconf_type;};

        inline tpport_t getPort(void)
                {return zeroconf_port;};

        inline zeroconf_family_t getFamily(void)
                {return zeroconf_family;};
};

class __EXPORT BayonneConfig : public DynamicKeydata
{
private:
        static BayonneConfig *first;

        BayonneConfig *next;
        const char *id;

public:
        BayonneConfig(const char *id, Keydata::Define *def, const char *path);
        BayonneConfig(const char *id, const char *path);
        void setEnv(const char *id);
        static BayonneConfig *get(const char *id);
        static void rebuild(ScriptImage *img);
};

class __EXPORT BayonneTranslator : public Bayonne
{
protected:
        static BayonneTranslator *first;
        BayonneTranslator *next;
        const char *id;

        static const char *getToken(BayonneSession *s, Line *l, unsigned *idx);
        static unsigned addItem(BayonneSession *s, unsigned count, const char *text);
        static const char *getLast(BayonneSession *s, unsigned count);

public:
        BayonneTranslator(const char *iso);

        virtual ~BayonneTranslator();

        static BayonneTranslator *get(const char *name);

        static inline BayonneTranslator *getFirst(void)
                {return first;};

        inline BayonneTranslator *getNext()
                {return next;};
        
        static BayonneTranslator *loadTranslator(const char *iso);

        virtual unsigned digits(BayonneSession *sessiob, unsigned count, const char *string);

        virtual unsigned spell(BayonneSession *session, unsigned count, const char *string);

        virtual unsigned sayorder(BayonneSession *session, unsigned count, const char *string);

        virtual unsigned number(BayonneSession *session, unsigned count, const char *string);

        virtual unsigned saynumber(BayonneSession *session, unsigned count, const char *string);

        virtual unsigned saycount(BayonneSession *session, unsigned count, const char *string);

        virtual unsigned sayhour(BayonneSession *session, unsigned count, const char *string);

        virtual unsigned saytime(BayonneSession *session, unsigned count, const char *string);

        virtual unsigned weekday(BayonneSession *session, unsigned count, const char *string);

        /*
         * Translate a string with a date into spoken date without year.
         *
         * @param session to save list of prompts.
         * @param count of current prompts used.
         * @param string to be processed.
         * @return new count of prompts used.
         */
        virtual unsigned sayday(BayonneSession *session, unsigned count, const char *string);

        virtual unsigned saydate(BayonneSession *session, unsigned count, const char *string);

        virtual unsigned saybool(BayonneSession *session, unsigned count, const char *string);

        virtual unsigned phone(BayonneSession *session, unsigned count, const char *string);

        virtual unsigned extension(BayonneSession *session, unsigned count, const char *string);

        virtual const char *speak(BayonneSession *session, Line *line = NULL);

        inline const char *getId(void)
                {return id;};
};


class __EXPORT BayonneAudio : public AudioStream, public Bayonne
{
protected:
        char filename[MAX_PATHNAME];
        const char **list;
        char *getContinuation(void);

public:
        AudioTone *tone;

        BayonneTranslator *translator;

        char vlib[60];

        const char *extension, *voicelib, *libext, *prefixdir, *offset;
        Encoding encoding;
        timeout_t framing;
        char var_position[14];

        BayonneAudio();

        const char *getFilename(const char *name, bool write = false);

        void cleanup(void);
        
        void play(const char **list, Mode mode = modeRead);

        void record(const char *name, Mode mode = modeCreate, const char *annotation = NULL);

        const char *getVoicelib(const char *iso);

        inline AudioCodec *getCodec(void)
                {return codec;};
};              

class __EXPORT BayonneMsgport : public Thread, public Buffer, public Bayonne
{
public:
        virtual ~BayonneMsgport();

        BayonneMsgport(BayonneDriver *driver);

        void update(void); 

        void initial(void);

protected:
        BayonneDriver *msgdriver;
        Event *msglist;
        unsigned msgsize, msghead, msgtail;
        timeslot_t tsfirst, tscount;
        char msgname[16];

        void shutdown(void);

        virtual timeout_t getTimeout(Event *event);
        
        void run(void);

        size_t onWait(void *buf);
        size_t onPost(void *buf);
        size_t onPeek(void *buf);
};

class __EXPORT BayonneDriver : public Bayonne, public ReconfigKeydata, public Mutex
{
protected:
        friend class __EXPORT BayonneSession;
        friend class __EXPORT BayonneMsgport;
        static BayonneDriver *firstDriver;
        static BayonneDriver *lastDriver;
        static BayonneDriver *trunkDriver;
        static BayonneDriver *protoDriver;
        static Semaphore oink;  // the pig has been kicked!
        static bool protocols;

        BayonneSession *firstIdle, *lastIdle, *highIdle;
        BayonneMsgport *msgport;
        BayonneDriver *nextDriver;
        const char *name;
        timeslot_t timeslot, count;
        unsigned avail;
        unsigned span, spans;   
        bool running;
        static bool stopping;
        std::ostream *logevents;

        int audio_priority;
        size_t audio_stack;
        Audio::Level audio_level;

        timeout_t pickup_timer, hangup_timer, seize_timer, ring_timer, hunt_timer;
        timeout_t reset_timer, release_timer, flash_timer, interdigit_timer;
        unsigned answer_count;

        virtual void reloadDriver(void);

        virtual void startDriver(void);

        virtual void stopDriver(void);

        void relistIdle(void);

public:
        virtual bool isAuthorized(const char *userid, const char *secret);

        virtual bool deregister(const char *id);
        virtual bool reregister(const char *id, const char *uri, const char *secret, timeout_t expires);

        Traffic call_attempts, call_complete;
        volatile unsigned short active_calls;

        BayonneDriver(Keydata::Define *pairs, const char *key, const char *id, bool virt = false);

        ~BayonneDriver();

        static inline bool useProtocols(void)
                {return protocols;}

        static bool isStopping(void)
                {return stopping;};

        static inline BayonneDriver *getTrunking(void)
                {return trunkDriver;}

        static inline BayonneDriver *getPrimary(void)
                {return firstDriver;}

        static BayonneDriver *authorize(const char *userid, const char *secret);
        
        inline BayonneDriver *getNext(void)
                {return nextDriver;};

        static inline BayonneDriver *getRoot(void)
                {return firstDriver;};

        static inline BayonneDriver *getProtocol(void)
                {return protoDriver;}

        BayonneSession *getIdle(void);

        virtual bool suspend(void);

        virtual bool resume(void);

        virtual void reregister(void);

        virtual const char *registerScript(ScriptImage *image, Line *line);

        virtual const char *assignScript(ScriptImage *image, Line *line);

        static BayonneDriver *get(const char *id);

        static BayonneDriver *loadDriver(const char *id);

        static BayonneDriver *loadTrunking(const char *id);

        static BayonneDriver *loadProtocol(const char *id, unsigned timeslots = 0);

        static unsigned list(char **items, unsigned max);

        static void start(void);
        
        static void stop(void);

        static void reload(void);

        static void add(BayonneSession *session);

        static void del(BayonneSession *session);

        inline timeslot_t getFirst(void)
                {return timeslot;};

        inline timeslot_t getCount(void)
                {return count;};

        inline unsigned getSpanFirst(void)
                {return span;};

        inline unsigned getSpansUsed(void)
                {return spans;};

        inline const char *getName(void)
                {return name;};

        inline timeout_t getResetTimer(void)
                {return reset_timer;};

        inline timeout_t getReleaseTimer(void)
                {return release_timer;};

        inline timeout_t getHangupTimer(void)
                {return hangup_timer;};

        inline timeout_t getPickupTimer(void)
                {return pickup_timer;};

        inline timeout_t getSeizeTimer(void)
                {return seize_timer;};

        inline timeout_t getHuntTimer(void)
                {return hunt_timer;};

        inline timeout_t getFlashTimer(void)
                {return flash_timer;};

        inline timeout_t getInterdigit(void)
                {return interdigit_timer;};

        inline timeout_t getRingTimer(void)
                {return ring_timer;};

        inline unsigned getAnswerCount(void)
                {return answer_count;};

        BayonneSpan *getSpan(unsigned id);

        BayonneSession *getTimeslot(timeslot_t id);

        inline BayonneMsgport *getMsgport(void)
                {return msgport;};

        inline size_t getAudioStack(void)
                {return audio_stack;};

        inline int getAudioPriority(void)
                {return audio_priority;};

        inline Audio::Level getAudioLevel(void)
                {return audio_level;};

        inline void setLogging(std::ostream *output)
                {logevents = output;};

        inline bool isSpanable(unsigned span);

        virtual bool getDestination(const char *target, const char *dial, char *output, size_t size);

        inline unsigned getAvail(void)
                {return avail;}

        virtual bool isExternal(const char *dest);

        virtual bool isRegistered(const char *dest);

        virtual bool isAvailable(const char *dest);

        virtual bool isReachable(const char *proxy);

        virtual unsigned getRegistration(regauth_t *data, unsigned count, const char *id = NULL);
};      

class __EXPORT BayonneSpan : public Bayonne, public Keydata
{
protected:
        friend class __EXPORT BayonneSession;
        friend class __EXPORT BayonneDriver;

        static BayonneSpan *first;
        static BayonneSpan *last;
        static unsigned spans;
        static BayonneSpan **index;
        
        unsigned id;
        BayonneDriver *driver;
        BayonneSpan *next;
        timeslot_t timeslot, count, used;       // timeslots

public:
        Traffic call_attempts, call_complete;
        volatile unsigned short active_calls;

        BayonneSpan(BayonneDriver *driver, timeslot_t timeslots);

        static BayonneSpan *get(unsigned id);
        
        BayonneSession *getTimeslot(timeslot_t id);

        static void allocate(unsigned total = 0);

        static inline unsigned getSpans(void)
                {return spans;};

        inline timeslot_t getFirst(void)
                {return timeslot;};

        inline timeslot_t getCount(void)
                {return count;};

        inline unsigned getId(void)
                {return id;};

        inline BayonneDriver *getDriver(void)
                {return driver;};

        inline unsigned getAvail(void)
                {return count - used;}

        virtual bool suspend(void);

        virtual bool resume(void);

        virtual bool reset(void);
};

class __EXPORT BayonneBinder : public ScriptBinder, public Bayonne
{
private:
        friend class __EXPORT BayonneSession;
        static BayonneBinder *binder;

        class Image : public ScriptImage
        {
        public:
                inline Image() : ScriptImage(NULL, NULL) {};
                unsigned gatherPrefix(const char *prefix, const char **list, unsigned max);
        };

protected:
        virtual const char *submit(const char **data);

        virtual ScriptCompiler *compiler(void);
        
        virtual unsigned destinations(Image *img, const char **array, unsigned max);

        virtual bool isDestination(Image *img, const char *name);

        BayonneSession *session(ScriptInterp *interp);

        bool scriptEvent(ScriptInterp *interp, const char *evt);

        bool digitEvent(ScriptInterp *interp, const char *evt);

        BayonneBinder(const char *id);

        virtual void makeCall(BayonneSession *child);

        virtual void dropCall(BayonneSession *child);

        virtual Name *getIncoming(ScriptImage *img, BayonneSession *s, Event *event);

public:
        static const char *submitRequest(const char **data);

        static ScriptCompiler *getCompiler(void);

        static unsigned gatherDestinations(ScriptImage *img, const char **index, unsigned max);

        static bool isDestination(const char *name);
};

class __EXPORT BayonneSession : public ScriptInterp, public Bayonne
{
private:
        friend class __EXPORT ScriptEngine;
        friend class __EXPORT BayonneMsgport;
        friend class __EXPORT BayonneTranslator;
        friend class __EXPORT BayonneDriver;
        friend class __EXPORT Bayonne;

        BayonneSession() {};

        BayonneSession *nextIdle, *prevIdle;
        bool isAvail;

protected:
        static BayonneTranslator langNone;
        static ScriptSymbols *globalSyms;
        static Mutex globalLock;        

        std::ostream *logevents, *logtrace;
        Ring *ring;
        BayonneDriver *driver;
        BayonneMsgport *msgport;
        BayonneSession *peer;
        BayonneSpan *span;
        timeslot_t timeslot;
        uint8 seq;
        uint16 evseq;
        uint32 tseq;
        bool offhook, dtmf, answered, starting, holding, connecting, referring;
        time_t audiotimer, starttime;
        interface_t iface;
        bridge_t bridge;
        calltype_t type;
        event_t seizure;
        ScriptEngine *vm;

//      Name *getScript(const char *scr);

        bool requiresDTMF(void);

        void enterCall(void);

        void exitCall(const char *reason);

        virtual bool enableDTMF(void);

        virtual void disableDTMF(void);

        virtual const char *checkAudio(bool live);

        virtual bool filterPosting(Event *event);

        virtual bool enterCommon(Event *event);
        virtual bool enterInitial(Event *event);
        virtual bool enterFinal(Event *event);
        virtual bool enterIdle(Event *event);
        virtual bool enterReset(Event *event);
        virtual bool enterRelease(Event *event);
        virtual bool enterRinging(Event *event);
        virtual bool enterPickup(Event *event);
        virtual bool enterAnswer(Event *event);
        virtual bool enterSeize(Event *event);
        virtual bool enterHunting(Event *event);
        virtual bool enterHangup(Event *event);
        virtual bool enterTone(Event *event);
        virtual bool enterReconnect(Event *event);
        virtual bool enterDTMF(Event *event);
        virtual bool enterPlay(Event *event);
        virtual bool enterRecord(Event *event);
        virtual bool enterJoin(Event *event);
        virtual bool enterWait(Event *event);
        virtual bool enterDial(Event *event);
        virtual bool enterBusy(Event *event);
        virtual bool enterStandby(Event *event);
        virtual bool enterXfer(Event *event);
        virtual bool enterRefer(Event *event);
        virtual bool enterHold(Event *event);
        virtual bool enterRecall(Event *event);

        void check(void);

        void renameRecord(void);
        bool stateInitial(Event *event);
        bool stateFinal(Event *event);
        bool stateIdle(Event *event);
        bool stateIdleReset(Event *event);
        bool stateReset(Event *event);
        bool stateRelease(Event *event);
        bool stateBusy(Event *event);
        bool stateStandby(Event *event);
        bool stateRinging(Event *event);
        bool statePickup(Event *event);
        bool stateAnswer(Event *event);
        bool stateSeize(Event *event);
        bool stateHunting(Event *event);
        bool stateRunning(Event *event);
        bool stateLibexec(Event *event);
        bool stateLibreset(Event *event);
        bool stateLibwait(Event *event);
        bool stateWaitkey(Event *event);
        bool stateThreading(Event *event);
        bool stateHangup(Event *event);
        bool stateCollect(Event *event);
        bool stateSleep(Event *event);
        bool stateStart(Event *event);
        bool stateClear(Event *event);
        bool stateInkey(Event *event);
        bool stateInput(Event *event);
        bool stateRead(Event *event);
        bool stateDial(Event *event);
        bool stateXfer(Event *event);
        bool stateRefer(Event *event);
        bool stateHold(Event *event);
        bool stateRecall(Event *event);
        bool stateTone(Event *event);
        bool stateDTMF(Event *event);
        bool statePlay(Event *event);
        bool stateRecord(Event *event);
        bool stateJoin(Event *event);
        bool stateWait(Event *event);
        bool stateConnect(Event *event);
        bool stateReconnect(Event *event);
        bool stateCalling(Event *event);

        bool putEvent(Event *event);

        void libWrite(const char *string);

        void libClose(const char *string);

        bool isLibexec(const char *tsid);

        timeout_t getLibexecTimeout(void);

        const char *getWritepath(char *buf = NULL, size_t len = 0);

        void incIncomingAttempts(void);

        void incOutgoingAttempts(void);

        void incIncomingComplete(void);

        void incOutgoingComplete(void);

        void incActiveCalls(void);

        void decActiveCalls(void);

public:
        Traffic call_attempts, call_complete;

        inline bool isDTMF(void)
                {return dtmf;};

        inline bool isPeering(void)
                {return state.peering;};

        inline BayonneSpan *getSpan(void)
                {return span;};

        inline timeslot_t getTimeslot(void)
                {return timeslot;};

        inline ScriptEngine *getEngine(void)
                {return vm;};

        const char *getExternal(const char *option);

        bool addSymbol(const char *id, const char *value);

    bool clearSymbol(const char *id);

        inline uint16 getEventSequence(void)
                {return evseq;};

        static const char *getGlobal(const char *id);
        static bool setGlobal(const char *id, const char *value);
        static bool sizeGlobal(const char *id, unsigned size);
        static bool addGlobal(const char *id, const char *value);
        static bool clearGlobal(const char *id);

protected:
        ScriptInterp *getInterp(const char *id);

        ScriptSymbols *getSymbols(const char *id);

        BayonneTranslator *translator;

        Name *attachStart(Event *event);

        unsigned getId(void);

        void setSid(void);

        void setState(state_t);

        void setRunning(void);

        bool setReconnect(const char *enc, timeout_t framing);


        bool recallReconnect(void);

        void setConnecting(const char *evname = NULL);

        bool setLibexec(result_t result);

        bool setLibreset(result_t result);

public:
        inline BayonneTranslator *getTranslator(void)
                {return translator;};

        inline void startConnecting(void)
                {connecting = true;};

protected:
        inline libaudio_t *getLibaudio(void)
                {return state.libaudio;};

        void finalize(void);

        bool exit(void);

        char var_date[12];
        char var_time[12];
        char var_duration[12];
        char var_callid[12];
        char var_tid[14];
        char var_sid[16];
        char var_pid[16];
        char var_recall[16];
        char var_joined[16];
        char var_rings[4];
        char var_timeslot[8];
        char var_spanid[8];
        char var_bankid[4];
        char var_spantsid[12];
        const char *voicelib;
        char *dtmf_digits;              // dtmf sym space;
        unsigned digit_count, ring_count;
        time_t time_joined;

        State state;

public:
        BayonneSession(BayonneDriver *driver, timeslot_t timeslot, BayonneSpan *span = NULL);

        virtual ~BayonneSession();

        const char *getDigits(void);

        inline const char *defVoicelib(void)
                {return voicelib;}

        inline const char *getSessionId(void)
                {return var_sid;};

        inline const char *getSessionParent(void)
                {return var_pid;};

        inline const char *getSessionJoined(void)
                {return var_joined;};

        inline time_t getSessionStart(void)
                {return starttime;};

        void initialevent(void);

        void initialize(void);

        void detach(void);

        inline time_t getJoined(void)
                {return time_joined;};

        inline BayonneDriver *getDriver(void)
                {return driver;}

        virtual timeout_t getRemaining(void) = 0;

        virtual void startTimer(timeout_t timer) = 0;

        virtual void stopTimer(void) = 0;

        virtual void setOffhook(bool state);

        virtual void makeIdle(void);

        void part(event_t reason);

        virtual bool postEvent(Event *event);


        bool matchLine(Line *line);

        virtual void queEvent(Event *event);

        virtual void startThread(void);

        virtual void enterThread(ScriptThread *thr);

        virtual void exitThread(const char *msg);

        virtual void clrAudio(void);

        virtual timeout_t getToneFraming(void);

        virtual const char *audioEncoding(void);

        virtual const char *audioExtension(void);
        
        virtual timeout_t audioFraming(void);

        const char *getAudio(bool live = true);

        void branching(void);

        inline bool isOffhook(void)
                {return offhook;};

        inline interface_t getInterface(void)
                {return iface;};

        inline bridge_t getBridge(void)
                {return bridge;};

        inline calltype_t getType(void)
                {return type;};

        inline timeslot_t getSlot(void)
                {return timeslot;};

        inline bool isIdle(void)
                {return isAvail;};

        bool isRefer(void);

        bool isJoined(void);

        bool isAssociated(void);

        void associate(BayonneSession *s);

        inline bool isHolding(void)
                {return holding;};

        bool isDisconnecting(void);

        timeout_t getJoinTimer(void);

        bool signalScript(signal_t signal);

        virtual bool peerLinear(void);

        virtual bool peerAudio(Audio::Encoded encoded);

        virtual bool setPeering(Audio::Encoding encoding, timeout_t framing);

        const char *getKeyString(const char *id);
        bool getKeyBool(const char *id);
        long getKeyValue(const char *id);
        timeout_t getSecTimeout(const char *id);
        timeout_t getMSecTimeout(const char *id);
        timeout_t getTimeoutValue(const char *opt = NULL);
        timeout_t getTimeoutKeyword(const char *kw);
        const char *getExitKeyword(const char *def);
        const char *getMenuKeyword(const char *def);

        unsigned getInputCount(const char *digits, unsigned max);

        uint32 newTid(void);

        inline const char *getTid(void)
                {return var_tid;};

        bool digitEvent(const char *event);

        inline bool stringEvent(const char *evt)
                {return scriptEvent(evt);}

        char getDigit(void);

        BayonneAudio audio;
};

class __EXPORT BayonneRPC : public Bayonne
{
protected:
        BayonneRPC();
        virtual ~BayonneRPC();

        struct params
        {
                char *name[RPC_MAX_PARAMS];
                char *map[RPC_MAX_PARAMS];
                char *value[RPC_MAX_PARAMS];
                unsigned short param[RPC_MAX_PARAMS];
                unsigned count;
                short argc;
        }       params;

        bool parseCall(char *cp);

public:
        virtual void setComplete(BayonneSession *s);

        struct {
                char *buffer;
                size_t bufsize;
                size_t bufused;
                const char *agent_id;
                const char *protocol;
                bool authorized;                // transport authorized
                const char *userid;             // null if anonymous
                BayonneDriver *driver;          // authorizing driver
        }       transport;

        struct {
                unsigned code;
                const char *string;
        }       result;

        struct {
                const char *prefix;     // xmlrpc has prefix, soap NULL
                const char *method;
                const char *tranid;
                const char *action;
                const char *resuri;
        }       header;

        inline unsigned getCount(void)
                {return params.argc;};

        const char *getParamId(unsigned short param, unsigned short offset); 
        const char *getIndexed(unsigned short param, unsigned short offset = 0);
        const char *getNamed(unsigned short param, const char *member);
        const char *getMapped(const char *map, const char *member);

        friend size_t xmlwrite(char **buf, size_t *max, const char *fmt, ...);
        bool buildResponse(const char *fmt, ...);
        void sendSuccess(void);
        void sendFault(int code, const char *string);
        
        inline void transportFault(unsigned code, const char *string)
                {result.code = code; result.string = string;};

        bool invokeXMLRPC(void);
};      

size_t xmlwrite(char **buf, size_t *max, const char *fmt, ...);
         
class __EXPORT BayonneService : public Thread                
{          
private:            
        friend class __EXPORT BayonneSession;

        static BayonneService *first;
        static BayonneService *last;
        BayonneService *next;
        friend void startServices(void);        
        friend void stopServices(void);

protected:
        BayonneService(int pri, size_t stack);

        virtual void stopService(void);

        virtual void startService(void);

        virtual void detachSession(BayonneSession *s);

        virtual void attachSession(BayonneSession *s);

        virtual void enteringCall(BayonneSession *child);

        virtual void exitingCall(BayonneSession *child);

public:
        static void start(void);
        
        static void stop(void); 
};

class __EXPORT ScriptEngine
{
protected:
        friend class __EXPORT BayonneSession;

        virtual bool signalEngine(Bayonne::signal_t signal) = 0;

        virtual void releaseEngine(void) = 0;

        virtual void disconnectEngine(void) = 0;

        virtual bool stepEngine(void) = 0;

        virtual ~ScriptEngine() = 0;

        /*
         * Clears vm session.
         */
        inline void clearEngine(BayonneSession *s)
                {s->vm = NULL;};

        inline void setEngine(BayonneSession *s)
                {s->vm = this;};
};


} // namespace

#endif