Start untangling header inclusion in a way that does not affect
[asterisk/asterisk.git] / apps / app_directed_pickup.c
1 /*
2  * Asterisk -- An open source telephony toolkit.
3  *
4  * Copyright (C) 2005, Joshua Colp
5  *
6  * Joshua Colp <jcolp@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  * \brief Directed Call Pickup Support
22  *
23  * \author Joshua Colp <jcolp@digium.com>
24  *
25  * \ingroup applications
26  */
27
28 #include "asterisk.h"
29
30 ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
31
32 #include "asterisk/file.h"
33 #include "asterisk/logger.h"
34 #include "asterisk/channel.h"
35 #include "asterisk/pbx.h"
36 #include "asterisk/module.h"
37 #include "asterisk/lock.h"
38 #include "asterisk/app.h"
39 #include "asterisk/options.h"
40 #include "asterisk/features.h"
41
42 #define PICKUPMARK "PICKUPMARK"
43
44 static const char *app = "Pickup";
45 static const char *synopsis = "Directed Call Pickup";
46 static const char *descrip =
47 "  Pickup([extension[@context][&extension2@[context]...]]):  This application can\n"
48 "pickup any ringing channel that is calling the specified extension.  If no\n"
49 "context is specified, the current context will be used. If you use the special\n"
50 "string \"PICKUPMARK\" for the context parameter, for example 10@PICKUPMARK,\n"
51 "this application tries to find a channel which has defined a ${PICKUPMARK}\n"
52 "channel variable with the same value as \"extension\" (in this example, \"10\").\n"
53 "When no parameter is specified, the application will pickup a channel matching\n"
54 "the pickup group of the active channel.";
55
56 /* Perform actual pickup between two channels */
57 static int pickup_do(struct ast_channel *chan, struct ast_channel *target)
58 {
59         int res = 0;
60
61         ast_debug(1, "Call pickup on '%s' by '%s'\n", target->name, chan->name);
62
63         if ((res = ast_answer(chan))) {
64                 ast_log(LOG_WARNING, "Unable to answer '%s'\n", chan->name);
65                 return -1;
66         }
67
68         if ((res = ast_queue_control(chan, AST_CONTROL_ANSWER))) {
69                 ast_log(LOG_WARNING, "Unable to queue answer on '%s'\n", chan->name);
70                 return -1;
71         }
72
73         if ((res = ast_channel_masquerade(target, chan))) {
74                 ast_log(LOG_WARNING, "Unable to masquerade '%s' into '%s'\n", chan->name, target->name);
75                 return -1;
76         }
77
78         return res;
79 }
80
81 /* Helper function that determines whether a channel is capable of being picked up */
82 static int can_pickup(struct ast_channel *chan)
83 {
84         if (!chan->pbx && (chan->_state == AST_STATE_RINGING || chan->_state == AST_STATE_RING))
85                 return 1;
86         else
87                 return 0;
88 }
89
90 /* Attempt to pick up specified extension with context */
91 static int pickup_by_exten(struct ast_channel *chan, const char *exten, const char *context)
92 {
93         int res = -1;
94         struct ast_channel *target = NULL;
95
96         while ((target = ast_channel_walk_locked(target))) {
97                 if ((!strcasecmp(target->macroexten, exten) || !strcasecmp(target->exten, exten)) &&
98                     !strcasecmp(target->dialcontext, context) &&
99                     can_pickup(target)) {
100                         res = pickup_do(chan, target);
101                         ast_channel_unlock(target);
102                         break;
103                 }
104                 ast_channel_unlock(target);
105         }
106
107         return res;
108 }
109
110 /* Attempt to pick up specified mark */
111 static int pickup_by_mark(struct ast_channel *chan, const char *mark)
112 {
113         int res = -1;
114         const char *tmp = NULL;
115         struct ast_channel *target = NULL;
116
117         while ((target = ast_channel_walk_locked(target))) {
118                 if ((tmp = pbx_builtin_getvar_helper(target, PICKUPMARK)) &&
119                     !strcasecmp(tmp, mark) &&
120                     can_pickup(target)) {
121                         res = pickup_do(chan, target);
122                         ast_channel_unlock(target);
123                         break;
124                 }
125                 ast_channel_unlock(target);
126         }
127
128         return res;
129 }
130
131 /* Main application entry point */
132 static int pickup_exec(struct ast_channel *chan, void *data)
133 {
134         int res = 0;
135         char *tmp = ast_strdupa(data);
136         char *exten = NULL, *context = NULL;
137
138         if (ast_strlen_zero(data)) {
139                 res = ast_pickup_call(chan);
140                 return res;
141         }
142         
143         /* Parse extension (and context if there) */
144         while (!ast_strlen_zero(tmp) && (exten = strsep(&tmp, "&"))) {
145                 if ((context = strchr(exten, '@')))
146                         *context++ = '\0';
147                 if (!ast_strlen_zero(context) && !strcasecmp(context, PICKUPMARK)) {
148                         if (!pickup_by_mark(chan, exten))
149                                 break;
150                 } else {
151                         if (!pickup_by_exten(chan, exten, !ast_strlen_zero(context) ? context : chan->context))
152                                 break;
153                 }
154                 ast_log(LOG_NOTICE, "No target channel found for %s.\n", exten);
155         }
156
157         return res;
158 }
159
160 static int unload_module(void)
161 {
162         int res;
163
164         res = ast_unregister_application(app);
165         
166         return res;
167 }
168
169 static int load_module(void)
170 {
171         return ast_register_application(app, pickup_exec, synopsis, descrip);
172 }
173
174 AST_MODULE_INFO_STANDARD(ASTERISK_GPL_KEY, "Directed Call Pickup Application");