mirror of https://github.com/lianthony/NT4.0
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
326 lines
7.7 KiB
326 lines
7.7 KiB
#include "precomp.h"
|
|
#pragma hdrstop
|
|
EnableAssert
|
|
|
|
char rgchIn[] = "(stdin)";
|
|
char rgchOut[] = "(stdout)";
|
|
char rgchErr[] = "(stderr)";
|
|
char rgchLog[] = "(log)";
|
|
char rgchLocal1[] = "(local1)";
|
|
char rgchLocal2[] = "(local2)";
|
|
MF mfStdin = { (PTH *)rgchIn, "", 0, fdNil, fxNil, fFalse, mmNil ,0L };
|
|
MF mfStdout = { (PTH *)rgchOut, "", fdNil, 1, fxNil, fFalse, mmNil ,0L };
|
|
MF mfStderr = { (PTH *)rgchErr, "", fdNil, 2, fxNil, fFalse, mmNil ,0L };
|
|
MF mfStdlog = { (PTH *)rgchLog, "", fdNil, fdNil, fxNil, fFalse, mmNil ,0L };
|
|
|
|
MF mfLocal1 = { (PTH *)rgchLocal1, "", fdNil, fdNil, fxNil, fFalse, mmNil ,0L };
|
|
MF mfLocal2 = { (PTH *)rgchLocal2, "", fdNil, fdNil, fxNil, fFalse, mmNil ,0L };
|
|
|
|
/* four mf to allocate; pthReal==0 indicates availability; other fields
|
|
always valid (i.e. so FreeMf and CloseMf do nothing).
|
|
*/
|
|
MF mf1 = { (PTH *)0, "", fdNil, fdNil, fxNil, fFalse, mmNil, -1L };
|
|
MF mf2 = { (PTH *)0, "", fdNil, fdNil, fxNil, fFalse, mmNil, -1L };
|
|
MF mf3 = { (PTH *)0, "", fdNil, fdNil, fxNil, fFalse, mmNil, -1L };
|
|
MF mf4 = { (PTH *)0, "", fdNil, fdNil, fxNil, fFalse, mmNil, -1L };
|
|
|
|
|
|
void
|
|
InitLogHandle(
|
|
AD *pad,
|
|
char *pszLogName)
|
|
{
|
|
if (!_stricmp(pszLogName, "nul"))
|
|
return;
|
|
|
|
mfStdlog.pthReal = malloc(strlen(pszLogName) + 1);
|
|
if (mfStdlog.pthReal)
|
|
{
|
|
strcpy(mfStdlog.pthReal, pszLogName);
|
|
mfStdlog.fdWrite = _open(mfStdlog.pthReal, O_APPEND|O_WRONLY|O_CREAT,
|
|
S_IREAD|S_IWRITE);
|
|
}
|
|
|
|
if (mfStdlog.fdWrite == fdNil)
|
|
FatalError("Unable to open log file (%s) for write access\n",
|
|
pszLogName );
|
|
}
|
|
|
|
|
|
void
|
|
CloseLogHandle(
|
|
void)
|
|
{
|
|
if (mfStdlog.fdWrite != fdNil)
|
|
{
|
|
_close(mfStdlog.fdWrite);
|
|
mfStdlog.fdWrite = fdNil;
|
|
}
|
|
}
|
|
|
|
|
|
/* Open one of the two static MF structures dedicated for local files.
|
|
*/
|
|
MF *
|
|
OpenLocalMf(
|
|
char *pszLocalFileName)
|
|
{
|
|
register MF *pmf;
|
|
int wRetErr;
|
|
|
|
if (mfLocal1.fdWrite == fdNil)
|
|
pmf = &mfLocal1;
|
|
else
|
|
if (mfLocal2.fdWrite == fdNil)
|
|
pmf = &mfLocal2;
|
|
else
|
|
{
|
|
AssertF(fFalse);
|
|
return NULL;
|
|
}
|
|
pmf->pthReal = malloc(strlen(pszLocalFileName) + 1);
|
|
if (pmf->pthReal)
|
|
{
|
|
strcpy(pmf->pthReal, pszLocalFileName);
|
|
pmf->fdWrite = _open(pmf->pthReal, O_APPEND|O_WRONLY|O_CREAT,
|
|
S_IREAD|S_IWRITE);
|
|
}
|
|
|
|
if (pmf->fdWrite == fdNil)
|
|
FatalError("Unable to open file (%s) for write access\n",
|
|
pszLocalFileName);
|
|
else {
|
|
pmf->pos = SeekMf(pmf, (POS)0, 2);
|
|
pmf->fWritten = fFalse;
|
|
}
|
|
|
|
return pmf;
|
|
}
|
|
|
|
void
|
|
CloseLocalMf(AD *pad)
|
|
{
|
|
if (mfLocal1.fdWrite != fdNil && mfLocal1.fWritten)
|
|
{
|
|
if (!_stricmp( pad->pecmd->szCmd, "status" ))
|
|
Warn("Backup script written to %s\n", mfLocal1.pthReal);
|
|
else
|
|
Warn("SSync log written to %s\n", mfLocal1.pthReal);
|
|
|
|
_close( mfLocal1.fdWrite );
|
|
mfLocal1.fdWrite = fdNil;
|
|
mfLocal1.fWritten = fFalse;
|
|
}
|
|
|
|
if (mfLocal2.fdWrite != fdNil && mfLocal2.fWritten)
|
|
{
|
|
Warn("Backup script for local files written to %s\n", mfLocal2.pthReal);
|
|
_close( mfLocal2.fdWrite );
|
|
mfLocal2.fdWrite = fdNil;
|
|
mfLocal2.fWritten = fFalse;
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
void
|
|
AssertNoMf(
|
|
void)
|
|
{
|
|
AssertF(mf1.pthReal == 0);
|
|
AssertF(mf2.pthReal == 0);
|
|
AssertF(mf3.pthReal == 0);
|
|
AssertF(mf4.pthReal == 0);
|
|
AssertF(FEmptyNm(mf1.nmTemp));
|
|
AssertF(FEmptyNm(mf2.nmTemp));
|
|
AssertF(FEmptyNm(mf3.nmTemp));
|
|
AssertF(FEmptyNm(mf4.nmTemp));
|
|
AssertF(mf1.fdRead == fdNil);
|
|
AssertF(mf2.fdRead == fdNil);
|
|
AssertF(mf3.fdRead == fdNil);
|
|
AssertF(mf4.fdRead == fdNil);
|
|
AssertF(mf1.fdWrite == fdNil);
|
|
AssertF(mf2.fdWrite == fdNil);
|
|
AssertF(mf3.fdWrite == fdNil);
|
|
AssertF(mf4.fdWrite == fdNil);
|
|
AssertF(!mf1.fFileLock);
|
|
AssertF(!mf2.fFileLock);
|
|
AssertF(!mf3.fFileLock);
|
|
AssertF(!mf4.fFileLock);
|
|
AssertF(mf1.mm == mmNil);
|
|
AssertF(mf2.mm == mmNil);
|
|
AssertF(mf3.mm == mmNil);
|
|
AssertF(mf4.mm == mmNil);
|
|
}
|
|
|
|
|
|
/* return fTrue if the mf is allocated and otherwise valid */
|
|
F
|
|
FIsValidMf(
|
|
MF *pmf)
|
|
{
|
|
if (pmf != &mfStdin &&
|
|
pmf != &mfStdout &&
|
|
pmf != &mfStderr &&
|
|
pmf != &mfStdlog &&
|
|
pmf != &mfLocal1 &&
|
|
pmf != &mfLocal2 &&
|
|
pmf != &mf1 &&
|
|
pmf != &mf2 &&
|
|
pmf != &mf3 &&
|
|
pmf != &mf4)
|
|
return fFalse;
|
|
|
|
if (pmf->pthReal == 0)
|
|
return fFalse;
|
|
|
|
/* check for proper configuration */
|
|
switch(pmf->mm)
|
|
{
|
|
default:
|
|
AssertF(fFalse);
|
|
|
|
case mmNil:
|
|
break;
|
|
|
|
case mmDelTemp:
|
|
case mmInstall:
|
|
case mmInstall1Ed:
|
|
case mmRenTemp:
|
|
case mmRenTempRO:
|
|
case mmRenReal:
|
|
case mmAppToReal:
|
|
case mmCreate:
|
|
if (FEmptyNm(pmf->nmTemp))
|
|
return fFalse;
|
|
break;
|
|
|
|
case mmDelReal:
|
|
case mmSetRO:
|
|
case mmSetRW:
|
|
if (!FEmptyNm(pmf->nmTemp))
|
|
return fFalse;
|
|
break;
|
|
}
|
|
|
|
if (pmf->fFileLock && pmf->fdWrite < 0)
|
|
return fFalse;
|
|
|
|
return fTrue;
|
|
}
|
|
|
|
|
|
/* return fTrue if the mf is valid and open */
|
|
F
|
|
FIsOpenMf(
|
|
MF *pmf)
|
|
{
|
|
return FIsValidMf(pmf) && (pmf->fdRead >= 0 || pmf->fdWrite >= 0);
|
|
}
|
|
|
|
|
|
/* return fTrue if the mf is valid and closed */
|
|
F
|
|
FIsClosedMf(
|
|
MF *pmf)
|
|
{
|
|
return FIsValidMf(pmf) && pmf->fdRead < 0 && pmf->fdWrite < 0;
|
|
}
|
|
|
|
|
|
void
|
|
AbortMf(
|
|
void)
|
|
{
|
|
if (mf1.pthReal != 0)
|
|
CloseMf(&mf1);
|
|
if (mf2.pthReal != 0)
|
|
CloseMf(&mf2);
|
|
if (mf3.pthReal != 0)
|
|
CloseMf(&mf3);
|
|
if (mf4.pthReal != 0)
|
|
CloseMf(&mf4);
|
|
}
|
|
|
|
|
|
/* allocate new MF; retains pointer to pthReal! Must free via FreeMf (or
|
|
CloseMf which calls FreeMf). mm set to mmNil.
|
|
*/
|
|
MF *
|
|
PmfAlloc(
|
|
PTH pthReal[],
|
|
char *szTemp, /* 0 -> use base of pthReal */
|
|
FX fx)
|
|
{
|
|
register MF *pmf;
|
|
|
|
AssertF(pthReal != 0);
|
|
|
|
if (mf1.pthReal == 0)
|
|
pmf = &mf1;
|
|
else if (mf2.pthReal == 0)
|
|
pmf = &mf2;
|
|
else if (mf3.pthReal == 0)
|
|
pmf = &mf3;
|
|
else if (mf4.pthReal == 0)
|
|
pmf = &mf4;
|
|
else
|
|
AssertF(fFalse);
|
|
|
|
/* initialize contents which are not already initialized */
|
|
pmf->fx = fx;
|
|
pmf->pthReal = pthReal;
|
|
pmf->fNoBuffering = fFalse;
|
|
pmf->fWritten = fFalse;
|
|
if (szTemp != 0)
|
|
NmCopySz(pmf->nmTemp, szTemp, cchFileMax);
|
|
|
|
AssertF(FIsClosedMf(pmf));
|
|
|
|
return pmf;
|
|
}
|
|
|
|
|
|
/* Records the mf (if not already) and makes the mf available for use; we
|
|
ensure that the mf is back the initial state
|
|
*/
|
|
void
|
|
FreeMf(
|
|
MF *pmf)
|
|
{
|
|
static char *mpmmsz[] =
|
|
{
|
|
"nil\n", /* mmNil */
|
|
"delete %@T\n", /* mmDelTemp */
|
|
"clear %@R\n", /* mmDelReal */
|
|
"rename %@T %@R\n", /* mmRenTemp */
|
|
"install %@T %@R\n", /* mmInstall */
|
|
"renreal %@T %@R\n", /* mmRenReal */
|
|
"append %@T %@R\n", /* mmAppToReal */
|
|
"makero %@R\n", /* mmSetRO */
|
|
"makerw %@R\n", /* mmSetRW */
|
|
"rename %@T %@R\n", /* mmRenTempRO ( + makero) */
|
|
"link %@R %@N\n", /* mmLinkReal */
|
|
"create %@R\n", /* mmCreate */
|
|
"install1Ed %@T %@R\n" /* mmInstall1Ed */
|
|
};
|
|
|
|
AssertF(FIsClosedMf(pmf));
|
|
|
|
if (pmf->mm != mmNil)
|
|
{
|
|
AppendScript(pmf->fx, mpmmsz[pmf->mm], pmf, pmf);
|
|
if (pmf->mm == mmRenTempRO)
|
|
AppendScript(pmf->fx, mpmmsz[mmSetRO], pmf, pmf);
|
|
}
|
|
|
|
pmf->mm = mmNil;
|
|
pmf->fx = fxNil;
|
|
pmf->pthReal = 0;
|
|
*pmf->nmTemp = '\0';
|
|
pmf->fdRead = fdNil;
|
|
pmf->fdWrite = fdNil;
|
|
pmf->fFileLock = fFalse;
|
|
pmf->fNoBuffering = fFalse;
|
|
pmf->fWritten = fFalse;
|
|
}
|