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

#ifdef WIN32

    15

#include <windows.h>

    16

#else

    17

#include <pwd.h>

    18

#include <unistd.h>

    19

#endif

    20

#include <sys/stat.h>

    21

    22

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

    23

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

    24

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

    25

    26

#define FIO_BUFFER_SIZE 512

    27

    28

struct Fio {

    29

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

    30

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

    31

	FILE *cur_fh;                          ///< current file handle

    32

	const char *filename;                  ///< current filename

    33

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

    34

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

    35

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

    36

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

    37

#if defined(LIMITED_FDS)

    38

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

    39

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

    40

#endif /* LIMITED_FDS */

    41

};

    42

    43

static Fio _fio;

    44

    45

/* Get current position in file */

    46

size_t FioGetPos()

    47

{

    48

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

    49

}

    50

    51

const char *FioGetFilename(uint8 slot)

    52

{

    53

	return _fio.shortnames[slot];

    54

}

    55

    56

void FioSeekTo(size_t pos, int mode)

    57

{

    58

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

    59

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

    60

	_fio.pos = pos;

    61

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

    62

}

    63

    64

#if defined(LIMITED_FDS)

    65

static void FioRestoreFile(int slot)

    66

{

    67

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

    68

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

    69

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

    70

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

    71

	}

    72

	_fio.usage_count[slot]++;

    73

}

    74

#endif /* LIMITED_FDS */

    75

    76

/* Seek to a file and a position */

    77

void FioSeekToFile(uint8 slot, size_t pos)

    78

{

    79

	FILE *f;

    80

#if defined(LIMITED_FDS)

    81

	/* Make sure we have this file open */

    82

	FioRestoreFile(slot);

    83

#endif /* LIMITED_FDS */

    84

	f = _fio.handles[slot];

    85

	assert(f != NULL);

    86

	_fio.cur_fh = f;

    87

	_fio.filename = _fio.filenames[slot];

    88

	FioSeekTo(pos, SEEK_SET);

    89

}

    90

    91

byte FioReadByte()

    92

{

    93

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

    94

		_fio.buffer = _fio.buffer_start;

    95

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

    96

		_fio.pos += size;

    97

		_fio.buffer_end = _fio.buffer_start + size;

    98

    99

		if (size == 0) return 0;

   100

	}

   101

	return *_fio.buffer++;

   102

}

   103

   104

void FioSkipBytes(int n)

   105

{

   106

	for (;;) {

   107

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

   108

		_fio.buffer += m;

   109

		n -= m;

   110

		if (n == 0) break;

   111

		FioReadByte();

   112

		n--;

   113

	}

   114

}

   115

   116

uint16 FioReadWord()

   117

{

   118

	byte b = FioReadByte();

   119

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

   120

}

   121

   122

uint32 FioReadDword()

   123

{

   124

	uint b = FioReadWord();

   125

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

   126

}

   127

   128

void FioReadBlock(void *ptr, size_t size)

   129

{

   130

	FioSeekTo(FioGetPos(), SEEK_SET);

   131

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

   132

}

   133

   134

static inline void FioCloseFile(int slot)

   135

{

   136

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

   137

		fclose(_fio.handles[slot]);

   138

   139

		free(_fio.shortnames[slot]);

   140

		_fio.shortnames[slot] = NULL;

   141

   142

		_fio.handles[slot] = NULL;

   143

#if defined(LIMITED_FDS)

   144

		_fio.open_handles--;

   145

#endif /* LIMITED_FDS */

   146

	}

   147

}

   148

   149

void FioCloseAll()

   150

{

   151

	int i;

   152

   153

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

   154

		FioCloseFile(i);

   155

}

   156

   157

#if defined(LIMITED_FDS)

   158

static void FioFreeHandle()

   159

{

   160

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

   161

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

   162

		uint i, count;

   163

		int slot;

   164

   165

		count = UINT_MAX;

   166

		slot = -1;

   167

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

   168

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

   169

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

   170

				count = _fio.usage_count[i];

   171

				slot  = i;

   172

			}

   173

		}

   174

		assert(slot != -1);

   175

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

   176

		FioCloseFile(slot);

   177

	}

   178

}

   179

#endif /* LIMITED_FDS */

   180

   181

void FioOpenFile(int slot, const char *filename)

   182

{

   183

	FILE *f;

   184

   185

#if defined(LIMITED_FDS)

   186

	FioFreeHandle();

   187

#endif /* LIMITED_FDS */

   188

	f = FioFOpenFile(filename);

   190

	uint32 pos = ftell(f);

   191

   192

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

   193

	_fio.handles[slot] = f;

   194

	_fio.filenames[slot] = filename;

   195

   196

	/* Store the filename without path and extension */

   197

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

   198

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

   199

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

   200

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

   201

	strtolower(_fio.shortnames[slot]);

   202

   203

#if defined(LIMITED_FDS)

   204

	_fio.usage_count[slot] = 0;

   205

	_fio.open_handles++;

   206

#endif /* LIMITED_FDS */

   207

	FioSeekToFile(slot, pos);

   208

}

   209

   210

const char *_subdirs[NUM_SUBDIRS] = {

   211

	"",

   212

	"save" PATHSEP,

   213

	"save" PATHSEP "autosave" PATHSEP,

   214

	"scenario" PATHSEP,

   215

	"scenario" PATHSEP "heightmap" PATHSEP,

   216

	"gm" PATHSEP,

   217

	"data" PATHSEP,

   218

	"lang" PATHSEP

   219

};

   220

   221

const char *_searchpaths[NUM_SEARCHPATHS];

   222

TarList _tar_list;

   223

TarFileList _tar_filelist;

   224

   225

/**

   226

 * Check whether the given file exists

   227

 * @param filename the file to try for existance

   228

 * @param subdir the subdirectory to look in

   229

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

   230

 */

   231

bool FioCheckFileExists(const char *filename, Subdirectory subdir)

   232

{

   233

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

   234

	if (f == NULL) return false;

   235

   236

	FioFCloseFile(f);

   237

	return true;

   238

}

   239

   240

/**

   241

 * Close a file in a safe way.

   242

 */

   243

void FioFCloseFile(FILE *f)

   244

{

   245

	fclose(f);

   246

}

   247

   248

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

   249

{

   250

	assert(subdir < NUM_SUBDIRS);

   251

	assert(sp < NUM_SEARCHPATHS);

   252

   253

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

   254

	return buf;

   255

}

   256

   257

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

   258

{

   259

	Searchpath sp;

   260

	assert(subdir < NUM_SUBDIRS);

   261

   262

	FOR_ALL_SEARCHPATHS(sp) {

   263

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

   264

		if (FileExists(buf)) break;

   265

	}

   266

   267

	return buf;

   268

}

   269

   270

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

   271

{

   272

	assert(subdir < NUM_SUBDIRS);

   273

	assert(sp < NUM_SEARCHPATHS);

   274

   275

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

   276

	return buf;

   277

}

   278

   279

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

   280

{

   281

	Searchpath sp;

   282

   283

	/* Find and return the first valid directory */

   284

	FOR_ALL_SEARCHPATHS(sp) {

   285

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

   286

		if (FileExists(buf)) return ret;

   287

	}

   288

   289

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

   290

	ttd_strlcpy(buf, _personal_dir, buflen);

   291

   292

	return buf;

   293

}

   294

   295

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

   296

{

   297

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

   298

	/* fopen is implemented as a define with ellipses for

   299

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

   300

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

   301

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

   302

	wchar_t Lmode[5];

   303

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

   304

#endif

   305

	FILE *f = NULL;

   306

	char buf[MAX_PATH];

   307

   308

	if (subdir == NO_DIRECTORY) {

   309

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

   310

	} else {

   311

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

   312

	}

   313

   314

#if defined(WIN32)

   315

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

   316

#endif

   317

   318

	f = fopen(buf, mode);

   319

#if !defined(WIN32)

   320

	if (f == NULL) {

   321

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

   322

		f = fopen(buf, mode);

   323

	}

   324

#endif

   325

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

   326

		/* Find the size of the file */

   327

		fseek(f, 0, SEEK_END);

   328

		*filesize = ftell(f);

   329

		fseek(f, 0, SEEK_SET);

   330

	}

   331

	return f;

   332

}

   333

   334

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

   335

{

   336

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

   337

	assert(f != NULL);

   338

   339

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

   340

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

   341

	return f;

   342

}

   343

   344

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

   345

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

   346

{

   347

	FILE *f = NULL;

   348

	Searchpath sp;

   349

   350

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

   351

   352

	FOR_ALL_SEARCHPATHS(sp) {

   353

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

   354

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

   355

	}

   356

   357

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

   358

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

   359

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

   360

		char *lcfilename = strdup(filename);

   361

		strtolower(lcfilename);

   362

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

   363

		free(lcfilename);

   364

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

   365

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

   366

		}

   367

	}

   368

   369

	/* Sometimes a full path is given. To support

   370

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

   371

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

   372

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

   373

	}

   374

   375

	return f;

   376

}

   377

   378

/**

   379

 * Create a directory with the given name

   380

 * @param name the new name of the directory

   381

 */

   382

void FioCreateDirectory(const char *name)

   383

{

   384

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

   385

	CreateDirectory(OTTD2FS(name), NULL);

   386

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

   387

	mkdir(OTTD2FS(name));

   388

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

   389

	char buf[MAX_PATH];

   390

	ttd_strlcpy(buf, name, MAX_PATH);

   391

   392

	size_t len = strlen(name) - 1;

   393

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

   394

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

   395

	}

   396

   397

	mkdir(OTTD2FS(buf), 0755);

   398

#else

   399

	mkdir(OTTD2FS(name), 0755);

   400

#endif

   401

}

   402

   403

/**

   404

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

   405

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

   406

 * @param buf    string to append the separator to

   407

 * @param buflen the length of the buf

   408

 */

   409

void AppendPathSeparator(char *buf, size_t buflen)

   410

{

   411

	size_t s = strlen(buf);

   412

   413

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

   414

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

   415

		buf[s]     = PATHSEPCHAR;

   416

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

   417

	}

   418

}

   419

   420

/**

   421

 * Allocates and files a variable with the full path

   422

 * based on the given directory.

   423

 * @param dir the directory to base the path on

   424

 * @return the malloced full path

   425

 */

   426

char *BuildWithFullPath(const char *dir)

   427

{

   428

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

   429

	ttd_strlcpy(dest, dir, MAX_PATH);

   430

   431

	/* Check if absolute or relative path */

   432

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

   433

   434

	/* Add absolute path */

   435

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

   436

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

   437

		AppendPathSeparator(dest, MAX_PATH);

   438

		ttd_strlcat(dest, dir, MAX_PATH);

   439

	}

   440

	AppendPathSeparator(dest, MAX_PATH);

   441

   442

	return dest;

   443

}

   444

   445

static bool TarListAddFile(const char *filename)

   446

{

   447

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

   448

	typedef struct TarHeader {

   449

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

   450

		char mode[8];

   451

		char uid[8];

   452

		char gid[8];

   453

		char size[12];       ///< Size of the file, in ASCII

   454

		char mtime[12];

   455

		char chksum[8];

   456

		char typeflag;

   457

		char linkname[100];

   458

		char magic[6];

   459

		char version[2];

   460

		char uname[32];

   461

		char gname[32];

   462

		char devmajor[8];

   463

		char devminor[8];

   464

		char prefix[155];    ///< Path of the file

   465

   466

		char unused[12];

   467

	} TarHeader;

   468

   469

	/* Check if we already seen this file */

   470

	TarList::iterator it = _tar_list.find(filename);

   471

	if (it != _tar_list.end()) return false;

   472

   473

	FILE *f = fopen(filename, "rb");

   474

	assert(f != NULL);

   475

   476

	TarListEntry *tar_entry = MallocT<TarListEntry>(1);

   477

	tar_entry->filename = strdup(filename);

   478

	_tar_list.insert(TarList::value_type(filename, tar_entry));

   479

   480

	TarHeader th;

   481

	char buf[sizeof(th.name) + 1], *end;

   482

	char name[sizeof(th.prefix) + 1 + sizeof(th.name) + 1];

   483

	size_t num = 0, pos = 0;

   484

   485

	/* Make a char of 512 empty bytes */

   486

	char empty[512];

   487

	memset(&empty[0], 0, sizeof(empty));

   488

   489

	while (!feof(f)) {

   490

		pos += fread(&th, 1, 512, f);