00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032
00033
00034
00035
00036 #include "asterisk.h"
00037
00038 ASTERISK_FILE_VERSION(__FILE__, "$Revision: 364108 $")
00039
00040 #include "asterisk/file.h"
00041 #include "asterisk/channel.h"
00042 #include "asterisk/pbx.h"
00043 #include "asterisk/module.h"
00044 #include "asterisk/lock.h"
00045 #include "asterisk/app.h"
00046 #include "asterisk/features.h"
00047 #include "asterisk/manager.h"
00048 #include "asterisk/callerid.h"
00049 #include "asterisk/cel.h"
00050
00051 #define PICKUPMARK "PICKUPMARK"
00052
00053
00054
00055
00056
00057
00058
00059
00060
00061
00062
00063
00064
00065
00066
00067
00068
00069
00070
00071
00072
00073
00074
00075
00076
00077
00078
00079
00080
00081
00082
00083
00084
00085
00086
00087
00088
00089
00090
00091
00092
00093
00094
00095
00096
00097
00098
00099
00100
00101
00102
00103
00104
00105
00106
00107
00108
00109
00110
00111
00112
00113
00114
00115
00116
00117
00118
00119 static const char app[] = "Pickup";
00120 static const char app2[] = "PickupChan";
00121
00122 struct pickup_by_name_args {
00123 const char *name;
00124 size_t len;
00125 };
00126
00127 static int pickup_by_name_cb(void *obj, void *arg, void *data, int flags)
00128 {
00129 struct ast_channel *target = obj;
00130 struct pickup_by_name_args *args = data;
00131
00132 ast_channel_lock(target);
00133 if (!strncasecmp(target->name, args->name, args->len) && ast_can_pickup(target)) {
00134
00135 return CMP_MATCH | CMP_STOP;
00136 }
00137 ast_channel_unlock(target);
00138
00139 return 0;
00140 }
00141
00142
00143 static struct ast_channel *my_ast_get_channel_by_name_locked(const char *channame)
00144 {
00145 char *chkchan;
00146 struct pickup_by_name_args pickup_args;
00147
00148
00149
00150
00151 if (strchr(channame, '-')) {
00152
00153 pickup_args.len = strlen(channame);
00154 pickup_args.name = channame;
00155 } else {
00156
00157
00158
00159
00160 pickup_args.len = strlen(channame) + 1;
00161 chkchan = alloca(pickup_args.len + 1);
00162 strcpy(chkchan, channame);
00163 strcat(chkchan, "-");
00164 pickup_args.name = chkchan;
00165 }
00166
00167 return ast_channel_callback(pickup_by_name_cb, NULL, &pickup_args, 0);
00168 }
00169
00170
00171 static int pickup_by_channel(struct ast_channel *chan, char *pickup)
00172 {
00173 int res = -1;
00174 struct ast_channel *target;
00175
00176 target = my_ast_get_channel_by_name_locked(pickup);
00177 if (target) {
00178
00179 if (chan != target) {
00180 res = ast_do_pickup(chan, target);
00181 }
00182 ast_channel_unlock(target);
00183 target = ast_channel_unref(target);
00184 }
00185
00186 return res;
00187 }
00188
00189
00190 static int pickup_by_exten(struct ast_channel *chan, const char *exten, const char *context)
00191 {
00192 struct ast_channel *target = NULL;
00193 struct ast_channel_iterator *iter;
00194 int res = -1;
00195
00196 if (!(iter = ast_channel_iterator_by_exten_new(exten, context))) {
00197 return -1;
00198 }
00199
00200 while ((target = ast_channel_iterator_next(iter))) {
00201 ast_channel_lock(target);
00202 if ((chan != target) && ast_can_pickup(target)) {
00203 ast_log(LOG_NOTICE, "%s pickup by %s\n", target->name, chan->name);
00204 break;
00205 }
00206 ast_channel_unlock(target);
00207 target = ast_channel_unref(target);
00208 }
00209
00210 ast_channel_iterator_destroy(iter);
00211
00212 if (target) {
00213 res = ast_do_pickup(chan, target);
00214 ast_channel_unlock(target);
00215 target = ast_channel_unref(target);
00216 }
00217
00218 return res;
00219 }
00220
00221 static int find_by_mark(void *obj, void *arg, void *data, int flags)
00222 {
00223 struct ast_channel *target = obj;
00224 const char *mark = data;
00225 const char *tmp;
00226
00227 ast_channel_lock(target);
00228 tmp = pbx_builtin_getvar_helper(target, PICKUPMARK);
00229 if (tmp && !strcasecmp(tmp, mark) && ast_can_pickup(target)) {
00230
00231 return CMP_MATCH | CMP_STOP;
00232 }
00233 ast_channel_unlock(target);
00234
00235 return 0;
00236 }
00237
00238
00239 static int pickup_by_mark(struct ast_channel *chan, const char *mark)
00240 {
00241 struct ast_channel *target;
00242 int res = -1;
00243
00244
00245 target = ast_channel_callback(find_by_mark, NULL, (char *) mark, 0);
00246 if (target) {
00247 res = ast_do_pickup(chan, target);
00248 ast_channel_unlock(target);
00249 target = ast_channel_unref(target);
00250 }
00251
00252 return res;
00253 }
00254
00255 static int find_channel_by_group(void *obj, void *arg, void *data, int flags)
00256 {
00257 struct ast_channel *target = obj;
00258 struct ast_channel *chan = data;
00259
00260 ast_channel_lock(target);
00261 if (chan != target && (chan->pickupgroup & target->callgroup)
00262 && ast_can_pickup(target)) {
00263
00264 return CMP_MATCH | CMP_STOP;
00265 }
00266 ast_channel_unlock(target);
00267
00268 return 0;
00269 }
00270
00271 static int pickup_by_group(struct ast_channel *chan)
00272 {
00273 struct ast_channel *target;
00274 int res = -1;
00275
00276
00277 target = ast_channel_callback(find_channel_by_group, NULL, chan, 0);
00278 if (target) {
00279 ast_log(LOG_NOTICE, "pickup %s attempt by %s\n", target->name, chan->name);
00280 res = ast_do_pickup(chan, target);
00281 ast_channel_unlock(target);
00282 target = ast_channel_unref(target);
00283 }
00284
00285 return res;
00286 }
00287
00288
00289 static int pickup_exec(struct ast_channel *chan, const char *data)
00290 {
00291 char *tmp = ast_strdupa(data);
00292 char *exten = NULL, *context = NULL;
00293
00294 if (ast_strlen_zero(data)) {
00295 return pickup_by_group(chan) ? 0 : -1;
00296 }
00297
00298
00299 while (!ast_strlen_zero(tmp) && (exten = strsep(&tmp, "&"))) {
00300 if ((context = strchr(exten, '@')))
00301 *context++ = '\0';
00302 if (!ast_strlen_zero(context) && !strcasecmp(context, PICKUPMARK)) {
00303 if (!pickup_by_mark(chan, exten)) {
00304
00305 return -1;
00306 }
00307 } else {
00308 if (!pickup_by_exten(chan, exten, !ast_strlen_zero(context) ? context : chan->context)) {
00309
00310 return -1;
00311 }
00312 }
00313 ast_log(LOG_NOTICE, "No target channel found for %s.\n", exten);
00314 }
00315
00316
00317 return 0;
00318 }
00319
00320
00321 static int find_by_part(void *obj, void *arg, void *data, int flags)
00322 {
00323 struct ast_channel *target = obj;
00324 const char *part = data;
00325 int len = strlen(part);
00326
00327 ast_channel_lock(target);
00328 if (len <= strlen(target->name) && !strncmp(target->name, part, len)
00329 && ast_can_pickup(target)) {
00330
00331 return CMP_MATCH | CMP_STOP;
00332 }
00333 ast_channel_unlock(target);
00334
00335 return 0;
00336 }
00337
00338
00339 static int pickup_by_part(struct ast_channel *chan, const char *part)
00340 {
00341 struct ast_channel *target;
00342 int res = -1;
00343
00344
00345 target = ast_channel_callback(find_by_part, NULL, (char *) part, 0);
00346 if (target) {
00347 res = ast_do_pickup(chan, target);
00348 ast_channel_unlock(target);
00349 target = ast_channel_unref(target);
00350 }
00351
00352 return res;
00353 }
00354
00355
00356 static int pickupchan_exec(struct ast_channel *chan, const char *data)
00357 {
00358 int partial_pickup = 0;
00359 char *pickup = NULL;
00360 char *parse = ast_strdupa(data);
00361 AST_DECLARE_APP_ARGS(args,
00362 AST_APP_ARG(channel);
00363 AST_APP_ARG(options);
00364 );
00365 AST_STANDARD_APP_ARGS(args, parse);
00366
00367 if (ast_strlen_zero(args.channel)) {
00368 ast_log(LOG_WARNING, "PickupChan requires an argument (channel)!\n");
00369
00370 return 0;
00371 }
00372
00373 if (!ast_strlen_zero(args.options) && strchr(args.options, 'p')) {
00374 partial_pickup = 1;
00375 }
00376
00377
00378 while (!ast_strlen_zero(args.channel) && (pickup = strsep(&args.channel, "&"))) {
00379 if (!strncasecmp(chan->name, pickup, strlen(pickup))) {
00380 ast_log(LOG_NOTICE, "Cannot pickup your own channel %s.\n", pickup);
00381 } else {
00382 if (partial_pickup) {
00383 if (!pickup_by_part(chan, pickup)) {
00384
00385 return -1;
00386 }
00387 } else if (!pickup_by_channel(chan, pickup)) {
00388
00389 return -1;
00390 }
00391 ast_log(LOG_NOTICE, "No target channel found for %s.\n", pickup);
00392 }
00393 }
00394
00395
00396 return 0;
00397 }
00398
00399 static int unload_module(void)
00400 {
00401 int res;
00402
00403 res = ast_unregister_application(app);
00404 res |= ast_unregister_application(app2);
00405
00406 return res;
00407 }
00408
00409 static int load_module(void)
00410 {
00411 int res;
00412
00413 res = ast_register_application_xml(app, pickup_exec);
00414 res |= ast_register_application_xml(app2, pickupchan_exec);
00415
00416 return res;
00417 }
00418
00419 AST_MODULE_INFO_STANDARD(ASTERISK_GPL_KEY, "Directed Call Pickup Application");