Main Page | Alphabetical List | Data Structures | File List | Data Fields | Globals

indications.h File Reference

#include <asterisk/lock.h>

Go to the source code of this file.

Data Structures

struct  tone_zone
struct  tone_zone_sound

Functions

int ast_set_indication_country (const char *country)
tone_zone * ast_get_indication_zone (const char *country)
tone_zone_sound * ast_get_indication_tone (const struct tone_zone *zone, const char *indication)
int ast_register_indication_country (struct tone_zone *country)
int ast_unregister_indication_country (const char *country)
int ast_register_indication (struct tone_zone *zone, const char *indication, const char *tonelist)
int ast_unregister_indication (struct tone_zone *zone, const char *indication)
int ast_playtones_start (struct ast_channel *chan, int vol, const char *tonelist, int interruptible)
void ast_playtones_stop (struct ast_channel *chan)

Variables

tone_zone * tone_zones
ast_mutex_t tzlock

Function Documentation

struct tone_zone_sound* ast_get_indication_tone (  const struct tone_zone *  zone,
const char *  indication
) 
 

Definition at line 286 of file indications.c.

References ast_log(), ast_mutex_lock, ast_mutex_unlock, LOG_WARNING, tone_zone_sound::next, tone_zones, tone_zone::tones, and tzlock.

Referenced by ast_indicate(). 

00287 {
00288    struct tone_zone_sound *ts;
00289 
00290    /* we need some tonezone, pick the first */
00291    if (zone == NULL && current_tonezone)
00292       zone = current_tonezone;   /* default country? */
00293    if (zone == NULL && tone_zones)
00294       zone = tone_zones;      /* any country? */
00295    if (zone == NULL)
00296       return 0;   /* not a single country insight */
00297 
00298    if (ast_mutex_lock(&tzlock)) {
00299       ast_log(LOG_WARNING, "Unable to lock tone_zones list\n");
00300       return 0;
00301    }
00302    for (ts=zone->tones; ts; ts=ts->next) {
00303       if (strcasecmp(indication,ts->name)==0) {
00304          /* found indication! */
00305          ast_mutex_unlock(&tzlock);
00306          return ts;
00307       }
00308    }
00309    /* nothing found, sorry */
00310    ast_mutex_unlock(&tzlock);
00311    return 0;
00312 }

struct tone_zone* ast_get_indication_zone (  const char *  country  ) 
 

Definition at line 248 of file indications.c.

References ast_log(), ast_mutex_lock, ast_mutex_unlock, LOG_NOTICE, LOG_WARNING, tone_zone::next, tone_zones, and tzlock.

Referenced by ast_set_indication_country(). 

00249 {
00250    struct tone_zone *tz;
00251    int alias_loop = 0;
00252 
00253    /* we need some tonezone, pick the first */
00254    if (country == NULL && current_tonezone)
00255       return current_tonezone;   /* default country? */
00256    if (country == NULL && tone_zones)
00257       return tone_zones;      /* any country? */
00258    if (country == NULL)
00259       return 0;   /* not a single country insight */
00260 
00261    if (ast_mutex_lock(&tzlock)) {
00262       ast_log(LOG_WARNING, "Unable to lock tone_zones list\n");
00263       return 0;
00264    }
00265    do {
00266       for (tz=tone_zones; tz; tz=tz->next) {
00267          if (strcasecmp(country,tz->country)==0) {
00268             /* tone_zone found */
00269             if (tz->alias && tz->alias[0]) {
00270                country = tz->alias;
00271                break;
00272             }
00273             ast_mutex_unlock(&tzlock);
00274             return tz;
00275          }
00276       }
00277    } while (++alias_loop<20 && tz);
00278    ast_mutex_unlock(&tzlock);
00279    if (alias_loop==20)
00280       ast_log(LOG_NOTICE,"Alias loop for '%s' forcefull broken\n",country);
00281    /* nothing found, sorry */
00282    return 0;
00283 }

int ast_playtones_start (  struct ast_channel *  chan,
int  vol,
const char *  tonelist,
int  interruptible
) 
 

Definition at line 147 of file indications.c.

References ast_activate_generator(), ast_log(), free, playtones_def::interruptible, playtones_def::items, LOG_WARNING, ast_channel::name, playtones_def::nitems, realloc, playtones_def::reppos, s, and playtones_def::vol.

Referenced by ast_indicate(). 

00148 {
00149    char *s, *data = ast_strdupa(playlst); /* cute */
00150    struct playtones_def d = { vol, -1, 0, 1, NULL};
00151    char *stringp=NULL;
00152    char *separator;
00153    if (!data)
00154       return -1;
00155    if (vol < 1)
00156       d.vol = 8192;
00157 
00158    d.interruptible = interruptible;
00159    
00160    stringp=data;
00161    /* the stringp/data is not null here */
00162    /* check if the data is separated with '|' or with ',' by default */
00163    if (strchr(stringp,'|'))
00164       separator = "|";
00165    else
00166       separator = ",";
00167    s = strsep(&stringp,separator);
00168         while(s && *s) {
00169       int freq1, freq2, time, modulate=0;
00170 
00171       if (s[0]=='!')
00172          s++;
00173       else if (d.reppos == -1)
00174          d.reppos = d.nitems;
00175       if (sscanf(s, "%d+%d/%d", &freq1, &freq2, &time) == 3) {
00176          /* f1+f2/time format */
00177       } else if (sscanf(s, "%d+%d", &freq1, &freq2) == 2) {
00178          /* f1+f2 format */
00179          time = 0;
00180       } else if (sscanf(s, "%d*%d/%d", &freq1, &freq2, &time) == 3) {
00181          /* f1*f2/time format */
00182          modulate = 1;
00183       } else if (sscanf(s, "%d*%d", &freq1, &freq2) == 2) {
00184          /* f1*f2 format */
00185          time = 0;
00186          modulate = 1;
00187       } else if (sscanf(s, "%d/%d", &freq1, &time) == 2) {
00188          /* f1/time format */
00189          freq2 = 0;
00190       } else if (sscanf(s, "%d", &freq1) == 1) {
00191          /* f1 format */
00192          freq2 = 0;
00193          time = 0;
00194       } else {
00195          ast_log(LOG_WARNING,"%s: tone component '%s' of '%s' is no good\n",chan->name,s,playlst);
00196          return -1;
00197       }
00198 
00199       d.items = realloc(d.items,(d.nitems+1)*sizeof(struct playtones_item));
00200       if (d.items == NULL)
00201          return -1;
00202       d.items[d.nitems].freq1    = freq1;
00203       d.items[d.nitems].freq2    = freq2;
00204       d.items[d.nitems].duration = time;
00205       d.items[d.nitems].modulate = modulate;
00206       d.nitems++;
00207 
00208       s = strsep(&stringp,separator);
00209    }
00210 
00211    if (ast_activate_generator(chan, &playtones, &d)) {
00212       free(d.items);
00213       return -1;
00214    }
00215    return 0;
00216 }

void ast_playtones_stop (  struct ast_channel *  chan  ) 
 

Stop the tones from playing

Definition at line 218 of file indications.c.

References ast_deactivate_generator().

Referenced by ast_indicate(). 

00219 {
00220    ast_deactivate_generator(chan);
00221 }

int ast_register_indication (  struct tone_zone *  zone,
const char *  indication,
const char *  tonelist
) 
 

Definition at line 413 of file indications.c.

References tone_zone::alias, ast_log(), ast_mutex_lock, ast_mutex_unlock, free, LOG_WARNING, malloc, tone_zone_sound::next, strdup, tone_zone::tones, and tzlock. 

00414 {
00415    struct tone_zone_sound *ts,*ps;
00416 
00417    /* is it an alias? stop */
00418    if (zone->alias[0])
00419       return -1;
00420 
00421    if (ast_mutex_lock(&tzlock)) {
00422       ast_log(LOG_WARNING, "Unable to lock tone_zones list\n");
00423       return -2;
00424    }
00425    for (ps=NULL,ts=zone->tones; ts; ps=ts,ts=ts->next) {
00426       if (strcasecmp(indication,ts->name)==0) {
00427          /* indication already there, replace */
00428          free((void*)ts->name);
00429          free((void*)ts->data);
00430          break;
00431       }
00432    }
00433    if (!ts) {
00434       /* not there, we have to add */
00435       ts = malloc(sizeof(struct tone_zone_sound));
00436       if (!ts) {
00437          ast_log(LOG_WARNING, "Out of memory\n");
00438          ast_mutex_unlock(&tzlock);
00439          return -2;
00440       }
00441       ts->next = NULL;
00442    }
00443    ts->name = strdup(indication);
00444    ts->data = strdup(tonelist);
00445    if (ts->name==NULL || ts->data==NULL) {
00446       ast_log(LOG_WARNING, "Out of memory\n");
00447       ast_mutex_unlock(&tzlock);
00448       return -2;
00449    }
00450    if (ps)
00451       ps->next = ts;
00452    else
00453       zone->tones = ts;
00454    ast_mutex_unlock(&tzlock);
00455    return 0;
00456 }

int ast_register_indication_country (  struct tone_zone *  country  ) 
 

Definition at line 330 of file indications.c.

References ast_log(), ast_mutex_lock, ast_mutex_unlock, ast_verbose(), tone_zone::country, LOG_WARNING, tone_zone::next, option_verbose, tone_zones, tzlock, and VERBOSE_PREFIX_3. 

00331 {
00332    struct tone_zone *tz,*pz;
00333 
00334    if (ast_mutex_lock(&tzlock)) {
00335       ast_log(LOG_WARNING, "Unable to lock tone_zones list\n");
00336       return -1;
00337    }
00338    for (pz=NULL,tz=tone_zones; tz; pz=tz,tz=tz->next) {
00339       if (strcasecmp(zone->country,tz->country)==0) {
00340          /* tone_zone already there, replace */
00341          zone->next = tz->next;
00342          if (pz)
00343             pz->next = zone;
00344          else
00345             tone_zones = zone;
00346          /* if we are replacing the default zone, re-point it */
00347          if (tz == current_tonezone)
00348             current_tonezone = zone;
00349          /* now free the previous zone */
00350          free_zone(tz);
00351          ast_mutex_unlock(&tzlock);
00352          return 0;
00353       }
00354    }
00355    /* country not there, add */
00356    zone->next = NULL;
00357    if (pz)
00358       pz->next = zone;
00359    else
00360       tone_zones = zone;
00361    ast_mutex_unlock(&tzlock);
00362 
00363    if (option_verbose > 2)
00364       ast_verbose(VERBOSE_PREFIX_3 "Registered indication country '%s'\n",zone->country);
00365    return 0;
00366 }

int ast_set_indication_country (  const char *  country  ) 
 

Definition at line 233 of file indications.c.

References ast_get_indication_zone(), ast_verbose(), option_verbose, and VERBOSE_PREFIX_3. 

00234 {
00235    if (country) {
00236       struct tone_zone *z = ast_get_indication_zone(country);
00237       if (z) {
00238          if (option_verbose > 2)
00239             ast_verbose(VERBOSE_PREFIX_3 "Setting default indication country to '%s'\n",country);
00240          current_tonezone = z;
00241          return 0;
00242       }
00243    }
00244    return 1; /* not found */
00245 }

int ast_unregister_indication (  struct tone_zone *  zone,
const char *  indication
) 
 

Definition at line 459 of file indications.c.

References tone_zone::alias, ast_log(), ast_mutex_lock, ast_mutex_unlock, free, LOG_WARNING, tone_zone_sound::next, tone_zone::tones, and tzlock. 

00460 {
00461    struct tone_zone_sound *ts,*ps = NULL, *tmp;
00462    int res = -1;
00463 
00464    /* is it an alias? stop */
00465    if (zone->alias[0])
00466       return -1;
00467 
00468    if (ast_mutex_lock(&tzlock)) {
00469       ast_log(LOG_WARNING, "Unable to lock tone_zones list\n");
00470       return -1;
00471    }
00472    ts = zone->tones;
00473    while (ts) {
00474       if (strcasecmp(indication,ts->name)==0) {
00475          /* indication found */
00476          tmp = ts->next;
00477          if (ps)
00478             ps->next = tmp;
00479          else
00480             zone->tones = tmp;
00481          free((void*)ts->name);
00482          free((void*)ts->data);
00483          free(ts);
00484          ts = tmp;
00485          res = 0;
00486       }
00487       else {
00488          /* next zone please */
00489          ps = ts;
00490          ts = ts->next;
00491       }
00492    }
00493    /* indication not found, goodbye */
00494    ast_mutex_unlock(&tzlock);
00495    return res;
00496 }

int ast_unregister_indication_country (  const char *  country  ) 
 

Definition at line 370 of file indications.c.

References ast_log(), ast_mutex_lock, ast_mutex_unlock, ast_verbose(), LOG_NOTICE, LOG_WARNING, tone_zone::next, option_verbose, tone_zones, tzlock, and VERBOSE_PREFIX_3. 

00371 {
00372    struct tone_zone *tz, *pz = NULL, *tmp;
00373    int res = -1;
00374 
00375    if (ast_mutex_lock(&tzlock)) {
00376       ast_log(LOG_WARNING, "Unable to lock tone_zones list\n");
00377       return -1;
00378    }
00379    tz = tone_zones;
00380    while (tz) {
00381       if (country==NULL ||
00382           (strcasecmp(country, tz->country)==0 ||
00383            strcasecmp(country, tz->alias)==0)) {
00384          /* tone_zone found, remove */
00385          tmp = tz->next;
00386          if (pz)
00387             pz->next = tmp;
00388          else
00389             tone_zones = tmp;
00390          /* if we are unregistering the default country, w'll notice */
00391          if (tz == current_tonezone) {
00392             ast_log(LOG_NOTICE,"Removed default indication country '%s'\n",tz->country);
00393             current_tonezone = NULL;
00394          }
00395          if (option_verbose > 2)
00396             ast_verbose(VERBOSE_PREFIX_3 "Unregistered indication country '%s'\n",tz->country);
00397          free_zone(tz);
00398          tz = tmp;
00399          res = 0;
00400       }
00401       else {
00402          /* next zone please */
00403          pz = tz;
00404          tz = tz->next;
00405       }
00406    }
00407    ast_mutex_unlock(&tzlock);
00408    return res;
00409 }

Variable Documentation

struct tone_zone* tone_zones
 

Definition at line 74 of file indications.h.

Referenced by ast_get_indication_tone(), ast_get_indication_zone(), ast_register_indication_country(), and ast_unregister_indication_country().

ast_mutex_t tzlock
 

Definition at line 75 of file indications.h.

Referenced by ast_get_indication_tone(), ast_get_indication_zone(), ast_register_indication(), ast_register_indication_country(), ast_unregister_indication(), and ast_unregister_indication_country().

Generated on Fri Feb 27 12:19:49 2004 for Asterisk by doxygen 1.3.5