int
DOM_DocumentLS_load(DOM_Document *doc, const DOM_String *uri)
{
FILE *fd;
XML_Parser p;
struct stack *stk;
size_t n; // was ssize_t (DBL)
void *buf;
int ret, done;
DOM_Exception=DOM_NO_ERR; //line added by DBL
if (doc == NULL || uri == NULL) {
DOM_Exception = DOM_NULL_POINTER_ERR;
return 0;
}
fd = fopen(uri, "r");
if (fd == NULL) {
DOM_Exception = DOM_SYSTEM_ERR;
return 0;
}
p = XML_ParserCreate(NULL);
if (p == NULL) {
DOM_Exception = DOM_XML_PARSER_ERR;
fclose(fd);
return 0;
}
stk = stack_new(INT_MAX);
if (stk == NULL || stack_push(stk, doc) == 0) {
DOM_Exception = DOM_SYSTEM_ERR;
XML_ParserFree(p);
fclose(fd);
stack_del(stk, NULL);
return 0;
}
XML_SetElementHandler(p, start_fn, end_fn);
XML_SetCharacterDataHandler(p, chardata_fn);
XML_SetCommentHandler(p, comment_fn);
XML_SetProcessingInstructionHandler(p , processing_fn);
XML_SetUserData(p, stk);
ret = 1;
for ( ;; ) {
if ((buf = XML_GetBuffer(p, BUF_SIZ)) == NULL) {
DOM_Exception = DOM_NO_MEMORY_ERR;
ret = 0;
break;
}
if ((n = fread(buf, 1, BUF_SIZ, fd)) == 0 && ferror(fd)) {
DOM_Exception = DOM_SYSTEM_ERR;
ret = 0;
break;
}
if (XML_ParseBuffer(p, (int) n, (done = feof(fd))) == 0 || DOM_Exception) {
if (DOM_Exception == 0) {
DOM_Exception = DOM_XML_PARSER_ERR;
}
ret = 0;
break;
}
if (done) {
break;
}
}
stack_del(stk, NULL);
XML_ParserFree(p);
fclose(fd);
return ret;
}
static int naip_readXml(const char* fname)
{
assert(fname);
FILE* f = fopen(fname, "r");
if(f == NULL)
{
LOGE("invalid %s", fname);
return 0;
}
XML_Parser xml = XML_ParserCreate("US-ASCII");
if(xml == NULL)
{
LOGE("XML_ParserCreate failed");
goto fail_create;
}
XML_SetElementHandler(xml,
naip_parseStart,
naip_parseEnd);
int done = 0;
while(done == 0)
{
void* buf = XML_GetBuffer(xml, 4096);
if(buf == NULL)
{
LOGE("XML_GetBuffer buf=NULL");
goto fail_parse;
}
int bytes = fread(buf, 1, 4096, f);
if(bytes < 0)
{
LOGE("read failed");
goto fail_parse;
}
done = (bytes == 0) ? 1 : 0;
if(XML_ParseBuffer(xml, bytes, done) == 0)
{
// make sure str is null terminated
char* str = (char*) buf;
str[(bytes > 0) ? (bytes - 1) : 0] = '\0';
enum XML_Error e = XML_GetErrorCode(xml);
LOGE("XML_ParseBuffer err=%s, bytes=%i, buf=%s",
XML_ErrorString(e), bytes, str);
goto fail_parse;
}
}
XML_ParserFree(xml);
fclose(f);
// success
return 1;
// failure
fail_parse:
XML_ParserFree(xml);
fail_create:
fclose(f);
return 0;
}
int
cr_xml_parser_generic(XML_Parser parser,
cr_ParserData *pd,
const char *path,
GError **err)
{
/* Note: This function uses .err members of cr_ParserData! */
int ret = CRE_OK;
CR_FILE *f;
GError *tmp_err = NULL;
assert(parser);
assert(pd);
assert(path);
assert(!err || *err == NULL);
f = cr_open(path, CR_CW_MODE_READ, CR_CW_AUTO_DETECT_COMPRESSION, &tmp_err);
if (tmp_err) {
int code = tmp_err->code;
g_propagate_prefixed_error(err, tmp_err, "Cannot open %s: ", path);
return code;
}
while (1) {
int len;
void *buf = XML_GetBuffer(parser, XML_BUFFER_SIZE);
if (!buf) {
ret = CRE_MEMORY;
g_set_error(err, ERR_DOMAIN, CRE_MEMORY,
"Out of memory: Cannot allocate buffer for xml parser '%s'",
path);
break;
}
len = cr_read(f, buf, XML_BUFFER_SIZE, &tmp_err);
if (tmp_err) {
ret = tmp_err->code;
g_critical("%s: Error while reading xml '%s': %s",
__func__, path, tmp_err->message);
g_propagate_prefixed_error(err, tmp_err, "Read error: ");
break;
}
if (!XML_ParseBuffer(parser, len, len == 0)) {
ret = CRE_XMLPARSER;
g_critical("%s: parsing error '%s': %s",
__func__,
path,
XML_ErrorString(XML_GetErrorCode(parser)));
g_set_error(err, ERR_DOMAIN, CRE_XMLPARSER,
"Parse error '%s' at line: %d (%s)",
path,
(int) XML_GetCurrentLineNumber(parser),
(char *) XML_ErrorString(XML_GetErrorCode(parser)));
break;
}
if (pd->err) {
ret = pd->err->code;
g_propagate_error(err, pd->err);
break;
}
if (len == 0)
break;
}
if (ret != CRE_OK) {
// An error already encoutentered
// just close the file without error checking
cr_close(f, NULL);
} else {
// No error encountered yet
cr_close(f, &tmp_err);
if (tmp_err) {
ret = tmp_err->code;
g_propagate_prefixed_error(err, tmp_err, "Error while closing: ");
}
}
return ret;
}
int load_config()
{
XML_Parser p;
FILE *fp;
char *buffer;
char *config_file, *home;
int nb;
/* Try the following configuration-files:
* ~/.mimic.xml
* /etc/mimic.xml
*/
fp = NULL; config_file = NULL;
home = getenv("HOME");
if( home ){
if( (config_file = malloc(strlen(home) + 15)) == NULL){
perror("malloc()");
return -1;
}
sprintf(config_file, "%s/.mimic.xml", home);
fp = fopen(config_file, "r");
}
/* Try with /etc/mimic.xml */
if( !fp ){
if( config_file )
free(config_file);
if( (config_file = strdup("/etc/mimic.xml")) == NULL ){
perror("strdup()");
return -1;
}
fp = fopen(config_file, "r");
}
/* Print error, and exit */
if( !fp ){
free(config_file);
printf("No usable configuration file found! (Please create ~/.mimic.xml)\n");
return -1;
}
p = XML_ParserCreate(NULL);
if( ! p ) {
fprintf(stderr, "XML_ParserCreate failed (not enough memory?)\n");
free(config_file); fclose(fp);
return -1;
}
if( (buffer = XML_GetBuffer(p, BUFSIZE)) == NULL ){
perror("XML_GetBuffer()");
free(config_file); fclose(fp);
return -1;
}
XML_SetElementHandler(p, start, end);
XML_SetCharacterDataHandler(p, ch_data_handler);
XML_SetUserData(p, &settings);
while( !feof(fp) ){
nb = fread(buffer, 1, BUFSIZE, fp);
if( ferror(fp) ){
perror("fread()");
return -1;
}
if( nb == 0 )
break;
if( XML_ParseBuffer(p, nb, feof(fp)) == XML_STATUS_ERROR ){
fprintf(stderr, "XML parsing error at line %lu:\n%s\n",
XML_GetCurrentLineNumber(p),
XML_ErrorString(XML_GetErrorCode(p)));
fclose(fp);
return -1;
}
}
XML_ParserFree(p);
fclose(fp);
free(config_file);
return 0;
}
int main(int argc, char* argv[])
{
int err = 0;
XML_Parser expat = XML_ParserCreate(NULL);
main_args args;
dae_COLLADA* collada = NULL;
FILE* fp = NULL;
void* data = NULL;
size_t size = 0;
taa_scene scene;
err = main_parse_args(argc, argv, &args);
if(err != 0)
{
puts(MAIN_USAGE);
}
taa_scene_create(&scene, taa_SCENE_Y_UP);
if(err == 0)
{
// open input file
fp = fopen(args.dae, "rb");
if(fp == NULL)
{
printf("could not open input file %s\n", args.dae);
err = -1;
}
}
if(err == 0)
{
// get allocate file buffer
fseek(fp, 0, SEEK_END);
size = ftell(fp);
fseek(fp, 0, SEEK_SET);
data = XML_GetBuffer(expat, size);
if(data == NULL)
{
printf("could not allocate memory of size %u", (unsigned) size);
err = -1;
}
}
if(err == 0)
{
// read file
if(fread(data, 1, size, fp) != size)
{
printf("error reading file\n");
err = -1;
}
}
if(fp != NULL)
{
fclose(fp);
}
if(err == 0)
{
// parse the dae data
daeu_xml_parser parser;
collada = dae_create();
daeu_xml_create(collada, &parser);
XML_SetElementHandler(
expat,
daeu_xml_startelement,
daeu_xml_endelement);
XML_SetCharacterDataHandler(expat, daeu_xml_chardata);
XML_SetUserData(expat, parser);
if(XML_ParseBuffer(expat, size, 1) != XML_STATUS_OK)
{
printf("error parsing xml\n");
err = -1;
}
daeu_xml_destroy(parser);
}
XML_ParserFree(expat);
if(err == 0)
{
// convert to taa_scene
convert_collada(args.dae, collada, &scene);
}
if(collada != NULL)
{
dae_destroy(collada);
}
if(err == 0)
{
// convert up axis
taa_scene_convert_upaxis(&scene, args.upaxis);
}
if(err == 0)
{
// open output file
fp = fopen(args.out, "wb");
if(fp == NULL)
{
printf("could not open output file %s\n", args.out);
err = -1;
}
}
if(err == 0)
{
// export
taa_filestream outfs;
taa_filestream_create(fp, 1024 * 1024, taa_FILESTREAM_WRITE, &outfs);
taa_scenefile_serialize(&scene, &outfs);
taa_filestream_destroy(&outfs);
fclose(fp);
}
taa_scene_destroy(&scene);
#if defined(_DEBUG) && defined(_MSC_FULL_VER)
_CrtSetReportMode(_CRT_ERROR, _CRTDBG_MODE_FILE);
_CrtSetReportFile(_CRT_ERROR, _CRTDBG_FILE_STDOUT);
_CrtCheckMemory();
_CrtDumpMemoryLeaks();
#endif
return err;
}
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);
}
}
void * _Expat_XML_GetBuffer(struct ExpatIFace * Self, XML_Parser parser, int len)
{
return XML_GetBuffer(parser, len);
}
char* XML_Parser::allocate(size_t n)
{
return (char*)XML_GetBuffer(_rep->parser, n);
}
bool
OMXMLReaderExpat::next()
{
TRACE("OMXMLReaderExpat::next");
if (_status == false)
{
return _status;
}
while (_status && nextEvent() == NONE)
{
if (!_readNextChunk)
{
int ret = XML_ResumeParser(_parser);
if (ret == XML_STATUS_ERROR)
{
XML_Error errorCode = XML_GetErrorCode(_parser);
if (errorCode == XML_ERROR_NOT_SUSPENDED)
{
XML_ParsingStatus pStatus;
XML_GetParsingStatus(_parser, &pStatus);
if (pStatus.parsing == XML_FINISHED)
{
// finished
_status = false;
}
else
{
_readNextChunk = true;
}
}
else
{
throw OMException(getErrorString());
}
}
}
if (_readNextChunk)
{
void* buffer = XML_GetBuffer(_parser, READ_CHUNK_SIZE);
_numInBuffer = readNextChunk(buffer, READ_CHUNK_SIZE);
int ret = XML_ParseBuffer(_parser, _numInBuffer, _numInBuffer < READ_CHUNK_SIZE);
if (ret == XML_STATUS_ERROR)
{
throw OMException(getErrorString());
}
if (_status)
{
XML_ParsingStatus pStatus;
XML_GetParsingStatus(_parser, &pStatus);
if (pStatus.parsing == XML_FINISHED)
{
if (_numInBuffer < READ_CHUNK_SIZE)
{
_status = false;
}
else
{
_readNextChunk = true;
}
}
else
{
_readNextChunk = false;
}
}
}
}
return _status;
}
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;
}
struct audio_route *audio_route_init(unsigned int card_slot)
{
struct config_parse_state state;
XML_Parser parser;
FILE *file;
int bytes_read;
void *buf;
int fd, cnt;
struct mixer_path *path;
struct audio_route *ar;
char vendor_xml_path[PATH_MAX];
char codec_vendor_name[PATH_MAX];
char vendor_name[255];
char *tmpchar;
ar = calloc(1, sizeof(struct audio_route));
if (!ar)
goto err_calloc;
ar->mixer = mixer_open(card_slot);
if (!ar->mixer) {
ALOGE("Unable to open the mixer, aborting.");
goto err_mixer_open;
}
ALOGV("Mixer open successful.");
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;
snprintf(codec_vendor_name, sizeof(codec_vendor_name), CODEC_CHIP_NAME_PATH, card_slot);
fd = open(codec_vendor_name, O_RDONLY);
if (fd == -1) {
ALOGE("Failed to open %s", codec_vendor_name);
/* If no codec name file, then use unknown. */
strcpy(vendor_name, CODEC_CHIP_NAME_UNKNOWN);
} else {
cnt = read(fd, vendor_name, 255);
if (cnt <= 0) {
ALOGE("Failed to read vendor name:%s.", vendor_name);
/* If no codec name file, then use unknown. */
strcpy(vendor_name, CODEC_CHIP_NAME_UNKNOWN);
} else {
vendor_name[cnt-1] = '\0';
}
close(fd);
}
/* Replace spaces with underscore in vendor name */
tmpchar = vendor_name;
while (*tmpchar) {
if (*tmpchar == ' ')
*tmpchar = '_';
tmpchar++;
}
sprintf(vendor_xml_path, MIXER_XML_PATH, vendor_name);
ALOGV("Opening up %s.", vendor_xml_path);
file = fopen(vendor_xml_path, "r");
if (!file) {
ALOGE("Failed to open %s", vendor_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 (ferror(file))
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 */
update_mixer_state(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;
}
int
lr_metalink_parse_file(lr_Metalink metalink, int fd, const char *filename)
{
int ret = LRE_OK;
XML_Parser parser;
ParserData pd;
lr_StatesSwitch *sw;
assert(metalink);
DEBUGASSERT(fd >= 0);
/* Parser configuration */
parser = XML_ParserCreate(NULL);
XML_SetUserData(parser, (void *) &pd);
XML_SetElementHandler(parser, lr_metalink_start_handler, lr_metalink_end_handler);
XML_SetCharacterDataHandler(parser, lr_metalink_char_handler);
/* Initialization of parser data */
memset(&pd, 0, sizeof(pd));
pd.ret = LRE_OK;
pd.depth = 0;
pd.state = STATE_START;
pd.statedepth = 0;
pd.docontent = 0;
pd.content = lr_malloc(CONTENT_REALLOC_STEP);
pd.lcontent = 0;
pd.acontent = CONTENT_REALLOC_STEP;
pd.parser = &parser;
pd.metalink = metalink;
pd.filename = (char *) filename;
pd.ignore = 1;
pd.found = 0;
for (sw = stateswitches; sw->from != NUMSTATES; sw++) {
if (!pd.swtab[sw->from])
pd.swtab[sw->from] = sw;
pd.sbtab[sw->to] = sw->from;
}
/* Parse */
for (;;) {
char *buf;
int len;
buf = XML_GetBuffer(parser, CHUNK_SIZE);
if (!buf)
lr_out_of_memory();
len = read(fd, (void *) buf, CHUNK_SIZE);
if (len < 0) {
DPRINTF("%s: Cannot read for parsing : %s\n",
__func__, strerror(errno));
ret = LRE_IO;
break;
}
if (!XML_ParseBuffer(parser, len, len == 0)) {
DPRINTF("%s: parsing error: %s\n",
__func__, XML_ErrorString(XML_GetErrorCode(parser)));
ret = LRE_MLXML;
break;
}
if (len == 0)
break;
if (pd.ret != LRE_OK) {
ret = pd.ret;
break;
}
}
/* Parser data cleanup */
lr_free(pd.content);
XML_ParserFree(parser);
if (!pd.found)
return LRE_MLBAD; /* The wanted file was not found in metalink */
return ret;
}
bool PG_Layout::Load(PG_Widget* parent, const std::string& filename, void (* WorkCallback)(int now, int max), void *UserSpace) {
ParseUserData_t XMLParser;
bool status = true;
int bytes_pos = 0;
XMLParser.Parser = XML_ParserCreate(NULL);
XMLParser.Section = XML_SECTION_DOC;
XMLParser.PrevUserData = NULL;
XMLParser.ParentObject = parent;
XMLParser.InhTagFlags = 0;
XMLParser.UserSpace = UserSpace;
XML_SetUserData(XMLParser.Parser, &XMLParser);
XML_SetElementHandler(XMLParser.Parser, XMLStartDoc, XMLEndDoc);
XML_SetCharacterDataHandler(XMLParser.Parser, XMLTextDoc);
XML_SetProcessingInstructionHandler(XMLParser.Parser, XMLProcInstr);
XMLParser.FileName = filename.c_str();
PG_File* f = PG_Application::OpenFile(XMLParser.FileName);
if (f == NULL) {
PG_LogWRN("Layout file %s not found !", filename.c_str());
return false;
}
for (;;) {
int bytes_read;
void* buff;
if ((buff = XML_GetBuffer(XMLParser.Parser, XML_BUFF_SIZE)) == NULL) {
PG_LogWRN("Can`t get parse buffer");
status = false;
break;
}
bytes_read = f->read(buff, XML_BUFF_SIZE);
bytes_pos += bytes_read;
if (WorkCallback != NULL) {
WorkCallback(bytes_pos , f->fileLength());
}
if (XML_ParseBuffer(XMLParser.Parser, bytes_read, bytes_read == 0) == 0) {
PG_LogWRN("%s on the line %d pos %d",XML_ErrorString(XML_GetErrorCode(XMLParser.Parser)),XML_GetCurrentLineNumber(XMLParser.Parser), XML_GetCurrentColumnNumber(XMLParser.Parser));
status = false;
break;
}
if (bytes_read == 0) {
status = true;
break;
}
}
if (XMLParser.Parser != NULL) {
XML_ParserFree(XMLParser.Parser);
}
delete f;
while (XMLParser.PrevUserData != NULL)
RestoreUserData(&XMLParser);
return true;
}
bool
Csocketcan::open(const char *pUsername,
const char *pPassword,
const char *pHost,
short port,
const char *pPrefix,
const char *pConfig)
{
bool rv = true;
std::string wxstr = std::string(pConfig);
m_username = std::string(pUsername);
m_password = std::string(pPassword);
m_host = std::string(pHost);
m_port = port;
m_prefix = std::string(pPrefix);
// Parse the configuration string. It should
// have the following form path
std::deque<std::string> tokens;
vscp_split( tokens, std::string(pConfig), ";" );
// Check for socketcan interface in configuration string
if (!tokens.empty()) {
// Interface
m_interface = tokens.front();
tokens.pop_front();
}
// First log on to the host and get configuration
// variables
if (VSCP_ERROR_SUCCESS != m_srv.doCmdOpen(m_host,
m_port,
m_username,
m_password)) {
syslog(LOG_ERR,
"%s",
(const char *)"Unable to connect to "
"VSCP TCP/IP interface. Terminating!");
return false;
}
// Find the channel id
uint32_t ChannelID;
m_srv.doCmdGetChannelID(&ChannelID);
// m_srv.doCmdGetGUID( m_ifguid );
// The server should hold configuration data for each sensor
// we want to monitor.
//
// We look for
//
// _interface - The socketcan interface to use. Typically this
// is “can0, can0, can1...
//
// _filter - Standard VSCP filter in string form.
// 1,0x0000,0x0006,
// ff:ff:ff:ff:ff:ff:ff:01:00:00:00:00:00:00:00:00
// as priority,class,type,GUID
// Used to filter what events that is received from
// the socketcan interface. If not give all events
// are received.
// _mask - Standard VSCP mask in string form.
// 1,0x0000,0x0006,
// ff:ff:ff:ff:ff:ff:ff:01:00:00:00:00:00:00:00:00
// as priority,class,type,GUID
// Used to filter what events that is received from
// the socketcan interface. If not give all events
// are received.
//
// <setup interface="vcan0"
// filter=""
// mask="" />
//
std::string str;
std::string strName = m_prefix + std::string("_interface");
m_srv.getRemoteVariableValue(strName, m_interface);
strName = m_prefix + std::string("_filter");
if (m_srv.getRemoteVariableValue(strName, str)) {
vscp_readFilterFromString(&m_vscpfilter, str);
}
strName = m_prefix + std::string("_mask");
if (m_srv.getRemoteVariableValue(strName, str)) {
vscp_readMaskFromString(&m_vscpfilter, str);
}
m_srv.doClrInputQueue();
// XML setup
std::string strSetupXML;
strName = m_prefix + std::string("_setup");
if (VSCP_ERROR_SUCCESS ==
m_srv.getRemoteVariableValue(strName, strSetupXML, true)) {
XML_Parser xmlParser = XML_ParserCreate("UTF-8");
XML_SetUserData(xmlParser, this);
XML_SetElementHandler(xmlParser, startSetupParser, endSetupParser);
int bytes_read;
void *buff = XML_GetBuffer(xmlParser, XML_BUFF_SIZE);
strncpy((char *)buff, strSetupXML.c_str(), strSetupXML.length());
bytes_read = strSetupXML.length();
if (!XML_ParseBuffer(xmlParser, bytes_read, bytes_read == 0)) {
syslog(LOG_ERR, "Failed parse XML setup.");
}
XML_ParserFree(xmlParser);
}
// start the workerthread
if ( pthread_create( &m_threadWork,
NULL,
workerThread,
this ) ) {
syslog( LOG_CRIT, "Unable to start worker thread." );
return false;
}
// Close the channel
m_srv.doCmdClose();
return rv;
}
/*
* Starts parsing. The XML data being parsed should be set either set as
* a buffer in OSCTXT (pctxt->buffer) or read from its stream (pctxt->pStream).
*/
int rtSaxCParse (OSXMLREADER* pReader)
{
long len;
enum XML_Status stat = XML_STATUS_OK;
struct OSRTSTREAM* pStream;
XMLReaderImpl* readerImpl = (XMLReaderImpl*)(void*)pReader;
OSCTXT* pctxt;
OSSAXHandlerBase* pSaxBase;
if (pReader == 0 || pReader->pctxt == 0 || readerImpl->parser == 0)
return RTERR_NOTINIT;
pctxt = pReader->pctxt;
pStream = pctxt->pStream;
rtxErrReset (pctxt);
pSaxBase = (OSSAXHandlerBase*)readerImpl->userData;
if (pStream == 0) {
/* stream is not set - parse just a buffer */
stat = XML_Parse (readerImpl->parser, (char*)OSRTBUFPTR(pctxt),
(int)pctxt->buffer.size, TRUE);
return (stat == XML_STATUS_ERROR) ? RTERR_XMLPARSE : 0;
}
else { /* read from stream and parse */
do {
void* pbuf;
XML_Bool isFinal;
/* get the buffer to read in */
pbuf = XML_GetBuffer (readerImpl->parser, XML_BUF_SIZE);
/* read data to the buffer */
len = rtxStreamRead (pctxt, (OSOCTET*)pbuf, XML_BUF_SIZE);
if (len < 0)
break;
isFinal = (XML_Bool)(!len);
/* parse the data in the buffer */
if ((stat = XML_ParseBuffer (readerImpl->parser, len, isFinal)) == 0)
break;
/* the following code is necessary only if it is necessary to
* decode several XML documents consequently from one stream. */
if (pSaxBase->mState == OS_SAX_FINAL_STATE) {
/* if parsing is finished, but buffer is not empty we need
* to find the beginning of the next XML message and set
* this piece of data as pre-read buffer for BufferedStream.*/
XML_ParsingStatus status;
XML_GetParsingStatus(readerImpl->parser, &status);
if (status.parsing == XML_SUSPENDED) {
int offset, lenn;
/* Get buffer pointer, offset and length of remaining data.
Note, that patching of Expat is necessary to fix two problems:
1) even if parser is stopped by XML_StopParser, it will return
error "junk after end-of-document" if buffer is not empty;
2) XML_GetInputContext worked only if macro XML_CONTEXT_BYTES
was defined. But it could work even without it. */
const char * _pbuf =
XML_GetInputContext(readerImpl->parser, &offset, &lenn);
if (offset > 0 && lenn - offset > 0) {
int stat = 0;
const OSUTF8CHAR* prereadBuf = (const OSUTF8CHAR*)_pbuf + offset;
size_t prereadBufLen = (size_t)(lenn - offset), i;
/* check, is the buffer just whitespaces or not. If yes,
discard it */
for (i = 0; i < prereadBufLen; i++) {
if (!OS_ISSPACE (prereadBuf[i])) {
if (OSRTSTREAM_ID (pctxt) != OSRTSTRMID_DIRECTBUF) {
stat = rtxStreamBufferedCreate (pctxt,
OSRTSTRMCM_RESTORE_UNDERLAYING_AFTER_RESET);
if (stat < 0) len = stat;
}
if (stat == 0) {
stat = rtxStreamBufferedSetPreReadBuf (pctxt,
(const OSOCTET*)prereadBuf + i, prereadBufLen - i);
if (stat < 0) len = stat;
}
break;
}
}
}
stat = XML_STATUS_OK;
}
break;
}
} while (len > 0);
}
if (len < 0) {
return LOG_RTERR (pctxt, len);
}
else if (stat != XML_STATUS_OK) {
XML_LChar str[256];
len = RTERR_XMLPARSE;
EXML_ErrorString (readerImpl->parser,
XML_GetErrorCode (readerImpl->parser), str,
sizeof(str)/sizeof(str[0]));
LOG_RTERRNEW (pctxt, len);
rtxErrAddStrParm (pctxt, LSTRX (pctxt, str));
return len;
}
return 0;
}
void *
threadWorker(void *pData)
{
CLogWrkThreadObj *pObj = (CLogWrkThreadObj *)pData;
if (NULL == pObj) {
syslog(LOG_CRIT,
"No thread object supplied to worker thread. Aborting!");
return NULL;
}
// Check pointers
if (NULL == pObj->m_pLog) {
syslog(LOG_CRIT,
"No valid logger object suppied to worker thread. Aborting!");
return NULL;
}
// First log on to the host and get configuration
// variables
if (VSCP_ERROR_SUCCESS ==
pObj->m_srv.doCmdOpen(pObj->m_pLog->m_host,
pObj->m_pLog->m_username,
pObj->m_pLog->m_password) <= 0) {
return NULL;
}
// Find the channel id
uint32_t ChannelID;
pObj->m_srv.doCmdGetChannelID(&ChannelID);
// It is possible that there is configuration data the server holds
// that we need to read in.
// We look for
// prefix_filter to find a filter. A string is expected.
// prefix_mask to find a mask. A string is expected.
// prefix_path to overide the file path for the log file. A string is
// expected. prefix_rewrite to override the overwrite flag. A bool is
// expected.
// Get filter data
std::string varFilter;
std::string varMask;
std::string strFilter = pObj->m_pLog->m_prefix + std::string("_filter");
std::string strMask = pObj->m_pLog->m_prefix + std::string("_mask");
if ((VSCP_ERROR_SUCCESS ==
pObj->m_srv.getRemoteVariableValue(strFilter, varFilter)) &&
(VSCP_ERROR_SUCCESS ==
pObj->m_srv.getRemoteVariableValue(strMask, varMask))) {
pObj->m_srv.doCmdFilter(varFilter, varMask);
}
// get overriden file path
std::string strPath = pObj->m_pLog->m_prefix + std::string("_path");
std::string varPath;
if (VSCP_ERROR_SUCCESS ==
pObj->m_srv.getRemoteVariableValue(strPath, varPath)) {
pObj->m_pLog->m_path = varPath;
}
std::string strRewrite = pObj->m_pLog->m_prefix + std::string("_rewrite");
bool bOverwrite;
if (VSCP_ERROR_SUCCESS ==
pObj->m_srv.getRemoteVariableBool(strRewrite, &bOverwrite)) {
if (bOverwrite) {
pObj->m_pLog->m_flags |= LOG_FILE_OVERWRITE;
} else {
pObj->m_pLog->m_flags &= ~LOG_FILE_OVERWRITE;
}
}
bool bVSCPWorksFormat;
std::string strVscpWorkdFmt =
pObj->m_pLog->m_prefix + std::string("_vscpworksfmt");
if (VSCP_ERROR_SUCCESS ==
pObj->m_srv.getRemoteVariableBool(strVscpWorkdFmt, &bVSCPWorksFormat)) {
if (bVSCPWorksFormat) {
pObj->m_pLog->m_flags |= LOG_FILE_VSCP_WORKS;
} else {
pObj->m_pLog->m_flags &= ~LOG_FILE_VSCP_WORKS;
}
}
// XML setup
std::string str;
std::string strSetupXML;
std::string strName = pObj->m_pLog->m_prefix + std::string("_setup");
if (VSCP_ERROR_SUCCESS ==
pObj->m_srv.getRemoteVariableValue(strName, strSetupXML, true)) {
XML_Parser xmlParser = XML_ParserCreate("UTF-8");
XML_SetUserData(xmlParser, pObj->m_pLog);
XML_SetElementHandler(xmlParser, startSetupParser, endSetupParser);
int bytes_read;
void *buff = XML_GetBuffer(xmlParser, XML_BUFF_SIZE);
strncpy((char *)buff, strSetupXML.c_str(), strSetupXML.length());
bytes_read = strSetupXML.length();
if (!XML_ParseBuffer(xmlParser, bytes_read, bytes_read == 0)) {
syslog(LOG_ERR, "Failed parse XML setup.");
}
XML_ParserFree(xmlParser);
}
// Close server connection
pObj->m_srv.doCmdClose();
// Open the file
if (!pObj->m_pLog->openFile()) return NULL;
while (!pObj->m_pLog->m_bQuit) {
// Wait for events
if ((-1 == vscp_sem_wait(&pObj->m_pLog->m_semSendQueue, 500)) &&
errno == ETIMEDOUT) {
continue;
}
if (pObj->m_pLog->m_sendList.size()) {
pthread_mutex_lock(&pObj->m_pLog->m_mutexSendQueue);
vscpEvent *pEvent = pObj->m_pLog->m_sendList.front();
pObj->m_pLog->m_sendList.pop_front();
pthread_mutex_unlock(&pObj->m_pLog->m_mutexSendQueue);
if (NULL == pEvent) continue;
pObj->m_pLog->writeEvent(pEvent);
vscp_deleteVSCPevent(pEvent);
pEvent = NULL;
} // Event received
} // Receive loop
// Close the channel
pObj->m_srv.doCmdClose();
return NULL;
}
//! 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;
}
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;
}
S32 LLSDXMLParser::Impl::parseLines(std::istream& input, LLSD& data)
{
XML_Status status = XML_STATUS_OK;
data = LLSD();
static const int BUFFER_SIZE = 1024;
//static char last_buffer[ BUFFER_SIZE ];
//std::streamsize last_num_read;
// Must get rid of any leading \n, otherwise the stream gets into an error/eof state
clear_eol(input);
while( !mGracefullStop
&& input.good()
&& !input.eof())
{
void* buffer = XML_GetBuffer(mParser, BUFFER_SIZE);
/*
* If we happened to end our last buffer right at the end of the llsd, but the
* stream is still going we will get a null buffer here. Check for mGracefullStop.
* -- I don't think this is actually true - zero 2008-05-09
*/
if (!buffer)
{
break;
}
// Get one line
input.getline((char*)buffer, BUFFER_SIZE);
std::streamsize num_read = input.gcount();
//memcpy( last_buffer, buffer, num_read );
//last_num_read = num_read;
if ( num_read > 0 )
{
if (!input.good() )
{ // Clear state that's set when we run out of buffer
input.clear();
}
// Re-insert with the \n that was absorbed by getline()
char * text = (char *) buffer;
if ( text[num_read - 1] == 0)
{
text[num_read - 1] = '\n';
}
}
status = XML_ParseBuffer(mParser, num_read, false);
if (status == XML_STATUS_ERROR)
{
break;
}
}
if (status != XML_STATUS_ERROR
&& !mGracefullStop)
{ // Parse last bit
status = XML_ParseBuffer(mParser, 0, true);
}
if (status == XML_STATUS_ERROR
&& !mGracefullStop)
{
llinfos << "LLSDXMLParser::Impl::parseLines: XML_STATUS_ERROR" << llendl;
return LLSDParser::PARSE_FAILURE;
}
clear_eol(input);
data = mResult;
return mParseCount;
}
struct razor_set *
razor_set_create_from_yum(void)
{
struct yum_context ctx;
void *buf;
int len, ret;
gzFile primary, filelists;
XML_ParsingStatus status;
ctx.importer = razor_importer_create();
ctx.state = YUM_STATE_BEGIN;
ctx.primary_parser = XML_ParserCreate(NULL);
XML_SetUserData(ctx.primary_parser, &ctx);
XML_SetElementHandler(ctx.primary_parser,
yum_primary_start_element,
yum_primary_end_element);
XML_SetCharacterDataHandler(ctx.primary_parser,
yum_character_data);
ctx.filelists_parser = XML_ParserCreate(NULL);
XML_SetUserData(ctx.filelists_parser, &ctx);
XML_SetElementHandler(ctx.filelists_parser,
yum_filelists_start_element,
yum_filelists_end_element);
XML_SetCharacterDataHandler(ctx.filelists_parser,
yum_character_data);
primary = gzopen("primary.xml.gz", "rb");
if (primary == NULL)
return NULL;
filelists = gzopen("filelists.xml.gz", "rb");
if (filelists == NULL)
return NULL;
ctx.current_parser = ctx.primary_parser;
ctx.current = 0;
do {
XML_GetParsingStatus(ctx.current_parser, &status);
switch (status.parsing) {
case XML_SUSPENDED:
ret = XML_ResumeParser(ctx.current_parser);
break;
case XML_PARSING:
case XML_INITIALIZED:
buf = XML_GetBuffer(ctx.current_parser,
XML_BUFFER_SIZE);
if (ctx.current_parser == ctx.primary_parser)
len = gzread(primary, buf, XML_BUFFER_SIZE);
else
len = gzread(filelists, buf, XML_BUFFER_SIZE);
if (len < 0) {
fprintf(stderr,
"couldn't read input: %s\n",
strerror(errno));
return NULL;
}
XML_ParseBuffer(ctx.current_parser, len, len == 0);
break;
case XML_FINISHED:
break;
}
} while (status.parsing != XML_FINISHED);
XML_ParserFree(ctx.primary_parser);
XML_ParserFree(ctx.filelists_parser);
gzclose(primary);
gzclose(filelists);
printf ("\nsaving\n");
return razor_importer_finish(ctx.importer);
}
void read_maxgroups(char *pPath) {
int i;
AppData *ad;
int f;
XML_Parser p = XML_ParserCreateNS(NULL, '|');
if (!p) {
fprintf(stderr, "Couldn't allocate memory for parser!\n");
exit(1);
}
ad = newAppData();
// null them out
for (i = 0; i < 1000; i++) {
maxgroup[i] = -1; // no way a 2 digit group # will match that
}
// parse the SSN.xml we've been passed and populate the maxgroup
// array
XML_SetUserData(p, (void *) ad);
XML_SetElementHandler(p, start, end);
XML_SetNamespaceDeclHandler(p, ns_start, ns_end);
f = open(pPath, O_RDONLY);
if (f < 0) {
fprintf(stderr, "can't open %s: %s\n", pPath,
strerror(errno));
exit(1);
}
for (;;) {
char *buff;
int len;
buff = XML_GetBuffer(p, CHUNK_SIZE);
if (! buff) {
fprintf(stderr, "parse buffer\n");
exit(1);
}
len = read(f, buff, CHUNK_SIZE);
if (len < 0) {
fprintf(stderr, "XML read error\n");
exit(1);
}
if (! XML_ParseBuffer(p, len, len == 0)) {
fprintf(stderr, "Parse error at line %d:\n%s\n",
XML_GetCurrentLineNumber(p),
XML_ErrorString(XML_GetErrorCode(p)));
exit(1);
}
if (len == 0) {
break;
}
}
return;
}
CP_C_API cp_plugin_info_t * cp_load_plugin_descriptor(cp_context_t *context, const char *path, cp_status_t *error) {
char *file = NULL;
cp_status_t status = CP_OK;
FILE *fh = NULL;
XML_Parser parser = NULL;
ploader_context_t *plcontext = NULL;
cp_plugin_info_t *plugin = NULL;
CHECK_NOT_NULL(context);
CHECK_NOT_NULL(path);
cpi_lock_context(context);
cpi_check_invocation(context, CPI_CF_ANY, __func__);
do {
int path_len;
// Construct the file name for the plug-in descriptor
path_len = strlen(path);
if (path_len == 0) {
status = CP_ERR_IO;
break;
}
if (path[path_len - 1] == CP_FNAMESEP_CHAR) {
path_len--;
}
file = malloc((path_len + strlen(CP_PLUGIN_DESCRIPTOR) + 2) * sizeof(char));
if (file == NULL) {
status = CP_ERR_RESOURCE;
break;
}
strcpy(file, path);
file[path_len] = CP_FNAMESEP_CHAR;
strcpy(file + path_len + 1, CP_PLUGIN_DESCRIPTOR);
// Open the file
if ((fh = fopen(file, "rb")) == NULL) {
status = CP_ERR_IO;
break;
}
// Initialize the XML parsing
parser = XML_ParserCreate(NULL);
if (parser == NULL) {
status = CP_ERR_RESOURCE;
break;
}
XML_SetElementHandler(parser,
start_element_handler,
end_element_handler);
// Initialize the parsing context
if ((plcontext = malloc(sizeof(ploader_context_t))) == NULL) {
status = CP_ERR_RESOURCE;
break;
}
memset(plcontext, 0, sizeof(ploader_context_t));
if ((plcontext->plugin = malloc(sizeof(cp_plugin_info_t))) == NULL) {
status = CP_ERR_RESOURCE;
break;
}
plcontext->context = context;
plcontext->configuration = NULL;
plcontext->value = NULL;
plcontext->parser = parser;
plcontext->file = file;
plcontext->state = PARSER_BEGIN;
memset(plcontext->plugin, 0, sizeof(cp_plugin_info_t));
plcontext->plugin->name = NULL;
plcontext->plugin->identifier = NULL;
plcontext->plugin->version = NULL;
plcontext->plugin->provider_name = NULL;
plcontext->plugin->abi_bw_compatibility = NULL;
plcontext->plugin->api_bw_compatibility = NULL;
plcontext->plugin->plugin_path = NULL;
plcontext->plugin->req_cpluff_version = NULL;
plcontext->plugin->imports = NULL;
plcontext->plugin->runtime_lib_name = NULL;
plcontext->plugin->runtime_funcs_symbol = NULL;
plcontext->plugin->ext_points = NULL;
plcontext->plugin->extensions = NULL;
plcontext->plugin->url = NULL;
plcontext->plugin->resourcetype = NULL;
XML_SetUserData(parser, plcontext);
// Parse the plug-in descriptor
while (1) {
int bytes_read;
void *xml_buffer;
int i;
// Get buffer from Expat
if ((xml_buffer = XML_GetBuffer(parser, CP_XML_PARSER_BUFFER_SIZE))
== NULL) {
status = CP_ERR_RESOURCE;
break;
}
// Read data into buffer
bytes_read = fread(xml_buffer, 1, CP_XML_PARSER_BUFFER_SIZE, fh);
if (ferror(fh)) {
status = CP_ERR_IO;
break;
}
// Parse the data
if (!(i = XML_ParseBuffer(parser, bytes_read, bytes_read == 0))
&& context != NULL) {
cpi_lock_context(context);
cpi_errorf(context,
N_("XML parsing error in %s, line %d, column %d (%s)."),
file,
XML_GetErrorLineNumber(parser),
XML_GetErrorColumnNumber(parser) + 1,
XML_ErrorString(XML_GetErrorCode(parser)));
cpi_unlock_context(context);
}
if (!i || plcontext->state == PARSER_ERROR) {
status = CP_ERR_MALFORMED;
break;
}
if (bytes_read == 0) {
break;
}
}
if (status == CP_OK) {
if (plcontext->state != PARSER_END || plcontext->error_count > 0) {
status = CP_ERR_MALFORMED;
}
if (plcontext->resource_error_count > 0) {
status = CP_ERR_RESOURCE;
}
}
if (status != CP_OK) {
break;
}
// Initialize the plug-in path
*(file + path_len) = '\0';
plcontext->plugin->plugin_path = file;
file = NULL;
// Increase plug-in usage count
if ((status = cpi_register_info(context, plcontext->plugin, (void (*)(cp_context_t *, void *)) dealloc_plugin_info)) != CP_OK) {
break;
}
} while (0);
// Report possible errors
if (status != CP_OK) {
switch (status) {
case CP_ERR_MALFORMED:
cpi_errorf(context,
N_("Plug-in descriptor in %s is invalid."), path);
break;
case CP_ERR_IO:
cpi_errorf(context,
N_("An I/O error occurred while loading a plug-in descriptor from %s."), path);
break;
case CP_ERR_RESOURCE:
cpi_errorf(context,
N_("Insufficient system resources to load a plug-in descriptor from %s."), path);
break;
default:
cpi_errorf(context,
N_("Failed to load a plug-in descriptor from %s."), path);
break;
}
}
cpi_unlock_context(context);
// Release persistently allocated data on failure
if (status != CP_OK) {
if (file != NULL) {
free(file);
file = NULL;
}
if (plcontext != NULL && plcontext->plugin != NULL) {
cpi_free_plugin(plcontext->plugin);
plcontext->plugin = NULL;
}
}
// Otherwise copy the plug-in pointer
else {
plugin = plcontext->plugin;
}
// Release data allocated for parsing
if (parser != NULL) {
XML_ParserFree(parser);
}
if (fh != NULL) {
fclose(fh);
}
if (plcontext != NULL) {
if (plcontext->value != NULL) {
free(plcontext->value);
}
free(plcontext);
plcontext = NULL;
}
// Return error code
if (error != NULL) {
*error = status;
}
return plugin;
}
