1 /*
2 KHOMP generic endpoint/channel library.
3 Copyright (C) 2007-2009 Khomp Ind. & Com.
4
5 The contents of this file are subject to the Mozilla Public License Version 1.1
6 (the "License"); you may not use this file except in compliance with the
7 License. You may obtain a copy of the License at http://www.mozilla.org/MPL/
8
9 Software distributed under the License is distributed on an "AS IS" basis,
10 WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License for
11 the specific language governing rights and limitations under the License.
12
13 Alternatively, the contents of this file may be used under the terms of the
14 "GNU Lesser General Public License 2.1" license (the “LGPL" License), in which
15 case the provisions of "LGPL License" are applicable instead of those above.
16
17 If you wish to allow use of your version of this file only under the terms of
18 the LGPL License and not to allow others to use your version of this file under
19 the MPL, indicate your decision by deleting the provisions above and replace them
20 with the notice and other provisions required by the LGPL License. If you do not
21 delete the provisions above, a recipient may use your version of this file under
22 either the MPL or the LGPL License.
23
24 The LGPL header follows below:
25
26 This library is free software; you can redistribute it and/or
27 modify it under the terms of the GNU Lesser General Public
28 License as published by the Free Software Foundation; either
29 version 2.1 of the License, or (at your option) any later version.
30
31 This library is distributed in the hope that it will be useful,
32 but WITHOUT ANY WARRANTY; without even the implied warranty of
33 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
34 Lesser General Public License for more details.
35
36 You should have received a copy of the GNU Lesser General Public License
37 along with this library; if not, write to the Free Software Foundation, Inc.,
38 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
39
40 */
41
42 #include <strings.hpp>
43 #include <verbose.hpp>
44
45 #define PRESENTATION_CHECK_RETURN(fmt, txtexact, txthuman) \
46 { \
47 switch(fmt) \
48 { \
49 case EXACT: return txtexact; \
50 case HUMAN: return txthuman; \
51 } \
52 return txtexact; \
53 }
54
55 /********************************************/
56
channelStatus(const int32 dev,const int32 obj,const int32 cs,const Verbose::Presentation fmt) const57 std::string Verbose::channelStatus(const int32 dev, const int32 obj, const int32 cs, const Verbose::Presentation fmt) const
58 {
59 try
60 {
61 const K3L_CHANNEL_CONFIG & config = _api.channel_config(dev, obj);
62 return Verbose::channelStatus(config.Signaling, cs, fmt);
63 }
64 catch (...)
65 {
66 return presentation(fmt, "<unknown>", "Unknown");
67 }
68 }
69
70 #if K3L_AT_LEAST(2,0,0)
event(const int32 obj,const K3L_EVENT * const ev,const R2CountryType r2_country,const Verbose::Presentation fmt) const71 std::string Verbose::event(const int32 obj, const K3L_EVENT * const ev, const R2CountryType r2_country, const Verbose::Presentation fmt) const
72 #else
73 std::string Verbose::event(const int32 obj, const K3L_EVENT * const ev, const Verbose::Presentation fmt) const
74 #endif
75 {
76 try
77 {
78 const K3L_CHANNEL_CONFIG & config = _api.channel_config(ev->DeviceId, obj);
79 #if K3L_AT_LEAST(2,0,0)
80 return Verbose::event(config.Signaling, obj, ev, r2_country, fmt);
81 #else
82 return Verbose::event(config.Signaling, obj, ev, fmt);
83 #endif
84 }
85 catch (...)
86 {
87 #if K3L_AT_LEAST(2,0,0)
88 return Verbose::event(ksigInactive, obj, ev, r2_country, fmt);
89 #else
90 return Verbose::event(ksigInactive, obj, ev, fmt);
91 #endif
92 }
93 }
94
95 /********************************************/
96
echoLocation(const KEchoLocation ec,const Verbose::Presentation fmt)97 std::string Verbose::echoLocation(const KEchoLocation ec, const Verbose::Presentation fmt)
98 {
99 switch (ec)
100 {
101 #if K3L_AT_LEAST(1,5,4)
102 case kelNetwork: return presentation(fmt, "kelNetwork", "Network");
103 #else
104 case kelE1: return presentation(fmt, "kelE1", "Network");
105 #endif
106 case kelCtBus: return presentation(fmt, "kelCtBus", "CT-Bus");
107 };
108
109 return presentation(fmt, "<unknown>", "Unknown");
110 };
111
echoCancellerConfig(KEchoCancellerConfig ec,const Verbose::Presentation fmt)112 std::string Verbose::echoCancellerConfig(KEchoCancellerConfig ec, const Verbose::Presentation fmt)
113 {
114 switch (ec)
115 {
116 case keccNotPresent: return presentation(fmt, "keccNotPresent", "Not Present");
117 case keccOneSingleBank: return presentation(fmt, "keccOneSingleBank", "One, Single Bank");
118 case keccOneDoubleBank: return presentation(fmt, "keccOneDoubleBank", "One, Double Bank");
119 case keccTwoSingleBank: return presentation(fmt, "keccTwoSingleBank", "Two, Single Bank");
120 case keccTwoDoubleBank: return presentation(fmt, "keccTwoDoubleBank", "Two, Double Bank");
121 case keccFail: return presentation(fmt, "keccFail", "Failure");
122 };
123
124 return presentation(fmt, "<unknown>", "Unknown");
125 };
126
deviceName(const KDeviceType dt,const int32 model,const Verbose::Presentation fmt)127 std::string Verbose::deviceName(const KDeviceType dt, const int32 model, const Verbose::Presentation fmt)
128 {
129 return deviceName(dt, model, 0, fmt);
130 }
131
deviceName(const KDeviceType dt,const int32 model,const int32 count,const Verbose::Presentation fmt)132 std::string Verbose::deviceName(const KDeviceType dt, const int32 model, const int32 count, const Verbose::Presentation fmt)
133 {
134 try
135 {
136 std::string value;
137
138 value += internal_deviceType(dt, count);
139 value += "-";
140 value += internal_deviceModel(dt, model, count);
141
142 return value;
143 }
144 catch (internal_not_found e)
145 {
146 PRESENTATION_CHECK_RETURN(fmt,
147 STG(FMT("[type/model='%d/%d']") % (int)dt % (int)model),
148 STG(FMT("Unknown device type/model (%d/%d)") % (int)dt % (int)model));
149 }
150 }
151
deviceType(const KDeviceType dt,const Verbose::Presentation fmt)152 std::string Verbose::deviceType(const KDeviceType dt, const Verbose::Presentation fmt)
153 {
154 return deviceType(dt, 0, fmt);
155 }
156
deviceType(const KDeviceType dt,const int32 count,const Verbose::Presentation fmt)157 std::string Verbose::deviceType(const KDeviceType dt, const int32 count, const Verbose::Presentation fmt)
158 {
159 try
160 {
161 return internal_deviceType(dt, count);
162 }
163 catch (internal_not_found e)
164 {
165 PRESENTATION_CHECK_RETURN(fmt,
166 STG(FMT("[type='%d']") % (int)dt),
167 STG(FMT("Unknown device type (%d)") % (int)dt));
168 }
169 }
170
internal_deviceType(const KDeviceType dt,const int32 count)171 std::string Verbose::internal_deviceType(const KDeviceType dt, const int32 count)
172 {
173 switch (dt)
174 {
175 case kdtE1: return (count > 34 || count == 0 ? "K2E1" : "K1E1");
176
177 #if K3L_AT_LEAST(1,6,0)
178 case kdtFXO: return "KFXO";
179 #else
180 case kdtFX: return "KFXO";
181 #endif
182
183 case kdtConf: return "KCONF";
184 case kdtPR: return "KPR";
185 case kdtE1GW: return "KE1GW";
186
187 #if K3L_AT_LEAST(1,6,0)
188 case kdtFXOVoIP: return "KFXVoIP";
189 #else
190 case kdtFXVoIP: return "KFXVoIP";
191 #endif
192
193 #if K3L_AT_LEAST(1,5,0)
194 case kdtE1IP: return (count > 90 || count == 0 ? "K2E1" : "K1E1");
195 #endif
196 #if K3L_AT_LEAST(1,5,1)
197 case kdtE1Spx: return (count > 30 || count == 0 ? "K2E1" : "K1E1");
198 case kdtGWIP: return "KGWIP";
199 #endif
200
201 #if K3L_AT_LEAST(1,6,0)
202 case kdtFXS: return "KFXS";
203 case kdtFXSSpx: return "KFXS";
204 case kdtGSM: return "KGSM";
205 case kdtGSMSpx: return "KGSM";
206 #endif
207
208 #if K3L_AT_LEAST(2,1,0)
209 case kdtGSMUSB: return "KGSMUSB";
210 case kdtGSMUSBSpx: return "KGSMUSB";
211
212 case kdtE1FXSSpx: return "KE1FXS";
213 #endif
214
215 #if K3L_EXACT(2,1,0)
216 case kdtReserved1: return "Reserved1";
217 #endif
218
219 #if K3L_AT_LEAST(2,2,0)
220 case kdtE1AdHoc: return "KE1AdHoc";
221 #endif
222 case kdtDevTypeCount: break;
223 }
224
225 throw internal_not_found();
226 }
227
deviceModel(const KDeviceType dt,const int32 model,const Verbose::Presentation fmt)228 std::string Verbose::deviceModel(const KDeviceType dt, const int32 model, const Verbose::Presentation fmt)
229 {
230 return deviceModel(dt, model, 0, fmt);
231 };
232
deviceModel(const KDeviceType dt,const int32 model,const int32 count,const Verbose::Presentation fmt)233 std::string Verbose::deviceModel(const KDeviceType dt, const int32 model, const int32 count, const Verbose::Presentation fmt)
234 {
235 try
236 {
237 return internal_deviceModel(dt, model, count);
238 }
239 catch (internal_not_found e)
240 {
241 PRESENTATION_CHECK_RETURN(fmt,
242 STG(FMT("[model='%d']") % (int)model),
243 STG(FMT("Unknown device model (%d)") % (int)model));
244 }
245 }
246
internal_deviceModel(const KDeviceType dt,const int32 model,const int32 count)247 std::string Verbose::internal_deviceModel(const KDeviceType dt, const int32 model, const int32 count)
248 {
249 switch (dt)
250 {
251 case kdtE1:
252 switch ((KE1DeviceModel)model)
253 {
254 case kdmE1600: return (count > 34 || count == 0 ? "600" : "300");
255 case kdmE1600E: return (count > 34 || count == 0 ? "600" : "300");
256 #if K3L_AT_LEAST(2,0,0)
257 case kdmE1600EX: return (count > 34 || count == 0 ? "600" : "300");
258 #endif
259 }
260 throw internal_not_found();
261
262 #if K3L_AT_LEAST(1,6,0)
263 case kdtFXO:
264 switch ((KFXODeviceModel)model)
265 #else
266 case kdtFX:
267 switch ((KFXDeviceModel)model)
268 #endif
269 {
270 #if K3L_AT_LEAST(1,6,0)
271 case kdmFXO80:
272 switch (count)
273 {
274 case 0: /* default */
275 case 8: return "80";
276 case 4: return "40";
277 }
278 break;
279
280 case kdmFXOHI:
281 switch (count)
282 {
283 case 0: /* default */
284 case 8: return "80-HI";
285 case 4: return "40-HI";
286 }
287 break;
288
289 case kdmFXO160HI: return "160HI";
290 #if K3L_AT_LEAST(2,1,0)
291 case kdmFXO240HI: return "240HI";
292 #endif
293 #else
294 case kdmFXO80:
295 switch (count)
296 {
297 case 0: /* default */
298 case 8: return "80";
299 case 4: return "40";
300 }
301 break;
302
303 #endif
304 }
305
306 throw internal_not_found();
307
308 case kdtConf:
309 switch ((KConfDeviceModel)model)
310 {
311 case kdmConf240: return "240";
312 case kdmConf120: return "120";
313 #if K3L_AT_LEAST(2,0,0)
314 case kdmConf240EX: return "240EX";
315 case kdmConf120EX: return "120EX";
316 #endif
317 }
318
319 throw internal_not_found();
320
321 case kdtPR:
322 switch ((KPRDeviceModel)model)
323 {
324 #if K3L_AT_LEAST(1,6,0)
325 case kdmPR300v1: return "300v1";
326 case kdmPR300SpxBased: return "300S";
327 #if K3L_AT_LEAST(2,0,0)
328 case kdmPR300EX: return "300EX";
329 #endif
330 case kdmPR300: return "300";
331 }
332 #endif
333 throw internal_not_found();
334
335 #if K3L_AT_LEAST(1,4,0)
336 case kdtE1GW:
337 switch ((KE1GWDeviceModel)model)
338 {
339 #if K3L_AT_LEAST(1,6,0)
340 case kdmE1GW640: return "640";
341 #if K3L_AT_LEAST(2,0,0)
342 case kdmE1GW640EX: return "640EX";
343 #endif
344 #else
345 case kdmE1600V: return (count > 34 || count == 0 ? "600V" : "300V" );
346 case kdmE1600EV: return (count > 34 || count == 0 ? "600EV" : "600EV");
347 #endif
348 }
349
350 throw internal_not_found();
351 #endif
352
353 #if K3L_AT_LEAST(1,6,0)
354 case kdtFXOVoIP:
355 switch ((KFXOVoIPDeviceModel)model)
356 {
357 case kdmFXGW180: return "180";
358 }
359
360 throw internal_not_found();
361
362 #elif K3L_AT_LEAST(1,4,0)
363 case kdtFXVoIP:
364 switch ((KFXVoIPDeviceModel)model)
365 {
366 case kdmFXO80V: return "80V";
367 }
368
369 throw internal_not_found();
370 #endif
371
372 #if K3L_AT_LEAST(1,5,0)
373 case kdtE1IP:
374 switch ((KE1IPDeviceModel)model)
375 {
376 #if K3L_AT_LEAST(1,6,0)
377 case kdmE1IP: return "E1IP";
378 #if K3L_AT_LEAST(2,0,0)
379 case kdmE1IPEX: return "E1IPEX";
380 #endif
381 #else
382 case kdmE1600EG: return (count > 90 || count == 0 ? "600EG" : "300EG");
383 #endif
384 }
385
386 throw internal_not_found();
387 #endif
388
389 #if K3L_AT_LEAST(1,5,1)
390 case kdtE1Spx:
391 switch ((KE1SpxDeviceModel)model)
392 {
393 case kdmE1Spx: return "SPX";
394 case kdm2E1Based: return "SPX-2E1";
395 #if K3L_AT_LEAST(2,0,0)
396 case kdmE1SpxEX: return "SPXEX";
397 #endif
398 }
399 throw internal_not_found();
400
401 case kdtGWIP:
402 switch ((KGWIPDeviceModel)model)
403 {
404 #if K3L_AT_LEAST(1,6,0)
405 case kdmGWIP: return "GWIP";
406 #if K3L_AT_LEAST(2,0,0)
407 case kdmGWIPEX: return "GWIPEX";
408 #endif
409 #else
410 case kdmGW600G: return "600G";
411 case kdmGW600EG: return "600EG";
412 #endif
413 }
414
415 throw internal_not_found();
416 #endif
417
418 #if K3L_AT_LEAST(1,6,0)
419 case kdtFXS:
420 switch ((KFXSDeviceModel)model)
421 {
422 case kdmFXS300: return (count > 30 || count == 0 ? "300" : "150");
423 #if K3L_AT_LEAST(2,0,0)
424 case kdmFXS300EX: return (count > 30 || count == 0 ? "300EX" : "150EX");
425 #endif
426 }
427
428 throw internal_not_found();
429
430 case kdtFXSSpx:
431 switch ((KFXSSpxDeviceModel)model)
432 {
433 case kdmFXSSpx300: return (count > 30 || count == 0 ? "300-SPX" : "150-SPX");
434 case kdmFXSSpx2E1Based: return "SPX-2E1";
435 #if K3L_AT_LEAST(2,0,0)
436 case kdmFXSSpx300EX: return (count > 30 || count == 0 ? "300-SPXEX" : "150-SPXEX");
437 #endif
438 }
439
440 throw internal_not_found();
441
442 case kdtGSM:
443 switch ((KGSMDeviceModel)model)
444 {
445 case kdmGSM:
446 switch (count)
447 {
448 case 0: /* default */
449 case 4: return "40";
450 case 3: return "30";
451 case 2: return "20";
452 case 1: return "10";
453 }
454 break;
455 #if K3L_AT_LEAST(2,0,0)
456 case kdmGSMEX:
457 switch (count)
458 {
459 case 0: /* default */
460 case 4: return "40EX";
461 case 3: return "80EX";
462 case 2: return "20EX";
463 case 1: return "10EX";
464 }
465 break;
466 #endif
467 }
468
469 throw internal_not_found();
470
471 case kdtGSMSpx:
472 switch ((KGSMSpxDeviceModel)model)
473 {
474 case kdmGSMSpx:
475 switch (count)
476 {
477 case 0: /* default */
478 case 4: return "40";
479 case 3: return "30";
480 case 2: return "20";
481 case 1: return "10";
482 }
483 break;
484 #if K3L_AT_LEAST(2,0,0)
485 case kdmGSMSpxEX:
486 switch (count)
487 {
488 case 0: /* default */
489 case 4: return "40-SPXEX";
490 case 3: return "80-SPXEX";
491 case 2: return "20-SPXEX";
492 case 1: return "10-SPXEX";
493 }
494 break;
495 #endif
496 }
497
498 throw internal_not_found();
499
500 #if K3L_AT_LEAST(2,1,0)
501 case kdtGSMUSB:
502 switch ((KGSMUSBDeviceModel)model)
503 {
504 case kdmGSMUSB: return "20";
505 }
506
507 throw internal_not_found();
508
509 case kdtGSMUSBSpx:
510 switch ((KGSMUSBSpxDeviceModel)model)
511 {
512 case kdmGSMUSBSpx: return "SPX";
513 }
514
515 throw internal_not_found();
516
517 case kdtE1FXSSpx:
518 switch ((KGSMSpxDeviceModel)model)
519 {
520 case kdmE1FXSSpx: return "450-SPX";
521 case kdmE1FXSSpxEX: return "450-SPXEX";
522 }
523
524 throw internal_not_found();
525 #if K3L_AT_LEAST(2,2,0)
526 case kdtE1AdHoc:
527 switch((KE1AdHocModel)model)
528 {
529 case kdmE1AdHoc100: return "E1AdHoc100";
530 case kdmE1AdHoc100E: return "E1AdHoc100E";
531 case kdmE1AdHoc240: return "E1AdHoc240";
532 case kdmE1AdHoc240E: return "E1AdHoc240E";
533 case kdmE1AdHoc400: return "E1AdHoc240";
534 case kdmE1AdHoc400E: return "E1AdHoc240E";
535 }
536 throw internal_not_found();
537 #endif
538
539 #if K3L_EXACT(2,1,0)
540 case kdtReserved1:
541 #endif
542 case kdtDevTypeCount:
543 throw internal_not_found();
544
545 #endif
546 #endif
547 }
548
549 throw internal_not_found();
550 }
551
signaling(const KSignaling sig,const Verbose::Presentation fmt)552 std::string Verbose::signaling(const KSignaling sig, const Verbose::Presentation fmt)
553 {
554 switch (sig)
555 {
556 case ksigInactive: return presentation(fmt, "ksigInactive", "Inactive");
557 case ksigAnalog: return presentation(fmt, "ksigAnalog", "FXO (analog)");
558 case ksigContinuousEM: return presentation(fmt, "ksigContinuousEM", "E+M Continuous");
559 case ksigPulsedEM: return presentation(fmt, "ksigPulsedEM", "E+M PUlsed");
560 case ksigOpenCAS: return presentation(fmt, "ksigOpenCAS", "Open CAS");
561 case ksigOpenR2: return presentation(fmt, "ksigOpenR2", "Open R2");
562 case ksigR2Digital: return presentation(fmt, "ksigR2Digital", "R2/MFC");
563 case ksigUserR2Digital: return presentation(fmt, "ksigUserR2Digital", "R2/Other");
564 #if K3L_AT_LEAST(1,4,0)
565 case ksigSIP: return presentation(fmt, "ksigSIP", "SIP");
566 #endif
567
568 #if K3L_AT_LEAST(1,5,1)
569 case ksigOpenCCS: return presentation(fmt, "ksigOpenCCS", "Open CCS");
570 case ksigPRI_EndPoint: return presentation(fmt, "ksigPRI_EndPoint", "ISDN Endpoint");
571 case ksigPRI_Network: return presentation(fmt, "ksigPRI_Network", "ISDN Network");
572 case ksigPRI_Passive: return presentation(fmt, "ksigPRI_Passive", "ISDN Passive");
573 #endif
574 #if K3L_AT_LEAST(1,5,3)
575 case ksigLineSide: return presentation(fmt, "ksigLineSide", "Line Side");
576 #endif
577 #if K3L_AT_LEAST(1,6,0)
578 case ksigAnalogTerminal: return presentation(fmt, "ksigAnalogTerminal", "FXS (analog)");
579 case ksigGSM: return presentation(fmt, "ksigGSM", "GSM");
580 case ksigCAS_EL7: return presentation(fmt, "ksigCAS_EL7", "CAS EL7");
581 case ksigE1LC: return presentation(fmt, "ksigE1LC", "E1 LC");
582 #endif
583 #if K3L_AT_LEAST(2,1,0)
584 case ksigISUP: return presentation(fmt, "ksigISUP", "ISUP");
585 #endif
586 #if K3L_EXACT(2,1,0)
587 case ksigFax: return presentation(fmt, "ksigFax", "Fax");
588 #endif
589 #if K3L_AT_LEAST(2,2,0)
590 case ksigISUPPassive: return presentation(fmt, "ksigISUPPassive", "ISUP Passive");
591 #endif
592 }
593
594 PRESENTATION_CHECK_RETURN(fmt,
595 STG(FMT("[KSignaling='%d']") % (int)sig),
596 STG(FMT("Unknown signaling (%d)") % (int)sig));
597 }
598
systemObject(const KSystemObject so,const Verbose::Presentation fmt)599 std::string Verbose::systemObject(const KSystemObject so, const Verbose::Presentation fmt)
600 {
601 switch (so)
602 {
603 case ksoLink: return presentation(fmt, "ksoLink", "Link");
604 case ksoLinkMon: return presentation(fmt, "ksoLinkMon", "Link Monitor");
605 case ksoChannel: return presentation(fmt, "ksoChannel", "Channel");
606 #if K3L_AT_LEAST(2,1,0)
607 case ksoGsmChannel:return presentation(fmt, "ksoGsmChannel","GsmChannel");
608 #endif
609 case ksoH100: return presentation(fmt, "ksoH100", "H.100");
610 case ksoFirmware: return presentation(fmt, "ksoFirmware", "Firmware");
611 case ksoDevice: return presentation(fmt, "ksoDevice", "Device");
612 case ksoAPI: return presentation(fmt, "ksoAPI", "Software Layer");
613 }
614
615 return presentation(fmt,
616 STG(FMT("[KSystemObject='%d']") % (int)so),
617 STG(FMT("Unknown object (%d)") % (int)so));
618 }
619
mixerTone(const KMixerTone mt,const Verbose::Presentation fmt)620 std::string Verbose::mixerTone(const KMixerTone mt, const Verbose::Presentation fmt)
621 {
622 switch (mt)
623 {
624 case kmtSilence: return presentation(fmt, "kmtSilence", "Silence");
625 case kmtDial: return presentation(fmt, "kmtDial", "Dialtone begin");
626 case kmtEndOf425: return presentation(fmt, "kmtEndOf425", "Dialtone end");
627 case kmtBusy: return presentation(fmt, "kmtBusy", "Busy");
628 case kmtFax: return presentation(fmt, "kmtFax", "Fax");
629 case kmtVoice: return presentation(fmt, "kmtVoice", "Voice");
630 #if K3L_AT_LEAST(1,5,0)
631 case kmtCollect: return presentation(fmt, "kmtCollect", "Collect Call");
632 #endif
633 #if K3L_AT_LEAST(1,5,1)
634 case kmtEndOfDtmf: return presentation(fmt, "kmtEndOfDtmf", "DTMF end");
635 #endif
636 }
637
638 PRESENTATION_CHECK_RETURN(fmt,
639 STG(FMT("[KMixerTone='%d']") % (int)mt),
640 STG(FMT("Unknonwn tone (%d)") % (int)mt));
641 }
642
mixerSource(const KMixerSource ms,const Verbose::Presentation fmt)643 std::string Verbose::mixerSource(const KMixerSource ms, const Verbose::Presentation fmt)
644 {
645 switch (ms)
646 {
647 case kmsChannel: return presentation(fmt, "kmsChannel", "Channel");
648 case kmsPlay: return presentation(fmt, "kmsPlay", "Player");
649 case kmsGenerator: return presentation(fmt, "kmsGenerator", "Generator");
650 case kmsCTbus: return presentation(fmt, "kmsCTbus", "CT-bus");
651 #if (K3L_AT_LEAST(1,4,0) && !K3L_AT_LEAST(1,6,0))
652 case kmsVoIP: return presentation(fmt, "kmsVoIP", "VoIP");
653 #endif
654 #if K3L_AT_LEAST(1,6,0)
655 case kmsNoDelayChannel: return presentation(fmt, "kmsNoDelayChannel", "No delay channel");
656 #endif
657 }
658
659 PRESENTATION_CHECK_RETURN(fmt,
660 STG(FMT("[KMixerSource='%d']") % (int)ms),
661 STG(FMT("Unknonwn source (%d)") % (int)ms));
662 }
663
channelFeatures(const int32 flags,const Verbose::Presentation fmt)664 std::string Verbose::channelFeatures(const int32 flags, const Verbose::Presentation fmt)
665 {
666 if (0x00 != flags)
667 {
668 Strings::Merger strs;
669
670 if (kcfDtmfSuppression & flags) strs.add(presentation(fmt, "DtmfSuppression", "DTMF Suppression"));
671 if (kcfCallProgress & flags) strs.add(presentation(fmt, "CallProgress", "Call Progress"));
672 if (kcfPulseDetection & flags) strs.add(presentation(fmt, "PulseDetection", "Pulse Detection"));
673 if (kcfAudioNotification & flags) strs.add(presentation(fmt, "AudioNotification", "Audio Notification"));
674 if (kcfEchoCanceller & flags) strs.add(presentation(fmt, "EchoCanceller", "Echo Canceller"));
675 if (kcfAutoGainControl & flags) strs.add(presentation(fmt, "AutoGainControl", "Input AGC"));
676 if (kcfHighImpEvents & flags) strs.add(presentation(fmt, "HighImpEvents", "High Impedance Events"));
677 #if K3L_AT_LEAST(1,6,0)
678 if (kcfCallAnswerInfo & flags) strs.add(presentation(fmt, "CallAnswerInfo", "Call Answer Info"));
679 if (kcfOutputVolume & flags) strs.add(presentation(fmt, "OutputVolume", "Output Volume"));
680 if (kcfPlayerAGC & flags) strs.add(presentation(fmt, "PlayerAGC", "Player AGC"));
681 #endif
682
683 return presentation(fmt,
684 STG(FMT("kcf{%s}") % strs.merge(",")),
685 STG(FMT("%s") % strs.merge(", ")));
686 };
687
688 PRESENTATION_CHECK_RETURN(fmt, "", "No features");
689 }
690
seizeFail(const KSeizeFail sf,const Verbose::Presentation fmt)691 std::string Verbose::seizeFail(const KSeizeFail sf, const Verbose::Presentation fmt)
692 {
693 switch (sf)
694 {
695 case ksfChannelLocked: return presentation(fmt, "ksfChannelLocked", "Channel Locked");
696 case ksfChannelBusy: return presentation(fmt, "ksfChannelBusy", "Channel Busy");
697 case ksfIncomingChannel: return presentation(fmt, "ksfIncomingChannel", "Incoming Channel");
698 case ksfDoubleSeizure: return presentation(fmt, "ksfDoubleSeizure", "Double Seizure");
699 case ksfCongestion: return presentation(fmt, "ksfCongestion", "Congestion");
700 case ksfNoDialTone: return presentation(fmt, "ksfNoDialTone", "No Dial Tone");
701 }
702
703 PRESENTATION_CHECK_RETURN(fmt,
704 STG(FMT("[KSeizeFail='%d']") % (int)sf),
705 STG(FMT("Unknown seize fail (%d)") % (int)sf));
706 }
707
708 #if K3L_AT_LEAST(1,5,0)
internal_sipFailures(const KSIP_Failures code,const Verbose::Presentation fmt)709 std::string Verbose::internal_sipFailures(const KSIP_Failures code, const Verbose::Presentation fmt)
710 {
711 switch (code)
712 {
713 #if K3L_AT_LEAST(1,6,0)
714 case kveResponse_200_OK_Success: return presentation(fmt, "kveResponse_200_OK_Success", "200 OK");
715 #endif
716 case kveRedirection_300_MultipleChoices: return presentation(fmt, "kveRedirection_300_MultipleChoices", "300 Multiple Choices");
717 case kveRedirection_301_MovedPermanently: return presentation(fmt, "kveRedirection_301_MovedPermanently", "301 Moved Permanently");
718 case kveRedirection_302_MovedTemporarily: return presentation(fmt, "kveRedirection_302_MovedTemporarily", "302 Moved Temporarily");
719 case kveRedirection_305_UseProxy: return presentation(fmt, "kveRedirection_305_UseProxy", "305 Use Proxy");
720 case kveRedirection_380_AlternativeService: return presentation(fmt, "kveRedirection_380_AlternativeService", "380 Alternate Service");
721 case kveFailure_400_BadRequest: return presentation(fmt, "kveFailure_400_BadRequest", "400 Bad Request");
722 case kveFailure_401_Unauthorized: return presentation(fmt, "kveFailure_401_Unauthorized", "401 Unauthorized");
723 case kveFailure_402_PaymentRequired: return presentation(fmt, "kveFailure_402_PaymentRequired", "402 Payment Required");
724 case kveFailure_403_Forbidden: return presentation(fmt, "kveFailure_403_Forbidden", "403 Forbidden");
725 case kveFailure_404_NotFound: return presentation(fmt, "kveFailure_404_NotFound", "404 Not Found");
726 case kveFailure_405_MethodNotAllowed: return presentation(fmt, "kveFailure_405_MethodNotAllowed", "405 Method Not Allowed");
727 case kveFailure_406_NotAcceptable: return presentation(fmt, "kveFailure_406_NotAcceptable", "406 Not Acceptable");
728 case kveFailure_407_ProxyAuthenticationRequired: return presentation(fmt, "kveFailure_407_ProxyAuthenticationRequired", "407 Proxy Authentication Required");
729 case kveFailure_408_RequestTimeout: return presentation(fmt, "kveFailure_408_RequestTimeout", "408 Request Timeout");
730 case kveFailure_410_Gone: return presentation(fmt, "kveFailure_410_Gone", "410 Gone");
731 case kveFailure_413_RequestEntityTooLarge: return presentation(fmt, "kveFailure_413_RequestEntityTooLarge", "413 Request Entity Too Large");
732 case kveFailure_414_RequestURI_TooLong: return presentation(fmt, "kveFailure_414_RequestURI_TooLong", "414 Request URI Too Long");
733 case kveFailure_415_UnsupportedMediaType: return presentation(fmt, "kveFailure_415_UnsupportedMediaType", "415 Unsupported Media Type");
734 case kveFailure_416_UnsupportedURI_Scheme: return presentation(fmt, "kveFailure_416_UnsupportedURI_Scheme", "416 Unsupported URI Scheme");
735 case kveFailure_420_BadExtension: return presentation(fmt, "kveFailure_420_BadExtension", "420 Bad Extension");
736 case kveFailure_421_ExtensionRequired: return presentation(fmt, "kveFailure_421_ExtensionRequired", "421 Extension Required");
737 case kveFailure_423_IntervalTooBrief: return presentation(fmt, "kveFailure_423_IntervalTooBrief", "423 Internal Too Brief");
738 case kveFailure_480_TemporarilyUnavailable: return presentation(fmt, "kveFailure_480_TemporarilyUnavailable", "480 Temporarily Unavailable");
739 case kveFailure_481_CallDoesNotExist: return presentation(fmt, "kveFailure_481_CallDoesNotExist", "481 Call Does Not Exist");
740 case kveFailure_482_LoopDetected: return presentation(fmt, "kveFailure_482_LoopDetected", "482 Loop Detected");
741 case kveFailure_483_TooManyHops: return presentation(fmt, "kveFailure_483_TooManyHops", "483 Too Many Hops");
742 case kveFailure_484_AddressIncomplete: return presentation(fmt, "kveFailure_484_AddressIncomplete", "484 Address Incomplete");
743 case kveFailure_485_Ambiguous: return presentation(fmt, "kveFailure_485_Ambiguous", "485 Ambiguous");
744 case kveFailure_486_BusyHere: return presentation(fmt, "kveFailure_486_BusyHere", "486 Busy Here");
745 case kveFailure_487_RequestTerminated: return presentation(fmt, "kveFailure_487_RequestTerminated", "487 Request Terminated");
746 case kveFailure_488_NotAcceptableHere: return presentation(fmt, "kveFailure_488_NotAcceptableHere", "488 Not Acceptable Here");
747 case kveFailure_491_RequestPending: return presentation(fmt, "kveFailure_491_RequestPending", "491 Request Pending");
748 case kveFailure_493_Undecipherable: return presentation(fmt, "kveFailure_493_Undecipherable", "493 Undecipherable");
749 case kveServer_500_InternalError: return presentation(fmt, "kveServer_500_InternalError", "500 Internal Error");
750 case kveServer_501_NotImplemented: return presentation(fmt, "kveServer_501_NotImplemented", "501 Not Implemented");
751 case kveServer_502_BadGateway: return presentation(fmt, "kveServer_502_BadGateway", "502 Bad Gateway");
752 case kveServer_503_ServiceUnavailable: return presentation(fmt, "kveServer_503_ServiceUnavailable", "503 Service Unavailable");
753 case kveServer_504_TimeOut: return presentation(fmt, "kveServer_504_TimeOut", "504 Timed Out");
754 case kveServer_505_VersionNotSupported: return presentation(fmt, "kveServer_505_VersionNotSupported", "505 Version Not Supported");
755 case kveServer_513_MessageTooLarge: return presentation(fmt, "kveServer_513_MessageTooLarge", "513 Message Too Large");
756 case kveGlobalFailure_600_BusyEverywhere: return presentation(fmt, "kveGlobalFailure_600_BusyEverywhere", "600 Busy Everywhere");
757 case kveGlobalFailure_603_Decline: return presentation(fmt, "kveGlobalFailure_603_Decline", "603 Decline");
758 case kveGlobalFailure_604_DoesNotExistAnywhere: return presentation(fmt, "kveGlobalFailure_604_DoesNotExistAnywhere", "604 Does Not Exist Anywhere");
759 case kveGlobalFailure_606_NotAcceptable: return presentation(fmt, "kveGlobalFailure_606_NotAcceptable", "606 Not Acceptable");
760 }
761
762 throw internal_not_found();
763 }
764
sipFailures(const KSIP_Failures code,const Verbose::Presentation fmt)765 std::string Verbose::sipFailures(const KSIP_Failures code, const Verbose::Presentation fmt)
766 {
767 try
768 {
769 return internal_sipFailures(code, fmt);
770 }
771 catch (internal_not_found e)
772 {
773 PRESENTATION_CHECK_RETURN(fmt,
774 STG(FMT("[KSIP_Failures='%d']") % (int)code),
775 STG(FMT("Unknown SIP failure (%d)") % (int)code));
776 }
777 }
778
779 #endif
780
781 #if K3L_AT_LEAST(1,5,1)
internal_isdnCause(const KQ931Cause code,const Verbose::Presentation fmt)782 std::string Verbose::internal_isdnCause(const KQ931Cause code, const Verbose::Presentation fmt)
783 {
784 switch (code)
785 {
786 case kq931cNone: return presentation(fmt, "kq931cNone", "None");
787 case kq931cUnallocatedNumber: return presentation(fmt, "kq931cUnallocatedNumber", "Unallocated number");
788 case kq931cNoRouteToTransitNet: return presentation(fmt, "kq931cNoRouteToTransitNet", "No route to transmit to network");
789 case kq931cNoRouteToDest: return presentation(fmt, "kq931cNoRouteToDest", "No route to destination");
790 #if 1 /* this changed during K3L 1.6.0 development cycle... */
791 case kq931cSendSpecialInfoTone: return presentation(fmt, "kq931cSendSpecialInfoTone", "Send special information tone");
792 case kq931cMisdialedTrunkPrefix: return presentation(fmt, "kq931cMisdialedTrunkPrefix", "Misdialed trunk prefix");
793 #endif
794 case kq931cChannelUnacceptable: return presentation(fmt, "kq931cChannelUnacceptable", "Channel unacceptable");
795 case kq931cCallAwarded: return presentation(fmt, "kq931cCallAwarded", "Call awarded");
796 #if 1 /* this changed during K3L 1.6.0 development cycle... */
797 case kq931cPreemption: return presentation(fmt, "kq931cPreemption", "Preemption");
798 case kq931cPreemptionCircuitReuse: return presentation(fmt, "kq931cPreemptionCircuitReuse", "Preemption circuit reuse");
799 case kq931cQoR_PortedNumber: return presentation(fmt, "kq931cQoR_PortedNumber", "QoR ported number");
800 #endif
801 case kq931cNormalCallClear: return presentation(fmt, "kq931cNormalCallClear", "Normal call clear");
802 case kq931cUserBusy: return presentation(fmt, "kq931cUserBusy", "User busy");
803 case kq931cNoUserResponding: return presentation(fmt, "kq931cNoUserResponding", "No user responding");
804 case kq931cNoAnswerFromUser: return presentation(fmt, "kq931cNoAnswerFromUser", "No answer from user");
805 #if 1 /* this changed during K3L 1.6.0 development cycle... */
806 case kq931cSubscriberAbsent: return presentation(fmt, "kq931cSubscriberAbsent", "Subscriber absent");
807 #endif
808 case kq931cCallRejected: return presentation(fmt, "kq931cCallRejected", "Call rejected");
809 case kq931cNumberChanged: return presentation(fmt, "kq931cNumberChanged", "Number changed");
810 #if 1 /* this changed during K3L 1.6.0 development cycle... */
811 case kq931cRedirectionToNewDest: return presentation(fmt, "kq931cRedirectionToNewDest", "Redirection to new destination");
812 case kq931cCallRejectedFeatureDest: return presentation(fmt, "kq931cCallRejectedFeatureDest", "Call rejected feature destination");
813 case kq931cExchangeRoutingError: return presentation(fmt, "kq931cExchangeRoutingError", "Exchange routing error");
814 #endif
815 case kq931cNonSelectedUserClear: return presentation(fmt, "kq931cNonSelectedUserClear", "Non selected user clear");
816 case kq931cDestinationOutOfOrder: return presentation(fmt, "kq931cDestinationOutOfOrder", "Destination out of order");
817 case kq931cInvalidNumberFormat: return presentation(fmt, "kq931cInvalidNumberFormat", "Invalid number format");
818 case kq931cFacilityRejected: return presentation(fmt, "kq931cFacilityRejected", "Facility rejected");
819 case kq931cRespStatusEnquiry: return presentation(fmt, "kq931cRespStatusEnquiry", "Response status enquiry");
820 case kq931cNormalUnspecified: return presentation(fmt, "kq931cNormalUnspecified", "Normal unespecified");
821 case kq931cNoCircuitChannelAvail: return presentation(fmt, "kq931cNoCircuitChannelAvail", "No circuit channel available");
822 case kq931cNetworkOutOfOrder: return presentation(fmt, "kq931cNetworkOutOfOrder", "Network out of order");
823 #if 1 /* this changed during K3L 1.6.0 development cycle... */
824 case kq931cPermanentFrameConnOutOfService: return presentation(fmt, "kq931cPermanentFrameConnOutOfService", "Permanent frame connection out of service");
825 case kq931cPermanentFrameConnOperational: return presentation(fmt, "kq931cPermanentFrameConnOperational", "Permanent frame connection operational");
826 #endif
827 case kq931cTemporaryFailure: return presentation(fmt, "kq931cTemporaryFailure", "Temporary failure");
828 case kq931cSwitchCongestion: return presentation(fmt, "kq931cSwitchCongestion", "Switch congestion");
829 case kq931cAccessInfoDiscarded: return presentation(fmt, "kq931cAccessInfoDiscarded", "Access information discarded");
830 case kq931cRequestedChannelUnav: return presentation(fmt, "kq931cRequestedChannelUnav", "Requested channel unavailable");
831 case kq931cPrecedenceCallBlocked: return presentation(fmt, "kq931cPrecedenceCallBlocked", "Precedence call blocked");
832 case kq931cResourceUnavailable: return presentation(fmt, "kq931cResourceUnavailable", "Request resource unavailable");
833 case kq931cQosUnavailable: return presentation(fmt, "kq931cQosUnavailable", "QoS unavailable");
834 case kq931cReqFacilityNotSubsc: return presentation(fmt, "kq931cReqFacilityNotSubsc", "Request facility not subscribed");
835 case kq931cOutCallsBarredWithinCUG: return presentation(fmt, "kq931cOutCallsBarredWithinCUG", "Out calls barred within UG");
836 case kq931cInCallsBarredWithinCUG: return presentation(fmt, "kq931cInCallsBarredWithinCUG", "In calls barred within UG");
837 case kq931cBearerCapabNotAuthor: return presentation(fmt, "kq931cBearerCapabNotAuthor", "Bearer capability not authorized");
838 case kq931cBearerCapabNotAvail: return presentation(fmt, "kq931cBearerCapabNotAvail", "Bearer capability not available");
839 #if 1 /* this changed during K3L 1.6.0 development cycle... */
840 case kq931cInconsistency: return presentation(fmt, "kq931cInconsistency", "Inconsistency");
841 #endif
842 case kq931cServiceNotAvailable: return presentation(fmt, "kq931cServiceNotAvailable", "Service not available");
843 case kq931cBcNotImplemented: return presentation(fmt, "kq931cBcNotImplemented", "Bearer capability not implemented");
844 case kq931cChannelTypeNotImplem: return presentation(fmt, "kq931cChannelTypeNotImplem", "Channel type not implemented");
845 case kq931cReqFacilityNotImplem: return presentation(fmt, "kq931cReqFacilityNotImplem", "Request facility not implemented");
846 case kq931cOnlyRestrictedBcAvail: return presentation(fmt, "kq931cOnlyRestrictedBcAvail", "Only restricted bearer capability available");
847 case kq931cServiceNotImplemented: return presentation(fmt, "kq931cServiceNotImplemented", "Service not implemented");
848 case kq931cInvalidCrv: return presentation(fmt, "kq931cInvalidCrv", "Invalid call reference value");
849 case kq931cChannelDoesNotExist: return presentation(fmt, "kq931cChannelDoesNotExist", "Channel does not exist");
850 case kq931cCallIdDoesNotExist: return presentation(fmt, "kq931cCallIdDoesNotExist", "Call identification does not exist");
851 case kq931cCallIdInUse: return presentation(fmt, "kq931cCallIdInUse", "Call identification in use");
852 case kq931cNoCallSuspended: return presentation(fmt, "kq931cNoCallSuspended", "No call suspended");
853 case kq931cCallIdCleared: return presentation(fmt, "kq931cCallIdCleared", "Call identification cleared");
854 #if 1 /* this changed during K3L 1.6.0 development cycle... */
855 case kq931cUserNotMemberofCUG: return presentation(fmt, "kq931cUserNotMemberofCUG", "User not member of UG");
856 #endif
857 case kq931cIncompatibleDestination: return presentation(fmt, "kq931cIncompatibleDestination", "Incompatible destination");
858 case kq931cInvalidTransitNetSel: return presentation(fmt, "kq931cInvalidTransitNetSel", "Invalid transit network selected");
859 case kq931cInvalidMessage: return presentation(fmt, "kq931cInvalidMessage", "Invalid message");
860 case kq931cMissingMandatoryIe: return presentation(fmt, "kq931cMissingMandatoryIe", "Missing mandatory information element");
861 case kq931cMsgTypeNotImplemented: return presentation(fmt, "kq931cMsgTypeNotImplemented", "Message type not implemented");
862 case kq931cMsgIncompatWithState: return presentation(fmt, "kq931cMsgIncompatWithState", "Message incompatible with state");
863 case kq931cIeNotImplemented: return presentation(fmt, "kq931cIeNotImplemented", "Information element not implemented");
864 case kq931cInvalidIe: return presentation(fmt, "kq931cInvalidIe", "Invalid information element");
865 case kq931cMsgIncompatWithState2: return presentation(fmt, "kq931cMsgIncompatWithState2", "Message incompatible with state (2)");
866 case kq931cRecoveryOnTimerExpiry: return presentation(fmt, "kq931cRecoveryOnTimerExpiry", "Recovery on timer expiry");
867 case kq931cProtocolError: return presentation(fmt, "kq931cProtocolError", "Protocol error");
868 #if 1 /* this changed during K3L 1.6.0 development cycle... */
869 case kq931cMessageWithUnrecognizedParam: return presentation(fmt, "kq931cMessageWithUnrecognizedParam", "Message with unrecognized parameters");
870 case kq931cProtocolErrorUnspecified: return presentation(fmt, "kq931cProtocolErrorUnspecified", "Protocol error unspecified");
871 #endif
872 case kq931cInterworking: return presentation(fmt, "kq931cInterworking", "Interworking");
873 case kq931cCallConnected: return presentation(fmt, "kq931cCallConnected", "Call connected");
874 case kq931cCallTimedOut: return presentation(fmt, "kq931cCallTimedOut", "Call timeout");
875 case kq931cCallNotFound: return presentation(fmt, "kq931cCallNotFound", "Call not found");
876 case kq931cCantReleaseCall: return presentation(fmt, "kq931cCantReleaseCall", "Cannot realese call");
877 case kq931cNetworkFailure: return presentation(fmt, "kq931cNetworkFailure", "Network failure");
878 case kq931cNetworkRestart: return presentation(fmt, "kq931cNetworkRestart", "Network restart");
879 }
880
881 throw internal_not_found();
882 }
883
isdnCause(const KQ931Cause code,const Verbose::Presentation fmt)884 std::string Verbose::isdnCause(const KQ931Cause code, const Verbose::Presentation fmt)
885 {
886 try
887 {
888 return internal_isdnCause(code);
889 }
890 catch (internal_not_found e)
891 {
892 return STG(FMT("[KQ931Cause='%d']") % (int)code);
893 }
894 }
895 #endif
896
897 #if K3L_AT_LEAST(1,5,2)
isdnDebug(const int32 flags,const Verbose::Presentation fmt)898 std::string Verbose::isdnDebug(const int32 flags, const Verbose::Presentation fmt)
899 {
900 if (0x00 != flags)
901 {
902 Strings::Merger strs;
903
904 if (flags & kidfQ931) strs.add("Q931");
905 if (flags & kidfLAPD) strs.add("LAPD");
906 if (flags & kidfSystem) strs.add("System");
907
908 PRESENTATION_CHECK_RETURN(fmt,
909 STG(FMT("kidf{%s}") % strs.merge(",")),
910 strs.merge(", "));
911 }
912
913 return presentation(fmt, "", "No debug active");
914 }
915 #endif
916
917 #if K3L_AT_LEAST(2,0,0)
internal_signGroupB(const KSignGroupB group,const R2CountryType country,const Verbose::Presentation fmt)918 std::string Verbose::internal_signGroupB(const KSignGroupB group, const R2CountryType country, const Verbose::Presentation fmt)
919 #else
920 std::string Verbose::internal_signGroupB(const KSignGroupB group, const Verbose::Presentation fmt)
921 #endif
922 {
923 #if K3L_AT_LEAST(2,0,0)
924 switch (country)
925 {
926 case R2_COUNTRY_ARG:
927 switch ((KSignGroupB_Argentina)group)
928 {
929 case kgbArNumberChanged: return presentation(fmt, "kgbArNumberChanged", "Number Changed");
930 case kgbArBusy: return presentation(fmt, "kgbArBusy", "Busy");
931 case kgbArCongestion: return presentation(fmt, "kgbArCongestion", "Congestion");
932 case kgbArInvalidNumber: return presentation(fmt, "kgbArInvalidNumber", "Invalid Number");
933 case kgbArLineFreeCharged: return presentation(fmt, "kgbArLineFreeCharged", "Line Free Charged");
934 case kgbArLineFreeNotCharged: return presentation(fmt, "kgbArLineFreeNotCharged", "Line Free Not Charged");
935 case kgbArLineOutOfOrder: return presentation(fmt, "kgbArLineOutOfOrder", "Line Out Of Order");
936 case kgbArNone: return presentation(fmt, "kgbArNone", "None");
937 }
938 break;
939
940 case R2_COUNTRY_BRA:
941 switch ((KSignGroupB_Brazil)group)
942 {
943 case kgbBrLineFreeCharged: return presentation(fmt, "kgbBrLineFreeCharged", "Line Free Charged");
944 case kgbBrLineFreeNotCharged: return presentation(fmt, "kgbBrLineFreeNotCharged", "Line Free Not Charged");
945 case kgbBrLineFreeChargedLPR: return presentation(fmt, "kgbBrLineFreeChargedLPR", "Line Free Charged PLR");
946 case kgbBrBusy: return presentation(fmt, "kgbBrBusy", "Busy");
947 case kgbBrNumberChanged: return presentation(fmt, "kgbBrNumberChanged", "Number Changed");
948 case kgbBrCongestion: return presentation(fmt, "kgbBrCongestion", "Congestion");
949 case kgbBrInvalidNumber: return presentation(fmt, "kgbBrInvalidNumber", "Invalid Number");
950 case kgbBrLineOutOfOrder: return presentation(fmt, "kgbBrLineOutOfOrder", "Line Out Of Order");
951 case kgbBrNone: return presentation(fmt, "kgbBrNone", "None");
952 }
953 break;
954
955 case R2_COUNTRY_CHI:
956 switch ((KSignGroupB_Chile)group)
957 {
958 case kgbClNumberChanged: return presentation(fmt, "kgbClNumberChanged", "Number Changed");
959 case kgbClBusy: return presentation(fmt, "kgbClBusy", "Busy");
960 case kgbClCongestion: return presentation(fmt, "kgbClCongestion", "Congestion");
961 case kgbClInvalidNumber: return presentation(fmt, "kgbClInvalidNumber", "Invalid Number");
962 case kgbClLineFreeCharged: return presentation(fmt, "kgbClLineFreeCharged", "Line Free Charged");
963 case kgbClLineFreeNotCharged: return presentation(fmt, "kgbClLineFreeNotCharged", "Line Free Not Charged");
964 case kgbClLineOutOfOrder: return presentation(fmt, "kgbClLineOutOfOrder", "Line Out Of Order");
965 case kgbClNone: return presentation(fmt, "kgbClNone", "None");
966 }
967 break;
968
969 case R2_COUNTRY_MEX:
970 switch ((KSignGroupB_Mexico)group)
971 {
972 case kgbMxLineFreeCharged: return presentation(fmt, "kgbMxLineFreeCharged", "Line Free Charged");
973 case kgbMxBusy: return presentation(fmt, "kgbMxBusy", "Busy");
974 case kgbMxLineFreeNotCharged: return presentation(fmt, "kgbMxLineFreeNotCharged", "Line Free Not Charged");
975 case kgbMxNone: return presentation(fmt, "kgbMxNone", "None");
976 }
977 break;
978
979 case R2_COUNTRY_URY:
980 switch ((KSignGroupB_Uruguay)group)
981 {
982 case kgbUyNumberChanged: return presentation(fmt, "kgbUyNumberChanged", "Number Changed");
983 case kgbUyBusy: return presentation(fmt, "kgbUyBusy", "Busy");
984 case kgbUyCongestion: return presentation(fmt, "kgbUyCongestion", "Congestion");
985 case kgbUyInvalidNumber: return presentation(fmt, "kgbUyInvalidNumber", "Invalid Number");
986 case kgbUyLineFreeCharged: return presentation(fmt, "kgbUyLineFreeCharged", "Line Free Charged");
987 case kgbUyLineFreeNotCharged: return presentation(fmt, "kgbUyLineFreeNotCharged", "Line Free Not Charged");
988 case kgbUyLineOutOfOrder: return presentation(fmt, "kgbUyLineOutOfOrder", "Line Out Of Order");
989 case kgbUyNone: return presentation(fmt, "kgbUyNone", "None");
990 }
991 break;
992
993 case R2_COUNTRY_VEN:
994 switch ((KSignGroupB_Venezuela)group)
995 {
996 case kgbVeLineFreeChargedLPR: return presentation(fmt, "kgbVeLineFreeChargedLPR", "Line Free Charged PLR");
997 case kgbVeNumberChanged: return presentation(fmt, "kgbVeNumberChanged", "Number Changed");
998 case kgbVeBusy: return presentation(fmt, "kgbVeBusy", "Busy");
999 case kgbVeCongestion: return presentation(fmt, "kgbVeCongestion", "Congestion");
1000 case kgbVeInformationTone: return presentation(fmt, "kgbVeInformationTone", "Information Tone");
1001 case kgbVeLineFreeCharged: return presentation(fmt, "kgbVeLineFreeCharged", "Line Free Charged");
1002 case kgbVeLineFreeNotCharged: return presentation(fmt, "kgbVeLineFreeNotCharged", "Line Free Not Charged");
1003 case kgbVeLineBlocked: return presentation(fmt, "kgbVeLineBlocked", "Line Blocked");
1004 case kgbVeIntercepted: return presentation(fmt, "kgbVeIntercepted", "Intercepted");
1005 case kgbVeDataTrans: return presentation(fmt, "kgbVeDataTrans", "Data Transfer");
1006 case kgbVeNone: return presentation(fmt, "kgbVeNone", "None");
1007 }
1008 break;
1009 }
1010 #else
1011 switch ((KSignGroupB)group)
1012 {
1013 case kgbLineFreeCharged: return presentation(fmt, "kgbLineFreeCharged", "Line Free Charged");
1014 case kgbLineFreeNotCharged: return presentation(fmt, "kgbLineFreeNotCharged", "Line Free Not Charged");
1015 case kgbLineFreeChargedLPR: return presentation(fmt, "kgbLineFreeChargedLPR", "Line Free Charged PLR");
1016 case kgbBusy: return presentation(fmt, "kgbBusy", "Busy");
1017 case kgbNumberChanged: return presentation(fmt, "kgbNumberChanged", "Number Changed");
1018 case kgbCongestion: return presentation(fmt, "kgbCongestion", "Congestion");
1019 case kgbInvalidNumber: return presentation(fmt, "kgbInvalidNumber", "Invalid Number");
1020 case kgbLineOutOfOrder: return presentation(fmt, "kgbLineOutOfOrder", "Line Out Of Order");
1021 case kgbNone: return presentation(fmt, "kgbNone", "None");
1022 }
1023 #endif
1024
1025 throw internal_not_found();
1026 }
1027
1028 #if K3L_AT_LEAST(2,0,0)
signGroupB(const KSignGroupB group,const R2CountryType r2_country,const Verbose::Presentation fmt)1029 std::string Verbose::signGroupB(const KSignGroupB group, const R2CountryType r2_country, const Verbose::Presentation fmt)
1030 #else
1031 std::string Verbose::signGroupB(const KSignGroupB group, const Verbose::Presentation fmt)
1032 #endif
1033 {
1034 try
1035 {
1036 #if K3L_AT_LEAST(2,0,0)
1037 return internal_signGroupB(group, r2_country, fmt);
1038 #else
1039 return internal_signGroupB(group, fmt);
1040 #endif
1041 }
1042 catch (internal_not_found e)
1043 {
1044 PRESENTATION_CHECK_RETURN(fmt,
1045 STG(FMT("[KSignGroupB='%d']") % (int)group),
1046 STG(FMT("Unknown group B (%d)") % (int)group));
1047 }
1048 }
1049
1050 #if K3L_AT_LEAST(2,0,0)
internal_signGroupII(const KSignGroupII group,const R2CountryType country,const Verbose::Presentation fmt)1051 std::string Verbose::internal_signGroupII(const KSignGroupII group, const R2CountryType country, const Verbose::Presentation fmt)
1052 #else
1053 std::string Verbose::internal_signGroupII(const KSignGroupII group, const Verbose::Presentation fmt)
1054 #endif
1055 {
1056 #if K3L_AT_LEAST(2,0,0)
1057 switch (country)
1058 {
1059 case R2_COUNTRY_ARG:
1060 switch ((KSignGroupII_Argentina)group)
1061 {
1062 case kg2ArOrdinary: return presentation(fmt, "kg2ArOrdinary", "Ordinary");
1063 case kg2ArPriority: return presentation(fmt, "kg2ArPriority", "Priority");
1064 case kg2ArMaintenance: return presentation(fmt, "kg2ArMaintenance", "Maintenance");
1065 case kg2ArLocalPayPhone: return presentation(fmt, "kg2ArLocalPayPhone", "Local pay phone");
1066 case kg2ArTrunkOperator: return presentation(fmt, "kg2ArTrunkOperator", "Trunk operator");
1067 case kg2ArDataTrans: return presentation(fmt, "kg2ArDataTrans", "Data transfer");
1068 case kg2ArCPTP: return presentation(fmt, "kg2ArCPTP", "CPTP");
1069 case kg2ArSpecialLine: return presentation(fmt, "kg2ArSpecialLine", "Special line");
1070 case kg2ArMobileUser: return presentation(fmt, "kg2ArMobileUser", "Mobile user");
1071 case kg2ArPrivateRedLine: return presentation(fmt, "kg2ArPrivateRedLine", "Private red line");
1072 case kg2ArSpecialPayPhoneLine: return presentation(fmt, "kg2ArSpecialPayPhoneLine", "Special pay phone line");
1073 }
1074 break;
1075
1076 case R2_COUNTRY_BRA:
1077 switch ((KSignGroupII_Brazil)group)
1078 {
1079 case kg2BrOrdinary: return presentation(fmt, "kg2BrOrdinary", "Ordinary");
1080 case kg2BrPriority: return presentation(fmt, "kg2BrPriority", "Priority");
1081 case kg2BrMaintenance: return presentation(fmt, "kg2BrMaintenance", "Maintenance");
1082 case kg2BrLocalPayPhone: return presentation(fmt, "kg2BrLocalPayPhone", "Local pay phone");
1083 case kg2BrTrunkOperator: return presentation(fmt, "kg2BrTrunkOperator", "Trunk operator");
1084 case kg2BrDataTrans: return presentation(fmt, "kg2BrDataTrans", "Data transfer");
1085 case kg2BrNonLocalPayPhone: return presentation(fmt, "kg2BrNonLocalPayPhone", "Non local pay phone");
1086 case kg2BrCollectCall: return presentation(fmt, "kg2BrCollectCall", "Collect call");
1087 case kg2BrOrdinaryInter: return presentation(fmt, "kg2BrOrdinaryInter", "Ordinary international");
1088 case kg2BrTransfered: return presentation(fmt, "kg2BrTransfered", "Transfered");
1089 }
1090 break;
1091
1092 case R2_COUNTRY_CHI:
1093 switch ((KSignGroupII_Chile)group)
1094 {
1095 case kg2ClOrdinary: return presentation(fmt, "kg2ClOrdinary", "Ordinary");
1096 case kg2ClPriority: return presentation(fmt, "kg2ClPriority", "Priority");
1097 case kg2ClMaintenance: return presentation(fmt, "kg2ClMaintenance", "Maintenance");
1098 case kg2ClTrunkOperator: return presentation(fmt, "kg2ClTrunkOperator", "Trunk operator");
1099 case kg2ClDataTrans: return presentation(fmt, "kg2ClDataTrans", "Data transfer");
1100 case kg2ClUnidentifiedSubscriber: return presentation(fmt, "kg2ClUnidentifiedSubscriber", "Unidentified subscriber");
1101 }
1102 break;
1103
1104 case R2_COUNTRY_MEX:
1105 switch ((KSignGroupII_Mexico)group)
1106 {
1107 case kg2MxTrunkOperator: return presentation(fmt, "kg2MxTrunkOperator", "Trunk operator");
1108 case kg2MxOrdinary: return presentation(fmt, "kg2MxOrdinary", "Ordinary");
1109 case kg2MxMaintenance: return presentation(fmt, "kg2MxMaintenance", "Maintenance");
1110 }
1111 break;
1112
1113 case R2_COUNTRY_URY:
1114 switch ((KSignGroupII_Uruguay)group)
1115 {
1116 case kg2UyOrdinary: return presentation(fmt, "kg2UyOrdinary", "Ordinary");
1117 case kg2UyPriority: return presentation(fmt, "kg2UyPriority", "Priority");
1118 case kg2UyMaintenance: return presentation(fmt, "kg2UyMaintenance", "Maintenance");
1119 case kg2UyLocalPayPhone: return presentation(fmt, "kg2UyLocalPayPhone", "Local pay phone");
1120 case kg2UyTrunkOperator: return presentation(fmt, "kg2UyTrunkOperator", "Trunk operator");
1121 case kg2UyDataTrans: return presentation(fmt, "kg2UyDataTrans", "Data transfer");
1122 case kg2UyInternSubscriber: return presentation(fmt, "kg2UyInternSubscriber", "International subscriber");
1123 }
1124 break;
1125
1126 case R2_COUNTRY_VEN:
1127 switch ((KSignGroupII_Venezuela)group)
1128 {
1129 case kg2VeOrdinary: return presentation(fmt, "kg2VeOrdinary", "Ordinary");
1130 case kg2VePriority: return presentation(fmt, "kg2VePriority", "Priority");
1131 case kg2VeMaintenance: return presentation(fmt, "kg2VeMaintenance", "Maintenance");
1132 case kg2VeLocalPayPhone: return presentation(fmt, "kg2VeLocalPayPhone", "Local pay phone");
1133 case kg2VeTrunkOperator: return presentation(fmt, "kg2VeTrunkOperator", "Trunk operator");
1134 case kg2VeDataTrans: return presentation(fmt, "kg2VeDataTrans", "Data transfer");
1135 case kg2VeNoTransferFacility: return presentation(fmt, "kg2VeNoTransferFacility", "No transfer facility");
1136 }
1137 break;
1138 }
1139 #else
1140 switch ((KSignGroupII)group)
1141 {
1142 case kg2Ordinary: return presentation(fmt, "kg2Ordinary", "Ordinary");
1143 case kg2Priority: return presentation(fmt, "kg2Priority", "Priority");
1144 case kg2Maintenance: return presentation(fmt, "kg2Maintenance", "Maintenance");
1145 case kg2LocalPayPhone: return presentation(fmt, "kg2LocalPayPhone", "Local pay phone");
1146 case kg2TrunkOperator: return presentation(fmt, "kg2TrunkOperator", "Trunk operator");
1147 case kg2DataTrans: return presentation(fmt, "kg2DataTrans", "Data transfer");
1148 case kg2NonLocalPayPhone: return presentation(fmt, "kg2NonLocalPayPhone", "Non local pay phone");
1149 case kg2CollectCall: return presentation(fmt, "kg2CollectCall", "Collect call");
1150 case kg2OrdinaryInter: return presentation(fmt, "kg2OrdinaryInter", "Ordinary international");
1151 case kg2Transfered: return presentation(fmt, "kg2Transfered", "Transfered");
1152 }
1153 #endif
1154
1155 throw internal_not_found();
1156 }
1157
1158 #if K3L_AT_LEAST(2,0,0)
signGroupII(const KSignGroupII group,const R2CountryType r2_country,const Verbose::Presentation fmt)1159 std::string Verbose::signGroupII(const KSignGroupII group, const R2CountryType r2_country, const Verbose::Presentation fmt)
1160 #else
1161 std::string Verbose::signGroupII(const KSignGroupII group, const Verbose::Presentation fmt)
1162 #endif
1163 {
1164 try
1165 {
1166 #if K3L_AT_LEAST(2,0,0)
1167 return internal_signGroupII(group, r2_country);
1168 #else
1169 return internal_signGroupII(group);
1170 #endif
1171 }
1172 catch (internal_not_found e)
1173 {
1174 PRESENTATION_CHECK_RETURN(fmt,
1175 STG(FMT("[KSignGroupII='%d']") % (int)group),
1176 STG(FMT("Unknown group II (%d)") % (int)group));
1177 }
1178 }
1179
1180 #if K3L_AT_LEAST(2,0,0)
callFail(const KSignaling sig,const R2CountryType country,const int32 info,const Verbose::Presentation fmt)1181 std::string Verbose::callFail(const KSignaling sig, const R2CountryType country, const int32 info, const Verbose::Presentation fmt)
1182 #else
1183 std::string Verbose::callFail(const KSignaling sig, const int32 info, const Verbose::Presentation fmt)
1184 #endif
1185 {
1186 try
1187 {
1188 switch (sig)
1189 {
1190 case ksigInactive:
1191 throw internal_not_found();
1192
1193 case ksigAnalog:
1194 if (('a' <= ((char)info) && 'z' >= ((char)info)) || ('A' <= ((char)info) && 'Z' >= ((char)info)))
1195 return STG(FMT("%c") % (char)info);
1196 else
1197 throw internal_not_found();
1198
1199 #if K3L_AT_LEAST(1,5,4)
1200 case ksigLineSide:
1201 #endif
1202 #if K3L_EXACT(2,1,0)
1203 case ksigISUP:
1204 #if !K3L_AT_LEAST(2,2,0)
1205 case ksigFax:
1206 #endif
1207 #endif
1208 #if K3L_AT_LEAST(1,6,0)
1209 case ksigCAS_EL7:
1210 case ksigE1LC:
1211 return "NOT IMPLEMENTED";
1212
1213 case ksigAnalogTerminal:
1214 #endif
1215 case ksigContinuousEM:
1216 case ksigPulsedEM:
1217
1218 case ksigR2Digital:
1219 case ksigOpenR2:
1220 #if K3L_AT_LEAST(2,0,0)
1221 return internal_signGroupB((KSignGroupB)info, country);
1222 #else
1223 return internal_signGroupB((KSignGroupB)info);
1224 #endif
1225
1226 case ksigOpenCAS:
1227 case ksigUserR2Digital:
1228 #if K3L_AT_LEAST(2,0,0)
1229 return internal_signGroupB((KSignGroupB)info, R2_COUNTRY_BRA);
1230 #else
1231 return internal_signGroupB((KSignGroupB)info);
1232 #endif
1233
1234 #if K3L_AT_LEAST(1,5,0)
1235 case ksigSIP:
1236 return internal_sipFailures((KSIP_Failures)info);
1237 #endif
1238
1239 #if K3L_AT_LEAST(1,5,1)
1240 case ksigOpenCCS:
1241 case ksigPRI_EndPoint:
1242 case ksigPRI_Network:
1243 case ksigPRI_Passive:
1244 #if K3L_AT_LEAST(2,2,0)
1245 case ksigISUP:
1246 case ksigISUPPassive:
1247 #endif
1248 return internal_isdnCause((KQ931Cause)info);
1249 #endif
1250
1251 #if K3L_AT_LEAST(1,6,0)
1252 case ksigGSM:
1253 return internal_gsmCallCause((KGsmCallCause)info);
1254 #endif
1255 }
1256 }
1257 catch (internal_not_found e)
1258 {
1259 /* this exception is used for breaking the control flow */
1260 }
1261
1262 PRESENTATION_CHECK_RETURN(fmt,
1263 STG(FMT("[%s, callFail='%d']") % signaling(sig, fmt) % (int)info),
1264 STG(FMT("Unknown call fail code for '%s' (%d)") % signaling(sig, fmt) % (int)info));
1265 }
1266
channelFail(const KSignaling sig,const int32 code,const Verbose::Presentation fmt)1267 std::string Verbose::channelFail(const KSignaling sig, const int32 code, const Verbose::Presentation fmt)
1268 {
1269 try
1270 {
1271 switch (sig)
1272 {
1273 case ksigInactive:
1274 case ksigAnalog:
1275 case ksigSIP:
1276 #if K3L_EXACT(2,1,0)
1277 case ksigISUP:
1278 #if !K3L_AT_LEAST(2,2,0)
1279 case ksigFax:
1280 #endif
1281 #endif
1282 throw internal_not_found();
1283
1284 #if K3L_AT_LEAST(1,6,0)
1285 case ksigGSM:
1286 return internal_gsmMobileCause((KGsmMobileCause)code);
1287
1288 case ksigAnalogTerminal:
1289 case ksigCAS_EL7:
1290 case ksigE1LC:
1291 #endif
1292
1293 case ksigContinuousEM:
1294 case ksigPulsedEM:
1295
1296 case ksigLineSide:
1297
1298 case ksigOpenCAS:
1299 case ksigOpenR2:
1300 case ksigR2Digital:
1301 case ksigUserR2Digital:
1302 switch ((KChannelFail)code)
1303 {
1304 case kfcRemoteFail: return presentation(fmt, "kfcRemoteFail", "Remote failure");
1305 case kfcLocalFail: return presentation(fmt, "kfcLocalFail", "Local failure");
1306 case kfcRemoteLock: return presentation(fmt, "kfcRemoteLock", "Remote lock");
1307 case kfcLineSignalFail: return presentation(fmt, "kfcLineSignalFail", "Line signal failure");
1308 case kfcAcousticSignalFail: return presentation(fmt, "kfcAcousticSignalFail", "Acoustic signal failure");
1309 }
1310
1311 throw internal_not_found();
1312
1313 #if K3L_AT_LEAST(1,5,1)
1314 case ksigOpenCCS:
1315 case ksigPRI_EndPoint:
1316 case ksigPRI_Network:
1317 case ksigPRI_Passive:
1318 #if K3L_AT_LEAST(2,2,0)
1319 case ksigISUP:
1320 case ksigISUPPassive:
1321 #endif
1322 return internal_isdnCause((KQ931Cause)code);
1323 #endif
1324 }
1325 }
1326 catch (internal_not_found e)
1327 {
1328 /* this exception is used for breaking the control flow */
1329 }
1330
1331 PRESENTATION_CHECK_RETURN(fmt,
1332 STG(FMT("[%s, channelFail='%d']") % signaling(sig, fmt) % (int)code),
1333 STG(FMT("Unknown channel fail code for '%s' (%d)") % signaling(sig, fmt) % (int)code));
1334 }
1335
internalFail(const KInternalFail inf,const Verbose::Presentation fmt)1336 std::string Verbose::internalFail(const KInternalFail inf, const Verbose::Presentation fmt)
1337 {
1338 switch (inf)
1339 {
1340 case kifInterruptCtrl: return presentation(fmt, "kifInterruptCtrl", "Interrupt control");
1341 case kifCommunicationFail: return presentation(fmt, "kifCommunicationFail", "Communication failure");
1342 case kifProtocolFail: return presentation(fmt, "kifProtocolFail", "Protocol failure");
1343 case kifInternalBuffer: return presentation(fmt, "kifInternalBuffer", "Internal buffer");
1344 case kifMonitorBuffer: return presentation(fmt, "kifMonitorBuffer", "Monitor buffer");
1345 case kifInitialization: return presentation(fmt, "kifInitialization", "Initialization");
1346 case kifInterfaceFail: return presentation(fmt, "kifInterfaceFail", "Interface failure");
1347 case kifClientCommFail: return presentation(fmt, "kifClientCommFail", "Client communication failure");
1348 }
1349
1350 PRESENTATION_CHECK_RETURN(fmt,
1351 STG(FMT("[KInternalFail='%d']") % (int)inf),
1352 STG(FMT("Unknown internal failure (%d)") % (int)inf));
1353 }
1354
linkErrorCounter(const KLinkErrorCounter ec,const Verbose::Presentation fmt)1355 std::string Verbose::linkErrorCounter(const KLinkErrorCounter ec, const Verbose::Presentation fmt)
1356 {
1357 switch (ec)
1358 {
1359 case klecChangesToLock: return presentation(fmt, "klecChangesToLock", "Changes to lock");
1360 case klecLostOfSignal: return presentation(fmt, "klecLostOfSignal", "Lost of signal");
1361 case klecAlarmNotification: return presentation(fmt, "klecAlarmNotification", "Alarm notification");
1362 case klecLostOfFrame: return presentation(fmt, "klecLostOfFrame", "Lost of frame");
1363 case klecLostOfMultiframe: return presentation(fmt, "klecLostOfMultiframe", "Lost of multiframe");
1364 case klecRemoteAlarm: return presentation(fmt, "klecRemoteAlarm", "Remote alarm");
1365 case klecUnknowAlarm: return presentation(fmt, "klecUnknowAlarm", "Slip alarm");
1366 case klecPRBS: return presentation(fmt, "klecPRBS", "PRBS");
1367 case klecWrogrBits: return presentation(fmt, "klecWrongBits", "Wrong bits");
1368 case klecJitterVariation: return presentation(fmt, "klecJitterVariation", "Jitter variation");
1369 case klecFramesWithoutSync: return presentation(fmt, "klecFramesWithoutSync", "Frames without sync");
1370 case klecMultiframeSignal: return presentation(fmt, "klecMultiframeSignal", "Multiframe Signal");
1371 case klecFrameError: return presentation(fmt, "klecFrameError", "Frame error");
1372 case klecBipolarViolation: return presentation(fmt, "klecBipolarViolation", "Bipolar violation");
1373 case klecCRC4: return presentation(fmt, "klecCRC4", "CRC4 error");
1374 case klecCount: return ""; /* this should never be verbosed */
1375 }
1376
1377 PRESENTATION_CHECK_RETURN(fmt,
1378 STG(FMT("[KLinkErrorCounter='%d']") % (int)ec),
1379 STG(FMT("Unknown link error counter (%d)") % (int)ec));
1380 }
1381
callStatus(const KCallStatus code,const Verbose::Presentation fmt)1382 std::string Verbose::callStatus(const KCallStatus code, const Verbose::Presentation fmt)
1383 {
1384 switch (code)
1385 {
1386 case kcsFree: return presentation(fmt, "kcsFree", "Free");
1387 case kcsIncoming: return presentation(fmt, "kcsIncoming", "Incoming");
1388 case kcsOutgoing: return presentation(fmt, "kcsOutgoing", "Outgoing");
1389 case kcsFail: return presentation(fmt, "kcsFail", "Failure");
1390 }
1391
1392 PRESENTATION_CHECK_RETURN(fmt,
1393 STG(FMT("[KCallStatus='%d']") % (int)code),
1394 STG(FMT("Unknown call status (%d)") % (int)code));
1395 }
1396
linkStatus(const KSignaling sig,const int32 code,const Verbose::Presentation fmt,const bool simpleStatus)1397 std::string Verbose::linkStatus(const KSignaling sig, const int32 code, const Verbose::Presentation fmt, const bool simpleStatus)
1398 {
1399 switch (sig)
1400 {
1401 case ksigInactive:
1402 return presentation(fmt, "[ksigInactive]", "Inactive trunk");
1403
1404 case ksigAnalog:
1405 return presentation(fmt, "[ksigAnalog]", "Analog trunk");
1406
1407 #if K3L_AT_LEAST(1,4,1)
1408 case ksigSIP:
1409 return presentation(fmt, "[ksigSIP]", "SIP trunk");
1410 #endif
1411
1412 #if K3L_AT_LEAST(1,6,0)
1413 case ksigGSM:
1414 return presentation(fmt, "[ksigGSM]", "GSM trunk");
1415 #endif
1416
1417 #if K3L_EXACT(2,1,0)
1418 #if !K3L_AT_LEAST(2,2,0)
1419 case ksigFax:
1420 #endif
1421 return presentation(fmt, "[ksigFax]", "FAX");
1422 #endif
1423 case ksigContinuousEM:
1424 case ksigPulsedEM:
1425
1426 case ksigOpenCAS:
1427 case ksigOpenR2:
1428 case ksigR2Digital:
1429 case ksigUserR2Digital:
1430
1431 #if K3L_AT_LEAST(1,5,1)
1432 case ksigOpenCCS:
1433 case ksigPRI_EndPoint:
1434 case ksigPRI_Network:
1435 case ksigPRI_Passive:
1436 #endif
1437 #if K3L_AT_LEAST(1,5,3)
1438 case ksigLineSide:
1439 #endif
1440 #if K3L_AT_LEAST(1,6,0)
1441 case ksigAnalogTerminal:
1442 case ksigCAS_EL7:
1443 case ksigE1LC:
1444 #endif
1445 #if K3L_AT_LEAST(2,2,0)
1446 case ksigISUP:
1447 case ksigISUPPassive:
1448 #endif
1449 if (kesOk == code)
1450 {
1451 return presentation(fmt, "kesOk", "Up");
1452 }
1453 else
1454 {
1455 Strings::Merger strs;
1456
1457 if (kesSignalLost & code) strs.add(presentation(fmt, "SignalLost", "Signal lost"));
1458 if (kesNetworkAlarm & code) strs.add(presentation(fmt, "NetworkAlarm", "Network alarm"));
1459 if (kesFrameSyncLost & code) strs.add(presentation(fmt, "FrameSyncLost", "Frame sync lost"));
1460 if (kesMultiframeSyncLost & code) strs.add(presentation(fmt, "MultiframeSyncLost", "Multiframe sync lost"));
1461 if (kesRemoteAlarm & code) strs.add(presentation(fmt, "RemoteAlarm", "Remote alarm"));
1462 if (kesHighErrorRate & code) strs.add(presentation(fmt, "HighErrorRate", "High error rate"));
1463 if (kesUnknownAlarm & code) strs.add(presentation(fmt, "UnknownAlarm", "Slip alarm"));
1464 if (kesE1Error & code) strs.add(presentation(fmt, "E1Error", "E1 error"));
1465
1466 if (simpleStatus)
1467 {
1468 PRESENTATION_CHECK_RETURN(fmt,
1469 STG(FMT("kes{%s}") % *(strs.list().begin())),
1470 *(strs.list().begin()));
1471 }
1472 else
1473 {
1474 PRESENTATION_CHECK_RETURN(fmt,
1475 STG(FMT("kes{%s}") % strs.merge(",")),
1476 strs.merge(", "));
1477 }
1478 }
1479 }
1480
1481 PRESENTATION_CHECK_RETURN(fmt,
1482 STG(FMT("[%s, linkStatus='%d']") % signaling(sig) % (int)code),
1483 STG(FMT("Unknown link status for '%s' (%d)") % signaling(sig) % (int)code));
1484 }
1485
channelStatus(const KSignaling sig,const int32 flags,const Verbose::Presentation fmt)1486 std::string Verbose::channelStatus(const KSignaling sig, const int32 flags, const Verbose::Presentation fmt)
1487 {
1488 try
1489 {
1490 switch (sig)
1491 {
1492 case ksigInactive:
1493 return presentation(fmt, "[ksigInactive]", "Inactive channel");
1494
1495 #if K3L_AT_LEAST(1,4,1)
1496 case ksigSIP:
1497 return presentation(fmt, "[ksigSIP]", "SIP channel");
1498 #endif
1499 #if K3L_EXACT(2,1,0)
1500 case ksigISUP:
1501 return presentation(fmt, "[ksigISUP]", "ISUP trunk");
1502 #if !K3L_AT_LEAST(2,2,0)
1503 case ksigFax:
1504 return presentation(fmt, "[ksigFax]", "FAX");
1505 #endif
1506 #endif
1507
1508 case ksigAnalog:
1509 #if K3L_AT_LEAST(1,6,0)
1510 switch ((KFXOChannelStatus)flags)
1511 #else
1512 switch ((KFXChannelStatus)flags)
1513 #endif
1514 {
1515 case kfcsDisabled: return presentation(fmt, "kfcsDisabled", "Disabled");
1516 case kfcsEnabled: return presentation(fmt, "kfcsEnabled", "Enabled");
1517 }
1518
1519 throw internal_not_found();
1520
1521 #if K3L_AT_LEAST(1,6,0)
1522 case ksigAnalogTerminal:
1523 switch ((KFXSChannelStatus)flags)
1524 {
1525 case kfxsOnHook: return presentation(fmt, "kfxsOnHook", "On Hook");
1526 case kfxsOffHook: return presentation(fmt, "kfxsOffHook", "Off Hook");
1527 case kfxsRinging: return presentation(fmt, "kfxsRinging", "Ringing");
1528 case kfxsFail: return presentation(fmt, "kfxsFail", "Failure");
1529 }
1530
1531 throw internal_not_found();
1532
1533 case ksigGSM:
1534 switch ((KGsmChannelStatus)flags)
1535 {
1536 case kgsmIdle: return presentation(fmt, "kgsmIdle", "Idle");
1537 case kgsmCallInProgress: return presentation(fmt, "kgsmCallInProgress", "Call in progress");
1538 case kgsmSMSInProgress: return presentation(fmt, "kgsmSMSInProgress", "SMS in progress");
1539 case kgsmModemError: return presentation(fmt, "kgsmModemError", "Modem error");
1540 case kgsmSIMCardError: return presentation(fmt, "kgsmSIMCardError", "SIM card error");
1541 case kgsmNetworkError: return presentation(fmt, "kgsmNetworkError", "Network error");
1542 case kgsmNotReady: return presentation(fmt, "kgsmNotReady", "Initializing");
1543 }
1544
1545 throw internal_not_found();
1546 #endif
1547
1548 /* deprecated, but still.. */
1549 case ksigPulsedEM:
1550 case ksigContinuousEM:
1551
1552 case ksigOpenCAS:
1553 case ksigOpenR2:
1554 case ksigR2Digital:
1555 case ksigUserR2Digital:
1556
1557 #if K3L_AT_LEAST(1,5,1)
1558 case ksigOpenCCS:
1559 case ksigPRI_EndPoint:
1560 case ksigPRI_Network:
1561 case ksigPRI_Passive:
1562 #endif
1563 #if K3L_AT_LEAST(1,5,3)
1564 case ksigLineSide:
1565 #endif
1566 #if K3L_AT_LEAST(1,6,0)
1567 case ksigCAS_EL7:
1568 case ksigE1LC:
1569 #endif
1570 #if K3L_AT_LEAST(2,2,0)
1571 case ksigISUP:
1572 case ksigISUPPassive:
1573 #endif
1574 {
1575 if (flags == kecsFree)
1576 {
1577 return presentation(fmt, "kecsFree", "Free");
1578 }
1579 else
1580 {
1581 Strings::Merger strs;
1582
1583 if (flags & kecsBusy)
1584 strs.add("Busy");
1585
1586 switch (flags & 0x06)
1587 {
1588 case kecsOutgoing:
1589 strs.add("Outgoing");
1590 break;
1591 case kecsIncoming:
1592 strs.add("Incoming");
1593 break;
1594 case kecsLocked:
1595 strs.add("Locked");
1596 default:
1597 break;
1598 }
1599
1600 int32 value = (flags & 0xf0);
1601
1602 if (kecsOutgoingLock & value)
1603 strs.add(presentation(fmt, "OutgoingLock", "Outgoing Lock"));
1604
1605 if (kecsLocalFail & value)
1606 strs.add(presentation(fmt, "LocalFail", "Local Failure"));
1607
1608 if (kecsIncomingLock & value)
1609 strs.add(presentation(fmt, "IncomingLock", "Incoming Lock"));
1610
1611 if (kecsRemoteLock & value)
1612 strs.add(presentation(fmt, "RemoteLock", "Remote Lock"));
1613
1614 PRESENTATION_CHECK_RETURN(fmt,
1615 STG(FMT("kecs{%s}") % strs.merge(",")),
1616 strs.merge(", "));
1617 }
1618
1619 throw internal_not_found();
1620 }
1621 }
1622 }
1623 catch (internal_not_found e)
1624 {
1625 /* we use this exception to break the control flow */
1626 }
1627
1628 PRESENTATION_CHECK_RETURN(fmt,
1629 STG(FMT("[%s, channelStatus='%d']") % signaling(sig) % flags),
1630 STG(FMT("Unknown channel status for '%s' (%d)") % signaling(sig) % flags));
1631 }
1632
status(const KLibraryStatus code,const Verbose::Presentation fmt)1633 std::string Verbose::status(const KLibraryStatus code, const Verbose::Presentation fmt)
1634 {
1635 switch (code)
1636 {
1637 case ksSuccess: return presentation(fmt, "ksSuccess", "Success");
1638 case ksFail: return presentation(fmt, "ksFail", "Failure");
1639 case ksTimeOut: return presentation(fmt, "ksTimeOut", "Time Out");
1640 case ksBusy: return presentation(fmt, "ksBusy", "Busy");
1641 case ksLocked: return presentation(fmt, "ksLocked", "Locked");
1642 case ksInvalidParams: return presentation(fmt, "ksInvalidParams", "Invalid Parameters");
1643 case ksEndOfFile: return presentation(fmt, "ksEndOfFile", "End of File");
1644 case ksInvalidState: return presentation(fmt, "ksInvalidState", "Invalid State");
1645 case ksServerCommFail: return presentation(fmt, "ksServerCommFail", "Communication Failure");
1646 case ksOverflow: return presentation(fmt, "ksOverflow", "Overflow");
1647 case ksUnderrun: return presentation(fmt, "ksUnderrun", "Underrun");
1648
1649 #if K3L_AT_LEAST(1,4,0)
1650 case ksNotFound: return presentation(fmt, "ksNotFound", "Not Found");
1651 case ksNotAvailable: return presentation(fmt, "ksNotAvaiable", "Not Available");
1652 #endif
1653 }
1654
1655 PRESENTATION_CHECK_RETURN(fmt,
1656 STG(FMT("[KLibraryStatus='%d']") % (int)code),
1657 STG(FMT("Unknown library status (%d)") % (int)code));
1658 }
1659
h100configIndex(const KH100ConfigIndex code,const Verbose::Presentation fmt)1660 std::string Verbose::h100configIndex(const KH100ConfigIndex code, const Verbose::Presentation fmt)
1661 {
1662 switch (code)
1663 {
1664 case khciDeviceMode: return presentation(fmt, "khciDeviceMode", "Device Mode");
1665 case khciMasterGenClock: return presentation(fmt, "khciMasterGenClock", "Master Generated Clock");
1666 case khciCTNetRefEnable: return presentation(fmt, "khciCTNetRefEnable", "CTBus Network Reference Enable");
1667 case khciSCbusEnable: return presentation(fmt, "khciSCbusEnable", "SCBus Enable");
1668 case khciHMVipEnable: return presentation(fmt, "khciHMVipEnable", "HMVip Enable");
1669 case khciMVip90Enable: return presentation(fmt, "khciMVip90Enable", "MVip90 Enable");
1670 case khciCTbusDataEnable: return presentation(fmt, "khciCTbusDataEnable", "CTBus Data Enable");
1671 case khciCTbusFreq03_00: return presentation(fmt, "khciCTbusFreq03_00", "CTBus Frequency 03 00"); // TODO: find better name
1672 case khciCTbusFreq07_04: return presentation(fmt, "khciCTbusFreq07_04", "CTBus Frequency 07 04"); // TODO: find better name
1673 case khciCTbusFreq11_08: return presentation(fmt, "khciCTbusFreq11_08", "CTBus Frequency 11 08"); // TODO: find better name
1674 case khciCTbusFreq15_12: return presentation(fmt, "khciCTbusFreq15_12", "CTBus Frequency 15 12"); // TODO: find better name
1675 case khciMax: return presentation(fmt, "khciMax", "Max"); // TODO: find better name
1676 case khciMasterDevId: return presentation(fmt, "khciMasterDevId", "Master Device Number");
1677 case khciSecMasterDevId: return presentation(fmt, "khciSecMasterDevId", "Secondary Master Device Number");
1678 case khciCtNetrefDevId: return presentation(fmt, "khciCtNetrefDevId", "CTBus Network Reference Device Number");
1679 #if K3L_AT_LEAST(1,6,0)
1680 case khciMaxH100ConfigIndex: return ""; /* do not verbose this value */
1681 #endif
1682 }
1683
1684 PRESENTATION_CHECK_RETURN(fmt,
1685 STG(FMT("[KH100ConfigIndex='%d']") % (int)code),
1686 STG(FMT("Unknown H.100 config index (%d)") % (int)code));
1687 }
1688
1689 #if K3L_AT_LEAST(1,6,0)
callStartInfo(const KCallStartInfo code,const Verbose::Presentation fmt)1690 std::string Verbose::callStartInfo(const KCallStartInfo code, const Verbose::Presentation fmt)
1691 {
1692 switch (code)
1693 {
1694 case kcsiHumanAnswer: return presentation(fmt, "kcsiHumanAnswer", "Human Answer");
1695 case kcsiAnsweringMachine: return presentation(fmt, "kcsiAnsweringMachine", "Answering Machine");
1696 case kcsiCellPhoneMessageBox: return presentation(fmt, "kcsiCellPhoneMessageBox", "Cell Phone Message Box");
1697 case kcsiCarrierMessage: return presentation(fmt, "kcsiCarrierMessage", "Carrier Message");
1698 case kcsiUnknown: return presentation(fmt, "kcsiUnknown", "Unknown");
1699 }
1700
1701 PRESENTATION_CHECK_RETURN(fmt,
1702 STG(FMT("[KCallStartInfo='%d']") % (int)code),
1703 STG(FMT("Unknown call answer info (%d)") % (int)code));
1704 }
1705
gsmCallCause(const KGsmCallCause code,const Verbose::Presentation fmt)1706 std::string Verbose::gsmCallCause(const KGsmCallCause code, const Verbose::Presentation fmt)
1707 {
1708 try
1709 {
1710 return internal_gsmCallCause(code, fmt);
1711 }
1712 catch (internal_not_found e)
1713 {
1714 PRESENTATION_CHECK_RETURN(fmt,
1715 STG(FMT("[KGsmCallCause='%d']") % (int)code),
1716 STG(FMT("Unknown GSM call cause (%d)") % (int)code));
1717 }
1718 }
1719
internal_gsmCallCause(const KGsmCallCause code,const Verbose::Presentation fmt)1720 std::string Verbose::internal_gsmCallCause(const KGsmCallCause code, const Verbose::Presentation fmt)
1721 {
1722 switch (code)
1723 {
1724 case kgccNone: return presentation(fmt, "kgccNone", "None");
1725 case kgccUnallocatedNumber: return presentation(fmt, "kgccUnallocatedNumber", "Unallocated number");
1726 case kgccNoRouteToDest: return presentation(fmt, "kgccNoRouteToDest", "No route to destination");
1727 case kgccChannelUnacceptable: return presentation(fmt, "kgccChannelUnacceptable", "Channel unacceptable");
1728 case kgccOperatorDeterminedBarring: return presentation(fmt, "kgccOperatorDeterminedBarring", "Operator determined barring");
1729 case kgccNormalCallClear: return presentation(fmt, "kgccNormalCallClear", "Normal call clear");
1730 case kgccUserBusy: return presentation(fmt, "kgccUserBusy", "User busy");
1731 case kgccNoUserResponding: return presentation(fmt, "kgccNoUserResponding", "No user responding");
1732 case kgccNoAnswerFromUser: return presentation(fmt, "kgccNoAnswerFromUser", "No answer from user");
1733 case kgccCallRejected: return presentation(fmt, "kgccCallRejected", "Call rejected");
1734 case kgccNumberChanged: return presentation(fmt, "kgccNumberChanged", "Number changed");
1735 case kgccNonSelectedUserClear: return presentation(fmt, "kgccNonSelectedUserClear", "Non Selected user clear");
1736 case kgccDestinationOutOfOrder: return presentation(fmt, "kgccDestinationOutOfOrder", "Destination out of order");
1737 case kgccInvalidNumberFormat: return presentation(fmt, "kgccInvalidNumberFormat", "Invalid number format");
1738 case kgccFacilityRejected: return presentation(fmt, "kgccFacilityRejected", "Facility rejected");
1739 case kgccRespStatusEnquiry: return presentation(fmt, "kgccRespStatusEnquiry", "Response status enquiry");
1740 case kgccNormalUnspecified: return presentation(fmt, "kgccNormalUnspecified", "Normal, unspecified");
1741 case kgccNoCircuitChannelAvail: return presentation(fmt, "kgccNoCircuitChannelAvail", "No circuit channel available");
1742 case kgccNetworkOutOfOrder: return presentation(fmt, "kgccNetworkOutOfOrder", "Network out of order");
1743 case kgccTemporaryFailure: return presentation(fmt, "kgccTemporaryFailure", "Temporary failure");
1744 case kgccSwitchCongestion: return presentation(fmt, "kgccSwitchCongestion", "Switch congestion");
1745 case kgccAccessInfoDiscarded: return presentation(fmt, "kgccAccessInfoDiscarded", "Access information discarded");
1746 case kgccRequestedChannelUnav: return presentation(fmt, "kgccRequestedChannelUnav", "Requested channel unavailable");
1747 case kgccResourceUnavailable: return presentation(fmt, "kgccResourceUnavailable", "Resource unavailable");
1748 case kgccQosUnavailable: return presentation(fmt, "kgccQosUnavailable", "QoS unavailable");
1749 case kgccReqFacilityNotSubsc: return presentation(fmt, "kgccReqFacilityNotSubsc", "Request facility not subscribed");
1750 case kgccCallBarredWitchCUG: return presentation(fmt, "kgccCallBarredWitchCUG", "Call barred with UG");
1751 case kgccBearerCapabNotAuthor: return presentation(fmt, "kgccBearerCapabNotAuthor", "Bearer capability not authorized");
1752 case kgccBearerCapabNotAvail: return presentation(fmt, "kgccBearerCapabNotAvail", "Bearer capability not available");
1753 case kgccServiceNotAvailable: return presentation(fmt, "kgccServiceNotAvailable", "Service not available");
1754 case kgccBcNotImplemented: return presentation(fmt, "kgccBcNotImplemented", "Bearer capability not implemented");
1755 case kgccReqFacilityNotImplem: return presentation(fmt, "kgccReqFacilityNotImplem", "Request facility not implemented");
1756 case kgccOnlyRestrictedBcAvail: return presentation(fmt, "kgccOnlyRestrictedBcAvail", "Only restricted bearer capability available");
1757 case kgccServiceNotImplemented: return presentation(fmt, "kgccServiceNotImplemented", "Service not implemented");
1758 case kgccInvalidCrv: return presentation(fmt, "kgccInvalidCrv", "Invalid call reference value");
1759 case kgccUserNotMemberOfCUG: return presentation(fmt, "kgccUserNotMemberOfCUG", "User not member of UG");
1760 case kgccIncompatibleDestination: return presentation(fmt, "kgccIncompatibleDestination", "Incompatible destination");
1761 case kgccInvalidTransitNetSel: return presentation(fmt, "kgccInvalidTransitNetSel", "Invalid transit network selected");
1762 case kgccInvalidMessage: return presentation(fmt, "kgccInvalidMessage", "Invalid message");
1763 case kgccMissingMandatoryIe: return presentation(fmt, "kgccMissingMandatoryIe", "Missing mandatory information element");
1764 case kgccMsgTypeNotImplemented: return presentation(fmt, "kgccMsgTypeNotImplemented", "Message type not implemented");
1765 case kgccMsgIncompatWithState: return presentation(fmt, "kgccMsgIncompatWithState", "Message incompatible with state");
1766 case kgccIeNotImplemented: return presentation(fmt, "kgccIeNotImplemented", "Information element not implemented");
1767 case kgccInvalidIe: return presentation(fmt, "kgccInvalidIe", "Invalid information element");
1768 case kgccMsgIncompatWithState2: return presentation(fmt, "kgccMsgIncompatWithState2", "Message incompatible with state (2)");
1769 case kgccRecoveryOnTimerExpiry: return presentation(fmt, "kgccRecoveryOnTimerExpiry", "Recovery on timer expiry");
1770 case kgccProtocolError: return presentation(fmt, "kgccProtocolError", "Protocol error");
1771 case kgccInterworking: return presentation(fmt, "kgccInterworking", "Interworking");
1772 }
1773
1774 throw internal_not_found();
1775 }
1776
gsmMobileCause(const KGsmMobileCause code,const Verbose::Presentation fmt)1777 std::string Verbose::gsmMobileCause(const KGsmMobileCause code, const Verbose::Presentation fmt)
1778 {
1779 try
1780 {
1781 return internal_gsmMobileCause(code, fmt);
1782 }
1783 catch (internal_not_found e)
1784 {
1785 PRESENTATION_CHECK_RETURN(fmt,
1786 STG(FMT("[KGsmMobileCause='%d']") % (int)code),
1787 STG(FMT("Unknown GSM mobile cause (%d)") % (int)code));
1788 }
1789 }
1790
internal_gsmMobileCause(const KGsmMobileCause code,const Verbose::Presentation fmt)1791 std::string Verbose::internal_gsmMobileCause(const KGsmMobileCause code, const Verbose::Presentation fmt)
1792 {
1793 switch (code)
1794 {
1795 case kgmcPhoneFailure: return presentation(fmt, "kgmcPhoneFailure", "Phone failure");
1796 case kgmcNoConnectionToPhone: return presentation(fmt, "kgmcNoConnectionToPhone", "No connection to phone");
1797 case kgmcPhoneAdaptorLinkReserved: return presentation(fmt, "kgmcPhoneAdaptorLinkReserved", "Phone adaptor link reserved");
1798 #if 0 /* this changed during K3L 1.6.0 development cycle... */
1799 case kgmcCoperationNotAllowed: return presentation(fmt, "kgmcCoperationNotAllowed", "");
1800 case kgmcCoperationNotSupported: return presentation(fmt, "kgmcCoperationNotSupported", "");
1801 #else
1802 case kgmcOperationNotAllowed: return presentation(fmt, "kgmcOperationNotAllowed", "Operation not allowed");
1803 case kgmcOperationNotSupported: return presentation(fmt, "kgmcOperationNotSupported", "Operation not supported");
1804 #endif
1805 case kgmcPH_SIMPINRequired: return presentation(fmt, "kgmcPH_SIMPINRequired", "Phone SIM PIN required");
1806 case kgmcPH_FSIMPINRequired: return presentation(fmt, "kgmcPH_FSIMPINRequired", "Phone FSIM PIN required");
1807 case kgmcPH_FSIMPUKRequired: return presentation(fmt, "kgmcPH_FSIMPUKRequired", "Phone FSIM PUK required");
1808 case kgmcSIMNotInserted: return presentation(fmt, "kgmcSIMNotInserted", "SIM not inserted");
1809 case kgmcSIMPINRequired: return presentation(fmt, "kgmcSIMPINRequired", "SIM PIN required");
1810 case kgmcSIMPUKRequired: return presentation(fmt, "kgmcSIMPUKRequired", "SIM PUK required");
1811 case kgmcSIMFailure: return presentation(fmt, "kgmcSIMFailure", "SIM failure");
1812 case kgmcSIMBusy: return presentation(fmt, "kgmcSIMBusy", "SIM busy");
1813 case kgmcSIMWrong: return presentation(fmt, "kgmcSIMWrong", "SIM wrong");
1814 case kgmcIncorrectPassword: return presentation(fmt, "kgmcIncorrectPassword", "Incorrect password");
1815 case kgmcSIMPIN2Required: return presentation(fmt, "kgmcSIMPIN2Required", "SIM PIN2 required");
1816 case kgmcSIMPUK2Required: return presentation(fmt, "kgmcSIMPUK2Required", "SIM PUK2 required");
1817 case kgmcMemoryFull: return presentation(fmt, "kgmcMemoryFull", "Memory full");
1818 case kgmcInvalidIndex: return presentation(fmt, "kgmcInvalidIndex", "Invalid index");
1819 case kgmcNotFound: return presentation(fmt, "kgmcNotFound", "Not found");
1820 case kgmcMemoryFailure: return presentation(fmt, "kgmcMemoryFailure", "Memory failure");
1821 case kgmcTextStringTooLong: return presentation(fmt, "kgmcTextStringTooLong", "Text string too long");
1822 case kgmcInvalidCharInTextString: return presentation(fmt, "kgmcInvalidCharInTextString", "Invalid character in text string");
1823 case kgmcDialStringTooLong: return presentation(fmt, "kgmcDialStringTooLong", "Dial string too long");
1824 case kgmcInvalidCharInDialString: return presentation(fmt, "kgmcInvalidCharInDialString", "Invalid character in dial string");
1825 case kgmcNoNetworkService: return presentation(fmt, "kgmcNoNetworkService", "No network service");
1826 case kgmcNetworkTimeout: return presentation(fmt, "kgmcNetworkTimeout", "Network timeout");
1827 case kgmcNetworkNotAllowed: return presentation(fmt, "kgmcNetworkNotAllowed", "Network not allowed");
1828 case kgmcCommandAborted: return presentation(fmt, "kgmcCommandAborted", "Command aborted");
1829 case kgmcNumParamInsteadTextParam: return presentation(fmt, "kgmcNumParamInsteadTextParam", "Number parameter instead of text parameter");
1830 case kgmcTextParamInsteadNumParam: return presentation(fmt, "kgmcTextParamInsteadNumParam", "Text parameter instead of number parameter");
1831 case kgmcNumericParamOutOfBounds: return presentation(fmt, "kgmcNumericParamOutOfBounds", "Numeric parameter out of bounds");
1832 case kgmcTextStringTooShort: return presentation(fmt, "kgmcTextStringTooShort", "Text string too short");
1833 case kgmcNetworkPINRequired: return presentation(fmt, "kgmcNetworkPINRequired", "Network PIN required");
1834 case kgmcNetworkPUKRequired: return presentation(fmt, "kgmcNetworkPUKRequired", "Network PUK required");
1835 case kgmcNetworkSubsetPINRequired: return presentation(fmt, "kgmcNetworkSubsetPINRequired", "Network subset PIN required");
1836 case kgmcNetworkSubnetPUKRequired: return presentation(fmt, "kgmcNetworkSubnetPUKRequired", "Network subset PUK required");
1837 case kgmcServiceProviderPINRequired: return presentation(fmt, "kgmcServiceProviderPINRequired", "Network service provider PIN required");
1838 case kgmcServiceProviderPUKRequired: return presentation(fmt, "kgmcServiceProviderPUKRequired", "Network service provider PUK required");
1839 case kgmcCorporatePINRequired: return presentation(fmt, "kgmcCorporatePINRequired", "Corporate PIN required");
1840 case kgmcCorporatePUKRequired: return presentation(fmt, "kgmcCorporatePUKRequired", "Corporate PUK required");
1841 case kgmcSIMServiceOptNotSupported: return presentation(fmt, "kgmcSIMServiceOptNotSupported", "SIM Service option not supported");
1842 case kgmcUnknown: return presentation(fmt, "kgmcUnknown", "Unknown");
1843 case kgmcIllegalMS_N3: return presentation(fmt, "kgmcIllegalMS_N3", "Illegal MS #3");
1844 case kgmcIllegalME_N6: return presentation(fmt, "kgmcIllegalME_N6", "Illegal MS #6");
1845 case kgmcGPRSServicesNotAllowed_N7: return presentation(fmt, "kgmcGPRSServicesNotAllowed_N7", "GPRS service not allowed #7");
1846 case kgmcPLMNNotAllowed_No11: return presentation(fmt, "kgmcPLMNNotAllowed_No11", "PLMN not allowed #11");
1847 case kgmcLocationAreaNotAllowed_N12: return presentation(fmt, "kgmcLocationAreaNotAllowed_N12", "Location area not allowed #12");
1848 case kgmcRoamingNotAllowed_N13: return presentation(fmt, "kgmcRoamingNotAllowed_N13", "Roaming not allowed #13");
1849 case kgmcServiceOptNotSupported_N32: return presentation(fmt, "kgmcServiceOptNotSupported_N32", "Service option not supported #32");
1850 case kgmcReqServOptNotSubscribed_N33: return presentation(fmt, "kgmcReqServOptNotSubscribed_N33", "Registration service option not subscribed #33");
1851 case kgmcServOptTempOutOfOrder_N34: return presentation(fmt, "kgmcServOptTempOutOfOrder_N34", "Service option temporary out of order #34");
1852 case kgmcLongContextActivation: return presentation(fmt, "kgmcLongContextActivation", "Long context activation");
1853 case kgmcUnspecifiedGPRSError: return presentation(fmt, "kgmcUnspecifiedGPRSError", "Unspecified GPRS error");
1854 case kgmcPDPAuthenticationFailure: return presentation(fmt, "kgmcPDPAuthenticationFailure", "PDP authentication failure");
1855 case kgmcInvalidMobileClass: return presentation(fmt, "kgmcInvalidMobileClass", "Invalid mobile class");
1856 case kgmcGPRSDisconnectionTmrActive: return presentation(fmt, "kgmcGPRSDisconnectionTmrActive", "GPRS disconnection TMR active");
1857 case kgmcTooManyActiveCalls: return presentation(fmt, "kgmcTooManyActiveCalls", "Too many active calls");
1858 case kgmcCallRejected: return presentation(fmt, "kgmcCallRejected", "Call rejected");
1859 case kgmcUnansweredCallPending: return presentation(fmt, "kgmcUnansweredCallPending", "Unanswered call pending");
1860 case kgmcUnknownCallingError: return presentation(fmt, "kgmcUnknownCallingError", "Unknown calling error");
1861 case kgmcNoPhoneNumRecognized: return presentation(fmt, "kgmcNoPhoneNumRecognized", "No phone number recognized");
1862 case kgmcCallStateNotIdle: return presentation(fmt, "kgmcCallStateNotIdle", "Call state not idle");
1863 case kgmcCallInProgress: return presentation(fmt, "kgmcCallInProgress", "Call in progress");
1864 case kgmcDialStateError: return presentation(fmt, "kgmcDialStateError", "Dial state error");
1865 case kgmcUnlockCodeRequired: return presentation(fmt, "kgmcUnlockCodeRequired", "Unlock code required");
1866 case kgmcNetworkBusy: return presentation(fmt, "kgmcNetworkBusy", "Network busy");
1867 case kgmcInvalidPhoneNumber: return presentation(fmt, "kgmcInvalidPhoneNumber", "Invalid phone number");
1868 case kgmcNumberEntryAlreadyStarted: return presentation(fmt, "kgmcNumberEntryAlreadyStarted", "Number entry already started");
1869 case kgmcCancelledByUser: return presentation(fmt, "kgmcCancelledByUser", "Cancelled by user");
1870 case kgmcNumEntryCouldNotBeStarted: return presentation(fmt, "kgmcNumEntryCouldNotBeStarted", "Number entry could not be started");
1871 case kgmcDataLost: return presentation(fmt, "kgmcDataLost", "Data lost");
1872 case kgmcInvalidBessageBodyLength: return presentation(fmt, "kgmcInvalidBessageBodyLength", "Invalid message body length");
1873 case kgmcInactiveSocket: return presentation(fmt, "kgmcInactiveSocket", "Inactive socket");
1874 case kgmcSocketAlreadyOpen: return presentation(fmt, "kgmcSocketAlreadyOpen", "Socket already open");
1875 #if K3L_AT_LEAST(2,1,0)
1876 case kgmcSuccess: return presentation(fmt, "kgmcSuccess", "Success");
1877 #endif
1878 }
1879
1880 throw internal_not_found();
1881 }
1882
gsmSmsCause(const KGsmSmsCause code,const Verbose::Presentation fmt)1883 std::string Verbose::gsmSmsCause(const KGsmSmsCause code, const Verbose::Presentation fmt)
1884 {
1885 try
1886 {
1887 return internal_gsmSmsCause(code, fmt);
1888 }
1889 catch (internal_not_found e)
1890 {
1891 PRESENTATION_CHECK_RETURN(fmt,
1892 STG(FMT("[KGsmSmsCause='%d']") % (int)code),
1893 STG(FMT("Unknown GSM SMS cause (%d)") % (int)code));
1894 }
1895 }
1896
internal_gsmSmsCause(const KGsmSmsCause code,const Verbose::Presentation fmt)1897 std::string Verbose::internal_gsmSmsCause(const KGsmSmsCause code, const Verbose::Presentation fmt)
1898 {
1899 switch (code)
1900 {
1901 #if K3L_AT_LEAST(2,1,0)
1902 case kgscNone: return presentation(fmt, "kgscNone", "None");
1903 #endif
1904 case kgscUnassigned: return presentation(fmt, "kgscUnassigned", "Unassigned number");
1905 case kgscOperatorDeterminedBarring: return presentation(fmt, "kgscOperatorDeterminedBarring", "Operator determined barring");
1906 case kgscCallBarred: return presentation(fmt, "kgscCallBarred", "Call barred");
1907 case kgscSMSTransferRejected: return presentation(fmt, "kgscSMSTransferRejected", "SMS transfer rejected");
1908 case kgscDestinationOutOfService: return presentation(fmt, "kgscDestinationOutOfService", "Destination out of service");
1909 case kgscUnidentifiedSubscriber: return presentation(fmt, "kgscUnidentifiedSubscriber", "Unidentified subscriber");
1910 case kgscFacilityRejected: return presentation(fmt, "kgscFacilityRejected", "Facility rejected");
1911 case kgscUnknownSubscriber: return presentation(fmt, "kgscUnknownSubscriber", "Unknown subscriber");
1912 case kgscNetworkOutOfOrder: return presentation(fmt, "kgscNetworkOutOfOrder", "Network out of order");
1913 case kgscTemporaryFailure: return presentation(fmt, "kgscTemporaryFailure", "Temporary failure");
1914 case kgscCongestion: return presentation(fmt, "kgscCongestion", "Congestion");
1915 case kgscResourcesUnavailable: return presentation(fmt, "kgscResourcesUnavailable", "Resources unavailable");
1916 case kgscFacilityNotSubscribed: return presentation(fmt, "kgscFacilityNotSubscribed", "Facility not subscribed");
1917 case kgscFacilityNotImplemented: return presentation(fmt, "kgscFacilityNotImplemented", "Facility not implemented");
1918 case kgscInvalidSMSTransferRefValue: return presentation(fmt, "kgscInvalidSMSTransferRefValue", "Invalid SMS transfer reference value");
1919 case kgscInvalidMessage: return presentation(fmt, "kgscInvalidMessage", "Invalid message");
1920 case kgscInvalidMandatoryInformation: return presentation(fmt, "kgscInvalidMandatoryInformation", "Invalid mandatory information");
1921 case kgscMessageTypeNonExistent: return presentation(fmt, "kgscMessageTypeNonExistent", "Message type non existent");
1922 case kgscMsgNotCompatWithSMProtState: return presentation(fmt, "kgscMsgNotCompatWithSMProtState", "Message not compatible with SMS protection state");
1923 case kgscInformationElementNonExiste: return presentation(fmt, "kgscInformationElementNonExiste", "Information element non existent");
1924 case kgscProtocolError: return presentation(fmt, "kgscProtocolError", "Protocol error");
1925 case kgscInterworking: return presentation(fmt, "kgscInterworking", "Interworking");
1926 case kgscTelematicInterworkingNotSup: return presentation(fmt, "kgscTelematicInterworkingNotSup", "Telematic interworking not supported");
1927 case kgscSMSTypeZeroNotSupported: return presentation(fmt, "kgscSMSTypeZeroNotSupported", "SMS type zero not supported");
1928 case kgscCannotReplaceSMS: return presentation(fmt, "kgscCannotReplaceSMS", "Cannot replace SMS");
1929 case kgscUnspecifiedTPPIDError: return presentation(fmt, "kgscUnspecifiedTPPIDError", "Unspecified TPPID error");
1930 case kgscAlphabetNotSupported: return presentation(fmt, "kgscAlphabetNotSupported", "Alphabet not supported");
1931 case kgscMessageClassNotSupported: return presentation(fmt, "kgscMessageClassNotSupported", "Message class not supported");
1932 case kgscUnspecifiedTPDCSError: return presentation(fmt, "kgscUnspecifiedTPDCSError", "Unspecified TPDCS error");
1933 case kgscCommandCannotBeActioned: return presentation(fmt, "kgscCommandCannotBeActioned", "Command cannot be actioned");
1934 case kgscCommandUnsupported: return presentation(fmt, "kgscCommandUnsupported", "Command unsupported");
1935 case kgscUnspecifiedTPCommandError: return presentation(fmt, "kgscUnspecifiedTPCommandError", "Unspecified TP command error");
1936 case kgscTPDUNotSupported: return presentation(fmt, "kgscTPDUNotSupported", "TPDU not supported");
1937 case kgscSCBusy: return presentation(fmt, "kgscSCBusy", "SC busy");
1938 case kgscNoSCSubscription: return presentation(fmt, "kgscNoSCSubscription", "No SC subscription");
1939 case kgscSCSystemFailure: return presentation(fmt, "kgscSCSystemFailure", "SC system failure");
1940 case kgscInvalidSMEAddress: return presentation(fmt, "kgscInvalidSMEAddress", "Invalid SME address");
1941 case kgscDestinationSMEBarred: return presentation(fmt, "kgscDestinationSMEBarred", "Destination SME barred");
1942 case kgscSMRejectedDuplicateSM: return presentation(fmt, "kgscSMRejectedDuplicateSM", "SM rejected duplicate SM");
1943 case kgscTPVPFNotSupported: return presentation(fmt, "kgscTPVPFNotSupported", "TPVPF not supported");
1944 case kgscTPVPNotSupported: return presentation(fmt, "kgscTPVPNotSupported", "TPVP not supported");
1945 case kgscSIMSMSStorageFull: return presentation(fmt, "kgscSIMSMSStorageFull", "SIM SMS storage full");
1946 case kgscNoSMSStorageCapabilityInSIM: return presentation(fmt, "kgscNoSMSStorageCapabilityInSIM", "No SMS storage capability in SIM");
1947 case kgscErrorInMS: return presentation(fmt, "kgscErrorInMS", "Error in SMS");
1948 case kgscMemoryCapacityExceeded: return presentation(fmt, "kgscMemoryCapacityExceeded", "Memory capatity exceeded");
1949 case kgscSIMDataDownloadError: return presentation(fmt, "kgscSIMDataDownloadError", "SIM data download error");
1950 case kgscUnspecifiedError: return presentation(fmt, "kgscUnspecifiedError", "Unspecified error");
1951 case kgscPhoneFailure: return presentation(fmt, "kgscPhoneFailure", "Phone failure");
1952 case kgscSmsServiceReserved: return presentation(fmt, "kgscSmsServiceReserved", "SMS service reserved");
1953 case kgscOperationNotAllowed: return presentation(fmt, "kgscOperationNotAllowed", "Operation not allowed");
1954 case kgscOperationNotSupported: return presentation(fmt, "kgscOperationNotSupported", "Operation not supported");
1955 case kgscInvalidPDUModeParameter: return presentation(fmt, "kgscInvalidPDUModeParameter", "Invalid PDU mode parameter");
1956 case kgscInvalidTextModeParameter: return presentation(fmt, "kgscInvalidTextModeParameter", "Invalid text mode parameter");
1957 case kgscSIMNotInserted: return presentation(fmt, "kgscSIMNotInserted", "SIM not inserted");
1958 case kgscSIMPINNecessary: return presentation(fmt, "kgscSIMPINNecessary", "SIM PIN necessary");
1959 case kgscPH_SIMPINNecessary: return presentation(fmt, "kgscPH_SIMPINNecessary", "Phone SIM PIN necessary");
1960 case kgscSIMFailure: return presentation(fmt, "kgscSIMFailure", "SIM failure");
1961 case kgscSIMBusy: return presentation(fmt, "kgscSIMBusy", "SIM busy");
1962 case kgscSIMWrong: return presentation(fmt, "kgscSIMWrong", "SIM wrong");
1963 case kgscMemoryFailure: return presentation(fmt, "kgscMemoryFailure", "Memory failure");
1964 case kgscInvalidMemoryIndex: return presentation(fmt, "kgscInvalidMemoryIndex", "Invalid memory index");
1965 case kgscMemoryFull: return presentation(fmt, "kgscMemoryFull", "Memory full");
1966 case kgscSMSCAddressUnknown: return presentation(fmt, "kgscSMSCAddressUnknown", "SMSC address unknown");
1967 case kgscNoNetworkService: return presentation(fmt, "kgscNoNetworkService", "No network service");
1968 case kgscNetworkTimeout: return presentation(fmt, "kgscNetworkTimeout", "Network timeout");
1969 case kgscUnknownError: return presentation(fmt, "kgscUnknownError", "Unknown error");
1970 case kgscNetworkBusy: return presentation(fmt, "kgscNetworkBusy", "Network busy");
1971 case kgscInvalidDestinationAddress: return presentation(fmt, "kgscInvalidDestinationAddress", "Invalid destination address");
1972 case kgscInvalidMessageBodyLength: return presentation(fmt, "kgscInvalidMessageBodyLength", "Invalid message body length");
1973 case kgscPhoneIsNotInService: return presentation(fmt, "kgscPhoneIsNotInService", "Phone is not in service");
1974 case kgscInvalidPreferredMemStorage: return presentation(fmt, "kgscInvalidPreferredMemStorage", "Invalid preferred memory storage");
1975 case kgscUserTerminated: return presentation(fmt, "kgscUserTerminated", "User terminated");
1976 }
1977
1978 throw internal_not_found();
1979 }
1980
q931ProgressIndication(const KQ931ProgressIndication code,const Verbose::Presentation fmt)1981 std::string Verbose::q931ProgressIndication(const KQ931ProgressIndication code, const Verbose::Presentation fmt)
1982 {
1983 try
1984 {
1985 return internal_q931ProgressIndication(code);
1986 }
1987 catch (internal_not_found e)
1988 {
1989 PRESENTATION_CHECK_RETURN(fmt,
1990 STG(FMT("[KQ931ProgressIndication='%d']") % (int)code),
1991 STG(FMT("Unknown Q931 progress indication (%d)") % (int)code));
1992 }
1993 }
1994
internal_q931ProgressIndication(const KQ931ProgressIndication code,const Verbose::Presentation fmt)1995 std::string Verbose::internal_q931ProgressIndication(const KQ931ProgressIndication code, const Verbose::Presentation fmt)
1996 {
1997 switch (code)
1998 {
1999 case kq931pTonesMaybeAvailable: return presentation(fmt, "kq931pTonesMaybeAvailable", "Tones may be available");
2000 case kq931pDestinationIsNonIsdn: return presentation(fmt, "kq931pDestinationIsNonIsdn", "Destination is not ISDN");
2001 case kq931pOriginationIsNonIsdn: return presentation(fmt, "kq931pOriginationIsNonIsdn", "Origination is not ISDN");
2002 case kq931pCallReturnedToIsdn: return presentation(fmt, "kq931pCallReturnedToIsdn", "Call returned to ISDN");
2003 case kq931pTonesAvailable: return presentation(fmt, "kq931pTonesAvailable", "Tones available");
2004 }
2005
2006 throw internal_not_found();
2007 }
2008
2009 #endif /* K3L_AT_LEAST(1,6,0) */
2010
2011
2012
2013
2014 #if K3L_AT_LEAST(2,1,0)
faxResult(const KFaxResult code,const Verbose::Presentation fmt)2015 std::string Verbose::faxResult(const KFaxResult code, const Verbose::Presentation fmt)
2016 {
2017 switch (code)
2018 {
2019 case kfaxrEndOfTransmission: return presentation(fmt, "kfaxrEndOfTransmission", "EndOfTransmission");
2020 case kfaxrStoppedByCommand: return presentation(fmt, "kfaxrStoppedByCommand", "StoppedByCommand");
2021 case kfaxrProtocolTimeout: return presentation(fmt, "kfaxrProtocolTimeout", "ProtocolTimeout");
2022 case kfaxrProtocolError: return presentation(fmt, "kfaxrProtocolError", "ProtocolError");
2023 case kfaxrRemoteDisconnection: return presentation(fmt, "kfaxrRemoteDisconnection", "RemoteDisconnection");
2024 case kfaxrFileError: return presentation(fmt, "kfaxrFileError", "FileError");
2025 case kfaxrUnknown: return presentation(fmt, "kfaxrUnknown", "Unknown");
2026 case kfaxrEndOfReception: return presentation(fmt, "kfaxrEndOfReception", "EndOfReception");
2027 case kfaxrCompatibilityError: return presentation(fmt, "kfaxrCompatibilityError", "CompatibilityError");
2028 case kfaxrQualityError: return presentation(fmt, "kfaxrQualityError", "QualityError");
2029 }
2030
2031 PRESENTATION_CHECK_RETURN(fmt,
2032 STG(FMT("[KFaxResult='%d']") % (int)code),
2033 STG(FMT("Unknown fax result (%d)") % (int)code));
2034 }
2035
faxFileErrorCause(const KFaxFileErrorCause code,const Verbose::Presentation fmt)2036 std::string Verbose::faxFileErrorCause(const KFaxFileErrorCause code, const Verbose::Presentation fmt)
2037 {
2038 switch (code)
2039 {
2040 case kfaxfecTransmissionStopped: return presentation(fmt, "kfaxfecTransmissionStopped", "TransmissionStopped");
2041 case kfaxfecTransmissionError: return presentation(fmt, "kfaxfecTransmissionError", "TransmissionError");
2042 case kfaxfecListCleared: return presentation(fmt, "kfaxfecListCleared", "ListCleared");
2043 case kfaxfecCouldNotOpen: return presentation(fmt, "kfaxfecCouldNotOpen", "CouldNotOpen");
2044 case kfaxfecInvalidHeader: return presentation(fmt, "kfaxfecInvalidHeader", "InvalidHeader");
2045 case kfaxfecDataNotFound: return presentation(fmt, "kfaxfecDataNotFound", "DataNotFound");
2046 case kfaxfecInvalidHeight: return presentation(fmt, "kfaxfecInvalidHeight", "InvalidHeight");
2047 case kfaxfecUnsupportedWidth: return presentation(fmt, "kfaxfecUnsupportedWidth", "UnsupportedWidth");
2048 case kfaxfecUnsupportedCompression: return presentation(fmt, "kfaxfecUnsupportedCompression", "UnsupportedCompression");
2049 case kfaxfecUnsupportedRowsPerStrip: return presentation(fmt, "kfaxfecUnsupportedRowsPerStrip", "UnsupportedRowsPerStrip");
2050 case kfaxfecUnknown: return presentation(fmt, "kfaxfecUnknown", "Unknown");
2051 }
2052
2053 PRESENTATION_CHECK_RETURN(fmt,
2054 STG(FMT("[KFaxFileErrorCause='%d']") % (int)code),
2055 STG(FMT("Unknown fax file error cause (%d)") % (int)code));
2056 }
2057
2058 #endif
2059
2060 /********/
2061
2062 #if K3L_AT_LEAST(2,0,0)
command(const int32 dev,const K3L_COMMAND * const k3lcmd,const R2CountryType r2_country,const Verbose::Presentation fmt)2063 std::string Verbose::command(const int32 dev, const K3L_COMMAND * const k3lcmd, const R2CountryType r2_country, const Verbose::Presentation fmt)
2064 #else
2065 std::string Verbose::command(const int32 dev, const K3L_COMMAND * const k3lcmd, const Verbose::Presentation fmt)
2066 #endif
2067 {
2068 #if K3L_AT_LEAST(2,0,0)
2069 return command(k3lcmd->Cmd, dev, k3lcmd->Object, (const char *) k3lcmd->Params, r2_country, fmt);
2070 #else
2071 return command(k3lcmd->Cmd, dev, k3lcmd->Object, (const char *) k3lcmd->Params, fmt);
2072 #endif
2073 }
2074
2075 #if K3L_AT_LEAST(2,0,0)
command(const int32 cmd_code,const int32 dev_idx,const int32 obj_idx,const char * const params,const R2CountryType r2_country,const Verbose::Presentation fmt)2076 std::string Verbose::command(const int32 cmd_code, const int32 dev_idx, const int32 obj_idx, const char * const params, const R2CountryType r2_country, const Verbose::Presentation fmt)
2077 #else
2078 std::string Verbose::command(const int32 cmd_code, const int32 dev_idx, const int32 obj_idx, const char * const params, const Verbose::Presentation fmt)
2079 #endif
2080 {
2081 unsigned short int dev = (unsigned short int) dev_idx;
2082 unsigned short int obj = (unsigned short int) obj_idx;
2083
2084 VerboseTraits::Command code = (VerboseTraits::Command) cmd_code;
2085
2086 std::string buf, extra;
2087
2088 switch (code)
2089 {
2090 case VerboseTraits::K_CM_SEIZE:
2091 case VerboseTraits::K_CM_SYNC_SEIZE:
2092 case VerboseTraits::K_CM_VOIP_SEIZE:
2093 case VerboseTraits::K_CM_DIAL_MFC:
2094 case VerboseTraits::K_CM_DIAL_DTMF:
2095
2096 case VerboseTraits::K_CM_CONNECT:
2097 case VerboseTraits::K_CM_PRE_CONNECT:
2098 case VerboseTraits::K_CM_DISCONNECT:
2099 case VerboseTraits::K_CM_DROP_COLLECT_CALL:
2100
2101 case VerboseTraits::K_CM_START_SEND_FAIL:
2102 case VerboseTraits::K_CM_STOP_SEND_FAIL:
2103
2104 case VerboseTraits::K_CM_ENABLE_DTMF_SUPPRESSION:
2105 case VerboseTraits::K_CM_DISABLE_DTMF_SUPPRESSION:
2106 case VerboseTraits::K_CM_ENABLE_AUDIO_EVENTS:
2107 case VerboseTraits::K_CM_DISABLE_AUDIO_EVENTS:
2108 case VerboseTraits::K_CM_ENABLE_CALL_PROGRESS:
2109 case VerboseTraits::K_CM_DISABLE_CALL_PROGRESS:
2110 case VerboseTraits::K_CM_ENABLE_PULSE_DETECTION:
2111 case VerboseTraits::K_CM_DISABLE_PULSE_DETECTION:
2112 case VerboseTraits::K_CM_ENABLE_ECHO_CANCELLER:
2113 case VerboseTraits::K_CM_DISABLE_ECHO_CANCELLER:
2114 case VerboseTraits::K_CM_ENABLE_AGC:
2115 case VerboseTraits::K_CM_DISABLE_AGC:
2116 case VerboseTraits::K_CM_ENABLE_HIGH_IMP_EVENTS:
2117 case VerboseTraits::K_CM_DISABLE_HIGH_IMP_EVENTS:
2118
2119 case VerboseTraits::K_CM_FLASH:
2120 case VerboseTraits::K_CM_RESET_LINK:
2121 case VerboseTraits::K_CM_CLEAR_MIXER:
2122
2123 case VerboseTraits::K_CM_LOCK_INCOMING:
2124 case VerboseTraits::K_CM_UNLOCK_INCOMING:
2125 case VerboseTraits::K_CM_LOCK_OUTGOING:
2126 case VerboseTraits::K_CM_UNLOCK_OUTGOING:
2127
2128 case VerboseTraits::K_CM_INCREASE_VOLUME:
2129 case VerboseTraits::K_CM_DECREASE_VOLUME:
2130
2131 case VerboseTraits::K_CM_STOP_RECORD:
2132 case VerboseTraits::K_CM_PAUSE_RECORD:
2133 case VerboseTraits::K_CM_RESUME_RECORD:
2134
2135 case VerboseTraits::K_CM_STOP_LISTEN:
2136
2137 case VerboseTraits::K_CM_PLAY_SOUND_CARD:
2138 case VerboseTraits::K_CM_STOP_SOUND_CARD:
2139 case VerboseTraits::K_CM_RINGBACK:
2140 #if K3L_AT_LEAST(1,4,0) && !K3L_AT_LEAST(2,0,0)
2141 case VerboseTraits::K_CM_VOIP_START_DEBUG:
2142 case VerboseTraits::K_CM_VOIP_STOP_DEBUG:
2143 case VerboseTraits::K_CM_VOIP_DUMP_STAT:
2144 #endif
2145
2146 #if K3L_AT_LEAST(1,5,3)
2147 case VerboseTraits::K_CM_END_OF_NUMBER:
2148 #endif
2149
2150 #if K3L_AT_LEAST(1,5,4)
2151 case VerboseTraits::K_CM_SET_VOLUME:
2152 #endif
2153
2154 #if K3L_AT_LEAST(1,6,0)
2155 case VerboseTraits::K_CM_ENABLE_CALL_ANSWER_INFO:
2156 case VerboseTraits::K_CM_DISABLE_CALL_ANSWER_INFO:
2157
2158 case VerboseTraits::K_CM_SS_TRANSFER:
2159
2160 case VerboseTraits::K_CM_CHECK_NEW_SMS:
2161 case VerboseTraits::K_CM_GET_SMS:
2162 case VerboseTraits::K_CM_PREPARE_SMS:
2163 case VerboseTraits::K_CM_SEND_SMS:
2164
2165 case VerboseTraits::K_CM_START_CADENCE:
2166 case VerboseTraits::K_CM_STOP_CADENCE:
2167 case VerboseTraits::K_CM_SEND_TO_MODEM:
2168 #endif
2169 #if K3L_HAS_MPTY_SUPPORT
2170 case VerboseTraits::K_CM_HOLD_SWITCH:
2171 case VerboseTraits::K_CM_MPTY_CONF:
2172 case VerboseTraits::K_CM_MPTY_SPLIT:
2173 #endif
2174 #if K3L_AT_LEAST(2,1,0)
2175 case VerboseTraits::K_CM_SIM_CARD_SELECT:
2176 case VerboseTraits::K_CM_CT_TRANSFER:
2177 #endif
2178 if (params != NULL)
2179 {
2180 extra += "param='";
2181 extra += (params ? params : "<empty>");
2182 extra += "'";
2183
2184 return show(buf, commandName(code), Target(CHANNEL, dev, obj), extra);
2185 }
2186 else
2187 {
2188 return show(buf, commandName(code), Target(CHANNEL, dev, obj));
2189 }
2190
2191 case VerboseTraits::K_CM_SEND_DTMF: /* ?? */
2192 return show(buf, commandName(code), Target(CHANNEL, dev, obj));
2193
2194 /****/
2195
2196 case VerboseTraits::K_CM_STOP_AUDIO:
2197 extra = "stop='";
2198 switch ((params ? (int)(*params) : -1))
2199 {
2200 case 1: extra += "tx";
2201 case 2: extra += "rx";
2202 case 3: extra += "tx+rx";
2203 default: extra += "<unknown>";
2204 }
2205 extra = "'";
2206
2207 return show(buf, commandName(code), Target(CHANNEL, dev, obj), extra);
2208
2209 /****/
2210
2211 #if K3L_AT_LEAST(1,5,2) && !K3L_AT_LEAST(2,0,0)
2212 case VerboseTraits::K_CM_ISDN_DEBUG:
2213 extra = "flags='";
2214 extra += isdnDebug((unsigned long)params);
2215 extra += "'";
2216
2217 return show(buf, commandName(code), Target(NONE), extra);
2218 #endif
2219
2220 /****/
2221
2222 #if K3L_AT_LEAST(1,5,1)
2223 case VerboseTraits::K_CM_USER_INFORMATION:
2224 #endif
2225 if (params != NULL)
2226 {
2227 KUserInformation * userinfo = (KUserInformation *)params;
2228
2229 std::string tmp((const char*) userinfo->UserInfo, userinfo->UserInfoLength);
2230
2231 extra = STG(FMT("proto='%d',length='%d',data='%s'")
2232 % userinfo->ProtocolDescriptor % userinfo->UserInfoLength % tmp);
2233
2234 return show(buf, commandName(code), Target(CHANNEL, dev, obj), extra);
2235 }
2236 else
2237 {
2238 return show(buf, commandName(code), Target(CHANNEL, dev, obj));
2239 }
2240
2241 /****/
2242
2243
2244
2245 case VerboseTraits::K_CM_CAS_CHANGE_LINE_STT:
2246 {
2247 const char status = (params ? *params : 0x00);
2248
2249 extra += "status='";
2250 extra += (status & 0x01 ? "1" : "0");
2251 extra += (status & 0x02 ? "1" : "0");
2252 extra += (status & 0x04 ? "1" : "0");
2253 extra += (status & 0x08 ? "1" : "0");
2254 extra += "'";
2255
2256 return show(buf, commandName(code), Target(CHANNEL, dev, obj), extra);
2257 }
2258
2259 case VerboseTraits::K_CM_CAS_SEND_MFC:
2260 {
2261 char mfc = (params ? *params : 0xff);
2262
2263 extra = STG(FMT("mfc='%d'") % (int) mfc);
2264
2265 return show(buf, commandName(code), Target(CHANNEL, dev, obj), extra);
2266 }
2267
2268 case VerboseTraits::K_CM_CAS_SET_MFC_DETECT_MODE:
2269 {
2270 int mode = (params ? *((int *)params) : -1);
2271
2272 extra = STG(FMT("mode='%d'") % mode);
2273
2274 return show(buf, commandName(code), Target(CHANNEL, dev, obj), extra);
2275 }
2276
2277 case VerboseTraits::K_CM_SET_FORWARD_CHANNEL:
2278 {
2279 int channel = (params ? *((int*) params) : -1);
2280
2281 extra = STG(FMT("forward='%03d'") % channel);
2282
2283 return show(buf, commandName(code), Target(CHANNEL, dev, obj), extra);
2284 }
2285
2286 #if K3L_AT_LEAST(1,5,0)
2287 case VerboseTraits::K_CM_MAKE_CALL:
2288 extra = "options='";
2289 extra += (params ? params : "<empty>");
2290 extra += "'";
2291
2292 return show(buf, commandName(code), Target(CHANNEL, dev, obj), extra);
2293 #endif
2294
2295 case VerboseTraits::K_CM_MIXER:
2296 case VerboseTraits::K_CM_MIXER_CTBUS:
2297 {
2298 if (params)
2299 {
2300 KMixerCommand *m = (KMixerCommand*)params;
2301
2302 std::string src = mixerSource((KMixerSource)m->Source);
2303 std::string idx("<unknown>");
2304
2305 switch (m->Source)
2306 {
2307 case kmsChannel:
2308 case kmsPlay:
2309 case kmsCTbus:
2310 #if (K3L_AT_LEAST(1,4,0) && !K3L_AT_LEAST(1,6,0))
2311 case kmsVoIP:
2312 #endif
2313 #if K3L_AT_LEAST(1,6,0)
2314 case kmsNoDelayChannel:
2315 #endif
2316 idx = STG(FMT("%02d") % (int)m->SourceIndex);
2317 break;
2318
2319 case kmsGenerator:
2320 idx = mixerTone((KMixerTone)m->SourceIndex);
2321 break;
2322 };
2323
2324 extra = STG(FMT("track='%d',src='%s',index='%s'") % (int)m->Track % src % idx);
2325 }
2326 else
2327 {
2328 extra = "<unknown>";
2329 }
2330
2331 return show(buf, commandName(code), Target(MIXER, dev, obj), extra);
2332 };
2333
2334 case VerboseTraits::K_CM_PLAY_FROM_FILE:
2335 extra = "file='";
2336 extra += (params ? params : "<empty>");
2337 extra += "'";
2338
2339 return show(buf, commandName(code), Target(PLAYER, dev, obj), extra);
2340
2341 case VerboseTraits::K_CM_RECORD_TO_FILE:
2342 extra = "file='";
2343 extra += (params ? params : "<empty>");
2344 extra += "'";
2345
2346 return show(buf, commandName(code), Target(PLAYER, dev, obj), extra);
2347
2348 case VerboseTraits::K_CM_RECORD_TO_FILE_EX:
2349 extra = "params='";
2350 extra += (params ? params : "<empty>");
2351 extra += "'";
2352
2353 return show(buf, commandName(code), Target(PLAYER, dev, obj), extra);
2354
2355 case VerboseTraits::K_CM_PLAY_FROM_STREAM:
2356 case VerboseTraits::K_CM_ADD_STREAM_BUFFER:
2357 {
2358 struct buffer_param
2359 {
2360 const void * ptr;
2361 const int size;
2362 }
2363 *p = (buffer_param *) params;
2364
2365 std::stringstream stream;
2366
2367 extra = STG(FMT("buffer='%p',size='%d'")
2368 % (const void *) p->ptr % (const int) p->size);
2369
2370 return show(buf, commandName(code), Target(PLAYER, dev, obj), extra);
2371 }
2372
2373 case VerboseTraits::K_CM_PLAY_FROM_STREAM_EX:
2374 {
2375 struct buffer_param
2376 {
2377 const void * ptr;
2378 const int size;
2379 const char codec;
2380 }
2381 *p = (buffer_param *) params;
2382
2383 std::string codec;
2384
2385 switch (p->codec)
2386 {
2387 case 0: codec = "A-Law";
2388 case 1: codec = "PCM-08khz";
2389 case 2: codec = "PCM-11khz";
2390 default: codec = "<unknown>";
2391 }
2392
2393 std::stringstream stream;
2394
2395 extra = STG(FMT("buffer='%p',size='%d',codec='%s'")
2396 % (const void *) p->ptr % (const int) p->size % codec);
2397
2398 return show(buf, commandName(code), Target(PLAYER, dev, obj), extra);
2399 }
2400
2401 case VerboseTraits::K_CM_STOP_PLAY:
2402 case VerboseTraits::K_CM_PAUSE_PLAY:
2403 case VerboseTraits::K_CM_RESUME_PLAY:
2404
2405 case VerboseTraits::K_CM_START_STREAM_BUFFER:
2406 case VerboseTraits::K_CM_STOP_STREAM_BUFFER:
2407
2408 case VerboseTraits::K_CM_ENABLE_PLAYER_AGC:
2409 case VerboseTraits::K_CM_DISABLE_PLAYER_AGC:
2410
2411 case VerboseTraits::K_CM_SEND_BEEP:
2412 case VerboseTraits::K_CM_SEND_BEEP_CONF:
2413
2414 case VerboseTraits::K_CM_INTERNAL_PLAY:
2415 case VerboseTraits::K_CM_INTERNAL_PLAY_EX:
2416 return show(buf, commandName(code), Target(PLAYER, dev, obj));
2417
2418 case VerboseTraits::K_CM_ADD_TO_CONF:
2419 extra += "conference='";
2420 extra += (params ? (int) (*params) : -1);
2421 extra += "'";
2422
2423 return show(buf, commandName(code), Target(MIXER, dev, obj), extra);
2424
2425 case CM_REMOVE_FROM_CONF:
2426 return show(buf, commandName(code), Target(MIXER, dev, obj));
2427
2428 case VerboseTraits::K_CM_LISTEN:
2429 case VerboseTraits::K_CM_PREPARE_FOR_LISTEN:
2430 {
2431 int msecs = (params ? *((int*)params) : -1);
2432
2433 extra = STG(FMT("msecs='%d'") % msecs);
2434
2435 return show(buf, commandName(code), Target(PLAYER, dev, obj), extra);
2436 }
2437
2438 case VerboseTraits::K_CM_SEND_TO_CTBUS:
2439 case VerboseTraits::K_CM_RECV_FROM_CTBUS:
2440 {
2441 KCtbusCommand *p = (KCtbusCommand*)(params);
2442
2443 extra = STG(FMT("stream='%02d',timeslot='%02d',enable='%d'")
2444 % (int)p->Stream % (int)p->TimeSlot % (int)p->Enable);
2445
2446 return show(buf, commandName(code), Target(CHANNEL, dev, obj), extra);
2447 }
2448
2449 case VerboseTraits::K_CM_SET_LINE_CONDITION:
2450 case VerboseTraits::K_CM_SEND_LINE_CONDITION:
2451 extra = "condition='";
2452 #if K3L_AT_LEAST(2,0,0)
2453 extra += signGroupB((KSignGroupB) *((int *) params), r2_country);
2454 #else
2455 extra += signGroupB((KSignGroupB) *((int *) params));
2456 #endif
2457 extra += "'";
2458
2459 return show(buf, commandName(code), Target(CHANNEL, dev, obj), extra);
2460
2461 case VerboseTraits::K_CM_SET_CALLER_CATEGORY:
2462 extra = "category='";
2463 #if K3L_AT_LEAST(2,0,0)
2464 extra += signGroupII((KSignGroupII) *((int *) params), r2_country);
2465 #else
2466 extra += signGroupII((KSignGroupII) *((int *) params));
2467 #endif
2468 extra += "'";
2469
2470 return show(buf, commandName(code), Target(CHANNEL, dev, obj), extra);
2471
2472 #if K3L_AT_LEAST(1,6,0)
2473 case VerboseTraits::K_CM_CLEAR_LINK_ERROR_COUNTER:
2474 return show(buf, commandName(code), Target(LINK, dev, obj));
2475
2476 case VerboseTraits::K_CM_SIP_REGISTER:
2477 if (params != NULL)
2478 {
2479 extra += "param='";
2480 extra += (params ? params : "<empty>");
2481 extra += "'";
2482
2483 return show(buf, commandName(code), Target(DEVICE, dev), extra);
2484 }
2485 else
2486 {
2487 return show(buf, commandName(code), Target(DEVICE, dev));
2488 }
2489 #endif
2490
2491 case VerboseTraits::K_CM_SETUP_H100:
2492 extra += "option='";
2493 extra += h100configIndex((KH100ConfigIndex)obj_idx);
2494 extra += "'value='";
2495 extra += (params ? STG(FMT("%02d") % (int)(*params)) : "<empty>");
2496 extra += "'";
2497
2498 return show(buf, commandName(code), Target(DEVICE, dev), extra);
2499
2500 case VerboseTraits::K_CM_HARD_RESET:
2501 return show(buf, commandName(code), Target(LINK, dev, obj));
2502
2503 #if !K3L_AT_LEAST(2,0,0)
2504 /* como funciona? */
2505 case VerboseTraits::K_CM_LOG_REQUEST:
2506 case VerboseTraits::K_CM_LOG_CREATE_DISPATCHER:
2507 case VerboseTraits::K_CM_LOG_DESTROY_DISPATCHER:
2508 case VerboseTraits::K_CM_PING:
2509 #endif
2510 //#if K3L_AT_LEAST(2,1,0)
2511 // case VerboseTraits::K_CM_LOG_UPDATE:
2512 //#endif
2513 return show(buf, commandName(code), Target(NONE));
2514 #if K3L_AT_LEAST(2,1,0)
2515 case VerboseTraits::K_CM_START_FAX_TX:
2516 case VerboseTraits::K_CM_START_FAX_RX:
2517 case VerboseTraits::K_CM_ADD_FAX_FILE:
2518 extra = "params='";
2519 extra += (params ? params : "<empty>");
2520 extra += "'";
2521 return show(buf, commandName(code), Target(CHANNEL, dev, obj), extra);
2522 case VerboseTraits::K_CM_STOP_FAX_TX:
2523 case VerboseTraits::K_CM_STOP_FAX_RX:
2524 case VerboseTraits::K_CM_ADD_FAX_PAGE_BREAK:
2525 return show(buf, commandName(code), Target(CHANNEL, dev, obj));
2526 #endif
2527
2528 #if K3L_AT_LEAST(2,1,0)
2529 case VerboseTraits::K_CM_NOTIFY_WATCHDOG:
2530 case VerboseTraits::K_CM_STOP_WATCHDOG:
2531 case VerboseTraits::K_CM_START_WATCHDOG:
2532 return show(buf, commandName(code) , Target(DEVICE, obj));
2533 case VerboseTraits::K_CM_WATCHDOG_COUNT:
2534 return show(buf, commandName(code) , Target(NONE));
2535 #endif
2536
2537 }
2538
2539 /* default command handler */
2540 return show(buf, commandName(code), Target(CHANNEL, dev, obj));
2541 }
2542
2543 #if K3L_AT_LEAST(2,0,0)
event(const KSignaling sig,const int32 obj_idx,const K3L_EVENT * const ev,const R2CountryType r2_country,const Verbose::Presentation fmt)2544 std::string Verbose::event(const KSignaling sig, const int32 obj_idx, const K3L_EVENT * const ev, const R2CountryType r2_country, const Verbose::Presentation fmt)
2545 #else
2546 std::string Verbose::event(const KSignaling sig, const int32 obj_idx, const K3L_EVENT * const ev, const Verbose::Presentation fmt)
2547 #endif
2548 {
2549 unsigned short int dev = (unsigned short int) ev->DeviceId;
2550 unsigned short int obj = (unsigned short int) obj_idx;
2551
2552 VerboseTraits::Event code = (VerboseTraits::Event) ev->Code;
2553
2554 std::string buf;
2555 std::string extra;
2556
2557 switch (code)
2558 {
2559 case VerboseTraits::VerboseTraits::K_EV_CHANNEL_FREE:
2560 case VerboseTraits::VerboseTraits::K_EV_SEIZE_SUCCESS:
2561 case VerboseTraits::VerboseTraits::K_EV_CALL_SUCCESS:
2562 case VerboseTraits::VerboseTraits::K_EV_NO_ANSWER:
2563 case VerboseTraits::VerboseTraits::K_EV_CONNECT:
2564 case VerboseTraits::VerboseTraits::K_EV_DTMF_SEND_FINISH:
2565 case VerboseTraits::VerboseTraits::K_EV_SEIZURE_START:
2566 case VerboseTraits::VerboseTraits::K_EV_BILLING_PULSE:
2567 case VerboseTraits::VerboseTraits::K_EV_REFERENCE_FAIL:
2568
2569 #if K3L_AT_LEAST(1,4,0)
2570 case VerboseTraits::VerboseTraits::K_EV_CALL_HOLD_START:
2571 case VerboseTraits::VerboseTraits::K_EV_CALL_HOLD_STOP:
2572 #endif
2573
2574 #if K3L_AT_LEAST(1,5,0)
2575 case VerboseTraits::VerboseTraits::K_EV_NEW_CALL:
2576 #endif
2577
2578 #if K3L_AT_LEAST(1,6,0)
2579 case VerboseTraits::VerboseTraits::K_EV_FLASH:
2580 case VerboseTraits::VerboseTraits::K_EV_POLARITY_REVERSAL:
2581 case VerboseTraits::VerboseTraits::K_EV_COLLECT_CALL:
2582 case VerboseTraits::VerboseTraits::K_EV_RING_DETECTED:
2583 case VerboseTraits::VerboseTraits::K_EV_SS_TRANSFER_FAIL:
2584 #endif
2585 #if K3L_HAS_MPTY_SUPPORT
2586 case VerboseTraits::VerboseTraits::K_EV_CALL_MPTY_START:
2587 case VerboseTraits::VerboseTraits::K_EV_CALL_MPTY_STOP:
2588 #endif
2589 break;
2590
2591 #if K3L_AT_LEAST(1,6,0)
2592 case VerboseTraits::VerboseTraits::K_EV_RECV_FROM_MODEM:
2593 case VerboseTraits::VerboseTraits::K_EV_SMS_INFO:
2594 case VerboseTraits::VerboseTraits::K_EV_SMS_DATA:
2595 #endif
2596 extra = "data='";
2597 extra += (ev->Params ? (const char *)(ev->Params) : "<empty>");
2598 extra += "'";
2599
2600 return show(buf, eventName(code), Target(CHANNEL, dev, obj), extra);
2601
2602 #if K3L_AT_LEAST(1,6,0)
2603 case VerboseTraits::VerboseTraits::K_EV_SMS_SEND_RESULT:
2604 extra = "result='";
2605 #if K3L_AT_LEAST(2,0,0)
2606 extra += gsmSmsCause((KGsmSmsCause)ev->AddInfo);
2607 #else
2608 extra += gsmCallCause((KGsmCallCause)ev->AddInfo);
2609 #endif
2610 extra += "'";
2611 return show(buf, eventName(code), Target(CHANNEL, dev, obj), extra);
2612
2613 #if K3L_HAS_MPTY_SUPPORT
2614 case VerboseTraits::VerboseTraits::K_EV_GSM_COMMAND_STATUS:
2615 extra = "result='";
2616 extra += gsmMobileCause((KGsmMobileCause)ev->AddInfo);
2617 extra += "'";
2618 return show(buf, eventName(code), Target(CHANNEL, dev, obj), extra);
2619 #endif
2620
2621 case VerboseTraits::VerboseTraits::K_EV_CALL_ANSWER_INFO:
2622 extra = "info='";
2623 extra += callStartInfo((KCallStartInfo)ev->AddInfo);
2624 extra += "'";
2625 return show(buf, eventName(code), Target(CHANNEL, dev, obj), extra);
2626
2627 case VerboseTraits::VerboseTraits::K_EV_NEW_SMS:
2628 if (ev->AddInfo != 0)
2629 {
2630 extra = "messages='";
2631 extra += STG(FMT("%d") % ev->AddInfo);
2632 extra += "'";
2633 return show(buf, eventName(code), Target(CHANNEL, dev, obj), extra);
2634 }
2635 else
2636 {
2637 return show(buf, eventName(code), Target(CHANNEL, dev, obj));
2638 }
2639
2640 case VerboseTraits::VerboseTraits::K_EV_ISDN_PROGRESS_INDICATOR:
2641 if (ev->AddInfo != 0)
2642 {
2643 extra = "indication='";
2644 extra += q931ProgressIndication((KQ931ProgressIndication)ev->AddInfo);
2645 extra += "'";
2646 return show(buf, eventName(code), Target(CHANNEL, dev, obj), extra);
2647 }
2648 else
2649 {
2650 return show(buf, eventName(code), Target(CHANNEL, dev, obj));
2651 }
2652 #endif
2653
2654 case VerboseTraits::VerboseTraits::K_EV_CAS_LINE_STT_CHANGED:
2655 extra = STG(FMT("[a=%d,b=%d,c=%d,d=%d]")
2656 % ((ev->AddInfo & 0x8) >> 3) % ((ev->AddInfo & 0x4) >> 2)
2657 % ((ev->AddInfo & 0x2) >> 1) % (ev->AddInfo & 0x1));
2658
2659 return show(buf, eventName(code), Target(CHANNEL, dev, obj), extra);
2660
2661 case VerboseTraits::VerboseTraits::K_EV_CAS_MFC_RECV:
2662 extra = STG(FMT("digit='%d'") % ev->AddInfo);
2663
2664 return show(buf, eventName(code), Target(CHANNEL, dev, obj), extra);
2665
2666 case VerboseTraits::VerboseTraits::K_EV_CALL_FAIL:
2667 extra = "cause='";
2668 #if K3L_AT_LEAST(2,0,0)
2669 extra += callFail(sig, r2_country, ev->AddInfo);
2670 #else
2671 extra += callFail(sig, ev->AddInfo);
2672 #endif
2673 extra += "'";
2674
2675 if (ev->Params != NULL && ev->ParamSize != 0)
2676 {
2677 if (!extra.empty())
2678 extra += ",";
2679
2680 extra += "params='";
2681 extra += (const char *) ev->Params;
2682 extra += "'";
2683 }
2684
2685 return show(buf, eventName(code), Target(CHANNEL, dev, obj), extra);
2686
2687 case VerboseTraits::VerboseTraits::K_EV_DISCONNECT:
2688 switch (sig)
2689 {
2690 #if K3L_AT_LEAST(1,5,1)
2691 case ksigOpenCCS:
2692 case ksigPRI_EndPoint:
2693 case ksigPRI_Network:
2694 case ksigPRI_Passive:
2695 extra = "cause='";
2696 extra += isdnCause((KQ931Cause) ev->AddInfo);
2697 extra += "'";
2698 #endif
2699 default:
2700 break;
2701 }
2702
2703 if (ev->Params != NULL && ev->ParamSize != 0)
2704 {
2705 if (!extra.empty())
2706 extra += ",";
2707
2708 extra += "params='";
2709 extra += (const char *) ev->Params;
2710 extra += "'";
2711 }
2712
2713 if (!extra.empty())
2714 return show(buf, eventName(code), Target(CHANNEL, dev, obj), extra);
2715 else
2716 return show(buf, eventName(code), Target(CHANNEL, dev, obj));
2717
2718 break;
2719
2720 #if K3L_AT_LEAST(1,6,0)
2721 case VerboseTraits::VerboseTraits::K_EV_SIP_DTMF_DETECTED:
2722 #endif
2723 case VerboseTraits::VerboseTraits::K_EV_DTMF_DETECTED:
2724 case VerboseTraits::VerboseTraits::K_EV_PULSE_DETECTED:
2725 case VerboseTraits::VerboseTraits::K_EV_DIALED_DIGIT:
2726 extra = STG(FMT("digit='%c'") % (char)ev->AddInfo);
2727
2728 return show(buf, eventName(code), Target(CHANNEL, dev, obj), extra);
2729
2730 case VerboseTraits::VerboseTraits::K_EV_SEIZURE:
2731 {
2732 KIncomingSeizeParams *n = (KIncomingSeizeParams *)
2733 ( ((char*)ev) + sizeof(K3L_EVENT) );
2734
2735 extra += "orig_addr='";
2736 extra += n->NumberA;
2737 extra += "',dest_addr='";
2738 extra += n->NumberB;
2739 extra += "'";
2740
2741 return show(buf, eventName(code), Target(CHANNEL, dev, obj), extra);
2742 }
2743
2744 #if K3L_AT_LEAST(1,4,0)
2745 case VerboseTraits::VerboseTraits::K_EV_VOIP_SEIZURE:
2746 {
2747 char *numB = ((char*)ev) + sizeof(K3L_EVENT);
2748 char *numA = numB + 61;
2749
2750 extra = "numberA='";
2751 extra += numA;
2752 extra += "',numberB='";
2753 extra += numB;
2754 extra += "'";
2755
2756 return show(buf, eventName(code), Target(CHANNEL, dev, obj), extra);
2757 }
2758 #endif
2759
2760
2761 case VerboseTraits::VerboseTraits::K_EV_END_OF_STREAM:
2762 return show(buf, eventName(code), Target(PLAYER, dev, obj));
2763
2764 case VerboseTraits::VerboseTraits::K_EV_AUDIO_STATUS:
2765 extra = "tone='";
2766 extra += mixerTone((KMixerTone)ev->AddInfo);
2767 extra += "'";
2768
2769 return show(buf, eventName(code), Target(CHANNEL, dev, obj), extra);
2770
2771 case VerboseTraits::VerboseTraits::K_EV_CADENCE_RECOGNIZED:
2772 extra = STG(FMT("cadence='%c'") % (char)(ev->AddInfo));
2773
2774 return show(buf, eventName(code), Target(CHANNEL, dev, obj), extra);
2775
2776 case VerboseTraits::VerboseTraits::K_EV_CHANNEL_FAIL:
2777 extra = "reason='";
2778 extra += channelFail(sig, ev->AddInfo);
2779 extra += "'";
2780
2781 return show(buf, eventName(code), Target(CHANNEL, dev, obj), extra);
2782
2783 case VerboseTraits::VerboseTraits::K_EV_SEIZE_FAIL:
2784 extra = "reason='";
2785 extra += seizeFail((KSeizeFail) ev->AddInfo);
2786 extra += "'";
2787
2788 return show(buf, eventName(code), Target(CHANNEL, dev, obj), extra);
2789
2790 case VerboseTraits::VerboseTraits::K_EV_INTERNAL_FAIL:
2791 extra = "reason='";
2792 extra += internalFail((KInternalFail) ev->AddInfo);
2793 extra += "'";
2794
2795 return show(buf, eventName(code), Target(CHANNEL, dev, obj), extra);
2796
2797 case VerboseTraits::VerboseTraits::K_EV_HARDWARE_FAIL:
2798 extra = "component='";
2799 extra += systemObject((KSystemObject) ev->AddInfo);
2800 extra += "'";
2801
2802 switch (ev->AddInfo)
2803 {
2804 case ksoChannel:
2805 return show(buf, eventName(code), Target(CHANNEL, dev, obj), extra);
2806 case ksoLink:
2807 return show(buf, eventName(code), Target(LINK, dev, obj), extra);
2808 case ksoLinkMon:
2809 case ksoH100:
2810 case ksoFirmware:
2811 case ksoDevice:
2812 return show(buf, eventName(code), Target(DEVICE, dev), extra);
2813 case ksoAPI:
2814 return show(buf, eventName(code), Target(NONE), extra);
2815 }
2816
2817
2818 case VerboseTraits::VerboseTraits::K_EV_LINK_STATUS:
2819 // EV_LINK_STATUS has always zero in ObjectInfo (and AddInfo!)
2820 /* fall throught... */
2821
2822 #if K3L_AT_LEAST(1,6,0)
2823 case VerboseTraits::VerboseTraits::K_EV_PHYSICAL_LINK_UP:
2824 case VerboseTraits::VerboseTraits::K_EV_PHYSICAL_LINK_DOWN:
2825 return show(buf, eventName(code), Target(LINK, dev, obj));
2826 #endif
2827
2828 #if K3L_AT_LEAST(1,5,1)
2829 case VerboseTraits::VerboseTraits::K_EV_USER_INFORMATION:
2830 {
2831 KUserInformation *info = (KUserInformation *)(ev->Params);
2832
2833 std::string data((const char *)info->UserInfo,
2834 std::min<size_t>(info->UserInfoLength, KMAX_USER_USER_LEN));
2835
2836 extra = STG(FMT("proto='%d',length='%d',data='%s'")
2837 % info->ProtocolDescriptor % info->UserInfoLength % data);
2838
2839 return show(buf, eventName(code), Target(CHANNEL, dev, obj), extra);
2840 }
2841 #endif
2842
2843 #if K3L_AT_LEAST(1,6,0)
2844 case VerboseTraits::VerboseTraits::K_EV_SIP_REGISTER_INFO:
2845 extra = "params='";
2846 extra += (ev->Params ? (const char *) (ev->Params) : "<unknown>");
2847 extra += "',status='";
2848 extra += sipFailures((KSIP_Failures)(ev->AddInfo));
2849 extra += "'";
2850
2851 return show(buf, eventName(code), Target(DEVICE, dev), extra);
2852 #endif
2853
2854 #if !K3L_AT_LEAST(2,0,0)
2855 case VerboseTraits::VerboseTraits::K_EV_PONG:
2856 #endif
2857
2858 #if K3L_AT_LEAST(1,4,0)
2859 case VerboseTraits::VerboseTraits::K_EV_CLIENT_RECONNECT:
2860 #endif
2861 return show(buf, eventName(code), Target(NONE));
2862
2863 #if K3L_AT_LEAST(2,1,0)
2864 case VerboseTraits::VerboseTraits::K_EV_FAX_CHANNEL_FREE:
2865 extra = "status='";
2866 extra += faxResult((KFaxResult)ev->AddInfo);
2867 extra += "'";
2868 return show(buf, eventName(code), Target(CHANNEL, dev, obj), extra);
2869
2870 case VerboseTraits::VerboseTraits::K_EV_FAX_FILE_SENT:
2871 extra = "filename='";
2872 extra += (ev->Params ? (const char *) (ev->Params) : "<unknown>");
2873 extra += "'";
2874 return show(buf, eventName(code), Target(CHANNEL, dev, obj), extra);
2875
2876 case VerboseTraits::VerboseTraits::K_EV_FAX_FILE_FAIL:
2877 extra = "cause='";
2878 extra += faxFileErrorCause((KFaxFileErrorCause)ev->AddInfo);
2879 extra += "',filename='";
2880 extra += (ev->Params ? (const char *) (ev->Params) : "<unknown>");
2881 extra += "'";
2882 return show(buf, eventName(code), Target(CHANNEL, dev, obj), extra);
2883
2884 case VerboseTraits::VerboseTraits::K_EV_FAX_REMOTE_INFO:
2885 extra = ((ev->Params && ev->ParamSize != 0) ? (const char *) ev->Params : "");
2886 return show(buf, eventName(code), Target(CHANNEL, dev, obj), extra);
2887
2888 case VerboseTraits::VerboseTraits::K_EV_FAX_PAGE_CONFIRMATION:
2889 case VerboseTraits::VerboseTraits::K_EV_FAX_TX_TIMEOUT:
2890 return show(buf, eventName(code), Target(CHANNEL, dev, obj));
2891 #endif
2892
2893 #if K3L_AT_LEAST(2,1,0)
2894 case VerboseTraits::VerboseTraits::K_EV_WATCHDOG_COUNT:
2895 extra = STG(FMT("count='%d'") % (char)ev->AddInfo);
2896 return show(buf , eventName(code), Target(NONE), extra);
2897 #endif
2898
2899 #if K3L_AT_LEAST(2,1,0)
2900 case VerboseTraits::VerboseTraits::K_EV_CT_TRANSFER_FAIL:
2901 extra = "cause='";
2902 extra += isdnCause((KQ931Cause)ev->AddInfo);
2903 extra += "'";
2904
2905 return show(buf, eventName(code), Target(CHANNEL, dev, obj), extra);
2906 #endif
2907 }
2908
2909 // default handler...
2910 if (ev->Params != NULL && ev->ParamSize != 0)
2911 {
2912 extra += "params='";
2913 extra.append((const char *) ev->Params, (unsigned int) std::max<int>(ev->ParamSize - 1, 0));
2914 extra += "'";
2915
2916 return show(buf, eventName(code), Target(CHANNEL, dev, obj), extra);
2917 }
2918 else
2919 return show(buf, eventName(code), Target(CHANNEL, dev, obj));
2920 }
2921
2922 /********************************************/
2923
show(std::string & buf,const std::string & name,const Target tgt,const std::string & extra)2924 std::string Verbose::show(std::string & buf, const std::string & name, const Target tgt, const std::string & extra)
2925 {
2926 if (tgt.type == NONE)
2927 {
2928 generate(buf, name, tgt, extra);
2929 }
2930 else
2931 {
2932 std::string tmp(",");
2933 tmp += extra;
2934
2935 generate(buf, name, tgt, tmp);
2936 }
2937
2938 return buf;
2939 }
2940
show(std::string & buf,const std::string & name,const Target tgt)2941 std::string Verbose::show(std::string & buf, const std::string & name, const Target tgt)
2942 {
2943 std::string tmp("");
2944
2945 generate(buf, name, tgt, tmp);
2946 return buf;
2947 }
2948
generate(std::string & buf,const std::string & name,const Target tgt,const std::string & extra)2949 void Verbose::generate(std::string & buf, const std::string & name, const Target tgt, const std::string & extra)
2950 {
2951 switch (tgt.type)
2952 {
2953 case NONE:
2954 if (extra.empty())
2955 buf += STG(FMT("<%s>") % name);
2956 else
2957 buf += STG(FMT("<%s> (%s)") % name % extra);
2958 break;
2959
2960 case DEVICE:
2961 buf += STG(FMT("<%s> (d=%02d%s)")
2962 % name % tgt.device % extra);
2963 break;
2964
2965 default:
2966 {
2967 const char *kind = "o";
2968
2969 switch (tgt.type)
2970 {
2971 case CHANNEL:
2972 kind = "c";
2973 break;
2974 case PLAYER:
2975 kind = "p";
2976 break;
2977 case MIXER:
2978 kind = "m";
2979 break;
2980 case LINK:
2981 kind = "l";
2982 default:
2983 break;
2984 }
2985
2986 buf += STG(FMT("<%s> (d=%02d,%s=%03d%s)")
2987 % name % tgt.device % kind % tgt.object % extra);
2988 break;
2989 }
2990 }
2991 }
2992
2993