/*
Without Ethernet-Header,VLAN-Tag or any TLV
*/
static lbmpdu_t generateLbmPdu(void * mp,int mpFlag)//Modified 10:50,07-22
{
CFMHeader_t header ;
lbmpdu_t pdu ;
MEP_t mep;
if(mp==NULL)return faultMsg("mp is NULL in generateLbmPdu");
if(mpFlag==MEP)mep=(MEP_t)mp;
else return NULL;
pdu = (lbmpdu_t)alloc(sizeof(struct lbmpdu_st));
if(pdu==NULL)return faultMsg("Cannot alloc <pdu> in generateLbmPdu()");
header = generateCFMHeader(mep->MEPBasic.ma->MDPointer->MDLevel,type_LBM, 0);
pdu->header = header ;
pdu->ltransId = mep->lbpm->nextLBMtransID;
pdu->endTLVOffset = 0 ;
return pdu ;
}
virtual bool execute(const HttpRequestContext& requestContext, ///< request context
UtlSList& params, ///< request param list
void* userData, ///< user data
XmlRpcResponse& response, ///< request response
ExecutionStatus& status
)
{
UtlString* dbName = dynamic_cast<UtlString*>(params.at(0));
if (dbName && !dbName->isNull())
{
OsReadLock lock(*ConfigRPC::spDatabaseLock);
ConfigRPC* db = ConfigRPC::find(*dbName);
if (db)
{
status = db->mCallback->accessAllowed(requestContext, ConfigRPC_Callback::Version);
if ( XmlRpcMethod::OK == status )
{
response.setResponse(&db->mVersion);
}
else
{
UtlString faultMsg("Access Denied");
response.setFault(XmlRpcMethod::FAILED, faultMsg.data());
}
}
else
{
UtlString faultMsg;
faultMsg.append("db lookup failed for '");
faultMsg.append(*dbName);
faultMsg.append("'");
response.setFault( XmlRpcResponse::UnregisteredMethod, faultMsg.data());
status = XmlRpcMethod::FAILED;
}
}
else
{
response.setFault( XmlRpcResponse::EmptyParameterValue
,"'dbname' parameter is missing or invalid type"
);
status = XmlRpcMethod::FAILED;
}
return true;
}
/*
Add Ethernet-Header,VLAN-Tag and TLVs to char[]
*/
static dataStream_t lbmpdu_format(uint8 destination_address[ADDR_LEN],uint8 priority,void * mp,int mpFlag)//Modified 11:00 07-22
{
int tlv_total_len=0,cnt=0 ,sender_id_tlv_len=0;
lbmpdu_t pdu ;
dataStream_t datas ;
MEP_t mep=NULL;
if(mpFlag==MEP)mep=(MEP_t)mp;
datas=(dataStream_t)alloc(sizeof(struct dataStream_st));
if(datas==NULL)
{
return faultMsg("Cannot alloc <datas> in lbmpdu_format()");
}
pdu = generateLbmPdu( mep,mpFlag);
#if 1
if(mep->lbpm->senderID_TLV_Contained)
{
switch(mep->MEPBasic.ma->SenderIDPermission)
{
case None:break;
case Chassis:;sender_id_tlv_len=gCfm->TLV.Sender_ID_TLV.chassis_ID_Length+2;break;
case Manage:sender_id_tlv_len=gCfm->TLV.Sender_ID_TLV.management_Address_Domain_Length+gCfm->TLV.Sender_ID_TLV.management_Address_Length+3;break;
case ChassisManage:
sender_id_tlv_len=gCfm->TLV.Sender_ID_TLV.chassis_ID_Length+gCfm->TLV.Sender_ID_TLV.management_Address_Domain_Length+gCfm->TLV.Sender_ID_TLV.management_Address_Length+4;
break;
}
tlv_total_len+=sender_id_tlv_len+3;
}
if(mep->lbpm->data_TLV_Contained)
{
tlv_total_len+=mep->lbpm->Data_TLV.length+3;
}
if(mep->lbpm->orgSpecificTLVContained)
{
tlv_total_len+=gCfm->TLV.Organization_Specific_TLV.length+3;
}
#endif
datas->length=ETHERNETHEAD_LEN+LBM_HEAD_LEN+VLAN_TAG_LEN+tlv_total_len ;
memcpy(datas->data,destination_address,ADDR_LEN);
memcpy(datas->data+ADDR_LEN,mep->MEPStatus.MACAddress,ADDR_LEN);
cnt=ADDR_LEN*2 ;
datas->data[cnt++]=0x81 ;
//Vlan-Tag
datas->data[cnt++]=0x00 ;
datas->data[cnt++]=(uint8)(priority<<5)+(uint8)(mep->MEPBasic.PrimaryVlan>>8);
datas->data[cnt++]=(uint8)(mep->MEPBasic.PrimaryVlan&0xFF);
//VlanId
datas->data[cnt++]=0x89 ;
//802.1agCFM Tag
datas->data[cnt++]=0x02 ;
datas->data[cnt++]=pdu->header->mdLevel_version ;
//CFM Header
datas->data[cnt++]=pdu->header->opCode ;
datas->data[cnt++]=pdu->header->flags ;
datas->data[cnt++]=pdu->header->firstTLVOffset ;
datas->data[cnt++]=(uint8)(pdu->ltransId>>24);
//LBM-TransID
datas->data[cnt++]=(uint8)((pdu->ltransId>>16)&0xFF);
datas->data[cnt++]=(uint8)((pdu->ltransId>>8)&0xFF);
datas->data[cnt++]=(uint8)(pdu->ltransId);
#if 1
if(mep->lbpm->senderID_TLV_Contained)
{
datas->data[cnt++]=gCfm->TLV.Sender_ID_TLV.type;
datas->data[cnt++]=(uint8)(sender_id_tlv_len>>8);
datas->data[cnt++]=(uint8)(sender_id_tlv_len&0x00FF);
if(mep->MEPBasic.ma->SenderIDPermission==Chassis||mep->MEPBasic.ma->SenderIDPermission==ChassisManage)
{
datas->data[cnt++]=gCfm->TLV.Sender_ID_TLV.chassis_ID_Length;
datas->data[cnt++]=gCfm->TLV.Sender_ID_TLV.chassis_ID_Subtype;
memcpy(datas->data+cnt,gCfm->TLV.Sender_ID_TLV.chassis_ID,gCfm->TLV.Sender_ID_TLV.chassis_ID_Length);
cnt+=gCfm->TLV.Sender_ID_TLV.chassis_ID_Length;
}
if(mep->MEPBasic.ma->SenderIDPermission==Manage){
datas->data[cnt++] = 0x00;
}
if(mep->MEPBasic.ma->SenderIDPermission==Manage||mep->MEPBasic.ma->SenderIDPermission==ChassisManage)
{
datas->data[cnt++]=gCfm->TLV.Sender_ID_TLV.management_Address_Domain_Length;
memcpy(datas->data+cnt,gCfm->TLV.Sender_ID_TLV.management_Address_Domain,gCfm->TLV.Sender_ID_TLV.management_Address_Domain_Length);
cnt+=gCfm->TLV.Sender_ID_TLV.management_Address_Domain_Length;
datas->data[cnt++]=gCfm->TLV.Sender_ID_TLV.management_Address_Length;
memcpy(datas->data+cnt,gCfm->TLV.Sender_ID_TLV.management_Address,gCfm->TLV.Sender_ID_TLV.management_Address_Length);
cnt+=gCfm->TLV.Sender_ID_TLV.management_Address_Length;
}
}
virtual bool execute(const HttpRequestContext& requestContext, ///< request context
UtlSList& params, ///< request param list
void* userData, ///< user data
XmlRpcResponse& response, ///< request response
ExecutionStatus& status
)
{
UtlString* dbName = dynamic_cast<UtlString*>(params.at(0));
if (dbName && !dbName->isNull())
{
OsReadLock lock(*ConfigRPC::spDatabaseLock);
ConfigRPC* db = ConfigRPC::find(*dbName);
if (db)
{
status = db->mCallback->accessAllowed(requestContext, ConfigRPC_Callback::Set);
if ( XmlRpcMethod::OK == status )
{
// read in the dataset
OsConfigDb dataset;
OsStatus datasetStatus = db->load(dataset);
if ( OS_SUCCESS == datasetStatus )
{
// get the list of names that the request is trying to delete
UtlContainable* secondParam = params.at(1);
if ( secondParam )
{
UtlSList* nameList = dynamic_cast<UtlSList*>(secondParam);
if (nameList)
{
/*
* Iterate over the names
* - For each name found, delete it from the dataset and count it
*/
UtlSListIterator deleteNames(*nameList);
UtlString* deleteName = NULL;
size_t deleted = 0;
while ((deleteName = dynamic_cast<UtlString*>(deleteNames())))
{
if (OS_SUCCESS == dataset.remove(*deleteName))
{
deleted++;
}
}
if (OS_SUCCESS == db->store(dataset))
{
status = XmlRpcMethod::OK;
UtlInt deletedCount(deleted);
response.setResponse(&deletedCount);
}
else
{
response.setFault( ConfigRPC::storeFailed
,"error storing dataset"
);
status = XmlRpcMethod::FAILED;
}
}
else
{
// The second parameter was not a list
response.setFault( ConfigRPC::invalidType
,"namelist parameter is not an array"
);
status = XmlRpcMethod::FAILED;
}
}
else // No second parameter
{
response.setFault( ConfigRPC::invalidType
,"no second parameter list of names to delete"
);
status = XmlRpcMethod::FAILED;
}
}
else
{
UtlString faultMsg("dataset load failed");
response.setFault(ConfigRPC::loadFailed, faultMsg);
status = XmlRpcMethod::FAILED;
}
}
else
{
UtlString faultMsg("Access Denied");
response.setFault(XmlRpcMethod::FAILED, faultMsg.data());
}
}
else
{
UtlString faultMsg;
faultMsg.append("db lookup failed for '");
faultMsg.append(*dbName);
faultMsg.append("'");
response.setFault( XmlRpcResponse::UnregisteredMethod, faultMsg.data());
status = XmlRpcMethod::FAILED;
}
}
else
{
response.setFault( XmlRpcResponse::EmptyParameterValue
,"'dbname' parameter is missing or invalid type"
);
status = XmlRpcMethod::FAILED;
}
return true;
}
virtual bool execute(const HttpRequestContext& requestContext, ///< request context
UtlSList& params, ///< request param list
void* userData, ///< user data
XmlRpcResponse& response, ///< request response
ExecutionStatus& status
)
{
UtlString* dbName = dynamic_cast<UtlString*>(params.at(0));
if (dbName && !dbName->isNull())
{
OsReadLock lock(*ConfigRPC::spDatabaseLock);
ConfigRPC* db = ConfigRPC::find(*dbName);
if (db)
{
status = db->mCallback->accessAllowed(requestContext, ConfigRPC_Callback::Set);
if ( XmlRpcMethod::OK == status )
{
// read in the dataset
OsConfigDb dataset;
OsStatus datasetStatus = db->load(dataset);
if ( OS_SUCCESS == datasetStatus )
{
// get the list of names that the request is asking for
UtlContainable* secondParam = params.at(1);
if ( secondParam )
{
UtlHashMap* paramList = dynamic_cast<UtlHashMap*>(secondParam);
if (paramList)
{
/*
* Iterate over the requested name/value pairs
*/
UtlHashMapIterator params(*paramList);
UtlContainable* nextParam = NULL;
size_t paramsSet = 0;
while ( XmlRpcMethod::OK == status
&& (nextParam = params())
)
{
UtlString* name = dynamic_cast<UtlString*>(params.key());
if ( name )
{
UtlString* value = dynamic_cast<UtlString*>(params.value());
if (value)
{
dataset.set(*name, *value);
paramsSet++;
}
else
{
UtlString faultMsg;
faultMsg.append("parameter name '");
faultMsg.append(*name);
faultMsg.append("' value is not a string");
response.setFault(ConfigRPC::invalidType, faultMsg.data());
status = XmlRpcMethod::FAILED;
}
}
else
{
UtlString faultMsg;
faultMsg.append("parameter number ");
char paramIndex[10];
sprintf(paramIndex,"%zu", paramsSet + 1);
faultMsg.append(paramIndex);
faultMsg.append(" name is not a string");
response.setFault(ConfigRPC::invalidType, faultMsg.data());
status = XmlRpcMethod::FAILED;
}
}
if ( XmlRpcMethod::OK == status )
{
if (OS_SUCCESS == db->store(dataset))
{
UtlInt numberSet(paramList->entries());
response.setResponse(&numberSet);
}
else
{
response.setFault( ConfigRPC::storeFailed
,"error storing dataset"
);
status = XmlRpcMethod::FAILED;
}
}
}
else
{
// The second parameter was not a list
response.setFault( ConfigRPC::invalidType
,"second parameter is not a struct"
);
status = XmlRpcMethod::FAILED;
}
}
else // no parameter names specified
{
// No second parameter
response.setFault( ConfigRPC::invalidType
,"no second parameter of name/value pairs"
);
status = XmlRpcMethod::FAILED;
}
}
else
{
UtlString faultMsg("dataset load failed");
response.setFault(ConfigRPC::loadFailed, faultMsg);
status = XmlRpcMethod::FAILED;
}
}
else
{
UtlString faultMsg("Access Denied");
response.setFault(XmlRpcMethod::FAILED, faultMsg.data());
}
}
else
{
UtlString faultMsg;
faultMsg.append("db lookup failed for '");
faultMsg.append(*dbName);
faultMsg.append("'");
response.setFault( XmlRpcResponse::UnregisteredMethod, faultMsg.data());
status = XmlRpcMethod::FAILED;
}
}
else
{
response.setFault( XmlRpcResponse::EmptyParameterValue
,"'dbname' parameter is missing or invalid type"
);
status = XmlRpcMethod::FAILED;
}
return true;
}
virtual bool execute(const HttpRequestContext& requestContext, ///< request context
UtlSList& params, ///< request param list
void* userData, ///< user data
XmlRpcResponse& response, ///< request response
ExecutionStatus& status
)
{
UtlString* dbName = dynamic_cast<UtlString*>(params.at(0));
if (dbName && !dbName->isNull())
{
OsReadLock lock(*ConfigRPC::spDatabaseLock);
// find the dataset registered with this name
ConfigRPC* db = ConfigRPC::find(*dbName);
if (db)
{
// check with the application to see if this request is authorized on this dataset
status = db->mCallback->accessAllowed(requestContext, ConfigRPC_Callback::Get);
if ( XmlRpcMethod::OK == status )
{
// read in the dataset
OsConfigDb dataset;
OsStatus datasetStatus = db->load(dataset);
if ( OS_SUCCESS == datasetStatus )
{
// get the list of names that the request is asking for
UtlContainable* secondParam = params.at(1);
if ( secondParam )
{
UtlSList* nameList = dynamic_cast<UtlSList*>(secondParam);
if (nameList)
{
/*
* Iterate over the requested names
* - All must be present or the request is an error
* - For each name found, add the name and value to the
* selectedParams hash to be returned in a success response.
*/
UtlHashMap selectedParams;
UtlSListIterator requestedNames(*nameList);
UtlString* requestedName = NULL;
bool allNamesFound = true;
while ( allNamesFound
&& (requestedName = dynamic_cast<UtlString*>(requestedNames()))
)
{
UtlString* paramValue = new UtlString();
if ( OS_SUCCESS == dataset.get(*requestedName, *paramValue) )
{
UtlString* paramName = new UtlString(*requestedName);
// put it into the results
selectedParams.insertKeyAndValue(paramName, paramValue);
}
else
{
allNamesFound = false;
delete paramValue;
}
}
if (allNamesFound)
{
// all were found - return the name/value pairs
response.setResponse(&selectedParams);
}
else
{
// at least one name was not found - return an error.
UtlString faultMsg;
faultMsg.append("parameter name '");
faultMsg.append(*requestedName);
faultMsg.append("' not found");
response.setFault(ConfigRPC::nameNotFound, faultMsg.data());
status = XmlRpcMethod::FAILED;
}
selectedParams.destroyAll();
}
else
{
// The second parameter was not a list
response.setFault( ConfigRPC::invalidType
,"namelist parameter is not an array"
);
status = XmlRpcMethod::FAILED;
}
}
else // no parameter names specified
{
// return all names
UtlHashMap allParams;
UtlString lastKey;
OsStatus iterateStatus;
UtlString* paramName;
UtlString* paramValue;
bool notEmpty = false;
for ( ( paramName = new UtlString()
,paramValue = new UtlString()
,iterateStatus = dataset.getNext(lastKey, *paramName, *paramValue)
);
OS_SUCCESS == iterateStatus;
( lastKey = *paramName
,paramName = new UtlString()
,paramValue = new UtlString()
,iterateStatus = dataset.getNext(lastKey, *paramName, *paramValue)
)
)
{
notEmpty = true; // got at least one parameter
// put it into the result array
allParams.insertKeyAndValue(paramName, paramValue);
}
// on the final iteration these were not used
delete paramName;
delete paramValue;
if (notEmpty)
{
response.setResponse(&allParams);
allParams.destroyAll();
}
else
{
// there is no way to send a well-formed but empty response,
// so a 'get all' on an empty dataset returns a fault.
UtlString faultMsg;
faultMsg.append("dataset '");
faultMsg.append(*dbName);
faultMsg.append("' has no parameters");
response.setFault(ConfigRPC::emptyDataset, faultMsg);
status = XmlRpcMethod::FAILED;
}
}
}
else
{
UtlString faultMsg("dataset load failed");
response.setFault(ConfigRPC::loadFailed, faultMsg);
status = XmlRpcMethod::FAILED;
}
}
else
{
UtlString faultMsg("Access Denied");
response.setFault(XmlRpcMethod::FAILED, faultMsg.data());
}
}
else
{
UtlString faultMsg;
faultMsg.append("db lookup failed for '");
faultMsg.append(*dbName);
faultMsg.append("'");
response.setFault( XmlRpcResponse::UnregisteredMethod, faultMsg.data());
status = XmlRpcMethod::FAILED;
}
}
else
{
response.setFault( XmlRpcResponse::EmptyParameterValue
,"'dbname' parameter is missing or invalid type"
);
status = XmlRpcMethod::FAILED;
}
return true;
}
bool XmlRpcDispatch::parseXmlRpcRequest(const UtlString& requestContent,
XmlRpcMethodContainer*& methodContainer,
UtlSList& params,
XmlRpcResponse& response)
{
bool result = false;
// Parse the XML-RPC response
TiXmlDocument doc("XmlRpcRequest.xml");
doc.Parse(requestContent);
if (!doc.Error())
{
TiXmlNode* rootNode = doc.FirstChild ("methodCall");
if (rootNode != NULL)
{
// Positive response example
//
// <methodCall>
// <methodName>examples.getStateName</methodName>
// <params>
// <param>
// <value><i4>41</i4></value>
// </param>
// </params>
// </methodCall>
TiXmlNode* methodNode = rootNode->FirstChild("methodName");
if (methodNode)
{
// Check whether the method exists or not. If not, send back a fault response
UtlString methodCall = methodNode->FirstChild()->Value();
methodContainer = (XmlRpcMethodContainer*) mMethods.findValue(&methodCall);
if (methodContainer)
{
/*
* Since params are optional,
* assume all is well until proven otherwise now
*/
result = true;
TiXmlNode* paramsNode = rootNode->FirstChild("params");
if (paramsNode)
{
int index = 0;
for (TiXmlNode* paramNode = paramsNode->FirstChild("param");
result /* stop if any error */ && paramNode /* or no more param nodes */;
paramNode = paramNode->NextSibling("param"))
{
TiXmlNode* subNode = paramNode->FirstChild("value");
if (subNode)
{
UtlString parseErrorMsg;
UtlContainable* param = XmlRpcBody::parseValue(subNode, 0, parseErrorMsg);
if (param)
{
params.append(param);
index++;
}
else
{
char errorLoc[200];
sprintf(errorLoc," in param %d",
index);
OsSysLog::add(FAC_XMLRPC, PRI_ERR,
"XmlRpcDispatch::parseXmlRpcRequest"
" invalid <value> contents %s of %s",
errorLoc, requestContent.data());
parseErrorMsg.append(errorLoc);
response.setFault(EMPTY_PARAM_VALUE_FAULT_CODE,
parseErrorMsg.data());
result=false;
}
}
else
{
char errorLoc[200];
sprintf(errorLoc,"no <value> element in param %d.",
index);
OsSysLog::add(FAC_XMLRPC, PRI_ERR,
"XmlRpcDispatch::parseXmlRpcRequest %s of: %s",
errorLoc, requestContent.data());
response.setFault(EMPTY_PARAM_VALUE_FAULT_CODE,
errorLoc);
result=false;
}
}
}
else
{
OsSysLog::add(FAC_XMLRPC, PRI_ERR,
"XmlRpcDispatch::parseXmlRpcRequest no <params> element found");
response.setMethod(methodCall);
response.setFault(ILL_FORMED_CONTENTS_FAULT_CODE, "no <params> element");
result = false;
}
}
else
{
OsSysLog::add(FAC_XMLRPC, PRI_ERR,
"XmlRpcDispatch::parseXmlRpcRequest no method '%s' registered",
methodCall.data());
response.setMethod(methodCall);
response.setFault(UNREGISTERED_METHOD_FAULT_CODE, UNREGISTERED_METHOD_FAULT_STRING);
result = false;
}
}
else
{
UtlString faultMsg(INVALID_ELEMENT_FAULT_STRING);
faultMsg.append("methodName not found");
OsSysLog::add(FAC_XMLRPC, PRI_ERR,
"XmlRpcDispatch::parseXmlRpcRequest %s", faultMsg.data());
response.setFault(INVALID_ELEMENT, faultMsg.data());
result = false;
}
}
else
{
UtlString faultMsg(INVALID_ELEMENT_FAULT_STRING);
faultMsg.append("methodCall not found");
OsSysLog::add(FAC_XMLRPC, PRI_ERR,
"XmlRpcDispatch::parseXmlRpcRequest %s", faultMsg.data());
response.setFault(INVALID_ELEMENT, faultMsg.data());
result = false;
}
}
else
{
OsSysLog::add(FAC_XMLRPC, PRI_ERR,
"XmlRpcDispatch::parseXmlRpcRequest"
" ill-formed XML contents in %s. Parsing error = %s",
requestContent.data(), doc.ErrorDesc());
response.setFault(ILL_FORMED_CONTENTS_FAULT_CODE, ILL_FORMED_CONTENTS_FAULT_STRING);
result = false;
}
return result;
}
