bool DBusObjectManagerStub::emitInterfacesAddedSignal(std::shared_ptr<DBusStubAdapter> dbusStubAdapter,
const std::shared_ptr<DBusProxyConnection>& dbusConnection) const {
assert(dbusConnection);
assert(dbusConnection->isConnected());
const auto& dbusStubObjectPath = dbusStubAdapter->getObjectPath();
const auto& dbusStubInterfaceName = dbusStubAdapter->getInterfaceName();
DBusMessage dbusSignal = DBusMessage::createSignal(dbusObjectPath_, getInterfaceName(), "InterfacesAdded", "oa{sa{sv}}");
DBusOutputStream dbusOutputStream(dbusSignal);
DBusInterfacesAndPropertiesDict dbusInterfacesAndPropertiesDict({
{ dbusStubInterfaceName, DBusPropertiesChangedDict() }
});
if (dbusStubAdapter->isManagingInterface()) {
dbusInterfacesAndPropertiesDict.insert({ getInterfaceName(), DBusPropertiesChangedDict() });
}
if (dbusStubAdapter->hasFreedesktopProperties()) {
dbusInterfacesAndPropertiesDict.insert({ "org.freedesktop.DBus.Properties", DBusPropertiesChangedDict() });
}
dbusOutputStream << dbusStubObjectPath;
dbusOutputStream << dbusInterfacesAndPropertiesDict;
dbusOutputStream.flush();
const bool dbusSignalEmitted = dbusConnection->sendDBusMessage(dbusSignal);
return dbusSignalEmitted;
}
void serialize(
Archive & ar,
RcfClientT & rcfClient)
{
if (ar.isWrite())
{
rcfClient.mClientStubPtr ?
ar & true & rcfClient.getClientStub() :
ar & false;
}
else //if (ar.isRead())
{
bool hasClientStub = false;
ar & hasClientStub;
if (hasClientStub)
{
if (!rcfClient.mClientStubPtr)
{
typedef typename RcfClientT::Interface Interface;
std::string interfaceName = getInterfaceName( (Interface*) 0);
ClientStubPtr clientStubPtr(new ClientStub(interfaceName));
rcfClient.setClientStubPtr(clientStubPtr);
}
ar & rcfClient.getClientStub();
}
else
{
rcfClient.setClientStubPtr( ClientStubPtr());
}
}
}
void
Ethernet_getInterfaceMACAddress(const char* interfaceId, uint8_t* addr)
{
#ifdef __GNUC__
#ifndef __MINGW64_VERSION_MAJOR
if (!dllLoaded) {
loadDLLs();
dllLoaded = true;
}
#endif
#endif
char* endPtr;
long interfaceIndex = strtol(interfaceId, &endPtr, 10);
if (endPtr != NULL) {
printf("Ethernet_getInterfaceMACAddress: invalid interface number %s\n", interfaceId);
return;
}
char* interfaceName = getInterfaceName((int) interfaceIndex);
getAdapterMacAddress(interfaceName, addr);
}
shared_ptr<Interface> ThriftConfigApplier::updateInterface(
const shared_ptr<Interface>& orig,
const cfg::Interface* config,
const Interface::Addresses& addrs) {
CHECK_EQ(orig->getID(), config->intfID);
cfg::NdpConfig ndp;
if (config->__isset.ndp) {
ndp = config->ndp;
}
auto name = getInterfaceName(config);
auto mac = getInterfaceMac(config);
auto mtu = config->__isset.mtu ? config->mtu : Interface::kDefaultMtu;
if (orig->getRouterID() == RouterID(config->routerID) &&
orig->getVlanID() == VlanID(config->vlanID) &&
orig->getName() == name &&
orig->getMac() == mac &&
orig->getAddresses() == addrs &&
orig->getNdpConfig() == ndp &&
orig->getMtu() == mtu) {
// No change
return nullptr;
}
auto newIntf = orig->clone();
newIntf->setRouterID(RouterID(config->routerID));
newIntf->setVlanID(VlanID(config->vlanID));
newIntf->setName(name);
newIntf->setMac(mac);
newIntf->setAddresses(addrs);
newIntf->setNdpConfig(ndp);
newIntf->setMtu(mtu);
return newIntf;
}
bool endPublish(Interface *, const std::string &publisherName_ = "")
{
const std::string &publisherName = (publisherName_ == "") ?
getInterfaceName((Interface *) NULL) :
publisherName_;
return endPublishNamed(publisherName);
}
bool beginPublish(Interface *, const std::string &publisherName_ = "")
{
const std::string &publisherName = (publisherName_ == "") ?
getInterfaceName((Interface *) NULL) :
publisherName_;
typedef typename Interface::RcfClientT RcfClientT;
RcfClientPtr rcfClientPtr( new RcfClientT( ClientStub(publisherName)));
return beginPublishNamed(publisherName, rcfClientPtr);
}
typename Interface::RcfClientT &publish(
Interface *,
const std::string &publisherName_ = "")
{
const std::string &publisherName = (publisherName_ == "") ?
getInterfaceName( (Interface *) NULL) :
publisherName_;
return dynamic_cast<typename Interface::RcfClientT &>(
publishNamed(publisherName) );
}
bool bind(I1 *, I2 *, ImplementationT **, const std::string &name_ = "")
{
const std::string &name = (name_ == "") ?
getInterfaceName((I1 *) NULL) :
name_;
StubFactoryPtr stubFactoryPtr(
new RCF::StubFactory_2<ImplementationT, I1, I2>());
std::string desc;
return insertStubFactory(name, desc, stubFactoryPtr);
}
bool DBusObjectManagerStub::emitInterfacesRemovedSignal(std::shared_ptr<DBusStubAdapter> dbusStubAdapter,
const std::shared_ptr<DBusProxyConnection>& dbusConnection) const {
assert(dbusConnection);
assert(dbusConnection->isConnected());
const auto& dbusStubObjectPath = dbusStubAdapter->getObjectPath();
const auto& dbusStubInterfaceName = dbusStubAdapter->getInterfaceName();
DBusMessage dbusSignal = DBusMessage::createSignal(dbusObjectPath_, getInterfaceName(), "InterfacesRemoved", "oas");
DBusOutputStream dbusOutputStream(dbusSignal);
std::vector<std::string> removedInterfaces({ { dbusStubInterfaceName } });
if (dbusStubAdapter->isManagingInterface()) {
removedInterfaces.push_back(getInterfaceName());
}
dbusOutputStream << dbusStubObjectPath;
dbusOutputStream << removedInterfaces;
dbusOutputStream.flush();
const bool dbusSignalEmitted = dbusConnection->sendDBusMessage(dbusSignal);
return dbusSignalEmitted;
}
NwIface::NwIface()
{
int s, lerrno;
struct ifreq ifr;
struct sockaddr_in *sin(0);
if ((s = socket(AF_INET, SOCK_DGRAM, 0)) < 0)
{
OW_THROW(SocketException, "socket");
}
getInterfaceName(s);
bzero(&ifr, sizeof(ifr));
strncpy(ifr.ifr_name, m_name.c_str(), sizeof(ifr.ifr_name));
////////////////////
// Get IP address
if (ioctl(s, SIOCGIFADDR, &ifr) < 0)
{
lerrno = errno;
close(s);
OW_THROW(SocketException, "ioctl:SIOCGIFADDR");
}
sin = reinterpret_cast<struct sockaddr_in *>(&ifr.ifr_addr);
m_addr = sin->sin_addr.s_addr;
////////////////////
// Get the broadcast address
// Testing
if (ioctl(s, SIOCGIFBRDADDR, &ifr) < 0)
{
lerrno = errno;
close(s);
OW_THROW(SocketException, "ioctl:SIOCGIFBRDADDR");
}
sin = reinterpret_cast<struct sockaddr_in*>(&ifr.ifr_broadaddr);
m_bcastAddr = sin->sin_addr.s_addr;
////////////////////
// Get net mask
if (ioctl(s, SIOCGIFNETMASK, &ifr) < 0)
{
lerrno = errno;
close(s);
OW_THROW(SocketException, "ioctl:SIOCGIFNETMASK");
}
#ifdef OW_GNU_LINUX
sin = reinterpret_cast<struct sockaddr_in *>(&ifr.ifr_netmask);
#else
sin = reinterpret_cast<struct sockaddr_in *>(&ifr.ifr_broadaddr);
#endif
m_netmask = sin->sin_addr.s_addr;
close(s);
}
bool DBusObjectManagerStub::onInterfaceDBusMessage(const DBusMessage& dbusMessage) {
auto dbusConnection = dbusConnection_.lock();
if (!dbusConnection || !dbusConnection->isConnected()) {
return false;
}
if (!dbusMessage.isMethodCallType() || !dbusMessage.hasMemberName("GetManagedObjects")) {
return false;
}
std::lock_guard<std::mutex> dbusObjectManagerStubLock(dbusObjectManagerStubLock_);
DBusObjectPathAndInterfacesDict dbusObjectPathAndInterfacesDict;
for (const auto& registeredDBusObjectPathIterator : registeredDBusObjectPathsMap_) {
const std::string& registeredDBusObjectPath = registeredDBusObjectPathIterator.first;
const auto& registeredDBusInterfacesMap = registeredDBusObjectPathIterator.second;
DBusInterfacesAndPropertiesDict dbusInterfacesAndPropertiesDict;
assert(registeredDBusObjectPath.length() > 0);
assert(registeredDBusInterfacesMap.size() > 0);
for (const auto& registeredDBusInterfaceIterator : registeredDBusInterfacesMap) {
const std::string& registeredDBusInterfaceName = registeredDBusInterfaceIterator.first;
const auto& registeredDBusStubAdapter = registeredDBusInterfaceIterator.second;
assert(registeredDBusInterfaceName.length() > 0);
dbusInterfacesAndPropertiesDict.insert({ registeredDBusInterfaceName, DBusPropertiesChangedDict() });
if (registeredDBusStubAdapter->isManagingInterface()) {
dbusInterfacesAndPropertiesDict.insert({ getInterfaceName(), DBusPropertiesChangedDict() });
}
}
dbusObjectPathAndInterfacesDict.insert({ registeredDBusObjectPath, std::move(dbusInterfacesAndPropertiesDict) });
}
DBusMessage dbusMessageReply = dbusMessage.createMethodReturn("a{oa{sa{sv}}}");
DBusOutputStream dbusOutputStream(dbusMessageReply);
dbusOutputStream << dbusObjectPathAndInterfacesDict;
dbusOutputStream.flush();
const bool dbusMessageReplySent = dbusConnection->sendDBusMessage(dbusMessageReply);
return dbusMessageReplySent;
}
shared_ptr<Interface> ThriftConfigApplier::createInterface(
const cfg::Interface* config,
const Interface::Addresses& addrs) {
auto name = getInterfaceName(config);
auto mac = getInterfaceMac(config);
auto mtu = config->__isset.mtu ? config->mtu : Interface::kDefaultMtu;
auto intf = make_shared<Interface>(InterfaceID(config->intfID),
RouterID(config->routerID),
VlanID(config->vlanID),
name,
mac,
mtu);
intf->setAddresses(addrs);
if (config->__isset.ndp) {
intf->setNdpConfig(config->ndp);
}
return intf;
}
EthernetSocket
Ethernet_createSocket(const char* interfaceId, uint8_t* destAddress)
{
pcap_t *pcapSocket;
char errbuf[PCAP_ERRBUF_SIZE];
int interfaceIndex = atoi(interfaceId);
char* interfaceName = getInterfaceName(interfaceIndex);
if ((pcapSocket = pcap_open_live(interfaceName, 65536, PCAP_OPENFLAG_PROMISCUOUS, 10, errbuf)) == NULL)
{
printf("Open ethernet socket failed for device %s\n", interfaceName);
return NULL;
}
EthernetSocket ethernetSocket = (EthernetSocket) calloc(1, sizeof(struct sEthernetSocket));
ethernetSocket->rawSocket = pcapSocket;
return ethernetSocket;
}
void serialize(
Archive & ar,
RcfClientT & rcfClient,
const unsigned int)
{
typedef typename Archive::is_saving IsSaving;
const bool isSaving = IsSaving::value;
if (isSaving)
{
bool hasClientStub = rcfClient.mClientStubPtr;
ar & hasClientStub;
if (hasClientStub)
{
ar & rcfClient.getClientStub();
}
}
else //if (ar.isRead())
{
bool hasClientStub = false;
ar & hasClientStub;
if (hasClientStub)
{
if (!rcfClient.mClientStubPtr)
{
typedef typename RcfClientT::Interface Interface;
std::string interfaceName = getInterfaceName( (Interface*) 0);
ClientStubPtr clientStubPtr(new ClientStub(interfaceName));
rcfClient.setClientStubPtr(clientStubPtr);
}
ar & rcfClient.getClientStub();
}
else
{
rcfClient.setClientStubPtr( ClientStubPtr());
}
}
}
FutureImpl<Void> ClientStub::ping(const CallOptions & callOptions)
{
typedef Void V;
CurrentClientStubSentry sentry(*this);
setAsync(false);
return RCF::FutureImpl<V>(
::RCF::AllocateClientParameters<
V
,
V,V,V,V,V,V,V,V,V,V,V,V,V,V,V >()(
*this
,
V(),V(),V(),V(),V(),V(),V(),V(),V(),V(),V(),V(),V(),V(),V()).r.get(),
*this,
getInterfaceName(),
-1,
callOptions.apply(*this),
"ping",
"V0");
}
Properties::Properties(const QString &objectPath,
const QString &interface,
QObject *parent)
: SystemBusInterface(parent),
mObjectPath(objectPath),
mInterface(interface)
{
qDebug() << "Connected" <<
QDBusConnection::systemBus().connect(getServiceName(), getObjectPath(), getInterfaceName(), "PropertiesChanged", this, SLOT(PropertiesChanged(QString,QMap<QString,QVariant>,QList<QString>)));
}
