Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
capi.c
Go to the documentation of this file.
1 /*
2  * CAPI encoder/decoder for
3  * Portugal Telecom CAPI 2.0
4  *
5  * Copyright (C) 1996 Universidade de Lisboa
6  *
7  * Written by Pedro Roque Marques ([email protected])
8  *
9  * This software may be used and distributed according to the terms of
10  * the GNU General Public License, incorporated herein by reference.
11  *
12  * Not compatible with the AVM Gmbh. CAPI 2.0
13  *
14  */
15 
16 /*
17  * Documentation:
18  * - "Common ISDN API - Perfil Português - Versão 2.1",
19  * Telecom Portugal, Fev 1992.
20  * - "Common ISDN API - Especificação de protocolos para
21  * acesso aos canais B", Inesc, Jan 1994.
22  */
23 
24 /*
25  * TODO: better decoding of Information Elements
26  * for debug purposes mainly
27  * encode our number in CallerPN and ConnectedPN
28  */
29 
30 #include <linux/string.h>
31 #include <linux/kernel.h>
32 
33 #include <linux/types.h>
34 #include <linux/slab.h>
35 #include <linux/mm.h>
36 
37 #include <linux/skbuff.h>
38 
39 #include <asm/io.h>
40 #include <asm/string.h>
41 
42 #include <linux/isdnif.h>
43 
44 #include "pcbit.h"
45 #include "edss1.h"
46 #include "capi.h"
47 
48 
49 /*
50  * Encoding of CAPI messages
51  *
52  */
53 
54 int capi_conn_req(const char *calledPN, struct sk_buff **skb, int proto)
55 {
56  ushort len;
57 
58  /*
59  * length
60  * AppInfoMask - 2
61  * BC0 - 3
62  * BC1 - 1
63  * Chan - 2
64  * Keypad - 1
65  * CPN - 1
66  * CPSA - 1
67  * CalledPN - 2 + strlen
68  * CalledPSA - 1
69  * rest... - 4
70  * ----------------
71  * Total 18 + strlen
72  */
73 
74  len = 18 + strlen(calledPN);
75 
76  if (proto == ISDN_PROTO_L2_TRANS)
77  len++;
78 
79  if ((*skb = dev_alloc_skb(len)) == NULL) {
80 
81  printk(KERN_WARNING "capi_conn_req: alloc_skb failed\n");
82  return -1;
83  }
84 
85  /* InfoElmMask */
86  *((ushort *)skb_put(*skb, 2)) = AppInfoMask;
87 
88  if (proto == ISDN_PROTO_L2_TRANS)
89  {
90  /* Bearer Capability - Mandatory*/
91  *(skb_put(*skb, 1)) = 3; /* BC0.Length */
92  *(skb_put(*skb, 1)) = 0x80; /* Speech */
93  *(skb_put(*skb, 1)) = 0x10; /* Circuit Mode */
94  *(skb_put(*skb, 1)) = 0x23; /* A-law */
95  }
96  else
97  {
98  /* Bearer Capability - Mandatory*/
99  *(skb_put(*skb, 1)) = 2; /* BC0.Length */
100  *(skb_put(*skb, 1)) = 0x88; /* Digital Information */
101  *(skb_put(*skb, 1)) = 0x90; /* BC0.Octect4 */
102  }
103 
104  /* Bearer Capability - Optional*/
105  *(skb_put(*skb, 1)) = 0; /* BC1.Length = 0 */
106 
107  *(skb_put(*skb, 1)) = 1; /* ChannelID.Length = 1 */
108  *(skb_put(*skb, 1)) = 0x83; /* Basic Interface - Any Channel */
109 
110  *(skb_put(*skb, 1)) = 0; /* Keypad.Length = 0 */
111 
112 
113  *(skb_put(*skb, 1)) = 0; /* CallingPN.Length = 0 */
114  *(skb_put(*skb, 1)) = 0; /* CallingPSA.Length = 0 */
115 
116  /* Called Party Number */
117  *(skb_put(*skb, 1)) = strlen(calledPN) + 1;
118  *(skb_put(*skb, 1)) = 0x81;
119  memcpy(skb_put(*skb, strlen(calledPN)), calledPN, strlen(calledPN));
120 
121  /* '#' */
122 
123  *(skb_put(*skb, 1)) = 0; /* CalledPSA.Length = 0 */
124 
125  /* LLC.Length = 0; */
126  /* HLC0.Length = 0; */
127  /* HLC1.Length = 0; */
128  /* UTUS.Length = 0; */
129  memset(skb_put(*skb, 4), 0, 4);
130 
131  return len;
132 }
133 
134 int capi_conn_resp(struct pcbit_chan *chan, struct sk_buff **skb)
135 {
136 
137  if ((*skb = dev_alloc_skb(5)) == NULL) {
138 
139  printk(KERN_WARNING "capi_conn_resp: alloc_skb failed\n");
140  return -1;
141  }
142 
143  *((ushort *)skb_put(*skb, 2)) = chan->callref;
144  *(skb_put(*skb, 1)) = 0x01; /* ACCEPT_CALL */
145  *(skb_put(*skb, 1)) = 0;
146  *(skb_put(*skb, 1)) = 0;
147 
148  return 5;
149 }
150 
151 int capi_conn_active_req(struct pcbit_chan *chan, struct sk_buff **skb)
152 {
153  /*
154  * 8 bytes
155  */
156 
157  if ((*skb = dev_alloc_skb(8)) == NULL) {
158 
159  printk(KERN_WARNING "capi_conn_active_req: alloc_skb failed\n");
160  return -1;
161  }
162 
163  *((ushort *)skb_put(*skb, 2)) = chan->callref;
164 
165 #ifdef DEBUG
166  printk(KERN_DEBUG "Call Reference: %04x\n", chan->callref);
167 #endif
168 
169  *(skb_put(*skb, 1)) = 0; /* BC.Length = 0; */
170  *(skb_put(*skb, 1)) = 0; /* ConnectedPN.Length = 0 */
171  *(skb_put(*skb, 1)) = 0; /* PSA.Length */
172  *(skb_put(*skb, 1)) = 0; /* LLC.Length = 0; */
173  *(skb_put(*skb, 1)) = 0; /* HLC.Length = 0; */
174  *(skb_put(*skb, 1)) = 0; /* UTUS.Length = 0; */
175 
176  return 8;
177 }
178 
179 int capi_conn_active_resp(struct pcbit_chan *chan, struct sk_buff **skb)
180 {
181  /*
182  * 2 bytes
183  */
184 
185  if ((*skb = dev_alloc_skb(2)) == NULL) {
186 
187  printk(KERN_WARNING "capi_conn_active_resp: alloc_skb failed\n");
188  return -1;
189  }
190 
191  *((ushort *)skb_put(*skb, 2)) = chan->callref;
192 
193  return 2;
194 }
195 
196 
197 int capi_select_proto_req(struct pcbit_chan *chan, struct sk_buff **skb,
198  int outgoing)
199 {
200 
201  /*
202  * 18 bytes
203  */
204 
205  if ((*skb = dev_alloc_skb(18)) == NULL) {
206 
207  printk(KERN_WARNING "capi_select_proto_req: alloc_skb failed\n");
208  return -1;
209  }
210 
211  *((ushort *)skb_put(*skb, 2)) = chan->callref;
212 
213  /* Layer2 protocol */
214 
215  switch (chan->proto) {
216  case ISDN_PROTO_L2_X75I:
217  *(skb_put(*skb, 1)) = 0x05; /* LAPB */
218  break;
219  case ISDN_PROTO_L2_HDLC:
220  *(skb_put(*skb, 1)) = 0x02;
221  break;
222  case ISDN_PROTO_L2_TRANS:
223  /*
224  * Voice (a-law)
225  */
226  *(skb_put(*skb, 1)) = 0x06;
227  break;
228  default:
229 #ifdef DEBUG
230  printk(KERN_DEBUG "Transparent\n");
231 #endif
232  *(skb_put(*skb, 1)) = 0x03;
233  break;
234  }
235 
236  *(skb_put(*skb, 1)) = (outgoing ? 0x02 : 0x42); /* Don't ask */
237  *(skb_put(*skb, 1)) = 0x00;
238 
239  *((ushort *) skb_put(*skb, 2)) = MRU;
240 
241 
242  *(skb_put(*skb, 1)) = 0x08; /* Modulo */
243  *(skb_put(*skb, 1)) = 0x07; /* Max Window */
244 
245  *(skb_put(*skb, 1)) = 0x01; /* No Layer3 Protocol */
246 
247  /*
248  * 2 - layer3 MTU [10]
249  * - Modulo [12]
250  * - Window
251  * - layer1 proto [14]
252  * - bitrate
253  * - sub-channel [16]
254  * - layer1dataformat [17]
255  */
256 
257  memset(skb_put(*skb, 8), 0, 8);
258 
259  return 18;
260 }
261 
262 
263 int capi_activate_transp_req(struct pcbit_chan *chan, struct sk_buff **skb)
264 {
265 
266  if ((*skb = dev_alloc_skb(7)) == NULL) {
267 
268  printk(KERN_WARNING "capi_activate_transp_req: alloc_skb failed\n");
269  return -1;
270  }
271 
272  *((ushort *)skb_put(*skb, 2)) = chan->callref;
273 
274 
275  *(skb_put(*skb, 1)) = chan->layer2link; /* Layer2 id */
276  *(skb_put(*skb, 1)) = 0x00; /* Transmit by default */
277 
278  *((ushort *) skb_put(*skb, 2)) = MRU;
279 
280  *(skb_put(*skb, 1)) = 0x01; /* Enables reception*/
281 
282  return 7;
283 }
284 
285 int capi_tdata_req(struct pcbit_chan *chan, struct sk_buff *skb)
286 {
287  ushort data_len;
288 
289 
290  /*
291  * callref - 2
292  * layer2link - 1
293  * wBlockLength - 2
294  * data - 4
295  * sernum - 1
296  */
297 
298  data_len = skb->len;
299 
300  if (skb_headroom(skb) < 10)
301  {
302  printk(KERN_CRIT "No headspace (%u) on headroom %p for capi header\n", skb_headroom(skb), skb);
303  }
304  else
305  {
306  skb_push(skb, 10);
307  }
308 
309  *((u16 *) (skb->data)) = chan->callref;
310  skb->data[2] = chan->layer2link;
311  *((u16 *) (skb->data + 3)) = data_len;
312 
313  chan->s_refnum = (chan->s_refnum + 1) % 8;
314  *((u32 *) (skb->data + 5)) = chan->s_refnum;
315 
316  skb->data[9] = 0; /* HDLC frame number */
317 
318  return 10;
319 }
320 
321 int capi_tdata_resp(struct pcbit_chan *chan, struct sk_buff **skb)
322 
323 {
324  if ((*skb = dev_alloc_skb(4)) == NULL) {
325 
326  printk(KERN_WARNING "capi_tdata_resp: alloc_skb failed\n");
327  return -1;
328  }
329 
330  *((ushort *)skb_put(*skb, 2)) = chan->callref;
331 
332  *(skb_put(*skb, 1)) = chan->layer2link;
333  *(skb_put(*skb, 1)) = chan->r_refnum;
334 
335  return (*skb)->len;
336 }
337 
338 int capi_disc_req(ushort callref, struct sk_buff **skb, u_char cause)
339 {
340 
341  if ((*skb = dev_alloc_skb(6)) == NULL) {
342 
343  printk(KERN_WARNING "capi_disc_req: alloc_skb failed\n");
344  return -1;
345  }
346 
347  *((ushort *)skb_put(*skb, 2)) = callref;
348 
349  *(skb_put(*skb, 1)) = 2; /* Cause.Length = 2; */
350  *(skb_put(*skb, 1)) = 0x80;
351  *(skb_put(*skb, 1)) = 0x80 | cause;
352 
353  /*
354  * Change it: we should send 'Sic transit gloria Mundi' here ;-)
355  */
356 
357  *(skb_put(*skb, 1)) = 0; /* UTUS.Length = 0; */
358 
359  return 6;
360 }
361 
362 int capi_disc_resp(struct pcbit_chan *chan, struct sk_buff **skb)
363 {
364  if ((*skb = dev_alloc_skb(2)) == NULL) {
365 
366  printk(KERN_WARNING "capi_disc_resp: alloc_skb failed\n");
367  return -1;
368  }
369 
370  *((ushort *)skb_put(*skb, 2)) = chan->callref;
371 
372  return 2;
373 }
374 
375 
376 /*
377  * Decoding of CAPI messages
378  *
379  */
380 
381 int capi_decode_conn_ind(struct pcbit_chan *chan,
382  struct sk_buff *skb,
383  struct callb_data *info)
384 {
385  int CIlen, len;
386 
387  /* Call Reference [CAPI] */
388  chan->callref = *((ushort *)skb->data);
389  skb_pull(skb, 2);
390 
391 #ifdef DEBUG
392  printk(KERN_DEBUG "Call Reference: %04x\n", chan->callref);
393 #endif
394 
395  /* Channel Identification */
396 
397  /* Expect
398  Len = 1
399  Octect 3 = 0100 10CC - [ 7 Basic, 4 , 2-1 chan ]
400  */
401 
402  CIlen = skb->data[0];
403 #ifdef DEBUG
404  if (CIlen == 1) {
405 
406  if (((skb->data[1]) & 0xFC) == 0x48)
407  printk(KERN_DEBUG "decode_conn_ind: chan ok\n");
408  printk(KERN_DEBUG "phyChan = %d\n", skb->data[1] & 0x03);
409  }
410  else
411  printk(KERN_DEBUG "conn_ind: CIlen = %d\n", CIlen);
412 #endif
413  skb_pull(skb, CIlen + 1);
414 
415  /* Calling Party Number */
416  /* An "additional service" as far as Portugal Telecom is concerned */
417 
418  len = skb->data[0];
419 
420  if (len > 0) {
421  int count = 1;
422 
423 #ifdef DEBUG
424  printk(KERN_DEBUG "CPN: Octect 3 %02x\n", skb->data[1]);
425 #endif
426  if ((skb->data[1] & 0x80) == 0)
427  count = 2;
428 
429  if (!(info->data.setup.CallingPN = kmalloc(len - count + 1, GFP_ATOMIC)))
430  return -1;
431 
432  skb_copy_from_linear_data_offset(skb, count + 1,
433  info->data.setup.CallingPN,
434  len - count);
435  info->data.setup.CallingPN[len - count] = 0;
436 
437  }
438  else {
439  info->data.setup.CallingPN = NULL;
440  printk(KERN_DEBUG "NULL CallingPN\n");
441  }
442 
443  skb_pull(skb, len + 1);
444 
445  /* Calling Party Subaddress */
446  skb_pull(skb, skb->data[0] + 1);
447 
448  /* Called Party Number */
449 
450  len = skb->data[0];
451 
452  if (len > 0) {
453  int count = 1;
454 
455  if ((skb->data[1] & 0x80) == 0)
456  count = 2;
457 
458  if (!(info->data.setup.CalledPN = kmalloc(len - count + 1, GFP_ATOMIC)))
459  return -1;
460 
461  skb_copy_from_linear_data_offset(skb, count + 1,
462  info->data.setup.CalledPN,
463  len - count);
464  info->data.setup.CalledPN[len - count] = 0;
465 
466  }
467  else {
468  info->data.setup.CalledPN = NULL;
469  printk(KERN_DEBUG "NULL CalledPN\n");
470  }
471 
472  skb_pull(skb, len + 1);
473 
474  /* Called Party Subaddress */
475  skb_pull(skb, skb->data[0] + 1);
476 
477  /* LLC */
478  skb_pull(skb, skb->data[0] + 1);
479 
480  /* HLC */
481  skb_pull(skb, skb->data[0] + 1);
482 
483  /* U2U */
484  skb_pull(skb, skb->data[0] + 1);
485 
486  return 0;
487 }
488 
489 /*
490  * returns errcode
491  */
492 
493 int capi_decode_conn_conf(struct pcbit_chan *chan, struct sk_buff *skb,
494  int *complete)
495 {
496  int errcode;
497 
498  chan->callref = *((ushort *)skb->data); /* Update CallReference */
499  skb_pull(skb, 2);
500 
501  errcode = *((ushort *) skb->data); /* read errcode */
502  skb_pull(skb, 2);
503 
504  *complete = *(skb->data);
505  skb_pull(skb, 1);
506 
507  /* FIX ME */
508  /* This is actually a firmware bug */
509  if (!*complete)
510  {
511  printk(KERN_DEBUG "complete=%02x\n", *complete);
512  *complete = 1;
513  }
514 
515 
516  /* Optional Bearer Capability */
517  skb_pull(skb, *(skb->data) + 1);
518 
519  /* Channel Identification */
520  skb_pull(skb, *(skb->data) + 1);
521 
522  /* High Layer Compatibility follows */
523  skb_pull(skb, *(skb->data) + 1);
524 
525  return errcode;
526 }
527 
528 int capi_decode_conn_actv_ind(struct pcbit_chan *chan, struct sk_buff *skb)
529 {
530  ushort len;
531 #ifdef DEBUG
532  char str[32];
533 #endif
534 
535  /* Yet Another Bearer Capability */
536  skb_pull(skb, *(skb->data) + 1);
537 
538 
539  /* Connected Party Number */
540  len = *(skb->data);
541 
542 #ifdef DEBUG
543  if (len > 1 && len < 31) {
544  skb_copy_from_linear_data_offset(skb, 2, str, len - 1);
545  str[len] = 0;
546  printk(KERN_DEBUG "Connected Party Number: %s\n", str);
547  }
548  else
549  printk(KERN_DEBUG "actv_ind CPN len = %d\n", len);
550 #endif
551 
552  skb_pull(skb, len + 1);
553 
554  /* Connected Subaddress */
555  skb_pull(skb, *(skb->data) + 1);
556 
557  /* Low Layer Capability */
558  skb_pull(skb, *(skb->data) + 1);
559 
560  /* High Layer Capability */
561  skb_pull(skb, *(skb->data) + 1);
562 
563  return 0;
564 }
565 
566 int capi_decode_conn_actv_conf(struct pcbit_chan *chan, struct sk_buff *skb)
567 {
568  ushort errcode;
569 
570  errcode = *((ushort *)skb->data);
571  skb_pull(skb, 2);
572 
573  /* Channel Identification
574  skb_pull(skb, skb->data[0] + 1);
575  */
576  return errcode;
577 }
578 
579 
580 int capi_decode_sel_proto_conf(struct pcbit_chan *chan, struct sk_buff *skb)
581 {
582  ushort errcode;
583 
584  chan->layer2link = *(skb->data);
585  skb_pull(skb, 1);
586 
587  errcode = *((ushort *)skb->data);
588  skb_pull(skb, 2);
589 
590  return errcode;
591 }
592 
593 int capi_decode_actv_trans_conf(struct pcbit_chan *chan, struct sk_buff *skb)
594 {
595  ushort errcode;
596 
597  if (chan->layer2link != *(skb->data))
598  printk("capi_decode_actv_trans_conf: layer2link doesn't match\n");
599 
600  skb_pull(skb, 1);
601 
602  errcode = *((ushort *)skb->data);
603  skb_pull(skb, 2);
604 
605  return errcode;
606 }
607 
608 int capi_decode_disc_ind(struct pcbit_chan *chan, struct sk_buff *skb)
609 {
610  ushort len;
611 #ifdef DEBUG
612  int i;
613 #endif
614  /* Cause */
615 
616  len = *(skb->data);
617  skb_pull(skb, 1);
618 
619 #ifdef DEBUG
620 
621  for (i = 0; i < len; i++)
622  printk(KERN_DEBUG "Cause Octect %d: %02x\n", i + 3,
623  *(skb->data + i));
624 #endif
625 
626  skb_pull(skb, len);
627 
628  return 0;
629 }
630 
631 #ifdef DEBUG
632 int capi_decode_debug_188(u_char *hdr, ushort hdrlen)
633 {
634  char str[64];
635  int len;
636 
637  len = hdr[0];
638 
639  if (len < 64 && len == hdrlen - 1) {
640  memcpy(str, hdr + 1, hdrlen - 1);
641  str[hdrlen - 1] = 0;
642  printk("%s\n", str);
643  }
644  else
645  printk("debug message incorrect\n");
646 
647  return 0;
648 }
649 #endif
Generated on Thu Jan 10 2013 13:40:55 for Linux Kernel by   doxygen 1.8.2