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

    32

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

    33

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

    35

#if defined(LIMITED_FDS)

    36

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

    37

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

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

    68

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

    69

	}

    70

	_fio.usage_count[slot]++;

    71

}

    72

#endif /* LIMITED_FDS */

    73

    74

/* Seek to a file and a position */

    75

void FioSeekToFile(uint32 pos)

    76

{

    77

	FILE *f;

    78

#if defined(LIMITED_FDS)

    79

	/* Make sure we have this file open */

    80

	FioRestoreFile(pos >> 24);

    81

#endif /* LIMITED_FDS */

    82

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

    83

	assert(f != NULL);

    84

	_fio.cur_fh = f;

    86

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

   182

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

   183

	_fio.handles[slot] = f;

   185

#if defined(LIMITED_FDS)

   186

	_fio.usage_count[slot] = 0;

   187

	_fio.open_handles++;

   188

#endif /* LIMITED_FDS */

   189

	FioSeekToFile(slot << 24);

   190

}

   191

   192

/**

   193

 * Check whether the given file exists

   194

 * @param filename the file to try for existance

   195

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

   196

 */

   197

bool FioCheckFileExists(const char *filename)

   198

{

   199

	FILE *f = FioFOpenFile(filename);

   200

	if (f == NULL) return false;

   201

   202

	fclose(f);

   203

	return true;

   204

}

   205

   206

/**

   207

 * Opens the file with the given name

   208

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

   209

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

   210

 */

   211

FILE *FioFOpenFile(const char *filename)

   212

{

   213

	FILE *f;

   214

	char buf[MAX_PATH];

   215

   216

	if (filename[0] == PATHSEPCHAR || filename[1] == ':') {

   217

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

   218

	} else {

   219

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

   220

	}

   221

   222

	f = fopen(buf, "rb");

   223

#if !defined(WIN32)

   224

	if (f == NULL) {

   225

		strtolower(strrchr(buf, PATHSEPCHAR));

   226

		f = fopen(buf, "rb");

   227

   228

#if defined SECOND_DATA_DIR

   229

		/* tries in the 2nd data directory */

   230

		if (f == NULL) {

   231

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

   232

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

   233

			f = fopen(buf, "rb");

   234

		}

   235

#endif

   236

	}

   237

#endif

   238

   239

	return f;

   240

}

   241

   242

/**

   243

 * Create a directory with the given name

   244

 * @param name the new name of the directory

   245

 */

   246

void FioCreateDirectory(const char *name)

   247

{

   248

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

   249

	CreateDirectory(OTTD2FS(name), NULL);

   250

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

   251

	mkdir(OTTD2FS(name));

   252

#else

   253

	mkdir(OTTD2FS(name), 0755);

   254

#endif

   255

}

   256

   257

/**

   258

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

   259

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

   260

 * @param buf    string to append the separator to

   261

 * @param buflen the length of the buf

   262

 */

   263

void AppendPathSeparator(char *buf, size_t buflen)

   264

{

   265

	size_t s = strlen(buf);

   266

   267

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

   268

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

   269

		buf[s]     = PATHSEPCHAR;

   270

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

   271

	}

   272

}

   273

   274

/**

   275

 * Allocates and files a variable with the full path

   276

 * based on the given directory.

   277

 * @param dir the directory to base the path on

   278

 * @return the malloced full path

   279

 */

   280

char *BuildWithFullPath(const char *dir)

   281

{

   282

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

   283

	ttd_strlcpy(dest, dir, MAX_PATH);

   284

   285

	/* Check if absolute or relative path */

   286

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

   287

   288

	/* Add absolute path */

   289

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

   290

		getcwd(dest, MAX_PATH);

   291

		AppendPathSeparator(dest, MAX_PATH);

   292

		ttd_strlcat(dest, dir, MAX_PATH);

   293

	}

   294

	AppendPathSeparator(dest, MAX_PATH);

   295

   296

	return dest;

   297

}

   298

   299

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

   300

/**

   301

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

   302

 * @param exe the path to the executable

   303

 */

   304

extern void DetermineBasePaths(const char *exe);

   305

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

   306

   307

/**

   308

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

   309

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

   310

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

   311

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

   312

 * @param exe the path to the executable

   313

 */

   314

void ChangeWorkingDirectory(const char *exe)

   315

{

   316

#ifdef WITH_COCOA

   317

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

   318

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

   319

   320

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

   321

#endif /* WITH_COCOA */

   322

	char *s = strrchr(exe, PATHSEPCHAR);

   323

	if (s != NULL) {

   324

		*s = '\0';

   325

		chdir(exe);

   326

		*s = PATHSEPCHAR;

   327

	}

   328

#ifdef WITH_COCOA

   329

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

   330

#endif /* WITH_COCOA */

   331

}

   332

   333

/**

   334

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

   335

 * @param exe the path to the executable

   336

 */

   337

void DetermineBasePaths(const char *exe)

   338

{

   339

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

   340

	ChangeWorkingDirectory(exe);

   341

   342

	_paths.game_data_dir = BuildWithFullPath(GAME_DATA_DIR);

   343

#if defined(SECOND_DATA_DIR)

   344

	_paths.second_data_dir = BuildWithFullPath(SECOND_DATA_DIR);

   345

#else

   346

	_paths.second_data_dir = NULL;

   347

#endif

   348

   349

#if defined(USE_HOMEDIR)

   350

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

   351

   352

	if (homedir == NULL) {

   353

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

   354

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

   355

	}

   356

   357

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

   358

	AppendPathSeparator(_paths.personal_dir, MAX_PATH);

   359

#else /* not defined(USE_HOMEDIR) */

   360

	_paths.personal_dir = BuildWithFullPath(PERSONAL_DIR);

   361

#endif /* defined(USE_HOMEDIR) */

   362

}

   363

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

   364

   365

/**

   366

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

   367

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

   368

 * make the save and scenario directories.

   369

 * @param exe the path to the executable

   370

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

   371

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

   372

 *       lang_dir and data_dir that assumption is made.

   373

 *       This inconsistency should be resolved.

   374

 */

   375

void DeterminePaths(const char *exe)

   376

{

   377

	DetermineBasePaths(exe);

   378

   379

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

   380

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

   381

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

   382

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

   383

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

   384

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

   385

#if defined(CUSTOM_LANG_DIR)

   386

	_paths.lang_dir = BuildWithFullPath(CUSTOM_LANG_DIR);

   387

#else

   388

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

   389

#endif

   390

   391

	if (_config_file == NULL) {

   392

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

   393

	}

   394

   395

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

   396

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

   397

   398

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

   399

	FioCreateDirectory(_paths.save_dir);

   400

	FioCreateDirectory(_paths.autosave_dir);

   401

	FioCreateDirectory(_paths.scenario_dir);

   402

	FioCreateDirectory(_paths.heightmap_dir);

   403

}

   404

   405

/**

   406

 * Sanitizes a filename, i.e. removes all illegal characters from it.

   407

 * @param filename the "\0" terminated filename

   408

 */

   409

void SanitizeFilename(char *filename)

   410

{

   411

	for (; *filename != '\0'; filename++) {

   412

		switch (*filename) {

   413

			/* The following characters are not allowed in filenames

   414

			 * on at least one of the supported operating systems: */

   415

			case ':': case '\\': case '*': case '?': case '/':

   416

				*filename = '_';

   417

				break;

   418

		}

   419

	}

   420

}