void PrintDevice(mUpnpDevice *dev, int indent)
{
mUpnpDevice *childDev;
PrintDeviceInfo(dev, indent);
for (childDev = mupnp_device_getdevices(dev); childDev != NULL; childDev = mupnp_device_next(childDev))
PrintDevice(childDev, indent+1);
}
static void
PrintPlatform(cl_platform_id platform) {
static struct { cl_platform_info param; const char *name; } props[] = {
{ CL_PLATFORM_PROFILE, "profile" },
{ CL_PLATFORM_VERSION, "version" },
{ CL_PLATFORM_NAME, "name" },
{ CL_PLATFORM_VENDOR, "vendor" },
{ CL_PLATFORM_EXTENSIONS, "extensions" },
{ 0, NULL },
};
cl_device_id *deviceList;
cl_uint numDevices;
cl_int status;
char buf[65536];
size_t size;
int ii;
for (ii = 0; props[ii].name != NULL; ii++) {
status = clGetPlatformInfo(platform, props[ii].param, sizeof buf, buf, &size);
if (status != CL_SUCCESS) {
Warning("platform[%p]: Unable to get %s: %s\n",
platform, props[ii].name, CLErrString(status));
continue;
}
if (size > sizeof buf) {
Warning("platform[%p]: Huge %s (%d bytes)! Truncating to %d\n",
platform, props[ii].name, size, sizeof buf);
}
printf("platform[%p]: %s: %s\n", platform, props[ii].name, buf);
}
if ((status = clGetDeviceIDs(platform, CL_DEVICE_TYPE_ALL,
0, NULL, &numDevices)) != CL_SUCCESS) {
Warning("platform[%p]: Unable to query the number of devices: %s\n",
platform, CLErrString(status));
return;
}
printf("platform[%p]: Found %d device(s).\n", platform, numDevices);
deviceList = malloc(numDevices * sizeof(cl_device_id));
if ((status = clGetDeviceIDs(platform, CL_DEVICE_TYPE_ALL,
numDevices, deviceList, NULL)) != CL_SUCCESS) {
Warning("platform[%p]: Unable to enumerate the devices: %s\n",
platform, CLErrString(status));
free(deviceList);
return;
}
for (ii = 0; ii < numDevices; ii++) {
PrintDevice(deviceList[ii]);
}
free(deviceList);
}
void PrintControlPointDevice(mUpnpControlPoint *ctrlPoint)
{
mUpnpDevice *dev;
int devCnt;
printf("Device Num = %d\n", mupnp_controlpoint_getndevices(ctrlPoint));
devCnt = 0;
for (dev = mupnp_controlpoint_getdevices(ctrlPoint); dev != NULL; dev = mupnp_device_next(dev)) {
printf("[%d] = %s\n", ++devCnt, mupnp_device_getfriendlyname(dev));
PrintDevice(dev, 1);
}
}
int main(int argc, char* argv[])
{
#if 0
std::cout << "size adapter::Device : " << sizeof(adapter::Device) << std::endl;
std::cout << "size adapter::Method : " << sizeof(adapter::Method) << std::endl;
std::cout << "size adapter::Prop : " << sizeof(adapter::Property) << std::endl;
std::cout << "size adpater::Intf : " << sizeof(adapter::Interface) << std::endl;
std::cout << "size std::string : " << sizeof(std::string) << std::endl;
std::cout << "size adapter::Guid : " << sizeof(adapter::Guid) << std::endl;
std::cout << "size string map<> : " << sizeof(std::map<std::string, std::string>) << std::endl;
#endif
int optionIndex = 0;
char const* adapterName = nullptr;
char const* configFile = "alljoyndsb.xml";
while (true)
{
int c = getopt_long(argc, argv, "a:c:", longOptions, &optionIndex);
if (c == -1)
break;
switch (c)
{
case 'a':
adapterName = optarg;
break;
case 'c':
configFile = optarg;
break;
default:
return 0;
}
}
#if 0
bridge::bridgeConfig config;
config.FromFile("/some/file.xml");
std::cout << config.GetBridgeKeyX() << std::endl;
std::cout << config.GetDeviceKeyX() << std::endl;
std::cout << config.GetDeviceUsername() << std::endl;
std::cout << config.GetDevicePassword() << std::endl;
std::cout << config.GetDeviceEcdheEcdsaPrivateKey() << std::endl;
std::cout << config.GetDeviceEcdheEcdsaCertChain() << std::endl;
std::cout << config.GetDefaultVisibility() << std::endl;
bridge::DsbObjectConfig obj;
QStatus st = config.FindObject("/my/bus/object", obj);
obj.SetId("/my/bus/object2");
obj.SetDescription("This is bus object2");
obj.SetIsVisible(true);
config.AddObject(obj);
obj.SetId("/my/bus/object3");
obj.SetDescription("This is bus object3");
obj.SetIsVisible(true);
config.AddObject(obj);
config.ToFile("/tmp/test.xml");
config.FromFile("/tmp/test.xml");
config.RemoveObject("/my/bus/object2");
config.ToFile("/tmp/test2.xml");
#endif
adapter::Log::SetDefaultLevel(adapter::LogLevel::Debug);
if (!adapterName)
{
DSBLOG_ERROR("need --adapter=<adaptername> argument");
exit(1);
}
adapter::Loader loader(adapterName);
if (!loader.bind())
exit(1);
std::shared_ptr<adapter::Adapter> adapter = loader.create();
bridge::Bridge::InitializeSingleton(adapter);
try
{
DSB()->Initialize(configFile);
}
catch (std::exception const& err)
{
DSBLOG_ERROR("failed to initialize dsb. %s", err.what());
exit(1);
}
#if 0
std::shared_ptr<adapter::Adapter> adapter = DSB()->GetAdapter();
adapter::ItemInformation const& info = adapter->GetInfo();
adapter::Device::Vector devices;
std::shared_ptr<adapter::IoRequest> req(new adapter::IoRequest());
adapter->EnumDevices(adapter::EnumDeviceOptions::ForceRefresh, devices, req);
if (req)
{
DSBLOG_INFO("waiting for EnumDevices to complete");
if (!req->Wait(20000))
DSBLOG_INFO("EnumDevices timed out");
else
DSBLOG_INFO("EnumDevices completed");
}
for (auto const& device : devices)
PrintDevice(*adapter, device);
#endif
getchar();
bridge::Bridge::ReleaseSingleton();
return 0;
}
/**
* PrintVertex -- Print a vertex.
*
* @param imEnv is the compare environment
* @param vertex is the vertex we are printing
*/
void
PrintVertex(IMEnv * imEnv, Vertex * vertex) {
register int i;
if (!(vertex != NULL))
throwError(imEnv, "Empty vertex to PrintVertex");
switch (vertex->vertexType) {
case DEVICE:
if (!strcmp(imEnv->deviceDefs[vertex->n.vertexDef].name, ""))
throwError(imEnv,
"Fatal internal error in PrintVertex: device has empty string for name\n");
printf("DEVICE %s: ", imEnv->deviceDefs[vertex->n.vertexDef].name);
fflush(stdout);
if ((vertex->name[0] != '*') || (vertex->name[1] != '\0'))
printf("\"%s\" ", vertex->name);
if (imEnv->verbose) {
printf("[%d,%d", vertex->vertexValue, vertex->pass);
switch (vertex->flag) {
case UNIQUE:
printf(" UNIQUE");
break;
case SUSPECT:
printf(" SUSPECT");
break;
case BAD:
printf(" BAD");
break;
default:
printf(" PENDING");
break;
}
printf("]\n");
}
if (vertex->match)
printf(" (MATCHED %s)",
imEnv->deviceDefs[vertex->match->n.vertexDef].name);
printf(" connections: ");
PrintDevice(imEnv, vertex);
break;
case NET:
printf("NET ");
if ((vertex->name[0] != '*') || (vertex->name[1] != '\0'))
printf("\"%s\"", vertex->name);
if (imEnv->verbose) {
printf("[%d,%d,", vertex->vertexValue, vertex->pass);
switch (vertex->flag) {
case UNIQUE:
printf(" UNIQUE");
break;
case SUSPECT:
printf(" SUSPECT");
break;
case BAD:
printf(" BAD");
break;
default:
printf(" PENDING");
}
printf("]");
}
if (vertex->match)
printf(" (MATCHED %s)", vertex->match->name);
printf(" %d connections\n", vertex->n.netConnects);
if (vertex->n.netConnects <= imEnv->netPrintLimit) {
for (i = 0; i < vertex->n.netConnects; i++) {
register Vertex *nVertex = vertex->connects.devList[i].vertex;
printf(" %s (%d,%d): ",
imEnv->deviceDefs[nVertex->n.vertexDef].name,
imEnv->deviceDefs[nVertex->n.vertexDef].occ[0],
imEnv->deviceDefs[nVertex->n.vertexDef].occ[1]);
PrintDevice(imEnv, nVertex);
}
}
break;
}
}
void PrintReject(Record* rd, FILE* fp) {
PrintTime(rd, fp);
PrintType(rd, fp);
PrintDevice(rd, 0, fp);
}
void PrintAccept(Record* rd, FILE* fp) {
PrintTime(rd, fp);
PrintType(rd, fp);
PrintRequester(rd, fp);
PrintDevice(rd, 1, fp);
}
