コード例 #1
0
ファイル: CExpat.cpp プロジェクト: Gaurav2728/rhodes
CExpat::CExpat()
	{
	// Open and set up expat to parse the xml
	P = XML_ParserCreate(NULL);
	}
コード例 #2
0
ZLXMLReaderInternal::ZLXMLReaderInternal(ZLXMLReader &reader, const char *encoding) : myReader(reader) {
	myParser = XML_ParserCreate(encoding);
	myInitialized = false;
}
コード例 #3
0
ファイル: xml_analys.cpp プロジェクト: bgtwoigu/code808
int parser_xml_file(char *path)
{ 
    int ret = 0;

    if(NULL == path)
    {
        printf("path error!\n");
        ret = NO_FILE;
        return ret;
    }

    char *path_buffer = path;

	FILE *fp = fopen(path_buffer, "r");
    if(!fp)
    {
        printf("open file error!\n");
        ret =  NO_FILE;
        fclose(fp);
        return ret;
    }

	XML_Parser p = XML_ParserCreate(NULL);
    if(!p)
    {
        fprintf(stderr, "Couldn't allocate memory for parser\n");
        ret =  WRITE_ERROR;
        fclose(fp);
        return ret;
    }

	XML_SetElementHandler(p, start, end);
	XML_SetCharacterDataHandler(p, ElementData);

    for(;;)
    {
    int done;
    int len;

        len = fread(Buff, 1, BUFF_SIZE, fp);
        if (ferror(fp)) 
        {
            fprintf(stderr, "Read error\n");
            ret =  WRITE_ERROR;
            break;
        }

        done = feof(fp);

        if(!XML_Parse(p, Buff, len, done)) 
        {
            fprintf(stderr, "Parse error at line %d:\n%s\n",
			(int)XML_GetCurrentLineNumber(p),
			XML_ErrorString(XML_GetErrorCode(p)));
            ret =  WRITE_ERROR;
            break;
        }

        if (done)
            break;
    }

	fclose(fp);

    return ret;
}
コード例 #4
0
ファイル: repo_rpmmd.c プロジェクト: openSUSE/sat-solver
void
repo_add_rpmmd(Repo *repo, FILE *fp, const char *language, int flags)
{
  Pool *pool = repo->pool;
  struct parsedata pd;
  char buf[BUFF_SIZE];
  int i, l;
  struct stateswitch *sw;
  Repodata *data;
  unsigned int now;

  now = sat_timems(0);
  data = repo_add_repodata(repo, flags);

  memset(&pd, 0, sizeof(pd));
  for (i = 0, sw = stateswitches; sw->from != NUMSTATES; i++, sw++)
    {
      if (!pd.swtab[sw->from])
        pd.swtab[sw->from] = sw;
      pd.sbtab[sw->to] = sw->from;
    }
  pd.common.pool = pool;
  pd.common.repo = repo;

  pd.data = data;

  pd.content = sat_malloc(256);
  pd.acontent = 256;
  pd.lcontent = 0;
  pd.common.tmp = 0;
  pd.common.tmpl = 0;
  pd.kind = 0;
  pd.language = language;

  /* initialize the string pool where we will store
     the package checksums we know about, to get an Id
     we can use in a cache */
  stringpool_init_empty(&pd.cspool);
  if ((flags & REPO_EXTEND_SOLVABLES) != 0)
    {
      /* setup join data */
      Dataiterator di;
      dataiterator_init(&di, pool, repo, 0, SOLVABLE_CHECKSUM, 0, 0);
      while (dataiterator_step(&di))
	{
	  const char *str;
	  int index;

	  if (!sat_chksum_len(di.key->type))
	    continue;
	  str = repodata_chk2str(di.data, di.key->type, (const unsigned char *)di.kv.str);
          index = stringpool_str2id(&pd.cspool, str, 1);
	  if (index >= pd.ncscache)
	    {
	      pd.cscache = sat_zextend(pd.cscache, pd.ncscache, index + 1 - pd.ncscache, sizeof(Id), 255);
	      pd.ncscache = index + 1;
	    }
          pd.cscache[index] = di.solvid;
	}
      dataiterator_free(&di);
    }

  XML_Parser parser = XML_ParserCreate(NULL);
  XML_SetUserData(parser, &pd);
  pd.parser = &parser;
  XML_SetElementHandler(parser, startElement, endElement);
  XML_SetCharacterDataHandler(parser, characterData);
  for (;;)
    {
      l = fread(buf, 1, sizeof(buf), fp);
      if (XML_Parse(parser, buf, l, l == 0) == XML_STATUS_ERROR)
	{
	  pool_debug(pool, SAT_FATAL, "repo_rpmmd: %s at line %u:%u\n", XML_ErrorString(XML_GetErrorCode(parser)), (unsigned int)XML_GetCurrentLineNumber(parser), (unsigned int)XML_GetCurrentColumnNumber(parser));
	  exit(1);
	}
      if (l == 0)
	break;
    }
  XML_ParserFree(parser);
  sat_free(pd.content);
  sat_free(pd.lastdirstr);
  join_freemem();
  stringpool_free(&pd.cspool);
  sat_free(pd.cscache);

  if (!(flags & REPO_NO_INTERNALIZE))
    repodata_internalize(data);
  POOL_DEBUG(SAT_DEBUG_STATS, "repo_add_rpmmd took %d ms\n", sat_timems(now));
  POOL_DEBUG(SAT_DEBUG_STATS, "repo size: %d solvables\n", repo->nsolvables);
  POOL_DEBUG(SAT_DEBUG_STATS, "repo memory used: %d K incore, %d K idarray\n", data->incoredatalen/1024, repo->idarraysize / (int)(1024/sizeof(Id)));
}
コード例 #5
0
ファイル: SMCComMessageInbox.c プロジェクト: gpsnavi/gpsnavi
/**
 * @brief message/inbox/応答メッセージ解析
 * @param [IN] xml      XMLファイルのフルパス
 * @param [IN] resp_inf CICレスポンス情報
 * @param [IN] personalInfo     パーソナルお知らせ情報
 * @param [IN] personalInfoNum  パーソナルお知らせ情報数
 * @return 処理結果(E_SC_RESULT)
 */
E_SC_RESULT CC_MessageInbox_XmlParse(const Char* xml,
									 T_CC_CMN_SMS_RESPONSE_INFO* resp_inf,
									 INT32 limit,
									 SMPERSONALINFO *personalInfo,
									 INT32 *personalInfoNum,
									 Char *personalNum,
									 SMCALOPT *opt)
{
	E_SC_RESULT		ret = e_SC_RESULT_SUCCESS;
	PERSONALINFO_PARSER	personalInfoParser = {};
	Char buf[CC_CMN_XML_PARSE_DATA_SIZE + 1] = {};
	XML_Parser parser = NULL;
	INT32	done = 0;
	INT32	len = 0;
	INT32	parsedLen = 0;
	FILE	*fp = NULL;

	SCC_LOG_DebugPrint(SC_TAG_CC, SCC_LOG_START);

	do {
		// パラメータチェック
		if ((NULL == opt) || (true != opt->isResOutputFile)) {
			if (NULL == xml) {
				SCC_LOG_ErrorPrint(SC_TAG_CC, (Char*)"param error[xml], " HERE);
				CB_Result = e_SC_RESULT_FAIL;
				ret = CB_Result;
				break;
			}
		}

		// 初期化
		resp_inf->sts = 0;
		personalInfoParser.buf = (Char*)SCC_MALLOC(CC_CMN_XML_BUF_SIZE + 1);
		if (NULL == personalInfoParser.buf) {
			SCC_LOG_ErrorPrint(SC_TAG_CC, (Char*)"SCC_MALLOC error, " HERE);
			CB_Result = e_SC_RESULT_MALLOC_ERR;
			ret = CB_Result;
			break;
		}
		personalInfoParser.personalInfoMaxNum = limit;
		personalInfoParser.personalInfo.personalInfoNum = 0;
		personalInfoParser.personalInfo.personalInfo = personalInfo;
		personalInfoParser.personalInfo.apiStatus = &resp_inf->apiSts[0];
		personalInfoParser.personalInfo.personalNum = personalNum;
		CB_Result = e_SC_RESULT_SUCCESS;

		// XMLパーサ生成
		parser = XML_ParserCreate(NULL);
		if (NULL == parser) {
			SCC_LOG_ErrorPrint(SC_TAG_CC, (Char*)"XML_ParserCreate error, " HERE);
			CB_Result = e_SC_RESULT_FAIL;
			ret = CB_Result;
			break;
		}

		// コールバック関数設定
		XML_SetUserData(parser, &personalInfoParser);
		XML_SetElementHandler(parser, CC_MessageInbox_StartElement, CC_MessageInbox_EndElement);
		XML_SetCharacterDataHandler(parser, CC_MessageInbox_CharacterData);

		if ((NULL == opt) || (true != opt->isResOutputFile)) {
			CB_IsXmlFile = false;
		} else {
			CB_IsXmlFile = true;
			fp = fopen((char*)opt->resFilePath, "r");
			if (NULL == fp) {
				SCC_LOG_ErrorPrint(SC_TAG_CC, (Char*)"file open error(%d)[%s], " HERE, errno, opt->resFilePath);
				CB_Result = e_SC_RESULT_FILE_ACCESSERR;
				ret = CB_Result;
				break;
			}
		}

		while (!done) {
			if (CC_ISCANCEL()) {
				SCC_LOG_ErrorPrint(SC_TAG_CC, (Char*)"cancel, " HERE);
				CB_Result = e_SC_RESULT_CANCEL;
				ret = CB_Result;
				break;
			}

			if (!CB_IsXmlFile) {
				strncpy((char*)buf, &xml[parsedLen], (sizeof(buf) - 1));
				len = (INT32)strlen(buf);
				parsedLen += len;
				if (strlen(xml) <= parsedLen) {
					done = 1;
				} else {
					done = 0;
				}
			} else {
				len = (INT32)fread(buf, 1, (sizeof(buf) - 1), fp);
				done = (len < (sizeof(buf) - 1));
			}

			// XML解析
			if ((XML_STATUS_ERROR == XML_Parse(parser, (const char*)buf, len, done)) || (e_SC_RESULT_SUCCESS != CB_Result)) {
				SCC_LOG_ErrorPrint(SC_TAG_CC, (Char*)"XML_Parse error(0x%08x), " HERE, CB_Result);
				CB_Result = e_SC_RESULT_SMS_API_ERR;
				ret = CB_Result;
				break;
			}

			if (!done) {
				// バッファクリア
				memset(buf, 0, (sizeof(buf) - 1));
			}
		}
		if (e_SC_RESULT_SUCCESS == CB_Result) {
			*personalInfoNum = personalInfoParser.personalInfo.personalInfoNum;
		}
	} while (0);

	if (NULL != personalInfoParser.buf) {
		SCC_FREE(personalInfoParser.buf);
	}
	if (NULL != fp) {
		fclose(fp);
	}

	if (NULL != parser) {
		XML_ParserFree(parser);
	}

	SCC_LOG_DebugPrint(SC_TAG_CC, SCC_LOG_END);

	return (ret);
}
コード例 #6
0
ファイル: XML_Email.cpp プロジェクト: RadekSimkanic/JA2-1.13
BOOLEAN ReadInEmailOther(STR fileName, BOOLEAN localizedVersion)
{
	HWFILE		hFile;
	UINT32		uiBytesRead;
	UINT32		uiFSize;
	CHAR8 *		lpcBuffer;
	XML_Parser	parser = XML_ParserCreate(NULL);

	EmailOtherParseData pData;

	DebugMsg(TOPIC_JA2, DBG_LEVEL_3, "Loading EmailOther.xml" );

	EmailOther_TextOnly = localizedVersion;
	
	// Open file
	hFile = FileOpen( fileName, FILE_ACCESS_READ, FALSE );
	if ( !hFile )
		return( localizedVersion );

	uiFSize = FileGetSize(hFile);
	lpcBuffer = (CHAR8 *) MemAlloc(uiFSize+1);

	//Read in block
	if ( !FileRead( hFile, lpcBuffer, uiFSize, &uiBytesRead ) )
	{
		MemFree(lpcBuffer);
		return( FALSE );
	}

	lpcBuffer[uiFSize] = 0; //add a null terminator

	FileClose( hFile );


	XML_SetElementHandler(parser, EmailOtherStartElementHandle, EmailOtherEndElementHandle);
	XML_SetCharacterDataHandler(parser, EmailOtherCharacterDataHandle);


	memset(&pData,0,sizeof(pData));
	XML_SetUserData(parser, &pData);


	if(!XML_Parse(parser, lpcBuffer, uiFSize, TRUE))
	{
		CHAR8 errorBuf[511];

		sprintf(errorBuf, "XML Parser Error in EmailOther.xml: %s at line %d", XML_ErrorString(XML_GetErrorCode(parser)), XML_GetCurrentLineNumber(parser));
		LiveMessage(errorBuf);

		MemFree(lpcBuffer);
		return FALSE;
	}

	MemFree(lpcBuffer);


	XML_ParserFree(parser);


	return( TRUE );
}
コード例 #7
0
int RD_TrimAudio(struct rd_trimaudio *trimaudio[],
		  	const char hostname[],
                  	const char username[],
                  	const char passwd[],
                  	const unsigned cartnumber,
			const unsigned cutnumber,
			const int trimlevel,
                  	unsigned *numrecs)
{
  char post[1500];
  char url[1500];
  CURL *curl=NULL;
  XML_Parser parser;
  struct xml_data xml_data;
  long response_code;
  char errbuf[CURL_ERROR_SIZE];
  CURLcode res;

   /* Set number of recs so if fail already set */
  *numrecs = 0;

  /*
   * Setup the CURL call
   */
  memset(&xml_data,0,sizeof(xml_data));
  parser=XML_ParserCreate(NULL);
  XML_SetUserData(parser,&xml_data);
  XML_SetElementHandler(parser,__TrimAudioElementStart,
			__TrimAudioElementEnd);
  XML_SetCharacterDataHandler(parser,__TrimAudioElementData);
  snprintf(url,1500,"http://%s/rd-bin/rdxport.cgi",hostname);
  snprintf(post,1500,"COMMAND=17&LOGIN_NAME=%s&PASSWORD=%s&CART_NUMBER=%u&CUT_NUMBER=%u&TRIM_LEVEL=%d",
	   username,passwd,cartnumber,cutnumber,trimlevel);
  if((curl=curl_easy_init())==NULL) {
    return -1;
  }
  curl_easy_setopt(curl,CURLOPT_WRITEDATA,parser);
  curl_easy_setopt(curl,CURLOPT_WRITEFUNCTION,__TrimAudioCallback);
  curl_easy_setopt(curl,CURLOPT_URL,url);
  curl_easy_setopt(curl,CURLOPT_POST,1);
  curl_easy_setopt(curl,CURLOPT_POSTFIELDS,post);
  curl_easy_setopt(curl,CURLOPT_NOPROGRESS,1);
  curl_easy_setopt(curl,CURLOPT_ERRORBUFFER,errbuf);
  //  curl_easy_setopt(curl,CURLOPT_VERBOSE,1);
  res = curl_easy_perform(curl);
  if(res != CURLE_OK) {
    size_t len = strlen(errbuf);
    fprintf(stderr, "\nlibcurl error: (%d)", res);
    if (len)
        fprintf(stderr, "%s%s", errbuf,
            ((errbuf[len-1] != '\n') ? "\n" : ""));
    else
        fprintf(stderr, "%s\n", curl_easy_strerror(res));
    curl_easy_cleanup(curl);
    return -1;
  }

/* The response OK - so figure out if we got what we wanted.. */

  curl_easy_getinfo(curl,CURLINFO_RESPONSE_CODE,&response_code);
  curl_easy_cleanup(curl);
  
  if (response_code > 199 && response_code < 300) { 
    *trimaudio=xml_data.trimaudio;
    *numrecs = 1;
    return 0;
  }
  else {
    fprintf(stderr," Call Returned Error: %s\n",xml_data.strbuf);
    return (int)response_code;
  }
}
コード例 #8
0
ファイル: HTMLWidget.cpp プロジェクト: binji/drod-nacl
//*****************************************************************************
bool CHTMLWidget::Parse(
//Parse text buffer and add child widgets for each part.
//
//Params:
	const CStretchyBuffer &text)  //(in)   Text to parse.
//
//Returns: True if parse was successful, false if there was a parse error.
{
	//Renderer init.
	ClearChildren();
	this->wCurrentColumn = this->wX = 0;
	this->wY = this->wMargin;
	this->bSkipSpace = true;
	this->dwCurrentLinkTag = this->dwLinkTagStart;
	for (int i = First_Tag; i <= Tag_Count; ++i)  // Including unknown
		aeTagLevel[i] = 0;
	mIdmap.clear();

	static const WCHAR defaultColor[] = {We('F'),We('F'),We('F'),We('F'),We('F'),We('F'),We(0)};
	this->wstrBGColor = defaultColor;

	//Parser init.
	XML_Parser parser = XML_ParserCreate(NULL);
	XML_SetUserData(parser, this);
	XML_SetElementHandler(parser, StartElement_cb, EndElement_cb);
	XML_SetCharacterDataHandler(parser, InElement_cb);
// XML_SetParamEntityParsing(parser, XML_PARAM_ENTITY_PARSING_NEVER);

	bool bResult = true;
	char *buf = (char*)(BYTE*)text;
	//size - 2 seems to fix "invalid token" errors at EOF (even at empty files).
	const UINT size = text.Size() - 2;

	//Parse the XML.
	static const char entities[] = "<?xml version=\"1.0\" encoding=\""
   "UTF-8"
   "\"?>"
   "<!DOCTYPE html ["
	"<!ENTITY nbsp \"\xc2\xa0\">" //utf-8 for 0xa0 = unicode nbsp
   "]>";

	if ((XML_Parse(parser, entities, strlen(entities), false) == XML_STATUS_ERROR) ||
			(XML_Parse(parser, buf, size, true) == XML_STATUS_ERROR))
	{
		//Some problem occurred.
		char errorStr[256];
		_snprintf(errorStr, 256,
				"HTML Parse Error: %s at line %u:%u" NEWLINE,
				XML_ErrorString(XML_GetErrorCode(parser)),
				(UINT)XML_GetCurrentLineNumber(parser),
				(UINT)XML_GetCurrentColumnNumber(parser));
		CFiles Files;
		Files.AppendErrorLog((char *)errorStr);

#ifdef RUSSIAN_BUILD
		//Fix unsupported KOI8 encoded Cyrillic chars.
//		ConvertCyrillicEncodedXMLToUTF8(text);
#endif

		AsciiToUnicode(errorStr, this->wstrStatus);

		bResult = false;
	}

	//Parser clean-up.
	XML_ParserFree(parser);

	NewLine();	//once done, ensure final line of text is included in height
	NewLine(true);  //...and have a blank line at the bottom to look good

	//Render surface to display on screen.
	bool bCanResize = CanResize();
	if (bCanResize)
	{
		this->pParent->ScrollAbsolute(0, 0);   //scroll to top of page
		if (this->wY < this->pParent->GetH())  //stretch surface to fill container
			this->wY = this->pParent->GetH();
	}
	UpdateHTMLSurface();

	//Resize (if possible).
	if (bCanResize)
		Resize(this->pHTMLSurface->w, this->pHTMLSurface->h);

	return bResult;
}
コード例 #9
0
ファイル: xml.cpp プロジェクト: EEmmanuel7/wxWidgets
bool wxXmlDocument::Load(wxInputStream& stream, const wxString& encoding, int flags)
{
#if wxUSE_UNICODE
    (void)encoding;
#else
    m_encoding = encoding;
#endif

    const size_t BUFSIZE = 1024;
    char buf[BUFSIZE];
    wxXmlParsingContext ctx;
    bool done;
    XML_Parser parser = XML_ParserCreate(NULL);
    wxXmlNode *root = new wxXmlNode(wxXML_DOCUMENT_NODE, wxEmptyString);

    ctx.encoding = wxS("UTF-8"); // default in absence of encoding=""
    ctx.conv = NULL;
#if !wxUSE_UNICODE
    if ( encoding.CmpNoCase(wxS("UTF-8")) != 0 )
        ctx.conv = new wxCSConv(encoding);
#endif
    ctx.removeWhiteOnlyNodes = (flags & wxXMLDOC_KEEP_WHITESPACE_NODES) == 0;
    ctx.parser = parser;
    ctx.node = root;

    XML_SetUserData(parser, (void*)&ctx);
    XML_SetElementHandler(parser, StartElementHnd, EndElementHnd);
    XML_SetCharacterDataHandler(parser, TextHnd);
    XML_SetCdataSectionHandler(parser, StartCdataHnd, EndCdataHnd);;
    XML_SetCommentHandler(parser, CommentHnd);
    XML_SetProcessingInstructionHandler(parser, PIHnd);
    XML_SetDefaultHandler(parser, DefaultHnd);
    XML_SetUnknownEncodingHandler(parser, UnknownEncodingHnd, NULL);

    bool ok = true;
    do
    {
        size_t len = stream.Read(buf, BUFSIZE).LastRead();
        done = (len < BUFSIZE);
        if (!XML_Parse(parser, buf, len, done))
        {
            wxString error(XML_ErrorString(XML_GetErrorCode(parser)),
                           *wxConvCurrent);
            wxLogError(_("XML parsing error: '%s' at line %d"),
                       error.c_str(),
                       (int)XML_GetCurrentLineNumber(parser));
            ok = false;
            break;
        }
    } while (!done);

    if (ok)
    {
        if (!ctx.version.empty())
            SetVersion(ctx.version);
        if (!ctx.encoding.empty())
            SetFileEncoding(ctx.encoding);
        SetDocumentNode(root);
    }
    else
    {
        delete root;
    }

    XML_ParserFree(parser);
#if !wxUSE_UNICODE
    if ( ctx.conv )
        delete ctx.conv;
#endif

    return ok;

}
コード例 #10
0
ファイル: xml_element.c プロジェクト: vpj/PHP-Extension-API
/****f* xml_element/xml_elem_parse_buf
 * NAME
 *   xml_elem_parse_buf
 * SYNOPSIS
 *   xml_element* xml_elem_parse_buf(const char* in_buf, int len, XML_ELEM_INPUT_OPTIONS options, XML_ELEM_ERROR error)
 * FUNCTION
 *   parse a buffer containing XML into an xml_element in-memory tree
 * INPUTS
 *   in_buf   - buffer containing XML document
 *   len      - length of buffer
 *   options  - input options. optional
 *   error    - error result data. optional. check if result is null.
 * RESULT
 *   void
 * NOTES
 *   The returned data must be free'd by caller
 * SEE ALSO
 *   xml_elem_serialize_to_string ()
 *   xml_elem_free ()
 * SOURCE
 */
xml_element* xml_elem_parse_buf(const char* in_buf, int len, XML_ELEM_INPUT_OPTIONS options, XML_ELEM_ERROR error)
{
   xml_element* xReturn = NULL;
   char buf[100] = "";
   static STRUCT_XML_ELEM_INPUT_OPTIONS default_opts = {encoding_utf_8};

   if(!options) {
      options = &default_opts;
   }

   if(in_buf) {
      XML_Parser parser;
      xml_elem_data mydata = {0};

      parser = XML_ParserCreate(NULL);

      mydata.root = xml_elem_new();
      mydata.current = mydata.root;
      mydata.input_options = options;
      mydata.needs_enc_conversion = options->encoding && strcmp(options->encoding, encoding_utf_8);

      XML_SetElementHandler(parser, (XML_StartElementHandler)_xmlrpc_startElement, (XML_EndElementHandler)_xmlrpc_endElement);
      XML_SetCharacterDataHandler(parser, (XML_CharacterDataHandler)_xmlrpc_charHandler);

      /* pass the xml_elem_data struct along */
      XML_SetUserData(parser, (void*)&mydata);

      if(!len) {
         len = strlen(in_buf);
      }

      /* parse the XML */
      if(XML_Parse(parser, in_buf, len, 1) == 0) {
         enum XML_Error err_code = XML_GetErrorCode(parser);
         int line_num = XML_GetCurrentLineNumber(parser);
         int col_num = XML_GetCurrentColumnNumber(parser);
         long byte_idx = XML_GetCurrentByteIndex(parser);
/*         int byte_total = XML_GetCurrentByteCount(parser); */
         const char * error_str = XML_ErrorString(err_code);
         if(byte_idx >= 0) {
             snprintf(buf, 
                      sizeof(buf),
                      "\n\tdata beginning %ld before byte index: %s\n",
                      byte_idx > 10  ? 10 : byte_idx,
                      in_buf + (byte_idx > 10 ? byte_idx - 10 : byte_idx));
         }
/*
         fprintf(stderr, "expat reports error code %i\n"
                "\tdescription: %s\n"
                "\tline: %i\n"
                "\tcolumn: %i\n"
                "\tbyte index: %ld\n"
                "\ttotal bytes: %i\n%s ",
                err_code, error_str, line_num, 
                col_num, byte_idx, byte_total, buf);
*/

          /* error condition */
          if(error) {
              error->parser_code = (long)err_code;
              error->line = line_num;
              error->column = col_num;
              error->byte_index = byte_idx;
              error->parser_error = error_str;
          }
      }
      else {
         xReturn = (xml_element*)Q_Head(&mydata.root->children);
         xReturn->parent = NULL;
      }

      XML_ParserFree(parser);


      xml_elem_free_non_recurse(mydata.root);
   }

   return xReturn;
}
コード例 #11
0
ファイル: xmlparser.cpp プロジェクト: Dheeraj-B/mxflib
//! Use Expat parser to parse an XML file
bool mxflib::XMLParserParseFile(XML_Parser *pParser, mxflib::XMLParserHandlerPtr Hand, void *UserData, const char *filename, bool ParseNamespaces /*=false*/)
{
	if(!Hand)
	{
		error("No handler defined in call to XMLParserParseFile()\n");
		return false;
	}

	// Open the input file
	FileHandle InFile = FileOpenRead(filename);
	if(!FileValid(InFile))
	{
		Hand->fatalError(UserData, "Couldn't open file %s\n", filename);
		return false;
	}

	// Build a new parser
	XML_Parser Parser = ParseNamespaces ? XML_ParserCreateNS(NULL, '|') : XML_ParserCreate(NULL);
	if(!Parser)
	{
		Hand->fatalError(UserData, "Could't create an expat XML parser\n");
		FileClose(InFile);
		return false;
	}

	// Set the caller's parser pointer if requested
	if(pParser) *pParser = Parser;

	// Set the element handlers
	XML_SetElementHandler(Parser, Hand->startElement, Hand->endElement);

	// Set the user data
	XML_SetUserData(Parser, UserData);

	int Done = 0;
	do
	{
		const int BufferSize = 1024 * 64;
		UInt8 *Buffer = (UInt8*)XML_GetBuffer(Parser, BufferSize);

		int Bytes = (int)FileRead(InFile, Buffer, BufferSize);

		if(FileEof(InFile)) Done = -1;

		if (XML_ParseBuffer(Parser, Bytes, Done) == XML_STATUS_ERROR) 
		{
			Hand->fatalError(UserData, "Parse error at line %d:\n%s\n",  XML_GetCurrentLineNumber(Parser),
																		 XML_ErrorString(XML_GetErrorCode(Parser)));

			XML_ParserFree(Parser);
			FileClose(InFile);
			return false;
		}
	} while(!Done);

	// Free the parser
	XML_ParserFree(Parser);

	FileClose(InFile);

	return true;
}
コード例 #12
0
ファイル: xsd.c プロジェクト: AAS/ezquake-source
// load document, auto-recognizing its type, returns NULL in case of failure
xml_t * XSD_LoadDocument(char *filename)
{
    xml_t *ret = NULL;
    int i;
	vfsfile_t *f;
    XML_Parser parser = NULL;
    int len;
	int filelen;
    char buf[XML_READ_BUFSIZE];
    char document_type[1024];
	
	// FIXME: D-Kure, does FS_ANY handle both the above cases
	if (!(f = FS_OpenVFS(filename, "rb", FS_ANY))) {
		return NULL;
	}
	filelen = VFS_GETLEN(f);

    // initialize XML parser
    parser = XML_ParserCreate(NULL);
	if (parser == NULL) {
		Com_Printf("could not open2\n");
        goto error;
	}
    XML_SetStartElementHandler(parser, XSD_DetectType_OnStartElement);
    XML_SetUserData(parser, document_type);

    document_type[0] = 0;

    while (document_type[0] == 0  &&  (len = VFS_READ(f, buf, XML_READ_BUFSIZE, NULL)) > 0)
    {
		if (XML_Parse(parser, buf, len, 0) != XML_STATUS_OK) {
			Com_Printf("could not open3\n");
            goto error;
		}
    }
	if (document_type[0] == 0) {
		Com_Printf("could not open4\n");
        goto error;
	}

    // now we know what document type it is...

    // parser is no more needed
    XML_ParserFree(parser);
    parser = NULL;

    // fseek to the beginning of the file
	VFS_SEEK(f, 0, SEEK_SET);

    // execute loading parser
    i = 0;
    while (xsd_mappings[i].document_type != NULL)
    {
        if (!strcmp(xsd_mappings[i].document_type, document_type))
        {
			//???
            ret = xsd_mappings[i].load_function(f, filelen);
            break;
        }
        i++;
    }

    if (ret)
    {
		VFS_CLOSE(f);
        return ret;
    }

error:
    if (f)
		VFS_CLOSE(f);

    if (parser)
        XML_ParserFree(parser);
    return NULL;
}
コード例 #13
0
BOOL cg_xml_parse(CgXmlParser *parser, CgXmlNodeList *nodeList, const char *data, size_t len)
{
#if defined DEBUG_XML_RESULT
    CgString* resdata = NULL;
#endif
    XML_Parser p;
    CgExpatData expatData;
#ifdef CG_SHOW_TIMINGS
    struct timeval start_time, end_time, elapsed_time;
#endif

    cg_log_debug_l4("Entering...\n");

#ifdef CG_SHOW_TIMINGS
    gettimeofday(&start_time, NULL);
#endif

    if (!data || len <= 0)
        return FALSE;

    p = XML_ParserCreate(NULL);
    if (!p)
        return FALSE;
    /* Fix to get expat parser to work with DLink-routers */
    if (data[len-1] == 0) len--;

    expatData.rootNode = NULL;
    expatData.currNode = NULL;
    XML_SetUserData(p, &expatData);
    XML_SetElementHandler(p, cg_expat_element_start, cg_expat_element_end);
    XML_SetCharacterDataHandler(p, cg_expat_character_data);

    parser->parseResult = XML_Parse(p, data, len, 1);
    XML_ParserFree(p);

    if (parser->parseResult == 0 /*XML_STATUS_ERROR*/) {
        if (expatData.rootNode != NULL)
            cg_xml_node_delete(expatData.rootNode);
#if defined DEBUG_XML_RESULT
            resdata = cg_string_new();
            cg_string_naddvalue(resdata,data,len);
            printf("XML parse Error on data %s\n time used = %ds\n",
                cg_string_getvalue(resdata),
                time(NULL)-startTime);
            cg_string_delete(resdata);
#endif
            return FALSE;
    }

    cg_xml_nodelist_add(nodeList, expatData.rootNode);

#ifdef CG_SHOW_TIMINGS
    gettimeofday(&end_time, NULL);
    timersub(&end_time, &start_time, &elapsed_time);
cg_log_debug_s("Parsing XML completed. Elapsed time: "
           "%ld msec\n", ((elapsed_time.tv_sec*1000) +
                  (elapsed_time.tv_usec/1000)));
    cg_total_elapsed_time += (elapsed_time.tv_sec*1000000)+
                 (elapsed_time.tv_usec);
cg_log_debug_s("Total elapsed time: %ld msec\n", cg_total_elapsed_time / 1000);
#endif

#if defined DEBUG_XML_RESULT
            resdata = cg_string_new();
            cg_string_naddvalue(resdata,data,len);
            printf("XML parse success - time used %ds\n",time(NULL)-startTime);
            cg_string_delete(resdata);
#endif

    return TRUE;

    cg_log_debug_l4("Leaving...\n");
}
コード例 #14
0
ファイル: omxcore.c プロジェクト: LeMaker/android-actions
static int createComponentLoaders()
{
    FILE *fp = NULL;
    parser_info *parserInfo;
    char buf[BUFSIZ];
    XML_Parser parser = XML_ParserCreate(NULL );
    int done;
    int nCompNums = 0;
    fp = fopen("/system/etc/omx_codec.xml", "r");
    if (fp == NULL )
    {
        DEBUG(DEB_LEV_ERR, "open file error\n");
		XML_ParserFree(parser);
        return OMX_ErrorInsufficientResources;
    }

    XML_SetUserData(parser, &nCompNums);
    XML_SetElementHandler(parser, startElement, endElement);
    do
    {
        int len = (int) fread(buf, 1, sizeof(buf), fp);
        done = (unsigned) len < sizeof(buf);
        if (XML_Parse(parser, buf, len, done) == XML_STATUS_ERROR)
        {
            DEBUG(DEB_LEV_ERR, "%s at line %u\n", XML_ErrorString(XML_GetErrorCode(parser)),
                    (unsigned int) XML_GetCurrentLineNumber(parser));
			fclose(fp);
			XML_ParserFree(parser);
            return OMX_ErrorInsufficientResources;
        }
    } while (!done);

    XML_ParserFree(parser);

    fseek(fp, 0, SEEK_SET);

    if (nCompNums == 0)
    {
        DEBUG(DEB_LEV_ERR, "error of %s,OMX_Init is %d\n", __func__, __LINE__);
        act_loaders = 0;
        fclose(fp);
        return OMX_ErrorInsufficientResources;
    }

    ActComponentType *act_component;

    act_loaders = nCompNums;
    act_component = (ActComponentType *) malloc(sizeof(ActComponentType) * nCompNums);
    parserInfo = (parser_info *) malloc(sizeof(parser_info));
    if(NULL == act_component)
    {
        DEBUG(DEB_LEV_ERR, "error of %s,OMX_Init is %d\n", __func__, __LINE__);
        fclose(fp);
        return OMX_ErrorInsufficientResources;
    }
    memset(parserInfo, 0, sizeof(parser_info));
    parserInfo->loadlist = act_component;
    parserInfo->roleIndex = -1;

    parser = XML_ParserCreate(NULL);
    XML_SetUserData(parser, parserInfo);
    XML_SetCharacterDataHandler(parser, charhandle);
    XML_SetElementHandler(parser, startElement2, endElement2);
    parserInfo->compIndex = -1;
    do
    {
        int len = (int) fread(buf, 1, sizeof(buf), fp);
        done = (unsigned) len < sizeof(buf);
        if (XML_Parse(parser, buf, len, done) == XML_STATUS_ERROR)
        {
            DEBUG(DEB_LEV_ERR, "%s at line %u\n", XML_ErrorString(XML_GetErrorCode(parser)),
                    (unsigned int) XML_GetCurrentLineNumber(parser));
            free(parserInfo);
			fclose(fp);
			XML_ParserFree(parser);
            return OMX_ErrorInsufficientResources;
        }
    } while (!done);

    loadersList = parserInfo->loadlist;
	int i =0;

    XML_ParserFree(parser);

    fclose(fp);

    free(parserInfo);

    return 0;
}
コード例 #15
0
ファイル: benchmark.c プロジェクト: 151706061/Gdcm
int main (int argc, char *argv[]) 
#endif
{
  XML_Parser  parser;
  char        *XMLBuf, *XMLBufEnd, *XMLBufPtr;
  FILE        *fd;
  struct stat fileAttr;
  int         nrOfLoops, bufferSize, fileSize, i, isFinal;
  int         j = 0, ns = 0;
  clock_t     tstart, tend;
  double      cpuTime = 0.0;

  if (argc > 1) {
    if (argv[1][0] == '-') {
      if (argv[1][1] == 'n' && argv[1][2] == '\0') {
        ns = 1;
        j = 1;
      }
      else
        usage(argv[0], 1);
    }
  }

  if (argc != j + 4)
    usage(argv[0], 1);

  if (stat (argv[j + 1], &fileAttr) != 0) {
    fprintf (stderr, "could not access file '%s'\n", argv[j + 1]);
    return 2;
  }
  
  fd = fopen (argv[j + 1], "r");
  if (!fd) {
    fprintf (stderr, "could not open file '%s'\n", argv[j + 1]);
    exit(2);
  }
  
  bufferSize = atoi (argv[j + 2]);
  nrOfLoops = atoi (argv[j + 3]);
  if (bufferSize <= 0 || nrOfLoops <= 0) {
    fprintf (stderr, 
             "buffer size and nr of loops must be greater than zero.\n");
    exit(3);
  }

  XMLBuf = malloc (fileAttr.st_size);
  fileSize = fread (XMLBuf, sizeof (char), fileAttr.st_size, fd);
  fclose (fd);
  
  i = 0;
  XMLBufEnd = XMLBuf + fileSize;
  while (i < nrOfLoops) {
    XMLBufPtr = XMLBuf;
    isFinal = 0;
    if (ns)
      parser = XML_ParserCreateNS(NULL, '!');
    else
      parser = XML_ParserCreate(NULL);
    tstart = clock();
    do {
      int parseBufferSize = XMLBufEnd - XMLBufPtr;
      if (parseBufferSize <= bufferSize)
        isFinal = 1;
      else
        parseBufferSize = bufferSize;
      if (!XML_Parse (parser, XMLBufPtr, parseBufferSize, isFinal)) {
        fprintf (stderr, "error '%s' at line %" XML_FMT_INT_MOD \
                     "u character %" XML_FMT_INT_MOD "u\n",
                 XML_ErrorString (XML_GetErrorCode (parser)),
                 XML_GetCurrentLineNumber (parser),
                 XML_GetCurrentColumnNumber (parser));
        free (XMLBuf);
        XML_ParserFree (parser);
        exit (4);
      }
      XMLBufPtr += bufferSize;
    } while (!isFinal);
    tend = clock();
    cpuTime += ((double) (tend - tstart)) / CLOCKS_PER_SEC;
    XML_ParserFree (parser);
    i++;
  }

  free (XMLBuf);
      
  printf ("%d loops, with buffer size %d. Average time per loop: %f\n", 
          nrOfLoops, bufferSize, cpuTime / (double) nrOfLoops);
  return 0;
}
コード例 #16
0
ファイル: xsInfoset.c プロジェクト: basuke/kinomajs
void xs_infoset_scan(xsMachine* the)
{
	int c = xsToInteger(xsArgc);
	Scanner scanner;
	Scanner* self;
	xsVars(COUNT);
	xsTry {
		self = &scanner;
		c_memset(self, 0, sizeof(Scanner));
		if (c < 1)
			xsSyntaxError("no buffer");
		
		self->expat = XML_ParserCreate(NULL);
		xsThrowIfNULL(self->expat);
		XML_SetUserData(self->expat, self);
		XML_SetElementHandler(self->expat, scanStartTag, scanStopTag);
		XML_SetCdataSectionHandler(self->expat, scanStartCdata, scanStopCdata);
		XML_SetCharacterDataHandler(self->expat, scanCharacter);
		XML_SetCommentHandler(self->expat, scanComment);
		XML_SetProcessingInstructionHandler(self->expat, scanProcessingInstruction);
		XML_SetUnknownEncodingHandler(self->expat, scanUnknownEncoding, NULL);
		XML_SetSkippedEntityHandler(self->expat, scanEntity);
		
		self->result = 1;
		self->textBuffer = c_malloc(8192);
		xsThrowIfNULL(self->textBuffer);
		self->textSize = 8192;
		
		self->the = the;
		xsVar(ATTRIBUTE_PROTOTYPE) = xsGet(xsThis, xsID_attribute);
		xsVar(CDATA_PROTOTYPE) = xsGet(xsThis, xsID_cdata);
		xsVar(COMMENT_PROTOTYPE) = xsGet(xsThis, xsID_comment);
		xsVar(DOCUMENT_PROTOTYPE) = xsGet(xsThis, xsID_document);
		xsVar(ELEMENT_PROTOTYPE) = xsGet(xsThis, xsID_element);
		xsVar(NO_NAMESPACE) = xsString("");
		xsVar(NO_PREFIX) = xsString("");
		xsVar(PATH) = (c > 1) ? xsArg(1) : xsUndefined;
		xsVar(PI_PROTOTYPE) = xsGet(xsThis, xsID_pi);
		xsVar(XML_NAMESPACE) = xsGet(xsThis, xsID_xmlnsNamespace);
		xsVar(XML_PREFIX) = xsGet(xsThis, xsID_xmlnsPrefix);
		
		xsResult = xsNewInstanceOf(xsVar(DOCUMENT_PROTOTYPE));
		xsSet(xsResult, xsID_encoding, xsString("UTF-8"));
		xsSet(xsResult, xsID_version, xsString("1.0"));
		xsVar(CHILDREN) = xsNewInstanceOf(xsArrayPrototype);
		xsArrayCacheBegin(xsVar(CHILDREN));
		xsSet(xsResult, xsID_children, xsVar(CHILDREN));
		xsSet(xsResult, xsID_parent, xsNull);
		xsSet(xsResult, xsID_xmlnsAttributes, xsNull);

		if (xsIsInstanceOf(xsArg(0), xsChunkPrototype)) {
			xsStringValue buffer = xsGetHostData(xsArg(0));
			xsIntegerValue size = xsToInteger(xsGet(xsArg(0), xsID_length));
			self->result = XML_Parse(self->expat, (const char *)buffer, size, 1);
		}
		else if (xsTypeOf(xsArg(0)) == xsStringType) {
			xsStringValue string = xsToString(xsArg(0));
			xsIntegerValue stringOffset = 0;
			xsIntegerValue stringSize = c_strlen(string);
			while (self->result && (stringOffset < stringSize)) {
				xsIntegerValue size = stringSize - stringOffset;
				xsStringValue buffer = (char *)XML_GetBuffer(self->expat, 1024);
				xsThrowIfNULL(buffer);
				if (size > 1024) 
					size = 1024;
				c_memcpy(buffer, string + stringOffset, size);
				self->result = XML_ParseBuffer(self->expat, size, (size < 1024) ? 1 : 0);
				stringOffset += size;
				string = xsToString(xsArg(0)); // @@ gc
			}
		}
		else {
			xsStreamGetter* streamGetter = xsGetHostData(xsArg(0));
			while (self->result) {
				xsIntegerValue i;
				xsStringValue p, buffer = (char *)XML_GetBuffer(self->expat, 1024);
				xsThrowIfNULL(buffer);
				for (i = 0, p = buffer; i < 1024; i++, p++) {
					int c = (*(streamGetter->getter))(streamGetter->stream);
					if (c == C_EOF)
						break;
					*p = (char)c;
				}
				self->result = XML_ParseBuffer(self->expat, i, (i < 1024) ? 1 : 0);
				if (i < 1024)
					break;
			}
		}
		
		xsDelete(xsResult, xsID_xmlnsAttributes);
		xsDelete(xsResult, xsID_parent);
		xsArrayCacheEnd(xsVar(CHILDREN));
		
		if (!self->result) {
			xsVar(LINE) = xsInteger(XML_GetCurrentLineNumber(self->expat));
			xsVar(VALUE) = xsString((char*)XML_ErrorString(XML_GetErrorCode(self->expat)));
			if (xsHas(xsThis, xsID_reportError))
				xsCall3_noResult(xsThis, xsID_reportError, xsVar(PATH), xsVar(LINE), xsVar(VALUE));
			xsThrow(xsNewInstanceOf(xsSyntaxErrorPrototype));
		}
		c_free(self->textBuffer);
		self->textBuffer = NULL;
		XML_ParserFree(self->expat);
		self->expat = NULL;
	}
	xsCatch {
		if (self->textBuffer)
			c_free(self->textBuffer);
		if (self->expat)
			XML_ParserFree(self->expat);
	}
}
コード例 #17
0
ファイル: xmldom.cpp プロジェクト: zhuxiaokun/workshop
BOOL XMLDomParser::Parse(StreamInterface& s, XMLElementNode& root)
{
	this->Reset();
	size_t pos = s.tell();

	DWORD flag = 0;
	int_r n2 = s.ReadData(&flag, 3);
	if(n2 == 3 && flag == utf8_signature)
	{
		const char* encoding = "UTF-8";
		if(stricmp(encoding, m_encoding.c_str()) && m_parser)
		{
			XML_ParserFree(m_parser);
			m_parser = NULL;
		}
		m_encoding = encoding;
	}
	else
	{
		s.Seek(pos);
	}

	if(!m_parser)
	{
		if(m_encoding.empty()) m_encoding = "GB2312";
		m_parser = XML_ParserCreate(m_encoding.c_str());
		if(!m_parser) return FALSE;
		XML_SetUserData(m_parser, this);
		XML_SetElementHandler(m_parser, &StartElementHandler, &EndElementHandler);
		XML_SetCharacterDataHandler(m_parser, &CharacterDataHandler);
	}

	if(root.m_tagName.empty())
		root.SetTagName("XMLRoot");

	m_pRootNode = &root;
	m_stack.push(m_pRootNode);

	//const char* orglocale = NULL;
	//if(m_encoding.icompare("GB2312") == 0)
	//	orglocale = setLocaleToGbk();
	//else if(g_encoding == encode_ansii && m_encoding.icompare("UTF-8") == 0)
	//	orglocale = setLocaleToGbk();

	int_r n;
	char cBuffer[2048];
	while(n = s.ReadData(&cBuffer, 2048), n>=0)
	{
		BOOL isFinal = (n < 2048);
		XML_Status status = XML_Parse(m_parser, cBuffer, (int)n, isFinal);
		if(status == XML_STATUS_ERROR)
		{
			//if(orglocale) setlocale(LC_CTYPE, orglocale);
			sprintf_k(cBuffer, sizeof(cBuffer), "%s at line:%d col:%d",
				XML_ErrorString(XML_GetErrorCode(m_parser)),
				XML_GetCurrentLineNumber(m_parser),
				XML_GetCurrentColumnNumber(m_parser));
			m_errMsg = cBuffer;
			return FALSE;
		}
		if(isFinal) break;
	}
	//if(orglocale) setlocale(LC_CTYPE, orglocale);
	return TRUE;
}
コード例 #18
0
ファイル: upnp.c プロジェクト: 0x7F800000/Aleph-NONE
/* get the control url from the description, which is in xml format, and
   set the control_url variable in c equal to the string */
static int Get_Control_Url(UpnpController * c, const char * desc_url, 
                           const char * description)
{
  int ret;
  char host[MAX_HOST_LEN];
  char host_port[MAX_HOST_LEN];
  short int port;
  XML_Parser parser;
  XmlDescData xdescdat = {0, 0, 0, 0, 0, 0, 0};

  if((ret = Parse_Url(desc_url, host, NULL, &port)) != OK) {
    return ret;
  }
  sprintf(host_port, "%s:%d", host, port);
    
  parser = XML_ParserCreate(NULL);
  xdescdat.correct_service = (char *)malloc(strlen(SSDP_TARGET) +
                                            strlen(c->service_type) +
                                            NULL_TERM_LEN);
  (void)sprintf(xdescdat.correct_service, SSDP_TARGET, c->service_type);

  XML_SetUserData(parser, &xdescdat);
  XML_SetElementHandler(parser, Start_Desc_Element, End_Desc_Element);
  XML_SetCharacterDataHandler(parser, Data_Desc_Handler);

  if(!XML_Parse(parser, description, (int)strlen(description), 1)) {
    XML_ParserFree(parser);
    XmlDescData_Free(xdescdat);
    return UPNP_BAD_DESCRIPTION;
  }

  /* if we didn't find a base url in the description, then it is the
     same url as the desc_url */
  if(NULL == xdescdat.url_base) {
    xdescdat.url_base = (char *)malloc(strlen(host_port) + NULL_TERM_LEN);
    strcpy(xdescdat.url_base, host_port);
  }

  /* if the control_url contains the http protocol string,
     then don't prepend the base url to it */
  if(strncmp(xdescdat.control_url, HTTP_PROTOCOL_STRING, 
             strlen(HTTP_PROTOCOL_STRING))  == 0) {
    c->control_url = (char *)malloc(strlen(xdescdat.control_url) + 
                                    NULL_TERM_LEN);
    if(NULL == c->control_url) {
      XmlDescData_Free(xdescdat);
      return BAD_MALLOC;
    }
    strcpy(c->control_url, xdescdat.control_url);
  } else {
    c->control_url = (char *)malloc(strlen(xdescdat.url_base)+
                                    strlen(xdescdat.control_url) +
                                    NULL_TERM_LEN);
    if(NULL == c->control_url) {
      XmlDescData_Free(xdescdat);
      return BAD_MALLOC;
    }
    (void)sprintf(c->control_url, "%s%s", xdescdat.url_base, xdescdat.control_url);
  }

  XmlDescData_Free(xdescdat);
  XML_ParserFree(parser);

  /* now make sure that the url size is appropriate */
  if(strlen(c->control_url)+NULL_TERM_LEN > MAX_URL_LEN) {
    free(c->control_url);
    return UPNP_URL_OVER_MAX_LEN;
  }
  return OK;
}
コード例 #19
0
ファイル: static-services.c プロジェクト: BrianClaggett/avahi
static int static_service_group_load(StaticServiceGroup *g) {
    XML_Parser parser = NULL;
    int fd = -1;
    struct xml_userdata u;
    int r = -1;
    struct stat st;
    ssize_t n;

    assert(g);

    u.buf = NULL;
    u.group = g;
    u.service = NULL;
    u.current_tag = XML_TAG_INVALID;
    u.failed = 0;

    /* Cleanup old data in this service group, if available */
    remove_static_service_group_from_server(g);
    while (g->services)
        static_service_free(g->services);

    avahi_free(g->name);
    avahi_free(g->chosen_name);
    g->name = g->chosen_name = NULL;
    g->replace_wildcards = 0;

    if (!(parser = XML_ParserCreate(NULL))) {
        avahi_log_error("XML_ParserCreate() failed.");
        goto finish;
    }

    if ((fd = open(g->filename, O_RDONLY)) < 0) {
        avahi_log_error("open(\"%s\", O_RDONLY): %s", g->filename, strerror(errno));
        goto finish;
    }

    if (fstat(fd, &st) < 0) {
        avahi_log_error("fstat(): %s", strerror(errno));
        goto finish;
    }

    g->mtime = st.st_mtime;

    XML_SetUserData(parser, &u);

    XML_SetElementHandler(parser, xml_start, xml_end);
    XML_SetCharacterDataHandler(parser, xml_cdata);

    do {
        void *buffer;

#define BUFSIZE (10*1024)

        if (!(buffer = XML_GetBuffer(parser, BUFSIZE))) {
            avahi_log_error("XML_GetBuffer() failed.");
            goto finish;
        }

        if ((n = read(fd, buffer, BUFSIZE)) < 0) {
            avahi_log_error("read(): %s\n", strerror(errno));
            goto finish;
        }

        if (!XML_ParseBuffer(parser, n, n == 0)) {
            avahi_log_error("XML_ParseBuffer() failed at line %d: %s.\n", (int) XML_GetCurrentLineNumber(parser), XML_ErrorString(XML_GetErrorCode(parser)));
            goto finish;
        }

    } while (n != 0);

    if (!u.failed)
        r = 0;

finish:

    if (fd >= 0)
        close(fd);

    if (parser)
        XML_ParserFree(parser);

    avahi_free(u.buf);

    return r;
}
コード例 #20
0
BOOLEAN ReadInLBEPocketPopups(STR fileName)
{
	HWFILE		hFile;
	UINT32		uiBytesRead;
	UINT32		uiFSize;
	CHAR8 *		lpcBuffer;
	XML_Parser	parser = XML_ParserCreate(NULL);
	
	pocketPopupParseData pData;

	DebugMsg(TOPIC_JA2, DBG_LEVEL_3, "Loading pocketPopups.xml" );

	hFile = FileOpen( fileName, FILE_ACCESS_READ, FALSE );
	if ( !hFile )
		return( FALSE );
	
	uiFSize = FileGetSize(hFile);
	lpcBuffer = (CHAR8 *) MemAlloc(uiFSize+1);

	//Read in block
	if ( !FileRead( hFile, lpcBuffer, uiFSize, &uiBytesRead ) )
	{
		MemFree(lpcBuffer);
		return( FALSE );
	}

	lpcBuffer[uiFSize] = 0; //add a null terminator

	FileClose( hFile );

	
	XML_SetElementHandler(parser, pocketPopupStartElementHandle, pocketPopupEndElementHandle);
	XML_SetCharacterDataHandler(parser, pocketPopupCharacterDataHandle);

	
	memset(&pData,0,sizeof(pData));
	XML_SetUserData(parser, &pData);
	
	XML_SetUserData(parser, &pData);

	if(!XML_Parse(parser, lpcBuffer, uiFSize, TRUE))
	{
		CHAR8 errorBuf[511];

		sprintf(errorBuf, "XML Parser Error in Pocket.xml: %s at line %d", XML_ErrorString(XML_GetErrorCode(parser)), XML_GetCurrentLineNumber(parser));
		LiveMessage(errorBuf);

		MemFree(lpcBuffer);
		return FALSE;
	}

	/*
	// dummy popup

	 popupDef* popup = new popupDef();
	 popup->addOption(new std::wstring(L"Option one"),NULL,NULL);
	 popup->addOption(new std::wstring(L"Option two"),NULL,NULL);
	 popup->addOption(new std::wstring(L"Option three"),NULL,NULL);

	LBEPocketPopup[5] = *popup;
	*/

	MemFree(lpcBuffer);


	XML_ParserFree(parser);


	return( TRUE );
}
コード例 #21
0
int
  main
    (int
      argc,
    char
      *argv [])

{ /* main for groom-nmap-xml */

  char
    buff [65536];
  int
    buff_size;
  int
    done;
  FILE
    *fp;
  int
    i;
  int
    j;
  XML_Parser
    parser;
  int
    status;
  int
    status_io;


  status = ST_OK;
  buff_size = sizeof (buff);
if (argc > 1)
  fprintf (stderr, "Groom NMAP XML 0.0 EP 01\n");

  param_verbosity = 2;
  strcpy (param_results_path, "/tester/current/results");
  if (argc > 1)
  {
    strcpy (param_results_path, argv [1]);
    if (argc > 2)
    {
      int i;
      sscanf (argv [1], "%d", &i);
      param_verbosity = i;
    };
  };

  if (param_verbosity > 2)
  {
    fprintf (stderr, "collect_nmap: param_verbosity %d\n",
      param_verbosity);
  };

  cur_netnode = -1;
  cur_sap = -1;
  memset (netnodes, 0, sizeof (netnodes));
  fp = fopen ("test.in", "r");
  if (fp == NULL)
  {
    printf ("Failed to open file\n");
    status = -1;
  }

  if (status EQUALS ST_OK)
  {
    parser = XML_ParserCreate (NULL);
    XML_SetElementHandler(parser, start_element, end_element);
    XML_SetCharacterDataHandler (parser, handle_data);

    memset(buff, 0, buff_size);
    memset((void *)&nctx, 0, sizeof (nctx));

    status_io = fread (buff, sizeof(char), buff_size, fp);
    if (param_verbosity > 1)
      fprintf (stderr, "Read %d bytes from file\n", status_io);
    if (status_io EQUALS buff_size)
      status = -2;

    if (status EQUALS ST_OK)
    {
      /* parse the xml */
      if (XML_Parse(parser, buff, strlen(buff), XML_TRUE) == XML_STATUS_ERROR)
      {
        printf("Error: %s\n", XML_ErrorString(XML_GetErrorCode(parser)));
      }
    };
    XML_ParserFree (parser);
  };

  fprintf (stderr, "%d nodes found\n",
    1+cur_netnode);
  done = 0;
  for (i=0; (!done) && (i<cur_netnode); i++)
  {
    char filename [1024]; 
    FILE *ninfo;
    char s1 [1024];


    sprintf (filename, "%s/%06d_node_inventory.json",
      param_results_path, i);
    ninfo = fopen (filename, "w");
    if (!ninfo)
      done = 1;
    if (!done)
    {
      fprintf (ninfo, "{\n");
      if (strlen (netnodes[i].addr_ieee802) EQUALS 0)
        strcpy (s1, "(Unknown)");
      else
        strcpy (s1, netnodes[i].addr_ieee802);

      fprintf (ninfo, "  \"ipv4\" : \"%s\",\n  \"mac\" : \"%s\",\n",
        netnodes [i].addr_ipv4, s1);
      for (j=0; j < netnodes [i].port_count; j++)
      {
        fprintf (ninfo, "  \"port\" : \"tcp/%s\"",
          netnodes [i].ports [j].sap_port);
        if (j != (netnodes[i].port_count-1))
          fprintf (ninfo, ",");
        fprintf (ninfo, "\n");
      };
      fprintf (ninfo, "}\n");
      fclose (ninfo);
    };
  };

  if (status != 0)
    fprintf (stderr, "Status was %d\n", status);
  return (status);

} /* main for groom-nmap-xml */
コード例 #22
0
ファイル: iterparse.c プロジェクト: Juanlu001/astropy
/*
 * Initialize an IterParser object
 *
 * The Python arguments are:
 *
 *    *fd*: A Python file object or a callable object
 *    *buffersize*: The size of the read buffer
 */
static int
IterParser_init(IterParser *self, PyObject *args, PyObject *kwds)
{
    PyObject* fd              = NULL;
    PyObject* read            = NULL;
    ssize_t   buffersize      = 1 << 14;

    static char *kwlist[] = {"fd", "buffersize", NULL};
    if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|n:IterParser.__init__", kwlist,
                                     &fd, &buffersize)) {
        return -1;
    }

    /* Keep the buffersize within a reasonable range */
    self->buffersize = CLAMP(buffersize, (ssize_t)(1 << 10), (ssize_t)(1 << 24));
#ifdef __clang__
    /* Clang can't handle the file descriptors Python gives us,
       so in that case, we just call the object's read method. */
    read = PyObject_GetAttrString(fd, "read");
    if (read != NULL) {
        fd = read;
    }
#else
    self->file = PyObject_AsFileDescriptor(fd);
    if (self->file != -1) {
        /* This is a real C file handle or descriptor.  We therefore
           need to allocate our own read buffer, and get the real C
           object. */
        self->buffer = malloc((size_t)self->buffersize);
        if (self->buffer == NULL) {
            PyErr_SetString(PyExc_MemoryError, "Out of memory");
            goto fail;
        }
        self->fd = fd;   Py_INCREF(self->fd);
        lseek(self->file, 0, SEEK_SET);
    } else
#endif
    if (PyCallable_Check(fd)) {
        /* fd is a Python callable */
        self->fd = fd;   Py_INCREF(self->fd);
        self->read = fd; Py_INCREF(self->read);
    } else {
        PyErr_SetString(
            PyExc_TypeError,
            "Arg 1 to iterparser must be a file object or callable object");
        goto fail;
    }

    PyErr_Clear();

    self->queue_read_idx  = 0;
    self->queue_write_idx = 0;
    self->done            = 0;

    self->text = malloc((size_t)buffersize * sizeof(XML_Char));
    self->text_alloc = buffersize;
    if (self->text == NULL) {
        PyErr_SetString(PyExc_MemoryError, "Out of memory");
        goto fail;
    }
    text_clear(self);

    self->read_args = Py_BuildValue("(n)", buffersize);
    if (self->read_args == NULL) {
        goto fail;
    }

    self->dict_singleton = PyDict_New();
    if (self->dict_singleton == NULL) {
        goto fail;
    }

    self->td_singleton = PyUnicode_FromString("TD");
    if (self->td_singleton == NULL) {
        goto fail;
    }

    if (queue_realloc(self, buffersize)) {
        goto fail;
    }

    /* Set up an expat parser with our callbacks */
    self->parser = XML_ParserCreate(NULL);
    if (self->parser == NULL) {
        PyErr_SetString(PyExc_MemoryError, "Out of memory");
        goto fail;
    }
    XML_SetUserData(self->parser, self);
    XML_SetElementHandler(
        self->parser,
        (XML_StartElementHandler)startElement,
        (XML_EndElementHandler)endElement);
    XML_SetCharacterDataHandler(
        self->parser,
        (XML_CharacterDataHandler)characterData);
    XML_SetXmlDeclHandler(
        self->parser,
        (XML_XmlDeclHandler)xmlDecl);

    Py_XDECREF(read);

    return 0;

 fail:
    Py_XDECREF(read);
    Py_XDECREF(self->fd);
    Py_XDECREF(self->read);
    free(self->text);
    Py_XDECREF(self->dict_singleton);
    Py_XDECREF(self->td_singleton);
    Py_XDECREF(self->read_args);
    free(self->queue);

    return -1;
}
コード例 #23
0
LLSDXMLParser::Impl::Impl()
{
	mParser = XML_ParserCreate(NULL);
	reset();
}
コード例 #24
0
ファイル: posm_extractor.c プロジェクト: agentelinux/odopoi
int main(int argc, char *argv[], char *envp[])
{
	int i;
	FILE *f;
	char buf[BUFSIZE];
	int len;
	int done;
	int depth;
	XML_Parser parser;

	f = NULL;
	len = 0;
	done = 0;
	depth = 0;

	if (argc < 2) {
		fprintf(stderr, "To read from a file:\n\tposm_extractor filename.osm [filename-2.osm ...]\nTo read from stdin:\n\tposm_extractor -\n");
		return -1;
	}

	fprintf(stdout, "SET NAMES 'utf8' COLLATE 'utf8_unicode_ci';\n");
	fprintf(stdout, "SET CHARACTER SET 'utf8';\n");
	fprintf(stdout, "SET collation_connection = 'utf8_general_ci';\n");
	fprintf(stdout, "DELETE FROM node;\n");
	fprintf(stdout, "DELETE FROM tag;\n");
	fflush(stdout);

	for (i = 1; i < argc; i++) {

#ifdef DO_FORK
		pid_t pid = fork();

		if (pid == 0) {
#endif

			parser = XML_ParserCreate("UTF-8");
			if (parser == NULL) {
				fprintf(stderr, "Could not initialize parser.\n");
			}

			XML_SetUserData(parser, &depth);
			XML_SetElementHandler(parser, startElement, endElement);

			if (strlen(argv[i]) == 1 && argv[i][0] == '-') {
				f = stdin;
			} else {
				f = fopen(argv[i], "rb");
				if (f == NULL) {
					fprintf(stderr, "Could not open '%s'\n", argv[i]);
					XML_ParserFree(parser);
					return 1;
				}
			}

			do {
				len = fread(buf, sizeof(char), BUFSIZE, f);
				done = feof(f);

				if (!XML_Parse(parser, buf, len, done)) {
					fclose(f);
					fprintf(stderr, "Error (%d): %s at line %d\n", XML_GetErrorCode(parser), XML_ErrorString(XML_GetErrorCode(parser)), (int) XML_GetCurrentLineNumber(parser));
					XML_ParserFree(parser);
					return 1;
				}

			} while (!done);

			if (f != stdin) {
				fclose(f);
			}

			XML_ParserFree(parser);

#ifdef DO_FORK
			return 0;
		} else if (pid == -1) {
			perror("fork");
			return -1;
		}
#endif
	}

#ifdef DO_FORK
	while (1) {
		int status = 0;
		pid_t pid = wait(&status);
		if (pid == -1 && errno == ECHILD) {
			break;
		}
	}
#endif

	return 0;
}
コード例 #25
0
ファイル: rd_editcart.c プロジェクト: ElvishArtisan/rivendell
int RD_EditCart(struct rd_cart *cart[],
			struct edit_cart_values edit_c_values,
		  	const char hostname[],
			const char username[],
			const char passwd[],
			const char ticket[],
			const unsigned cartnum,
                        const char user_agent[],
			unsigned *numrecs)
{
  char url[1500];
  CURL *curl=NULL;
  XML_Parser parser;
  struct xml_data xml_data;
  long response_code;
  char errbuf[CURL_ERROR_SIZE];
  CURLcode res;
  char user_agent_string[255];
  char cart_buffer[7];
  struct curl_httppost *first=NULL;
  struct curl_httppost *last=NULL;

  if((curl=curl_easy_init())==NULL) {
    curl_easy_cleanup(curl);
    return -1;
  }

  /*  Set number of recs so if fail already set */
  *numrecs = 0;
  /*
   * Setup the CURL call
   */
  memset(&xml_data,0,sizeof(xml_data));
  parser=XML_ParserCreate(NULL);
  XML_SetUserData(parser,&xml_data);
  XML_SetElementHandler(parser,__EditCartElementStart,
			__EditCartElementEnd);
  XML_SetCharacterDataHandler(parser,__EditCartElementData);
  snprintf(url,1500,"http://%s/rd-bin/rdxport.cgi",hostname);

  curl_formadd(&first,
	&last,
	CURLFORM_PTRNAME,
	"COMMAND",
        CURLFORM_COPYCONTENTS,
        "14",
        CURLFORM_END);

  curl_formadd(&first,
	&last,
	CURLFORM_PTRNAME,
	"LOGIN_NAME",
	CURLFORM_COPYCONTENTS,
	username,
	CURLFORM_END); 

  curl_formadd(&first,
	&last,
	CURLFORM_PTRNAME,
	"PASSWORD",
        CURLFORM_COPYCONTENTS,
	passwd,
	CURLFORM_END);

  curl_formadd(&first,
	&last,
	CURLFORM_PTRNAME,
	"TICKET",
        CURLFORM_COPYCONTENTS,
        ticket,
	CURLFORM_END);

  snprintf(cart_buffer,7,"%u",cartnum);
  curl_formadd(&first,
	&last,
	CURLFORM_PTRNAME,
	"CART_NUMBER",
        CURLFORM_COPYCONTENTS, 
	cart_buffer,
	CURLFORM_END);

  Build_Post_Cart_Fields(&first,&last,edit_c_values);
  
  // Check if User Agent Present otherwise set to default
  if (strlen(user_agent)> 0){
    curl_easy_setopt(curl, CURLOPT_USERAGENT,user_agent);
  }
  else
  {
    strcpy(user_agent_string, RD_GetUserAgent());
    strcat(user_agent_string,VERSION);
    curl_easy_setopt(curl, CURLOPT_USERAGENT,user_agent_string);
  }

  curl_easy_setopt(curl,CURLOPT_WRITEDATA,parser);
  curl_easy_setopt(curl,CURLOPT_WRITEFUNCTION,__EditCartCallback);
  curl_easy_setopt(curl,CURLOPT_URL,url);
  curl_easy_setopt(curl,CURLOPT_POST,1);
  curl_easy_setopt(curl,CURLOPT_HTTPPOST,first);
  curl_easy_setopt(curl,CURLOPT_NOPROGRESS,1);
  curl_easy_setopt(curl,CURLOPT_ERRORBUFFER,errbuf);
 
  res = curl_easy_perform(curl);
  if(res != CURLE_OK) {
    #ifdef RIVC_DEBUG_OUT
        size_t len = strlen(errbuf);
        fprintf(stderr, "\nlibcurl error: (%d)", res);
        if (len)
            fprintf(stderr, "%s%s", errbuf,
                ((errbuf[len-1] != '\n') ? "\n" : ""));
        else
            fprintf(stderr, "%s\n", curl_easy_strerror(res));
    #endif
    curl_easy_cleanup(curl);
    return -1;
  }
/* The response OK - so figure out if we got what we wanted.. */

  curl_easy_getinfo(curl,CURLINFO_RESPONSE_CODE,&response_code);
  curl_formfree(first);
  curl_easy_cleanup(curl);
  
  if (response_code > 199 && response_code < 300) {  //Success
    *cart=xml_data.cart;
    *numrecs = 1;
    return 0;
  }
  else {
    #ifdef RIVC_DEBUG_OUT
        fprintf(stderr," rd_editcart Call Returned Error: %s\n",xml_data.strbuf);
    #endif
    return (int)response_code;
  }
}
コード例 #26
0
ファイル: config_xml.c プロジェクト: JonathanFu/OpenAM-1
am_config_t *am_parse_config_xml(unsigned long instance_id, const char *xml, size_t xml_sz, char log_enable) {
    const char *thisfunc = "am_parse_config_xml():";
    am_config_t *r = NULL;
    char *begin, *stream = NULL;
    size_t data_sz;
    pcre *x = NULL;
    const char *error = NULL;
    int erroroffset;

    am_xml_parser_ctx_t xctx = {.depth = 0, .setting_value = 0,
        .conf = NULL, .rgx = NULL, .parser = NULL, .log_enable = log_enable};

    if (xml == NULL || xml_sz == 0) {
        am_log_error(instance_id, "%s memory allocation error", thisfunc);
        return NULL;
    }

    /*match [key]=value returned within <value>[key]=value_of_a_key</value> element*/
    x = pcre_compile("(?<=\\[)(.+?)(?=\\])\\]\\s*\\=\\s*(.+)", 0, &error, &erroroffset, NULL);
    if (x == NULL) {
        am_log_error(instance_id, "%s pcre error %s", thisfunc, error == NULL ? "" : error);
    }

    r = calloc(1, sizeof (am_config_t));
    if (r == NULL) {
        am_log_error(instance_id, "%s memory allocation error", thisfunc);
        pcre_free(x);
        return NULL;
    }
    r->instance_id = instance_id;

    begin = strstr(xml, "![CDATA[");
    if (begin != NULL) {
        char *end = strstr(begin + 8, "]]>");
        if (end != NULL) {
            stream = begin + 8;
            data_sz = end - (begin + 8);
        }
    } else {
        /*no CDATA*/
        stream = (char *) xml;
        data_sz = xml_sz;
    }

    if (stream != NULL && data_sz > 0) {
        XML_Parser parser = XML_ParserCreate("UTF-8");
        xctx.parser = &parser;
        xctx.conf = r;
        xctx.rgx = x;
        XML_SetUserData(parser, &xctx);
        XML_SetElementHandler(parser, start_element, end_element);
        XML_SetCharacterDataHandler(parser, character_data);
        XML_SetEntityDeclHandler(parser, entity_declaration);
        if (XML_Parse(parser, stream, (int) data_sz, XML_TRUE) == XML_STATUS_ERROR) {
            const char *message = XML_ErrorString(XML_GetErrorCode(parser));
            int line = XML_GetCurrentLineNumber(parser);
            int col = XML_GetCurrentColumnNumber(parser);
            am_log_error(instance_id, "%s xml parser error (%d:%d) %s", thisfunc,
                    line, col, message);
            am_config_free(&r);
            r = NULL;
        } else {
            r->ts = time(NULL);
        }
        XML_ParserFree(parser);
    }

    pcre_free(x);
    return r;
}
コード例 #27
0
XML_Parser _Expat_XML_ParserCreate(struct ExpatIFace * Self, const XML_Char *encoding)
{
	return XML_ParserCreate(encoding);
}
コード例 #28
0
struct audio_route *audio_route_init(unsigned int card, const char *xml_path)
{
    struct config_parse_state state;
    XML_Parser parser;
    FILE *file;
    int bytes_read;
    void *buf;
    int i;
    struct audio_route *ar;

    ar = calloc(1, sizeof(struct audio_route));
    if (!ar)
        goto err_calloc;

    ar->mixer = mixer_open(card);
    if (!ar->mixer) {
        ALOGE("Unable to open the mixer, aborting.");
        goto err_mixer_open;
    }

    ar->mixer_path = NULL;
    ar->mixer_path_size = 0;
    ar->num_mixer_paths = 0;

    /* allocate space for and read current mixer settings */
    if (alloc_mixer_state(ar) < 0)
        goto err_mixer_state;

    /* use the default XML path if none is provided */
    if (xml_path == NULL)
        xml_path = MIXER_XML_PATH;

    file = fopen(xml_path, "r");

    if (!file) {
        ALOGE("Failed to open %s", xml_path);
        goto err_fopen;
    }

    parser = XML_ParserCreate(NULL);
    if (!parser) {
        ALOGE("Failed to create XML parser");
        goto err_parser_create;
    }

    memset(&state, 0, sizeof(state));
    state.ar = ar;
    XML_SetUserData(parser, &state);
    XML_SetElementHandler(parser, start_tag, end_tag);

    for (;;) {
        buf = XML_GetBuffer(parser, BUF_SIZE);
        if (buf == NULL)
            goto err_parse;

        bytes_read = fread(buf, 1, BUF_SIZE, file);
        if (bytes_read < 0)
            goto err_parse;

        if (XML_ParseBuffer(parser, bytes_read,
                            bytes_read == 0) == XML_STATUS_ERROR) {
            ALOGE("Error in mixer xml (%s)", MIXER_XML_PATH);
            goto err_parse;
        }

        if (bytes_read == 0)
            break;
    }

    /* apply the initial mixer values, and save them so we can reset the
       mixer to the original values */
    audio_route_update_mixer(ar);
    save_mixer_state(ar);

    XML_ParserFree(parser);
    fclose(file);
    return ar;

err_parse:
    XML_ParserFree(parser);
err_parser_create:
    fclose(file);
err_fopen:
    free_mixer_state(ar);
err_mixer_state:
    mixer_close(ar->mixer);
err_mixer_open:
    free(ar);
    ar = NULL;
err_calloc:
    return NULL;
}
コード例 #29
0
ファイル: XML_Drugs.cpp プロジェクト: RadekSimkanic/JA2-1.13
BOOLEAN ReadInDrugsStats(STR fileName)
{
	HWFILE		hFile;
	UINT32		uiBytesRead;
	UINT32		uiFSize;
	CHAR8 *		lpcBuffer;
	XML_Parser	parser = XML_ParserCreate(NULL);

	drugsParseData pData;

	DebugMsg(TOPIC_JA2, DBG_LEVEL_3, "Loading Drugs.xml" );

	// Open drugs file
	hFile = FileOpen( fileName, FILE_ACCESS_READ, FALSE );
	if ( !hFile )
		return( FALSE );

	uiFSize = FileGetSize(hFile);
	lpcBuffer = (CHAR8 *) MemAlloc(uiFSize+1);

	//Read in block
	if ( !FileRead( hFile, lpcBuffer, uiFSize, &uiBytesRead ) )
	{
		MemFree(lpcBuffer);
		return( FALSE );
	}

	lpcBuffer[uiFSize] = 0; //add a null terminator

	FileClose( hFile );


	XML_SetElementHandler(parser, drugsStartElementHandle, drugsEndElementHandle);
	XML_SetCharacterDataHandler(parser, drugsCharacterDataHandle);


	memset(&pData,0,sizeof(pData));
	pData.curArray = Drug;
	pData.maxArraySize = DRUG_TYPE_MAX;

	XML_SetUserData(parser, &pData);


	if(!XML_Parse(parser, lpcBuffer, uiFSize, TRUE))
	{
		CHAR8 errorBuf[511];

		sprintf(errorBuf, "XML Parser Error in Drugs.xml: %s at line %d", XML_ErrorString(XML_GetErrorCode(parser)), XML_GetCurrentLineNumber(parser));
		LiveMessage(errorBuf);

		MemFree(lpcBuffer);
		return FALSE;
	}

	MemFree(lpcBuffer);


	XML_ParserFree(parser);


	return( TRUE );
}
コード例 #30
0
static void
ngx_http_dav_ext_propfind_handler(ngx_http_request_t *r)
{
	ngx_chain_t             *c;
	ngx_buf_t               *b;
	XML_Parser              parser;
	ngx_uint_t              status;
	ngx_http_dav_ext_ctx_t *ctx;

	ctx = ngx_http_get_module_ctx(r, ngx_http_dav_ext_module);

	if (ctx == NULL) {
		ctx = ngx_pcalloc(r->pool, sizeof(ngx_http_dav_ext_ctx_t));
		ngx_http_set_ctx(r, ctx, ngx_http_dav_ext_module);
	}

	c = r->request_body->bufs;

	status = NGX_OK;

	parser = XML_ParserCreate(NULL);

	XML_SetUserData(parser, ctx);

	XML_SetElementHandler(parser, 
			ngx_http_dav_ext_start_xml_elt,
			ngx_http_dav_ext_end_xml_elt);

	for(; c != NULL && c->buf != NULL && !c->buf->last_buf; c = c->next) {

		b = c ->buf;

		if (!XML_Parse(parser, (const char*)b->pos, b->last - b->pos, b->last_buf)) {

			ngx_log_error(NGX_LOG_ALERT, r->connection->log, 0,
					"dav_ext propfind XML error");

			status = NGX_ERROR;

			break;
		}

	}

	XML_ParserFree(parser);

	if (status == NGX_OK) {

		r->headers_out.status = 207;

		ngx_str_set(&r->headers_out.status_line, "207 Multi-Status");

		ngx_http_send_header(r);

		ngx_http_finalize_request(r, ngx_http_dav_ext_send_propfind(r));

	} else {

		r->headers_out.status = NGX_HTTP_INTERNAL_SERVER_ERROR;

		r->header_only = 1;

		r->headers_out.content_length_n = 0;

		ngx_http_finalize_request(r, ngx_http_send_header(r));

	}

}