mirror of
https://gitlab.freedesktop.org/gstreamer/gstreamer.git
synced 2024-12-05 16:06:43 +00:00
1207 lines
28 KiB
C
1207 lines
28 KiB
C
/* GStreamer RTMP Library
|
|
* Copyright (C) 2014 David Schleef <ds@schleef.org>
|
|
* Copyright (C) 2017 Make.TV, Inc. <info@make.tv>
|
|
* Contact: Jan Alexander Steffens (heftig) <jsteffens@make.tv>
|
|
*
|
|
* 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.
|
|
*/
|
|
|
|
#ifdef HAVE_CONFIG_H
|
|
#include "config.h"
|
|
#endif
|
|
|
|
#include "amf.h"
|
|
#include "rtmputils.h"
|
|
#include <string.h>
|
|
#include <gst/gst.h>
|
|
|
|
#define MAX_RECURSION_DEPTH 16
|
|
|
|
GST_DEBUG_CATEGORY_STATIC (gst_rtmp_amf_debug_category);
|
|
#define GST_CAT_DEFAULT gst_rtmp_amf_debug_category
|
|
|
|
static GBytes *empty_bytes;
|
|
|
|
static void
|
|
init_static (void)
|
|
{
|
|
static gsize done = 0;
|
|
if (g_once_init_enter (&done)) {
|
|
empty_bytes = g_bytes_new_static ("", 0);
|
|
GST_DEBUG_CATEGORY_INIT (gst_rtmp_amf_debug_category, "rtmpamf", 0,
|
|
"debug category for the amf parser");
|
|
g_once_init_leave (&done, 1);
|
|
}
|
|
}
|
|
|
|
const gchar *
|
|
gst_amf_type_get_nick (GstAmfType type)
|
|
{
|
|
switch (type) {
|
|
case GST_AMF_TYPE_INVALID:
|
|
return "invalid";
|
|
case GST_AMF_TYPE_NUMBER:
|
|
return "number";
|
|
case GST_AMF_TYPE_BOOLEAN:
|
|
return "boolean";
|
|
case GST_AMF_TYPE_STRING:
|
|
return "string";
|
|
case GST_AMF_TYPE_OBJECT:
|
|
return "object";
|
|
case GST_AMF_TYPE_MOVIECLIP:
|
|
return "movieclip";
|
|
case GST_AMF_TYPE_NULL:
|
|
return "null";
|
|
case GST_AMF_TYPE_UNDEFINED:
|
|
return "undefined";
|
|
case GST_AMF_TYPE_REFERENCE:
|
|
return "reference";
|
|
case GST_AMF_TYPE_ECMA_ARRAY:
|
|
return "ecma-array";
|
|
case GST_AMF_TYPE_OBJECT_END:
|
|
return "object-end";
|
|
case GST_AMF_TYPE_STRICT_ARRAY:
|
|
return "strict-array";
|
|
case GST_AMF_TYPE_DATE:
|
|
return "date";
|
|
case GST_AMF_TYPE_LONG_STRING:
|
|
return "long-string";
|
|
case GST_AMF_TYPE_UNSUPPORTED:
|
|
return "unsupported";
|
|
case GST_AMF_TYPE_RECORDSET:
|
|
return "recordset";
|
|
case GST_AMF_TYPE_XML_DOCUMENT:
|
|
return "xml-document";
|
|
case GST_AMF_TYPE_TYPED_OBJECT:
|
|
return "typed-object";
|
|
case GST_AMF_TYPE_AVMPLUS_OBJECT:
|
|
return "avmplus-object";
|
|
default:
|
|
return "unknown";
|
|
}
|
|
}
|
|
|
|
typedef struct
|
|
{
|
|
gchar *name;
|
|
GstAmfNode *value;
|
|
} AmfObjectField;
|
|
|
|
static void
|
|
amf_object_field_clear (gpointer ptr)
|
|
{
|
|
AmfObjectField *field = ptr;
|
|
g_clear_pointer (&field->name, g_free);
|
|
g_clear_pointer (&field->value, gst_amf_node_free);
|
|
}
|
|
|
|
struct _GstAmfNode
|
|
{
|
|
GstAmfType type;
|
|
union
|
|
{
|
|
gint v_int;
|
|
gdouble v_double;
|
|
GBytes *v_bytes;
|
|
GArray *v_fields;
|
|
GPtrArray *v_elements;
|
|
} value;
|
|
};
|
|
|
|
static inline const AmfObjectField *
|
|
get_field (const GstAmfNode * node, guint index)
|
|
{
|
|
return &g_array_index (node->value.v_fields, const AmfObjectField, index);
|
|
}
|
|
|
|
static inline void
|
|
append_field (GstAmfNode * node, gchar * name, GstAmfNode * value)
|
|
{
|
|
AmfObjectField field = {
|
|
.name = name,
|
|
.value = value,
|
|
};
|
|
g_array_append_val (node->value.v_fields, field);
|
|
}
|
|
|
|
static inline const GstAmfNode *
|
|
get_element (const GstAmfNode * node, guint index)
|
|
{
|
|
return g_ptr_array_index (node->value.v_elements, index);
|
|
}
|
|
|
|
static inline void
|
|
append_element (GstAmfNode * node, GstAmfNode * value)
|
|
{
|
|
g_ptr_array_add (node->value.v_elements, value);
|
|
}
|
|
|
|
static GstAmfNode *
|
|
node_new (GstAmfType type)
|
|
{
|
|
GstAmfNode *node;
|
|
|
|
init_static ();
|
|
|
|
node = g_malloc0 (sizeof *node);
|
|
node->type = type;
|
|
|
|
switch (type) {
|
|
case GST_AMF_TYPE_STRING:
|
|
case GST_AMF_TYPE_LONG_STRING:
|
|
node->value.v_bytes = g_bytes_ref (empty_bytes);
|
|
break;
|
|
|
|
case GST_AMF_TYPE_OBJECT:
|
|
case GST_AMF_TYPE_ECMA_ARRAY:
|
|
node->value.v_fields =
|
|
g_array_new (FALSE, FALSE, sizeof (AmfObjectField));
|
|
g_array_set_clear_func (node->value.v_fields, amf_object_field_clear);
|
|
break;
|
|
|
|
case GST_AMF_TYPE_STRICT_ARRAY:
|
|
node->value.v_elements =
|
|
g_ptr_array_new_with_free_func (gst_amf_node_free);
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return node;
|
|
}
|
|
|
|
GstAmfNode *
|
|
gst_amf_node_new_null (void)
|
|
{
|
|
return node_new (GST_AMF_TYPE_NULL);
|
|
}
|
|
|
|
GstAmfNode *
|
|
gst_amf_node_new_boolean (gboolean value)
|
|
{
|
|
GstAmfNode *node = node_new (GST_AMF_TYPE_BOOLEAN);
|
|
node->value.v_int = !!value;
|
|
return node;
|
|
}
|
|
|
|
GstAmfNode *
|
|
gst_amf_node_new_number (gdouble value)
|
|
{
|
|
GstAmfNode *node = node_new (GST_AMF_TYPE_NUMBER);
|
|
node->value.v_double = value;
|
|
return node;
|
|
}
|
|
|
|
GstAmfNode *
|
|
gst_amf_node_new_string (const gchar * value, gssize size)
|
|
{
|
|
GstAmfNode *node = node_new (GST_AMF_TYPE_STRING);
|
|
gst_amf_node_set_string (node, value, size);
|
|
return node;
|
|
}
|
|
|
|
GstAmfNode *
|
|
gst_amf_node_new_take_string (gchar * value, gssize size)
|
|
{
|
|
GstAmfNode *node = node_new (GST_AMF_TYPE_STRING);
|
|
gst_amf_node_take_string (node, value, size);
|
|
return node;
|
|
}
|
|
|
|
GstAmfNode *
|
|
gst_amf_node_new_object (void)
|
|
{
|
|
return node_new (GST_AMF_TYPE_OBJECT);
|
|
}
|
|
|
|
GstAmfNode *
|
|
gst_amf_node_copy (const GstAmfNode * node)
|
|
{
|
|
GstAmfNode *copy;
|
|
|
|
g_return_val_if_fail (node, NULL);
|
|
|
|
copy = node_new (node->type);
|
|
|
|
switch (node->type) {
|
|
case GST_AMF_TYPE_STRING:
|
|
case GST_AMF_TYPE_LONG_STRING:
|
|
copy->value.v_bytes = g_bytes_ref (node->value.v_bytes);
|
|
break;
|
|
|
|
case GST_AMF_TYPE_OBJECT:
|
|
case GST_AMF_TYPE_ECMA_ARRAY:{
|
|
guint i, len = gst_amf_node_get_num_fields (node);
|
|
for (i = 0; i < len; i++) {
|
|
const AmfObjectField *field = get_field (node, i);
|
|
append_field (copy, g_strdup (field->name),
|
|
gst_amf_node_copy (field->value));
|
|
}
|
|
break;
|
|
}
|
|
|
|
case GST_AMF_TYPE_STRICT_ARRAY:{
|
|
guint i, len = gst_amf_node_get_num_elements (node);
|
|
for (i = 0; i < len; i++) {
|
|
const GstAmfNode *elem = get_element (node, i);
|
|
append_element (copy, gst_amf_node_copy (elem));
|
|
}
|
|
break;
|
|
}
|
|
|
|
default:
|
|
copy->value = node->value;
|
|
break;
|
|
}
|
|
|
|
return copy;
|
|
}
|
|
|
|
void
|
|
gst_amf_node_free (gpointer ptr)
|
|
{
|
|
GstAmfNode *node = ptr;
|
|
|
|
switch (node->type) {
|
|
case GST_AMF_TYPE_STRING:
|
|
case GST_AMF_TYPE_LONG_STRING:
|
|
g_bytes_unref (node->value.v_bytes);
|
|
break;
|
|
|
|
case GST_AMF_TYPE_OBJECT:
|
|
case GST_AMF_TYPE_ECMA_ARRAY:
|
|
g_array_unref (node->value.v_fields);
|
|
break;
|
|
|
|
case GST_AMF_TYPE_STRICT_ARRAY:
|
|
g_ptr_array_unref (node->value.v_elements);
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
g_free (node);
|
|
}
|
|
|
|
GstAmfType
|
|
gst_amf_node_get_type (const GstAmfNode * node)
|
|
{
|
|
g_return_val_if_fail (node, GST_AMF_TYPE_INVALID);
|
|
return node->type;
|
|
}
|
|
|
|
gboolean
|
|
gst_amf_node_get_boolean (const GstAmfNode * node)
|
|
{
|
|
g_return_val_if_fail (gst_amf_node_get_type (node) == GST_AMF_TYPE_BOOLEAN,
|
|
FALSE);
|
|
return node->value.v_int;
|
|
}
|
|
|
|
gdouble
|
|
gst_amf_node_get_number (const GstAmfNode * node)
|
|
{
|
|
g_return_val_if_fail (gst_amf_node_get_type (node) == GST_AMF_TYPE_NUMBER,
|
|
FALSE);
|
|
return node->value.v_double;
|
|
}
|
|
|
|
gchar *
|
|
gst_amf_node_get_string (const GstAmfNode * node, gsize * out_size)
|
|
{
|
|
gsize size;
|
|
const gchar *data = gst_amf_node_peek_string (node, &size);
|
|
|
|
if (out_size) {
|
|
*out_size = size;
|
|
return g_memdup2 (data, size);
|
|
} else {
|
|
return g_strndup (data, size);
|
|
}
|
|
}
|
|
|
|
const gchar *
|
|
gst_amf_node_peek_string (const GstAmfNode * node, gsize * size)
|
|
{
|
|
GstAmfType type = gst_amf_node_get_type (node);
|
|
g_return_val_if_fail (type == GST_AMF_TYPE_STRING ||
|
|
type == GST_AMF_TYPE_LONG_STRING, FALSE);
|
|
return g_bytes_get_data (node->value.v_bytes, size);
|
|
}
|
|
|
|
const GstAmfNode *
|
|
gst_amf_node_get_field (const GstAmfNode * node, const gchar * name)
|
|
{
|
|
guint i, len = gst_amf_node_get_num_fields (node);
|
|
|
|
g_return_val_if_fail (name, NULL);
|
|
|
|
for (i = 0; i < len; i++) {
|
|
const AmfObjectField *field = get_field (node, i);
|
|
if (strcmp (field->name, name) == 0) {
|
|
return field->value;
|
|
}
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
const GstAmfNode *
|
|
gst_amf_node_get_field_by_index (const GstAmfNode * node, guint index)
|
|
{
|
|
guint len = gst_amf_node_get_num_fields (node);
|
|
g_return_val_if_fail (index < len, NULL);
|
|
return get_field (node, index)->value;
|
|
}
|
|
|
|
guint
|
|
gst_amf_node_get_num_fields (const GstAmfNode * node)
|
|
{
|
|
GstAmfType type = gst_amf_node_get_type (node);
|
|
g_return_val_if_fail (type == GST_AMF_TYPE_OBJECT ||
|
|
type == GST_AMF_TYPE_ECMA_ARRAY, 0);
|
|
return node->value.v_fields->len;
|
|
}
|
|
|
|
const GstAmfNode *
|
|
gst_amf_node_get_element (const GstAmfNode * node, guint index)
|
|
{
|
|
guint len = gst_amf_node_get_num_elements (node);
|
|
g_return_val_if_fail (index < len, NULL);
|
|
return get_element (node, index);
|
|
}
|
|
|
|
guint
|
|
gst_amf_node_get_num_elements (const GstAmfNode * node)
|
|
{
|
|
GstAmfType type = gst_amf_node_get_type (node);
|
|
g_return_val_if_fail (type == GST_AMF_TYPE_STRICT_ARRAY, 0);
|
|
return node->value.v_elements->len;
|
|
}
|
|
|
|
void
|
|
gst_amf_node_set_boolean (GstAmfNode * node, gboolean value)
|
|
{
|
|
g_return_if_fail (node->type == GST_AMF_TYPE_BOOLEAN);
|
|
node->value.v_int = !!value;
|
|
}
|
|
|
|
void
|
|
gst_amf_node_set_number (GstAmfNode * node, gdouble value)
|
|
{
|
|
g_return_if_fail (node->type == GST_AMF_TYPE_NUMBER);
|
|
node->value.v_double = value;
|
|
}
|
|
|
|
void
|
|
gst_amf_node_take_string (GstAmfNode * node, gchar * value, gssize size)
|
|
{
|
|
g_return_if_fail (node->type == GST_AMF_TYPE_STRING ||
|
|
node->type == GST_AMF_TYPE_LONG_STRING);
|
|
|
|
g_return_if_fail (value);
|
|
|
|
if (size < 0) {
|
|
size = strlen (value);
|
|
}
|
|
|
|
if (size > G_MAXUINT32) {
|
|
GST_WARNING ("Long string too long (%" G_GSSIZE_FORMAT "), truncating",
|
|
size);
|
|
size = G_MAXUINT32;
|
|
value[size] = 0;
|
|
}
|
|
|
|
if (size > G_MAXUINT16) {
|
|
node->type = GST_AMF_TYPE_LONG_STRING;
|
|
}
|
|
|
|
g_bytes_unref (node->value.v_bytes);
|
|
node->value.v_bytes = g_bytes_new_take (value, size);
|
|
}
|
|
|
|
void
|
|
gst_amf_node_set_string (GstAmfNode * node, const gchar * value, gssize size)
|
|
{
|
|
gchar *copy;
|
|
|
|
g_return_if_fail (value);
|
|
|
|
if (size < 0) {
|
|
size = strlen (value);
|
|
copy = g_memdup2 (value, size + 1);
|
|
} else {
|
|
copy = g_memdup2 (value, size);
|
|
}
|
|
|
|
gst_amf_node_take_string (node, copy, size);
|
|
}
|
|
|
|
void
|
|
gst_amf_node_append_field (GstAmfNode * node, const gchar * name,
|
|
const GstAmfNode * value)
|
|
{
|
|
gst_amf_node_append_take_field (node, name, gst_amf_node_copy (value));
|
|
}
|
|
|
|
void
|
|
gst_amf_node_append_take_field (GstAmfNode * node, const gchar * name,
|
|
GstAmfNode * value)
|
|
{
|
|
g_return_if_fail (node->type == GST_AMF_TYPE_OBJECT ||
|
|
node->type == GST_AMF_TYPE_ECMA_ARRAY);
|
|
g_return_if_fail (name);
|
|
append_field (node, g_strdup (name), value);
|
|
}
|
|
|
|
void
|
|
gst_amf_node_append_field_number (GstAmfNode * node, const gchar * name,
|
|
gdouble value)
|
|
{
|
|
gst_amf_node_append_take_field (node, name, gst_amf_node_new_number (value));
|
|
}
|
|
|
|
void
|
|
gst_amf_node_append_field_boolean (GstAmfNode * node, const gchar * name,
|
|
gboolean value)
|
|
{
|
|
gst_amf_node_append_take_field (node, name, gst_amf_node_new_boolean (value));
|
|
}
|
|
|
|
void
|
|
gst_amf_node_append_field_string (GstAmfNode * node, const gchar * name,
|
|
const gchar * value, gssize size)
|
|
{
|
|
gst_amf_node_append_take_field (node, name,
|
|
gst_amf_node_new_string (value, size));
|
|
}
|
|
|
|
void
|
|
gst_amf_node_append_field_take_string (GstAmfNode * node, const gchar * name,
|
|
gchar * value, gssize size)
|
|
{
|
|
gst_amf_node_append_take_field (node, name,
|
|
gst_amf_node_new_take_string (value, size));
|
|
}
|
|
|
|
/* Dumper *******************************************************************/
|
|
|
|
static inline void
|
|
dump_indent (GString * string, gint indent, guint depth)
|
|
{
|
|
if (indent < 0) {
|
|
g_string_append_c (string, ' ');
|
|
} else {
|
|
guint i;
|
|
g_string_append_c (string, '\n');
|
|
for (i = 0; i < indent + depth * 2; i++) {
|
|
g_string_append_c (string, ' ');
|
|
}
|
|
}
|
|
}
|
|
|
|
static inline void
|
|
dump_bytes (GString * string, GBytes * value)
|
|
{
|
|
gsize size;
|
|
const gchar *data = g_bytes_get_data (value, &size);
|
|
gst_rtmp_string_print_escaped (string, data, size);
|
|
}
|
|
|
|
static void
|
|
dump_node (GString * string, const GstAmfNode * node, gint indent,
|
|
guint recursion_depth)
|
|
{
|
|
const gchar *object_delim = "{}";
|
|
|
|
switch (gst_amf_node_get_type (node)) {
|
|
case GST_AMF_TYPE_NUMBER:
|
|
g_string_append_printf (string, "%g", node->value.v_double);
|
|
break;
|
|
|
|
case GST_AMF_TYPE_BOOLEAN:
|
|
g_string_append (string, node->value.v_int ? "True" : "False");
|
|
break;
|
|
|
|
case GST_AMF_TYPE_LONG_STRING:
|
|
g_string_append_c (string, 'L');
|
|
/* no break */
|
|
case GST_AMF_TYPE_STRING:
|
|
dump_bytes (string, node->value.v_bytes);
|
|
break;
|
|
|
|
case GST_AMF_TYPE_ECMA_ARRAY:
|
|
object_delim = "[]";
|
|
/* no break */
|
|
case GST_AMF_TYPE_OBJECT:{
|
|
guint i, len = gst_amf_node_get_num_fields (node);
|
|
g_string_append_c (string, object_delim[0]);
|
|
if (len) {
|
|
for (i = 0; i < len; i++) {
|
|
const AmfObjectField *field = get_field (node, i);
|
|
dump_indent (string, indent, recursion_depth + 1);
|
|
gst_rtmp_string_print_escaped (string, field->name, -1);
|
|
g_string_append_c (string, ':');
|
|
g_string_append_c (string, ' ');
|
|
dump_node (string, field->value, indent, recursion_depth + 1);
|
|
if (i < len - 1) {
|
|
g_string_append_c (string, ',');
|
|
}
|
|
}
|
|
dump_indent (string, indent, recursion_depth);
|
|
}
|
|
g_string_append_c (string, object_delim[1]);
|
|
break;
|
|
}
|
|
|
|
case GST_AMF_TYPE_STRICT_ARRAY:{
|
|
guint i, len = gst_amf_node_get_num_elements (node);
|
|
g_string_append_c (string, '(');
|
|
if (len) {
|
|
for (i = 0; i < len; i++) {
|
|
const GstAmfNode *value = get_element (node, i);
|
|
dump_indent (string, indent, recursion_depth + 1);
|
|
dump_node (string, value, indent, recursion_depth + 1);
|
|
if (i < len - 1) {
|
|
g_string_append_c (string, ',');
|
|
}
|
|
}
|
|
dump_indent (string, indent, recursion_depth);
|
|
}
|
|
g_string_append_c (string, ')');
|
|
break;
|
|
}
|
|
|
|
default:
|
|
g_string_append (string, gst_amf_type_get_nick (node->type));
|
|
break;
|
|
}
|
|
}
|
|
|
|
void
|
|
gst_amf_node_dump (const GstAmfNode * node, gint indent, GString * string)
|
|
{
|
|
dump_node (string, node, indent, 0);
|
|
}
|
|
|
|
static void
|
|
dump_argument (const GstAmfNode * node, guint n)
|
|
{
|
|
if (G_UNLIKELY (GST_LEVEL_LOG <= _gst_debug_min) &&
|
|
GST_LEVEL_LOG <= gst_debug_category_get_threshold (GST_CAT_DEFAULT)) {
|
|
GString *string = g_string_new (NULL);
|
|
gst_amf_node_dump (node, -1, string);
|
|
GST_LOG ("Argument #%u: %s", n, string->str);
|
|
g_string_free (string, TRUE);
|
|
}
|
|
}
|
|
|
|
/* Parser *******************************************************************/
|
|
|
|
typedef struct
|
|
{
|
|
const guint8 *data;
|
|
gsize size, offset;
|
|
guint8 recursion_depth;
|
|
} AmfParser;
|
|
|
|
static GstAmfNode *parse_value (AmfParser * parser);
|
|
|
|
static inline guint8
|
|
parse_u8 (AmfParser * parser)
|
|
{
|
|
guint8 value;
|
|
value = parser->data[parser->offset];
|
|
parser->offset += sizeof value;
|
|
return value;
|
|
}
|
|
|
|
static inline guint16
|
|
parse_u16 (AmfParser * parser)
|
|
{
|
|
guint16 value;
|
|
value = GST_READ_UINT16_BE (parser->data + parser->offset);
|
|
parser->offset += sizeof value;
|
|
return value;
|
|
}
|
|
|
|
static inline guint32
|
|
parse_u32 (AmfParser * parser)
|
|
{
|
|
guint32 value;
|
|
value = GST_READ_UINT32_BE (parser->data + parser->offset);
|
|
parser->offset += sizeof value;
|
|
return value;
|
|
}
|
|
|
|
static gdouble
|
|
parse_number (AmfParser * parser)
|
|
{
|
|
gdouble value;
|
|
|
|
if (sizeof value > parser->size - parser->offset) {
|
|
GST_ERROR ("number too long");
|
|
return 0.0;
|
|
}
|
|
|
|
value = GST_READ_DOUBLE_BE (parser->data + parser->offset);
|
|
parser->offset += sizeof value;
|
|
return value;
|
|
}
|
|
|
|
static gboolean
|
|
parse_boolean (AmfParser * parser)
|
|
{
|
|
guint8 value;
|
|
|
|
if (sizeof value > parser->size - parser->offset) {
|
|
GST_ERROR ("boolean too long");
|
|
return FALSE;
|
|
}
|
|
|
|
value = parse_u8 (parser);
|
|
return !!value;
|
|
}
|
|
|
|
static inline GBytes *
|
|
read_string (AmfParser * parser, gsize size)
|
|
{
|
|
gchar *string;
|
|
|
|
if (size == 0) {
|
|
return g_bytes_ref (empty_bytes);
|
|
}
|
|
|
|
if (size > parser->size - parser->offset) {
|
|
GST_ERROR ("string too long (%" G_GSIZE_FORMAT ")", size);
|
|
return NULL;
|
|
}
|
|
|
|
/* Null-terminate all incoming strings for internal safety */
|
|
if (parser->data[parser->offset + size - 1] == 0) {
|
|
string = g_malloc (size);
|
|
} else {
|
|
string = g_malloc (size + 1);
|
|
string[size] = 0;
|
|
}
|
|
|
|
memcpy (string, parser->data + parser->offset, size);
|
|
|
|
parser->offset += size;
|
|
return g_bytes_new_take (string, size);
|
|
}
|
|
|
|
static GBytes *
|
|
parse_string (AmfParser * parser)
|
|
{
|
|
guint16 size;
|
|
|
|
if (sizeof size > parser->size - parser->offset) {
|
|
GST_ERROR ("string size too long");
|
|
return NULL;
|
|
}
|
|
|
|
size = parse_u16 (parser);
|
|
return read_string (parser, size);
|
|
}
|
|
|
|
static GBytes *
|
|
parse_long_string (AmfParser * parser)
|
|
{
|
|
guint32 size;
|
|
|
|
if (sizeof size > parser->size - parser->offset) {
|
|
GST_ERROR ("long string size too long");
|
|
return NULL;
|
|
}
|
|
|
|
size = parse_u32 (parser);
|
|
return read_string (parser, size);
|
|
}
|
|
|
|
static guint32
|
|
parse_object (AmfParser * parser, GstAmfNode * node)
|
|
{
|
|
guint32 n_fields = 0;
|
|
|
|
while (TRUE) {
|
|
GBytes *name;
|
|
gsize size;
|
|
GstAmfNode *value;
|
|
|
|
name = parse_string (parser);
|
|
if (!name) {
|
|
GST_ERROR ("object too long");
|
|
break;
|
|
}
|
|
|
|
value = parse_value (parser);
|
|
if (!value) {
|
|
GST_ERROR ("object too long");
|
|
g_bytes_unref (name);
|
|
break;
|
|
}
|
|
|
|
if (gst_amf_node_get_type (value) == GST_AMF_TYPE_OBJECT_END) {
|
|
g_bytes_unref (name);
|
|
gst_amf_node_free (value);
|
|
break;
|
|
}
|
|
|
|
if (g_bytes_get_size (name) == 0) {
|
|
GST_ERROR ("empty object field name");
|
|
g_bytes_unref (name);
|
|
gst_amf_node_free (value);
|
|
break;
|
|
}
|
|
|
|
append_field (node, g_bytes_unref_to_data (name, &size), value);
|
|
n_fields++;
|
|
};
|
|
|
|
return n_fields;
|
|
}
|
|
|
|
static void
|
|
parse_ecma_array (AmfParser * parser, GstAmfNode * node)
|
|
{
|
|
guint32 n_elements, n_read;
|
|
|
|
if (sizeof n_elements > parser->size - parser->offset) {
|
|
GST_ERROR ("array size too long");
|
|
return;
|
|
}
|
|
|
|
n_elements = parse_u32 (parser);
|
|
|
|
/* FIXME This is weird. The one time I've seen this, the encoded value
|
|
* was 0, but the number of elements was 1. */
|
|
if (n_elements == 0) {
|
|
GST_DEBUG ("Interpreting ECMA array length 0 as 1");
|
|
n_elements = 1;
|
|
}
|
|
|
|
n_read = parse_object (parser, node);
|
|
|
|
if (n_read != n_elements) {
|
|
GST_WARNING ("Expected array with %" G_GUINT32_FORMAT " elements,"
|
|
" but read %" G_GUINT32_FORMAT, n_elements, n_read);
|
|
}
|
|
}
|
|
|
|
static void
|
|
parse_strict_array (AmfParser * parser, GstAmfNode * node)
|
|
{
|
|
GstAmfNode *value = NULL;
|
|
guint32 n_elements, i;
|
|
|
|
if (sizeof n_elements > parser->size - parser->offset) {
|
|
GST_ERROR ("array size too long");
|
|
return;
|
|
}
|
|
|
|
n_elements = parse_u32 (parser);
|
|
|
|
for (i = 0; i < n_elements; i++) {
|
|
value = parse_value (parser);
|
|
if (!value) {
|
|
GST_ERROR ("array too long");
|
|
break;
|
|
}
|
|
|
|
append_element (node, value);
|
|
}
|
|
}
|
|
|
|
static GstAmfNode *
|
|
parse_value (AmfParser * parser)
|
|
{
|
|
GstAmfNode *node = NULL;
|
|
GstAmfType type;
|
|
|
|
if (1 > parser->size - parser->offset) {
|
|
GST_ERROR ("value too long");
|
|
return NULL;
|
|
}
|
|
|
|
type = parse_u8 (parser);
|
|
node = node_new (type);
|
|
GST_TRACE ("parsing AMF type %d (%s)", type, gst_amf_type_get_nick (type));
|
|
|
|
parser->recursion_depth++;
|
|
if (parser->recursion_depth > MAX_RECURSION_DEPTH) {
|
|
GST_ERROR ("maximum recursion depth %d reached", parser->recursion_depth);
|
|
return node;
|
|
}
|
|
|
|
switch (type) {
|
|
case GST_AMF_TYPE_NUMBER:
|
|
node->value.v_double = parse_number (parser);
|
|
break;
|
|
case GST_AMF_TYPE_BOOLEAN:
|
|
node->value.v_int = parse_boolean (parser);
|
|
break;
|
|
case GST_AMF_TYPE_STRING:
|
|
node->value.v_bytes = parse_string (parser);
|
|
break;
|
|
case GST_AMF_TYPE_LONG_STRING:
|
|
node->value.v_bytes = parse_long_string (parser);
|
|
break;
|
|
case GST_AMF_TYPE_OBJECT:
|
|
parse_object (parser, node);
|
|
break;
|
|
case GST_AMF_TYPE_ECMA_ARRAY:
|
|
parse_ecma_array (parser, node);
|
|
break;
|
|
case GST_AMF_TYPE_STRICT_ARRAY:
|
|
parse_strict_array (parser, node);
|
|
break;
|
|
case GST_AMF_TYPE_NULL:
|
|
case GST_AMF_TYPE_UNDEFINED:
|
|
case GST_AMF_TYPE_OBJECT_END:
|
|
case GST_AMF_TYPE_UNSUPPORTED:
|
|
break;
|
|
default:
|
|
GST_ERROR ("unimplemented AMF type %d (%s)", type,
|
|
gst_amf_type_get_nick (type));
|
|
break;
|
|
}
|
|
|
|
parser->recursion_depth--;
|
|
return node;
|
|
}
|
|
|
|
GstAmfNode *
|
|
gst_amf_node_parse (const guint8 * data, gsize size, guint8 ** endptr)
|
|
{
|
|
AmfParser parser = {
|
|
.data = data,
|
|
.size = size,
|
|
};
|
|
GstAmfNode *node;
|
|
|
|
g_return_val_if_fail (data, NULL);
|
|
g_return_val_if_fail (size, NULL);
|
|
|
|
init_static ();
|
|
|
|
GST_TRACE ("Starting parse with %" G_GSIZE_FORMAT " bytes", parser.size);
|
|
|
|
node = parse_value (&parser);
|
|
if (gst_amf_node_get_type (node) == GST_AMF_TYPE_INVALID) {
|
|
GST_ERROR ("invalid value");
|
|
goto out;
|
|
}
|
|
|
|
if (G_UNLIKELY (GST_LEVEL_LOG <= _gst_debug_min) &&
|
|
GST_LEVEL_LOG <= gst_debug_category_get_threshold (GST_CAT_DEFAULT)) {
|
|
GString *string = g_string_new (NULL);
|
|
gst_amf_node_dump (node, -1, string);
|
|
GST_LOG ("Parsed value: %s", string->str);
|
|
g_string_free (string, TRUE);
|
|
}
|
|
|
|
GST_TRACE ("Done parsing; consumed %" G_GSIZE_FORMAT " bytes and left %"
|
|
G_GSIZE_FORMAT " bytes", parser.offset, parser.size - parser.offset);
|
|
|
|
out:
|
|
if (endptr) {
|
|
*endptr = (guint8 *) parser.data + parser.offset;
|
|
}
|
|
|
|
return node;
|
|
}
|
|
|
|
GPtrArray *
|
|
gst_amf_parse_command (const guint8 * data, gsize size,
|
|
gdouble * transaction_id, gchar ** command_name)
|
|
{
|
|
AmfParser parser = {
|
|
.data = data,
|
|
.size = size,
|
|
};
|
|
GstAmfNode *node1 = NULL, *node2 = NULL;
|
|
GPtrArray *args = NULL;
|
|
|
|
g_return_val_if_fail (data, NULL);
|
|
g_return_val_if_fail (size, NULL);
|
|
|
|
init_static ();
|
|
|
|
GST_TRACE ("Starting parse with %" G_GSIZE_FORMAT " bytes", parser.size);
|
|
|
|
node1 = parse_value (&parser);
|
|
if (gst_amf_node_get_type (node1) != GST_AMF_TYPE_STRING) {
|
|
GST_ERROR ("no command name");
|
|
goto out;
|
|
}
|
|
|
|
node2 = parse_value (&parser);
|
|
if (gst_amf_node_get_type (node2) != GST_AMF_TYPE_NUMBER) {
|
|
GST_ERROR ("no transaction ID");
|
|
goto out;
|
|
}
|
|
|
|
GST_LOG ("Parsing command '%s', transid %.0f",
|
|
gst_amf_node_peek_string (node1, NULL), gst_amf_node_get_number (node2));
|
|
|
|
args = g_ptr_array_new_with_free_func (gst_amf_node_free);
|
|
|
|
while (parser.offset < parser.size) {
|
|
GstAmfNode *node = parse_value (&parser);
|
|
if (!node) {
|
|
break;
|
|
}
|
|
|
|
dump_argument (node, args->len);
|
|
g_ptr_array_add (args, node);
|
|
}
|
|
|
|
GST_TRACE ("Done parsing; consumed %" G_GSIZE_FORMAT " bytes and left %"
|
|
G_GSIZE_FORMAT " bytes", parser.offset, parser.size - parser.offset);
|
|
|
|
if (args->len == 0) {
|
|
GST_ERROR ("no command arguments");
|
|
g_clear_pointer (&args, g_ptr_array_unref);
|
|
goto out;
|
|
}
|
|
|
|
if (command_name) {
|
|
*command_name = gst_amf_node_get_string (node1, NULL);
|
|
}
|
|
|
|
if (transaction_id) {
|
|
*transaction_id = gst_amf_node_get_number (node2);
|
|
}
|
|
|
|
out:
|
|
g_clear_pointer (&node1, gst_amf_node_free);
|
|
g_clear_pointer (&node2, gst_amf_node_free);
|
|
return args;
|
|
}
|
|
|
|
/* Serializer ***************************************************************/
|
|
|
|
static void serialize_value (GByteArray * array, const GstAmfNode * node);
|
|
|
|
static inline void
|
|
serialize_u8 (GByteArray * array, guint8 value)
|
|
{
|
|
g_byte_array_append (array, (guint8 *) & value, sizeof value);
|
|
}
|
|
|
|
static inline void
|
|
serialize_u16 (GByteArray * array, guint16 value)
|
|
{
|
|
value = GUINT16_TO_BE (value);
|
|
g_byte_array_append (array, (guint8 *) & value, sizeof value);
|
|
}
|
|
|
|
static inline void
|
|
serialize_u32 (GByteArray * array, guint32 value)
|
|
{
|
|
value = GUINT32_TO_BE (value);
|
|
g_byte_array_append (array, (guint8 *) & value, sizeof value);
|
|
}
|
|
|
|
static inline void
|
|
serialize_number (GByteArray * array, gdouble value)
|
|
{
|
|
value = GDOUBLE_TO_BE (value);
|
|
g_byte_array_append (array, (guint8 *) & value, sizeof value);
|
|
}
|
|
|
|
static inline void
|
|
serialize_boolean (GByteArray * array, gboolean value)
|
|
{
|
|
serialize_u8 (array, value);
|
|
}
|
|
|
|
static void
|
|
serialize_string (GByteArray * array, const gchar * string, gssize size)
|
|
{
|
|
if (size < 0) {
|
|
size = strlen (string);
|
|
}
|
|
|
|
if (size > G_MAXUINT16) {
|
|
GST_WARNING ("String too long: %" G_GSSIZE_FORMAT, size);
|
|
size = G_MAXUINT16;
|
|
}
|
|
|
|
serialize_u16 (array, size);
|
|
g_byte_array_append (array, (guint8 *) string, size);
|
|
}
|
|
|
|
static void
|
|
serialize_long_string (GByteArray * array, const gchar * string, gssize size)
|
|
{
|
|
if (size < 0) {
|
|
size = strlen (string);
|
|
}
|
|
|
|
if (size > G_MAXUINT32) {
|
|
GST_WARNING ("Long string too long: %" G_GSSIZE_FORMAT, size);
|
|
size = G_MAXUINT32;
|
|
}
|
|
|
|
serialize_u32 (array, size);
|
|
g_byte_array_append (array, (guint8 *) string, size);
|
|
}
|
|
|
|
static inline void
|
|
serialize_bytes (GByteArray * array, GBytes * bytes, gboolean long_string)
|
|
{
|
|
gsize size;
|
|
const gchar *data = g_bytes_get_data (bytes, &size);
|
|
|
|
if (long_string) {
|
|
serialize_long_string (array, data, size);
|
|
} else {
|
|
serialize_string (array, data, size);
|
|
}
|
|
}
|
|
|
|
static void
|
|
serialize_object (GByteArray * array, const GstAmfNode * node)
|
|
{
|
|
guint i;
|
|
|
|
for (i = 0; i < gst_amf_node_get_num_fields (node); i++) {
|
|
const AmfObjectField *field = get_field (node, i);
|
|
serialize_string (array, field->name, -1);
|
|
serialize_value (array, field->value);
|
|
}
|
|
serialize_u16 (array, 0);
|
|
serialize_u8 (array, GST_AMF_TYPE_OBJECT_END);
|
|
}
|
|
|
|
static void
|
|
serialize_ecma_array (GByteArray * array, const GstAmfNode * node)
|
|
{
|
|
/* FIXME: Shouldn't this be the field count? */
|
|
serialize_u32 (array, 0);
|
|
serialize_object (array, node);
|
|
}
|
|
|
|
static void
|
|
serialize_value (GByteArray * array, const GstAmfNode * node)
|
|
{
|
|
serialize_u8 (array, node->type);
|
|
switch (node->type) {
|
|
case GST_AMF_TYPE_NUMBER:
|
|
serialize_number (array, node->value.v_double);
|
|
break;
|
|
case GST_AMF_TYPE_BOOLEAN:
|
|
serialize_boolean (array, node->value.v_int);
|
|
break;
|
|
case GST_AMF_TYPE_STRING:
|
|
serialize_bytes (array, node->value.v_bytes, FALSE);
|
|
break;
|
|
case GST_AMF_TYPE_LONG_STRING:
|
|
serialize_bytes (array, node->value.v_bytes, TRUE);
|
|
break;
|
|
case GST_AMF_TYPE_OBJECT:
|
|
serialize_object (array, node);
|
|
break;
|
|
case GST_AMF_TYPE_ECMA_ARRAY:
|
|
serialize_ecma_array (array, node);
|
|
break;
|
|
case GST_AMF_TYPE_NULL:
|
|
case GST_AMF_TYPE_UNDEFINED:
|
|
case GST_AMF_TYPE_OBJECT_END:
|
|
case GST_AMF_TYPE_UNSUPPORTED:
|
|
break;
|
|
default:
|
|
GST_ERROR ("unimplemented AMF type %d (%s)", node->type,
|
|
gst_amf_type_get_nick (node->type));
|
|
break;
|
|
}
|
|
}
|
|
|
|
GBytes *
|
|
gst_amf_node_serialize (const GstAmfNode * node)
|
|
{
|
|
GByteArray *array = g_byte_array_new ();
|
|
|
|
g_return_val_if_fail (node, NULL);
|
|
|
|
init_static ();
|
|
|
|
if (G_UNLIKELY (GST_LEVEL_LOG <= _gst_debug_min) &&
|
|
GST_LEVEL_LOG <= gst_debug_category_get_threshold (GST_CAT_DEFAULT)) {
|
|
GString *string = g_string_new (NULL);
|
|
gst_amf_node_dump (node, -1, string);
|
|
GST_LOG ("Serializing value: %s", string->str);
|
|
g_string_free (string, TRUE);
|
|
}
|
|
|
|
serialize_value (array, node);
|
|
|
|
GST_TRACE ("Done serializing; produced %u bytes", array->len);
|
|
|
|
return g_byte_array_free_to_bytes (array);
|
|
}
|
|
|
|
GBytes *
|
|
gst_amf_serialize_command (gdouble transaction_id, const gchar * command_name,
|
|
const GstAmfNode * argument, ...)
|
|
{
|
|
va_list ap;
|
|
GBytes *ret;
|
|
|
|
va_start (ap, argument);
|
|
ret = gst_amf_serialize_command_valist (transaction_id, command_name,
|
|
argument, ap);
|
|
va_end (ap);
|
|
|
|
return ret;
|
|
}
|
|
|
|
GBytes *
|
|
gst_amf_serialize_command_valist (gdouble transaction_id,
|
|
const gchar * command_name, const GstAmfNode * argument, va_list var_args)
|
|
{
|
|
GByteArray *array = g_byte_array_new ();
|
|
guint i = 0;
|
|
|
|
g_return_val_if_fail (command_name, NULL);
|
|
g_return_val_if_fail (argument, NULL);
|
|
|
|
init_static ();
|
|
|
|
GST_LOG ("Serializing command '%s', transid %.0f", command_name,
|
|
transaction_id);
|
|
|
|
serialize_u8 (array, GST_AMF_TYPE_STRING);
|
|
serialize_string (array, command_name, -1);
|
|
serialize_u8 (array, GST_AMF_TYPE_NUMBER);
|
|
serialize_number (array, transaction_id);
|
|
|
|
while (argument) {
|
|
serialize_value (array, argument);
|
|
dump_argument (argument, i++);
|
|
|
|
argument = va_arg (var_args, const GstAmfNode *);
|
|
}
|
|
|
|
GST_TRACE ("Done serializing; consumed %u args and produced %u bytes", i,
|
|
array->len);
|
|
|
|
return g_byte_array_free_to_bytes (array);
|
|
}
|