void CNsIDirectoryService::StartTests(UINT nMenuID)
{
QAOutput("------------------------------------------------",1);
QAOutput("Start DirectoryService Test",1);
// Calls all or indivdual test cases on the basis of the
// option selected from menu.
switch(nMenuID)
{
case ID_INTERFACES_NSIDIRECTORYSERVICE_RUNALLTESTS :
Init();
RegisterProvider();
UnRegisterProvider();
break ;
case ID_INTERFACES_NSIDIRECTORYSERVICE_INIT :
Init();
break ;
case ID_INTERFACES_NSIDIRECTORYSERVICE_REGISTERPROVIDER :
RegisterProvider();
break ;
case ID_INTERFACES_NSIDIRECTORYSERVICE_UNREGISTERPROVIDER :
UnRegisterProvider();
break ;
default :
AfxMessageBox("Menu handler not added for this menu item");
break ;
}
}
void
nsDirectoryService::RegisterCategoryProviders()
{
nsCOMPtr<nsICategoryManager> catman
(do_GetService(NS_CATEGORYMANAGER_CONTRACTID));
if (!catman)
return;
nsCOMPtr<nsISimpleEnumerator> entries;
catman->EnumerateCategory(XPCOM_DIRECTORY_PROVIDER_CATEGORY,
getter_AddRefs(entries));
nsCOMPtr<nsIUTF8StringEnumerator> strings(do_QueryInterface(entries));
if (!strings)
return;
bool more;
while (NS_SUCCEEDED(strings->HasMore(&more)) && more) {
nsCAutoString entry;
strings->GetNext(entry);
nsXPIDLCString contractID;
catman->GetCategoryEntry(XPCOM_DIRECTORY_PROVIDER_CATEGORY, entry.get(), getter_Copies(contractID));
if (contractID) {
nsCOMPtr<nsIDirectoryServiceProvider> provider = do_GetService(contractID.get());
if (provider)
RegisterProvider(provider);
}
}
}
/* ========================================================================= */
int ProcStatRegister(struct proot *p)
{
this_data = NULL;
this_buf = NULL;
this_provider = RegisterProvider(p, /* The provider "root" structure */
"proc.stat", /* The name of the provider Q1 */
procstat_update,
procstat_list,
procstat_enablepitem);
/* Check status */
if ( NULL == this_provider )
return(1);
return(0);
}
/* ========================================================================= */
int MountDFRegister(struct proot *p)
{
/* Set the lists to un-initialized */
full_mount_list = NULL;
mnt_item_ui = NULL;
/* No data types are checked - we only export *specific* data types. */
if ( NULL == (myself = RegisterProvider(p, "mount.df",
mdf_update,
mdf_list,
mdf_enablepitem)) )
{
/* All about readability */
return(1);
}
return(0);
}
/* ========================================================================= */
int FileStatRegister(struct proot *p)
{
struct stat assert_stat; /* Just used to reference the data types */
/* Check our data types */
assert(sizeof(assert_stat.st_ino) == sizeof(int64_t));
assert(sizeof(assert_stat.st_size) == sizeof(int64_t));
assert(sizeof(assert_stat.st_atime) == sizeof(int64_t)); /* atime == mtime == ctime */
if ( NULL == (myself = RegisterProvider(p, "file.stat",
fstat_update,
fstat_list,
fstat_enablepitem)) )
{
/* All about readability */
return(1);
}
return(0);
}
/* ========================================================================= */
int MemInfoRegister(struct proot *p)
{
/* The conditionall malloc (init_midata) will key off this value later */
this_data = NULL;
/* Best pracitces would dictate that the provider assert() data type
sizes being equal. That is NOT necessary here because the struct
this provider pulls from is of our own design. There are no ambiguous
data types used here - this provider pulls from a text string and
assigns to its own type. */
this_provider = RegisterProvider(p, /* The provider "root" structure */
"proc.meminfo", /* The name of the provider Q1 */
meminfo_update,
meminfo_list,
meminfo_enablepitem);
/* Check status */
if ( NULL == this_provider )
return(1);
return(0);
}
DWORD CALLBACK VirtRngCoInstaller(IN DI_FUNCTION InstallFunction,
IN HDEVINFO DeviceInfoSet,
IN PSP_DEVINFO_DATA DeviceInfoData OPTIONAL,
IN OUT PCOINSTALLER_CONTEXT_DATA Context)
{
NTSTATUS status;
DWORD error = NO_ERROR;
UNREFERENCED_PARAMETER(DeviceInfoSet);
UNREFERENCED_PARAMETER(DeviceInfoData);
UNREFERENCED_PARAMETER(Context);
switch (InstallFunction)
{
case DIF_INSTALLDEVICE:
status = RegisterProvider(FALSE);
if (!NT_SUCCESS(status))
{
error = ToDosError(status);
}
break;
case DIF_REMOVE:
status = UnregisterProvider();
if (!NT_SUCCESS(status))
{
error = ToDosError(status);
}
break;
default:
break;
}
return error;
}
std::string IDSEXT::InvokeMethod(const std::string& command)
{
int index = command.find_first_of(" ");
string strCommand = command.substr(0, index);
string strParam = command.substr(index + 1, command.length());
Json::Reader reader;
Json::Value obj;
if (strCommand == "getVersion") {
return GetVersion();
} else if (strCommand == "registerProvider") {
return RegisterProvider(strParam);
} else if (strCommand == "setOption") {
// parse the JSON
bool parse = reader.parse(strParam, obj);
if (!parse) {
//fprintf(stderr, "%s\n", "error parsing\n");
return "unable to parse options";
}
int option = obj["option"].asInt();
const std::string value = obj["value"].asString();
return( SetOption(option, value) );
} else if (strCommand == "getToken") {
// parse the JSON
bool parse = reader.parse(strParam, obj);
if (!parse) {
//fprintf(stderr, "%s", "error parsing\n");
return "unable to parse options";
}
event_id = obj["_eventId"].asString();
std::string provider = obj["provider"].asString();
std::string tokenType = obj["tokenType"].asString();
const std::string appliesTo = obj["appliesTo"].asString();
GetToken(provider, tokenType, appliesTo);
} else if (strCommand == "clearToken") {
// parse the JSON
bool parse = reader.parse(strParam, obj);
if (!parse) {
//fprintf(stderr, "%s", "error parsing\n");
return "unable to parse options";
}
event_id = obj["_eventId"].asString();
std::string provider = obj["provider"].asString();
std::string tokenType = obj["tokenType"].asString();
const std::string appliesTo = obj["appliesTo"].asString();
ClearToken(provider, tokenType, appliesTo);
} else if (strCommand == "getProperties") {
// parse the JSON
bool parse = reader.parse(strParam, obj);
if (!parse) {
//fprintf(stderr, "%s", "error parsing\n");
return "unable to parse options";
}
event_id = obj["_eventId"].asString();
std::string provider = obj["provider"].asString();
int propertyType = obj["propertyType"].asInt();
int numProps = obj["numProps"].asInt();
const std::string userProps = obj["userProperties"].asString();
GetProperties(provider, propertyType, numProps, userProps);
} else if (strCommand == "getData") {
// parse the JSON
bool parse = reader.parse(strParam, obj);
if (!parse) {
//fprintf(stderr, "%s", "error parsing\n");
return "unable to parse options";
}
event_id = obj["_eventId"].asString();
std::string provider = obj["provider"].asString();
int dataType = obj["dataType"].asInt();
int dataFlags = obj["dataFlags"].asInt();
const std::string dataName = obj["dataName"].asString();
GetData(provider, dataType, dataFlags, dataName);
} else if (strCommand == "createData") {
// parse the JSON
bool parse = reader.parse(strParam, obj);
if (!parse) {
//fprintf(stderr, "%s", "error parsing\n");
return "unable to parse options";
}
event_id = obj["_eventId"].asString();
std::string provider = obj["provider"].asString();
int dataType = obj["dataType"].asInt();
int dataFlags = obj["dataFlags"].asInt();
const std::string dataName = obj["dataName"].asString();
const std::string dataValue = obj["dataValue"].asString();
CreateData(provider, dataType, dataFlags, dataName, dataValue);
} else if (strCommand == "deleteData") {
// parse the JSON
bool parse = reader.parse(strParam, obj);
if (!parse) {
//fprintf(stderr, "%s", "error parsing\n");
return "unable to parse options";
}
event_id = obj["_eventId"].asString();
std::string provider = obj["provider"].asString();
int dataType = obj["dataType"].asInt();
int dataFlags = obj["dataFlags"].asInt();
const std::string dataName = obj["dataName"].asString();
DeleteData(provider, dataType, dataFlags, dataName);
} else if (strCommand == "setData") {
// parse the JSON
bool parse = reader.parse(strParam, obj);
if (!parse) {
//fprintf(stderr, "%s", "error parsing\n");
return "unable to parse options";
}
event_id = obj["_eventId"].asString();
std::string provider = obj["provider"].asString();
int dataType = obj["dataType"].asInt();
int dataFlags = obj["dataFlags"].asInt();
const std::string dataName = obj["dataName"].asString();
const std::string dataValue = obj["dataValue"].asString();
SetData(provider, dataType, dataFlags, dataName, dataValue);
} else if (strCommand == "listData") {
// parse the JSON
bool parse = reader.parse(strParam, obj);
if (!parse) {
//fprintf(stderr, "%s", "error parsing\n");
return "unable to parse options";
}
event_id = obj["_eventId"].asString();
std::string provider = obj["provider"].asString();
int dataType = obj["dataType"].asInt();
int dataFlags = obj["dataFlags"].asInt();
ListData(provider, dataType, dataFlags);
} else if (strCommand == "challenge") {
// parse the JSON
bool parse = reader.parse(strParam, obj);
if (!parse) {
//fprintf(stderr, "%s", "error parsing\n");
return "unable to parse options";
}
event_id = obj["_eventId"].asString();
std::string provider = obj["provider"].asString();
int challengeType = obj["challengeType"].asInt();
int challengeFlags = obj["challengeFlags"].asInt();
Challenge(provider, challengeType, challengeFlags);
} else if (strCommand == "registerNotifier") {
// parse the JSON
bool parse = reader.parse(strParam, obj);
if (!parse) {
//fprintf(stderr, "%s", "error parsing\n");
return "unable to parse options";
}
event_id = obj["_eventId"].asString();
std::string provider = obj["provider"].asString();
int notifierType = obj["notifierType"].asInt();
int notifierFlags = obj["notifierFlags"].asInt();
std::string notifierName = obj["notifierName"].asString();
RegisterNotifier(provider, notifierType, notifierFlags, notifierName);
}
return "";
}
