summaryrefslogtreecommitdiff
path: root/src/serialization.cpp
blob: 79f66fcaebb15b3c8d4fc2c2f21600c03d97b6e1 (plain) 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270

/*
Minetest
Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>

This program is free software; you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation; either version 2.1 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 Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License along
with this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/

#include "serialization.h"

#include "util/serialize.h"
#ifdef _WIN32
	#define ZLIB_WINAPI
#endif
#include "zlib.h"

/* report a zlib or i/o error */
void zerr(int ret)
{   
    dstream<<"zerr: ";
    switch (ret) {
    case Z_ERRNO:
        if (ferror(stdin))
            dstream<<"error reading stdin"<<std::endl;
        if (ferror(stdout))
            dstream<<"error writing stdout"<<std::endl;
        break;
    case Z_STREAM_ERROR:
        dstream<<"invalid compression level"<<std::endl;
        break;
    case Z_DATA_ERROR:
        dstream<<"invalid or incomplete deflate data"<<std::endl;
        break;
    case Z_MEM_ERROR:
        dstream<<"out of memory"<<std::endl;
        break;
    case Z_VERSION_ERROR:
        dstream<<"zlib version mismatch!"<<std::endl;
		break;
	default:
		dstream<<"return value = "<<ret<<std::endl;
    }
}

void compressZlib(SharedBuffer<u8> data, std::ostream &os, int level)
{
	z_stream z;
	const s32 bufsize = 16384;
	char output_buffer[bufsize];
	int status = 0;
	int ret;

	z.zalloc = Z_NULL;
	z.zfree = Z_NULL;
	z.opaque = Z_NULL;

	ret = deflateInit(&z, level);
	if(ret != Z_OK)
		throw SerializationError("compressZlib: deflateInit failed");
	
	// Point zlib to our input buffer
	z.next_in = (Bytef*)&data[0];
	z.avail_in = data.getSize();
	// And get all output
	for(;;)
	{
		z.next_out = (Bytef*)output_buffer;
		z.avail_out = bufsize;
		
		status = deflate(&z, Z_FINISH);
		if(status == Z_NEED_DICT || status == Z_DATA_ERROR
				|| status == Z_MEM_ERROR)
		{
			zerr(status);
			throw SerializationError("compressZlib: deflate failed");
		}
		int count = bufsize - z.avail_out;
		if(count)
			os.write(output_buffer, count);
		// This determines zlib has given all output
		if(status == Z_STREAM_END)
			break;
	}

	deflateEnd(&z);
}

void compressZlib(const std::string &data, std::ostream &os, int level)
{
	SharedBuffer<u8> databuf((u8*)data.c_str(), data.size());
	compressZlib(databuf, os, level);
}

void decompressZlib(std::istream &is, std::ostream &os)
{
	z_stream z;
	const s32 bufsize = 16384;
	char input_buffer[bufsize];
	char output_buffer[bufsize];
	int status = 0;
	int ret;
	int bytes_read = 0;
	int input_buffer_len = 0;

	z.zalloc = Z_NULL;
	z.zfree = Z_NULL;
	z.opaque = Z_NULL;

	ret = inflateInit(&z);
	if(ret != Z_OK)
		throw SerializationError("dcompressZlib: inflateInit failed");
	
	z.avail_in = 0;
	
	//dstream<<"initial fail="<<is.fail()<<" bad="<<is.bad()<<std::endl;

	for(;;)
	{
		z.next_out = (Bytef*)output_buffer;
		z.avail_out = bufsize;

		if(z.avail_in == 0)
		{
			z.next_in = (Bytef*)input_buffer;
			is.read(input_buffer, bufsize);
			input_buffer_len = is.gcount();
			z.avail_in = input_buffer_len;
			//dstream<<"read fail="<<is.fail()<<" bad="<<is.bad()<<std::endl;
		}
		if(z.avail_in == 0)
		{
			//dstream<<"z.avail_in == 0"<<std::endl;
			break;
		}
			
		//dstream<<"1 z.avail_in="<<z.avail_in<<std::endl;
		status = inflate(&z, Z_NO_FLUSH);
		//dstream<<"2 z.avail_in="<<z.avail_in<<std::endl;
		bytes_read += is.gcount() - z.avail_in;
		//dstream<<"bytes_read="<<bytes_read<<std::endl;

		if(status == Z_NEED_DICT || status == Z_DATA_ERROR
				|| status == Z_MEM_ERROR)
		{
			zerr(status);
			throw SerializationError("decompressZlib: inflate failed");
		}
		int count = bufsize - z.avail_out;
		//dstream<<"count="<<count<<std::endl;
		if(count)
			os.write(output_buffer, count);
		if(status == Z_STREAM_END)
		{
			//dstream<<"Z_STREAM_END"<<std::endl;
			
			//dstream<<"z.avail_in="<<z.avail_in<<std::endl;
			//dstream<<"fail="<<is.fail()<<" bad="<<is.bad()<<std::endl;
			// Unget all the data that inflate didn't take
			is.clear(); // Just in case EOF is set
			for(u32 i=0; i < z.avail_in; i++)
			{
				is.unget();
				if(is.fail() || is.bad())
				{
					dstream<<"unget #"<<i<<" failed"<<std::endl;
					dstream<<"fail="<<is.fail()<<" bad="<<is.bad()<<std::endl;
					throw SerializationError("decompressZlib: unget failed");
				}
			}
			
			break;
		}
	}

	inflateEnd(&z);
}

void compress(SharedBuffer<u8> data, std::ostream &os, u8 version)
{
	if(version >= 11)
	{
		compressZlib(data, os);
		return;
	}

	if(data.getSize() == 0)
		return;
	
	// Write length (u32)

	u8 tmp[4];
	writeU32(tmp, data.getSize());
	os.write((char*)tmp, 4);
	
	// We will be writing 8-bit pairs of more_count and byte
	u8 more_count = 0;
	u8 current_byte = data[0];
	for(u32 i=1; i<data.getSize(); i++)
	{
		if(
			data[i] != current_byte
			|| more_count == 255
		)
		{
			// write count and byte
			os.write((char*)&more_count, 1);
			os.write((char*)&current_byte, 1);
			more_count = 0;
			current_byte = data[i];
		}
		else
		{
			more_count++;
		}
	}
	// write count and byte
	os.write((char*)&more_count, 1);
	os.write((char*)&current_byte, 1);
}

void decompress(std::istream &is, std::ostream &os, u8 version)
{
	if(version >= 11)
	{
		decompressZlib(is, os);
		return;
	}

	// Read length (u32)

	u8 tmp[4];
	is.read((char*)tmp, 4);
	u32 len = readU32(tmp);
	
	// We will be reading 8-bit pairs of more_count and byte
	u32 count = 0;
	for(;;)
	{
		u8 more_count=0;
		u8 byte=0;

		is.read((char*)&more_count, 1);
		
		is.read((char*)&byte, 1);

		if(is.eof())
			throw SerializationError("decompress: stream ended halfway");

		for(s32 i=0; i<(u16)more_count+1; i++)
			os.write((char*)&byte, 1);

		count += (u16)more_count+1;

		if(count == len)
			break;
	}
}
generated by cgit v1.2.3 (git 2.25.1) at 2024-07-03 22:04:55 +0000
"hl opt">()); bool is_directory = (attr != INVALID_FILE_ATTRIBUTES && (attr & FILE_ATTRIBUTE_DIRECTORY)); if(!is_directory) { infostream<<"RecursiveDelete: Deleting file "<<path<<std::endl; //bool did = DeleteFile(path.c_str()); bool did = true; if(!did){ errorstream<<"RecursiveDelete: Failed to delete file " <<path<<std::endl; return false; } } else { infostream<<"RecursiveDelete: Deleting content of directory " <<path<<std::endl; std::vector<DirListNode> content = GetDirListing(path); for(size_t i=0; i<content.size(); i++){ const DirListNode &n = content[i]; std::string fullpath = path + DIR_DELIM + n.name; bool did = RecursiveDelete(fullpath); if(!did){ errorstream<<"RecursiveDelete: Failed to recurse to " <<fullpath<<std::endl; return false; } } infostream<<"RecursiveDelete: Deleting directory "<<path<<std::endl; //bool did = RemoveDirectory(path.c_str(); bool did = true; if(!did){ errorstream<<"Failed to recursively delete directory " <<path<<std::endl; return false; } } return true; } bool DeleteSingleFileOrEmptyDirectory(const std::string &path) { DWORD attr = GetFileAttributes(path.c_str()); bool is_directory = (attr != INVALID_FILE_ATTRIBUTES && (attr & FILE_ATTRIBUTE_DIRECTORY)); if(!is_directory) { bool did = DeleteFile(path.c_str()); return did; } else { bool did = RemoveDirectory(path.c_str()); return did; } } std::string TempPath() { DWORD bufsize = GetTempPath(0, NULL); if(bufsize == 0){ errorstream<<"GetTempPath failed, error = "<<GetLastError()<<std::endl; return ""; } std::vector<char> buf(bufsize); DWORD len = GetTempPath(bufsize, &buf[0]); if(len == 0 || len > bufsize){ errorstream<<"GetTempPath failed, error = "<<GetLastError()<<std::endl; return ""; } return std::string(buf.begin(), buf.begin() + len); } #else // POSIX #include <sys/types.h> #include <dirent.h> #include <sys/stat.h> #include <sys/wait.h> #include <unistd.h> std::vector<DirListNode> GetDirListing(const std::string &pathstring) { std::vector<DirListNode> listing; DIR *dp; struct dirent *dirp; if((dp = opendir(pathstring.c_str())) == NULL) { //infostream<<"Error("<<errno<<") opening "<<pathstring<<std::endl; return listing; } while ((dirp = readdir(dp)) != NULL) { // NOTE: // Be very sure to not include '..' in the results, it will // result in an epic failure when deleting stuff. if(strcmp(dirp->d_name, ".") == 0 || strcmp(dirp->d_name, "..") == 0) continue; DirListNode node; node.name = dirp->d_name; int isdir = -1; // -1 means unknown /* POSIX doesn't define d_type member of struct dirent and certain filesystems on glibc/Linux will only return DT_UNKNOWN for the d_type member. Also we don't know whether symlinks are directories or not. */ #ifdef _DIRENT_HAVE_D_TYPE if(dirp->d_type != DT_UNKNOWN && dirp->d_type != DT_LNK) isdir = (dirp->d_type == DT_DIR); #endif /* _DIRENT_HAVE_D_TYPE */ /* Was d_type DT_UNKNOWN, DT_LNK or nonexistent? If so, try stat(). */ if(isdir == -1) { struct stat statbuf; if (stat((pathstring + "/" + node.name).c_str(), &statbuf)) continue; isdir = ((statbuf.st_mode & S_IFDIR) == S_IFDIR); } node.dir = isdir; listing.push_back(node); } closedir(dp); return listing; } bool CreateDir(const std::string &path) { int r = mkdir(path.c_str(), S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH); if(r == 0) { return true; } else { // If already exists, return true if(errno == EEXIST) return true; return false; } } bool PathExists(const std::string &path) { struct stat st; return (stat(path.c_str(),&st) == 0); } bool IsPathAbsolute(const std::string &path) { return path[0] == '/'; } bool IsDir(const std::string &path) { struct stat statbuf; if(stat(path.c_str(), &statbuf)) return false; // Actually error; but certainly not a directory return ((statbuf.st_mode & S_IFDIR) == S_IFDIR); } bool IsDirDelimiter(char c) { return c == '/'; } bool RecursiveDelete(const std::string &path) { /* Execute the 'rm' command directly, by fork() and execve() */ infostream<<"Removing \""<<path<<"\""<<std::endl; //return false; pid_t child_pid = fork(); if(child_pid == 0) { // Child char argv_data[3][10000]; strcpy(argv_data[0], "/bin/rm"); strcpy(argv_data[1], "-rf"); strncpy(argv_data[2], path.c_str(), 10000); char *argv[4]; argv[0] = argv_data[0]; argv[1] = argv_data[1]; argv[2] = argv_data[2]; argv[3] = NULL; verbosestream<<"Executing '"<<argv[0]<<"' '"<<argv[1]<<"' '" <<argv[2]<<"'"<<std::endl; execv(argv[0], argv); // Execv shouldn't return. Failed. _exit(1); } else { // Parent int child_status; pid_t tpid; do{ tpid = wait(&child_status); //if(tpid != child_pid) process_terminated(tpid); }while(tpid != child_pid); return (child_status == 0); } } bool DeleteSingleFileOrEmptyDirectory(const std::string &path) { if(IsDir(path)){ bool did = (rmdir(path.c_str()) == 0); if(!did) errorstream<<"rmdir errno: "<<errno<<": "<<strerror(errno) <<std::endl; return did; } else { bool did = (unlink(path.c_str()) == 0); if(!did) errorstream<<"unlink errno: "<<errno<<": "<<strerror(errno) <<std::endl; return did; } } std::string TempPath() { /* Should the environment variables TMPDIR, TMP and TEMP and the macro P_tmpdir (if defined by stdio.h) be checked before falling back on /tmp? Probably not, because this function is intended to be compatible with lua's os.tmpname which under the default configuration hardcodes mkstemp("/tmp/lua_XXXXXX"). */ #ifdef __ANDROID__ return DIR_DELIM "sdcard" DIR_DELIM PROJECT_NAME DIR_DELIM "tmp"; #else return DIR_DELIM "tmp"; #endif } #endif void GetRecursiveSubPaths(const std::string &path, std::vector<std::string> &dst) { std::vector<DirListNode> content = GetDirListing(path); for(unsigned int i=0; i<content.size(); i++){ const DirListNode &n = content[i]; std::string fullpath = path + DIR_DELIM + n.name; dst.push_back(fullpath); if (n.dir) { GetRecursiveSubPaths(fullpath, dst); } } } bool DeletePaths(const std::vector<std::string> &paths) { bool success = true; // Go backwards to succesfully delete the output of GetRecursiveSubPaths for(int i=paths.size()-1; i>=0; i--){ const std::string &path = paths[i]; bool did = DeleteSingleFileOrEmptyDirectory(path); if(!did){ errorstream<<"Failed to delete "<<path<<std::endl; success = false; } } return success; } bool RecursiveDeleteContent(const std::string &path) { infostream<<"Removing content of \""<<path<<"\""<<std::endl; std::vector<DirListNode> list = GetDirListing(path); for(unsigned int i=0; i<list.size(); i++) { if(trim(list[i].name) == "." || trim(list[i].name) == "..") continue; std::string childpath = path + DIR_DELIM + list[i].name; bool r = RecursiveDelete(childpath); if(r == false) { errorstream<<"Removing \""<<childpath<<"\" failed"<<std::endl; return false; } } return true; } bool CreateAllDirs(const std::string &path) { std::vector<std::string> tocreate; std::string basepath = path; while(!PathExists(basepath)) { tocreate.push_back(basepath); basepath = RemoveLastPathComponent(basepath); if(basepath.empty()) break; } for(int i=tocreate.size()-1;i>=0;i--) if(!CreateDir(tocreate[i])) return false; return true; } bool CopyFileContents(const std::string &source, const std::string &target) { FILE *sourcefile = fopen(source.c_str(), "rb"); if(sourcefile == NULL){ errorstream<<source<<": can't open for reading: " <<strerror(errno)<<std::endl; return false; } FILE *targetfile = fopen(target.c_str(), "wb"); if(targetfile == NULL){ errorstream<<target<<": can't open for writing: " <<strerror(errno)<<std::endl; fclose(sourcefile); return false; } size_t total = 0; bool retval = true; bool done = false; char readbuffer[BUFSIZ]; while(!done){ size_t readbytes = fread(readbuffer, 1, sizeof(readbuffer), sourcefile); total += readbytes; if(ferror(sourcefile)){ errorstream<<source<<": IO error: " <<strerror(errno)<<std::endl; retval = false; done = true; } if(readbytes > 0){ fwrite(readbuffer, 1, readbytes, targetfile); } if(feof(sourcefile) || ferror(sourcefile)){ // flush destination file to catch write errors // (e.g. disk full) fflush(targetfile); done = true; } if(ferror(targetfile)){ errorstream<<target<<": IO error: " <<strerror(errno)<<std::endl; retval = false; done = true; } } infostream<<"copied "<<total<<" bytes from " <<source<<" to "<<target<<std::endl; fclose(sourcefile); fclose(targetfile); return retval; } bool CopyDir(const std::string &source, const std::string &target) { if(PathExists(source)){ if(!PathExists(target)){ fs::CreateAllDirs(target); } bool retval = true; std::vector<DirListNode> content = fs::GetDirListing(source); for(unsigned int i=0; i < content.size(); i++){ std::string sourcechild = source + DIR_DELIM + content[i].name; std::string targetchild = target + DIR_DELIM + content[i].name; if(content[i].dir){ if(!fs::CopyDir(sourcechild, targetchild)){ retval = false; } } else { if(!fs::CopyFileContents(sourcechild, targetchild)){ retval = false; } } } return retval; } else { return false; } } bool PathStartsWith(const std::string &path, const std::string &prefix) { size_t pathsize = path.size(); size_t pathpos = 0; size_t prefixsize = prefix.size(); size_t prefixpos = 0; for(;;){ bool delim1 = pathpos == pathsize || IsDirDelimiter(path[pathpos]); bool delim2 = prefixpos == prefixsize || IsDirDelimiter(prefix[prefixpos]); if(delim1 != delim2) return false; if(delim1){ while(pathpos < pathsize && IsDirDelimiter(path[pathpos])) ++pathpos; while(prefixpos < prefixsize && IsDirDelimiter(prefix[prefixpos])) ++prefixpos; if(prefixpos == prefixsize) return true; if(pathpos == pathsize) return false; } else{ size_t len = 0; do{ char pathchar = path[pathpos+len]; char prefixchar = prefix[prefixpos+len]; if(FILESYS_CASE_INSENSITIVE){ pathchar = tolower(pathchar); prefixchar = tolower(prefixchar); } if(pathchar != prefixchar) return false; ++len; } while(pathpos+len < pathsize && !IsDirDelimiter(path[pathpos+len]) && prefixpos+len < prefixsize && !IsDirDelimiter( prefix[prefixpos+len])); pathpos += len; prefixpos += len; } } } std::string RemoveLastPathComponent(const std::string &path, std::string *removed, int count) { if(removed) *removed = ""; size_t remaining = path.size(); for(int i = 0; i < count; ++i){ // strip a dir delimiter while(remaining != 0 && IsDirDelimiter(path[remaining-1])) remaining--; // strip a path component size_t component_end = remaining; while(remaining != 0 && !IsDirDelimiter(path[remaining-1])) remaining--; size_t component_start = remaining; // strip a dir delimiter while(remaining != 0 && IsDirDelimiter(path[remaining-1])) remaining--; if(removed){ std::string component = path.substr(component_start, component_end - component_start); if(i) *removed = component + DIR_DELIM + *removed; else *removed = component; } } return path.substr(0, remaining); } std::string RemoveRelativePathComponents(std::string path) { size_t pos = path.size(); size_t dotdot_count = 0; while(pos != 0){ size_t component_with_delim_end = pos; // skip a dir delimiter while(pos != 0 && IsDirDelimiter(path[pos-1])) pos--; // strip a path component size_t component_end = pos; while(pos != 0 && !IsDirDelimiter(path[pos-1])) pos--; size_t component_start = pos; std::string component = path.substr(component_start, component_end - component_start); bool remove_this_component = false; if(component == "."){ remove_this_component = true; } else if(component == ".."){ remove_this_component = true; dotdot_count += 1; } else if(dotdot_count != 0){ remove_this_component = true; dotdot_count -= 1; } if(remove_this_component){ while(pos != 0 && IsDirDelimiter(path[pos-1])) pos--; path = path.substr(0, pos) + DIR_DELIM + path.substr(component_with_delim_end, std::string::npos); pos++; } } if(dotdot_count > 0) return ""; // remove trailing dir delimiters pos = path.size(); while(pos != 0 && IsDirDelimiter(path[pos-1])) pos--; return path.substr(0, pos); } std::string AbsolutePath(const std::string &path) { #ifdef _WIN32 char *abs_path = _fullpath(NULL, path.c_str(), MAX_PATH); #else char *abs_path = realpath(path.c_str(), NULL); #endif if (!abs_path) return ""; std::string abs_path_str(abs_path); free(abs_path); return abs_path_str; } const char *GetFilenameFromPath(const char *path) { const char *filename = strrchr(path, DIR_DELIM_CHAR); return filename ? filename + 1 : path; } bool safeWriteToFile(const std::string &path, const std::string &content) { std::string tmp_file = path + ".~mt"; // Write to a tmp file std::ofstream os(tmp_file.c_str(), std::ios::binary); if (!os.good()) return false; os << content; os.flush(); os.close(); if (os.fail()) { remove(tmp_file.c_str()); return false; } // Copy file remove(path.c_str()); if(rename(tmp_file.c_str(), path.c_str())) { remove(tmp_file.c_str()); return false; } else { return true; } } } // namespace fs
generated by cgit v1.2.3 (git 2.25.1) at 2024-07-03 22:04:54 +0000