blob: 2124af90a3d5ddaee949a5f0c8171913cea5e75a [file] [log] [blame]
#include "utils.hpp"
#include <phosphor-logging/log.hpp>
#include <phosphor-logging/elog-errors.hpp>
#include "xyz/openbmc_project/Common/error.hpp"
#include <arpa/inet.h>
#include <dirent.h>
#include <net/if.h>
namespace ipmi
{
using namespace phosphor::logging;
using namespace sdbusplus::xyz::openbmc_project::Common::Error;
//TODO There may be cases where an interface is implemented by multiple
// objects,to handle such cases we are interested on that object
// which are on interested busname.
// Currently mapper doesn't give the readable busname(gives busid) so we can't
// use busname to find the object,will do later once the support is there.
DbusObjectInfo getDbusObject(sdbusplus::bus::bus& bus,
const std::string& interface,
const std::string& serviceRoot,
const std::string& match)
{
std::vector<DbusInterface> interfaces;
interfaces.emplace_back(interface);
auto depth = 0;
auto mapperCall = bus.new_method_call(MAPPER_BUS_NAME,
MAPPER_OBJ,
MAPPER_INTF,
"GetSubTree");
mapperCall.append(serviceRoot, depth, interfaces);
auto mapperReply = bus.call(mapperCall);
if (mapperReply.is_method_error())
{
log<level::ERR>("Error in mapper call");
elog<InternalFailure>();
}
ObjectTree objectTree;
mapperReply.read(objectTree);
if (objectTree.empty())
{
log<level::ERR>("No Object has implemented the interface",
entry("INTERFACE=%s", interface.c_str()));
elog<InternalFailure>();
}
DbusObjectInfo objectInfo;
// if match is empty then return the first object
if(match == "")
{
objectInfo = std::make_pair(objectTree.begin()->first,
std::move(objectTree.begin()->second.begin()->first));
return objectInfo;
}
// else search the match string in the object path
auto objectFound = false;
for (auto& object : objectTree)
{
if(object.first.find(match) != std::string::npos)
{
objectFound = true;
objectInfo = make_pair(object.first,
std::move(object.second.begin()->first));
break;
}
}
if(!objectFound)
{
log<level::ERR>("Failed to find object which matches",
entry("MATCH=%s", match.c_str()));
elog<InternalFailure>();
}
return objectInfo;
}
Value getDbusProperty(sdbusplus::bus::bus& bus,
const std::string& service,
const std::string& objPath,
const std::string& interface,
const std::string& property)
{
Value value;
auto method = bus.new_method_call(
service.c_str(),
objPath.c_str(),
PROP_INTF,
METHOD_GET);
method.append(interface, property);
auto reply = bus.call(method);
if (reply.is_method_error())
{
log<level::ERR>("Failed to get property",
entry("PROPERTY=%s", property.c_str()),
entry("PATH=%s", objPath.c_str()),
entry("INTERFACE=%s", interface.c_str()));
elog<InternalFailure>();
}
reply.read(value);
return value;
}
PropertyMap getAllDbusProperties(sdbusplus::bus::bus& bus,
const std::string& service,
const std::string& objPath,
const std::string& interface)
{
PropertyMap properties;
auto method = bus.new_method_call(
service.c_str(),
objPath.c_str(),
PROP_INTF,
METHOD_GET_ALL);
method.append(interface);
auto reply = bus.call(method);
if (reply.is_method_error())
{
log<level::ERR>("Failed to get all properties",
entry("PATH=%s", objPath.c_str()),
entry("INTERFACE=%s", interface.c_str()));
elog<InternalFailure>();
}
reply.read(properties);
return properties;
}
void setDbusProperty(sdbusplus::bus::bus& bus,
const std::string& service,
const std::string& objPath,
const std::string& interface,
const std::string& property,
const Value& value)
{
auto method = bus.new_method_call(
service.c_str(),
objPath.c_str(),
PROP_INTF,
METHOD_SET);
method.append(interface, property, value);
if (!bus.call(method))
{
log<level::ERR>("Failed to set property",
entry("PROPERTY=%s", property.c_str()),
entry("PATH=%s",objPath.c_str()),
entry("INTERFACE=%s",interface.c_str()));
elog<InternalFailure>();
}
}
std::string getService(sdbusplus::bus::bus& bus,
const std::string& intf,
const std::string& path)
{
auto mapperCall = bus.new_method_call("xyz.openbmc_project.ObjectMapper",
"/xyz/openbmc_project/object_mapper",
"xyz.openbmc_project.ObjectMapper",
"GetObject");
mapperCall.append(path);
mapperCall.append(std::vector<std::string>({intf}));
auto mapperResponseMsg = bus.call(mapperCall);
if (mapperResponseMsg.is_method_error())
{
throw std::runtime_error("ERROR in mapper call");
}
std::map<std::string, std::vector<std::string>> mapperResponse;
mapperResponseMsg.read(mapperResponse);
if (mapperResponse.begin() == mapperResponse.end())
{
throw std::runtime_error("ERROR in reading the mapper response");
}
return mapperResponse.begin()->first;
}
ipmi::ObjectTree getAllDbusObjects(sdbusplus::bus::bus& bus,
const std::string& serviceRoot,
const std::string& interface,
const std::string& match)
{
std::vector<std::string> interfaces;
interfaces.emplace_back(interface);
auto depth = 0;
auto mapperCall = bus.new_method_call(MAPPER_BUS_NAME,
MAPPER_OBJ,
MAPPER_INTF,
"GetSubTree");
mapperCall.append(serviceRoot, depth, interfaces);
auto mapperReply = bus.call(mapperCall);
if (mapperReply.is_method_error())
{
log<level::ERR>("Error in mapper call",
entry("SERVICEROOT=%s",serviceRoot.c_str()),
entry("INTERFACE=%s", interface.c_str()));
elog<InternalFailure>();
}
ObjectTree objectTree;
mapperReply.read(objectTree);
for (auto it = objectTree.begin(); it != objectTree.end();)
{
if (it->first.find(match) == std::string::npos)
{
it = objectTree.erase(it);
}
else
{
++it;
}
}
return objectTree;
}
void deleteAllDbusObjects(sdbusplus::bus::bus& bus,
const std::string& serviceRoot,
const std::string& interface,
const std::string& match)
{
try
{
auto objectTree = getAllDbusObjects(bus, serviceRoot, interface, match);
for (auto& object : objectTree)
{
method_no_args::callDbusMethod(bus,
object.second.begin()->first,
object.first,
DELETE_INTERFACE, "Delete");
}
}
catch (InternalFailure& e)
{
log<level::INFO>("Unable to delete the objects having",
entry("INTERFACE=%s", interface.c_str()),
entry("SERVICE=%s", serviceRoot.c_str()));
}
}
ObjectTree getAllAncestors(sdbusplus::bus::bus& bus,
const std::string& path,
InterfaceList&& interfaces)
{
auto convertToString = [](InterfaceList& interfaces) -> std::string
{
std::string intfStr;
for (const auto& intf : interfaces)
{
intfStr += "," + intf;
}
return intfStr;
};
auto mapperCall = bus.new_method_call(MAPPER_BUS_NAME,
MAPPER_OBJ,
MAPPER_INTF,
"GetAncestors");
mapperCall.append(path, interfaces);
auto mapperReply = bus.call(mapperCall);
if (mapperReply.is_method_error())
{
log<level::ERR>("Error in mapper call",
entry("PATH=%s", path.c_str()),
entry("INTERFACES=%s",
convertToString(interfaces).c_str()));
elog<InternalFailure>();
}
ObjectTree objectTree;
mapperReply.read(objectTree);
if (objectTree.empty())
{
log<level::ERR>("No Object has implemented the interface",
entry("PATH=%s", path.c_str()),
entry("INTERFACES=%s",
convertToString(interfaces).c_str()));
elog<InternalFailure>();
}
return objectTree;
}
namespace method_no_args
{
void callDbusMethod(sdbusplus::bus::bus& bus,
const std::string& service,
const std::string& objPath,
const std::string& interface,
const std::string& method)
{
auto busMethod = bus.new_method_call(
service.c_str(),
objPath.c_str(),
interface.c_str(),
method.c_str());
auto reply = bus.call(busMethod);
if (reply.is_method_error())
{
log<level::ERR>("Failed to execute method",
entry("METHOD=%s", method.c_str()),
entry("PATH=%s", objPath.c_str()),
entry("INTERFACE=%s", interface.c_str()));
elog<InternalFailure>();
}
}
}// namespace method_no_args
namespace network
{
void createIP(sdbusplus::bus::bus& bus,
const std::string& service,
const std::string& objPath,
const std::string& protocolType,
const std::string& ipaddress,
uint8_t prefix)
{
std::string gateway = "";
auto busMethod = bus.new_method_call(
service.c_str(),
objPath.c_str(),
IP_CREATE_INTERFACE,
"IP");
busMethod.append(protocolType, ipaddress, prefix, gateway);
auto reply = bus.call(busMethod);
if (reply.is_method_error())
{
log<level::ERR>("Failed to excute method",
entry("METHOD=%s", "IP"),
entry("PATH=%s", objPath.c_str()));
elog<InternalFailure>();
}
}
void createVLAN(sdbusplus::bus::bus& bus,
const std::string& service,
const std::string& objPath,
const std::string& interfaceName,
uint32_t vlanID)
{
auto busMethod = bus.new_method_call(
service.c_str(),
objPath.c_str(),
VLAN_CREATE_INTERFACE,
"VLAN");
busMethod.append(interfaceName, vlanID);
auto reply = bus.call(busMethod);
if (reply.is_method_error())
{
log<level::ERR>("Failed to excute method",
entry("METHOD=%s", "VLAN"),
entry("PATH=%s", objPath.c_str()));
elog<InternalFailure>();
}
}
uint8_t toPrefix(int addressFamily, const std::string& subnetMask)
{
if (addressFamily == AF_INET6)
{
return 0;
}
uint32_t buff {};
auto rc = inet_pton(addressFamily, subnetMask.c_str(), &buff);
if (rc <= 0)
{
log<level::ERR>("inet_pton failed:",
entry("SUBNETMASK=%s", subnetMask));
return 0;
}
buff = be32toh(buff);
// total no of bits - total no of leading zero == total no of ones
if (((sizeof(buff) * 8) - (__builtin_ctz(buff))) == __builtin_popcount(buff))
{
return __builtin_popcount(buff);
}
else
{
log<level::ERR>("Invalid Mask",
entry("SUBNETMASK=%s", subnetMask));
return 0;
}
}
uint32_t getVLAN(const std::string& path)
{
// Path would be look like
// /xyz/openbmc_project/network/eth0_443/ipv4
uint32_t vlanID = 0;
try
{
auto intfObjectPath = path.substr(0,
path.find(IP_TYPE) - 1);
auto intfName = intfObjectPath.substr(intfObjectPath.rfind("/") + 1);
auto index = intfName.find("_");
if (index != std::string::npos)
{
auto str = intfName.substr(index + 1);
vlanID = std::stoul(str);
}
}
catch (std::exception & e)
{
log<level::ERR>("Exception occured during getVLAN",
entry("PATH=%s",path.c_str()),
entry("EXCEPTIOn=%s", e.what()));
}
return vlanID;
}
} // namespace network
} // namespace ipmi