// %%% luz:2003-04-24: added syncmlvers parameter
// %%% luz:2003-07-31: changed to vers enum
Ret_t getExtName(SmlPcdataExtension_t ext, String_t *name, SmlVersion_t vers) {
DtdPtr_t dtdhead = getDtdTable();
DtdPtr_t dtd = dtdhead;
const char *dtdname;
if (!dtdhead) return -1;
for (;dtd->ext != SML_EXT_LAST; dtd++) {
if (!dtd->name) continue; /* skip empty names (should not appear but better be on the safe side) */
if (dtd->ext == ext) {
String_t _tmp;
// this is the default
dtdname=dtd->name;
// %%% luz:2003-04-24: added dynamic generation of namespace according to SyncML version
if (ext==SML_EXT_UNDEFINED && vers!=SML_VERS_UNDEF) {
// this requests SyncML namespace
dtdname=SyncMLNamespaces[vers];
}
_tmp = smlLibMalloc(smlLibStrlen(dtdname)+1);
if (!_tmp) {
freeDtdTable(dtdhead);
return SML_ERR_NOT_ENOUGH_SPACE;
}
smlLibStrcpy(_tmp, dtdname);
freeDtdTable(dtdhead);
*name = _tmp;
return SML_ERR_OK;
}
}
freeDtdTable(dtdhead);
return -1;
}
/**
* FUNCTION: smlLibStrdup
*
* Duplicates the String "constStringP".
* Returns a pointer to the new copy of "constStringP".
*
* IN: String_t constStringP string, which is duplicated
* RETURN: String_t pointer to the new copy,
* null, if no copy could be allocated
*/
SML_API String_t smlLibStrdup (const char *constStringP)
{
String_t _new_str;
// allocate memory for new copy
_new_str = (String_t)smlLibMalloc(smlLibStrlen(constStringP) + 1);
// Copy the string into the new memory
if (_new_str != NULL)
smlLibStrcpy(_new_str, constStringP);
return _new_str;
}
/**
* FUNCTION: smlString2Pcdata
*
* copy a string into a Pcdata structure
*
* IN: String_t
* Input String
*
* RETURN: SmlPcdataPtr_t
* A Pointer to a PcData structure
*
*/
SML_API SmlPcdataPtr_t smlString2Pcdata(String_t str)
{
/* Definitions */
SmlPcdataPtr_t pcdata;
/* Invalid Input */
if (! str)
return NULL;
/* Allocate the PcData Structure */
pcdata = (SmlPcdataPtr_t)smlLibMalloc((MemSize_t)sizeof(SmlPcdata_t));
if (! pcdata)
return NULL;
smlLibMemset (pcdata, 0, (MemSize_t)sizeof(SmlPcdata_t));
/* Set the PcData Structure */
pcdata->contentType = SML_PCDATA_STRING;
pcdata->length = smlLibStrlen( str );
pcdata->content = (VoidPtr_t)smlLibStrdup(str);
return pcdata;
}
/* decoder callbacks */
Ret_t buildDmTndFormatCmd(XltDecoderPtr_t pDecoder, VoidPtr_t *ppElem)
{
XltDecScannerPtr_t pScanner;
SmlDmTndFormatPtr_t pDmTndFormat;
Ret_t rc;
pScanner = pDecoder->scanner;
if (*ppElem != NULL)
return SML_ERR_XLT_INVAL_SYNCML_DOC;
if ((pDmTndFormat = (SmlDmTndFormatPtr_t)smlLibMalloc(sizeof(SmlDmTndFormat_t))) == NULL)
return SML_ERR_NOT_ENOUGH_SPACE;
smlLibMemset(pDmTndFormat, 0, sizeof(SmlDmTndFormat_t));
if (IS_EMPTY(pScanner->curtok)) {
*ppElem = pDmTndFormat;
return SML_ERR_OK;
}
if (((rc = nextToken(pDecoder)) != SML_ERR_OK)) {
smlFreeDmTndFormat(pDmTndFormat);
return rc;
}
while (pScanner->curtok->type != TOK_TAG_END) {
VoidPtr_t pContent = smlLibMalloc(6);
if ( pContent == NULL )
{
smlFreeDmTndFormat(pDmTndFormat);
return SML_ERR_NOT_ENOUGH_SPACE;
}
smlLibMemset(pContent, 0, 6);
switch (pScanner->curtok->tagid) {
case TN_DMTND_b64:
smlLibStrcpy(pContent, "b64");
break;
case TN_DMTND_bin:
smlLibStrcpy(pContent, "bin");
break;
case TN_DMTND_bool:
smlLibStrcpy(pContent, "bool");
break;
case TN_DMTND_chr:
smlLibStrcpy(pContent, "chr");
break;
case TN_DMTND_int:
smlLibStrcpy(pContent, "int");
break;
case TN_DMTND_node:
smlLibStrcpy(pContent, "node");
break;
case TN_DMTND_null:
smlLibStrcpy(pContent, "null");
break;
case TN_DMTND_xml:
smlLibStrcpy(pContent, "xml");
break;
case TN_DMTND_date:
smlLibStrcpy(pContent, "date");
break;
case TN_DMTND_time:
smlLibStrcpy(pContent, "time");
break;
case TN_DMTND_float:
smlLibStrcpy(pContent, "float");
break;
default:
KCDBG(">>>>> Unkown token: %d <<<<<\n", pScanner->curtok->tagid);
rc = SML_ERR_XLT_INVAL_SYNCML_DOC;
}
if (rc != SML_ERR_OK) {
smlLibFree(pContent);
smlFreeDmTndFormat(pDmTndFormat);
return rc;
}
rc = buildPCData(pDecoder, (VoidPtr_t)&pDmTndFormat->value);
if (rc != SML_ERR_OK) {
smlLibFree(pContent);
smlFreeDmTndFormat(pDmTndFormat);
return rc;
}
pDmTndFormat->value->content = pContent;
pDmTndFormat->value->length = smlLibStrlen(pContent);
if (((rc = nextToken(pDecoder)) != SML_ERR_OK)) {
smlLibFree(pContent);
smlFreeDmTndFormat(pDmTndFormat);
return rc;
}
if (pScanner->curtok->type != TOK_TAG_END) {
smlLibFree(pContent);
smlFreeDmTndFormat(pDmTndFormat);
return SML_ERR_XLT_INVAL_SYNCML_DOC;
}
}
*ppElem = pDmTndFormat;
return SML_ERR_OK;
}
/**
* FUNCTION: xmlGenerateTag
*
* Generates a XML tag
*
* PRE-Condition: valid parameters
*
* POST-Condition: the XML tag is written to the XML buffer
*
* IN: tagId, the ID for the tag to generate (TN_ADD, ...)
* tagType, the tag type (e.g. Begin Tag -> TT_BEG, ...)
* attFlag, indicates if the encoded tag contain Attributes in namespace extensions
*
* IN/OUT: pBufMgr, pointer to a structure containing buffer management elements
*
* RETURN: shows error codes of function,
* 0, if OK
*/
Ret_t xmlGenerateTag(XltTagID_t tagId, XltTagType_t tagType, BufferMgmtPtr_t pBufMgr, SmlPcdataExtension_t attFlag)
{
Ret_t _err;
MemByte_t _begpar = XML_BEGPAR;
MemByte_t _tagdel = XML_TAGDEL;
MemByte_t _endpar = XML_ENDPAR;
MemByte_t _nstagstart[] = XML_NSSTART;
MemByte_t _nstagend[] = XML_NSEND;
String_t _tagstr;
String_t _tagnsattr = NULL;
if ((_tagstr = (String_t)smlLibMalloc(XML_MAX_TAGLEN)) == NULL) return SML_ERR_NOT_ENOUGH_SPACE;
if ((_err = getTagString(tagId, _tagstr, attFlag)) != SML_ERR_OK) {
smlLibFree(_tagstr);
return _err;
}
if (!_tagstr) { // check again as _tagstr might be alterd in getTagString
smlLibFree(_tagstr);
return SML_ERR_XLT_INVAL_TAG_TYPE;
}
/* the <SyncML> tag _must_ have an xmlns attribute */
if (attFlag != pBufMgr->smlActiveExt || tagId == TN_SYNCML) {
// %%% luz:2003-07-31: now uses namespace from table according to version
if (getExtName(attFlag, &_tagnsattr, pBufMgr->vers) != SML_ERR_OK) {
smlLibFree(_tagstr);
return SML_ERR_XLT_INVAL_TAG_TYPE;
}
}
pBufMgr->smlActiveExt = attFlag;
//check if content byte has to be added to the tag
switch (tagType)
{
// set the end tag
case TT_END:
{
if ((_err = xltAddToBuffer((MemPtr_t)(&_begpar), 1, pBufMgr)) != SML_ERR_OK) break;
if ((_err = xltAddToBuffer((MemPtr_t)(&_tagdel), 1, pBufMgr)) != SML_ERR_OK) break;
if ((_err = xltAddToBuffer((MemPtr_t)_tagstr, smlLibStrlen(_tagstr), pBufMgr)) != SML_ERR_OK) break;
if ((_err = xltAddToBuffer((MemPtr_t)(&_endpar), 1, pBufMgr)) != SML_ERR_OK) break;
if (tagId == pBufMgr->switchExtTag) {
pBufMgr->smlActiveExt = pBufMgr->smlLastExt;
pBufMgr->smlCurExt = pBufMgr->smlLastExt;
pBufMgr->smlLastExt = attFlag;
}
// just forget the stored number ob bytes for this end-tag since written now
pBufMgr->endTagSize -= (3 + smlLibStrlen(_tagstr));
break;
}
//Empty tag
case TT_ALL:
{
if ((_err = xltAddToBuffer((MemPtr_t)(&_begpar), 1, pBufMgr)) != SML_ERR_OK) break;
if ((_err = xltAddToBuffer((MemPtr_t)_tagstr, smlLibStrlen(_tagstr), pBufMgr)) != SML_ERR_OK) break;
if (_tagnsattr) {
if ((_err = xltAddToBuffer((MemPtr_t)(&_nstagstart), 8, pBufMgr)) != SML_ERR_OK) break;
if ((_err = xltAddToBuffer((MemPtr_t)_tagnsattr, smlLibStrlen(_tagnsattr), pBufMgr)) != SML_ERR_OK) break;
if ((_err = xltAddToBuffer((MemPtr_t)&_nstagend, 1, pBufMgr)) != SML_ERR_OK) break;
}
if ((_err = xltAddToBuffer((MemPtr_t)(&_tagdel), 1, pBufMgr)) != SML_ERR_OK) break;
if ((_err = xltAddToBuffer((MemPtr_t)(&_endpar), 1, pBufMgr)) != SML_ERR_OK) break;
break;
}
//Only Begin Tag -> content follows -> content byte has to be added
case TT_BEG:
{
if ((_err = xltAddToBuffer((MemPtr_t)(&_begpar), 1, pBufMgr)) != SML_ERR_OK) break;
if ((_err = xltAddToBuffer((MemPtr_t)_tagstr, smlLibStrlen(_tagstr), pBufMgr)) != SML_ERR_OK) break;
if (_tagnsattr) {
if ((_err = xltAddToBuffer((MemPtr_t)&_nstagstart, 8, pBufMgr)) != SML_ERR_OK) break;
if ((_err = xltAddToBuffer((MemPtr_t)_tagnsattr, smlLibStrlen(_tagnsattr), pBufMgr)) != SML_ERR_OK) break;
if ((_err = xltAddToBuffer((MemPtr_t)&_nstagend, 1, pBufMgr)) != SML_ERR_OK) break;
}
if ((_err = xltAddToBuffer((MemPtr_t)(&_endpar), 1, pBufMgr)) != SML_ERR_OK) break;
// remember the number of byte that must follow for the according end-tag
pBufMgr->endTagSize += (3 + smlLibStrlen(_tagstr));
break;
}
default:
{
smlLibFree(_tagstr);
smlLibFree(_tagnsattr);
return SML_ERR_XLT_INVAL_TAG_TYPE;
}
}
smlLibFree(_tagstr);
smlLibFree(_tagnsattr);
return _err;
}
