static GstStateChangeReturn
gst_dtls_enc_change_state (GstElement * element, GstStateChange transition)
{
GstDtlsBase *base = GST_DTLS_BASE (element);
GstStateChangeReturn ret;
switch (transition) {
case GST_STATE_CHANGE_READY_TO_PAUSED:
gst_output_stream_set_push_function (GST_OUTPUT_STREAM
(g_io_stream_get_output_stream (G_IO_STREAM (base->conn->
base_stream))),
(GstOutputStreamPushFunc) gst_dtls_enc_push, element);
break;
default:
break;
}
ret = GST_ELEMENT_CLASS (gst_dtls_enc_parent_class)->change_state (element,
transition);
if (ret == GST_STATE_CHANGE_FAILURE)
return ret;
switch (transition) {
case GST_STATE_CHANGE_PAUSED_TO_READY:
gst_output_stream_set_push_function (GST_OUTPUT_STREAM
(g_io_stream_get_output_stream (G_IO_STREAM (base->conn->
base_stream))), NULL, NULL);
break;
default:
break;
}
return ret;
}
int writeToFile(PlatformFileHandle handle, const char* data, int length)
{
gsize bytesWritten;
g_output_stream_write_all(g_io_stream_get_output_stream(G_IO_STREAM(handle)),
data, length, &bytesWritten, 0, 0);
return bytesWritten;
}
static void
initialize_io (CockpitStream *self)
{
GInputStream *is;
GOutputStream *os;
g_return_if_fail (self->priv->in_source == NULL);
is = g_io_stream_get_input_stream (self->priv->io);
os = g_io_stream_get_output_stream (self->priv->io);
if (!G_IS_POLLABLE_INPUT_STREAM (is) ||
!g_pollable_input_stream_can_poll (G_POLLABLE_INPUT_STREAM (is)) ||
!G_IS_POLLABLE_OUTPUT_STREAM (os) ||
!g_pollable_output_stream_can_poll (G_POLLABLE_OUTPUT_STREAM (os)))
{
g_warning ("%s: stream is not pollable", self->priv->name);
close_immediately (self, "internal-error");
return;
}
if (self->priv->connecting)
{
g_object_unref (self->priv->connecting);
self->priv->connecting = NULL;
}
self->priv->in_source = g_pollable_input_stream_create_source (G_POLLABLE_INPUT_STREAM (is), NULL);
g_source_set_name (self->priv->in_source, "stream-input");
g_source_set_callback (self->priv->in_source, (GSourceFunc)dispatch_input, self, NULL);
g_source_attach (self->priv->in_source, self->priv->context);
start_output (self);
}
gboolean
g_vfs_afp_connection_close (GVfsAfpConnection *afp_connection,
GCancellable *cancellable,
GError **error)
{
GVfsAfpConnectionPrivate *priv = afp_connection->priv;
guint16 req_id;
gboolean res;
/* close DSI session */
req_id = get_request_id (afp_connection);
res = send_request_sync (g_io_stream_get_output_stream (priv->conn),
DSI_CLOSE_SESSION, req_id, 0, 0, NULL,
cancellable, error);
if (!res)
{
g_io_stream_close (priv->conn, cancellable, NULL);
g_object_unref (priv->conn);
return FALSE;
}
res = g_io_stream_close (priv->conn, cancellable, error);
g_object_unref (priv->conn);
return res;
}
GSpeechdClient *
gspeechd_client_new (GSocketConnection *connection)
{
GSpeechdClient *client;
GOutputStream *output_stream;
GInputStream *input_stream;
client = g_slice_new0 (GSpeechdClient);
client->ref_count = 1;
client->cancellable = g_cancellable_new ();
client->connection = g_object_ref (connection);
client->failed = FALSE;
/*
* Start listening for the message
*/
input_stream = g_io_stream_get_input_stream(G_IO_STREAM(connection));
client->input = g_data_input_stream_new (input_stream);
g_data_input_stream_read_line_async(client->input,
G_PRIORITY_DEFAULT,
client->cancellable,
(GAsyncReadyCallback)gspeechd_client_read_line_cb,
gspeechd_client_ref (client));
output_stream = g_io_stream_get_output_stream (G_IO_STREAM(connection));
client->output = g_data_output_stream_new (output_stream);
return (client);
}
static void
g_io_stream_get_property (GObject *object,
guint prop_id,
GValue *value,
GParamSpec *pspec)
{
GIOStream *stream = G_IO_STREAM (object);
switch (prop_id)
{
case PROP_CLOSED:
g_value_set_boolean (value, stream->priv->closed);
break;
case PROP_INPUT_STREAM:
g_value_set_object (value, g_io_stream_get_input_stream (stream));
break;
case PROP_OUTPUT_STREAM:
g_value_set_object (value, g_io_stream_get_output_stream (stream));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
}
}
static void done_async_connect(GObject *obj, GAsyncResult *res, gpointer user_data) {
GSocketClient *sock = G_SOCKET_CLIENT(obj);
struct ekg_connection_starter *cs = user_data;
GSocketConnection *conn;
GError *err = NULL;
conn = g_socket_client_connect_finish(sock, res, &err);
if (conn) {
#ifdef HAVE_LIBGNUTLS
if (cs->use_tls) {
ekg_gnutls_new_session(sock, conn, cs);
} else
#endif
{
GIOStream *cio = G_IO_STREAM(conn);
succeeded_async_connect(
sock, conn, cs,
g_io_stream_get_input_stream(cio),
g_io_stream_get_output_stream(cio));
}
} else {
failed_async_connect(sock, err, cs);
g_error_free(err);
}
}
static void sendIncompleteRequest(InspectorServerTest* test, gconstpointer)
{
GOwnPtr<GError> error;
// Connect to the inspector server.
GRefPtr<GSocketClient> client = adoptGRef(g_socket_client_new());
GRefPtr<GSocketConnection> connection = adoptGRef(g_socket_client_connect_to_host(client.get(), "127.0.0.1", 2999, 0, &error.outPtr()));
g_assert_no_error(error.get());
// Send incomplete request (missing blank line after headers) and check if inspector server
// replies. The server should not reply to an incomplete request and the test should timeout
// on read.
GOutputStream* ostream = g_io_stream_get_output_stream(G_IO_STREAM(connection.get()));
// Request missing blank line after headers.
const gchar* incompleteRequest = "GET /devtools/page/1 HTTP/1.1\r\nHost: Localhost\r\n";
g_output_stream_write(ostream, incompleteRequest, strlen(incompleteRequest), 0, &error.outPtr());
g_assert_no_error(error.get());
GInputStream* istream = g_io_stream_get_input_stream(G_IO_STREAM(connection.get()));
char response[16];
memset(response, 0, sizeof(response));
GRefPtr<GCancellable> cancel = adoptGRef(g_cancellable_new());
g_input_stream_read_async(istream, response, sizeof(response) - 1, G_PRIORITY_DEFAULT, cancel.get(), 0, 0);
// Give a chance for the server to reply.
test->wait(1);
g_cancellable_cancel(cancel.get());
// If we got any answer it means the server replied to an incomplete request, lets fail.
g_assert(response[0] == '\0');
}
static void
tunnel_connected_cb (GObject *object,
GAsyncResult *result,
gpointer user_data)
{
Tunnel *tunnel = user_data;
GError *error = NULL;
tunnel->server.iostream = (GIOStream *)
g_socket_client_connect_to_host_finish (G_SOCKET_CLIENT (object), result, &error);
if (!tunnel->server.iostream) {
soup_message_set_status (tunnel->msg, SOUP_STATUS_BAD_GATEWAY);
soup_message_set_response (tunnel->msg, "text/plain",
SOUP_MEMORY_COPY,
error->message, strlen (error->message));
g_error_free (error);
soup_server_unpause_message (tunnel->self, tunnel->msg);
tunnel_close (tunnel);
return;
}
tunnel->server.istream = g_io_stream_get_input_stream (tunnel->server.iostream);
tunnel->server.ostream = g_io_stream_get_output_stream (tunnel->server.iostream);
soup_message_set_status (tunnel->msg, SOUP_STATUS_OK);
soup_server_unpause_message (tunnel->self, tunnel->msg);
g_signal_connect (tunnel->msg, "finished",
G_CALLBACK (start_tunnel), tunnel);
}
gboolean
g_vfs_ftp_connection_send (GVfsFtpConnection *conn,
const char * command,
int len,
GCancellable * cancellable,
GError ** error)
{
g_return_val_if_fail (conn != NULL, FALSE);
g_return_val_if_fail (!conn->waiting_for_reply, FALSE);
g_return_val_if_fail (command != NULL, FALSE);
g_return_val_if_fail (len >= -1, FALSE);
if (len < 0)
len = strlen (command);
g_return_val_if_fail (command[len-2] == '\r' && command[len-1] == '\n', FALSE);
if (g_str_has_prefix (command, "PASS"))
g_debug ("--%2d -> PASS ***\r\n", conn->debug_id);
else
g_debug ("--%2d -> %s", conn->debug_id, command);
conn->waiting_for_reply = TRUE;
return g_output_stream_write_all (g_io_stream_get_output_stream (conn->commands),
command,
len,
NULL,
cancellable,
error);
}
/* Class Implementation */
static void
kixmail_io_stream_set_property (GObject *object,
guint prop_id,
const GValue *value,
GParamSpec *pspec)
{
KixmailIOStream *iostream = KIXMAIL_IO_STREAM (object);
GIOStream *io;
switch (prop_id) {
case PROP_BASE_IOSTREAM:
io = iostream->priv->base_iostream = g_value_dup_object (value);
if (io) {
iostream->priv->istream =
kixmail_filter_input_stream_new (g_io_stream_get_input_stream (io));
iostream->priv->ostream =
g_object_ref (g_io_stream_get_output_stream (io));
} else {
g_clear_object (&iostream->priv->istream);
g_clear_object (&iostream->priv->ostream);
}
break;
case PROP_CLOSE_ON_DISPOSE:
iostream->priv->close_on_dispose = g_value_get_boolean (value);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
FusionTLSOutputStream* fusion_tls_output_stream_construct (GType object_type, FusionTLSConnection* connection) {
FusionTLSOutputStream * self = NULL;
FusionTLSConnection* _tmp0_ = NULL;
GSocketConnection* _tmp1_ = NULL;
GSocketConnection* _tmp2_ = NULL;
GOutputStream* _tmp3_ = NULL;
FusionTLSConnection* _tmp4_ = NULL;
FusionTLSConnection* _tmp5_ = NULL;
FusionTLSConnection* _tmp6_ = NULL;
GSocketConnection* _tmp7_ = NULL;
GSocketConnection* _tmp8_ = NULL;
GSocket* _tmp9_ = NULL;
GSocket* _tmp10_ = NULL;
g_return_val_if_fail (connection != NULL, NULL);
_tmp0_ = connection;
_tmp1_ = fusion_tls_connection_get_socket_connection (_tmp0_);
_tmp2_ = _tmp1_;
_tmp3_ = g_io_stream_get_output_stream ((GIOStream*) _tmp2_);
self = (FusionTLSOutputStream*) g_object_new (object_type, "base-stream", _tmp3_, NULL);
_tmp4_ = connection;
_tmp5_ = _g_object_ref0 (_tmp4_);
_g_object_unref0 (self->priv->connection);
self->priv->connection = _tmp5_;
_tmp6_ = connection;
_tmp7_ = fusion_tls_connection_get_socket_connection (_tmp6_);
_tmp8_ = _tmp7_;
_tmp9_ = g_socket_connection_get_socket (_tmp8_);
_tmp10_ = _g_object_ref0 (_tmp9_);
_g_object_unref0 (self->priv->socket);
self->priv->socket = _tmp10_;
return self;
}
static void
gdk_clipboard_read_local_async (GdkClipboard *clipboard,
GdkContentFormats *formats,
int io_priority,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
GdkClipboardPrivate *priv = gdk_clipboard_get_instance_private (clipboard);
GdkContentFormats *content_formats;
const char *mime_type;
GTask *task;
task = g_task_new (clipboard, cancellable, callback, user_data);
g_task_set_priority (task, io_priority);
g_task_set_source_tag (task, gdk_clipboard_read_local_async);
if (priv->content == NULL)
{
g_task_return_new_error (task, G_IO_ERROR, G_IO_ERROR_NOT_FOUND,
_("Cannot read from empty clipboard."));
g_object_unref (task);
return;
}
content_formats = gdk_content_provider_ref_formats (priv->content);
content_formats = gdk_content_formats_union_serialize_mime_types (content_formats);
mime_type = gdk_content_formats_match_mime_type (content_formats, formats);
if (mime_type != NULL)
{
GOutputStream *output_stream;
GIOStream *stream;
stream = gdk_pipe_io_stream_new ();
output_stream = g_io_stream_get_output_stream (stream);
gdk_clipboard_write_async (clipboard,
mime_type,
output_stream,
io_priority,
cancellable,
gdk_clipboard_read_local_write_done,
g_object_ref (output_stream));
g_task_set_task_data (task, (gpointer) mime_type, NULL);
g_task_return_pointer (task, g_object_ref (g_io_stream_get_input_stream (stream)), g_object_unref);
g_object_unref (stream);
}
else
{
g_task_return_new_error (task, G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED,
_("No compatible formats to transfer clipboard contents."));
}
gdk_content_formats_unref (content_formats);
g_object_unref (task);
}
void IOChannel::write(size_t offset, const Data& data, WorkQueue*, std::function<void (int error)> completionHandler)
{
ASSERT(m_outputStream || m_ioStream);
GOutputStream* stream = m_outputStream ? m_outputStream.get() : g_io_stream_get_output_stream(G_IO_STREAM(m_ioStream.get()));
WriteAsyncData* asyncData = new WriteAsyncData { this, data.soupBuffer(), completionHandler };
// FIXME: implement offset.
g_output_stream_write_async(stream, asyncData->buffer->data, data.size(), G_PRIORITY_DEFAULT, nullptr,
reinterpret_cast<GAsyncReadyCallback>(outputStreamWriteReadyCallback), asyncData);
}
static void
_j4status_io_stream_set_connection(J4statusIOStream *self, GSocketConnection *connection)
{
self->connection = connection;
self->out = g_data_output_stream_new(g_io_stream_get_output_stream(G_IO_STREAM(self->connection)));
self->in = g_data_input_stream_new(g_io_stream_get_input_stream(G_IO_STREAM(self->connection)));
if ( ! self->header_sent )
_j4status_io_stream_put_header(self, self->io->header);
g_data_input_stream_read_line_async(self->in, G_PRIORITY_DEFAULT, NULL, _j4status_io_stream_read_callback, self);
}
// poll if there is a message on port needed to be transmitted or processed.
// port: see localhost:port, socket
// pMsg: both input ArMsg and output ArMsg
boolean ArvfbPoll(ArPortType port,ArMsgType* pMsg)
{
boolean rv= FALSE;
GError * error = NULL;
uint32 command = pMsg->Command;
/* create a new connection */
GSocketConnection * connection = NULL;
GSocketClient * client = g_socket_client_new();
/* connect to the host */
connection = g_socket_client_connect_to_host (client,
(gchar*)"localhost",
port, /* your port goes here */
NULL,
&error);
/* don't forget to check for errors */
if (error != NULL)
{
g_print("SERVER: <%s>!\n",error->message);
g_object_unref(client);
return FALSE;
}
/* use the connection */
GOutputStream * ostream = g_io_stream_get_output_stream (G_IO_STREAM (connection));
g_output_stream_write (ostream,
pMsg,
pMsg->Length+MSG_MIN_LENGTH,
NULL,
&error);
GInputStream * istream = g_io_stream_get_input_stream (G_IO_STREAM (connection));
gssize size = g_input_stream_read(istream,pMsg,sizeof(ArMsgType),NULL,&error);
if( (size > MSG_MIN_LENGTH) &&
((MSG_MIN_LENGTH+pMsg->Length)==size) &&
((command|MSG_CMD_ACK) == pMsg->Command) )
{
rv = TRUE;
}
else
{ // <= MSG_MIN_LENGTH, default nothing has been gotten on the port
rv = FALSE;
}
/* don't forget to check for errors */
if (error != NULL)
{
g_print("SERVER: <%s>!\n",error->message);
}
g_object_unref(connection);
g_object_unref(client);
return rv;
}
/**
* uncompress_bzip2:
* @name: The name of the file to attempt to decompress
*
* Returns: The name of the uncompressed file (in a temporary location) or NULL
* free the returned name after use.
*
* Also see: http://www.bzip.org/1.0.5/bzip2-manual-1.0.5.html
*/
gchar* uncompress_bzip2 ( gchar *name )
{
#ifdef HAVE_BZLIB_H
FILE *ff = g_fopen ( name, "r" );
if ( !ff )
return NULL;
int bzerror;
BZFILE* bf = BZ2_bzReadOpen ( &bzerror, ff, 0, 0, NULL, 0 ); // This should take care of the bz2 file header
if ( bzerror != BZ_OK ) {
BZ2_bzReadClose ( &bzerror, bf );
// handle error
return NULL;
}
GFileIOStream *gios;
GError *error = NULL;
GFile *gf = g_file_new_tmp ( "vik-bz2-tmp.XXXXXX", &gios, &error );
gchar *tmpname = g_file_get_path (gf);
GOutputStream *gos = g_io_stream_get_output_stream ( G_IO_STREAM(gios) );
// Process in arbitary sized chunks
char buf[4096];
bzerror = BZ_OK;
int nBuf;
// Now process the actual compression data
while ( bzerror == BZ_OK ) {
nBuf = BZ2_bzRead ( &bzerror, bf, buf, 4096 );
if ( bzerror == BZ_OK || bzerror == BZ_STREAM_END) {
// do something with buf[0 .. nBuf-1]
if ( g_output_stream_write ( gos, buf, nBuf, NULL, &error ) < 0 ) {
g_critical ( "Couldn't write bz2 tmp %s file due to %s", tmpname, error->message );
g_error_free (error);
BZ2_bzReadClose ( &bzerror, bf );
goto end;
}
}
}
if ( bzerror != BZ_STREAM_END ) {
BZ2_bzReadClose ( &bzerror, bf );
// handle error...
goto end;
} else {
BZ2_bzReadClose ( &bzerror, bf );
g_output_stream_close ( gos, NULL, &error );
}
end:
return tmpname;
#else
return NULL;
#endif
}
//Bfoadcast ivy msgs to clients
void broadcast_to_clients () {
int i;
if (uTCP) {
//broadcast using tcp connection
GError *error = NULL;
for (i = 0; i < MAXCLIENT; i++) {
if (ConnectedClients[i].used > 0) {
GOutputStream * ostream = g_io_stream_get_output_stream (ConnectedClients[i].ClientTcpData);
g_output_stream_write(ostream, ivybuffer, strlen(ivybuffer), NULL, &error);
}
}
return;
}
i=0;
for (i = 0; i < MAXCLIENT; i++) {
if (ConnectedClients[i].used > 0) {
//Send data
GInetAddress *udpAddress;
GSocketAddress *udpSocketAddress;
GSocket *udpSocket;
udpAddress = g_inet_address_new_from_string(ConnectedClients[i].client_ip);
udpSocketAddress = g_inet_socket_address_new(udpAddress, udp_port);
udpSocket = g_socket_new(G_SOCKET_FAMILY_IPV4, G_SOCKET_TYPE_DATAGRAM, 17, NULL);
if (g_socket_connect(udpSocket, udpSocketAddress, NULL, NULL) == FALSE) {
printf("App Server: stg wrong with socket connect\n");
fflush(stdout);
}
if (g_socket_send(udpSocket, ivybuffer, strlen(ivybuffer) , NULL, NULL) < 0) {
printf("App Server: stg wrong with send func\n");
fflush(stdout);
}
if (g_socket_close(udpSocket, NULL) == FALSE) {
printf("App Server: stg wrong with socket close\n");
fflush(stdout);
}
//Unref objects
g_object_unref(udpAddress);
g_object_unref(udpSocketAddress);
g_object_unref(udpSocket);
}
}
}
char *
ot_editor_prompt (OstreeRepo *repo,
const char *input,
GCancellable *cancellable,
GError **error)
{
glnx_unref_object GSubprocess *proc = NULL;
g_autoptr(GFile) file = NULL;
g_autoptr(GFileIOStream) io = NULL;
GOutputStream *output;
const char *editor;
char *ret = NULL;
g_autofree char *args = NULL;
editor = get_editor ();
if (editor == NULL)
{
g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_FAILED,
"Terminal is dumb, but EDITOR unset");
goto out;
}
file = g_file_new_tmp (NULL, &io, error);
if (file == NULL)
goto out;
output = g_io_stream_get_output_stream (G_IO_STREAM (io));
if (!g_output_stream_write_all (output, input, strlen (input), NULL, cancellable, error) ||
!g_io_stream_close (G_IO_STREAM (io), cancellable, error))
goto out;
{
g_autofree char *quoted_file = g_shell_quote (gs_file_get_path_cached (file));
args = g_strconcat (editor, " ", quoted_file, NULL);
}
proc = g_subprocess_new (G_SUBPROCESS_FLAGS_STDIN_INHERIT, error,
"/bin/sh", "-c", args, NULL);
if (!g_subprocess_wait_check (proc, cancellable, error))
{
g_prefix_error (error, "There was a problem with the editor '%s'", editor);
goto out;
}
ret = glnx_file_get_contents_utf8_at (AT_FDCWD, gs_file_get_path_cached (file), NULL,
cancellable, error);
out:
if (file)
(void )g_file_delete (file, NULL, NULL);
return ret;
}
/**
* Given a new socket, this will create the interface connection structure.
*
* @param conn The socket that this interface is connected to
* @param threads Thread pool handling sockets
* @return the newly allocated and populated interface connection
*/
static interface_connection* interface_conn_init(
GSocketConnection* conn, GThreadPool* threads)
{
interface_connection* inter = g_new0(interface_connection, 1);
inter->conn = conn;
inter->istr = g_io_stream_get_input_stream((GIOStream*)inter->conn);
inter->ostr = g_io_stream_get_output_stream((GIOStream*)inter->conn);
g_thread_pool_push(threads, inter, NULL);
return inter;
}
static void
do_write (GAsyncReadyCallback callback, GTask *task, ConnectAsyncData *data)
{
GOutputStream *out;
out = g_io_stream_get_output_stream (data->io_stream);
g_output_stream_write_async (out,
data->buffer + data->offset,
data->length - data->offset,
g_task_get_priority (task),
g_task_get_cancellable (task),
callback, task);
}
static void
identd_read_ready (GInputStream *in_stream, GAsyncResult *res, ident_info *info)
{
GSocketAddress *sok_addr;
GOutputStream *out_stream;
guint64 local, remote;
gchar buf[512], *p;
if (g_input_stream_read_finish (in_stream, res, NULL))
{
local = g_ascii_strtoull (info->read_buf, NULL, 0);
p = strchr (info->read_buf, ',');
if (!p)
goto cleanup;
remote = g_ascii_strtoull (p + 1, NULL, 0);
if (!local || !remote || local > G_MAXUINT16 || remote > G_MAXUINT16)
goto cleanup;
info->username = g_strdup (g_hash_table_lookup (responses, GINT_TO_POINTER (local)));
if (!info->username)
goto cleanup;
g_hash_table_remove (responses, GINT_TO_POINTER (local));
if ((sok_addr = g_socket_connection_get_remote_address (info->conn, NULL)))
{
GInetAddress *inet_addr;
gchar *addr;
inet_addr = g_inet_socket_address_get_address (G_INET_SOCKET_ADDRESS (sok_addr));
addr = g_inet_address_to_string (inet_addr);
hextor_printf (ph, _("*\tServicing ident request from %s as %s"), addr, info->username);
g_object_unref (sok_addr);
g_object_unref (inet_addr);
g_free (addr);
}
g_snprintf (buf, sizeof (buf), "%"G_GUINT16_FORMAT", %"G_GUINT16_FORMAT" : USERID : UNIX : %s\r\n", (guint16)local, (guint16)remote, info->username);
out_stream = g_io_stream_get_output_stream (G_IO_STREAM (info->conn));
g_output_stream_write_async (out_stream, buf, strlen (buf), G_PRIORITY_DEFAULT,
NULL, (GAsyncReadyCallback)identd_write_ready, info);
}
return;
cleanup:
g_object_unref (info->conn);
g_free (info);
}
static GIOStream *
g_socks4a_proxy_connect (GProxy *proxy,
GIOStream *io_stream,
GProxyAddress *proxy_address,
GCancellable *cancellable,
GError **error)
{
GInputStream *in;
GOutputStream *out;
const gchar *hostname;
guint16 port;
const gchar *username;
hostname = g_proxy_address_get_destination_hostname (proxy_address);
port = g_proxy_address_get_destination_port (proxy_address);
username = g_proxy_address_get_username (proxy_address);
in = g_io_stream_get_input_stream (io_stream);
out = g_io_stream_get_output_stream (io_stream);
/* Send SOCKS4 connection request */
{
guint8 msg[SOCKS4_CONN_MSG_LEN];
gint len;
len = set_connect_msg (msg, hostname, port, username, error);
if (len < 0)
goto error;
if (!g_output_stream_write_all (out, msg, len, NULL,
cancellable, error))
goto error;
}
/* Read SOCKS4 response */
{
guint8 data[SOCKS4_CONN_REP_LEN];
if (!g_input_stream_read_all (in, data, SOCKS4_CONN_REP_LEN, NULL,
cancellable, error))
goto error;
if (!parse_connect_reply (data, error))
goto error;
}
return g_object_ref (io_stream);
error:
return NULL;
}
static gboolean
handle_set_icon_data_url (CockpitAccount *object,
GDBusMethodInvocation *invocation,
const gchar *arg_data)
{
GError *error = NULL;
Account *acc = ACCOUNT (object);
if (!account_auth_check (object, invocation, acc))
return TRUE;
if (acc->u)
{
const gchar *base64_data = strstr (arg_data, "base64,");
if (base64_data == NULL)
goto out;
base64_data += strlen ("base64,");
gsize raw_size;
gs_free gchar *raw_data = (gchar *)g_base64_decode (base64_data, &raw_size);
gs_unref_object GFileIOStream *tmp_stream = NULL;
gs_unref_object GFile *tmp_file = g_file_new_tmp ("cockpit-user-icon-XXXXXX", &tmp_stream, &error);
if (tmp_file == NULL)
goto out;
GOutputStream *out = g_io_stream_get_output_stream (G_IO_STREAM (tmp_stream));
if (!g_output_stream_write_all (out, raw_data, raw_size, NULL, NULL, &error))
goto out;
if (!g_io_stream_close (G_IO_STREAM (tmp_stream), NULL, &error))
goto out;
gs_free gchar *tmp_path = g_file_get_path (tmp_file);
act_user_set_icon_file (acc->u, tmp_path);
g_file_delete (tmp_file, NULL, NULL);
}
out:
if (error)
{
g_dbus_method_invocation_return_error (invocation,
COCKPIT_ERROR, COCKPIT_ERROR_FAILED,
"%s", error->message);
g_clear_error (&error);
}
else
cockpit_account_complete_set_icon_data_url (object, invocation);
return TRUE;
}
void SocketStreamHandle::connected(GRefPtr<GSocketConnection>&& socketConnection)
{
m_socketConnection = WTFMove(socketConnection);
m_outputStream = G_POLLABLE_OUTPUT_STREAM(g_io_stream_get_output_stream(G_IO_STREAM(m_socketConnection.get())));
m_inputStream = g_io_stream_get_input_stream(G_IO_STREAM(m_socketConnection.get()));
m_readBuffer = std::make_unique<char[]>(READ_BUFFER_SIZE);
RefPtr<SocketStreamHandle> protectedThis(this);
g_input_stream_read_async(m_inputStream.get(), m_readBuffer.get(), READ_BUFFER_SIZE, G_PRIORITY_DEFAULT, m_cancellable.get(),
reinterpret_cast<GAsyncReadyCallback>(readReadyCallback), protectedThis.leakRef());
m_state = Open;
m_client.didOpenSocketStream(*this);
}
static void
process_write_queue (HotSshTab *self)
{
HotSshTabPrivate *priv = hotssh_tab_get_instance_private (self);
if (!priv->have_outstanding_write && priv->write_queue.length > 0)
{
GOutputStream *ostream = g_io_stream_get_output_stream ((GIOStream*)priv->channel);
GBytes *buf = g_queue_peek_head (&priv->write_queue);
g_output_stream_write_bytes_async (ostream, buf, G_PRIORITY_DEFAULT,
priv->cancellable, on_ostream_write_complete, self);
priv->have_outstanding_write = TRUE;
}
}
static void
test_io_stream_properties (NiceAddress *addr)
{
NiceAgent *agent;
guint stream_id;
GIOStream *io_stream;
GInputStream *input_stream;
GOutputStream *output_stream;
agent = nice_agent_new_reliable (NULL, NICE_COMPATIBILITY_RFC5245);
nice_agent_add_local_address (agent, addr);
stream_id = nice_agent_add_stream (agent, 1);
/* Try building an I/O stream around it. */
io_stream = nice_agent_get_io_stream (agent, stream_id, 1);
g_assert (G_IS_IO_STREAM (io_stream));
g_assert (NICE_IS_IO_STREAM (io_stream));
/* Check various initial properties. */
g_assert (!g_io_stream_is_closed (G_IO_STREAM (io_stream)));
g_assert (!g_io_stream_has_pending (G_IO_STREAM (io_stream)));
/* Check the input stream’s properties. */
input_stream = g_io_stream_get_input_stream (G_IO_STREAM (io_stream));
g_assert (G_IS_INPUT_STREAM (input_stream));
g_assert (NICE_IS_INPUT_STREAM (input_stream));
g_assert (!g_input_stream_is_closed (input_stream));
g_assert (!g_input_stream_has_pending (input_stream));
/* Check the output stream’s properties. */
output_stream = g_io_stream_get_output_stream (G_IO_STREAM (io_stream));
g_assert (G_IS_OUTPUT_STREAM (output_stream));
g_assert (NICE_IS_OUTPUT_STREAM (output_stream));
g_assert (!g_output_stream_is_closing (output_stream));
g_assert (!g_output_stream_is_closed (output_stream));
g_assert (!g_output_stream_has_pending (output_stream));
/* Remove the component and check that the I/O streams close. */
nice_agent_remove_stream (agent, stream_id);
g_assert (g_io_stream_is_closed (G_IO_STREAM (io_stream)));
g_assert (g_input_stream_is_closed (input_stream));
g_assert (g_output_stream_is_closed (output_stream));
g_object_unref (io_stream);
g_object_unref (agent);
}
static void
kick_write(SpiceVDAgent *self)
{
Msg *msg = g_queue_peek_head(self->outq);
if (!msg || self->writing)
return;
GOutputStream *out = g_io_stream_get_output_stream(self->connection);
g_output_stream_write_async(out, msg->data + self->pos,
msg->size - self->pos,
G_PRIORITY_DEFAULT, self->cancellable,
msg_write_cb, self);
self->writing = TRUE;
}
static void
initialize_io (CockpitStream *self)
{
GInputStream *is;
GOutputStream *os;
g_return_if_fail (self->priv->in_source == NULL);
is = g_io_stream_get_input_stream (self->priv->io);
os = g_io_stream_get_output_stream (self->priv->io);
if (!G_IS_POLLABLE_INPUT_STREAM (is) ||
!g_pollable_input_stream_can_poll (G_POLLABLE_INPUT_STREAM (is)) ||
!G_IS_POLLABLE_OUTPUT_STREAM (os) ||
!g_pollable_output_stream_can_poll (G_POLLABLE_OUTPUT_STREAM (os)))
{
g_warning ("%s: stream is not pollable", self->priv->name);
close_immediately (self, "internal-error");
return;
}
if (self->priv->connecting)
{
cockpit_connectable_unref (self->priv->connecting);
self->priv->connecting = NULL;
}
self->priv->in_source = g_pollable_input_stream_create_source (G_POLLABLE_INPUT_STREAM (is), NULL);
g_source_set_name (self->priv->in_source, "stream-input");
g_source_set_callback (self->priv->in_source, (GSourceFunc)dispatch_input, self, NULL);
g_source_attach (self->priv->in_source, self->priv->context);
if (G_IS_TLS_CONNECTION (self->priv->io))
{
self->priv->sig_accept_cert = g_signal_connect (G_TLS_CONNECTION (self->priv->io),
"accept-certificate",
G_CALLBACK (on_rejected_certificate),
self);
}
else
{
self->priv->sig_accept_cert = 0;
}
start_output (self);
g_signal_emit (self, cockpit_stream_sig_open, 0);
}
MCState *mc_state_new(char *host, int port) {
GSocketClient *client;
MCState *state = g_new0(MCState, 1);
state->in = mc_buf_new();
state->out = mc_buf_new();
client = g_socket_client_new();
state->conn = g_socket_client_connect_to_host(client, host, port, NULL, NULL);
state->istream = g_io_stream_get_input_stream(G_IO_STREAM(state->conn));
state->ostream = g_io_stream_get_output_stream(G_IO_STREAM(state->conn));
g_object_unref(client);
return state;
}
