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

#ifndef WIN32

    15

#include <pwd.h>

    16

#include <unistd.h>

    17

#include <sys/stat.h>

    18

#endif

    19

    20

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

    21

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

    22

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

    23

    24

#define FIO_BUFFER_SIZE 512

    25

#define MAX_HANDLES 64

    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

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

    32

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

    33

#if defined(LIMITED_FDS)

    34

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

    35

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

    36

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

    37

#endif /* LIMITED_FDS */

    38

};

    39

    40

static Fio _fio;

    41

    42

/* Get current position in file */

    43

uint32 FioGetPos()

    44

{

    45

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

    46

}

    47

    48

void FioSeekTo(uint32 pos, int mode)

    49

{

    50

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

    51

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

    52

	_fio.pos = pos;

    53

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

    54

}

    55

    56

#if defined(LIMITED_FDS)

    57

static void FioRestoreFile(int slot)

    58

{

    59

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

    60

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

    61

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

    62

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

    63

	}

    64

	_fio.usage_count[slot]++;

    65

}

    66

#endif /* LIMITED_FDS */

    67

    68

/* Seek to a file and a position */

    69

void FioSeekToFile(uint32 pos)

    70

{

    71

	FILE *f;

    72

#if defined(LIMITED_FDS)

    73

	/* Make sure we have this file open */

    74

	FioRestoreFile(pos >> 24);

    75

#endif /* LIMITED_FDS */

    76

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

    77

	assert(f != NULL);

    78

	_fio.cur_fh = f;

    79

	FioSeekTo(GB(pos, 0, 24), SEEK_SET);

    80

}

    81

    82

byte FioReadByte()

    83

{

    84

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

    85

		_fio.pos += FIO_BUFFER_SIZE;

    86

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

    87

	}

    88

	return *_fio.buffer++;

    89

}

    90

    91

void FioSkipBytes(int n)

    92

{

    93

	for (;;) {

    94

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

    95

		_fio.buffer += m;

    96

		n -= m;

    97

		if (n == 0) break;

    98

		FioReadByte();

    99

		n--;

   100

	}

   101

}

   102

   103

uint16 FioReadWord()

   104

{

   105

	byte b = FioReadByte();

   106

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

   107

}

   108

   109

uint32 FioReadDword()

   110

{

   111

	uint b = FioReadWord();

   112

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

   113

}

   114

   115

void FioReadBlock(void *ptr, uint size)

   116

{

   117

	FioSeekTo(FioGetPos(), SEEK_SET);

   118

	_fio.pos += size;

   119

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

   120

}

   121

   122

static inline void FioCloseFile(int slot)

   123

{

   124

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

   125

		fclose(_fio.handles[slot]);

   126

		_fio.handles[slot] = NULL;

   127

#if defined(LIMITED_FDS)

   128

		_fio.open_handles--;

   129

#endif /* LIMITED_FDS */

   130

	}

   131

}

   132

   133

void FioCloseAll()

   134

{

   135

	int i;

   136

   137

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

   138

		FioCloseFile(i);

   139

}

   140

   141

#if defined(LIMITED_FDS)

   142

static void FioFreeHandle()

   143

{

   144

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

   145

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

   146

		uint i, count;

   147

		int slot;

   148

   149

		count = UINT_MAX;

   150

		slot = -1;

   151

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

   152

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

   153

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

   154

				count = _fio.usage_count[i];

   155

				slot  = i;

   156

			}

   157

		}

   158

		assert(slot != -1);

   159

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

   160

		FioCloseFile(slot);

   161

	}

   162

}

   163

#endif /* LIMITED_FDS */

   164

   165

void FioOpenFile(int slot, const char *filename)

   166

{

   167

	FILE *f;

   168

   169

#if defined(LIMITED_FDS)

   170

	FioFreeHandle();

   171

#endif /* LIMITED_FDS */

   172

	f = FioFOpenFile(filename);

   173

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

   174

   175

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

   176

	_fio.handles[slot] = f;

   177

#if defined(LIMITED_FDS)

   178

	_fio.filename[slot] = filename;

   179

	_fio.usage_count[slot] = 0;

   180

	_fio.open_handles++;

   181

#endif /* LIMITED_FDS */

   182

	FioSeekToFile(slot << 24);

   183

}

   184

   185

/**

   186

 * Check whether the given file exists

   187

 * @param filename the file to try for existance

   188

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

   189

 */

   190

bool FioCheckFileExists(const char *filename)

   191

{

   192

	FILE *f = FioFOpenFile(filename);

   193

	if (f == NULL) return false;

   194

   195

	fclose(f);

   196

	return true;

   197

}

   198

   199

/**

   200

 * Opens the file with the given name

   201

 * @param filename the file to open (in either data_dir or second_data_dir)

   202

 * @return the opened file or NULL when it failed.

   203

 */

   204

FILE *FioFOpenFile(const char *filename)

   205

{

   206

	FILE *f;

   207

	char buf[MAX_PATH];

   208

   209

	if (strrchr(filename, PATHSEPCHAR) == NULL) {

   210

		snprintf(buf, lengthof(buf), "%s%s", _paths.data_dir, filename);

   211

	} else {

   212

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

   213

	}

   214

   215

	f = fopen(buf, "rb");

   216

#if !defined(WIN32)

   217

	if (f == NULL) {

   218

		strtolower(strrchr(buf, PATHSEPCHAR));

   219

		f = fopen(buf, "rb");

   220

   221

#if defined SECOND_DATA_DIR

   222

		/* tries in the 2nd data directory */

   223

		if (f == NULL) {

   224

			snprintf(buf, lengthof(buf), "%s%s", _paths.second_data_dir, filename);

   225

			strtolower(buf + strlen(_paths.second_data_dir) - 1);

   226

			f = fopen(buf, "rb");

   227

		}

   228

#endif

   229

	}

   230

#endif

   231

   232

	return f;

   233

}

   234

   235

/**

   236

 * Create a directory with the given name

   237

 * @param name the new name of the directory

   238

 */

   239

void FioCreateDirectory(const char *name)

   240

{

   241

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

   242

	CreateDirectory(OTTD2FS(name), NULL);

   243

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

   244

	mkdir(OTTD2FS(name));

   245

#else

   246

	mkdir(OTTD2FS(name), 0755);

   247

#endif

   248

}

   249

   250

/**

   251

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

   252

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

   253

 * @param buf    string to append the separator to

   254

 * @param buflen the length of the buf

   255

 */

   256

void AppendPathSeparator(char *buf, size_t buflen)

   257

{

   258

	size_t s = strlen(buf);

   259

   260

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

   261

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

   262

		buf[s]     = PATHSEPCHAR;

   263

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

   264

	}

   265

}

   266

   267

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

   268

/**

   269

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

   270

 * @param exe the path to the executable

   271

 */

   272

extern void DetermineBasePaths(const char *exe);

   273

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

   274

   275

/**

   276

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

   277

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

   278

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

   279

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

   280

 * @param exe the path to the executable

   281

 */

   282

void ChangeWorkingDirectory(const char *exe)

   283

{

   284

#ifdef WITH_COCOA

   285

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

   286

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

   287

   288

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

   289

#endif /* WITH_COCOA */

   290

	char *s = strrchr(exe, PATHSEPCHAR);

   291

	if (s != NULL) {

   292

		*s = '\0';

   293

		chdir(exe);

   294

		*s = PATHSEPCHAR;

   295

	}

   296

#ifdef WITH_COCOA

   297

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

   298

#endif /* WITH_COCOA */

   299

}

   300

   301

/**

   302

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

   303

 * @param exe the path to the executable

   304

 */

   305

void DetermineBasePaths(const char *exe)

   306

{

   307

	/* Change the working directory to enable doubleclicking in UIs */

   308

	ChangeWorkingDirectory(exe);

   309

   310

	_paths.game_data_dir = MallocT<char>(MAX_PATH);

   311

	ttd_strlcpy(_paths.game_data_dir, GAME_DATA_DIR, MAX_PATH);

   312

#if defined(SECOND_DATA_DIR)

   313

	_paths.second_data_dir = MallocT<char>(MAX_PATH);

   314

	ttd_strlcpy(_paths.second_data_dir, SECOND_DATA_DIR, MAX_PATH);

   315

#else

   316

	_paths.second_data_dir = NULL;

   317

#endif

   318

   319

#if defined(USE_HOMEDIR)

   320

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

   321

   322

	if (homedir == NULL) {

   323

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

   324

		if (pw != NULL) homedir = pw->pw_dir;

   325

	}

   326

   327

	_paths.personal_dir = str_fmt("%s" PATHSEP "%s", homedir, PERSONAL_DIR);

   328

#else /* not defined(USE_HOMEDIR) */

   329

	_paths.personal_dir = MallocT<char>(MAX_PATH);

   330

	ttd_strlcpy(_paths.personal_dir, PERSONAL_DIR, MAX_PATH);

   331

   332

	/* check if absolute or relative path */

   333

	const char *s = strchr(_paths.personal_dir, PATHSEPCHAR);

   334

   335

	/* add absolute path */

   336

	if (s == NULL || _paths.personal_dir != s) {

   337

		getcwd(_paths.personal_dir, MAX_PATH);

   338

		AppendPathSeparator(_paths.personal_dir, MAX_PATH);

   339

		ttd_strlcat(_paths.personal_dir, PERSONAL_DIR, MAX_PATH);

   340

	}

   341

#endif /* defined(USE_HOMEDIR) */

   342

   343

	AppendPathSeparator(_paths.personal_dir,  MAX_PATH);

   344

	AppendPathSeparator(_paths.game_data_dir, MAX_PATH);

   345

}

   346

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

   347

   348

/**

   349

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

   350

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

   351

 * make the save and scenario directories.

   352

 * @param exe the path to the executable

   353

 * @todo for save_dir, autosave_dir, scenario_dir and heightmap_dir the

   354

 *       assumption is that there is no path separator, however for gm_dir

   355

 *       lang_dir and data_dir that assumption is made.

   356

 *       This inconsistency should be resolved.

   357

 */

   358

void DeterminePaths(const char *exe)

   359

{

   360

	DetermineBasePaths(exe);

   361

   362

	_paths.save_dir      = str_fmt("%ssave", _paths.personal_dir);

   363

	_paths.autosave_dir  = str_fmt("%s" PATHSEP "autosave", _paths.save_dir);

   364

	_paths.scenario_dir  = str_fmt("%sscenario", _paths.personal_dir);

   365

	_paths.heightmap_dir = str_fmt("%s" PATHSEP "heightmap", _paths.scenario_dir);

   366

	_paths.gm_dir        = str_fmt("%sgm" PATHSEP, _paths.game_data_dir);

   367

	_paths.data_dir      = str_fmt("%sdata" PATHSEP, _paths.game_data_dir);

   368

#if defined(CUSTOM_LANG_DIR)

   369

	/* Sets the search path for lng files to the custom one */

   370

	_paths.lang_dir = MallocT<char>(MAX_PATH);

   371

	ttd_strlcpy(_paths.lang_dir, CUSTOM_LANG_DIR, MAX_PATH);

   372

	AppendPathSeparator(_paths.lang_dir, MAX_PATH);

   373

#else

   374

	_paths.lang_dir = str_fmt("%slang" PATHSEP, _paths.game_data_dir);

   375

#endif

   376

   377

	if (_config_file == NULL) {

   378

		_config_file = str_fmt("%sopenttd.cfg", _paths.personal_dir);

   379

	}

   380

   381

	_highscore_file = str_fmt("%shs.dat", _paths.personal_dir);

   382

	_log_file = str_fmt("%sopenttd.log",  _paths.personal_dir);

   383

   384

	/* Make (auto)save and scenario folder */

   385

	FioCreateDirectory(_paths.save_dir);

   386

	FioCreateDirectory(_paths.autosave_dir);

   387

	FioCreateDirectory(_paths.scenario_dir);

   388

	FioCreateDirectory(_paths.heightmap_dir);

   389

}