NT4/private/nw/convert/nwconv/fastcopy.c

/*
  +-------------------------------------------------------------------------+
  |                      File Copying Routines                              |
  +-------------------------------------------------------------------------+
  |                     (c) Copyright 1993-1994                             |
  |                          Microsoft Corp.                                |
  |                        All rights reserved                              |
  |                                                                         |
  | Program               : [FastCopy.c]                                    |
  | Programmer            : Arthur Hanson                                   |
  | Original Program Date : [Jul 27, 1993]                                  |
  | Last Update           : [Jun 18, 1994]                                  |
  |                                                                         |
  | Version:  1.00                                                          |
  |                                                                         |
  |   Use multiple threads to whack data from one file to another           |
  |                                                                         |
  | Modifications:                                                          |
  |    18-Oct-1990 w-barry Removed 'dead' code.                             |
  |    21-Nov-1990 w-barry Updated API's to the Win32 set.                  |
  |                                                                         |
  +-------------------------------------------------------------------------+
*/

#define INCL_DOSPROCESS
#define INCL_DOSSEMAPHORES

#include "globals.h"
#include <stdio.h>
#include <process.h>
#include <windows.h>
#include <malloc.h>
#include "mem.h"
#include "debug.h"
#include "utils.h"
#include "convapi.h"

#define BUFSIZE     0xFE00       //  full segment minus sector
#define STACKSIZE   256          //  stack size for child thread

typedef struct BUF BUF;

struct BUF {
    BOOL  flag;
    DWORD cbBuf;
    BUF  *fpbufNext;
    BYTE ach[BUFSIZE];
};

#define LAST    TRUE
#define NOTLAST FALSE

static HANDLE hevQNotEmpty;
static CRITICAL_SECTION  hcrtQLock;
static BUF *fpbufHead = NULL;
static BUF *fpbufTail = NULL;
static HANDLE hfSrc, hfDst;
static HANDLE hThread;
static BOOLEAN fAbort;

//  forward type definitions

LPTSTR writer( void );
DWORD reader( void );
BUF  *dequeue( void );
void  enqueue( BUF *fpbuf );
TCHAR *fastcopy( HANDLE hfSrcParm, HANDLE hfDstParm );

/*+-------------------------------------------------------------------------+
  | writer()
  |
  +-------------------------------------------------------------------------+*/
LPTSTR writer ( void ) {
    BUF *fpbuf;
    DWORD cbBytesOut;
    BOOL f = !LAST;
    LPTSTR npsz = NULL;
    ULONG BytesCopied = 0;

    TCHAR buffer[MAX_PATH];

    Status_Bytes(lToStr(BytesCopied));

    while (f != LAST && npsz == NULL) {
        fpbuf = dequeue ();

        if (fpbuf) {
           if ((f = fpbuf->flag) != LAST) {
               if (!WriteFile(hfDst, fpbuf->ach, fpbuf->cbBuf, &cbBytesOut, NULL)) {
                   npsz = Lids(IDS_L_4);
#ifdef DEBUG
dprintf(TEXT("ERROR: WriteFile\n"));
#endif
               } else {
                  BytesCopied += cbBytesOut;
                  Status_Bytes(lToStr(BytesCopied));


                  if (cbBytesOut != (DWORD)fpbuf->cbBuf) {
                     npsz = Lids(IDS_L_5);
#ifdef DEBUG
dprintf(TEXT("ERROR: WriteFile: out-of-space\n"));
#endif
                  }
               }
           }
           else
               npsz = *(LPTSTR *)fpbuf->ach;

           FreeMemory(fpbuf);

        } else {
           wsprintf (buffer, Lids(IDS_L_4), fpbuf);
#ifdef DEBUG
dprintf(TEXT("ERROR: WriteFile - FileBuffer is NULL\n"));
#endif
        }
    }

    if (f != LAST)
        fAbort = TRUE;

    WaitForSingleObject(hThread, (DWORD)-1);
    CloseHandle(hThread);
    CloseHandle(hevQNotEmpty);
    DeleteCriticalSection(&hcrtQLock);

    return (npsz);
} // writer


/*+-------------------------------------------------------------------------+
  | reader()
  |
  +-------------------------------------------------------------------------+*/
DWORD reader( void ) {
    BUF *fpbuf;
    BOOL f = !LAST;

    while (!fAbort && f != LAST) {
        if ((fpbuf = AllocMemory(sizeof(BUF))) == NULL) {
#ifdef DEBUG
dprintf(TEXT("ERROR: MemoryAlloc error %ld\n"), GetLastError());
#endif
            return(0);
        }

        f = fpbuf->flag = NOTLAST;
        if (!ReadFile(hfSrc, fpbuf->ach, BUFSIZE, &fpbuf->cbBuf, NULL) || fpbuf->cbBuf == 0) {
            f = fpbuf->flag = LAST;
            *(LPTSTR *)(fpbuf->ach) = NULL;
        }

        enqueue (fpbuf);
    }

    return(0);
} // reader


/*+-------------------------------------------------------------------------+
  | dequeue()
  |
  +-------------------------------------------------------------------------+*/
BUF *dequeue( void ) {
    BUF *fpbuf;

    while (TRUE) {
        if (fpbufHead != NULL) {
            EnterCriticalSection(&hcrtQLock);
            fpbufHead = (fpbuf = fpbufHead)->fpbufNext;

            if (fpbufTail == fpbuf)
                fpbufTail = NULL;

            LeaveCriticalSection(&hcrtQLock);
            break;
        }

        // the head pointer is null so the list is empty.  Block on eventsem 
        // until enqueue posts (ie. adds to queue)
        WaitForSingleObject(hevQNotEmpty, (DWORD)-1);
    }

    return fpbuf;
} // dequeue


/*+-------------------------------------------------------------------------+
  | enqueue()
  |
  +-------------------------------------------------------------------------+*/
void enqueue( BUF *fpbuf ) {
    fpbuf->fpbufNext = NULL;

    EnterCriticalSection(&hcrtQLock);

    if (fpbufTail == NULL)
        fpbufHead = fpbuf;
    else
        fpbufTail->fpbufNext = fpbuf;

    fpbufTail = fpbuf;
    LeaveCriticalSection(&hcrtQLock);

    SetEvent(hevQNotEmpty);
} // enqueue


/*+-------------------------------------------------------------------------+
  | fastcopy()
  |
  |  hfSrcParm       file handle to read from
  |  hfDstParm       file handle to write to
  |
  |  returns         NULL if successful
  |                  pointer to error string otherwise
  +-------------------------------------------------------------------------+*/
TCHAR *fastcopy (HANDLE hfSrcParm, HANDLE hfDstParm) {
    DWORD dwReader;

    hfSrc = hfSrcParm;
    hfDst = hfDstParm;


    hevQNotEmpty = CreateEvent(NULL, (BOOL)FALSE, (BOOL)FALSE, NULL);
    if (hevQNotEmpty == INVALID_HANDLE_VALUE)
        return NULL;

    InitializeCriticalSection(&hcrtQLock);

    fAbort = FALSE;
    hThread = CreateThread(0, STACKSIZE, (LPTHREAD_START_ROUTINE)reader, 0, 0, &dwReader);
    if (hThread == INVALID_HANDLE_VALUE) {
#ifdef DEBUG
dprintf(TEXT("ERROR: Can't create thread - FileCopy\n"));
#endif
        return Lids(IDS_L_6);
    }

    return(writer());
} // fastcopy