C4UpdatePackage Class Reference

#include <C4Update.h>

Inheritance diagram for C4UpdatePackage:

Collaboration diagram for C4UpdatePackage:

Public Member Functions
bool	Load (C4Group *pGroup)
bool	Execute (C4Group *pGroup)
int	Check (C4Group *pGroup)
bool	MakeUpdate (const char *strFile1, const char *strFile2, const char *strUpdateFile, const char *strName=nullptr)
void	CompileFunc (StdCompiler *pComp)
bool	Load (C4Group &hGroup)
bool	Save (C4Group &hGroup)

Static Public Member Functions
static bool	Optimize (C4Group *pGrpFrom, const char *strTarget)

Public Attributes
int32_t	RequireVersion [4] = { 0, 0, 0, 0 }
char	Name [C4MaxName+1] = { 0 }
char	DestPath [_MAX_PATH_LEN] = { 0 }
int32_t	GrpUpdate = 0
int32_t	UpGrpCnt = 0
uint32_t	GrpChks1 [C4UP_MaxUpGrpCnt] = { 0 }
uint32_t	GrpChks2 = 0

Protected Member Functions
bool	DoUpdate (C4Group *pGrpFrom, class C4GroupEx *pGrpTo, const char *strFileName)
bool	DoGrpUpdate (C4Group *pUpdateData, class C4GroupEx *pGrpTo)
bool	MkUp (C4Group *pGrp1, C4Group *pGrp2, C4GroupEx *pUpGr, bool *fModified)
bool	OpenUnpackParents (C4GroupEx &rGroup, const char *strGroup, const char *strEnsureMaker)
void	WriteLog (const char *strMsg,...) GNUC_FORMAT_ATTRIBUTE_O

Static Protected Member Functions
static bool	Optimize (C4Group *pGrpFrom, class C4GroupEx *pGrpTo, const char *strFileName)

Protected Attributes
CStdFile	Log

Detailed Description

Definition at line 46 of file C4Update.h.

Member Function Documentation

Check()

int C4UpdatePackage::Check

(

C4Group *

pGroup

)

Definition at line 431 of file C4Update.cpp.

{
    // Version requirement is set
    if (RequireVersion[0])
    {
        // Engine and game version must match (rest ignored)
        if ((C4XVER1 != RequireVersion[0]) || (C4XVER2 != RequireVersion[1]))
            return C4UPD_CHK_BAD_VERSION;
    }
 
    // only group updates have any special needs
    if (!GrpUpdate) return C4UPD_CHK_OK;
 
    // check source file
    C4Group TargetGrp;
    if (!TargetGrp.Open(DestPath))
        return C4UPD_CHK_NO_SOURCE;
    if (!TargetGrp.IsPacked())
        return C4UPD_CHK_BAD_SOURCE;
    TargetGrp.Close();
 
    // check source crc
    uint32_t iCRC32;
    if (!GetFileCRC(DestPath, &iCRC32))
        return C4UPD_CHK_BAD_SOURCE;
    // equal to destination group?
    if (iCRC32 == GrpChks2)
        // so there's nothing to do
        return C4UPD_CHK_ALREADY_UPDATED;
    // check if it's one of our registered sources
    int i = 0;
    for (; i < UpGrpCnt; i++)
        if (iCRC32 == GrpChks1[i])
            break;
    if (i >= UpGrpCnt)
        return C4UPD_CHK_BAD_SOURCE;
 
    // ok
    return C4UPD_CHK_OK;
}

References C4UPD_CHK_ALREADY_UPDATED, C4UPD_CHK_BAD_SOURCE, C4UPD_CHK_BAD_VERSION, C4UPD_CHK_NO_SOURCE, C4UPD_CHK_OK, C4Group::Close(), C4UpdatePackageCore::DestPath, GetFileCRC(), C4UpdatePackageCore::GrpChks1, C4UpdatePackageCore::GrpChks2, C4UpdatePackageCore::GrpUpdate, C4Group::IsPacked(), C4Group::Open(), C4UpdatePackageCore::RequireVersion, and C4UpdatePackageCore::UpGrpCnt.

Referenced by C4Group_ApplyUpdate().

Here is the call graph for this function:

Here is the caller graph for this function:

CompileFunc()

void C4UpdatePackageCore::CompileFunc ( StdCompiler *  pComp )

inherited

Definition at line 230 of file C4Update.cpp.

{
    pComp->Value(mkNamingAdapt(toC4CArr(RequireVersion), "RequireVersion"));
    pComp->Value(mkNamingAdapt(toC4CStr(Name), "Name", ""));
    pComp->Value(mkNamingAdapt(toC4CStr(DestPath), "DestPath", ""));
    pComp->Value(mkNamingAdapt(GrpUpdate, "GrpUpdate", 0));
    pComp->Value(mkNamingAdapt(UpGrpCnt, "TargetCount", 0));
    pComp->Value(mkNamingAdapt(toC4CArrU(GrpChks1), "GrpChks1"));
    pComp->Value(mkNamingAdapt(GrpChks2, "GrpChks2", 0u));
}

References C4UpdatePackageCore::DestPath, C4UpdatePackageCore::GrpChks1, C4UpdatePackageCore::GrpChks2, C4UpdatePackageCore::GrpUpdate, mkNamingAdapt(), C4UpdatePackageCore::Name, C4UpdatePackageCore::RequireVersion, toC4CArr, toC4CArrU, toC4CStr, C4UpdatePackageCore::UpGrpCnt, and StdCompiler::Value().

Here is the call graph for this function:

DoGrpUpdate()

bool C4UpdatePackage::DoGrpUpdate ( C4Group *  pUpdateData, class C4GroupEx *  pGrpTo  )

protected

Definition at line 527 of file C4Update.cpp.

{
    char *pData;
    // sort entries
    if (pUpdateData->LoadEntry(C4CFN_UpdateEntries, &pData, nullptr, 1))
    {
        // delete all entries that do not appear in the entries list
        char strItemName[_MAX_FNAME_LEN], strItemName2[_MAX_FNAME_LEN];
        pGrpTo->ResetSearch();
        while (pGrpTo->FindNextEntry("*", strItemName))
        {
            bool fGotIt = false;
            for (int i = 0; (fGotIt = SCopySegment(pData, i, strItemName2, '|', _MAX_FNAME)); i++)
            {
                // remove separator
                char *pSep = strchr(strItemName2, '=');
                if (pSep) *pSep = '\0';
                // in list?
                if (SEqual(strItemName, strItemName2))
                    break;
            }
            if (!fGotIt)
                pGrpTo->DeleteEntry(strItemName);
        }
        // set entry times, set sort list
        char strSortList[32767] = "";
        for (int i = 0; SCopySegment(pData, i, strItemName, '|', _MAX_FNAME); i++)
        {
            // strip checksum/time (if given)
            char *pTime = strchr(strItemName, '=');
            if (pTime) *pTime = '\0';
            // copy to sort list
            SAppend(strItemName, strSortList);
            SAppendChar('|', strSortList);
        }
        // sort by list
        pGrpTo->Sort(strSortList);
        delete[] pData;
    }
    // copy header from update group
    pGrpTo->SetHead(*pUpdateData);
    // ok
    return true;
}

References _MAX_FNAME, _MAX_FNAME_LEN, C4CFN_UpdateEntries, C4Group::DeleteEntry(), C4Group::FindNextEntry(), C4Group::LoadEntry(), C4Group::ResetSearch(), SAppend(), SAppendChar(), SCopySegment(), SEqual(), C4GroupEx::SetHead(), and C4Group::Sort().

Referenced by DoUpdate(), and Execute().

Here is the call graph for this function:

Here is the caller graph for this function:

DoUpdate()

bool C4UpdatePackage::DoUpdate ( C4Group *  pGrpFrom, class C4GroupEx *  pGrpTo, const char *  strFileName  )

protected

Definition at line 472 of file C4Update.cpp.

{
    // group file?
    C4Group ItemGroupFrom;
    if (ItemGroupFrom.OpenAsChild(pGrpFrom, strFileName))
    {
        // try to open target group
        C4GroupEx ItemGroupTo;
        char strTempGroup[_MAX_PATH_LEN]; strTempGroup[0] = 0;
        if (!ItemGroupTo.OpenAsChild(pGrpTo, strFileName, false, true))
            return false;
        // update children
        char ItemFileName[_MAX_PATH];
        ItemGroupFrom.ResetSearch();
        while (ItemGroupFrom.FindNextEntry("*", ItemFileName))
            if (!SEqual(ItemFileName, C4CFN_UpdateCore) && !SEqual(ItemFileName, C4CFN_UpdateEntries))
                DoUpdate(&ItemGroupFrom, &ItemGroupTo, ItemFileName);
        if (GrpUpdate)
        {
            DoGrpUpdate(&ItemGroupFrom, &ItemGroupTo);
            // write group (do not change any headers set by DoGrpUpdate!)
            ItemGroupTo.Close(false);
            // set core (C4Group::Save overwrites it)
            pGrpTo->SaveEntryCore(*pGrpFrom, strFileName);
            pGrpTo->SetSavedEntryCore(strFileName);
            // flag as no-resort
            pGrpTo->SetNoSort(strFileName);
        }
        else
        {
            // write group
            ItemGroupTo.Close(true);
            // temporary group?
            if (strTempGroup[0])
                if (!pGrpTo->Move(strTempGroup, strFileName))
                    return false;
        }
    }
    else
    {
#ifdef _WIN32
        OutputDebugString(FormatString("updating %s\\%s\n", pGrpTo->GetFullName().getData(), strFileName).GetWideChar());
#elif defined(_DEBUG)
        printf("updating %s\\%s\n", pGrpTo->GetFullName().getData(), strFileName);
#endif
        if (!C4Group_CopyEntry(pGrpFrom, pGrpTo, strFileName))
            return false;
        // set core
        pGrpTo->SaveEntryCore(*pGrpFrom, strFileName);
        pGrpTo->SetSavedEntryCore(strFileName);
    }
    // ok
    return true;
}

References _MAX_PATH, _MAX_PATH_LEN, C4CFN_UpdateCore, C4CFN_UpdateEntries, C4Group_CopyEntry(), C4GroupEx::Close(), DoGrpUpdate(), C4Group::FindNextEntry(), FormatString(), StdStrBuf::getData(), C4Group::GetFullName(), C4UpdatePackageCore::GrpUpdate, C4Group::Move(), C4Group::OpenAsChild(), C4Group::ResetSearch(), C4GroupEx::SaveEntryCore(), SEqual(), C4GroupEx::SetNoSort(), and C4GroupEx::SetSavedEntryCore().

Referenced by Execute().

Here is the call graph for this function:

Here is the caller graph for this function:

Execute()

bool C4UpdatePackage::Execute

(

C4Group *

pGroup

)

Definition at line 303 of file C4Update.cpp.

{
 
    // search target
    C4GroupEx TargetGrp;
    char strTarget[_MAX_PATH]; SCopy(DestPath, strTarget, _MAX_PATH);
    char *p = strTarget, *lp = strTarget;
    while ((p = strchr(p + 1, '\\')))
    {
        *p = 0;
        if (!*(p + 1)) break;
        if (!SEqual(lp, ".."))
        {
            if (TargetGrp.Open(strTarget))
            {
                // packed?
                bool fPacked = TargetGrp.IsPacked();
                // Close Group
                TargetGrp.Close(true);
                if (fPacked)
                    // Unpack
                    C4Group_UnpackDirectory(strTarget);
            }
            else
            {
                // GrpUpdate -> file must exist
                if (GrpUpdate) return false;
                // create dir
                CreatePath(strTarget);
            }
        }
        *p = '\\'; lp = p + 1;
    }
 
    // try to open it
    if (!TargetGrp.Open(strTarget, !GrpUpdate))
        return false;
 
    // check if the update is allowed
    if (GrpUpdate)
    {
        // check checksum
        uint32_t iCRC32;
        if (!GetFileCRC(TargetGrp.GetFullName().getData(), &iCRC32))
            return false;
        int i = 0;
        for (; i < UpGrpCnt; i++)
            if (iCRC32 == GrpChks1[i])
                break;
        if (i >= UpGrpCnt)
            return false;
    }
    else
    {
        // only allow Extra.ocg-Updates
        if (!SEqual2(DestPath, "Extra.ocg"))
            return false;
    }
 
    // update children
    char ItemFileName[_MAX_PATH];
    pGroup->ResetSearch();
    while (pGroup->FindNextEntry("*", ItemFileName))
        if (!SEqual(ItemFileName, C4CFN_UpdateCore) && !SEqual(ItemFileName, C4CFN_UpdateEntries))
            DoUpdate(pGroup, &TargetGrp, ItemFileName);
 
    // do GrpUpdate
    if (GrpUpdate)
        DoGrpUpdate(pGroup, &TargetGrp);
 
    // close the group
    TargetGrp.Close(false);
 
    if (GrpUpdate)
    {
        // check the result
        uint32_t iResChks;
        if (!GetFileCRC(strTarget, &iResChks))
            return false;
        if (iResChks != GrpChks2)
        {
#ifdef UPDATE_DEBUG
            char *pData; int iSize;
            CStdFile MyFile; MyFile.Load(strTarget, (BYTE **)&pData, &iSize, 0, true);
            MyFile.Create("DiesesDingIstMist.txt", false);
            MyFile.Write(pData, iSize);
            MyFile.Close();
#endif
            return false;
        }
    }
 
    return true;
}

References _MAX_PATH, C4CFN_UpdateCore, C4CFN_UpdateEntries, C4Group_UnpackDirectory(), C4GroupEx::Close(), CStdFile::Close(), CStdFile::Create(), CreatePath(), C4UpdatePackageCore::DestPath, DoGrpUpdate(), DoUpdate(), C4Group::FindNextEntry(), StdStrBuf::getData(), GetFileCRC(), C4Group::GetFullName(), C4UpdatePackageCore::GrpChks1, C4UpdatePackageCore::GrpChks2, C4UpdatePackageCore::GrpUpdate, iSize, C4Group::IsPacked(), C4Group::Open(), C4Group::ResetSearch(), SCopy(), SEqual(), SEqual2(), C4UpdatePackageCore::UpGrpCnt, and CStdFile::Write().

Referenced by C4Group_ApplyUpdate().

Here is the call graph for this function:

Here is the caller graph for this function:

Load() [1/2]

bool C4UpdatePackageCore::Load ( C4Group &  hGroup )

inherited

Definition at line 241 of file C4Update.cpp.

{
    // Load from group
    StdStrBuf Source;
    if (!hGroup.LoadEntryString(C4CFN_UpdateCore,&Source))
        return false;
    try
    {
        // Compile data
        CompileFromBuf<StdCompilerINIRead>(mkNamingAdapt(*this, "Update"), Source);
    }
    catch (StdCompiler::Exception *pExc)
    {
        delete pExc;
        return false;
    }
    return true;
}

References C4CFN_UpdateCore, C4Group::LoadEntryString(), and mkNamingAdapt().

Referenced by MakeUpdate().

Here is the call graph for this function:

Here is the caller graph for this function:

Load() [2/2]

bool C4UpdatePackage::Load

(

C4Group *

pGroup

)

Definition at line 280 of file C4Update.cpp.

{
    // read update core
    StdStrBuf Source;
    if (!pGroup->LoadEntryString(C4CFN_UpdateCore,&Source))
        return false;
    try
    {
        // Compile data
        CompileFromBuf<StdCompilerINIRead>(mkNamingAdapt(*this, "Update"), Source);
    }
    catch (StdCompiler::Exception *pExc)
    {
        StdStrBuf Name = pGroup->GetFullName() + DirSep + C4CFN_UpdateCore;
        WriteLog("ERROR: %s (in %s)", pExc->Msg.getData(), Name.getData());
        delete pExc;
        return false;
    }
    return true;
}

References C4CFN_UpdateCore, DirSep, StdStrBuf::getData(), C4Group::GetFullName(), C4Group::LoadEntryString(), mkNamingAdapt(), StdCompiler::Exception::Msg, C4UpdatePackageCore::Name, and WriteLog().

Referenced by C4Group_ApplyUpdate().

Here is the call graph for this function:

Here is the caller graph for this function:

MakeUpdate()

bool C4UpdatePackage::MakeUpdate	(	const char *	strFile1,
		const char *	strFile2,
		const char *	strUpdateFile,
		const char *	strName = nullptr
	)

Definition at line 600 of file C4Update.cpp.

{
#ifdef UPDATE_DEBUG
    char *pData; int iSize;
    CStdFile MyFile; MyFile.Load(strFile2, (BYTE **)&pData, &iSize, 0, true);
    MyFile.Create("SoIstRichtig.txt", false);
    MyFile.Write(pData, iSize);
    MyFile.Close();
    MemScramble((BYTE *)pData, iSize);
    MyFile.Create("UndSoAuch.txt", false);
    MyFile.Write(pData, iSize);
    MyFile.Close();
#endif
 
    // open Log
    if (!Log.Create("Update.log"))
        return false;
 
    // begin message
    WriteLog("Source: %s\nTarget: %s\nOutput: %s\n\n", strFile1, strFile2, strUpdateFile);
 
    // open both groups
    C4Group Group1, Group2;
    if (!Group1.Open(strFile1)) { WriteLog("Error: could not open %s!\n", strFile1); return false; }
    if (!Group2.Open(strFile2)) { WriteLog("Error: could not open %s!\n", strFile2); return false; }
 
    // All groups to be compared need to be packed
    if (!Group1.IsPacked()) { WriteLog("Error: source group %s not packed!\n", strFile1); return false; }
    if (!Group2.IsPacked()) { WriteLog("Error: target group %s not packed!\n", strFile2); return false; }
    if (Group1.HasPackedMother()) { WriteLog("Error: source group %s must not have a packed mother group!\n", strFile1); return false; }
    if (Group2.HasPackedMother()) { WriteLog("Error: target group %s must not have a packed mother group!\n", strFile2); return false; }
 
    // create/open update-group
    C4GroupEx UpGroup;
    if (!UpGroup.Open(strUpdateFile, true)) { WriteLog("Error: could not open %s!\n", strUpdateFile); return false; }
 
    // may be continued update-file -> try to load core
    UpGrpCnt = 0;
    bool fContinued = C4UpdatePackageCore::Load(UpGroup);
 
    // save crc2 for later check
    unsigned int iOldChks2 = GrpChks2;
 
    // create core info
    if (strName)
        SCopy(strName, Name, C4MaxName);
    else
        sprintf(Name, "%s Update", GetFilename(strFile1));
    SCopy(strFile1, DestPath, _MAX_PATH);
    GrpUpdate = true;
    if (!GetFileCRC(strFile1, &GrpChks1[UpGrpCnt]))
        { WriteLog("Error: could not calc checksum for %s!\n", strFile1); return false; }
    if (!GetFileCRC(strFile2, &GrpChks2))
        { WriteLog("Error: could not calc checksum for %s!\n", strFile2); return false; }
    if (fContinued)
    {
        // continuation check: GrpChks2 matches?
        if (GrpChks2 != iOldChks2)
            // that would mess up the update result...
            { WriteLog("Error: could not add to update package - target groups don't match (checksum error)\n"); return false; }
        // already supported by this update?
        int i = 0;
        for (; i < UpGrpCnt; i++)
            if (GrpChks1[UpGrpCnt] == GrpChks1[i])
                break;
        if (i < UpGrpCnt)
            { WriteLog("This update already supports the version of the source file.\n"); return false; }
    }
 
    UpGrpCnt++;
 
    // save core
    if (!C4UpdatePackageCore::Save(UpGroup))
        { WriteLog("Could not save update package core!\n"); return false; }
 
    // compare groups, create update
    bool fModified = false;
    bool fSuccess = MkUp(&Group1, &Group2, &UpGroup, &fModified);
    // close (save) it
    UpGroup.Close(false);
    // error?
    if (!fSuccess)
    {
        WriteLog("Update package not created.\n");
        EraseItem(strUpdateFile);
        return false;
    }
 
    WriteLog("Update package created.\n");
    return true;
}

References _MAX_PATH, C4MaxName, C4GroupEx::Close(), CStdFile::Close(), CStdFile::Create(), C4UpdatePackageCore::DestPath, EraseItem(), GetFileCRC(), GetFilename(), C4UpdatePackageCore::GrpChks1, C4UpdatePackageCore::GrpChks2, C4UpdatePackageCore::GrpUpdate, C4Group::HasPackedMother(), iSize, C4Group::IsPacked(), C4UpdatePackageCore::Load(), Log, MemScramble(), MkUp(), C4UpdatePackageCore::Name, C4Group::Open(), C4UpdatePackageCore::Save(), SCopy(), sprintf, C4UpdatePackageCore::UpGrpCnt, CStdFile::Write(), and WriteLog().

Referenced by ProcessGroup().

Here is the call graph for this function:

Here is the caller graph for this function:

MkUp()

bool C4UpdatePackage::MkUp ( C4Group *  pGrp1, C4Group *  pGrp2, C4GroupEx *  pUpGr, bool *  fModified  )

protected

Definition at line 694 of file C4Update.cpp.

{
    // (CAUTION: pGrp1 may be nullptr - that means that there is no counterpart for Grp2
    //           in the base group)
 
    // compare headers
    if (!pGrp1 || pGrp1->EntryCRC32() != pGrp2->EntryCRC32())
        *fModified = true;
    // set header
    pUpGrp->SetHead(*pGrp2);
    // compare entries
    char strItemName[_MAX_PATH], strItemName2[_MAX_PATH]; StdStrBuf EntryList;
    strItemName[0] = strItemName2[0] = 0;
    pGrp2->ResetSearch(); if (!*fModified) pGrp1->ResetSearch();
    int iChangedEntries = 0;
    while (pGrp2->FindNextEntry("*", strItemName, nullptr, !! strItemName[0]))
    {
        // add to entry list
        if (!!EntryList) EntryList.AppendChar('|');
        EntryList.AppendFormat("%s=%d", strItemName, pGrp2->EntryCRC32(strItemName));
        // no modification detected yet? then check order
        if (!*fModified)
        {
            if (!pGrp1->FindNextEntry("*", strItemName2, nullptr, !! strItemName2[0]))
                *fModified = true;
            else if (!SEqual(strItemName, strItemName2))
                *fModified = true;
        }
 
        // TODO: write DeleteEntries.txt
 
        // a child group?
        C4GroupEx ChildGrp2;
        if (ChildGrp2.OpenAsChild(pGrp2, strItemName))
        {
            // open in Grp1
            C4Group *pChildGrp1 = new C4GroupEx();
            if (!pGrp1 || !pChildGrp1->OpenAsChild(pGrp1, strItemName))
                { delete pChildGrp1; pChildGrp1 = nullptr; }
            // open group for update data
            C4GroupEx UpdGroup; char strTempGroupName[_MAX_FNAME_LEN];
            strTempGroupName[0] = 0;
            if (!UpdGroup.OpenAsChild(pUpGrp, strItemName))
            {
                // create new group (may be temporary)
                if (C4Group_TempPath[0]) { SCopy(C4Group_TempPath,strTempGroupName,_MAX_FNAME); SAppend("~upd",strTempGroupName,_MAX_FNAME); }
                else SCopy("~upd",strTempGroupName,_MAX_FNAME);
                MakeTempFilename(strTempGroupName);
                if (!UpdGroup.Open(strTempGroupName, true)) { delete pChildGrp1; WriteLog("Error: could not create temp group\n"); return false; }
            }
            // do nested MkUp-search
            bool Modified = false;
            bool fSuccess = MkUp(pChildGrp1, &ChildGrp2, &UpdGroup, &Modified);
            // sort & close
            extern const char ** C4Group_SortList;
            UpdGroup.SortByList(C4Group_SortList, ChildGrp2.GetName());
            UpdGroup.Close(false);
            // check entry crcs
            if (!pGrp1 || (pGrp1->EntryCRC32(strItemName) != pGrp2->EntryCRC32(strItemName)))
                Modified = true;
            // add group (if modified)
            if (fSuccess && Modified)
            {
                if (strTempGroupName[0])
                    if (!pUpGrp->Move(strTempGroupName, strItemName))
                    {
                        WriteLog("Error: could not add modified group\n");
                        return false;
                    }
                // copy core
                pUpGrp->SaveEntryCore(*pGrp2, strItemName);
                pUpGrp->SetSavedEntryCore(strItemName);
                // got a modification in a subgroup
                *fModified = true;
                iChangedEntries++;
            }
            else
                // delete group (do not remove groups that existed before!)
                if (strTempGroupName[0])
                    if (!EraseItem(strTempGroupName))
                            { WriteLog("Error: could not delete temporary directory\n"); return false; }
            delete pChildGrp1;
        }
        else
        {
            // compare them (size & crc32)
            if (!pGrp1 ||
                pGrp1->EntrySize(strItemName) != pGrp2->EntrySize(strItemName) ||
                pGrp1->EntryCRC32(strItemName) != pGrp2->EntryCRC32(strItemName))
            {
                bool fCopied = false;
 
                // save core (EntryCRC32 might set additional fields)
                pUpGrp->SaveEntryCore(*pGrp2, strItemName);
 
                // already in update grp?
                if (pUpGrp->EntrySize(strItemName) != pGrp2->EntrySize(strItemName) ||
                    pUpGrp->EntryCRC32(strItemName) != pGrp2->EntryCRC32(strItemName))
                {
                    // copy it
                    if (!C4Group_CopyEntry(pGrp2, pUpGrp, strItemName))
                    {
                        WriteLog("Error: could not add changed entry to update group\n");
                        return false;
                    }
                    // set entry core
                    pUpGrp->SetSavedEntryCore(strItemName);
                    // modified...
                    *fModified = true;
                    fCopied = true;
                }
                iChangedEntries++;
 
                WriteLog("%s\\%s: update%s\n", pGrp2->GetFullName().getData(), strItemName, fCopied ? "" : " (already in group)");
            }
        }
    }
    // write entries list (always)
    if (!pUpGrp->Add(C4CFN_UpdateEntries, EntryList, false, true))
    {
        WriteLog("Error: could not save entry list!");
        return false;
    }
 
    if (iChangedEntries > 0)
        WriteLog("%s: %d/%d changed (%s)\n", pGrp2->GetFullName().getData(), iChangedEntries, pGrp2->EntryCount(), *fModified ? "update" : "skip");
 
    // success
    return true;
}

References _MAX_FNAME, _MAX_FNAME_LEN, _MAX_PATH, C4Group::Add(), StdStrBuf::AppendChar(), StdStrBuf::AppendFormat(), C4CFN_UpdateEntries, C4Group_CopyEntry(), C4Group_SortList, C4Group_TempPath, C4GroupEx::Close(), C4Group::EntryCount(), C4Group::EntryCRC32(), C4Group::EntrySize(), EraseItem(), C4Group::FindNextEntry(), StdStrBuf::getData(), C4Group::GetFullName(), C4Group::GetName(), MakeTempFilename(), C4Group::Move(), C4Group::Open(), C4Group::OpenAsChild(), C4Group::ResetSearch(), SAppend(), C4GroupEx::SaveEntryCore(), SCopy(), SEqual(), C4GroupEx::SetHead(), C4GroupEx::SetSavedEntryCore(), C4Group::SortByList(), and WriteLog().

Referenced by MakeUpdate().

Here is the call graph for this function:

Here is the caller graph for this function:

OpenUnpackParents()

bool C4UpdatePackage::OpenUnpackParents ( C4GroupEx &  rGroup, const char *  strGroup, const char *  strEnsureMaker  )

protected

Optimize() [1/2]

bool C4UpdatePackage::Optimize ( C4Group *  pGrpFrom, class C4GroupEx *  pGrpTo, const char *  strFileName  )

staticprotected

Definition at line 572 of file C4Update.cpp.

{
    // group file?
    C4Group ItemGroupFrom;
    if (!ItemGroupFrom.OpenAsChild(pGrpFrom, strFileName))
        return true;
    // try to open target group
    C4GroupEx ItemGroupTo;
    if (!ItemGroupTo.OpenAsChild(pGrpTo, strFileName))
        return true;
    // update children
    char ItemFileName[_MAX_PATH];
    ItemGroupFrom.ResetSearch();
    while (ItemGroupFrom.FindNextEntry("*", ItemFileName))
        Optimize(&ItemGroupFrom, &ItemGroupTo, ItemFileName);
    // set head
    if (ItemGroupTo.HeadIdentical(ItemGroupFrom, true))
        ItemGroupTo.SetHead(ItemGroupFrom);
    // write group (do not change any headers set by DoGrpUpdate!)
    ItemGroupTo.Close(false);
    // set core (C4Group::Save overwrites it)
    pGrpTo->SaveEntryCore(*pGrpFrom, strFileName);
    pGrpTo->SetSavedEntryCore(strFileName);
    return true;
}

References _MAX_PATH, C4GroupEx::Close(), C4Group::FindNextEntry(), C4GroupEx::HeadIdentical(), C4Group::OpenAsChild(), Optimize(), C4Group::ResetSearch(), C4GroupEx::SaveEntryCore(), C4GroupEx::SetHead(), and C4GroupEx::SetSavedEntryCore().

Here is the call graph for this function:

Optimize() [2/2]

bool C4UpdatePackage::Optimize ( C4Group *  pGrpFrom, const char *  strTarget  )

static

Definition at line 398 of file C4Update.cpp.

{
 
    // Open target group
    C4GroupEx TargetGrp;
    if (!TargetGrp.Open(strTarget))
        return false;
 
    // Both groups must be packed
    if (!pGroup->IsPacked() || !TargetGrp.IsPacked())
    {
        TargetGrp.Close(false);
        return false;
    }
 
    // update children
    char ItemFileName[_MAX_PATH];
    pGroup->ResetSearch();
    while (pGroup->FindNextEntry("*", ItemFileName))
        if (!SEqual(ItemFileName, C4CFN_UpdateCore) && !SEqual(ItemFileName, C4CFN_UpdateEntries))
            Optimize(pGroup, &TargetGrp, ItemFileName);
 
    // set header
    if (TargetGrp.HeadIdentical(*pGroup, true))
        TargetGrp.SetHead(*pGroup);
 
    // save
    TargetGrp.Close(false);
 
    // okay
    return true;
}

References _MAX_PATH, C4CFN_UpdateCore, C4CFN_UpdateEntries, C4GroupEx::Close(), C4Group::FindNextEntry(), C4GroupEx::HeadIdentical(), C4Group::IsPacked(), C4Group::Open(), C4Group::ResetSearch(), SEqual(), and C4GroupEx::SetHead().

Referenced by Optimize().

Here is the call graph for this function:

Here is the caller graph for this function:

Save()

bool C4UpdatePackageCore::Save ( C4Group &  hGroup )

inherited

Definition at line 260 of file C4Update.cpp.

{
    try
    {
        // decompile data
        StdStrBuf Core = DecompileToBuf<StdCompilerINIWrite>(mkNamingAdapt(*this, "Update"));
        char *stupid_buffer = new char[Core.getLength() + 1];
        memcpy(stupid_buffer, Core.getMData(), Core.getLength() + 1);
        // add to group
        return hGroup.Add(C4CFN_UpdateCore, stupid_buffer, Core.getLength(), false, true);
    }
    catch (StdCompiler::Exception * pExc)
    {
        delete pExc;
        return false;
    }
}

References C4Group::Add(), C4CFN_UpdateCore, StdStrBuf::getLength(), StdStrBuf::getMData(), and mkNamingAdapt().

Referenced by MakeUpdate().

Here is the call graph for this function:

Here is the caller graph for this function:

WriteLog()

void C4UpdatePackage::WriteLog ( const char *  strMsg,   ...  )

protected

Definition at line 825 of file C4Update.cpp.

{
    va_list arglist; va_start(arglist, strMsg);
    char strOutp[1024];
    vsprintf(strOutp, strMsg, arglist);
    Log.Write(strOutp, strlen(strOutp));
    Log.Flush();
    ::Log(strOutp);
}

References CStdFile::Flush(), Log, and CStdFile::Write().

Referenced by Load(), MakeUpdate(), and MkUp().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

DestPath

char C4UpdatePackageCore::DestPath[_MAX_PATH_LEN] = { 0 }

inherited

Definition at line 30 of file C4Update.h.

Referenced by C4Group_ApplyUpdate(), Check(), C4UpdatePackageCore::CompileFunc(), Execute(), and MakeUpdate().

GrpChks1

uint32_t C4UpdatePackageCore::GrpChks1[C4UP_MaxUpGrpCnt] = { 0 }

inherited

Definition at line 33 of file C4Update.h.

Referenced by Check(), C4UpdatePackageCore::CompileFunc(), Execute(), and MakeUpdate().

GrpChks2

uint32_t C4UpdatePackageCore::GrpChks2 = 0

inherited

Definition at line 33 of file C4Update.h.

Referenced by Check(), C4UpdatePackageCore::CompileFunc(), Execute(), and MakeUpdate().

GrpUpdate

int32_t C4UpdatePackageCore::GrpUpdate = 0

inherited

Definition at line 31 of file C4Update.h.

Referenced by Check(), C4UpdatePackageCore::CompileFunc(), DoUpdate(), Execute(), and MakeUpdate().

Log

CStdFile C4UpdatePackage::Log

protected

Definition at line 65 of file C4Update.h.

Referenced by MakeUpdate(), and WriteLog().

Name

char C4UpdatePackageCore::Name[C4MaxName+1] = { 0 }

inherited

Definition at line 29 of file C4Update.h.

Referenced by C4Group_ApplyUpdate(), C4UpdatePackageCore::CompileFunc(), Load(), and MakeUpdate().

RequireVersion

int32_t C4UpdatePackageCore::RequireVersion[4] = { 0, 0, 0, 0 }

inherited

Definition at line 28 of file C4Update.h.

Referenced by C4Group_ApplyUpdate(), Check(), and C4UpdatePackageCore::CompileFunc().

UpGrpCnt

int32_t C4UpdatePackageCore::UpGrpCnt = 0

inherited

Definition at line 32 of file C4Update.h.

Referenced by Check(), C4UpdatePackageCore::CompileFunc(), Execute(), and MakeUpdate().

---

The documentation for this class was generated from the following files:

• C4Update.h
• C4Update.cpp