From bc9bd7bb7c38d2ec2bd0b0814d19473e1615b3b5 Mon Sep 17 00:00:00 2001 From: mnicholson Date: Tue, 2 Mar 2010 23:11:06 +0000 Subject: Merge res_fax and res_fax_spandsp. git-svn-id: http://svn.digium.com/svn/asterisk/trunk@250190 f38db490-d61c-443f-a65b-d21fe96a405b --- include/asterisk/frame.h | 10 +- res/res_fax.c | 1891 ++++++++++++++++++++++++++++++++++++++++++++++ res/res_fax.exports | 11 + res/res_fax_spandsp.c | 762 +++++++++++++++++++ 4 files changed, 2670 insertions(+), 4 deletions(-) create mode 100644 res/res_fax.c create mode 100644 res/res_fax.exports create mode 100644 res/res_fax_spandsp.c diff --git a/include/asterisk/frame.h b/include/asterisk/frame.h index c493b8114..f9a9a4f0a 100644 --- a/include/asterisk/frame.h +++ b/include/asterisk/frame.h @@ -131,16 +131,18 @@ enum { AST_FRFLAG_HAS_TIMING_INFO = (1 << 0), }; +union ast_frame_subclass { + int integer; + format_t codec; +}; + /*! \brief Data structure associated with a single frame of data */ struct ast_frame { /*! Kind of frame */ enum ast_frame_type frametype; /*! Subclass, frame dependent */ - union { - int integer; - format_t codec; - } subclass; + union ast_frame_subclass subclass; /*! Length of data */ int datalen; /*! Number of samples in this frame */ diff --git a/res/res_fax.c b/res/res_fax.c new file mode 100644 index 000000000..36ca2601b --- /dev/null +++ b/res/res_fax.c @@ -0,0 +1,1891 @@ +/* + * Asterisk -- An open source telephony toolkit. + * + * Copyright (C) 2008-2009, Digium, Inc. + * + * Dwayne M. Hubbard + * Kevin P. Fleming + * + * See http://www.asterisk.org for more information about + * the Asterisk project. Please do not directly contact + * any of the maintainers of this project for assistance; + * the project provides a web site, mailing lists and IRC + * channels for your use. + * + * This program is free software, distributed under the terms of + * the GNU General Public License Version 2. See the LICENSE file + * at the top of the source tree. + */ + +/*! \file + * + * \brief Generic FAX Resource for FAX technology resource modules + * + * \author Dwayne M. Hubbard + * \author Kevin P. Fleming + * + * A generic FAX resource module that provides SendFAX and ReceiveFAX applications. + * This module requires FAX technology modules, like res_fax_spandsp, to register with it + * so it can use the technology modules to perform the actual FAX transmissions. + * \ingroup applications + */ + +#include "asterisk.h" + +ASTERISK_FILE_VERSION(__FILE__, "$Revision$") + +#include "asterisk/io.h" +#include "asterisk/file.h" +#include "asterisk/logger.h" +#include "asterisk/module.h" +#include "asterisk/app.h" +#include "asterisk/lock.h" +#include "asterisk/options.h" +#include "asterisk/strings.h" +#include "asterisk/cli.h" +#include "asterisk/utils.h" +#include "asterisk/config.h" +#include "asterisk/astobj2.h" +#include "asterisk/file.h" +#include "asterisk/channel.h" +#include "asterisk/pbx.h" +#include "asterisk/manager.h" +#include "asterisk/dsp.h" +#include "asterisk/res_fax.h" + +static const char app_receivefax[] = "ReceiveFAX"; +static const char synopsis_receivefax[] = "Receive a FAX and save as a TIFF/F file."; +static const char descrip_receivefax[] = "ReceiveFAX(filename[,options]):\n" + " The ReceiveFAX() application receives a FAX as a TIFF/F file with specified filename.\n" + " The application arguments are:\n" + " 'd' - enables FAX debugging\n" + " 'f' - allow audio fallback FAX transfer on T.38 capable channels\n" + " 's' - send progress Manager events (overrides statusevents setting in res_fax.conf)\n" + "\n" + " Use the FAXOPT function to specify session arguments prior to calling ReceiveFAX()\n" + " and use FAXOPT after ReceiveFAX completes to query result status for the session.\n" + " The ReceiveFAX() is provided by res_fax, which is a FAX technology agnostic module\n" + " that utilizes FAX technology resource modules to complete a FAX transmission.\n"; + +static const char app_sendfax[] = "SendFAX"; +static const char synopsis_sendfax[] = "Sends a specified TIFF/F file as a FAX."; +static const char descrip_sendfax[] = "SendFAX(filename[,options]):\n" + " The SendFAX() application sends the specified TIFF/F file as a FAX.\n" + " The application arguments are:\n" + " 'd' - enables FAX debugging\n" + " 'f' - allow audio fallback FAX transfer on T.38 capable channels\n" + " 's' - send progress Manager events (overrides statusevents setting in res_fax.conf)\n" + "\n" + " Use the FAXOPT function to specify session arguments prior to calling SendFAX()\n" + " and use FAXOPT after SendFAX completes to query result status for the session.\n" + " The SendFAX() application is provided by res_fax, which is a FAX technology agnostic module\n" + " that utilizes FAX technology resource modules to complete a FAX transmission.\n"; + +struct debug_info_history { + unsigned int consec_frames; + unsigned int consec_ms; + unsigned char silence; +}; + +struct ast_fax_debug_info { + struct timeval base_tv; + struct debug_info_history c2s, s2c; + struct ast_dsp *dsp; +}; + +/*! \brief maximum buckets for res_fax ao2 containers */ +#define FAX_MAXBUCKETS 10 + +#define RES_FAX_TIMEOUT 10000 + +/*! \brief The faxregistry is used to manage information and statistics for all FAX sessions. */ +static struct { + /*! The number of active FAX sessions */ + int active_sessions; + /*! active sessions are astobj2 objects */ + struct ao2_container *container; + /*! Total number of Tx FAX attempts */ + int fax_tx_attempts; + /*! Total number of Rx FAX attempts */ + int fax_rx_attempts; + /*! Number of successful FAX transmissions */ + int fax_complete; + /*! Number of failed FAX transmissions */ + int fax_failures; + /*! the next unique session name */ + int nextsessionname; +} faxregistry; + +/*! \brief registered FAX technology modules are put into this list */ +struct fax_module { + const struct ast_fax_tech *tech; + AST_RWLIST_ENTRY(fax_module) list; +}; +static AST_RWLIST_HEAD_STATIC(faxmodules, fax_module); + +#define RES_FAX_MINRATE 2400 +#define RES_FAX_MAXRATE 14400 +#define RES_FAX_STATUSEVENTS 0 +#define RES_FAX_MODEM (AST_FAX_MODEM_V17 | AST_FAX_MODEM_V27 | AST_FAX_MODEM_V29) + +static struct { + enum ast_fax_modems modems; + uint32_t statusevents:1; + unsigned int minrate; + unsigned int maxrate; +} general_options; + +static const char *config = "res_fax.conf"; + +static int global_fax_debug = 0; + +enum { + OPT_CALLEDMODE = (1 << 0), + OPT_CALLERMODE = (1 << 1), + OPT_DEBUG = (1 << 2), + OPT_STATUS = (1 << 3), + OPT_ALLOWAUDIO = (1 << 5), +}; + +AST_APP_OPTIONS(fax_exec_options, BEGIN_OPTIONS + AST_APP_OPTION('a', OPT_CALLEDMODE), + AST_APP_OPTION('c', OPT_CALLERMODE), + AST_APP_OPTION('d', OPT_DEBUG), + AST_APP_OPTION('f', OPT_ALLOWAUDIO), + AST_APP_OPTION('s', OPT_STATUS), +END_OPTIONS); + +struct manager_event_info { + char context[AST_MAX_CONTEXT]; + char exten[AST_MAX_EXTENSION]; + char cid[128]; +}; + +static void debug_check_frame_for_silence(struct ast_fax_session *s, unsigned int c2s, struct ast_frame *frame) +{ + struct debug_info_history *history = c2s ? &s->debug_info->c2s : &s->debug_info->s2c; + int dspsilence; + unsigned int last_consec_frames, last_consec_ms; + unsigned char wassil; + struct timeval diff; + + diff = ast_tvsub(ast_tvnow(), s->debug_info->base_tv); + + ast_dsp_reset(s->debug_info->dsp); + ast_dsp_silence(s->debug_info->dsp, frame, &dspsilence); + + wassil = history->silence; + history->silence = (dspsilence != 0) ? 1 : 0; + if (history->silence != wassil) { + last_consec_frames = history->consec_frames; + last_consec_ms = history->consec_ms; + history->consec_frames = 0; + history->consec_ms = 0; + + if ((last_consec_frames != 0)) { + ast_verb(6, "Channel '%s' fax session '%d', [ %.3ld.%.6ld ], %s sent %d frames (%d ms) of %s.\n", + s->channame, s->id, (long) diff.tv_sec, (long int) diff.tv_usec, + (c2s) ? "channel" : "stack", last_consec_frames, last_consec_ms, + (wassil) ? "silence" : "energy"); + } + } + + history->consec_frames++; + history->consec_ms += (frame->samples / 8); +} + +static void destroy_callback(void *data) +{ + if (data) { + ao2_ref(data, -1); + } +} + +static const struct ast_datastore_info fax_datastore = { + .type = "res_fax", + .destroy = destroy_callback, +}; + +/*! \brief returns a reference counted pointer to a fax datastore, if it exists */ +static struct ast_fax_session_details *find_details(struct ast_channel *chan) +{ + struct ast_fax_session_details *details; + struct ast_datastore *datastore; + + ast_channel_lock(chan); + if (!(datastore = ast_channel_datastore_find(chan, &fax_datastore, NULL))) { + ast_channel_unlock(chan); + return NULL; + } + if (!(details = datastore->data)) { + ast_log(LOG_WARNING, "Huh? channel '%s' has a FAX datastore without data!\n", chan->name); + ast_channel_unlock(chan); + return NULL; + } + ao2_ref(details, 1); + ast_channel_unlock(chan); + + return details; +} + +/*! \brief destroy a FAX session details structure */ +static void destroy_session_details(void *details) +{ + struct ast_fax_session_details *d = details; + struct ast_fax_document *doc; + + while ((doc = AST_LIST_REMOVE_HEAD(&d->documents, next))) { + ast_free(doc); + } + ast_string_field_free_memory(d); +} + +/*! \brief create a FAX session details structure */ +static struct ast_fax_session_details *session_details_new(void) +{ + struct ast_fax_session_details *d; + + if (!(d = ao2_alloc(sizeof(*d), destroy_session_details))) { + return NULL; + } + + if (ast_string_field_init(d, 512)) { + ao2_ref(d, -1); + return NULL; + } + + AST_LIST_HEAD_INIT_NOLOCK(&d->documents); + + /* These options need to be set to the configured default and may be overridden by + * SendFAX, ReceiveFAX, or FAXOPT */ + d->option.ecm = AST_FAX_OPTFLAG_DEFAULT; + d->option.statusevents = general_options.statusevents; + d->modems = general_options.modems; + d->minrate = general_options.minrate; + d->maxrate = general_options.maxrate; + + return d; +} + +/*! \brief returns a reference counted details structure from the channel's fax datastore. If the datastore + * does not exist it will be created */ +static struct ast_fax_session_details *find_or_create_details(struct ast_channel *chan) +{ + struct ast_fax_session_details *details; + struct ast_datastore *datastore; + + if ((details = find_details(chan))) { + return details; + } + /* channel does not have one so we must create one */ + if (!(details = session_details_new())) { + ast_log(LOG_WARNING, "channel '%s' can't get a FAX details structure for the datastore!\n", chan->name); + return NULL; + } + if (!(datastore = ast_datastore_alloc(&fax_datastore, NULL))) { + ao2_ref(details, -1); + ast_log(LOG_WARNING, "channel '%s' can't get a datastore!\n", chan->name); + return NULL; + } + /* add the datastore to the channel and increment the refcount */ + datastore->data = details; + ao2_ref(details, 1); + ast_channel_lock(chan); + ast_channel_datastore_add(chan, datastore); + ast_channel_unlock(chan); + return details; +} + +unsigned int ast_fax_maxrate(void) +{ + return general_options.maxrate; +} + +unsigned int ast_fax_minrate(void) +{ + return general_options.minrate; +} + +static int update_modem_bits(enum ast_fax_modems *bits, const char *value) +{ + char *m[5], *tok, *v = (char *)value; + int i = 0, j; + + if (!(tok = strchr(v, ','))) { + m[i++] = v; + m[i] = NULL; + } else { + tok = strtok(v, ", "); + while (tok && (i < 5)) { + m[i++] = tok; + tok = strtok(NULL, ", "); + } + m[i] = NULL; + } + + *bits = 0; + for (j = 0; j < i; j++) { + if (!strcasecmp(m[j], "v17")) { + *bits |= AST_FAX_MODEM_V17; + } else if (!strcasecmp(m[j], "v27")) { + *bits |= AST_FAX_MODEM_V27; + } else if (!strcasecmp(m[j], "v29")) { + *bits |= AST_FAX_MODEM_V29; + } else if (!strcasecmp(m[j], "v34")) { + *bits |= AST_FAX_MODEM_V34; + } else { + ast_log(LOG_WARNING, "ignoring invalid modem setting: '%s', valid options {v17 | v27 | v29 | v34}\n", m[j]); + } + } + return 0; +} + +static int ast_fax_modem_to_str(enum ast_fax_modems bits, char *tbuf, size_t bufsize) +{ + int count = 0; + + if (bits & AST_FAX_MODEM_V17) { + strcat(tbuf, "V17"); + count++; + } + if (bits & AST_FAX_MODEM_V27) { + if (count) { + strcat(tbuf, ","); + } + strcat(tbuf, "V27"); + count++; + } + if (bits & AST_FAX_MODEM_V29) { + if (count) { + strcat(tbuf, ","); + } + strcat(tbuf, "V29"); + count++; + } + if (bits & AST_FAX_MODEM_V34) { + if (count) { + strcat(tbuf, ","); + } + strcat(tbuf, "V34"); + count++; + } + + return 0; +} + +/*! \brief register a FAX technology module */ +int ast_fax_tech_register(struct ast_fax_tech *tech) +{ + struct fax_module *fax; + + if (!(fax = ast_calloc(1, sizeof(*fax)))) { + return -1; + } + fax->tech = tech; + AST_RWLIST_WRLOCK(&faxmodules); + AST_RWLIST_INSERT_TAIL(&faxmodules, fax, list); + AST_RWLIST_UNLOCK(&faxmodules); + ast_module_ref(ast_module_info->self); + + ast_verb(3, "Registered handler for '%s' (%s)\n", fax->tech->type, fax->tech->description); + + return 0; +} + +/*! \brief unregister a FAX technology module */ +void ast_fax_tech_unregister(struct ast_fax_tech *tech) +{ + struct fax_module *fax; + + ast_verb(3, "Unregistering FAX module type '%s'\n", tech->type); + + AST_RWLIST_WRLOCK(&faxmodules); + AST_RWLIST_TRAVERSE_SAFE_BEGIN(&faxmodules, fax, list) { + if (fax->tech != tech) { + continue; + } + AST_RWLIST_REMOVE_CURRENT(list); + ast_module_unref(ast_module_info->self); + ast_free(fax); + ast_verb(4, "Unregistered FAX module type '%s'\n", tech->type); + break; + } + AST_RWLIST_TRAVERSE_SAFE_END; + AST_RWLIST_UNLOCK(&faxmodules); +} + +/*! \brief convert a ast_fax_state to a string */ +const char *ast_fax_state_to_str(enum ast_fax_state state) +{ + switch (state) { + case AST_FAX_STATE_UNINITIALIZED: + return "Uninitialized"; + case AST_FAX_STATE_INITIALIZED: + return "Initialized"; + case AST_FAX_STATE_OPEN: + return "Open"; + case AST_FAX_STATE_ACTIVE: + return "Active"; + case AST_FAX_STATE_COMPLETE: + return "Complete"; + default: + ast_log(LOG_WARNING, "unhandled FAX state: %d\n", state); + return "Unknown"; + } +} + +/*! \brief convert a rate string to a rate */ +static int fax_rate_str_to_int(const char *ratestr) +{ + int rate; + + if (sscanf(ratestr, "%d", &rate) != 1) { + ast_log(LOG_ERROR, "failed to sscanf '%s' to rate\n", ratestr); + return -1; + } + switch (rate) { + case 2400: + case 4800: + case 7200: + case 9600: + case 12000: + case 14400: + case 28800: + case 33600: + return rate; + default: + ast_log(LOG_WARNING, "ignoring invalid rate '%s'. Valid options are {2400 | 4800 | 7200 | 9600 | 12000 | 14400 | 28800 | 33600}\n", ratestr); + return -1; + } +} + +/*! \brief destroy a FAX session structure */ +static void destroy_session(void *session) +{ + struct ast_fax_session *s = session; + + if (s->tech) { + if (s->tech_pvt) { + s->tech->destroy_session(s); + } + ast_module_unref(s->tech->module); + } + + if (s->details) { + ao2_ref(s->details, -1); + } + + if (s->debug_info) { + ast_dsp_free(s->debug_info->dsp); + ast_free(s->debug_info); + } + + if (s->smoother) { + ast_smoother_free(s->smoother); + } + + ast_atomic_fetchadd_int(&faxregistry.active_sessions, -1); + + ast_free(s->channame); +} + +/*! \brief create a FAX session */ +static struct ast_fax_session *fax_session_new(struct ast_fax_session_details *details, struct ast_channel *chan) +{ + struct ast_fax_session *s; + struct fax_module *faxmod; + + if (!(s = ao2_alloc(sizeof(*s), destroy_session))) { + return NULL; + } + + ast_atomic_fetchadd_int(&faxregistry.active_sessions, 1); + + if (details->option.debug && (details->caps & AST_FAX_TECH_AUDIO)) { + if (!(s->debug_info = ast_calloc(1, sizeof(*(s->debug_info))))) { + ao2_ref(s, -1); + return NULL; + } + if (!(s->debug_info->dsp = ast_dsp_new())) { + ast_free(s->debug_info); + s->debug_info = NULL; + ao2_ref(s, -1); + return NULL; + } + ast_dsp_set_threshold(s->debug_info->dsp, 128); + } + + if (!(s->channame = ast_strdup(chan->name))) { + ao2_ref(s, -1); + return NULL; + } + s->chan = chan; + s->details = details; + ao2_ref(s->details, 1); + s->state = AST_FAX_STATE_UNINITIALIZED; + + details->id = s->id = ast_atomic_fetchadd_int(&faxregistry.nextsessionname, 1); + + /* locate a FAX technology module that can handle said requirements */ + AST_RWLIST_RDLOCK(&faxmodules); + AST_RWLIST_TRAVERSE(&faxmodules, faxmod, list) { + if ((faxmod->tech->caps & details->caps) != details->caps) { + continue; + } + ast_debug(4, "Requesting a new FAX session from '%s'.\n", faxmod->tech->description); + ast_module_ref(faxmod->tech->module); + s->tech = faxmod->tech; + break; + } + AST_RWLIST_UNLOCK(&faxmodules); + + if (!faxmod) { + ast_log(LOG_ERROR, "Could not locate a FAX technology module with capabilities (0x%X)\n", details->caps); + ao2_ref(s, -1); + return NULL; + } + if (!(s->tech_pvt = s->tech->new_session(s, NULL))) { + ast_log(LOG_ERROR, "FAX session failed to initialize.\n"); + ao2_ref(s, -1); + ast_module_unref(faxmod->tech->module); + return NULL; + } + /* link the session to the session container */ + if (!(ao2_link(faxregistry.container, s))) { + ast_log(LOG_ERROR, "failed to add FAX session '%d' to container.\n", s->id); + ao2_ref(s, -1); + ast_module_unref(faxmod->tech->module); + return NULL; + } + ast_debug(4, "channel '%s' using FAX session '%d'\n", s->channame, s->id); + + return s; +} + +static void get_manager_event_info(struct ast_channel *chan, struct manager_event_info *info) +{ + pbx_substitute_variables_helper(chan, "${CONTEXT}", info->context, sizeof(info->context)); + pbx_substitute_variables_helper(chan, "${EXTEN}", info->exten, sizeof(info->exten)); + pbx_substitute_variables_helper(chan, "${CALLERID(num)}", info->cid, sizeof(info->cid)); +} + +/*! \brief send a FAX status manager event */ +static int report_fax_status(struct ast_channel *chan, struct ast_fax_session_details *details, const char *status) +{ + ast_channel_lock(chan); + pbx_builtin_setvar_helper(chan, "FAXSTATUSSTRING", status); + if (details->option.statusevents) { + struct manager_event_info info; + + get_manager_event_info(chan, &info); + manager_event(EVENT_FLAG_CALL, + (details->caps & AST_FAX_TECH_RECEIVE) ? "ReceiveFAXStatus" : "SendFAXStatus", + "Status: %s\r\n" + "Channel: %s\r\n" + "Context: %s\r\n" + "Exten: %s\r\n" + "CallerID: %s\r\n" + "LocalStationID: %s\r\n" + "FileName: %s\r\n", + status, + chan->name, + info.context, + info.exten, + info.cid, + details->localstationid, + AST_LIST_FIRST(&details->documents)->filename); + } + ast_channel_unlock(chan); + + return 0; +} + +#define GENERIC_FAX_EXEC_ERROR(fax, chan, reason) \ + do { \ + ast_log(LOG_ERROR, "channel '%s' FAX session '%d' failure, reason: '%s'\n", chan->name, fax->id, reason); \ + pbx_builtin_setvar_helper(chan, "FAXSTATUSSTRING", reason); \ + if (ast_strlen_zero(fax->details->result)) ast_string_field_set(fax->details, result, "FAILED"); \ + res = ms = -1; \ + } while (0) + +static void t38_parameters_ast_to_fax(struct ast_fax_t38_parameters *dst, const struct ast_control_t38_parameters *src) +{ + dst->version = src->version; + dst->max_ifp = src->max_ifp; + dst->rate = src->rate; + dst->rate_management = src->rate_management; + dst->fill_bit_removal = src->fill_bit_removal; + dst->transcoding_mmr = src->transcoding_mmr; + dst->transcoding_jbig = src->transcoding_jbig; +} + +static void t38_parameters_fax_to_ast(struct ast_control_t38_parameters *dst, const struct ast_fax_t38_parameters *src) +{ + dst->version = src->version; + dst->max_ifp = src->max_ifp; + dst->rate = src->rate; + dst->rate_management = src->rate_management; + dst->fill_bit_removal = src->fill_bit_removal; + dst->transcoding_mmr = src->transcoding_mmr; + dst->transcoding_jbig = src->transcoding_jbig; +} + +/*! \brief this is the generic FAX session handling function */ +static int generic_fax_exec(struct ast_channel *chan, struct ast_fax_session_details *details) +{ + int ms; + int timeout = RES_FAX_TIMEOUT; + int res = 0, chancount; + unsigned int expected_frametype = -1; + union ast_frame_subclass expected_framesubclass = { .integer = -1 }; + char tbuf[10]; + unsigned int t38negotiated = 0; + enum ast_t38_state t38_state; + struct ast_control_t38_parameters t38_parameters; + int send_cng = -1; + unsigned int disable_t38 = 0; + const char *tempvar; + struct ast_fax_session *fax = NULL; + struct ast_frame *frame = NULL; + struct ast_channel *c = chan; + unsigned int orig_write_format = 0, orig_read_format = 0; + unsigned int request_t38 = 0; + + details->our_t38_parameters.version = 0; + details->our_t38_parameters.max_ifp = 400; + details->our_t38_parameters.rate = AST_T38_RATE_14400; + details->our_t38_parameters.rate_management = AST_T38_RATE_MANAGEMENT_TRANSFERRED_TCF; + + chancount = 1; + + /* generate 3 seconds of CED if we are in receive mode */ + if (details->caps & AST_FAX_TECH_RECEIVE) { + ms = 3000; + if (ast_tonepair_start(chan, 2100, 0, ms, 0)) { + ast_log(LOG_ERROR, "error generating CED tone on %s\n", chan->name); + return -1; + } + + do { + ms = ast_waitfor(chan, ms); + if (ms < 0) { + ast_log(LOG_ERROR, "error while generating CED tone on %s\n", chan->name); + ast_tonepair_stop(chan); + return -1; + } + + if (ms == 0) { /* all done, nothing happened */ + break; + } + + if (!(frame = ast_read(chan))) { + ast_log(LOG_ERROR, "error reading frame while generating CED tone on %s\n", chan->name); + ast_tonepair_stop(chan); + return -1; + } + + if ((frame->frametype == AST_FRAME_CONTROL) && + (frame->subclass.integer == AST_CONTROL_T38_PARAMETERS) && + (frame->datalen == sizeof(t38_parameters))) { + struct ast_control_t38_parameters *parameters = frame->data.ptr; + + switch (parameters->request_response) { + case AST_T38_REQUEST_NEGOTIATE: + /* the other end has requested a switch to T.38, so reply that we are willing, if we can + * do T.38 as well + */ + t38_parameters_fax_to_ast(&t38_parameters, &details->our_t38_parameters); + t38_parameters.request_response = (details->caps & AST_FAX_TECH_T38) ? AST_T38_NEGOTIATED : AST_T38_REFUSED; + ast_indicate_data(chan, AST_CONTROL_T38_PARAMETERS, &t38_parameters, sizeof(t38_parameters)); + break; + case AST_T38_NEGOTIATED: + ast_log(LOG_NOTICE, "Negotiated T.38 for receive on %s\n", chan->name); + t38_parameters_ast_to_fax(&details->their_t38_parameters, parameters); + details->caps &= ~AST_FAX_TECH_AUDIO; + report_fax_status(chan, details, "T.38 Negotiated"); + t38negotiated = 1; + ms = 0; + break; + default: + break; + } + } + ast_frfree(frame); + } while (ms > 0); + ast_tonepair_stop(chan); + } + + switch ((t38_state = ast_channel_get_t38_state(chan))) { + case T38_STATE_UNKNOWN: + if (details->caps & AST_FAX_TECH_SEND) { + if (details->option.allow_audio) { + details->caps |= AST_FAX_TECH_AUDIO; + } else { + /* we are going to send CNG to attempt to stimulate the receiver + * into switching to T.38, since audio mode is not allowed + */ + send_cng = 0; + } + } else { + /* we *always* request a switch to T.38 if allowed; if audio is also + * allowed, then we will allow the switch to happen later if needed + */ + if (details->option.allow_audio) { + details->caps |= AST_FAX_TECH_AUDIO; + } + request_t38 = 1; + } + details->caps |= AST_FAX_TECH_T38; + break; + case T38_STATE_UNAVAILABLE: + details->caps |= AST_FAX_TECH_AUDIO; + break; + default: + ast_log(LOG_ERROR, "channel '%s' is in an unsupported T.38 negotiation state, cannot continue.\n", chan->name); + return -1; + } + + if (request_t38) { + /* wait up to five seconds for negotiation to complete */ + timeout = 5000; + + /* set parameters based on the session's parameters */ + t38_parameters_fax_to_ast(&t38_parameters, &details->our_t38_parameters); + t38_parameters.request_response = AST_T38_REQUEST_NEGOTIATE; + if ((ast_indicate_data(chan, AST_CONTROL_T38_PARAMETERS, &t38_parameters, sizeof(t38_parameters)) != 0)) { + res = -1; + goto t38done; + } + + ast_log(LOG_NOTICE, "Negotiating T.38 for %s on %s\n", (details->caps & AST_FAX_TECH_SEND) ? "send" : "receive", chan->name); + } else if (!details->option.allow_audio) { + /* wait up to sixty seconds for negotiation to complete */ + timeout = 60000; + + ast_log(LOG_NOTICE, "Waiting for T.38 negotiation for %s on %s\n", (details->caps & AST_FAX_TECH_SEND) ? "send" : "receive", chan->name); + } + + if (request_t38 || !details->option.allow_audio) { + struct ast_silence_generator *silence_gen = NULL; + + if (send_cng != -1) { + silence_gen = ast_channel_start_silence_generator(chan); + } + + while (timeout > 0) { + if (send_cng > 3000) { + ast_channel_stop_silence_generator(chan, silence_gen); + silence_gen = NULL; + ast_tonepair_start(chan, 1100, 0, 500, 0); + send_cng = 0; + } else if (!chan->generator && (send_cng != -1)) { + /* The CNG tone is done so restart silence generation. */ + silence_gen = ast_channel_start_silence_generator(chan); + } + /* this timeout *MUST* be 500ms, in order to keep the spacing + * of CNG tones correct when this loop is sending them + */ + ms = ast_waitfor(chan, 500); + if (ms < 0) { + ast_log(LOG_WARNING, "something bad happened while channel '%s' was polling.\n", chan->name); + res = -1; + break; + } + if (send_cng != -1) { + send_cng += 500 - ms; + } + if (!ms) { + /* nothing happened */ + if (timeout > 0) { + timeout -= 500; + continue; + } else { + ast_log(LOG_WARNING, "channel '%s' timed-out during the T.38 negotiation.\n", chan->name); + res = -1; + break; + } + } + if (!(frame = ast_read(chan))) { + if (silence_gen) { + ast_channel_stop_silence_generator(chan, silence_gen); + silence_gen = NULL; + } + return -1; + } + if ((frame->frametype == AST_FRAME_CONTROL) && + (frame->subclass.integer == AST_CONTROL_T38_PARAMETERS) && + (frame->datalen == sizeof(t38_parameters))) { + struct ast_control_t38_parameters *parameters = frame->data.ptr; + int stop = 1; + + switch (parameters->request_response) { + case AST_T38_REQUEST_NEGOTIATE: + t38_parameters_fax_to_ast(&t38_parameters, &details->our_t38_parameters); + t38_parameters.request_response = AST_T38_NEGOTIATED; + ast_indicate_data(chan, AST_CONTROL_T38_PARAMETERS, &t38_parameters, sizeof(t38_parameters)); + stop = 0; + break; + case AST_T38_NEGOTIATED: + ast_log(LOG_NOTICE, "Negotiated T.38 for %s on %s\n", (details->caps & AST_FAX_TECH_SEND) ? "send" : "receive", chan->name); + t38_parameters_ast_to_fax(&details->their_t38_parameters, parameters); + details->caps &= ~AST_FAX_TECH_AUDIO; + t38negotiated = 1; + disable_t38 = 1; + break; + case AST_T38_REFUSED: + ast_log(LOG_WARNING, "channel '%s' refused to negotiate T.38\n", chan->name); + res = -1; + break; + default: + ast_log(LOG_ERROR, "channel '%s' failed to negotiate T.38\n", chan->name); + res = -1; + break; + } + if (stop) { + ast_frfree(frame); + break; + } + } + ast_frfree(frame); + } + + if (silence_gen) { + ast_channel_stop_silence_generator(chan, silence_gen); + silence_gen = NULL; + } + } + +t38done: + /* if any failures occurred during T.38 negotiation, handle them here */ + if (res) { + /* if audio is allowed, then drop the T.38 session requirement + * and proceed, otherwise the request has failed + */ + if (details->option.allow_audio) { + details->caps &= ~AST_FAX_TECH_T38; + res = 0; + } else { + ast_log(LOG_WARNING, "Audio FAX not allowed on channel '%s' and T.38 negotiation failed; aborting.\n", chan->name); + return -1; + } + } + + /* create the FAX session */ + if (!(fax = fax_session_new(details, chan))) { + ast_log(LOG_ERROR, "Can't create a FAX session, FAX attempt failed.\n"); + report_fax_status(chan, details, "No Available Resource"); + chancount = -1; + goto disable_t38; + } + + ast_channel_lock(chan); + /* update session details */ + if (ast_strlen_zero(details->headerinfo) && (tempvar = pbx_builtin_getvar_helper(chan, "LOCALHEADERINFO"))) { + ast_string_field_set(details, headerinfo, tempvar); + } + if (ast_strlen_zero(details->localstationid)) { + tempvar = pbx_builtin_getvar_helper(chan, "LOCALSTATIONID"); + ast_string_field_set(details, localstationid, tempvar ? tempvar : "unknown"); + } + ast_channel_unlock(chan); + + report_fax_status(chan, details, "Allocating Resources"); + + if (details->caps & AST_FAX_TECH_AUDIO) { + expected_frametype = AST_FRAME_VOICE;; + expected_framesubclass.codec = AST_FORMAT_SLINEAR; + orig_write_format = chan->writeformat; + if (ast_set_write_format(chan, AST_FORMAT_SLINEAR) < 0) { + ast_log(LOG_ERROR, "channel '%s' failed to set write format to signed linear'.\n", chan->name); + ao2_lock(faxregistry.container); + ao2_unlink(faxregistry.container, fax); + ao2_unlock(faxregistry.container); + ao2_ref(fax, -1); + ast_channel_unlock(chan); + return -1; + } + orig_read_format = chan->readformat; + if (ast_set_read_format(chan, AST_FORMAT_SLINEAR) < 0) { + ast_log(LOG_ERROR, "channel '%s' failed to set read format to signed linear.\n", chan->name); + ao2_lock(faxregistry.container); + ao2_unlink(faxregistry.container, fax); + ao2_unlock(faxregistry.container); + ao2_ref(fax, -1); + ast_channel_unlock(chan); + return -1; + } + if (fax->smoother) { + ast_smoother_free(fax->smoother); + fax->smoother = NULL; + } + if (!(fax->smoother = ast_smoother_new(320))) { + ast_log(LOG_WARNING, "Channel '%s' FAX session '%d' failed to obtain a smoother.\n", chan->name, fax->id); + } + } else { + expected_frametype = AST_FRAME_MODEM; + expected_framesubclass.codec = AST_MODEM_T38; + } + + if (fax->debug_info) { + fax->debug_info->base_tv = ast_tvnow(); + } + if (fax->tech->start_session(fax) < 0) { + GENERIC_FAX_EXEC_ERROR(fax, chan, "failed to start FAX session"); + } + + pbx_builtin_setvar_helper(chan, "FAXSTATUS", NULL); + pbx_builtin_setvar_helper(chan, "FAXERROR", NULL); + report_fax_status(chan, details, "FAX Transmission In Progress"); + + ast_debug(5, "channel %s will wait on FAX fd %d\n", chan->name, fax->fd); + + /* handle frames for the session */ + ms = 1000; + while ((ms > -1) && (timeout > 0)) { + struct ast_channel *ready_chan; + int ofd, exception; + + ms = 1000; + errno = 0; + ready_chan = ast_waitfor_nandfds(&c, chancount, &fax->fd, 1, &exception, &ofd, &ms); + if (ready_chan) { + if (!(frame = ast_read(chan))) { + /* the channel is probably gone, so lets stop polling on it and let the + * FAX session complete before we exit the application. if needed, + * send the FAX stack silence so the modems can finish their session without + * any problems */ + ast_log(LOG_NOTICE, "Channel '%s' did not return a frame; probably hung up.\n", chan->name); + c = NULL; + chancount = 0; + timeout -= (1000 - ms); + fax->tech->cancel_session(fax); + if (fax->tech->generate_silence) { + fax->tech->generate_silence(fax); + } + continue; + } + + if ((frame->frametype == AST_FRAME_CONTROL) && + (frame->subclass.integer == AST_CONTROL_T38_PARAMETERS) && + (frame->datalen == sizeof(t38_parameters))) { + unsigned int was_t38 = t38negotiated; + struct ast_control_t38_parameters *parameters = frame->data.ptr; + + switch (parameters->request_response) { + case AST_T38_REQUEST_NEGOTIATE: + /* the other end has requested a switch to T.38, so reply that we are willing, if we can + * do T.38 as well + */ + t38_parameters_fax_to_ast(&t38_parameters, &details->our_t38_parameters); + t38_parameters.request_response = (details->caps & AST_FAX_TECH_T38) ? AST_T38_NEGOTIATED : AST_T38_REFUSED; + ast_indicate_data(chan, AST_CONTROL_T38_PARAMETERS, &t38_parameters, sizeof(t38_parameters)); + break; + case AST_T38_NEGOTIATED: + t38_parameters_ast_to_fax(&details->their_t38_parameters, parameters); + t38negotiated = 1; + break; + default: + break; + } + if (t38negotiated && !was_t38) { + fax->tech->switch_to_t38(fax); + details->caps &= ~AST_FAX_TECH_AUDIO; + expected_frametype = AST_FRAME_MODEM; + expected_framesubclass.codec = AST_MODEM_T38; + if (fax->smoother) { + ast_smoother_free(fax->smoother); + fax->smoother = NULL; + } + + report_fax_status(chan, details, "T.38 Negotiated"); + + ast_verb(3, "Channel '%s' switched to T.38 FAX session '%d'.\n", chan->name, fax->id); + } + } else if ((frame->frametype == expected_frametype) && + (!memcmp(&frame->subclass, &expected_framesubclass, sizeof(frame->subclass)))) { + struct ast_frame *f; + + if (fax->smoother) { + /* push the frame into a smoother */ + if (ast_smoother_feed(fax->smoother, frame) < 0) { + GENERIC_FAX_EXEC_ERROR(fax, chan, "Failed to feed the smoother"); + } + while ((f = ast_smoother_read(fax->smoother)) && (f->data.ptr)) { + if (fax->debug_info) { + debug_check_frame_for_silence(fax, 1, f); + } + /* write the frame to the FAX stack */ + fax->tech->write(fax, f); + fax->frames_received++; + if (f != frame) { + ast_frfree(f); + } + } + } else { + /* write the frame to the FAX stack */ + fax->tech->write(fax, frame); + fax->frames_received++; + } + timeout = RES_FAX_TIMEOUT; + } + ast_frfree(frame); + } else if (ofd == fax->fd) { + /* read a frame from the FAX stack and send it out the channel. + * the FAX stack will return a NULL if the FAX session has already completed */ + if (!(frame = fax->tech->read(fax))) { + break; + } + + if (fax->debug_info && (frame->frametype == AST_FRAME_VOICE)) { + debug_check_frame_for_silence(fax, 0, frame); + } + + ast_write(chan, frame); + fax->frames_sent++; + ast_frfree(frame); + timeout = RES_FAX_TIMEOUT; + } else { + if (ms && (ofd < 0)) { + if ((errno == 0) || (errno == EINTR)) { + timeout -= (1000 - ms); + continue; + } else { + ast_log(LOG_WARNING, "something bad happened while channel '%s' was polling.\n", chan->name); + res = ms; + break; + } + } else { + /* nothing happened */ + if (timeout > 0) { + timeout -= 1000; + continue; + } else { + ast_log(LOG_WARNING, "channel '%s' timed-out during the FAX transmission.\n", chan->name); + GENERIC_FAX_EXEC_ERROR(fax, chan, "fax session timed-out"); + break; + } + } + } + } + ast_debug(3, "channel '%s' - event loop stopped { timeout: %d, ms: %d, res: %d }\n", chan->name, timeout, ms, res); + + pbx_builtin_setvar_helper(chan, "FAXSTATUS", details->result); + pbx_builtin_setvar_helper(chan, "FAXERROR", details->error); + pbx_builtin_setvar_helper(chan, "FAXSTATUSSTRING", details->resultstr); + pbx_builtin_setvar_helper(chan, "REMOTESTATIONID", details->remotestationid); + pbx_builtin_setvar_helper(chan, "FAXBITRATE", details->transfer_rate); + pbx_builtin_setvar_helper(chan, "FAXRESOLUTION", details->resolution); + + snprintf(tbuf, sizeof(tbuf), "%d", details->pages_transferred); + pbx_builtin_setvar_helper(chan, "FAXPAGES", tbuf); + + ast_atomic_fetchadd_int(&faxregistry.fax_complete, 1); + if (!strcasecmp(details->result, "FAILED")) { + ast_atomic_fetchadd_int(&faxregistry.fax_failures, 1); + } + + if (fax) { + ao2_lock(faxregistry.container); + ao2_unlink(faxregistry.container, fax); + ao2_unlock(faxregistry.container); + ao2_ref(fax, -1); + } + + /* if the channel is still alive, and we changed its read/write formats, + * restore them now + */ + if (chancount) { + if (orig_read_format) { + ast_set_read_format(chan, orig_read_format); + } + if (orig_write_format) { + ast_set_write_format(chan, orig_write_format); + } + } + +disable_t38: + if (disable_t38 && + (ast_channel_get_t38_state(chan) == T38_STATE_NEGOTIATED)) { + struct ast_control_t38_parameters t38_parameters = { .request_response = AST_T38_REQUEST_TERMINATE, }; + + if (ast_indicate_data(chan, AST_CONTROL_T38_PARAMETERS, &t38_parameters, sizeof(t38_parameters)) == 0) { + /* wait up to five seconds for negotiation to complete */ + unsigned int timeout = 5000; + int ms; + + ast_debug(1, "Shutting down T.38 on %s\n", chan->name); + while (timeout > 0) { + ms = ast_waitfor(chan, 1000); + if (ms < 0) { + ast_log(LOG_WARNING, "something bad happened while channel '%s' was polling.\n", chan->name); + return -1; + } + if (!ms) { + /* nothing happened */ + if (timeout > 0) { + timeout -= 1000; + continue; + } else { + ast_log(LOG_WARNING, "channel '%s' timed-out during the T.38 shutdown.\n", chan->name); + break; + } + } + if (!(frame = ast_read(chan))) { + return -1; + } + if ((frame->frametype == AST_FRAME_CONTROL) && + (frame->subclass.integer == AST_CONTROL_T38_PARAMETERS) && + (frame->datalen == sizeof(t38_parameters))) { + struct ast_control_t38_parameters *parameters = frame->data.ptr; + + switch (parameters->request_response) { + case AST_T38_TERMINATED: + ast_debug(1, "Shut down T.38 on %s\n", chan->name); + break; + case AST_T38_REFUSED: + ast_log(LOG_WARNING, "channel '%s' refused to disable T.38\n", chan->name); + break; + default: + ast_log(LOG_ERROR, "channel '%s' failed to disable T.38\n", chan->name); + break; + } + ast_frfree(frame); + break; + } + ast_frfree(frame); + } + } + } + + /* return the chancount so the calling function can determine if the channel hungup during this FAX session or not */ + return chancount; +} + +/*! \brief initiate a receive FAX session */ +static int receivefax_exec(struct ast_channel *chan, const char *data) +{ + char *parse; + int channel_alive; + struct ast_fax_session_details *details; + struct ast_fax_document *doc; + AST_DECLARE_APP_ARGS(args, + AST_APP_ARG(filename); + AST_APP_ARG(options); + ); + struct ast_flags opts = { 0, }; + struct manager_event_info info; + + if (ast_strlen_zero(data)) { + ast_log(LOG_WARNING, "%s requires an argument (filename[,options])\n", app_receivefax); + return -1; + } + parse = ast_strdupa(data); + AST_STANDARD_APP_ARGS(args, parse); + + /* initialize output channel variables */ + pbx_builtin_setvar_helper(chan, "FAXSTATUS", "FAILED"); + pbx_builtin_setvar_helper(chan, "FAXERROR", "Application Problems"); + pbx_builtin_setvar_helper(chan, "FAXSTATUSSTRING", "Invalid application arguments."); + pbx_builtin_setvar_helper(chan, "REMOTESTATIONID", NULL); + pbx_builtin_setvar_helper(chan, "FAXPAGES", "0"); + pbx_builtin_setvar_helper(chan, "FAXBITRATE", NULL); + pbx_builtin_setvar_helper(chan, "FAXRESOLUTION", NULL); + + if (!ast_strlen_zero(args.options) && + ast_app_parse_options(fax_exec_options, &opts, NULL, args.options)) { + return -1; + } + if (ast_strlen_zero(args.filename)) { + ast_log(LOG_WARNING, "%s requires an argument (filename[,options])\n", app_receivefax); + return -1; + } + + /* check for unsupported FAX application options */ + if (ast_test_flag(&opts, OPT_CALLERMODE) || ast_test_flag(&opts, OPT_CALLEDMODE)) { + ast_log(LOG_WARNING, "%s does not support polling\n", app_receivefax); + return -1; + } + + /* make sure the channel is up */ + if (chan->_state != AST_STATE_UP) { + if (ast_answer(chan)) { + ast_log(LOG_WARNING, "Channel '%s' failed answer attempt.\n", chan->name); + return -1; + } + } + + ast_atomic_fetchadd_int(&faxregistry.fax_rx_attempts, 1); + + pbx_builtin_setvar_helper(chan, "FAXERROR", "Channel Problems"); + pbx_builtin_setvar_helper(chan, "FAXSTATUSSTRING", "Error before FAX transmission started."); + + /* Get a FAX session details structure from the channel's FAX datastore and create one if + * it does not already exist. */ + if (!(details = find_or_create_details(chan))) { + ast_log(LOG_ERROR, "System cannot provide memory for session requirements.\n"); + return -1; + } + + if (!(doc = ast_calloc(1, sizeof(*doc) + strlen(args.filename) + 1))) { + ast_log(LOG_ERROR, "System cannot provide memory for session requirements.\n"); + ao2_ref(details, -1); + return -1; + } + + strcpy(doc->filename, args.filename); + AST_LIST_INSERT_TAIL(&details->documents, doc, next); + + ast_verb(3, "Channel '%s' receiving FAX '%s'\n", chan->name, args.filename); + + details->caps = AST_FAX_TECH_RECEIVE; + + /* check for debug */ + if (ast_test_flag(&opts, OPT_DEBUG) || global_fax_debug) { + details->option.debug = AST_FAX_OPTFLAG_TRUE; + } + + /* check for request for status events */ + if (ast_test_flag(&opts, OPT_STATUS)) { + details->option.statusevents = AST_FAX_OPTFLAG_TRUE; + } + + if ((ast_channel_get_t38_state(chan) == T38_STATE_UNAVAILABLE) || + ast_test_flag(&opts, OPT_ALLOWAUDIO)) { + details->option.allow_audio = AST_FAX_OPTFLAG_TRUE; + } + + if ((channel_alive = generic_fax_exec(chan, details)) < 0) { + ast_atomic_fetchadd_int(&faxregistry.fax_failures, 1); + } + + /* send out the AMI completion event */ + ast_channel_lock(chan); + + get_manager_event_info(chan, &info); + manager_event(EVENT_FLAG_CALL, + "ReceiveFAX", + "Channel: %s\r\n" + "Context: %s\r\n" + "Exten: %s\r\n" + "CallerID: %s\r\n" + "RemoteStationID: %s\r\n" + "LocalStationID: %s\r\n" + "PagesTransferred: %s\r\n" + "Resolution: %s\r\n" + "TransferRate: %s\r\n" + "FileName: %s\r\n", + chan->name, + info.context, + info.exten, + info.cid, + pbx_builtin_getvar_helper(chan, "REMOTESTATIONID"), + pbx_builtin_getvar_helper(chan, "LOCALSTATIONID"), + pbx_builtin_getvar_helper(chan, "FAXPAGES"), + pbx_builtin_getvar_helper(chan, "FAXRESOLUTION"), + pbx_builtin_getvar_helper(chan, "FAXBITRATE"), + args.filename); + ast_channel_unlock(chan); + + ao2_ref(details, -1); + + /* If the channel hungup return -1; otherwise, return 0 to continue in the dialplan */ + return (!channel_alive) ? -1 : 0; +} + +/*! \brief initiate a send FAX session */ +static int sendfax_exec(struct ast_channel *chan, const char *data) +{ + char *parse; + int channel_alive; + struct ast_fax_session_details *details; + struct ast_fax_document *doc; + AST_DECLARE_APP_ARGS(args, + AST_APP_ARG(filename); + AST_APP_ARG(options); + ); + struct ast_flags opts = { 0, }; + struct manager_event_info info; + + if (ast_strlen_zero(data)) { + ast_log(LOG_WARNING, "%s requires an argument (filename[,options])\n", app_sendfax); + return -1; + } + parse = ast_strdupa(data); + AST_STANDARD_APP_ARGS(args, parse); + + /* initialize output channel variables */ + pbx_builtin_setvar_helper(chan, "FAXSTATUS", "FAILED"); + pbx_builtin_setvar_helper(chan, "FAXERROR", "Application Problems"); + pbx_builtin_setvar_helper(chan, "FAXSTATUSSTRING", "Invalid application arguments."); + pbx_builtin_setvar_helper(chan, "REMOTESTATIONID", NULL); + pbx_builtin_setvar_helper(chan, "FAXPAGES", "0"); + pbx_builtin_setvar_helper(chan, "FAXBITRATE", NULL); + pbx_builtin_setvar_helper(chan, "FAXRESOLUTION", NULL); + + if (!ast_strlen_zero(args.options) && + ast_app_parse_options(fax_exec_options, &opts, NULL, args.options)) { + return -1; + } + if (ast_strlen_zero(args.filename)) { + ast_log(LOG_WARNING, "%s requires an argument (filename[,options])\n", app_sendfax); + return -1; + } + + /* check for unsupported FAX application options */ + if (ast_test_flag(&opts, OPT_CALLERMODE) || ast_test_flag(&opts, OPT_CALLEDMODE)) { + ast_log(LOG_WARNING, "%s does not support polling\n", app_sendfax); + return -1; + } + + if (access(args.filename, (F_OK | R_OK)) < 0) { + ast_log(LOG_ERROR, "access failure. Verify '%s' exists and check permissions.\n", args.filename); + return -1; + } + + /* make sure the channel is up */ + if (chan->_state != AST_STATE_UP) { + if (ast_answer(chan)) { + ast_log(LOG_WARNING, "Channel '%s' failed answer attempt.\n", chan->name); + return -1; + } + } + + ast_atomic_fetchadd_int(&faxregistry.fax_tx_attempts, 1); + + pbx_builtin_setvar_helper(chan, "FAXERROR", "Channel Problems"); + pbx_builtin_setvar_helper(chan, "FAXSTATUSSTRING", "Error before FAX transmission started."); + + /* Get a requirement structure and set it. This structure is used + * to tell the FAX technology module about the higher level FAX session */ + if (!(details = find_or_create_details(chan))) { + ast_log(LOG_ERROR, "System cannot provide memory for session requirements.\n"); + return -1; + } + + if (!(doc = ast_calloc(1, sizeof(*doc) + strlen(args.filename) + 1))) { + ast_log(LOG_ERROR, "System cannot provide memory for session requirements.\n"); + ao2_ref(details, -1); + return -1; + } + + strcpy(doc->filename, args.filename); + AST_LIST_INSERT_TAIL(&details->documents, doc, next); + + ast_verb(3, "Channel '%s' sending FAX '%s'\n", chan->name, args.filename); + + details->caps = AST_FAX_TECH_SEND; + + /* check for debug */ + if (ast_test_flag(&opts, OPT_DEBUG) || global_fax_debug) { + details->option.debug = AST_FAX_OPTFLAG_TRUE; + } + + /* check for request for status events */ + if (ast_test_flag(&opts, OPT_STATUS)) { + details->option.statusevents = AST_FAX_OPTFLAG_TRUE; + } + + if ((ast_channel_get_t38_state(chan) == T38_STATE_UNAVAILABLE) || + ast_test_flag(&opts, OPT_ALLOWAUDIO)) { + details->option.allow_audio = AST_FAX_OPTFLAG_TRUE; + } + + if ((channel_alive = generic_fax_exec(chan, details)) < 0) { + ast_atomic_fetchadd_int(&faxregistry.fax_failures, 1); + } + + /* send out the AMI completion event */ + ast_channel_lock(chan); + get_manager_event_info(chan, &info); + manager_event(EVENT_FLAG_CALL, + "SendFAX", + "Channel: %s\r\n" + "Context: %s\r\n" + "Exten: %s\r\n" + "CallerID: %s\r\n" + "RemoteStationID: %s\r\n" + "LocalStationID: %s\r\n" + "PagesTransferred: %s\r\n" + "Resolution: %s\r\n" + "TransferRate: %s\r\n" + "FileName: %s\r\n", + chan->name, + info.context, + info.exten, + info.cid, + pbx_builtin_getvar_helper(chan, "REMOTESTATIONID"), + pbx_builtin_getvar_helper(chan, "LOCALSTATIONID"), + pbx_builtin_getvar_helper(chan, "FAXPAGES"), + pbx_builtin_getvar_helper(chan, "FAXRESOLUTION"), + pbx_builtin_getvar_helper(chan, "FAXBITRATE"), + args.filename); + ast_channel_unlock(chan); + + ao2_ref(details, -1); + + /* If the channel hungup return -1; otherwise, return 0 to continue in the dialplan */ + return (!channel_alive) ? -1 : 0; +} + +/*! \brief hash callback for ao2 */ +static int session_hash_cb(const void *obj, const int flags) +{ + const struct ast_fax_session *s = obj; + + return s->id; +} + +/*! \brief compare callback for ao2 */ +static int session_cmp_cb(void *obj, void *arg, int flags) +{ + struct ast_fax_session *lhs = obj, *rhs = arg; + + return (lhs->id == rhs->id) ? CMP_MATCH | CMP_STOP : 0; +} + +/*! \brief FAX session tab completion */ +static char *fax_session_tab_complete(struct ast_cli_args *a) +{ + int tklen; + int wordnum = 0; + char *name = NULL; + struct ao2_iterator i; + struct ast_fax_session *s; + char tbuf[5]; + + if (a->pos != 3) { + return NULL; + } + + tklen = strlen(a->word); + i = ao2_iterator_init(faxregistry.container, 0); + while ((s = ao2_iterator_next(&i))) { + snprintf(tbuf, sizeof(tbuf), "%d", s->id); + if (!strncasecmp(a->word, tbuf, tklen) && ++wordnum > a->n) { + name = ast_strdup(tbuf); + ao2_ref(s, -1); + break; + } + ao2_ref(s, -1); + } + if (ao2_iterator_destroy != NULL) { + ao2_iterator_destroy(&i); + } + return name; +} + +/*! \brief enable FAX debugging */ +static char *cli_fax_set_debug(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a) +{ + int flag; + const char *what; + + switch (cmd) { + case CLI_INIT: + e->command = "fax set debug {on|off}"; + e->usage = + "Usage: fax set debug { on | off }\n" + " Enable/Disable FAX debugging on new FAX sessions. The basic FAX debugging will result in\n" + " additional events sent to manager sessions with 'call' class permissions. When\n" + " verbosity is greater than '5' events will be displayed to the console and audio versus\n" + " energy analysis will be performed and displayed to the console.\n"; + return NULL; + case CLI_GENERATE: + return NULL; + } + + what = a->argv[e->args-1]; /* guaranteed to exist */ + if (!strcasecmp(what, "on")) { + flag = 1; + } else if (!strcasecmp(what, "off")) { + flag = 0; + } else { + return CLI_SHOWUSAGE; + } + + global_fax_debug = flag; + ast_cli(a->fd, "\n\nFAX Debug %s\n\n", (flag) ? "Enabled" : "Disabled"); + + return CLI_SUCCESS; +} + +/*! \brief display registered FAX capabilities */ +static char *cli_fax_show_capabilities(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a) +{ + struct fax_module *fax; + unsigned int num_modules = 0; + + switch (cmd) { + case CLI_INIT: + e->command = "fax show capabilities"; + e->usage = + "Usage: fax show capabilities\n" + " Shows the capabilities of the registered FAX technology modules\n"; + return NULL; + case CLI_GENERATE: + return NULL; + } + + ast_cli(a->fd, "\n\nRegistered FAX Technology Modules:\n\n"); + AST_RWLIST_RDLOCK(&faxmodules); + AST_RWLIST_TRAVERSE(&faxmodules, fax, list) { + ast_cli(a->fd, "%-15s : %s\n%-15s : %s\n%-15s : ", "Type", fax->tech->type, "Description", fax->tech->description, "Capabilities"); + fax->tech->cli_show_capabilities(a->fd); + num_modules++; + } + AST_RWLIST_UNLOCK(&faxmodules); + ast_cli(a->fd, "%d registered modules\n\n", num_modules); + + return CLI_SUCCESS; +} + +/*! \brief display details of a specified FAX session */ +static char *cli_fax_show_session(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a) +{ + struct ast_fax_session *s, tmp; + + switch (cmd) { + case CLI_INIT: + e->command = "fax show session"; + e->usage = + "Usage: fax show session \n" + " Shows status of the named FAX session\n"; + return NULL; + case CLI_GENERATE: + return fax_session_tab_complete(a); + } + + if (a->argc != 4) { + return CLI_SHOWUSAGE; + } + + if (sscanf(a->argv[3], "%d", &tmp.id) != 1) { + ast_log(LOG_ERROR, "invalid session id: '%s'\n", a->argv[3]); + return RESULT_SUCCESS; + } + + ast_cli(a->fd, "\nFAX Session Details:\n--------------------\n\n"); + s = ao2_find(faxregistry.container, &tmp, OBJ_POINTER); + if (s) { + s->tech->cli_show_session(s, a->fd); + ao2_ref(s, -1); + } + ast_cli(a->fd, "\n\n"); + + return CLI_SUCCESS; +} + +/*! \brief display fax stats */ +static char *cli_fax_show_stats(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a) +{ + struct fax_module *fax; + + switch (cmd) { + case CLI_INIT: + e->command = "fax show stats"; + e->usage = + "Usage: fax show stats\n" + " Shows a statistical summary of FAX transmissions\n"; + return NULL; + case CLI_GENERATE: + return NULL; + } + + ast_cli(a->fd, "\nFAX Statistics:\n---------------\n\n"); + ast_cli(a->fd, "%-20.20s : %d\n", "Current Sessions", faxregistry.active_sessions); + ast_cli(a->fd, "%-20.20s : %d\n", "Transmit Attempts", faxregistry.fax_tx_attempts); + ast_cli(a->fd, "%-20.20s : %d\n", "Receive Attempts", faxregistry.fax_rx_attempts); + ast_cli(a->fd, "%-20.20s : %d\n", "Completed FAXes", faxregistry.fax_complete); + ast_cli(a->fd, "%-20.20s : %d\n", "Failed FAXes", faxregistry.fax_failures); + AST_RWLIST_RDLOCK(&faxmodules); + AST_RWLIST_TRAVERSE(&faxmodules, fax, list) { + fax->tech->cli_show_stats(a->fd); + } + AST_RWLIST_UNLOCK(&faxmodules); + ast_cli(a->fd, "\n\n"); + + return CLI_SUCCESS; +} + +/*! \brief display fax sessions */ +static char *cli_fax_show_sessions(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a) +{ + struct ast_fax_session *s; + struct ao2_iterator i; + int session_count; + + switch (cmd) { + case CLI_INIT: + e->command = "fax show sessions"; + e->usage = + "Usage: fax show sessions\n" + " Shows the current FAX sessions\n"; + return NULL; + case CLI_GENERATE: + return NULL; + } + + ast_cli(a->fd, "\nCurrent FAX Sessions:\n\n"); + ast_cli(a->fd, "%-20.20s %-10.10s %-10.10s %-10.10s %-15.15s %-30.30s\n", + "Channel", "ID", "Type", "Operation", "State", "File"); + i = ao2_iterator_init(faxregistry.container, 0); + while ((s = ao2_iterator_next(&i))) { + ao2_lock(s); + ast_cli(a->fd, "%-20.20s %-10d %-10.10s %-10.10s %-15.15s %-30.30s\n", + s->channame, s->id, s->tech->type, (s->details->caps & AST_FAX_TECH_SEND) ? "send" : "receive", + ast_fax_state_to_str(s->state), AST_LIST_FIRST(&s->details->documents)->filename); + ao2_unlock(s); + ao2_ref(s, -1); + } + if (ao2_iterator_destroy != NULL) { + ao2_iterator_destroy(&i); + } + session_count = ao2_container_count(faxregistry.container); + ast_cli(a->fd, "\n%d FAX sessions\n\n", session_count); + + return CLI_SUCCESS; +} + +static struct ast_cli_entry fax_cli[] = { + AST_CLI_DEFINE(cli_fax_set_debug, "Enable/Disable FAX debugging on new FAX sessions"), + AST_CLI_DEFINE(cli_fax_show_capabilities, "Show the capabilities of the registered FAX technology modules"), + AST_CLI_DEFINE(cli_fax_show_session, "Show the status of the named FAX sessions"), + AST_CLI_DEFINE(cli_fax_show_sessions, "Show the current FAX sessions"), + AST_CLI_DEFINE(cli_fax_show_stats, "Summarize FAX session history"), +}; + +/*! \brief configure res_fax */ +static int set_config(const char *config_file) +{ + struct ast_config *cfg; + struct ast_variable *v; + struct ast_flags config_flags = { 0 }; + + /* set defaults */ + general_options.minrate = RES_FAX_MINRATE; + general_options.maxrate = RES_FAX_MAXRATE; + general_options.statusevents = RES_FAX_STATUSEVENTS; + general_options.modems = RES_FAX_MODEM; + + /* read configuration */ + if (!(cfg = ast_config_load2(config_file, "res_fax", config_flags))) { + ast_log(LOG_NOTICE, "Configuration file '%s' not found, using default options.\n", config_file); + return 0; + } + if (cfg == CONFIG_STATUS_FILEUNCHANGED) { + ast_clear_flag(&config_flags, CONFIG_FLAG_FILEUNCHANGED); + cfg = ast_config_load2(config_file, "res_fax", config_flags); + } + + /* create configuration */ + for (v = ast_variable_browse(cfg, "general"); v; v = v->next) { + int rate; + + if (!strcasecmp(v->name, "minrate")) { + ast_debug(3, "reading minrate '%s' from configuration file\n", v->value); + if ((rate = fax_rate_str_to_int(v->value)) == -1) { + ast_config_destroy(cfg); + return -1; + } + general_options.minrate = rate; + } else if (!strcasecmp(v->name, "maxrate")) { + ast_debug(3, "reading maxrate '%s' from configuration file\n", v->value); + if ((rate = fax_rate_str_to_int(v->value)) == -1) { + ast_config_destroy(cfg); + return -1; + } + general_options.maxrate = rate; + } else if (!strcasecmp(v->name, "statusevents")) { + ast_debug(3, "reading statusevents '%s' from configuration file\n", v->value); + general_options.statusevents = ast_true(v->value); + } else if ((!strcasecmp(v->name, "modem")) || (!strcasecmp(v->name, "modems"))) { + general_options.modems = 0; + update_modem_bits(&general_options.modems, v->value); + } + } + + ast_config_destroy(cfg); + + return 0; +} + +/*! \brief FAXOPT read function returns the contents of a FAX option */ +static int acf_faxopt_read(struct ast_channel *chan, const char *cmd, char *data, char *buf, size_t len) +{ + struct ast_fax_session_details *details = find_details(chan); + int res = 0; + + if (!details) { + ast_log(LOG_ERROR, "channel '%s' can't read FAXOPT(%s) because it has never been written.\n", chan->name, data); + return -1; + } + if (!strcasecmp(data, "ecm")) { + ast_copy_string(buf, details->option.ecm ? "yes" : "no", len); + } else if (!strcasecmp(data, "error")) { + ast_copy_string(buf, details->error, len); + } else if (!strcasecmp(data, "filename")) { + ast_copy_string(buf, AST_LIST_FIRST(&details->documents)->filename, len); + } else if (!strcasecmp(data, "headerinfo")) { + ast_copy_string(buf, details->headerinfo, len); + } else if (!strcasecmp(data, "localstationid")) { + ast_copy_string(buf, details->localstationid, len); + } else if (!strcasecmp(data, "maxrate")) { + snprintf(buf, len, "%d", details->maxrate); + } else if (!strcasecmp(data, "minrate")) { + snprintf(buf, len, "%d", details->minrate); + } else if (!strcasecmp(data, "pages")) { + snprintf(buf, len, "%d", details->pages_transferred); + } else if (!strcasecmp(data, "rate")) { + ast_copy_string(buf, details->transfer_rate, len); + } else if (!strcasecmp(data, "remotestationid")) { + ast_copy_string(buf, details->remotestationid, len); + } else if (!strcasecmp(data, "resolution")) { + ast_copy_string(buf, details->resolution, len); + } else if (!strcasecmp(data, "sessionid")) { + snprintf(buf, len, "%d", details->id); + } else if (!strcasecmp(data, "status")) { + ast_copy_string(buf, details->result, len); + } else if (!strcasecmp(data, "statusstr")) { + ast_copy_string(buf, details->resultstr, len); + } else if ((!strcasecmp(data, "modem")) || (!strcasecmp(data, "modems"))) { + ast_fax_modem_to_str(details->modems, buf, len); + } else { + ast_log(LOG_WARNING, "channel '%s' can't read FAXOPT(%s) because it is unhandled!\n", chan->name, data); + res = -1; + } + ao2_ref(details, -1); + + return res; +} + +/*! \brief FAXOPT write function modifies the contents of a FAX option */ +static int acf_faxopt_write(struct ast_channel *chan, const char *cmd, char *data, const char *value) +{ + int res = 0; + struct ast_fax_session_details *details; + + if (!(details = find_or_create_details(chan))) { + ast_log(LOG_WARNING, "channel '%s' can't set FAXOPT(%s) to '%s' because it failed to create a datastore.\n", chan->name, data, value); + return -1; + } + ast_debug(3, "channel '%s' setting FAXOPT(%s) to '%s'\n", chan->name, data, value); + + if (!strcasecmp(data, "ecm")) { + details->option.ecm = ast_true(value) ? 1 : 0; + } else if (!strcasecmp(data, "headerinfo")) { + ast_string_field_set(details, headerinfo, value); + } else if (!strcasecmp(data, "localstationid")) { + ast_string_field_set(details, localstationid, value); + } else if (!strcasecmp(data, "maxrate")) { + details->maxrate = fax_rate_str_to_int(value); + } else if (!strcasecmp(data, "minrate")) { + details->minrate = fax_rate_str_to_int(value); + } else if ((!strcasecmp(data, "modem")) || (!strcasecmp(data, "modems"))) { + update_modem_bits(&details->modems, value); + } else { + ast_log(LOG_WARNING, "channel '%s' set FAXOPT(%s) to '%s' is unhandled!\n", chan->name, data, value); + res = -1; + } + + ao2_ref(details, -1); + + return res; +} + +/*! \brief FAXOPT dialplan function */ +struct ast_custom_function acf_faxopt = { + .name = "FAXOPT", + .synopsis = "Set options for use with the SendFAX and ReceiveFAX functions, or read options after a FAX transmission completes", + .syntax = +"FAXOPT(