开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > 嵌入式Linux > 查看源码
l3dss1.c
资源名称：SBC-2410X_kernel.tar.gz　[点击查看]
上传用户：lgb322
上传日期：2013-02-24
资源大小：30529k
文件大小：81k
源码类别：

嵌入式Linux

开发平台：

Unix_Linux

l3dss1.c：源码内容
  1. /* $Id: l3dss1.c,v 1.1.4.1 2001/11/20 14:19:36 kai Exp $
  2.  *
  3.  * EURO/DSS1 D-channel protocol
  4.  *
  5.  * German 1TR6 D-channel protocol
  6.  *
  7.  * Author       Karsten Keil
  8.  *              based on the teles driver from Jan den Ouden
  9.  * Copyright    by Karsten Keil      <keil@isdn4linux.de>
  10.  * 
  11.  * This software may be used and distributed according to the terms
  12.  * of the GNU General Public License, incorporated herein by reference.
  13.  *
  14.  * For changes and modifications please read
  15.  * ../../../Documentation/isdn/HiSax.cert
  16.  *
  17.  * Thanks to    Jan den Ouden
  18.  *              Fritz Elfert
  19.  *
  20.  */
  22. #define __NO_VERSION__
  23. #include "hisax.h"
  24. #include "isdnl3.h"
  25. #include "l3dss1.h"
  26. #include <linux/ctype.h>
  27. #include <linux/config.h>
  29. extern char *HiSax_getrev(const char *revision);
  30. const char *dss1_revision = "$Revision: 1.1.4.1 $";
  32. #define EXT_BEARER_CAPS 1
  34. #define MsgHead(ptr, cref, mty) 
  35. *ptr++ = 0x8; 
  36. if (cref == -1) { 
  37. *ptr++ = 0x0; 
  38. } else { 
  39. *ptr++ = 0x1; 
  40. *ptr++ = cref^0x80; 
  41. } 
  42. *ptr++ = mty
  45. /**********************************************/
  46. /* get a new invoke id for remote operations. */
  47. /* Only a return value != 0 is valid          */
  48. /**********************************************/
  49. static unsigned char new_invoke_id(struct PStack *p)
  50. {
  51. unsigned char retval;
  52. unsigned long flags;
  53. int i;
  54.   
  55. i = 32; /* maximum search depth */
  57. save_flags(flags);
  58. cli();
  60. retval = p->prot.dss1.last_invoke_id + 1; /* try new id */
  61. while ((i) && (p->prot.dss1.invoke_used[retval >> 3] == 0xFF)) {
  62. p->prot.dss1.last_invoke_id = (retval & 0xF8) + 8;
  63. i--;
  64. }  
  65. if (i) {
  66. while (p->prot.dss1.invoke_used[retval >> 3] & (1 << (retval & 7)))
  67. retval++; 
  68. } else
  69. retval = 0;
  70. p->prot.dss1.last_invoke_id = retval;
  71. p->prot.dss1.invoke_used[retval >> 3] |= (1 << (retval & 7));
  72. restore_flags(flags);
  74. return(retval);  
  75. } /* new_invoke_id */
  77. /*************************/
  78. /* free a used invoke id */
  79. /*************************/
  80. static void free_invoke_id(struct PStack *p, unsigned char id)
  81. { unsigned long flags;
  83.   if (!id) return; /* 0 = invalid value */
  85.   save_flags(flags);
  86.   cli();
  87.   p->prot.dss1.invoke_used[id >> 3] &= ~(1 << (id & 7));
  88.   restore_flags(flags);
  89. } /* free_invoke_id */  
  92. /**********************************************************/
  93. /* create a new l3 process and fill in dss1 specific data */
  94. /**********************************************************/
  95. static struct l3_process
  96. *dss1_new_l3_process(struct PStack *st, int cr)
  97. {  struct l3_process *proc;
  99.    if (!(proc = new_l3_process(st, cr))) 
  100.      return(NULL);
  102.    proc->prot.dss1.invoke_id = 0;
  103.    proc->prot.dss1.remote_operation = 0;
  104.    proc->prot.dss1.uus1_data[0] = '';
  105.    
  106.    return(proc);
  107. } /* dss1_new_l3_process */
  109. /************************************************/
  110. /* free a l3 process and all dss1 specific data */
  111. /************************************************/ 
  112. static void
  113. dss1_release_l3_process(struct l3_process *p)
  114. {
  115.    free_invoke_id(p->st,p->prot.dss1.invoke_id);
  116.    release_l3_process(p);
  117. } /* dss1_release_l3_process */
  118.  
  119. /********************************************************/
  120. /* search a process with invoke id id and dummy callref */
  121. /********************************************************/
  122. static struct l3_process *
  123. l3dss1_search_dummy_proc(struct PStack *st, int id)
  124. { struct l3_process *pc = st->l3.proc; /* start of processes */
  126.   if (!id) return(NULL);
  128.   while (pc)
  129.    { if ((pc->callref == -1) && (pc->prot.dss1.invoke_id == id))
  130.        return(pc);
  131.      pc = pc->next;
  132.    } 
  133.   return(NULL);
  134. } /* l3dss1_search_dummy_proc */
  136. /*******************************************************************/
  137. /* called when a facility message with a dummy callref is received */
  138. /* and a return result is delivered. id specifies the invoke id.   */
  139. /*******************************************************************/ 
  140. static void 
  141. l3dss1_dummy_return_result(struct PStack *st, int id, u_char *p, u_char nlen)
  142. { isdn_ctrl ic;
  143.   struct IsdnCardState *cs;
  144.   struct l3_process *pc = NULL; 
  146.   if ((pc = l3dss1_search_dummy_proc(st, id)))
  147.    { L3DelTimer(&pc->timer); /* remove timer */
  149.      cs = pc->st->l1.hardware;
  150.      ic.driver = cs->myid;
  151.      ic.command = ISDN_STAT_PROT;
  152.      ic.arg = DSS1_STAT_INVOKE_RES;
  153.      ic.parm.dss1_io.hl_id = pc->prot.dss1.invoke_id;
  154.      ic.parm.dss1_io.ll_id = pc->prot.dss1.ll_id;
  155.      ic.parm.dss1_io.proc = pc->prot.dss1.proc;
  156.      ic.parm.dss1_io.timeout= 0;
  157.      ic.parm.dss1_io.datalen = nlen;
  158.      ic.parm.dss1_io.data = p;
  159.      free_invoke_id(pc->st, pc->prot.dss1.invoke_id);
  160.      pc->prot.dss1.invoke_id = 0; /* reset id */
  162.      cs->iif.statcallb(&ic);
  163.      dss1_release_l3_process(pc); 
  164.    }
  165.   else
  166.    l3_debug(st, "dummy return result id=0x%x result len=%d",id,nlen);
  167. } /* l3dss1_dummy_return_result */
  169. /*******************************************************************/
  170. /* called when a facility message with a dummy callref is received */
  171. /* and a return error is delivered. id specifies the invoke id.    */
  172. /*******************************************************************/ 
  173. static void 
  174. l3dss1_dummy_error_return(struct PStack *st, int id, ulong error)
  175. { isdn_ctrl ic;
  176.   struct IsdnCardState *cs;
  177.   struct l3_process *pc = NULL; 
  179.   if ((pc = l3dss1_search_dummy_proc(st, id)))
  180.    { L3DelTimer(&pc->timer); /* remove timer */
  182.      cs = pc->st->l1.hardware;
  183.      ic.driver = cs->myid;
  184.      ic.command = ISDN_STAT_PROT;
  185.      ic.arg = DSS1_STAT_INVOKE_ERR;
  186.      ic.parm.dss1_io.hl_id = pc->prot.dss1.invoke_id;
  187.      ic.parm.dss1_io.ll_id = pc->prot.dss1.ll_id;
  188.      ic.parm.dss1_io.proc = pc->prot.dss1.proc;
  189.      ic.parm.dss1_io.timeout= error;
  190.      ic.parm.dss1_io.datalen = 0;
  191.      ic.parm.dss1_io.data = NULL;
  192.      free_invoke_id(pc->st, pc->prot.dss1.invoke_id);
  193.      pc->prot.dss1.invoke_id = 0; /* reset id */
  195.      cs->iif.statcallb(&ic);
  196.      dss1_release_l3_process(pc); 
  197.    }
  198.   else
  199.    l3_debug(st, "dummy return error id=0x%x error=0x%lx",id,error);
  200. } /* l3dss1_error_return */
  202. /*******************************************************************/
  203. /* called when a facility message with a dummy callref is received */
  204. /* and a invoke is delivered. id specifies the invoke id.          */
  205. /*******************************************************************/ 
  206. static void 
  207. l3dss1_dummy_invoke(struct PStack *st, int cr, int id, 
  208.                     int ident, u_char *p, u_char nlen)
  209. { isdn_ctrl ic;
  210.   struct IsdnCardState *cs;
  211.   
  212.   l3_debug(st, "dummy invoke %s id=0x%x ident=0x%x datalen=%d",
  213.                (cr == -1) ? "local" : "broadcast",id,ident,nlen);
  214.   if (cr >= -1) return; /* ignore local data */
  216.   cs = st->l1.hardware;
  217.   ic.driver = cs->myid;
  218.   ic.command = ISDN_STAT_PROT;
  219.   ic.arg = DSS1_STAT_INVOKE_BRD;
  220.   ic.parm.dss1_io.hl_id = id;
  221.   ic.parm.dss1_io.ll_id = 0;
  222.   ic.parm.dss1_io.proc = ident;
  223.   ic.parm.dss1_io.timeout= 0;
  224.   ic.parm.dss1_io.datalen = nlen;
  225.   ic.parm.dss1_io.data = p;
  227.   cs->iif.statcallb(&ic);
  228. } /* l3dss1_dummy_invoke */
  230. static void
  231. l3dss1_parse_facility(struct PStack *st, struct l3_process *pc,
  232.                       int cr, u_char * p)
  233. {
  234. int qd_len = 0;
  235. unsigned char nlen = 0, ilen, cp_tag;
  236. int ident, id;
  237. ulong err_ret;
  239. if (pc) 
  240. st = pc->st; /* valid Stack */
  241. else
  242. if ((!st) || (cr >= 0)) return; /* neither pc nor st specified */
  244. p++;
  245. qd_len = *p++;
  246. if (qd_len == 0) {
  247. l3_debug(st, "qd_len == 0");
  248. return;
  249. }
  250. if ((*p & 0x1F) != 0x11) { /* Service discriminator, supplementary service */
  251. l3_debug(st, "supplementary service != 0x11");
  252. return;
  253. }
  254. while (qd_len > 0 && !(*p & 0x80)) { /* extension ? */
  255. p++;
  256. qd_len--;
  257. }
  258. if (qd_len < 2) {
  259. l3_debug(st, "qd_len < 2");
  260. return;
  261. }
  262. p++;
  263. qd_len--;
  264. if ((*p & 0xE0) != 0xA0) { /* class and form */
  265. l3_debug(st, "class and form != 0xA0");
  266. return;
  267. }
  268.        
  269.         cp_tag = *p & 0x1F; /* remember tag value */
  271.         p++;
  272. qd_len--;
  273. if (qd_len < 1) 
  274.           { l3_debug(st, "qd_len < 1");
  275.     return;
  276.   }
  277. if (*p & 0x80) 
  278.           { /* length format indefinite or limited */
  279.     nlen = *p++ & 0x7F; /* number of len bytes or indefinite */
  280.             if ((qd_len-- < ((!nlen) ? 3 : (1 + nlen))) ||
  281.                 (nlen > 1))   
  282.      { l3_debug(st, "length format error or not implemented");
  283.        return;
  284.              }
  285.             if (nlen == 1)
  286.      { nlen = *p++; /* complete length */
  287.                qd_len--;
  288.              } 
  289.             else
  290.      { qd_len -= 2; /* trailing null bytes */
  291.                if ((*(p+qd_len)) || (*(p+qd_len+1)))
  292. { l3_debug(st,"length format indefinite error");
  293.                   return;
  294.                 }
  295.                nlen = qd_len;
  296.              }
  297.   }
  298.         else
  299.   { nlen = *p++;
  300.     qd_len--;
  301.           } 
  302. if (qd_len < nlen) 
  303.           { l3_debug(st, "qd_len < nlen");
  304.     return;
  305.   }
  306. qd_len -= nlen;
  308. if (nlen < 2) 
  309.           { l3_debug(st, "nlen < 2");
  310.     return;
  311.   }
  312.         if (*p != 0x02) 
  313.           {  /* invoke identifier tag */
  314.      l3_debug(st, "invoke identifier tag !=0x02");
  315.      return;
  316.   }
  317. p++;
  318. nlen--;
  319. if (*p & 0x80) 
  320.           { /* length format */
  321.     l3_debug(st, "invoke id length format 2");
  322.     return;
  323.   }
  324. ilen = *p++;
  325. nlen--;
  326. if (ilen > nlen || ilen == 0) 
  327.           { l3_debug(st, "ilen > nlen || ilen == 0");
  328.     return;
  329.   }
  330. nlen -= ilen;
  331. id = 0;
  332. while (ilen > 0) 
  333.           { id = (id << 8) | (*p++ & 0xFF); /* invoke identifier */
  334.     ilen--;
  335.   }
  337. switch (cp_tag) { /* component tag */
  338. case 1: /* invoke */
  339. if (nlen < 2) {
  340. l3_debug(st, "nlen < 2 22");
  341. return;
  342. }
  343. if (*p != 0x02) { /* operation value */
  344. l3_debug(st, "operation value !=0x02");
  345. return;
  346. }
  347. p++;
  348. nlen--;
  349. ilen = *p++;
  350. nlen--;
  351. if (ilen > nlen || ilen == 0) {
  352. l3_debug(st, "ilen > nlen || ilen == 0 22");
  353. return;
  354. }
  355. nlen -= ilen;
  356. ident = 0;
  357. while (ilen > 0) {
  358. ident = (ident << 8) | (*p++ & 0xFF);
  359. ilen--;
  360. }
  362.                                 if (!pc) 
  363.          { l3dss1_dummy_invoke(st, cr, id, ident, p, nlen);
  364.                                    return;
  365.                                  } 
  366. #if HISAX_DE_AOC
  367. {
  369. #define FOO1(s,a,b) 
  370.     while(nlen > 1) {
  371.     int ilen = p[1];
  372.     if(nlen < ilen+2) {
  373.     l3_debug(st, "FOO1  nlen < ilen+2"); 
  374.     return;
  375.     }
  376.     nlen -= ilen+2;
  377.     if((*p & 0xFF) == (a)) {
  378.     int nlen = ilen;
  379.     p += 2;
  380.     b;
  381.     } else {
  382.     p += ilen+2;
  383.     }
  384.     }
  386. switch (ident) {
  387. case 0x22: /* during */
  388. FOO1("1A", 0x30, FOO1("1C", 0xA1, FOO1("1D", 0x30, FOO1("1E", 0x02, ( {
  389.        ident = 0;
  390. nlen = (nlen)?nlen:0; /* Make gcc happy */
  391. while (ilen > 0) {
  392.      ident = (ident << 8) | *p++;
  393.   ilen--;
  394. }
  395.      if (ident > pc->para.chargeinfo) {
  396.      pc->para.chargeinfo = ident;
  397.      st->l3.l3l4(st, CC_CHARGE | INDICATION, pc);
  398. }
  399.      if (st->l3.debug & L3_DEB_CHARGE) {
  400.      if (*(p + 2) == 0) {
  401.      l3_debug(st, "charging info during %d", pc->para.chargeinfo);
  402. }
  403.    else {
  404.      l3_debug(st, "charging info final %d", pc->para.chargeinfo);
  405. }
  406. }
  407. }
  408.     )))))
  409. break;
  410. case 0x24: /* final */
  411. FOO1("2A", 0x30, FOO1("2B", 0x30, FOO1("2C", 0xA1, FOO1("2D", 0x30, FOO1("2E", 0x02, ( {
  412.        ident = 0;
  413. nlen = (nlen)?nlen:0; /* Make gcc happy */
  414. while (ilen > 0) {
  415.       ident = (ident << 8) | *p++;
  416.   ilen--;
  417. }
  418.       if (ident > pc->para.chargeinfo) {
  419.       pc->para.chargeinfo = ident;
  420.       st->l3.l3l4(st, CC_CHARGE | INDICATION, pc);
  421. }
  422.       if (st->l3.debug & L3_DEB_CHARGE) {
  423.       l3_debug(st, "charging info final %d", pc->para.chargeinfo);
  424. }
  425. }
  426.    ))))))
  427. break;
  428. default:
  429.                                                        l3_debug(st, "invoke break invalid ident %02x",ident);
  430. break;
  431. }
  432. #undef FOO1
  434. }
  435. #else  /* not HISAX_DE_AOC */
  436.                         l3_debug(st, "invoke break");
  437. #endif /* not HISAX_DE_AOC */
  438. break;
  439. case 2: /* return result */
  440.  /* if no process available handle separately */ 
  441.                         if (!pc)
  442.  { if (cr == -1) 
  443.                              l3dss1_dummy_return_result(st, id, p, nlen);
  444.                            return; 
  445.                          }   
  446.                         if ((pc->prot.dss1.invoke_id) && (pc->prot.dss1.invoke_id == id))
  447.                           { /* Diversion successful */
  448.                             free_invoke_id(st,pc->prot.dss1.invoke_id);
  449.                             pc->prot.dss1.remote_result = 0; /* success */     
  450.                             pc->prot.dss1.invoke_id = 0;
  451.                             pc->redir_result = pc->prot.dss1.remote_result; 
  452.                             st->l3.l3l4(st, CC_REDIR | INDICATION, pc);                                  } /* Diversion successful */
  453.                         else
  454.                           l3_debug(st,"return error unknown identifier");
  455. break;
  456. case 3: /* return error */
  457.                             err_ret = 0;
  458.                     if (nlen < 2) 
  459.                               { l3_debug(st, "return error nlen < 2");
  460.                         return;
  461.                       }
  462.                             if (*p != 0x02) 
  463.                               { /* result tag */
  464.                         l3_debug(st, "invoke error tag !=0x02");
  465.                         return;
  466.                       }
  467.                     p++;
  468.                     nlen--;
  469.                     if (*p > 4) 
  470.                               { /* length format */
  471.                         l3_debug(st, "invoke return errlen > 4 ");
  472.                         return;
  473.                       }
  474.                     ilen = *p++;
  475.                     nlen--;
  476.                     if (ilen > nlen || ilen == 0) 
  477.                               { l3_debug(st, "error return ilen > nlen || ilen == 0");
  478.                         return;
  479.                        }
  480.                     nlen -= ilen;
  481.                     while (ilen > 0) 
  482.                              { err_ret = (err_ret << 8) | (*p++ & 0xFF); /* error value */
  483.                        ilen--;
  484.                      }
  485.  /* if no process available handle separately */ 
  486.                         if (!pc)
  487.  { if (cr == -1)
  488.                              l3dss1_dummy_error_return(st, id, err_ret);
  489.                            return; 
  490.                          }   
  491.                         if ((pc->prot.dss1.invoke_id) && (pc->prot.dss1.invoke_id == id))
  492.                           { /* Deflection error */
  493.                             free_invoke_id(st,pc->prot.dss1.invoke_id);
  494.                             pc->prot.dss1.remote_result = err_ret; /* result */
  495.                             pc->prot.dss1.invoke_id = 0; 
  496.                             pc->redir_result = pc->prot.dss1.remote_result; 
  497.                             st->l3.l3l4(st, CC_REDIR | INDICATION, pc);  
  498.                           } /* Deflection error */
  499.                         else
  500.                           l3_debug(st,"return result unknown identifier");
  501. break;
  502. default:
  503. l3_debug(st, "facility default break tag=0x%02x",cp_tag);
  504. break;
  505. }
  506. }
  508. static void
  509. l3dss1_message(struct l3_process *pc, u_char mt)
  510. {
  511. struct sk_buff *skb;
  512. u_char *p;
  514. if (!(skb = l3_alloc_skb(4)))
  515. return;
  516. p = skb_put(skb, 4);
  517. MsgHead(p, pc->callref, mt);
  518. l3_msg(pc->st, DL_DATA | REQUEST, skb);
  519. }
  521. static void
  522. l3dss1_message_cause(struct l3_process *pc, u_char mt, u_char cause)
  523. {
  524. struct sk_buff *skb;
  525. u_char tmp[16];
  526. u_char *p = tmp;
  527. int l;
  529. MsgHead(p, pc->callref, mt);
  530. *p++ = IE_CAUSE;
  531. *p++ = 0x2;
  532. *p++ = 0x80;
  533. *p++ = cause | 0x80;
  535. l = p - tmp;
  536. if (!(skb = l3_alloc_skb(l)))
  537. return;
  538. memcpy(skb_put(skb, l), tmp, l);
  539. l3_msg(pc->st, DL_DATA | REQUEST, skb);
  540. }
  542. static void
  543. l3dss1_status_send(struct l3_process *pc, u_char pr, void *arg)
  544. {
  545. u_char tmp[16];
  546. u_char *p = tmp;
  547. int l;
  548. struct sk_buff *skb;
  550. MsgHead(p, pc->callref, MT_STATUS);
  552. *p++ = IE_CAUSE;
  553. *p++ = 0x2;
  554. *p++ = 0x80;
  555. *p++ = pc->para.cause | 0x80;
  557. *p++ = IE_CALL_STATE;
  558. *p++ = 0x1;
  559. *p++ = pc->state & 0x3f;
  561. l = p - tmp;
  562. if (!(skb = l3_alloc_skb(l)))
  563. return;
  564. memcpy(skb_put(skb, l), tmp, l);
  565. l3_msg(pc->st, DL_DATA | REQUEST, skb);
  566. }
  568. static void
  569. l3dss1_msg_without_setup(struct l3_process *pc, u_char pr, void *arg)
  570. {
  571. /* This routine is called if here was no SETUP made (checks in dss1up and in
  572.  * l3dss1_setup) and a RELEASE_COMPLETE have to be sent with an error code
  573.  * MT_STATUS_ENQUIRE in the NULL state is handled too
  574.  */
  575. u_char tmp[16];
  576. u_char *p = tmp;
  577. int l;
  578. struct sk_buff *skb;
  580. switch (pc->para.cause) {
  581. case 81: /* invalid callreference */
  582. case 88: /* incomp destination */
  583. case 96: /* mandory IE missing */
  584. case 100:       /* invalid IE contents */
  585. case 101: /* incompatible Callstate */
  586. MsgHead(p, pc->callref, MT_RELEASE_COMPLETE);
  587. *p++ = IE_CAUSE;
  588. *p++ = 0x2;
  589. *p++ = 0x80;
  590. *p++ = pc->para.cause | 0x80;
  591. break;
  592. default:
  593. printk(KERN_ERR "HiSax l3dss1_msg_without_setup wrong cause %dn",
  594. pc->para.cause);
  595. return;
  596. }
  597. l = p - tmp;
  598. if (!(skb = l3_alloc_skb(l)))
  599. return;
  600. memcpy(skb_put(skb, l), tmp, l);
  601. l3_msg(pc->st, DL_DATA | REQUEST, skb);
  602. dss1_release_l3_process(pc);
  603. }
  605. static int ie_ALERTING[] = {IE_BEARER, IE_CHANNEL_ID | IE_MANDATORY_1,
  606. IE_FACILITY, IE_PROGRESS, IE_DISPLAY, IE_SIGNAL, IE_HLC,
  607. IE_USER_USER, -1};
  608. static int ie_CALL_PROCEEDING[] = {IE_BEARER, IE_CHANNEL_ID | IE_MANDATORY_1,
  609. IE_FACILITY, IE_PROGRESS, IE_DISPLAY, IE_HLC, -1};
  610. static int ie_CONNECT[] = {IE_BEARER, IE_CHANNEL_ID | IE_MANDATORY_1, 
  611. IE_FACILITY, IE_PROGRESS, IE_DISPLAY, IE_DATE, IE_SIGNAL,
  612. IE_CONNECT_PN, IE_CONNECT_SUB, IE_LLC, IE_HLC, IE_USER_USER, -1};
  613. static int ie_CONNECT_ACKNOWLEDGE[] = {IE_CHANNEL_ID, IE_DISPLAY, IE_SIGNAL, -1};
  614. static int ie_DISCONNECT[] = {IE_CAUSE | IE_MANDATORY, IE_FACILITY,
  615. IE_PROGRESS, IE_DISPLAY, IE_SIGNAL, IE_USER_USER, -1};
  616. static int ie_INFORMATION[] = {IE_COMPLETE, IE_DISPLAY, IE_KEYPAD, IE_SIGNAL,
  617. IE_CALLED_PN, -1};
  618. static int ie_NOTIFY[] = {IE_BEARER, IE_NOTIFY | IE_MANDATORY, IE_DISPLAY, -1};
  619. static int ie_PROGRESS[] = {IE_BEARER, IE_CAUSE, IE_FACILITY, IE_PROGRESS |
  620. IE_MANDATORY, IE_DISPLAY, IE_HLC, IE_USER_USER, -1};
  621. static int ie_RELEASE[] = {IE_CAUSE | IE_MANDATORY_1, IE_FACILITY, IE_DISPLAY,
  622. IE_SIGNAL, IE_USER_USER, -1};
  623. /* a RELEASE_COMPLETE with errors don't require special actions 
  624. static int ie_RELEASE_COMPLETE[] = {IE_CAUSE | IE_MANDATORY_1, IE_DISPLAY, IE_SIGNAL, IE_USER_USER, -1};
  625. */
  626. static int ie_RESUME_ACKNOWLEDGE[] = {IE_CHANNEL_ID| IE_MANDATORY, IE_FACILITY,
  627. IE_DISPLAY, -1};
  628. static int ie_RESUME_REJECT[] = {IE_CAUSE | IE_MANDATORY, IE_DISPLAY, -1};
  629. static int ie_SETUP[] = {IE_COMPLETE, IE_BEARER  | IE_MANDATORY,
  630. IE_CHANNEL_ID| IE_MANDATORY, IE_FACILITY, IE_PROGRESS,
  631. IE_NET_FAC, IE_DISPLAY, IE_KEYPAD, IE_SIGNAL, IE_CALLING_PN,
  632. IE_CALLING_SUB, IE_CALLED_PN, IE_CALLED_SUB, IE_REDIR_NR,
  633. IE_LLC, IE_HLC, IE_USER_USER, -1};
  634. static int ie_SETUP_ACKNOWLEDGE[] = {IE_CHANNEL_ID | IE_MANDATORY, IE_FACILITY,
  635. IE_PROGRESS, IE_DISPLAY, IE_SIGNAL, -1};
  636. static int ie_STATUS[] = {IE_CAUSE | IE_MANDATORY, IE_CALL_STATE |
  637. IE_MANDATORY, IE_DISPLAY, -1};
  638. static int ie_STATUS_ENQUIRY[] = {IE_DISPLAY, -1};
  639. static int ie_SUSPEND_ACKNOWLEDGE[] = {IE_DISPLAY, IE_FACILITY, -1};
  640. static int ie_SUSPEND_REJECT[] = {IE_CAUSE | IE_MANDATORY, IE_DISPLAY, -1};
  641. /* not used 
  642.  * static int ie_CONGESTION_CONTROL[] = {IE_CONGESTION | IE_MANDATORY,
  643.  * IE_CAUSE | IE_MANDATORY, IE_DISPLAY, -1};
  644.  * static int ie_USER_INFORMATION[] = {IE_MORE_DATA, IE_USER_USER | IE_MANDATORY, -1};
  645.  * static int ie_RESTART[] = {IE_CHANNEL_ID, IE_DISPLAY, IE_RESTART_IND |
  646.  * IE_MANDATORY, -1};
  647.  */
  648. static int ie_FACILITY[] = {IE_FACILITY | IE_MANDATORY, IE_DISPLAY, -1};
  649. static int comp_required[] = {1,2,3,5,6,7,9,10,11,14,15,-1};
  650. static int l3_valid_states[] = {0,1,2,3,4,6,7,8,9,10,11,12,15,17,19,25,-1};
  652. struct ie_len {
  653. int ie;
  654. int len;
  655. };
  657. static
  658. struct ie_len max_ie_len[] = {
  659. {IE_SEGMENT, 4},
  660. {IE_BEARER, 12},
  661. {IE_CAUSE, 32},
  662. {IE_CALL_ID, 10},
  663. {IE_CALL_STATE, 3},
  664. {IE_CHANNEL_ID, 34},
  665. {IE_FACILITY, 255},
  666. {IE_PROGRESS, 4},
  667. {IE_NET_FAC, 255},
  668. {IE_NOTIFY, 3},
  669. {IE_DISPLAY, 82},
  670. {IE_DATE, 8},
  671. {IE_KEYPAD, 34},
  672. {IE_SIGNAL, 3},
  673. {IE_INFORATE, 6},
  674. {IE_E2E_TDELAY, 11},
  675. {IE_TDELAY_SEL, 5},
  676. {IE_PACK_BINPARA, 3},
  677. {IE_PACK_WINSIZE, 4},
  678. {IE_PACK_SIZE, 4},
  679. {IE_CUG, 7},
  680. {IE_REV_CHARGE, 3},
  681. {IE_CALLING_PN, 24},
  682. {IE_CALLING_SUB, 23},
  683. {IE_CALLED_PN, 24},
  684. {IE_CALLED_SUB, 23},
  685. {IE_REDIR_NR, 255},
  686. {IE_TRANS_SEL, 255},
  687. {IE_RESTART_IND, 3},
  688. {IE_LLC, 18},
  689. {IE_HLC, 5},
  690. {IE_USER_USER, 131},
  691. {-1,0},
  692. };
  694. static int
  695. getmax_ie_len(u_char ie) {
  696. int i = 0;
  697. while (max_ie_len[i].ie != -1) {
  698. if (max_ie_len[i].ie == ie)
  699. return(max_ie_len[i].len);
  700. i++;
  701. }
  702. return(255);
  703. }
  705. static int
  706. ie_in_set(struct l3_process *pc, u_char ie, int *checklist) {
  707. int ret = 1;
  709. while (*checklist != -1) {
  710. if ((*checklist & 0xff) == ie) {
  711. if (ie & 0x80)
  712. return(-ret);
  713. else
  714. return(ret);
  715. }
  716. ret++;
  717. checklist++;
  718. }
  719. return(0);
  720. }
  722. static int
  723. check_infoelements(struct l3_process *pc, struct sk_buff *skb, int *checklist)
  724. {
  725. int *cl = checklist;
  726. u_char mt;
  727. u_char *p, ie;
  728. int l, newpos, oldpos;
  729. int err_seq = 0, err_len = 0, err_compr = 0, err_ureg = 0;
  730. u_char codeset = 0;
  731. u_char old_codeset = 0;
  732. u_char codelock = 1;
  734. p = skb->data;
  735. /* skip cr */
  736. p++;
  737. l = (*p++) & 0xf;
  738. p += l;
  739. mt = *p++;
  740. oldpos = 0;
  741. while ((p - skb->data) < skb->len) {
  742. if ((*p & 0xf0) == 0x90) { /* shift codeset */
  743. old_codeset = codeset;
  744. codeset = *p & 7;
  745. if (*p & 0x08)
  746. codelock = 0;
  747. else
  748. codelock = 1;
  749. if (pc->debug & L3_DEB_CHECK)
  750. l3_debug(pc->st, "check IE shift%scodeset %d->%d",
  751. codelock ? " locking ": " ", old_codeset, codeset);
  752. p++;
  753. continue;
  754. }
  755. if (!codeset) { /* only codeset 0 */
  756. if ((newpos = ie_in_set(pc, *p, cl))) {
  757. if (newpos > 0) {
  758. if (newpos < oldpos)
  759. err_seq++;
  760. else
  761. oldpos = newpos;
  762. }
  763. } else {
  764. if (ie_in_set(pc, *p, comp_required))
  765. err_compr++;
  766. else
  767. err_ureg++;
  768. }
  769. }
  770. ie = *p++;
  771. if (ie & 0x80) {
  772. l = 1;
  773. } else {
  774. l = *p++;
  775. p += l;
  776. l += 2;
  777. }
  778. if (!codeset && (l > getmax_ie_len(ie)))
  779. err_len++;
  780. if (!codelock) {
  781. if (pc->debug & L3_DEB_CHECK)
  782. l3_debug(pc->st, "check IE shift back codeset %d->%d",
  783. codeset, old_codeset);
  784. codeset = old_codeset;
  785. codelock = 1;
  786. }
  787. }
  788. if (err_compr | err_ureg | err_len | err_seq) {
  789. if (pc->debug & L3_DEB_CHECK)
  790. l3_debug(pc->st, "check IE MT(%x) %d/%d/%d/%d",
  791. mt, err_compr, err_ureg, err_len, err_seq);
  792. if (err_compr)
  793. return(ERR_IE_COMPREHENSION);
  794. if (err_ureg)
  795. return(ERR_IE_UNRECOGNIZED);
  796. if (err_len)
  797. return(ERR_IE_LENGTH);
  798. if (err_seq)
  799. return(ERR_IE_SEQUENCE);
  800. } 
  801. return(0);
  802. }
  804. /* verify if a message type exists and contain no IE error */
  805. static int
  806. l3dss1_check_messagetype_validity(struct l3_process *pc, int mt, void *arg)
  807. {
  808. switch (mt) {
  809. case MT_ALERTING:
  810. case MT_CALL_PROCEEDING:
  811. case MT_CONNECT:
  812. case MT_CONNECT_ACKNOWLEDGE:
  813. case MT_DISCONNECT:
  814. case MT_INFORMATION:
  815. case MT_FACILITY:
  816. case MT_NOTIFY:
  817. case MT_PROGRESS:
  818. case MT_RELEASE:
  819. case MT_RELEASE_COMPLETE:
  820. case MT_SETUP:
  821. case MT_SETUP_ACKNOWLEDGE:
  822. case MT_RESUME_ACKNOWLEDGE:
  823. case MT_RESUME_REJECT:
  824. case MT_SUSPEND_ACKNOWLEDGE:
  825. case MT_SUSPEND_REJECT:
  826. case MT_USER_INFORMATION:
  827. case MT_RESTART:
  828. case MT_RESTART_ACKNOWLEDGE:
  829. case MT_CONGESTION_CONTROL:
  830. case MT_STATUS:
  831. case MT_STATUS_ENQUIRY:
  832. if (pc->debug & L3_DEB_CHECK)
  833. l3_debug(pc->st, "l3dss1_check_messagetype_validity mt(%x) OK", mt);
  834. break;
  835. case MT_RESUME: /* RESUME only in user->net */
  836. case MT_SUSPEND: /* SUSPEND only in user->net */
  837. default:
  838. if (pc->debug & (L3_DEB_CHECK | L3_DEB_WARN))
  839. l3_debug(pc->st, "l3dss1_check_messagetype_validity mt(%x) fail", mt);
  840. pc->para.cause = 97;
  841. l3dss1_status_send(pc, 0, NULL);
  842. return(1);
  843. }
  844. return(0);
  845. }
  847. static void
  848. l3dss1_std_ie_err(struct l3_process *pc, int ret) {
  850. if (pc->debug & L3_DEB_CHECK)
  851. l3_debug(pc->st, "check_infoelements ret %d", ret);
  852. switch(ret) {
  853. case 0: 
  854. break;
  855. case ERR_IE_COMPREHENSION:
  856. pc->para.cause = 96;
  857. l3dss1_status_send(pc, 0, NULL);
  858. break;
  859. case ERR_IE_UNRECOGNIZED:
  860. pc->para.cause = 99;
  861. l3dss1_status_send(pc, 0, NULL);
  862. break;
  863. case ERR_IE_LENGTH:
  864. pc->para.cause = 100;
  865. l3dss1_status_send(pc, 0, NULL);
  866. break;
  867. case ERR_IE_SEQUENCE:
  868. default:
  869. break;
  870. }
  871. }
  873. static int
  874. l3dss1_get_channel_id(struct l3_process *pc, struct sk_buff *skb) {
  875. u_char *p;
  877. p = skb->data;
  878. if ((p = findie(p, skb->len, IE_CHANNEL_ID, 0))) {
  879. p++;
  880. if (*p != 1) { /* len for BRI = 1 */
  881. if (pc->debug & L3_DEB_WARN)
  882. l3_debug(pc->st, "wrong chid len %d", *p);
  883. return (-2);
  884. }
  885. p++;
  886. if (*p & 0x60) { /* only base rate interface */
  887. if (pc->debug & L3_DEB_WARN)
  888. l3_debug(pc->st, "wrong chid %x", *p);
  889. return (-3);
  890. }
  891. return(*p & 0x3);
  892. } else
  893. return(-1);
  894. }
  896. static int
  897. l3dss1_get_cause(struct l3_process *pc, struct sk_buff *skb) {
  898. u_char l, i=0;
  899. u_char *p;
  901. p = skb->data;
  902. pc->para.cause = 31;
  903. pc->para.loc = 0;
  904. if ((p = findie(p, skb->len, IE_CAUSE, 0))) {
  905. p++;
  906. l = *p++;
  907. if (l>30)
  908. return(1);
  909. if (l) {
  910. pc->para.loc = *p++;
  911. l--;
  912. } else {
  913. return(2);
  914. }
  915. if (l && !(pc->para.loc & 0x80)) {
  916. l--;
  917. p++; /* skip recommendation */
  918. }
  919. if (l) {
  920. pc->para.cause = *p++;
  921. l--;
  922. if (!(pc->para.cause & 0x80))
  923. return(3);
  924. } else
  925. return(4);
  926. while (l && (i<6)) {
  927. pc->para.diag[i++] = *p++;
  928. l--;
  929. }
  930. } else
  931. return(-1);
  932. return(0);
  933. }
  935. static void
  936. l3dss1_msg_with_uus(struct l3_process *pc, u_char cmd)
  937. {
  938. struct sk_buff *skb;
  939. u_char tmp[16+40];
  940. u_char *p = tmp;
  941. int l;
  943. MsgHead(p, pc->callref, cmd);
  945.         if (pc->prot.dss1.uus1_data[0])
  946.  { *p++ = IE_USER_USER; /* UUS info element */
  947.            *p++ = strlen(pc->prot.dss1.uus1_data) + 1;
  948.            *p++ = 0x04; /* IA5 chars */
  949.            strcpy(p,pc->prot.dss1.uus1_data);
  950.            p += strlen(pc->prot.dss1.uus1_data);
  951.            pc->prot.dss1.uus1_data[0] = '';   
  952.          } 
  954. l = p - tmp;
  955. if (!(skb = l3_alloc_skb(l)))
  956. return;
  957. memcpy(skb_put(skb, l), tmp, l);
  958. l3_msg(pc->st, DL_DATA | REQUEST, skb);
  959. } /* l3dss1_msg_with_uus */
  961. static void
  962. l3dss1_release_req(struct l3_process *pc, u_char pr, void *arg)
  963. {
  964. StopAllL3Timer(pc);
  965. newl3state(pc, 19);
  966. if (!pc->prot.dss1.uus1_data[0]) 
  967. l3dss1_message(pc, MT_RELEASE);
  968. else
  969. l3dss1_msg_with_uus(pc, MT_RELEASE);
  970. L3AddTimer(&pc->timer, T308, CC_T308_1);
  971. }
  973. static void
  974. l3dss1_release_cmpl(struct l3_process *pc, u_char pr, void *arg)
  975. {
  976. struct sk_buff *skb = arg;
  977. int ret;
  979. if ((ret = l3dss1_get_cause(pc, skb))>0) {
  980. if (pc->debug & L3_DEB_WARN)
  981. l3_debug(pc->st, "RELCMPL get_cause ret(%d)",ret);
  982. } else if (ret < 0)
  983. pc->para.cause = NO_CAUSE;
  984. StopAllL3Timer(pc);
  985. newl3state(pc, 0);
  986. pc->st->l3.l3l4(pc->st, CC_RELEASE | CONFIRM, pc);
  987. dss1_release_l3_process(pc);
  988. }
  990. #if EXT_BEARER_CAPS
  992. static u_char *
  993. EncodeASyncParams(u_char * p, u_char si2)
  994. { // 7c 06 88  90 21 42 00 bb
  996. p[0] = 0;
  997. p[1] = 0x40; // Intermediate rate: 16 kbit/s jj 2000.02.19
  998. p[2] = 0x80;
  999. if (si2 & 32) // 7 data bits
  1001. p[2] += 16;
  1002. else // 8 data bits
  1004. p[2] += 24;
  1006. if (si2 & 16) // 2 stop bits
  1008. p[2] += 96;
  1009. else // 1 stop bit
  1011. p[2] += 32;
  1013. if (si2 & 8) // even parity
  1015. p[2] += 2;
  1016. else // no parity
  1018. p[2] += 3;
  1020. switch (si2 & 0x07) {
  1021. case 0:
  1022. p[0] = 66; // 1200 bit/s
  1024. break;
  1025. case 1:
  1026. p[0] = 88; // 1200/75 bit/s
  1028. break;
  1029. case 2:
  1030. p[0] = 87; // 75/1200 bit/s
  1032. break;
  1033. case 3:
  1034. p[0] = 67; // 2400 bit/s
  1036. break;
  1037. case 4:
  1038. p[0] = 69; // 4800 bit/s
  1040. break;
  1041. case 5:
  1042. p[0] = 72; // 9600 bit/s
  1044. break;
  1045. case 6:
  1046. p[0] = 73; // 14400 bit/s
  1048. break;
  1049. case 7:
  1050. p[0] = 75; // 19200 bit/s
  1052. break;
  1053. }
  1054. return p + 3;
  1055. }
  1057. static  u_char
  1058. EncodeSyncParams(u_char si2, u_char ai)
  1059. {
  1061. switch (si2) {
  1062. case 0:
  1063. return ai + 2; // 1200 bit/s
  1065. case 1:
  1066. return ai + 24; // 1200/75 bit/s
  1068. case 2:
  1069. return ai + 23; // 75/1200 bit/s
  1071. case 3:
  1072. return ai + 3; // 2400 bit/s
  1074. case 4:
  1075. return ai + 5; // 4800 bit/s
  1077. case 5:
  1078. return ai + 8; // 9600 bit/s
  1080. case 6:
  1081. return ai + 9; // 14400 bit/s
  1083. case 7:
  1084. return ai + 11; // 19200 bit/s
  1086. case 8:
  1087. return ai + 14; // 48000 bit/s
  1089. case 9:
  1090. return ai + 15; // 56000 bit/s
  1092. case 15:
  1093. return ai + 40; // negotiate bit/s
  1095. default:
  1096. break;
  1097. }
  1098. return ai;
  1099. }
  1102. static u_char
  1103. DecodeASyncParams(u_char si2, u_char * p)
  1104. {
  1105. u_char info;
  1107. switch (p[5]) {
  1108. case 66: // 1200 bit/s
  1110. break; // si2 don't change
  1112. case 88: // 1200/75 bit/s
  1114. si2 += 1;
  1115. break;
  1116. case 87: // 75/1200 bit/s
  1118. si2 += 2;
  1119. break;
  1120. case 67: // 2400 bit/s
  1122. si2 += 3;
  1123. break;
  1124. case 69: // 4800 bit/s
  1126. si2 += 4;
  1127. break;
  1128. case 72: // 9600 bit/s
  1130. si2 += 5;
  1131. break;
  1132. case 73: // 14400 bit/s
  1134. si2 += 6;
  1135. break;
  1136. case 75: // 19200 bit/s
  1138. si2 += 7;
  1139. break;
  1140. }
  1142. info = p[7] & 0x7f;
  1143. if ((info & 16) && (!(info & 8))) // 7 data bits
  1145. si2 += 32; // else 8 data bits
  1147. if ((info & 96) == 96) // 2 stop bits
  1149. si2 += 16; // else 1 stop bit
  1151. if ((info & 2) && (!(info & 1))) // even parity
  1153. si2 += 8; // else no parity
  1155. return si2;
  1156. }
  1159. static u_char
  1160. DecodeSyncParams(u_char si2, u_char info)
  1161. {
  1162. info &= 0x7f;
  1163. switch (info) {
  1164. case 40: // bit/s negotiation failed  ai := 165 not 175!
  1166. return si2 + 15;
  1167. case 15: // 56000 bit/s failed, ai := 0 not 169 !
  1169. return si2 + 9;
  1170. case 14: // 48000 bit/s
  1172. return si2 + 8;
  1173. case 11: // 19200 bit/s
  1175. return si2 + 7;
  1176. case 9: // 14400 bit/s
  1178. return si2 + 6;
  1179. case 8: // 9600  bit/s
  1181. return si2 + 5;
  1182. case 5: // 4800  bit/s
  1184. return si2 + 4;
  1185. case 3: // 2400  bit/s
  1187. return si2 + 3;
  1188. case 23: // 75/1200 bit/s
  1190. return si2 + 2;
  1191. case 24: // 1200/75 bit/s
  1193. return si2 + 1;
  1194. default: // 1200 bit/s
  1196. return si2;
  1197. }
  1198. }
  1200. static u_char
  1201. DecodeSI2(struct sk_buff *skb)
  1202. {
  1203. u_char *p; //, *pend=skb->data + skb->len;
  1205. if ((p = findie(skb->data, skb->len, 0x7c, 0))) {
  1206. switch (p[4] & 0x0f) {
  1207. case 0x01:
  1208. if (p[1] == 0x04) // sync. Bitratenadaption
  1210. return DecodeSyncParams(160, p[5]); // V.110/X.30
  1212. else if (p[1] == 0x06) // async. Bitratenadaption
  1214. return DecodeASyncParams(192, p); // V.110/X.30
  1216. break;
  1217. case 0x08: // if (p[5] == 0x02) // sync. Bitratenadaption
  1218. if (p[1] > 3) 
  1219. return DecodeSyncParams(176, p[5]); // V.120
  1220. break;
  1221. }
  1222. }
  1223. return 0;
  1224. }
  1226. #endif
  1229. static void
  1230. l3dss1_setup_req(struct l3_process *pc, u_char pr,
  1231.  void *arg)
  1232. {
  1233. struct sk_buff *skb;
  1234. u_char tmp[128];
  1235. u_char *p = tmp;
  1236. u_char channel = 0;
  1238.         u_char send_keypad;
  1239. u_char screen = 0x80;
  1240. u_char *teln;
  1241. u_char *msn;
  1242. u_char *sub;
  1243. u_char *sp;
  1244. int l;
  1246. MsgHead(p, pc->callref, MT_SETUP);
  1248. teln = pc->para.setup.phone;
  1249. #ifndef CONFIG_HISAX_NO_KEYPAD
  1250.         send_keypad = (strchr(teln,'*') || strchr(teln,'#')) ? 1 : 0; 
  1251. #else
  1252. send_keypad = 0;
  1253. #endif
  1254. #ifndef CONFIG_HISAX_NO_SENDCOMPLETE
  1255. if (!send_keypad)
  1256. *p++ = 0xa1; /* complete indicator */
  1257. #endif
  1258. /*
  1259.  * Set Bearer Capability, Map info from 1TR6-convention to EDSS1
  1260.  */
  1261. switch (pc->para.setup.si1) {
  1262. case 1:                   /* Telephony                                */
  1263. *p++ = IE_BEARER;
  1264. *p++ = 0x3;   /* Length                                   */
  1265. *p++ = 0x90;   /* Coding Std. CCITT, 3.1 kHz audio         */
  1266. *p++ = 0x90;   /* Circuit-Mode 64kbps                      */
  1267. *p++ = 0xa3;   /* A-Law Audio                              */
  1268. break;
  1269. case 5:                   /* Datatransmission 64k, BTX                */
  1270. case 7:                   /* Datatransmission 64k                     */
  1271. default:
  1272. *p++ = IE_BEARER;
  1273. *p++ = 0x2;   /* Length                                   */
  1274. *p++ = 0x88;   /* Coding Std. CCITT, unrestr. dig. Inform. */
  1275. *p++ = 0x90;   /* Circuit-Mode 64kbps                      */
  1276. break;
  1277. }
  1279. if (send_keypad) {
  1280. *p++ = IE_KEYPAD;
  1281. *p++ = strlen(teln);
  1282. while (*teln)
  1283. *p++ = (*teln++) & 0x7F;
  1284. }
  1285.   
  1286. /*
  1287.  * What about info2? Mapping to High-Layer-Compatibility?
  1288.  */
  1289. if ((*teln) && (!send_keypad)) {
  1290. /* parse number for special things */
  1291. if (!isdigit(*teln)) {
  1292. switch (0x5f & *teln) {
  1293. case 'C':
  1294. channel = 0x08;
  1295. case 'P':
  1296. channel |= 0x80;
  1297. teln++;
  1298. if (*teln == '1')
  1299. channel |= 0x01;
  1300. else
  1301. channel |= 0x02;
  1302. break;
  1303. case 'R':
  1304. screen = 0xA0;
  1305. break;
  1306. case 'D':
  1307. screen = 0x80;
  1308. break;
  1310.         default:
  1311. if (pc->debug & L3_DEB_WARN)
  1312. l3_debug(pc->st, "Wrong MSN Code");
  1313. break;
  1314. }
  1315. teln++;
  1316. }
  1317. }
  1318. if (channel) {
  1319. *p++ = IE_CHANNEL_ID;
  1320. *p++ = 1;
  1321. *p++ = channel;
  1322. }
  1323. msn = pc->para.setup.eazmsn;
  1324. sub = NULL;
  1325. sp = msn;
  1326. while (*sp) {
  1327. if ('.' == *sp) {
  1328. sub = sp;
  1329. *sp = 0;
  1330. } else
  1331. sp++;
  1332. }
  1333. if (*msn) {
  1334. *p++ = IE_CALLING_PN;
  1335. *p++ = strlen(msn) + (screen ? 2 : 1);
  1336. /* Classify as AnyPref. */
  1337. if (screen) {
  1338. *p++ = 0x01; /* Ext = '0'B, Type = '000'B, Plan = '0001'B. */
  1339. *p++ = screen;
  1340. } else
  1341. *p++ = 0x81; /* Ext = '1'B, Type = '000'B, Plan = '0001'B. */
  1342. while (*msn)
  1343. *p++ = *msn++ & 0x7f;
  1344. }
  1345. if (sub) {
  1346. *sub++ = '.';
  1347. *p++ = IE_CALLING_SUB;
  1348. *p++ = strlen(sub) + 2;
  1349. *p++ = 0x80; /* NSAP coded */
  1350. *p++ = 0x50; /* local IDI format */
  1351. while (*sub)
  1352. *p++ = *sub++ & 0x7f;
  1353. }
  1354. sub = NULL;
  1355. sp = teln;
  1356. while (*sp) {
  1357. if ('.' == *sp) {
  1358. sub = sp;
  1359. *sp = 0;
  1360. } else
  1361. sp++;
  1362. }
  1364.         if (!send_keypad) {      
  1365. *p++ = IE_CALLED_PN;
  1366. *p++ = strlen(teln) + 1;
  1367. /* Classify as AnyPref. */
  1368. *p++ = 0x81; /* Ext = '1'B, Type = '000'B, Plan = '0001'B. */
  1369. while (*teln)
  1370. *p++ = *teln++ & 0x7f;
  1372. if (sub) {
  1373. *sub++ = '.';
  1374. *p++ = IE_CALLED_SUB;
  1375. *p++ = strlen(sub) + 2;
  1376. *p++ = 0x80; /* NSAP coded */
  1377. *p++ = 0x50; /* local IDI format */
  1378. while (*sub)
  1379. *p++ = *sub++ & 0x7f;
  1380. }
  1381.         }
  1382. #if EXT_BEARER_CAPS
  1383. if ((pc->para.setup.si2 >= 160) && (pc->para.setup.si2 <= 175)) { // sync. Bitratenadaption, V.110/X.30
  1385. *p++ = IE_LLC;
  1386. *p++ = 0x04;
  1387. *p++ = 0x88;
  1388. *p++ = 0x90;
  1389. *p++ = 0x21;
  1390. *p++ = EncodeSyncParams(pc->para.setup.si2 - 160, 0x80);
  1391. } else if ((pc->para.setup.si2 >= 176) && (pc->para.setup.si2 <= 191)) { // sync. Bitratenadaption, V.120
  1393. *p++ = IE_LLC;
  1394. *p++ = 0x05;
  1395. *p++ = 0x88;
  1396. *p++ = 0x90;
  1397. *p++ = 0x28;
  1398. *p++ = EncodeSyncParams(pc->para.setup.si2 - 176, 0);
  1399. *p++ = 0x82;
  1400. } else if (pc->para.setup.si2 >= 192) { // async. Bitratenadaption, V.110/X.30
  1402. *p++ = IE_LLC;
  1403. *p++ = 0x06;
  1404. *p++ = 0x88;
  1405. *p++ = 0x90;
  1406. *p++ = 0x21;
  1407. p = EncodeASyncParams(p, pc->para.setup.si2 - 192);
  1408. #ifndef CONFIG_HISAX_NO_LLC
  1409. } else {
  1410.   switch (pc->para.setup.si1) {
  1411. case 1:                 /* Telephony                                */
  1412. *p++ = IE_LLC;
  1413. *p++ = 0x3; /* Length                                   */
  1414. *p++ = 0x90; /* Coding Std. CCITT, 3.1 kHz audio         */
  1415. *p++ = 0x90; /* Circuit-Mode 64kbps                      */
  1416. *p++ = 0xa3; /* A-Law Audio                              */
  1417. break;
  1418. case 5:                 /* Datatransmission 64k, BTX                */
  1419. case 7:                 /* Datatransmission 64k                     */
  1420. default:
  1421. *p++ = IE_LLC;
  1422. *p++ = 0x2; /* Length                                   */
  1423. *p++ = 0x88; /* Coding Std. CCITT, unrestr. dig. Inform. */
  1424. *p++ = 0x90; /* Circuit-Mode 64kbps                      */
  1425. break;
  1426.   }
  1427. #endif
  1428. }
  1429. #endif
  1430. l = p - tmp;
  1431. if (!(skb = l3_alloc_skb(l)))
  1432. return;
  1433. memcpy(skb_put(skb, l), tmp, l);
  1434. L3DelTimer(&pc->timer);
  1435. L3AddTimer(&pc->timer, T303, CC_T303);
  1436. newl3state(pc, 1);
  1437. l3_msg(pc->st, DL_DATA | REQUEST, skb);
  1438. }
  1440. static void
  1441. l3dss1_call_proc(struct l3_process *pc, u_char pr, void *arg)
  1442. {
  1443. struct sk_buff *skb = arg;
  1444. int id, ret;
  1446. if ((id = l3dss1_get_channel_id(pc, skb)) >= 0) {
  1447. if ((0 == id) || ((3 == id) && (0x10 == pc->para.moderate))) {
  1448. if (pc->debug & L3_DEB_WARN)
  1449. l3_debug(pc->st, "setup answer with wrong chid %x", id);
  1450. pc->para.cause = 100;
  1451. l3dss1_status_send(pc, pr, NULL);
  1452. return;
  1453. }
  1454. pc->para.bchannel = id;
  1455. } else if (1 == pc->state) {
  1456. if (pc->debug & L3_DEB_WARN)
  1457. l3_debug(pc->st, "setup answer wrong chid (ret %d)", id);
  1458. if (id == -1)
  1459. pc->para.cause = 96;
  1460. else
  1461. pc->para.cause = 100;
  1462. l3dss1_status_send(pc, pr, NULL);
  1463. return;
  1464. }
  1465. /* Now we are on none mandatory IEs */
  1466. ret = check_infoelements(pc, skb, ie_CALL_PROCEEDING);
  1467. if (ERR_IE_COMPREHENSION == ret) {
  1468. l3dss1_std_ie_err(pc, ret);
  1469. return;
  1470. }
  1471. L3DelTimer(&pc->timer);
  1472. newl3state(pc, 3);
  1473. L3AddTimer(&pc->timer, T310, CC_T310);
  1474. if (ret) /* STATUS for none mandatory IE errors after actions are taken */
  1475. l3dss1_std_ie_err(pc, ret);
  1476. pc->st->l3.l3l4(pc->st, CC_PROCEEDING | INDICATION, pc);
  1477. }
  1479. static void
  1480. l3dss1_setup_ack(struct l3_process *pc, u_char pr, void *arg)
  1481. {
  1482. struct sk_buff *skb = arg;
  1483. int id, ret;
  1485. if ((id = l3dss1_get_channel_id(pc, skb)) >= 0) {
  1486. if ((0 == id) || ((3 == id) && (0x10 == pc->para.moderate))) {
  1487. if (pc->debug & L3_DEB_WARN)
  1488. l3_debug(pc->st, "setup answer with wrong chid %x", id);
  1489. pc->para.cause = 100;
  1490. l3dss1_status_send(pc, pr, NULL);
  1491. return;
  1492. }
  1493. pc->para.bchannel = id;
  1494. } else {
  1495. if (pc->debug & L3_DEB_WARN)
  1496. l3_debug(pc->st, "setup answer wrong chid (ret %d)", id);
  1497. if (id == -1)
  1498. pc->para.cause = 96;
  1499. else
  1500. pc->para.cause = 100;
  1501. l3dss1_status_send(pc, pr, NULL);
  1502. return;
  1503. }
  1504. /* Now we are on none mandatory IEs */
  1505. ret = check_infoelements(pc, skb, ie_SETUP_ACKNOWLEDGE);
  1506. if (ERR_IE_COMPREHENSION == ret) {
  1507. l3dss1_std_ie_err(pc, ret);
  1508. return;
  1509. }
  1510. L3DelTimer(&pc->timer);
  1511. newl3state(pc, 2);
  1512. L3AddTimer(&pc->timer, T304, CC_T304);
  1513. if (ret) /* STATUS for none mandatory IE errors after actions are taken */
  1514. l3dss1_std_ie_err(pc, ret);
  1515. pc->st->l3.l3l4(pc->st, CC_MORE_INFO | INDICATION, pc);
  1516. }
  1518. static void
  1519. l3dss1_disconnect(struct l3_process *pc, u_char pr, void *arg)
  1520. {
  1521. struct sk_buff *skb = arg;
  1522. u_char *p;
  1523. int ret;
  1524. u_char cause = 0;
  1526. StopAllL3Timer(pc);
  1527. if ((ret = l3dss1_get_cause(pc, skb))) {
  1528. if (pc->debug & L3_DEB_WARN)
  1529. l3_debug(pc->st, "DISC get_cause ret(%d)", ret);
  1530. if (ret < 0)
  1531. cause = 96;
  1532. else if (ret > 0)
  1533. cause = 100;
  1534. } 
  1535. if ((p = findie(skb->data, skb->len, IE_FACILITY, 0)))
  1536. l3dss1_parse_facility(pc->st, pc, pc->callref, p);
  1537. ret = check_infoelements(pc, skb, ie_DISCONNECT);
  1538. if (ERR_IE_COMPREHENSION == ret)
  1539. cause = 96;
  1540. else if ((!cause) && (ERR_IE_UNRECOGNIZED == ret))
  1541. cause = 99;
  1542. ret = pc->state;
  1543. newl3state(pc, 12);
  1544. if (cause)
  1545. newl3state(pc, 19);
  1546.         if (11 != ret)
  1547. pc->st->l3.l3l4(pc->st, CC_DISCONNECT | INDICATION, pc);
  1548.         else if (!cause)
  1549.    l3dss1_release_req(pc, pr, NULL);
  1550. if (cause) {
  1551. l3dss1_message_cause(pc, MT_RELEASE, cause);
  1552. L3AddTimer(&pc->timer, T308, CC_T308_1);
  1553. }
  1554. }
  1556. static void
  1557. l3dss1_connect(struct l3_process *pc, u_char pr, void *arg)
  1558. {
  1559. struct sk_buff *skb = arg;
  1560. int ret;
  1562. ret = check_infoelements(pc, skb, ie_CONNECT);
  1563. if (ERR_IE_COMPREHENSION == ret) {
  1564. l3dss1_std_ie_err(pc, ret);
  1565. return;
  1566. }
  1567. L3DelTimer(&pc->timer); /* T310 */
  1568. newl3state(pc, 10);
  1569. pc->para.chargeinfo = 0;
  1570. /* here should inserted COLP handling KKe */
  1571. if (ret)
  1572. l3dss1_std_ie_err(pc, ret);
  1573. pc->st->l3.l3l4(pc->st, CC_SETUP | CONFIRM, pc);
  1574. }
  1576. static void
  1577. l3dss1_alerting(struct l3_process *pc, u_char pr, void *arg)
  1578. {
  1579. struct sk_buff *skb = arg;
  1580. int ret;
  1582. ret = check_infoelements(pc, skb, ie_ALERTING);
  1583. if (ERR_IE_COMPREHENSION == ret) {
  1584. l3dss1_std_ie_err(pc, ret);
  1585. return;
  1586. }
  1587. L3DelTimer(&pc->timer); /* T304 */
  1588. newl3state(pc, 4);
  1589. if (ret)
  1590. l3dss1_std_ie_err(pc, ret);
  1591. pc->st->l3.l3l4(pc->st, CC_ALERTING | INDICATION, pc);
  1592. }
  1594. static void
  1595. l3dss1_setup(struct l3_process *pc, u_char pr, void *arg)
  1596. {
  1597. u_char *p;
  1598. int bcfound = 0;
  1599. char tmp[80];
  1600. struct sk_buff *skb = arg;
  1601. int id;
  1602. int err = 0;
  1604. /*
  1605.  * Bearer Capabilities
  1606.  */
  1607. p = skb->data;
  1608. /* only the first occurence 'll be detected ! */
  1609. if ((p = findie(p, skb->len, 0x04, 0))) {
  1610. if ((p[1] < 2) || (p[1] > 11))
  1611. err = 1;
  1612. else {
  1613. pc->para.setup.si2 = 0;
  1614. switch (p[2] & 0x7f) {
  1615. case 0x00: /* Speech */
  1616. case 0x10: /* 3.1 Khz audio */
  1617. pc->para.setup.si1 = 1;
  1618. break;
  1619. case 0x08: /* Unrestricted digital information */
  1620. pc->para.setup.si1 = 7;
  1621. /* JIM, 05.11.97 I wanna set service indicator 2 */
  1622. #if EXT_BEARER_CAPS
  1623. pc->para.setup.si2 = DecodeSI2(skb);
  1624. #endif
  1625. break;
  1626. case 0x09: /* Restricted digital information */
  1627. pc->para.setup.si1 = 2;
  1628. break;
  1629. case 0x11:
  1630. /* Unrestr. digital information  with 
  1631.  * tones/announcements ( or 7 kHz audio
  1632.  */
  1633. pc->para.setup.si1 = 3;
  1634. break;
  1635. case 0x18: /* Video */
  1636. pc->para.setup.si1 = 4;
  1637. break;
  1638. default:
  1639. err = 2;
  1640. break;
  1641. }
  1642. switch (p[3] & 0x7f) {
  1643. case 0x40: /* packed mode */
  1644. pc->para.setup.si1 = 8;
  1645. break;
  1646. case 0x10: /* 64 kbit */
  1647. case 0x11: /* 2*64 kbit */
  1648. case 0x13: /* 384 kbit */
  1649. case 0x15: /* 1536 kbit */
  1650. case 0x17: /* 1920 kbit */
  1651. pc->para.moderate = p[3] & 0x7f;
  1652. break;
  1653. default:
  1654. err = 3;
  1655. break;
  1656. }
  1657. }
  1658. if (pc->debug & L3_DEB_SI)
  1659. l3_debug(pc->st, "SI=%d, AI=%d",
  1660. pc->para.setup.si1, pc->para.setup.si2);
  1661. if (err) {
  1662. if (pc->debug & L3_DEB_WARN)
  1663. l3_debug(pc->st, "setup with wrong bearer(l=%d:%x,%x)",
  1664. p[1], p[2], p[3]);
  1665. pc->para.cause = 100;
  1666. l3dss1_msg_without_setup(pc, pr, NULL);
  1667. return;
  1668. }
  1669. } else {
  1670. if (pc->debug & L3_DEB_WARN)
  1671. l3_debug(pc->st, "setup without bearer capabilities");
  1672. /* ETS 300-104 1.3.3 */
  1673. pc->para.cause = 96;
  1674. l3dss1_msg_without_setup(pc, pr, NULL);
  1675. return;
  1676. }
  1677. /*
  1678.  * Channel Identification
  1679.  */
  1680. if ((id = l3dss1_get_channel_id(pc, skb)) >= 0) {
  1681. if ((pc->para.bchannel = id)) {
  1682. if ((3 == id) && (0x10 == pc->para.moderate)) {
  1683. if (pc->debug & L3_DEB_WARN)
  1684. l3_debug(pc->st, "setup with wrong chid %x",
  1685. id);
  1686. pc->para.cause = 100;
  1687. l3dss1_msg_without_setup(pc, pr, NULL);
  1688. return;
  1689. }
  1690. bcfound++;
  1691. } else 
  1692.                    { if (pc->debug & L3_DEB_WARN)
  1693.  l3_debug(pc->st, "setup without bchannel, call waiting");
  1694.                      bcfound++;
  1695.                    } 
  1696. } else {
  1697. if (pc->debug & L3_DEB_WARN)
  1698. l3_debug(pc->st, "setup with wrong chid ret %d", id);
  1699. if (id == -1)
  1700. pc->para.cause = 96;
  1701. else
  1702. pc->para.cause = 100;
  1703. l3dss1_msg_without_setup(pc, pr, NULL);
  1704. return;
  1705. }
  1706. /* Now we are on none mandatory IEs */
  1707. err = check_infoelements(pc, skb, ie_SETUP);
  1708. if (ERR_IE_COMPREHENSION == err) {
  1709. pc->para.cause = 96;
  1710. l3dss1_msg_without_setup(pc, pr, NULL);
  1711. return;
  1712. }
  1713. p = skb->data;
  1714. if ((p = findie(p, skb->len, 0x70, 0)))
  1715. iecpy(pc->para.setup.eazmsn, p, 1);
  1716. else
  1717. pc->para.setup.eazmsn[0] = 0;
  1719. p = skb->data;
  1720. if ((p = findie(p, skb->len, 0x71, 0))) {
  1721. /* Called party subaddress */
  1722. if ((p[1] >= 2) && (p[2] == 0x80) && (p[3] == 0x50)) {
  1723. tmp[0] = '.';
  1724. iecpy(&tmp[1], p, 2);
  1725. strcat(pc->para.setup.eazmsn, tmp);
  1726. } else if (pc->debug & L3_DEB_WARN)
  1727. l3_debug(pc->st, "wrong called subaddress");
  1728. }
  1729. p = skb->data;
  1730. if ((p = findie(p, skb->len, 0x6c, 0))) {
  1731. pc->para.setup.plan = p[2];
  1732. if (p[2] & 0x80) {
  1733. iecpy(pc->para.setup.phone, p, 1);
  1734. pc->para.setup.screen = 0;
  1735. } else {
  1736. iecpy(pc->para.setup.phone, p, 2);
  1737. pc->para.setup.screen = p[3];
  1738. }
  1739. } else {
  1740. pc->para.setup.phone[0] = 0;
  1741. pc->para.setup.plan = 0;
  1742. pc->para.setup.screen = 0;
  1743. }
  1744. p = skb->data;
  1745. if ((p = findie(p, skb->len, 0x6d, 0))) {
  1746. /* Calling party subaddress */
  1747. if ((p[1] >= 2) && (p[2] == 0x80) && (p[3] == 0x50)) {
  1748. tmp[0] = '.';
  1749. iecpy(&tmp[1], p, 2);
  1750. strcat(pc->para.setup.phone, tmp);
  1751. } else if (pc->debug & L3_DEB_WARN)
  1752. l3_debug(pc->st, "wrong calling subaddress");
  1753. }
  1754. newl3state(pc, 6);
  1755. if (err) /* STATUS for none mandatory IE errors after actions are taken */
  1756. l3dss1_std_ie_err(pc, err);
  1757. pc->st->l3.l3l4(pc->st, CC_SETUP | INDICATION, pc);
  1758. }
  1760. static void
  1761. l3dss1_reset(struct l3_process *pc, u_char pr, void *arg)
  1762. {
  1763. dss1_release_l3_process(pc);
  1764. }
  1766. static void
  1767. l3dss1_disconnect_req(struct l3_process *pc, u_char pr, void *arg)
  1768. {
  1769. struct sk_buff *skb;
  1770. u_char tmp[16+40];
  1771. u_char *p = tmp;
  1772. int l;
  1773. u_char cause = 16;
  1775. if (pc->para.cause != NO_CAUSE)
  1776. cause = pc->para.cause;
  1778. StopAllL3Timer(pc);
  1780. MsgHead(p, pc->callref, MT_DISCONNECT);
  1782. *p++ = IE_CAUSE;
  1783. *p++ = 0x2;
  1784. *p++ = 0x80;
  1785. *p++ = cause | 0x80;
  1787.         if (pc->prot.dss1.uus1_data[0])
  1788.  { *p++ = IE_USER_USER; /* UUS info element */
  1789.            *p++ = strlen(pc->prot.dss1.uus1_data) + 1;
  1790.            *p++ = 0x04; /* IA5 chars */
  1791.            strcpy(p,pc->prot.dss1.uus1_data);
  1792.            p += strlen(pc->prot.dss1.uus1_data);
  1793.            pc->prot.dss1.uus1_data[0] = '';   
  1794.          } 
  1796. l = p - tmp;
  1797. if (!(skb = l3_alloc_skb(l)))
  1798. return;
  1799. memcpy(skb_put(skb, l), tmp, l);
  1800. newl3state(pc, 11);
  1801. l3_msg(pc->st, DL_DATA | REQUEST, skb);
  1802. L3AddTimer(&pc->timer, T305, CC_T305);
  1803. }
  1805. static void
  1806. l3dss1_setup_rsp(struct l3_process *pc, u_char pr,
  1807.  void *arg)
  1808. {
  1809.         if (!pc->para.bchannel) 
  1810.  { if (pc->debug & L3_DEB_WARN)
  1811.        l3_debug(pc->st, "D-chan connect for waiting call");
  1812.            l3dss1_disconnect_req(pc, pr, arg);
  1813.            return;
  1814.          }
  1815. newl3state(pc, 8);
  1816. l3dss1_message(pc, MT_CONNECT);
  1817. L3DelTimer(&pc->timer);
  1818. L3AddTimer(&pc->timer, T313, CC_T313);
  1819. }
  1821. static void
  1822. l3dss1_connect_ack(struct l3_process *pc, u_char pr, void *arg)
  1823. {
  1824. struct sk_buff *skb = arg;
  1825. int ret;
  1827. ret = check_infoelements(pc, skb, ie_CONNECT_ACKNOWLEDGE);
  1828. if (ERR_IE_COMPREHENSION == ret) {
  1829. l3dss1_std_ie_err(pc, ret);
  1830. return;
  1831. }
  1832. newl3state(pc, 10);
  1833. L3DelTimer(&pc->timer);
  1834. if (ret)
  1835. l3dss1_std_ie_err(pc, ret);
  1836. pc->st->l3.l3l4(pc->st, CC_SETUP_COMPL | INDICATION, pc);
  1837. }
  1839. static void
  1840. l3dss1_reject_req(struct l3_process *pc, u_char pr, void *arg)
  1841. {
  1842. struct sk_buff *skb;
  1843. u_char tmp[16];
  1844. u_char *p = tmp;
  1845. int l;
  1846. u_char cause = 21;
  1848. if (pc->para.cause != NO_CAUSE)
  1849. cause = pc->para.cause;
  1851. MsgHead(p, pc->callref, MT_RELEASE_COMPLETE);
  1853. *p++ = IE_CAUSE;
  1854. *p++ = 0x2;
  1855. *p++ = 0x80;
  1856. *p++ = cause | 0x80;
  1858. l = p - tmp;
  1859. if (!(skb = l3_alloc_skb(l)))
  1860. return;
  1861. memcpy(skb_put(skb, l), tmp, l);
  1862. l3_msg(pc->st, DL_DATA | REQUEST, skb);
  1863. pc->st->l3.l3l4(pc->st, CC_RELEASE | INDICATION, pc);
  1864. newl3state(pc, 0);
  1865. dss1_release_l3_process(pc);
  1866. }
  1868. static void
  1869. l3dss1_release(struct l3_process *pc, u_char pr, void *arg)
  1870. {
  1871. struct sk_buff *skb = arg;
  1872. u_char *p;
  1873. int ret, cause=0;
  1875. StopAllL3Timer(pc);
  1876. if ((ret = l3dss1_get_cause(pc, skb))>0) {
  1877. if (pc->debug & L3_DEB_WARN)
  1878. l3_debug(pc->st, "REL get_cause ret(%d)", ret);
  1879. } else if (ret<0)
  1880. pc->para.cause = NO_CAUSE;
  1881. if ((p = findie(skb->data, skb->len, IE_FACILITY, 0))) {
  1882. l3dss1_parse_facility(pc->st, pc, pc->callref, p);
  1883. }
  1884. if ((ret<0) && (pc->state != 11))
  1885. cause = 96;
  1886. else if (ret>0)
  1887. cause = 100;
  1888. ret = check_infoelements(pc, skb, ie_RELEASE);
  1889. if (ERR_IE_COMPREHENSION == ret)
  1890. cause = 96;
  1891. else if ((ERR_IE_UNRECOGNIZED == ret) && (!cause))
  1892. cause = 99;  
  1893. if (cause)
  1894. l3dss1_message_cause(pc, MT_RELEASE_COMPLETE, cause);
  1895. else
  1896. l3dss1_message(pc, MT_RELEASE_COMPLETE);
  1897. pc->st->l3.l3l4(pc->st, CC_RELEASE | INDICATION, pc);
  1898. newl3state(pc, 0);
  1899. dss1_release_l3_process(pc);
  1900. }
  1902. static void
  1903. l3dss1_alert_req(struct l3_process *pc, u_char pr,
  1904.  void *arg)
  1905. {
  1906. newl3state(pc, 7);
  1907. if (!pc->prot.dss1.uus1_data[0]) 
  1908. l3dss1_message(pc, MT_ALERTING);
  1909. else
  1910. l3dss1_msg_with_uus(pc, MT_ALERTING); 
  1911. }
  1913. static void
  1914. l3dss1_proceed_req(struct l3_process *pc, u_char pr,
  1915.    void *arg)
  1916. {
  1917. newl3state(pc, 9);
  1918. l3dss1_message(pc, MT_CALL_PROCEEDING);
  1919. pc->st->l3.l3l4(pc->st, CC_PROCEED_SEND | INDICATION, pc); 
  1920. }
  1922. static void
  1923. l3dss1_setup_ack_req(struct l3_process *pc, u_char pr,
  1924.    void *arg)
  1925. {
  1926. newl3state(pc, 25);
  1927. L3DelTimer(&pc->timer);
  1928. L3AddTimer(&pc->timer, T302, CC_T302);
  1929. l3dss1_message(pc, MT_SETUP_ACKNOWLEDGE);
  1930. }
  1932. /********************************************/
  1933. /* deliver a incoming display message to HL */
  1934. /********************************************/
  1935. static void
  1936. l3dss1_deliver_display(struct l3_process *pc, int pr, u_char *infp)
  1937. {       u_char len;
  1938.         isdn_ctrl ic; 
  1939. struct IsdnCardState *cs;
  1940.         char *p; 
  1942.         if (*infp++ != IE_DISPLAY) return;
  1943.         if ((len = *infp++) > 80) return; /* total length <= 82 */
  1944. if (!pc->chan) return;
  1946. p = ic.parm.display; 
  1947.         while (len--)
  1948.   *p++ = *infp++;
  1949. *p = '';
  1950. ic.command = ISDN_STAT_DISPLAY;
  1951. cs = pc->st->l1.hardware;
  1952. ic.driver = cs->myid;
  1953. ic.arg = pc->chan->chan; 
  1954. cs->iif.statcallb(&ic);
  1955. } /* l3dss1_deliver_display */
  1958. static void
  1959. l3dss1_progress(struct l3_process *pc, u_char pr, void *arg)
  1960. {
  1961. struct sk_buff *skb = arg;
  1962. int err = 0;
  1963. u_char *p;
  1965. if ((p = findie(skb->data, skb->len, IE_PROGRESS, 0))) {
  1966. if (p[1] != 2) {
  1967. err = 1;
  1968. pc->para.cause = 100;
  1969. } else if (!(p[2] & 0x70)) {
  1970. switch (p[2]) {
  1971. case 0x80:
  1972. case 0x81:
  1973. case 0x82:
  1974. case 0x84:
  1975. case 0x85:
  1976. case 0x87:
  1977. case 0x8a:
  1978. switch (p[3]) {
  1979. case 0x81:
  1980. case 0x82:
  1981. case 0x83:
  1982. case 0x84:
  1983. case 0x88:
  1984. break;
  1985. default:
  1986. err = 2;
  1987. pc->para.cause = 100;
  1988. break;
  1989. }
  1990. break;
  1991. default:
  1992. err = 3;
  1993. pc->para.cause = 100;
  1994. break;
  1995. }
  1996. }
  1997. } else {
  1998. pc->para.cause = 96;
  1999. err = 4;
  2000. }
  2001. if (err) {
  2002. if (pc->debug & L3_DEB_WARN)
  2003. l3_debug(pc->st, "progress error %d", err);
  2004. l3dss1_status_send(pc, pr, NULL);
  2005. return;
  2006. }
  2007. /* Now we are on none mandatory IEs */
  2008. err = check_infoelements(pc, skb, ie_PROGRESS);
  2009. if (err)
  2010. l3dss1_std_ie_err(pc, err);
  2011. if (ERR_IE_COMPREHENSION != err)
  2012. pc->st->l3.l3l4(pc->st, CC_PROGRESS | INDICATION, pc);
  2013. }
  2015. static void
  2016. l3dss1_notify(struct l3_process *pc, u_char pr, void *arg)
  2017. {
  2018. struct sk_buff *skb = arg;
  2019. int err = 0;
  2020. u_char *p;
  2022. if ((p = findie(skb->data, skb->len, IE_NOTIFY, 0))) {
  2023. if (p[1] != 1) {
  2024. err = 1;
  2025. pc->para.cause = 100;
  2026. } else {
  2027. switch (p[2]) {
  2028. case 0x80:
  2029. case 0x81:
  2030. case 0x82:
  2031. break;
  2032. default:
  2033. pc->para.cause = 100;
  2034. err = 2;
  2035. break;
  2036. }
  2037. }
  2038. } else {
  2039. pc->para.cause = 96;
  2040. err = 3;
  2041. }
  2042. if (err) {
  2043. if (pc->debug & L3_DEB_WARN)
  2044. l3_debug(pc->st, "notify error %d", err);
  2045. l3dss1_status_send(pc, pr, NULL);
  2046. return;
  2047. }
  2048. /* Now we are on none mandatory IEs */
  2049. err = check_infoelements(pc, skb, ie_NOTIFY);
  2050. if (err)
  2051. l3dss1_std_ie_err(pc, err);
  2052. if (ERR_IE_COMPREHENSION != err)
  2053. pc->st->l3.l3l4(pc->st, CC_NOTIFY | INDICATION, pc);
  2054. }
  2056. static void
  2057. l3dss1_status_enq(struct l3_process *pc, u_char pr, void *arg)
  2058. {
  2059. int ret;
  2060. struct sk_buff *skb = arg;
  2062. ret = check_infoelements(pc, skb, ie_STATUS_ENQUIRY);
  2063. l3dss1_std_ie_err(pc, ret);
  2064. pc->para.cause = 30; /* response to STATUS_ENQUIRY */
  2065.         l3dss1_status_send(pc, pr, NULL);
  2066. }
  2068. static void
  2069. l3dss1_information(struct l3_process *pc, u_char pr, void *arg)
  2070. {
  2071. int ret;
  2072. struct sk_buff *skb = arg;
  2073. u_char *p;
  2074. char tmp[32];
  2076. ret = check_infoelements(pc, skb, ie_INFORMATION);
  2077. if (ret)
  2078. l3dss1_std_ie_err(pc, ret);
  2079. if (pc->state == 25) { /* overlap receiving */
  2080. L3DelTimer(&pc->timer);
  2081. p = skb->data;
  2082. if ((p = findie(p, skb->len, 0x70, 0))) {
  2083. iecpy(tmp, p, 1);
  2084. strcat(pc->para.setup.eazmsn, tmp);
  2085. pc->st->l3.l3l4(pc->st, CC_MORE_INFO | INDICATION, pc);
  2086. }
  2087. L3AddTimer(&pc->timer, T302, CC_T302);
  2088. }
  2089. }
  2091. /******************************/
  2092. /* handle deflection requests */
  2093. /******************************/
  2094. static void l3dss1_redir_req(struct l3_process *pc, u_char pr, void *arg)
  2095. {
  2096. struct sk_buff *skb;
  2097. u_char tmp[128];
  2098. u_char *p = tmp;
  2099.         u_char *subp;
  2100.         u_char len_phone = 0;
  2101.         u_char len_sub = 0;
  2102. int l; 
  2105.         strcpy(pc->prot.dss1.uus1_data,pc->chan->setup.eazmsn); /* copy uus element if available */
  2106.         if (!pc->chan->setup.phone[0])
  2107.           { pc->para.cause = -1;
  2108.             l3dss1_disconnect_req(pc,pr,arg); /* disconnect immediately */
  2109.             return;
  2110.           } /* only uus */
  2111.  
  2112.         if (pc->prot.dss1.invoke_id) 
  2113.           free_invoke_id(pc->st,pc->prot.dss1.invoke_id);
  2114.  
  2115.         if (!(pc->prot.dss1.invoke_id = new_invoke_id(pc->st))) 
  2116.           return;
  2118.         MsgHead(p, pc->callref, MT_FACILITY);
  2120.         for (subp = pc->chan->setup.phone; (*subp) && (*subp != '.'); subp++) len_phone++; /* len of phone number */
  2121.         if (*subp++ == '.') len_sub = strlen(subp) + 2; /* length including info subaddress element */ 
  2123. *p++ = 0x1c;   /* Facility info element */
  2124.         *p++ = len_phone + len_sub + 2 + 2 + 8 + 3 + 3; /* length of element */
  2125.         *p++ = 0x91;  /* remote operations protocol */
  2126.         *p++ = 0xa1;  /* invoke component */
  2127.   
  2128.         *p++ = len_phone + len_sub + 2 + 2 + 8 + 3; /* length of data */
  2129.         *p++ = 0x02;  /* invoke id tag, integer */
  2130. *p++ = 0x01;  /* length */
  2131.         *p++ = pc->prot.dss1.invoke_id;  /* invoke id */ 
  2132.         *p++ = 0x02;  /* operation value tag, integer */
  2133. *p++ = 0x01;  /* length */
  2134.         *p++ = 0x0D;  /* Call Deflect */
  2135.   
  2136.         *p++ = 0x30;  /* sequence phone number */
  2137.         *p++ = len_phone + 2 + 2 + 3 + len_sub; /* length */
  2138.   
  2139.         *p++ = 0x30;  /* Deflected to UserNumber */
  2140.         *p++ = len_phone+2+len_sub; /* length */
  2141.         *p++ = 0x80; /* NumberDigits */
  2142. *p++ = len_phone; /* length */
  2143.         for (l = 0; l < len_phone; l++)
  2144.  *p++ = pc->chan->setup.phone[l];
  2146.         if (len_sub)
  2147.   { *p++ = 0x04; /* called party subaddress */
  2148.             *p++ = len_sub - 2;
  2149.             while (*subp) *p++ = *subp++;
  2150.           }
  2152.         *p++ = 0x01; /* screening identifier */
  2153.         *p++ = 0x01;
  2154.         *p++ = pc->chan->setup.screen;
  2156. l = p - tmp;
  2157. if (!(skb = l3_alloc_skb(l))) return;
  2158. memcpy(skb_put(skb, l), tmp, l);
  2160.         l3_msg(pc->st, DL_DATA | REQUEST, skb);
  2161. } /* l3dss1_redir_req */
  2163. /********************************************/
  2164. /* handle deflection request in early state */
  2165. /********************************************/
  2166. static void l3dss1_redir_req_early(struct l3_process *pc, u_char pr, void *arg)
  2167. {
  2168.   l3dss1_proceed_req(pc,pr,arg);
  2169.   l3dss1_redir_req(pc,pr,arg);
  2170. } /* l3dss1_redir_req_early */
  2172. /***********************************************/
  2173. /* handle special commands for this protocol.  */
  2174. /* Examples are call independant services like */
  2175. /* remote operations with dummy  callref.      */
  2176. /***********************************************/
  2177. static int l3dss1_cmd_global(struct PStack *st, isdn_ctrl *ic)
  2178. { u_char id;
  2179.   u_char temp[265];
  2180.   u_char *p = temp;
  2181.   int i, l, proc_len; 
  2182.   struct sk_buff *skb;
  2183.   struct l3_process *pc = NULL;
  2185.   switch (ic->arg)
  2186.    { case DSS1_CMD_INVOKE:
  2187.        if (ic->parm.dss1_io.datalen < 0) return(-2); /* invalid parameter */ 
  2189.        for (proc_len = 1, i = ic->parm.dss1_io.proc >> 8; i; i++) 
  2190.          i = i >> 8; /* add one byte */    
  2191.        l = ic->parm.dss1_io.datalen + proc_len + 8; /* length excluding ie header */
  2192.        if (l > 255) 
  2193.          return(-2); /* too long */
  2195.        if (!(id = new_invoke_id(st))) 
  2196.          return(0); /* first get a invoke id -> return if no available */
  2197.        
  2198.        i = -1; 
  2199.        MsgHead(p, i, MT_FACILITY); /* build message head */
  2200.        *p++ = 0x1C; /* Facility IE */
  2201.        *p++ = l; /* length of ie */
  2202.        *p++ = 0x91; /* remote operations */
  2203.        *p++ = 0xA1; /* invoke */
  2204.        *p++ = l - 3; /* length of invoke */
  2205.        *p++ = 0x02; /* invoke id tag */
  2206.        *p++ = 0x01; /* length is 1 */
  2207.        *p++ = id; /* invoke id */
  2208.        *p++ = 0x02; /* operation */
  2209.        *p++ = proc_len; /* length of operation */
  2210.        
  2211.        for (i = proc_len; i; i--)
  2212.          *p++ = (ic->parm.dss1_io.proc >> (i-1)) & 0xFF;
  2213.        memcpy(p, ic->parm.dss1_io.data, ic->parm.dss1_io.datalen); /* copy data */
  2214.        l = (p - temp) + ic->parm.dss1_io.datalen; /* total length */         
  2216.        if (ic->parm.dss1_io.timeout > 0)
  2217.         if (!(pc = dss1_new_l3_process(st, -1)))
  2218.           { free_invoke_id(st, id);
  2219.             return(-2);
  2220.           } 
  2221.        pc->prot.dss1.ll_id = ic->parm.dss1_io.ll_id; /* remember id */ 
  2222.        pc->prot.dss1.proc = ic->parm.dss1_io.proc; /* and procedure */
  2224.        if (!(skb = l3_alloc_skb(l))) 
  2225.          { free_invoke_id(st, id);
  2226.            if (pc) dss1_release_l3_process(pc);
  2227.            return(-2);
  2228.          }
  2229.        memcpy(skb_put(skb, l), temp, l);
  2230.        
  2231.        if (pc)
  2232.         { pc->prot.dss1.invoke_id = id; /* remember id */
  2233.           L3AddTimer(&pc->timer, ic->parm.dss1_io.timeout, CC_TDSS1_IO | REQUEST);
  2234.         }
  2235.        
  2236.        l3_msg(st, DL_DATA | REQUEST, skb);
  2237.        ic->parm.dss1_io.hl_id = id; /* return id */
  2238.        return(0);
  2240.      case DSS1_CMD_INVOKE_ABORT:
  2241.        if ((pc = l3dss1_search_dummy_proc(st, ic->parm.dss1_io.hl_id)))
  2242. { L3DelTimer(&pc->timer); /* remove timer */
  2243.           dss1_release_l3_process(pc);
  2244.           return(0); 
  2245.         } 
  2246.        else
  2247. { l3_debug(st, "l3dss1_cmd_global abort unknown id");
  2248.           return(-2);
  2249.         } 
  2250.        break;
  2251.     
  2252.      default: 
  2253.        l3_debug(st, "l3dss1_cmd_global unknown cmd 0x%lx", ic->arg);
  2254.        return(-1);  
  2255.    } /* switch ic-> arg */
  2256.   return(-1);
  2257. } /* l3dss1_cmd_global */
  2259. static void 
  2260. l3dss1_io_timer(struct l3_process *pc)
  2261. { isdn_ctrl ic;
  2262.   struct IsdnCardState *cs = pc->st->l1.hardware;
  2264.   L3DelTimer(&pc->timer); /* remove timer */
  2266.   ic.driver = cs->myid;
  2267.   ic.command = ISDN_STAT_PROT;
  2268.   ic.arg = DSS1_STAT_INVOKE_ERR;
  2269.   ic.parm.dss1_io.hl_id = pc->prot.dss1.invoke_id;
  2270.   ic.parm.dss1_io.ll_id = pc->prot.dss1.ll_id;
  2271.   ic.parm.dss1_io.proc = pc->prot.dss1.proc;
  2272.   ic.parm.dss1_io.timeout= -1;
  2273.   ic.parm.dss1_io.datalen = 0;
  2274.   ic.parm.dss1_io.data = NULL;
  2275.   free_invoke_id(pc->st, pc->prot.dss1.invoke_id);
  2276.   pc->prot.dss1.invoke_id = 0; /* reset id */
  2278.   cs->iif.statcallb(&ic);
  2280.   dss1_release_l3_process(pc); 
  2281. } /* l3dss1_io_timer */
  2283. static void
  2284. l3dss1_release_ind(struct l3_process *pc, u_char pr, void *arg)
  2285. {
  2286. u_char *p;
  2287. struct sk_buff *skb = arg;
  2288. int callState = 0;
  2289. p = skb->data;
  2291. if ((p = findie(p, skb->len, IE_CALL_STATE, 0))) {
  2292. p++;
  2293. if (1 == *p++)
  2294. callState = *p;
  2295. }
  2296. if (callState == 0) {
  2297. /* ETS 300-104 7.6.1, 8.6.1, 10.6.1... and 16.1
  2298.  * set down layer 3 without sending any message
  2299.  */
  2300. pc->st->l3.l3l4(pc->st, CC_RELEASE | INDICATION, pc);
  2301. newl3state(pc, 0);
  2302. dss1_release_l3_process(pc);
  2303. } else {
  2304. pc->st->l3.l3l4(pc->st, CC_IGNORE | INDICATION, pc);
  2305. }
  2306. }
  2308. static void
  2309. l3dss1_dummy(struct l3_process *pc, u_char pr, void *arg)
  2310. {
  2311. }
  2313. static void
  2314. l3dss1_t302(struct l3_process *pc, u_char pr, void *arg)
  2315. {
  2316. L3DelTimer(&pc->timer);
  2317. pc->para.loc = 0;
  2318. pc->para.cause = 28; /* invalid number */
  2319. l3dss1_disconnect_req(pc, pr, NULL);
  2320. pc->st->l3.l3l4(pc->st, CC_SETUP_ERR, pc);
  2321. }
  2323. static void
  2324. l3dss1_t303(struct l3_process *pc, u_char pr, void *arg)
  2325. {
  2326. if (pc->N303 > 0) {
  2327. pc->N303--;
  2328. L3DelTimer(&pc->timer);
  2329. l3dss1_setup_req(pc, pr, arg);
  2330. } else {
  2331. L3DelTimer(&pc->timer);
  2332. l3dss1_message_cause(pc, MT_RELEASE_COMPLETE, 102);
  2333. pc->st->l3.l3l4(pc->st, CC_NOSETUP_RSP, pc);
  2334. dss1_release_l3_process(pc);
  2335. }
  2336. }
  2338. static void
  2339. l3dss1_t304(struct l3_process *pc, u_char pr, void *arg)
  2340. {
  2341. L3DelTimer(&pc->timer);
  2342. pc->para.loc = 0;
  2343. pc->para.cause = 102;
  2344. l3dss1_disconnect_req(pc, pr, NULL);
  2345. pc->st->l3.l3l4(pc->st, CC_SETUP_ERR, pc);
  2347. }
  2349. static void
  2350. l3dss1_t305(struct l3_process *pc, u_char pr, void *arg)
  2351. {
  2352. u_char tmp[16];
  2353. u_char *p = tmp;
  2354. int l;
  2355. struct sk_buff *skb;
  2356. u_char cause = 16;
  2358. L3DelTimer(&pc->timer);
  2359. if (pc->para.cause != NO_CAUSE)
  2360. cause = pc->para.cause;
  2362. MsgHead(p, pc->callref, MT_RELEASE);
  2364. *p++ = IE_CAUSE;
  2365. *p++ = 0x2;
  2366. *p++ = 0x80;
  2367. *p++ = cause | 0x80;
  2369. l = p - tmp;
  2370. if (!(skb = l3_alloc_skb(l)))
  2371. return;
  2372. memcpy(skb_put(skb, l), tmp, l);
  2373. newl3state(pc, 19);
  2374. l3_msg(pc->st, DL_DATA | REQUEST, skb);
  2375. L3AddTimer(&pc->timer, T308, CC_T308_1);
  2376. }
  2378. static void
  2379. l3dss1_t310(struct l3_process *pc, u_char pr, void *arg)
  2380. {
  2381. L3DelTimer(&pc->timer);
  2382. pc->para.loc = 0;
  2383. pc->para.cause = 102;
  2384. l3dss1_disconnect_req(pc, pr, NULL);
  2385. pc->st->l3.l3l4(pc->st, CC_SETUP_ERR, pc);
  2386. }
  2388. static void
  2389. l3dss1_t313(struct l3_process *pc, u_char pr, void *arg)
  2390. {
  2391. L3DelTimer(&pc->timer);
  2392. pc->para.loc = 0;
  2393. pc->para.cause = 102;
  2394. l3dss1_disconnect_req(pc, pr, NULL);
  2395. pc->st->l3.l3l4(pc->st, CC_CONNECT_ERR, pc);
  2396. }
  2398. static void
  2399. l3dss1_t308_1(struct l3_process *pc, u_char pr, void *arg)
  2400. {
  2401. newl3state(pc, 19);
  2402. L3DelTimer(&pc->timer);
  2403. l3dss1_message(pc, MT_RELEASE);
  2404. L3AddTimer(&pc->timer, T308, CC_T308_2);
  2405. }
  2407. static void
  2408. l3dss1_t308_2(struct l3_process *pc, u_char pr, void *arg)
  2409. {
  2410. L3DelTimer(&pc->timer);
  2411. pc->st->l3.l3l4(pc->st, CC_RELEASE_ERR, pc);
  2412. dss1_release_l3_process(pc);
  2413. }
  2415. static void
  2416. l3dss1_t318(struct l3_process *pc, u_char pr, void *arg)
  2417. {
  2418. L3DelTimer(&pc->timer);
  2419. pc->para.cause = 102; /* Timer expiry */
  2420. pc->para.loc = 0; /* local */
  2421. pc->st->l3.l3l4(pc->st, CC_RESUME_ERR, pc);
  2422. newl3state(pc, 19);
  2423. l3dss1_message(pc, MT_RELEASE);
  2424. L3AddTimer(&pc->timer, T308, CC_T308_1);
  2425. }
  2427. static void
  2428. l3dss1_t319(struct l3_process *pc, u_char pr, void *arg)
  2429. {
  2430. L3DelTimer(&pc->timer);
  2431. pc->para.cause = 102; /* Timer expiry */
  2432. pc->para.loc = 0; /* local */
  2433. pc->st->l3.l3l4(pc->st, CC_SUSPEND_ERR, pc);
  2434. newl3state(pc, 10);
  2435. }
  2437. static void
  2438. l3dss1_restart(struct l3_process *pc, u_char pr, void *arg)
  2439. {
  2440. L3DelTimer(&pc->timer);
  2441. pc->st->l3.l3l4(pc->st, CC_RELEASE | INDICATION, pc);
  2442. dss1_release_l3_process(pc);
  2443. }
  2445. static void
  2446. l3dss1_status(struct l3_process *pc, u_char pr, void *arg)
  2447. {
  2448. u_char *p;
  2449. struct sk_buff *skb = arg;
  2450. int ret; 
  2451. u_char cause = 0, callState = 0;
  2453. if ((ret = l3dss1_get_cause(pc, skb))) {
  2454. if (pc->debug & L3_DEB_WARN)
  2455. l3_debug(pc->st, "STATUS get_cause ret(%d)",ret);
  2456. if (ret < 0)
  2457. cause = 96;
  2458. else if (ret > 0)
  2459. cause = 100;
  2460. }
  2461. if ((p = findie(skb->data, skb->len, IE_CALL_STATE, 0))) {
  2462. p++;
  2463. if (1 == *p++) {
  2464. callState = *p;
  2465. if (!ie_in_set(pc, *p, l3_valid_states))
  2466. cause = 100;
  2467. } else
  2468. cause = 100;
  2469. } else
  2470. cause = 96;
  2471. if (!cause) { /*  no error before */
  2472. ret = check_infoelements(pc, skb, ie_STATUS);
  2473. if (ERR_IE_COMPREHENSION == ret)
  2474. cause = 96;
  2475. else if (ERR_IE_UNRECOGNIZED == ret)
  2476. cause = 99;
  2477. }
  2478. if (cause) {
  2479. u_char tmp;
  2481. if (pc->debug & L3_DEB_WARN)
  2482. l3_debug(pc->st, "STATUS error(%d/%d)",ret,cause);
  2483. tmp = pc->para.cause;
  2484. pc->para.cause = cause;
  2485. l3dss1_status_send(pc, 0, NULL);
  2486. if (cause == 99)
  2487. pc->para.cause = tmp;
  2488. else
  2489. return;
  2490. }
  2491. cause = pc->para.cause;
  2492. if (((cause & 0x7f) == 111) && (callState == 0)) {
  2493. /* ETS 300-104 7.6.1, 8.6.1, 10.6.1...
  2494.  * if received MT_STATUS with cause == 111 and call
  2495.  * state == 0, then we must set down layer 3
  2496.  */
  2497. pc->st->l3.l3l4(pc->st, CC_RELEASE | INDICATION, pc);
  2498. newl3state(pc, 0);
  2499. dss1_release_l3_process(pc);
  2500. }
  2501. }
  2503. static void
  2504. l3dss1_facility(struct l3_process *pc, u_char pr, void *arg)
  2505. {
  2506. struct sk_buff *skb = arg;
  2507. int ret;
  2509. ret = check_infoelements(pc, skb, ie_FACILITY);
  2510. l3dss1_std_ie_err(pc, ret);
  2511.     {
  2512. u_char *p;
  2513. if ((p = findie(skb->data, skb->len, IE_FACILITY, 0)))
  2514. l3dss1_parse_facility(pc->st, pc, pc->callref, p);
  2515. }
  2516. }
  2518. static void
  2519. l3dss1_suspend_req(struct l3_process *pc, u_char pr, void *arg)
  2520. {
  2521. struct sk_buff *skb;
  2522. u_char tmp[32];
  2523. u_char *p = tmp;
  2524. u_char i, l;
  2525. u_char *msg = pc->chan->setup.phone;
  2527. MsgHead(p, pc->callref, MT_SUSPEND);
  2528. l = *msg++;
  2529. if (l && (l <= 10)) { /* Max length 10 octets */
  2530. *p++ = IE_CALL_ID;
  2531. *p++ = l;
  2532. for (i = 0; i < l; i++)
  2533. *p++ = *msg++;
  2534. } else if (l) {
  2535. l3_debug(pc->st, "SUS wrong CALL_ID len %d", l);
  2536. return;
  2537. }
  2538. l = p - tmp;
  2539. if (!(skb = l3_alloc_skb(l)))
  2540. return;
  2541. memcpy(skb_put(skb, l), tmp, l);
  2542. l3_msg(pc->st, DL_DATA | REQUEST, skb);
  2543. newl3state(pc, 15);
  2544. L3AddTimer(&pc->timer, T319, CC_T319);
  2545. }
  2547. static void
  2548. l3dss1_suspend_ack(struct l3_process *pc, u_char pr, void *arg)
  2549. {
  2550. struct sk_buff *skb = arg;
  2551. int ret;
  2553. L3DelTimer(&pc->timer);
  2554. newl3state(pc, 0);
  2555. pc->para.cause = NO_CAUSE;
  2556. pc->st->l3.l3l4(pc->st, CC_SUSPEND | CONFIRM, pc);
  2557. /* We don't handle suspend_ack for IE errors now */
  2558. if ((ret = check_infoelements(pc, skb, ie_SUSPEND_ACKNOWLEDGE)))
  2559. if (pc->debug & L3_DEB_WARN)
  2560. l3_debug(pc->st, "SUSPACK check ie(%d)",ret);
  2561. dss1_release_l3_process(pc);
  2562. }
  2564. static void
  2565. l3dss1_suspend_rej(struct l3_process *pc, u_char pr, void *arg)
  2566. {
  2567. struct sk_buff *skb = arg;
  2568. int ret;
  2570. if ((ret = l3dss1_get_cause(pc, skb))) {
  2571. if (pc->debug & L3_DEB_WARN)
  2572. l3_debug(pc->st, "SUSP_REJ get_cause ret(%d)",ret);
  2573. if (ret < 0) 
  2574. pc->para.cause = 96;
  2575. else
  2576. pc->para.cause = 100;
  2577. l3dss1_status_send(pc, pr, NULL);
  2578. return;
  2579. }
  2580. ret = check_infoelements(pc, skb, ie_SUSPEND_REJECT);
  2581. if (ERR_IE_COMPREHENSION == ret) {
  2582. l3dss1_std_ie_err(pc, ret);
  2583. return;
  2584. }
  2585. L3DelTimer(&pc->timer);
  2586. pc->st->l3.l3l4(pc->st, CC_SUSPEND_ERR, pc);
  2587. newl3state(pc, 10);
  2588. if (ret) /* STATUS for none mandatory IE errors after actions are taken */
  2589. l3dss1_std_ie_err(pc, ret);
  2590. }
  2592. static void
  2593. l3dss1_resume_req(struct l3_process *pc, u_char pr, void *arg)
  2594. {
  2595. struct sk_buff *skb;
  2596. u_char tmp[32];
  2597. u_char *p = tmp;
  2598. u_char i, l;
  2599. u_char *msg = pc->para.setup.phone;
  2601. MsgHead(p, pc->callref, MT_RESUME);
  2603. l = *msg++;
  2604. if (l && (l <= 10)) { /* Max length 10 octets */
  2605. *p++ = IE_CALL_ID;
  2606. *p++ = l;
  2607. for (i = 0; i < l; i++)
  2608. *p++ = *msg++;
  2609. } else if (l) {
  2610. l3_debug(pc->st, "RES wrong CALL_ID len %d", l);
  2611. return;
  2612. }
  2613. l = p - tmp;
  2614. if (!(skb = l3_alloc_skb(l)))
  2615. return;
  2616. memcpy(skb_put(skb, l), tmp, l);
  2617. l3_msg(pc->st, DL_DATA | REQUEST, skb);
  2618. newl3state(pc, 17);
  2619. L3AddTimer(&pc->timer, T318, CC_T318);
  2620. }
  2622. static void
  2623. l3dss1_resume_ack(struct l3_process *pc, u_char pr, void *arg)
  2624. {
  2625. struct sk_buff *skb = arg;
  2626. int id, ret;
  2628. if ((id = l3dss1_get_channel_id(pc, skb)) > 0) {
  2629. if ((0 == id) || ((3 == id) && (0x10 == pc->para.moderate))) {
  2630. if (pc->debug & L3_DEB_WARN)
  2631. l3_debug(pc->st, "resume ack with wrong chid %x", id);
  2632. pc->para.cause = 100;
  2633. l3dss1_status_send(pc, pr, NULL);
  2634. return;
  2635. }
  2636. pc->para.bchannel = id;
  2637. } else if (1 == pc->state) {
  2638. if (pc->debug & L3_DEB_WARN)
  2639. l3_debug(pc->st, "resume ack without chid (ret %d)", id);
  2640. pc->para.cause = 96;
  2641. l3dss1_status_send(pc, pr, NULL);
  2642. return;
  2643. }
  2644. ret = check_infoelements(pc, skb, ie_RESUME_ACKNOWLEDGE);
  2645. if (ERR_IE_COMPREHENSION == ret) {
  2646. l3dss1_std_ie_err(pc, ret);
  2647. return;
  2648. }
  2649. L3DelTimer(&pc->timer);
  2650. pc->st->l3.l3l4(pc->st, CC_RESUME | CONFIRM, pc);
  2651. newl3state(pc, 10);
  2652. if (ret) /* STATUS for none mandatory IE errors after actions are taken */
  2653. l3dss1_std_ie_err(pc, ret);
  2654. }
  2656. static void
  2657. l3dss1_resume_rej(struct l3_process *pc, u_char pr, void *arg)
  2658. {
  2659. struct sk_buff *skb = arg;
  2660. int ret;
  2662. if ((ret = l3dss1_get_cause(pc, skb))) {
  2663. if (pc->debug & L3_DEB_WARN)
  2664. l3_debug(pc->st, "RES_REJ get_cause ret(%d)",ret);
  2665. if (ret < 0) 
  2666. pc->para.cause = 96;
  2667. else
  2668. pc->para.cause = 100;
  2669. l3dss1_status_send(pc, pr, NULL);
  2670. return;
  2671. }
  2672. ret = check_infoelements(pc, skb, ie_RESUME_REJECT);
  2673. if (ERR_IE_COMPREHENSION == ret) {
  2674. l3dss1_std_ie_err(pc, ret);
  2675. return;
  2676. }
  2677. L3DelTimer(&pc->timer);
  2678. pc->st->l3.l3l4(pc->st, CC_RESUME_ERR, pc);
  2679. newl3state(pc, 0);
  2680. if (ret) /* STATUS for none mandatory IE errors after actions are taken */
  2681. l3dss1_std_ie_err(pc, ret);
  2682. dss1_release_l3_process(pc);
  2683. }
  2685. static void
  2686. l3dss1_global_restart(struct l3_process *pc, u_char pr, void *arg)
  2687. {
  2688. u_char tmp[32];
  2689. u_char *p;
  2690. u_char ri, ch = 0, chan = 0;
  2691. int l;
  2692. struct sk_buff *skb = arg;
  2693. struct l3_process *up;
  2695. newl3state(pc, 2);
  2696. L3DelTimer(&pc->timer);
  2697. p = skb->data;
  2698. if ((p = findie(p, skb->len, IE_RESTART_IND, 0))) {
  2699. ri = p[2];
  2700. l3_debug(pc->st, "Restart %x", ri);
  2701. } else {
  2702. l3_debug(pc->st, "Restart without restart IE");
  2703. ri = 0x86;
  2704. }
  2705. p = skb->data;
  2706. if ((p = findie(p, skb->len, IE_CHANNEL_ID, 0))) {
  2707. chan = p[2] & 3;
  2708. ch = p[2];
  2709. if (pc->st->l3.debug)
  2710. l3_debug(pc->st, "Restart for channel %d", chan);
  2711. }
  2712. newl3state(pc, 2);
  2713. up = pc->st->l3.proc;
  2714. while (up) {
  2715. if ((ri & 7) == 7)
  2716. up->st->lli.l4l3(up->st, CC_RESTART | REQUEST, up);
  2717. else if (up->para.bchannel == chan)
  2718. up->st->lli.l4l3(up->st, CC_RESTART | REQUEST, up);
  2719. up = up->next;
  2720. }
  2721. p = tmp;
  2722. MsgHead(p, pc->callref, MT_RESTART_ACKNOWLEDGE);
  2723. if (chan) {
  2724. *p++ = IE_CHANNEL_ID;
  2725. *p++ = 1;
  2726. *p++ = ch | 0x80;
  2727. }
  2728. *p++ = 0x79; /* RESTART Ind */
  2729. *p++ = 1;
  2730. *p++ = ri;
  2731. l = p - tmp;
  2732. if (!(skb = l3_alloc_skb(l)))
  2733. return;
  2734. memcpy(skb_put(skb, l), tmp, l);
  2735. newl3state(pc, 0);
  2736. l3_msg(pc->st, DL_DATA | REQUEST, skb);
  2737. }
  2739. static void
  2740. l3dss1_dl_reset(struct l3_process *pc, u_char pr, void *arg)
  2741. {
  2742.         pc->para.cause = 0x29;          /* Temporary failure */
  2743.         pc->para.loc = 0;
  2744.         l3dss1_disconnect_req(pc, pr, NULL);
  2745.         pc->st->l3.l3l4(pc->st, CC_SETUP_ERR, pc);
  2746. }
  2748. static void
  2749. l3dss1_dl_release(struct l3_process *pc, u_char pr, void *arg)
  2750. {
  2751.         newl3state(pc, 0);
  2752.         pc->para.cause = 0x1b;          /* Destination out of order */
  2753.         pc->para.loc = 0;
  2754.         pc->st->l3.l3l4(pc->st, CC_RELEASE | INDICATION, pc);
  2755.         release_l3_process(pc);
  2756. }
  2758. static void
  2759. l3dss1_dl_reestablish(struct l3_process *pc, u_char pr, void *arg)
  2760. {
  2761.         L3DelTimer(&pc->timer);
  2762.         L3AddTimer(&pc->timer, T309, CC_T309);
  2763.         l3_msg(pc->st, DL_ESTABLISH | REQUEST, NULL);
  2764. }
  2765.  
  2766. static void
  2767. l3dss1_dl_reest_status(struct l3_process *pc, u_char pr, void *arg)
  2768. {
  2769. L3DelTimer(&pc->timer);
  2770.  
  2771.   pc->para.cause = 0x1F; /* normal, unspecified */
  2772. l3dss1_status_send(pc, 0, NULL);
  2773. }
  2775. /* *INDENT-OFF* */
  2776. static struct stateentry downstatelist[] =
  2777. {
  2778. {SBIT(0),
  2779.  CC_SETUP | REQUEST, l3dss1_setup_req},
  2780. {SBIT(0),
  2781.  CC_RESUME | REQUEST, l3dss1_resume_req},
  2782. {SBIT(1) | SBIT(2) | SBIT(3) | SBIT(4) | SBIT(6) | SBIT(7) | SBIT(8) | SBIT(9) | SBIT(10) | SBIT(25),
  2783.  CC_DISCONNECT | REQUEST, l3dss1_disconnect_req},
  2784. {SBIT(12),
  2785.  CC_RELEASE | REQUEST, l3dss1_release_req},
  2786. {ALL_STATES,
  2787.  CC_RESTART | REQUEST, l3dss1_restart},
  2788. {SBIT(6) | SBIT(25),
  2789.  CC_IGNORE | REQUEST, l3dss1_reset},
  2790. {SBIT(6) | SBIT(25),
  2791.  CC_REJECT | REQUEST, l3dss1_reject_req},
  2792. {SBIT(6) | SBIT(25),
  2793.  CC_PROCEED_SEND | REQUEST, l3dss1_proceed_req},
  2794. {SBIT(6),
  2795.  CC_MORE_INFO | REQUEST, l3dss1_setup_ack_req},
  2796. {SBIT(25),
  2797.  CC_MORE_INFO | REQUEST, l3dss1_dummy},
  2798. {SBIT(6) | SBIT(9) | SBIT(25),
  2799.  CC_ALERTING | REQUEST, l3dss1_alert_req},
  2800. {SBIT(6) | SBIT(7) | SBIT(9) | SBIT(25),
  2801.  CC_SETUP | RESPONSE, l3dss1_setup_rsp},
  2802. {SBIT(10),
  2803.  CC_SUSPEND | REQUEST, l3dss1_suspend_req},
  2804.         {SBIT(7) | SBIT(9) | SBIT(25),
  2805.          CC_REDIR | REQUEST, l3dss1_redir_req},
  2806.         {SBIT(6),
  2807.          CC_REDIR | REQUEST, l3dss1_redir_req_early},
  2808.         {SBIT(9) | SBIT(25),
  2809.          CC_DISCONNECT | REQUEST, l3dss1_disconnect_req},
  2810. {SBIT(25),
  2811.  CC_T302, l3dss1_t302},
  2812. {SBIT(1),
  2813.  CC_T303, l3dss1_t303},
  2814. {SBIT(2),
  2815.  CC_T304, l3dss1_t304},
  2816. {SBIT(3),
  2817.  CC_T310, l3dss1_t310},
  2818. {SBIT(8),
  2819.  CC_T313, l3dss1_t313},
  2820. {SBIT(11),
  2821.  CC_T305, l3dss1_t305},
  2822. {SBIT(15),
  2823.  CC_T319, l3dss1_t319},
  2824. {SBIT(17),
  2825.  CC_T318, l3dss1_t318},
  2826. {SBIT(19),
  2827.  CC_T308_1, l3dss1_t308_1},
  2828. {SBIT(19),
  2829.  CC_T308_2, l3dss1_t308_2},
  2830. {SBIT(10),
  2831.  CC_T309, l3dss1_dl_release},
  2832. };
  2834. #define DOWNSLLEN 
  2835. (sizeof(downstatelist) / sizeof(struct stateentry))
  2837. static struct stateentry datastatelist[] =
  2838. {
  2839. {ALL_STATES,
  2840.  MT_STATUS_ENQUIRY, l3dss1_status_enq},
  2841. {ALL_STATES,
  2842.  MT_FACILITY, l3dss1_facility},
  2843. {SBIT(19),
  2844.  MT_STATUS, l3dss1_release_ind},
  2845. {ALL_STATES,
  2846.  MT_STATUS, l3dss1_status},
  2847. {SBIT(0),
  2848.  MT_SETUP, l3dss1_setup},
  2849. {SBIT(6) | SBIT(7) | SBIT(8) | SBIT(9) | SBIT(10) | SBIT(11) | SBIT(12) |
  2850.  SBIT(15) | SBIT(17) | SBIT(19) | SBIT(25),
  2851.  MT_SETUP, l3dss1_dummy},
  2852. {SBIT(1) | SBIT(2),
  2853.  MT_CALL_PROCEEDING, l3dss1_call_proc},
  2854. {SBIT(1),
  2855.  MT_SETUP_ACKNOWLEDGE, l3dss1_setup_ack},
  2856. {SBIT(2) | SBIT(3),
  2857.  MT_ALERTING, l3dss1_alerting},
  2858. {SBIT(2) | SBIT(3),
  2859.  MT_PROGRESS, l3dss1_progress},
  2860. {SBIT(2) | SBIT(3) | SBIT(4) | SBIT(7) | SBIT(8) | SBIT(9) | SBIT(10) |
  2861.  SBIT(11) | SBIT(12) | SBIT(15) | SBIT(17) | SBIT(19) | SBIT(25),
  2862.  MT_INFORMATION, l3dss1_information},
  2863. {SBIT(10) | SBIT(11) | SBIT(15),
  2864.  MT_NOTIFY, l3dss1_notify},
  2865. {SBIT(0) | SBIT(1) | SBIT(2) | SBIT(3) | SBIT(4) | SBIT(7) | SBIT(8) | SBIT(10) |
  2866.  SBIT(11) | SBIT(12) | SBIT(15) | SBIT(17) | SBIT(19) | SBIT(25),
  2867.  MT_RELEASE_COMPLETE, l3dss1_release_cmpl},
  2868. {SBIT(1) | SBIT(2) | SBIT(3) | SBIT(4) | SBIT(7) | SBIT(8) | SBIT(9) | SBIT(10) | SBIT(11) | SBIT(12) | SBIT(15) | SBIT(17) | SBIT(25),
  2869.  MT_RELEASE, l3dss1_release},
  2870. {SBIT(19),  MT_RELEASE, l3dss1_release_ind},
  2871. {SBIT(1) | SBIT(2) | SBIT(3) | SBIT(4) | SBIT(7) | SBIT(8) | SBIT(9) | SBIT(10) | SBIT(11) | SBIT(15) | SBIT(17) | SBIT(25),
  2872.  MT_DISCONNECT, l3dss1_disconnect},
  2873. {SBIT(19),
  2874.  MT_DISCONNECT, l3dss1_dummy},
  2875. {SBIT(1) | SBIT(2) | SBIT(3) | SBIT(4),
  2876.  MT_CONNECT, l3dss1_connect},
  2877. {SBIT(8),
  2878.  MT_CONNECT_ACKNOWLEDGE, l3dss1_connect_ack},
  2879. {SBIT(15),
  2880.  MT_SUSPEND_ACKNOWLEDGE, l3dss1_suspend_ack},
  2881. {SBIT(15),
  2882.  MT_SUSPEND_REJECT, l3dss1_suspend_rej},
  2883. {SBIT(17),
  2884.  MT_RESUME_ACKNOWLEDGE, l3dss1_resume_ack},
  2885. {SBIT(17),
  2886.  MT_RESUME_REJECT, l3dss1_resume_rej},
  2887. };
  2889. #define DATASLLEN 
  2890. (sizeof(datastatelist) / sizeof(struct stateentry))
  2892. static struct stateentry globalmes_list[] =
  2893. {
  2894. {ALL_STATES,
  2895.  MT_STATUS, l3dss1_status},
  2896. {SBIT(0),
  2897.  MT_RESTART, l3dss1_global_restart},
  2898. /* {SBIT(1),
  2899.  MT_RESTART_ACKNOWLEDGE, l3dss1_restart_ack},
  2900. */
  2901. };
  2902. #define GLOBALM_LEN 
  2903. (sizeof(globalmes_list) / sizeof(struct stateentry))
  2905. static struct stateentry manstatelist[] =
  2906. {
  2907.         {SBIT(2),
  2908.          DL_ESTABLISH | INDICATION, l3dss1_dl_reset},
  2909.         {SBIT(10),
  2910.          DL_ESTABLISH | CONFIRM, l3dss1_dl_reest_status},
  2911.         {SBIT(10),
  2912.          DL_RELEASE | INDICATION, l3dss1_dl_reestablish},
  2913.         {ALL_STATES,
  2914.          DL_RELEASE | INDICATION, l3dss1_dl_release},
  2915. };
  2917. #define MANSLLEN 
  2918.         (sizeof(manstatelist) / sizeof(struct stateentry))
  2919. /* *INDENT-ON* */
  2922. static void
  2923. global_handler(struct PStack *st, int mt, struct sk_buff *skb)
  2924. {
  2925. u_char tmp[16];
  2926. u_char *p = tmp;
  2927. int l;
  2928. int i;
  2929. struct l3_process *proc = st->l3.global;
  2931. proc->callref = skb->data[2]; /* cr flag */
  2932. for (i = 0; i < GLOBALM_LEN; i++)
  2933. if ((mt == globalmes_list[i].primitive) &&
  2934.     ((1 << proc->state) & globalmes_list[i].state))
  2935. break;
  2936. if (i == GLOBALM_LEN) {
  2937. if (st->l3.debug & L3_DEB_STATE) {
  2938. l3_debug(st, "dss1 global state %d mt %x unhandled",
  2939. proc->state, mt);
  2940. }
  2941. MsgHead(p, proc->callref, MT_STATUS);
  2942. *p++ = IE_CAUSE;
  2943. *p++ = 0x2;
  2944. *p++ = 0x80;
  2945. *p++ = 81 |0x80; /* invalid cr */
  2946. *p++ = 0x14; /* CallState */
  2947. *p++ = 0x1;
  2948. *p++ = proc->state & 0x3f;
  2949. l = p - tmp;
  2950. if (!(skb = l3_alloc_skb(l)))
  2951. return;
  2952. memcpy(skb_put(skb, l), tmp, l);
  2953. l3_msg(proc->st, DL_DATA | REQUEST, skb);
  2954. } else {
  2955. if (st->l3.debug & L3_DEB_STATE) {
  2956. l3_debug(st, "dss1 global %d mt %x",
  2957. proc->state, mt);
  2958. }
  2959. globalmes_list[i].rout(proc, mt, skb);
  2960. }
  2961. }
  2963. static void
  2964. dss1up(struct PStack *st, int pr, void *arg)
  2965. {
  2966. int i, mt, cr, cause, callState;
  2967. char *ptr;
  2968. u_char *p;
  2969. struct sk_buff *skb = arg;
  2970. struct l3_process *proc;
  2972. switch (pr) {
  2973. case (DL_DATA | INDICATION):
  2974. case (DL_UNIT_DATA | INDICATION):
  2975. break;
  2976. case (DL_ESTABLISH | CONFIRM):
  2977. case (DL_ESTABLISH | INDICATION):
  2978. case (DL_RELEASE | INDICATION):
  2979. case (DL_RELEASE | CONFIRM):
  2980. l3_msg(st, pr, arg);
  2981. return;
  2982. break;
  2983.                 default:
  2984.                         printk(KERN_ERR "HiSax dss1up unknown pr=%04xn", pr);
  2985.                         return;
  2986. }
  2987. if (skb->len < 3) {
  2988. l3_debug(st, "dss1up frame too short(%d)", skb->len);
  2989. dev_kfree_skb(skb);
  2990. return;
  2991. }
  2993. if (skb->data[0] != PROTO_DIS_EURO) {
  2994. if (st->l3.debug & L3_DEB_PROTERR) {
  2995. l3_debug(st, "dss1up%sunexpected discriminator %x message len %d",
  2996.  (pr == (DL_DATA | INDICATION)) ? " " : "(broadcast) ",
  2997.  skb->data[0], skb->len);
  2998. }
  2999. dev_kfree_skb(skb);
  3000. return;
  3001. }
  3002. cr = getcallref(skb->data);
  3003. if (skb->len < ((skb->data[1] & 0x0f) + 3)) {
  3004. l3_debug(st, "dss1up frame too short(%d)", skb->len);
  3005. dev_kfree_skb(skb);
  3006. return;
  3007. }
  3008. mt = skb->data[skb->data[1] + 2];
  3009. if (st->l3.debug & L3_DEB_STATE)
  3010. l3_debug(st, "dss1up cr %d", cr);
  3011. if (cr == -2) {  /* wrong Callref */
  3012. if (st->l3.debug & L3_DEB_WARN)
  3013. l3_debug(st, "dss1up wrong Callref");
  3014. dev_kfree_skb(skb);
  3015. return;
  3016. } else if (cr == -1) { /* Dummy Callref */
  3017. if (mt == MT_FACILITY)
  3018. if ((p = findie(skb->data, skb->len, IE_FACILITY, 0))) {
  3019. l3dss1_parse_facility(st, NULL, 
  3020. (pr == (DL_DATA | INDICATION)) ? -1 : -2, p); 
  3021. dev_kfree_skb(skb);
  3022. return;  
  3023. }
  3024. if (st->l3.debug & L3_DEB_WARN)
  3025. l3_debug(st, "dss1up dummy Callref (no facility msg or ie)");
  3026. dev_kfree_skb(skb);
  3027. return;
  3028. } else if ((((skb->data[1] & 0x0f) == 1) && (0==(cr & 0x7f))) ||
  3029. (((skb->data[1] & 0x0f) == 2) && (0==(cr & 0x7fff)))) { /* Global CallRef */
  3030. if (st->l3.debug & L3_DEB_STATE)
  3031. l3_debug(st, "dss1up Global CallRef");
  3032. global_handler(st, mt, skb);
  3033. dev_kfree_skb(skb);
  3034. return;
  3035. } else if (!(proc = getl3proc(st, cr))) {
  3036. /* No transaction process exist, that means no call with
  3037.  * this callreference is active
  3038.  */
  3039. if (mt == MT_SETUP) {
  3040. /* Setup creates a new transaction process */
  3041. if (skb->data[2] & 0x80) {
  3042. /* Setup with wrong CREF flag */
  3043. if (st->l3.debug & L3_DEB_STATE)
  3044. l3_debug(st, "dss1up wrong CRef flag");
  3045. dev_kfree_skb(skb);
  3046. return;
  3047. }
  3048. if (!(proc = dss1_new_l3_process(st, cr))) {
  3049. /* May be to answer with RELEASE_COMPLETE and
  3050.  * CAUSE 0x2f "Resource unavailable", but this
  3051.  * need a new_l3_process too ... arghh
  3052.  */
  3053. dev_kfree_skb(skb);
  3054. return;
  3055. }
  3056. } else if (mt == MT_STATUS) {
  3057. cause = 0;
  3058. if ((ptr = findie(skb->data, skb->len, IE_CAUSE, 0)) != NULL) {
  3059. ptr++;
  3060. if (*ptr++ == 2)
  3061. ptr++;
  3062. cause = *ptr & 0x7f;
  3063. }
  3064. callState = 0;
  3065. if ((ptr = findie(skb->data, skb->len, IE_CALL_STATE, 0)) != NULL) {
  3066. ptr++;
  3067. if (*ptr++ == 2)
  3068. ptr++;
  3069. callState = *ptr;
  3070. }
  3071. /* ETS 300-104 part 2.4.1
  3072.  * if setup has not been made and a message type
  3073.  * MT_STATUS is received with call state == 0,
  3074.  * we must send nothing
  3075.  */
  3076. if (callState != 0) {
  3077. /* ETS 300-104 part 2.4.2
  3078.  * if setup has not been made and a message type
  3079.  * MT_STATUS is received with call state != 0,
  3080.  * we must send MT_RELEASE_COMPLETE cause 101
  3081.  */
  3082. if ((proc = dss1_new_l3_process(st, cr))) {
  3083. proc->para.cause = 101;
  3084. l3dss1_msg_without_setup(proc, 0, NULL);
  3085. }
  3086. }
  3087. dev_kfree_skb(skb);
  3088. return;
  3089. } else if (mt == MT_RELEASE_COMPLETE) {
  3090. dev_kfree_skb(skb);
  3091. return;
  3092. } else {
  3093. /* ETS 300-104 part 2
  3094.  * if setup has not been made and a message type
  3095.  * (except MT_SETUP and RELEASE_COMPLETE) is received,
  3096.  * we must send MT_RELEASE_COMPLETE cause 81 */
  3097. dev_kfree_skb(skb);
  3098. if ((proc = dss1_new_l3_process(st, cr))) {
  3099. proc->para.cause = 81;
  3100. l3dss1_msg_without_setup(proc, 0, NULL);
  3101. }
  3102. return;
  3103. }
  3104. }
  3105. if (l3dss1_check_messagetype_validity(proc, mt, skb)) {
  3106. dev_kfree_skb(skb);
  3107. return;
  3108. }
  3109. if ((p = findie(skb->data, skb->len, IE_DISPLAY, 0)) != NULL) 
  3110.   l3dss1_deliver_display(proc, pr, p); /* Display IE included */
  3111. for (i = 0; i < DATASLLEN; i++)
  3112. if ((mt == datastatelist[i].primitive) &&
  3113.     ((1 << proc->state) & datastatelist[i].state))
  3114. break;
  3115. if (i == DATASLLEN) {
  3116. if (st->l3.debug & L3_DEB_STATE) {
  3117. l3_debug(st, "dss1up%sstate %d mt %#x unhandled",
  3118. (pr == (DL_DATA | INDICATION)) ? " " : "(broadcast) ",
  3119. proc->state, mt);
  3120. }
  3121. if ((MT_RELEASE_COMPLETE != mt) && (MT_RELEASE != mt)) {
  3122. proc->para.cause = 101;
  3123. l3dss1_status_send(proc, pr, skb);
  3124. }
  3125. } else {
  3126. if (st->l3.debug & L3_DEB_STATE) {
  3127. l3_debug(st, "dss1up%sstate %d mt %x",
  3128. (pr == (DL_DATA | INDICATION)) ? " " : "(broadcast) ",
  3129. proc->state, mt);
  3130. }
  3131. datastatelist[i].rout(proc, pr, skb);
  3132. }
  3133. dev_kfree_skb(skb);
  3134. return;
  3135. }
  3137. static void
  3138. dss1down(struct PStack *st, int pr, void *arg)
  3139. {
  3140. int i, cr;
  3141. struct l3_process *proc;
  3142. struct Channel *chan;
  3144. if ((DL_ESTABLISH | REQUEST) == pr) {
  3145. l3_msg(st, pr, NULL);
  3146. return;
  3147. } else if (((CC_SETUP | REQUEST) == pr) || ((CC_RESUME | REQUEST) == pr)) {
  3148. chan = arg;
  3149. cr = newcallref();
  3150. cr |= 0x80;
  3151. if ((proc = dss1_new_l3_process(st, cr))) {
  3152. proc->chan = chan;
  3153. chan->proc = proc;
  3154. memcpy(&proc->para.setup, &chan->setup, sizeof(setup_parm));
  3155. proc->callref = cr;
  3156. }
  3157. } else {
  3158. proc = arg;
  3159. }
  3160. if (!proc) {
  3161. printk(KERN_ERR "HiSax dss1down without proc pr=%04xn", pr);
  3162. return;
  3163. }
  3165. if ( pr == (CC_TDSS1_IO | REQUEST)) {
  3166. l3dss1_io_timer(proc); /* timer expires */ 
  3167. return;
  3168. }  
  3170. for (i = 0; i < DOWNSLLEN; i++)
  3171. if ((pr == downstatelist[i].primitive) &&
  3172.     ((1 << proc->state) & downstatelist[i].state))
  3173. break;
  3174. if (i == DOWNSLLEN) {
  3175. if (st->l3.debug & L3_DEB_STATE) {
  3176. l3_debug(st, "dss1down state %d prim %#x unhandled",
  3177. proc->state, pr);
  3178. }
  3179. } else {
  3180. if (st->l3.debug & L3_DEB_STATE) {
  3181. l3_debug(st, "dss1down state %d prim %#x",
  3182. proc->state, pr);
  3183. }
  3184. downstatelist[i].rout(proc, pr, arg);
  3185. }
  3186. }
  3188. static void
  3189. dss1man(struct PStack *st, int pr, void *arg)
  3190. {
  3191.         int i;
  3192.         struct l3_process *proc = arg;
  3193.  
  3194.         if (!proc) {
  3195.                 printk(KERN_ERR "HiSax dss1man without proc pr=%04xn", pr);
  3196.                 return;
  3197.         }
  3198.         for (i = 0; i < MANSLLEN; i++)
  3199.                 if ((pr == manstatelist[i].primitive) &&
  3200.                     ((1 << proc->state) & manstatelist[i].state))
  3201.                         break;
  3202.         if (i == MANSLLEN) {
  3203.                 if (st->l3.debug & L3_DEB_STATE) {
  3204.                         l3_debug(st, "cr %d dss1man state %d prim %#x unhandled",
  3205.                                 proc->callref & 0x7f, proc->state, pr);
  3206.                 }
  3207.         } else {
  3208.                 if (st->l3.debug & L3_DEB_STATE) {
  3209.                         l3_debug(st, "cr %d dss1man state %d prim %#x",
  3210.                                 proc->callref & 0x7f, proc->state, pr);
  3211.                 }
  3212.                 manstatelist[i].rout(proc, pr, arg);
  3213.         }
  3214. }
  3215.  
  3216. void
  3217. setstack_dss1(struct PStack *st)
  3218. {
  3219. char tmp[64];
  3220. int i;
  3222. st->lli.l4l3 = dss1down;
  3223. st->lli.l4l3_proto = l3dss1_cmd_global;
  3224. st->l2.l2l3 = dss1up;
  3225. st->l3.l3ml3 = dss1man;
  3226. st->l3.N303 = 1;
  3227. st->prot.dss1.last_invoke_id = 0;
  3228. st->prot.dss1.invoke_used[0] = 1; /* Bit 0 must always be set to 1 */
  3229. i = 1;
  3230. while (i < 32) 
  3231. st->prot.dss1.invoke_used[i++] = 0;   
  3233. if (!(st->l3.global = kmalloc(sizeof(struct l3_process), GFP_ATOMIC))) {
  3234. printk(KERN_ERR "HiSax can't get memory for dss1 global CRn");
  3235. } else {
  3236. st->l3.global->state = 0;
  3237. st->l3.global->callref = 0;
  3238. st->l3.global->next = NULL;
  3239. st->l3.global->debug = L3_DEB_WARN;
  3240. st->l3.global->st = st;
  3241. st->l3.global->N303 = 1;
  3242. st->l3.global->prot.dss1.invoke_id = 0; 
  3244. L3InitTimer(st->l3.global, &st->l3.global->timer);
  3245. }
  3246. strcpy(tmp, dss1_revision);
  3247. printk(KERN_INFO "HiSax: DSS1 Rev. %sn", HiSax_getrev(tmp));
  3248. }