61dc7c25f6e5cb6c696107a91fc2ac417d9c610d
[asterisk/asterisk.git] / channels / chan_h323.c
1 /*
2  * Asterisk -- An open source telephony toolkit.
3  *
4  * Copyright (C) 1999 - 2005
5  *
6  * OpenH323 Channel Driver for ASTERISK PBX.
7  *                      By Jeremy McNamara
8  *                      For The NuFone Network
9  *
10  * chan_h323 has been derived from code created by
11  *               Michael Manousos and Mark Spencer
12  *
13  * See http://www.asterisk.org for more information about
14  * the Asterisk project. Please do not directly contact
15  * any of the maintainers of this project for assistance;
16  * the project provides a web site, mailing lists and IRC
17  * channels for your use.
18  *
19  * This program is free software, distributed under the terms of
20  * the GNU General Public License Version 2. See the LICENSE file
21  * at the top of the source tree.
22  */
23
24 /*! \file
25  *
26  * \brief This file is part of the chan_h323 driver for Asterisk
27  *
28  * \author Jeremy McNamara
29  *
30  * \par See also
31  * \arg Config_h323
32  * \extref OpenH323 http://www.voxgratia.org/
33  *
34  * \ingroup channel_drivers
35  */
36
37 /*** MODULEINFO
38         <depend>openh323</depend>
39         <defaultenabled>yes</defaultenabled>
40  ***/
41
42 #ifdef __cplusplus
43 extern "C" {
44 #endif
45
46 #include "asterisk.h"
47
48 ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
49
50 #ifdef __cplusplus
51 }
52 #endif
53
54 #include <sys/types.h>
55 #include <sys/socket.h>
56 #include <sys/signal.h>
57 #include <sys/param.h>
58 #include <arpa/inet.h>
59 #include <net/if.h>
60 #include <netinet/in.h>
61 #include <netinet/in_systm.h>
62 #include <netinet/ip.h>
63 #include <netdb.h>
64 #include <fcntl.h>
65
66 #ifdef __cplusplus
67 extern "C" {
68 #endif
69
70 #include "asterisk/lock.h"
71 #include "asterisk/channel.h"
72 #include "asterisk/config.h"
73 #include "asterisk/module.h"
74 #include "asterisk/musiconhold.h"
75 #include "asterisk/pbx.h"
76 #include "asterisk/utils.h"
77 #include "asterisk/sched.h"
78 #include "asterisk/io.h"
79 #include "asterisk/rtp.h"
80 #include "asterisk/acl.h"
81 #include "asterisk/callerid.h"
82 #include "asterisk/cli.h"
83 #include "asterisk/dsp.h"
84 #include "asterisk/causes.h"
85 #include "asterisk/stringfields.h"
86 #include "asterisk/abstract_jb.h"
87 #include "asterisk/astobj.h"
88
89 #ifdef __cplusplus
90 }
91 #endif
92
93 #include "h323/chan_h323.h"
94
95 receive_digit_cb on_receive_digit;
96 on_rtp_cb on_external_rtp_create;
97 start_rtp_cb on_start_rtp_channel;
98 setup_incoming_cb on_incoming_call;
99 setup_outbound_cb on_outgoing_call;
100 chan_ringing_cb on_chan_ringing;
101 con_established_cb on_connection_established;
102 clear_con_cb on_connection_cleared;
103 answer_call_cb on_answer_call;
104 progress_cb on_progress;
105 rfc2833_cb on_set_rfc2833_payload;
106 hangup_cb on_hangup;
107 setcapabilities_cb on_setcapabilities;
108 setpeercapabilities_cb on_setpeercapabilities;
109 onhold_cb on_hold;
110
111 int h323debug; /*!< global debug flag */
112
113 /*! \brief Global jitterbuffer configuration - by default, jb is disabled */
114 static struct ast_jb_conf default_jbconf =
115 {
116         .flags = 0,
117         .max_size = -1,
118         .resync_threshold = -1,
119         .impl = ""
120 };
121 static struct ast_jb_conf global_jbconf;
122
123 /** Variables required by Asterisk */
124 static const char tdesc[] = "The NuFone Network's Open H.323 Channel Driver";
125 static const char config[] = "h323.conf";
126 static char default_context[AST_MAX_CONTEXT] = "default";
127 static struct sockaddr_in bindaddr;
128
129 #define GLOBAL_CAPABILITY (AST_FORMAT_G723_1 | AST_FORMAT_GSM | AST_FORMAT_ULAW | AST_FORMAT_ALAW | AST_FORMAT_G729A | AST_FORMAT_G726_AAL2 | AST_FORMAT_H261)
130
131 /** H.323 configuration values */
132 static int h323_signalling_port = 1720;
133 static char gatekeeper[100];
134 static int gatekeeper_disable = 1;
135 static int gatekeeper_discover = 0;
136 static int gkroute = 0;
137 /* Find user by alias (h.323 id) is default, alternative is the incomming call's source IP address*/
138 static int userbyalias = 1;
139 static int acceptAnonymous = 1;
140 static unsigned int tos = 0;
141 static unsigned int cos = 0;
142 static char secret[50];
143 static unsigned int unique = 0;
144
145 static call_options_t global_options;
146
147 /*! \brief Private structure of a OpenH323 channel */
148 struct oh323_pvt {
149         ast_mutex_t lock;                       /*!< Channel private lock */
150         call_options_t options;                 /*!<!< Options to be used during call setup */
151         int alreadygone;                        /*!< Whether or not we've already been destroyed by our peer */
152         int needdestroy;                        /*!< if we need to be destroyed */
153         call_details_t cd;                      /*!< Call details */
154         struct ast_channel *owner;              /*!< Who owns us */
155         struct sockaddr_in sa;                  /*!< Our peer */
156         struct sockaddr_in redirip;             /*!< Where our RTP should be going if not to us */
157         int nonCodecCapability;                 /*!< non-audio capability */
158         int outgoing;                           /*!< Outgoing or incoming call? */
159         char exten[AST_MAX_EXTENSION];          /*!< Requested extension */
160         char context[AST_MAX_CONTEXT];          /*!< Context where to start */
161         char accountcode[256];                  /*!< Account code */
162         char rdnis[80];                         /*!< Referring DNIS, if available */
163         int amaflags;                           /*!< AMA Flags */
164         struct ast_rtp *rtp;                    /*!< RTP Session */
165         struct ast_dsp *vad;                    /*!< Used for in-band DTMF detection */
166         int nativeformats;                      /*!< Codec formats supported by a channel */
167         int needhangup;                         /*!< Send hangup when Asterisk is ready */
168         int hangupcause;                        /*!< Hangup cause from OpenH323 layer */
169         int newstate;                           /*!< Pending state change */
170         int newcontrol;                         /*!< Pending control to send */
171         int newdigit;                           /*!< Pending DTMF digit to send */
172         int newduration;                        /*!< Pending DTMF digit duration to send */
173         int pref_codec;                         /*!< Preferred codec */
174         int peercapability;                     /*!< Capabilities learned from peer */
175         int jointcapability;                    /*!< Common capabilities for local and remote side */
176         struct ast_codec_pref peer_prefs;       /*!< Preferenced list of codecs which remote side supports */
177         int dtmf_pt[2];                         /*!< Payload code used for RFC2833/CISCO messages */
178         int curDTMF;                            /*!< DTMF tone being generated to Asterisk side */
179         int DTMFsched;                          /*!< Scheduler descriptor for DTMF */
180         int update_rtp_info;                    /*!< Configuration of fd's array is pending */
181         int recvonly;                           /*!< Peer isn't wish to receive our voice stream */
182         int txDtmfDigit;                        /*!< DTMF digit being to send to H.323 side */
183         int noInbandDtmf;                       /*!< Inband DTMF processing by DSP isn't available */
184         int connection_established;             /*!< Call got CONNECT message */
185         int got_progress;                       /*!< Call got PROGRESS message, pass inband audio */
186         struct oh323_pvt *next;                 /*!< Next channel in list */
187 } *iflist = NULL;
188
189 /*! \brief H323 User list */
190 static struct h323_user_list {
191         ASTOBJ_CONTAINER_COMPONENTS(struct oh323_user);
192 } userl;
193
194 /*! \brief H323 peer list */
195 static struct h323_peer_list {
196         ASTOBJ_CONTAINER_COMPONENTS(struct oh323_peer);
197 } peerl;
198
199 /*! \brief H323 alias list */
200 static struct h323_alias_list {
201         ASTOBJ_CONTAINER_COMPONENTS(struct oh323_alias);
202 } aliasl;
203
204 /* Asterisk RTP stuff */
205 static struct sched_context *sched;
206 static struct io_context *io;
207
208 AST_MUTEX_DEFINE_STATIC(iflock);        /*!< Protect the interface list (oh323_pvt) */
209
210 /*! \brief  Protect the H.323 monitoring thread, so only one process can kill or start it, and not
211    when it's doing something critical. */
212 AST_MUTEX_DEFINE_STATIC(monlock);
213
214 /*! \brief Protect the H.323 capabilities list, to avoid more than one channel to set the capabilities simultaneaously in the h323 stack. */
215 AST_MUTEX_DEFINE_STATIC(caplock);
216
217 /*! \brief Protect the reload process */
218 AST_MUTEX_DEFINE_STATIC(h323_reload_lock);
219 static int h323_reloading = 0;
220
221 /*! \brief This is the thread for the monitor which checks for input on the channels
222    which are not currently in use. */
223 static pthread_t monitor_thread = AST_PTHREADT_NULL;
224 static int restart_monitor(void);
225 static int h323_do_reload(void);
226
227 static void delete_users(void);
228 static void delete_aliases(void);
229 static void prune_peers(void);
230
231 static struct ast_channel *oh323_request(const char *type, int format, void *data, int *cause);
232 static int oh323_digit_begin(struct ast_channel *c, char digit);
233 static int oh323_digit_end(struct ast_channel *c, char digit, unsigned int duration);
234 static int oh323_call(struct ast_channel *c, char *dest, int timeout);
235 static int oh323_hangup(struct ast_channel *c);
236 static int oh323_answer(struct ast_channel *c);
237 static struct ast_frame *oh323_read(struct ast_channel *c);
238 static int oh323_write(struct ast_channel *c, struct ast_frame *frame);
239 static int oh323_indicate(struct ast_channel *c, int condition, const void *data, size_t datalen);
240 static int oh323_fixup(struct ast_channel *oldchan, struct ast_channel *newchan);
241
242 static const struct ast_channel_tech oh323_tech = {
243         .type = "H323",
244         .description = tdesc,
245         .capabilities = AST_FORMAT_AUDIO_MASK,
246         .properties = AST_CHAN_TP_WANTSJITTER | AST_CHAN_TP_CREATESJITTER,
247         .requester = oh323_request,
248         .send_digit_begin = oh323_digit_begin,
249         .send_digit_end = oh323_digit_end,
250         .call = oh323_call,
251         .hangup = oh323_hangup,
252         .answer = oh323_answer,
253         .read = oh323_read,
254         .write = oh323_write,
255         .indicate = oh323_indicate,
256         .fixup = oh323_fixup,
257         /* disable, for now */
258 #if 0
259         .bridge = ast_rtp_bridge,
260 #endif
261 };
262
263 static const char* redirectingreason2str(int redirectingreason)
264 {
265         switch (redirectingreason) {
266         case 0:
267                 return "UNKNOWN";
268         case 1:
269                 return "BUSY";
270         case 2:
271                 return "NO_REPLY";
272         case 0xF:
273                 return "UNCONDITIONAL";
274         default:
275                 return "NOREDIRECT";
276         }
277 }
278
279 static void oh323_destroy_alias(struct oh323_alias *alias)
280 {
281         if (h323debug)
282                 ast_debug(1, "Destroying alias '%s'\n", alias->name);
283         ast_free(alias);
284 }
285
286 static void oh323_destroy_user(struct oh323_user *user)
287 {
288         if (h323debug)
289                 ast_debug(1, "Destroying user '%s'\n", user->name);
290         ast_free_ha(user->ha);
291         ast_free(user);
292 }
293
294 static void oh323_destroy_peer(struct oh323_peer *peer)
295 {
296         if (h323debug)
297                 ast_debug(1, "Destroying peer '%s'\n", peer->name);
298         ast_free_ha(peer->ha);
299         ast_free(peer);
300 }
301
302 static int oh323_simulate_dtmf_end(const void *data)
303 {
304         struct oh323_pvt *pvt = (struct oh323_pvt *)data;
305
306         if (pvt) {
307                 ast_mutex_lock(&pvt->lock);
308                 /* Don't hold pvt lock while trying to lock the channel */
309                 while(pvt->owner && ast_channel_trylock(pvt->owner)) {
310                         ast_mutex_unlock(&pvt->lock);
311                         usleep(1);
312                         ast_mutex_lock(&pvt->lock);
313                 }
314
315                 if (pvt->owner) {
316                         struct ast_frame f = {
317                                 .frametype = AST_FRAME_DTMF_END,
318                                 .subclass = pvt->curDTMF,
319                                 .samples = 0,
320                                 .src = "SIMULATE_DTMF_END",
321                         };
322                         ast_queue_frame(pvt->owner, &f);
323                         ast_channel_unlock(pvt->owner);
324                 }
325
326                 pvt->DTMFsched = -1;
327                 ast_mutex_unlock(&pvt->lock);
328         }
329
330         return 0;
331 }
332
333 /*! \brief Channel and private structures should be already locked */
334 static void __oh323_update_info(struct ast_channel *c, struct oh323_pvt *pvt)
335 {
336         if (c->nativeformats != pvt->nativeformats) {
337                 if (h323debug)
338                         ast_debug(1, "Preparing %s for new native format\n", c->name);
339                 c->nativeformats = pvt->nativeformats;
340                 ast_set_read_format(c, c->readformat);
341                 ast_set_write_format(c, c->writeformat);
342         }
343         if (pvt->needhangup) {
344                 if (h323debug)
345                         ast_debug(1, "Process pending hangup for %s\n", c->name);
346                 c->_softhangup |= AST_SOFTHANGUP_DEV;
347                 c->hangupcause = pvt->hangupcause;
348                 ast_queue_hangup(c);
349                 pvt->needhangup = 0;
350                 pvt->newstate = pvt->newcontrol = pvt->newdigit = pvt->DTMFsched = -1;
351         }
352         if (pvt->newstate >= 0) {
353                 ast_setstate(c, pvt->newstate);
354                 pvt->newstate = -1;
355         }
356         if (pvt->newcontrol >= 0) {
357                 ast_queue_control(c, pvt->newcontrol);
358                 pvt->newcontrol = -1;
359         }
360         if (pvt->newdigit >= 0) {
361                 struct ast_frame f = {
362                         .frametype = AST_FRAME_DTMF_END,
363                         .subclass = pvt->newdigit,
364                         .samples = pvt->newduration * 8,
365                         .len = pvt->newduration,
366                         .src = "UPDATE_INFO",
367                 };
368                 if (pvt->newdigit == ' ') {             /* signalUpdate message */
369                         f.subclass = pvt->curDTMF;
370                         if (pvt->DTMFsched >= 0) {
371                                 ast_sched_del(sched, pvt->DTMFsched);
372                                 pvt->DTMFsched = -1;
373                         }
374                 } else {                                                /* Regular input or signal message */
375                         if (pvt->newduration) {         /* This is a signal, signalUpdate follows */
376                                 f.frametype = AST_FRAME_DTMF_BEGIN;
377                                 if (pvt->DTMFsched >= 0)
378                                         ast_sched_del(sched, pvt->DTMFsched);
379                                 pvt->DTMFsched = ast_sched_add(sched, pvt->newduration, oh323_simulate_dtmf_end, pvt);
380                                 if (h323debug)
381                                         ast_log(LOG_DTMF, "Scheduled DTMF END simulation for %d ms, id=%d\n", pvt->newduration, pvt->DTMFsched);
382                         }
383                         pvt->curDTMF = pvt->newdigit;
384                 }
385                 ast_queue_frame(c, &f);
386                 pvt->newdigit = -1;
387         }
388         if (pvt->update_rtp_info > 0) {
389                 if (pvt->rtp) {
390                         ast_jb_configure(c, &global_jbconf);
391                         ast_channel_set_fd(c, 0, ast_rtp_fd(pvt->rtp));
392                         ast_channel_set_fd(c, 1, ast_rtcp_fd(pvt->rtp));
393                         ast_queue_frame(pvt->owner, &ast_null_frame);   /* Tell Asterisk to apply changes */
394                 }
395                 pvt->update_rtp_info = -1;
396         }
397 }
398
399 /*! \brief Only channel structure should be locked */
400 static void oh323_update_info(struct ast_channel *c)
401 {
402         struct oh323_pvt *pvt = c->tech_pvt;
403
404         if (pvt) {
405                 ast_mutex_lock(&pvt->lock);
406                 __oh323_update_info(c, pvt);
407                 ast_mutex_unlock(&pvt->lock);
408         }
409 }
410
411 static void cleanup_call_details(call_details_t *cd)
412 {
413         if (cd->call_token) {
414                 ast_free(cd->call_token);
415                 cd->call_token = NULL;
416         }
417         if (cd->call_source_aliases) {
418                 ast_free(cd->call_source_aliases);
419                 cd->call_source_aliases = NULL;
420         }
421         if (cd->call_dest_alias) {
422                 ast_free(cd->call_dest_alias);
423                 cd->call_dest_alias = NULL;
424         }
425         if (cd->call_source_name) {
426                 ast_free(cd->call_source_name);
427                 cd->call_source_name = NULL;
428         }
429         if (cd->call_source_e164) {
430                 ast_free(cd->call_source_e164);
431                 cd->call_source_e164 = NULL;
432         }
433         if (cd->call_dest_e164) {
434                 ast_free(cd->call_dest_e164);
435                 cd->call_dest_e164 = NULL;
436         }
437         if (cd->sourceIp) {
438                 ast_free(cd->sourceIp);
439                 cd->sourceIp = NULL;
440         }
441         if (cd->redirect_number) {
442                 ast_free(cd->redirect_number);
443                 cd->redirect_number = NULL;
444         }
445 }
446
447 static void __oh323_destroy(struct oh323_pvt *pvt)
448 {
449         struct oh323_pvt *cur, *prev = NULL;
450
451         if (pvt->DTMFsched >= 0) {
452                 ast_sched_del(sched, pvt->DTMFsched);
453                 pvt->DTMFsched = -1;
454         }
455
456         if (pvt->rtp) {
457                 ast_rtp_destroy(pvt->rtp);
458         }
459
460         /* Free dsp used for in-band DTMF detection */
461         if (pvt->vad) {
462                 ast_dsp_free(pvt->vad);
463         }
464         cleanup_call_details(&pvt->cd);
465
466         /* Unlink us from the owner if we have one */
467         if (pvt->owner) {
468                 ast_channel_lock(pvt->owner);
469                 if (h323debug)
470                         ast_debug(1, "Detaching from %s\n", pvt->owner->name);
471                 pvt->owner->tech_pvt = NULL;
472                 ast_channel_unlock(pvt->owner);
473         }
474         cur = iflist;
475         while(cur) {
476                 if (cur == pvt) {
477                         if (prev)
478                                 prev->next = cur->next;
479                         else
480                                 iflist = cur->next;
481                         break;
482                 }
483                 prev = cur;
484                 cur = cur->next;
485         }
486         if (!cur) {
487                 ast_log(LOG_WARNING, "%p is not in list?!?! \n", cur);
488         } else {
489                 ast_mutex_unlock(&pvt->lock);
490                 ast_mutex_destroy(&pvt->lock);
491                 ast_free(pvt);
492         }
493 }
494
495 static void oh323_destroy(struct oh323_pvt *pvt)
496 {
497         if (h323debug) {
498                 ast_debug(1, "Destroying channel %s\n", (pvt->owner ? pvt->owner->name : "<unknown>"));
499         }
500         ast_mutex_lock(&iflock);
501         ast_mutex_lock(&pvt->lock);
502         __oh323_destroy(pvt);
503         ast_mutex_unlock(&iflock);
504 }
505
506 static int oh323_digit_begin(struct ast_channel *c, char digit)
507 {
508         struct oh323_pvt *pvt = (struct oh323_pvt *) c->tech_pvt;
509         char *token;
510
511         if (!pvt) {
512                 ast_log(LOG_ERROR, "No private structure?! This is bad\n");
513                 return -1;
514         }
515         ast_mutex_lock(&pvt->lock);
516         if (pvt->rtp &&
517                 (((pvt->options.dtmfmode & H323_DTMF_RFC2833) && pvt->dtmf_pt[0])
518                  /*|| ((pvt->options.dtmfmode & H323_DTMF_CISCO) && pvt->dtmf_pt[1]))*/)) {
519                 /* out-of-band DTMF */
520                 if (h323debug) {
521                         ast_log(LOG_DTMF, "Begin sending out-of-band digit %c on %s\n", digit, c->name);
522                 }
523                 ast_rtp_senddigit_begin(pvt->rtp, digit);
524                 ast_mutex_unlock(&pvt->lock);
525         } else if (pvt->txDtmfDigit != digit) {
526                 /* in-band DTMF */
527                 if (h323debug) {
528                         ast_log(LOG_DTMF, "Begin sending inband digit %c on %s\n", digit, c->name);
529                 }
530                 pvt->txDtmfDigit = digit;
531                 token = pvt->cd.call_token ? ast_strdup(pvt->cd.call_token) : NULL;
532                 ast_mutex_unlock(&pvt->lock);
533                 h323_send_tone(token, digit);
534                 if (token) {
535                         ast_free(token);
536                 }
537         } else
538                 ast_mutex_unlock(&pvt->lock);
539         oh323_update_info(c);
540         return 0;
541 }
542
543 /*! \brief
544  * Send (play) the specified digit to the channel.
545  *
546  */
547 static int oh323_digit_end(struct ast_channel *c, char digit, unsigned int duration)
548 {
549         struct oh323_pvt *pvt = (struct oh323_pvt *) c->tech_pvt;
550         char *token;
551
552         if (!pvt) {
553                 ast_log(LOG_ERROR, "No private structure?! This is bad\n");
554                 return -1;
555         }
556         ast_mutex_lock(&pvt->lock);
557         if (pvt->rtp && (pvt->options.dtmfmode & H323_DTMF_RFC2833) && ((pvt->dtmf_pt[0] > 0) || (pvt->dtmf_pt[0] > 0))) {
558                 /* out-of-band DTMF */
559                 if (h323debug) {
560                         ast_log(LOG_DTMF, "End sending out-of-band digit %c on %s, duration %d\n", digit, c->name, duration);
561                 }
562                 ast_rtp_senddigit_end(pvt->rtp, digit);
563                 ast_mutex_unlock(&pvt->lock);
564         } else {
565                 /* in-band DTMF */
566                 if (h323debug) {
567                         ast_log(LOG_DTMF, "End sending inband digit %c on %s, duration %d\n", digit, c->name, duration);
568                 }
569                 pvt->txDtmfDigit = ' ';
570                 token = pvt->cd.call_token ? ast_strdup(pvt->cd.call_token) : NULL;
571                 ast_mutex_unlock(&pvt->lock);
572                 h323_send_tone(token, ' ');
573                 if (token) {
574                         ast_free(token);
575                 }
576         }
577         oh323_update_info(c);
578         return 0;
579 }
580
581 /*! \brief
582  * Make a call over the specified channel to the specified
583  * destination.
584  * Returns -1 on error, 0 on success.
585  */
586 static int oh323_call(struct ast_channel *c, char *dest, int timeout)
587 {
588         int res = 0;
589         struct oh323_pvt *pvt = (struct oh323_pvt *)c->tech_pvt;
590         const char *addr;
591         char called_addr[1024];
592
593         if (h323debug) {
594                 ast_debug(1, "Calling to %s on %s\n", dest, c->name);
595         }
596         if ((c->_state != AST_STATE_DOWN) && (c->_state != AST_STATE_RESERVED)) {
597                 ast_log(LOG_WARNING, "Line is already in use (%s)\n", c->name);
598                 return -1;
599         }
600         ast_mutex_lock(&pvt->lock);
601         if (!gatekeeper_disable) {
602                 if (ast_strlen_zero(pvt->exten)) {
603                         ast_copy_string(called_addr, dest, sizeof(called_addr));
604                 } else {
605                         snprintf(called_addr, sizeof(called_addr), "%s@%s", pvt->exten, dest);
606                 }
607         } else {
608                 res = htons(pvt->sa.sin_port);
609                 addr = ast_inet_ntoa(pvt->sa.sin_addr);
610                 if (ast_strlen_zero(pvt->exten)) {
611                         snprintf(called_addr, sizeof(called_addr), "%s:%d", addr, res);
612                 } else {
613                         snprintf(called_addr, sizeof(called_addr), "%s@%s:%d", pvt->exten, addr, res);
614                 }
615         }
616         /* make sure null terminated */
617         called_addr[sizeof(called_addr) - 1] = '\0';
618
619         if (c->cid.cid_num)
620                 ast_copy_string(pvt->options.cid_num, c->cid.cid_num, sizeof(pvt->options.cid_num));
621
622         if (c->cid.cid_name)
623                 ast_copy_string(pvt->options.cid_name, c->cid.cid_name, sizeof(pvt->options.cid_name));
624
625         if (c->cid.cid_rdnis) {
626                 ast_copy_string(pvt->options.cid_rdnis, c->cid.cid_rdnis, sizeof(pvt->options.cid_rdnis));
627         }
628
629         pvt->options.presentation = c->cid.cid_pres;
630         pvt->options.type_of_number = c->cid.cid_ton;
631
632         if ((addr = pbx_builtin_getvar_helper(c, "PRIREDIRECTREASON"))) {
633                 if (!strcasecmp(addr, "UNKNOWN"))
634                         pvt->options.redirect_reason = 0;
635                 else if (!strcasecmp(addr, "BUSY"))
636                         pvt->options.redirect_reason = 1;
637                 else if (!strcasecmp(addr, "NO_REPLY"))
638                         pvt->options.redirect_reason = 2;
639                 else if (!strcasecmp(addr, "UNCONDITIONAL"))
640                         pvt->options.redirect_reason = 15;
641                 else
642                         pvt->options.redirect_reason = -1;
643         } else
644                 pvt->options.redirect_reason = -1;
645
646         pvt->options.transfer_capability = c->transfercapability;
647
648         /* indicate that this is an outgoing call */
649         pvt->outgoing = 1;
650
651         ast_verb(3, "Requested transfer capability: 0x%.2x - %s\n", c->transfercapability, ast_transfercapability2str(c->transfercapability));
652         if (h323debug)
653                 ast_debug(1, "Placing outgoing call to %s, %d/%d\n", called_addr, pvt->options.dtmfcodec[0], pvt->options.dtmfcodec[1]);
654         ast_mutex_unlock(&pvt->lock);
655         res = h323_make_call(called_addr, &(pvt->cd), &pvt->options);
656         if (res) {
657                 ast_log(LOG_NOTICE, "h323_make_call failed(%s)\n", c->name);
658                 return -1;
659         }
660         oh323_update_info(c);
661         return 0;
662 }
663
664 static int oh323_answer(struct ast_channel *c)
665 {
666         int res;
667         struct oh323_pvt *pvt = (struct oh323_pvt *) c->tech_pvt;
668         char *token;
669
670         if (h323debug)
671                 ast_debug(1, "Answering on %s\n", c->name);
672
673         ast_mutex_lock(&pvt->lock);
674         token = pvt->cd.call_token ? ast_strdup(pvt->cd.call_token) : NULL;
675         ast_mutex_unlock(&pvt->lock);
676         res = h323_answering_call(token, 0);
677         if (token)
678                 ast_free(token);
679
680         oh323_update_info(c);
681         if (c->_state != AST_STATE_UP) {
682                 ast_setstate(c, AST_STATE_UP);
683         }
684         return res;
685 }
686
687 static int oh323_hangup(struct ast_channel *c)
688 {
689         struct oh323_pvt *pvt = (struct oh323_pvt *) c->tech_pvt;
690         int q931cause = AST_CAUSE_NORMAL_CLEARING;
691         char *call_token;
692
693
694         if (h323debug)
695                 ast_debug(1, "Hanging up and scheduling destroy of call %s\n", c->name);
696
697         if (!c->tech_pvt) {
698                 ast_log(LOG_WARNING, "Asked to hangup channel not connected\n");
699                 return 0;
700         }
701         ast_mutex_lock(&pvt->lock);
702         /* Determine how to disconnect */
703         if (pvt->owner != c) {
704                 ast_log(LOG_WARNING, "Huh?  We aren't the owner?\n");
705                 ast_mutex_unlock(&pvt->lock);
706                 return 0;
707         }
708
709         pvt->owner = NULL;
710         c->tech_pvt = NULL;
711
712         if (c->hangupcause) {
713                 q931cause = c->hangupcause;
714         } else {
715                 const char *cause = pbx_builtin_getvar_helper(c, "DIALSTATUS");
716                 if (cause) {
717                         if (!strcmp(cause, "CONGESTION")) {
718                                 q931cause = AST_CAUSE_NORMAL_CIRCUIT_CONGESTION;
719                         } else if (!strcmp(cause, "BUSY")) {
720                                 q931cause = AST_CAUSE_USER_BUSY;
721                         } else if (!strcmp(cause, "CHANISUNVAIL")) {
722                                 q931cause = AST_CAUSE_REQUESTED_CHAN_UNAVAIL;
723                         } else if (!strcmp(cause, "NOANSWER")) {
724                                 q931cause = AST_CAUSE_NO_ANSWER;
725                         } else if (!strcmp(cause, "CANCEL")) {
726                                 q931cause = AST_CAUSE_CALL_REJECTED;
727                         }
728                 }
729         }
730
731         /* Start the process if it's not already started */
732         if (!pvt->alreadygone && !pvt->hangupcause) {
733                 call_token = pvt->cd.call_token ? ast_strdup(pvt->cd.call_token) : NULL;
734                 if (call_token) {
735                         /* Release lock to eliminate deadlock */
736                         ast_mutex_unlock(&pvt->lock);
737                         if (h323_clear_call(call_token, q931cause)) {
738                                 ast_log(LOG_WARNING, "ClearCall failed.\n");
739                         }
740                         ast_free(call_token);
741                         ast_mutex_lock(&pvt->lock);
742                 }
743         }
744         pvt->needdestroy = 1;
745         ast_mutex_unlock(&pvt->lock);
746
747         /* Update usage counter */
748         ast_module_unref(ast_module_info->self);
749
750         return 0;
751 }
752
753 /*! \brief Retrieve audio/etc from channel. Assumes pvt->lock is already held. */
754 static struct ast_frame *oh323_rtp_read(struct oh323_pvt *pvt)
755 {
756         struct ast_frame *f;
757
758         /* Only apply it for the first packet, we just need the correct ip/port */
759         if (pvt->options.nat) {
760                 ast_rtp_setnat(pvt->rtp, pvt->options.nat);
761                 pvt->options.nat = 0;
762         }
763
764         f = ast_rtp_read(pvt->rtp);
765         /* Don't send RFC2833 if we're not supposed to */
766         if (f && (f->frametype == AST_FRAME_DTMF) && !(pvt->options.dtmfmode & (H323_DTMF_RFC2833 | H323_DTMF_CISCO))) {
767                 return &ast_null_frame;
768         }
769         if (pvt->owner) {
770                 /* We already hold the channel lock */
771                 if (f->frametype == AST_FRAME_VOICE) {
772                         if (f->subclass != pvt->owner->nativeformats) {
773                                 /* Try to avoid deadlock */
774                                 if (ast_channel_trylock(pvt->owner)) {
775                                         ast_log(LOG_NOTICE, "Format changed but channel is locked. Ignoring frame...\n");
776                                         return &ast_null_frame;
777                                 }
778                                 if (h323debug)
779                                         ast_debug(1, "Oooh, format changed to %d\n", f->subclass);
780                                 pvt->owner->nativeformats = f->subclass;
781                                 pvt->nativeformats = f->subclass;
782                                 ast_set_read_format(pvt->owner, pvt->owner->readformat);
783                                 ast_set_write_format(pvt->owner, pvt->owner->writeformat);
784                                 ast_channel_unlock(pvt->owner);
785                         }
786                         /* Do in-band DTMF detection */
787                         if ((pvt->options.dtmfmode & H323_DTMF_INBAND) && pvt->vad) {
788                                 if ((pvt->nativeformats & (AST_FORMAT_SLINEAR | AST_FORMAT_ALAW | AST_FORMAT_ULAW))) {
789                                         if (!ast_channel_trylock(pvt->owner)) {
790                                                 f = ast_dsp_process(pvt->owner, pvt->vad, f);
791                                                 ast_channel_unlock(pvt->owner);
792                                         }
793                                         else
794                                                 ast_log(LOG_NOTICE, "Unable to process inband DTMF while channel is locked\n");
795                                 } else if (pvt->nativeformats && !pvt->noInbandDtmf) {
796                                         ast_log(LOG_NOTICE, "Inband DTMF is not supported on codec %s. Use RFC2833\n", ast_getformatname(f->subclass));
797                                         pvt->noInbandDtmf = 1;
798                                 }
799                                 if (f &&(f->frametype == AST_FRAME_DTMF)) {
800                                         if (h323debug)
801                                                 ast_log(LOG_DTMF, "Received in-band digit %c.\n", f->subclass);
802                                 }
803                         }
804                 }
805         }
806         return f;
807 }
808
809 static struct ast_frame *oh323_read(struct ast_channel *c)
810 {
811         struct ast_frame *fr;
812         struct oh323_pvt *pvt = (struct oh323_pvt *)c->tech_pvt;
813         ast_mutex_lock(&pvt->lock);
814         __oh323_update_info(c, pvt);
815         switch(c->fdno) {
816         case 0:
817                 fr = oh323_rtp_read(pvt);
818                 break;
819         case 1:
820                 if (pvt->rtp)
821                         fr = ast_rtcp_read(pvt->rtp);
822                 else
823                         fr = &ast_null_frame;
824                 break;
825         default:
826                 ast_log(LOG_ERROR, "Unable to handle fd %d on channel %s\n", c->fdno, c->name);
827                 fr = &ast_null_frame;
828                 break;
829         }
830         ast_mutex_unlock(&pvt->lock);
831         return fr;
832 }
833
834 static int oh323_write(struct ast_channel *c, struct ast_frame *frame)
835 {
836         struct oh323_pvt *pvt = (struct oh323_pvt *) c->tech_pvt;
837         int res = 0;
838         if (frame->frametype != AST_FRAME_VOICE) {
839                 if (frame->frametype == AST_FRAME_IMAGE) {
840                         return 0;
841                 } else {
842                         ast_log(LOG_WARNING, "Can't send %d type frames with H323 write\n", frame->frametype);
843                         return 0;
844                 }
845         } else {
846                 if (!(frame->subclass & c->nativeformats)) {
847                         ast_log(LOG_WARNING, "Asked to transmit frame type %d, while native formats is %d (read/write = %d/%d)\n",
848                                 frame->subclass, c->nativeformats, c->readformat, c->writeformat);
849                         return 0;
850                 }
851         }
852         if (pvt) {
853                 ast_mutex_lock(&pvt->lock);
854                 if (pvt->rtp && !pvt->recvonly)
855                         res = ast_rtp_write(pvt->rtp, frame);
856                 __oh323_update_info(c, pvt);
857                 ast_mutex_unlock(&pvt->lock);
858         }
859         return res;
860 }
861
862 static int oh323_indicate(struct ast_channel *c, int condition, const void *data, size_t datalen)
863 {
864
865         struct oh323_pvt *pvt = (struct oh323_pvt *) c->tech_pvt;
866         char *token = (char *)NULL;
867         int res = -1;
868         int got_progress;
869
870         ast_mutex_lock(&pvt->lock);
871         token = (pvt->cd.call_token ? ast_strdup(pvt->cd.call_token) : NULL);
872         got_progress = pvt->got_progress;
873         if (condition == AST_CONTROL_PROGRESS)
874                 pvt->got_progress = 1;
875         else if ((condition == AST_CONTROL_BUSY) || (condition == AST_CONTROL_CONGESTION))
876                 pvt->alreadygone = 1;
877         ast_mutex_unlock(&pvt->lock);
878
879         if (h323debug)
880                 ast_debug(1, "OH323: Indicating %d on %s (%s)\n", condition, token, c->name);
881
882         switch(condition) {
883         case AST_CONTROL_RINGING:
884                 if (c->_state == AST_STATE_RING || c->_state == AST_STATE_RINGING) {
885                         h323_send_alerting(token);
886                         res = (got_progress ? 0 : -1);  /* Do not simulate any audio tones if we got PROGRESS message */
887                 }
888                 break;
889         case AST_CONTROL_PROGRESS:
890                 if (c->_state != AST_STATE_UP) {
891                         /* Do not send PROGRESS message more than once */
892                         if (!got_progress)
893                                 h323_send_progress(token);
894                         res = 0;
895                 }
896                 break;
897         case AST_CONTROL_BUSY:
898                 if (c->_state != AST_STATE_UP) {
899                         h323_answering_call(token, 1);
900                         ast_softhangup_nolock(c, AST_SOFTHANGUP_DEV);
901                         res = 0;
902                 }
903                 break;
904         case AST_CONTROL_CONGESTION:
905                 if (c->_state != AST_STATE_UP) {
906                         h323_answering_call(token, 1);
907                         ast_softhangup_nolock(c, AST_SOFTHANGUP_DEV);
908                         res = 0;
909                 }
910                 break;
911         case AST_CONTROL_HOLD:
912                 h323_hold_call(token, 1);
913                 /* We should start MOH only if remote party isn't provide audio for us */
914                 ast_moh_start(c, data, NULL);
915                 res = 0;
916                 break;
917         case AST_CONTROL_UNHOLD:
918                 h323_hold_call(token, 0);
919                 ast_moh_stop(c);
920                 res = 0;
921                 break;
922         case AST_CONTROL_PROCEEDING:
923         case -1:
924                 break;
925         default:
926                 ast_log(LOG_WARNING, "OH323: Don't know how to indicate condition %d on %s\n", condition, token);
927                 break;
928         }
929
930         if (h323debug)
931                 ast_debug(1, "OH323: Indicated %d on %s, res=%d\n", condition, token, res);
932         if (token)
933                 ast_free(token);
934         oh323_update_info(c);
935
936         return res;
937 }
938
939 static int oh323_fixup(struct ast_channel *oldchan, struct ast_channel *newchan)
940 {
941         struct oh323_pvt *pvt = (struct oh323_pvt *) newchan->tech_pvt;
942
943         ast_mutex_lock(&pvt->lock);
944         if (pvt->owner != oldchan) {
945                 ast_log(LOG_WARNING, "old channel wasn't %p but was %p\n", oldchan, pvt->owner);
946                 return -1;
947         }
948         pvt->owner = newchan;
949         ast_mutex_unlock(&pvt->lock);
950         return 0;
951 }
952
953 static int __oh323_rtp_create(struct oh323_pvt *pvt)
954 {
955         struct in_addr our_addr;
956
957         if (pvt->rtp)
958                 return 0;
959
960         if (ast_find_ourip(&our_addr, bindaddr)) {
961                 ast_mutex_unlock(&pvt->lock);
962                 ast_log(LOG_ERROR, "Unable to locate local IP address for RTP stream\n");
963                 return -1;
964         }
965         pvt->rtp = ast_rtp_new_with_bindaddr(sched, io, 1, 0, our_addr);
966         if (!pvt->rtp) {
967                 ast_mutex_unlock(&pvt->lock);
968                 ast_log(LOG_WARNING, "Unable to create RTP session: %s\n", strerror(errno));
969                 return -1;
970         }
971         if (h323debug)
972                 ast_debug(1, "Created RTP channel\n");
973
974         ast_rtp_setqos(pvt->rtp, tos, cos, "H323 RTP");
975
976         if (h323debug)
977                 ast_debug(1, "Setting NAT on RTP to %d\n", pvt->options.nat);
978         ast_rtp_setnat(pvt->rtp, pvt->options.nat);
979
980         if (pvt->dtmf_pt[0] > 0)
981                 ast_rtp_set_rtpmap_type(pvt->rtp, pvt->dtmf_pt[0], "audio", "telephone-event", 0);
982         if (pvt->dtmf_pt[1] > 0)
983                 ast_rtp_set_rtpmap_type(pvt->rtp, pvt->dtmf_pt[1], "audio", "cisco-telephone-event", 0);
984
985         if (pvt->peercapability)
986                 ast_rtp_codec_setpref(pvt->rtp, &pvt->peer_prefs);
987
988         if (pvt->owner && !ast_channel_trylock(pvt->owner)) {
989                 ast_jb_configure(pvt->owner, &global_jbconf);
990                 ast_channel_set_fd(pvt->owner, 0, ast_rtp_fd(pvt->rtp));
991                 ast_channel_set_fd(pvt->owner, 1, ast_rtcp_fd(pvt->rtp));
992                 ast_queue_frame(pvt->owner, &ast_null_frame);   /* Tell Asterisk to apply changes */
993                 ast_channel_unlock(pvt->owner);
994         } else
995                 pvt->update_rtp_info = 1;
996
997         return 0;
998 }
999
1000 /*! \brief Private structure should be locked on a call */
1001 static struct ast_channel *__oh323_new(struct oh323_pvt *pvt, int state, const char *host)
1002 {
1003         struct ast_channel *ch;
1004         char *cid_num, *cid_name;
1005         int fmt;
1006
1007         if (!ast_strlen_zero(pvt->options.cid_num))
1008                 cid_num = pvt->options.cid_num;
1009         else
1010                 cid_num = pvt->cd.call_source_e164;
1011
1012         if (!ast_strlen_zero(pvt->options.cid_name))
1013                 cid_name = pvt->options.cid_name;
1014         else
1015                 cid_name = pvt->cd.call_source_name;
1016         
1017         /* Don't hold a oh323_pvt lock while we allocate a chanel */
1018         ast_mutex_unlock(&pvt->lock);
1019         ch = ast_channel_alloc(1, state, cid_num, cid_name, pvt->accountcode, pvt->exten, pvt->context, pvt->amaflags, "H323/%s", host);
1020         /* Update usage counter */
1021         ast_module_ref(ast_module_info->self);
1022         ast_mutex_lock(&pvt->lock);
1023         if (ch) {
1024                 ch->tech = &oh323_tech;
1025                 if (!(fmt = pvt->jointcapability) && !(fmt = pvt->options.capability))
1026                         fmt = global_options.capability;
1027                 ch->nativeformats = ast_codec_choose(&pvt->options.prefs, fmt, 1)/* | (pvt->jointcapability & AST_FORMAT_VIDEO_MASK)*/;
1028                 pvt->nativeformats = ch->nativeformats;
1029                 fmt = ast_best_codec(ch->nativeformats);
1030                 ch->writeformat = fmt;
1031                 ch->rawwriteformat = fmt;
1032                 ch->readformat = fmt;
1033                 ch->rawreadformat = fmt;
1034                 if (!pvt->rtp)
1035                         __oh323_rtp_create(pvt);
1036 #if 0
1037                 ast_channel_set_fd(ch, 0, ast_rtp_fd(pvt->rtp));
1038                 ast_channel_set_fd(ch, 1, ast_rtcp_fd(pvt->rtp));
1039 #endif
1040 #ifdef VIDEO_SUPPORT
1041                 if (pvt->vrtp) {
1042                         ast_channel_set_fd(ch, 2, ast_rtp_fd(pvt->vrtp));
1043                         ast_channel_set_fd(ch, 3, ast_rtcp_fd(pvt->vrtp));
1044                 }
1045 #endif
1046 #ifdef T38_SUPPORT
1047                 if (pvt->udptl) {
1048                         ast_channel_set_fd(ch, 4, ast_udptl_fd(pvt->udptl));
1049                 }
1050 #endif
1051                 if (state == AST_STATE_RING) {
1052                         ch->rings = 1;
1053                 }
1054                 /* Allocate dsp for in-band DTMF support */
1055                 if (pvt->options.dtmfmode & H323_DTMF_INBAND) {
1056                         pvt->vad = ast_dsp_new();
1057                         ast_dsp_set_features(pvt->vad, DSP_FEATURE_DTMF_DETECT);
1058                 }
1059                 /* Register channel functions. */
1060                 ch->tech_pvt = pvt;
1061                 /* Set the owner of this channel */
1062                 pvt->owner = ch;
1063
1064                 ast_copy_string(ch->context, pvt->context, sizeof(ch->context));
1065                 ast_copy_string(ch->exten, pvt->exten, sizeof(ch->exten));
1066                 ch->priority = 1;
1067                 if (!ast_strlen_zero(pvt->accountcode)) {
1068                         ast_string_field_set(ch, accountcode, pvt->accountcode);
1069                 }
1070                 if (pvt->amaflags) {
1071                         ch->amaflags = pvt->amaflags;
1072                 }
1073
1074                 /* Don't use ast_set_callerid() here because it will
1075                  * generate a needless NewCallerID event */
1076                 ch->cid.cid_ani = ast_strdup(cid_num);
1077
1078                 if (pvt->cd.redirect_reason >= 0) {
1079                         ch->cid.cid_rdnis = ast_strdup(pvt->cd.redirect_number);
1080                         pbx_builtin_setvar_helper(ch, "PRIREDIRECTREASON", redirectingreason2str(pvt->cd.redirect_reason));
1081                 }
1082                 ch->cid.cid_pres = pvt->cd.presentation;
1083                 ch->cid.cid_ton = pvt->cd.type_of_number;
1084
1085                 if (!ast_strlen_zero(pvt->exten) && strcmp(pvt->exten, "s")) {
1086                         ch->cid.cid_dnid = ast_strdup(pvt->exten);
1087                 }
1088                 if (pvt->cd.transfer_capability >= 0)
1089                         ch->transfercapability = pvt->cd.transfer_capability;
1090                 if (state != AST_STATE_DOWN) {
1091                         if (ast_pbx_start(ch)) {
1092                                 ast_log(LOG_WARNING, "Unable to start PBX on %s\n", ch->name);
1093                                 ast_hangup(ch);
1094                                 ch = NULL;
1095                         }
1096                 }
1097         } else {
1098                 ast_log(LOG_WARNING, "Unable to allocate channel structure\n");
1099         }
1100         return ch;
1101 }
1102
1103 static struct oh323_pvt *oh323_alloc(int callid)
1104 {
1105         struct oh323_pvt *pvt;
1106
1107         pvt = ast_calloc(1, sizeof(*pvt));
1108         if (!pvt) {
1109                 ast_log(LOG_ERROR, "Couldn't allocate private structure. This is bad\n");
1110                 return NULL;
1111         }
1112         pvt->cd.redirect_reason = -1;
1113         pvt->cd.transfer_capability = -1;
1114         /* Ensure the call token is allocated for outgoing call */
1115         if (!callid) {
1116                 if ((pvt->cd).call_token == NULL) {
1117                         (pvt->cd).call_token = ast_calloc(1, 128);
1118                 }
1119                 if (!pvt->cd.call_token) {
1120                         ast_log(LOG_ERROR, "Not enough memory to alocate call token\n");
1121                         ast_rtp_destroy(pvt->rtp);
1122                         ast_free(pvt);
1123                         return NULL;
1124                 }
1125                 memset((char *)(pvt->cd).call_token, 0, 128);
1126                 pvt->cd.call_reference = callid;
1127         }
1128         memcpy(&pvt->options, &global_options, sizeof(pvt->options));
1129         pvt->jointcapability = pvt->options.capability;
1130         if (pvt->options.dtmfmode & (H323_DTMF_RFC2833 | H323_DTMF_CISCO)) {
1131                 pvt->nonCodecCapability |= AST_RTP_DTMF;
1132         } else {
1133                 pvt->nonCodecCapability &= ~AST_RTP_DTMF;
1134         }
1135         ast_copy_string(pvt->context, default_context, sizeof(pvt->context));
1136         pvt->newstate = pvt->newcontrol = pvt->newdigit = pvt->update_rtp_info = pvt->DTMFsched = -1;
1137         ast_mutex_init(&pvt->lock);
1138         /* Add to interface list */
1139         ast_mutex_lock(&iflock);
1140         pvt->next = iflist;
1141         iflist = pvt;
1142         ast_mutex_unlock(&iflock);
1143         return pvt;
1144 }
1145
1146 static struct oh323_pvt *find_call_locked(int call_reference, const char *token)
1147 {
1148         struct oh323_pvt *pvt;
1149
1150         ast_mutex_lock(&iflock);
1151         pvt = iflist;
1152         while(pvt) {
1153                 if (!pvt->needdestroy && ((signed int)pvt->cd.call_reference == call_reference)) {
1154                         /* Found the call */
1155                         if ((token != NULL) && (!strcmp(pvt->cd.call_token, token))) {
1156                                 ast_mutex_lock(&pvt->lock);
1157                                 ast_mutex_unlock(&iflock);
1158                                 return pvt;
1159                         } else if (token == NULL) {
1160                                 ast_log(LOG_WARNING, "Call Token is NULL\n");
1161                                 ast_mutex_lock(&pvt->lock);
1162                                 ast_mutex_unlock(&iflock);
1163                                 return pvt;
1164                         }
1165                 }
1166                 pvt = pvt->next;
1167         }
1168         ast_mutex_unlock(&iflock);
1169         return NULL;
1170 }
1171
1172 static int update_state(struct oh323_pvt *pvt, int state, int signal)
1173 {
1174         if (!pvt)
1175                 return 0;
1176         if (pvt->owner && !ast_channel_trylock(pvt->owner)) {
1177                 if (state >= 0)
1178                         ast_setstate(pvt->owner, state);
1179                 if (signal >= 0)
1180                         ast_queue_control(pvt->owner, signal);
1181                 ast_channel_unlock(pvt->owner);
1182                 return 1;
1183         }
1184         else {
1185                 if (state >= 0)
1186                         pvt->newstate = state;
1187                 if (signal >= 0)
1188                         pvt->newcontrol = signal;
1189                 return 0;
1190         }
1191 }
1192
1193 static struct oh323_alias *build_alias(const char *name, struct ast_variable *v, struct ast_variable *alt, int realtime)
1194 {
1195         struct oh323_alias *alias;
1196         int found = 0;
1197
1198         alias = ASTOBJ_CONTAINER_FIND_UNLINK_FULL(&aliasl, name, name, 0, 0, strcasecmp);
1199
1200         if (alias)
1201                 found++;
1202         else {
1203                 if (!(alias = ast_calloc(1, sizeof(*alias))))
1204                         return NULL;
1205                 ASTOBJ_INIT(alias);
1206         }
1207         if (!found && name)
1208                 ast_copy_string(alias->name, name, sizeof(alias->name));
1209         for (; v || ((v = alt) && !(alt = NULL)); v = v->next) {
1210                 if (!strcasecmp(v->name, "e164")) {
1211                         ast_copy_string(alias->e164, v->value, sizeof(alias->e164));
1212                 } else if (!strcasecmp(v->name, "prefix")) {
1213                         ast_copy_string(alias->prefix, v->value, sizeof(alias->prefix));
1214                 } else if (!strcasecmp(v->name, "context")) {
1215                         ast_copy_string(alias->context, v->value, sizeof(alias->context));
1216                 } else if (!strcasecmp(v->name, "secret")) {
1217                         ast_copy_string(alias->secret, v->value, sizeof(alias->secret));
1218                 } else {
1219                         if (strcasecmp(v->value, "h323")) {
1220                                 ast_log(LOG_WARNING, "Keyword %s does not make sense in type=h323\n", v->name);
1221                         }
1222                 }
1223         }
1224         ASTOBJ_UNMARK(alias);
1225         return alias;
1226 }
1227
1228 static struct oh323_alias *realtime_alias(const char *alias)
1229 {
1230         struct ast_variable *var, *tmp;
1231         struct oh323_alias *a;
1232
1233         var = ast_load_realtime("h323", "name", alias, NULL);
1234
1235         if (!var)
1236                 return NULL;
1237
1238         for (tmp = var; tmp; tmp = tmp->next) {
1239                 if (!strcasecmp(tmp->name, "type") &&
1240                 !(!strcasecmp(tmp->value, "alias") || !strcasecmp(tmp->value, "h323"))) {
1241                         ast_variables_destroy(var);
1242                         return NULL;
1243                 }
1244         }
1245
1246         a = build_alias(alias, var, NULL, 1);
1247
1248         ast_variables_destroy(var);
1249
1250         return a;
1251 }
1252
1253 static int update_common_options(struct ast_variable *v, struct call_options *options)
1254 {
1255         int tmp;
1256         char *val, *opt;
1257
1258         if (!strcasecmp(v->name, "allow")) {
1259                 ast_parse_allow_disallow(&options->prefs, &options->capability, v->value, 1);
1260         } else if (!strcasecmp(v->name, "disallow")) {
1261                 ast_parse_allow_disallow(&options->prefs, &options->capability, v->value, 0);
1262         } else if (!strcasecmp(v->name, "dtmfmode")) {
1263                 val = ast_strdupa(v->value);
1264                 if ((opt = strchr(val, ':')) != (char *)NULL) {
1265                         *opt++ = '\0';
1266                         tmp = atoi(opt);
1267                 }
1268                 if (!strcasecmp(v->value, "inband")) {
1269                         options->dtmfmode |= H323_DTMF_INBAND;
1270                 } else if (!strcasecmp(val, "rfc2833")) {
1271                         options->dtmfmode |= H323_DTMF_RFC2833;
1272                         if (!opt) {
1273                                 options->dtmfcodec[0] = H323_DTMF_RFC2833_PT;
1274                         } else if ((tmp >= 96) && (tmp < 128)) {
1275                                 options->dtmfcodec[0] = tmp;
1276                         } else {
1277                                 options->dtmfcodec[0] = H323_DTMF_RFC2833_PT;
1278                                 ast_log(LOG_WARNING, "Unknown rfc2833 payload %s specified at line %d, using default %d\n", opt, v->lineno, options->dtmfcodec[0]);
1279                         }
1280                 } else if (!strcasecmp(val, "cisco")) {
1281                         options->dtmfmode |= H323_DTMF_CISCO;
1282                         if (!opt) {
1283                                 options->dtmfcodec[1] = H323_DTMF_CISCO_PT;
1284                         } else if ((tmp >= 96) && (tmp < 128)) {
1285                                 options->dtmfcodec[1] = tmp;
1286                         } else {
1287                                 options->dtmfcodec[1] = H323_DTMF_CISCO_PT;
1288                                 ast_log(LOG_WARNING, "Unknown Cisco DTMF payload %s specified at line %d, using default %d\n", opt, v->lineno, options->dtmfcodec[1]);
1289                         }
1290                 } else if (!strcasecmp(v->value, "h245-signal")) {
1291                         options->dtmfmode |= H323_DTMF_SIGNAL;
1292                 } else {
1293                         ast_log(LOG_WARNING, "Unknown dtmf mode '%s' at line %d\n", v->value, v->lineno);
1294                 }
1295         } else if (!strcasecmp(v->name, "dtmfcodec")) {
1296                 ast_log(LOG_NOTICE, "Option %s at line %d is deprecated. Use dtmfmode=rfc2833[:<payload>] instead.\n", v->name, v->lineno);
1297                 tmp = atoi(v->value);
1298                 if (tmp < 96)
1299                         ast_log(LOG_WARNING, "Invalid %s value %s at line %d\n", v->name, v->value, v->lineno);
1300                 else
1301                         options->dtmfcodec[0] = tmp;
1302         } else if (!strcasecmp(v->name, "bridge")) {
1303                 options->bridge = ast_true(v->value);
1304         } else if (!strcasecmp(v->name, "nat")) {
1305                 options->nat = ast_true(v->value);
1306         } else if (!strcasecmp(v->name, "fastStart")) {
1307                 options->fastStart = ast_true(v->value);
1308         } else if (!strcasecmp(v->name, "h245Tunneling")) {
1309                 options->h245Tunneling = ast_true(v->value);
1310         } else if (!strcasecmp(v->name, "silenceSuppression")) {
1311                 options->silenceSuppression = ast_true(v->value);
1312         } else if (!strcasecmp(v->name, "progress_setup")) {
1313                 tmp = atoi(v->value);
1314                 if ((tmp != 0) && (tmp != 1) && (tmp != 3) && (tmp != 8)) {
1315                         ast_log(LOG_WARNING, "Invalid value %s for %s at line %d, assuming 0\n", v->value, v->name, v->lineno);
1316                         tmp = 0;
1317                 }
1318                 options->progress_setup = tmp;
1319         } else if (!strcasecmp(v->name, "progress_alert")) {
1320                 tmp = atoi(v->value);
1321                 if ((tmp != 0) && (tmp != 1) && (tmp != 8)) {
1322                         ast_log(LOG_WARNING, "Invalid value %s for %s at line %d, assuming 0\n", v->value, v->name, v->lineno);
1323                         tmp = 0;
1324                 }
1325                 options->progress_alert = tmp;
1326         } else if (!strcasecmp(v->name, "progress_audio")) {
1327                 options->progress_audio = ast_true(v->value);
1328         } else if (!strcasecmp(v->name, "callerid")) {
1329                 ast_callerid_split(v->value, options->cid_name, sizeof(options->cid_name), options->cid_num, sizeof(options->cid_num));
1330         } else if (!strcasecmp(v->name, "fullname")) {
1331                 ast_copy_string(options->cid_name, v->value, sizeof(options->cid_name));
1332         } else if (!strcasecmp(v->name, "cid_number")) {
1333                 ast_copy_string(options->cid_num, v->value, sizeof(options->cid_num));
1334         } else if (!strcasecmp(v->name, "tunneling")) {
1335                 if (!strcasecmp(v->value, "none"))
1336                         options->tunnelOptions = 0;
1337                 else if (!strcasecmp(v->value, "cisco"))
1338                         options->tunnelOptions |= H323_TUNNEL_CISCO;
1339                 else if (!strcasecmp(v->value, "qsig"))
1340                         options->tunnelOptions |= H323_TUNNEL_QSIG;
1341                 else
1342                         ast_log(LOG_WARNING, "Invalid value %s for %s at line %d\n", v->value, v->name, v->lineno);
1343         } else if (!strcasecmp(v->name, "hold")) {
1344                 if (!strcasecmp(v->value, "none"))
1345                         options->holdHandling = ~0;
1346                 else if (!strcasecmp(v->value, "notify"))
1347                         options->holdHandling |= H323_HOLD_NOTIFY;
1348                 else if (!strcasecmp(v->value, "q931only"))
1349                         options->holdHandling |= H323_HOLD_NOTIFY | H323_HOLD_Q931ONLY;
1350                 else if (!strcasecmp(v->value, "h450"))
1351                         options->holdHandling |= H323_HOLD_H450;
1352                 else
1353                         ast_log(LOG_WARNING, "Invalid value %s for %s at line %d\n", v->value, v->name, v->lineno);
1354         } else
1355                 return 1;
1356
1357         return 0;
1358 }
1359
1360 static struct oh323_user *build_user(const char *name, struct ast_variable *v, struct ast_variable *alt, int realtime)
1361 {
1362         struct oh323_user *user;
1363         struct ast_ha *oldha;
1364         int found = 0;
1365         int format;
1366
1367         user = ASTOBJ_CONTAINER_FIND_UNLINK_FULL(&userl, name, name, 0, 0, strcmp);
1368
1369         if (user)
1370                 found++;
1371         else {
1372                 if (!(user = ast_calloc(1, sizeof(*user))))
1373                         return NULL;
1374                 ASTOBJ_INIT(user);
1375         }
1376         oldha = user->ha;
1377         user->ha = (struct ast_ha *)NULL;
1378         memcpy(&user->options, &global_options, sizeof(user->options));
1379         user->options.dtmfmode = 0;
1380         user->options.holdHandling = 0;
1381         /* Set default context */
1382         ast_copy_string(user->context, default_context, sizeof(user->context));
1383         if (user && !found)
1384                 ast_copy_string(user->name, name, sizeof(user->name));
1385
1386 #if 0 /* XXX Port channel variables functionality from chan_sip XXX */
1387         if (user->chanvars) {
1388                 ast_variables_destroy(user->chanvars);
1389                 user->chanvars = NULL;
1390         }
1391 #endif
1392
1393         for (; v || ((v = alt) && !(alt = NULL)); v = v->next) {
1394                 if (!update_common_options(v, &user->options))
1395                         continue;
1396                 if (!strcasecmp(v->name, "context")) {
1397                         ast_copy_string(user->context, v->value, sizeof(user->context));
1398                 } else if (!strcasecmp(v->name, "secret")) {
1399                         ast_copy_string(user->secret, v->value, sizeof(user->secret));
1400                 } else if (!strcasecmp(v->name, "accountcode")) {
1401                         ast_copy_string(user->accountcode, v->value, sizeof(user->accountcode));
1402                 } else if (!strcasecmp(v->name, "host")) {
1403                         if (!strcasecmp(v->value, "dynamic")) {
1404                                 ast_log(LOG_ERROR, "A dynamic host on a type=user does not make any sense\n");
1405                                 ASTOBJ_UNREF(user, oh323_destroy_user);
1406                                 return NULL;
1407                         } else if (ast_get_ip(&user->addr, v->value)) {
1408                                 ASTOBJ_UNREF(user, oh323_destroy_user);
1409                                 return NULL;
1410                         }
1411                         /* Let us know we need to use ip authentication */
1412                         user->host = 1;
1413                 } else if (!strcasecmp(v->name, "amaflags")) {
1414                         format = ast_cdr_amaflags2int(v->value);
1415                         if (format < 0) {
1416                                 ast_log(LOG_WARNING, "Invalid AMA Flags: %s at line %d\n", v->value, v->lineno);
1417                         } else {
1418                                 user->amaflags = format;
1419                         }
1420                 } else if (!strcasecmp(v->name, "permit") ||
1421                                         !strcasecmp(v->name, "deny")) {
1422                         int ha_error = 0;
1423
1424                         user->ha = ast_append_ha(v->name, v->value, user->ha, &ha_error);
1425                         if (ha_error)
1426                                 ast_log(LOG_ERROR, "Bad ACL entry in configuration line %d : %s\n", v->lineno, v->value);
1427                 }
1428         }
1429         if (!user->options.dtmfmode)
1430                 user->options.dtmfmode = global_options.dtmfmode;
1431         if (user->options.holdHandling == ~0)
1432                 user->options.holdHandling = 0;
1433         else if (!user->options.holdHandling)
1434                 user->options.holdHandling = global_options.holdHandling;
1435         ASTOBJ_UNMARK(user);
1436         ast_free_ha(oldha);
1437         return user;
1438 }
1439
1440 static struct oh323_user *realtime_user(const call_details_t *cd)
1441 {
1442         struct ast_variable *var, *tmp;
1443         struct oh323_user *user;
1444         const char *username;
1445
1446         if (userbyalias)
1447                 var = ast_load_realtime("h323", "name", username = cd->call_source_aliases, NULL);
1448         else {
1449                 username = (char *)NULL;
1450                 var = ast_load_realtime("h323", "host", cd->sourceIp, NULL);
1451         }
1452
1453         if (!var)
1454                 return NULL;
1455
1456         for (tmp = var; tmp; tmp = tmp->next) {
1457                 if (!strcasecmp(tmp->name, "type") &&
1458                 !(!strcasecmp(tmp->value, "user") || !strcasecmp(tmp->value, "friend"))) {
1459                         ast_variables_destroy(var);
1460                         return NULL;
1461                 } else if (!username && !strcasecmp(tmp->name, "name"))
1462                         username = tmp->value;
1463         }
1464
1465         if (!username) {
1466                 ast_log(LOG_WARNING, "Cannot determine user name for IP address %s\n", cd->sourceIp);
1467                 ast_variables_destroy(var);
1468                 return NULL;
1469         }
1470
1471         user = build_user(username, var, NULL, 1);
1472
1473         ast_variables_destroy(var);
1474
1475         return user;
1476 }
1477
1478 static struct oh323_peer *build_peer(const char *name, struct ast_variable *v, struct ast_variable *alt, int realtime)
1479 {
1480         struct oh323_peer *peer;
1481         struct ast_ha *oldha;
1482         int found = 0;
1483
1484         peer = ASTOBJ_CONTAINER_FIND_UNLINK_FULL(&peerl, name, name, 0, 0, strcmp);
1485
1486         if (peer)
1487                 found++;
1488         else {
1489                 if (!(peer = ast_calloc(1, sizeof(*peer))))
1490                         return NULL;
1491                 ASTOBJ_INIT(peer);
1492         }
1493         oldha = peer->ha;
1494         peer->ha = NULL;
1495         memcpy(&peer->options, &global_options, sizeof(peer->options));
1496         peer->options.dtmfmode = 0;
1497         peer->options.holdHandling = 0;
1498         peer->addr.sin_port = htons(h323_signalling_port);
1499         peer->addr.sin_family = AF_INET;
1500         if (!found && name)
1501                 ast_copy_string(peer->name, name, sizeof(peer->name));
1502
1503 #if 0 /* XXX Port channel variables functionality from chan_sip XXX */
1504         if (peer->chanvars) {
1505                 ast_variables_destroy(peer->chanvars);
1506                 peer->chanvars = NULL;
1507         }
1508 #endif
1509         /* Default settings for mailbox */
1510         peer->mailbox[0] = '\0';
1511
1512         for (; v || ((v = alt) && !(alt = NULL)); v = v->next) {
1513                 if (!update_common_options(v, &peer->options))
1514                         continue;
1515                 if (!strcasecmp(v->name, "host")) {
1516                         if (!strcasecmp(v->value, "dynamic")) {
1517                                 ast_log(LOG_ERROR, "Dynamic host configuration not implemented.\n");
1518                                 ASTOBJ_UNREF(peer, oh323_destroy_peer);
1519                                 return NULL;
1520                         }
1521                         if (ast_get_ip(&peer->addr, v->value)) {
1522                                 ast_log(LOG_ERROR, "Could not determine IP for %s\n", v->value);
1523                                 ASTOBJ_UNREF(peer, oh323_destroy_peer);
1524                                 return NULL;
1525                         }
1526                 } else if (!strcasecmp(v->name, "port")) {
1527                         peer->addr.sin_port = htons(atoi(v->value));
1528                 } else if (!strcasecmp(v->name, "permit") ||
1529                                         !strcasecmp(v->name, "deny")) {
1530                         int ha_error = 0;
1531
1532                         peer->ha = ast_append_ha(v->name, v->value, peer->ha, &ha_error);
1533                         if (ha_error)
1534                                 ast_log(LOG_ERROR, "Bad ACL entry in configuration line %d : %s\n", v->lineno, v->value);
1535                 } else if (!strcasecmp(v->name, "mailbox")) {
1536                         ast_copy_string(peer->mailbox, v->value, sizeof(peer->mailbox));
1537                 }
1538         }
1539         if (!peer->options.dtmfmode)
1540                 peer->options.dtmfmode = global_options.dtmfmode;
1541         if (peer->options.holdHandling == ~0)
1542                 peer->options.holdHandling = 0;
1543         else if (!peer->options.holdHandling)
1544                 peer->options.holdHandling = global_options.holdHandling;
1545         ASTOBJ_UNMARK(peer);
1546         ast_free_ha(oldha);
1547         return peer;
1548 }
1549
1550 static struct oh323_peer *realtime_peer(const char *peername, struct sockaddr_in *sin)
1551 {
1552         struct oh323_peer *peer;
1553         struct ast_variable *var;
1554         struct ast_variable *tmp;
1555         const char *addr;
1556
1557         /* First check on peer name */
1558         if (peername)
1559                 var = ast_load_realtime("h323", "name", peername, addr = NULL);
1560         else if (sin) /* Then check on IP address for dynamic peers */
1561                 var = ast_load_realtime("h323", "host", addr = ast_inet_ntoa(sin->sin_addr), NULL);
1562         else
1563                 return NULL;
1564
1565         if (!var)
1566                 return NULL;
1567
1568         for (tmp = var; tmp; tmp = tmp->next) {
1569                 /* If this is type=user, then skip this object. */
1570                 if (!strcasecmp(tmp->name, "type") &&
1571                                 !(!strcasecmp(tmp->value, "peer") || !strcasecmp(tmp->value, "friend"))) {
1572                         ast_variables_destroy(var);
1573                         return NULL;
1574                 } else if (!peername && !strcasecmp(tmp->name, "name")) {
1575                         peername = tmp->value;
1576                 }
1577         }
1578
1579         if (!peername) {        /* Did not find peer in realtime */
1580                 ast_log(LOG_WARNING, "Cannot determine peer name for IP address %s\n", addr);
1581                 ast_variables_destroy(var);
1582                 return NULL;
1583         }
1584
1585         /* Peer found in realtime, now build it in memory */
1586         peer = build_peer(peername, var, NULL, 1);
1587
1588         ast_variables_destroy(var);
1589
1590         return peer;
1591 }
1592
1593 static int oh323_addrcmp_str(struct in_addr inaddr, char *addr)
1594 {
1595         return strcmp(ast_inet_ntoa(inaddr), addr);
1596 }
1597
1598 static struct oh323_user *find_user(const call_details_t *cd, int realtime)
1599 {
1600         struct oh323_user *u;
1601
1602         if (userbyalias)
1603                 u = ASTOBJ_CONTAINER_FIND(&userl, cd->call_source_aliases);
1604         else
1605                 u = ASTOBJ_CONTAINER_FIND_FULL(&userl, cd->sourceIp, addr.sin_addr, 0, 0, oh323_addrcmp_str);
1606
1607         if (!u && realtime)
1608                 u = realtime_user(cd);
1609
1610         if (!u && h323debug)
1611                 ast_debug(1, "Could not find user by name %s or address %s\n", cd->call_source_aliases, cd->sourceIp);
1612
1613         return u;
1614 }
1615
1616 static int oh323_addrcmp(struct sockaddr_in addr, struct sockaddr_in *sin)
1617 {
1618         int res;
1619
1620         if (!sin)
1621                 res = -1;
1622         else
1623                 res = inaddrcmp(&addr , sin);
1624
1625         return res;
1626 }
1627
1628 static struct oh323_peer *find_peer(const char *peer, struct sockaddr_in *sin, int realtime)
1629 {
1630         struct oh323_peer *p;
1631
1632         if (peer)
1633                 p = ASTOBJ_CONTAINER_FIND(&peerl, peer);
1634         else
1635                 p = ASTOBJ_CONTAINER_FIND_FULL(&peerl, sin, addr, 0, 0, oh323_addrcmp);
1636
1637         if (!p && realtime)
1638                 p = realtime_peer(peer, sin);
1639
1640         if (!p && h323debug)
1641                 ast_debug(1, "Could not find peer by name %s or address %s\n", (peer ? peer : "<NONE>"), (sin ? ast_inet_ntoa(sin->sin_addr) : "<NONE>"));
1642
1643         return p;
1644 }
1645
1646 static int create_addr(struct oh323_pvt *pvt, char *opeer)
1647 {
1648         struct hostent *hp;
1649         struct ast_hostent ahp;
1650         struct oh323_peer *p;
1651         int portno;
1652         int found = 0;
1653         char *port;
1654         char *hostn;
1655         char peer[256] = "";
1656
1657         ast_copy_string(peer, opeer, sizeof(peer));
1658         port = strchr(peer, ':');
1659         if (port) {
1660                 *port = '\0';
1661                 port++;
1662         }
1663         pvt->sa.sin_family = AF_INET;
1664         p = find_peer(peer, NULL, 1);
1665         if (p) {
1666                 found++;
1667                 memcpy(&pvt->options, &p->options, sizeof(pvt->options));
1668                 pvt->jointcapability = pvt->options.capability;
1669                 if (pvt->options.dtmfmode) {
1670                         if (pvt->options.dtmfmode & H323_DTMF_RFC2833) {
1671                                 pvt->nonCodecCapability |= AST_RTP_DTMF;
1672                         } else {
1673                                 pvt->nonCodecCapability &= ~AST_RTP_DTMF;
1674                         }
1675                 }
1676                 if (p->addr.sin_addr.s_addr) {
1677                         pvt->sa.sin_addr = p->addr.sin_addr;
1678                         pvt->sa.sin_port = p->addr.sin_port;
1679                 }
1680                 ASTOBJ_UNREF(p, oh323_destroy_peer);
1681         }
1682         if (!p && !found) {
1683                 hostn = peer;
1684                 if (port) {
1685                         portno = atoi(port);
1686                 } else {
1687                         portno = h323_signalling_port;
1688                 }
1689                 hp = ast_gethostbyname(hostn, &ahp);
1690                 if (hp) {
1691                         memcpy(&pvt->sa.sin_addr, hp->h_addr, sizeof(pvt->sa.sin_addr));
1692                         pvt->sa.sin_port = htons(portno);
1693                         /* Look peer by address */
1694                         p = find_peer(NULL, &pvt->sa, 1);
1695                         memcpy(&pvt->options, (p ? &p->options : &global_options), sizeof(pvt->options));
1696                         pvt->jointcapability = pvt->options.capability;
1697                         if (p) {
1698                                 ASTOBJ_UNREF(p, oh323_destroy_peer);
1699                         }
1700                         if (pvt->options.dtmfmode) {
1701                                 if (pvt->options.dtmfmode & H323_DTMF_RFC2833) {
1702                                         pvt->nonCodecCapability |= AST_RTP_DTMF;
1703                                 } else {
1704                                         pvt->nonCodecCapability &= ~AST_RTP_DTMF;
1705                                 }
1706                         }
1707                         return 0;
1708                 } else {
1709                         ast_log(LOG_WARNING, "No such host: %s\n", peer);
1710                         return -1;
1711                 }
1712         } else if (!found) {
1713                 return -1;
1714         } else {
1715                 return 0;
1716         }
1717 }
1718 static struct ast_channel *oh323_request(const char *type, int format, void *data, int *cause)
1719 {
1720         int oldformat;
1721         struct oh323_pvt *pvt;
1722         struct ast_channel *tmpc = NULL;
1723         char *dest = (char *)data;
1724         char *ext, *host;
1725         char *h323id = NULL;
1726         char tmp[256], tmp1[256];
1727
1728         if (h323debug)
1729                 ast_debug(1, "type=%s, format=%d, data=%s.\n", type, format, (char *)data);
1730
1731         pvt = oh323_alloc(0);
1732         if (!pvt) {
1733                 ast_log(LOG_WARNING, "Unable to build pvt data for '%s'\n", (char *)data);
1734                 return NULL;
1735         }
1736         oldformat = format;
1737         format &= AST_FORMAT_AUDIO_MASK;
1738         if (!format) {
1739                 ast_log(LOG_NOTICE, "Asked to get a channel of unsupported format '%d'\n", format);
1740                 oh323_destroy(pvt);
1741                 if (cause)
1742                         *cause = AST_CAUSE_INCOMPATIBLE_DESTINATION;
1743                 return NULL;
1744         }
1745         ast_copy_string(tmp, dest, sizeof(tmp));
1746         host = strchr(tmp, '@');
1747         if (host) {
1748                 *host = '\0';
1749                 host++;
1750                 ext = tmp;
1751         } else {
1752                 ext = strrchr(tmp, '/');
1753                 if (ext)
1754                         *ext++ = '\0';
1755                 host = tmp;
1756         }
1757         strtok_r(host, "/", &(h323id));
1758         if (!ast_strlen_zero(h323id)) {
1759                 h323_set_id(h323id);
1760         }
1761         if (ext) {
1762                 ast_copy_string(pvt->exten, ext, sizeof(pvt->exten));
1763         }
1764         if (h323debug)
1765                 ast_debug(1, "Extension: %s Host: %s\n", pvt->exten, host);
1766
1767         if (gatekeeper_disable) {
1768                 if (create_addr(pvt, host)) {
1769                         oh323_destroy(pvt);
1770                         if (cause)
1771                                 *cause = AST_CAUSE_DESTINATION_OUT_OF_ORDER;
1772                         return NULL;
1773                 }
1774         }
1775         else {
1776                 memcpy(&pvt->options, &global_options, sizeof(pvt->options));
1777                 pvt->jointcapability = pvt->options.capability;
1778                 if (pvt->options.dtmfmode) {
1779                         if (pvt->options.dtmfmode & H323_DTMF_RFC2833) {
1780                                 pvt->nonCodecCapability |= AST_RTP_DTMF;
1781                         } else {
1782                                 pvt->nonCodecCapability &= ~AST_RTP_DTMF;
1783                         }
1784                 }
1785         }
1786
1787         ast_mutex_lock(&caplock);
1788         /* Generate unique channel identifier */
1789         snprintf(tmp1, sizeof(tmp1)-1, "%s-%u", host, ++unique);
1790         tmp1[sizeof(tmp1)-1] = '\0';
1791         ast_mutex_unlock(&caplock);
1792
1793         ast_mutex_lock(&pvt->lock);
1794         tmpc = __oh323_new(pvt, AST_STATE_DOWN, tmp1);
1795         ast_mutex_unlock(&pvt->lock);
1796         if (!tmpc) {
1797                 oh323_destroy(pvt);
1798                 if (cause)
1799                         *cause = AST_CAUSE_NORMAL_TEMPORARY_FAILURE;
1800         }
1801         ast_update_use_count();
1802         restart_monitor();
1803         return tmpc;
1804 }
1805
1806 /*! \brief Find a call by alias */
1807 static struct oh323_alias *find_alias(const char *source_aliases, int realtime)
1808 {
1809         struct oh323_alias *a;
1810
1811         a = ASTOBJ_CONTAINER_FIND(&aliasl, source_aliases);
1812
1813         if (!a && realtime)
1814                 a = realtime_alias(source_aliases);
1815
1816         return a;
1817 }
1818
1819 /*! \brief
1820   * Callback for sending digits from H.323 up to asterisk
1821   *
1822   */
1823 static int receive_digit(unsigned call_reference, char digit, const char *token, int duration)
1824 {
1825         struct oh323_pvt *pvt;
1826         int res;
1827
1828         pvt = find_call_locked(call_reference, token);
1829         if (!pvt) {
1830                 ast_log(LOG_ERROR, "Received digit '%c' (%u ms) for call %s without private structure\n", digit, duration, token);
1831                 return -1;
1832         }
1833         if (h323debug)
1834                 ast_log(LOG_DTMF, "Received %s digit '%c' (%u ms) for call %s\n", (digit == ' ' ? "update for" : "new"), (digit == ' ' ? pvt->curDTMF : digit), duration, token);
1835
1836         if (pvt->owner && !ast_channel_trylock(pvt->owner)) {
1837                 if (digit == '!')
1838                         res = ast_queue_control(pvt->owner, AST_CONTROL_FLASH);
1839                 else {
1840                         struct ast_frame f = {
1841                                 .frametype = AST_FRAME_DTMF_END,
1842                                 .subclass = digit,
1843                                 .samples = duration * 8,
1844                                 .len = duration,
1845                                 .src = "SEND_DIGIT",
1846                         };
1847                         if (digit == ' ') {             /* signalUpdate message */
1848                                 f.subclass = pvt->curDTMF;
1849                                 if (pvt->DTMFsched >= 0) {
1850                                         ast_sched_del(sched, pvt->DTMFsched);
1851                                         pvt->DTMFsched = -1;
1852                                 }
1853                         } else {                                /* Regular input or signal message */
1854                                 if (pvt->DTMFsched >= 0) {
1855                                         /* We still don't send DTMF END from previous event, send it now */
1856                                         ast_sched_del(sched, pvt->DTMFsched);
1857                                         pvt->DTMFsched = -1;
1858                                         f.subclass = pvt->curDTMF;
1859                                         f.samples = f.len = 0;
1860                                         ast_queue_frame(pvt->owner, &f);
1861                                         /* Restore values */
1862                                         f.subclass = digit;
1863                                         f.samples = duration * 8;
1864                                         f.len = duration;
1865                                 }
1866                                 if (duration) {         /* This is a signal, signalUpdate follows */
1867                                         f.frametype = AST_FRAME_DTMF_BEGIN;
1868                                         pvt->DTMFsched = ast_sched_add(sched, duration, oh323_simulate_dtmf_end, pvt);
1869                                         if (h323debug)
1870                                                 ast_log(LOG_DTMF, "Scheduled DTMF END simulation for %d ms, id=%d\n", duration, pvt->DTMFsched);
1871                                 }
1872                                 pvt->curDTMF = digit;
1873                         }
1874                         res = ast_queue_frame(pvt->owner, &f);
1875                 }
1876                 ast_channel_unlock(pvt->owner);
1877         } else {
1878                 if (digit == '!')
1879                         pvt->newcontrol = AST_CONTROL_FLASH;
1880                 else {
1881                         pvt->newduration = duration;
1882                         pvt->newdigit = digit;
1883                 }
1884                 res = 0;
1885         }
1886         ast_mutex_unlock(&pvt->lock);
1887         return res;
1888 }
1889
1890 /*! \brief
1891   * Callback function used to inform the H.323 stack of the local rtp ip/port details
1892   *
1893   * \return Returns the local RTP information
1894   */
1895 static struct rtp_info *external_rtp_create(unsigned call_reference, const char * token)
1896 {
1897         struct oh323_pvt *pvt;
1898         struct sockaddr_in us;
1899         struct rtp_info *info;
1900
1901         info = ast_calloc(1, sizeof(*info));
1902         if (!info) {
1903                 ast_log(LOG_ERROR, "Unable to allocated info structure, this is very bad\n");
1904                 return NULL;
1905         }
1906         pvt = find_call_locked(call_reference, token);
1907         if (!pvt) {
1908                 ast_free(info);
1909                 ast_log(LOG_ERROR, "Unable to find call %s(%d)\n", token, call_reference);
1910                 return NULL;
1911         }
1912         if (!pvt->rtp)
1913                 __oh323_rtp_create(pvt);
1914         if (!pvt->rtp) {
1915                 ast_mutex_unlock(&pvt->lock);
1916                 ast_free(info);
1917                 ast_log(LOG_ERROR, "No RTP stream is available for call %s (%d)", token, call_reference);
1918                 return NULL;
1919         }
1920         /* figure out our local RTP port and tell the H.323 stack about it */
1921         ast_rtp_get_us(pvt->rtp, &us);
1922         ast_mutex_unlock(&pvt->lock);
1923
1924         ast_copy_string(info->addr, ast_inet_ntoa(us.sin_addr), sizeof(info->addr));
1925         info->port = ntohs(us.sin_port);
1926         if (h323debug)
1927                 ast_debug(1, "Sending RTP 'US' %s:%d\n", info->addr, info->port);
1928         return info;
1929 }
1930
1931 /* 
1932  * Definition taken from rtp.c for rtpPayloadType because we need it here.
1933  */
1934
1935 struct rtpPayloadType {
1936         int isAstFormat;        /* whether the following code is an AST_FORMAT */
1937         int code;
1938 };
1939
1940 /*! \brief
1941   * Call-back function passing remote ip/port information from H.323 to asterisk
1942   *
1943   * Returns nothing
1944   */
1945 static void setup_rtp_connection(unsigned call_reference, const char *remoteIp, int remotePort, const char *token, int pt)
1946 {
1947         struct oh323_pvt *pvt;
1948         struct sockaddr_in them;
1949         struct rtpPayloadType rtptype;
1950         int nativeformats_changed;
1951         enum { NEED_NONE, NEED_HOLD, NEED_UNHOLD } rtp_change = NEED_NONE;
1952
1953         if (h323debug)
1954                 ast_debug(1, "Setting up RTP connection for %s\n", token);
1955
1956         /* Find the call or allocate a private structure if call not found */
1957         pvt = find_call_locked(call_reference, token);
1958         if (!pvt) {
1959                 ast_log(LOG_ERROR, "Something is wrong: rtp\n");
1960                 return;
1961         }
1962         if (pvt->alreadygone) {
1963                 ast_mutex_unlock(&pvt->lock);
1964                 return;
1965         }
1966
1967         if (!pvt->rtp)
1968                 __oh323_rtp_create(pvt);
1969
1970         if ((pt == 2) && (pvt->jointcapability & AST_FORMAT_G726_AAL2)) {
1971                 ast_rtp_set_rtpmap_type(pvt->rtp, pt, "audio", "G726-32", AST_RTP_OPT_G726_NONSTANDARD);
1972         }
1973
1974         them.sin_family = AF_INET;
1975         /* only works for IPv4 */
1976         them.sin_addr.s_addr = inet_addr(remoteIp);
1977         them.sin_port = htons(remotePort);
1978
1979         if (them.sin_addr.s_addr) {
1980                 ast_rtp_set_peer(pvt->rtp, &them);
1981                 if (pvt->recvonly) {
1982                         pvt->recvonly = 0;
1983                         rtp_change = NEED_UNHOLD;
1984                 }
1985         } else {
1986                 ast_rtp_stop(pvt->rtp);
1987                 if (!pvt->recvonly) {
1988                         pvt->recvonly = 1;
1989                         rtp_change = NEED_HOLD;
1990                 }
1991         }
1992
1993         /* Change native format to reflect information taken from OLC/OLCAck */
1994         nativeformats_changed = 0;
1995         if (pt != 128 && pvt->rtp) {    /* Payload type is invalid, so try to use previously decided */
1996                 rtptype = ast_rtp_lookup_pt(pvt->rtp, pt);
1997                 if (h323debug)
1998                         ast_debug(1, "Native format is set to %d from %d by RTP payload type %d\n", rtptype.code, pvt->nativeformats, pt);
1999                 if (pvt->nativeformats != rtptype.code) {
2000                         pvt->nativeformats = rtptype.code;
2001                         nativeformats_changed = 1;
2002                 }
2003         } else if (h323debug)
2004                 ast_log(LOG_NOTICE, "Payload type is unknown, formats isn't changed\n");
2005
2006         /* Don't try to lock the channel if nothing changed */
2007         if (nativeformats_changed || pvt->options.progress_audio || (rtp_change != NEED_NONE)) {
2008                 if (pvt->owner && !ast_channel_trylock(pvt->owner)) {
2009                         /* Re-build translation path only if native format(s) has been changed */
2010                         if (pvt->owner->nativeformats != pvt->nativeformats) {
2011                                 if (h323debug)
2012                                         ast_debug(1, "Native format changed to %d from %d, read format is %d, write format is %d\n", pvt->nativeformats, pvt->owner->nativeformats, pvt->owner->readformat, pvt->owner->writeformat);
2013                                 pvt->owner->nativeformats = pvt->nativeformats;
2014                                 ast_set_read_format(pvt->owner, pvt->owner->readformat);
2015                                 ast_set_write_format(pvt->owner, pvt->owner->writeformat);
2016                         }
2017                         if (pvt->options.progress_audio)
2018                                 ast_queue_control(pvt->owner, AST_CONTROL_PROGRESS);
2019                         switch (rtp_change) {
2020                         case NEED_HOLD:
2021                                 ast_queue_control(pvt->owner, AST_CONTROL_HOLD);
2022                                 break;
2023                         case NEED_UNHOLD:
2024                                 ast_queue_control(pvt->owner, AST_CONTROL_UNHOLD);
2025                                 break;
2026                         default:
2027                                 break;
2028                         }
2029                         ast_channel_unlock(pvt->owner);
2030                 }
2031                 else {
2032                         if (pvt->options.progress_audio)
2033                                 pvt->newcontrol = AST_CONTROL_PROGRESS;
2034                         else if (rtp_change == NEED_HOLD)
2035                                 pvt->newcontrol = AST_CONTROL_HOLD;
2036                         else if (rtp_change == NEED_UNHOLD)
2037                                 pvt->newcontrol = AST_CONTROL_UNHOLD;
2038                         if (h323debug)
2039                                 ast_debug(1, "RTP connection preparation for %s is pending...\n", token);
2040                 }
2041         }
2042         ast_mutex_unlock(&pvt->lock);
2043
2044         if (h323debug)
2045                 ast_debug(1, "RTP connection prepared for %s\n", token);
2046
2047         return;
2048 }
2049
2050 /*! \brief
2051   *     Call-back function to signal asterisk that the channel has been answered
2052   * Returns nothing
2053   */
2054 static void connection_made(unsigned call_reference, const char *token)
2055 {
2056         struct oh323_pvt *pvt;
2057
2058         if (h323debug)
2059                 ast_debug(1, "Call %s answered\n", token);
2060
2061         pvt = find_call_locked(call_reference, token);
2062         if (!pvt) {
2063                 ast_log(LOG_ERROR, "Something is wrong: connection\n");
2064                 return;
2065         }
2066
2067         /* Inform asterisk about remote party connected only on outgoing calls */
2068         if (!pvt->outgoing) {
2069                 ast_mutex_unlock(&pvt->lock);
2070                 return;
2071         }
2072         /* Do not send ANSWER message more than once */
2073         if (!pvt->connection_established) {
2074                 pvt->connection_established = 1;
2075                 update_state(pvt, -1, AST_CONTROL_ANSWER);
2076         }
2077         ast_mutex_unlock(&pvt->lock);
2078         return;
2079 }
2080
2081 static int progress(unsigned call_reference, const char *token, int inband)
2082 {
2083         struct oh323_pvt *pvt;
2084
2085         if (h323debug)
2086                 ast_debug(1, "Received ALERT/PROGRESS message for %s tones\n", (inband ? "inband" : "self-generated"));
2087
2088         pvt = find_call_locked(call_reference, token);
2089         if (!pvt) {
2090                 ast_log(LOG_ERROR, "Private structure not found in progress.\n");
2091                 return -1;
2092         }
2093         if (!pvt->owner) {
2094                 ast_mutex_unlock(&pvt->lock);
2095                 ast_log(LOG_ERROR, "No Asterisk channel associated with private structure.\n");
2096                 return -1;
2097         }
2098         update_state(pvt, -1, (inband ? AST_CONTROL_PROGRESS : AST_CONTROL_RINGING));
2099         ast_mutex_unlock(&pvt->lock);
2100
2101         return 0;
2102 }
2103
2104 /*! \brief
2105  *  Call-back function for incoming calls
2106  *
2107  *  Returns 1 on success
2108  */
2109 static call_options_t *setup_incoming_call(call_details_t *cd)
2110 {
2111         struct oh323_pvt *pvt;
2112         struct oh323_user *user = NULL;
2113         struct oh323_alias *alias = NULL;
2114
2115         if (h323debug)
2116                 ast_debug(1, "Setting up incoming call for %s\n", cd->call_token);
2117
2118         /* allocate the call*/
2119         pvt = oh323_alloc(cd->call_reference);
2120
2121         if (!pvt) {
2122                 ast_log(LOG_ERROR, "Unable to allocate private structure, this is bad.\n");
2123                 cleanup_call_details(cd);
2124                 return NULL;
2125         }
2126
2127         /* Populate the call details in the private structure */
2128         memcpy(&pvt->cd, cd, sizeof(pvt->cd));
2129         memcpy(&pvt->options, &global_options, sizeof(pvt->options));
2130         pvt->jointcapability = pvt->options.capability;
2131
2132         if (h323debug) {
2133                 ast_verb(3, "Setting up Call\n");
2134                 ast_verb(3, " \tCall token:  [%s]\n", pvt->cd.call_token);
2135                 ast_verb(3, " \tCalling party name:  [%s]\n", pvt->cd.call_source_name);
2136                 ast_verb(3, " \tCalling party number:  [%s]\n", pvt->cd.call_source_e164);
2137                 ast_verb(3, " \tCalled party name:  [%s]\n", pvt->cd.call_dest_alias);
2138                 ast_verb(3, " \tCalled party number:  [%s]\n", pvt->cd.call_dest_e164);
2139                 if (pvt->cd.redirect_reason >= 0)
2140                         ast_verb(3, " \tRedirecting party number:  [%s] (reason %d)\n", pvt->cd.redirect_number, pvt->cd.redirect_reason);
2141                 ast_verb(3, " \tCalling party IP:  [%s]\n", pvt->cd.sourceIp);
2142         }
2143
2144         /* Decide if we are allowing Gatekeeper routed calls*/
2145         if ((!strcasecmp(cd->sourceIp, gatekeeper)) && (gkroute == -1) && !gatekeeper_disable) {
2146                 if (!ast_strlen_zero(cd->call_dest_e164)) {
2147                         ast_copy_string(pvt->exten, cd->call_dest_e164, sizeof(pvt->exten));
2148                         ast_copy_string(pvt->context, default_context, sizeof(pvt->context));
2149                 } else {
2150                         alias = find_alias(cd->call_dest_alias, 1);
2151                         if (!alias) {
2152                                 ast_log(LOG_ERROR, "Call for %s rejected, alias not found\n", cd->call_dest_alias);
2153                                 oh323_destroy(pvt);
2154                                 return NULL;
2155                         }
2156                         ast_copy_string(pvt->exten, alias->name, sizeof(pvt->exten));
2157                         ast_copy_string(pvt->context, alias->context, sizeof(pvt->context));
2158                 }
2159         } else {
2160                 /* Either this call is not from the Gatekeeper
2161                    or we are not allowing gk routed calls */
2162                 user = find_user(cd, 1);
2163                 if (!user) {
2164                         if (!acceptAnonymous) {
2165                                 ast_log(LOG_NOTICE, "Anonymous call from '%s@%s' rejected\n", pvt->cd.call_source_aliases, pvt->cd.sourceIp);
2166                                 oh323_destroy(pvt);
2167                                 return NULL;
2168                         }
2169                         if (ast_strlen_zero(default_context)) {
2170                                 ast_log(LOG_ERROR, "Call from '%s@%s' rejected due to no default context\n", pvt->cd.call_source_aliases, pvt->cd.sourceIp);
2171                                 oh323_destroy(pvt);
2172                                 return NULL;
2173                         }
2174                         ast_copy_string(pvt->context, default_context, sizeof(pvt->context));
2175                         if (!ast_strlen_zero(pvt->cd.call_dest_e164)) {
2176                                 ast_copy_string(pvt->exten, cd->call_dest_e164, sizeof(pvt->exten));
2177                         } else {
2178                                 ast_copy_string(pvt->exten, cd->call_dest_alias, sizeof(pvt->exten));
2179                         }
2180                         if (h323debug)
2181                                 ast_debug(1, "Sending %s@%s to context [%s] extension %s\n", cd->call_source_aliases, cd->sourceIp, pvt->context, pvt->exten);
2182                 } else {
2183                         if (user->host) {
2184                                 if (strcasecmp(cd->sourceIp, ast_inet_ntoa(user->addr.sin_addr))) {
2185                                         if (ast_strlen_zero(user->context)) {
2186                                                 if (ast_strlen_zero(default_context)) {
2187                                                         ast_log(LOG_ERROR, "Call from '%s' rejected due to non-matching IP address (%s) and no default context\n", user->name, cd->sourceIp);
2188                                                         oh323_destroy(pvt);
2189                                                         ASTOBJ_UNREF(user, oh323_destroy_user);
2190                                                         return NULL;
2191                                                 }
2192                                                 ast_copy_string(pvt->context, default_context, sizeof(pvt->context));
2193                                         } else {
2194                                                 ast_copy_string(pvt->context, user->context, sizeof(pvt->context));
2195                                         }
2196                                         pvt->exten[0] = 'i';
2197                                         pvt->exten[1] = '\0';
2198                                         ast_log(LOG_ERROR, "Call from '%s' rejected due to non-matching IP address (%s)s\n", user->name, cd->sourceIp);
2199                                         oh323_destroy(pvt);
2200                                         ASTOBJ_UNREF(user, oh323_destroy_user);
2201                                         return NULL;    /* XXX: Hmmm... Why to setup context if we drop connection immediately??? */
2202                                 }
2203                         }
2204                         ast_copy_string(pvt->context, user->context, sizeof(pvt->context));
2205                         memcpy(&pvt->options, &user->options, sizeof(pvt->options));
2206                         pvt->jointcapability = pvt->options.capability;
2207                         if (!ast_strlen_zero(pvt->cd.call_dest_e164)) {
2208                                 ast_copy_string(pvt->exten, cd->call_dest_e164, sizeof(pvt->exten));
2209                         } else {
2210                                 ast_copy_string(pvt->exten, cd->call_dest_alias, sizeof(pvt->exten));
2211                         }
2212                         if (!ast_strlen_zero(user->accountcode)) {
2213                                 ast_copy_string(pvt->accountcode, user->accountcode, sizeof(pvt->accountcode));
2214                         }
2215                         if (user->amaflags) {
2216                                 pvt->amaflags = user->amaflags;
2217                         }
2218                         ASTOBJ_UNREF(user, oh323_destroy_user);
2219                 }
2220         }
2221         return &pvt->options;
2222 }
2223
2224 /*! \brief
2225  * Call-back function to start PBX when OpenH323 ready to serve incoming call
2226  *
2227  * Returns 1 on success
2228  */
2229 static int answer_call(unsigned call_reference, const char *token)
2230 {
2231         struct oh323_pvt *pvt;
2232         struct ast_channel *c = NULL;
2233         enum {ext_original, ext_s, ext_i, ext_notexists} try_exten;
2234         char tmp_exten[sizeof(pvt->exten)];
2235
2236         if (h323debug)
2237                 ast_debug(1, "Preparing Asterisk to answer for %s\n", token);
2238
2239         /* Find the call or allocate a private structure if call not found */
2240         pvt = find_call_locked(call_reference, token);
2241         if (!pvt) {
2242                 ast_log(LOG_ERROR, "Something is wrong: answer_call\n");
2243                 return 0;
2244         }
2245         /* Check if requested extension@context pair exists in the dialplan */
2246         ast_copy_string(tmp_exten, pvt->exten, sizeof(tmp_exten));
2247
2248         /* Try to find best extension in specified context */
2249         if ((tmp_exten[0] != '\0') && (tmp_exten[1] == '\0')) {
2250                 if (tmp_exten[0] == 's')
2251                         try_exten = ext_s;
2252                 else if (tmp_exten[0] == 'i')
2253                         try_exten = ext_i;
2254                 else
2255                         try_exten = ext_original;
2256         } else
2257                 try_exten = ext_original;
2258         do {
2259                 if (ast_exists_extension(NULL, pvt->context, tmp_exten, 1, NULL))
2260                         break;
2261                 switch (try_exten) {
2262                 case ext_original:
2263                         tmp_exten[0] = 's';
2264                         tmp_exten[1] = '\0';
2265                         try_exten = ext_s;
2266                         break;
2267                 case ext_s:
2268                         tmp_exten[0] = 'i';
2269                         try_exten = ext_i;
2270                         break;
2271                 case ext_i:
2272                         try_exten = ext_notexists;
2273                         break;
2274                 default:
2275                         break;
2276                 }
2277         } while (try_exten != ext_notexists);
2278
2279         /* Drop the call if we don't have <exten>, s and i extensions */
2280         if (try_exten == ext_notexists) {
2281                 ast_log(LOG_NOTICE, "Dropping call because extensions '%s', 's' and 'i' doesn't exists in context [%s]\n", pvt->exten, pvt->context);
2282                 ast_mutex_unlock(&pvt->lock);
2283                 h323_clear_call(token, AST_CAUSE_UNALLOCATED);
2284                 return 0;
2285         } else if ((try_exten != ext_original) && (strcmp(pvt->exten, tmp_exten) != 0)) {
2286                 if (h323debug)
2287                         ast_debug(1, "Going to extension %s@%s because %s@%s isn't exists\n", tmp_exten, pvt->context, pvt->exten, pvt->context);
2288                 ast_copy_string(pvt->exten, tmp_exten, sizeof(pvt->exten));
2289         }
2290
2291         /* allocate a channel and tell asterisk about it */
2292         c = __oh323_new(pvt, AST_STATE_RINGING, pvt->cd.call_token);
2293
2294         /* And release when done */
2295         ast_mutex_unlock(&pvt->lock);
2296         if (!c) {
2297                 ast_log(LOG_ERROR, "Couldn't create channel. This is bad\n");
2298                 return 0;
2299         }
2300         return 1;
2301 }
2302
2303 /*! \brief
2304  * Call-back function to establish an outgoing H.323 call
2305  *
2306  * Returns 1 on success
2307  */
2308 static int setup_outgoing_call(call_details_t *cd)
2309 {
2310         /* Use argument here or free it immediately */
2311         cleanup_call_details(cd);
2312
2313         return 1;
2314 }
2315
2316 /*! \brief
2317   *  Call-back function to signal asterisk that the channel is ringing
2318   *  Returns nothing
2319   */
2320 static void chan_ringing(unsigned call_reference, const char *token)
2321 {
2322         struct oh323_pvt *pvt;
2323
2324         if (h323debug)
2325                 ast_debug(1, "Ringing on %s\n", token);
2326
2327         pvt = find_call_locked(call_reference, token);
2328         if (!pvt) {
2329                 ast_log(LOG_ERROR, "Something is wrong: ringing\n");
2330                 return;
2331         }
2332         if (!pvt->owner) {
2333                 ast_mutex_unlock(&pvt->lock);
2334                 ast_log(LOG_ERROR, "Channel has no owner\n");
2335                 return;
2336         }
2337         update_state(pvt, AST_STATE_RINGING, AST_CONTROL_RINGING);
2338         ast_mutex_unlock(&pvt->lock);
2339         return;
2340 }
2341
2342 /*! \brief
2343   * Call-back function to cleanup communication
2344   * Returns nothing,
2345   */
2346 static void cleanup_connection(unsigned call_reference, const char *call_token)
2347 {
2348         struct oh323_pvt *pvt;
2349
2350         if (h323debug)
2351                 ast_debug(1, "Cleaning connection to %s\n", call_token);
2352
2353         while (1) {
2354                 pvt = find_call_locked(call_reference, call_token);
2355                 if (!pvt) {
2356                         if (h323debug)
2357                                 ast_debug(1, "No connection for %s\n", call_token);
2358                         return;
2359                 }
2360                 if (!pvt->owner || !ast_channel_trylock(pvt->owner))
2361                         break;
2362 #if 1
2363                 ast_log(LOG_NOTICE, "Avoiding H.323 destory deadlock on %s\n", call_token);
2364 #ifdef DEBUG_THREADS
2365                 /* XXX to be completed
2366                  * If we want to print more info on who is holding the lock,
2367                  * implement the relevant code in lock.h and use the routines
2368                  * supplied there.
2369                  */
2370 #endif
2371 #endif
2372                 ast_mutex_unlock(&pvt->lock);
2373                 usleep(1);
2374         }
2375         if (pvt->rtp) {
2376                 /* Immediately stop RTP */
2377                 ast_rtp_destroy(pvt->rtp);
2378                 pvt->rtp = NULL;
2379         }
2380         /* Free dsp used for in-band DTMF detection */
2381         if (pvt->vad) {
2382                 ast_dsp_free(pvt->vad);
2383                 pvt->vad = NULL;
2384         }
2385         cleanup_call_details(&pvt->cd);
2386         pvt->alreadygone = 1;
2387         /* Send hangup */
2388         if (pvt->owner) {
2389                 pvt->owner->_softhangup |= AST_SOFTHANGUP_DEV;
2390                 ast_queue_hangup(pvt->owner);
2391                 ast_channel_unlock(pvt->owner);
2392         }
2393         ast_mutex_unlock(&pvt->lock);
2394         if (h323debug)
2395                 ast_debug(1, "Connection to %s cleaned\n", call_token);
2396         return;
2397 }
2398
2399 static void hangup_connection(unsigned int call_reference, const char *token, int cause)
2400 {
2401         struct oh323_pvt *pvt;
2402
2403         if (h323debug)
2404                 ast_debug(1, "Hanging up connection to %s with cause %d\n", token, cause);
2405
2406         pvt = find_call_locked(call_reference, token);
2407         if (!pvt) {
2408                 if (h323debug)
2409                         ast_debug(1, "Connection to %s already cleared\n", token);
2410                 return;
2411         }
2412         if (pvt->owner && !ast_channel_trylock(pvt->owner)) {
2413                 pvt->owner->_softhangup |= AST_SOFTHANGUP_DEV;
2414                 pvt->owner->hangupcause = pvt->hangupcause = cause;
2415                 ast_queue_hangup(pvt->owner);
2416                 ast_channel_unlock(pvt->owner);
2417         }
2418         else {
2419                 pvt->needhangup = 1;
2420                 pvt->hangupcause = cause;
2421                 if (h323debug)
2422                         ast_debug(1, "Hangup for %s is pending\n", token);
2423         }
2424         ast_mutex_unlock(&pvt->lock);
2425 }
2426
2427 static void set_dtmf_payload(unsigned call_reference, const char *token, int payload, int is_cisco)
2428 {
2429         struct oh323_pvt *pvt;
2430
2431         if (h323debug)
2432                 ast_debug(1, "Setting %s DTMF payload to %d on %s\n", (is_cisco ? "Cisco" : "RFC2833"), payload, token);
2433
2434         pvt = find_call_locked(call_reference, token);
2435         if (!pvt) {
2436                 return;
2437         }
2438         if (pvt->rtp) {
2439                 ast_rtp_set_rtpmap_type(pvt->rtp, payload, "audio", (is_cisco ? "cisco-telephone-event" : "telephone-event"), 0);
2440         }
2441         pvt->dtmf_pt[is_cisco ? 1 : 0] = payload;
2442         ast_mutex_unlock(&pvt->lock);
2443         if (h323debug)
2444                 ast_debug(1, "DTMF payload on %s set to %d\n", token, payload);
2445 }
2446
2447 static void set_peer_capabilities(unsigned call_reference, const char *token, int capabilities, struct ast_codec_pref *prefs)
2448 {
2449         struct oh323_pvt *pvt;
2450
2451         if (h323debug)
2452                 ast_debug(1, "Got remote capabilities from connection %s\n", token);
2453
2454         pvt = find_call_locked(call_reference, token);
2455         if (!pvt)
2456                 return;
2457         pvt->peercapability = capabilities;
2458         pvt->jointcapability = pvt->options.capability & capabilities;
2459         if (prefs) {
2460                 memcpy(&pvt->peer_prefs, prefs, sizeof(pvt->peer_prefs));
2461                 if (h323debug) {
2462                         int i;
2463                         for (i = 0; i < 32; ++i) {
2464                                 if (!prefs->order[i])
2465                                         break;
2466                                 ast_debug(1, "prefs[%d]=%s:%d\n", i, (prefs->order[i] ? ast_getformatname(1 << (prefs->order[i]-1)) : "<none>"), prefs->framing[i]);
2467                         }
2468                 }
2469                 if (pvt->rtp)
2470                         ast_rtp_codec_setpref(pvt->rtp, &pvt->peer_prefs);
2471         }
2472         ast_mutex_unlock(&pvt->lock);
2473 }
2474
2475 static void set_local_capabilities(unsigned call_reference, const char *token)
2476 {
2477         struct oh323_pvt *pvt;
2478         int capability, dtmfmode, pref_codec;
2479         struct ast_codec_pref prefs;
2480
2481         if (h323debug)
2482                 ast_debug(1, "Setting capabilities for connection %s\n", token);
2483
2484         pvt = find_call_locked(call_reference, token);
2485         if (!pvt)
2486                 return;
2487         capability = (pvt->jointcapability) ? pvt->jointcapability : pvt->options.capability;
2488         dtmfmode = pvt->options.dtmfmode;
2489         prefs = pvt->options.prefs;
2490         pref_codec = pvt->pref_codec;
2491         ast_mutex_unlock(&pvt->lock);
2492         h323_set_capabilities(token, capability, dtmfmode, &prefs, pref_codec);
2493
2494         if (h323debug)
2495                 ast_debug(1, "Capabilities for connection %s is set\n", token);
2496 }
2497
2498 static void remote_hold(unsigned call_reference, const char *token, int is_hold)
2499 {
2500         struct oh323_pvt *pvt;
2501
2502         if (h323debug)
2503                 ast_debug(1, "Setting %shold status for connection %s\n", (is_hold ? "" : "un"), token);
2504
2505         pvt = find_call_locked(call_reference, token);
2506         if (!pvt)
2507                 return;
2508         if (pvt->owner && !ast_channel_trylock(pvt->owner)) {
2509                 if (is_hold)
2510                         ast_queue_control(pvt->owner, AST_CONTROL_HOLD);
2511                 else
2512                         ast_queue_control(pvt->owner, AST_CONTROL_UNHOLD);
2513                 ast_channel_unlock(pvt->owner);
2514         }
2515         else {
2516                 if (is_hold)
2517                         pvt->newcontrol = AST_CONTROL_HOLD;
2518                 else
2519                         pvt->newcontrol = AST_CONTROL_UNHOLD;
2520         }
2521         ast_mutex_unlock(&pvt->lock);
2522 }
2523
2524 static void *do_monitor(void *data)
2525 {
2526         int res;
2527         int reloading;
2528         struct oh323_pvt *oh323 = NULL;
2529
2530         for(;;) {
2531                 /* Check for a reload request */
2532                 ast_mutex_lock(&h323_reload_lock);
2533                 reloading = h323_reloading;
2534                 h323_reloading = 0;
2535                 ast_mutex_unlock(&h323_reload_lock);
2536                 if (reloading) {
2537                         ast_verb(1, "Reloading H.323\n");
2538                         h323_do_reload();
2539                 }
2540                 /* Check for interfaces needing to be killed */
2541                 if (!ast_mutex_trylock(&iflock)) {
2542 #if 1
2543                         do {
2544                                 for (oh323 = iflist; oh323; oh323 = oh323->next) {
2545                                         if (!ast_mutex_trylock(&oh323->lock)) {
2546                                                 if (oh323->needdestroy) {
2547                                                         __oh323_destroy(oh323);
2548                                                         break;
2549                                                 }
2550                                                 ast_mutex_unlock(&oh323->lock);
2551                                         }
2552                                 }
2553                         } while (/*oh323*/ 0);
2554 #else
2555 restartsearch:
2556                         oh323 = iflist;
2557                         while(oh323) {
2558                                 if (!ast_mutex_trylock(&oh323->lock)) {
2559                                         if (oh323->needdestroy) {
2560                                                 __oh323_destroy(oh323);
2561                                                 goto restartsearch;
2562                                         }
2563                                         ast_mutex_unlock(&oh323->lock);
2564                                         oh323 = oh323->next;
2565                                 }
2566                         }
2567 #endif
2568                         ast_mutex_unlock(&iflock);
2569                 } else
2570                         oh323 = (struct oh323_pvt *)1;  /* Force fast loop */
2571                 pthread_testcancel();
2572                 /* Wait for sched or io */
2573                 res = ast_sched_wait(sched);
2574                 if ((res < 0) || (res > 1000)) {
2575                         res = 1000;
2576                 }
2577                 /* Do not wait if some channel(s) is destroyed, probably, more available too */
2578                 if (oh323)
2579                         res = 1;
2580                 res = ast_io_wait(io, res);
2581                 pthread_testcancel();
2582                 ast_mutex_lock(&monlock);
2583                 if (res >= 0) {
2584                         ast_sched_runq(sched);
2585                 }
2586                 ast_mutex_unlock(&monlock);
2587         }
2588         /* Never reached */
2589         return NULL;
2590 }
2591
2592 static int restart_monitor(void)
2593 {
2594         /* If we're supposed to be stopped -- stay stopped */
2595         if (ast_mutex_lock(&monlock)) {
2596                 ast_log(LOG_WARNING, "Unable to lock monitor\n");
2597                 return -1;
2598         }
2599         if (monitor_thread == AST_PTHREADT_STOP) {
2600                 ast_mutex_unlock(&monlock);
2601                 return 0;
2602         }
2603         if (monitor_thread == pthread_self()) {
2604                 ast_mutex_unlock(&monlock);
2605                 ast_log(LOG_WARNING, "Cannot kill myself\n");
2606                 return -1;
2607         }
2608         if (monitor_thread && (monitor_thread != AST_PTHREADT_NULL)) {
2609                 /* Wake up the thread */
2610                 pthread_kill(monitor_thread, SIGURG);
2611         } else {
2612                 /* Start a new monitor */
2613                 if (ast_pthread_create_detached_background(&monitor_thread, NULL, do_monitor, NULL) < 0) {
2614                         monitor_thread = AST_PTHREADT_NULL;
2615                         ast_mutex_unlock(&monlock);
2616                         ast_log(LOG_ERROR, "Unable to start monitor thread.\n");
2617                         return -1;
2618                 }
2619         }
2620         ast_mutex_unlock(&monlock);
2621         return 0;
2622 }
2623
2624 static char *handle_cli_h323_set_trace(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
2625 {
2626         switch (cmd) {
2627         case CLI_INIT:
2628                 e->command = "h323 set trace [off]";
2629                 e->usage =
2630                         "Usage: h323 set trace (off|<trace level>)\n"
2631                         "       Enable/Disable H.323 stack tracing for debugging purposes\n";
2632                 return NULL;
2633         case CLI_GENERATE:
2634                 return NULL;
2635         }
2636
2637         if (a->argc != 4)
2638                 return CLI_SHOWUSAGE;
2639         if (!strcasecmp(a->argv[3], "off")) {
2640                 h323_debug(0, 0);
2641                 ast_cli(a->fd, "H.323 Trace Disabled\n");
2642         } else {
2643                 int tracelevel = atoi(a->argv[3]);
2644                 h323_debug(1, tracelevel);
2645                 ast_cli(a->fd, "H.323 Trace Enabled (Trace Level: %d)\n", tracelevel);
2646         }
2647         return CLI_SUCCESS;
2648 }
2649
2650 static char *handle_cli_h323_set_debug(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
2651 {
2652         switch (cmd) {
2653         case CLI_INIT:
2654                 e->command = "h323 set debug [off]";
2655                 e->usage =
2656                         "Usage: h323 set debug [off]\n"
2657                         "       Enable/Disable H.323 debugging output\n";
2658                 return NULL;
2659         case CLI_GENERATE:
2660                 return NULL;
2661         }
2662
2663         if (a->argc < 3 || a->argc > 4)
2664                 return CLI_SHOWUSAGE;
2665         if (a->argc == 4 && strcasecmp(a->argv[3], "off"))
2666                 return CLI_SHOWUSAGE;
2667
2668         h323debug = (a->argc == 3) ? 1 : 0;
2669         ast_cli(a->fd, "H.323 Debugging %s\n", h323debug ? "Enabled" : "Disabled");
2670         return CLI_SUCCESS;
2671 }
2672
2673 static char *handle_cli_h323_cycle_gk(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
2674 {
2675         switch (cmd) {
2676         case CLI_INIT:
2677                 e->command = "h323 cycle gk";
2678                 e->usage =
2679                         "Usage: h323 cycle gk\n"
2680                         "       Manually re-register with the Gatekeper (Currently Disabled)\n";
2681                 return NULL;
2682         case CLI_GENERATE:
2683                 return NULL;
2684         }
2685
2686         if (a->argc != 3)
2687                 return CLI_SHOWUSAGE;
2688
2689         h323_gk_urq();
2690
2691         /* Possibly register with a GK */
2692         if (!gatekeeper_disable) {
2693                 if (h323_set_gk(gatekeeper_discover, gatekeeper, secret)) {
2694                         ast_log(LOG_ERROR, "Gatekeeper registration failed.\n");
2695                 }
2696         }
2697         return CLI_SUCCESS;
2698 }
2699
2700 static char *handle_cli_h323_hangup(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
2701 {
2702         switch (cmd) {
2703         case CLI_INIT:
2704                 e->command = "h323 hangup";
2705                 e->usage =
2706                         "Usage: h323 hangup <token>\n"
2707                         "       Manually try to hang up the call identified by <token>\n";
2708                 return NULL;
2709         case CLI_GENERATE:
2710                 return NULL;
2711         }
2712
2713         if (a->argc != 3)
2714                 return CLI_SHOWUSAGE;
2715         if (h323_soft_hangup(a->argv[2])) {
2716                 ast_verb(3, "Hangup succeeded on %s\n", a->argv[2]);
2717         } else {
2718                 ast_verb(3, "Hangup failed for %s\n", a->argv[2]);
2719         }
2720         return CLI_SUCCESS;
2721 }
2722
2723 static char *handle_cli_h323_show_tokens(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
2724 {
2725         switch (cmd) {
2726         case CLI_INIT:
2727                 e->command = "h323 show tokens";
2728                 e->usage =
2729                         "Usage: h323 show tokens\n"
2730                         "       Print out all active call tokens\n";
2731                 return NULL;
2732         case CLI_GENERATE:
2733                 return NULL;
2734         }
2735
2736         if (a->argc != 3)
2737                 return CLI_SHOWUSAGE;
2738
2739         h323_show_tokens();
2740
2741         return CLI_SUCCESS;
2742 }
2743
2744 static struct ast_cli_entry cli_h323[] = {
2745         AST_CLI_DEFINE(handle_cli_h323_set_trace,   "Enable/Disable H.323 Stack Tracing"),
2746         AST_CLI_DEFINE(handle_cli_h323_set_debug,   "Enable/Disable H.323 Debugging"),
2747         AST_CLI_DEFINE(handle_cli_h323_cycle_gk,    "Manually re-register with the Gatekeper"),
2748         AST_CLI_DEFINE(handle_cli_h323_hangup,      "Manually try to hang up a call"),
2749         AST_CLI_DEFINE(handle_cli_h323_show_tokens, "Show all active call tokens"),
2750 };
2751
2752 static void delete_users(void)
2753 {
2754         int pruned = 0;
2755
2756         /* Delete all users */
2757         ASTOBJ_CONTAINER_WRLOCK(&userl);
2758         ASTOBJ_CONTAINER_TRAVERSE(&userl, 1, do {
2759                 ASTOBJ_RDLOCK(iterator);
2760                 ASTOBJ_MARK(iterator);
2761                 ++pruned;
2762                 ASTOBJ_UNLOCK(iterator);
2763         } while (0) );
2764         if (pruned) {
2765                 ASTOBJ_CONTAINER_PRUNE_MARKED(&userl, oh323_destroy_user);
2766         }
2767         ASTOBJ_CONTAINER_UNLOCK(&userl);
2768
2769         ASTOBJ_CONTAINER_WRLOCK(&peerl);
2770         ASTOBJ_CONTAINER_TRAVERSE(&peerl, 1, do {
2771                 ASTOBJ_RDLOCK(iterator);
2772                 ASTOBJ_MARK(iterator);
2773                 ASTOBJ_UNLOCK(iterator);
2774         } while (0) );
2775         ASTOBJ_CONTAINER_UNLOCK(&peerl);
2776 }
2777
2778 static void delete_aliases(void)
2779 {
2780         int pruned = 0;
2781
2782         /* Delete all aliases */
2783         ASTOBJ_CONTAINER_WRLOCK(&aliasl);
2784         ASTOBJ_CONTAINER_TRAVERSE(&aliasl, 1, do {
2785                 ASTOBJ_RDLOCK(iterator);
2786                 ASTOBJ_MARK(iterator);
2787                 ++pruned;
2788                 ASTOBJ_UNLOCK(iterator);
2789         } while (0) );
2790         if (pruned) {
2791                 ASTOBJ_CONTAINER_PRUNE_MARKED(&aliasl, oh323_destroy_alias);
2792         }
2793         ASTOBJ_CONTAINER_UNLOCK(&aliasl);
2794 }
2795
2796 static void prune_peers(void)
2797 {
2798         /* Prune peers who still are supposed to be deleted */
2799         ASTOBJ_CONTAINER_PRUNE_MARKED(&peerl, oh323_destroy_peer);
2800 }
2801
2802 static int reload_config(int is_reload)
2803 {
2804         struct ast_config *cfg, *ucfg;
2805         struct ast_variable *v;
2806         struct oh323_peer *peer = NULL;
2807         struct oh323_user *user = NULL;
2808         struct oh323_alias *alias = NULL;
2809         struct ast_hostent ahp; struct hostent *hp;
2810         char *cat;
2811         const char *utype;
2812         int is_user, is_peer, is_alias;
2813         char _gatekeeper[100];
2814         int gk_discover, gk_disable, gk_changed;
2815         struct ast_flags config_flags = { is_reload ? CONFIG_FLAG_FILEUNCHANGED : 0 };
2816
2817         cfg = ast_config_load(config, config_flags);
2818
2819         /* We *must* have a config file otherwise stop immediately */
2820         if (!cfg) {
2821                 ast_log(LOG_NOTICE, "Unable to load config %s, H.323 disabled\n", config);
2822                 return 1;
2823         } else if (cfg == CONFIG_STATUS_FILEUNCHANGED) {
2824                 ucfg = ast_config_load("users.conf", config_flags);
2825                 if (ucfg == CONFIG_STATUS_FILEUNCHANGED)
2826                         return 0;
2827                 ast_clear_flag(&config_flags, CONFIG_FLAG_FILEUNCHANGED);
2828                 cfg = ast_config_load(config, config_flags);
2829         } else {
2830                 ast_clear_flag(&config_flags, CONFIG_FLAG_FILEUNCHANGED);
2831                 ucfg = ast_config_load("users.conf", config_flags);
2832         }
2833
2834         if (is_reload) {
2835                 delete_users();
2836                 delete_aliases();
2837                 prune_peers();
2838         }
2839
2840         /* fire up the H.323 Endpoint */
2841         if (!h323_end_point_exist()) {
2842                 h323_end_point_create();
2843         }
2844         ast_copy_string(_gatekeeper, gatekeeper, sizeof(_gatekeeper));
2845         gk_discover = gatekeeper_discover;
2846         gk_disable = gatekeeper_disable;
2847         memset(&bindaddr, 0, sizeof(bindaddr));
2848         memset(&global_options, 0, sizeof(global_options));
2849         global_options.fastStart = 1;
2850         global_options.h245Tunneling = 1;
2851         global_options.dtmfcodec[0] = H323_DTMF_RFC2833_PT;
2852         global_options.dtmfcodec[1] = H323_DTMF_CISCO_PT;
2853         global_options.dtmfmode = 0;
2854         global_options.holdHandling = 0;
2855         global_options.capability = GLOBAL_CAPABILITY;
2856         global_options.bridge = 1;              /* Do native bridging by default */
2857         strcpy(default_context, "default");
2858         h323_signalling_port = 1720;
2859         gatekeeper_disable = 1;
2860         gatekeeper_discover = 0;
2861         gkroute = 0;
2862         userbyalias = 1;
2863         acceptAnonymous = 1;
2864         tos = 0;
2865         cos = 0;
2866
2867         /* Copy the default jb config over global_jbconf */
2868         memcpy(&global_jbconf, &default_jbconf, sizeof(struct ast_jb_conf));
2869
2870         if (ucfg) {
2871                 struct ast_variable *gen;
2872                 int genhas_h323;
2873                 const char *has_h323;
2874
2875                 genhas_h323 = ast_true(ast_variable_retrieve(ucfg, "general", "hash323"));
2876                 gen = ast_variable_browse(ucfg, "general");
2877                 for (cat = ast_category_browse(ucfg, NULL); cat; cat = ast_category_browse(ucfg, cat)) {
2878                         if (strcasecmp(cat, "general")) {
2879                                 has_h323 = ast_variable_retrieve(ucfg, cat, "hash323");
2880                                 if (ast_true(has_h323) || (!has_h323 && genhas_h323)) {
2881                                         user = build_user(cat, gen, ast_variable_browse(ucfg, cat), 0);
2882                                         if (user) {
2883                                                 ASTOBJ_CONTAINER_LINK(&userl, user);
2884                                                 ASTOBJ_UNREF(user, oh323_destroy_user);
2885                                         }
2886                                         peer = build_peer(cat, gen, ast_variable_browse(ucfg, cat), 0);
2887                                         if (peer) {
2888                                                 ASTOBJ_CONTAINER_LINK(&peerl, peer);
2889                                                 ASTOBJ_UNREF(peer, oh323_destroy_peer);
2890                                         }
2891                                 }
2892                         }
2893                 }
2894                 ast_config_destroy(ucfg);
2895         }
2896
2897         for (v = ast_variable_browse(cfg, "general"); v; v = v->next) {
2898                 /* handle jb conf */
2899                 if (!ast_jb_read_conf(&global_jbconf, v->name, v->value))
2900                         continue;
2901                 /* Create the interface list */
2902                 if (!strcasecmp(v->name, "port")) {
2903                         h323_signalling_port = (int)strtol(v->value, NULL, 10);
2904                 } else if (!strcasecmp(v->name, "bindaddr")) {
2905                         if (!(hp = ast_gethostbyname(v->value, &ahp))) {
2906                                 ast_log(LOG_WARNING, "Invalid address: %s\n", v->value);
2907                         } else {
2908                                 memcpy(&bindaddr.sin_addr, hp->h_addr, sizeof(bindaddr.sin_addr));
2909                         }
2910                 } else if (!strcasecmp(v->name, "tos")) {       /* Needs to be removed in next release */
2911                         ast_log(LOG_WARNING, "The \"tos\" setting is deprecated in this version of Asterisk. Please change to \"tos_audio\".\n");
2912                         if (ast_str2tos(v->value, &tos)) {
2913                                 ast_log(LOG_WARNING, "Invalid tos_audio value at line %d, refer to QoS documentation\n", v->lineno);                    
2914                         }
2915                 } else if (!strcasecmp(v->name, "tos_audio")) {
2916                         if (ast_str2tos(v->value, &tos)) {
2917                                 ast_log(LOG_WARNING, "Invalid tos_audio value at line %d, refer to QoS documentation\n", v->lineno);                    
2918                         }
2919                 } else if (!strcasecmp(v->name, "cos")) {
2920                         ast_log(LOG_WARNING, "The \"cos\" setting is deprecated in this version of Asterisk. Please change to \"cos_audio\".\n");
2921                         if (ast_str2cos(v->value, &cos)) {
2922                                 ast_log(LOG_WARNING, "Invalid cos_audio value at line %d, refer to QoS documentation\n", v->lineno);                    
2923                         }
2924                 } else if (!strcasecmp(v->name, "cos_audio")) {
2925                         if (ast_str2cos(v->value, &cos)) {
2926                                 ast_log(LOG_WARNING, "Invalid cos_audio value at line %d, refer to QoS documentation\n", v->lineno);                    
2927                         }
2928                 } else if (!strcasecmp(v->name, "gatekeeper")) {
2929                         if (!strcasecmp(v->value, "DISABLE")) {
2930                                 gatekeeper_disable = 1;
2931                         } else if (!strcasecmp(v->value, "DISCOVER")) {
2932                                 gatekeeper_disable = 0;
2933                                 gatekeeper_discover = 1;
2934                         } else {
2935                                 gatekeeper_disable = 0;
2936                                 ast_copy_string(gatekeeper, v->value, sizeof(gatekeeper));
2937                         }
2938                 } else if (!strcasecmp(v->name, "secret")) {
2939                         ast_copy_string(secret, v->value, sizeof(secret));
2940                 } else if (!strcasecmp(v->name, "AllowGKRouted")) {
2941                         gkroute = ast_true(v->value);
2942                 } else if (!strcasecmp(v->name, "context")) {
2943                         ast_copy_string(default_context, v->value, sizeof(default_context));
2944                         ast_verb(2, "Setting default context to %s\n", default_context);
2945                 } else if (!strcasecmp(v->name, "UserByAlias")) {
2946                         userbyalias = ast_true(v->value);
2947                 } else if (!strcasecmp(v->name, "AcceptAnonymous")) {
2948                         acceptAnonymous = ast_true(v->value);
2949                 } else if (!update_common_options(v, &global_options)) {
2950                         /* dummy */
2951                 }
2952         }
2953         if (!global_options.dtmfmode)
2954                 global_options.dtmfmode = H323_DTMF_RFC2833;
2955         if (global_options.holdHandling == ~0)
2956                 global_options.holdHandling = 0;
2957         else if (!global_options.holdHandling)
2958                 global_options.holdHandling = H323_HOLD_H450;
2959
2960         for (cat = ast_category_browse(cfg, NULL); cat; cat = ast_category_browse(cfg, cat)) {
2961                 if (strcasecmp(cat, "general")) {
2962                         utype = ast_variable_retrieve(cfg, cat, "type");
2963                         if (utype) {
2964                                 is_user = is_peer = is_alias = 0;
2965                                 if (!strcasecmp(utype, "user"))
2966                                         is_user = 1;
2967                                 else if (!strcasecmp(utype, "peer"))
2968                                         is_peer = 1;
2969                                 else if (!strcasecmp(utype, "friend"))
2970                                         is_user = is_peer = 1;
2971                                 else if (!strcasecmp(utype, "h323") || !strcasecmp(utype, "alias"))
2972                                         is_alias = 1;
2973                                 else {
2974                                         ast_log(LOG_WARNING, "Unknown type '%s' for '%s' in %s\n", utype, cat, config);
2975                                         continue;
2976                                 }
2977                                 if (is_user) {
2978                                         user = build_user(cat, ast_variable_browse(cfg, cat), NULL, 0);
2979                                         if (user) {
2980                                                 ASTOBJ_CONTAINER_LINK(&userl, user);
2981                                                 ASTOBJ_UNREF(user, oh323_destroy_user);
2982                                         }
2983                                 }
2984                                 if (is_peer) {
2985                                         peer = build_peer(cat, ast_variable_browse(cfg, cat), NULL, 0);
2986                                         if (peer) {
2987                                                 ASTOBJ_CONTAINER_LINK(&peerl, peer);
2988                                                 ASTOBJ_UNREF(peer, oh323_destroy_peer);
2989                                         }
2990                                 }
2991                                 if (is_alias) {
2992                                         alias = build_alias(cat, ast_variable_browse(cfg, cat), NULL, 0);
2993                                         if (alias) {
2994                                                 ASTOBJ_CONTAINER_LINK(&aliasl, alias);
2995                                                 ASTOBJ_UNREF(alias, oh323_destroy_alias);
2996                                         }
2997                                 }
2998                         } else {
2999                                 ast_log(LOG_WARNING, "Section '%s' lacks type\n", cat);
3000                         }
3001                 }
3002         }
3003         ast_config_destroy(cfg);
3004
3005         /* Register our H.323 aliases if any*/
3006         ASTOBJ_CONTAINER_WRLOCK(&aliasl);
3007         ASTOBJ_CONTAINER_TRAVERSE(&aliasl, 1, do {
3008                 ASTOBJ_RDLOCK(iterator);
3009                 if (h323_set_alias(iterator)) {
3010                         ast_log(LOG_ERROR, "Alias %s rejected by endpoint\n", alias->name);
3011                         ASTOBJ_UNLOCK(iterator);
3012                         continue;
3013                 }
3014                 ASTOBJ_UNLOCK(iterator);
3015         } while (0) );
3016         ASTOBJ_CONTAINER_UNLOCK(&aliasl);
3017
3018         /* Don't touch GK if nothing changed because URQ will drop all existing calls */
3019         gk_changed = 0;
3020         if (gatekeeper_disable != gk_disable)
3021                 gk_changed = is_reload;
3022         else if(!gatekeeper_disable && (gatekeeper_discover != gk_discover))
3023                 gk_changed = is_reload;
3024         else if(!gatekeeper_disable && (strncmp(_gatekeeper, gatekeeper, sizeof(_gatekeeper)) != 0))
3025                 gk_changed = is_reload;
3026         if (gk_changed) {
3027                 if(!gk_disable)
3028                         h323_gk_urq();
3029                 if (!gatekeeper_disable) {
3030                         if (h323_set_gk(gatekeeper_discover, gatekeeper, secret)) {
3031                                 ast_log(LOG_ERROR, "Gatekeeper registration failed.\n");
3032                                 gatekeeper_disable = 1;
3033                         }
3034                 }
3035         }
3036         return 0;
3037 }
3038
3039 static int h323_reload(void)
3040 {
3041         ast_mutex_lock(&h323_reload_lock);
3042         if (h323_reloading) {
3043                 ast_verbose("Previous H.323 reload not yet done\n");
3044         } else {
3045                 h323_reloading = 1;
3046         }
3047         ast_mutex_unlock(&h323_reload_lock);
3048         restart_monitor();
3049         return 0;
3050 }
3051
3052 static char *handle_cli_h323_reload(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
3053 {
3054         switch (cmd) {
3055         case CLI_INIT:
3056                 e->command = "h323 reload";
3057                 e->usage =
3058                         "Usage: h323 reload\n"
3059                         "       Reloads H.323 configuration from h323.conf\n";
3060                 return NULL;
3061         case CLI_GENERATE:
3062                 return NULL;
3063         }
3064
3065         if (a->argc != 2)
3066                 return CLI_SHOWUSAGE;
3067
3068         h323_reload();
3069
3070         return CLI_SUCCESS;
3071 }
3072
3073 static int h323_do_reload(void)
3074 {
3075         reload_config(1);
3076         return 0;
3077 }
3078
3079 static int reload(void)
3080 {
3081         if (!sched || !io) {
3082                 ast_log(LOG_NOTICE, "Unload and load chan_h323.so again in order to receive configuration changes.\n");
3083                 return 0;
3084         }
3085         return h323_reload();
3086 }
3087
3088 static struct ast_cli_entry cli_h323_reload =
3089         AST_CLI_DEFINE(handle_cli_h323_reload, "Reload H.323 configuration");
3090
3091 static enum ast_rtp_get_result oh323_get_rtp_peer(struct ast_channel *chan, struct ast_rtp **rtp)
3092 {
3093         struct oh323_pvt *pvt;
3094         enum ast_rtp_get_result res = AST_RTP_GET_FAILED;
3095
3096         if (!(pvt = (struct oh323_pvt *)chan->tech_pvt))
3097                 return res;
3098
3099         ast_mutex_lock(&pvt->lock);
3100         if (pvt->rtp && pvt->options.bridge) {
3101                 *rtp = pvt->rtp;
3102                 res = AST_RTP_TRY_NATIVE;
3103         }
3104         ast_mutex_unlock(&pvt->lock);
3105
3106         return res;
3107 }
3108
3109 static enum ast_rtp_get_result oh323_get_vrtp_peer(struct ast_channel *chan, struct ast_rtp **rtp)
3110 {
3111         return AST_RTP_GET_FAILED;
3112 }
3113
3114 static char *convertcap(int cap)
3115 {
3116         switch (cap) {
3117         case AST_FORMAT_G723_1:
3118                 return "G.723";
3119         case AST_FORMAT_GSM:
3120                 return "GSM";
3121         case AST_FORMAT_ULAW:
3122                 return "ULAW";
3123         case AST_FORMAT_ALAW:
3124                 return "ALAW";
3125         case AST_FORMAT_G722:
3126                 return "G.722";
3127         case AST_FORMAT_ADPCM:
3128                 return "G.728";
3129         case AST_FORMAT_G729A:
3130                 return "G.729";
3131         case AST_FORMAT_SPEEX:
3132                 return "SPEEX";
3133         case AST_FORMAT_ILBC:
3134                 return "ILBC";
3135         default:
3136                 ast_log(LOG_NOTICE, "Don't know how to deal with mode %d\n", cap);
3137                 return NULL;
3138         }
3139 }
3140
3141 static int oh323_set_rtp_peer(struct ast_channel *chan, struct ast_rtp *rtp, struct ast_rtp *vrtp, struct ast_rtp *trtp, int codecs, int nat_active)
3142 {
3143         /* XXX Deal with Video */
3144         struct oh323_pvt *pvt;
3145         struct sockaddr_in them;
3146         struct sockaddr_in us;
3147         char *mode;
3148
3149         if (!rtp) {
3150                 return 0;
3151         }
3152
3153         mode = convertcap(chan->writeformat);
3154         pvt = (struct oh323_pvt *) chan->tech_pvt;
3155         if (!pvt) {
3156                 ast_log(LOG_ERROR, "No Private Structure, this is bad\n");
3157                 return -1;
3158         }
3159         ast_rtp_get_peer(rtp, &them);
3160         ast_rtp_get_us(rtp, &us);
3161 #if 0   /* Native bridge still isn't ready */
3162         h323_native_bridge(pvt->cd.call_token, ast_inet_ntoa(them.sin_addr), mode);
3163 #endif
3164         return 0;
3165 }
3166
3167 static struct ast_rtp_protocol oh323_rtp = {
3168         .type = "H323",
3169         .get_rtp_info = oh323_get_rtp_peer,
3170         .get_vrtp_info = oh323_get_vrtp_peer,
3171         .set_rtp_peer = oh323_set_rtp_peer,
3172 };
3173
3174 static enum ast_module_load_result load_module(void)
3175 {
3176         int res;
3177
3178         h323debug = 0;
3179         sched = sched_context_create();
3180         if (!sched) {
3181                 ast_log(LOG_WARNING, "Unable to create schedule context\n");
3182                 return AST_MODULE_LOAD_FAILURE;
3183         }
3184         io = io_context_create();
3185         if (!io) {
3186                 ast_log(LOG_WARNING, "Unable to create I/O context\n");
3187                 return AST_MODULE_LOAD_FAILURE;
3188         }
3189         ast_cli_register(&cli_h323_reload);
3190         ASTOBJ_CONTAINER_INIT(&userl);
3191         ASTOBJ_CONTAINER_INIT(&peerl);
3192         ASTOBJ_CONTAINER_INIT(&aliasl);
3193         res = reload_config(0);
3194         if (res) {
3195                 /* No config entry */
3196                 ast_log(LOG_NOTICE, "Unload and load chan_h323.so again in order to receive configuration changes.\n");
3197                 ast_cli_unregister(&cli_h323_reload);
3198                 io_context_destroy(io);
3199                 io = NULL;
3200                 sched_context_destroy(sched);
3201                 sched = NULL;
3202                 ASTOBJ_CONTAINER_DESTROY(&userl);
3203                 ASTOBJ_CONTAINER_DESTROY(&peerl);
3204                 ASTOBJ_CONTAINER_DESTROY(&aliasl);
3205                 return AST_MODULE_LOAD_DECLINE;
3206         } else {
3207                 /* Make sure we can register our channel type */
3208                 if (ast_channel_register(&oh323_tech)) {
3209                         ast_log(LOG_ERROR, "Unable to register channel class 'H323'\n");
3210                         ast_cli_unregister(&cli_h323_reload);
3211                         h323_end_process();
3212                         io_context_destroy(io);
3213                         sched_context_destroy(sched);
3214
3215                         ASTOBJ_CONTAINER_DESTROYALL(&userl, oh323_destroy_user);
3216                         ASTOBJ_CONTAINER_DESTROY(&userl);
3217                         ASTOBJ_CONTAINER_DESTROYALL(&peerl, oh323_destroy_peer);
3218                         ASTOBJ_CONTAINER_DESTROY(&peerl);
3219                         ASTOBJ_CONTAINER_DESTROYALL(&aliasl, oh323_destroy_alias);
3220                         ASTOBJ_CONTAINER_DESTROY(&aliasl);
3221
3222                         return AST_MODULE_LOAD_FAILURE;
3223                 }
3224                 ast_cli_register_multiple(cli_h323, sizeof(cli_h323) / sizeof(struct ast_cli_entry));
3225
3226                 ast_rtp_proto_register(&oh323_rtp);
3227
3228                 /* Register our callback functions */
3229                 h323_callback_register(setup_incoming_call,
3230                                                 setup_outgoing_call,
3231                                                 external_rtp_create,
3232                                                 setup_rtp_connection,
3233                                                 cleanup_connection,
3234                                                 chan_ringing,
3235                                                 connection_made,
3236                                                 receive_digit,
3237                                                 answer_call,
3238                                                 progress,
3239                                                 set_dtmf_payload,
3240                                                 hangup_connection,
3241                                                 set_local_capabilities,
3242                                                 set_peer_capabilities,
3243                                                 remote_hold);
3244                 /* start the h.323 listener */
3245                 if (h323_start_listener(h323_signalling_port, bindaddr)) {
3246                         ast_log(LOG_ERROR, "Unable to create H323 listener.\n");
3247                         ast_rtp_proto_unregister(&oh323_rtp);
3248                         ast_cli_unregister_multiple(cli_h323, sizeof(cli_h323) / sizeof(struct ast_cli_entry));
3249                         ast_cli_unregister(&cli_h323_reload);
3250                         h323_end_process();
3251                         io_context_destroy(io);
3252                         sched_context_destroy(sched);
3253
3254                         ASTOBJ_CONTAINER_DESTROYALL(&userl, oh323_destroy_user);
3255                         ASTOBJ_CONTAINER_DESTROY(&userl);
3256                         ASTOBJ_CONTAINER_DESTROYALL(&peerl, oh323_destroy_peer);
3257                         ASTOBJ_CONTAINER_DESTROY(&peerl);
3258                         ASTOBJ_CONTAINER_DESTROYALL(&aliasl, oh323_destroy_alias);
3259                         ASTOBJ_CONTAINER_DESTROY(&aliasl);
3260
3261                         return AST_MODULE_LOAD_FAILURE;
3262                 }
3263                 /* Possibly register with a GK */
3264                 if (!gatekeeper_disable) {
3265                         if (h323_set_gk(gatekeeper_discover, gatekeeper, secret)) {
3266                                 ast_log(LOG_ERROR, "Gatekeeper registration failed.\n");
3267                                 gatekeeper_disable = 1;
3268                                 res = AST_MODULE_LOAD_SUCCESS;
3269                         }
3270                 }
3271                 /* And start the monitor for the first time */
3272                 restart_monitor();
3273         }
3274         return res;
3275 }
3276
3277 static int unload_module(void)
3278 {
3279         struct oh323_pvt *p, *pl;
3280
3281         /* unregister commands */
3282         ast_cli_unregister_multiple(cli_h323, sizeof(cli_h323) / sizeof(struct ast_cli_entry));
3283         ast_cli_unregister(&cli_h323_reload);
3284
3285         ast_channel_unregister(&oh323_tech);
3286         ast_rtp_proto_unregister(&oh323_rtp);
3287
3288         if (!ast_mutex_lock(&iflock)) {
3289                 /* hangup all interfaces if they have an owner */
3290                 p = iflist;
3291                 while(p) {
3292                         if (p->owner) {
3293                                 ast_softhangup(p->owner, AST_SOFTHANGUP_APPUNLOAD);
3294                         }
3295                         p = p->next;
3296                 }
3297                 iflist = NULL;
3298                 ast_mutex_unlock(&iflock);
3299         } else {
3300                 ast_log(LOG_WARNING, "Unable to lock the interface list\n");
3301                 return -1;
3302         }
3303         if (!ast_mutex_lock(&monlock)) {
3304                 if ((monitor_thread != AST_PTHREADT_STOP) && (monitor_thread != AST_PTHREADT_NULL)) {
3305                         /* this causes a seg, anyone know why? */
3306                         if (monitor_thread != pthread_self())
3307                                 pthread_cancel(monitor_thread);
3308                         pthread_kill(monitor_thread, SIGURG);
3309                         pthread_join(monitor_thread, NULL);
3310                 }
3311                 monitor_thread = AST_PTHREADT_STOP;
3312                 ast_mutex_unlock(&monlock);
3313         } else {
3314                 ast_log(LOG_WARNING, "Unable to lock the monitor\n");
3315                 return -1;
3316         }
3317         if (!ast_mutex_lock(&iflock)) {
3318                 /* destroy all the interfaces and free their memory */
3319                 p = iflist;
3320                 while(p) {
3321                         pl = p;
3322                         p = p->next;
3323                         /* free associated memory */
3324                         ast_mutex_destroy(&pl->lock);
3325                         ast_free(pl);
3326                 }
3327                 iflist = NULL;
3328                 ast_mutex_unlock(&iflock);
3329         } else {
3330                 ast_log(LOG_WARNING, "Unable to lock the interface list\n");
3331                 return -1;
3332         }
3333         if (!gatekeeper_disable)
3334                 h323_gk_urq();
3335         h323_end_process();
3336         if (io)
3337                 io_context_destroy(io);
3338         if (sched)
3339                 sched_context_destroy(sched);
3340
3341         ASTOBJ_CONTAINER_DESTROYALL(&userl, oh323_destroy_user);
3342         ASTOBJ_CONTAINER_DESTROY(&userl);
3343         ASTOBJ_CONTAINER_DESTROYALL(&peerl, oh323_destroy_peer);
3344         ASTOBJ_CONTAINER_DESTROY(&peerl);
3345         ASTOBJ_CONTAINER_DESTROYALL(&aliasl, oh323_destroy_alias);
3346         ASTOBJ_CONTAINER_DESTROY(&aliasl);
3347
3348         return 0;
3349 }
3350
3351 AST_MODULE_INFO(ASTERISK_GPL_KEY, AST_MODFLAG_DEFAULT, "The NuFone Network's OpenH323 Channel Driver",
3352                 .load = load_module,
3353                 .unload = unload_module,
3354                 .reload = reload,
3355 );