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

    11

#include "variables.h"

    12

#include "debug.h"

    13

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

#define MAX_HANDLES 64

    28

    29

struct Fio {

    30

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

    31

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

    32

	FILE *cur_fh;                       ///< current file handle

    33

	const char *filename;               ///< current filename

    34

	FILE *handles[MAX_HANDLES];         ///< 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_HANDLES]; ///< array of filenames we (should) have open

    37

#if defined(LIMITED_FDS)

    38

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

    39

	uint usage_count[MAX_HANDLES];      ///< 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

uint32 FioGetPos()

    47

{

    48

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

    49

}

    50

    51

const char *FioGetFilename()

    52

{

    53

	return _fio.filename;

    54

}

    55

    56

void FioSeekTo(uint32 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, uint32 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.pos += FIO_BUFFER_SIZE;

    95

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

    96

	}

    97

	return *_fio.buffer++;

    98

}

    99

   100

void FioSkipBytes(int n)

   101

{

   102

	for (;;) {

   103

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

   104

		_fio.buffer += m;

   105

		n -= m;

   106

		if (n == 0) break;

   107

		FioReadByte();

   108

		n--;

   109

	}

   110

}

   111

   112

uint16 FioReadWord()

   113

{

   114

	byte b = FioReadByte();

   115

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

   116

}

   117

   118

uint32 FioReadDword()

   119

{

   120

	uint b = FioReadWord();

   121

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

   122

}

   123

   124

void FioReadBlock(void *ptr, uint size)

   125

{

   126

	FioSeekTo(FioGetPos(), SEEK_SET);

   127

	_fio.pos += size;

   128

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

   129

}

   130

   131

static inline void FioCloseFile(int slot)

   132

{

   133

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

   134

		fclose(_fio.handles[slot]);

   135

		_fio.handles[slot] = NULL;

   136

#if defined(LIMITED_FDS)

   137

		_fio.open_handles--;

   138

#endif /* LIMITED_FDS */

   139

	}

   140

}

   141

   142

void FioCloseAll()

   143

{

   144

	int i;

   145

   146

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

   147

		FioCloseFile(i);

   148

}

   149

   150

#if defined(LIMITED_FDS)

   151

static void FioFreeHandle()

   152

{

   153

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

   154

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

   155

		uint i, count;

   156

		int slot;

   157

   158

		count = UINT_MAX;

   159

		slot = -1;

   160

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

   161

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

   162

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

   163

				count = _fio.usage_count[i];

   164

				slot  = i;

   165

			}

   166

		}

   167

		assert(slot != -1);

   168

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

   169

		FioCloseFile(slot);

   170

	}

   171

}

   172

#endif /* LIMITED_FDS */

   173

   174

void FioOpenFile(int slot, const char *filename)

   175

{

   176

	FILE *f;

   177

   178

#if defined(LIMITED_FDS)

   179

	FioFreeHandle();

   180

#endif /* LIMITED_FDS */

   181

	f = FioFOpenFile(filename);

   182

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

   183

	uint32 pos = ftell(f);

   184

   185

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

   186

	_fio.handles[slot] = f;

   187

	_fio.filenames[slot] = filename;

   188

#if defined(LIMITED_FDS)

   189

	_fio.usage_count[slot] = 0;

   190

	_fio.open_handles++;

   191

#endif /* LIMITED_FDS */

   192

	FioSeekToFile(slot, pos);

   193

}

   194

   195

const char *_subdirs[NUM_SUBDIRS] = {

   196

	"",

   197

	"save" PATHSEP,

   198

	"save" PATHSEP "autosave" PATHSEP,

   199

	"scenario" PATHSEP,

   200

	"scenario" PATHSEP "heightmap" PATHSEP,

   201

	"gm" PATHSEP,

   202

	"data" PATHSEP,

   203

	"lang" PATHSEP

   204

};

   205

   206

const char *_searchpaths[NUM_SEARCHPATHS];

   207

TarList _tar_list;

   208

TarFileList _tar_filelist;

   209

   210

/**

   211

 * Check whether the given file exists

   212

 * @param filename the file to try for existance

   213

 * @param subdir the subdirectory to look in

   214

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

   215

 */

   216

bool FioCheckFileExists(const char *filename, Subdirectory subdir)

   217

{

   218

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

   219

	if (f == NULL) return false;

   220

   221

	FioFCloseFile(f);

   222

	return true;

   223

}

   224

   225

/**

   226

 * Close a file in a safe way.

   227

 */

   228

void FioFCloseFile(FILE *f)

   229

{

   230

	fclose(f);

   231

}

   232

   233

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

   234

{

   235

	assert(subdir < NUM_SUBDIRS);

   236

	assert(sp < NUM_SEARCHPATHS);

   237

   238

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

   239

	return buf;

   240

}

   241

   242

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

   243

{

   244

	Searchpath sp;

   245

	assert(subdir < NUM_SUBDIRS);

   246

   247

	FOR_ALL_SEARCHPATHS(sp) {

   248

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

   249

		if (FileExists(buf)) break;

   250

	}

   251

   252

	return buf;

   253

}

   254

   255

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

   256

{

   257

	assert(subdir < NUM_SUBDIRS);

   258

	assert(sp < NUM_SEARCHPATHS);

   259

   260

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

   261

	return buf;

   262

}

   263

   264

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

   265

{

   266

	Searchpath sp;

   267

   268

	/* Find and return the first valid directory */

   269

	FOR_ALL_SEARCHPATHS(sp) {

   270

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

   271

		if (FileExists(buf)) return ret;

   272

	}

   273

   274

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

   275

	ttd_strlcpy(buf, _personal_dir, buflen);

   276

   277

	return buf;

   278

}

   279

   280

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

   281

{

   282

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

   283

	/* fopen is implemented as a define with ellipses for

   284

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

   285

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

   286

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

   287

	wchar_t Lmode[5];

   288

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

   289

#endif

   290

	FILE *f = NULL;

   291

	char buf[MAX_PATH];

   292

   293

	if (subdir == NO_DIRECTORY) {

   294

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

   295

	} else {

   296

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

   297

	}

   298

   299

#if defined(WIN32)

   301

#endif

   302

   303

	f = fopen(buf, mode);

   304

#if !defined(WIN32)

   305

	if (f == NULL) {

   306

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

   307

		f = fopen(buf, mode);

   308

	}

   309

#endif

   310

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

   311

		/* Find the size of the file */

   312

		fseek(f, 0, SEEK_END);

   313

		*filesize = ftell(f);

   314

		fseek(f, 0, SEEK_SET);

   315

	}

   316

	return f;

   317

}

   318

   319

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

   320

{

   321

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

   322

	assert(f != NULL);

   323

   324

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

   325

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

   326

	return f;

   327

}

   328

   329

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

   330

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

   331

{

   332

	FILE *f = NULL;

   333

	Searchpath sp;

   334

   335

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

   336

   337

	FOR_ALL_SEARCHPATHS(sp) {

   338

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

   339

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

   340

	}

   341

   342

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

   343

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

   344

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

   345

		char *lcfilename = strdup(filename);

   346

		strtolower(lcfilename);

   347

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

   348

		free(lcfilename);

   349

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

   350

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

   351

		}

   352

	}

   353

   354

	return f;

   355

}

   356

   357

/**

   358

 * Create a directory with the given name

   359

 * @param name the new name of the directory

   360

 */

   361

void FioCreateDirectory(const char *name)

   362

{

   363

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

   364

	CreateDirectory(OTTD2FS(name), NULL);

   365

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

   366

	mkdir(OTTD2FS(name));

   367

#else

   368

	mkdir(OTTD2FS(name), 0755);

   369

#endif

   370

}

   371

   372

/**

   373

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

   374

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

   375

 * @param buf    string to append the separator to

   376

 * @param buflen the length of the buf

   377

 */

   378

void AppendPathSeparator(char *buf, size_t buflen)

   379

{

   380

	size_t s = strlen(buf);

   381

   382

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

   383

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

   384

		buf[s]     = PATHSEPCHAR;

   385

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

   386

	}

   387

}

   388

   389

/**

   390

 * Allocates and files a variable with the full path

   391

 * based on the given directory.

   392

 * @param dir the directory to base the path on

   393

 * @return the malloced full path

   394

 */

   395

char *BuildWithFullPath(const char *dir)

   396

{

   397

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

   398

	ttd_strlcpy(dest, dir, MAX_PATH);

   399

   400

	/* Check if absolute or relative path */

   401

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

   402

   403

	/* Add absolute path */

   404

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

   405

		getcwd(dest, MAX_PATH);

   406

		AppendPathSeparator(dest, MAX_PATH);

   407

		ttd_strlcat(dest, dir, MAX_PATH);

   408

	}

   409

	AppendPathSeparator(dest, MAX_PATH);

   410

   411

	return dest;

   412

}

   413

   414

static bool TarListAddFile(const char *filename)

   415

{

   416

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

   417

	typedef struct TarHeader {

   418

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

   419

		char mode[8];

   420

		char uid[8];

   421

		char gid[8];

   422

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

   423

		char mtime[12];

   424

		char chksum[8];

   425

		char typeflag;

   426

		char linkname[100];

   427

		char magic[6];

   428

		char version[2];

   429

		char uname[32];

   430

		char gname[32];

   431

		char devmajor[8];

   432

		char devminor[8];

   433

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

   434

   435

		char unused[12];

   436

	} TarHeader;

   437

   438

	/* Check if we already seen this file */

   439

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

   440

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

   441

   442

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

   443

	assert(f != NULL);

   444

   445

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

   446

	tar_entry->filename = strdup(filename);

   447

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

   448

   449

	TarHeader th;

   450

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

   451

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

   452

	int num = 0, pos = 0;

   453

   454

	/* Make a char of 512 empty bytes */

   455

	char empty[512];

   456

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

   457

   458

	while (!feof(f)) {

   459

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

   460

		pos += 512;

   461

   462

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

   463

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

   464

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

   465

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

   466

   467

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

   468

			return false;

   469

		}

   470

   471

		name[0] = '\0';

   472

		int len = 0;

   473

   474

		/* The prefix contains the directory-name */

   475

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

   476

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

   477

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

   478

			len = strlen(name);

   479

			name[len] = PATHSEPCHAR;

   480

			len++;

   481

		}

   482

   483

		/* Copy the name of the file in a safe way at the end of 'name' */

   484

		memcpy(&name[len], th.name, sizeof(th.name));

   485

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

   486

   487

		/* Calculate the size of the file.. for some strange reason this is stored as a string */

   488

		memcpy(buf, th.size, sizeof(th.size));

   489

		buf[sizeof(th.size)] = '\0';

   490

		int skip = strtol(buf, &end, 8);

   491

   492

		/* 0 byte sized files can be skipped (dirs, symlinks, ..) */