apps/app_rpt.c

   1 /** @file app_rpt.c
   2  *
   3  * Asterisk -- A telephony toolkit for Linux.
   4  *
   5  * Radio Repeater program
   6  *
   7  * Copyright (C) 2002, Jim Dixon
   8  *
   9  * Jim Dixon <jim@lambdatel.com>
  10  *
  11  * This program is free software, distributed under the terms of
  12  * the GNU General Public License
  13  *
  14  */
  15
  16 #include <asterisk/lock.h>
  17 #include <asterisk/file.h>
  18 #include <asterisk/logger.h>
  19 #include <asterisk/channel.h>
  20 #include <asterisk/pbx.h>
  21 #include <asterisk/module.h>
  22 #include <asterisk/translate.h>
  23 #include <asterisk/options.h>
  24 #include <asterisk/config.h>
  25 #include <stdio.h>
  26 #include <unistd.h>
  27 #include <string.h>
  28 #include <stdlib.h>
  29 #include <pthread.h>
  30 #include <sys/types.h>
  31 #include <sys/stat.h>
  32 #include <errno.h>
  33 #include <dirent.h>
  34 #include <ctype.h>
  35 #include <sys/stat.h>
  36 #include <sys/time.h>
  37 #include <sys/file.h>
  38 #include <sys/ioctl.h>
  39 #include <math.h>
  40 #include <tonezone.h>
  41 #include <linux/zaptel.h>
  42
  43 static  char *tdesc = "Radio Repeater";
  44 static int debug = 0;
  45 STANDARD_LOCAL_USER;
  46 LOCAL_USER_DECL;
  47
  48 #define MSWAIT 200
  49 #define HANGTIME 5000
  50 #define TOTIME 180000
  51 #define IDTIME 300000
  52 #define MAXRPTS 20
  53
  54 static  pthread_t rpt_master_thread;
  55
  56 static struct rpt
  57 {
  58         char *name;
  59         char *rxchanname;
  60         char *txchanname;
  61         char *ourcontext;
  62         char *ourcallerid;
  63         char *acctcode;
  64         char *idrecording;
  65         int hangtime;
  66         int totime;
  67         int idtime;
  68         struct ast_channel *rxchannel,*txchannel,*pchannel;
  69         int tailtimer,totimer,idtimer,txconf,pconf,callmode,cidx;
  70         pthread_t rpt_id_thread,rpt_term_thread,rpt_proc_thread,rpt_call_thread;
  71         char mydtmf,iding,terming;
  72         char exten[AST_MAX_EXTENSION];
  73 } rpt_vars[MAXRPTS];
  74
  75
  76 static void *rpt_id(void *this)
  77 {
  78 ZT_CONFINFO ci;  /* conference info */
  79 int     res;
  80 struct  rpt *myrpt = (struct rpt *)this;
  81 struct ast_channel *mychannel;
  82
  83         /* allocate a pseudo-channel thru asterisk */
  84         mychannel = ast_request("zap",AST_FORMAT_SLINEAR,"pseudo");
  85         if (!mychannel)
  86         {
  87                 fprintf(stderr,"rpt:Sorry unable to obtain pseudo channel\n");
  88                 pthread_exit(NULL);
  89         }
  90         /* make a conference for the tx */
  91         ci.chan = 0;
  92         ci.confno = myrpt->txconf; /* use the tx conference */
  93         ci.confmode = ZT_CONF_CONFANN;
  94         /* first put the channel on the conference in announce mode */
  95         if (ioctl(mychannel->fds[0],ZT_SETCONF,&ci) == -1)
  96         {
  97                 ast_log(LOG_WARNING, "Unable to set conference mode to Announce\n");
  98                 pthread_exit(NULL);
  99         }
 100         myrpt->iding = 1;
 101         ast_stopstream(mychannel);
 102         res = ast_streamfile(mychannel, myrpt->idrecording, mychannel->language);
 103         if (!res)
 104                 res = ast_waitstream(mychannel, "");
 105         else {
 106                 ast_log(LOG_WARNING, "ast_streamfile failed on %s\n", mychannel->name);
 107                 res = 0;
 108         }
 109         myrpt->iding = 0;
 110         ast_stopstream(mychannel);
 111         ast_hangup(mychannel);
 112         pthread_exit(NULL);
 113 }
 114
 115 static void *rpt_proc(void *this)
 116 {
 117 ZT_CONFINFO ci;  /* conference info */
 118 int     res;
 119 struct  rpt *myrpt = (struct rpt *)this;
 120 struct ast_channel *mychannel;
 121
 122         /* wait a little bit */
 123         usleep(1500000);
 124         /* allocate a pseudo-channel thru asterisk */
 125         mychannel = ast_request("zap",AST_FORMAT_SLINEAR,"pseudo");
 126         if (!mychannel)
 127         {
 128                 fprintf(stderr,"rpt:Sorry unable to obtain pseudo channel\n");
 129                 pthread_exit(NULL);
 130         }
 131         /* make a conference for the tx */
 132         ci.chan = 0;
 133         ci.confno = myrpt->pconf; /* use the tx conference */
 134         ci.confmode = ZT_CONF_CONFANN;
 135         /* first put the channel on the conference in announce mode */
 136         if (ioctl(mychannel->fds[0],ZT_SETCONF,&ci) == -1)
 137         {
 138                 ast_log(LOG_WARNING, "Unable to set conference mode to Announce\n");
 139                 pthread_exit(NULL);
 140         }
 141         myrpt->terming = 1;
 142         ast_stopstream(mychannel);
 143         res = ast_streamfile(mychannel, "callproceeding", mychannel->language);
 144         if (!res)
 145                 res = ast_waitstream(mychannel, "");
 146         else {
 147                 ast_log(LOG_WARNING, "ast_streamfile failed on %s\n", mychannel->name);
 148                 res = 0;
 149         }
 150         myrpt->terming = 0;
 151         ast_stopstream(mychannel);
 152         ast_hangup(mychannel);
 153         pthread_exit(NULL);
 154 }
 155
 156 static void *rpt_term(void *this)
 157 {
 158 ZT_CONFINFO ci;  /* conference info */
 159 int     res;
 160 struct  rpt *myrpt = (struct rpt *)this;
 161 struct ast_channel *mychannel;
 162
 163         /* wait a little bit */
 164         usleep(1500000);
 165         /* allocate a pseudo-channel thru asterisk */
 166         mychannel = ast_request("zap",AST_FORMAT_SLINEAR,"pseudo");
 167         if (!mychannel)
 168         {
 169                 fprintf(stderr,"rpt:Sorry unable to obtain pseudo channel\n");
 170                 pthread_exit(NULL);
 171         }
 172         /* make a conference for the tx */
 173         ci.chan = 0;
 174         ci.confno = myrpt->pconf; /* use the tx conference */
 175         ci.confmode = ZT_CONF_CONFANN;
 176         /* first put the channel on the conference in announce mode */
 177         if (ioctl(mychannel->fds[0],ZT_SETCONF,&ci) == -1)
 178         {
 179                 ast_log(LOG_WARNING, "Unable to set conference mode to Announce\n");
 180                 pthread_exit(NULL);
 181         }
 182         myrpt->terming = 1;
 183         ast_stopstream(mychannel);
 184         res = ast_streamfile(mychannel, "callterminated", mychannel->language);
 185         if (!res)
 186                 res = ast_waitstream(mychannel, "");
 187         else {
 188                 ast_log(LOG_WARNING, "ast_streamfile failed on %s\n", mychannel->name);
 189                 res = 0;
 190         }
 191         myrpt->terming = 0;
 192         ast_stopstream(mychannel);
 193         ast_hangup(mychannel);
 194         pthread_exit(NULL);
 195 }
 196
 197 static void *rpt_call(void *this)
 198 {
 199 ZT_CONFINFO ci;  /* conference info */
 200 struct  rpt *myrpt = (struct rpt *)this;
 201 int     res;
 202 struct  ast_frame *f,wf;
 203 int stopped,congstarted;
 204 struct ast_channel *mychannel,*genchannel;
 205
 206         myrpt->mydtmf = 0;
 207         /* allocate a pseudo-channel thru asterisk */
 208         mychannel = ast_request("zap",AST_FORMAT_SLINEAR,"pseudo");
 209         if (!mychannel)
 210         {
 211                 fprintf(stderr,"rpt:Sorry unable to obtain pseudo channel\n");
 212                 pthread_exit(NULL);
 213         }
 214         ci.chan = 0;
 215         ci.confno = myrpt->pconf; /* use the pseudo conference */
 216         ci.confmode = ZT_CONF_REALANDPSEUDO | ZT_CONF_TALKER | ZT_CONF_LISTENER
 217                 | ZT_CONF_PSEUDO_TALKER | ZT_CONF_PSEUDO_LISTENER;
 218         /* first put the channel on the conference */
 219         if (ioctl(mychannel->fds[0],ZT_SETCONF,&ci) == -1)
 220         {
 221                 ast_log(LOG_WARNING, "Unable to set conference mode to Announce\n");
 222                 ast_hangup(mychannel);
 223                 myrpt->callmode = 0;
 224                 pthread_exit(NULL);
 225         }
 226         /* allocate a pseudo-channel thru asterisk */
 227         genchannel = ast_request("zap",AST_FORMAT_SLINEAR,"pseudo");
 228         if (!genchannel)
 229         {
 230                 fprintf(stderr,"rpt:Sorry unable to obtain pseudo channel\n");
 231                 ast_hangup(mychannel);
 232                 pthread_exit(NULL);
 233         }
 234         ci.chan = 0;
 235         ci.confno = myrpt->pconf;
 236         ci.confmode = ZT_CONF_REALANDPSEUDO | ZT_CONF_TALKER | ZT_CONF_LISTENER
 237                 | ZT_CONF_PSEUDO_TALKER | ZT_CONF_PSEUDO_LISTENER;
 238         /* first put the channel on the conference */
 239         if (ioctl(genchannel->fds[0],ZT_SETCONF,&ci) == -1)
 240         {
 241                 ast_log(LOG_WARNING, "Unable to set conference mode to Announce\n");
 242                 ast_hangup(mychannel);
 243                 ast_hangup(genchannel);
 244                 myrpt->callmode = 0;
 245                 pthread_exit(NULL);
 246         }
 247         /* start dialtone */
 248         if (tone_zone_play_tone(mychannel->fds[0],ZT_TONE_DIALTONE) < 0)
 249         {
 250                 ast_log(LOG_WARNING, "Cannot start dialtone\n");
 251                 ast_hangup(mychannel);
 252                 ast_hangup(genchannel);
 253                 myrpt->callmode = 0;
 254                 pthread_exit(NULL);
 255         }
 256         stopped = 0;
 257         congstarted = 0;
 258         while ((myrpt->callmode == 1) || (myrpt->callmode == 4))
 259         {
 260
 261                 if ((myrpt->callmode == 1) && (myrpt->cidx > 0) && (!stopped))
 262                 {
 263                         stopped = 1;
 264                         /* stop dial tone */
 265                         tone_zone_play_tone(mychannel->fds[0],-1);
 266                 }
 267                 if ((myrpt->callmode == 4) && (!congstarted))
 268                 {
 269                         congstarted = 1;
 270                         /* start congestion tone */
 271                         tone_zone_play_tone(mychannel->fds[0],ZT_TONE_CONGESTION);
 272                 }
 273                 res = ast_waitfor(mychannel, MSWAIT);
 274                 if (res < 0)
 275                 {
 276                         ast_hangup(mychannel);
 277                         ast_hangup(genchannel);
 278                         myrpt->callmode = 0;
 279                         pthread_exit(NULL);
 280                 }
 281                 if (res == 0) continue;
 282                 f = ast_read(mychannel);
 283                 if (f == NULL)
 284                 {
 285                         ast_hangup(mychannel);
 286                         ast_hangup(genchannel);
 287                         myrpt->callmode = 0;
 288                         pthread_exit(NULL);
 289                 }
 290                 if ((f->frametype == AST_FRAME_CONTROL) &&
 291                     (f->subclass == AST_CONTROL_HANGUP))
 292                 {
 293                         ast_frfree(f);
 294                         ast_hangup(mychannel);
 295                         ast_hangup(genchannel);
 296                         myrpt->callmode = 0;
 297                         pthread_exit(NULL);
 298                 }
 299                 ast_frfree(f);
 300         }
 301         /* stop any tone generation */
 302         tone_zone_play_tone(mychannel->fds[0],-1);
 303         /* end if done */
 304         if (!myrpt->callmode)
 305         {
 306                 ast_hangup(mychannel);
 307                 ast_hangup(genchannel);
 308                 myrpt->callmode = 0;
 309                 pthread_exit(NULL);
 310         }
 311         if (myrpt->ourcallerid && *myrpt->ourcallerid)
 312         {
 313                 if (mychannel->callerid) free(mychannel->callerid);
 314                 mychannel->callerid = strdup(myrpt->ourcallerid);
 315         }
 316         strcpy(mychannel->exten,myrpt->exten);
 317         strcpy(mychannel->context,myrpt->ourcontext);
 318         if (myrpt->acctcode)
 319                 strcpy(mychannel->accountcode,myrpt->acctcode);
 320         mychannel->priority = 1;
 321         ast_channel_undefer_dtmf(mychannel);
 322         if (ast_pbx_start(mychannel) < 0)
 323         {
 324                 ast_log(LOG_WARNING, "Unable to start PBX!!\n");
 325                 ast_hangup(mychannel);
 326                 ast_hangup(genchannel);
 327                 myrpt->callmode = 0;
 328                 pthread_exit(NULL);
 329         }
 330         myrpt->callmode = 3;
 331
 332         while(myrpt->callmode)
 333         {
 334                 if ((!mychannel->pvt) && (myrpt->callmode != 4))
 335                 {
 336                         myrpt->callmode = 4;
 337                         /* start congestion tone */
 338                         tone_zone_play_tone(genchannel->fds[0],ZT_TONE_CONGESTION);
 339                 }
 340                 if (myrpt->mydtmf)
 341                 {
 342                         wf.frametype = AST_FRAME_DTMF;
 343                         wf.subclass = myrpt->mydtmf;
 344                         wf.offset = 0;
 345                         wf.mallocd = 0;
 346                         wf.data = NULL;
 347                         wf.datalen = 0;
 348                         wf.samples = 0;
 349                         ast_write(genchannel,&wf);
 350                         myrpt->mydtmf = 0;
 351                 }
 352                 usleep(25000);
 353         }
 354         tone_zone_play_tone(genchannel->fds[0],-1);
 355         if (mychannel->pvt) ast_softhangup(mychannel,AST_SOFTHANGUP_DEV);
 356         ast_hangup(genchannel);
 357         myrpt->callmode = 0;
 358         pthread_exit(NULL);
 359 }
 360
 361 /* single thread with one file (request) to dial */
 362 static void *rpt(void *this)
 363 {
 364 struct  rpt *myrpt = (struct rpt *)this;
 365 char *tele;
 366 int ms = MSWAIT,lasttx,keyed,val;
 367 struct ast_channel *who;
 368 ZT_CONFINFO ci;  /* conference info */
 369 pthread_attr_t attr;
 370
 371         tele = strchr(myrpt->rxchanname,'/');
 372         if (!tele)
 373         {
 374                 fprintf(stderr,"rpt:Dial number must be in format tech/number\n");
 375                 pthread_exit(NULL);
 376         }
 377         *tele++ = 0;
 378         myrpt->rxchannel = ast_request(myrpt->rxchanname,AST_FORMAT_SLINEAR,tele);
 379         if (myrpt->rxchannel)
 380         {
 381                 ast_set_read_format(myrpt->rxchannel,AST_FORMAT_SLINEAR);
 382                 ast_set_write_format(myrpt->rxchannel,AST_FORMAT_SLINEAR);
 383                 myrpt->rxchannel->whentohangup = 0;
 384                 myrpt->rxchannel->appl = "Apprpt";
 385                 myrpt->rxchannel->data = "(Repeater Rx)";
 386                 if (option_verbose > 2)
 387                         ast_verbose(VERBOSE_PREFIX_3 "rpt (Rx) initiating call to %s/%s on %s\n",
 388                                 myrpt->rxchanname,tele,myrpt->rxchannel->name);
 389                 ast_call(myrpt->rxchannel,tele,999);
 390         }
 391         else
 392         {
 393                 fprintf(stderr,"rpt:Sorry unable to obtain channel\n");
 394                 pthread_exit(NULL);
 395         }
 396         if (myrpt->txchanname)
 397         {
 398                 tele = strchr(myrpt->txchanname,'/');
 399                 if (!tele)
 400                 {
 401                         fprintf(stderr,"rpt:Dial number must be in format tech/number\n");
 402                         pthread_exit(NULL);
 403                 }
 404                 *tele++ = 0;
 405                 myrpt->txchannel = ast_request(myrpt->txchanname,AST_FORMAT_SLINEAR,tele);
 406                 if (myrpt->txchannel)
 407                 {
 408                         ast_set_read_format(myrpt->txchannel,AST_FORMAT_SLINEAR);
 409                         ast_set_write_format(myrpt->txchannel,AST_FORMAT_SLINEAR);
 410                         myrpt->txchannel->whentohangup = 0;
 411                         myrpt->txchannel->appl = "Apprpt";
 412                         myrpt->txchannel->data = "(Repeater Rx)";
 413                         if (option_verbose > 2)
 414                                 ast_verbose(VERBOSE_PREFIX_3 "rpt (Tx) initiating call to %s/%s on %s\n",
 415                                         myrpt->txchanname,tele,myrpt->txchannel->name);
 416                         ast_call(myrpt->txchannel,tele,999);
 417                 }
 418                 else
 419                 {
 420                         fprintf(stderr,"rpt:Sorry unable to obtain channel\n");
 421                         pthread_exit(NULL);
 422                 }
 423         }
 424         else
 425         {
 426                 myrpt->txchannel = myrpt->rxchannel;
 427         }
 428         /* allocate a pseudo-channel thru asterisk */
 429         myrpt->pchannel = ast_request("zap",AST_FORMAT_SLINEAR,"pseudo");
 430         if (!myrpt->pchannel)
 431         {
 432                 fprintf(stderr,"rpt:Sorry unable to obtain pseudo channel\n");
 433                 pthread_exit(NULL);
 434         }
 435         /* make a conference for the tx */
 436         ci.chan = 0;
 437         ci.confno = -1; /* make a new conf */
 438         ci.confmode = ZT_CONF_CONF | ZT_CONF_LISTENER;
 439         /* first put the channel on the conference in announce mode */
 440         if (ioctl(myrpt->txchannel->fds[0],ZT_SETCONF,&ci) == -1)
 441         {
 442                 ast_log(LOG_WARNING, "Unable to set conference mode to Announce\n");
 443                 pthread_exit(NULL);
 444         }
 445         /* save tx conference number */
 446         myrpt->txconf = ci.confno;
 447         /* make a conference for the pseudo */
 448         ci.chan = 0;
 449         ci.confno = -1; /* make a new conf */
 450         ci.confmode = ZT_CONF_CONFANNMON;
 451         /* first put the channel on the conference in announce mode */
 452         if (ioctl(myrpt->pchannel->fds[0],ZT_SETCONF,&ci) == -1)
 453         {
 454                 ast_log(LOG_WARNING, "Unable to set conference mode to Announce\n");
 455                 pthread_exit(NULL);
 456         }
 457         /* save pseudo channel conference number */
 458         myrpt->pconf = ci.confno;
 459         /* Now, the idea here is to copy from the physical rx channel buffer
 460            into the pseudo tx buffer, and from the pseudo rx buffer into the
 461            tx channel buffer */
 462         myrpt->tailtimer = 0;
 463         myrpt->totimer = 0;
 464         myrpt->idtimer = 0;
 465         lasttx = 0;
 466         keyed = 0;
 467         myrpt->callmode = 0;
 468         val = 0;
 469         ast_channel_setoption(myrpt->rxchannel,AST_OPTION_TONE_VERIFY,&val,sizeof(char),0);
 470         val = 1;
 471         ast_channel_setoption(myrpt->rxchannel,AST_OPTION_RELAXDTMF,&val,sizeof(char),0);
 472         while (ms >= 0)
 473         {
 474                 struct ast_frame *f;
 475                 struct ast_channel *cs[3];
 476                 int totx,elap;
 477
 478                 totx = (keyed || myrpt->callmode || myrpt->iding || myrpt->terming);
 479                 if (!totx) myrpt->totimer = myrpt->totime;
 480                 else myrpt->tailtimer = myrpt->hangtime;
 481                 totx = (totx || myrpt->tailtimer) && myrpt->totimer;
 482                 /* if wants to transmit and in phone call, but timed out,
 483                         reset time-out timer if keyed */
 484                 if ((!totx) && (!myrpt->totimer) && myrpt->callmode && keyed)
 485                 {
 486                         myrpt->totimer = myrpt->totime;
 487                         continue;
 488                 }
 489                 if (totx && (!myrpt->idtimer))
 490                 {
 491                         myrpt->idtimer = myrpt->idtime;
 492                         pthread_attr_init(&attr);
 493                         pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
 494                         pthread_create(&myrpt->rpt_id_thread,&attr,rpt_id,(void *) myrpt);
 495                 }
 496                 if (totx && (!lasttx))
 497                 {
 498                         lasttx = 1;
 499                         ast_indicate(myrpt->txchannel,AST_CONTROL_RADIO_KEY);
 500                 }
 501                 if ((!totx) && lasttx)
 502                 {
 503                         lasttx = 0;
 504                         ast_indicate(myrpt->txchannel,AST_CONTROL_RADIO_UNKEY);
 505                 }
 506
 507                 cs[0] = myrpt->rxchannel;
 508                 cs[1] = myrpt->pchannel;
 509                 cs[2] = myrpt->txchannel;
 510                 ms = MSWAIT;
 511                 who = ast_waitfor_n(cs,3,&ms);
 512                 if (who == NULL) ms = 0;
 513                 elap = MSWAIT - ms;
 514                 if (myrpt->tailtimer) myrpt->tailtimer -= elap;
 515                 if (myrpt->tailtimer < 0) myrpt->tailtimer = 0;
 516                 if (myrpt->totimer) myrpt->totimer -= elap;
 517                 if (myrpt->totimer < 0) myrpt->totimer = 0;
 518                 if (myrpt->idtimer) myrpt->idtimer -= elap;
 519                 if (myrpt->idtimer < 0) myrpt->idtimer = 0;
 520                 if (!ms) continue;
 521                 if (who == myrpt->rxchannel) /* if it was a read from rx */
 522                 {
 523                         f = ast_read(myrpt->rxchannel);
 524                         if (!f)
 525                         {
 526                                 if (debug) printf("@@@@ rpt:Hung Up\n");
 527                                 break;
 528                         }
 529                         if (f->frametype == AST_FRAME_VOICE)
 530                         {
 531                                 ast_write(myrpt->pchannel,f);
 532                         }
 533                         else if (f->frametype == AST_FRAME_DTMF)
 534                         {
 535                                 char c;
 536
 537                                 c = (char) f->subclass; /* get DTMF char */
 538                                 if ((!myrpt->callmode) && (c == '*'))
 539                                 {
 540                                         myrpt->callmode = 1;
 541                                         myrpt->cidx = 0;
 542                                         myrpt->exten[myrpt->cidx] = 0;
 543                                         pthread_attr_init(&attr);
 544                                         pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
 545                                         pthread_create(&myrpt->rpt_call_thread,&attr,rpt_call,(void *)myrpt);
 546                                         continue;
 547                                 }
 548                                 if (myrpt->callmode && (c == '#'))
 549                                 {
 550                                         myrpt->callmode = 0;
 551                                         pthread_attr_init(&attr);
 552                                         pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
 553                                         pthread_create(&myrpt->rpt_term_thread,&attr,rpt_term,(void *) myrpt);
 554                                         continue;
 555                                 }
 556                                 if (myrpt->callmode == 1)
 557                                 {
 558                                         myrpt->exten[myrpt->cidx++] = c;
 559                                         myrpt->exten[myrpt->cidx] = 0;
 560                                         /* if this exists */
 561                                         if (ast_exists_extension(myrpt->pchannel,myrpt->ourcontext,myrpt->exten,1,NULL))
 562                                         {
 563                                                 myrpt->callmode = 2;
 564                                                 pthread_attr_init(&attr);
 565                                                 pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
 566                                                 pthread_create(&myrpt->rpt_proc_thread,&attr,rpt_proc,(void *) myrpt);
 567                                         }
 568                                         /* if can continue, do so */
 569                                         if (ast_canmatch_extension(myrpt->pchannel,myrpt->ourcontext,myrpt->exten,1,NULL)) continue;
 570                                         /* call has failed, inform user */
 571                                         myrpt->callmode = 4;
 572                                         continue;
 573                                 }
 574                                 if ((myrpt->callmode == 2) || (myrpt->callmode == 3))
 575                                 {
 576                                         myrpt->mydtmf = f->subclass;
 577                                 }
 578                         }
 579                         else if (f->frametype == AST_FRAME_CONTROL)
 580                         {
 581                                 if (f->subclass == AST_CONTROL_HANGUP)
 582                                 {
 583                                         if (debug) printf("@@@@ rpt:Hung Up\n");
 584                                         ast_frfree(f);
 585                                         break;
 586                                 }
 587                                 /* if RX key */
 588                                 if (f->subclass == AST_CONTROL_RADIO_KEY)
 589                                 {
 590                                         if (debug) printf("@@@@ rx key\n");
 591                                         keyed = 1;
 592                                 }
 593                                 /* if RX un-key */
 594                                 if (f->subclass == AST_CONTROL_RADIO_UNKEY)
 595                                 {
 596                                         if (debug) printf("@@@@ rx un-key\n");
 597                                         keyed = 0;
 598                                 }
 599                         }
 600                         ast_frfree(f);
 601                 }
 602                 if (who == myrpt->pchannel) /* if it was a read from pseudo */
 603                 {
 604                         f = ast_read(myrpt->pchannel);
 605                         if (!f)
 606                         {
 607                                 if (debug) printf("@@@@ rpt:Hung Up\n");
 608                                 break;
 609                         }
 610                         if (f->frametype == AST_FRAME_VOICE)
 611                         {
 612                                 ast_write(myrpt->txchannel,f);
 613                         }
 614                         if (f->frametype == AST_FRAME_CONTROL)
 615                         {
 616                                 if (f->subclass == AST_CONTROL_HANGUP)
 617                                 {
 618                                         if (debug) printf("@@@@ rpt:Hung Up\n");
 619                                         ast_frfree(f);
 620                                         break;
 621                                 }
 622                         }
 623                         ast_frfree(f);
 624                 }
 625                 if (who == myrpt->txchannel) /* if it was a read from tx */
 626                 {
 627                         f = ast_read(myrpt->txchannel);
 628                         if (!f)
 629                         {
 630                                 if (debug) printf("@@@@ rpt:Hung Up\n");
 631                                 break;
 632                         }
 633                         if (f->frametype == AST_FRAME_CONTROL)
 634                         {
 635                                 if (f->subclass == AST_CONTROL_HANGUP)
 636                                 {
 637                                         if (debug) printf("@@@@ rpt:Hung Up\n");
 638                                         ast_frfree(f);
 639                                         break;
 640                                 }
 641                         }
 642                         ast_frfree(f);
 643                 }
 644
 645         }
 646         ast_hangup(myrpt->pchannel);
 647         ast_hangup(myrpt->rxchannel);
 648         ast_hangup(myrpt->txchannel);
 649         if (debug) printf("@@@@ rpt:Hung up channel\n");
 650         pthread_exit(NULL);
 651         return NULL;
 652 }
 653
 654 static void *rpt_master(void *ignore)
 655 {
 656 struct  ast_config *cfg;
 657 char *this,*val;
 658 int     i,n;
 659
 660         /* start with blank config */
 661         memset(&rpt_vars,0,sizeof(rpt_vars));
 662
 663         cfg = ast_load("rpt.conf");
 664         if (!cfg) {
 665                 ast_log(LOG_NOTICE, "Unable to open radio repeater configuration rpt.conf.  Radio Repeater disabled.\n");
 666                 pthread_exit(NULL);
 667         }
 668
 669         /* go thru all the specified repeaters */
 670         this = NULL;
 671         n = 0;
 672         while((this = ast_category_browse(cfg,this)) != NULL)
 673         {
 674                 ast_log(LOG_DEBUG,"Loading config for repeater %s\n",this);
 675                 rpt_vars[n].name = this;
 676                 rpt_vars[n].rxchanname = ast_variable_retrieve(cfg,this,"rxchannel");
 677                 rpt_vars[n].txchanname = ast_variable_retrieve(cfg,this,"txchannel");
 678                 rpt_vars[n].ourcontext = ast_variable_retrieve(cfg,this,"context");
 679                 if (!rpt_vars[n].ourcontext) rpt_vars[n].ourcontext = this;
 680                 rpt_vars[n].ourcallerid = ast_variable_retrieve(cfg,this,"callerid");
 681                 rpt_vars[n].acctcode = ast_variable_retrieve(cfg,this,"accountcode");
 682                 rpt_vars[n].idrecording = ast_variable_retrieve(cfg,this,"idrecording");
 683                 val = ast_variable_retrieve(cfg,this,"hangtime");
 684                 if (val) rpt_vars[n].hangtime = atoi(val);
 685                         else rpt_vars[n].hangtime = HANGTIME;
 686                 val = ast_variable_retrieve(cfg,this,"totime");
 687                 if (val) rpt_vars[n].totime = atoi(val);
 688                         else rpt_vars[n].totime = TOTIME;
 689                 val = ast_variable_retrieve(cfg,this,"idtime");
 690                 if (val) rpt_vars[n].idtime = atoi(val);
 691                         else rpt_vars[n].idtime = IDTIME;
 692                 n++;
 693         }
 694         ast_log(LOG_DEBUG, "Total of %d repeaters configured.\n",n);
 695         /* start em all */
 696         for(i = 0; i < n; i++)
 697         {
 698                 if (!rpt_vars[i].rxchanname)
 699                 {
 700                         ast_log(LOG_WARNING,"Did not specify rxchanname for repeater %s\n",rpt_vars[i].name);
 701                         pthread_exit(NULL);
 702                 }
 703                 if (!rpt_vars[i].idrecording)
 704                 {
 705                         ast_log(LOG_WARNING,"Did not specify idrecording for repeater %s\n",rpt_vars[i].name);
 706                         pthread_exit(NULL);
 707                 }
 708                 pthread_create(&rpt_vars[i].rpt_id_thread,NULL,rpt,(void *) &rpt_vars[i]);
 709         }
 710         /* wait for first one to die (should be never) */
 711         pthread_join(rpt_vars[0].rpt_id_thread,NULL);
 712         pthread_exit(NULL);
 713 }
 714
 715 int unload_module(void)
 716 {
 717         STANDARD_HANGUP_LOCALUSERS;
 718         return 0;
 719 }
 720
 721 int load_module(void)
 722 {
 723         pthread_create(&rpt_master_thread,NULL,rpt_master,NULL);
 724         return 0;
 725 }
 726
 727 char *description(void)
 728 {
 729         return tdesc;
 730 }
 731
 732 int usecount(void)
 733 {
 734         int res;
 735         STANDARD_USECOUNT(res);
 736         return res;
 737 }
 738
 739 char *key()
 740 {
 741         return ASTERISK_GPL_KEY;
 742 }