00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018 #include "asterisk.h"
00019
00020 ASTERISK_FILE_VERSION(__FILE__, "$Revision: 91450 $")
00021
00022 #include <stdio.h>
00023 #include <stdlib.h>
00024 #include <string.h>
00025 #include <sys/time.h>
00026 #include <signal.h>
00027 #include <errno.h>
00028 #include <unistd.h>
00029 #include <netinet/in.h>
00030 #include <sys/time.h>
00031 #include <sys/socket.h>
00032 #include <arpa/inet.h>
00033 #include <fcntl.h>
00034
00035 #include "asterisk/udptl.h"
00036 #include "asterisk/frame.h"
00037 #include "asterisk/logger.h"
00038 #include "asterisk/options.h"
00039 #include "asterisk/channel.h"
00040 #include "asterisk/acl.h"
00041 #include "asterisk/channel.h"
00042 #include "asterisk/config.h"
00043 #include "asterisk/lock.h"
00044 #include "asterisk/utils.h"
00045 #include "asterisk/cli.h"
00046 #include "asterisk/unaligned.h"
00047 #include "asterisk/utils.h"
00048
00049 #define UDPTL_MTU 1200
00050
00051 #if !defined(FALSE)
00052 #define FALSE 0
00053 #endif
00054 #if !defined(TRUE)
00055 #define TRUE (!FALSE)
00056 #endif
00057
00058 static int udptlstart;
00059 static int udptlend;
00060 static int udptldebug;
00061 static struct sockaddr_in udptldebugaddr;
00062 #ifdef SO_NO_CHECK
00063 static int nochecksums;
00064 #endif
00065 static int udptlfectype;
00066 static int udptlfecentries;
00067 static int udptlfecspan;
00068 static int udptlmaxdatagram;
00069
00070 #define LOCAL_FAX_MAX_DATAGRAM 400
00071 #define MAX_FEC_ENTRIES 5
00072 #define MAX_FEC_SPAN 5
00073
00074 #define UDPTL_BUF_MASK 15
00075
00076 typedef struct {
00077 int buf_len;
00078 uint8_t buf[LOCAL_FAX_MAX_DATAGRAM];
00079 } udptl_fec_tx_buffer_t;
00080
00081 typedef struct {
00082 int buf_len;
00083 uint8_t buf[LOCAL_FAX_MAX_DATAGRAM];
00084 int fec_len[MAX_FEC_ENTRIES];
00085 uint8_t fec[MAX_FEC_ENTRIES][LOCAL_FAX_MAX_DATAGRAM];
00086 int fec_span;
00087 int fec_entries;
00088 } udptl_fec_rx_buffer_t;
00089
00090 struct ast_udptl {
00091 int fd;
00092 char resp;
00093 struct ast_frame f[16];
00094 unsigned char rawdata[8192 + AST_FRIENDLY_OFFSET];
00095 unsigned int lasteventseqn;
00096 int nat;
00097 int flags;
00098 struct sockaddr_in us;
00099 struct sockaddr_in them;
00100 int *ioid;
00101 struct sched_context *sched;
00102 struct io_context *io;
00103 void *data;
00104 ast_udptl_callback callback;
00105 int udptl_offered_from_local;
00106
00107
00108
00109 int error_correction_scheme;
00110
00111
00112
00113 int error_correction_entries;
00114
00115
00116
00117 int error_correction_span;
00118
00119
00120
00121 int far_max_datagram_size;
00122
00123
00124
00125 int local_max_datagram_size;
00126
00127 int verbose;
00128
00129 struct sockaddr_in far;
00130
00131 int tx_seq_no;
00132 int rx_seq_no;
00133 int rx_expected_seq_no;
00134
00135 udptl_fec_tx_buffer_t tx[UDPTL_BUF_MASK + 1];
00136 udptl_fec_rx_buffer_t rx[UDPTL_BUF_MASK + 1];
00137 };
00138
00139 static struct ast_udptl_protocol *protos;
00140
00141 static int udptl_rx_packet(struct ast_udptl *s, uint8_t *buf, int len);
00142 static int udptl_build_packet(struct ast_udptl *s, uint8_t *buf, uint8_t *ifp, int ifp_len);
00143
00144 static inline int udptl_debug_test_addr(struct sockaddr_in *addr)
00145 {
00146 if (udptldebug == 0)
00147 return 0;
00148 if (udptldebugaddr.sin_addr.s_addr) {
00149 if (((ntohs(udptldebugaddr.sin_port) != 0)
00150 && (udptldebugaddr.sin_port != addr->sin_port))
00151 || (udptldebugaddr.sin_addr.s_addr != addr->sin_addr.s_addr))
00152 return 0;
00153 }
00154 return 1;
00155 }
00156
00157 static int decode_length(uint8_t *buf, int limit, int *len, int *pvalue)
00158 {
00159 if ((buf[*len] & 0x80) == 0) {
00160 if (*len >= limit)
00161 return -1;
00162 *pvalue = buf[*len];
00163 (*len)++;
00164 return 0;
00165 }
00166 if ((buf[*len] & 0x40) == 0) {
00167 if (*len >= limit - 1)
00168 return -1;
00169 *pvalue = (buf[*len] & 0x3F) << 8;
00170 (*len)++;
00171 *pvalue |= buf[*len];
00172 (*len)++;
00173 return 0;
00174 }
00175 if (*len >= limit)
00176 return -1;
00177 *pvalue = (buf[*len] & 0x3F) << 14;
00178 (*len)++;
00179
00180 return 1;
00181 }
00182
00183
00184 static int decode_open_type(uint8_t *buf, int limit, int *len, const uint8_t **p_object, int *p_num_octets)
00185 {
00186 int octet_cnt;
00187 int octet_idx;
00188 int stat;
00189 int i;
00190 const uint8_t **pbuf;
00191
00192 for (octet_idx = 0, *p_num_octets = 0; ; octet_idx += octet_cnt) {
00193 if ((stat = decode_length(buf, limit, len, &octet_cnt)) < 0)
00194 return -1;
00195 if (octet_cnt > 0) {
00196 *p_num_octets += octet_cnt;
00197
00198 pbuf = &p_object[octet_idx];
00199 i = 0;
00200
00201 if ((*len + octet_cnt) > limit)
00202 return -1;
00203
00204 *pbuf = &buf[*len];
00205 *len += octet_cnt;
00206 }
00207 if (stat == 0)
00208 break;
00209 }
00210 return 0;
00211 }
00212
00213
00214 static int encode_length(uint8_t *buf, int *len, int value)
00215 {
00216 int multiplier;
00217
00218 if (value < 0x80) {
00219
00220 buf[*len] = value;
00221 (*len)++;
00222 return value;
00223 }
00224 if (value < 0x4000) {
00225
00226
00227 buf[*len] = ((0x8000 | value) >> 8) & 0xFF;
00228 (*len)++;
00229 buf[*len] = value & 0xFF;
00230 (*len)++;
00231 return value;
00232 }
00233
00234 multiplier = (value < 0x10000) ? (value >> 14) : 4;
00235
00236 buf[*len] = 0xC0 | multiplier;
00237 (*len)++;
00238 return multiplier << 14;
00239 }
00240
00241
00242 static int encode_open_type(uint8_t *buf, int *len, const uint8_t *data, int num_octets)
00243 {
00244 int enclen;
00245 int octet_idx;
00246 uint8_t zero_byte;
00247
00248
00249 if (num_octets == 0) {
00250 zero_byte = 0;
00251 data = &zero_byte;
00252 num_octets = 1;
00253 }
00254
00255 for (octet_idx = 0; ; num_octets -= enclen, octet_idx += enclen) {
00256 if ((enclen = encode_length(buf, len, num_octets)) < 0)
00257 return -1;
00258 if (enclen > 0) {
00259 memcpy(&buf[*len], &data[octet_idx], enclen);
00260 *len += enclen;
00261 }
00262 if (enclen >= num_octets)
00263 break;
00264 }
00265
00266 return 0;
00267 }
00268
00269
00270 static int udptl_rx_packet(struct ast_udptl *s, uint8_t *buf, int len)
00271 {
00272 int stat;
00273 int stat2;
00274 int i;
00275 int j;
00276 int k;
00277 int l;
00278 int m;
00279 int x;
00280 int limit;
00281 int which;
00282 int ptr;
00283 int count;
00284 int total_count;
00285 int seq_no;
00286 const uint8_t *ifp;
00287 const uint8_t *data;
00288 int ifp_len;
00289 int repaired[16];
00290 const uint8_t *bufs[16];
00291 int lengths[16];
00292 int span;
00293 int entries;
00294 int ifp_no;
00295
00296 ptr = 0;
00297 ifp_no = 0;
00298 memset(&s->f[0], 0, sizeof(s->f[0]));
00299
00300
00301 if (ptr + 2 > len)
00302 return -1;
00303 seq_no = (buf[0] << 8) | buf[1];
00304 ptr += 2;
00305
00306
00307 if ((stat = decode_open_type(buf, len, &ptr, &ifp, &ifp_len)) != 0)
00308 return -1;
00309
00310 if (ptr + 1 > len)
00311 return -1;
00312 if ((buf[ptr++] & 0x80) == 0) {
00313
00314 if (seq_no > s->rx_seq_no) {
00315
00316
00317 total_count = 0;
00318 do {
00319 if ((stat2 = decode_length(buf, len, &ptr, &count)) < 0)
00320 return -1;
00321 for (i = 0; i < count; i++) {
00322 if ((stat = decode_open_type(buf, len, &ptr, &bufs[total_count + i], &lengths[total_count + i])) != 0)
00323 return -1;
00324 }
00325 total_count += count;
00326 }
00327 while (stat2 > 0);
00328
00329 for (i = total_count; i > 0; i--) {
00330 if (seq_no - i >= s->rx_seq_no) {
00331
00332
00333
00334 s->f[ifp_no].frametype = AST_FRAME_MODEM;
00335 s->f[ifp_no].subclass = AST_MODEM_T38;
00336
00337 s->f[ifp_no].mallocd = 0;
00338 s->f[ifp_no].seqno = seq_no - i;
00339 s->f[ifp_no].datalen = lengths[i - 1];
00340 s->f[ifp_no].data = (uint8_t *) bufs[i - 1];
00341 s->f[ifp_no].offset = 0;
00342 s->f[ifp_no].src = "UDPTL";
00343 if (ifp_no > 0)
00344 AST_LIST_NEXT(&s->f[ifp_no - 1], frame_list) = &s->f[ifp_no];
00345 AST_LIST_NEXT(&s->f[ifp_no], frame_list) = NULL;
00346 ifp_no++;
00347 }
00348 }
00349 }
00350 }
00351 else
00352 {
00353
00354
00355 if (ifp_len > LOCAL_FAX_MAX_DATAGRAM)
00356 return -1;
00357
00358 for ( ; seq_no > s->rx_seq_no; s->rx_seq_no++) {
00359 x = s->rx_seq_no & UDPTL_BUF_MASK;
00360 s->rx[x].buf_len = -1;
00361 s->rx[x].fec_len[0] = 0;
00362 s->rx[x].fec_span = 0;
00363 s->rx[x].fec_entries = 0;
00364 }
00365
00366 x = seq_no & UDPTL_BUF_MASK;
00367
00368 memset(repaired, 0, sizeof(repaired));
00369
00370
00371 memcpy(s->rx[x].buf, ifp, ifp_len);
00372 s->rx[x].buf_len = ifp_len;
00373 repaired[x] = TRUE;
00374
00375
00376
00377
00378 if (ptr + 2 > len)
00379 return -1;
00380 if (buf[ptr++] != 1)
00381 return -1;
00382 span = buf[ptr++];
00383 s->rx[x].fec_span = span;
00384
00385
00386
00387 if (ptr + 1 > len)
00388 return -1;
00389 entries = buf[ptr++];
00390 s->rx[x].fec_entries = entries;
00391
00392
00393 for (i = 0; i < entries; i++) {
00394 if ((stat = decode_open_type(buf, len, &ptr, &data, &s->rx[x].fec_len[i])) != 0)
00395 return -1;
00396 if (s->rx[x].fec_len[i] > LOCAL_FAX_MAX_DATAGRAM)
00397 return -1;
00398
00399
00400 memcpy(s->rx[x].fec[i], data, s->rx[x].fec_len[i]);
00401 #if 0
00402 fprintf(stderr, "FEC: ");
00403 for (j = 0; j < s->rx[x].fec_len[i]; j++)
00404 fprintf(stderr, "%02X ", data[j]);
00405 fprintf(stderr, "\n");
00406 #endif
00407 }
00408
00409
00410
00411 for (l = x; l != ((x - (16 - span*entries)) & UDPTL_BUF_MASK); l = (l - 1) & UDPTL_BUF_MASK) {
00412 if (s->rx[l].fec_len[0] <= 0)
00413 continue;
00414 for (m = 0; m < s->rx[l].fec_entries; m++) {
00415 limit = (l + m) & UDPTL_BUF_MASK;
00416 for (which = -1, k = (limit - s->rx[l].fec_span * s->rx[l].fec_entries) & UDPTL_BUF_MASK; k != limit; k = (k + s->rx[l].fec_entries) & UDPTL_BUF_MASK) {
00417 if (s->rx[k].buf_len <= 0)
00418 which = (which == -1) ? k : -2;
00419 }
00420 if (which >= 0) {
00421
00422 for (j = 0; j < s->rx[l].fec_len[m]; j++) {
00423 s->rx[which].buf[j] = s->rx[l].fec[m][j];
00424 for (k = (limit - s->rx[l].fec_span * s->rx[l].fec_entries) & UDPTL_BUF_MASK; k != limit; k = (k + s->rx[l].fec_entries) & UDPTL_BUF_MASK)
00425 s->rx[which].buf[j] ^= (s->rx[k].buf_len > j) ? s->rx[k].buf[j] : 0;
00426 }
00427 s->rx[which].buf_len = s->rx[l].fec_len[m];
00428 repaired[which] = TRUE;
00429 }
00430 }
00431 }
00432
00433 for (l = (x + 1) & UDPTL_BUF_MASK, j = seq_no - UDPTL_BUF_MASK; l != x; l = (l + 1) & UDPTL_BUF_MASK, j++) {
00434 if (repaired[l]) {
00435
00436 s->f[ifp_no].frametype = AST_FRAME_MODEM;
00437 s->f[ifp_no].subclass = AST_MODEM_T38;
00438
00439 s->f[ifp_no].mallocd = 0;
00440 s->f[ifp_no].seqno = j;
00441 s->f[ifp_no].datalen = s->rx[l].buf_len;
00442 s->f[ifp_no].data = s->rx[l].buf;
00443 s->f[ifp_no].offset = 0;
00444 s->f[ifp_no].src = "UDPTL";
00445 if (ifp_no > 0)
00446 AST_LIST_NEXT(&s->f[ifp_no - 1], frame_list) = &s->f[ifp_no];
00447 AST_LIST_NEXT(&s->f[ifp_no], frame_list) = NULL;
00448 ifp_no++;
00449 }
00450 }
00451 }
00452
00453
00454
00455 if (seq_no >= s->rx_seq_no) {
00456
00457 s->f[ifp_no].frametype = AST_FRAME_MODEM;
00458 s->f[ifp_no].subclass = AST_MODEM_T38;
00459
00460 s->f[ifp_no].mallocd = 0;
00461 s->f[ifp_no].seqno = seq_no;
00462 s->f[ifp_no].datalen = ifp_len;
00463 s->f[ifp_no].data = (uint8_t *) ifp;
00464 s->f[ifp_no].offset = 0;
00465 s->f[ifp_no].src = "UDPTL";
00466 if (ifp_no > 0)
00467 AST_LIST_NEXT(&s->f[ifp_no - 1], frame_list) = &s->f[ifp_no];
00468 AST_LIST_NEXT(&s->f[ifp_no], frame_list) = NULL;
00469
00470 ifp_no++;
00471 }
00472
00473 s->rx_seq_no = seq_no + 1;
00474 return ifp_no;
00475 }
00476
00477
00478 static int udptl_build_packet(struct ast_udptl *s, uint8_t *buf, uint8_t *ifp, int ifp_len)
00479 {
00480 uint8_t fec[LOCAL_FAX_MAX_DATAGRAM];
00481 int i;
00482 int j;
00483 int seq;
00484 int entry;
00485 int entries;
00486 int span;
00487 int m;
00488 int len;
00489 int limit;
00490 int high_tide;
00491
00492 seq = s->tx_seq_no & 0xFFFF;
00493
00494
00495 entry = seq & UDPTL_BUF_MASK;
00496
00497
00498
00499 s->tx[entry].buf_len = ifp_len;
00500 memcpy(s->tx[entry].buf, ifp, ifp_len);
00501
00502
00503
00504 len = 0;
00505
00506 buf[len++] = (seq >> 8) & 0xFF;
00507 buf[len++] = seq & 0xFF;
00508
00509
00510 if (encode_open_type(buf, &len, ifp, ifp_len) < 0)
00511 return -1;
00512
00513
00514 switch (s->error_correction_scheme)
00515 {
00516 case UDPTL_ERROR_CORRECTION_NONE:
00517
00518 buf[len++] = 0x00;
00519
00520
00521 if (encode_length(buf, &len, 0) < 0)
00522 return -1;
00523 break;
00524 case UDPTL_ERROR_CORRECTION_REDUNDANCY:
00525
00526 buf[len++] = 0x00;
00527 if (s->tx_seq_no > s->error_correction_entries)
00528 entries = s->error_correction_entries;
00529 else
00530 entries = s->tx_seq_no;
00531
00532
00533 if (encode_length(buf, &len, entries) < 0)
00534 return -1;
00535
00536 for (i = 0; i < entries; i++) {
00537 j = (entry - i - 1) & UDPTL_BUF_MASK;
00538 if (encode_open_type(buf, &len, s->tx[j].buf, s->tx[j].buf_len) < 0)
00539 return -1;
00540 }
00541 break;
00542 case UDPTL_ERROR_CORRECTION_FEC:
00543 span = s->error_correction_span;
00544 entries = s->error_correction_entries;
00545 if (seq < s->error_correction_span*s->error_correction_entries) {
00546
00547 entries = seq/s->error_correction_span;
00548 if (seq < s->error_correction_span)
00549 span = 0;
00550 }
00551
00552 buf[len++] = 0x80;
00553
00554
00555 buf[len++] = 1;
00556 buf[len++] = span;
00557
00558
00559 buf[len++] = entries;
00560 for (m = 0; m < entries; m++) {
00561
00562 limit = (entry + m) & UDPTL_BUF_MASK;
00563 high_tide = 0;
00564 for (i = (limit - span*entries) & UDPTL_BUF_MASK; i != limit; i = (i + entries) & UDPTL_BUF_MASK) {
00565 if (high_tide < s->tx[i].buf_len) {
00566 for (j = 0; j < high_tide; j++)
00567 fec[j] ^= s->tx[i].buf[j];
00568 for ( ; j < s->tx[i].buf_len; j++)
00569 fec[j] = s->tx[i].buf[j];
00570 high_tide = s->tx[i].buf_len;
00571 } else {
00572 for (j = 0; j < s->tx[i].buf_len; j++)
00573 fec[j] ^= s->tx[i].buf[j];
00574 }
00575 }
00576 if (encode_open_type(buf, &len, fec, high_tide) < 0)
00577 return -1;
00578 }
00579 break;
00580 }
00581
00582 if (s->verbose)
00583 fprintf(stderr, "\n");
00584
00585 s->tx_seq_no++;
00586 return len;
00587 }
00588
00589 int ast_udptl_fd(struct ast_udptl *udptl)
00590 {
00591 return udptl->fd;
00592 }
00593
00594 void ast_udptl_set_data(struct ast_udptl *udptl, void *data)
00595 {
00596 udptl->data = data;
00597 }
00598
00599 void ast_udptl_set_callback(struct ast_udptl *udptl, ast_udptl_callback callback)
00600 {
00601 udptl->callback = callback;
00602 }
00603
00604 void ast_udptl_setnat(struct ast_udptl *udptl, int nat)
00605 {
00606 udptl->nat = nat;
00607 }
00608
00609 static int udptlread(int *id, int fd, short events, void *cbdata)
00610 {
00611 struct ast_udptl *udptl = cbdata;
00612 struct ast_frame *f;
00613
00614 if ((f = ast_udptl_read(udptl))) {
00615 if (udptl->callback)
00616 udptl->callback(udptl, f, udptl->data);
00617 }
00618 return 1;
00619 }
00620
00621 struct ast_frame *ast_udptl_read(struct ast_udptl *udptl)
00622 {
00623 int res;
00624 struct sockaddr_in sin;
00625 socklen_t len;
00626 uint16_t seqno = 0;
00627 uint16_t *udptlheader;
00628
00629 len = sizeof(sin);
00630
00631
00632 res = recvfrom(udptl->fd,
00633 udptl->rawdata + AST_FRIENDLY_OFFSET,
00634 sizeof(udptl->rawdata) - AST_FRIENDLY_OFFSET,
00635 0,
00636 (struct sockaddr *) &sin,
00637 &len);
00638 udptlheader = (uint16_t *)(udptl->rawdata + AST_FRIENDLY_OFFSET);
00639 if (res < 0) {
00640 if (errno != EAGAIN)
00641 ast_log(LOG_WARNING, "UDPTL read error: %s\n", strerror(errno));
00642 if (errno == EBADF)
00643 CRASH;
00644 return &ast_null_frame;
00645 }
00646
00647
00648 if (!udptl->them.sin_addr.s_addr || !udptl->them.sin_port)
00649 return &ast_null_frame;
00650
00651 if (udptl->nat) {
00652
00653 if ((udptl->them.sin_addr.s_addr != sin.sin_addr.s_addr) ||
00654 (udptl->them.sin_port != sin.sin_port)) {
00655 memcpy(&udptl->them, &sin, sizeof(udptl->them));
00656 ast_log(LOG_DEBUG, "UDPTL NAT: Using address %s:%d\n", ast_inet_ntoa(udptl->them.sin_addr), ntohs(udptl->them.sin_port));
00657 }
00658 }
00659
00660 if (udptl_debug_test_addr(&sin)) {
00661 ast_verbose("Got UDPTL packet from %s:%d (type %d, seq %d, len %d)\n",
00662 ast_inet_ntoa(sin.sin_addr), ntohs(sin.sin_port), 0, seqno, res);
00663 }
00664 #if 0
00665 printf("Got UDPTL packet from %s:%d (seq %d, len = %d)\n", ast_inet_ntoa(sin.sin_addr), ntohs(sin.sin_port), seqno, res);
00666 #endif
00667 if (udptl_rx_packet(udptl, udptl->rawdata + AST_FRIENDLY_OFFSET, res) < 1)
00668 return &ast_null_frame;
00669
00670 return &udptl->f[0];
00671 }
00672
00673 void ast_udptl_offered_from_local(struct ast_udptl* udptl, int local)
00674 {
00675 if (udptl)
00676 udptl->udptl_offered_from_local = local;
00677 else
00678 ast_log(LOG_WARNING, "udptl structure is null\n");
00679 }
00680
00681 int ast_udptl_get_error_correction_scheme(struct ast_udptl* udptl)
00682 {
00683 if (udptl)
00684 return udptl->error_correction_scheme;
00685 else {
00686 ast_log(LOG_WARNING, "udptl structure is null\n");
00687 return -1;
00688 }
00689 }
00690
00691 void ast_udptl_set_error_correction_scheme(struct ast_udptl* udptl, int ec)
00692 {
00693 if (udptl) {
00694 switch (ec) {
00695 case UDPTL_ERROR_CORRECTION_FEC:
00696 udptl->error_correction_scheme = UDPTL_ERROR_CORRECTION_FEC;
00697 break;
00698 case UDPTL_ERROR_CORRECTION_REDUNDANCY:
00699 udptl->error_correction_scheme = UDPTL_ERROR_CORRECTION_REDUNDANCY;
00700 break;
00701 case UDPTL_ERROR_CORRECTION_NONE:
00702 udptl->error_correction_scheme = UDPTL_ERROR_CORRECTION_NONE;
00703 break;
00704 default:
00705 ast_log(LOG_WARNING, "error correction parameter invalid\n");
00706 };
00707 } else
00708 ast_log(LOG_WARNING, "udptl structure is null\n");
00709 }
00710
00711 int ast_udptl_get_local_max_datagram(struct ast_udptl* udptl)
00712 {
00713 if (udptl)
00714 return udptl->local_max_datagram_size;
00715 else {
00716 ast_log(LOG_WARNING, "udptl structure is null\n");
00717 return -1;
00718 }
00719 }
00720
00721 int ast_udptl_get_far_max_datagram(struct ast_udptl* udptl)
00722 {
00723 if (udptl)
00724 return udptl->far_max_datagram_size;
00725 else {
00726 ast_log(LOG_WARNING, "udptl structure is null\n");
00727 return -1;
00728 }
00729 }
00730
00731 void ast_udptl_set_local_max_datagram(struct ast_udptl* udptl, int max_datagram)
00732 {
00733 if (udptl)
00734 udptl->local_max_datagram_size = max_datagram;
00735 else
00736 ast_log(LOG_WARNING, "udptl structure is null\n");
00737 }
00738
00739 void ast_udptl_set_far_max_datagram(struct ast_udptl* udptl, int max_datagram)
00740 {
00741 if (udptl)
00742 udptl->far_max_datagram_size = max_datagram;
00743 else
00744 ast_log(LOG_WARNING, "udptl structure is null\n");
00745 }
00746
00747 struct ast_udptl *ast_udptl_new_with_bindaddr(struct sched_context *sched, struct io_context *io, int callbackmode, struct in_addr addr)
00748 {
00749 struct ast_udptl *udptl;
00750 int x;
00751 int startplace;
00752 int i;
00753 long int flags;
00754
00755 if (!(udptl = ast_calloc(1, sizeof(*udptl))))
00756 return NULL;
00757
00758 if (udptlfectype == 2)
00759 udptl->error_correction_scheme = UDPTL_ERROR_CORRECTION_FEC;
00760 else if (udptlfectype == 1)
00761 udptl->error_correction_scheme = UDPTL_ERROR_CORRECTION_REDUNDANCY;
00762 else
00763 udptl->error_correction_scheme = UDPTL_ERROR_CORRECTION_NONE;
00764 udptl->error_correction_span = udptlfecspan;
00765 udptl->error_correction_entries = udptlfecentries;
00766
00767 udptl->far_max_datagram_size = udptlmaxdatagram;
00768 udptl->local_max_datagram_size = udptlmaxdatagram;
00769
00770 memset(&udptl->rx, 0, sizeof(udptl->rx));
00771 memset(&udptl->tx, 0, sizeof(udptl->tx));
00772 for (i = 0; i <= UDPTL_BUF_MASK; i++) {
00773 udptl->rx[i].buf_len = -1;
00774 udptl->tx[i].buf_len = -1;
00775 }
00776
00777 udptl->them.sin_family = AF_INET;
00778 udptl->us.sin_family = AF_INET;
00779
00780 if ((udptl->fd = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
00781 free(udptl);
00782 ast_log(LOG_WARNING, "Unable to allocate socket: %s\n", strerror(errno));
00783 return NULL;
00784 }
00785 flags = fcntl(udptl->fd, F_GETFL);
00786 fcntl(udptl->fd, F_SETFL, flags | O_NONBLOCK);
00787 #ifdef SO_NO_CHECK
00788 if (nochecksums)
00789 setsockopt(udptl->fd, SOL_SOCKET, SO_NO_CHECK, &nochecksums, sizeof(nochecksums));
00790 #endif
00791
00792 x = (ast_random() % (udptlend - udptlstart)) + udptlstart;
00793 startplace = x;
00794 for (;;) {
00795 udptl->us.sin_port = htons(x);
00796 udptl->us.sin_addr = addr;
00797 if (bind(udptl->fd, (struct sockaddr *) &udptl->us, sizeof(udptl->us)) == 0)
00798 break;
00799 if (errno != EADDRINUSE) {
00800 ast_log(LOG_WARNING, "Unexpected bind error: %s\n", strerror(errno));
00801 close(udptl->fd);
00802 free(udptl);
00803 return NULL;
00804 }
00805 if (++x > udptlend)
00806 x = udptlstart;
00807 if (x == startplace) {
00808 ast_log(LOG_WARNING, "No UDPTL ports remaining\n");
00809 close(udptl->fd);
00810 free(udptl);
00811 return NULL;
00812 }
00813 }
00814 if (io && sched && callbackmode) {
00815
00816 udptl->sched = sched;
00817 udptl->io = io;
00818 udptl->ioid = ast_io_add(udptl->io, udptl->fd, udptlread, AST_IO_IN, udptl);
00819 }
00820 return udptl;
00821 }
00822
00823 struct ast_udptl *ast_udptl_new(struct sched_context *sched, struct io_context *io, int callbackmode)
00824 {
00825 struct in_addr ia;
00826 memset(&ia, 0, sizeof(ia));
00827 return ast_udptl_new_with_bindaddr(sched, io, callbackmode, ia);
00828 }
00829
00830 int ast_udptl_settos(struct ast_udptl *udptl, int tos)
00831 {
00832 int res;
00833
00834 if ((res = setsockopt(udptl->fd, IPPROTO_IP, IP_TOS, &tos, sizeof(tos))))
00835 ast_log(LOG_WARNING, "UDPTL unable to set TOS to %d\n", tos);
00836 return res;
00837 }
00838
00839 void ast_udptl_set_peer(struct ast_udptl *udptl, struct sockaddr_in *them)
00840 {
00841 udptl->them.sin_port = them->sin_port;
00842 udptl->them.sin_addr = them->sin_addr;
00843 }
00844
00845 void ast_udptl_get_peer(struct ast_udptl *udptl, struct sockaddr_in *them)
00846 {
00847 them->sin_family = AF_INET;
00848 them->sin_port = udptl->them.sin_port;
00849 them->sin_addr = udptl->them.sin_addr;
00850 }
00851
00852 void ast_udptl_get_us(struct ast_udptl *udptl, struct sockaddr_in *us)
00853 {
00854 memcpy(us, &udptl->us, sizeof(udptl->us));
00855 }
00856
00857 void ast_udptl_stop(struct ast_udptl *udptl)
00858 {
00859 memset(&udptl->them.sin_addr, 0, sizeof(udptl->them.sin_addr));
00860 memset(&udptl->them.sin_port, 0, sizeof(udptl->them.sin_port));
00861 }
00862
00863 void ast_udptl_destroy(struct ast_udptl *udptl)
00864 {
00865 if (udptl->ioid)
00866 ast_io_remove(udptl->io, udptl->ioid);
00867 if (udptl->fd > -1)
00868 close(udptl->fd);
00869 free(udptl);
00870 }
00871
00872 int ast_udptl_write(struct ast_udptl *s, struct ast_frame *f)
00873 {
00874 int seq;
00875 int len;
00876 int res;
00877 uint8_t buf[LOCAL_FAX_MAX_DATAGRAM];
00878
00879
00880 if (s->them.sin_addr.s_addr == INADDR_ANY)
00881 return 0;
00882
00883
00884 if (f->datalen == 0)
00885 return 0;
00886
00887 if (f->frametype != AST_FRAME_MODEM) {
00888 ast_log(LOG_WARNING, "UDPTL can only send T.38 data\n");
00889 return -1;
00890 }
00891
00892
00893 seq = s->tx_seq_no & 0xFFFF;
00894
00895
00896 len = udptl_build_packet(s, buf, f->data, f->datalen);
00897
00898 if (len > 0 && s->them.sin_port && s->them.sin_addr.s_addr) {
00899 if ((res = sendto(s->fd, buf, len, 0, (struct sockaddr *) &s->them, sizeof(s->them))) < 0)
00900 ast_log(LOG_NOTICE, "UDPTL Transmission error to %s:%d: %s\n", ast_inet_ntoa(s->them.sin_addr), ntohs(s->them.sin_port), strerror(errno));
00901 #if 0
00902 printf("Sent %d bytes of UDPTL data to %s:%d\n", res, ast_inet_ntoa(udptl->them.sin_addr), ntohs(udptl->them.sin_port));
00903 #endif
00904 if (udptl_debug_test_addr(&s->them))
00905 ast_verbose("Sent UDPTL packet to %s:%d (type %d, seq %d, len %d)\n",
00906 ast_inet_ntoa(s->them.sin_addr),
00907 ntohs(s->them.sin_port), 0, seq, len);
00908 }
00909
00910 return 0;
00911 }
00912
00913 void ast_udptl_proto_unregister(struct ast_udptl_protocol *proto)
00914 {
00915 struct ast_udptl_protocol *cur;
00916 struct ast_udptl_protocol *prev;
00917
00918 cur = protos;
00919 prev = NULL;
00920 while (cur) {
00921 if (cur == proto) {
00922 if (prev)
00923 prev->next = proto->next;
00924 else
00925 protos = proto->next;
00926 return;
00927 }
00928 prev = cur;
00929 cur = cur->next;
00930 }
00931 }
00932
00933 int ast_udptl_proto_register(struct ast_udptl_protocol *proto)
00934 {
00935 struct ast_udptl_protocol *cur;
00936
00937 cur = protos;
00938 while (cur) {
00939 if (cur->type == proto->type) {
00940 ast_log(LOG_WARNING, "Tried to register same protocol '%s' twice\n", cur->type);
00941 return -1;
00942 }
00943 cur = cur->next;
00944 }
00945 proto->next = protos;
00946 protos = proto;
00947 return 0;
00948 }
00949
00950 static struct ast_udptl_protocol *get_proto(struct ast_channel *chan)
00951 {
00952 struct ast_udptl_protocol *cur;
00953
00954 cur = protos;
00955 while (cur) {
00956 if (cur->type == chan->tech->type)
00957 return cur;
00958 cur = cur->next;
00959 }
00960 return NULL;
00961 }
00962
00963 int ast_udptl_bridge(struct ast_channel *c0, struct ast_channel *c1, int flags, struct ast_frame **fo, struct ast_channel **rc)
00964 {
00965 struct ast_frame *f;
00966 struct ast_channel *who;
00967 struct ast_channel *cs[3];
00968 struct ast_udptl *p0;
00969 struct ast_udptl *p1;
00970 struct ast_udptl_protocol *pr0;
00971 struct ast_udptl_protocol *pr1;
00972 struct sockaddr_in ac0;
00973 struct sockaddr_in ac1;
00974 struct sockaddr_in t0;
00975 struct sockaddr_in t1;
00976 void *pvt0;
00977 void *pvt1;
00978 int to;
00979
00980 ast_channel_lock(c0);
00981 while (ast_channel_trylock(c1)) {
00982 ast_channel_unlock(c0);
00983 usleep(1);
00984 ast_channel_lock(c0);
00985 }
00986 pr0 = get_proto(c0);
00987 pr1 = get_proto(c1);
00988 if (!pr0) {
00989 ast_log(LOG_WARNING, "Can't find native functions for channel '%s'\n", c0->name);
00990 ast_channel_unlock(c0);
00991 ast_channel_unlock(c1);
00992 return -1;
00993 }
00994 if (!pr1) {
00995 ast_log(LOG_WARNING, "Can't find native functions for channel '%s'\n", c1->name);
00996 ast_channel_unlock(c0);
00997 ast_channel_unlock(c1);
00998 return -1;
00999 }
01000 pvt0 = c0->tech_pvt;
01001 pvt1 = c1->tech_pvt;
01002 p0 = pr0->get_udptl_info(c0);
01003 p1 = pr1->get_udptl_info(c1);
01004 if (!p0 || !p1) {
01005
01006 ast_channel_unlock(c0);
01007 ast_channel_unlock(c1);
01008 return -2;
01009 }
01010 if (pr0->set_udptl_peer(c0, p1)) {
01011 ast_log(LOG_WARNING, "Channel '%s' failed to talk to '%s'\n", c0->name, c1->name);
01012 } else {
01013
01014 ast_udptl_get_peer(p1, &ac1);
01015 }
01016 if (pr1->set_udptl_peer(c1, p0))
01017 ast_log(LOG_WARNING, "Channel '%s' failed to talk back to '%s'\n", c1->name, c0->name);
01018 else {
01019
01020 ast_udptl_get_peer(p0, &ac0);
01021 }
01022 ast_channel_unlock(c0);
01023 ast_channel_unlock(c1);
01024 cs[0] = c0;
01025 cs[1] = c1;
01026 cs[2] = NULL;
01027 for (;;) {
01028 if ((c0->tech_pvt != pvt0) ||
01029 (c1->tech_pvt != pvt1) ||
01030 (c0->masq || c0->masqr || c1->masq || c1->masqr)) {
01031 ast_log(LOG_DEBUG, "Oooh, something is weird, backing out\n");
01032
01033 return -3;
01034 }
01035 to = -1;
01036 ast_udptl_get_peer(p1, &t1);
01037 ast_udptl_get_peer(p0, &t0);
01038 if (inaddrcmp(&t1, &ac1)) {
01039 ast_log(LOG_DEBUG, "Oooh, '%s' changed end address to %s:%d\n",
01040 c1->name, ast_inet_ntoa(t1.sin_addr), ntohs(t1.sin_port));
01041 ast_log(LOG_DEBUG, "Oooh, '%s' was %s:%d\n",
01042 c1->name, ast_inet_ntoa(ac1.sin_addr), ntohs(ac1.sin_port));
01043 memcpy(&ac1, &t1, sizeof(ac1));
01044 }
01045 if (inaddrcmp(&t0, &ac0)) {
01046 ast_log(LOG_DEBUG, "Oooh, '%s' changed end address to %s:%d\n",
01047 c0->name, ast_inet_ntoa(t0.sin_addr), ntohs(t0.sin_port));
01048 ast_log(LOG_DEBUG, "Oooh, '%s' was %s:%d\n",
01049 c0->name, ast_inet_ntoa(ac0.sin_addr), ntohs(ac0.sin_port));
01050 memcpy(&ac0, &t0, sizeof(ac0));
01051 }
01052 who = ast_waitfor_n(cs, 2, &to);
01053 if (!who) {
01054 ast_log(LOG_DEBUG, "Ooh, empty read...\n");
01055
01056 if (ast_check_hangup(c0) || ast_check_hangup(c1))
01057 break;
01058 continue;
01059 }
01060 f = ast_read(who);
01061 if (!f) {
01062 *fo = f;
01063 *rc = who;
01064 ast_log(LOG_DEBUG, "Oooh, got a %s\n", f ? "digit" : "hangup");
01065
01066 return 0;
01067 } else {
01068 if (f->frametype == AST_FRAME_MODEM) {
01069
01070 if (who == c0) {
01071 ast_write(c1, f);
01072 } else if (who == c1) {
01073 ast_write(c0, f);
01074 }
01075 }
01076 ast_frfree(f);
01077 }
01078
01079 cs[2] = cs[0];
01080 cs[0] = cs[1];
01081 cs[1] = cs[2];
01082 }
01083 return -1;
01084 }
01085
01086 static int udptl_do_debug_ip(int fd, int argc, char *argv[])
01087 {
01088 struct hostent *hp;
01089 struct ast_hostent ahp;
01090 int port;
01091 char *p;
01092 char *arg;
01093
01094 port = 0;
01095 if (argc != 4)
01096 return RESULT_SHOWUSAGE;
01097 arg = argv[3];
01098 p = strstr(arg, ":");
01099 if (p) {
01100 *p = '\0';
01101 p++;
01102 port = atoi(p);
01103 }
01104 hp = ast_gethostbyname(arg, &ahp);
01105 if (hp == NULL)
01106 return RESULT_SHOWUSAGE;
01107 udptldebugaddr.sin_family = AF_INET;
01108 memcpy(&udptldebugaddr.sin_addr, hp->h_addr, sizeof(udptldebugaddr.sin_addr));
01109 udptldebugaddr.sin_port = htons(port);
01110 if (port == 0)
01111 ast_cli(fd, "UDPTL Debugging Enabled for IP: %s\n", ast_inet_ntoa(udptldebugaddr.sin_addr));
01112 else
01113 ast_cli(fd, "UDPTL Debugging Enabled for IP: %s:%d\n", ast_inet_ntoa(udptldebugaddr.sin_addr), port);
01114 udptldebug = 1;
01115 return RESULT_SUCCESS;
01116 }
01117
01118 static int udptl_do_debug(int fd, int argc, char *argv[])
01119 {
01120 if (argc != 2) {
01121 if (argc != 4)
01122 return RESULT_SHOWUSAGE;
01123 return udptl_do_debug_ip(fd, argc, argv);
01124 }
01125 udptldebug = 1;
01126 memset(&udptldebugaddr,0,sizeof(udptldebugaddr));
01127 ast_cli(fd, "UDPTL Debugging Enabled\n");
01128 return RESULT_SUCCESS;
01129 }
01130
01131 static int udptl_nodebug(int fd, int argc, char *argv[])
01132 {
01133 if (argc != 3)
01134 return RESULT_SHOWUSAGE;
01135 udptldebug = 0;
01136 ast_cli(fd,"UDPTL Debugging Disabled\n");
01137 return RESULT_SUCCESS;
01138 }
01139
01140 static char debug_usage[] =
01141 "Usage: udptl debug [ip host[:port]]\n"
01142 " Enable dumping of all UDPTL packets to and from host.\n";
01143
01144 static char nodebug_usage[] =
01145 "Usage: udptl debug off\n"
01146 " Disable all UDPTL debugging\n";
01147
01148 static struct ast_cli_entry cli_udptl_no_debug = {
01149 { "udptl", "no", "debug", NULL },
01150 udptl_nodebug, NULL,
01151 NULL };
01152
01153 static struct ast_cli_entry cli_udptl[] = {
01154 { { "udptl", "debug", NULL },
01155 udptl_do_debug, "Enable UDPTL debugging",
01156 debug_usage },
01157
01158 { { "udptl", "debug", "ip", NULL },
01159 udptl_do_debug, "Enable UDPTL debugging on IP",
01160 debug_usage },
01161
01162 { { "udptl", "debug", "off", NULL },
01163 udptl_nodebug, "Disable UDPTL debugging",
01164 nodebug_usage, NULL, &cli_udptl_no_debug },
01165 };
01166
01167 void ast_udptl_reload(void)
01168 {
01169 struct ast_config *cfg;
01170 const char *s;
01171
01172 udptlstart = 4500;
01173 udptlend = 4999;
01174 udptlfectype = 0;
01175 udptlfecentries = 0;
01176 udptlfecspan = 0;
01177 udptlmaxdatagram = 0;
01178
01179 if ((cfg = ast_config_load("udptl.conf"))) {
01180 if ((s = ast_variable_retrieve(cfg, "general", "udptlstart"))) {
01181 udptlstart = atoi(s);
01182 if (udptlstart < 1024)
01183 udptlstart = 1024;
01184 if (udptlstart > 65535)
01185 udptlstart = 65535;
01186 }
01187 if ((s = ast_variable_retrieve(cfg, "general", "udptlend"))) {
01188 udptlend = atoi(s);
01189 if (udptlend < 1024)
01190 udptlend = 1024;
01191 if (udptlend > 65535)
01192 udptlend = 65535;
01193 }
01194 if ((s = ast_variable_retrieve(cfg, "general", "udptlchecksums"))) {
01195 #ifdef SO_NO_CHECK
01196 if (ast_false(s))
01197 nochecksums = 1;
01198 else
01199 nochecksums = 0;
01200 #else
01201 if (ast_false(s))
01202 ast_log(LOG_WARNING, "Disabling UDPTL checksums is not supported on this operating system!\n");
01203 #endif
01204 }
01205 if ((s = ast_variable_retrieve(cfg, "general", "T38FaxUdpEC"))) {
01206 if (strcmp(s, "t38UDPFEC") == 0)
01207 udptlfectype = 2;
01208 else if (strcmp(s, "t38UDPRedundancy") == 0)
01209 udptlfectype = 1;
01210 }
01211 if ((s = ast_variable_retrieve(cfg, "general", "T38FaxMaxDatagram"))) {
01212 udptlmaxdatagram = atoi(s);
01213 if (udptlmaxdatagram < 0)
01214 udptlmaxdatagram = 0;
01215 if (udptlmaxdatagram > LOCAL_FAX_MAX_DATAGRAM)
01216 udptlmaxdatagram = LOCAL_FAX_MAX_DATAGRAM;
01217 }
01218 if ((s = ast_variable_retrieve(cfg, "general", "UDPTLFECentries"))) {
01219 udptlfecentries = atoi(s);
01220 if (udptlfecentries < 0)
01221 udptlfecentries = 0;
01222 if (udptlfecentries > MAX_FEC_ENTRIES)
01223 udptlfecentries = MAX_FEC_ENTRIES;
01224 }
01225 if ((s = ast_variable_retrieve(cfg, "general", "UDPTLFECspan"))) {
01226 udptlfecspan = atoi(s);
01227 if (udptlfecspan < 0)
01228 udptlfecspan = 0;
01229 if (udptlfecspan > MAX_FEC_SPAN)
01230 udptlfecspan = MAX_FEC_SPAN;
01231 }
01232 ast_config_destroy(cfg);
01233 }
01234 if (udptlstart >= udptlend) {
01235 ast_log(LOG_WARNING, "Unreasonable values for UDPTL start/end\n");
01236 udptlstart = 4500;
01237 udptlend = 4999;
01238 }
01239 if (option_verbose > 1)
01240 ast_verbose(VERBOSE_PREFIX_2 "UDPTL allocating from port range %d -> %d\n", udptlstart, udptlend);
01241 }
01242
01243 void ast_udptl_init(void)
01244 {
01245 ast_cli_register_multiple(cli_udptl, sizeof(cli_udptl) / sizeof(struct ast_cli_entry));
01246 ast_udptl_reload();
01247 }