Merge "res_pjsip_outbound_registration.c: Be tolerant of short registration timeouts."
authorMatt Jordan <mjordan@digium.com>
Sat, 21 Nov 2015 16:57:16 +0000 (10:57 -0600)
committerGerrit Code Review <gerrit2@gerrit.digium.api>
Sat, 21 Nov 2015 16:57:16 +0000 (10:57 -0600)
CHANGES
apps/app_bridgeaddchan.c [new file with mode: 0644]
apps/app_statsd.c
res/res_format_attr_h264.c
res/res_pjsip_outbound_registration.c

diff --git a/CHANGES b/CHANGES
index d6fea74..6e96515 100644 (file)
--- a/CHANGES
+++ b/CHANGES
 Applications
 ------------------
 
+BridgeAdd
+------------------
+ * A new application in Asterisk, this will join the calling channel
+   to an existing bridge containing the named channel prefix.
+
 ConfBridge
 ------------------
  * Added the ability to pass options to MixMonitor when recording is used with
diff --git a/apps/app_bridgeaddchan.c b/apps/app_bridgeaddchan.c
new file mode 100644 (file)
index 0000000..fda6ca5
--- /dev/null
@@ -0,0 +1,124 @@
+/*
+ * Asterisk -- An open source telephony toolkit.
+ *
+ * Copyright (C) 2015, Digium, Inc.
+ *
+ * Alec Davis <sivad.a@paradise.net.nz>
+ *
+ * See http://www.asterisk.org for more information about
+ * the Asterisk project. Please do not directly contact
+ * any of the maintainers of this project for assistance;
+ * the project provides a web site, mailing lists and IRC
+ * channels for your use.
+ *
+ * This program is free software, distributed under the terms of
+ * the GNU General Public License Version 2. See the LICENSE file
+ * at the top of the source tree.
+ */
+
+/*! \file
+ *
+ * \brief Application to place the channel into an existing Bridge
+ *
+ * \author Alec Davis
+ *
+ * \ingroup applications
+ */
+
+/*** MODULEINFO
+       <support_level>core</support_level>
+ ***/
+
+#include "asterisk.h"
+
+ASTERISK_REGISTER_FILE()
+
+#include "asterisk/file.h"
+#include "asterisk/module.h"
+#include "asterisk/channel.h"
+#include "asterisk/bridge.h"
+#include "asterisk/features.h"
+
+/*** DOCUMENTATION
+       <application name="BridgeAdd" language="en_US">
+               <synopsis>
+                       Join a bridge that contains the specified channel.
+               </synopsis>
+               <syntax>
+                       <parameter name="name">
+                               <para>Name of the channel in an existing bridge
+                               </para>
+                       </parameter>
+               </syntax>
+               <description>
+                       <para>This application places the incoming channel into
+                       the bridge containing the specified channel. The specified
+                       channel only needs to be the prefix of a full channel name
+                       IE. 'SIP/cisco0001'.
+                       </para>
+               </description>
+       </application>
+ ***/
+
+static const char app[] = "BridgeAdd";
+
+static int bridgeadd_exec(struct ast_channel *chan, const char *data)
+{
+       struct ast_channel *c_ref;
+       struct ast_bridge_features chan_features;
+       struct ast_bridge *bridge;
+       char *c_name;
+
+       /* Answer the channel if needed */
+       if (ast_channel_state(chan) != AST_STATE_UP) {
+               ast_answer(chan);
+       }
+
+       if (!(c_ref = ast_channel_get_by_name_prefix(data, strlen(data)))) {
+               ast_log(LOG_WARNING, "Channel %s not found\n", data);
+               return -1;
+       }
+
+       c_name = ast_strdupa(ast_channel_name(c_ref));
+
+       ast_channel_lock(c_ref);
+       bridge = ast_channel_get_bridge(c_ref);
+       ast_channel_unlock(c_ref);
+
+       ast_channel_unref(c_ref);
+
+       if (!bridge) {
+               ast_log(LOG_WARNING, "Channel %s is not in a bridge\n", c_name);
+               return -1;
+       }
+
+       ast_verb(3, "%s is joining %s in bridge %s\n", ast_channel_name(chan),
+               c_name, bridge->uniqueid);
+
+       if (ast_bridge_features_init(&chan_features)
+               || ast_bridge_join(bridge, chan, NULL, &chan_features, NULL, 0)) {
+
+               ast_log(LOG_WARNING, "%s failed to join %s in bridge %s\n", ast_channel_name(chan),
+                        c_name, bridge->uniqueid);
+
+               ast_bridge_features_cleanup(&chan_features);
+               ao2_cleanup(bridge);
+               return -1;
+       }
+
+       ast_bridge_features_cleanup(&chan_features);
+       ao2_cleanup(bridge);
+       return 0;
+}
+
+static int unload_module(void)
+{
+       return ast_unregister_application(app);
+}
+
+static int load_module(void)
+{
+       return ast_register_application_xml(app, bridgeadd_exec);
+}
+
+AST_MODULE_INFO_STANDARD(ASTERISK_GPL_KEY, "Bridge Add Channel Application");
index 176796f..e87aac6 100644 (file)
-/*
- * Asterisk -- An open source telephony toolkit.
- *
- * Copyright (C) 2015, Digium, Inc.
- *
- * Tyler Cambron <tcambron@digium.com>
- *
- * See http://www.asterisk.org for more information about
- * the Asterisk project. Please do not directly contact
- * any of the maintainers of this project for assistance;
- * the project provides a web site, mailing lists and IRC
- * channels for your use.
- *
- * This program is free software, distributed under the terms of
- * the GNU General Public License Version 2. See the LICENSE file
- * at the top of the source tree.
- */
-
- /*** MODULEINFO
-       <depend>res_statsd</depend>
-       <defaultenabled>no</defaultenabled>
-       <support_level>extended</support_level>
- ***/
-
-#include "asterisk.h"
-
-ASTERISK_REGISTER_FILE()
-
-#include <math.h>
-
-#include "asterisk/module.h"
-#include "asterisk/logger.h"
-#include "asterisk/app.h"
-#include "asterisk/pbx.h"
-#include "asterisk/strings.h"
-#include "asterisk/statsd.h"
-
-/*** DOCUMENTATION
-       <application name="StatsD" language="en_US">
-               <synopsis>
-                       Allow statistics to be passed to the StatsD server from the dialplan.
-               </synopsis>
-               <syntax>
-                       <parameter name="metric_type" required="true">
-                               <para>The metric type to be sent to StatsD.</para>
-                       </parameter>
-                       <parameter name="statistic_name" required="true">
-                               <para>The name of the variable to be sent to StatsD.</para>
-                       </parameter>
-                       <parameter name="value" required="true">
-                               <para>The value of the variable to be sent to StatsD.</para>
-                       </parameter>
-               </syntax>
-               <description>
-                       <para>This dialplan application sends statistics to the StatsD
-                       server specified inside of <literal>statsd.conf</literal>.</para>
-               </description>
-       </application>
- ***/
-
-static const char app[] = "StatsD";
-
-/*!
- * \brief Check to ensure the value is within the allowed range.
- *
- * \param value The value of the statistic to be sent to StatsD.
- * \param metric The metric type to be sent to StatsD.
- *
- * This function checks to see if the value given to the StatsD daialplan
- * application is within the allowed range as specified by StatsD. A counter
- * is the only metric type allowed to be initialized as a negative number.
- *
- * \retval zero on success.
- * \retval 1 on error.
- */
-static int value_in_range(const char *value, const char *metric)
-{
-       double numerical_value = strtod(value, NULL);
-
-       if (!strcmp(metric, "c")) {
-               if (numerical_value < pow(-2, 63) || numerical_value > pow(2, 63)) {
-                       ast_log(AST_LOG_WARNING, "Value %lf out of range!\n", numerical_value);
-                       return 1;
-               }
-       } else {
-               if (numerical_value < 0 || numerical_value > pow(2, 64)) {
-                       ast_log(AST_LOG_WARNING, "Value %lf out of range!\n", numerical_value);
-                       return 1;
-               }
-       }
-
-       return 0;
-}
-
-/*!
- * \brief Check to ensure the metric type is a valid metric type.
- *
- * \param metric The metric type to be sent to StatsD.
- *
- * This function checks to see if the metric type given to the StatsD dialplan
- * is a valid metric type. Metric types are determined by StatsD.
- *
- * \retval zero on success.
- * \retval 1 on error.
- */
-static int validate_metric(const char *metric)
-{
-       const char *valid_metrics[] = {"g","s","ms","c"};
-       int i;
-
-       if (ast_strlen_zero(metric)) {
-               ast_log(AST_LOG_ERROR, "Missing metric type argument.\n");
-               return 1;
-       }
-
-       for (i = 0; i < ARRAY_LEN(valid_metrics); i++) {
-               if (!strcmp(valid_metrics[i], metric)) {
-                       return 0;
-               }
-       }
-
-       ast_log(AST_LOG_ERROR, "Invalid metric type %s.\n", metric);
-
-       return 1;
-}
-
-/*!
- * \brief Check to ensure the statistic name is valid.
- *
- * \param name The variable name to be sent to StatsD.
- *
- * This function checks to see if the statistic name given to the StatsD
- * dialplan application is valid by ensuring that the name does not have any
- * invalid characters.
- *
- * \retval zero on success.
- * \retval 1 on error.
- */
-static int validate_name(const char *name)
-{
-       if (ast_strlen_zero(name) || (strstr(name, "|") != NULL)) {
-               ast_log(AST_LOG_ERROR, "Statistic name %s is missing or contains a pipe (|)"
-                       " character.\n", name);
-               return 1;
-       }
-
-       return 0;
-}
-
-/*!
- * \brief Check to ensure the value is valid.
- *
- * \param value The value of the statistic to be sent to StatsD.
- * \param metric The metric type to be sent to StatsD.
- *
- * This function checks to see if the value given to the StatsD daialplan
- * application is valid by testing if it is numeric. A plus or minus is only
- * allowed at the beginning of the value if it is a counter or a gauge.
- *
- * \retval zero on success.
- * \retval 1 on error.
- */
-static int validate_value(const char *value, const char *metric)
-{
-       const char *actual_value;
-
-       if (ast_strlen_zero(value)) {
-               ast_log(AST_LOG_ERROR, "Missing value argument.\n");
-               return 1;
-       }
-
-       if (!strcmp(metric, "g") || !strcmp(metric, "c")) {
-               if ((value[0] == '+') || (value[0] == '-')) {
-                       actual_value = &value[1];
-                       if (ast_strlen_zero(actual_value)) {
-                               ast_log(AST_LOG_ERROR, "Value argument %s only contains a sign"
-                                       " operator.\n", value);
-                               return 1;
-                       }
-               } else {
-                       actual_value = &value[0];
-               }
-       } else {
-               actual_value = &value[0];
-       }
-
-       if (!isdigit(*actual_value)) {
-               ast_log(AST_LOG_ERROR, "Value of %s is not a valid number!\n", actual_value);
-               return 1;
-       }
-
-       if (value_in_range(actual_value, metric)) {
-               return 1;
-       }
-
-       return 0;
-}
-
-static int statsd_exec(struct ast_channel *chan, const char *data)
-{
-       char *stats;
-       double numerical_value;
-
-       AST_DECLARE_APP_ARGS(args,
-                       AST_APP_ARG(metric_type);
-                       AST_APP_ARG(statistic_name);
-                       AST_APP_ARG(value);
-       );
-
-       if (!data) {
-               ast_log(AST_LOG_ERROR, "No parameters were provided. Correct format is "
-                       "StatsD(metric_type,statistic_name,value). All parameters are required.\n");
-               return 1;
-       }
-
-       stats = ast_strdupa(data);
-       AST_STANDARD_APP_ARGS(args, stats);
-
-       /* If any of the validations fail, emit a warning message. */
-       if (validate_metric(args.metric_type) || validate_name(args.statistic_name)
-               || validate_value(args.value, args.metric_type)) {
-               ast_log(AST_LOG_WARNING, "Invalid parameters provided. Correct format is "
-                       "StatsD(metric_type,statistic_name,value). All parameters are required.\n");
-
-               return 1;
-       }
-
-       /*
-        * Conversion to a double is safe here since the value would have been validated as a
-        * number in validate_value().
-        */
-       numerical_value = strtod(args.value, NULL);
-       ast_statsd_log(args.statistic_name, args.metric_type, numerical_value);
-
-       return 0;
-}
-
-static int unload_module(void)
-{
-       return ast_unregister_application(app);
-}
-
-static int load_module(void)
-{
-       return ast_register_application_xml(app, statsd_exec);
-}
-
-AST_MODULE_INFO_STANDARD_EXTENDED(ASTERISK_GPL_KEY, "StatsD Dialplan Application");
+/*\r
+ * Asterisk -- An open source telephony toolkit.\r
+ *\r
+ * Copyright (C) 2015, Digium, Inc.\r
+ *\r
+ * Tyler Cambron <tcambron@digium.com>\r
+ *\r
+ * See http://www.asterisk.org for more information about\r
+ * the Asterisk project. Please do not directly contact\r
+ * any of the maintainers of this project for assistance;\r
+ * the project provides a web site, mailing lists and IRC\r
+ * channels for your use.\r
+ *\r
+ * This program is free software, distributed under the terms of\r
+ * the GNU General Public License Version 2. See the LICENSE file\r
+ * at the top of the source tree.\r
+ */\r
+\r
+ /*** MODULEINFO\r
+       <depend>res_statsd</depend>\r
+       <defaultenabled>no</defaultenabled>\r
+       <support_level>extended</support_level>\r
+ ***/\r
+\r
+#include "asterisk.h"\r
+\r
+ASTERISK_REGISTER_FILE()\r
+\r
+#include <math.h>\r
+\r
+#include "asterisk/module.h"\r
+#include "asterisk/logger.h"\r
+#include "asterisk/app.h"\r
+#include "asterisk/pbx.h"\r
+#include "asterisk/strings.h"\r
+#include "asterisk/statsd.h"\r
+\r
+/*** DOCUMENTATION\r
+       <application name="StatsD" language="en_US">\r
+               <synopsis>\r
+                       Allow statistics to be passed to the StatsD server from the dialplan.\r
+               </synopsis>\r
+               <syntax>\r
+                       <parameter name="metric_type" required="true">\r
+                               <para>The metric type to be sent to StatsD. Valid metric types\r
+                               are 'g' for gauge, 'c' for counter, 'ms' for timer, and 's' for\r
+                               sets.</para>\r
+                       </parameter>\r
+                       <parameter name="statistic_name" required="true">\r
+                               <para>The name of the variable to be sent to StatsD. Statistic\r
+                               names cannot contain the pipe (|) character.</para>\r
+                       </parameter>\r
+                       <parameter name="value" required="true">\r
+                               <para>The value of the variable to be sent to StatsD. Values\r
+                               must be numeric. Values for gauge and counter metrics can be\r
+                               sent with a '+' or '-' to update a value after the value has\r
+                               been initialized. Only counters can be initialized as negative.\r
+                               Sets can send a string as the value parameter, but the string\r
+                               cannot contain the pipe character.</para>\r
+                       </parameter>\r
+                       <parameter name="sample_rate">\r
+                               <para>The value of the sample rate to be sent to StatsD. Sample\r
+                               rates less than or equal to 0 will never be sent and sample rates\r
+                               greater than or equal to 1 will always be sent. Any rate\r
+                               between 1 and 0 will be compared to a randomly generated value,\r
+                               and if it is greater than the random value, it will be sent.</para>\r
+                       </parameter>\r
+               </syntax>\r
+               <description>\r
+                       <para>This dialplan application sends statistics to the StatsD\r
+                       server specified inside of <literal>statsd.conf</literal>.</para>\r
+               </description>\r
+       </application>\r
+ ***/\r
+\r
+static const char app[] = "StatsD";\r
+\r
+/*!\r
+ * \brief Check to ensure the value is within the allowed range.\r
+ *\r
+ * \param value The value of the statistic to be sent to StatsD.\r
+ *\r
+ * This function checks to see if the value given to the StatsD daialplan\r
+ * application is within the allowed range of [-2^63, 2^63] as specified by StatsD.\r
+ *\r
+ * \retval zero on success.\r
+ * \retval 1 on error.\r
+ */\r
+static int value_in_range(const char *value) {\r
+       double numerical_value = strtod(value, NULL);\r
+\r
+       if (numerical_value < pow(-2, 63) || numerical_value > pow(2, 63)) {\r
+               ast_log(AST_LOG_WARNING, "Value %lf out of range!\n", numerical_value);\r
+               return 1;\r
+       }\r
+\r
+       return 0;\r
+}\r
+\r
+/*!\r
+ * \brief Check to ensure the value is within the allowed range.\r
+ *\r
+ * \param value The value of the statistic to be sent to StatsD.\r
+ *\r
+ * This function checks to see if the value given to the StatsD daialplan\r
+ * application is within the allowed range of [0, 2^64] as specified by StatsD.\r
+ *\r
+ * \retval zero on success.\r
+ * \retval 1 on error.\r
+ */\r
+static int non_neg_value_range(const char *value) {\r
+       double numerical_value = strtod(value, NULL);\r
+\r
+       if (numerical_value < 0 || numerical_value > pow(2, 64)) {\r
+               ast_log(AST_LOG_WARNING, "Value %lf out of range!\n", numerical_value);\r
+               return 1;\r
+       }\r
+\r
+       return 0;\r
+}\r
+\r
+/*!\r
+ * \brief Check to ensure the metric type is a valid metric type.\r
+ *\r
+ * \param metric The metric type to be sent to StatsD.\r
+ *\r
+ * This function checks to see if the metric type given to the StatsD dialplan\r
+ * is a valid metric type. Metric types are determined by StatsD.\r
+ *\r
+ * \retval zero on success.\r
+ * \retval 1 on error.\r
+ */\r
+static int validate_metric(const char *metric)\r
+{\r
+       const char *valid_metrics[] = {"g","s","ms","c"};\r
+       int i;\r
+\r
+       if (ast_strlen_zero(metric)) {\r
+               ast_log(AST_LOG_ERROR, "Missing metric type argument.\n");\r
+               return 1;\r
+       }\r
+\r
+       for (i = 0; i < ARRAY_LEN(valid_metrics); i++) {\r
+               if (!strcmp(valid_metrics[i], metric)) {\r
+                       return 0;\r
+               }\r
+       }\r
+\r
+       ast_log(AST_LOG_ERROR, "Invalid metric type %s.\n", metric);\r
+\r
+       return 1;\r
+}\r
+\r
+/*!\r
+ * \brief Check to ensure that a numeric value is valid.\r
+ *\r
+ * \param numeric_value The numeric value to be sent to StatsD.\r
+ *\r
+ * This function checks to see if a number to be sent to StatsD is actually\r
+ * a valid number. One decimal is allowed.\r
+ *\r
+ * \retval zero on success.\r
+ * \retval 1 on error.\r
+ */\r
+static int validate_numeric(const char *numeric_value) {\r
+       const char *num;\r
+       int decimal_counter = 0;\r
+\r
+       num = numeric_value;\r
+       while (*num) {\r
+               if (!isdigit(*num++)) {\r
+                       if (strstr(numeric_value, ".") != NULL && decimal_counter == 0) {\r
+                               decimal_counter++;\r
+                               continue;\r
+                       }\r
+                       ast_log(AST_LOG_ERROR, "%s is not a number!\n", numeric_value);\r
+                       return 1;\r
+               }\r
+       }\r
+\r
+       return 0;\r
+}\r
+\r
+/*!\r
+ * \brief Determines the actual value of a number by looking for a leading + or -.\r
+ *\r
+ * \param raw_value The entire numeric string to be sent to StatsD.\r
+ *\r
+ * This function checks to see if the numeric string contains valid characters\r
+ * and then isolates the actual number to be sent for validation. Returns the\r
+ * result of the numeric validation.\r
+ *\r
+ * \retval zero on success.\r
+ * \retval 1 on error.\r
+ */\r
+static int determine_actual_value(const char *raw_value) {\r
+       const char *actual_value;\r
+\r
+       if ((raw_value[0] == '+') || (raw_value[0] == '-')) {\r
+               actual_value = &raw_value[1];\r
+               if (ast_strlen_zero(actual_value)) {\r
+                       ast_log(AST_LOG_ERROR, "Value argument %s only contains a sign"\r
+                               " operator.\n", raw_value);\r
+                       return 1;\r
+               }\r
+       } else {\r
+               actual_value = &raw_value[0];\r
+       }\r
+\r
+       return validate_numeric(actual_value);\r
+}\r
+\r
+/*!\r
+ * \brief Check to ensure the statistic name is valid.\r
+ *\r
+ * \param name The variable name to be sent to StatsD.\r
+ *\r
+ * This function checks to see if the statistic name given to the StatsD\r
+ * dialplan application is valid by ensuring that the name does not have any\r
+ * invalid characters.\r
+ *\r
+ * \retval zero on success.\r
+ * \retval 1 on error.\r
+ */\r
+static int validate_name(const char *name)\r
+{\r
+       if (ast_strlen_zero(name) || (strstr(name, "|") != NULL)) {\r
+               ast_log(AST_LOG_ERROR, "Statistic name %s is missing or contains a pipe (|)"\r
+                       " character.\n", name);\r
+               return 1;\r
+       }\r
+\r
+       return 0;\r
+}\r
+\r
+\r
+/*!\r
+ * \brief Calls the appropriate functions to validate a gauge metric.\r
+ *\r
+ * \param statistic_name The statistic name to be sent to StatsD.\r
+ * \param value The value to be sent to StatsD.\r
+ *\r
+ * This function calls other validating functions to correctly validate each\r
+ * input based on allowable input for a gauge metric.\r
+ *\r
+ * \retval zero on success.\r
+ * \retval 1 on error.\r
+ */\r
+static int validate_metric_type_gauge(const char *statistic_name, const char *value) {\r
+\r
+       if (ast_strlen_zero(value)) {\r
+               ast_log(AST_LOG_ERROR, "Missing value argument.\n");\r
+               return 1;\r
+       }\r
+\r
+       if (validate_name(statistic_name) || determine_actual_value(value)\r
+               || value_in_range(value)) {\r
+               return 1;\r
+       }\r
+\r
+       return 0;\r
+}\r
+\r
+/*!\r
+ * \brief Calls the appropriate functions to validate a counter metric.\r
+ *\r
+ * \param statistic_name The statistic name to be sent to StatsD.\r
+ * \param value The value to be sent to StatsD.\r
+ *\r
+ * This function calls other validating functions to correctly validate each\r
+ * input based on allowable input for a counter metric.\r
+ *\r
+ * \retval zero on success.\r
+ * \retval 1 on error.\r
+ */\r
+static int validate_metric_type_counter(const char *statistic_name, const char *value) {\r
+\r
+       if (ast_strlen_zero(value)) {\r
+               ast_log(AST_LOG_ERROR, "Missing value argument.\n");\r
+               return 1;\r
+       }\r
+\r
+       if (validate_name(statistic_name) || determine_actual_value(value)\r
+               || value_in_range(value)) {\r
+               return 1;\r
+       }\r
+\r
+       return 0;\r
+}\r
+\r
+/*!\r
+ * \brief Calls the appropriate functions to validate a timer metric.\r
+ *\r
+ * \param statistic_name The statistic name to be sent to StatsD.\r
+ * \param value The value to be sent to StatsD.\r
+ *\r
+ * This function calls other validating functions to correctly validate each\r
+ * input based on allowable input for a timer metric.\r
+ *\r
+ * \retval zero on success.\r
+ * \retval 1 on error.\r
+ */\r
+static int validate_metric_type_timer(const char *statistic_name, const char *value) {\r
+\r
+       if (ast_strlen_zero(value)) {\r
+               ast_log(AST_LOG_ERROR, "Missing value argument.\n");\r
+               return 1;\r
+       }\r
+\r
+       if (validate_name(statistic_name) || validate_numeric(value)\r
+               || non_neg_value_range(value)) {\r
+               return 1;\r
+       }\r
+\r
+       return 0;\r
+}\r
+\r
+/*!\r
+ * \brief Calls the appropriate functions to validate a set metric.\r
+ *\r
+ * \param statistic_name The statistic name to be sent to StatsD.\r
+ * \param value The value to be sent to StatsD.\r
+ *\r
+ * This function calls other validating functions to correctly validate each\r
+ * input based on allowable input for a set metric.\r
+ *\r
+ * \retval zero on success.\r
+ * \retval 1 on error.\r
+ */\r
+static int validate_metric_type_set(const char *statistic_name, const char *value) {\r
+       if (ast_strlen_zero(value)) {\r
+               ast_log(AST_LOG_ERROR, "Missing value argument.\n");\r
+               return 1;\r
+       }\r
+\r
+       if (validate_name(statistic_name)) {\r
+               return 1;\r
+       }\r
+\r
+       if (strstr(value, "|") != NULL) {\r
+               ast_log(AST_LOG_ERROR, "Pipe (|) character is not allowed for value %s"\r
+                       " in a set metric.\n", value);\r
+               return 1;\r
+       }\r
+\r
+       return 0;\r
+}\r
+\r
+static int statsd_exec(struct ast_channel *chan, const char *data)\r
+{\r
+       char *stats;\r
+       double numerical_rate = 1.0;\r
+\r
+       AST_DECLARE_APP_ARGS(args,\r
+                       AST_APP_ARG(metric_type);\r
+                       AST_APP_ARG(statistic_name);\r
+                       AST_APP_ARG(value);\r
+                       AST_APP_ARG(sample_rate);\r
+       );\r
+\r
+       if (!data) {\r
+               ast_log(AST_LOG_ERROR, "No parameters were provided. Correct format is "\r
+                       "StatsD(metric_type,statistic_name,value[,sample_rate]). Sample rate is the "\r
+                       "only optional parameter.\n");\r
+               return 1;\r
+       }\r
+\r
+       stats = ast_strdupa(data);\r
+       AST_STANDARD_APP_ARGS(args, stats);\r
+\r
+       if (validate_metric(args.metric_type)) {\r
+               return 1;\r
+       }\r
+\r
+       if (!strcmp(args.metric_type, "g")) {\r
+               if (validate_metric_type_gauge(args.statistic_name, args.value)) {\r
+                       ast_log(AST_LOG_ERROR, "Invalid input for a gauge metric.\n");\r
+                       return 1;\r
+               }\r
+       }\r
+       else if (!strcmp(args.metric_type, "c")) {\r
+               if (validate_metric_type_counter(args.statistic_name, args.value)) {\r
+                       ast_log(AST_LOG_ERROR, "Invalid input for a counter metric.\n");\r
+                       return 1;\r
+               }\r
+       }\r
+       else if (!strcmp(args.metric_type, "ms")) {\r
+               if (validate_metric_type_timer(args.statistic_name, args.value)) {\r
+                       ast_log(AST_LOG_ERROR, "Invalid input for a timer metric.\n");\r
+                       return 1;\r
+               }\r
+       }\r
+       else if (!strcmp(args.metric_type, "s")) {\r
+               if (validate_metric_type_set(args.statistic_name, args.value)) {\r
+                       ast_log(AST_LOG_ERROR, "Invalid input for a set metric.\n");\r
+                       return 1;\r
+               }\r
+       }\r
+\r
+       if (args.sample_rate) {\r
+\r
+               if (validate_numeric(args.sample_rate)) {\r
+                       return 1;\r
+               }\r
+\r
+               numerical_rate = strtod(args.sample_rate, NULL);\r
+       }\r
+\r
+       ast_statsd_log_string(args.statistic_name, args.metric_type, args.value,\r
+               numerical_rate);\r
+\r
+       return 0;\r
+}\r
+\r
+static int unload_module(void)\r
+{\r
+       return ast_unregister_application(app);\r
+}\r
+\r
+static int load_module(void)\r
+{\r
+       return ast_register_application_xml(app, statsd_exec);\r
+}\r
+\r
+AST_MODULE_INFO_STANDARD_EXTENDED(ASTERISK_GPL_KEY, "StatsD Dialplan Application");\r
index 9527469..ccf2176 100644 (file)
@@ -236,7 +236,7 @@ static struct ast_format *h264_parse_sdp_fmtp(const struct ast_format *format, c
        if (field != H264_ATTR_KEY_UNSET) {     \
                if (added) {    \
                        ast_str_append(str, 0, ";");    \
-               } else {        \
+               } else if (0 < ast_str_append(str, 0, "a=fmtp:%u ", payload)) { \
                        added = 1;      \
                }       \
                ast_str_append(str, 0, "%s=%u", name, field);   \
@@ -247,7 +247,7 @@ static struct ast_format *h264_parse_sdp_fmtp(const struct ast_format *format, c
        if (field) {    \
                if (added) {    \
                        ast_str_append(str, 0, ";");    \
-               } else {        \
+               } else if (0 < ast_str_append(str, 0, "a=fmtp:%u ", payload)) { \
                        added = 1;      \
                }       \
                ast_str_append(str, 0, "%s=%u", name, field);   \
@@ -263,8 +263,6 @@ static void h264_generate_sdp_fmtp(const struct ast_format *format, unsigned int
                return;
        }
 
-       ast_str_append(str, 0, "a=fmtp:%u ", payload);
-
        APPEND_IF_NONZERO(attr->MAX_MBPS, str, "max-mbps");
        APPEND_IF_NONZERO(attr->MAX_FS, str, "max-fs");
        APPEND_IF_NONZERO(attr->MAX_CPB, str, "max-cpb");
@@ -287,7 +285,7 @@ static void h264_generate_sdp_fmtp(const struct ast_format *format, unsigned int
        if (attr->PROFILE_IDC && attr->PROFILE_IOP && attr->LEVEL) {
                if (added) {
                        ast_str_append(str, 0, ";");
-               } else {
+               } else if (0 < ast_str_append(str, 0, "a=fmtp:%u ", payload)) {
                        added = 1;
                }
                ast_str_append(str, 0, "profile-level-id=%02X%02X%02X", attr->PROFILE_IDC, attr->PROFILE_IOP, attr->LEVEL);
@@ -296,15 +294,13 @@ static void h264_generate_sdp_fmtp(const struct ast_format *format, unsigned int
        if (!ast_strlen_zero(attr->SPS) && !ast_strlen_zero(attr->PPS)) {
                if (added) {
                        ast_str_append(str, 0, ";");
-               } else {
+               } else if (0 < ast_str_append(str, 0, "a=fmtp:%u ", payload)) {
                        added = 1;
                }
-               ast_str_append(str, 0, ";sprop-parameter-sets=%s,%s", attr->SPS, attr->PPS);
+               ast_str_append(str, 0, "sprop-parameter-sets=%s,%s", attr->SPS, attr->PPS);
        }
 
-       if (!added) {
-               ast_str_reset(*str);
-       } else {
+       if (added) {
                ast_str_append(str, 0, "\r\n");
        }
 
index 83386c6..e6cd961 100644 (file)
@@ -1867,6 +1867,13 @@ static void registration_loaded_observer(const char *name, const struct ast_sorc
                return;
        }
 
+       /*
+        * Refresh the current configured registrations. We don't need to hold
+        * onto the objects, as the apply handler will cause their states to
+        * be created appropriately.
+        */
+       ao2_cleanup(get_registrations());
+
        /* Now to purge dead registrations. */
        ao2_callback(states, OBJ_UNLINK | OBJ_NODATA | OBJ_MULTIPLE, check_state, NULL);
        ao2_ref(states, -1);