static GSocketAddress *
g_proxy_address_enumerator_next (GSocketAddressEnumerator *enumerator,
GCancellable *cancellable,
GError **error)
{
GProxyAddressEnumeratorPrivate *priv = GET_PRIVATE (enumerator);
GSocketAddress *result = NULL;
GError *first_error = NULL;
if (priv->proxies == NULL)
{
GProxyResolver *resolver = g_proxy_resolver_get_default ();
priv->proxies = g_proxy_resolver_lookup (resolver,
priv->dest_uri,
cancellable,
error);
priv->next_proxy = priv->proxies;
if (priv->proxies == NULL)
return NULL;
}
while (result == NULL && (*priv->next_proxy || priv->addr_enum))
{
gchar *dest_hostname;
gchar *dest_protocol;
GInetSocketAddress *inetsaddr;
GInetAddress *inetaddr;
guint16 port;
next_enumerator (priv);
if (!priv->addr_enum)
continue;
if (priv->proxy_address == NULL)
{
priv->proxy_address = g_socket_address_enumerator_next (
priv->addr_enum,
cancellable,
first_error ? NULL : &first_error);
}
if (priv->proxy_address == NULL)
{
g_object_unref (priv->addr_enum);
priv->addr_enum = NULL;
if (priv->dest_ips)
{
g_resolver_free_addresses (priv->dest_ips);
priv->dest_ips = NULL;
}
continue;
}
if (strcmp ("direct", priv->proxy_type) == 0)
{
result = priv->proxy_address;
priv->proxy_address = NULL;
continue;
}
if (!priv->supports_hostname)
{
GInetAddress *dest_ip;
if (!priv->dest_ips)
{
GResolver *resolver;
resolver = g_resolver_get_default();
priv->dest_ips = g_resolver_lookup_by_name (resolver,
priv->dest_hostname,
cancellable,
first_error ? NULL : &first_error);
g_object_unref (resolver);
if (!priv->dest_ips)
{
g_object_unref (priv->proxy_address);
priv->proxy_address = NULL;
continue;
}
}
if (!priv->next_dest_ip)
priv->next_dest_ip = priv->dest_ips;
dest_ip = G_INET_ADDRESS (priv->next_dest_ip->data);
dest_hostname = g_inet_address_to_string (dest_ip);
priv->next_dest_ip = g_list_next (priv->next_dest_ip);
}
else
{
dest_hostname = g_strdup (priv->dest_hostname);
}
dest_protocol = g_uri_parse_scheme (priv->dest_uri);
g_return_val_if_fail (G_IS_INET_SOCKET_ADDRESS (priv->proxy_address),
NULL);
inetsaddr = G_INET_SOCKET_ADDRESS (priv->proxy_address);
inetaddr = g_inet_socket_address_get_address (inetsaddr);
port = g_inet_socket_address_get_port (inetsaddr);
result = g_object_new (G_TYPE_PROXY_ADDRESS,
"address", inetaddr,
"port", port,
"protocol", priv->proxy_type,
"destination-protocol", dest_protocol,
"destination-hostname", dest_hostname,
"destination-port", priv->dest_port,
"username", priv->proxy_username,
"password", priv->proxy_password,
"uri", priv->proxy_uri,
NULL);
g_free (dest_hostname);
g_free (dest_protocol);
if (priv->supports_hostname || priv->next_dest_ip == NULL)
{
g_object_unref (priv->proxy_address);
priv->proxy_address = NULL;
}
}
if (result == NULL && first_error)
g_propagate_error (error, first_error);
else if (first_error)
g_error_free (first_error);
return result;
}
static void
return_result (GTask *task)
{
GProxyAddressEnumeratorPrivate *priv = g_task_get_task_data (task);
GSocketAddress *result;
if (strcmp ("direct", priv->proxy_type) == 0)
{
result = priv->proxy_address;
priv->proxy_address = NULL;
}
else
{
gchar *dest_hostname, *dest_protocol;
GInetSocketAddress *inetsaddr;
GInetAddress *inetaddr;
guint16 port;
if (!priv->supports_hostname)
{
GInetAddress *dest_ip;
if (!priv->next_dest_ip)
priv->next_dest_ip = priv->dest_ips;
dest_ip = G_INET_ADDRESS (priv->next_dest_ip->data);
dest_hostname = g_inet_address_to_string (dest_ip);
priv->next_dest_ip = g_list_next (priv->next_dest_ip);
}
else
{
dest_hostname = g_strdup (priv->dest_hostname);
}
dest_protocol = g_uri_parse_scheme (priv->dest_uri);
g_return_if_fail (G_IS_INET_SOCKET_ADDRESS (priv->proxy_address));
inetsaddr = G_INET_SOCKET_ADDRESS (priv->proxy_address);
inetaddr = g_inet_socket_address_get_address (inetsaddr);
port = g_inet_socket_address_get_port (inetsaddr);
result = g_object_new (G_TYPE_PROXY_ADDRESS,
"address", inetaddr,
"port", port,
"protocol", priv->proxy_type,
"destination-protocol", dest_protocol,
"destination-hostname", dest_hostname,
"destination-port", priv->dest_port,
"username", priv->proxy_username,
"password", priv->proxy_password,
"uri", priv->proxy_uri,
NULL);
g_free (dest_hostname);
g_free (dest_protocol);
if (priv->supports_hostname || priv->next_dest_ip == NULL)
{
g_object_unref (priv->proxy_address);
priv->proxy_address = NULL;
}
}
g_task_return_pointer (task, result, g_object_unref);
g_object_unref (task);
}
/**
* seahorse_util_uris_package
* @package: Package uri
* @uris: null-terminated array of uris to package
*
* Package uris into an archive. The uris must be local.
*
* Returns: Success or failure
*/
gboolean
seahorse_util_uris_package (const gchar* package, const char** uris)
{
GError* err = NULL;
gchar *out = NULL;
gint status;
gboolean r;
GString *str;
gchar *cmd;
gchar *t;
gchar *x;
GFile *file, *fpackage;
fpackage = g_file_new_for_uri (package);
t = g_file_get_path (fpackage);
x = g_shell_quote (t);
g_free (t);
/* create execution */
str = g_string_new ("");
g_string_printf (str, "file-roller --add-to=%s", x);
g_free(x);
while(*uris) {
x = g_uri_parse_scheme (*uris);
if (x)
file = g_file_new_for_uri (*uris);
else
file = g_file_new_for_path (*uris);
g_free (x);
t = g_file_get_path (file);
g_object_unref (file);
g_return_val_if_fail (t != NULL, FALSE);
x = g_shell_quote(t);
g_free(t);
g_string_append_printf (str, " %s", x);
g_free(x);
uris++;
}
/* Execute the command */
cmd = g_string_free (str, FALSE);
r = g_spawn_command_line_sync (cmd, &out, NULL, &status, &err);
g_free (cmd);
if (out) {
g_print (out, NULL);
g_free (out);
}
if (!r) {
seahorse_util_handle_error (err, _("Couldn't run file-roller"));
return FALSE;
}
if(!(WIFEXITED(status) && WEXITSTATUS(status) == 0)) {
seahorse_util_show_error(NULL, _("Couldn't package files"),
_("The file-roller process did not complete successfully"));
return FALSE;
}
t = g_file_get_path (fpackage);
if (t != NULL) {
g_chmod (t, S_IRUSR | S_IWUSR);
g_free (t);
}
return TRUE;
}
/**
* fm_launch_files
* @ctx: (allow-none): a launch context
* @file_infos: (element-type FmFileInfo): files to launch
* @launcher: #FmFileLauncher with callbacks
* @user_data: data supplied for callbacks
*
* Launches files using callbacks in @launcher.
*
* Returns: %TRUE in case of success.
*
* Since: 0.1.0
*/
gboolean fm_launch_files(GAppLaunchContext* ctx, GList* file_infos, FmFileLauncher* launcher, gpointer user_data)
{
GList* l;
GHashTable* hash = g_hash_table_new_full(g_str_hash, g_str_equal, NULL, NULL);
GList *folders = NULL;
FmFileInfo* fi;
GList *targets = NULL;
GError* err = NULL;
GAppInfo* app;
const char* type;
for(l = file_infos; l; l=l->next)
{
GList* fis;
char *filename, *scheme;
const char *target = NULL;
fi = (FmFileInfo*)l->data;
/* special handling for shortcuts */
if (!fm_file_info_is_symlink(fi))
/* symlinks also has fi->target, but we only handle shortcuts here. */
target = fm_file_info_get_target(fi);
if (launcher->open_folder && fm_file_info_is_dir(fi))
{
/* special handling for shortcuts */
if(target)
{
fi = _fetch_file_info_for_shortcut(fm_file_info_get_target(fi),
ctx, launcher, user_data);
if (fi == NULL)
/* error was shown by job already */
continue;
targets = g_list_prepend(targets, fi);
}
folders = g_list_prepend(folders, fi);
}
else if (fm_file_info_is_desktop_entry(fi))
{
_launch_desktop_entry:
if (!target)
filename = fm_path_to_str(fm_file_info_get_path(fi));
fm_launch_desktop_entry(ctx, target ? target : filename, NULL,
launcher, user_data);
if (!target)
g_free(filename);
continue;
}
else
{
FmPath* path = fm_file_info_get_path(fi);
FmMimeType* mime_type = NULL;
if(fm_path_is_native(path))
{
/* special handling for shortcuts */
if (target)
{
if (fm_file_info_get_mime_type(fi) == _fm_mime_type_get_inode_x_shortcut())
/* if we already know MIME type then use it instead */
{
scheme = g_uri_parse_scheme(target);
if (scheme)
{
/* FIXME: this is rough! */
if (strcmp(scheme, "file") != 0 &&
strcmp(scheme, "trash") != 0 &&
strcmp(scheme, "network") != 0 &&
strcmp(scheme, "computer") != 0 &&
strcmp(scheme, "menu") != 0)
{
/* we don't support this URI internally, try GIO */
app = g_app_info_get_default_for_uri_scheme(scheme);
if (app)
{
fis = g_list_prepend(NULL, (char *)target);
fm_app_info_launch_uris(app, fis, ctx, &err);
g_list_free(fis);
g_object_unref(app);
}
else if (launcher->error)
g_set_error(&err, G_IO_ERROR, G_IO_ERROR_FAILED,
_("No default application is set to launch URIs %s://"),
scheme);
if (err)
{
launcher->error(ctx, err, NULL, user_data);
g_clear_error(&err);
}
g_free(scheme);
continue;
}
g_free(scheme);
}
}
else
mime_type = fm_file_info_get_mime_type(fi);
/* retrieve file info for target otherwise and handle it */
fi = _fetch_file_info_for_shortcut(target, ctx, launcher, user_data);
if (fi == NULL)
/* error was shown by job already */
continue;
targets = g_list_prepend(targets, fi);
path = fm_file_info_get_path(fi);
/* special handling for desktop entries */
if (fm_file_info_is_desktop_entry(fi))
goto _launch_desktop_entry;
}
if(fm_file_info_is_executable_type(fi))
{
/* if it's an executable file, directly execute it. */
filename = fm_path_to_str(path);
/* FIXME: we need to use eaccess/euidaccess here. */
if(g_file_test(filename, G_FILE_TEST_IS_EXECUTABLE))
{
if(launcher->exec_file)
{
FmFileLauncherExecAction act = launcher->exec_file(fi, user_data);
GAppInfoCreateFlags flags = 0;
switch(act)
{
case FM_FILE_LAUNCHER_EXEC_IN_TERMINAL:
flags |= G_APP_INFO_CREATE_NEEDS_TERMINAL;
/* NOTE: no break here */
case FM_FILE_LAUNCHER_EXEC:
{
/* filename may contain spaces. Fix #3143296 */
char* quoted = g_shell_quote(filename);
app = fm_app_info_create_from_commandline(quoted, NULL, flags, NULL);
g_free(quoted);
if(app)
{
char* run_path = g_path_get_dirname(filename);
char* cwd = NULL;
/* bug #3589641: scripts are ran from $HOME.
since GIO launcher is kinda ugly - it has
no means to set running directory so we
do workaround - change directory to it */
if(run_path && strcmp(run_path, "."))
{
cwd = g_get_current_dir();
if(chdir(run_path) != 0)
{
g_free(cwd);
cwd = NULL;
if (launcher->error)
{
g_set_error(&err, G_IO_ERROR,
g_io_error_from_errno(errno),
_("Cannot set working directory to '%s': %s"),
run_path, g_strerror(errno));
launcher->error(ctx, err, NULL, user_data);
g_clear_error(&err);
}
}
}
g_free(run_path);
if(!fm_app_info_launch(app, NULL, ctx, &err))
{
if(launcher->error)
launcher->error(ctx, err, NULL, user_data);
g_error_free(err);
err = NULL;
}
if(cwd) /* return back */
{
if(chdir(cwd) != 0)
g_warning("fm_launch_files(): chdir() failed");
g_free(cwd);
}
g_object_unref(app);
continue;
}
break;
}
case FM_FILE_LAUNCHER_EXEC_OPEN:
break;
case FM_FILE_LAUNCHER_EXEC_CANCEL:
continue;
}
}
}
g_free(filename);
}
}
if (mime_type == NULL)
mime_type = fm_file_info_get_mime_type(fi);
if(mime_type && (type = fm_mime_type_get_type(mime_type)))
{
fis = g_hash_table_lookup(hash, type);
fis = g_list_prepend(fis, fi);
g_hash_table_insert(hash, (gpointer)type, fis);
}
else if (launcher->error)
{
g_set_error(&err, G_IO_ERROR, G_IO_ERROR_FAILED,
_("Could not determine content type of file '%s' to launch it"),
fm_file_info_get_disp_name(fi));
launcher->error(ctx, err, NULL, user_data);
g_clear_error(&err);
}
}
}
if(g_hash_table_size(hash) > 0)
{
GHashTableIter it;
GList* fis;
g_hash_table_iter_init(&it, hash);
while(g_hash_table_iter_next(&it, (void**)&type, (void**)&fis))
{
GAppInfo* app = g_app_info_get_default_for_type(type, FALSE);
if(!app)
{
if(launcher->get_app)
{
FmMimeType* mime_type = fm_file_info_get_mime_type((FmFileInfo*)fis->data);
app = launcher->get_app(fis, mime_type, user_data, NULL);
}
}
if(app)
{
for(l=fis; l; l=l->next)
{
char* uri;
fi = (FmFileInfo*)l->data;
/* special handling for shortcuts */
if (fm_file_info_is_shortcut(fi))
uri = g_strdup(fm_file_info_get_target(fi));
else
uri = fm_path_to_uri(fm_file_info_get_path(fi));
l->data = uri;
}
fis = g_list_reverse(fis);
fm_app_info_launch_uris(app, fis, ctx, &err);
/* free URI strings */
g_list_foreach(fis, (GFunc)g_free, NULL);
g_object_unref(app);
}
else if (launcher->error)
g_set_error(&err, G_IO_ERROR, G_IO_ERROR_FAILED,
_("No default application is set for MIME type %s"),
type);
if (err)
{
launcher->error(ctx, err, NULL, user_data);
g_clear_error(&err);
}
g_list_free(fis);
}
}
g_hash_table_destroy(hash);
if(folders)
{
folders = g_list_reverse(folders);
if(launcher->open_folder)
{
launcher->open_folder(ctx, folders, user_data, &err);
if(err)
{
if(launcher->error)
launcher->error(ctx, err, NULL, user_data);
g_error_free(err);
err = NULL;
}
}
g_list_free(folders);
}
g_list_free_full(targets, (GDestroyNotify)fm_file_info_unref);
return TRUE;
}
void
caja_launch_application_by_uri (GAppInfo *application,
GList *uris,
GtkWindow *parent_window)
{
char *uri, *uri_scheme;
GList *locations, *l;
GFile *location;
CajaFile *file;
gboolean result;
GError *error;
GdkDisplay *display;
GdkAppLaunchContext *launch_context;
CajaIconInfo *icon;
int count, total;
g_assert (uris != NULL);
/* count the number of uris with local paths */
count = 0;
total = g_list_length (uris);
locations = NULL;
for (l = uris; l != NULL; l = l->next)
{
uri = l->data;
location = g_file_new_for_uri (uri);
if (g_file_is_native (location))
{
count++;
}
locations = g_list_prepend (locations, location);
}
locations = g_list_reverse (locations);
if (parent_window != NULL) {
display = gtk_widget_get_display (GTK_WIDGET (parent_window));
} else {
display = gdk_display_get_default ();
}
launch_context = gdk_display_get_app_launch_context (display);
if (parent_window != NULL) {
gdk_app_launch_context_set_screen (launch_context,
gtk_window_get_screen (parent_window));
}
file = caja_file_get_by_uri (uris->data);
icon = caja_file_get_icon (file, 48, 0);
caja_file_unref (file);
if (icon)
{
gdk_app_launch_context_set_icon_name (launch_context,
caja_icon_info_get_used_name (icon));
g_object_unref (icon);
}
error = NULL;
result = g_desktop_app_info_launch_uris_as_manager (G_DESKTOP_APP_INFO (application),
uris,
G_APP_LAUNCH_CONTEXT (launch_context),
G_SPAWN_SEARCH_PATH | G_SPAWN_DO_NOT_REAP_CHILD,
NULL, NULL,
gather_pid_callback, application,
&error);
g_object_unref (launch_context);
if (!result)
{
if (error->domain == G_IO_ERROR &&
error->code == G_IO_ERROR_NOT_SUPPORTED)
{
uri_scheme = g_uri_parse_scheme (uris->data);
application_cannot_open_location (application,
file,
uri_scheme,
parent_window);
g_free (uri_scheme);
}
else
{
#ifdef NEW_MIME_COMPLETE
caja_program_chooser_show_invalid_message
(MATE_VFS_MIME_ACTION_TYPE_APPLICATION, file, parent_window);
#else
g_warning ("Cannot open app: %s\n", error->message);
#endif
}
g_error_free (error);
}
else
{
for (l = uris; l != NULL; l = l->next)
{
file = caja_file_get_by_uri (l->data);
caja_recent_add_file (file, application);
caja_file_unref (file);
}
}
g_list_free_full (locations, g_object_unref);
}
static gint32
webpage_capture (void)
{
gint32 image = -1;
gchar *scheme;
GtkWidget *window;
GtkWidget *view;
WebKitWebSettings *settings;
char *ua_old;
char *ua;
if (webpagevals.pixbuf)
{
g_object_unref (webpagevals.pixbuf);
webpagevals.pixbuf = NULL;
}
if (webpagevals.error)
{
g_error_free (webpagevals.error);
webpagevals.error = NULL;
}
if ((!webpagevals.url) ||
(strlen (webpagevals.url) == 0))
{
g_set_error (&webpagevals.error, 0, 0, _("No URL was specified"));
return -1;
}
scheme = g_uri_parse_scheme (webpagevals.url);
if (!scheme)
{
char *url;
/* If we were not given a well-formed URL, make one. */
url = g_strconcat ("http://", webpagevals.url, NULL);
g_free (webpagevals.url);
webpagevals.url = url;
g_free (scheme);
}
if (webpagevals.width < 32)
{
g_warning ("Width '%d' is too small. Clamped to 32.",
webpagevals.width);
webpagevals.width = 32;
}
else if (webpagevals.width > 8192)
{
g_warning ("Width '%d' is too large. Clamped to 8192.",
webpagevals.width);
webpagevals.width = 8192;
}
window = gtk_offscreen_window_new ();
gtk_widget_show (window);
view = webkit_web_view_new ();
gtk_widget_show (view);
gtk_widget_set_size_request (view, webpagevals.width, -1);
gtk_container_add (GTK_CONTAINER (window), view);
/* Append "GIMP/<GIMP_VERSION>" to the user agent string */
settings = webkit_web_view_get_settings (WEBKIT_WEB_VIEW (view));
g_object_get (settings,
"user-agent", &ua_old,
NULL);
ua = g_strdup_printf ("%s GIMP/%s", ua_old, GIMP_VERSION);
g_object_set (settings,
"user-agent", ua,
NULL);
g_free (ua_old);
g_free (ua);
/* Set font size */
g_object_set (settings,
"default-font-size", webpagevals.font_size,
NULL);
g_signal_connect (view, "notify::progress",
G_CALLBACK (notify_progress_cb),
window);
g_signal_connect (view, "load-error",
G_CALLBACK (load_error_cb),
window);
g_signal_connect (view, "notify::load-status",
G_CALLBACK (notify_load_status_cb),
window);
gimp_progress_init_printf (_("Downloading webpage '%s'"), webpagevals.url);
webkit_web_view_open (WEBKIT_WEB_VIEW (view),
webpagevals.url);
gtk_main ();
gtk_widget_destroy (window);
gimp_progress_update (1.0);
if (webpagevals.pixbuf)
{
gint width;
gint height;
gint32 layer;
gimp_progress_init_printf (_("Transferring webpage image for '%s'"),
webpagevals.url);
width = gdk_pixbuf_get_width (webpagevals.pixbuf);
height = gdk_pixbuf_get_height (webpagevals.pixbuf);
image = gimp_image_new (width, height, GIMP_RGB);
gimp_image_undo_disable (image);
layer = gimp_layer_new_from_pixbuf (image, _("Webpage"), webpagevals.pixbuf,
100, GIMP_NORMAL_MODE, 0.0, 1.0);
gimp_image_insert_layer (image, layer, -1, 0);
gimp_image_undo_enable (image);
g_object_unref (webpagevals.pixbuf);
webpagevals.pixbuf = NULL;
gimp_progress_update (1.0);
}
return image;
}
/* This or something equivalent will eventually go into glib/guri.h */
gboolean
nautilus_uri_parse (const char *uri,
char **host,
guint16 *port,
char **userinfo)
{
char *tmp_str;
const char *start, *p;
char c;
g_return_val_if_fail (uri != NULL, FALSE);
if (host)
*host = NULL;
if (port)
*port = 0;
if (userinfo)
*userinfo = NULL;
/* From RFC 3986 Decodes:
* URI = scheme ":" hier-part [ "?" query ] [ "#" fragment ]
* hier-part = "//" authority path-abempty
* path-abempty = *( "/" segment )
* authority = [ userinfo "@" ] host [ ":" port ]
*/
/* Check we have a valid scheme */
tmp_str = g_uri_parse_scheme (uri);
if (tmp_str == NULL)
return FALSE;
g_free (tmp_str);
/* Decode hier-part:
* hier-part = "//" authority path-abempty
*/
p = uri;
start = strstr (p, "//");
if (start == NULL)
return FALSE;
start += 2;
if (strchr (start, '@') != NULL)
{
/* Decode userinfo:
* userinfo = *( unreserved / pct-encoded / sub-delims / ":" )
* unreserved = ALPHA / DIGIT / "-" / "." / "_" / "~"
* pct-encoded = "%" HEXDIG HEXDIG
*/
p = start;
while (1)
{
c = *p++;
if (c == '@')
break;
/* pct-encoded */
if (c == '%')
{
if (!(g_ascii_isxdigit (p[0]) ||
g_ascii_isxdigit (p[1])))
return FALSE;
p++;
continue;
}
/* unreserved / sub-delims / : */
if (!(g_ascii_isalnum (c) ||
strchr (G_URI_OTHER_UNRESERVED, c) ||
strchr (G_URI_RESERVED_CHARS_SUBCOMPONENT_DELIMITERS, c) ||
c == ':'))
return FALSE;
}
if (userinfo)
*userinfo = g_strndup (start, p - start - 1);
start = p;
}
else
{
p = start;
}
/* decode host:
* host = IP-literal / IPv4address / reg-name
* reg-name = *( unreserved / pct-encoded / sub-delims )
*/
/* If IPv6 or IPvFuture */
if (*p == '[')
{
start++;
p++;
while (1)
{
c = *p++;
if (c == ']')
break;
/* unreserved / sub-delims */
if (!(g_ascii_isalnum (c) ||
strchr (G_URI_OTHER_UNRESERVED, c) ||
strchr (G_URI_RESERVED_CHARS_SUBCOMPONENT_DELIMITERS, c) ||
c == ':' ||
c == '.'))
goto error;
}
}
else
{
while (1)
{
c = *p++;
if (c == ':' ||
c == '/' ||
c == '?' ||
c == '#' ||
c == '\0')
break;
/* pct-encoded */
if (c == '%')
{
if (!(g_ascii_isxdigit (p[0]) ||
g_ascii_isxdigit (p[1])))
goto error;
p++;
continue;
}
/* unreserved / sub-delims */
if (!(g_ascii_isalnum (c) ||
strchr (G_URI_OTHER_UNRESERVED, c) ||
strchr (G_URI_RESERVED_CHARS_SUBCOMPONENT_DELIMITERS, c)))
goto error;
}
}
if (host)
*host = g_uri_unescape_segment (start, p - 1, NULL);
if (c == ':')
{
/* Decode pot:
* port = *DIGIT
*/
guint tmp = 0;
while (1)
{
c = *p++;
if (c == '/' ||
c == '?' ||
c == '#' ||
c == '\0')
break;
if (!g_ascii_isdigit (c))
goto error;
tmp = (tmp * 10) + (c - '0');
if (tmp > 65535)
goto error;
}
if (port)
*port = (guint16) tmp;
}
return TRUE;
error:
if (host && *host)
{
g_free (*host);
*host = NULL;
}
if (userinfo && *userinfo)
{
g_free (*userinfo);
*userinfo = NULL;
}
return FALSE;
}
