/**
* gst_net_time_packet_send:
* @packet: the #GstNetTimePacket to send
* @socket: socket to send the time packet on
* @dest_address: address to send the time packet to
* @error: return address for a #GError, or NULL
*
* Sends a #GstNetTimePacket over a socket.
*
* MT safe.
*
* Returns: TRUE if successful, FALSE in case an error occurred.
*/
gboolean
gst_net_time_packet_send (const GstNetTimePacket * packet,
GSocket * socket, GSocketAddress * dest_address, GError ** error)
{
gboolean was_blocking;
guint8 *buffer;
gssize res;
g_return_val_if_fail (packet != NULL, FALSE);
g_return_val_if_fail (G_IS_SOCKET (socket), FALSE);
g_return_val_if_fail (G_IS_SOCKET_ADDRESS (dest_address), FALSE);
g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
was_blocking = g_socket_get_blocking (socket);
if (was_blocking)
g_socket_set_blocking (socket, FALSE);
/* FIXME: avoid pointless alloc/free, serialise into stack-allocated buffer */
buffer = gst_net_time_packet_serialize (packet);
res = g_socket_send_to (socket, dest_address, (const gchar *) buffer,
GST_NET_TIME_PACKET_SIZE, NULL, error);
/* datagram packets should be sent as a whole or not at all */
g_assert (res < 0 || res == GST_NET_TIME_PACKET_SIZE);
g_free (buffer);
if (was_blocking)
g_socket_set_blocking (socket, TRUE);
return (res == GST_NET_TIME_PACKET_SIZE);
}
gssize
sctp_socket_receive (GSocket * socket, gchar * buffer, gsize size,
GCancellable * cancellable, guint * streamid, GError ** error)
{
g_return_val_if_fail (G_IS_SOCKET (socket) && buffer != NULL, -1);
return sctp_socket_receive_with_blocking (socket, buffer, size,
g_socket_get_blocking (socket), cancellable, streamid, error);
}
gssize
sctp_socket_send (GSocket * socket, guint streamid, guint32 timetolive,
const gchar * buffer, gsize size, GCancellable * cancellable,
GError ** error)
{
g_return_val_if_fail (G_IS_SOCKET (socket) && buffer != NULL, -1);
return sctp_socket_send_with_blocking (socket, streamid, timetolive, buffer,
size, g_socket_get_blocking (socket), cancellable, error);
}
gssize fusion_tls_connection_send (FusionTLSConnection* self, guint8* buffer, int buffer_length1, GCancellable* cancellable, GError** error) {
gssize result = 0L;
gssize ret = 0L;
GSocket* _tmp0_ = NULL;
gboolean _tmp1_ = FALSE;
GCancellable* _tmp3_ = NULL;
GError * _inner_error_ = NULL;
g_return_val_if_fail (self != NULL, 0L);
g_warning ("TLSConnection.vala:123: SEND");
_tmp0_ = self->priv->socket;
_tmp1_ = g_socket_is_closed (_tmp0_);
if (_tmp1_) {
GError* _tmp2_ = NULL;
_tmp2_ = g_error_new_literal (G_IO_ERROR, G_IO_ERROR_CLOSED, "Socket is already closed");
_inner_error_ = _tmp2_;
if (_inner_error_->domain == G_IO_ERROR) {
g_propagate_error (error, _inner_error_);
return 0L;
} else {
g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
g_clear_error (&_inner_error_);
return 0L;
}
}
_tmp3_ = cancellable;
g_cancellable_set_error_if_cancelled (_tmp3_, &_inner_error_);
if (_inner_error_ != NULL) {
if (_inner_error_->domain == G_IO_ERROR) {
g_propagate_error (error, _inner_error_);
return 0L;
} else {
g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
g_clear_error (&_inner_error_);
return 0L;
}
}
while (TRUE) {
gboolean _tmp4_ = FALSE;
GSocket* _tmp5_ = NULL;
gboolean _tmp6_ = FALSE;
gboolean _tmp11_ = FALSE;
struct gnutls_session_int* _tmp12_ = NULL;
guint8* _tmp13_ = NULL;
gint _tmp13__length1 = 0;
guint8* _tmp14_ = NULL;
gint _tmp14__length1 = 0;
gssize _tmp15_ = 0L;
gssize _tmp16_ = 0L;
_tmp5_ = self->priv->socket;
_tmp6_ = g_socket_get_blocking (_tmp5_);
if (_tmp6_) {
gboolean _tmp7_ = FALSE;
GSocket* _tmp8_ = NULL;
GCancellable* _tmp9_ = NULL;
gboolean _tmp10_ = FALSE;
_tmp8_ = self->priv->socket;
_tmp9_ = cancellable;
_tmp10_ = g_socket_condition_wait (_tmp8_, G_IO_OUT, _tmp9_, &_inner_error_);
_tmp7_ = _tmp10_;
if (_inner_error_ != NULL) {
if (_inner_error_->domain == G_IO_ERROR) {
g_propagate_error (error, _inner_error_);
return 0L;
} else {
g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
g_clear_error (&_inner_error_);
return 0L;
}
}
_tmp4_ = !_tmp7_;
} else {
_tmp4_ = FALSE;
}
_tmp11_ = _tmp4_;
if (_tmp11_) {
result = (gssize) (-1);
return result;
}
_tmp12_ = self->tls_session;
_tmp13_ = buffer;
_tmp13__length1 = buffer_length1;
_tmp14_ = buffer;
_tmp14__length1 = buffer_length1;
_tmp15_ = gnutls_record_send (_tmp12_, _tmp13_, (gsize) _tmp14__length1);
ret = _tmp15_;
_tmp16_ = ret;
if (_tmp16_ < ((gssize) 0)) {
int ecode = 0;
gssize _tmp17_ = 0L;
int _tmp18_ = 0;
gboolean _tmp19_ = FALSE;
GSocket* _tmp20_ = NULL;
gboolean _tmp21_ = FALSE;
gboolean _tmp23_ = FALSE;
int _tmp24_ = 0;
_tmp17_ = ret;
ecode = (int) _tmp17_;
_tmp18_ = ecode;
if (_tmp18_ == GNUTLS_E_INTERRUPTED) {
continue;
}
_tmp20_ = self->priv->socket;
_tmp21_ = g_socket_get_blocking (_tmp20_);
if (_tmp21_) {
int _tmp22_ = 0;
_tmp22_ = ecode;
_tmp19_ = _tmp22_ == GNUTLS_E_AGAIN;
} else {
_tmp19_ = FALSE;
}
_tmp23_ = _tmp19_;
if (_tmp23_) {
continue;
}
_tmp24_ = ecode;
fusion_tls_connection_handle_error (self, _tmp24_, 2, &_inner_error_);
if (_inner_error_ != NULL) {
if (_inner_error_->domain == G_IO_ERROR) {
g_propagate_error (error, _inner_error_);
return 0L;
} else {
g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
g_clear_error (&_inner_error_);
return 0L;
}
}
continue;
}
break;
}
result = ret;
return result;
}
int
main (int argc,
char *argv[])
{
GSocket *socket, *new_socket, *recv_socket;
GSocketAddress *src_address;
GSocketAddress *address;
GSocketType socket_type;
GError *error = NULL;
GOptionContext *context;
GCancellable *cancellable;
g_thread_init (NULL);
g_type_init ();
context = g_option_context_new (" - Test GSocket server stuff");
g_option_context_add_main_entries (context, cmd_entries, NULL);
if (!g_option_context_parse (context, &argc, &argv, &error))
{
g_printerr ("%s: %s\n", argv[0], error->message);
return 1;
}
if (cancel_timeout)
{
cancellable = g_cancellable_new ();
g_thread_create (cancel_thread, cancellable, FALSE, NULL);
}
else
{
cancellable = NULL;
}
loop = g_main_loop_new (NULL, FALSE);
if (use_udp)
socket_type = G_SOCKET_TYPE_DATAGRAM;
else
socket_type = G_SOCKET_TYPE_STREAM;
socket = g_socket_new (G_SOCKET_FAMILY_IPV4, socket_type, 0, &error);
if (socket == NULL)
{
g_printerr ("%s: %s\n", argv[0], error->message);
return 1;
}
if (non_blocking)
g_socket_set_blocking (socket, FALSE);
src_address = g_inet_socket_address_new (g_inet_address_new_any (G_SOCKET_FAMILY_IPV4), port);
if (!g_socket_bind (socket, src_address, !dont_reuse_address, &error))
{
g_printerr ("Can't bind socket: %s\n", error->message);
return 1;
}
if (!use_udp)
{
if (!g_socket_listen (socket, &error))
{
g_printerr ("Can't listen on socket: %s\n", error->message);
return 1;
}
g_print ("listening on port %d...\n", port);
ensure_condition (socket, "accept", cancellable, G_IO_IN);
new_socket = g_socket_accept (socket, &error);
if (!new_socket)
{
g_printerr ("Error accepting socket: %s\n",
error->message);
return 1;
}
if (non_blocking)
g_socket_set_blocking (new_socket, FALSE);
address = g_socket_get_remote_address (new_socket, &error);
if (!address)
{
g_printerr ("Error getting remote address: %s\n",
error->message);
return 1;
}
g_print ("got a new connection from %s (blocking: %d)\n",
socket_address_to_string (address),
g_socket_get_blocking (new_socket));
recv_socket = new_socket;
}
else
{
recv_socket = socket;
new_socket = NULL;
}
while (TRUE)
{
gchar buffer[4096] = { };
gssize size;
gsize to_send;
ensure_condition (recv_socket, "receive", cancellable, G_IO_IN);
if (use_udp)
size = g_socket_receive_from (recv_socket, &address,
buffer, sizeof buffer, &error);
else
size = g_socket_receive (recv_socket, buffer, sizeof buffer, &error);
if (size < 0)
{
g_printerr ("Error receiving from socket: %s\n",
error->message);
return 1;
}
if (size == 0)
break;
g_print ("received %" G_GSSIZE_FORMAT " bytes of data", size);
if (use_udp)
g_print (" from %s", socket_address_to_string (address));
g_print ("\n");
if (verbose)
g_print ("-------------------------\n"
"%.*s\n"
"-------------------------\n",
(int)size, buffer);
to_send = size;
while (to_send > 0)
{
ensure_condition (recv_socket, "send", cancellable, G_IO_OUT);
if (use_udp)
size = g_socket_send_to (recv_socket, address,
buffer, to_send, &error);
else
size = g_socket_send (recv_socket, buffer, to_send, &error);
if (size < 0)
{
if (g_error_matches (error,
G_IO_ERROR,
G_IO_ERROR_WOULD_BLOCK))
{
g_print ("socket send would block, handling\n");
g_error_free (error);
error = NULL;
continue;
}
else
{
g_printerr ("Error sending to socket: %s\n",
error->message);
return 1;
}
}
g_print ("sent %" G_GSSIZE_FORMAT " bytes of data\n", size);
if (size == 0)
{
g_printerr ("Unexpected short write\n");
return 1;
}
to_send -= size;
}
}
g_print ("connection closed\n");
if (new_socket)
{
if (!g_socket_close (new_socket, &error))
{
g_printerr ("Error closing connection socket: %s\n",
error->message);
return 1;
}
g_object_unref (G_OBJECT (new_socket));
}
if (!g_socket_close (socket, &error))
{
g_printerr ("Error closing master socket: %s\n",
error->message);
return 1;
}
g_object_unref (G_OBJECT (socket));
return 0;
}
