1

/* $Id$ */

     2

     3

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

     4

     5

#include "stdafx.h"

     6

#include "openttd.h"

     7

#include "fileio_func.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

};

   221

   222

const char *_searchpaths[NUM_SEARCHPATHS];

   223

TarList _tar_list;

   224

TarFileList _tar_filelist;

   225

   226

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

   227

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

   228

   229

/**

   230

 * Check whether the given file exists

   231

 * @param filename the file to try for existance

   232

 * @param subdir the subdirectory to look in

   233

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

   234

 */

   235

bool FioCheckFileExists(const char *filename, Subdirectory subdir)

   236

{

   237

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

   238

	if (f == NULL) return false;

   239

   240

	FioFCloseFile(f);

   241

	return true;

   242

}

   243

   244

/**

   245

 * Close a file in a safe way.

   246

 */

   247

void FioFCloseFile(FILE *f)

   248

{

   249

	fclose(f);

   250

}

   251

   252

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

   253

{

   254

	assert(subdir < NUM_SUBDIRS);

   255

	assert(sp < NUM_SEARCHPATHS);

   256

   257

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

   258

	return buf;

   259

}

   260

   261

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

   262

{

   263

	Searchpath sp;

   264

	assert(subdir < NUM_SUBDIRS);

   265

   266

	FOR_ALL_SEARCHPATHS(sp) {

   267

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

   268

		if (FileExists(buf)) break;

   269

	}

   270

   271

	return buf;

   272

}

   273

   274

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

   275

{

   276

	assert(subdir < NUM_SUBDIRS);

   277

	assert(sp < NUM_SEARCHPATHS);

   278

   279

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

   280

	return buf;

   281

}

   282

   283

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

   284

{

   285

	Searchpath sp;

   286

   287

	/* Find and return the first valid directory */

   288

	FOR_ALL_SEARCHPATHS(sp) {

   289

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

   290

		if (FileExists(buf)) return ret;

   291

	}

   292

   293

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

   294

	ttd_strlcpy(buf, _personal_dir, buflen);

   295

   296

	return buf;

   297

}

   298

   299

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

   300

{

   301

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

   302

	/* fopen is implemented as a define with ellipses for

   303

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

   304

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

   305

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

   306

	wchar_t Lmode[5];

   307

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

   308

#endif

   309

	FILE *f = NULL;

   310

	char buf[MAX_PATH];

   311

   312

	if (subdir == NO_DIRECTORY) {

   313

		strecpy(buf, filename, lastof(buf));

   314

	} else {

   315

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

   316

	}

   317

   318

#if defined(WIN32)

   319

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

   320

#endif

   321

   322

	f = fopen(buf, mode);

   323

#if !defined(WIN32)

   324

	if (f == NULL) {

   325

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

   326

		f = fopen(buf, mode);

   327

	}

   328

#endif

   329

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

   330

		/* Find the size of the file */

   331

		fseek(f, 0, SEEK_END);

   332

		*filesize = ftell(f);

   333

		fseek(f, 0, SEEK_SET);

   334

	}

   335

	return f;

   336

}

   337

   338

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

   339

{

   340

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

   341

	assert(f != NULL);

   342

   343

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

   344

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

   345

	return f;

   346

}

   347

   348

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

   349

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

   350

{

   351

	FILE *f = NULL;

   352

	Searchpath sp;

   353

   354

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

   355

   356

	FOR_ALL_SEARCHPATHS(sp) {

   357

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

   358

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

   359

	}

   360

   361

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

   362

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

   363

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

   364

		char resolved_name[MAX_RESOLVED_LENGTH];

   365

   366

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

   367

		strcpy(resolved_name, filename);

   368

		strtolower(resolved_name);

   369

   370

		size_t resolved_len = strlen(resolved_name);

   371

   372

		/* Resolve ONE directory link */

   373

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

   374

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

   375

			size_t len = src.length();

   376

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

   377

				/* Apply link */

   378

				char resolved_name2[MAX_RESOLVED_LENGTH];

   379

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

   380

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

   381

				strcpy(resolved_name, dest.c_str());

   382

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

   383

				break; // Only resolve one level

   384

			}

   385

		}

   386

   387

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

   388

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

   389

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

   390

		}

   391

	}

   392

   393

	/* Sometimes a full path is given. To support

   394

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

   395

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

   396

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

   397

	}

   398

   399

	return f;

   400

}

   401

   402

/**

   403

 * Create a directory with the given name

   404

 * @param name the new name of the directory

   405

 */

   406

void FioCreateDirectory(const char *name)

   407

{

   408

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

   409

	CreateDirectory(OTTD2FS(name), NULL);

   410

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

   411

	mkdir(OTTD2FS(name));

   412

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

   413

	char buf[MAX_PATH];

   414

	ttd_strlcpy(buf, name, MAX_PATH);

   415

   416

	size_t len = strlen(name) - 1;

   417

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

   418

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

   419

	}

   420

   421

	mkdir(OTTD2FS(buf), 0755);

   422

#else

   423

	mkdir(OTTD2FS(name), 0755);

   424

#endif

   425

}

   426

   427

/**

   428

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

   429

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

   430

 * @param buf    string to append the separator to

   431

 * @param buflen the length of the buf

   432

 */

   433

void AppendPathSeparator(char *buf, size_t buflen)

   434

{

   435

	size_t s = strlen(buf);

   436

   437

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

   438

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

   439

		buf[s]     = PATHSEPCHAR;

   440

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

   441

	}

   442

}

   443

   444

/**

   445

 * Allocates and files a variable with the full path

   446

 * based on the given directory.

   447

 * @param dir the directory to base the path on

   448

 * @return the malloced full path

   449

 */

   450

char *BuildWithFullPath(const char *dir)

   451

{

   452

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

   453

	ttd_strlcpy(dest, dir, MAX_PATH);

   454

   455

	/* Check if absolute or relative path */

   456

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

   457

   458

	/* Add absolute path */

   459

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

   460

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

   461

		AppendPathSeparator(dest, MAX_PATH);

   462

		ttd_strlcat(dest, dir, MAX_PATH);

   463

	}

   464

	AppendPathSeparator(dest, MAX_PATH);

   465

   466

	return dest;

   467

}

   468

   469

/**

   470

 * Simplify filenames from tars.

   471

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

   472

 * @param name Filename to process.

   473

 */

   474

static void SimplifyFileName(char *name)

   475

{

   476

	/* Force lowercase */

   477

	strtolower(name);

   478

   479

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

   480

#if (PATHSEPCHAR != '/')

   481

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

   482

#endif

   483

}

   484

   485

static bool TarListAddFile(const char *filename)

   486

{

   487

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

   488

	typedef struct TarHeader {

   489

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

   490