Who owns my IBM i integrated file system object?

//---------------------------------------------------------------------
// Sample program to retrieve B0 and B1 journal entries
//---------------------------------------------------------------------

#include <stdio.h>
#include <stdlib.h>
#include <sys/time.h>
#include <time.h>
#include <qusec.h>    /* Error code structure */
#include <qp0ljrnl.h> /* entry structs defined*/
#include <qjournal.h> /* QjoRetrieveJournalEntries()     */
#include <qtqiconv.h> // iconv
#include <errno.h>    /* use errno values     */

//
// struct TimeRange
//
//  Starting and ending time of the variation--used when retrieving
//  journal entries.
//
typedef struct TimeRange {
    time_t startTime;
    time_t endTime;
} TimeRange_t;

// struct JournalEntryTypeKeyArray
//
// Structure to contain the B0 and B1 entry types to be retrieved
// from the journal
//
typedef _Packed struct JournalEntryTypeKeyArray
{
  Qjo_JE_Data_Key_8_t   EntryTypeKeyFixed;
  Qjo_Jrn_Entry_Type_t  Jrn_Entry_Type[2];
} JournalEntryTypeKeyArray_t;

//---------------------------------------------------------------------
// SetTimeRangeStartValue()
//---------------------------------------------------------------------
int  SetTimeRangeStartValue(TimeRange_t *rtr)
{
  /* get current time, set value in structure */
  time(&(rtr->startTime));
  return(0);
}

//---------------------------------------------------------------------
// SetTimeRangeEndValue()
//---------------------------------------------------------------------
int  SetTimeRangeEndValue(TimeRange_t *rtr)
{
  /* get current time, set value in structure */
  time(&(rtr->endTime));
  return(0);
}

//---------------------------------------------------------------------
// convert_time_to_SAA_string()
//---------------------------------------------------------------------
int convert_time_to_SAA_string(time_t ntime, char *outtime)
{
  struct tm tm_time;
  size_t rv;
  char timestring[27];

  // convert to tm struct
  localtime_r(&ntime, &tm_time);
  rv = strftime(timestring, 27, "%Y-%m-%d-%H.%M.%S.000000", &tm_time);
  if (rv == 0)
  {
    return(-1);
  }
  memcpy (outtime, timestring, 26);
  // return ok
  return(0);
}

//---------------------------------------------------------------------
// setupSelectionCriteria()
//---------------------------------------------------------------------
int setupSelectionCriteria(char *selectCriteria,
                           int selectCriteriaLength,
                           TimeRange_t *rtr)
{
  Qjo_JE_Jrn_Info_Retrieve_t *selCriteria_p;
  Qjo_JE_Fmt_Var_Len_Rcrd_t  *varRec_p;
  Qjo_JE_Data_Key_3_t        *dataKey3_p;
  Qjo_JE_Data_Key_5_t        *dataKey5_p;
  JournalEntryTypeKeyArray_t *dataKey8_p;
  int      offset = 0;
  int      rv;

  // initialize structure
  memset (selectCriteria, 0x00, selectCriteriaLength);

  selCriteria_p = (Qjo_JE_Jrn_Info_Retrieve_t *)selectCriteria;
  selCriteria_p->Num_Var_Len_Rcrds = 3;
  offset += sizeof(Qjo_JE_Jrn_Info_Retrieve_t);


  // Fill in first key -- start time
  varRec_p = (Qjo_JE_Fmt_Var_Len_Rcrd_t *)(selectCriteria+offset);
  varRec_p->Len_Var_Len_Rcrd = sizeof(Qjo_JE_Fmt_Var_Len_Rcrd_t) +
    sizeof(Qjo_JE_Data_Key_3_t);
  varRec_p->Key = 3;
  varRec_p->Len_Of_Data = sizeof(Qjo_JE_Data_Key_3_t);
  offset += sizeof(Qjo_JE_Fmt_Var_Len_Rcrd_t);
  dataKey3_p = (Qjo_JE_Data_Key_3_t *)( &selectCriteria[offset]);
  rv = convert_time_to_SAA_string(rtr->startTime,
                                  dataKey3_p->Starting_Time_Stamp);
  if (rv == -1) // failed to convert time string
  {
    return(-1);
  }
  offset += sizeof(Qjo_JE_Data_Key_3_t);

  // Fill in second key -- end time
  varRec_p = (Qjo_JE_Fmt_Var_Len_Rcrd_t *) &selectCriteria[offset];
  varRec_p->Len_Var_Len_Rcrd = sizeof(Qjo_JE_Fmt_Var_Len_Rcrd_t) +
    sizeof(Qjo_JE_Data_Key_5_t);
  varRec_p->Key = 5;
  varRec_p->Len_Of_Data = sizeof(Qjo_JE_Data_Key_5_t);
  offset += sizeof(Qjo_JE_Fmt_Var_Len_Rcrd_t);
  dataKey5_p = (Qjo_JE_Data_Key_5_t *) &selectCriteria[offset];
  rv = convert_time_to_SAA_string(rtr->endTime,
                                  dataKey5_p->Ending_Time_Stamp);
  if (rv == -1) // failed to convert time string
  {
    return(-1);
  }
  offset += sizeof(Qjo_JE_Data_Key_5_t);

  // Fill in third key -- entry types B0 and B1
  varRec_p = (Qjo_JE_Fmt_Var_Len_Rcrd_t *) &selectCriteria[offset];
  varRec_p->Len_Var_Len_Rcrd = sizeof(Qjo_JE_Fmt_Var_Len_Rcrd_t) +
    sizeof(JournalEntryTypeKeyArray_t);
  varRec_p->Key = 8;
  varRec_p->Len_Of_Data = sizeof(JournalEntryTypeKeyArray_t);
  offset += sizeof(Qjo_JE_Fmt_Var_Len_Rcrd_t);
  dataKey8_p = (JournalEntryTypeKeyArray_t *) &selectCriteria[offset];
  dataKey8_p->EntryTypeKeyFixed.Num_In_Array = 2;
  memcpy(dataKey8_p->Jrn_Entry_Type[0],"B0        ",
         sizeof(Qjo_Jrn_Entry_Type_t));
  memcpy(dataKey8_p->Jrn_Entry_Type[1],"B1        ",
         sizeof(Qjo_Jrn_Entry_Type_t));

  return(0);
}

//---------------------------------------------------------------------
// convertStringToJobCCSID()
//---------------------------------------------------------------------

int convertStringToJobCCSID(int    in_ccsid,
                          char   *in_buf,
                          char   *out_buf,
                          size_t *in_bytes_left,
                          size_t *out_bytes_left)
{
  QtqCode_T from_code =
  { 0,                           // input CCSID.
    0,                           // IBM default conversion.
    0,                           // do not return substitution count
    0,                           // conv descriptor is not
                                 // returned to initial shift state
    0,                           // inbytesleft required
    0                            // No mixed byte errors
  };

  QtqCode_T to_code =
  { 0,                           // output CCSID
    0,                           // ignored on output
    0,                           // ignored on output
    0,                           // ignored on output
    0,                           // ignored on output
    0                            // ignored on output
  };

  iconv_t cd;                    // conversion descriptor.
  int rc = 0;                    // return value

  from_code.CCSID = in_ccsid;    // set from CCSID
  to_code.CCSID = 0;             // set to job CCSID

  /// Open conversion descriptor
  cd = QtqIconvOpen(&to_code, &from_code);

  if ( cd.return_value == -1 ) // failed, return error
    return(-1);

  // Do the conversion.
  rc = iconv(cd,
             &in_buf,
             in_bytes_left,
             &out_buf,
             out_bytes_left);

  // Close conversion descriptor
  iconv_close(cd);
  return(rc);
}

//---------------------------------------------------------------------
// processB1JournalEntry()
//---------------------------------------------------------------------
int processB1JournalEntry(Qp0l_B1_Journal_Entry_t *B1_entry_p)
{
  char *tmpPtr;
  Qp0l_Path_Name_t *pathName;
  char pathNameString[5000];  // local path in job CCSID
  unsigned int outputPathBufLen = 5000;
  unsigned int inputPathLen;
  Qp0l_Object_Name_t *objName;
  char objNameString[512];
  unsigned int outputObjNameBufLen = 512;
  unsigned int inputObjNameLen;
  int rc;
  char chgownCmdString[10000];

  // Get pathname and object name
  tmpPtr = (char *)B1_entry_p;
  pathName = (Qp0l_Path_Name_t *)(tmpPtr + B1_entry_p->PathOffset);
  inputPathLen = pathName->PathHeader.Path_Length;
  objName = (Qp0l_Object_Name_t *)(tmpPtr + B1_entry_p->NameOffset);
  inputObjNameLen = objName->Length;

  // convert path to job ccsid
  memset(pathNameString,0x00,outputPathBufLen);
  rc = convertStringToJobCCSID(pathName->PathHeader.CCSID,
                             &(pathName->Path[0]),
                             &(pathNameString[0]),
                             &inputPathLen,
                             &outputPathBufLen);
  if (0!=rc) // Conversion of path to job CCSID didn't complete
  {
    return(-1); // failed
  }
  // convert object name to job ccsid
  memset(objNameString,0x00,outputObjNameBufLen);
  rc = convertStringToJobCCSID(objName->NLSinfo.ccsid,
                             &(objName->Name[0]),
                             &(objNameString[0]),
                             &inputObjNameLen,
                             &outputObjNameBufLen);
  if (0!=rc) // Conversion of path to job CCSID didn't complete
  {
    return(-1); // failed
  }

  // Set up CHGOWN command
  memset(chgownCmdString,0x00,10000);

  sprintf(chgownCmdString,
          "CHGOWN OBJ('%s/%s') NEWOWN(RESERVE)",
          pathNameString,objNameString);
  system(chgownCmdString);  // change owner
  return(0);
}

//---------------------------------------------------------------------
//  Retrieve and process B0 and B1 journal entries
//---------------------------------------------------------------------
int  main(  int argc,
            char *argv[])
{
  // local variables
  int         rc,rv;
  int waitTime = (60 * 60 * 4);  // wait 4 hours

  // Variables for QjoRetrieveJournalEntries
  char     formatName[8];
  Qus_EC_t errcode;
  char     msg[7];
  char     journalname[20];  // journal name and library

  // Variables for journal entry criteria
  const int entryCriteriaSize = sizeof(Qjo_JE_Jrn_Info_Retrieve_t) +
                                3 * sizeof(Qjo_JE_Fmt_Var_Len_Rcrd_t) +
                                sizeof(Qjo_JE_Data_Key_3_t) +
                                sizeof(Qjo_JE_Data_Key_5_t) +
                                sizeof(JournalEntryTypeKeyArray_t);
  char     selectCriteria[entryCriteriaSize]; // space for criteria information
  TimeRange_t rtr;  // time range for retrieve

  // Variables for QjoRetrieveJournalEntries receiver variable
  char    *recvar;      // receiver variable pointer
  long int recvarlen;   // length of receiver variable
  int      entryI;
  Qjo_RJNE0100_Hdr_t *header_p;
  Qjo_RJNE0100_JE_Hdr_t *entry_header_p;
  Qjo_RJNE0100_JE_ESD_t *entry_specific_p;
  Qp0l_B1_Journal_Entry_t *B1_entry_p;
  int receiverOffset=0;

  // Set up journal name and library for call to
  // QjoRetrieveJournalEntries
  sprintf (journalname,"%-10.10s%-10.10s", "RESERVE","JRN");
  // Set up formatName variable
  memcpy(formatName, "RJNE0100", 8);

  // retrieve initial start time
  SetTimeRangeStartValue(&rtr);

  // Allocate and setup receiver buffer
  recvarlen = 4 * 1024 * 1024;
  recvar = (char *) malloc(recvarlen);
  if (NULL == recvar)
  {
    // error allocating buffer, exit with error
    return(ENOMEM);
  }

  // Start loop here
  Loop:

  // wait 4 hours
  sleep(waitTime);

  // Retrieve end time
  SetTimeRangeEndValue(&rtr);
  // Set up selection criteria variable with three records,
  // start time, end time and entry type.
  setupSelectionCriteria(selectCriteria, entryCriteriaSize, &rtr);
  // Clear receiver buffer
  memset (recvar, 0x00, recvarlen);
  // Set up error code parameter for QjoRetrieveJournalEntries
  memset((char *)&errcode, 0x00, sizeof(errcode));
  errcode.Bytes_Provided = sizeof(errcode);

  // Call QjoRetrieveJournalEntries()
  QjoRetrieveJournalEntries(recvar,               // Receiver variable
                            &recvarlen,           // Length of receiver
                                                  // variable
                            journalname,          // Qualified journal
                                                  // name
                            formatName,           // format of returned
                                                  // data
                            selectCriteria,       // Selection criteria
                            (void *) &errcode);   // Error code

  // Check for errors, message CPF7062 is OK
  if((errcode.Bytes_Available > 0) &&
     (0 != memcmp(errcode.Exception_Id, "CPF7062",7)))
  {
    free(recvar);
    return(-1);
  }

  // Process returned entries
  header_p = (Qjo_RJNE0100_Hdr_t *) recvar;  // header information
  receiverOffset = header_p->Offset_First_Jrn_Entry; // first entry

  // If no entries returned jump to the top of the loop and wait
  if (header_p->Number_Entries_Retreived == 0)
  {
    goto Loop;
  }

  // Loop through retrieved entries
  for (entryI = 0;
       entryI < header_p->Number_Entries_Retreived;
       entryI++)
  {
    entry_header_p = (Qjo_RJNE0100_JE_Hdr_t *) &recvar[receiverOffset];
    entry_specific_p = (Qjo_RJNE0100_JE_ESD_t *) &recvar[receiverOffset
                       + entry_header_p->Dsp_Entry_Specific_Data];
    B1_entry_p = (Qp0l_B1_Journal_Entry_t *)&(entry_specific_p->ESD);

    // Process B1 entries
    if (0 == memcmp("B1", entry_header_p->Entry_Type, 2))
    {
      // Process the entry
      processB1JournalEntry(B1_entry_p);
    }
    // advance offset to next entry header
    receiverOffset += entry_header_p->Dsp_Next_Jrn_Hdr;
  }
  // use the current end time for the start time in the next loop
  // iteration
  rtr.startTime = rtr.endTime;

  // go to the start of the loop
  goto Loop;

  // free allocated storage
  free(recvar);
  // return ok
  return(0);
}