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