/*
* 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);
}
