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 "functions.h"

     9

#include "string.h"

    10

#include "variables.h"

    11

#include "debug.h"

    12

#include "fios.h"

    13

#ifdef WIN32

    14

#include <windows.h>

    15

#else

    16

#include <pwd.h>

    17

#include <unistd.h>

    18

#endif

    19

#include <sys/stat.h>

    20

    21

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

    22

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

    23

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

    24

    25

#define FIO_BUFFER_SIZE 512

    26

    27

struct Fio {

    28

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

    29

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

    30

	FILE *cur_fh;                          ///< current file handle

    31

	const char *filename;                  ///< current filename

    32

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

    33

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

    34

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

    35

#if defined(LIMITED_FDS)

    36

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

    37

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

    38

#endif /* LIMITED_FDS */

    39

};

    40

    41

static Fio _fio;

    42

    43

/* Get current position in file */

    44

uint32 FioGetPos()

    45

{

    46

	return _fio.pos + (_fio.buffer - _fio.buffer_start) - FIO_BUFFER_SIZE;

    47

}

    48

    49

const char *FioGetFilename()

    50

{

    51

	return _fio.filename;

    52

}

    53

    54

void FioSeekTo(uint32 pos, int mode)

    55

{

    56

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

    57

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

    58

	_fio.pos = pos;

    59

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

    60

}

    61

    62

#if defined(LIMITED_FDS)

    63

static void FioRestoreFile(int slot)

    64

{

    65

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

    66

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

    67

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

    68

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

    69

	}

    70

	_fio.usage_count[slot]++;

    71

}

    72

#endif /* LIMITED_FDS */

    73

    74

/* Seek to a file and a position */

    75

void FioSeekToFile(uint8 slot, uint32 pos)

    76

{

    77

	FILE *f;

    78

#if defined(LIMITED_FDS)

    79

	/* Make sure we have this file open */

    80

	FioRestoreFile(slot);

    81

#endif /* LIMITED_FDS */

    82

	f = _fio.handles[slot];

    83

	assert(f != NULL);

    84

	_fio.cur_fh = f;

    85

	_fio.filename = _fio.filenames[slot];

    86

	FioSeekTo(pos, SEEK_SET);

    87

}

    88

    89

byte FioReadByte()

    90

{

    91

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

    92

		_fio.pos += FIO_BUFFER_SIZE;

    93

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

    94

	}

    95

	return *_fio.buffer++;

    96

}

    97

    98

void FioSkipBytes(int n)

    99

{

   100

	for (;;) {

   101

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

   102

		_fio.buffer += m;

   103

		n -= m;

   104

		if (n == 0) break;

   105

		FioReadByte();

   106

		n--;

   107

	}

   108

}

   109

   110

uint16 FioReadWord()

   111

{

   112

	byte b = FioReadByte();

   113

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

   114

}

   115

   116

uint32 FioReadDword()

   117

{

   118

	uint b = FioReadWord();

   119

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

   120

}

   121

   122

void FioReadBlock(void *ptr, uint size)

   123

{

   124

	FioSeekTo(FioGetPos(), SEEK_SET);

   125

	_fio.pos += size;

   126

	fread(ptr, 1, size, _fio.cur_fh);

   127

}

   128

   129

static inline void FioCloseFile(int slot)

   130

{

   131

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

   132

		fclose(_fio.handles[slot]);

   133

		_fio.handles[slot] = NULL;

   134

#if defined(LIMITED_FDS)

   135

		_fio.open_handles--;

   136

#endif /* LIMITED_FDS */

   137

	}

   138

}

   139

   140

void FioCloseAll()

   141

{

   142

	int i;

   143

   144

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

   145

		FioCloseFile(i);

   146

}

   147

   148

#if defined(LIMITED_FDS)

   149

static void FioFreeHandle()

   150

{

   151

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

   152

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

   153

		uint i, count;

   154

		int slot;

   155

   156

		count = UINT_MAX;

   157

		slot = -1;

   158

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

   159

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

   160

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

   161

				count = _fio.usage_count[i];

   162

				slot  = i;

   163

			}

   164

		}

   165

		assert(slot != -1);

   166

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

   167

		FioCloseFile(slot);

   168

	}

   169

}

   170

#endif /* LIMITED_FDS */

   171

   172

void FioOpenFile(int slot, const char *filename)

   173

{

   174

	FILE *f;

   175

   176

#if defined(LIMITED_FDS)

   177

	FioFreeHandle();

   178

#endif /* LIMITED_FDS */

   179

	f = FioFOpenFile(filename);

   180

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

   181

	uint32 pos = ftell(f);

   182

   183

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

   184

	_fio.handles[slot] = f;

   185

	_fio.filenames[slot] = filename;

   186

#if defined(LIMITED_FDS)

   187

	_fio.usage_count[slot] = 0;

   188

	_fio.open_handles++;

   189

#endif /* LIMITED_FDS */

   190

	FioSeekToFile(slot, pos);

   191

}

   192

   193

const char *_subdirs[NUM_SUBDIRS] = {

   194

	"",

   195

	"save" PATHSEP,

   196

	"save" PATHSEP "autosave" PATHSEP,

   197

	"scenario" PATHSEP,

   198

	"scenario" PATHSEP "heightmap" PATHSEP,

   199

	"gm" PATHSEP,

   200

	"data" PATHSEP,

   201

	"lang" PATHSEP

   202

};

   203

   204

const char *_searchpaths[NUM_SEARCHPATHS];

   205

TarList _tar_list;

   206

TarFileList _tar_filelist;

   207

   208

/**

   209

 * Check whether the given file exists

   210

 * @param filename the file to try for existance

   211

 * @param subdir the subdirectory to look in

   212

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

   213

 */

   214

bool FioCheckFileExists(const char *filename, Subdirectory subdir)

   215

{

   216

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

   217

	if (f == NULL) return false;

   218

   219

	FioFCloseFile(f);

   220

	return true;

   221

}

   222

   223

/**

   224

 * Close a file in a safe way.

   225

 */

   226

void FioFCloseFile(FILE *f)

   227

{

   228

	fclose(f);

   229

}

   230

   231

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

   232

{

   233

	assert(subdir < NUM_SUBDIRS);

   234

	assert(sp < NUM_SEARCHPATHS);

   235

   236

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

   237

	return buf;

   238

}

   239

   240

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

   241

{

   242

	Searchpath sp;

   243

	assert(subdir < NUM_SUBDIRS);

   244

   245

	FOR_ALL_SEARCHPATHS(sp) {

   246

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

   247

		if (FileExists(buf)) break;

   248

	}

   249

   250

	return buf;

   251

}

   252

   253

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

   254

{

   255

	assert(subdir < NUM_SUBDIRS);

   256

	assert(sp < NUM_SEARCHPATHS);

   257

   258

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

   259

	return buf;

   260

}

   261

   262

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

   263

{

   264

	Searchpath sp;

   265

   266

	/* Find and return the first valid directory */

   267

	FOR_ALL_SEARCHPATHS(sp) {

   268

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

   269

		if (FileExists(buf)) return ret;

   270

	}

   271

   272

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

   273

	ttd_strlcpy(buf, _personal_dir, buflen);

   274

   275

	return buf;

   276

}

   277

   278

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

   279

{

   280

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

   281

	/* fopen is implemented as a define with ellipses for

   282

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

   283

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

   284

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

   285

	wchar_t Lmode[5];

   286

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

   287

#endif

   288

	FILE *f = NULL;

   289

	char buf[MAX_PATH];

   290

   291

	if (subdir == NO_DIRECTORY) {

   292

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

   293

	} else {

   294

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

   295

	}

   296

   297

#if defined(WIN32)

   298

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

   299

#endif

   300

   301

	f = fopen(buf, mode);

   302

#if !defined(WIN32)

   303

	if (f == NULL) {

   304

		strtolower(buf + strlen(_searchpaths[sp]) - 1);

   305

		f = fopen(buf, mode);

   306

	}

   307

#endif

   308

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

   309

		/* Find the size of the file */

   310

		fseek(f, 0, SEEK_END);

   311

		*filesize = ftell(f);

   312

		fseek(f, 0, SEEK_SET);

   313

	}

   314

	return f;

   315

}

   316

   317

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

   318

{

   319

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

   320

	assert(f != NULL);

   321

   322

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

   323

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

   324

	return f;

   325

}

   326

   327

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

   328

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

   329

{

   330

	FILE *f = NULL;

   331

	Searchpath sp;

   332

   333

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

   334

   335

	FOR_ALL_SEARCHPATHS(sp) {

   336

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

   337

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

   338

	}

   339

   340

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

   341

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

   342

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

   343

		char *lcfilename = strdup(filename);

   344

		strtolower(lcfilename);

   345

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

   346

		free(lcfilename);

   347

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

   348

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

   349

		}

   350

	}

   351

   352

	/* Sometimes a full path is given. To support

   353

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

   354

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

   355

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

   356

	}

   357

   358

	return f;

   359

}

   360

   361

/**

   362

 * Create a directory with the given name

   363

 * @param name the new name of the directory

   364

 */

   365

void FioCreateDirectory(const char *name)

   366

{

   367

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

   368

	CreateDirectory(OTTD2FS(name), NULL);

   369

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

   370

	mkdir(OTTD2FS(name));

   371

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

   372

	char buf[MAX_PATH];

   373

	ttd_strlcpy(buf, name, MAX_PATH);

   374

   375

	size_t len = strlen(name) - 1;

   376

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

   377

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

   378

	}

   379

   380

	mkdir(OTTD2FS(buf), 0755);

   381

#else

   382

	mkdir(OTTD2FS(name), 0755);

   383

#endif

   384

}

   385

   386

/**

   387

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

   388

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

   389

 * @param buf    string to append the separator to

   390

 * @param buflen the length of the buf

   391

 */

   392

void AppendPathSeparator(char *buf, size_t buflen)

   393

{

   394

	size_t s = strlen(buf);

   395

   396

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

   397

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

   398

		buf[s]     = PATHSEPCHAR;

   399

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

   400

	}

   401

}

   402

   403

/**

   404

 * Allocates and files a variable with the full path

   405

 * based on the given directory.

   406

 * @param dir the directory to base the path on

   407

 * @return the malloced full path

   408

 */

   409

char *BuildWithFullPath(const char *dir)

   410

{

   411

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

   412

	ttd_strlcpy(dest, dir, MAX_PATH);

   413

   414

	/* Check if absolute or relative path */

   415

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

   416

   417

	/* Add absolute path */

   418

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

   419

		getcwd(dest, MAX_PATH);

   420

		AppendPathSeparator(dest, MAX_PATH);

   421

		ttd_strlcat(dest, dir, MAX_PATH);

   422

	}

   423

	AppendPathSeparator(dest, MAX_PATH);

   424

   425

	return dest;

   426

}

   427

   428

static bool TarListAddFile(const char *filename)

   429

{

   430

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

   431

	typedef struct TarHeader {

   432

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

   433

		char mode[8];

   434

		char uid[8];

   435

		char gid[8];

   436

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

   437

		char mtime[12];

   438

		char chksum[8];

   439

		char typeflag;

   440

		char linkname[100];

   441

		char magic[6];

   442

		char version[2];

   443

		char uname[32];

   444

		char gname[32];

   445

		char devmajor[8];

   446

		char devminor[8];

   447

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

   448

   449

		char unused[12];

   450

	} TarHeader;

   451

   452

	/* Check if we already seen this file */

   453

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

   454

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

   455

   456

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

   457

	assert(f != NULL);

   458

   459

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

   460

	tar_entry->filename = strdup(filename);

   461

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

   462

   463

	TarHeader th;

   464

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

   465

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

   466

	int num = 0, pos = 0;

   467

   468

	/* Make a char of 512 empty bytes */

   469

	char empty[512];

   470

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

   471

   472

	while (!feof(f)) {

   473

		fread(&th, 1, 512, f);

   474

		pos += 512;

   475

   476

		/* Check if we have the new tar-format (ustar) or the old one (a lot of zeros after 'link' field) */

   477

		if (strncmp(th.magic, "ustar", 5) != 0 && memcmp(&th.magic, &empty[0], 512 - offsetof(TarHeader, magic)) != 0) {

   478

			/* If we have only zeros in the block, it can be an end-of-file indicator */

   479

			if (memcmp(&th, &empty[0], 512) == 0) continue;

   480

   481

			DEBUG(misc, 0, "The file '%s' isn't a valid tar-file", filename);

   482

			return false;

   483

		}

   484

   485

		name[0] = '\0';

   486

		int len = 0;

   487

   488

		/* The prefix contains the directory-name */

   489

		if (th.prefix[0] != '\0') {

   490

			memcpy(name, th.prefix, sizeof(th.prefix));

   491

			name[sizeof(th.prefix)] = '\0';

   492

			len = strlen(name);