route.c

   1 /*****************************************************************************\
   2 **                                                                           **
   3 ** PBX4Linux                                                                 **
   4 **                                                                           **
   5 **---------------------------------------------------------------------------**
   6 ** Copyright: Andreas Eversberg                                              **
   7 **                                                                           **
   8 ** match processing of routing configuration                                 **
   9 **                                                                           **
  10 \*****************************************************************************/
  11
  12 #include <stdio.h>
  13 #include <string.h>
  14 #include <stdlib.h>
  15 #include <unistd.h>
  16 #include "main.h"
  17
  18
  19 struct route_ruleset    *ruleset_first;         /* first entry */
  20 struct route_ruleset    *ruleset_main;          /* pointer to main ruleset */
  21
  22 struct cond_defs cond_defs[] = {
  23         { "extern",     MATCH_EXTERN,   COND_TYPE_NULL,
  24           "extern", "Matches if call is from external port (no extension)."},
  25         { "intern",     MATCH_INTERN,COND_TYPE_NULL,
  26           "intern", "Matches if call is from an extension."},
  27         { "port",       MATCH_PORT,     COND_TYPE_INTEGER,
  28           "port=<number>[-<number>][,...]", "Matches if call is received from given port(s). NOT INTERFACE!"},
  29         { "interface",  MATCH_INTERFACE,COND_TYPE_STRING,
  30           "interface=<interface>[,...]", "Matches if call is received from given interface(s). NOT PORTS!"},
  31         { "callerid",   MATCH_CALLERID, COND_TYPE_STRING,
  32           "callerid=<digits>[-<digits>][,...]", "Matches if caller ID matches or begins with the given (range(s) of) prefixes(s)."},
  33         { "extension",  MATCH_EXTENSION,COND_TYPE_STRING,
  34           "extension=<digits>[-<digits>][,...]", "Matches if caller calls from given (range(s) of) extension(s)."},
  35         { "dialing",    MATCH_DIALING,  COND_TYPE_STRING,
  36           "dialing=<digits>[-<digits>][,...]", "Matches if caller has dialed the given (range(s) of) digits at least."},
  37         { "enblock",    MATCH_ENBLOCK,  COND_TYPE_NULL,
  38           "enblock", "Matches if caller dialed en block. (Dial the number before pick up.)"},
  39         { "overlap",    MATCH_OVERLAP,  COND_TYPE_NULL,
  40           "overlap", "Matches if caller dialed digit by digit. (Dial the number after pick up.)"},
  41         { "anonymous",  MATCH_ANONYMOUS,COND_TYPE_NULL,
  42           "anonymous", "Matches if caller uses restricted caller ID or if not available."},
  43         { "visible",    MATCH_VISIBLE,  COND_TYPE_NULL,
  44           "visible", "Matches if caller ID is presented and if available."},
  45         { "unknown",    MATCH_UNKNOWN,  COND_TYPE_NULL,
  46           "unknown", "Matches if no ID is available from caller."},
  47         { "available",  MATCH_AVAILABLE,COND_TYPE_NULL,
  48           "available", "Matches if ID is available from caller."},
  49         { "fake",       MATCH_FAKE,     COND_TYPE_NULL,
  50           "fake", "Matches if caller ID is not screened and may be faked by caller."},
  51         { "real",       MATCH_REAL,     COND_TYPE_NULL,
  52           "real", "Matches if caller ID is screend and so it is the real caller's ID."},
  53         { "redirected", MATCH_REDIRECTED,COND_TYPE_NULL,
  54           "redirected", "Matches if caller has been redirected."},
  55         { "direct",     MATCH_DIRECT    ,COND_TYPE_NULL,
  56           "direct", "Matches if caller did not come from an redirection."},
  57         { "redirid",    MATCH_REDIRID   ,COND_TYPE_STRING,
  58           "redirid=<digits>[-<digits>][,...]", "Matches if the caller has been redirected by the given (range(s) of) ID(s) or prefix(es))"},
  59         { "time",       MATCH_TIME,     COND_TYPE_TIME,
  60           "time=<minutes>[-<minutes>][,...]", "Matches if the caller calls within the given (range(s) of) time(s). (e.g. 0700-1900)"},
  61         { "mday",       MATCH_MDAY,     COND_TYPE_MDAY,
  62           "mday=<day>[-<day>][,...]", "Matches if the caller calls within the given (range(s) of) day(s) of the month. (1..31)"},
  63         { "month",      MATCH_MONTH,    COND_TYPE_MONTH,
  64           "month=<month>[-<month>][,...]", "Matches if the caller calls within the given (range(s) of) month(s). (1=January..12=December)"},
  65         { "year",       MATCH_YEAR,     COND_TYPE_YEAR,
  66           "year=<year>[-<year>][,...]", "Matches if the caller calls within the given (range(s) of) year(s). (1970..2106)"},
  67         { "wday",       MATCH_WDAY,     COND_TYPE_WDAY,
  68           "wday=<day>[-<day>][,...]", "Matches if the caller calls within the given (range(s) of) weekday(s). (1=Monday..7=Sunday)"},
  69         { "capability", MATCH_CAPABILITY, COND_TYPE_CAPABILITY,
  70           "capability=speech|audio|video|digital-restricted|digital-unrestricted|digital-unrestricted-tones[,...]", "Matches the given bearer capability(s)."},
  71         { "infolayer1", MATCH_INFOLAYER1, COND_TYPE_INTEGER,
  72           "infolayer1=<value>[,...]", "Matches the given information layer 1. (2=u-Law, 3=a-law, see info layer 1 in bearer capability.)"},
  73         { "hlc",        MATCH_HLC,      COND_TYPE_INTEGER,
  74           "hlc=<value>[,...]", "Matches the high layer capability(s)."},
  75         { "file",       MATCH_FILE,     COND_TYPE_STRING,
  76           "file=<path>[,...]", "Mathes is the given file exists and if the first character is '1'."},
  77         { "execute",    MATCH_EXECUTE,  COND_TYPE_STRING,
  78           "execute=<command>[,...]","Matches if the return value of the given command is greater 0."},
  79         { "default",    MATCH_DEFAULT,  COND_TYPE_NULL,
  80           "default","Matches if no further dialing could match."},
  81         { "timeout",    MATCH_TIMEOUT,  COND_TYPE_INTEGER,
  82           "timeout=<seconds>","Matches if the ruleset was entered AFTER given seconds."},
  83         { "free",       MATCH_FREE,     COND_TYPE_IFATTR,
  84           "free=<interface>:<channel>","Matches if the given minimum of channels are free."},
  85         { "notfree",    MATCH_NOTFREE,  COND_TYPE_IFATTR,
  86           "notfree=<interface>:<channel>","Matches if NOT the given minimum of channels are free."},
  87         { "blocked",    MATCH_DOWN,     COND_TYPE_STRING,
  88           "blocked=<interfaces>[,...]","Matches if all of the given interfaces are blocked."},
  89         { "idle",       MATCH_UP,       COND_TYPE_STRING,
  90           "idle=<interface>[,...]","Matches if any of the given interfaces is idle."},
  91         { "busy",       MATCH_BUSY,     COND_TYPE_STRING,
  92           "busy=<extension>[,...]","Matches if any of the given extension is busy."},
  93         { "notbusy",    MATCH_IDLE,     COND_TYPE_STRING,
  94           "notbusy<extension>[,...]","Matches if any of the given extension is not busy."},
  95         { NULL, 0, 0, NULL}
  96 };
  97
  98 struct param_defs param_defs[] = {
  99         { PARAM_PROCEEDING,
 100           "proceeding", PARAM_TYPE_NULL,
 101           "proceeding", "Will set the call into 'proceeding' state to prevent dial timeout."},
 102         { PARAM_ALERTING,
 103           "alerting",   PARAM_TYPE_NULL,
 104           "alerting", "Will set the call into 'altering' state."},
 105         { PARAM_CONNECT,
 106           "connect",    PARAM_TYPE_NULL,
 107           "connect", "Will complete the call before processing the action. Audio path for external calls will be established."},
 108         { PARAM_EXTENSION,
 109           "extension",  PARAM_TYPE_STRING,
 110           "extension=<digits>", "Give extension name (digits) to relate this action to."},
 111         { PARAM_EXTENSIONS,
 112           "extensions", PARAM_TYPE_STRING,
 113           "extensions=<extension>[,<extension>[,...]]", "One or more extensions may be given."},
 114         { PARAM_PREFIX,
 115           "prefix",     PARAM_TYPE_STRING,
 116           "prefix=<digits>", "Add prefix in front of the dialed number."},
 117         { PARAM_CAPA,
 118           "capability", PARAM_TYPE_CAPABILITY,
 119           "capability=speech|audio|video|digital-restricted|digital-unrestricted|digital-unrestricted-tones", "Alter the service type of the call."},
 120         { PARAM_BMODE,
 121           "bmode",      PARAM_TYPE_BMODE,
 122           "capability=transparent|hdlc", "Alter the bchannel mode of the call. Use hdlc for data calls."},
 123         { PARAM_INFO1,
 124           "infolayer1", PARAM_TYPE_INTEGER,
 125           "infolayer1=<value>", "Alter the layer 1 information of a call. Use 3 for ALAW or 2 for uLAW."},
 126         { PARAM_HLC,
 127           "hlc",        PARAM_TYPE_INTEGER,
 128           "hlc=<value>", "Alter the HLC identification. Use 1 for telephony or omit."},
 129         { PARAM_EXTHLC,
 130           "exthlc",     PARAM_TYPE_INTEGER,
 131           "exthlc=<value>", "Alter extended HLC value. (Mainenance only, don't use it.)"},
 132         { PARAM_PRESENT,
 133           "present",    PARAM_TYPE_YESNO,
 134           "present=yes|no", "Allow or restrict caller ID regardless what the caller wants."},
 135         { PARAM_DIVERSION,
 136           "diversion",  PARAM_TYPE_DIVERSION,
 137           "diversion=cfu|cfnr|cfb|cfp", "Set diversion type."},
 138         { PARAM_DEST,
 139           "dest",       PARAM_TYPE_DESTIN,
 140           "dest=<string>", "Destination number to divert to. Use 'vbox' to divert to vbox. (cfu,cfnr,cfb only)"},
 141         { PARAM_SELECT,
 142           "select",     PARAM_TYPE_NULL,
 143           "select", "Lets the caller select the history of calls using keys '1'/'3' or '*'/'#'."},
 144         { PARAM_DELAY,
 145           "delay",      PARAM_TYPE_INTEGER,
 146           "delay=<seconds>", "Number of seconds to delay."},
 147         { PARAM_LIMIT,
 148           "limit",      PARAM_TYPE_INTEGER,
 149           "limit=<retries>", "Number of maximum retries."},
 150         { PARAM_HOST,
 151           "host",       PARAM_TYPE_STRING,
 152           "host=<string>", "Name of remote VoIP host."},
 153         { PARAM_PORT,
 154           "port",       PARAM_TYPE_STRING,
 155           "port=<value>", "Alternate port to use if 'host' is given."},
 156         { PARAM_INTERFACES,
 157           "interfaces", PARAM_TYPE_STRING,
 158           "interfaces=<interface>[,<interface>[,...]]", "Give one or a list of Interfaces to select a free channel from."},
 159         { PARAM_ADDRESS,
 160           "address",    PARAM_TYPE_STRING,
 161           "address=<string>", "Complete VoIP address. ( [user@]host[:port] )"},
 162         { PARAM_SAMPLE,
 163           "sample",     PARAM_TYPE_STRING,
 164           "sample=<file prefix>", "Filename of sample (current tone's dir) or full path to sample. ('.wav'/'.wave'/'.isdn' is added automatically."},
 165         { PARAM_ANNOUNCEMENT,
 166           "announcement",PARAM_TYPE_STRING,
 167           "announcement=<file prefix>", "Filename of announcement (inside vbox recording dir) or full path to sample. ('.wav'/'.wave'/'.isdn' is added automatically."},
 168         { PARAM_RULESET,
 169           "ruleset",    PARAM_TYPE_STRING,
 170           "ruleset=<name>", "Ruleset to go to."},
 171         { PARAM_CAUSE,
 172           "cause",      PARAM_TYPE_INTEGER,
 173           "cause=<cause value>", "Cause value when disconnecting. (21=reject 1=unassigned 63=service not available)"},
 174         { PARAM_LOCATION,
 175           "location",   PARAM_TYPE_INTEGER,
 176           "location=<location value>", "Location of cause value when disconnecting. (0=user 1=private network sering local user)"},
 177         { PARAM_DISPLAY,
 178           "display",    PARAM_TYPE_STRING,
 179           "display=<text>", "Message to display on the caller's telephone. (internal only)"},
 180         { PARAM_PORTS,
 181           "ports",      PARAM_TYPE_INTEGER,
 182           "ports=<port>[,<port>[,...]]", "ISDN port[s] to use."},
 183         { PARAM_TPRESET,
 184           "tpreset",    PARAM_TYPE_INTEGER,
 185           "tpreset=<seconds>", "Preset of countdown timer."},
 186         { PARAM_FILE,
 187           "file",       PARAM_TYPE_STRING,
 188           "file=<full path>", "Full path to file name."},
 189         { PARAM_CONTENT,
 190           "content",    PARAM_TYPE_STRING,
 191           "content=<string>", "Content to write into file."},
 192         { PARAM_APPEND,
 193           "append",     PARAM_TYPE_NULL,
 194           "append", "Will append to given file, rather than overwriting it."},
 195         { PARAM_EXECUTE,
 196           "execute",    PARAM_TYPE_STRING,
 197           "execute=<full path>", "Full path to script/command name. (Dialed digits are the argument 1.)"},
 198         { PARAM_PARAM,
 199           "param",      PARAM_TYPE_STRING,
 200           "param=<string>", "Optionally this parameter can be inserted as argument 1, others are shifted."},
 201         { PARAM_TYPE,
 202           "type",       PARAM_TYPE_TYPE,
 203           "type=unknown|subscriber|national|international", "Type of number to dial, default is 'unknown'."},
 204         { PARAM_COMPLETE,
 205           "complete",   PARAM_TYPE_NULL,
 206           "complete", "Indicates complete number as given by prefix. Proceeding of long distance calls may be faster."},
 207         { PARAM_CALLERID,
 208           "callerid",   PARAM_TYPE_STRING,
 209           "callerid=<digits>", "Change caller ID to given string."},
 210         { PARAM_CALLERIDTYPE,
 211           "calleridtype",PARAM_TYPE_CALLERIDTYPE,
 212           "calleridtype=[unknown|subscriber|national|international]", "Type of caller ID. For normal MSN use 'unknown'"},
 213         { PARAM_CALLTO,
 214           "callto",     PARAM_TYPE_STRING,
 215           "callto=<digits>", "Where to call back. By default the caller ID is used."},
 216         { PARAM_ROOM,
 217           "room",       PARAM_TYPE_INTEGER,
 218           "room=<digits>", "Conference room number, must be greater 0, as in real life."},
 219         { PARAM_TIMEOUT,
 220           "timeout",    PARAM_TYPE_INTEGER,
 221           "timeout=<seconds>", "Timeout before continue with next action."},
 222         { PARAM_NOPASSWORD,
 223           "nopassword", PARAM_TYPE_NULL,
 224           "nopassword", "Don't ask for password. Be sure to authenticate right via real caller ID."},
 225         { 0, NULL, 0, NULL, NULL}
 226 };
 227
 228 struct action_defs action_defs[] = {
 229         { ACTION_EXTERNAL,
 230           "extern",     &EndpointAppPBX::action_init_call, &EndpointAppPBX::action_dialing_external, &EndpointAppPBX::action_hangup_call,
 231           PARAM_CONNECT | PARAM_PREFIX | PARAM_COMPLETE | PARAM_TYPE | PARAM_CAPA | PARAM_BMODE | PARAM_INFO1 | PARAM_HLC | PARAM_EXTHLC | PARAM_PRESENT | PARAM_INTERFACES | PARAM_CALLERID | PARAM_CALLERIDTYPE | PARAM_TIMEOUT,
 232           "Call is routed to extern number as dialed."},
 233         { ACTION_INTERNAL,
 234           "intern",     &EndpointAppPBX::action_init_call, &EndpointAppPBX::action_dialing_internal, &EndpointAppPBX::action_hangup_call,
 235           PARAM_CONNECT | PARAM_EXTENSION | PARAM_TYPE | PARAM_CAPA | PARAM_BMODE | PARAM_INFO1 | PARAM_HLC | PARAM_EXTHLC | PARAM_PRESENT | PARAM_TIMEOUT,
 236           "Call is routed to intern extension as given by the dialed number or specified by option."},
 237         { ACTION_OUTDIAL,
 238           "outdial",    &EndpointAppPBX::action_init_call, &EndpointAppPBX::action_dialing_external, &EndpointAppPBX::action_hangup_call,
 239           PARAM_CONNECT | PARAM_PREFIX | PARAM_COMPLETE | PARAM_TYPE | PARAM_CAPA | PARAM_BMODE | PARAM_INFO1 | PARAM_HLC | PARAM_EXTHLC | PARAM_PRESENT | PARAM_INTERFACES | PARAM_CALLERID | PARAM_CALLERIDTYPE | PARAM_TIMEOUT,
 240           "Same as 'extern'"},
 241         { ACTION_CHAN,
 242           "asterisk",   &EndpointAppPBX::action_init_chan, &EndpointAppPBX::action_dialing_chan, &EndpointAppPBX::action_hangup_call,
 243           PARAM_CONNECT | PARAM_TIMEOUT,
 244           "Call is routed to Asterisk via channel driver."},
 245         { ACTION_VBOX_RECORD,
 246           "vbox-record",&EndpointAppPBX::action_init_call, &EndpointAppPBX::action_dialing_vbox_record, &EndpointAppPBX::action_hangup_call,
 247           PARAM_CONNECT | PARAM_EXTENSION | PARAM_ANNOUNCEMENT | PARAM_TIMEOUT,
 248           "Caller is routed to the voice box of given extension."},
 249         { ACTION_PARTYLINE,
 250           "partyline",&EndpointAppPBX::action_init_partyline, NULL, &EndpointAppPBX::action_hangup_call,
 251           PARAM_ROOM,
 252           "Caller is participating the conference with the given room number."},
 253         { ACTION_LOGIN,
 254           "login",      NULL, &EndpointAppPBX::action_dialing_login, NULL,
 255           PARAM_CONNECT | PARAM_EXTENSION | PARAM_NOPASSWORD,
 256           "Log into the given extension. Password required."},
 257         { ACTION_CALLERID,
 258           "callerid",   &EndpointAppPBX::action_init_change_callerid, &EndpointAppPBX::action_dialing_callerid, NULL,
 259           PARAM_CONNECT | PARAM_CALLERID | PARAM_CALLERIDTYPE | PARAM_PRESENT,
 260           "Caller changes the caller ID for all calls."},
 261         { ACTION_CALLERIDNEXT,
 262           "calleridnext",&EndpointAppPBX::action_init_change_callerid, &EndpointAppPBX::action_dialing_calleridnext, NULL,
 263           PARAM_CONNECT | PARAM_CALLERID | PARAM_CALLERIDTYPE | PARAM_PRESENT,
 264           "Caller changes the caller ID for the next call."},
 265         { ACTION_FORWARD,
 266           "forward",    &EndpointAppPBX::action_init_change_forward, &EndpointAppPBX::action_dialing_forward, NULL,
 267           PARAM_CONNECT | PARAM_DIVERSION | PARAM_DEST | PARAM_DELAY,
 268           "Caller changes the diversion of given type to the given destination or voice box."},
 269         { ACTION_REDIAL,
 270           "redial",     &EndpointAppPBX::action_init_redial_reply, &EndpointAppPBX::action_dialing_redial, NULL,
 271           PARAM_CONNECT | PARAM_SELECT,
 272           "Caller redials. (last outgoing call(s))"},
 273         { ACTION_REPLY,
 274           "reply",      &EndpointAppPBX::action_init_redial_reply, &EndpointAppPBX::action_dialing_reply, NULL,
 275           PARAM_CONNECT | PARAM_SELECT,
 276           "Caller replies. (last incomming call(s))"},
 277         { ACTION_POWERDIAL,
 278           "powerdial",  NULL, &EndpointAppPBX::action_dialing_powerdial, NULL,
 279           PARAM_CONNECT | PARAM_DELAY | PARAM_LIMIT | PARAM_TIMEOUT,
 280           "Caller redials using powerdialing."},
 281         { ACTION_CALLBACK,
 282           "callback",   NULL, &EndpointAppPBX::action_dialing_callback, &EndpointAppPBX::action_hangup_callback,
 283           PARAM_PROCEEDING | PARAM_ALERTING | PARAM_CONNECT | PARAM_EXTENSION | PARAM_DELAY | PARAM_CALLTO | PARAM_PREFIX,
 284           "Caller will use the callback service. After disconnecting, the callback is triggered."},
 285         { ACTION_ABBREV,
 286           "abbrev",     NULL, &EndpointAppPBX::action_dialing_abbrev, NULL,
 287           PARAM_CONNECT,
 288           "Caller dials abbreviation."},
 289         { ACTION_TEST,
 290           "test",       NULL, &EndpointAppPBX::action_dialing_test, NULL,
 291           PARAM_CONNECT | PARAM_PREFIX | PARAM_TIMEOUT,
 292           "Caller dials test mode."},
 293         { ACTION_PLAY,
 294           "play",       &EndpointAppPBX::action_init_play, NULL, NULL,
 295           PARAM_PROCEEDING | PARAM_ALERTING | PARAM_CONNECT | PARAM_SAMPLE | PARAM_TIMEOUT,
 296           "Plays the given sample."},
 297         { ACTION_VBOX_PLAY,
 298           "vbox-play",  &EndpointAppPBX::action_init_vbox_play, &EndpointAppPBX::action_dialing_vbox_play, NULL,
 299           PARAM_EXTENSION,
 300           "Caller listens to her voice box or to given extension."},
 301         { ACTION_CALCULATOR,
 302           "calculator", NULL, &EndpointAppPBX::action_dialing_calculator, NULL,
 303           PARAM_CONNECT,
 304           "Caller calls the calculator."},
 305         { ACTION_TIMER,
 306           "timer",      NULL, &EndpointAppPBX::action_dialing_timer, NULL,
 307           PARAM_CONNECT | PARAM_TPRESET | PARAM_TIMEOUT,
 308           NULL},
 309 //        "Caller calls the timer."},
 310         { ACTION_GOTO,
 311           "goto",       NULL, &EndpointAppPBX::action_dialing_goto, NULL,
 312           PARAM_CONNECT | PARAM_RULESET | PARAM_SAMPLE,
 313           "Jump to given ruleset and optionally play sample. Dialed digits are not flushed."},
 314         { ACTION_MENU,
 315           "menu",       NULL, &EndpointAppPBX::action_dialing_menu, NULL,
 316           PARAM_CONNECT | PARAM_RULESET | PARAM_SAMPLE,
 317           "Same as 'goto', but flushes all digits dialed so far."},
 318         { ACTION_DISCONNECT,
 319           "disconnect", NULL, &EndpointAppPBX::action_dialing_disconnect, NULL,
 320           PARAM_CONNECT | PARAM_CAUSE | PARAM_LOCATION | PARAM_SAMPLE | PARAM_DISPLAY,
 321           "Caller gets disconnected optionally with given cause and given sample and given display text."},
 322         { ACTION_HELP,
 323           "help",       NULL, &EndpointAppPBX::action_dialing_help, NULL,
 324           PARAM_CONNECT | PARAM_TIMEOUT,
 325           NULL},
 326 //        "Caller will be able to select from current rules that would match. (using * and #)"},
 327         { ACTION_DEFLECT,
 328           "deflect",    NULL, &EndpointAppPBX::action_dialing_deflect, NULL,
 329           PARAM_DEST,
 330           NULL},
 331 //        "External call is deflected to the given destination within the telephone network."},
 332         { ACTION_SETFORWARD,
 333           "setforward", NULL, &EndpointAppPBX::action_dialing_setforward, NULL,
 334           PARAM_CONNECT | PARAM_DIVERSION | PARAM_DEST | PARAM_PORT,
 335           NULL},
 336 //        "The call forward is set within the telephone network of the external line."},
 337         { ACTION_EXECUTE,
 338           "execute",    NULL, NULL, &EndpointAppPBX::action_hangup_execute,
 339           PARAM_CONNECT | PARAM_EXECUTE | PARAM_PARAM,
 340           "Executes the given script file. The file must terminate quickly, because it will halt the PBX."},
 341         { ACTION_FILE,
 342           "file",       NULL, NULL, &EndpointAppPBX::action_hangup_file,
 343           PARAM_CONNECT | PARAM_FILE | PARAM_CONTENT | PARAM_APPEND,
 344           "Writes givent content to given file. If content is not given, the dialed digits are written."},
 345         { ACTION_PICK,
 346           "pick",       &EndpointAppPBX::action_init_pick, NULL, NULL,
 347           PARAM_EXTENSIONS,
 348           "Pick up a call that is ringing on any phone. Extensions may be given to limit the picking ability."},
 349         { ACTION_PASSWORD,
 350           "password",   NULL, &EndpointAppPBX::action_dialing_password, NULL,
 351           0,
 352           NULL},
 353         { ACTION_PASSWORD_WRITE,
 354           "password_wr",NULL, &EndpointAppPBX::action_dialing_password_wr, NULL,
 355           0,
 356           NULL},
 357         { ACTION_NOTHING,
 358           "nothing",    NULL, NULL, NULL,
 359           PARAM_PROCEEDING | PARAM_ALERTING | PARAM_CONNECT | PARAM_TIMEOUT,
 360           "does nothing. Usefull to wait for calls to be released completely, by giving timeout value."},
 361         { ACTION_EFI,
 362           "efi",        &EndpointAppPBX::action_init_efi, NULL, NULL,
 363           PARAM_PROCEEDING | PARAM_ALERTING | PARAM_CONNECT,
 364           "Elektronische Fernsprecher Identifikation."},
 365         { -1,
 366           NULL, NULL, NULL, NULL, 0, NULL}
 367 };
 368
 369
 370 /* display documentation of rules */
 371
 372 void doc_rules(const char *name)
 373 {
 374         int i, j;
 375
 376         if (name)
 377         {
 378                 i = 0;
 379                 while(action_defs[i].name)
 380                 {
 381                         if (!strcasecmp(action_defs[i].name, name))
 382                                 break;
 383                         i++;
 384                 }
 385                 if (!action_defs[i].name)
 386                 {
 387                         fprintf(stderr, "Given action '%s' unknown.\n", name);
 388                         return;
 389                 }
 390                 name = action_defs[i].name;
 391         }
 392
 393         printf("Syntax overview:\n");
 394         printf("----------------\n\n");
 395         printf("[ruleset]\n");
 396         printf("<condition> ...   : <action> [parameter ...]   [timeout=X : <action> ...]\n");
 397         printf("...\n");
 398         printf("Please refer to the documentation for description on rule format.\n\n");
 399
 400         if (!name)
 401         {
 402                 printf("Available conditions to match:\n");
 403                 printf("------------------------------\n\n");
 404                 i = 0;
 405                 while(cond_defs[i].name)
 406                 {
 407                         printf("Usage: %s\n", cond_defs[i].doc);
 408                         printf("%s\n\n", cond_defs[i].help);
 409                         i++;
 410                 }
 411
 412                 printf("Available actions with their parameters:\n");
 413                 printf("----------------------------------------\n\n");
 414         } else
 415         {
 416                 printf("Detailes parameter description of action:\n");
 417                 printf("-----------------------------------------\n\n");
 418         }
 419         i = 0;
 420         while(action_defs[i].name)
 421         {
 422                 if (name && !!strcmp(action_defs[i].name,name)) /* not selected */
 423                 {
 424                         i++;
 425                         continue;
 426                 }
 427                 if (!action_defs[i].help) /* not internal actions */
 428                 {
 429                         i++;
 430                         continue;
 431                 }
 432                 printf("Usage: %s", action_defs[i].name);
 433                 j = 0;
 434                 while(j < 64)
 435                 {
 436                         if ((1LL<<j) & action_defs[i].params)
 437                                 printf(" [%s]", param_defs[j].doc);
 438                         j++;
 439                 }
 440                 printf("\n%s\n\n", action_defs[i].help);
 441                 if (name) /* only show parameter help for specific action */
 442                 {
 443                         j = 0;
 444                         while(j < 64)
 445                         {
 446                                 if ((1LL<<j) & action_defs[i].params)
 447                                         printf("%s:\n\t%s\n", param_defs[j].doc, param_defs[j].help);
 448                                 j++;
 449                         }
 450                         printf("\n");
 451                 }
 452                 i++;
 453         }
 454 }
 455
 456 void ruleset_free(struct route_ruleset *ruleset_start)
 457 {
 458         struct route_ruleset *ruleset;
 459         struct route_rule *rule;
 460         struct route_cond *cond;
 461         struct route_action *action;
 462         struct route_param *param;
 463
 464         while(ruleset_start)
 465         {
 466                 ruleset = ruleset_start;
 467                 ruleset_start = ruleset->next;
 468                 while(ruleset->rule_first)
 469                 {
 470                         rule = ruleset->rule_first;
 471                         ruleset->rule_first = rule->next;
 472                         while(rule->cond_first)
 473                         {
 474                                 cond = rule->cond_first;
 475                                 if (cond->string_value)
 476                                 {
 477                                         free(cond->string_value);
 478                                         rmemuse--;
 479                                 }
 480                                 if (cond->string_value_to)
 481                                 {
 482                                         free(cond->string_value_to);
 483                                         rmemuse--;
 484                                 }
 485                                 rule->cond_first = cond->next;
 486                                 free(cond);
 487                                 rmemuse--;
 488                         }
 489                         while(rule->action_first)
 490                         {
 491                                 action = rule->action_first;
 492                                 rule->action_first = action->next;
 493                                 while(action->param_first)
 494                                 {
 495                                         param = action->param_first;
 496                                         action->param_first = param->next;
 497                                         if (param->string_value)
 498                                         {
 499                                                 free(param->string_value);
 500                                                 rmemuse--;
 501                                         }
 502                                         free(param);
 503                                         rmemuse--;
 504                                 }
 505                                 free(action);
 506                                 rmemuse--;
 507                         }
 508                         free(rule);
 509                         rmemuse--;
 510                 }
 511                 free(ruleset);
 512                 rmemuse--;
 513         }
 514 }
 515
 516 void ruleset_debug(struct route_ruleset *ruleset_start)
 517 {
 518         struct route_ruleset    *ruleset;
 519         struct route_rule       *rule;
 520         struct route_cond       *cond;
 521         struct route_action     *action;
 522         struct route_param      *param;
 523         int                     first;
 524
 525         ruleset = ruleset_start;
 526         while(ruleset)
 527         {
 528                 printf("Ruleset: '%s'\n", ruleset->name);
 529                 rule = ruleset->rule_first;
 530                 while(rule)
 531                 {
 532                         /* CONDITION */
 533                         first = 1;
 534                         cond = rule->cond_first;
 535                         while(cond)
 536                         {
 537                                 if (first)
 538                                         printf("    Condition:");
 539                                 else
 540                                         printf("    and       ");
 541                                 first = 0;
 542                                 printf(" %s", cond_defs[cond->index].name);
 543                                 if (cond->value_type != VALUE_TYPE_NULL)
 544                                         printf(" = ");
 545                                 next_cond_value:
 546                                 switch(cond->value_type)
 547                                 {
 548                                         case VALUE_TYPE_NULL:
 549                                         break;
 550
 551                                         case VALUE_TYPE_INTEGER:
 552                                         printf("%d", cond->integer_value);
 553                                         break;
 554
 555                                         case VALUE_TYPE_INTEGER_RANGE:
 556                                         printf("%d-%d", cond->integer_value, cond->integer_value_to);
 557                                         break;
 558
 559                                         case VALUE_TYPE_STRING:
 560                                         printf("'%s'", cond->string_value);
 561                                         break;
 562
 563                                         case VALUE_TYPE_STRING_RANGE:
 564                                         printf("'%s'-'%s'", cond->string_value, cond->string_value_to);
 565                                         break;
 566
 567                                         default:
 568                                         printf("Software error: VALUE_TYPE_* %d not known in function '%s' line=%d", cond->value_type, __FUNCTION__, __LINE__);
 569                                 }
 570                                 if (cond->value_extension && cond->next)
 571                                 {
 572                                         cond = cond->next;
 573                                         printf(" or ");
 574                                         goto next_cond_value;
 575                                 }
 576
 577                                 cond = cond->next;
 578                                 printf("\n");
 579                         }
 580
 581                         /* ACTION */
 582                         action = rule->action_first;
 583                         while(action)
 584                         {
 585                                 printf("    Action: %s\n", action_defs[action->index].name);
 586                                 /* PARAM */
 587                                 first = 1;
 588                                 param = action->param_first;
 589                                 while(param)
 590                                 {
 591                                         if (first)
 592                                                 printf("    Param:");
 593                                         else
 594                                                 printf("          ");
 595                                         first = 0;
 596                                         printf(" %s", param_defs[param->index].name);
 597                                         if (param->value_type != VALUE_TYPE_NULL)
 598                                                 printf(" = ");
 599                                         switch(param->value_type)
 600                                         {
 601                                                 case VALUE_TYPE_NULL:
 602                                                 break;
 603
 604                                                 case VALUE_TYPE_INTEGER:
 605                                                 if (param_defs[param->index].type == PARAM_TYPE_CALLERIDTYPE)
 606                                                 {
 607                                                         switch(param->integer_value)
 608                                                         {
 609                                                                 case INFO_NTYPE_UNKNOWN:
 610                                                                 printf("unknown");
 611                                                                 break;
 612                                                                 case INFO_NTYPE_SUBSCRIBER:
 613                                                                 printf("subscriber");
 614                                                                 break;
 615                                                                 case INFO_NTYPE_NATIONAL:
 616                                                                 printf("national");
 617                                                                 break;
 618                                                                 case INFO_NTYPE_INTERNATIONAL:
 619                                                                 printf("international");
 620                                                                 break;
 621                                                                 default:
 622                                                                 printf("unknown(%d)", param->integer_value);
 623                                                         }
 624                                                         break;
 625                                                 }
 626                                                 if (param_defs[param->index].type == PARAM_TYPE_CAPABILITY)
 627                                                 {
 628                                                         switch(param->integer_value)
 629                                                         {
 630                                                                 case INFO_BC_SPEECH:
 631                                                                 printf("speech");
 632                                                                 break;
 633                                                                 case INFO_BC_AUDIO:
 634                                                                 printf("audio");
 635                                                                 break;
 636                                                                 case INFO_BC_VIDEO:
 637                                                                 printf("video");
 638                                                                 break;
 639                                                                 case INFO_BC_DATARESTRICTED:
 640                                                                 printf("digital-restricted");
 641                                                                 break;
 642                                                                 case INFO_BC_DATAUNRESTRICTED:
 643                                                                 printf("digital-unrestricted");
 644                                                                 break;
 645                                                                 case INFO_BC_DATAUNRESTRICTED_TONES:
 646                                                                 printf("digital-unrestricted-tones");
 647                                                                 break;
 648                                                                 default:
 649                                                                 printf("unknown(%d)", param->integer_value);
 650                                                         }
 651                                                         break;
 652                                                 }
 653                                                 if (param_defs[param->index].type == PARAM_TYPE_DIVERSION)
 654                                                 {
 655                                                         switch(param->integer_value)
 656                                                         {
 657                                                                 case INFO_DIVERSION_CFU:
 658                                                                 printf("cfu");
 659                                                                 break;
 660                                                                 case INFO_DIVERSION_CFNR:
 661                                                                 printf("cfnr");
 662                                                                 break;
 663                                                                 case INFO_DIVERSION_CFB:
 664                                                                 printf("cfb");
 665                                                                 break;
 666                                                                 case INFO_DIVERSION_CFP:
 667                                                                 printf("cfp");
 668                                                                 break;
 669                                                                 default:
 670                                                                 printf("unknown(%d)", param->integer_value);
 671                                                         }
 672                                                         break;
 673                                                 }
 674                                                 if (param_defs[param->index].type == PARAM_TYPE_TYPE)
 675                                                 {
 676                                                         switch(param->integer_value)
 677                                                         {
 678                                                                 case INFO_NTYPE_UNKNOWN:
 679                                                                 printf("unknown");
 680                                                                 break;
 681                                                                 case INFO_NTYPE_SUBSCRIBER:
 682                                                                 printf("subscriber");
 683                                                                 break;
 684                                                                 case INFO_NTYPE_NATIONAL:
 685                                                                 printf("national");
 686                                                                 break;
 687                                                                 case INFO_NTYPE_INTERNATIONAL:
 688                                                                 printf("international");
 689                                                                 break;
 690                                                                 default:
 691                                                                 printf("unknown(%d)", param->integer_value);
 692                                                         }
 693                                                         break;
 694                                                 }
 695                                                 if (param_defs[param->index].type == PARAM_TYPE_YESNO)
 696                                                 {
 697                                                         switch(param->integer_value)
 698                                                         {
 699                                                                 case 1:
 700                                                                 printf("yes");
 701                                                                 break;
 702                                                                 case 0:
 703                                                                 printf("no");
 704                                                                 break;
 705                                                                 default:
 706                                                                 printf("unknown(%d)", param->integer_value);
 707                                                         }
 708                                                         break;
 709                                                 }
 710                                                 if (param_defs[param->index].type == PARAM_TYPE_NULL)
 711                                                 {
 712                                                         break;
 713                                                 }
 714                                                 printf("%d", param->integer_value);
 715                                                 break;
 716
 717                                                 case VALUE_TYPE_STRING:
 718                                                 printf("'%s'", param->string_value);
 719                                                 break;
 720
 721                                                 default:
 722                                                 printf("Software error: VALUE_TYPE_* %d not known in function '%s' line=%d", param->value_type, __FUNCTION__, __LINE__);
 723                                         }
 724                                         param = param->next;
 725                                         printf("\n");
 726                                 }
 727                                 /* TIMEOUT */
 728                                 if (action->timeout)
 729                                         printf("    Timeout: %d\n", action->timeout);
 730                                 action = action->next;
 731                         }
 732                         printf("\n");
 733                         rule = rule->next;
 734                 }
 735                 printf("\n");
 736                 ruleset = ruleset->next;
 737         }
 738 }
 739
 740
 741 /*
 742  * parse ruleset
 743  */
 744 static char *read_string(char *p, char *key, int key_size, char *special)
 745 {
 746         key[0] = 0;
 747
 748         if (*p == '\"')
 749         {
 750                 p++;
 751                 /* quote */
 752                 while(*p)
 753                 {
 754                         if (*p == '\"')
 755                         {
 756                                 p++;
 757                                 *key = '\0';
 758                                 return(p);
 759                         }
 760                         if (*p == '\\')
 761                         {
 762                                 p++;
 763                                 if (*p == '\0')
 764                                 {
 765                                         break;
 766                                 }
 767                         }
 768                         if (--key_size == 0)
 769                         {
 770                                 UPRINT(key, "\001String too long.");
 771                                 return(p);
 772                         }
 773                         *key++ = *p++;
 774                 }
 775                 UPRINT(key, "\001Unexpected end of line inside quotes.");
 776                 return(p);
 777         }
 778
 779         /* no quote */
 780         while(*p)
 781         {
 782                 if (strchr(special, *p))
 783                 {
 784                         *key = '\0';
 785                         return(p);
 786                 }
 787                 if (*p == '\\')
 788                 {
 789                         p++;
 790                         if (*p == '\0')
 791                         {
 792                                 UPRINT(key, "\001Unexpected end of line.");
 793                                 return(p);
 794                         }
 795                 }
 796                 if (--key_size == 0)
 797                 {
 798                         UPRINT(key, "\001String too long.");
 799                         return(p);
 800                 }
 801                 *key++ = *p++;
 802         }
 803         *key = '\0';
 804         return(p);
 805 }
 806 char ruleset_error[256];
 807 struct route_ruleset *ruleset_parse(void)
 808 {
 809 //      char                    from[128];
 810 //      char                    to[128];
 811         int                     i;
 812         unsigned long long      j;
 813 //      int                     a,
 814 //                              b;
 815         #define                 MAXNESTING 8
 816         FILE                    *fp[MAXNESTING];
 817         char                    filename[MAXNESTING][256];
 818         int                     line[MAXNESTING];
 819         int                     nesting = -1;
 820         char                    buffer[1024],
 821                                 key[1024],
 822                                 key_to[1024],
 823                                 pointer[1024+1],
 824                                 *p;
 825         int                     expecting = 1; /* 1 = expecting ruleset */
 826         int                     index,
 827                                 value_type,
 828                                 integer,
 829                                 integer_to; /* condition index, .. */
 830         struct route_ruleset    *ruleset_start = NULL, *ruleset;
 831         struct route_ruleset    **ruleset_pointer = &ruleset_start;
 832         struct route_rule       *rule;
 833         struct route_rule       **rule_pointer = NULL;
 834         struct route_cond       *cond;
 835         struct route_cond       **cond_pointer = NULL;
 836         struct route_action     *action;
 837         struct route_action     **action_pointer = NULL;
 838         struct route_param      *param;
 839         struct route_param      **param_pointer = NULL;
 840         char                    failure[256];
 841
 842         /* check the integrity of IDs for ACTION_* and PARAM_* */
 843         i = 0;
 844         while(action_defs[i].name)
 845         {
 846                 if (action_defs[i].id != i)
 847                 {
 848                         PERROR("Software Error action '%s' must have id of %d, but has %d.\n",
 849                                 action_defs[i].name, i, action_defs[i].id);
 850                         goto openerror;
 851                 }
 852                 i++;
 853         }
 854         i = 0; j = 1;
 855         while(param_defs[i].name)
 856         {
 857                 if (param_defs[i].id != j)
 858                 {
 859                         PERROR("Software Error param '%s' must have id of 0x%llx, but has 0x%llx.\n",
 860                                 param_defs[i].name, j, param_defs[i].id);
 861                         goto openerror;
 862                 }
 863                 i++;
 864                 j<<=1;
 865         }
 866
 867         SPRINT(filename[0], "%s/routing.conf", INSTALL_DATA);
 868
 869         if (!(fp[0]=fopen(filename[0],"r")))
 870         {
 871                 PERROR("Cannot open %s\n",filename[0]);
 872                 goto openerror;
 873         }
 874         nesting++;
 875         fduse++;
 876
 877         go_leaf:
 878         line[nesting]=0;
 879         go_root:
 880         while((fgets(buffer,sizeof(buffer),fp[nesting])))
 881         {
 882                 line[nesting]++;
 883                 buffer[sizeof(buffer)-1]=0;
 884                 if (buffer[0]) buffer[strlen(buffer)-1]=0;
 885                 p = buffer;
 886
 887                 /* remove tabs */
 888                 while(*p) {
 889                         if (*p < 32)
 890                                 *p = 32;
 891                         p++;
 892                 }
 893                 p = buffer;
 894
 895                 /* skip spaces, if any */
 896                 while(*p == 32)
 897                 {
 898                         if (*p == 0)
 899                                 break;
 900                         p++;
 901                 }
 902
 903                 /* skip comments */
 904                 if (*p == '#')
 905                 {
 906                         p++;
 907                         /* don't skip "define" */
 908                         if (!!strncmp(p, "define", 6))
 909                                 continue;
 910                         p+=6;
 911                         if (*p != 32)
 912                                 continue;
 913                         /* skip spaces */
 914                         while(*p == 32)
 915                         {
 916                                 if (*p == 0)
 917                                         break;
 918                                 p++;
 919                         }
 920                         p++;
 921                         p = read_string(p, key, sizeof(key), " ");
 922                         if (key[0] == 1) /* error */
 923                         {
 924                                 SPRINT(failure, "Parsing Filename failed: %s", key+1);
 925                                 goto parse_error;
 926                         }
 927                         if (nesting == MAXNESTING-1)
 928                         {
 929                                 SPRINT(failure, "'include' is nesting too deep.\n");
 930                                 goto parse_error;
 931                         }
 932                         if (key[0] == '/')
 933                                 SCPY(filename[nesting+1], key);
 934                         else
 935                                 SPRINT(filename[nesting+1], "%s/%s", INSTALL_DATA, key);
 936                         if (!(fp[nesting+1]=fopen(filename[nesting+1],"r")))
 937                         {
 938                                 PERROR("Cannot open %s\n", filename[nesting+1]);
 939                                 goto parse_error;
 940                         }
 941                         fduse++;
 942                         nesting++;
 943                         goto go_leaf;
 944                 }
 945                 if (*p == '/') if (p[1] == '/')
 946                         continue;
 947
 948                 /* skip empty lines */
 949                 if (*p == 0)
 950                         continue;
 951
 952                 /* expecting ruleset */
 953                 if (expecting)
 954                 {
 955                         new_ruleset:
 956                         /* expecting [ */
 957                         if (*p != '[')
 958                         {
 959                                 SPRINT(failure, "Expecting ruleset name starting with '['.");
 960                                 goto parse_error;
 961                         }
 962                         p++;
 963
 964                         /* reading ruleset name text */
 965                         i = 0;
 966                         while((*p>='a' && *p<='z') || (*p>='A' && *p<='Z') || (*p>='0' && *p<='9'))
 967                         {
 968                                 if (*p>='A' && *p<='Z') *p = *p-'A'+'a'; /* lower case */
 969                                 key[i++] = *p++;
 970                                 if (i == sizeof(key)) i--; /* limit */
 971                         }
 972                         key[i] = 0;
 973                         if (key[0] == '\0') {
 974                                 SPRINT(failure, "Missing ruleset name after '['.");
 975                                 goto parse_error;
 976                         }
 977
 978                         /* expecting ] and nothing more */
 979                         if (*p != ']') {
 980                                 SPRINT(failure, "Expecting ']' after ruleset name.");
 981                                 goto parse_error;
 982                         }
 983                         p++;
 984                         if (*p != 0) {
 985                                 SPRINT(failure, "Unexpected character after ruleset name.");
 986                                 goto parse_error;
 987                         }
 988
 989                         /* check for duplicate rulesets */
 990                         ruleset = ruleset_start;
 991                         while(ruleset)
 992                         {
 993                                 if (!strcmp(ruleset->name, key))
 994                                 {
 995                                         SPRINT(failure, "Duplicate ruleset '%s', already defined in file '%s' line %d.", key, ruleset->file, ruleset->line);
 996                                         goto parse_error;
 997                                 }
 998                                 ruleset = ruleset->next;
 999                         }
1000
1001                         /* create ruleset */
1002                         ruleset = (struct route_ruleset *)malloc(sizeof(struct route_ruleset));
1003                         if (ruleset == NULL)
1004                         {
1005                                 SPRINT(failure, "Out of memory.");
1006                                 goto parse_error;
1007                         }
1008                         rmemuse++;
1009                         memset(ruleset, 0, sizeof(struct route_ruleset));
1010                         *ruleset_pointer = ruleset;
1011                         ruleset_pointer = &(ruleset->next);
1012                         SCPY(ruleset->name, key);
1013                         SCPY(ruleset->file, filename[nesting]);
1014                         ruleset->line = line[nesting];
1015                         rule_pointer = &(ruleset->rule_first);
1016                         expecting = 0;
1017                         continue;
1018                 }
1019
1020                 /* for new ruleset [ */
1021                 if (*p == '[')
1022                 {
1023                         goto new_ruleset;
1024                 }
1025
1026                 /* alloc memory for rule */
1027                 rule = (struct route_rule *)malloc(sizeof(struct route_rule));
1028                 if (rule == NULL)
1029                 {
1030                         SPRINT(failure, "Out of memory.");
1031                         goto parse_error;
1032                 }
1033                 rmemuse++;
1034                 memset(rule, 0, sizeof(struct route_rule));
1035                 *rule_pointer = rule;
1036                 rule_pointer = &(rule->next);
1037                 cond_pointer = &(rule->cond_first);
1038                 action_pointer = &(rule->action_first);
1039                 SCPY(rule->file, filename[nesting]);
1040                 rule->line = line[nesting];
1041
1042                 /* loop CONDITIONS */
1043                 while(*p!=':' && *p!='\0')
1044                 {
1045                         /* read item text */
1046                         i = 0;
1047                         while((*p>='a' && *p<='z') || (*p>='A' && *p<='Z') || (*p>='0' && *p<='9'))
1048                         {
1049                                 if (*p>='A' && *p<='Z') *p = *p-'A'+'a'; /* lower case */
1050                                 key[i++] = *p++;
1051                                 if (i == sizeof(key)) i--; /* limit */
1052                         }
1053                         key[i] = 0;
1054                         if (key[0] == '\0')
1055                         {
1056                                 SPRINT(failure, "Expecting condition item name or ':' for end of condition list.");
1057                                 goto parse_error;
1058                         }
1059                         if (*p!=' ' && *p!='=')
1060                         {
1061                                 SPRINT(failure, "Illegal character '%c' after condition name '%s'. Expecting '=' for equation or ' ' to seperate condition items.", *p, key);
1062                                 goto parse_error;
1063                         }
1064
1065                         /* check if condition exists */
1066                         index = 0;
1067                         while(cond_defs[index].name)
1068                         {
1069                                 if (!strcmp(cond_defs[index].name, key))
1070                                         break;
1071                                 index++;
1072                         }
1073                         if (cond_defs[index].name == NULL)
1074                         {
1075                                 SPRINT(failure, "Unknown condition item name '%s'.", key);
1076                                 goto parse_error;
1077                         }
1078
1079                         /* items without values must not have any parameter */
1080                         if (cond_defs[index].type == COND_TYPE_NULL)
1081                         {
1082                                 if (*p == '=')
1083                                 {
1084                                         SPRINT(failure, "Condition item '%s' must not have any value. Don't use '=' for this type of condition.", key);
1085                                         goto parse_error;
1086                                 }
1087                                 if (*p != ' ')
1088                                 {
1089                                         SPRINT(failure, "Condition item '%s' must not have any value. Expecting ' ' or tab after item name.", key);
1090                                         goto parse_error;
1091                                 }
1092 //                              p++;
1093                         } else
1094                         {
1095                                 if (*p == ' ')
1096                                 {
1097                                         SPRINT(failure, "Condition item '%s' must have at least one value, '=' expected, and not a space.", key);
1098                                         goto parse_error;
1099                                 }
1100                                 if (*p != '=')
1101                                 {
1102                                         SPRINT(failure, "Condition item '%s' must have at least one value, '=' expected.", key);
1103                                         goto parse_error;
1104                                 }
1105                                 p++;
1106                         }
1107
1108                         /* check for duplicate condition */
1109                         cond = rule->cond_first;
1110                         while(cond)
1111                         {
1112                                 if (cond->index == index)
1113                                 {
1114                                         SPRINT(failure, "Duplicate condition '%s', use ',' to give multiple values.", key);
1115                                         goto parse_error;
1116                                 }
1117                                 cond = cond->next;
1118                         }
1119
1120                         nextcondvalue:
1121                         /* alloc memory for item */
1122                         cond = (struct route_cond *)malloc(sizeof(struct route_cond));
1123                         if (cond == NULL)
1124                         {
1125                                 SPRINT(failure, "Out of memory.");
1126                                 goto parse_error;
1127                         }
1128                         rmemuse++;
1129                         memset(cond, 0, sizeof(struct route_cond));
1130                         *cond_pointer = cond;
1131                         cond_pointer = &(cond->next);
1132                         cond->index = index;
1133                         cond->match = cond_defs[index].match;
1134                         switch(cond_defs[index].type)
1135                         {
1136                                 case COND_TYPE_NULL:
1137                                 if (*p=='=')
1138                                 {
1139                                         SPRINT(failure, "Expecting no value.");
1140                                         goto parse_error;
1141                                 }
1142                                 value_type = VALUE_TYPE_NULL;
1143                                 break;
1144
1145                                 /* parse all integer values/ranges */
1146                                 case COND_TYPE_INTEGER:
1147                                 case COND_TYPE_TIME:
1148                                 case COND_TYPE_MDAY:
1149                                 case COND_TYPE_MONTH:
1150                                 case COND_TYPE_WDAY:
1151                                 case COND_TYPE_YEAR:
1152                                 integer = integer_to = 0;
1153                                 if (*p==',' || *p==' ' || *p=='\0')
1154                                 {
1155                                         SPRINT(failure, "Missing integer value.");
1156                                         goto parse_error;
1157                                 }
1158                                 while(*p>='0' && *p<='9')
1159                                 {
1160                                         integer = integer*10 + *p-'0';
1161                                         p++;
1162                                 }
1163                                 value_type = VALUE_TYPE_INTEGER;
1164                                 if (*p == '-')
1165                                 {
1166                                         p++;
1167                                         if (*p==',' || *p==' ' || *p=='\0')
1168                                         {
1169                                                 SPRINT(failure, "Missing integer value.");
1170                                                 goto parse_error;
1171                                         }
1172                                         while(*p>='0' && *p<='9')
1173                                         {
1174                                                 integer_to = integer_to*10 + *p-'0';
1175                                                 p++;
1176                                         }
1177                                         value_type = VALUE_TYPE_INTEGER_RANGE;
1178                                 }
1179                                 if (cond_defs[index].type == COND_TYPE_TIME)
1180                                 {
1181                                         // Simon: i store the time as decimal, later i compare it correctly:
1182                                         // hours * 100 + minutes
1183                                         if (integer == 2400)
1184                                                 integer = 0;
1185                                         if (integer >= 2400)
1186                                         {
1187                                                 timeoutofrange1:
1188                                                 SPRINT(failure, "Given time '%d' not in range 0000..2359 (or 2400 for 0000)", integer);
1189                                                 goto parse_error;
1190                                         }
1191                                         if (integer%100 >= 60)
1192                                                 goto timeoutofrange1;
1193                                         if (value_type == VALUE_TYPE_INTEGER)
1194                                                 goto integer_done;
1195                                         if (integer_to == 2400)
1196                                                 integer_to = 0;
1197                                         if (integer_to >= 2400)
1198                                         {
1199                                                 timeoutofrange2:
1200                                                 SPRINT(failure, "Given time '%d' not in range 0000..2359 (or 2400 for 0000)", integer_to);
1201                                                 goto parse_error;
1202                                         }
1203                                         if (integer_to%100 >= 60)
1204                                                 goto timeoutofrange2;
1205                                 }
1206                                 if (cond_defs[index].type == COND_TYPE_MDAY)
1207                                 {
1208                                         if (integer<1 || integer>31)
1209                                         {
1210                                                 SPRINT(failure, "Given day-of-month '%d' not in range 1..31", integer);
1211                                                 goto parse_error;
1212                                         }
1213                                         if (value_type == VALUE_TYPE_INTEGER)
1214                                                 goto integer_done;
1215                                         if (integer_to<1 || integer_to>31)
1216                                         {
1217                                                 SPRINT(failure, "Given day-of-month '%d' not in range 1..31", integer_to);
1218                                                 goto parse_error;
1219                                         }
1220                                 }
1221                                 if (cond_defs[index].type == COND_TYPE_WDAY)
1222                                 {
1223                                         if (integer<1 || integer>7)
1224                                         {
1225                                                 SPRINT(failure, "Given day-of-week '%d' not in range 1..7", integer);
1226                                                 goto parse_error;
1227                                         }
1228                                         if (value_type == VALUE_TYPE_INTEGER)
1229                                                 goto integer_done;
1230                                         if (integer_to<1 || integer_to>7)
1231                                         {
1232                                                 SPRINT(failure, "Given day-of-week '%d' not in range 1..7", integer_to);
1233                                                 goto parse_error;
1234                                         }
1235                                 }
1236                                 if (cond_defs[index].type == COND_TYPE_MONTH)
1237                                 {
1238                                         if (integer<1 || integer>12)
1239                                         {
1240                                                 SPRINT(failure, "Given month '%d' not in range 1..12", integer);
1241                                                 goto parse_error;
1242                                         }
1243                                         if (value_type == VALUE_TYPE_INTEGER)
1244                                                 goto integer_done;
1245                                         if (integer_to<1 || integer_to>12)
1246                                         {
1247                                                 SPRINT(failure, "Given month '%d' not in range 1..12", integer_to);
1248                                                 goto parse_error;
1249                                         }
1250                                 }
1251                                 if (cond_defs[index].type == COND_TYPE_YEAR)
1252                                 {
1253                                         if (integer<1970 || integer>2106)
1254                                         {
1255                                                 SPRINT(failure, "Given year '%d' not in range 1970..2106", integer);
1256                                                 goto parse_error;
1257                                         }
1258                                         if (value_type == VALUE_TYPE_INTEGER)
1259                                                 goto integer_done;
1260                                         if (integer_to<1970 || integer_to>2106)
1261                                         {
1262                                                 SPRINT(failure, "Given year '%d' not in range 1970..2106", integer_to);
1263                                                 goto parse_error;
1264                                         }
1265                                 }
1266                                 integer_done:
1267                                 cond->integer_value = integer;
1268                                 cond->integer_value_to = integer_to;
1269                                 cond->value_type = value_type;
1270                                 break;
1271
1272                                 /* parse all string values/ranges */
1273                                 case COND_TYPE_STRING:
1274                                 key[0] = key_to[0] = '\0';
1275                                 if (*p==',' || *p==' ' || *p=='\0')
1276                                 {
1277                                         SPRINT(failure, "Missing string value, use \"\" for empty string.");
1278                                         goto parse_error;
1279                                 }
1280                                 p = read_string(p, key, sizeof(key), "-, ");
1281                                 if (key[0] == 1) /* error */
1282                                 {
1283                                         SPRINT(failure, "Parsing String failed: %s", key+1);
1284                                         goto parse_error;
1285                                 }
1286                                 value_type = VALUE_TYPE_STRING;
1287                                 if (*p == '-')
1288                                 {
1289                                         p++;
1290                                         if (*p==',' || *p==' ' || *p=='\0')
1291                                         {
1292                                                 SPRINT(failure, "Missing string value, use \"\" for empty string.");
1293                                                 goto parse_error;
1294                                         }
1295                                         p = read_string(p, key_to, sizeof(key_to), "-, ");
1296                                         if (key_to[0] == 1) /* error */
1297                                         {
1298                                                 SPRINT(failure, "Parsing string failed: %s", key_to+1);
1299                                                 goto parse_error;
1300                                         }
1301                                         value_type = VALUE_TYPE_STRING_RANGE;
1302                                         if (strlen(key) != strlen(key_to))
1303                                         {
1304                                                 SPRINT(failure, "Given range of strings \"%s\"-\"%s\" have unequal length.", key, key_to);
1305                                                 goto parse_error;
1306                                         }
1307                                         if (key[0] == '\0')
1308                                         {
1309                                                 SPRINT(failure, "Given range has no length.");
1310                                                 goto parse_error;
1311                                         }
1312                                 }
1313                                 alloc_string:
1314                                 cond->string_value = (char *)malloc(strlen(key)+1);
1315                                 if (cond->string_value == NULL)
1316                                 {
1317                                         SPRINT(failure, "Out of memory.");
1318                                         goto parse_error;
1319                                 }
1320                                 rmemuse++;
1321                                 UCPY(cond->string_value, key);
1322                                 if (value_type == VALUE_TYPE_STRING_RANGE)
1323                                 {
1324                                         cond->string_value_to = (char *)malloc(strlen(key_to)+1);
1325                                         if (cond->string_value_to == NULL)
1326                                         {
1327                                                 SPRINT(failure, "Out of memory.");
1328                                                 goto parse_error;
1329                                         }
1330                                         rmemuse++;
1331                                         UCPY(cond->string_value_to, key_to);
1332                                         cond->comp_string = strcmp(key, key_to);
1333                                 }
1334                                 cond->value_type = value_type;
1335                                 break;
1336
1337                                 /* parse service value */
1338                                 case COND_TYPE_CAPABILITY:
1339                                 if (!strncasecmp("speech", p, 6))
1340                                         cond->integer_value = INFO_BC_SPEECH;
1341                                 else if (!strncasecmp("audio", p, 5))
1342                                         cond->integer_value = INFO_BC_AUDIO;
1343                                 else if (!strncasecmp("video", p, 5))
1344                                         cond->integer_value = INFO_BC_VIDEO;
1345                                 else if (!strncasecmp("digital-restricted", p, 18))
1346                                         cond->integer_value = INFO_BC_DATARESTRICTED;
1347                                 else if (!strncasecmp("digital-unrestricted", p, 20))
1348                                         cond->integer_value = INFO_BC_DATAUNRESTRICTED;
1349                                 else if (!strncasecmp("digital-unrestricted-tones", p, 26))
1350                                         cond->integer_value = INFO_BC_DATAUNRESTRICTED_TONES;
1351                                 else
1352                                 {
1353                                         SPRINT(failure, "Given service type is invalid or misspelled.");
1354                                         goto parse_error;
1355                                 }
1356                                 cond->value_type = VALUE_TYPE_INTEGER;
1357                                 break;
1358
1359                                 /* parse bmode value */
1360                                 case COND_TYPE_BMODE:
1361                                 if (!strncasecmp("transparent", p, 11))
1362                                         cond->integer_value = INFO_BMODE_CIRCUIT;
1363                                 else if (!strncasecmp("hdlc", p, 4))
1364                                         cond->integer_value = INFO_BMODE_PACKET;
1365                                 else
1366                                 {
1367                                         SPRINT(failure, "Given bchannel mode is invalid or misspelled.");
1368                                         goto parse_error;
1369                                 }
1370                                 cond->value_type = VALUE_TYPE_INTEGER;
1371                                 break;
1372
1373                                 /* parse interface attribute <if>:<value> */
1374                                 case COND_TYPE_IFATTR:
1375                                 key[0] = key_to[0] = '\0';
1376                                 if (*p==':' || *p==',' || *p==' ' || *p=='\0')
1377                                 {
1378                                         SPRINT(failure, "Missing interface name.");
1379                                         goto parse_error;
1380                                 }
1381                                 p = read_string(p, key, sizeof(key), ":-, ");
1382                                 if (key[0] == 1) /* error */
1383                                 {
1384                                         SPRINT(failure, "Parsing interface failed: %s", key+1);
1385                                         goto parse_error;
1386                                 }
1387                                 if (*p != ':')
1388                                 {
1389                                         SPRINT(failure, "Expeciting kolon to seperate value behind interface name.");
1390                                         goto parse_error;
1391                                 }
1392                                 SCCAT(key, *p++);
1393                                 while(*p>='0' && *p<='9')
1394                                 {
1395                                         SCCAT(key, *p++);
1396                                 }
1397                                 if (*p!=',' && *p!=' ' && *p!='\0')
1398                                 {
1399                                         SPRINT(failure, "Invalid characters behind value.");
1400                                         goto parse_error;
1401                                 }
1402                                 value_type = VALUE_TYPE_STRING;
1403                                 goto alloc_string;
1404                                 break;
1405
1406                                 default:
1407                                 SPRINT(failure, "Software error: COND_TYPE_* %d not parsed in function '%s'", cond_defs[index].type, __FUNCTION__);
1408                                 goto parse_error;
1409                         }
1410                         /* if we have another value for that item, we attach it */
1411                         if (*p == ',')
1412                         {
1413                                 p++;
1414                                 /* next item */
1415                                 cond->value_extension = 1;
1416                                 goto nextcondvalue;
1417                         }
1418                         /* to seperate the items, a space is required */
1419                         if (*p != ' ')
1420                         {
1421                                 SPRINT(failure, "Character '%c' not expected here. Use ',' to seperate multiple possible values.", *p);
1422                                 goto parse_error;
1423                         }
1424                         /* skip spaces */
1425                         while(*p == 32)
1426                         {
1427                                 if (*p == 0)
1428                                         break;
1429                                 p++;
1430                         }
1431                 }
1432
1433                 /* we are done with CONDITIONS, so we expect the ACTION */
1434                 if (*p != ':')
1435                 {
1436                         SPRINT(failure, "Expecting ':' after condition item(s).");
1437                         goto parse_error;
1438                 }
1439                 p++;
1440
1441                 nextaction:
1442                 /* skip spaces, if any */
1443                 while(*p == 32)
1444                 {
1445                         if (*p == 0)
1446                                 break;
1447                         p++;
1448                 }
1449
1450                 /* read action name */
1451                 i = 0;
1452                 while((*p>='a' && *p<='z') || (*p>='A' && *p<='Z') || (*p>='0' && *p<='9') || *p == '-')
1453                 {
1454                         if (*p>='A' && *p<='Z') *p = *p-'A'+'a'; /* lower case */
1455                         key[i++] = *p++;
1456                         if (i == sizeof(key)) i--; /* limit */
1457                 }
1458                 key[i] = 0;
1459                 if (key[0] == '\0') {
1460                         SPRINT(failure, "Expecting action name.");
1461                         goto parse_error;
1462                 }
1463
1464                 /* check if item exists */
1465                 index = 0;
1466                 while(action_defs[index].name)
1467                 {
1468                         if (!action_defs[index].help) /* not internal actions */
1469                         {
1470                                 index++;
1471                                 continue;
1472                         }
1473                         if (!strcmp(action_defs[index].name, key))
1474                                 break;
1475                         index++;
1476                 }
1477                 if (action_defs[index].name == NULL)
1478                 {
1479                         SPRINT(failure, "Unknown action name '%s'.", key);
1480                         goto parse_error;
1481                 }
1482
1483                 /* alloc memory for action */
1484                 action = (struct route_action *)malloc(sizeof(struct route_action));
1485                 if (action == NULL)
1486                 {
1487                         SPRINT(failure, "Out of memory.");
1488                         goto parse_error;
1489                 }
1490                 rmemuse++;
1491                 memset(action, 0, sizeof(struct route_action));
1492                 *action_pointer = action;
1493                 action_pointer = &(action->next);
1494                 param_pointer = &(action->param_first);
1495                 action->index = index;
1496                 action->line = line[nesting];
1497
1498                 /* skip spaces after param name */
1499                 while(*p == 32)
1500                 {
1501                         if (*p == 0)
1502                                 break;
1503                         p++;
1504                 }
1505
1506                 /* loop PARAMS */
1507                 while(*p != 0)
1508                 {
1509                         /* read param text */
1510                         i = 0;
1511                         while((*p>='a' && *p<='z') || (*p>='A' && *p<='Z') || (*p>='0' && *p<='9'))
1512                         {
1513                                 if (*p>='A' && *p<='Z') *p = *p-'A'+'a'; /* lower case */
1514                                 key[i++] = *p++;
1515                                 if (i == sizeof(key)) i--; /* limit */
1516                         }
1517                         key[i] = 0;
1518                         if (key[0] == '\0') {
1519                                 SPRINT(failure, "Expecting parameter name.");
1520                                 goto parse_error;
1521                         }
1522
1523                         /* check if item exists */
1524                         index = 0;
1525                         while(param_defs[index].name)
1526                         {
1527                                 if (!strcmp(param_defs[index].name, key))
1528                                         break;
1529                                 index++;
1530                         }
1531                         if (param_defs[index].name == NULL)
1532                         {
1533                                 SPRINT(failure, "Unknown param name '%s'.", key);
1534                                 goto parse_error;
1535                         }
1536
1537                         /* params without values must not have any parameter */
1538                         if (param_defs[index].type == PARAM_TYPE_NULL)
1539                         {
1540                                 if (*p!=' ' && *p!='\0')
1541                                 {
1542                                         SPRINT(failure, "Parameter '%s' must not have any value.", key);
1543                                         goto parse_error;
1544                                 }
1545                         } else
1546                         {
1547                                 if (*p == ' ')
1548                                 {
1549                                         SPRINT(failure, "Parameter '%s' must have at least one value, '=' expected and not a space.", key);
1550                                         goto parse_error;
1551                                 }
1552                                 if (*p != '=')
1553                                 {
1554                                         SPRINT(failure, "Parameter '%s' must have at least one value, '=' expected.", key);
1555                                         goto parse_error;
1556                                 }
1557                                 p++;
1558                         }
1559
1560                         /* special timeout value */
1561                         if (!strcmp("timeout", key))
1562                         {
1563                                 if (action->timeout)
1564                                 {
1565                                         SPRINT(failure, "Duplicate timeout value.");
1566                                         goto parse_error;
1567                                 }
1568                                 if (*p==',' || *p==' ' || *p=='\0')
1569                                 {
1570                                         SPRINT(failure, "Missing integer value.");
1571                                         goto parse_error;
1572                                 }
1573                                 integer = 0;
1574                                 while(*p>='0' && *p<='9')
1575                                 {
1576                                         integer = integer*10 + *p-'0';
1577                                         p++;
1578                                 }
1579                                 if (integer < 1)
1580                                 {
1581                                         SPRINT(failure, "Expecting timeout value greater 0.");
1582                                         goto parse_error;
1583                                 }
1584                                 if (*p!=' ' && *p!='\0')
1585                                 {
1586                                         SPRINT(failure, "Character '%c' not expected here. Use ' ' to seperate parameters.", *p);
1587                                         goto parse_error;
1588                                 }
1589                                 /* skip spaces */
1590                                 while(*p == 32)
1591                                 {
1592                                         if (*p == 0)
1593                                                 break;
1594                                         p++;
1595                                 }
1596                                 action->timeout = integer;
1597                                 /* check for next ACTION */
1598                                 if (*p == ':')
1599                                 {
1600                                         p++;
1601                                         goto nextaction;
1602                                 }
1603                                 continue;
1604                         }
1605
1606                         /* check for duplicate parameters */
1607                         param = action->param_first;
1608                         while(param)
1609                         {
1610                                 if (param->index == index)
1611                                 {
1612                                         SPRINT(failure, "Duplicate parameter '%s', use ',' to give multiple values.", key);
1613                                         goto parse_error;
1614                                 }
1615                                 param = param->next;
1616                         }
1617
1618                         nextparamvalue:
1619                         /* alloc memory for param */
1620                         param = (struct route_param *)malloc(sizeof(struct route_param));
1621                         if (param == NULL)
1622                         {
1623                                 SPRINT(failure, "Out of memory.");
1624                                 goto parse_error;
1625                         }
1626                         rmemuse++;
1627                         memset(param, 0, sizeof(struct route_param));
1628                         *param_pointer = param;
1629                         param_pointer = &(param->next);
1630                         param->index = index;
1631                         param->id = param_defs[index].id;
1632
1633                         switch(param_defs[index].type)
1634                         {
1635                                 /* parse null value */
1636                                 case PARAM_TYPE_NULL:
1637                                 param->value_type = VALUE_TYPE_NULL;
1638                                 break;
1639
1640                                 /* parse integer value */
1641                                 case PARAM_TYPE_INTEGER:
1642                                 integer = 0;
1643                                 if (*p==',' || *p==' ' || *p=='\0')
1644                                 {
1645                                         SPRINT(failure, "Missing integer value.");
1646                                         goto parse_error;
1647                                 }
1648                                 while(*p>='0' && *p<='9')
1649                                 {
1650                                         integer = integer*10 + *p-'0';
1651                                         p++;
1652                                 }
1653                                 param->integer_value = integer;
1654                                 param->value_type = VALUE_TYPE_INTEGER;
1655                                 break;
1656
1657 #if 0
1658                                 /* parse ports value */
1659                                 case PARAM_TYPE_PORTS:
1660                                 key[0] = '\0';
1661                                 if (*p==',' || *p==' ' || *p=='\0')
1662                                 {
1663                                         SPRINT(failure, "Missing port number, omit parameter or give port number.");
1664                                         goto parse_error;
1665                                 }
1666                                 i = 0;
1667                                 nextport:
1668                                 integer = 0;
1669                                 while(*p>='0' && *p<='9')
1670                                 {
1671                                         if (i < (int)sizeof(key)-1)
1672                                         {
1673                                                 key[i] = *p;
1674                                                 key[i++] = '\0';
1675                                         }
1676                                         integer = integer*10 + *p-'0';
1677                                         p++;
1678                                 }
1679                                 if (integer > 255)
1680                                 {
1681                                         SPRINT(failure, "Port number too high.");
1682                                         goto parse_error;
1683                                 }
1684                                 if (*p==',')
1685                                 {
1686                                         if (i < (int)sizeof(key)-1)
1687                                         {
1688                                                 key[i] = *p;
1689                                                 key[i++] = '\0';
1690                                         }
1691                                         p++;
1692                                         goto nextport;
1693                                 }
1694                                 goto mallocstring;
1695 #endif
1696
1697                                 /* parse string value */
1698                                 case PARAM_TYPE_STRING:
1699                                 case PARAM_TYPE_CALLERIDTYPE:
1700                                 case PARAM_TYPE_CAPABILITY:
1701                                 case PARAM_TYPE_BMODE:
1702                                 case PARAM_TYPE_DIVERSION:
1703                                 case PARAM_TYPE_DESTIN:
1704                                 case PARAM_TYPE_TYPE:
1705                                 case PARAM_TYPE_YESNO:
1706                                 key[0] = '\0';
1707                                 if (*p==',' || *p==' ' || *p=='\0')
1708                                 {
1709                                         SPRINT(failure, "Missing string value, use \"\" for empty string.");
1710                                         goto parse_error;
1711                                 }
1712                                 p = read_string(p, key, sizeof(key), " ");
1713                                 if (key[0] == 1) /* error */
1714                                 {
1715                                         SPRINT(failure, "Parsing string failed: %s", key+1);
1716                                         goto parse_error;
1717                                 }
1718                                 if (param_defs[index].type == PARAM_TYPE_CALLERIDTYPE)
1719                                 {
1720                                         param->value_type = VALUE_TYPE_INTEGER;
1721                                         if (!strcasecmp(key, "unknown"))
1722                                         {
1723                                                 param->integer_value = INFO_NTYPE_UNKNOWN;
1724                                                 break;
1725                                         }
1726                                         if (!strcasecmp(key, "subscriber"))
1727                                         {
1728                                                 param->integer_value = INFO_NTYPE_SUBSCRIBER;
1729                                                 break;
1730                                         }
1731                                         if (!strcasecmp(key, "national"))
1732                                         {
1733                                                 param->integer_value = INFO_NTYPE_NATIONAL;
1734                                                 break;
1735                                         }
1736                                         if (!strcasecmp(key, "international"))
1737                                         {
1738                                                 param->integer_value = INFO_NTYPE_INTERNATIONAL;
1739                                                 break;
1740                                         }
1741                                         SPRINT(failure, "Caller ID type '%s' unknown.", key);
1742                                         goto parse_error;
1743                                 }
1744                                 if (param_defs[index].type == PARAM_TYPE_CAPABILITY)
1745                                 {
1746                                         param->value_type = VALUE_TYPE_INTEGER;
1747                                         if (!strcasecmp(key, "speech"))
1748                                         {
1749                                                 param->integer_value = INFO_BC_SPEECH;
1750                                                 break;
1751                                         }
1752                                         if (!strcasecmp(key, "audio"))
1753                                         {
1754                                                 param->integer_value = INFO_BC_AUDIO;
1755                                                 break;
1756                                         }
1757                                         if (!strcasecmp(key, "video"))
1758                                         {
1759                                                 param->integer_value = INFO_BC_VIDEO;
1760                                                 break;
1761                                         }
1762                                         if (!strcasecmp(key, "digital-restricted"))
1763                                         {
1764                                                 param->integer_value = INFO_BC_DATARESTRICTED;
1765                                                 break;
1766                                         }
1767                                         if (!strcasecmp(key, "digital-unrestricted"))
1768                                         {
1769                                                 param->integer_value = INFO_BC_DATAUNRESTRICTED;
1770                                                 break;
1771                                         }
1772                                         if (!strcasecmp(key, "digital-unrestricted-tones"))
1773                                         {
1774                                                 param->integer_value = INFO_BC_DATAUNRESTRICTED_TONES;
1775                                                 break;
1776                                         }
1777                                         SPRINT(failure, "Service type '%s' unknown.", key);
1778                                         goto parse_error;
1779                                 }
1780                                 if (param_defs[index].type == PARAM_TYPE_BMODE)
1781                                 {
1782                                         param->value_type = VALUE_TYPE_INTEGER;
1783                                         if (!strcasecmp(key, "transparent"))
1784                                         {
1785                                                 param->integer_value = INFO_BMODE_CIRCUIT;
1786                                                 break;
1787                                         }
1788                                         if (!strcasecmp(key, "hdlc"))
1789                                         {
1790                                                 param->integer_value = INFO_BMODE_PACKET;
1791                                                 break;
1792                                         }
1793                                         SPRINT(failure, "Bchannel mode '%s' unknown.", key);
1794                                         goto parse_error;
1795                                 }
1796                                 if (param_defs[index].type == PARAM_TYPE_DIVERSION)
1797                                 {
1798                                         param->value_type = VALUE_TYPE_INTEGER;
1799                                         if (!strcasecmp(key, "cfu"))
1800                                         {
1801                                                 param->integer_value = INFO_DIVERSION_CFU;
1802                                                 break;
1803                                         }
1804                                         if (!strcasecmp(key, "cfb"))
1805                                         {
1806                                                 param->integer_value = INFO_DIVERSION_CFB;
1807                                                 break;
1808                                         }
1809                                         if (!strcasecmp(key, "cfnr"))
1810                                         {
1811                                                 param->integer_value = INFO_DIVERSION_CFNR;
1812                                                 break;
1813                                         }
1814                                         if (!strcasecmp(key, "cfp"))
1815                                         {
1816                                                 param->integer_value = INFO_DIVERSION_CFP;
1817                                                 break;
1818                                         }
1819                                         SPRINT(failure, "Diversion type '%s' unknown.", key);
1820                                         goto parse_error;
1821                                 }
1822                                 if (param_defs[index].type == PARAM_TYPE_TYPE)
1823                                 {
1824                                         param->value_type = VALUE_TYPE_INTEGER;
1825                                         if (!strcasecmp(key, "unknown"))
1826                                         {
1827                                                 param->integer_value = INFO_NTYPE_UNKNOWN;
1828                                                 break;
1829                                         }
1830                                         if (!strcasecmp(key, "subscriber"))
1831                                         {
1832                                                 param->integer_value = INFO_NTYPE_SUBSCRIBER;
1833                                                 break;
1834                                         }
1835                                         if (!strcasecmp(key, "national"))
1836                                         {
1837                                                 param->integer_value = INFO_NTYPE_NATIONAL;
1838                                                 break;
1839                                         }
1840                                         if (!strcasecmp(key, "international"))
1841                                         {
1842                                                 param->integer_value = INFO_NTYPE_INTERNATIONAL;
1843                                                 break;
1844                                         }
1845                                         SPRINT(failure, "Number type '%s' unknown.", key);
1846                                         goto parse_error;
1847                                 }
1848                                 if (param_defs[index].type == PARAM_TYPE_YESNO)
1849                                 {
1850                                         param->value_type = VALUE_TYPE_INTEGER;
1851                                         if (!strcasecmp(key, "yes"))
1852                                         {
1853                                                 param->integer_value = 1;
1854                                                 break;
1855                                         }
1856                                         if (!strcasecmp(key, "no"))
1857                                         {
1858                                                 param->integer_value = 0;
1859                                                 break;
1860                                         }
1861                                         SPRINT(failure, "Value '%s' unknown. ('yes' or 'no')", key);
1862                                         goto parse_error;
1863                                 }
1864                                 param->string_value = (char *)malloc(strlen(key)+1);
1865                                 if (param->string_value == NULL)
1866                                 {
1867                                         SPRINT(failure, "Out of memory.");
1868                                         goto parse_error;
1869                                 }
1870                                 rmemuse++;
1871                                 UCPY(param->string_value, key);
1872                                 param->value_type = VALUE_TYPE_STRING;
1873                                 break;
1874
1875                                 default:
1876                                 SPRINT(failure, "Software error: PARAM_TYPE_* %d not parsed in function '%s'", param_defs[index].type, __FUNCTION__);
1877                                 goto parse_error;
1878                         }
1879
1880                         if (*p == ',')
1881                         {
1882                                 p++;
1883                                 /* next item */
1884                                 param->value_extension = 1;
1885                                 goto nextparamvalue;
1886                         }
1887
1888                         /* end of line */
1889                         if (*p == '\0')
1890                                 break;
1891
1892                         /* to seperate the items, a space is required */
1893                         if (*p != ' ')
1894                         {
1895                                 SPRINT(failure, "Character '%c' not expected here. Use ' ' to seperate parameters, or ',' for multiple values.", *p);
1896                                 goto parse_error;
1897                         }
1898                         /* skip spaces */
1899                         while(*p == 32)
1900                         {
1901                                 if (*p == 0)
1902                                         break;
1903                                 p++;
1904                         }
1905
1906                         /* check for next ACTION */
1907                         if (*p == ':')
1908                         {
1909                                 p++;
1910                                 goto nextaction;
1911                         }
1912                 }
1913         }
1914
1915         fclose(fp[nesting--]);
1916         fduse--;
1917
1918         if (nesting >= 0)
1919                 goto go_root;
1920
1921         if (!ruleset_start)
1922         {
1923                 SPRINT(failure, "No ruleset defined.");
1924         }
1925         return(ruleset_start);
1926
1927         parse_error:
1928         printf("While parsing %s, an error occurred in line %d:\n", filename[nesting], line[nesting]);
1929         printf("-> %s\n", buffer);
1930         memset(pointer, ' ', sizeof(pointer));
1931         pointer[p-buffer] = '^';
1932         pointer[p-buffer+1] = '\0';
1933         printf("   %s\n", pointer);
1934         printf("%s\n", failure);
1935         SPRINT(ruleset_error, "Error in file %s, line %d: %s",  filename[nesting], line[nesting], failure);
1936
1937         openerror:
1938         while(nesting >= 0)
1939         {
1940                 fclose(fp[nesting--]);
1941                 fduse--;
1942         }
1943
1944         ruleset_free(ruleset_start);
1945         return(NULL);
1946 }
1947
1948 /*
1949  * return ruleset by name
1950  */
1951 struct route_ruleset *getrulesetbyname(char *name)
1952 {
1953         struct route_ruleset *ruleset = ruleset_first;
1954
1955         while(ruleset)
1956         {
1957                 if (!strcasecmp(name, ruleset->name))
1958                 {
1959                         break;
1960                 }
1961                 ruleset = ruleset->next;
1962         }
1963         PDEBUG(DEBUG_ROUTE, "ruleset %s %s.\n", name, ruleset?"found":"not found");
1964         return(ruleset);
1965 }
1966
1967 /*
1968  * parses the current ruleset and returns action
1969  */
1970 struct route_action *EndpointAppPBX::route(struct route_ruleset *ruleset)
1971 {
1972         int                     match,
1973                                 couldmatch = 0, /* any rule could match */
1974                                 istrue,
1975                                 couldbetrue,
1976                                 condition,
1977                                 dialing_required,
1978                                 avail,
1979                                 any;
1980         struct route_rule       *rule = ruleset->rule_first;
1981         struct route_cond       *cond;
1982         struct route_action     *action = NULL;
1983         unsigned long           comp_len;
1984         int                     j, jj;
1985         char                    callerid[64],   redirid[64];
1986         int                     integer;
1987         char                    *string;
1988         FILE                    *tfp;
1989         double                  timeout;
1990         struct mISDNport        *mISDNport;
1991
1992         /* reset timeout action */
1993         e_match_timeout = 0; /* no timeout */
1994         e_match_to_action = NULL;
1995
1996         SCPY(callerid, numberrize_callerinfo(e_callerinfo.id, e_callerinfo.ntype));
1997         SCPY(redirid, numberrize_callerinfo(e_redirinfo.id, e_redirinfo.ntype));
1998
1999         PDEBUG(DEBUG_ROUTE, "parsing ruleset '%s'\n", ruleset->name);
2000         while(rule)
2001         {
2002                 PDEBUG(DEBUG_ROUTE, "checking rule in line %d\n", rule->line);
2003                 match = 1; /* this rule matches */
2004                 dialing_required = 0;
2005                 timeout = 0; /* timeout time */
2006                 cond = rule->cond_first;
2007                 while(cond)
2008                 {
2009                         condition = 0; /* any condition element is true (1) or could be true (2) */
2010                         checkextension:
2011                         istrue = 0; /* this condition-element is true */
2012                         couldbetrue = 0; /* this conditions-element could be true */
2013                         switch(cond->match)
2014                         {
2015                                 case MATCH_EXTERN:
2016                                 if (!e_ext.number[0])
2017                                         istrue = 1;
2018                                 break;
2019
2020                                 case MATCH_INTERN:
2021                                 if (e_ext.number[0])
2022                                         istrue = 1;
2023                                 break;
2024
2025                                 case MATCH_PORT:
2026                                 if (ea_endpoint->ep_portlist)
2027                                 if ((ea_endpoint->ep_portlist->port_type & PORT_CLASS_mISDN_MASK) != PORT_CLASS_mISDN_DSS1)
2028                                         break;
2029                                 integer = e_callerinfo.isdn_port;
2030                                 goto match_integer;
2031
2032                                 case MATCH_INTERFACE:
2033                                 if (!e_callerinfo.interface[0])
2034                                         break;
2035                                 string = e_callerinfo.interface;
2036                                 goto match_string_prefix;
2037
2038                                 case MATCH_CALLERID:
2039                                 string = callerid;
2040                                 goto match_string_prefix;
2041
2042                                 case MATCH_EXTENSION:
2043                                 string = e_ext.name;
2044                                 goto match_string;
2045
2046                                 case MATCH_DIALING:
2047                                 string = e_dialinginfo.number;
2048                                 goto match_string_prefix;
2049
2050                                 case MATCH_ENBLOCK:
2051                                 if (!e_overlap)
2052                                         istrue = 1;
2053                                 break;
2054
2055                                 case MATCH_OVERLAP:
2056                                 if (e_overlap)
2057                                         istrue = 1;
2058                                 break;
2059
2060                                 case MATCH_ANONYMOUS:
2061                                 if (e_callerinfo.present != INFO_PRESENT_ALLOWED)
2062                                         istrue = 1;
2063                                 break;
2064
2065                                 case MATCH_VISIBLE:
2066                                 if (e_callerinfo.present == INFO_PRESENT_ALLOWED)
2067                                         istrue = 1;
2068                                 break;
2069
2070                                 case MATCH_UNKNOWN:
2071                                 if (e_callerinfo.present == INFO_PRESENT_NOTAVAIL)
2072                                         istrue = 1;
2073                                 break;
2074
2075                                 case MATCH_AVAILABLE:
2076                                 if (e_callerinfo.present != INFO_PRESENT_NOTAVAIL)
2077                                         istrue = 1;
2078                                 break;
2079
2080                                 case MATCH_FAKE:
2081                                 if (e_callerinfo.screen == INFO_SCREEN_USER)
2082                                         istrue = 1;
2083                                 break;
2084
2085                                 case MATCH_REAL:
2086                                 if (e_callerinfo.screen != INFO_SCREEN_USER)
2087                                         istrue = 1;
2088                                 break;
2089
2090                                 case MATCH_REDIRECTED:
2091                                 if (e_redirinfo.present != INFO_PRESENT_NULL)
2092                                         istrue = 1;
2093                                 break;
2094
2095                                 case MATCH_DIRECT:
2096                                 if (e_redirinfo.present == INFO_PRESENT_NULL)
2097                                         istrue = 1;
2098                                 break;
2099
2100                                 case MATCH_REDIRID:
2101                                 string = redirid;
2102                                 goto match_string_prefix;
2103
2104                                 case MATCH_TIME:
2105                                 integer = now_tm->tm_hour*100 + now_tm->tm_min;
2106                                 goto match_integer;
2107
2108                                 case MATCH_MDAY:
2109                                 integer = now_tm->tm_mday;
2110                                 goto match_integer;
2111
2112                                 case MATCH_MONTH:
2113                                 integer = now_tm->tm_mon+1;
2114                                 goto match_integer;
2115
2116                                 case MATCH_YEAR:
2117                                 integer = now_tm->tm_year + 1900;
2118                                 goto match_integer;
2119
2120                                 case MATCH_WDAY:
2121                                 integer = now_tm->tm_wday;
2122                                 integer = integer?integer:7; /* correct sunday */
2123                                 goto match_integer;
2124
2125                                 case MATCH_CAPABILITY:
2126                                 integer = e_capainfo.bearer_capa;
2127                                 goto match_integer;
2128
2129                                 case MATCH_INFOLAYER1:
2130                                 integer = e_capainfo.bearer_info1;
2131                                 goto match_integer;
2132
2133                                 case MATCH_HLC:
2134                                 integer = e_capainfo.hlc;
2135                                 goto match_integer;
2136
2137                                 case MATCH_FILE:
2138                                 tfp = fopen(cond->string_value, "r");
2139                                 if (!tfp)
2140                                 {
2141                                         break;
2142                                 }
2143                                 if (fgetc(tfp) == '1')
2144                                         istrue = 1;
2145                                 fclose(tfp);
2146                                 break;
2147
2148                                 case MATCH_EXECUTE:
2149                                 if (system(cond->string_value) == 0)
2150                                         istrue = 1;
2151                                 break;
2152
2153                                 case MATCH_DEFAULT:
2154                                 if (!couldmatch)
2155                                         istrue = 1;
2156                                 break;
2157
2158                                 case MATCH_TIMEOUT:
2159                                 timeout = now_d + cond->integer_value;
2160                                 istrue = 1;
2161                                 break;
2162
2163                                 case MATCH_FREE:
2164                                 case MATCH_NOTFREE:
2165                                 if (!(comp_len = (unsigned long)strchr(cond->string_value, ':')))
2166                                         break;
2167                                 comp_len = comp_len-(unsigned long)cond->string_value;
2168                                 avail = 0;
2169                                 mISDNport = mISDNport_first;
2170                                 while(mISDNport)
2171                                 {
2172                                         if (mISDNport->ifport)
2173                                         if (strlen(mISDNport->ifport->interface->name) == comp_len)
2174                                         if (!strncasecmp(mISDNport->ifport->interface->name, cond->string_value, comp_len))
2175                                         if (!mISDNport->ptp || mISDNport->l2link)
2176                                         {
2177                                                 j = 0;
2178                                                 jj = mISDNport->b_num;
2179                                                 avail += jj;
2180                                                 while(j < jj)
2181                                                 {
2182                                                         if (mISDNport->b_state[j])
2183                                                                 avail--;
2184                                                         j++;
2185                                                 }
2186                                         }
2187                                         mISDNport = mISDNport->next;
2188                                 }
2189                                 if (cond->match == MATCH_FREE)
2190                                 {
2191                                         if (avail >= atoi(cond->string_value + comp_len + 1))
2192                                                 istrue = 1;
2193                                 } else
2194                                 {
2195                                         if (avail < atoi(cond->string_value + comp_len + 1))
2196                                                 istrue = 1;
2197                                 }
2198                                 break;
2199
2200
2201                                 case MATCH_DOWN:
2202                                 mISDNport = mISDNport_first;
2203                                 while(mISDNport)
2204                                 {
2205                                         if (mISDNport->ifport)
2206                                         if (!strcasecmp(mISDNport->ifport->interface->name, cond->string_value))
2207                                         if (!mISDNport->ptp || mISDNport->l2link) /* break if one is up */
2208                                                 break;
2209                                         mISDNport = mISDNport->next;
2210                                 }
2211                                 if (!mISDNport) /* all down */
2212                                         istrue = 1;
2213                                 break;
2214
2215                                 case MATCH_UP:
2216                                 mISDNport = mISDNport_first;
2217                                 while(mISDNport)
2218                                 {
2219                                         if (mISDNport->ifport)
2220                                         if (!strcasecmp(mISDNport->ifport->interface->name, cond->string_value))
2221                                         if (!mISDNport->ptp || mISDNport->l2link) /* break if one is up */
2222                                                 break;
2223
2224                                         mISDNport = mISDNport->next;
2225                                 }
2226                                 if (mISDNport) /* one link at least */
2227                                         istrue = 1;
2228                                 break;
2229
2230                                 case MATCH_BUSY:
2231                                 any = 0;
2232                                 mISDNport = mISDNport_first;
2233                                 while(mISDNport)
2234                                 {
2235                                         if (mISDNport->ifport)
2236                                         if (!strcasecmp(mISDNport->ifport->interface->name, cond->string_value))
2237                                         if (mISDNport->use) /* break if in use */
2238                                                 break;
2239                                         mISDNport = mISDNport->next;
2240                                 }
2241                                 if (mISDNport)
2242                                         istrue = 1;
2243                                 break;
2244
2245                                 case MATCH_IDLE:
2246                                 mISDNport = mISDNport_first;
2247                                 while(mISDNport)
2248                                 {
2249                                         if (mISDNport->ifport)
2250                                         if (!strcasecmp(mISDNport->ifport->interface->name, cond->string_value))
2251                                         if (mISDNport->use) /* break if in use */
2252                                                 break;
2253                                         mISDNport = mISDNport->next;
2254                                 }
2255                                 if (!mISDNport)
2256                                         istrue = 1;
2257                                 break;
2258
2259                                 default:
2260                                 PERROR("Software error: MATCH_* %d not parsed in function '%s'", cond->match, __FUNCTION__);
2261                                 break;
2262
2263                                 match_integer:
2264                                 if (cond->value_type == VALUE_TYPE_INTEGER)
2265                                 {
2266                                         if (integer != cond->integer_value)
2267                                                 break;
2268                                         istrue = 1;
2269                                         break;
2270                                 }
2271                                 if (cond->value_type == VALUE_TYPE_INTEGER_RANGE)
2272                                 {
2273                                         /* check if negative range (2100 - 700 o'clock) */
2274                                         if (cond->integer_value > cond->integer_value_to)
2275                                         {
2276                                                 if (integer>=cond->integer_value && integer<=cond->integer_value_to)
2277                                                         istrue = 1;
2278                                                 break;
2279                                         }
2280                                         /* range is positive */
2281                                         if (integer>=cond->integer_value && integer<=cond->integer_value_to)
2282                                                 istrue = 1;
2283                                         break;
2284                                 }
2285                                 break;
2286
2287                                 match_string:
2288                                 if (strlen(cond->string_value) != strlen(string))
2289                                         break;
2290                                 /* fall through */
2291                                 match_string_prefix:
2292                                 comp_len = strlen(cond->string_value); /* because we must reach value's length */
2293                                 /* we must have greater or equal length to values */
2294                                 if ((unsigned long)strlen(string) < comp_len)
2295                                 {
2296                                         /* special case for unfinished dialing */
2297                                         if (cond->match == MATCH_DIALING)
2298                                         {
2299                                                 couldbetrue = 1; /* could match */
2300                                                 comp_len = strlen(string);
2301                                         } else
2302                                         {
2303                                                 break;
2304                                         }
2305                                 }
2306                                 /* on single string match */
2307                                 if (cond->value_type == VALUE_TYPE_STRING)
2308                                 {
2309                                         if (!strncmp(string, cond->string_value, comp_len))
2310                                         {
2311                                                 istrue = 1;
2312                                                 /* must be set for changing 'e_extdialing' */
2313                                                 if (cond->match == MATCH_DIALING)
2314                                                         dialing_required = comp_len;
2315                                                 break;
2316                                         }
2317                                         break;
2318                                 }
2319                                 /* on range match */
2320                                 if (cond->value_type == VALUE_TYPE_STRING_RANGE)
2321                                 {
2322                                         /* check if negative range ("55"-"22") */
2323                                         if (cond->comp_string > 0)
2324                                         {
2325                                                 if (strncmp(string, cond->string_value, comp_len) >= 0)
2326                                                 {
2327                                                         istrue = 1;
2328                                                         /* must be set for changing 'e_extdialing' */
2329                                                         if (cond->match == MATCH_DIALING)
2330                                                                 dialing_required = comp_len;
2331                                                         break;
2332                                                 }
2333                                                 if (strncmp(string, cond->string_value_to, comp_len) <= 0)
2334                                                 {
2335                                                         /* must be set for changing 'e_extdialing' */
2336                                                         istrue = 1;
2337                                                         if (cond->match == MATCH_DIALING)
2338                                                                 dialing_required = comp_len;
2339                                                         break;
2340                                                 }
2341                                                 break;
2342                                         }
2343                                         /* range is positive */
2344                                         if (strncmp(string, cond->string_value, comp_len) < 0)
2345                                                 break;
2346                                         if (strncmp(string, cond->string_value_to, comp_len) > 0)
2347                                                 break;
2348                                         istrue = 1;
2349                                         if (cond->match == MATCH_DIALING)
2350                                                 dialing_required = comp_len;
2351                                         break;
2352                                 }
2353                                 break;
2354                         }
2355
2356                         /* set current condition */
2357                         if (istrue && !couldbetrue)
2358                                 condition = 1; /* element matches, so condition matches */
2359                         if (istrue && couldbetrue && !condition)
2360                                 condition = 2; /* element could match and other elements don't match, so condition could match */
2361
2362                         /* if not matching or could match */
2363                         if (condition != 1)
2364                         {
2365                                 /* if we have more values to check */
2366                                 if (cond->value_extension && cond->next)
2367                                 {
2368                                         cond = cond->next;
2369                                         goto checkextension;
2370                                 }
2371                                 match = condition;
2372                                 break;
2373                         }
2374
2375                         /* skip exteded values, beacuse we already have one matching value */
2376                         while(cond->value_extension && cond->next)
2377                                 cond = cond->next;
2378
2379                         cond = cond->next;
2380                 }
2381                 if (timeout>now_d && match==1) /* the matching rule with timeout in the future */
2382                 if (e_match_timeout<1 || timeout<e_match_timeout) /* first timeout or lower */
2383                 {
2384                         /* set timeout in the furture */
2385                         e_match_timeout = timeout;
2386                         e_match_to_action = rule->action_first;
2387                         e_match_to_extdialing = e_dialinginfo.number + dialing_required;
2388                         match = 0; /* matches in the future */
2389                 }
2390                 if (match == 1)
2391                 {
2392                         /* matching, we return first action */
2393                         action = rule->action_first;
2394                         e_match_timeout = 0; /* no timeout */
2395                         e_match_to_action = NULL;
2396                         e_extdialing = e_dialinginfo.number + dialing_required;
2397                         break;
2398                 }
2399                 if (match == 2)
2400                 {
2401                         /* rule could match if more is dialed */
2402                         couldmatch = 1;
2403                 }
2404                 rule = rule->next;
2405         }
2406         return(action);
2407 }
2408
2409 /*
2410  * parses the current action's parameters and return them
2411  */
2412 struct route_param *EndpointAppPBX::routeparam(struct route_action *action, unsigned long long id)
2413 {
2414         struct route_param *param = action->param_first;
2415
2416         while(param)
2417         {
2418                 if (param->id == id)
2419                         break;
2420                 param = param->next;
2421         }
2422         return(param);
2423 }
2424
2425
2426 /*
2427  * internal rules that are not defined by route.conf
2428  */
2429 struct route_action action_password = {
2430         NULL,
2431         NULL,
2432         ACTION_PASSWORD,
2433         0,
2434         0,
2435 };
2436
2437 struct route_action action_password_write = {
2438         NULL,
2439         NULL,
2440         ACTION_PASSWORD_WRITE,
2441         0,
2442         0,
2443 };
2444
2445 struct route_action action_external = {
2446         NULL,
2447         NULL,
2448         ACTION_EXTERNAL,
2449         0,
2450         0,
2451 };
2452
2453 struct route_action action_internal = {
2454         NULL,
2455         NULL,
2456         ACTION_INTERNAL,
2457         0,
2458         0,
2459 };
2460
2461 struct route_action action_chan = {
2462         NULL,
2463         NULL,
2464         ACTION_CHAN,
2465         0,
2466         0,
2467 };
2468
2469 struct route_action action_vbox = {
2470         NULL,
2471         NULL,
2472         ACTION_VBOX_RECORD,
2473         0,
2474         0,
2475 };
2476
2477 struct route_action action_partyline = {
2478         NULL,
2479         NULL,
2480         ACTION_PARTYLINE,
2481         0,
2482         0,
2483 };
2484
2485 struct route_action action_disconnect = {
2486         NULL,
2487         NULL,
2488         ACTION_DISCONNECT,
2489         0,
2490         0,
2491 };
2492
2493