CWE-ou-minkata/Sources/Plasma/Apps/plPlasmaUpdate/plManifest.cpp

/*==LICENSE==*

CyanWorlds.com Engine - MMOG client, server and tools
Copyright (C) 2011  Cyan Worlds, Inc.

This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.

You can contact Cyan Worlds, Inc. by email legal@cyan.com
 or by snail mail at:
      Cyan Worlds, Inc.
      14617 N Newport Hwy
      Mead, WA   99021

*==LICENSE==*/
#include "HeadSpin.h"
#include "hsUtils.h"
#include "plManifest.h"

#include "../plEncryption/plChecksum.h"
#include "../plCompression/plZlibStream.h"
#include "../plFile/plEncryptedStream.h"
#include "../plFile/plFileUtils.h"
#include "../plUnifiedTime/plUnifiedTime.h"

class plManifestFile
{
public:
    char* fFilename;
    plMD5Checksum fSum;
    plMD5Checksum fLocalSum;
    UInt32 fSize;
    UInt32 fCompressedSize;
    UInt32 fFlags;
};

plManifest::plManifest(LogFunc log) :
    fDownloadFiles(0),
    fDownloadBytes(0),
    fDirtySums(false),
    fLog(log)
{
}

plManifest::~plManifest()
{
    if (fDirtySums)
        IWriteCache();

    delete [] fManifestName;

    for (int i = 0; i < fFiles.size(); i++)
    {
        delete [] fFiles[i]->fFilename;
        delete fFiles[i];
    }
}

bool plManifest::Read(hsStream* mfsStream, const char* basePath, const char* mfsName)
{
    fBasePath = basePath;
    fManifestName = hsStrcpy(mfsName);

    fLog("--- Reading manifest for %s", fManifestName);

    char buf[256];
    while (mfsStream->ReadLn(buf, sizeof(buf)))
    {
        plManifestFile* file = new plManifestFile;

        char* tok = strtok(buf, "\t");
        file->fFilename = hsStrcpy(tok);

        tok = strtok(nil, "\t");
        file->fSum.SetFromHexString(tok);

        tok = strtok(nil, "\t");
        file->fSize = atoi(tok);

        tok = strtok(nil, "\t");
        file->fCompressedSize = atoi(tok);

        tok = strtok(nil, "\t");
        file->fFlags = atoi(tok);

        fFiles.push_back(file);
    }

    return true;
}

void plManifest::ValidateFiles(ProgressFunc progress)
{
    if (fFiles.empty())
        return;

    fLog("--- Validating files for %s", fManifestName);

    IReadCache(progress);

    fDownloadFiles = 0;
    fDownloadBytes = 0;

    for (int i = 0; i < fFiles.size(); i++)
    {
        plManifestFile* file = fFiles[i];

        // If the local checksum is invalid, this file wasn't in our cache.
        // Get the sum, and update the progress bar.
        if (!file->fLocalSum.IsValid())
        {
            fLog("    No sum for %s, calculating", file->fFilename);
            file->fLocalSum.CalcFromFile(file->fFilename);
            fDirtySums = true;
            progress(file->fFilename, 1);
        }

        if (file->fLocalSum != file->fSum)
        {
            fLog("    Incorrect sum for %s", file->fFilename);
            fDownloadFiles++;
            fDownloadBytes += file->fCompressedSize;
        }
    }

    fLog("---  Need to download %d files, %.1f MB", fDownloadFiles, float(fDownloadBytes) / (1024.f*1024.f));
}

void plManifest::DownloadUpdates(ProgressFunc progress, plFileGrabber* grabber)
{
    for (int i = 0; i < fFiles.size(); i++)
    {
        plManifestFile* file = fFiles[i];
        if (file->fLocalSum != file->fSum)
        {
            char serverPath[MAX_PATH];

            sprintf(serverPath, "%s%s.gz", fBasePath.c_str(), file->fFilename);
            grabber->MakeProperPath(serverPath);

            hsRAMStream serverStream;
            if (grabber->FileToStream(serverPath, &serverStream))
            {
                plFileUtils::EnsureFilePathExists(file->fFilename);

                plFileUtils::RemoveFile(file->fFilename, true);

                plZlibStream localStream;
                if (localStream.Open(file->fFilename, "wb"))
                {
                    char dataBuf[1024];
                    UInt32 sizeLeft = serverStream.GetSizeLeft();
                    while (UInt32 amtRead = serverStream.Read( (sizeof(dataBuf) > sizeLeft) ? sizeLeft : sizeof(dataBuf), dataBuf))
                    {
                        progress(file->fFilename, amtRead);

                        localStream.Write(amtRead, dataBuf);
                        sizeLeft = serverStream.GetSizeLeft();
                    }

                    localStream.Close();

                    // FIXME - Should we recalc this?
                    file->fLocalSum = file->fSum;
                    fDirtySums = true;

                    if (file->fFlags != 0)
                        IDecompressSound(file);
                }
            }
        }
    }
}

plManifestFile* plManifest::IFindFile(const char* name)
{
    // FIXME
    for (int i = 0; i < fFiles.size(); i++)
    {
        if (hsStrEQ(fFiles[i]->fFilename, name))
            return fFiles[i];
    }

    return nil;
}

// KLUDGE - Put age checksums in the dat dir, for backwards compatability
const char* plManifest::IGetCacheDir()
{
    const char* prefix = "";
    if (strncmp(fFiles[0]->fFilename, "dat\\", strlen("dat\\")) == 0)
        return "dat\\";
    else
        return "";
}

#define kCacheFileVersion 1

void plManifest::IWriteCache()
{
    plEncryptedStream s;

    bool openedFile = false;

    UInt32 numFiles = 0;
    for (int i = 0; i < fFiles.size(); i++)
    {
        plManifestFile* file = fFiles[i];

        plUnifiedTime modifiedTime;
        if (file->fLocalSum.IsValid() &&
            plFileUtils::GetFileTimes(file->fFilename, nil, &modifiedTime))
        {
            if (!openedFile)
            {
                openedFile = true;
                char buf[256];
                sprintf(buf, "%s%s.sum", IGetCacheDir(), fManifestName);
                s.Open(buf, "wb");
                s.WriteSwap32(0);
                s.WriteSwap32(kCacheFileVersion);
            }

            s.WriteSafeString(file->fFilename);

            plMD5Checksum& checksum = file->fLocalSum;
            s.Write(checksum.GetSize(), checksum.GetValue());

            modifiedTime.Write(&s);

            numFiles++;
        }
    }

    if (openedFile)
    {
        s.Rewind();
        s.WriteSwap32(numFiles);

        s.Close();
    }
}

void plManifest::IReadCache(ProgressFunc progress)
{
    //
    // Load valid cached checksums
    //
    char buf[256];
    sprintf(buf, "%s%s.sum", IGetCacheDir(), fManifestName);
    hsStream* s = plEncryptedStream::OpenEncryptedFile(buf);

    if (s)
    {
        UInt32 numCached = s->ReadSwap32();
        UInt32 cacheFileVersion = s->ReadSwap32();

        if (cacheFileVersion != kCacheFileVersion)
        {
            s->Close();
            delete s;
            return;
        }

        fLog("  Reading cache...found %d cached sums", numCached);

        for (int i = 0; i < numCached; i++)
        {
            char* name = s->ReadSafeString();

            UInt8 checksumBuf[MD5_DIGEST_LENGTH];
            s->Read(sizeof(checksumBuf), checksumBuf);
            plMD5Checksum checksum;
            checksum.SetValue(checksumBuf);

            plUnifiedTime modifiedTime;
            modifiedTime.Read(s);

            plManifestFile* file = IFindFile(name);
            if (file)
            {
                plUnifiedTime curModifiedTime;
                if (plFileUtils::GetFileTimes(file->fFilename, nil, &curModifiedTime))
                {
                    if (curModifiedTime == modifiedTime)
                        file->fLocalSum = checksum;
                    else
                        fLog("    Invalid modified time for %s", name);
                }
                else
                    fLog("    Couldn't get modified time for %s", name);

                progress(file->fFilename, 1);
            }
            else
                fLog("    Couldn't find cached file '%s' in manifest, discarding", name);


            delete [] name;
        }

        s->Close();
        delete s;
    }
}

#include "../plAudioCore/plAudioFileReader.h"
#include "../plAudio/plOGGCodec.h"
#include "../plAudio/plWavFile.h"


bool plManifest::IDecompressSound(plManifestFile* file)
{
    enum
    {
        kSndFlagCacheSplit          = 1<<0,
        kSndFlagCacheStereo         = 1<<2,
    };

    if (hsCheckBits(file->fFlags, kSndFlagCacheSplit) ||
        hsCheckBits(file->fFlags, kSndFlagCacheStereo))
    {
        plAudioFileReader* reader = plAudioFileReader::CreateReader(file->fFilename, plAudioCore::kAll, plAudioFileReader::kStreamNative);
        if (!reader)
            return false;
        UInt32 size = reader->GetDataSize();
        delete reader;

        if (hsCheckBits(file->fFlags, kSndFlagCacheSplit))
            plAudioFileReader::CacheFile(file->fFilename, true);
        if (hsCheckBits(file->fFlags, kSndFlagCacheStereo))
            plAudioFileReader::CacheFile(file->fFilename, false);
    }

    return true;
}