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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 查看源码
isdnl3.c
资源名称：linux-2.4.20.tar.gz　[点击查看]
上传用户：jlfgdled
上传日期：2013-04-10
资源大小：33168k
文件大小：13k
源码类别：

Linux/Unix编程

开发平台：

Unix_Linux

isdnl3.c：源码内容
  1. /* $Id: isdnl3.c,v 1.1.4.1 2001/11/20 14:19:36 kai Exp $
  2.  *
  3.  * Author       Karsten Keil
  4.  *              based on the teles driver from Jan den Ouden
  5.  * Copyright    by Karsten Keil      <keil@isdn4linux.de>
  6.  * 
  7.  * This software may be used and distributed according to the terms
  8.  * of the GNU General Public License, incorporated herein by reference.
  9.  *
  10.  * For changes and modifications please read
  11.  * ../../../Documentation/isdn/HiSax.cert
  12.  *
  13.  * Thanks to    Jan den Ouden
  14.  *              Fritz Elfert
  15.  *
  16.  */
  18. #define __NO_VERSION__
  19. #include <linux/init.h>
  20. #include "hisax.h"
  21. #include "isdnl3.h"
  22. #include <linux/config.h>
  24. const char *l3_revision = "$Revision: 1.1.4.1 $";
  26. static struct Fsm l3fsm;
  28. enum {
  29. ST_L3_LC_REL,
  30. ST_L3_LC_ESTAB_WAIT,
  31. ST_L3_LC_REL_DELAY, 
  32. ST_L3_LC_REL_WAIT,
  33. ST_L3_LC_ESTAB,
  34. };
  36. #define L3_STATE_COUNT (ST_L3_LC_ESTAB+1)
  38. static char *strL3State[] =
  39. {
  40. "ST_L3_LC_REL",
  41. "ST_L3_LC_ESTAB_WAIT",
  42. "ST_L3_LC_REL_DELAY",
  43. "ST_L3_LC_REL_WAIT",
  44. "ST_L3_LC_ESTAB",
  45. };
  47. enum {
  48. EV_ESTABLISH_REQ,
  49. EV_ESTABLISH_IND,
  50. EV_ESTABLISH_CNF,
  51. EV_RELEASE_REQ,
  52. EV_RELEASE_CNF,
  53. EV_RELEASE_IND,
  54. EV_TIMEOUT,
  55. };
  57. #define L3_EVENT_COUNT (EV_TIMEOUT+1)
  59. static char *strL3Event[] =
  60. {
  61. "EV_ESTABLISH_REQ",
  62. "EV_ESTABLISH_IND",
  63. "EV_ESTABLISH_CNF",
  64. "EV_RELEASE_REQ",
  65. "EV_RELEASE_CNF",
  66. "EV_RELEASE_IND",
  67. "EV_TIMEOUT",
  68. };
  70. static void
  71. l3m_debug(struct FsmInst *fi, char *fmt, ...)
  72. {
  73. va_list args;
  74. struct PStack *st = fi->userdata;
  76. va_start(args, fmt);
  77. VHiSax_putstatus(st->l1.hardware, st->l3.debug_id, fmt, args);
  78. va_end(args);
  79. }
  81. u_char *
  82. findie(u_char * p, int size, u_char ie, int wanted_set)
  83. {
  84. int l, codeset, maincodeset;
  85. u_char *pend = p + size;
  87. /* skip protocol discriminator, callref and message type */
  88. p++;
  89. l = (*p++) & 0xf;
  90. p += l;
  91. p++;
  92. codeset = 0;
  93. maincodeset = 0;
  94. /* while there are bytes left... */
  95. while (p < pend) {
  96. if ((*p & 0xf0) == 0x90) {
  97. codeset = *p & 0x07;
  98. if (!(*p & 0x08))
  99. maincodeset = codeset;
  100. }
  101. if (*p & 0x80)
  102. p++;
  103. else {
  104. if (codeset == wanted_set) {
  105. if (*p == ie)
  106.                                   { /* improved length check (Werner Cornelius) */
  107.                                     if ((pend - p) < 2) 
  108.                                       return(NULL); 
  109.                                     if (*(p+1) > (pend - (p+2))) 
  110.                                       return(NULL); 
  111.                                     return (p);
  112.                                   }           
  113.                                   
  114. if (*p > ie)
  115. return (NULL);
  116. }
  117. p++;
  118. l = *p++;
  119. p += l;
  120. codeset = maincodeset;
  121. }
  122. }
  123. return (NULL);
  124. }
  126. int
  127. getcallref(u_char * p)
  128. {
  129. int l, cr = 0;
  131. p++; /* prot discr */
  132. if (*p & 0xfe) /* wrong callref BRI only 1 octet*/
  133. return(-2);
  134. l = 0xf & *p++; /* callref length */
  135. if (!l) /* dummy CallRef */
  136. return(-1);
  137. cr = *p++;
  138. return (cr);
  139. }
  141. static int OrigCallRef = 0;
  143. int
  144. newcallref(void)
  145. {
  146. if (OrigCallRef == 127)
  147. OrigCallRef = 1;
  148. else
  149. OrigCallRef++;
  150. return (OrigCallRef);
  151. }
  153. void
  154. newl3state(struct l3_process *pc, int state)
  155. {
  156. if (pc->debug & L3_DEB_STATE)
  157. l3_debug(pc->st, "newstate cr %d %d --> %d", 
  158.  pc->callref & 0x7F,
  159.  pc->state, state);
  160. pc->state = state;
  161. }
  163. static void
  164. L3ExpireTimer(struct L3Timer *t)
  165. {
  166. t->pc->st->lli.l4l3(t->pc->st, t->event, t->pc);
  167. }
  169. void
  170. L3InitTimer(struct l3_process *pc, struct L3Timer *t)
  171. {
  172. t->pc = pc;
  173. t->tl.function = (void *) L3ExpireTimer;
  174. t->tl.data = (long) t;
  175. init_timer(&t->tl);
  176. }
  178. void
  179. L3DelTimer(struct L3Timer *t)
  180. {
  181. del_timer(&t->tl);
  182. }
  184. int
  185. L3AddTimer(struct L3Timer *t,
  186.    int millisec, int event)
  187. {
  188. if (timer_pending(&t->tl)) {
  189. printk(KERN_WARNING "L3AddTimer: timer already active!n");
  190. return -1;
  191. }
  192. init_timer(&t->tl);
  193. t->event = event;
  194. t->tl.expires = jiffies + (millisec * HZ) / 1000;
  195. add_timer(&t->tl);
  196. return 0;
  197. }
  199. void
  200. StopAllL3Timer(struct l3_process *pc)
  201. {
  202. L3DelTimer(&pc->timer);
  203. }
  205. struct sk_buff *
  206. l3_alloc_skb(int len)
  207. {
  208. struct sk_buff *skb;
  210. if (!(skb = alloc_skb(len + MAX_HEADER_LEN, GFP_ATOMIC))) {
  211. printk(KERN_WARNING "HiSax: No skb for D-channeln");
  212. return (NULL);
  213. }
  214. skb_reserve(skb, MAX_HEADER_LEN);
  215. return (skb);
  216. }
  218. static void
  219. no_l3_proto(struct PStack *st, int pr, void *arg)
  220. {
  221. struct sk_buff *skb = arg;
  223. HiSax_putstatus(st->l1.hardware, "L3", "no D protocol");
  224. if (skb) {
  225. dev_kfree_skb(skb);
  226. }
  227. }
  229. static int
  230. no_l3_proto_spec(struct PStack *st, isdn_ctrl *ic)
  231. {
  232. printk(KERN_WARNING "HiSax: no specific protocol handler for proto %lun",ic->arg & 0xFF);
  233. return(-1);
  234. }
  236. #ifdef CONFIG_HISAX_EURO
  237. extern void setstack_dss1(struct PStack *st);
  238. #endif
  240. #ifdef  CONFIG_HISAX_NI1
  241. extern void setstack_ni1(struct PStack *st);
  242. #endif
  244. #ifdef CONFIG_HISAX_1TR6
  245. extern void setstack_1tr6(struct PStack *st);
  246. #endif
  248. struct l3_process
  249. *getl3proc(struct PStack *st, int cr)
  250. {
  251. struct l3_process *p = st->l3.proc;
  253. while (p)
  254. if (p->callref == cr)
  255. return (p);
  256. else
  257. p = p->next;
  258. return (NULL);
  259. }
  261. struct l3_process
  262. *new_l3_process(struct PStack *st, int cr)
  263. {
  264. struct l3_process *p, *np;
  266. if (!(p = kmalloc(sizeof(struct l3_process), GFP_ATOMIC))) {
  267. printk(KERN_ERR "HiSax can't get memory for cr %dn", cr);
  268. return (NULL);
  269. }
  270. if (!st->l3.proc)
  271. st->l3.proc = p;
  272. else {
  273. np = st->l3.proc;
  274. while (np->next)
  275. np = np->next;
  276. np->next = p;
  277. }
  278. p->next = NULL;
  279. p->debug = st->l3.debug;
  280. p->callref = cr;
  281. p->state = 0;
  282. p->chan = NULL;
  283. p->st = st;
  284. p->N303 = st->l3.N303;
  285. L3InitTimer(p, &p->timer);
  286. return (p);
  287. };
  289. void
  290. release_l3_process(struct l3_process *p)
  291. {
  292. struct l3_process *np, *pp = NULL;
  294. if (!p)
  295. return;
  296. np = p->st->l3.proc;
  297. while (np) {
  298. if (np == p) {
  299. StopAllL3Timer(p);
  300. if (pp)
  301. pp->next = np->next;
  302. else if (!(p->st->l3.proc = np->next) &&
  303. !test_bit(FLG_PTP, &p->st->l2.flag)) {
  304. if (p->debug)
  305. l3_debug(p->st, "release_l3_process: last process");
  306. if (!skb_queue_len(&p->st->l3.squeue)) {
  307. if (p->debug)
  308. l3_debug(p->st, "release_l3_process: release link");
  309. if (p->st->protocol != ISDN_PTYPE_NI1)
  310. FsmEvent(&p->st->l3.l3m, EV_RELEASE_REQ, NULL);
  311. else
  312. FsmEvent(&p->st->l3.l3m, EV_RELEASE_IND, NULL);
  313. } else {
  314. if (p->debug)
  315. l3_debug(p->st, "release_l3_process: not release link");
  316. }
  317. } 
  318. kfree(p);
  319. return;
  320. }
  321. pp = np;
  322. np = np->next;
  323. }
  324. printk(KERN_ERR "HiSax internal L3 error CR(%d) not in listn", p->callref);
  325. l3_debug(p->st, "HiSax internal L3 error CR(%d) not in list", p->callref);
  326. };
  328. static void
  329. l3ml3p(struct PStack *st, int pr)
  330. {
  331. struct l3_process *p = st->l3.proc;
  332. struct l3_process *np;
  334. while (p) {
  335. /* p might be kfreed under us, so we need to save where we want to go on */
  336. np = p->next;
  337. st->l3.l3ml3(st, pr, p);
  338. p = np;
  339. }
  340. }
  342. void
  343. setstack_l3dc(struct PStack *st, struct Channel *chanp)
  344. {
  345. char tmp[64];
  347. st->l3.proc   = NULL;
  348. st->l3.global = NULL;
  349. skb_queue_head_init(&st->l3.squeue);
  350. st->l3.l3m.fsm = &l3fsm;
  351. st->l3.l3m.state = ST_L3_LC_REL;
  352. st->l3.l3m.debug = 1;
  353. st->l3.l3m.userdata = st;
  354. st->l3.l3m.userint = 0;
  355. st->l3.l3m.printdebug = l3m_debug;
  356.         FsmInitTimer(&st->l3.l3m, &st->l3.l3m_timer);
  357. strcpy(st->l3.debug_id, "L3DC ");
  358. st->lli.l4l3_proto = no_l3_proto_spec;
  360. #ifdef CONFIG_HISAX_EURO
  361. if (st->protocol == ISDN_PTYPE_EURO) {
  362. setstack_dss1(st);
  363. } else
  364. #endif
  365. #ifdef  CONFIG_HISAX_NI1
  366. if (st->protocol == ISDN_PTYPE_NI1) {
  367. setstack_ni1(st);
  368. } else
  369. #endif
  370. #ifdef CONFIG_HISAX_1TR6
  371. if (st->protocol == ISDN_PTYPE_1TR6) {
  372. setstack_1tr6(st);
  373. } else
  374. #endif
  375. if (st->protocol == ISDN_PTYPE_LEASED) {
  376. st->lli.l4l3 = no_l3_proto;
  377. st->l2.l2l3 = no_l3_proto;
  378.                 st->l3.l3ml3 = no_l3_proto;
  379. printk(KERN_INFO "HiSax: Leased line moden");
  380. } else {
  381. st->lli.l4l3 = no_l3_proto;
  382. st->l2.l2l3 = no_l3_proto;
  383.                 st->l3.l3ml3 = no_l3_proto;
  384. sprintf(tmp, "protocol %s not supported",
  385. (st->protocol == ISDN_PTYPE_1TR6) ? "1tr6" :
  386. (st->protocol == ISDN_PTYPE_EURO) ? "euro" :
  387. (st->protocol == ISDN_PTYPE_NI1) ? "ni1" :
  388. "unknown");
  389. printk(KERN_WARNING "HiSax: %sn", tmp);
  390. st->protocol = -1;
  391. }
  392. }
  394. void
  395. isdnl3_trans(struct PStack *st, int pr, void *arg) {
  396. st->l3.l3l2(st, pr, arg);
  397. }
  399. void
  400. releasestack_isdnl3(struct PStack *st)
  401. {
  402. while (st->l3.proc)
  403. release_l3_process(st->l3.proc);
  404. if (st->l3.global) {
  405. StopAllL3Timer(st->l3.global);
  406. kfree(st->l3.global);
  407. st->l3.global = NULL;
  408. }
  409. FsmDelTimer(&st->l3.l3m_timer, 54);
  410. skb_queue_purge(&st->l3.squeue);
  411. }
  413. void
  414. setstack_l3bc(struct PStack *st, struct Channel *chanp)
  415. {
  417. st->l3.proc   = NULL;
  418. st->l3.global = NULL;
  419. skb_queue_head_init(&st->l3.squeue);
  420. st->l3.l3m.fsm = &l3fsm;
  421. st->l3.l3m.state = ST_L3_LC_REL;
  422. st->l3.l3m.debug = 1;
  423. st->l3.l3m.userdata = st;
  424. st->l3.l3m.userint = 0;
  425. st->l3.l3m.printdebug = l3m_debug;
  426. strcpy(st->l3.debug_id, "L3BC ");
  427. st->lli.l4l3 = isdnl3_trans;
  428. }
  430. #define DREL_TIMER_VALUE 40000
  432. static void
  433. lc_activate(struct FsmInst *fi, int event, void *arg)
  434. {
  435. struct PStack *st = fi->userdata;
  437. FsmChangeState(fi, ST_L3_LC_ESTAB_WAIT);
  438. st->l3.l3l2(st, DL_ESTABLISH | REQUEST, NULL);
  439. }
  441. static void
  442. lc_connect(struct FsmInst *fi, int event, void *arg)
  443. {
  444. struct PStack *st = fi->userdata;
  445. struct sk_buff *skb = arg;
  446. int dequeued = 0;
  448. FsmChangeState(fi, ST_L3_LC_ESTAB);
  449. while ((skb = skb_dequeue(&st->l3.squeue))) {
  450. st->l3.l3l2(st, DL_DATA | REQUEST, skb);
  451. dequeued++;
  452. }
  453. if ((!st->l3.proc) &&  dequeued) {
  454. if (st->l3.debug)
  455. l3_debug(st, "lc_connect: release link");
  456. FsmEvent(&st->l3.l3m, EV_RELEASE_REQ, NULL);
  457. } else
  458. l3ml3p(st, DL_ESTABLISH | INDICATION);
  459. }
  461. static void
  462. lc_connected(struct FsmInst *fi, int event, void *arg)
  463. {
  464. struct PStack *st = fi->userdata;
  465. struct sk_buff *skb = arg;
  466. int dequeued = 0;
  468. FsmDelTimer(&st->l3.l3m_timer, 51);
  469. FsmChangeState(fi, ST_L3_LC_ESTAB);
  470. while ((skb = skb_dequeue(&st->l3.squeue))) {
  471. st->l3.l3l2(st, DL_DATA | REQUEST, skb);
  472. dequeued++;
  473. }
  474. if ((!st->l3.proc) &&  dequeued) {
  475. if (st->l3.debug)
  476. l3_debug(st, "lc_connected: release link");
  477. FsmEvent(&st->l3.l3m, EV_RELEASE_REQ, NULL);
  478. } else
  479. l3ml3p(st, DL_ESTABLISH | CONFIRM);
  480. }
  482. static void
  483. lc_start_delay(struct FsmInst *fi, int event, void *arg)
  484. {
  485.        struct PStack *st = fi->userdata;
  487.        FsmChangeState(fi, ST_L3_LC_REL_DELAY);
  488.        FsmAddTimer(&st->l3.l3m_timer, DREL_TIMER_VALUE, EV_TIMEOUT, NULL, 50);
  489. }
  491. static void
  492. lc_start_delay_check(struct FsmInst *fi, int event, void *arg)
  493. /* 20/09/00 - GE timer not user for NI-1 as layer 2 should stay up */
  494. {
  495.        struct PStack *st = fi->userdata;
  497.        FsmChangeState(fi, ST_L3_LC_REL_DELAY);
  498.        /* 19/09/00 - GE timer not user for NI-1 */
  499.        if (st->protocol != ISDN_PTYPE_NI1) 
  500.         FsmAddTimer(&st->l3.l3m_timer, DREL_TIMER_VALUE, EV_TIMEOUT, NULL, 50);
  501. }
  503. static void
  504. lc_release_req(struct FsmInst *fi, int event, void *arg)
  505. {
  506. struct PStack *st = fi->userdata;
  508. if (test_bit(FLG_L2BLOCK, &st->l2.flag)) {
  509. if (st->l3.debug)
  510. l3_debug(st, "lc_release_req: l2 blocked");
  511. /* restart release timer */
  512. FsmAddTimer(&st->l3.l3m_timer, DREL_TIMER_VALUE, EV_TIMEOUT, NULL, 51);
  513. } else {
  514. FsmChangeState(fi, ST_L3_LC_REL_WAIT);
  515. st->l3.l3l2(st, DL_RELEASE | REQUEST, NULL);
  516. }
  517. }
  519. static void
  520. lc_release_ind(struct FsmInst *fi, int event, void *arg)
  521. {
  522. struct PStack *st = fi->userdata;
  524. FsmDelTimer(&st->l3.l3m_timer, 52);
  525. FsmChangeState(fi, ST_L3_LC_REL);
  526. skb_queue_purge(&st->l3.squeue);
  527. l3ml3p(st, DL_RELEASE | INDICATION);
  528. }
  530. static void
  531. lc_release_cnf(struct FsmInst *fi, int event, void *arg)
  532. {
  533. struct PStack *st = fi->userdata;
  535. FsmChangeState(fi, ST_L3_LC_REL);
  536. skb_queue_purge(&st->l3.squeue);
  537. l3ml3p(st, DL_RELEASE | CONFIRM);
  538. }
  541. /* *INDENT-OFF* */
  542. static struct FsmNode L3FnList[] __initdata =
  543. {
  544. {ST_L3_LC_REL, EV_ESTABLISH_REQ, lc_activate},
  545. {ST_L3_LC_REL, EV_ESTABLISH_IND, lc_connect},
  546. {ST_L3_LC_REL, EV_ESTABLISH_CNF, lc_connect},
  547. {ST_L3_LC_ESTAB_WAIT, EV_ESTABLISH_CNF, lc_connected},
  548. {ST_L3_LC_ESTAB_WAIT, EV_RELEASE_REQ, lc_start_delay},
  549. {ST_L3_LC_ESTAB_WAIT, EV_RELEASE_IND, lc_release_ind},
  550. {ST_L3_LC_ESTAB, EV_RELEASE_IND, lc_release_ind},
  551. {ST_L3_LC_ESTAB, EV_RELEASE_REQ, lc_start_delay_check},
  552.         {ST_L3_LC_REL_DELAY,    EV_RELEASE_IND,         lc_release_ind},
  553.         {ST_L3_LC_REL_DELAY,    EV_ESTABLISH_REQ,       lc_connected},
  554.         {ST_L3_LC_REL_DELAY,    EV_TIMEOUT,             lc_release_req},
  555. {ST_L3_LC_REL_WAIT, EV_RELEASE_CNF, lc_release_cnf},
  556. {ST_L3_LC_REL_WAIT, EV_ESTABLISH_REQ, lc_activate},
  557. };
  558. /* *INDENT-ON* */
  560. #define L3_FN_COUNT (sizeof(L3FnList)/sizeof(struct FsmNode))
  562. void
  563. l3_msg(struct PStack *st, int pr, void *arg)
  564. {
  565. switch (pr) {
  566. case (DL_DATA | REQUEST):
  567. if (st->l3.l3m.state == ST_L3_LC_ESTAB) {
  568. st->l3.l3l2(st, pr, arg);
  569. } else {
  570. struct sk_buff *skb = arg;
  572. skb_queue_tail(&st->l3.squeue, skb);
  573. FsmEvent(&st->l3.l3m, EV_ESTABLISH_REQ, NULL); 
  574. }
  575. break;
  576. case (DL_ESTABLISH | REQUEST):
  577. FsmEvent(&st->l3.l3m, EV_ESTABLISH_REQ, NULL);
  578. break;
  579. case (DL_ESTABLISH | CONFIRM):
  580. FsmEvent(&st->l3.l3m, EV_ESTABLISH_CNF, NULL);
  581. break;
  582. case (DL_ESTABLISH | INDICATION):
  583. FsmEvent(&st->l3.l3m, EV_ESTABLISH_IND, NULL);
  584. break;
  585. case (DL_RELEASE | INDICATION):
  586. FsmEvent(&st->l3.l3m, EV_RELEASE_IND, NULL);
  587. break;
  588. case (DL_RELEASE | CONFIRM):
  589. FsmEvent(&st->l3.l3m, EV_RELEASE_CNF, NULL);
  590. break;
  591. case (DL_RELEASE | REQUEST):
  592. FsmEvent(&st->l3.l3m, EV_RELEASE_REQ, NULL);
  593. break;
  594. }
  595. }
  597. int __init
  598. Isdnl3New(void)
  599. {
  600. l3fsm.state_count = L3_STATE_COUNT;
  601. l3fsm.event_count = L3_EVENT_COUNT;
  602. l3fsm.strEvent = strL3Event;
  603. l3fsm.strState = strL3State;
  604. return FsmNew(&l3fsm, L3FnList, L3_FN_COUNT);
  605. }
  607. void
  608. Isdnl3Free(void)
  609. {
  610. FsmFree(&l3fsm);
  611. }