messageloader.cpp

Pegasus is an open-source implementationof the DMTF CIM and WBEM standards. It is designed to be por

//%2006////////////////////////////////////////////////////////////////////////
//
// Copyright (c) 2000, 2001, 2002 BMC Software; Hewlett-Packard Development
// Company, L.P.; IBM Corp.; The Open Group; Tivoli Systems.
// Copyright (c) 2003 BMC Software; Hewlett-Packard Development Company, L.P.;
// IBM Corp.; EMC Corporation, The Open Group.
// Copyright (c) 2004 BMC Software; Hewlett-Packard Development Company, L.P.;
// IBM Corp.; EMC Corporation; VERITAS Software Corporation; The Open Group.
// Copyright (c) 2005 Hewlett-Packard Development Company, L.P.; IBM Corp.;
// EMC Corporation; VERITAS Software Corporation; The Open Group.
// Copyright (c) 2006 Hewlett-Packard Development Company, L.P.; IBM Corp.;
// EMC Corporation; Symantec Corporation; The Open Group.
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to
// deal in the Software without restriction, including without limitation the
// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
// sell copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
// 
// THE ABOVE COPYRIGHT NOTICE AND THIS PERMISSION NOTICE SHALL BE INCLUDED IN
// ALL COPIES OR SUBSTANTIAL PORTIONS OF THE SOFTWARE. THE SOFTWARE IS PROVIDED
// "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT
// LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
// ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//
//==============================================================================
//
//%/////////////////////////////////////////////////////////////////////////////

#include <Pegasus/Common/MessageLoader.h>
#include <Pegasus/Common/Thread.h>
#include <Pegasus/Common/Tracer.h>
#include <Pegasus/Common/Constants.h>
#include <Pegasus/Common/CommonUTF.h>
#include <Pegasus/Common/FileSystem.h>
#include <Pegasus/Common/LanguageParser.h>
#include <iostream>
#ifdef PEGASUS_OS_OS400
#include "EBCDIC_OS400.h"
#endif
PEGASUS_NAMESPACE_BEGIN
PEGASUS_USING_STD;

static const int ID_INVALID = -1;
static const String server_resbundl_name = "pegasus/pegasusServer";
String MessageLoader::pegasus_MSG_HOME;
Boolean MessageLoader::_useProcessLocale = false;
Boolean MessageLoader::_useDefaultMsg = false;
AcceptLanguageList MessageLoader::_acceptlanguages;

String MessageLoader::getMessage(MessageLoaderParms& parms)
{
    PEG_METHOD_ENTER(TRC_L10N, "MessageLoader::getMessage");
    String msg;

    try
    {
        openMessageFile(parms);
        msg = getMessage2(parms);
        closeMessageFile(parms);
    }
    catch (Exception&)
    {
        msg = String("AN INTERNAL ERROR OCCURED IN MESSAGELOADER: ").append(
            parms.default_msg);
    }
    PEG_METHOD_EXIT();
    return msg;
}

String MessageLoader::getMessage2(MessageLoaderParms& parms)
{
    PEG_METHOD_ENTER(TRC_L10N, "MessageLoader::getMessage2");
    String msg;

    try
    {
#if defined (PEGASUS_HAS_MESSAGES) && defined (PEGASUS_HAS_ICU)
        if (!_useDefaultMsg && (parms._resbundl != NO_ICU_MAGIC))
        {
            msg = extractICUMessage(parms._resbundl,parms);
            if (msg.size() > 0)
            {
                PEG_METHOD_EXIT();
                return msg;
            }
        }
#endif
        // NOTE: the default message is returned if:
        // 1) The previous call to openMessageFile() set _useDefaultMsg
        // 2) parms._resbundl is set to NO_ICU_MAGIC from a previous
        //    call to openMessageFile() indicating an error
        //    (including InitializeICU::initICUSuccessful() failed)
        // 3) Message loading is DISABLED
        // 4) Did not get a message from ICU

        msg = formatDefaultMessage(parms);
    }
    catch (Exception&)
    {
        msg = String("AN INTERNAL ERROR OCCURED IN MESSAGELOADER: ").append(
            parms.default_msg);
    }

    PEG_METHOD_EXIT();
    return msg;
}

void MessageLoader::openMessageFile(MessageLoaderParms& parms)
{
    PEG_METHOD_ENTER(TRC_L10N, "MessageLoader::openMessageFile");

    try
    {
        parms.contentlanguages.clear();

#if defined (PEGASUS_HAS_MESSAGES) && defined (PEGASUS_HAS_ICU)
        if (InitializeICU::initICUSuccessful())
        {
            openICUMessageFile(parms);
        }
        // If initICUSuccessful() has returned false, then
        // _resbundl is still set to NO_ICU_MAGIC and
        // subsequent calls to getMessage2 will call
        // formatDefaultMessage() instead of using ICU.
#else
        // Set _resbundl to the "magic number" indicating there is no ICU
        // resource bundle to use
        parms._resbundl = NO_ICU_MAGIC;
#endif
    }
    catch (Exception&)
    {
        // Set _resbundl to the "magic number" indicating there was trouble
        // during openICUMessageFile(), so there is no ICU resource bundle
        // to use.
        parms._resbundl = NO_ICU_MAGIC;
    }

    PEG_METHOD_EXIT();
    return;
}

void MessageLoader::closeMessageFile(MessageLoaderParms& parms)
{
    PEG_METHOD_ENTER(TRC_L10N, "MessageLoader::closeMessageFile");

#if defined (PEGASUS_HAS_MESSAGES) && defined (PEGASUS_HAS_ICU)
    if (parms._resbundl != NO_ICU_MAGIC)
    {
        ures_close(parms._resbundl);
    }
#endif

    PEG_METHOD_EXIT();
    return;
}

#ifdef PEGASUS_HAS_ICU

void MessageLoader::openICUMessageFile(MessageLoaderParms &parms)
{
    PEG_METHOD_ENTER(TRC_L10N, "MessageLoader::openICUMessageFile");
    UErrorCode status = U_ZERO_ERROR;
    CString resbundl_path_ICU;

    const int size_locale_ICU = 50;

    // the static AcceptLangauges takes precedence over what
    // parms.acceptlangauges has
    AcceptLanguageList acceptlanguages;
    acceptlanguages = (_acceptlanguages.size() > 0) ?
        _acceptlanguages : parms.acceptlanguages;

    // get the correct path to the resource bundles
    resbundl_path_ICU = getQualifiedMsgPath(parms.msg_src_path).getCString();

    //cout << "USING PACKAGE PATH: " << endl;
    //cout << resbundl_path_ICU << endl;
    PEG_TRACE_STRING(TRC_L10N, Tracer::LEVEL4, "Using resource bundle path:");
    PEG_TRACE_STRING(TRC_L10N, Tracer::LEVEL4, resbundl_path_ICU);
#ifdef PEGASUS_OS_OS400
    const char *atoe = resbundl_path_ICU;
    AtoE((char*)atoe);
#endif

    if (_useProcessLocale ||
        (acceptlanguages.size() == 0 && parms.useProcessLocale))
    {
        // use the system default resource bundle

        parms._resbundl = ures_open(
            (const char*)resbundl_path_ICU, uloc_getDefault(), &status);

        if (U_SUCCESS(status))
        {
            UErrorCode _status = U_ZERO_ERROR;
            PEG_TRACE_STRING(TRC_L10N, Tracer::LEVEL4, "Using process locale:");
            PEG_TRACE_STRING(TRC_L10N, Tracer::LEVEL4,
                ures_getLocale(parms._resbundl, &_status));
            if (status == U_USING_FALLBACK_WARNING ||
                status == U_USING_DEFAULT_WARNING)
            {
                PEG_TRACE_STRING(TRC_L10N, Tracer::LEVEL4,
                    "Using process locale fallback or default");
            }
            const char * _locale = ures_getLocale(parms._resbundl,&status);
#ifdef PEGASUS_OS_OS400
            char tmplcl[size_locale_ICU];
            strcpy(tmplcl, _locale);
            EtoA(tmplcl);
            String localeStr(tmplcl);
#else
            String localeStr(_locale);
#endif
			// The "root" locale indicates that an ICU message bundle is not present
			// for the current locale setting.
            if (localeStr != "root")
            {
                parms.contentlanguages.append(LanguageTag(
                    LanguageParser::convertLocaleIdToLanguageTag(localeStr)));
            }
        }
        else
        {
            PEG_TRACE_STRING(TRC_L10N, Tracer::LEVEL4,
                "Using process locale.  Could not open resource, "
                    "formatting default message.");
            // magic number to indicate no ICU resource bundle to use
            parms._resbundl = NO_ICU_MAGIC;
        }
        PEG_METHOD_EXIT();
        return;
    }
    else if (acceptlanguages.size() == 0 && parms.useThreadLocale)
    {
        // get AcceptLanguageList from the current Thread
        AcceptLanguageList *al = Thread::getLanguages();
        if (al != NULL)
        {
            acceptlanguages = *al;
            PEG_TRACE_STRING(TRC_L10N, Tracer::LEVEL4,
                "Using thread locale: got AcceptLanguageList from thread.");
        }
        else
        {
            PEG_TRACE_STRING(TRC_L10N, Tracer::LEVEL4,
                "Using thread locale: thread returned NULL for "
                    "AcceptLanguageList.");
        }
    }

    char locale_ICU[size_locale_ICU];
    LanguageTag languageTag;

    // iterate through AcceptLanguageList, use the first resource bundle match
    PEG_TRACE_STRING(TRC_L10N, Tracer::LEVEL4,
        "Looping through AcceptLanguageList...");
    for (Uint32 index = 0; index < acceptlanguages.size(); index++)
    {
        languageTag = acceptlanguages.getLanguageTag(index);
#ifdef PEGASUS_OS_OS400
        CString cstr = languageTag.toString().getCString();
        const char *atoe = cstr;
        AtoE((char*)atoe);

        uloc_getName(atoe, locale_ICU, size_locale_ICU, &status);
#else
        uloc_getName(
            (const char*)(languageTag.toString()).getCString(),
            locale_ICU, size_locale_ICU, &status);
#endif
        // TODO: check to see if we have previously cached the resource bundle

        parms._resbundl =
            ures_open((const char*)resbundl_path_ICU, locale_ICU, &status);

        if (U_SUCCESS(status))
        {
            PEG_TRACE_STRING(TRC_L10N, Tracer::LEVEL4,
                "ACCEPTLANGUAGES LOOP: opened resource bundle with:");
            PEG_TRACE_STRING(TRC_L10N, Tracer::LEVEL4, languageTag.toString());
            if (status == U_USING_FALLBACK_WARNING ||
                status == U_USING_DEFAULT_WARNING)
            {
                // we want to use the ICU fallback behaviour in the following
                // cases ONLY
                PEG_TRACE_STRING(TRC_L10N, Tracer::LEVEL4,
                    "ACCEPTLANGUAGES LOOP: ICU warns using FALLBACK or "
                        "DEFAULT");
                if ((acceptlanguages.size() == 1) && (!parms.useICUfallback) &&
                    (status == U_USING_DEFAULT_WARNING))
                {
                    // in this case we want to return messages from the root
                    // bundle
                    status = U_ZERO_ERROR;
                    PEG_TRACE_STRING(TRC_L10N, Tracer::LEVEL4,
                        "acceptlang.size =1 && !parms.useICUfallback && "
                            "U_USING_DEFAULT_WARNING, using root bundle.");

                    // Reopen the bundle in the root locale
                    ures_close(parms._resbundl);
                    parms._resbundl = ures_open(
                        (const char*)resbundl_path_ICU, "", &status);
                    if (U_SUCCESS(status))
                    {
                        PEG_METHOD_EXIT();
                        return;
                    }
                }
                else if (acceptlanguages.size() == 1 || parms.useICUfallback)
                {
                    PEG_TRACE_STRING(TRC_L10N, Tracer::LEVEL4,
                        "ACCEPTLANGUAGES LOOP: acceptlanguages.size == 1 or "
                            "useICUfallback true, using ICU fallback "
                            "behaviour...");
                    const char* _locale =
                        ures_getLocale(parms._resbundl, &status);

#ifdef PEGASUS_OS_OS400
                    char tmplcl[size_locale_ICU];
                    strcpy(tmplcl, _locale);
                    EtoA(tmplcl);
                    String localeStr(tmplcl);
#else
                    String localeStr(_locale);
#endif

					// The "root" locale indicates that an ICU message bundle is not present
					// for the current locale setting.
                    if (localeStr != "root")
                    {
                        parms.contentlanguages.append(LanguageTag(
                            LanguageParser::convertLocaleIdToLanguageTag(
                                localeStr)));
                    }
                    PEG_METHOD_EXIT();
                    return;
                }
            }
            else
            {
                // we found an exact resource bundle match, extract, and set
                // ContentLanguage

                PEG_TRACE_STRING(TRC_L10N, Tracer::LEVEL4,
                    "ACCEPTLANGUAGES LOOP: found an EXACT resource bundle "
                        "MATCH:");
                PEG_TRACE_STRING(TRC_L10N, Tracer::LEVEL4,
                    languageTag.toString());
                parms.contentlanguages.append(
                    LanguageTag(languageTag.toString()));
                PEG_METHOD_EXIT();
                return;
            }
        }
        else
        {