Example: Listing subdirectories

This ILE C program creates a report listing the subdirectories of a directory.

You should call this program with only one parameter, the parameter that represents the directory you want to list.

Note: By using the code examples, you agree to the terms of the Code license and disclaimer information.
/******************************************************************/
/******************************************************************/
/* FUNCTION:                            */
/*                                                                */
/* LANGUAGE:  ILE C                                    */
/*                                                                */
/*                                                                */
/* APIs USED:  QHFOPNDR, QHFRDDR, QHFCLODR                        */
/*                                                                */
/******************************************************************/
/******************************************************************/

/******************************************************************/
/* INCLUDE FILES                                                  */
/******************************************************************/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <qhfopndr.h>
#include <qhfrddr.h>
#include <qhfclodr.h>
#include <qusec.h>

char    write_string[100];
FILE    *stream;

void print_subdir(char name[100], int numtabs)
{

/******************************************************************/
/* Parameters for QHFOPNDR                                        */
/******************************************************************/
char   dir_handle[16];           /* Directory handle              */
int    namelen;                  /* Length of path name           */
char   openinfo[6];              /* Open information              */

typedef struct {
        Qhf_Attr_Selec_Tbl_t fixed;
        int                 att_len;
        char                att_name[8];
} selection_struct;

selection_struct select;
int              selectionlen;

/******************************************************************/
/* Error Code Structure                                           */
/*                                                                */
/* This shows how the user can define the variable length         */
/* portion of error code for the exception data.                  */
/*                                                                */
/******************************************************************/
typedef struct {
     Qus_EC_t   ec_fields;
     char       Exception_Data[100];
        } error_code_t;

error_code_t  error_code;

/******************************************************************/
/* Parameters for QHFRDDR                                         */
/******************************************************************/
/* The directory handle is the same as for QHFOPNDR               */

typedef struct {
        Qhf_Data_Buffer_t   fixed;
        int                 num_att;
        int                 offsets[2];
        char                attinfo[180];
} read_buffer;

read_buffer buffer;
int    result_count;
int    bytes_returned;

/******************************************************************/
/* Parameters for QHFCLODR                                        */
/******************************************************************/
/* No additional ones need to be declared                         */

/******************************************************************/
/* Other declarations                                             */
/******************************************************************/
char   *att;
char   attname[30];
char   attval[30];
int    attnamelen;
int    attvallen;
char   newname[30];
int    newnamelen;
int    filesize;
char   fileatt[10];
char   tab[5];
int    bytes_used;
int    i, j;
char   charbin4[4];
char   tempname[100];

  error_code.ec_fields.Bytes_Provided = 0;

  /****************************************************************/
  /* Build the attribute selection table for QHFOPNDR.            */
  /****************************************************************/
  select.fixed.Number_Attributes = 1;
  select.fixed.Offset_First_Attr = 8;
  select.att_len = 8;
  memcpy(select.att_name, "QFILATTR", 8);
  selectionlen = 20;
  memcpy(openinfo, "10    ", 6);
  memcpy(tab,"     ", 5);

  /****************************************************************/
  /* Find the length of the directory name.                       */
  /****************************************************************/
  for(i=0;i<100;i++)
  {
    if((name[i] == ' ') || (name[i] == '\x00'))
      break;
  }
  namelen = i;

  /****************************************************************/
  /* Open the directory.                                          */
  /****************************************************************/
  QHFOPNDR(dir_handle, name, namelen, openinfo, &select, selectionlen,
           &error_code);

  /****************************************************************/
  /* Read one entry from the directory.                           */
  /****************************************************************/
  QHFRDDR(dir_handle, &buffer, 200, 1, &result_count, &bytes_returned,
          &error_code);

  fprintf(stream,"\n");
  for(i=0;i<numtabs;i++)
    fprintf(stream, tab);
  fprintf(stream, name);

  while(result_count > 0)
  {
    memcpy(attname,"                              ",30);
    memcpy(attval,"                              ",30);
    att = buffer.attinfo;
    bytes_used = 12;

    /**************************************************************/
    /* Loop for the number of attributes in the entry.            */
    /**************************************************************/
    for(i=0;i<buffer.num_att;i++)
    {
      memcpy(charbin4, att, 4);
      attnamelen = *(int *)charbin4;
      att += 4;
      bytes_used += 4;
      memcpy(charbin4, att, 4);
      attvallen = *(int *)charbin4;
      att += 8;
      bytes_used += 8;
      memcpy(attname, att, attnamelen);
      att += attnamelen;
      bytes_used += attnamelen;
      memcpy(attval, att, attvallen);
      att += attvallen;
      bytes_used += attvallen;

      /************************************************************/
      /* Update att so that its first character is the first      */
      /* character of the next attribute entry.                   */
      /************************************************************/
      if ((bytes_used == buffer.offsets[i+1]) &&
          ((i+1) == buffer.num_att))
        att += (buffer.offsets[i] - bytes_used);

      /************************************************************/
      /* If the attribute is QNAME, then set newname and          */
      /* newnamelen just in case the entry is a directory.        */
      /************************************************************/
      if(!memcmp(attname, "QNAME", 5))
      {
        memcpy(newname, attval, attvallen);
        newnamelen = attvallen;
      }

      /************************************************************/
      /* Else the attribute was QFILATTR, so set fileatt.         */
      /************************************************************/
      else
        memcpy(fileatt, attval, 10);
    }

    /**************************************************************/
    /* If the entry was a directory, construct new path name and  */
    /* print_subdir to print the subdirectory.                    */
    /**************************************************************/
    if(fileatt[3] == '1')
    {
      memcpy(tempname, name, 100);
      strcat(name, "/");
      strcat(name, newname);
      memcpy(newname, name, namelen + newnamelen + 1);
      print_subdir(newname, numtabs + 1);
      memcpy(name, tempname, 100);
    }

    QHFRDDR(dir_handle, &buffer, 200, 1, &result_count, &bytes_returned,
            &error_code);

  } /* while */

  /****************************************************************/
  /* Close the directory.                                         */
  /****************************************************************/
  QHFCLODR(dir_handle, &error_code);

}/* print_subdir */


main(int argc, char *argv[])
{
  char    dir_name[100];

  /****************************************************************/
  /* Make sure we received the correct number of parameters. The  */
  /* argc parameter will contain the number of parameters that    */
  /* was passed to this program. This number also includes the    */
  /* program itself, so we need to evaluate argc-1.               */
  /****************************************************************/

  if (((argc - 1) < 1) || ((argc - 1 > 1)))
  /****************************************************************/
  /* We did not receive all of the required parameters, or        */
  /* received too many. Exit from the program.                    */
  /****************************************************************/
  {
    exit(1);
  }

  /****************************************************************/
  /* Open QPRINT file so that data can be written to it.  If the  */
  /* file cannot be opened, print a message and exit.             */
  /****************************************************************/
  if((stream = fopen("QPRINT", "wb")) == NULL)
  {
    printf("File could not be opened\n");
    exit(1);
  }

  memset(dir_name, ' ', 100);
  memcpy(dir_name, argv[1], 100);
  if(!memcmp(dir_name, " ", 1))
  {
  fprintf(stream,"No directory specified");
  }
  else
  {
  fprintf(stream,"Directory substructure starting at %.100s", dir_name);
  print_subdir(dir_name, 0);
  }

  fclose(stream);

} /* main */