Open-Harbor/osrm-backend
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 3 Wiki Activity

safeguard: do not read/write 0 bytes (iostream)

Browse Source
This commit is contained in:
Alexei Kasatkin 2014-06-05 23:14:36 +06:00
parent a32116d24c
commit b6787b0014
6 changed files with 61 additions and 18 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
DataStructures/StaticRTree.h
View File

@ -450,7 +450,10 @@ class StaticRTree
tree_node_file.read((char *)&tree_size, sizeof(uint32_t));
m_search_tree.resize(tree_size);
tree_node_file.read((char *)&m_search_tree[0], sizeof(TreeNode) * tree_size);
if (tree_size > 0)
{
tree_node_file.read((char *)&m_search_tree[0], sizeof(TreeNode) * tree_size);
}
tree_node_file.close();
// open leaf node file and store thread specific pointer
if (!boost::filesystem::exists(leaf_file))

10
Server/DataStructures/InternalDataFacade.h
View File

@ -172,16 +172,22 @@ template <class EdgeDataT> class InternalDataFacade : public BaseDataFacade<Edge
geometry_stream.read((char *)&number_of_indices, sizeof(unsigned));
m_geometry_indices.resize(number_of_indices);
geometry_stream.read((char *)&(m_geometry_indices[0]),
if (number_of_indices > 0)
{
geometry_stream.read((char *)&(m_geometry_indices[0]),
number_of_indices * sizeof(unsigned));
}
geometry_stream.read((char *)&number_of_compressed_geometries, sizeof(unsigned));
BOOST_ASSERT(m_geometry_indices.back() == number_of_compressed_geometries);
m_geometry_list.resize(number_of_compressed_geometries);
geometry_stream.read((char *)&(m_geometry_list[0]),
if (number_of_compressed_geometries > 0)
{
geometry_stream.read((char *)&(m_geometry_list[0]),
number_of_compressed_geometries * sizeof(unsigned));
}
geometry_stream.close();
}

7
Tools/components.cpp
View File

@ -79,8 +79,11 @@ int main(int argc, char *argv[])
restriction_ifstream.read((char *)&usable_restriction_count, sizeof(uint32_t));
restrictions_vector.resize(usable_restriction_count);
restriction_ifstream.read((char *)&(restrictions_vector[0]),
usable_restriction_count * sizeof(TurnRestriction));
if (usable_restriction_count>0)
{
restriction_ifstream.read((char *)&(restrictions_vector[0]),
usable_restriction_count * sizeof(TurnRestriction));
}
restriction_ifstream.close();
std::ifstream input_stream;

5
Util/GraphLoader.h
View File

@ -308,7 +308,10 @@ unsigned readHSGRFromStream(const boost::filesystem::path &hsgr_file,
hsgr_input_stream.read((char *)&(node_list[0]), number_of_nodes * sizeof(NodeT));
edge_list.resize(number_of_edges);
hsgr_input_stream.read((char *)&(edge_list[0]), number_of_edges * sizeof(EdgeT));
if (number_of_edges > 0)
{
hsgr_input_stream.read((char *)&(edge_list[0]), number_of_edges * sizeof(EdgeT));
}
hsgr_input_stream.close();
return number_of_nodes;

37
datastore.cpp
View File

@ -332,12 +332,17 @@ int main(const int argc, const char *argv[])
// Loading street names
unsigned *name_index_ptr =
(unsigned *)(shared_memory_ptr + shared_layout_ptr->GetNameIndexOffset());
name_stream.read((char *)name_index_ptr,
if (shared_layout_ptr->name_index_list_size > 0)
{
name_stream.read((char *)name_index_ptr,
shared_layout_ptr->name_index_list_size * sizeof(unsigned));
}
char *name_char_ptr = shared_memory_ptr + shared_layout_ptr->GetNameListOffset();
name_stream.read(name_char_ptr, shared_layout_ptr->name_char_list_size * sizeof(char));
if (shared_layout_ptr->name_char_list_size > 0)
{
name_stream.read(name_char_ptr, shared_layout_ptr->name_char_list_size * sizeof(char));
}
name_stream.close();
// load original edge information
@ -387,10 +392,12 @@ int main(const int argc, const char *argv[])
geometry_input_stream.seekg(0, geometry_input_stream.beg);
geometry_input_stream.read((char *)&temporary_value, sizeof(unsigned));
BOOST_ASSERT(temporary_value == shared_layout_ptr->geometries_index_list_size);
geometry_input_stream.read((char *)geometries_index_ptr,
if (shared_layout_ptr->geometries_index_list_size > 0)
{
geometry_input_stream.read((char *)geometries_index_ptr,
shared_layout_ptr->geometries_index_list_size *
sizeof(unsigned));
}
unsigned *geometries_list_ptr =
(unsigned *)(shared_memory_ptr + shared_layout_ptr->GetGeometryListOffset());
@ -398,8 +405,11 @@ int main(const int argc, const char *argv[])
geometry_input_stream.read((char *)&temporary_value, sizeof(unsigned));
BOOST_ASSERT(temporary_value == shared_layout_ptr->geometries_list_size);
geometry_input_stream.read((char *)geometries_list_ptr,
if (shared_layout_ptr->geometries_list_size > 0)
{
geometry_input_stream.read((char *)geometries_list_ptr,
shared_layout_ptr->geometries_list_size * sizeof(unsigned));
}
// Loading list of coordinates
FixedPointCoordinate *coordinates_ptr =
@ -423,24 +433,33 @@ int main(const int argc, const char *argv[])
char *rtree_ptr =
static_cast<char *>(shared_memory_ptr + shared_layout_ptr->GetRSearchTreeOffset());
tree_node_file.read(rtree_ptr, sizeof(RTreeNode) * tree_size);
if (tree_size > 0)
{
tree_node_file.read(rtree_ptr, sizeof(RTreeNode) * tree_size);
}
tree_node_file.close();
// load the nodes of the search graph
QueryGraph::NodeArrayEntry *graph_node_list_ptr =
(QueryGraph::NodeArrayEntry *)(shared_memory_ptr +
shared_layout_ptr->GetGraphNodeListOffset());
hsgr_input_stream.read((char *)graph_node_list_ptr,
if (shared_layout_ptr->graph_node_list_size > 0)
{
hsgr_input_stream.read((char *)graph_node_list_ptr,
shared_layout_ptr->graph_node_list_size *
sizeof(QueryGraph::NodeArrayEntry));
}
// load the edges of the search graph
QueryGraph::EdgeArrayEntry *graph_edge_list_ptr =
(QueryGraph::EdgeArrayEntry *)(shared_memory_ptr +
shared_layout_ptr->GetGraphEdgeListOffset());
hsgr_input_stream.read((char *)graph_edge_list_ptr,
if (shared_layout_ptr->graph_edge_list_size > 0)
{
hsgr_input_stream.read((char *)graph_edge_list_ptr,
shared_layout_ptr->graph_edge_list_size *
sizeof(QueryGraph::EdgeArrayEntry));
}
hsgr_input_stream.close();
// acquire lock

15
prepare.cpp
View File

@ -203,8 +203,11 @@ int main(int argc, char *argv[])
restriction_stream.read((char *)&number_of_usable_restrictions, sizeof(unsigned));
restriction_list.resize(number_of_usable_restrictions);
restriction_stream.read((char *)&(restriction_list[0]),
if (number_of_usable_restrictions > 0)
{
restriction_stream.read((char *)&(restriction_list[0]),
number_of_usable_restrictions * sizeof(TurnRestriction));
}
restriction_stream.close();
boost::filesystem::ifstream in;
@ -347,8 +350,11 @@ int main(int argc, char *argv[])
boost::filesystem::ofstream node_stream(node_filename, std::ios::binary);
const unsigned size_of_mapping = internal_to_external_node_map.size();
node_stream.write((char *)&size_of_mapping, sizeof(unsigned));
node_stream.write((char *)&(internal_to_external_node_map[0]),
if (size_of_mapping > 0)
{
node_stream.write((char *)&(internal_to_external_node_map[0]),
size_of_mapping * sizeof(NodeInfo));
}
node_stream.close();
internal_to_external_node_map.clear();
internal_to_external_node_map.shrink_to_fit();
@ -429,8 +435,11 @@ int main(int argc, char *argv[])
// serialize number of edges
hsgr_output_stream.write((char *)&contracted_edge_count, sizeof(unsigned));
// serialize all nodes
hsgr_output_stream.write((char *)&node_array[0],
if (node_array_size > 0)
{
hsgr_output_stream.write((char *)&node_array[0],
sizeof(StaticGraph<EdgeData>::NodeArrayEntry) * node_array_size);
}
// serialize all edges
SimpleLogger().Write() << "Building edge array";