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"

    17

#include <pwd.h>

    18

#include <unistd.h>

    19

#include <sys/stat.h>

    20

#endif

    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

    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

    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

    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.filename[slot], slot);

    70

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

    71

	}

    72

	_fio.usage_count[slot]++;

    73

}

    74

#endif /* LIMITED_FDS */

    75

    76

/* Seek to a file and a position */

    77

void FioSeekToFile(uint32 pos)

    78

{

    79

	FILE *f;

    80

#if defined(LIMITED_FDS)

    81

	/* Make sure we have this file open */

    82

	FioRestoreFile(pos >> 24);

    83

#endif /* LIMITED_FDS */

    84

	f = _fio.handles[pos >> 24];

    85

	assert(f != NULL);

    86

	_fio.cur_fh = f;

    88

	FioSeekTo(GB(pos, 0, 24), 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.filename[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

   184

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

   185

	_fio.handles[slot] = f;

   187

#if defined(LIMITED_FDS)

   188

	_fio.usage_count[slot] = 0;

   189

	_fio.open_handles++;

   190

#endif /* LIMITED_FDS */

   191

	FioSeekToFile(slot << 24);

   192

}

   193

   207

/**

   208

 * Check whether the given file exists

   209

 * @param filename the file to try for existance

   211

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

   212

 */

   214

{

   216

	if (f == NULL) return false;

   217

   218

	fclose(f);

   219

	return true;

   220

}

   221

   223

{

   226

   239

	}

   240

   289

#if !defined(WIN32)

   290

	if (f == NULL) {

   293

	}

   294

#endif

   310

   311

	return f;

   312

}

   313

   314

/**

   315

 * Create a directory with the given name

   316

 * @param name the new name of the directory

   317

 */

   318

void FioCreateDirectory(const char *name)

   319

{

   320

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

   321

	CreateDirectory(OTTD2FS(name), NULL);

   322

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

   323

	mkdir(OTTD2FS(name));

   324

#else

   325

	mkdir(OTTD2FS(name), 0755);

   326

#endif

   327

}

   328

   329

/**

   330

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

   331

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

   332

 * @param buf    string to append the separator to

   333

 * @param buflen the length of the buf

   334

 */

   335

void AppendPathSeparator(char *buf, size_t buflen)

   336

{

   337

	size_t s = strlen(buf);

   338

   339

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

   340

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

   341

		buf[s]     = PATHSEPCHAR;

   342

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

   343

	}

   344

}

   345

   346

/**

   347

 * Allocates and files a variable with the full path

   348

 * based on the given directory.

   349

 * @param dir the directory to base the path on

   350

 * @return the malloced full path

   351

 */

   352

char *BuildWithFullPath(const char *dir)

   353

{

   354

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

   355

	ttd_strlcpy(dest, dir, MAX_PATH);

   356

   357

	/* Check if absolute or relative path */

   358

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

   359

   360

	/* Add absolute path */

   361

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

   362

		getcwd(dest, MAX_PATH);

   363

		AppendPathSeparator(dest, MAX_PATH);

   364

		ttd_strlcat(dest, dir, MAX_PATH);

   365

	}

   366

	AppendPathSeparator(dest, MAX_PATH);

   367

   368

	return dest;

   369

}

   370

   371

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

   372

/**

   373

 * Determine the base (personal dir and game data dir) paths

   376

 */

   377

extern void DetermineBasePaths(const char *exe);

   378

#else /* defined(WIN32) || defined(WINCE) */

   379

   380

/**

   381

 * Changes the working directory to the path of the give executable.

   382

 * For OSX application bundles '.app' is the required extension of the bundle,

   383

 * so when we crop the path to there, when can remove the name of the bundle

   384

 * in the same way we remove the name from the executable name.

   385

 * @param exe the path to the executable

   386

 */

   387

void ChangeWorkingDirectory(const char *exe)

   388

{

   389

#ifdef WITH_COCOA

   390

	char *app_bundle = strchr(exe, '.');

   391

	while (app_bundle != NULL && strncasecmp(app_bundle, ".app", 4) != 0) app_bundle = strchr(&app_bundle[1], '.');

   392

   393

	if (app_bundle != NULL) app_bundle[0] = '\0';

   394

#endif /* WITH_COCOA */

   395

	char *s = strrchr(exe, PATHSEPCHAR);

   396

	if (s != NULL) {

   397

		*s = '\0';

   398

		chdir(exe);

   399

		*s = PATHSEPCHAR;

   400

	}

   401

#ifdef WITH_COCOA

   402

	if (app_bundle != NULL) app_bundle[0] = '.';

   403

#endif /* WITH_COCOA */

   404

}

   405

   406

/**

   407

 * Determine the base (personal dir and game data dir) paths

   408

 * @param exe the path to the executable

   409

 */

   410

void DetermineBasePaths(const char *exe)

   411

{

   414

	const char *homedir = getenv("HOME");

   415

   416

	if (homedir == NULL) {

   417

		const struct passwd *pw = getpwuid(getuid());

   419

	}

   420

   449

}

   450

#endif /* defined(WIN32) || defined(WINCE) */

   451

   454

/**

   455

 * Acquire the base paths (personal dir and game data dir),

   456

 * fill all other paths (save dir, autosave dir etc) and

   457

 * make the save and scenario directories.

   459

 */

   460

void DeterminePaths(const char *exe)

   461

{

   462

	DetermineBasePaths(exe);

   463

   466