src/filecache.cpp

   1 /*
   2 Minetest
   3 Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
   4 Copyright (C) 2013 Jonathan Neuschäfer <j.neuschaefer@gmx.net>
   5
   6 This program is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU Lesser General Public License as published by
   8 the Free Software Foundation; either version 2.1 of the License, or
   9 (at your option) any later version.
  10
  11 This program is distributed in the hope that it will be useful,
  12 but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 GNU Lesser General Public License for more details.
  15
  16 You should have received a copy of the GNU Lesser General Public License along
  17 with this program; if not, write to the Free Software Foundation, Inc.,
  18 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  19 */
  20
  21 #include "filecache.h"
  22
  23 #include "clientserver.h"
  24 #include "log.h"
  25 #include "filesys.h"
  26 #include "hex.h"
  27 #include "sha1.h"
  28 #include <string>
  29 #include <iostream>
  30 #include <fstream>
  31 #include <sstream>
  32
  33 bool FileCache::loadByPath(const std::string &path, std::ostream &os)
  34 {
  35         std::ifstream fis(path.c_str(), std::ios_base::binary);
  36
  37         if(!fis.good()){
  38                 verbosestream<<"FileCache: File not found in cache: "
  39                                 <<path<<std::endl;
  40                 return false;
  41         }
  42
  43         bool bad = false;
  44         for(;;){
  45                 char buf[1024];
  46                 fis.read(buf, 1024);
  47                 std::streamsize len = fis.gcount();
  48                 os.write(buf, len);
  49                 if(fis.eof())
  50                         break;
  51                 if(!fis.good()){
  52                         bad = true;
  53                         break;
  54                 }
  55         }
  56         if(bad){
  57                 errorstream<<"FileCache: Failed to read file from cache: \""
  58                                 <<path<<"\""<<std::endl;
  59         }
  60
  61         return !bad;
  62 }
  63
  64 bool FileCache::updateByPath(const std::string &path, const std::string &data)
  65 {
  66         std::ofstream file(path.c_str(), std::ios_base::binary |
  67                         std::ios_base::trunc);
  68
  69         if(!file.good())
  70         {
  71                 errorstream<<"FileCache: Can't write to file at "
  72                                 <<path<<std::endl;
  73                 return false;
  74         }
  75
  76         file.write(data.c_str(), data.length());
  77         file.close();
  78
  79         return !file.fail();
  80 }
  81
  82 bool FileCache::update(const std::string &name, const std::string &data)
  83 {
  84         std::string path = m_dir + DIR_DELIM + name;
  85         return updateByPath(path, data);
  86 }
  87 bool FileCache::update_sha1(const std::string &data)
  88 {
  89         SHA1 sha1;
  90         sha1.addBytes(data.c_str(), data.size());
  91         unsigned char *digest = sha1.getDigest();
  92         std::string sha1_raw((char*)digest, 20);
  93         free(digest);
  94         std::string sha1_hex = hex_encode(sha1_raw);
  95         return update(sha1_hex, data);
  96 }
  97 bool FileCache::load(const std::string &name, std::ostream &os)
  98 {
  99         std::string path = m_dir + DIR_DELIM + name;
 100         return loadByPath(path, os);
 101 }
 102 bool FileCache::load_sha1(const std::string &sha1_raw, std::ostream &os)
 103 {
 104         std::ostringstream tmp_os(std::ios_base::binary);
 105         if(!load(hex_encode(sha1_raw), tmp_os))
 106                 return false;
 107         SHA1 sha1;
 108         sha1.addBytes(tmp_os.str().c_str(), tmp_os.str().length());
 109         unsigned char *digest = sha1.getDigest();
 110         std::string sha1_real_raw((char*)digest, 20);
 111         free(digest);
 112         if(sha1_real_raw != sha1_raw){
 113                 verbosestream<<"FileCache["<<m_dir<<"]: filename "<<sha1_real_raw
 114                                 <<" mismatches actual checksum"<<std::endl;
 115                 return false;
 116         }
 117         os<<tmp_os.str();
 118         return true;
 119 }