nel/tools/misc/bnp_make/main.cpp

   1 // NeL - MMORPG Framework <http://dev.ryzom.com/projects/nel/>
   2 // Copyright (C) 2010-2020  Winch Gate Property Limited
   3 //
   4 // This source file has been modified by the following contributors:
   5 // Copyright (C) 2020  Jan BOON (Kaetemi) <jan.boon@kaetemi.be>
   6 //
   7 // This program is free software: you can redistribute it and/or modify
   8 // it under the terms of the GNU Affero General Public License as
   9 // published by the Free Software Foundation, either version 3 of the
  10 // License, or (at your option) any later version.
  11 //
  12 // This program is distributed in the hope that it will be useful,
  13 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 // GNU Affero General Public License for more details.
  16 //
  17 // You should have received a copy of the GNU Affero General Public License
  18 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
  19
  20 #include "nel/misc/types_nl.h"
  21
  22 #include <stdio.h>
  23 #include <stdlib.h>
  24
  25 #ifdef NL_OS_WINDOWS
  26 #       include <io.h>
  27 #       include <direct.h>
  28 #endif
  29
  30 #include <vector>
  31 #include <string>
  32
  33 #include "nel/misc/debug.h"
  34 #include "nel/misc/file.h"
  35 #include "nel/misc/path.h"
  36 #include "nel/misc/algo.h"
  37 #include "nel/misc/common.h"
  38 #include "nel/misc/big_file.h"
  39 #include "nel/misc/cmd_args.h"
  40
  41
  42 using namespace std;
  43 using namespace NLMISC;
  44
  45 // ---------------------------------------------------------------------------
  46
  47 class CWildCard
  48 {
  49 public:
  50         string          Expression;
  51         bool            Not;
  52 };
  53 std::vector<CWildCard>  WildCards;
  54
  55 // ---------------------------------------------------------------------------
  56
  57 bool keepFile (const std::string &fileName)
  58 {
  59         uint i;
  60         bool ifPresent = false;
  61         bool ifTrue = false;
  62         string file = toLowerAscii(CFile::getFilename (fileName));
  63         for (i=0; i<WildCards.size(); i++)
  64         {
  65                 if (WildCards[i].Not)
  66                 {
  67                         // One ifnot condition met and the file is not added
  68                         if (testWildCard(file, WildCards[i].Expression))
  69                                 return false;
  70                 }
  71                 else
  72                 {
  73                         ifPresent = true;
  74                         ifTrue |= testWildCard(file, WildCards[i].Expression);
  75                 }
  76         }
  77
  78         return !ifPresent || ifTrue;
  79 }
  80
  81 // ---------------------------------------------------------------------------
  82
  83 NLMISC::CBigFile::BNP gBNPHeader;
  84
  85 // ---------------------------------------------------------------------------
  86 bool i_comp(const string &s0, const string &s1)
  87 {
  88         return nlstricmp (CFile::getFilename(s0).c_str(), CFile::getFilename(s1).c_str()) < 0;
  89 }
  90
  91 bool packSubRecurse(const std::string &srcDirectory)
  92 {
  93         vector<string>  pathContent;
  94
  95         printf ("Treating directory: %s\n", srcDirectory.c_str());
  96         CPath::getPathContent(srcDirectory, true, false, true, pathContent);
  97
  98         if (pathContent.empty()) return true;
  99
 100         // Sort filename
 101         sort (pathContent.begin(), pathContent.end(), i_comp);
 102
 103         // check for files with same name
 104         for(uint i = 1, len = pathContent.size(); i < len; ++i)
 105         {
 106                 if (toLowerAscii(CFile::getFilename(pathContent[i-1])) == toLowerAscii(CFile::getFilename(pathContent[i])))
 107                 {
 108                         nlwarning("File %s is not unique in BNP!", CFile::getFilename(pathContent[i]).c_str());
 109                         return false;
 110                 }
 111         }
 112
 113         for (uint i=0; i<pathContent.size(); ++i)
 114         {
 115                 if (keepFile(pathContent[i]))
 116                 {
 117                         if (gBNPHeader.appendFile(pathContent[i]))
 118                         {
 119                                 printf("Adding %s\n", pathContent[i].c_str());
 120                         }
 121                         else
 122                         {
 123                                 printf("Error: cannot open %s\n", pathContent[i].c_str());
 124                         }
 125                 }
 126         }
 127
 128         return true;
 129 }
 130
 131 // ---------------------------------------------------------------------------
 132 int main(int argc, char **argv)
 133 {
 134         NLMISC::CApplicationContext myApplicationContext;
 135
 136         NLMISC::CCmdArgs args;
 137
 138         args.addArg("p", "pack", "", "Pack the directory to a BNP file");
 139         args.addArg("u", "unpack", "", "Unpack the BNP file to a directory");
 140         args.addArg("l", "list", "", "List the files contained in the BNP file");
 141         args.addArg("o", "output", "destination", "Output directory or file");
 142         args.addArg("i", "if", "wildcard", "Add the file if it matches the wilcard (at least one 'if' conditions must be met for a file to be adding)", false);
 143         args.addArg("n", "ifnot", "wildcard", "Add the file if it doesn't match the wilcard (all the 'ifnot' conditions must be met for a file to be adding)", false);
 144         args.addArg("", "list-verbose", "", "List files using 'pos size name' format");
 145         args.addArg("", "extract", "name", "Extract file(s) from BNP into --output");
 146         args.addAdditionalArg("input", "Input directory or BNP file depending on command");
 147
 148         if (!args.parse(argc, argv)) return 1;
 149
 150         if (args.haveArg("p"))
 151         {
 152                 std::vector<std::string> filters;
 153
 154                 // If ?
 155                 filters = args.getLongArg("if");
 156
 157                 for (uint i = 0; i < filters.size(); ++i)
 158                 {
 159                         CWildCard card;
 160                         card.Expression = toLowerAscii(filters[i]);
 161                         card.Not = false;
 162                         WildCards.push_back(card);
 163                 }
 164
 165                 // If not ?
 166                 filters = args.getLongArg("ifnot");
 167
 168                 for (uint i = 0; i < filters.size(); ++i)
 169                 {
 170                         CWildCard card;
 171                         card.Expression = toLowerAscii(filters[i]);
 172                         card.Not = true;
 173                         WildCards.push_back(card);
 174                 }
 175
 176                 // Pack a directory
 177                 std::string srcDirectory = args.getAdditionalArg("input").front();
 178
 179                 if (!CFile::isDirectory(srcDirectory) || !CFile::isExists(srcDirectory))
 180                 {
 181                         nlwarning("Error: %s doesn't exist or is not a directory!", srcDirectory.c_str());
 182                 }
 183
 184                 // Output directory or filename
 185                 if (args.haveArg("o"))
 186                 {
 187                         gBNPHeader.BigFileName = args.getArg("o").front();
 188
 189                         if (CFile::isDirectory(gBNPHeader.BigFileName))
 190                         {
 191                                 gBNPHeader.BigFileName = CPath::standardizePath(gBNPHeader.BigFileName) + CFile::getFilename(srcDirectory);
 192                         }
 193                 }
 194                 else
 195                 {
 196                         gBNPHeader.BigFileName = CFile::getFilename(srcDirectory);
 197                 }
 198
 199                 if (CFile::getExtension(gBNPHeader.BigFileName) != "bnp")
 200                         gBNPHeader.BigFileName += ".bnp";
 201
 202                 CFile::deleteFile(gBNPHeader.BigFileName);
 203
 204                 if (!packSubRecurse(srcDirectory)) return 1;
 205
 206                 return gBNPHeader.appendHeader() ? 0:-1;
 207         }
 208
 209         if (args.haveArg("u"))
 210         {
 211                 gBNPHeader.BigFileName = args.getAdditionalArg("input").front();
 212
 213                 std::string dirName;
 214
 215                 // Output directory or filename
 216                 if (args.haveArg("o"))
 217                 {
 218                         dirName = args.getArg("o").front();
 219                 }
 220                 else
 221                 {
 222                         dirName = CFile::getFilenameWithoutExtension(gBNPHeader.BigFileName);
 223                 }
 224
 225                 // Unpack a bnp file
 226                 return gBNPHeader.unpack(dirName) ? 0:-1;
 227         }
 228
 229         if (args.haveArg("l"))
 230         {
 231                 gBNPHeader.BigFileName = args.getAdditionalArg("input").front();
 232
 233                 // Read header of BNP file
 234                 if (!gBNPHeader.readHeader()) return -1;
 235
 236                 for (uint i = 0; i < gBNPHeader.SFiles.size(); ++i)
 237                 {
 238                         printf("%s\n", gBNPHeader.SFiles[i].Name.c_str());
 239                 }
 240
 241                 return 0;
 242         }
 243
 244         if (args.haveLongArg("list-verbose"))
 245         {
 246                 gBNPHeader.BigFileName = args.getAdditionalArg("input").front();
 247
 248                 // Read header of BNP file
 249                 if (!gBNPHeader.readHeader()) return -1;
 250
 251                 for (uint i = 0; i < gBNPHeader.SFiles.size(); ++i)
 252                 {
 253                         printf("%u %u %s\n", gBNPHeader.SFiles[i].Pos, gBNPHeader.SFiles[i].Size, gBNPHeader.SFiles[i].Name.c_str());
 254                 }
 255
 256                 return 0;
 257         }
 258
 259         // --extract <name>
 260         if (args.haveLongArg("extract") && !args.getLongArg("extract").empty())
 261         {
 262                 std::string bnpName = args.getAdditionalArg("input").front();
 263                 CBigFile::getInstance().add(bnpName, BF_ALWAYS_OPENED);
 264
 265                 // Output directory or filename
 266                 if (!args.haveArg("o") || args.getArg("o").empty())
 267                 {
 268                         nlerror("Output file or directory not set");
 269                 }
 270
 271                 std::string srcName = args.getLongArg("extract").front();
 272                 std::string dstName = args.getArg("o").front();
 273                 if (CFile::fileExists(dstName) && CFile::isDirectory(dstName))
 274                 {
 275                         dstName += "/" + srcName;
 276                 }
 277
 278                 CIFile inFile;
 279                 // bnpName without path
 280                 if (!inFile.open(CFile::getFilename(bnpName) + "@" + srcName))
 281                 {
 282                         nlerror("Unable to open '%s' for reading", inFile.getStreamName().c_str());
 283                 }
 284
 285                 COFile outFile;
 286                 if (!outFile.open(dstName))
 287                 {
 288                         nlerror("Unable to open '%s' for writing", outFile.getStreamName().c_str());
 289                 }
 290
 291                 std::string buf;
 292                 inFile.readAll(buf);
 293                 outFile.serialBuffer((uint8 *)&buf[0], buf.size());
 294
 295                 return 0;
 296         }
 297
 298         args.displayHelp();
 299         return -1;
 300 }