Added support for Doug Hall RBI-1 Remote base controller, memory channels for
[asterisk/asterisk.git] / apps / app_rpt.c
1 /** @file app_rpt.c 
2  *
3  * Asterisk -- A telephony toolkit for Linux.
4  *
5  * Radio Repeater / Remote Base program 
6  *  version 0.8 6/26/04
7  * 
8  * Copyright (C) 2002-2004, Jim Dixon, WB6NIL
9  *
10  * Jim Dixon, WB6NIL <jim@lambdatel.com>
11  *
12  * This program is free software, distributed under the terms of
13  * the GNU General Public License
14  *
15  * Repeater / Remote Functions:
16  * "Simple" Mode:  * - autopatch access, # - autopatch hangup
17  * Normal mode:
18  *  *0 - autopatch off
19  *  *1XXX - remote link off
20  *  *2XXX - remote link monitor
21  *  *3XXX - remote link tranceive
22  *  *4XXX - remote link command mode
23  *  *6 - autopatch access/send (*)
24  *  *7 - system status
25  *  *8 - force ID
26  *  *90 - system disable (and reset)
27  *  *91 - system enable
28  *  *99 - system reset
29  *
30  *  To send an asterisk (*) while dialing or talking on phone,
31  *  use the autopatch acess code.
32  *
33  *
34  * Remote cmds:
35  *
36  *  *0 - Recall Memory MM  (*000-*099) (Gets memory from rpt.conf)
37  *  *1 - Set VFO MMMMM*KKK*O   (Mhz digits, Khz digits, Offset)
38  *  *2 - Set Rx PL Tone HHH*D*
39  *  *3 - Set Tx PL Tone HHH*D*
40  *  *40 - RX PL off (Default)
41  *  *41 - RX PL On
42  *  *42 - TX PL Off (Default)
43  *  *43 - TX PL On
44  *  *44 - Low Power
45  *  *45 - Med Power
46  *  *46 - Hi Power
47  *
48 */
49  
50 /* number of digits for function after *. Must be at least 1 */
51 #define FUNCTION_LEN 4
52 /* string containing all of the 1 digit functions */
53 #define SHORTFUNCS "05678"
54 /* string containing all of the 2 digit functions */
55 #define MEDFUNCS "9"
56
57 /* maximum digits in DTMF buffer, and seconds after * for DTMF command timeout */
58
59 #define MAXDTMF 10
60 #define DTMF_TIMEOUT 3
61
62 #define MAXREMSTR 15
63
64 #define NODES "nodes"
65 #define MEMORY "memory"
66
67 #define DEFAULT_IOBASE 0x378
68
69 #define MAXCONNECTTIME 5000
70
71 #define MAXNODESTR 300
72
73 enum {REM_OFF,REM_MONITOR,REM_TX};
74
75 enum{ID,PROC,TERM,COMPLETE,UNKEY,REMDISC,REMALREADY,REMNOTFOUND,REMGO,
76         CONNECTED,CONNFAIL,STATUS,TIMEOUT};
77
78 enum {REM_SIMPLEX,REM_MINUS,REM_PLUS};
79
80 enum {REM_LOWPWR,REM_MEDPWR,REM_HIPWR};
81
82 #include <asterisk/lock.h>
83 #include <asterisk/file.h>
84 #include <asterisk/logger.h>
85 #include <asterisk/channel.h>
86 #include <asterisk/callerid.h>
87 #include <asterisk/pbx.h>
88 #include <asterisk/module.h>
89 #include <asterisk/translate.h>
90 #include <asterisk/options.h>
91 #include <asterisk/config.h>
92 #include <asterisk/utils.h>
93 #include <asterisk/say.h>
94 #include <stdio.h>
95 #include <unistd.h>
96 #include <string.h>
97 #include <stdlib.h>
98 #include <search.h>
99 #include <sys/types.h>
100 #include <sys/stat.h>
101 #include <errno.h>
102 #include <dirent.h>
103 #include <ctype.h>
104 #include <sys/stat.h>
105 #include <sys/time.h>
106 #include <sys/file.h>
107 #include <sys/ioctl.h>
108 #include <sys/io.h>
109 #include <math.h>
110 #include <tonezone.h>
111 #include <linux/zaptel.h>
112
113 static  char *tdesc = "Radio Repeater / Remote Base  version 0.8  06/26/2004";
114 static char *app = "Rpt";
115
116 static char *synopsis = "Radio Repeater/Remote Base Control System";
117
118 static char *descrip = 
119 "  Rpt(sysname):  Radio Remote Link or Remote Base Link Endpoint Process.\n";
120
121 static int debug = 0;
122 static int nrpts = 0;
123
124 struct  ast_config *cfg;
125
126 STANDARD_LOCAL_USER;
127 LOCAL_USER_DECL;
128
129 #define MSWAIT 200
130 #define HANGTIME 5000
131 #define TOTIME 180000
132 #define IDTIME 300000
133 #define MAXRPTS 20
134
135 static  pthread_t rpt_master_thread;
136
137 struct rpt;
138
139 struct rpt_link
140 {
141         struct rpt_link *next;
142         struct rpt_link *prev;
143         char    mode;                   /* 1 if in tx mode */
144         char    isremote;
145         char    name[MAXNODESTR];       /* identifier (routing) string */
146         char    lasttx;
147         char    lastrx;
148         char    connected;
149         char    outbound;
150         long elaptime;
151         struct ast_channel *chan;       
152         struct ast_channel *pchan;      
153 } ;
154
155 struct rpt_tele
156 {
157         struct rpt_tele *next;
158         struct rpt_tele *prev;
159         struct rpt *rpt;
160         int     mode;
161         struct rpt_link mylink;
162         pthread_t threadid;
163 } ;
164
165 static struct rpt
166 {
167         char *name;
168         ast_mutex_t lock;
169         char *rxchanname;
170         char *txchanname;
171         char *ourcontext;
172         char *ourcallerid;
173         char *acctcode;
174         char *ident;
175         char *tonezone;
176         struct rpt_link links;
177         int hangtime;
178         int totime;
179         int idtime;
180         char exttx;
181         char localtx;
182         char remoterx;
183         char remotetx;
184         char remoteon;
185         char simple;
186         char remote;
187         char tounkeyed;
188         char tonotify;
189         char enable;
190         char dtmfbuf[MAXDTMF];
191         char rem_dtmfbuf[MAXDTMF];
192         char cmdnode[50];
193         struct ast_channel *rxchannel,*txchannel;
194         struct ast_channel *pchannel,*txpchannel;
195         struct rpt_tele tele;
196         pthread_t rpt_call_thread,rpt_thread;
197         time_t rem_dtmf_time,dtmf_time_rem;
198         int tailtimer,totimer,idtimer,txconf,conf,callmode,cidx;
199         int dtmfidx,rem_dtmfidx;
200         char mydtmf;
201         int iobase;
202         char exten[AST_MAX_EXTENSION];
203         char freq[MAXREMSTR],rxpl[MAXREMSTR],txpl[MAXREMSTR];
204         char offset;
205         char powerlevel;
206         char txplon;
207         char rxplon;
208 } rpt_vars[MAXRPTS];            
209
210 static void *rpt_tele_thread(void *this)
211 {
212 ZT_CONFINFO ci;  /* conference info */
213 int     res = 0,hastx,imdone = 0;
214 struct  rpt_tele *mytele = (struct rpt_tele *)this;
215 struct  rpt *myrpt;
216 struct  rpt_link *l,*m,linkbase;
217 struct  ast_channel *mychannel;
218
219         /* get a pointer to myrpt */
220         myrpt = mytele->rpt;
221         /* allocate a pseudo-channel thru asterisk */
222         mychannel = ast_request("zap",AST_FORMAT_SLINEAR,"pseudo");
223         if (!mychannel)
224         {
225                 fprintf(stderr,"rpt:Sorry unable to obtain pseudo channel\n");
226                 ast_mutex_lock(&myrpt->lock);
227                 remque((struct qelem *)mytele);
228                 ast_mutex_unlock(&myrpt->lock);
229                 free(mytele);           
230                 pthread_exit(NULL);
231         }
232         /* make a conference for the tx */
233         ci.chan = 0;
234         ci.confno = myrpt->conf; /* use the tx conference */
235         ci.confmode = ZT_CONF_CONFANN;
236         /* first put the channel on the conference in announce mode */
237         if (ioctl(mychannel->fds[0],ZT_SETCONF,&ci) == -1)
238         {
239                 ast_log(LOG_WARNING, "Unable to set conference mode to Announce\n");
240                 ast_mutex_lock(&myrpt->lock);
241                 remque((struct qelem *)mytele);
242                 ast_mutex_unlock(&myrpt->lock);
243                 free(mytele);           
244                 ast_hangup(mychannel);
245                 pthread_exit(NULL);
246         }
247         ast_stopstream(mychannel);
248         switch(mytele->mode)
249         {
250             case ID:
251                 res = ast_streamfile(mychannel, myrpt->ident, mychannel->language);
252                 break;
253             case PROC:
254                 /* wait a little bit longer */
255                 usleep(1500000);
256                 res = ast_streamfile(mychannel, "rpt/callproceeding", mychannel->language);
257                 break;
258             case TERM:
259                 /* wait a little bit longer */
260                 usleep(1500000);
261                 res = ast_streamfile(mychannel, "rpt/callterminated", mychannel->language);
262                 break;
263             case COMPLETE:
264                 /* wait a little bit */
265                 usleep(1000000);
266                 res = ast_streamfile(mychannel, "rpt/functioncomplete", mychannel->language);
267                 break;
268             case UNKEY:
269                 /* wait a little bit */
270                 usleep(1000000);
271                 hastx = 0;
272                 l = myrpt->links.next;
273                 if (l != &myrpt->links)
274                 {
275                         ast_mutex_lock(&myrpt->lock);
276                         while(l != &myrpt->links)
277                         {
278                                 if (l->mode) hastx++;
279                                 l = l->next;
280                         }
281                         ast_mutex_unlock(&myrpt->lock);
282                         res = ast_streamfile(mychannel, 
283                                 ((!hastx) ? "rpt/remote_monitor" : "rpt/remote_tx"),
284                                         mychannel->language);
285                         if (!res) 
286                                 res = ast_waitstream(mychannel, "");
287                         else
288                                  ast_log(LOG_WARNING, "ast_streamfile failed on %s\n", mychannel->name);
289                         ast_stopstream(mychannel);
290                 } 
291                 /* if in remote cmd mode, indicate it */
292                 if (myrpt->cmdnode[0])
293                 {
294                         ast_safe_sleep(mychannel,200);
295                         res = ast_streamfile(mychannel, "rpt/remote_cmd", mychannel->language);
296                         if (!res) 
297                                 res = ast_waitstream(mychannel, "");
298                         else
299                                  ast_log(LOG_WARNING, "ast_streamfile failed on %s\n", mychannel->name);
300                         ast_stopstream(mychannel);
301                 }
302                 imdone = 1;
303                 break;
304             case REMDISC:
305                 /* wait a little bit */
306                 usleep(1000000);
307                 res = ast_streamfile(mychannel, "rpt/node", mychannel->language);
308                 if (!res) 
309                         res = ast_waitstream(mychannel, "");
310                 else
311                          ast_log(LOG_WARNING, "ast_streamfile failed on %s\n", mychannel->name);
312                 ast_stopstream(mychannel);
313                 ast_say_character_str(mychannel,mytele->mylink.name,NULL,mychannel->language);
314                 res = ast_streamfile(mychannel, ((mytele->mylink.connected) ? 
315                         "rpt/remote_disc" : "rpt/remote_busy"), mychannel->language);
316                 break;
317             case REMALREADY:
318                 /* wait a little bit */
319                 usleep(1000000);
320                 res = ast_streamfile(mychannel, "rpt/remote_already", mychannel->language);
321                 break;
322             case REMNOTFOUND:
323                 /* wait a little bit */
324                 usleep(1000000);
325                 res = ast_streamfile(mychannel, "rpt/remote_notfound", mychannel->language);
326                 break;
327             case REMGO:
328                 /* wait a little bit */
329                 usleep(1000000);
330                 res = ast_streamfile(mychannel, "rpt/remote_go", mychannel->language);
331                 break;
332             case CONNECTED:
333                 /* wait a little bit */
334                 usleep(1000000);
335                 res = ast_streamfile(mychannel, "rpt/node", mychannel->language);
336                 if (!res) 
337                         res = ast_waitstream(mychannel, "");
338                 else
339                          ast_log(LOG_WARNING, "ast_streamfile failed on %s\n", mychannel->name);
340                 ast_stopstream(mychannel);
341                 ast_say_character_str(mychannel,mytele->mylink.name,NULL,mychannel->language);
342                 res = ast_streamfile(mychannel, "rpt/connected", mychannel->language);
343                 break;
344             case CONNFAIL:
345                 res = ast_streamfile(mychannel, "rpt/node", mychannel->language);
346                 if (!res) 
347                         res = ast_waitstream(mychannel, "");
348                 else
349                          ast_log(LOG_WARNING, "ast_streamfile failed on %s\n", mychannel->name);
350                 ast_stopstream(mychannel);
351                 ast_say_character_str(mychannel,mytele->mylink.name,NULL,mychannel->language);
352                 res = ast_streamfile(mychannel, "rpt/connection_failed", mychannel->language);
353                 break;
354             case STATUS:
355                 /* wait a little bit */
356                 usleep(1000000);
357                 hastx = 0;
358                 linkbase.next = &linkbase;
359                 linkbase.prev = &linkbase;
360                 ast_mutex_lock(&myrpt->lock);
361                 /* make our own list of links */
362                 l = myrpt->links.next;
363                 while(l != &myrpt->links)
364                 {
365                         m = malloc(sizeof(struct rpt_link));
366                         if (!m)
367                         {
368                                 ast_log(LOG_WARNING, "Cannot alloc memory on %s\n", mychannel->name);
369                                 pthread_exit(NULL);
370                         }
371                         memcpy(m,l,sizeof(struct rpt_link));
372                         m->next = m->prev = NULL;
373                         insque((struct qelem *)m,(struct qelem *)linkbase.next);
374                         l = l->next;
375                 }
376                 ast_mutex_unlock(&myrpt->lock);
377                 res = ast_streamfile(mychannel, "rpt/node", mychannel->language);
378                 if (!res) 
379                         res = ast_waitstream(mychannel, "");
380                 else
381                          ast_log(LOG_WARNING, "ast_streamfile failed on %s\n", mychannel->name);
382                 ast_stopstream(mychannel);
383                 ast_say_character_str(mychannel,myrpt->name,NULL,mychannel->language);
384                 if (!res) 
385                         res = ast_waitstream(mychannel, "");
386                 else
387                          ast_log(LOG_WARNING, "ast_streamfile failed on %s\n", mychannel->name);
388                 ast_stopstream(mychannel);
389                 if (myrpt->callmode)
390                 {
391                         hastx = 1;
392                         res = ast_streamfile(mychannel, "rpt/autopatch_on", mychannel->language);
393                         if (!res) 
394                                 res = ast_waitstream(mychannel, "");
395                         else
396                                  ast_log(LOG_WARNING, "ast_streamfile failed on %s\n", mychannel->name);
397                         ast_stopstream(mychannel);
398                 }
399                 l = linkbase.next;
400                 while(l != &linkbase)
401                 {
402                         hastx = 1;
403                         res = ast_streamfile(mychannel, "rpt/node", mychannel->language);
404                         if (!res) 
405                                 res = ast_waitstream(mychannel, "");
406                         else
407                                 ast_log(LOG_WARNING, "ast_streamfile failed on %s\n", mychannel->name);
408                         ast_stopstream(mychannel);
409                         ast_say_character_str(mychannel,l->name,NULL,mychannel->language);
410                         if (!res) 
411                                 res = ast_waitstream(mychannel, "");
412                         else
413                                  ast_log(LOG_WARNING, "ast_streamfile failed on %s\n", mychannel->name);
414                         ast_stopstream(mychannel);
415                         res = ast_streamfile(mychannel, ((l->mode) ? 
416                                 "rpt/tranceive" : "rpt/monitor"), mychannel->language);
417                         if (!res) 
418                                 res = ast_waitstream(mychannel, "");
419                         else
420                                 ast_log(LOG_WARNING, "ast_streamfile failed on %s\n", mychannel->name);
421                         ast_stopstream(mychannel);
422                         l = l->next;
423                 }                       
424                 if (!hastx)
425                 {
426                         res = ast_streamfile(mychannel, "rpt/repeat_only", mychannel->language);
427                         if (!res) 
428                                 res = ast_waitstream(mychannel, "");
429                         else
430                                  ast_log(LOG_WARNING, "ast_streamfile failed on %s\n", mychannel->name);
431                         ast_stopstream(mychannel);
432                 }
433                 /* destroy our local link queue */
434                 l = linkbase.next;
435                 while(l != &linkbase)
436                 {
437                         m = l;
438                         l = l->next;
439                         remque((struct qelem *)m);
440                         free(m);
441                 }                       
442                 imdone = 1;
443                 break;
444             case TIMEOUT:
445                 res = ast_streamfile(mychannel, "rpt/node", mychannel->language);
446                 if (!res) 
447                         res = ast_waitstream(mychannel, "");
448                 else
449                          ast_log(LOG_WARNING, "ast_streamfile failed on %s\n", mychannel->name);
450                 ast_stopstream(mychannel);
451                 ast_say_character_str(mychannel,myrpt->name,NULL,mychannel->language);
452                 res = ast_streamfile(mychannel, "rpt/timeout", mychannel->language);
453                 break;
454         }
455         if (!imdone)
456         {
457                 if (!res) 
458                         res = ast_waitstream(mychannel, "");
459                 else {
460                         ast_log(LOG_WARNING, "ast_streamfile failed on %s\n", mychannel->name);
461                         res = 0;
462                 }
463         }
464         ast_stopstream(mychannel);
465         ast_mutex_lock(&myrpt->lock);
466         remque((struct qelem *)mytele);
467         ast_mutex_unlock(&myrpt->lock);
468         free(mytele);           
469         ast_hangup(mychannel);
470         pthread_exit(NULL);
471 }
472
473 static void rpt_telemetry(struct rpt *myrpt,int mode,struct rpt_link *mylink)
474 {
475 struct rpt_tele *tele;
476 pthread_attr_t attr;
477
478         tele = malloc(sizeof(struct rpt_tele));
479         if (!tele)
480         {
481                 ast_log(LOG_WARNING, "Unable to allocate memory\n");
482                 pthread_exit(NULL);
483                 return;
484         }
485         /* zero it out */
486         memset((char *)tele,0,sizeof(struct rpt_tele));
487         tele->rpt = myrpt;
488         tele->mode = mode;
489         ast_mutex_lock(&myrpt->lock);
490         memset(&tele->mylink,0,sizeof(struct rpt_link));
491         if (mylink)
492         {
493                 memcpy(&tele->mylink,mylink,sizeof(struct rpt_link));
494         }               
495         insque((struct qelem *)tele,(struct qelem *)myrpt->tele.next); 
496         ast_mutex_unlock(&myrpt->lock);
497         pthread_attr_init(&attr);
498         pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
499         pthread_create(&tele->threadid,&attr,rpt_tele_thread,(void *) tele);
500         return;
501 }
502
503 static int sayfile(struct ast_channel *mychannel,char *fname)
504 {
505 int     res;
506
507         res = ast_streamfile(mychannel, fname, mychannel->language);
508         if (!res) 
509                 res = ast_waitstream(mychannel, "");
510         else
511                  ast_log(LOG_WARNING, "ast_streamfile failed on %s\n", mychannel->name);
512         ast_stopstream(mychannel);
513         return res;
514 }
515
516 static int saycharstr(struct ast_channel *mychannel,char *str)
517 {
518 int     res;
519
520         res = ast_say_character_str(mychannel,str,NULL,mychannel->language);
521         if (!res) 
522                 res = ast_waitstream(mychannel, "");
523         else
524                  ast_log(LOG_WARNING, "ast_streamfile failed on %s\n", mychannel->name);
525         ast_stopstream(mychannel);
526         return res;
527 }
528
529 static void *rpt_call(void *this)
530 {
531 ZT_CONFINFO ci;  /* conference info */
532 struct  rpt *myrpt = (struct rpt *)this;
533 int     res;
534 struct  ast_frame *f,wf;
535 int stopped,congstarted;
536 struct ast_channel *mychannel,*genchannel;
537
538         myrpt->mydtmf = 0;
539         /* allocate a pseudo-channel thru asterisk */
540         mychannel = ast_request("zap",AST_FORMAT_SLINEAR,"pseudo");
541         if (!mychannel)
542         {
543                 fprintf(stderr,"rpt:Sorry unable to obtain pseudo channel\n");
544                 pthread_exit(NULL);
545         }
546         ci.chan = 0;
547         ci.confno = myrpt->conf; /* use the pseudo conference */
548         ci.confmode = ZT_CONF_REALANDPSEUDO | ZT_CONF_TALKER | ZT_CONF_LISTENER
549                 | ZT_CONF_PSEUDO_TALKER | ZT_CONF_PSEUDO_LISTENER; 
550         /* first put the channel on the conference */
551         if (ioctl(mychannel->fds[0],ZT_SETCONF,&ci) == -1)
552         {
553                 ast_log(LOG_WARNING, "Unable to set conference mode to Announce\n");
554                 ast_hangup(mychannel);
555                 myrpt->callmode = 0;
556                 pthread_exit(NULL);
557         }
558         /* allocate a pseudo-channel thru asterisk */
559         genchannel = ast_request("zap",AST_FORMAT_SLINEAR,"pseudo");
560         if (!genchannel)
561         {
562                 fprintf(stderr,"rpt:Sorry unable to obtain pseudo channel\n");
563                 ast_hangup(mychannel);
564                 pthread_exit(NULL);
565         }
566         ci.chan = 0;
567         ci.confno = myrpt->conf;
568         ci.confmode = ZT_CONF_REALANDPSEUDO | ZT_CONF_TALKER | ZT_CONF_LISTENER
569                 | ZT_CONF_PSEUDO_TALKER | ZT_CONF_PSEUDO_LISTENER; 
570         /* first put the channel on the conference */
571         if (ioctl(genchannel->fds[0],ZT_SETCONF,&ci) == -1)
572         {
573                 ast_log(LOG_WARNING, "Unable to set conference mode to Announce\n");
574                 ast_hangup(mychannel);
575                 ast_hangup(genchannel);
576                 myrpt->callmode = 0;
577                 pthread_exit(NULL);
578         }
579         if (myrpt->tonezone && (tone_zone_set_zone(mychannel->fds[0],myrpt->tonezone) == -1))
580         {
581                 ast_log(LOG_WARNING, "Unable to set tone zone %s\n",myrpt->tonezone);
582                 ast_hangup(mychannel);
583                 ast_hangup(genchannel);
584                 myrpt->callmode = 0;
585                 pthread_exit(NULL);
586         }
587         if (myrpt->tonezone && (tone_zone_set_zone(genchannel->fds[0],myrpt->tonezone) == -1))
588         {
589                 ast_log(LOG_WARNING, "Unable to set tone zone %s\n",myrpt->tonezone);
590                 ast_hangup(mychannel);
591                 ast_hangup(genchannel);
592                 myrpt->callmode = 0;
593                 pthread_exit(NULL);
594         }
595         /* start dialtone */
596         if (tone_zone_play_tone(mychannel->fds[0],ZT_TONE_DIALTONE) < 0)
597         {
598                 ast_log(LOG_WARNING, "Cannot start dialtone\n");
599                 ast_hangup(mychannel);
600                 ast_hangup(genchannel);
601                 myrpt->callmode = 0;
602                 pthread_exit(NULL);
603         }
604         stopped = 0;
605         congstarted = 0;
606         while ((myrpt->callmode == 1) || (myrpt->callmode == 4))
607         {
608
609                 if ((myrpt->callmode == 1) && (myrpt->cidx > 0) && (!stopped))
610                 {
611                         stopped = 1;
612                         /* stop dial tone */
613                         tone_zone_play_tone(mychannel->fds[0],-1);
614                 }
615                 if ((myrpt->callmode == 4) && (!congstarted))
616                 {
617                         congstarted = 1;
618                         /* start congestion tone */
619                         tone_zone_play_tone(mychannel->fds[0],ZT_TONE_CONGESTION);
620                 }
621                 res = ast_waitfor(mychannel, MSWAIT);
622                 if (res < 0)
623                 {
624                         ast_hangup(mychannel);
625                         ast_hangup(genchannel);
626                         ast_mutex_lock(&myrpt->lock);
627                         myrpt->callmode = 0;
628                         ast_mutex_unlock(&myrpt->lock);
629                         pthread_exit(NULL);
630                 }
631                 if (res == 0) continue;
632                 f = ast_read(mychannel);
633                 if (f == NULL) 
634                 {
635                         ast_hangup(mychannel);
636                         ast_hangup(genchannel);
637                         ast_mutex_lock(&myrpt->lock);
638                         myrpt->callmode = 0;
639                         ast_mutex_unlock(&myrpt->lock);
640                         pthread_exit(NULL);                     
641                 }
642                 if ((f->frametype == AST_FRAME_CONTROL) &&
643                     (f->subclass == AST_CONTROL_HANGUP))
644                 {
645                         ast_frfree(f);
646                         ast_hangup(mychannel);
647                         ast_hangup(genchannel);
648                         ast_mutex_lock(&myrpt->lock);
649                         myrpt->callmode = 0;
650                         ast_mutex_unlock(&myrpt->lock);
651                         pthread_exit(NULL);                     
652                 }
653                 ast_frfree(f);
654         }
655         /* stop any tone generation */
656         tone_zone_play_tone(mychannel->fds[0],-1);
657         /* end if done */
658         if (!myrpt->callmode)
659         {
660                 ast_hangup(mychannel);
661                 ast_hangup(genchannel);
662                 ast_mutex_lock(&myrpt->lock);
663                 myrpt->callmode = 0;
664                 ast_mutex_unlock(&myrpt->lock);
665                 pthread_exit(NULL);                     
666         }
667         if (myrpt->ourcallerid && *myrpt->ourcallerid)
668         {
669                 if (mychannel->callerid) free(mychannel->callerid);
670                 mychannel->callerid = strdup(myrpt->ourcallerid);
671         }
672         strcpy(mychannel->exten,myrpt->exten);
673         strcpy(mychannel->context,myrpt->ourcontext);
674         if (myrpt->acctcode)
675                 strcpy(mychannel->accountcode,myrpt->acctcode);
676         mychannel->priority = 1;
677         ast_channel_undefer_dtmf(mychannel);
678         if (ast_pbx_start(mychannel) < 0)
679         {
680                 ast_log(LOG_WARNING, "Unable to start PBX!!\n");
681                 ast_hangup(mychannel);
682                 ast_hangup(genchannel);
683                 ast_mutex_lock(&myrpt->lock);
684                 myrpt->callmode = 0;
685                 ast_mutex_unlock(&myrpt->lock);
686                 pthread_exit(NULL);
687         }
688         ast_mutex_lock(&myrpt->lock);
689         myrpt->callmode = 3;
690         while(myrpt->callmode)
691         {
692                 if ((!mychannel->pvt) && (myrpt->callmode != 4))
693                 {
694                         myrpt->callmode = 4;
695                         ast_mutex_unlock(&myrpt->lock);
696                         /* start congestion tone */
697                         tone_zone_play_tone(genchannel->fds[0],ZT_TONE_CONGESTION);
698                         ast_mutex_lock(&myrpt->lock);
699                 }
700                 if (myrpt->mydtmf)
701                 {
702                         wf.frametype = AST_FRAME_DTMF;
703                         wf.subclass = myrpt->mydtmf;
704                         wf.offset = 0;
705                         wf.mallocd = 0;
706                         wf.data = NULL;
707                         wf.datalen = 0;
708                         wf.samples = 0;
709                         ast_mutex_unlock(&myrpt->lock);
710                         ast_write(genchannel,&wf); 
711                         ast_mutex_lock(&myrpt->lock);
712                         myrpt->mydtmf = 0;
713                 }
714                 ast_mutex_unlock(&myrpt->lock);
715                 usleep(25000);
716                 ast_mutex_lock(&myrpt->lock);
717         }
718         ast_mutex_unlock(&myrpt->lock);
719         tone_zone_play_tone(genchannel->fds[0],-1);
720         if (mychannel->pvt) ast_softhangup(mychannel,AST_SOFTHANGUP_DEV);
721         ast_hangup(genchannel);
722         ast_mutex_lock(&myrpt->lock);
723         myrpt->callmode = 0;
724         ast_mutex_unlock(&myrpt->lock);
725         pthread_exit(NULL);
726 }
727
728 static void send_link_dtmf(struct rpt *myrpt,char c)
729 {
730 char    str[300];
731 struct  ast_frame wf;
732 struct  rpt_link *l;
733
734         sprintf(str,"D %s %s %d %c",myrpt->cmdnode,myrpt->name,++(myrpt->dtmfidx),c);
735         wf.frametype = AST_FRAME_TEXT;
736         wf.subclass = 0;
737         wf.offset = 0;
738         wf.mallocd = 1;
739         wf.datalen = strlen(str) + 1;
740         wf.samples = 0;
741         l = myrpt->links.next;
742         /* first, see if our dude is there */
743         while(l != &myrpt->links)
744         {
745                 /* if we found it, write it and were done */
746                 if (!strcmp(l->name,myrpt->cmdnode))
747                 {
748                         wf.data = strdup(str);
749                         ast_write(l->chan,&wf);
750                         return;
751                 }
752                 l = l->next;
753         }
754         l = myrpt->links.next;
755         /* if not, give it to everyone */
756         while(l != &myrpt->links)
757         {
758                 wf.data = strdup(str);
759                 ast_write(l->chan,&wf);
760                 l = l->next;
761         }
762         return;
763 }
764
765 static void process_dtmf(char *cmd,struct rpt *myrpt, int allow_linkcmd)
766 {
767 pthread_attr_t attr;
768 char *tele,tmp[300],deststr[300],*val,*s,*s1;
769 struct rpt_link *l;
770 ZT_CONFINFO ci;  /* conference info */
771
772         switch(atoi(cmd) / 1000)
773         {
774         case 6: /* autopatch on / send asterisk (*) */
775                 if (!myrpt->enable) return;
776                 ast_mutex_lock(&myrpt->lock);
777                 /* if on call, force * into current audio stream */
778                 if ((myrpt->callmode == 2) || (myrpt->callmode == 3))
779                 {
780                         myrpt->mydtmf = '*';
781                         ast_mutex_unlock(&myrpt->lock);
782                         break;
783                 }
784                 if (myrpt->callmode)
785                 {
786                         ast_mutex_unlock(&myrpt->lock);
787                         return;
788                 }
789                 myrpt->callmode = 1;
790                 myrpt->cidx = 0;
791                 myrpt->exten[myrpt->cidx] = 0;
792                 ast_mutex_unlock(&myrpt->lock);
793                 pthread_attr_init(&attr);
794                 pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
795                 pthread_create(&myrpt->rpt_call_thread,&attr,rpt_call,(void *) myrpt);
796                 return;
797         case 0: /* autopatch off */
798                 if (!myrpt->enable) return;
799                 ast_mutex_lock(&myrpt->lock);
800                 if (!myrpt->callmode)
801                 {
802                         ast_mutex_unlock(&myrpt->lock);
803                         return;
804                 }
805                 myrpt->callmode = 0;
806                 ast_mutex_unlock(&myrpt->lock);
807                 rpt_telemetry(myrpt,TERM,NULL);
808                 return;
809         case 9: /* system control group */
810                 /* if invalid, just ignore */
811                 if ((cmd[1] >= '2') && (cmd[1] <= '8')) return;
812                 ast_mutex_lock(&myrpt->lock);
813                 if (cmd[1] == '1') /* system enable */
814                 {
815                         myrpt->enable = 1;
816                 }
817                 if (cmd[1] == '0') /* system disable */
818                 {
819                         myrpt->enable = 0;
820                 }
821                 /* reset system */
822                 myrpt->callmode = 0;
823                 ast_mutex_unlock(&myrpt->lock);
824                 l = myrpt->links.next;
825                 /* disconnect all of the remote stuff */
826                 while(l != &myrpt->links)
827                 {
828                         ast_softhangup(l->chan,AST_SOFTHANGUP_DEV);
829                         l = l->next;
830                 }
831                 break;
832         case 1: /* remote base off */
833                 if (!myrpt->enable) return;
834                 val = ast_variable_retrieve(cfg,NODES,cmd + 1);
835                 if (!val)
836                 {
837                         rpt_telemetry(myrpt,REMNOTFOUND,NULL);
838                         return;
839                 }
840                 strncpy(tmp,val,sizeof(tmp) - 1);
841                 s = tmp;
842                 s1 = strsep(&s,",");
843                 ast_mutex_lock(&myrpt->lock);
844                 l = myrpt->links.next;
845                 /* try to find this one in queue */
846                 while(l != &myrpt->links)
847                 {
848                         /* if found matching string */
849                         if (!strcmp(l->name,cmd + 1)) break;
850                         l = l->next;
851                 }
852                 if (l != &myrpt->links) /* if found */
853                 {
854                         ast_mutex_unlock(&myrpt->lock);
855                         ast_softhangup(l->chan,AST_SOFTHANGUP_DEV);
856                         break;
857                 }
858                 ast_mutex_unlock(&myrpt->lock);
859                 return;
860         case 2: /* remote base monitor */
861                 if (!myrpt->enable) return;
862                 val = ast_variable_retrieve(cfg,NODES,cmd + 1);
863                 if (!val)
864                 {
865                         rpt_telemetry(myrpt,REMNOTFOUND,NULL);
866                         return;
867                 }
868                 strncpy(tmp,val,sizeof(tmp) - 1);
869                 s = tmp;
870                 s1 = strsep(&s,",");
871                 ast_mutex_lock(&myrpt->lock);
872                 l = myrpt->links.next;
873                 /* try to find this one in queue */
874                 while(l != &myrpt->links)
875                 {
876                         /* if found matching string */
877                         if (!strcmp(l->name,cmd + 1)) break;
878                         l = l->next;
879                 }
880                 /* if found */
881                 if (l != &myrpt->links) 
882                 {
883                         /* if already in this mode, just ignore */
884                         if (!l->mode) {
885                                 ast_mutex_unlock(&myrpt->lock);
886                                 rpt_telemetry(myrpt,REMALREADY,NULL);
887                                 return;
888                         }
889                         ast_softhangup(l->chan,AST_SOFTHANGUP_DEV);
890                         usleep(500000); 
891                 }
892                 ast_mutex_unlock(&myrpt->lock);
893                 /* establish call in monitor mode */
894                 l = malloc(sizeof(struct rpt_link));
895                 if (!l)
896                 {
897                         ast_log(LOG_WARNING, "Unable to malloc\n");
898                         pthread_exit(NULL);
899                 }
900                 /* zero the silly thing */
901                 memset((char *)l,0,sizeof(struct rpt_link));
902                 sprintf(deststr,"IAX2/%s",s1);
903                 tele = strchr(deststr,'/');
904                 if (!tele)
905                 {
906                         fprintf(stderr,"rpt:Dial number (%s) must be in format tech/number\n",deststr);
907                         pthread_exit(NULL);
908                 }
909                 *tele++ = 0;
910                 l->isremote = (s && ast_true(s));
911                 strncpy(l->name,cmd + 1,MAXNODESTR - 1);
912                 l->chan = ast_request(deststr,AST_FORMAT_SLINEAR,tele);
913                 if (l->chan)
914                 {
915                         ast_set_read_format(l->chan,AST_FORMAT_SLINEAR);
916                         ast_set_write_format(l->chan,AST_FORMAT_SLINEAR);
917                         l->chan->whentohangup = 0;
918                         l->chan->appl = "Apprpt";
919                         l->chan->data = "(Remote Rx)";
920                         if (option_verbose > 2)
921                                 ast_verbose(VERBOSE_PREFIX_3 "rpt (remote) initiating call to %s/%s on %s\n",
922                                         deststr,tele,l->chan->name);
923                         l->chan->callerid = strdup(myrpt->name);
924                         ast_call(l->chan,tele,0);
925                 }
926                 else
927                 {
928                         free(l);
929                         if (option_verbose > 2)
930                                 ast_verbose(VERBOSE_PREFIX_3 "Unable to place call to %s/%s on %s\n",
931                                         deststr,tele,l->chan->name);
932                         return;
933                 }
934                 /* allocate a pseudo-channel thru asterisk */
935                 l->pchan = ast_request("zap",AST_FORMAT_SLINEAR,"pseudo");
936                 if (!l->pchan)
937                 {
938                         fprintf(stderr,"rpt:Sorry unable to obtain pseudo channel\n");
939                         pthread_exit(NULL);
940                 }
941                 ast_set_read_format(l->pchan,AST_FORMAT_SLINEAR);
942                 ast_set_write_format(l->pchan,AST_FORMAT_SLINEAR);
943                 /* make a conference for the pseudo-one */
944                 ci.chan = 0;
945                 ci.confno = myrpt->conf;
946                 ci.confmode = ZT_CONF_CONF | ZT_CONF_LISTENER | ZT_CONF_TALKER;
947                 /* first put the channel on the conference in proper mode */
948                 if (ioctl(l->pchan->fds[0],ZT_SETCONF,&ci) == -1)
949                 {
950                         ast_log(LOG_WARNING, "Unable to set conference mode to Announce\n");
951                         pthread_exit(NULL);
952                 }
953                 ast_mutex_lock(&myrpt->lock);
954                 /* insert at end of queue */
955                 insque((struct qelem *)l,(struct qelem *)myrpt->links.next);
956                 ast_mutex_unlock(&myrpt->lock);
957                 break;
958         case 3: /* remote base tranceieve */
959                 if (!myrpt->enable) return;
960                 val = ast_variable_retrieve(cfg,NODES,cmd + 1);
961                 if (!val)
962                 {
963                         rpt_telemetry(myrpt,REMNOTFOUND,NULL);
964                         return;
965                 }
966                 strncpy(tmp,val,sizeof(tmp) - 1);
967                 s = tmp;
968                 s1 = strsep(&s,",");
969                 ast_mutex_lock(&myrpt->lock);
970                 l = myrpt->links.next;
971                 /* try to find this one in queue */
972                 while(l != &myrpt->links)
973                 {
974                         /* if found matching string */
975                         if (!strcmp(l->name,cmd + 1)) break;
976                         l = l->next;
977                 }
978                 /* if found */
979                 if (l != &myrpt->links) 
980                 {
981                         /* if already in this mode, just ignore */
982                         if (l->mode)
983                         {
984                                 ast_mutex_unlock(&myrpt->lock);
985                                 rpt_telemetry(myrpt,REMALREADY,NULL);
986                                 return;
987                         }
988                         ast_softhangup(l->chan,AST_SOFTHANGUP_DEV);
989                         usleep(500000); 
990                 }
991                 ast_mutex_unlock(&myrpt->lock);
992                 /* establish call in tranceive mode */
993                 l = malloc(sizeof(struct rpt_link));
994                 if (!l)
995                 {
996                         ast_log(LOG_WARNING, "Unable to malloc\n");
997                         pthread_exit(NULL);
998                 }
999                 /* zero the silly thing */
1000                 memset((char *)l,0,sizeof(struct rpt_link));
1001                 l->mode = 1;
1002                 strncpy(l->name,cmd + 1,MAXNODESTR - 1);
1003                 l->isremote = (s && ast_true(s));
1004                 sprintf(deststr,"IAX2/%s",s1);
1005                 tele = strchr(deststr,'/');
1006                 if (!tele)
1007                 {
1008                         fprintf(stderr,"rpt:Dial number must be in format tech/number\n");
1009                         pthread_exit(NULL);
1010                 }
1011                 *tele++ = 0;
1012                 l->chan = ast_request(deststr,AST_FORMAT_SLINEAR,tele);
1013                 if (l->chan)
1014                 {
1015                         ast_set_read_format(l->chan,AST_FORMAT_SLINEAR);
1016                         ast_set_write_format(l->chan,AST_FORMAT_SLINEAR);
1017                         l->chan->whentohangup = 0;
1018                         l->chan->appl = "Apprpt";
1019                         l->chan->data = "(Remote Rx)";
1020                         if (option_verbose > 2)
1021                                 ast_verbose(VERBOSE_PREFIX_3 "rpt (remote) initiating call to %s/%s on %s\n",
1022                                         deststr,tele,l->chan->name);
1023                         l->chan->callerid = strdup(myrpt->name);
1024                         ast_call(l->chan,tele,999);
1025                 }
1026                 else
1027                 {
1028                         free(l);
1029                         if (option_verbose > 2)
1030                                 ast_verbose(VERBOSE_PREFIX_3 "Unable to place call to %s/%s on %s\n",
1031                                         deststr,tele,l->chan->name);
1032                         return;
1033                 }
1034                 /* allocate a pseudo-channel thru asterisk */
1035                 l->pchan = ast_request("zap",AST_FORMAT_SLINEAR,"pseudo");
1036                 if (!l->pchan)
1037                 {
1038                         fprintf(stderr,"rpt:Sorry unable to obtain pseudo channel\n");
1039                         pthread_exit(NULL);
1040                 }
1041                 ast_set_read_format(l->pchan,AST_FORMAT_SLINEAR);
1042                 ast_set_write_format(l->pchan,AST_FORMAT_SLINEAR);
1043                 /* make a conference for the tx */
1044                 ci.chan = 0;
1045                 ci.confno = myrpt->conf;
1046                 ci.confmode = ZT_CONF_CONF | ZT_CONF_LISTENER | ZT_CONF_TALKER;
1047                 /* first put the channel on the conference in proper mode */
1048                 if (ioctl(l->pchan->fds[0],ZT_SETCONF,&ci) == -1)
1049                 {
1050                         ast_log(LOG_WARNING, "Unable to set conference mode to Announce\n");
1051                         pthread_exit(NULL);
1052                 }
1053                 ast_mutex_lock(&myrpt->lock);
1054                 /* insert at end of queue */
1055                 insque((struct qelem *)l,(struct qelem *)myrpt->links.next);
1056                 ast_mutex_unlock(&myrpt->lock);
1057                 break;
1058         case 4: /* remote cmd mode */
1059                 if (!myrpt->enable) return;
1060                 /* if doesnt allow link cmd, return */
1061                 if ((!allow_linkcmd) || (myrpt->links.next == &myrpt->links)) return;
1062                 /* if already in cmd mode, or selected self, forget it */
1063                 if ((myrpt->cmdnode[0]) || (!strcmp(myrpt->name,cmd + 1)))
1064                 {
1065                         rpt_telemetry(myrpt,REMALREADY,NULL);
1066                         return;
1067                 }
1068                 /* node must at least exist in list */
1069                 val = ast_variable_retrieve(cfg,NODES,cmd + 1);
1070                 if (!val)
1071                 {
1072                         rpt_telemetry(myrpt,REMNOTFOUND,NULL);
1073                         return;
1074                 }
1075                 ast_mutex_lock(&myrpt->lock);
1076                 myrpt->dtmfidx = -1;
1077                 myrpt->dtmfbuf[0] = 0;
1078                 myrpt->rem_dtmfidx = -1;
1079                 myrpt->rem_dtmfbuf[0] = 0;
1080                 strcpy(myrpt->cmdnode,cmd + 1);
1081                 ast_mutex_unlock(&myrpt->lock);
1082                 rpt_telemetry(myrpt,REMGO,NULL);                                
1083                 return;
1084         case 7: /* system status */
1085                 if (!myrpt->enable) return;
1086                 rpt_telemetry(myrpt,STATUS,NULL);
1087                 return;
1088         case 8: /* force ID */
1089                 if (!myrpt->enable) return;
1090                 myrpt->idtimer = 0;
1091                 return;
1092         default:
1093                 return;
1094         }
1095         if (!myrpt->enable) return;
1096         rpt_telemetry(myrpt,COMPLETE,NULL);
1097 }
1098
1099 static void handle_link_data(struct rpt *myrpt, struct rpt_link *mylink,
1100         char *str)
1101 {
1102 char    tmp[300],cmd[300],dest[300],src[300],c;
1103 int     seq;
1104 struct rpt_link *l;
1105 struct  ast_frame wf;
1106
1107         /* if we are a remote, we dont want to do this */
1108         if (myrpt->remote) return;
1109         wf.frametype = AST_FRAME_TEXT;
1110         wf.subclass = 0;
1111         wf.offset = 0;
1112         wf.mallocd = 1;
1113         wf.datalen = strlen(str) + 1;
1114         wf.samples = 0;
1115         /* put string in our buffer */
1116         strncpy(tmp,str,sizeof(tmp) - 1);
1117         if (sscanf(tmp,"%s %s %s %d %c",cmd,dest,src,&seq,&c) != 5)
1118         {
1119                 ast_log(LOG_WARNING, "Unable to parse link string %s\n",str);
1120                 return;
1121         }
1122         if (strcmp(cmd,"D"))
1123         {
1124                 ast_log(LOG_WARNING, "Unable to parse link string %s\n",str);
1125                 return;
1126         }
1127         /* if not for me, redistribute to all links */
1128         if (strcmp(dest,myrpt->name))
1129         {
1130                 l = myrpt->links.next;
1131                 /* see if this is one in list */
1132                 while(l != &myrpt->links)
1133                 {
1134                         /* dont send back from where it came */
1135                         if ((l == mylink) || (!strcmp(l->name,mylink->name)))
1136                         {
1137                                 l = l->next;
1138                                 continue;
1139                         }
1140                         /* if it is, send it and we're done */
1141                         if (!strcmp(l->name,dest))
1142                         {
1143                                 /* send, but not to src */
1144                                 if (strcmp(l->name,src)) {
1145                                         wf.data = strdup(str);
1146                                         ast_write(l->chan,&wf);
1147                                 }
1148                                 return;
1149                         }
1150                         l = l->next;
1151                 }
1152                 l = myrpt->links.next;
1153                 /* otherwise, send it to all of em */
1154                 while(l != &myrpt->links)
1155                 {
1156                         /* dont send back from where it came */
1157                         if ((l == mylink) || (!strcmp(l->name,mylink->name)))
1158                         {
1159                                 l = l->next;
1160                                 continue;
1161                         }
1162                         /* send, but not to src */
1163                         if (strcmp(l->name,src)) {
1164                                 wf.data = strdup(str);
1165                                 ast_write(l->chan,&wf);
1166                         }
1167                         l = l->next;
1168                 }
1169                 return;
1170         }
1171         ast_mutex_lock(&myrpt->lock);
1172         if (c == '*')
1173         {
1174                 myrpt->rem_dtmfidx = 0;
1175                 myrpt->rem_dtmfbuf[myrpt->rem_dtmfidx] = 0;
1176                 time(&myrpt->rem_dtmf_time);
1177                 ast_mutex_unlock(&myrpt->lock);
1178                 return;
1179         } 
1180         else if ((c != '#') && (myrpt->rem_dtmfidx >= 0))
1181         {
1182                 time(&myrpt->rem_dtmf_time);
1183                 if (myrpt->rem_dtmfidx < MAXDTMF)
1184                 {
1185                         myrpt->rem_dtmfbuf[myrpt->rem_dtmfidx++] = c;
1186                         myrpt->rem_dtmfbuf[myrpt->rem_dtmfidx] = 0;
1187                         /* if to terminate function now */
1188                         if ((myrpt->rem_dtmfidx == 1) && strchr(SHORTFUNCS,c))
1189                         {
1190                                 while(myrpt->rem_dtmfidx < FUNCTION_LEN)
1191                                         myrpt->rem_dtmfbuf[myrpt->rem_dtmfidx++] = '0';
1192                                 myrpt->rem_dtmfbuf[myrpt->rem_dtmfidx] = 0;
1193                         }
1194                         /* if to terminate function now */
1195                         if ((myrpt->rem_dtmfidx == 2) && strchr(MEDFUNCS,myrpt->rem_dtmfbuf[0]))
1196                         {
1197                                 while(myrpt->rem_dtmfidx < FUNCTION_LEN)
1198                                         myrpt->rem_dtmfbuf[myrpt->rem_dtmfidx++] = '0';
1199                                 myrpt->rem_dtmfbuf[myrpt->rem_dtmfidx] = 0;
1200                         }
1201                 }
1202                 if (myrpt->rem_dtmfidx == FUNCTION_LEN)
1203                 {
1204                         strcpy(cmd,myrpt->rem_dtmfbuf);
1205                         myrpt->rem_dtmfbuf[0] = 0;
1206                         myrpt->rem_dtmfidx = -1;
1207                         ast_mutex_unlock(&myrpt->lock);
1208                         process_dtmf(cmd,myrpt,0);
1209                         return;
1210                 }
1211         }
1212         ast_mutex_unlock(&myrpt->lock);
1213         return;
1214 }
1215
1216 /* Doug Hall RBI-1 serial data definitions:
1217  *
1218  * Byte 0: Expansion external outputs 
1219  * Byte 1: 
1220  *      Bits 0-3 are BAND as follows:
1221  *      Bits 4-5 are POWER bits as follows:
1222  *              00 - Low Power
1223  *              01 - Hi Power
1224  *              02 - Med Power
1225  *      Bits 6-7 are always set
1226  * Byte 2:
1227  *      Bits 0-3 MHZ in BCD format
1228  *      Bits 4-5 are offset as follows:
1229  *              00 - minus
1230  *              01 - plus
1231  *              02 - simplex
1232  *              03 - minus minus (whatever that is)
1233  *      Bit 6 is the 0/5 KHZ bit
1234  *      Bit 7 is always set
1235  * Byte 3:
1236  *      Bits 0-3 are 10 KHZ in BCD format
1237  *      Bits 4-7 are 100 KHZ in BCD format
1238  * Byte 4: PL Tone code and encode/decode enable bits
1239  *      Bits 0-5 are PL tone code (comspec binary codes)
1240  *      Bit 6 is encode enable/disable
1241  *      Bit 7 is decode enable/disable
1242  */
1243
1244 /* take the frequency from the 10 mhz digits (and up) and convert it
1245    to a band number */
1246
1247 static int rbi_mhztoband(char *str)
1248 {
1249 int     i;
1250
1251         i = atoi(str) / 10; /* get the 10's of mhz */
1252         switch(i)
1253         {
1254             case 2:
1255                 return 10;
1256             case 5:
1257                 return 11;
1258             case 14:
1259                 return 2;
1260             case 22:
1261                 return 3;
1262             case 44:
1263                 return 4;
1264             case 124:
1265                 return 0;
1266             case 125:
1267                 return 1;
1268             case 126:
1269                 return 8;
1270             case 127:
1271                 return 5;
1272             case 128:
1273                 return 6;
1274             case 129:
1275                 return 7;
1276             default:
1277                 break;
1278         }
1279         return -1;
1280 }
1281
1282 /* take a PL frequency and turn it into a code */
1283 static int rbi_pltocode(char *str)
1284 {
1285 int i;
1286 char *s;
1287
1288         s = strchr(str,'.');
1289         i = 0;
1290         if (s) i = atoi(s + 1);
1291         i += atoi(str) * 10;
1292         switch(i)
1293         {
1294             case 670:
1295                 return 0;
1296             case 719:
1297                 return 1;
1298             case 744:
1299                 return 2;
1300             case 770:
1301                 return 3;
1302             case 797:
1303                 return 4;
1304             case 825:
1305                 return 5;
1306             case 854:
1307                 return 6;
1308             case 885:
1309                 return 7;
1310             case 915:
1311                 return 8;
1312             case 948:
1313                 return 9;
1314             case 974:
1315                 return 10;
1316             case 1000:
1317                 return 11;
1318             case 1035:
1319                 return 12;
1320             case 1072:
1321                 return 13;
1322             case 1109:
1323                 return 14;
1324             case 1148:
1325                 return 15;
1326             case 1188:
1327                 return 16;
1328             case 1230:
1329                 return 17;
1330             case 1273:
1331                 return 18;
1332             case 1318:
1333                 return 19;
1334             case 1365:
1335                 return 20;
1336             case 1413:
1337                 return 21;
1338             case 1462:
1339                 return 22;
1340             case 1514:
1341                 return 23;
1342             case 1567:
1343                 return 24;
1344             case 1622:
1345                 return 25;
1346             case 1679:
1347                 return 26;
1348             case 1738:
1349                 return 27;
1350             case 1799:
1351                 return 28;
1352             case 1862:
1353                 return 29;
1354             case 1928:
1355                 return 30;
1356             case 2035:
1357                 return 31;
1358             case 2107:
1359                 return 32;
1360             case 2181:
1361                 return 33;
1362             case 2257:
1363                 return 34;
1364             case 2336:
1365                 return 35;
1366             case 2418:
1367                 return 36;
1368             case 2503:
1369                 return 37;
1370         }
1371         return -1;
1372 }
1373
1374 /*
1375 * Shift out a formatted serial bit stream
1376 */
1377
1378 static void rbi_out(struct rpt *myrpt,unsigned char *data)
1379     {
1380     int i,j;
1381     unsigned char od,d;
1382     static volatile long long delayvar;
1383
1384     for(i = 0 ; i < 5 ; i++){
1385         od = *data++; 
1386         for(j = 0 ; j < 8 ; j++){
1387             d = od & 1;
1388             outb(d,myrpt->iobase);
1389             /* >= 15 us */
1390             for(delayvar = 1; delayvar < 15000; delayvar++); 
1391             od >>= 1;
1392             outb(d | 2,myrpt->iobase);
1393             /* >= 30 us */
1394             for(delayvar = 1; delayvar < 30000; delayvar++); 
1395             outb(d,myrpt->iobase);
1396             /* >= 10 us */
1397             for(delayvar = 1; delayvar < 10000; delayvar++); 
1398             }
1399         }
1400         /* >= 50 us */
1401         for(delayvar = 1; delayvar < 50000; delayvar++); 
1402     }
1403
1404 static int setrbi(struct rpt *myrpt)
1405 {
1406 char tmp[MAXREMSTR],rbicmd[5],*s;
1407 int     band,txoffset = 0,txpower = 0,rxpl;
1408
1409         
1410         strcpy(tmp,myrpt->freq);
1411         s = strchr(tmp,'.');
1412         /* if no decimal, is invalid */
1413         if (s == NULL) return -1;
1414         *s++ = 0;
1415         if (strlen(tmp) < 2) return -1;
1416         if (strlen(s) < 3) return -1;
1417         if ((s[2] != '0') && (s[2] != '5')) return -1;
1418         band = rbi_mhztoband(tmp);
1419         if (band == -1) return -1;
1420         rxpl = rbi_pltocode(myrpt->rxpl);
1421         if (rxpl == -1) return -1;
1422         switch(myrpt->offset)
1423         {
1424             case REM_MINUS:
1425                 txoffset = 0;
1426                 break;
1427             case REM_PLUS:
1428                 txoffset = 0x10;
1429                 break;
1430             case REM_SIMPLEX:
1431                 txoffset = 0x20;
1432                 break;
1433         }
1434         switch(myrpt->powerlevel)
1435         {
1436             case REM_LOWPWR:
1437                 txpower = 0;
1438                 break;
1439             case REM_MEDPWR:
1440                 txpower = 0x20;
1441                 break;
1442             case REM_HIPWR:
1443                 txpower = 0x10;
1444                 break;
1445         }
1446         rbicmd[0] = 0;
1447         rbicmd[1] = band | txpower | 0xc0;
1448         rbicmd[2] = (*(s - 2) - '0') | txoffset | 0x80;
1449         if (s[2] == '5') rbicmd[2] |= 0x40;
1450         rbicmd[3] = ((*s - '0') << 4) + (s[1] - '0');
1451         rbicmd[4] = rxpl;
1452         if (myrpt->txplon) rbicmd[4] |= 0x40;
1453         if (myrpt->rxplon) rbicmd[4] |= 0x80;
1454         rbi_out(myrpt,rbicmd);
1455         return 0;
1456 }
1457
1458 static int remote_function(struct rpt *myrpt,char *cmd, struct ast_channel *mychannel)
1459 {
1460 char    *s,*s1,tmp[300],oc,savestr[MAXREMSTR],*val;
1461
1462         switch(cmd[0])
1463         {
1464             case '0':  /* retrieve memory */
1465                 val = ast_variable_retrieve(cfg,MEMORY,cmd + 1);
1466                 if (!val)
1467                 {
1468                         if (ast_safe_sleep(mychannel,1000) == -1) return -1;
1469                         return(sayfile(mychannel,"rpt/memory_notfound"));
1470                 }                       
1471                 strncpy(tmp,val,sizeof(tmp) - 1);
1472                 s = strchr(tmp,',');
1473                 if (!s) return 0;
1474                 *s++ = 0;
1475                 s1 = strchr(s,',');
1476                 if (!s1) return 0;
1477                 *s1++ = 0;
1478                 strcpy(myrpt->freq,tmp);
1479                 strcpy(myrpt->rxpl,s);
1480                 myrpt->offset = REM_SIMPLEX;
1481                 myrpt->powerlevel = REM_MEDPWR;
1482                 myrpt->rxplon = 0;
1483                 myrpt->txplon = 0;
1484                 while(*s1)
1485                 {
1486                         switch(*s1++)
1487                         {
1488                             case 'L':
1489                             case 'l':
1490                                 myrpt->powerlevel = REM_LOWPWR;
1491                                 break;
1492                             case 'H':
1493                             case 'h':
1494                                 myrpt->powerlevel = REM_HIPWR;
1495                                 break;
1496                             case 'M':
1497                             case 'm':
1498                                 myrpt->powerlevel = REM_MEDPWR;
1499                                 break;
1500                             case '-':
1501                                 myrpt->offset = REM_MINUS;
1502                                 break;
1503                             case '+':
1504                                 myrpt->offset = REM_PLUS;
1505                                 break;
1506                             case 'S':
1507                             case 's':
1508                                 myrpt->offset = REM_SIMPLEX;
1509                                 break;
1510                             case 'T':
1511                             case 't':
1512                                 myrpt->txplon = 1;
1513                                 break;
1514                             case 'R':
1515                             case 'r':
1516                                 myrpt->rxplon = 1;
1517                                 break;
1518                         }
1519                 }
1520                 if (setrbi(myrpt) == -1) return 0;
1521                 break;          
1522             case '1':  /* set freq + offset */
1523                 strncpy(tmp,cmd,sizeof(tmp) - 1);
1524                 s1 = NULL;
1525                 oc = 0;
1526                 /* see if we have at least 1 */
1527                 s = strchr(tmp,'*');
1528                 if (s)
1529                 {
1530                         *s++ = 0;
1531                         s1 = strchr(s,'*');
1532                         if (s1)
1533                         {
1534                                 *s1++ = 0;
1535                                 oc = *s1;
1536                         }
1537                         if (strlen(s) > 3) return 0;
1538                         if (strlen(s) < 3) memset(s + strlen(s),'0',3 - strlen(s));
1539                         s[3] = 0;
1540                 } else strcat(tmp,".000");
1541                 if (oc)
1542                 {
1543                         switch(oc)
1544                         {
1545                             case '1':
1546                                 myrpt->offset = REM_MINUS;
1547                                 break;
1548                             case '2':
1549                                 myrpt->offset = REM_SIMPLEX;
1550                                 break;
1551                             case '3':
1552                                 myrpt->offset = REM_PLUS;
1553                                 break;
1554                             default:
1555                                 return 0;
1556                         } 
1557                 } else myrpt->offset = REM_SIMPLEX;
1558                 if(s) *--s = '.';
1559                 strcpy(savestr,myrpt->freq);
1560                 strcpy(myrpt->freq,tmp + 1);
1561                 if (setrbi(myrpt) == -1)
1562                 {
1563                         strcpy(myrpt->freq,savestr);
1564                         return 0;
1565                 }
1566                 break;
1567             case '2': /* set rx PL tone */
1568                 strncpy(tmp,cmd,sizeof(tmp) - 1);
1569                 /* see if we have at least 1 */
1570                 s = strchr(tmp,'*');
1571                 if (s)
1572                 {
1573                         *s++ = '.';
1574                         if (strlen(s + 1) > 1) return 0;
1575                 } else strcat(tmp,".0");
1576                 strcpy(savestr,myrpt->rxpl);
1577                 strcpy(myrpt->rxpl,tmp + 1);
1578                 if (setrbi(myrpt) == -1)
1579                 {
1580                         strcpy(myrpt->rxpl,savestr);
1581                         return 0;
1582                 }
1583                 break;
1584             case '4': /* other stuff */
1585                 if (strlen(cmd) > 2) return 0;
1586                 switch(cmd[1])
1587                 {
1588                     case '0': /* RX PL Off */
1589                         myrpt->rxplon = 0;
1590                         break;
1591                     case '1': /* RX PL On */
1592                         myrpt->rxplon = 1;
1593                         break;
1594                     case '2': /* TX PL Off */
1595                         myrpt->txplon = 0;
1596                         break;
1597                     case '3': /* TX PL On */
1598                         myrpt->txplon = 1;
1599                         break;
1600                     case '4': /* Low Power */
1601                         myrpt->powerlevel = REM_LOWPWR;
1602                         break;
1603                     case '5': /* Medium Power */
1604                         myrpt->powerlevel = REM_MEDPWR;
1605                         break;
1606                     case '6': /* Hi Power */
1607                         myrpt->powerlevel = REM_HIPWR;
1608                         break;
1609                     default:
1610                         return 0;
1611                 }
1612                 if (setrbi(myrpt) == -1) return 0;
1613                 break;
1614             default:
1615                 return 0;
1616         }
1617         return 1;
1618 }
1619
1620 static int handle_dtmf_digit(struct rpt *myrpt,char c, struct ast_channel *mychannel)
1621 {
1622 char str[MAXDTMF],*s,*s1;
1623 time_t  now;
1624
1625         time(&now);
1626         /* if timed-out */
1627         if ((myrpt->dtmf_time_rem + DTMF_TIMEOUT) < now)
1628         {
1629                 strcpy(str,myrpt->dtmfbuf);
1630                 myrpt->dtmfidx = -1;
1631                 myrpt->dtmfbuf[0] = 0;
1632                 myrpt->dtmf_time_rem = 0;
1633         }
1634         /* if decode not active */
1635         if (myrpt->dtmfidx == -1)
1636         {
1637                 /* if not lead-in digit, dont worry */
1638                 if (c != '*') return 0;
1639                 myrpt->dtmfidx = 0;
1640                 myrpt->dtmfbuf[0] = 0;
1641                 myrpt->dtmf_time_rem = now;
1642                 return 0;
1643         }
1644         /* if too many in buffer, start over */
1645         if (myrpt->dtmfidx >= MAXDTMF)
1646         {
1647                 myrpt->dtmfidx = 0;
1648                 myrpt->dtmfbuf[0] = 0;
1649                 myrpt->dtmf_time_rem = now;
1650         }
1651         if (c == '*')
1652         {
1653                 /* if star at beginning, or 2 together, erase buffer */
1654                 if ((myrpt->dtmfidx < 1) || 
1655                         (myrpt->dtmfbuf[myrpt->dtmfidx - 1] == '*'))
1656                 {
1657                         myrpt->dtmfidx = 0;
1658                         myrpt->dtmfbuf[0] = 0;
1659                         myrpt->dtmf_time_rem = now;
1660                         return 0;
1661                 }
1662         }
1663         myrpt->dtmfbuf[myrpt->dtmfidx++] = c;
1664         myrpt->dtmfbuf[myrpt->dtmfidx] = 0;
1665         myrpt->dtmf_time_rem = now;
1666         switch(myrpt->dtmfbuf[0])
1667         {
1668             case '4': /* wait for 1 more digit */
1669                 /* if we are at end, process it */
1670                 if (myrpt->dtmfidx >= 2) break;
1671                 return 0;
1672             case '0': /* wait for 2 more digits */
1673                 /* if we are at end, process it */
1674                 if (myrpt->dtmfidx >= 3) break;
1675                 return 0;
1676             case '2':
1677             case '3': /* go until 1 digit after * */
1678                 s = strchr(myrpt->dtmfbuf,'*');
1679                 /* if we dont have a star, dont worry yet */
1680                 if (s == NULL) return 0;                        
1681                 /* if nothing after star yet */
1682                 if (!s[1]) return 0;
1683                 /* okay, we got it */
1684                 break;
1685             case '1': /* go until 1 digit after second * */
1686                 s = strchr(myrpt->dtmfbuf,'*');
1687                 /* if we dont have a star, dont worry yet */
1688                 if (s == NULL) return 0;                        
1689                 /* if nothing after star yet */
1690                 if (!s[1]) return 0;
1691                 s1 = strchr(s + 1,'*');
1692                 /* if we dont have a 2nd star, dont worry yet */
1693                 if (s1 == NULL) return 0;
1694                 /* if nothing after 2nd * yet */
1695                 if (!s1[1]) return 0;
1696                 /* okay, we got it */
1697                 break;
1698             case '5': /* status, just deux it here */
1699                 if (sayfile(mychannel,"rpt/node") == -1) return -1;
1700                 if (saycharstr(mychannel,myrpt->name) == -1) return -1;
1701                 if (sayfile(mychannel,"rpt/frequency") == -1) return -1;
1702                 if (saycharstr(mychannel,myrpt->freq) == -1) return -1;
1703                 switch(myrpt->offset)
1704                 {
1705                     case REM_MINUS:
1706                         if (sayfile(mychannel,"rpt/minus") == -1) return -1;
1707                         break;
1708                     case REM_SIMPLEX:
1709                         if (sayfile(mychannel,"rpt/simplex") == -1) return -1;
1710                         break;
1711                     case REM_PLUS:
1712                         if (sayfile(mychannel,"rpt/plus") == -1) return -1;
1713                         break;
1714                 }
1715                 switch(myrpt->powerlevel)
1716                 {
1717                     case REM_LOWPWR:
1718                         if (sayfile(mychannel,"rpt/lopwr") == -1) return -1;
1719                         break;
1720                     case REM_MEDPWR:
1721                         if (sayfile(mychannel,"rpt/medpwr") == -1) return -1;
1722                         break;
1723                     case REM_HIPWR:
1724                         if (sayfile(mychannel,"rpt/hipwr") == -1) return -1;
1725                         break;
1726                 }
1727                 if (sayfile(mychannel,"rpt/rxpl") == -1) return -1;
1728                 if (sayfile(mychannel,"rpt/frequency") == -1) return -1;
1729                 if (saycharstr(mychannel,myrpt->rxpl) == -1) return -1;
1730                 if (sayfile(mychannel,"rpt/txpl") == -1) return -1;
1731                 if (sayfile(mychannel,((myrpt->txplon) ? "rpt/on" : "rpt/off")) == -1) return -1;
1732                 if (sayfile(mychannel,"rpt/rxpl") == -1) return -1;
1733                 if (sayfile(mychannel,((myrpt->rxplon) ? "rpt/on" : "rpt/off")) == -1) return -1;
1734                 myrpt->dtmfidx = -1;
1735                 myrpt->dtmfbuf[0] = 0;
1736                 myrpt->dtmf_time_rem = 0;
1737                 return 1;
1738             default:
1739                 myrpt->dtmfidx = -1;
1740                 myrpt->dtmfbuf[0] = 0;
1741                 myrpt->dtmf_time_rem = 0;
1742                 return 0;
1743         }
1744         strcpy(str,myrpt->dtmfbuf);
1745         myrpt->dtmfidx = -1;
1746         myrpt->dtmfbuf[0] = 0;
1747         myrpt->dtmf_time_rem = 0;
1748         return(remote_function(myrpt,str,mychannel));
1749 }
1750
1751 static int handle_remote_data(struct rpt *myrpt, char *str, struct ast_channel *mychannel)
1752 {
1753 char    tmp[300],cmd[300],dest[300],src[300],c;
1754 int     seq,res;
1755
1756         /* put string in our buffer */
1757         strncpy(tmp,str,sizeof(tmp) - 1);
1758         if (sscanf(tmp,"%s %s %s %d %c",cmd,dest,src,&seq,&c) != 5)
1759         {
1760                 ast_log(LOG_WARNING, "Unable to parse link string %s\n",str);
1761                 return 0;
1762         }
1763         if (strcmp(cmd,"D"))
1764         {
1765                 ast_log(LOG_WARNING, "Unable to parse link string %s\n",str);
1766                 return 0;
1767         }
1768         /* if not for me, ignore */
1769         if (strcmp(dest,myrpt->name)) return 0;
1770         res = handle_dtmf_digit(myrpt,c,mychannel);
1771         if (res != 1) return res;
1772         if (ast_safe_sleep(mychannel,1000) == -1) return -1;
1773         return(sayfile(mychannel,"rpt/functioncomplete"));
1774 }
1775
1776 /* single thread with one file (request) to dial */
1777 static void *rpt(void *this)
1778 {
1779 struct  rpt *myrpt = (struct rpt *)this;
1780 char *tele;
1781 int ms = MSWAIT,lasttx,keyed,val,remrx;
1782 struct ast_channel *who;
1783 ZT_CONFINFO ci;  /* conference info */
1784 time_t  dtmf_time,t;
1785 struct rpt_link *l,*m;
1786 pthread_attr_t attr;
1787
1788         ast_mutex_lock(&myrpt->lock);
1789         tele = strchr(myrpt->rxchanname,'/');
1790         if (!tele)
1791         {
1792                 fprintf(stderr,"rpt:Dial number must be in format tech/number\n");
1793                 ast_mutex_unlock(&myrpt->lock);
1794                 pthread_exit(NULL);
1795         }
1796         *tele++ = 0;
1797         myrpt->rxchannel = ast_request(myrpt->rxchanname,AST_FORMAT_SLINEAR,tele);
1798         if (myrpt->rxchannel)
1799         {
1800                 ast_set_read_format(myrpt->rxchannel,AST_FORMAT_SLINEAR);
1801                 ast_set_write_format(myrpt->rxchannel,AST_FORMAT_SLINEAR);
1802                 myrpt->rxchannel->whentohangup = 0;
1803                 myrpt->rxchannel->appl = "Apprpt";
1804                 myrpt->rxchannel->data = "(Repeater Rx)";
1805                 if (option_verbose > 2)
1806                         ast_verbose(VERBOSE_PREFIX_3 "rpt (Rx) initiating call to %s/%s on %s\n",
1807                                 myrpt->rxchanname,tele,myrpt->rxchannel->name);
1808                 ast_call(myrpt->rxchannel,tele,999);
1809         }
1810         else
1811         {
1812                 fprintf(stderr,"rpt:Sorry unable to obtain Rx channel\n");
1813                 ast_mutex_unlock(&myrpt->lock);
1814                 pthread_exit(NULL);
1815         }
1816         if (myrpt->txchanname)
1817         {
1818                 tele = strchr(myrpt->txchanname,'/');
1819                 if (!tele)
1820                 {
1821                         fprintf(stderr,"rpt:Dial number must be in format tech/number\n");
1822                         ast_mutex_unlock(&myrpt->lock);
1823                         pthread_exit(NULL);
1824                 }
1825                 *tele++ = 0;
1826                 myrpt->txchannel = ast_request(myrpt->txchanname,AST_FORMAT_SLINEAR,tele);
1827                 if (myrpt->txchannel)
1828                 {
1829                         ast_set_read_format(myrpt->txchannel,AST_FORMAT_SLINEAR);
1830                         ast_set_write_format(myrpt->txchannel,AST_FORMAT_SLINEAR);
1831                         myrpt->txchannel->whentohangup = 0;
1832                         myrpt->txchannel->appl = "Apprpt";
1833                         myrpt->txchannel->data = "(Repeater Rx)";
1834                         if (option_verbose > 2)
1835                                 ast_verbose(VERBOSE_PREFIX_3 "rpt (Tx) initiating call to %s/%s on %s\n",
1836                                         myrpt->txchanname,tele,myrpt->txchannel->name);
1837                         ast_call(myrpt->txchannel,tele,999);
1838                 }
1839                 else
1840                 {
1841                         fprintf(stderr,"rpt:Sorry unable to obtain Tx channel\n");
1842                         ast_mutex_unlock(&myrpt->lock);
1843                         pthread_exit(NULL);
1844                 }
1845         }
1846         else
1847         {
1848                 myrpt->txchannel = myrpt->rxchannel;
1849         }
1850         /* allocate a pseudo-channel thru asterisk */
1851         myrpt->pchannel = ast_request("zap",AST_FORMAT_SLINEAR,"pseudo");
1852         if (!myrpt->pchannel)
1853         {
1854                 fprintf(stderr,"rpt:Sorry unable to obtain pseudo channel\n");
1855                 ast_mutex_unlock(&myrpt->lock);
1856                 pthread_exit(NULL);
1857         }
1858         /* make a conference for the tx */
1859         ci.chan = 0;
1860         ci.confno = -1; /* make a new conf */
1861         ci.confmode = ZT_CONF_CONF | ZT_CONF_LISTENER;
1862         /* first put the channel on the conference in proper mode */
1863         if (ioctl(myrpt->txchannel->fds[0],ZT_SETCONF,&ci) == -1)
1864         {
1865                 ast_log(LOG_WARNING, "Unable to set conference mode to Announce\n");
1866                 ast_mutex_unlock(&myrpt->lock);
1867                 pthread_exit(NULL);
1868         }
1869         /* save tx conference number */
1870         myrpt->txconf = ci.confno;
1871         /* make a conference for the pseudo */
1872         ci.chan = 0;
1873         ci.confno = -1; /* make a new conf */
1874         ci.confmode = ZT_CONF_CONFANNMON; 
1875         /* first put the channel on the conference in announce mode */
1876         if (ioctl(myrpt->pchannel->fds[0],ZT_SETCONF,&ci) == -1)
1877         {
1878                 ast_log(LOG_WARNING, "Unable to set conference mode to Announce\n");
1879                 ast_mutex_unlock(&myrpt->lock);
1880                 pthread_exit(NULL);
1881         }
1882         /* save pseudo channel conference number */
1883         myrpt->conf = ci.confno;
1884         /* allocate a pseudo-channel thru asterisk */
1885         myrpt->txpchannel = ast_request("zap",AST_FORMAT_SLINEAR,"pseudo");
1886         if (!myrpt->txpchannel)
1887         {
1888                 fprintf(stderr,"rpt:Sorry unable to obtain pseudo channel\n");
1889                 ast_mutex_unlock(&myrpt->lock);
1890                 pthread_exit(NULL);
1891         }
1892         /* make a conference for the tx */
1893         ci.chan = 0;
1894         ci.confno = myrpt->txconf;
1895         ci.confmode = ZT_CONF_CONF | ZT_CONF_TALKER ;
1896         /* first put the channel on the conference in proper mode */
1897         if (ioctl(myrpt->txpchannel->fds[0],ZT_SETCONF,&ci) == -1)
1898         {
1899                 ast_log(LOG_WARNING, "Unable to set conference mode to Announce\n");
1900                 ast_mutex_unlock(&myrpt->lock);
1901                 pthread_exit(NULL);
1902         }
1903         /* Now, the idea here is to copy from the physical rx channel buffer
1904            into the pseudo tx buffer, and from the pseudo rx buffer into the 
1905            tx channel buffer */
1906         myrpt->links.next = &myrpt->links;
1907         myrpt->links.prev = &myrpt->links;
1908         myrpt->tailtimer = 0;
1909         myrpt->totimer = 0;
1910         myrpt->idtimer = 0;
1911         myrpt->callmode = 0;
1912         myrpt->tounkeyed = 0;
1913         myrpt->tonotify = 0;
1914         lasttx = 0;
1915         keyed = 0;
1916         myrpt->dtmfidx = -1;
1917         myrpt->dtmfbuf[0] = 0;
1918         myrpt->rem_dtmfidx = -1;
1919         myrpt->rem_dtmfbuf[0] = 0;
1920         dtmf_time = 0;
1921         myrpt->rem_dtmf_time = 0;
1922         myrpt->enable = 1;
1923         ast_mutex_unlock(&myrpt->lock);
1924         val = 0;
1925         ast_channel_setoption(myrpt->rxchannel,AST_OPTION_TONE_VERIFY,&val,sizeof(char),0);
1926         val = 1;
1927         ast_channel_setoption(myrpt->rxchannel,AST_OPTION_RELAXDTMF,&val,sizeof(char),0);
1928         while (ms >= 0)
1929         {
1930                 struct ast_frame *f;
1931                 struct ast_channel *cs[300];
1932                 int totx,elap,n,toexit;
1933
1934                 if (ast_check_hangup(myrpt->rxchannel)) break;
1935                 if (ast_check_hangup(myrpt->txchannel)) break;
1936                 if (ast_check_hangup(myrpt->pchannel)) break;
1937                 if (ast_check_hangup(myrpt->txpchannel)) break;
1938                 ast_mutex_lock(&myrpt->lock);
1939                 myrpt->localtx = keyed;
1940                 l = myrpt->links.next;
1941                 remrx = 0;
1942                 while(l != &myrpt->links)
1943                 {
1944                         if (l->lastrx) remrx = 1;
1945                         l = l->next;
1946                 }
1947                 totx = (keyed || myrpt->callmode || 
1948                         (myrpt->tele.next != &myrpt->tele));
1949                 myrpt->exttx = totx;
1950                 totx = totx || remrx;
1951                 if (!totx) 
1952                 {
1953                         myrpt->totimer = myrpt->totime;
1954                         myrpt->tounkeyed = 0;
1955                         myrpt->tonotify = 0;
1956                 }
1957                 else myrpt->tailtimer = myrpt->hangtime;
1958                 totx = totx && myrpt->totimer;
1959                 /* if timed-out and not said already, say it */
1960                 if ((!myrpt->totimer) && (!myrpt->tonotify))
1961                 {
1962                         myrpt->tonotify = 1;
1963                         rpt_telemetry(myrpt,TIMEOUT,NULL);
1964                 }
1965                 /* if wants to transmit and in phone call, but timed out, 
1966                         reset time-out timer if keyed */
1967                 if ((!totx) && (!myrpt->totimer) && (!myrpt->tounkeyed) && (!keyed))
1968                 {
1969                         myrpt->tounkeyed = 1;
1970                 }
1971                 if ((!totx) && (!myrpt->totimer) && myrpt->tounkeyed && keyed)
1972                 {
1973                         myrpt->totimer = myrpt->totime;
1974                         myrpt->tounkeyed = 0;
1975                         myrpt->tonotify = 0;
1976                         ast_mutex_unlock(&myrpt->lock);
1977                         continue;
1978                 }
1979                 /* if timed-out and in circuit busy after call */
1980                 if ((!totx) && (!myrpt->totimer) && (myrpt->callmode == 4))
1981                 {
1982                         myrpt->callmode = 0;
1983                 }
1984                 /* get rid of tail if timed out */
1985                 if (!myrpt->totimer) myrpt->tailtimer = 0;
1986                 /* if not timed-out, add in tail */
1987                 if (myrpt->totimer) totx = totx || myrpt->tailtimer;
1988                 /* if time to ID */
1989                 if (totx && (!myrpt->idtimer))
1990                 {
1991                         myrpt->idtimer = myrpt->idtime;
1992                         ast_mutex_unlock(&myrpt->lock);
1993                         rpt_telemetry(myrpt,ID,NULL);
1994                         ast_mutex_lock(&myrpt->lock);
1995                 }
1996                 /* let telemetry transmit anyway (regardless of timeout) */
1997                 totx = totx || (myrpt->tele.next != &myrpt->tele);
1998                 if (totx && (!lasttx))
1999                 {
2000                         lasttx = 1;
2001                         ast_mutex_unlock(&myrpt->lock);
2002                         ast_indicate(myrpt->txchannel,AST_CONTROL_RADIO_KEY);
2003                         ast_mutex_lock(&myrpt->lock);
2004                 }
2005                 totx = totx && myrpt->enable;
2006                 if ((!totx) && lasttx)
2007                 {
2008                         lasttx = 0;
2009                         ast_mutex_unlock(&myrpt->lock);
2010                         ast_indicate(myrpt->txchannel,AST_CONTROL_RADIO_UNKEY);
2011                         ast_mutex_lock(&myrpt->lock);
2012                 }
2013                 time(&t);
2014                 /* if DTMF timeout */
2015                 if ((!myrpt->cmdnode[0]) && (myrpt->dtmfidx >= 0) && ((dtmf_time + DTMF_TIMEOUT) < t))
2016                 {
2017                         myrpt->dtmfidx = -1;
2018                         myrpt->dtmfbuf[0] = 0;
2019                 }                       
2020                 /* if remote DTMF timeout */
2021                 if ((myrpt->rem_dtmfidx >= 0) && ((myrpt->rem_dtmf_time + DTMF_TIMEOUT) < t))
2022                 {
2023                         myrpt->rem_dtmfidx = -1;
2024                         myrpt->rem_dtmfbuf[0] = 0;
2025                 }                       
2026                 n = 0;
2027                 cs[n++] = myrpt->rxchannel;
2028                 cs[n++] = myrpt->pchannel;
2029                 cs[n++] = myrpt->txpchannel;
2030                 if (myrpt->txchannel != myrpt->rxchannel) cs[n++] = myrpt->txchannel;
2031                 l = myrpt->links.next;
2032                 while(l != &myrpt->links)
2033                 {
2034                         cs[n++] = l->chan;
2035                         cs[n++] = l->pchan;
2036                         l = l->next;
2037                 }
2038                 ast_mutex_unlock(&myrpt->lock);
2039                 ms = MSWAIT;
2040                 who = ast_waitfor_n(cs,n,&ms);
2041                 if (who == NULL) ms = 0;
2042                 elap = MSWAIT - ms;
2043                 ast_mutex_lock(&myrpt->lock);
2044                 l = myrpt->links.next;
2045                 while(l != &myrpt->links)
2046                 {
2047                         /* ignore non-timing channels */
2048                         if (l->elaptime < 0)
2049                         {
2050                                 l = l->next;
2051                                 continue;
2052                         }
2053                         l->elaptime += elap;
2054                         /* if connection has taken too long */
2055                         if ((l->elaptime > MAXCONNECTTIME) && 
2056                            (l->chan->_state != AST_STATE_UP))
2057                         {
2058                                 ast_mutex_unlock(&myrpt->lock);
2059                                 ast_softhangup(l->chan,AST_SOFTHANGUP_DEV);
2060                                 rpt_telemetry(myrpt,CONNFAIL,l);
2061                                 ast_mutex_lock(&myrpt->lock);
2062                         }
2063                         l = l->next;
2064                 }
2065                 if (myrpt->tailtimer) myrpt->tailtimer -= elap;
2066                 if (myrpt->tailtimer < 0) myrpt->tailtimer = 0;
2067                 if (myrpt->totimer) myrpt->totimer -= elap;
2068                 if (myrpt->totimer < 0) myrpt->totimer = 0;
2069                 if (myrpt->idtimer) myrpt->idtimer -= elap;
2070                 if (myrpt->idtimer < 0) myrpt->idtimer = 0;
2071                 ast_mutex_unlock(&myrpt->lock);
2072                 if (!ms) continue;
2073                 if (who == myrpt->rxchannel) /* if it was a read from rx */
2074                 {
2075                         f = ast_read(myrpt->rxchannel);
2076                         if (!f)
2077                         {
2078                                 if (debug) printf("@@@@ rpt:Hung Up\n");
2079                                 break;
2080                         }
2081                         if (f->frametype == AST_FRAME_VOICE)
2082                         {
2083                                 ast_write(myrpt->pchannel,f);
2084                         }
2085                         else if (f->frametype == AST_FRAME_DTMF)
2086                         {
2087                                 char c;
2088
2089                                 c = (char) f->subclass; /* get DTMF char */
2090                                 if (c == '#')
2091                                 {
2092                                         /* if in simple mode, kill autopatch */
2093                                         if (myrpt->simple && myrpt->callmode)
2094                                         {
2095                                                 myrpt->callmode = 0;
2096                                                 rpt_telemetry(myrpt,TERM,NULL);
2097                                                 continue;
2098                                         }
2099                                         ast_mutex_lock(&myrpt->lock);
2100                                         if (myrpt->cmdnode[0])
2101                                         {
2102                                                 myrpt->cmdnode[0] = 0;
2103                                                 myrpt->dtmfidx = -1;
2104                                                 myrpt->dtmfbuf[0] = 0;
2105                                                 ast_mutex_unlock(&myrpt->lock);
2106                                                 rpt_telemetry(myrpt,COMPLETE,NULL);
2107                                         } else ast_mutex_unlock(&myrpt->lock);
2108                                         continue;
2109                                 }
2110                                 if (myrpt->cmdnode[0])
2111                                 {
2112                                         send_link_dtmf(myrpt,c);
2113                                         continue;
2114                                 }
2115                                 if (!myrpt->simple)
2116                                 {
2117                                         if (c == '*')
2118                                         {
2119                                                 myrpt->dtmfidx = 0;
2120                                                 myrpt->dtmfbuf[myrpt->dtmfidx] = 0;
2121                                                 time(&dtmf_time);
2122                                                 continue;
2123                                         } 
2124                                         else if ((c != '#') && (myrpt->dtmfidx >= 0))
2125                                         {
2126                                                 time(&dtmf_time);
2127                                                 if (myrpt->dtmfidx < MAXDTMF)
2128                                                 {
2129                                                         myrpt->dtmfbuf[myrpt->dtmfidx++] = c;
2130                                                         myrpt->dtmfbuf[myrpt->dtmfidx] = 0;
2131                                                         /* if to terminate function now */
2132                                                         if ((myrpt->dtmfidx == 1) && strchr(SHORTFUNCS,c))
2133                                                         {
2134                                                                 while(myrpt->dtmfidx < FUNCTION_LEN)
2135                                                                         myrpt->dtmfbuf[myrpt->dtmfidx++] = '0';
2136                                                                 myrpt->dtmfbuf[myrpt->dtmfidx] = 0;
2137                                                         }
2138                                                         /* if to terminate function now */
2139                                                         if ((myrpt->dtmfidx == 2) && strchr(MEDFUNCS,myrpt->dtmfbuf[0]))
2140                                                         {
2141                                                                 while(myrpt->dtmfidx < FUNCTION_LEN)
2142                                                                         myrpt->dtmfbuf[myrpt->dtmfidx++] = '0';
2143                                                                 myrpt->dtmfbuf[myrpt->dtmfidx] = 0;
2144                                                         }
2145                                                 }
2146                                                 if (myrpt->dtmfidx == FUNCTION_LEN)
2147                                                 {
2148                                                         process_dtmf(myrpt->dtmfbuf,myrpt,1);
2149                                                         myrpt->dtmfbuf[0] = 0;
2150                                                         myrpt->dtmfidx = -1;
2151                                                         continue;
2152                                                 }
2153                                         }
2154                                 }
2155                                 else
2156                                 {
2157                                         if ((!myrpt->callmode) && (c == '*'))
2158                                         {
2159                                                 myrpt->callmode = 1;
2160                                                 myrpt->cidx = 0;
2161                                                 myrpt->exten[myrpt->cidx] = 0;
2162                                                 pthread_attr_init(&attr);
2163                                                 pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
2164                                                 pthread_create(&myrpt->rpt_call_thread,&attr,rpt_call,(void *)myrpt);
2165                                                 continue;
2166                                         }
2167                                 }
2168                                 if (myrpt->callmode == 1)
2169                                 {
2170                                         myrpt->exten[myrpt->cidx++] = c;
2171                                         myrpt->exten[myrpt->cidx] = 0;
2172                                         /* if this exists */
2173                                         if (ast_exists_extension(myrpt->pchannel,myrpt->ourcontext,myrpt->exten,1,NULL))
2174                                         {
2175                                                 myrpt->callmode = 2;
2176                                                 rpt_telemetry(myrpt,PROC,NULL);
2177                                         }
2178                                         /* if can continue, do so */
2179                                         if (ast_canmatch_extension(myrpt->pchannel,myrpt->ourcontext,myrpt->exten,1,NULL)) continue;
2180                                         /* call has failed, inform user */
2181                                         myrpt->callmode = 4;
2182                                         continue;
2183                                 }
2184                                 if ((myrpt->callmode == 2) || (myrpt->callmode == 3))
2185                                 {
2186                                         myrpt->mydtmf = f->subclass;
2187                                 }
2188                         }                                               
2189                         else if (f->frametype == AST_FRAME_CONTROL)
2190                         {
2191                                 if (f->subclass == AST_CONTROL_HANGUP)
2192                                 {
2193                                         if (debug) printf("@@@@ rpt:Hung Up\n");
2194                                         ast_frfree(f);
2195                                         break;
2196                                 }
2197                                 /* if RX key */
2198                                 if (f->subclass == AST_CONTROL_RADIO_KEY)
2199                                 {
2200                                         if (debug) printf("@@@@ rx key\n");
2201                                         keyed = 1;
2202                                 }
2203                                 /* if RX un-key */
2204                                 if (f->subclass == AST_CONTROL_RADIO_UNKEY)
2205                                 {
2206                                         if (debug) printf("@@@@ rx un-key\n");
2207                                         keyed = 0;
2208                                         /* if we have remotes, twiddle */
2209                                         if (myrpt->cmdnode[0] || (myrpt->links.next != &myrpt->links))
2210                                         {
2211                                                 rpt_telemetry(myrpt,UNKEY,NULL);
2212                                         }
2213                                 }
2214                         }
2215                         ast_frfree(f);
2216                         continue;
2217                 }
2218                 if (who == myrpt->pchannel) /* if it was a read from pseudo */
2219                 {
2220                         f = ast_read(myrpt->pchannel);
2221                         if (!f)
2222                         {
2223                                 if (debug) printf("@@@@ rpt:Hung Up\n");
2224                                 break;
2225                         }
2226                         if (f->frametype == AST_FRAME_VOICE)
2227                         {
2228                                 ast_write(myrpt->txpchannel,f);
2229                         }
2230                         if (f->frametype == AST_FRAME_CONTROL)
2231                         {
2232                                 if (f->subclass == AST_CONTROL_HANGUP)
2233                                 {
2234                                         if (debug) printf("@@@@ rpt:Hung Up\n");
2235                                         ast_frfree(f);
2236                                         break;
2237                                 }
2238                         }
2239                         ast_frfree(f);
2240                         continue;
2241                 }
2242                 if (who == myrpt->txchannel) /* if it was a read from tx */
2243                 {
2244                         f = ast_read(myrpt->txchannel);
2245                         if (!f)
2246                         {
2247                                 if (debug) printf("@@@@ rpt:Hung Up\n");
2248                                 break;
2249                         }
2250                         if (f->frametype == AST_FRAME_CONTROL)
2251                         {
2252                                 if (f->subclass == AST_CONTROL_HANGUP)
2253                                 {
2254                                         if (debug) printf("@@@@ rpt:Hung Up\n");
2255                                         ast_frfree(f);
2256                                         break;
2257                                 }
2258                         }
2259                         ast_frfree(f);
2260                         continue;
2261                 }
2262                 toexit = 0;
2263                 l = myrpt->links.next;
2264                 while(l != &myrpt->links)
2265                 {
2266                         if (who == l->chan) /* if it was a read from rx */
2267                         {
2268                                 ast_mutex_lock(&myrpt->lock);
2269                                 remrx = 0;
2270                                 /* see if any other links are receiving */
2271                                 m = myrpt->links.next;
2272                                 while(m != &myrpt->links)
2273                                 {
2274                                         /* if not us, count it */
2275                                         if ((m != l) && (m->lastrx)) remrx = 1;
2276                                         m = m->next;
2277                                 }
2278                                 ast_mutex_unlock(&myrpt->lock);
2279                                 totx = (((l->isremote) ? myrpt->localtx : 
2280                                         myrpt->exttx) || remrx) && l->mode;
2281                                 if (l->lasttx != totx)
2282                                 {
2283                                         if (totx)
2284                                         {
2285                                                 ast_indicate(l->chan,AST_CONTROL_RADIO_KEY);
2286                                         }
2287                                         else
2288                                         {
2289                                                 ast_indicate(l->chan,AST_CONTROL_RADIO_UNKEY);
2290                                         }
2291                                 }
2292                                 l->lasttx = totx;
2293                                 f = ast_read(l->chan);
2294                                 if (!f)
2295                                 {
2296                                         ast_mutex_lock(&myrpt->lock);
2297                                         /* remove from queue */
2298                                         remque((struct qelem *) l);
2299                                         ast_mutex_unlock(&myrpt->lock);
2300                                         rpt_telemetry(myrpt,REMDISC,l);
2301                                         /* hang-up on call to device */
2302                                         ast_hangup(l->chan);
2303                                         ast_hangup(l->pchan);
2304                                         free(l);
2305                                         break;
2306                                 }
2307                                 if (f->frametype == AST_FRAME_VOICE)
2308                                 {
2309                                         ast_write(l->pchan,f);
2310                                 }
2311                                 if (f->frametype == AST_FRAME_TEXT)
2312                                 {
2313                                         handle_link_data(myrpt,l,f->data);
2314                                 }
2315                                 if (f->frametype == AST_FRAME_CONTROL)
2316                                 {
2317                                         if (f->subclass == AST_CONTROL_ANSWER)
2318                                         {
2319                                                 l->connected = 1;
2320                                                 l->elaptime = -1;
2321                                                 rpt_telemetry(myrpt,CONNECTED,l);
2322                                         }
2323                                         /* if RX key */
2324                                         if (f->subclass == AST_CONTROL_RADIO_KEY)
2325                                         {
2326                                                 if (debug) printf("@@@@ rx key\n");
2327                                                 l->lastrx = 1;
2328                                         }
2329                                         /* if RX un-key */
2330                                         if (f->subclass == AST_CONTROL_RADIO_UNKEY)
2331                                         {
2332                                                 if (debug) printf("@@@@ rx un-key\n");
2333                                                 l->lastrx = 0;
2334                                         }
2335                                         if (f->subclass == AST_CONTROL_HANGUP)
2336                                         {
2337                                                 ast_frfree(f);
2338                                                 ast_mutex_lock(&myrpt->lock);
2339                                                 /* remove from queue */
2340                                                 remque((struct qelem *) l);
2341                                                 ast_mutex_unlock(&myrpt->lock);
2342                                                 rpt_telemetry(myrpt,REMDISC,l);
2343                                                 /* hang-up on call to device */
2344                                                 ast_hangup(l->chan);
2345                                                 ast_hangup(l->pchan);
2346                                                 free(l);
2347                                                 break;
2348                                         }
2349                                 }
2350                                 ast_frfree(f);
2351                                 break;
2352                         }
2353                         if (who == l->pchan) 
2354                         {
2355                                 f = ast_read(l->pchan);
2356                                 if (!f)
2357                                 {
2358                                         if (debug) printf("@@@@ rpt:Hung Up\n");
2359                                         toexit = 1;
2360                                         break;
2361                                 }
2362                                 if (f->frametype == AST_FRAME_VOICE)
2363                                 {
2364                                         ast_write(l->chan,f);
2365                                 }
2366                                 if (f->frametype == AST_FRAME_CONTROL)
2367                                 {
2368                                         if (f->subclass == AST_CONTROL_HANGUP)
2369                                         {
2370                                                 if (debug) printf("@@@@ rpt:Hung Up\n");
2371                                                 ast_frfree(f);
2372                                                 toexit = 1;
2373                                                 break;
2374                                         }
2375                                 }
2376                                 ast_frfree(f);
2377                                 break;
2378                         }
2379                         l = l->next;
2380                 }
2381                 if (toexit) break;
2382                 if (who == myrpt->txpchannel) /* if it was a read from remote tx */
2383                 {
2384                         f = ast_read(myrpt->txpchannel);
2385                         if (!f)
2386                         {
2387                                 if (debug) printf("@@@@ rpt:Hung Up\n");
2388                                 break;
2389                         }
2390                         if (f->frametype == AST_FRAME_CONTROL)
2391                         {
2392                                 if (f->subclass == AST_CONTROL_HANGUP)
2393                                 {
2394                                         if (debug) printf("@@@@ rpt:Hung Up\n");
2395                                         ast_frfree(f);
2396                                         break;
2397                                 }
2398                         }
2399                         ast_frfree(f);
2400                         continue;
2401                 }
2402         }
2403         ast_mutex_lock(&myrpt->lock);
2404         ast_hangup(myrpt->pchannel);
2405         ast_hangup(myrpt->txpchannel);
2406         ast_hangup(myrpt->rxchannel);
2407         if (myrpt->txchannel != myrpt->rxchannel) ast_hangup(myrpt->txchannel);
2408         l = myrpt->links.next;
2409         while(l != &myrpt->links)
2410         {
2411                 struct rpt_link *ll = l;
2412                 /* remove from queue */
2413                 remque((struct qelem *) l);
2414                 /* hang-up on call to device */
2415                 ast_hangup(l->chan);
2416                 ast_hangup(l->pchan);
2417                 l = l->next;
2418                 free(ll);
2419         }
2420         ast_mutex_unlock(&myrpt->lock);
2421         if (debug) printf("@@@@ rpt:Hung up channel\n");
2422         pthread_exit(NULL); 
2423         return NULL;
2424 }
2425
2426 static void *rpt_master(void *ignore)
2427 {
2428 char *this,*val;
2429 int     i,n;
2430
2431         /* start with blank config */
2432         memset(&rpt_vars,0,sizeof(rpt_vars));
2433
2434         cfg = ast_load("rpt.conf");
2435         if (!cfg) {
2436                 ast_log(LOG_NOTICE, "Unable to open radio repeater configuration rpt.conf.  Radio Repeater disabled.\n");
2437                 pthread_exit(NULL);
2438         }
2439
2440         /* go thru all the specified repeaters */
2441         this = NULL;
2442         n = 0;
2443         while((this = ast_category_browse(cfg,this)) != NULL)
2444         {
2445                 if (!strcmp(this,NODES)) continue;
2446                 if (!strcmp(this,MEMORY)) continue;
2447                 ast_log(LOG_DEBUG,"Loading config for repeater %s\n",this);
2448                 ast_mutex_init(&rpt_vars[n].lock);
2449                 rpt_vars[n].tele.next = &rpt_vars[n].tele;
2450                 rpt_vars[n].tele.prev = &rpt_vars[n].tele;
2451                 rpt_vars[n].name = this;
2452                 rpt_vars[n].rxchanname = ast_variable_retrieve(cfg,this,"rxchannel");
2453                 rpt_vars[n].txchanname = ast_variable_retrieve(cfg,this,"txchannel");
2454                 rpt_vars[n].ourcontext = ast_variable_retrieve(cfg,this,"context");
2455                 if (!rpt_vars[n].ourcontext) rpt_vars[n].ourcontext = this;
2456                 rpt_vars[n].ourcallerid = ast_variable_retrieve(cfg,this,"callerid");
2457                 rpt_vars[n].acctcode = ast_variable_retrieve(cfg,this,"accountcode");
2458                 rpt_vars[n].ident = ast_variable_retrieve(cfg,this,"idrecording");
2459                 val = ast_variable_retrieve(cfg,this,"hangtime");
2460                 if (val) rpt_vars[n].hangtime = atoi(val);
2461                         else rpt_vars[n].hangtime = HANGTIME;
2462                 val = ast_variable_retrieve(cfg,this,"totime");
2463                 if (val) rpt_vars[n].totime = atoi(val);
2464                         else rpt_vars[n].totime = TOTIME;
2465                 val = ast_variable_retrieve(cfg,this,"idtime");
2466                 if (val) rpt_vars[n].idtime = atoi(val);
2467                         else rpt_vars[n].idtime = IDTIME;
2468                 val = ast_variable_retrieve(cfg,this,"simple");
2469                 if (val) rpt_vars[n].simple = ast_true(val); 
2470                         else rpt_vars[n].simple = 0;
2471                 val = ast_variable_retrieve(cfg,this,"remote");
2472                 if (val) rpt_vars[n].remote = ast_true(val); 
2473                         else rpt_vars[n].remote = 0;
2474                 rpt_vars[n].tonezone = ast_variable_retrieve(cfg,this,"tonezone");
2475                 val = ast_variable_retrieve(cfg,this,"iobase");
2476                 if (val) rpt_vars[n].iobase = atoi(val);
2477                 else rpt_vars[n].iobase = DEFAULT_IOBASE;
2478                 n++;
2479         }
2480         nrpts = n;
2481         ast_log(LOG_DEBUG, "Total of %d repeaters configured.\n",n);
2482         /* start em all */
2483         for(i = 0; i < n; i++)
2484         {
2485                 if (!rpt_vars[i].rxchanname)
2486                 {
2487                         ast_log(LOG_WARNING,"Did not specify rxchanname for node %s\n",rpt_vars[i].name);
2488                         pthread_exit(NULL);
2489                 }
2490                 /* if is a remote, dont start one for it */
2491                 if (rpt_vars[i].remote)
2492                 {
2493                         strcpy(rpt_vars[i].freq,"146.460");
2494                         strcpy(rpt_vars[i].rxpl,"100.0");
2495                         rpt_vars[i].offset = REM_SIMPLEX;
2496                         rpt_vars[i].powerlevel = REM_MEDPWR;
2497                         continue;
2498                 }
2499                 if (!rpt_vars[i].ident)
2500                 {
2501                         ast_log(LOG_WARNING,"Did not specify ident for node %s\n",rpt_vars[i].name);
2502                         pthread_exit(NULL);
2503                 }
2504                 pthread_create(&rpt_vars[i].rpt_thread,NULL,rpt,(void *) &rpt_vars[i]);
2505         }
2506         /* wait for first one to die (should be never) */
2507         pthread_join(rpt_vars[0].rpt_thread,NULL);
2508         pthread_exit(NULL);
2509 }
2510
2511 static int rpt_exec(struct ast_channel *chan, void *data)
2512 {
2513         int res=-1,i,keyed = 0,rem_totx;
2514         struct localuser *u;
2515         char tmp[256];
2516         char *options,*stringp,*tele;
2517         struct  rpt *myrpt;
2518         struct ast_frame *f;
2519         struct ast_channel *who;
2520         struct ast_channel *cs[20];
2521         struct  rpt_link *l;
2522         ZT_CONFINFO ci;  /* conference info */
2523         int ms,elap;
2524
2525         if (!data || ast_strlen_zero((char *)data)) {
2526                 ast_log(LOG_WARNING, "Rpt requires an argument (system node)\n");
2527                 return -1;
2528         }
2529         strncpy(tmp, (char *)data, sizeof(tmp)-1);
2530         stringp=tmp;
2531         strsep(&stringp, "|");
2532         options = strsep(&stringp, "|");
2533         myrpt = NULL;
2534         /* see if we can find our specified one */
2535         for(i = 0; i < nrpts; i++)
2536         {
2537                 /* if name matches, assign it and exit loop */
2538                 if (!strcmp(tmp,rpt_vars[i].name))
2539                 {
2540                         myrpt = &rpt_vars[i];
2541                         break;
2542                 }
2543         }
2544         if (myrpt == NULL)
2545         {
2546                 ast_log(LOG_WARNING, "Cannot find specified system node %s\n",tmp);
2547                 return -1;
2548         }
2549         /* if is not a remote */
2550         if (!myrpt->remote)
2551         {
2552                 char *b,*b1;
2553
2554                 /* look at callerid to see what node this comes from */
2555                 if (!chan->callerid) /* if doesnt have callerid */
2556                 {
2557                         ast_log(LOG_WARNING, "Trying to use busy link on %s\n",tmp);
2558                         return -1;
2559                 }
2560                 ast_callerid_parse(chan->callerid,&b,&b1);
2561                 ast_shrink_phone_number(b1);
2562                 if (!strcmp(myrpt->name,b1))
2563                 {
2564                         ast_log(LOG_WARNING, "Trying to link to self!!\n");
2565                         return -1;
2566                 }
2567                 ast_mutex_lock(&myrpt->lock);
2568                 l = myrpt->links.next;
2569                 /* try to find this one in queue */
2570                 while(l != &myrpt->links)
2571                 {
2572                         /* if found matching string */
2573                         if (!strcmp(l->name,b1)) break;
2574                         l = l->next;
2575                 }
2576                 /* if found */
2577                 if (l != &myrpt->links) 
2578                 {
2579                         /* remove from queue */
2580                         remque((struct qelem *) l);
2581                         ast_mutex_unlock(&myrpt->lock);
2582                         /* hang-up on call to device */
2583                         ast_hangup(l->chan);
2584                         ast_hangup(l->pchan);
2585                         free(l);
2586                         usleep(500000); 
2587                 } else 
2588                         ast_mutex_unlock(&myrpt->lock);
2589                 /* establish call in tranceive mode */
2590                 l = malloc(sizeof(struct rpt_link));
2591                 if (!l)
2592                 {
2593                         ast_log(LOG_WARNING, "Unable to malloc\n");
2594                         pthread_exit(NULL);
2595                 }
2596                 /* zero the silly thing */
2597                 memset((char *)l,0,sizeof(struct rpt_link));
2598                 l->mode = 1;
2599                 strncpy(l->name,b1,MAXNODESTR - 1);
2600                 l->isremote = 0;
2601                 l->chan = chan;
2602                 l->connected = 1;
2603                 ast_set_read_format(l->chan,AST_FORMAT_SLINEAR);
2604                 ast_set_write_format(l->chan,AST_FORMAT_SLINEAR);
2605                 /* allocate a pseudo-channel thru asterisk */
2606                 l->pchan = ast_request("zap",AST_FORMAT_SLINEAR,"pseudo");
2607                 if (!l->pchan)
2608                 {
2609                         fprintf(stderr,"rpt:Sorry unable to obtain pseudo channel\n");
2610                         pthread_exit(NULL);
2611                 }
2612                 ast_set_read_format(l->pchan,AST_FORMAT_SLINEAR);
2613                 ast_set_write_format(l->pchan,AST_FORMAT_SLINEAR);
2614                 /* make a conference for the tx */
2615                 ci.chan = 0;
2616                 ci.confno = myrpt->conf;
2617                 ci.confmode = ZT_CONF_CONF | ZT_CONF_LISTENER | ZT_CONF_TALKER;
2618                 /* first put the channel on the conference in proper mode */
2619                 if (ioctl(l->pchan->fds[0],ZT_SETCONF,&ci) == -1)
2620                 {
2621                         ast_log(LOG_WARNING, "Unable to set conference mode to Announce\n");
2622                         pthread_exit(NULL);
2623                 }
2624                 ast_mutex_lock(&myrpt->lock);
2625                 /* insert at end of queue */
2626                 insque((struct qelem *)l,(struct qelem *)myrpt->links.next);
2627                 ast_mutex_unlock(&myrpt->lock);
2628                 if (chan->_state != AST_STATE_UP) {
2629                         ast_answer(chan);
2630                 }
2631                 return AST_PBX_KEEPALIVE;
2632         }
2633         /* if remote, error if anyone else already linked */
2634         if (myrpt->remoteon)
2635         {
2636                 ast_mutex_unlock(&myrpt->lock);
2637                 ast_log(LOG_WARNING, "Trying to use busy link on %s\n",tmp);
2638                 return -1;
2639         }
2640         if (ioperm(myrpt->iobase,1,1) == -1)
2641         {
2642                 ast_mutex_unlock(&myrpt->lock);
2643                 ast_log(LOG_WARNING, "Cant get io permission on IO port %x hex\n",myrpt->iobase);
2644                 return -1;
2645         }
2646         LOCAL_USER_ADD(u);
2647         tele = strchr(myrpt->rxchanname,'/');
2648         if (!tele)
2649         {
2650                 fprintf(stderr,"rpt:Dial number must be in format tech/number\n");
2651                 ast_mutex_unlock(&myrpt->lock);
2652                 pthread_exit(NULL);
2653         }
2654         *tele++ = 0;
2655         ast_mutex_lock(&myrpt->lock);
2656         myrpt->rxchannel = ast_request(myrpt->rxchanname,AST_FORMAT_SLINEAR,tele);
2657         if (myrpt->rxchannel)
2658         {
2659                 ast_set_read_format(myrpt->rxchannel,AST_FORMAT_SLINEAR);
2660                 ast_set_write_format(myrpt->rxchannel,AST_FORMAT_SLINEAR);
2661                 myrpt->rxchannel->whentohangup = 0;
2662                 myrpt->rxchannel->appl = "Apprpt";
2663                 myrpt->rxchannel->data = "(Repeater Rx)";
2664                 if (option_verbose > 2)
2665                         ast_verbose(VERBOSE_PREFIX_3 "rpt (Rx) initiating call to %s/%s on %s\n",
2666                                 myrpt->rxchanname,tele,myrpt->rxchannel->name);
2667                 ast_mutex_unlock(&myrpt->lock);
2668                 ast_call(myrpt->rxchannel,tele,999);
2669                 ast_mutex_lock(&myrpt->lock);
2670         }
2671         else
2672         {
2673                 fprintf(stderr,"rpt:Sorry unable to obtain Rx channel\n");
2674                 ast_mutex_unlock(&myrpt->lock);
2675                 pthread_exit(NULL);
2676         }
2677         *--tele = '/';
2678         if (myrpt->txchanname)
2679         {
2680                 tele = strchr(myrpt->txchanname,'/');
2681                 if (!tele)
2682                 {
2683                         fprintf(stderr,"rpt:Dial number must be in format tech/number\n");
2684                         ast_mutex_unlock(&myrpt->lock);
2685                         pthread_exit(NULL);
2686                 }
2687                 *tele++ = 0;
2688                 myrpt->txchannel = ast_request(myrpt->txchanname,AST_FORMAT_SLINEAR,tele);
2689                 if (myrpt->txchannel)
2690                 {
2691                         ast_set_read_format(myrpt->txchannel,AST_FORMAT_SLINEAR);
2692                         ast_set_write_format(myrpt->txchannel,AST_FORMAT_SLINEAR);
2693                         myrpt->txchannel->whentohangup = 0;
2694                         myrpt->txchannel->appl = "Apprpt";
2695                         myrpt->txchannel->data = "(Repeater Rx)";
2696                         if (option_verbose > 2)
2697                                 ast_verbose(VERBOSE_PREFIX_3 "rpt (Tx) initiating call to %s/%s on %s\n",
2698                                         myrpt->txchanname,tele,myrpt->txchannel->name);
2699                         ast_mutex_unlock(&myrpt->lock);
2700                         ast_call(myrpt->txchannel,tele,999);
2701                         ast_mutex_lock(&myrpt->lock);
2702                 }
2703                 else
2704                 {
2705                         fprintf(stderr,"rpt:Sorry unable to obtain Tx channel\n");
2706                         ast_mutex_unlock(&myrpt->lock);
2707                         pthread_exit(NULL);
2708                 }
2709                 *--tele = '/';
2710         }
2711         else
2712         {
2713                 myrpt->txchannel = myrpt->rxchannel;
2714         }
2715         myrpt->remoterx = 0;
2716         myrpt->remotetx = 0;
2717         myrpt->remoteon = 1;
2718         myrpt->dtmfidx = -1;
2719         myrpt->dtmfbuf[0] = 0;
2720         myrpt->dtmf_time_rem = 0;
2721         ast_mutex_unlock(&myrpt->lock);
2722         setrbi(myrpt);
2723         ast_set_write_format(chan, AST_FORMAT_SLINEAR);
2724         ast_set_read_format(chan, AST_FORMAT_SLINEAR);
2725         /* if we are on 2w loop and are a remote, turn EC on */
2726         if (myrpt->remote && (myrpt->rxchannel == myrpt->txchannel))
2727         {
2728                 i = 128;
2729                 ioctl(myrpt->rxchannel->fds[0],ZT_ECHOCANCEL,&i);
2730         }
2731         if (chan->_state != AST_STATE_UP) {
2732                 ast_answer(chan);
2733         }
2734         cs[0] = chan;
2735         cs[1] = myrpt->rxchannel;
2736         for(;;)
2737         {
2738                 if (ast_check_hangup(chan)) break;
2739                 if (ast_check_hangup(myrpt->rxchannel)) break;
2740                 ms = MSWAIT;
2741                 who = ast_waitfor_n(cs,2,&ms);
2742                 if (who == NULL) ms = 0;
2743                 elap = MSWAIT - ms;
2744                 if (!ms) continue;
2745                 rem_totx = keyed;
2746                 if (rem_totx && (!myrpt->remotetx))
2747                 {
2748                         myrpt->remotetx = 1;
2749                         ast_indicate(myrpt->txchannel,AST_CONTROL_RADIO_KEY);
2750                 }
2751                 if ((!rem_totx) && myrpt->remotetx)
2752                 {
2753                         myrpt->remotetx = 0;
2754                         ast_indicate(myrpt->txchannel,AST_CONTROL_RADIO_UNKEY);
2755                 }
2756                 if (who == chan) /* if it was a read from incomming */
2757                 {
2758                         f = ast_read(chan);
2759                         if (!f)
2760                         {
2761                                 if (debug) printf("@@@@ link:Hung Up\n");
2762                                 break;
2763                         }
2764                         if (f->frametype == AST_FRAME_VOICE)
2765                         {
2766                                 /* if not transmitting, zero-out audio */
2767                                 if (!myrpt->remotetx)
2768                                         memset(f->data,0,f->datalen);
2769                                 ast_write(myrpt->txchannel,f);
2770                         }
2771                         else if (f->frametype == AST_FRAME_TEXT)
2772                         {
2773                                 if (handle_remote_data(myrpt,f->data,chan) == -1)
2774                                 {
2775                                         if (debug) printf("@@@@ rpt:Hung Up\n");
2776                                         ast_frfree(f);
2777                                         break;
2778                                 }
2779                         }
2780                         else if (f->frametype == AST_FRAME_CONTROL)
2781                         {
2782                                 if (f->subclass == AST_CONTROL_HANGUP)
2783                                 {
2784                                         if (debug) printf("@@@@ rpt:Hung Up\n");
2785                                         ast_frfree(f);
2786                                         break;
2787                                 }
2788                                 /* if RX key */
2789                                 if (f->subclass == AST_CONTROL_RADIO_KEY)
2790                                 {
2791                                         if (debug) printf("@@@@ rx key\n");
2792                                         keyed = 1;
2793                                 }
2794                                 /* if RX un-key */
2795                                 if (f->subclass == AST_CONTROL_RADIO_UNKEY)
2796                                 {
2797                                         if (debug) printf("@@@@ rx un-key\n");
2798                                         keyed = 0;
2799                                 }
2800                         }
2801                         ast_frfree(f);
2802                         continue;
2803                 }
2804                 if (who == myrpt->rxchannel) /* if it was a read from radio */
2805                 {
2806                         f = ast_read(myrpt->rxchannel);
2807                         if (!f)
2808                         {
2809                                 if (debug) printf("@@@@ link:Hung Up\n");
2810                                 break;
2811                         }
2812                         if (f->frametype == AST_FRAME_VOICE)
2813                         {
2814                                 if ((myrpt->remote) && (myrpt->remotetx))
2815                                         memset(f->data,0,f->datalen);
2816                                  ast_write(chan,f);
2817                         }
2818                         else if (f->frametype == AST_FRAME_CONTROL)
2819                         {
2820                                 if (f->subclass == AST_CONTROL_HANGUP)
2821                                 {
2822                                         if (debug) printf("@@@@ rpt:Hung Up\n");
2823                                         ast_frfree(f);
2824                                         break;
2825                                 }
2826                                 /* if RX key */
2827                                 if (f->subclass == AST_CONTROL_RADIO_KEY)
2828                                 {
2829                                         if (debug) printf("@@@@ remote rx key\n");
2830                                         if (!myrpt->remotetx)
2831                                         {
2832                                                 ast_indicate(chan,AST_CONTROL_RADIO_KEY);
2833                                                 myrpt->remoterx = 1;
2834                                         }
2835                                 }
2836                                 /* if RX un-key */
2837                                 if (f->subclass == AST_CONTROL_RADIO_UNKEY)
2838                                 {
2839                                         if (debug) printf("@@@@ remote rx un-key\n");
2840                                         if (!myrpt->remotetx) 
2841                                         {
2842                                                 ast_indicate(chan,AST_CONTROL_RADIO_UNKEY);
2843                                                 myrpt->remoterx = 0;
2844                                         }
2845                                 }
2846                         }
2847                         ast_frfree(f);
2848                         continue;
2849                 }
2850
2851         }
2852         ast_mutex_lock(&myrpt->lock);
2853         if (myrpt->rxchannel != myrpt->txchannel) ast_hangup(myrpt->txchannel);
2854         ast_hangup(myrpt->rxchannel);
2855         myrpt->remoteon = 0;
2856         ast_mutex_unlock(&myrpt->lock);
2857         LOCAL_USER_REMOVE(u);
2858         return res;
2859 }
2860
2861 int unload_module(void)
2862 {
2863         int i;
2864
2865         STANDARD_HANGUP_LOCALUSERS;
2866         for(i = 0; i < nrpts; i++) {
2867                 if (!strcmp(rpt_vars[i].name,NODES)) continue;
2868                 ast_mutex_destroy(&rpt_vars[i].lock);
2869         }
2870         return ast_unregister_application(app);
2871         return 0;
2872 }
2873
2874 int load_module(void)
2875 {
2876         pthread_create(&rpt_master_thread,NULL,rpt_master,NULL);
2877         return ast_register_application(app, rpt_exec, synopsis, descrip);
2878 }
2879
2880 char *description(void)
2881 {
2882         return tdesc;
2883 }
2884
2885 int usecount(void)
2886 {
2887         int res;
2888         STANDARD_USECOUNT(res);
2889         return res;
2890 }
2891
2892 char *key()
2893 {
2894         return ASTERISK_GPL_KEY;
2895 }