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/isdn/capiutil.h> 21#include <linux/slab.h> 22 23/* from CAPI2.0 DDK AVM Berlin GmbH */ 24 25#ifndef CONFIG_ISDN_DRV_AVMB1_VERBOSE_REASON 26char *capi_info2str(u16 reason) 27{ 28 return ".."; 29} 30#else 31char *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 224typedef 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 236static _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 336static 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/*-------------------------------------------------------*/ 403static 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 419static 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/*-------------------------------------------------------*/ 436static 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 == NULL) { 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 * capi_cmsg2message() - assemble CAPI 2.0 message from _cmsg structure 496 * @cmsg: _cmsg structure 497 * @msg: buffer for assembled message 498 * 499 * Return value: 0 for success 500 */ 501 502unsigned capi_cmsg2message(_cmsg *cmsg, u8 *msg) 503{ 504 cmsg->m = msg; 505 cmsg->l = 8; 506 cmsg->p = 0; 507 cmsg->par = cpars[command_2_index(cmsg->Command, cmsg->Subcommand)]; 508 509 pars_2_message(cmsg); 510 511 wordTLcpy(msg + 0, &cmsg->l); 512 byteTLcpy(cmsg->m + 4, &cmsg->Command); 513 byteTLcpy(cmsg->m + 5, &cmsg->Subcommand); 514 wordTLcpy(cmsg->m + 2, &cmsg->ApplId); 515 wordTLcpy(cmsg->m + 6, &cmsg->Messagenumber); 516 517 return 0; 518} 519 520/*-------------------------------------------------------*/ 521static void message_2_pars(_cmsg *cmsg) 522{ 523 for (; TYP != _CEND; cmsg->p++) { 524 525 switch (TYP) { 526 case _CBYTE: 527 byteTRcpy(cmsg->m + cmsg->l, OFF); 528 cmsg->l++; 529 break; 530 case _CWORD: 531 wordTRcpy(cmsg->m + cmsg->l, OFF); 532 cmsg->l += 2; 533 break; 534 case _CDWORD: 535 dwordTRcpy(cmsg->m + cmsg->l, OFF); 536 cmsg->l += 4; 537 break; 538 case _CSTRUCT: 539 *(u8 **) OFF = cmsg->m + cmsg->l; 540 541 if (cmsg->m[cmsg->l] != 0xff) 542 cmsg->l += 1 + cmsg->m[cmsg->l]; 543 else 544 cmsg->l += 3 + *(u16 *) (cmsg->m + cmsg->l + 1); 545 break; 546 case _CMSTRUCT: 547/*----- Metastruktur 0 -----*/ 548 if (cmsg->m[cmsg->l] == '\0') { 549 *(_cmstruct *) OFF = CAPI_DEFAULT; 550 cmsg->l++; 551 jumpcstruct(cmsg); 552 } else { 553 unsigned _l = cmsg->l; 554 *(_cmstruct *) OFF = CAPI_COMPOSE; 555 cmsg->l = (cmsg->m + _l)[0] == 255 ? cmsg->l + 3 : cmsg->l + 1; 556 cmsg->p++; 557 message_2_pars(cmsg); 558 } 559 break; 560 } 561 } 562} 563 564/** 565 * capi_message2cmsg() - disassemble CAPI 2.0 message into _cmsg structure 566 * @cmsg: _cmsg structure 567 * @msg: buffer for assembled message 568 * 569 * Return value: 0 for success 570 */ 571 572unsigned capi_message2cmsg(_cmsg *cmsg, u8 *msg) 573{ 574 memset(cmsg, 0, sizeof(_cmsg)); 575 cmsg->m = msg; 576 cmsg->l = 8; 577 cmsg->p = 0; 578 byteTRcpy(cmsg->m + 4, &cmsg->Command); 579 byteTRcpy(cmsg->m + 5, &cmsg->Subcommand); 580 cmsg->par = cpars[command_2_index(cmsg->Command, cmsg->Subcommand)]; 581 582 message_2_pars(cmsg); 583 584 wordTRcpy(msg + 0, &cmsg->l); 585 wordTRcpy(cmsg->m + 2, &cmsg->ApplId); 586 wordTRcpy(cmsg->m + 6, &cmsg->Messagenumber); 587 588 return 0; 589} 590 591/** 592 * capi_cmsg_header() - initialize header part of _cmsg structure 593 * @cmsg: _cmsg structure 594 * @_ApplId: ApplID field value 595 * @_Command: Command field value 596 * @_Subcommand: Subcommand field value 597 * @_Messagenumber: Message Number field value 598 * @_Controller: Controller/PLCI/NCCI field value 599 * 600 * Return value: 0 for success 601 */ 602 603unsigned capi_cmsg_header(_cmsg *cmsg, u16 _ApplId, 604 u8 _Command, u8 _Subcommand, 605 u16 _Messagenumber, u32 _Controller) 606{ 607 memset(cmsg, 0, sizeof(_cmsg)); 608 cmsg->ApplId = _ApplId; 609 cmsg->Command = _Command; 610 cmsg->Subcommand = _Subcommand; 611 cmsg->Messagenumber = _Messagenumber; 612 cmsg->adr.adrController = _Controller; 613 return 0; 614} 615 616/*-------------------------------------------------------*/ 617 618static char *mnames[] = 619{ 620 [0x01] = "ALERT_REQ", 621 [0x02] = "CONNECT_REQ", 622 [0x04] = "DISCONNECT_REQ", 623 [0x05] = "LISTEN_REQ", 624 [0x08] = "INFO_REQ", 625 [0x09] = "FACILITY_REQ", 626 [0x0a] = "SELECT_B_PROTOCOL_REQ", 627 [0x0b] = "CONNECT_B3_REQ", 628 [0x0d] = "DISCONNECT_B3_REQ", 629 [0x0f] = "DATA_B3_REQ", 630 [0x10] = "RESET_B3_REQ", 631 [0x13] = "ALERT_CONF", 632 [0x14] = "CONNECT_CONF", 633 [0x16] = "DISCONNECT_CONF", 634 [0x17] = "LISTEN_CONF", 635 [0x18] = "MANUFACTURER_REQ", 636 [0x1a] = "INFO_CONF", 637 [0x1b] = "FACILITY_CONF", 638 [0x1c] = "SELECT_B_PROTOCOL_CONF", 639 [0x1d] = "CONNECT_B3_CONF", 640 [0x1f] = "DISCONNECT_B3_CONF", 641 [0x21] = "DATA_B3_CONF", 642 [0x22] = "RESET_B3_CONF", 643 [0x26] = "CONNECT_IND", 644 [0x27] = "CONNECT_ACTIVE_IND", 645 [0x28] = "DISCONNECT_IND", 646 [0x2a] = "MANUFACTURER_CONF", 647 [0x2c] = "INFO_IND", 648 [0x2d] = "FACILITY_IND", 649 [0x2f] = "CONNECT_B3_IND", 650 [0x30] = "CONNECT_B3_ACTIVE_IND", 651 [0x31] = "DISCONNECT_B3_IND", 652 [0x33] = "DATA_B3_IND", 653 [0x34] = "RESET_B3_IND", 654 [0x35] = "CONNECT_B3_T90_ACTIVE_IND", 655 [0x38] = "CONNECT_RESP", 656 [0x39] = "CONNECT_ACTIVE_RESP", 657 [0x3a] = "DISCONNECT_RESP", 658 [0x3c] = "MANUFACTURER_IND", 659 [0x3e] = "INFO_RESP", 660 [0x3f] = "FACILITY_RESP", 661 [0x41] = "CONNECT_B3_RESP", 662 [0x42] = "CONNECT_B3_ACTIVE_RESP", 663 [0x43] = "DISCONNECT_B3_RESP", 664 [0x45] = "DATA_B3_RESP", 665 [0x46] = "RESET_B3_RESP", 666 [0x47] = "CONNECT_B3_T90_ACTIVE_RESP", 667 [0x4e] = "MANUFACTURER_RESP" 668}; 669 670/** 671 * capi_cmd2str() - convert CAPI 2.0 command/subcommand number to name 672 * @cmd: command number 673 * @subcmd: subcommand number 674 * 675 * Return value: static string, NULL if command/subcommand unknown 676 */ 677 678char *capi_cmd2str(u8 cmd, u8 subcmd) 679{ 680 return mnames[command_2_index(cmd, subcmd)]; 681} 682 683 684/*-------------------------------------------------------*/ 685 686#ifdef CONFIG_CAPI_TRACE 687 688/*-------------------------------------------------------*/ 689 690static char *pnames[] = 691{ 692 /*00 */ NULL, 693 /*01 */ NULL, 694 /*02 */ NULL, 695 /*03 */ "Controller/PLCI/NCCI", 696 /*04 */ "AdditionalInfo", 697 /*05 */ "B1configuration", 698 /*06 */ "B1protocol", 699 /*07 */ "B2configuration", 700 /*08 */ "B2protocol", 701 /*09 */ "B3configuration", 702 /*0a */ "B3protocol", 703 /*0b */ "BC", 704 /*0c */ "BChannelinformation", 705 /*0d */ "BProtocol", 706 /*0e */ "CalledPartyNumber", 707 /*0f */ "CalledPartySubaddress", 708 /*10 */ "CallingPartyNumber", 709 /*11 */ "CallingPartySubaddress", 710 /*12 */ "CIPmask", 711 /*13 */ "CIPmask2", 712 /*14 */ "CIPValue", 713 /*15 */ "Class", 714 /*16 */ "ConnectedNumber", 715 /*17 */ "ConnectedSubaddress", 716 /*18 */ "Data32", 717 /*19 */ "DataHandle", 718 /*1a */ "DataLength", 719 /*1b */ "FacilityConfirmationParameter", 720 /*1c */ "Facilitydataarray", 721 /*1d */ "FacilityIndicationParameter", 722 /*1e */ "FacilityRequestParameter", 723 /*1f */ "FacilitySelector", 724 /*20 */ "Flags", 725 /*21 */ "Function", 726 /*22 */ "HLC", 727 /*23 */ "Info", 728 /*24 */ "InfoElement", 729 /*25 */ "InfoMask", 730 /*26 */ "InfoNumber", 731 /*27 */ "Keypadfacility", 732 /*28 */ "LLC", 733 /*29 */ "ManuData", 734 /*2a */ "ManuID", 735 /*2b */ "NCPI", 736 /*2c */ "Reason", 737 /*2d */ "Reason_B3", 738 /*2e */ "Reject", 739 /*2f */ "Useruserdata" 740}; 741 742 743 744#include <stdarg.h> 745 746/*-------------------------------------------------------*/ 747static _cdebbuf *bufprint(_cdebbuf *cdb, char *fmt, ...) 748{ 749 va_list f; 750 size_t n, r; 751 752 if (!cdb) 753 return NULL; 754 va_start(f, fmt); 755 r = cdb->size - cdb->pos; 756 n = vsnprintf(cdb->p, r, fmt, f); 757 va_end(f); 758 if (n >= r) { 759 /* truncated, need bigger buffer */ 760 size_t ns = 2 * cdb->size; 761 u_char *nb; 762 763 while ((ns - cdb->pos) <= n) 764 ns *= 2; 765 nb = kmalloc(ns, GFP_ATOMIC); 766 if (!nb) { 767 cdebbuf_free(cdb); 768 return NULL; 769 } 770 memcpy(nb, cdb->buf, cdb->pos); 771 kfree(cdb->buf); 772 nb[cdb->pos] = 0; 773 cdb->buf = nb; 774 cdb->p = cdb->buf + cdb->pos; 775 cdb->size = ns; 776 va_start(f, fmt); 777 r = cdb->size - cdb->pos; 778 n = vsnprintf(cdb->p, r, fmt, f); 779 va_end(f); 780 } 781 cdb->p += n; 782 cdb->pos += n; 783 return cdb; 784} 785 786static _cdebbuf *printstructlen(_cdebbuf *cdb, u8 *m, unsigned len) 787{ 788 unsigned hex = 0; 789 790 if (!cdb) 791 return NULL; 792 for (; len; len--, m++) 793 if (isalnum(*m) || *m == ' ') { 794 if (hex) 795 cdb = bufprint(cdb, ">"); 796 cdb = bufprint(cdb, "%c", *m); 797 hex = 0; 798 } else { 799 if (!hex) 800 cdb = bufprint(cdb, "<%02x", *m); 801 else 802 cdb = bufprint(cdb, " %02x", *m); 803 hex = 1; 804 } 805 if (hex) 806 cdb = bufprint(cdb, ">"); 807 return cdb; 808} 809 810static _cdebbuf *printstruct(_cdebbuf *cdb, u8 *m) 811{ 812 unsigned len; 813 814 if (m[0] != 0xff) { 815 len = m[0]; 816 m += 1; 817 } else { 818 len = ((u16 *) (m + 1))[0]; 819 m += 3; 820 } 821 cdb = printstructlen(cdb, m, len); 822 return cdb; 823} 824 825/*-------------------------------------------------------*/ 826#define NAME (pnames[cmsg->par[cmsg->p]]) 827 828static _cdebbuf *protocol_message_2_pars(_cdebbuf *cdb, _cmsg *cmsg, int level) 829{ 830 for (; TYP != _CEND; cmsg->p++) { 831 int slen = 29 + 3 - level; 832 int i; 833 834 if (!cdb) 835 return NULL; 836 cdb = bufprint(cdb, " "); 837 for (i = 0; i < level - 1; i++) 838 cdb = bufprint(cdb, " "); 839 840 switch (TYP) { 841 case _CBYTE: 842 cdb = bufprint(cdb, "%-*s = 0x%x\n", slen, NAME, *(u8 *) (cmsg->m + cmsg->l)); 843 cmsg->l++; 844 break; 845 case _CWORD: 846 cdb = bufprint(cdb, "%-*s = 0x%x\n", slen, NAME, *(u16 *) (cmsg->m + cmsg->l)); 847 cmsg->l += 2; 848 break; 849 case _CDWORD: 850 cdb = bufprint(cdb, "%-*s = 0x%lx\n", slen, NAME, *(u32 *) (cmsg->m + cmsg->l)); 851 cmsg->l += 4; 852 break; 853 case _CSTRUCT: 854 cdb = bufprint(cdb, "%-*s = ", slen, NAME); 855 if (cmsg->m[cmsg->l] == '\0') 856 cdb = bufprint(cdb, "default"); 857 else 858 cdb = printstruct(cdb, cmsg->m + cmsg->l); 859 cdb = bufprint(cdb, "\n"); 860 if (cmsg->m[cmsg->l] != 0xff) 861 cmsg->l += 1 + cmsg->m[cmsg->l]; 862 else 863 cmsg->l += 3 + *(u16 *) (cmsg->m + cmsg->l + 1); 864 865 break; 866 867 case _CMSTRUCT: 868/*----- Metastruktur 0 -----*/ 869 if (cmsg->m[cmsg->l] == '\0') { 870 cdb = bufprint(cdb, "%-*s = default\n", slen, NAME); 871 cmsg->l++; 872 jumpcstruct(cmsg); 873 } else { 874 char *name = NAME; 875 unsigned _l = cmsg->l; 876 cdb = bufprint(cdb, "%-*s\n", slen, name); 877 cmsg->l = (cmsg->m + _l)[0] == 255 ? cmsg->l + 3 : cmsg->l + 1; 878 cmsg->p++; 879 cdb = protocol_message_2_pars(cdb, cmsg, level + 1); 880 } 881 break; 882 } 883 } 884 return cdb; 885} 886/*-------------------------------------------------------*/ 887 888static _cdebbuf *g_debbuf; 889static u_long g_debbuf_lock; 890static _cmsg *g_cmsg; 891 892static _cdebbuf *cdebbuf_alloc(void) 893{ 894 _cdebbuf *cdb; 895 896 if (likely(!test_and_set_bit(1, &g_debbuf_lock))) { 897 cdb = g_debbuf; 898 goto init; 899 } else 900 cdb = kmalloc(sizeof(_cdebbuf), GFP_ATOMIC); 901 if (!cdb) 902 return NULL; 903 cdb->buf = kmalloc(CDEBUG_SIZE, GFP_ATOMIC); 904 if (!cdb->buf) { 905 kfree(cdb); 906 return NULL; 907 } 908 cdb->size = CDEBUG_SIZE; 909init: 910 cdb->buf[0] = 0; 911 cdb->p = cdb->buf; 912 cdb->pos = 0; 913 return cdb; 914} 915 916/** 917 * cdebbuf_free() - free CAPI debug buffer 918 * @cdb: buffer to free 919 */ 920 921void cdebbuf_free(_cdebbuf *cdb) 922{ 923 if (likely(cdb == g_debbuf)) { 924 test_and_clear_bit(1, &g_debbuf_lock); 925 return; 926 } 927 if (likely(cdb)) 928 kfree(cdb->buf); 929 kfree(cdb); 930} 931 932 933/** 934 * capi_message2str() - format CAPI 2.0 message for printing 935 * @msg: CAPI 2.0 message 936 * 937 * Allocates a CAPI debug buffer and fills it with a printable representation 938 * of the CAPI 2.0 message in @msg. 939 * Return value: allocated debug buffer, NULL on error 940 * The returned buffer should be freed by a call to cdebbuf_free() after use. 941 */ 942 943_cdebbuf *capi_message2str(u8 *msg) 944{ 945 _cdebbuf *cdb; 946 _cmsg *cmsg; 947 948 cdb = cdebbuf_alloc(); 949 if (unlikely(!cdb)) 950 return NULL; 951 if (likely(cdb == g_debbuf)) 952 cmsg = g_cmsg; 953 else 954 cmsg = kmalloc(sizeof(_cmsg), GFP_ATOMIC); 955 if (unlikely(!cmsg)) { 956 cdebbuf_free(cdb); 957 return NULL; 958 } 959 cmsg->m = msg; 960 cmsg->l = 8; 961 cmsg->p = 0; 962 byteTRcpy(cmsg->m + 4, &cmsg->Command); 963 byteTRcpy(cmsg->m + 5, &cmsg->Subcommand); 964 cmsg->par = cpars[command_2_index(cmsg->Command, cmsg->Subcommand)]; 965 966 cdb = bufprint(cdb, "%-26s ID=%03d #0x%04x LEN=%04d\n", 967 mnames[command_2_index(cmsg->Command, cmsg->Subcommand)], 968 ((unsigned short *) msg)[1], 969 ((unsigned short *) msg)[3], 970 ((unsigned short *) msg)[0]); 971 972 cdb = protocol_message_2_pars(cdb, cmsg, 1); 973 if (unlikely(cmsg != g_cmsg)) 974 kfree(cmsg); 975 return cdb; 976} 977 978/** 979 * capi_cmsg2str() - format _cmsg structure for printing 980 * @cmsg: _cmsg structure 981 * 982 * Allocates a CAPI debug buffer and fills it with a printable representation 983 * of the CAPI 2.0 message stored in @cmsg by a previous call to 984 * capi_cmsg2message() or capi_message2cmsg(). 985 * Return value: allocated debug buffer, NULL on error 986 * The returned buffer should be freed by a call to cdebbuf_free() after use. 987 */ 988 989_cdebbuf *capi_cmsg2str(_cmsg *cmsg) 990{ 991 _cdebbuf *cdb; 992 993 if (!cmsg->m) 994 return NULL; /* no message */ 995 cdb = cdebbuf_alloc(); 996 if (!cdb) 997 return NULL; 998 cmsg->l = 8; 999 cmsg->p = 0; 1000 cdb = bufprint(cdb, "%s ID=%03d #0x%04x LEN=%04d\n", 1001 mnames[command_2_index(cmsg->Command, cmsg->Subcommand)], 1002 ((u16 *) cmsg->m)[1], 1003 ((u16 *) cmsg->m)[3], 1004 ((u16 *) cmsg->m)[0]); 1005 cdb = protocol_message_2_pars(cdb, cmsg, 1); 1006 return cdb; 1007} 1008 1009int __init cdebug_init(void) 1010{ 1011 g_cmsg = kmalloc(sizeof(_cmsg), GFP_KERNEL); 1012 if (!g_cmsg) 1013 return -ENOMEM; 1014 g_debbuf = kmalloc(sizeof(_cdebbuf), GFP_KERNEL); 1015 if (!g_debbuf) { 1016 kfree(g_cmsg); 1017 return -ENOMEM; 1018 } 1019 g_debbuf->buf = kmalloc(CDEBUG_GSIZE, GFP_KERNEL); 1020 if (!g_debbuf->buf) { 1021 kfree(g_cmsg); 1022 kfree(g_debbuf); 1023 return -ENOMEM; 1024 } 1025 g_debbuf->size = CDEBUG_GSIZE; 1026 g_debbuf->buf[0] = 0; 1027 g_debbuf->p = g_debbuf->buf; 1028 g_debbuf->pos = 0; 1029 return 0; 1030} 1031 1032void __exit cdebug_exit(void) 1033{ 1034 if (g_debbuf) 1035 kfree(g_debbuf->buf); 1036 kfree(g_debbuf); 1037 kfree(g_cmsg); 1038} 1039 1040#else /* !CONFIG_CAPI_TRACE */ 1041 1042static _cdebbuf g_debbuf = {"CONFIG_CAPI_TRACE not enabled", NULL, 0, 0}; 1043 1044_cdebbuf *capi_message2str(u8 *msg) 1045{ 1046 return &g_debbuf; 1047} 1048 1049_cdebbuf *capi_cmsg2str(_cmsg *cmsg) 1050{ 1051 return &g_debbuf; 1052} 1053 1054void cdebbuf_free(_cdebbuf *cdb) 1055{ 1056} 1057 1058int __init cdebug_init(void) 1059{ 1060 return 0; 1061} 1062 1063void __exit cdebug_exit(void) 1064{ 1065} 1066 1067#endif 1068 1069EXPORT_SYMBOL(cdebbuf_free); 1070EXPORT_SYMBOL(capi_cmsg2message); 1071EXPORT_SYMBOL(capi_message2cmsg); 1072EXPORT_SYMBOL(capi_cmsg_header); 1073EXPORT_SYMBOL(capi_cmd2str); 1074EXPORT_SYMBOL(capi_cmsg2str); 1075EXPORT_SYMBOL(capi_message2str); 1076EXPORT_SYMBOL(capi_info2str); 1077