static guint
socket_connected (SoupSocket *sock, GSocketConnection *conn, GError *error)
{
SoupSocketPrivate *priv = SOUP_SOCKET_GET_PRIVATE (sock);
if (priv->connect_cancel) {
GCancellable *cancellable = priv->connect_cancel;
gboolean cancelled = g_cancellable_is_cancelled (cancellable);
g_object_unref (priv->connect_cancel);
priv->connect_cancel = NULL;
if (cancelled) {
g_clear_error (&error);
return SOUP_STATUS_CANCELLED;
}
}
if (error) {
if (error->domain == G_RESOLVER_ERROR) {
g_error_free (error);
return SOUP_STATUS_CANT_RESOLVE;
} else {
g_error_free (error);
return SOUP_STATUS_CANT_CONNECT;
}
}
priv->conn = (GIOStream *)conn;
priv->gsock = g_object_ref (g_socket_connection_get_socket (conn));
finish_socket_setup (priv);
return SOUP_STATUS_OK;
}
FusionTLSInputStream* fusion_tls_input_stream_construct (GType object_type, FusionTLSConnection* connection) {
FusionTLSInputStream * self = NULL;
FusionTLSConnection* _tmp0_ = NULL;
GSocketConnection* _tmp1_ = NULL;
GSocketConnection* _tmp2_ = NULL;
GInputStream* _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_input_stream ((GIOStream*) _tmp2_);
self = (FusionTLSInputStream*) 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 on_connected (GObject *source_object,
GAsyncResult *res,
gpointer user_data)
{
GSocketClient *client = NULL;
GSocketConnection *connection = NULL;
GSocket *socket = NULL;
gint fd = 0;
GIOChannel *channel = NULL;
GError *local_error = NULL;
client = G_SOCKET_CLIENT (source_object);
connection = g_socket_client_connect_to_host_finish (client, res, &local_error);
if (local_error)
{
g_warning("connect failed: %s", local_error->message);
g_clear_error (&local_error);
return;
}
socket = g_socket_connection_get_socket (connection);
fd = g_socket_get_fd (socket);
channel = g_io_channel_unix_new (fd);
g_io_channel_set_encoding (channel, NULL, NULL);
g_io_add_watch (channel, G_IO_IN, on_read, g_object_ref (connection));
}
static pid_t
_gumd_dbus_server_p2p_get_remote_pid (
GumdDbusServer *self,
GDBusMethodInvocation *invocation)
{
pid_t remote_pid = 0;
GDBusConnection *connection = NULL;
gint peer_fd = -1;
struct ucred peer_cred;
socklen_t cred_size = sizeof(peer_cred);
g_return_val_if_fail (invocation && GUMD_IS_DBUS_SERVER_P2P (self),
remote_pid);
connection = g_dbus_method_invocation_get_connection (invocation);
peer_fd = g_socket_get_fd (g_socket_connection_get_socket (
G_SOCKET_CONNECTION (g_dbus_connection_get_stream(connection))));
if (peer_fd < 0 || getsockopt (peer_fd, SOL_SOCKET, SO_PEERCRED,
&peer_cred, &cred_size) != 0) {
WARN ("getsockopt() for SO_PEERCRED failed");
return remote_pid;
}
DBG ("Remote p2p peer pid=%d uid=%d gid=%d", peer_cred.pid, peer_cred.uid,
peer_cred.gid);
return peer_cred.pid;
}
static void
cockpit_request_start (CockpitWebServer *self,
GIOStream *io,
gboolean first)
{
GSocketConnection *connection;
CockpitRequest *request;
gboolean input = TRUE;
GSocket *socket;
request = g_new0 (CockpitRequest, 1);
request->web_server = self;
request->io = g_object_ref (io);
request->buffer = g_byte_array_new ();
/* Right before a successive request, EOF is not unexpected */
request->eof_okay = !first;
request->timeout = g_timeout_source_new_seconds (cockpit_webserver_request_timeout);
g_source_set_callback (request->timeout, on_request_timeout, request, NULL);
g_source_attach (request->timeout, self->main_context);
if (first)
{
connection = G_SOCKET_CONNECTION (io);
socket = g_socket_connection_get_socket (connection);
g_socket_set_blocking (socket, FALSE);
if (self->certificate)
{
request->source = g_socket_create_source (g_socket_connection_get_socket (connection),
G_IO_IN, NULL);
g_source_set_callback (request->source, (GSourceFunc)on_socket_input, request, NULL);
g_source_attach (request->source, self->main_context);
/* Wait on reading input */
input = FALSE;
}
}
/* Owns the request */
g_hash_table_add (self->requests, request);
if (input)
start_request_input (request);
}
GSocket *
xg_socket_connection_get_socket (GSocketConnection *connection)
{
GSocket *s;
s = g_socket_connection_get_socket (connection);
if (s == NULL)
g_critical("g_socket_connection_get_socket() returned NULL");
return s;
}
gboolean _xr_server_service_run(GThreadedSocketService *service, GSocketConnection *connection, GObject *source_object, gpointer user_data)
{
GError* local_err = NULL;
xr_server* server = user_data;
xr_server_conn* conn;
//xr_trace(XR_DEBUG_SERVER_TRACE, "(conn=%p, server=%p)", conn, server);
xr_set_nodelay(g_socket_connection_get_socket(connection));
// new connection accepted
conn = g_new0(xr_server_conn, 1);
conn->servlets = g_ptr_array_sized_new(3);
conn->running = TRUE;
// setup TLS
if (server->secure)
{
conn->tls_conn = g_tls_server_connection_new(G_IO_STREAM(connection), server->cert, &local_err);
if (local_err)
{
g_error_free(local_err);
goto out;
}
//g_object_set(conn->conn, "authentication-mode", test->auth_mode, NULL);
//g_signal_connect(conn->conn, "accept-certificate", G_CALLBACK(on_accept_certificate), server);
conn->http = xr_http_new(conn->tls_conn);
}
else
{
conn->http = xr_http_new(G_IO_STREAM(connection));
}
conn->conn = connection;
while (conn->running)
{
if (!_xr_server_serve_request(server, conn))
break;
}
out:
xr_http_free(conn->http);
if (conn->tls_conn)
g_object_unref(conn->tls_conn);
g_ptr_array_foreach(conn->servlets, (GFunc)xr_servlet_free_fini, NULL);
g_ptr_array_free(conn->servlets, TRUE);
memset(conn, 0, sizeof(*conn));
g_free(conn);
return FALSE;
}
/* Set TCP_NODELAY on the connection to avoid a bad interaction between Nagle's
* algorithm and delayed acks when doing a write-write-read. */
static void
enable_nodelay (GSocketConnection *conn)
{
GError *error = NULL;
GSocket *socket = g_socket_connection_get_socket (conn);
if (!g_socket_set_option (socket, IPPROTO_TCP, TCP_NODELAY, TRUE, &error))
{
g_warning ("Could not set TCP_NODELAY: %s\n", error->message);
g_error_free (error);
}
}
gboolean dasom_im_get_surrounding (DasomIM *im,
gchar **text,
gint *cursor_index)
{
g_debug (G_STRLOC ": %s", G_STRFUNC);
g_return_val_if_fail (DASOM_IS_IM (im), FALSE);
GSocket *socket = g_socket_connection_get_socket (im->connection);
if (!socket || g_socket_is_closed (socket))
{
if (text)
*text = g_strdup ("");
if (cursor_index)
*cursor_index = 0;
g_warning ("socket is closed");
return FALSE;
}
dasom_send_message (socket, DASOM_MESSAGE_GET_SURROUNDING, NULL, 0, NULL);
dasom_result_iteration_until (im->result,
dasom_im_sockets_context,
DASOM_MESSAGE_GET_SURROUNDING_REPLY);
if (im->result->reply == NULL)
{
if (text)
*text = g_strdup ("");
if (cursor_index)
*cursor_index = 0;
return FALSE;
}
if (text)
*text = g_strndup (im->result->reply->data,
im->result->reply->header->data_len - 1 -
sizeof (gint) - sizeof (gboolean));
if (cursor_index)
{
*cursor_index = *(gint *) (im->result->reply->data +
im->result->reply->header->data_len -
sizeof (gint) - sizeof (gboolean));
}
return *(gboolean *) (im->result->reply->data - sizeof (gboolean));
}
static void
connect_cb(GObject *source,
GAsyncResult *res,
gpointer user_data)
{
GSocketConnection *socket_conn;
PnNode *conn;
GError *error = NULL;
conn = PN_NODE(user_data);
socket_conn = g_socket_client_connect_to_host_finish(G_SOCKET_CLIENT(source), res, &error);
g_object_unref(source);
if (error) {
g_error_free(error);
return;
}
g_object_ref(conn);
if (socket_conn) {
GSocket *socket;
GInputStream *input;
conn->socket_conn = socket_conn;
socket = g_socket_connection_get_socket(socket_conn);
conn->status = PN_NODE_STATUS_OPEN;
input = g_io_stream_get_input_stream (G_IO_STREAM (conn->socket_conn));
g_object_ref (conn);
g_input_stream_read_async (input, conn->input_buffer, PN_BUF_LEN,
G_PRIORITY_DEFAULT, NULL,
read_cb, conn);
}
else {
conn->error = g_error_new_literal(PN_NODE_ERROR, PN_NODE_ERROR_OPEN,
"Unable to connect");
pn_node_error(conn);
}
{
PnNodeClass *class;
class = g_type_class_peek(PN_NODE_TYPE);
g_signal_emit(G_OBJECT(conn), class->open_sig, 0, conn);
}
g_object_unref(conn);
}
gboolean xr_client_open(xr_client_conn* conn, const char* uri, GError** err)
{
GError* local_err = NULL;
g_return_val_if_fail(conn != NULL, FALSE);
g_return_val_if_fail(uri != NULL, FALSE);
g_return_val_if_fail(!conn->is_open, FALSE);
g_return_val_if_fail(err == NULL || *err == NULL, FALSE);
xr_trace(XR_DEBUG_CLIENT_TRACE, "(conn=%p, uri=%s)", conn, uri);
// parse URI format: http://host:8080/RES
g_free(conn->host);
g_free(conn->resource);
conn->host = NULL;
conn->resource = NULL;
if (!_parse_uri(uri, &conn->secure, &conn->host, &conn->resource))
{
g_set_error(err, XR_CLIENT_ERROR, XR_CLIENT_ERROR_FAILED, "invalid URI format: %s", uri);
return FALSE;
}
// enable/disable TLS
if (conn->secure)
{
g_socket_client_set_tls(conn->client, TRUE);
g_socket_client_set_tls_validation_flags(conn->client, G_TLS_CERTIFICATE_VALIDATE_ALL & ~G_TLS_CERTIFICATE_UNKNOWN_CA & ~G_TLS_CERTIFICATE_BAD_IDENTITY);
}
else
{
g_socket_client_set_tls(conn->client, FALSE);
}
conn->conn = g_socket_client_connect_to_host(conn->client, conn->host, 80, NULL, &local_err);
if (local_err)
{
g_propagate_prefixed_error(err, local_err, "Connection failed: ");
return FALSE;
}
xr_set_nodelay(g_socket_connection_get_socket(conn->conn));
conn->http = xr_http_new(G_IO_STREAM(conn->conn));
g_free(conn->session_id);
conn->session_id = g_strdup_printf("%08x%08x%08x%08x", g_random_int(), g_random_int(), g_random_int(), g_random_int());
conn->is_open = 1;
xr_client_set_http_header(conn, "X-SESSION-ID", conn->session_id);
return TRUE;
}
static void
connect_cb(GObject *source,
GAsyncResult *res,
gpointer user_data)
{
GSocketConnection *socket_conn;
PnNode *conn;
conn = PN_NODE(user_data);
socket_conn = g_socket_client_connect_to_host_finish(G_SOCKET_CLIENT(source), res, NULL);
g_object_unref(source);
g_object_ref(conn);
if (socket_conn) {
GIOChannel *channel;
GSocket *socket;
conn->socket_conn = socket_conn;
socket = g_socket_connection_get_socket(socket_conn);
conn->stream = pn_stream_new(g_socket_get_fd(socket));
channel = conn->stream->channel;
PN_NODE_GET_CLASS (conn)->channel_setup (conn, channel);
conn->status = PN_NODE_STATUS_OPEN;
pn_info("connected: conn=%p,channel=%p", conn, channel);
conn->read_watch = g_io_add_watch(channel, G_IO_IN, read_cb, conn);
#if 0
g_io_add_watch (channel, G_IO_ERR | G_IO_HUP | G_IO_NVAL, close_cb, conn);
#endif
}
else {
conn->error = g_error_new_literal(PN_NODE_ERROR, PN_NODE_ERROR_OPEN,
"Unable to connect");
pn_node_error(conn);
}
{
PnNodeClass *class;
class = g_type_class_peek(PN_NODE_TYPE);
g_signal_emit(G_OBJECT(conn), class->open_sig, 0, conn);
}
g_object_unref(conn);
}
static void
enable_keepalive (GSocketConnection *conn)
{
/* We enable keepalive on the socket, because data connections can be
* idle for a long time while data is transferred using the data
* connection. And there are still buggy routers in existance that purge
* idle connections from time to time.
* To work around this problem, we set the keep alive flag here. It's the
* user's responsibility to configure his kernel properly so that the
* keepalive packets are sent before the buggy router disconnects the
* TCP connection. If a user asks, a howto is at
* http://tldp.org/HOWTO/html_single/TCP-Keepalive-HOWTO/
*/
g_socket_set_keepalive (g_socket_connection_get_socket (conn), TRUE);
}
/**
* g_vfs_ftp_connection_is_usable:
* @conn: a connection
*
* Checks if this connection can be used to send new commands. For
* example, if the connection is in the process of a command sequence or
* if the connection was closed, this is not possible and this function
* will return %FALSE.
*
* Returns: %TRUE if the connection is still usable
**/
gboolean
g_vfs_ftp_connection_is_usable (GVfsFtpConnection *conn)
{
GIOCondition cond;
g_return_val_if_fail (conn != NULL, FALSE);
if (conn->waiting_for_reply)
return FALSE;
cond = G_IO_ERR | G_IO_HUP;
cond = g_socket_condition_check (g_socket_connection_get_socket (G_SOCKET_CONNECTION (conn->commands)), cond);
if (cond)
return FALSE;
return TRUE;
}
static gboolean
on_new_connection (GSocketService * service, GSocketConnection * connection,
GObject * source_object, gpointer user_data)
{
Client *client = g_slice_new0 (Client);
GSocketAddress *addr;
GInetAddress *iaddr;
gchar *ip;
guint16 port;
addr = g_socket_connection_get_remote_address (connection, NULL);
iaddr = g_inet_socket_address_get_address (G_INET_SOCKET_ADDRESS (addr));
port = g_inet_socket_address_get_port (G_INET_SOCKET_ADDRESS (addr));
ip = g_inet_address_to_string (iaddr);
client->name = g_strdup_printf ("%s:%u", ip, port);
g_free (ip);
g_object_unref (addr);
g_print ("New connection %s\n", client->name);
client->connection = (GSocketConnection *) g_object_ref (connection);
client->socket = g_socket_connection_get_socket (connection);
client->istream =
g_io_stream_get_input_stream (G_IO_STREAM (client->connection));
client->ostream =
g_io_stream_get_output_stream (G_IO_STREAM (client->connection));
client->current_message = g_byte_array_sized_new (1024);
client->tosource = g_timeout_source_new_seconds (5);
g_source_set_callback (client->tosource, (GSourceFunc) on_timeout, client,
NULL);
g_source_attach (client->tosource, NULL);
client->isource =
g_pollable_input_stream_create_source (G_POLLABLE_INPUT_STREAM
(client->istream), NULL);
g_source_set_callback (client->isource, (GSourceFunc) on_read_bytes, client,
NULL);
g_source_attach (client->isource, NULL);
G_LOCK (clients);
clients = g_list_prepend (clients, client);
G_UNLOCK (clients);
return TRUE;
}
/* Called onincoming TCP connection
*/
static void on_incoming(GSocketService *service, gpointer udata){
gint fd;
GIOChannel *channel;
GSocketConnection *connection;
AppData *app_data;
app_data = udata;
connection = udata;
/* syslog(LOG_NOTICE, "Incoming Connection\n");*/
g_object_ref(connection);
GSocket *socket = g_socket_connection_get_socket(connection);
fd = g_socket_get_fd(socket);
channel = g_io_channel_unix_new(fd);
g_io_add_watch(channel, G_IO_IN, (GIOFunc)network_read, connection);
}
void dasom_im_reset (DasomIM *im)
{
g_debug (G_STRLOC ": %s", G_STRFUNC);
g_return_if_fail (DASOM_IS_IM (im));
GSocket *socket = g_socket_connection_get_socket (im->connection);
if (!socket || g_socket_is_closed (socket))
{
g_warning ("socket is closed");
return;
}
dasom_send_message (socket, DASOM_MESSAGE_RESET, NULL, 0, NULL);
dasom_result_iteration_until (im->result,
dasom_im_sockets_context,
DASOM_MESSAGE_RESET_REPLY);
}
static gboolean
on_new_connection (GSocketService *service,
GSocketConnection *socket_connection,
GObject *source_object,
DasomServer *server)
{
g_debug (G_STRLOC ": %s", G_STRFUNC);
/* TODO: simple authentication using GCredentials */
GSocket *socket = g_socket_connection_get_socket (socket_connection);
DasomMessage *message;
message = dasom_recv_message (socket);
if (message->header->type == DASOM_MESSAGE_CONNECT)
dasom_send_message (socket, DASOM_MESSAGE_CONNECT_REPLY, NULL, 0, NULL);
else
{
/* TODO: error handling */
dasom_send_message (socket, DASOM_MESSAGE_ERROR, NULL, 0, NULL);
return TRUE; /* TODO: what happened if return value is FALSE */
}
DasomConnection *connection;
connection = dasom_connection_new (*(DasomConnectionType *) message->data,
dasom_server_get_default_engine (server), NULL);
dasom_message_unref (message);
connection->socket = socket;
dasom_server_add_connection (server, connection);
if (connection->type == DASOM_CONNECTION_DASOM_AGENT)
server->agents_list = g_list_prepend (server->agents_list, connection);
connection->source = g_socket_create_source (socket, G_IO_IN, NULL);
connection->socket_connection = g_object_ref (socket_connection);
g_source_set_can_recurse (connection->source, TRUE);
g_source_set_callback (connection->source,
(GSourceFunc) on_incoming_message_dasom,
connection, NULL);
g_source_attach (connection->source, server->main_context);
return TRUE;
}
static gboolean
BP_TCPService_IncomingConnection (GSocketService *service,
GSocketConnection *incomingConnection,
GObject *source_object,
gpointer user_data)
{
BPTCPService *filter = BP_TCPSERVICE (user_data);
GSocket *socket = g_socket_connection_get_socket(incomingConnection);
GSocketAddress *sockaddr = g_socket_connection_get_remote_address(incomingConnection, NULL);
GInetAddress *addr = g_inet_socket_address_get_address(G_INET_SOCKET_ADDRESS(sockaddr));
gchar* remoteHost = g_inet_address_to_string(addr);
gint fd = g_socket_get_fd(socket);
GIOChannel *channel = g_io_channel_unix_new(fd);
if (filter->mode == BP_MODE_SINK_ONLY) {
GST_ERROR ("Attempt to accept connection but in sink-only mode");
return FALSE;
}
// Ref connection
g_object_ref (incomingConnection);
// Get remote host & port
filter->remotePort = g_inet_socket_address_get_port(G_INET_SOCKET_ADDRESS(sockaddr));
g_string_assign(filter->remoteAddress, remoteHost);
g_free (remoteHost);
g_message ("New connection from %s:%d", filter->remoteAddress->str, (int) filter->remotePort);
g_message ("Attaching IO channel watch ...");
// Add IO watch with pointer to connection handle as user data for callback
g_io_add_watch(channel, G_IO_IN, (GIOFunc) BP_TCPService_IncomingConnectionReceive, filter);
g_io_channel_unref (channel);
g_message ("Registering connection");
BP_TCPService_UpdateUID (filter);
ServerPool_AddInstance (filter->uid, filter->service, incomingConnection);
return FALSE;
}
void dasom_im_set_cursor_location (DasomIM *im,
const DasomRectangle *area)
{
g_debug (G_STRLOC ": %s", G_STRFUNC);
g_return_if_fail (DASOM_IS_IM (im));
GSocket *socket = g_socket_connection_get_socket (im->connection);
if (!socket || g_socket_is_closed (socket))
{
g_warning ("socket is closed");
return;
}
dasom_send_message (socket, DASOM_MESSAGE_SET_CURSOR_LOCATION,
(gchar *) area, sizeof (DasomRectangle), NULL);
dasom_result_iteration_until (im->result,
dasom_im_sockets_context,
DASOM_MESSAGE_SET_CURSOR_LOCATION_REPLY);
}
void dasom_im_set_use_preedit (DasomIM *im,
gboolean use_preedit)
{
g_debug (G_STRLOC ": %s", G_STRFUNC);
g_return_if_fail (DASOM_IS_IM (im));
GSocket *socket = g_socket_connection_get_socket (im->connection);
if (!socket || g_socket_is_closed (socket))
{
g_warning ("socket is closed");
return;
}
dasom_send_message (socket, DASOM_MESSAGE_SET_USE_PREEDIT,
(gchar *) &use_preedit, sizeof (gboolean), NULL);
dasom_result_iteration_until (im->result,
dasom_im_sockets_context,
DASOM_MESSAGE_SET_USE_PREEDIT_REPLY);
}
int main(int argc, char *argv[]) {
LibWCRelay *relay = libwc_relay_new();
GSocketClient *socket_client = g_socket_client_new();
GSocketConnection *socket_connection;
gboolean result;
gchar *ping_result;
GError *error = NULL;
if (argc < 2) {
fprintf(stderr, "Usage: test-client <host[:port]>\n");
exit(1);
}
socket_connection = g_socket_client_connect_to_host(socket_client, argv[1],
49153, NULL, &error);
END_IF_FAIL(socket_connection != NULL);
libwc_relay_password_set(relay, "test");
libwc_relay_connection_set(relay, G_IO_STREAM(socket_connection),
g_socket_connection_get_socket(socket_connection));
result = libwc_relay_connection_init(relay, NULL, &error);
if (result)
printf("Connection successful!\n");
else {
fprintf(stderr, "Connection unsuccessful: %s\n",
error->message);
exit(1);
}
ping_result = libwc_relay_ping(relay, NULL, &error, TEST_PING_MESSAGE);
if (ping_result && strcmp(ping_result, TEST_PING_MESSAGE) == 0)
printf("Ping successful!\n");
else {
fprintf(stderr, "Ping unsuccessful: %s\n",
error->message);
exit(1);
}
}
static void _connect_to_host_ready(GObject *source_object, GAsyncResult *res, gpointer user_data) {
GSocketClient *socket_client = G_SOCKET_CLIENT(source_object);
GSimpleAsyncResult *result = G_SIMPLE_ASYNC_RESULT(user_data);
IdleServerConnection *conn = IDLE_SERVER_CONNECTION(g_async_result_get_source_object(G_ASYNC_RESULT(result)));
IdleServerConnectionPrivate *priv = IDLE_SERVER_CONNECTION_GET_PRIVATE(conn);
GInputStream *input_stream;
GSocket *socket_;
GSocketConnection *socket_connection;
gint nodelay = 1;
gint socket_fd;
GError *error = NULL;
socket_connection = g_socket_client_connect_to_host_finish(socket_client, res, &error);
if (socket_connection == NULL) {
IDLE_DEBUG("g_socket_client_connect_to_host failed: %s", error->message);
g_simple_async_result_set_error(result, TP_ERROR, TP_ERROR_NETWORK_ERROR, "%s", error->message);
g_error_free(error);
change_state(conn, SERVER_CONNECTION_STATE_NOT_CONNECTED, SERVER_CONNECTION_STATE_REASON_ERROR);
g_object_unref(conn);
goto cleanup;
}
socket_ = g_socket_connection_get_socket(socket_connection);
g_socket_set_keepalive(socket_, TRUE);
socket_fd = g_socket_get_fd(socket_);
setsockopt(socket_fd, IPPROTO_TCP, TCP_NODELAY, &nodelay, sizeof(nodelay));
g_tcp_connection_set_graceful_disconnect(G_TCP_CONNECTION(socket_connection), TRUE);
priv->io_stream = G_IO_STREAM(socket_connection);
input_stream = g_io_stream_get_input_stream(priv->io_stream);
_input_stream_read(conn, input_stream, _input_stream_read_ready);
change_state(conn, SERVER_CONNECTION_STATE_CONNECTED, SERVER_CONNECTION_STATE_REASON_REQUESTED);
cleanup:
g_simple_async_result_complete(result);
g_object_unref(result);
}
//New tcp conection
gboolean new_connection(GSocketService *service, GSocketConnection *connection, GObject *source_object, gpointer user_data) {
//New client connected
GSocketAddress *sockaddr = g_socket_connection_get_remote_address(connection, NULL);
GInetAddress *addr = g_inet_socket_address_get_address(G_INET_SOCKET_ADDRESS(sockaddr));
guint16 port = g_inet_socket_address_get_port(G_INET_SOCKET_ADDRESS(sockaddr));
if (verbose) {
printf("App Server: New Connection from %s:%d\n", g_inet_address_to_string(addr), port);
fflush(stdout);
}
//Record client (if new)
add_client(g_inet_address_to_string(addr), connection);
g_object_ref (connection);
GSocket *socket = g_socket_connection_get_socket(connection);
gint fd = g_socket_get_fd(socket);
GIOChannel *channel = g_io_channel_unix_new(fd);
g_io_add_watch(channel, G_IO_IN, (GIOFunc) network_read, connection);
return TRUE;
}
/**
* g_vfs_ftp_connection_is_usable:
* @conn: a connection
*
* Checks if this connection can be used to send new commands. For
* example, if the connection is in the process of a command sequence or
* if the connection was closed, this is not possible and this function
* will return %FALSE.
*
* Returns: %TRUE if the connection is still usable
**/
gboolean
g_vfs_ftp_connection_is_usable (GVfsFtpConnection *conn)
{
GIOCondition cond;
g_return_val_if_fail (conn != NULL, FALSE);
if (conn->waiting_for_reply)
return FALSE;
cond = G_IO_ERR | G_IO_HUP | G_IO_IN;
cond = g_socket_condition_check (g_socket_connection_get_socket (conn->connection), cond);
if (cond)
{
g_debug ("##%2d ## connection unusuable: %s%s%s\r\n", conn->debug_id,
cond & G_IO_IN ? "IN " : "",
cond & G_IO_HUP ? "HUP " : "",
cond & G_IO_ERR ? "ERR " : "");
return FALSE;
}
return TRUE;
}
gboolean dasom_im_filter_event (DasomIM *im, DasomEvent *event)
{
g_debug (G_STRLOC ":%s", G_STRFUNC);
g_return_val_if_fail (DASOM_IS_IM (im), FALSE);
GSocket *socket = g_socket_connection_get_socket (im->connection);
if (!socket || g_socket_is_closed (socket))
{
g_warning ("socket is closed");
return dasom_im_filter_event_fallback (im, event);
}
dasom_send_message (socket, DASOM_MESSAGE_FILTER_EVENT, event,
sizeof (DasomEvent), NULL);
dasom_result_iteration_until (im->result,
dasom_im_sockets_context,
DASOM_MESSAGE_FILTER_EVENT_REPLY);
if (im->result->reply == NULL)
return dasom_im_filter_event_fallback (im, event);
return *(gboolean *) (im->result->reply->data);
}
void dasom_im_set_surrounding (DasomIM *im,
const char *text,
gint len,
gint cursor_index)
{
g_debug (G_STRLOC ": %s", G_STRFUNC);
g_return_if_fail (DASOM_IS_IM (im));
GSocket *socket = g_socket_connection_get_socket (im->connection);
if (!socket || g_socket_is_closed (socket))
{
g_warning ("socket is closed");
return;
}
gchar *data = NULL;
gint str_len;
if (len == -1)
str_len = strlen (text);
else
str_len = len;
data = g_strndup (text, str_len);
data = g_realloc (data, str_len + 1 + 2 * sizeof (gint));
*(gint *) (data + str_len + 1) = len;
*(gint *) (data + str_len + 1 + sizeof (gint)) = cursor_index;
dasom_send_message (socket, DASOM_MESSAGE_SET_SURROUNDING, data,
str_len + 1 + 2 * sizeof (gint), g_free);
dasom_result_iteration_until (im->result,
dasom_im_sockets_context,
DASOM_MESSAGE_SET_SURROUNDING_REPLY);
}
static void hev_scgi_handler_cgi_handle(HevSCGIHandler *handler, GObject *scgi_task)
{
HevSCGIHandlerCGI *self = HEV_SCGI_HANDLER_CGI(handler);
HevSCGIHandlerCGIPrivate *priv = HEV_SCGI_HANDLER_CGI_GET_PRIVATE(self);
HevSCGIHandlerCGITaskData *task_data = NULL;
gchar *str = NULL, **argv = NULL, *workdir = NULL;
GPid pid = 0;
GError *error = NULL;
GObject *connection = NULL;
GSocket *socket = NULL;
g_debug("%s:%d[%s]", __FILE__, __LINE__, __FUNCTION__);
task_data = g_slice_new0(HevSCGIHandlerCGITaskData);
if(!task_data)
{
g_critical("%s:%d[%s]", __FILE__, __LINE__, __FUNCTION__);
return;
}
connection = hev_scgi_task_get_socket_connection(HEV_SCGI_TASK(scgi_task));
socket = g_socket_connection_get_socket(G_SOCKET_CONNECTION(connection));
task_data->fd = g_socket_get_fd(socket);
task_data->scgi_task = scgi_task;
task_data->scgi_request = hev_scgi_task_get_request(HEV_SCGI_TASK(scgi_task));
task_data->scgi_response = hev_scgi_task_get_response(HEV_SCGI_TASK(scgi_task));
task_data->req_hash_table =
hev_scgi_request_get_header_hash_table(HEV_SCGI_REQUEST(task_data->scgi_request));
task_data->envp =
g_malloc0_n(g_hash_table_size(task_data->req_hash_table)+1, sizeof(gchar *));
g_hash_table_foreach(task_data->req_hash_table, req_hash_table_foreach_handler, task_data);
/* Script file and Work dir */
str = g_hash_table_lookup(task_data->req_hash_table, "SCRIPT_FILE");
argv = g_malloc0_n(2, sizeof(gchar *));
if(str)
{
argv[0] = g_strdup(str);
workdir = g_path_get_dirname(str);
}
else
{
argv[0] = g_key_file_get_string(priv->config, "Module", "CGIBinPath", NULL);
workdir = g_key_file_get_string(priv->config, "Module", "WorkDir", NULL);
if(NULL == argv[0])
argv[0] = g_strdup(HEV_SCGI_HANDLER_CGI_BIN_PATH);
if(NULL == workdir)
workdir = g_strdup(HEV_SCGI_HANDLER_CGI_WORK_DIR);
}
#ifdef G_OS_UNIX
/* User and Group */
str = g_hash_table_lookup(task_data->req_hash_table, "_USER");
if(str)
task_data->user = g_strdup(str);
else
task_data->user = g_key_file_get_string(priv->config, "Module", "User", NULL);
str = g_hash_table_lookup(task_data->req_hash_table, "_GROUP");
if(str)
task_data->group = g_strdup(str);
else
task_data->group = g_key_file_get_string(priv->config, "Module", "Group", NULL);
#endif /* G_OS_UNIX */
if(g_spawn_async(workdir, argv, task_data->envp, G_SPAWN_DO_NOT_REAP_CHILD,
hev_scgi_handler_spawn_child_setup_handler,
task_data, &pid, &error))
{
g_object_ref(scgi_task);
g_child_watch_add(pid, hev_scgi_handler_child_watch_handler, task_data);
}
else
{
g_critical("%s:%d[%s]=>(%s)", __FILE__, __LINE__,
__FUNCTION__, error->message);
g_error_free(error);
}
g_strfreev(argv);
g_free(workdir);
}
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);
}
FusionTLSConnection* fusion_tls_connection_construct (GType object_type, GSocketConnection* connection, GError** error) {
FusionTLSConnection * self = NULL;
GSocketConnection* _tmp0_ = NULL;
GSocketConnection* _tmp1_ = NULL;
GSocket* _tmp2_ = NULL;
GSocket* _tmp3_ = NULL;
struct gnutls_anon_server_credentials_st* anon_creds = NULL;
struct gnutls_anon_server_credentials_st* _tmp4_ = NULL;
struct gnutls_dh_params_int* dh_params = NULL;
struct gnutls_dh_params_int* _tmp5_ = NULL;
struct gnutls_dh_params_int* _tmp6_ = NULL;
struct gnutls_anon_server_credentials_st* _tmp7_ = NULL;
struct gnutls_dh_params_int* _tmp8_ = NULL;
struct gnutls_session_int* _tmp9_ = NULL;
gchar* err = NULL;
struct gnutls_session_int* _tmp10_ = NULL;
const gchar* _tmp11_ = NULL;
gint _tmp12_ = 0;
gchar* _tmp13_ = NULL;
struct gnutls_session_int* _tmp16_ = NULL;
struct gnutls_anon_server_credentials_st* _tmp17_ = NULL;
struct gnutls_session_int* _tmp18_ = NULL;
GSocket* _tmp19_ = NULL;
gint _tmp20_ = 0;
FusionTLSInputStream* _tmp21_ = NULL;
FusionTLSInputStream* _tmp22_ = NULL;
FusionTLSOutputStream* _tmp23_ = NULL;
FusionTLSOutputStream* _tmp24_ = NULL;
GError * _inner_error_ = NULL;
g_return_val_if_fail (connection != NULL, NULL);
_tmp0_ = connection;
self = (FusionTLSConnection*) g_object_new (object_type, "socket-connection", _tmp0_, NULL);
_tmp1_ = self->priv->_socket_connection;
_tmp2_ = g_socket_connection_get_socket (_tmp1_);
_tmp3_ = _g_object_ref0 (_tmp2_);
_g_object_unref0 (self->priv->socket);
self->priv->socket = _tmp3_;
_tmp4_ = gnutls_anon_server_credentials_create ();
anon_creds = _tmp4_;
_tmp5_ = gnutls_dh_params_create ();
dh_params = _tmp5_;
_tmp6_ = dh_params;
gnutls_dh_params_generate2 (_tmp6_, (guint) FUSION_TLS_CONNECTION_DH_BITS);
_tmp7_ = anon_creds;
_tmp8_ = dh_params;
gnutls_anon_set_server_dh_params (_tmp7_, _tmp8_);
_tmp9_ = gnutls_create ();
_gnutls_deinit0 (self->tls_session);
self->tls_session = _tmp9_;
_tmp10_ = self->tls_session;
_tmp12_ = gnutls_priority_set_direct (_tmp10_, "NORMAL:+ANON-DH", &_tmp11_);
_g_free0 (err);
_tmp13_ = g_strdup (_tmp11_);
err = _tmp13_;
if (_tmp12_ < 0) {
const gchar* _tmp14_ = NULL;
GError* _tmp15_ = NULL;
_tmp14_ = err;
_tmp15_ = g_error_new (G_IO_ERROR, G_IO_ERROR_FAILED, "Invalid chipers priority: %s", _tmp14_);
_inner_error_ = _tmp15_;
g_propagate_error (error, _inner_error_);
_g_free0 (err);
_gnutls_dh_params_deinit0 (dh_params);
_gnutls_anon_free_server_credentials0 (anon_creds);
_g_object_unref0 (self);
return NULL;
}
_tmp16_ = self->tls_session;
_tmp17_ = anon_creds;
anon_creds = NULL;
gnutls_credentials_set (_tmp16_, GNUTLS_CRD_ANON, _tmp17_);
_tmp18_ = self->tls_session;
_tmp19_ = self->priv->socket;
_tmp20_ = g_socket_get_fd (_tmp19_);
gnutls_transport_set_ptr (_tmp18_, (void*) ((glong) _tmp20_));
_tmp21_ = fusion_tls_input_stream_new (self);
_tmp22_ = _tmp21_;
fusion_tls_connection_set_input_stream (self, (GInputStream*) _tmp22_);
_g_object_unref0 (_tmp22_);
_tmp23_ = fusion_tls_output_stream_new (self);
_tmp24_ = _tmp23_;
fusion_tls_connection_set_output_stream (self, (GOutputStream*) _tmp24_);
_g_object_unref0 (_tmp24_);
_g_free0 (err);
_gnutls_dh_params_deinit0 (dh_params);
_gnutls_anon_free_server_credentials0 (anon_creds);
return self;
}
