diff options
author | Linus Torvalds <torvalds@ppc970.osdl.org> | 2005-04-16 18:20:36 -0400 |
---|---|---|
committer | Linus Torvalds <torvalds@ppc970.osdl.org> | 2005-04-16 18:20:36 -0400 |
commit | 1da177e4c3f41524e886b7f1b8a0c1fc7321cac2 (patch) | |
tree | 0bba044c4ce775e45a88a51686b5d9f90697ea9d /drivers/isdn/capi/capiutil.c |
Linux-2.6.12-rc2v2.6.12-rc2
Initial git repository build. I'm not bothering with the full history,
even though we have it. We can create a separate "historical" git
archive of that later if we want to, and in the meantime it's about
3.2GB when imported into git - space that would just make the early
git days unnecessarily complicated, when we don't have a lot of good
infrastructure for it.
Let it rip!
Diffstat (limited to 'drivers/isdn/capi/capiutil.c')
-rw-r--r-- | drivers/isdn/capi/capiutil.c | 859 |
1 files changed, 859 insertions, 0 deletions
diff --git a/drivers/isdn/capi/capiutil.c b/drivers/isdn/capi/capiutil.c new file mode 100644 index 000000000000..e7cf6bc286a6 --- /dev/null +++ b/drivers/isdn/capi/capiutil.c | |||
@@ -0,0 +1,859 @@ | |||
1 | /* $Id: capiutil.c,v 1.13.6.4 2001/09/23 22:24:33 kai Exp $ | ||
2 | * | ||
3 | * CAPI 2.0 convert capi message to capi message struct | ||
4 | * | ||
5 | * From CAPI 2.0 Development Kit AVM 1995 (msg.c) | ||
6 | * Rewritten for Linux 1996 by Carsten Paeth <calle@calle.de> | ||
7 | * | ||
8 | * This software may be used and distributed according to the terms | ||
9 | * of the GNU General Public License, incorporated herein by reference. | ||
10 | * | ||
11 | */ | ||
12 | |||
13 | #include <linux/module.h> | ||
14 | #include <linux/string.h> | ||
15 | #include <linux/ctype.h> | ||
16 | #include <linux/stddef.h> | ||
17 | #include <linux/kernel.h> | ||
18 | #include <linux/mm.h> | ||
19 | #include <linux/init.h> | ||
20 | #include <linux/config.h> | ||
21 | #include <linux/isdn/capiutil.h> | ||
22 | |||
23 | /* from CAPI2.0 DDK AVM Berlin GmbH */ | ||
24 | |||
25 | #ifndef CONFIG_ISDN_DRV_AVMB1_VERBOSE_REASON | ||
26 | char *capi_info2str(u16 reason) | ||
27 | { | ||
28 | return ".."; | ||
29 | } | ||
30 | #else | ||
31 | char *capi_info2str(u16 reason) | ||
32 | { | ||
33 | switch (reason) { | ||
34 | |||
35 | /*-- informative values (corresponding message was processed) -----*/ | ||
36 | case 0x0001: | ||
37 | return "NCPI not supported by current protocol, NCPI ignored"; | ||
38 | case 0x0002: | ||
39 | return "Flags not supported by current protocol, flags ignored"; | ||
40 | case 0x0003: | ||
41 | return "Alert already sent by another application"; | ||
42 | |||
43 | /*-- error information concerning CAPI_REGISTER -----*/ | ||
44 | case 0x1001: | ||
45 | return "Too many applications"; | ||
46 | case 0x1002: | ||
47 | return "Logical block size too small, must be at least 128 Bytes"; | ||
48 | case 0x1003: | ||
49 | return "Buffer exceeds 64 kByte"; | ||
50 | case 0x1004: | ||
51 | return "Message buffer size too small, must be at least 1024 Bytes"; | ||
52 | case 0x1005: | ||
53 | return "Max. number of logical connections not supported"; | ||
54 | case 0x1006: | ||
55 | return "Reserved"; | ||
56 | case 0x1007: | ||
57 | return "The message could not be accepted because of an internal busy condition"; | ||
58 | case 0x1008: | ||
59 | return "OS resource error (no memory ?)"; | ||
60 | case 0x1009: | ||
61 | return "CAPI not installed"; | ||
62 | case 0x100A: | ||
63 | return "Controller does not support external equipment"; | ||
64 | case 0x100B: | ||
65 | return "Controller does only support external equipment"; | ||
66 | |||
67 | /*-- error information concerning message exchange functions -----*/ | ||
68 | case 0x1101: | ||
69 | return "Illegal application number"; | ||
70 | case 0x1102: | ||
71 | return "Illegal command or subcommand or message length less than 12 bytes"; | ||
72 | case 0x1103: | ||
73 | return "The message could not be accepted because of a queue full condition !! The error code does not imply that CAPI cannot receive messages directed to another controller, PLCI or NCCI"; | ||
74 | case 0x1104: | ||
75 | return "Queue is empty"; | ||
76 | case 0x1105: | ||
77 | return "Queue overflow, a message was lost !! This indicates a configuration error. The only recovery from this error is to perform a CAPI_RELEASE"; | ||
78 | case 0x1106: | ||
79 | return "Unknown notification parameter"; | ||
80 | case 0x1107: | ||
81 | return "The Message could not be accepted because of an internal busy condition"; | ||
82 | case 0x1108: | ||
83 | return "OS Resource error (no memory ?)"; | ||
84 | case 0x1109: | ||
85 | return "CAPI not installed"; | ||
86 | case 0x110A: | ||
87 | return "Controller does not support external equipment"; | ||
88 | case 0x110B: | ||
89 | return "Controller does only support external equipment"; | ||
90 | |||
91 | /*-- error information concerning resource / coding problems -----*/ | ||
92 | case 0x2001: | ||
93 | return "Message not supported in current state"; | ||
94 | case 0x2002: | ||
95 | return "Illegal Controller / PLCI / NCCI"; | ||
96 | case 0x2003: | ||
97 | return "Out of PLCI"; | ||
98 | case 0x2004: | ||
99 | return "Out of NCCI"; | ||
100 | case 0x2005: | ||
101 | return "Out of LISTEN"; | ||
102 | case 0x2006: | ||
103 | return "Out of FAX resources (protocol T.30)"; | ||
104 | case 0x2007: | ||
105 | return "Illegal message parameter coding"; | ||
106 | |||
107 | /*-- error information concerning requested services -----*/ | ||
108 | case 0x3001: | ||
109 | return "B1 protocol not supported"; | ||
110 | case 0x3002: | ||
111 | return "B2 protocol not supported"; | ||
112 | case 0x3003: | ||
113 | return "B3 protocol not supported"; | ||
114 | case 0x3004: | ||
115 | return "B1 protocol parameter not supported"; | ||
116 | case 0x3005: | ||
117 | return "B2 protocol parameter not supported"; | ||
118 | case 0x3006: | ||
119 | return "B3 protocol parameter not supported"; | ||
120 | case 0x3007: | ||
121 | return "B protocol combination not supported"; | ||
122 | case 0x3008: | ||
123 | return "NCPI not supported"; | ||
124 | case 0x3009: | ||
125 | return "CIP Value unknown"; | ||
126 | case 0x300A: | ||
127 | return "Flags not supported (reserved bits)"; | ||
128 | case 0x300B: | ||
129 | return "Facility not supported"; | ||
130 | case 0x300C: | ||
131 | return "Data length not supported by current protocol"; | ||
132 | case 0x300D: | ||
133 | return "Reset procedure not supported by current protocol"; | ||
134 | |||
135 | /*-- informations about the clearing of a physical connection -----*/ | ||
136 | case 0x3301: | ||
137 | return "Protocol error layer 1 (broken line or B-channel removed by signalling protocol)"; | ||
138 | case 0x3302: | ||
139 | return "Protocol error layer 2"; | ||
140 | case 0x3303: | ||
141 | return "Protocol error layer 3"; | ||
142 | case 0x3304: | ||
143 | return "Another application got that call"; | ||
144 | /*-- T.30 specific reasons -----*/ | ||
145 | case 0x3311: | ||
146 | return "Connecting not successful (remote station is no FAX G3 machine)"; | ||
147 | case 0x3312: | ||
148 | return "Connecting not successful (training error)"; | ||
149 | case 0x3313: | ||
150 | return "Disconnected before transfer (remote station does not support transfer mode, e.g. resolution)"; | ||
151 | case 0x3314: | ||
152 | return "Disconnected during transfer (remote abort)"; | ||
153 | case 0x3315: | ||
154 | return "Disconnected during transfer (remote procedure error, e.g. unsuccessful repetition of T.30 commands)"; | ||
155 | case 0x3316: | ||
156 | return "Disconnected during transfer (local tx data underrun)"; | ||
157 | case 0x3317: | ||
158 | return "Disconnected during transfer (local rx data overflow)"; | ||
159 | case 0x3318: | ||
160 | return "Disconnected during transfer (local abort)"; | ||
161 | case 0x3319: | ||
162 | return "Illegal parameter coding (e.g. SFF coding error)"; | ||
163 | |||
164 | /*-- disconnect causes from the network according to ETS 300 102-1/Q.931 -----*/ | ||
165 | case 0x3481: return "Unallocated (unassigned) number"; | ||
166 | case 0x3482: return "No route to specified transit network"; | ||
167 | case 0x3483: return "No route to destination"; | ||
168 | case 0x3486: return "Channel unacceptable"; | ||
169 | case 0x3487: | ||
170 | return "Call awarded and being delivered in an established channel"; | ||
171 | case 0x3490: return "Normal call clearing"; | ||
172 | case 0x3491: return "User busy"; | ||
173 | case 0x3492: return "No user responding"; | ||
174 | case 0x3493: return "No answer from user (user alerted)"; | ||
175 | case 0x3495: return "Call rejected"; | ||
176 | case 0x3496: return "Number changed"; | ||
177 | case 0x349A: return "Non-selected user clearing"; | ||
178 | case 0x349B: return "Destination out of order"; | ||
179 | case 0x349C: return "Invalid number format"; | ||
180 | case 0x349D: return "Facility rejected"; | ||
181 | case 0x349E: return "Response to STATUS ENQUIRY"; | ||
182 | case 0x349F: return "Normal, unspecified"; | ||
183 | case 0x34A2: return "No circuit / channel available"; | ||
184 | case 0x34A6: return "Network out of order"; | ||
185 | case 0x34A9: return "Temporary failure"; | ||
186 | case 0x34AA: return "Switching equipment congestion"; | ||
187 | case 0x34AB: return "Access information discarded"; | ||
188 | case 0x34AC: return "Requested circuit / channel not available"; | ||
189 | case 0x34AF: return "Resources unavailable, unspecified"; | ||
190 | case 0x34B1: return "Quality of service unavailable"; | ||
191 | case 0x34B2: return "Requested facility not subscribed"; | ||
192 | case 0x34B9: return "Bearer capability not authorized"; | ||
193 | case 0x34BA: return "Bearer capability not presently available"; | ||
194 | case 0x34BF: return "Service or option not available, unspecified"; | ||
195 | case 0x34C1: return "Bearer capability not implemented"; | ||
196 | case 0x34C2: return "Channel type not implemented"; | ||
197 | case 0x34C5: return "Requested facility not implemented"; | ||
198 | case 0x34C6: return "Only restricted digital information bearer capability is available"; | ||
199 | case 0x34CF: return "Service or option not implemented, unspecified"; | ||
200 | case 0x34D1: return "Invalid call reference value"; | ||
201 | case 0x34D2: return "Identified channel does not exist"; | ||
202 | case 0x34D3: return "A suspended call exists, but this call identity does not"; | ||
203 | case 0x34D4: return "Call identity in use"; | ||
204 | case 0x34D5: return "No call suspended"; | ||
205 | case 0x34D6: return "Call having the requested call identity has been cleared"; | ||
206 | case 0x34D8: return "Incompatible destination"; | ||
207 | case 0x34DB: return "Invalid transit network selection"; | ||
208 | case 0x34DF: return "Invalid message, unspecified"; | ||
209 | case 0x34E0: return "Mandatory information element is missing"; | ||
210 | case 0x34E1: return "Message type non-existent or not implemented"; | ||
211 | case 0x34E2: return "Message not compatible with call state or message type non-existent or not implemented"; | ||
212 | case 0x34E3: return "Information element non-existent or not implemented"; | ||
213 | case 0x34E4: return "Invalid information element contents"; | ||
214 | case 0x34E5: return "Message not compatible with call state"; | ||
215 | case 0x34E6: return "Recovery on timer expiry"; | ||
216 | case 0x34EF: return "Protocol error, unspecified"; | ||
217 | case 0x34FF: return "Interworking, unspecified"; | ||
218 | |||
219 | default: return "No additional information"; | ||
220 | } | ||
221 | } | ||
222 | #endif | ||
223 | |||
224 | typedef struct { | ||
225 | int typ; | ||
226 | size_t off; | ||
227 | } _cdef; | ||
228 | |||
229 | #define _CBYTE 1 | ||
230 | #define _CWORD 2 | ||
231 | #define _CDWORD 3 | ||
232 | #define _CSTRUCT 4 | ||
233 | #define _CMSTRUCT 5 | ||
234 | #define _CEND 6 | ||
235 | |||
236 | static _cdef cdef[] = | ||
237 | { | ||
238 | /*00 */ | ||
239 | {_CEND}, | ||
240 | /*01 */ | ||
241 | {_CEND}, | ||
242 | /*02 */ | ||
243 | {_CEND}, | ||
244 | /*03 */ | ||
245 | {_CDWORD, offsetof(_cmsg, adr.adrController)}, | ||
246 | /*04 */ | ||
247 | {_CMSTRUCT, offsetof(_cmsg, AdditionalInfo)}, | ||
248 | /*05 */ | ||
249 | {_CSTRUCT, offsetof(_cmsg, B1configuration)}, | ||
250 | /*06 */ | ||
251 | {_CWORD, offsetof(_cmsg, B1protocol)}, | ||
252 | /*07 */ | ||
253 | {_CSTRUCT, offsetof(_cmsg, B2configuration)}, | ||
254 | /*08 */ | ||
255 | {_CWORD, offsetof(_cmsg, B2protocol)}, | ||
256 | /*09 */ | ||
257 | {_CSTRUCT, offsetof(_cmsg, B3configuration)}, | ||
258 | /*0a */ | ||
259 | {_CWORD, offsetof(_cmsg, B3protocol)}, | ||
260 | /*0b */ | ||
261 | {_CSTRUCT, offsetof(_cmsg, BC)}, | ||
262 | /*0c */ | ||
263 | {_CSTRUCT, offsetof(_cmsg, BChannelinformation)}, | ||
264 | /*0d */ | ||
265 | {_CMSTRUCT, offsetof(_cmsg, BProtocol)}, | ||
266 | /*0e */ | ||
267 | {_CSTRUCT, offsetof(_cmsg, CalledPartyNumber)}, | ||
268 | /*0f */ | ||
269 | {_CSTRUCT, offsetof(_cmsg, CalledPartySubaddress)}, | ||
270 | /*10 */ | ||
271 | {_CSTRUCT, offsetof(_cmsg, CallingPartyNumber)}, | ||
272 | /*11 */ | ||
273 | {_CSTRUCT, offsetof(_cmsg, CallingPartySubaddress)}, | ||
274 | /*12 */ | ||
275 | {_CDWORD, offsetof(_cmsg, CIPmask)}, | ||
276 | /*13 */ | ||
277 | {_CDWORD, offsetof(_cmsg, CIPmask2)}, | ||
278 | /*14 */ | ||
279 | {_CWORD, offsetof(_cmsg, CIPValue)}, | ||
280 | /*15 */ | ||
281 | {_CDWORD, offsetof(_cmsg, Class)}, | ||
282 | /*16 */ | ||
283 | {_CSTRUCT, offsetof(_cmsg, ConnectedNumber)}, | ||
284 | /*17 */ | ||
285 | {_CSTRUCT, offsetof(_cmsg, ConnectedSubaddress)}, | ||
286 | /*18 */ | ||
287 | {_CDWORD, offsetof(_cmsg, Data)}, | ||
288 | /*19 */ | ||
289 | {_CWORD, offsetof(_cmsg, DataHandle)}, | ||
290 | /*1a */ | ||
291 | {_CWORD, offsetof(_cmsg, DataLength)}, | ||
292 | /*1b */ | ||
293 | {_CSTRUCT, offsetof(_cmsg, FacilityConfirmationParameter)}, | ||
294 | /*1c */ | ||
295 | {_CSTRUCT, offsetof(_cmsg, Facilitydataarray)}, | ||
296 | /*1d */ | ||
297 | {_CSTRUCT, offsetof(_cmsg, FacilityIndicationParameter)}, | ||
298 | /*1e */ | ||
299 | {_CSTRUCT, offsetof(_cmsg, FacilityRequestParameter)}, | ||
300 | /*1f */ | ||
301 | {_CWORD, offsetof(_cmsg, FacilitySelector)}, | ||
302 | /*20 */ | ||
303 | {_CWORD, offsetof(_cmsg, Flags)}, | ||
304 | /*21 */ | ||
305 | {_CDWORD, offsetof(_cmsg, Function)}, | ||
306 | /*22 */ | ||
307 | {_CSTRUCT, offsetof(_cmsg, HLC)}, | ||
308 | /*23 */ | ||
309 | {_CWORD, offsetof(_cmsg, Info)}, | ||
310 | /*24 */ | ||
311 | {_CSTRUCT, offsetof(_cmsg, InfoElement)}, | ||
312 | /*25 */ | ||
313 | {_CDWORD, offsetof(_cmsg, InfoMask)}, | ||
314 | /*26 */ | ||
315 | {_CWORD, offsetof(_cmsg, InfoNumber)}, | ||
316 | /*27 */ | ||
317 | {_CSTRUCT, offsetof(_cmsg, Keypadfacility)}, | ||
318 | /*28 */ | ||
319 | {_CSTRUCT, offsetof(_cmsg, LLC)}, | ||
320 | /*29 */ | ||
321 | {_CSTRUCT, offsetof(_cmsg, ManuData)}, | ||
322 | /*2a */ | ||
323 | {_CDWORD, offsetof(_cmsg, ManuID)}, | ||
324 | /*2b */ | ||
325 | {_CSTRUCT, offsetof(_cmsg, NCPI)}, | ||
326 | /*2c */ | ||
327 | {_CWORD, offsetof(_cmsg, Reason)}, | ||
328 | /*2d */ | ||
329 | {_CWORD, offsetof(_cmsg, Reason_B3)}, | ||
330 | /*2e */ | ||
331 | {_CWORD, offsetof(_cmsg, Reject)}, | ||
332 | /*2f */ | ||
333 | {_CSTRUCT, offsetof(_cmsg, Useruserdata)} | ||
334 | }; | ||
335 | |||
336 | static unsigned char *cpars[] = | ||
337 | { | ||
338 | /* ALERT_REQ */ [0x01] = "\x03\x04\x0c\x27\x2f\x1c\x01\x01", | ||
339 | /* CONNECT_REQ */ [0x02] = "\x03\x14\x0e\x10\x0f\x11\x0d\x06\x08\x0a\x05\x07\x09\x01\x0b\x28\x22\x04\x0c\x27\x2f\x1c\x01\x01", | ||
340 | /* DISCONNECT_REQ */ [0x04] = "\x03\x04\x0c\x27\x2f\x1c\x01\x01", | ||
341 | /* LISTEN_REQ */ [0x05] = "\x03\x25\x12\x13\x10\x11\x01", | ||
342 | /* INFO_REQ */ [0x08] = "\x03\x0e\x04\x0c\x27\x2f\x1c\x01\x01", | ||
343 | /* FACILITY_REQ */ [0x09] = "\x03\x1f\x1e\x01", | ||
344 | /* SELECT_B_PROTOCOL_REQ */ [0x0a] = "\x03\x0d\x06\x08\x0a\x05\x07\x09\x01\x01", | ||
345 | /* CONNECT_B3_REQ */ [0x0b] = "\x03\x2b\x01", | ||
346 | /* DISCONNECT_B3_REQ */ [0x0d] = "\x03\x2b\x01", | ||
347 | /* DATA_B3_REQ */ [0x0f] = "\x03\x18\x1a\x19\x20\x01", | ||
348 | /* RESET_B3_REQ */ [0x10] = "\x03\x2b\x01", | ||
349 | /* ALERT_CONF */ [0x13] = "\x03\x23\x01", | ||
350 | /* CONNECT_CONF */ [0x14] = "\x03\x23\x01", | ||
351 | /* DISCONNECT_CONF */ [0x16] = "\x03\x23\x01", | ||
352 | /* LISTEN_CONF */ [0x17] = "\x03\x23\x01", | ||
353 | /* MANUFACTURER_REQ */ [0x18] = "\x03\x2a\x15\x21\x29\x01", | ||
354 | /* INFO_CONF */ [0x1a] = "\x03\x23\x01", | ||
355 | /* FACILITY_CONF */ [0x1b] = "\x03\x23\x1f\x1b\x01", | ||
356 | /* SELECT_B_PROTOCOL_CONF */ [0x1c] = "\x03\x23\x01", | ||
357 | /* CONNECT_B3_CONF */ [0x1d] = "\x03\x23\x01", | ||
358 | /* DISCONNECT_B3_CONF */ [0x1f] = "\x03\x23\x01", | ||
359 | /* DATA_B3_CONF */ [0x21] = "\x03\x19\x23\x01", | ||
360 | /* RESET_B3_CONF */ [0x22] = "\x03\x23\x01", | ||
361 | /* CONNECT_IND */ [0x26] = "\x03\x14\x0e\x10\x0f\x11\x0b\x28\x22\x04\x0c\x27\x2f\x1c\x01\x01", | ||
362 | /* CONNECT_ACTIVE_IND */ [0x27] = "\x03\x16\x17\x28\x01", | ||
363 | /* DISCONNECT_IND */ [0x28] = "\x03\x2c\x01", | ||
364 | /* MANUFACTURER_CONF */ [0x2a] = "\x03\x2a\x15\x21\x29\x01", | ||
365 | /* INFO_IND */ [0x2c] = "\x03\x26\x24\x01", | ||
366 | /* FACILITY_IND */ [0x2d] = "\x03\x1f\x1d\x01", | ||
367 | /* CONNECT_B3_IND */ [0x2f] = "\x03\x2b\x01", | ||
368 | /* CONNECT_B3_ACTIVE_IND */ [0x30] = "\x03\x2b\x01", | ||
369 | /* DISCONNECT_B3_IND */ [0x31] = "\x03\x2d\x2b\x01", | ||
370 | /* DATA_B3_IND */ [0x33] = "\x03\x18\x1a\x19\x20\x01", | ||
371 | /* RESET_B3_IND */ [0x34] = "\x03\x2b\x01", | ||
372 | /* CONNECT_B3_T90_ACTIVE_IND */ [0x35] = "\x03\x2b\x01", | ||
373 | /* CONNECT_RESP */ [0x38] = "\x03\x2e\x0d\x06\x08\x0a\x05\x07\x09\x01\x16\x17\x28\x04\x0c\x27\x2f\x1c\x01\x01", | ||
374 | /* CONNECT_ACTIVE_RESP */ [0x39] = "\x03\x01", | ||
375 | /* DISCONNECT_RESP */ [0x3a] = "\x03\x01", | ||
376 | /* MANUFACTURER_IND */ [0x3c] = "\x03\x2a\x15\x21\x29\x01", | ||
377 | /* INFO_RESP */ [0x3e] = "\x03\x01", | ||
378 | /* FACILITY_RESP */ [0x3f] = "\x03\x1f\x01", | ||
379 | /* CONNECT_B3_RESP */ [0x41] = "\x03\x2e\x2b\x01", | ||
380 | /* CONNECT_B3_ACTIVE_RESP */ [0x42] = "\x03\x01", | ||
381 | /* DISCONNECT_B3_RESP */ [0x43] = "\x03\x01", | ||
382 | /* DATA_B3_RESP */ [0x45] = "\x03\x19\x01", | ||
383 | /* RESET_B3_RESP */ [0x46] = "\x03\x01", | ||
384 | /* CONNECT_B3_T90_ACTIVE_RESP */ [0x47] = "\x03\x01", | ||
385 | /* MANUFACTURER_RESP */ [0x4e] = "\x03\x2a\x15\x21\x29\x01", | ||
386 | }; | ||
387 | |||
388 | /*-------------------------------------------------------*/ | ||
389 | |||
390 | #define byteTLcpy(x,y) *(u8 *)(x)=*(u8 *)(y); | ||
391 | #define wordTLcpy(x,y) *(u16 *)(x)=*(u16 *)(y); | ||
392 | #define dwordTLcpy(x,y) memcpy(x,y,4); | ||
393 | #define structTLcpy(x,y,l) memcpy (x,y,l) | ||
394 | #define structTLcpyovl(x,y,l) memmove (x,y,l) | ||
395 | |||
396 | #define byteTRcpy(x,y) *(u8 *)(y)=*(u8 *)(x); | ||
397 | #define wordTRcpy(x,y) *(u16 *)(y)=*(u16 *)(x); | ||
398 | #define dwordTRcpy(x,y) memcpy(y,x,4); | ||
399 | #define structTRcpy(x,y,l) memcpy (y,x,l) | ||
400 | #define structTRcpyovl(x,y,l) memmove (y,x,l) | ||
401 | |||
402 | /*-------------------------------------------------------*/ | ||
403 | static unsigned command_2_index(unsigned c, unsigned sc) | ||
404 | { | ||
405 | if (c & 0x80) | ||
406 | c = 0x9 + (c & 0x0f); | ||
407 | else if (c <= 0x0f); | ||
408 | else if (c == 0x41) | ||
409 | c = 0x9 + 0x1; | ||
410 | else if (c == 0xff) | ||
411 | c = 0x00; | ||
412 | return (sc & 3) * (0x9 + 0x9) + c; | ||
413 | } | ||
414 | |||
415 | /*-------------------------------------------------------*/ | ||
416 | #define TYP (cdef[cmsg->par[cmsg->p]].typ) | ||
417 | #define OFF (((u8 *)cmsg)+cdef[cmsg->par[cmsg->p]].off) | ||
418 | |||
419 | static void jumpcstruct(_cmsg * cmsg) | ||
420 | { | ||
421 | unsigned layer; | ||
422 | for (cmsg->p++, layer = 1; layer;) { | ||
423 | /* $$$$$ assert (cmsg->p); */ | ||
424 | cmsg->p++; | ||
425 | switch (TYP) { | ||
426 | case _CMSTRUCT: | ||
427 | layer++; | ||
428 | break; | ||
429 | case _CEND: | ||
430 | layer--; | ||
431 | break; | ||
432 | } | ||
433 | } | ||
434 | } | ||
435 | /*-------------------------------------------------------*/ | ||
436 | static void pars_2_message(_cmsg * cmsg) | ||
437 | { | ||
438 | |||
439 | for (; TYP != _CEND; cmsg->p++) { | ||
440 | switch (TYP) { | ||
441 | case _CBYTE: | ||
442 | byteTLcpy(cmsg->m + cmsg->l, OFF); | ||
443 | cmsg->l++; | ||
444 | break; | ||
445 | case _CWORD: | ||
446 | wordTLcpy(cmsg->m + cmsg->l, OFF); | ||
447 | cmsg->l += 2; | ||
448 | break; | ||
449 | case _CDWORD: | ||
450 | dwordTLcpy(cmsg->m + cmsg->l, OFF); | ||
451 | cmsg->l += 4; | ||
452 | break; | ||
453 | case _CSTRUCT: | ||
454 | if (*(u8 **) OFF == 0) { | ||
455 | *(cmsg->m + cmsg->l) = '\0'; | ||
456 | cmsg->l++; | ||
457 | } else if (**(_cstruct *) OFF != 0xff) { | ||
458 | structTLcpy(cmsg->m + cmsg->l, *(_cstruct *) OFF, 1 + **(_cstruct *) OFF); | ||
459 | cmsg->l += 1 + **(_cstruct *) OFF; | ||
460 | } else { | ||
461 | _cstruct s = *(_cstruct *) OFF; | ||
462 | structTLcpy(cmsg->m + cmsg->l, s, 3 + *(u16 *) (s + 1)); | ||
463 | cmsg->l += 3 + *(u16 *) (s + 1); | ||
464 | } | ||
465 | break; | ||
466 | case _CMSTRUCT: | ||
467 | /*----- Metastruktur 0 -----*/ | ||
468 | if (*(_cmstruct *) OFF == CAPI_DEFAULT) { | ||
469 | *(cmsg->m + cmsg->l) = '\0'; | ||
470 | cmsg->l++; | ||
471 | jumpcstruct(cmsg); | ||
472 | } | ||
473 | /*----- Metastruktur wird composed -----*/ | ||
474 | else { | ||
475 | unsigned _l = cmsg->l; | ||
476 | unsigned _ls; | ||
477 | cmsg->l++; | ||
478 | cmsg->p++; | ||
479 | pars_2_message(cmsg); | ||
480 | _ls = cmsg->l - _l - 1; | ||
481 | if (_ls < 255) | ||
482 | (cmsg->m + _l)[0] = (u8) _ls; | ||
483 | else { | ||
484 | structTLcpyovl(cmsg->m + _l + 3, cmsg->m + _l + 1, _ls); | ||
485 | (cmsg->m + _l)[0] = 0xff; | ||
486 | wordTLcpy(cmsg->m + _l + 1, &_ls); | ||
487 | } | ||
488 | } | ||
489 | break; | ||
490 | } | ||
491 | } | ||
492 | } | ||
493 | |||
494 | /*-------------------------------------------------------*/ | ||
495 | unsigned capi_cmsg2message(_cmsg * cmsg, u8 * msg) | ||
496 | { | ||
497 | cmsg->m = msg; | ||
498 | cmsg->l = 8; | ||
499 | cmsg->p = 0; | ||
500 | cmsg->par = cpars[command_2_index(cmsg->Command, cmsg->Subcommand)]; | ||
501 | |||
502 | pars_2_message(cmsg); | ||
503 | |||
504 | wordTLcpy(msg + 0, &cmsg->l); | ||
505 | byteTLcpy(cmsg->m + 4, &cmsg->Command); | ||
506 | byteTLcpy(cmsg->m + 5, &cmsg->Subcommand); | ||
507 | wordTLcpy(cmsg->m + 2, &cmsg->ApplId); | ||
508 | wordTLcpy(cmsg->m + 6, &cmsg->Messagenumber); | ||
509 | |||
510 | return 0; | ||
511 | } | ||
512 | |||
513 | /*-------------------------------------------------------*/ | ||
514 | static void message_2_pars(_cmsg * cmsg) | ||
515 | { | ||
516 | for (; TYP != _CEND; cmsg->p++) { | ||
517 | |||
518 | switch (TYP) { | ||
519 | case _CBYTE: | ||
520 | byteTRcpy(cmsg->m + cmsg->l, OFF); | ||
521 | cmsg->l++; | ||
522 | break; | ||
523 | case _CWORD: | ||
524 | wordTRcpy(cmsg->m + cmsg->l, OFF); | ||
525 | cmsg->l += 2; | ||
526 | break; | ||
527 | case _CDWORD: | ||
528 | dwordTRcpy(cmsg->m + cmsg->l, OFF); | ||
529 | cmsg->l += 4; | ||
530 | break; | ||
531 | case _CSTRUCT: | ||
532 | *(u8 **) OFF = cmsg->m + cmsg->l; | ||
533 | |||
534 | if (cmsg->m[cmsg->l] != 0xff) | ||
535 | cmsg->l += 1 + cmsg->m[cmsg->l]; | ||
536 | else | ||
537 | cmsg->l += 3 + *(u16 *) (cmsg->m + cmsg->l + 1); | ||
538 | break; | ||
539 | case _CMSTRUCT: | ||
540 | /*----- Metastruktur 0 -----*/ | ||
541 | if (cmsg->m[cmsg->l] == '\0') { | ||
542 | *(_cmstruct *) OFF = CAPI_DEFAULT; | ||
543 | cmsg->l++; | ||
544 | jumpcstruct(cmsg); | ||
545 | } else { | ||
546 | unsigned _l = cmsg->l; | ||
547 | *(_cmstruct *) OFF = CAPI_COMPOSE; | ||
548 | cmsg->l = (cmsg->m + _l)[0] == 255 ? cmsg->l + 3 : cmsg->l + 1; | ||
549 | cmsg->p++; | ||
550 | message_2_pars(cmsg); | ||
551 | } | ||
552 | break; | ||
553 | } | ||
554 | } | ||
555 | } | ||
556 | |||
557 | /*-------------------------------------------------------*/ | ||
558 | unsigned capi_message2cmsg(_cmsg * cmsg, u8 * msg) | ||
559 | { | ||
560 | memset(cmsg, 0, sizeof(_cmsg)); | ||
561 | cmsg->m = msg; | ||
562 | cmsg->l = 8; | ||
563 | cmsg->p = 0; | ||
564 | byteTRcpy(cmsg->m + 4, &cmsg->Command); | ||
565 | byteTRcpy(cmsg->m + 5, &cmsg->Subcommand); | ||
566 | cmsg->par = cpars[command_2_index(cmsg->Command, cmsg->Subcommand)]; | ||
567 | |||
568 | message_2_pars(cmsg); | ||
569 | |||
570 | wordTRcpy(msg + 0, &cmsg->l); | ||
571 | wordTRcpy(cmsg->m + 2, &cmsg->ApplId); | ||
572 | wordTRcpy(cmsg->m + 6, &cmsg->Messagenumber); | ||
573 | |||
574 | return 0; | ||
575 | } | ||
576 | |||
577 | /*-------------------------------------------------------*/ | ||
578 | unsigned capi_cmsg_header(_cmsg * cmsg, u16 _ApplId, | ||
579 | u8 _Command, u8 _Subcommand, | ||
580 | u16 _Messagenumber, u32 _Controller) | ||
581 | { | ||
582 | memset(cmsg, 0, sizeof(_cmsg)); | ||
583 | cmsg->ApplId = _ApplId; | ||
584 | cmsg->Command = _Command; | ||
585 | cmsg->Subcommand = _Subcommand; | ||
586 | cmsg->Messagenumber = _Messagenumber; | ||
587 | cmsg->adr.adrController = _Controller; | ||
588 | return 0; | ||
589 | } | ||
590 | |||
591 | /*-------------------------------------------------------*/ | ||
592 | |||
593 | static char *mnames[] = | ||
594 | { | ||
595 | [0x01] = "ALERT_REQ", | ||
596 | [0x02] = "CONNECT_REQ", | ||
597 | [0x04] = "DISCONNECT_REQ", | ||
598 | [0x05] = "LISTEN_REQ", | ||
599 | [0x08] = "INFO_REQ", | ||
600 | [0x09] = "FACILITY_REQ", | ||
601 | [0x0a] = "SELECT_B_PROTOCOL_REQ", | ||
602 | [0x0b] = "CONNECT_B3_REQ", | ||
603 | [0x0d] = "DISCONNECT_B3_REQ", | ||
604 | [0x0f] = "DATA_B3_REQ", | ||
605 | [0x10] = "RESET_B3_REQ", | ||
606 | [0x13] = "ALERT_CONF", | ||
607 | [0x14] = "CONNECT_CONF", | ||
608 | [0x16] = "DISCONNECT_CONF", | ||
609 | [0x17] = "LISTEN_CONF", | ||
610 | [0x18] = "MANUFACTURER_REQ", | ||
611 | [0x1a] = "INFO_CONF", | ||
612 | [0x1b] = "FACILITY_CONF", | ||
613 | [0x1c] = "SELECT_B_PROTOCOL_CONF", | ||
614 | [0x1d] = "CONNECT_B3_CONF", | ||
615 | [0x1f] = "DISCONNECT_B3_CONF", | ||
616 | [0x21] = "DATA_B3_CONF", | ||
617 | [0x22] = "RESET_B3_CONF", | ||
618 | [0x26] = "CONNECT_IND", | ||
619 | [0x27] = "CONNECT_ACTIVE_IND", | ||
620 | [0x28] = "DISCONNECT_IND", | ||
621 | [0x2a] = "MANUFACTURER_CONF", | ||
622 | [0x2c] = "INFO_IND", | ||
623 | [0x2d] = "FACILITY_IND", | ||
624 | [0x2f] = "CONNECT_B3_IND", | ||
625 | [0x30] = "CONNECT_B3_ACTIVE_IND", | ||
626 | [0x31] = "DISCONNECT_B3_IND", | ||
627 | [0x33] = "DATA_B3_IND", | ||
628 | [0x34] = "RESET_B3_IND", | ||
629 | [0x35] = "CONNECT_B3_T90_ACTIVE_IND", | ||
630 | [0x38] = "CONNECT_RESP", | ||
631 | [0x39] = "CONNECT_ACTIVE_RESP", | ||
632 | [0x3a] = "DISCONNECT_RESP", | ||
633 | [0x3c] = "MANUFACTURER_IND", | ||
634 | [0x3e] = "INFO_RESP", | ||
635 | [0x3f] = "FACILITY_RESP", | ||
636 | [0x41] = "CONNECT_B3_RESP", | ||
637 | [0x42] = "CONNECT_B3_ACTIVE_RESP", | ||
638 | [0x43] = "DISCONNECT_B3_RESP", | ||
639 | [0x45] = "DATA_B3_RESP", | ||
640 | [0x46] = "RESET_B3_RESP", | ||
641 | [0x47] = "CONNECT_B3_T90_ACTIVE_RESP", | ||
642 | [0x4e] = "MANUFACTURER_RESP" | ||
643 | }; | ||
644 | |||
645 | char *capi_cmd2str(u8 cmd, u8 subcmd) | ||
646 | { | ||
647 | return mnames[command_2_index(cmd, subcmd)]; | ||
648 | } | ||
649 | |||
650 | |||
651 | /*-------------------------------------------------------*/ | ||
652 | /*-------------------------------------------------------*/ | ||
653 | |||
654 | static char *pnames[] = | ||
655 | { | ||
656 | /*00 */ NULL, | ||
657 | /*01 */ NULL, | ||
658 | /*02 */ NULL, | ||
659 | /*03 */ "Controller/PLCI/NCCI", | ||
660 | /*04 */ "AdditionalInfo", | ||
661 | /*05 */ "B1configuration", | ||
662 | /*06 */ "B1protocol", | ||
663 | /*07 */ "B2configuration", | ||
664 | /*08 */ "B2protocol", | ||
665 | /*09 */ "B3configuration", | ||
666 | /*0a */ "B3protocol", | ||
667 | /*0b */ "BC", | ||
668 | /*0c */ "BChannelinformation", | ||
669 | /*0d */ "BProtocol", | ||
670 | /*0e */ "CalledPartyNumber", | ||
671 | /*0f */ "CalledPartySubaddress", | ||
672 | /*10 */ "CallingPartyNumber", | ||
673 | /*11 */ "CallingPartySubaddress", | ||
674 | /*12 */ "CIPmask", | ||
675 | /*13 */ "CIPmask2", | ||
676 | /*14 */ "CIPValue", | ||
677 | /*15 */ "Class", | ||
678 | /*16 */ "ConnectedNumber", | ||
679 | /*17 */ "ConnectedSubaddress", | ||
680 | /*18 */ "Data32", | ||
681 | /*19 */ "DataHandle", | ||
682 | /*1a */ "DataLength", | ||
683 | /*1b */ "FacilityConfirmationParameter", | ||
684 | /*1c */ "Facilitydataarray", | ||
685 | /*1d */ "FacilityIndicationParameter", | ||
686 | /*1e */ "FacilityRequestParameter", | ||
687 | /*1f */ "FacilitySelector", | ||
688 | /*20 */ "Flags", | ||
689 | /*21 */ "Function", | ||
690 | /*22 */ "HLC", | ||
691 | /*23 */ "Info", | ||
692 | /*24 */ "InfoElement", | ||
693 | /*25 */ "InfoMask", | ||
694 | /*26 */ "InfoNumber", | ||
695 | /*27 */ "Keypadfacility", | ||
696 | /*28 */ "LLC", | ||
697 | /*29 */ "ManuData", | ||
698 | /*2a */ "ManuID", | ||
699 | /*2b */ "NCPI", | ||
700 | /*2c */ "Reason", | ||
701 | /*2d */ "Reason_B3", | ||
702 | /*2e */ "Reject", | ||
703 | /*2f */ "Useruserdata" | ||
704 | }; | ||
705 | |||
706 | |||
707 | static char buf[8192]; | ||
708 | static char *p = NULL; | ||
709 | |||
710 | #include <stdarg.h> | ||
711 | |||
712 | /*-------------------------------------------------------*/ | ||
713 | static void bufprint(char *fmt,...) | ||
714 | { | ||
715 | va_list f; | ||
716 | va_start(f, fmt); | ||
717 | vsprintf(p, fmt, f); | ||
718 | va_end(f); | ||
719 | p += strlen(p); | ||
720 | } | ||
721 | |||
722 | static void printstructlen(u8 * m, unsigned len) | ||
723 | { | ||
724 | unsigned hex = 0; | ||
725 | for (; len; len--, m++) | ||
726 | if (isalnum(*m) || *m == ' ') { | ||
727 | if (hex) | ||
728 | bufprint(">"); | ||
729 | bufprint("%c", *m); | ||
730 | hex = 0; | ||
731 | } else { | ||
732 | if (!hex) | ||
733 | bufprint("<%02x", *m); | ||
734 | else | ||
735 | bufprint(" %02x", *m); | ||
736 | hex = 1; | ||
737 | } | ||
738 | if (hex) | ||
739 | bufprint(">"); | ||
740 | } | ||
741 | |||
742 | static void printstruct(u8 * m) | ||
743 | { | ||
744 | unsigned len; | ||
745 | if (m[0] != 0xff) { | ||
746 | len = m[0]; | ||
747 | m += 1; | ||
748 | } else { | ||
749 | len = ((u16 *) (m + 1))[0]; | ||
750 | m += 3; | ||
751 | } | ||
752 | printstructlen(m, len); | ||
753 | } | ||
754 | |||
755 | /*-------------------------------------------------------*/ | ||
756 | #define NAME (pnames[cmsg->par[cmsg->p]]) | ||
757 | |||
758 | static void protocol_message_2_pars(_cmsg * cmsg, int level) | ||
759 | { | ||
760 | for (; TYP != _CEND; cmsg->p++) { | ||
761 | int slen = 29 + 3 - level; | ||
762 | int i; | ||
763 | |||
764 | bufprint(" "); | ||
765 | for (i = 0; i < level - 1; i++) | ||
766 | bufprint(" "); | ||
767 | |||
768 | switch (TYP) { | ||
769 | case _CBYTE: | ||
770 | bufprint("%-*s = 0x%x\n", slen, NAME, *(u8 *) (cmsg->m + cmsg->l)); | ||
771 | cmsg->l++; | ||
772 | break; | ||
773 | case _CWORD: | ||
774 | bufprint("%-*s = 0x%x\n", slen, NAME, *(u16 *) (cmsg->m + cmsg->l)); | ||
775 | cmsg->l += 2; | ||
776 | break; | ||
777 | case _CDWORD: | ||
778 | bufprint("%-*s = 0x%lx\n", slen, NAME, *(u32 *) (cmsg->m + cmsg->l)); | ||
779 | cmsg->l += 4; | ||
780 | break; | ||
781 | case _CSTRUCT: | ||
782 | bufprint("%-*s = ", slen, NAME); | ||
783 | if (cmsg->m[cmsg->l] == '\0') | ||
784 | bufprint("default"); | ||
785 | else | ||
786 | printstruct(cmsg->m + cmsg->l); | ||
787 | bufprint("\n"); | ||
788 | if (cmsg->m[cmsg->l] != 0xff) | ||
789 | cmsg->l += 1 + cmsg->m[cmsg->l]; | ||
790 | else | ||
791 | cmsg->l += 3 + *(u16 *) (cmsg->m + cmsg->l + 1); | ||
792 | |||
793 | break; | ||
794 | |||
795 | case _CMSTRUCT: | ||
796 | /*----- Metastruktur 0 -----*/ | ||
797 | if (cmsg->m[cmsg->l] == '\0') { | ||
798 | bufprint("%-*s = default\n", slen, NAME); | ||
799 | cmsg->l++; | ||
800 | jumpcstruct(cmsg); | ||
801 | } else { | ||
802 | char *name = NAME; | ||
803 | unsigned _l = cmsg->l; | ||
804 | bufprint("%-*s\n", slen, name); | ||
805 | cmsg->l = (cmsg->m + _l)[0] == 255 ? cmsg->l + 3 : cmsg->l + 1; | ||
806 | cmsg->p++; | ||
807 | protocol_message_2_pars(cmsg, level + 1); | ||
808 | } | ||
809 | break; | ||
810 | } | ||
811 | } | ||
812 | } | ||
813 | /*-------------------------------------------------------*/ | ||
814 | char *capi_message2str(u8 * msg) | ||
815 | { | ||
816 | |||
817 | _cmsg cmsg; | ||
818 | p = buf; | ||
819 | p[0] = 0; | ||
820 | |||
821 | cmsg.m = msg; | ||
822 | cmsg.l = 8; | ||
823 | cmsg.p = 0; | ||
824 | byteTRcpy(cmsg.m + 4, &cmsg.Command); | ||
825 | byteTRcpy(cmsg.m + 5, &cmsg.Subcommand); | ||
826 | cmsg.par = cpars[command_2_index(cmsg.Command, cmsg.Subcommand)]; | ||
827 | |||
828 | bufprint("%-26s ID=%03d #0x%04x LEN=%04d\n", | ||
829 | mnames[command_2_index(cmsg.Command, cmsg.Subcommand)], | ||
830 | ((unsigned short *) msg)[1], | ||
831 | ((unsigned short *) msg)[3], | ||
832 | ((unsigned short *) msg)[0]); | ||
833 | |||
834 | protocol_message_2_pars(&cmsg, 1); | ||
835 | return buf; | ||
836 | } | ||
837 | |||
838 | char *capi_cmsg2str(_cmsg * cmsg) | ||
839 | { | ||
840 | p = buf; | ||
841 | p[0] = 0; | ||
842 | cmsg->l = 8; | ||
843 | cmsg->p = 0; | ||
844 | bufprint("%s ID=%03d #0x%04x LEN=%04d\n", | ||
845 | mnames[command_2_index(cmsg->Command, cmsg->Subcommand)], | ||
846 | ((u16 *) cmsg->m)[1], | ||
847 | ((u16 *) cmsg->m)[3], | ||
848 | ((u16 *) cmsg->m)[0]); | ||
849 | protocol_message_2_pars(cmsg, 1); | ||
850 | return buf; | ||
851 | } | ||
852 | |||
853 | EXPORT_SYMBOL(capi_cmsg2message); | ||
854 | EXPORT_SYMBOL(capi_message2cmsg); | ||
855 | EXPORT_SYMBOL(capi_cmsg_header); | ||
856 | EXPORT_SYMBOL(capi_cmd2str); | ||
857 | EXPORT_SYMBOL(capi_cmsg2str); | ||
858 | EXPORT_SYMBOL(capi_message2str); | ||
859 | EXPORT_SYMBOL(capi_info2str); | ||