blob: 38577663b758b77f30f7366b8daa53597e4f276c [file] [log] [blame]
// Copyright 2017 The Bazel Authors. All rights reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#include <fstream>
#include <memory>
#include <string>
#include <unordered_map>
#include "src/main/cpp/util/path_platform.h"
#include "src/main/cpp/util/strings.h"
#include "src/tools/launcher/util/data_parser.h"
#include "src/tools/launcher/util/launcher_util.h"
namespace bazel {
namespace launcher {
using std::ifstream;
using std::ios;
using std::make_unique;
using std::string;
using std::unique_ptr;
using std::wstring;
int64_t LaunchDataParser::ReadDataSize(ifstream* binary) {
int64_t data_size;
binary->seekg(0 - sizeof(data_size), ios::end);
binary->read(reinterpret_cast<char*>(&data_size), sizeof(data_size));
return data_size;
}
void LaunchDataParser::ReadLaunchData(ifstream* binary, char* launch_data,
int64_t data_size) {
binary->seekg(0 - data_size - sizeof(data_size), ios::end);
binary->read(launch_data, data_size);
}
bool LaunchDataParser::ParseLaunchData(LaunchInfo* launch_info,
const char* launch_data,
int64_t data_size) {
int64_t start, end, equal;
start = 0;
while (start < data_size) {
// Move start to point to the next non-null character.
while (launch_data[start] == '\0' && start < data_size) {
start++;
}
// Move end to the next null character or end of the string,
// also find the first equal symbol appears.
end = start;
equal = -1;
while (launch_data[end] != '\0' && end < data_size) {
if (equal == -1 && launch_data[end] == '=') {
equal = end;
}
end++;
}
if (equal == -1) {
PrintError(L"Cannot find equal symbol in line: %hs",
string(launch_data + start, end - start).c_str());
return false;
} else if (start == equal) {
PrintError(L"Key is empty string in line: %hs",
string(launch_data + start, end - start).c_str());
return false;
} else {
string key(launch_data + start, equal - start);
string value(launch_data + equal + 1, end - equal - 1);
if (launch_info->find(key) != launch_info->end()) {
PrintError(L"Duplicated launch info key: %hs", key.c_str());
return false;
}
launch_info->insert(make_pair(key, blaze_util::CstringToWstring(value)));
}
start = end + 1;
}
return true;
}
bool LaunchDataParser::GetLaunchInfo(const wstring& binary_path,
LaunchInfo* launch_info) {
unique_ptr<ifstream> binary =
make_unique<ifstream>(AsAbsoluteWindowsPath(binary_path.c_str()).c_str(),
ios::binary | ios::in);
if (!binary->good()) {
PrintError(L"Cannot open the binary to read launch data");
return false;
}
int64_t data_size = ReadDataSize(binary.get());
if (data_size == 0) {
PrintError(L"No data appended, cannot launch anything!");
return false;
}
unique_ptr<char[]> launch_data(new char[data_size]);
ReadLaunchData(binary.get(), launch_data.get(), data_size);
if (!ParseLaunchData(launch_info, launch_data.get(), data_size)) {
return false;
}
return true;
}
} // namespace launcher
} // namespace bazel