action_vbox.cpp

   1 /*****************************************************************************\
   2 **                                                                           **
   3 ** PBX4Linux                                                                 **
   4 **                                                                           **
   5 **---------------------------------------------------------------------------**
   6 ** Copyright: Andreas Eversberg                                              **
   7 **                                                                           **
   8 ** dialing for answering machine is processed here                           **
   9 **                                                                           **
  10 \*****************************************************************************/
  11
  12 #include "main.h"
  13
  14
  15 // note: the given display message (e_vbox_display) may include "%s" for the counter
  16
  17 /*
  18  * these are the state, the vbox is in. if the current tone has been played,
  19  * an action will be calles as defined in vbox_message_eof(), which is called
  20  * from Epoint:handler().
  21  * also this state is used to determine the correct processing of the current key press
  22  */
  23 enum {
  24         VBOX_STATE_MENU,                /* tell the menu */
  25 VBOX_STATE_CALLINFO_BEGIN, /* this value defines the start of callinfo */
  26         VBOX_STATE_CALLINFO_INTRO,      /* tell that the "call is received at" */
  27         VBOX_STATE_CALLINFO_MONTH,      /* tell the month */
  28         VBOX_STATE_CALLINFO_DAY,        /* tell the day */
  29         VBOX_STATE_CALLINFO_HOUR,       /* tell the hour */
  30         VBOX_STATE_CALLINFO_OCLOCK,     /* tell the word "o'clock" */
  31         VBOX_STATE_CALLINFO_MIN,        /* tell the minute */
  32         VBOX_STATE_CALLINFO_MINUTES,    /* tell the word "minutes" */
  33         VBOX_STATE_CALLINFO_DIGIT,      /* tell the digits */
  34 VBOX_STATE_CALLINFO_END, /* this value defines the end of callingo */
  35         VBOX_STATE_NOTHING,             /* tells that no calls are recorded */
  36         VBOX_STATE_PLAY,                /* play the current recording */
  37         VBOX_STATE_PAUSE,               /* tell that the recording is paused */
  38         VBOX_STATE_RECORD_ASK,  /* ask for recording */
  39         VBOX_STATE_RECORD_PLAY, /* play recording */
  40         VBOX_STATE_RECORD_RECORD,       /* record recording */
  41         VBOX_STATE_STORE_ASK,   /* ask for store */
  42         VBOX_STATE_DELETE_ASK,  /* ask for delete */
  43         VBOX_STATE_STORE_DONE,  /* tell that message is store */
  44         VBOX_STATE_DELETE_DONE, /* tell that message is delete */
  45 };
  46
  47 const char *months_english[] = {"Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"};
  48 const char *months_german[] = {"Jan","Feb","Maer","Apr","Mai","Jun","Jul","Aug","Sep","Okt","Nov","Dez"};
  49
  50 struct vbox_menu {
  51         const char digit;
  52         const char *english;
  53         const char *german;
  54 } vbox_menu[] = {
  55         {'1', "<< previous", "<< zurueck"},
  56         {'2', "-> play", "-> anhoeren"},
  57         {'3', ">> next", ">> vor"},
  58         {'4', "<  rewind", "<  rueckspulen"},
  59         {'5', "[] stop", "[] stop"},
  60         {'6', ">  wind", ">  vorspulen"},
  61         {'7', "() record", "() Aufnahme"},
  62         {'8', "=  store", "=  speichern"},
  63         {'9', "X  delete", "X  loeschen"},
  64         {'0', "*  call", "*  anrufen"},
  65         {'\0', NULL, NULL}
  66 };
  67
  68 /*
  69  * initialize the vbox. this is called at process_dialing(), when the VBOX_PLAY
  70  * action has been selected by the caller
  71  */
  72 void EndpointAppPBX::action_init_vbox_play(void)
  73 {
  74         int                     language = e_ext.vbox_language;
  75         struct route_param      *rparam;
  76         struct lcr_msg          *message;
  77         struct port_list        *portlist = ea_endpoint->ep_portlist;
  78
  79         /* get extension */
  80         SCPY(e_vbox, e_ext.number);
  81         if ((rparam = routeparam(e_action, PARAM_EXTENSION)))
  82                 SCPY(e_vbox, rparam->string_value);
  83         if (e_vbox[0] == '\0') {
  84                 /* facility rejected */
  85                 message_disconnect_port(portlist, CAUSE_FACILITYREJECTED, LOCATION_PRIVATE_LOCAL, "");
  86                 new_state(EPOINT_STATE_OUT_DISCONNECT);
  87                 set_tone(portlist,"cause_22");
  88                 return;
  89         }
  90
  91         /* connect, but still accept more digits */
  92         new_state(EPOINT_STATE_IN_OVERLAP);
  93         if (e_ext.number[0])
  94                 e_dtmf = 1;
  95         message = message_create(ea_endpoint->ep_serial, portlist->port_id, EPOINT_TO_PORT, MESSAGE_CONNECT);
  96         message_put(message);
  97         logmessage(message->type, &message->param, portlist->port_id, DIRECTION_OUT);
  98
  99         /* initialize the vbox */
 100         PDEBUG(DEBUG_EPOINT, "EPOINT(%d) initializing answering vbox state\n", ea_endpoint->ep_serial);
 101
 102         e_vbox_state = VBOX_STATE_MENU;
 103         SCPY(e_vbox_display, (char *)((language)?"druecke 2 f. wiedergabe":"press 2 to play"));
 104         e_vbox_display_refresh = 1;
 105         set_tone_vbox("menu");
 106
 107         e_vbox_menu = -1;
 108         e_vbox_play = 0;
 109         vbox_index_read(e_vbox_play);
 110         PDEBUG(DEBUG_EPOINT, "EPOINT(%d) number of calls: %d\n", ea_endpoint->ep_serial, e_vbox_index_num);
 111
 112         if (e_vbox_index_num == 0) {
 113                 e_vbox_state = VBOX_STATE_NOTHING;
 114                 SCPY(e_vbox_display, (char *)((language)?"keine Anrufe":"no calls"));
 115                 e_vbox_display_refresh = 1;
 116                 set_tone_vbox("nothing");
 117         }
 118 }
 119
 120 /*
 121  * read index list, and fill the index variables with the given position
 122  * if the index is empty (or doesn't exist), the variables are not filled.
 123  * but alway the e_vbox_index_num is given.
 124  */
 125 void EndpointAppPBX::vbox_index_read(int num)
 126 {
 127         FILE *fp;
 128         char filename[256];
 129         char buffer[256];
 130         char name[sizeof(buffer)];
 131         char callerid[sizeof(buffer)];
 132         int year, mon, mday, hour, min;
 133         int i;
 134
 135         e_vbox_index_num = 0;
 136
 137         SPRINT(filename, "%s/%s/vbox/index", EXTENSION_DATA, e_vbox);
 138         if (!(fp = fopen(filename, "r"))) {
 139                 PDEBUG(DEBUG_EPOINT, "EPOINT(%d) no files in index\n", ea_endpoint->ep_serial);
 140                 return;
 141         }
 142         fduse++;
 143
 144         i = 0;
 145         while((GETLINE(buffer, fp))) {
 146                 name[0] = callerid[0] = '\0';
 147                 mon = mday = hour = min = 0;
 148                 sscanf(buffer, "%s %d %d %d %d %d %s", name, &year, &mon, &mday, &hour, &min, callerid);
 149
 150                 if (name[0]=='\0' || name[0]=='#')
 151                         continue;
 152
 153                 /* the selected entry */
 154                 if (i == num) {
 155                         SCPY(e_vbox_index_file, name);
 156                         e_vbox_index_year = year;
 157                         e_vbox_index_mon = mon;
 158                         e_vbox_index_mday = mday;
 159                         e_vbox_index_hour = hour;
 160                         e_vbox_index_min = min;
 161                         SCPY(e_vbox_index_callerid, callerid);
 162                         PDEBUG(DEBUG_EPOINT, "EPOINT(%d) read entry #%d: '%s', %02d:%02d %02d:%02d cid='%s'\n", ea_endpoint->ep_serial, i, name, mon+1, mday, hour, min, callerid);
 163                 }
 164
 165                 i++;
 166         }
 167
 168         e_vbox_index_num = i;
 169
 170         fclose(fp);
 171         fduse--;
 172 }
 173
 174
 175 /*
 176  * removes given index from list
 177  * after removing, the list should be reread, since e_vbox_index_num
 178  * and the current variabled do not change
 179  */
 180 void EndpointAppPBX::vbox_index_remove(int num)
 181 {
 182         FILE *fpr, *fpw;
 183         char buffer[256];
 184         int i;
 185         char filename1[256], filename2[256];
 186
 187         PDEBUG(DEBUG_EPOINT, "EPOINT(%d) removing entrie #%d\n", ea_endpoint->ep_serial, num);
 188
 189         SPRINT(filename1, "%s/%s/vbox/index", EXTENSION_DATA, e_vbox);
 190         SPRINT(filename2, "%s/%s/vbox/index-temp", EXTENSION_DATA, e_vbox);
 191         if (!(fpr = fopen(filename1, "r"))) {
 192                 return;
 193         }
 194         if (!(fpw = fopen(filename2, "w"))) {
 195                 fclose(fpr);
 196                 return;
 197         }
 198         fduse += 2;
 199
 200         i = 0;
 201         while((fgets(buffer,sizeof(buffer),fpr))) {
 202                 buffer[sizeof(buffer)-1] = '\0';
 203                 if (buffer[0]) buffer[strlen(buffer)-1] = '\0';
 204
 205                 if (buffer[0]=='\0' || buffer[0]=='#') {
 206                         fprintf(fpw, "%s\n", buffer);
 207                         continue;
 208                 }
 209
 210                 /* the selected entry will not be written */
 211                 if (i != num) {
 212                         fprintf(fpw, "%s\n", buffer);
 213                 }
 214
 215                 i++;
 216         }
 217
 218         fclose(fpr);
 219         fclose(fpw);
 220         fduse -= 2;
 221
 222         rename(filename2, filename1);
 223 }
 224
 225
 226 /*
 227  * process dialing of vbox_play (actually the menu)
 228  * it is depended by the state, which action is performed
 229  */
 230 void EndpointAppPBX::action_dialing_vbox_play(void)
 231 {
 232         int language = e_ext.vbox_language;
 233         struct port_list *portlist;
 234         class Port *port;
 235
 236         portlist = ea_endpoint->ep_portlist;
 237
 238         if (e_extdialing[0] == '\0') {
 239                 PDEBUG(DEBUG_EPOINT, "EPOINT(%d) called with no digit\n", ea_endpoint->ep_serial);
 240                 return;
 241         }
 242
 243         PDEBUG(DEBUG_EPOINT, "EPOINT(%d) dialing digit: %c\n", ea_endpoint->ep_serial, e_extdialing[0]);
 244
 245         e_vbox_display_refresh = 1;
 246
 247         if (e_vbox_state == VBOX_STATE_RECORD_RECORD) {
 248                 if (e_extdialing[0] == '1' || e_extdialing[0] == '0') {
 249                         PDEBUG(DEBUG_EPOINT, "EPOINT(%d) stopping recording of announcement.\n", ea_endpoint->ep_serial);
 250
 251                         port = find_port_id(portlist->port_id);
 252                         if (port)
 253                                 port->close_record((e_extdialing[0]=='1')?6000:0, 2000); /* append beep */
 254                         goto record_ask;
 255                 }
 256                 goto done;
 257         }
 258
 259         if (e_vbox_state == VBOX_STATE_RECORD_PLAY) {
 260                 if (e_extdialing[0] == '1') {
 261                         PDEBUG(DEBUG_EPOINT, "EPOINT(%d) stopping playback of announcement.\n", ea_endpoint->ep_serial);
 262
 263                         goto record_ask;
 264                 }
 265                 goto done;
 266         }
 267
 268         if (e_vbox_state == VBOX_STATE_RECORD_ASK) {
 269                 switch(e_extdialing[0]) {
 270                         case '3':
 271                         PDEBUG(DEBUG_EPOINT, "EPOINT(%d) quit recoding menu.\n", ea_endpoint->ep_serial);
 272                         ask_abort:
 273                         /* abort */
 274                         e_vbox_state = VBOX_STATE_MENU;
 275                         SCPY(e_vbox_display, (char *)((language)?"druecke 2 f. wiedergabe":"press 2 to play"));
 276                         set_tone_vbox("menu");
 277                         break;
 278
 279                         case '2':
 280                         PDEBUG(DEBUG_EPOINT, "EPOINT(%d) play recoding.\n", ea_endpoint->ep_serial);
 281                         /* play announcement */
 282                         e_vbox_counter = 0;
 283                         e_vbox_counter_last = 0;
 284                         e_vbox_counter_max = 0;
 285                         e_vbox_speed = 1;
 286                         e_vbox_state = VBOX_STATE_RECORD_PLAY;
 287                         if (e_ext.vbox_language)
 288                                 SCPY(e_vbox_display, "Wied., 1=stop %s");
 289                         else
 290                                 SCPY(e_vbox_display, "play, 1=stop %s");
 291                         if (e_ext.vbox_display == VBOX_DISPLAY_BRIEF)
 292                                 SCPY(e_vbox_display, "1=stop %s");
 293                         set_play_vbox("announcement", 0);
 294                         break;
 295
 296                         case '1':
 297                         PDEBUG(DEBUG_EPOINT, "EPOINT(%d) record announcement.\n", ea_endpoint->ep_serial);
 298                         /* close recording if already recording */
 299                         port = find_port_id(portlist->port_id);
 300                         if (port) {
 301                                 port->close_record(0,0);
 302                                 port->open_record(CODEC_MONO, 1, 4000, e_ext.number, 0, "", 0); /* record announcement, skip the first 4000 samples */
 303                         }
 304                         e_vbox_state = VBOX_STATE_RECORD_RECORD;
 305                         if (e_ext.vbox_language)
 306                                 SCPY(e_vbox_display, "Aufnahme, 1=stop");
 307                         else
 308                                 SCPY(e_vbox_display, "recording, 1=stop");
 309                         set_tone_vbox(NULL);
 310                         break;
 311
 312                         default:
 313                         ;
 314                 }
 315                 goto done;
 316         }
 317
 318         if (e_vbox_state==VBOX_STATE_STORE_ASK || e_vbox_state==VBOX_STATE_DELETE_ASK) {
 319                 char filename[256], filename2[256];
 320
 321                 switch(e_extdialing[0]) {
 322                         case '3':
 323                         PDEBUG(DEBUG_EPOINT, "EPOINT(%d) quit store/delete menu.\n", ea_endpoint->ep_serial);
 324                         goto ask_abort;
 325
 326                         case '1':
 327                         PDEBUG(DEBUG_EPOINT, "EPOINT(%d) do store/delete.\n", ea_endpoint->ep_serial);
 328                         SPRINT(filename, "%s/%s/vbox/%s", EXTENSION_DATA, e_vbox, e_vbox_index_file);
 329
 330                         /* move file */
 331                         if (e_vbox_state == VBOX_STATE_STORE_ASK) {
 332                                 SPRINT(filename, "%s/%s/recordings", EXTENSION_DATA, e_vbox);
 333                                 if (mkdir(filename, 0755) < 0) {
 334                                         if (errno != EEXIST) {
 335                                                 PERROR("EPOINT(%d) cannot create directory '%s'\n", ea_endpoint->ep_serial, filename);
 336                                                 goto done;
 337                                         }
 338                                 }
 339                                 SPRINT(filename2, "%s/%s/recordings/%s", EXTENSION_DATA, e_vbox, e_vbox_index_file);
 340                                 rename(filename, filename2);
 341                                 e_vbox_state = VBOX_STATE_STORE_DONE;
 342                                 if (e_ext.vbox_language)
 343                                         SCPY(e_vbox_display, "Nachricht gespeichert!");
 344                                 else
 345                                         SCPY(e_vbox_display, "Message stored!");
 346                                 set_tone_vbox("store_done");
 347                         }
 348
 349                         /* remove file */
 350                         if (e_vbox_state == VBOX_STATE_DELETE_ASK) {
 351                                 remove(filename);
 352                                 e_vbox_state = VBOX_STATE_DELETE_DONE;
 353                                 if (e_ext.vbox_language)
 354                                         SCPY(e_vbox_display, "Nachricht geloescht!");
 355                                 else
 356                                         SCPY(e_vbox_display, "Message deleted!");
 357                                 set_tone_vbox("delete_done");
 358                         }
 359
 360                         /* remove from list */
 361                         vbox_index_remove(e_vbox_play);
 362                         vbox_index_read(e_vbox_play);
 363                         /* stay at the last message+1, so we always get "no messages" */
 364                         if (e_vbox_play>e_vbox_index_num && e_vbox_play) {
 365                                 e_vbox_play = e_vbox_index_num-1;
 366                         }
 367                         default:
 368                         ;
 369                 }
 370                 goto done;
 371         }
 372
 373         /* dialing during menu */
 374         switch(e_extdialing[0]) {
 375                 /* process the vbox functions */
 376                 case '1': /* previous */
 377                 PDEBUG(DEBUG_EPOINT, "EPOINT(%d) previous call is selected.\n", ea_endpoint->ep_serial);
 378                 if (e_vbox_index_num == 0) { /* nothing to play */
 379                         no_calls:
 380                         e_vbox_state = VBOX_STATE_MENU;
 381                         SCPY(e_vbox_display, (char *)((language)?"keine Anrufe":"no calls"));
 382                         set_tone_vbox("nothing");
 383                         break;
 384                 }
 385                 e_vbox_play--;
 386                 if (e_vbox_play < 0) {
 387                         e_vbox_play = 0;
 388
 389                         e_vbox_state = VBOX_STATE_MENU;
 390                         SCPY(e_vbox_display, (char *)((language)?"kein vorheriger Anruf":"no previous call"));
 391                         set_tone_vbox("nothing");
 392                         break;
 393                 }
 394                 /* announce call */
 395                 announce_call:
 396                 e_vbox_state = VBOX_STATE_CALLINFO_INTRO;
 397                 SPRINT(e_vbox_display, "#%d", e_vbox_play+1);
 398                 vbox_index_read(e_vbox_play);
 399                 if (e_vbox_index_mon!=now_tm->tm_mon || e_vbox_index_year!=now_tm->tm_year) {
 400                         UPRINT(strchr(e_vbox_display,'\0'), " %s", (language)?months_german[e_vbox_index_mon]:months_english[e_vbox_index_mon]);
 401                 }
 402                 if (e_vbox_index_mday!=now_tm->tm_mday || e_vbox_index_mon!=now_tm->tm_mon || e_vbox_index_year!=now_tm->tm_year) {
 403                         UPRINT(strchr(e_vbox_display,'\0'), " %d", e_vbox_index_mday);
 404                 }
 405                 UPRINT(strchr(e_vbox_display,'\0'), " %02d:%02d", e_vbox_index_hour, e_vbox_index_min);
 406                 if (e_ext.vbox_display == VBOX_DISPLAY_DETAILED)
 407                         UPRINT(strchr(e_vbox_display,'\0'), " (%s)", e_vbox_index_callerid);
 408                 set_tone_vbox("intro");
 409                 break;
 410
 411                 case '2': /* play */
 412                 if (e_vbox_play >= e_vbox_index_num)
 413                         goto no_messages;
 414                 if (e_vbox_index_num == 0) { /* nothing to play */
 415                         goto no_calls;
 416                 }
 417                 PDEBUG(DEBUG_EPOINT, "EPOINT(%d) play call #%d.\n", ea_endpoint->ep_serial, e_vbox_play+1);
 418                 if (e_vbox_state>VBOX_STATE_CALLINFO_BEGIN && e_vbox_state<VBOX_STATE_CALLINFO_END) {
 419                         PDEBUG(DEBUG_EPOINT, "EPOINT(%d) play call #%d. abborting announcement and starting with playback\n", ea_endpoint->ep_serial, e_vbox_play+1);
 420                         /* the callinfo is played, so we start with the call */
 421                         e_vbox_counter = 0;
 422                         e_vbox_counter_last = 0;
 423                         e_vbox_counter_max = 0;
 424                         e_vbox_speed = 1;
 425                         e_vbox_state = VBOX_STATE_PLAY;
 426                         SPRINT(e_vbox_display, "#%d %%s", e_vbox_play+1);
 427                         if (e_ext.vbox_display == VBOX_DISPLAY_DETAILED)
 428                                 UPRINT(strchr(e_vbox_display,'\0'), " (%s)", e_vbox_index_callerid);
 429                         set_play_vbox(e_vbox_index_file, 0);
 430                         break;
 431                 } else
 432                 if (e_vbox_state==VBOX_STATE_PLAY && e_vbox_speed!=1) {
 433                         PDEBUG(DEBUG_EPOINT, "EPOINT(%d) play call #%d. play speed is different from 1, so we play now with normal speed\n", ea_endpoint->ep_serial, e_vbox_play+1);
 434                         /* we set play speed to normal */
 435                         e_vbox_speed = 1;
 436                         set_play_speed(e_vbox_speed);
 437                 } else
 438                 if (e_vbox_state == VBOX_STATE_PLAY) {
 439                         PDEBUG(DEBUG_EPOINT, "EPOINT(%d) play call #%d. play speed is equals 1, so we pause\n", ea_endpoint->ep_serial, e_vbox_play+1);
 440                         /* we pause the current play */
 441                         e_vbox_state = VBOX_STATE_PAUSE;
 442                         SCPY(e_vbox_display, (char *)((language)?"druecke 2 f. wiedergabe":"press 2 to play"));
 443                         set_tone_vbox("pause");
 444                 } else
 445                 if (e_vbox_state == VBOX_STATE_PAUSE) {
 446                         PDEBUG(DEBUG_EPOINT, "EPOINT(%d) play call #%d. currently pause, so we continue play\n", ea_endpoint->ep_serial, e_vbox_play+1);
 447                         /* we continue the current play */
 448                         e_vbox_state = VBOX_STATE_PLAY;
 449                         SPRINT(e_vbox_display, "#%d %%s", e_vbox_play+1);
 450                         if (e_ext.vbox_display == VBOX_DISPLAY_DETAILED)
 451                                 UPRINT(strchr(e_vbox_display,'\0'), " (%s)", e_vbox_index_callerid);
 452                         set_play_vbox(e_vbox_index_file, e_vbox_counter);
 453                 } else {
 454                         /* now we have something else going on, so we announce the call */
 455                         PDEBUG(DEBUG_EPOINT, "EPOINT(%d) play call #%d. announcing call during any other state\n", ea_endpoint->ep_serial, e_vbox_play+1);
 456                         goto announce_call;
 457                 }
 458                 break;
 459
 460                 case '3': /* next */
 461                 PDEBUG(DEBUG_EPOINT, "EPOINT(%d) next call is selected.\n", ea_endpoint->ep_serial);
 462                 if (e_vbox_index_num == 0) { /* nothing to play */
 463                         goto no_calls;
 464                 }
 465                 e_vbox_play++;
 466                 if (e_vbox_play >= e_vbox_index_num) {
 467                         no_messages:
 468                         e_vbox_play = e_vbox_index_num;
 469
 470                         e_vbox_state = VBOX_STATE_MENU;
 471                         SCPY(e_vbox_display, (char *)((language)?"kein weiterer Anruf":"no next call"));
 472                         set_tone_vbox("nothing");
 473                         break;
 474                 }
 475                 /* announce call */
 476                 goto announce_call;
 477                 break;
 478
 479                 case '4': /* rewind */
 480                 if (e_vbox_state==VBOX_STATE_PLAY) {
 481                         if (e_vbox_speed >= -1)
 482                                 e_vbox_speed = -1;
 483                         e_vbox_speed = e_vbox_speed * 2;
 484                         set_play_speed(e_vbox_speed);
 485                         PDEBUG(DEBUG_EPOINT, "EPOINT(%d) rewind speed has been changed to: %d\n", ea_endpoint->ep_serial, e_vbox_speed);
 486                 }
 487                 break;
 488
 489                 case '5': /* stop */
 490                 PDEBUG(DEBUG_EPOINT, "EPOINT(%d) stop is pressed, so we hear the menu\n", ea_endpoint->ep_serial);
 491                 e_vbox_state = VBOX_STATE_MENU;
 492                 SCPY(e_vbox_display, (char *)((language)?"druecke 2 f. wiedergabe":"press 2 to play"));
 493                 set_tone_vbox("menu");
 494                 break;
 495
 496                 case '6': /* wind */
 497                 if (e_vbox_state==VBOX_STATE_PLAY) {
 498                         if (e_vbox_speed <= 1)
 499                                 e_vbox_speed = 1;
 500                         e_vbox_speed = e_vbox_speed * 2;
 501                         set_play_speed(e_vbox_speed);
 502                         PDEBUG(DEBUG_EPOINT, "EPOINT(%d) wind speed has been changed to: %d\n", ea_endpoint->ep_serial, e_vbox_speed);
 503                 }
 504                 break;
 505
 506                 case '7': /* record announcement */
 507                 PDEBUG(DEBUG_EPOINT, "EPOINT(%d) entering the record announcement menu\n", ea_endpoint->ep_serial);
 508                 record_ask:
 509                 e_vbox_state = VBOX_STATE_RECORD_ASK;
 510                 SCPY(e_vbox_display, (char *)((language)?"1=Aufn. 2=Wied. 3=nein":"1=record 2=play 3=back"));
 511                 set_tone_vbox("record_ask");
 512                 break;
 513
 514                 case '8': /* store file */
 515                 PDEBUG(DEBUG_EPOINT, "EPOINT(%d) entering the store menu\n", ea_endpoint->ep_serial);
 516                 if (e_vbox_play >= e_vbox_index_num)
 517                         goto no_messages;
 518                 if (e_vbox_index_num == 0) { /* nothing to play */
 519                         goto no_calls;
 520                 }
 521                 e_vbox_state = VBOX_STATE_STORE_ASK;
 522                 SCPY(e_vbox_display, (char *)((language)?"speichern 1=ja 3=nein":"store 1=yes 3=back"));
 523                 set_tone_vbox("store_ask");
 524                 break;
 525
 526                 case '9': /* delete file */
 527                 PDEBUG(DEBUG_EPOINT, "EPOINT(%d) entering the delete menu\n", ea_endpoint->ep_serial);
 528                 if (e_vbox_play >= e_vbox_index_num)
 529                         goto no_messages;
 530                 if (e_vbox_index_num == 0) { /* nothing to play */
 531                         goto no_calls;
 532                 }
 533                 e_vbox_state = VBOX_STATE_DELETE_ASK;
 534                 SCPY(e_vbox_display, (char *)((language)?"loeschen 1=ja 3=nein":"delete 1=yes 3=back"));
 535                 set_tone_vbox("delete_ask");
 536                 break;
 537
 538
 539                 /* process the menu */
 540                 case '#':
 541                 if (e_vbox_menu < 0)
 542                         e_vbox_menu = 0;
 543                 else
 544                         e_vbox_menu++;
 545                 if (vbox_menu[e_vbox_menu].english == NULL)
 546                         e_vbox_menu = 0;
 547                 /* show menu */
 548                 show_menu:
 549                 SPRINT(e_vbox_display, "%c: %s", vbox_menu[e_vbox_menu].digit, (language)?vbox_menu[e_vbox_menu].german:vbox_menu[e_vbox_menu].english);
 550                 break;
 551
 552                 case '0':
 553                 if (e_vbox_menu < 0) { /* only if menu selection is pressed before*/
 554                         /* call if phonenumber is given */
 555                         if (e_vbox_index_num)
 556                         if (e_vbox_index_callerid[0]!='\0' && !!strcmp(e_vbox_index_callerid,"anonymous") && !!strcmp(e_vbox_index_callerid,"unknown")) {
 557                                 set_tone(portlist, "dialing");
 558                                 SPRINT(e_dialinginfo.id, "extern:%s", e_vbox_index_callerid);
 559                                 e_extdialing = e_dialinginfo.id;
 560                                 e_action = NULL;
 561                                 process_dialing();
 562                                 return;
 563                         }
 564                         break;
 565                 }
 566                 e_extdialing[0] = vbox_menu[e_vbox_menu].digit;
 567                 e_extdialing[1] = '\0';
 568                 e_vbox_menu = -1;
 569                 PDEBUG(DEBUG_EPOINT, "EPOINT(%d) executing selected menu:%d\n", e_extdialing[0]);
 570                 action_dialing_vbox_play(); /* redo this method using the digit */
 571                 return;
 572
 573                 case '*':
 574                 if (e_vbox_menu < 0)
 575                         e_vbox_menu = 0;
 576                 else
 577                         e_vbox_menu--;
 578                 if (e_vbox_menu < 0)
 579                         while(vbox_menu[e_vbox_menu+1].english) /* jump to the end */
 580                                 e_vbox_menu++;
 581                 /* show menu */
 582                 goto show_menu;
 583                 break;
 584
 585                 default:
 586                 PDEBUG(DEBUG_EPOINT, "EPOINT(%d) unsupported digit '%c'\n", ea_endpoint->ep_serial, e_extdialing);
 587         }
 588
 589         done:
 590         /* reset menu after dialing a function */
 591         if (e_extdialing[0]!='*' && e_extdialing[0]!='#')
 592                 e_vbox_menu = -1;
 593
 594
 595         e_extdialing[0] = '\0';
 596
 597 }
 598
 599
 600 /*
 601  * this handler is called by Epoint::handler(), whenever the action is NUMB_ACTION_VBOX_PLAY
 602  */
 603 void EndpointAppPBX::vbox_handler(void)
 604 {
 605         /* refresh if counter changes */
 606         if (e_vbox_state==VBOX_STATE_PLAY || e_vbox_state==VBOX_STATE_RECORD_PLAY)
 607         if (e_vbox_counter != e_vbox_counter_last) {
 608                 e_vbox_counter_last = e_vbox_counter;
 609                 e_vbox_display_refresh = 1;
 610         }
 611
 612         /* refresh display, if required (include counter) */
 613         if (e_vbox_display_refresh && e_ext.vbox_display!=VBOX_DISPLAY_OFF) {
 614                 char counter[32];
 615                 struct lcr_msg *message;
 616
 617                 SPRINT(counter, "%02d:%02d", e_vbox_counter/60, e_vbox_counter%60);
 618                 if (e_vbox_counter_max)
 619                         UPRINT(strchr(counter,'\0'), " of %02d:%02d", e_vbox_counter_max/60, e_vbox_counter_max%60);
 620
 621                 e_vbox_display_refresh = 0;
 622                 message = message_create(ea_endpoint->ep_serial, ea_endpoint->ep_portlist->port_id, EPOINT_TO_PORT, MESSAGE_NOTIFY);
 623                 SPRINT(message->param.notifyinfo.display, e_vbox_display, counter);
 624                 PDEBUG(DEBUG_EPOINT, "EPOINT(%d) terminal %s pending display:%s\n", ea_endpoint->ep_serial, e_ext.number, message->param.notifyinfo.display);
 625                 message_put(message);
 626                 logmessage(message->type, &message->param, ea_endpoint->ep_portlist->port_id, DIRECTION_OUT);
 627         }
 628 }
 629
 630
 631 /*
 632  * the audio file has ended
 633  * this is called by Endpoint::message_port(), whenever an audio of has been received
 634  */
 635 void EndpointAppPBX::vbox_message_eof(void)
 636 {
 637         char buffer[32];
 638         int language = e_ext.vbox_language;
 639
 640         PDEBUG(DEBUG_EPOINT, "EPOINT(%d) terminal %s end of file during state: %d\n", ea_endpoint->ep_serial, e_ext.number, e_vbox_state);
 641
 642         switch(e_vbox_state) {
 643                 case VBOX_STATE_MENU:
 644                 case VBOX_STATE_NOTHING:
 645                 e_vbox_state = VBOX_STATE_MENU;
 646                 SCPY(e_vbox_display, (char *)((language)?"druecke 2 f. wiedergabe":"press 2 to play"));
 647                 e_vbox_display_refresh = 1;
 648                 set_tone_vbox("menu");
 649                 break;
 650
 651                 case VBOX_STATE_PLAY:
 652                 if (e_vbox_speed > 0) {
 653                         e_vbox_state = VBOX_STATE_MENU;
 654                         SCPY(e_vbox_display, (char *)((language)?"druecke 3 f. Naechste":"press 3 for next"));
 655                         e_vbox_display_refresh = 1;
 656                         set_tone_vbox("menu");
 657                 } else {
 658                         /* if we have endoffile because we were playing backwards, we continue to play forward */
 659                         e_vbox_speed = 1;
 660                         e_vbox_counter = 1;
 661                         set_play_vbox(e_vbox_index_file, e_vbox_counter);
 662                 }
 663                 break;
 664
 665                 case VBOX_STATE_PAUSE:
 666                 SCPY(e_vbox_display, (char *)((language)?"druecke 2 f. weiterspielen":"press 2 to continue"));
 667                 e_vbox_display_refresh = 1;
 668                 break;
 669
 670                 case VBOX_STATE_CALLINFO_INTRO:
 671                 if (e_vbox_index_mday==now_tm->tm_mday && e_vbox_index_mon==now_tm->tm_mon && e_vbox_index_year==now_tm->tm_year)
 672                         goto skip_day_month;
 673                 e_vbox_state = VBOX_STATE_CALLINFO_MONTH; //german day
 674                 if (e_ext.vbox_language)
 675                         /* german starts with day */
 676                         SPRINT(buffer, "day_%02d", e_vbox_index_mday);
 677                 else
 678                         /* english starts with month */
 679                         SPRINT(buffer, "month_%02d", e_vbox_index_mon+1);
 680                 set_tone_vbox(buffer);
 681                 break;
 682
 683                 case VBOX_STATE_CALLINFO_MONTH:
 684                 e_vbox_state = VBOX_STATE_CALLINFO_DAY; //german month
 685                 if (e_ext.vbox_language) {
 686                         /* done with month, so we send the month*/
 687                         SPRINT(buffer, "month_%02d", e_vbox_index_mon+1);
 688                 } else {
 689                         /* done with day, so we send the day */
 690                         SPRINT(buffer, "day_%02d", e_vbox_index_mday);
 691                 }
 692                 set_tone_vbox(buffer);
 693                 break;
 694
 695                 case VBOX_STATE_CALLINFO_DAY: //german month
 696                 skip_day_month:
 697                 e_vbox_state = VBOX_STATE_CALLINFO_HOUR;
 698                 if (e_ext.vbox_language) {
 699                         if (e_vbox_index_hour == 1)
 700                                 SCPY(buffer, "number_ein");
 701                         else
 702                                 SPRINT(buffer, "number_%02d", e_vbox_index_hour); /* 1-23 hours */
 703                 } else {
 704                         SPRINT(buffer, "number_%02d", ((e_vbox_index_hour+11)%12)+1); /* 12 hours am/pm */
 705                 }
 706                 set_tone_vbox(buffer);
 707                 break;
 708
 709                 case VBOX_STATE_CALLINFO_HOUR:
 710                 e_vbox_state = VBOX_STATE_CALLINFO_OCLOCK;
 711                 if (e_ext.vbox_language) {
 712                         set_tone_vbox("oclock");
 713                 } else {
 714                         if (e_vbox_index_hour >= 12)
 715                                 set_tone_vbox("oclock_pm");
 716                         else
 717                                 set_tone_vbox("oclock_am");
 718                 }
 719                 break;
 720
 721                 case VBOX_STATE_CALLINFO_OCLOCK:
 722                 e_vbox_state = VBOX_STATE_CALLINFO_MIN;
 723                 if (e_ext.vbox_language) {
 724 // german says "zwölfuhr und eins"
 725 //                      if (e_vbox_index_min == 1)
 726 //                              SCPY(buffer, "number_eine");
 727 //                      else
 728                                 SPRINT(buffer, "number_%02d", e_vbox_index_min); /* 1-59 minutes */
 729                 } else {
 730                         SPRINT(buffer, "number_%02d", e_vbox_index_min);
 731                 }
 732                 set_tone_vbox(buffer);
 733                 break;
 734
 735                 case VBOX_STATE_CALLINFO_MIN:
 736                 if (e_ext.vbox_language)
 737                         goto start_digits;
 738                 e_vbox_state = VBOX_STATE_CALLINFO_MINUTES;
 739                 if (e_vbox_index_mday == 1)
 740                         set_tone_vbox("minute");
 741                 else
 742                         set_tone_vbox("minutes");
 743                 break;
 744
 745                 case VBOX_STATE_CALLINFO_MINUTES:
 746                 start_digits:
 747                 e_vbox_state = VBOX_STATE_CALLINFO_DIGIT;
 748                 if (e_vbox_index_callerid[0]=='\0' || !strcmp(e_vbox_index_callerid,"anonymous") || !strcmp(e_vbox_index_callerid,"unknown")) {
 749                         set_tone_vbox("call_anonymous");
 750                         e_vbox_index_callerid_index = strlen(e_vbox_index_callerid);
 751                 } else {
 752                         set_tone_vbox("call_from");
 753                         e_vbox_index_callerid_index = 0;
 754                 }
 755                 break;
 756
 757                 case VBOX_STATE_CALLINFO_DIGIT:
 758                 while (e_vbox_index_callerid[e_vbox_index_callerid_index] && (e_vbox_index_callerid[e_vbox_index_callerid_index]<'0' || e_vbox_index_callerid[e_vbox_index_callerid_index]>'9'))
 759                         e_vbox_index_callerid_index++;
 760                 if (e_vbox_index_callerid[e_vbox_index_callerid_index]) {
 761                         SPRINT(buffer, "number_%02d", e_vbox_index_callerid[e_vbox_index_callerid_index]-'0');
 762                         set_tone_vbox(buffer);
 763                         e_vbox_index_callerid_index ++;
 764                 } else {
 765                         /* the callinfo is played, so we start with the call */
 766                         e_vbox_counter = 0;
 767                         e_vbox_counter_last = 0;
 768                         e_vbox_counter_max = 0;
 769                         e_vbox_speed = 1;
 770                         e_vbox_state = VBOX_STATE_PLAY;
 771                         SPRINT(e_vbox_display, "#%d %%s", e_vbox_play);
 772                         if (e_ext.vbox_display == VBOX_DISPLAY_DETAILED)
 773                                 UPRINT(strchr(e_vbox_display,'\0'), " (%s)", e_vbox_index_callerid);
 774                         e_vbox_display_refresh = 1;
 775                         set_play_vbox(e_vbox_index_file, 0);
 776                 }
 777                 break;
 778
 779                 case VBOX_STATE_RECORD_ASK:
 780                 set_tone_vbox("record_ask");
 781                 e_vbox_display_refresh = 1;
 782                 break;
 783
 784                 case VBOX_STATE_STORE_ASK:
 785                 set_tone_vbox("store_ask");
 786                 e_vbox_display_refresh = 1;
 787                 break;
 788
 789                 case VBOX_STATE_DELETE_ASK:
 790                 set_tone_vbox("delete_ask");
 791                 e_vbox_display_refresh = 1;
 792                 break;
 793
 794                 case VBOX_STATE_RECORD_PLAY:
 795                 e_vbox_state = VBOX_STATE_RECORD_ASK;
 796                 SCPY(e_vbox_display, (char *)((language)?"1=Aufn. 2=Wied. 3=nein":"1=record 2=play 3=no"));
 797                 e_vbox_display_refresh = 1;
 798                 set_tone_vbox("record_ask");
 799                 break;
 800
 801                 case VBOX_STATE_STORE_DONE:
 802                 case VBOX_STATE_DELETE_DONE:
 803                 if (e_vbox_index_num == 0) { /* nothing to play */
 804                         e_vbox_state = VBOX_STATE_MENU;
 805                         SCPY(e_vbox_display, (char *)((language)?"keine Anrufe":"no calls"));
 806                         e_vbox_display_refresh = 1;
 807                         set_tone_vbox("nothing");
 808                 } else {
 809                         e_vbox_state = VBOX_STATE_MENU;
 810                         SCPY(e_vbox_display, (char *)((language)?"druecke 2 f. wiedergabe":"press 2 to play"));
 811                         e_vbox_display_refresh = 1;
 812                         set_tone_vbox("menu");
 813                 }
 814                 break;
 815
 816                 default:
 817                 PERROR("vbox_message_eof(ep%d): terminal %s unknown state: %d\n", ea_endpoint->ep_serial, e_ext.number, e_vbox_state);
 818         }
 819 }
 820
 821
 822
 823 /*
 824  * set the given vbox-tone with full path (without appending)
 825  * the tone is played and after eof, a message is received
 826  */
 827 void EndpointAppPBX::set_tone_vbox(const char *tone)
 828 {
 829         struct lcr_msg *message;
 830
 831         if (tone == NULL)
 832                 tone = "";
 833
 834         if (!ea_endpoint->ep_portlist) {
 835                 PERROR("EPOINT(%d) no portlist\n", ea_endpoint->ep_serial);
 836         }
 837         message = message_create(ea_endpoint->ep_serial, ea_endpoint->ep_portlist->port_id, EPOINT_TO_PORT, MESSAGE_VBOX_TONE);
 838         SCPY(message->param.tone.dir, ((e_ext.vbox_language) ? "vbox_german" : "vbox_english"));
 839         SCPY(message->param.tone.name, tone);
 840         message_put(message);
 841
 842         PDEBUG(DEBUG_EPOINT, "EPOINT(%d) terminal %s set tone '%s'\n", ea_endpoint->ep_serial, e_ext.number, tone);
 843 }
 844
 845
 846 /*
 847  * set the given recording file
 848  * the appendix is removed
 849  * the file is played and after eof, a message is received
 850  * the current counter value is also received by a message
 851  * set the offset in seconds of the current recording
 852  */
 853 void EndpointAppPBX::set_play_vbox(const char *file, int offset)
 854 {
 855         char filename[256];
 856         struct lcr_msg *message;
 857
 858         SPRINT(filename, "%s/%s/vbox/%s", EXTENSION_DATA, e_vbox, file);
 859
 860         /* remove .wav */
 861         if (!strcmp(filename+strlen(filename)-4, ".wav")) /* filename is always more than 4 digits long */
 862                 filename[strlen(filename)-4] = '\0';
 863         else // to not check twice
 864         /* remove .isdn */
 865         if (!strcmp(filename+strlen(filename)-5, ".isdn")) /* filename is always more than 5 digits long */
 866                 filename[strlen(filename)-5] = '\0';
 867
 868         if (!ea_endpoint->ep_portlist) {
 869                 PERROR("EPOINT(%d) no portlist\n", ea_endpoint->ep_serial);
 870         }
 871         message = message_create(ea_endpoint->ep_serial, ea_endpoint->ep_portlist->port_id, EPOINT_TO_PORT, MESSAGE_VBOX_PLAY);
 872         SCPY(message->param.play.file, filename);
 873         message->param.play.offset = offset;
 874         message_put(message);
 875
 876         PDEBUG(DEBUG_EPOINT, "EPOINT(%d) terminal %s set play '%s'\n", ea_endpoint->ep_serial, e_ext.number, filename);
 877 }
 878
 879
 880 /*
 881  * change speed of the recording file, the default is 1
 882  * negative values cause negative speed
 883  */
 884 void EndpointAppPBX::set_play_speed(int speed)
 885 {
 886         struct lcr_msg *message;
 887
 888         if (!ea_endpoint->ep_portlist) {
 889                 PERROR("EPOINT(%d) no portlist\n", ea_endpoint->ep_serial);
 890         }
 891         message = message_create(ea_endpoint->ep_serial, ea_endpoint->ep_portlist->port_id, EPOINT_TO_PORT, MESSAGE_VBOX_PLAY_SPEED);
 892         message->param.speed = speed;
 893         message_put(message);
 894
 895         PDEBUG(DEBUG_EPOINT, "EPOINT(%d) terminal %s set speed '%d'\n", ea_endpoint->ep_serial, e_ext.number, speed);
 896 }
 897
 898
 899