1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
|
/*
* 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/environment.h"
#include "host/libs/config/config_constants.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");
}
std::string DefaultQemuBinaryDir() {
const std::string target_prod_str = StringFromEnv("TARGET_PRODUCT", "");
if (HostArch() == Arch::X86_64 &&
target_prod_str.find("arm") == std::string::npos) {
return HostBinaryDir();
}
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 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;
}
}
|
