Return to Identify.c CVS log

Up to [OMI] / omi / providers / identify

Initial Import

/*
**==============================================================================
**
** Open Management Infrastructure (OMI)
**
** Copyright (c) Microsoft Corporation
** 
** Licensed under the Apache License, Version 2.0 (the "License"); you may not 
** use this file except in compliance with the License. You may obtain a copy 
** of the License at 
**
**     http://www.apache.org/licenses/LICENSE-2.0 
**
** THIS CODE IS PROVIDED *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
** KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED 
** WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE, 
** MERCHANTABLITY OR NON-INFRINGEMENT. 
**
** See the Apache 2 License for the specific language governing permissions 
** and limitations under the License.
**
**==============================================================================
*/

/* @migen@ */
#include <MI.h>
#include <common.h>
#include <base/paths.h>
#include <base/dir.h>
#include <base/strings.h>
#include <base/batch.h>
#include <base/strarr.h>
#include <base/stringarray.h>
#include <provmgr/provmgr.h>
#include "Identify.h"

extern MI_Server* __mi_server;

#define PROVIDER_ID  "2FDB5542-5896-45D5-9BE9-DC04430AAABE"

static MI_Result _MakeInstance(Identify* inst, MI_Context* context)
{
    ProvMgrFT* ft = (ProvMgrFT*)__mi_server->serverFT - 1;

    if (ft->magic != PROVMGRFT_MAGIC)
        return MI_RESULT_FAILED;

    Identify_Construct(inst, context);

    Identify_Set_InstanceID(inst, PROVIDER_ID);
    Identify_Set_ProductName(inst, CONFIG_PRODUCT);
    Identify_Set_ProductVendor(inst, "Microsoft");
    Identify_Set_ProductVersionMajor(inst, CONFIG_MAJOR);
    Identify_Set_ProductVersionMinor(inst, CONFIG_MINOR);
    Identify_Set_ProductVersionRevision(inst, CONFIG_REVISION);
    Identify_Set_ProductVersionString(inst, CONFIG_VERSION);
    Identify_Set_Platform(inst, CONFIG_PLATFORM);
    Identify_Set_OperatingSystem(inst, CONFIG_OS);
    Identify_Set_Architecture(inst, CONFIG_ARCH);
    Identify_Set_Compiler(inst, CONFIG_COMPILER);
    Identify_Set_ConfigPrefix(inst, CONFIG_PREFIX);
    Identify_Set_ConfigLibDir(inst, CONFIG_LIBDIR);
    Identify_Set_ConfigBinDir(inst, CONFIG_BINDIR);
    Identify_Set_ConfigIncludeDir(inst, CONFIG_INCLUDEDIR);
    Identify_Set_ConfigDataDir(inst, CONFIG_DATADIR);
    Identify_Set_ConfigLocalStateDir(inst, CONFIG_LOCALSTATEDIR);
    Identify_Set_ConfigSysConfDir(inst, CONFIG_SYSCONFDIR);
    Identify_Set_ConfigProviderDir(inst, CONFIG_SYSCONFDIR);
    Identify_Set_ConfigLogFile(inst, GetPath(ID_LOGFILE));
    Identify_Set_ConfigPIDFile(inst, GetPath(ID_PIDFILE));
    Identify_Set_ConfigRegisterDir(inst, GetPath(ID_REGISTERDIR));
    Identify_Set_ConfigSchemaDir(inst, GetPath(ID_SCHEMADIR));

    /* Identify.SystemName */
    {
        const MI_Char* systemName;
        if (MI_Server_GetSystemName(&systemName) == MI_RESULT_OK)
            Identify_Set_SystemName(inst, systemName);
    }

    /* Identify.ConfigNameSpaces */
    {
        typedef const char* (*GetPathFunc)(PathID id);
        GetPathFunc func;

        if ((func = (GetPathFunc)ft->FindSymbol("GetPath")))
        {
            char** data = Listdir(func(ID_REGISTERDIR));

            if (data)
            {
                Identify_Set_ConfigNameSpaces(
                    inst, (const char**)data, (MI_Uint32)StrArrLen(data));

                StrArrFree(data);
            }
        }
    }

    return MI_RESULT_OK;
}

void MI_CALL Identify_Load(
    Identify_Self** self,
    MI_Module_Self* selfModule,
    MI_Context* context)
{
    *self = NULL;
    MI_PostResult(context, MI_RESULT_OK);
}

void MI_CALL Identify_Unload(
    Identify_Self* self,
    MI_Context* context)
{
    MI_PostResult(context, MI_RESULT_OK);
}

void MI_CALL Identify_EnumerateInstances(
    Identify_Self* self,
    MI_Context* context,
    const MI_Char* nameSpace,
    const MI_Char* className,
    const MI_PropertySet* propertySet,
    MI_Boolean keysOnly,
    const MI_Filter* filter)
{
    Identify inst;
    _MakeInstance(&inst, context);
    Identify_Post(&inst, context);
    Identify_Destruct(&inst);
    MI_PostResult(context, MI_RESULT_OK);
}

void MI_CALL Identify_GetInstance(
    Identify_Self* self,
    MI_Context* context,
    const MI_Char* nameSpace,
    const MI_Char* className,
    const Identify* instanceName,
    const MI_PropertySet* propertySet)
{
    if (!instanceName ||
        !instanceName->InstanceID.exists ||
        strcmp(PROVIDER_ID,instanceName->InstanceID.value) != 0)
    {
        MI_PostResult(context, MI_RESULT_NOT_FOUND);
        return;
    }

    {
        Identify inst;
        _MakeInstance(&inst, context);
        Identify_Post(&inst, context);
        Identify_Destruct(&inst);
        MI_PostResult(context, MI_RESULT_OK);
    }
}

void MI_CALL Identify_CreateInstance(
    Identify_Self* self,
    MI_Context* context,
    const MI_Char* nameSpace,
    const MI_Char* className,
    const Identify* newInstance)
{
    MI_PostResult(context, MI_RESULT_NOT_SUPPORTED);
}

void MI_CALL Identify_ModifyInstance(
    Identify_Self* self,
    MI_Context* context,
    const MI_Char* nameSpace,
    const MI_Char* className,
    const Identify* modifiedInstance,
    const MI_PropertySet* propertySet)
{
    MI_PostResult(context, MI_RESULT_NOT_SUPPORTED);
}

void MI_CALL Identify_DeleteInstance(
    Identify_Self* self,
    MI_Context* context,
    const MI_Char* nameSpace,
    const MI_Char* className,
    const Identify* instanceName)
{
    MI_PostResult(context, MI_RESULT_NOT_SUPPORTED);
}