status_t
add_interface(const char* name, net_domain_private* domain,
const ifaliasreq& request, net_device_interface* deviceInterface)
{
RecursiveLocker locker(sLock);
if (find_interface(name) != NULL)
return B_NAME_IN_USE;
Interface* interface
= new(std::nothrow) Interface(name, deviceInterface);
if (interface == NULL)
return B_NO_MEMORY;
sInterfaces.Add(interface);
interface->AcquireReference();
// We need another reference to be able to use the interface without
// holding sLock.
locker.Unlock();
status_t status = add_interface_address(interface, domain, request);
if (status == B_OK)
notify_interface_added(interface);
else {
locker.Lock();
sInterfaces.Remove(interface);
locker.Unlock();
interface->ReleaseReference();
}
interface->ReleaseReference();
return status;
}
void VrrpManager::removeVrrpInterfaces ()
{
InterfaceList interfaces = Netlink::interfaces();
for (InterfaceList::const_iterator interface = interfaces.begin(); interface != interfaces.end(); ++interface)
{
if (interface->second.substr(0, 4) == "vrrp")
Netlink::removeInterface(interface->first);
}
}
std::vector<IComponent*> CComponentManager::Script_GetComponentsWithInterface(void* cbdata, int iid)
{
CComponentManager* componentManager = static_cast<CComponentManager*> (cbdata);
std::vector<IComponent*> ret;
InterfaceList ents = componentManager->GetEntitiesWithInterface(iid);
for (InterfaceList::const_iterator it = ents.begin(); it != ents.end(); ++it)
ret.push_back(it->second); // TODO: maybe we should exclude local entities
return ret;
}
const CallManager::InterfaceList CallManager::get_interfaces () const
{
InterfaceList list;
for (CallManager::iterator iter = begin ();
iter != end ();
iter++)
list.push_back ((*iter)->get_listen_interface ());
return list;
}
void QBluetoothDeviceDiscoveryAgentPrivate::startBluez5()
{
Q_Q(QBluetoothDeviceDiscoveryAgent);
bool ok = false;
const QString adapterPath = findAdapterForAddress(m_adapterAddress, &ok);
if (!ok || adapterPath.isEmpty()) {
qCWarning(QT_BT_BLUEZ) << "Cannot find Bluez 5 adapter for device search" << ok;
lastError = QBluetoothDeviceDiscoveryAgent::InputOutputError;
errorString = QBluetoothDeviceDiscoveryAgent::tr("Cannot find valid Bluetooth adapter.");
q->error(lastError);
return;
}
adapterBluez5 = new OrgBluezAdapter1Interface(QStringLiteral("org.bluez"),
adapterPath,
QDBusConnection::systemBus());
if (!adapterBluez5->powered()) {
qCDebug(QT_BT_BLUEZ) << "Aborting device discovery due to offline Bluetooth Adapter";
lastError = QBluetoothDeviceDiscoveryAgent::PoweredOffError;
errorString = QBluetoothDeviceDiscoveryAgent::tr("Device is powered off");
delete adapterBluez5;
adapterBluez5 = 0;
emit q->error(lastError);
return;
}
QtBluezDiscoveryManager::instance()->registerDiscoveryInterest(adapterBluez5->path());
QObject::connect(QtBluezDiscoveryManager::instance(), SIGNAL(discoveryInterrupted(QString)),
q, SLOT(_q_discoveryInterrupted(QString)));
// collect initial set of information
QDBusPendingReply<ManagedObjectList> reply = managerBluez5->GetManagedObjects();
reply.waitForFinished();
if (!reply.isError()) {
foreach (const QDBusObjectPath &path, reply.value().keys()) {
const InterfaceList ifaceList = reply.value().value(path);
foreach (const QString &iface, ifaceList.keys()) {
if (iface == QStringLiteral("org.bluez.Device1")) {
if (path.path().indexOf(adapterBluez5->path()) != 0)
continue; //devices whose path doesn't start with same path we skip
deviceFoundBluez5(path.path());
}
}
}
}
QString QBluetoothSocketPrivate::peerName() const
{
quint64 bdaddr;
if (socketType == QBluetoothServiceInfo::RfcommProtocol) {
sockaddr_rc addr;
socklen_t addrLength = sizeof(addr);
if (::getpeername(socket, reinterpret_cast<sockaddr *>(&addr), &addrLength) < 0)
return QString();
convertAddress(addr.rc_bdaddr.b, bdaddr);
} else if (socketType == QBluetoothServiceInfo::L2capProtocol) {
sockaddr_l2 addr;
socklen_t addrLength = sizeof(addr);
if (::getpeername(socket, reinterpret_cast<sockaddr *>(&addr), &addrLength) < 0)
return QString();
convertAddress(addr.l2_bdaddr.b, bdaddr);
} else {
qCWarning(QT_BT_BLUEZ) << "peerName() called on socket of unknown type";
return QString();
}
const QString peerAddress = QBluetoothAddress(bdaddr).toString();
const QString localAdapter = localAddress().toString();
if (isBluez5()) {
OrgFreedesktopDBusObjectManagerInterface manager(QStringLiteral("org.bluez"),
QStringLiteral("/"),
QDBusConnection::systemBus());
QDBusPendingReply<ManagedObjectList> reply = manager.GetManagedObjects();
reply.waitForFinished();
if (reply.isError())
return QString();
foreach (const QDBusObjectPath &path, reply.value().keys()) {
const InterfaceList ifaceList = reply.value().value(path);
foreach (const QString &iface, ifaceList.keys()) {
if (iface == QStringLiteral("org.bluez.Device1")) {
if (ifaceList.value(iface).value(QStringLiteral("Address")).toString()
== peerAddress)
return ifaceList.value(iface).value(QStringLiteral("Alias")).toString();
}
}
}
return QString();
} else {
uint32
count_interfaces()
{
RecursiveLocker locker(sLock);
return sInterfaces.Count();
}
/*! Returns a reference to an Interface that matches the given \a linkAddress.
The link address is checked against its hardware address, or its interface
name, or finally the interface index.
*/
Interface*
get_interface_for_link(net_domain* domain, const sockaddr* _linkAddress)
{
sockaddr_dl& linkAddress = *(sockaddr_dl*)_linkAddress;
RecursiveLocker locker(sLock);
InterfaceList::Iterator iterator = sInterfaces.GetIterator();
while (Interface* interface = iterator.Next()) {
if (interface->IsBusy())
continue;
// Test if the hardware address matches, or if the given interface
// matches, or if at least the index matches.
if ((linkAddress.sdl_alen == interface->device->address.length
&& memcmp(LLADDR(&linkAddress), interface->device->address.data,
linkAddress.sdl_alen) == 0)
|| (linkAddress.sdl_nlen > 0
&& !strcmp(interface->name, (const char*)linkAddress.sdl_data))
|| (linkAddress.sdl_nlen == 0 && linkAddress.sdl_alen == 0
&& linkAddress.sdl_index == interface->index)) {
if (interface->IsBusy())
return NULL;
if (interface->CreateDomainDatalinkIfNeeded(domain) != B_OK)
return NULL;
interface->AcquireReference();
return interface;
}
}
return NULL;
}
/*! Returns a reference to an InterfaceAddress of the specified \a domain that
belongs to the interface identified via \a linkAddress. Only the hardware
address is matched.
If \a unconfiguredOnly is set, the interface address must not yet be
configured, or must currently be in the process of being configured.
*/
InterfaceAddress*
get_interface_address_for_link(net_domain* domain, const sockaddr* address,
bool unconfiguredOnly)
{
sockaddr_dl& linkAddress = *(sockaddr_dl*)address;
RecursiveLocker locker(sLock);
InterfaceList::Iterator iterator = sInterfaces.GetIterator();
while (Interface* interface = iterator.Next()) {
if (interface->IsBusy())
continue;
// Test if the hardware address matches, or if the given interface
// matches, or if at least the index matches.
if (linkAddress.sdl_alen == interface->device->address.length
&& memcmp(LLADDR(&linkAddress), interface->device->address.data,
linkAddress.sdl_alen) == 0) {
TRACE(" %s matches\n", interface->name);
// link address matches
if (unconfiguredOnly)
return interface->FirstUnconfiguredForFamily(domain->family);
return interface->FirstForFamily(domain->family);
}
}
return NULL;
}
static int
dump_interfaces(int argc, char** argv)
{
InterfaceList::Iterator iterator = sInterfaces.GetIterator();
while (Interface* interface = iterator.Next()) {
kprintf("%p %s\n", interface, interface->name);
}
return 0;
}
//! For debugging purposes only
void
dump_interface_refs(void)
{
RecursiveLocker locker(sLock);
InterfaceList::Iterator iterator = sInterfaces.GetIterator();
while (Interface* interface = iterator.Next()) {
dprintf("%p: %s, %ld\n", interface, interface->name,
interface->CountReferences());
}
}
/*! Searches for a specific interface by index.
You need to have the interface list's lock hold when calling this function.
*/
static struct Interface*
find_interface(uint32 index)
{
InterfaceList::Iterator iterator = sInterfaces.GetIterator();
while (Interface* interface = iterator.Next()) {
if (interface->index == index)
return interface;
}
return NULL;
}
/*! Searches for a specific interface by name.
You need to have the interface list's lock hold when calling this function.
*/
static struct Interface*
find_interface(const char* name)
{
ASSERT_LOCKED_RECURSIVE(&sLock);
InterfaceList::Iterator iterator = sInterfaces.GetIterator();
while (Interface* interface = iterator.Next()) {
if (!strcmp(interface->name, name))
return interface;
}
return NULL;
}
void NeardHelper::interfacesAdded(const QDBusObjectPath &path, InterfaceList interfaceList)
{
foreach (const QString &key, interfaceList.keys()) {
if (key == QStringLiteral("org.neard.Tag")) {
emit tagFound(path);
break;
}
if (key == QStringLiteral("org.neard.Record")) {
emit recordFound(path);
break;
}
}
}
/*! Removes the interface from the list, and puts the stack's reference to it.
*/
void
remove_interface(Interface* interface)
{
interface->SetDown();
interface->RemoveAddresses();
RecursiveLocker locker(sLock);
sInterfaces.Remove(interface);
locker.Unlock();
notify_interface_removed(interface);
interface->ReleaseReference();
}
// TODO We need a constructor that lets us select an adapter
QNearFieldManagerPrivateImpl::QNearFieldManagerPrivateImpl()
: QNearFieldManagerPrivate(),
m_neardHelper(NeardHelper::instance())
{
QDBusPendingReply<ManagedObjectList> reply = m_neardHelper->dbusObjectManager()->GetManagedObjects();
reply.waitForFinished();
if (reply.isError()) {
qCWarning(QT_NFC_NEARD) << "Error getting managed objects";
return;
}
bool found = false;
foreach (const QDBusObjectPath &path, reply.value().keys()) {
const InterfaceList ifaceList = reply.value().value(path);
foreach (const QString &iface, ifaceList.keys()) {
if (iface == QStringLiteral("org.neard.Adapter")) {
found = true;
m_adapterPath = path.path();
qCDebug(QT_NFC_NEARD) << "org.neard.Adapter found for path" << m_adapterPath;
break;
}
}
if (found)
break;
}
if (!found) {
qCWarning(QT_NFC_NEARD) << "no adapter found, neard daemon running?";
} else {
connect(m_neardHelper, SIGNAL(tagFound(QDBusObjectPath)),
this, SLOT(handleTagFound(QDBusObjectPath)));
connect(m_neardHelper, SIGNAL(tagRemoved(QDBusObjectPath)),
this, SLOT(handleTagRemoved(QDBusObjectPath)));
}
}
Interface*
get_interface(net_domain* domain, uint32 index)
{
RecursiveLocker locker(sLock);
Interface* interface;
if (index == 0)
interface = sInterfaces.First();
else
interface = find_interface(index);
if (interface == NULL || interface->IsBusy())
return NULL;
if (interface->CreateDomainDatalinkIfNeeded(domain) != B_OK)
return NULL;
interface->AcquireReference();
return interface;
}
/*! Dumps a list of all interfaces into the supplied userland buffer.
If the interfaces don't fit into the buffer, an error (\c ENOBUFS) is
returned.
*/
status_t
list_interfaces(int family, void* _buffer, size_t* bufferSize)
{
RecursiveLocker locker(sLock);
UserBuffer buffer(_buffer, *bufferSize);
InterfaceList::Iterator iterator = sInterfaces.GetIterator();
while (Interface* interface = iterator.Next()) {
// Copy name
buffer.Push(interface->name, IF_NAMESIZE);
// Copy address
InterfaceAddress* address = interface->FirstForFamily(family);
size_t length = 0;
if (address != NULL && address->local != NULL) {
// Actual address
buffer.Push(address->local, length = address->local->sa_len);
} else {
// Empty address
sockaddr empty;
empty.sa_len = 2;
empty.sa_family = AF_UNSPEC;
buffer.Push(&empty, length = empty.sa_len);
}
if (address != NULL)
address->ReleaseReference();
if (IF_NAMESIZE + length < sizeof(ifreq)) {
// Make sure at least sizeof(ifreq) bytes are written for each
// interface for compatibility with other platforms
buffer.Pad(sizeof(ifreq) - IF_NAMESIZE - length);
}
if (buffer.Status() != B_OK)
return buffer.Status();
}
*bufferSize = buffer.BytesConsumed();
return B_OK;
}
InterfaceAddress*
get_interface_address_for_destination(net_domain* domain,
const sockaddr* destination)
{
RecursiveLocker locker(sLock);
InterfaceList::Iterator iterator = sInterfaces.GetIterator();
while (Interface* interface = iterator.Next()) {
if (interface->IsBusy())
continue;
InterfaceAddress* address
= interface->AddressForDestination(domain, destination);
if (address != NULL)
return address;
}
return NULL;
}
Interface*
get_interface_for_device(net_domain* domain, uint32 index)
{
RecursiveLocker locker(sLock);
InterfaceList::Iterator iterator = sInterfaces.GetIterator();
while (Interface* interface = iterator.Next()) {
if (interface->device->index == index) {
if (interface->IsBusy())
return NULL;
if (interface->CreateDomainDatalinkIfNeeded(domain) != B_OK)
return NULL;
interface->AcquireReference();
return interface;
}
}
return NULL;
}
static int
dump_interface(int argc, char** argv)
{
if (argc != 2) {
kprintf("usage: %s [name|address]\n", argv[0]);
return 0;
}
Interface* interface = NULL;
InterfaceList::Iterator iterator = sInterfaces.GetIterator();
while ((interface = iterator.Next()) != NULL) {
if (!strcmp(argv[1], interface->name))
break;
}
if (interface == NULL)
interface = (Interface*)parse_expression(argv[1]);
interface->Dump();
return 0;
}
ReflectPair runABM(int nSamples, double azimuthalAngle,
double polarAngle, bool disableSieve, InterfaceList &interfaceList) {
int startState;
int reflectedState;
int transmittedState;
int absorbedState = -2;
int numReflected = 0;
int numTransmitted = 0;
int numAbsorbed = 0;
double sp = sin(polarAngle);
vec3 startingPosition(
cos(azimuthalAngle)*sp,
sin(azimuthalAngle)*sp,
cos(polarAngle)
);
startingPosition.z *= -1; /* Leaf interfaces are listed adaxial-first,
orientation is generally assumed with respect to abaxial */
if(startingPosition.z < 0) {
startState = 0;
reflectedState = -1;
transmittedState = interfaceList.size();
} else {
startState = interfaceList.size() - 1;
reflectedState = startState + 1;
transmittedState = -1;
}
for(int i = 0; i < nSamples; i++) {
vec3 direction(startingPosition);
int state = startState;
interfaceList.prepareForSample();
while(state != reflectedState && state != transmittedState && state != absorbedState) {
const ABMInterface &interface = interfaceList.getInterface(state);
double n1;
double n2;
double perturbanceReflect;
double perturbanceRefract;
int reflectState;
int refractState;
double thickness;
double absorption;
vec3 normal(0,0,0);
if(direction.z < 0) {
normal.z = 1.0;
n1 = interface.nAbove;
n2 = interface.nBelow;
perturbanceReflect = interface.perturbanceDownAbove;
perturbanceRefract = interface.perturbanceDownBelow;
refractState = state + 1;
reflectState = state - 1;
thickness = interface.thicknessAbove;
absorption = interface.absorptionAbove;
} else {
normal.z = -1.0;
n1 = interface.nBelow;
n2 = interface.nAbove;
perturbanceReflect = interface.perturbanceUpBelow;
perturbanceRefract = interface.perturbanceUpAbove;
reflectState = state + 1;
refractState = state - 1;
thickness = interface.thicknessBelow;
absorption = interface.absorptionBelow;
}
double normalAngle = -direction.Dot(normal);
if(thickness > 0 && freePathLength(direction, normal, normalAngle, absorption, disableSieve) < thickness) {
state = absorbedState;
break;
} else {
if(RANDOM_FUNCTION() < fresnellCoefficient(direction, normal, normalAngle, n1, n2)) {
state = reflectState;
direction = reflect(direction, normal, normalAngle);
if(perturbanceReflect != INFINITY) {
direction = brakkeScattering(direction, perturbanceReflect);
}
} else {
state = refractState;
direction = refract(direction, normal, normalAngle, n1, n2);
if(perturbanceRefract != INFINITY) {
direction = brakkeScattering(direction, perturbanceRefract);
}
}
}
}
if(state == reflectedState) {
numReflected++;
} else if(state == transmittedState) {
numTransmitted++;
} else {
numAbsorbed++;
}
}
return ReflectPair((double)numReflected / nSamples, (double)numTransmitted / nSamples);
}