/* * Get the psessionid. * * This function is the last step of loginning */ static int get_psessionid(QQInfo *info) { int ret = NO_ERR; gint res = 0; if(info -> ptwebqq == NULL || info -> ptwebqq -> len <= 0){ g_warning("Need ptwebqq!!(%s, %d)", __FILE__, __LINE__); return PARAMETER_ERR; } Request *req = request_new(); Response *rps = NULL; request_set_method(req, "POST"); request_set_version(req, "HTTP/1.1"); request_set_uri(req, PSIDPATH); request_set_default_headers(req); request_add_header(req, "Host", PSIDHOST); request_add_header(req, "Cookie2", "$Version=1"); request_add_header(req, "Referer" , "http://d.web2.qq.com/proxy.html?v=20101025002"); GString *clientid = generate_clientid(); info -> clientid = clientid; g_debug("clientid: %s", clientid -> str); gchar* msg = g_malloc(500); g_snprintf(msg, 500, "{\"status\":\"%s\",\"ptwebqq\":\"%s\"," "\"passwd_sig\":""\"\",\"clientid\":\"%s\"" ", \"psessionid\":null}" , info -> me -> status -> str, info -> ptwebqq -> str , clientid -> str); gchar *escape = g_uri_escape_string(msg, NULL, FALSE); g_snprintf(msg, 500, "r=%s", escape); g_free(escape); request_append_msg(req, msg, strlen(msg)); gchar cl[10]; g_sprintf(cl, "%u", (unsigned int)strlen(msg)); request_add_header(req, "Content-Length", cl); request_add_header(req, "Content-Type" , "application/x-www-form-urlencoded"); g_free(msg); gchar *cookie = g_malloc(2000); gint idx = 0; if(info -> ptvfsession != NULL){ idx += g_snprintf(cookie + idx, 2000 - idx, "ptvfsession=%s; " , info -> ptvfsession -> str); } idx += g_snprintf(cookie + idx, 2000 - idx, "%s" , info -> cookie -> str); request_add_header(req, "Cookie", cookie); g_free(cookie); Connection *con = connect_to_host(PSIDHOST, 80); if(con == NULL){ g_warning("Can NOT connect to server!(%s, %d)" , __FILE__, __LINE__); request_del(req); return NETWORK_ERR; } send_request(con, req); res = rcv_response(con, &rps); if (-1 == res || !rps) { g_warning("Null point access (%s, %d)\n", __FILE__, __LINE__); ret = -1; goto error; } const gchar *retstatus = rps -> status -> str; if(g_strstr_len(retstatus, -1, "200") == NULL){ g_warning("Server status %s (%s, %d)", retstatus , __FILE__, __LINE__); ret = NETWORK_ERR; goto error; } json_t *json = NULL; switch(json_parse_document(&json, rps -> msg -> str)) { case JSON_OK: break; default: g_warning("json_parser_document: syntax error. (%s, %d)" , __FILE__, __LINE__); ret = NETWORK_ERR; goto error; } json_t *val; val = json_find_first_label_all(json, "retcode"); if(val -> child -> text[0] != '0'){ g_warning("Server return code %s(%s, %d)", val -> child -> text , __FILE__, __LINE__); ret = NETWORK_ERR; goto error; } val = json_find_first_label_all(json, "seskey"); if(val != NULL){ g_debug("seskey: %s (%s, %d)", val -> child -> text , __FILE__, __LINE__); info -> seskey = g_string_new(val -> child -> text); } val = json_find_first_label_all(json, "cip"); if(val != NULL){ info -> cip = g_string_new(val -> child -> text); } val = json_find_first_label_all(json, "index"); if(val != NULL){ info -> index = g_string_new(val -> child -> text); } val = json_find_first_label_all(json, "port"); if(val != NULL){ info -> port = g_string_new(val -> child -> text); } val = json_find_first_label_all(json, "status"); { g_debug("status: %s (%s, %d)", val -> child -> text , __FILE__, __LINE__); } val = json_find_first_label_all(json, "vfwebqq"); if(val != NULL){ g_debug("vfwebqq: %s (%s, %d)", val -> child -> text , __FILE__, __LINE__); info -> vfwebqq = g_string_new(val -> child -> text); } val = json_find_first_label_all(json, "psessionid"); if(val != NULL){ g_debug("psessionid: %s (%s, %d)", val -> child -> text , __FILE__, __LINE__); info -> psessionid = g_string_new(val -> child -> text); }else{ g_debug("Can not find pesssionid!(%s, %d): %s" , __FILE__, __LINE__, rps -> msg -> str); } error: json_free_value(&json); close_con(con); connection_free(con); request_del(req); response_del(rps); return ret; }
static struct playlist_provider * lastfm_open_uri(const char *uri, GMutex *mutex, GCond *cond) { struct lastfm_playlist *playlist; GError *error = NULL; char *p, *q, *response, *session; /* handshake */ p = g_strconcat("http://ws.audioscrobbler.com/radio/handshake.php?" "version=1.1.1&platform=linux&" "username="******"&" "passwordmd5=", lastfm_config.md5, "&" "debug=0&partner=", NULL); response = lastfm_get(p, mutex, cond); g_free(p); if (response == NULL) return NULL; /* extract session id from response */ session = lastfm_find(response, "session"); g_free(response); if (session == NULL) { g_warning("last.fm handshake failed"); return NULL; } q = g_uri_escape_string(session, NULL, false); g_free(session); session = q; g_debug("session='%s'", session); /* "adjust" last.fm radio */ if (strlen(uri) > 9) { char *escaped_uri; escaped_uri = g_uri_escape_string(uri, NULL, false); p = g_strconcat("http://ws.audioscrobbler.com/radio/adjust.php?" "session=", session, "&url=", escaped_uri, "&debug=0", NULL); g_free(escaped_uri); response = lastfm_get(p, mutex, cond); g_free(response); g_free(p); if (response == NULL) { g_free(session); return NULL; } } /* create the playlist object */ playlist = g_new(struct lastfm_playlist, 1); playlist_provider_init(&playlist->base, &lastfm_playlist_plugin); /* open the last.fm playlist */ p = g_strconcat("http://ws.audioscrobbler.com/radio/xspf.php?" "sk=", session, "&discovery=0&desktop=1.5.1.31879", NULL); g_free(session); playlist->is = input_stream_open(p, mutex, cond, &error); g_free(p); if (playlist->is == NULL) { if (error != NULL) { g_warning("Failed to load XSPF playlist: %s", error->message); g_error_free(error); } else g_warning("Failed to load XSPF playlist"); g_free(playlist); return NULL; } g_mutex_lock(mutex); input_stream_wait_ready(playlist->is); /* last.fm does not send a MIME type, we have to fake it here :-( */ g_free(playlist->is->mime); playlist->is->mime = g_strdup("application/xspf+xml"); g_mutex_unlock(mutex); /* parse the XSPF playlist */ playlist->xspf = playlist_list_open_stream(playlist->is, NULL); if (playlist->xspf == NULL) { input_stream_close(playlist->is); g_free(playlist); g_warning("Failed to parse XSPF playlist"); return NULL; } return &playlist->base; }
char *gg_oauth_parameter_join(gg_oauth_parameter_t *list, int header) { gg_oauth_parameter_t *p; int len = 0; char *res, *out; if (header) len += strlen("OAuth "); for (p = list; p; p = p->next) { gchar *escaped; len += strlen(p->key); len += (header) ? 3 : 1; escaped = g_uri_escape_string(p->value, NULL, FALSE); len += strlen(escaped); g_free(escaped); if (p->next) len += 1; } res = malloc(len + 1); if (res == NULL) return NULL; out = res; *out = 0; if (header) { strcpy(out, "OAuth "); out += strlen(out); } for (p = list; p; p = p->next) { gchar *escaped; strcpy(out, p->key); out += strlen(p->key); strcpy(out++, "="); if (header) strcpy(out++, "\""); escaped = g_uri_escape_string(p->value, NULL, FALSE); strcpy(out, escaped); out += strlen(escaped); g_free(escaped); if (header) strcpy(out++, "\""); if (p->next != NULL) strcpy(out++, (header) ? "," : "&"); } return res; }
/** * tracker_sparql_escape_uri_vprintf: * @format: a standard printf() format string, but notice * <link linkend="string-precision">string precision pitfalls</link> documented in g_strdup_printf() * @args: the list of parameters to insert into the format string * * Similar to the standard C vsprintf() function but safer, since it * calculates the maximum space required and allocates memory to hold * the result. * * The result is escaped using g_uri_escape_string(). * * Returns: a newly-allocated string holding the result. The returned string * should be freed with g_free() when no longer needed. * * Since: 0.10 */ gchar * tracker_sparql_escape_uri_vprintf (const gchar *format, va_list args) { GString *format1; GString *format2; GString *result = NULL; gchar *output1 = NULL; gchar *output2 = NULL; const char *p; gchar *op1, *op2; va_list args2; format1 = g_string_new (NULL); format2 = g_string_new (NULL); p = format; while (TRUE) { const char *after; const char *conv = find_conversion (p, &after); if (!conv) break; g_string_append_len (format1, conv, after - conv); g_string_append_c (format1, 'X'); g_string_append_len (format2, conv, after - conv); g_string_append_c (format2, 'Y'); p = after; } /* Use them to format the arguments */ G_VA_COPY (args2, args); output1 = g_strdup_vprintf (format1->str, args); va_end (args); if (!output1) { va_end (args2); goto cleanup; } output2 = g_strdup_vprintf (format2->str, args2); va_end (args2); if (!output2) goto cleanup; result = g_string_new (NULL); op1 = output1; op2 = output2; p = format; while (TRUE) { const char *after; const char *output_start; const char *conv = find_conversion (p, &after); char *escaped; if (!conv) { g_string_append_len (result, p, after - p); break; } g_string_append_len (result, p, conv - p); output_start = op1; while (*op1 == *op2) { op1++; op2++; } *op1 = '\0'; escaped = g_uri_escape_string (output_start, G_URI_RESERVED_CHARS_ALLOWED_IN_PATH_ELEMENT, FALSE); g_string_append (result, escaped); g_free (escaped); p = after; op1++; op2++; } cleanup: g_string_free (format1, TRUE); g_string_free (format2, TRUE); g_free (output1); g_free (output2); if (result) return g_string_free (result, FALSE); else return NULL; }
static void add_clicked_cb (GtkWidget *widget, DialogData *data) { FrWindow *window = data->window; char *archive_name; char *archive_dir; char *archive_file; char *tmp; const char *archive_ext; gboolean do_not_add = FALSE; GError *error = NULL; data->add_clicked = TRUE; /* Collect data */ archive_name = g_uri_escape_string (gtk_entry_get_text (GTK_ENTRY (data->a_add_to_entry)), NULL, FALSE); /* Check whether the user entered a valid archive name. */ if ((archive_name == NULL) || (*archive_name == '\0')) { GtkWidget *d; d = _gtk_error_dialog_new (GTK_WINDOW (window), GTK_DIALOG_DESTROY_WITH_PARENT, NULL, _("Could not create the archive"), "%s", _("You have to specify an archive name.")); gtk_dialog_run (GTK_DIALOG (d)); gtk_widget_destroy (GTK_WIDGET (d)); g_free (archive_name); return; } else if (strchrs (archive_name, BAD_CHARS)) { GtkWidget *d; char *utf8_name = g_filename_display_name (archive_name); d = _gtk_error_dialog_new (GTK_WINDOW (window), GTK_DIALOG_DESTROY_WITH_PARENT, NULL, _("Could not create the archive"), _("The name \"%s\" is not valid because it cannot contain the characters: %s\n\n%s"), utf8_name, BAD_CHARS, _("Please use a different name.")); gtk_dialog_run (GTK_DIALOG (d)); gtk_widget_destroy (GTK_WIDGET (d)); g_free (utf8_name); g_free (archive_name); return; } /* Check directory existence. */ archive_dir = gtk_file_chooser_get_uri (GTK_FILE_CHOOSER (data->a_location_filechooserbutton)); if (archive_dir == NULL) { g_free (archive_dir); g_free (archive_name); return; } if (! check_permissions (archive_dir, R_OK|W_OK|X_OK)) { GtkWidget *d; d = _gtk_error_dialog_new (GTK_WINDOW (window), GTK_DIALOG_DESTROY_WITH_PARENT, NULL, _("Could not create the archive"), "%s", _("You don't have the right permissions to create an archive in the destination folder.")); gtk_dialog_run (GTK_DIALOG (d)); gtk_widget_destroy (GTK_WIDGET (d)); g_free (archive_dir); g_free (archive_name); return; } if (! uri_is_dir (archive_dir)) { GtkWidget *d; int r; char *folder_name; char *msg; folder_name = g_filename_display_name (archive_dir); msg = g_strdup_printf (_("Destination folder \"%s\" does not exist.\n\nDo you want to create it?"), folder_name); g_free (folder_name); d = _gtk_message_dialog_new (GTK_WINDOW (data->dialog), GTK_DIALOG_MODAL, GTK_STOCK_DIALOG_QUESTION, msg, NULL, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, _("Create _Folder"), GTK_RESPONSE_YES, NULL); gtk_dialog_set_default_response (GTK_DIALOG (d), GTK_RESPONSE_YES); r = gtk_dialog_run (GTK_DIALOG (d)); gtk_widget_destroy (GTK_WIDGET (d)); g_free (msg); do_not_add = (r != GTK_RESPONSE_YES); } if (! do_not_add && ! ensure_dir_exists (archive_dir, 0755, &error)) { GtkWidget *d; d = _gtk_error_dialog_new (GTK_WINDOW (window), GTK_DIALOG_DESTROY_WITH_PARENT, NULL, _("Could not create the archive"), _("Could not create the destination folder: %s."), error->message); gtk_dialog_run (GTK_DIALOG (d)); gtk_widget_destroy (GTK_WIDGET (d)); g_error_free (error); g_free (archive_dir); g_free (archive_name); return; } if (do_not_add) { GtkWidget *d; d = _gtk_message_dialog_new (GTK_WINDOW (window), GTK_DIALOG_DESTROY_WITH_PARENT, GTK_STOCK_DIALOG_WARNING, _("Archive not created"), NULL, GTK_STOCK_OK, GTK_RESPONSE_OK, NULL); gtk_dialog_set_default_response (GTK_DIALOG (d), GTK_RESPONSE_OK); gtk_dialog_run (GTK_DIALOG (d)); gtk_widget_destroy (GTK_WIDGET (d)); g_free (archive_dir); g_free (archive_name); return; } /**/ archive_ext = get_ext (data); tmp = archive_name; archive_name = g_strconcat (tmp, archive_ext, NULL); g_free (tmp); archive_file = g_strconcat (archive_dir, "/", archive_name, NULL); if (uri_is_dir (archive_file)) { GtkWidget *d; d = _gtk_error_dialog_new (GTK_WINDOW (window), GTK_DIALOG_DESTROY_WITH_PARENT, NULL, _("Could not create the archive"), "%s", _("You have to specify an archive name.")); gtk_dialog_run (GTK_DIALOG (d)); gtk_widget_destroy (GTK_WIDGET (d)); g_free (archive_name); g_free (archive_dir); g_free (archive_file); return; } if (uri_exists (archive_file)) { GtkWidget *d; int r; d = _gtk_message_dialog_new (GTK_WINDOW (data->dialog), GTK_DIALOG_MODAL, GTK_STOCK_DIALOG_QUESTION, _("The archive is already present. Do you want to overwrite it?"), NULL, GTK_STOCK_NO, GTK_RESPONSE_NO, _("_Overwrite"), GTK_RESPONSE_YES, NULL); gtk_dialog_set_default_response (GTK_DIALOG (d), GTK_RESPONSE_YES); r = gtk_dialog_run (GTK_DIALOG (d)); gtk_widget_destroy (GTK_WIDGET (d)); if (r == GTK_RESPONSE_YES) { GFile *file; GError *err = NULL; /* FIXME: convert this code in a function in file-utils.c */ file = g_file_new_for_uri (archive_file); g_file_delete (file, NULL, &err); if (err != NULL) { g_warning ("Failed to delete file %s: %s", archive_file, err->message); g_clear_error (&err); } g_object_unref (file); } else { g_free (archive_name); g_free (archive_dir); g_free (archive_file); return; } } set_archive_options (data); gtk_widget_destroy (data->dialog); fr_window_archive_new (window, archive_file); g_free (archive_name); g_free (archive_dir); g_free (archive_file); }
/** * anjuta_session_get_relative_uri_from_file: * @session: an #AnjutaSession object * @file: a GFile * @fragment: an optional fragment * * Return an URI relative to the session directory file with an optional * fragment. * It is useful to keep only relative file paths in a session file to be able * to copy the whole project without breaking references. * * Returns: (transfer full): A string that has to be freed with g_free(). */ gchar * anjuta_session_get_relative_uri_from_file (AnjutaSession *session, GFile *file, const gchar *fragment) { GFile *parent; gchar *uri; gint level; parent = g_file_new_for_path (session->priv->dir_path); for (level = 0; (parent != NULL) && !g_file_equal (file, parent) && !g_file_has_prefix (file, parent); level++) { GFile *next = g_file_get_parent (parent); g_object_unref (parent); parent = next; } if (parent == NULL) { uri = g_file_get_uri (file); } else { gchar *path; if (g_file_equal (file, parent)) { uri = g_strdup("."); } else { path = g_file_get_relative_path (parent, file); uri = g_uri_escape_string (path, G_URI_RESERVED_CHARS_ALLOWED_IN_PATH, TRUE); g_free (path); } if (level != 0) { gsize len; gchar *buffer; gchar *ptr; len = strlen (uri); buffer = g_new (gchar, len + level * 3 + 1); for (ptr = buffer; level; level--) { memcpy (ptr, ".." G_DIR_SEPARATOR_S, 3); ptr += 3; } memcpy (ptr, uri, len + 1); g_free (uri); uri = buffer; } } if (fragment != NULL) { gchar *with_fragment; with_fragment = g_strconcat (uri, "#", fragment, NULL); g_free (uri); uri = with_fragment; } return uri; }
static gboolean _lib_location_search(gpointer user_data) { GMarkupParseContext *ctx = NULL; CURL *curl = NULL; CURLcode res; GError *err = NULL; dt_lib_module_t *self = (dt_lib_module_t *)user_data; dt_lib_location_t *lib = (dt_lib_location_t *)self->data; gchar *query = NULL, *text = NULL; /* get escaped search text */ text = g_uri_escape_string(gtk_entry_get_text(lib->search), NULL, FALSE); if(!(text && *text)) goto bail_out; /* clean up previous results before adding new */ clear_search(lib); /* build the query url */ query = dt_util_dstrcat(query, "http://nominatim.openstreetmap.org/search/%s?format=xml&limit=%d&polygon_text=1", text, LIMIT_RESULT); /* load url */ curl = curl_easy_init(); if(!curl) goto bail_out; curl_easy_setopt(curl, CURLOPT_URL, query); // curl_easy_setopt(curl, CURLOPT_VERBOSE, 1); curl_easy_setopt(curl, CURLOPT_WRITEDATA, lib); curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, _lib_location_curl_write_data); curl_easy_setopt(curl, CURLOPT_USERAGENT, (char *)darktable_package_string); res = curl_easy_perform(curl); if(res != 0) goto bail_out; if(!lib->response) goto bail_out; /* parse xml response and populate the result list */ ctx = g_markup_parse_context_new(&_lib_location_parser, 0, lib, NULL); g_markup_parse_context_parse(ctx, lib->response, lib->response_size, &err); if(err) goto bail_out; /* add the places into the result list */ GList *item = lib->places; if(!item) goto bail_out; // while(item) // { // _lib_location_result_t *p = (_lib_location_result_t *)item->data; // fprintf(stderr, "(%f,%f) %s\n", p->lon, p->lat, p->name); // item = g_list_next(item); // } /* cleanup an exit search job */ bail_out: if(err) { fprintf(stderr, "location search: %s\n", err->message); g_error_free(err); } if(curl) curl_easy_cleanup(curl); g_free(text); g_free(query); if(ctx) g_markup_parse_context_free(ctx); /* enable the widgets */ gtk_widget_set_sensitive(GTK_WIDGET(lib->search), TRUE); // gtk_widget_set_sensitive(lib->result, FALSE); return FALSE; }
static gboolean _save_data_track_xml (xmlTextWriter *project, RejillaBurnSession *session) { gchar *uri; gint success; GSList *iter; GSList *tracks; GSList *grafts; gchar *filename; RejillaTrackDataCfg *track; tracks = rejilla_burn_session_get_tracks (session); track = REJILLA_TRACK_DATA_CFG (tracks->data); filename = rejilla_track_data_cfg_get_icon_path (track); if (filename) { /* Write the icon if any */ success = xmlTextWriterWriteElement (project, (xmlChar *) "icon", (xmlChar *) filename); g_free (filename); if (success < 0) return FALSE; } grafts = rejilla_track_data_get_grafts (REJILLA_TRACK_DATA (track)); for (; grafts; grafts = grafts->next) { RejillaGraftPt *graft; graft = grafts->data; success = xmlTextWriterStartElement (project, (xmlChar *) "graft"); if (success < 0) return FALSE; success = xmlTextWriterWriteElement (project, (xmlChar *) "path", (xmlChar *) graft->path); if (success < 0) return FALSE; if (graft->uri) { xmlChar *escaped; escaped = (unsigned char *) g_uri_escape_string (graft->uri, NULL, FALSE); success = xmlTextWriterWriteElement (project, (xmlChar *) "uri", escaped); g_free (escaped); if (success < 0) return FALSE; } success = xmlTextWriterEndElement (project); /* graft */ if (success < 0) return FALSE; } /* save excluded uris */ iter = rejilla_track_data_get_excluded_list (REJILLA_TRACK_DATA (track)); for (; iter; iter = iter->next) { xmlChar *escaped; escaped = xmlURIEscapeStr ((xmlChar *) iter->data, NULL); success = xmlTextWriterWriteElement (project, (xmlChar *) "excluded", (xmlChar *) escaped); g_free (escaped); if (success < 0) return FALSE; } /* save restored uris */ iter = rejilla_track_data_cfg_get_restored_list (track); for (; iter; iter = iter->next) { uri = iter->data; success = xmlTextWriterWriteElement (project, (xmlChar *) "restored", (xmlChar *) uri); if (success < 0) return FALSE; } /* NOTE: we don't write symlinks and unreadable they are useless */ return TRUE; }
gboolean rejilla_project_save_project_xml (RejillaBurnSession *session, const gchar *uri) { RejillaTrackType *track_type = NULL; xmlTextWriter *project; gboolean retval; GSList *tracks; GValue *value; gint success; gchar *path; path = g_filename_from_uri (uri, NULL, NULL); if (!path) return FALSE; project = xmlNewTextWriterFilename (path, 0); if (!project) { g_free (path); return FALSE; } xmlTextWriterSetIndent (project, 1); xmlTextWriterSetIndentString (project, (xmlChar *) "\t"); success = xmlTextWriterStartDocument (project, NULL, "UTF-8", NULL); if (success < 0) goto error; success = xmlTextWriterStartElement (project, (xmlChar *) "rejillaproject"); if (success < 0) goto error; /* write the name of the version */ success = xmlTextWriterWriteElement (project, (xmlChar *) "version", (xmlChar *) REJILLA_PROJECT_VERSION); if (success < 0) goto error; if (rejilla_burn_session_get_label (session)) { success = xmlTextWriterWriteElement (project, (xmlChar *) "label", (xmlChar *) rejilla_burn_session_get_label (session)); if (success < 0) goto error; } value = NULL; rejilla_burn_session_tag_lookup (session, REJILLA_COVER_URI, &value); if (value) { gchar *escaped; escaped = g_uri_escape_string (g_value_get_string (value), NULL, FALSE); success = xmlTextWriterWriteElement (project, (xmlChar *) "cover", (xmlChar *) escaped); g_free (escaped); if (success < 0) goto error; } success = xmlTextWriterStartElement (project, (xmlChar *) "track"); if (success < 0) goto error; track_type = rejilla_track_type_new (); tracks = rejilla_burn_session_get_tracks (session); for (; tracks; tracks = tracks->next) { RejillaTrack *track; track = tracks->data; rejilla_track_get_track_type (track, track_type); if (rejilla_track_type_get_has_stream (track_type)) { if (REJILLA_STREAM_FORMAT_HAS_VIDEO (rejilla_track_type_get_stream_format (track_type))) success = xmlTextWriterStartElement (project, (xmlChar *) "video"); else success = xmlTextWriterStartElement (project, (xmlChar *) "audio"); if (success < 0) goto error; retval = _save_audio_track_xml (project, REJILLA_TRACK_STREAM (track)); if (!retval) goto error; success = xmlTextWriterEndElement (project); /* audio/video */ if (success < 0) goto error; } else if (rejilla_track_type_get_has_data (track_type)) { success = xmlTextWriterStartElement (project, (xmlChar *) "data"); if (success < 0) goto error; retval = _save_data_track_xml (project, session); if (!retval) goto error; success = xmlTextWriterEndElement (project); /* data */ if (success < 0) goto error; } else retval = FALSE; } success = xmlTextWriterEndElement (project); /* track */ if (success < 0) goto error; rejilla_track_type_free (track_type); success = xmlTextWriterEndElement (project); /* rejillaproject */ if (success < 0) goto error; xmlTextWriterEndDocument (project); xmlFreeTextWriter (project); g_free (path); return TRUE; error: if (track_type) rejilla_track_type_free (track_type); xmlTextWriterEndDocument (project); xmlFreeTextWriter (project); g_remove (path); g_free (path); return FALSE; }
static void list_dir (SMBCCTX *smb_context, const gchar *dirname, const gchar *path, GCancellable *cancellable, SMBData *data) { struct smbc_dirent *dirent; smbc_closedir_fn smbclient_closedir; smbc_readdir_fn smbclient_readdir; smbc_opendir_fn smbclient_opendir; PpPrintDevice *device; const gchar *host_name; SMBCFILE *dir; if (!g_cancellable_is_cancelled (cancellable)) { smbclient_closedir = smbc_getFunctionClosedir (smb_context); smbclient_readdir = smbc_getFunctionReaddir (smb_context); smbclient_opendir = smbc_getFunctionOpendir (smb_context); dir = smbclient_opendir (smb_context, dirname); if (!dir && errno == EACCES) { if (g_str_has_prefix (dirname, "smb://")) host_name = dirname + 6; else host_name = dirname; if (data->auth_if_needed) { data->cancelled = FALSE; smbc_setFunctionAuthDataWithContext (smb_context, auth_fn); dir = smbclient_opendir (smb_context, dirname); smbc_setFunctionAuthDataWithContext (smb_context, anonymous_auth_fn); if (data->cancelled) { device = g_object_new (PP_TYPE_PRINT_DEVICE, "host-name", host_name, "is-authenticated-server", TRUE, NULL); data->devices->devices = g_list_append (data->devices->devices, device); if (dir) smbclient_closedir (smb_context, dir); return; } } else { device = g_object_new (PP_TYPE_PRINT_DEVICE, "host-name", host_name, "is-authenticated-server", TRUE, NULL); data->devices->devices = g_list_append (data->devices->devices, device); } } while (dir && (dirent = smbclient_readdir (smb_context, dir))) { gchar *device_name; gchar *device_uri; gchar *subdirname = NULL; gchar *subpath = NULL; gchar *uri; if (dirent->smbc_type == SMBC_WORKGROUP) { subdirname = g_strdup_printf ("%s%s", dirname, dirent->name); subpath = g_strdup_printf ("%s%s", path, dirent->name); } if (dirent->smbc_type == SMBC_SERVER) { subdirname = g_strdup_printf ("smb://%s", dirent->name); subpath = g_strdup_printf ("%s//%s", path, dirent->name); } if (dirent->smbc_type == SMBC_PRINTER_SHARE) { uri = g_strdup_printf ("%s/%s", dirname, dirent->name); device_uri = g_uri_escape_string (uri, G_URI_RESERVED_CHARS_GENERIC_DELIMITERS G_URI_RESERVED_CHARS_SUBCOMPONENT_DELIMITERS, FALSE); device_name = g_strdup (dirent->name); device_name = g_strcanon (device_name, ALLOWED_CHARACTERS, '-'); device = g_object_new (PP_TYPE_PRINT_DEVICE, "device-uri", device_uri, "is-network-device", TRUE, "device-info", dirent->comment, "device-name", device_name, "acquisition-method", data->hostname_set ? ACQUISITION_METHOD_SAMBA_HOST : ACQUISITION_METHOD_SAMBA, "device-location", path, "host-name", dirname, NULL); g_free (device_name); g_free (device_uri); g_free (uri); data->devices->devices = g_list_append (data->devices->devices, device); } if (subdirname) { list_dir (smb_context, subdirname, subpath, cancellable, data); g_free (subdirname); g_free (subpath); } } if (dir) smbclient_closedir (smb_context, dir); } }
static gboolean _save_audio_track_xml (xmlTextWriter *project, RejillaTrackStream *track) { xmlChar *escaped; gchar *start; gint success; gchar *isrc; gchar *uri; gchar *end; uri = rejilla_track_stream_get_source (track, TRUE); escaped = (unsigned char *) g_uri_escape_string (uri, NULL, FALSE); g_free (uri); success = xmlTextWriterWriteElement (project, (xmlChar *) "uri", escaped); g_free (escaped); if (success == -1) return FALSE; if (rejilla_track_stream_get_gap (track) > 0) { gchar *silence; silence = g_strdup_printf ("%"G_GINT64_FORMAT, rejilla_track_stream_get_gap (track)); success = xmlTextWriterWriteElement (project, (xmlChar *) "silence", (xmlChar *) silence); g_free (silence); if (success == -1) return FALSE; } if (rejilla_track_stream_get_end (track) > 0) { /* start of the song */ start = g_strdup_printf ("%"G_GINT64_FORMAT, rejilla_track_stream_get_start (track)); success = xmlTextWriterWriteElement (project, (xmlChar *) "start", (xmlChar *) start); g_free (start); if (success == -1) return FALSE; /* end of the song */ end = g_strdup_printf ("%"G_GINT64_FORMAT, rejilla_track_stream_get_end (track)); success = xmlTextWriterWriteElement (project, (xmlChar *) "end", (xmlChar *) end); g_free (end); if (success == -1) return FALSE; } if (rejilla_track_tag_lookup_string (REJILLA_TRACK (track), REJILLA_TRACK_STREAM_TITLE_TAG)) { escaped = (unsigned char *) g_uri_escape_string (rejilla_track_tag_lookup_string (REJILLA_TRACK (track), REJILLA_TRACK_STREAM_TITLE_TAG), NULL, FALSE); success = xmlTextWriterWriteElement (project, (xmlChar *) "title", escaped); g_free (escaped); if (success == -1) return FALSE; } if (rejilla_track_tag_lookup_string (REJILLA_TRACK (track), REJILLA_TRACK_STREAM_ARTIST_TAG)) { escaped = (unsigned char *) g_uri_escape_string (rejilla_track_tag_lookup_string (REJILLA_TRACK (track), REJILLA_TRACK_STREAM_ARTIST_TAG), NULL, FALSE); success = xmlTextWriterWriteElement (project, (xmlChar *) "artist", escaped); g_free (escaped); if (success == -1) return FALSE; } if (rejilla_track_tag_lookup_string (REJILLA_TRACK (track), REJILLA_TRACK_STREAM_COMPOSER_TAG)) { escaped = (unsigned char *) g_uri_escape_string (rejilla_track_tag_lookup_string (REJILLA_TRACK (track), REJILLA_TRACK_STREAM_COMPOSER_TAG), NULL, FALSE); success = xmlTextWriterWriteElement (project, (xmlChar *) "composer", escaped); g_free (escaped); if (success == -1) return FALSE; } if (rejilla_track_tag_lookup_int (REJILLA_TRACK (track), REJILLA_TRACK_STREAM_ISRC_TAG)) { isrc = g_strdup_printf ("%d", rejilla_track_tag_lookup_int (REJILLA_TRACK (track), REJILLA_TRACK_STREAM_ISRC_TAG)); success = xmlTextWriterWriteElement (project, (xmlChar *) "isrc", (xmlChar *) isrc); g_free (isrc); if (success == -1) return FALSE; } return TRUE; }
int main(int argc, char **argv) { abrt_init(argv); enum { OPT_v = 1 << 0, OPT_d = 1 << 1, OPT_g = 1 << 2, OPT_b = 1 << 3, OPT_u = 1 << 4, OPT_r = 1 << 5, }; const char *bugs = NULL, *release = NULL, *dump_dir_path = "."; /* Keep enum above and order of options below in sync! */ struct options program_options[] = { OPT__VERBOSE(&g_verbose), OPT__DUMP_DIR(&dump_dir_path), OPT_GROUP(""), OPT_STRING('b', "bugs", &bugs, "ID1[,ID2,...]" , _("List of bug ids")), OPT_STRING('u', "url", &bodhi_url, "URL", _("Specify a bodhi server url")), OPT_OPTSTRING('r', "release", &release, "RELEASE", _("Specify a release")), OPT_END() }; const char *program_usage_string = _( "& [-v] [-r[RELEASE]] (-b ID1[,ID2,...] | PKG-NAME) [PKG-NAME]... \n" "\n" "Search for updates on bodhi server" ); unsigned opts = parse_opts(argc, argv, program_options, program_usage_string); if (!bugs && !argv[optind]) show_usage_and_die(program_usage_string, program_options); struct strbuf *query = strbuf_new(); if (bugs) query = strbuf_append_strf(query, "bugs=%s&", bugs); if (opts & OPT_r) { if (release) { /* There are no bodhi updates for Rawhide */ if (strcasecmp(release, "rawhide") == 0) error_msg_and_die("Release \"%s\" is not supported",release); query = strbuf_append_strf(query, "releases=%s&", release); } else { struct dump_dir *dd = dd_opendir(dump_dir_path, DD_OPEN_READONLY); if (!dd) xfunc_die(); problem_data_t *problem_data = create_problem_data_from_dump_dir(dd); dd_close(dd); if (!problem_data) xfunc_die(); /* create_problem_data_for_reporting already emitted error msg */ char *product, *version; map_string_t *osinfo = new_map_string(); problem_data_get_osinfo(problem_data, osinfo); parse_osinfo_for_rhts(osinfo, &product, &version); /* There are no bodhi updates for Rawhide */ bool rawhide = strcasecmp(version, "rawhide") == 0; if (!rawhide) query = strbuf_append_strf(query, "releases=f%s&", version); free(product); free(version); free_map_string(osinfo); if (rawhide) { strbuf_free(query); error_msg_and_die("Release \"Rawhide\" is not supported"); } } } if (argv[optind]) { char *escaped = g_uri_escape_string(argv[optind], NULL, 0); query = strbuf_append_strf(query, "packages=%s&", escaped); free(escaped); } if (query->buf[query->len - 1] == '&') query->buf[query->len - 1] = '\0'; log_warning(_("Searching for updates")); GHashTable *update_hash_tbl = bodhi_query_list(query->buf, release); strbuf_free(query); if (!update_hash_tbl || !g_hash_table_size(update_hash_tbl)) { log_warning(_("No updates for this package found")); /*if (update_hash_tbl) g_hash_table_unref(update_hash_tbl);*/ return 0; } GHashTableIter iter; char *name; struct bodhi *b; struct strbuf *q = strbuf_new(); g_hash_table_iter_init(&iter, update_hash_tbl); while (g_hash_table_iter_next(&iter, (void **) &name, (void **) &b)) { char *installed_pkg_nvr = rpm_get_nvr_by_pkg_name(name); if (installed_pkg_nvr && rpmvercmp(installed_pkg_nvr, b->nvr) >= 0) { log_info("Update %s is older or same as local version %s, skipping", b->nvr, installed_pkg_nvr); free(installed_pkg_nvr); continue; } free(installed_pkg_nvr); strbuf_append_strf(q, " %s", b->nvr); } /*g_hash_table_unref(update_hash_tbl);*/ if (!q->len) { /*strbuf_free(q);*/ log_warning(_("Local version of the package is newer than available updates")); return 0; } /* Message is split into text and command in order to make * translator's job easier */ /* We suggest the command which is most likely to exist on user's system, * and which is familiar to the largest population of users. * There are other tools (pkcon et al) which might be somewhat more * convenient (for example, they might be usable from non-root), but they * might be not present on the system, may evolve or be superseded, * as it did happen to yum. */ map_string_t *settings = new_map_string(); load_abrt_plugin_conf_file("CCpp.conf", settings); const char *value; strbuf_prepend_str(q, " update --enablerepo=fedora --enablerepo=updates --enablerepo=updates-testing"); value = get_map_string_item_or_NULL(settings, "PackageManager"); if (value) strbuf_prepend_str(q, value); else strbuf_prepend_str(q, DEFAULT_PACKAGE_MANAGER); free_map_string(settings); char *msg = xasprintf(_("An update exists which might fix your problem. " "You can install it by running: %s. " "Do you want to continue with reporting the bug?"), q->buf ); /*strbuf_free(q);*/ return ask_yes_no(msg) ? 0 : EXIT_STOP_EVENT_RUN; }
static char* idol_disc_recorder_plugin_write_video_project (IdolDiscRecorderPlugin *pi, char **error) { xmlTextWriter *project; xmlDocPtr doc = NULL; xmlSaveCtxt *save; xmlChar *escaped; gint success; char *title, *path, *uri; int fd; /* get a temporary path */ path = g_build_filename (g_get_tmp_dir (), "brasero-tmp-project-XXXXXX", NULL); fd = g_mkstemp (path); if (!fd) { g_free (path); *error = g_strdup (_("Unable to write a project.")); return NULL; } project = xmlNewTextWriterDoc (&doc, 0); if (!project) { g_remove (path); g_free (path); close (fd); *error = g_strdup (_("Unable to write a project.")); return NULL; } xmlTextWriterSetIndent (project, 1); xmlTextWriterSetIndentString (project, (xmlChar *) "\t"); success = xmlTextWriterStartDocument (project, NULL, "UTF8", NULL); if (success < 0) goto error; success = xmlTextWriterStartElement (project, (xmlChar *) "braseroproject"); if (success < 0) goto error; /* write the name of the version */ success = xmlTextWriterWriteElement (project, (xmlChar *) "version", (xmlChar *) "0.2"); if (success < 0) goto error; title = idol_get_short_title (pi->idol); if (title) { success = xmlTextWriterWriteElement (project, (xmlChar *) "label", (xmlChar *) title); g_free (title); if (success < 0) goto error; } success = xmlTextWriterStartElement (project, (xmlChar *) "track"); if (success < 0) goto error; success = xmlTextWriterStartElement (project, (xmlChar *) "video"); if (success < 0) goto error; uri = idol_get_current_mrl (pi->idol); escaped = (unsigned char *) g_uri_escape_string (uri, NULL, FALSE); g_free (uri); success = xmlTextWriterWriteElement (project, (xmlChar *) "uri", escaped); g_free (escaped); if (success == -1) goto error; /* start of the song always 0 */ success = xmlTextWriterWriteElement (project, (xmlChar *) "start", (xmlChar *) "0"); if (success == -1) goto error; success = xmlTextWriterEndElement (project); /* video */ if (success < 0) goto error; success = xmlTextWriterEndElement (project); /* track */ if (success < 0) goto error; success = xmlTextWriterEndElement (project); /* braseroproject */ if (success < 0) goto error; xmlTextWriterEndDocument (project); xmlFreeTextWriter (project); save = xmlSaveToFd (fd, "UTF8", XML_SAVE_FORMAT); xmlSaveDoc (save, doc); xmlSaveClose (save); xmlFreeDoc (doc); close (fd); return path; error: /* cleanup */ xmlTextWriterEndDocument (project); xmlFreeTextWriter (project); g_remove (path); g_free (path); close (fd); *error = g_strdup (_("Unable to write a project.")); return NULL; }
static gchar* rb_disc_recorder_plugin_write_audio_project (const gchar *name, GtkTreeModel *model, GError **error) { GtkTreeIter iter; xmlTextWriter *project; xmlDocPtr doc = NULL; xmlSaveCtxt *save; gint success; gchar *path; int fd; int use_errno = 0; if (! gtk_tree_model_get_iter_first (model, &iter)) { g_set_error (error, RB_RECORDER_ERROR, RB_RECORDER_ERROR_GENERAL, _("Unable to build an audio track list")); return NULL; } /* get a temporary path */ path = g_build_filename (g_get_tmp_dir (), "brasero-tmp-project-XXXXXX", NULL); fd = g_mkstemp (path); if (fd == -1) { g_set_error (error, RB_RECORDER_ERROR, RB_RECORDER_ERROR_GENERAL, _("Unable to write audio project file %s: %s"), path, g_strerror (errno)); rb_debug ("g_mkstemp failed"); g_free (path); return NULL; } project = xmlNewTextWriterDoc (&doc, 0); if (!project) { g_remove (path); g_free (path); close (fd); g_set_error (error, RB_RECORDER_ERROR, RB_RECORDER_ERROR_GENERAL, _("Unable to write audio project")); return NULL; } xmlTextWriterSetIndent (project, 1); xmlTextWriterSetIndentString (project, (xmlChar *) "\t"); success = xmlTextWriterStartDocument (project, NULL, "UTF8", NULL); if (success < 0) goto error; success = xmlTextWriterStartElement (project, (xmlChar *) "braseroproject"); if (success < 0) goto error; /* write the name of the version */ success = xmlTextWriterWriteElement (project, (xmlChar *) "version", (xmlChar *) "0.2"); if (success < 0) goto error; if (name) { success = xmlTextWriterWriteElement (project, (xmlChar *) "label", (xmlChar *) name); if (success < 0) goto error; } success = xmlTextWriterStartElement (project, (xmlChar *) "track"); if (success < 0) goto error; success = xmlTextWriterStartElement (project, (xmlChar *) "audio"); if (success < 0) goto error; do { RhythmDBEntry *entry; const char *str; xmlChar *escaped; gtk_tree_model_get (model, &iter, 0, &entry, -1); str = rhythmdb_entry_get_string (entry, RHYTHMDB_PROP_LOCATION); escaped = (xmlChar *) g_uri_escape_string (str, NULL, FALSE); success = xmlTextWriterWriteElement (project, (xmlChar *) "uri", escaped); g_free (escaped); if (success == -1) goto error; /* start of the song always 0 */ success = xmlTextWriterWriteElement (project, (xmlChar *) "start", (xmlChar *) "0"); if (success == -1) goto error; /* end of the song = duration (in seconds while brasero likes it * in nanoseconds =( ) */ /* Disable this for the moment and let brasero check the size * itself. In case the user chooses on the fly burning we need * a more precise duration or we'd end up burning the track * incompletely or with a big padding */ /* end = g_strdup_printf ("%"G_GINT64_FORMAT, (gint64) (song->duration * 1000000000LL)); success = xmlTextWriterWriteElement (project, (xmlChar *) "end", (xmlChar *) end); g_free (end); if (success == -1) goto error; */ str = rhythmdb_entry_get_string (entry, RHYTHMDB_PROP_TITLE); if (str) { escaped = (xmlChar *) g_uri_escape_string (str, NULL, FALSE); success = xmlTextWriterWriteElement (project, (xmlChar *) "title", escaped); g_free (escaped); if (success == -1) goto error; } str = rhythmdb_entry_get_string (entry, RHYTHMDB_PROP_ARTIST); if (str) { escaped = (xmlChar *) g_uri_escape_string (str, NULL, FALSE); success = xmlTextWriterWriteElement (project, (xmlChar *) "artist", escaped); g_free (escaped); if (success == -1) goto error; } /* if (song->composer) { escaped = (unsigned char *) g_uri_escape_string (song->composer, NULL, FALSE); success = xmlTextWriterWriteElement (project, (xmlChar *) "composer", escaped); g_free (escaped); if (success == -1) goto error; } */ } while (gtk_tree_model_iter_next (model, &iter)); success = xmlTextWriterEndElement (project); /* audio */ if (success < 0) goto error; success = xmlTextWriterEndElement (project); /* track */ if (success < 0) goto error; success = xmlTextWriterEndElement (project); /* braseroproject */ if (success < 0) goto error; success = xmlTextWriterEndDocument (project); if (success < 0) goto end_error; xmlFreeTextWriter (project); save = xmlSaveToFd (fd, "UTF8", XML_SAVE_FORMAT); if (save == NULL) goto save_error; if (xmlSaveDoc (save, doc) == -1) goto save_error; if (xmlSaveClose (save) == -1) { use_errno = errno; rb_debug ("xmlSaveClose failed"); goto save_error; } xmlFreeDoc (doc); if (close (fd) == -1) { use_errno = errno; rb_debug ("close() failed"); goto save_error; } return path; error: /* cleanup */ xmlTextWriterEndDocument (project); end_error: xmlFreeTextWriter (project); save_error: if (use_errno != 0) { g_set_error (error, RB_RECORDER_ERROR, RB_RECORDER_ERROR_GENERAL, _("Unable to write audio project file %s: %s"), path, g_strerror (use_errno)); } else { g_set_error (error, RB_RECORDER_ERROR, RB_RECORDER_ERROR_GENERAL, _("Unable to write audio project")); } g_remove (path); g_free (path); close (fd); return NULL; }
} JS_EXPORT_API char* dentry_get_uri(Entry* e) { TEST_GFILE(e, f) char* uri = g_file_get_uri(f); /* * some characters like ')', '(' may not be escaped * * ':' for scheme, like file:///...., the : cannot be escaped * '/' for path separator, should be escaped * '%' for the characters escaped, should be escaped */ char* escaped_uri = g_uri_escape_string(uri, ":/%", FALSE); g_free(uri); return escaped_uri; TEST_GAPP(e, app) char* encode = g_uri_escape_string(g_desktop_app_info_get_filename(G_DESKTOP_APP_INFO(app)), "/", FALSE); char* uri = g_strdup_printf("file://%s", encode); g_free(encode); return uri; g_message("uri:---%s---",uri); TEST_END } JS_EXPORT_API char* dentry_get_icon(Entry* e) {
static gchar * encode_uri (const gchar *uri) { return g_uri_escape_string (uri, NULL, TRUE); }
char* rygel_http_item_uri_to_string (RygelHTTPItemURI* self) { #line 462 "rygel-http-item-uri.c" char* result = NULL; gchar* _tmp1_; gint _data_size_; gint data_length1; gint _tmp0_; gchar* data; char* _tmp2_; char* _tmp3_; char* escaped; char* path; #line 93 "rygel-http-item-uri.vala" g_return_val_if_fail (self != NULL, NULL); #line 475 "rygel-http-item-uri.c" data = (_tmp1_ = string_to_utf8 (self->item_id, &_tmp0_), data_length1 = _tmp0_, _data_size_ = data_length1, _tmp1_); #line 98 "rygel-http-item-uri.vala" escaped = (_tmp3_ = g_uri_escape_string (_tmp2_ = g_base64_encode ((guchar*) data, data_length1), "", TRUE), _g_free0 (_tmp2_), _tmp3_); #line 101 "rygel-http-item-uri.vala" path = g_strconcat ("/item/", escaped, NULL); #line 103 "rygel-http-item-uri.vala" if (self->transcode_target != NULL) { #line 483 "rygel-http-item-uri.c" char* _tmp4_; char* _tmp6_; char* _tmp5_; #line 104 "rygel-http-item-uri.vala" escaped = (_tmp4_ = g_uri_escape_string (self->transcode_target, "", TRUE), _g_free0 (escaped), _tmp4_); #line 105 "rygel-http-item-uri.vala" path = (_tmp6_ = g_strconcat (path, _tmp5_ = g_strconcat ("/transcoded/", escaped, NULL), NULL), _g_free0 (path), _tmp6_); #line 491 "rygel-http-item-uri.c" _g_free0 (_tmp5_); } else { #line 106 "rygel-http-item-uri.vala" if (self->thumbnail_index >= 0) { #line 496 "rygel-http-item-uri.c" char* _tmp9_; char* _tmp8_; char* _tmp7_; #line 107 "rygel-http-item-uri.vala" path = (_tmp9_ = g_strconcat (path, _tmp8_ = g_strconcat ("/thumbnail/", _tmp7_ = g_strdup_printf ("%i", self->thumbnail_index), NULL), NULL), _g_free0 (path), _tmp9_); #line 502 "rygel-http-item-uri.c" _g_free0 (_tmp8_); _g_free0 (_tmp7_); } else { #line 108 "rygel-http-item-uri.vala" if (self->subtitle_index >= 0) { #line 508 "rygel-http-item-uri.c" char* _tmp12_; char* _tmp11_; char* _tmp10_; #line 109 "rygel-http-item-uri.vala" path = (_tmp12_ = g_strconcat (path, _tmp11_ = g_strconcat ("/subtitle/", _tmp10_ = g_strdup_printf ("%i", self->subtitle_index), NULL), NULL), _g_free0 (path), _tmp12_); #line 514 "rygel-http-item-uri.c" _g_free0 (_tmp11_); _g_free0 (_tmp10_); } } } result = rygel_http_item_uri_create_uri_for_path (self, path); data = (g_free (data), NULL); _g_free0 (escaped); _g_free0 (path); #line 112 "rygel-http-item-uri.vala" return result; #line 526 "rygel-http-item-uri.c" }
gint main (gint argc, gchar **argv) { GeoIP *geoip; const gchar *remote_addr; const gchar *path_info; gchar **path_parts; const gchar *country; gchar *action; gchar *input; gchar *domain; gchar *affiliate_code; gchar *p; gchar *dest_url = NULL; gboolean direct_url = FALSE; country = NULL; input = NULL; action = NULL; remote_addr = g_getenv ("REMOTE_ADDR"); path_parts = g_strsplit (path_info = g_getenv ("PATH_INFO"), "/", 4); if (path_parts != NULL && path_parts[0] != NULL && (country = path_parts[1]) != NULL && (action = path_parts[2]) != NULL) { input = path_parts[3]; } if ((p = strrchr (remote_addr, ':')) != NULL) { remote_addr = p + 1; } if (country == NULL || strcmp (country, "geo") == 0) { geoip = GeoIP_new (GEOIP_STANDARD); country = GeoIP_country_code_by_name (geoip, remote_addr); } // We ask that no one change these affiliate codes. ALL (100%) revenue // generated by these affiliate IDs is sent directly to the GNOME // Foundation. The GNOME Foundation controls/owns these affiliate IDs. // Please help support Free Software through the GNOME Foundation! if (country == NULL || strcmp (country, "US") == 0) { domain = "com"; affiliate_code = "banshee-20"; } else if (strcmp (country, "FR") == 0) { domain = "fr"; affiliate_code = "banshee-fr-21"; } else if (strcmp (country, "UK") == 0) { domain = "co.uk"; affiliate_code = "banshee-uk-21"; } else if (strcmp (country, "DE") == 0 || strcmp (country, "CH") == 0 || strcmp (country, "AT") == 0) { domain = "de"; affiliate_code = "banshee-de-21"; } else if (strcmp (country, "JP") == 0) { domain = "co.jp"; affiliate_code = "banshee-jp-22"; } else { domain = "com"; affiliate_code = "banshee-20"; } if (strcmp (action, "search") == 0) { dest_url = g_strdup_printf ("http://www.amazon.%s/s/ref=nb_sb_noss?url=search-alias%%3Ddigital-music&field-keywords=%s", domain, input); } else if (strcmp (action, "sign_out") == 0) { dest_url = g_strdup_printf ("http://www.amazon.%s/gp/help/customer/sign-out.html/ref=ya__lo?ie=UTF8&returnPath=%%2Fmp3", domain); } else if (strcmp (action, "about") == 0) { dest_url = g_strdup ("http://banshee.fm/about/revenue/"); direct_url = TRUE; } if (dest_url == NULL) { dest_url = g_strdup_printf ("http://www.amazon.%s/mp3/", domain); } if (direct_url) { printf ("Location: %s" "\n\n", dest_url); } else { printf ("Location: http://www.amazon.%s/gp/redirect.html?ie=UTF8&location=%s&tag=%s" "\n\n", domain, g_uri_escape_string (dest_url, NULL, TRUE), affiliate_code ); } return 0; }
static GdkPixbuf * get_poi_icon (poi_t *poi) { GdkPixbuf *icon; static GHashTable *icon_cache = NULL; static GdkPixbuf *poi_icon_default = NULL; if (!icon_cache) { /* Initialise icon-cache: */ icon_cache = g_hash_table_new (g_str_hash, g_str_equal); } if (!poi_icon_default) { /* Initialise the default POI icon: */ poi_icon_default = gdk_pixbuf_new_from_file_at_size (PACKAGE_PIXMAPS_DIR "/" PACKAGE "-poi.png", 25, 25, NULL); } icon = g_hash_table_lookup (icon_cache, poi->keywords); if (!icon) { char *icon_dir = g_build_filename (foxtrotgps_dir, "poi-icons", NULL); /* Not all characters that might be in a POI's name are suitable for use in icon-filenames, e.g.: path-separators need to be escaped so that a POI named something like "../../evil" doesn't result in us reading/writing a file somewhere where we shouldn't, and a number of characters need to be escaped to allow files to be stored on some filesystems like FAT. */ char *icon_basename = g_uri_escape_string (poi->keywords, NULL, TRUE); char *icon_path = g_build_filename (icon_dir, icon_basename, NULL); g_free (icon_basename); g_mkdir (icon_dir, 0777); g_free (icon_dir); if (!g_file_test (icon_path, G_FILE_TEST_EXISTS)) { pid_t mkvisualid_pid; int mkvisualid_status; char *autocache_dir = g_build_filename (global_home_dir, ".VisualIDs", PACKAGE, "poi-icons", NULL); g_mkdir_with_parents (autocache_dir, 0777); /* Free autocache_dir later--we need to pass it to mkvisualid, below... */ mkvisualid_pid = fork(); switch (mkvisualid_pid) { case 0: execlp ("mkvisualid", "mkvisualid", "--autocache", "--autocache-dir", autocache_dir, "--output", icon_path, "--linewidth=.1", "--outline-width=.2", /* Don't use glyph-types that are easily confused with streets: */ "--line=0", "--path=0", poi->keywords, NULL); _exit (1); /* execlp failed */ default: waitpid (mkvisualid_pid, &mkvisualid_status, 0); /* Fall through to cleanup... */ case -1: g_free (autocache_dir); } } icon = gdk_pixbuf_new_from_file_at_size (icon_path, 32, 32, NULL); /*^Note that this is slightly bigger than the `generic POI star' fallback-icon: we budget an additional 25% of the icon-radius for a border in case the icon needs one, e.g.: to ensure contrast against the map. */ g_free (icon_path); if (icon) { g_hash_table_insert (icon_cache, poi->keywords, icon); } } if (!icon) { icon = poi_icon_default; } return icon; }
// start bool cPlayback::Start(char *filename, int /*vpid*/, int /*vtype*/, int /*apid*/, int /*ac3*/, int /*duration*/) { lt_info( "%s:%s\n", FILENAME, __FUNCTION__); mAudioStream = 0; //create playback path char file[400] = {""}; bool isHTTP = false; if(!strncmp("http://", filename, 7)) { isHTTP = true; } else if(!strncmp("file://", filename, 7)) { isHTTP = false; } else if(!strncmp("upnp://", filename, 7)) { isHTTP = true; } else if(!strncmp("rtmp://", filename, 7)) { isHTTP = true; } else if(!strncmp("rtsp://", filename, 7)) { isHTTP = true; } else if(!strncmp("mms://", filename, 6)) { isHTTP = true; } else strcat(file, "file://"); strcat(file, filename); if (isHTTP) uri = g_uri_escape_string(filename, G_URI_RESERVED_CHARS_GENERIC_DELIMITERS, true); else uri = g_filename_to_uri(filename, NULL, NULL); lt_info("%s:%s - filename=%s\n", FILENAME, __FUNCTION__, filename); // create gst pipeline m_gst_playbin = gst_element_factory_make("playbin2", "playbin"); if(m_gst_playbin) { lt_info("%s:%s - m_gst_playbin\n", FILENAME, __FUNCTION__); guint flags; g_object_get(G_OBJECT (m_gst_playbin), "flags", &flags, NULL); /* avoid video conversion, let the (hardware) sinks handle that */ flags |= GST_PLAY_FLAG_NATIVE_VIDEO; /* volume control is done by hardware */ flags &= ~GST_PLAY_FLAG_SOFT_VOLUME; g_object_set(G_OBJECT (m_gst_playbin), "uri", uri, NULL); g_object_set(G_OBJECT (m_gst_playbin), "flags", flags, NULL); //gstbus handler GstBus * bus = gst_pipeline_get_bus( GST_PIPELINE(m_gst_playbin) ); gst_bus_set_sync_handler(bus, Gst_bus_call, NULL); gst_object_unref(bus); // state playing gst_element_set_state(GST_ELEMENT(m_gst_playbin), GST_STATE_PLAYING); playing = true; playstate = STATE_PLAY; } else { lt_info("%s:%s - failed to create GStreamer pipeline!, sorry we can not play\n", FILENAME, __FUNCTION__); playing = false; return false; } g_free(uri); // set buffer size /* increase the default 2 second / 2 MB buffer limitations to 5s / 5MB */ int m_buffer_size = 5*1024*1024; //g_object_set(G_OBJECT(m_gst_playbin), "buffer-duration", 5LL * GST_SECOND, NULL); g_object_set(G_OBJECT(m_gst_playbin), "buffer-size", m_buffer_size, NULL); return true; }
int main (int argc, char *argv[]) { gchar *uri = "http:\\\\[email protected]"; gchar *res_str = ":\\"; char *p; char *q; char *escape_str; p = g_uri_parse_scheme(uri); if(p) { if(strcmp(p, "http")) { std_log(LOG_FILENAME_LINE,"g_uri_parse_scheme didnt work as expected"); assert_failed = 1; } free(p); } else { std_log(LOG_FILENAME_LINE,"g_uri_parse_scheme returnd NULL. errno = %d", errno); assert_failed = 1; } //escape the uri escape_str = g_uri_escape_string(uri, res_str, TRUE); if(escape_str) { std_log(LOG_FILENAME_LINE, "escape string %s", escape_str); //convert back only a segment q = g_uri_unescape_segment(escape_str, escape_str+16, NULL); if(q) { std_log(LOG_FILENAME_LINE, "unescape segment string %s", q); if(strcmp(q, "http:\\\\www.no!")) { std_log(LOG_FILENAME_LINE,"g_uri_unescape_segment didnt work as expected"); assert_failed = 1; } free(q); } else { std_log(LOG_FILENAME_LINE,"g_uri_unescape_segment returned NULL. errno = %d", errno); assert_failed = 1; } //convert back the whole string p = g_uri_unescape_string(escape_str, NULL); if(p) { std_log(LOG_FILENAME_LINE, "unescape string %s", p); //converted string should be same as original uri string if(strcmp(p, uri)) { std_log(LOG_FILENAME_LINE,"g_uri_unescape_string returned NULL"); assert_failed = 1; } free(p); } else { std_log(LOG_FILENAME_LINE,"g_uri_unescape_string returned NULL. errno = %d", errno); assert_failed = 1; } free(escape_str); } else { std_log(LOG_FILENAME_LINE,"g_uri_escape_string returned NULL. errno = %d", errno); assert_failed = 1; } if(assert_failed) std_log(LOG_FILENAME_LINE,"Test Failed"); else std_log(LOG_FILENAME_LINE,"Test Successful"); create_xml(0); return 0; }
/* note that address_entry has already been validated => * both host and port (guaranteed to be a number in [0, 65535]) are set (family is optional) */ static gboolean try_tcp (GDBusServer *server, const gchar *address_entry, GHashTable *key_value_pairs, gboolean do_nonce, GError **error) { gboolean ret; const gchar *host; const gchar *port; gint port_num; GResolver *resolver; GList *resolved_addresses; GList *l; ret = FALSE; resolver = NULL; resolved_addresses = NULL; host = g_hash_table_lookup (key_value_pairs, "host"); port = g_hash_table_lookup (key_value_pairs, "port"); /* family = g_hash_table_lookup (key_value_pairs, "family"); */ if (g_hash_table_lookup (key_value_pairs, "noncefile") != NULL) { g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_INVALID_ARGUMENT, _("Cannot specify nonce file when creating a server")); goto out; } if (host == NULL) host = "localhost"; if (port == NULL) port = "0"; port_num = strtol (port, NULL, 10); resolver = g_resolver_get_default (); resolved_addresses = g_resolver_lookup_by_name (resolver, host, NULL, error); if (resolved_addresses == NULL) goto out; /* TODO: handle family */ for (l = resolved_addresses; l != NULL; l = l->next) { GInetAddress *address = G_INET_ADDRESS (l->data); GSocketAddress *socket_address; GSocketAddress *effective_address; socket_address = g_inet_socket_address_new (address, port_num); if (!g_socket_listener_add_address (server->listener, socket_address, G_SOCKET_TYPE_STREAM, G_SOCKET_PROTOCOL_TCP, NULL, /* GObject *source_object */ &effective_address, error)) { g_object_unref (socket_address); goto out; } if (port_num == 0) /* make sure we allocate the same port number for other listeners */ port_num = g_inet_socket_address_get_port (G_INET_SOCKET_ADDRESS (effective_address)); g_object_unref (effective_address); g_object_unref (socket_address); } if (do_nonce) { gint fd; guint n; gsize bytes_written; gsize bytes_remaining; char *file_escaped; server->nonce = g_new0 (guchar, 16); for (n = 0; n < 16; n++) server->nonce[n] = g_random_int_range (0, 256); fd = g_file_open_tmp ("gdbus-nonce-file-XXXXXX", &server->nonce_file, error); if (fd == -1) { g_socket_listener_close (server->listener); goto out; } again: bytes_written = 0; bytes_remaining = 16; while (bytes_remaining > 0) { gssize ret; ret = write (fd, server->nonce + bytes_written, bytes_remaining); if (ret == -1) { if (errno == EINTR) goto again; g_set_error (error, G_IO_ERROR, g_io_error_from_errno (errno), _("Error writing nonce file at '%s': %s"), server->nonce_file, strerror (errno)); goto out; } bytes_written += ret; bytes_remaining -= ret; } if (!g_close (fd, error)) goto out; file_escaped = g_uri_escape_string (server->nonce_file, "/\\", FALSE); server->client_address = g_strdup_printf ("nonce-tcp:host=%s,port=%d,noncefile=%s", host, port_num, file_escaped); g_free (file_escaped); } else { server->client_address = g_strdup_printf ("tcp:host=%s,port=%d", host, port_num); } server->is_using_listener = TRUE; ret = TRUE; out: g_list_free_full (resolved_addresses, g_object_unref); if (resolver) g_object_unref (resolver); return ret; }
static void got_more_files (GObject *source_object, GAsyncResult *res, gpointer user_data) { LoadBasenamesData *data = user_data; GList *infos, *l; GFileInfo *info; const char *name; gboolean append_slash; char *t; char *basename; if (data->completer == NULL) { /* Was cancelled */ load_basenames_data_free (data); return; } infos = g_file_enumerator_next_files_finish (data->enumerator, res, NULL); for (l = infos; l != NULL; l = l->next) { info = l->data; if (data->dirs_only && g_file_info_get_file_type (info) != G_FILE_TYPE_DIRECTORY) { g_object_unref (info); continue; } append_slash = g_file_info_get_file_type (info) == G_FILE_TYPE_DIRECTORY; name = g_file_info_get_name (info); if (name == NULL) { g_object_unref (info); continue; } if (data->should_escape) basename = g_uri_escape_string (name, G_URI_RESERVED_CHARS_ALLOWED_IN_PATH, TRUE); else /* If not should_escape, must be a local filename, convert to utf8 */ basename = g_filename_to_utf8 (name, -1, NULL, NULL, NULL); if (basename) { if (append_slash) { t = basename; basename = g_strconcat (basename, "/", NULL); g_free (t); } data->basenames = g_list_prepend (data->basenames, basename); } g_object_unref (info); } g_list_free (infos); if (infos) { /* Not last, get more files */ g_file_enumerator_next_files_async (data->enumerator, 100, 0, data->cancellable, got_more_files, data); } else { data->completer->basename_loader = NULL; if (data->completer->basenames_dir) g_object_unref (data->completer->basenames_dir); g_list_foreach (data->completer->basenames, (GFunc)g_free, NULL); g_list_free (data->completer->basenames); data->completer->basenames_dir = g_object_ref (data->dir); data->completer->basenames = data->basenames; data->completer->basenames_are_escaped = data->should_escape; data->basenames = NULL; g_file_enumerator_close_async (data->enumerator, 0, NULL, NULL, NULL); g_signal_emit (data->completer, signals[GOT_COMPLETION_DATA], 0); load_basenames_data_free (data); } }
char *http_client_uri_escape(const char *src) { return g_uri_escape_string(src, NULL, false); }