extension.c

   1 /*****************************************************************************\
   2 **                                                                           **
   3 ** PBX4Linux                                                                 **
   4 **                                                                           **
   5 **---------------------------------------------------------------------------**
   6 ** Copyright: Andreas Eversberg                                              **
   7 **                                                                           **
   8 ** reading and writing files for extensions                                  **
   9 **                                                                           **
  10 \*****************************************************************************/
  11
  12 #include "main.h"
  13
  14 /* extension */
  15
  16 const char *ext_rights[] = {
  17         "none",
  18         "internal",
  19         "local",
  20         "national",
  21         "international",
  22         NULL
  23 };
  24
  25 const char *ext_yesno[] = {
  26         "no",
  27         "yes",
  28         NULL
  29 };
  30
  31
  32 /* read extension
  33  *
  34  * reads extension from given extension number and fills structure
  35  */
  36 int read_extension(struct extension *ext, char *num)
  37 {
  38         FILE *fp=NULL;
  39         char number[32];
  40         char filename[256];
  41         char *p;
  42         char option[32];
  43         char param[256],param2[256];
  44         unsigned int line,i;
  45         char buffer[1024];
  46         int last_in_count = 0, last_out_count = 0;
  47
  48         /* save number, so &ext and ext.number can be given as parameters - without overwriting itself */
  49         SCPY(number, num);
  50
  51         if (number[0] == '\0')
  52                 return(0);
  53
  54         SPRINT(filename, "%s/%s/settings", EXTENSION_DATA, number);
  55
  56         if (!(fp = fopen(filename, "r"))) {
  57                 printf("the given extension doesn't exist: \"%s\"\n", filename);
  58                 PDEBUG(DEBUG_CONFIG, "the given extension doesn't exist: \"%s\"\n", filename);
  59                 return(0);
  60         }
  61
  62         /* default values */
  63         memset(ext, 0, sizeof(struct extension));
  64         SCPY(ext->number, number);
  65 //      ********** NOTE: also change value in apppbx constructor
  66         ext->rights = 4; /* international */
  67         ext->cfnr_delay = 20;
  68         ext->vbox_codec = CODEC_MONO;
  69
  70         line=0;
  71         while((GETLINE(buffer, fp))) {
  72                 line++;
  73                 p = buffer;
  74
  75                 while(*p <= 32) { /* skip spaces */
  76                         if (*p == 0)
  77                                 break;
  78                         p++;
  79                 }
  80                 if (*p==0 || *p=='#') /* ignore comments and empty line */
  81                         continue;
  82
  83                 option[0]=0;
  84                 i=0; /* read option */
  85                 while(*p > 32) {
  86                         if (i+1 >= sizeof(option)) {
  87                                 PERROR_RUNTIME("Error in %s (line %d): option too long.\n",filename,line);
  88                                 break;
  89                         }
  90                         option[i+1] = '\0';
  91                         option[i++] = *p++;
  92                 }
  93
  94                 while(*p <= 32) { /* skip spaces */
  95                         if (*p == 0)
  96                                 break;
  97                         p++;
  98                 }
  99
 100                 param[0]=0;
 101                 param2[0]=0;
 102                 if (*p!=0 && *p!='#') { /* param */
 103                         i=0; /* read param */
 104                         while(*p > 32) {
 105                                 if (i+1 >= sizeof(param)) {
 106                                         PERROR_RUNTIME("Error in %s (line %d): param too long.\n",filename,line);
 107                                         break;
 108                                 }
 109                                 param[i+1] = '\0';
 110                                 param[i++] = *p++;
 111                         }
 112
 113                         while(*p <= 32) { /* skip spaces */
 114                                 if (*p == 0)
 115                                         break;
 116                                 p++;
 117                         }
 118
 119                         if (*p!=0 && *p!='#') { /* param2 */
 120                                 i=0; /* read param2 */
 121                                 while(*p >= 32) {
 122                                         if (i+1 >= sizeof(param2)) {
 123                                                 PERROR_RUNTIME("Error in %s (line %d): param too long.\n",filename,line);
 124                                                 break;
 125                                         }
 126                                         param2[i+1] = '\0';
 127                                         param2[i++] = *p++;
 128                                 }
 129                         }
 130                 }
 131
 132                 /* at this point we have option and param */
 133
 134                 /* check option */
 135                 if (!strcmp(option,"name")) {
 136                         SCPY(ext->name, param);
 137                         if (param2[0]) {
 138                                 SCAT(ext->name, (char *)" ");
 139                                 SCAT(ext->name, param2);
 140                         }
 141
 142                         PDEBUG(DEBUG_CONFIG, "name of extension: %s\n",param);
 143                 } else
 144                 if (!strcmp(option,"prefix")) {
 145                         SCPY(ext->prefix, param);
 146
 147                         PDEBUG(DEBUG_CONFIG, "dial prefix on pickup: %s\n",param);
 148                 } else
 149                 if (!strcmp(option,"next")) {
 150                         SCPY(ext->next, param);
 151
 152                         PDEBUG(DEBUG_CONFIG, "dial next on pickup: %s\n",param);
 153                 } else
 154                 if (!strcmp(option,"alarm")) {
 155                         SCPY(ext->alarm, param);
 156
 157                         PDEBUG(DEBUG_CONFIG, "alarm message (if prefix): %s\n",param);
 158                 } else
 159                 if (!strcmp(option,"cfu")) {
 160                         SCPY(ext->cfu, param);
 161
 162                         PDEBUG(DEBUG_CONFIG, "call forward unconditional: %s\n",param);
 163                 } else
 164                 if (!strcmp(option,"cfb")) {
 165                         SCPY(ext->cfb, param);
 166
 167                         PDEBUG(DEBUG_CONFIG, "call forward when busy: %s\n",param);
 168                 } else
 169                 if (!strcmp(option,"cfnr")) {
 170                         SCPY(ext->cfnr, param);
 171
 172                         PDEBUG(DEBUG_CONFIG, "call forward on no response: %s\n",param);
 173                 } else
 174                 if (!strcmp(option,"cfnr_delay")) {
 175                         ext->cfnr_delay = atoi(param);
 176                         if (ext->cfnr_delay < 0)
 177                                 ext->cfnr_delay = 1;
 178
 179                         PDEBUG(DEBUG_CONFIG, "call forward no response delay: %d\n",ext->cfnr_delay);
 180                 } else
 181                 if (!strcmp(option,"cfp")) {
 182                         SCPY(ext->cfp, param);
 183
 184                         PDEBUG(DEBUG_CONFIG, "call forward parallel: %s\n",param);
 185                 } else
 186                 if (!strcmp(option,"change_forward")) {
 187                         i=0;
 188                         while(ext_yesno[i]) {
 189                                 if (!strcasecmp(param,ext_yesno[i]))
 190                                         break;
 191                                 i++;
 192                         }
 193                         if (ext_yesno[i]) {
 194                                 ext->change_forward = i;
 195                                 PDEBUG(DEBUG_CONFIG, "allow the change of forwarding: %s\n", ext_yesno[i]);
 196                         } else {
 197                                 PDEBUG(DEBUG_CONFIG, "unknown parameter for change_forward: %s\n", param);
 198                         }
 199                 } else
 200                 if (!strcmp(option,"interfaces")) {
 201                         SCPY(ext->interfaces, param);
 202
 203                         PDEBUG(DEBUG_CONFIG, "interfaces to ring calls to extension: %s %s\n",param,param2);
 204                 } else
 205                 if (!strcmp(option,"callerid")) {
 206                         ext->callerid_present = INFO_PRESENT_ALLOWED;
 207                         if (!strncasecmp(param2, "anonymous", 9))
 208                                 ext->callerid_present = INFO_PRESENT_RESTRICTED;
 209                         if (!strncasecmp(param, "non", 3)) {
 210                                 ext->callerid[0] = '\0';
 211                                 ext->callerid_present = INFO_PRESENT_NOTAVAIL;
 212                                 ext->callerid_type = INFO_NTYPE_UNKNOWN;
 213                                 PDEBUG(DEBUG_CONFIG, "caller id: ID NOT AVAILABLE\n");
 214                         } else
 215                         switch(param[0]) {
 216                                 case 'i':
 217                                 case 'I':
 218                                 ext->callerid_type = INFO_NTYPE_INTERNATIONAL;
 219                                 SCPY(ext->callerid, param+1);
 220                                 PDEBUG(DEBUG_CONFIG, "caller id: %s INTERNATIONAL\n",param+1);
 221                                 break;
 222                                 case 'n':
 223                                 case 'N':
 224                                 ext->callerid_type = INFO_NTYPE_NATIONAL;
 225                                 SCPY(ext->callerid, param+1);
 226                                 PDEBUG(DEBUG_CONFIG, "caller id: %s NATIONAL\n",param+1);
 227                                 break;
 228                                 case 's':
 229                                 case 'S':
 230                                 ext->callerid_type = INFO_NTYPE_SUBSCRIBER;
 231                                 SCPY(ext->callerid, param+1);
 232                                 PDEBUG(DEBUG_CONFIG, "caller id: %s SUBSCRIBER\n",param+1);
 233                                 break;
 234                                 default:
 235                                 ext->callerid_type = INFO_NTYPE_UNKNOWN;
 236                                 SCPY(ext->callerid, param);
 237                                 PDEBUG(DEBUG_CONFIG, "caller id: %s UNKNOWN\n",param);
 238                         }
 239                         ext->callerid[sizeof(ext->callerid)-1] = 0;
 240                 } else
 241                 if (!strcmp(option,"id_next_call")) {
 242                         ext->id_next_call_present = INFO_PRESENT_ALLOWED;
 243                         if (!strncasecmp(param2, "anonymous", 9))
 244                                 ext->id_next_call_present = INFO_PRESENT_RESTRICTED;
 245                         if (param[0] == '\0') {
 246                                 ext->id_next_call_present = -1;
 247                                 PDEBUG(DEBUG_CONFIG, "id next call: no id for next call\n");
 248                         } else
 249                         if (!strncasecmp(param, "none", 3)) {
 250                                 ext->id_next_call[0] = '\0';
 251                                 ext->id_next_call_present = INFO_PRESENT_NOTAVAIL;
 252                                 ext->id_next_call_type = INFO_NTYPE_UNKNOWN;
 253                                 PDEBUG(DEBUG_CONFIG, "id next call: ID NOT AVAILABLE\n");
 254                         } else
 255                         switch(param[0]) {
 256                                 case 'i':
 257                                 case 'I':
 258                                 ext->id_next_call_type = INFO_NTYPE_INTERNATIONAL;
 259                                 SCPY(ext->id_next_call, param+1);
 260                                 PDEBUG(DEBUG_CONFIG, "id next call: %s INTERNATIONAL\n",param+1);
 261                                 break;
 262                                 case 'n':
 263                                 case 'N':
 264                                 ext->id_next_call_type = INFO_NTYPE_NATIONAL;
 265                                 SCPY(ext->id_next_call, param+1);
 266                                 PDEBUG(DEBUG_CONFIG, "id next call: %s NATIONAL\n",param+1);
 267                                 break;
 268                                 case 's':
 269                                 case 'S':
 270                                 ext->id_next_call_type = INFO_NTYPE_SUBSCRIBER;
 271                                 SCPY(ext->id_next_call, param+1);
 272                                 PDEBUG(DEBUG_CONFIG, "id next call: %s SUBSCRIBER\n",param+1);
 273                                 break;
 274                                 default:
 275                                 ext->id_next_call_type = INFO_NTYPE_UNKNOWN;
 276                                 SCPY(ext->id_next_call, param);
 277                                 PDEBUG(DEBUG_CONFIG, "id next call: %s UNKNOWN\n",param);
 278                         }
 279
 280
 281
 282                 } else
 283                 if (!strcmp(option,"change_callerid")) {
 284                         i=0;
 285                         while(ext_yesno[i]) {
 286                                 if (!strcasecmp(param,ext_yesno[i]))
 287                                         break;
 288                                 i++;
 289                         }
 290                         if (ext_yesno[i]) {
 291                                 ext->change_callerid = i;
 292                                 PDEBUG(DEBUG_CONFIG, "allow the change of caller id: %s\n", ext_yesno[i]);
 293                         } else {
 294                                 PDEBUG(DEBUG_CONFIG, "unknown parameter for change_callerid: %s\n", param);
 295                         }
 296                 } else
 297                 if (!strcmp(option,"anon-ignore")) {
 298                         i=0;
 299                         while(ext_yesno[i]) {
 300                                 if (!strcasecmp(param,ext_yesno[i]))
 301                                         break;
 302                                 i++;
 303                         }
 304                         if (ext_yesno[i]) {
 305                                 ext->anon_ignore = i;
 306                                 PDEBUG(DEBUG_CONFIG, "ignore restriction of CLIP & COLP %s\n", ext_yesno[i]);
 307                         } else {
 308                                 PDEBUG(DEBUG_CONFIG, "unknown parameter given anon-ignore: %s\n", param);
 309                         }
 310                 } else
 311                 if (!strcmp(option,"clip")) {
 312                         if (!strcasecmp(param, "hide"))
 313                                 ext->clip = CLIP_HIDE;
 314                         else
 315                                 ext->clip = CLIP_ASIS;
 316
 317                         PDEBUG(DEBUG_CONFIG, "clip: %d\n",ext->clip);
 318                 } else
 319                 if (!strcmp(option,"colp")) {
 320                         if (!strcasecmp(param, "hide"))
 321                                 ext->colp = COLP_HIDE;
 322                         else if (!strcasecmp(param, "force"))
 323                                 ext->colp = COLP_FORCE;
 324                         else
 325                                 ext->colp = COLP_ASIS;
 326
 327                         PDEBUG(DEBUG_CONFIG, "colp: %d\n",ext->colp);
 328                 } else
 329                 if (!strcmp(option,"clip_prefix")) {
 330                         SCPY(ext->clip_prefix, param);
 331
 332                         PDEBUG(DEBUG_CONFIG, "clip prefix: %s\n",param);
 333                 } else
 334                 if (!strcmp(option,"keypad")) {
 335                         i=0;
 336                         while(ext_yesno[i]) {
 337                                 if (!strcasecmp(param,ext_yesno[i]))
 338                                         break;
 339                                 i++;
 340                         }
 341                         if (ext_yesno[i]) {
 342                                 ext->keypad = i;
 343                                 PDEBUG(DEBUG_CONFIG, "use keypad to do call control %s\n", ext_yesno[i]);
 344                         } else {
 345                                 PDEBUG(DEBUG_CONFIG, "unknown parameter given keypad: %s\n", param);
 346                         }
 347                 } else
 348                 if (!strcmp(option,"rights")) {
 349                         i=0;
 350                         while(ext_rights[i]) {
 351                                 if (!strcasecmp(param,ext_rights[i]))
 352                                         break;
 353                                 i++;
 354                         }
 355                         if (ext_rights[i]) {
 356                                 ext->rights = i;
 357                                 PDEBUG(DEBUG_CONFIG, "rights to dial: %s\n", ext_rights[i]);
 358                         } else {
 359                                 PDEBUG(DEBUG_CONFIG, "given rights unknown: %s\n", param);
 360                         }
 361                 } else
 362                 if (!strcmp(option,"delete_ext")) {
 363                         i=0;
 364                         while(ext_yesno[i]) {
 365                                 if (!strcasecmp(param,ext_yesno[i]))
 366                                         break;
 367                                 i++;
 368                         }
 369                         if (ext_yesno[i]) {
 370                                 ext->delete_ext = i;
 371                                 PDEBUG(DEBUG_CONFIG, "enables the delete key function for external calls: %s\n", ext_yesno[i]);
 372                         } else {
 373                                 PDEBUG(DEBUG_CONFIG, "unknown parameter given delete: %s\n", param);
 374                         }
 375                 } else
 376                 if (!strcmp(option,"noknocking")) {
 377                         i=0;
 378                         while(ext_yesno[i]) {
 379                                 if (!strcasecmp(param,ext_yesno[i]))
 380                                         break;
 381                                 i++;
 382                         }
 383                         if (ext_yesno[i]) {
 384                                 ext->noknocking = i;
 385                                 PDEBUG(DEBUG_CONFIG, "noknocking %s\n", ext_yesno[i]);
 386                         } else {
 387                                 PDEBUG(DEBUG_CONFIG, "given noknocking param unknown: %s\n", param);
 388                         }
 389                 } else
 390                 if (!strcmp(option,"rx_gain")
 391                  || !strcmp(option,"rxvol")) {
 392                         ext->rx_gain = atoi(param);
 393                         if (ext->rx_gain<-8 || ext->rx_gain>8)
 394                                 ext->rx_gain = 0;
 395
 396                         PDEBUG(DEBUG_CONFIG, "receive volume: %d\n",ext->rx_gain);
 397                 } else
 398                 if (!strcmp(option,"tx_gain")
 399                  || !strcmp(option,"txvol")) {
 400                         ext->tx_gain = atoi(param);
 401                         if (ext->tx_gain<-8 || ext->tx_gain>8)
 402                                 ext->tx_gain = 0;
 403
 404                         PDEBUG(DEBUG_CONFIG, "transmit volume: %d\n",ext->tx_gain);
 405                 } else
 406                 if (!strcmp(option,"own_setup")) {
 407                         i=0;
 408                         while(ext_yesno[i]) {
 409                                 if (!strcasecmp(param,ext_yesno[i]))
 410                                         break;
 411                                 i++;
 412                         }
 413                         if (ext_yesno[i]) {
 414                                 ext->own_setup = i;
 415                                 PDEBUG(DEBUG_CONFIG, "own_setup %s\n", ext_yesno[i]);
 416                         } else {
 417                                 PDEBUG(DEBUG_CONFIG, "given own_setup param unknown: %s\n", param);
 418                         }
 419                 } else
 420                 if (!strcmp(option,"own_proceeding")) {
 421                         i=0;
 422                         while(ext_yesno[i]) {
 423                                 if (!strcasecmp(param,ext_yesno[i]))
 424                                         break;
 425                                 i++;
 426                         }
 427                         if (ext_yesno[i]) {
 428                                 ext->own_proceeding = i;
 429                                 PDEBUG(DEBUG_CONFIG, "own_proceeding %s\n", ext_yesno[i]);
 430                         } else {
 431                                 PDEBUG(DEBUG_CONFIG, "given own_proceeding param unknown: %s\n", param);
 432                         }
 433                 } else
 434                 if (!strcmp(option,"own_alerting")) {
 435                         i=0;
 436                         while(ext_yesno[i]) {
 437                                 if (!strcasecmp(param,ext_yesno[i]))
 438                                         break;
 439                                 i++;
 440                         }
 441                         if (ext_yesno[i]) {
 442                                 ext->own_alerting = i;
 443                                 PDEBUG(DEBUG_CONFIG, "own_alerting %s\n", ext_yesno[i]);
 444                         } else {
 445                                 PDEBUG(DEBUG_CONFIG, "given own_alerting param unknown: %s\n", param);
 446                         }
 447                 } else
 448                 if (!strcmp(option,"own_cause")) {
 449                         i=0;
 450                         while(ext_yesno[i]) {
 451                                 if (!strcasecmp(param,ext_yesno[i]))
 452                                         break;
 453                                 i++;
 454                         }
 455                         if (ext_yesno[i]) {
 456                                 ext->own_cause = i;
 457                                 PDEBUG(DEBUG_CONFIG, "own_cause %s\n", ext_yesno[i]);
 458                         } else {
 459                                 PDEBUG(DEBUG_CONFIG, "given own_cause param unknown: %s\n", param);
 460                         }
 461                 } else
 462                 if (!strcmp(option,"facility")) {
 463                         i=0;
 464                         while(ext_yesno[i]) {
 465                                 if (!strcasecmp(param,ext_yesno[i]))
 466                                         break;
 467                                 i++;
 468                         }
 469                         if (ext_yesno[i]) {
 470                                 ext->facility = i;
 471                                 PDEBUG(DEBUG_CONFIG, "facility %s\n", ext_yesno[i]);
 472                         } else {
 473                                 PDEBUG(DEBUG_CONFIG, "given facility param unknown: %s\n", param);
 474                         }
 475                 } else
 476                 if (!strcmp(option,"display_cause")) {
 477                         if (!strcasecmp(param, "german"))
 478                                 ext->display_cause = DISPLAY_CAUSE_GERMAN;
 479                         else if (!strcasecmp(param, "english"))
 480                                 ext->display_cause = DISPLAY_CAUSE_ENGLISH;
 481                         else if (!strcasecmp(param, "german-location"))
 482                                 ext->display_cause = DISPLAY_LOCATION_GERMAN;
 483                         else if (!strcasecmp(param, "english-location"))
 484                                 ext->display_cause = DISPLAY_LOCATION_ENGLISH;
 485                         else if (!strcasecmp(param, "number"))
 486                                 ext->display_cause = DISPLAY_CAUSE_NUMBER;
 487                         else
 488                                 ext->display_cause = DISPLAY_CAUSE_NONE;
 489
 490                         PDEBUG(DEBUG_CONFIG, "display cause: %d\n",ext->display_cause);
 491                 } else
 492 #if 0
 493                 if (!strcmp(option,"display_ext")) {
 494                         if (!strcasecmp(param, "number"))
 495                                 ext->display_ext = DISPLAY_CID_NUMBER;
 496                         else if (!strcasecmp(param, "abbrev"))
 497                                 ext->display_ext = DISPLAY_CID_ABBREVIATION;
 498                         else if (!strcasecmp(param, "name"))
 499                                 ext->display_ext = DISPLAY_CID_NAME;
 500                         else if (!strcasecmp(param, "number-name"))
 501                                 ext->display_ext = DISPLAY_CID_NUMBER_NAME;
 502                         else if (!strcasecmp(param, "name-number"))
 503                                 ext->display_ext = DISPLAY_CID_NAME_NUMBER;
 504                         else if (!strcasecmp(param, "abbrev-number"))
 505                                 ext->display_ext = DISPLAY_CID_ABBREV_NUMBER;
 506                         else if (!strcasecmp(param, "abbrev-name"))
 507                                 ext->display_ext = DISPLAY_CID_ABBREV_NAME;
 508                         else if (!strcasecmp(param, "abbrev-name-number"))
 509                                 ext->display_ext = DISPLAY_CID_ABBREV_NAME_NUMBER;
 510                         else if (!strcasecmp(param, "abbrev-number-name"))
 511                                 ext->display_ext = DISPLAY_CID_ABBREV_NUMBER_NAME;
 512                         else
 513                                 ext->display_ext = DISPLAY_CID_ASIS;
 514
 515                         PDEBUG(DEBUG_CONFIG, "display ext: %d\n",ext->display_ext);
 516                 } else
 517 #endif
 518                 if (!strcmp(option,"display_ext")) {
 519                         i=0;
 520                         while(ext_yesno[i]) {
 521                                 if (!strcasecmp(param,ext_yesno[i]))
 522                                         break;
 523                                 i++;
 524                         }
 525                         if (ext_yesno[i]) {
 526                                 ext->display_ext = i;
 527                                 PDEBUG(DEBUG_CONFIG, "display ext %s\n", ext_yesno[i]);
 528                         } else {
 529                                 PDEBUG(DEBUG_CONFIG, "given display_ext param unknown: %s\n", param);
 530                         }
 531                 } else
 532                 if (!strcmp(option,"display_int")) {
 533                         i=0;
 534                         while(ext_yesno[i]) {
 535                                 if (!strcasecmp(param,ext_yesno[i]))
 536                                         break;
 537                                 i++;
 538                         }
 539                         if (ext_yesno[i]) {
 540                                 ext->display_int = i;
 541                                 PDEBUG(DEBUG_CONFIG, "display int %s\n", ext_yesno[i]);
 542                         } else {
 543                                 PDEBUG(DEBUG_CONFIG, "given display_int param unknown: %s\n", param);
 544                         }
 545                 } else
 546                 if (!strcmp(option,"display_fake")) {
 547                         i=0;
 548                         while(ext_yesno[i]) {
 549                                 if (!strcasecmp(param,ext_yesno[i]))
 550                                         break;
 551                                 i++;
 552                         }
 553                         if (ext_yesno[i]) {
 554                                 ext->display_fake = i;
 555                                 PDEBUG(DEBUG_CONFIG, "display fake caller ids %s\n", ext_yesno[i]);
 556                         } else {
 557                                 PDEBUG(DEBUG_CONFIG, "given display_fake param unknown: %s\n", param);
 558                         }
 559                 } else
 560                 if (!strcmp(option,"display_anon")) {
 561                         i=0;
 562                         while(ext_yesno[i]) {
 563                                 if (!strcasecmp(param,ext_yesno[i]))
 564                                         break;
 565                                 i++;
 566                         }
 567                         if (ext_yesno[i]) {
 568                                 ext->display_anon = i;
 569                                 PDEBUG(DEBUG_CONFIG, "display anonymouse ids %s\n", ext_yesno[i]);
 570                         } else {
 571                                 PDEBUG(DEBUG_CONFIG, "given display_anon param unknown: %s\n", param);
 572                         }
 573                 } else
 574                 if (!strcmp(option,"display_menu")) {
 575                         i=0;
 576                         while(ext_yesno[i]) {
 577                                 if (!strcasecmp(param,ext_yesno[i]))
 578                                         break;
 579                                 i++;
 580                         }
 581                         if (ext_yesno[i]) {
 582                                 ext->display_menu = i;
 583                                 PDEBUG(DEBUG_CONFIG, "display menu %s\n", ext_yesno[i]);
 584                         } else {
 585                                 PDEBUG(DEBUG_CONFIG, "given display_menu param unknown: %s\n", param);
 586                         }
 587                 } else
 588                 if (!strcmp(option,"display_dialing")) {
 589                         i=0;
 590                         while(ext_yesno[i]) {
 591                                 if (!strcasecmp(param,ext_yesno[i]))
 592                                         break;
 593                                 i++;
 594                         }
 595                         if (ext_yesno[i]) {
 596                                 ext->display_dialing = i;
 597                                 PDEBUG(DEBUG_CONFIG, "display dialing %s\n", ext_yesno[i]);
 598                         } else {
 599                                 PDEBUG(DEBUG_CONFIG, "given display_dialing param unknown: %s\n", param);
 600                         }
 601                 } else
 602                 if (!strcmp(option,"display_name")) {
 603                         i=0;
 604                         while(ext_yesno[i]) {
 605                                 if (!strcasecmp(param,ext_yesno[i]))
 606                                         break;
 607                                 i++;
 608                         }
 609                         if (ext_yesno[i]) {
 610                                 ext->display_name = i;
 611                                 PDEBUG(DEBUG_CONFIG, "display name %s\n", ext_yesno[i]);
 612                         } else {
 613                                 PDEBUG(DEBUG_CONFIG, "given display_name param unknown: %s\n", param);
 614                         }
 615                 } else
 616                 if (!strcmp(option,"tones_dir")) {
 617                         if (param[strlen(param)-1] == '/')
 618                                 param[strlen(param)-1]=0;
 619                         SCPY(ext->tones_dir, param);
 620
 621                         PDEBUG(DEBUG_CONFIG, "directory of tones: %s\n",param);
 622                 } else
 623                 if (!strcmp(option,"record")) {
 624                         if (!strcasecmp(param, "mono"))
 625                                 ext->record = CODEC_MONO;
 626                         else if (!strcasecmp(param, "stereo"))
 627                                 ext->record = CODEC_STEREO;
 628                         else if (!strcasecmp(param, "8bit"))
 629                                 ext->record = CODEC_8BIT;
 630                         else if (!strcasecmp(param, "law"))
 631                                 ext->record = CODEC_LAW;
 632                         else
 633                                 ext->record = CODEC_OFF;
 634                         PDEBUG(DEBUG_CONFIG, "given record param: %s\n", param);
 635                 } else
 636                 if (!strcmp(option,"password")) {
 637                         SCPY(ext->password, param);
 638
 639                         PDEBUG(DEBUG_CONFIG, "password: %s\n",param);
 640                 } else
 641                 if (!strcmp(option,"vbox_mode")) {
 642                         if (!strcasecmp(param, "parallel"))
 643                                 ext->vbox_mode = VBOX_MODE_PARALLEL;
 644                         else if (!strcasecmp(param, "announcement"))
 645                                 ext->vbox_mode = VBOX_MODE_ANNOUNCEMENT;
 646                         else
 647                                 ext->vbox_mode = VBOX_MODE_NORMAL;
 648                         PDEBUG(DEBUG_CONFIG, "given vbox mode: %s\n", param);
 649                 } else
 650                 if (!strcmp(option,"vbox_codec")) {
 651                         if (!strcasecmp(param, "stereo"))
 652                                 ext->vbox_codec = CODEC_STEREO;
 653                         else if (!strcasecmp(param, "8bit"))
 654                                 ext->vbox_codec = CODEC_8BIT;
 655                         else if (!strcasecmp(param, "law"))
 656                                 ext->vbox_codec = CODEC_LAW;
 657                         else
 658                                 ext->vbox_codec = CODEC_MONO;
 659                         PDEBUG(DEBUG_CONFIG, "given record param: %s\n", param);
 660                 } else
 661                 if (!strcmp(option,"vbox_time")) {
 662                         ext->vbox_time = atoi(param);
 663                         if (ext->vbox_time < 0)
 664                                 ext->vbox_time = 0;
 665
 666                         PDEBUG(DEBUG_CONFIG, "vbox time to record: %d\n",ext->vbox_time);
 667                 } else
 668                 if (!strcmp(option,"vbox_display")) {
 669                         if (!strcasecmp(param, "detailed")
 670                          || !strcasecmp(param, "detailled"))
 671                                 ext->vbox_display = VBOX_DISPLAY_DETAILED;
 672                         else if (!strcasecmp(param, "off"))
 673                                 ext->vbox_display = VBOX_DISPLAY_OFF;
 674                         else
 675                                 ext->vbox_display = VBOX_DISPLAY_BRIEF;
 676                         PDEBUG(DEBUG_CONFIG, "given vbox mode: %s\n", param);
 677                 } else
 678                 if (!strcmp(option,"vbox_language")) {
 679                         if (!strcasecmp(param, "german"))
 680                                 ext->vbox_language = VBOX_LANGUAGE_GERMAN;
 681                         else
 682                                 ext->vbox_language = VBOX_LANGUAGE_ENGLISH;
 683                         PDEBUG(DEBUG_CONFIG, "given vbox mode: %s\n", param);
 684                 } else
 685                 if (!strcmp(option,"vbox_email")) {
 686                         SCPY(ext->vbox_email, param);
 687                         PDEBUG(DEBUG_CONFIG, "given vbox email: %s\n", param);
 688                 } else
 689                 if (!strcmp(option,"vbox_email_file")) {
 690                         i=0;
 691                         while(ext_yesno[i]) {
 692                                 if (!strcasecmp(param,ext_yesno[i]))
 693                                         break;
 694                                 i++;
 695                         }
 696                         if (ext_yesno[i]) {
 697                                 ext->vbox_email_file = i;
 698                                 PDEBUG(DEBUG_CONFIG, "attach audio file %s\n", ext_yesno[i]);
 699                         } else {
 700                                 PDEBUG(DEBUG_CONFIG, "given vbox_email_file param unknown: %s\n", param);
 701                         }
 702                 } else
 703                 if (!strcmp(option,"vbox_free")) {
 704                         i=0;
 705                         while(ext_yesno[i]) {
 706                                 if (!strcasecmp(param,ext_yesno[i]))
 707                                         break;
 708                                 i++;
 709                         }
 710                         if (ext_yesno[i]) {
 711                                 ext->vbox_free = i;
 712                                 PDEBUG(DEBUG_CONFIG, "vbox_free %s\n", ext_yesno[i]);
 713                         } else {
 714                                 PDEBUG(DEBUG_CONFIG, "given vbox_free param unknown: %s\n", param);
 715                         }
 716                 } else
 717                 if (!strcmp(option,"last_in")) {
 718                         if (param[0] && last_in_count<MAX_REMEMBER) {
 719                                 SCPY(ext->last_in[last_in_count], param);
 720                                 last_in_count++;
 721                         }
 722                         PDEBUG(DEBUG_CONFIG, "last_in dialed number: %s\n",param);
 723                 } else
 724                 if (!strcmp(option,"last_out")) {
 725                         if (param[0] && last_out_count<MAX_REMEMBER) {
 726                                 SCPY(ext->last_out[last_out_count], param);
 727                                 last_out_count++;
 728                         }
 729                         PDEBUG(DEBUG_CONFIG, "last_out dialed number: %s\n",param);
 730                 } else
 731                 if (!strcmp(option,"datacall")) {
 732                         i=0;
 733                         while(ext_yesno[i]) {
 734                                 if (!strcasecmp(param,ext_yesno[i]))
 735                                         break;
 736                                 i++;
 737                         }
 738                         if (ext_yesno[i]) {
 739                                 ext->datacall = i;
 740                                 PDEBUG(DEBUG_CONFIG, "datacall %s\n", ext_yesno[i]);
 741                         } else {
 742                                 PDEBUG(DEBUG_CONFIG, "given datacall param unknown: %s\n", param);
 743                         }
 744                 } else
 745                 if (!strcmp(option,"seconds")) {
 746                         i=0;
 747                         while(ext_yesno[i]) {
 748                                 if (!strcasecmp(param,ext_yesno[i]))
 749                                         break;
 750                                 i++;
 751                         }
 752                         if (ext_yesno[i]) {
 753                                 ext->no_seconds = 1-i;
 754                                 PDEBUG(DEBUG_CONFIG, "seconds %s\n", ext_yesno[i]);
 755                         } else {
 756                                 PDEBUG(DEBUG_CONFIG, "unknown param for seconds: %s\n", param);
 757                         }
 758                 } else
 759                 if (!strcmp(option,"otp-ident")) {
 760                         SCPY(ext->otp_ident, param);
 761                         PDEBUG(DEBUG_CONFIG, "otp-ident: %s\n",param);
 762                 } else
 763                 if (!strcmp(option,"dov_ident")) {
 764                         if (param[0]) {
 765                                 SCPY(ext->dov_ident, param);
 766                                 PDEBUG(DEBUG_CONFIG, "dov_ident string: %s\n",param);
 767                         }
 768                 } else
 769                 if (!strcmp(option,"dov_log")) {
 770                         if (param[0]) {
 771                                 SCPY(ext->dov_log, param);
 772                                 PDEBUG(DEBUG_CONFIG, "dov_log filename: %s\n",param);
 773                         }
 774                 } else
 775                 if (!strcmp(option,"dov_type")) {
 776                         if (!strcasecmp(param, "pcm"))
 777                                 ext->dov_type = DOV_TYPE_PCM;
 778                         else
 779                                 ext->dov_type = DOV_TYPE_PWM;
 780                         PDEBUG(DEBUG_CONFIG, "given dov type: %s\n", param);
 781                 } else
 782                 if (!strcmp(option,"dov_level")) {
 783                         if (atoi(param)) {
 784                                 ext->dov_level = atoi(param);
 785                                 PDEBUG(DEBUG_CONFIG, "dov_level: %s\n",param);
 786                         }
 787                 } else {
 788                         PERROR_RUNTIME("Error in %s (line %d): wrong option keyword %s.\n",filename,line,option);
 789                 }
 790         }
 791
 792         if (fp) fclose(fp);
 793         return(1);
 794 }
 795
 796
 797 /* write extension
 798  *
 799  * writes extension for given extension number from structure
 800  */
 801 int write_extension(struct extension *ext, char *number)
 802 {
 803         FILE *fp=NULL;
 804         char filename[256];
 805         int i;
 806
 807         if (number[0] == '\0')
 808                 return(0);
 809
 810         SPRINT(filename, "%s/%s/settings", EXTENSION_DATA, number);
 811
 812         if (!(fp = fopen(filename, "w"))) {
 813                 PERROR("Cannot open settings: \"%s\"\n", filename);
 814                 return(0);
 815         }
 816
 817         fprintf(fp,"# Settings of extension %s\n\n", number);
 818
 819         fprintf(fp,"# Name of extension:\n");
 820         fprintf(fp,"name            %s\n\n",ext->name);
 821
 822         fprintf(fp,"# Predialed prefix after pick-up of the phone\n");
 823         fprintf(fp,"prefix          %s\n\n",ext->prefix);
 824
 825         fprintf(fp,"# Next prefix to dial pick-up of the phone\n");
 826         fprintf(fp,"# This will be cleared on hangup.\n");
 827         fprintf(fp,"next            %s\n\n",ext->next);
 828
 829 //      fprintf(fp,"# Set up alarm message after prefix is dialed and connection is established\n");
 830 //      fprintf(fp,"alarm           %s\n\n",ext->alarm);
 831
 832         fprintf(fp,"# Interface(s) to ring on calls to extension (as named in interface.conf)\n");
 833         fprintf(fp,"# Seperate multiple interfaces by using komma without spaces\n");
 834         fprintf(fp,"# Example: Int would ring on the interface with the name \"Int\"\n");
 835         fprintf(fp,"#          Int1,Int2 would ring incoming calls on both interfaces Int1 and Int2.\n");
 836         fprintf(fp,"interfaces      %s\n\n",ext->interfaces);
 837
 838         fprintf(fp,"# Call Forward Unconditional (CFU)\n");
 839         fprintf(fp,"# No port will be called, CFB, CFNR and CFP is ignored.\n");
 840         fprintf(fp,"# Use keyword \"vbox\" to forward call directly to answering machine.\n");
 841         fprintf(fp,"cfu             %s\n\n",ext->cfu);
 842
 843         fprintf(fp,"# Call Forward when Busy (CFB)\n");
 844         fprintf(fp,"# If the extension is in use at least once, this forward is done.\n");
 845         fprintf(fp,"# In case of busy line, CFNR and CFP is ignored.\n");
 846         fprintf(fp,"# Use keyword \"vbox\" to forward call to answering machine when busy.\n");
 847         fprintf(fp,"cfb             %s\n\n",ext->cfb);
 848
 849         fprintf(fp,"# Call Forward on No Response (CFNR)\n");
 850         fprintf(fp,"# If noone answers, the call is forwarded, ports and CFP will be released.\n");
 851         fprintf(fp,"# The default delay is 20 seconds.\n");
 852         fprintf(fp,"# Use keyword \"vbox\" to forward call to answering machine on no response.\n");
 853         fprintf(fp,"cfnr            %s\n",ext->cfnr);
 854         fprintf(fp,"cfnr_delay      %d\n\n",ext->cfnr_delay);
 855
 856         fprintf(fp,"# Call Forward Parallel (CFP)\n");
 857         fprintf(fp,"# Call will ring on the forwarded number, simulaniousely with the ports.\n");
 858         fprintf(fp,"cfp             %s\n\n",ext->cfp);
 859
 860         fprintf(fp,"# Allow user to change call forwarding.\n");
 861         fprintf(fp,"change_forward  %s\n\n", ext_yesno[ext->change_forward]);
 862
 863         fprintf(fp,"# Caller id\n# This must be one of the following:\n");
 864         fprintf(fp,"# <number> (as dialed from your local area)\n");
 865         fprintf(fp,"# <number> anonymous (will only be shown to emergency phones)\n");
 866         fprintf(fp,"# none (no number available at all)\n");
 867         fprintf(fp,"# by default the number is of type UNKNOWN (for MULTIPOINT lines)\n");
 868         fprintf(fp,"# if your caller id is not screened on outgoing calls use one of the following:\n");
 869         fprintf(fp,"# use prefix 'i' for TYPE INTERNATIONAL (i<county code><areacode+number>)\n");
 870         fprintf(fp,"# use prefix 'n' for TYPE NATIONAL (n<areacode+number>)\n");
 871         fprintf(fp,"# use prefix 's' for TYPE SUBSCRIBER (s<local number>)\n");
 872         if (ext->callerid_present == INFO_PRESENT_NOTAVAIL)
 873                 fprintf(fp,"callerid        none\n\n");
 874         else {
 875                 switch(ext->callerid_type) {
 876                         case INFO_NTYPE_INTERNATIONAL:
 877                         fprintf(fp,"callerid        i%s%s\n\n",ext->callerid, (ext->callerid_present==INFO_PRESENT_RESTRICTED)?" anonymous":"");
 878                         break;
 879                         case INFO_NTYPE_NATIONAL:
 880                         fprintf(fp,"callerid        n%s%s\n\n",ext->callerid, (ext->callerid_present==INFO_PRESENT_RESTRICTED)?" anonymous":"");
 881                         break;
 882                         case INFO_NTYPE_SUBSCRIBER:
 883                         fprintf(fp,"callerid        s%s%s\n\n",ext->callerid, (ext->callerid_present==INFO_PRESENT_RESTRICTED)?" anonymous":"");
 884                         break;
 885                         default:
 886                         fprintf(fp,"callerid        %s%s\n\n",ext->callerid, (ext->callerid_present==INFO_PRESENT_RESTRICTED)?" anonymous":"");
 887                 }
 888         }
 889
 890         fprintf(fp,"# Caller id for next call (see caller id)\n");
 891         if (ext->id_next_call_present < 0)
 892                 fprintf(fp,"id_next_call    \n\n");
 893         else if (ext->id_next_call_present == INFO_PRESENT_NOTAVAIL)
 894                 fprintf(fp,"id_next_call    none\n\n");
 895         else {
 896                 switch(ext->id_next_call_type) {
 897                         case INFO_NTYPE_INTERNATIONAL:
 898                         fprintf(fp,"id_next_call    i%s%s\n\n",ext->id_next_call, (ext->id_next_call_present==INFO_PRESENT_RESTRICTED)?" anonymous":"");
 899                         break;
 900                         case INFO_NTYPE_NATIONAL:
 901                         fprintf(fp,"id_next_call    n%s%s\n\n",ext->id_next_call, (ext->id_next_call_present==INFO_PRESENT_RESTRICTED)?" anonymous":"");
 902                         break;
 903                         case INFO_NTYPE_SUBSCRIBER:
 904                         fprintf(fp,"id_next_call    s%s%s\n\n",ext->id_next_call, (ext->id_next_call_present==INFO_PRESENT_RESTRICTED)?" anonymous":"");
 905                         break;
 906                         default:
 907                         fprintf(fp,"id_next_call    %s%s\n\n",ext->id_next_call, (ext->id_next_call_present==INFO_PRESENT_RESTRICTED)?" anonymous":"");
 908                 }
 909         }
 910
 911         fprintf(fp,"# Allow user to change caller ID.\n");
 912         fprintf(fp,"change_callerid %s\n\n", ext_yesno[ext->change_callerid]);
 913
 914         fprintf(fp,"# Caller Line Identification Presentation (CLIP)\n");
 915         fprintf(fp,"# clip (asis|hide)\n");
 916         fprintf(fp,"# asis: On forwarded calls the CLIP is used as presented by the calling party.\n");
 917         fprintf(fp,"# hide: Always use extension's caller id, even on forwared calls.\n");
 918         switch(ext->clip) {
 919                 case CLIP_HIDE:
 920                 fprintf(fp,"clip            hide\n\n");
 921                 break;
 922                 default:
 923                 fprintf(fp,"clip            asis\n\n");
 924         }
 925
 926         fprintf(fp,"# Connected Line Identification Presentation (COLP)\n");
 927         fprintf(fp,"# colp (asis|hide|force)\n");
 928         fprintf(fp,"# asis: Provides colp as defined by the extension's caller id.\n");
 929         fprintf(fp,"#       On forwarded calls the COLP is used as presented by the called party.\n");
 930         fprintf(fp,"# hide: Always use extension's caller id, even on forwared calls.\n");
 931         fprintf(fp,"# force: If COLP is not presented by forwarded calls the dialed number is used.\n");
 932         switch(ext->colp) {
 933                 case COLP_HIDE:
 934                 fprintf(fp,"colp            hide\n\n");
 935                 break;
 936                 case COLP_FORCE:
 937                 fprintf(fp,"colp            force\n\n");
 938                 break;
 939                 default:
 940                 fprintf(fp,"colp            asis\n\n");
 941         }
 942
 943         fprintf(fp,"# CLIP Prefix\n");
 944         fprintf(fp,"# Adds a prefix to incoming caller IDs, so telephones will be able to respond\n");
 945         fprintf(fp,"# to unanswered calls from their list. The prefix must be the digit(s) to get\n");
 946         fprintf(fp,"# an external line. The caller ID will then be extendet so that they can be\n");
 947         fprintf(fp,"# dialed from internal telephones. Many telephones have this feature, but some\n");
 948         fprintf(fp,"# don't.\n");
 949         fprintf(fp,"clip_prefix     %s\n\n",ext->clip_prefix);
 950
 951         fprintf(fp,"# Keypad control\n");
 952         fprintf(fp,"# If supported by telephone, pressing a key on the keypad will not result in\n");
 953         fprintf(fp,"# DTMF tone, but the digit is transmitted via D-channel diaing info.\n");
 954         fprintf(fp,"keypad          %s\n\n",(ext->keypad)?"yes":"no");
 955
 956         fprintf(fp,"# Ignore restriction of COLP and CLIP\n");
 957         fprintf(fp,"# In this case even restricted numbers are presented to this extension.\n");
 958         fprintf(fp,"# This also works for incoming external anonymous calls IF:\n");
 959         fprintf(fp,"# You have the CLIRIGN feature like POLICE or equivalent.\n");
 960         fprintf(fp,"anon-ignore     %s\n\n",(ext->anon_ignore)?"yes":"no");
 961
 962         fprintf(fp,"# Dialing rights (none|internal|local|national|international)\n");
 963         fprintf(fp,"rights          %s\n\n",ext_rights[ext->rights]);
 964
 965         fprintf(fp,"# Delete function for external calls. '*' will delete the last digit, '#' will\n");
 966         fprintf(fp,"# delete the complete number. Also enable 'display_dialing' to see on the\n");
 967         fprintf(fp,"# display what actually happens.\n");
 968         fprintf(fp,"delete_ext      %s\n\n",ext_yesno[ext->delete_ext]);
 969
 970         fprintf(fp,"# If noknocking is enabled, the caller will get a busy message when the\n");
 971         fprintf(fp,"# extension is doing at least one call.\n");
 972         fprintf(fp,"noknocking      %s\n\n",ext_yesno[ext->noknocking]);
 973
 974         fprintf(fp,"# Transmit volume (-8 .. 8)\n");
 975         fprintf(fp,"# 0 = normal\n");
 976         fprintf(fp,"# 1 = double, 2 = quadrupel, 8 = 256 times (amplitude)\n");
 977         fprintf(fp,"# -1 = half, -2 = quarter, 8 = 1/256th (amplitude)\n");
 978         fprintf(fp,"# Audio data is limited to the maximum value when exceeds limit.\n");
 979         fprintf(fp,"tx_gain          %d\n\n",ext->tx_gain);
 980
 981         fprintf(fp,"# Receive volume (-8 .. 8)\n");
 982         fprintf(fp,"# (see tx_gain)\n");
 983         fprintf(fp,"rx_gain          %d\n\n",ext->rx_gain);
 984
 985
 986         fprintf(fp,"# Force to use tones and announcements generated by the pbx.\n");
 987         fprintf(fp,"# For internal calls always own tones are used. You may specify own tones for\n");
 988         fprintf(fp,"# different call states:\n");
 989         fprintf(fp,"# own_setup (dialtone and during dialing)\n");
 990         fprintf(fp,"# own_proceeding (call in poceeding state)\n");
 991         fprintf(fp,"# own_alerting (call is ringing)\n");
 992         fprintf(fp,"# own_cause (when the call gets disconnected or failed to be completed)\n");
 993         fprintf(fp,"own_setup       %s\n",ext_yesno[ext->own_setup]);
 994         fprintf(fp,"own_proceeding  %s\n",ext_yesno[ext->own_proceeding]);
 995         fprintf(fp,"own_alerting    %s\n",ext_yesno[ext->own_alerting]);
 996         fprintf(fp,"own_cause       %s\n\n",ext_yesno[ext->own_cause]);
 997
 998         fprintf(fp,"# Allow facility information to be transfered to the telephone.\n");
 999         fprintf(fp,"# This is required to receive advice of charge.\n");
1000         fprintf(fp,"facility        %s\n\n",ext_yesno[ext->facility]);
1001
1002         fprintf(fp,"# Display clear causes using display messages (Q.850)\n# This must be one of the following:\n");
1003         fprintf(fp,"# none (no displaying of clear causes)\n");
1004         fprintf(fp,"# english (display cause text in english)\n");
1005         fprintf(fp,"# german (display cause text in german)\n");
1006         fprintf(fp,"# number (display cause number only)\n");
1007         fprintf(fp,"# english-location (display cause text in english and location)\n");
1008         fprintf(fp,"# german-location (display cause text in german and location)\n");
1009         switch(ext->display_cause) {
1010                 case DISPLAY_CAUSE_ENGLISH:
1011                 fprintf(fp,"display_cause   english\n\n");
1012                 break;
1013                 case DISPLAY_CAUSE_GERMAN:
1014                 fprintf(fp,"display_cause   german\n\n");
1015                 break;
1016                 case DISPLAY_LOCATION_ENGLISH:
1017                 fprintf(fp,"display_cause   english-location\n\n");
1018                 break;
1019                 case DISPLAY_LOCATION_GERMAN:
1020                 fprintf(fp,"display_cause   german-location\n\n");
1021                 break;
1022                 case DISPLAY_CAUSE_NUMBER:
1023                 fprintf(fp,"display_cause   number\n\n");
1024                 break;
1025                 default:
1026                 fprintf(fp,"display_cause   none\n\n");
1027         }
1028
1029         fprintf(fp,"# Display external caller ids using display override (yes or no)\n");
1030         fprintf(fp,"# example: \"15551212\"\n");
1031         fprintf(fp,"display_ext     %s\n\n",(ext->display_ext)?"yes":"no");
1032
1033         fprintf(fp,"# Display internal caller ids using display override (yes or no)\n");
1034         fprintf(fp,"# example: \"200 (int)\"\n");
1035         fprintf(fp,"display_int     %s\n\n",(ext->display_int)?"yes":"no");
1036
1037         fprintf(fp,"# Display if calls are anonymous using display override (yes or no)\n");
1038         fprintf(fp,"# This makes only sense if the anon-ignore feature is enabled.\n");
1039         fprintf(fp,"# example: \"15551212 anon\"\n");
1040         fprintf(fp,"display_anon    %s\n\n",(ext->display_anon)?"yes":"no");
1041
1042         fprintf(fp,"# Display fake caller ids using display override (yes or no)\n");
1043         fprintf(fp,"# If the caller uses \"clip no screening\", you will see if the number is\n");
1044         fprintf(fp,"# real or fake\n");
1045         fprintf(fp,"# example: \"15551212 fake\"\n");
1046         fprintf(fp,"display_fake    %s\n\n",(ext->display_fake)?"yes":"no");
1047
1048         fprintf(fp,"# Display caller's name if available. (yes or no)\n");
1049         fprintf(fp,"# example: \"15551212 Axel\"\n");
1050         fprintf(fp,"display_name    %s\n\n",(ext->display_name)?"yes":"no");
1051
1052         fprintf(fp,"# Display menu when '*' and '#' is pressed. The menu shows all prefixes for\n");
1053         fprintf(fp,"# internal dialing by pressing '*' for previous prefix and '#' for next prefix.\n");
1054         fprintf(fp,"# Also the dialed prefix is show on display. (yes or no)\n");
1055         fprintf(fp,"display_menu    %s\n\n",(ext->display_menu)?"yes":"no");
1056
1057         fprintf(fp,"# Display digits as they are interpreted by pbx. (yes or no)\n");
1058         fprintf(fp,"display_dialing %s\n\n",(ext->display_dialing)?"yes":"no");
1059
1060         fprintf(fp,"# Tones directory for announcements and patterns\n");
1061         fprintf(fp,"# Enter nothing for default tones as selected by options.conf or interface.conf.\n");
1062         fprintf(fp,"tones_dir       %s\n\n",ext->tones_dir);
1063
1064         fprintf(fp,"# Record calls to extension's directory. The file is written as wave.\n");
1065         fprintf(fp,"# This must be one of the following:\n");
1066         fprintf(fp,"# off (no recording)\n");
1067         fprintf(fp,"# mono (records wave 16 bit mono, 128kbits/s)\n");
1068         fprintf(fp,"# stereo (records wave 32 bit stereo, 256kbits/s)\n");
1069         fprintf(fp,"# 8bit (records wave 8 bit mono, 64kbits/s)\n");
1070         fprintf(fp,"# law (records xLaw encoded, as specified in options.conf, 64kbps/s)\n");
1071         switch(ext->record) {
1072                 case CODEC_MONO:
1073                 fprintf(fp,"record          mono\n\n");
1074                 break;
1075                 case CODEC_STEREO:
1076                 fprintf(fp,"record          stereo\n\n");
1077                 break;
1078                 case CODEC_8BIT:
1079                 fprintf(fp,"record          8bit\n\n");
1080                 break;
1081                 case CODEC_LAW:
1082                 fprintf(fp,"record          law\n\n");
1083                 break;
1084                 default:
1085                 fprintf(fp,"record          off\n\n");
1086         }
1087
1088         fprintf(fp,"# Password for callback and login\n");
1089         fprintf(fp,"# Enter nothing if callback and login should not be possible.\n");
1090         fprintf(fp,"password        %s\n\n",ext->password);
1091
1092         fprintf(fp,"# The Answering Machine. Enter the mode of answering machine.\n");
1093         fprintf(fp,"# This must be one of the following:\n");
1094         fprintf(fp,"# normal (plays announcement and records after that)\n");
1095         fprintf(fp,"# parallel (plays announcement and records also DURING announcement.)\n");
1096         fprintf(fp,"# announcement (just plays announcement and hangs up)\n");
1097         switch(ext->vbox_mode) {
1098                 case VBOX_MODE_PARALLEL:
1099                 fprintf(fp,"vbox_mode       parallel\n\n");
1100                 break;
1101                 case VBOX_MODE_ANNOUNCEMENT:
1102                 fprintf(fp,"vbox_mode       announcement\n\n");
1103                 break;
1104                 default:
1105                 fprintf(fp,"vbox_mode       normal\n\n");
1106         }
1107
1108         fprintf(fp,"# The Answering Machine. Enter the type of codec for recording.\n");
1109         fprintf(fp,"# This must be one of the following:\n");
1110         fprintf(fp,"# law (alaw/ulas codec, as specified in options.conf)\n");
1111         fprintf(fp,"# mono (16 bit mono wave file)\n");
1112         fprintf(fp,"# stereo (16 bit stereo wave file)\n");
1113         fprintf(fp,"# 8bit (8 bit mono wave file)\n");
1114         switch(ext->vbox_codec) {
1115                 case CODEC_LAW:
1116                 fprintf(fp,"vbox_codec      law\n\n");
1117                 break;
1118                 case CODEC_STEREO:
1119                 fprintf(fp,"vbox_codec      stereo\n\n");
1120                 break;
1121                 case CODEC_8BIT:
1122                 fprintf(fp,"vbox_codec      8bit\n\n");
1123                 break;
1124                 default:
1125                 fprintf(fp,"vbox_codec      mono\n\n");
1126         }
1127
1128         fprintf(fp,"# The Answering Machine. Enter maximum time to record after announcement.\n");
1129         fprintf(fp,"# Leave empty, enter \"infinite\" or give time in seconds.\n");
1130         fprintf(fp,"# Enter nothing if callback and login should not be possible.\n");
1131         if (ext->vbox_time)
1132                 fprintf(fp,"vbox_time       %d\n\n",ext->vbox_time);
1133         else
1134                 fprintf(fp,"vbox_time       infinite\n\n");
1135
1136         fprintf(fp,"# The Answering Machine. Enter mode for display current state.\n");
1137         fprintf(fp,"# This must be one of the following:\n");
1138         fprintf(fp,"# brief (displays brief information, for small displays)\n");
1139         fprintf(fp,"# detailed (displays detailed information, for larger displays)\n");
1140         fprintf(fp,"# off (don't display anything)\n");
1141         switch(ext->vbox_display) {
1142                 case VBOX_DISPLAY_OFF:
1143                 fprintf(fp,"vbox_display    off\n\n");
1144                 break;
1145                 case VBOX_DISPLAY_DETAILED:
1146                 fprintf(fp,"vbox_display    detailed\n\n");
1147                 break;
1148                 default:
1149                 fprintf(fp,"vbox_display    brief\n\n");
1150         }
1151
1152         fprintf(fp,"# The Answering Machine. Enter type of language: \"english\" or \"german\"\n");
1153         fprintf(fp,"# Display information of the menu, will be provided as specified.\n");
1154         fprintf(fp,"# The menu's voice is located in \"vbox_english\" and \"vbox_german\".\n");
1155         if (ext->vbox_language)
1156                 fprintf(fp,"vbox_language   german\n\n");
1157         else
1158                 fprintf(fp,"vbox_language   english\n\n");
1159
1160         fprintf(fp,"# The Answering Machine. Enter email to send incoming messages to:\n");
1161         fprintf(fp,"# All incoming message will be send to the given address.\n");
1162         fprintf(fp,"# The audio file is attached if \"vbox_email_file\" is 'yes'\n");
1163         fprintf(fp,"vbox_email      %s\n", ext->vbox_email);
1164         fprintf(fp,"vbox_email_file %s\n\n",ext_yesno[ext->vbox_email_file]);
1165
1166         fprintf(fp,"# If audio path is connected prior answering of a call, say 'yes'\n");
1167         fprintf(fp,"# will cause the call to be billed after playing the announcement. (yes or no)\n");
1168         fprintf(fp,"vbox_free       %s\n\n",(ext->vbox_free)?"yes":"no");
1169
1170         fprintf(fp,"# Accept incoming data calls as it would be an audio call.\n");
1171         fprintf(fp,"datacall        %s\n\n",ext_yesno[ext->datacall]);
1172
1173         fprintf(fp,"# Include seconds (time) in the connect message. (Should be always enabled.)\n");
1174         fprintf(fp,"seconds         %s\n\n",ext_yesno[1-ext->no_seconds]);
1175
1176         fprintf(fp,"# Identity string for VoOTP encryption\n");
1177         fprintf(fp,"otp-ident       %s\n\n", ext->otp_ident);
1178
1179         fprintf(fp,"# Last outgoing and incoming numbers (including prefix)\n");
1180         i = 0;
1181         while(i < MAX_REMEMBER) {
1182                 if (ext->last_out[i][0])
1183                         fprintf(fp,"last_out        %s\n",ext->last_out[i]);
1184                 i++;
1185         }
1186         i = 0;
1187         while(i < MAX_REMEMBER) {
1188                 if (ext->last_in[i][0])
1189                         fprintf(fp,"last_in         %s\n",ext->last_in[i]);
1190                 i++;
1191         }
1192         fprintf(fp,"\n");
1193
1194         fprintf(fp,"# Identify to/from remove via Data-Over-Voice feature.\n");
1195         fprintf(fp,"dov_ident       %s\n", ext->dov_ident);
1196         fprintf(fp,"dov_log         %s\n", ext->dov_log);
1197         switch(ext->dov_type) {
1198                 case DOV_TYPE_PWM:
1199                 fprintf(fp,"dov_type        pwm\n");
1200                 break;
1201                 case DOV_TYPE_PCM:
1202                 fprintf(fp,"dov_type        pcm\n");
1203                 break;
1204         }
1205         fprintf(fp,"dov_level       %d\n\n", ext->dov_level);
1206
1207         if (fp) fclose(fp);
1208         return(1);
1209 }
1210
1211
1212 /* write log for extension
1213  *
1214  */
1215 int write_log(char *number, char *callerid, char *calledid, time_t start, time_t stop, int aoce, int cause, int location)
1216 {
1217         const char *mon[] = {"Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"};
1218         FILE *fp=NULL;
1219         char filename[256];
1220         struct tm *tm;
1221
1222         if (callerid[0] == '\0')
1223                 callerid = (char *)"<unknown>";
1224
1225         SPRINT(filename, "%s/%s/log", EXTENSION_DATA, number);
1226
1227         if (!(fp = fopen(filename, "a"))) {
1228                 PERROR("Cannot open log: \"%s\"\n", filename);
1229                 return(0);
1230         }
1231
1232         tm = localtime(&start);
1233         fprintf(fp,"%s %2d %04d %02d:%02d:%02d %s", mon[tm->tm_mon], tm->tm_mday, tm->tm_year+1900, tm->tm_hour, tm->tm_min, tm->tm_sec, number);
1234         if (stop)
1235                 fprintf(fp," %2ld:%02d:%02d", (stop-start)/3600, (((unsigned int)(stop-start))/60)%60, ((unsigned int)(stop-start))%60);
1236         else
1237                 fprintf(fp," --:--:--");
1238         fprintf(fp," %s -> %s", callerid, calledid);
1239         if (cause >= 1 && cause <=127 && location>=0 && location<=15)
1240                 fprintf(fp," (cause=%d '%s' location=%d '%s')", cause, isdn_cause[cause].german, location, isdn_location[location].german);
1241         fprintf(fp,"\n");
1242
1243         if (fp) fclose(fp);
1244         return(1);
1245 }
1246
1247
1248 /* parse phonebook
1249  *
1250  * reads phone book of extextension and compares the given elements which
1251  * are: abreviation, phone number, name (name is not compared)
1252  * on success a 1 is returned and the pointers of elements are set to the
1253  * result.
1254  */
1255 int parse_phonebook(char *number, char **abbrev_pointer, char **phone_pointer, char **name_pointer)
1256 {
1257         FILE *fp=NULL;
1258         char filename[256];
1259         char *p;
1260         static char abbrev[32], phone[256], name[256];
1261         unsigned int line,i;
1262         char buffer[1024];
1263         int found = 0, found_if_more_digits = 0;
1264
1265         SPRINT(filename, "%s/%s/phonebook", EXTENSION_DATA, number);
1266
1267         if (!(fp = fopen(filename, "r"))) {
1268                 PERROR("Cannot open phonebook: \"%s\"\n", filename);
1269                 return(0);
1270         }
1271
1272         line=0;
1273         while((GETLINE(buffer, fp))) {
1274                 line++;
1275                 p = buffer;
1276
1277                 while(*p <= 32) { /* skip spaces */
1278                         if (*p == 0)
1279                                 break;
1280                         p++;
1281                 }
1282                 if (*p==0 || *p=='#') /* ignore comments and empty line */
1283                         continue;
1284
1285                 abbrev[0]=0;
1286                 phone[0]=0;
1287                 name[0]=0;
1288
1289                 i=0; /* read abbrev */
1290                 while(*p > 32) {
1291                         if (i+1 >= sizeof(abbrev)) {
1292                                 PERROR_RUNTIME("Error in %s (line %d): abbrev too long.\n",filename,line);
1293                                 break;
1294                         }
1295                         abbrev[i+1] = '\0';
1296                         abbrev[i++] = *p++;
1297                 }
1298
1299                 while(*p <= 32) { /* skip spaces */
1300                         if (*p == 0)
1301                                 break;
1302                         p++;
1303                 }
1304
1305                 if (*p!=0 && *p!='#') { /* phone */
1306                         i=0; /* read phone */
1307                         while(*p > 32) {
1308                                 if (i+1 >= sizeof(phone)) {
1309                                         PERROR_RUNTIME("Error in %s (line %d): phone too long.\n",filename,line);
1310                                         break;
1311                                 }
1312                                 phone[i+1] = '\0';
1313                                 phone[i++] = *p++;
1314                         }
1315                         while(*p <= 32) { /* skip spaces */
1316                                 if (*p == 0)
1317                                         break;
1318                                 p++;
1319                         }
1320                 }
1321
1322                 if (*p!=0 && *p!='#') { /* name */
1323                         i=0; /* read name */
1324                         while(*p > 0) {
1325                                 if (i+1 >= sizeof(name)) {
1326                                         PERROR_RUNTIME("Error in %s (line %d): name too long.\n",filename,line);
1327                                         break;
1328                                 }
1329                                 name[i+1] = '\0';
1330                                 name[i++] = *p++;
1331                         }
1332                 }
1333
1334                 if (*abbrev_pointer) {
1335                         if (!strncmp(*abbrev_pointer, abbrev, strlen(*abbrev_pointer))) {
1336                                 /* may match if abbreviation is longer */
1337                                 found_if_more_digits = 1;
1338                         }
1339                         if (!!strcasecmp(*abbrev_pointer, abbrev))
1340                                 continue;
1341                 }
1342                 if (*phone_pointer)
1343                         if (!!strcasecmp(*phone_pointer, phone))
1344                                 continue;
1345                 if (*name_pointer)
1346                         if (!!strcasecmp(*name_pointer, name))
1347                                 continue;
1348
1349                 found = 1;
1350                 break; /* found entry */
1351         }
1352
1353         if (fp) fclose(fp);
1354
1355         if (found) {
1356                 *abbrev_pointer = abbrev;
1357                 *phone_pointer = phone;
1358                 *name_pointer = name;
1359         }
1360
1361         if (found == 0) {
1362                 if (found_if_more_digits)
1363                         found = -1;
1364         }
1365         return(found);
1366 }
1367
1368 /* parsing secrets file
1369  *
1370  * 'number' specifies the externsion number, not the caller id
1371  * 'remote_id' specifies the dialed number, or the caller id for incoming calls
1372  * the result is the auth, crypt and key string, and 1 is returned.
1373  * on failure or not matching number, the 0 is returned
1374  */
1375 int parse_secrets(char *number, char *remote_id, char **auth_pointer, char **crypt_pointer, char **key_pointer)
1376 {
1377         FILE *fp=NULL;
1378         char filename[256];
1379         char *p;
1380         char remote[128];
1381         static char auth[64], crypt[64], key[4096];
1382         unsigned int line,i;
1383         char buffer[4096];
1384         int found = 0;
1385
1386         SPRINT(filename, "%s/%s/secrets", EXTENSION_DATA, number);
1387
1388         if (!(fp = fopen(filename, "r"))) {
1389                 PERROR("Cannot open secrets: \"%s\"\n", filename);
1390                 return(0);
1391         }
1392
1393         line=0;
1394         while((GETLINE(buffer, fp))) {
1395                 line++;
1396                 p = buffer;
1397
1398                 while(*p <= 32) { /* skip spaces */
1399                         if (*p == 0)
1400                                 break;
1401                         p++;
1402                 }
1403                 if (*p==0 || *p=='#') /* ignore comments and empty line */
1404                         continue;
1405
1406                 remote[0]=0;
1407                 auth[0]=0;
1408                 crypt[0]=0;
1409                 key[0]=0;
1410
1411                 i=0; /* read auth */
1412                 while(*p > 32) {
1413                         if (i+1 >= sizeof(remote)) {
1414                                 PERROR_RUNTIME("Error in %s (line %d): remote too long.\n",filename,line);
1415                                 break;
1416                         }
1417                         remote[i+1] = '\0';
1418                         remote[i++] = *p++;
1419                 }
1420
1421                 while(*p <= 32) { /* skip spaces */
1422                         if (*p == 0)
1423                                 break;
1424                         p++;
1425                 }
1426
1427                 if (*p!=0 && *p!='#') { /* auth */
1428                         i=0; /* read auth */
1429                         while(*p > 32) {
1430                                 if (i+1 >= sizeof(auth)) {
1431                                         PERROR_RUNTIME("Error in %s (line %d): auth too long.\n",filename,line);
1432                                         break;
1433                                 }
1434                                 auth[i+1] = '\0';
1435                                 auth[i++] = *p++;
1436                         }
1437                         while(*p <= 32) { /* skip spaces */
1438                                 if (*p == 0)
1439                                         break;
1440                                 p++;
1441                         }
1442                 }
1443
1444                 if (*p!=0 && *p!='#') { /* crypt */
1445                         i=0; /* read crypt */
1446                         while(*p > 32) {
1447                                 if (i+1 >= sizeof(crypt)) {
1448                                         PERROR_RUNTIME("Error in %s (line %d): crypt too long.\n",filename,line);
1449                                         break;
1450                                 }
1451                                 crypt[i+1] = '\0';
1452                                 crypt[i++] = *p++;
1453                         }
1454                         while(*p <= 32) { /* skip spaces */
1455                                 if (*p == 0)
1456                                         break;
1457                                 p++;
1458                         }
1459                 }
1460
1461                 if (*p!=0 && *p!='#') { /* key */
1462                         i=0; /* read key */
1463                         while(*p > 0) {
1464                                 if (i+1 >= sizeof(key)) {
1465                                         PERROR_RUNTIME("Error in %s (line %d): key too long.\n",filename,line);
1466                                         break;
1467                                 }
1468                                 key[i+1] = '\0';
1469                                 key[i++] = *p++;
1470                         }
1471                 }
1472 //printf("COMPARING: '%s' with '%s' %s %s %s\n", remote_id, remote, auth, crypt, key);
1473
1474                 if (!!strcasecmp(remote, remote_id))
1475                         continue;
1476
1477                 found = 1;
1478                 break; /* found entry */
1479         }
1480
1481         if (fp) fclose(fp);
1482
1483         if (found) {
1484                 *auth_pointer = auth;
1485                 *crypt_pointer = crypt;
1486                 *key_pointer = key;
1487         }
1488
1489         return(found);
1490 }
1491
1492 /* parse directory
1493  *
1494  * the caller id is given and the name is returned. if the name is not found,
1495  * NULL is returned.
1496  * on success a 1 is returned and the pointers of elements are set to the
1497  * result.
1498  */
1499 char *parse_directory(char *number, int type)
1500 {
1501         FILE *fp=NULL;
1502         char filename[256];
1503         char *p;
1504         static char phone[32], name[64];
1505         unsigned int line,i;
1506         char buffer[256];
1507         int found = 0;
1508
1509         SPRINT(filename, "%s/directory.list", CONFIG_DATA);
1510
1511         if (!(fp = fopen(filename, "r"))) {
1512                 PERROR("Cannot open directory: \"%s\"\n", filename);
1513                 return(NULL);
1514         }
1515
1516         line=0;
1517         while((GETLINE(buffer, fp))) {
1518                 line++;
1519                 p = buffer;
1520
1521                 while(*p <= 32) { /* skip spaces */
1522                         if (*p == 0)
1523                                 break;
1524                         p++;
1525                 }
1526                 if (*p==0 || *p=='#') /* ignore comments and empty line */
1527                         continue;
1528
1529                 phone[0]=0;
1530                 name[0]=0;
1531
1532                 i=0; /* read number */
1533                 while(*p > 32) {
1534                         if (i+1 >= sizeof(phone)) {
1535                                 PERROR_RUNTIME("Error in %s (line %d): number too long.\n",filename,line);
1536                                 break;
1537                         }
1538                         phone[i+1] = '\0';
1539                         phone[i++] = *p++;
1540                 }
1541
1542                 while(*p <= 32) { /* skip spaces */
1543                         if (*p == 0)
1544                                 break;
1545                         p++;
1546                 }
1547
1548                 i=0; /* read name */
1549                 while(*p >= 32) {
1550                         if (i+1 >= sizeof(name)) {
1551                                 PERROR_RUNTIME("Error in %s (line %d): name too long.\n",filename,line);
1552                                 break;
1553                         }
1554                         name[i+1] = '\0';
1555                         name[i++] = *p++;
1556                 }
1557
1558                 if (phone[0] == 'i') {
1559                         if (type != INFO_NTYPE_INTERNATIONAL)
1560                                 continue;
1561                         if (!strcmp(number, phone+1)) {
1562                                 found = 1;
1563                                 break;
1564                         }
1565                         continue;
1566                 }
1567                 if (phone[0] == 'n') {
1568                         if (type != INFO_NTYPE_NATIONAL)
1569                                 continue;
1570                         if (!strcmp(number, phone+1)) {
1571                                 found = 1;
1572                                 break;
1573                         }
1574                         continue;
1575                 }
1576                 if (phone[0] == 's') {
1577                         if (type==INFO_NTYPE_NATIONAL || type==INFO_NTYPE_INTERNATIONAL)
1578                                 continue;
1579                         if (!strcmp(number, phone+1)) {
1580                                 found = 1;
1581                                 break;
1582                         }
1583                         continue;
1584                 }
1585                 if (!strncmp(phone, options.international, strlen(options.international))) {
1586                         if (type != INFO_NTYPE_INTERNATIONAL)
1587                                 continue;
1588                         if (!strcmp(number, phone+strlen(options.international))) {
1589                                 found = 1;
1590                                 break;
1591                         }
1592                         continue;
1593                 }
1594                 if (!options.national[0]) { /* no national prefix */
1595                         if (type == INFO_NTYPE_INTERNATIONAL)
1596                                 continue;
1597                         if (!strcmp(number, phone)) {
1598                                 found = 1;
1599                                 break;
1600                         }
1601                         continue;
1602                 }
1603                 if (!strncmp(phone, options.national, strlen(options.national))) {
1604                         if (type != INFO_NTYPE_NATIONAL)
1605                                 continue;
1606                         if (!strcmp(number, phone+strlen(options.national))) {
1607                                 found = 1;
1608                                 break;
1609                         }
1610                         continue;
1611                 }
1612                 if (type==INFO_NTYPE_NATIONAL || type==INFO_NTYPE_INTERNATIONAL)
1613                         continue;
1614                 if (!strcmp(number, phone)) {
1615                         found = 1;
1616                         break;
1617                 }
1618         }
1619
1620         if (fp) fclose(fp);
1621
1622         if (found)
1623                 return(name);
1624         else
1625                 return(NULL);
1626 }
1627
1628 /* parse callbackauth
1629  *
1630  * searches for the given caller id and returns 1 == true or 0 == false
1631  */
1632 int parse_callbackauth(char *number, struct caller_info *callerinfo)
1633 {
1634         FILE *fp = NULL;
1635         char filename[256];
1636         char *p;
1637         unsigned int line,i;
1638         char buffer[256];
1639         static char caller_type[32], caller_id[64];
1640         int found = 0;
1641
1642         SPRINT(filename, "%s/%s/callbackauth", EXTENSION_DATA, number);
1643
1644         if (!(fp = fopen(filename, "r"))) {
1645                 PDEBUG(DEBUG_EPOINT, "Cannot open callbackauth: \"%s\"\n", filename);
1646                 return(0);
1647         }
1648
1649         line=0;
1650         while((GETLINE(buffer, fp))) {
1651                 line++;
1652                 p = buffer;
1653
1654                 while(*p <= 32) { /* skip spaces */
1655                         if (*p == 0)
1656                                 break;
1657                         p++;
1658                 }
1659                 if (*p==0 || *p=='#') /* ignore comments and empty line */
1660                         continue;
1661
1662                 caller_type[0]=0;
1663                 caller_id[0]=0;
1664
1665                 i=0; /* read caller_type */
1666                 while(*p > 32) {
1667                         if (i+1 >= sizeof(caller_type)) {
1668                                 PERROR_RUNTIME("Error in %s (line %d): caller_type too long.\n",filename,line);
1669                                 break;
1670                         }
1671                         caller_type[i+1] = '\0';
1672                         caller_type[i++] = *p++;
1673                 }
1674
1675                 while(*p <= 32) { /* skip spaces */
1676                         if (*p == 0)
1677                                 break;
1678                         p++;
1679                 }
1680
1681                 if (*p!=0 && *p!='#') { /* caller_id */
1682                         i=0; /* read caller_id */
1683                         while(*p > 32) {
1684                                 if (i+1 >= sizeof(caller_id)) {
1685                                         PERROR_RUNTIME("Error in %s (line %d): caller_id too long.\n",filename,line);
1686                                         break;
1687                                 }
1688                                 caller_id[i+1] = '\0';
1689                                 caller_id[i++] = *p++;
1690                         }
1691                         // ignoring more
1692                 }
1693
1694                 if (caller_type[0]=='\0' && caller_id[0]=='\0')
1695                         continue;
1696
1697                 if (atoi(caller_type) != callerinfo->ntype)
1698                         continue;
1699
1700                 if (!!strcmp(caller_id, callerinfo->id))
1701                         continue;
1702
1703                 found = 1;
1704                 break; /* found entry */
1705         }
1706
1707         if (fp) fclose(fp);
1708
1709         if (found)
1710                 return(1);
1711         return(0);
1712 }
1713
1714
1715 /* append line to callbackauth
1716  *
1717  */
1718 void append_callbackauth(char *number, struct caller_info *callerinfo)
1719 {
1720         FILE *fp = NULL;
1721         char filename[256];
1722
1723         SPRINT(filename, "%s/%s/callbackauth", EXTENSION_DATA, number);
1724
1725         if (callerinfo->id[0]=='\0') {
1726                 PERROR("caller has no id.\n");
1727                 return;
1728         }
1729         if (!(fp = fopen(filename, "a"))) {
1730                 PERROR("Cannot open callbackauth: \"%s\"\n", filename);
1731                 return;
1732         }
1733
1734         fprintf(fp, "%6d  %s\n", callerinfo->ntype, callerinfo->id);
1735
1736         fclose(fp);
1737
1738 }
1739
1740