|
|
/*
* file.c * * send files on request over a named pipe. * * supports requests to package up a file and send it over a named pipe. * * Geraint Davies, August 92 */
#include <windows.h>
#include <stdio.h>
#include <string.h>
#include "sumserve.h"
#include "errlog.h"
#include "server.h"
BOOL ss_compress(PSTR original, PSTR compressed);ULONG ss_checksum_block(PSTR block, int size);
extern BOOL bNoCompression; /* imported from sumserve.c Read only here */
/*
* given a pathname to a file, read the file, compress it package it up * into SSPACKETs and send these via ss_sendblock to the named pipe. * * * each packet has a sequence number. if we can't read the file, we send * a single packet with sequence -1. otherwise, we carry on until we run out * of data, then we send a packet with 0 size. */voidss_sendfile(HANDLE hpipe, LPSTR file, LONG lVersion){ SSPACKET packet; HANDLE hfile; int size; char szTempname[MAX_PATH]; PSSATTRIBS attribs; BY_HANDLE_FILE_INFORMATION bhfi;
dprintf1(("getting '%s' for %8x\n", file, hpipe));
/*
* get the file attributes first */ hfile = CreateFile(file, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, 0); if (hfile == INVALID_HANDLE_VALUE) {
/* report that we could not read the file */ packet.lSequence = -1; ss_sendblock(hpipe, (PSTR) &packet, sizeof(packet));
DeleteFile(szTempname); return; } /*
* seems to be a bug in GetFileInformationByHandle if the * file is not on local machine - so avoid it. */ bhfi.dwFileAttributes = GetFileAttributes(file); GetFileTime(hfile, &bhfi.ftCreationTime, &bhfi.ftLastAccessTime, &bhfi.ftLastWriteTime);
CloseHandle(hfile);
/* create temp filename */ GetTempPath(sizeof(szTempname), szTempname); GetTempFileName(szTempname, "sum", 0, szTempname);
/* compress the file into this temporary file */ if (bNoCompression || (!ss_compress(file, szTempname))) {
/* try to open the original file */ hfile = CreateFile(file, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, 0);
dprintf1(("sending original file to %8x\n", hpipe)); } else { /* open temp (compressed) file and send this */ hfile = CreateFile(szTempname, GENERIC_READ, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, 0); dprintf1(("sending compressed file to %8x\n", hpipe)); }
if (hfile == INVALID_HANDLE_VALUE) {
/* report that we could not read the file */ packet.lSequence = -1; ss_sendblock(hpipe, (PSTR) &packet, sizeof(packet));
DeleteFile(szTempname); return; }
/* loop reading blocks of the file */ for (packet.lSequence = 0; ; packet.lSequence++) {
if(!ReadFile(hfile, packet.Data, sizeof(packet.Data), (LPDWORD)(&size), NULL)) { /* error reading file. send a -1 packet to
* indicate this */ packet.lSequence = -1; ss_sendblock(hpipe, (PSTR) &packet, sizeof(packet)); break; }
packet.ulSize = size;
if (lVersion==0) packet.ulSum = ss_checksum_block(packet.Data, size); else packet.ulSum = 0; /* checksum was compute-bound and overkill */
if (size == 0) { /*
* in the last block, in the Data[] field, * we place a SSATTRIBS struct with the file * times and attribs */ attribs = (PSSATTRIBS) packet.Data;
attribs->fileattribs = bhfi.dwFileAttributes; attribs->ft_create = bhfi.ftCreationTime; attribs->ft_lastaccess = bhfi.ftLastAccessTime; attribs->ft_lastwrite = bhfi.ftLastWriteTime;
}
if (!ss_sendblock(hpipe, (PSTR) &packet, sizeof(packet))) { dprintf1(("connection to %8x lost during copy\n", hpipe)); break; }
if (size == 0) { /* end of file */ break; } }
CloseHandle(hfile); DeleteFile(szTempname);
return;}
/*
* compress a file. original is the pathname of the original file, * compressed is the pathname of the output compressed file. * * spawns a copy of compress.exe to compress the file, and waits for * it to complete successfully. */BOOLss_compress(PSTR original, PSTR compressed){ char szCmdLine[MAX_PATH * 2]; STARTUPINFO si; PROCESS_INFORMATION pi; DWORD exitcode;
si.cb = sizeof(STARTUPINFO); si.lpDesktop = NULL; si.lpReserved = NULL; si.lpReserved2 = NULL; si.cbReserved2 = 0; si.lpTitle = "Sumserve Compression"; si.dwFlags = STARTF_FORCEOFFFEEDBACK;
sprintf(szCmdLine, "compress %s %s", original, compressed);
if (!CreateProcess(NULL, szCmdLine, NULL, NULL, FALSE, DETACHED_PROCESS | NORMAL_PRIORITY_CLASS, //??? Can't we silence the console?
NULL, NULL, &si, &pi)) {
return(FALSE); }
/* wait for completion. */ WaitForSingleObject(pi.hProcess, INFINITE); if (!GetExitCodeProcess(pi.hProcess, &exitcode)) { return(FALSE); }
/* close process and thread handles */ CloseHandle(pi.hProcess); CloseHandle(pi.hThread);
if (exitcode != 0) { dprintf1(("compress exit code %ld\n", exitcode)); return(FALSE); } else { return(TRUE); }} /* ss_compress */
/* produce a checksum of a block of data.
* * This is undoubtedly a good checksum algorithm, but it's also compute bound. * For version 1 we turn it off. If we decide in version 2 to turn it back * on again then we will use a faster algorithm (e.g. the one used to checksum * a whole file. * * Generate checksum by the formula * checksum = SUM( rnd(i)*(1+byte[i]) ) * where byte[i] is the i-th byte in the file, counting from 1 * rnd(x) is a pseudo-random number generated from the seed x. * * Adding 1 to byte ensures that all null bytes contribute, rather than * being ignored. Multiplying each such byte by a pseudo-random * function of its position ensures that "anagrams" of each other come * to different sums. The pseudorandom function chosen is successive * powers of 1664525 modulo 2**32. 1664525 is a magic number taken * from Donald Knuth's "The Art Of Computer Programming" */
ULONGss_checksum_block(PSTR block, int size){ unsigned long lCheckSum = 0; /* grows into the checksum */ const unsigned long lSeed = 1664525; /* seed for random Knuth */ unsigned long lRand = 1; /* seed**n */ unsigned long lIndex = 1; /* byte number in block */ unsigned Byte; /* next byte to process in buffer */ unsigned length; /* unsigned copy of size */ length = size; for (Byte = 0; Byte < length ;++Byte, ++lIndex) {
lRand = lRand*lSeed; lCheckSum += lIndex*(1+block[Byte])*lRand; }
return(lCheckSum);} /* ss_checksum_block */
|
