main/indications.c

   1 /*
   2  * Asterisk -- An open source telephony toolkit.
   3  *
   4  * Copyright (C) 2002, Pauline Middelink
   5  * Copyright (C) 2009, Digium, Inc.
   6  *
   7  * See http://www.asterisk.org for more information about
   8  * the Asterisk project. Please do not directly contact
   9  * any of the maintainers of this project for assistance;
  10  * the project provides a web site, mailing lists and IRC
  11  * channels for your use.
  12  *
  13  * This program is free software, distributed under the terms of
  14  * the GNU General Public License Version 2. See the LICENSE file
  15  * at the top of the source tree.
  16  */
  17
  18 /*!
  19  * \file
  20  * \brief Indication Tone Handling
  21  *
  22  * \author Pauline Middelink <middelink@polyware.nl>
  23  * \author Russell Bryant <russell@digium.com>
  24  */
  25
  26 /*** MODULEINFO
  27         <support_level>core</support_level>
  28  ***/
  29
  30 #include "asterisk.h"
  31
  32 ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
  33
  34 #include <math.h>
  35
  36 #include "asterisk/lock.h"
  37 #include "asterisk/linkedlists.h"
  38 #include "asterisk/indications.h"
  39 #include "asterisk/frame.h"
  40 #include "asterisk/channel.h"
  41 #include "asterisk/utils.h"
  42 #include "asterisk/cli.h"
  43 #include "asterisk/module.h"
  44 #include "asterisk/astobj2.h"
  45 #include "asterisk/data.h"
  46
  47 #include "asterisk/_private.h" /* _init(), _reload() */
  48
  49 #define DATA_EXPORT_TONE_ZONE(MEMBER)                                   \
  50         MEMBER(ast_tone_zone, country, AST_DATA_STRING)                 \
  51         MEMBER(ast_tone_zone, description, AST_DATA_STRING)             \
  52         MEMBER(ast_tone_zone, nrringcadence, AST_DATA_UNSIGNED_INTEGER)
  53
  54 AST_DATA_STRUCTURE(ast_tone_zone, DATA_EXPORT_TONE_ZONE);
  55
  56 #define DATA_EXPORT_TONE_ZONE_SOUND(MEMBER)                     \
  57         MEMBER(ast_tone_zone_sound, name, AST_DATA_STRING)      \
  58         MEMBER(ast_tone_zone_sound, data, AST_DATA_STRING)
  59
  60 AST_DATA_STRUCTURE(ast_tone_zone_sound, DATA_EXPORT_TONE_ZONE_SOUND);
  61
  62 /* Globals */
  63 static const char config[] = "indications.conf";
  64
  65 static const int midi_tohz[128] = {
  66         8,     8,     9,     9,     10,    10,    11,    12,    12,    13,
  67         14,    15,    16,    17,    18,    19,    20,    21,    23,    24,
  68         25,    27,    29,    30,    32,    34,    36,    38,    41,    43,
  69         46,    48,    51,    55,    58,    61,    65,    69,    73,    77,
  70         82,    87,    92,    97,    103,   110,   116,   123,   130,   138,
  71         146,   155,   164,   174,   184,   195,   207,   220,   233,   246,
  72         261,   277,   293,   311,   329,   349,   369,   391,   415,   440,
  73         466,   493,   523,   554,   587,   622,   659,   698,   739,   783,
  74         830,   880,   932,   987,   1046,  1108,  1174,  1244,  1318,  1396,
  75         1479,  1567,  1661,  1760,  1864,  1975,  2093,  2217,  2349,  2489,
  76         2637,  2793,  2959,  3135,  3322,  3520,  3729,  3951,  4186,  4434,
  77         4698,  4978,  5274,  5587,  5919,  6271,  6644,  7040,  7458,  7902,
  78         8372,  8869,  9397,  9956,  10548, 11175, 11839, 12543
  79 };
  80
  81 static struct ao2_container *ast_tone_zones;
  82
  83 #define NUM_TONE_ZONE_BUCKETS 53
  84
  85 /*!
  86  * \note Access to this is protected by locking the ast_tone_zones container
  87  */
  88 static struct ast_tone_zone *default_tone_zone;
  89
  90 struct playtones_item {
  91         int fac1;
  92         int init_v2_1;
  93         int init_v3_1;
  94         int fac2;
  95         int init_v2_2;
  96         int init_v3_2;
  97         int modulate;
  98         int duration;
  99 };
 100
 101 struct playtones_def {
 102         int vol;
 103         int reppos;
 104         int nitems;
 105         int interruptible;
 106         struct playtones_item *items;
 107 };
 108
 109 struct playtones_state {
 110         int vol;
 111         int v1_1;
 112         int v2_1;
 113         int v3_1;
 114         int v1_2;
 115         int v2_2;
 116         int v3_2;
 117         int reppos;
 118         int nitems;
 119         struct playtones_item *items;
 120         int npos;
 121         int oldnpos;
 122         int pos;
 123         struct ast_format origwfmt;
 124         struct ast_frame f;
 125         unsigned char offset[AST_FRIENDLY_OFFSET];
 126         short data[4000];
 127 };
 128
 129 static void playtones_release(struct ast_channel *chan, void *params)
 130 {
 131         struct playtones_state *ps = params;
 132
 133         if (chan) {
 134                 ast_set_write_format(chan, &ps->origwfmt);
 135         }
 136
 137         if (ps->items) {
 138                 ast_free(ps->items);
 139                 ps->items = NULL;
 140         }
 141
 142         ast_free(ps);
 143 }
 144
 145 static void *playtones_alloc(struct ast_channel *chan, void *params)
 146 {
 147         struct playtones_def *pd = params;
 148         struct playtones_state *ps = NULL;
 149
 150         if (!(ps = ast_calloc(1, sizeof(*ps)))) {
 151                 return NULL;
 152         }
 153
 154         ast_format_copy(&ps->origwfmt, ast_channel_writeformat(chan));
 155
 156         if (ast_set_write_format_by_id(chan, AST_FORMAT_SLINEAR)) {
 157                 ast_log(LOG_WARNING, "Unable to set '%s' to signed linear format (write)\n", ast_channel_name(chan));
 158                 playtones_release(NULL, ps);
 159                 ps = NULL;
 160         } else {
 161                 ps->vol = pd->vol;
 162                 ps->reppos = pd->reppos;
 163                 ps->nitems = pd->nitems;
 164                 ps->items = pd->items;
 165                 ps->oldnpos = -1;
 166         }
 167
 168         /* Let interrupts interrupt :) */
 169         if (pd->interruptible) {
 170                 ast_set_flag(ast_channel_flags(chan), AST_FLAG_WRITE_INT);
 171         } else {
 172                 ast_clear_flag(ast_channel_flags(chan), AST_FLAG_WRITE_INT);
 173         }
 174
 175         return ps;
 176 }
 177
 178 static int playtones_generator(struct ast_channel *chan, void *data, int len, int samples)
 179 {
 180         struct playtones_state *ps = data;
 181         struct playtones_item *pi;
 182         int x;
 183
 184         /* we need to prepare a frame with 16 * timelen samples as we're
 185          * generating SLIN audio */
 186
 187         len = samples * 2;
 188         if (len > sizeof(ps->data) / 2 - 1) {
 189                 ast_log(LOG_WARNING, "Can't generate that much data!\n");
 190                 return -1;
 191         }
 192
 193         memset(&ps->f, 0, sizeof(ps->f));
 194
 195         pi = &ps->items[ps->npos];
 196
 197         if (ps->oldnpos != ps->npos) {
 198                 /* Load new parameters */
 199                 ps->v1_1 = 0;
 200                 ps->v2_1 = pi->init_v2_1;
 201                 ps->v3_1 = pi->init_v3_1;
 202                 ps->v1_2 = 0;
 203                 ps->v2_2 = pi->init_v2_2;
 204                 ps->v3_2 = pi->init_v3_2;
 205                 ps->oldnpos = ps->npos;
 206         }
 207
 208         for (x = 0; x < samples; x++) {
 209                 ps->v1_1 = ps->v2_1;
 210                 ps->v2_1 = ps->v3_1;
 211                 ps->v3_1 = (pi->fac1 * ps->v2_1 >> 15) - ps->v1_1;
 212
 213                 ps->v1_2 = ps->v2_2;
 214                 ps->v2_2 = ps->v3_2;
 215                 ps->v3_2 = (pi->fac2 * ps->v2_2 >> 15) - ps->v1_2;
 216                 if (pi->modulate) {
 217                         int p;
 218                         p = ps->v3_2 - 32768;
 219                         if (p < 0) {
 220                                 p = -p;
 221                         }
 222                         p = ((p * 9) / 10) + 1;
 223                         ps->data[x] = (ps->v3_1 * p) >> 15;
 224                 } else {
 225                         ps->data[x] = ps->v3_1 + ps->v3_2;
 226                 }
 227         }
 228
 229         ps->f.frametype = AST_FRAME_VOICE;
 230         ast_format_set(&ps->f.subclass.format, AST_FORMAT_SLINEAR, 0);
 231         ps->f.datalen = len;
 232         ps->f.samples = samples;
 233         ps->f.offset = AST_FRIENDLY_OFFSET;
 234         ps->f.data.ptr = ps->data;
 235
 236         if (ast_write(chan, &ps->f)) {
 237                 return -1;
 238         }
 239
 240         ps->pos += x;
 241
 242         if (pi->duration && ps->pos >= pi->duration * 8) {      /* item finished? */
 243                 ps->pos = 0;                                    /* start new item */
 244                 ps->npos++;
 245                 if (ps->npos >= ps->nitems) {                   /* last item? */
 246                         if (ps->reppos == -1) {                 /* repeat set? */
 247                                 return -1;
 248                         }
 249                         ps->npos = ps->reppos;                  /* redo from top */
 250                 }
 251         }
 252
 253         return 0;
 254 }
 255
 256 static struct ast_generator playtones = {
 257         .alloc     = playtones_alloc,
 258         .release   = playtones_release,
 259         .generate  = playtones_generator,
 260 };
 261
 262 int ast_tone_zone_part_parse(const char *s, struct ast_tone_zone_part *tone_data)
 263 {
 264         if (sscanf(s, "%30u+%30u/%30u", &tone_data->freq1, &tone_data->freq2,
 265                         &tone_data->time) == 3) {
 266                 /* f1+f2/time format */
 267         } else if (sscanf(s, "%30u+%30u", &tone_data->freq1, &tone_data->freq2) == 2) {
 268                 /* f1+f2 format */
 269                 tone_data->time = 0;
 270         } else if (sscanf(s, "%30u*%30u/%30u", &tone_data->freq1, &tone_data->freq2,
 271                         &tone_data->time) == 3) {
 272                 /* f1*f2/time format */
 273                 tone_data->modulate = 1;
 274         } else if (sscanf(s, "%30u*%30u", &tone_data->freq1, &tone_data->freq2) == 2) {
 275                 /* f1*f2 format */
 276                 tone_data->time = 0;
 277                 tone_data->modulate = 1;
 278         } else if (sscanf(s, "%30u/%30u", &tone_data->freq1, &tone_data->time) == 2) {
 279                 /* f1/time format */
 280                 tone_data->freq2 = 0;
 281         } else if (sscanf(s, "%30u", &tone_data->freq1) == 1) {
 282                 /* f1 format */
 283                 tone_data->freq2 = 0;
 284                 tone_data->time = 0;
 285         } else if (sscanf(s, "M%30u+M%30u/%30u", &tone_data->freq1, &tone_data->freq2,
 286                         &tone_data->time) == 3) {
 287                 /* Mf1+Mf2/time format */
 288                 tone_data->midinote = 1;
 289         } else if (sscanf(s, "M%30u+M%30u", &tone_data->freq1, &tone_data->freq2) == 2) {
 290                 /* Mf1+Mf2 format */
 291                 tone_data->time = 0;
 292                 tone_data->midinote = 1;
 293         } else if (sscanf(s, "M%30u*M%30u/%30u", &tone_data->freq1, &tone_data->freq2,
 294                         &tone_data->time) == 3) {
 295                 /* Mf1*Mf2/time format */
 296                 tone_data->modulate = 1;
 297                 tone_data->midinote = 1;
 298         } else if (sscanf(s, "M%30u*M%30u", &tone_data->freq1, &tone_data->freq2) == 2) {
 299                 /* Mf1*Mf2 format */
 300                 tone_data->time = 0;
 301                 tone_data->modulate = 1;
 302                 tone_data->midinote = 1;
 303         } else if (sscanf(s, "M%30u/%30u", &tone_data->freq1, &tone_data->time) == 2) {
 304                 /* Mf1/time format */
 305                 tone_data->freq2 = -1;
 306                 tone_data->midinote = 1;
 307         } else if (sscanf(s, "M%30u", &tone_data->freq1) == 1) {
 308                 /* Mf1 format */
 309                 tone_data->freq2 = -1;
 310                 tone_data->time = 0;
 311                 tone_data->midinote = 1;
 312         } else {
 313                 return -1;
 314         }
 315
 316         return 0;
 317 }
 318
 319 int ast_playtones_start(struct ast_channel *chan, int vol, const char *playlst, int interruptible)
 320 {
 321         char *s, *data = ast_strdupa(playlst);
 322         struct playtones_def d = { vol, -1, 0, 1, NULL };
 323         char *stringp;
 324         char *separator;
 325         static const float sample_rate = 8000.0;
 326         static const float max_sample_val = 32768.0;
 327
 328         if (vol < 1) {
 329                 d.vol = 7219; /* Default to -8db */
 330         }
 331
 332         d.interruptible = interruptible;
 333
 334         stringp = data;
 335
 336         /* check if the data is separated with '|' or with ',' by default */
 337         if (strchr(stringp,'|')) {
 338                 separator = "|";
 339         } else {
 340                 separator = ",";
 341         }
 342
 343         while ((s = strsep(&stringp, separator)) && !ast_strlen_zero(s)) {
 344                 struct playtones_item *new_items;
 345                 struct ast_tone_zone_part tone_data = {
 346                         .time = 0,
 347                 };
 348
 349                 s = ast_strip(s);
 350                 if (s[0]=='!') {
 351                         s++;
 352                 } else if (d.reppos == -1) {
 353                         d.reppos = d.nitems;
 354                 }
 355
 356                 if (ast_tone_zone_part_parse(s, &tone_data)) {
 357                         ast_log(LOG_ERROR, "Failed to parse tone part '%s'\n", s);
 358                         continue;
 359                 }
 360
 361                 if (tone_data.midinote) {
 362                         /* midi notes must be between 0 and 127 */
 363
 364                         if (tone_data.freq1 >= 0 && tone_data.freq1 <= 127) {
 365                                 tone_data.freq1 = midi_tohz[tone_data.freq1];
 366                         } else {
 367                                 tone_data.freq1 = 0;
 368                         }
 369
 370                         if (tone_data.freq2 >= 0 && tone_data.freq2 <= 127) {
 371                                 tone_data.freq2 = midi_tohz[tone_data.freq2];
 372                         } else {
 373                                 tone_data.freq2 = 0;
 374                         }
 375                 }
 376
 377                 new_items = ast_realloc(d.items, (d.nitems + 1) * sizeof(*d.items));
 378                 if (!new_items) {
 379                         ast_free(d.items);
 380                         return -1;
 381                 }
 382                 d.items = new_items;
 383
 384                 d.items[d.nitems].fac1 = 2.0 * cos(2.0 * M_PI * (tone_data.freq1 / sample_rate)) * max_sample_val;
 385                 d.items[d.nitems].init_v2_1 = sin(-4.0 * M_PI * (tone_data.freq1 / sample_rate)) * d.vol;
 386                 d.items[d.nitems].init_v3_1 = sin(-2.0 * M_PI * (tone_data.freq1 / sample_rate)) * d.vol;
 387
 388                 d.items[d.nitems].fac2 = 2.0 * cos(2.0 * M_PI * (tone_data.freq2 / sample_rate)) * max_sample_val;
 389                 d.items[d.nitems].init_v2_2 = sin(-4.0 * M_PI * (tone_data.freq2 / sample_rate)) * d.vol;
 390                 d.items[d.nitems].init_v3_2 = sin(-2.0 * M_PI * (tone_data.freq2 / sample_rate)) * d.vol;
 391
 392                 d.items[d.nitems].duration = tone_data.time;
 393                 d.items[d.nitems].modulate = tone_data.modulate;
 394
 395                 d.nitems++;
 396         }
 397
 398         if (!d.nitems) {
 399                 ast_log(LOG_ERROR, "No valid tone parts\n");
 400                 return -1;
 401         }
 402
 403         if (ast_activate_generator(chan, &playtones, &d)) {
 404                 ast_free(d.items);
 405                 return -1;
 406         }
 407
 408         return 0;
 409 }
 410
 411 void ast_playtones_stop(struct ast_channel *chan)
 412 {
 413         ast_deactivate_generator(chan);
 414 }
 415
 416 int ast_tone_zone_count(void)
 417 {
 418         return ao2_container_count(ast_tone_zones);
 419 }
 420
 421 struct ao2_iterator ast_tone_zone_iterator_init(void)
 422 {
 423         return ao2_iterator_init(ast_tone_zones, 0);
 424 }
 425
 426 /*! \brief Set global indication country
 427    If no country is specified or we are unable to find the zone, then return not found */
 428 static int ast_set_indication_country(const char *country)
 429 {
 430         struct ast_tone_zone *zone = NULL;
 431
 432         if (ast_strlen_zero(country) || !(zone = ast_get_indication_zone(country))) {
 433                 return -1;
 434         }
 435
 436         ast_verb(3, "Setting default indication country to '%s'\n", country);
 437
 438         ao2_lock(ast_tone_zones);
 439         if (default_tone_zone) {
 440                 default_tone_zone = ast_tone_zone_unref(default_tone_zone);
 441         }
 442         default_tone_zone = ast_tone_zone_ref(zone);
 443         ao2_unlock(ast_tone_zones);
 444
 445         zone = ast_tone_zone_unref(zone);
 446
 447         return 0;
 448 }
 449
 450 /*! \brief locate ast_tone_zone, given the country. if country == NULL, use the default country */
 451 struct ast_tone_zone *ast_get_indication_zone(const char *country)
 452 {
 453         struct ast_tone_zone *tz = NULL;
 454         struct ast_tone_zone zone_arg = {
 455                 .nrringcadence = 0,
 456         };
 457
 458         if (ast_strlen_zero(country)) {
 459                 ao2_lock(ast_tone_zones);
 460                 if (default_tone_zone) {
 461                         tz = ast_tone_zone_ref(default_tone_zone);
 462                 }
 463                 ao2_unlock(ast_tone_zones);
 464
 465                 return tz;
 466         }
 467
 468         ast_copy_string(zone_arg.country, country, sizeof(zone_arg.country));
 469
 470         return ao2_find(ast_tone_zones, &zone_arg, OBJ_POINTER);
 471 }
 472
 473 struct ast_tone_zone_sound *ast_get_indication_tone(const struct ast_tone_zone *_zone, const char *indication)
 474 {
 475         struct ast_tone_zone_sound *ts = NULL;
 476         /* _zone is const to the users of the API */
 477         struct ast_tone_zone *zone = (struct ast_tone_zone *) _zone;
 478
 479         /* If no zone is specified, use the default */
 480         if (!zone) {
 481                 ao2_lock(ast_tone_zones);
 482                 if (default_tone_zone) {
 483                         zone = ast_tone_zone_ref(default_tone_zone);
 484                 }
 485                 ao2_unlock(ast_tone_zones);
 486
 487                 if (!zone) {
 488                         return NULL;
 489                 }
 490         }
 491
 492         ast_tone_zone_lock(zone);
 493
 494         /* Look through list of tones in the zone searching for the right one */
 495         AST_LIST_TRAVERSE(&zone->tones, ts, entry) {
 496                 if (!strcasecmp(ts->name, indication)) {
 497                         /* Increase ref count for the reference we will return */
 498                         ts = ast_tone_zone_sound_ref(ts);
 499                         break;
 500                 }
 501         }
 502
 503         ast_tone_zone_unlock(zone);
 504
 505         if (!_zone)
 506                 zone = ast_tone_zone_unref(zone);
 507
 508         return ts;
 509 }
 510
 511 static void ast_tone_zone_sound_destructor(void *obj)
 512 {
 513         struct ast_tone_zone_sound *ts = obj;
 514
 515         /* Deconstify the 'const char *'s so the compiler doesn't complain. (but it's safe) */
 516         if (ts->name) {
 517                 ast_free((char *) ts->name);
 518                 ts->name = NULL;
 519         }
 520
 521         if (ts->data) {
 522                 ast_free((char *) ts->data);
 523                 ts->data = NULL;
 524         }
 525 }
 526
 527 /*! \brief deallocate the passed tone zone */
 528 static void ast_tone_zone_destructor(void *obj)
 529 {
 530         struct ast_tone_zone *zone = obj;
 531         struct ast_tone_zone_sound *current;
 532
 533         while ((current = AST_LIST_REMOVE_HEAD(&zone->tones, entry))) {
 534                 current = ast_tone_zone_sound_unref(current);
 535         }
 536
 537         if (zone->ringcadence) {
 538                 ast_free(zone->ringcadence);
 539                 zone->ringcadence = NULL;
 540         }
 541 }
 542
 543 /*! \brief add a new country, if country exists, it will be replaced. */
 544 static int ast_register_indication_country(struct ast_tone_zone *zone)
 545 {
 546         ao2_lock(ast_tone_zones);
 547         if (!default_tone_zone) {
 548                 default_tone_zone = ast_tone_zone_ref(zone);
 549         }
 550         ao2_unlock(ast_tone_zones);
 551
 552         ao2_link(ast_tone_zones, zone);
 553
 554         ast_verb(3, "Registered indication country '%s'\n", zone->country);
 555
 556         return 0;
 557 }
 558
 559 /*! \brief remove an existing country and all its indications, country must exist. */
 560 static int ast_unregister_indication_country(const char *country)
 561 {
 562         struct ast_tone_zone *tz = NULL;
 563         struct ast_tone_zone zone_arg = {
 564                 .nrringcadence = 0,
 565         };
 566
 567         ast_copy_string(zone_arg.country, country, sizeof(zone_arg.country));
 568
 569         ao2_lock(ast_tone_zones);
 570         tz = ao2_find(ast_tone_zones, &zone_arg, OBJ_POINTER | OBJ_UNLINK);
 571         if (!tz) {
 572                 ao2_unlock(ast_tone_zones);
 573                 return -1;
 574         }
 575
 576         if (default_tone_zone == tz) {
 577                 ast_tone_zone_unref(default_tone_zone);
 578                 /* Get a new default, punt to the first one we find */
 579                 default_tone_zone = ao2_callback(ast_tone_zones, 0, NULL, NULL);
 580         }
 581         ao2_unlock(ast_tone_zones);
 582
 583         tz = ast_tone_zone_unref(tz);
 584
 585         return 0;
 586 }
 587
 588 /*!
 589  * \note called with the tone zone locked
 590  */
 591 static int ast_register_indication(struct ast_tone_zone *zone, const char *indication,
 592                 const char *tonelist)
 593 {
 594         struct ast_tone_zone_sound *ts;
 595
 596         if (ast_strlen_zero(indication) || ast_strlen_zero(tonelist)) {
 597                 return -1;
 598         }
 599
 600         AST_LIST_TRAVERSE_SAFE_BEGIN(&zone->tones, ts, entry) {
 601                 if (!strcasecmp(indication, ts->name)) {
 602                         AST_LIST_REMOVE_CURRENT(entry);
 603                         ts = ast_tone_zone_sound_unref(ts);
 604                         break;
 605                 }
 606         }
 607         AST_LIST_TRAVERSE_SAFE_END;
 608
 609         if (!(ts = ao2_alloc(sizeof(*ts), ast_tone_zone_sound_destructor))) {
 610                 return -1;
 611         }
 612
 613         if (!(ts->name = ast_strdup(indication)) || !(ts->data = ast_strdup(tonelist))) {
 614                 ts = ast_tone_zone_sound_unref(ts);
 615                 return -1;
 616         }
 617
 618         AST_LIST_INSERT_TAIL(&zone->tones, ts, entry); /* Inherit reference */
 619
 620         return 0;
 621 }
 622
 623 /*! \brief remove an existing country's indication. Both country and indication must exist */
 624 static int ast_unregister_indication(struct ast_tone_zone *zone, const char *indication)
 625 {
 626         struct ast_tone_zone_sound *ts;
 627         int res = -1;
 628
 629         ast_tone_zone_lock(zone);
 630
 631         AST_LIST_TRAVERSE_SAFE_BEGIN(&zone->tones, ts, entry) {
 632                 if (!strcasecmp(indication, ts->name)) {
 633                         AST_LIST_REMOVE_CURRENT(entry);
 634                         ts = ast_tone_zone_sound_unref(ts);
 635                         res = 0;
 636                         break;
 637                 }
 638         }
 639         AST_LIST_TRAVERSE_SAFE_END;
 640
 641         ast_tone_zone_unlock(zone);
 642
 643         return res;
 644 }
 645
 646 static struct ast_tone_zone *ast_tone_zone_alloc(void)
 647 {
 648         return ao2_alloc(sizeof(struct ast_tone_zone), ast_tone_zone_destructor);
 649 }
 650
 651 static char *complete_country(struct ast_cli_args *a)
 652 {
 653         char *res = NULL;
 654         struct ao2_iterator i;
 655         int which = 0;
 656         size_t wordlen;
 657         struct ast_tone_zone *tz;
 658
 659         wordlen = strlen(a->word);
 660
 661         i = ao2_iterator_init(ast_tone_zones, 0);
 662         while ((tz = ao2_iterator_next(&i))) {
 663                 if (!strncasecmp(a->word, tz->country, wordlen) && ++which > a->n) {
 664                         res = ast_strdup(tz->country);
 665                 }
 666                 tz = ast_tone_zone_unref(tz);
 667                 if (res) {
 668                         break;
 669                 }
 670         }
 671         ao2_iterator_destroy(&i);
 672
 673         return res;
 674 }
 675
 676 static char *handle_cli_indication_add(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
 677 {
 678         struct ast_tone_zone *tz;
 679         int created_country = 0;
 680         char *res = CLI_SUCCESS;
 681
 682         switch (cmd) {
 683         case CLI_INIT:
 684                 e->command = "indication add";
 685                 e->usage =
 686                         "Usage: indication add <country> <indication> \"<tonelist>\"\n"
 687                         "       Add the given indication to the country.\n";
 688                 return NULL;
 689         case CLI_GENERATE:
 690                 if (a->pos == 2) {
 691                         return complete_country(a);
 692                 } else {
 693                         return NULL;
 694                 }
 695         }
 696
 697         if (a->argc != 5) {
 698                 return CLI_SHOWUSAGE;
 699         }
 700
 701         if (!(tz = ast_get_indication_zone(a->argv[2]))) {
 702                 /* country does not exist, create it */
 703                 ast_log(LOG_NOTICE, "Country '%s' does not exist, creating it.\n", a->argv[2]);
 704
 705                 if (!(tz = ast_tone_zone_alloc())) {
 706                         return CLI_FAILURE;
 707                 }
 708
 709                 ast_copy_string(tz->country, a->argv[2], sizeof(tz->country));
 710
 711                 if (ast_register_indication_country(tz)) {
 712                         ast_log(LOG_WARNING, "Unable to register new country\n");
 713                         tz = ast_tone_zone_unref(tz);
 714                         return CLI_FAILURE;
 715                 }
 716
 717                 created_country = 1;
 718         }
 719
 720         ast_tone_zone_lock(tz);
 721
 722         if (ast_register_indication(tz, a->argv[3], a->argv[4])) {
 723                 ast_log(LOG_WARNING, "Unable to register indication %s/%s\n", a->argv[2], a->argv[3]);
 724                 if (created_country) {
 725                         ast_unregister_indication_country(a->argv[2]);
 726                 }
 727                 res = CLI_FAILURE;
 728         }
 729
 730         ast_tone_zone_unlock(tz);
 731
 732         tz = ast_tone_zone_unref(tz);
 733
 734         return res;
 735 }
 736
 737 static char *complete_indications(struct ast_cli_args *a)
 738 {
 739         char *res = NULL;
 740         int which = 0;
 741         size_t wordlen;
 742         struct ast_tone_zone_sound *ts;
 743         struct ast_tone_zone *tz, tmp_tz = {
 744                 .nrringcadence = 0,
 745         };
 746
 747         ast_copy_string(tmp_tz.country, a->argv[a->pos - 1], sizeof(tmp_tz.country));
 748
 749         if (!(tz = ao2_find(ast_tone_zones, &tmp_tz, OBJ_POINTER))) {
 750                 return NULL;
 751         }
 752
 753         wordlen = strlen(a->word);
 754
 755         ast_tone_zone_lock(tz);
 756         AST_LIST_TRAVERSE(&tz->tones, ts, entry) {
 757                 if (!strncasecmp(a->word, ts->name, wordlen) && ++which > a->n) {
 758                         res = ast_strdup(ts->name);
 759                         break;
 760                 }
 761         }
 762         ast_tone_zone_unlock(tz);
 763
 764         tz = ast_tone_zone_unref(tz);
 765
 766         return res;
 767 }
 768
 769 static char *handle_cli_indication_remove(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
 770 {
 771         struct ast_tone_zone *tz;
 772         char *res = CLI_SUCCESS;
 773
 774         switch (cmd) {
 775         case CLI_INIT:
 776                 e->command = "indication remove";
 777                 e->usage =
 778                         "Usage: indication remove <country> [indication]\n"
 779                         "       Remove the given indication from the country.\n";
 780                 return NULL;
 781         case CLI_GENERATE:
 782                 if (a->pos == 2) {
 783                         return complete_country(a);
 784                 } else if (a->pos == 3) {
 785                         return complete_indications(a);
 786                 }
 787         }
 788
 789         if (a->argc != 3 && a->argc != 4) {
 790                 return CLI_SHOWUSAGE;
 791         }
 792
 793         if (a->argc == 3) {
 794                 /* remove entire country */
 795                 if (ast_unregister_indication_country(a->argv[2])) {
 796                         ast_log(LOG_WARNING, "Unable to unregister indication country %s\n", a->argv[2]);
 797                         return CLI_FAILURE;
 798                 }
 799
 800                 return CLI_SUCCESS;
 801         }
 802
 803         if (!(tz = ast_get_indication_zone(a->argv[2]))) {
 804                 ast_log(LOG_WARNING, "Unable to unregister indication %s/%s, country does not exists\n", a->argv[2], a->argv[3]);
 805                 return CLI_FAILURE;
 806         }
 807
 808         if (ast_unregister_indication(tz, a->argv[3])) {
 809                 ast_log(LOG_WARNING, "Unable to unregister indication %s/%s\n", a->argv[2], a->argv[3]);
 810                 res = CLI_FAILURE;
 811         }
 812
 813         tz = ast_tone_zone_unref(tz);
 814
 815         return res;
 816 }
 817
 818 static char *handle_cli_indication_show(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
 819 {
 820         struct ast_tone_zone *tz = NULL;
 821         struct ast_str *buf;
 822         int found_country = 0;
 823         int i;
 824
 825         switch (cmd) {
 826         case CLI_INIT:
 827                 e->command = "indication show";
 828                 e->usage =
 829                         "Usage: indication show [<country> ...]\n"
 830                         "       Display either a condensed summary of all countries and indications, or a\n"
 831                         "       more verbose list of indications for the specified countries.\n";
 832                 return NULL;
 833         case CLI_GENERATE:
 834                 return complete_country(a);
 835         }
 836
 837         if (a->argc == 2) {
 838                 struct ao2_iterator iter;
 839                 /* no arguments, show a list of countries */
 840                 ast_cli(a->fd, "Country   Description\n");
 841                 ast_cli(a->fd, "===========================\n");
 842                 iter = ast_tone_zone_iterator_init();
 843                 while ((tz = ao2_iterator_next(&iter))) {
 844                         ast_tone_zone_lock(tz);
 845                         ast_cli(a->fd, "%-7.7s  %s\n", tz->country, tz->description);
 846                         ast_tone_zone_unlock(tz);
 847                         tz = ast_tone_zone_unref(tz);
 848                 }
 849                 ao2_iterator_destroy(&iter);
 850                 return CLI_SUCCESS;
 851         }
 852
 853         buf = ast_str_alloca(256);
 854
 855         for (i = 2; i < a->argc; i++) {
 856                 struct ast_tone_zone zone_arg = {
 857                         .nrringcadence = 0,
 858                 };
 859                 struct ast_tone_zone_sound *ts;
 860                 int j;
 861
 862                 ast_copy_string(zone_arg.country, a->argv[i], sizeof(zone_arg.country));
 863
 864                 if (!(tz = ao2_find(ast_tone_zones, &zone_arg, OBJ_POINTER))) {
 865                         continue;
 866                 }
 867
 868                 if (!found_country) {
 869                         found_country = 1;
 870                         ast_cli(a->fd, "Country Indication      PlayList\n");
 871                         ast_cli(a->fd, "=====================================\n");
 872                 }
 873
 874                 ast_tone_zone_lock(tz);
 875
 876                 ast_str_set(&buf, 0, "%-7.7s %-15.15s ", tz->country, "<ringcadence>");
 877                 for (j = 0; j < tz->nrringcadence; j++) {
 878                         ast_str_append(&buf, 0, "%d%s", tz->ringcadence[j],
 879                                         (j == tz->nrringcadence - 1) ? "" : ",");
 880                 }
 881                 ast_str_append(&buf, 0, "\n");
 882                 ast_cli(a->fd, "%s", ast_str_buffer(buf));
 883
 884                 AST_LIST_TRAVERSE(&tz->tones, ts, entry) {
 885                         ast_cli(a->fd, "%-7.7s %-15.15s %s\n", tz->country, ts->name, ts->data);
 886                 }
 887
 888                 ast_tone_zone_unlock(tz);
 889                 tz = ast_tone_zone_unref(tz);
 890         }
 891
 892         if (!found_country) {
 893                 ast_cli(a->fd, "No countries matched your criteria.\n");
 894         }
 895
 896         return CLI_SUCCESS;
 897 }
 898
 899 static int is_valid_tone_zone(struct ast_tone_zone *zone)
 900 {
 901         int res;
 902
 903         ast_tone_zone_lock(zone);
 904         res = (!ast_strlen_zero(zone->description) && !AST_LIST_EMPTY(&zone->tones));
 905         ast_tone_zone_unlock(zone);
 906
 907         return res;
 908 }
 909
 910 /*!\brief
 911  *
 912  * \note This is called with the tone zone locked.
 913  */
 914 static void store_tone_zone_ring_cadence(struct ast_tone_zone *zone, const char *val)
 915 {
 916         char buf[1024];
 917         char *ring, *c = buf;
 918
 919         ast_copy_string(buf, val, sizeof(buf));
 920
 921         while ((ring = strsep(&c, ","))) {
 922                 int *tmp, val;
 923
 924                 ring = ast_strip(ring);
 925
 926                 if (!isdigit(ring[0]) || (val = atoi(ring)) == -1) {
 927                         ast_log(LOG_WARNING, "Invalid ringcadence given '%s'.\n", ring);
 928                         continue;
 929                 }
 930
 931                 if (!(tmp = ast_realloc(zone->ringcadence, (zone->nrringcadence + 1) * sizeof(int)))) {
 932                         return;
 933                 }
 934
 935                 zone->ringcadence = tmp;
 936                 tmp[zone->nrringcadence] = val;
 937                 zone->nrringcadence++;
 938         }
 939 }
 940
 941 static void store_config_tone_zone(struct ast_tone_zone *zone, const char *var,
 942                 const char *value)
 943 {
 944         CV_START(var, value);
 945
 946         CV_STR("description", zone->description);
 947         CV_F("ringcadence", store_tone_zone_ring_cadence(zone, value));
 948
 949         ast_register_indication(zone, var, value);
 950
 951         CV_END;
 952 }
 953
 954 static void reset_tone_zone(struct ast_tone_zone *zone)
 955 {
 956         ast_tone_zone_lock(zone);
 957
 958         zone->killme = 0;
 959
 960         if (zone->nrringcadence) {
 961                 zone->nrringcadence = 0;
 962                 ast_free(zone->ringcadence);
 963                 zone->ringcadence = NULL;
 964         }
 965
 966         ast_tone_zone_unlock(zone);
 967 }
 968
 969 static int parse_tone_zone(struct ast_config *cfg, const char *country)
 970 {
 971         struct ast_variable *v;
 972         struct ast_tone_zone *zone;
 973         struct ast_tone_zone tmp_zone = {
 974                 .nrringcadence = 0,
 975         };
 976         int allocd = 0;
 977
 978         ast_copy_string(tmp_zone.country, country, sizeof(tmp_zone.country));
 979
 980         if ((zone = ao2_find(ast_tone_zones, &tmp_zone, OBJ_POINTER))) {
 981                 reset_tone_zone(zone);
 982         } else if ((zone = ast_tone_zone_alloc())) {
 983                 allocd = 1;
 984                 ast_copy_string(zone->country, country, sizeof(zone->country));
 985         } else {
 986                 return -1;
 987         }
 988
 989         ast_tone_zone_lock(zone);
 990         for (v = ast_variable_browse(cfg, country); v; v = v->next) {
 991                 store_config_tone_zone(zone, v->name, v->value);
 992         }
 993         ast_tone_zone_unlock(zone);
 994
 995         if (allocd) {
 996                 if (!is_valid_tone_zone(zone)) {
 997                         ast_log(LOG_WARNING, "Indication country '%s' is invalid\n", country);
 998                 } else if (ast_register_indication_country(zone)) {
 999                         ast_log(LOG_WARNING, "Unable to register indication country '%s'.\n",
1000                                         country);
1001                 }
1002         }
1003
1004         zone = ast_tone_zone_unref(zone);
1005
1006         return 0;
1007 }
1008
1009 /*! \brief
1010  * Mark the zone and its tones before parsing configuration.  We will use this
1011  * to know what to remove after configuration is parsed.
1012  */
1013 static int tone_zone_mark(void *obj, void *arg, int flags)
1014 {
1015         struct ast_tone_zone *zone = obj;
1016         struct ast_tone_zone_sound *s;
1017
1018         ast_tone_zone_lock(zone);
1019
1020         zone->killme = 1;
1021
1022         AST_LIST_TRAVERSE(&zone->tones, s, entry) {
1023                 s->killme = 1;
1024         }
1025
1026         ast_tone_zone_unlock(zone);
1027
1028         return 0;
1029 }
1030
1031 /*! \brief
1032  * Prune tones no longer in the configuration, and have the tone zone unlinked
1033  * if it is no longer in the configuration at all.
1034  */
1035 static int prune_tone_zone(void *obj, void *arg, int flags)
1036 {
1037         struct ast_tone_zone *zone = obj;
1038         struct ast_tone_zone_sound *s;
1039
1040         ast_tone_zone_lock(zone);
1041
1042         AST_LIST_TRAVERSE_SAFE_BEGIN(&zone->tones, s, entry) {
1043                 if (s->killme) {
1044                         AST_LIST_REMOVE_CURRENT(entry);
1045                         s = ast_tone_zone_sound_unref(s);
1046                 }
1047         }
1048         AST_LIST_TRAVERSE_SAFE_END;
1049
1050         ast_tone_zone_unlock(zone);
1051
1052         return zone->killme ? CMP_MATCH : 0;
1053 }
1054
1055 /*! \brief load indications module */
1056 static int load_indications(int reload)
1057 {
1058         struct ast_config *cfg;
1059         const char *cxt = NULL;
1060         const char *country = NULL;
1061         struct ast_flags config_flags = { reload ? CONFIG_FLAG_FILEUNCHANGED : 0 };
1062         int res = -1;
1063
1064         cfg = ast_config_load2(config, "indications", config_flags);
1065
1066         if (cfg == CONFIG_STATUS_FILEMISSING || cfg == CONFIG_STATUS_FILEINVALID) {
1067                 ast_log(LOG_WARNING, "Can't find indications config file %s.\n", config);
1068                 return 0;
1069         } else if (cfg == CONFIG_STATUS_FILEUNCHANGED) {
1070                 return 0;
1071         }
1072
1073         /* Lock the container to prevent multiple simultaneous reloads */
1074         ao2_lock(ast_tone_zones);
1075
1076         ao2_callback(ast_tone_zones, OBJ_NODATA, tone_zone_mark, NULL);
1077
1078         /* Use existing config to populate the Indication table */
1079         while ((cxt = ast_category_browse(cfg, cxt))) {
1080                 /* All categories but "general" are considered countries */
1081                 if (!strcasecmp(cxt, "general")) {
1082                         continue;
1083                 }
1084
1085                 if (parse_tone_zone(cfg, cxt)) {
1086                         goto return_cleanup;
1087                 }
1088         }
1089
1090         ao2_callback(ast_tone_zones, OBJ_NODATA | OBJ_MULTIPLE | OBJ_UNLINK,
1091                         prune_tone_zone, NULL);
1092
1093         /* determine which country is the default */
1094         country = ast_variable_retrieve(cfg, "general", "country");
1095         if (ast_strlen_zero(country) || ast_set_indication_country(country)) {
1096                 ast_log(LOG_WARNING, "Unable to set the default country (for indication tones)\n");
1097         }
1098
1099         res = 0;
1100
1101 return_cleanup:
1102         ao2_unlock(ast_tone_zones);
1103         ast_config_destroy(cfg);
1104
1105         return res;
1106 }
1107
1108 /*! \brief CLI entries for commands provided by this module */
1109 static struct ast_cli_entry cli_indications[] = {
1110         AST_CLI_DEFINE(handle_cli_indication_add,    "Add the given indication to the country"),
1111         AST_CLI_DEFINE(handle_cli_indication_remove, "Remove the given indication from the country"),
1112         AST_CLI_DEFINE(handle_cli_indication_show,   "Display a list of all countries/indications")
1113 };
1114
1115 static int ast_tone_zone_hash(const void *obj, const int flags)
1116 {
1117         const struct ast_tone_zone *zone = obj;
1118
1119         return ast_str_case_hash(zone->country);
1120 }
1121
1122 static int ast_tone_zone_cmp(void *obj, void *arg, int flags)
1123 {
1124         struct ast_tone_zone *zone = obj;
1125         struct ast_tone_zone *zone_arg = arg;
1126
1127         return (!strcasecmp(zone->country, zone_arg->country)) ?
1128                         CMP_MATCH | CMP_STOP : 0;
1129 }
1130
1131 int ast_tone_zone_data_add_structure(struct ast_data *tree, struct ast_tone_zone *zone)
1132 {
1133         struct ast_data *data_zone_sound;
1134         struct ast_tone_zone_sound *s;
1135
1136         ast_data_add_structure(ast_tone_zone, tree, zone);
1137
1138         if (AST_LIST_EMPTY(&zone->tones)) {
1139                 return 0;
1140         }
1141
1142         data_zone_sound = ast_data_add_node(tree, "tones");
1143         if (!data_zone_sound) {
1144                 return -1;
1145         }
1146
1147         ast_tone_zone_lock(zone);
1148
1149         AST_LIST_TRAVERSE(&zone->tones, s, entry) {
1150                 ast_data_add_structure(ast_tone_zone_sound, data_zone_sound, s);
1151         }
1152
1153         ast_tone_zone_unlock(zone);
1154
1155         return 0;
1156 }
1157
1158 /*!
1159  * \internal
1160  * \brief Clean up resources on Asterisk shutdown
1161  */
1162 static void indications_shutdown(void)
1163 {
1164         ast_cli_unregister_multiple(cli_indications, ARRAY_LEN(cli_indications));
1165         if (default_tone_zone) {
1166                 ast_tone_zone_unref(default_tone_zone);
1167                 default_tone_zone = NULL;
1168         }
1169         if (ast_tone_zones) {
1170                 ao2_ref(ast_tone_zones, -1);
1171                 ast_tone_zones = NULL;
1172         }
1173 }
1174
1175 /*! \brief Load indications module */
1176 int ast_indications_init(void)
1177 {
1178         if (!(ast_tone_zones = ao2_container_alloc(NUM_TONE_ZONE_BUCKETS,
1179                         ast_tone_zone_hash, ast_tone_zone_cmp))) {
1180                 return -1;
1181         }
1182
1183         if (load_indications(0)) {
1184                 indications_shutdown();
1185                 return -1;
1186         }
1187
1188         ast_cli_register_multiple(cli_indications, ARRAY_LEN(cli_indications));
1189
1190         ast_register_atexit(indications_shutdown);
1191         return 0;
1192 }
1193
1194 /*! \brief Reload indications module */
1195 int ast_indications_reload(void)
1196 {
1197         return load_indications(1);
1198 }
1199