#include <unistd.h>
#include <string.h>
-using namespace std;
-
namespace vasum {
namespace cli {
return out;
}
-typedef vector<vector<string>> Table;
+typedef std::vector<std::vector<std::string>> Table;
-ostream& operator<<(ostream& out, const Table& table)
+std::ostream& operator<<(std::ostream& out, const Table& table)
{
- vector<size_t> sizes;
+ std::vector<size_t> sizes;
for (const auto& row : table) {
if (sizes.size() < row.size()) {
sizes.resize(row.size());
}
for (size_t i = 0; i < row.size(); ++i) {
- sizes[i] = max(sizes[i], row[i].length());
+ sizes[i] = std::max(sizes[i], row[i].length());
}
}
for (const auto& row : table) {
for (size_t i = 0; i < row.size(); ++i) {
- out << left << setw(sizes[i]+2) << row[i];
+ out << std::left << std::setw(sizes[i]+2) << row[i];
}
out << "\n";
}
if (mode == "passthru") {
return MACVLAN_MODE_PASSTHRU;
}
- throw runtime_error("Unsupported macvlan mode");
+ throw std::runtime_error("Unsupported macvlan mode");
}
void buildZoneList(std::vector<std::string>& list)
vsm_array_string_free(ids);
}
-void buildNetdevList(const std::string& zone,std::vector<std::string>& list)
+void buildNetdevList(const std::string& zone, std::vector<std::string>& list)
{
using namespace std::placeholders;
VsmArrayString ids;
}
ArgSpec as = mArgsSpec[a.size() - 2];
- string::size_type s = 0U;
- string::size_type e = s;
- while (e != string::npos) {
+ std::string::size_type s = 0U;
+ std::string::size_type e = s;
+ while (e != std::string::npos) {
e = as.format.find('|', s);
std::string ss = as.format.substr(s, e - s);
s = e + 1;
CommandLineInterface::client = vsm_client_create();
if (CommandLineInterface::client == nullptr) {
- throw runtime_error("Can't create client");
+ throw std::runtime_error("Can't create client");
}
status = vsm_connect(client);
if (VSMCLIENT_SUCCESS != status) {
- string msg = vsm_get_status_message(CommandLineInterface::client);
+ std::string msg = vsm_get_status_message(CommandLineInterface::client);
vsm_client_free(CommandLineInterface::client);
CommandLineInterface::client = nullptr;
throw IOException(msg);
void CommandLineInterface::disconnect()
{
- string msg;
+ std::string msg;
VsmStatus status;
if (CommandLineInterface::client == nullptr) {
CommandLineInterface::client = nullptr;
if (VSMCLIENT_SUCCESS != status) {
- throw runtime_error(msg);
+ throw std::runtime_error(msg);
}
}
-void CommandLineInterface::executeCallback(const function<VsmStatus(VsmClient)>& fun)
+void CommandLineInterface::executeCallback(const std::function<VsmStatus(VsmClient)>& fun)
{
CommandLineInterface::connect();
VsmStatus status = fun(CommandLineInterface::client);
if (VSMCLIENT_SUCCESS != status) {
- throw runtime_error(vsm_get_status_message(CommandLineInterface::client));
+ throw std::runtime_error(vsm_get_status_message(CommandLineInterface::client));
}
}
using namespace std::placeholders;
if (argv.size() < 2) {
- throw runtime_error("Not enough parameters");
+ throw std::runtime_error("Not enough parameters");
}
CommandLineInterface::executeCallback(bind(vsm_set_active_zone, _1, argv[1].c_str()));
using namespace std::placeholders;
if (argv.size() < 2) {
- throw runtime_error("Not enough parameters");
+ throw std::runtime_error("Not enough parameters");
}
if (argv.size() >= 3 && !argv[2].empty()) {
using namespace std::placeholders;
if (argv.size() < 2) {
- throw runtime_error("Not enough parameters");
+ throw std::runtime_error("Not enough parameters");
}
CommandLineInterface::executeCallback(bind(vsm_destroy_zone, _1, argv[1].c_str(), 1));
using namespace std::placeholders;
if (argv.size() < 2) {
- throw runtime_error("Not enough parameters");
+ throw std::runtime_error("Not enough parameters");
}
CommandLineInterface::executeCallback(bind(vsm_shutdown_zone, _1, argv[1].c_str()));
using namespace std::placeholders;
if (argv.size() < 2) {
- throw runtime_error("Not enough parameters");
+ throw std::runtime_error("Not enough parameters");
}
CommandLineInterface::executeCallback(bind(vsm_start_zone, _1, argv[1].c_str()));
using namespace std::placeholders;
if (argv.size() < 2) {
- throw runtime_error("Not enough parameters");
+ throw std::runtime_error("Not enough parameters");
}
VsmZone zone;
if (zoneStateToString(vsm_zone_get_state(zone)) != "RUNNING") {
vsm_zone_free(zone);
- throw runtime_error("Zone '" + argv[1] + "' is not running");
+ throw std::runtime_error("Zone '" + argv[1] + "' is not running");
}
std::string zonesPath = vsm_zone_get_rootfs(zone);
.add("-P").add(zonesPath.c_str());
if (!execv("/usr/bin/lxc-console", const_cast<char* const*>(args.c_array()))) {
- throw runtime_error("Could not log into zone");
+ throw std::runtime_error("Could not log into zone");
}
}
using namespace std::placeholders;
if (argv.size() < 2) {
- throw runtime_error("Not enough parameters");
+ throw std::runtime_error("Not enough parameters");
}
CommandLineInterface::executeCallback(bind(vsm_lock_zone, _1, argv[1].c_str()));
using namespace std::placeholders;
if (argv.size() < 2) {
- throw runtime_error("Not enough parameters");
+ throw std::runtime_error("Not enough parameters");
}
CommandLineInterface::executeCallback(bind(vsm_unlock_zone, _1, argv[1].c_str()));
for (VsmString* id = ids; *id; ++id) {
VsmZone zone;
CommandLineInterface::executeCallback(bind(vsm_lookup_zone_by_id, _1, *id, &zone));
- assert(string(vsm_zone_get_id(zone)) == string(*id));
- table.push_back({string(vsm_zone_get_id(zone)) == string(activeId) ? "YES" : "NO",
+ assert(std::string(vsm_zone_get_id(zone)) == std::string(*id));
+ table.push_back({std::string(vsm_zone_get_id(zone)) == std::string(activeId) ? "YES" : "NO",
vsm_zone_get_id(zone),
zoneStateToString(vsm_zone_get_state(zone)),
- to_string(vsm_zone_get_terminal(zone)),
+ std::to_string(vsm_zone_get_terminal(zone)),
vsm_zone_get_rootfs(zone)});
vsm_zone_free(zone);
}
vsm_string_free(activeId);
vsm_array_string_free(ids);
- cout << table << endl;
+ std::cout << table << std::endl;
}
void get_zone_ids(const Args& /*argv*/)
VsmArrayString ids;
CommandLineInterface::executeCallback(bind(vsm_get_zone_ids, _1, &ids));
- string delim;
+ std::string delim;
for (VsmString* id = ids; *id; ++id) {
- cout << delim << *id;
+ std::cout << delim << *id;
delim = ", ";
}
- cout << endl;
+ std::cout << std::endl;
vsm_array_string_free(ids);
}
VsmString id;
CommandLineInterface::executeCallback(bind(vsm_get_active_zone_id, _1, &id));
- cout << id << endl;
+ std::cout << id << std::endl;
vsm_string_free(id);
}
using namespace std::placeholders;
if (argv.size() < 3) {
- throw runtime_error("Not enough parameters");
+ throw std::runtime_error("Not enough parameters");
}
uint32_t flags = O_RDWR;
using namespace std::placeholders;
if (argv.size() < 3) {
- throw runtime_error("Not enough parameters");
+ throw std::runtime_error("Not enough parameters");
}
CommandLineInterface::executeCallback(bind(vsm_revoke_device, _1, argv[1].c_str(), argv[2].c_str()));
using namespace std::placeholders;
if (argv.size() < 3) {
- throw runtime_error("Not enough parameters");
+ throw std::runtime_error("Not enough parameters");
}
std::string nettype = argv[2];
if (nettype == "phys") {
if (argv.size() < 4) {
- throw runtime_error("Not enough parameters");
+ throw std::runtime_error("Not enough parameters");
}
CommandLineInterface::executeCallback(bind(vsm_create_netdev_phys,
_1,
}
else if (nettype == "veth") {
if (argv.size() < 5) {
- throw runtime_error("Not enough parameters");
+ throw std::runtime_error("Not enough parameters");
}
CommandLineInterface::executeCallback(bind(vsm_create_netdev_veth,
_1,
}
else if (nettype == "macvlan") {
if (argv.size() < 6) {
- throw runtime_error("Not enough parameters");
+ throw std::runtime_error("Not enough parameters");
}
CommandLineInterface::executeCallback(bind(vsm_create_netdev_macvlan,
_1,
macvlanFromString(argv[5].c_str())));
}
else
- throw runtime_error("Wrong nettype option " + nettype);
+ throw std::runtime_error("Wrong nettype option " + nettype);
}
void destroy_netdev(const Args& argv)
using namespace std::placeholders;
if (argv.size() < 3) {
- throw runtime_error("Not enough parameters");
+ throw std::runtime_error("Not enough parameters");
}
CommandLineInterface::executeCallback(bind(vsm_destroy_netdev,
_1,
using namespace std::placeholders;
if (argv.size() < 2) {
- throw runtime_error("Not enough parameters");
+ throw std::runtime_error("Not enough parameters");
}
if (argv.size() < 3) {
VsmArrayString ids;
_1,
argv[1].c_str(),
&ids));
- string delim;
+ std::string delim;
for (VsmString* id = ids; *id; ++id) {
- cout << delim << *id;
+ std::cout << delim << *id;
delim = ", ";
}
if (delim.empty()) {
- cout << "There is no network device in zone";
+ std::cout << "There is no network device in zone";
}
- cout << endl;
+ std::cout << std::endl;
vsm_array_string_free(ids);
}
else {
argv[1].c_str(),
argv[2].c_str(),
&netdev));
- cout << netdevToString(netdev) << endl;
+ std::cout << netdevToString(netdev) << std::endl;
vsm_netdev_free(netdev);
VsmAddrList addrs = NULL;
for (unsigned i=0; i < listsize; ++i) {
int type=vsm_addrlist_get_type(addrs, i);
if (inet_ntop(type, vsm_addrlist_get_addr(addrs, i), buf, INET6_ADDRSTRLEN) == NULL) {
- throw runtime_error("Wrong address received ["+std::to_string(i)+"] type="+std::to_string(type));
+ throw std::runtime_error("Wrong address received ["+std::to_string(i)+"] type="+std::to_string(type));
}
- cout << buf << "/" << vsm_addrlist_get_prefix(addrs, i) << endl;
+ std::cout << buf << "/" << vsm_addrlist_get_prefix(addrs, i) << std::endl;
}
vsm_addrlist_free(addrs);
}
{
using namespace std::placeholders;
if (argv.size() < 5) {
- throw runtime_error("Not enough parameters");
+ throw std::runtime_error("Not enough parameters");
}
if (argv[3].find(':') == std::string::npos) {
in_addr addr;
if (inet_pton(AF_INET, argv[3].c_str(), &addr) != 1) {
- throw runtime_error("Wrong address format");
+ throw std::runtime_error("Wrong address format");
};
CommandLineInterface::executeCallback(bind(vsm_netdev_add_ipv4_addr,
_1,
argv[1].c_str(),
argv[2].c_str(),
&addr,
- stoi(argv[4].c_str())));
+ std::stoi(argv[4].c_str())));
}
else {
in6_addr addr;
if (inet_pton(AF_INET6, argv[3].c_str(), &addr) != 1) {
- throw runtime_error("Wrong address format");
+ throw std::runtime_error("Wrong address format");
};
CommandLineInterface::executeCallback(bind(vsm_netdev_add_ipv6_addr,
_1,
argv[1].c_str(),
argv[2].c_str(),
&addr,
- stoi(argv[4].c_str())));
+ std::stoi(argv[4].c_str())));
}
}
{
using namespace std::placeholders;
if (argv.size() < 5) {
- throw runtime_error("Not enough parameters");
+ throw std::runtime_error("Not enough parameters");
}
if (argv[3].find(':') == std::string::npos) {
in_addr addr;
if (inet_pton(AF_INET, argv[3].c_str(), &addr) != 1) {
- throw runtime_error("Wrong address format");
+ throw std::runtime_error("Wrong address format");
};
CommandLineInterface::executeCallback(bind(vsm_netdev_del_ipv4_addr,
_1,
argv[1].c_str(),
argv[2].c_str(),
&addr,
- stoi(argv[4].c_str())));
+ std::stoi(argv[4].c_str())));
}
else {
in6_addr addr;
if (inet_pton(AF_INET6, argv[3].c_str(), &addr) != 1) {
- throw runtime_error("Wrong address format");
+ throw std::runtime_error("Wrong address format");
};
CommandLineInterface::executeCallback(bind(vsm_netdev_del_ipv6_addr,
_1,
argv[1].c_str(),
argv[2].c_str(),
&addr,
- stoi(argv[4].c_str())));
+ std::stoi(argv[4].c_str())));
}
}
using namespace std::placeholders;
if (argv.size() < 3) {
- throw runtime_error("Not enough parameters");
+ throw std::runtime_error("Not enough parameters");
}
CommandLineInterface::executeCallback(bind(vsm_netdev_up,
_1,
using namespace std::placeholders;
if (argv.size() < 3) {
- throw runtime_error("Not enough parameters");
+ throw std::runtime_error("Not enough parameters");
}
CommandLineInterface::executeCallback(bind(vsm_netdev_down,
_1,
#include <boost/algorithm/string/split.hpp>
#include <boost/algorithm/string/classification.hpp>
-using namespace std;
using namespace utils;
using namespace vasum;
zone = vsmZone;
}
-string toString(const in_addr* addr)
+std::string toString(const in_addr* addr)
{
char buf[INET_ADDRSTRLEN];
const char* ret = inet_ntop(AF_INET, addr, buf, INET_ADDRSTRLEN);
return ret;
}
-string toString(const in6_addr* addr)
+std::string toString(const in6_addr* addr)
{
char buf[INET6_ADDRSTRLEN];
const char* ret = inet_ntop(AF_INET6, addr, buf, INET6_ADDRSTRLEN);
return ret;
}
-bool readFirstLineOfFile(const string& path, string& ret)
+bool readFirstLineOfFile(const std::string& path, std::string& ret)
{
- ifstream file(path);
+ std::ifstream file(path);
if (!file) {
return false;
}
{
}
-Client::Status::Status(VsmStatus status, const string& msg)
+Client::Status::Status(VsmStatus status, const std::string& msg)
: mVsmStatus(status), mMsg(msg)
{
}
}
}
-VsmStatus Client::coverException(const function<void(void)>& worker) noexcept
+VsmStatus Client::coverException(const std::function<void(void)>& worker) noexcept
{
try {
worker();
mStatus = Status(VSMCLIENT_CUSTOM_ERROR, ex.what());
} catch (const ipc::IPCException& ex) {
mStatus = Status(VSMCLIENT_IO_ERROR, ex.what());
- } catch (const exception& ex) {
+ } catch (const std::exception& ex) {
mStatus = Status(VSMCLIENT_CUSTOM_ERROR, ex.what());
}
VsmStatus ret = mStatus.mVsmStatus;
VsmStatus Client::vsm_get_status() const noexcept
{
- lock_guard<mutex> lock(mStatusMutex);
+ std::lock_guard<std::mutex> lock(mStatusMutex);
return mStatus.mVsmStatus;
}
return coverException([&] {
IS_SET(id);
- const string path = "/proc/" + to_string(pid) + "/cpuset";
+ const std::string path = "/proc/" + std::to_string(pid) + "/cpuset";
- string cpuset;
+ std::string cpuset;
if (!readFirstLineOfFile(path, cpuset)) {
throw InvalidArgumentException("Process not found");
}
- string zoneId;
+ std::string zoneId;
if (!parseZoneIdFromCpuSet(cpuset, zoneId)) {
throw OperationFailedException("unknown format of cpuset");
}
return coverException([&] {
IS_SET(id);
- string template_name = tname ? tname : "default";
+ std::string template_name = tname ? tname : "default";
mClient->callSync<api::CreateZoneIn, api::Void>(
api::ipc::METHOD_CREATE_ZONE,
std::make_shared<api::CreateZoneIn>(api::CreateZoneIn{ id, template_name }),
std::vector<std::string> addrAttrs;
for(const auto& addrAttr : split(addrAttrs, attr.second, is_any_of(","))) {
size_t pos = addrAttr.find(":");
- if (pos == string::npos) continue;
+ if (pos == std::string::npos) continue;
if (addrAttr.substr(0, pos) == "prefixlen") {
addr.prefix = atoi(addrAttr.substr(pos + 1).c_str());
IS_SET(netdevId);
IS_SET(addr);
- string value = "ip:" + toString(addr) + ",""prefixlen:" + to_string(prefix);
+ std::string value = "ip:" + toString(addr) + ",""prefixlen:" + std::to_string(prefix);
mClient->callSync<api::SetNetDevAttrsIn, api::Void>(
api::ipc::METHOD_SET_NETDEV_ATTRS,
std::make_shared<api::SetNetDevAttrsIn>(
IS_SET(netdevId);
IS_SET(addr);
- string value = "ip:" + toString(addr) + ",""prefixlen:" + to_string(prefix);
+ std::string value = "ip:" + toString(addr) + ",""prefixlen:" + std::to_string(prefix);
mClient->callSync<api::SetNetDevAttrsIn, api::Void>(
api::ipc::METHOD_SET_NETDEV_ATTRS,
std::make_shared<api::SetNetDevAttrsIn>(
IS_SET(addr);
//CIDR notation
- string ip = toString(addr) + "/" + to_string(prefix);
+ std::string ip = toString(addr) + "/" + std::to_string(prefix);
mClient->callSync<api::DeleteNetdevIpAddressIn, api::Void>(
api::ipc::METHOD_DELETE_NETDEV_IP_ADDRESS,
std::make_shared<api::DeleteNetdevIpAddressIn>(
IS_SET(addr);
//CIDR notation
- string ip = toString(addr) + "/" + to_string(prefix);
+ std::string ip = toString(addr) + "/" + std::to_string(prefix);
mClient->callSync<api::DeleteNetdevIpAddressIn, api::Void>(
api::ipc::METHOD_DELETE_NETDEV_IP_ADDRESS,
std::make_shared<api::DeleteNetdevIpAddressIn>(
mClient->callSync<api::SetNetDevAttrsIn, api::Void>(
api::ipc::METHOD_SET_NETDEV_ATTRS,
std::make_shared<api::SetNetDevAttrsIn>(
- api::SetNetDevAttrsIn{ id, netdevId, { { "flags", to_string(IFF_UP) },
- { "change", to_string(IFF_UP) } } }));
+ api::SetNetDevAttrsIn{ id, netdevId, { { "flags", std::to_string(IFF_UP) },
+ { "change", std::to_string(IFF_UP) } } }));
});
}
mClient->callSync<api::SetNetDevAttrsIn, api::Void>(
api::ipc::METHOD_SET_NETDEV_ATTRS,
std::make_shared<api::SetNetDevAttrsIn>(
- api::SetNetDevAttrsIn{ id, netdevId, { { "flags", to_string(~IFF_UP) },
- { "change", to_string(IFF_UP) } } }));
+ api::SetNetDevAttrsIn{ id, netdevId, { { "flags", std::to_string(~IFF_UP) },
+ { "change", std::to_string(IFF_UP) } } }));
});
}
*
* Client uses dbus API.
*/
-class Client {
+class Client final {
public:
Client() noexcept;
~Client() noexcept;
#define API __attribute__((visibility("default")))
#endif // API
-using namespace std;
-
namespace {
Client& getClient(VsmClient client)
API VsmClient vsm_client_create()
{
- Client* clientPtr = new(nothrow) Client();
+ Client* clientPtr = new(std::nothrow) Client();
return reinterpret_cast<VsmClient>(clientPtr);
}
#define BRIDGE_FLAGS_MASTER 1
#endif
-using namespace std;
using namespace utils;
using namespace vasum::netlink;
+using std::get;
namespace vasum {
namespace netdev {
namespace {
-string getUniqueVethName()
+std::string getUniqueVethName()
{
- auto find = [](const ifaddrs* ifaddr, const string& name) -> bool {
+ auto find = [](const ifaddrs* ifaddr, const std::string& name) -> bool {
for (const ifaddrs* ifa = ifaddr; ifa != NULL; ifa = ifa->ifa_next) {
if (name == ifa->ifa_name) {
return true;
ifaddrs* ifaddr;
getifaddrs(&ifaddr);
- string newName;
+ std::string newName;
int i = 0;
do {
- newName = "veth0" + to_string(++i);
+ newName = "veth0" + std::to_string(++i);
} while (find(ifaddr, newName));
freeifaddrs(ifaddr);
return newName;
}
-uint32_t getInterfaceIndex(const string& name) {
+uint32_t getInterfaceIndex(const std::string& name) {
uint32_t index = if_nametoindex(name.c_str());
if (!index) {
const std::string msg = "Can't get " + name + " interface index (" + getSystemErrorMessage() + ")";
return index;
}
-uint32_t getInterfaceIndex(const string& name, pid_t nsPid) {
+uint32_t getInterfaceIndex(const std::string& name, pid_t nsPid) {
NetlinkMessage nlm(RTM_GETLINK, NLM_F_REQUEST | NLM_F_ACK);
ifinfomsg infoPeer = utils::make_clean<ifinfomsg>();
infoPeer.ifi_family = AF_UNSPEC;
return ip.find(':') == std::string::npos ? AF_INET : AF_INET6;
}
-void validateNetdevName(const string& name)
+void validateNetdevName(const std::string& name)
{
if (name.size() <= 1 || name.size() >= IFNAMSIZ) {
throw ZoneOperationException("Invalid netdev name format");
}
}
-void createPipedNetdev(const string& netdev1, const string& netdev2)
+void createPipedNetdev(const std::string& netdev1, const std::string& netdev2)
{
validateNetdevName(netdev1);
validateNetdevName(netdev2);
send(nlm);
}
-void attachToBridge(const string& bridge, const string& netdev)
+void attachToBridge(const std::string& bridge, const std::string& netdev)
{
validateNetdevName(bridge);
validateNetdevName(netdev);
close(fd);
}
-int setFlags(const string& name, uint32_t mask, uint32_t flags)
+int setFlags(const std::string& name, uint32_t mask, uint32_t flags)
{
uint32_t index = getInterfaceIndex(name);
NetlinkMessage nlm(RTM_NEWLINK, NLM_F_REQUEST | NLM_F_ACK);
return 0;
}
-void up(const string& netdev)
+void up(const std::string& netdev)
{
setFlags(netdev, IFF_UP, IFF_UP);
}
-void moveToNS(const string& netdev, pid_t pid)
+void moveToNS(const std::string& netdev, pid_t pid)
{
uint32_t index = getInterfaceIndex(netdev);
NetlinkMessage nlm(RTM_NEWLINK, NLM_F_REQUEST | NLM_F_ACK);
send(nlm);
}
-void createMacvlan(const string& master, const string& slave, const macvlan_mode& mode)
+void createMacvlan(const std::string& master, const std::string& slave, const macvlan_mode& mode)
{
validateNetdevName(master);
validateNetdevName(slave);
LOGE(msg);
throw VasumException(msg);
}
- attrs.push_back(make_tuple("ip", buf));
+ attrs.push_back(std::make_tuple("ip", buf));
break;
default:
response.skipAttribute();
} // namespace
-void createVeth(const pid_t& nsPid, const string& nsDev, const string& hostDev)
+void createVeth(const pid_t& nsPid, const std::string& nsDev, const std::string& hostDev)
{
- string hostVeth = getUniqueVethName();
+ std::string hostVeth = getUniqueVethName();
LOGT("Creating veth: bridge: " << hostDev << ", port: " << hostVeth << ", zone: " << nsDev);
createPipedNetdev(nsDev, hostVeth);
try {
attachToBridge(hostDev, hostVeth);
up(hostVeth);
moveToNS(nsDev, nsPid);
- } catch(const exception& ex) {
+ } catch(const std::exception& ex) {
try {
destroyNetdev(hostVeth);
- } catch (const exception& ex) {
+ } catch (const std::exception& ex) {
LOGE("Can't destroy netdev pipe: " << hostVeth << ", " << nsDev);
}
throw;
}
void createMacvlan(const pid_t& nsPid,
- const string& nsDev,
- const string& hostDev,
+ const std::string& nsDev,
+ const std::string& hostDev,
const macvlan_mode& mode)
{
LOGT("Creating macvlan: host: " << hostDev << ", zone: " << nsDev << ", mode: " << mode);
try {
up(nsDev);
moveToNS(nsDev, nsPid);
- } catch(const exception& ex) {
+ } catch(const std::exception& ex) {
try {
destroyNetdev(nsDev);
- } catch (const exception& ex) {
+ } catch (const std::exception& ex) {
LOGE("Can't destroy netdev: " << nsDev);
}
throw;
}
}
-void movePhys(const pid_t& nsPid, const string& devId)
+void movePhys(const pid_t& nsPid, const std::string& devId)
{
LOGT("Creating phys: dev: " << devId);
moveToNS(devId, nsPid);
return interfaces;
}
-void destroyNetdev(const string& netdev, const pid_t pid)
+void destroyNetdev(const std::string& netdev, const pid_t pid)
{
LOGT("Destroying netdev: " << netdev);
validateNetdevName(netdev);
send(nlm, pid);
}
-void createBridge(const string& netdev)
+void createBridge(const std::string& netdev)
{
LOGT("Creating bridge: " << netdev);
validateNetdevName(netdev);
{
auto joinAddresses = [](const Attrs& attrs) -> std::string {
bool first = true;
- stringstream ss;
+ std::stringstream ss;
for (const auto& attr : attrs) {
ss << (first ? "" : ",") << get<0>(attr) << ":" << get<1>(attr);
first = false;
void setAttrs(const pid_t nsPid, const std::string& netdev, const Attrs& attrs)
{
- const set<string> supportedAttrs{"flags", "change", "type", "mtu", "link", "ipv4", "ipv6"};
+ const std::set<std::string> supportedAttrs{"flags", "change", "type", "mtu", "link", "ipv4", "ipv6"};
LOGT("Setting network device informations: " << netdev);
validateNetdevName(netdev);
}
//TODO: Multiple addresses should be set at once (add support NLM_F_MULTI to NetlinkMessage).
- vector<string> ipv4;
- vector<string> ipv6;
+ std::vector<std::string> ipv4;
+ std::vector<std::string> ipv6;
for (const auto& attr : attrs) {
if (get<0>(attr) == "ipv4") {
ipv4.push_back(get<1>(attr));
}
}
- auto setIp = [nsPid](const vector<string>& ips, uint32_t index, int family) -> void {
+ auto setIp = [nsPid](const std::vector<std::string>& ips, uint32_t index, int family) -> void {
using namespace boost::algorithm;
for (const auto& ip : ips) {
Attrs attrs;
- vector<string> params;
+ std::vector<std::string> params;
for (const auto& addrAttr : split(params, ip, is_any_of(","))) {
size_t pos = addrAttr.find(":");
- if (pos == string::npos || pos == addrAttr.length()) {
+ if (pos == std::string::npos || pos == addrAttr.length()) {
const std::string msg = "Wrong input data format: ill formed address attribute: " + addrAttr;
LOGE(msg);
throw VasumException(msg);
{
uint32_t index = getInterfaceIndex(netdev, nsPid);
size_t slash = ip.find('/');
- if (slash == string::npos) {
+ if (slash == std::string::npos) {
const std::string msg = "Wrong address format: it is not CIDR notation: can't find '/'";
LOGE(msg);
throw VasumException(msg);
} //namespace netdev
} //namespace vasum
-
projects / platform / core / security / vasum.git / commitdiff