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

#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

namespace ost {

class __EXPORT BayonneMsgport;
class __EXPORT BayonneDriver;
class __EXPORT BayonneSession;
class __EXPORT BayonneSpan;
class __EXPORT BayonneService;
class __EXPORT BayonneTranslator;
          
class __EXPORT Bayonne : public Script
{
public:
#ifdef  WIN32
        typedef WORD    timeslot_t;
#else
        typedef uint16_t timeslot_t;
#endif

protected:
        static BayonneSession **timeslots;
        static ScriptImage **localimages;
        static char *status;
        static ScriptCommand *server;
        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[];
        static time_t start_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 bool provision_defines;
        static bool provision_daemon;
        static bool provision_system;
        static bool provision_check;
        static bool provision_user;
        static bool provision_test;
        static const char *provision_server;
        static const char *provision_libexec;

        static Audio::Encoding peer_encoding;
        static Audio::timeout_t peer_framing;
        static BayonneTranslator *init_translator;
        static const char *init_voicelib;
        static AtomicCounter libexec_count;

        static const char *getKeypath(const char *cp);

        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 */
        }       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_STEP,
                STATE_EXEC,
                STATE_THREAD,
                STATE_CLEAR,
                STATE_INKEY,
                STATE_INPUT,
                STATE_READ,
                STATE_COLLECT,
                STATE_DIAL,
                STATE_XFER,
                STATE_HOLD,
                STATE_RECALL,
                STATE_TONE,
                STATE_DTMF,
                STATE_PLAY,
                STATE_RECORD,
                STATE_JOIN,
                STATE_WAIT,
                STATE_CONNECT,
                STATE_SLEEP,
                STATE_START,
                STATE_HANGUP,
                STATE_LIBRESET,
                STATE_WAITKEY,
                STATE_LIBWAIT,
                STATE_IRESET,
                STATE_FINAL,

                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

                // 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
                STOP_SCRIPT,
                STOP_DISCONNECT,
                STOP_PARENT,
                CANCEL_CHILD,
                DETACH_CHILD,
                CHILD_RUNNING,
                CHILD_FAILED,
                CHILD_INVALID,
                CHILD_EXPIRED,
                CHILD_BUSY,
                CHILD_FAX,

                START_SCRIPT = START_INCOMING,
                START_SELECTED = START_OUTGOING,

                // 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,

                // 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_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 */
                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,

                // 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;
        }       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
                        {
                                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;

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

        }       Event;

        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;
                Name *menu;
                unsigned stack;
                Line *lib;
#ifdef  WIN32
                HANDLE pfd;
#else
                int pfd;
#endif
                result_t result;
                int pid;
                libaudio_t *libaudio;

                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;
                                const char *list[MAX_LIST];
                        }       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;
                                bool exiting;
                                bool dtmf;
                                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;
                                BayonneSession *peer;
                                timeout_t answer_timer;
                                char digits[64];
                        }       join;

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

        static Mutex serialize;

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

        static void allocateLocal(void);

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

        static ScriptCompiler *reload(void);

        static void down(void);

        static bool service(const char *service);

        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);

        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, ...); 
};

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

        BayonneConfig *next;
        const char *id;

public:
        BayonneConfig(const char *id, 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 Keydata, 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;
        BayonneMsgport *msgport;
        BayonneDriver *nextDriver;
        const char *name;
        timeslot_t timeslot, count;
        unsigned avail;
        unsigned span, spans;   
        bool running;
        std::ostream *logevents;

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

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

        virtual void startDriver(void);

        virtual void stopDriver(void);

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

        ~BayonneDriver();

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

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

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

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

        BayonneSession *getIdle(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 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 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 unsigned getRegistration(regauth_t *data, unsigned count);
};      

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:
        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;}
};

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

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

        BayonneSession *session(ScriptInterp *interp);

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

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

        BayonneBinder(const char *id);

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

class __EXPORT BayonneSession : public ScriptInterp, public Bayonne
{
private:
        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;
        BayonneDriver *driver;
        BayonneMsgport *msgport;
        BayonneSession *peer;
        BayonneSpan *span;
        timeslot_t timeslot;
        uint8 seq;
        uint16 evseq;
        uint32 tseq;
        bool offhook, dtmf, answered, starting, holding;
        time_t audiotimer, starttime;
        interface_t iface;
        bridge_t bridge;
        calltype_t type;
        event_t seizure;

        Name *getScript(const char *scr);

        bool requiresDTMF(void);

        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 enterSeize(Event *event);
        virtual bool enterHangup(Event *event);
        virtual bool enterTone(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 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 stateSeize(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 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 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);

public:
        const char *getExternal(const char *option);