res_fax.c: crash on framehook with no dsp in fax detect
[asterisk/asterisk.git] / apps / app_forkcdr.c
1 /*
2  * Asterisk -- An open source telephony toolkit.
3  *
4  * Copyright (C) 1999 - 2005, Anthony Minessale anthmct@yahoo.com
5  * Development of this app Sponsered/Funded  by TAAN Softworks Corp
6  *
7  * See http://www.asterisk.org for more information about
8  * the Asterisk project. Please do not directly contact
9  * any of the maintainers of this project for assistance;
10  * the project provides a web site, mailing lists and IRC
11  * channels for your use.
12  *
13  * This program is free software, distributed under the terms of
14  * the GNU General Public License Version 2. See the LICENSE file
15  * at the top of the source tree.
16  */
17
18 /*! \file
19  *
20  * \brief Fork CDR application
21  *
22  * \author Anthony Minessale anthmct@yahoo.com
23  *
24  * \note Development of this app Sponsored/Funded by TAAN Softworks Corp
25  * 
26  * \ingroup applications
27  */
28
29 /*** MODULEINFO
30         <support_level>core</support_level>
31  ***/
32
33 #include "asterisk.h"
34
35 ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
36
37 #include "asterisk/file.h"
38 #include "asterisk/channel.h"
39 #include "asterisk/pbx.h"
40 #include "asterisk/cdr.h"
41 #include "asterisk/app.h"
42 #include "asterisk/module.h"
43 #include "asterisk/stasis.h"
44
45 /*** DOCUMENTATION
46         <application name="ForkCDR" language="en_US">
47                 <synopsis>
48                         Forks the current Call Data Record for this channel.
49                 </synopsis>
50                 <syntax>
51                         <parameter name="options">
52                                 <optionlist>
53                                         <option name="a">
54                                                 <para>If the channel is answered, set the answer time on
55                                                 the forked CDR to the current time. If this option is
56                                                 not used, the answer time on the forked CDR will be the
57                                                 answer time on the original CDR. If the channel is not
58                                                 answered, this option has no effect.</para>
59                                                 <para>Note that this option is implicitly assumed if the
60                                                 <literal>r</literal> option is used.</para>
61                                         </option>
62                                         <option name="e">
63                                                 <para>End (finalize) the original CDR.</para>
64                                         </option>
65                                         <option name="r">
66                                                 <para>Reset the start and answer times on the forked CDR.
67                                                 This will set the start and answer times (if the channel
68                                                 is answered) to be set to the current time.</para>
69                                                 <para>Note that this option implicitly assumes the
70                                                 <literal>a</literal> option.</para>
71                                         </option>
72                                         <option name="v">
73                                                 <para>Do not copy CDR variables and attributes from the
74                                                 original CDR to the forked CDR.</para>
75                                                 <warning><para>This option has changed. Previously, the
76                                                 variables were removed from the original CDR. This no
77                                                 longer occurs - this option now controls whether or not
78                                                 a forked CDR inherits the variables from the original
79                                                 CDR.</para></warning>
80                                         </option>
81                                 </optionlist>
82                         </parameter>
83                 </syntax>
84                 <description>
85                         <para>Causes the Call Data Record engine to fork a new CDR starting
86                         from the time the application is executed. The forked CDR will be
87                         linked to the end of the CDRs associated with the channel.</para>
88                 </description>
89                 <see-also>
90                         <ref type="function">CDR</ref>
91                         <ref type="application">NoCDR</ref>
92                         <ref type="application">ResetCDR</ref>
93                 </see-also>
94         </application>
95  ***/
96
97 static char *app = "ForkCDR";
98
99 AST_APP_OPTIONS(forkcdr_exec_options, {
100         AST_APP_OPTION('a', AST_CDR_FLAG_SET_ANSWER),
101         AST_APP_OPTION('e', AST_CDR_FLAG_FINALIZE),
102         AST_APP_OPTION('r', AST_CDR_FLAG_RESET),
103         AST_APP_OPTION('v', AST_CDR_FLAG_KEEP_VARS),
104 });
105
106 STASIS_MESSAGE_TYPE_DEFN_LOCAL(forkcdr_message_type);
107
108 /*! \internal \brief Message payload for the Stasis message sent to fork the CDR */
109 struct fork_cdr_message_payload {
110         /*! The name of the channel whose CDR will be forked */
111         const char *channel_name;
112         /*! Option flags that control how the CDR will be forked */
113         struct ast_flags *flags;
114 };
115
116 static void forkcdr_callback(void *data, struct stasis_subscription *sub, struct stasis_message *message)
117 {
118         struct fork_cdr_message_payload *payload;
119
120         if (stasis_message_type(message) != forkcdr_message_type()) {
121                 return;
122         }
123
124         payload = stasis_message_data(message);
125         if (!payload) {
126                 return;
127         }
128
129         if (ast_cdr_fork(payload->channel_name, payload->flags)) {
130                 ast_log(AST_LOG_WARNING, "Failed to fork CDR for channel %s\n",
131                         payload->channel_name);
132         }
133 }
134
135 static int forkcdr_exec(struct ast_channel *chan, const char *data)
136 {
137         RAII_VAR(struct stasis_message *, message, NULL, ao2_cleanup);
138         RAII_VAR(struct fork_cdr_message_payload *, payload, ao2_alloc(sizeof(*payload), NULL), ao2_cleanup);
139         RAII_VAR(struct stasis_subscription *, subscription, NULL, ao2_cleanup);
140
141         char *parse;
142         struct ast_flags flags = { 0, };
143         AST_DECLARE_APP_ARGS(args,
144                 AST_APP_ARG(options);
145         );
146
147         parse = ast_strdupa(data);
148
149         AST_STANDARD_APP_ARGS(args, parse);
150
151         if (!ast_strlen_zero(args.options)) {
152                 ast_app_parse_options(forkcdr_exec_options, &flags, NULL, args.options);
153         }
154
155         if (!payload) {
156                 return -1;
157         }
158
159         payload->channel_name = ast_channel_name(chan);
160         payload->flags = &flags;
161         message = stasis_message_create(forkcdr_message_type(), payload);
162         if (!message) {
163                 ast_log(AST_LOG_WARNING, "Failed to fork CDR for channel %s: unable to create message\n",
164                         ast_channel_name(chan));
165                 return -1;
166         }
167
168         subscription = stasis_subscribe(ast_channel_topic(chan), forkcdr_callback, NULL);
169         if (!subscription) {
170                 ast_log(AST_LOG_WARNING, "Failed to fork CDR for channel %s: unable to create subscription\n",
171                         payload->channel_name);
172                 return -1;
173         }
174
175         stasis_publish(ast_channel_topic(chan), message);
176
177         subscription = stasis_unsubscribe_and_join(subscription);
178
179         return 0;
180 }
181
182 static int unload_module(void)
183 {
184         STASIS_MESSAGE_TYPE_CLEANUP(forkcdr_message_type);
185
186         return ast_unregister_application(app);
187 }
188
189 static int load_module(void)
190 {
191         int res = 0;
192
193         res |= STASIS_MESSAGE_TYPE_INIT(forkcdr_message_type);
194         res |= ast_register_application_xml(app, forkcdr_exec);
195
196         return res;
197 }
198
199 AST_MODULE_INFO_STANDARD(ASTERISK_GPL_KEY, "Fork The CDR into 2 separate entities");