void
_gtk_builder_parser_parse_buffer (GtkBuilder *builder,
const gchar *filename,
const gchar *buffer,
gsize length,
gchar **requested_objs,
GError **error)
{
const gchar* domain;
ParserData *data;
GSList *l;
/* Store the original domain so that interface domain attribute can be
* applied for the builder and the original domain can be restored after
* parsing has finished. This allows subparsers to translate elements with
* gtk_builder_get_translation_domain() without breaking the ABI or API
*/
domain = gtk_builder_get_translation_domain (builder);
data = g_new0 (ParserData, 1);
data->builder = builder;
data->filename = filename;
data->domain = g_strdup (domain);
data->object_ids = g_hash_table_new_full (g_str_hash, g_str_equal,
(GDestroyNotify)g_free, NULL);
data->requested_objects = NULL;
if (requested_objs)
{
gint i;
data->inside_requested_object = FALSE;
for (i = 0; requested_objs[i]; ++i)
{
data->requested_objects = g_slist_prepend (data->requested_objects,
g_strdup (requested_objs[i]));
}
}
else
{
/* get all the objects */
data->inside_requested_object = TRUE;
}
data->ctx = g_markup_parse_context_new (&parser,
G_MARKUP_TREAT_CDATA_AS_TEXT,
data, NULL);
if (!g_markup_parse_context_parse (data->ctx, buffer, length, error))
goto out;
_gtk_builder_finish (builder);
/* Custom parser_finished */
data->custom_finalizers = g_slist_reverse (data->custom_finalizers);
for (l = data->custom_finalizers; l; l = l->next)
{
SubParser *sub = (SubParser*)l->data;
gtk_buildable_custom_finished (GTK_BUILDABLE (sub->object),
builder,
sub->child,
sub->tagname,
sub->data);
}
/* Common parser_finished, for all created objects */
data->finalizers = g_slist_reverse (data->finalizers);
for (l = data->finalizers; l; l = l->next)
{
GtkBuildable *buildable = (GtkBuildable*)l->data;
gtk_buildable_parser_finished (GTK_BUILDABLE (buildable), builder);
}
out:
g_slist_foreach (data->stack, (GFunc)free_info, NULL);
g_slist_free (data->stack);
g_slist_foreach (data->custom_finalizers, (GFunc)free_subparser, NULL);
g_slist_free (data->custom_finalizers);
g_slist_free (data->finalizers);
g_slist_foreach (data->requested_objects, (GFunc) g_free, NULL);
g_slist_free (data->requested_objects);
g_free (data->domain);
g_hash_table_destroy (data->object_ids);
g_markup_parse_context_free (data->ctx);
g_free (data);
/* restore the original domain */
gtk_builder_set_translation_domain (builder, domain);
}
G_MODULE_EXPORT gboolean
tracker_extract_get_metadata (TrackerExtractInfo *extract_info)
{
TrackerResource *metadata;
TrackerConfig *config;
ODTMetadataParseInfo info = { 0 };
ODTFileType file_type;
GFile *file;
gchar *uri;
const gchar *mime_used;
GMarkupParseContext *context;
GMarkupParser parser = {
xml_start_element_handler_metadata,
xml_end_element_handler_metadata,
xml_text_handler_metadata,
NULL,
NULL
};
if (G_UNLIKELY (maximum_size_error_quark == 0)) {
maximum_size_error_quark = g_quark_from_static_string ("maximum_size_error");
}
metadata = tracker_resource_new (NULL);
mime_used = tracker_extract_info_get_mimetype (extract_info);
file = tracker_extract_info_get_file (extract_info);
uri = g_file_get_uri (file);
/* Setup conf */
config = tracker_main_get_config ();
g_debug ("Extracting OASIS metadata and contents from '%s'", uri);
/* First, parse metadata */
tracker_resource_add_uri (metadata, "rdf:type", "nfo:PaginatedTextDocument");
/* Create parse info */
info.metadata = metadata;
info.current = ODT_TAG_TYPE_UNKNOWN;
info.uri = uri;
/* Create parsing context */
context = g_markup_parse_context_new (&parser, 0, &info, NULL);
/* Load the internal XML file from the Zip archive, and parse it
* using the given context */
tracker_gsf_parse_xml_in_zip (uri, "meta.xml", context, NULL);
g_markup_parse_context_free (context);
if (g_ascii_strcasecmp (mime_used, "application/vnd.oasis.opendocument.text") == 0) {
file_type = FILE_TYPE_ODT;
} else if (g_ascii_strcasecmp (mime_used, "application/vnd.oasis.opendocument.presentation") == 0) {
file_type = FILE_TYPE_ODP;
} else if (g_ascii_strcasecmp (mime_used, "application/vnd.oasis.opendocument.spreadsheet") == 0) {
file_type = FILE_TYPE_ODS;
} else if (g_ascii_strcasecmp (mime_used, "application/vnd.oasis.opendocument.graphics") == 0) {
file_type = FILE_TYPE_ODG;
} else {
g_message ("Mime type was not recognised:'%s'", mime_used);
file_type = FILE_TYPE_INVALID;
}
/* Extract content with the given limitations */
extract_oasis_content (uri,
tracker_config_get_max_bytes (config),
file_type,
metadata);
g_free (uri);
tracker_extract_info_set_resource (extract_info, metadata);
g_object_unref (metadata);
return TRUE;
}
void dt_styles_import_from_file(const char *style_path)
{
FILE *style_file;
StyleData *style;
GMarkupParseContext *parser;
gchar buf[1024];
size_t num_read;
style = dt_styles_style_data_new();
parser = g_markup_parse_context_new(&dt_style_parser, 0, style, NULL);
if((style_file = fopen(style_path, "r")))
{
while(!feof(style_file))
{
num_read = fread(buf, sizeof(gchar), sizeof(buf), style_file);
if(num_read == 0)
{
break;
}
else if(num_read == -1)
{
// FIXME: ferror?
// ERROR !
break;
}
if(!g_markup_parse_context_parse(parser, buf, num_read, NULL))
{
g_markup_parse_context_free(parser);
dt_styles_style_data_free(style, TRUE);
fclose(style_file);
return;
}
}
}
else
{
// Failed to open file, clean up.
g_markup_parse_context_free(parser);
dt_styles_style_data_free(style, TRUE);
return;
}
if(!g_markup_parse_context_end_parse(parser, NULL))
{
g_markup_parse_context_free(parser);
dt_styles_style_data_free(style, TRUE);
fclose(style_file);
return;
}
g_markup_parse_context_free(parser);
// save data
dt_style_save(style);
//
dt_styles_style_data_free(style, TRUE);
fclose(style_file);
}
void stor_parse(char *fname, const char *text, size_t len)
{
GMarkupParseContext* parser;
struct config_context ctx;
memset(&ctx, 0, sizeof(struct config_context));
ctx.fname = fname;
parser = g_markup_parse_context_new(&cfg_parse_ops, 0, &ctx, NULL);
if (!parser) {
applog(LOG_ERR, "g_markup_parse_context_new failed");
return;
}
if (!g_markup_parse_context_parse(parser, text, len, NULL)) {
applog(LOG_ERR, "Parse failure for Chunk in %s", fname);
g_markup_parse_context_free(parser);
goto out_free_all;
}
g_markup_parse_context_free(parser);
switch (ctx.stor_type) {
case CFG_TYPE_FS:
if (!stor_verify_fs(fname, &ctx))
goto out_free_all;
stor_add_node(ctx.nid, STT_POSIX, ctx.stor_base,
NULL, NULL, &ctx.loc);
break;
case CFG_TYPE_SWIFT: /* same as chunk for now */
if (!stor_verify_chunk(fname, &ctx))
goto out_free_all;
stor_add_node(ctx.nid, STT_SWIFT, NULL,
ctx.stor_ok_host, ctx.stor_ok_port, &ctx.loc);
break;
case CFG_TYPE_UNKNOWN:
if (debugging)
applog(LOG_DEBUG, "%s: Unknown storage type", fname);
break;
case CFG_TYPE_CHUNK:
default:
if (!stor_verify_chunk(fname, &ctx))
goto out_free_all;
stor_add_node(ctx.nid, STT_CHUNK, NULL,
ctx.stor_ok_host, ctx.stor_ok_port, &ctx.loc);
}
out_free_all:
free(ctx.text);
free(ctx.stor_host);
free(ctx.stor_port);
free(ctx.stor_ok_host);
free(ctx.stor_ok_port);
free(ctx.loc.area);
free(ctx.loc.zone);
free(ctx.loc.rack);
free(ctx.stor_base);
return;
}
static void on_get_http_response(char *buffer, size_t buffer_len, gpointer userdata)
{
if (!buffer)
return;
const char *p = g_strstr_len(buffer, buffer_len, "\r\n\r\n");
if (!p) {
return;
}
p += 4;
if(g_str_has_prefix(p, UTF8_BOM))
p += (sizeof(UTF8_BOM)-1); // better than strlen(UTF8_BOM);
updateinfo_ParseUserData Data;
Data.latest_version_num = 0;
const gchar* const *languages = g_get_language_names();
const char *locale = languages[0];
if (locale && locale[0] != '\0') {
const char *p = strchr(locale, '.');
if (p) {
Data.locale_name.assign(locale, p - locale);
} else {
Data.locale_name = locale;
}
}
GMarkupParser parser;
parser.start_element = NULL;
parser.end_element = NULL;
parser.text = updateinfo_parse_text;
parser.passthrough = NULL;
parser.error = NULL;
GMarkupParseContext* context = g_markup_parse_context_new(&parser, (GMarkupParseFlags)0, &Data, NULL);
g_markup_parse_context_parse(context, p, buffer_len - (p - buffer), NULL);
g_markup_parse_context_end_parse(context, NULL);
g_markup_parse_context_free(context);
bool updated = false;
if (Data.latest_version_num != latest_version_num) {
updated = true;
latest_version_num = Data.latest_version_num;
version_msg_title = Data.version_msg_title;
version_msg_content = Data.version_msg_content;
}
if (Data.latest_version_num > my_version_num && Data.latest_version_num != last_prompt_num) {
std::string content = version_msg_content;
content += "\n\n";
content += _("Visit StarDict website now?");
GtkWidget *dialog = gtk_message_dialog_new(GTK_WINDOW(plugin_info->mainwin), GTK_DIALOG_MODAL, GTK_MESSAGE_INFO, GTK_BUTTONS_YES_NO, "%s", content.c_str());
GtkWidget *prompt = gtk_check_button_new_with_mnemonic(_("_Don't show this until the next update."));
gtk_widget_show(prompt);
gtk_container_add (GTK_CONTAINER (gtk_dialog_get_content_area(GTK_DIALOG(dialog))), prompt);
gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_YES);
gtk_window_set_title (GTK_WINDOW (dialog), version_msg_title.c_str());
if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_YES) {
plugin_service->show_url("http://www.stardict.org");
}
if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(prompt))) {
updated = true;
last_prompt_num = Data.latest_version_num;
}
gtk_widget_destroy (dialog);
}
if (Data.latest_news != latest_news) {
updated = true;
latest_news = Data.latest_news;
}
if (updated) {
GKeyFile *keyfile = g_key_file_new();
g_key_file_set_string(keyfile, "update", "version_msg_title", version_msg_title.c_str());
g_key_file_set_string(keyfile, "update", "version_msg_content", version_msg_content.c_str());
g_key_file_set_string(keyfile, "update", "latest_news", latest_news.c_str());
g_key_file_set_integer(keyfile, "update", "latest_version_num", latest_version_num);
g_key_file_set_integer(keyfile, "update", "last_prompt_num", last_prompt_num);
g_key_file_set_boolean(keyfile, "misc", "show_ads", show_ads);
gsize length;
gchar *content = g_key_file_to_data(keyfile, &length, NULL);
std::string res = get_cfg_filename();
g_file_set_contents(res.c_str(), content, length, NULL);
g_free(content);
}
if (show_ads) {
plugin_service->set_news(latest_news.c_str(), Data.links.c_str());
}
}
gboolean
purple_prefs_load()
{
gchar *filename = g_build_filename(purple_user_dir(), "prefs.xml", NULL);
gchar *contents = NULL;
gsize length;
GMarkupParseContext *context;
GError *error = NULL;
if (!filename) {
prefs_loaded = TRUE;
return FALSE;
}
purple_debug_info("prefs", "Reading %s\n", filename);
if(!g_file_get_contents(filename, &contents, &length, &error)) {
#ifdef _WIN32
gchar *common_appdata = wpurple_get_special_folder(CSIDL_COMMON_APPDATA);
#endif
g_free(filename);
g_error_free(error);
error = NULL;
/* BEGIN SPICEBIRD CHANGES */
filename = g_build_filename(g_getenv("MOZILLA_FIVE_HOME"),
"purple", "prefs.xml", NULL);
#if 0
#ifdef _WIN32
filename = g_build_filename(common_appdata ? common_appdata : "", "purple", "prefs.xml", NULL);
g_free(common_appdata);
#else
filename = g_build_filename(SYSCONFDIR, "purple", "prefs.xml", NULL);
#endif
#endif
/* END SPICEBIRD CHANGES */
purple_debug_info("prefs", "Reading %s\n", filename);
if (!g_file_get_contents(filename, &contents, &length, &error)) {
purple_debug_error("prefs", "Error reading prefs: %s\n",
error->message);
g_error_free(error);
g_free(filename);
prefs_loaded = TRUE;
return FALSE;
}
}
context = g_markup_parse_context_new(&prefs_parser, 0, NULL, NULL);
if(!g_markup_parse_context_parse(context, contents, length, NULL)) {
g_markup_parse_context_free(context);
g_free(contents);
g_free(filename);
prefs_loaded = TRUE;
return FALSE;
}
if(!g_markup_parse_context_end_parse(context, NULL)) {
purple_debug_error("prefs", "Error parsing %s\n", filename);
g_markup_parse_context_free(context);
g_free(contents);
g_free(filename);
prefs_loaded = TRUE;
return FALSE;
}
purple_debug_info("prefs", "Finished reading %s\n", filename);
g_markup_parse_context_free(context);
g_free(contents);
g_free(filename);
prefs_loaded = TRUE;
return TRUE;
}
/**
* shell_mobile_providers_parse:
* @country_codes: (allow-none) File with the list of country codes.
* @service_providers: (allow-none) File with the list of service providers.
*
* Returns: (element-type utf8 Shell.CountryMobileProvider) (transfer full): a
* hash table where keys are country names #gchar and values are #ShellCountryMobileProvider.
* Everything is destroyed with g_hash_table_destroy().
*/
GHashTable *
shell_mobile_providers_parse (const gchar *country_codes,
const gchar *service_providers)
{
GMarkupParseContext *ctx;
GIOChannel *channel;
MobileParser parser;
GError *error = NULL;
char buffer[4096];
GIOStatus status;
gsize len = 0;
/* Use default paths if none given */
if (!country_codes)
country_codes = ISO_3166_COUNTRY_CODES;
if (!service_providers)
service_providers = MOBILE_BROADBAND_PROVIDER_INFO;
memset (&parser, 0, sizeof (MobileParser));
parser.table = read_country_codes (country_codes);
if (!parser.table)
goto out;
channel = g_io_channel_new_file (service_providers, "r", &error);
if (!channel) {
if (error) {
g_warning ("Could not read %s: %s", service_providers, error->message);
g_error_free (error);
} else
g_warning ("Could not read %s: Unknown error", service_providers);
goto out;
}
parser.state = PARSER_TOPLEVEL;
ctx = g_markup_parse_context_new (&mobile_parser, 0, &parser, NULL);
status = G_IO_STATUS_NORMAL;
while (status == G_IO_STATUS_NORMAL) {
status = g_io_channel_read_chars (channel, buffer, sizeof (buffer), &len, &error);
switch (status) {
case G_IO_STATUS_NORMAL:
if (!g_markup_parse_context_parse (ctx, buffer, len, &error)) {
status = G_IO_STATUS_ERROR;
g_warning ("Error while parsing XML: %s", error->message);
g_error_free (error);;
}
break;
case G_IO_STATUS_EOF:
break;
case G_IO_STATUS_ERROR:
g_warning ("Error while reading: %s", error->message);
g_error_free (error);
break;
case G_IO_STATUS_AGAIN:
/* FIXME: Try again a few times, but really, it never happes, right? */
break;
}
}
g_io_channel_unref (channel);
g_markup_parse_context_free (ctx);
if (parser.current_provider) {
g_warning ("pending current provider");
shell_mobile_provider_unref (parser.current_provider);
}
if (parser.current_providers) {
g_warning ("pending current providers");
provider_list_free (parser.current_providers);
}
g_free (parser.current_country);
g_free (parser.text_buffer);
out:
return parser.table;
}
static void
migrate_history ()
{
GFileInputStream *input;
GMarkupParseContext *context;
GError *error = NULL;
GFile *file;
char *filename;
char buffer[1024];
HistoryParseData parse_data;
gchar *temporary_file = g_build_filename (ephy_dot_dir (), "ephy-history.db", NULL);
/* Do nothing if the history file already exists. Safer than wiping
* it out. */
if (g_file_test (temporary_file, G_FILE_TEST_EXISTS)) {
g_warning ("Did not migrate Epiphany's history, the ephy-history.db file already exists");
g_free (temporary_file);
return;
}
history_service = ephy_history_service_new (temporary_file);
g_free (temporary_file);
memset (&parse_data, 0, sizeof (HistoryParseData));
parse_data.location = NULL;
parse_data.title = NULL;
parse_data.visits = NULL;
filename = g_build_filename (ephy_dot_dir (),
"ephy-history.xml",
NULL);
file = g_file_new_for_path (filename);
g_free (filename);
input = g_file_read (file, NULL, &error);
g_object_unref (file);
if (error) {
if (error->code != G_IO_ERROR_NOT_FOUND)
g_warning ("Could not load Epiphany history data, migration aborted: %s", error->message);
g_error_free (error);
return;
}
context = g_markup_parse_context_new (&history_parse_funcs, 0, &parse_data, NULL);
while (TRUE) {
gssize count = g_input_stream_read (G_INPUT_STREAM (input), buffer, sizeof (buffer), NULL, &error);
if (count <= 0)
break;
if (!g_markup_parse_context_parse (context, buffer, count, &error))
break;
}
g_markup_parse_context_free (context);
g_input_stream_close (G_INPUT_STREAM (input), NULL, NULL);
g_object_unref (input);
if (parse_data.visits) {
ephy_history_service_add_visits (history_service, parse_data.visits, NULL, (EphyHistoryJobCallback)visit_cb, NULL);
ephy_history_page_visit_list_free (parse_data.visits);
while (!all_done)
g_main_context_iteration (NULL, FALSE);
}
g_object_unref (history_service);
}
gboolean
gaim_pounces_load(void)
{
gchar *filename = g_build_filename(gaim_user_dir(), "pounces.xml", NULL);
gchar *contents = NULL;
gsize length;
GMarkupParseContext *context;
GError *error = NULL;
PounceParserData *parser_data;
if (filename == NULL) {
pounces_loaded = TRUE;
return FALSE;
}
if (!g_file_get_contents(filename, &contents, &length, &error)) {
gaim_debug(GAIM_DEBUG_ERROR, "pounces",
"Error reading pounces: %s\n", error->message);
g_free(filename);
g_error_free(error);
pounces_loaded = TRUE;
return FALSE;
}
parser_data = g_new0(PounceParserData, 1);
context = g_markup_parse_context_new(&pounces_parser, 0,
parser_data, free_parser_data);
if (!g_markup_parse_context_parse(context, contents, length, NULL)) {
g_markup_parse_context_free(context);
g_free(contents);
g_free(filename);
pounces_loaded = TRUE;
return FALSE;
}
if (!g_markup_parse_context_end_parse(context, NULL)) {
gaim_debug(GAIM_DEBUG_ERROR, "pounces", "Error parsing %s\n",
filename);
g_markup_parse_context_free(context);
g_free(contents);
g_free(filename);
pounces_loaded = TRUE;
return FALSE;
}
g_markup_parse_context_free(context);
g_free(contents);
g_free(filename);
pounces_loaded = TRUE;
return TRUE;
}
static storage_status_t xml_load_real( irc_t *irc, const char *my_nick, const char *password, xml_pass_st action )
{
GMarkupParseContext *ctx;
struct xml_parsedata *xd;
char *fn, buf[512];
GError *gerr = NULL;
int fd, st;
xd = g_new0( struct xml_parsedata, 1 );
xd->irc = irc;
xd->given_nick = g_strdup( my_nick );
xd->given_pass = g_strdup( password );
xd->pass_st = action;
nick_lc( xd->given_nick );
fn = g_strdup_printf( "%s%s%s", global.conf->configdir, xd->given_nick, ".xml" );
if( ( fd = open( fn, O_RDONLY ) ) < 0 )
{
xml_destroy_xd( xd );
g_free( fn );
return STORAGE_NO_SUCH_USER;
}
g_free( fn );
ctx = g_markup_parse_context_new( &xml_parser, 0, xd, xml_destroy_xd );
while( ( st = read( fd, buf, sizeof( buf ) ) ) > 0 )
{
if( !g_markup_parse_context_parse( ctx, buf, st, &gerr ) || gerr )
{
xml_pass_st pass_st = xd->pass_st;
g_markup_parse_context_free( ctx );
close( fd );
if( pass_st == XML_PASS_WRONG )
{
g_clear_error( &gerr );
return STORAGE_INVALID_PASSWORD;
}
else
{
if( gerr && irc )
irc_usermsg( irc, "Error from XML-parser: %s", gerr->message );
g_clear_error( &gerr );
return STORAGE_OTHER_ERROR;
}
}
}
/* Just to be sure... */
g_clear_error( &gerr );
g_markup_parse_context_free( ctx );
close( fd );
if( action == XML_PASS_CHECK_ONLY )
return STORAGE_OK;
return STORAGE_OK;
}
static gboolean
read_service_providers (GHashTable *countries,
const gchar *service_providers,
GCancellable *cancellable,
GError **error)
{
GMarkupParseContext *ctx;
GIOChannel *channel;
MobileParser parser;
char buffer[4096];
GIOStatus status;
gsize len = 0;
memset (&parser, 0, sizeof (MobileParser));
parser.table = countries;
channel = g_io_channel_new_file (service_providers, "r", error);
if (!channel) {
g_prefix_error (error,
"Could not read '%s': ",
service_providers);
return FALSE;
}
parser.state = PARSER_TOPLEVEL;
ctx = g_markup_parse_context_new (&mobile_parser, 0, &parser, NULL);
status = G_IO_STATUS_NORMAL;
while (status == G_IO_STATUS_NORMAL) {
status = g_io_channel_read_chars (channel, buffer, sizeof (buffer), &len, error);
switch (status) {
case G_IO_STATUS_NORMAL:
if (!g_markup_parse_context_parse (ctx, buffer, len, error)) {
status = G_IO_STATUS_ERROR;
g_prefix_error (error,
"Error while parsing XML at '%s': ",
service_providers);
}
break;
case G_IO_STATUS_EOF:
break;
case G_IO_STATUS_ERROR:
g_prefix_error (error,
"Error while reading '%s': ",
service_providers);
break;
case G_IO_STATUS_AGAIN:
/* FIXME: Try again a few times, but really, it never happens, right? */
break;
}
if (g_cancellable_set_error_if_cancelled (cancellable, error))
status = G_IO_STATUS_ERROR;
}
g_io_channel_unref (channel);
g_markup_parse_context_free (ctx);
if (parser.current_provider) {
g_warning ("pending current provider");
nma_mobile_provider_unref (parser.current_provider);
}
if (parser.current_providers) {
g_warning ("pending current providers");
provider_list_free (parser.current_providers);
}
g_free (parser.current_country);
g_free (parser.text_buffer);
return (status == G_IO_STATUS_EOF);
}
/**
* shell_mobile_providers_parse:
* @out_ccs: (out) (allow-none): (element-type utf8 utf8): a #GHashTable containing
* country codes
*
* Returns: (element-type utf8 GList) (transfer container): a
* hash table where keys are country names #gchar, values are a #GSList
* of #ShellMobileProvider. Everything is destroyed with g_hash_table_destroy().
*/
GHashTable *
shell_mobile_providers_parse (GHashTable **out_ccs)
{
GMarkupParseContext *ctx;
GIOChannel *channel;
MobileParser parser;
GError *error = NULL;
char buffer[4096];
GIOStatus status;
gsize len = 0;
memset (&parser, 0, sizeof (MobileParser));
parser.country_codes = read_country_codes ();
if (!parser.country_codes)
goto out;
channel = g_io_channel_new_file (MOBILE_BROADBAND_PROVIDER_INFO, "r", &error);
if (!channel) {
if (error) {
g_warning ("Could not read " MOBILE_BROADBAND_PROVIDER_INFO ": %s", error->message);
g_error_free (error);
} else
g_warning ("Could not read " MOBILE_BROADBAND_PROVIDER_INFO ": Unknown error");
goto out;
}
parser.table = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, provider_list_free);
parser.state = PARSER_TOPLEVEL;
ctx = g_markup_parse_context_new (&mobile_parser, 0, &parser, NULL);
status = G_IO_STATUS_NORMAL;
while (status == G_IO_STATUS_NORMAL) {
status = g_io_channel_read_chars (channel, buffer, sizeof (buffer), &len, &error);
switch (status) {
case G_IO_STATUS_NORMAL:
if (!g_markup_parse_context_parse (ctx, buffer, len, &error)) {
status = G_IO_STATUS_ERROR;
g_warning ("Error while parsing XML: %s", error->message);
g_error_free (error);;
}
break;
case G_IO_STATUS_EOF:
break;
case G_IO_STATUS_ERROR:
g_warning ("Error while reading: %s", error->message);
g_error_free (error);
break;
case G_IO_STATUS_AGAIN:
/* FIXME: Try again a few times, but really, it never happes, right? */
break;
}
}
g_io_channel_unref (channel);
g_markup_parse_context_free (ctx);
if (parser.current_provider) {
g_warning ("pending current provider");
shell_mobile_provider_unref (parser.current_provider);
}
if (parser.current_providers) {
g_warning ("pending current providers");
provider_list_free (parser.current_providers);
}
g_free (parser.current_country);
g_free (parser.text_buffer);
out:
if (parser.country_codes) {
if (out_ccs)
*out_ccs = parser.country_codes;
else
g_hash_table_destroy (parser.country_codes);
}
return parser.table;
}
static void wordnet2result(const char *p, size_t sec_size, ParseResult &result, const char *oword)
{
WnUserData Data;
Data.oword = oword;
GMarkupParser parser;
parser.start_element = NULL;
parser.end_element = NULL;
parser.text = func_parse_text;
parser.passthrough = NULL;
parser.error = NULL;
GMarkupParseContext* context = g_markup_parse_context_new(&parser, (GMarkupParseFlags)0, &Data, NULL);
g_markup_parse_context_parse(context, p, sec_size, NULL);
g_markup_parse_context_end_parse(context, NULL);
g_markup_parse_context_free(context);
LinksPosList links_list;
std::string res;
std::string::size_type cur_pos = 0;
char *eword;
if (Data.type == "n") {
res += "Noun\n";
cur_pos += sizeof("Noun\n")-1;
} else if (Data.type == "v") {
res += "Verb\n";
cur_pos += sizeof("Verb\n")-1;
} else if (Data.type == "a") {
res += "Adjective\n";
cur_pos += sizeof("Adjective\n")-1;
} else if (Data.type == "s") {
res += "Adjective satellite\n";
cur_pos += sizeof("Adjective satellite\n")-1;
} else if (Data.type == "r") {
res += "Adverb\n";
cur_pos += sizeof("Adverb\n")-1;
} else {
eword = g_markup_escape_text(Data.type.c_str(), Data.type.length());
res += eword;
g_free(eword);
cur_pos += g_utf8_strlen(Data.type.c_str(), Data.type.length());
}
size_t utf8_len;
for (std::list<std::string>::iterator i = Data.wordlist.begin(); i != Data.wordlist.end(); ++i) {
if (i != Data.wordlist.begin()) {
res += '\t';
cur_pos++;
}
res += "<span foreground=\"blue\" underline=\"single\">";
utf8_len = g_utf8_strlen(i->c_str(), i->length());
std::string link;
link = "query://";
link += *i;
links_list.push_back(LinkDesc(cur_pos, utf8_len, link));
eword = g_markup_escape_text(i->c_str(), i->length());
res += eword;
g_free(eword);
res += "</span>";
cur_pos += utf8_len;
}
if (!Data.wordlist.empty()) {
res += '\n';
//cur_pos++;
}
eword = g_markup_escape_text(Data.gloss.c_str(), Data.gloss.length());
res += eword;
g_free(eword);
//cur_pos += g_utf8_strlen(Data.gloss.c_str(), Data.gloss.length());
ParseResultItem item;
item.type = ParseResultItemType_link;
item.link = new ParseResultLinkItem;
item.link->pango = res;
item.link->links_list = links_list;
result.item_list.push_back(item);
}
static void on_get_http_response(char *buffer, size_t buffer_len, gpointer userdata)
{
if (!buffer) {
return;
}
const char *p = g_strstr_len(buffer, buffer_len, "\r\n\r\n");
if (!p) {
return;
}
p += 4;
QueryInfo *qi = (QueryInfo *)userdata;
NetDictResponse *resp = new NetDictResponse;
resp->bookname = _("Dict.cn");
resp->booklink = "http://www.dict.cn";
resp->word = qi->word; // So neen't free qi->word;
if (use_html_or_xml) {
std::string charset;
char *p3 = g_strstr_len(p, buffer_len - (p - buffer), "charset=");
if (p3) {
p3 += sizeof("charset=") -1;
char *p4 = strchr(p3, '\"');
if (p4) {
charset.assign(p3, p4-p3);
}
}
gchar *content;
if (charset.empty()) {
content = NULL;
} else {
content = g_convert(p, buffer_len - (p - buffer), "UTF-8", charset.c_str(), NULL, NULL, NULL);
p = content;
}
resp->data = NULL;
if (p) {
const char *body = strcasestr(p, "<body");
if (body) {
const char *body_end = strcasestr(p, "</body>");
if (body_end) {
body_end += sizeof("</body>") -1;
std::string html(body, body_end - body);
resp->data = build_dictdata('h', html.c_str());
}
}
}
g_free(content);
} else {
const char *xml = g_strstr_len(p, buffer_len - (p - buffer), "<dict>");
if (!xml) {
return;
}
const char *xml_end = g_strstr_len(xml+6, buffer_len - (xml+6 - buffer), "</dict>");
if (!xml_end) {
return;
}
xml_end += 7;
dict_ParseUserData Data;
GMarkupParser parser;
parser.start_element = dict_parse_start_element;
parser.end_element = dict_parse_end_element;
parser.text = dict_parse_text;
parser.passthrough = NULL;
parser.error = NULL;
GMarkupParseContext* context = g_markup_parse_context_new(&parser, (GMarkupParseFlags)0, &Data, NULL);
g_markup_parse_context_parse(context, xml, xml_end - xml, NULL);
g_markup_parse_context_end_parse(context, NULL);
g_markup_parse_context_free(context);
if (Data.def == "Not Found") {
resp->data = NULL;
} else {
std::string definition;
if (!Data.pron.empty()) {
definition += "[";
definition += Data.pron;
definition += "]\n";
}
definition += Data.def;
if (!Data.rel.empty()) {
definition += "\n";
definition += Data.rel;
}
if (!Data.sentences.empty()) {
definition += "\n\n例句与用法:";
int index = 1;
char *tmp_str;
for (std::list<std::pair<std::string, std::string> >::iterator i = Data.sentences.begin(); i != Data.sentences.end(); ++i) {
tmp_str = g_strdup_printf("\n%d. %s\n %s", index, i->first.c_str(), i->second.c_str());
definition += tmp_str;
g_free(tmp_str);
index++;
}
}
resp->data = build_dictdata('m', definition.c_str());
}
}
plugin_service->netdict_save_cache_resp(DICTDOTCN, qi->word, resp);
plugin_service->show_netdict_resp(resp, qi->ismainwin);
delete qi;
keyword_list.remove(qi);
}
static char*
load_state (const char *previous_save_file)
{
GMarkupParseContext *context;
GError *error;
ParseData parse_data;
char *text;
gsize length;
char *session_file;
session_file = g_strconcat (g_get_user_config_dir (),
G_DIR_SEPARATOR_S "metacity"
G_DIR_SEPARATOR_S "sessions" G_DIR_SEPARATOR_S,
previous_save_file,
NULL);
error = NULL;
if (!g_file_get_contents (session_file,
&text,
&length,
&error))
{
char *canonical_session_file = session_file;
/* Maybe they were doing it the old way, with ~/.metacity */
session_file = g_strconcat (g_get_home_dir (),
G_DIR_SEPARATOR_S ".metacity"
G_DIR_SEPARATOR_S "sessions"
G_DIR_SEPARATOR_S,
previous_save_file,
NULL);
if (!g_file_get_contents (session_file,
&text,
&length,
NULL))
{
/* oh, just give up */
meta_warning (_("Failed to read saved session file %s: %s\n"),
canonical_session_file, error->message);
g_error_free (error);
g_free (session_file);
g_free (canonical_session_file);
return NULL;
}
g_free (canonical_session_file);
}
meta_topic (META_DEBUG_SM, "Parsing saved session file %s\n", session_file);
g_free (session_file);
session_file = NULL;
parse_data.info = NULL;
parse_data.previous_id = NULL;
context = g_markup_parse_context_new (&metacity_session_parser,
0, &parse_data, NULL);
error = NULL;
if (!g_markup_parse_context_parse (context,
text,
length,
&error))
goto error;
error = NULL;
if (!g_markup_parse_context_end_parse (context, &error))
goto error;
g_markup_parse_context_free (context);
goto out;
error:
meta_warning (_("Failed to parse saved session file: %s\n"),
error->message);
g_error_free (error);
if (parse_data.info)
session_info_free (parse_data.info);
g_free (parse_data.previous_id);
parse_data.previous_id = NULL;
out:
g_free (text);
return parse_data.previous_id;
}
static GHashTable *
parse_resource_file (const gchar *filename,
gboolean collect_data,
GHashTable *files)
{
GMarkupParser parser = { start_element, end_element, text };
ParseState state = { 0, };
GMarkupParseContext *context;
GError *error = NULL;
gchar *contents;
GHashTable *table = NULL;
gsize size;
if (!g_file_get_contents (filename, &contents, &size, &error))
{
g_printerr ("%s\n", error->message);
g_clear_error (&error);
return NULL;
}
state.collect_data = collect_data;
state.table = g_hash_table_ref (files);
context = g_markup_parse_context_new (&parser,
G_MARKUP_TREAT_CDATA_AS_TEXT |
G_MARKUP_PREFIX_ERROR_POSITION,
&state, NULL);
if (!g_markup_parse_context_parse (context, contents, size, &error) ||
!g_markup_parse_context_end_parse (context, &error))
{
g_printerr ("%s: %s.\n", filename, error->message);
g_clear_error (&error);
}
else
{
GHashTableIter iter;
const char *key;
char *mykey;
gsize key_len;
FileData *data;
GVariant *v_data;
GVariantBuilder builder;
GvdbItem *item;
table = gvdb_hash_table_new (NULL, NULL);
g_hash_table_iter_init (&iter, state.table);
while (g_hash_table_iter_next (&iter, (gpointer *)&key, (gpointer *)&data))
{
key_len = strlen (key);
mykey = g_strdup (key);
item = gvdb_hash_table_insert (table, key);
gvdb_item_set_parent (item,
get_parent (table, mykey, key_len));
g_free (mykey);
g_variant_builder_init (&builder, G_VARIANT_TYPE ("(uuay)"));
g_variant_builder_add (&builder, "u", data->size); /* Size */
g_variant_builder_add (&builder, "u", data->flags); /* Flags */
v_data = g_variant_new_from_data (G_VARIANT_TYPE("ay"),
data->content, data->content_size, TRUE,
g_free, data->content);
g_variant_builder_add_value (&builder, v_data);
data->content = NULL; /* Take ownership */
gvdb_item_set_value (item,
g_variant_builder_end (&builder));
}
}
g_hash_table_unref (state.table);
g_markup_parse_context_free (context);
g_free (contents);
return table;
}
/**********************************************************************
* errlog2event_hash_init:
* @custom_handle: Plugin's data pointer.
*
* Initializes the Error Log to event translation hash table.
*
* Returns:
* SA_OK - Normal operation.
* SA_ERR_HPI_OUT_OF_SPACE - No memory to allocate hash table structures.
* SA_ERR_HPI_INVALID_PARAMS - @custom_handle NULL
**********************************************************************/
SaErrorT errlog2event_hash_init(struct snmp_bc_hnd *custom_handle) {
GMarkupParser parser;
GMarkupParseContext *pcontext;
gboolean rc;
GError *err;
struct errlog2event_hash_info user_data;
if (!custom_handle) {
dbg("Invalid parameter.");
return(SA_ERR_HPI_INVALID_PARAMS);
}
err = NULL;
snmp_bc_lock(snmp_bc_plock);
/* Initialize hash table */
errlog2event_hash = g_hash_table_new(g_str_hash, g_str_equal);
if (errlog2event_hash == NULL) {
dbg("No memory.");
snmp_bc_unlock(snmp_bc_plock);
return(SA_ERR_HPI_OUT_OF_SPACE);
}
/* Initialize user data used in parsing XML events */
user_data.hashtable = errlog2event_hash;
/* Initialize XML parser */
memset(&parser, 0, sizeof(parser));
parser.start_element = event_start_element;
pcontext = g_markup_parse_context_new(&parser, 0, &user_data, NULL);
if (pcontext == NULL) {
dbg("No memory.");
snmp_bc_unlock(snmp_bc_plock);
return(SA_ERR_HPI_OUT_OF_SPACE);
}
/* Parse XML events */
rc = g_markup_parse_context_parse(pcontext,
(const gchar *)eventxml,
(gssize)strlen(eventxml), &err);
if (rc == FALSE || err != NULL) {
if (err != NULL) {
dbg("Parse error=%s.", err->message);
g_error_free(err);
}
else {
dbg("Unknown XML parse error.");
}
g_markup_parse_context_free(pcontext);
snmp_bc_unlock(snmp_bc_plock);
return(SA_ERR_HPI_INTERNAL_ERROR);
}
g_markup_parse_context_end_parse(pcontext, &err);
g_markup_parse_context_free(pcontext);
/* Make sure there are elements in the hash table */
if (g_hash_table_size(errlog2event_hash) == 0) {
dbg("Hash table is empty.");
snmp_bc_unlock(snmp_bc_plock);
return(SA_ERR_HPI_INTERNAL_ERROR);
}
snmp_bc_unlock(snmp_bc_plock);
return(SA_OK);
}
/**
* Function reading an XML file specifying a cup.
* @param cup_name name of the xml file (e.g. 'cup_england_fa.xml')
* to be read. Full path is not necessary, if the file is located in
* one of the suppport directories; neither are the prefix 'cup_'
* or the suffix '.xml'.
* @param cups The array we append the new cup to.
*/
void
xml_cup_read(const gchar *cup_name, GArray *cups)
{
#ifdef DEBUG
printf("xml_cup_read\n");
#endif
gchar *file_name = file_find_support_file(cup_name, FALSE);
GMarkupParser parser = {xml_cup_read_start_element,
xml_cup_read_end_element,
xml_cup_read_text, NULL, NULL};
GMarkupParseContext *context;
gchar *file_contents;
gsize length;
GError *error = NULL;
gchar buf[SMALL];
gint i;
context =
g_markup_parse_context_new(&parser, 0, NULL, NULL);
if(file_name == NULL)
{
sprintf(buf, "cup_%s.xml", cup_name);
file_name = file_find_support_file(buf, TRUE);
}
if(!g_file_get_contents(file_name, &file_contents, &length, &error))
{
debug_print_message("xml_cup_read: error reading file %s\n", file_name);
misc_print_error(&error, FALSE);
return;
}
state = STATE_CUP;
strcpy(buf, file_name);
g_free(file_name);
if(g_markup_parse_context_parse(context, file_contents, length, &error))
{
g_markup_parse_context_end_parse(context, NULL);
g_markup_parse_context_free(context);
g_free(file_contents);
}
else
{
g_critical("xml_cup_read: error parsing file %s\n", buf);
misc_print_error(&error, TRUE);
}
new_cup.id = cup_id_new;
league_cup_adjust_week_breaks(new_cup.week_breaks, new_cup.week_gap);
for(i = 0; i < new_cup.rounds->len; i++)
if(g_array_index(new_cup.rounds, CupRound, i).name == NULL)
{
cup_get_round_name(&new_cup, i, buf);
g_array_index(new_cup.rounds, CupRound, i).name = g_strdup(buf);
}
g_array_append_val(cups, new_cup);
}
