source3/rpcclient/display.c

   1 /*
   2    Unix SMB/Netbios implementation.
   3    Version 1.9.
   4    Samba utility functions
   5    Copyright (C) Andrew Tridgell 1992-1998
   6    Copyright (C) Luke Kenneth Casson Leighton 1996 - 1998
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 2 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program; if not, write to the Free Software
  20    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  21 */
  22
  23 #include "includes.h"
  24
  25
  26 /****************************************************************************
  27 convert a share mode to a string
  28 ****************************************************************************/
  29 char *get_file_mode_str(uint32 share_mode)
  30 {
  31         static fstring mode;
  32
  33         switch (GET_DENY_MODE(share_mode))
  34         {
  35                 case DENY_NONE : fstrcpy(mode, "DENY_NONE  "); break;
  36                 case DENY_ALL  : fstrcpy(mode, "DENY_ALL   "); break;
  37                 case DENY_DOS  : fstrcpy(mode, "DENY_DOS   "); break;
  38                 case DENY_READ : fstrcpy(mode, "DENY_READ  "); break;
  39                 case DENY_WRITE: fstrcpy(mode, "DENY_WRITE "); break;
  40                 case DENY_FCB:   fstrcpy(mode, "DENY_FCB "); break;
  41                 default        : fstrcpy(mode, "DENY_????  "); break;
  42         }
  43
  44         switch (share_mode & 0xF)
  45         {
  46                 case 0 : fstrcat(mode, "RDONLY"); break;
  47                 case 1 : fstrcat(mode, "WRONLY"); break;
  48                 case 2 : fstrcat(mode, "RDWR  "); break;
  49                 default: fstrcat(mode, "R??W??"); break;
  50         }
  51
  52         return mode;
  53 }
  54
  55 /****************************************************************************
  56 convert an oplock mode to a string
  57 ****************************************************************************/
  58 char *get_file_oplock_str(uint32 op_type)
  59 {
  60         static fstring oplock;
  61         BOOL excl  = ((op_type & EXCLUSIVE_OPLOCK) != 0);
  62         BOOL batch = ((op_type & BATCH_OPLOCK    ) != 0);
  63
  64         oplock[0] = 0;
  65
  66         if (excl           ) fstrcat(oplock, "EXCLUSIVE");
  67         if (excl  &&  batch) fstrcat(oplock, "+");
  68         if (          batch) fstrcat(oplock, "BATCH");
  69         if (!excl && !batch) fstrcat(oplock, "NONE");
  70
  71         return oplock;
  72 }
  73
  74 /****************************************************************************
  75 convert a share type enum to a string
  76 ****************************************************************************/
  77 char *get_share_type_str(uint32 type)
  78 {
  79         static fstring typestr;
  80
  81         switch (type)
  82         {
  83                 case STYPE_DISKTREE: fstrcpy(typestr, "Disk"   ); break;
  84                 case STYPE_PRINTQ  : fstrcpy(typestr, "Printer"); break;
  85                 case STYPE_DEVICE  : fstrcpy(typestr, "Device" ); break;
  86                 case STYPE_IPC     : fstrcpy(typestr, "IPC"    ); break;
  87                 default            : fstrcpy(typestr, "????"   ); break;
  88         }
  89         return typestr;
  90 }
  91
  92 /****************************************************************************
  93 convert a server type enum to a string
  94 ****************************************************************************/
  95 char *get_server_type_str(uint32 type)
  96 {
  97         static fstring typestr;
  98
  99         if (type == SV_TYPE_ALL)
 100         {
 101                 fstrcpy(typestr, "All");
 102         }
 103         else
 104         {
 105                 int i;
 106                 typestr[0] = 0;
 107                 for (i = 0; i < 32; i++)
 108                 {
 109                         if (type & (1 << i))
 110                         {
 111                                 switch (((unsigned)1) << i)
 112                                 {
 113                                         case SV_TYPE_WORKSTATION      : fstrcat(typestr, "Wk " ); break;
 114                                         case SV_TYPE_SERVER           : fstrcat(typestr, "Sv " ); break;
 115                                         case SV_TYPE_SQLSERVER        : fstrcat(typestr, "Sql "); break;
 116                                         case SV_TYPE_DOMAIN_CTRL      : fstrcat(typestr, "PDC "); break;
 117                                         case SV_TYPE_DOMAIN_BAKCTRL   : fstrcat(typestr, "BDC "); break;
 118                                         case SV_TYPE_TIME_SOURCE      : fstrcat(typestr, "Tim "); break;
 119                                         case SV_TYPE_AFP              : fstrcat(typestr, "AFP "); break;
 120                                         case SV_TYPE_NOVELL           : fstrcat(typestr, "Nov "); break;
 121                                         case SV_TYPE_DOMAIN_MEMBER    : fstrcat(typestr, "Dom "); break;
 122                                         case SV_TYPE_PRINTQ_SERVER    : fstrcat(typestr, "PrQ "); break;
 123                                         case SV_TYPE_DIALIN_SERVER    : fstrcat(typestr, "Din "); break;
 124                                         case SV_TYPE_SERVER_UNIX      : fstrcat(typestr, "Unx "); break;
 125                                         case SV_TYPE_NT               : fstrcat(typestr, "NT " ); break;
 126                                         case SV_TYPE_WFW              : fstrcat(typestr, "Wfw "); break;
 127                                         case SV_TYPE_SERVER_MFPN      : fstrcat(typestr, "Mfp "); break;
 128                                         case SV_TYPE_SERVER_NT        : fstrcat(typestr, "SNT "); break;
 129                                         case SV_TYPE_POTENTIAL_BROWSER: fstrcat(typestr, "PtB "); break;
 130                                         case SV_TYPE_BACKUP_BROWSER   : fstrcat(typestr, "BMB "); break;
 131                                         case SV_TYPE_MASTER_BROWSER   : fstrcat(typestr, "LMB "); break;
 132                                         case SV_TYPE_DOMAIN_MASTER    : fstrcat(typestr, "DMB "); break;
 133                                         case SV_TYPE_SERVER_OSF       : fstrcat(typestr, "OSF "); break;
 134                                         case SV_TYPE_SERVER_VMS       : fstrcat(typestr, "VMS "); break;
 135                                         case SV_TYPE_WIN95_PLUS       : fstrcat(typestr, "W95 "); break;
 136                                         case SV_TYPE_ALTERNATE_XPORT  : fstrcat(typestr, "Xpt "); break;
 137                                         case SV_TYPE_LOCAL_LIST_ONLY  : fstrcat(typestr, "Dom "); break;
 138                                         case SV_TYPE_DOMAIN_ENUM      : fstrcat(typestr, "Loc "); break;
 139                                 }
 140                         }
 141                 }
 142                 i = strlen(typestr)-1;
 143                 if (typestr[i] == ' ') typestr[i] = 0;
 144
 145         }
 146         return typestr;
 147 }
 148
 149 /****************************************************************************
 150 server info level 101 display function
 151 ****************************************************************************/
 152 void display_srv_info_101(FILE *out_hnd, enum action_type action,
 153                 SRV_INFO_101 *sv101)
 154 {
 155         if (sv101 == NULL)
 156         {
 157                 return;
 158         }
 159
 160         switch (action)
 161         {
 162                 case ACTION_HEADER:
 163                 {
 164                         fprintf(out_hnd, "Server Info Level 101:\n");
 165
 166                         break;
 167                 }
 168                 case ACTION_ENUMERATE:
 169                 {
 170                         fstring name;
 171                         fstring comment;
 172
 173                         rpcstr_pull(name, sv101->uni_name.buffer,  sizeof(name), sv101->uni_name.uni_str_len*2, 0);
 174                         rpcstr_pull(comment, sv101->uni_comment.buffer,  sizeof(comment), sv101->uni_comment.uni_str_len*2, 0);
 175
 176                         display_server(out_hnd, action, name, sv101->srv_type, comment);
 177
 178                         fprintf(out_hnd, "\tplatform_id     : %d\n"    , sv101->platform_id);
 179                         fprintf(out_hnd, "\tos version      : %d.%d\n" , sv101->ver_major, sv101->ver_minor);
 180
 181                         break;
 182                 }
 183                 case ACTION_FOOTER:
 184                 {
 185                         break;
 186                 }
 187         }
 188
 189 }
 190
 191 /****************************************************************************
 192 server info level 102 display function
 193 ****************************************************************************/
 194 void display_srv_info_102(FILE *out_hnd, enum action_type action,SRV_INFO_102 *sv102)
 195 {
 196         if (sv102 == NULL)
 197         {
 198                 return;
 199         }
 200
 201         switch (action)
 202         {
 203                 case ACTION_HEADER:
 204                 {
 205                         fprintf(out_hnd, "Server Info Level 102:\n");
 206
 207                         break;
 208                 }
 209                 case ACTION_ENUMERATE:
 210                 {
 211                         fstring name;
 212                         fstring comment;
 213                         fstring usr_path;
 214
 215                         rpcstr_pull(name, sv102->uni_name.buffer,  sizeof(name), sv102->uni_name.uni_str_len*2, 0);
 216                         rpcstr_pull(comment, sv102->uni_comment.buffer,  sizeof(comment), sv102->uni_comment.uni_str_len*2, 0);
 217                         rpcstr_pull(usr_path, sv102->uni_usr_path.buffer,  sizeof(usr_path), sv102->uni_usr_path.uni_str_len*2, 0);
 218
 219                         display_server(out_hnd, action, name, sv102->srv_type, comment);
 220
 221                         fprintf(out_hnd, "\tplatform_id     : %d\n"    , sv102->platform_id);
 222                         fprintf(out_hnd, "\tos version      : %d.%d\n" , sv102->ver_major, sv102->ver_minor);
 223
 224                         fprintf(out_hnd, "\tusers           : %x\n"    , sv102->users      );
 225                         fprintf(out_hnd, "\tdisc, hidden    : %x,%x\n" , sv102->disc     , sv102->hidden   );
 226                         fprintf(out_hnd, "\tannounce, delta : %d, %d\n", sv102->announce , sv102->ann_delta);
 227                         fprintf(out_hnd, "\tlicenses        : %d\n"    , sv102->licenses   );
 228                         fprintf(out_hnd, "\tuser path       : %s\n"    , usr_path);
 229
 230                         break;
 231                 }
 232                 case ACTION_FOOTER:
 233                 {
 234                         break;
 235                 }
 236         }
 237 }
 238
 239 /****************************************************************************
 240 server info container display function
 241 ****************************************************************************/
 242 void display_srv_info_ctr(FILE *out_hnd, enum action_type action,SRV_INFO_CTR *ctr)
 243 {
 244         if (ctr == NULL || ctr->ptr_srv_ctr == 0)
 245         {
 246                 fprintf(out_hnd, "Server Information: unavailable due to an error\n");
 247                 return;
 248         }
 249
 250         switch (ctr->switch_value)
 251         {
 252                 case 101:
 253                 {
 254                         display_srv_info_101(out_hnd, action, &(ctr->srv.sv101));
 255                         break;
 256                 }
 257                 case 102:
 258                 {
 259                         display_srv_info_102(out_hnd, action, &(ctr->srv.sv102));
 260                         break;
 261                 }
 262                 default:
 263                 {
 264                         fprintf(out_hnd, "Server Information: Unknown Info Level\n");
 265                         break;
 266                 }
 267         }
 268 }
 269
 270 /****************************************************************************
 271 connection info level 0 display function
 272 ****************************************************************************/
 273 void display_conn_info_0(FILE *out_hnd, enum action_type action,
 274                 CONN_INFO_0 *info0)
 275 {
 276         if (info0 == NULL)
 277         {
 278                 return;
 279         }
 280
 281         switch (action)
 282         {
 283                 case ACTION_HEADER:
 284                 {
 285                         fprintf(out_hnd, "Connection Info Level 0:\n");
 286
 287                         break;
 288                 }
 289                 case ACTION_ENUMERATE:
 290                 {
 291                         fprintf(out_hnd, "\tid: %d\n", info0->id);
 292
 293                         break;
 294                 }
 295                 case ACTION_FOOTER:
 296                 {
 297                         fprintf(out_hnd, "\n");
 298                         break;
 299                 }
 300         }
 301
 302 }
 303
 304 /****************************************************************************
 305 connection info level 1 display function
 306 ****************************************************************************/
 307 void display_conn_info_1(FILE *out_hnd, enum action_type action,
 308                 CONN_INFO_1 *info1, CONN_INFO_1_STR *str1)
 309 {
 310         if (info1 == NULL || str1 == NULL)
 311         {
 312                 return;
 313         }
 314
 315         switch (action)
 316         {
 317                 case ACTION_HEADER:
 318                 {
 319                         fprintf(out_hnd, "Connection Info Level 1:\n");
 320
 321                         break;
 322                 }
 323                 case ACTION_ENUMERATE:
 324                 {
 325                         fstring usr_name;
 326                         fstring net_name;
 327
 328                         rpcstr_pull(usr_name, str1->uni_usr_name.buffer, sizeof(usr_name), str1->uni_usr_name.uni_str_len*2,0);
 329                         rpcstr_pull(net_name, str1->uni_net_name.buffer, sizeof(net_name), str1->uni_net_name.uni_str_len*2,0);
 330
 331                         fprintf(out_hnd, "\tid       : %d\n", info1->id);
 332                         fprintf(out_hnd, "\ttype     : %s\n", get_share_type_str(info1->type));
 333                         fprintf(out_hnd, "\tnum_opens: %d\n", info1->num_opens);
 334                         fprintf(out_hnd, "\tnum_users: %d\n", info1->num_users);
 335                         fprintf(out_hnd, "\topen_time: %d\n", info1->open_time);
 336
 337                         fprintf(out_hnd, "\tuser name: %s\n", usr_name);
 338                         fprintf(out_hnd, "\tnet  name: %s\n", net_name);
 339
 340                         break;
 341                 }
 342                 case ACTION_FOOTER:
 343                 {
 344                         fprintf(out_hnd, "\n");
 345                         break;
 346                 }
 347         }
 348
 349 }
 350
 351 /****************************************************************************
 352 connection info level 0 container display function
 353 ****************************************************************************/
 354 void display_srv_conn_info_0_ctr(FILE *out_hnd, enum action_type action,
 355                                 SRV_CONN_INFO_0 *ctr)
 356 {
 357         if (ctr == NULL)
 358         {
 359                 fprintf(out_hnd, "display_srv_conn_info_0_ctr: unavailable due to an internal error\n");
 360                 return;
 361         }
 362
 363         switch (action)
 364         {
 365                 case ACTION_HEADER:
 366                 {
 367                         break;
 368                 }
 369                 case ACTION_ENUMERATE:
 370                 {
 371                         int i;
 372
 373                         for (i = 0; i < ctr->num_entries_read; i++)
 374                         {
 375                                 display_conn_info_0(out_hnd, ACTION_HEADER   , &(ctr->info_0[i]));
 376                                 display_conn_info_0(out_hnd, ACTION_ENUMERATE, &(ctr->info_0[i]));
 377                                 display_conn_info_0(out_hnd, ACTION_FOOTER   , &(ctr->info_0[i]));
 378                         }
 379                         break;
 380                 }
 381                 case ACTION_FOOTER:
 382                 {
 383                         break;
 384                 }
 385         }
 386 }
 387
 388 /****************************************************************************
 389 connection info level 1 container display function
 390 ****************************************************************************/
 391 void display_srv_conn_info_1_ctr(FILE *out_hnd, enum action_type action,
 392                                 SRV_CONN_INFO_1 *ctr)
 393 {
 394         if (ctr == NULL)
 395         {
 396                 fprintf(out_hnd, "display_srv_conn_info_1_ctr: unavailable due to an internal error\n");
 397                 return;
 398         }
 399
 400         switch (action)
 401         {
 402                 case ACTION_HEADER:
 403                 {
 404                         break;
 405                 }
 406                 case ACTION_ENUMERATE:
 407                 {
 408                         int i;
 409
 410                         for (i = 0; i < ctr->num_entries_read; i++)
 411                         {
 412                                 display_conn_info_1(out_hnd, ACTION_HEADER   , &(ctr->info_1[i]), &(ctr->info_1_str[i]));
 413                                 display_conn_info_1(out_hnd, ACTION_ENUMERATE, &(ctr->info_1[i]), &(ctr->info_1_str[i]));
 414                                 display_conn_info_1(out_hnd, ACTION_FOOTER   , &(ctr->info_1[i]), &(ctr->info_1_str[i]));
 415                         }
 416                         break;
 417                 }
 418                 case ACTION_FOOTER:
 419                 {
 420                         break;
 421                 }
 422         }
 423 }
 424
 425 /****************************************************************************
 426 connection info container display function
 427 ****************************************************************************/
 428 void display_srv_conn_info_ctr(FILE *out_hnd, enum action_type action,
 429                                 SRV_CONN_INFO_CTR *ctr)
 430 {
 431         if (ctr == NULL || ctr->ptr_conn_ctr == 0)
 432         {
 433                 fprintf(out_hnd, "display_srv_conn_info_ctr: unavailable due to an internal error\n");
 434                 return;
 435         }
 436
 437         switch (ctr->switch_value)
 438         {
 439                 case 0:
 440                 {
 441                         display_srv_conn_info_0_ctr(out_hnd, action,
 442                                            &(ctr->conn.info0));
 443                         break;
 444                 }
 445                 case 1:
 446                 {
 447                         display_srv_conn_info_1_ctr(out_hnd, action,
 448                                            &(ctr->conn.info1));
 449                         break;
 450                 }
 451                 default:
 452                 {
 453                         fprintf(out_hnd, "display_srv_conn_info_ctr: Unknown Info Level\n");
 454                         break;
 455                 }
 456         }
 457 }
 458
 459
 460 /****************************************************************************
 461 share info level 1 display function
 462 ****************************************************************************/
 463 void display_share_info_1(FILE *out_hnd, enum action_type action,
 464                           SRV_SHARE_INFO_1 *info1)
 465 {
 466         if (info1 == NULL)
 467         {
 468                 return;
 469         }
 470
 471         switch (action)
 472         {
 473                 case ACTION_HEADER:
 474                 {
 475                         fprintf(out_hnd, "Share Info Level 1:\n");
 476
 477                         break;
 478                 }
 479                 case ACTION_ENUMERATE:
 480                 {
 481                         fstring remark  ;
 482                         fstring net_name;
 483
 484                         rpcstr_pull(net_name, info1->info_1_str.uni_netname.buffer, sizeof(net_name), info1->info_1_str.uni_netname.uni_str_len*2, 0);
 485                         rpcstr_pull(remark, info1->info_1_str.uni_remark.buffer, sizeof(remark), info1->info_1_str.uni_remark.uni_str_len*2, 0);
 486
 487                         display_share(out_hnd, action, net_name, info1->info_1.type, remark);
 488
 489                         break;
 490                 }
 491                 case ACTION_FOOTER:
 492                 {
 493                         fprintf(out_hnd, "\n");
 494                         break;
 495                 }
 496         }
 497
 498 }
 499
 500 /****************************************************************************
 501 share info level 2 display function
 502 ****************************************************************************/
 503 void display_share_info_2(FILE *out_hnd, enum action_type action,
 504                           SRV_SHARE_INFO_2 *info2)
 505 {
 506         if (info2 == NULL)
 507         {
 508                 return;
 509         }
 510
 511         switch (action)
 512         {
 513                 case ACTION_HEADER:
 514                 {
 515                         fprintf(out_hnd, "Share Info Level 2:\n");
 516
 517                         break;
 518                 }
 519                 case ACTION_ENUMERATE:
 520                 {
 521                         fstring remark  ;
 522                         fstring net_name;
 523                         fstring path    ;
 524                         fstring passwd  ;
 525
 526                         rpcstr_pull(net_name, info2->info_2_str.uni_netname.buffer, sizeof(net_name), info2->info_2_str.uni_netname.uni_str_len*2, 0);
 527                         rpcstr_pull(remark, info2->info_2_str.uni_remark.buffer, sizeof(remark), info2->info_2_str.uni_remark.uni_str_len*2, 0);
 528                         rpcstr_pull(path, info2->info_2_str.uni_path.buffer, sizeof(path), info2->info_2_str.uni_path.uni_str_len*2, 0);
 529                         rpcstr_pull(passwd, info2->info_2_str.uni_passwd.buffer, sizeof(passwd), info2->info_2_str.uni_passwd.uni_str_len*2, 0);
 530
 531                         display_share2(out_hnd, action, net_name,
 532                               info2->info_2.type, remark, info2->info_2.perms,
 533                               info2->info_2.max_uses, info2->info_2.num_uses,
 534                               path, passwd);
 535
 536                         break;
 537                 }
 538                 case ACTION_FOOTER:
 539                 {
 540                         fprintf(out_hnd, "\n");
 541                         break;
 542                 }
 543         }
 544
 545 }
 546
 547 /****************************************************************************
 548 share info container display function
 549 ****************************************************************************/
 550 void display_srv_share_info_ctr(FILE *out_hnd, enum action_type action,
 551                                 SRV_SHARE_INFO_CTR *ctr)
 552 {
 553         if (ctr == NULL)
 554         {
 555                 fprintf(out_hnd, "display_srv_share_info_ctr: unavailable due to an internal error\n");
 556         return;
 557         }
 558
 559         switch (action)
 560         {
 561                 case ACTION_HEADER:
 562                 {
 563                         break;
 564                 }
 565                 case ACTION_ENUMERATE:
 566                 {
 567                         int i;
 568
 569                         for (i = 0; i < ctr->num_entries; i++)
 570                         {
 571                                 switch (ctr->info_level) {
 572                                 case 1:
 573                                         display_share_info_1(out_hnd, ACTION_HEADER   , &(ctr->share.info1[i]));
 574                                         display_share_info_1(out_hnd, ACTION_ENUMERATE, &(ctr->share.info1[i]));
 575                                         display_share_info_1(out_hnd, ACTION_FOOTER   , &(ctr->share.info1[i]));
 576                                         break;
 577                                 case 2:
 578                                         display_share_info_2(out_hnd, ACTION_HEADER   , &(ctr->share.info2[i]));
 579                                         display_share_info_2(out_hnd, ACTION_ENUMERATE, &(ctr->share.info2[i]));
 580                                         display_share_info_2(out_hnd, ACTION_FOOTER   , &(ctr->share.info2[i]));
 581                                         break;
 582                                 default:
 583                                         fprintf(out_hnd, "display_srv_share_info_ctr: Unknown Info Level\n");
 584                                         break;
 585                                 }
 586                         }
 587                         break;
 588                 }
 589                 case ACTION_FOOTER:
 590                 {
 591                         break;
 592                 }
 593         }
 594 }
 595
 596 /****************************************************************************
 597 file info level 3 display function
 598 ****************************************************************************/
 599 void display_file_info_3(FILE *out_hnd, enum action_type action,
 600                 FILE_INFO_3 *info3, FILE_INFO_3_STR *str3)
 601 {
 602         if (info3 == NULL || str3 == NULL)
 603         {
 604                 return;
 605         }
 606
 607         switch (action)
 608         {
 609                 case ACTION_HEADER:
 610                 {
 611                         fprintf(out_hnd, "File Info Level 3:\n");
 612
 613                         break;
 614                 }
 615                 case ACTION_ENUMERATE:
 616                 {
 617                         fstring path_name;
 618                         fstring user_name;
 619
 620                         rpcstr_pull(path_name, str3->uni_path_name.buffer, sizeof(path_name), str3->uni_path_name.uni_str_len*2, 0);
 621                         rpcstr_pull(user_name, str3->uni_user_name.buffer, sizeof(user_name), str3->uni_user_name.uni_str_len*2, 0);
 622
 623                         fprintf(out_hnd, "\tid       : %d\n", info3->id);
 624                         fprintf(out_hnd, "\tperms    : %s\n", get_file_mode_str(info3->perms));
 625                         fprintf(out_hnd, "\tnum_locks: %d\n", info3->num_locks);
 626
 627                         fprintf(out_hnd, "\tpath name: %s\n", path_name);
 628                         fprintf(out_hnd, "\tuser name: %s\n", user_name);
 629
 630                         break;
 631                 }
 632                 case ACTION_FOOTER:
 633                 {
 634                         fprintf(out_hnd, "\n");
 635                         break;
 636                 }
 637         }
 638
 639 }
 640
 641 /****************************************************************************
 642 file info level 3 container display function
 643 ****************************************************************************/
 644 void display_srv_file_info_3_ctr(FILE *out_hnd, enum action_type action,
 645                                 SRV_FILE_INFO_3 *ctr)
 646 {
 647         if (ctr == NULL)
 648         {
 649                 fprintf(out_hnd, "display_srv_file_info_3_ctr: unavailable due to an internal error\n");
 650                 return;
 651         }
 652
 653         switch (action)
 654         {
 655                 case ACTION_HEADER:
 656                 {
 657                         break;
 658                 }
 659                 case ACTION_ENUMERATE:
 660                 {
 661                         int i;
 662
 663                         for (i = 0; i < ctr->num_entries_read; i++)
 664                         {
 665                                 display_file_info_3(out_hnd, ACTION_HEADER   , &(ctr->info_3[i]), &(ctr->info_3_str[i]));
 666                                 display_file_info_3(out_hnd, ACTION_ENUMERATE, &(ctr->info_3[i]), &(ctr->info_3_str[i]));
 667                                 display_file_info_3(out_hnd, ACTION_FOOTER   , &(ctr->info_3[i]), &(ctr->info_3_str[i]));
 668                         }
 669                         break;
 670                 }
 671                 case ACTION_FOOTER:
 672                 {
 673                         break;
 674                 }
 675         }
 676 }
 677
 678 /****************************************************************************
 679 file info container display function
 680 ****************************************************************************/
 681 void display_srv_file_info_ctr(FILE *out_hnd, enum action_type action,
 682                                 SRV_FILE_INFO_CTR *ctr)
 683 {
 684         if (ctr == NULL || ctr->ptr_file_ctr == 0)
 685         {
 686                 fprintf(out_hnd, "display_srv_file_info_ctr: unavailable due to an internal error\n");
 687                 return;
 688         }
 689
 690         switch (ctr->switch_value)
 691         {
 692                 case 3:
 693                 {
 694                         display_srv_file_info_3_ctr(out_hnd, action,
 695                                            &(ctr->file.info3));
 696                         break;
 697                 }
 698                 default:
 699                 {
 700                         fprintf(out_hnd, "display_srv_file_info_ctr: Unknown Info Level\n");
 701                         break;
 702                 }
 703         }
 704 }
 705
 706 /****************************************************************************
 707  print browse connection on a host
 708  ****************************************************************************/
 709 void display_server(FILE *out_hnd, enum action_type action,
 710                                 char *sname, uint32 type, char *comment)
 711 {
 712         switch (action)
 713         {
 714                 case ACTION_HEADER:
 715                 {
 716                         break;
 717                 }
 718                 case ACTION_ENUMERATE:
 719                 {
 720                         fprintf(out_hnd, "\t%-15.15s%-20s %s\n",
 721                                          sname, get_server_type_str(type), comment);
 722                         break;
 723                 }
 724                 case ACTION_FOOTER:
 725                 {
 726                         break;
 727                 }
 728         }
 729 }
 730
 731 /****************************************************************************
 732 print shares on a host
 733 ****************************************************************************/
 734 void display_share(FILE *out_hnd, enum action_type action,
 735                                 char *sname, uint32 type, char *comment)
 736 {
 737         switch (action)
 738         {
 739                 case ACTION_HEADER:
 740                 {
 741                         break;
 742                 }
 743                 case ACTION_ENUMERATE:
 744                 {
 745                         fprintf(out_hnd, "\t%-15.15s%-10.10s%s\n",
 746                                          sname, get_share_type_str(type), comment);
 747                         break;
 748                 }
 749                 case ACTION_FOOTER:
 750                 {
 751                         break;
 752                 }
 753         }
 754 }
 755
 756
 757 /****************************************************************************
 758 print shares on a host, level 2
 759 ****************************************************************************/
 760 void display_share2(FILE *out_hnd, enum action_type action,
 761                                 char *sname, uint32 type, char *comment,
 762                                 uint32 perms, uint32 max_uses, uint32 num_uses,
 763                                 char *path, char *passwd)
 764 {
 765         switch (action)
 766         {
 767                 case ACTION_HEADER:
 768                 {
 769                         break;
 770                 }
 771                 case ACTION_ENUMERATE:
 772                 {
 773                         fprintf(out_hnd, "\t%-15.15s%-10.10s%s %x %x %x %s %s\n",
 774                                          sname, get_share_type_str(type), comment,
 775                                          perms, max_uses, num_uses, path, passwd);
 776                         break;
 777                 }
 778                 case ACTION_FOOTER:
 779                 {
 780                         break;
 781                 }
 782         }
 783 }
 784
 785
 786 /****************************************************************************
 787 print name info
 788 ****************************************************************************/
 789 void display_name(FILE *out_hnd, enum action_type action,
 790                                 char *sname)
 791 {
 792         switch (action)
 793         {
 794                 case ACTION_HEADER:
 795                 {
 796                         break;
 797                 }
 798                 case ACTION_ENUMERATE:
 799                 {
 800                         fprintf(out_hnd, "\t%-21.21s\n", sname);
 801                         break;
 802                 }
 803                 case ACTION_FOOTER:
 804                 {
 805                         break;
 806                 }
 807         }
 808 }
 809
 810
 811 /****************************************************************************
 812  display group rid info
 813  ****************************************************************************/
 814 void display_group_rid_info(FILE *out_hnd, enum action_type action,
 815                                 uint32 num_gids, DOM_GID *gid)
 816 {
 817         switch (action)
 818         {
 819                 case ACTION_HEADER:
 820                 {
 821                         if (num_gids == 0)
 822                         {
 823                                 fprintf(out_hnd, "\tNo Groups\n");
 824                         }
 825                         else
 826                         {
 827                                 fprintf(out_hnd, "\tGroup Info\n");
 828                                 fprintf(out_hnd, "\t----------\n");
 829                         }
 830                         break;
 831                 }
 832                 case ACTION_ENUMERATE:
 833                 {
 834                         int i;
 835
 836                         for (i = 0; i < num_gids; i++)
 837                         {
 838                                 fprintf(out_hnd, "\tGroup RID: %8x attr: %x\n",
 839                                                                   gid[i].g_rid, gid[i].attr);
 840                         }
 841
 842                         break;
 843                 }
 844                 case ACTION_FOOTER:
 845                 {
 846                         fprintf(out_hnd, "\n");
 847                         break;
 848                 }
 849         }
 850 }
 851
 852
 853 /****************************************************************************
 854  display alias name info
 855  ****************************************************************************/
 856 void display_alias_name_info(FILE *out_hnd, enum action_type action,
 857                                 uint32 num_aliases, fstring *alias_name, uint32 *num_als_usrs)
 858 {
 859         switch (action)
 860         {
 861                 case ACTION_HEADER:
 862                 {
 863                         if (num_aliases == 0)
 864                         {
 865                                 fprintf(out_hnd, "\tNo Aliases\n");
 866                         }
 867                         else
 868                         {
 869                                 fprintf(out_hnd, "\tAlias Names\n");
 870                                 fprintf(out_hnd, "\t----------- \n");
 871                         }
 872                         break;
 873                 }
 874                 case ACTION_ENUMERATE:
 875                 {
 876                         int i;
 877
 878                         for (i = 0; i < num_aliases; i++)
 879                         {
 880                                 fprintf(out_hnd, "\tAlias Name: %s Attributes: %3d\n",
 881                                                                   alias_name[i], num_als_usrs[i]);
 882                         }
 883
 884                         break;
 885                 }
 886                 case ACTION_FOOTER:
 887                 {
 888                         fprintf(out_hnd, "\n");
 889                         break;
 890                 }
 891         }
 892 }
 893
 894
 895 /****************************************************************************
 896  display sam_user_info_21 structure
 897  ****************************************************************************/
 898 void display_sam_user_info_21(FILE *out_hnd, enum action_type action, SAM_USER_INFO_21 *usr)
 899 {
 900         switch (action)
 901         {
 902                 case ACTION_HEADER:
 903                 {
 904                         fprintf(out_hnd, "\tUser Info, Level 0x15\n");
 905                         fprintf(out_hnd, "\t---------------------\n");
 906
 907                         break;
 908                 }
 909                 case ACTION_ENUMERATE:
 910                 {
 911                         pstring tmp;
 912                         rpcstr_pull(tmp, usr->uni_user_name.buffer, sizeof(tmp),usr->uni_user_name.uni_str_len*2, 0);
 913                         fprintf(out_hnd, "\t\tUser Name   : %s\n", tmp); /* username unicode string */
 914                         rpcstr_pull(tmp, usr->uni_full_name.buffer, sizeof(tmp),usr->uni_full_name.uni_str_len*2, 0);
 915                         fprintf(out_hnd, "\t\tFull Name   : %s\n", tmp); /* user's full name unicode string */
 916                         rpcstr_pull(tmp, usr->uni_home_dir.buffer, sizeof(tmp),usr->uni_home_dir.uni_str_len*2, 0);
 917                         fprintf(out_hnd, "\t\tHome Drive  : %s\n", tmp); /* home directory unicode string */
 918                         rpcstr_pull(tmp, usr->uni_dir_drive.buffer, sizeof(tmp),usr->uni_dir_drive.uni_str_len*2, 0);
 919                         fprintf(out_hnd, "\t\tDir Drive   : %s\n", tmp); /* home directory drive unicode string */
 920                         rpcstr_pull(tmp, usr->uni_profile_path.buffer, sizeof(tmp),usr->uni_profile_path.uni_str_len*2, 0);
 921                         fprintf(out_hnd, "\t\tProfile Path: %s\n", tmp); /* profile path unicode string */
 922                         rpcstr_pull(tmp, usr->uni_logon_script.buffer, sizeof(tmp),usr->uni_logon_script.uni_str_len*2, 0);
 923                         fprintf(out_hnd, "\t\tLogon Script: %s\n", tmp); /* logon script unicode string */
 924                         rpcstr_pull(tmp, usr->uni_acct_desc.buffer, sizeof(tmp),usr->uni_acct_desc.uni_str_len*2, 0);
 925                         fprintf(out_hnd, "\t\tDescription : %s\n", tmp); /* user description unicode string */
 926                         rpcstr_pull(tmp, usr->uni_workstations.buffer, sizeof(tmp),usr->uni_workstations.uni_str_len*2, 0);
 927                         fprintf(out_hnd, "\t\tWorkstations: %s\n", tmp); /* workstaions unicode string */
 928                         rpcstr_pull(tmp, usr->uni_unknows_str.buffer, sizeof(tmp),usr->uni_unknown_str.uni_str_len*2, 0);
 929                         fprintf(out_hnd, "\t\tUnknown Str : %s\n", tmp); /* unknown string unicode string */
 930                         rpcstr_pull(tmp, usr->uni_munged_dial.buffer, sizeof(tmp),usr->uni_munged_dial.uni_str_len*2, 0);
 931                         fprintf(out_hnd, "\t\tRemote Dial : %s\n", tmp); /* munged remote access unicode string */
 932
 933                         fprintf(out_hnd, "\t\tLogon Time               : %s\n", http_timestring(nt_time_to_unix(&(usr->logon_time           ))));
 934                         fprintf(out_hnd, "\t\tLogoff Time              : %s\n", http_timestring(nt_time_to_unix(&(usr->logoff_time          ))));
 935                         fprintf(out_hnd, "\t\tKickoff Time             : %s\n", http_timestring(nt_time_to_unix(&(usr->kickoff_time         ))));
 936                         fprintf(out_hnd, "\t\tPassword last set Time   : %s\n", http_timestring(nt_time_to_unix(&(usr->pass_last_set_time   ))));
 937                         fprintf(out_hnd, "\t\tPassword can change Time : %s\n", http_timestring(nt_time_to_unix(&(usr->pass_can_change_time ))));
 938                         fprintf(out_hnd, "\t\tPassword must change Time: %s\n", http_timestring(nt_time_to_unix(&(usr->pass_must_change_time))));
 939
 940                         fprintf(out_hnd, "\t\tunknown_2[0..31]...\n"); /* user passwords? */
 941
 942                         fprintf(out_hnd, "\t\tuser_rid : %x\n"  , usr->user_rid ); /* User ID */
 943                         fprintf(out_hnd, "\t\tgroup_rid: %x\n"  , usr->group_rid); /* Group ID */
 944                         fprintf(out_hnd, "\t\tacb_info : %04x\n", usr->acb_info ); /* Account Control Info */
 945
 946                         fprintf(out_hnd, "\t\tunknown_3: %08x\n", usr->unknown_3); /* 0x00ff ffff */
 947                         fprintf(out_hnd, "\t\tlogon_divs: %d\n", usr->logon_divs); /* 0x0000 00a8 which is 168 which is num hrs in a week */
 948                         fprintf(out_hnd, "\t\tunknown_5: %08x\n", usr->unknown_5); /* 0x0002 0000 */
 949
 950                         fprintf(out_hnd, "\t\tpadding1[0..7]...\n");
 951
 952                         if (usr->ptr_logon_hrs)
 953                         {
 954                                 fprintf(out_hnd, "\t\tlogon_hrs[0..%d]...\n", usr->logon_hrs.len);
 955                         }
 956
 957                         break;
 958                 }
 959                 case ACTION_FOOTER:
 960                 {
 961                         fprintf(out_hnd, "\n");
 962                         break;
 963                 }
 964         }
 965 }
 966
 967
 968 /****************************************************************************
 969 convert a security permissions into a string
 970 ****************************************************************************/
 971 char *get_sec_mask_str(uint32 type)
 972 {
 973         static fstring typestr;
 974         int i;
 975
 976         switch (type)
 977         {
 978                 case SEC_RIGHTS_FULL_CONTROL:
 979                 {
 980                         fstrcpy(typestr, "Full Control");
 981                         return typestr;
 982                 }
 983
 984                 case SEC_RIGHTS_READ:
 985                 {
 986                         fstrcpy(typestr, "Read");
 987                         return typestr;
 988                 }
 989                 default:
 990                 {
 991                         break;
 992                 }
 993         }
 994
 995         typestr[0] = 0;
 996         for (i = 0; i < 32; i++)
 997         {
 998                 if (type & (1 << i))
 999                 {
1000                         switch (((unsigned)1) << i)
1001                         {
1002                                 case SEC_RIGHTS_QUERY_VALUE    : fstrcat(typestr, "Query " ); break;
1003                                 case SEC_RIGHTS_SET_VALUE      : fstrcat(typestr, "Set " ); break;
1004                                 case SEC_RIGHTS_CREATE_SUBKEY  : fstrcat(typestr, "Create "); break;
1005                                 case SEC_RIGHTS_ENUM_SUBKEYS   : fstrcat(typestr, "Enum "); break;
1006                                 case SEC_RIGHTS_NOTIFY         : fstrcat(typestr, "Notify "); break;
1007                                 case SEC_RIGHTS_CREATE_LINK    : fstrcat(typestr, "CreateLink "); break;
1008                                 case SEC_RIGHTS_DELETE         : fstrcat(typestr, "Delete "); break;
1009                                 case SEC_RIGHTS_READ_CONTROL   : fstrcat(typestr, "ReadControl "); break;
1010                                 case SEC_RIGHTS_WRITE_DAC      : fstrcat(typestr, "WriteDAC "); break;
1011                                 case SEC_RIGHTS_WRITE_OWNER    : fstrcat(typestr, "WriteOwner "); break;
1012                         }
1013                         type &= ~(1 << i);
1014                 }
1015         }
1016
1017         /* remaining bits get added on as-is */
1018         if (type != 0)
1019         {
1020                 fstring tmp;
1021                 slprintf(tmp, sizeof(tmp)-1, "[%08x]", type);
1022                 fstrcat(typestr, tmp);
1023         }
1024
1025         /* remove last space */
1026         i = strlen(typestr)-1;
1027         if (typestr[i] == ' ') typestr[i] = 0;
1028
1029         return typestr;
1030 }
1031
1032 /****************************************************************************
1033  display sec_access structure
1034  ****************************************************************************/
1035 void display_sec_access(FILE *out_hnd, enum action_type action, SEC_ACCESS *info)
1036 {
1037         switch (action)
1038         {
1039                 case ACTION_HEADER:
1040                 {
1041                         break;
1042                 }
1043                 case ACTION_ENUMERATE:
1044                 {
1045                         fprintf(out_hnd, "\t\tPermissions: %s\n",
1046                                 get_sec_mask_str(info->mask));
1047                 }
1048                 case ACTION_FOOTER:
1049                 {
1050                         break;
1051                 }
1052         }
1053 }
1054
1055 /****************************************************************************
1056  display sec_ace structure
1057  ****************************************************************************/
1058 void display_sec_ace(FILE *out_hnd, enum action_type action, SEC_ACE *ace)
1059 {
1060         switch (action)
1061         {
1062                 case ACTION_HEADER:
1063                 {
1064                         fprintf(out_hnd, "\tACE\n");
1065                         break;
1066                 }
1067                 case ACTION_ENUMERATE:
1068                 {
1069                         fstring sid_str;
1070
1071                         display_sec_access(out_hnd, ACTION_HEADER   , &ace->info);
1072                         display_sec_access(out_hnd, ACTION_ENUMERATE, &ace->info);
1073                         display_sec_access(out_hnd, ACTION_FOOTER   , &ace->info);
1074
1075                         sid_to_string(sid_str, &ace->sid);
1076                         fprintf(out_hnd, "\t\tSID: %s\n", sid_str);
1077                 }
1078                 case ACTION_FOOTER:
1079                 {
1080                         break;
1081                 }
1082         }
1083 }
1084
1085 /****************************************************************************
1086  display sec_acl structure
1087  ****************************************************************************/
1088 void display_sec_acl(FILE *out_hnd, enum action_type action, SEC_ACL *sec_acl)
1089 {
1090         switch (action)
1091         {
1092                 case ACTION_HEADER:
1093                 {
1094                         fprintf(out_hnd, "\tACL\tNum ACEs:\t%d\trevision:\t%x\n",
1095                                          sec_acl->num_aces, sec_acl->revision);
1096                         fprintf(out_hnd, "\t---\n");
1097
1098                         break;
1099                 }
1100                 case ACTION_ENUMERATE:
1101                 {
1102                         if (sec_acl->size != 0 && sec_acl->num_aces != 0)
1103                         {
1104                                 int i;
1105                                 for (i = 0; i < sec_acl->num_aces; i++)
1106                                 {
1107                                         display_sec_ace(out_hnd, ACTION_HEADER   , &sec_acl->ace[i]);
1108                                         display_sec_ace(out_hnd, ACTION_ENUMERATE, &sec_acl->ace[i]);
1109                                         display_sec_ace(out_hnd, ACTION_FOOTER   , &sec_acl->ace[i]);
1110                                 }
1111                         }
1112
1113                         break;
1114                 }
1115                 case ACTION_FOOTER:
1116                 {
1117                         fprintf(out_hnd, "\n");
1118                         break;
1119                 }
1120         }
1121 }
1122
1123 /****************************************************************************
1124  display sec_desc structure
1125  ****************************************************************************/
1126 void display_sec_desc(FILE *out_hnd, enum action_type action, SEC_DESC *sec)
1127 {
1128         switch (action)
1129         {
1130                 case ACTION_HEADER:
1131                 {
1132                         fprintf(out_hnd, "\tSecurity Descriptor\trevision:\t%x\ttype:\t%x\n",
1133                                          sec->revision, sec->type);
1134                         fprintf(out_hnd, "\t-------------------\n");
1135
1136                         break;
1137                 }
1138                 case ACTION_ENUMERATE:
1139                 {
1140                         fstring sid_str;
1141
1142                         if (sec->off_sacl != 0)
1143                         {
1144                                 display_sec_acl(out_hnd, ACTION_HEADER   , sec->sacl);
1145                                 display_sec_acl(out_hnd, ACTION_ENUMERATE, sec->sacl);
1146                                 display_sec_acl(out_hnd, ACTION_FOOTER   , sec->sacl);
1147                         }
1148                         if (sec->off_dacl != 0)
1149                         {
1150                                 display_sec_acl(out_hnd, ACTION_HEADER   , sec->dacl);
1151                                 display_sec_acl(out_hnd, ACTION_ENUMERATE, sec->dacl);
1152                                 display_sec_acl(out_hnd, ACTION_FOOTER   , sec->dacl);
1153                         }
1154                         if (sec->off_owner_sid != 0)
1155                         {
1156                                 sid_to_string(sid_str, sec->owner_sid);
1157                                 fprintf(out_hnd, "\tOwner SID:\t%s\n", sid_str);
1158                         }
1159                         if (sec->off_grp_sid != 0)
1160                         {
1161                                 sid_to_string(sid_str, sec->grp_sid);
1162                                 fprintf(out_hnd, "\tParent SID:\t%s\n", sid_str);
1163                         }
1164
1165                         break;
1166                 }
1167                 case ACTION_FOOTER:
1168                 {
1169                         fprintf(out_hnd, "\n");
1170                         break;
1171                 }
1172         }
1173 }
1174
1175 /****************************************************************************
1176 convert a security permissions into a string
1177 ****************************************************************************/
1178 char *get_reg_val_type_str(uint32 type)
1179 {
1180         static fstring typestr;
1181
1182         switch (type)
1183         {
1184                 case 0x01:
1185                 {
1186                         fstrcpy(typestr, "string");
1187                         return typestr;
1188                 }
1189
1190                 case 0x03:
1191                 {
1192                         fstrcpy(typestr, "bytes");
1193                         return typestr;
1194                 }
1195
1196                 case 0x04:
1197                 {
1198                         fstrcpy(typestr, "uint32");
1199                         return typestr;
1200                 }
1201
1202                 case 0x07:
1203                 {
1204                         fstrcpy(typestr, "multi");
1205                         return typestr;
1206                 }
1207                 default:
1208                 {
1209                         break;
1210                 }
1211         }
1212         slprintf(typestr, sizeof(typestr)-1, "[%d]", type);
1213         return typestr;
1214 }
1215
1216
1217 static void print_reg_value(FILE *out_hnd, char *val_name, uint32 val_type, BUFFER2 *value)
1218 {
1219         fstring type;
1220         pstring intvalue;
1221         fstrcpy(type, get_reg_val_type_str(val_type));
1222
1223         switch (val_type)
1224         {
1225                 case 0x01: /* unistr */
1226                 {
1227                         rpcstr_pull(intvalue, value->buffer, sizeof(intvalue), value->buf_len, 0);
1228                         /*fprintf(out_hnd,"\t%s:\t%s:\t%s\n", val_name, type, dos_buffer2_to_str(value));*/
1229                         fprintf(out_hnd,"\t%s:\t%s:\t%s\n", val_name, type, value);
1230                         break;
1231                 }
1232
1233                 default: /* unknown */
1234                 case 0x03: /* bytes */
1235                 {
1236                         if (value->buf_len <= 8)
1237                         {
1238                                 fprintf(out_hnd,"\t%s:\t%s:\t", val_name, type);
1239                                 out_data(out_hnd, (char*)value->buffer, value->buf_len, 8);
1240                         }
1241                         else
1242                         {
1243                                 fprintf(out_hnd,"\t%s:\t%s:\n", val_name, type);
1244                                 out_data(out_hnd, (char*)value->buffer, value->buf_len, 16);
1245                         }
1246                         break;
1247                 }
1248
1249                 case 0x04: /* uint32 */
1250                 {
1251                         fprintf(out_hnd,"\t%s:\t%s: 0x%08x\n", val_name, type, buffer2_to_uint32(value));
1252                         break;
1253                 }
1254
1255                 case 0x07: /* multiunistr */
1256                 {
1257                         fprintf(out_hnd,"\t%s:\t%s:\t%s\n", val_name, type, dos_buffer2_to_multistr(value));
1258                         break;
1259                 }
1260         }
1261 }
1262
1263 /****************************************************************************
1264  display structure
1265  ****************************************************************************/
1266 void display_reg_value_info(FILE *out_hnd, enum action_type action,
1267                                 char *val_name, uint32 val_type, BUFFER2 *value)
1268 {
1269         switch (action)
1270         {
1271                 case ACTION_HEADER:
1272                 {
1273                         break;
1274                 }
1275                 case ACTION_ENUMERATE:
1276                 {
1277                         print_reg_value(out_hnd, val_name, val_type, value);
1278                         break;
1279                 }
1280                 case ACTION_FOOTER:
1281                 {
1282                         break;
1283                 }
1284         }
1285 }
1286
1287 /****************************************************************************
1288  display structure
1289  ****************************************************************************/
1290 void display_reg_key_info(FILE *out_hnd, enum action_type action,
1291                                 char *key_name, time_t key_mod_time)
1292 {
1293         switch (action)
1294         {
1295                 case ACTION_HEADER:
1296                 {
1297                         break;
1298                 }
1299                 case ACTION_ENUMERATE:
1300                 {
1301                         fprintf(out_hnd, "\t%s\t(%s)\n",
1302                                 key_name, http_timestring(key_mod_time));
1303                         break;
1304                 }
1305                 case ACTION_FOOTER:
1306                 {
1307                         break;
1308                 }
1309         }
1310 }
1311
1312 #if COPY_THIS_TEMPLATE
1313 /****************************************************************************
1314  display structure
1315  ****************************************************************************/
1316  void display_(FILE *out_hnd, enum action_type action, *)
1317 {
1318         switch (action)
1319         {
1320                 case ACTION_HEADER:
1321                 {
1322                         fprintf(out_hnd, "\t\n");
1323                         fprintf(out_hnd, "\t-------------------\n");
1324
1325                         break;
1326                 }
1327                 case ACTION_ENUMERATE:
1328                 {
1329                         break;
1330                 }
1331                 case ACTION_FOOTER:
1332                 {
1333                         fprintf(out_hnd, "\n");
1334                         break;
1335                 }
1336         }
1337 }
1338
1339 #endif