为在telnet自己TCP服务器程序的界面上实现shell一样的自动补齐和历史记录的功能

转自    http://blog.csdn.net/ren911/article/details/5705955

1. 目的

希望在 telnet 自己 TCP 服务器程序的界面上实现 shell 一样的自动补齐和历史记录的功能。

2. 问题

程序的远程登陆的 telnet 界面通常是通过一个 TCP 服务器来实现的，但是如果想在这个 TCP 服务器端实现客户端登陆界面的自动补齐和历史记录的功能会有如下的问题：

（ 1 ）常见的 telnet 客户端是以行模式发送数据的，即输入一个字符串后再按一个回车，整个数据才会被发送到服务器端。

（ 2 ）常见的 telnet 客户端是自动回显的，即你在键盘上输入一个字符后，客户端自己将这个字符显示在客户端界面上，而不是显示的从服务器端发送过来的数据。

默认这样做的原因，是为了简化了客户端和服务器端的实现。但是如果希望能够让客户端能够具有 shell 一样的自动补齐和历史记录功能则无法实现，原因如下：

（ 1 ）自动补齐功能一般是按 tab 键后按现有输入的部分进行匹配的，不能等按回车，因为按回车一般表示客户端输入完成，等待服务器处理的结果。应该是按下每个按键都发送一次。

（ 2 ）历史记录功能一般有按 ” ↑ ” 和 ” ↓ ” 键来实现对记录上翻和下翻的功能，而如上翻功能在按下 ” ↑ ” 键后应用上条历史记录来替代当前行输入的值，这就需要抹除当前行已有的字符，这点在自动回显的功能中很难做到。换句话说，最好由服务器端完全控制客户端的显示，不要让客户端自动显示任何东西。

 

3. 解决办法

按照 telnet 协议的规定，详见附录1，将回显功能关闭，将输入模式从逐行模式改为逐个字符模式。具体参考 命令参考大全。

echo

在输入字符的本地屏幕显示与禁止本地屏幕显示间切换。本地屏幕显示用于正常处理，而禁止屏幕显示便于输入不宜显示在屏幕上的文本，如密码。该变量仅可用于逐行方式

输入方式

当带参数发出 telnet 命令时，它执行包含这些参数的 open 子命令，然后进入输入方式。输入方式的类型为逐个字母或逐行，取决于远程系统所支持的是什么。在逐个字母方式下，大部分输入的文本会立即送到远程主机处理。在逐行方式下，所有文本在本地屏幕显示，然后将完整的行发送到远程主机。

这样做增加了客户端和服务端实现的工作量，尤其是服务器端，需要对接收的字符进行拼装处理，同时要控制客户端的显示。主要实现功能如下：

（ 1 ）实现对客户端显示的控制功能，因为客户端不再自动显示，一些原有的功能现在需要由服务器来完成，比如删除一个字符，现在服务器需要三步完成： 1. 发送指令让客户端的光标向前移动一个字符 à 2. 向客户端发送一个空格 à 3. 再发送指令让客户端的光标向前移动一个字符。

（ 2 ）在服务器端对接收到的数据进行缓存和管理，根据收到的数据对前面的数据做对应的处理。如收到一个删除字符就要将缓存的字符串最后一个字符删除并将长度减一并进行（ 1 ）提到的操作。

（ 3 ）实现自动补齐算法，主要包括两种情况： A. 如果和现有输入匹配的命令只有一个，直接用其在当前行替代已有输入。 B. 如果和现有输入匹配的命令有多个，一般是在当前行下面将这多个命令显示。

（ 4 ）对历史记录的管理。

 

4. 具体实现

整体实现参考了 zebra 源代码部分的 telnet 部分的实现，但是 zebra 源码实现的较为复杂，功能虽强，但超出我当前的需求代价太大，故参考简化实现。只在 linux 下的 telnet 测试通过， windows 下可能有点小问题。具体的怎样将命令执行参考 asterisk 源码中 cli 的实现简化实现，感觉 asterisk 的 cli 的设计思路更加清晰些，但是只支持本地显示，不能 telnet 。

大概代码如下，省略部分

 

view plain
  1. #define TEL_MAXHIST 20   
  2.   
  3. #define TEL_COM_LEN 100   
  4.   
  5. typedef struct tel_vty   
  6.   
  7. {   
  8.   
  9.     /* socket fd */   
  10.   
  11.     int fd;   
  12.   
  13.     
  14.   
  15.     /* 命令接受缓冲区 */   
  16.   
  17.     char buf[TEL_COM_LEN];   
  18.   
  19.     
  20.   
  21.     /* 命令当前指针，主要用于左右移动等操作需要记录当前在操作字符串的那个位置 */   
  22.   
  23.     int cp;   
  24.   
  25.     
  26.   
  27.     /* 命令长度 */   
  28.   
  29.     int length;   
  30.   
  31.     
  32.   
  33.     /*  命令历史记录数组，准备循环使用，当未到达最大长度时每个新的节点都插入在 hp 之后的位置，数组最后一个位置的下一个位置是第一个位置 */   
  34.   
  35.     char *hist[TEL_MAXHIST];   
  36.   
  37.     
  38.   
  39.     /* 当前历史记录指针 , 主要用于在历史记录中上下翻时记录当前指向的历史记录 */   
  40.   
  41.     int hp;   
  42.   
  43.     
  44.   
  45.     /* 历史插入的结尾指针 */   
  46.   
  47.     int hindex;   
  48.   
  49.     
  50.   
  51. }tel_vty;   
  52.   
  53. /*-------------------------------------------------------------------------*/   
  54.   
  55. /*                      TELNET 协议处理                                         */   
  56.   
  57. /*-------------------------------------------------------------------------*/   
  58.   
  59. char telnet_backward_char = 0x08;// 用与控制客户端光标向前移动一个字符   
  60.   
  61. char telnet_space_char = ' ';   
  62.   
  63. // 向客户端发送值   
  64.   
  65. void vty_out(tel_vty *p_tel_vty, char cmd[], int len)   
  66.   
  67. // 清空当前 buf   
  68.   
  69. void vty_clear(tel_vty *p_tel_vty)   
  70.   
  71. {   
  72.   
  73.     memset(p_tel_vty->buf, 0x00, p_tel_vty->length);   
  74.   
  75.     p_tel_vty->length=0;   
  76.   
  77. }   
  78.   
  79.     
  80.   
  81. /* 使客户端不要自动回显 */   
  82.   
  83. void vty_will_echo(tel_vty *p_tel_vty)   
  84.   
  85. {   
  86.   
  87.     char cmd[] = { IAC, WILL, TELOPT_ECHO, '/0' };   
  88.   
  89.     vty_out(p_tel_vty, cmd, sizeof(cmd));   
  90.   
  91. }   
  92.   
  93.     
  94.   
  95. /* 使用 suppress Go-Ahead telnet 选项 . */   
  96.   
  97. static void vty_will_suppress_go_ahead(tel_vty *p_tel_vty)   
  98.   
  99. {   
  100.   
  101.     char cmd[] = { IAC, WILL, TELOPT_SGA, '/0' };   
  102.   
  103.     vty_out(p_tel_vty, cmd, sizeof(cmd));   
  104.   
  105. }   
  106.   
  107.     
  108.   
  109. /* 使用逐个字符显示的输入方式 . */   
  110.   
  111. static void vty_dont_linemode(tel_vty *p_tel_vty)   
  112.   
  113. {   
  114.   
  115.     char cmd[] = { IAC, DONT, TELOPT_LINEMODE, '/0' };   
  116.   
  117.     vty_out(p_tel_vty, cmd, sizeof(cmd));   
  118.   
  119. }   
  120.   
  121.     
  122.   
  123. /* Use window size. */   
  124.   
  125. static void vty_do_window_size(tel_vty *p_tel_vty)   
  126.   
  127. {   
  128.   
  129.     char cmd[] = { IAC, DO, TELOPT_NAWS, '/0' };   
  130.   
  131.     vty_out(p_tel_vty, cmd, sizeof(cmd));   
  132.   
  133. }   
  134.   
  135. // 使客户端光标向前移动一个字符   
  136.   
  137. static void vty_backward_char(tel_vty *p_tel_vty)   
  138.   
  139. {   
  140.   
  141.     if(p_tel_vty->length > 0)   
  142.   
  143.     {   
  144.   
  145.         p_tel_vty->buf[p_tel_vty->length--]='/0';   
  146.   
  147.         vty_out(p_tel_vty, &telnet_backward_char, 1);   
  148.   
  149.     }   
  150.   
  151. }   
  152.   
  153. // 发送空格字符   
  154.   
  155. static void vty_space_char(tel_vty *p_tel_vty)   
  156.   
  157. // 回到当前行的开始   
  158.   
  159. static void vty_beginning_of_line(tel_vty *p_tel_vty)   
  160.   
  161. {   
  162.   
  163.     while(p_tel_vty->length)   
  164.   
  165.         vty_backward_char(p_tel_vty);   
  166.   
  167. }   
  168.   
  169. // 使客户端删除一个字符   
  170.   
  171. static void vty_ec(tel_vty *p_tel_vty)   
  172.   
  173. {   
  174.   
  175. //    printf("ec len is %d/n", p_tel_vty->length);   
  176.   
  177.     vty_backward_char(p_tel_vty);   
  178.   
  179.     vty_space_char(p_tel_vty);   
  180.   
  181.     vty_backward_char(p_tel_vty);   
  182.   
  183. }   
  184.   
  185. // 使客户端删除当前位置向后的一行   
  186.   
  187. static void vty_kill_line(tel_vty *p_tel_vty)   
  188.   
  189. {   
  190.   
  191.     int i=0;   
  192.   
  193.     for ( i = 0; i< MAX_CLI_LEN; i++)   
  194.   
  195.     {   
  196.   
  197.         vty_space_char(p_tel_vty);   
  198.   
  199.     }   
  200.   
  201.     for ( i = 0; i< MAX_CLI_LEN; i++)   
  202.   
  203.     {   
  204.   
  205.         vty_backward_char(p_tel_vty);   
  206.   
  207.     }   
  208.   
  209. }   
  210.   
  211. // 删除从当前行起始位置的一行，即将当前行清空   
  212.   
  213. static void vty_kill_line_from_beginning(tel_vty *p_tel_vty)   
  214.   
  215. {   
  216.   
  217.     vty_beginning_of_line(p_tel_vty);   
  218.   
  219.     vty_kill_line(p_tel_vty);   
  220.   
  221.     p_tel_vty->length = 0;   
  222.   
  223. }   
  224.   
  225. // 添加历史记录   
  226.   
  227. static void vty_hist_add(tel_vty *p_tel_vty)   
  228.   
  229. {   
  230.   
  231.     int index;   
  232.   
  233.     if (p_tel_vty->length == 0)   
  234.   
  235.         return;   
  236.   
  237.     index = p_tel_vty->hindex?p_tel_vty->hindex - 1: TEL_MAXHIST - 1;   
  238.   
  239.     /* 如果和上一次命令相同则忽略 */   
  240.   
  241.     if (p_tel_vty->hist[index])   
  242.   
  243.         if(strcmp(p_tel_vty->buf, p_tel_vty->hist[index]) == 0)   
  244.   
  245.         {   
  246.   
  247.             p_tel_vty->hp = p_tel_vty->hindex;   
  248.   
  249.             return;   
  250.   
  251.         }   
  252.   
  253.     
  254.   
  255.     if (p_tel_vty->hist[p_tel_vty->hindex])   
  256.   
  257.     {   
  258.   
  259.         free(p_tel_vty->hist[p_tel_vty->hindex]);   
  260.   
  261.     }   
  262.   
  263.     p_tel_vty->hist[p_tel_vty->hindex] = strdup(p_tel_vty->buf);   
  264.   
  265.     p_tel_vty->hindex++;   
  266.   
  267.     if(p_tel_vty->hindex == TEL_MAXHIST)   
  268.   
  269.         p_tel_vty->hindex = 0;   
  270.   
  271.     
  272.   
  273.     p_tel_vty->hp = p_tel_vty->hindex;   
  274.   
  275. }   
  276.   
  277. // 显示一行   
  278.   
  279. static void vty_redraw_line(tel_vty *p_tel_vty)   
  280.   
  281. {   
  282.   
  283.     vty_out(p_tel_vty, p_tel_vty->buf, p_tel_vty->length);   
  284.   
  285.     p_tel_vty->cp = p_tel_vty->length;   
  286.   
  287. }   
  288.   
  289. // 打印历史记录   
  290.   
  291. static void vty_histroy_print(tel_vty *p_tel_vty)   
  292.   
  293. {   
  294.   
  295.     int length;   
  296.   
  297.     vty_kill_line_from_beginning(p_tel_vty);   
  298.   
  299.     
  300.   
  301.     /* 从历史记录缓存中取得字符窜 */   
  302.   
  303.     length = strlen(p_tel_vty->hist[p_tel_vty->hp]);   
  304.   
  305.      memcpy(p_tel_vty->buf, p_tel_vty->hist[p_tel_vty->hp], length);   
  306.   
  307.     p_tel_vty->cp = p_tel_vty->length = length;   
  308.   
  309.     /* 显示此行 */   
  310.   
  311.     vty_redraw_line(p_tel_vty);   
  312.   
  313. }   
  314.   
  315. // 显示当前记录的下一个历史记录   
  316.   
  317. static void vty_next_line(tel_vty *p_tel_vty)   
  318.   
  319. {   
  320.   
  321.     int try_index;   
  322.   
  323.     
  324.   
  325.     if(p_tel_vty->hp == p_tel_vty->hindex)   
  326.   
  327.         return;   
  328.   
  329.     
  330.   
  331.     /* 寻找下个位置，如果已经在最后，循环到第一位 */   
  332.   
  333.     try_index = p_tel_vty->hp;   
  334.   
  335.     if (try_index == (TEL_MAXHIST - 1))   
  336.   
  337.         try_index = 0;   
  338.   
  339.     else   
  340.   
  341.         try_index++;   
  342.   
  343.     
  344.   
  345.     /* 查看此位置有没有记录 */   
  346.   
  347.     if (p_tel_vty->hist[try_index] == NULL)   
  348.   
  349.         return;   
  350.   
  351.     else   
  352.   
  353.         p_tel_vty->hp = try_index;   
  354.   
  355.     
  356.   
  357.     vty_histroy_print(p_tel_vty);   
  358.   
  359. }   
  360.   
  361. // 显示当前记录的上一个历史记录   
  362.   
  363. static void vty_previous_line(tel_vty *p_tel_vty)   
  364.   
  365. {   
  366.   
  367.     int try_index;   
  368.   
  369.     try_index = p_tel_vty->hp;   
  370.   
  371.     if (try_index == 0)   
  372.   
  373.     {   
  374.   
  375.         try_index = TEL_MAXHIST - 1;   
  376.   
  377.     }   
  378.   
  379.     else   
  380.   
  381.     {   
  382.   
  383.         try_index--;   
  384.   
  385.     }   
  386.   
  387.     if (p_tel_vty->hist[try_index] == NULL)   
  388.   
  389.         return;   
  390.   
  391.     else   
  392.   
  393.         p_tel_vty->hp = try_index;   
  394.   
  395.     
  396.   
  397.     vty_histroy_print(p_tel_vty);     
  398.   
  399. }   
  400.   
  401. // 自动补齐函数   
  402.   
  403. static int vty_complete(tel_vty * p_tel_vty)   
  404.   
  405. {   
  406.   
  407.     int fd = p_tel_vty->fd;   
  408.   
  409.     char matchstr[80] = "";   
  410.   
  411.     struct ngn_cli_entry *e;   
  412.   
  413.     struct ngn_cli_entry *match_e;   
  414.   
  415.     int len = 0;   
  416.   
  417.     int found = 0;   
  418.   
  419.     char tmp_out_str[80];   
  420.   
  421.     int tmp_showed = 0;   
  422.   
  423.     
  424.   
  425.      if (p_tel_vty->buf)   
  426.   
  427.     {   
  428.   
  429.         sprintf(matchstr,"%s",p_tel_vty->buf);   
  430.   
  431.         len = strlen(matchstr);   
  432.   
  433.     }   
  434.   
  435.     
  436.   
  437.     NGN_LIST_LOCK(&helpers);   
  438.   
  439.     e = NGN_LIST_FIRST(&helpers);   
  440.   
  441.     if (e)   
  442.   
  443.     {   
  444.   
  445.     do{   
  446.   
  447.         /* Hide commands that start with '_' */   
  448.   
  449.         if (p_tel_vty->buf && strncasecmp(p_tel_vty->buf, e->cmda[0], len))   
  450.   
  451.             continue;   
  452.   
  453.         if (found == 0)   
  454.   
  455.         {   
  456.   
  457.             sprintf(tmp_out_str,  "%25.20s   %s/n/r", e->cmda[0], S_OR(e->summary,""));   
  458.   
  459.         }   
  460.   
  461.           
  462.   
  463.         match_e = e;   
  464.   
  465.         found++;   
  466.   
  467.         if (found > 1)// 多于一个匹配时的处理   
  468.   
  469.         {   
  470.   
  471.             if (tmp_showed == 0)   
  472.   
  473.             {      
  474.   
  475.                 ngn_cli(fd, "/r/n");      
  476.   
  477.                 ngn_cli(fd, tmp_out_str);   
  478.   
  479.                 tmp_showed = 1;   
  480.   
  481.             }   
  482.   
  483.              ngn_cli(fd, "%25.20s   %s/n/r", e->cmda[0], S_OR(e->summary,""));   
  484.   
  485.         }   
  486.   
  487.     }while(e = NGN_LIST_NEXT(e, list));   
  488.   
  489.     }   
  490.   
  491.     /* 找到唯一匹配 */   
  492.   
  493.     if ((found == 1))   
  494.   
  495.     {   
  496.   
  497.         e = match_e;   
  498.   
  499.         vty_kill_line_from_beginning(p_tel_vty);   
  500.   
  501.         memset(p_tel_vty->buf, 0x00, p_tel_vty->length);   
  502.   
  503.         memcpy(p_tel_vty->buf,e->cmda[0], strlen(e->cmda[0]));   
  504.   
  505.         p_tel_vty->length = strlen(e->cmda[0]);   
  506.   
  507.         vty_redraw_line(p_tel_vty);   
  508.   
  509.     }   
  510.   
  511.     else if (found > 1)// 如果多于一个，其实已经在上面处理过了   
  512.   
  513.     {   
  514.   
  515.         vty_clear(p_tel_vty);   
  516.   
  517.         ngn_cli(fd, "/r/n->");   
  518.   
  519.     }   
  520.   
  521.     
  522.   
  523.     NGN_LIST_UNLOCK(&helpers);   
  524.   
  525.     if (!found && matchstr[0])   
  526.   
  527.     {   
  528.   
  529.         return RESULT_FAILURE;   
  530.   
  531.     }   
  532.   
  533.     
  534.   
  535.     return RESULT_SUCCESS;   
  536.   
  537. }   
  538.   
  539. // 执行一个命令   
  540.   
  541. static void vty_excute(tel_vty *p_tel_vty)   
  542.   
  543. {   
  544.   
  545.     char recv_buf[MAX_CLI_LEN];   
  546.   
  547.     memset(recv_buf, 0x00, MAX_CLI_LEN);   
  548.   
  549.     ast_cli(p_tel_vty->fd, "/r/n");   
  550.   
  551.     vty_hist_add(p_tel_vty);   
  552.   
  553.     memcpy(recv_buf, p_tel_vty->buf, p_tel_vty->length);   
  554.   
  555.     
  556.   
  557.     ast_cli_command(p_tel_vty->fd,(const char *)recv_buf);// 具体执行一个命令，这部分另外参考 astersik 源码实现。   
  558.   
  559.     memset(p_tel_vty->buf, 0x00 , p_tel_vty->length);   
  560.   
  561.     p_tel_vty->length = 0;   
  562.   
  563. }   
  564.   
  565. // 初始化结构   
  566.   
  567. static void init_tel_vty(tel_vty *p_tel_vty)   
  568.   
  569. {   
  570.   
  571.     memset(p_tel_vty->buf, 0x00, TEL_COM_LEN);   
  572.   
  573.     p_tel_vty->cp = 0;   
  574.   
  575.     p_tel_vty->length = 0;   
  576.   
  577.     for ( int i = 0; i< TEL_MAXHIST; i++)   
  578.   
  579.     {   
  580.   
  581.         p_tel_vty->hist[i] = NULL;   
  582.   
  583.     }   
  584.   
  585.     p_tel_vty->hp = 0;   
  586.   
  587.     p_tel_vty->hindex = 0;   
  588.   
  589. }   
  590.   
  591.     
  592.   
  593. /* 主函数 */   
  594.   
  595. #define CONTROL_TAB         0X09   
  596.   
  597. #define CONTROL_DEL         0X7F   
  598.   
  599. void *processDebugThread(void *arg)   
  600.   
  601. {   
  602.   
  603. …   
  604.   
  605. Int connfd = *((int *)arg);   
  606.   
  607.     /* 设置终端 */   
  608.   
  609.     tel_vty tel_vty;   
  610.   
  611.     tel_vty.fd = connfd;   
  612.   
  613.     init_tel_vty(&tel_vty);   
  614.   
  615.     vty_will_echo(&tel_vty);   
  616.   
  617. vty_will_suppress_go_ahead(&tel_vty);   
  618.   
  619. /* 上面的处理严格的话要检查客户端的返回值，是 OK 才表明客户端支持这样设置，但对我的应用环境暂不需要 */   
  620.   
  621.     
  622.   
  623.     vty_dont_linemode(&tel_vty);   
  624.   
  625.     vty_do_window_size(&tel_vty);   
  626.   
  627.     
  628.   
  629.     const char *wel =   
  630.   
  631.          "--------Hello, you are entering the ren911's debug cmd terminal, welcome-------/n";   
  632.   
  633.     write(connfd, wel, strlen(wel));   
  634.   
  635.     write(connfd, "/r->", 3);   
  636.   
  637.     
  638.   
  639.     while ((n = read(connfd, buf, MAX_CLI_LEN)) > 0) {   
  640.   
  641.          {   
  642.   
  643.         /*  是特殊键 , 以 ^]] 开头的键值 ( 如向上键是 ^]]A ) */   
  644.   
  645.         if (3 == n)   
  646.   
  647.         {   
  648.   
  649.             switch(buf[2]) {   
  650.   
  651.                 case CONTROL_UP:   
  652.   
  653.                     {   
  654.   
  655.                         vty_previous_line(&tel_vty);   
  656.   
  657.                     }   
  658.   
  659.                     break;   
  660.   
  661.                 case CONTROL_DOWN:   
  662.   
  663.                     {   
  664.   
  665.                         vty_next_line(&tel_vty);   
  666.   
  667.                     }   
  668.   
  669.                                break;   
  670.   
  671.             }   
  672.   
  673.         }   
  674.   
  675.                    /* 主要处理的是回车换行 ”/r/n” */   
  676.   
  677.         else if ( 2 == n )   
  678.   
  679.         {   
  680.   
  681.             switch(buf[0]) {   
  682.   
  683.                 case '/r':   
  684.   
  685.                     {   
  686.   
  687.                         if (tel_vty.length > 0)   
  688.   
  689.                         {   
  690.   
  691.                             vty_excute(&tel_vty);   
  692.   
  693.                         }   
  694.   
  695.                         vty_clear(&tel_vty);   
  696.   
  697.                         ngn_cli(connfd, "/r/n->");   
  698.   
  699.                     }   
  700.   
  701.             }   
  702.   
  703.         }   
  704.   
  705.                    /* 单个字符的处理和一些特殊键的处理，例如删除键和 TAB 键 */   
  706.   
  707.         else if ( 1 == n )   
  708.   
  709.         {   
  710.   
  711.                  switch (buf[0]) {   
  712.   
  713.                 case CONTROL_DEL:   
  714.   
  715.                     {   
  716.   
  717.                         vty_ec(&tel_vty);   
  718.   
  719.                     }   
  720.   
  721.                     break;   
  722.   
  723.                      case CONTROL_TAB:   
  724.   
  725.                     {      
  726.   
  727.                         vty_complete(&tel_vty);   
  728.   
  729.                      }   
  730.   
  731.                            break;   
  732.   
  733.     
  734.   
  735.                      default:   
  736.   
  737.                            {   
  738.   
  739.                     ngn_cli(connfd, "%c", buf[0]);   
  740.   
  741.                     tel_vty.buf[tel_vty.length++] = buf[0];   
  742.   
  743.                            }   
  744.   
  745.             }   
  746.   
  747.              }   
  748.   
  749.          }   
  750.   
  751.     }   
  752.   
  753. …   
  754.   
  755. }   

  

5 相关参考

1. telnet 协议介绍 http://support.microsoft.com/kb/231866/en-us/

2. zebra Zebra  是一个开源的  TCP/IP  路由软件，同  Cisco Internet  网络操作系统（ IOS ）类似。详见 http://www.zebra.org/

3. asterisk 是一个开源的软 PBX 软件。详见 http://www.asterisk.org/

 

posted on 2011-08-08 21:49  艾杏佛  阅读(1359)  评论(0)    收藏  举报

导航