src/soap/SoapFault.cpp

/*
 *   Copyright 2003-2004 The Apache Software Foundation.
// (c) Copyright IBM Corp. 2004, 2005 All Rights Reserved
 *
 *   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
 *
 *   Unless required by applicable law or agreed to in writing, software
 *   distributed under the License is distributed on an "AS IS" BASIS,
 *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *   See the License for the specific language governing permissions and
 *   limitations under the License.
 */
 
/*
 * @author Roshan Weerasuriya (roshan@opensource.lk, roshanw@jkcsworld.com)
 * @author Damitha Kumarage (damitha@opensource.lk, damitha@jkcsworld.com)
 */

// !!! This include file must be first thing in file !!!
#include "../platforms/PlatformAutoSense.hpp"

#include <axis/SoapEnvVersions.hpp>
#include <axis/GDefine.hpp>

#include "SoapFault.h"
#include "SoapSerializer.h"
#include "SoapDeSerializer.h"
#include "../common/AxisConfig.h"

#include "../common/AxisTrace.h"


// This array of structure is used to store all the soap faults
// which are used in Axis C++. Each time a fault object is needed it is
// created using this array, in SoapFault class.

static SoapFaultStruct* s_parrSoapFaultStruct;

extern AxisConfig* g_pConfig;
AXIS_CPP_NAMESPACE_START
extern SoapEnvVersionsStruct gs_SoapEnvVersionsStruct[VERSION_LAST];
volatile bool SoapFault::m_bInit = false;

SoapFault::
SoapFault()
{
    m_bIsSimpleDetail = false;
    m_pFaultDetail = NULL;
    m_pFaultcodeParam = NULL;
    m_pFaultstringParam = NULL;
    m_pFaultactorParam = NULL;    
}

SoapFault::
~SoapFault()
{
    delete m_pFaultcodeParam;
    delete m_pFaultstringParam;
    delete m_pFaultactorParam;
    delete m_pFaultDetail;
}

int SoapFault::
serialize(SoapSerializer& pSZ, SOAP_VERSION eSoapVersion)
{
	logEntryEngine("SoapFault::serialize")

    // written according to SOAP Version 1.1
    int iStatus= AXIS_SUCCESS;
    pSZ.setStyle(DOC_LITERAL);
    pSZ.serialize("<", gs_SoapEnvVersionsStruct[eSoapVersion].pchPrefix, ":",
        gs_SoapEnvVersionsStruct[eSoapVersion].pchWords[SKW_FAULT], ">\n", NULL);

    m_pFaultcodeParam->serialize(pSZ);
    m_pFaultstringParam->serialize(pSZ);

    if(m_pFaultactorParam)
        m_pFaultactorParam->serialize(pSZ);

    if(m_pFaultDetail)
    {
        pSZ.serialize("<detail>", NULL);
        m_pFaultDetail->serialize(pSZ);
        pSZ.serialize("</detail>\n", NULL);
    }

    pSZ.serialize("</", gs_SoapEnvVersionsStruct[eSoapVersion].pchPrefix, ":",
        gs_SoapEnvVersionsStruct[eSoapVersion].pchWords[SKW_FAULT], ">\n", NULL);

    logExitWithReturnCode(iStatus)

    return iStatus;
}



void SoapFault::
initialize()
{
    if (!m_bInit)
    {
        static SoapFaultStruct s_arrLocalFaultStruct[FAULT_LAST] = 
        {
            /*VersionMismatch faults */
        /*0*/    {"VersionMismatch", "Soap Version Mismatch error", "", ""},
            /*MustUnderstand faults */ 
        /*1*/    {"MustUnderstand", "Soap Must Understand  error", "", ""},
            /*Client faults */
        /*2*/    {"Client", "Soap message is incorrect or incomplete", "", ""},
        /*3*/    {"Client", "Soap Action header empty", "", ""},
        /*4*/    {"Client", "Soap content is not valid", "", ""},
        /*5*/    {"Client", "No method to invoke", "", ""},
        /*6*/    {"Client", "Content is not Soap", "", ""},
        /*7*/    {"Client", "Requested service is not registered at the server", "", ""},
        /*8*/    {"Client", "Soap method is not allowed to invoke", "", ""},
        /*9*/    {"Client", "Parameter type mismatch", "", ""},
        /*10*/    {"Client", "A client handler failed", "", ""},
        /*11*/    {"Client", "Client transport exception", "", ""},
        /*12*/    {"Client", "Client transport open connection failed", "", ""},
        /*13*/    {"Client", "Client transport type mismatch", "", ""},
        /*14*/    {"Client", "Client transport has no unsecure transport layer", "", ""},
        /*15*/    {"Client", "Client transport has no secure transport layer", "", ""},
        /*16*/    {"Client", "Client SSL channel reception error", "", ""},
        /*17*/    {"Client", "Client SSL channel sending error", "", ""},
        /*18*/    {"Client", "Client SSL channel init error", "", ""},
        /*19*/    {"Client", "Client SSL channel socket create error", "", ""},
        /*20*/    {"Client", "Client SSL channel socket connect error", "", ""},
        /*21*/    {"Client", "Client SSL channel invalid socket error", "", ""},
        /*22*/    {"Client", "Client SSL channel context create error", "", ""},
        /*23*/    {"Client", "Client SSL channel error", "", ""},
        /*24*/    {"Client", "Client MIME content ID not unique", "", ""},

            /*Server faults */
        /*25*/    {"Server", "Unknown Server Engine Exception", "", ""},
        /*26*/    {"Server", "Cannot load web service", "", ""},
        /*27*/    {"Server", "Cannot load service handlers", "", ""},
        /*28*/    {"Server", "DLOPEN FAILED in loading transport library", "", ""},
        /*29*/    {"Server", "DLOPEN FAILED in loading parser library", "", ""},
        /*30*/    {"Server", "A service handler failed", "", ""},
        /*31*/    {"Server", "Webservice failed", "", ""},
        /*32*/    {"Server", "Handler initialization failed", "", ""},
        /*33*/    {"Server", "Handler creation failed", "", ""},
        /*34*/    {"Server", "Library loading failed", "", ""},
        /*35*/    {"Server", "Handler not loaded", "", ""},
        /*36*/    {"Server", "Handler is being used", "", ""},
        /*37*/    {"Server", "Get hander failed", "", ""},
        /*38*/    {"Server", "Wrong handler type", "", ""},
        /*39*/    {"Server", "Unknown Axis Configuration Exception", "", ""},
        /*40*/    {"Server", "Transport configuration error", "", ""},
        /*41*/    {"Server", "Library path is empty", "", ""},
        /*42*/    {"Server", "Wsdd file not found", "", ""},
        /*43*/    {"Server", "Unknown Wsdd Exception", "", ""},
        /*44*/    {"Server", "No handlers configured", "", ""},
        /*45*/    {"Server", "Unknown Soap Exception", "", ""},
        /*46*/    {"Server", "Unknown Transport Exception", "", ""},
        /*47*/    {"Server", "Receive from transport failed", "", ""},
        /*48*/    {"Server", "Send to transport failed", "", ""},
        /*49*/    {"Server", "HTTP Error, cannot process response message", "", ""},
        /*50*/    {"Server", "Unnknown HTTP response, cannot process response message", "", ""},
        /*51*/    {"Server", "Http transport exception", "", ""},
        /*52*/    {"Server", "Unexpected string", "", ""},
        /*53*/    {"Server", "Cannot initialize a channel to the remote end", "", ""},
        /*54*/    {"Server", "Sockets error Couldn't create socket", "", ""},
        /*55*/    {"Server", "Cannot open a channel to the remote end, shutting down the channel", "", ""},
        /*56*/    {"Server", "Invalid socket. Socket may not be open", "", ""},
        /*57*/    {"Server", "Output streaming error on Channel while writing data", "", ""},
        /*58*/    {"Server", "Input streaming error while getting data", "", ""},
        /*59*/    {"Server", "Channel error while waiting for timeout", "", ""},
        /*60*/    {"Server", "Channel error connection timeout before receiving", "", ""},
        /*61*/    {"Server", "Loading SSL channel failed", "", ""},
        /*62*/    {"Server", "Loading channel failed", "", ""},
        /*63*/    {"Server", "Transport buffer is empty", "", ""},
        /*64*/    {"Server", "Buffer received from the parser is empty", "", ""},
        /*65*/    {"Server", "XML_STATUS_ERROR thrown from parser", "", ""},
        /*66*/    {"Server", "Error when getting the byte stream from the transport", "", ""},
        /*67*/    {"Server", "Test exception", "", ""},
        /*68*/    {"Server", "Unknown exception", "", ""},
        /*69*/    {"Server", "Server and Client engines mismatch", "", ""},
            
        /*70*/    {"AXISC", "Service thrown exception", "", ""},
        /*71*/    {"AXISC", "Unknown element exception", "", ""},
        /*72*/    {"AXISC", "Node value mismatch exception", "", ""},
        /*73*/    {"AXISC", "Configuration read exception", "", ""},

        /*74*/    {"AXISC", "Configuration defaults already set", "", ""},

        /*75*/    {"Server", "Redirect received", "", ""}

        };
        s_parrSoapFaultStruct = s_arrLocalFaultStruct;
        m_bInit = true;
    }
}

/*the caller of the SoapFault::getSoapFault(int) has to delete the 
 * returned SoapFault pointer
 */
SoapFault* SoapFault::
getSoapFault(int iFaultCode)
{   
	logEntryEngine("SoapFault::getSoapFault")

    SoapFault* pSoapFault= NULL;

    // fill the soap fault object 
    pSoapFault= new SoapFault();
        
    /* TODO *********************************************** */
    /* the soap envelope namespace prefix to be obtained from 
     * gs_SoapEnvVersionsStruct should depend on the relevant SOAP VERSION
     */
     string strFaultcode = s_parrSoapFaultStruct[iFaultCode].pcFaultcode;
     string strSoapEnvVerStruct = gs_SoapEnvVersionsStruct[SOAP_VER_1_1].pchPrefix;
     pSoapFault->setFaultcode((strSoapEnvVerStruct + ":" + strFaultcode).c_str());
     pSoapFault->setFaultstring(s_parrSoapFaultStruct[iFaultCode].pcFaultstring);
     /* Fault actor should be set to the node url in which Axis C++ running.
      * Currently it is hardcoded to localhost
      */

    char* pcNodeName = g_pConfig->getAxisConfProperty(AXCONF_NODENAME);
    char* pcPort = g_pConfig->getAxisConfProperty(AXCONF_LISTENPORT);
    string strUrl = pcNodeName;
    strUrl += ":";
    strUrl += string(pcPort);
    pSoapFault->setFaultactor(strUrl.c_str());             
    pSoapFault->setFaultDetail(s_parrSoapFaultStruct[iFaultCode].pcFaultDetail);
    
    logExitWithPointer(pSoapFault)
    
    return pSoapFault;
}

SoapFault::
SoapFault(string sFaultcode, string sFaultstring, string sFaultactor, string sDetail) 
{
	logEntryEngine("SoapFault::SoapFault")

    m_sFaultcode= sFaultcode;
    m_sFaultstring= sFaultstring;
    m_sFaultactor= sFaultactor;
    m_sFaultDetail= sDetail;    
    
    logExit()
}

int SoapFault::
setParam(Param* pParam, const AxisChar* pchName, const void* pValue, XSDTYPE type)
{
	logEntryEngine("SoapFault::setParam")

	int Status = AXIS_FAIL;
	
    if (pParam) 
    {        
    	pParam->m_sName = pchName;
    	pParam->setValue( type , (IAnySimpleType*) pValue);
    	Status = AXIS_SUCCESS;
    }
    
    logExitWithReturnCode(Status)
    
    return Status;
}

int SoapFault::
setFaultcode(const AxisChar* sFaultcode)
{
	logEntryEngine("SoapFault::setFaultcode")

    m_pFaultcodeParam = new Param();
    setParam(m_pFaultcodeParam, "faultcode", new String((xsd__string)sFaultcode), XSD_STRING); 
    m_sFaultcode= sFaultcode;

    logExitWithReturnCode(AXIS_SUCCESS)

    return AXIS_SUCCESS;
}

int SoapFault::
setFaultstring(const AxisChar* sFaultstring)
{
	logEntryEngine("SoapFault::setFaultstring")

    m_pFaultstringParam = new Param();
    setParam(m_pFaultstringParam, "faultstring", new String((xsd__string)sFaultstring), XSD_STRING); 
    m_sFaultstring= sFaultstring;

    logExitWithReturnCode(AXIS_SUCCESS)

    return AXIS_SUCCESS;
}
int SoapFault::
setFaultactor(const AxisChar* sFaultactor)
{
	logEntryEngine("SoapFault::setFaultactor")

    m_pFaultactorParam = new Param();
    setParam(m_pFaultactorParam, "faultactor", new String((xsd__string)sFaultactor), XSD_STRING); 
    m_sFaultactor = sFaultactor;
    
    logExitWithReturnCode(AXIS_SUCCESS)

    return AXIS_SUCCESS;
}

int SoapFault::
setFaultDetail(const AxisChar* sFaultDetail)
{
	logEntryEngine("SoapFault::setFaultDetail")

    m_pFaultDetail = new Param();
    setParam(m_pFaultDetail, "appSpecific", new String((xsd__string)sFaultDetail), XSD_STRING);
    m_sFaultDetail = sFaultDetail;
    m_bIsSimpleDetail = true;

    logExitWithReturnCode(AXIS_SUCCESS)

    return AXIS_SUCCESS;
}

int SoapFault::
setFaultDetail(const Param* pFaultDetail)
{
	logEntryEngine("SoapFault::setFaultDetail")

    m_pFaultDetail = (Param*) pFaultDetail;

    logExitWithReturnCode(AXIS_SUCCESS)

    return AXIS_SUCCESS;
}

int SoapFault::
setCmplxFaultObjectName(const string& sCmplxFaultObjectName)
{
	logEntryEngine("SoapFault::setCmplxFaultObjectName")

    m_sCmplxFaultObjectName = sCmplxFaultObjectName;
	
    logExitWithReturnCode(AXIS_SUCCESS)

    return AXIS_SUCCESS;
}

int SoapFault::
setCmplxFaultObject(const void* pCmplxFaultObject)
{
	logEntryEngine("SoapFault::setCmplxFaultObject")

    m_pCmplxFaultObject = pCmplxFaultObject;

    logExitWithReturnCode(AXIS_SUCCESS)

    return AXIS_SUCCESS;
}

void SoapFault::
setPrefix(const AxisChar* prefix)
{
    m_strPrefix = prefix;
}

void SoapFault::
setLocalName(const AxisChar* localname)
{
    m_strLocalname = localname;
}

void SoapFault::
setURI(const AxisChar* uri)
{
    m_strUri = uri;
}

void SoapFault::
setDeSerializer(SoapDeSerializer* pDZ)
{
    m_pDZ = pDZ;
}

const char* SoapFault::
getSoapString()
{
    return m_sFaultstring.c_str(); 
}

const AxisChar* SoapFault::
getFaultcode()
{
    return m_sFaultcode.c_str();
}

const AxisChar* SoapFault::
getFaultstring()
{
    return m_sFaultstring.c_str();
}

const AxisChar* SoapFault::
getFaultactor()
{
    return m_sFaultactor.c_str();
}

const AxisChar* SoapFault::
getSimpleFaultDetail()
{
    return m_sFaultDetail.c_str();
}

const AxisChar* SoapFault::
getCmplxFaultObjectName()
{
    return m_sCmplxFaultObjectName.c_str();
}

void* SoapFault::
getCmplxFaultObject(void* pDZFunct, void* pCreFunct, void* pDelFunct,
                    const AxisChar* pName, const AxisChar* pNamespace)
{ 
    return m_pDZ->getCmplxObject (pDZFunct, pCreFunct, pDelFunct, pName, pNamespace, true);
}

const void* SoapFault::
getCmplxFaultObject()
{
    return m_pCmplxFaultObject;
}

bool SoapFault::
operator ==(const SoapFault &objSoapFault)
{
    if ((m_sFaultcode == objSoapFault.m_sFaultcode) &&
        (m_sFaultstring == objSoapFault.m_sFaultstring) &&
        (m_sFaultactor == objSoapFault.m_sFaultactor) &&
        (m_sFaultDetail == objSoapFault.m_sFaultDetail))
    {
        return true;
    }

    return false;
}

AXIS_CPP_NAMESPACE_END