1

/* $Id$ */

     2

     3

/** @file fileio.cpp Standard In/Out file operations */

     4

     5

#include "stdafx.h"

     6

#include "openttd.h"

     7

#include "fileio.h"

     8

#include "variables.h"

     9

#include "debug.h"

    10

#include "fios.h"

    11

#include "core/alloc_func.hpp"

    12

#include "core/math_func.hpp"

    13

#include "string_func.h"

    14

#include "tar_type.h"

    15

#ifdef WIN32

    16

#include <windows.h>

    17

#else

    18

#include <pwd.h>

    19

#include <unistd.h>

    20

#endif

    21

#include <sys/stat.h>

    22

    23

/*************************************************/

    24

/* FILE IO ROUTINES ******************************/

    25

/*************************************************/

    26

    27

#define FIO_BUFFER_SIZE 512

    28

    29

struct Fio {

    30

	byte *buffer, *buffer_end;             ///< position pointer in local buffer and last valid byte of buffer

    31

	size_t pos;                            ///< current (system) position in file

    32

	FILE *cur_fh;                          ///< current file handle

    33

	const char *filename;                  ///< current filename

    34

	FILE *handles[MAX_FILE_SLOTS];         ///< array of file handles we can have open

    35

	byte buffer_start[FIO_BUFFER_SIZE];    ///< local buffer when read from file

    36

	const char *filenames[MAX_FILE_SLOTS]; ///< array of filenames we (should) have open

    37

	char *shortnames[MAX_FILE_SLOTS];///< array of short names for spriteloader's use

    38

#if defined(LIMITED_FDS)

    39

	uint open_handles;                     ///< current amount of open handles

    40

	uint usage_count[MAX_FILE_SLOTS];      ///< count how many times this file has been opened

    41

#endif /* LIMITED_FDS */

    42

};

    43

    44

static Fio _fio;

    45

    46

/* Get current position in file */

    47

size_t FioGetPos()

    48

{

    49

	return _fio.pos + (_fio.buffer - _fio.buffer_end);

    50

}

    51

    52

const char *FioGetFilename(uint8 slot)

    53

{

    54

	return _fio.shortnames[slot];

    55

}

    56

    57

void FioSeekTo(size_t pos, int mode)

    58

{

    59

	if (mode == SEEK_CUR) pos += FioGetPos();

    60

	_fio.buffer = _fio.buffer_end = _fio.buffer_start + FIO_BUFFER_SIZE;

    61

	_fio.pos = pos;

    62

	fseek(_fio.cur_fh, _fio.pos, SEEK_SET);

    63

}

    64

    65

#if defined(LIMITED_FDS)

    66

static void FioRestoreFile(int slot)

    67

{

    68

	/* Do we still have the file open, or should we reopen it? */

    69

	if (_fio.handles[slot] == NULL) {

    70

		DEBUG(misc, 6, "Restoring file '%s' in slot '%d' from disk", _fio.filenames[slot], slot);

    71

		FioOpenFile(slot, _fio.filenames[slot]);

    72

	}

    73

	_fio.usage_count[slot]++;

    74

}

    75

#endif /* LIMITED_FDS */

    76

    77

/* Seek to a file and a position */

    78

void FioSeekToFile(uint8 slot, size_t pos)

    79

{

    80

	FILE *f;

    81

#if defined(LIMITED_FDS)

    82

	/* Make sure we have this file open */

    83

	FioRestoreFile(slot);

    84

#endif /* LIMITED_FDS */

    85

	f = _fio.handles[slot];

    86

	assert(f != NULL);

    87

	_fio.cur_fh = f;

    88

	_fio.filename = _fio.filenames[slot];

    89

	FioSeekTo(pos, SEEK_SET);

    90

}

    91

    92

byte FioReadByte()

    93

{

    94

	if (_fio.buffer == _fio.buffer_end) {

    95

		_fio.buffer = _fio.buffer_start;

    96

		size_t size = fread(_fio.buffer, 1, FIO_BUFFER_SIZE, _fio.cur_fh);

    97

		_fio.pos += size;

    98

		_fio.buffer_end = _fio.buffer_start + size;

    99

   100

		if (size == 0) return 0;

   101

	}

   102

	return *_fio.buffer++;

   103

}

   104

   105

void FioSkipBytes(int n)

   106

{

   107

	for (;;) {

   108

		int m = min(_fio.buffer_end - _fio.buffer, n);

   109

		_fio.buffer += m;

   110

		n -= m;

   111

		if (n == 0) break;

   112

		FioReadByte();

   113

		n--;

   114

	}

   115

}

   116

   117

uint16 FioReadWord()

   118

{

   119

	byte b = FioReadByte();

   120

	return (FioReadByte() << 8) | b;

   121

}

   122

   123

uint32 FioReadDword()

   124

{

   125

	uint b = FioReadWord();

   126

	return (FioReadWord() << 16) | b;

   127

}

   128

   129

void FioReadBlock(void *ptr, size_t size)

   130

{

   131

	FioSeekTo(FioGetPos(), SEEK_SET);

   132

	_fio.pos += fread(ptr, 1, size, _fio.cur_fh);

   133

}

   134

   135

static inline void FioCloseFile(int slot)

   136

{

   137

	if (_fio.handles[slot] != NULL) {

   138

		fclose(_fio.handles[slot]);

   139

   140

		free(_fio.shortnames[slot]);

   141

		_fio.shortnames[slot] = NULL;

   142

   143

		_fio.handles[slot] = NULL;

   144

#if defined(LIMITED_FDS)

   145

		_fio.open_handles--;

   146

#endif /* LIMITED_FDS */

   147

	}

   148

}

   149

   150

void FioCloseAll()

   151

{

   152

	int i;

   153

   154

	for (i = 0; i != lengthof(_fio.handles); i++)

   155

		FioCloseFile(i);

   156

}

   157

   158

#if defined(LIMITED_FDS)

   159

static void FioFreeHandle()

   160

{

   161

	/* If we are about to open a file that will exceed the limit, close a file */

   162

	if (_fio.open_handles + 1 == LIMITED_FDS) {

   163

		uint i, count;

   164

		int slot;

   165

   166

		count = UINT_MAX;

   167

		slot = -1;

   168

		/* Find the file that is used the least */

   169

		for (i = 0; i < lengthof(_fio.handles); i++) {

   170

			if (_fio.handles[i] != NULL && _fio.usage_count[i] < count) {

   171

				count = _fio.usage_count[i];

   172

				slot  = i;

   173

			}

   174

		}

   175

		assert(slot != -1);

   176

		DEBUG(misc, 6, "Closing filehandler '%s' in slot '%d' because of fd-limit", _fio.filenames[slot], slot);

   177

		FioCloseFile(slot);

   178

	}

   179

}

   180

#endif /* LIMITED_FDS */

   181

   182

void FioOpenFile(int slot, const char *filename)

   183

{

   184

	FILE *f;

   185

   186

#if defined(LIMITED_FDS)

   187

	FioFreeHandle();

   188

#endif /* LIMITED_FDS */

   189

	f = FioFOpenFile(filename);

   190

	if (f == NULL) usererror("Cannot open file '%s'", filename);

   191

	uint32 pos = ftell(f);

   192

   193

	FioCloseFile(slot); // if file was opened before, close it

   194

	_fio.handles[slot] = f;

   195

	_fio.filenames[slot] = filename;

   196

   197

	/* Store the filename without path and extension */

   198

	const char *t = strrchr(filename, PATHSEPCHAR);

   199

	_fio.shortnames[slot] = strdup(t == NULL ? filename : t);

   200

	char *t2 = strrchr(_fio.shortnames[slot], '.');

   201

	if (t2 != NULL) *t2 = '\0';

   202

	strtolower(_fio.shortnames[slot]);

   203

   204

#if defined(LIMITED_FDS)

   205

	_fio.usage_count[slot] = 0;

   206

	_fio.open_handles++;

   207

#endif /* LIMITED_FDS */

   208

	FioSeekToFile(slot, pos);

   209

}

   210

   211

const char *_subdirs[NUM_SUBDIRS] = {

   212

	"",

   213

	"save" PATHSEP,

   214

	"save" PATHSEP "autosave" PATHSEP,

   215

	"scenario" PATHSEP,

   216

	"scenario" PATHSEP "heightmap" PATHSEP,

   217

	"gm" PATHSEP,

   218

	"data" PATHSEP,

   219

	"lang" PATHSEP,

   220

    "cache" PATHSEP

   221

};

   222

   223

const char *_searchpaths[NUM_SEARCHPATHS];

   224

TarList _tar_list;

   225

TarFileList _tar_filelist;

   226

   227

typedef std::map<std::string, std::string> TarLinkList;

   228

static TarLinkList _tar_linklist; ///< List of directory links

   229

   230

/**

   231

 * Check whether the given file exists

   232

 * @param filename the file to try for existance

   233

 * @param subdir the subdirectory to look in

   234

 * @return true if and only if the file can be opened

   235

 */

   236

bool FioCheckFileExists(const char *filename, Subdirectory subdir)

   237

{

   238

	FILE *f = FioFOpenFile(filename, "rb", subdir);

   239

	if (f == NULL) return false;

   240

   241

	FioFCloseFile(f);

   242

	return true;

   243

}

   244

   245

/**

   246

 * Close a file in a safe way.

   247

 */

   248

void FioFCloseFile(FILE *f)

   249

{

   250

	fclose(f);

   251

}

   252

   253

char *FioGetFullPath(char *buf, size_t buflen, Searchpath sp, Subdirectory subdir, const char *filename)

   254

{

   255

	assert(subdir < NUM_SUBDIRS);

   256

	assert(sp < NUM_SEARCHPATHS);

   257

   258

	snprintf(buf, buflen, "%s%s%s", _searchpaths[sp], _subdirs[subdir], filename);

   259

	return buf;

   260

}

   261

   262

char *FioFindFullPath(char *buf, size_t buflen, Subdirectory subdir, const char *filename)

   263

{

   264

	Searchpath sp;

   265

	assert(subdir < NUM_SUBDIRS);

   266

   267

	FOR_ALL_SEARCHPATHS(sp) {

   268

		FioGetFullPath(buf, buflen, sp, subdir, filename);

   269

		if (FileExists(buf)) break;

   270

	}

   271

   272

	return buf;

   273

}

   274

   275

char *FioAppendDirectory(char *buf, size_t buflen, Searchpath sp, Subdirectory subdir)

   276

{

   277

	assert(subdir < NUM_SUBDIRS);

   278

	assert(sp < NUM_SEARCHPATHS);

   279

   280

	snprintf(buf, buflen, "%s%s", _searchpaths[sp], _subdirs[subdir]);

   281

	return buf;

   282

}

   283

   284

char *FioGetDirectory(char *buf, size_t buflen, Subdirectory subdir)

   285

{

   286

	Searchpath sp;

   287

   288

	/* Find and return the first valid directory */

   289

	FOR_ALL_SEARCHPATHS(sp) {

   290

		char *ret = FioAppendDirectory(buf, buflen, sp, subdir);

   291

		if (FileExists(buf)) return ret;

   292

	}

   293

   294

	/* Could not find the directory, fall back to a base path */

   295

	ttd_strlcpy(buf, _personal_dir, buflen);

   296

   297

	return buf;

   298

}

   299

   300

FILE *FioFOpenFileSp(const char *filename, const char *mode, Searchpath sp, Subdirectory subdir, size_t *filesize)

   301

{

   302

#if defined(WIN32) && defined(UNICODE)

   303

	/* fopen is implemented as a define with ellipses for

   304

	 * Unicode support (prepend an L). As we are not sending

   305

	 * a string, but a variable, it 'renames' the variable,

   306

	 * so make that variable to makes it compile happily */

   307

	wchar_t Lmode[5];

   308

	MultiByteToWideChar(CP_ACP, 0, mode, -1, Lmode, lengthof(Lmode));

   309

#endif

   310

	FILE *f = NULL;

   311

	char buf[MAX_PATH];

   312

   313

	if (subdir == NO_DIRECTORY) {

   314

		ttd_strlcpy(buf, filename, lengthof(buf));

   315

	} else {

   316

		snprintf(buf, lengthof(buf), "%s%s%s", _searchpaths[sp], _subdirs[subdir], filename);

   317

	}

   318

   319

#if defined(WIN32)

   320

	if (mode[0] == 'r' && GetFileAttributes(OTTD2FS(buf)) == INVALID_FILE_ATTRIBUTES) return NULL;

   321

#endif

   322

   323

	f = fopen(buf, mode);

   324

#if !defined(WIN32)

   325

	if (f == NULL) {

   326

		strtolower(buf + ((subdir == NO_DIRECTORY) ? 0 : strlen(_searchpaths[sp]) - 1));

   327

		f = fopen(buf, mode);

   328

	}

   329

#endif

   330

	if (f != NULL && filesize != NULL) {

   331

		/* Find the size of the file */

   332

		fseek(f, 0, SEEK_END);

   333

		*filesize = ftell(f);

   334

		fseek(f, 0, SEEK_SET);

   335

	}

   336

	return f;

   337

}

   338

   339

FILE *FioFOpenFileTar(TarFileListEntry *entry, size_t *filesize)

   340

{

   341

	FILE *f = fopen(entry->tar->filename, "rb");

   342

	assert(f != NULL);

   343

   344

	fseek(f, entry->position, SEEK_SET);

   345

	if (filesize != NULL) *filesize = entry->size;

   346

	return f;

   347

}

   348

   349

/** Opens OpenTTD files somewhere in a personal or global directory */

   350

FILE *FioFOpenFile(const char *filename, const char *mode, Subdirectory subdir, size_t *filesize)

   351

{

   352

	FILE *f = NULL;

   353

	Searchpath sp;

   354

   355

	assert(subdir < NUM_SUBDIRS || subdir == NO_DIRECTORY);

   356

   357

	FOR_ALL_SEARCHPATHS(sp) {

   358

		f = FioFOpenFileSp(filename, mode, sp, subdir, filesize);

   359

		if (f != NULL || subdir == NO_DIRECTORY) break;

   360

	}

   361

   362

	/* We can only use .tar in case of data-dir, and read-mode */

   363

	if (f == NULL && subdir == DATA_DIR && mode[0] == 'r') {

   364

		static const uint MAX_RESOLVED_LENGTH = 2 * (100 + 100 + 155) + 1; // Enough space to hold two filenames plus link. See 'TarHeader'.

   365

		char resolved_name[MAX_RESOLVED_LENGTH];

   366

   367

		/* Filenames in tars are always forced to be lowercase */

   368

		strcpy(resolved_name, filename);

   369

		strtolower(resolved_name);

   370

   371

		uint resolved_len = strlen(resolved_name);

   372

   373

		/* Resolve ONE directory link */

   374

		for (TarLinkList::iterator link = _tar_linklist.begin(); link != _tar_linklist.end(); link++) {

   375

			const std::string &src = link->first;

   376

			uint len = src.length();

   377

			if (resolved_len >= len && resolved_name[len - 1] == PATHSEPCHAR && strncmp(src.c_str(), resolved_name, len) == 0) {

   378

				/* Apply link */

   379

				char resolved_name2[MAX_RESOLVED_LENGTH];

   380

				const std::string &dest = link->second;

   381

				strcpy(resolved_name2, &(resolved_name[len]));

   382

				strcpy(resolved_name, dest.c_str());

   383

				strcpy(&(resolved_name[dest.length()]), resolved_name2);

   384

				break; // Only resolve one level

   385

			}

   386

		}

   387

   388

		TarFileList::iterator it = _tar_filelist.find(resolved_name);

   389

		if (it != _tar_filelist.end()) {

   390

			f = FioFOpenFileTar(&((*it).second), filesize);

   391

		}

   392

	}

   393

   394

	/* Sometimes a full path is given. To support

   395

	 * the 'subdirectory' must be 'removed'. */

   396

	if (f == NULL && subdir != NO_DIRECTORY) {

   397

		f = FioFOpenFile(filename, mode, NO_DIRECTORY, filesize);

   398

	}

   399

   400

	return f;

   401

}

   402

   403

/**

   404

 * Create a directory with the given name

   405

 * @param name the new name of the directory

   406

 */

   407

void FioCreateDirectory(const char *name)

   408

{

   409

#if defined(WIN32) || defined(WINCE)

   410

	CreateDirectory(OTTD2FS(name), NULL);

   411

#elif defined(OS2) && !defined(__INNOTEK_LIBC__)

   412

	mkdir(OTTD2FS(name));

   413

#elif defined(__MORPHOS__) || defined(__AMIGAOS__)

   414

	char buf[MAX_PATH];

   415

	ttd_strlcpy(buf, name, MAX_PATH);

   416

   417

	size_t len = strlen(name) - 1;

   418

	if (buf[len] == '/') {

   419

		buf[len] = '\0'; // Kill pathsep, so mkdir() will not fail

   420

	}

   421

   422

	mkdir(OTTD2FS(buf), 0755);

   423

#else

   424

	mkdir(OTTD2FS(name), 0755);

   425

#endif

   426

}

   427

   428

/**

   429

 * Appends, if necessary, the path separator character to the end of the string.

   430

 * It does not add the path separator to zero-sized strings.

   431

 * @param buf    string to append the separator to

   432

 * @param buflen the length of the buf

   433

 */

   434

void AppendPathSeparator(char *buf, size_t buflen)

   435

{

   436

	size_t s = strlen(buf);

   437

   438

	/* Length of string + path separator + '\0' */

   439

	if (s != 0 && buf[s - 1] != PATHSEPCHAR && s + 2 < buflen) {

   440

		buf[s]     = PATHSEPCHAR;

   441

		buf[s + 1] = '\0';

   442

	}

   443

}

   444

   445

/**

   446

 * Allocates and files a variable with the full path

   447

 * based on the given directory.

   448

 * @param dir the directory to base the path on

   449

 * @return the malloced full path

   450

 */

   451

char *BuildWithFullPath(const char *dir)

   452

{

   453

	char *dest = MallocT<char>(MAX_PATH);

   454

	ttd_strlcpy(dest, dir, MAX_PATH);

   455

   456

	/* Check if absolute or relative path */

   457

	const char *s = strchr(dest, PATHSEPCHAR);

   458

   459

	/* Add absolute path */

   460

	if (s == NULL || dest != s) {

   461

		if (getcwd(dest, MAX_PATH) == NULL) *dest = '\0';

   462

		AppendPathSeparator(dest, MAX_PATH);

   463

		ttd_strlcat(dest, dir, MAX_PATH);

   464

	}

   465

	AppendPathSeparator(dest, MAX_PATH);

   466

   467

	return dest;

   468

}

   469

   470

/**

   471

 * Simplify filenames from tars.

   472

 * Replace '/' by PATHSEPCHAR, and force 'name' to lowercase.

   473

 * @param name Filename to process.

   474

 */

   475

static void SimplifyFileName(char *name)

   476

{

   477

	/* Force lowercase */

   478

	strtolower(name);

   479

   480

	/* Tar-files always have '/' path-seperator, but we want our PATHSEPCHAR */

   481

#if (PATHSEPCHAR != '/')

   482

	for (char *n = name; *n != '\0'; n++) if (*n == '/') *n = PATHSEPCHAR;

   483

#endif

   484

}

   485

   487

{

   488

	/* The TAR-header, repeated for every file */

   489

	typedef struct TarHeader {

   490

		char name[100];      ///< Name of the file