bf5e6b126937cb0493001b7ff4b9232d498bcf77
[asterisk/asterisk.git] / channels / chan_local.c
1 /*
2  * Asterisk -- An open source telephony toolkit.
3  *
4  * Copyright (C) 1999 - 2005, Digium, Inc.
5  *
6  * Mark Spencer <markster@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 /*! \file
20  *
21  * \author Mark Spencer <markster@digium.com>
22  *
23  * \brief Local Proxy Channel
24  * 
25  * \ingroup channel_drivers
26  */
27
28 #include "asterisk.h"
29
30 ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
31
32 #include <fcntl.h>
33 #include <sys/signal.h>
34
35 #include "asterisk/lock.h"
36 #include "asterisk/channel.h"
37 #include "asterisk/config.h"
38 #include "asterisk/module.h"
39 #include "asterisk/pbx.h"
40 #include "asterisk/sched.h"
41 #include "asterisk/io.h"
42 #include "asterisk/acl.h"
43 #include "asterisk/callerid.h"
44 #include "asterisk/file.h"
45 #include "asterisk/cli.h"
46 #include "asterisk/app.h"
47 #include "asterisk/musiconhold.h"
48 #include "asterisk/manager.h"
49 #include "asterisk/stringfields.h"
50 #include "asterisk/devicestate.h"
51 #include "asterisk/astobj2.h"
52
53 /*** DOCUMENTATION
54         <manager name="LocalOptimizeAway" language="en_US">
55                 <synopsis>
56                         Optimize away a local channel when possible.
57                 </synopsis>
58                 <syntax>
59                         <xi:include xpointer="xpointer(/docs/manager[@name='Login']/syntax/parameter[@name='ActionID'])" />
60                         <parameter name="Channel" required="true">
61                                 <para>The channel name to optimize away.</para>
62                         </parameter>
63                 </syntax>
64                 <description>
65                         <para>A local channel created with "/n" will not automatically optimize away.
66                         Calling this command on the local channel will clear that flag and allow
67                         it to optimize away if it's bridged or when it becomes bridged.</para>
68                 </description>
69         </manager>
70  ***/
71
72 static const char tdesc[] = "Local Proxy Channel Driver";
73
74 #define IS_OUTBOUND(a,b) (a == b->chan ? 1 : 0)
75
76 /* right now we are treating the locals astobj2 container as a
77  * list.  If there is ever a reason to make this more efficient
78  * increasing the bucket size would help. */
79 static const int BUCKET_SIZE = 1;
80
81 static struct ao2_container *locals;
82
83 static struct ast_jb_conf g_jb_conf = {
84         .flags = 0,
85         .max_size = -1,
86         .resync_threshold = -1,
87         .impl = "",
88         .target_extra = -1,
89 };
90
91 static struct ast_channel *local_request(const char *type, struct ast_format_cap *cap, const struct ast_channel *requestor, void *data, int *cause);
92 static int local_digit_begin(struct ast_channel *ast, char digit);
93 static int local_digit_end(struct ast_channel *ast, char digit, unsigned int duration);
94 static int local_call(struct ast_channel *ast, char *dest, int timeout);
95 static int local_hangup(struct ast_channel *ast);
96 static int local_answer(struct ast_channel *ast);
97 static struct ast_frame *local_read(struct ast_channel *ast);
98 static int local_write(struct ast_channel *ast, struct ast_frame *f);
99 static int local_indicate(struct ast_channel *ast, int condition, const void *data, size_t datalen);
100 static int local_fixup(struct ast_channel *oldchan, struct ast_channel *newchan);
101 static int local_sendhtml(struct ast_channel *ast, int subclass, const char *data, int datalen);
102 static int local_sendtext(struct ast_channel *ast, const char *text);
103 static int local_devicestate(void *data);
104 static struct ast_channel *local_bridgedchannel(struct ast_channel *chan, struct ast_channel *bridge);
105 static int local_queryoption(struct ast_channel *ast, int option, void *data, int *datalen);
106 static int local_setoption(struct ast_channel *chan, int option, void *data, int datalen);
107
108 /* PBX interface structure for channel registration */
109 static struct ast_channel_tech local_tech = {
110         .type = "Local",
111         .description = tdesc,
112         .requester = local_request,
113         .send_digit_begin = local_digit_begin,
114         .send_digit_end = local_digit_end,
115         .call = local_call,
116         .hangup = local_hangup,
117         .answer = local_answer,
118         .read = local_read,
119         .write = local_write,
120         .write_video = local_write,
121         .exception = local_read,
122         .indicate = local_indicate,
123         .fixup = local_fixup,
124         .send_html = local_sendhtml,
125         .send_text = local_sendtext,
126         .devicestate = local_devicestate,
127         .bridged_channel = local_bridgedchannel,
128         .queryoption = local_queryoption,
129         .setoption = local_setoption,
130 };
131
132 /*! \brief the local pvt structure for all channels
133
134         The local channel pvt has two ast_chan objects - the "owner" and the "next channel", the outbound channel
135
136         ast_chan owner -> local_pvt -> ast_chan chan -> yet-another-pvt-depending-on-channel-type
137
138 */
139 struct local_pvt {
140         unsigned int flags;             /*!< Private flags */
141         char context[AST_MAX_CONTEXT];  /*!< Context to call */
142         char exten[AST_MAX_EXTENSION];  /*!< Extension to call */
143         struct ast_format_cap *reqcap;  /*!< Requested format capabilities */
144         struct ast_jb_conf jb_conf;     /*!< jitterbuffer configuration for this local channel */
145         struct ast_channel *owner;      /*!< Master Channel - Bridging happens here */
146         struct ast_channel *chan;       /*!< Outbound channel - PBX is run here */
147         struct ast_module_user *u_owner;/*!< reference to keep the module loaded while in use */
148         struct ast_module_user *u_chan; /*!< reference to keep the module loaded while in use */
149 };
150
151 #define LOCAL_ALREADY_MASQED  (1 << 0) /*!< Already masqueraded */
152 #define LOCAL_LAUNCHED_PBX    (1 << 1) /*!< PBX was launched */
153 #define LOCAL_NO_OPTIMIZATION (1 << 2) /*!< Do not optimize using masquerading */
154 #define LOCAL_BRIDGE          (1 << 3) /*!< Report back the "true" channel as being bridged to */
155 #define LOCAL_MOH_PASSTHRU    (1 << 4) /*!< Pass through music on hold start/stop frames */
156
157 static int local_setoption(struct ast_channel *chan, int option, void * data, int datalen)
158 {
159         int res;
160         struct local_pvt *p;
161         struct ast_channel *otherchan;
162         ast_chan_write_info_t *write_info;
163
164         if (option != AST_OPTION_CHANNEL_WRITE) {
165                 return -1;
166         }
167
168         write_info = data;
169
170         if (write_info->version != AST_CHAN_WRITE_INFO_T_VERSION) {
171                 ast_log(LOG_ERROR, "The chan_write_info_t type has changed, and this channel hasn't been updated!\n");
172                 return -1;
173         }
174
175
176 startover:
177         ast_channel_lock(chan);
178
179         p = chan->tech_pvt;
180         if (!p) {
181                 ast_channel_unlock(chan);
182                 ast_log(LOG_WARNING, "Could not update other side of %s, local_pvt went away.\n", chan->name);
183                 return -1;
184         }
185
186         while (ao2_trylock(p)) {
187                 ast_channel_unlock(chan);
188                 sched_yield();
189                 ast_channel_lock(chan);
190                 p = chan->tech_pvt;
191                 if (!p) {
192                         ast_channel_unlock(chan);
193                         ast_log(LOG_WARNING, "Could not update other side of %s, local_pvt went away.\n", chan->name);
194                         return -1;
195                 }
196         }
197
198         otherchan = (write_info->chan == p->owner) ? p->chan : p->owner;
199
200         if (!otherchan || otherchan == write_info->chan) {
201                 ao2_unlock(p);
202                 ast_channel_unlock(chan);
203                 ast_log(LOG_WARNING, "Could not update other side of %s, other side went away.\n", chan->name);
204                 return 0;
205         }
206
207         if (ast_channel_trylock(otherchan)) {
208                 ao2_unlock(p);
209                 ast_channel_unlock(chan);
210                 goto startover;
211         }
212
213         res = write_info->write_fn(otherchan, write_info->function, write_info->data, write_info->value);
214
215         ast_channel_unlock(otherchan);
216         ao2_unlock(p);
217         ast_channel_unlock(chan);
218
219         return res;
220 }
221
222 /*! \brief Adds devicestate to local channels */
223 static int local_devicestate(void *data)
224 {
225         char *exten = ast_strdupa(data);
226         char *context = NULL, *opts = NULL;
227         int res;
228         struct local_pvt *lp;
229         struct ao2_iterator it;
230
231         if (!(context = strchr(exten, '@'))) {
232                 ast_log(LOG_WARNING, "Someone used Local/%s somewhere without a @context. This is bad.\n", exten);
233                 return AST_DEVICE_INVALID;      
234         }
235
236         *context++ = '\0';
237
238         /* Strip options if they exist */
239         if ((opts = strchr(context, '/')))
240                 *opts = '\0';
241
242         ast_debug(3, "Checking if extension %s@%s exists (devicestate)\n", exten, context);
243
244         res = ast_exists_extension(NULL, context, exten, 1, NULL);
245         if (!res)               
246                 return AST_DEVICE_INVALID;
247         
248         res = AST_DEVICE_NOT_INUSE;
249
250         it = ao2_iterator_init(locals, 0);
251         while ((lp = ao2_iterator_next(&it))) {
252                 if (!strcmp(exten, lp->exten) && !strcmp(context, lp->context) && lp->owner) {
253                         res = AST_DEVICE_INUSE;
254                         ao2_ref(lp, -1);
255                         break;
256                 }
257                 ao2_ref(lp, -1);
258         }
259         ao2_iterator_destroy(&it);
260
261         return res;
262 }
263
264 /*! \brief Return the bridged channel of a Local channel */
265 static struct ast_channel *local_bridgedchannel(struct ast_channel *chan, struct ast_channel *bridge)
266 {
267         struct local_pvt *p = bridge->tech_pvt;
268         struct ast_channel *bridged = bridge;
269
270         if (!p) {
271                 ast_debug(1, "Asked for bridged channel on '%s'/'%s', returning <none>\n",
272                         chan->name, bridge->name);
273                 return NULL;
274         }
275
276         ao2_lock(p);
277
278         if (ast_test_flag(p, LOCAL_BRIDGE)) {
279                 /* Find the opposite channel */
280                 bridged = (bridge == p->owner ? p->chan : p->owner);
281                 
282                 /* Now see if the opposite channel is bridged to anything */
283                 if (!bridged) {
284                         bridged = bridge;
285                 } else if (bridged->_bridge) {
286                         bridged = bridged->_bridge;
287                 }
288         }
289
290         ao2_unlock(p);
291
292         return bridged;
293 }
294
295 static int local_queryoption(struct ast_channel *ast, int option, void *data, int *datalen)
296 {
297         struct local_pvt *p = ast->tech_pvt;
298         struct ast_channel *chan, *bridged;
299         int res;
300
301         if (!p) {
302                 return -1;
303         }
304
305         if (option != AST_OPTION_T38_STATE) {
306                 /* AST_OPTION_T38_STATE is the only supported option at this time */
307                 return -1;
308         }
309
310         ao2_lock(p);
311         chan = IS_OUTBOUND(ast, p) ? p->owner : p->chan;
312
313 try_again:
314         if (!chan) {
315                 ao2_unlock(p);
316                 return -1;
317         }
318
319         if (ast_channel_trylock(chan)) {
320                 ao2_unlock(p);
321                 sched_yield();
322                 ao2_lock(p);
323                 chan = IS_OUTBOUND(ast, p) ? p->owner : p->chan;
324                 goto try_again;
325         }
326
327         bridged = ast_bridged_channel(chan);
328         if (!bridged) {
329                 /* can't query channel unless we are bridged */
330                 ao2_unlock(p);
331                 ast_channel_unlock(chan);
332                 return -1;
333         }
334
335         if (ast_channel_trylock(bridged)) {
336                 ast_channel_unlock(chan);
337                 ao2_unlock(p);
338                 sched_yield();
339                 ao2_lock(p);
340                 chan = IS_OUTBOUND(ast, p) ? p->owner : p->chan;
341                 goto try_again;
342         }
343
344         res = ast_channel_queryoption(bridged, option, data, datalen, 0);
345         ao2_unlock(p);
346         ast_channel_unlock(chan);
347         ast_channel_unlock(bridged);
348         return res;
349 }
350
351 /*! \brief queue a frame on a to either the p->owner or p->chan
352  *
353  * \note the local_pvt MUST have it's ref count bumped before entering this function and
354  * decremented after this function is called.  This is a side effect of the deadlock
355  * avoidance that is necessary to lock 2 channels and a tech_pvt.  Without a ref counted
356  * local_pvt, it is impossible to guarantee it will not be destroyed by another thread
357  * during deadlock avoidance.
358  */
359 static int local_queue_frame(struct local_pvt *p, int isoutbound, struct ast_frame *f, 
360         struct ast_channel *us, int us_locked)
361 {
362         struct ast_channel *other = NULL;
363
364         /* Recalculate outbound channel */
365         other = isoutbound ? p->owner : p->chan;
366
367         if (!other) {
368                 return 0;
369         }
370
371         /* do not queue frame if generator is on both local channels */
372         if (us && us->generator && other->generator) {
373                 return 0;
374         }
375
376         /* Ensure that we have both channels locked */
377         while (other && ast_channel_trylock(other)) {
378                 int res;
379                 if ((res = ao2_unlock(p))) {
380                         ast_log(LOG_ERROR, "chan_local bug! '&p->lock' was not locked when entering local_queue_frame! (%s)\n", strerror(res));
381                         return -1;
382                 }
383                 if (us && us_locked) {
384                         do {
385                                 CHANNEL_DEADLOCK_AVOIDANCE(us);
386                         } while (ao2_trylock(p));
387                 } else {
388                         usleep(1);
389                         ao2_lock(p);
390                 }
391                 other = isoutbound ? p->owner : p->chan;
392         }
393
394         if (other) {
395                 if (f->frametype == AST_FRAME_CONTROL && f->subclass.integer == AST_CONTROL_RINGING) {
396                         ast_setstate(other, AST_STATE_RINGING);
397                 }
398                 ast_queue_frame(other, f);
399                 ast_channel_unlock(other);
400         }
401
402         return 0;
403 }
404
405 static int local_answer(struct ast_channel *ast)
406 {
407         struct local_pvt *p = ast->tech_pvt;
408         int isoutbound;
409         int res = -1;
410
411         if (!p)
412                 return -1;
413
414         ao2_lock(p);
415         ao2_ref(p, 1);
416         isoutbound = IS_OUTBOUND(ast, p);
417         if (isoutbound) {
418                 /* Pass along answer since somebody answered us */
419                 struct ast_frame answer = { AST_FRAME_CONTROL, { AST_CONTROL_ANSWER } };
420                 res = local_queue_frame(p, isoutbound, &answer, ast, 1);
421         } else {
422                 ast_log(LOG_WARNING, "Huh?  Local is being asked to answer?\n");
423         }
424         ao2_unlock(p);
425         ao2_ref(p, -1);
426         return res;
427 }
428
429 /*!
430  * \internal
431  * \note This function assumes that we're only called from the "outbound" local channel side
432  */
433 static void check_bridge(struct local_pvt *p)
434 {
435         struct ast_channel_monitor *tmp;
436         if (ast_test_flag(p, LOCAL_ALREADY_MASQED) || ast_test_flag(p, LOCAL_NO_OPTIMIZATION) || !p->chan || !p->owner || (p->chan->_bridge != ast_bridged_channel(p->chan)))
437                 return;
438
439         /* only do the masquerade if we are being called on the outbound channel,
440            if it has been bridged to another channel and if there are no pending
441            frames on the owner channel (because they would be transferred to the
442            outbound channel during the masquerade)
443         */
444         if (p->chan->_bridge /* Not ast_bridged_channel!  Only go one step! */ && AST_LIST_EMPTY(&p->owner->readq)) {
445                 /* Masquerade bridged channel into owner */
446                 /* Lock everything we need, one by one, and give up if
447                    we can't get everything.  Remember, we'll get another
448                    chance in just a little bit */
449                 if (!ast_channel_trylock(p->chan->_bridge)) {
450                         if (!ast_check_hangup(p->chan->_bridge)) {
451                                 if (!ast_channel_trylock(p->owner)) {
452                                         if (!ast_check_hangup(p->owner)) {
453                                                 if (p->owner->monitor && !p->chan->_bridge->monitor) {
454                                                         /* If a local channel is being monitored, we don't want a masquerade
455                                                          * to cause the monitor to go away. Since the masquerade swaps the monitors,
456                                                          * pre-swapping the monitors before the masquerade will ensure that the monitor
457                                                          * ends up where it is expected.
458                                                          */
459                                                         tmp = p->owner->monitor;
460                                                         p->owner->monitor = p->chan->_bridge->monitor;
461                                                         p->chan->_bridge->monitor = tmp;
462                                                 }
463                                                 if (p->chan->audiohooks) {
464                                                         struct ast_audiohook_list *audiohooks_swapper;
465                                                         audiohooks_swapper = p->chan->audiohooks;
466                                                         p->chan->audiohooks = p->owner->audiohooks;
467                                                         p->owner->audiohooks = audiohooks_swapper;
468                                                 }
469
470                                                 /* If any Caller ID was set, preserve it after masquerade like above. We must check
471                                                  * to see if Caller ID was set because otherwise we'll mistakingly copy info not
472                                                  * set from the dialplan and will overwrite the real channel Caller ID. The reason
473                                                  * for this whole preswapping action is because the Caller ID is set on the channel
474                                                  * thread (which is the to be masqueraded away local channel) before both local
475                                                  * channels are optimized away.
476                                                  */
477                                                 if (p->owner->caller.id.name.valid || p->owner->caller.id.number.valid
478                                                         || p->owner->caller.id.subaddress.valid || p->owner->caller.ani.name.valid
479                                                         || p->owner->caller.ani.number.valid || p->owner->caller.ani.subaddress.valid) {
480                                                         struct ast_party_caller tmp;
481                                                         tmp = p->owner->caller;
482                                                         p->owner->caller = p->chan->_bridge->caller;
483                                                         p->chan->_bridge->caller = tmp;
484                                                 }
485                                                 if (p->owner->redirecting.from.name.valid || p->owner->redirecting.from.number.valid
486                                                         || p->owner->redirecting.from.subaddress.valid || p->owner->redirecting.to.name.valid
487                                                         || p->owner->redirecting.to.number.valid || p->owner->redirecting.to.subaddress.valid) {
488                                                         struct ast_party_redirecting tmp;
489                                                         tmp = p->owner->redirecting;
490                                                         p->owner->redirecting = p->chan->_bridge->redirecting;
491                                                         p->chan->_bridge->redirecting = tmp;
492                                                 }
493                                                 if (p->owner->dialed.number.str || p->owner->dialed.subaddress.valid) {
494                                                         struct ast_party_dialed tmp;
495                                                         tmp = p->owner->dialed;
496                                                         p->owner->dialed = p->chan->_bridge->dialed;
497                                                         p->chan->_bridge->dialed = tmp;
498                                                 }
499
500
501                                                 ast_app_group_update(p->chan, p->owner);
502                                                 ast_channel_masquerade(p->owner, p->chan->_bridge);
503                                                 ast_set_flag(p, LOCAL_ALREADY_MASQED);
504                                         }
505                                         ast_channel_unlock(p->owner);
506                                 }
507                         }
508                         ast_channel_unlock(p->chan->_bridge);
509                 }
510         }
511 }
512
513 static struct ast_frame  *local_read(struct ast_channel *ast)
514 {
515         return &ast_null_frame;
516 }
517
518 static int local_write(struct ast_channel *ast, struct ast_frame *f)
519 {
520         struct local_pvt *p = ast->tech_pvt;
521         int res = -1;
522         int isoutbound;
523
524         if (!p)
525                 return -1;
526
527         /* Just queue for delivery to the other side */
528         ao2_lock(p);
529         ao2_ref(p, 1); /* ref for local_queue_frame */
530         isoutbound = IS_OUTBOUND(ast, p);
531         if (isoutbound && f && (f->frametype == AST_FRAME_VOICE || f->frametype == AST_FRAME_VIDEO))
532                 check_bridge(p);
533         if (!ast_test_flag(p, LOCAL_ALREADY_MASQED))
534                 res = local_queue_frame(p, isoutbound, f, ast, 1);
535         else {
536                 ast_debug(1, "Not posting to queue since already masked on '%s'\n", ast->name);
537                 res = 0;
538         }
539         ao2_unlock(p);
540         ao2_ref(p, -1);
541
542         return res;
543 }
544
545 static int local_fixup(struct ast_channel *oldchan, struct ast_channel *newchan)
546 {
547         struct local_pvt *p = newchan->tech_pvt;
548
549         if (!p)
550                 return -1;
551
552         ao2_lock(p);
553
554         if ((p->owner != oldchan) && (p->chan != oldchan)) {
555                 ast_log(LOG_WARNING, "Old channel wasn't %p but was %p/%p\n", oldchan, p->owner, p->chan);
556                 ao2_unlock(p);
557                 return -1;
558         }
559         if (p->owner == oldchan)
560                 p->owner = newchan;
561         else
562                 p->chan = newchan;
563
564         /* Do not let a masquerade cause a Local channel to be bridged to itself! */
565         if (!ast_check_hangup(newchan) && ((p->owner && p->owner->_bridge == p->chan) || (p->chan && p->chan->_bridge == p->owner))) {
566                 ast_log(LOG_WARNING, "You can not bridge a Local channel to itself!\n");
567                 ao2_unlock(p);
568                 ast_queue_hangup(newchan);
569                 return -1;
570         }
571
572         ao2_unlock(p);
573         return 0;
574 }
575
576 static int local_indicate(struct ast_channel *ast, int condition, const void *data, size_t datalen)
577 {
578         struct local_pvt *p = ast->tech_pvt;
579         int res = 0;
580         struct ast_frame f = { AST_FRAME_CONTROL, };
581         int isoutbound;
582
583         if (!p)
584                 return -1;
585
586         ao2_ref(p, 1); /* ref for local_queue_frame */
587
588         /* If this is an MOH hold or unhold, do it on the Local channel versus real channel */
589         if (!ast_test_flag(p, LOCAL_MOH_PASSTHRU) && condition == AST_CONTROL_HOLD) {
590                 ast_moh_start(ast, data, NULL);
591         } else if (!ast_test_flag(p, LOCAL_MOH_PASSTHRU) && condition == AST_CONTROL_UNHOLD) {
592                 ast_moh_stop(ast);
593         } else if (condition == AST_CONTROL_CONNECTED_LINE || condition == AST_CONTROL_REDIRECTING) {
594                 struct ast_channel *this_channel;
595                 struct ast_channel *the_other_channel;
596                 /* A connected line update frame may only contain a partial amount of data, such
597                  * as just a source, or just a ton, and not the full amount of information. However,
598                  * the collected information is all stored in the outgoing channel's connectedline
599                  * structure, so when receiving a connected line update on an outgoing local channel,
600                  * we need to transmit the collected connected line information instead of whatever
601                  * happens to be in this control frame. The same applies for redirecting information, which
602                  * is why it is handled here as well.*/
603                 ao2_lock(p);
604                 isoutbound = IS_OUTBOUND(ast, p);
605                 if (isoutbound) {
606                         this_channel = p->chan;
607                         the_other_channel = p->owner;
608                 } else {
609                         this_channel = p->owner;
610                         the_other_channel = p->chan;
611                 }
612                 if (the_other_channel) {
613                         unsigned char frame_data[1024];
614                         if (condition == AST_CONTROL_CONNECTED_LINE) {
615                                 if (isoutbound) {
616                                         ast_connected_line_copy_to_caller(&the_other_channel->caller, &this_channel->connected);
617                                 }
618                                 f.datalen = ast_connected_line_build_data(frame_data, sizeof(frame_data), &this_channel->connected, NULL);
619                         } else {
620                                 f.datalen = ast_redirecting_build_data(frame_data, sizeof(frame_data), &this_channel->redirecting, NULL);
621                         }
622                         f.subclass.integer = condition;
623                         f.data.ptr = frame_data;
624                         res = local_queue_frame(p, isoutbound, &f, ast, 1);
625                 }
626                 ao2_unlock(p);
627         } else {
628                 /* Queue up a frame representing the indication as a control frame */
629                 ao2_lock(p);
630                 isoutbound = IS_OUTBOUND(ast, p);
631                 f.subclass.integer = condition;
632                 f.data.ptr = (void*)data;
633                 f.datalen = datalen;
634                 res = local_queue_frame(p, isoutbound, &f, ast, 1);
635                 ao2_unlock(p);
636         }
637
638         ao2_ref(p, -1);
639         return res;
640 }
641
642 static int local_digit_begin(struct ast_channel *ast, char digit)
643 {
644         struct local_pvt *p = ast->tech_pvt;
645         int res = -1;
646         struct ast_frame f = { AST_FRAME_DTMF_BEGIN, };
647         int isoutbound;
648
649         if (!p)
650                 return -1;
651
652         ao2_ref(p, 1); /* ref for local_queue_frame */
653         ao2_lock(p);
654         isoutbound = IS_OUTBOUND(ast, p);
655         f.subclass.integer = digit;
656         res = local_queue_frame(p, isoutbound, &f, ast, 0);
657         ao2_unlock(p);
658         ao2_ref(p, -1);
659
660         return res;
661 }
662
663 static int local_digit_end(struct ast_channel *ast, char digit, unsigned int duration)
664 {
665         struct local_pvt *p = ast->tech_pvt;
666         int res = -1;
667         struct ast_frame f = { AST_FRAME_DTMF_END, };
668         int isoutbound;
669
670         if (!p)
671                 return -1;
672
673         ao2_ref(p, 1); /* ref for local_queue_frame */
674         ao2_lock(p);
675         isoutbound = IS_OUTBOUND(ast, p);
676         f.subclass.integer = digit;
677         f.len = duration;
678         res = local_queue_frame(p, isoutbound, &f, ast, 0);
679         ao2_unlock(p);
680         ao2_ref(p, -1);
681
682         return res;
683 }
684
685 static int local_sendtext(struct ast_channel *ast, const char *text)
686 {
687         struct local_pvt *p = ast->tech_pvt;
688         int res = -1;
689         struct ast_frame f = { AST_FRAME_TEXT, };
690         int isoutbound;
691
692         if (!p)
693                 return -1;
694
695         ao2_lock(p);
696         ao2_ref(p, 1); /* ref for local_queue_frame */
697         isoutbound = IS_OUTBOUND(ast, p);
698         f.data.ptr = (char *) text;
699         f.datalen = strlen(text) + 1;
700         res = local_queue_frame(p, isoutbound, &f, ast, 0);
701         ao2_unlock(p);
702         ao2_ref(p, -1);
703         return res;
704 }
705
706 static int local_sendhtml(struct ast_channel *ast, int subclass, const char *data, int datalen)
707 {
708         struct local_pvt *p = ast->tech_pvt;
709         int res = -1;
710         struct ast_frame f = { AST_FRAME_HTML, };
711         int isoutbound;
712
713         if (!p)
714                 return -1;
715
716         ao2_lock(p);
717         ao2_ref(p, 1); /* ref for local_queue_frame */
718         isoutbound = IS_OUTBOUND(ast, p);
719         f.subclass.integer = subclass;
720         f.data.ptr = (char *)data;
721         f.datalen = datalen;
722         res = local_queue_frame(p, isoutbound, &f, ast, 0);
723         ao2_unlock(p);
724         ao2_ref(p, -1);
725
726         return res;
727 }
728
729 /*! \brief Initiate new call, part of PBX interface 
730  *      dest is the dial string */
731 static int local_call(struct ast_channel *ast, char *dest, int timeout)
732 {
733         struct local_pvt *p = ast->tech_pvt;
734         int res;
735         struct ast_var_t *varptr = NULL, *new;
736         size_t len, namelen;
737         char *reduced_dest = ast_strdupa(dest);
738         char *slash;
739         struct ast_channel *chan;
740         const char *exten;
741         const char *context;
742
743         if (!p || p->owner != ast) {
744                 return -1;
745         }
746
747         /* since we are letting go of channel locks that were locked coming into
748          * this function, then we need to give the tech pvt a ref */
749         ao2_ref(p, 1);
750
751         while (ao2_trylock(p)) {
752                 ast_channel_unlock(ast);
753                 sched_yield();
754                 ast_channel_lock(ast);
755         }
756         while ((p->chan && p->owner) && ast_channel_trylock(p->chan)) {
757                 ao2_unlock(p);
758                 if (p->owner) {
759                         ast_channel_unlock(p->owner);
760                 }
761                 sched_yield();
762                 if (p->owner) {
763                         ast_channel_lock(p->owner);
764                 }
765                 ao2_lock(p);
766         }
767
768         if (!p->owner || !p->chan) {
769                 /* someone went away during the locking madness.
770                  * time to bail. */
771                 if (p->chan) {
772                         ast_channel_unlock(p->chan);
773                 }
774                 ao2_unlock(p);
775                 ao2_ref(p,-1);
776                 return -1;
777         }
778
779         /*
780          * Note that cid_num and cid_name aren't passed in the ast_channel_alloc
781          * call, so it's done here instead.
782          *
783          * All these failure points just return -1. The individual strings will
784          * be cleared when we destroy the channel.
785          */
786         ast_party_redirecting_copy(&p->chan->redirecting, &p->owner->redirecting);
787
788         ast_party_dialed_copy(&p->chan->dialed, &p->owner->dialed);
789
790         ast_connected_line_copy_to_caller(&p->chan->caller, &p->owner->connected);
791         ast_connected_line_copy_from_caller(&p->chan->connected, &p->owner->caller);
792
793         ast_string_field_set(p->chan, language, p->owner->language);
794         ast_string_field_set(p->chan, accountcode, p->owner->accountcode);
795         ast_string_field_set(p->chan, musicclass, p->owner->musicclass);
796         ast_cdr_update(p->chan);
797
798         ast_channel_cc_params_init(p->chan, ast_channel_get_cc_config_params(p->owner));
799
800         /* Make sure we inherit the ANSWERED_ELSEWHERE flag if it's set on the queue/dial call request in the dialplan */
801         if (ast_test_flag(ast, AST_FLAG_ANSWERED_ELSEWHERE)) {
802                 ast_set_flag(p->chan, AST_FLAG_ANSWERED_ELSEWHERE);
803         }
804
805         /* copy the channel variables from the incoming channel to the outgoing channel */
806         /* Note that due to certain assumptions, they MUST be in the same order */
807         AST_LIST_TRAVERSE(&p->owner->varshead, varptr, entries) {
808                 namelen = strlen(varptr->name);
809                 len = sizeof(struct ast_var_t) + namelen + strlen(varptr->value) + 2;
810                 if ((new = ast_calloc(1, len))) {
811                         memcpy(new, varptr, len);
812                         new->value = &(new->name[0]) + namelen + 1;
813                         AST_LIST_INSERT_TAIL(&p->chan->varshead, new, entries);
814                 }
815         }
816         ast_channel_datastore_inherit(p->owner, p->chan);
817         /* If the local channel has /n or /b on the end of it,
818          * we need to lop that off for our argument to setting
819          * up the CC_INTERFACES variable
820          */
821         if ((slash = strrchr(reduced_dest, '/'))) {
822                 *slash = '\0';
823         }
824         ast_set_cc_interfaces_chanvar(p->chan, reduced_dest);
825
826         chan = ast_channel_ref(p->chan);
827         ao2_unlock(p);
828         exten = ast_strdupa(chan->exten);
829         context = ast_strdupa(chan->context);
830         ast_channel_unlock(chan);
831
832         if (!ast_exists_extension(chan, context, exten, 1,
833                 S_COR(p->owner->caller.id.number.valid, p->owner->caller.id.number.str, NULL))) {
834                 ast_log(LOG_NOTICE, "No such extension/context %s@%s while calling Local channel\n", exten, context);
835                 res = -1;
836                 goto return_cleanup;
837         }
838
839         /* Start switch on sub channel */
840         if (!(res = ast_pbx_start(chan))) {
841                 ao2_lock(p);
842                 ast_set_flag(p, LOCAL_LAUNCHED_PBX);
843                 ao2_unlock(p);
844         }
845
846 return_cleanup:
847         ast_channel_unref(chan);
848         ao2_ref(p, -1);
849         return res;
850 }
851
852 /*! \brief Hangup a call through the local proxy channel */
853 static int local_hangup(struct ast_channel *ast)
854 {
855         struct local_pvt *p = ast->tech_pvt;
856         int isoutbound;
857         struct ast_frame f = { AST_FRAME_CONTROL, { AST_CONTROL_HANGUP }, .data.uint32 = ast->hangupcause };
858         struct ast_channel *ochan = NULL;
859
860         if (!p)
861                 return -1;
862
863         /* we MUST give the tech_pvt a ref here since we are unlocking the
864          * channel during deadlock avoidance. */
865         ao2_ref(p, 1);
866
867         ao2_lock(p);
868
869         isoutbound = IS_OUTBOUND(ast, p);
870
871         if (p->chan && ast_test_flag(ast, AST_FLAG_ANSWERED_ELSEWHERE)) {
872                 ast_set_flag(p->chan, AST_FLAG_ANSWERED_ELSEWHERE);
873                 ast_debug(2, "This local call has the ANSWERED_ELSEWHERE flag set.\n");
874         }
875
876         if (isoutbound) {
877                 const char *status = pbx_builtin_getvar_helper(p->chan, "DIALSTATUS");
878                 if ((status) && (p->owner)) {
879                         /* Deadlock avoidance */
880                         while (p->owner && ast_channel_trylock(p->owner)) {
881                                 ao2_unlock(p);
882                                 if (p->chan) {
883                                         ast_channel_unlock(p->chan);
884                                 }
885                                 sched_yield();
886                                 if (p->chan) {
887                                         ast_channel_lock(p->chan);
888                                 }
889                                 ao2_lock(p);
890                         }
891                         if (p->owner) {
892                                 p->owner->hangupcause = p->chan->hangupcause;
893                                 pbx_builtin_setvar_helper(p->owner, "CHANLOCALSTATUS", status);
894                                 ast_channel_unlock(p->owner);
895                         }
896                 }
897                 if (!p->chan) {
898                         /* chan was == to ast and was !NULL before deadlock avoidance started, if chan
899                          * is NULL now, then we should bail because that channel
900                          * hungup already. This is possible because we let go of the
901                          * lock given to the ast channel passed to this function during
902                          * deadlock avoidance. */
903                         ao2_unlock(p);
904                         ao2_ref(p, -1);
905                         return 0;
906                 }
907                 p->chan = NULL;
908                 ast_clear_flag(p, LOCAL_LAUNCHED_PBX);
909                 ast_module_user_remove(p->u_chan);
910         } else {
911                 ast_module_user_remove(p->u_owner);
912                 while (p->chan && ast_channel_trylock(p->chan)) {
913                                 ao2_unlock(p);
914                                 if (p->owner) {
915                                         ast_channel_unlock(p->owner);
916                                 }
917                                 sched_yield();
918                                 if (p->owner) {
919                                         ast_channel_lock(p->owner);
920                                 }
921                                 ao2_lock(p);
922                 }
923                 if (p->chan) {
924                         ast_queue_hangup(p->chan);
925                         ast_channel_unlock(p->chan);
926                 }
927
928                 if (!p->owner) {
929                         /* owner was == to ast and was !NULL before deadlock avoidance started, if
930                          * owner is NULL now, then we should bail because that channel
931                          * hungup already. This is possible because we let go of the
932                          * lock given to the ast channel passed to this function during
933                          * deadlock avoidance. */
934                         ao2_unlock(p);
935                         ao2_ref(p, -1);
936                         return 0;
937                 }
938                 p->owner = NULL;
939         }
940
941         ast->tech_pvt = NULL;
942
943         if (!p->owner && !p->chan) {
944                 ao2_unlock(p);
945
946                 /* Remove from list */
947                 ao2_unlink(locals, p);
948                 ao2_ref(p, -1);
949                 return 0;
950         }
951         if (p->chan && !ast_test_flag(p, LOCAL_LAUNCHED_PBX)) {
952                 /* Need to actually hangup since there is no PBX */
953                 ochan = p->chan;
954         } else {
955                 local_queue_frame(p, isoutbound, &f, NULL, 1);
956         }
957
958         ao2_unlock(p);
959         if (ochan) {
960                 ast_hangup(ochan);
961         }
962
963         ao2_ref(p, -1);
964         return 0;
965 }
966
967 static void local_destroy(void *obj)
968 {
969         struct local_pvt *pvt = obj;
970         pvt->reqcap = ast_format_cap_destroy(pvt->reqcap);
971 }
972
973 /*! \brief Create a call structure */
974 static struct local_pvt *local_alloc(const char *data, struct ast_format_cap *cap)
975 {
976         struct local_pvt *tmp = NULL;
977         char *c = NULL, *opts = NULL;
978
979         if (!(tmp = ao2_alloc(sizeof(*tmp), local_destroy))) {
980                 return NULL;
981         }
982         if (!(tmp->reqcap = ast_format_cap_dup(cap))) {
983                 ao2_ref(tmp, -1);
984                 return NULL;
985         }
986
987         /* Initialize private structure information */
988         ast_copy_string(tmp->exten, data, sizeof(tmp->exten));
989
990         memcpy(&tmp->jb_conf, &g_jb_conf, sizeof(tmp->jb_conf));
991
992         /* Look for options */
993         if ((opts = strchr(tmp->exten, '/'))) {
994                 *opts++ = '\0';
995                 if (strchr(opts, 'n'))
996                         ast_set_flag(tmp, LOCAL_NO_OPTIMIZATION);
997                 if (strchr(opts, 'j')) {
998                         if (ast_test_flag(tmp, LOCAL_NO_OPTIMIZATION))
999                                 ast_set_flag(&tmp->jb_conf, AST_JB_ENABLED);
1000                         else {
1001                                 ast_log(LOG_ERROR, "You must use the 'n' option for chan_local "
1002                                         "to use the 'j' option to enable the jitterbuffer\n");
1003                         }
1004                 }
1005                 if (strchr(opts, 'b')) {
1006                         ast_set_flag(tmp, LOCAL_BRIDGE);
1007                 }
1008                 if (strchr(opts, 'm')) {
1009                         ast_set_flag(tmp, LOCAL_MOH_PASSTHRU);
1010                 }
1011         }
1012
1013         /* Look for a context */
1014         if ((c = strchr(tmp->exten, '@')))
1015                 *c++ = '\0';
1016
1017         ast_copy_string(tmp->context, c ? c : "default", sizeof(tmp->context));
1018 #if 0
1019         /* We can't do this check here, because we don't know the CallerID yet, and
1020          * the CallerID could potentially affect what step is actually taken (or
1021          * even if that step exists). */
1022         if (!ast_exists_extension(NULL, tmp->context, tmp->exten, 1, NULL)) {
1023                 ast_log(LOG_NOTICE, "No such extension/context %s@%s creating local channel\n", tmp->exten, tmp->context);
1024                 tmp = local_pvt_destroy(tmp);
1025         } else {
1026 #endif
1027                 /* Add to list */
1028                 ao2_link(locals, tmp);
1029 #if 0
1030         }
1031 #endif
1032         return tmp; /* this is returned with a ref */
1033 }
1034
1035 /*! \brief Start new local channel */
1036 static struct ast_channel *local_new(struct local_pvt *p, int state, const char *linkedid)
1037 {
1038         struct ast_channel *tmp = NULL, *tmp2 = NULL;
1039         int randnum = ast_random() & 0xffff;
1040         struct ast_format fmt;
1041         const char *t;
1042         int ama;
1043
1044         /* Allocate two new Asterisk channels */
1045         /* safe accountcode */
1046         if (p->owner && p->owner->accountcode)
1047                 t = p->owner->accountcode;
1048         else
1049                 t = "";
1050
1051         if (p->owner)
1052                 ama = p->owner->amaflags;
1053         else
1054                 ama = 0;
1055         if (!(tmp = ast_channel_alloc(1, state, 0, 0, t, p->exten, p->context, linkedid, ama, "Local/%s@%s-%04x;1", p->exten, p->context, randnum)) 
1056                 || !(tmp2 = ast_channel_alloc(1, AST_STATE_RING, 0, 0, t, p->exten, p->context, linkedid, ama, "Local/%s@%s-%04x;2", p->exten, p->context, randnum))) {
1057                 if (tmp) {
1058                         tmp = ast_channel_release(tmp);
1059                 }
1060                 ast_log(LOG_WARNING, "Unable to allocate channel structure(s)\n");
1061                 return NULL;
1062         }
1063
1064         tmp2->tech = tmp->tech = &local_tech;
1065
1066         ast_format_cap_copy(tmp->nativeformats, p->reqcap);
1067         ast_format_cap_copy(tmp2->nativeformats, p->reqcap);
1068
1069         /* Determine our read/write format and set it on each channel */
1070         ast_best_codec(p->reqcap, &fmt);
1071         ast_format_copy(&tmp->writeformat, &fmt);
1072         ast_format_copy(&tmp2->writeformat, &fmt);
1073         ast_format_copy(&tmp->rawwriteformat, &fmt);
1074         ast_format_copy(&tmp2->rawwriteformat, &fmt);
1075         ast_format_copy(&tmp->readformat, &fmt);
1076         ast_format_copy(&tmp2->readformat, &fmt);
1077         ast_format_copy(&tmp->rawreadformat, &fmt);
1078         ast_format_copy(&tmp2->rawreadformat, &fmt);
1079
1080         tmp->tech_pvt = p;
1081         tmp2->tech_pvt = p;
1082
1083         p->owner = tmp;
1084         p->chan = tmp2;
1085         p->u_owner = ast_module_user_add(p->owner);
1086         p->u_chan = ast_module_user_add(p->chan);
1087
1088         ast_copy_string(tmp->context, p->context, sizeof(tmp->context));
1089         ast_copy_string(tmp2->context, p->context, sizeof(tmp2->context));
1090         ast_copy_string(tmp2->exten, p->exten, sizeof(tmp->exten));
1091         tmp->priority = 1;
1092         tmp2->priority = 1;
1093
1094         ast_jb_configure(tmp, &p->jb_conf);
1095
1096         return tmp;
1097 }
1098
1099 /*! \brief Part of PBX interface */
1100 static struct ast_channel *local_request(const char *type, struct ast_format_cap *cap, const struct ast_channel *requestor, void *data, int *cause)
1101 {
1102         struct local_pvt *p = NULL;
1103         struct ast_channel *chan = NULL;
1104
1105         /* Allocate a new private structure and then Asterisk channel */
1106         if ((p = local_alloc(data, cap))) {
1107                 if (!(chan = local_new(p, AST_STATE_DOWN, requestor ? requestor->linkedid : NULL))) {
1108                         ao2_unlink(locals, p);
1109                 }
1110                 if (chan && ast_channel_cc_params_init(chan, requestor ? ast_channel_get_cc_config_params((struct ast_channel *)requestor) : NULL)) {
1111                         chan = ast_channel_release(chan);
1112                         ao2_unlink(locals, p);
1113                 }
1114                 ao2_ref(p, -1); /* kill the ref from the alloc */
1115         }
1116
1117         return chan;
1118 }
1119
1120 /*! \brief CLI command "local show channels" */
1121 static char *locals_show(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
1122 {
1123         struct local_pvt *p = NULL;
1124         struct ao2_iterator it;
1125
1126         switch (cmd) {
1127         case CLI_INIT:
1128                 e->command = "local show channels";
1129                 e->usage =
1130                         "Usage: local show channels\n"
1131                         "       Provides summary information on active local proxy channels.\n";
1132                 return NULL;
1133         case CLI_GENERATE:
1134                 return NULL;
1135         }
1136
1137         if (a->argc != 3)
1138                 return CLI_SHOWUSAGE;
1139
1140         if (ao2_container_count(locals) == 0) {
1141                 ast_cli(a->fd, "No local channels in use\n");
1142                 return RESULT_SUCCESS;
1143         }
1144
1145         it = ao2_iterator_init(locals, 0);
1146         while ((p = ao2_iterator_next(&it))) {
1147                 ao2_lock(p);
1148                 ast_cli(a->fd, "%s -- %s@%s\n", p->owner ? p->owner->name : "<unowned>", p->exten, p->context);
1149                 ao2_unlock(p);
1150                 ao2_ref(p, -1);
1151         }
1152         ao2_iterator_destroy(&it);
1153
1154         return CLI_SUCCESS;
1155 }
1156
1157 static struct ast_cli_entry cli_local[] = {
1158         AST_CLI_DEFINE(locals_show, "List status of local channels"),
1159 };
1160
1161 static int manager_optimize_away(struct mansession *s, const struct message *m)
1162 {
1163         const char *channel;
1164         struct local_pvt *p, *tmp = NULL;
1165         struct ast_channel *c;
1166         int found = 0;
1167         struct ao2_iterator it;
1168
1169         channel = astman_get_header(m, "Channel");
1170
1171         if (ast_strlen_zero(channel)) {
1172                 astman_send_error(s, m, "'Channel' not specified.");
1173                 return 0;
1174         }
1175
1176         c = ast_channel_get_by_name(channel);
1177         if (!c) {
1178                 astman_send_error(s, m, "Channel does not exist.");
1179                 return 0;
1180         }
1181
1182         p = c->tech_pvt;
1183         ast_channel_unref(c);
1184         c = NULL;
1185
1186         it = ao2_iterator_init(locals, 0);
1187         while ((tmp = ao2_iterator_next(&it))) {
1188                 if (tmp == p) {
1189                         ao2_lock(tmp);
1190                         found = 1;
1191                         ast_clear_flag(tmp, LOCAL_NO_OPTIMIZATION);
1192                         ao2_unlock(tmp);
1193                         ao2_ref(tmp, -1);
1194                         break;
1195                 }
1196                 ao2_ref(tmp, -1);
1197         }
1198         ao2_iterator_destroy(&it);
1199
1200         if (found) {
1201                 astman_send_ack(s, m, "Queued channel to be optimized away");
1202         } else {
1203                 astman_send_error(s, m, "Unable to find channel");
1204         }
1205
1206         return 0;
1207 }
1208
1209
1210 static int locals_cmp_cb(void *obj, void *arg, int flags)
1211 {
1212         return (obj == arg) ? CMP_MATCH : 0;
1213 }
1214
1215 /*! \brief Load module into PBX, register channel */
1216 static int load_module(void)
1217 {
1218         if (!(local_tech.capabilities = ast_format_cap_alloc())) {
1219                 return AST_MODULE_LOAD_FAILURE;
1220         }
1221         ast_format_cap_add_all(local_tech.capabilities);
1222
1223         if (!(locals = ao2_container_alloc(BUCKET_SIZE, NULL, locals_cmp_cb))) {
1224                 ast_format_cap_destroy(local_tech.capabilities);
1225                 return AST_MODULE_LOAD_FAILURE;
1226         }
1227
1228         /* Make sure we can register our channel type */
1229         if (ast_channel_register(&local_tech)) {
1230                 ast_log(LOG_ERROR, "Unable to register channel class 'Local'\n");
1231                 ao2_ref(locals, -1);
1232                 ast_format_cap_destroy(local_tech.capabilities);
1233                 return AST_MODULE_LOAD_FAILURE;
1234         }
1235         ast_cli_register_multiple(cli_local, sizeof(cli_local) / sizeof(struct ast_cli_entry));
1236         ast_manager_register_xml("LocalOptimizeAway", EVENT_FLAG_SYSTEM|EVENT_FLAG_CALL, manager_optimize_away);
1237
1238         return AST_MODULE_LOAD_SUCCESS;
1239 }
1240
1241 /*! \brief Unload the local proxy channel from Asterisk */
1242 static int unload_module(void)
1243 {
1244         struct local_pvt *p = NULL;
1245         struct ao2_iterator it;
1246
1247         /* First, take us out of the channel loop */
1248         ast_cli_unregister_multiple(cli_local, sizeof(cli_local) / sizeof(struct ast_cli_entry));
1249         ast_manager_unregister("LocalOptimizeAway");
1250         ast_channel_unregister(&local_tech);
1251
1252         it = ao2_iterator_init(locals, 0);
1253         while ((p = ao2_iterator_next(&it))) {
1254                 if (p->owner) {
1255                         ast_softhangup(p->owner, AST_SOFTHANGUP_APPUNLOAD);
1256                 }
1257                 ao2_ref(p, -1);
1258         }
1259         ao2_iterator_destroy(&it);
1260         ao2_ref(locals, -1);
1261
1262         ast_format_cap_destroy(local_tech.capabilities);
1263         return 0;
1264 }
1265
1266 AST_MODULE_INFO(ASTERISK_GPL_KEY, AST_MODFLAG_LOAD_ORDER, "Local Proxy Channel (Note: used internally by other modules)",
1267                 .load = load_module,
1268                 .unload = unload_module,
1269                 .load_pri = AST_MODPRI_CHANNEL_DRIVER,
1270         );