aboutsummaryrefslogtreecommitdiffstats
path: root/apps/app_forkcdr.c
blob: ffeeca8ece52e86f66fa5d90a9416a19c7fe7a86 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
/*
 * Asterisk -- An open source telephony toolkit.
 *
 * Copyright (C) 1999 - 2005, Anthony Minessale anthmct@yahoo.com
 * Development of this app Sponsered/Funded  by TAAN Softworks Corp
 *
 * 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 Fork CDR application
 *
 * \author Anthony Minessale anthmct@yahoo.com
 *
 * \note Development of this app Sponsored/Funded by TAAN Softworks Corp
 * 
 * \ingroup applications
 */

/*** MODULEINFO
	<support_level>core</support_level>
 ***/

#include "asterisk.h"

ASTERISK_FILE_VERSION(__FILE__, "$Revision$")

#include "asterisk/file.h"
#include "asterisk/channel.h"
#include "asterisk/pbx.h"
#include "asterisk/cdr.h"
#include "asterisk/app.h"
#include "asterisk/module.h"

/*** DOCUMENTATION
	<application name="ForkCDR" language="en_US">
		<synopsis>
			Forks the Call Data Record.
		</synopsis>
		<syntax>
			<parameter name="options">
				<optionlist>
					<option name="a">
						<para>Update the answer time on the NEW CDR just after it's been inited.
						The new CDR may have been answered already. The reset that forkcdr does
						will erase the answer time. This will bring it back, but the answer time
						will be a copy of the fork/start time. It will only do this if the initial
						cdr was indeed already answered.</para>
					</option>
					<option name="A">
						<para>Lock the original CDR against the answer time being updated. This
						will allow the disposition on the original CDR to remain the same.</para>
					</option>
					<option name="d">
						<para>Copy the disposition forward from the old cdr, after the init.</para>
					</option>
					<option name="D">
						<para>Clear the <literal>dstchannel</literal> on the new CDR after
						reset.</para>
					</option>
					<option name="e">
						<para>End the original CDR. Do this after all the necessary data is copied
						from the original CDR to the new forked CDR.</para>
					</option>
					<option name="r">
						<para>Do <emphasis>NOT</emphasis> reset the new cdr.</para>
					</option>
					<option name="s(name=val)">
						<para>Set the CDR var <replaceable>name</replaceable> in the original CDR,
						with value <replaceable>val</replaceable>.</para>
					</option>
					<option name="T">
						<para>Mark the original CDR with a DONT_TOUCH flag. setvar, answer, and end
						cdr funcs will obey this flag; normally they don't honor the LOCKED flag
						set on the original CDR record.</para>
						<note><para>Using this flag may cause CDR's not to have their end times
						updated! It is suggested that if you specify this flag, you might wish
						to use the <literal>e</literal> flag as well!.</para></note>
					</option>
					<option name="v">
						<para>When the new CDR is forked, it gets a copy of the vars attached to
						the current CDR. The vars attached to the original CDR are removed unless
						this option is specified.</para>
					</option>
				</optionlist>
			</parameter>
		</syntax>
		<description>
			<para> Causes the Call Data Record to fork an additional cdr record starting from the time
			of the fork call. This new cdr record will be linked to end of the list of cdr records attached
			to the channel.	The original CDR has a LOCKED flag set, which forces most cdr operations to skip
			it, except for the functions that set the answer and end times, which ignore the LOCKED flag. This
			allows all the cdr records in the channel to be 'ended' together when the channel is closed.</para>
			<para>The CDR() func (when setting CDR values) normally ignores the LOCKED flag also, but has options
			to vary its behavior. The 'T' option (described below), can override this behavior, but beware
			the risks.</para>
			<para>First, this app finds the last cdr record in the list, and makes a copy of it. This new copy
			will be the newly forked cdr record. Next, this new record is linked to the end of the cdr record list.
			Next, The new cdr record is RESET (unless you use an option to prevent this)</para>
			<para>This means that:</para>
			<para>   1. All flags are unset on the cdr record</para>
			<para>   2. the start, end, and answer times are all set to zero.</para>
			<para>   3. the billsec and duration fields are set to zero.</para>
			<para>   4. the start time is set to the current time.</para>
			<para>   5. the disposition is set to NULL.</para>
			<para>Next, unless you specified the <literal>v</literal> option, all variables will be removed from
			the original cdr record. Thus, the <literal>v</literal> option allows any CDR variables to be replicated
			to all new forked cdr records. Without the <literal>v</literal> option, the variables on the original
			are effectively moved to the new forked cdr record.</para>
			<para>Next, if the <literal>s</literal> option is set, the provided variable and value are set on the
			original cdr record.</para>
			<para>Next, if the <literal>a</literal> option is given, and the original cdr record has an answer time
			set, then the new forked cdr record will have its answer time set to its start time. If the old answer
			time were carried forward, the answer time would be earlier than the start time, giving strange
			duration and billsec times.</para>
			<para>If the <literal>d</literal> option was specified, the disposition is copied from
			the original cdr record to the new forked cdr. If the <literal>D</literal> option was specified,
			the destination channel field in the new forked CDR is erased. If the <literal>e</literal> option
			was specified, the 'end' time for the original cdr record is set to the current time. Future hang-up or
			ending events will not override this time stamp. If the <literal>A</literal> option is specified,
			the original cdr record will have it ANS_LOCKED flag set, which prevent future answer events from updating
			the original cdr record's disposition. Normally, an <literal>ANSWERED</literal> event would mark all cdr
			records in the chain as <literal>ANSWERED</literal>. If the <literal>T</literal> option is specified,
			the original cdr record will have its <literal>DONT_TOUCH</literal> flag set, which will force the
			cdr_answer, cdr_end, and cdr_setvar functions to leave that cdr record alone.</para>
			<para>And, last but not least, the original cdr record has its LOCKED flag set. Almost all internal
			CDR functions (except for the funcs that set the end, and answer times, and set a variable) will honor
			this flag and leave a LOCKED cdr record alone. This means that the newly created forked cdr record
			will be affected by events transpiring within Asterisk, with the previously noted exceptions.</para>
		</description>
		<see-also>
			<ref type="function">CDR</ref>
			<ref type="application">NoCDR</ref>
			<ref type="application">ResetCDR</ref>
		</see-also>
	</application>
 ***/

static char *app = "ForkCDR";

enum {
	OPT_SETANS =            (1 << 0),
	OPT_SETDISP =           (1 << 1),
	OPT_RESETDEST =         (1 << 2),
	OPT_ENDCDR =            (1 << 3),
	OPT_NORESET =           (1 << 4),
	OPT_KEEPVARS =          (1 << 5),
	OPT_VARSET =            (1 << 6),
	OPT_ANSLOCK =           (1 << 7),
	OPT_DONTOUCH =          (1 << 8),
};

enum {
	OPT_ARG_VARSET = 0,
	/* note: this entry _MUST_ be the last one in the enum */
	OPT_ARG_ARRAY_SIZE,
};

AST_APP_OPTIONS(forkcdr_exec_options, {
	AST_APP_OPTION('a', OPT_SETANS),
	AST_APP_OPTION('A', OPT_ANSLOCK),
	AST_APP_OPTION('d', OPT_SETDISP),
	AST_APP_OPTION('D', OPT_RESETDEST),
	AST_APP_OPTION('e', OPT_ENDCDR),
	AST_APP_OPTION('R', OPT_NORESET),
	AST_APP_OPTION_ARG('s', OPT_VARSET, OPT_ARG_VARSET),
	AST_APP_OPTION('T', OPT_DONTOUCH),
	AST_APP_OPTION('v', OPT_KEEPVARS),
});

static void ast_cdr_fork(struct ast_channel *chan, struct ast_flags optflags, char *set) 
{
	struct ast_cdr *cdr;
	struct ast_cdr *newcdr;
	struct ast_flags flags = { AST_CDR_FLAG_KEEP_VARS };

	cdr = chan->cdr;

	while (cdr->next)
		cdr = cdr->next;
	
	if (!(newcdr = ast_cdr_dup_unique(cdr)))
		return;
	
	ast_cdr_append(cdr, newcdr);

	if (!ast_test_flag(&optflags, OPT_NORESET))
		ast_cdr_reset(newcdr, &flags);
		
	if (!ast_test_flag(cdr, AST_CDR_FLAG_KEEP_VARS))
		ast_cdr_free_vars(cdr, 0);
	
	if (!ast_strlen_zero(set)) {
		char *varname = ast_strdupa(set), *varval;
		varval = strchr(varname,'=');
		if (varval) {
			*varval = 0;
			varval++;
			ast_cdr_setvar(cdr, varname, varval, 0);
		}
	}
	
	if (ast_test_flag(&optflags, OPT_SETANS) && !ast_tvzero(cdr->answer))
		newcdr->answer = newcdr->start;

	if (ast_test_flag(&optflags, OPT_SETDISP))
		newcdr->disposition = cdr->disposition;
	
	if (ast_test_flag(&optflags, OPT_RESETDEST))
		newcdr->dstchannel[0] = 0;
	
	if (ast_test_flag(&optflags, OPT_ENDCDR))
		ast_cdr_end(cdr);

	if (ast_test_flag(&optflags, OPT_ANSLOCK))
		ast_set_flag(cdr, AST_CDR_FLAG_ANSLOCKED);
	
	if (ast_test_flag(&optflags, OPT_DONTOUCH))
		ast_set_flag(cdr, AST_CDR_FLAG_DONT_TOUCH);
		
	ast_set_flag(cdr, AST_CDR_FLAG_CHILD | AST_CDR_FLAG_LOCKED);
}

static int forkcdr_exec(struct ast_channel *chan, const char *data)
{
	int res = 0;
	char *argcopy = NULL;
	struct ast_flags flags = {0};
	char *opts[OPT_ARG_ARRAY_SIZE];
	AST_DECLARE_APP_ARGS(arglist,
		AST_APP_ARG(options);
	);

	if (!chan->cdr) {
		ast_log(LOG_WARNING, "Channel does not have a CDR\n");
		return 0;
	}

	argcopy = ast_strdupa(data);

	AST_STANDARD_APP_ARGS(arglist, argcopy);

	opts[OPT_ARG_VARSET] = 0;

	if (!ast_strlen_zero(arglist.options))
		ast_app_parse_options(forkcdr_exec_options, &flags, opts, arglist.options);

	if (!ast_strlen_zero(data)) {
		int keepvars = ast_test_flag(&flags, OPT_KEEPVARS) ? 1 : 0;
		ast_set2_flag(chan->cdr, keepvars, AST_CDR_FLAG_KEEP_VARS);
	}
	
	ast_cdr_fork(chan, flags, opts[OPT_ARG_VARSET]);

	return res;
}

static int unload_module(void)
{
	return ast_unregister_application(app);
}

static int load_module(void)
{
	return ast_register_application_xml(app, forkcdr_exec);
}

AST_MODULE_INFO_STANDARD(ASTERISK_GPL_KEY, "Fork The CDR into 2 separate entities");