xltdecxml.c

SyncML ToolKits,学习syncml的参考工具包.非常好用.

        
	}


	if (pScanner->ext == ext) {
		/* no new Namespace found - lets proceed with the active one */

		/* first lets check wether a tag is in the right namespace, in case
		 * we are using namespaces with prefix notation ('mi:Format' instead of
		 * 'Format nsattr="..."). 
		 * If we are and the token is not in this namespace -> bail out
		 */
		if (pScanner->nsprelen > 0 && smlLibStrlen(name) > pScanner->nsprelen+1) {
			if (name[pScanner->nsprelen] != ':' || smlLibStrncmp(name,pScanner->nsprefix, pScanner->nsprelen) != 0) {
				smlLibFree(name);
				smlLibFree(attname);
				smlLibFree(value);
				smlLibFree(nsprefix);
				return SML_ERR_XLT_NO_MATCHING_CODEPAGE;
			}
		}
		/* Strip off namespace prefixes and ':' to find the tag.
		 * If no prefix is defined (pScanner->nsprelen == 0) take the whole tagname.
		 */
		if (pScanner->nsprelen > 0)
 			rc = getTagIDByStringAndExt(&name[0+pScanner->nsprelen+1], pScanner->ext, &tagid);
		else
			rc = getTagIDByStringAndExt(name, pScanner->ext, &tagid);
	} else {
		/* we have a new Namespace */
		if (nsprelen > 0 && smlLibStrlen(name) > nsprelen+1) {
			if (name[nsprelen] != ':' || smlLibStrncmp(name,nsprefix, nsprelen) != 0) {
				smlLibFree(name);
				smlLibFree(attname);
				smlLibFree(value);
				smlLibFree(nsprefix);
				return SML_ERR_XLT_NO_MATCHING_CODEPAGE;
			}
		}
		/* Strip off namespace prefixes and ':' to find the tag.
		 * If no prefix is defined (pScanner->nsprelen == 0) take the whole tagname.
		 */
		if (nsprelen > 0)
 			rc = getTagIDByStringAndExt(&name[nsprelen+1], ext, &tagid);
		else
			rc = getTagIDByStringAndExt(name, ext, &tagid);
	}
	/* free temporary buffers */
	smlLibFree(name);
	smlLibFree(attname);
	smlLibFree(value);

	if ((tagid == TN_UNDEF) || (rc != SML_ERR_OK)) {
		smlLibFree(nsprefix);
	return rc;
	}

	/* remember the old extension including the corresponding start tag if we found a new one */
	if (ext != pScanner->ext) { /* namespace changed */
		pScanner->prev_ext     = pScanner->ext;     /* remember the old ext */
		pScanner->prev_ext_tag = pScanner->ext_tag; /* and the corresponding start tag */
		pScanner->ext          = ext;
		pScanner->ext_tag      = tagid;
		smlLibFree(pScanner->nsprefix);
		pScanner->nsprefix    = nsprefix;
		pScanner->nsprelen    = nsprelen;
	}


	pScanner->curtok->tagid = tagid;
	pScanner->curtok->ext   = pScanner->ext;
    skipS(pScanner);

    if (endtag) {
        /* found end tag */
        if (smlLibStrncmp((String_t)pScanner->pos, ">", 1) != 0)
            return SML_ERR_XLT_INVAL_XML_DOC;
        pScanner->curtok->type = TOK_TAG_END;
        readBytes(pScanner, 1);
    	/* in case of an endtag we might need to close the current CP */
		if (tagid == pScanner->ext_tag) {
			pScanner->ext_tag = pScanner->prev_ext_tag;
			pScanner->ext     = pScanner->prev_ext;
			pScanner->prev_ext     = SML_EXT_UNDEFINED;
			pScanner->prev_ext_tag = TN_UNDEF;
			pScanner->nsprelen    = 0;
			smlLibFree(pScanner->nsprefix);
			pScanner->nsprefix    = NULL;
		}
    } else {
        /* Attributes are not supported in SyncML -> skip them*/
        if ((rc = xmlSkipAttributes(pScanner)) != SML_ERR_OK) return rc;

        if (smlLibStrncmp((String_t)pScanner->pos, "/>", 2) == 0) {
            /* found empty tag */
            pScanner->curtok->type = TOK_TAG_EMPTY;
            readBytes(pScanner, 2);
        } else if (smlLibStrncmp((String_t)pScanner->pos, ">", 1) == 0) {
            pScanner->curtok->type = TOK_TAG_START;
            readBytes(pScanner, 1);
        } else {
            return SML_ERR_XLT_INVAL_XML_DOC;
        }
    }

    return SML_ERR_OK;
}

/**
 * FUNCTION: xmlSkipPI
 *
 * Skip PI elements
 */
static Ret_t
xmlSkipPI(xmlScannerPrivPtr_t pScanner)
{
    if (pScanner) { /* Get rid of warning, this should not be called anyway */
 	}

    return SML_ERR_UNSPECIFIC;
}

/**
 * FUNCTION: xmlSkipComment
 *
 * Skip comments
 */
static Ret_t
xmlSkipComment(xmlScannerPrivPtr_t pScanner)
{
    readBytes(pScanner, 4);

    while ((pScanner->pos + 3 <= pScanner->bufend) &&
           (smlLibStrncmp((String_t)pScanner->pos, "-->", 3) != 0))
		   if (!readBytes(pScanner, 1))
           return SML_ERR_XLT_END_OF_BUFFER;
        

    if (pScanner->pos + 3 > pScanner->bufend)
        return SML_ERR_XLT_END_OF_BUFFER;

    if (!readBytes(pScanner, 3))
        return SML_ERR_XLT_END_OF_BUFFER;

    skipS(pScanner);

    return SML_ERR_OK;
}

/**
 * FUNCTION: xmlSkipAttributes
 *
 * Skip attributes -> they are not supported in SyncML
 */
static Ret_t
xmlSkipAttributes(xmlScannerPrivPtr_t pScanner)
{ 

    while ((pScanner->pos + 1 <= pScanner->bufend) &&
           (smlLibStrncmp((String_t)pScanner->pos, ">", 1)) && (smlLibStrncmp((String_t)pScanner->pos, "/>", 2)))
		   if (!readBytes(pScanner, 1))
           return SML_ERR_XLT_END_OF_BUFFER;

    
    if (pScanner->pos + 1 > pScanner->bufend)
        return SML_ERR_XLT_END_OF_BUFFER;

    return SML_ERR_OK;
}

/**
 * FUNCTION: xmlCDATA
 *
 * Handle a CDATA content
 */
static Ret_t
xmlCDATA(xmlScannerPrivPtr_t pScanner)
{
    SmlPcdataPtr_t pPCData;
    MemPtr_t begin;
    int len;
    
    readBytes(pScanner, 9);

    pPCData = (SmlPcdataPtr_t)smlLibMalloc(sizeof(SmlPcdata_t));
    if (pPCData == NULL)
        return SML_ERR_NOT_ENOUGH_SPACE;
    pPCData->contentType = SML_PCDATA_UNDEFINED;
    pPCData->length = 0;
    pPCData->content = NULL;

    begin = pScanner->pos;
    while (!((pScanner->pos[0] == ']') && (pScanner->pos[1] == ']') && (pScanner->pos[2] == '>')))
        if (!readBytes(pScanner, 1))
        return SML_ERR_XLT_END_OF_BUFFER;
		
    len = pScanner->pos - begin;
    pPCData->content = smlLibMalloc(len + 1);
    if (pPCData->content == NULL) {
		smlLibFree(pPCData);
 		return SML_ERR_NOT_ENOUGH_SPACE;
 	}

    smlLibMemset(pPCData->content, 0, len + 1);
    smlLibMemcpy(pPCData->content, begin, len);
    pPCData->contentType = SML_PCDATA_CDATA;
    pPCData->length = len;

    pScanner->curtok->type = TOK_CONT;
    pScanner->curtok->pcdata = pPCData;

    readBytes(pScanner, 3);

    return SML_ERR_OK;
}

/**
 * FUNCTION: xmlSkipPCDATA
 *
 * Read over a Pcdata content
 */
static Ret_t
xmlSkipPCDATA(xmlScannerPrivPtr_t pScanner)
{
    SmlPcdataPtr_t pPCData;
    MemPtr_t begin;
    int len;
    Ret_t rc;
    String_t _tagString = NULL;
    String_t _tagString2 = NULL;

		/* Check wether this PCData might contain a subdtd.
    ** We assume a Sub DTD starts with '<' as first char.
    ** If this char is present start further processing else
    ** take it as pure String data. If the scanning returns an
    ** error we reject the file, as '<' is not a valid char inside
    ** PCData elements.
		 */
    if (smlLibStrncmp((String_t)pScanner->pos, "<", 1) == 0) {
      rc = xmlTag(pScanner, 0);
        return rc;
    }

    _tagString = smlLibMalloc(XML_MAX_TAGLEN);
    if (_tagString == NULL) return SML_ERR_NOT_ENOUGH_SPACE;
    if ((rc = getTagString(pScanner->curtok->tagid, _tagString, pScanner->curtok->ext)) != SML_ERR_OK)
    {
        smlLibFree(_tagString);
        return rc;
    }
    
    _tagString2 = smlLibMalloc(smlLibStrlen(_tagString) + 4 + (pScanner->nsprelen +1));

    // build a end tag String to compate (e.g. </Meta>)
		// beware of possible namespace prefixes
    if (_tagString2 == NULL) 
    {
        smlLibFree(_tagString);
        return SML_ERR_NOT_ENOUGH_SPACE;
    }
    
    _tagString2 = smlLibStrcpy(_tagString2,"</");
		if (pScanner->nsprelen > 0) {
			_tagString2 = smlLibStrcat(_tagString2,pScanner->nsprefix);
			_tagString2 = smlLibStrcat(_tagString2,":");
		}
    _tagString2 = smlLibStrcat(_tagString2,_tagString);
    _tagString2 = smlLibStrcat(_tagString2,">");
    smlLibFree(_tagString);

    pPCData = (SmlPcdataPtr_t)smlLibMalloc(sizeof(SmlPcdata_t));
    
    
    
    if (pPCData == NULL)
    {
        smlLibFree(_tagString2);
        return SML_ERR_NOT_ENOUGH_SPACE;
    }
    pPCData->contentType = SML_PCDATA_UNDEFINED;
    pPCData->extension = SML_EXT_UNDEFINED;
    pPCData->length = 0;
    pPCData->content = NULL;

    begin = pScanner->pos;

    // read Pcdata content until end tag appears
    while (smlLibStrncmp((String_t)pScanner->pos, _tagString2, smlLibStrlen(_tagString2)) != 0)
    {
      if (pScanner->pos >= pScanner->bufend)
      {
        smlLibFree(_tagString2);
        return SML_ERR_XLT_INVAL_SYNCML_DOC;
      }
        if (!readBytes(pScanner, 1))
            return SML_ERR_XLT_END_OF_BUFFER;
        
    }
    
    smlLibFree(_tagString2);
    
    len = pScanner->pos - begin;
    pPCData->content = smlLibMalloc(len + 1);
    if (pPCData->content == NULL) 
    {
        smlLibFree(pPCData);
        return SML_ERR_NOT_ENOUGH_SPACE;
    }
    
    
    smlLibMemset(pPCData->content, 0, len + 1);
    smlLibMemcpy(pPCData->content, begin, len);
    pPCData->contentType = SML_PCDATA_STRING;
    pPCData->length = len;

    pScanner->curtok->type = TOK_CONT;
    pScanner->curtok->pcdata = pPCData;


    return SML_ERR_OK;
}

/**
 * FUNCTION: isPcdata
 *
 * Check if the current tag id represents a Pcdata element
 */
Boolean_t isPcdata(XltTagID_t tagid)
{
  switch (tagid)
  {
    case TN_CMD:
    case TN_CMDID:
    case TN_CMDREF:
    case TN_LANG:
    case TN_LOCNAME:      
    case TN_LOCURI:   
    case TN_MSGID:   
    case TN_MSGREF:   
    case TN_RESPURI:   
    case TN_SESSIONID:   
    case TN_SOURCEREF:   
    case TN_TARGETREF:   
    case TN_VERSION:   
    case TN_PROTO:   
    case TN_DATA:
    case TN_META:
	case TN_NUMBEROFCHANGES:
#ifdef __USE_METINF__
	case TN_METINF_EMI:
	case TN_METINF_FORMAT:
	case TN_METINF_FREEID:
	case TN_METINF_FREEMEM:
	case TN_METINF_LAST:
	case TN_METINF_MARK:
	case TN_METINF_MAXMSGSIZE:
	/* SCTSTK - 18/03/2002 S.H. 2002-04-05 : SyncML 1.1 */
	case TN_METINF_MAXOBJSIZE:
	case TN_METINF_NEXT:
	case TN_METINF_NEXTNONCE:		
	case TN_METINF_SIZE:
	case TN_METINF_TYPE:
	case TN_METINF_VERSION:
#endif
#ifdef __USE_DEVINF__
    case TN_DEVINF_MAN:
    case TN_DEVINF_MOD:
    case TN_DEVINF_OEM:
    case TN_DEVINF_FWV:
    case TN_DEVINF_SWV:
    case TN_DEVINF_HWV:
    case TN_DEVINF_DEVID:
    case TN_DEVINF_DEVTYP:
    case TN_DEVINF_MAXGUIDSIZE:
    case TN_DEVINF_SOURCEREF:
    case TN_DEVINF_DISPLAYNAME:
    case TN_DEVINF_CTTYPE:
    case TN_DEVINF_DATATYPE:
    case TN_DEVINF_SIZE:
    case TN_DEVINF_PROPNAME:
    case TN_DEVINF_VALENUM:
    case TN_DEVINF_PARAMNAME:
    case TN_DEVINF_SYNCTYPE:
    case TN_DEVINF_XNAM:
    case TN_DEVINF_XVAL:
    case TN_DEVINF_MAXMEM:
    case TN_DEVINF_MAXID:
    case TN_DEVINF_VERCT:
    case TN_DEVINF_VERDTD:
#endif
      return 1;
    default:
      return 0;
  }
}
#endif