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 <sys/stat.h>

    16

#endif

    17

    18

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

    19

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

    20

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

    21

    22

#define FIO_BUFFER_SIZE 512

    23

#define MAX_HANDLES 64

    24

    25

struct Fio {

    26

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

    27

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

    28

	FILE *cur_fh;                       ///< current file handle

    29

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

    30

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

    31

#if defined(LIMITED_FDS)

    32

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

    33

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

    34

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

    35

#endif /* LIMITED_FDS */

    36

};

    37

    38

static Fio _fio;

    39

    40

/* Get current position in file */

    41

uint32 FioGetPos()

    42

{

    43

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

    44

}

    45

    46

void FioSeekTo(uint32 pos, int mode)

    47

{

    48

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

    49

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

    50

	_fio.pos = pos;

    51

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

    52

}

    53

    54

#if defined(LIMITED_FDS)

    55

static void FioRestoreFile(int slot)

    56

{

    57

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

    58

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

    59

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

    60

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

    61

	}

    62

	_fio.usage_count[slot]++;

    63

}

    64

#endif /* LIMITED_FDS */

    65

    66

/* Seek to a file and a position */

    67

void FioSeekToFile(uint32 pos)

    68

{

    69

	FILE *f;

    70

#if defined(LIMITED_FDS)

    71

	/* Make sure we have this file open */

    72

	FioRestoreFile(pos >> 24);

    73

#endif /* LIMITED_FDS */

    74

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

    75

	assert(f != NULL);

    76

	_fio.cur_fh = f;

    77

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

    78

}

    79

    80

byte FioReadByte()

    81

{

    82

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

    83

		_fio.pos += FIO_BUFFER_SIZE;

    84

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

    85

	}

    86

	return *_fio.buffer++;

    87

}

    88

    89

void FioSkipBytes(int n)

    90

{

    91

	for (;;) {

    92

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

    93

		_fio.buffer += m;

    94

		n -= m;

    95

		if (n == 0) break;

    96

		FioReadByte();

    97

		n--;

    98

	}

    99

}

   100

   101

uint16 FioReadWord()

   102

{

   103

	byte b = FioReadByte();

   104

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

   105

}

   106

   107

uint32 FioReadDword()

   108

{

   109

	uint b = FioReadWord();

   110

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

   111

}

   112

   113

void FioReadBlock(void *ptr, uint size)

   114

{

   115

	FioSeekTo(FioGetPos(), SEEK_SET);

   116

	_fio.pos += size;

   117

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

   118

}

   119

   120

static inline void FioCloseFile(int slot)

   121

{

   122

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

   123

		fclose(_fio.handles[slot]);

   124

		_fio.handles[slot] = NULL;

   125

#if defined(LIMITED_FDS)

   126

		_fio.open_handles--;

   127

#endif /* LIMITED_FDS */

   128

	}

   129

}

   130

   131

void FioCloseAll()

   132

{

   133

	int i;

   134

   135

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

   136

		FioCloseFile(i);

   137

}

   138

   139

#if defined(LIMITED_FDS)

   140

static void FioFreeHandle()

   141

{

   142

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

   143

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

   144

		uint i, count;

   145

		int slot;

   146

   147

		count = UINT_MAX;

   148

		slot = -1;

   149

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

   150

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

   151

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

   152

				count = _fio.usage_count[i];

   153

				slot  = i;

   154

			}

   155

		}

   156

		assert(slot != -1);

   157

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

   158

		FioCloseFile(slot);

   159

	}

   160

}

   161

#endif /* LIMITED_FDS */

   162

   163

void FioOpenFile(int slot, const char *filename)

   164

{

   165

	FILE *f;

   166

   167

#if defined(LIMITED_FDS)

   168

	FioFreeHandle();

   169

#endif /* LIMITED_FDS */

   170

	f = FioFOpenFile(filename);

   171

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

   172

   173

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

   174

	_fio.handles[slot] = f;

   175

#if defined(LIMITED_FDS)

   176

	_fio.filename[slot] = filename;

   177

	_fio.usage_count[slot] = 0;

   178

	_fio.open_handles++;

   179

#endif /* LIMITED_FDS */

   180

	FioSeekToFile(slot << 24);

   181

}

   182

   183

/**

   184

 * Check whether the given file exists

   185

 * @param filename the file to try for existance

   186

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

   187

 */

   188

bool FioCheckFileExists(const char *filename)

   189

{

   190

	FILE *f = FioFOpenFile(filename);

   191

	if (f == NULL) return false;

   192

   193

	fclose(f);

   194

	return true;

   195

}

   196

   197

/**

   198

 * Opens the file with the given name

   199

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

   200

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

   201

 */

   202

FILE *FioFOpenFile(const char *filename)

   203

{

   204

	FILE *f;

   205

	char buf[MAX_PATH];

   206

   207

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

   208

   209

	f = fopen(buf, "rb");

   210

#if !defined(WIN32)

   211

	if (f == NULL) {

   212

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

   213

		f = fopen(buf, "rb");

   214

   215

#if defined SECOND_DATA_DIR

   216

		/* tries in the 2nd data directory */

   217

		if (f == NULL) {

   218

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

   219

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

   220

			f = fopen(buf, "rb");

   221

		}

   222

#endif

   223

	}

   224

#endif

   225

   226

	return f;

   227

}

   228

   229

/**

   230

 * Create a directory with the given name

   231

 * @param name the new name of the directory

   232

 */

   233

void FioCreateDirectory(const char *name)

   234

{

   235

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

   236

	CreateDirectory(OTTD2FS(name), NULL);

   237

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

   238

	mkdir(OTTD2FS(name));

   239

#else

   240

	mkdir(OTTD2FS(name), 0755);

   241

#endif

   242

}

   243

   244

/**

   245

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

   246

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

   247

 * @param buf    string to append the separator to

   248

 * @param buflen the length of the buf

   249

 */

   250

void AppendPathSeparator(char *buf, size_t buflen)

   251

{

   252

	size_t s = strlen(buf);

   253

   254

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

   255

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

   256

		buf[s]     = PATHSEPCHAR;

   257

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

   258

	}

   259

}

   260

   261

/**

   262

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

   263

 * @note defined in the OS related files (os2.cpp, win32.cpp, unix.cpp etc)

   264

 */

   265

extern void DetermineBasePaths();

   266

   267

/**

   268

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

   269

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

   270

 * make the save and scenario directories.

   271

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

   272

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

   273

 *       lang_dir and data_dir that assumption is made.

   274

 *       This inconsistency should be resolved.

   275

 */

   276

void DeterminePaths()

   277

{

   278

	DetermineBasePaths();

   279

   280

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

   281

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

   282

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

   283

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

   284

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

   285

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

   286

#if defined(CUSTOM_LANG_DIR)

   287

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

   288

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

   289

	ttd_strlcpy(_paths.lang_dir, CUSTOM_LANG_DIR, MAX_PATH);

   290

#else

   291

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

   292

#endif

   293

   294

	if (_config_file == NULL) {

   295

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

   296

	}

   297

   298

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

   299

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

   300

   301

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

   302

	FioCreateDirectory(_paths.save_dir);

   303

	FioCreateDirectory(_paths.autosave_dir);

   304

	FioCreateDirectory(_paths.scenario_dir);

   305

	FioCreateDirectory(_paths.heightmap_dir);

   306

}