usr.sbin/cxgbetool/tcb_common.c

   1 /*-
   2  * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
   3  *
   4  * Copyright (c) 2018 Chelsio Communications, Inc.
   5  * All rights reserved.
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions and the following disclaimer.
  12  * 2. Redistributions in binary form must reproduce the above copyright
  13  *    notice, this list of conditions and the following disclaimer in the
  14  *    documentation and/or other materials provided with the distribution.
  15  *
  16  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  17  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  18  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  19  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  20  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  21  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  22  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  23  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  24  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  25  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  26  * SUCH DAMAGE.
  27  */
  28
  29 #include <sys/cdefs.h>
  30 __FBSDID("$FreeBSD$");
  31
  32 #include "tcb_common.h"
  33
  34 /***:-----------------------------------------------------------------------
  35  ***: externals
  36  ***:-----------------------------------------------------------------------
  37  */
  38
  39 extern _TCBVAR g_tcb_info4[];
  40 extern _TCBVAR g_scb_info4[];
  41 extern _TCBVAR g_fcb_info4[];
  42 extern void t4_display_tcb_aux_0(_TCBVAR *tvp,int aux);
  43 extern void t4_display_tcb_aux_1(_TCBVAR *tvp,int aux);
  44 extern void t4_display_tcb_aux_2(_TCBVAR *tvp,int aux);
  45 extern void t4_display_tcb_aux_3(_TCBVAR *tvp,int aux);
  46
  47 extern _TCBVAR g_tcb_info5[];
  48 extern _TCBVAR g_scb_info5[];
  49 extern _TCBVAR g_fcb_info5[];
  50 extern void t5_display_tcb_aux_0(_TCBVAR *tvp,int aux);
  51 extern void t5_display_tcb_aux_1(_TCBVAR *tvp,int aux);
  52 extern void t5_display_tcb_aux_2(_TCBVAR *tvp,int aux);
  53 extern void t5_display_tcb_aux_3(_TCBVAR *tvp,int aux);
  54
  55 extern _TCBVAR g_tcb_info6[];
  56 extern _TCBVAR g_scb_info6[];
  57 extern _TCBVAR g_fcb_info6[];
  58 extern void t6_display_tcb_aux_0(_TCBVAR *tvp,int aux);
  59 extern void t6_display_tcb_aux_1(_TCBVAR *tvp,int aux);
  60 extern void t6_display_tcb_aux_2(_TCBVAR *tvp,int aux);
  61 extern void t6_display_tcb_aux_3(_TCBVAR *tvp,int aux);
  62 extern void t6_display_tcb_aux_4(_TCBVAR *tvp,int aux);
  63
  64 /***:-----------------------------------------------------------------------
  65  ***: globals
  66  ***:-----------------------------------------------------------------------
  67  */
  68
  69 _TCBVAR *g_tcb_info=g_tcb_info5;
  70 _TCBVAR *g_scb_info=g_scb_info5;
  71 _TCBVAR *g_fcb_info=g_fcb_info5;
  72 static int g_tN=0;
  73
  74 static int g_prntstyl=PRNTSTYL_COMP;
  75
  76 static int g_got_scb=0;
  77 static int g_got_fcb=0;
  78
  79
  80 /***:-----------------------------------------------------------------------
  81 ***: error exit functions
  82 ***:-----------------------------------------------------------------------
  83 */
  84
  85 /**: err_exit functions
  86 *:  ------------------
  87 */
  88
  89 void tcb_prflush(void)
  90 {
  91     fflush(stdout);
  92     fflush(stderr);
  93 }
  94
  95
  96 void tcb_code_err_exit(char *fmt, ...)
  97 {
  98   va_list args;
  99   va_start(args, fmt);
 100   printf("Coding Error in: ");
 101   vprintf(fmt, args);
 102   printf("\n");
 103   tcb_prflush();
 104   va_end(args);
 105   exit(1);
 106 }
 107
 108 /***:-----------------------------------------------------------------------
 109 ***: tcb_hexdump functions
 110 ***:-----------------------------------------------------------------------
 111 */
 112
 113 void
 114 tcb_hexdump(unsigned base, unsigned char *buf, unsigned int size)
 115 {
 116     unsigned offset;
 117
 118     for (offset = 0; offset < size; ++offset) {
 119         if (!(offset % 16)) printf("\n0x%4.4x: ", base + offset);
 120         else if (!(offset % 8)) printf(" ");
 121         printf("%2.2x ", (unsigned char)buf[offset]);
 122     }
 123 }
 124
 125 int tcb_strmatch_nc(char *cs, char *ct) {
 126     while (*cs)
 127         if (tolower(*cs++) != tolower(*ct++)) return (FALSE);
 128     return (!(*ct));  /*return TRUE if *ct NULL at same time as *cs==NULL*/
 129 }
 130
 131
 132 /*: -------------------------------------------------------------------------
 133 string functions
 134 tcb_strmatch_nc:     Similar to exact match, but case insensitive.
 135 */
 136
 137
 138 int
 139 tcb_strncmp_nc(char *cs, char *ct, int n)
 140 {
 141     /*case insensitive version of the standard strncmp() function */
 142     int i = 0;
 143     int ret;
 144
 145
 146     ret = 0;
 147     for (i = 0; i < n && 0 == ret && !(EOS == *cs && EOS == *ct); ++i) {
 148         /* this is weird, but it matched GCC linux when strings don't
 149         * have any upper case characters.
 150         */
 151         ret = tolower(*cs++) - tolower(*ct++);
 152     }
 153     return ret;
 154 }
 155
 156 int
 157 tcb_startswith_nc(char *cs, char *ct)
 158 { /* return true if cs start with ct */
 159     return (0 == tcb_strncmp_nc(cs, ct, (int)strlen(ct)));
 160 }
 161
 162
 163
 164
 165 /***:-----------------------------------------------------------------------
 166  ***: START OF WINDOWS FUNCTIONS
 167  ***:-----------------------------------------------------------------------
 168  */
 169
 170
 171 /***:-----------------------------------------------------------------------
 172  ***: print utilties
 173  ***:-----------------------------------------------------------------------
 174  */
 175
 176 static int g_PR_indent=1;
 177
 178 void PR(char *fmt, ...)
 179 {
 180   int fmt_len;
 181   va_list args;
 182   va_start(args,fmt);
 183
 184   if (g_PR_indent) printf("  ");
 185   g_PR_indent=0;
 186   fmt_len=(int) strlen(fmt);
 187   if (fmt_len>0 && fmt[fmt_len-1]=='\n') g_PR_indent=1;
 188
 189   vprintf(fmt,args);
 190   tcb_prflush();
 191   va_end(args);
 192 }
 193
 194
 195 /***:-----------------------------------------------------------------------
 196  ***: val()
 197  ***:-----------------------------------------------------------------------
 198  */
 199
 200 _TCBVAR *
 201 lu_tcbvar(char *name)
 202 {
 203   _TCBVAR *tvp=g_tcb_info;
 204
 205   while (tvp->name!=NULL) {
 206     if      (tcb_strmatch_nc(name,tvp->name)) return tvp;
 207     else if (tcb_strmatch_nc(name,tvp->aka )) return tvp;
 208     tvp+=1;
 209   }
 210   tcb_code_err_exit("lu_tcbvar: bad name %s\n",name);
 211   return NULL;
 212 }
 213
 214 unsigned
 215 val(char *name)
 216 {
 217   _TCBVAR *tvp;
 218
 219   tvp=lu_tcbvar(name);
 220   return tvp->val;
 221 }
 222
 223 ui64
 224 val64(char *name)
 225 {
 226   _TCBVAR *tvp;
 227
 228   tvp=lu_tcbvar(name);
 229   return tvp->rawval;
 230 }
 231
 232
 233
 234 /***:-----------------------------------------------------------------------
 235  ***: get_tcb_bits
 236  ***:-----------------------------------------------------------------------
 237  */
 238
 239
 240 static int
 241 get_tcb_bit(unsigned char *A, int bit)
 242 {
 243   int ret=0;
 244   int ix,shift;
 245
 246   ix = 127 - (bit>>3);
 247   shift=bit&0x7;
 248   /*  prdbg("  ix: %u, shift=%u\n",ix,shift); */
 249   ret=(A[ix] >> shift) & 1;
 250   return ret;
 251 }
 252
 253 static ui64
 254 get_tcb_bits (unsigned char  *A, int hi, int lo)
 255 {
 256   ui64 ret=0;
 257
 258   if (lo>hi) {
 259     int temp=lo;
 260     lo=hi;
 261     hi=temp;
 262   }
 263
 264   while (hi>=lo) {
 265     ret = (ret<<1) | get_tcb_bit(A,hi);
 266     --hi;
 267   }
 268
 269   return ret;
 270 }
 271
 272
 273 void
 274 decompress_val(_TCBVAR *tvp,unsigned ulp_type,unsigned tx_max,
 275                unsigned rcv_nxt,unsigned rx_frag0_start_idx_raw)
 276 {
 277   unsigned rawval=(unsigned) tvp->rawval;
 278
 279   switch(tvp->comp) {
 280   case COMP_NONE: tvp->val=rawval;  break;
 281   case COMP_ULP:  tvp->val=rawval;  break;
 282   case COMP_TX_MAX:
 283     tvp->val=(tx_max - rawval) & 0xFFFFFFFF;
 284     break;
 285   case COMP_RCV_NXT:
 286     if (tcb_startswith_nc(tvp->name,"rx_frag")) {
 287       unsigned fragx=0;
 288       if (!tcb_strmatch_nc(tvp->name,"rx_frag0_start_idx_raw"))
 289         fragx=rawval;
 290       tvp->val=(rcv_nxt+rx_frag0_start_idx_raw+fragx) & 0xFFFFFFFF;
 291     } else {
 292       tvp->val=(rcv_nxt - rawval) & 0xFFFFFFFF;
 293     }
 294     break;
 295   case COMP_PTR: tvp->val=rawval;  break;
 296   case COMP_LEN:
 297     {
 298       tvp->val=rawval;
 299       if (PM_MODE_RDDP==ulp_type ||  PM_MODE_DDP==ulp_type ||
 300           PM_MODE_IANDP==ulp_type) {
 301         /* TP does this internally.  Not sure if I should show the
 302          *  unaltered value or the raw value.  For now I
 303          *  will diplay the raw value.  For now I've added the code
 304          *  mainly to stop windows compiler from warning about ulp_type
 305          *  being an unreferenced parameter.
 306          */
 307         tvp->val=0;
 308         tvp->val=rawval;  /* comment this out to display altered value */
 309       }
 310     }
 311     break;
 312   default:
 313     tcb_code_err_exit("decompress_val, bad switch: %d",tvp->comp);
 314     break;
 315   }
 316
 317
 318
 319 }
 320
 321
 322 void
 323 get_tcb_field(_TCBVAR *tvp,unsigned char *buf)
 324 {
 325   assert(tvp->hi-tvp->lo+1<=64);
 326   assert(tvp->hi>=tvp->lo);
 327
 328   tvp->rawval=get_tcb_bits(buf,tvp->lo,tvp->hi);
 329   /* assume no compression and 32-bit value for now */
 330   tvp->val=(unsigned) (tvp->rawval & 0xFFFFFFFF);
 331
 332
 333 }
 334
 335
 336 /***:-----------------------------------------------------------------------
 337  ***: spr_* functions
 338  ***:-----------------------------------------------------------------------
 339  */
 340
 341 char *
 342 spr_tcp_state (unsigned state)
 343 {
 344   char *ret="UNKNOWN";
 345
 346   if      ( 0 == state) {ret = "CLOSED";}
 347   else if ( 1 == state) {ret = "LISTEN";}
 348   else if ( 2 == state) {ret = "SYN_SENT";}
 349   else if ( 3 == state) {ret = "SYN_RCVD";}
 350   else if ( 4 == state) {ret = "ESTABLISHED";}
 351   else if ( 5 == state) {ret = "CLOSE_WAIT";}
 352   else if ( 6 == state) {ret = "FIN_WAIT_1";}
 353   else if ( 7 == state) {ret = "CLOSING";}
 354   else if ( 8 == state) {ret = "LAST_ACK";}
 355   else if ( 9 == state) {ret = "FIN_WAIT_2";}
 356   else if (10 == state) {ret = "TIME_WAIT";}
 357   else if (11 == state) {ret = "ESTABLISHED_RX";}
 358   else if (12 == state) {ret = "ESTABLISHED_TX";}
 359   else if (13 == state) {ret = "SYN_PEND";}
 360   else if (14 == state) {ret = "ESC_1_STATE";}
 361   else if (15 == state) {ret = "ESC_2_STATE";}
 362
 363   return ret;
 364 }
 365
 366 char *
 367 spr_cctrl_sel(unsigned sel0,unsigned sel1)
 368 {
 369   unsigned sel=(sel1<<1) | sel0;
 370   char *ret="UNKNOWN";
 371
 372   if      ( 0 == sel) {ret = "Reno";}
 373   else if ( 1 == sel) {ret = "Tahoe";}
 374   else if ( 2 == sel) {ret = "NewReno";}
 375   else if ( 3 == sel) {ret = "HighSpeed";}
 376
 377   return ret;
 378 }
 379
 380
 381 char *
 382 spr_ulp_type(unsigned ulp_type)
 383 {
 384   char *ret="UNKNOWN";
 385
 386   /*The tp.h PM_MODE_XXX call 1 DDP and 5 IANDP, but external
 387    * documentation (tcb.h" calls 5 ddp, and doesn't mention 1 or 3.
 388    */
 389
 390   if      ( PM_MODE_PASS  == ulp_type) {ret = "TOE";}
 391   else if ( PM_MODE_DDP   == ulp_type) {ret = "DDP";}
 392   else if ( PM_MODE_ISCSI == ulp_type) {ret = "ISCSI";}
 393   else if ( PM_MODE_IWARP == ulp_type) {ret = "IWARP";}
 394   else if ( PM_MODE_RDDP  == ulp_type) {ret = "RDMA";}
 395   else if ( PM_MODE_IANDP == ulp_type) {ret = "IANDP_DDP";}
 396   else if ( PM_MODE_FCOE  == ulp_type) {ret = "FCoE";}
 397   else if ( PM_MODE_USER  == ulp_type) {ret = "USER";}
 398   else if ( PM_MODE_TLS   == ulp_type) {ret = "TLS";}
 399   else if ( PM_MODE_DTLS  == ulp_type) {ret = "DTLS";}
 400
 401   return ret;
 402 }
 403
 404 char *
 405 spr_ip_version(unsigned ip_version)
 406 {
 407   char *ret="UNKNOWN";
 408
 409   if      ( 0 == ip_version) {ret = "IPv4";}
 410   else if ( 1 == ip_version) {ret = "IPv6";}
 411
 412   return ret;
 413 }
 414
 415
 416
 417 /***:-----------------------------------------------------------------------
 418  ***: display_tcb()
 419  ***:-----------------------------------------------------------------------
 420  */
 421
 422 void
 423 display_tcb_compressed(_TCBVAR *tvp,int aux)
 424 {
 425
 426   if (g_tN==4) {
 427     t4_display_tcb_aux_0(tvp,aux);
 428     if      (1==aux) t4_display_tcb_aux_1(tvp,aux);
 429     else if (2==aux) t4_display_tcb_aux_2(tvp,aux);
 430     else if (3==aux) t4_display_tcb_aux_3(tvp,aux);
 431
 432   } else if (g_tN==5) {
 433     t5_display_tcb_aux_0(tvp,aux);
 434     if      (1==aux) t5_display_tcb_aux_1(tvp,aux);
 435     else if (2==aux) t5_display_tcb_aux_2(tvp,aux);
 436     else if (3==aux) t5_display_tcb_aux_3(tvp,aux);
 437   } else if (g_tN==6) {
 438     t6_display_tcb_aux_0(tvp,aux);
 439     if      (1==aux) t6_display_tcb_aux_1(tvp,aux);
 440     else if (2==aux) t6_display_tcb_aux_2(tvp,aux);
 441     else if (3==aux) t6_display_tcb_aux_3(tvp,aux);
 442     else if (4==aux) t6_display_tcb_aux_4(tvp,aux);
 443   }
 444 }
 445
 446
 447
 448
 449 /***:-----------------------------------------------------------------------
 450  ***: parse_n_decode_tcb
 451  ***:-----------------------------------------------------------------------
 452  */
 453
 454
 455 unsigned
 456 parse_tcb( _TCBVAR *base_tvp, unsigned char *buf)
 457 {   /* parse the TCB */
 458   _TCBVAR *tvp=base_tvp;
 459   unsigned ulp_type;
 460   int aux=1;  /* assume TOE or iSCSI */
 461   unsigned tx_max=0, rcv_nxt=0, rx_frag0_start_idx_raw=0;
 462   int got_tx_max=0, got_rcv_nxt=0, got_rx_frag0_start_idx_raw=0;
 463
 464
 465   /* parse the TCB */
 466   while (tvp->name!=NULL) {
 467     get_tcb_field(tvp,buf);
 468     if (!got_tx_max && tcb_strmatch_nc("tx_max",tvp->name)) {
 469       tx_max=tvp->val;
 470       got_tx_max=1;
 471     }
 472     if (!got_rcv_nxt && tcb_strmatch_nc("rcv_nxt",tvp->name)) {
 473       rcv_nxt=tvp->val;
 474       got_rcv_nxt=1;
 475     }
 476     if (!got_rx_frag0_start_idx_raw &&
 477         tcb_strmatch_nc("rx_frag0_start_idx_raw",tvp->name)) {
 478       rx_frag0_start_idx_raw=tvp->val;
 479       got_rx_frag0_start_idx_raw=1;
 480     }
 481     tvp+=1;
 482   }
 483
 484   tvp=base_tvp;
 485   ulp_type=tvp->val;  /* ULP type is always first variable in TCB */
 486   if (PM_MODE_IANDP==ulp_type || PM_MODE_FCOE==ulp_type) aux=3;
 487   else if (PM_MODE_RDDP==ulp_type) aux=2;
 488   else if (6==g_tN && (PM_MODE_TLS==ulp_type || PM_MODE_DTLS==ulp_type)) aux=4;
 489   else aux=1;
 490
 491   assert(got_tx_max && got_rcv_nxt && got_rx_frag0_start_idx_raw);
 492
 493   /* decompress the compressed values */
 494   tvp=base_tvp;
 495   while (tvp->name!=NULL) {
 496     decompress_val(tvp,ulp_type,tx_max,rcv_nxt,rx_frag0_start_idx_raw);
 497     tvp+=1;
 498   }
 499
 500   return aux;
 501 }
 502
 503
 504
 505 void
 506 parse_scb( _TCBVAR *base_tvp, unsigned char *buf)
 507 {   /* parse the SCB */
 508   _TCBVAR *tvp=base_tvp;
 509
 510   while (tvp->name!=NULL) {
 511     if (tcb_strmatch_nc("scb_slush",tvp->name)) {
 512       /* the scb_slush field is all of remaining memory */
 513       tvp->rawval=0;
 514       tvp->val=0;
 515     } else {
 516       get_tcb_field(tvp,buf);
 517     }
 518     tvp+=1;
 519   }
 520 }
 521
 522
 523 void
 524 parse_fcb( _TCBVAR *base_tvp, unsigned char *buf)
 525 {   /* parse the FCB */
 526   _TCBVAR *tvp=base_tvp;
 527
 528   while (tvp->name!=NULL) {
 529     get_tcb_field(tvp,buf);
 530     tvp+=1;
 531   }
 532 }
 533
 534
 535 void
 536 display_list_tcb(_TCBVAR *base_tvp,int aux)
 537 {
 538   _TCBVAR *tvp=base_tvp;
 539   while (tvp->name!=NULL) {
 540     if (tvp->aux==0 || tvp->aux==aux) {
 541       if (tvp->hi-tvp->lo+1<=32) {
 542         printf("  %4d:%4d %31s: %10u (0x%1x)",tvp->lo,tvp->hi,tvp->name,
 543                (unsigned) tvp->rawval,(unsigned) tvp->rawval);
 544         if (COMP_TX_MAX==tvp->comp || COMP_RCV_NXT==tvp->comp)
 545           printf("  -> %1u (0x%x)", tvp->val,tvp->val);
 546       } else {
 547         printf("  %4d:%4d %31s: 0x%1llx",tvp->lo,tvp->hi,tvp->name,
 548                tvp->rawval);
 549       }
 550       printf("\n");
 551     }
 552     tvp+=1;
 553   }
 554 }
 555
 556 void
 557 display_tcb(_TCBVAR *tvp,unsigned char *buf,int aux)
 558 {
 559   if (g_prntstyl==PRNTSTYL_VERBOSE ||
 560       g_prntstyl==PRNTSTYL_RAW) {
 561     tcb_hexdump(0,buf,128);
 562     printf("\n");
 563   }
 564
 565   if (g_prntstyl==PRNTSTYL_VERBOSE ||
 566       g_prntstyl==PRNTSTYL_LIST) {
 567     display_list_tcb(tvp,aux);
 568   }
 569
 570   if (g_prntstyl==PRNTSTYL_VERBOSE ||
 571       g_prntstyl==PRNTSTYL_COMP) {
 572     display_tcb_compressed(tvp,aux);
 573   }
 574
 575 }
 576
 577 void
 578 parse_n_display_tcb(unsigned char *buf)
 579 {
 580   _TCBVAR *tvp=g_tcb_info;
 581   int aux;
 582
 583   aux=parse_tcb(tvp,buf);
 584   display_tcb(tvp,buf,aux);
 585 }
 586
 587 void
 588 parse_n_display_scb(unsigned char *buf)
 589 {
 590   _TCBVAR *tvp=g_scb_info;
 591
 592   parse_scb(tvp,buf);
 593   if (g_prntstyl==PRNTSTYL_VERBOSE ||
 594       g_prntstyl==PRNTSTYL_RAW) {
 595     tcb_hexdump(0,buf,128);
 596     printf("\n");
 597   }
 598   if (g_prntstyl==PRNTSTYL_VERBOSE ||
 599       g_prntstyl==PRNTSTYL_LIST ||
 600       g_prntstyl==PRNTSTYL_COMP) {
 601     display_list_tcb(tvp,0);
 602   }
 603 }
 604
 605 void
 606 parse_n_display_fcb(unsigned char *buf)
 607 {
 608   _TCBVAR *tvp=g_fcb_info;
 609
 610   parse_fcb(tvp,buf);
 611   if (g_prntstyl==PRNTSTYL_VERBOSE ||
 612       g_prntstyl==PRNTSTYL_RAW) {
 613     tcb_hexdump(0,buf,128);
 614     printf("\n");
 615   }
 616
 617   if (g_prntstyl==PRNTSTYL_VERBOSE ||
 618       g_prntstyl==PRNTSTYL_LIST ||
 619       g_prntstyl==PRNTSTYL_COMP) {
 620     display_list_tcb(tvp,0);
 621   }
 622 }
 623
 624 void
 625 parse_n_display_xcb(unsigned char *buf)
 626 {
 627   if      (g_got_scb) parse_n_display_scb(buf);
 628   else if (g_got_fcb) parse_n_display_fcb(buf);
 629   else                parse_n_display_tcb(buf);
 630 }
 631
 632 /***:-----------------------------------------------------------------------
 633  ***: swizzle_tcb
 634  ***:-----------------------------------------------------------------------
 635  */
 636
 637 void
 638 swizzle_tcb(unsigned char *buf)
 639 {
 640   int i,j,k;
 641
 642   for (i=0, j=128-16 ; i<j ; i+=16, j-=16) {
 643     unsigned char temp;
 644     for (k=0; k<16; ++k) {
 645       temp=buf[i+k];
 646       buf[i+k]=buf[j+k];
 647       buf[j+k]=temp;
 648     }
 649   }
 650 }
 651
 652
 653 /***:-----------------------------------------------------------------------
 654  ***: END OF WINDOWS FUNCTIONS
 655  ***:-----------------------------------------------------------------------
 656  */
 657
 658 void set_tidtype(unsigned int tidtype)
 659 {
 660     if (tidtype == TIDTYPE_SCB)
 661     {
 662         g_got_scb = 1;
 663     }
 664     else if (tidtype == TIDTYPE_FCB)
 665     {
 666         g_got_fcb = 1;
 667     }
 668     else
 669     {
 670         g_got_scb = 0;
 671         g_got_fcb = 0;
 672     }
 673
 674 }
 675
 676 void
 677 set_tcb_info(unsigned int tidtype, unsigned int cardtype)
 678 {
 679     set_tidtype(tidtype);
 680
 681     g_tN = cardtype;
 682     if (4 == g_tN) {
 683         g_tcb_info = g_tcb_info4;
 684         g_scb_info = g_scb_info4;
 685         g_fcb_info = g_fcb_info4;
 686     }
 687     else if (5 == g_tN) {
 688         g_tcb_info = g_tcb_info5;
 689         g_scb_info = g_scb_info5;
 690         g_fcb_info = g_fcb_info5;
 691     }
 692     else if (6 == g_tN) {
 693         g_tcb_info = g_tcb_info6;
 694         g_scb_info = g_scb_info6;
 695         g_fcb_info = g_fcb_info6;
 696     }
 697 }
 698
 699 void
 700 set_print_style(unsigned int prntstyl)
 701 {
 702   g_prntstyl=prntstyl;
 703 }