Line data Source code
1 : /* stream.cpp: utilities for character streams
2 : *
3 : * stream.cpp defines character handling to enable character streams to be written
4 : * into and out of files
5 : * also included is utilities for gz archive support
6 : *
7 : */
8 : #include <sstream>
9 :
10 : #include "../libprimis-headers/cube.h"
11 : #include "stream.h"
12 :
13 : #include "../engine/interface/console.h"
14 :
15 : ///////////////////////// character conversion /////////////////////////////////
16 :
17 : #define CUBECTYPE(s, p, d, a, A, u, U) \
18 : 0, U, U, U, U, U, U, U, U, s, s, s, s, s, U, U, \
19 : U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, \
20 : s, p, p, p, p, p, p, p, p, p, p, p, p, p, p, p, \
21 : d, d, d, d, d, d, d, d, d, d, p, p, p, p, p, p, \
22 : p, A, A, A, A, A, A, A, A, A, A, A, A, A, A, A, \
23 : A, A, A, A, A, A, A, A, A, A, A, p, p, p, p, p, \
24 : p, a, a, a, a, a, a, a, a, a, a, a, a, a, a, a, \
25 : a, a, a, a, a, a, a, a, a, a, a, p, p, p, p, U, \
26 : U, u, u, u, u, u, u, u, u, u, u, u, u, u, u, u, \
27 : u, u, u, u, u, u, u, u, u, u, u, u, u, u, u, U, \
28 : u, U, u, U, u, U, u, U, u, U, u, U, u, U, u, U, \
29 : u, U, u, U, u, U, u, U, u, U, u, U, u, U, u, U, \
30 : u, U, u, U, u, U, u, U, U, u, U, u, U, u, U, U, \
31 : U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, U, \
32 : U, U, U, U, u, u, u, u, u, u, u, u, u, u, u, u, \
33 : u, u, u, u, u, u, u, u, u, u, u, u, u, u, U, u
34 :
35 : /* note here:
36 : * these vars are declared extern inline to allow a `const` (implicitly also
37 : * `static`) to be linked to other files as a `const`.
38 : *
39 : * these vars cannot be `constexpr` due to it not being legal to define constexpr
40 : * prototypes in headers
41 : */
42 :
43 : extern const uchar cubectype[256] =
44 : {
45 : CUBECTYPE(CubeType_Space,
46 : CubeType_Print,
47 : CubeType_Print | CubeType_Digit,
48 : CubeType_Print | CubeType_Alpha | CubeType_Lower,
49 : CubeType_Print | CubeType_Alpha | CubeType_Upper,
50 : CubeType_Print | CubeType_Unicode | CubeType_Alpha | CubeType_Lower,
51 : CubeType_Print | CubeType_Unicode | CubeType_Alpha | CubeType_Upper)
52 : };
53 :
54 697 : size_t encodeutf8(uchar *dstbuf, size_t dstlen, const uchar *srcbuf, size_t srclen, size_t *carry)
55 : {
56 697 : uchar *dst = dstbuf,
57 697 : *dstend = &dstbuf[dstlen];
58 697 : const uchar *src = srcbuf,
59 697 : *srcend = &srcbuf[srclen];
60 697 : if(src < srcend && dst < dstend)
61 : {
62 : do
63 : {
64 697 : int uni = cube2uni(*src);
65 697 : if(uni <= 0x7F)
66 : {
67 697 : if(dst >= dstend)
68 : {
69 0 : goto done;
70 : }
71 697 : const uchar *end = std::min(srcend, &src[dstend-dst]);
72 : do
73 : {
74 13139 : if(uni == '\f')
75 : {
76 0 : if(++src >= srcend)
77 : {
78 0 : goto done;
79 : }
80 0 : goto uni1;
81 : }
82 13139 : *dst++ = uni;
83 13139 : if(++src >= end)
84 : {
85 697 : goto done;
86 : }
87 12442 : uni = cube2uni(*src);
88 12442 : } while(uni <= 0x7F);
89 : }
90 0 : if(uni <= 0x7FF)
91 : {
92 0 : if(dst + 2 > dstend)
93 : {
94 0 : goto done;
95 : }
96 0 : *dst++ = 0xC0 | (uni>>6);
97 0 : goto uni2;
98 : }
99 0 : else if(uni <= 0xFFFF)
100 : {
101 0 : if(dst + 3 > dstend)
102 : {
103 0 : goto done;
104 : }
105 0 : *dst++ = 0xE0 | (uni>>12);
106 0 : goto uni3;
107 : }
108 0 : else if(uni <= 0x1FFFFF)
109 : {
110 0 : if(dst + 4 > dstend)
111 : {
112 0 : goto done;
113 : }
114 0 : *dst++ = 0xF0 | (uni>>18);
115 0 : goto uni4;
116 : }
117 0 : else if(uni <= 0x3FFFFFF)
118 : {
119 0 : if(dst + 5 > dstend)
120 : {
121 0 : goto done;
122 : }
123 0 : *dst++ = 0xF8 | (uni>>24);
124 0 : goto uni5;
125 : }
126 : else if(uni <= 0x7FFFFFFF)
127 : {
128 0 : if(dst + 6 > dstend)
129 : {
130 0 : goto done;
131 : }
132 0 : *dst++ = 0xFC | (uni>>30);
133 0 : goto uni6;
134 : }
135 : else
136 : {
137 : goto uni1;
138 : }
139 0 : uni6: *dst++ = 0x80 | ((uni>>24)&0x3F);
140 0 : uni5: *dst++ = 0x80 | ((uni>>18)&0x3F);
141 0 : uni4: *dst++ = 0x80 | ((uni>>12)&0x3F);
142 0 : uni3: *dst++ = 0x80 | ((uni>>6)&0x3F);
143 0 : uni2: *dst++ = 0x80 | (uni&0x3F);
144 0 : uni1:;
145 0 : } while(++src < srcend);
146 : }
147 0 : done:
148 697 : if(carry)
149 : {
150 697 : *carry += src - srcbuf;
151 : }
152 697 : return dst - dstbuf;
153 : }
154 :
155 : ///////////////////////// file system ///////////////////////
156 :
157 : #ifdef WIN32
158 : #include <shlobj.h>
159 : #else
160 : #include <unistd.h>
161 : #include <sys/stat.h>
162 : #include <sys/types.h>
163 : #include <dirent.h>
164 : #endif
165 :
166 : std::string homedir = "";
167 : struct packagedir
168 : {
169 : std::string dir;
170 : std::string filter;
171 : };
172 : static std::vector<packagedir> packagedirs;
173 :
174 12 : char *makerelpath(const char *dir, const char *file, const char *prefix, const char *cmd)
175 : {
176 : static string tmp;
177 12 : if(prefix)
178 : {
179 0 : copystring(tmp, prefix);
180 : }
181 : else
182 : {
183 12 : tmp[0] = '\0';
184 : }
185 12 : if(file[0]=='<')
186 : {
187 0 : const char *end = std::strrchr(file, '>');
188 0 : if(end)
189 : {
190 0 : size_t len = std::strlen(tmp);
191 0 : copystring(&tmp[len], file, std::min(sizeof(tmp)-len, static_cast<size_t>(end+2-file)));
192 0 : file = end+1;
193 : }
194 : }
195 12 : if(cmd)
196 : {
197 0 : concatstring(tmp, cmd);
198 : }
199 12 : if(dir)
200 : {
201 12 : DEF_FORMAT_STRING(pname, "%s/%s", dir, file);
202 12 : concatstring(tmp, pname);
203 : }
204 : else
205 : {
206 0 : concatstring(tmp, file);
207 : }
208 12 : return tmp;
209 : }
210 :
211 :
212 30 : char *path(char *s)
213 : {
214 30 : for(char *curpart = s;;)
215 : {
216 34 : char *endpart = std::strchr(curpart, '&');
217 34 : if(endpart)
218 : {
219 4 : *endpart = '\0';
220 : }
221 34 : if(curpart[0]=='<')
222 : {
223 4 : char *file = std::strrchr(curpart, '>');
224 4 : if(!file)
225 : {
226 0 : return s;
227 : }
228 4 : curpart = file+1;
229 : }
230 114 : for(char *t = curpart; (t = std::strpbrk(t, "/\\")); *t++ = PATHDIV)
231 : {
232 : //(empty body)
233 : }
234 34 : for(char *prevdir = nullptr, *curdir = curpart;;)
235 : {
236 107 : prevdir = curdir[0]==PATHDIV ? curdir+1 : curdir;
237 107 : curdir = std::strchr(prevdir, PATHDIV);
238 107 : if(!curdir)
239 : {
240 34 : break;
241 : }
242 73 : if(prevdir+1==curdir && prevdir[0]=='.')
243 : {
244 4 : std::memmove(prevdir, curdir+1, std::strlen(curdir+1)+1);
245 4 : curdir = prevdir;
246 : }
247 69 : else if(curdir[1]=='.' && curdir[2]=='.' && curdir[3]==PATHDIV)
248 : {
249 8 : if(prevdir+2==curdir && prevdir[0]=='.' && prevdir[1]=='.')
250 : {
251 0 : continue;
252 : }
253 8 : std::memmove(prevdir, curdir+4, std::strlen(curdir+4)+1);
254 8 : if(prevdir-2 >= curpart && prevdir[-1]==PATHDIV)
255 : {
256 1 : prevdir -= 2;
257 2 : while(prevdir-1 >= curpart && prevdir[-1] != PATHDIV)
258 : {
259 1 : --prevdir;
260 : }
261 : }
262 8 : curdir = prevdir;
263 : }
264 : }
265 34 : if(endpart)
266 : {
267 4 : *endpart = '&';
268 4 : curpart = endpart+1;
269 : }
270 : else
271 : {
272 30 : break;
273 : }
274 4 : }
275 30 : return s;
276 : }
277 :
278 58 : std::string path(std::string s)
279 : {
280 58 : std::string truncated_path, processed_path;
281 :
282 58 : size_t path_begin = 0,
283 58 : path_end = s.length();
284 :
285 : // Find the in-line command segment and skip it
286 58 : if(s.find('<') != std::string::npos)
287 : {
288 4 : size_t command_end = s.rfind('>');
289 4 : if(command_end != std::string::npos)
290 : {
291 4 : path_begin = command_end + 1;
292 : }
293 : }
294 :
295 : // Find the conjugated path and cut it
296 58 : if(s.find('&') != std::string::npos)
297 : {
298 4 : path_end = s.find('&');
299 : }
300 :
301 58 : truncated_path = s.substr(path_begin, path_end - path_begin);
302 :
303 : // Handle "."" and ".."" in the path
304 58 : std::istringstream path_stream(truncated_path);
305 58 : std::stack<std::string> path_stack;
306 58 : std::string token;
307 :
308 : // Construct a stack of path tokens
309 268 : while(std::getline(path_stream, token, '/'))
310 : {
311 210 : if(token == "..")
312 : {
313 8 : if(!path_stack.empty())
314 : {
315 6 : path_stack.pop();
316 : }
317 : else
318 : {
319 2 : path_stack.push(token);
320 : }
321 : }
322 202 : else if(!token.empty() && token != ".")
323 : {
324 195 : path_stack.push(token);
325 : }
326 : }
327 :
328 : // Re-construct the processed path from the stack
329 249 : while(!path_stack.empty())
330 : {
331 191 : if(path_stack.size() > 1)
332 : {
333 140 : processed_path = "/" + path_stack.top() + processed_path;
334 : }
335 : else
336 : {
337 51 : processed_path = path_stack.top() + processed_path;
338 : }
339 191 : path_stack.pop();
340 : }
341 :
342 116 : return processed_path;
343 58 : }
344 :
345 2 : char *copypath(const char *s)
346 : {
347 : static string tmp;
348 2 : copystring(tmp, s);
349 2 : path(tmp);
350 2 : return tmp;
351 : }
352 :
353 7 : const char *parentdir(const char *directory)
354 : {
355 7 : const char *p = directory + std::strlen(directory);
356 48 : while(p > directory && *p != '/' && *p != '\\')
357 : {
358 41 : p--;
359 : }
360 : static string parent;
361 7 : size_t len = p-directory+1;
362 7 : copystring(parent, directory, len);
363 7 : return parent;
364 : }
365 :
366 2 : bool fileexists(const char *path, const char *mode)
367 : {
368 2 : bool exists = true;
369 2 : if(mode[0]=='w' || mode[0]=='a')
370 : {
371 1 : path = parentdir(path);
372 : }
373 : #ifdef WIN32
374 : if(GetFileAttributes(path[0] ? path : ".\\") == INVALID_FILE_ATTRIBUTES)
375 : {
376 : exists = false;
377 : }
378 : #else
379 2 : if(access(path[0] ? path : ".", mode[0]=='w' || mode[0]=='a' ? W_OK : (mode[0]=='d' ? X_OK : R_OK)) == -1)
380 : {
381 1 : exists = false;
382 : }
383 : #endif
384 2 : return exists;
385 : }
386 :
387 1 : bool createdir(const char *path)
388 : {
389 1 : size_t len = std::strlen(path);
390 1 : if(path[len-1] == PATHDIV)
391 : {
392 : static string strip;
393 1 : path = copystring(strip, path, len);
394 : }
395 : #ifdef WIN32
396 : return CreateDirectory(path, nullptr) != 0;
397 : #else
398 1 : return mkdir(path, 0777) == 0;
399 : #endif
400 : }
401 :
402 3 : size_t fixpackagedir(char *dir)
403 : {
404 3 : path(dir);
405 3 : size_t len = std::strlen(dir);
406 3 : if(len > 0 && dir[len-1] != PATHDIV)
407 : {
408 1 : dir[len] = PATHDIV;
409 1 : dir[len+1] = '\0';
410 : }
411 3 : return len;
412 : }
413 :
414 0 : bool subhomedir(char *dst, int len, const char *src)
415 : {
416 0 : const char *sub = std::strstr(src, "$HOME");
417 0 : if(!sub)
418 : {
419 0 : sub = std::strchr(src, '~');
420 : }
421 0 : if(sub && sub-src < len)
422 : {
423 : #ifdef WIN32
424 : char home[MAX_PATH+1];
425 : home[0] = '\0';
426 : if(SHGetFolderPath(nullptr, CSIDL_PERSONAL, nullptr, 0, home) != S_OK || !home[0])
427 : {
428 : return false;
429 : }
430 : #else
431 0 : const char *home = getenv("HOME");
432 0 : if(!home || !home[0])
433 : {
434 0 : return false;
435 : }
436 : #endif
437 0 : dst[sub-src] = '\0';
438 0 : concatstring(dst, home, len);
439 0 : concatstring(dst, sub+(*sub == '~' ? 1 : std::strlen("$HOME")), len);
440 : }
441 0 : return true;
442 : }
443 :
444 0 : const char *sethomedir(const char *dir)
445 : {
446 : string pdir;
447 0 : copystring(pdir, dir);
448 0 : if(!subhomedir(pdir, sizeof(pdir), dir) || !fixpackagedir(pdir))
449 : {
450 0 : return nullptr;
451 : }
452 0 : homedir = pdir;
453 0 : return homedir.c_str();
454 : }
455 :
456 0 : const char *addpackagedir(const char *dir)
457 : {
458 : string pdir;
459 0 : copystring(pdir, dir);
460 0 : if(!subhomedir(pdir, sizeof(pdir), dir) || !fixpackagedir(pdir))
461 : {
462 0 : return nullptr;
463 : }
464 0 : char *filter = pdir;
465 : for(;;)
466 : {
467 : static int len = std::strlen("media");
468 0 : filter = std::strstr(filter, "media");
469 0 : if(!filter)
470 : {
471 0 : break;
472 : }
473 0 : if(filter > pdir && filter[-1] == PATHDIV && filter[len] == PATHDIV)
474 : {
475 0 : break;
476 : }
477 0 : filter += len;
478 0 : }
479 0 : packagedir pf;
480 0 : pf.dir = filter ? std::string(pdir, filter-pdir) : std::string(pdir);
481 0 : pf.filter = filter ? std::string(filter) : "";
482 0 : packagedirs.push_back(pf);
483 0 : return pf.dir.c_str();
484 0 : }
485 :
486 23 : const char *findfile(const char *filename, const char *mode)
487 : {
488 : static string s;
489 23 : if(homedir[0])
490 : {
491 0 : formatstring(s, "%s%s", homedir.c_str(), filename);
492 0 : if(fileexists(s, mode))
493 : {
494 0 : return s;
495 : }
496 0 : if(mode[0] == 'w' || mode[0] == 'a')
497 : {
498 : string dirs;
499 0 : copystring(dirs, s);
500 0 : char *dir = std::strchr(dirs[0] == PATHDIV ? dirs+1 : dirs, PATHDIV);
501 0 : while(dir)
502 : {
503 0 : *dir = '\0';
504 0 : if(!fileexists(dirs, "d") && !createdir(dirs))
505 : {
506 0 : return s;
507 : }
508 0 : *dir = PATHDIV;
509 0 : dir = std::strchr(dir+1, PATHDIV);
510 : }
511 0 : return s;
512 : }
513 : }
514 23 : if(mode[0] == 'w' || mode[0] == 'a')
515 : {
516 1 : return filename;
517 : }
518 22 : for(const packagedir &pf : packagedirs)
519 : {
520 0 : if(pf.filter.size() > 0 && std::strncmp(filename, pf.filter.c_str(), pf.filter.size()))
521 : {
522 0 : continue;
523 : }
524 0 : formatstring(s, "%s%s", pf.dir.c_str(), filename);
525 0 : if(fileexists(s, mode))
526 : {
527 0 : return s;
528 : }
529 : }
530 22 : if(mode[0]=='e')
531 : {
532 0 : return nullptr;
533 : }
534 22 : return filename;
535 : }
536 :
537 1 : bool listdir(const char *dirname, bool rel, const char *ext, std::vector<char *> &files)
538 : {
539 1 : size_t extsize = ext ? std::strlen(ext)+1 : 0;
540 : #ifdef WIN32
541 : DEF_FORMAT_STRING(pathname, rel ? ".\\%s\\*.%s" : "%s\\*.%s", dirname, ext ? ext : "*");
542 : WIN32_FIND_DATA FindFileData;
543 : HANDLE Find = FindFirstFile(pathname, &FindFileData);
544 : if(Find != INVALID_HANDLE_VALUE)
545 : {
546 : do {
547 : if(!ext)
548 : {
549 : files.push_back(newstring(FindFileData.cFileName));
550 : }
551 : else
552 : {
553 : size_t namelen = std::strlen(FindFileData.cFileName);
554 : if(namelen > extsize)
555 : {
556 : namelen -= extsize;
557 : if(FindFileData.cFileName[namelen] == '.' && std::strncmp(FindFileData.cFileName+namelen+1, ext, extsize-1)==0)
558 : {
559 : files.push_back(newstring(FindFileData.cFileName, namelen));
560 : }
561 : }
562 : }
563 : } while(FindNextFile(Find, &FindFileData));
564 : FindClose(Find);
565 : return true;
566 : }
567 : #else
568 1 : DEF_FORMAT_STRING(pathname, rel ? "./%s" : "%s", dirname);
569 1 : DIR *d = opendir(pathname);
570 1 : if(d)
571 : {
572 : struct dirent *de;
573 74 : while((de = readdir(d)) != nullptr)
574 : {
575 73 : if(!ext)
576 : {
577 73 : files.push_back(newstring(de->d_name));
578 : }
579 : else
580 : {
581 0 : size_t namelen = std::strlen(de->d_name);
582 0 : if(namelen > extsize)
583 : {
584 0 : namelen -= extsize;
585 0 : if(de->d_name[namelen] == '.' && std::strncmp(de->d_name+namelen+1, ext, extsize-1)==0)
586 : {
587 0 : files.push_back(newstring(de->d_name, namelen));
588 : }
589 : }
590 : }
591 : }
592 1 : closedir(d);
593 1 : return true;
594 : }
595 : #endif
596 : else
597 : {
598 0 : return false;
599 : }
600 : }
601 :
602 1 : int listfiles(const char *dir, const char *ext, std::vector<char *> &files)
603 : {
604 : string dirname;
605 1 : copystring(dirname, dir);
606 1 : path(dirname);
607 1 : size_t dirlen = std::strlen(dirname);
608 1 : while(dirlen > 1 && dirname[dirlen-1] == PATHDIV)
609 : {
610 0 : dirname[--dirlen] = '\0';
611 : }
612 1 : int dirs = 0;
613 1 : if(listdir(dirname, true, ext, files))
614 : {
615 1 : dirs++;
616 : }
617 : string s;
618 1 : if(homedir[0])
619 : {
620 0 : formatstring(s, "%s%s", homedir.c_str(), dirname);
621 0 : if(listdir(s, false, ext, files))
622 : {
623 0 : dirs++;
624 : }
625 : }
626 1 : for(const packagedir &pf : packagedirs)
627 : {
628 0 : if(pf.filter.size() && std::strncmp(dirname, pf.filter.c_str(), dirlen == pf.filter.size()-1 ? dirlen : pf.filter.size()))
629 : {
630 0 : continue;
631 : }
632 0 : formatstring(s, "%s%s", pf.dir.c_str(), dirname);
633 0 : if(listdir(s, false, ext, files))
634 : {
635 0 : dirs++;
636 : }
637 : }
638 1 : dirs += listzipfiles(dirname, ext, files);
639 1 : return dirs;
640 : }
641 :
642 0 : static Sint64 rwopsseek(SDL_RWops *rw, Sint64 pos, int whence)
643 : {
644 0 : stream *f = static_cast<stream *>(rw->hidden.unknown.data1);
645 0 : if((!pos && whence==SEEK_CUR) || f->seek(pos, whence))
646 : {
647 0 : return static_cast<int>(f->tell());
648 : }
649 0 : return -1;
650 : }
651 :
652 0 : static size_t rwopsread(SDL_RWops *rw, void *buf, size_t size, size_t nmemb)
653 : {
654 0 : stream *f = static_cast<stream *>(rw->hidden.unknown.data1);
655 0 : return f->read(buf, size*nmemb)/size;
656 : }
657 :
658 0 : static size_t rwopswrite(SDL_RWops *rw, const void *buf, size_t size, size_t nmemb)
659 : {
660 0 : stream *f = static_cast<stream *>(rw->hidden.unknown.data1);
661 0 : return f->write(buf, size*nmemb)/size;
662 : }
663 :
664 1 : SDL_RWops *stream::rwops()
665 : {
666 1 : SDL_RWops *rw = SDL_AllocRW();
667 1 : if(!rw)
668 : {
669 0 : return nullptr;
670 : }
671 1 : rw->hidden.unknown.data1 = this;
672 1 : rw->seek = rwopsseek;
673 1 : rw->read = rwopsread;
674 1 : rw->write = rwopswrite;
675 1 : rw->close = 0;
676 1 : return rw;
677 : }
678 :
679 2 : stream::offset stream::size()
680 : {
681 2 : offset pos = tell(),
682 : endpos;
683 2 : if(pos < 0 || !seek(0, SEEK_END))
684 : {
685 2 : return -1;
686 : }
687 0 : endpos = tell();
688 0 : return pos == endpos || seek(pos, SEEK_SET) ? endpos : -1;
689 : }
690 :
691 1 : bool stream::getline(char *str, size_t len)
692 : {
693 1 : for(int i = 0; i < static_cast<int>(len-1); ++i)
694 : {
695 0 : if(read(&str[i], 1) != 1)
696 : {
697 0 : str[i] = '\0';
698 0 : return i > 0;
699 : }
700 0 : else if(str[i] == '\n')
701 : {
702 0 : str[i+1] = '\0';
703 0 : return true;
704 : }
705 : }
706 1 : if(len > 0)
707 : {
708 0 : str[len-1] = '\0';
709 : }
710 1 : return true;
711 : }
712 :
713 1 : size_t stream::printf(const char *fmt, ...)
714 : {
715 : char buf[512];
716 1 : char *str = buf;
717 : va_list args;
718 : #if defined(WIN32) && !defined(__GNUC__)
719 : va_start(args, fmt);
720 : int len = _vscprintf(fmt, args);
721 : if(len <= 0)
722 : {
723 : va_end(args);
724 : return 0;
725 : }
726 : if(len >= static_cast<int>(sizeof(buf)))
727 : {
728 : str = new char[len+1];
729 : }
730 : _vsnprintf(str, len+1, fmt, args);
731 : va_end(args);
732 : #else
733 1 : va_start(args, fmt);
734 1 : int len = vsnprintf(buf, sizeof(buf), fmt, args);
735 1 : va_end(args);
736 1 : if(len <= 0)
737 : {
738 0 : return 0;
739 : }
740 1 : if(len >= static_cast<int>(sizeof(buf)))
741 : {
742 0 : str = new char[len+1];
743 0 : va_start(args, fmt);
744 0 : vsnprintf(str, len+1, fmt, args);
745 0 : va_end(args);
746 : }
747 : #endif
748 1 : size_t n = write(str, len);
749 1 : if(str != buf)
750 : {
751 0 : delete[] str;
752 : }
753 1 : return n;
754 : }
755 :
756 : struct filestream final : stream
757 : {
758 : FILE *file;
759 :
760 11 : filestream() : file(nullptr) {}
761 22 : ~filestream() { close(); }
762 :
763 11 : bool open(const char *name, const char *mode)
764 : {
765 11 : if(file)
766 : {
767 0 : return false;
768 : }
769 11 : file = fopen(name, mode);
770 11 : return file!=nullptr;
771 : }
772 : #ifdef WIN32
773 : bool opentemp(const char *name, const char *mode)
774 : {
775 : if(file)
776 : {
777 : return false;
778 : }
779 : file = fopen(name, mode);
780 : return file!=nullptr;
781 : }
782 : #else
783 : bool opentemp(const char *, const char *)
784 : {
785 : if(file)
786 : {
787 : return false;
788 : }
789 : file = tmpfile();
790 : return file!=nullptr;
791 : }
792 : #endif
793 11 : void close() override final
794 : {
795 11 : if(file)
796 : {
797 2 : fclose(file);
798 2 : file = nullptr;
799 : }
800 11 : }
801 :
802 0 : bool end() override final
803 : {
804 0 : return feof(file)!=0;
805 : }
806 :
807 0 : offset tell() const override final
808 : {
809 : #ifdef WIN32
810 : #if defined(__GNUC__) && !defined(__MINGW32__)
811 : offset off = ftello64(file);
812 : #else
813 : offset off = _ftelli64(file);
814 : #endif
815 : #else
816 0 : offset off = ftello(file);
817 : #endif
818 : // ftello returns LONG_MAX for directories on some platforms
819 0 : return off + 1 >= 0 ? off : -1;
820 : }
821 :
822 0 : bool seek(offset pos, int whence) override final
823 : {
824 : #ifdef WIN32
825 : #if defined(__GNUC__) && !defined(__MINGW32__)
826 : return fseeko64(file, pos, whence) >= 0;
827 : #else
828 : return _fseeki64(file, pos, whence) >= 0;
829 : #endif
830 : #else
831 0 : return fseeko(file, pos, whence) >= 0;
832 : #endif
833 : }
834 :
835 0 : size_t read(void *buf, size_t len) override final
836 : {
837 0 : return fread(buf, 1, len, file);
838 : }
839 :
840 0 : size_t write(const void *buf, size_t len) override final
841 : {
842 0 : return fwrite(buf, 1, len, file);
843 : }
844 :
845 0 : bool flush() override final
846 : {
847 0 : return !fflush(file);
848 : }
849 :
850 0 : int getchar() override final
851 : {
852 0 : return fgetc(file);
853 : }
854 :
855 0 : bool putchar(int c) override final
856 : {
857 0 : return fputc(c, file)!=EOF;
858 : }
859 :
860 1454 : bool getline(char *str, size_t len) override final
861 : {
862 1454 : return fgets(str, len, file)!=nullptr;
863 : }
864 :
865 0 : bool putstring(const char *str) override final
866 : {
867 0 : return fputs(str, file)!=EOF;
868 : }
869 :
870 0 : size_t printf(const char *fmt, ...) override final
871 : {
872 : va_list v;
873 0 : va_start(v, fmt);
874 0 : int result = std::vfprintf(file, fmt, v);
875 0 : va_end(v);
876 0 : return std::max(result, 0);
877 : }
878 : };
879 :
880 : VAR(debuggz, 0, 0, 1); //toggles gz checking routines
881 :
882 : class gzstream final : public stream
883 : {
884 : public:
885 0 : gzstream() : file(nullptr), buf(nullptr), reading(false), writing(false), autoclose(false), crc(0), headersize(0)
886 : {
887 0 : zfile.zalloc = nullptr;
888 0 : zfile.zfree = nullptr;
889 0 : zfile.opaque = nullptr;
890 0 : zfile.next_in = zfile.next_out = nullptr;
891 0 : zfile.avail_in = zfile.avail_out = 0;
892 0 : }
893 :
894 0 : ~gzstream()
895 0 : {
896 0 : close();
897 0 : }
898 :
899 0 : void writeheader()
900 : {
901 0 : uchar header[] = { MAGIC1, MAGIC2, Z_DEFLATED, 0, 0, 0, 0, 0, 0, OS_UNIX };
902 0 : file->write(header, sizeof(header));
903 0 : }
904 :
905 0 : void readbuf(size_t size = BUFSIZE)
906 : {
907 0 : if(!zfile.avail_in)
908 : {
909 0 : zfile.next_in = static_cast<Bytef *>(buf);
910 : }
911 0 : size = std::min(size, static_cast<size_t>(&buf[BUFSIZE] - &zfile.next_in[zfile.avail_in]));
912 0 : size_t n = file->read(zfile.next_in + zfile.avail_in, size);
913 0 : if(n > 0)
914 : {
915 0 : zfile.avail_in += n;
916 : }
917 0 : }
918 :
919 0 : uchar readbyte(size_t size = BUFSIZE)
920 : {
921 0 : if(!zfile.avail_in)
922 : {
923 0 : readbuf(size);
924 : }
925 0 : if(!zfile.avail_in)
926 : {
927 0 : return 0;
928 : }
929 0 : zfile.avail_in--;
930 0 : return *static_cast<uchar *>(zfile.next_in++);
931 : }
932 :
933 0 : void skipbytes(size_t n)
934 : {
935 0 : while(n > 0 && zfile.avail_in > 0)
936 : {
937 0 : size_t skipped = std::min(n, static_cast<size_t>(zfile.avail_in));
938 0 : zfile.avail_in -= skipped;
939 0 : zfile.next_in += skipped;
940 0 : n -= skipped;
941 : }
942 0 : if(n <= 0)
943 : {
944 0 : return;
945 : }
946 0 : file->seek(n, SEEK_CUR);
947 : }
948 :
949 0 : bool checkheader()
950 : {
951 0 : readbuf(10);
952 0 : if(readbyte() != MAGIC1 || readbyte() != MAGIC2 || readbyte() != Z_DEFLATED)
953 : {
954 0 : return false;
955 : }
956 0 : uchar flags = readbyte();
957 0 : if(flags & F_RESERVED)
958 : {
959 0 : return false;
960 : }
961 0 : skipbytes(6);
962 0 : if(flags & F_EXTRA)
963 : {
964 0 : size_t len = readbyte(512);
965 0 : len |= static_cast<size_t>(readbyte(512))<<8;
966 0 : skipbytes(len);
967 : }
968 0 : if(flags & F_NAME)
969 : {
970 0 : while(readbyte(512))
971 : {
972 : //(empty body)
973 : }
974 : }
975 0 : if(flags & F_COMMENT)
976 : {
977 0 : while(readbyte(512))
978 : {
979 : //(empty body)
980 : }
981 : }
982 0 : if(flags & F_CRC)
983 : {
984 0 : skipbytes(2);
985 : }
986 0 : headersize = static_cast<size_t>(file->tell() - zfile.avail_in);
987 0 : return zfile.avail_in > 0 || !file->end();
988 : }
989 :
990 0 : bool open(stream *f, const char *mode, bool needclose, int level)
991 : {
992 0 : if(file)
993 : {
994 0 : return false;
995 : }
996 0 : for(; *mode; mode++)
997 : {
998 0 : if(*mode=='r')
999 : {
1000 0 : reading = true;
1001 0 : break;
1002 : }
1003 0 : else if(*mode=='w')
1004 : {
1005 0 : writing = true;
1006 0 : break;
1007 : }
1008 : }
1009 0 : if(reading)
1010 : {
1011 0 : if(inflateInit2(&zfile, -MAX_WBITS) != Z_OK)
1012 : {
1013 0 : reading = false;
1014 : }
1015 : }
1016 0 : else if(writing && deflateInit2(&zfile, level, Z_DEFLATED, -MAX_WBITS, std::min(MAX_MEM_LEVEL, 8), Z_DEFAULT_STRATEGY) != Z_OK)
1017 : {
1018 0 : writing = false;
1019 : }
1020 0 : if(!reading && !writing)
1021 : {
1022 0 : return false;
1023 : }
1024 0 : file = f;
1025 0 : crc = crc32(0, nullptr, 0);
1026 0 : buf = new uchar[BUFSIZE];
1027 0 : if(reading)
1028 : {
1029 0 : if(!checkheader())
1030 : {
1031 0 : stopreading();
1032 0 : return false;
1033 : }
1034 : }
1035 0 : else if(writing)
1036 : {
1037 0 : writeheader();
1038 : }
1039 0 : autoclose = needclose;
1040 0 : return true;
1041 : }
1042 :
1043 0 : uint getcrc() override final
1044 : {
1045 0 : return crc;
1046 : }
1047 :
1048 0 : void finishreading()
1049 : {
1050 0 : if(!reading)
1051 : {
1052 0 : return;
1053 : }
1054 0 : if(debuggz)
1055 : {
1056 0 : uint checkcrc = 0,
1057 0 : checksize = 0;
1058 0 : for(int i = 0; i < 4; ++i)
1059 : {
1060 0 : checkcrc |= static_cast<uint>(readbyte()) << (i*8);
1061 : }
1062 0 : for(int i = 0; i < 4; ++i)
1063 : {
1064 0 : checksize |= static_cast<uint>(readbyte()) << (i*8);
1065 : }
1066 0 : if(checkcrc != crc)
1067 : {
1068 0 : conoutf(Console_Debug, "gzip crc check failed: read %X, calculated %X", checkcrc, crc);
1069 : }
1070 0 : if(checksize != zfile.total_out)
1071 : {
1072 0 : conoutf(Console_Debug, "gzip size check failed: read %u, calculated %u", checksize, static_cast<uint>(zfile.total_out));
1073 : }
1074 : }
1075 : }
1076 :
1077 0 : void stopreading()
1078 : {
1079 0 : if(!reading)
1080 : {
1081 0 : return;
1082 : }
1083 0 : inflateEnd(&zfile);
1084 0 : reading = false;
1085 : }
1086 :
1087 0 : void finishwriting()
1088 : {
1089 0 : if(!writing)
1090 : {
1091 0 : return;
1092 : }
1093 : for(;;)
1094 : {
1095 0 : int err = zfile.avail_out > 0 ? deflate(&zfile, Z_FINISH) : Z_OK;
1096 0 : if(err != Z_OK && err != Z_STREAM_END)
1097 : {
1098 0 : break;
1099 : }
1100 0 : flushbuf();
1101 0 : if(err == Z_STREAM_END)
1102 : {
1103 0 : break;
1104 : }
1105 0 : }
1106 : uchar trailer[8] =
1107 : {
1108 0 : static_cast<uchar>(crc&0xFF), static_cast<uchar>((crc>>8)&0xFF), static_cast<uchar>((crc>>16)&0xFF), static_cast<uchar>((crc>>24)&0xFF),
1109 0 : static_cast<uchar>(zfile.total_in&0xFF), static_cast<uchar>((zfile.total_in>>8)&0xFF), static_cast<uchar>((zfile.total_in>>16)&0xFF), static_cast<uchar>((zfile.total_in>>24)&0xFF)
1110 0 : };
1111 0 : file->write(trailer, sizeof(trailer));
1112 : }
1113 :
1114 0 : void stopwriting()
1115 : {
1116 0 : if(!writing)
1117 : {
1118 0 : return;
1119 : }
1120 0 : deflateEnd(&zfile);
1121 0 : writing = false;
1122 : }
1123 :
1124 0 : void close() override final
1125 : {
1126 0 : if(reading)
1127 : {
1128 0 : finishreading();
1129 : }
1130 0 : stopreading();
1131 0 : if(writing)
1132 : {
1133 0 : finishwriting();
1134 : }
1135 0 : stopwriting();
1136 0 : delete[] buf;
1137 0 : buf = nullptr;
1138 0 : if(autoclose)
1139 : {
1140 0 : if(file)
1141 : {
1142 0 : delete file;
1143 0 : file = nullptr;
1144 : }
1145 : }
1146 0 : }
1147 :
1148 0 : bool end() override final
1149 : {
1150 0 : return !reading && !writing;
1151 : }
1152 :
1153 0 : offset tell() const override final
1154 : {
1155 0 : return reading ? zfile.total_out : (writing ? zfile.total_in : offset(-1));
1156 : }
1157 :
1158 0 : offset rawtell() const override final
1159 : {
1160 0 : return file ? file->tell() : offset(-1);
1161 : }
1162 :
1163 0 : offset size() override final
1164 : {
1165 0 : if(!file)
1166 : {
1167 0 : return -1;
1168 : }
1169 0 : offset pos = tell();
1170 0 : if(!file->seek(-4, SEEK_END))
1171 : {
1172 0 : return -1;
1173 : }
1174 0 : uint isize = file->get<uint>();
1175 0 : return file->seek(pos, SEEK_SET) ? isize : offset(-1);
1176 : }
1177 :
1178 0 : offset rawsize() override final
1179 : {
1180 0 : return file ? file->size() : offset(-1);
1181 : }
1182 :
1183 0 : bool seek(offset pos, int whence) override final
1184 : {
1185 0 : if(writing || !reading)
1186 : {
1187 0 : return false;
1188 : }
1189 :
1190 0 : if(whence == SEEK_END)
1191 : {
1192 : uchar skip[512];
1193 0 : while(read(skip, sizeof(skip)) == sizeof(skip))
1194 : {
1195 : //(empty body)
1196 : }
1197 0 : return !pos;
1198 : }
1199 0 : else if(whence == SEEK_CUR)
1200 : {
1201 0 : pos += zfile.total_out;
1202 : }
1203 0 : if(pos >= static_cast<offset>(zfile.total_out))
1204 : {
1205 0 : pos -= zfile.total_out;
1206 : }
1207 0 : else if(pos < 0 || !file->seek(headersize, SEEK_SET))
1208 : {
1209 0 : return false;
1210 : }
1211 : else
1212 : {
1213 0 : if(zfile.next_in && zfile.total_in <= static_cast<uint>(zfile.next_in - buf))
1214 : {
1215 0 : zfile.avail_in += zfile.total_in;
1216 0 : zfile.next_in -= zfile.total_in;
1217 : }
1218 : else
1219 : {
1220 0 : zfile.avail_in = 0;
1221 0 : zfile.next_in = nullptr;
1222 : }
1223 0 : inflateReset(&zfile);
1224 0 : crc = crc32(0, nullptr, 0);
1225 : }
1226 :
1227 : uchar skip[512];
1228 0 : while(pos > 0)
1229 : {
1230 0 : size_t skipped = static_cast<size_t>(std::min(pos, static_cast<offset>(sizeof(skip))));
1231 0 : if(read(skip, skipped) != skipped)
1232 : {
1233 0 : stopreading();
1234 0 : return false;
1235 : }
1236 0 : pos -= skipped;
1237 : }
1238 :
1239 0 : return true;
1240 : }
1241 :
1242 0 : size_t read(void *buf, size_t len) override final
1243 : {
1244 0 : if(!reading || !buf || !len)
1245 : {
1246 0 : return 0;
1247 : }
1248 0 : zfile.next_out = static_cast<Bytef *>(buf);
1249 0 : zfile.avail_out = len;
1250 0 : while(zfile.avail_out > 0)
1251 : {
1252 0 : if(!zfile.avail_in)
1253 : {
1254 0 : readbuf(BUFSIZE);
1255 0 : if(!zfile.avail_in)
1256 : {
1257 0 : stopreading();
1258 0 : break;
1259 : }
1260 : }
1261 0 : int err = inflate(&zfile, Z_NO_FLUSH);
1262 0 : if(err == Z_STREAM_END)
1263 : {
1264 0 : crc = crc32(crc, static_cast<Bytef *>(buf), len - zfile.avail_out);
1265 0 : finishreading();
1266 0 : stopreading();
1267 0 : return len - zfile.avail_out;
1268 : }
1269 0 : else if(err != Z_OK)
1270 : {
1271 0 : stopreading();
1272 0 : break;
1273 : }
1274 : }
1275 0 : crc = crc32(crc, reinterpret_cast<Bytef *>(buf), len - zfile.avail_out);
1276 0 : return len - zfile.avail_out;
1277 : }
1278 :
1279 0 : bool flushbuf(bool full = false)
1280 : {
1281 0 : if(full)
1282 : {
1283 0 : deflate(&zfile, Z_SYNC_FLUSH);
1284 : }
1285 0 : if(zfile.next_out && zfile.avail_out < BUFSIZE)
1286 : {
1287 0 : if(file->write(buf, BUFSIZE - zfile.avail_out) != BUFSIZE - zfile.avail_out || (full && !file->flush()))
1288 : {
1289 0 : return false;
1290 : }
1291 : }
1292 0 : zfile.next_out = buf;
1293 0 : zfile.avail_out = BUFSIZE;
1294 0 : return true;
1295 : }
1296 :
1297 0 : bool flush() override final
1298 : {
1299 0 : return flushbuf(true);
1300 : }
1301 :
1302 0 : size_t write(const void *buf, size_t len) override final
1303 : {
1304 0 : if(!writing || !buf || !len)
1305 : {
1306 0 : return 0;
1307 : }
1308 0 : zfile.next_in = static_cast<Bytef *>(const_cast<void *>(buf)); //cast away constness, then to Bytef
1309 0 : zfile.avail_in = len;
1310 0 : while(zfile.avail_in > 0)
1311 : {
1312 0 : if(!zfile.avail_out && !flushbuf())
1313 : {
1314 0 : stopwriting();
1315 0 : break;
1316 : }
1317 0 : int err = deflate(&zfile, Z_NO_FLUSH);
1318 0 : if(err != Z_OK)
1319 : {
1320 0 : stopwriting();
1321 0 : break;
1322 : }
1323 : }
1324 0 : crc = crc32(crc, static_cast<Bytef *>(const_cast<void *>(buf)), len - zfile.avail_in);
1325 0 : return len - zfile.avail_in;
1326 : }
1327 : private:
1328 : enum GzHeader
1329 : {
1330 : MAGIC1 = 0x1F,
1331 : MAGIC2 = 0x8B,
1332 : BUFSIZE = 16384,
1333 : OS_UNIX = 0x03
1334 : };
1335 :
1336 : enum GzFlags
1337 : {
1338 : F_ASCII = 0x01,
1339 : F_CRC = 0x02,
1340 : F_EXTRA = 0x04,
1341 : F_NAME = 0x08,
1342 : F_COMMENT = 0x10,
1343 : F_RESERVED = 0xE0
1344 : };
1345 :
1346 : stream *file;
1347 : z_stream zfile;
1348 : uchar *buf;
1349 : bool reading, writing, autoclose;
1350 : uint crc;
1351 : size_t headersize;
1352 : };
1353 :
1354 11 : stream *openrawfile(const char *filename, const char *mode)
1355 : {
1356 11 : const char *found = findfile(filename, mode);
1357 11 : if(!found)
1358 : {
1359 0 : return nullptr;
1360 : }
1361 11 : filestream *file = new filestream;
1362 11 : if(!file->open(found, mode))
1363 : {
1364 9 : delete file;
1365 9 : return nullptr;
1366 : }
1367 2 : return file;
1368 : }
1369 :
1370 11 : stream *openfile(const char *filename, const char *mode)
1371 : {
1372 11 : stream *s = openzipfile(filename, mode);
1373 11 : if(s)
1374 : {
1375 0 : return s;
1376 : }
1377 11 : return openrawfile(filename, mode);
1378 : }
1379 :
1380 0 : stream *opengzfile(const char *filename, const char *mode, stream *file, int level)
1381 : {
1382 0 : stream *source = file ? file : openfile(filename, mode);
1383 0 : if(!source)
1384 : {
1385 0 : return nullptr;
1386 : }
1387 0 : gzstream *gz = new gzstream;
1388 0 : if(!gz->open(source, mode, !file, level))
1389 : {
1390 0 : if(!file)
1391 : {
1392 0 : delete source;
1393 : }
1394 0 : delete gz;
1395 0 : return nullptr;
1396 : }
1397 0 : return gz;
1398 : }
1399 :
1400 7 : char *loadfile(const char *fn, size_t *size, bool utf8)
1401 : {
1402 7 : stream *f = openfile(fn, "rb");
1403 7 : if(!f)
1404 : {
1405 7 : return nullptr;
1406 : }
1407 0 : stream::offset fsize = f->size();
1408 0 : if(fsize <= 0)
1409 : {
1410 0 : delete f;
1411 0 : return nullptr;
1412 : }
1413 0 : size_t len = fsize;
1414 0 : char *buf = new char[len+1];
1415 0 : if(!buf)
1416 : {
1417 0 : delete f;
1418 0 : return nullptr;
1419 : }
1420 0 : size_t offset = 0;
1421 0 : if(utf8 && len >= 3)
1422 : {
1423 0 : if(f->read(buf, 3) != 3)
1424 : {
1425 0 : delete f;
1426 0 : delete[] buf;
1427 0 : return nullptr;
1428 : }
1429 0 : if((reinterpret_cast<uchar*>(buf))[0] == 0xEF &&
1430 0 : (reinterpret_cast<uchar*>(buf))[1] == 0xBB &&
1431 0 : (reinterpret_cast<uchar*>(buf))[2] == 0xBF)
1432 : {
1433 0 : len -= 3;
1434 : }
1435 : else
1436 : {
1437 0 : offset += 3;
1438 : }
1439 : }
1440 0 : size_t rlen = f->read(&buf[offset], len-offset);
1441 0 : delete f;
1442 0 : if(rlen != len-offset)
1443 : {
1444 0 : delete[] buf;
1445 0 : return nullptr;
1446 : }
1447 0 : buf[len] = '\0';
1448 0 : if(size!=nullptr)
1449 : {
1450 0 : *size = len;
1451 : }
1452 0 : return buf;
1453 : }
1454 :
|
