usr.sbin/i4b/isdndecode/layer3_subr.c

   1 /*
   2  * Copyright (c) 1997, 2000 Hellmuth Michaelis. All rights reserved.
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions
   6  * are met:
   7  * 1. Redistributions of source code must retain the above copyright
   8  *    notice, this list of conditions and the following disclaimer.
   9  * 2. Redistributions in binary form must reproduce the above copyright
  10  *    notice, this list of conditions and the following disclaimer in the
  11  *    documentation and/or other materials provided with the distribution.
  12  *
  13  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  14  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  15  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  16  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  17  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  18  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  19  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  20  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  21  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  22  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  23  * SUCH DAMAGE.
  24  *
  25  *---------------------------------------------------------------------------
  26  *
  27  *      layer3_subr.c - subroutines for IE decoding
  28  *      -------------------------------------------
  29  *
  30  *      $Id: layer3_subr.c,v 1.8 2000/02/21 15:17:17 hm Exp $
  31  *
  32  * $FreeBSD: src/usr.sbin/i4b/isdndecode/layer3_subr.c,v 1.6.2.2 2001/08/01 17:45:05 obrien Exp $
  33  *
  34  *      last edit-date: [Mon Feb 21 15:45:16 2000]
  35  *
  36  *---------------------------------------------------------------------------*/
  37
  38 #include "decode.h"
  39
  40 /*---------------------------------------------------------------------------*
  41  *      dummy function
  42  *---------------------------------------------------------------------------*/
  43 int
  44 f_null(char *pbuf, unsigned char *buf, int off)
  45 {
  46         return(0);
  47 }
  48
  49 /*---------------------------------------------------------------------------*
  50  *
  51  *---------------------------------------------------------------------------*/
  52 int
  53 f_cstat(char *pbuf, unsigned char *buf, int off)
  54 {
  55         int i = 0;
  56         int len = 0;
  57         char buffer[256];
  58
  59         i++;
  60         len = buf[i];
  61         i++;
  62         sprintf((pbuf+strlen(pbuf)), "Std=");
  63         switch((buf[i] & 0x60) >> 5)
  64         {
  65                 case 0:
  66                         strcpy(buffer, "CCITT");
  67                         break;
  68                 case 1:
  69                         strcpy(buffer, "ISO/IEC");
  70                         break;
  71                 case 2:
  72                         strcpy(buffer, "National");
  73                         break;
  74                 case 3:
  75                         strcpy(buffer, "Special");
  76                         break;
  77         }
  78         sprintf((pbuf+strlen(pbuf)), ", State=");
  79
  80         switch((buf[i] & 0x3f))
  81         {
  82                 case 0:
  83                         strcpy(buffer, "Null");
  84                         break;
  85                 case 1:
  86                         strcpy(buffer, "Call initiated");
  87                         break;
  88                 case 2:
  89                         strcpy(buffer, "Overlap sending");
  90                         break;
  91                 case 3:
  92                         strcpy(buffer, "Outgoing call proceeding");
  93                         break;
  94                 case 4:
  95                         strcpy(buffer, "Call delivered");
  96                         break;
  97                 case 6:
  98                         strcpy(buffer, "Call present");
  99                         break;
 100                 case 7:
 101                         strcpy(buffer, "Call received");
 102                         break;
 103                 case 8:
 104                         strcpy(buffer, "Connect request");
 105                         break;
 106                 case 9:
 107                         strcpy(buffer, "Incoming call proceeding");
 108                         break;
 109                 case 10:
 110                         strcpy(buffer, "Active");
 111                         break;
 112                 case 11:
 113                         strcpy(buffer, "Disconnect request");
 114                         break;
 115                 case 12:
 116                         strcpy(buffer, "Disconnect indication");
 117                         break;
 118                 case 15:
 119                         strcpy(buffer, "Suspend request");
 120                         break;
 121                 case 17:
 122                         strcpy(buffer, "Resume request");
 123                         break;
 124                 case 19:
 125                         strcpy(buffer, "Release request");
 126                         break;
 127                 case 22:
 128                         strcpy(buffer, "Call abort");
 129                         break;
 130                 case 25:
 131                         strcpy(buffer, "Overlap receiving");
 132                         break;
 133                 case 0x3d:
 134                         strcpy(buffer, "Restart request");
 135                         break;
 136                 case 0x3e:
 137                         strcpy(buffer, "Restart");
 138                         break;
 139                 default:
 140                         strcpy(buffer, "ERROR: undefined/reserved");
 141                         break;
 142         }
 143         sprintf((pbuf+strlen(pbuf)), "]");
 144         i++;
 145         return(i);
 146 }
 147
 148 /*---------------------------------------------------------------------------*
 149  *
 150  *---------------------------------------------------------------------------*/
 151 int
 152 f_chid(char *pbuf, unsigned char *buf, int off)
 153 {
 154         int i = 0;
 155         int len = 0;
 156         char buffer[256];
 157
 158         i++;
 159         len = buf[i];
 160         i++;
 161
 162         extension(3, pbuf+strlen(pbuf), off+i, buf[i], 0x80);
 163
 164         sprintline(3, (pbuf+strlen(pbuf)), off+i, buf[i], 0x40, "Interface Id present = %s", buf[i] & 0x40 ? "Yes" : "No");
 165
 166         sprintline(3, (pbuf+strlen(pbuf)), off+i, buf[i], 0x20, "Interface Type = %s", buf[i] & 0x20 ? "Other (PRI)" : "BRI");
 167
 168         sprintline(3, (pbuf+strlen(pbuf)), off+i, buf[i], 0x10, "Spare");
 169
 170         sprintline(3, (pbuf+strlen(pbuf)), off+i, buf[i], 0x08, "Channel = %s", buf[i] & 0x08 ? "exclusive" : "preferred");
 171
 172         sprintline(3, (pbuf+strlen(pbuf)), off+i, buf[i], 0x04, "Channel is%s the D-Channel", buf[i] & 0x04 ? "" : " not");
 173
 174         switch(buf[i] & 0x03)
 175         {
 176                 case 0:
 177                         strcpy(buffer, "no channel");
 178                         break;
 179                 case 1:
 180                         strcpy(buffer, "B-1");
 181                         break;
 182                 case 2:
 183                         strcpy(buffer, "B-2");
 184                         break;
 185                 case 3:
 186                         strcpy(buffer, "any channel");
 187                         break;
 188         }
 189         sprintline(3, (pbuf+strlen(pbuf)), off+i, buf[i], 0x03, "Channel = %s", buffer);
 190
 191         i++;
 192         return(i);
 193 }
 194
 195 /*---------------------------------------------------------------------------*
 196  *
 197  *---------------------------------------------------------------------------*/
 198 int
 199 f_fac(char *pbuf, unsigned char *buf, int off)
 200 {
 201         return(q932_facility(pbuf, buf));
 202 }
 203
 204 /*---------------------------------------------------------------------------*
 205  *
 206  *---------------------------------------------------------------------------*/
 207 int
 208 f_progi(char *pbuf, unsigned char *buf, int off)
 209 {
 210         int i = 0;
 211         int len = 0;
 212         char buffer[256];
 213
 214         i++;
 215         len = buf[i];
 216         i++;
 217         sprintf((pbuf+strlen(pbuf)), "Std=");
 218         switch((buf[i] & 0x60) >> 5)
 219         {
 220                 case 0:
 221                         strcpy(buffer, "CCITT");
 222                         break;
 223                 case 1:
 224                         strcpy(buffer, "ISO/IEC");
 225                         break;
 226                 case 2:
 227                         strcpy(buffer, "National");
 228                         break;
 229                 case 3:
 230                         strcpy(buffer, "Local");
 231                         break;
 232         }
 233         sprintf((pbuf+strlen(pbuf)), ", Loc=");
 234
 235         switch((buf[i] & 0x0f))
 236         {
 237                 case 0:
 238                         strcpy(buffer, "User");
 239                         break;
 240                 case 1:
 241                         strcpy(buffer, "Private network serving local user");
 242                         break;
 243                 case 2:
 244                         strcpy(buffer, "Public network serving local user");
 245                         break;
 246                 case 3:
 247                         strcpy(buffer, "Transit network");
 248                         break;
 249                 case 4:
 250                         strcpy(buffer, "Public network serving remote user");
 251                         break;
 252                 case 5:
 253                         strcpy(buffer, "Private network serving remote user");
 254                         break;
 255                 case 6:
 256                         strcpy(buffer, "Network beyond interworking point");
 257                         break;
 258                 default:
 259                         strcpy(buffer, "ERROR: undefined/reserved");
 260                         break;
 261         }
 262
 263         i++;
 264
 265         sprintf((pbuf+strlen(pbuf)), "\n          Description");
 266
 267         switch((buf[i] & 0x7f))
 268         {
 269                 case 1:
 270                         strcpy(buffer, "Call is not end-to-end ISDN");
 271                         break;
 272                 case 2:
 273                         strcpy(buffer, "Destination address is non-ISDN");
 274                         break;
 275                 case 3:
 276                         strcpy(buffer, "Origination address is non-ISDN");
 277                         break;
 278                 case 4:
 279                         strcpy(buffer, "Call has returned to the ISDN");
 280                         break;
 281                 case 5:
 282                         strcpy(buffer, "Interworking occured, Service change");
 283                         break;
 284                 case 8:
 285                         strcpy(buffer, "In-band info or appropriate pattern now available");
 286                         break;
 287                 default:
 288                         strcpy(buffer, "ERROR: undefined/reserved");
 289                         break;
 290         }
 291         sprintf((pbuf+strlen(pbuf)), "]");
 292         i++;
 293
 294         return(i);
 295 }
 296
 297 /*---------------------------------------------------------------------------*
 298  *
 299  *---------------------------------------------------------------------------*/
 300 int
 301 f_displ(char *pbuf, unsigned char *buf, int off)
 302 {
 303         int i = 0;
 304         int j = 0;
 305         int len = 0;
 306
 307         i++;
 308         len = buf[i];
 309         i++;
 310         for(j = 0; j < len; j++)
 311         {
 312                 sprintf((pbuf+strlen(pbuf)),"%c", buf[j+i]);
 313         }
 314         sprintf((pbuf+strlen(pbuf)),"]");
 315         i += j;
 316
 317         return(i);
 318 }
 319
 320 /*---------------------------------------------------------------------------*
 321  *
 322  *---------------------------------------------------------------------------*/
 323 int
 324 f_date(char *pbuf, unsigned char *buf, int off)
 325 {
 326         int i = 0;
 327         int j = 0;
 328         int len = 0;
 329
 330         i++;
 331         len = buf[i];
 332         i++;
 333
 334         sprintline(3, (pbuf+strlen(pbuf)), off+i, buf[i], 0xff, "Year = %02d", buf[i]);
 335         i++;
 336
 337         sprintline(3, (pbuf+strlen(pbuf)), off+i, buf[i], 0xff, "Month = %02d", buf[i]);
 338         i++;
 339
 340         sprintline(3, (pbuf+strlen(pbuf)), off+i, buf[i], 0xff, "Day = %02d", buf[i]);
 341         i++;
 342
 343         j=3;
 344         if(j < len)
 345         {
 346                 sprintline(3, (pbuf+strlen(pbuf)), off+i, buf[i], 0xff, "Hour = %02d", buf[i]);
 347                 i++;
 348                 j++;
 349         }
 350         if(j < len)
 351         {
 352                 sprintline(3, (pbuf+strlen(pbuf)), off+i, buf[i], 0xff, "Minute = %02d", buf[i]);
 353                 i++;
 354                 j++;
 355         }
 356         if(j < len)
 357         {
 358                 sprintline(3, (pbuf+strlen(pbuf)), off+i, buf[i], 0xff, "Second = %02d", buf[i]);
 359                 i++;
 360                 j++;
 361         }
 362         i += len;
 363         return(i);
 364 }
 365
 366 /*---------------------------------------------------------------------------*
 367  *      decode and print the cause
 368  *---------------------------------------------------------------------------*/
 369 int
 370 f_cause(char *pbuf, unsigned char *buf, int off)
 371 {
 372         int j;
 373         int len;
 374         int i = 0;
 375         int ls;
 376         char buffer[256];
 377
 378         i++;    /* index -> length */
 379
 380         len = buf[i];
 381
 382         i++;    /* coding/location */
 383         len--;
 384
 385         ls = buf[i];
 386
 387         extension(3, pbuf+strlen(pbuf), off+i, buf[i], 0x80);
 388
 389         switch((ls & 0x60) >> 5)
 390         {
 391                 case 0:
 392                         strcpy(buffer, "CCITT");
 393                         break;
 394                 case 1:
 395                         strcpy(buffer, "ISO/IEC");
 396                         break;
 397                 case 2:
 398                         strcpy(buffer, "National");
 399                         break;
 400                 case 3:
 401                         strcpy(buffer, "Local");
 402                         break;
 403         }
 404         sprintline(3, (pbuf+strlen(pbuf)), off+i, buf[i], 0x60, "Coding Standard = %s", buffer);
 405
 406         sprintline(3, (pbuf+strlen(pbuf)), off+i, buf[i], 0x10, "Spare");
 407
 408         switch(ls & 0x0f)
 409         {
 410                 case 0x00:
 411                         strcpy(buffer, "user");
 412                         break;
 413                 case 0x01:
 414                         strcpy(buffer, "private network serving local user");
 415                         break;
 416                 case 0x02:
 417                         strcpy(buffer, "public network serving local user");
 418                         break;
 419                 case 0x03:
 420                         strcpy(buffer, "transit network");
 421                         break;
 422                 case 0x04:
 423                         strcpy(buffer, "public network serving remote user");
 424                         break;
 425                 case 0x05:
 426                         strcpy(buffer, "private network serving remote user");
 427                         break;
 428                 case 0x07:
 429                         strcpy(buffer, "international network");
 430                         break;
 431                 case 0x0a:
 432                         strcpy(buffer, "network beyond interworking point");
 433                         break;
 434                 default:
 435                         sprintf(buffer, "reserved (0x%02x)", ls & 0x0f);
 436                         break;
 437         }
 438         sprintline(3, (pbuf+strlen(pbuf)), off+i, buf[i], 0x0f, "Location = %s", buffer);
 439
 440         i++;
 441         len--;
 442
 443         if(!(ls & 0x80))
 444         {
 445                 extension(3, pbuf+strlen(pbuf), off+i, buf[i], 0x80);
 446
 447                 switch(buf[i] & 0x7f)
 448                 {
 449                         case 0:
 450                                 strcpy(buffer, "Q.931");
 451                                 break;
 452                         case 3:
 453                                 strcpy(buffer, "X.21");
 454                                 break;
 455                         case 4:
 456                                 strcpy(buffer, "X.25");
 457                                 break;
 458                         case 5:
 459                                 strcpy(buffer, "Q.1031/Q.1051");
 460                                 break;
 461                         default:
 462                                 strcpy(buffer, "Reserved");
 463                                 break;
 464                 }
 465                 sprintline(3, (pbuf+strlen(pbuf)), off+i, buf[i], 0x7f, "Recommendation = %s", buffer);
 466                 i++;
 467                 len--;
 468         }
 469
 470         extension(3, pbuf+strlen(pbuf), off+i, buf[i], 0x80);
 471
 472         sprintline(3, (pbuf+strlen(pbuf)), off+i, buf[i], 0x7f, "Cause = %s", print_cause_q850(buf[i] & 0x7f));
 473
 474         i++;
 475         len--;
 476
 477         for(j = 0; j < len; j++)
 478                 sprintline(3, (pbuf+strlen(pbuf)), off+i+j, buf[i+j], 0xff, "Diagnostics = %02d %s", buf[i+j], buf[i+j]);
 479
 480         i += (len+1);
 481
 482         return(i);
 483 }
 484
 485 /*---------------------------------------------------------------------------*
 486  *      decode and print the bearer capability
 487  *---------------------------------------------------------------------------*/
 488 int
 489 f_bc(char *pbuf, unsigned char *buf, int off)
 490 {
 491         int len;
 492         int i = 0;
 493         int mr = 0;
 494         char buffer[256];
 495
 496         i++;    /* index -> length */
 497
 498         len = buf[i];
 499         i++;
 500
 501         extension(3, pbuf+strlen(pbuf), off+i, buf[i], 0x80);
 502
 503         switch((buf[i] & 0x60) >> 5)
 504         {
 505                 case 0:
 506                         strcpy(buffer, "CCITT");
 507                         break;
 508                 case 1:
 509                         strcpy(buffer, "ISO/IEC");
 510                         break;
 511                 case 2:
 512                         strcpy(buffer, "National");
 513                         break;
 514                 case 3:
 515                         strcpy(buffer, "NSI Std");
 516                         break;
 517         }
 518         sprintline(3, (pbuf+strlen(pbuf)), off+i, buf[i], 0x60, "Coding standard = %s", buffer);
 519
 520         switch(buf[i] & 0x1f)
 521         {
 522                 case 0x00:
 523                         strcpy(buffer, "speech");
 524                         break;
 525                 case 0x08:
 526                         strcpy(buffer, "unrestricted digital information");
 527                         break;
 528                 case 0x09:
 529                         strcpy(buffer, "restricted digital information");
 530                         break;
 531                 case 0x10:
 532                         strcpy(buffer, "3.1 kHz audio");
 533                         break;
 534                 case 0x11:
 535                         strcpy(buffer, "unrestricted digital information with tones");
 536                         break;
 537                 case 0x18:
 538                         strcpy(buffer, "video");
 539                         break;
 540                 default:
 541                         sprintf(buffer, "reserved (0x%02x)", buf[i] & 0x0f);
 542                         break;
 543         }
 544         sprintline(3, (pbuf+strlen(pbuf)), off+i, buf[i], 0x1f, "Capability = %s", buffer);
 545
 546         i++;
 547         len--;
 548
 549         extension(3, pbuf+strlen(pbuf), off+i, buf[i], 0x80);
 550
 551         switch((buf[i] & 0x60) >> 5)
 552         {
 553                 case 0:
 554                         strcpy(buffer, "circuit");
 555                         break;
 556                 case 2:
 557                         strcpy(buffer, "packet");
 558                         break;
 559                 default:
 560                         sprintf((pbuf+strlen(pbuf)), "reserved (0x%02x)", ((buf[i] & 0x60) >> 5));
 561                         break;
 562         }
 563         sprintline(3, (pbuf+strlen(pbuf)), off+i, buf[i], 0x60, "Mode = %s", buffer);
 564
 565         switch(buf[i] & 0x1f)
 566         {
 567                 case 0x00:
 568                         strcpy(buffer, "packet mode");
 569                         break;
 570                 case 0x10:
 571                         strcpy(buffer, "64 kbit/s");
 572                         break;
 573                 case 0x11:
 574                         strcpy(buffer, "2 x 64 kbit/s");
 575                         break;
 576                 case 0x13:
 577                         strcpy(buffer, "384 kbit/s");
 578                         break;
 579                 case 0x15:
 580                         strcpy(buffer, "1536 kbit/s");
 581                         break;
 582                 case 0x17:
 583                         strcpy(buffer, "1920 kbit/s");
 584                         break;
 585                 case 0x18:
 586                         strcpy(buffer, "Multirate");
 587                         mr = 1;
 588                         break;
 589                 default:
 590                         sprintf((pbuf+strlen(pbuf)), "reserved (0x%02x)", buf[i] & 0x0f);
 591                         break;
 592         }
 593         sprintline(3, (pbuf+strlen(pbuf)), off+i, buf[i], 0x1f, "Rate = %s", buffer);
 594
 595         i++;
 596         len--;
 597
 598         if(!len)
 599                 goto exit;
 600
 601         if(mr)
 602         {
 603                 extension(3, pbuf+strlen(pbuf), off+i, buf[i], 0x80);
 604                 sprintline(3, (pbuf+strlen(pbuf)), off+i, buf[i], 0x60, "Rate multiplier = %d", buf[i] & 0x7f);
 605                 i++;
 606                 len--;
 607         }
 608
 609         if(!len)
 610                 goto exit;
 611
 612         switch(buf[i] & 0x1f)
 613         {
 614                 case 0x01:
 615                         strcpy(buffer, "V.110/X.30");
 616                         break;
 617                 case 0x02:
 618                         strcpy(buffer, "G.711 u-Law");
 619                         break;
 620                 case 0x03:
 621                         strcpy(buffer, "G.711 a-Law");
 622                         break;
 623                 case 0x04:
 624                         strcpy(buffer, "G.721 ADPCM/I.460");
 625                         break;
 626                 case 0x05:
 627                         strcpy(buffer, "H.221/H.242");
 628                         break;
 629                 case 0x07:
 630                         strcpy(buffer, "non-CCITT rate adaption");
 631                         break;
 632                 case 0x08:
 633                         strcpy(buffer, "V.120");
 634                         break;
 635                 case 0x09:
 636                         strcpy(buffer, "X.31");
 637                         break;
 638                 default:
 639                         sprintf((pbuf+strlen(pbuf)), "reserved (0x%02x)", buf[i] & 0x1f);
 640                         break;
 641         }
 642         sprintline(3, (pbuf+strlen(pbuf)), off+i, buf[i], 0x1f, "Layer 1 Protocol = %s", buffer);
 643
 644         i++;
 645         len--;
 646
 647         if(!len)
 648                 goto exit;
 649
 650 /* work to do ahead !!! */
 651
 652         if(!(buf[i-1] & 0x80))
 653         {
 654                 sprintf((pbuf+strlen(pbuf)), "\n          user rate=0x%02x ", buf[i] & 0x1f);
 655
 656                 if(buf[i] & 0x40)
 657                         sprintf((pbuf+strlen(pbuf)), "(async,");
 658                 else
 659                         sprintf((pbuf+strlen(pbuf)), "(sync,");
 660
 661                 if(buf[i] & 0x20)
 662                         sprintf((pbuf+strlen(pbuf)), "in-band neg. possible)");
 663                 else
 664                         sprintf((pbuf+strlen(pbuf)), "in-band neg not possible)");
 665
 666                 i++;
 667                 len--;
 668         }
 669
 670         if(!len)
 671                 goto exit;
 672
 673         if(!(buf[i-1] & 0x80))
 674         {
 675                 sprintf((pbuf+strlen(pbuf)), "\n          clk/flow=0x%02x", buf[i] & 0x1f);
 676
 677                 sprintf((pbuf+strlen(pbuf)), "\n          intermediate rate=");
 678
 679                 switch((buf[i] & 0x60) >> 5)
 680                 {
 681                         case 0:
 682                                 sprintf((pbuf+strlen(pbuf)), "not used");
 683                                 break;
 684                         case 1:
 685                                 sprintf((pbuf+strlen(pbuf)), "8 kbit/s");
 686                                 break;
 687                         case 2:
 688                                 sprintf((pbuf+strlen(pbuf)), "16 kbit/s");
 689                                 break;
 690                         case 3:
 691                                 sprintf((pbuf+strlen(pbuf)), "32 kbit/s");
 692                                 break;
 693                 }
 694                 i++;
 695                 len--;
 696         }
 697
 698         if(!len)
 699                 goto exit;
 700
 701         if(!(buf[i-1] & 0x80))
 702         {
 703                 sprintf((pbuf+strlen(pbuf)), "\n          hdr/mfrm/etc.=0x%02x", buf[i]);
 704                 i++;
 705                 len--;
 706         }
 707
 708         if(!len)
 709                 goto exit;
 710
 711         if(!(buf[i-1] & 0x80))
 712         {
 713                 sprintf((pbuf+strlen(pbuf)), "\n          stop/data/parity=0x%02x", buf[i]);
 714                 i++;
 715                 len--;
 716         }
 717
 718         if(!len)
 719                 goto exit;
 720
 721         if(!(buf[i-1] & 0x80))
 722         {
 723                 sprintf((pbuf+strlen(pbuf)), "\n          modemtype=0x%02x", buf[i]);
 724                 i++;
 725                 len--;
 726         }
 727
 728         if(!len)
 729                 goto exit;
 730
 731         switch(buf[i] & 0x7f)
 732         {
 733                 case 0x42:
 734                         sprintf((pbuf+strlen(pbuf)), "\n          layer2=Q.921/I.441");
 735                         break;
 736                 case 0x46:
 737                         sprintf((pbuf+strlen(pbuf)), "\n          layer2=X.25 link");
 738                         break;
 739                 default:
 740                         sprintf((pbuf+strlen(pbuf)), "\n          layer2=0x%02x",(buf[i] & 0x7f));
 741                         break;
 742         }
 743         i++;
 744         len--;
 745
 746         if(!len)
 747                 goto exit;
 748
 749         switch(buf[i] & 0x7f)
 750         {
 751                 case 0x62:
 752                         sprintf((pbuf+strlen(pbuf)), "\n          layer3=Q.921/I.441");
 753                         break;
 754                 case 0x66:
 755                         sprintf((pbuf+strlen(pbuf)), "\n          layer3=X.25 packet");
 756                         break;
 757                 default:
 758                         sprintf((pbuf+strlen(pbuf)), "\n          layer3=0x%02x",(buf[i] & 0x7f));
 759                         break;
 760         }
 761         i++;
 762         len--;
 763
 764 exit:
 765
 766         return(i);
 767 }
 768
 769 /*---------------------------------------------------------------------------*
 770  *      decode and print the ISDN (telephone) number
 771  *---------------------------------------------------------------------------*/
 772 int
 773 f_cnu(char *pbuf, unsigned char *buf, int off)
 774 {
 775         int j;
 776         int len;
 777         int i = 0;
 778         int tp;
 779         int ind = 0;
 780         char buffer[256];
 781
 782         i++;    /* index -> length */
 783         len = buf[i];
 784
 785         i++;    /* index -> type/plan */
 786         tp = buf[i];
 787
 788         extension(3, pbuf+strlen(pbuf), off+i, buf[i], 0x80);
 789
 790         switch((tp & 0x70) >> 4)
 791         {
 792                 case 0:
 793                         strcpy(buffer, "Unknown");
 794                         break;
 795                 case 1:
 796                         strcpy(buffer, "International number");
 797                         break;
 798                 case 2:
 799                         strcpy(buffer, "National number");
 800                         break;
 801                 case 3:
 802                         strcpy(buffer, "Network specific number");
 803                         break;
 804                 case 4:
 805                         strcpy(buffer, "Subscriber number");
 806                         break;
 807                 case 6:
 808                         strcpy(buffer, "Abbreviated number");
 809                         break;
 810                 default:
 811                         sprintf(buffer, "Reserved (%d), ", ((tp & 0x70) >> 4));
 812                         break;
 813         }
 814         sprintline(3, (pbuf+strlen(pbuf)), off+i, buf[i], 0x60, "Type = %s", buffer);
 815
 816         switch(tp & 0x0f)
 817         {
 818                 case 0:
 819                         strcpy(buffer, "Unknown");
 820                         break;
 821                 case 1:
 822                         strcpy(buffer, "ISDN (E.164)");
 823                         break;
 824                 case 3:
 825                         strcpy(buffer, "Data (X.121)");
 826                         break;
 827                 case 4:
 828                         strcpy(buffer, "Telex (F.69)");
 829                         break;
 830                 case 8:
 831                         strcpy(buffer, "National");
 832                         break;
 833                 case 9:
 834                         strcpy(buffer, "Private");
 835                         break;
 836                 default:
 837                         sprintf(buffer, "Reserved (%d)", (tp & 0x0f));
 838                         break;
 839         }
 840         sprintline(3, (pbuf+strlen(pbuf)), off+i, buf[i], 0x0f, "Plan = %s", buffer);
 841
 842         i++;
 843         len--;
 844
 845         if(!(tp & 0x80))
 846         {
 847                 extension(3, pbuf+strlen(pbuf), off+i, buf[i], 0x80);
 848
 849                 switch((buf[i] & 0x60) >> 5)
 850                 {
 851                         case 0:
 852                                 strcpy(buffer, "allowed");
 853                                 break;
 854                         case 1:
 855                                 strcpy(buffer, "restricted");
 856                                 break;
 857                         case 2:
 858                                 strcpy(buffer, "number not available");
 859                                 break;
 860                         case 3:
 861                                 strcpy(buffer, "reserved");
 862                                 break;
 863                 }
 864                 sprintline(3, (pbuf+strlen(pbuf)), off+i, buf[i], 0x60, "Presentation = %s", buffer);
 865
 866                 sprintline(3, (pbuf+strlen(pbuf)), off+i, buf[i], 0x1c, "Spare");
 867
 868                 switch(ind & 0x03)
 869                 {
 870                         case 0:
 871                                 strcpy(buffer, "user provided, not screened");
 872                                 break;
 873                         case 1:
 874                                 strcpy(buffer, "user provided, verified & passed");
 875                                 break;
 876                         case 2:
 877                                 strcpy(buffer, "user provided, verified & failed");
 878                                 break;
 879                         case 3:
 880                                 strcpy(buffer, "network provided");
 881                                 break;
 882                 }
 883                 sprintline(3, (pbuf+strlen(pbuf)), off+i, buf[i], 0x03, "Screening = %s", buffer);
 884                 i++;
 885                 len--;
 886         }
 887
 888         for(j = 0; j < len; j++)
 889         {
 890                 sprintline(3, (pbuf+strlen(pbuf)), off+i+j, buf[i+j], 0xff, "Number digit = %c", buf[i+j]);
 891         }
 892
 893         i += j;
 894
 895         return(i);
 896 }
 897
 898 /*---------------------------------------------------------------------------*
 899  *      decode and print HL comatibility
 900  *---------------------------------------------------------------------------*/
 901 int
 902 f_hlc(char *pbuf, unsigned char *buf, int off)
 903 {
 904         int i = 0;
 905         int len = 0;
 906         char buffer[256];
 907
 908         i++;
 909         len = buf[i];
 910
 911         i++;
 912         extension(3, pbuf+strlen(pbuf), off+i, buf[i], 0x80);
 913
 914         switch((buf[i] >> 5) & 0x03)
 915         {
 916                 case 0: strcpy(buffer, "CCITT");
 917                         break;
 918                 case 1: strcpy(buffer, "ISO/IEC");
 919                         break;
 920                 case 2: strcpy(buffer, "National");
 921                         break;
 922                 case 3: strcpy(buffer, "Network");
 923         }
 924         sprintline(3, (pbuf+strlen(pbuf)), off+i, buf[i], 0x60, "Coding standard = %s", buffer);
 925
 926         sprintline(3, (pbuf+strlen(pbuf)), off+i, buf[i], 0x1c, "Interpretation = %s", ((buf[i] >> 2) & 0x07) == 0x04 ? "first" : "reserved");
 927
 928         sprintline(3, (pbuf+strlen(pbuf)), off+i, buf[i], 0x03, "Presentation = %s", ((buf[i]) & 0x03) == 0x01 ? "High layer protocol profile" : "reserved");
 929
 930         i++;
 931         len--;
 932
 933         extension(3, pbuf+strlen(pbuf), off+i, buf[i], 0x80);
 934
 935         switch(buf[i] & 0x7f)
 936         {
 937                 case 0x01:
 938                         strcpy(buffer, "Telephony");
 939                         break;
 940                 case 0x04:
 941                         strcpy(buffer, "Fax Group 2/3 (F.182)");
 942                         break;
 943                 case 0x21:
 944                         strcpy(buffer, "Fax Group 4 I (F.184)");
 945                         break;
 946                 case 0x24:
 947                         strcpy(buffer, "Teletex (F.230) or Fax Group 4 II/III (F.184)");
 948                         break;
 949                 case 0x28:
 950                         strcpy(buffer, "Teletex (F.220)");
 951                         break;
 952                 case 0x31:
 953                         strcpy(buffer, "Teletex (F.200)");
 954                         break;
 955                 case 0x32:
 956                         strcpy(buffer, "Videotex (F.300/T.102)");
 957                         break;
 958                 case 0x33:
 959                         strcpy(buffer, "Videotex (F.300/T.101)");
 960                         break;
 961                 case 0x35:
 962                         strcpy(buffer, "Telex (F.60)");
 963                         break;
 964                 case 0x38:
 965                         strcpy(buffer, "MHS (X.400)");
 966                         break;
 967                 case 0x41:
 968                         strcpy(buffer, "OSI (X.200)");
 969                         break;
 970                 case 0x5e:
 971                         strcpy(buffer, "Maintenance");
 972                         break;
 973                 case 0x5f:
 974                         strcpy(buffer, "Management");
 975                         break;
 976                 case 0x60:
 977                         strcpy(buffer, "Audio visual (F.721)");
 978                         break;
 979                 default:
 980                         sprintf(buffer, "Reserved (0x%02x)", buf[i] & 0x7f);
 981                         break;
 982         }
 983         sprintline(3, (pbuf+strlen(pbuf)), off+i, buf[i], 0x7f, "Characteristics = %s", buffer);
 984         i++;
 985         len--;
 986
 987         if(buf[i-1] & 0x80)
 988         {
 989                 return(i);
 990         }
 991
 992         extension(3, pbuf+strlen(pbuf), off+i, buf[i], 0x80);
 993
 994         switch(buf[i] & 0x7f)
 995         {
 996                 case 0x01:
 997                         strcpy(buffer, "Telephony");
 998                         break;
 999                 case 0x04:
1000                         strcpy(buffer, "Fax Group 2/3 (F.182)");
1001                         break;
1002                 case 0x21:
1003                         strcpy(buffer, "Fax Group 4 I (F.184)");
1004                         break;
1005                 case 0x24:
1006                         strcpy(buffer, "Teletex (F.230) or Fax Group 4 II/III (F.184)");
1007                         break;
1008                 case 0x28:
1009                         strcpy(buffer, "Teletex (F.220)");
1010                         break;
1011                 case 0x31:
1012                         strcpy(buffer, "Teletex (F.200)");
1013                         break;
1014                 case 0x32:
1015                         strcpy(buffer, "Videotex (F.300/T.102)");
1016                         break;
1017                 case 0x33:
1018                         strcpy(buffer, "Videotex (F.300/T.101)");
1019                         break;
1020                 case 0x35:
1021                         strcpy(buffer, "Telex (F.60)");
1022                         break;
1023                 case 0x38:
1024                         strcpy(buffer, "MHS (X.400)");
1025                         break;
1026                 case 0x41:
1027                         strcpy(buffer, "OSI (X.200)");
1028                         break;
1029                 case 0x5e:
1030                         strcpy(buffer, "Maintenance");
1031                         break;
1032                 case 0x5f:
1033                         strcpy(buffer, "Management");
1034                         break;
1035                 case 0x60:
1036                         strcpy(buffer, "Audio visual (F.721)");
1037                         break;
1038                 default:
1039                         sprintf(buffer, "Reserved (0x%02x)", buf[i] & 0x7f);
1040                         break;
1041
1042         }
1043         sprintline(3, (pbuf+strlen(pbuf)), off+i, buf[i], 0x7f, "Ext. characteristics = %s", buffer);
1044         i++;
1045         return(i);
1046 }
1047
1048 /*---------------------------------------------------------------------------*
1049  *      user-user
1050  *---------------------------------------------------------------------------*/
1051 int
1052 f_uu(char *pbuf, unsigned char *buf, int off)
1053 {
1054         int j;
1055         int len;
1056         int i = 0;
1057         int pd;
1058         char buffer[256];
1059
1060         i++;    /* index -> length */
1061         len = buf[i];
1062
1063         i++;    /* index -> PD */
1064         pd = buf[i];
1065
1066         switch(pd)
1067         {
1068                 case 0:
1069                         strcpy(buffer, "user-specific");
1070                         break;
1071                 case 1:
1072                         strcpy(buffer, "OSI high layer");
1073                         break;
1074                 case 2:
1075                         strcpy(buffer, "X.244");
1076                         break;
1077                 case 3:
1078                         strcpy(buffer, "reserved for sys mgmt");
1079                         break;
1080                 case 4:
1081                         strcpy(buffer, "IA5 characters");
1082                         break;
1083                 case 5:
1084                         strcpy(buffer, "X.208/X.209");
1085                         break;
1086                 case 7:
1087                         strcpy(buffer, "V.120");
1088                         break;
1089                 case 8:
1090                         strcpy(buffer, "Q.931/I.451");
1091                         break;
1092                 default:
1093                         if(pd >= 0x10 && pd <= 0x3f)
1094                                 sprintf(buffer, "reserved incl X.31 (0x%2x)", pd);
1095                         else if (pd >= 0x40 && pd <= 0x4f)
1096                                 sprintf(buffer, "national use (0x%2x)", pd);
1097                         else if (pd >= 0x50 && pd <= 0xfe)
1098                                 sprintf(buffer, "reserved incl X.31 (0x%2x)", pd);
1099                         else
1100                                 sprintf(buffer, "reserved (0x%2x)", pd);
1101                         break;
1102         }
1103         sprintline(3, (pbuf+strlen(pbuf)), off+i, buf[i], 0xff, "protocol = %s", buffer);
1104
1105         i++;
1106         len--;
1107
1108         for(j = 0; j < len; j++)
1109         {
1110                 if(isprint(buf[i+j]))
1111                         sprintline(3, (pbuf+strlen(pbuf)), off+i+j, buf[i+j], 0xff, "user information = %c", buf[i+j]);
1112                 else
1113                         sprintline(3, (pbuf+strlen(pbuf)), off+i+j, buf[i+j], 0xff, "user information = 0x%2x", buf[i+j]);
1114         }
1115
1116         i += j;
1117
1118         return(i);
1119 }
1120
1121 /* EOF */
1122