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 #include "asterisk.h"
00027
00028 ASTERISK_FILE_VERSION(__FILE__, "$Revision: 183767 $")
00029
00030 #include <sys/stat.h>
00031 #include <libgen.h>
00032
00033 #include "asterisk/paths.h"
00034 #include "asterisk/lock.h"
00035 #include "asterisk/channel.h"
00036 #include "asterisk/file.h"
00037 #include "asterisk/pbx.h"
00038 #include "asterisk/module.h"
00039 #include "asterisk/manager.h"
00040 #include "asterisk/cli.h"
00041 #include "asterisk/monitor.h"
00042 #include "asterisk/app.h"
00043 #include "asterisk/utils.h"
00044 #include "asterisk/config.h"
00045 #include "asterisk/options.h"
00046
00047 AST_MUTEX_DEFINE_STATIC(monitorlock);
00048
00049 #define LOCK_IF_NEEDED(lock, needed) do { \
00050 if (needed) \
00051 ast_channel_lock(lock); \
00052 } while(0)
00053
00054 #define UNLOCK_IF_NEEDED(lock, needed) do { \
00055 if (needed) \
00056 ast_channel_unlock(lock); \
00057 } while (0)
00058
00059 static unsigned long seq = 0;
00060
00061 static char *monitor_synopsis = "Monitor a channel";
00062
00063 static char *monitor_descrip = " Monitor([file_format[:urlbase],[fname_base],[options]]):\n"
00064 "Used to start monitoring a channel. The channel's input and output\n"
00065 "voice packets are logged to files until the channel hangs up or\n"
00066 "monitoring is stopped by the StopMonitor application.\n"
00067 " file_format optional, if not set, defaults to \"wav\"\n"
00068 " fname_base if set, changes the filename used to the one specified.\n"
00069 " options:\n"
00070 " m - when the recording ends mix the two leg files into one and\n"
00071 " delete the two leg files. If the variable MONITOR_EXEC is set, the\n"
00072 " application referenced in it will be executed instead of\n"
00073 #ifdef HAVE_SOXMIX
00074 " soxmix and the raw leg files will NOT be deleted automatically.\n"
00075 " soxmix or MONITOR_EXEC is handed 3 arguments, the two leg files\n"
00076 #else
00077 " sox and the raw leg files will NOT be deleted automatically.\n"
00078 " sox or MONITOR_EXEC is handed 3 arguments, the two leg files\n"
00079 #endif
00080 " and a target mixed file name which is the same as the leg file names\n"
00081 " only without the in/out designator.\n"
00082 " If MONITOR_EXEC_ARGS is set, the contents will be passed on as\n"
00083 " additional arguments to MONITOR_EXEC\n"
00084 " Both MONITOR_EXEC and the Mix flag can be set from the\n"
00085 " administrator interface\n"
00086 "\n"
00087 " b - Don't begin recording unless a call is bridged to another channel\n"
00088 " i - Skip recording of input stream (disables m option)\n"
00089 " o - Skip recording of output stream (disables m option)\n"
00090 "\nBy default, files are stored to /var/spool/asterisk/monitor/.\n"
00091 "\nReturns -1 if monitor files can't be opened or if the channel is already\n"
00092 "monitored, otherwise 0.\n"
00093 ;
00094
00095 static char *stopmonitor_synopsis = "Stop monitoring a channel";
00096
00097 static char *stopmonitor_descrip = " StopMonitor():\n"
00098 "Stops monitoring a channel. Has no effect if the channel is not monitored\n";
00099
00100 static char *changemonitor_synopsis = "Change monitoring filename of a channel";
00101
00102 static char *changemonitor_descrip = " ChangeMonitor(filename_base):\n"
00103 "Changes monitoring filename of a channel. Has no effect if the channel is not monitored.\n"
00104 "The argument is the new filename base to use for monitoring this channel.\n";
00105
00106 static char *pausemonitor_synopsis = "Pause monitoring of a channel";
00107
00108 static char *pausemonitor_descrip = " PauseMonitor():\n"
00109 "Pauses monitoring of a channel until it is re-enabled by a call to UnpauseMonitor.\n";
00110
00111 static char *unpausemonitor_synopsis = "Unpause monitoring of a channel";
00112
00113 static char *unpausemonitor_descrip = " UnpauseMonitor():\n"
00114 "Unpauses monitoring of a channel on which monitoring had\n"
00115 "previously been paused with PauseMonitor.\n";
00116
00117
00118
00119
00120
00121
00122
00123
00124 static int ast_monitor_set_state(struct ast_channel *chan, int state)
00125 {
00126 LOCK_IF_NEEDED(chan, 1);
00127 if (!chan->monitor) {
00128 UNLOCK_IF_NEEDED(chan, 1);
00129 return -1;
00130 }
00131 chan->monitor->state = state;
00132 UNLOCK_IF_NEEDED(chan, 1);
00133 return 0;
00134 }
00135
00136
00137
00138
00139
00140
00141
00142
00143
00144
00145
00146
00147 int ast_monitor_start( struct ast_channel *chan, const char *format_spec,
00148 const char *fname_base, int need_lock, int stream_action)
00149 {
00150 int res = 0;
00151
00152 LOCK_IF_NEEDED(chan, need_lock);
00153
00154 if (!(chan->monitor)) {
00155 struct ast_channel_monitor *monitor;
00156 char *channel_name, *p;
00157
00158
00159 ast_mkdir(ast_config_AST_MONITOR_DIR, 0777);
00160
00161 if (!(monitor = ast_calloc(1, sizeof(*monitor)))) {
00162 UNLOCK_IF_NEEDED(chan, need_lock);
00163 return -1;
00164 }
00165
00166
00167 if (!ast_strlen_zero(fname_base)) {
00168 int directory = strchr(fname_base, '/') ? 1 : 0;
00169 const char *absolute = *fname_base == '/' ? "" : "/";
00170
00171 if (directory) {
00172 char *name = ast_strdupa(fname_base);
00173 ast_mkdir(dirname(name), 0777);
00174 }
00175 snprintf(monitor->read_filename, FILENAME_MAX, "%s%s%s-in",
00176 directory ? "" : ast_config_AST_MONITOR_DIR, absolute, fname_base);
00177 snprintf(monitor->write_filename, FILENAME_MAX, "%s%s%s-out",
00178 directory ? "" : ast_config_AST_MONITOR_DIR, absolute, fname_base);
00179 ast_copy_string(monitor->filename_base, fname_base, sizeof(monitor->filename_base));
00180 } else {
00181 ast_mutex_lock(&monitorlock);
00182 snprintf(monitor->read_filename, FILENAME_MAX, "%s/audio-in-%ld",
00183 ast_config_AST_MONITOR_DIR, seq);
00184 snprintf(monitor->write_filename, FILENAME_MAX, "%s/audio-out-%ld",
00185 ast_config_AST_MONITOR_DIR, seq);
00186 seq++;
00187 ast_mutex_unlock(&monitorlock);
00188
00189 channel_name = ast_strdupa(chan->name);
00190 while ((p = strchr(channel_name, '/'))) {
00191 *p = '-';
00192 }
00193 snprintf(monitor->filename_base, FILENAME_MAX, "%s/%d-%s",
00194 ast_config_AST_MONITOR_DIR, (int)time(NULL), channel_name);
00195 monitor->filename_changed = 1;
00196 }
00197
00198 monitor->stop = ast_monitor_stop;
00199
00200
00201 if (!ast_strlen_zero(format_spec)) {
00202 monitor->format = ast_strdup(format_spec);
00203 } else {
00204 monitor->format = ast_strdup("wav");
00205 }
00206
00207
00208 if (stream_action & X_REC_IN) {
00209 if (ast_fileexists(monitor->read_filename, NULL, NULL) > 0)
00210 ast_filedelete(monitor->read_filename, NULL);
00211 if (!(monitor->read_stream = ast_writefile(monitor->read_filename,
00212 monitor->format, NULL,
00213 O_CREAT|O_TRUNC|O_WRONLY, 0, AST_FILE_MODE))) {
00214 ast_log(LOG_WARNING, "Could not create file %s\n",
00215 monitor->read_filename);
00216 ast_free(monitor);
00217 UNLOCK_IF_NEEDED(chan, need_lock);
00218 return -1;
00219 }
00220 } else
00221 monitor->read_stream = NULL;
00222
00223 if (stream_action & X_REC_OUT) {
00224 if (ast_fileexists(monitor->write_filename, NULL, NULL) > 0) {
00225 ast_filedelete(monitor->write_filename, NULL);
00226 }
00227 if (!(monitor->write_stream = ast_writefile(monitor->write_filename,
00228 monitor->format, NULL,
00229 O_CREAT|O_TRUNC|O_WRONLY, 0, AST_FILE_MODE))) {
00230 ast_log(LOG_WARNING, "Could not create file %s\n",
00231 monitor->write_filename);
00232 ast_closestream(monitor->read_stream);
00233 ast_free(monitor);
00234 UNLOCK_IF_NEEDED(chan, need_lock);
00235 return -1;
00236 }
00237 } else
00238 monitor->write_stream = NULL;
00239
00240 chan->monitor = monitor;
00241 ast_monitor_set_state(chan, AST_MONITOR_RUNNING);
00242
00243 pbx_builtin_setvar_helper(chan, "__MONITORED","true");
00244
00245 manager_event(EVENT_FLAG_CALL, "MonitorStart",
00246 "Channel: %s\r\n"
00247 "Uniqueid: %s\r\n",
00248 chan->name,
00249 chan->uniqueid
00250 );
00251 } else {
00252 ast_debug(1,"Cannot start monitoring %s, already monitored\n", chan->name);
00253 res = -1;
00254 }
00255
00256 UNLOCK_IF_NEEDED(chan, need_lock);
00257
00258 return res;
00259 }
00260
00261
00262
00263
00264
00265
00266
00267
00268 static const char *get_soxmix_format(const char *format)
00269 {
00270 const char *res = format;
00271
00272 if (!strcasecmp(format,"ulaw"))
00273 res = "ul";
00274 if (!strcasecmp(format,"alaw"))
00275 res = "al";
00276
00277 return res;
00278 }
00279
00280
00281
00282
00283
00284
00285
00286
00287 int ast_monitor_stop(struct ast_channel *chan, int need_lock)
00288 {
00289 int delfiles = 0;
00290
00291 LOCK_IF_NEEDED(chan, need_lock);
00292
00293 if (chan->monitor) {
00294 char filename[ FILENAME_MAX ];
00295
00296 if (chan->monitor->read_stream) {
00297 ast_closestream(chan->monitor->read_stream);
00298 }
00299 if (chan->monitor->write_stream) {
00300 ast_closestream(chan->monitor->write_stream);
00301 }
00302
00303 if (chan->monitor->filename_changed && !ast_strlen_zero(chan->monitor->filename_base)) {
00304 if (ast_fileexists(chan->monitor->read_filename,NULL,NULL) > 0) {
00305 snprintf(filename, FILENAME_MAX, "%s-in", chan->monitor->filename_base);
00306 if (ast_fileexists(filename, NULL, NULL) > 0) {
00307 ast_filedelete(filename, NULL);
00308 }
00309 ast_filerename(chan->monitor->read_filename, filename, chan->monitor->format);
00310 } else {
00311 ast_log(LOG_WARNING, "File %s not found\n", chan->monitor->read_filename);
00312 }
00313
00314 if (ast_fileexists(chan->monitor->write_filename,NULL,NULL) > 0) {
00315 snprintf(filename, FILENAME_MAX, "%s-out", chan->monitor->filename_base);
00316 if (ast_fileexists(filename, NULL, NULL) > 0) {
00317 ast_filedelete(filename, NULL);
00318 }
00319 ast_filerename(chan->monitor->write_filename, filename, chan->monitor->format);
00320 } else {
00321 ast_log(LOG_WARNING, "File %s not found\n", chan->monitor->write_filename);
00322 }
00323 }
00324
00325 if (chan->monitor->joinfiles && !ast_strlen_zero(chan->monitor->filename_base)) {
00326 char tmp[1024];
00327 char tmp2[1024];
00328 const char *format = !strcasecmp(chan->monitor->format,"wav49") ? "WAV" : chan->monitor->format;
00329 char *name = chan->monitor->filename_base;
00330 int directory = strchr(name, '/') ? 1 : 0;
00331 const char *dir = directory ? "" : ast_config_AST_MONITOR_DIR;
00332 const char *execute, *execute_args;
00333 const char *absolute = *name == '/' ? "" : "/";
00334
00335
00336 execute = pbx_builtin_getvar_helper(chan, "MONITOR_EXEC");
00337 if (ast_strlen_zero(execute)) {
00338 #ifdef HAVE_SOXMIX
00339 execute = "nice -n 19 soxmix";
00340 #else
00341 execute = "nice -n 19 sox -m";
00342 #endif
00343 format = get_soxmix_format(format);
00344 delfiles = 1;
00345 }
00346 execute_args = pbx_builtin_getvar_helper(chan, "MONITOR_EXEC_ARGS");
00347 if (ast_strlen_zero(execute_args)) {
00348 execute_args = "";
00349 }
00350
00351 snprintf(tmp, sizeof(tmp), "%s \"%s%s%s-in.%s\" \"%s%s%s-out.%s\" \"%s%s%s.%s\" %s &", execute, dir, absolute, name, format, dir, absolute, name, format, dir, absolute, name, format,execute_args);
00352 if (delfiles) {
00353 snprintf(tmp2,sizeof(tmp2), "( %s& rm -f \"%s%s%s-\"* ) &",tmp, dir, absolute, name);
00354 ast_copy_string(tmp, tmp2, sizeof(tmp));
00355 }
00356 ast_debug(1,"monitor executing %s\n",tmp);
00357 if (ast_safe_system(tmp) == -1)
00358 ast_log(LOG_WARNING, "Execute of %s failed.\n",tmp);
00359 }
00360
00361 ast_free(chan->monitor->format);
00362 ast_free(chan->monitor);
00363 chan->monitor = NULL;
00364
00365 manager_event(EVENT_FLAG_CALL, "MonitorStop",
00366 "Channel: %s\r\n"
00367 "Uniqueid: %s\r\n",
00368 chan->name,
00369 chan->uniqueid
00370 );
00371 }
00372
00373 UNLOCK_IF_NEEDED(chan, need_lock);
00374
00375 return 0;
00376 }
00377
00378
00379
00380 int ast_monitor_pause(struct ast_channel *chan)
00381 {
00382 return ast_monitor_set_state(chan, AST_MONITOR_PAUSED);
00383 }
00384
00385
00386 int ast_monitor_unpause(struct ast_channel *chan)
00387 {
00388 return ast_monitor_set_state(chan, AST_MONITOR_RUNNING);
00389 }
00390
00391
00392 static int pause_monitor_exec(struct ast_channel *chan, void *data)
00393 {
00394 return ast_monitor_pause(chan);
00395 }
00396
00397
00398 static int unpause_monitor_exec(struct ast_channel *chan, void *data)
00399 {
00400 return ast_monitor_unpause(chan);
00401 }
00402
00403
00404
00405
00406
00407
00408
00409
00410
00411 int ast_monitor_change_fname(struct ast_channel *chan, const char *fname_base, int need_lock)
00412 {
00413 if (ast_strlen_zero(fname_base)) {
00414 ast_log(LOG_WARNING, "Cannot change monitor filename of channel %s to null\n", chan->name);
00415 return -1;
00416 }
00417
00418 LOCK_IF_NEEDED(chan, need_lock);
00419
00420 if (chan->monitor) {
00421 int directory = strchr(fname_base, '/') ? 1 : 0;
00422 const char *absolute = *fname_base == '/' ? "" : "/";
00423 char tmpstring[sizeof(chan->monitor->filename_base)] = "";
00424
00425
00426 snprintf(tmpstring, sizeof(tmpstring), "%s%s%s", directory ? "" : ast_config_AST_MONITOR_DIR, absolute, fname_base);
00427 if (!strcmp(tmpstring, chan->monitor->filename_base)) {
00428 if (option_debug > 2)
00429 ast_log(LOG_DEBUG, "No need to rename monitor filename to itself\n");
00430 UNLOCK_IF_NEEDED(chan, need_lock);
00431 return 0;
00432 }
00433
00434
00435 if (directory) {
00436 char *name = ast_strdupa(fname_base);
00437 ast_mkdir(dirname(name), 0777);
00438 }
00439
00440 ast_copy_string(chan->monitor->filename_base, tmpstring, sizeof(chan->monitor->filename_base));
00441 chan->monitor->filename_changed = 1;
00442 } else {
00443 ast_log(LOG_WARNING, "Cannot change monitor filename of channel %s to %s, monitoring not started\n", chan->name, fname_base);
00444 }
00445
00446 UNLOCK_IF_NEEDED(chan, need_lock);
00447
00448 return 0;
00449 }
00450
00451
00452
00453
00454
00455
00456
00457
00458
00459 static int start_monitor_exec(struct ast_channel *chan, void *data)
00460 {
00461 char *arg = NULL;
00462 char *options = NULL;
00463 char *delay = NULL;
00464 char *urlprefix = NULL;
00465 char tmp[256];
00466 int stream_action = X_REC_IN | X_REC_OUT;
00467 int joinfiles = 0;
00468 int waitforbridge = 0;
00469 int res = 0;
00470 char *parse;
00471 AST_DECLARE_APP_ARGS(args,
00472 AST_APP_ARG(format);
00473 AST_APP_ARG(fname_base);
00474 AST_APP_ARG(options);
00475 );
00476
00477
00478 if (ast_strlen_zero((char*)data)) {
00479 ast_log(LOG_ERROR, "Monitor requires an argument\n");
00480 return 0;
00481 }
00482
00483 parse = ast_strdupa((char*)data);
00484 AST_STANDARD_APP_ARGS(args, parse);
00485
00486 if (!ast_strlen_zero(args.options)) {
00487 if (strchr(args.options, 'm'))
00488 stream_action |= X_JOIN;
00489 if (strchr(args.options, 'b'))
00490 waitforbridge = 1;
00491 if (strchr(args.options, 'i'))
00492 stream_action &= ~X_REC_IN;
00493 if (strchr(args.options, 'o'))
00494 stream_action &= ~X_REC_OUT;
00495 }
00496
00497 arg = strchr(args.format, ':');
00498 if (arg) {
00499 *arg++ = 0;
00500 urlprefix = arg;
00501 }
00502
00503 if (urlprefix) {
00504 snprintf(tmp, sizeof(tmp), "%s/%s.%s", urlprefix, args.fname_base,
00505 ((strcmp(args.format, "gsm")) ? "wav" : "gsm"));
00506 if (!chan->cdr && !(chan->cdr = ast_cdr_alloc()))
00507 return -1;
00508 ast_cdr_setuserfield(chan, tmp);
00509 }
00510 if (waitforbridge) {
00511
00512
00513
00514
00515 delay = ast_strdupa(data);
00516 options = strrchr(delay, ',');
00517 if (options) {
00518 arg = strchr(options, 'b');
00519 if (arg) {
00520 *arg = 'X';
00521 pbx_builtin_setvar_helper(chan,"AUTO_MONITOR", delay);
00522 }
00523 }
00524 return 0;
00525 }
00526
00527 res = ast_monitor_start(chan, args.format, args.fname_base, 1, stream_action);
00528 if (res < 0)
00529 res = ast_monitor_change_fname(chan, args.fname_base, 1);
00530
00531 if (stream_action & X_JOIN) {
00532 if ((stream_action & X_REC_IN) && (stream_action & X_REC_OUT))
00533 joinfiles = 1;
00534 else
00535 ast_log(LOG_WARNING, "Won't mix streams unless both input and output streams are recorded\n");
00536 }
00537 ast_monitor_setjoinfiles(chan, joinfiles);
00538
00539 return res;
00540 }
00541
00542
00543 static int stop_monitor_exec(struct ast_channel *chan, void *data)
00544 {
00545 return ast_monitor_stop(chan, 1);
00546 }
00547
00548
00549 static int change_monitor_exec(struct ast_channel *chan, void *data)
00550 {
00551 return ast_monitor_change_fname(chan, (const char*)data, 1);
00552 }
00553
00554 static char start_monitor_action_help[] =
00555 "Description: The 'Monitor' action may be used to record the audio on a\n"
00556 " specified channel. The following parameters may be used to control\n"
00557 " this:\n"
00558 " Channel - Required. Used to specify the channel to record.\n"
00559 " File - Optional. Is the name of the file created in the\n"
00560 " monitor spool directory. Defaults to the same name\n"
00561 " as the channel (with slashes replaced with dashes).\n"
00562 " Format - Optional. Is the audio recording format. Defaults\n"
00563 " to \"wav\".\n"
00564 " Mix - Optional. Boolean parameter as to whether to mix\n"
00565 " the input and output channels together after the\n"
00566 " recording is finished.\n";
00567
00568
00569 static int start_monitor_action(struct mansession *s, const struct message *m)
00570 {
00571 struct ast_channel *c = NULL;
00572 const char *name = astman_get_header(m, "Channel");
00573 const char *fname = astman_get_header(m, "File");
00574 const char *format = astman_get_header(m, "Format");
00575 const char *mix = astman_get_header(m, "Mix");
00576 char *d;
00577
00578 if (ast_strlen_zero(name)) {
00579 astman_send_error(s, m, "No channel specified");
00580 return 0;
00581 }
00582 c = ast_get_channel_by_name_locked(name);
00583 if (!c) {
00584 astman_send_error(s, m, "No such channel");
00585 return 0;
00586 }
00587
00588 if (ast_strlen_zero(fname)) {
00589
00590 fname = ast_strdupa(c->name);
00591
00592 if ((d = strchr(fname, '/')))
00593 *d = '-';
00594 }
00595
00596 if (ast_monitor_start(c, format, fname, 1, X_REC_IN | X_REC_OUT)) {
00597 if (ast_monitor_change_fname(c, fname, 1)) {
00598 astman_send_error(s, m, "Could not start monitoring channel");
00599 ast_channel_unlock(c);
00600 return 0;
00601 }
00602 }
00603
00604 if (ast_true(mix)) {
00605 ast_monitor_setjoinfiles(c, 1);
00606 }
00607
00608 ast_channel_unlock(c);
00609 astman_send_ack(s, m, "Started monitoring channel");
00610 return 0;
00611 }
00612
00613 static char stop_monitor_action_help[] =
00614 "Description: The 'StopMonitor' action may be used to end a previously\n"
00615 " started 'Monitor' action. The only parameter is 'Channel', the name\n"
00616 " of the channel monitored.\n";
00617
00618
00619 static int stop_monitor_action(struct mansession *s, const struct message *m)
00620 {
00621 struct ast_channel *c = NULL;
00622 const char *name = astman_get_header(m, "Channel");
00623 int res;
00624 if (ast_strlen_zero(name)) {
00625 astman_send_error(s, m, "No channel specified");
00626 return 0;
00627 }
00628 c = ast_get_channel_by_name_locked(name);
00629 if (!c) {
00630 astman_send_error(s, m, "No such channel");
00631 return 0;
00632 }
00633 res = ast_monitor_stop(c, 1);
00634 ast_channel_unlock(c);
00635 if (res) {
00636 astman_send_error(s, m, "Could not stop monitoring channel");
00637 return 0;
00638 }
00639 astman_send_ack(s, m, "Stopped monitoring channel");
00640 return 0;
00641 }
00642
00643 static char change_monitor_action_help[] =
00644 "Description: The 'ChangeMonitor' action may be used to change the file\n"
00645 " started by a previous 'Monitor' action. The following parameters may\n"
00646 " be used to control this:\n"
00647 " Channel - Required. Used to specify the channel to record.\n"
00648 " File - Required. Is the new name of the file created in the\n"
00649 " monitor spool directory.\n";
00650
00651
00652 static int change_monitor_action(struct mansession *s, const struct message *m)
00653 {
00654 struct ast_channel *c = NULL;
00655 const char *name = astman_get_header(m, "Channel");
00656 const char *fname = astman_get_header(m, "File");
00657 if (ast_strlen_zero(name)) {
00658 astman_send_error(s, m, "No channel specified");
00659 return 0;
00660 }
00661 if (ast_strlen_zero(fname)) {
00662 astman_send_error(s, m, "No filename specified");
00663 return 0;
00664 }
00665 c = ast_get_channel_by_name_locked(name);
00666 if (!c) {
00667 astman_send_error(s, m, "No such channel");
00668 return 0;
00669 }
00670 if (ast_monitor_change_fname(c, fname, 1)) {
00671 astman_send_error(s, m, "Could not change monitored filename of channel");
00672 ast_channel_unlock(c);
00673 return 0;
00674 }
00675 ast_channel_unlock(c);
00676 astman_send_ack(s, m, "Changed monitor filename");
00677 return 0;
00678 }
00679
00680 void ast_monitor_setjoinfiles(struct ast_channel *chan, int turnon)
00681 {
00682 if (chan->monitor)
00683 chan->monitor->joinfiles = turnon;
00684 }
00685
00686 enum MONITOR_PAUSING_ACTION
00687 {
00688 MONITOR_ACTION_PAUSE,
00689 MONITOR_ACTION_UNPAUSE
00690 };
00691
00692 static int do_pause_or_unpause(struct mansession *s, const struct message *m, int action)
00693 {
00694 struct ast_channel *c = NULL;
00695 const char *name = astman_get_header(m, "Channel");
00696
00697 if (ast_strlen_zero(name)) {
00698 astman_send_error(s, m, "No channel specified");
00699 return -1;
00700 }
00701
00702 c = ast_get_channel_by_name_locked(name);
00703 if (!c) {
00704 astman_send_error(s, m, "No such channel");
00705 return -1;
00706 }
00707
00708 if (action == MONITOR_ACTION_PAUSE)
00709 ast_monitor_pause(c);
00710 else
00711 ast_monitor_unpause(c);
00712
00713 ast_channel_unlock(c);
00714 astman_send_ack(s, m, (action == MONITOR_ACTION_PAUSE ? "Paused monitoring of the channel" : "Unpaused monitoring of the channel"));
00715 return 0;
00716 }
00717
00718 static char pause_monitor_action_help[] =
00719 "Description: The 'PauseMonitor' action may be used to temporarily stop the\n"
00720 " recording of a channel. The following parameters may\n"
00721 " be used to control this:\n"
00722 " Channel - Required. Used to specify the channel to record.\n";
00723
00724 static int pause_monitor_action(struct mansession *s, const struct message *m)
00725 {
00726 return do_pause_or_unpause(s, m, MONITOR_ACTION_PAUSE);
00727 }
00728
00729 static char unpause_monitor_action_help[] =
00730 "Description: The 'UnpauseMonitor' action may be used to re-enable recording\n"
00731 " of a channel after calling PauseMonitor. The following parameters may\n"
00732 " be used to control this:\n"
00733 " Channel - Required. Used to specify the channel to record.\n";
00734
00735 static int unpause_monitor_action(struct mansession *s, const struct message *m)
00736 {
00737 return do_pause_or_unpause(s, m, MONITOR_ACTION_UNPAUSE);
00738 }
00739
00740
00741 static int load_module(void)
00742 {
00743 ast_register_application("Monitor", start_monitor_exec, monitor_synopsis, monitor_descrip);
00744 ast_register_application("StopMonitor", stop_monitor_exec, stopmonitor_synopsis, stopmonitor_descrip);
00745 ast_register_application("ChangeMonitor", change_monitor_exec, changemonitor_synopsis, changemonitor_descrip);
00746 ast_register_application("PauseMonitor", pause_monitor_exec, pausemonitor_synopsis, pausemonitor_descrip);
00747 ast_register_application("UnpauseMonitor", unpause_monitor_exec, unpausemonitor_synopsis, unpausemonitor_descrip);
00748 ast_manager_register2("Monitor", EVENT_FLAG_CALL, start_monitor_action, monitor_synopsis, start_monitor_action_help);
00749 ast_manager_register2("StopMonitor", EVENT_FLAG_CALL, stop_monitor_action, stopmonitor_synopsis, stop_monitor_action_help);
00750 ast_manager_register2("ChangeMonitor", EVENT_FLAG_CALL, change_monitor_action, changemonitor_synopsis, change_monitor_action_help);
00751 ast_manager_register2("PauseMonitor", EVENT_FLAG_CALL, pause_monitor_action, pausemonitor_synopsis, pause_monitor_action_help);
00752 ast_manager_register2("UnpauseMonitor", EVENT_FLAG_CALL, unpause_monitor_action, unpausemonitor_synopsis, unpause_monitor_action_help);
00753
00754 return AST_MODULE_LOAD_SUCCESS;
00755 }
00756
00757 static int unload_module(void)
00758 {
00759 ast_unregister_application("Monitor");
00760 ast_unregister_application("StopMonitor");
00761 ast_unregister_application("ChangeMonitor");
00762 ast_unregister_application("PauseMonitor");
00763 ast_unregister_application("UnpauseMonitor");
00764 ast_manager_unregister("Monitor");
00765 ast_manager_unregister("StopMonitor");
00766 ast_manager_unregister("ChangeMonitor");
00767 ast_manager_unregister("PauseMonitor");
00768 ast_manager_unregister("UnpauseMonitor");
00769
00770 return 0;
00771 }
00772
00773
00774 AST_MODULE_INFO(ASTERISK_GPL_KEY, AST_MODFLAG_GLOBAL_SYMBOLS, "Call Monitoring Resource",
00775 .load = load_module,
00776 .unload = unload_module,
00777 );