/* This Source Code Form is subject to the terms of the Mozilla Public

 * License, v. 2.0. If a copy of the MPL was not distributed with this

 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

#define INCL_DOS

#define INCL_DOSERRORS

#include <os2.h>

#include "secrng.h"

#include "prerror.h"

#include <stdlib.h>

#include <time.h>

#include <stdio.h>

#include <sys/stat.h>

static BOOL clockTickTime(unsigned long *phigh, unsigned long *plow)

{

    APIRET rc = NO_ERROR;

    QWORD qword = {0,0};

    rc = DosTmrQueryTime(&qword);

    if (rc != NO_ERROR)

       return FALSE;

    *phigh = qword.ulHi;

    *plow  = qword.ulLo;

    return TRUE;

}

size_t RNG_GetNoise(void *buf, size_t maxbuf)

{

    unsigned long high = 0;

    unsigned long low  = 0;

    clock_t val = 0;

    int n = 0;

    int nBytes = 0;

    time_t sTime;

    if (maxbuf <= 0)

       return 0;

    clockTickTime(&high, &low);

    /* get the maximally changing bits first */

    nBytes = sizeof(low) > maxbuf ? maxbuf : sizeof(low);

    memcpy(buf, &low, nBytes);

    n += nBytes;

    maxbuf -= nBytes;

    if (maxbuf <= 0)

       return n;

    nBytes = sizeof(high) > maxbuf ? maxbuf : sizeof(high);

    memcpy(((char *)buf) + n, &high, nBytes);

    n += nBytes;

    maxbuf -= nBytes;

    if (maxbuf <= 0)

       return n;

    /* get the number of milliseconds that have elapsed since application started */

    val = clock();

    nBytes = sizeof(val) > maxbuf ? maxbuf : sizeof(val);

    memcpy(((char *)buf) + n, &val, nBytes);

    n += nBytes;

    maxbuf -= nBytes;

    if (maxbuf <= 0)

       return n;

    /* get the time in seconds since midnight Jan 1, 1970 */

    time(&sTime);

    nBytes = sizeof(sTime) > maxbuf ? maxbuf : sizeof(sTime);

    memcpy(((char *)buf) + n, &sTime, nBytes);

    n += nBytes;

    return n;

}

static BOOL

EnumSystemFiles(void (*func)(const char *))

{

    APIRET              rc;

    ULONG               sysInfo = 0;

    char                bootLetter[2];

    char                sysDir[_MAX_PATH] = "";

    char                filename[_MAX_PATH];

    HDIR                hdir = HDIR_CREATE;

    ULONG               numFiles = 1;

    FILEFINDBUF3        fileBuf = {0};

    ULONG               buflen = sizeof(FILEFINDBUF3);

    if (DosQuerySysInfo(QSV_BOOT_DRIVE, QSV_BOOT_DRIVE, (PVOID)&sysInfo,

                        sizeof(ULONG)) == NO_ERROR)

    {

      bootLetter[0] = sysInfo + 'A' -1;

      bootLetter[1] = '\0';

      strcpy(sysDir, bootLetter);

      strcpy(sysDir+1, ":\\OS2\\");

      strcpy( filename, sysDir );

      strcat( filename, "*.*" );

    }

    rc =DosFindFirst( filename, &hdir, FILE_NORMAL, &fileBuf, buflen,

                      &numFiles, FIL_STANDARD );

    if( rc == NO_ERROR )

    {

      do {

        // pass the full pathname to the callback

        sprintf( filename, "%s%s", sysDir, fileBuf.achName );

        (*func)(filename);

        numFiles = 1;

        rc = DosFindNext( hdir, &fileBuf, buflen, &numFiles );

        if( rc != NO_ERROR && rc != ERROR_NO_MORE_FILES )

          printf( "DosFindNext errod code = %d\n", rc );

      } while ( rc == NO_ERROR );

      rc = DosFindClose(hdir);

      if( rc != NO_ERROR )

        printf( "DosFindClose error code = %d", rc );

    }

    else

      printf( "DosFindFirst error code = %d", rc );

    return TRUE;

}

static int    dwNumFiles, dwReadEvery, dwFileToRead=0;

static void

CountFiles(const char *file)

{

    dwNumFiles++;

}

static void

ReadFiles(const char *file)

{

    if ((dwNumFiles % dwReadEvery) == 0)

        RNG_FileForRNG(file);

    dwNumFiles++;

}

static void 

ReadSingleFile(const char *filename)

{

    unsigned char buffer[1024];

    FILE *file; 

    file = fopen((char *)filename, "rb");

    if (file != NULL) {

	while (fread(buffer, 1, sizeof(buffer), file) > 0) 

	    ;

	fclose(file);

    }

}

static void

ReadOneFile(const char *file)

{

    if (dwNumFiles == dwFileToRead) {

        ReadSingleFile(file);

    }

    dwNumFiles++;

}

static void

ReadSystemFiles(void)

{

    // first count the number of files

    dwNumFiles = 0;

    if (!EnumSystemFiles(CountFiles))

        return;

    RNG_RandomUpdate(&dwNumFiles, sizeof(dwNumFiles));

    // now read 10 files

    if (dwNumFiles == 0)

        return;

    dwReadEvery = dwNumFiles / 10;

    if (dwReadEvery == 0)

        dwReadEvery = 1;  // less than 10 files

    dwNumFiles = 0;

    EnumSystemFiles(ReadFiles);

}

void RNG_SystemInfoForRNG(void)

{

   unsigned long *plong = 0;

   PTIB ptib;

   PPIB ppib;

   APIRET rc = NO_ERROR;

   DATETIME dt;

   COUNTRYCODE cc = {0};

   COUNTRYINFO ci = {0};

   unsigned long actual = 0;

   char path[_MAX_PATH]="";

   char fullpath[_MAX_PATH]="";

   unsigned long pathlength = sizeof(path);

   FSALLOCATE fsallocate;

   FILESTATUS3 fstatus;

   unsigned long defaultdrive = 0;

   unsigned long logicaldrives = 0;

   unsigned long sysInfo[QSV_MAX] = {0};

   char buffer[20];

   int nBytes = 0;

   nBytes = RNG_GetNoise(buffer, sizeof(buffer));

   RNG_RandomUpdate(buffer, nBytes);

   /* allocate memory and use address and memory */

   plong = (unsigned long *)malloc(sizeof(*plong));

   RNG_RandomUpdate(&plong, sizeof(plong));

   RNG_RandomUpdate(plong, sizeof(*plong));

   free(plong);

   /* process info */

   rc = DosGetInfoBlocks(&ptib, &ppib);

   if (rc == NO_ERROR)

   {

      RNG_RandomUpdate(ptib, sizeof(*ptib));

      RNG_RandomUpdate(ppib, sizeof(*ppib));

   }

   /* time */

   rc = DosGetDateTime(&dt);

   if (rc == NO_ERROR)

   {

      RNG_RandomUpdate(&dt, sizeof(dt));

   }

   /* country */

   rc = DosQueryCtryInfo(sizeof(ci), &cc, &ci, &actual);

   if (rc == NO_ERROR)

   {

      RNG_RandomUpdate(&cc, sizeof(cc));

      RNG_RandomUpdate(&ci, sizeof(ci));

      RNG_RandomUpdate(&actual, sizeof(actual));

   }

   /* current directory */

   rc = DosQueryCurrentDir(0, path, &pathlength);

   strcat(fullpath, "\\");

   strcat(fullpath, path);

   if (rc == NO_ERROR)

   {

      RNG_RandomUpdate(fullpath, strlen(fullpath));

      // path info

      rc = DosQueryPathInfo(fullpath, FIL_STANDARD, &fstatus, sizeof(fstatus));

      if (rc == NO_ERROR)

      {

         RNG_RandomUpdate(&fstatus, sizeof(fstatus));

      }

   }

   /* file system info */

   rc = DosQueryFSInfo(0, FSIL_ALLOC, &fsallocate, sizeof(fsallocate));

   if (rc == NO_ERROR)

   {

      RNG_RandomUpdate(&fsallocate, sizeof(fsallocate));

   }

   /* drive info */

   rc = DosQueryCurrentDisk(&defaultdrive, &logicaldrives);

   if (rc == NO_ERROR)

   {

      RNG_RandomUpdate(&defaultdrive, sizeof(defaultdrive));

      RNG_RandomUpdate(&logicaldrives, sizeof(logicaldrives));

   }

   /* system info */

   rc = DosQuerySysInfo(1L, QSV_MAX, (PVOID)&sysInfo, sizeof(ULONG)*QSV_MAX);

   if (rc == NO_ERROR)

   {

      RNG_RandomUpdate(&sysInfo, sizeof(sysInfo));

   }

   // now let's do some files

   ReadSystemFiles();

   /* more noise */

   nBytes = RNG_GetNoise(buffer, sizeof(buffer));

   RNG_RandomUpdate(buffer, nBytes);

}

void RNG_FileForRNG(const char *filename)

{

    struct stat stat_buf;

    unsigned char buffer[1024];

    FILE *file = 0;

    int nBytes = 0;

    static int totalFileBytes = 0;

    if (stat((char *)filename, &stat_buf) < 0)

       return;

    RNG_RandomUpdate((unsigned char*)&stat_buf, sizeof(stat_buf));

    file = fopen((char *)filename, "r");

    if (file != NULL)

    {

       for (;;)

       {

           size_t bytes = fread(buffer, 1, sizeof(buffer), file);

           if (bytes == 0)

              break;

           RNG_RandomUpdate(buffer, bytes);

           totalFileBytes += bytes;

           if (totalFileBytes > 250000)

              break;

       }

       fclose(file);

    }

    nBytes = RNG_GetNoise(buffer, 20); 

    RNG_RandomUpdate(buffer, nBytes);

}

static void rng_systemJitter(void)

{

    dwNumFiles = 0;

    EnumSystemFiles(ReadOneFile);

    dwFileToRead++;

    if (dwFileToRead >= dwNumFiles) {

	dwFileToRead = 0;

    }

}

size_t RNG_SystemRNG(void *dest, size_t maxLen)

{

    return rng_systemFromNoise(dest,maxLen);

}