00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032
00033
00034 #include <sys/socket.h>
00035 #include <sys/signal.h>
00036 #include <sys/param.h>
00037 #if defined(BSD)
00038 #ifndef IPTOS_MINCOST
00039 #define IPTOS_MINCOST 0x02
00040 #endif
00041 #endif
00042 #include <arpa/inet.h>
00043 #include <net/if.h>
00044 #include <netinet/in.h>
00045 #include <netinet/in_systm.h>
00046 #include <netinet/ip.h>
00047 #include <unistd.h>
00048 #include <stdlib.h>
00049 #include <netdb.h>
00050 #include <stdio.h>
00051 #include <string.h>
00052 #include <errno.h>
00053 #include <fcntl.h>
00054 #ifdef __cplusplus
00055 extern "C" {
00056 #endif
00057
00058 #include "asterisk.h"
00059
00060 ASTERISK_FILE_VERSION(__FILE__, "$Revision: 36725 $")
00061
00062 #include "asterisk/lock.h"
00063 #include "asterisk/logger.h"
00064 #include "asterisk/channel.h"
00065 #include "asterisk/config.h"
00066 #include "asterisk/module.h"
00067 #include "asterisk/pbx.h"
00068 #include "asterisk/options.h"
00069 #include "asterisk/utils.h"
00070 #include "asterisk/lock.h"
00071 #include "asterisk/sched.h"
00072 #include "asterisk/io.h"
00073 #include "asterisk/rtp.h"
00074 #include "asterisk/acl.h"
00075 #include "asterisk/callerid.h"
00076 #include "asterisk/cli.h"
00077 #include "asterisk/dsp.h"
00078 #include "asterisk/causes.h"
00079 #ifdef __cplusplus
00080 }
00081 #endif
00082 #include "h323/chan_h323.h"
00083
00084 send_digit_cb on_send_digit;
00085 on_rtp_cb on_external_rtp_create;
00086 start_rtp_cb on_start_rtp_channel;
00087 setup_incoming_cb on_incoming_call;
00088 setup_outbound_cb on_outgoing_call;
00089 chan_ringing_cb on_chan_ringing;
00090 con_established_cb on_connection_established;
00091 clear_con_cb on_connection_cleared;
00092 answer_call_cb on_answer_call;
00093 progress_cb on_progress;
00094 rfc2833_cb on_set_rfc2833_payload;
00095 hangup_cb on_hangup;
00096 setcapabilities_cb on_setcapabilities;
00097
00098
00099 int h323debug;
00100
00101
00102 static const char type[] = "H323";
00103 static const char desc[] = "The NuFone Network's Open H.323 Channel Driver";
00104 static const char tdesc[] = "The NuFone Network's Open H.323 Channel Driver";
00105 static const char config[] = "h323.conf";
00106 static char default_context[AST_MAX_CONTEXT] = "default";
00107 static struct sockaddr_in bindaddr;
00108
00109
00110 static int h323_signalling_port = 1720;
00111 static char gatekeeper[100];
00112 static int gatekeeper_disable = 1;
00113 static int gatekeeper_discover = 0;
00114 static int usingGk = 0;
00115 static int gkroute = 0;
00116
00117 static int userbyalias = 1;
00118 static int tos = 0;
00119 static char secret[50];
00120 static unsigned int unique = 0;
00121
00122 static call_options_t global_options;
00123
00124
00125 struct oh323_pvt {
00126 ast_mutex_t lock;
00127 call_options_t options;
00128 int alreadygone;
00129 int needdestroy;
00130 call_details_t cd;
00131 struct ast_channel *owner;
00132 struct sockaddr_in sa;
00133 struct sockaddr_in redirip;
00134 int nonCodecCapability;
00135 int outgoing;
00136 char exten[AST_MAX_EXTENSION];
00137 char context[AST_MAX_CONTEXT];
00138 char accountcode[256];
00139 char cid_num[80];
00140 char cid_name[80];
00141 char rdnis[80];
00142 int amaflags;
00143 struct ast_rtp *rtp;
00144 struct ast_dsp *vad;
00145 int nativeformats;
00146 int needhangup;
00147 int hangupcause;
00148 int newstate;
00149 int newcontrol;
00150 struct oh323_pvt *next;
00151 } *iflist = NULL;
00152
00153 static struct ast_user_list {
00154 struct oh323_user *users;
00155 ast_mutex_t lock;
00156 } userl;
00157
00158 static struct ast_peer_list {
00159 struct oh323_peer *peers;
00160 ast_mutex_t lock;
00161 } peerl;
00162
00163 static struct ast_alias_list {
00164 struct oh323_alias *aliases;
00165 ast_mutex_t lock;
00166 } aliasl;
00167
00168
00169 static struct sched_context *sched;
00170 static struct io_context *io;
00171
00172
00173 AST_MUTEX_DEFINE_STATIC(iflock);
00174
00175
00176 static int usecnt = 0;
00177 AST_MUTEX_DEFINE_STATIC(usecnt_lock);
00178
00179
00180
00181 AST_MUTEX_DEFINE_STATIC(monlock);
00182
00183
00184 AST_MUTEX_DEFINE_STATIC(caplock);
00185
00186
00187 AST_MUTEX_DEFINE_STATIC(h323_reload_lock);
00188 static int h323_reloading = 0;
00189
00190
00191
00192 static pthread_t monitor_thread = AST_PTHREADT_NULL;
00193 static int restart_monitor(void);
00194 static int h323_do_reload(void);
00195
00196 static struct ast_channel *oh323_request(const char *type, int format, void *data, int *cause);
00197 static int oh323_digit(struct ast_channel *c, char digit);
00198 static int oh323_call(struct ast_channel *c, char *dest, int timeout);
00199 static int oh323_hangup(struct ast_channel *c);
00200 static int oh323_answer(struct ast_channel *c);
00201 static struct ast_frame *oh323_read(struct ast_channel *c);
00202 static int oh323_write(struct ast_channel *c, struct ast_frame *frame);
00203 static int oh323_indicate(struct ast_channel *c, int condition);
00204 static int oh323_fixup(struct ast_channel *oldchan, struct ast_channel *newchan);
00205
00206 static const struct ast_channel_tech oh323_tech = {
00207 .type = type,
00208 .description = tdesc,
00209 .capabilities = AST_FORMAT_ULAW,
00210 .properties = AST_CHAN_TP_WANTSJITTER,
00211 .requester = oh323_request,
00212 .send_digit = oh323_digit,
00213 .call = oh323_call,
00214 .hangup = oh323_hangup,
00215 .answer = oh323_answer,
00216 .read = oh323_read,
00217 .write = oh323_write,
00218 .indicate = oh323_indicate,
00219 .fixup = oh323_fixup,
00220
00221 #if 0
00222 .bridge = ast_rtp_bridge,
00223 #endif
00224 };
00225
00226
00227 static void __oh323_update_info(struct ast_channel *c, struct oh323_pvt *pvt)
00228 {
00229 if (c->nativeformats != pvt->nativeformats) {
00230 if (h323debug)
00231 ast_log(LOG_DEBUG, "Preparing %s for new native format\n", c->name);
00232 c->nativeformats = pvt->nativeformats;
00233 ast_set_read_format(c, c->readformat);
00234 ast_set_write_format(c, c->writeformat);
00235 }
00236 if (pvt->needhangup) {
00237 if (h323debug)
00238 ast_log(LOG_DEBUG, "Process pending hangup for %s\n", c->name);
00239 c->_softhangup |= AST_SOFTHANGUP_DEV;
00240 c->hangupcause = pvt->hangupcause;
00241 ast_queue_hangup(c);
00242 pvt->needhangup = 0;
00243 pvt->newstate = pvt->newcontrol = -1;
00244 }
00245 if (pvt->newstate >= 0) {
00246 ast_setstate(c, pvt->newstate);
00247 pvt->newstate = -1;
00248 }
00249 if (pvt->newcontrol >= 0) {
00250 ast_queue_control(c, pvt->newcontrol);
00251 pvt->newcontrol = -1;
00252 }
00253 }
00254
00255
00256 static void oh323_update_info(struct ast_channel *c)
00257 {
00258 struct oh323_pvt *pvt = c->tech_pvt;
00259
00260 if (pvt) {
00261 ast_mutex_lock(&pvt->lock);
00262 __oh323_update_info(c, pvt);
00263 ast_mutex_unlock(&pvt->lock);
00264 }
00265 }
00266
00267 static void cleanup_call_details(call_details_t *cd)
00268 {
00269 if (cd->call_token) {
00270 free(cd->call_token);
00271 cd->call_token = NULL;
00272 }
00273 if (cd->call_source_aliases) {
00274 free(cd->call_source_aliases);
00275 cd->call_source_aliases = NULL;
00276 }
00277 if (cd->call_dest_alias) {
00278 free(cd->call_dest_alias);
00279 cd->call_dest_alias = NULL;
00280 }
00281 if (cd->call_source_name) {
00282 free(cd->call_source_name);
00283 cd->call_source_name = NULL;
00284 }
00285 if (cd->call_source_e164) {
00286 free(cd->call_source_e164);
00287 cd->call_source_e164 = NULL;
00288 }
00289 if (cd->call_dest_e164) {
00290 free(cd->call_dest_e164);
00291 cd->call_dest_e164 = NULL;
00292 }
00293 if (cd->sourceIp) {
00294 free(cd->sourceIp);
00295 cd->sourceIp = NULL;
00296 }
00297 }
00298
00299 static void __oh323_destroy(struct oh323_pvt *pvt)
00300 {
00301 struct oh323_pvt *cur, *prev = NULL;
00302
00303 if (pvt->rtp) {
00304 ast_rtp_destroy(pvt->rtp);
00305 }
00306
00307
00308 if (pvt->vad) {
00309 ast_dsp_free(pvt->vad);
00310 }
00311 cleanup_call_details(&pvt->cd);
00312
00313
00314 if (pvt->owner) {
00315 ast_mutex_lock(&pvt->owner->lock);
00316 ast_log(LOG_DEBUG, "Detaching from %s\n", pvt->owner->name);
00317 pvt->owner->tech_pvt = NULL;
00318 ast_mutex_unlock(&pvt->owner->lock);
00319 }
00320 cur = iflist;
00321 while(cur) {
00322 if (cur == pvt) {
00323 if (prev)
00324 prev->next = cur->next;
00325 else
00326 iflist = cur->next;
00327 break;
00328 }
00329 prev = cur;
00330 cur = cur->next;
00331 }
00332 if (!cur) {
00333 ast_log(LOG_WARNING, "%p is not in list?!?! \n", cur);
00334 } else {
00335 ast_mutex_destroy(&pvt->lock);
00336 free(pvt);
00337 }
00338 }
00339
00340 static void oh323_destroy(struct oh323_pvt *pvt)
00341 {
00342 ast_mutex_lock(&iflock);
00343 __oh323_destroy(pvt);
00344 ast_mutex_unlock(&iflock);
00345 }
00346
00347
00348
00349
00350
00351 static int oh323_digit(struct ast_channel *c, char digit)
00352 {
00353 struct oh323_pvt *pvt = (struct oh323_pvt *) c->tech_pvt;
00354 char *token;
00355
00356 if (!pvt) {
00357 ast_log(LOG_ERROR, "No private structure?! This is bad\n");
00358 return -1;
00359 }
00360 ast_mutex_lock(&pvt->lock);
00361 if (pvt->rtp && (pvt->options.dtmfmode & H323_DTMF_RFC2833)) {
00362
00363 if (h323debug) {
00364 ast_log(LOG_DEBUG, "Sending out-of-band digit %c on %s\n", digit, c->name);
00365 }
00366 ast_rtp_senddigit(pvt->rtp, digit);
00367 } else {
00368
00369 if (h323debug) {
00370 ast_log(LOG_DEBUG, "Sending inband digit %c on %s\n", digit, c->name);
00371 }
00372 token = pvt->cd.call_token ? strdup(pvt->cd.call_token) : NULL;
00373 h323_send_tone(token, digit);
00374 if (token) {
00375 free(token);
00376 }
00377 }
00378 ast_mutex_unlock(&pvt->lock);
00379 oh323_update_info(c);
00380 return 0;
00381 }
00382
00383
00384
00385
00386
00387
00388 static int oh323_call(struct ast_channel *c, char *dest, int timeout)
00389 {
00390 int res = 0;
00391 struct oh323_pvt *pvt = (struct oh323_pvt *)c->tech_pvt;
00392 char addr[INET_ADDRSTRLEN];
00393 char called_addr[1024];
00394
00395 if (h323debug) {
00396 ast_log(LOG_DEBUG, "Calling to %s on %s\n", dest, c->name);
00397 }
00398 if ((c->_state != AST_STATE_DOWN) && (c->_state != AST_STATE_RESERVED)) {
00399 ast_log(LOG_WARNING, "Line is already in use (%s)\n", c->name);
00400 return -1;
00401 }
00402 ast_mutex_lock(&pvt->lock);
00403 if (usingGk) {
00404 if (ast_strlen_zero(pvt->exten)) {
00405 strncpy(called_addr, dest, sizeof(called_addr));
00406 } else {
00407 snprintf(called_addr, sizeof(called_addr), "%s@%s", pvt->exten, dest);
00408 }
00409 } else {
00410 ast_inet_ntoa(addr, sizeof(addr), pvt->sa.sin_addr);
00411 res = htons(pvt->sa.sin_port);
00412 if (ast_strlen_zero(pvt->exten)) {
00413 snprintf(called_addr, sizeof(called_addr), "%s:%d", addr, res);
00414 } else {
00415 snprintf(called_addr, sizeof(called_addr), "%s@%s:%d", pvt->exten, addr, res);
00416 }
00417 }
00418
00419 called_addr[sizeof(called_addr) - 1] = '\0';
00420
00421 if (c->cid.cid_num) {
00422 strncpy(pvt->options.cid_num, c->cid.cid_num, sizeof(pvt->options.cid_num));
00423 }
00424 if (c->cid.cid_name) {
00425 strncpy(pvt->options.cid_name, c->cid.cid_name, sizeof(pvt->options.cid_name));
00426 }
00427
00428
00429 pvt->outgoing = 1;
00430
00431 ast_log(LOG_DEBUG, "Placing outgoing call to %s, %d\n", called_addr, pvt->options.dtmfcodec);
00432 ast_mutex_unlock(&pvt->lock);
00433 res = h323_make_call(called_addr, &(pvt->cd), &pvt->options);
00434 if (res) {
00435 ast_log(LOG_NOTICE, "h323_make_call failed(%s)\n", c->name);
00436 return -1;
00437 }
00438 oh323_update_info(c);
00439 return 0;
00440 }
00441
00442 static int oh323_answer(struct ast_channel *c)
00443 {
00444 int res;
00445 struct oh323_pvt *pvt = (struct oh323_pvt *) c->tech_pvt;
00446 char *token;
00447
00448 if (h323debug)
00449 ast_log(LOG_DEBUG, "Answering on %s\n", c->name);
00450
00451 ast_mutex_lock(&pvt->lock);
00452 token = pvt->cd.call_token ? strdup(pvt->cd.call_token) : NULL;
00453 ast_mutex_unlock(&pvt->lock);
00454 res = h323_answering_call(token, 0);
00455 if (token)
00456 free(token);
00457
00458 oh323_update_info(c);
00459 if (c->_state != AST_STATE_UP) {
00460 ast_setstate(c, AST_STATE_UP);
00461 }
00462 return res;
00463 }
00464
00465 static int oh323_hangup(struct ast_channel *c)
00466 {
00467 struct oh323_pvt *pvt = (struct oh323_pvt *) c->tech_pvt;
00468 int needcancel = 0;
00469 int q931cause = AST_CAUSE_NORMAL_CLEARING;
00470 char *call_token;
00471
00472
00473 if (h323debug)
00474 ast_log(LOG_DEBUG, "Hanging up call %s\n", c->name);
00475
00476 if (!c->tech_pvt) {
00477 ast_log(LOG_DEBUG, "Asked to hangup channel not connected\n");
00478 return 0;
00479 }
00480 ast_mutex_lock(&pvt->lock);
00481
00482 if (pvt->owner != c) {
00483 ast_log(LOG_WARNING, "Huh? We aren't the owner?\n");
00484 ast_mutex_unlock(&pvt->lock);
00485 return 0;
00486 }
00487 if (!c || (c->_state != AST_STATE_UP)) {
00488 needcancel = 1;
00489 }
00490
00491 pvt->owner = NULL;
00492 c->tech_pvt = NULL;
00493
00494 if (c->hangupcause) {
00495 q931cause = c->hangupcause;
00496 } else {
00497 char *cause = pbx_builtin_getvar_helper(c, "DIALSTATUS");
00498 if (cause) {
00499 if (!strcmp(cause, "CONGESTION")) {
00500 q931cause = AST_CAUSE_NORMAL_CIRCUIT_CONGESTION;
00501 } else if (!strcmp(cause, "BUSY")) {
00502 q931cause = AST_CAUSE_USER_BUSY;
00503 } else if (!strcmp(cause, "CHANISUNVAIL")) {
00504 q931cause = AST_CAUSE_REQUESTED_CHAN_UNAVAIL;
00505 } else if (!strcmp(cause, "NOANSWER")) {
00506 q931cause = AST_CAUSE_NO_ANSWER;
00507 } else if (!strcmp(cause, "CANCEL")) {
00508 q931cause = AST_CAUSE_CALL_REJECTED;
00509 }
00510 }
00511 }
00512
00513
00514 if (!pvt->alreadygone && !pvt->hangupcause) {
00515 call_token = pvt->cd.call_token ? strdup(pvt->cd.call_token) : NULL;
00516 if (call_token) {
00517
00518 ast_mutex_unlock(&pvt->lock);
00519 if (h323_clear_call(call_token, q931cause)) {
00520 ast_log(LOG_DEBUG, "ClearCall failed.\n");
00521 }
00522 free(call_token);
00523 ast_mutex_lock(&pvt->lock);
00524 }
00525 }
00526 pvt->needdestroy = 1;
00527
00528
00529 ast_mutex_lock(&usecnt_lock);
00530 usecnt--;
00531 if (usecnt < 0) {
00532 ast_log(LOG_WARNING, "Usecnt < 0\n");
00533 }
00534 ast_mutex_unlock(&usecnt_lock);
00535 ast_mutex_unlock(&pvt->lock);
00536 ast_update_use_count();
00537 return 0;
00538 }
00539
00540 static struct ast_frame *oh323_rtp_read(struct oh323_pvt *pvt)
00541 {
00542
00543 struct ast_frame *f;
00544 static struct ast_frame null_frame = { AST_FRAME_NULL, };
00545
00546
00547 if (pvt->options.nat) {
00548 ast_rtp_setnat(pvt->rtp, pvt->options.nat);
00549 pvt->options.nat = 0;
00550 }
00551
00552 f = ast_rtp_read(pvt->rtp);
00553
00554 if (f && (f->frametype == AST_FRAME_DTMF) && !(pvt->options.dtmfmode & H323_DTMF_RFC2833)) {
00555 return &null_frame;
00556 }
00557 if (pvt->owner) {
00558
00559 if (f->frametype == AST_FRAME_VOICE) {
00560 if (f->subclass != pvt->owner->nativeformats) {
00561
00562 if (ast_mutex_trylock(&pvt->owner->lock)) {
00563 ast_log(LOG_NOTICE, "Format changed but channel is locked. Ignoring frame...\n");
00564 return &null_frame;
00565 }
00566 ast_log(LOG_DEBUG, "Oooh, format changed to %d\n", f->subclass);
00567 pvt->owner->nativeformats = f->subclass;
00568 pvt->nativeformats = f->subclass;
00569 ast_set_read_format(pvt->owner, pvt->owner->readformat);
00570 ast_set_write_format(pvt->owner, pvt->owner->writeformat);
00571 ast_mutex_unlock(&pvt->owner->lock);
00572 }
00573
00574 if ((pvt->options.dtmfmode & H323_DTMF_INBAND) && pvt->vad) {
00575 if (!ast_mutex_trylock(&pvt->owner->lock)) {
00576 f = ast_dsp_process(pvt->owner,pvt->vad,f);
00577 ast_mutex_unlock(&pvt->owner->lock);
00578 }
00579 else
00580 ast_log(LOG_NOTICE, "Unable to process inband DTMF while channel is locked\n");
00581 if (f &&(f->frametype == AST_FRAME_DTMF)) {
00582 ast_log(LOG_DEBUG, "Received in-band digit %c.\n", f->subclass);
00583 }
00584 }
00585 }
00586 }
00587 return f;
00588 }
00589
00590 static struct ast_frame *oh323_read(struct ast_channel *c)
00591 {
00592 struct ast_frame *fr;
00593 struct oh323_pvt *pvt = (struct oh323_pvt *)c->tech_pvt;
00594 ast_mutex_lock(&pvt->lock);
00595 __oh323_update_info(c, pvt);
00596 fr = oh323_rtp_read(pvt);
00597 ast_mutex_unlock(&pvt->lock);
00598 return fr;
00599 }
00600
00601 static int oh323_write(struct ast_channel *c, struct ast_frame *frame)
00602 {
00603 struct oh323_pvt *pvt = (struct oh323_pvt *) c->tech_pvt;
00604 int res = 0;
00605 if (frame->frametype != AST_FRAME_VOICE) {
00606 if (frame->frametype == AST_FRAME_IMAGE) {
00607 return 0;
00608 } else {
00609 ast_log(LOG_WARNING, "Can't send %d type frames with H323 write\n", frame->frametype);
00610 return 0;
00611 }
00612 } else {
00613 if (!(frame->subclass & c->nativeformats)) {
00614 ast_log(LOG_WARNING, "Asked to transmit frame type %d, while native formats is %d (read/write = %d/%d)\n",
00615 frame->subclass, c->nativeformats, c->readformat, c->writeformat);
00616 return 0;
00617 }
00618 }
00619 if (pvt) {
00620 ast_mutex_lock(&pvt->lock);
00621 if (pvt->rtp) {
00622 res = ast_rtp_write(pvt->rtp, frame);
00623 }
00624 __oh323_update_info(c, pvt);
00625 ast_mutex_unlock(&pvt->lock);
00626 }
00627 return res;
00628 }
00629
00630 static int oh323_indicate(struct ast_channel *c, int condition)
00631 {
00632
00633 struct oh323_pvt *pvt = (struct oh323_pvt *) c->tech_pvt;
00634 char *token = (char *)NULL;
00635
00636 ast_mutex_lock(&pvt->lock);
00637 token = (pvt->cd.call_token ? strdup(pvt->cd.call_token) : NULL);
00638 ast_mutex_unlock(&pvt->lock);
00639
00640 if (h323debug)
00641 ast_log(LOG_DEBUG, "OH323: Indicating %d on %s\n", condition, token);
00642
00643 switch(condition) {
00644 case AST_CONTROL_RINGING:
00645 if (c->_state == AST_STATE_RING || c->_state == AST_STATE_RINGING) {
00646 h323_send_alerting(token);
00647 break;
00648 }
00649 if (token)
00650 free(token);
00651 return -1;
00652 case AST_CONTROL_PROGRESS:
00653 if (c->_state != AST_STATE_UP) {
00654 h323_send_progress(token);
00655 break;
00656 }
00657 if (token)
00658 free(token);
00659 return -1;
00660
00661 case AST_CONTROL_BUSY:
00662 if (c->_state != AST_STATE_UP) {
00663 h323_answering_call(token, 1);
00664 ast_mutex_lock(&pvt->lock);
00665 pvt->alreadygone = 1;
00666 ast_mutex_unlock(&pvt->lock);
00667 ast_softhangup_nolock(c, AST_SOFTHANGUP_DEV);
00668 break;
00669 }
00670 if (token)
00671 free(token);
00672 return -1;
00673 case AST_CONTROL_CONGESTION:
00674 if (c->_state != AST_STATE_UP) {
00675 h323_answering_call(token, 1);
00676 ast_mutex_lock(&pvt->lock);
00677 pvt->alreadygone = 1;
00678 ast_mutex_unlock(&pvt->lock);
00679 ast_softhangup_nolock(c, AST_SOFTHANGUP_DEV);
00680 break;
00681 }
00682 if (token)
00683 free(token);
00684 return -1;
00685 case AST_CONTROL_PROCEEDING:
00686 case -1:
00687 if (token)
00688 free(token);
00689 return -1;
00690 default:
00691 ast_log(LOG_WARNING, "Don't know how to indicate condition %d on %s\n", condition, token);
00692 if (token)
00693 free(token);
00694 return -1;
00695 }
00696
00697 if (h323debug)
00698 ast_log(LOG_DEBUG, "OH323: Indicated %d on %s\n", condition, token);
00699 if (token)
00700 free(token);
00701 oh323_update_info(c);
00702
00703 return -1;
00704 }
00705
00706 static int oh323_fixup(struct ast_channel *oldchan, struct ast_channel *newchan)
00707 {
00708 struct oh323_pvt *pvt = (struct oh323_pvt *) newchan->tech_pvt;
00709
00710 ast_mutex_lock(&pvt->lock);
00711 if (pvt->owner != oldchan) {
00712 ast_log(LOG_WARNING, "old channel wasn't %p but was %p\n", oldchan, pvt->owner);
00713 return -1;
00714 }
00715 pvt->owner = newchan;
00716 ast_mutex_unlock(&pvt->lock);
00717 return 0;
00718 }
00719
00720
00721 static struct ast_channel *__oh323_new(struct oh323_pvt *pvt, int state, const char *host)
00722 {
00723 struct ast_channel *ch;
00724 int fmt;
00725
00726
00727 ast_mutex_unlock(&pvt->lock);
00728 ch = ast_channel_alloc(1);
00729
00730 ast_mutex_lock(&usecnt_lock);
00731 usecnt++;
00732 ast_mutex_unlock(&usecnt_lock);
00733 ast_update_use_count();
00734 ast_mutex_lock(&pvt->lock);
00735 if (ch) {
00736 ch->tech = &oh323_tech;
00737 snprintf(ch->name, sizeof(ch->name), "H323/%s", host);
00738 ch->nativeformats = pvt->options.capability;
00739 if (!ch->nativeformats) {
00740 ch->nativeformats = global_options.capability;
00741 }
00742 pvt->nativeformats = ch->nativeformats;
00743 fmt = ast_best_codec(ch->nativeformats);
00744 ch->type = type;
00745 ch->fds[0] = ast_rtp_fd(pvt->rtp);
00746 if (state == AST_STATE_RING) {
00747 ch->rings = 1;
00748 }
00749 ch->writeformat = fmt;
00750 ch->rawwriteformat = fmt;
00751 ch->readformat = fmt;
00752 ch->rawreadformat = fmt;
00753
00754 if (pvt->options.dtmfmode & H323_DTMF_INBAND) {
00755 pvt->vad = ast_dsp_new();
00756 ast_dsp_set_features(pvt->vad, DSP_FEATURE_DTMF_DETECT);
00757 }
00758
00759 ch->tech_pvt = pvt;
00760
00761 pvt->owner = ch;
00762
00763 strncpy(ch->context, pvt->context, sizeof(ch->context) - 1);
00764 strncpy(ch->exten, pvt->exten, sizeof(ch->exten) - 1);
00765 ch->priority = 1;
00766 if (!ast_strlen_zero(pvt->accountcode)) {
00767 strncpy(ch->accountcode, pvt->accountcode, sizeof(ch->accountcode) - 1);
00768 }
00769 if (pvt->amaflags) {
00770 ch->amaflags = pvt->amaflags;
00771 }
00772
00773
00774
00775
00776
00777
00778 ast_set_callerid(ch,
00779 !ast_strlen_zero(pvt->cid_num) ? pvt->cid_num : pvt->cd.call_source_e164,
00780 pvt->cid_name,
00781 !ast_strlen_zero(pvt->cid_num) ? pvt->cid_num : pvt->cd.call_source_e164);
00782
00783 if (!ast_strlen_zero(pvt->rdnis)) {
00784 ch->cid.cid_rdnis = strdup(pvt->rdnis);
00785 }
00786 if (!ast_strlen_zero(pvt->exten) && strcmp(pvt->exten, "s")) {
00787 ch->cid.cid_dnid = strdup(pvt->exten);
00788 }
00789 ast_setstate(ch, state);
00790 if (state != AST_STATE_DOWN) {
00791 if (ast_pbx_start(ch)) {
00792 ast_log(LOG_WARNING, "Unable to start PBX on %s\n", ch->name);
00793 ast_hangup(ch);
00794 ch = NULL;
00795 }
00796 }
00797 } else {
00798 ast_log(LOG_WARNING, "Unable to allocate channel structure\n");
00799 }
00800 return ch;
00801 }
00802
00803 static struct oh323_pvt *oh323_alloc(int callid)
00804 {
00805 struct oh323_pvt *pvt;
00806
00807 pvt = (struct oh323_pvt *) malloc(sizeof(struct oh323_pvt));
00808 if (!pvt) {
00809 ast_log(LOG_ERROR, "Couldn't allocate private structure. This is bad\n");
00810 return NULL;
00811 }
00812 memset(pvt, 0, sizeof(struct oh323_pvt));
00813 pvt->rtp = ast_rtp_new_with_bindaddr(sched, io, 1, 0,bindaddr.sin_addr);
00814 if (!pvt->rtp) {
00815 ast_log(LOG_WARNING, "Unable to create RTP session: %s\n", strerror(errno));
00816 free(pvt);
00817 return NULL;
00818 }
00819 ast_rtp_settos(pvt->rtp, tos);
00820 ast_mutex_init(&pvt->lock);
00821
00822 if ((pvt->cd).call_token == NULL) {
00823 (pvt->cd).call_token = (char *)malloc(128);
00824 }
00825 if (!pvt->cd.call_token) {
00826 ast_log(LOG_ERROR, "Not enough memory to alocate call token\n");
00827 return NULL;
00828 }
00829 memset((char *)(pvt->cd).call_token, 0, 128);
00830 pvt->cd.call_reference = callid;
00831 memcpy(&pvt->options, &global_options, sizeof(pvt->options));
00832 if (pvt->options.dtmfmode & H323_DTMF_RFC2833) {
00833 pvt->nonCodecCapability |= AST_RTP_DTMF;
00834 } else {
00835 pvt->nonCodecCapability &= ~AST_RTP_DTMF;
00836 }
00837 strncpy(pvt->context, default_context, sizeof(pvt->context) - 1);
00838 pvt->newstate = pvt->newcontrol = -1;
00839
00840 ast_mutex_lock(&iflock);
00841 pvt->next = iflist;
00842 iflist = pvt;
00843 ast_mutex_unlock(&iflock);
00844 return pvt;
00845 }
00846
00847 static struct oh323_pvt *find_call_locked(int call_reference, const char *token)
00848 {
00849 struct oh323_pvt *pvt;
00850
00851 ast_mutex_lock(&iflock);
00852 pvt = iflist;
00853 while(pvt) {
00854 if (!pvt->needdestroy && ((signed int)pvt->cd.call_reference == call_reference)) {
00855
00856 if ((token != NULL) && (!strcmp(pvt->cd.call_token, token))) {
00857 ast_mutex_lock(&pvt->lock);
00858 ast_mutex_unlock(&iflock);
00859 return pvt;
00860 } else if (token == NULL) {
00861 ast_log(LOG_WARNING, "Call Token is NULL\n");
00862 ast_mutex_lock(&pvt->lock);
00863 ast_mutex_unlock(&iflock);
00864 return pvt;
00865 }
00866 }
00867 pvt = pvt->next;
00868 }
00869 ast_mutex_unlock(&iflock);
00870 return NULL;
00871 }
00872
00873 static int update_state(struct oh323_pvt *pvt, int state, int signal)
00874 {
00875 if (!pvt)
00876 return 0;
00877 if (pvt->owner && !ast_mutex_trylock(&pvt->owner->lock)) {
00878 if (state >= 0)
00879 ast_setstate(pvt->owner, state);
00880 if (signal >= 0)
00881 ast_queue_control(pvt->owner, signal);
00882 return 1;
00883 }
00884 else {
00885 if (state >= 0)
00886 pvt->newstate = state;
00887 if (signal >= 0)
00888 pvt->newcontrol = signal;
00889 return 0;
00890 }
00891 }
00892
00893 struct oh323_user *find_user(const call_details_t *cd)
00894 {
00895 struct oh323_user *u;
00896 char iabuf[INET_ADDRSTRLEN];
00897 u = userl.users;
00898 if (userbyalias) {
00899 while(u) {
00900 if (!strcasecmp(u->name, cd->call_source_aliases)) {
00901 break;
00902 }
00903 u = u->next;
00904 }
00905 } else {
00906 while(u) {
00907 if (!strcasecmp(cd->sourceIp, ast_inet_ntoa(iabuf, sizeof(iabuf), u->addr.sin_addr))) {
00908 break;
00909 }
00910 u = u->next;
00911 }
00912 }
00913 return u;
00914 }
00915
00916 struct oh323_peer *find_peer(const char *peer, struct sockaddr_in *sin)
00917 {
00918 struct oh323_peer *p = NULL;
00919 static char iabuf[INET_ADDRSTRLEN];
00920
00921 p = peerl.peers;
00922 if (peer) {
00923 while(p) {
00924 if (!strcasecmp(p->name, peer)) {
00925 ast_log(LOG_DEBUG, "Found peer %s by name\n", peer);
00926 break;
00927 }
00928 p = p->next;
00929 }
00930 } else {
00931
00932 if (sin) {
00933 while (p) {
00934 if ((!inaddrcmp(&p->addr, sin)) ||
00935 (p->addr.sin_addr.s_addr == sin->sin_addr.s_addr)) {
00936 ast_log(LOG_DEBUG, "Found peer %s/%s by addr\n", peer, ast_inet_ntoa(iabuf, sizeof(iabuf), p->addr.sin_addr));
00937 break;
00938 }
00939 p = p->next;
00940 }
00941 }
00942 }
00943 if (!p) {
00944 ast_log(LOG_DEBUG, "Could not find peer %s by name or address\n", peer);
00945 }
00946 return p;
00947 }
00948
00949 static int create_addr(struct oh323_pvt *pvt, char *opeer)
00950 {
00951 struct hostent *hp;
00952 struct ast_hostent ahp;
00953 struct oh323_peer *p;
00954 int portno;
00955 int found = 0;
00956 char *port;
00957 char *hostn;
00958 char peer[256] = "";
00959
00960 strncpy(peer, opeer, sizeof(peer) - 1);
00961 port = strchr(peer, ':');
00962 if (port) {
00963 *port = '\0';
00964 port++;
00965 }
00966 pvt->sa.sin_family = AF_INET;
00967 ast_mutex_lock(&peerl.lock);
00968 p = find_peer(peer, NULL);
00969 if (p) {
00970 found++;
00971 memcpy(&pvt->options, &p->options, sizeof(pvt->options));
00972 if (pvt->rtp) {
00973 ast_log(LOG_DEBUG, "Setting NAT on RTP to %d\n", pvt->options.nat);
00974 ast_rtp_setnat(pvt->rtp, pvt->options.nat);
00975 }
00976 if (pvt->options.dtmfmode) {
00977 if (pvt->options.dtmfmode & H323_DTMF_RFC2833) {
00978 pvt->nonCodecCapability |= AST_RTP_DTMF;
00979 } else {
00980 pvt->nonCodecCapability &= ~AST_RTP_DTMF;
00981 }
00982 }
00983 if (p->addr.sin_addr.s_addr) {
00984 pvt->sa.sin_addr = p->addr.sin_addr;
00985 pvt->sa.sin_port = p->addr.sin_port;
00986 }
00987 }
00988 ast_mutex_unlock(&peerl.lock);
00989 if (!p && !found) {
00990 hostn = peer;
00991 if (port) {
00992 portno = atoi(port);
00993 } else {
00994 portno = h323_signalling_port;
00995 }
00996 hp = ast_gethostbyname(hostn, &ahp);
00997 if (hp) {
00998 memcpy(&pvt->options, &global_options, sizeof(pvt->options));
00999 memcpy(&pvt->sa.sin_addr, hp->h_addr, sizeof(pvt->sa.sin_addr));
01000 pvt->sa.sin_port = htons(portno);
01001 return 0;
01002 } else {
01003 ast_log(LOG_WARNING, "No such host: %s\n", peer);
01004 return -1;
01005 }
01006 } else if (!p) {
01007 return -1;
01008 } else {
01009 return 0;
01010 }
01011 }
01012 static struct ast_channel *oh323_request(const char *type, int format, void *data, int *cause)
01013 {
01014 int oldformat;
01015 struct oh323_pvt *pvt;
01016 struct ast_channel *tmpc = NULL;
01017 char *dest = (char *)data;
01018 char *ext, *host;
01019 char *h323id = NULL;
01020 char tmp[256], tmp1[256];
01021
01022 ast_log(LOG_DEBUG, "type=%s, format=%d, data=%s.\n", type, format, (char *)data);
01023 pvt = oh323_alloc(0);
01024 if (!pvt) {
01025 ast_log(LOG_WARNING, "Unable to build pvt data for '%s'\n", (char *)data);
01026 return NULL;
01027 }
01028 oldformat = format;
01029 format &= ((AST_FORMAT_MAX_AUDIO << 1) - 1);
01030 if (!format) {
01031 ast_log(LOG_NOTICE, "Asked to get a channel of unsupported format '%d'\n", format);
01032 return NULL;
01033 }
01034 strncpy(tmp, dest, sizeof(tmp) - 1);
01035 host = strchr(tmp, '@');
01036 if (host) {
01037 *host = '\0';
01038 host++;
01039 ext = tmp;
01040 } else {
01041 host = tmp;
01042 ext = NULL;
01043 }
01044 strtok_r(host, "/", &(h323id));
01045 if (!ast_strlen_zero(h323id)) {
01046 h323_set_id(h323id);
01047 }
01048 if (ext) {
01049 strncpy(pvt->exten, ext, sizeof(pvt->exten) - 1);
01050 }
01051 ast_log(LOG_DEBUG, "Extension: %s Host: %s\n", pvt->exten, host);
01052 if (!usingGk) {
01053 if (create_addr(pvt, host)) {
01054 oh323_destroy(pvt);
01055 return NULL;
01056 }
01057 }
01058 else {
01059 memcpy(&pvt->options, &global_options, sizeof(pvt->options));
01060 if (pvt->rtp) {
01061 ast_log(LOG_DEBUG, "Setting NAT on RTP to %d\n", pvt->options.nat);
01062 ast_rtp_setnat(pvt->rtp, pvt->options.nat);
01063 }
01064 if (pvt->options.dtmfmode) {
01065 if (pvt->options.dtmfmode & H323_DTMF_RFC2833) {
01066 pvt->nonCodecCapability |= AST_RTP_DTMF;
01067 } else {
01068 pvt->nonCodecCapability &= ~AST_RTP_DTMF;
01069 }
01070 }
01071 }
01072
01073 ast_mutex_lock(&caplock);
01074
01075 snprintf(tmp1, sizeof(tmp1)-1, "%s-%u", host, ++unique);
01076 tmp1[sizeof(tmp1)-1] = '\0';
01077 ast_mutex_unlock(&caplock);
01078
01079 ast_mutex_lock(&pvt->lock);
01080 tmpc = __oh323_new(pvt, AST_STATE_DOWN, tmp1);
01081 ast_mutex_unlock(&pvt->lock);
01082 if (!tmpc) {
01083 oh323_destroy(pvt);
01084 }
01085 ast_update_use_count();
01086 restart_monitor();
01087 return tmpc;
01088 }
01089
01090
01091 struct oh323_alias *find_alias(const char *source_aliases)
01092 {
01093 struct oh323_alias *a;
01094
01095 a = aliasl.aliases;
01096 while(a) {
01097 if (!strcasecmp(a->name, source_aliases)) {
01098 break;
01099 }
01100 a = a->next;
01101 }
01102 return a;
01103 }
01104
01105
01106
01107
01108
01109 int send_digit(unsigned call_reference, char digit, const char *token)
01110 {
01111 struct oh323_pvt *pvt;
01112 struct ast_frame f;
01113 int res;
01114
01115 ast_log(LOG_DEBUG, "Received Digit: %c\n", digit);
01116 pvt = find_call_locked(call_reference, token);
01117 if (!pvt) {
01118 ast_log(LOG_ERROR, "Private structure not found in send_digit.\n");
01119 return -1;
01120 }
01121 memset(&f, 0, sizeof(f));
01122 f.frametype = AST_FRAME_DTMF;
01123 f.subclass = digit;
01124 f.datalen = 0;
01125 f.samples = 800;
01126 f.offset = 0;
01127 f.data = NULL;
01128 f.mallocd = 0;
01129 f.src = "SEND_DIGIT";
01130 res = ast_queue_frame(pvt->owner, &f);
01131 ast_mutex_unlock(&pvt->lock);
01132 return res;
01133 }
01134
01135
01136
01137
01138
01139
01140 struct rtp_info *external_rtp_create(unsigned call_reference, const char * token)
01141 {
01142 struct oh323_pvt *pvt;
01143 struct sockaddr_in us;
01144 struct rtp_info *info;
01145
01146 info = (struct rtp_info *)malloc(sizeof(struct rtp_info));
01147 if (!info) {
01148 ast_log(LOG_ERROR, "Unable to allocated info structure, this is very bad\n");
01149 return NULL;
01150 }
01151 pvt = find_call_locked(call_reference, token);
01152 if (!pvt) {
01153 free(info);
01154 ast_log(LOG_ERROR, "Unable to find call %s(%d)\n", token, call_reference);
01155 return NULL;
01156 }
01157
01158 ast_rtp_get_us(pvt->rtp, &us);
01159 ast_mutex_unlock(&pvt->lock);
01160
01161 ast_inet_ntoa(info->addr, sizeof(info->addr), us.sin_addr);
01162 info->port = ntohs(us.sin_port);
01163 if (h323debug)
01164 ast_log(LOG_DEBUG, "Sending RTP 'US' %s:%d\n", info->addr, info->port);
01165 return info;
01166 }
01167
01168
01169
01170
01171 struct rtpPayloadType {
01172 int isAstFormat;
01173 int code;
01174 };
01175
01176
01177
01178
01179
01180
01181 void setup_rtp_connection(unsigned call_reference, const char *remoteIp, int remotePort, const char *token, int pt)
01182 {
01183 struct oh323_pvt *pvt;
01184 struct sockaddr_in them;
01185 struct rtpPayloadType rtptype;
01186
01187 if (h323debug)
01188 ast_log(LOG_DEBUG, "Setting up RTP connection for %s\n", token);
01189
01190
01191 pvt = find_call_locked(call_reference, token);
01192 if (!pvt) {
01193 ast_log(LOG_ERROR, "Something is wrong: rtp\n");
01194 return;
01195 }
01196 if (pvt->alreadygone) {
01197 ast_mutex_unlock(&pvt->lock);
01198 return;
01199 }
01200 rtptype = ast_rtp_lookup_pt(pvt->rtp, pt);
01201 pvt->nativeformats = rtptype.code;
01202 if (pvt->owner && !ast_mutex_trylock(&pvt->owner->lock)) {
01203 pvt->owner->nativeformats = pvt->nativeformats;
01204 ast_set_read_format(pvt->owner, pvt->owner->readformat);
01205 ast_set_write_format(pvt->owner, pvt->owner->writeformat);
01206 if (pvt->options.progress_audio)
01207 ast_queue_control(pvt->owner, AST_CONTROL_PROGRESS);
01208 ast_mutex_unlock(&pvt->owner->lock);
01209 }
01210 else {
01211 if (pvt->options.progress_audio)
01212 pvt->newcontrol = AST_CONTROL_PROGRESS;
01213 if (h323debug)
01214 ast_log(LOG_DEBUG, "RTP connection preparation for %s is pending...\n", token);
01215 }
01216
01217 them.sin_family = AF_INET;
01218
01219 them.sin_addr.s_addr = inet_addr(remoteIp);
01220 them.sin_port = htons(remotePort);
01221 ast_rtp_set_peer(pvt->rtp, &them);
01222
01223 ast_mutex_unlock(&pvt->lock);
01224
01225 if (h323debug)
01226 ast_log(LOG_DEBUG, "RTP connection prepared for %s\n", token);
01227
01228 return;
01229 }
01230
01231
01232
01233
01234
01235 void connection_made(unsigned call_reference, const char *token)
01236 {
01237 struct oh323_pvt *pvt;
01238
01239 if (h323debug)
01240 ast_log(LOG_DEBUG, "Call %s answered\n", token);
01241
01242 pvt = find_call_locked(call_reference, token);
01243 if (!pvt) {
01244 ast_log(LOG_ERROR, "Something is wrong: connection\n");
01245 return;
01246 }
01247
01248
01249 if (!pvt->outgoing) {
01250 ast_mutex_unlock(&pvt->lock);
01251 return;
01252 }
01253 if (update_state(pvt, AST_STATE_UP, AST_CONTROL_ANSWER))
01254 ast_mutex_unlock(&pvt->owner->lock);
01255 ast_mutex_unlock(&pvt->lock);
01256 return;
01257 }
01258
01259 int progress(unsigned call_reference, const char *token, int inband)
01260 {
01261 struct oh323_pvt *pvt;
01262
01263 ast_log(LOG_DEBUG, "Received ALERT/PROGRESS message for %s tones\n", (inband ? "inband" : "self-generated"));
01264
01265 pvt = find_call_locked(call_reference, token);
01266 if (!pvt) {
01267 ast_log(LOG_ERROR, "Private structure not found in progress.\n");
01268 return -1;
01269 }
01270 if (!pvt->owner) {
01271 ast_mutex_unlock(&pvt->lock);
01272 ast_log(LOG_ERROR, "No Asterisk channel associated with private structure.\n");
01273 return -1;
01274 }
01275 if (update_state(pvt, -1, (inband ? AST_CONTROL_PROGRESS : AST_CONTROL_RINGING)))
01276 ast_mutex_unlock(&pvt->owner->lock);
01277 ast_mutex_unlock(&pvt->lock);
01278
01279 return 0;
01280 }
01281
01282
01283
01284
01285
01286
01287 call_options_t *setup_incoming_call(call_details_t *cd)
01288 {
01289 struct oh323_pvt *pvt;
01290 struct oh323_user *user = NULL;
01291 struct oh323_alias *alias = NULL;
01292 char iabuf[INET_ADDRSTRLEN];
01293
01294 if (h323debug)
01295 ast_log(LOG_DEBUG, "Setting up incoming call for %s\n", cd->call_token);
01296
01297
01298 pvt = oh323_alloc(cd->call_reference);
01299
01300 if (!pvt) {
01301 ast_log(LOG_ERROR, "Unable to allocate private structure, this is bad.\n");
01302 return NULL;
01303 }
01304
01305
01306 memcpy(&pvt->cd, cd, sizeof(pvt->cd));
01307 memcpy(&pvt->options, &global_options, sizeof(pvt->options));
01308
01309 if (h323debug) {
01310 ast_verbose(VERBOSE_PREFIX_3 "Setting up Call\n");
01311 ast_verbose(VERBOSE_PREFIX_3 "\tCall token: [%s]\n", pvt->cd.call_token);
01312 ast_verbose(VERBOSE_PREFIX_3 "\tCalling party name: [%s]\n", pvt->cd.call_source_name);
01313 ast_verbose(VERBOSE_PREFIX_3 "\tCalling party number: [%s]\n", pvt->cd.call_source_e164);
01314 ast_verbose(VERBOSE_PREFIX_3 "\tCalled party name: [%s]\n", pvt->cd.call_dest_alias);
01315 ast_verbose(VERBOSE_PREFIX_3 "\tCalled party number: [%s]\n", pvt->cd.call_dest_e164);
01316 }
01317
01318
01319 if ((!strcasecmp(cd->sourceIp, gatekeeper)) && (gkroute == -1) && (usingGk)) {
01320 if (!ast_strlen_zero(cd->call_dest_e164)) {
01321 strncpy(pvt->exten, cd->call_dest_e164, sizeof(pvt->exten) - 1);
01322 strncpy(pvt->context, default_context, sizeof(pvt->context) - 1);
01323 } else {
01324 alias = find_alias(cd->call_dest_alias);
01325 if (!alias) {
01326 ast_log(LOG_ERROR, "Call for %s rejected, alias not found\n", cd->call_dest_alias);
01327 return NULL;
01328 }
01329 strncpy(pvt->exten, alias->name, sizeof(pvt->exten) - 1);
01330 strncpy(pvt->context, alias->context, sizeof(pvt->context) - 1);
01331 }
01332 } else {
01333
01334
01335 user = find_user(cd);
01336 if (!user) {
01337 if (!ast_strlen_zero(pvt->cd.call_dest_e164)) {
01338 strncpy(pvt->exten, cd->call_dest_e164, sizeof(pvt->exten) - 1);
01339 } else {
01340 strncpy(pvt->exten, cd->call_dest_alias, sizeof(pvt->exten) - 1);
01341 }
01342 if (ast_strlen_zero(default_context)) {
01343 ast_log(LOG_ERROR, "Call from '%s' rejected due to no default context\n", pvt->cd.call_source_aliases);
01344 return NULL;
01345 }
01346 strncpy(pvt->context, default_context, sizeof(pvt->context) - 1);
01347 ast_log(LOG_DEBUG, "Sending %s to context [%s]\n", cd->call_source_aliases, pvt->context);
01348
01349 #if 0
01350 memset(&pvt->options, 0, sizeof(pvt->options));
01351 #endif
01352 } else {
01353 if (user->host) {
01354 if (strcasecmp(cd->sourceIp, ast_inet_ntoa(iabuf, sizeof(iabuf), user->addr.sin_addr))) {
01355 if (ast_strlen_zero(user->context)) {
01356 if (ast_strlen_zero(default_context)) {
01357 ast_log(LOG_ERROR, "Call from '%s' rejected due to non-matching IP address (%s) and no default context\n", user->name, cd->sourceIp);
01358 return NULL;
01359 }
01360 strncpy(pvt->context, default_context, sizeof(pvt->context) - 1);
01361 } else {
01362 strncpy(pvt->context, user->context, sizeof(pvt->context) - 1);
01363 }
01364 pvt->exten[0] = 'i';
01365 pvt->exten[1] = '\0';
01366 ast_log(LOG_ERROR, "Call from '%s' rejected due to non-matching IP address (%s)s\n", user->name, cd->sourceIp);
01367 return NULL;
01368 }
01369 }
01370 strncpy(pvt->context, user->context, sizeof(pvt->context) - 1);
01371 memcpy(&pvt->options, &user->options, sizeof(pvt->options));
01372 if (!ast_strlen_zero(pvt->cd.call_dest_e164)) {
01373 strncpy(pvt->exten, cd->call_dest_e164, sizeof(pvt->exten) - 1);
01374 } else {
01375 strncpy(pvt->exten, cd->call_dest_alias, sizeof(pvt->exten) - 1);
01376 }
01377 if (!ast_strlen_zero(user->accountcode)) {
01378 strncpy(pvt->accountcode, user->accountcode, sizeof(pvt->accountcode) - 1);
01379 }
01380 if (user->amaflags) {
01381 pvt->amaflags = user->amaflags;
01382 }
01383 }
01384 }
01385 return &pvt->options;
01386 }
01387
01388
01389
01390
01391
01392
01393 static int answer_call(unsigned call_reference, const char *token)
01394 {
01395 struct oh323_pvt *pvt;
01396 struct ast_channel *c = NULL;
01397
01398 if (h323debug)
01399 ast_log(LOG_DEBUG, "Preparing Asterisk to answer for %s\n", token);
01400
01401
01402 pvt = find_call_locked(call_reference, token);
01403 if (!pvt) {
01404 ast_log(LOG_ERROR, "Something is wrong: answer_call\n");
01405 return 0;
01406 }
01407
01408 c = __oh323_new(pvt, AST_STATE_RINGING, pvt->cd.call_token);
01409
01410
01411 ast_mutex_unlock(&pvt->lock);
01412 if (!c) {
01413 ast_log(LOG_ERROR, "Couldn't create channel. This is bad\n");
01414 return 0;
01415 }
01416 return 1;
01417 }
01418
01419
01420
01421
01422
01423
01424 int setup_outgoing_call(call_details_t *cd)
01425 {
01426
01427 cleanup_call_details(cd);
01428
01429 return 1;
01430 }
01431
01432
01433
01434
01435
01436 void chan_ringing(unsigned call_reference, const char *token)
01437 {
01438 struct oh323_pvt *pvt;
01439
01440 if (h323debug)
01441 ast_log(LOG_DEBUG, "Ringing on %s\n", token);
01442
01443 pvt = find_call_locked(call_reference, token);
01444 if (!pvt) {
01445 ast_log(LOG_ERROR, "Something is wrong: ringing\n");
01446 return;
01447 }
01448 if (!pvt->owner) {
01449 ast_mutex_unlock(&pvt->lock);
01450 ast_log(LOG_ERROR, "Channel has no owner\n");
01451 return;
01452 }
01453 if (update_state(pvt, AST_STATE_RINGING, AST_CONTROL_RINGING))
01454 ast_mutex_unlock(&pvt->owner->lock);
01455 ast_mutex_unlock(&pvt->lock);
01456 return;
01457 }
01458
01459
01460
01461
01462
01463 static void cleanup_connection(unsigned call_reference, const char *call_token)
01464 {
01465 struct oh323_pvt *pvt;
01466
01467 ast_log(LOG_DEBUG, "Cleaning connection to %s\n", call_token);
01468
01469 while (1) {
01470 pvt = find_call_locked(call_reference, call_token);
01471 if (!pvt) {
01472 if (h323debug)
01473 ast_log(LOG_DEBUG, "No connection for %s\n", call_token);
01474 return;
01475 }
01476 if (!pvt->owner || !ast_mutex_trylock(&pvt->owner->lock))
01477 break;
01478 #if 1
01479 #ifdef DEBUG_THREADS
01480 ast_log(LOG_NOTICE, "Avoiding H.323 destory deadlock on %s, locked at %ld/%d by %s (%s:%d)\n", call_token, pvt->owner->lock.thread, pvt->owner->lock.reentrancy, pvt->owner->lock.func, pvt->owner->lock.file, pvt->owner->lock.lineno);
01481 #else
01482 ast_log(LOG_NOTICE, "Avoiding H.323 destory deadlock on %s\n", call_token);
01483 #endif
01484 #endif
01485 ast_mutex_unlock(&pvt->lock);
01486 usleep(1);
01487 }
01488 if (pvt->rtp) {
01489
01490 ast_rtp_destroy(pvt->rtp);
01491 pvt->rtp = NULL;
01492 }
01493
01494 if (pvt->vad) {
01495 ast_dsp_free(pvt->vad);
01496 pvt->vad = NULL;
01497 }
01498 cleanup_call_details(&pvt->cd);
01499 pvt->alreadygone = 1;
01500
01501 if (pvt->owner) {
01502 pvt->owner->_softhangup |= AST_SOFTHANGUP_DEV;
01503 ast_queue_hangup(pvt->owner);
01504 ast_mutex_unlock(&pvt->owner->lock);
01505 }
01506 ast_mutex_unlock(&pvt->lock);
01507 if (h323debug)
01508 ast_log(LOG_DEBUG, "Connection to %s cleaned\n", call_token);
01509 return;
01510 }
01511
01512 static void hangup_connection(unsigned int call_reference, const char *token, int cause)
01513 {
01514 struct oh323_pvt *pvt;
01515
01516 ast_log(LOG_DEBUG, "Hanging up connection to %s with cause %d\n", token, cause);
01517
01518 pvt = find_call_locked(call_reference, token);
01519 if (!pvt) {
01520 return;
01521 }
01522 if (pvt->owner && !ast_mutex_trylock(&pvt->owner->lock)) {
01523 pvt->owner->_softhangup |= AST_SOFTHANGUP_DEV;
01524 pvt->owner->hangupcause = pvt->hangupcause = cause;
01525 ast_queue_hangup(pvt->owner);
01526 ast_mutex_unlock(&pvt->owner->lock);
01527 }
01528 else {
01529 pvt->needhangup = 1;
01530 pvt->hangupcause = cause;
01531 ast_log(LOG_DEBUG, "Hangup for %s is pending\n", token);
01532 }
01533 ast_mutex_unlock(&pvt->lock);
01534 }
01535
01536 void set_dtmf_payload(unsigned call_reference, const char *token, int payload)
01537 {
01538 struct oh323_pvt *pvt;
01539
01540 if (h323debug)
01541 ast_log(LOG_DEBUG, "Setting DTMF payload to %d on %s\n", payload, token);
01542
01543 pvt = find_call_locked(call_reference, token);
01544 if (!pvt) {
01545 return;
01546 }
01547 if (pvt->rtp) {
01548 ast_rtp_set_rtpmap_type(pvt->rtp, payload, "audio", "telephone-event");
01549 }
01550 ast_mutex_unlock(&pvt->lock);
01551 if (h323debug)
01552 ast_log(LOG_DEBUG, "DTMF payload on %s set to %d\n", token, payload);
01553 }
01554
01555 static void set_local_capabilities(unsigned call_reference, const char *token)
01556 {
01557 struct oh323_pvt *pvt;
01558 int capability, dtmfmode;
01559
01560 if (h323debug)
01561 ast_log(LOG_DEBUG, "Setting capabilities for connection %s\n", token);
01562
01563 pvt = find_call_locked(call_reference, token);
01564 if (!pvt)
01565 return;
01566 capability = pvt->options.capability;
01567 dtmfmode = pvt->options.dtmfmode;
01568 ast_mutex_unlock(&pvt->lock);
01569 h323_set_capabilities(token, capability, dtmfmode);
01570
01571 if (h323debug)
01572 ast_log(LOG_DEBUG, "Capabilities for connection %s is set\n", token);
01573 }
01574
01575 static void *do_monitor(void *data)
01576 {
01577 int res;
01578 int reloading;
01579 struct oh323_pvt *oh323 = NULL;
01580
01581 for(;;) {
01582
01583 ast_mutex_lock(&h323_reload_lock);
01584 reloading = h323_reloading;
01585 h323_reloading = 0;
01586 ast_mutex_unlock(&h323_reload_lock);
01587 if (reloading) {
01588 if (option_verbose > 0) {
01589 ast_verbose(VERBOSE_PREFIX_1 "Reloading H.323\n");
01590 }
01591 h323_do_reload();
01592 }
01593
01594 ast_mutex_lock(&iflock);
01595 restartsearch:
01596 oh323 = iflist;
01597 while(oh323) {
01598 if (oh323->needdestroy) {
01599 __oh323_destroy(oh323);
01600 goto restartsearch;
01601 }
01602 oh323 = oh323->next;
01603 }
01604 ast_mutex_unlock(&iflock);
01605 pthread_testcancel();
01606
01607 res = ast_sched_wait(sched);
01608 if ((res < 0) || (res > 1000)) {
01609 res = 1000;
01610 }
01611 res = ast_io_wait(io, res);
01612 pthread_testcancel();
01613 ast_mutex_lock(&monlock);
01614 if (res >= 0) {
01615 ast_sched_runq(sched);
01616 }
01617 ast_mutex_unlock(&monlock);
01618 }
01619
01620 return NULL;
01621 }
01622
01623 static int restart_monitor(void)
01624 {
01625 pthread_attr_t attr;
01626
01627 if (monitor_thread == AST_PTHREADT_STOP) {
01628 return 0;
01629 }
01630 if (ast_mutex_lock(&monlock)) {
01631 ast_log(LOG_WARNING, "Unable to lock monitor\n");
01632 return -1;
01633 }
01634 if (monitor_thread == pthread_self()) {
01635 ast_mutex_unlock(&monlock);
01636 ast_log(LOG_WARNING, "Cannot kill myself\n");
01637 return -1;
01638 }
01639 if (monitor_thread && (monitor_thread != AST_PTHREADT_NULL)) {
01640
01641 pthread_kill(monitor_thread, SIGURG);
01642 } else {
01643 pthread_attr_init(&attr);
01644 pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
01645
01646 if (ast_pthread_create(&monitor_thread, &attr, do_monitor, NULL) < 0) {
01647 ast_mutex_unlock(&monlock);
01648 ast_log(LOG_ERROR, "Unable to start monitor thread.\n");
01649 return -1;
01650 }
01651
01652 }
01653 ast_mutex_unlock(&monlock);
01654 return 0;
01655 }
01656
01657 static int h323_do_trace(int fd, int argc, char *argv[])
01658 {
01659 if (argc != 3) {
01660 return RESULT_SHOWUSAGE;
01661 }
01662 h323_debug(1, atoi(argv[2]));
01663 ast_cli(fd, "H.323 trace set to level %s\n", argv[2]);
01664 return RESULT_SUCCESS;
01665 }
01666
01667 static int h323_no_trace(int fd, int argc, char *argv[])
01668 {
01669 if (argc != 3) {
01670 return RESULT_SHOWUSAGE;
01671 }
01672 h323_debug(0,0);
01673 ast_cli(fd, "H.323 trace disabled\n");
01674 return RESULT_SUCCESS;
01675 }
01676
01677 static int h323_do_debug(int fd, int argc, char *argv[])
01678 {
01679 if (argc != 2) {
01680 return RESULT_SHOWUSAGE;
01681 }
01682 h323debug = 1;
01683 ast_cli(fd, "H323 debug enabled\n");
01684 return RESULT_SUCCESS;
01685 }
01686
01687 static int h323_no_debug(int fd, int argc, char *argv[])
01688 {
01689 if (argc != 3) {
01690 return RESULT_SHOWUSAGE;
01691 }
01692 h323debug = 0;
01693 ast_cli(fd, "H323 Debug disabled\n");
01694 return RESULT_SUCCESS;
01695 }
01696
01697 static int h323_gk_cycle(int fd, int argc, char *argv[])
01698 {
01699 #if 0
01700 if (argc != 3) {
01701 return RESULT_SHOWUSAGE;
01702 }
01703 h323_gk_urq();
01704
01705
01706 if (!gatekeeper_disable) {
01707 if (h323_set_gk(gatekeeper_discover, gatekeeper, secret)) {
01708 ast_log(LOG_ERROR, "Gatekeeper registration failed.\n");
01709 }
01710 }
01711 #endif
01712 return RESULT_SUCCESS;
01713 }
01714
01715 static int h323_ep_hangup(int fd, int argc, char *argv[])
01716 {
01717 if (argc != 3) {
01718 return RESULT_SHOWUSAGE;
01719 }
01720 if (h323_soft_hangup(argv[2])) {
01721 ast_verbose(VERBOSE_PREFIX_3 "Hangup succeeded on %s\n", argv[2]);
01722 } else {
01723 ast_verbose(VERBOSE_PREFIX_3 "Hangup failed for %s\n", argv[2]);
01724 }
01725 return RESULT_SUCCESS;
01726 }
01727
01728 static int h323_tokens_show(int fd, int argc, char *argv[])
01729 {
01730 if (argc != 3) {
01731 return RESULT_SHOWUSAGE;
01732 }
01733 h323_show_tokens();
01734 return RESULT_SUCCESS;
01735 }
01736
01737 static char trace_usage[] =
01738 "Usage: h.323 trace <level num>\n"
01739 " Enables H.323 stack tracing for debugging purposes\n";
01740
01741 static char no_trace_usage[] =
01742 "Usage: h.323 no trace\n"
01743 " Disables H.323 stack tracing for debugging purposes\n";
01744
01745 static char debug_usage[] =
01746 "Usage: h.323 debug\n"
01747 " Enables H.323 debug output\n";
01748
01749 static char no_debug_usage[] =
01750 "Usage: h.323 no debug\n"
01751 " Disables H.323 debug output\n";
01752
01753 static char show_codec_usage[] =
01754 "Usage: h.323 show codec\n"
01755 " Shows all enabled codecs\n";
01756
01757 static char show_cycle_usage[] =
01758 "Usage: h.323 gk cycle\n"
01759 " Manually re-register with the Gatekeper (Currently Disabled)\n";
01760
01761 static char show_hangup_usage[] =
01762 "Usage: h.323 hangup <token>\n"
01763 " Manually try to hang up call identified by <token>\n";
01764
01765 static char show_tokens_usage[] =
01766 "Usage: h.323 show tokens\n"
01767 " Print out all active call tokens\n";
01768
01769 static char h323_reload_usage[] =
01770 "Usage: h323 reload\n"
01771 " Reloads H.323 configuration from sip.conf\n";
01772
01773 static struct ast_cli_entry cli_trace =
01774 { { "h.323", "trace", NULL }, h323_do_trace, "Enable H.323 Stack Tracing", trace_usage };
01775 static struct ast_cli_entry cli_no_trace =
01776 { { "h.323", "no", "trace", NULL }, h323_no_trace, "Disable H.323 Stack Tracing", no_trace_usage };
01777 static struct ast_cli_entry cli_debug =
01778 { { "h.323", "debug", NULL }, h323_do_debug, "Enable H.323 debug", debug_usage };
01779 static struct ast_cli_entry cli_no_debug =
01780 { { "h.323", "no", "debug", NULL }, h323_no_debug, "Disable H.323 debug", no_debug_usage };
01781 static struct ast_cli_entry cli_show_codecs =
01782 { { "h.323", "show", "codecs", NULL }, h323_show_codec, "Show enabled codecs", show_codec_usage };
01783 static struct ast_cli_entry cli_gk_cycle =
01784 { { "h.323", "gk", "cycle", NULL }, h323_gk_cycle, "Manually re-register with the Gatekeper", show_cycle_usage };
01785 static struct ast_cli_entry cli_hangup_call =
01786 { { "h.323", "hangup", NULL }, h323_ep_hangup, "Manually try to hang up a call", show_hangup_usage };
01787 static struct ast_cli_entry cli_show_tokens =
01788 { { "h.323", "show", "tokens", NULL }, h323_tokens_show, "Show all active call tokens", show_tokens_usage };
01789
01790 static int update_common_options(struct ast_variable *v, struct call_options *options)
01791 {
01792 unsigned int format;
01793 int tmp;
01794
01795 if (!strcasecmp(v->name, "allow")) {
01796 format = ast_getformatbyname(v->value);
01797 if (format < 1)
01798 ast_log(LOG_WARNING, "Cannot allow unknown format '%s'\n", v->value);
01799 else
01800 options->capability |= format;
01801 } else if (!strcasecmp(v->name, "disallow")) {
01802 format = ast_getformatbyname(v->value);
01803 if (format < 1)
01804 ast_log(LOG_WARNING, "Cannot disallow unknown format '%s'\n", v->value);
01805 else
01806 options->capability &= ~format;
01807 } else if (!strcasecmp(v->name, "dtmfmode")) {
01808 if (!strcasecmp(v->value, "inband")) {
01809 options->dtmfmode = H323_DTMF_INBAND;
01810 } else if (!strcasecmp(v->value, "rfc2833")) {
01811 options->dtmfmode = H323_DTMF_RFC2833;
01812 } else {
01813 ast_log(LOG_WARNING, "Unknown dtmf mode '%s', using rfc2833\n", v->value);
01814 options->dtmfmode = H323_DTMF_RFC2833;
01815 }
01816 } else if (!strcasecmp(v->name, "dtmfcodec")) {
01817 tmp = atoi(v->value);
01818 if (tmp < 96)
01819 ast_log(LOG_WARNING, "Invalid global dtmfcodec value %s\n", v->value);
01820 else
01821 options->dtmfcodec = tmp;
01822 } else if (!strcasecmp(v->name, "bridge")) {
01823 options->bridge = ast_true(v->value);
01824 } else if (!strcasecmp(v->name, "nat")) {
01825 options->nat = ast_true(v->value);
01826 } else if (!strcasecmp(v->name, "noFastStart")) {
01827 options->noFastStart = ast_true(v->value);
01828 } else if (!strcasecmp(v->name, "noH245Tunneling")) {
01829 options->noH245Tunneling = ast_true(v->value);
01830 } else if (!strcasecmp(v->name, "noSilenceSuppression")) {
01831 options->noSilenceSuppression = ast_true(v->value);
01832 } else if (!strcasecmp(v->name, "progress_setup")) {
01833 tmp = atoi(v->value);
01834 if ((tmp != 0) && (tmp != 1) && (tmp != 3) && (tmp != 8)) {
01835 ast_log(LOG_WARNING, "Invalid value %d for progress_setup at line %d, assuming 0\n", tmp, v->lineno);
01836 tmp = 0;
01837 }
01838 options->progress_setup = tmp;
01839 } else if (!strcasecmp(v->name, "progress_alert")) {
01840 tmp = atoi(v->value);
01841 if ((tmp != 0) && (tmp != 8)) {
01842 ast_log(LOG_WARNING, "Invalud value %d for progress_alert at line %d, assuming 0\n", tmp, v->lineno);
01843 tmp = 0;
01844 }
01845 options->progress_alert = tmp;
01846 } else if (!strcasecmp(v->name, "progress_audio")) {
01847 options->progress_audio = ast_true(v->value);
01848 } else
01849 return 1;
01850
01851 return 0;
01852 }
01853
01854 static struct oh323_alias *build_alias(char *name, struct ast_variable *v)
01855 {
01856 struct oh323_alias *alias;
01857
01858 alias = (struct oh323_alias *)malloc(sizeof(struct oh323_alias));
01859 if (alias) {
01860 memset(alias, 0, sizeof(struct oh323_alias));
01861 strncpy(alias->name, name, sizeof(alias->name) - 1);
01862 while (v) {
01863 if (!strcasecmp(v->name, "e164")) {
01864 strncpy(alias->e164, v->value, sizeof(alias->e164) - 1);
01865 } else if (!strcasecmp(v->name, "prefix")) {
01866 strncpy(alias->prefix, v->value, sizeof(alias->prefix) - 1);
01867 } else if (!strcasecmp(v->name, "context")) {
01868 strncpy(alias->context, v->value, sizeof(alias->context) - 1);
01869 } else if (!strcasecmp(v->name, "secret")) {
01870 strncpy(alias->secret, v->value, sizeof(alias->secret) - 1);
01871 } else {
01872 if (strcasecmp(v->value, "h323")) {
01873 ast_log(LOG_WARNING, "Keyword %s does not make sense in type=h323\n", v->value);
01874 }
01875 }
01876 v = v->next;
01877 }
01878 }
01879 return alias;
01880 }
01881
01882 static struct oh323_user *build_user(char *name, struct ast_variable *v)
01883 {
01884 struct oh323_user *user;
01885 int format;
01886
01887 user = (struct oh323_user *)malloc(sizeof(struct oh323_user));
01888 if (user) {
01889 memset(user, 0, sizeof(struct oh323_user));
01890 strncpy(user->name, name, sizeof(user->name) - 1);
01891 memcpy(&user->options, &global_options, sizeof(user->options));
01892
01893 strncpy(user->context, default_context, sizeof(user->context) - 1);
01894 while(v) {
01895 if (!strcasecmp(v->name, "context")) {
01896 strncpy(user->context, v->value, sizeof(user->context) - 1);
01897 } else if (!update_common_options(v, &user->options)) {
01898
01899 } else if (!strcasecmp(v->name, "secret")) {
01900 strncpy(user->secret, v->value, sizeof(user->secret) - 1);
01901 } else if (!strcasecmp(v->name, "callerid")) {
01902 strncpy(user->callerid, v->value, sizeof(user->callerid) - 1);
01903 } else if (!strcasecmp(v->name, "accountcode")) {
01904 strncpy(user->accountcode, v->value, sizeof(user->accountcode) - 1);
01905 } else if (!strcasecmp(v->name, "host")) {
01906 if (!strcasecmp(v->value, "dynamic")) {
01907 ast_log(LOG_ERROR, "A dynamic host on a type=user does not make any sense\n");
01908 free(user);
01909 return NULL;
01910 } else if (ast_get_ip(&user->addr, v->value)) {
01911 free(user);
01912 return NULL;
01913 }
01914
01915 user->host = 1;
01916 } else if (!strcasecmp(v->name, "amaflags")) {
01917 format = ast_cdr_amaflags2int(v->value);
01918 if (format < 0) {
01919 ast_log(LOG_WARNING, "Invalid AMA Flags: %s at line %d\n", v->value, v->lineno);
01920 } else {
01921 user->amaflags = format;
01922 }
01923 }
01924 v = v->next;
01925 }
01926 }
01927 return user;
01928 }
01929
01930 static struct oh323_peer *build_peer(char *name, struct ast_variable *v)
01931 {
01932 struct oh323_peer *peer;
01933 struct oh323_peer *prev;
01934 struct ast_ha *oldha = NULL;
01935 int found=0;
01936
01937 prev = NULL;
01938 ast_mutex_lock(&peerl.lock);
01939 peer = peerl.peers;
01940
01941 while(peer) {
01942 if (!strcasecmp(peer->name, name)) {
01943 break;
01944 }
01945 prev = peer;
01946 peer = peer->next;
01947 }
01948
01949 if (peer) {
01950 found++;
01951
01952 if (prev) {
01953 prev->next = peer->next;
01954 } else {
01955 peerl.peers = peer->next;
01956 }
01957 ast_mutex_unlock(&peerl.lock);
01958 } else {
01959 ast_mutex_unlock(&peerl.lock);
01960 peer = (struct oh323_peer*)malloc(sizeof(struct oh323_peer));
01961 if (peer)
01962 memset(peer, 0, sizeof(struct oh323_peer));
01963 }
01964 if (peer) {
01965 if (!found) {
01966 strncpy(peer->name, name, sizeof(peer->name) - 1);
01967 peer->addr.sin_port = htons(h323_signalling_port);
01968 peer->addr.sin_family = AF_INET;
01969 }
01970 oldha = peer->ha;
01971 peer->ha = NULL;
01972 peer->addr.sin_family = AF_INET;
01973 memcpy(&peer->options, &global_options, sizeof(peer->options));
01974
01975 while(v) {
01976 if (!update_common_options(v, &peer->options)) {
01977
01978 } else if (!strcasecmp(v->name, "host")) {
01979 if (!strcasecmp(v->value, "dynamic")) {
01980 ast_log(LOG_ERROR, "Dynamic host configuration not implemented.\n");
01981 free(peer);
01982 return NULL;
01983 }
01984 if (ast_get_ip(&peer->addr, v->value)) {
01985 ast_log(LOG_ERROR, "Could not determine IP for %s\n", v->value);
01986 free(peer);
01987 return NULL;
01988 }
01989 } else if (!strcasecmp(v->name, "port")) {
01990 peer->addr.sin_port = htons(atoi(v->value));
01991 }
01992 v=v->next;
01993 }
01994 }
01995 return peer;
01996 }
01997
01998 int reload_config(void)
01999 {
02000 int format;
02001 struct ast_config *cfg;
02002 struct ast_variable *v;
02003 struct oh323_peer *peer = NULL;
02004 struct oh323_user *user = NULL;
02005 struct oh323_alias *alias = NULL;
02006 struct ast_hostent ahp; struct hostent *hp;
02007 char *cat;
02008 char *utype;
02009
02010 cfg = ast_config_load(config);
02011
02012
02013 if (!cfg) {
02014 ast_log(LOG_NOTICE, "Unable to load config %s, H.323 disabled\n", config);
02015 return 1;
02016 }
02017
02018
02019 if (!h323_end_point_exist()) {
02020 h323_end_point_create();
02021 }
02022 h323debug = 0;
02023 memset(&bindaddr, 0, sizeof(bindaddr));
02024 memset(&global_options, 0, sizeof(global_options));
02025 global_options.dtmfcodec = 101;
02026 global_options.dtmfmode = H323_DTMF_RFC2833;
02027 global_options.capability = ~0;
02028 global_options.bridge = 1;
02029 v = ast_variable_browse(cfg, "general");
02030 while(v) {
02031
02032 if (!strcasecmp(v->name, "port")) {
02033 h323_signalling_port = (int)strtol(v->value, NULL, 10);
02034 } else if (!strcasecmp(v->name, "bindaddr")) {
02035 if (!(hp = ast_gethostbyname(v->value, &ahp))) {
02036 ast_log(LOG_WARNING, "Invalid address: %s\n", v->value);
02037 } else {
02038 memcpy(&bindaddr.sin_addr, hp->h_addr, sizeof(bindaddr.sin_addr));
02039 }
02040 } else if (!strcasecmp(v->name, "tos")) {
02041 if (sscanf(v->value, "%d", &format)) {
02042 tos = format & 0xff;
02043 } else if (!strcasecmp(v->value, "lowdelay")) {
02044 tos = IPTOS_LOWDELAY;
02045 } else if (!strcasecmp(v->value, "throughput")) {
02046 tos = IPTOS_THROUGHPUT;
02047 } else if (!strcasecmp(v->value, "reliability")) {
02048 tos = IPTOS_RELIABILITY;
02049 } else if (!strcasecmp(v->value, "mincost")) {
02050 tos = IPTOS_MINCOST;
02051 } else if (!strcasecmp(v->value, "none")) {
02052 tos = 0;
02053 } else {
02054 ast_log(LOG_WARNING, "Invalid tos value at line %d, should be 'lowdelay', 'throughput', 'reliability', 'mincost', or 'none'\n", v->lineno);
02055 }
02056 } else if (!strcasecmp(v->name, "gatekeeper")) {
02057 if (!strcasecmp(v->value, "DISABLE")) {
02058 gatekeeper_disable = 1;
02059 usingGk = 0;
02060 } else if (!strcasecmp(v->value, "DISCOVER")) {
02061 gatekeeper_disable = 0;
02062 gatekeeper_discover = 1;
02063 usingGk = 1;
02064 } else {
02065 gatekeeper_disable = 0;
02066 usingGk = 1;
02067 strncpy(gatekeeper, v->value, sizeof(gatekeeper) - 1);
02068 }
02069 } else if (!strcasecmp(v->name, "secret")) {
02070 strncpy(secret, v->value, sizeof(secret) - 1);
02071 } else if (!strcasecmp(v->name, "AllowGKRouted")) {
02072 gkroute = ast_true(v->value);
02073 } else if (!strcasecmp(v->name, "context")) {
02074 strncpy(default_context, v->value, sizeof(default_context) - 1);
02075 ast_verbose(VERBOSE_PREFIX_2 "Setting default context to %s\n", default_context);
02076 } else if (!strcasecmp(v->name, "UserByAlias")) {
02077 userbyalias = ast_true(v->value);
02078 } else if (!update_common_options(v, &global_options)) {
02079
02080 }
02081 v = v->next;
02082 }
02083
02084 cat = ast_category_browse(cfg, NULL);
02085 while(cat) {
02086 if (strcasecmp(cat, "general")) {
02087 utype = ast_variable_retrieve(cfg, cat, "type");
02088 if (utype) {
02089 if (!strcasecmp(utype, "user")) {
02090 user = build_user(cat, ast_variable_browse(cfg, cat));
02091 if (user) {
02092 ast_mutex_lock(&userl.lock);
02093 user->next = userl.users;
02094 userl.users = user;
02095 ast_mutex_unlock(&userl.lock);
02096 }
02097 } else if (!strcasecmp(utype, "peer")) {
02098 peer = build_peer(cat, ast_variable_browse(cfg, cat));
02099 if (peer) {
02100 ast_mutex_lock(&peerl.lock);
02101 peer->next = peerl.peers;
02102 peerl.peers = peer;
02103 ast_mutex_unlock(&peerl.lock);
02104 }
02105 } else if (!strcasecmp(utype, "friend")) {
02106 user = build_user(cat, ast_variable_browse(cfg, cat));
02107 peer = build_peer(cat, ast_variable_browse(cfg, cat));
02108 if (user) {
02109 ast_mutex_lock(&userl.lock);
02110 user->next = userl.users;
02111 userl.users = user;
02112 ast_mutex_unlock(&userl.lock);
02113 }
02114 if (peer) {
02115 ast_mutex_lock(&peerl.lock);
02116 peer->next = peerl.peers;
02117 peerl.peers = peer;
02118 ast_mutex_unlock(&peerl.lock);
02119 }
02120 } else if (!strcasecmp(utype, "h323") || !strcasecmp(utype, "alias")) {
02121 alias = build_alias(cat, ast_variable_browse(cfg, cat));
02122 if (alias) {
02123 ast_mutex_lock(&aliasl.lock);
02124 alias->next = aliasl.aliases;
02125 aliasl.aliases = alias;
02126 ast_mutex_unlock(&aliasl.lock);
02127 }
02128 } else {
02129 ast_log(LOG_WARNING, "Unknown type '%s' for '%s' in %s\n", utype, cat, config);
02130 }
02131 } else {
02132 ast_log(LOG_WARNING, "Section '%s' lacks type\n", cat);
02133 }
02134 }
02135 cat = ast_category_browse(cfg, cat);
02136 }
02137 ast_config_destroy(cfg);
02138
02139
02140 while (alias) {
02141 if (h323_set_alias(alias)) {
02142 ast_log(LOG_ERROR, "Alias %s rejected by endpoint\n", alias->name);
02143 return -1;
02144 }
02145 alias = alias->next;
02146 }
02147
02148 return 0;
02149 }
02150
02151 void delete_users(void)
02152 {
02153 struct oh323_user *user, *userlast;
02154 struct oh323_peer *peer;
02155
02156
02157 ast_mutex_lock(&userl.lock);
02158 for (user=userl.users;user;) {
02159 userlast = user;
02160 user=user->next;
02161 free(userlast);
02162 }
02163 userl.users=NULL;
02164 ast_mutex_unlock(&userl.lock);
02165 ast_mutex_lock(&peerl.lock);
02166 for (peer=peerl.peers;peer;) {
02167
02168 peer->delme = 1;
02169 peer = peer->next;
02170 }
02171 ast_mutex_unlock(&peerl.lock);
02172 }
02173
02174 void delete_aliases(void)
02175 {
02176 struct oh323_alias *alias, *aliaslast;
02177
02178
02179 ast_mutex_lock(&aliasl.lock);
02180 for (alias=aliasl.aliases;alias;) {
02181 aliaslast = alias;
02182 alias=alias->next;
02183 free(aliaslast);
02184 }
02185 aliasl.aliases=NULL;
02186 ast_mutex_unlock(&aliasl.lock);
02187 }
02188
02189 void prune_peers(void)
02190 {
02191
02192 struct oh323_peer *peer, *peerlast, *peernext;
02193 ast_mutex_lock(&peerl.lock);
02194 peerlast = NULL;
02195 for (peer=peerl.peers;peer;) {
02196 peernext = peer->next;
02197 if (peer->delme) {
02198 free(peer);
02199 if (peerlast) {
02200 peerlast->next = peernext;
02201 } else {
02202 peerl.peers = peernext;
02203 }
02204 } else {
02205 peerlast = peer;
02206 }
02207 peer = peernext;
02208 }
02209 ast_mutex_unlock(&peerl.lock);
02210 }
02211
02212 static int h323_reload(int fd, int argc, char *argv[])
02213 {
02214 ast_mutex_lock(&h323_reload_lock);
02215 if (h323_reloading) {
02216 ast_verbose("Previous H.323 reload not yet done\n");
02217 } else {
02218 h323_reloading = 1;
02219 }
02220 ast_mutex_unlock(&h323_reload_lock);
02221 restart_monitor();
02222 return 0;
02223 }
02224
02225 static int h323_do_reload(void)
02226 {
02227 delete_users();
02228 delete_aliases();
02229 prune_peers();
02230 reload_config();
02231 restart_monitor();
02232 return 0;
02233 }
02234
02235 int reload(void)
02236 {
02237 return h323_reload(0, 0, NULL);
02238 }
02239
02240 static struct ast_cli_entry cli_h323_reload =
02241 { { "h.323", "reload", NULL }, h323_reload, "Reload H.323 configuration", h323_reload_usage };
02242
02243 static struct ast_rtp *oh323_get_rtp_peer(struct ast_channel *chan)
02244 {
02245 struct oh323_pvt *pvt;
02246 pvt = (struct oh323_pvt *) chan->tech_pvt;
02247 if (pvt && pvt->rtp && pvt->options.bridge) {
02248 return pvt->rtp;
02249 }
02250 return NULL;
02251 }
02252
02253 static struct ast_rtp *oh323_get_vrtp_peer(struct ast_channel *chan)
02254 {
02255 return NULL;
02256 }
02257
02258 static char *convertcap(int cap)
02259 {
02260 switch (cap) {
02261 case AST_FORMAT_G723_1:
02262 return "G.723";
02263 case AST_FORMAT_GSM:
02264 return "GSM";
02265 case AST_FORMAT_ULAW:
02266 return "ULAW";
02267 case AST_FORMAT_ALAW:
02268 return "ALAW";
02269 case AST_FORMAT_ADPCM:
02270 return "G.728";
02271 case AST_FORMAT_G729A:
02272 return "G.729";
02273 case AST_FORMAT_SPEEX:
02274 return "SPEEX";
02275 case AST_FORMAT_ILBC:
02276 return "ILBC";
02277 default:
02278 ast_log(LOG_NOTICE, "Don't know how to deal with mode %d\n", cap);
02279 return NULL;
02280 }
02281 }
02282
02283 static int oh323_set_rtp_peer(struct ast_channel *chan, struct ast_rtp *rtp, struct ast_rtp *vrtp, int codecs, int nat_active)
02284 {
02285
02286 struct oh323_pvt *pvt;
02287 struct sockaddr_in them;
02288 struct sockaddr_in us;
02289 char *mode;
02290 char iabuf[INET_ADDRSTRLEN];
02291
02292 if (!rtp) {
02293 return 0;
02294 }
02295
02296 mode = convertcap(chan->writeformat);
02297 pvt = (struct oh323_pvt *) chan->tech_pvt;
02298 if (!pvt) {
02299 ast_log(LOG_ERROR, "No Private Structure, this is bad\n");
02300 return -1;
02301 }
02302 ast_rtp_get_peer(rtp, &them);
02303 ast_rtp_get_us(rtp, &us);
02304 h323_native_bridge(pvt->cd.call_token, ast_inet_ntoa(iabuf, sizeof(iabuf), them.sin_addr), mode);
02305 return 0;
02306 }
02307
02308 static struct ast_rtp_protocol oh323_rtp = {
02309 .type = type,
02310 .get_rtp_info = oh323_get_rtp_peer,
02311 .get_vrtp_info = oh323_get_vrtp_peer,
02312 .set_rtp_peer = oh323_set_rtp_peer,
02313 };
02314
02315 int load_module()
02316 {
02317 int res;
02318 ast_mutex_init(&userl.lock);
02319 ast_mutex_init(&peerl.lock);
02320 ast_mutex_init(&aliasl.lock);
02321 sched = sched_context_create();
02322 if (!sched) {
02323 ast_log(LOG_WARNING, "Unable to create schedule context\n");
02324 }
02325 io = io_context_create();
02326 if (!io) {
02327 ast_log(LOG_WARNING, "Unable to create I/O context\n");
02328 }
02329 res = reload_config();
02330 if (res) {
02331 return 0;
02332 } else {
02333
02334 if (ast_channel_register(&oh323_tech)) {
02335 ast_log(LOG_ERROR, "Unable to register channel class %s\n", type);
02336 h323_end_process();
02337 return -1;
02338 }
02339 ast_cli_register(&cli_debug);
02340 ast_cli_register(&cli_no_debug);
02341 ast_cli_register(&cli_trace);
02342 ast_cli_register(&cli_no_trace);
02343 ast_cli_register(&cli_show_codecs);
02344 ast_cli_register(&cli_gk_cycle);
02345 ast_cli_register(&cli_hangup_call);
02346 ast_cli_register(&cli_show_tokens);
02347 ast_cli_register(&cli_h323_reload);
02348
02349 ast_rtp_proto_register(&oh323_rtp);
02350
02351
02352 h323_callback_register(setup_incoming_call,
02353 setup_outgoing_call,
02354 external_rtp_create,
02355 setup_rtp_connection,
02356 cleanup_connection,
02357 chan_ringing,
02358 connection_made,
02359 send_digit,
02360 answer_call,
02361 progress,
02362 set_dtmf_payload,
02363 hangup_connection,
02364 set_local_capabilities);
02365
02366 if (h323_start_listener(h323_signalling_port, bindaddr)) {
02367 ast_log(LOG_ERROR, "Unable to create H323 listener.\n");
02368 return -1;
02369 }
02370
02371 if (!gatekeeper_disable) {
02372 if (h323_set_gk(gatekeeper_discover, gatekeeper, secret)) {
02373 ast_log(LOG_ERROR, "Gatekeeper registration failed.\n");
02374 return 0;
02375 }
02376 }
02377
02378 restart_monitor();
02379 }
02380 return res;
02381 }
02382
02383 int unload_module()
02384 {
02385 struct oh323_pvt *p, *pl;
02386
02387
02388 ast_cli_unregister(&cli_debug);
02389 ast_cli_unregister(&cli_no_debug);
02390 ast_cli_unregister(&cli_trace);
02391 ast_cli_unregister(&cli_no_trace);
02392 ast_cli_unregister(&cli_show_codecs);
02393 ast_cli_unregister(&cli_gk_cycle);
02394 ast_cli_unregister(&cli_hangup_call);
02395 ast_cli_unregister(&cli_show_tokens);
02396 ast_cli_unregister(&cli_h323_reload);
02397 ast_rtp_proto_unregister(&oh323_rtp);
02398 ast_channel_unregister(&oh323_tech);
02399
02400 if (!ast_mutex_lock(&iflock)) {
02401
02402 p = iflist;
02403 while(p) {
02404 if (p->owner) {
02405 ast_softhangup(p->owner, AST_SOFTHANGUP_APPUNLOAD);
02406 }
02407 p = p->next;
02408 }
02409 iflist = NULL;
02410 ast_mutex_unlock(&iflock);
02411 } else {
02412 ast_log(LOG_WARNING, "Unable to lock the interface list\n");
02413 return -1;
02414 }
02415 if (!ast_mutex_lock(&monlock)) {
02416 if (monitor_thread && (monitor_thread != AST_PTHREADT_STOP)) {
02417
02418 pthread_cancel(monitor_thread);
02419 pthread_kill(monitor_thread, SIGURG);
02420 pthread_join(monitor_thread, NULL);
02421 }
02422 monitor_thread = AST_PTHREADT_STOP;
02423 ast_mutex_unlock(&monlock);
02424 } else {
02425 ast_log(LOG_WARNING, "Unable to lock the monitor\n");
02426 return -1;
02427 }
02428 if (!ast_mutex_lock(&iflock)) {
02429
02430 p = iflist;
02431 while(p) {
02432 pl = p;
02433 p = p->next;
02434
02435 ast_mutex_destroy(&pl->lock);
02436 free(pl);
02437 }
02438 iflist = NULL;
02439 ast_mutex_unlock(&iflock);
02440 } else {
02441 ast_log(LOG_WARNING, "Unable to lock the interface list\n");
02442 return -1;
02443 }
02444 h323_gk_urq();
02445 h323_end_process();
02446 io_context_destroy(io);
02447 sched_context_destroy(sched);
02448 delete_users();
02449 delete_aliases();
02450 prune_peers();
02451 ast_mutex_destroy(&aliasl.lock);
02452 ast_mutex_destroy(&userl.lock);
02453 ast_mutex_destroy(&peerl.lock);
02454 return 0;
02455 }
02456
02457 int usecount()
02458 {
02459 return usecnt;
02460 }
02461
02462 char *description()
02463 {
02464 return (char *) desc;
02465 }
02466
02467 char *key()
02468 {
02469 return ASTERISK_GPL_KEY;
02470 }