asterisk概述和代码分析
很久以前整理的，引用了多人的资料，难以一一记起，再次表示感谢！
目录
- asterisk概述和结构分析
- 1 Asterisk项目概述
- 2 Asterisk二次开发概述
- 3 Asterisk通道模型与呼叫流程
- 3.1什么是asterisk通道？
- 3.2基本的呼叫流程
- 3.3详细呼叫流程分析
1 Asterisk项目概述
Asterisk是一个开源的软件包，通常运行在Linux操作系统平台上。Asterisk可以用三种协议来实现VoIP，同时可以与目前电话使用的标准硬件进行交互通信，Asterisk在实现VoIP时，不需要任何附加硬件，本文所采用的也是这种使用方式。但是，如果企业没有与VoIP语音网关运营商建立合作关系，想要自己构建这样的一个平台，那么要和数字电话设备与模拟电话设备进行交互通信，Asterisk需要一个PCI硬件的支持，这个硬件生产商中最著名的是Digium平台提供的。
Asterisk 的结构基本上是十分简单，但是它不同于大多数的电话产品。基本上，Asterisk担任的是一个中间件的功能，它连接了底层的电话技术和上层的电话应用。所以，Asterisk 具有很大的柔韧性，特殊的API接口都围绕着PBX核心系统。这个核心处理着PBX内部之间的相互联系。每一部分都是清晰来自于协议、编码或内部电话使用的硬件接口的抽象。这些抽象的接口使Asterisk可以与任何的硬件和技术以及将来的硬件和软件技术完美的结合。从下图可以看出，Asterisk由内部核心和外围动态可加载模块组成。内部核心由以下六个部分组成：PBX交换核心模块(PBX Switching Core)、调度和I/O管理模块(Scheduler and I/O Manager)、应用调用模块(Application Launcher)、编解码转换模块(Codec Translator)、动态模块加载器模块(Dynamic Module Loader)和CDR生成模块(CDR Core) 。
2 Asterisk二次开发概述
Asterisk是一个开源的PBX架构；但它并不是一个成品。通常情况下，由于企业应用的多样性，很难有一个成型的PBX产品可以满足企业的各种需求。传统的PBX成品，要么功能和灵活性不足，要么配置和维护复杂；而且都具有一个致命的缺点，那就是开放性、可扩展性。
Asterisk具有传统PBX无法比拟的优点，那就是其灵活性，可扩展能力；Asterisk的扩展能力是通过开放相应的架构和接口来实现的。这就意味着Asterisk是一个组件而不是一个成型的产品，Asterisk的核心提供了一个基本的可运行环境，而外围相应的能力则可以通过加载和配置相关的插件和模块来实现。
Asterisk是一个开源的PBX架构；但它并不是一个成品。Asterisk的扩展能力是通过开放相应的架构和接口来实现的。这就意味着Asterisk是一个组件而不是一个成型的产品，Asterisk的核心提供了一个基本的可运行环境，而外围相应的能力则可以通过加载和配置相关的插件和模块来实现。
因此，使用Asterisk，一定会面临二次开发问题，这些二次开发主要围绕以下几个方面：
（1）内部核心模块
①开发扩展编解码能力模块
②开发扩展相应的通道模块
（2）外围动态可加载模块
①开发应用部分
②开发外围管理部分
一般来说，Asterisk使用者很少需要去开发编解码能力模块和通道模块等内部核心模块；而需要开发最多的情况则是外围动态可加载模块，即外围管理部分和应用开发，本文也是指这些方面的开发。
3 Asterisk通道模型与呼叫流程
3.1什么是asterisk通道？
Asterisk通道是指通过asterisk建立起来的一路通话。这类通话都包含一个incoming连接和一个outbound连接。每个电话都是通过一种通道驱动程序建立起来的，比如SIP,ZAP,IAX2等等。每一类的通道驱动，都拥有自己私有的通道数据结构，这些私有的结构从属于一个通用的Asterisk通道数据结构中，具体定义在channel.h和channel.c中。
3.2基本的呼叫流程
Asterisk PBX呼叫流程如图2所示。
（1）通过Asterisk的一个电话呼叫在一个通道驱动接口上到达，如SIP Socket。
（2）通道驱动在该通道上创建一个PBX通道并启动一个pbx线程
（3）拨号方案被执行，拨号方案在一些地方通过dial应用(查看app_dial.c)
强制Asterisk创建一个呼出呼叫，一旦呼出，Asterisk会有以下两个动作将发生。
（1）Dial创建一个呼出的PBX通道并请求一种通道驱动创建一个呼叫
（2）当呼叫被应答时，Asterisk桥接媒体流，于是在第一个通道上的主叫可以和在第
二个通道也就是呼出通道上的被叫通话。
3.3详细呼叫流程分析
我们以sip的呼叫过程为例来描述，其他channel的呼叫过程基本类似。
Astersik下注册的sip用户主动发起一个呼叫的函数调用过程如下：
do_monitor->sipsock_read->handle_request->handle_request_invite->sip_new/ast_pbx_start->pbx_thread->__ast_pbx_run
-> ast_spawn_extension ->pbx_extension_helper->pbx_exec->执行dialplan
当Chan_sip模块被加载时，会启动一个独立的监听线程do_monitor，不断侦听sip端口上的外部消息；
当sip用户拨叫被叫号码后，chan_sip的do_monitor调用sipsock_read函数，在sip端口收到invite消息，然后就调用handle_request和handle_request_invite进行处理。
static void *do_monitor(void *data) { int res; struct sip_pvt *sip; struct sip_peer *peer = NULL; time_t t; int fastrestart = FALSE; int lastpeernum = -1; int curpeernum; int reloading; /* Add an I/O event to our SIP UDP socket */ if (sipsock > -1) /*io.c实现了asterisk跟外部交互时的I/O管理，如chan_sip为了从外部接收SIP信令，调用ast_io_add添加IO接口，并调用ast_io_wait实现外部消息接收。*/ sipsock_read_id =ast_io_add(io, sipsock,sipsock_read,AST_IO_IN, NULL); 。。。 } static int sipsock_read(int *id, int fd, short events, void *ignore) { /*当sip用户拨叫被叫号码后，chan_sip的do_monitor调用sipsock_read函数，在sip端口收到invite消息，然后就调用handle_request和handle_request_invite进行处理。*/ if (handle_request(p, &req, &sin, &recount, &nounlock) == -1) { /* Request failed */ if (option_debug) ast_log(LOG_DEBUG, "SIP message could not be handled, bad request: %-70.70s\n", p->callid[0] ? p->callid : ""); } 在 static int handle_request(struct sip_pvt *p, struct sip_request *req, struct sockaddr_in *sin, int *recount, int *nounlock) { 。。。 switch (p->method) { case SIP_OPTIONS: res = handle_request_options(p, req); break; case SIP_INVITE: res = handle_request_invite(p, req, debug, seqno, sin, recount, e, nounlock); break; case SIP_REFER: res = handle_request_refer(p, req, debug, ignore, seqno, nounlock); break; 。。。 }
在handle_request_invite中，首先解析invite消息，对该sip用户的业务属性分析，确认被叫可达，然后就调用sip_new申请channel资源：
static int handle_request_invite(struct sip_pvt *p, struct sip_request *req, int debug, int seqno, struct sockaddr_in *sin, int *recount, char *e, int *nounlock) { … /* Don't hold a sip pvt lock while we allocate a channel */ /*ast_channel_alloc定义在channel.c中，每个呼叫都会调用ast_channel_alloc来申请ast_channel*/ tmp = ast_channel_alloc(1, state, i->cid_num, i->cid_name, i->accountcode, i->exten, i->context, i->amaflags, "SIP/%s-%08x", my_name, (int)(long) i); } if (!tmp) { ast_log(LOG_WARNING, "Unable to allocate AST channel structure for SIP channel\n"); ast_mutex_lock(&i->lock); return NULL; } ast_mutex_lock(&i->lock); if (ast_test_flag(&i->flags[0], SIP_DTMF) == SIP_DTMF_INFO) /*Channel.c/channel.h定义了channel操作的结构体和接口函数。 struct ast_channel_tech结构体是所有channel都要用到的关键结构体，它定义channel操作的一系列回调函数指针，如call、hangup、answer等。每个channel模块都会定义ast_channel_tech的实体，并将各自的回调函数赋值给它。*/ tmp->tech = &sip_tech_info; else tmp->tech = &sip_tech; (struct ast_channel结构体定义了channel的上下文参数，它是每个参与呼叫的channel必不可少的，都会调用ast_channel_alloc来申请) /*channel.h*/ struct ast_channel { /*! \brief Technology (point to channel driver) */ const struct ast_channel_tech *tech; … }
里面ast_channel_tech应该是最主要的一个结构体，定义呼叫流程中标准的过程有那些，在具体的chan_**文件中各协议注册自己对应这些过程的回调函数
/*channel.h*/ /*! \brief Structure to describe a channel "technology", ie a channel driver See for examples: \arg chan_iax2.c - The Inter-Asterisk exchange protocol \arg chan_sip.c - The SIP channel driver \arg chan_zap.c - PSTN connectivity (TDM, PRI, T1/E1, FXO, FXS) If you develop your own channel driver, this is where you tell the PBX at registration of your driver what properties this driver supports and where different callbacks are implemented. */ struct ast_channel_tech { const char * const type; const char * const description; int capabilities; /*!< Bitmap of formats this channel can handle */ int properties; /*!< Technology Properties */ /*! \brief Requester - to set up call data structures (pvt's) */ struct ast_channel *(* const requester)(const char *type, int format, void *data, int *cause); int (* const devicestate)(void *data); /*!< Devicestate call back */ /*! \brief Start sending a literal DTMF digit 开始传送DTMF数据*/ int (* const send_digit_begin)(struct ast_channel *chan, char digit); /*! \brief Stop sending a literal DTMF digit 停止传送DTMF数据*/ int (* const send_digit_end)(struct ast_channel *chan, char digit, unsigned int duration); /*! \brief Call a given phone number (address, etc), but don't take longer than timeout seconds to do so. */ int (* const call)(struct ast_channel *chan, char *addr, int timeout); /*! \brief Hangup (and possibly destroy) the channel 挂断通道*/ int (* const hangup)(struct ast_channel *chan); /*! \brief Answer the channel 响应通道*/ int (* const answer)(struct ast_channel *chan); /*! \brief Read a frame, in standard format (see frame.h) 以标准祯格式读一个祯*/ struct ast_frame * (* const read)(struct ast_channel *chan); /*! \brief Write a frame, in standard format (see frame.h) 以标准祯格式写一个祯*/ int (* const write)(struct ast_channel *chan, struct ast_frame *frame); /*! \brief Display or transmit text 显示或发送文本*/ int (* const send_text)(struct ast_channel *chan, const char *text); /*! \brief Display or send an image 显示或发送图片*/ int (* const send_image)(struct ast_channel *chan, struct ast_frame *frame); /*! \brief Send HTML data 发送HTML数据*/ int (* const send_html)(struct ast_channel *chan, int subclass, const char *data, int len); /*! \brief Handle an exception, reading a frame 处理读取祯时发生的异常*/ struct ast_frame * (* const exception)(struct ast_channel *chan); /*! \brief Bridge two channels of the same type together 桥接两种相同类型的通道*/ enum ast_bridge_result (* const bridge)(struct ast_channel *c0, struct ast_channel *c1, int flags, struct ast_frame **fo, struct ast_channel **rc, int timeoutms); /*! \brief Indicate a particular condition (e.g. AST_CONTROL_BUSY or AST_CONTROL_RINGING or AST_CONTROL_CONGESTION 指示一种特殊的状况如sip的486error*/ int (* const indicate)(struct ast_channel *c, int condition, const void *data, size_t datalen); /*! \brief Fix up a channel: If a channel is consumed, this is called. Basically update any ->owner links */ int (* const fixup)(struct ast_channel *oldchan, struct ast_channel *newchan); /*! \brief Set a given option */ int (* const setoption)(struct ast_channel *chan, int option, void *data, int datalen); /*! \brief Query a given option */ int (* const queryoption)(struct ast_channel *chan, int option, void *data, int *datalen); /*! \brief Blind transfer other side (see app_transfer.c and ast_transfer() */ int (* const transfer)(struct ast_channel *chan, const char *newdest); /*! \brief Write a frame, in standard format */ int (* const write_video)(struct ast_channel *chan, struct ast_frame *frame); /*! \brief Find bridged channel 查询已经找到的通道*/ struct ast_channel *(* const bridged_channel)(struct ast_channel *chan, struct ast_channel *bridge); /*! \brief Provide additional read items for CHANNEL() dialplan function */ int (* func_channel_read)(struct ast_channel *chan, char *function, char *data, char *buf, size_t len); /*! \brief Provide additional write items for CHANNEL() dialplan function */ int (* func_channel_write)(struct ast_channel *chan, char *function, char *data, const char *value); /*! \brief Retrieve base channel (agent and local) */ struct ast_channel* (* get_base_channel)(struct ast_channel *chan); /*! \brief Set base channel (agent and local) */ int (* set_base_channel)(struct ast_channel *chan, struct ast_channel *base); };
如在chan_sip.c文件中实现如下：
/*! \brief Definition of this channel for PBX channel registration */ static const struct ast_channel_tech sip_tech = { .type = "SIP", .description = "Session Initiation Protocol (SIP)", .capabilities = ((AST_FORMAT_MAX_AUDIO << 1) - 1), .properties = AST_CHAN_TP_WANTSJITTER | AST_CHAN_TP_CREATESJITTER, .requester = sip_request_call, .devicestate = sip_devicestate, .call = sip_call, .hangup = sip_hangup, .answer = sip_answer, .read = sip_read, .write = sip_write, .write_video = sip_write, .indicate = sip_indicate, .transfer = sip_transfer, .fixup = sip_fixup, .send_digit_begin = sip_senddigit_begin, .send_digit_end = sip_senddigit_end, .bridge = ast_rtp_bridge, .send_text = sip_sendtext, .func_channel_read = acf_channel_read, };
并调用ast_pbx_start函数启动一个pbx_thread线程来专门处理该呼叫。
static struct ast_channel *sip_new(struct sip_pvt *i, int state, const char *title) { … tmp = ast_channel_alloc(… … /*ast_pbx_start函数启动一个pbx_thread线程来专门处理该呼叫*/ if (state != AST_STATE_DOWN &&ast_pbx_start(tmp)) { ast_log(LOG_WARNING, "Unable to start PBX on %s\n", tmp->name); tmp->hangupcause = AST_CAUSE_SWITCH_CONGESTION; ast_hangup(tmp); tmp = NULL; } … } enum ast_pbx_result ast_pbx_start(struct ast_channel *c) { pthread_t t; pthread_attr_t attr; if (!c) { ast_log(LOG_WARNING, "Asked to start thread on NULL channel?\n"); return AST_PBX_FAILED; } if (increase_call_count(c)) return AST_PBX_CALL_LIMIT; /* Start a new thread, and get something handling this channel. */ pthread_attr_init(&attr); pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED); if (ast_pthread_create(&t, &attr,pbx_thread, c)) { ast_log(LOG_WARNING, "Failed to create new channel thread\n"); pthread_attr_destroy(&attr); return AST_PBX_FAILED; } pthread_attr_destroy(&attr); return AST_PBX_SUCCESS; }
pbx_thread线程调用__ast_pbx_run。
static void *pbx_thread(void *data) { /* Oh joyeous kernel, we're a new thread, with nothing to do but answer this channel and get it going. */ /* NOTE: The launcher of this function _MUST_ increment 'countcalls' before invoking the function; it will be decremented when the PBX has finished running on the channel */ struct ast_channel *c = data; __ast_pbx_run(c); decrease_call_count(); pthread_exit(NULL); return NULL; }
__ast_pbx_run是一个衔接dialplan和内核的关键函数，它首先调用ast_exists_extension函数，根据分机号码的context属性，匹配到对应的dialplan；然后进入一个for死循环，逐条执行dialplan对应的context中的语句。
pbx_extension_helper函数调用pbx_extension_helper，在pbx_extension_helper中调用pbx_find_extension找到对应的context后，通过verbose打印dialplan执行语句“Executing ……”，同时调用pbx_exec执行该dialplan。执行到dial语句呼叫被叫。
static int __ast_pbx_run(struct ast_channel *c) { … while (ast_exists_extension(c, c->context, c->exten, c->priority, c->cid.cid_num)) { … } int ast_exists_extension(struct ast_channel *c, const char *context, const char *exten, int priority, const char *callerid) { returnpbx_extension_helper(c, NULL, context, exten, priority, NULL, callerid, E_MATCH); } /*! * \brief The return value depends on the action: * * E_MATCH, E_CANMATCH, E_MATCHMORE require a real match, * and return 0 on failure, -1 on match; * E_FINDLABEL maps the label to a priority, and returns * the priority on success, ... XXX * E_SPAWN, spawn an application, * and return 0 on success, -1 on failure. * * \note The channel is auto-serviced in this function, because doing an extension * match may block for a long time. For example, if the lookup has to use a network * dialplan switch, such as DUNDi or IAX2, it may take a while. However, the channel * auto-service code will queue up any important signalling frames to be processed * after this is done. */ static int pbx_extension_helper(struct ast_channel *c, struct ast_context *con, const char *context, const char *exten, int priority, const char *label, const char *callerid, enum ext_match_t action) { … ast_rdlock_contexts(); e =pbx_find_extension(c, con, &q, context, exten, priority, label, callerid, action); if (e) { if (matching_action) { ast_unlock_contexts(); return -1; /* success, we found it */ } else if (action == E_FINDLABEL) { /* map the label to a priority */ res = e->priority; ast_unlock_contexts(); return res; /* the priority we were looking for */ } else { /* spawn */ app = pbx_findapp(e->app); ast_unlock_contexts(); if (!app) { ast_log(LOG_WARNING, "No application '%s' for extension (%s, %s, %d)\n", e->app, context, exten, priority); return -1; } if (c->context != context) ast_copy_string(c->context, context, sizeof(c->context)); if (c->exten != exten) ast_copy_string(c->exten, exten, sizeof(c->exten)); c->priority = priority; '''/*passdata应该是在此赋值*/''' pbx_substitute_variables(passdata, sizeof(passdata), c, e); if (option_debug) { ast_log(LOG_DEBUG, "Launching '%s'\n", app->name); } if (option_verbose > 2) { char tmp[80], tmp2[80], tmp3[EXT_DATA_SIZE]; ast_verbose( VERBOSE_PREFIX_3 "Executing [%s@%s:%d] %s(\"%s\", \"%s\") %s\n", exten, context, priority, term_color(tmp, app->name, COLOR_BRCYAN, 0, sizeof(tmp)), term_color(tmp2, c->name, COLOR_BRMAGENTA, 0, sizeof(tmp2)), term_color(tmp3, passdata, COLOR_BRMAGENTA, 0, sizeof(tmp3)), "in new stack"); } /* 管理事件 */ manager_event(EVENT_FLAG_CALL, "Newexten", "Channel: %s\r\n" "Context: %s\r\n" "Extension: %s\r\n" "Priority: %d\r\n" "Application: %s\r\n" "AppData: %s\r\n" "Uniqueid: %s\r\n", c->name, c->context, c->exten, c->priority, app->name, passdata, c->uniqueid); returnpbx_exec(c, app, passdata); /* 0 on success, -1 on failure */ … }
Pbx_exec函数体为：
/* \note This function is special. It saves the stack so that no matter how many times it is called, it returns to the same place */ int pbx_exec(struct ast_channel *c, /*!< Channel */ struct ast_app *app, /*!< Application */ void *data) /*!< Data for execution */ { int res; const char *saved_c_appl; const char *saved_c_data; if (c->cdr && !ast_check_hangup(c)) ast_cdr_setapp(c->cdr, app->name, data); /* save channel values */ saved_c_appl= c->appl; saved_c_data= c->data; c->appl = app->name; c->data = data; /* XXX remember what to to when we have linked apps to modules */ if (app->module) { /* XXX LOCAL_USER_ADD(app->module) */ } /*应该是在此执行了应用*/ res = app->execute(c, S_OR(data, "")); if (app->module) { /* XXX LOCAL_USER_REMOVE(app->module) */ } /* restore channel values */ c->appl = saved_c_appl; c->data = saved_c_data; return res; }
在等待被叫接通的过程中，完成媒体协商过程，向主叫发送180、200OK消息接通呼叫。
当其他用户呼叫asterisk的sip用户时，函数调用过程如下：Dial->dial_exec->dial_exec_full->ast_request/ast_call/wait_for_answer/ ast_bridge_call
呼叫执行到dial时，pbx_exec调用application dial的接口函数dial_exec，dial_exec调用dial_exec_full。
static int load_module(void) { int res; res = ast_register_application(app, dial_exec, synopsis, descrip); res |= ast_register_application(rapp, retrydial_exec, rsynopsis, rdescrip); return res; } static int dial_exec(struct ast_channel *chan, void *data) { struct ast_flags peerflags; memset(&peerflags, 0, sizeof(peerflags)); return dial_exec_full(chan, data, &peerflags, NULL); } static int dial_exec_full(struct ast_channel *chan, void *data, struct ast_flags *peerflags, int *continue_exec) { 。。。 if (!(c =chan->tech->requester(type, capabilities | videoformat, data, cause))) return NULL; 。。。 }
chan->tech->requester在chan_sip.c中的ast_channel_tech实体中即为.requester = sip_request_call
在dial_exec_full中，首先调用ast_request，在ast_request调用chan_sip对应的回调函数sip_request_call为该被叫sip用户申请channel资源。然后调用ast_call，在ast_call中调用chan_sip对应的回调函数sip_call向被叫发送INVITE消息，呼叫被叫SIP用户。
static struct ast_channel *sip_request_call(const char *type, int format, void *data, int *cause) { … /*申请资源*/ if (!(p = sip_alloc(NULL, NULL, 0, SIP_INVITE))) { ast_log(LOG_ERROR, "Unable to build sip pvt data for '%s' (Out of memory or socket error)\n", (char *)data); *cause = AST_CAUSE_SWITCH_CONGESTION; return NULL; } …
然后该呼叫线程会调用wait_for_answer等待被叫接通。
在呼叫接通后，也即wait_for_answer函数返回，在dial_exec_full中调用ast_bridge_call桥接媒体，这样呼叫就正式接通了。
当chan_sip的侦听线程接收到BYE消息，则调用handle_request_bye找到相应的channel，执行hangup释放呼叫。
if (!ast_strlen_zero(get_header(req, "Also"))) { ast_log(LOG_NOTICE, "Client '%s' using deprecated BYE/Also transfer method. Ask vendor to support REFER instead\n", ast_inet_ntoa(p->recv.sin_addr)); if (ast_strlen_zero(p->context)) ast_string_field_set(p, context, default_context); res = get_also_info(p, req); if (!res) { c = p->owner; if (c) { bridged_to = ast_bridged_channel(c); if (bridged_to) { /* Don't actually hangup here... */ ast_queue_control(c, AST_CONTROL_UNHOLD); ast_async_goto(bridged_to, p->context, p->refer->refer_to,1); } else ast_queue_hangup(p->owner); } } else { ast_log(LOG_WARNING, "Invalid transfer information from '%s'\n", ast_inet_ntoa(p->recv.sin_addr)); if (p->owner) ast_queue_hangup(p->owner); } } else if (p->owner) { ast_queue_hangup(p->owner); ... }