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);

   189

	if (f == NULL) usererror("Cannot open file '%s'", 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

	"ai" PATHSEP,

   220

};

   221

   222

const char *_searchpaths[NUM_SEARCHPATHS];

   223

TarList _tar_list;

   224

TarFileList _tar_filelist;

   225

   226

/**

   227

 * Check whether the given file exists

   228

 * @param filename the file to try for existance

   229

 * @param subdir the subdirectory to look in

   230

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

   231

 */

   232

bool FioCheckFileExists(const char *filename, Subdirectory subdir)

   233

{

   234

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

   235

	if (f == NULL) return false;

   236

   237

	FioFCloseFile(f);

   238

	return true;

   239

}

   240

   241

/**

   242

 * Close a file in a safe way.

   243

 */

   244

void FioFCloseFile(FILE *f)

   245

{

   246

	fclose(f);

   247

}

   248

   249

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

   250

{

   251

	assert(subdir < NUM_SUBDIRS);

   252

	assert(sp < NUM_SEARCHPATHS);

   253

   254

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

   255

	return buf;

   256

}

   257

   258

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

   259

{

   260

	Searchpath sp;

   261

	assert(subdir < NUM_SUBDIRS);

   262

   263

	FOR_ALL_SEARCHPATHS(sp) {

   264

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

   265

		if (FileExists(buf)) break;

   266

	}

   267

   268

	return buf;

   269

}

   270

   271

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

   272

{

   273

	assert(subdir < NUM_SUBDIRS);

   274

	assert(sp < NUM_SEARCHPATHS);

   275

   276

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

   277

	return buf;

   278

}

   279

   280

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

   281

{

   282

	Searchpath sp;

   283

   284

	/* Find and return the first valid directory */

   285

	FOR_ALL_SEARCHPATHS(sp) {

   286

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

   287

		if (FileExists(buf)) return ret;

   288

	}

   289

   290

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

   291

	ttd_strlcpy(buf, _personal_dir, buflen);

   292

   293

	return buf;

   294

}

   295

   296

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

   297

{

   298

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

   299

	/* fopen is implemented as a define with ellipses for

   300

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

   301

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

   302

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

   303

	wchar_t Lmode[5];

   304

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

   305

#endif

   306

	FILE *f = NULL;

   307

	char buf[MAX_PATH];

   308

   309

	if (subdir == NO_DIRECTORY) {

   310

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

   311

	} else {

   312

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

   313

	}

   314

   315

#if defined(WIN32)

   316

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

   317

#endif

   318

   319

	f = fopen(buf, mode);

   320

#if !defined(WIN32)

   321

	if (f == NULL) {

   322

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

   323

		f = fopen(buf, mode);

   324

	}

   325

#endif

   326

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

   327

		/* Find the size of the file */

   328

		fseek(f, 0, SEEK_END);

   329

		*filesize = ftell(f);

   330

		fseek(f, 0, SEEK_SET);

   331

	}

   332

	return f;

   333

}

   334

   335

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

   336

{

   337

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

   338

	assert(f != NULL);

   339

   340

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

   341

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

   342

	return f;

   343

}

   344

   345

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

   346

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

   347

{

   348

	FILE *f = NULL;

   349

	Searchpath sp;

   350

   351

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

   352

   353

	FOR_ALL_SEARCHPATHS(sp) {

   354

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

   355

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

   356

	}

   357

   358

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

   359

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

   360

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

   361

		char *lcfilename = strdup(filename);

   362

		strtolower(lcfilename);

   363

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

   364

		free(lcfilename);

   365

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

   366

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

   367

		}

   368

	}

   369

   370

	/* Sometimes a full path is given. To support

   371

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

   372

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

   373

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

   374

	}

   375

   376

	return f;

   377

}

   378

   379

/**

   380

 * Create a directory with the given name

   381

 * @param name the new name of the directory

   382

 */

   383

void FioCreateDirectory(const char *name)

   384

{

   385

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

   386

	CreateDirectory(OTTD2FS(name), NULL);

   387

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

   388

	mkdir(OTTD2FS(name));

   389

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

   390

	char buf[MAX_PATH];

   391

	ttd_strlcpy(buf, name, MAX_PATH);

   392

   393

	size_t len = strlen(name) - 1;

   394

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

   395

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

   396

	}

   397

   398

	mkdir(OTTD2FS(buf), 0755);

   399

#else

   400

	mkdir(OTTD2FS(name), 0755);

   401

#endif

   402

}

   403

   404

/**

   405

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

   406

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

   407

 * @param buf    string to append the separator to

   408

 * @param buflen the length of the buf

   409

 */

   410

void AppendPathSeparator(char *buf, size_t buflen)

   411

{

   412

	size_t s = strlen(buf);

   413

   414

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

   415

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

   416

		buf[s]     = PATHSEPCHAR;

   417

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

   418

	}

   419

}

   420

   421

/**

   422

 * Allocates and files a variable with the full path

   423

 * based on the given directory.

   424

 * @param dir the directory to base the path on

   425

 * @return the malloced full path

   426

 */

   427

char *BuildWithFullPath(const char *dir)

   428

{

   429

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

   430

	ttd_strlcpy(dest, dir, MAX_PATH);

   431

   432

	/* Check if absolute or relative path */

   433

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

   434

   435

	/* Add absolute path */

   436

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

   437

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

   438

		AppendPathSeparator(dest, MAX_PATH);

   439

		ttd_strlcat(dest, dir, MAX_PATH);

   440

	}

   441

	AppendPathSeparator(dest, MAX_PATH);

   442

   443

	return dest;

   444

}

   445

   446

const char *FioTarFirstDir(const char *tarname)

   447

{

   448

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

   449

	if (it == _tar_list.end()) return NULL;

   450

	return (*it).second->dirname;

   451

}

   452

   453

static bool TarListAddFile(const char *filename)

   454

{

   455

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

   456

	typedef struct TarHeader {

   457

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

   458

		char mode[8];

   459

		char uid[8];

   460

		char gid[8];

   461

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

   462

		char mtime[12];

   463

		char chksum[8];

   464

		char typeflag;

   465

		char linkname[100];

   466

		char magic[6];

   467

		char version[2];

   468

		char uname[32];

   469

		char gname[32];

   470

		char devmajor[8];

   471

		char devminor[8];

   472

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

   473

   474

		char unused[12];

   475

	} TarHeader;

   476

   477

	/* Check if we already seen this file */

   478

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

   479

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

   480

   481

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

   482

	assert(f != NULL);

   483

   484

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

   485

	tar_entry->filename = strdup(filename);

   486

	tar_entry->dirname = NULL;

   487

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

   488

   489

	TarHeader th;

   490

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

   491

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