Merged revisions 43697 via svnmerge from
[asterisk/asterisk.git] / channels / chan_local.c
1 /*
2  * Asterisk -- An open source telephony toolkit.
3  *
4  * Copyright (C) 1999 - 2005, Digium, Inc.
5  *
6  * Mark Spencer <markster@digium.com>
7  *
8  * See http://www.asterisk.org for more information about
9  * the Asterisk project. Please do not directly contact
10  * any of the maintainers of this project for assistance;
11  * the project provides a web site, mailing lists and IRC
12  * channels for your use.
13  *
14  * This program is free software, distributed under the terms of
15  * the GNU General Public License Version 2. See the LICENSE file
16  * at the top of the source tree.
17  */
18
19 /*! \file
20  *
21  * \author Mark Spencer <markster@digium.com>
22  *
23  * \brief Local Proxy Channel
24  * 
25  * \ingroup channel_drivers
26  */
27
28 #include "asterisk.h"
29
30 ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
31
32 #include <stdio.h>
33 #include <string.h>
34 #include <unistd.h>
35 #include <sys/socket.h>
36 #include <errno.h>
37 #include <stdlib.h>
38 #include <fcntl.h>
39 #include <netdb.h>
40 #include <netinet/in.h>
41 #include <arpa/inet.h>
42 #include <sys/signal.h>
43
44 #include "asterisk/lock.h"
45 #include "asterisk/channel.h"
46 #include "asterisk/config.h"
47 #include "asterisk/logger.h"
48 #include "asterisk/module.h"
49 #include "asterisk/pbx.h"
50 #include "asterisk/options.h"
51 #include "asterisk/lock.h"
52 #include "asterisk/sched.h"
53 #include "asterisk/io.h"
54 #include "asterisk/rtp.h"
55 #include "asterisk/acl.h"
56 #include "asterisk/callerid.h"
57 #include "asterisk/file.h"
58 #include "asterisk/cli.h"
59 #include "asterisk/app.h"
60 #include "asterisk/musiconhold.h"
61 #include "asterisk/manager.h"
62 #include "asterisk/stringfields.h"
63 #include "asterisk/devicestate.h"
64
65 static const char tdesc[] = "Local Proxy Channel Driver";
66
67 #define IS_OUTBOUND(a,b) (a == b->chan ? 1 : 0)
68
69 static struct ast_channel *local_request(const char *type, int format, void *data, int *cause);
70 static int local_digit_begin(struct ast_channel *ast, char digit);
71 static int local_digit_end(struct ast_channel *ast, char digit);
72 static int local_call(struct ast_channel *ast, char *dest, int timeout);
73 static int local_hangup(struct ast_channel *ast);
74 static int local_answer(struct ast_channel *ast);
75 static struct ast_frame *local_read(struct ast_channel *ast);
76 static int local_write(struct ast_channel *ast, struct ast_frame *f);
77 static int local_indicate(struct ast_channel *ast, int condition, const void *data, size_t datalen);
78 static int local_fixup(struct ast_channel *oldchan, struct ast_channel *newchan);
79 static int local_sendhtml(struct ast_channel *ast, int subclass, const char *data, int datalen);
80 static int local_sendtext(struct ast_channel *ast, const char *text);
81 static int local_devicestate(void *data);
82
83 /* PBX interface structure for channel registration */
84 static const struct ast_channel_tech local_tech = {
85         .type = "Local",
86         .description = tdesc,
87         .capabilities = -1,
88         .requester = local_request,
89         .send_digit_begin = local_digit_begin,
90         .send_digit_end = local_digit_end,
91         .call = local_call,
92         .hangup = local_hangup,
93         .answer = local_answer,
94         .read = local_read,
95         .write = local_write,
96         .write_video = local_write,
97         .exception = local_read,
98         .indicate = local_indicate,
99         .fixup = local_fixup,
100         .send_html = local_sendhtml,
101         .send_text = local_sendtext,
102         .devicestate = local_devicestate,
103 };
104
105 struct local_pvt {
106         ast_mutex_t lock;                       /* Channel private lock */
107         unsigned int flags;                     /* Private flags */
108         char context[AST_MAX_CONTEXT];          /* Context to call */
109         char exten[AST_MAX_EXTENSION];          /* Extension to call */
110         int reqformat;                          /* Requested format */
111         struct ast_channel *owner;              /* Master Channel */
112         struct ast_channel *chan;               /* Outbound channel */
113         struct ast_module_user *u_owner;        /*! reference to keep the module loaded while in use */
114         struct ast_module_user *u_chan;         /*! reference to keep the module loaded while in use */
115         AST_LIST_ENTRY(local_pvt) list;         /* Next entity */
116 };
117
118 #define LOCAL_GLARE_DETECT    (1 << 0) /*!< Detect glare on hangup */
119 #define LOCAL_CANCEL_QUEUE    (1 << 1) /*!< Cancel queue */
120 #define LOCAL_ALREADY_MASQED  (1 << 2) /*!< Already masqueraded */
121 #define LOCAL_LAUNCHED_PBX    (1 << 3) /*!< PBX was launched */
122 #define LOCAL_NO_OPTIMIZATION (1 << 4) /*!< Do not optimize using masquerading */
123
124 static AST_LIST_HEAD_STATIC(locals, local_pvt);
125
126 /*! \brief Adds devicestate to local channels */
127 static int local_devicestate(void *data)
128 {
129         char *exten = ast_strdupa(data);
130         char *context = NULL, *opts = NULL;
131         int res;
132
133         if (!(context = strchr(exten, '@'))) {
134                 ast_log(LOG_WARNING, "Someone used Local/%s somewhere without a @context. This is bad.\n", exten);
135                 return AST_DEVICE_INVALID;      
136         }
137
138         *context++ = '\0';
139
140         /* Strip options if they exist */
141         if ((opts = strchr(context, '/')))
142                 *opts = '\0';
143
144         if (option_debug > 2)
145                 ast_log(LOG_DEBUG, "Checking if extension %s@%s exists (devicestate)\n", exten, context);
146         res = ast_exists_extension(NULL, context, exten, 1, NULL);
147         if (!res)               
148                 return AST_DEVICE_INVALID;
149         else
150                 return AST_DEVICE_UNKNOWN;
151 }
152
153 static int local_queue_frame(struct local_pvt *p, int isoutbound, struct ast_frame *f, struct ast_channel *us)
154 {
155         struct ast_channel *other = NULL;
156
157 retrylock:              
158
159         /* Recalculate outbound channel */
160         other = isoutbound ? p->owner : p->chan;
161
162         /* Set glare detection */
163         ast_set_flag(p, LOCAL_GLARE_DETECT);
164         if (ast_test_flag(p, LOCAL_CANCEL_QUEUE)) {
165                 /* We had a glare on the hangup.  Forget all this business,
166                 return and destroy p.  */
167                 ast_mutex_unlock(&p->lock);
168                 ast_mutex_destroy(&p->lock);
169                 free(p);
170                 return -1;
171         }
172         if (!other) {
173                 ast_clear_flag(p, LOCAL_GLARE_DETECT);
174                 return 0;
175         }
176         if (ast_mutex_trylock(&other->lock)) {
177                 /* Failed to lock.  Release main lock and try again */
178                 ast_mutex_unlock(&p->lock);
179                 if (us) {
180                         if (ast_mutex_unlock(&us->lock)) {
181                                 ast_log(LOG_WARNING, "%s wasn't locked while sending %d/%d\n",
182                                         us->name, f->frametype, f->subclass);
183                                 us = NULL;
184                         }
185                 }
186                 /* Wait just a bit */
187                 usleep(1);
188                 /* Only we can destroy ourselves, so we can't disappear here */
189                 if (us)
190                         ast_mutex_lock(&us->lock);
191                 ast_mutex_lock(&p->lock);
192                 goto retrylock;
193         }
194         ast_queue_frame(other, f);
195         ast_mutex_unlock(&other->lock);
196         ast_clear_flag(p, LOCAL_GLARE_DETECT);
197         return 0;
198 }
199
200 static int local_answer(struct ast_channel *ast)
201 {
202         struct local_pvt *p = ast->tech_pvt;
203         int isoutbound;
204         int res = -1;
205
206         ast_mutex_lock(&p->lock);
207         isoutbound = IS_OUTBOUND(ast, p);
208         if (isoutbound) {
209                 /* Pass along answer since somebody answered us */
210                 struct ast_frame answer = { AST_FRAME_CONTROL, AST_CONTROL_ANSWER };
211                 res = local_queue_frame(p, isoutbound, &answer, ast);
212         } else
213                 ast_log(LOG_WARNING, "Huh?  Local is being asked to answer?\n");
214         ast_mutex_unlock(&p->lock);
215         return res;
216 }
217
218 static void check_bridge(struct local_pvt *p, int isoutbound)
219 {
220         if (ast_test_flag(p, LOCAL_ALREADY_MASQED) || ast_test_flag(p, LOCAL_NO_OPTIMIZATION) || !p->chan || !p->owner)
221                 return;
222
223         /* only do the masquerade if we are being called on the outbound channel,
224            if it has been bridged to another channel and if there are no pending
225            frames on the owner channel (because they would be transferred to the
226            outbound channel during the masquerade)
227         */
228         if (isoutbound && p->chan->_bridge /* Not ast_bridged_channel!  Only go one step! */ && AST_LIST_EMPTY(&p->owner->readq)) {
229                 /* Masquerade bridged channel into owner */
230                 /* Lock everything we need, one by one, and give up if
231                    we can't get everything.  Remember, we'll get another
232                    chance in just a little bit */
233                 if (!ast_mutex_trylock(&(p->chan->_bridge)->lock)) {
234                         if (!p->chan->_bridge->_softhangup) {
235                                 if (!ast_mutex_trylock(&p->owner->lock)) {
236                                         if (!p->owner->_softhangup) {
237                                                 ast_channel_masquerade(p->owner, p->chan->_bridge);
238                                                 ast_set_flag(p, LOCAL_ALREADY_MASQED);
239                                         }
240                                         ast_mutex_unlock(&p->owner->lock);
241                                 }
242                                 ast_mutex_unlock(&(p->chan->_bridge)->lock);
243                         }
244                 }
245         /* We only allow masquerading in one 'direction'... it's important to preserve the state
246            (group variables, etc.) that live on p->chan->_bridge (and were put there by the dialplan)
247            when the local channels go away.
248         */
249 #if 0
250         } else if (!isoutbound && p->owner && p->owner->_bridge && p->chan && AST_LIST_EMPTY(&p->chan->readq)) {
251                 /* Masquerade bridged channel into chan */
252                 if (!ast_mutex_trylock(&(p->owner->_bridge)->lock)) {
253                         if (!p->owner->_bridge->_softhangup) {
254                                 if (!ast_mutex_trylock(&p->chan->lock)) {
255                                         if (!p->chan->_softhangup) {
256                                                 ast_channel_masquerade(p->chan, p->owner->_bridge);
257                                                 ast_set_flag(p, LOCAL_ALREADY_MASQED);
258                                         }
259                                         ast_mutex_unlock(&p->chan->lock);
260                                 }
261                         }
262                         ast_mutex_unlock(&(p->owner->_bridge)->lock);
263                 }
264 #endif
265         }
266 }
267
268 static struct ast_frame  *local_read(struct ast_channel *ast)
269 {
270         return &ast_null_frame;
271 }
272
273 static int local_write(struct ast_channel *ast, struct ast_frame *f)
274 {
275         struct local_pvt *p = ast->tech_pvt;
276         int res = -1;
277         int isoutbound;
278
279         /* Just queue for delivery to the other side */
280         ast_mutex_lock(&p->lock);
281         isoutbound = IS_OUTBOUND(ast, p);
282         if (f && (f->frametype == AST_FRAME_VOICE || f->frametype == AST_FRAME_VIDEO))
283                 check_bridge(p, isoutbound);
284         if (!ast_test_flag(p, LOCAL_ALREADY_MASQED))
285                 res = local_queue_frame(p, isoutbound, f, ast);
286         else {
287                 if (option_debug)
288                         ast_log(LOG_DEBUG, "Not posting to queue since already masked on '%s'\n", ast->name);
289                 res = 0;
290         }
291         ast_mutex_unlock(&p->lock);
292         return res;
293 }
294
295 static int local_fixup(struct ast_channel *oldchan, struct ast_channel *newchan)
296 {
297         struct local_pvt *p = newchan->tech_pvt;
298         ast_mutex_lock(&p->lock);
299
300         if ((p->owner != oldchan) && (p->chan != oldchan)) {
301                 ast_log(LOG_WARNING, "Old channel wasn't %p but was %p/%p\n", oldchan, p->owner, p->chan);
302                 ast_mutex_unlock(&p->lock);
303                 return -1;
304         }
305         if (p->owner == oldchan)
306                 p->owner = newchan;
307         else
308                 p->chan = newchan;
309         ast_mutex_unlock(&p->lock);
310         return 0;
311 }
312
313 static int local_indicate(struct ast_channel *ast, int condition, const void *data, size_t datalen)
314 {
315         struct local_pvt *p = ast->tech_pvt;
316         int res = -1;
317         struct ast_frame f = { AST_FRAME_CONTROL, };
318         int isoutbound;
319
320         /* Queue up a frame representing the indication as a control frame */
321         ast_mutex_lock(&p->lock);
322         isoutbound = IS_OUTBOUND(ast, p);
323         f.subclass = condition;
324         f.data = (void*)data;
325         f.datalen = datalen;
326         res = local_queue_frame(p, isoutbound, &f, ast);
327         ast_mutex_unlock(&p->lock);
328         return res;
329 }
330
331 static int local_digit_begin(struct ast_channel *ast, char digit)
332 {
333         struct local_pvt *p = ast->tech_pvt;
334         int res = -1;
335         struct ast_frame f = { AST_FRAME_DTMF_BEGIN, };
336         int isoutbound;
337
338         ast_mutex_lock(&p->lock);
339         isoutbound = IS_OUTBOUND(ast, p);
340         f.subclass = digit;
341         res = local_queue_frame(p, isoutbound, &f, ast);
342         ast_mutex_unlock(&p->lock);
343
344         return res;
345 }
346
347 static int local_digit_end(struct ast_channel *ast, char digit)
348 {
349         struct local_pvt *p = ast->tech_pvt;
350         int res = -1;
351         struct ast_frame f = { AST_FRAME_DTMF_END, };
352         int isoutbound;
353
354         ast_mutex_lock(&p->lock);
355         isoutbound = IS_OUTBOUND(ast, p);
356         f.subclass = digit;
357         res = local_queue_frame(p, isoutbound, &f, ast);
358         ast_mutex_unlock(&p->lock);
359         
360         return res;
361 }
362
363 static int local_sendtext(struct ast_channel *ast, const char *text)
364 {
365         struct local_pvt *p = ast->tech_pvt;
366         int res = -1;
367         struct ast_frame f = { AST_FRAME_TEXT, };
368         int isoutbound;
369
370         ast_mutex_lock(&p->lock);
371         isoutbound = IS_OUTBOUND(ast, p);
372         f.data = (char *) text;
373         f.datalen = strlen(text) + 1;
374         res = local_queue_frame(p, isoutbound, &f, ast);
375         ast_mutex_unlock(&p->lock);
376         return res;
377 }
378
379 static int local_sendhtml(struct ast_channel *ast, int subclass, const char *data, int datalen)
380 {
381         struct local_pvt *p = ast->tech_pvt;
382         int res = -1;
383         struct ast_frame f = { AST_FRAME_HTML, };
384         int isoutbound;
385
386         ast_mutex_lock(&p->lock);
387         isoutbound = IS_OUTBOUND(ast, p);
388         f.subclass = subclass;
389         f.data = (char *)data;
390         f.datalen = datalen;
391         res = local_queue_frame(p, isoutbound, &f, ast);
392         ast_mutex_unlock(&p->lock);
393         return res;
394 }
395
396 /*! \brief Initiate new call, part of PBX interface 
397  *      dest is the dial string */
398 static int local_call(struct ast_channel *ast, char *dest, int timeout)
399 {
400         struct local_pvt *p = ast->tech_pvt;
401         int res;
402         struct ast_var_t *varptr = NULL, *new;
403         size_t len, namelen;
404         
405         ast_mutex_lock(&p->lock);
406
407         p->chan->cid.cid_num = ast_strdup(p->owner->cid.cid_num);
408         p->chan->cid.cid_name = ast_strdup(p->owner->cid.cid_name);
409         p->chan->cid.cid_rdnis = ast_strdup(p->owner->cid.cid_rdnis);
410         p->chan->cid.cid_ani = ast_strdup(p->owner->cid.cid_ani);
411         p->chan->cid.cid_pres = p->owner->cid.cid_pres;
412         ast_string_field_set(p->chan, language, p->owner->language);
413         ast_string_field_set(p->chan, accountcode, p->owner->accountcode);
414         p->chan->cdrflags = p->owner->cdrflags;
415
416         /* copy the channel variables from the incoming channel to the outgoing channel */
417         /* Note that due to certain assumptions, they MUST be in the same order */
418         AST_LIST_TRAVERSE(&p->owner->varshead, varptr, entries) {
419                 namelen = strlen(varptr->name);
420                 len = sizeof(struct ast_var_t) + namelen + strlen(varptr->value) + 2;
421                 if ((new = ast_calloc(1, len))) {
422                         memcpy(new, varptr, len);
423                         new->value = &(new->name[0]) + namelen + 1;
424                         AST_LIST_INSERT_TAIL(&p->chan->varshead, new, entries);
425                 }
426         }
427
428         ast_set_flag(p, LOCAL_LAUNCHED_PBX);
429
430         /* Start switch on sub channel */
431         res = ast_pbx_start(p->chan);
432         ast_mutex_unlock(&p->lock);
433         return res;
434 }
435
436 /*! \brief Hangup a call through the local proxy channel */
437 static int local_hangup(struct ast_channel *ast)
438 {
439         struct local_pvt *p = ast->tech_pvt;
440         int isoutbound;
441         struct ast_frame f = { AST_FRAME_CONTROL, AST_CONTROL_HANGUP };
442         struct ast_channel *ochan = NULL;
443         int glaredetect = 0;
444
445         ast_mutex_lock(&p->lock);
446         isoutbound = IS_OUTBOUND(ast, p);
447         if (isoutbound) {
448                 const char *status = pbx_builtin_getvar_helper(p->chan, "DIALSTATUS");
449                 if ((status) && (p->owner))
450                         pbx_builtin_setvar_helper(p->owner, "CHANLOCALSTATUS", status);
451                 p->chan = NULL;
452                 ast_clear_flag(p, LOCAL_LAUNCHED_PBX);
453                 ast_module_user_remove(p->u_chan);
454         } else {
455                 p->owner = NULL;
456                 ast_module_user_remove(p->u_owner);
457         }
458         
459         ast->tech_pvt = NULL;
460         
461         if (!p->owner && !p->chan) {
462                 /* Okay, done with the private part now, too. */
463                 glaredetect = ast_test_flag(p, LOCAL_GLARE_DETECT);
464                 /* If we have a queue holding, don't actually destroy p yet, but
465                    let local_queue do it. */
466                 if (glaredetect)
467                         ast_set_flag(p, LOCAL_CANCEL_QUEUE);
468                 ast_mutex_unlock(&p->lock);
469                 /* Remove from list */
470                 AST_LIST_LOCK(&locals);
471                 AST_LIST_REMOVE(&locals, p, list);
472                 AST_LIST_UNLOCK(&locals);
473                 /* Grab / release lock just in case */
474                 ast_mutex_lock(&p->lock);
475                 ast_mutex_unlock(&p->lock);
476                 /* And destroy */
477                 if (!glaredetect) {
478                         ast_mutex_destroy(&p->lock);
479                         free(p);
480                 }
481                 return 0;
482         }
483         if (p->chan && !ast_test_flag(p, LOCAL_LAUNCHED_PBX))
484                 /* Need to actually hangup since there is no PBX */
485                 ochan = p->chan;
486         else
487                 local_queue_frame(p, isoutbound, &f, NULL);
488         ast_mutex_unlock(&p->lock);
489         if (ochan)
490                 ast_hangup(ochan);
491         return 0;
492 }
493
494 /*! \brief Create a call structure */
495 static struct local_pvt *local_alloc(const char *data, int format)
496 {
497         struct local_pvt *tmp = NULL;
498         char *c = NULL, *opts = NULL;
499
500         if (!(tmp = ast_calloc(1, sizeof(*tmp))))
501                 return NULL;
502
503         /* Initialize private structure information */
504         ast_mutex_init(&tmp->lock);
505         ast_copy_string(tmp->exten, data, sizeof(tmp->exten));
506
507         /* Look for options */
508         if ((opts = strchr(tmp->exten, '/'))) {
509                 *opts++ = '\0';
510                 if (strchr(opts, 'n'))
511                         ast_set_flag(tmp, LOCAL_NO_OPTIMIZATION);
512         }
513
514         /* Look for a context */
515         if ((c = strchr(tmp->exten, '@')))
516                 *c++ = '\0';
517
518         ast_copy_string(tmp->context, c ? c : "default", sizeof(tmp->context));
519
520         tmp->reqformat = format;
521
522         if (!ast_exists_extension(NULL, tmp->context, tmp->exten, 1, NULL)) {
523                 ast_log(LOG_NOTICE, "No such extension/context %s@%s creating local channel\n", tmp->exten, tmp->context);
524                 ast_mutex_destroy(&tmp->lock);
525                 free(tmp);
526                 tmp = NULL;
527         } else {
528                 /* Add to list */
529                 AST_LIST_LOCK(&locals);
530                 AST_LIST_INSERT_HEAD(&locals, tmp, list);
531                 AST_LIST_UNLOCK(&locals);
532         }
533         
534         return tmp;
535 }
536
537 /*! \brief Start new local channel */
538 static struct ast_channel *local_new(struct local_pvt *p, int state)
539 {
540         struct ast_channel *tmp = NULL, *tmp2 = NULL;
541         int randnum = ast_random() & 0xffff, fmt = 0;
542
543         /* Allocate two new Asterisk channels */
544         if (!(tmp = ast_channel_alloc(1)) || !(tmp2 = ast_channel_alloc(1))) {
545                 if (tmp)
546                         ast_channel_free(tmp);
547                 if (tmp2)
548                         ast_channel_free(tmp2);
549                 ast_log(LOG_WARNING, "Unable to allocate channel structure(s)\n");
550                 return NULL;
551         } 
552
553         tmp2->tech = tmp->tech = &local_tech;
554
555         tmp->nativeformats = p->reqformat;
556         tmp2->nativeformats = p->reqformat;
557
558         ast_string_field_build(tmp, name, "Local/%s@%s-%04x,1", p->exten, p->context, randnum);
559         ast_string_field_build(tmp2, name, "Local/%s@%s-%04x,2", p->exten, p->context, randnum);
560
561         ast_setstate(tmp, state);
562         ast_setstate(tmp2, AST_STATE_RING);
563
564         /* Determine our read/write format and set it on each channel */
565         fmt = ast_best_codec(p->reqformat);
566         tmp->writeformat = fmt;
567         tmp2->writeformat = fmt;
568         tmp->rawwriteformat = fmt;
569         tmp2->rawwriteformat = fmt;
570         tmp->readformat = fmt;
571         tmp2->readformat = fmt;
572         tmp->rawreadformat = fmt;
573         tmp2->rawreadformat = fmt;
574
575         tmp->tech_pvt = p;
576         tmp2->tech_pvt = p;
577
578         p->owner = tmp;
579         p->chan = tmp2;
580         p->u_owner = ast_module_user_add(p->owner);
581         p->u_chan = ast_module_user_add(p->chan);
582
583         ast_copy_string(tmp->context, p->context, sizeof(tmp->context));
584         ast_copy_string(tmp2->context, p->context, sizeof(tmp2->context));
585         ast_copy_string(tmp2->exten, p->exten, sizeof(tmp->exten));
586         tmp->priority = 1;
587         tmp2->priority = 1;
588
589         return tmp;
590 }
591
592
593 /*! \brief Part of PBX interface */
594 static struct ast_channel *local_request(const char *type, int format, void *data, int *cause)
595 {
596         struct local_pvt *p = NULL;
597         struct ast_channel *chan = NULL;
598
599         /* Allocate a new private structure and then Asterisk channel */
600         if ((p = local_alloc(data, format)))
601                 chan = local_new(p, AST_STATE_DOWN);
602
603         return chan;
604 }
605
606 /*! \brief CLI command "local show channels" */
607 static int locals_show(int fd, int argc, char **argv)
608 {
609         struct local_pvt *p = NULL;
610
611         if (argc != 3)
612                 return RESULT_SHOWUSAGE;
613
614         AST_LIST_LOCK(&locals);
615         if (!AST_LIST_EMPTY(&locals)) {
616                 AST_LIST_TRAVERSE(&locals, p, list) {
617                         ast_mutex_lock(&p->lock);
618                         ast_cli(fd, "%s -- %s@%s\n", p->owner ? p->owner->name : "<unowned>", p->exten, p->context);
619                         ast_mutex_unlock(&p->lock);
620                 }
621         } else
622                 ast_cli(fd, "No local channels in use\n");
623         AST_LIST_UNLOCK(&locals);
624
625         return RESULT_SUCCESS;
626 }
627
628 static char show_locals_usage[] = 
629 "Usage: local list channels\n"
630 "       Provides summary information on active local proxy channels.\n";
631
632 static struct ast_cli_entry cli_local[] = {
633         { { "local", "list", "channels", NULL },
634         locals_show, "List status of local channels",
635         show_locals_usage },
636 };
637
638 /*! \brief Load module into PBX, register channel */
639 static int load_module(void)
640 {
641         /* Make sure we can register our channel type */
642         if (ast_channel_register(&local_tech)) {
643                 ast_log(LOG_ERROR, "Unable to register channel class 'Local'\n");
644                 return -1;
645         }
646         ast_cli_register_multiple(cli_local, sizeof(cli_local) / sizeof(struct ast_cli_entry));
647         return 0;
648 }
649
650 /*! \brief Unload the local proxy channel from Asterisk */
651 static int unload_module(void)
652 {
653         struct local_pvt *p = NULL;
654
655         /* First, take us out of the channel loop */
656         ast_cli_unregister_multiple(cli_local, sizeof(cli_local) / sizeof(struct ast_cli_entry));
657         ast_channel_unregister(&local_tech);
658         if (!AST_LIST_LOCK(&locals)) {
659                 /* Hangup all interfaces if they have an owner */
660                 AST_LIST_TRAVERSE(&locals, p, list) {
661                         if (p->owner)
662                                 ast_softhangup(p->owner, AST_SOFTHANGUP_APPUNLOAD);
663                 }
664                 AST_LIST_UNLOCK(&locals);
665                 AST_LIST_HEAD_DESTROY(&locals);
666         } else {
667                 ast_log(LOG_WARNING, "Unable to lock the monitor\n");
668                 return -1;
669         }               
670         return 0;
671 }
672
673 AST_MODULE_INFO_STANDARD(ASTERISK_GPL_KEY, "Local Proxy Channel");