res_pjsip: Config option to enable PJSIP logger at load time.
[asterisk/asterisk.git] / res / res_pjsip_logger.c
1 /*
2  * Asterisk -- An open source telephony toolkit.
3  *
4  * Copyright (C) 2013, Digium, Inc.
5  *
6  * Mark Michelson <mmichelson@digium.com>
7  *
8  * See http://www.asterisk.org for more information about
9  * the Asterisk project. Please do not directly contact
10  * any of the maintainers of this project for assistance;
11  * the project provides a web site, mailing lists and IRC
12  * channels for your use.
13  *
14  * This program is free software, distributed under the terms of
15  * the GNU General Public License Version 2. See the LICENSE file
16  * at the top of the source tree.
17  */
18
19 /*** MODULEINFO
20         <depend>pjproject</depend>
21         <depend>res_pjsip</depend>
22         <defaultenabled>yes</defaultenabled>
23         <support_level>core</support_level>
24  ***/
25
26 #include "asterisk.h"
27
28 ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
29
30 #include <pjsip.h>
31
32 #include "asterisk/res_pjsip.h"
33 #include "asterisk/module.h"
34 #include "asterisk/logger.h"
35 #include "asterisk/cli.h"
36 #include "asterisk/netsock2.h"
37
38 enum pjsip_logging_mode {
39         LOGGING_MODE_DISABLED,    /* No logging is enabled */
40         LOGGING_MODE_ENABLED,     /* Logging is enabled */
41 };
42
43 static enum pjsip_logging_mode logging_mode;
44 static struct ast_sockaddr log_addr;
45
46 /*! \brief  Return the first entry from ast_sockaddr_resolve filtered by address family
47  *
48  * \warning Using this function probably means you have a faulty design.
49  * \note This function was taken from the function of the same name in chan_sip.c
50  */
51 static int ast_sockaddr_resolve_first_af(struct ast_sockaddr *addr,
52                                       const char* name, int flag, int family)
53 {
54         struct ast_sockaddr *addrs;
55         int addrs_cnt;
56
57         addrs_cnt = ast_sockaddr_resolve(&addrs, name, flag, family);
58         if (addrs_cnt <= 0) {
59                 return 1;
60         }
61         if (addrs_cnt > 1) {
62                 ast_debug(1, "Multiple addresses, using the first one only\n");
63         }
64
65         ast_sockaddr_copy(addr, &addrs[0]);
66
67         ast_free(addrs);
68         return 0;
69 }
70
71 /*! \brief See if we pass debug IP filter */
72 static inline int pjsip_log_test_addr(const char *address, int port)
73 {
74         struct ast_sockaddr test_addr;
75         if (logging_mode == LOGGING_MODE_DISABLED) {
76                 return 0;
77         }
78
79         /* A null logging address means we'll debug any address */
80         if (ast_sockaddr_isnull(&log_addr)) {
81                 return 1;
82         }
83
84         /* A null address was passed in. Just reject it. */
85         if (ast_strlen_zero(address)) {
86                 return 0;
87         }
88
89         ast_sockaddr_parse(&test_addr, address, PARSE_PORT_IGNORE);
90         ast_sockaddr_set_port(&test_addr, port);
91
92         /* If no port was specified for a debug address, just compare the
93          * addresses, otherwise compare the address and port
94          */
95         if (ast_sockaddr_port(&log_addr)) {
96                 return !ast_sockaddr_cmp(&log_addr, &test_addr);
97         } else {
98                 return !ast_sockaddr_cmp_addr(&log_addr, &test_addr);
99         }
100 }
101
102 static pj_status_t logging_on_tx_msg(pjsip_tx_data *tdata)
103 {
104         if (!pjsip_log_test_addr(tdata->tp_info.dst_name, tdata->tp_info.dst_port)) {
105                 return PJ_SUCCESS;
106         }
107
108         ast_verbose("<--- Transmitting SIP %s (%d bytes) to %s:%s:%d --->\n%.*s\n",
109                     tdata->msg->type == PJSIP_REQUEST_MSG ? "request" : "response",
110                     (int) (tdata->buf.cur - tdata->buf.start),
111                     tdata->tp_info.transport->type_name,
112                     tdata->tp_info.dst_name,
113                     tdata->tp_info.dst_port,
114                     (int) (tdata->buf.end - tdata->buf.start), tdata->buf.start);
115         return PJ_SUCCESS;
116 }
117
118 static pj_bool_t logging_on_rx_msg(pjsip_rx_data *rdata)
119 {
120         if (!pjsip_log_test_addr(rdata->pkt_info.src_name, rdata->pkt_info.src_port)) {
121                 return PJ_FALSE;
122         }
123
124         ast_verbose("<--- Received SIP %s (%d bytes) from %s:%s:%d --->\n%s\n",
125                     rdata->msg_info.msg->type == PJSIP_REQUEST_MSG ? "request" : "response",
126                     rdata->msg_info.len,
127                     rdata->tp_info.transport->type_name,
128                     rdata->pkt_info.src_name,
129                     rdata->pkt_info.src_port,
130                     rdata->pkt_info.packet);
131         return PJ_FALSE;
132 }
133
134 static pjsip_module logging_module = {
135         .name = { "Logging Module", 14 },
136         .priority = 0,
137         .on_rx_request = logging_on_rx_msg,
138         .on_rx_response = logging_on_rx_msg,
139         .on_tx_request = logging_on_tx_msg,
140         .on_tx_response = logging_on_tx_msg,
141 };
142
143 static char *pjsip_enable_logger_host(int fd, const char *arg)
144 {
145         if (ast_sockaddr_resolve_first_af(&log_addr, arg, 0, AST_AF_UNSPEC)) {
146                 return CLI_SHOWUSAGE;
147         }
148
149         ast_cli(fd, "PJSIP Logging Enabled for host: %s\n", ast_sockaddr_stringify_addr(&log_addr));
150         logging_mode = LOGGING_MODE_ENABLED;
151
152         return CLI_SUCCESS;
153 }
154
155 static char *pjsip_set_logger(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
156 {
157         const char *what;
158
159         if (cmd == CLI_INIT) {
160                 e->command = "pjsip set logger {on|off|host}";
161                 e->usage =
162                         "Usage: pjsip set logger {on|off}\n"
163                         "       Enables or disabling logging of SIP packets\n"
164                         "       read on ports bound to PJSIP transports either\n"
165                         "       globally or enables logging for an individual\n"
166                         "       host.\n";
167                 return NULL;
168         } else if (cmd == CLI_GENERATE) {
169                 return NULL;
170         }
171
172         what = a->argv[e->args - 1];     /* Guaranteed to exist */
173
174         if (a->argc == e->args) {        /* on/off */
175                 if (!strcasecmp(what, "on")) {
176                         logging_mode = LOGGING_MODE_ENABLED;
177                         ast_cli(a->fd, "PJSIP Logging enabled\n");
178                         ast_sockaddr_setnull(&log_addr);
179                         return CLI_SUCCESS;
180                 } else if (!strcasecmp(what, "off")) {
181                         logging_mode = LOGGING_MODE_DISABLED;
182                         ast_cli(a->fd, "PJSIP Logging disabled\n");
183                         return CLI_SUCCESS;
184                 }
185         } else if (a->argc == e->args + 1) {
186                 if (!strcasecmp(what, "host")) {
187                         return pjsip_enable_logger_host(a->fd, a->argv[e->args]);
188                 }
189         }
190
191         return CLI_SHOWUSAGE;
192 }
193
194 static struct ast_cli_entry cli_pjsip[] = {
195         AST_CLI_DEFINE(pjsip_set_logger, "Enable/Disable PJSIP Logger Output")
196 };
197
198 static void check_debug(void)
199 {
200         RAII_VAR(char *, debug, ast_sip_get_debug(), ast_free);
201
202         if (ast_false(debug)) {
203                 logging_mode = LOGGING_MODE_DISABLED;
204                 return;
205         }
206
207         logging_mode = LOGGING_MODE_ENABLED;
208
209         if (ast_true(debug)) {
210                 ast_sockaddr_setnull(&log_addr);
211                 return;
212         }
213
214         /* assume host */
215         if (ast_sockaddr_resolve_first_af(&log_addr, debug, 0, AST_AF_UNSPEC)) {
216                 ast_log(LOG_WARNING, "Could not resolve host %s for debug "
217                         "logging\n", debug);
218         }
219 }
220
221 static void global_reloaded(const char *object_type)
222 {
223         check_debug();
224 }
225
226 static const struct ast_sorcery_observer global_observer = {
227         .loaded = global_reloaded
228 };
229
230 static int load_module(void)
231 {
232         if (ast_sorcery_observer_add(ast_sip_get_sorcery(), "global", &global_observer)) {
233                 ast_log(LOG_WARNING, "Unable to add global observer\n");
234                 return AST_MODULE_LOAD_DECLINE;
235         }
236
237         check_debug();
238
239         ast_sip_register_service(&logging_module);
240         ast_cli_register_multiple(cli_pjsip, ARRAY_LEN(cli_pjsip));
241
242         return AST_MODULE_LOAD_SUCCESS;
243 }
244
245 static int unload_module(void)
246 {
247         ast_cli_unregister_multiple(cli_pjsip, ARRAY_LEN(cli_pjsip));
248         ast_sip_unregister_service(&logging_module);
249
250         ast_sorcery_observer_remove(
251                 ast_sip_get_sorcery(), "global", &global_observer);
252
253         return 0;
254 }
255
256 AST_MODULE_INFO(ASTERISK_GPL_KEY, AST_MODFLAG_LOAD_ORDER, "PJSIP Packet Logger",
257                 .load = load_module,
258                 .unload = unload_module,
259                 .load_pri = AST_MODPRI_APP_DEPEND,
260                );