THandle STDCALL SongcastCreate(const char* aDomain, uint32_t aSubnet, uint32_t aChannel, uint32_t aTtl, uint32_t aLatency, uint32_t aMulticast, uint32_t aEnabled, uint32_t aPreset, ReceiverCallback aReceiverCallback, void* aReceiverPtr, SubnetCallback aSubnetCallback, void* aSubnetPtr, ConfigurationChangedCallback aConfigurationChangedCallback, void* aConfigurationChangedPtr, MessageCallback aFatalErrorCallback, void* aFatalErrorPtr, MessageCallback aLogOutputCallback, void* aLogOutputPtr, const char* aManufacturer, const char* aManufacturerUrl, const char* aModelUrl, void* aImagePtr, uint32_t aImageBytes, const char* aMimeType)
{
try {
printf("%s\n", aDomain);
// get the computer name
Bws<Songcast::kMaxUdnBytes> computer;
TUint bytes = computer.MaxBytes();
if (!GetComputerName((LPSTR)computer.Ptr(), (LPDWORD)&bytes)) {
THROW(SongcastError);
}
computer.SetBytes(bytes);
TBool enabled = (aEnabled == 0) ? false : true;
TBool multicast = (aMulticast == 0) ? false : true;
// create the sender driver
OhmSenderDriverWindows* driver = new OhmSenderDriverWindows(aDomain, aManufacturer, enabled);
// create the soundcard
Songcast* songcast = new Songcast(aSubnet, aChannel, aTtl, aLatency, multicast, enabled, aPreset, aReceiverCallback, aReceiverPtr, aSubnetCallback, aSubnetPtr, aConfigurationChangedCallback, aConfigurationChangedPtr, aFatalErrorCallback, aFatalErrorPtr, aLogOutputCallback, aLogOutputPtr, computer, driver, aManufacturer, aManufacturerUrl, aModelUrl, Brn((TByte*) aImagePtr, aImageBytes), Brn(aMimeType));
driver->SetSongcast(*songcast);
return (songcast);
}
catch (SongcastError)
{
}
return (0);
}
void OpenHome::Net::Invocation::Output(IAsyncOutput& aConsole)
{
AutoMutex a(iLock); /* using iLock doesn't prevent logging for multiple invocations overlapping
Using iCpStack.Env().Mutex() causes problems though as the call to
ServiceType().FullName() below also uses the Environment's mutex and we
can't easily use a different mutex there.
If we later want to prevent overlapped output, it'd be best to add a
shared logging mutex to Environment */
Bws<Ascii::kMaxUintStringBytes+1> buf;
(void)Ascii::AppendDec(buf, iSequenceNumber);
buf.PtrZ();
aConsole.Output("SequenceNumber", (const TChar*)buf.Ptr());
aConsole.Output("Service", (const TChar*)ServiceType().FullName().Ptr());
aConsole.Output("Action", (const TChar*)iAction->Name().Ptr());
TUint count = (TUint)iInput.size();
for (TUint i=0; i<count; i++) {
OutputArgument(aConsole, "InputArg", *(iInput[i]));
}
if (Error()) {
iError.Output(aConsole);
}
else if (iCompleted) {
count = (TUint)iOutput.size();
for (TUint i=0; i<count; i++) {
OutputArgument(aConsole, "OutputArg", *(iOutput[i]));
}
}
}
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());
}
InvocationManager::InvocationManager(CpStack& aCpStack)
: Thread("InvocationManager")
, iCpStack(aCpStack)
, iLock("INVM")
, iFreeInvocations(aCpStack.Env().InitParams()->NumInvocations())
, iWaitingInvocations(aCpStack.Env().InitParams()->NumInvocations())
, iFreeInvokers(aCpStack.Env().InitParams()->NumActionInvokerThreads())
{
TUint i;
iInvokers = (Invoker**)malloc(sizeof(*iInvokers) * iCpStack.Env().InitParams()->NumActionInvokerThreads());
for (i=0; i<iCpStack.Env().InitParams()->NumActionInvokerThreads(); i++) {
Bws<Thread::kMaxNameBytes+1> thName;
thName.AppendPrintf("ActionInvoker %d", i);
thName.PtrZ();
iInvokers[i] = new Invoker((const TChar*)thName.Ptr(), iFreeInvokers);
iFreeInvokers.Write(iInvokers[i]);
iInvokers[i]->Start();
}
for (i=0; i<iCpStack.Env().InitParams()->NumInvocations(); i++) {
iFreeInvocations.Write(new OpenHome::Net::Invocation(iCpStack, iFreeInvocations));
}
iActive = true;
Start();
}
void Error::Output(IAsyncOutput& aConsole)
{
aConsole.Output("ErrorLevel", LevelName());
Bws<Ascii::kMaxUintStringBytes+1> buf;
(void)Ascii::AppendDec(buf, iCode);
buf.PtrZ();
aConsole.Output("ErrorCode", (const TChar*)buf.Ptr());
aConsole.Output("ErrorDescription", Description());
}
EventServerUpnp::EventServerUpnp(CpStack& aCpStack, TIpAddress aInterface)
: iTcpServer(aCpStack.Env(), "EventServer", aCpStack.Env().InitParams()->CpUpnpEventServerPort(), aInterface)
{
const TUint numThread = aCpStack.Env().InitParams()->NumEventSessionThreads();
for (TUint i=0; i<numThread; i++) {
Bws<Thread::kMaxNameBytes+1> thName;
thName.AppendPrintf("EventSession %d", i);
thName.PtrZ();
iTcpServer.Add((const TChar*)thName.Ptr(), new EventSessionUpnp(aCpStack));
}
}
EventServerUpnp::EventServerUpnp(CpStack& aCpStack, TIpAddress aInterface)
: iTcpServer(aCpStack.Env(), "EventServer", aCpStack.Env().InitParams()->CpUpnpEventServerPort(), aInterface)
{
const TUint numThread = aCpStack.Env().InitParams()->NumEventSessionThreads();
#ifndef _WIN32
// nothing terribly bad would happen if this assertion failed so its not worth a separate Windows implementation
ASSERT(numThread < 10);
#endif
for (TUint i=0; i<numThread; i++) {
Bws<Thread::kMaxNameBytes+1> thName;
thName.AppendPrintf("EventSession %d", i);
thName.PtrZ();
iTcpServer.Add((const TChar*)thName.Ptr(), new EventSessionUpnp(aCpStack));
}
}
void XmlFetch::Output(IAsyncOutput& aConsole)
{
Mutex& lock = iCpStack.Env().Mutex();
lock.Wait();
Bws<Ascii::kMaxUintStringBytes+1> buf;
(void)Ascii::AppendDec(buf, iSequenceNumber);
buf.PtrZ();
aConsole.Output("SequenceNumber", (const TChar*)buf.Ptr());
Bws<Uri::kMaxUriBytes+1> uri(iUri->AbsoluteUri());
uri.PtrZ();
aConsole.Output("XmlFetch", (const TChar*)uri.Ptr());
if (Error()) {
iError.Output(aConsole);
}
lock.Signal();
}
void LogMsg(const char *format, ...)
{
#ifdef DEFINE_TRACE
va_list args;
va_start(args, format);
// not all messages are errors but enough are that its handy to log everything here if we're interested in errors
if(Debug::TestLevel(Debug::kBonjour) || Debug::TestLevel(Debug::kError)) {
Bws<kMaxLogMsgBytes> msg;
TUint written = mDNS_vsnprintf((char*)msg.Ptr(), msg.MaxBytes(), format, args);
msg.SetBytes(written);
Log::Print(msg);
Log::Print("\n");
}
va_end(args);
#endif
}
SocketTcpServer* DviServerLpec::CreateServer(const NetworkAdapter& aNif)
{
SocketTcpServer* server = new SocketTcpServer(iDvStack.Env(), "LpecServer", iPort, aNif.Address());
const TUint numThreads = iDvStack.Env().InitParams()->DvNumLpecThreads();
AdapterData* ad = new AdapterData(aNif.Address());
iAdapterData.push_back(ad);
for (TUint i=0; i<numThreads; i++) {
Bws<Thread::kMaxNameBytes+1> thName;
thName.AppendPrintf("LpecSession %d", i);
thName.PtrZ();
DviSessionLpec* session = new DviSessionLpec(iDvStack, aNif.Address(), iPort);
server->Add((const TChar*)thName.Ptr(), session);
ad->iSessions.push_back(session);
}
return server;
}
TChar* CpListenerMsearch::CreateTypeString(const Brx& aDomain, const Brx& aType, TUint aVersion)
{
TChar* type = (TChar*)malloc(aDomain.Bytes() + aType.Bytes() + 2 + Ascii::kMaxUintStringBytes + 1);
TChar* ptr = type;
(void)strncpy(ptr, (const TChar*)aDomain.Ptr(), aDomain.Bytes());
ptr += aDomain.Bytes();
*ptr = ':';
ptr++;
(void)strncpy(ptr, (const TChar*)aType.Ptr(), aType.Bytes());
ptr += aType.Bytes();
*ptr = ':';
ptr++;
Bws<Ascii::kMaxUintStringBytes> ver;
Ascii::AppendDec(ver, aVersion);
(void)strncpy(ptr, (const TChar*)ver.Ptr(), ver.Bytes());
ptr += ver.Bytes();
*ptr = '\0';
return type;
}
DviSubscriptionManager::DviSubscriptionManager(DvStack& aDvStack)
: Thread("DvSubscriptionMgr")
, iDvStack(aDvStack)
, iLock("DSBM")
, iFree(aDvStack.Env().InitParams()->DvNumPublisherThreads())
{
const TUint numPublisherThreads = iDvStack.Env().InitParams()->DvNumPublisherThreads();
LOG(kDvEvent, "> DviSubscriptionManager: creating %u publisher threads\n", numPublisherThreads);
iPublishers = (Publisher**)malloc(sizeof(*iPublishers) * numPublisherThreads);
for (TUint i=0; i<numPublisherThreads; i++) {
Bws<Thread::kMaxNameBytes+1> thName;
thName.AppendPrintf("Publisher %d", i);
thName.PtrZ();
iPublishers[i] = new Publisher((const TChar*)thName.Ptr(), iFree);
iFree.Write(iPublishers[i]);
iPublishers[i]->Start();
}
Start();
}
XmlFetchManager::XmlFetchManager(CpStack& aCpStack)
: Thread("XmlFetchManager")
, iCpStack(aCpStack)
, iLock("FETL")
, iFree(iCpStack.Env().InitParams()->NumXmlFetcherThreads())
{
const TUint numThreads = iCpStack.Env().InitParams()->NumXmlFetcherThreads();
iFetchers = (XmlFetcher**)malloc(sizeof(*iFetchers) * numThreads);
for (TUint i=0; i<numThreads; i++) {
Bws<Thread::kMaxNameBytes+1> thName;
thName.AppendPrintf("XmlFetcher %d", i);
thName.PtrZ();
iFetchers[i] = new XmlFetcher((const TChar*)thName.Ptr(), iFree);
iFree.Write(iFetchers[i]);
iFetchers[i]->Start();
}
iActive = true;
Start();
}
void SuiteUnicast::Receiver()
{
TBool first = true;
iLastVal = 0;
TUint val;
Bws<kMsgBytes> recv;
do {
recv.SetBytes(0);
(void)iReceiver->Receive(recv);
ASSERT(recv.Bytes() >= sizeof(TUint32));
val = *((TUint32*)recv.Ptr());
if (val != kQuit) {
if (first) {
TEST(val == 0);
first = false;
}
else {
TEST(val == iLastVal+1);
}
}
//Print("Received %u, last sent %u\n", val, iSendVal);
iLastVal = val;
} while (val != kQuit);
}
Soundcard::Soundcard(TIpAddress /* aSubnet */, TUint aChannel, TUint aTtl, TBool aMulticast, TBool aEnabled, TUint aPreset, ReceiverCallback aReceiverCallback, void* aReceiverPtr)
: iReceiverCallback(aReceiverCallback)
, iReceiverPtr(aReceiverPtr)
{
InitialisationParams* initParams = InitialisationParams::Create();
UpnpLibrary::Initialise(initParams);
std::vector<NetworkInterface*>* list = UpnpLibrary::SubnetList();
ASSERT(list->size() > 0);
NetworkInterface* iface = *list->begin();
delete (list);
UpnpLibrary::SetCurrentSubnet(*iface);
printf("Using %x\n", iface->Address());
UpnpLibrary::StartCombined();
Bws<kMaxUdnBytes> computer;
Bws<kMaxUdnBytes> udn;
Bws<kMaxUdnBytes + 1> friendly;
TUint bytes = computer.MaxBytes();
if (!GetComputerName((LPSTR)computer.Ptr(), (LPDWORD)&bytes)) {
THROW(SoundcardError);
}
computer.SetBytes(bytes);
udn.Replace("ohSoundcard-");
udn.Append(computer);
friendly.Replace(udn);
friendly.Append('\0');
iDevice = new DvDeviceStandard(udn);
iDevice->SetAttribute("Upnp.Domain", "av.openhome.org");
iDevice->SetAttribute("Upnp.Type", "Soundcard");
iDevice->SetAttribute("Upnp.Version", "1");
iDevice->SetAttribute("Upnp.FriendlyName", (TChar*)friendly.Ptr());
iDevice->SetAttribute("Upnp.Manufacturer", "Openhome");
iDevice->SetAttribute("Upnp.ManufacturerUrl", "http://www.openhome.org");
iDevice->SetAttribute("Upnp.ModelDescription", "OpenHome Soundcard");
iDevice->SetAttribute("Upnp.ModelName", "ohSoundcard");
iDevice->SetAttribute("Upnp.ModelNumber", "1");
iDevice->SetAttribute("Upnp.ModelUrl", "http://www.openhome.org");
iDevice->SetAttribute("Upnp.SerialNumber", "");
iDevice->SetAttribute("Upnp.Upc", "");
iDriver = new OhmSenderDriverWindows();
Brn icon(icon_png, icon_png_len);
iSender = new OhmSender(*iDevice, *iDriver, computer, aChannel, iface->Address(), aTtl, aMulticast, aEnabled, icon, Brn("image/png"), aPreset);
iDevice->SetEnabled();
iReceiverManager = new ReceiverManager3(*this, iSender->SenderUri(), iSender->SenderMetadata());
}
void OpenHome::UnhandledExceptionHandler(std::exception& aException)
{
Bws<5> thName;
GetThreadName(thName);
char buf[1024];
(void)snprintf(buf, sizeof(buf), "Unhandled exception %s in thread %s\n", aException.what(), thName.Ptr());
CallFatalErrorHandler(buf);
}
void OpenHome::UnhandledExceptionHandler(Exception& aException)
{
Bws<5> thName;
GetThreadName(thName);
char buf[1024];
(void)snprintf(buf, sizeof(buf), "Unhandled exception %s at %s:%lu in thread %s\n", aException.Message(), aException.File(), (unsigned long)aException.Line(), thName.Ptr());
TInt len = 8*1024;
char* msg = new char[len];
if (msg != NULL) {
(void)strncpy(msg, buf, len);
len -= (TInt)strlen(buf);
(void)strncat(msg, "\n", len);
len -= 2;
THandle stackTrace = aException.StackTrace();
TUint count = Os::StackTraceNumEntries(stackTrace);
for (TUint i=0; i<count; i++) {
const char* entry = Os::StackTraceEntry(stackTrace, i);
(void)strncat(msg, entry, len);
len -= (TInt)strlen(entry) + 2;
if (len < 0) {
break;
}
(void)strncat(msg, "\n", len);
}
}
if (len > 0) {
(void)strncat(msg, "\n", len);
}
CallFatalErrorHandler((msg!=NULL? msg : buf));
delete msg;
}
void OpenHome::UnhandledExceptionHandler(const TChar* aExceptionMessage, const TChar* aFile, TUint aLine)
{
Bws<5> thName;
GetThreadName(thName);
char buf[1024];
(void)snprintf(buf, sizeof(buf), "Unhandled exception %s at %s:%lu in thread %s\n", aExceptionMessage, aFile, (unsigned long)aLine, thName.Ptr());
CallFatalErrorHandler(buf);
}