mirrors/gstreamer
mirrors/gstreamer
1
1
Fork 0
mirror of https://gitlab.freedesktop.org/gstreamer/gstreamer.git synced 2024-11-25 03:01:03 +00:00
Code Issues 1 Projects Releases Wiki Activity
gstreamer/libs/gst/helpers/gst-ptp-helper.c

690 lines
21 KiB
C
Raw Normal View History

ptp: Initial implementation of a PTP clock GstPtpClock implements a PTP (IEEE1588:2008) ordinary clock in slave-only mode, that allows a GStreamer pipeline to synchronize to a PTP network clock in some specific domain. The PTP subsystem can be initialized with gst_ptp_init(), which then starts a helper process to do the actual communication via the PTP ports. This is required as PTP listens on ports < 1024 and thus requires special privileges. Once this helper process is started, the main process will synchronize to all PTP domains that are detected on the selected interfaces. gst_ptp_clock_new() then allows to create a GstClock that provides the PTP time from a master clock inside a specific PTP domain. This clock will only return valid timestamps once the timestamps in the PTP domain are known. To check this, the GstPtpClock::internal-clock property and the related notify::clock signal can be used. Once the internal clock is not NULL, the PTP domain's time is known. Alternatively you can wait for this with gst_ptp_clock_wait_ready(). To gather statistics about the PTP clock synchronization, gst_ptp_statistics_callback_add() can be used. This gives the application the possibility to collect all kinds of statistics from the clock synchronization. https://bugzilla.gnome.org/show_bug.cgi?id=749391
2015-05-14 10:18:25 +00:00
/* GStreamer
* Copyright (C) 2015 Sebastian Dröge <sebastian@centricular.com>
*
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the
* Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
* Boston, MA 02110-1301, USA.
*/
/* Helper process that runs setuid root or with appropriate privileges to
* listen on ports < 1024, do multicast operations and get MAC addresses of
* interfaces. Privileges are dropped after these operations are done.
*
* It listens on the PTP multicast group on port 319 and 320 and forwards
* everything received there to stdout, while forwarding everything received
* on stdout to those sockets.
* Additionally it provides the MAC address of a network interface via stdout
*/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <errno.h>
#include <sys/ioctl.h>
gst-ptp-helper: #include <sys/socket.h> to fix net/if.h include on OSX 10.6 In file included from gst-ptp-helper.c:40:0: /usr/include/net/if.h:265:19: error: field 'ifru_addr' has incomplete type struct sockaddr ifru_addr; https://bugzilla.gnome.org/show_bug.cgi?id=756136
2015-10-07 10:25:52 +00:00
#include <sys/socket.h>
ptp: Initial implementation of a PTP clock GstPtpClock implements a PTP (IEEE1588:2008) ordinary clock in slave-only mode, that allows a GStreamer pipeline to synchronize to a PTP network clock in some specific domain. The PTP subsystem can be initialized with gst_ptp_init(), which then starts a helper process to do the actual communication via the PTP ports. This is required as PTP listens on ports < 1024 and thus requires special privileges. Once this helper process is started, the main process will synchronize to all PTP domains that are detected on the selected interfaces. gst_ptp_clock_new() then allows to create a GstClock that provides the PTP time from a master clock inside a specific PTP domain. This clock will only return valid timestamps once the timestamps in the PTP domain are known. To check this, the GstPtpClock::internal-clock property and the related notify::clock signal can be used. Once the internal clock is not NULL, the PTP domain's time is known. Alternatively you can wait for this with gst_ptp_clock_wait_ready(). To gather statistics about the PTP clock synchronization, gst_ptp_statistics_callback_add() can be used. This gives the application the possibility to collect all kinds of statistics from the clock synchronization. https://bugzilla.gnome.org/show_bug.cgi?id=749391
2015-05-14 10:18:25 +00:00
#include <net/if.h>
#include <netinet/in.h>
#include <string.h>
ptp: Check for the actual API we use instead of just looking for __APPLE__ Should fix the build on FreeBSD, DragonFly and other BSDs. https://bugzilla.gnome.org/show_bug.cgi?id=750530
2015-06-09 08:59:42 +00:00
#ifdef HAVE_GETIFADDRS_AF_LINK
ptp-helper: Fix interface listing and MAC retrieval on OSX
2015-06-04 16:00:50 +00:00
#include <ifaddrs.h>
#include <net/if_dl.h>
#endif
ptp: Initial implementation of a PTP clock GstPtpClock implements a PTP (IEEE1588:2008) ordinary clock in slave-only mode, that allows a GStreamer pipeline to synchronize to a PTP network clock in some specific domain. The PTP subsystem can be initialized with gst_ptp_init(), which then starts a helper process to do the actual communication via the PTP ports. This is required as PTP listens on ports < 1024 and thus requires special privileges. Once this helper process is started, the main process will synchronize to all PTP domains that are detected on the selected interfaces. gst_ptp_clock_new() then allows to create a GstClock that provides the PTP time from a master clock inside a specific PTP domain. This clock will only return valid timestamps once the timestamps in the PTP domain are known. To check this, the GstPtpClock::internal-clock property and the related notify::clock signal can be used. Once the internal clock is not NULL, the PTP domain's time is known. Alternatively you can wait for this with gst_ptp_clock_wait_ready(). To gather statistics about the PTP clock synchronization, gst_ptp_statistics_callback_add() can be used. This gives the application the possibility to collect all kinds of statistics from the clock synchronization. https://bugzilla.gnome.org/show_bug.cgi?id=749391
2015-05-14 10:18:25 +00:00
#ifdef HAVE_PTP_HELPER_SETUID
#include <grp.h>
#include <pwd.h>
#endif
#ifdef HAVE_PTP_HELPER_CAPABILITIES
#include <sys/capability.h>
#endif
#include <glib.h>
#include <gio/gio.h>
#include <gst/gst.h>
#include <gst/net/gstptp_private.h>
#define PTP_MULTICAST_GROUP "224.0.1.129"
#define PTP_EVENT_PORT 319
#define PTP_GENERAL_PORT 320
static gchar **ifaces = NULL;
static gboolean verbose = FALSE;
static guint64 clock_id = (guint64) - 1;
static guint8 clock_id_array[8];
static GOptionEntry opt_entries[] = {
{"interface", 'i', 0, G_OPTION_ARG_STRING_ARRAY, &ifaces,
"Interface to listen on", NULL},
{"clock-id", 'c', 0, G_OPTION_ARG_INT64, &clock_id,
"PTP clock id", NULL},
{"verbose", 'v', 0, G_OPTION_ARG_NONE, &verbose,
"Be verbose", NULL},
{NULL}
};
static GSocketAddress *event_saddr, *general_saddr;
static GSocket *socket_event, *socket_general;
static GIOChannel *stdin_channel, *stdout_channel;
static gboolean
have_socket_data_cb (GSocket * socket, GIOCondition condition,
gpointer user_data)
{
gchar buffer[8192];
gssize read;
gsize written;
GError *err = NULL;
GIOStatus status;
StdIOHeader header = { 0, };
read = g_socket_receive (socket, buffer, sizeof (buffer), NULL, &err);
if (read == -1)
g_error ("Failed to read from socket: %s", err->message);
gstreamer: Fix memory leaks when context parse fails When g_option_context_parse fails, context and error variables are not getting free'd which results in memory leaks. Free'ing the same. And replacing g_error_free with g_clear_error, which checks if the error being passed is not NULL and sets the variable to NULL on free'ing. https://bugzilla.gnome.org/show_bug.cgi?id=753851
2015-08-20 07:21:59 +00:00
g_clear_error (&err);
ptp: Initial implementation of a PTP clock GstPtpClock implements a PTP (IEEE1588:2008) ordinary clock in slave-only mode, that allows a GStreamer pipeline to synchronize to a PTP network clock in some specific domain. The PTP subsystem can be initialized with gst_ptp_init(), which then starts a helper process to do the actual communication via the PTP ports. This is required as PTP listens on ports < 1024 and thus requires special privileges. Once this helper process is started, the main process will synchronize to all PTP domains that are detected on the selected interfaces. gst_ptp_clock_new() then allows to create a GstClock that provides the PTP time from a master clock inside a specific PTP domain. This clock will only return valid timestamps once the timestamps in the PTP domain are known. To check this, the GstPtpClock::internal-clock property and the related notify::clock signal can be used. Once the internal clock is not NULL, the PTP domain's time is known. Alternatively you can wait for this with gst_ptp_clock_wait_ready(). To gather statistics about the PTP clock synchronization, gst_ptp_statistics_callback_add() can be used. This gives the application the possibility to collect all kinds of statistics from the clock synchronization. https://bugzilla.gnome.org/show_bug.cgi?id=749391
2015-05-14 10:18:25 +00:00
if (verbose)
g_message ("Received %" G_GSSIZE_FORMAT " bytes from %s socket", read,
(socket == socket_event ? "event" : "general"));
header.size = read;
header.type = (socket == socket_event) ? TYPE_EVENT : TYPE_GENERAL;
status =
g_io_channel_write_chars (stdout_channel, (gchar *) & header,
sizeof (header), &written, &err);
if (status == G_IO_STATUS_ERROR) {
g_error ("Failed to write to stdout: %s", err->message);
gstreamer: Fix memory leaks when context parse fails When g_option_context_parse fails, context and error variables are not getting free'd which results in memory leaks. Free'ing the same. And replacing g_error_free with g_clear_error, which checks if the error being passed is not NULL and sets the variable to NULL on free'ing. https://bugzilla.gnome.org/show_bug.cgi?id=753851
2015-08-20 07:21:59 +00:00
g_clear_error (&err);
ptp: Initial implementation of a PTP clock GstPtpClock implements a PTP (IEEE1588:2008) ordinary clock in slave-only mode, that allows a GStreamer pipeline to synchronize to a PTP network clock in some specific domain. The PTP subsystem can be initialized with gst_ptp_init(), which then starts a helper process to do the actual communication via the PTP ports. This is required as PTP listens on ports < 1024 and thus requires special privileges. Once this helper process is started, the main process will synchronize to all PTP domains that are detected on the selected interfaces. gst_ptp_clock_new() then allows to create a GstClock that provides the PTP time from a master clock inside a specific PTP domain. This clock will only return valid timestamps once the timestamps in the PTP domain are known. To check this, the GstPtpClock::internal-clock property and the related notify::clock signal can be used. Once the internal clock is not NULL, the PTP domain's time is known. Alternatively you can wait for this with gst_ptp_clock_wait_ready(). To gather statistics about the PTP clock synchronization, gst_ptp_statistics_callback_add() can be used. This gives the application the possibility to collect all kinds of statistics from the clock synchronization. https://bugzilla.gnome.org/show_bug.cgi?id=749391
2015-05-14 10:18:25 +00:00
} else if (status == G_IO_STATUS_EOF) {
g_message ("EOF on stdout");
exit (0);
} else if (status != G_IO_STATUS_NORMAL) {
g_error ("Unexpected stdout write status: %d", status);
} else if (written != sizeof (header)) {
g_error ("Unexpected write size: %" G_GSIZE_FORMAT, written);
}
status =
g_io_channel_write_chars (stdout_channel, buffer, read, &written, &err);
if (status == G_IO_STATUS_ERROR) {
g_error ("Failed to write to stdout: %s", err->message);
gstreamer: Fix memory leaks when context parse fails When g_option_context_parse fails, context and error variables are not getting free'd which results in memory leaks. Free'ing the same. And replacing g_error_free with g_clear_error, which checks if the error being passed is not NULL and sets the variable to NULL on free'ing. https://bugzilla.gnome.org/show_bug.cgi?id=753851
2015-08-20 07:21:59 +00:00
g_clear_error (&err);
ptp: Initial implementation of a PTP clock GstPtpClock implements a PTP (IEEE1588:2008) ordinary clock in slave-only mode, that allows a GStreamer pipeline to synchronize to a PTP network clock in some specific domain. The PTP subsystem can be initialized with gst_ptp_init(), which then starts a helper process to do the actual communication via the PTP ports. This is required as PTP listens on ports < 1024 and thus requires special privileges. Once this helper process is started, the main process will synchronize to all PTP domains that are detected on the selected interfaces. gst_ptp_clock_new() then allows to create a GstClock that provides the PTP time from a master clock inside a specific PTP domain. This clock will only return valid timestamps once the timestamps in the PTP domain are known. To check this, the GstPtpClock::internal-clock property and the related notify::clock signal can be used. Once the internal clock is not NULL, the PTP domain's time is known. Alternatively you can wait for this with gst_ptp_clock_wait_ready(). To gather statistics about the PTP clock synchronization, gst_ptp_statistics_callback_add() can be used. This gives the application the possibility to collect all kinds of statistics from the clock synchronization. https://bugzilla.gnome.org/show_bug.cgi?id=749391
2015-05-14 10:18:25 +00:00
} else if (status == G_IO_STATUS_EOF) {
g_message ("EOF on stdout");
exit (0);
} else if (status != G_IO_STATUS_NORMAL) {
g_error ("Unexpected stdout write status: %d", status);
} else if (written != read) {
g_error ("Unexpected write size: %" G_GSIZE_FORMAT, written);
}
return G_SOURCE_CONTINUE;
}
static gboolean
have_stdin_data_cb (GIOChannel * channel, GIOCondition condition,
gpointer user_data)
{
GIOStatus status;
StdIOHeader header = { 0, };
gchar buffer[8192];
GError *err = NULL;
gsize read;
gssize written;
if ((condition & G_IO_STATUS_EOF)) {
g_message ("EOF on stdin");
exit (0);
}
status =
g_io_channel_read_chars (channel, (gchar *) & header, sizeof (header),
&read, &err);
if (status == G_IO_STATUS_ERROR) {
g_error ("Failed to read from stdin: %s", err->message);
gstreamer: Fix memory leaks when context parse fails When g_option_context_parse fails, context and error variables are not getting free'd which results in memory leaks. Free'ing the same. And replacing g_error_free with g_clear_error, which checks if the error being passed is not NULL and sets the variable to NULL on free'ing. https://bugzilla.gnome.org/show_bug.cgi?id=753851
2015-08-20 07:21:59 +00:00
g_clear_error (&err);
ptp: Initial implementation of a PTP clock GstPtpClock implements a PTP (IEEE1588:2008) ordinary clock in slave-only mode, that allows a GStreamer pipeline to synchronize to a PTP network clock in some specific domain. The PTP subsystem can be initialized with gst_ptp_init(), which then starts a helper process to do the actual communication via the PTP ports. This is required as PTP listens on ports < 1024 and thus requires special privileges. Once this helper process is started, the main process will synchronize to all PTP domains that are detected on the selected interfaces. gst_ptp_clock_new() then allows to create a GstClock that provides the PTP time from a master clock inside a specific PTP domain. This clock will only return valid timestamps once the timestamps in the PTP domain are known. To check this, the GstPtpClock::internal-clock property and the related notify::clock signal can be used. Once the internal clock is not NULL, the PTP domain's time is known. Alternatively you can wait for this with gst_ptp_clock_wait_ready(). To gather statistics about the PTP clock synchronization, gst_ptp_statistics_callback_add() can be used. This gives the application the possibility to collect all kinds of statistics from the clock synchronization. https://bugzilla.gnome.org/show_bug.cgi?id=749391
2015-05-14 10:18:25 +00:00
} else if (status == G_IO_STATUS_EOF) {
g_message ("EOF on stdin");
exit (0);
} else if (status != G_IO_STATUS_NORMAL) {
g_error ("Unexpected stdin read status: %d", status);
} else if (read != sizeof (header)) {
g_error ("Unexpected read size: %" G_GSIZE_FORMAT, read);
} else if (header.size > 8192) {
g_error ("Unexpected size: %u", header.size);
}
status = g_io_channel_read_chars (channel, buffer, header.size, &read, &err);
if (status == G_IO_STATUS_ERROR) {
g_error ("Failed to read from stdin: %s", err->message);
gstreamer: Fix memory leaks when context parse fails When g_option_context_parse fails, context and error variables are not getting free'd which results in memory leaks. Free'ing the same. And replacing g_error_free with g_clear_error, which checks if the error being passed is not NULL and sets the variable to NULL on free'ing. https://bugzilla.gnome.org/show_bug.cgi?id=753851
2015-08-20 07:21:59 +00:00
g_clear_error (&err);
ptp: Initial implementation of a PTP clock GstPtpClock implements a PTP (IEEE1588:2008) ordinary clock in slave-only mode, that allows a GStreamer pipeline to synchronize to a PTP network clock in some specific domain. The PTP subsystem can be initialized with gst_ptp_init(), which then starts a helper process to do the actual communication via the PTP ports. This is required as PTP listens on ports < 1024 and thus requires special privileges. Once this helper process is started, the main process will synchronize to all PTP domains that are detected on the selected interfaces. gst_ptp_clock_new() then allows to create a GstClock that provides the PTP time from a master clock inside a specific PTP domain. This clock will only return valid timestamps once the timestamps in the PTP domain are known. To check this, the GstPtpClock::internal-clock property and the related notify::clock signal can be used. Once the internal clock is not NULL, the PTP domain's time is known. Alternatively you can wait for this with gst_ptp_clock_wait_ready(). To gather statistics about the PTP clock synchronization, gst_ptp_statistics_callback_add() can be used. This gives the application the possibility to collect all kinds of statistics from the clock synchronization. https://bugzilla.gnome.org/show_bug.cgi?id=749391
2015-05-14 10:18:25 +00:00
} else if (status == G_IO_STATUS_EOF) {
g_message ("EOF on stdin");
exit (0);
} else if (status != G_IO_STATUS_NORMAL) {
g_error ("Unexpected stdin read status: %d", status);
} else if (read != header.size) {
g_error ("Unexpected read size: %" G_GSIZE_FORMAT, read);
}
switch (header.type) {
case TYPE_EVENT:
case TYPE_GENERAL:
written =
g_socket_send_to (header.type ==
TYPE_EVENT ? socket_event : socket_general,
(header.type == TYPE_EVENT ? event_saddr : general_saddr), buffer,
header.size, NULL, &err);
if (written == -1)
g_error ("Failed to write to socket: %s", err->message);
else if (written != header.size)
g_error ("Unexpected write size: %" G_GSSIZE_FORMAT, written);
gstreamer: Fix memory leaks when context parse fails When g_option_context_parse fails, context and error variables are not getting free'd which results in memory leaks. Free'ing the same. And replacing g_error_free with g_clear_error, which checks if the error being passed is not NULL and sets the variable to NULL on free'ing. https://bugzilla.gnome.org/show_bug.cgi?id=753851
2015-08-20 07:21:59 +00:00
g_clear_error (&err);
ptp: Initial implementation of a PTP clock GstPtpClock implements a PTP (IEEE1588:2008) ordinary clock in slave-only mode, that allows a GStreamer pipeline to synchronize to a PTP network clock in some specific domain. The PTP subsystem can be initialized with gst_ptp_init(), which then starts a helper process to do the actual communication via the PTP ports. This is required as PTP listens on ports < 1024 and thus requires special privileges. Once this helper process is started, the main process will synchronize to all PTP domains that are detected on the selected interfaces. gst_ptp_clock_new() then allows to create a GstClock that provides the PTP time from a master clock inside a specific PTP domain. This clock will only return valid timestamps once the timestamps in the PTP domain are known. To check this, the GstPtpClock::internal-clock property and the related notify::clock signal can be used. Once the internal clock is not NULL, the PTP domain's time is known. Alternatively you can wait for this with gst_ptp_clock_wait_ready(). To gather statistics about the PTP clock synchronization, gst_ptp_statistics_callback_add() can be used. This gives the application the possibility to collect all kinds of statistics from the clock synchronization. https://bugzilla.gnome.org/show_bug.cgi?id=749391
2015-05-14 10:18:25 +00:00
if (verbose)
g_message ("Sent %" G_GSSIZE_FORMAT " bytes to %s socket", read,
(header.type == TYPE_EVENT ? "event" : "general"));
break;
default:
break;
}
return G_SOURCE_CONTINUE;
}
static void
setup_sockets (void)
{
GInetAddress *bind_addr, *mcast_addr;
GSocketAddress *bind_saddr;
GSource *socket_event_source, *socket_general_source;
gchar **probed_ifaces = NULL;
GError *err = NULL;
/* Create sockets */
socket_event =
g_socket_new (G_SOCKET_FAMILY_IPV4, G_SOCKET_TYPE_DATAGRAM,
G_SOCKET_PROTOCOL_UDP, &err);
if (!socket_event)
g_error ("Couldn't create event socket: %s", err->message);
gstreamer: Fix memory leaks when context parse fails When g_option_context_parse fails, context and error variables are not getting free'd which results in memory leaks. Free'ing the same. And replacing g_error_free with g_clear_error, which checks if the error being passed is not NULL and sets the variable to NULL on free'ing. https://bugzilla.gnome.org/show_bug.cgi?id=753851
2015-08-20 07:21:59 +00:00
g_clear_error (&err);
ptp-helper: Disable multicast loopback We're not really interested in our own packets and ignore them anyway.
2015-11-18 07:21:23 +00:00
g_socket_set_multicast_loopback (socket_event, FALSE);
ptp: Initial implementation of a PTP clock GstPtpClock implements a PTP (IEEE1588:2008) ordinary clock in slave-only mode, that allows a GStreamer pipeline to synchronize to a PTP network clock in some specific domain. The PTP subsystem can be initialized with gst_ptp_init(), which then starts a helper process to do the actual communication via the PTP ports. This is required as PTP listens on ports < 1024 and thus requires special privileges. Once this helper process is started, the main process will synchronize to all PTP domains that are detected on the selected interfaces. gst_ptp_clock_new() then allows to create a GstClock that provides the PTP time from a master clock inside a specific PTP domain. This clock will only return valid timestamps once the timestamps in the PTP domain are known. To check this, the GstPtpClock::internal-clock property and the related notify::clock signal can be used. Once the internal clock is not NULL, the PTP domain's time is known. Alternatively you can wait for this with gst_ptp_clock_wait_ready(). To gather statistics about the PTP clock synchronization, gst_ptp_statistics_callback_add() can be used. This gives the application the possibility to collect all kinds of statistics from the clock synchronization. https://bugzilla.gnome.org/show_bug.cgi?id=749391
2015-05-14 10:18:25 +00:00
socket_general =
g_socket_new (G_SOCKET_FAMILY_IPV4, G_SOCKET_TYPE_DATAGRAM,
G_SOCKET_PROTOCOL_UDP, &err);
if (!socket_general)
g_error ("Couldn't create general socket: %s", err->message);
gstreamer: Fix memory leaks when context parse fails When g_option_context_parse fails, context and error variables are not getting free'd which results in memory leaks. Free'ing the same. And replacing g_error_free with g_clear_error, which checks if the error being passed is not NULL and sets the variable to NULL on free'ing. https://bugzilla.gnome.org/show_bug.cgi?id=753851
2015-08-20 07:21:59 +00:00
g_clear_error (&err);
ptp-helper: Disable multicast loopback We're not really interested in our own packets and ignore them anyway.
2015-11-18 07:21:23 +00:00
g_socket_set_multicast_loopback (socket_general, FALSE);
ptp: Initial implementation of a PTP clock GstPtpClock implements a PTP (IEEE1588:2008) ordinary clock in slave-only mode, that allows a GStreamer pipeline to synchronize to a PTP network clock in some specific domain. The PTP subsystem can be initialized with gst_ptp_init(), which then starts a helper process to do the actual communication via the PTP ports. This is required as PTP listens on ports < 1024 and thus requires special privileges. Once this helper process is started, the main process will synchronize to all PTP domains that are detected on the selected interfaces. gst_ptp_clock_new() then allows to create a GstClock that provides the PTP time from a master clock inside a specific PTP domain. This clock will only return valid timestamps once the timestamps in the PTP domain are known. To check this, the GstPtpClock::internal-clock property and the related notify::clock signal can be used. Once the internal clock is not NULL, the PTP domain's time is known. Alternatively you can wait for this with gst_ptp_clock_wait_ready(). To gather statistics about the PTP clock synchronization, gst_ptp_statistics_callback_add() can be used. This gives the application the possibility to collect all kinds of statistics from the clock synchronization. https://bugzilla.gnome.org/show_bug.cgi?id=749391
2015-05-14 10:18:25 +00:00
/* Bind sockets */
bind_addr = g_inet_address_new_any (G_SOCKET_FAMILY_IPV4);
bind_saddr = g_inet_socket_address_new (bind_addr, PTP_EVENT_PORT);
if (!g_socket_bind (socket_event, bind_saddr, TRUE, &err))
g_error ("Couldn't bind event socket: %s", err->message);
g_object_unref (bind_saddr);
bind_saddr = g_inet_socket_address_new (bind_addr, PTP_GENERAL_PORT);
if (!g_socket_bind (socket_general, bind_saddr, TRUE, &err))
g_error ("Couldn't bind general socket: %s", err->message);
g_object_unref (bind_saddr);
g_object_unref (bind_addr);
/* Probe all non-loopback interfaces */
if (!ifaces) {
ptp: Check for the actual API we use instead of just looking for __APPLE__ Should fix the build on FreeBSD, DragonFly and other BSDs. https://bugzilla.gnome.org/show_bug.cgi?id=750530
2015-06-09 08:59:42 +00:00
#if defined(HAVE_SIOCGIFCONF_SIOCGIFFLAGS_SIOCGIFHWADDR)
ptp: Initial implementation of a PTP clock GstPtpClock implements a PTP (IEEE1588:2008) ordinary clock in slave-only mode, that allows a GStreamer pipeline to synchronize to a PTP network clock in some specific domain. The PTP subsystem can be initialized with gst_ptp_init(), which then starts a helper process to do the actual communication via the PTP ports. This is required as PTP listens on ports < 1024 and thus requires special privileges. Once this helper process is started, the main process will synchronize to all PTP domains that are detected on the selected interfaces. gst_ptp_clock_new() then allows to create a GstClock that provides the PTP time from a master clock inside a specific PTP domain. This clock will only return valid timestamps once the timestamps in the PTP domain are known. To check this, the GstPtpClock::internal-clock property and the related notify::clock signal can be used. Once the internal clock is not NULL, the PTP domain's time is known. Alternatively you can wait for this with gst_ptp_clock_wait_ready(). To gather statistics about the PTP clock synchronization, gst_ptp_statistics_callback_add() can be used. This gives the application the possibility to collect all kinds of statistics from the clock synchronization. https://bugzilla.gnome.org/show_bug.cgi?id=749391
2015-05-14 10:18:25 +00:00
struct ifreq ifr;
struct ifconf ifc;
gchar buf[8192];
ifc.ifc_len = sizeof (buf);
ifc.ifc_buf = buf;
if (ioctl (g_socket_get_fd (socket_event), SIOCGIFCONF, &ifc) != -1) {
ptp-helper: Fix interface listing and MAC retrieval on OSX
2015-06-04 16:00:50 +00:00
guint i, idx = 0;
ptp: Initial implementation of a PTP clock GstPtpClock implements a PTP (IEEE1588:2008) ordinary clock in slave-only mode, that allows a GStreamer pipeline to synchronize to a PTP network clock in some specific domain. The PTP subsystem can be initialized with gst_ptp_init(), which then starts a helper process to do the actual communication via the PTP ports. This is required as PTP listens on ports < 1024 and thus requires special privileges. Once this helper process is started, the main process will synchronize to all PTP domains that are detected on the selected interfaces. gst_ptp_clock_new() then allows to create a GstClock that provides the PTP time from a master clock inside a specific PTP domain. This clock will only return valid timestamps once the timestamps in the PTP domain are known. To check this, the GstPtpClock::internal-clock property and the related notify::clock signal can be used. Once the internal clock is not NULL, the PTP domain's time is known. Alternatively you can wait for this with gst_ptp_clock_wait_ready(). To gather statistics about the PTP clock synchronization, gst_ptp_statistics_callback_add() can be used. This gives the application the possibility to collect all kinds of statistics from the clock synchronization. https://bugzilla.gnome.org/show_bug.cgi?id=749391
2015-05-14 10:18:25 +00:00
probed_ifaces = g_new0 (gchar *, ifc.ifc_len + 1);
ptp-helper: Fix interface listing and MAC retrieval on OSX
2015-06-04 16:00:50 +00:00
for (i = 0; i < ifc.ifc_len / sizeof (struct ifreq); i++) {
ptp: Ensure that not too much is read from or written to struct ifreq.ifr_name
2015-06-08 10:02:39 +00:00
strncpy (ifr.ifr_name, ifc.ifc_req[i].ifr_name, IFNAMSIZ);
ptp: Initial implementation of a PTP clock GstPtpClock implements a PTP (IEEE1588:2008) ordinary clock in slave-only mode, that allows a GStreamer pipeline to synchronize to a PTP network clock in some specific domain. The PTP subsystem can be initialized with gst_ptp_init(), which then starts a helper process to do the actual communication via the PTP ports. This is required as PTP listens on ports < 1024 and thus requires special privileges. Once this helper process is started, the main process will synchronize to all PTP domains that are detected on the selected interfaces. gst_ptp_clock_new() then allows to create a GstClock that provides the PTP time from a master clock inside a specific PTP domain. This clock will only return valid timestamps once the timestamps in the PTP domain are known. To check this, the GstPtpClock::internal-clock property and the related notify::clock signal can be used. Once the internal clock is not NULL, the PTP domain's time is known. Alternatively you can wait for this with gst_ptp_clock_wait_ready(). To gather statistics about the PTP clock synchronization, gst_ptp_statistics_callback_add() can be used. This gives the application the possibility to collect all kinds of statistics from the clock synchronization. https://bugzilla.gnome.org/show_bug.cgi?id=749391
2015-05-14 10:18:25 +00:00
if (ioctl (g_socket_get_fd (socket_event), SIOCGIFFLAGS, &ifr) == 0) {
if ((ifr.ifr_flags & IFF_LOOPBACK))
continue;
ptp: Ensure that not too much is read from or written to struct ifreq.ifr_name
2015-06-08 10:02:39 +00:00
probed_ifaces[idx] = g_strndup (ifc.ifc_req[i].ifr_name, IFNAMSIZ);
ptp: Initial implementation of a PTP clock GstPtpClock implements a PTP (IEEE1588:2008) ordinary clock in slave-only mode, that allows a GStreamer pipeline to synchronize to a PTP network clock in some specific domain. The PTP subsystem can be initialized with gst_ptp_init(), which then starts a helper process to do the actual communication via the PTP ports. This is required as PTP listens on ports < 1024 and thus requires special privileges. Once this helper process is started, the main process will synchronize to all PTP domains that are detected on the selected interfaces. gst_ptp_clock_new() then allows to create a GstClock that provides the PTP time from a master clock inside a specific PTP domain. This clock will only return valid timestamps once the timestamps in the PTP domain are known. To check this, the GstPtpClock::internal-clock property and the related notify::clock signal can be used. Once the internal clock is not NULL, the PTP domain's time is known. Alternatively you can wait for this with gst_ptp_clock_wait_ready(). To gather statistics about the PTP clock synchronization, gst_ptp_statistics_callback_add() can be used. This gives the application the possibility to collect all kinds of statistics from the clock synchronization. https://bugzilla.gnome.org/show_bug.cgi?id=749391
2015-05-14 10:18:25 +00:00
idx++;
} else {
ptp-helper: Fix interface listing and MAC retrieval on OSX
2015-06-04 16:00:50 +00:00
g_warning ("can't get flags of interface '%s'",
ifc.ifc_req[i].ifr_name);
ptp: Ensure that not too much is read from or written to struct ifreq.ifr_name
2015-06-08 10:02:39 +00:00
probed_ifaces[idx] = g_strndup (ifc.ifc_req[i].ifr_name, IFNAMSIZ);
ptp: Initial implementation of a PTP clock GstPtpClock implements a PTP (IEEE1588:2008) ordinary clock in slave-only mode, that allows a GStreamer pipeline to synchronize to a PTP network clock in some specific domain. The PTP subsystem can be initialized with gst_ptp_init(), which then starts a helper process to do the actual communication via the PTP ports. This is required as PTP listens on ports < 1024 and thus requires special privileges. Once this helper process is started, the main process will synchronize to all PTP domains that are detected on the selected interfaces. gst_ptp_clock_new() then allows to create a GstClock that provides the PTP time from a master clock inside a specific PTP domain. This clock will only return valid timestamps once the timestamps in the PTP domain are known. To check this, the GstPtpClock::internal-clock property and the related notify::clock signal can be used. Once the internal clock is not NULL, the PTP domain's time is known. Alternatively you can wait for this with gst_ptp_clock_wait_ready(). To gather statistics about the PTP clock synchronization, gst_ptp_statistics_callback_add() can be used. This gives the application the possibility to collect all kinds of statistics from the clock synchronization. https://bugzilla.gnome.org/show_bug.cgi?id=749391
2015-05-14 10:18:25 +00:00
idx++;
}
ptp-helper: Fix interface listing and MAC retrieval on OSX
2015-06-04 16:00:50 +00:00
if (idx != 0)
ifaces = probed_ifaces;
ptp: Initial implementation of a PTP clock GstPtpClock implements a PTP (IEEE1588:2008) ordinary clock in slave-only mode, that allows a GStreamer pipeline to synchronize to a PTP network clock in some specific domain. The PTP subsystem can be initialized with gst_ptp_init(), which then starts a helper process to do the actual communication via the PTP ports. This is required as PTP listens on ports < 1024 and thus requires special privileges. Once this helper process is started, the main process will synchronize to all PTP domains that are detected on the selected interfaces. gst_ptp_clock_new() then allows to create a GstClock that provides the PTP time from a master clock inside a specific PTP domain. This clock will only return valid timestamps once the timestamps in the PTP domain are known. To check this, the GstPtpClock::internal-clock property and the related notify::clock signal can be used. Once the internal clock is not NULL, the PTP domain's time is known. Alternatively you can wait for this with gst_ptp_clock_wait_ready(). To gather statistics about the PTP clock synchronization, gst_ptp_statistics_callback_add() can be used. This gives the application the possibility to collect all kinds of statistics from the clock synchronization. https://bugzilla.gnome.org/show_bug.cgi?id=749391
2015-05-14 10:18:25 +00:00
}
ptp-helper: Fix interface listing and MAC retrieval on OSX
2015-06-04 16:00:50 +00:00
}
ptp: Check for the actual API we use instead of just looking for __APPLE__ Should fix the build on FreeBSD, DragonFly and other BSDs. https://bugzilla.gnome.org/show_bug.cgi?id=750530
2015-06-09 08:59:42 +00:00
#elif defined(HAVE_GETIFADDRS_AF_LINK)
ptp-helper: Fix interface listing and MAC retrieval on OSX
2015-06-04 16:00:50 +00:00
struct ifaddrs *ifaddr, *ifa;
if (getifaddrs (&ifaddr) != -1) {
GPtrArray *arr;
arr = g_ptr_array_new ();
for (ifa = ifaddr; ifa; ifa = ifa->ifa_next) {
if ((ifa->ifa_flags & IFF_LOOPBACK))
continue;
ptp: Initial implementation of a PTP clock GstPtpClock implements a PTP (IEEE1588:2008) ordinary clock in slave-only mode, that allows a GStreamer pipeline to synchronize to a PTP network clock in some specific domain. The PTP subsystem can be initialized with gst_ptp_init(), which then starts a helper process to do the actual communication via the PTP ports. This is required as PTP listens on ports < 1024 and thus requires special privileges. Once this helper process is started, the main process will synchronize to all PTP domains that are detected on the selected interfaces. gst_ptp_clock_new() then allows to create a GstClock that provides the PTP time from a master clock inside a specific PTP domain. This clock will only return valid timestamps once the timestamps in the PTP domain are known. To check this, the GstPtpClock::internal-clock property and the related notify::clock signal can be used. Once the internal clock is not NULL, the PTP domain's time is known. Alternatively you can wait for this with gst_ptp_clock_wait_ready(). To gather statistics about the PTP clock synchronization, gst_ptp_statistics_callback_add() can be used. This gives the application the possibility to collect all kinds of statistics from the clock synchronization. https://bugzilla.gnome.org/show_bug.cgi?id=749391
2015-05-14 10:18:25 +00:00
ptp-helper: Fix interface listing and MAC retrieval on OSX
2015-06-04 16:00:50 +00:00
if (!ifa->ifa_addr || ifa->ifa_addr->sa_family != AF_LINK)
continue;
g_ptr_array_add (arr, g_strdup (ifa->ifa_name));
}
freeifaddrs (ifaddr);
g_ptr_array_add (arr, NULL);
ifaces = probed_ifaces = (gchar **) g_ptr_array_free (arr, FALSE);
ptp: Initial implementation of a PTP clock GstPtpClock implements a PTP (IEEE1588:2008) ordinary clock in slave-only mode, that allows a GStreamer pipeline to synchronize to a PTP network clock in some specific domain. The PTP subsystem can be initialized with gst_ptp_init(), which then starts a helper process to do the actual communication via the PTP ports. This is required as PTP listens on ports < 1024 and thus requires special privileges. Once this helper process is started, the main process will synchronize to all PTP domains that are detected on the selected interfaces. gst_ptp_clock_new() then allows to create a GstClock that provides the PTP time from a master clock inside a specific PTP domain. This clock will only return valid timestamps once the timestamps in the PTP domain are known. To check this, the GstPtpClock::internal-clock property and the related notify::clock signal can be used. Once the internal clock is not NULL, the PTP domain's time is known. Alternatively you can wait for this with gst_ptp_clock_wait_ready(). To gather statistics about the PTP clock synchronization, gst_ptp_statistics_callback_add() can be used. This gives the application the possibility to collect all kinds of statistics from the clock synchronization. https://bugzilla.gnome.org/show_bug.cgi?id=749391
2015-05-14 10:18:25 +00:00
}
ptp: Check for the actual API we use instead of just looking for __APPLE__ Should fix the build on FreeBSD, DragonFly and other BSDs. https://bugzilla.gnome.org/show_bug.cgi?id=750530
2015-06-09 08:59:42 +00:00
#else
#warning "Implement something to list all network interfaces"
ptp-helper: Fix interface listing and MAC retrieval on OSX
2015-06-04 16:00:50 +00:00
#endif
ptp: Initial implementation of a PTP clock GstPtpClock implements a PTP (IEEE1588:2008) ordinary clock in slave-only mode, that allows a GStreamer pipeline to synchronize to a PTP network clock in some specific domain. The PTP subsystem can be initialized with gst_ptp_init(), which then starts a helper process to do the actual communication via the PTP ports. This is required as PTP listens on ports < 1024 and thus requires special privileges. Once this helper process is started, the main process will synchronize to all PTP domains that are detected on the selected interfaces. gst_ptp_clock_new() then allows to create a GstClock that provides the PTP time from a master clock inside a specific PTP domain. This clock will only return valid timestamps once the timestamps in the PTP domain are known. To check this, the GstPtpClock::internal-clock property and the related notify::clock signal can be used. Once the internal clock is not NULL, the PTP domain's time is known. Alternatively you can wait for this with gst_ptp_clock_wait_ready(). To gather statistics about the PTP clock synchronization, gst_ptp_statistics_callback_add() can be used. This gives the application the possibility to collect all kinds of statistics from the clock synchronization. https://bugzilla.gnome.org/show_bug.cgi?id=749391
2015-05-14 10:18:25 +00:00
}
/* Get a clock id from the MAC address if none was given */
if (clock_id == (guint64) - 1) {
gboolean success = FALSE;
ptp: Check for the actual API we use instead of just looking for __APPLE__ Should fix the build on FreeBSD, DragonFly and other BSDs. https://bugzilla.gnome.org/show_bug.cgi?id=750530
2015-06-09 08:59:42 +00:00
#if defined(HAVE_SIOCGIFCONF_SIOCGIFFLAGS_SIOCGIFHWADDR)
ptp: Don't use SIOCGIFHWADDR on Apple Just #ifdef the code for now, this should be implemented around IOKit later instead of using ioctls.
2015-06-03 15:06:09 +00:00
struct ifreq ifr;
ptp: Initial implementation of a PTP clock GstPtpClock implements a PTP (IEEE1588:2008) ordinary clock in slave-only mode, that allows a GStreamer pipeline to synchronize to a PTP network clock in some specific domain. The PTP subsystem can be initialized with gst_ptp_init(), which then starts a helper process to do the actual communication via the PTP ports. This is required as PTP listens on ports < 1024 and thus requires special privileges. Once this helper process is started, the main process will synchronize to all PTP domains that are detected on the selected interfaces. gst_ptp_clock_new() then allows to create a GstClock that provides the PTP time from a master clock inside a specific PTP domain. This clock will only return valid timestamps once the timestamps in the PTP domain are known. To check this, the GstPtpClock::internal-clock property and the related notify::clock signal can be used. Once the internal clock is not NULL, the PTP domain's time is known. Alternatively you can wait for this with gst_ptp_clock_wait_ready(). To gather statistics about the PTP clock synchronization, gst_ptp_statistics_callback_add() can be used. This gives the application the possibility to collect all kinds of statistics from the clock synchronization. https://bugzilla.gnome.org/show_bug.cgi?id=749391
2015-05-14 10:18:25 +00:00
if (ifaces) {
gchar **ptr = ifaces;
while (*ptr) {
gst: Use memcpy() instead of strncpy() where appropriate strncpy() is assumed to be for strings so the compiler assumes that it will need an extra byte for the string-terminaning NULL. For cases where we know it's actually "binary" data, just copy it with memcpy. https://bugzilla.gnome.org/show_bug.cgi?id=795756
2018-05-04 07:29:22 +00:00
memcpy (ifr.ifr_name, *ptr, IFNAMSIZ);
ptp: Initial implementation of a PTP clock GstPtpClock implements a PTP (IEEE1588:2008) ordinary clock in slave-only mode, that allows a GStreamer pipeline to synchronize to a PTP network clock in some specific domain. The PTP subsystem can be initialized with gst_ptp_init(), which then starts a helper process to do the actual communication via the PTP ports. This is required as PTP listens on ports < 1024 and thus requires special privileges. Once this helper process is started, the main process will synchronize to all PTP domains that are detected on the selected interfaces. gst_ptp_clock_new() then allows to create a GstClock that provides the PTP time from a master clock inside a specific PTP domain. This clock will only return valid timestamps once the timestamps in the PTP domain are known. To check this, the GstPtpClock::internal-clock property and the related notify::clock signal can be used. Once the internal clock is not NULL, the PTP domain's time is known. Alternatively you can wait for this with gst_ptp_clock_wait_ready(). To gather statistics about the PTP clock synchronization, gst_ptp_statistics_callback_add() can be used. This gives the application the possibility to collect all kinds of statistics from the clock synchronization. https://bugzilla.gnome.org/show_bug.cgi?id=749391
2015-05-14 10:18:25 +00:00
if (ioctl (g_socket_get_fd (socket_event), SIOCGIFHWADDR, &ifr) == 0) {
clock_id_array[0] = ifr.ifr_hwaddr.sa_data[0];
clock_id_array[1] = ifr.ifr_hwaddr.sa_data[1];
clock_id_array[2] = ifr.ifr_hwaddr.sa_data[2];
clock_id_array[3] = 0xff;
clock_id_array[4] = 0xfe;
clock_id_array[5] = ifr.ifr_hwaddr.sa_data[3];
clock_id_array[6] = ifr.ifr_hwaddr.sa_data[4];
clock_id_array[7] = ifr.ifr_hwaddr.sa_data[5];
success = TRUE;
break;
}
}
ptr++;
} else {
struct ifconf ifc;
gchar buf[8192];
ifc.ifc_len = sizeof (buf);
ifc.ifc_buf = buf;
if (ioctl (g_socket_get_fd (socket_event), SIOCGIFCONF, &ifc) != -1) {
ptp-helper: Fix interface listing and MAC retrieval on OSX
2015-06-04 16:00:50 +00:00
guint i;
ptp: Initial implementation of a PTP clock GstPtpClock implements a PTP (IEEE1588:2008) ordinary clock in slave-only mode, that allows a GStreamer pipeline to synchronize to a PTP network clock in some specific domain. The PTP subsystem can be initialized with gst_ptp_init(), which then starts a helper process to do the actual communication via the PTP ports. This is required as PTP listens on ports < 1024 and thus requires special privileges. Once this helper process is started, the main process will synchronize to all PTP domains that are detected on the selected interfaces. gst_ptp_clock_new() then allows to create a GstClock that provides the PTP time from a master clock inside a specific PTP domain. This clock will only return valid timestamps once the timestamps in the PTP domain are known. To check this, the GstPtpClock::internal-clock property and the related notify::clock signal can be used. Once the internal clock is not NULL, the PTP domain's time is known. Alternatively you can wait for this with gst_ptp_clock_wait_ready(). To gather statistics about the PTP clock synchronization, gst_ptp_statistics_callback_add() can be used. This gives the application the possibility to collect all kinds of statistics from the clock synchronization. https://bugzilla.gnome.org/show_bug.cgi?id=749391
2015-05-14 10:18:25 +00:00
ptp-helper: Fix interface listing and MAC retrieval on OSX
2015-06-04 16:00:50 +00:00
for (i = 0; i < ifc.ifc_len / sizeof (struct ifreq); i++) {
ptp: Ensure that not too much is read from or written to struct ifreq.ifr_name
2015-06-08 10:02:39 +00:00
strncpy (ifr.ifr_name, ifc.ifc_req[i].ifr_name, IFNAMSIZ);
ptp: Initial implementation of a PTP clock GstPtpClock implements a PTP (IEEE1588:2008) ordinary clock in slave-only mode, that allows a GStreamer pipeline to synchronize to a PTP network clock in some specific domain. The PTP subsystem can be initialized with gst_ptp_init(), which then starts a helper process to do the actual communication via the PTP ports. This is required as PTP listens on ports < 1024 and thus requires special privileges. Once this helper process is started, the main process will synchronize to all PTP domains that are detected on the selected interfaces. gst_ptp_clock_new() then allows to create a GstClock that provides the PTP time from a master clock inside a specific PTP domain. This clock will only return valid timestamps once the timestamps in the PTP domain are known. To check this, the GstPtpClock::internal-clock property and the related notify::clock signal can be used. Once the internal clock is not NULL, the PTP domain's time is known. Alternatively you can wait for this with gst_ptp_clock_wait_ready(). To gather statistics about the PTP clock synchronization, gst_ptp_statistics_callback_add() can be used. This gives the application the possibility to collect all kinds of statistics from the clock synchronization. https://bugzilla.gnome.org/show_bug.cgi?id=749391
2015-05-14 10:18:25 +00:00
if (ioctl (g_socket_get_fd (socket_event), SIOCGIFFLAGS, &ifr) == 0) {
if ((ifr.ifr_flags & IFF_LOOPBACK))
continue;
if (ioctl (g_socket_get_fd (socket_event), SIOCGIFHWADDR,
&ifr) == 0) {
clock_id_array[0] = ifr.ifr_hwaddr.sa_data[0];
clock_id_array[1] = ifr.ifr_hwaddr.sa_data[1];
clock_id_array[2] = ifr.ifr_hwaddr.sa_data[2];
clock_id_array[3] = 0xff;
clock_id_array[4] = 0xfe;
clock_id_array[5] = ifr.ifr_hwaddr.sa_data[3];
clock_id_array[6] = ifr.ifr_hwaddr.sa_data[4];
clock_id_array[7] = ifr.ifr_hwaddr.sa_data[5];
success = TRUE;
break;
}
} else {
ptp-helper: Fix interface listing and MAC retrieval on OSX
2015-06-04 16:00:50 +00:00
g_warning ("can't get flags of interface '%s'",
ifc.ifc_req[i].ifr_name);
}
}
}
}
ptp: Check for the actual API we use instead of just looking for __APPLE__ Should fix the build on FreeBSD, DragonFly and other BSDs. https://bugzilla.gnome.org/show_bug.cgi?id=750530
2015-06-09 08:59:42 +00:00
#elif defined(HAVE_GETIFADDRS_AF_LINK)
ptp-helper: Fix interface listing and MAC retrieval on OSX
2015-06-04 16:00:50 +00:00
struct ifaddrs *ifaddr, *ifa;
if (getifaddrs (&ifaddr) != -1) {
for (ifa = ifaddr; ifa; ifa = ifa->ifa_next) {
struct sockaddr_dl *sdl = (struct sockaddr_dl *) ifa->ifa_addr;
guint8 mac_addr[6];
if ((ifa->ifa_flags & IFF_LOOPBACK))
continue;
if (!ifa->ifa_addr || ifa->ifa_addr->sa_family != AF_LINK)
continue;
if (ifaces) {
gchar **p = ifaces;
gboolean found = FALSE;
while (*p) {
if (strcmp (*p, ifa->ifa_name) == 0) {
found = TRUE;
break;
}
p++;
ptp: Initial implementation of a PTP clock GstPtpClock implements a PTP (IEEE1588:2008) ordinary clock in slave-only mode, that allows a GStreamer pipeline to synchronize to a PTP network clock in some specific domain. The PTP subsystem can be initialized with gst_ptp_init(), which then starts a helper process to do the actual communication via the PTP ports. This is required as PTP listens on ports < 1024 and thus requires special privileges. Once this helper process is started, the main process will synchronize to all PTP domains that are detected on the selected interfaces. gst_ptp_clock_new() then allows to create a GstClock that provides the PTP time from a master clock inside a specific PTP domain. This clock will only return valid timestamps once the timestamps in the PTP domain are known. To check this, the GstPtpClock::internal-clock property and the related notify::clock signal can be used. Once the internal clock is not NULL, the PTP domain's time is known. Alternatively you can wait for this with gst_ptp_clock_wait_ready(). To gather statistics about the PTP clock synchronization, gst_ptp_statistics_callback_add() can be used. This gives the application the possibility to collect all kinds of statistics from the clock synchronization. https://bugzilla.gnome.org/show_bug.cgi?id=749391
2015-05-14 10:18:25 +00:00
}
ptp-helper: Fix interface listing and MAC retrieval on OSX
2015-06-04 16:00:50 +00:00
if (!found)
continue;
ptp: Initial implementation of a PTP clock GstPtpClock implements a PTP (IEEE1588:2008) ordinary clock in slave-only mode, that allows a GStreamer pipeline to synchronize to a PTP network clock in some specific domain. The PTP subsystem can be initialized with gst_ptp_init(), which then starts a helper process to do the actual communication via the PTP ports. This is required as PTP listens on ports < 1024 and thus requires special privileges. Once this helper process is started, the main process will synchronize to all PTP domains that are detected on the selected interfaces. gst_ptp_clock_new() then allows to create a GstClock that provides the PTP time from a master clock inside a specific PTP domain. This clock will only return valid timestamps once the timestamps in the PTP domain are known. To check this, the GstPtpClock::internal-clock property and the related notify::clock signal can be used. Once the internal clock is not NULL, the PTP domain's time is known. Alternatively you can wait for this with gst_ptp_clock_wait_ready(). To gather statistics about the PTP clock synchronization, gst_ptp_statistics_callback_add() can be used. This gives the application the possibility to collect all kinds of statistics from the clock synchronization. https://bugzilla.gnome.org/show_bug.cgi?id=749391
2015-05-14 10:18:25 +00:00
}
ptp-helper: Fix interface listing and MAC retrieval on OSX
2015-06-04 16:00:50 +00:00
if (sdl->sdl_alen != 6)
continue;
memcpy (mac_addr, LLADDR (sdl), sdl->sdl_alen);
clock_id_array[0] = mac_addr[0];
clock_id_array[1] = mac_addr[1];
clock_id_array[2] = mac_addr[2];
clock_id_array[3] = 0xff;
clock_id_array[4] = 0xfe;
clock_id_array[5] = mac_addr[3];
clock_id_array[6] = mac_addr[4];
clock_id_array[7] = mac_addr[5];
success = TRUE;
break;
ptp: Initial implementation of a PTP clock GstPtpClock implements a PTP (IEEE1588:2008) ordinary clock in slave-only mode, that allows a GStreamer pipeline to synchronize to a PTP network clock in some specific domain. The PTP subsystem can be initialized with gst_ptp_init(), which then starts a helper process to do the actual communication via the PTP ports. This is required as PTP listens on ports < 1024 and thus requires special privileges. Once this helper process is started, the main process will synchronize to all PTP domains that are detected on the selected interfaces. gst_ptp_clock_new() then allows to create a GstClock that provides the PTP time from a master clock inside a specific PTP domain. This clock will only return valid timestamps once the timestamps in the PTP domain are known. To check this, the GstPtpClock::internal-clock property and the related notify::clock signal can be used. Once the internal clock is not NULL, the PTP domain's time is known. Alternatively you can wait for this with gst_ptp_clock_wait_ready(). To gather statistics about the PTP clock synchronization, gst_ptp_statistics_callback_add() can be used. This gives the application the possibility to collect all kinds of statistics from the clock synchronization. https://bugzilla.gnome.org/show_bug.cgi?id=749391
2015-05-14 10:18:25 +00:00
}
ptp-helper: Fix interface listing and MAC retrieval on OSX
2015-06-04 16:00:50 +00:00
freeifaddrs (ifaddr);
ptp: Initial implementation of a PTP clock GstPtpClock implements a PTP (IEEE1588:2008) ordinary clock in slave-only mode, that allows a GStreamer pipeline to synchronize to a PTP network clock in some specific domain. The PTP subsystem can be initialized with gst_ptp_init(), which then starts a helper process to do the actual communication via the PTP ports. This is required as PTP listens on ports < 1024 and thus requires special privileges. Once this helper process is started, the main process will synchronize to all PTP domains that are detected on the selected interfaces. gst_ptp_clock_new() then allows to create a GstClock that provides the PTP time from a master clock inside a specific PTP domain. This clock will only return valid timestamps once the timestamps in the PTP domain are known. To check this, the GstPtpClock::internal-clock property and the related notify::clock signal can be used. Once the internal clock is not NULL, the PTP domain's time is known. Alternatively you can wait for this with gst_ptp_clock_wait_ready(). To gather statistics about the PTP clock synchronization, gst_ptp_statistics_callback_add() can be used. This gives the application the possibility to collect all kinds of statistics from the clock synchronization. https://bugzilla.gnome.org/show_bug.cgi?id=749391
2015-05-14 10:18:25 +00:00
}
ptp: Check for the actual API we use instead of just looking for __APPLE__ Should fix the build on FreeBSD, DragonFly and other BSDs. https://bugzilla.gnome.org/show_bug.cgi?id=750530
2015-06-09 08:59:42 +00:00
#else
#warning "Implement something to get MAC addresses of network interfaces"
ptp: Don't use SIOCGIFHWADDR on Apple Just #ifdef the code for now, this should be implemented around IOKit later instead of using ioctls.
2015-06-03 15:06:09 +00:00
#endif
ptp: Initial implementation of a PTP clock GstPtpClock implements a PTP (IEEE1588:2008) ordinary clock in slave-only mode, that allows a GStreamer pipeline to synchronize to a PTP network clock in some specific domain. The PTP subsystem can be initialized with gst_ptp_init(), which then starts a helper process to do the actual communication via the PTP ports. This is required as PTP listens on ports < 1024 and thus requires special privileges. Once this helper process is started, the main process will synchronize to all PTP domains that are detected on the selected interfaces. gst_ptp_clock_new() then allows to create a GstClock that provides the PTP time from a master clock inside a specific PTP domain. This clock will only return valid timestamps once the timestamps in the PTP domain are known. To check this, the GstPtpClock::internal-clock property and the related notify::clock signal can be used. Once the internal clock is not NULL, the PTP domain's time is known. Alternatively you can wait for this with gst_ptp_clock_wait_ready(). To gather statistics about the PTP clock synchronization, gst_ptp_statistics_callback_add() can be used. This gives the application the possibility to collect all kinds of statistics from the clock synchronization. https://bugzilla.gnome.org/show_bug.cgi?id=749391
2015-05-14 10:18:25 +00:00
if (!success) {
g_warning ("can't get any MAC address, using random clock id");
clock_id = (((guint64) g_random_int ()) << 32) | (g_random_int ());
GST_WRITE_UINT64_BE (clock_id_array, clock_id);
clock_id_array[3] = 0xff;
clock_id_array[4] = 0xfe;
}
} else {
GST_WRITE_UINT64_BE (clock_id_array, clock_id);
}
/* Join multicast groups */
mcast_addr = g_inet_address_new_from_string (PTP_MULTICAST_GROUP);
if (ifaces) {
gchar **ptr = ifaces;
gboolean success = FALSE;
while (*ptr) {
gint c = 0;
if (!g_socket_join_multicast_group (socket_event, mcast_addr, FALSE, *ptr,
ptp-helper: Fix interface listing and MAC retrieval on OSX
2015-06-04 16:00:50 +00:00
&err)
&& !g_error_matches (err, G_IO_ERROR, G_IO_ERROR_ADDRESS_IN_USE))
g_warning ("Couldn't join multicast group on interface '%s': %s", *ptr,
err->message);
ptp: Initial implementation of a PTP clock GstPtpClock implements a PTP (IEEE1588:2008) ordinary clock in slave-only mode, that allows a GStreamer pipeline to synchronize to a PTP network clock in some specific domain. The PTP subsystem can be initialized with gst_ptp_init(), which then starts a helper process to do the actual communication via the PTP ports. This is required as PTP listens on ports < 1024 and thus requires special privileges. Once this helper process is started, the main process will synchronize to all PTP domains that are detected on the selected interfaces. gst_ptp_clock_new() then allows to create a GstClock that provides the PTP time from a master clock inside a specific PTP domain. This clock will only return valid timestamps once the timestamps in the PTP domain are known. To check this, the GstPtpClock::internal-clock property and the related notify::clock signal can be used. Once the internal clock is not NULL, the PTP domain's time is known. Alternatively you can wait for this with gst_ptp_clock_wait_ready(). To gather statistics about the PTP clock synchronization, gst_ptp_statistics_callback_add() can be used. This gives the application the possibility to collect all kinds of statistics from the clock synchronization. https://bugzilla.gnome.org/show_bug.cgi?id=749391
2015-05-14 10:18:25 +00:00
else
c++;
ptp-helper: Fix interface listing and MAC retrieval on OSX
2015-06-04 16:00:50 +00:00
g_clear_error (&err);
ptp: Initial implementation of a PTP clock GstPtpClock implements a PTP (IEEE1588:2008) ordinary clock in slave-only mode, that allows a GStreamer pipeline to synchronize to a PTP network clock in some specific domain. The PTP subsystem can be initialized with gst_ptp_init(), which then starts a helper process to do the actual communication via the PTP ports. This is required as PTP listens on ports < 1024 and thus requires special privileges. Once this helper process is started, the main process will synchronize to all PTP domains that are detected on the selected interfaces. gst_ptp_clock_new() then allows to create a GstClock that provides the PTP time from a master clock inside a specific PTP domain. This clock will only return valid timestamps once the timestamps in the PTP domain are known. To check this, the GstPtpClock::internal-clock property and the related notify::clock signal can be used. Once the internal clock is not NULL, the PTP domain's time is known. Alternatively you can wait for this with gst_ptp_clock_wait_ready(). To gather statistics about the PTP clock synchronization, gst_ptp_statistics_callback_add() can be used. This gives the application the possibility to collect all kinds of statistics from the clock synchronization. https://bugzilla.gnome.org/show_bug.cgi?id=749391
2015-05-14 10:18:25 +00:00
if (!g_socket_join_multicast_group (socket_general, mcast_addr, FALSE,
ptp-helper: Fix interface listing and MAC retrieval on OSX
2015-06-04 16:00:50 +00:00
*ptr, &err)
&& !g_error_matches (err, G_IO_ERROR, G_IO_ERROR_ADDRESS_IN_USE))
g_warning ("Couldn't join multicast group on interface '%s': %s", *ptr,
err->message);
ptp: Initial implementation of a PTP clock GstPtpClock implements a PTP (IEEE1588:2008) ordinary clock in slave-only mode, that allows a GStreamer pipeline to synchronize to a PTP network clock in some specific domain. The PTP subsystem can be initialized with gst_ptp_init(), which then starts a helper process to do the actual communication via the PTP ports. This is required as PTP listens on ports < 1024 and thus requires special privileges. Once this helper process is started, the main process will synchronize to all PTP domains that are detected on the selected interfaces. gst_ptp_clock_new() then allows to create a GstClock that provides the PTP time from a master clock inside a specific PTP domain. This clock will only return valid timestamps once the timestamps in the PTP domain are known. To check this, the GstPtpClock::internal-clock property and the related notify::clock signal can be used. Once the internal clock is not NULL, the PTP domain's time is known. Alternatively you can wait for this with gst_ptp_clock_wait_ready(). To gather statistics about the PTP clock synchronization, gst_ptp_statistics_callback_add() can be used. This gives the application the possibility to collect all kinds of statistics from the clock synchronization. https://bugzilla.gnome.org/show_bug.cgi?id=749391
2015-05-14 10:18:25 +00:00
else
c++;
ptp-helper: Fix interface listing and MAC retrieval on OSX
2015-06-04 16:00:50 +00:00
g_clear_error (&err);
ptp: Initial implementation of a PTP clock GstPtpClock implements a PTP (IEEE1588:2008) ordinary clock in slave-only mode, that allows a GStreamer pipeline to synchronize to a PTP network clock in some specific domain. The PTP subsystem can be initialized with gst_ptp_init(), which then starts a helper process to do the actual communication via the PTP ports. This is required as PTP listens on ports < 1024 and thus requires special privileges. Once this helper process is started, the main process will synchronize to all PTP domains that are detected on the selected interfaces. gst_ptp_clock_new() then allows to create a GstClock that provides the PTP time from a master clock inside a specific PTP domain. This clock will only return valid timestamps once the timestamps in the PTP domain are known. To check this, the GstPtpClock::internal-clock property and the related notify::clock signal can be used. Once the internal clock is not NULL, the PTP domain's time is known. Alternatively you can wait for this with gst_ptp_clock_wait_ready(). To gather statistics about the PTP clock synchronization, gst_ptp_statistics_callback_add() can be used. This gives the application the possibility to collect all kinds of statistics from the clock synchronization. https://bugzilla.gnome.org/show_bug.cgi?id=749391
2015-05-14 10:18:25 +00:00
if (c == 2)
success = TRUE;
ptr++;
}
if (!success) {
/* Join multicast group without any interface */
if (!g_socket_join_multicast_group (socket_event, mcast_addr, FALSE, NULL,
&err))
g_error ("Couldn't join multicast group: %s", err->message);
gstreamer: Fix memory leaks when context parse fails When g_option_context_parse fails, context and error variables are not getting free'd which results in memory leaks. Free'ing the same. And replacing g_error_free with g_clear_error, which checks if the error being passed is not NULL and sets the variable to NULL on free'ing. https://bugzilla.gnome.org/show_bug.cgi?id=753851
2015-08-20 07:21:59 +00:00
g_clear_error (&err);
ptp: Initial implementation of a PTP clock GstPtpClock implements a PTP (IEEE1588:2008) ordinary clock in slave-only mode, that allows a GStreamer pipeline to synchronize to a PTP network clock in some specific domain. The PTP subsystem can be initialized with gst_ptp_init(), which then starts a helper process to do the actual communication via the PTP ports. This is required as PTP listens on ports < 1024 and thus requires special privileges. Once this helper process is started, the main process will synchronize to all PTP domains that are detected on the selected interfaces. gst_ptp_clock_new() then allows to create a GstClock that provides the PTP time from a master clock inside a specific PTP domain. This clock will only return valid timestamps once the timestamps in the PTP domain are known. To check this, the GstPtpClock::internal-clock property and the related notify::clock signal can be used. Once the internal clock is not NULL, the PTP domain's time is known. Alternatively you can wait for this with gst_ptp_clock_wait_ready(). To gather statistics about the PTP clock synchronization, gst_ptp_statistics_callback_add() can be used. This gives the application the possibility to collect all kinds of statistics from the clock synchronization. https://bugzilla.gnome.org/show_bug.cgi?id=749391
2015-05-14 10:18:25 +00:00
if (!g_socket_join_multicast_group (socket_general, mcast_addr, FALSE,
NULL, &err))
g_error ("Couldn't join multicast group: %s", err->message);
gstreamer: Fix memory leaks when context parse fails When g_option_context_parse fails, context and error variables are not getting free'd which results in memory leaks. Free'ing the same. And replacing g_error_free with g_clear_error, which checks if the error being passed is not NULL and sets the variable to NULL on free'ing. https://bugzilla.gnome.org/show_bug.cgi?id=753851
2015-08-20 07:21:59 +00:00
g_clear_error (&err);
ptp: Initial implementation of a PTP clock GstPtpClock implements a PTP (IEEE1588:2008) ordinary clock in slave-only mode, that allows a GStreamer pipeline to synchronize to a PTP network clock in some specific domain. The PTP subsystem can be initialized with gst_ptp_init(), which then starts a helper process to do the actual communication via the PTP ports. This is required as PTP listens on ports < 1024 and thus requires special privileges. Once this helper process is started, the main process will synchronize to all PTP domains that are detected on the selected interfaces. gst_ptp_clock_new() then allows to create a GstClock that provides the PTP time from a master clock inside a specific PTP domain. This clock will only return valid timestamps once the timestamps in the PTP domain are known. To check this, the GstPtpClock::internal-clock property and the related notify::clock signal can be used. Once the internal clock is not NULL, the PTP domain's time is known. Alternatively you can wait for this with gst_ptp_clock_wait_ready(). To gather statistics about the PTP clock synchronization, gst_ptp_statistics_callback_add() can be used. This gives the application the possibility to collect all kinds of statistics from the clock synchronization. https://bugzilla.gnome.org/show_bug.cgi?id=749391
2015-05-14 10:18:25 +00:00
}
} else {
/* Join multicast group without any interface */
if (!g_socket_join_multicast_group (socket_event, mcast_addr, FALSE, NULL,
&err))
g_error ("Couldn't join multicast group: %s", err->message);
gstreamer: Fix memory leaks when context parse fails When g_option_context_parse fails, context and error variables are not getting free'd which results in memory leaks. Free'ing the same. And replacing g_error_free with g_clear_error, which checks if the error being passed is not NULL and sets the variable to NULL on free'ing. https://bugzilla.gnome.org/show_bug.cgi?id=753851
2015-08-20 07:21:59 +00:00
g_clear_error (&err);
ptp: Initial implementation of a PTP clock GstPtpClock implements a PTP (IEEE1588:2008) ordinary clock in slave-only mode, that allows a GStreamer pipeline to synchronize to a PTP network clock in some specific domain. The PTP subsystem can be initialized with gst_ptp_init(), which then starts a helper process to do the actual communication via the PTP ports. This is required as PTP listens on ports < 1024 and thus requires special privileges. Once this helper process is started, the main process will synchronize to all PTP domains that are detected on the selected interfaces. gst_ptp_clock_new() then allows to create a GstClock that provides the PTP time from a master clock inside a specific PTP domain. This clock will only return valid timestamps once the timestamps in the PTP domain are known. To check this, the GstPtpClock::internal-clock property and the related notify::clock signal can be used. Once the internal clock is not NULL, the PTP domain's time is known. Alternatively you can wait for this with gst_ptp_clock_wait_ready(). To gather statistics about the PTP clock synchronization, gst_ptp_statistics_callback_add() can be used. This gives the application the possibility to collect all kinds of statistics from the clock synchronization. https://bugzilla.gnome.org/show_bug.cgi?id=749391
2015-05-14 10:18:25 +00:00
if (!g_socket_join_multicast_group (socket_general, mcast_addr, FALSE, NULL,
&err))
g_error ("Couldn't join multicast group: %s", err->message);
gstreamer: Fix memory leaks when context parse fails When g_option_context_parse fails, context and error variables are not getting free'd which results in memory leaks. Free'ing the same. And replacing g_error_free with g_clear_error, which checks if the error being passed is not NULL and sets the variable to NULL on free'ing. https://bugzilla.gnome.org/show_bug.cgi?id=753851
2015-08-20 07:21:59 +00:00
g_clear_error (&err);
ptp: Initial implementation of a PTP clock GstPtpClock implements a PTP (IEEE1588:2008) ordinary clock in slave-only mode, that allows a GStreamer pipeline to synchronize to a PTP network clock in some specific domain. The PTP subsystem can be initialized with gst_ptp_init(), which then starts a helper process to do the actual communication via the PTP ports. This is required as PTP listens on ports < 1024 and thus requires special privileges. Once this helper process is started, the main process will synchronize to all PTP domains that are detected on the selected interfaces. gst_ptp_clock_new() then allows to create a GstClock that provides the PTP time from a master clock inside a specific PTP domain. This clock will only return valid timestamps once the timestamps in the PTP domain are known. To check this, the GstPtpClock::internal-clock property and the related notify::clock signal can be used. Once the internal clock is not NULL, the PTP domain's time is known. Alternatively you can wait for this with gst_ptp_clock_wait_ready(). To gather statistics about the PTP clock synchronization, gst_ptp_statistics_callback_add() can be used. This gives the application the possibility to collect all kinds of statistics from the clock synchronization. https://bugzilla.gnome.org/show_bug.cgi?id=749391
2015-05-14 10:18:25 +00:00
}
event_saddr = g_inet_socket_address_new (mcast_addr, PTP_EVENT_PORT);
general_saddr = g_inet_socket_address_new (mcast_addr, PTP_GENERAL_PORT);
/* Create socket sources */
socket_event_source =
g_socket_create_source (socket_event, G_IO_IN | G_IO_PRI, NULL);
g_source_set_priority (socket_event_source, G_PRIORITY_HIGH);
g_source_set_callback (socket_event_source, (GSourceFunc) have_socket_data_cb,
NULL, NULL);
g_source_attach (socket_event_source, NULL);
socket_general_source =
g_socket_create_source (socket_general, G_IO_IN | G_IO_PRI, NULL);
g_source_set_priority (socket_general_source, G_PRIORITY_DEFAULT);
g_source_set_callback (socket_general_source,
(GSourceFunc) have_socket_data_cb, NULL, NULL);
g_source_attach (socket_general_source, NULL);
g_strfreev (probed_ifaces);
}
static void
drop_privileges (void)
{
#ifdef HAVE_PTP_HELPER_SETUID
/* Switch to the given user/group */
#ifdef HAVE_PTP_HELPER_SETUID_GROUP
{
struct group *grp;
grp = getgrnam (HAVE_PTP_HELPER_SETUID_GROUP);
if (!grp)
g_error ("Failed to get group information '%s': %s",
HAVE_PTP_HELPER_SETUID_GROUP, g_strerror (errno));
if (setgid (grp->gr_gid) != 0)
g_error ("Failed to change to group '%s': %s",
HAVE_PTP_HELPER_SETUID_GROUP, g_strerror (errno));
}
#endif
#ifdef HAVE_PTP_HELPER_SETUID_USER
{
struct passwd *pwd;
pwd = getpwnam (HAVE_PTP_HELPER_SETUID_USER);
if (!pwd)
g_error ("Failed to get user information '%s': %s",
HAVE_PTP_HELPER_SETUID_USER, g_strerror (errno));
#ifndef HAVE_PTP_HELPER_SETUID_GROUP
if (setgid (pwd->pw_gid) != 0)
g_error ("Failed to change to user group '%s': %s",
HAVE_PTP_HELPER_SETUID_USER, g_strerror (errno));
#endif
if (setuid (pwd->pw_uid) != 0)
g_error ("Failed to change to user '%s': %s", HAVE_PTP_HELPER_SETUID_USER,
g_strerror (errno));
}
#endif
#endif
#ifdef HAVE_PTP_HELPER_CAPABILITIES
/* Drop all capabilities */
{
cap_t caps;
caps = cap_get_proc ();
if (caps == 0)
g_error ("Failed to get process caps: %s", g_strerror (errno));
if (cap_clear (caps) != 0)
g_error ("Failed to clear caps: %s", g_strerror (errno));
if (cap_set_proc (caps) != 0)
g_error ("Failed to set process caps: %s", g_strerror (errno));
}
#endif
}
static void
setup_stdio_channels (void)
{
GSource *stdin_source;
/* Create stdin source */
stdin_channel = g_io_channel_unix_new (STDIN_FILENO);
if (g_io_channel_set_encoding (stdin_channel, NULL,
NULL) == G_IO_STATUS_ERROR)
g_error ("Failed to set stdin to binary encoding");
g_io_channel_set_buffered (stdin_channel, FALSE);
stdin_source =
g_io_create_watch (stdin_channel, G_IO_IN | G_IO_PRI | G_IO_HUP);
g_source_set_priority (stdin_source, G_PRIORITY_DEFAULT);
g_source_set_callback (stdin_source, (GSourceFunc) have_stdin_data_cb, NULL,
NULL);
g_source_attach (stdin_source, NULL);
/* Create stdout channel */
stdout_channel = g_io_channel_unix_new (STDOUT_FILENO);
if (g_io_channel_set_encoding (stdout_channel, NULL,
NULL) == G_IO_STATUS_ERROR)
g_error ("Failed to set stdout to binary encoding");
g_io_channel_set_buffered (stdout_channel, FALSE);
}
static void
write_clock_id (void)
{
GError *err = NULL;
GIOStatus status;
StdIOHeader header = { 0, };
gsize written;
/* Write clock id to stdout */
header.type = TYPE_CLOCK_ID;
header.size = 8;
status =
g_io_channel_write_chars (stdout_channel, (gchar *) & header,
sizeof (header), &written, &err);
if (status == G_IO_STATUS_ERROR) {
g_error ("Failed to write to stdout: %s", err->message);
gstreamer: Fix memory leaks when context parse fails When g_option_context_parse fails, context and error variables are not getting free'd which results in memory leaks. Free'ing the same. And replacing g_error_free with g_clear_error, which checks if the error being passed is not NULL and sets the variable to NULL on free'ing. https://bugzilla.gnome.org/show_bug.cgi?id=753851
2015-08-20 07:21:59 +00:00
g_clear_error (&err);
ptp: Initial implementation of a PTP clock GstPtpClock implements a PTP (IEEE1588:2008) ordinary clock in slave-only mode, that allows a GStreamer pipeline to synchronize to a PTP network clock in some specific domain. The PTP subsystem can be initialized with gst_ptp_init(), which then starts a helper process to do the actual communication via the PTP ports. This is required as PTP listens on ports < 1024 and thus requires special privileges. Once this helper process is started, the main process will synchronize to all PTP domains that are detected on the selected interfaces. gst_ptp_clock_new() then allows to create a GstClock that provides the PTP time from a master clock inside a specific PTP domain. This clock will only return valid timestamps once the timestamps in the PTP domain are known. To check this, the GstPtpClock::internal-clock property and the related notify::clock signal can be used. Once the internal clock is not NULL, the PTP domain's time is known. Alternatively you can wait for this with gst_ptp_clock_wait_ready(). To gather statistics about the PTP clock synchronization, gst_ptp_statistics_callback_add() can be used. This gives the application the possibility to collect all kinds of statistics from the clock synchronization. https://bugzilla.gnome.org/show_bug.cgi?id=749391
2015-05-14 10:18:25 +00:00
} else if (status == G_IO_STATUS_EOF) {
g_message ("EOF on stdout");
exit (0);
} else if (status != G_IO_STATUS_NORMAL) {
g_error ("Unexpected stdout write status: %d", status);
} else if (written != sizeof (header)) {
g_error ("Unexpected write size: %" G_GSIZE_FORMAT, written);
}
status =
g_io_channel_write_chars (stdout_channel,
(const gchar *) clock_id_array, sizeof (clock_id_array), &written, &err);
if (status == G_IO_STATUS_ERROR) {
g_error ("Failed to write to stdout: %s", err->message);
gstreamer: Fix memory leaks when context parse fails When g_option_context_parse fails, context and error variables are not getting free'd which results in memory leaks. Free'ing the same. And replacing g_error_free with g_clear_error, which checks if the error being passed is not NULL and sets the variable to NULL on free'ing. https://bugzilla.gnome.org/show_bug.cgi?id=753851
2015-08-20 07:21:59 +00:00
g_clear_error (&err);
ptp: Initial implementation of a PTP clock GstPtpClock implements a PTP (IEEE1588:2008) ordinary clock in slave-only mode, that allows a GStreamer pipeline to synchronize to a PTP network clock in some specific domain. The PTP subsystem can be initialized with gst_ptp_init(), which then starts a helper process to do the actual communication via the PTP ports. This is required as PTP listens on ports < 1024 and thus requires special privileges. Once this helper process is started, the main process will synchronize to all PTP domains that are detected on the selected interfaces. gst_ptp_clock_new() then allows to create a GstClock that provides the PTP time from a master clock inside a specific PTP domain. This clock will only return valid timestamps once the timestamps in the PTP domain are known. To check this, the GstPtpClock::internal-clock property and the related notify::clock signal can be used. Once the internal clock is not NULL, the PTP domain's time is known. Alternatively you can wait for this with gst_ptp_clock_wait_ready(). To gather statistics about the PTP clock synchronization, gst_ptp_statistics_callback_add() can be used. This gives the application the possibility to collect all kinds of statistics from the clock synchronization. https://bugzilla.gnome.org/show_bug.cgi?id=749391
2015-05-14 10:18:25 +00:00
} else if (status == G_IO_STATUS_EOF) {
g_message ("EOF on stdout");
exit (0);
} else if (status != G_IO_STATUS_NORMAL) {
g_error ("Unexpected stdout write status: %d", status);
} else if (written != sizeof (clock_id_array)) {
g_error ("Unexpected write size: %" G_GSIZE_FORMAT, written);
}
}
ptp-helper: Make sure to use g_poll() for the main context The modified main context from https://bugzilla.gnome.org/show_bug.cgi?id=741054 somehow calls setugid(), which abort()s setuid root applications on OSX.
2015-06-04 17:05:44 +00:00
#ifdef __APPLE__
static gint
dummy_poll (GPollFD * fds, guint nfds, gint timeout)
{
return g_poll (fds, nfds, timeout);
}
#endif
ptp: Initial implementation of a PTP clock GstPtpClock implements a PTP (IEEE1588:2008) ordinary clock in slave-only mode, that allows a GStreamer pipeline to synchronize to a PTP network clock in some specific domain. The PTP subsystem can be initialized with gst_ptp_init(), which then starts a helper process to do the actual communication via the PTP ports. This is required as PTP listens on ports < 1024 and thus requires special privileges. Once this helper process is started, the main process will synchronize to all PTP domains that are detected on the selected interfaces. gst_ptp_clock_new() then allows to create a GstClock that provides the PTP time from a master clock inside a specific PTP domain. This clock will only return valid timestamps once the timestamps in the PTP domain are known. To check this, the GstPtpClock::internal-clock property and the related notify::clock signal can be used. Once the internal clock is not NULL, the PTP domain's time is known. Alternatively you can wait for this with gst_ptp_clock_wait_ready(). To gather statistics about the PTP clock synchronization, gst_ptp_statistics_callback_add() can be used. This gives the application the possibility to collect all kinds of statistics from the clock synchronization. https://bugzilla.gnome.org/show_bug.cgi?id=749391
2015-05-14 10:18:25 +00:00
gint
main (gint argc, gchar ** argv)
{
GOptionContext *opt_ctx;
GMainLoop *loop;
GError *err = NULL;
ptp-helper: Make sure to use g_poll() for the main context The modified main context from https://bugzilla.gnome.org/show_bug.cgi?id=741054 somehow calls setugid(), which abort()s setuid root applications on OSX.
2015-06-04 17:05:44 +00:00
/* FIXME: Work around some side effects of the changes from
* https://bugzilla.gnome.org/show_bug.cgi?id=741054
*
* The modified poll function somehow calls setugid(), which
* then abort()s the application. Make sure that we use g_poll()
* here!
*/
#ifdef __APPLE__
{
GMainContext *context = g_main_context_default ();
g_main_context_set_poll_func (context, dummy_poll);
}
#endif
ptp-helper: Make sure that we are running setuid root if configured that way
2015-06-04 16:32:14 +00:00
#ifdef HAVE_PTP_HELPER_SETUID
if (setuid (0) < 0)
g_error ("not running with superuser privileges");
#endif
ptp: Initial implementation of a PTP clock GstPtpClock implements a PTP (IEEE1588:2008) ordinary clock in slave-only mode, that allows a GStreamer pipeline to synchronize to a PTP network clock in some specific domain. The PTP subsystem can be initialized with gst_ptp_init(), which then starts a helper process to do the actual communication via the PTP ports. This is required as PTP listens on ports < 1024 and thus requires special privileges. Once this helper process is started, the main process will synchronize to all PTP domains that are detected on the selected interfaces. gst_ptp_clock_new() then allows to create a GstClock that provides the PTP time from a master clock inside a specific PTP domain. This clock will only return valid timestamps once the timestamps in the PTP domain are known. To check this, the GstPtpClock::internal-clock property and the related notify::clock signal can be used. Once the internal clock is not NULL, the PTP domain's time is known. Alternatively you can wait for this with gst_ptp_clock_wait_ready(). To gather statistics about the PTP clock synchronization, gst_ptp_statistics_callback_add() can be used. This gives the application the possibility to collect all kinds of statistics from the clock synchronization. https://bugzilla.gnome.org/show_bug.cgi?id=749391
2015-05-14 10:18:25 +00:00
opt_ctx = g_option_context_new ("- GStreamer PTP helper process");
g_option_context_add_main_entries (opt_ctx, opt_entries, NULL);
if (!g_option_context_parse (opt_ctx, &argc, &argv, &err))
g_error ("Error parsing options: %s", err->message);
gstreamer: Fix memory leaks when context parse fails When g_option_context_parse fails, context and error variables are not getting free'd which results in memory leaks. Free'ing the same. And replacing g_error_free with g_clear_error, which checks if the error being passed is not NULL and sets the variable to NULL on free'ing. https://bugzilla.gnome.org/show_bug.cgi?id=753851
2015-08-20 07:21:59 +00:00
g_clear_error (&err);
ptp: Initial implementation of a PTP clock GstPtpClock implements a PTP (IEEE1588:2008) ordinary clock in slave-only mode, that allows a GStreamer pipeline to synchronize to a PTP network clock in some specific domain. The PTP subsystem can be initialized with gst_ptp_init(), which then starts a helper process to do the actual communication via the PTP ports. This is required as PTP listens on ports < 1024 and thus requires special privileges. Once this helper process is started, the main process will synchronize to all PTP domains that are detected on the selected interfaces. gst_ptp_clock_new() then allows to create a GstClock that provides the PTP time from a master clock inside a specific PTP domain. This clock will only return valid timestamps once the timestamps in the PTP domain are known. To check this, the GstPtpClock::internal-clock property and the related notify::clock signal can be used. Once the internal clock is not NULL, the PTP domain's time is known. Alternatively you can wait for this with gst_ptp_clock_wait_ready(). To gather statistics about the PTP clock synchronization, gst_ptp_statistics_callback_add() can be used. This gives the application the possibility to collect all kinds of statistics from the clock synchronization. https://bugzilla.gnome.org/show_bug.cgi?id=749391
2015-05-14 10:18:25 +00:00
g_option_context_free (opt_ctx);
setup_sockets ();
drop_privileges ();
setup_stdio_channels ();
write_clock_id ();
/* Get running */
loop = g_main_loop_new (NULL, FALSE);
g_main_loop_run (loop);
/* We never exit cleanly, so don't do cleanup */
g_assert_not_reached ();
return 0;
}
Reference in a new issue Copy permalink