blob: c4fea49ccedc07c10985430d6be5bf9b9a044c5d [file] [log] [blame] [edit]
/*
* Copyright (C) 2018 The Android Open Source Project
*
* 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 "host/libs/config/config_utils.h"
#include <string.h>
#include <iomanip>
#include <sstream>
#include <android-base/logging.h>
#include <android-base/strings.h>
#include "common/libs/utils/contains.h"
#include "common/libs/utils/environment.h"
#include "host/libs/config/config_constants.h"
#include "host/libs/config/cuttlefish_config.h"
namespace cuttlefish {
int InstanceFromString(std::string instance_str) {
if (android::base::StartsWith(instance_str, kVsocUserPrefix)) {
instance_str = instance_str.substr(std::string(kVsocUserPrefix).size());
} else if (android::base::StartsWith(instance_str, kCvdNamePrefix)) {
instance_str = instance_str.substr(std::string(kCvdNamePrefix).size());
}
int instance = std::stoi(instance_str);
if (instance <= 0) {
LOG(INFO) << "Failed to interpret \"" << instance_str << "\" as an id, "
<< "using instance id " << kDefaultInstance;
return kDefaultInstance;
}
return instance;
}
int InstanceFromEnvironment() {
std::string instance_str = StringFromEnv(kCuttlefishInstanceEnvVarName, "");
if (instance_str.empty()) {
// Try to get it from the user instead
instance_str = StringFromEnv("USER", "");
if (instance_str.empty()) {
LOG(DEBUG) << kCuttlefishInstanceEnvVarName
<< " and USER unset, using instance id " << kDefaultInstance;
return kDefaultInstance;
}
if (!android::base::StartsWith(instance_str, kVsocUserPrefix)) {
// No user or we don't recognize this user
LOG(DEBUG) << "Non-vsoc user, using instance id " << kDefaultInstance;
return kDefaultInstance;
}
}
return InstanceFromString(instance_str);
}
int GetInstance() {
static int instance_id = InstanceFromEnvironment();
return instance_id;
}
int GetDefaultVsockCid() {
// we assume that this function is used to configure CuttlefishConfig once
static const int default_vsock_cid = 3 + GetInstance() - 1;
return default_vsock_cid;
}
int GetVsockServerPort(const int base,
const int vsock_guest_cid /**< per instance guest cid */) {
return base + (vsock_guest_cid - 3);
}
std::string GetGlobalConfigFileLink() {
return StringFromEnv("HOME", ".") + "/.cuttlefish_config.json";
}
std::string ForCurrentInstance(const char* prefix) {
std::ostringstream stream;
stream << prefix << std::setfill('0') << std::setw(2) << GetInstance();
return stream.str();
}
int ForCurrentInstance(int base) { return base + GetInstance() - 1; }
std::string RandomSerialNumber(const std::string& prefix) {
const char hex_characters[] = "0123456789ABCDEF";
std::srand(time(0));
char str[10];
for(int i=0; i<10; i++){
str[i] = hex_characters[rand() % strlen(hex_characters)];
}
return prefix + str;
}
std::string DefaultHostArtifactsPath(const std::string& file_name) {
return (StringFromEnv("ANDROID_HOST_OUT", StringFromEnv("HOME", ".")) + "/") +
file_name;
}
std::string HostBinaryDir() {
return DefaultHostArtifactsPath("bin");
}
bool UseQemuPrebuilt() {
const std::string target_prod_str = StringFromEnv("TARGET_PRODUCT", "");
if (!Contains(target_prod_str, "arm")) {
return true;
}
return false;
}
std::string DefaultQemuBinaryDir() {
if (UseQemuPrebuilt()) {
return HostBinaryDir() + "/" + HostArchStr() + "-linux-gnu/qemu";
}
return "/usr/bin";
}
std::string HostBinaryPath(const std::string& binary_name) {
#ifdef __ANDROID__
return binary_name;
#else
return HostBinaryDir() + "/" + binary_name;
#endif
}
std::string HostUsrSharePath(const std::string& binary_name) {
return DefaultHostArtifactsPath("usr/share/" + binary_name);
}
std::string HostQemuBiosPath() {
if (UseQemuPrebuilt()) {
return DefaultHostArtifactsPath(
"usr/share/qemu/" + HostArchStr() + "-linux-gnu");
}
return "/usr/share/qemu";
}
std::string DefaultGuestImagePath(const std::string& file_name) {
return (StringFromEnv("ANDROID_PRODUCT_OUT", StringFromEnv("HOME", "."))) +
file_name;
}
bool HostSupportsQemuCli() {
static bool supported =
#ifdef __linux__
std::system(
"/usr/lib/cuttlefish-common/bin/capability_query.py qemu_cli") == 0;
#else
true;
#endif
return supported;
}
}