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
tcb_prflush(void)89 void tcb_prflush(void)
90 {
91 fflush(stdout);
92 fflush(stderr);
93 }
94
95
tcb_code_err_exit(char * fmt,...)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
tcb_hexdump(unsigned base,unsigned char * buf,unsigned int size)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
tcb_strmatch_nc(char * cs,char * ct)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
tcb_strncmp_nc(char * cs,char * ct,int n)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
tcb_startswith_nc(char * cs,char * ct)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
PR(char * fmt,...)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 *
lu_tcbvar(char * name)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
val(char * name)215 val(char *name)
216 {
217 _TCBVAR *tvp;
218
219 tvp=lu_tcbvar(name);
220 return tvp->val;
221 }
222
223 ui64
val64(char * name)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
get_tcb_bit(unsigned char * A,int bit)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
get_tcb_bits(unsigned char * A,int hi,int lo)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
decompress_val(_TCBVAR * tvp,unsigned ulp_type,unsigned tx_max,unsigned rcv_nxt,unsigned rx_frag0_start_idx_raw)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
get_tcb_field(_TCBVAR * tvp,unsigned char * buf)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 *
spr_tcp_state(unsigned state)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 *
spr_cctrl_sel(unsigned sel0,unsigned sel1)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 *
spr_ulp_type(unsigned ulp_type)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 *
spr_ip_version(unsigned ip_version)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
display_tcb_compressed(_TCBVAR * tvp,int aux)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
parse_tcb(_TCBVAR * base_tvp,unsigned char * buf)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
parse_scb(_TCBVAR * base_tvp,unsigned char * buf)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
parse_fcb(_TCBVAR * base_tvp,unsigned char * buf)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
display_list_tcb(_TCBVAR * base_tvp,int aux)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
display_tcb(_TCBVAR * tvp,unsigned char * buf,int aux)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
parse_n_display_tcb(unsigned char * buf)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
parse_n_display_scb(unsigned char * buf)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
parse_n_display_fcb(unsigned char * buf)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
parse_n_display_xcb(unsigned char * buf)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
swizzle_tcb(unsigned char * buf)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
set_tidtype(unsigned int tidtype)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
set_tcb_info(unsigned int tidtype,unsigned int cardtype)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
set_print_style(unsigned int prntstyl)700 set_print_style(unsigned int prntstyl)
701 {
702 g_prntstyl=prntstyl;
703 }
704