usr.sbin/i4b/isdnd/rc_config.c

   1 /*
   2  * Copyright (c) 1997, 2001 Hellmuth Michaelis. All rights reserved.
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions
   6  * are met:
   7  * 1. Redistributions of source code must retain the above copyright
   8  *    notice, this list of conditions and the following disclaimer.
   9  * 2. Redistributions in binary form must reproduce the above copyright
  10  *    notice, this list of conditions and the following disclaimer in the
  11  *    documentation and/or other materials provided with the distribution.
  12  *
  13  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  14  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  15  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  16  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  17  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  18  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  19  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  20  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  21  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  22  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  23  * SUCH DAMAGE.
  24  *
  25  *---------------------------------------------------------------------------
  26  *
  27  *      i4b daemon - config file processing
  28  *      -----------------------------------
  29  *
  30  * $FreeBSD: src/usr.sbin/i4b/isdnd/rc_config.c,v 1.6.2.3 2002/04/24 18:50:07 joerg Exp $
  31  * $DragonFly: src/usr.sbin/i4b/isdnd/rc_config.c,v 1.3 2003/11/16 15:17:35 eirikn Exp $
  32  *
  33  *      last edit-date: [Fri Jul 20 19:16:27 2001]
  34  *
  35  *---------------------------------------------------------------------------*/
  36
  37 #include <sys/types.h>
  38 #include <sys/socket.h>
  39 #include <netinet/in.h>
  40 #include <arpa/inet.h>
  41
  42 #include <sys/ioctl.h>
  43
  44 #include <net/if.h>
  45
  46 #include "isdnd.h"
  47 #include "y.tab.h"
  48
  49 #include "monitor.h"
  50
  51 extern int entrycount;
  52 extern int controllercount;
  53 extern int lineno;
  54 extern char *yytext;
  55
  56 extern FILE *yyin;
  57 extern int yyparse();
  58
  59 static void set_config_defaults(void);
  60 static void check_config(void);
  61 static void print_config(void);
  62 static void parse_valid(int entrycount, char *dt);
  63
  64 static int nregexpr = 0;
  65 static int nregprog = 0;
  66
  67 /*---------------------------------------------------------------------------*
  68  *      called from main to read and process config file
  69  *---------------------------------------------------------------------------*/
  70 void
  71 configure(char *filename, int reread)
  72 {
  73         extern void reset_scanner(FILE *inputfile);
  74
  75         set_config_defaults();
  76
  77         yyin = fopen(filename, "r");
  78
  79         if(reread)
  80         {
  81                 reset_scanner(yyin);
  82         }
  83
  84         if (yyin == NULL)
  85         {
  86                 log(LL_ERR, "cannot fopen file [%s]", filename);
  87                 exit(1);
  88         }
  89
  90         yyparse();
  91
  92         monitor_fixup_rights();
  93
  94         check_config();         /* validation and consistency check */
  95
  96         fclose(yyin);
  97
  98         if(do_print)
  99         {
 100                 if(config_error_flag)
 101                 {
 102                         log(LL_ERR, "there were %d error(s) in the configuration file, terminating!", config_error_flag);
 103                         exit(1);
 104                 }
 105                 print_config();
 106                 do_exit(0);
 107         }
 108 }
 109
 110 /*---------------------------------------------------------------------------*
 111  *      yacc error routine
 112  *---------------------------------------------------------------------------*/
 113 void
 114 yyerror(const char *msg)
 115 {
 116         log(LL_ERR, "configuration error: %s at line %d, token \"%s\"", msg, lineno+1, yytext);
 117         config_error_flag++;
 118 }
 119
 120 /*---------------------------------------------------------------------------*
 121  *      fill all config entries with default values
 122  *---------------------------------------------------------------------------*/
 123 static void
 124 set_config_defaults(void)
 125 {
 126         cfg_entry_t *cep = &cfg_entry_tab[0];   /* ptr to config entry */
 127         int i;
 128
 129         /* system section cleanup */
 130
 131         nregprog = nregexpr = 0;
 132
 133         rt_prio = RTPRIO_NOTUSED;
 134
 135         mailer[0] = '\0';
 136         mailto[0] = '\0';
 137
 138         /* clean regular expression table */
 139
 140         for(i=0; i < MAX_RE; i++)
 141         {
 142                 if(rarr[i].re_expr)
 143                         free(rarr[i].re_expr);
 144                 rarr[i].re_expr = NULL;
 145
 146                 if(rarr[i].re_prog)
 147                         free(rarr[i].re_prog);
 148                 rarr[i].re_prog = NULL;
 149
 150                 rarr[i].re_flg = 0;
 151         }
 152
 153         strcpy(rotatesuffix, "");
 154
 155         /*
 156          * controller table cleanup, beware: has already
 157          * been setup in main, init_controller() !
 158          */
 159
 160         for(i=0; i < ncontroller; i++)
 161         {
 162                 isdn_ctrl_tab[i].protocol = PROTOCOL_DSS1;
 163                 isdn_ctrl_tab[i].firmware = NULL;
 164         }
 165
 166         /* entry section cleanup */
 167
 168         for(i=0; i < CFG_ENTRY_MAX; i++, cep++)
 169         {
 170                 bzero(cep, sizeof(cfg_entry_t));
 171
 172                 /* ====== filled in at startup configuration, then static */
 173
 174                 sprintf(cep->name, "ENTRY%d", i);
 175
 176                 cep->isdncontroller = INVALID;
 177                 cep->isdnchannel = CHAN_ANY;
 178
 179                 cep->usrdevicename = INVALID;
 180                 cep->usrdeviceunit = INVALID;
 181
 182                 cep->remote_numbers_handling = RNH_LAST;
 183
 184                 cep->dialin_reaction = REACT_IGNORE;
 185
 186                 cep->b1protocol = BPROT_NONE;
 187
 188                 cep->unitlength = UNITLENGTH_DEFAULT;
 189
 190                 cep->earlyhangup = EARLYHANGUP_DEFAULT;
 191
 192                 cep->ratetype = INVALID_RATE;
 193
 194                 cep->unitlengthsrc = ULSRC_NONE;
 195
 196                 cep->answerprog = ANSWERPROG_DEF;
 197
 198                 cep->callbackwait = CALLBACKWAIT_MIN;
 199
 200                 cep->calledbackwait = CALLEDBACKWAIT_MIN;
 201
 202                 cep->dialretries = DIALRETRIES_DEF;
 203
 204                 cep->recoverytime = RECOVERYTIME_MIN;
 205
 206                 cep->dialouttype = DIALOUT_NORMAL;
 207
 208                 cep->inout = DIR_INOUT;
 209
 210                 cep->ppp_expect_auth = AUTH_UNDEF;
 211
 212                 cep->ppp_send_auth = AUTH_UNDEF;
 213
 214                 cep->ppp_auth_flags = AUTH_RECHALLENGE | AUTH_REQUIRED;
 215
 216                 /* ======== filled in after start, then dynamic */
 217
 218                 cep->cdid = CDID_UNUSED;
 219
 220                 cep->state = ST_IDLE;
 221
 222                 cep->aoc_valid = AOC_INVALID;
 223         }
 224 }
 225
 226 /*---------------------------------------------------------------------------*
 227  *      internaly set values for ommitted controler sectin
 228  *---------------------------------------------------------------------------*/
 229 void
 230 cfg_set_controller_default(void)
 231 {
 232         controllercount = 0;
 233         DBGL(DL_RCCF, (log(LL_DBG, "[defaults, no controller section] controller %d: protocol = dss1", controllercount)));
 234         isdn_ctrl_tab[controllercount].protocol = PROTOCOL_DSS1;
 235 }
 236
 237 #define PPP_PAP         0xc023
 238 #define PPP_CHAP        0xc223
 239
 240 static void
 241 set_isppp_auth(int entry)
 242 {
 243         cfg_entry_t *cep = &cfg_entry_tab[entry];       /* ptr to config entry */
 244
 245         struct ifreq ifr;
 246         struct spppreq spr;
 247         int s;
 248         int doioctl = 0;
 249
 250         if(cep->usrdevicename != BDRV_ISPPP)
 251                 return;
 252
 253         if(cep->ppp_expect_auth == AUTH_UNDEF
 254            && cep->ppp_send_auth == AUTH_UNDEF)
 255                 return;
 256
 257         if(cep->ppp_expect_auth == AUTH_NONE
 258            || cep->ppp_send_auth == AUTH_NONE)
 259                 doioctl = 1;
 260
 261         if ((cep->ppp_expect_auth == AUTH_CHAP
 262              || cep->ppp_expect_auth == AUTH_PAP)
 263             && cep->ppp_expect_name[0] != 0
 264             && cep->ppp_expect_password[0] != 0)
 265                 doioctl = 1;
 266
 267         if ((cep->ppp_send_auth == AUTH_CHAP || cep->ppp_send_auth == AUTH_PAP)
 268                         && cep->ppp_send_name[0] != 0
 269                         && cep->ppp_send_password[0] != 0)
 270                 doioctl = 1;
 271
 272         if(!doioctl)
 273                 return;
 274
 275         snprintf(ifr.ifr_name, sizeof(ifr.ifr_name), "isp%d", cep->usrdeviceunit);
 276
 277         /* use a random AF to create the socket */
 278         if ((s = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
 279                 log(LL_ERR, "ERROR opening control socket at line %d!", lineno);
 280                 config_error_flag++;
 281                 return;
 282         }
 283         spr.cmd = (int)SPPPIOGDEFS;
 284         ifr.ifr_data = (caddr_t)&spr;
 285
 286         if (ioctl(s, SIOCGIFGENERIC, &ifr) == -1) {
 287                 log(LL_ERR, "ERROR fetching active PPP authentication info for %s at line %d!", ifr.ifr_name, lineno);
 288                 close(s);
 289                 config_error_flag++;
 290                 return;
 291         }
 292         if (cep->ppp_expect_auth != AUTH_UNDEF)
 293         {
 294                 if(cep->ppp_expect_auth == AUTH_NONE)
 295                 {
 296                         spr.defs.hisauth.proto = 0;
 297                 }
 298                 else if ((cep->ppp_expect_auth == AUTH_CHAP
 299                           || cep->ppp_expect_auth == AUTH_PAP)
 300                          && cep->ppp_expect_name[0] != 0
 301                          && cep->ppp_expect_password[0] != 0)
 302                 {
 303                         spr.defs.hisauth.proto = cep->ppp_expect_auth == AUTH_PAP ? PPP_PAP : PPP_CHAP;
 304                         strncpy(spr.defs.hisauth.name, cep->ppp_expect_name, AUTHNAMELEN);
 305                         strncpy(spr.defs.hisauth.secret, cep->ppp_expect_password, AUTHKEYLEN);
 306                 }
 307         }
 308         if (cep->ppp_send_auth != AUTH_UNDEF)
 309         {
 310                 if(cep->ppp_send_auth == AUTH_NONE)
 311                 {
 312                         spr.defs.myauth.proto = 0;
 313                 }
 314                 else if ((cep->ppp_send_auth == AUTH_CHAP
 315                           || cep->ppp_send_auth == AUTH_PAP)
 316                          && cep->ppp_send_name[0] != 0
 317                          && cep->ppp_send_password[0] != 0)
 318                 {
 319                         spr.defs.myauth.proto = cep->ppp_send_auth == AUTH_PAP ? PPP_PAP : PPP_CHAP;
 320                         strncpy(spr.defs.myauth.name, cep->ppp_send_name, AUTHNAMELEN);
 321                         strncpy(spr.defs.myauth.secret, cep->ppp_send_password, AUTHKEYLEN);
 322
 323                         if(cep->ppp_auth_flags & AUTH_REQUIRED)
 324                                 spr.defs.hisauth.flags &= ~AUTHFLAG_NOCALLOUT;
 325                         else
 326                                 spr.defs.hisauth.flags |= AUTHFLAG_NOCALLOUT;
 327
 328                         if(cep->ppp_auth_flags & AUTH_RECHALLENGE)
 329                                 spr.defs.hisauth.flags &= ~AUTHFLAG_NORECHALLENGE;
 330                         else
 331                                 spr.defs.hisauth.flags |= AUTHFLAG_NORECHALLENGE;
 332                 }
 333         }
 334
 335         spr.cmd = (int)SPPPIOSDEFS;
 336
 337         if (ioctl(s, SIOCSIFGENERIC, &ifr) == -1) {
 338                 log(LL_ERR, "ERROR setting new PPP authentication parameters for %s at line %d!", ifr.ifr_name, lineno);
 339                 config_error_flag++;
 340         }
 341         close(s);
 342 }
 343
 344 /*---------------------------------------------------------------------------*
 345  *      extract values from config and fill table
 346  *---------------------------------------------------------------------------*/
 347 void
 348 cfg_setval(int keyword)
 349 {
 350         int i;
 351
 352         switch(keyword)
 353         {
 354                 case ACCTALL:
 355                         acct_all = yylval.booln;
 356                         DBGL(DL_RCCF, (log(LL_DBG, "system: acctall = %d", yylval.booln)));
 357                         break;
 358
 359                 case ACCTFILE:
 360                         strcpy(acctfile, yylval.str);
 361                         DBGL(DL_RCCF, (log(LL_DBG, "system: acctfile = %s", yylval.str)));
 362                         break;
 363
 364                 case ALERT:
 365                         if(yylval.num < MINALERT)
 366                         {
 367                                 yylval.num = MINALERT;
 368                                 DBGL(DL_RCCF, (log(LL_DBG, "entry %d: alert < %d, min = %d", entrycount, MINALERT, yylval.num)));
 369                         }
 370                         else if(yylval.num > MAXALERT)
 371                         {
 372                                 yylval.num = MAXALERT;
 373                                 DBGL(DL_RCCF, (log(LL_DBG, "entry %d: alert > %d, min = %d", entrycount, MAXALERT, yylval.num)));
 374                         }
 375
 376                         DBGL(DL_RCCF, (log(LL_DBG, "entry %d: alert = %d", entrycount, yylval.num)));
 377                         cfg_entry_tab[entrycount].alert = yylval.num;
 378                         break;
 379
 380                 case ALIASING:
 381                         DBGL(DL_RCCF, (log(LL_DBG, "system: aliasing = %d", yylval.booln)));
 382                         aliasing = yylval.booln;
 383                         break;
 384
 385                 case ALIASFNAME:
 386                         strcpy(aliasfile, yylval.str);
 387                         DBGL(DL_RCCF, (log(LL_DBG, "system: aliasfile = %s", yylval.str)));
 388                         break;
 389
 390                 case ANSWERPROG:
 391                         if((cfg_entry_tab[entrycount].answerprog = malloc(strlen(yylval.str)+1)) == NULL)
 392                         {
 393                                 log(LL_ERR, "entry %d: answerstring, malloc failed!", entrycount);
 394                                 do_exit(1);
 395                         }
 396                         strcpy(cfg_entry_tab[entrycount].answerprog, yylval.str);
 397                         DBGL(DL_RCCF, (log(LL_DBG, "entry %d: answerprog = %s", entrycount, yylval.str)));
 398                         break;
 399
 400                 case B1PROTOCOL:
 401                         DBGL(DL_RCCF, (log(LL_DBG, "entry %d: b1protocol = %s", entrycount, yylval.str)));
 402                         if(!(strcmp(yylval.str, "raw")))
 403                                 cfg_entry_tab[entrycount].b1protocol = BPROT_NONE;
 404                         else if(!(strcmp(yylval.str, "hdlc")))
 405                                 cfg_entry_tab[entrycount].b1protocol = BPROT_RHDLC;
 406                         else
 407                         {
 408                                 log(LL_ERR, "ERROR parsing config file: unknown parameter for keyword \"b1protocol\" at line %d!", lineno);
 409                                 config_error_flag++;
 410                         }
 411                         break;
 412
 413                 case BEEPCONNECT:
 414                         do_bell = yylval.booln;
 415                         DBGL(DL_RCCF, (log(LL_DBG, "system: beepconnect = %d", yylval.booln)));
 416                         break;
 417
 418                 case BUDGETCALLBACKPERIOD:
 419                         DBGL(DL_RCCF, (log(LL_DBG, "entry %d: budget-callbackperiod = %d", entrycount, yylval.num)));
 420                         cfg_entry_tab[entrycount].budget_callbackperiod = yylval.num;
 421                         break;
 422
 423                 case BUDGETCALLBACKNCALLS:
 424                         DBGL(DL_RCCF, (log(LL_DBG, "entry %d: budget-callbackncalls = %d", entrycount, yylval.num)));
 425                         cfg_entry_tab[entrycount].budget_callbackncalls = yylval.num;
 426                         break;
 427
 428                 case BUDGETCALLOUTPERIOD:
 429                         DBGL(DL_RCCF, (log(LL_DBG, "entry %d: budget-calloutperiod = %d", entrycount, yylval.num)));
 430                         cfg_entry_tab[entrycount].budget_calloutperiod = yylval.num;
 431                         break;
 432
 433                 case BUDGETCALLOUTNCALLS:
 434                         DBGL(DL_RCCF, (log(LL_DBG, "entry %d: budget-calloutncalls = %d", entrycount, yylval.num)));
 435                         cfg_entry_tab[entrycount].budget_calloutncalls = yylval.num;
 436                         break;
 437
 438                 case BUDGETCALLBACKSFILEROTATE:
 439                         cfg_entry_tab[entrycount].budget_callbacksfile_rotate = yylval.booln;
 440                         DBGL(DL_RCCF, (log(LL_DBG, "entry %d: budget-callbacksfile-rotate = %d", entrycount, yylval.booln)));
 441                         break;
 442
 443                 case BUDGETCALLBACKSFILE:
 444                         {
 445                                 FILE *fp;
 446                                 int s, l;
 447                                 int n;
 448                                 DBGL(DL_RCCF, (log(LL_DBG, "entry %d: budget-callbacksfile = %s", entrycount, yylval.str)));
 449                                 fp = fopen(yylval.str, "r");
 450                                 if(fp != NULL)
 451                                 {
 452                                         if((fscanf(fp, "%d %d %d", (int *)&s, (int *)&l, &n)) != 3)
 453                                         {
 454                                                 DBGL(DL_RCCF, (log(LL_DBG, "entry %d: initializing budget-callbacksfile %s", entrycount, yylval.str)));
 455                                                 fclose(fp);
 456                                                 fp = fopen(yylval.str, "w");
 457                                                 if(fp != NULL)
 458                                                         fprintf(fp, "%d %d %d", (int)time(NULL), (int)time(NULL), 0);
 459                                                 fclose(fp);
 460                                         }
 461                                 }
 462                                 else
 463                                 {
 464                                         DBGL(DL_RCCF, (log(LL_DBG, "entry %d: creating budget-callbacksfile %s", entrycount, yylval.str)));
 465                                         fp = fopen(yylval.str, "w");
 466                                         if(fp != NULL)
 467                                                 fprintf(fp, "%d %d %d", (int)time(NULL), (int)time(NULL), 0);
 468                                         fclose(fp);
 469                                 }
 470
 471                                 fp = fopen(yylval.str, "r");
 472                                 if(fp != NULL)
 473                                 {
 474                                         if((fscanf(fp, "%d %d %d", (int *)&s, (int *)&l, &n)) == 3)
 475                                         {
 476                                                 if((cfg_entry_tab[entrycount].budget_callbacks_file = malloc(strlen(yylval.str)+1)) == NULL)
 477                                                 {
 478                                                         log(LL_ERR, "entry %d: budget-callbacksfile, malloc failed!", entrycount);
 479                                                         do_exit(1);
 480                                                 }
 481                                                 strcpy(cfg_entry_tab[entrycount].budget_callbacks_file, yylval.str);
 482                                                 DBGL(DL_RCCF, (log(LL_DBG, "entry %d: using callbacksfile %s", entrycount, yylval.str)));
 483                                         }
 484                                         fclose(fp);
 485                                 }
 486                         }
 487                         break;
 488
 489                 case BUDGETCALLOUTSFILEROTATE:
 490                         cfg_entry_tab[entrycount].budget_calloutsfile_rotate = yylval.booln;
 491                         DBGL(DL_RCCF, (log(LL_DBG, "entry %d: budget-calloutsfile-rotate = %d", entrycount, yylval.booln)));
 492                         break;
 493
 494                 case BUDGETCALLOUTSFILE:
 495                         {
 496                                 FILE *fp;
 497                                 int s, l;
 498                                 int n;
 499                                 DBGL(DL_RCCF, (log(LL_DBG, "entry %d: budget-calloutsfile = %s", entrycount, yylval.str)));
 500                                 fp = fopen(yylval.str, "r");
 501                                 if(fp != NULL)
 502                                 {
 503                                         if((fscanf(fp, "%d %d %d", (int *)&s, (int *)&l, &n)) != 3)
 504                                         {
 505                                                 DBGL(DL_RCCF, (log(LL_DBG, "entry %d: initializing budget-calloutsfile %s", entrycount, yylval.str)));
 506                                                 fclose(fp);
 507                                                 fp = fopen(yylval.str, "w");
 508                                                 if(fp != NULL)
 509                                                         fprintf(fp, "%d %d %d", (int)time(NULL), (int)time(NULL), 0);
 510                                                 fclose(fp);
 511                                         }
 512                                 }
 513                                 else
 514                                 {
 515                                         DBGL(DL_RCCF, (log(LL_DBG, "entry %d: creating budget-calloutsfile %s", entrycount, yylval.str)));
 516                                         fp = fopen(yylval.str, "w");
 517                                         if(fp != NULL)
 518                                                 fprintf(fp, "%d %d %d", (int)time(NULL), (int)time(NULL), 0);
 519                                         fclose(fp);
 520                                 }
 521
 522                                 fp = fopen(yylval.str, "r");
 523                                 if(fp != NULL)
 524                                 {
 525                                         if((fscanf(fp, "%d %d %d", (int *)&s, (int *)&l, &n)) == 3)
 526                                         {
 527                                                 if((cfg_entry_tab[entrycount].budget_callouts_file = malloc(strlen(yylval.str)+1)) == NULL)
 528                                                 {
 529                                                         log(LL_ERR, "entry %d: budget-calloutsfile, malloc failed!", entrycount);
 530                                                         do_exit(1);
 531                                                 }
 532                                                 strcpy(cfg_entry_tab[entrycount].budget_callouts_file, yylval.str);
 533                                                 DBGL(DL_RCCF, (log(LL_DBG, "entry %d: using calloutsfile %s", entrycount, yylval.str)));
 534                                         }
 535                                         fclose(fp);
 536                                 }
 537                         }
 538                         break;
 539
 540                 case CALLBACKWAIT:
 541                         if(yylval.num < CALLBACKWAIT_MIN)
 542                         {
 543                                 yylval.num = CALLBACKWAIT_MIN;
 544                                 DBGL(DL_RCCF, (log(LL_DBG, "entry %d: callbackwait < %d, min = %d", entrycount, CALLBACKWAIT_MIN, yylval.num)));
 545                         }
 546
 547                         DBGL(DL_RCCF, (log(LL_DBG, "entry %d: callbackwait = %d", entrycount, yylval.num)));
 548                         cfg_entry_tab[entrycount].callbackwait = yylval.num;
 549                         break;
 550
 551                 case CALLEDBACKWAIT:
 552                         if(yylval.num < CALLEDBACKWAIT_MIN)
 553                         {
 554                                 yylval.num = CALLEDBACKWAIT_MIN;
 555                                 DBGL(DL_RCCF, (log(LL_DBG, "entry %d: calledbackwait < %d, min = %d", entrycount, CALLEDBACKWAIT_MIN, yylval.num)));
 556                         }
 557
 558                         DBGL(DL_RCCF, (log(LL_DBG, "entry %d: calledbackwait = %d", entrycount, yylval.num)));
 559                         cfg_entry_tab[entrycount].calledbackwait = yylval.num;
 560                         break;
 561
 562                 case CLONE:
 563                     /*
 564                      *  clone = <entryname>
 565                      *      Loads the entry from the named, existing one.
 566                      *      Fields such as name and usrdeviceunit should
 567                      *      always be specified after clone as they must be
 568                      *      unique.
 569                      *
 570                      *  NOTE: all malloc()'d fields must be dup()'d here,
 571                      *  we can't have multiple references to same storage.
 572                      */
 573                     for (i = 0; i < entrycount; i++)
 574                         if (!strcmp(cfg_entry_tab[i].name, yylval.str))
 575                             break;
 576                     if (i == entrycount) {
 577                         log(LL_ERR, "entry %d: clone, unknown entry %s!", entrycount, yylval.str);
 578                         do_exit(1);
 579                     }
 580
 581                     DBGL(DL_RCCF, (log(LL_DBG, "entry %d: clone = %s", entrycount, yylval.str)));
 582
 583                     memcpy(&cfg_entry_tab[entrycount], &cfg_entry_tab[i],
 584                            sizeof(cfg_entry_tab[0]));
 585
 586                     if (cfg_entry_tab[entrycount].answerprog)
 587                         cfg_entry_tab[entrycount].answerprog = strdup(cfg_entry_tab[entrycount].answerprog);
 588                     if (cfg_entry_tab[entrycount].budget_callbacks_file)
 589                         cfg_entry_tab[entrycount].budget_callbacks_file = strdup(cfg_entry_tab[entrycount].budget_callbacks_file);
 590                     if (cfg_entry_tab[entrycount].budget_callouts_file)
 591                         cfg_entry_tab[entrycount].budget_callouts_file = strdup(cfg_entry_tab[entrycount].budget_callouts_file);
 592                     if (cfg_entry_tab[entrycount].connectprog)
 593                         cfg_entry_tab[entrycount].connectprog = strdup(cfg_entry_tab[entrycount].connectprog);
 594                     if (cfg_entry_tab[entrycount].disconnectprog)
 595                         cfg_entry_tab[entrycount].disconnectprog = strdup(cfg_entry_tab[entrycount].disconnectprog);
 596                     break;
 597
 598                 case CONNECTPROG:
 599                         if((cfg_entry_tab[entrycount].connectprog = malloc(strlen(yylval.str)+1)) == NULL)
 600                         {
 601                                 log(LL_ERR, "entry %d: connectprog, malloc failed!", entrycount);
 602                                 do_exit(1);
 603                         }
 604                         strcpy(cfg_entry_tab[entrycount].connectprog, yylval.str);
 605                         DBGL(DL_RCCF, (log(LL_DBG, "entry %d: connectprog = %s", entrycount, yylval.str)));
 606                         break;
 607
 608                 case DIALOUTTYPE:
 609                         DBGL(DL_RCCF, (log(LL_DBG, "entry %d: dialouttype = %s", entrycount, yylval.str)));
 610                         if(!(strcmp(yylval.str, "normal")))
 611                                 cfg_entry_tab[entrycount].dialouttype = DIALOUT_NORMAL;
 612                         else if(!(strcmp(yylval.str, "calledback")))
 613                                 cfg_entry_tab[entrycount].dialouttype = DIALOUT_CALLEDBACK;
 614                         else
 615                         {
 616                                 log(LL_ERR, "ERROR parsing config file: unknown parameter for keyword \"dialout-type\" at line %d!", lineno);
 617                                 config_error_flag++;
 618                         }
 619                         break;
 620
 621                 case DIALRETRIES:
 622                         DBGL(DL_RCCF, (log(LL_DBG, "entry %d: dialretries = %d", entrycount, yylval.num)));
 623                         cfg_entry_tab[entrycount].dialretries = yylval.num;
 624                         break;
 625
 626                 case DIALRANDINCR:
 627                         DBGL(DL_RCCF, (log(LL_DBG, "entry %d: dialrandincr = %d", entrycount, yylval.booln)));
 628                         cfg_entry_tab[entrycount].dialrandincr = yylval.booln;
 629                         break;
 630
 631                 case DIRECTION:
 632                         DBGL(DL_RCCF, (log(LL_DBG, "entry %d: direction = %s", entrycount, yylval.str)));
 633
 634                         if(!(strcmp(yylval.str, "inout")))
 635                                 cfg_entry_tab[entrycount].inout = DIR_INOUT;
 636                         else if(!(strcmp(yylval.str, "in")))
 637                                 cfg_entry_tab[entrycount].inout = DIR_INONLY;
 638                         else if(!(strcmp(yylval.str, "out")))
 639                                 cfg_entry_tab[entrycount].inout = DIR_OUTONLY;
 640                         else
 641                         {
 642                                 log(LL_ERR, "ERROR parsing config file: unknown parameter for keyword \"direction\" at line %d!", lineno);
 643                                 config_error_flag++;
 644                         }
 645                         break;
 646
 647                 case DISCONNECTPROG:
 648                         if((cfg_entry_tab[entrycount].disconnectprog = malloc(strlen(yylval.str)+1)) == NULL)
 649                         {
 650                                 log(LL_ERR, "entry %d: disconnectprog, malloc failed!", entrycount);
 651                                 do_exit(1);
 652                         }
 653                         strcpy(cfg_entry_tab[entrycount].disconnectprog, yylval.str);
 654                         DBGL(DL_RCCF, (log(LL_DBG, "entry %d: disconnectprog = %s", entrycount, yylval.str)));
 655                         break;
 656
 657                 case DOWNTRIES:
 658                         if(yylval.num > DOWN_TRIES_MAX)
 659                                 yylval.num = DOWN_TRIES_MAX;
 660                         else if(yylval.num < DOWN_TRIES_MIN)
 661                                 yylval.num = DOWN_TRIES_MIN;
 662
 663                         DBGL(DL_RCCF, (log(LL_DBG, "entry %d: downtries = %d", entrycount, yylval.num)));
 664                         cfg_entry_tab[entrycount].downtries = yylval.num;
 665                         break;
 666
 667                 case DOWNTIME:
 668                         if(yylval.num > DOWN_TIME_MAX)
 669                                 yylval.num = DOWN_TIME_MAX;
 670                         else if(yylval.num < DOWN_TIME_MIN)
 671                                 yylval.num = DOWN_TIME_MIN;
 672
 673                         DBGL(DL_RCCF, (log(LL_DBG, "entry %d: downtime = %d", entrycount, yylval.num)));
 674                         cfg_entry_tab[entrycount].downtime = yylval.num;
 675                         break;
 676
 677                 case EARLYHANGUP:
 678                         DBGL(DL_RCCF, (log(LL_DBG, "entry %d: earlyhangup = %d", entrycount, yylval.num)));
 679                         cfg_entry_tab[entrycount].earlyhangup = yylval.num;
 680                         break;
 681
 682                 case EXTCALLATTR:
 683                         DBGL(DL_RCCF, (log(LL_DBG, "system: extcallattr = %d", yylval.booln)));
 684                         extcallattr = yylval.booln;
 685                         break;
 686
 687                 case FIRMWARE:
 688                         DBGL(DL_RCCF, (log(LL_DBG, "controller %d: firmware = %s", controllercount, yylval.str)));
 689                         isdn_ctrl_tab[controllercount].firmware = strdup(yylval.str);
 690                         break;
 691
 692                 case HOLIDAYFILE:
 693                         strcpy(holidayfile, yylval.str);
 694                         DBGL(DL_RCCF, (log(LL_DBG, "system: holidayfile = %s", yylval.str)));
 695                         break;
 696
 697                 case IDLE_ALG_OUT:
 698                         DBGL(DL_RCCF, (log(LL_DBG, "entry %d: idle-algorithm-outgoing = %s", entrycount, yylval.str)));
 699
 700                         if(!(strcmp(yylval.str, "fix-unit-size")))
 701                         {
 702                                 cfg_entry_tab[entrycount].shorthold_algorithm = SHA_FIXU;
 703                         }
 704                         else if(!(strcmp(yylval.str, "var-unit-size")))
 705                         {
 706                                 cfg_entry_tab[entrycount].shorthold_algorithm = SHA_VARU;
 707                         }
 708                         else
 709                         {
 710                                 log(LL_ERR, "ERROR parsing config file: unknown parameter for keyword \"idle-algorithm-outgoing\" at line %d!", lineno);
 711                                 config_error_flag++;
 712                         }
 713                         break;
 714
 715                 case IDLETIME_IN:
 716                         DBGL(DL_RCCF, (log(LL_DBG, "entry %d: idle_time_in = %d", entrycount, yylval.num)));
 717                         cfg_entry_tab[entrycount].idle_time_in = yylval.num;
 718                         break;
 719
 720                 case IDLETIME_OUT:
 721                         DBGL(DL_RCCF, (log(LL_DBG, "entry %d: idle_time_out = %d", entrycount, yylval.num)));
 722                         cfg_entry_tab[entrycount].idle_time_out = yylval.num;
 723                         break;
 724
 725                 case ISDNCONTROLLER:
 726                         cfg_entry_tab[entrycount].isdncontroller = yylval.num;
 727                         DBGL(DL_RCCF, (log(LL_DBG, "entry %d: isdncontroller = %d", entrycount, yylval.num)));
 728                         break;
 729
 730                 case ISDNCHANNEL:
 731                         if (yylval.num == 0 || yylval.num == -1)
 732                         {
 733                                         cfg_entry_tab[entrycount].isdnchannel = CHAN_ANY;
 734                                         DBGL(DL_RCCF, (log(LL_DBG, "entry %d: isdnchannel = any", entrycount)));
 735                         }
 736                         else if (yylval.num > MAX_BCHAN)
 737                         {
 738                                         log(LL_DBG, "entry %d: isdnchannel value out of range", entrycount);
 739                                         config_error_flag++;
 740                         }
 741                         else
 742                         {
 743                             cfg_entry_tab[entrycount].isdnchannel = yylval.num-1;
 744                             DBGL(DL_RCCF, (log(LL_DBG, "entry %d: isdnchannel = B%d", entrycount, yylval.num)));
 745                         }
 746                         break;
 747
 748                 case ISDNTIME:
 749                         DBGL(DL_RCCF, (log(LL_DBG, "system: isdntime = %d", yylval.booln)));
 750                         isdntime = yylval.booln;
 751                         break;
 752
 753                 case ISDNTXDELIN:
 754                         cfg_entry_tab[entrycount].isdntxdelin = yylval.num;
 755                         DBGL(DL_RCCF, (log(LL_DBG, "entry %d: isdntxdel-incoming = %d", entrycount, yylval.num)));
 756                         break;
 757
 758                 case ISDNTXDELOUT:
 759                         cfg_entry_tab[entrycount].isdntxdelout = yylval.num;
 760                         DBGL(DL_RCCF, (log(LL_DBG, "entry %d: isdntxdel-outgoing = %d", entrycount, yylval.num)));
 761                         break;
 762
 763                 case LOCAL_PHONE_DIALOUT:
 764                         DBGL(DL_RCCF, (log(LL_DBG, "entry %d: local_phone_dialout = %s", entrycount, yylval.str)));
 765                         strcpy(cfg_entry_tab[entrycount].local_phone_dialout, yylval.str);
 766                         break;
 767
 768                 case LOCAL_PHONE_INCOMING:
 769                         DBGL(DL_RCCF, (log(LL_DBG, "entry %d: local_phone_incoming = %s", entrycount, yylval.str)));
 770                         strcpy(cfg_entry_tab[entrycount].local_phone_incoming, yylval.str);
 771                         break;
 772
 773                 case MAILER:
 774                         strcpy(mailer, yylval.str);
 775                         DBGL(DL_RCCF, (log(LL_DBG, "system: mailer = %s", yylval.str)));
 776                         break;
 777
 778                 case MAILTO:
 779                         strcpy(mailto, yylval.str);
 780                         DBGL(DL_RCCF, (log(LL_DBG, "system: mailto = %s", yylval.str)));
 781                         break;
 782
 783                 case MAXCONNECTTIME:
 784                         DBGL(DL_RCCF, (log(LL_DBG, "entry %d: maxconnecttime = %d", entrycount, yylval.num)));
 785                         cfg_entry_tab[entrycount].maxconnecttime = yylval.num;
 786                         break;
 787
 788                 case MONITORPORT:
 789                         monitorport = yylval.num;
 790                         DBGL(DL_RCCF, (log(LL_DBG, "system: monitorport = %d", yylval.num)));
 791                         break;
 792
 793                 case MONITORSW:
 794                         if (yylval.booln && inhibit_monitor)
 795                         {
 796                                 do_monitor = 0;
 797                                 DBGL(DL_RCCF, (log(LL_DBG, "system: monitor-enable overriden by command line flag")));
 798                         }
 799                         else
 800                         {
 801                                 do_monitor = yylval.booln;
 802                                 DBGL(DL_RCCF, (log(LL_DBG, "system: monitor-enable = %d", yylval.booln)));
 803                         }
 804                         break;
 805
 806                 case NAME:
 807                         DBGL(DL_RCCF, (log(LL_DBG, "entry %d: name = %s", entrycount, yylval.str)));
 808                         strcpy(cfg_entry_tab[entrycount].name, yylval.str);
 809                         break;
 810
 811                 case PPP_AUTH_RECHALLENGE:
 812                         DBGL(DL_RCCF, (log(LL_DBG, "entry %d: ppp-auth-rechallenge = %d", entrycount, yylval.booln)));
 813                         if(yylval.booln)
 814                                 cfg_entry_tab[entrycount].ppp_auth_flags |= AUTH_RECHALLENGE;
 815                         else
 816                                 cfg_entry_tab[entrycount].ppp_auth_flags &= ~AUTH_RECHALLENGE;
 817                         set_isppp_auth(entrycount);
 818                         break;
 819
 820                 case PPP_AUTH_PARANOID:
 821                         DBGL(DL_RCCF, (log(LL_DBG, "entry %d: ppp-auth-paranoid = %d", entrycount, yylval.booln)));
 822                         if(yylval.booln)
 823                                 cfg_entry_tab[entrycount].ppp_auth_flags |= AUTH_REQUIRED;
 824                         else
 825                                 cfg_entry_tab[entrycount].ppp_auth_flags &= ~AUTH_REQUIRED;
 826                         set_isppp_auth(entrycount);
 827                         break;
 828
 829                 case PPP_EXPECT_AUTH:
 830                         DBGL(DL_RCCF, (log(LL_DBG, "entry %d: ppp-expect-auth = %s", entrycount, yylval.str)));
 831                         if(!(strcmp(yylval.str, "none")))
 832                                 cfg_entry_tab[entrycount].ppp_expect_auth = AUTH_NONE;
 833                         else if(!(strcmp(yylval.str, "pap")))
 834                                 cfg_entry_tab[entrycount].ppp_expect_auth = AUTH_PAP;
 835                         else if(!(strcmp(yylval.str, "chap")))
 836                                 cfg_entry_tab[entrycount].ppp_expect_auth = AUTH_CHAP;
 837                         else
 838                         {
 839                                 log(LL_ERR, "ERROR parsing config file: unknown parameter for keyword \"ppp-expect-auth\" at line %d!", lineno);
 840                                 config_error_flag++;
 841                                 break;
 842                         }
 843                         set_isppp_auth(entrycount);
 844                         break;
 845
 846                 case PPP_EXPECT_NAME:
 847                         DBGL(DL_RCCF, (log(LL_DBG, "entry %d: ppp-expect-name = %s", entrycount, yylval.str)));
 848                         strncpy(cfg_entry_tab[entrycount].ppp_expect_name, yylval.str, sizeof(cfg_entry_tab[entrycount].ppp_expect_name) -1);
 849                         set_isppp_auth(entrycount);
 850                         break;
 851
 852                 case PPP_EXPECT_PASSWORD:
 853                         DBGL(DL_RCCF, (log(LL_DBG, "entry %d: ppp-expect-password = %s", entrycount, yylval.str)));
 854                         strncpy(cfg_entry_tab[entrycount].ppp_expect_password, yylval.str, sizeof(cfg_entry_tab[entrycount].ppp_expect_password) -1);
 855                         set_isppp_auth(entrycount);
 856                         break;
 857
 858                 case PPP_SEND_AUTH:
 859                         DBGL(DL_RCCF, (log(LL_DBG, "entry %d: ppp-send-auth = %s", entrycount, yylval.str)));
 860                         if(!(strcmp(yylval.str, "none")))
 861                                 cfg_entry_tab[entrycount].ppp_send_auth = AUTH_NONE;
 862                         else if(!(strcmp(yylval.str, "pap")))
 863                                 cfg_entry_tab[entrycount].ppp_send_auth = AUTH_PAP;
 864                         else if(!(strcmp(yylval.str, "chap")))
 865                                 cfg_entry_tab[entrycount].ppp_send_auth = AUTH_CHAP;
 866                         else
 867                         {
 868                                 log(LL_ERR, "ERROR parsing config file: unknown parameter for keyword \"ppp-send-auth\" at line %d!", lineno);
 869                                 config_error_flag++;
 870                                 break;
 871                         }
 872                         set_isppp_auth(entrycount);
 873                         break;
 874
 875                 case PPP_SEND_NAME:
 876                         DBGL(DL_RCCF, (log(LL_DBG, "entry %d: ppp-send-name = %s", entrycount, yylval.str)));
 877                         strncpy(cfg_entry_tab[entrycount].ppp_send_name, yylval.str, sizeof(cfg_entry_tab[entrycount].ppp_send_name) -1);
 878                         set_isppp_auth(entrycount);
 879                         break;
 880
 881                 case PPP_SEND_PASSWORD:
 882                         DBGL(DL_RCCF, (log(LL_DBG, "entry %d: ppp-send-password = %s", entrycount, yylval.str)));
 883                         strncpy(cfg_entry_tab[entrycount].ppp_send_password, yylval.str, sizeof(cfg_entry_tab[entrycount].ppp_send_password) -1);
 884                         set_isppp_auth(entrycount);
 885                         break;
 886
 887                 case PROTOCOL:
 888                         DBGL(DL_RCCF, (log(LL_DBG, "controller %d: protocol = %s", controllercount, yylval.str)));
 889                         if(!(strcmp(yylval.str, "dss1")))
 890                                 isdn_ctrl_tab[controllercount].protocol = PROTOCOL_DSS1;
 891                         else if(!(strcmp(yylval.str, "d64s")))
 892                                 isdn_ctrl_tab[controllercount].protocol = PROTOCOL_D64S;
 893                         else
 894                         {
 895                                 log(LL_ERR, "ERROR parsing config file: unknown parameter for keyword \"protocol\" at line %d!", lineno);
 896                                 config_error_flag++;
 897                         }
 898                         break;
 899
 900                 case REACTION:
 901                         DBGL(DL_RCCF, (log(LL_DBG, "entry %d: dialin_reaction = %s", entrycount, yylval.str)));
 902                         if(!(strcmp(yylval.str, "accept")))
 903                                 cfg_entry_tab[entrycount].dialin_reaction = REACT_ACCEPT;
 904                         else if(!(strcmp(yylval.str, "reject")))
 905                                 cfg_entry_tab[entrycount].dialin_reaction = REACT_REJECT;
 906                         else if(!(strcmp(yylval.str, "ignore")))
 907                                 cfg_entry_tab[entrycount].dialin_reaction = REACT_IGNORE;
 908                         else if(!(strcmp(yylval.str, "answer")))
 909                                 cfg_entry_tab[entrycount].dialin_reaction = REACT_ANSWER;
 910                         else if(!(strcmp(yylval.str, "callback")))
 911                                 cfg_entry_tab[entrycount].dialin_reaction = REACT_CALLBACK;
 912                         else
 913                         {
 914                                 log(LL_ERR, "ERROR parsing config file: unknown parameter for keyword \"dialin_reaction\" at line %d!", lineno);
 915                                 config_error_flag++;
 916                         }
 917                         break;
 918
 919                 case REMOTE_PHONE_DIALOUT:
 920                         if(cfg_entry_tab[entrycount].remote_numbers_count >= MAXRNUMBERS)
 921                         {
 922                                 log(LL_ERR, "ERROR parsing config file: too many remote numbers at line %d!", lineno);
 923                                 config_error_flag++;
 924                                 break;
 925                         }
 926
 927                         DBGL(DL_RCCF, (log(LL_DBG, "entry %d: remote_phone_dialout #%d = %s",
 928                                 entrycount, cfg_entry_tab[entrycount].remote_numbers_count, yylval.str)));
 929
 930                         strcpy(cfg_entry_tab[entrycount].remote_numbers[cfg_entry_tab[entrycount].remote_numbers_count].number, yylval.str);
 931                         cfg_entry_tab[entrycount].remote_numbers[cfg_entry_tab[entrycount].remote_numbers_count].flag = 0;
 932
 933                         cfg_entry_tab[entrycount].remote_numbers_count++;
 934
 935                         break;
 936
 937                 case REMOTE_NUMBERS_HANDLING:
 938                         DBGL(DL_RCCF, (log(LL_DBG, "entry %d: remdial_handling = %s", entrycount, yylval.str)));
 939                         if(!(strcmp(yylval.str, "next")))
 940                                 cfg_entry_tab[entrycount].remote_numbers_handling = RNH_NEXT;
 941                         else if(!(strcmp(yylval.str, "last")))
 942                                 cfg_entry_tab[entrycount].remote_numbers_handling = RNH_LAST;
 943                         else if(!(strcmp(yylval.str, "first")))
 944                                 cfg_entry_tab[entrycount].remote_numbers_handling = RNH_FIRST;
 945                         else
 946                         {
 947                                 log(LL_ERR, "ERROR parsing config file: unknown parameter for keyword \"remdial_handling\" at line %d!", lineno);
 948                                 config_error_flag++;
 949                         }
 950                         break;
 951
 952                 case REMOTE_PHONE_INCOMING:
 953                         {
 954                                 int n;
 955                                 n = cfg_entry_tab[entrycount].incoming_numbers_count;
 956                                 if (n >= MAX_INCOMING)
 957                                 {
 958                                         log(LL_ERR, "ERROR parsing config file: too many \"remote_phone_incoming\" entries at line %d!", lineno);
 959                                         config_error_flag++;
 960                                         break;
 961                                 }
 962                                 DBGL(DL_RCCF, (log(LL_DBG, "entry %d: remote_phone_incoming #%d = %s", entrycount, n, yylval.str)));
 963                                 strcpy(cfg_entry_tab[entrycount].remote_phone_incoming[n].number, yylval.str);
 964                                 cfg_entry_tab[entrycount].incoming_numbers_count++;
 965                         }
 966                         break;
 967
 968                 case RATESFILE:
 969                         strcpy(ratesfile, yylval.str);
 970                         DBGL(DL_RCCF, (log(LL_DBG, "system: ratesfile = %s", yylval.str)));
 971                         break;
 972
 973                 case RATETYPE:
 974                         DBGL(DL_RCCF, (log(LL_DBG, "entry %d: ratetype = %d", entrycount, yylval.num)));
 975                         cfg_entry_tab[entrycount].ratetype = yylval.num;
 976                         break;
 977
 978                 case RECOVERYTIME:
 979                         if(yylval.num < RECOVERYTIME_MIN)
 980                         {
 981                                 yylval.num = RECOVERYTIME_MIN;
 982                                 DBGL(DL_RCCF, (log(LL_DBG, "entry %d: recoverytime < %d, min = %d", entrycount, RECOVERYTIME_MIN, yylval.num)));
 983                         }
 984
 985                         DBGL(DL_RCCF, (log(LL_DBG, "entry %d: recoverytime = %d", entrycount, yylval.num)));
 986                         cfg_entry_tab[entrycount].recoverytime = yylval.num;
 987                         break;
 988
 989                 case REGEXPR:
 990                         if(nregexpr >= MAX_RE)
 991                         {
 992                                 log(LL_ERR, "system: regexpr #%d >= MAX_RE", nregexpr);
 993                                 config_error_flag++;
 994                                 break;
 995                         }
 996
 997                         if((i = regcomp(&(rarr[nregexpr].re), yylval.str, REG_EXTENDED|REG_NOSUB)) != 0)
 998                         {
 999                                 char buf[256];
1000                                 regerror(i, &(rarr[nregexpr].re), buf, sizeof(buf));
1001                                 log(LL_ERR, "system: regcomp error for %s: [%s]", yylval.str, buf);
1002                                 config_error_flag++;
1003                                 break;
1004                         }
1005                         else
1006                         {
1007                                 if((rarr[nregexpr].re_expr = malloc(strlen(yylval.str)+1)) == NULL)
1008                                 {
1009                                         log(LL_ERR, "system: regexpr malloc error error for %s", yylval.str);
1010                                         config_error_flag++;
1011                                         break;
1012                                 }
1013                                 strcpy(rarr[nregexpr].re_expr, yylval.str);
1014
1015                                 DBGL(DL_RCCF, (log(LL_DBG, "system: regexpr %s stored into slot %d", yylval.str, nregexpr)));
1016
1017                                 if(rarr[nregexpr].re_prog != NULL)
1018                                         rarr[nregexpr].re_flg = 1;
1019
1020                                 nregexpr++;
1021
1022                         }
1023                         break;
1024
1025                 case REGPROG:
1026                         if(nregprog >= MAX_RE)
1027                         {
1028                                 log(LL_ERR, "system: regprog #%d >= MAX_RE", nregprog);
1029                                 config_error_flag++;
1030                                 break;
1031                         }
1032                         if((rarr[nregprog].re_prog = malloc(strlen(yylval.str)+1)) == NULL)
1033                         {
1034                                 log(LL_ERR, "system: regprog malloc error error for %s", yylval.str);
1035                                 config_error_flag++;
1036                                 break;
1037                         }
1038                         strcpy(rarr[nregprog].re_prog, yylval.str);
1039
1040                         DBGL(DL_RCCF, (log(LL_DBG, "system: regprog %s stored into slot %d", yylval.str, nregprog)));
1041
1042                         if(rarr[nregprog].re_expr != NULL)
1043                                 rarr[nregprog].re_flg = 1;
1044
1045                         nregprog++;
1046                         break;
1047
1048                 case ROTATESUFFIX:
1049                         strcpy(rotatesuffix, yylval.str);
1050                         DBGL(DL_RCCF, (log(LL_DBG, "system: rotatesuffix = %s", yylval.str)));
1051                         break;
1052
1053                 case RTPRIO:
1054 #ifdef USE_RTPRIO
1055                         rt_prio = yylval.num;
1056                         if(rt_prio < RTP_PRIO_MIN || rt_prio > RTP_PRIO_MAX)
1057                         {
1058                                 config_error_flag++;
1059                                 log(LL_ERR, "system: error, rtprio (%d) out of range!", yylval.num);
1060                         }
1061                         else
1062                         {
1063                                 DBGL(DL_RCCF, (log(LL_DBG, "system: rtprio = %d", yylval.num)));
1064                         }
1065 #else
1066                         rt_prio = RTPRIO_NOTUSED;
1067 #endif
1068                         break;
1069
1070                 case TINAINITPROG:
1071                         strcpy(tinainitprog, yylval.str);
1072                         DBGL(DL_RCCF, (log(LL_DBG, "system: tinainitprog = %s", yylval.str)));
1073                         break;
1074
1075                 case UNITLENGTH:
1076                         DBGL(DL_RCCF, (log(LL_DBG, "entry %d: unitlength = %d", entrycount, yylval.num)));
1077                         cfg_entry_tab[entrycount].unitlength = yylval.num;
1078                         break;
1079
1080                 case UNITLENGTHSRC:
1081                         DBGL(DL_RCCF, (log(LL_DBG, "entry %d: unitlengthsrc = %s", entrycount, yylval.str)));
1082                         if(!(strcmp(yylval.str, "none")))
1083                                 cfg_entry_tab[entrycount].unitlengthsrc = ULSRC_NONE;
1084                         else if(!(strcmp(yylval.str, "cmdl")))
1085                                 cfg_entry_tab[entrycount].unitlengthsrc = ULSRC_CMDL;
1086                         else if(!(strcmp(yylval.str, "conf")))
1087                                 cfg_entry_tab[entrycount].unitlengthsrc = ULSRC_CONF;
1088                         else if(!(strcmp(yylval.str, "rate")))
1089                                 cfg_entry_tab[entrycount].unitlengthsrc = ULSRC_RATE;
1090                         else if(!(strcmp(yylval.str, "aocd")))
1091                                 cfg_entry_tab[entrycount].unitlengthsrc = ULSRC_DYN;
1092                         else
1093                         {
1094                                 log(LL_ERR, "ERROR parsing config file: unknown parameter for keyword \"unitlengthsrc\" at line %d!", lineno);
1095                                 config_error_flag++;
1096                         }
1097                         break;
1098
1099                 case USRDEVICENAME:
1100                         DBGL(DL_RCCF, (log(LL_DBG, "entry %d: usrdevicename = %s", entrycount, yylval.str)));
1101                         if(!strcmp(yylval.str, "rbch"))
1102                                 cfg_entry_tab[entrycount].usrdevicename = BDRV_RBCH;
1103                         else if(!strcmp(yylval.str, "tel"))
1104                                 cfg_entry_tab[entrycount].usrdevicename = BDRV_TEL;
1105                         else if(!strcmp(yylval.str, "ipr"))
1106                                 cfg_entry_tab[entrycount].usrdevicename = BDRV_IPR;
1107                         else if(!strcmp(yylval.str, "isp"))
1108                                 cfg_entry_tab[entrycount].usrdevicename = BDRV_ISPPP;
1109 #ifdef __bsdi__
1110                         else if(!strcmp(yylval.str, "ibc"))
1111                                 cfg_entry_tab[entrycount].usrdevicename = BDRV_IBC;
1112 #endif
1113                         else if(!strcmp(yylval.str, "ing"))
1114                                 cfg_entry_tab[entrycount].usrdevicename = BDRV_ING;
1115                         else
1116                         {
1117                                 log(LL_ERR, "ERROR parsing config file: unknown parameter for keyword \"usrdevicename\" at line %d!", lineno);
1118                                 config_error_flag++;
1119                         }
1120                         break;
1121
1122                 case USRDEVICEUNIT:
1123                         DBGL(DL_RCCF, (log(LL_DBG, "entry %d: usrdeviceunit = %d", entrycount, yylval.num)));
1124                         cfg_entry_tab[entrycount].usrdeviceunit = yylval.num;
1125                         break;
1126
1127                 case USEACCTFILE:
1128                         useacctfile = yylval.booln;
1129                         DBGL(DL_RCCF, (log(LL_DBG, "system: useacctfile = %d", yylval.booln)));
1130                         break;
1131
1132                 case USEDOWN:
1133                         DBGL(DL_RCCF, (log(LL_DBG, "entry %d: usedown = %d", entrycount, yylval.booln)));
1134                         cfg_entry_tab[entrycount].usedown = yylval.booln;
1135                         break;
1136
1137                 case VALID:
1138                         DBGL(DL_RCCF, (log(LL_DBG, "entry %d: valid = %s", entrycount, yylval.str)));
1139                         parse_valid(entrycount, yylval.str);
1140                         break;
1141
1142                 default:
1143                         log(LL_ERR, "ERROR parsing config file: unknown keyword at line %d!", lineno);
1144                         config_error_flag++;
1145                         break;
1146         }
1147 }
1148
1149 /*---------------------------------------------------------------------------*
1150  *      parse a date/time range
1151  *---------------------------------------------------------------------------*/
1152 static void
1153 parse_valid(int entrycount, char *dt)
1154 {
1155         /* a valid string consists of some days of week separated by
1156          * commas, where 0=sunday, 1=monday .. 6=saturday and a special
1157          * value of 7 which is a holiday from the holiday file.
1158          * after the days comes an optional (!) time range in the form
1159          * aa:bb-cc:dd, this format is fixed to be parsable by sscanf.
1160          * Valid specifications looks like this:
1161          * 1,2,3,4,5,09:00-18:00        Monday-Friday 9-18h
1162          * 1,2,3,4,5,18:00-09:00        Monday-Friday 18-9h
1163          * 6                            Saturday (whole day)
1164          * 0,7                          Sunday and Holidays
1165          */
1166
1167         int day = 0;
1168         int fromhr = 0;
1169         int frommin = 0;
1170         int tohr = 0;
1171         int tomin = 0;
1172         int ret;
1173
1174         for(;;)
1175         {
1176                 if( ( ((*dt >= '0') && (*dt <= '9')) && (*(dt+1) == ':') ) ||
1177                     ( ((*dt >= '0') && (*dt <= '2')) && ((*(dt+1) >= '0') && (*(dt+1) <= '9')) && (*(dt+2) == ':') ) )
1178                 {
1179                         /* dt points to time spec */
1180                         ret = sscanf(dt, "%d:%d-%d:%d", &fromhr, &frommin, &tohr, &tomin);
1181                         if(ret !=4)
1182                         {
1183                                 log(LL_ERR, "ERROR parsing config file: timespec [%s] error at line %d!", *dt, lineno);
1184                                 config_error_flag++;
1185                                 return;
1186                         }
1187
1188                         if(fromhr < 0 || fromhr > 24 || tohr < 0 || tohr > 24 ||
1189                            frommin < 0 || frommin > 59 || tomin < 0 || tomin > 59)
1190                         {
1191                                 log(LL_ERR, "ERROR parsing config file: invalid time [%s] at line %d!", *dt, lineno);
1192                                 config_error_flag++;
1193                                 return;
1194                         }
1195                         break;
1196                 }
1197                 else if ((*dt >= '0') && (*dt <= '7'))
1198                 {
1199                         /* dt points to day spec */
1200                         day |= 1 << (*dt - '0');
1201                         dt++;
1202                         continue;
1203                 }
1204                 else if (*dt == ',')
1205                 {
1206                         /* dt points to delimiter */
1207                         dt++;
1208                         continue;
1209                 }
1210                 else if (*dt == '\0')
1211                 {
1212                         /* dt points to end of string */
1213                         break;
1214                 }
1215                 else
1216                 {
1217                         /* dt points to illegal character */
1218                         log(LL_ERR, "ERROR parsing config file: illegal character [%c=0x%x] in date/time spec at line %d!", *dt, *dt, lineno);
1219                         config_error_flag++;
1220                         return;
1221                 }
1222         }
1223         cfg_entry_tab[entrycount].day = day;
1224         cfg_entry_tab[entrycount].fromhr = fromhr;
1225         cfg_entry_tab[entrycount].frommin = frommin;
1226         cfg_entry_tab[entrycount].tohr = tohr;
1227         cfg_entry_tab[entrycount].tomin = tomin;
1228 }
1229
1230 /*---------------------------------------------------------------------------*
1231  *      configuration validation and consistency check
1232  *---------------------------------------------------------------------------*/
1233 static void
1234 check_config(void)
1235 {
1236         cfg_entry_t *cep = &cfg_entry_tab[0];   /* ptr to config entry */
1237         int i;
1238         int error = 0;
1239
1240         /* regular expression table */
1241
1242         for(i=0; i < MAX_RE; i++)
1243         {
1244                 if((rarr[i].re_expr != NULL) && (rarr[i].re_prog == NULL))
1245                 {
1246                         log(LL_ERR, "check_config: regular expression %d without program!", i);
1247                         error++;
1248                 }
1249                 if((rarr[i].re_prog != NULL) && (rarr[i].re_expr == NULL))
1250                 {
1251                         log(LL_ERR, "check_config: regular expression program %d without expression!", i);
1252                         error++;
1253                 }
1254         }
1255
1256         /* entry sections */
1257
1258         for(i=0; i <= entrycount; i++, cep++)
1259         {
1260                 /* isdn controller number */
1261
1262                 if((cep->isdncontroller < -1) || (cep->isdncontroller > (ncontroller-1)))
1263                 {
1264                         log(LL_ERR, "check_config: WARNING, isdncontroller out of range in entry %d!", i);
1265                 }
1266
1267                 /* numbers used for dialout */
1268
1269                 if((cep->inout != DIR_INONLY) && (cep->dialin_reaction != REACT_ANSWER))
1270                 {
1271                         if(cep->remote_numbers_count == 0)
1272                         {
1273                                 log(LL_ERR, "check_config: remote-phone-dialout not set in entry %d!", i);
1274                                 error++;
1275                         }
1276                         if(strlen(cep->local_phone_dialout) == 0)
1277                         {
1278                                 log(LL_ERR, "check_config: local-phone-dialout not set in entry %d!", i);
1279                                 error++;
1280                         }
1281                 }
1282
1283                 /* numbers used for incoming calls */
1284
1285                 if(cep->inout != DIR_OUTONLY)
1286                 {
1287                         if(strlen(cep->local_phone_incoming) == 0)
1288                         {
1289                                 log(LL_ERR, "check_config: local-phone-incoming not set in entry %d!", i);
1290                                 error++;
1291                         }
1292                         if(cep->incoming_numbers_count == 0)
1293                         {
1294                                 log(LL_ERR, "check_config: remote-phone-incoming not set in entry %d!", i);
1295                                 error++;
1296                         }
1297                 }
1298
1299                 if((cep->dialin_reaction == REACT_ANSWER) && (cep->b1protocol != BPROT_NONE))
1300                 {
1301                         log(LL_ERR, "check_config: b1protocol not raw for telephony in entry %d!", i);
1302                         error++;
1303                 }
1304
1305                 if((cep->ppp_send_auth == AUTH_PAP) || (cep->ppp_send_auth == AUTH_CHAP))
1306                 {
1307                         if(cep->ppp_send_name[0] == 0)
1308                         {
1309                                 log(LL_ERR, "check_config: no remote authentification name in entry %d!", i);
1310                                 error++;
1311                         }
1312                         if(cep->ppp_send_password[0] == 0)
1313                         {
1314                                 log(LL_ERR, "check_config: no remote authentification password in entry %d!", i);
1315                                 error++;
1316                         }
1317                 }
1318                 if((cep->ppp_expect_auth == AUTH_PAP) || (cep->ppp_expect_auth == AUTH_CHAP))
1319                 {
1320                         if(cep->ppp_expect_name[0] == 0)
1321                         {
1322                                 log(LL_ERR, "check_config: no local authentification name in entry %d!", i);
1323                                 error++;
1324                         }
1325                         if(cep->ppp_expect_password[0] == 0)
1326                         {
1327                                 log(LL_ERR, "check_config: no local authentification secret in entry %d!", i);
1328                                 error++;
1329                         }
1330                 }
1331         }
1332         if(error)
1333         {
1334                 log(LL_ERR, "check_config: %d error(s) in configuration file, exit!", error);
1335                 do_exit(1);
1336         }
1337 }
1338
1339 /*---------------------------------------------------------------------------*
1340  *      print the configuration
1341  *---------------------------------------------------------------------------*/
1342 static void
1343 print_config(void)
1344 {
1345 #define PFILE stdout
1346
1347 #ifdef I4B_EXTERNAL_MONITOR
1348         extern struct monitor_rights * monitor_next_rights(const struct monitor_rights *r);
1349         struct monitor_rights *m_rights;
1350 #endif
1351         cfg_entry_t *cep = &cfg_entry_tab[0];   /* ptr to config entry */
1352         int i, j;
1353         time_t clock;
1354         char mytime[64];
1355
1356         time(&clock);
1357         strcpy(mytime, ctime(&clock));
1358         mytime[strlen(mytime)-1] = '\0';
1359
1360         fprintf(PFILE, "#---------------------------------------------------------------------------\n");
1361         fprintf(PFILE, "# system section (generated %s)\n", mytime);
1362         fprintf(PFILE, "#---------------------------------------------------------------------------\n");
1363         fprintf(PFILE, "system\n");
1364         fprintf(PFILE, "useacctfile     = %s\n", useacctfile ? "on\t\t\t\t# update accounting information file" : "off\t\t\t\t# don't update accounting information file");
1365         fprintf(PFILE, "acctall         = %s\n", acct_all ? "on\t\t\t\t# put all events into accounting file" : "off\t\t\t\t# put only charged events into accounting file");
1366         fprintf(PFILE, "acctfile        = %s\t\t# accounting information file\n", acctfile);
1367         fprintf(PFILE, "ratesfile       = %s\t\t# charging rates database file\n", ratesfile);
1368
1369 #ifdef USE_RTPRIO
1370         if(rt_prio == RTPRIO_NOTUSED)
1371                 fprintf(PFILE, "# rtprio is unused\n");
1372         else
1373                 fprintf(PFILE, "rtprio          = %d\t\t\t\t# isdnd runs at realtime priority\n", rt_prio);
1374 #endif
1375
1376         /* regular expression table */
1377
1378         for(i=0; i < MAX_RE; i++)
1379         {
1380                 if(rarr[i].re_expr != NULL)
1381                 {
1382                         fprintf(PFILE, "regexpr         = \"%s\"\t\t# scan logfile for this expression\n", rarr[i].re_expr);
1383                 }
1384                 if(rarr[i].re_prog != NULL)
1385                 {
1386                         fprintf(PFILE, "regprog         = %s\t\t# program to run when expression is matched\n", rarr[i].re_prog);
1387                 }
1388         }
1389
1390 #ifdef I4B_EXTERNAL_MONITOR
1391
1392         fprintf(PFILE, "monitor-allowed = %s\n", do_monitor ? "on\t\t\t\t# remote isdnd monitoring allowed" : "off\t\t\t\t# remote isdnd monitoring disabled");
1393         fprintf(PFILE, "monitor-port    = %d\t\t\t\t# TCP/IP port number used for remote monitoring\n", monitorport);
1394
1395         m_rights = monitor_next_rights(NULL);
1396         if(m_rights != NULL)
1397         {
1398                 char *s = "error\n";
1399                 char b[512];
1400
1401                 for ( ; m_rights != NULL; m_rights = monitor_next_rights(m_rights))
1402                 {
1403                         if(m_rights->local)
1404                         {
1405                                 fprintf(PFILE, "monitor         = \"%s\"\t\t# local socket name for monitoring\n", m_rights->name);
1406                         }
1407                         else
1408                         {
1409                                 struct in_addr ia;
1410                                 ia.s_addr = ntohl(m_rights->net);
1411
1412                                 switch(m_rights->mask)
1413                                 {
1414                                         case 0xffffffff:
1415                                                 s = "32";
1416                                                 break;
1417                                         case 0xfffffffe:
1418                                                 s = "31";
1419                                                 break;
1420                                         case 0xfffffffc:
1421                                                 s = "30";
1422                                                 break;
1423                                         case 0xfffffff8:
1424                                                 s = "29";
1425                                                 break;
1426                                         case 0xfffffff0:
1427                                                 s = "28";
1428                                                 break;
1429                                         case 0xffffffe0:
1430                                                 s = "27";
1431                                                 break;
1432                                         case 0xffffffc0:
1433                                                 s = "26";
1434                                                 break;
1435                                         case 0xffffff80:
1436                                                 s = "25";
1437                                                 break;
1438                                         case 0xffffff00:
1439                                                 s = "24";
1440                                                 break;
1441                                         case 0xfffffe00:
1442                                                 s = "23";
1443                                                 break;
1444                                         case 0xfffffc00:
1445                                                 s = "22";
1446                                                 break;
1447                                         case 0xfffff800:
1448                                                 s = "21";
1449                                                 break;
1450                                         case 0xfffff000:
1451                                                 s = "20";
1452                                                 break;
1453                                         case 0xffffe000:
1454                                                 s = "19";
1455                                                 break;
1456                                         case 0xffffc000:
1457                                                 s = "18";
1458                                                 break;
1459                                         case 0xffff8000:
1460                                                 s = "17";
1461                                                 break;
1462                                         case 0xffff0000:
1463                                                 s = "16";
1464                                                 break;
1465                                         case 0xfffe0000:
1466                                                 s = "15";
1467                                                 break;
1468                                         case 0xfffc0000:
1469                                                 s = "14";
1470                                                 break;
1471                                         case 0xfff80000:
1472                                                 s = "13";
1473                                                 break;
1474                                         case 0xfff00000:
1475                                                 s = "12";
1476                                                 break;
1477                                         case 0xffe00000:
1478                                                 s = "11";
1479                                                 break;
1480                                         case 0xffc00000:
1481                                                 s = "10";
1482                                                 break;
1483                                         case 0xff800000:
1484                                                 s = "9";
1485                                                 break;
1486                                         case 0xff000000:
1487                                                 s = "8";
1488                                                 break;
1489                                         case 0xfe000000:
1490                                                 s = "7";
1491                                                 break;
1492                                         case 0xfc000000:
1493                                                 s = "6";
1494                                                 break;
1495                                         case 0xf8000000:
1496                                                 s = "5";
1497                                                 break;
1498                                         case 0xf0000000:
1499                                                 s = "4";
1500                                                 break;
1501                                         case 0xe0000000:
1502                                                 s = "3";
1503                                                 break;
1504                                         case 0xc0000000:
1505                                                 s = "2";
1506                                                 break;
1507                                         case 0x80000000:
1508                                                 s = "1";
1509                                                 break;
1510                                         case 0x00000000:
1511                                                 s = "0";
1512                                                 break;
1513                                 }
1514                                 fprintf(PFILE, "monitor         = \"%s/%s\"\t\t# host (net/mask) allowed to connect for monitoring\n", inet_ntoa(ia), s);
1515                         }
1516                         b[0] = '\0';
1517
1518                         if((m_rights->rights) & I4B_CA_COMMAND_FULL)
1519                                 strcat(b, "fullcmd,");
1520                         if((m_rights->rights) & I4B_CA_COMMAND_RESTRICTED)
1521                                 strcat(b, "restrictedcmd,");
1522                         if((m_rights->rights) & I4B_CA_EVNT_CHANSTATE)
1523                                 strcat(b, "channelstate,");
1524                         if((m_rights->rights) & I4B_CA_EVNT_CALLIN)
1525                                 strcat(b, "callin,");
1526                         if((m_rights->rights) & I4B_CA_EVNT_CALLOUT)
1527                                 strcat(b, "callout,");
1528                         if((m_rights->rights) & I4B_CA_EVNT_I4B)
1529                                 strcat(b, "logevents,");
1530
1531                         if(b[strlen(b)-1] == ',')
1532                                 b[strlen(b)-1] = '\0';
1533
1534                         fprintf(PFILE, "monitor-access  = %s\t\t# monitor access rights\n", b);
1535                 }
1536         }
1537
1538 #endif
1539         /* entry sections */
1540
1541         for(i=0; i <= entrycount; i++, cep++)
1542         {
1543                 fprintf(PFILE, "\n");
1544                 fprintf(PFILE, "#---------------------------------------------------------------------------\n");
1545                 fprintf(PFILE, "# entry section %d\n", i);
1546                 fprintf(PFILE, "#---------------------------------------------------------------------------\n");
1547                 fprintf(PFILE, "entry\n");
1548
1549                 fprintf(PFILE, "name                  = %s\t\t# name for this entry section\n", cep->name);
1550
1551                 fprintf(PFILE, "isdncontroller        = %d\t\t# ISDN card number used for this entry\n", cep->isdncontroller);
1552                 fprintf(PFILE, "isdnchannel           = ");
1553                 switch(cep->isdnchannel)
1554                 {
1555                                 case CHAN_ANY:
1556                                         fprintf(PFILE, "-1\t\t# any ISDN B-channel may be used\n");
1557                                         break;
1558                                 default:
1559                                         fprintf(PFILE, "%d\t\t# only ISDN B-channel %d may be used\n", cep->isdnchannel+1, cep->isdnchannel+1);
1560                                         break;
1561                 }
1562
1563                 fprintf(PFILE, "usrdevicename         = %s\t\t# name of userland ISDN B-channel device\n", bdrivername(cep->usrdevicename));
1564                 fprintf(PFILE, "usrdeviceunit         = %d\t\t# unit number of userland ISDN B-channel device\n", cep->usrdeviceunit);
1565
1566                 fprintf(PFILE, "b1protocol            = %s\n", cep->b1protocol ? "hdlc\t\t# B-channel layer 1 protocol is HDLC" : "raw\t\t# No B-channel layer 1 protocol used");
1567
1568                 if(!(cep->usrdevicename == BDRV_TEL))
1569                 {
1570                         fprintf(PFILE, "direction             = ");
1571                         switch(cep->inout)
1572                         {
1573                                 case DIR_INONLY:
1574                                         fprintf(PFILE, "in\t\t# only incoming connections allowed\n");
1575                                         break;
1576                                 case DIR_OUTONLY:
1577                                         fprintf(PFILE, "out\t\t# only outgoing connections allowed\n");
1578                                         break;
1579                                 case DIR_INOUT:
1580                                         fprintf(PFILE, "inout\t\t# incoming and outgoing connections allowed\n");
1581                                         break;
1582                         }
1583                 }
1584
1585                 if(!((cep->usrdevicename == BDRV_TEL) || (cep->inout == DIR_INONLY)))
1586                 {
1587                         if(cep->remote_numbers_count > 1)
1588                         {
1589                                 for(j=0; j<cep->remote_numbers_count; j++)
1590                                         fprintf(PFILE, "remote-phone-dialout  = %s\t\t# telephone number %d for dialing out to remote\n", cep->remote_numbers[j].number, j+1);
1591
1592                                 fprintf(PFILE, "remdial-handling      = ");
1593
1594                                 switch(cep->remote_numbers_handling)
1595                                 {
1596                                         case RNH_NEXT:
1597                                                 fprintf(PFILE, "next\t\t# use next number after last successfull for new dial\n");
1598                                                 break;
1599                                         case RNH_LAST:
1600                                                 fprintf(PFILE, "last\t\t# use last successfull number for new dial\n");
1601                                                 break;
1602                                         case RNH_FIRST:
1603                                                 fprintf(PFILE, "first\t\t# always start with first number for new dial\n");
1604                                                 break;
1605                                 }
1606                         }
1607                         else
1608                         {
1609                                 fprintf(PFILE, "remote-phone-dialout  = %s\t\t# telephone number for dialing out to remote\n", cep->remote_numbers[0].number);
1610                         }
1611
1612                         fprintf(PFILE, "local-phone-dialout   = %s\t\t# show this number to remote when dialling out\n", cep->local_phone_dialout);
1613                         fprintf(PFILE, "dialout-type          = %s\n", cep->dialouttype ? "calledback\t\t# i am called back by remote" : "normal\t\t# i am not called back by remote");
1614                 }
1615
1616                 if(!(cep->inout == DIR_OUTONLY))
1617                 {
1618                         int n;
1619
1620                         fprintf(PFILE, "local-phone-incoming  = %s\t\t# incoming calls must match this (mine) telephone number\n", cep->local_phone_incoming);
1621                         for (n = 0; n < cep->incoming_numbers_count; n++)
1622                                 fprintf(PFILE, "remote-phone-incoming = %s\t\t# this is a valid remote number to call me\n",
1623                                         cep->remote_phone_incoming[n].number);
1624
1625                         fprintf(PFILE, "dialin-reaction       = ");
1626                         switch(cep->dialin_reaction)
1627                         {
1628                                 case REACT_ACCEPT:
1629                                         fprintf(PFILE, "accept\t\t# i accept a call from remote and connect\n");
1630                                         break;
1631                                 case REACT_REJECT:
1632                                         fprintf(PFILE, "reject\t\t# i reject the call from remote\n");
1633                                         break;
1634                                 case REACT_IGNORE:
1635                                         fprintf(PFILE, "ignore\t\t# i ignore the call from remote\n");
1636                                         break;
1637                                 case REACT_ANSWER:
1638                                         fprintf(PFILE, "answer\t\t# i will start telephone answering when remote calls in\n");
1639                                         break;
1640                                 case REACT_CALLBACK:
1641                                         fprintf(PFILE, "callback\t\t# when remote calls in, i will hangup and call back\n");
1642                                         break;
1643                         }
1644                 }
1645
1646                 if(cep->usrdevicename == BDRV_ISPPP)
1647                 {
1648                         char *s;
1649                         switch(cep->ppp_expect_auth)
1650                         {
1651                                 case AUTH_NONE:
1652                                         s = "none";
1653                                         break;
1654                                 case AUTH_PAP:
1655                                         s = "pap";
1656                                         break;
1657                                 case AUTH_CHAP:
1658                                         s = "chap";
1659                                         break;
1660                                 default:
1661                                         s = NULL;
1662                                         break;
1663                         }
1664                         if(s != NULL)
1665                         {
1666                                 fprintf(PFILE, "ppp-expect-auth       = %s\t\t# the auth protocol we expect to receive on dial-in (none,pap,chap)\n", s);
1667                                 if(cep->ppp_expect_auth != AUTH_NONE)
1668                                 {
1669                                         fprintf(PFILE, "ppp-expect-name       = %s\t\t# the user name allowed in\n", cep->ppp_expect_name);
1670                                         fprintf(PFILE, "ppp-expect-password   = %s\t\t# the key expected from the other side\n", cep->ppp_expect_password);
1671                                         fprintf(PFILE, "ppp-auth-paranoid     = %s\t\t# do we require remote to authenticate even if we dial out\n", cep->ppp_auth_flags & AUTH_REQUIRED ? "yes" : "no");
1672                                 }
1673                         }
1674                         switch(cep->ppp_send_auth)
1675                         {
1676                                 case AUTH_NONE:
1677                                         s = "none";
1678                                         break;
1679                                 case AUTH_PAP:
1680                                         s = "pap";
1681                                         break;
1682                                 case AUTH_CHAP:
1683                                         s = "chap";
1684                                         break;
1685                                 default:
1686                                         s = NULL;
1687                                         break;
1688                         }
1689                         if(s != NULL)
1690                         {
1691                                 fprintf(PFILE, "ppp-send-auth         = %s\t\t# the auth protocol we use when dialing out (none,pap,chap)\n", s);
1692                                 if(cep->ppp_send_auth != AUTH_NONE)
1693                                 {
1694                                         fprintf(PFILE, "ppp-send-name         = %s\t\t# our PPP account used for dial-out\n", cep->ppp_send_name);
1695                                         fprintf(PFILE, "ppp-send-password     = %s\t\t# the key sent to the other side\n", cep->ppp_send_password);
1696                                 }
1697                         }
1698                         if(cep->ppp_send_auth == AUTH_CHAP ||
1699                            cep->ppp_expect_auth == AUTH_CHAP) {
1700                                 fprintf(PFILE, "ppp-auth-rechallenge   = %s\t\t# rechallenge CHAP connections once in a while\n", cep->ppp_auth_flags & AUTH_RECHALLENGE ? "yes" : "no");
1701                         }
1702                 }
1703
1704                 if(!((cep->inout == DIR_INONLY) || (cep->usrdevicename == BDRV_TEL)))
1705                 {
1706                         char *s;
1707                         fprintf(PFILE, "idletime-outgoing     = %d\t\t# outgoing call idle timeout\n", cep->idle_time_out);
1708
1709                         switch( cep->shorthold_algorithm )
1710                         {
1711                                 case SHA_FIXU:
1712                                         s = "fix-unit-size";
1713                                         break;
1714                                 case SHA_VARU:
1715                                         s = "var-unit-size";
1716                                         break;
1717                                 default:
1718                                         s = "error!!!";
1719                                         break;
1720                         }
1721
1722                         fprintf(PFILE, "idle-algorithm-outgoing     = %s\t\t# outgoing call idle algorithm\n", s);
1723                 }
1724
1725                 if(!(cep->inout == DIR_OUTONLY))
1726                         fprintf(PFILE, "idletime-incoming     = %d\t\t# incoming call idle timeout\n", cep->idle_time_in);
1727
1728                 if(!(cep->usrdevicename == BDRV_TEL))
1729                 {
1730                         fprintf(PFILE, "unitlengthsrc         = ");
1731                         switch(cep->unitlengthsrc)
1732                         {
1733                                 case ULSRC_NONE:
1734                                         fprintf(PFILE, "none\t\t# no unit length specified, using default\n");
1735                                         break;
1736                                 case ULSRC_CMDL:
1737                                         fprintf(PFILE, "cmdl\t\t# using unit length specified on commandline\n");
1738                                         break;
1739                                 case ULSRC_CONF:
1740                                         fprintf(PFILE, "conf\t\t# using unitlength specified by unitlength-keyword\n");
1741                                         fprintf(PFILE, "unitlength            = %d\t\t# fixed unitlength\n", cep->unitlength);
1742                                         break;
1743                                 case ULSRC_RATE:
1744                                         fprintf(PFILE, "rate\t\t# using unitlength specified in rate database\n");
1745                                         fprintf(PFILE, "ratetype              = %d\t\t# type of rate from rate database\n", cep->ratetype);
1746                                         break;
1747                                 case ULSRC_DYN:
1748                                         fprintf(PFILE, "aocd\t\t# using dynamically calculated unitlength based on AOCD subscription\n");
1749                                         fprintf(PFILE, "ratetype              = %d\t\t# type of rate from rate database\n", cep->ratetype);
1750                                         break;
1751                         }
1752
1753                         fprintf(PFILE, "earlyhangup           = %d\t\t# early hangup safety time\n", cep->earlyhangup);
1754
1755                 }
1756
1757                 if(cep->usrdevicename == BDRV_TEL)
1758                 {
1759                         fprintf(PFILE, "answerprog            = %s\t\t# program used to answer incoming telephone calls\n", cep->answerprog);
1760                         fprintf(PFILE, "alert                 = %d\t\t# number of seconds to wait before accepting a call\n", cep->alert);
1761                 }
1762
1763                 if(!(cep->usrdevicename == BDRV_TEL))
1764                 {
1765                         if(cep->dialin_reaction == REACT_CALLBACK)
1766                                 fprintf(PFILE, "callbackwait          = %d\t\t# i am waiting this time before calling back remote\n", cep->callbackwait);
1767
1768                         if(cep->dialouttype == DIALOUT_CALLEDBACK)
1769                                 fprintf(PFILE, "calledbackwait        = %d\t\t# i am waiting this time for a call back from remote\n", cep->calledbackwait);
1770
1771                         if(!(cep->inout == DIR_INONLY))
1772                         {
1773                                 fprintf(PFILE, "dialretries           = %d\t\t# number of dialing retries\n", cep->dialretries);
1774                                 fprintf(PFILE, "recoverytime          = %d\t\t# time to wait between dialling retries\n", cep->recoverytime);
1775                                 fprintf(PFILE, "dialrandincr          = %s\t\t# use random dialing time addon\n", cep->dialrandincr ? "on" : "off");
1776
1777                                 fprintf(PFILE, "usedown               = %s\n", cep->usedown ? "on\t\t# ISDN device switched off on excessive dial failures" : "off\t\t# no device switchoff on excessive dial failures");
1778                                 if(cep->usedown)
1779                                 {
1780                                         fprintf(PFILE, "downtries             = %d\t\t# number of dialretries failures before switching off\n", cep->downtries);
1781                                         fprintf(PFILE, "downtime              = %d\t\t# time device is switched off\n", cep->downtime);
1782                                 }
1783                         }
1784                 }
1785         }
1786         fprintf(PFILE, "\n");
1787 }
1788
1789 /* EOF */