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