#define INCL_BASE
#define INCL_DOSMISC
#define INCL_LOGGING
#define INCL_UNI
#define INCL_OS2SERVER_UNI
#ifdef  INCL_ULS_UNI
#undef    INCL_ULS_UNI
#endif

#include <stddef.h>                    /* C library of standard defines     */
#include <stdlib.h>                    /* C library of standard routines    */
#include <string.h>                    /* C library for string operations   */
#include <stdio.h>                     /* C library for standard I/O        */
#include <ctype.h>                     /* C library for character operations*/
#include <os2.h>                       /* for all dos api calls             */
#include <os2u.h>                      /* for all dos unicode api calls     */
#include <basemid.h>                   /* Base msgid definitions            */
#include <unidef.h>                    /* Unicode support                   */
#include <lfdef.h>                     /* Logging Framework support         */

#define QUERY_SIZE        1000
#define BUFFER_SIZE       8192

BOOL         SetupDone = FALSE;        /* Unicode setup performed flag      */

ULONG        CpList[8];                /* List of code page info.           */
ULONG        CpSize;                   /* Length of code page list.         */

UniChar      code_page[10];            /* Code page for current OS/2 process*/
UniChar      locale[128];              /* Locale name                       */

UconvObject  convert_object;           /* Unicode conversion object         */
LocaleObject locale_object;            /* Locale object                     */

/*--------------------------------------------------------------------------*/
/* FUNCTION PROTOTYPES                                                      */
/*--------------------------------------------------------------------------*/
/* Unicode support                                                          */
/*--------------------------------------------------------------------------*/
APIRET ConvertToUni(UniChar *UniString, char *CharString, int UniLength);
APIRET ConvertFromUni(UniChar *UniString, char *CharString, int CharLength);
APIRET SetupUni(void);

int main(int argc, char *argv[])
{
  BYTE    FmtBuffer[BUFFER_SIZE],
          ReadBuffer[BUFFER_SIZE];

  char   *pInsert;

  char    DetailStr[256];
  char    CvtDetailStr[256];

  ULONG   i                  = 0,
          ulDetailCount      = 0,
          ulUniFilesize      = 0,
          ulDetailLen        = 0,
          ulReadBufferLen    = BUFFER_SIZE,
          ulFormatBufferSize = BUFFER_SIZE;

  APIRET  rc = NO_ERROR;

  UniChar UniFilename[128];

  LOFREQUESTTRACE   OpenPkt;
  LCFREQUESTTRACE   ClosePkt;
  LFEREQUESTTRACE   FormatPkt;
  LREREQUESTTRACE   ReadPkt;

  PLFEDETAIL2       pDet2;
  PFILTERBLOCK      pFilterBlock;      /* Pointer to start of filters       */

  if (argc == 1) {
    printf("Trace inferred filename required\n");
    return(1);
  }

  /**************************************************************************/
  /* Open the file                                                          */
  /**************************************************************************/
  ConvertToUni(UniFilename, argv[1], 128);
  ulUniFilesize = UniStrlen(UniFilename);

  OpenPkt.packet_size            = sizeof(LOFREQUESTTRACE);
  OpenPkt.packet_revision_number = WPOS_RELEASE_1;
  OpenPkt.filename_length        = &ulUniFilesize;
  OpenPkt.filename               = UniFilename;
  OpenPkt.FileHandle             = NULLHANDLE;

  rc = LogOpenFile(EVENT_TRACE_SERVICE, &OpenPkt);
  if (rc != NO_ERROR) {
    printf("LogOpenFile RC(%d)\n", rc);
    exit(rc);
  }

  ClosePkt.packet_size               = sizeof(LCFREQUESTTRACE);
  ClosePkt.packet_revision_number    = WPOS_RELEASE_1;
  ClosePkt.FileHandle                = OpenPkt.FileHandle;

  FormatPkt.number_of_detail_records = &ulDetailCount;
  FormatPkt.packet_size              = sizeof(FormatPkt);
  FormatPkt.packet_revision_number   = WPOS_RELEASE_1;
  FormatPkt.log_entry_buffer         = &ReadBuffer;
  FormatPkt.string_buffer_length     = &ulFormatBufferSize;
  FormatPkt.string_buffer            = (UniChar *) &FmtBuffer;
  FormatPkt.pathname_table_size      = 0;
  FormatPkt.pathname_table           = NULL;
  FormatPkt.flags                    = TRACE_ENTRY_DATA;

  pFilterBlock = NULL;

  ReadPkt.packet_size                = sizeof(LREREQUESTTRACE);
  ReadPkt.packet_revision_number     = WPOS_RELEASE_1;
  ReadPkt.flags                      = TRACE_READ_SINGLE_RECORD;
  ReadPkt.pFilter                    = pFilterBlock;
  ReadPkt.pLogEntryBuffer            = (UniChar *) ReadBuffer;
  ReadPkt.pLogEntryBufferLength      = &ulReadBufferLen;
  ReadPkt.FileHandle                 = OpenPkt.FileHandle;
  ReadPkt.entry_ID                   = TRACE_NEWEST_ENTRY;

  do {

    /************************************************************************/
    /* Read in one buffer.                                                  */
    /************************************************************************/
    ulReadBufferLen = BUFFER_SIZE;
    rc = LogReadEntry(EVENT_TRACE_SERVICE, &ReadPkt);
    if ((rc != NO_ERROR) && (rc != INVALID_LF_AT_END_OF_LOG)) {
      printf("LogReadEntry RC(%d)\n", rc);
    }

    /************************************************************************/
    /* Loop through the buffer to format one entry at a time                */
    /************************************************************************/
    else if ((rc != INVALID_LF_AT_END_OF_LOG) && (ulReadBufferLen > 0)) {

      /**********************************************************************/
      /* Format the data                                                    */
      /**********************************************************************/
      ulFormatBufferSize = BUFFER_SIZE;
      FormatPkt.log_entry_buffer = (PULONG) &ReadBuffer;
      rc = LogFormatEntry(EVENT_TRACE_SERVICE, &FormatPkt);
      if (rc != NO_ERROR) {
        printf("LogFormatEntry RC(%d)\n", rc);

        /********************************************************************/
        /* Close the log file                                               */
        /********************************************************************/
        rc = LogCloseFile(EVENT_TRACE_SERVICE, &ClosePkt);
        if (rc != NO_ERROR) {
          printf("LogCloseFile RC(%d)\n", rc);
        }
        exit(rc);
      }

      pDet2 = (PLFEDETAIL2) FmtBuffer;
      pInsert = (char *) pDet2 + sizeof(LFEDETAIL2);

      for (i = 0; i < ulDetailCount; ++i) {
        memset(DetailStr, 0, sizeof(DetailStr));
        ulDetailLen = pDet2->length-sizeof(LFEDETAIL2);
        memcpy(DetailStr, pInsert, ulDetailLen);

        switch (pDet2->type) {
          case TRACE_ENTRY_TIME_TYPE:
            printf("Timestamp               = %s\n", DetailStr);
            break;

          case TRACE_ENTRY_ID_TYPE:
            printf("Entry number            = %s\n", DetailStr);
            break;

          case TRACE_ENTRY_PERSONALITY_TYPE:
            printf("Personality type        = %s\n", DetailStr);
            break;

          case TRACE_ENTRY_MK_TASK_TYPE:
            printf("Microkernel task type   = %s\n", DetailStr);
            break;

          case TRACE_ENTRY_MK_THREAD_TYPE:
            printf("Microkernel thread type = %s\n", DetailStr);
            break;

          case TRACE_ENTRY_OS2_PROCESS_TYPE:
            printf("OS/2 process type       = %s\n", DetailStr);
            break;

          case TRACE_ENTRY_OS2_THREAD_TYPE:
            printf("OS/2 thread type        = %s\n", DetailStr);
            break;

          case TRACE_ENTRY_MODULE_PATHNAME_TYPE:
            printf("Module pathname         = %s\n", DetailStr);
            break;

          case TRACE_ENTRY_DATA_TYPE_TYPE:
            printf("Entry data type         = %s\n", DetailStr);
            break;

          case BUFFER1_TYPE:
            if (ulDetailLen > 0)
              printf("Entry data              = %s\n", DetailStr);
            break;

          case TRACE_ENTRY_MAJOR_CODE_TYPE:
            printf("Major code              = %s\n", DetailStr);
            break;

          case TRACE_ENTRY_MINOR_CODE_TYPE:
            printf("Minor code              = %s\n", DetailStr);
            break;

          default:
            printf(">> DEFAULT              = %s\n", DetailStr);
            break;
        }  /* switch */

        pDet2 = (PLFEDETAIL2) ((char *)pDet2 + pDet2->length);
        pInsert = (char *)pDet2 + sizeof(LFEDETAIL2);
      }  /* Detail loop */

      printf("\n");

    }  /* Buffer has data */
  } while ((rc == NO_ERROR));

  /**************************************************************************/
  /* Close the log file                                                     */
  /**************************************************************************/
  rc = LogCloseFile(EVENT_TRACE_SERVICE, &ClosePkt);
  if (rc != NO_ERROR) {
    printf("LogCloseFile RC(%d)\n", rc);
    exit(rc);
  }

  UniFreeLocaleObject(locale_object);
  UniFreeUconvObject(convert_object);
  exit(0);
}  /* main */

/********************** START OF SPECIFICATION ******************************/
/*  Name:       ConvertToUni                                                */
/*                                                                          */
/*  Purpose:    Convert a char string to unicode string.                    */
/*                                                                          */
/*  Returns:    RC from API's                                               */
/*                                                                          */
/*  Parameters:                                                             */
/*              UniChar*    Pointer to converted unicode string             */
/*              char*       Pointer to string to convert                    */
/*              int         length of Unicode buffer in UniChars            */
/*                                                                          */
/********************* END OF SPECIFICATION *********************************/
APIRET ConvertToUni(UniChar *UniString, char *CharString, int UniLength)
{
  APIRET   rc = NO_ERROR;
  char*    pinbuf;
  UniChar* puni;
  size_t   inbytes, unichars, noni;

  if (SetupDone == FALSE) {
    rc = SetupUni();                   /* Setup local and convert objects   */
  }

  if (rc == NO_ERROR) {

    /************************************************************************/
    /* UniUconvToUcs will change the pointers given to it, so send in       */
    /* temporary pointers                                                   */
    /************************************************************************/
    inbytes  = strlen(CharString) + 1;
    unichars = UniLength;
    pinbuf   = CharString;
    puni     = UniString;
    memset(puni, 0, unichars * sizeof(UniChar));

    rc = UniUconvToUcs(convert_object,
                       (void *)&pinbuf,
                       &inbytes,
                       &puni,
                       &unichars,
                       &noni);
  }
  return(rc);
}  /* ConvertToUni */

/********************** START OF SPECIFICATION ******************************/
/*  Name:   ConvertFromUni                                                  */
/*                                                                          */
/*  Purpose:    Convert a unicode string to char string.                    */
/*                                                                          */
/*  Returns:    0  successfull conversion                                   */
/*              1  conversion failed                                        */
/*                                                                          */
/*  Parameters:                                                             */
/*              UniChar*     UniString; Pointer to string to convert        */
/*              char*        CharString; Pointer to converted string        */
/*              int          CharLength; length of the char buffer          */
/*                                                                          */
/********************* END OF SPECIFICATION *********************************/
APIRET ConvertFromUni(UniChar *UniString, char *CharString, int CharLength)
{
  APIRET   rc = NO_ERROR;
  char*    poutbuf;
  UniChar* puni;
  size_t   unichars, chars, noni;

  if (SetupDone == FALSE) {
    rc = SetupUni();                   /* Setup local and convert objects   */
  }

  if (rc == NO_ERROR) {

    /************************************************************************/
    /* UniUconvFromUcs will change the pointers given to it, so send in     */
    /* temporary pointers                                                   */
    /************************************************************************/
    unichars = UniStrlen(UniString);
    chars    = CharLength;
    poutbuf  = CharString;
    puni     = UniString;
    memset(poutbuf, 0, chars);         /* Zero output buffer and null term  */

    rc = UniUconvFromUcs(convert_object,         /* Conversion Object       */
                         &puni,                  /* Uni Input Buffer addr   */
                         &unichars,              /* Bytes left in ucsbuf    */
                         (void *)&poutbuf,       /* Output Buffer address   */
                         &chars,                 /* Bytes left in outbuf    */
                         &noni);                 /* nonident conversions    */
  }
  return(rc);
}  /* ConvertFromUni */

/********************** START OF SPECIFICATION ******************************/
/*  Name:       SetupUni                                                    */
/*                                                                          */
/*  Purpose:    Setup local and convert objects for unicode conversions     */
/*                                                                          */
/*  Returns:    RC from API's used                                          */
/*                                                                          */
/*  Parameters: none                                                        */
/*                                                                          */
/********************* END OF SPECIFICATION *********************************/
APIRET SetupUni(void)
{
  APIRET rc = NO_ERROR;

  rc = UniCreateLocaleObject(UNI_UCS_STRING_POINTER, L"", &locale_object);

  /**************************************************************************/
  /* Get the value of LC_MESSAGES to determine which language               */
  /**************************************************************************/
  rc = UniQueryLocaleObject(locale_object,
                            LC_MESSAGES,
                            UNI_UCS_STRING_POINTER,
                            (PVOID)&locale);
  if (rc != NO_ERROR)
    return(rc);

  UniStrcpy(code_page, L"IBM-850");

  rc = UniCreateUconvObject(code_page, &convert_object);
  if (rc != NO_ERROR)
    return(rc);

  SetupDone = TRUE;
  return(rc);
}  /* SetupUni */


[Back: TCEREQUEST Field - event_data]
[Next: Performance Services]