void NetworkAdapterList::TraceAdapter(const TChar* aPrefix, NetworkAdapter& aAdapter)
{ // static
Endpoint ep(0, aAdapter.Address());
Bws<Endpoint::kMaxAddressBytes> addr;
ep.AppendAddress(addr);
LOG(kTrace, "%s: %s(%s)\n", aPrefix, aAdapter.Name(), (const TChar*)addr.Ptr());
}
void MdnsPlatform::SubnetListChanged()
{
iInterfacesLock.Wait();
NetworkAdapter* current = iEnv.NetworkAdapterList().CurrentAdapter(kNifCookie);
NetworkAdapterList& nifList = iEnv.NetworkAdapterList();
std::vector<NetworkAdapter*>* subnetList = nifList.CreateSubnetList();
for (TInt i=(TInt)iInterfaces.size()-1; i>=0; i--) {
// Remove adapters with subnets no longer available and which don't
// match the currently selected adapter (if there is one).
if (InterfaceIndex(iInterfaces[i]->Adapter(), *subnetList) == -1
|| (current != NULL && current->Address() != iInterfaces[i]->Adapter().Address())) {
mDNS_DeregisterInterface(iMdns, &iInterfaces[i]->Info(), false);
delete iInterfaces[i];
iInterfaces.erase(iInterfaces.begin()+i);
}
}
if (current == NULL) { // no adapter selected; add new subnets
for (TUint i=0; i<(TUint)subnetList->size(); i++) {
NetworkAdapter* nif = (*subnetList)[i];
if (InterfaceIndex(*nif) == -1) {
AddInterface(nif);
}
}
}
if (current != NULL) {
if (iInterfaces.size() == 0) { // current adapter is on a newly added subnet
AddInterface(current);
iClient.SetMulticastIf(current->Address());
}
current->RemoveRef(kNifCookie);
}
iInterfacesLock.Signal();
nifList.DestroySubnetList(subnetList);
}
TBool CpiDeviceListUpnp::IsLocationReachable(const Brx& aLocation) const
{
/* linux's filtering of multicast messages appears to be buggy and messages
received by all interfaces are sometimes delivered to sockets which are
bound to / members of a group on a single (different) interface. It'd be
more correct to filter these out in SsdpListenerMulticast but that would
require API changes which would be more inconvenient than just moving the
filtering here.
This should be reconsidered if we ever add more clients of SsdpListenerMulticast */
TBool reachable = false;
Uri uri;
try {
uri.Replace(aLocation);
}
catch (UriError&) {
return false;
}
iLock.Wait();
Endpoint endpt(0, uri.Host());
NetworkAdapter* nif = iCpStack.Env().NetworkAdapterList().CurrentAdapter("CpiDeviceListUpnp::IsLocationReachable");
if (nif != NULL) {
if (nif->Address() == iInterface && nif->ContainsAddress(endpt.Address())) {
reachable = true;
}
nif->RemoveRef("CpiDeviceListUpnp::IsLocationReachable");
}
iLock.Signal();
return reachable;
}
void DviProtocolUpnp::GetResourceManagerUri(const NetworkAdapter& aAdapter, Brh& aUri)
{
if (iDevice.ResourceManager() == NULL) {
return;
}
for (TUint i=0; i<(TUint)iAdapters.size(); i++) {
if (iAdapters[i]->Interface() == aAdapter.Address()) {
WriterBwh writer(1024);
writer.Write("http://");
Bws<Endpoint::kMaxEndpointBytes> buf;
Endpoint ep(iAdapters[i]->ServerPort(), aAdapter.Address());
ep.AppendEndpoint(buf);
writer.Write(buf);
writer.Write('/');
Uri::Escape(writer, iDevice.Udn());
writer.Write('/');
writer.Write(kProtocolName);
writer.Write('/');
writer.Write(iDevice.kResourceDir);
writer.Write('/');
writer.TransferTo(aUri);
return;
}
}
}
MdnsPlatform::Status MdnsPlatform::Init()
{
LOG(kBonjour, "Bonjour Init\n");
LOG(kBonjour, "Bonjour Init - Set FQDN\n");
DoSetHostName();
LOG(kBonjour, "Bonjour Init - Register Interface\n");
iInterfacesLock.Wait();
Status status = mStatus_NoError;
NetworkAdapterList& nifList = iEnv.NetworkAdapterList();
Functor functorSubnet = MakeFunctor(*this, &MdnsPlatform::SubnetListChanged);
iSubnetListChangeListenerId = nifList.AddSubnetListChangeListener(functorSubnet, "MdnsPlatform-subnet");
Functor functorAdapter = MakeFunctor(*this, &MdnsPlatform::CurrentAdapterChanged);
iCurrentAdapterChangeListenerId = nifList.AddCurrentChangeListener(functorAdapter, "MdnsPlatform-current");
NetworkAdapter* current = iEnv.NetworkAdapterList().CurrentAdapter(kNifCookie);
if (current == NULL) { // Listening on all adapters.
std::vector<NetworkAdapter*>* subnetList = nifList.CreateSubnetList();
for (TUint i=0; i<(TUint)subnetList->size() && status==mStatus_NoError; i++) {
status = AddInterface((*subnetList)[i]);
}
nifList.DestroySubnetList(subnetList);
}
else { // Using a single adapter.
status = AddInterface(current);
iClient.SetMulticastIf(current->Address());
current->RemoveRef(kNifCookie);
}
iInterfacesLock.Signal();
if (status == mStatus_NoError) {
mDNSCoreInitComplete(iMdns, status);
}
return status;
}
TBool MdnsPlatform::NifsMatch(const NetworkAdapter& aNif1, const NetworkAdapter& aNif2)
{
if (aNif1.Address() == aNif2.Address() && aNif1.Subnet() == aNif2.Subnet() && strcmp(aNif1.Name(), aNif2.Name()) == 0) {
return true;
}
return false;
}
void SuiteAlive::Test()
{
Environment& env = iDvStack.Env();
Blocker* blocker = new Blocker(env);
CpListenerBasic* listener = new CpListenerBasic;
NetworkAdapter* nif = env.NetworkAdapterList().CurrentAdapter(kAdapterCookie);
SsdpListenerMulticast* listenerMulticast = new SsdpListenerMulticast(env, nif->Address());
nif->RemoveRef(kAdapterCookie);
TInt listenerId = listenerMulticast->AddNotifyHandler(listener);
listenerMulticast->Start();
DviDevice* device = new DviDeviceStandard(iDvStack, gNameDevice1);
device->SetAttribute("Upnp.Domain", "a.b.c");
device->SetAttribute("Upnp.Type", "type1");
device->SetAttribute("Upnp.Version", "1");
AddService(device, new DviService(iDvStack, "a.b.c", "service1", 1));
AddService(device, new DviService(iDvStack, "a.b.c", "service2", 1));
device->SetEnabled();
blocker->Wait(1);
/* we expect 5 messages but linux sometimes reports multicast messages from
all subnets to listeners on any single subnet so just check that we've
received a multiple of 5 messages */
TEST(listener->TotalAlives() > 0);
TEST(listener->TotalAlives() == listener->TotalByeByes());
TEST(listener->TotalAlives() % 5 == 0);
TUint byebyes = listener->TotalByeByes();
Functor disabled = MakeFunctor(*this, &SuiteAlive::Disabled);
device->SetDisabled(disabled);
iSem.Wait();
blocker->Wait(1); /* semaphore being signalled implies that the device has been
disabled. We may require some extra time to receive the
multicast byebye confirming this */
TEST(listener->TotalByeByes() > byebyes);
TEST(listener->TotalByeByes() % 5 == 0);
TUint alives = listener->TotalAlives();
byebyes = listener->TotalByeByes();
device->SetEnabled();
blocker->Wait(1);
TEST(listener->TotalAlives() > alives);
TEST(listener->TotalAlives() - alives == listener->TotalByeByes() - byebyes);
TEST(listener->TotalAlives() % 5 == 0);
// Control point doesn't process ssdp:update notifications
// check that updates are basically working by counting the extra alive messages instead
alives = listener->TotalAlives();
device->SetAttribute("Upnp.TestUpdate", "1");
blocker->Wait(1);
TEST(listener->TotalAlives() > alives);
TEST(listener->TotalAlives() % 5 == 0);
device->Destroy();
listenerMulticast->RemoveNotifyHandler(listenerId);
delete listenerMulticast;
delete listener;
delete blocker;
}
void CpiSubscription::DoSubscribe()
{
CpStack& cpStack = iDevice.GetCpStack();
Bws<Uri::kMaxUriBytes> uri;
uri.Append(Http::kSchemeHttp);
NetworkAdapter* nif = cpStack.Env().NetworkAdapterList().CurrentAdapter("CpiSubscription::DoSubscribe");
if (nif == NULL) {
THROW(NetworkError);
}
TIpAddress nifAddr = nif->Address();
nif->RemoveRef("CpiSubscription::DoSubscribe");
Endpoint endpt(cpStack.SubscriptionManager().EventServerPort(), nifAddr);
Endpoint::EndpointBuf buf;
endpt.AppendEndpoint(buf);
uri.Append(buf);
uri.Append('/');
Uri subscriber(uri);
LOG(kEvent, "Subscribing - service = ");
LOG(kEvent, iServiceType.FullName());
LOG(kEvent, "\n subscriber = ");
LOG(kEvent, subscriber.AbsoluteUri());
LOG(kEvent, "\n");
iNextSequenceNumber = 0;
TUint renewSecs;
try {
renewSecs = iDevice.Subscribe(*this, subscriber);
}
catch (XmlError&) {
// we don't expect to ever get here. Its worth capturing some debug info if we do.
Brh deviceXml;
if (!iDevice.GetAttribute("Upnp.DeviceXml", deviceXml)) {
deviceXml.Set("[missing]");
}
const Brx& udn = iDevice.Udn();
cpStack.Env().Mutex().Wait();
Log::Print("XmlError attempting to subscribe to device ");
Log::Print(udn);
Log::Print(", with xml\n\n");
Log::Print(deviceXml);
Log::Print("\n\n");
cpStack.Env().Mutex().Signal();
THROW(XmlError);
}
cpStack.SubscriptionManager().Add(*this);
LOG(kEvent, "Subscription for ");
LOG(kEvent, iServiceType.FullName());
LOG(kEvent, " completed\n Sid is ");
LOG(kEvent, iSid);
LOG(kEvent, "\n Renew in %u secs\n", renewSecs);
SetRenewTimer(renewSecs);
}
void DviProtocolUpnp::HandleInterfaceChange()
{
TBool update = false;
std::vector<DviProtocolUpnpAdapterSpecificData*> pendingDelete;
{
const TIpAddress kLoopbackAddr = MakeIpAddress(127, 0, 0, 1);
AutoMutex a(iLock);
NetworkAdapterList& adapterList = iDvStack.Env().NetworkAdapterList();
AutoNetworkAdapterRef ref(iDvStack.Env(), "DviProtocolUpnp::HandleInterfaceChange");
const NetworkAdapter* current = ref.Adapter();
TUint i = 0;
std::vector<NetworkAdapter*>* subnetList = adapterList.CreateSubnetList();
std::vector<NetworkAdapter*>* adapters = adapterList.CreateNetworkAdapterList();
// remove listeners whose interface is no longer available
while (i<iAdapters.size()) {
if (FindAdapter(iAdapters[i]->Interface(), *adapters) != -1
&& (!adapterList.SingleSubnetModeEnabled() ||
(current != NULL && iAdapters[i]->Interface() == current->Address()) ||
iAdapters[i]->Interface() == kLoopbackAddr)) {
i++;
}
else {
iAdapters[i]->SetPendingDelete();
pendingDelete.push_back(iAdapters[i]);
iAdapters.erase(iAdapters.begin() + i);
}
}
// add listeners for new subnets
for (i=0; i<subnetList->size(); i++) {
NetworkAdapter* subnet = (*subnetList)[i];
if (FindListenerForSubnet(subnet->Subnet()) == -1) {
AddInterface(*subnet);
update = iDevice.Enabled();
}
}
NetworkAdapterList::DestroyNetworkAdapterList(adapters);
NetworkAdapterList::DestroySubnetList(subnetList);
if (update) {
// halt any ssdp broadcasts/responses that are currently in progress
// (in case they're for a subnet that's no longer valid)
// they'll be advertised again by the SendUpdateNotifications() call below
iDvStack.SsdpNotifierManager().Stop(iDevice.Udn());
}
}
for (TUint i=0; i<pendingDelete.size(); i++) {
pendingDelete[i]->Destroy();
}
if (update) {
SendUpdateNotifications();
}
}
/*
void NetworkAdapterList::TempFailureRetry(Functor& aCallback)
{ // static
static const TUint kDelaysMs[] = { 100, 200, 400, 800, 1600, 3200, 5000, 10000, 20000, 20000, 30000 }; // roughly 90s worth of retries
for (TUint i=0; i<sizeof(kDelaysMs)/sizeof(kDelaysMs[0]); i++) {
try {
aCallback();
return;
}
catch (NetworkError&) {
LOG2(kNetwork, kError, "TempFailureRetry: error handling adapter change, try again in %ums\n", kDelaysMs[i]);
Thread::Sleep(kDelaysMs[i]);
}
}
THROW(NetworkError);
}
*/
std::vector<NetworkAdapter*>* NetworkAdapterList::CreateSubnetListLocked() const
{
std::vector<NetworkAdapter*>* list = new std::vector<NetworkAdapter*>;
for (TUint i=0; i<iNetworkAdapters->size(); i++) {
NetworkAdapter* nif = (*iNetworkAdapters)[i];
TIpAddress subnet = nif->Subnet();
if (-1 == NetworkAdapterList::FindSubnet(subnet, *list)) {
nif->AddRef("NetworkAdapterList");
list->push_back(nif);
}
}
return list;
}
SuiteMsearch::SuiteMsearch()
: Suite("Msearches")
{
RandomiseUdn(gNameDevice1);
RandomiseUdn(gNameDevice2);
RandomiseUdn(gNameDevice2Embedded1);
iBlocker = new Blocker;
iListener = new CpListenerMsearch;
NetworkAdapter* nif = Stack::NetworkAdapterList().CurrentAdapter(kAdapterCookie);
iListenerUnicast = new SsdpListenerUnicast(*iListener, nif->Address());
nif->RemoveRef(kAdapterCookie);
iListenerUnicast->Start();
}
void DviServer::SubnetListChanged()
{
/* DviProtocolUpnp relies on servers being available on all appropriate interfaces.
We assume this happens through DviServer being created before any devices
so registering for subnet change notification earlier. Assuming NetworkAdapterList
always runs its listeners in the order they registered, we'll have updated before
any device listeners are run. */
AutoMutex a(iLock);
NetworkAdapterList& adapterList = iDvStack.Env().NetworkAdapterList();
AutoNetworkAdapterRef ref(iDvStack.Env(), "DviServer::SubnetListChanged");
NetworkAdapter* current = ref.Adapter();
if (adapterList.SingleSubnetModeEnabled()) {
TInt i;
// remove servers whose interface is no longer available
for (i = (TInt)iServers.size() - 1; i >= 0; i--) {
DviServer::Server* server = iServers[i];
if (current == NULL || server->Interface() != current->Address()) {
delete server;
iServers.erase(iServers.begin() + i);
}
}
// add server if 'current' is a new subnet
if (current != NULL && iServers.size() == 0) {
AddServer(*current);
}
}
else {
std::vector<NetworkAdapter*>* subnetList = adapterList.CreateSubnetList();
std::vector<NetworkAdapter*>* nifList = adapterList.CreateNetworkAdapterList();
TInt i;
// remove servers whose interface is no longer available
for (i = (TInt)iServers.size() - 1; i >= 0; i--) {
DviServer::Server* server = iServers[i];
if (FindInterface(server->Interface(), *nifList) == -1) {
delete server;
iServers.erase(iServers.begin() + i);
}
}
// add servers for new subnets
for (i = 0; i < (TInt)subnetList->size(); i++) {
NetworkAdapter* subnet = (*subnetList)[i];
if (FindServer(subnet->Subnet()) == -1) {
AddServer(*subnet);
}
}
NetworkAdapterList::DestroyNetworkAdapterList(nifList);
NetworkAdapterList::DestroySubnetList(subnetList);
}
}
static void RandomiseUdn(Bwh& aUdn)
{
aUdn.Grow(aUdn.Bytes() + 1 + Ascii::kMaxUintStringBytes + 1);
aUdn.Append('-');
Bws<Ascii::kMaxUintStringBytes> buf;
NetworkAdapter* nif = Stack::NetworkAdapterList().CurrentAdapter(kAdapterCookie);
TUint max = nif->Address();
TUint seed = DviStack::ServerUpnp().Port(nif->Address());
SetRandomSeed(seed);
nif->RemoveRef(kAdapterCookie);
(void)Ascii::AppendDec(buf, Random(max));
aUdn.Append(buf);
aUdn.PtrZ();
}
std::vector<NetworkAdapter*>* NetworkAdapterList::CreateNetworkAdapterList() const
{
iListLock.Wait();
std::vector<NetworkAdapter*>* list = new std::vector<NetworkAdapter*>;
for (TUint i=0; i<iNetworkAdapters->size(); i++) {
NetworkAdapter* nif = (*iNetworkAdapters)[i];
nif->AddRef("NetworkAdapterList");
list->push_back(nif);
}
iListLock.Signal();
return list;
}
DviProtocolUpnpAdapterSpecificData::DviProtocolUpnpAdapterSpecificData(DvStack& aDvStack, IUpnpMsearchHandler& aMsearchHandler, const NetworkAdapter& aAdapter, Bwx& aUriBase, TUint aServerPort)
: iRefCount(1)
, iDvStack(aDvStack)
, iMsearchHandler(&aMsearchHandler)
, iId(0x7fffffff)
, iSubnet(aAdapter.Subnet())
, iAdapter(aAdapter.Address())
, iUriBase(aUriBase)
, iServerPort(aServerPort)
, iBonjourWebPage(0)
, iDevice(NULL)
{
iListener = &(iDvStack.Env().MulticastListenerClaim(aAdapter.Address()));
iId = iListener->AddMsearchHandler(this);
}
void MdnsPlatform::CurrentAdapterChanged()
{
iInterfacesLock.Wait();
NetworkAdapter* current = iEnv.NetworkAdapterList().CurrentAdapter(kNifCookie);
NetworkAdapterList& nifList = iEnv.NetworkAdapterList();
std::vector<NetworkAdapter*>* subnetList = nifList.CreateSubnetList();
if (current != NULL) {
// Remove existing interface(s) if not belonging to current adapter,
// then add current adapter if it didn't exist before.
for (TInt i=(TInt)iInterfaces.size()-1; i>=0; i--) {
if (InterfaceIndex(iInterfaces[i]->Adapter(), *subnetList) == -1
|| (current != NULL && current->Address() != iInterfaces[i]->Adapter().Address())) {
mDNS_DeregisterInterface(iMdns, &iInterfaces[i]->Info(), false);
delete iInterfaces[i];
iInterfaces.erase(iInterfaces.begin()+i);
}
}
if (iInterfaces.size() == 0) { // current adapter is on a newly added subnet
AddInterface(current);
}
// Set multicast iface in case current adapter was previously in a list
// subnets so no multicast iface was set.
iClient.SetMulticastIf(current->Address());
current->RemoveRef(kNifCookie);
}
else {
// No adapter selected.
// First, check if selected interface should be removed.
for (TInt i=(TInt)iInterfaces.size()-1; i>=0; i--) {
if (InterfaceIndex(iInterfaces[i]->Adapter(), *subnetList) == -1) {
mDNS_DeregisterInterface(iMdns, &iInterfaces[i]->Info(), false);
delete iInterfaces[i];
iInterfaces.erase(iInterfaces.begin()+i);
}
}
// Then, re-add all subnets that aren't already added.
for (TUint i=0; i<(TUint)subnetList->size(); i++) {
NetworkAdapter* nif = (*subnetList)[i];
if (InterfaceIndex(*nif) == -1) {
AddInterface(nif);
}
}
}
iInterfacesLock.Signal();
nifList.DestroySubnetList(subnetList);
}
void NetworkAdapterList::UpdateCurrentAdapter()
{
iCurrent = NULL;
if (iNetworkAdapters != NULL && iNetworkAdapters->size() > 0) {
for (TUint i=0; i<iNetworkAdapters->size(); i++) {
NetworkAdapter* nif = (*iNetworkAdapters)[i];
if (nif->Subnet() == iDefaultSubnet) {
iCurrent = nif;
TraceAdapter("Subnet changed", *iCurrent);
break;
}
}
}
if (iCurrent == NULL) {
LOG(kTrace, "Subnet changed: none active\n");
}
}
void CpiDeviceListUpnp::HandleInterfaceChange(TBool aNewSubnet)
{
NetworkAdapter* current = iCpStack.Env().NetworkAdapterList().CurrentAdapter("CpiDeviceListUpnp::HandleInterfaceChange");
if (aNewSubnet && current != NULL && current->Address() == iInterface) {
// list of subnets has changed but our interface is still available so there's nothing for us to do here
current->RemoveRef("CpiDeviceListUpnp::HandleInterfaceChange");
return;
}
iNextRefreshTimer->Cancel();
iCpStack.Env().Mutex().Wait();
iPendingRefreshCount = 0;
iCpStack.Env().Mutex().Signal();
StopListeners();
if (current == NULL) {
iLock.Wait();
iInterface = 0;
iLock.Signal();
RemoveAll();
return;
}
// we used to only remove devices for subnet changes
// its not clear why this was correct - any interface change will result in control/event urls changing
RemoveAll();
iLock.Wait();
iInterface = current->Address();
iLock.Signal();
TUint msearchTime = iCpStack.Env().InitParams().MsearchTimeSecs();
Mutex& lock = iCpStack.Env().Mutex();
lock.Wait();
iPendingRefreshCount = (kMaxMsearchRetryForNewAdapterSecs + msearchTime - 1) / (2 * msearchTime);
lock.Signal();
current->RemoveRef("CpiDeviceListUpnp::HandleInterfaceChange");
iSsdpLock.Wait();
iUnicastListener = new SsdpListenerUnicast(iCpStack.Env(), *this, iInterface);
iUnicastListener->Start();
iMulticastListener = &(iCpStack.Env().MulticastListenerClaim(iInterface));
iNotifyHandlerId = iMulticastListener->AddNotifyHandler(this);
iSsdpLock.Signal();
Refresh();
}
DviProtocolUpnp::DviProtocolUpnp(DviDevice& aDevice)
: iDevice(aDevice)
, iDvStack(aDevice.GetDvStack())
, iLock("DMUP")
, iUpdateCount(0)
, iSuppressScheduledEvents(false)
{
SetAttribute(kAttributeKeyVersionMajor, "1");
SetAttribute(kAttributeKeyVersionMinor, "1");
iLock.Wait();
iServer = &(iDvStack.ServerUpnp());
NetworkAdapterList& adapterList = iDvStack.Env().NetworkAdapterList();
Functor functor = MakeFunctor(*this, &DviProtocolUpnp::HandleInterfaceChange);
iCurrentAdapterChangeListenerId = adapterList.AddCurrentChangeListener(functor);
iSubnetListChangeListenerId = adapterList.AddSubnetListChangeListener(functor);
std::vector<NetworkAdapter*>* subnetList = adapterList.CreateSubnetList();
AutoNetworkAdapterRef ref(iDvStack.Env(), "DviProtocolUpnp ctor");
const NetworkAdapter* current = ref.Adapter();
if (current != NULL) {
AddInterface(*current);
}
else {
for (TUint i=0; i<subnetList->size(); i++) {
NetworkAdapter* subnet = (*subnetList)[i];
try {
AddInterface(*subnet);
}
catch (NetworkError& ) {
// some hosts may have adapters that don't support multicast
// we can't differentiate between no support ever and transient failure
// (typical on Windows & Mac after hibernation) so just ignore this exception
// and trust that we'll get advertised on another interface.
char* adapterName = subnet->FullName();
LOG2(kTrace, kError, "DvDevice unable to use adapter %s\n", adapterName);
delete adapterName;
}
}
}
NetworkAdapterList::DestroySubnetList(subnetList);
iAliveTimer = new Timer(iDvStack.Env(), MakeFunctor(*this, &DviProtocolUpnp::SendAliveNotifications), "DviProtocolUpnp");
iLock.Signal();
}
TBool CpListenerMsearch::LogUdn(const Brx& aUuid, const Brx& aLocation)
{
Uri uri(aLocation);
Endpoint endpt(0, uri.Host());
NetworkAdapter* nif = iEnv.NetworkAdapterList().CurrentAdapter(kAdapterCookie);
TBool correctSubnet = nif->ContainsAddress(endpt.Address());
nif->RemoveRef(kAdapterCookie);
if (!correctSubnet) {
#if 0
Print("Discarding advertisement from ");
Print(aUuid);
Endpoint::EndpointBuf buf;
endpt.AppendEndpoint(buf);
Print(" at %s\n", buf.Ptr());
#endif
return false;
}
if (aUuid == SuiteMsearch::gNameDevice1){
iUdnsReceived |= 1;
}
else if (aUuid == SuiteMsearch::gNameDevice2){
iUdnsReceived |= 2;
}
else if (aUuid == SuiteMsearch::gNameDevice2Embedded1) {
iUdnsReceived |= 4;
}
else {
#if 0
Print("Didn't match advertisement from ");
Print(aUuid);
Endpoint::EndpointBuf buf;
endpt.AppendEndpoint(buf);
Print(" at %s\n", buf.Ptr());
#endif
return false;
}
iTotal++;
return true;
}
SuiteMsearch::SuiteMsearch(DvStack& aDvStack)
: Suite("Msearches")
, iDvStack(aDvStack)
{
RandomiseUdn(iDvStack.Env(), gNameDevice1);
RandomiseUdn(iDvStack.Env(), gNameDevice2);
RandomiseUdn(iDvStack.Env(), gNameDevice2Embedded1);
Print("UDNs: \n ");
Print(gNameDevice1);
Print("\n ");
Print(gNameDevice2);
Print("\n ");
Print(gNameDevice2Embedded1);
Print("\n\n");
Environment& env = iDvStack.Env();
iBlocker = new Blocker(env);
iListener = new CpListenerMsearch(env);
NetworkAdapter* nif = env.NetworkAdapterList().CurrentAdapter(kAdapterCookie);
iListenerUnicast = new SsdpListenerUnicast(env, *iListener, nif->Address());
nif->RemoveRef(kAdapterCookie);
iListenerUnicast->Start();
}
void CpiDeviceListUpnp::HandleInterfaceChange()
{
NetworkAdapter* current = iCpStack.Env().NetworkAdapterList().CurrentAdapter("CpiDeviceListUpnp::HandleInterfaceChange");
if (current != NULL && current->Address() == iInterface) {
// list of subnets has changed but our interface is still available so there's nothing for us to do here
current->RemoveRef("CpiDeviceListUpnp::HandleInterfaceChange");
return;
}
StopListeners();
if (current == NULL) {
iLock.Wait();
iInterface = 0;
iLock.Signal();
RemoveAll();
return;
}
// we used to only remove devices for subnet changes
// its not clear why this was correct - any interface change will result in control/event urls changing
RemoveAll();
iLock.Wait();
iInterface = current->Address();
iLock.Signal();
current->RemoveRef("CpiDeviceListUpnp::HandleInterfaceChange");
{
AutoMutex a(iSsdpLock);
iUnicastListener = new SsdpListenerUnicast(iCpStack.Env(), *this, iInterface);
iUnicastListener->Start();
iMulticastListener = &(iCpStack.Env().MulticastListenerClaim(iInterface));
iNotifyHandlerId = iMulticastListener->AddNotifyHandler(this);
}
Refresh();
}
void STDCALL OhNetNetworkAdapterRemoveRef(OhNetHandleNetworkAdapter aNif, const char* aCookie)
{
NetworkAdapter* nif = reinterpret_cast<NetworkAdapter*>(aNif);
ASSERT(nif != NULL);
return nif->RemoveRef(aCookie);
}
char* STDCALL OhNetNetworkAdapterFullName(OhNetHandleNetworkAdapter aNif)
{
NetworkAdapter* nif = reinterpret_cast<NetworkAdapter*>(aNif);
ASSERT(nif != NULL);
return nif->FullName();
}
TIpAddress STDCALL OhNetNetworkAdapterMask(OhNetHandleNetworkAdapter aNif)
{
NetworkAdapter* nif = reinterpret_cast<NetworkAdapter*>(aNif);
ASSERT(nif != NULL);
return nif->Mask();
}
void NetworkAdapterList::HandleInterfaceListChanged()
{
static const char* kRemovedAdapterCookie = "RemovedAdapter";
iListLock.Wait();
std::vector<NetworkAdapter*>* list = Os::NetworkListAdapters(iEnv, iEnv.InitParams()->LoopbackNetworkAdapter(), "NetworkAdapterList");
TIpAddress oldAddress = (iCurrent==NULL ? 0 : iCurrent->Address());
DestroySubnetList(iNetworkAdapters);
iNetworkAdapters = list;
// update the 'current' adapter and inform observers if it has changed
UpdateCurrentAdapter();
TIpAddress newAddress = (iCurrent==NULL? 0 : iCurrent->Address());
// update the subnet list, noting if it has changed
std::vector<NetworkAdapter*>* subnets = CreateSubnetListLocked();
TBool subnetsChanged = false;
if (subnets->size() != iSubnets->size()) {
subnetsChanged = true;
}
else {
for (TUint i=0; i<iSubnets->size(); i++) {
if ((*iSubnets)[i]->Address() != (*subnets)[i]->Address()) {
subnetsChanged = true;
break;
}
}
}
// determine adds and/or removes from list
std::vector<NetworkAdapter*> oldSubnetsObj(iSubnets->begin(), iSubnets->end());
std::vector<NetworkAdapter*> newSubnetsObj(subnets->begin(), subnets->end());
std::vector<NetworkAdapter*>* oldSubnets = &oldSubnetsObj;
std::vector<NetworkAdapter*>* newSubnets = &newSubnetsObj;
std::vector<NetworkAdapter*> added;
std::vector<NetworkAdapter*> removed;
std::vector<NetworkAdapter*> adapterChanged;
std::sort(oldSubnets->begin(), oldSubnets->end(), CompareSubnets);
std::sort(newSubnets->begin(), newSubnets->end(), CompareSubnets);
if (oldSubnets->size() == 0 && newSubnets->size() > 0) {
for (TUint i=0; i < newSubnets->size(); i++) {
added.push_back((*newSubnets)[i]);
}
}
else if (oldSubnets->size() > 0 && newSubnets->size() == 0) {
for (TUint i=0; i < oldSubnets->size(); i++) {
NetworkAdapter* removedAdapter = (*oldSubnets)[i];
removed.push_back(removedAdapter);
removedAdapter->AddRef(kRemovedAdapterCookie); // DestroySubnetList(iSubnets) may destroy the last ref to this before QueueAdapterRemoved later claims a new ref
}
}
else {
TUint j = 0;
for (TUint i=0; i < newSubnets->size(); i++) {
while (j < oldSubnets->size() && (*oldSubnets)[j]->Subnet() < (*newSubnets)[i]->Subnet()) {
NetworkAdapter* removedAdapter = (*oldSubnets)[j];
removed.push_back(removedAdapter);
removedAdapter->AddRef(kRemovedAdapterCookie);
j++;
}
if (j < oldSubnets->size() && (*oldSubnets)[j]->Subnet() == (*newSubnets)[i]->Subnet()) {
if ((*oldSubnets)[j]->Address() != (*newSubnets)[i]->Address()) {
adapterChanged.push_back((*newSubnets)[i]);
}
j++;
}
}
if (j < oldSubnets->size()) {
while (j < oldSubnets->size()) {
NetworkAdapter* removedAdapter = (*oldSubnets)[j];
removed.push_back(removedAdapter);
removedAdapter->AddRef(kRemovedAdapterCookie);
j++;
}
}
j = 0;
for (TUint i=0; i < oldSubnets->size(); i++) {
while (j < newSubnets->size() && (*newSubnets)[j]->Subnet() < (*oldSubnets)[i]->Subnet()) {
added.push_back((*newSubnets)[j]);
j++;
}
if (j < newSubnets->size() && (*newSubnets)[j]->Subnet() == (*oldSubnets)[i]->Subnet()) {
j++;
}
}
if (j < newSubnets->size()) {
while (j < newSubnets->size()) {
added.push_back((*newSubnets)[j]);
j++;
}
}
}
DestroySubnetList(iSubnets);
iSubnets = subnets;
iListLock.Signal();
if (subnetsChanged) {
iNotifierThread->QueueSubnetsChanged();
}
else if (newAddress != oldAddress) {
iNotifierThread->QueueCurrentChanged();
}
// Notify added/removed callbacks.
if (removed.size() > 0) {
for (TUint i=0; i < removed.size(); i++) {
NetworkAdapter* removedAdapter = removed[i];
TraceAdapter("NetworkAdapter removed", *removedAdapter);
iNotifierThread->QueueAdapterRemoved(*removedAdapter);
removedAdapter->RemoveRef(kRemovedAdapterCookie);
}
}
if (added.size() > 0) {
for (TUint i=0; i < added.size(); i++) {
TraceAdapter("NetworkAdapter added", *added[i]);
iNotifierThread->QueueAdapterAdded(*added[i]);
}
}
// Notify network adapter changed callbacks.
if (adapterChanged.size() > 0) {
for (TUint i=0; i < adapterChanged.size(); i++) {
TraceAdapter("NetworkAdapter changed", *adapterChanged[i]);
iNotifierThread->QueueAdapterChanged(*adapterChanged[i]);
}
}
}
