static void gst_tcp_server_src_set_property (GObject * object, guint prop_id, const GValue * value, GParamSpec * pspec) { GstTCPServerSrc *tcpserversrc = GST_TCP_SERVER_SRC (object); switch (prop_id) { case PROP_HOST: if (!g_value_get_string (value)) { g_warning ("host property cannot be NULL"); break; } g_free (tcpserversrc->host); tcpserversrc->host = g_strdup (g_value_get_string (value)); break; case PROP_PORT: tcpserversrc->server_port = g_value_get_int (value); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } }
/* set up server */ static gboolean gst_tcp_server_src_start (GstBaseSrc * bsrc) { int ret; GstTCPServerSrc *src = GST_TCP_SERVER_SRC (bsrc); /* reset caps_received flag */ src->caps_received = FALSE; /* create the server listener socket */ if ((src->server_sock_fd.fd = socket (AF_INET, SOCK_STREAM, 0)) == -1) goto socket_error; GST_DEBUG_OBJECT (src, "opened receiving server socket with fd %d", src->server_sock_fd.fd); /* make address reusable */ ret = 1; if (setsockopt (src->server_sock_fd.fd, SOL_SOCKET, SO_REUSEADDR, &ret, sizeof (int)) < 0) goto sock_opt; /* name the socket */ memset (&src->server_sin, 0, sizeof (src->server_sin)); src->server_sin.sin_family = AF_INET; /* network socket */ src->server_sin.sin_port = htons (src->server_port); /* on port */ if (src->host) { gchar *host; if (!(host = gst_tcp_host_to_ip (GST_ELEMENT (src), src->host))) goto host_error; src->server_sin.sin_addr.s_addr = inet_addr (host); g_free (host); } else src->server_sin.sin_addr.s_addr = htonl (INADDR_ANY); /* bind it */ GST_DEBUG_OBJECT (src, "binding server socket to address"); if ((ret = bind (src->server_sock_fd.fd, (struct sockaddr *) &src->server_sin, sizeof (src->server_sin))) < 0) goto bind_error; GST_DEBUG_OBJECT (src, "listening on server socket %d with queue of %d", src->server_sock_fd.fd, TCP_BACKLOG); if (listen (src->server_sock_fd.fd, TCP_BACKLOG) == -1) goto listen_error; /* create an fdset to keep track of our file descriptors */ if ((src->fdset = gst_poll_new (TRUE)) == NULL) goto socket_pair; gst_poll_add_fd (src->fdset, &src->server_sock_fd); GST_DEBUG_OBJECT (src, "received client"); GST_OBJECT_FLAG_SET (src, GST_TCP_SERVER_SRC_OPEN); return TRUE; /* ERRORS */ socket_error: { GST_ELEMENT_ERROR (src, RESOURCE, OPEN_READ, (NULL), GST_ERROR_SYSTEM); return FALSE; } sock_opt: { GST_ELEMENT_ERROR (src, RESOURCE, SETTINGS, (NULL), ("Could not setsockopt: %s", g_strerror (errno))); gst_tcp_socket_close (&src->server_sock_fd); return FALSE; } host_error: { gst_tcp_socket_close (&src->server_sock_fd); return FALSE; } bind_error: { gst_tcp_socket_close (&src->server_sock_fd); switch (errno) { default: GST_ELEMENT_ERROR (src, RESOURCE, OPEN_READ, (NULL), ("bind failed: %s", g_strerror (errno))); break; } return FALSE; } listen_error: { gst_tcp_socket_close (&src->server_sock_fd); GST_ELEMENT_ERROR (src, RESOURCE, OPEN_READ, (NULL), ("Could not listen on server socket: %s", g_strerror (errno))); return FALSE; } socket_pair: { GST_ELEMENT_ERROR (src, RESOURCE, OPEN_READ_WRITE, (NULL), GST_ERROR_SYSTEM); gst_tcp_socket_close (&src->server_sock_fd); return FALSE; } }
static GstFlowReturn gst_tcp_server_src_create (GstPushSrc * psrc, GstBuffer ** outbuf) { GstTCPServerSrc *src; GstFlowReturn ret = GST_FLOW_OK; src = GST_TCP_SERVER_SRC (psrc); if (!GST_OBJECT_FLAG_IS_SET (src, GST_TCP_SERVER_SRC_OPEN)) goto wrong_state; restart: if (src->client_sock_fd.fd >= 0) { /* if we have a client, wait for read */ gst_poll_fd_ctl_read (src->fdset, &src->server_sock_fd, FALSE); gst_poll_fd_ctl_read (src->fdset, &src->client_sock_fd, TRUE); } else { /* else wait on server socket for connections */ gst_poll_fd_ctl_read (src->fdset, &src->server_sock_fd, TRUE); } /* no action (0) is an error too in our case */ if ((ret = gst_poll_wait (src->fdset, GST_CLOCK_TIME_NONE)) <= 0) { if (ret == -1 && errno == EBUSY) goto select_cancelled; else goto select_error; } /* if we have no client socket we can accept one now */ if (src->client_sock_fd.fd < 0) { if (gst_poll_fd_can_read (src->fdset, &src->server_sock_fd)) { if ((src->client_sock_fd.fd = accept (src->server_sock_fd.fd, (struct sockaddr *) &src->client_sin, &src->client_sin_len)) == -1) goto accept_error; gst_poll_add_fd (src->fdset, &src->client_sock_fd); } /* and restart now to poll the socket. */ goto restart; } GST_LOG_OBJECT (src, "asked for a buffer"); switch (src->protocol) { case GST_TCP_PROTOCOL_NONE: ret = gst_tcp_read_buffer (GST_ELEMENT (src), src->client_sock_fd.fd, src->fdset, outbuf); break; case GST_TCP_PROTOCOL_GDP: if (!src->caps_received) { GstCaps *caps; gchar *string; ret = gst_tcp_gdp_read_caps (GST_ELEMENT (src), src->client_sock_fd.fd, src->fdset, &caps); if (ret == GST_FLOW_WRONG_STATE) goto gdp_cancelled; if (ret != GST_FLOW_OK) goto gdp_caps_read_error; src->caps_received = TRUE; string = gst_caps_to_string (caps); GST_DEBUG_OBJECT (src, "Received caps through GDP: %s", string); g_free (string); gst_pad_set_caps (GST_BASE_SRC_PAD (psrc), caps); } ret = gst_tcp_gdp_read_buffer (GST_ELEMENT (src), src->client_sock_fd.fd, src->fdset, outbuf); if (ret == GST_FLOW_OK) gst_buffer_set_caps (*outbuf, GST_PAD_CAPS (GST_BASE_SRC_PAD (src))); break; default: /* need to assert as buf == NULL */ g_assert ("Unhandled protocol type"); break; } if (ret == GST_FLOW_OK) { GST_LOG_OBJECT (src, "Returning buffer from _get of size %d, ts %" GST_TIME_FORMAT ", dur %" GST_TIME_FORMAT ", offset %" G_GINT64_FORMAT ", offset_end %" G_GINT64_FORMAT, GST_BUFFER_SIZE (*outbuf), GST_TIME_ARGS (GST_BUFFER_TIMESTAMP (*outbuf)), GST_TIME_ARGS (GST_BUFFER_DURATION (*outbuf)), GST_BUFFER_OFFSET (*outbuf), GST_BUFFER_OFFSET_END (*outbuf)); } return ret; wrong_state: { GST_DEBUG_OBJECT (src, "connection to closed, cannot read data"); return GST_FLOW_WRONG_STATE; } select_error: { GST_ELEMENT_ERROR (src, RESOURCE, READ, (NULL), ("Select error: %s", g_strerror (errno))); return GST_FLOW_ERROR; } select_cancelled: { GST_DEBUG_OBJECT (src, "select canceled"); return GST_FLOW_WRONG_STATE; } accept_error: { GST_ELEMENT_ERROR (src, RESOURCE, OPEN_READ, (NULL), ("Could not accept client on server socket: %s", g_strerror (errno))); return GST_FLOW_ERROR; } gdp_cancelled: { GST_DEBUG_OBJECT (src, "reading gdp canceled"); return GST_FLOW_WRONG_STATE; } gdp_caps_read_error: { /* if we did not get canceled, report an error */ if (ret != GST_FLOW_WRONG_STATE) { GST_ELEMENT_ERROR (src, RESOURCE, READ, (NULL), ("Could not read caps through GDP")); } return ret; } }
/* set up server */ static gboolean gst_tcp_server_src_start (GstBaseSrc * bsrc) { GstTCPServerSrc *src = GST_TCP_SERVER_SRC (bsrc); GError *err = NULL; GInetAddress *addr; GSocketAddress *saddr; GResolver *resolver; /* look up name if we need to */ addr = g_inet_address_new_from_string (src->host); if (!addr) { GList *results; resolver = g_resolver_get_default (); results = g_resolver_lookup_by_name (resolver, src->host, src->cancellable, &err); if (!results) goto name_resolve; addr = G_INET_ADDRESS (g_object_ref (results->data)); g_resolver_free_addresses (results); g_object_unref (resolver); } #ifndef GST_DISABLE_GST_DEBUG { gchar *ip = g_inet_address_to_string (addr); GST_DEBUG_OBJECT (src, "IP address for host %s is %s", src->host, ip); g_free (ip); } #endif saddr = g_inet_socket_address_new (addr, src->server_port); g_object_unref (addr); /* create the server listener socket */ src->server_socket = g_socket_new (g_socket_address_get_family (saddr), G_SOCKET_TYPE_STREAM, G_SOCKET_PROTOCOL_TCP, &err); if (!src->server_socket) goto no_socket; GST_DEBUG_OBJECT (src, "opened receiving server socket"); /* bind it */ GST_DEBUG_OBJECT (src, "binding server socket to address"); if (!g_socket_bind (src->server_socket, saddr, TRUE, &err)) goto bind_failed; g_object_unref (saddr); GST_DEBUG_OBJECT (src, "listening on server socket"); g_socket_set_listen_backlog (src->server_socket, TCP_BACKLOG); if (!g_socket_listen (src->server_socket, &err)) goto listen_failed; GST_OBJECT_FLAG_SET (src, GST_TCP_SERVER_SRC_OPEN); return TRUE; /* ERRORS */ no_socket: { GST_ELEMENT_ERROR (src, RESOURCE, OPEN_READ, (NULL), ("Failed to create socket: %s", err->message)); g_clear_error (&err); g_object_unref (saddr); return FALSE; } name_resolve: { if (g_error_matches (err, G_IO_ERROR, G_IO_ERROR_CANCELLED)) { GST_DEBUG_OBJECT (src, "Cancelled name resolval"); } else { GST_ELEMENT_ERROR (src, RESOURCE, OPEN_READ, (NULL), ("Failed to resolve host '%s': %s", src->host, err->message)); } g_clear_error (&err); g_object_unref (resolver); return FALSE; } bind_failed: { if (g_error_matches (err, G_IO_ERROR, G_IO_ERROR_CANCELLED)) { GST_DEBUG_OBJECT (src, "Cancelled binding"); } else { GST_ELEMENT_ERROR (src, RESOURCE, OPEN_READ, (NULL), ("Failed to bind on host '%s:%d': %s", src->host, src->server_port, err->message)); } g_clear_error (&err); g_object_unref (saddr); gst_tcp_server_src_stop (GST_BASE_SRC (src)); return FALSE; } listen_failed: { if (g_error_matches (err, G_IO_ERROR, G_IO_ERROR_CANCELLED)) { GST_DEBUG_OBJECT (src, "Cancelled listening"); } else { GST_ELEMENT_ERROR (src, RESOURCE, OPEN_READ, (NULL), ("Failed to listen on host '%s:%d': %s", src->host, src->server_port, err->message)); } g_clear_error (&err); gst_tcp_server_src_stop (GST_BASE_SRC (src)); return FALSE; } }
static GstFlowReturn gst_tcp_server_src_create (GstPushSrc * psrc, GstBuffer ** outbuf) { GstTCPServerSrc *src; GstFlowReturn ret = GST_FLOW_OK; gssize rret, avail; gsize read; GError *err = NULL; GstMapInfo map; src = GST_TCP_SERVER_SRC (psrc); if (!GST_OBJECT_FLAG_IS_SET (src, GST_TCP_SERVER_SRC_OPEN)) goto wrong_state; if (!src->client_socket) { /* wait on server socket for connections */ src->client_socket = g_socket_accept (src->server_socket, src->cancellable, &err); if (!src->client_socket) goto accept_error; /* now read from the socket. */ } /* if we have a client, wait for read */ GST_LOG_OBJECT (src, "asked for a buffer"); /* read the buffer header */ avail = g_socket_get_available_bytes (src->client_socket); if (avail < 0) { goto get_available_error; } else if (avail == 0) { GIOCondition condition; if (!g_socket_condition_wait (src->client_socket, G_IO_IN | G_IO_PRI | G_IO_ERR | G_IO_HUP, src->cancellable, &err)) goto select_error; condition = g_socket_condition_check (src->client_socket, G_IO_IN | G_IO_PRI | G_IO_ERR | G_IO_HUP); if ((condition & G_IO_ERR)) { GST_ELEMENT_ERROR (src, RESOURCE, READ, (NULL), ("Socket in error state")); *outbuf = NULL; ret = GST_FLOW_ERROR; goto done; } else if ((condition & G_IO_HUP)) { GST_DEBUG_OBJECT (src, "Connection closed"); *outbuf = NULL; ret = GST_FLOW_EOS; goto done; } avail = g_socket_get_available_bytes (src->client_socket); if (avail < 0) goto get_available_error; } if (avail > 0) { read = MIN (avail, MAX_READ_SIZE); *outbuf = gst_buffer_new_and_alloc (read); gst_buffer_map (*outbuf, &map, GST_MAP_READWRITE); rret = g_socket_receive (src->client_socket, (gchar *) map.data, read, src->cancellable, &err); } else { /* Connection closed */ rret = 0; *outbuf = NULL; read = 0; } if (rret == 0) { GST_DEBUG_OBJECT (src, "Connection closed"); ret = GST_FLOW_EOS; if (*outbuf) { gst_buffer_unmap (*outbuf, &map); gst_buffer_unref (*outbuf); } *outbuf = NULL; } else if (rret < 0) { if (g_error_matches (err, G_IO_ERROR, G_IO_ERROR_CANCELLED)) { ret = GST_FLOW_FLUSHING; GST_DEBUG_OBJECT (src, "Cancelled reading from socket"); } else { ret = GST_FLOW_ERROR; GST_ELEMENT_ERROR (src, RESOURCE, READ, (NULL), ("Failed to read from socket: %s", err->message)); } gst_buffer_unmap (*outbuf, &map); gst_buffer_unref (*outbuf); *outbuf = NULL; } else { ret = GST_FLOW_OK; gst_buffer_unmap (*outbuf, &map); gst_buffer_resize (*outbuf, 0, rret); GST_LOG_OBJECT (src, "Returning buffer from _get of size %" G_GSIZE_FORMAT ", ts %" GST_TIME_FORMAT ", dur %" GST_TIME_FORMAT ", offset %" G_GINT64_FORMAT ", offset_end %" G_GINT64_FORMAT, gst_buffer_get_size (*outbuf), GST_TIME_ARGS (GST_BUFFER_TIMESTAMP (*outbuf)), GST_TIME_ARGS (GST_BUFFER_DURATION (*outbuf)), GST_BUFFER_OFFSET (*outbuf), GST_BUFFER_OFFSET_END (*outbuf)); } g_clear_error (&err); done: return ret; wrong_state: { GST_DEBUG_OBJECT (src, "connection to closed, cannot read data"); return GST_FLOW_FLUSHING; } accept_error: { if (g_error_matches (err, G_IO_ERROR, G_IO_ERROR_CANCELLED)) { GST_DEBUG_OBJECT (src, "Cancelled accepting of client"); } else { GST_ELEMENT_ERROR (src, RESOURCE, OPEN_READ, (NULL), ("Failed to accept client: %s", err->message)); } g_clear_error (&err); return GST_FLOW_ERROR; } select_error: { GST_ELEMENT_ERROR (src, RESOURCE, READ, (NULL), ("Select failed: %s", err->message)); g_clear_error (&err); return GST_FLOW_ERROR; } get_available_error: { GST_ELEMENT_ERROR (src, RESOURCE, READ, (NULL), ("Failed to get available bytes from socket")); return GST_FLOW_ERROR; } }