Asterisk内核框架

原帖：http://www.cppblog.com/eyesmart/archive/2009/09/03/95219.aspx

 Asterisk是一个开源的pbx系统，在公开的资料中，很难找到asterisk内核系统的详细描述。因此，很有必要写一篇内核框架的描述文档，作为内部培训文档，相互学习提高。

本文主要从三个层面来描述asterisk内核，即asterisk内核模块、内核启动过程、基本呼叫流程。

一、asterisk内核模块

Asterisk由内部核心和外围动态可加载模块组成。内部核心由以下六个部分组成：PBX交换核心模块(PBX Switching Core)、调度和I/O管理模块(Scheduler and I/O Manager)、应用调用模块(Application Launcher)、编解码转换模块(Codec Translator)、动态模块加载器模块(Dynamic Module Loader)和CDR生成模块(CDR Core)。

外围动态可加载模块包括以App_开始的Applications、以Func_开始的Functions、以Res_开始的Resources、以Chan_开始的channels、以Codec_开始的codec编解码模块等。

1.内核模块

1) PBX交换核心模块(PBX Switching Core)：

l  pbx.c

pbx.c是asterisk的核心模块，每路呼叫都需要经过它调度。pbx实现了builtin applications，也就是内置的应用，比如最常见的Answer,Hangup, Background,Wait等等。

struct ast_app是一个关键数据结构，它定义了注册builtin applications的结构。

load_pbx函数用来注册builtin applications和一些命令行CLI命令（每个模块都有些CLI命令）。该函数在系统启动时被调用。

pbx_exec是Answer/BackGround/Busy/Goto/GotoIf/Hangup/Set等builtin applications的执行入口函数，它被pbx_extension_helper调用。

ast_pbx_start函数是每路呼叫的起点。

2) 调度和I/O管理模块(Scheduler and I/O Manager)：

l         Channel.c:

Channel.c/channel.h定义了channel操作的结构体和接口函数。

struct ast_channel_tech结构体是所有channel都要用到的关键结构体，它定义channel操作的一系列回调函数指针，如call、 hangup、answer等。每个channel模块都会定义ast_channel_tech的实体，并将各自的回调函数赋值给它。例如 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_call、ast_hangup、ast_answer等函数分别实现ast_channel_tech中的call、hangup、answer等回调函数的调用。

struct ast_channel结构体定义了channel的上下文参数，它是每个参与呼叫的channel必不可少的，都会调用ast_channel_alloc来申请ast_channel。

l io.c

io.c实现了asterisk跟外部交互时的I/O管理，如chan_sip为了从外部接收SIP信令，调用ast_io_add添加IO接口，并调用ast_io_wait实现外部消息接收。

3)应用调用模块(Application Launcher)：

在pbx.c中定义了一系列的应用调用接口。

applications模块定义了application回调函数并注册后，在pbx.c中通过应用调用接口回调执行。

应用调用接口的关键函数是pbx_extension_helper，它执行dialplan，在cli上打印“Executing ……”,并抛出ami event事件，同时调用pbx_exec执行application回调函数。

4) 编解码转换模块(Codec Translator)：

Translate.c:

struct ast_translator：编码转换描述结构体，它定义了编码转换的名称、回调函数、运行时选项。

struct ast_trans_pvt：编码转换上下文描述结构体。

ast_register_translator：编码转换注册接口函数，供各编码模块调用，注册struct ast_translator类型的结构体变量。

ast_unregister_translator：编码转换注销函数

ast_translate：编码转换的执行函数。

codec_gsm.c/codec_...：对应各种编码的编解码执行模块，如g.711alaw/g.711ulaw/gsm等。

5)动态模块加载器模块(Dynamic Module Loader)：

该模块主要是Module.h。

Module.h中定义了struct ast_module_info结构，用来保存各模块的注册、注销回调函数，以及模块描述信息。

load_module、unload_module，每个应用模块的注册、注销函数，由各个模块自行定义为static函数。

AST_MODULE_INFO_STANDARD：注册接口、注销接口、模块描述信息等模块信息的登记接口。它是一个宏定义，动态模块调用它时，首先定义类型为ast_module_info的__mod_info静态结构变量，保存模块信息，并定义__attribute__ ((constructor)) __reg_module和__attribute__ ((destructor)) __unreg_module，在程序启动和退出时调用。

6)CDR生成模块(CDR Core)：

Cdr.c:

ast_cdr_register：cdr driver注册，供cdr_mysql等调用，注册话单保存的回调函数。

ast_cdr_engine_init：CDR模块初始化，注册cdr status、加载cdr.conf、启动CDR线程。

ast_cdr_detach：产生话单的接口函数，呼叫结束时被调用。

2.外围可加载模块：

1)Applications

以app_开始的模块，如app_dial.c、app_db.c、app_queue.c、app_record.c、app_meetme.c 等，代码保存在apps目录中。每个application模块都定义了load_module函数和unload_module函数，分别用来注册和注销application。

load_module函数调用ast_register_application函数，注册application命令，例如app_dial模块注册Dial：res = ast_register_application(app, dial_exec, synopsis, descrip)。

unload_module函数调用ast_unregister_application函数，注销application命令。

每个application模块都会使用AST_MODULE_INFO_STANDARD宏来登记模块信息__mod_info。 AST_MODULE_INFO_STANDARD将load_module和unload_module注册为回调函数，供module load/unload/reload调用。

2)Channel

以chan_开始的模块，如chan_sip.c、chan_h323.c、chan_mgcp.c 、chan_iax2.c、 chan_zap.c等，对应代码保存在channels目录中。

channel注册、注销过程和application基本类似。由于每个channel需要和外部交互，都会在load_module中启用do_monitor线程来侦听外部tcp/udp端口，接收外部消息。

每个channel也定义了各自的cli命令和Function命令，例如chan_sip定义了sip debug/history/no/notify/prune/ reload/set/show等cli命令和SIP_HEADER、CHECKSIPDOMAIN、SIPPEER、SIPCHANINFO等 Function命令。

3)Functions

以Fun_开始的模块，例如Fun_db.c、func_moh.c、func_cdr.c等，对应代码保存在funcs目录中。

Function注册、注销过程也和application类似。

每个Function模块也定义了各自的Function命令，例如Fun_db.c就定义了DB、DB_EXISTS、DB_DELETE等Function命令。

二、asterisk启动过程

主要就main函数讲解asterisk的启动过程：

<!--

Code highlighting produced by Actipro CodeHighlighter (freeware)
http://www.CodeHighlighter.com/

-->    1  int  main( int  argc,  char   * argv[])
   2 
   3  {
   4 
   5          int  c;
   6 
   7          char  filename[ 80 ]  =   "" ;
   8 
   9          char  hostname[MAXHOSTNAMELEN]  =   "" ;
  10 
  11          char  tmp[ 80 ];
  12 
  13          char   *  xarg  =  NULL;
  14 
  15          int  x;
  16 
  17         FILE  * f;
  18 
  19         sigset_t sigs;
  20 
  21          int  num;
  22 
  23          int  isroot  =   1 ;
  24 
  25          char   * buf;
  26 
  27          char   * runuser  =  NULL,  * rungroup  =  NULL;
  28 
  29  /* 保存命令行参数(argv[]->_argv[])，以便程序重启时使用 */
  30 
  31          /*  Remember original args for restart  */
  32 
  33          if  (argc  >   sizeof (_argv)  /   sizeof (_argv[ 0 ])  -   1 ) {
  34 
  35                fprintf(stderr,  " Truncating argument size to %d\n " , ( int )( sizeof (_argv)  /   sizeof (_argv[ 0 ]))  -   1 );
  36 
  37                argc  =   sizeof (_argv)  /   sizeof (_argv[ 0 ])  -   1 ;
  38 
  39         }
  40 
  41          for  (x = 0 ; x < argc; x ++ )
  42 
  43                _argv[x]  =  argv[x];
  44 
  45         _argv[x]  =  NULL;
  46 
  47          if  (geteuid()  !=   0 )
  48 
  49                isroot  =   0 ;
  50 
  51  /* 命令如果是rasterisk，设置AST_OPT_FLAG_NO_FORK和AST_OPT_FLAG_REMOTE标志位 */
  52 
  53          /*  if the progname is rasterisk consider it a remote console  */
  54 
  55          if  (argv[ 0 ]  &&  (strstr(argv[ 0 ],  " rasterisk " ))  !=  NULL) {
  56 
  57                ast_set_flag( & ast_options, AST_OPT_FLAG_NO_FORK  |  AST_OPT_FLAG_REMOTE);
  58 
  59         }
  60 
  61  /* 得到当前主机名,在启动时打印出来 */
  62 
  63          if  (gethostname(hostname,  sizeof (hostname) - 1 ))
  64 
  65                ast_copy_string(hostname,  " <Unknown> " ,  sizeof (hostname));
  66 
  67  /* 获取当前的进程标识 */
  68 
  69         ast_mainpid  =  getpid();
  70 
  71  /* 建立mu-law和a-law转换表 */
  72 
  73         ast_ulaw_init();
  74 
  75         ast_alaw_init();
  76 
  77  /* 为FFT逆变换（傅立叶逆变换）做一些初始化,用于在zaptel里进行callerid的DTMF检测 */
  78 
  79         callerid_init();
  80 
  81  /* 初始化内置命令的_full_cmd字符串，并注册常用命令，ast_builtins_init() -> ast_cli_register_multiple() -> ast_cli_register() -> __ast_cli_register()  */
  82 
  83         ast_builtins_init();
  84 
  85  /* 初始化base64转换 */
  86 
  87         ast_utils_init();
  88 
  89  /*  tty/tdd初始化 */
  90 
  91         tdd_init();
  92 
  93  /* 设置用户历史命令的保存路径 */
  94 
  95          if  (getenv( " HOME " ))
  96 
  97                snprintf(filename,  sizeof (filename),  " %s/.asterisk_history " , getenv( " HOME " ));
  98 
  99          /*  Check for options  */
 100 
 101  /* 检查命令行的输入参数，匹配参数范围是“mtThfFdvVqprRgciInx:U:G:C:L:M:”，不同的参数输入走到不同的case分支处理。有几个v,verbose级别就增加几 */
 102 
 103          while  ((c  =  getopt(argc, argv,  " mtThfFdvVqprRgciInx:U:G:C:L:M: " ))  !=   - 1 ) {
 104 
 105                 switch  (c) {
 106 
 107  #if  HAVE_WORKING_FORK
 108 
 109                 case   ' F ' :
 110 
 111                       ast_set_flag( & ast_options, AST_OPT_FLAG_ALWAYS_FORK);
 112 
 113                        break ;
 114 
 115                 case   ' f ' :
 116 
 117                       ast_set_flag( & ast_options, AST_OPT_FLAG_NO_FORK);
 118 
 119                        break ;
 120 
 121  #endif
 122 
 123                 case   ' d ' :
 124 
 125                       option_debug ++ ;
 126 
 127                       ast_set_flag( & ast_options, AST_OPT_FLAG_NO_FORK);
 128 
 129                        break ;
 130 
 131                 case   ' c ' :
 132 
 133                       ast_set_flag( & ast_options, AST_OPT_FLAG_NO_FORK  |  AST_OPT_FLAG_CONSOLE);
 134 
 135                        break ;
 136 
 137                 case   ' n ' :
 138 
 139                       ast_set_flag( & ast_options, AST_OPT_FLAG_NO_COLOR);
 140 
 141                        break ;
 142 
 143                 case   ' r ' :
 144 
 145                       ast_set_flag( & ast_options, AST_OPT_FLAG_NO_FORK  |  AST_OPT_FLAG_REMOTE);
 146 
 147                        break ;
 148 
 149                 case   ' R ' :
 150 
 151                       ast_set_flag( & ast_options, AST_OPT_FLAG_NO_FORK  |  AST_OPT_FLAG_REMOTE  |  AST_OPT_FLAG_RECONNECT);
 152 
 153                        break ;
 154 
 155                 case   ' p ' :
 156 
 157                       ast_set_flag( & ast_options, AST_OPT_FLAG_HIGH_PRIORITY);
 158 
 159                        break ;
 160 
 161                 case   ' v ' :
 162 
 163                       option_verbose ++ ;
 164 
 165                       ast_set_flag( & ast_options, AST_OPT_FLAG_NO_FORK);
 166 
 167                        break ;
 168 
 169                 case   ' m ' :
 170 
 171                       ast_set_flag( & ast_options, AST_OPT_FLAG_MUTE);
 172 
 173                        break ;
 174 
 175                 case   ' M ' :
 176 
 177                        if  ((sscanf(optarg,  " %d " ,  & option_maxcalls)  !=   1 )  ||  (option_maxcalls  <   0 ))
 178 
 179                              option_maxcalls  =   0 ;
 180 
 181                        break ;
 182 
 183                 case   ' L ' :
 184 
 185                        if  ((sscanf(optarg,  " %lf " ,  & option_maxload)  !=   1 )  ||  (option_maxload  <   0.0 ))
 186 
 187                              option_maxload  =   0.0 ;
 188 
 189                        break ;
 190 
 191                 case   ' q ' :
 192 
 193                       ast_set_flag( & ast_options, AST_OPT_FLAG_QUIET);
 194 
 195                        break ;
 196 
 197                 case   ' t ' :
 198 
 199                       ast_set_flag( & ast_options, AST_OPT_FLAG_CACHE_RECORD_FILES);
 200 
 201                        break ;
 202 
 203                 case   ' T ' :
 204 
 205                       ast_set_flag( & ast_options, AST_OPT_FLAG_TIMESTAMP);
 206 
 207                        break ;
 208 
 209                 case   ' x ' :
 210 
 211                       ast_set_flag( & ast_options, AST_OPT_FLAG_EXEC);
 212 
 213                       xarg  =  ast_strdupa(optarg);
 214 
 215                        break ;
 216 
 217                 case   ' C ' :
 218 
 219                       ast_copy_string(ast_config_AST_CONFIG_FILE, optarg,  sizeof (ast_config_AST_CONFIG_FILE));
 220 
 221                       ast_set_flag( & ast_options, AST_OPT_FLAG_OVERRIDE_CONFIG);
 222 
 223                        break ;
 224 
 225                 case   ' I ' :
 226 
 227                       ast_set_flag( & ast_options, AST_OPT_FLAG_INTERNAL_TIMING);
 228 
 229                        break ;
 230 
 231                 case   ' i ' :
 232 
 233                       ast_set_flag( & ast_options, AST_OPT_FLAG_INIT_KEYS);
 234 
 235                        break ;
 236 
 237                 case   ' g ' :
 238 
 239                       ast_set_flag( & ast_options, AST_OPT_FLAG_DUMP_CORE);
 240 
 241                        break ;
 242 
 243                 case   ' h ' :
 244 
 245                       show_cli_help();
 246 
 247                       exit( 0 );
 248 
 249                 case   ' V ' :
 250 
 251                       show_version();
 252 
 253                       exit( 0 );
 254 
 255                 case   ' U ' :
 256 
 257                       runuser  =  ast_strdupa(optarg);
 258 
 259                        break ;
 260 
 261                 case   ' G ' :
 262 
 263                       rungroup  =  ast_strdupa(optarg);
 264 
 265                        break ;
 266 
 267                 case   ' ? ' :
 268 
 269                       exit( 1 );
 270 
 271                }
 272 
 273         }
 274 
 275  /* 如果用了-c或者-v或者-r并且没有-x cmd参数，则打印欢迎信息 */
 276 
 277          if  (ast_opt_console  ||  option_verbose  ||  (ast_opt_remote  &&   ! ast_opt_exec)) {
 278 
 279                ast_register_verbose(console_verboser);
 280 
 281                WELCOME_MESSAGE;
 282 
 283         }
 284 
 285  /* 如果没有开调试则简单打印Booting  */
 286 
 287          if  (ast_opt_console  &&   ! option_verbose)
 288 
 289                ast_verbose( " [ Booting\n " );
 290 
 291  /* 显示控制台时，不论是本地还是远程，都不能使用-F参数，否则无效 */
 292 
 293          if  (ast_opt_always_fork  &&  (ast_opt_remote  ||  ast_opt_console)) {
 294 
 295                ast_log(LOG_WARNING,  " 'alwaysfork' is not compatible with console or remote console mode; ignored\n " );
 296 
 297                ast_clear_flag( & ast_options, AST_OPT_FLAG_ALWAYS_FORK);
 298 
 299         }
 300 
 301          /*  For remote connections, change the name of the remote connection.
 302 
 303          * We do this for the benefit of init scripts (which need to know if/when
 304 
 305          * the main asterisk process has died yet).  */
 306 
 307          if  (ast_opt_remote) {
 308 
 309                strcpy(argv[ 0 ],  " rasterisk " );
 310 
 311                 for  (x  =   1 ; x  <  argc; x ++ ) {
 312 
 313                       argv[x]  =  argv[ 0 ]  +   10 ;
 314 
 315                }
 316 
 317         }
 318 
 319  /* 读取主配置文件，主配置文件是由make menuselect配置的 */
 320 
 321          if  (ast_opt_console  &&   ! option_verbose)
 322 
 323                ast_verbose( " [ Reading Master Configuration ]\n " );
 324 
 325         ast_readconfig();
 326 
 327  /* 如果启动加了-g，取消core dump文件的大小限制 */
 328 
 329          if  (ast_opt_dump_core) {
 330 
 331                 struct  rlimit l;
 332 
 333                memset( & l,  0 ,  sizeof (l));
 334 
 335                l.rlim_cur  =  RLIM_INFINITY;
 336 
 337                l.rlim_max  =  RLIM_INFINITY;
 338 
 339                 if  (setrlimit(RLIMIT_CORE,  & l)) {
 340 
 341                       ast_log(LOG_WARNING,  " Unable to disable core size resource limit: %s\n " , strerror(errno));
 342 
 343                }
 344 
 345         }
 346 
 347  /* 修改用户和组权限 */
 348 
 349          if  (( ! rungroup)  &&   ! ast_strlen_zero(ast_config_AST_RUN_GROUP))
 350 
 351                rungroup  =  ast_config_AST_RUN_GROUP;
 352 
 353          if  (( ! runuser)  &&   ! ast_strlen_zero(ast_config_AST_RUN_USER))
 354 
 355                runuser  =  ast_config_AST_RUN_USER;
 356 
 357  #ifndef __CYGWIN__
 358 
 359          if  (isroot)
 360 
 361                ast_set_priority(ast_opt_high_priority);
 362 
 363          if  (isroot  &&  rungroup) {
 364 
 365                 struct  group  * gr;
 366 
 367                gr  =  getgrnam(rungroup);
 368 
 369                 if  ( ! gr) {
 370 
 371                       ast_log(LOG_WARNING,  " No such group '%s'!\n " , rungroup);
 372 
 373                       exit( 1 );
 374 
 375                }
 376 
 377                 if  (setgid(gr -> gr_gid)) {
 378 
 379                       ast_log(LOG_WARNING,  " Unable to setgid to %d (%s)\n " , ( int )gr -> gr_gid, rungroup);
 380 
 381                       exit( 1 );
 382 
 383                }
 384 
 385                 if  (setgroups( 0 , NULL)) {
 386 
 387                       ast_log(LOG_WARNING,  " Unable to drop unneeded groups\n " );
 388 
 389                       exit( 1 );
 390 
 391                }
 392 
 393                 if  (option_verbose)
 394 
 395                       ast_verbose( " Running as group '%s'\n " , rungroup);
 396 
 397         }
 398 
 399          if  (runuser  &&   ! ast_test_flag( & ast_options, AST_OPT_FLAG_REMOTE)) {
 400 
 401  #ifdef HAVE_CAP
 402 
 403                 int  has_cap  =   1 ;
 404 
 405  #endif  /* HAVE_CAP */
 406 
 407                 struct  passwd  * pw;
 408 
 409                pw  =  getpwnam(runuser);
 410 
 411                 if  ( ! pw) {
 412 
 413                       ast_log(LOG_WARNING,  " No such user '%s'!\n " , runuser);
 414 
 415                       exit( 1 );
 416 
 417                }
 418 
 419  #ifdef HAVE_CAP
 420 
 421                 if  (prctl(PR_SET_KEEPCAPS,  1 ,  0 ,  0 ,  0 )) {
 422 
 423                       ast_log(LOG_WARNING,  " Unable to keep capabilities.\n " );
 424 
 425                       has_cap  =   0 ;
 426 
 427                }
 428 
 429  #endif  /* HAVE_CAP */
 430 
 431                 if  ( ! isroot  &&  pw -> pw_uid  !=  geteuid()) {
 432 
 433                       ast_log(LOG_ERROR,  " Asterisk started as nonroot, but runuser '%s' requested.\n " , runuser);
 434 
 435                       exit( 1 );
 436 
 437                }
 438 
 439                 if  ( ! rungroup) {
 440 
 441                        if  (setgid(pw -> pw_gid)) {
 442 
 443                              ast_log(LOG_WARNING,  " Unable to setgid to %d!\n " , ( int )pw -> pw_gid);
 444 
 445                              exit( 1 );
 446 
 447                       }
 448 
 449                        if  (isroot  &&  initgroups(pw -> pw_name, pw -> pw_gid)) {
 450 
 451                              ast_log(LOG_WARNING,  " Unable to init groups for '%s'\n " , runuser);
 452 
 453                              exit( 1 );
 454 
 455                       }
 456 
 457                }
 458 
 459                 if  (setuid(pw -> pw_uid)) {
 460 
 461                       ast_log(LOG_WARNING,  " Unable to setuid to %d (%s)\n " , ( int )pw -> pw_uid, runuser);
 462 
 463                       exit( 1 );
 464 
 465                }
 466 
 467                 if  (option_verbose)
 468 
 469                       ast_verbose( " Running as user '%s'\n " , runuser);
 470 
 471  #ifdef HAVE_CAP
 472 
 473                 if  (has_cap) {
 474 
 475                       cap_t cap;
 476 
 477                       cap  =  cap_from_text( " cap_net_admin=ep " );
 478 
 479                        if  (cap_set_proc(cap))
 480 
 481                              ast_log(LOG_WARNING,  " Unable to install capabilities.\n " );
 482 
 483                        if  (cap_free(cap))
 484 
 485                              ast_log(LOG_WARNING,  " Unable to drop capabilities.\n " );
 486 
 487                }
 488 
 489  #endif  /* HAVE_CAP */
 490 
 491         }
 492 
 493  #endif  /* __CYGWIN__ */
 494 
 495  #ifdef linux
 496 
 497          if  (geteuid()  &&  ast_opt_dump_core) {
 498 
 499                 if  (prctl(PR_SET_DUMPABLE,  1 ,  0 ,  0 ,  0 )  <   0 ) {
 500 
 501                       ast_log(LOG_WARNING,  " Unable to set the process for core dumps after changing to a non-root user. %s\n " , strerror(errno));
 502 
 503                }   
 504 
 505         }
 506 
 507  #endif
 508 
 509  /* 初始化模拟终端ast_term_init(),默认是VT100 */
 510 
 511         ast_term_init();
 512 
 513         printf(term_end());
 514 
 515         fflush(stdout);
 516 
 517          if  (ast_opt_console  &&   ! option_verbose)
 518 
 519                ast_verbose( " [ Initializing Custom Configuration Options ]\n " );
 520 
 521          /*  custom config setup  */
 522 
 523  /* 注册命令core show config mappings */
 524 
 525         register_config_cli();
 526 
 527  /* 配置文件的映射和绑定 */
 528 
 529         read_config_maps();
 530 
 531          if  (ast_opt_console) {
 532 
 533                 if  (el_hist  ==  NULL  ||  el  ==  NULL)
 534 
 535                       ast_el_initialize();
 536 
 537                 if  ( ! ast_strlen_zero(filename))
 538 
 539                       ast_el_read_history(filename);
 540 
 541         }
 542 
 543  /* 设置和检查本地或远程终端的连接 */
 544 
 545          if  (ast_tryconnect()) {
 546 
 547                 /*  One is already running  */
 548 
 549                 if  (ast_opt_remote) {
 550 
 551                        if  (ast_opt_exec) {
 552 
 553                              ast_remotecontrol(xarg);
 554 
 555                              quit_handler( 0 ,  0 ,  0 ,  0 );
 556 
 557                              exit( 0 );
 558 
 559                       }
 560 
 561                       printf(term_quit());
 562 
 563                       ast_remotecontrol(NULL);
 564 
 565                       quit_handler( 0 ,  0 ,  0 ,  0 );
 566 
 567                       exit( 0 );
 568 
 569                }  else  {
 570 
 571                       ast_log(LOG_ERROR,  " Asterisk already running on %s.  Use 'asterisk -r' to connect.\n " , ast_config_AST_SOCKET);
 572 
 573                       printf(term_quit());
 574 
 575                       exit( 1 );
 576 
 577                }
 578 
 579         }  else   if  (ast_opt_remote  ||  ast_opt_exec) {
 580 
 581                ast_log(LOG_ERROR,  " Unable to connect to remote asterisk (does %s exist?)\n " , ast_config_AST_SOCKET);
 582 
 583                printf(term_quit());
 584 
 585                exit( 1 );
 586 
 587         }
 588 
 589          /*  Blindly write pid file since we couldn't connect  */
 590 
 591         unlink(ast_config_AST_PID);
 592 
 593         f  =  fopen(ast_config_AST_PID,  " w " );
 594 
 595          if  (f) {
 596 
 597                fprintf(f,  " %ld\n " , ( long )getpid());
 598 
 599                fclose(f);
 600 
 601         }  else
 602 
 603                ast_log(LOG_WARNING,  " Unable to open pid file '%s': %s\n " , ast_config_AST_PID, strerror(errno));
 604 
 605  #if  HAVE_WORKING_FORK
 606 
 607          if  (ast_opt_always_fork  ||   ! ast_opt_no_fork) {
 608 
 609  #ifndef HAVE_SBIN_LAUNCHD
 610 
 611                daemon( 1 ,  0 );
 612 
 613                ast_mainpid  =  getpid();
 614 
 615                 /*  Blindly re-write pid file since we are forking  */
 616 
 617                unlink(ast_config_AST_PID);
 618 
 619                f  =  fopen(ast_config_AST_PID,  " w " );
 620 
 621                 if  (f) {
 622 
 623                       fprintf(f,  " %ld\n " , ( long )ast_mainpid);
 624 
 625                       fclose(f);
 626 
 627                }  else
 628 
 629                       ast_log(LOG_WARNING,  " Unable to open pid file '%s': %s\n " , ast_config_AST_PID, strerror(errno));
 630 
 631  #else
 632 
 633                ast_log(LOG_WARNING,  " Mac OS X detected.  Use '/sbin/launchd -d' to launch with the nofork option.\n " );
 634 
 635  #endif
 636 
 637         }
 638 
 639  #endif
 640 
 641          /*  Test recursive mutex locking.  */
 642 
 643  /* 测试线程安全，避免出现死锁 */
 644 
 645          if  (test_for_thread_safety())
 646 
 647                ast_verbose( " Warning! Asterisk is not thread safe.\n " );
 648 
 649  /* 创建用于和控制台交互的服务器端socket接口 */
 650 
 651         ast_makesocket();
 652 
 653  /* 加入信号集，设置掩码，以及注册信号的相应handler  */
 654 
 655         sigemptyset( & sigs);
 656 
 657         sigaddset( & sigs, SIGHUP);
 658 
 659         sigaddset( & sigs, SIGTERM);
 660 
 661         sigaddset( & sigs, SIGINT);
 662 
 663         sigaddset( & sigs, SIGPIPE);
 664 
 665         sigaddset( & sigs, SIGWINCH);
 666 
 667         pthread_sigmask(SIG_BLOCK,  & sigs, NULL);
 668 
 669         signal(SIGURG, urg_handler);
 670 
 671         signal(SIGINT, __quit_handler);
 672 
 673         signal(SIGTERM, __quit_handler);
 674 
 675         signal(SIGHUP, hup_handler);
 676 
 677         signal(SIGCHLD, child_handler);
 678 
 679         signal(SIGPIPE, SIG_IGN);
 680 
 681          /*  ensure that the random number generators are seeded with a different value every time
 682 
 683            Asterisk is started
 684 
 685          */
 686 
 687  /* 设置种子并初始化随机数发生器 */
 688 
 689         srand((unsigned  int ) getpid()  +  (unsigned  int ) time(NULL));
 690 
 691         initstate((unsigned  int ) getpid()  *   65536   +  (unsigned  int ) time(NULL), randompool,  sizeof (randompool));
 692 
 693  /* 初始化日志模块 */
 694 
 695          if  (init_logger()) {
 696 
 697                printf(term_quit());
 698 
 699                exit( 1 );
 700 
 701         }
 702 
 703  #ifdef HAVE_ZAPTEL
 704 
 705         {
 706 
 707                 int  fd;
 708 
 709                 int  x  =   160 ;
 710 
 711                fd  =  open( " /dev/zap/timer " , O_RDWR);
 712 
 713                 if  (fd  >=   0 ) {
 714 
 715                        if  (ioctl(fd, ZT_TIMERCONFIG,  & x)) {
 716 
 717                              ast_log(LOG_ERROR,  " You have Zaptel built and drivers loaded, but the Zaptel timer test failed to set ZT_TIMERCONFIG to %d.\n " , x);
 718 
 719                              exit( 1 );
 720 
 721                       }
 722 
 723                        if  ((x  =  ast_wait_for_input(fd,  300 ))  <   0 ) {
 724 
 725                              ast_log(LOG_ERROR,  " You have Zaptel built and drivers loaded, but the Zaptel timer could not be polled during the Zaptel timer test.\n " );
 726 
 727                              exit( 1 );
 728 
 729                       }
 730 
 731                        if  ( ! x) {
 732 
 733                               const   char  zaptel_timer_error[]  =  {
 734 
 735                                      " Asterisk has detected a problem with your Zaptel configuration and will shutdown for your protection.  You have options: "
 736 
 737                                      " \n\t1. You only have to compile Zaptel support into Asterisk if you need it.  One option is to recompile without Zaptel support. "
 738 
 739                                      " \n\t2. You only have to load Zaptel drivers if you want to take advantage of Zaptel services.  One option is to unload zaptel modules if you don't need them. "
 740 
 741                                      " \n\t3. If you need Zaptel services, you must correctly configure Zaptel. "
 742 
 743                              };
 744 
 745                              ast_log(LOG_ERROR,  " %s\n " , zaptel_timer_error);
 746 
 747                              exit( 1 );
 748 
 749                       }
 750 
 751                       close(fd);
 752 
 753                }
 754 
 755         }
 756 
 757  #endif
 758 
 759  /* 注册threadstorage show allocations和threadstorage show summary这两个命令 */
 760 
 761         threadstorage_init();
 762 
 763         astobj2_init();
 764 
 765         ast_autoservice_init();
 766 
 767  /* 加载配置文件/etc/asterisk/modules.conf中标记为preload的模块，再去掉标记为noload的模块 */
 768 
 769          if  (load_modules( 1 )) {
 770 
 771                printf(term_quit());
 772 
 773                exit( 1 );
 774 
 775         }
 776 
 777  /*  DNS manager的初始化 */
 778 
 779          if  (dnsmgr_init()) {
 780 
 781                printf(term_quit());
 782 
 783                exit( 1 );
 784 
 785         }
 786 
 787  /* 配置http服务器 */
 788 
 789         ast_http_init();
 790 
 791  /* 注册两个命令core show channeltypes和core show channeltype  */
 792 
 793         ast_channels_init();
 794 
 795  /* 注册管理命令 */
 796 
 797          if  (init_manager()) {
 798 
 799                printf(term_quit());
 800 
 801                exit( 1 );
 802 
 803         }
 804 
 805  /* 用来创建一个调度上下文以及注册相应的命令,然后用do_reload来读取配置文件cdr.conf和创建后台线程do_cdr  */
 806 
 807          if  (ast_cdr_engine_init()) {
 808 
 809                printf(term_quit());
 810 
 811                exit( 1 );
 812 
 813         }
 814 
 815  /* 用来创建一个后台线程轮巡设备的状态，如果发生变化则及时通告 */
 816 
 817          if  (ast_device_state_engine_init()) {
 818 
 819                printf(term_quit());
 820 
 821                exit( 1 );
 822 
 823         }
 824 
 825  /* 注册rtp,rtcp,stun相关的CLI命令，然后调用ast_rtp_reload()读取配置文件rtp.conf，设置相关参数 */
 826 
 827         ast_rtp_init();
 828 
 829  /* 注册udptl相关的CLI命令，然后调用ast_udptl_reload()读取配置文件udptl.conf，设置相关参数 */
 830 
 831         ast_udptl_init();
 832 
 833  /* 注册core show image formats  */
 834 
 835          if  (ast_image_init()) {
 836 
 837                printf(term_quit());
 838 
 839                exit( 1 );
 840 
 841         }
 842 
 843  /* 注册core show file formats  */
 844 
 845          if  (ast_file_init()) {
 846 
 847                printf(term_quit());
 848 
 849                exit( 1 );
 850 
 851         }
 852 
 853  /* 注册dialplan相关的CLI命令，然后调用ast_register_application来注册所有的app  */
 854 
 855          if  (load_pbx()) {
 856 
 857                printf(term_quit());
 858 
 859                exit( 1 );
 860 
 861         }
 862 
 863  /* 注册与codec相关的CLI命令 */
 864 
 865          if  (init_framer()) {
 866 
 867                printf(term_quit());
 868 
 869                exit( 1 );
 870 
 871         }
 872 
 873  /* 注册与database相关的CLI命令，然后再注册两个管理命令DBGet和DBPut  */
 874 
 875          if  (astdb_init()) {
 876 
 877                printf(term_quit());
 878 
 879                exit( 1 );
 880 
 881         }
 882 
 883  /* 读取配置文件enum.conf，初始化支持ENUM(e164)的子系统 */
 884 
 885          if  (ast_enum_init()) {
 886 
 887                printf(term_quit());
 888 
 889                exit( 1 );
 890 
 891         }
 892 
 893  /*  load_modules(0)加载所有其它需要加载的动态链接库 */
 894 
 895          if  (load_modules( 0 )) {
 896 
 897                printf(term_quit());
 898 
 899                exit( 1 );
 900 
 901         }
 902 
 903         dnsmgr_start_refresh();
 904 
 905          /*  We might have the option of showing a console, but for now just
 906 
 907            do nothing  */
 908 
 909          if  (ast_opt_console  &&   ! option_verbose)
 910 
 911                ast_verbose( "  ]\n " );
 912 
 913          if  (option_verbose  ||  ast_opt_console)
 914 
 915                ast_verbose(term_color(tmp,  " Asterisk Ready.\n " , COLOR_BRWHITE, COLOR_BLACK,  sizeof (tmp)));
 916 
 917          if  (ast_opt_no_fork)
 918 
 919                consolethread  =  pthread_self();
 920 
 921  /* 创建管道 */
 922 
 923          if  (pipe(sig_alert_pipe))
 924 
 925                sig_alert_pipe[ 0 ]  =  sig_alert_pipe[ 1 ]  =   - 1 ;
 926 
 927         ast_set_flag( & ast_options, AST_OPT_FLAG_FULLY_BOOTED);
 928 
 929         pthread_sigmask(SIG_UNBLOCK,  & sigs, NULL);
 930 
 931  #ifdef __AST_DEBUG_MALLOC
 932 
 933         __ast_mm_init();
 934 
 935  #endif    
 936 
 937         time( & ast_startuptime);
 938 
 939  /* 注册asterisk相关的命令，比如stop,restart,halt等等 */
 940 
 941         ast_cli_register_multiple(cli_asterisk,  sizeof (cli_asterisk)  /   sizeof ( struct  ast_cli_entry));
 942 
 943          if  (ast_opt_console) {
 944 
 945                 /*  Console stuff now  */
 946 
 947                 /*  Register our quit function  */
 948 
 949                 char  title[ 256 ];
 950 
 951                pthread_attr_t attr;
 952 
 953                pthread_t dont_care;
 954 
 955  /* 创建线程，轮询上面创建的sig_alert_pipe管道 */
 956 
 957                pthread_attr_init( & attr);
 958 
 959                pthread_attr_setdetachstate( & attr, PTHREAD_CREATE_DETACHED);
 960 
 961                ast_pthread_create( & dont_care,  & attr, monitor_sig_flags, NULL);
 962 
 963                pthread_attr_destroy( & attr);
 964 
 965                set_icon( " Asterisk " );
 966 
 967                snprintf(title,  sizeof (title),  " Asterisk Console on '%s' (pid %ld) " , hostname, ( long )ast_mainpid);
 968 
 969                set_title(title);
 970 
 971  /* 接收和处理控制台命令 */
 972 
 973                 for  (;;) {
 974 
 975                       buf  =  ( char   * )el_gets(el,  & num);
 976 
 977                        if  ( ! buf  &&  write( 1 ,  "" ,  1 )  <   0 )
 978 
 979                               goto  lostterm;
 980 
 981                        if  (buf) {
 982 
 983                               if  (buf[strlen(buf) - 1 ]  ==   ' \n ' )
 984 
 985                                     buf[strlen(buf) - 1 ]  =   ' \0 ' ;
 986 
 987                              consolehandler(( char   * )buf);
 988 
 989                       }  else   if  (ast_opt_remote  &&  (write(STDOUT_FILENO,  " \nUse EXIT or QUIT to exit the asterisk console\n " ,
 990 
 991                                 strlen( " \nUse EXIT or QUIT to exit the asterisk console\n " ))  <   0 )) {
 992 
 993                               /*  Whoa, stdout disappeared from under us Make /dev/null's  */
 994 
 995                               int  fd;
 996 
 997                              fd  =  open( " /dev/null " , O_RDWR);
 998 
 999                               if  (fd  >   - 1 ) {
1000 
1001                                     dup2(fd, STDOUT_FILENO);
1002 
1003                                     dup2(fd, STDIN_FILENO);
1004 
1005                              }  else
1006 
1007                                     ast_log(LOG_WARNING,  " Failed to open /dev/null to recover from dead console. Bad things will happen!\n " );
1008 
1009                               break ;
1010 
1011                       }
1012 
1013                }
1014 
1015         }
1016 
1017         monitor_sig_flags(NULL);
1018 
1019  lostterm:
1020 
1021          return   0 ;
1022 
1023  }

三、asterisk基本呼叫流程

从内核的角度去分析问题时，弄清楚呼叫流程是非常关键的，只有理清了呼叫流程，才能从流程的各个环节细节中分析出问题所在。

Asterisk所有功能都是基于函数调用的模式，呼叫流程也不例外。因此如何从一团乱麻似的内核函数调用中理出函数调用执行路线，是解读呼叫流程的关键。

所有呼叫都跟astersisk的channel有关。这路通话都包含一个incoming连接和一个outbound连接。每个电话都是通过对应的channel程序建立起来的，比如Chan_sip,Chan_zap,Chan_iax2等等。每一类的channel，都拥有自己私有的 channel数据结构，例如chan_sip的struct sip_pvt结构，这些私有的结构从属于一个通用的Asterisk通道数据结构中，具体定义在channel.h的struct ast_channe中。

下图是asterisk 的呼叫流程图：

我们以sip的呼叫过程为例来描述，其他channel的呼叫过程基本类似。

Astersik下注册的sip用户主动发起一个呼叫的函数调用过程(incoming)如下：

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进行处理。

在handle_request_invite中，首先解析invite消息，对该sip用户的业务属性分析，确认被叫可达，然后就调用sip_new申请channel资源，并调用ast_pbx_start函数启动一个pbx_thread线程来专门处理该呼叫。

pbx_thread线程调用__ast_pbx_run。

__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语句呼叫被叫。

在等待被叫接通的过程中，完成媒体协商过程，向主叫发送180、200OK消息接通呼叫。

当其他用户呼叫asterisk的sip用户时，函数调用过程（outbound）如下： 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。

在dial_exec_full中，首先调用ast_request，在ast_request调用chan_sip对应的回调函数 sip_request_call为该被叫sip用户申请channel资源。然后调用ast_call，在ast_call中调用chan_sip对应的回调函数sip_call向被叫发送INVITE消息，呼叫被叫SIP用户。

然后该呼叫线程会调用wait_for_answer等待被叫接通。

在呼叫接通后，也即wait_for_answer函数返回，在dial_exec_full中调用ast_bridge_call桥接媒体，这样呼叫就正式接通了。

当chan_sip的侦听线程接收到BYE消息，则调用handle_request_bye找到相应的channel，执行hangup释放呼叫。