diff --git dataobj/height_map_loader.cc dataobj/height_map_loader.cc
index 526b27a3a..6ccd2ea56 100644
--- dataobj/height_map_loader.cc
+++ dataobj/height_map_loader.cc
@@ -1,4 +1,7 @@
-/* code for loading heightmaps */
+/*
+ * This file is part of the Simutrans project under the artistic licence.
+ * (see licence.txt)
+ */
 
 #include <stdio.h>
 #include <string.h>
@@ -10,234 +13,343 @@
 #include "../simsys.h"
 
 
-height_map_loader_t::height_map_loader_t(bool new_format):
-		height_map_conversion_version_new(new_format)
-	{
+height_map_loader_t::height_map_loader_t(bool new_format) :
+	height_map_conversion_version_new(new_format)
+{
 }
 
 
 // read height data from bmp or ppm files
 bool height_map_loader_t::get_height_data_from_file( const char *filename, sint8 groundwater, sint8 *&hfield, sint16 &ww, sint16 &hh, bool update_only_values )
 {
-	if (FILE* const file = dr_fopen(filename, "rb")) {
-		char id[3];
-		// parsing the header of this mixed file format is nottrivial ...
-		id[0] = fgetc(file);
-		id[1] = fgetc(file);
-		id[2] = 0;
-		if(strcmp(id, "P6")) {
-			if(strcmp(id, "BM")) {
-				fclose(file);
-				dbg->error("height_map_loader_t::load_heightfield()","Heightfield has wrong image type %s instead P6/BM", id);
-				return false;
+	hfield = NULL;
+
+	FILE *const file = dr_fopen(filename, "rb");
+	if(  !file  ) {
+		dbg->error("height_map_loader_t::get_height_data_from_file()", "Cannot open heightmap file");
+		return false;
+	}
+
+	char id[3] = {0, 0, 0};
+	// parsing the header of this mixed file format is non-trivial ...
+	if(  std::fgets(id, 3, file) == NULL  ) {
+		std::fclose(file);
+		dbg->error("height_map_loader_t::get_height_data_from_file()", "Cannot read magic number");
+		return false;
+	}
+
+	const bool is_bmp = std::strcmp(id, "BM") == 0;
+	const bool is_ppm = std::strcmp(id, "P6") == 0;
+
+	if(  !is_bmp  &&  !is_ppm  ) {
+		std::fclose(file);
+		dbg->error("height_map_loader_t::get_height_data_from_file()", "Unsupported height map format (must be bmp or ppm)");
+		return false;
+	}
+
+	const char *err = NULL;
+	if(  is_bmp  ) {
+		err = read_bmp(file, groundwater, hfield, ww, hh, update_only_values);
+	}
+	else {
+		err = read_ppm(file, groundwater, hfield, ww, hh, update_only_values);
+	}
+
+	// success ... (or not)
+	std::fclose(file);
+
+	if(  err  ) {
+		dbg->error("height_map_loader_t::get_height_data_from_file()",
+				   "Error while reading %s file: %s", is_bmp ? "bmp" : "ppm", err);
+
+		if(  hfield  ) {
+			delete[] hfield;
+			hfield = NULL;
+		}
+	}
+
+	return err == NULL;
+}
+
+
+const char *height_map_loader_t::read_bmp( FILE *file, sint8 groundwater, sint8 *&hfield, sint16 &ww, sint16 &hh, bool update_only_values )
+{
+	uint32 l;
+	uint16 s;
+
+	if(  std::fseek( file, 10, SEEK_SET ) != 0  ||  std::fread(&l, sizeof(uint32), 1, file) != 1  ) {
+		return "Malformed bmp file";
+	}
+	const uint32 data_offset = endian(l);
+
+	if(  std::fseek( file, 18, SEEK_SET ) != 0  ||  std::fread(&l, sizeof(sint32), 1, file) != 1  ) {
+		return "Malformed bmp file";
+	}
+	sint32 w = endian(l);
+
+	if(  std::fseek( file, 22, SEEK_SET ) != 0  ||  std::fread(&l, sizeof(sint32), 1, file) != 1  ) {
+		return "Malformed bmp file";
+	}
+	sint32 h = endian(l);
+
+	if(  std::fseek( file, 28, SEEK_SET ) != 0  ||  std::fread(&s, sizeof(sint16), 1, file) != 1  ) {
+		return "Malformed bmp file";
+	}
+	const sint16 bit_depth = endian(s);
+
+	if(  std::fseek( file, 30, SEEK_SET ) != 0  ||  std::fread(&l, sizeof(sint32), 1, file) != 1  ) {
+		return "Malformed bmp file";
+	}
+	const sint32 format = endian(l);
+
+	if(  std::fseek( file, 46, SEEK_SET ) != 0  ||  std::fread(&l, sizeof(sint32), 1, file) != 1  ) {
+		return "Malformed bmp file";
+	}
+	sint32 table = endian(l);
+
+	if(  (bit_depth!=8  &&  bit_depth!=24)  ||  format>1  ) {
+		return "Can only use 8 bit (RLE or normal) or 24 bit bitmaps!";
+	}
+
+	// skip parsing body
+	if(  update_only_values  ) {
+		ww = w;
+		hh = std::abs(h);
+		return NULL;
+	}
+
+	// now read the data and convert them on the fly
+	try {
+		hfield = new sint8[w*h];
+	}
+	catch (const std::bad_alloc &) {
+		hfield = NULL;
+		return "Not enough memory";
+	}
+
+	std::memset( hfield, groundwater, w*h );
+
+	if(  bit_depth==8  ) {
+		// convert color tables to height levels
+		if(  table==0  ) {
+			table = 256;
+		}
+
+		sint8 h_table[256];
+		if(  std::fseek( file, 54, SEEK_SET ) != 0  ) {
+			return "Malformed bmp file";
+		}
+
+		for( int i=0;  i<table;  i++  ) {
+			const int B = std::fgetc(file);
+			const int G = std::fgetc(file);
+			const int R = std::fgetc(file);
+			const int A = std::fgetc(file); // dummy
+			if(  B==EOF  || G==EOF  || R==EOF  || A==EOF  ) {
+				return "Malformed bmp file";
 			}
-			// bitmap format
-			fseek( file, 10, SEEK_SET );
-			uint32 data_offset;
-			sint32 w, h, format, table;
-			sint16 bit_depth;
-#ifdef SIM_BIG_ENDIAN
-			uint32 l;
-			uint16 s;
-			fread( &l, 4, 1, file );
-			data_offset = endian(l);
-			fseek( file, 18, SEEK_SET );
-			fread( &l, 4, 1, file );
-			w = endian(l);
-			fread( &l, 4, 1, file );
-			h = endian(l);
-			fseek( file, 28, SEEK_SET );
-			fread( &s, 2, 1, file );
-			bit_depth = endian(s);
-			fread( &l, 4, 1, file );
-			format = endian(l);
-			fseek( file, 46, SEEK_SET );
-			fread( &l, 4, 1, file );
-			table = endian(l);
-#else
-			fread( &data_offset, 4, 1, file );
-			fseek( file, 18, SEEK_SET );
-			fread( &w, 4, 1, file );
-			fread( &h, 4, 1, file );
-			fseek( file, 28, SEEK_SET );
-			fread( &bit_depth, 2, 1, file );
-			fread( &format, 4, 1, file );
-			fseek( file, 46, SEEK_SET );
-			fread( &table, 4, 1, file );
-#endif
-			if((bit_depth!=8  &&  bit_depth!=24)  ||  format>1) {
-				if(!update_only_values) {
-					dbg->fatal("height_map_loader_t::get_height_data_from_file()","Can only use 8Bit (RLE or normal) or 24 bit bitmaps!");
+
+			h_table[i] = height_map_loader_t::rgb_to_height(R, G, B);
+		}
+
+		// now read the data
+		if(  std::fseek( file, data_offset, SEEK_SET ) != 0  ) {
+			return "Malformed bmp file";
+		}
+
+		if(  format==0  ) {
+			// uncompressed (usually mirrored, if h<0)
+			const bool mirror = (h<0);
+			h = std::abs(h);
+			for(  sint32 y=0;  y<h;  y++  ) {
+				const sint32 offset = mirror ? y*w : (h-y-1)*w;
+				for(  sint32 x=0;  x<w;  x++  ) {
+					const int res = std::fgetc(file);
+					if(  res==EOF  ) {
+						return "Malformed bmp file";
+					}
+					hfield[x+offset] = h_table[res];
 				}
-				fclose( file );
-				return false;
-			}
 
-			// skip parsing body
-			if(update_only_values) {
-				ww = w;
-				hh = abs(h);
-				return true;
+				// skip line offset
+				if(  w&1  ) {
+					if(  std::fgetc(file) == EOF  ) {
+						return "Malformed bmp file";
+					}
+				}
 			}
+		}
+		else {
+			// compressed RLE (reverse y, since mirrored)
+			sint32 x=0, y=h-1;
+			while(  !std::feof(file)  ) {
+				int res = std::fgetc(file);
+				if(  res == EOF  ) {
+					return "Malformed bmp file";
+				}
+				uint8 Count = res;
 
-			// now read the data and convert them on the fly
-			hfield = new sint8[w*h];
-			memset( hfield, groundwater, w*h );
-			if(bit_depth==8) {
-				// convert color tables to height levels
-				if(table==0) {
-					table = 256;
+				res = std::fgetc(file);
+				if(  res == EOF  ) {
+					return "Malformed bmp file";
 				}
-				sint8 h_table[256];
-				fseek( file, 54, SEEK_SET );
-				for( int i=0;  i<table;  i++  ) {
-					int B = fgetc(file);
-					int G = fgetc(file);
-					int R = fgetc(file);
-					fgetc(file);	// dummy
-					h_table[i] = height_map_loader_t::rgb_to_height(R, G, B);
+				const uint8 ColorIndex = res;
+
+				if(  Count>0  ) {
+					for(  sint32 k=0;  k<Count;  k++, x++  ) {
+						hfield[x+(y*w)] = h_table[ColorIndex];
+					}
 				}
-				// now read the data
-				fseek( file, data_offset, SEEK_SET );
-				if(format==0) {
-					// uncompressed (usually mirrored, if h>0)
-					bool mirror = (h<0);
-					h = abs(h);
-					for(  sint32 y=0;  y<h;  y++  ) {
-						sint32 offset = mirror ? y*w : (h-y-1)*w;
-						for(  sint32 x=0;  x<w;  x++  ) {
-							hfield[x+offset] = h_table[fgetc(file)];
-						}
-						// skip line offset
-						if(w&1) {
-							fgetc(file);
+				else if(  Count==0  ) {
+					sint32 Flag = ColorIndex;
+					if(  Flag==0  ) {
+						// goto next line
+						x = 0;
+						y--;
+					}
+					else if(  Flag==1  ) {
+						// end of bitmap
+						break;
+					}
+					else if(  Flag==2  ) {
+						// skip with cursor
+						const int xx = std::fgetc(file);
+						const int yy = std::fgetc(file);
+
+						if(  xx==EOF  || yy==EOF  ) {
+							return "Malformed bmp file";
 						}
+
+						x += (uint8)xx;
+						y -= (uint8)yy;
 					}
-				}
-				else {
-					// compressed RLE (reverse y, since mirrored)
-					sint32 x=0, y=h-1;
-					while (!feof(file)) {
-						uint8 Count= fgetc(file);
-						uint8 ColorIndex = fgetc(file);
-
-						if (Count > 0) {
-							for( sint32 k = 0;  k < Count;  k++, x++  ) {
-								hfield[x+(y*w)] = h_table[ColorIndex];
-							}
-						} else if (Count == 0) {
-							sint32 Flag = ColorIndex;
-							if (Flag == 0) {
-								// goto next line
-								x = 0;
-								y--;
-							}
-							else if (Flag == 1) {
-								// end of bitmap
-								break;
-							}
-							else if (Flag == 2) {
-								// skip with cursor
-								x += (uint8)fgetc(file);
-								y -= (uint8)fgetc(file);
-							}
-							else {
-								// uncompressed run
-								Count = Flag;
-								for( sint32 k = 0;  k < Count;  k++, x++  ) {
-									hfield[x+y*w] = h_table[(uint8)fgetc(file)];
-								}
-								if (ftell(file) & 1) {	// alway even offset in file
-									fseek(file, 1, SEEK_CUR);
-								}
+					else {
+						// uncompressed run
+						Count = Flag;
+						for(  sint32 k=0;  k<Count;  k++, x++  ) {
+							const int idx = std::fgetc(file);
+							if(  idx==EOF  ) {
+								return "Malformed bmp file";
 							}
+
+							hfield[x+y*w] = h_table[(uint8)idx];
+						}
+
+						// always even offset in file
+						const long int pos = std::ftell(file);
+						if(  pos==-1L  ||  (pos&1  &&  std::fseek(file, 1, SEEK_CUR)!=0)  ) {
+							return "Malformed bmp file";
 						}
 					}
 				}
 			}
-			else {
-				// uncompressed 24 bits
-				bool mirror = (h<0);
-				h = abs(h);
-				for(  sint32 y=0;  y<h;  y++  ) {
-					sint32 offset = mirror ? y*w : (h-y-1)*w;
-					for(  sint32 x=0;  x<w;  x++  ) {
-						int B = fgetc(file);
-						int G = fgetc(file);
-						int R = fgetc(file);
-						hfield[x+offset] = height_map_loader_t::rgb_to_height(R, G, B);
-					}
-					fseek( file, (4-((w*3)&3))&3, SEEK_CUR );	// skip superfluos bytes at the end of each scanline
-				}
-			}
-			// success ...
-			fclose(file);
-			ww = w;
-			hh = h;
-			return true;
 		}
-		else {
-			// ppm format
-			char buf[255];
-			char *c = id+2;
-			sint32 param[3]={0,0,0};
-			for(int index=0;  index<3;  ) {
-				// the format is "P6[whitespace]width[whitespace]height[[whitespace bitdepth]]newline]
-				// however, Photoshop is the first program, that uses space for the first whitespace ...
-				// so we cater for Photoshop too
-				while(*c  &&  *c<=32) {
-					c++;
-				}
-				// usually, after P6 there comes a comment with the maker
-				// but comments can be anywhere
-				if(*c==0) {
-					read_line(buf, sizeof(buf), file);
-					c = buf;
-					continue;
-				}
-				param[index++] = atoi(c);
-				while(*c>='0'  &&  *c<='9') {
-					c++;
+	}
+	else {
+		// uncompressed 24 bits
+		const bool mirror = (h<0);
+		h = std::abs(h);
+
+		for(  sint32 y=0;  y<h;  y++  ) {
+			const sint32 offset = mirror ? y*w : (h-y-1)*w;
+			for(  sint32 x=0;  x<w;  x++  ) {
+				const int B = std::fgetc(file);
+				const int G = std::fgetc(file);
+				const int R = std::fgetc(file);
+
+				if(  B==EOF  ||  G==EOF  ||  R==EOF  ) {
+					return "Malformed bmp file";
 				}
+
+				hfield[x+offset] = height_map_loader_t::rgb_to_height(R, G, B);
 			}
-			// now the data
-			sint32 w = param[0];
-			sint32 h = param[1];
-			if(param[2]!=255) {
-				fclose(file);
-				if(!update_only_values) {
-					dbg->fatal("height_map_loader_t::load_heightfield()","Heightfield has wrong color depth %d", param[2] );
-				}
-				return false;
+
+			// skip superfluous bytes at the end of each scanline
+			if(  std::fseek( file, (4-((w*3)&3))&3, SEEK_CUR ) != 0  ) {
+				return "Malformed bmp file";
 			}
+		}
+	}
+
+	ww = w;
+	hh = h;
+	return NULL;
+}
+
 
-			// report only values
-			if(update_only_values) {
-				fclose(file);
-				ww = w;
-				hh = h;
-				return true;
+const char *height_map_loader_t::read_ppm( FILE *file, sint8 groundwater, sint8 *&hfield, sint16 &ww, sint16 &hh, bool update_only_values )
+{
+	// ppm format
+	char buf[255];
+	const char *c = "";
+	sint32 param[3] = {0, 0, 0};
+
+	for(  int index=0;  index<3;  ) {
+		// the format is "P6[whitespace]width[whitespace]height[[whitespace bitdepth]]newline]
+		// however, Photoshop is the first program, that uses space for the first whitespace ...
+		// so we cater for Photoshop too
+		while(  *c!=0  &&  *c<=32  ) {
+			c++;
+		}
+
+		// usually, after P6 there comes a comment with the maker
+		// but comments can be anywhere
+		if(  *c==0  ) {
+			if(  read_line(buf, sizeof(buf), file) == NULL  ) {
+				return "Malformed ppm file";
 			}
 
-			// ok, now read them in
-			hfield = new sint8[w*h];
-			memset( hfield, groundwater, w*h );
+			c = buf;
+			continue;
+		}
 
-			for(sint16 y=0; y<h; y++) {
-				for(sint16 x=0; x<w; x++) {
-					int R = fgetc(file);
-					int G = fgetc(file);
-					int B = fgetc(file);
-					hfield[x+(y*w)] = height_map_loader_t::rgb_to_height(R, G, B);
-				}
+		param[index++] = std::atoi(c);
+		while(  *c>='0'  &&  *c<='9'  ) {
+			c++;
+		}
+	}
+
+	// now the data
+	const sint32 w = param[0];
+	const sint32 h = param[1];
+
+	if(  param[2]!=255  ) {
+		return "Heightfield has wrong color depth (must be 255)";
+	}
+
+	// report only values
+	if(  update_only_values  ) {
+		ww = w;
+		hh = h;
+		return NULL;
+	}
+
+	// ok, now read them in
+	try {
+		hfield = new sint8[w*h];
+	}
+	catch (const std::bad_alloc &) {
+		hfield = NULL;
+		return "Not enough memory";
+	}
+
+	std::memset( hfield, groundwater, w*h );
+
+	for(  sint16 y=0;  y<h;  y++  ) {
+		for(  sint16 x=0;  x<w;  x++  ) {
+			const int R = std::fgetc(file);
+			const int G = std::fgetc(file);
+			const int B = std::fgetc(file);
+
+			if(  R==EOF  ||  G==EOF  || B==EOF  ) {
+				return "Malformed ppm file";
 			}
 
-			// success ...
-			fclose(file);
-			ww = w;
-			hh = h;
-			return true;
+			hfield[x+(y*w)] = height_map_loader_t::rgb_to_height(R, G, B);
 		}
 	}
-	return false;
+
+	ww = w;
+	hh = h;
+	return NULL;
 }
diff --git dataobj/height_map_loader.h dataobj/height_map_loader.h
index aec88aa3f..a87fa692d 100644
--- dataobj/height_map_loader.h
+++ dataobj/height_map_loader.h
@@ -1,4 +1,7 @@
-/* code for loading heightmaps */
+/*
+ * This file is part of the Simutrans project under the artistic licence.
+ * (see licence.txt)
+ */
 
 #ifndef load_height_file_h
 #define load_height_file_h
@@ -6,41 +9,56 @@
 #include "../simtypes.h"
 #include "environment.h"
 
-class height_map_loader_t {
+
+/**
+ * Loads height data from BMP or PPM files.
+ */
+class height_map_loader_t
+{
 public:
 	height_map_loader_t(bool height_map_conversion_version);
 
 	/**
-	 * Reads height data from 8 or 25 bit bmp or ppm files.
-	 * @return Either pointer to heightfield (use delete [] for it) or NULL.
+	 * Reads height data from 8 or 24 bit bmp or ppm files.
+	 *
+	 * @param filename the file to load the height data from.
+	 * @param[out] hfield 2d array of height values.
+	 * @param[out] ww,hh width and height of @p hfield. On failure, these values are undefined.
+	 * @param update_only_values When true, do not allocate the height field; instead, only update @p ww and @p hh
+	 *
+	 * @return true on success, false on failure. On success, @p hfield contains
+	 * the height field data (must be delete[]'d by the caller unless @p update_only_values is set).
+	 * On failure, @p hfield is set to NULL (Does not need to be delete[]'d)
 	 */
 	bool get_height_data_from_file( const char *filename, sint8 groundwater, sint8 *&hfield, sint16 &ww, sint16 &hh, bool update_only_values );
 
 private:
 	inline sint8 rgb_to_height( const int r, const int g, const int b ) {
 		const sint16 h0 = (r*2+g*3+b);
-		if(  !height_map_conversion_version_new  ) {
-			// old style
+		if(  height_map_conversion_version_new  ) {
+			// new style, heights more spread out
 			if(  env_t::pak_height_conversion_factor == 2  ) {
-				// was: return (((r*2+g*3+b)/4 - 224) & 0xFFF8)/8;
-				return h0/32 - 28;
+				return h0/24 - 34; // -34..8
 			}
 			else {
-				// was: return (( ((r*2+g*3+b)/4 - 224)) & 0xFFF0)/16;
-				return h0/64 - 14;
+				return h0/48 - 18; // -18..13
 			}
 		}
 		else {
-			// new style, heights more spread out
+			// old style
 			if(  env_t::pak_height_conversion_factor == 2  ) {
-				return h0/24 - 34;
+				return h0/32 - 28; // -28..19
 			}
 			else {
-				return h0/48 - 18;
+				return h0/64 - 14; // -14..9
 			}
 		}
 	}
 
+	const char *read_bmp(FILE *file, sint8 groundwater, sint8 *&hfield, sint16 &ww, sint16 &hh, bool update_only_values);
+	const char *read_ppm(FILE *file, sint8 groundwater, sint8 *&hfield, sint16 &ww, sint16 &hh, bool update_only_values);
+
+private:
 	const bool height_map_conversion_version_new;
 };
 
diff --git gui/load_relief_frame.cc gui/load_relief_frame.cc
index a2d688e4b..b131156f6 100644
--- gui/load_relief_frame.cc
+++ gui/load_relief_frame.cc
@@ -52,7 +52,7 @@ const char *load_relief_frame_t::get_info(const char *fullpath)
 	static char size[64];
 
 	sint16 w, h;
-	sint8 *h_field ;
+	sint8 *h_field = NULL;
 	height_map_loader_t hml(new_format.pressed);
 
 	if(hml.get_height_data_from_file(fullpath, (sint8)sets->get_groundwater(), h_field, w, h, true )) {
@@ -67,12 +67,12 @@ const char *load_relief_frame_t::get_info(const char *fullpath)
 bool load_relief_frame_t::check_file( const char *fullpath, const char * )
 {
 	sint16 w, h;
-	sint8 *h_field;
+	sint8 *h_field = NULL;
 
 	height_map_loader_t hml(new_format.pressed);
 	if(hml.get_height_data_from_file(fullpath, (sint8)sets->get_groundwater(), h_field, w, h, true )) {
-		return w>0  &&  h>0;
 		env_t::new_height_map_conversion = new_format.pressed;
+		return w>0  &&  h>0;
 	}
 	return false;
 }
diff --git gui/welt.cc gui/welt.cc
index 777fc3c24..bc922505e 100644
--- gui/welt.cc
+++ gui/welt.cc
@@ -287,7 +287,7 @@ bool welt_gui_t::update_from_heightfield(const char *filename)
 
 	sint16 w, h;
 	sint8 *h_field=NULL;
-	height_map_loader_t hml(sets);
+	height_map_loader_t hml(sets != NULL);
 	if(hml.get_height_data_from_file(filename, (sint8)sets->get_groundwater(), h_field, w, h, false )) {
 		sets->set_size_x(w);
 		sets->set_size_y(h);
@@ -306,6 +306,7 @@ bool welt_gui_t::update_from_heightfield(const char *filename)
 			}
 		}
 		map_preview.set_map_data(&map);
+		delete[] h_field;
 		return true;
 	}
 	return false;
diff --git simworld.cc simworld.cc
index 7885ad108..0d487ee97 100644
--- simworld.cc
+++ simworld.cc
@@ -6062,8 +6062,8 @@ uint8 karte_t::sp2num(player_t *player)
 void karte_t::load_heightfield(settings_t* const sets)
 {
 	sint16 w, h;
-	sint8 *h_field;
-	height_map_loader_t hml(sets);
+	sint8 *h_field = NULL;
+	height_map_loader_t hml(sets != NULL);
 	if(hml.get_height_data_from_file(sets->heightfield.c_str(), (sint8)(sets->get_groundwater()), h_field, w, h, false )) {
 		sets->set_size(w,h);
 		// create map