GVfsFtpConnection *
g_vfs_ftp_connection_new (GSocketConnectable *addr,
GCancellable * cancellable,
GError ** error)
{
GVfsFtpConnection *conn;
g_return_val_if_fail (G_IS_SOCKET_CONNECTABLE (addr), NULL);
conn = g_slice_new0 (GVfsFtpConnection);
conn->client = g_socket_client_new ();
conn->debug_id = g_atomic_int_add (&debug_id, 1);
conn->commands = G_IO_STREAM (g_socket_client_connect (conn->client,
addr,
cancellable,
error));
if (conn->commands == NULL)
{
g_object_unref (conn->client);
g_slice_free (GVfsFtpConnection, conn);
return NULL;
}
conn->connection = G_SOCKET_CONNECTION (conn->commands);
enable_nodelay (conn->connection);
enable_keepalive (conn->connection);
create_input_stream (conn);
/* The first thing that needs to happen is receiving the welcome message */
conn->waiting_for_reply = TRUE;
return conn;
}
/**
* soup_socket_connect_sync:
* @sock: a client #SoupSocket (which must not already be connected)
* @cancellable: a #GCancellable, or %NULL
*
* Attempt to synchronously connect @sock to its remote address.
*
* If @cancellable is non-%NULL, it can be used to cancel the
* connection, in which case soup_socket_connect_sync() will return
* %SOUP_STATUS_CANCELLED.
*
* Return value: a success or failure code.
**/
guint
soup_socket_connect_sync (SoupSocket *sock, GCancellable *cancellable)
{
SoupSocketPrivate *priv;
GSocketClient *client;
GSocketConnection *conn;
GError *error = NULL;
g_return_val_if_fail (SOUP_IS_SOCKET (sock), SOUP_STATUS_MALFORMED);
priv = SOUP_SOCKET_GET_PRIVATE (sock);
g_return_val_if_fail (!priv->is_server, SOUP_STATUS_MALFORMED);
g_return_val_if_fail (priv->gsock == NULL, SOUP_STATUS_MALFORMED);
g_return_val_if_fail (priv->remote_addr != NULL, SOUP_STATUS_MALFORMED);
if (cancellable)
g_object_ref (cancellable);
else
cancellable = g_cancellable_new ();
priv->connect_cancel = cancellable;
client = new_socket_client (sock);
conn = g_socket_client_connect (client,
G_SOCKET_CONNECTABLE (priv->remote_addr),
priv->connect_cancel, &error);
g_object_unref (client);
return socket_connected (sock, conn, error);
}
static GSocketConnection *_s52_init_sock(char *hostname, int port)
{
g_print("s52ais:_init_s52_sock(): starting ..\n");
GSocketClient *client = g_socket_client_new();
if (NULL == client) {
g_print("s52ais:_s52_init_sock(): client NULL ..\n");
return NULL;
}
GSocketConnectable *connectable = g_network_address_new(hostname, port);
if (NULL == connectable) {
g_print("s52ais:_s52_init_sock(): connectable NULL ..\n");
return NULL;
}
GError *error = NULL;
GSocketConnection *conn = g_socket_client_connect(client, connectable, NULL, &error);
g_object_unref(client);
g_object_unref(connectable);
if (NULL != error) {
g_print("s52ais:_s52_init_sock():ERROR: %s\n", error->message);
return NULL;
}
g_print("s52ais:_s52_init_sock(): connected to hostname:%s, port:%i\n", hostname, port);
return conn;
}
GVfsFtpConnection *
g_vfs_ftp_connection_new (GSocketConnectable *addr,
GCancellable * cancellable,
GError ** error)
{
GVfsFtpConnection *conn;
g_return_val_if_fail (G_IS_SOCKET_CONNECTABLE (addr), NULL);
conn = g_slice_new0 (GVfsFtpConnection);
conn->client = g_socket_client_new ();
conn->debug_id = g_atomic_int_exchange_and_add (&debug_id, 1);
conn->commands = G_IO_STREAM (g_socket_client_connect (conn->client,
addr,
cancellable,
error));
if (conn->commands == NULL)
{
g_object_unref (conn->client);
g_slice_free (GVfsFtpConnection, conn);
return NULL;
}
enable_keepalive (G_SOCKET_CONNECTION (conn->commands));
conn->commands_in = G_DATA_INPUT_STREAM (g_data_input_stream_new (g_io_stream_get_input_stream (conn->commands)));
g_data_input_stream_set_newline_type (conn->commands_in, G_DATA_STREAM_NEWLINE_TYPE_CR_LF);
/* The first thing that needs to happen is receiving the welcome message */
conn->waiting_for_reply = TRUE;
return conn;
}
static VALUE
rg_connect(int argc, VALUE *argv, VALUE self)
{
VALUE connectable, cancellable;
GError *error = NULL;
GSocketConnection *connection;
rb_scan_args(argc, argv, "11", &connectable, &cancellable);
connection = g_socket_client_connect(_SELF(self),
RVAL2GSOCKETCONNECTABLE(connectable),
RVAL2GCANCELLABLE(cancellable),
&error);
if (connection == NULL)
rbgio_raise_error(error);
return GOBJ2RVAL_UNREF(connection);
}
gboolean
g_vfs_ftp_connection_open_data_connection (GVfsFtpConnection *conn,
GSocketAddress * addr,
GCancellable * cancellable,
GError ** error)
{
g_return_val_if_fail (conn != NULL, FALSE);
g_return_val_if_fail (conn->data == NULL, FALSE);
g_vfs_ftp_connection_stop_listening (conn);
conn->data = G_IO_STREAM (g_socket_client_connect (conn->client,
G_SOCKET_CONNECTABLE (addr),
cancellable,
error));
return conn->data != NULL;
}
GVfsAfpReply *
g_vfs_afp_connection_get_server_info (GVfsAfpConnection *afp_connection,
GCancellable *cancellable,
GError **error)
{
GVfsAfpConnectionPrivate *priv = afp_connection->priv;
GSocketClient *client;
GIOStream *conn;
gboolean res;
DSIHeader dsi_header;
char *data;
client = g_socket_client_new ();
conn = G_IO_STREAM (g_socket_client_connect (client, priv->addr, cancellable, error));
g_object_unref (client);
if (!conn)
return NULL;
res = send_request_sync (g_io_stream_get_output_stream (conn), DSI_GET_STATUS,
0, 0, 0, NULL, cancellable, error);
if (!res)
{
g_object_unref (conn);
return NULL;
}
res = read_reply_sync (g_io_stream_get_input_stream (conn), &dsi_header,
&data, cancellable, error);
if (!res)
{
g_object_unref (conn);
return NULL;
}
g_object_unref (conn);
return g_vfs_afp_reply_new (dsi_header.errorCode, data,
dsi_header.totalDataLength, TRUE);
}
static void
dasom_im_init (DasomIM *im)
{
g_debug (G_STRLOC ": %s", G_STRFUNC);
GSocketClient *client;
GSocketAddress *address;
GSocket *socket;
GError *error = NULL;
address = g_unix_socket_address_new_with_type (DASOM_ADDRESS, -1,
G_UNIX_SOCKET_ADDRESS_ABSTRACT);
client = g_socket_client_new ();
im->connection = g_socket_client_connect (client,
G_SOCKET_CONNECTABLE (address),
NULL, &error);
g_object_unref (address);
g_object_unref (client);
if (im->connection == NULL)
{
g_critical (G_STRLOC ": %s: %s", G_STRFUNC, error->message);
g_clear_error (&error);
return;
}
socket = g_socket_connection_get_socket (im->connection);
if (!socket)
{
g_critical (G_STRLOC ": %s: %s", G_STRFUNC, "Can't get socket");
return;
}
DasomMessage *message;
DasomConnectionType type = DASOM_CONNECTION_DASOM_IM;
dasom_send_message (socket, DASOM_MESSAGE_CONNECT, &type, sizeof (DasomConnectionType), NULL);
g_socket_condition_wait (socket, G_IO_IN, NULL, NULL);
message = dasom_recv_message (socket);
if (G_UNLIKELY (message == NULL ||
message->header->type != DASOM_MESSAGE_CONNECT_REPLY))
{
dasom_message_unref (message);
g_error ("Couldn't connect to dasom daemon");
}
dasom_message_unref (message);
im->result = g_slice_new0 (DasomResult);
im->preedit_string = g_strdup ("");
GMutex mutex;
g_mutex_init (&mutex);
g_mutex_lock (&mutex);
if (G_UNLIKELY (dasom_im_sockets_context == NULL))
{
dasom_im_sockets_context = g_main_context_new ();
dasom_im_sockets_context_ref_count++;
}
else
{
dasom_im_sockets_context = g_main_context_ref (dasom_im_sockets_context);
dasom_im_sockets_context_ref_count++;
}
g_mutex_unlock (&mutex);
/* when g_main_context_iteration(), iterate only sockets */
im->sockets_context_source = g_socket_create_source (socket, G_IO_IN, NULL);
g_source_set_can_recurse (im->sockets_context_source, TRUE);
g_source_attach (im->sockets_context_source, dasom_im_sockets_context);
g_source_set_callback (im->sockets_context_source,
(GSourceFunc) on_incoming_message,
im, NULL);
im->default_context_source = g_socket_create_source (socket, G_IO_IN, NULL);
g_source_set_can_recurse (im->default_context_source, TRUE);
g_source_set_callback (im->default_context_source,
(GSourceFunc) on_incoming_message, im, NULL);
g_source_attach (im->default_context_source, NULL);
}
/* TODO: Declare an extension point called GDBusTransport (or similar)
* and move code below to extensions implementing said extension
* point. That way we can implement a D-Bus transport over X11 without
* making libgio link to libX11...
*/
static GIOStream *
g_dbus_address_connect (const gchar *address_entry,
const gchar *transport_name,
GHashTable *key_value_pairs,
GCancellable *cancellable,
GError **error)
{
GIOStream *ret;
GSocketConnectable *connectable;
const gchar *nonce_file;
connectable = NULL;
ret = NULL;
nonce_file = NULL;
if (FALSE)
{
}
#ifdef G_OS_UNIX
else if (g_strcmp0 (transport_name, "unix") == 0)
{
const gchar *path;
const gchar *abstract;
path = g_hash_table_lookup (key_value_pairs, "path");
abstract = g_hash_table_lookup (key_value_pairs, "abstract");
if ((path == NULL && abstract == NULL) || (path != NULL && abstract != NULL))
{
g_set_error (error,
G_IO_ERROR,
G_IO_ERROR_INVALID_ARGUMENT,
_("Error in address '%s' - the unix transport requires exactly one of the "
"keys 'path' or 'abstract' to be set"),
address_entry);
}
else if (path != NULL)
{
connectable = G_SOCKET_CONNECTABLE (g_unix_socket_address_new (path));
}
else if (abstract != NULL)
{
connectable = G_SOCKET_CONNECTABLE (g_unix_socket_address_new_with_type (abstract,
-1,
G_UNIX_SOCKET_ADDRESS_ABSTRACT));
}
else
{
g_assert_not_reached ();
}
}
#endif
else if (g_strcmp0 (transport_name, "tcp") == 0 || g_strcmp0 (transport_name, "nonce-tcp") == 0)
{
const gchar *s;
const gchar *host;
glong port;
gchar *endp;
gboolean is_nonce;
is_nonce = (g_strcmp0 (transport_name, "nonce-tcp") == 0);
host = g_hash_table_lookup (key_value_pairs, "host");
if (host == NULL)
{
g_set_error (error,
G_IO_ERROR,
G_IO_ERROR_INVALID_ARGUMENT,
_("Error in address '%s' - the host attribute is missing or malformed"),
address_entry);
goto out;
}
s = g_hash_table_lookup (key_value_pairs, "port");
if (s == NULL)
s = "0";
port = strtol (s, &endp, 10);
if ((*s == '\0' || *endp != '\0') || port < 0 || port >= 65536)
{
g_set_error (error,
G_IO_ERROR,
G_IO_ERROR_INVALID_ARGUMENT,
_("Error in address '%s' - the port attribute is missing or malformed"),
address_entry);
goto out;
}
if (is_nonce)
{
nonce_file = g_hash_table_lookup (key_value_pairs, "noncefile");
if (nonce_file == NULL)
{
g_set_error (error,
G_IO_ERROR,
G_IO_ERROR_INVALID_ARGUMENT,
_("Error in address '%s' - the noncefile attribute is missing or malformed"),
address_entry);
goto out;
}
}
/* TODO: deal with family key/value-pair */
connectable = g_network_address_new (host, port);
}
else if (g_strcmp0 (address_entry, "autolaunch:") == 0)
{
gchar *autolaunch_address;
autolaunch_address = get_session_address_platform_specific (error);
if (autolaunch_address != NULL)
{
ret = g_dbus_address_try_connect_one (autolaunch_address, NULL, cancellable, error);
g_free (autolaunch_address);
goto out;
}
else
{
g_prefix_error (error, _("Error auto-launching: "));
}
}
else
{
g_set_error (error,
G_IO_ERROR,
G_IO_ERROR_INVALID_ARGUMENT,
_("Unknown or unsupported transport '%s' for address '%s'"),
transport_name,
address_entry);
}
if (connectable != NULL)
{
GSocketClient *client;
GSocketConnection *connection;
g_assert (ret == NULL);
client = g_socket_client_new ();
connection = g_socket_client_connect (client,
connectable,
cancellable,
error);
g_object_unref (connectable);
g_object_unref (client);
if (connection == NULL)
goto out;
ret = G_IO_STREAM (connection);
if (nonce_file != NULL)
{
gchar nonce_contents[16 + 1];
size_t num_bytes_read;
FILE *f;
/* be careful to read only 16 bytes - we also check that the file is only 16 bytes long */
f = fopen (nonce_file, "rb");
if (f == NULL)
{
g_set_error (error,
G_IO_ERROR,
G_IO_ERROR_INVALID_ARGUMENT,
_("Error opening nonce file '%s': %s"),
nonce_file,
g_strerror (errno));
g_object_unref (ret);
ret = NULL;
goto out;
}
num_bytes_read = fread (nonce_contents,
sizeof (gchar),
16 + 1,
f);
if (num_bytes_read != 16)
{
if (num_bytes_read == 0)
{
g_set_error (error,
G_IO_ERROR,
G_IO_ERROR_INVALID_ARGUMENT,
_("Error reading from nonce file '%s': %s"),
nonce_file,
g_strerror (errno));
}
else
{
g_set_error (error,
G_IO_ERROR,
G_IO_ERROR_INVALID_ARGUMENT,
_("Error reading from nonce file '%s', expected 16 bytes, got %d"),
nonce_file,
(gint) num_bytes_read);
}
g_object_unref (ret);
ret = NULL;
fclose (f);
goto out;
}
fclose (f);
if (!g_output_stream_write_all (g_io_stream_get_output_stream (ret),
nonce_contents,
16,
NULL,
cancellable,
error))
{
g_prefix_error (error, _("Error writing contents of nonce file '%s' to stream:"), nonce_file);
g_object_unref (ret);
ret = NULL;
goto out;
}
}
}
out:
return ret;
}
gboolean
g_vfs_afp_connection_open (GVfsAfpConnection *afp_connection,
GCancellable *cancellable,
GError **error)
{
GVfsAfpConnectionPrivate *priv = afp_connection->priv;
GSocketClient *client;
guint16 req_id;
gboolean res;
char *reply;
DSIHeader dsi_header;
guint pos;
client = g_socket_client_new ();
priv->conn = G_IO_STREAM (g_socket_client_connect (client, priv->addr, cancellable, error));
g_object_unref (client);
if (!priv->conn)
return FALSE;
req_id = get_request_id (afp_connection);
res = send_request_sync (g_io_stream_get_output_stream (priv->conn),
DSI_OPEN_SESSION, req_id, 0, 0, NULL,
cancellable, error);
if (!res)
return FALSE;
res = read_reply_sync (g_io_stream_get_input_stream (priv->conn),
&dsi_header, &reply, cancellable, error);
if (!res)
return FALSE;
pos = 0;
while ((dsi_header.totalDataLength - pos) > 2)
{
guint8 optionType;
guint8 optionLength;
optionType = reply[pos++];
optionLength = reply[pos++];
switch (optionType)
{
case 0x00:
if (optionLength == 4 && (dsi_header.totalDataLength - pos) >= 4)
priv->kRequestQuanta = GUINT32_FROM_BE (*(guint32 *)(reply + pos));
break;
case 0x02:
if (optionLength == 4 && (dsi_header.totalDataLength - pos) >= 4)
priv->kServerReplayCacheSize = GUINT32_FROM_BE (*(guint32 *)(reply + pos));
break;
default:
g_debug ("Unknown DSI option\n");
}
pos += optionLength;
}
g_free (reply);
return TRUE;
}
ControllerLIRC::ControllerLIRC( TPContext * context , const char * uds , guint _repeat )
:
connection( 0 ),
controller( 0 ),
timer( 0 ),
repeat( gdouble( _repeat ) / 1000.0 )
{
g_assert( context );
g_assert( uds );
//.........................................................................
// Get the address of the Unix Domain Socket
GSocketAddress * socket_address = g_unix_socket_address_new( uds );
if ( ! socket_address )
{
tpwarn( "FAILED TO CREATE SOCKET ADDRESS WITH '%d'" , uds );
return;
}
//.........................................................................
// Create a socket client and attempt to connect to the address
GSocketClient * client = g_socket_client_new();
connection = g_socket_client_connect( client , G_SOCKET_CONNECTABLE( socket_address ) , NULL , NULL );
g_object_unref( socket_address );
g_object_unref( client );
if ( ! connection )
{
tplog( "FAILED TO CONNECT TO LIRC SOCKET" );
return;
}
//.........................................................................
// Now, get the socket's input stream, create a data input stream from it
// and start reading lines.
GDataInputStream * input_stream = g_data_input_stream_new( g_io_stream_get_input_stream( G_IO_STREAM( connection ) ) );
g_assert( input_stream );
g_data_input_stream_read_line_async( input_stream , 0 , NULL , line_read , this );
g_object_unref( input_stream );
//.........................................................................
// Add the controller
TPControllerSpec controller_spec;
memset( & controller_spec , 0 , sizeof( controller_spec ) );
controller_spec.capabilities = TP_CONTROLLER_HAS_KEYS;
controller = tp_context_add_controller( context , "Remote" , & controller_spec , 0 );
g_assert( controller );
//.........................................................................
// Populate the key map
key_map[ "0" ] = TP_KEY_0;
key_map[ "1" ] = TP_KEY_1;
key_map[ "2" ] = TP_KEY_2;
key_map[ "3" ] = TP_KEY_3;
key_map[ "4" ] = TP_KEY_4;
key_map[ "5" ] = TP_KEY_5;
key_map[ "6" ] = TP_KEY_6;
key_map[ "7" ] = TP_KEY_7;
key_map[ "8" ] = TP_KEY_8;
key_map[ "9" ] = TP_KEY_9;
key_map[ "MUTE" ] = TP_KEY_MUTE;
key_map[ "CH_UP" ] = TP_KEY_CHAN_UP;
key_map[ "VOL_UP" ] = TP_KEY_VOL_UP;
key_map[ "CH_DOWN" ] = TP_KEY_CHAN_DOWN;
key_map[ "VOL_DOWN" ] = TP_KEY_VOL_DOWN;
key_map[ "UP" ] = TP_KEY_UP;
key_map[ "LEFT" ] = TP_KEY_LEFT;
key_map[ "OK" ] = TP_KEY_OK;
key_map[ "RIGHT" ] = TP_KEY_RIGHT;
key_map[ "DOWN" ] = TP_KEY_DOWN;
key_map[ "MENU" ] = TP_KEY_MENU;
key_map[ "EXIT" ] = TP_KEY_EXIT;
key_map[ "PLAY" ] = TP_KEY_PLAY;
key_map[ "PAUSE" ] = TP_KEY_PAUSE;
key_map[ "STOP" ] = TP_KEY_STOP;
key_map[ "|<<" ] = TP_KEY_PREV;
key_map[ ">>|" ] = TP_KEY_NEXT;
key_map[ "RECORD" ] = TP_KEY_REC;
key_map[ "<<" ] = TP_KEY_REW;
key_map[ ">>" ] = TP_KEY_FFWD;
key_map[ "RED" ] = TP_KEY_RED;
key_map[ "GREEN" ] = TP_KEY_GREEN;
key_map[ "YELLOW" ] = TP_KEY_YELLOW;
key_map[ "BLUE" ] = TP_KEY_BLUE;
key_map[ "BACK" ] = TP_KEY_BACK;
timer = g_timer_new();
tplog( "READY" );
}
/* TODO: Declare an extension point called GDBusTransport (or similar)
* and move code below to extensions implementing said extension
* point. That way we can implement a D-Bus transport over X11 without
* making libgio link to libX11...
*/
static GIOStream *
g_dbus_address_connect (const gchar *address_entry,
const gchar *transport_name,
GHashTable *key_value_pairs,
GCancellable *cancellable,
GError **error)
{
GIOStream *ret;
GSocketConnectable *connectable;
const gchar *nonce_file;
connectable = NULL;
ret = NULL;
nonce_file = NULL;
if (FALSE)
{
}
#ifdef G_OS_UNIX
else if (g_strcmp0 (transport_name, "unix") == 0)
{
const gchar *path;
const gchar *abstract;
path = g_hash_table_lookup (key_value_pairs, "path");
abstract = g_hash_table_lookup (key_value_pairs, "abstract");
if ((path == NULL && abstract == NULL) || (path != NULL && abstract != NULL))
{
g_set_error (error,
G_IO_ERROR,
G_IO_ERROR_INVALID_ARGUMENT,
_("Error in address `%s' - the unix transport requires exactly one of the "
"keys `path' or `abstract' to be set"),
address_entry);
}
else if (path != NULL)
{
connectable = G_SOCKET_CONNECTABLE (g_unix_socket_address_new (path));
}
else if (abstract != NULL)
{
connectable = G_SOCKET_CONNECTABLE (g_unix_socket_address_new_with_type (abstract,
-1,
G_UNIX_SOCKET_ADDRESS_ABSTRACT));
}
else
{
g_assert_not_reached ();
}
}
#endif
else if (g_strcmp0 (transport_name, "tcp") == 0 || g_strcmp0 (transport_name, "nonce-tcp") == 0)
{
const gchar *s;
const gchar *host;
guint port;
gchar *endp;
gboolean is_nonce;
is_nonce = (g_strcmp0 (transport_name, "nonce-tcp") == 0);
host = g_hash_table_lookup (key_value_pairs, "host");
if (host == NULL)
{
g_set_error (error,
G_IO_ERROR,
G_IO_ERROR_INVALID_ARGUMENT,
_("Error in address `%s' - the host attribute is missing or malformed"),
address_entry);
goto out;
}
s = g_hash_table_lookup (key_value_pairs, "port");
if (s == NULL)
s = "0";
port = strtol (s, &endp, 10);
if ((*s == '\0' || *endp != '\0') || port < 0 || port >= 65536)
{
g_set_error (error,
G_IO_ERROR,
G_IO_ERROR_INVALID_ARGUMENT,
_("Error in address `%s' - the port attribute is missing or malformed"),
address_entry);
goto out;
}
if (is_nonce)
{
nonce_file = g_hash_table_lookup (key_value_pairs, "noncefile");
if (nonce_file == NULL)
{
g_set_error (error,
G_IO_ERROR,
G_IO_ERROR_INVALID_ARGUMENT,
_("Error in address `%s' - the noncefile attribute is missing or malformed"),
address_entry);
goto out;
}
}
/* TODO: deal with family */
connectable = g_network_address_new (host, port);
}
else
{
g_set_error (error,
G_IO_ERROR,
G_IO_ERROR_INVALID_ARGUMENT,
_("Unknown or unsupported transport `%s' for address `%s'"),
transport_name,
address_entry);
}
if (connectable != NULL)
{
GSocketClient *client;
GSocketConnection *connection;
g_assert (ret == NULL);
client = g_socket_client_new ();
connection = g_socket_client_connect (client,
connectable,
cancellable,
error);
g_object_unref (connectable);
g_object_unref (client);
if (connection == NULL)
goto out;
ret = G_IO_STREAM (connection);
if (nonce_file != NULL)
{
gchar *nonce_contents;
gsize nonce_length;
/* TODO: too dangerous to read the entire file? (think denial-of-service etc.) */
if (!g_file_get_contents (nonce_file,
&nonce_contents,
&nonce_length,
error))
{
g_prefix_error (error, _("Error reading nonce file `%s':"), nonce_file);
g_object_unref (ret);
ret = NULL;
goto out;
}
if (nonce_length != 16)
{
g_set_error (error,
G_IO_ERROR,
G_IO_ERROR_INVALID_ARGUMENT,
_("The nonce-file `%s' was %" G_GSIZE_FORMAT " bytes. Expected 16 bytes."),
nonce_file,
nonce_length);
g_free (nonce_contents);
g_object_unref (ret);
ret = NULL;
goto out;
}
if (!g_output_stream_write_all (g_io_stream_get_output_stream (ret),
nonce_contents,
nonce_length,
NULL,
cancellable,
error))
{
g_prefix_error (error, _("Error write contents of nonce file `%s' to stream:"), nonce_file);
g_object_unref (ret);
ret = NULL;
g_free (nonce_contents);
goto out;
}
g_free (nonce_contents);
}
}
out:
return ret;
}
static gpointer
open_thread_func (gpointer user_data)
{
SyncData *data = user_data;
GVfsAfpConnection *conn = data->conn;
GVfsAfpConnectionPrivate *priv = conn->priv;
GSocketClient *client;
guint16 req_id;
gboolean res = FALSE;
char *reply;
DSIHeader dsi_header;
guint pos;
client = g_socket_client_new ();
priv->stream = G_IO_STREAM (g_socket_client_connect (client, priv->addr, data->cancellable,
data->error));
g_object_unref (client);
if (!priv->stream)
goto out;
req_id = get_request_id (conn);
res = send_request_sync (g_io_stream_get_output_stream (priv->stream),
DSI_OPEN_SESSION, req_id, 0, 0, NULL,
data->cancellable, data->error);
if (!res)
goto out;
res = read_reply_sync (g_io_stream_get_input_stream (priv->stream),
&dsi_header, &reply, data->cancellable, data->error);
if (!res)
goto out;
pos = 0;
while ((dsi_header.totalDataLength - pos) > 2)
{
guint8 optionType;
guint8 optionLength;
optionType = reply[pos++];
optionLength = reply[pos++];
switch (optionType)
{
case 0x00:
if (optionLength == 4 && (dsi_header.totalDataLength - pos) >= 4)
priv->kRequestQuanta = GUINT32_FROM_BE (*(guint32 *)(reply + pos));
break;
case 0x02:
if (optionLength == 4 && (dsi_header.totalDataLength - pos) >= 4)
priv->kServerReplayCacheSize = GUINT32_FROM_BE (*(guint32 *)(reply + pos));
break;
default:
g_debug ("Unknown DSI option\n");
}
pos += optionLength;
}
g_free (reply);
out:
if (res)
g_atomic_int_set (&priv->atomic_state, STATE_CONNECTED);
/* Signal sync call thread */
data->res = res;
sync_data_signal (data);
/* Return from thread on failure */
if (!res)
{
g_clear_object (&priv->stream);
return NULL;
}
/* Create MainLoop */
priv->worker_context = g_main_context_new ();
priv->worker_loop = g_main_loop_new (priv->worker_context, TRUE);
read_reply (conn);
/* Run mainloop */
g_main_loop_run (priv->worker_loop);
return NULL;
}