main/udptl.c

   1 /*
   2  * Asterisk -- A telephony toolkit for Linux.
   3  *
   4  * UDPTL support for T.38
   5  *
   6  * Copyright (C) 2005, Steve Underwood, partly based on RTP code which is
   7  * Copyright (C) 1999-2006, Digium, Inc.
   8  *
   9  * Steve Underwood <steveu@coppice.org>
  10  *
  11  * See http://www.asterisk.org for more information about
  12  * the Asterisk project. Please do not directly contact
  13  * any of the maintainers of this project for assistance;
  14  * the project provides a web site, mailing lists and IRC
  15  * channels for your use.
  16  *
  17  * This program is free software, distributed under the terms of
  18  * the GNU General Public License Version 2. See the LICENSE file
  19  * at the top of the source tree.
  20  *
  21  * A license has been granted to Digium (via disclaimer) for the use of
  22  * this code.
  23  */
  24
  25 /*!
  26  * \file
  27  *
  28  * \brief UDPTL support for T.38 faxing
  29  *
  30  *
  31  * \author Mark Spencer <markster@digium.com>,  Steve Underwood <steveu@coppice.org>
  32  *
  33  * \page T38fax_udptl T38 fax passhtrough :: UDPTL
  34  *
  35  * Asterisk supports T.38 fax passthrough. Asterisk will not be a client, server
  36  * or any form of gateway. Currently fax passthrough is only implemented in the
  37  * SIP channel for strict SIP to SIP calls. If you are using chan_local or chan_agent
  38  * as a proxy channel, T.38 passthrough will not work.
  39  *
  40  * UDPTL is handled very much like RTP. It can be reinvited to go directly between
  41  * the endpoints, without involving Asterisk in the media stream.
  42  *
  43  * \b References:
  44  * - chan_sip.c
  45  * - udptl.c
  46  */
  47
  48
  49 #include "asterisk.h"
  50
  51 ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
  52
  53 #include <stdio.h>
  54 #include <stdlib.h>
  55 #include <string.h>
  56 #include <sys/time.h>
  57 #include <signal.h>
  58 #include <errno.h>
  59 #include <unistd.h>
  60 #include <netinet/in.h>
  61 #include <sys/time.h>
  62 #include <sys/socket.h>
  63 #include <arpa/inet.h>
  64 #include <fcntl.h>
  65
  66 #include "asterisk/udptl.h"
  67 #include "asterisk/frame.h"
  68 #include "asterisk/logger.h"
  69 #include "asterisk/options.h"
  70 #include "asterisk/channel.h"
  71 #include "asterisk/acl.h"
  72 #include "asterisk/channel.h"
  73 #include "asterisk/config.h"
  74 #include "asterisk/lock.h"
  75 #include "asterisk/utils.h"
  76 #include "asterisk/netsock.h"
  77 #include "asterisk/cli.h"
  78 #include "asterisk/unaligned.h"
  79 #include "asterisk/utils.h"
  80
  81 #define UDPTL_MTU               1200
  82
  83 #if !defined(FALSE)
  84 #define FALSE 0
  85 #endif
  86 #if !defined(TRUE)
  87 #define TRUE (!FALSE)
  88 #endif
  89
  90 static int udptlstart;
  91 static int udptlend;
  92 static int udptldebug;                      /*!< Are we debugging? */
  93 static struct sockaddr_in udptldebugaddr;   /*!< Debug packets to/from this host */
  94 #ifdef SO_NO_CHECK
  95 static int nochecksums;
  96 #endif
  97 static int udptlfectype;
  98 static int udptlfecentries;
  99 static int udptlfecspan;
 100 static int udptlmaxdatagram;
 101
 102 #define LOCAL_FAX_MAX_DATAGRAM      400
 103 #define MAX_FEC_ENTRIES             5
 104 #define MAX_FEC_SPAN                5
 105
 106 #define UDPTL_BUF_MASK              15
 107
 108 typedef struct {
 109         int buf_len;
 110         uint8_t buf[LOCAL_FAX_MAX_DATAGRAM];
 111 } udptl_fec_tx_buffer_t;
 112
 113 typedef struct {
 114         int buf_len;
 115         uint8_t buf[LOCAL_FAX_MAX_DATAGRAM];
 116         int fec_len[MAX_FEC_ENTRIES];
 117         uint8_t fec[MAX_FEC_ENTRIES][LOCAL_FAX_MAX_DATAGRAM];
 118         int fec_span;
 119         int fec_entries;
 120 } udptl_fec_rx_buffer_t;
 121
 122 /*! \brief Structure for an UDPTL session */
 123 struct ast_udptl {
 124         int fd;
 125         char resp;
 126         struct ast_frame f[16];
 127         unsigned char rawdata[8192 + AST_FRIENDLY_OFFSET];
 128         unsigned int lasteventseqn;
 129         int nat;
 130         int flags;
 131         struct sockaddr_in us;
 132         struct sockaddr_in them;
 133         int *ioid;
 134         uint16_t seqno;
 135         struct sched_context *sched;
 136         struct io_context *io;
 137         void *data;
 138         ast_udptl_callback callback;
 139         int udptl_offered_from_local;
 140
 141         /*! This option indicates the error correction scheme used in transmitted UDPTL
 142             packets. */
 143         int error_correction_scheme;
 144
 145         /*! This option indicates the number of error correction entries transmitted in
 146             UDPTL packets. */
 147         int error_correction_entries;
 148
 149         /*! This option indicates the span of the error correction entries in transmitted
 150             UDPTL packets (FEC only). */
 151         int error_correction_span;
 152
 153         /*! This option indicates the maximum size of a UDPTL packet that can be accepted by
 154             the remote device. */
 155         int far_max_datagram_size;
 156
 157         /*! This option indicates the maximum size of a UDPTL packet that we are prepared to
 158             accept. */
 159         int local_max_datagram_size;
 160
 161         int verbose;
 162
 163         struct sockaddr_in far;
 164
 165         int tx_seq_no;
 166         int rx_seq_no;
 167         int rx_expected_seq_no;
 168
 169         udptl_fec_tx_buffer_t tx[UDPTL_BUF_MASK + 1];
 170         udptl_fec_rx_buffer_t rx[UDPTL_BUF_MASK + 1];
 171 };
 172
 173 static struct ast_udptl_protocol *protos;
 174
 175 static int udptl_rx_packet(struct ast_udptl *s, uint8_t *buf, int len);
 176 static int udptl_build_packet(struct ast_udptl *s, uint8_t *buf, uint8_t *ifp, int ifp_len);
 177
 178 static inline int udptl_debug_test_addr(struct sockaddr_in *addr)
 179 {
 180         if (udptldebug == 0)
 181                 return 0;
 182         if (udptldebugaddr.sin_addr.s_addr) {
 183                 if (((ntohs(udptldebugaddr.sin_port) != 0)
 184                         && (udptldebugaddr.sin_port != addr->sin_port))
 185                         || (udptldebugaddr.sin_addr.s_addr != addr->sin_addr.s_addr))
 186                         return 0;
 187         }
 188         return 1;
 189 }
 190
 191 static int decode_length(uint8_t *buf, int limit, int *len, int *pvalue)
 192 {
 193         if ((buf[*len] & 0x80) == 0) {
 194                 if (*len >= limit)
 195                         return -1;
 196                 *pvalue = buf[*len];
 197                 (*len)++;
 198                 return 0;
 199         }
 200         if ((buf[*len] & 0x40) == 0) {
 201                 if (*len >= limit - 1)
 202                         return -1;
 203                 *pvalue = (buf[*len] & 0x3F) << 8;
 204                 (*len)++;
 205                 *pvalue |= buf[*len];
 206                 (*len)++;
 207                 return 0;
 208         }
 209         if (*len >= limit)
 210                 return -1;
 211         *pvalue = (buf[*len] & 0x3F) << 14;
 212         (*len)++;
 213         /* Indicate we have a fragment */
 214         return 1;
 215 }
 216 /*- End of function --------------------------------------------------------*/
 217
 218 static int decode_open_type(uint8_t *buf, int limit, int *len, const uint8_t **p_object, int *p_num_octets)
 219 {
 220         int octet_cnt;
 221         int octet_idx;
 222         int stat;
 223         int i;
 224         const uint8_t **pbuf;
 225
 226         for (octet_idx = 0, *p_num_octets = 0; ; octet_idx += octet_cnt) {
 227                 if ((stat = decode_length(buf, limit, len, &octet_cnt)) < 0)
 228                         return -1;
 229                 if (octet_cnt > 0) {
 230                         *p_num_octets += octet_cnt;
 231
 232                         pbuf = &p_object[octet_idx];
 233                         i = 0;
 234                         /* Make sure the buffer contains at least the number of bits requested */
 235                         if ((*len + octet_cnt) > limit)
 236                                 return -1;
 237
 238                         *pbuf = &buf[*len];
 239                         *len += octet_cnt;
 240                 }
 241                 if (stat == 0)
 242                         break;
 243         }
 244         return 0;
 245 }
 246 /*- End of function --------------------------------------------------------*/
 247
 248 static int encode_length(uint8_t *buf, int *len, int value)
 249 {
 250         int multiplier;
 251
 252         if (value < 0x80) {
 253                 /* 1 octet */
 254                 buf[*len] = value;
 255                 (*len)++;
 256                 return value;
 257         }
 258         if (value < 0x4000) {
 259                 /* 2 octets */
 260                 /* Set the first bit of the first octet */
 261                 buf[*len] = ((0x8000 | value) >> 8) & 0xFF;
 262                 (*len)++;
 263                 buf[*len] = value & 0xFF;
 264                 (*len)++;
 265                 return value;
 266         }
 267         /* Fragmentation */
 268         multiplier = (value < 0x10000) ? (value >> 14) : 4;
 269         /* Set the first 2 bits of the octet */
 270         buf[*len] = 0xC0 | multiplier;
 271         (*len)++;
 272         return multiplier << 14;
 273 }
 274 /*- End of function --------------------------------------------------------*/
 275
 276 static int encode_open_type(uint8_t *buf, int *len, const uint8_t *data, int num_octets)
 277 {
 278         int enclen;
 279         int octet_idx;
 280         uint8_t zero_byte;
 281
 282         /* If open type is of zero length, add a single zero byte (10.1) */
 283         if (num_octets == 0) {
 284                 zero_byte = 0;
 285                 data = &zero_byte;
 286                 num_octets = 1;
 287         }
 288         /* Encode the open type */
 289         for (octet_idx = 0; ; num_octets -= enclen, octet_idx += enclen) {
 290                 if ((enclen = encode_length(buf, len, num_octets)) < 0)
 291                         return -1;
 292                 if (enclen > 0) {
 293                         memcpy(&buf[*len], &data[octet_idx], enclen);
 294                         *len += enclen;
 295                 }
 296                 if (enclen >= num_octets)
 297                         break;
 298         }
 299
 300         return 0;
 301 }
 302 /*- End of function --------------------------------------------------------*/
 303
 304 static int udptl_rx_packet(struct ast_udptl *s, uint8_t *buf, int len)
 305 {
 306         int stat;
 307         int stat2;
 308         int i;
 309         int j;
 310         int k;
 311         int l;
 312         int m;
 313         int x;
 314         int limit;
 315         int which;
 316         int ptr;
 317         int count;
 318         int total_count;
 319         int seq_no;
 320         const uint8_t *ifp;
 321         const uint8_t *data;
 322         int ifp_len;
 323         int repaired[16];
 324         const uint8_t *bufs[16];
 325         int lengths[16];
 326         int span;
 327         int entries;
 328         int ifp_no;
 329
 330         ptr = 0;
 331         ifp_no = 0;
 332         memset(&s->f[0], 0, sizeof(s->f[0]));
 333
 334         /* Decode seq_number */
 335         if (ptr + 2 > len)
 336                 return -1;
 337         seq_no = (buf[0] << 8) | buf[1];
 338         ptr += 2;
 339
 340         /* Break out the primary packet */
 341         if ((stat = decode_open_type(buf, len, &ptr, &ifp, &ifp_len)) != 0)
 342                 return -1;
 343         /* Decode error_recovery */
 344         if (ptr + 1 > len)
 345                 return -1;
 346         if ((buf[ptr++] & 0x80) == 0) {
 347                 /* Secondary packet mode for error recovery */
 348                 if (seq_no > s->rx_seq_no) {
 349                         /* We received a later packet than we expected, so we need to check if we can fill in the gap from the
 350                            secondary packets. */
 351                         total_count = 0;
 352                         do {
 353                                 if ((stat2 = decode_length(buf, len, &ptr, &count)) < 0)
 354                                         return -1;
 355                                 for (i = 0; i < count; i++) {
 356                                         if ((stat = decode_open_type(buf, len, &ptr, &bufs[total_count + i], &lengths[total_count + i])) != 0)
 357                                                 return -1;
 358                                 }
 359                                 total_count += count;
 360                         }
 361                         while (stat2 > 0);
 362                         /* Step through in reverse order, so we go oldest to newest */
 363                         for (i = total_count; i > 0; i--) {
 364                                 if (seq_no - i >= s->rx_seq_no) {
 365                                         /* This one wasn't seen before */
 366                                         /* Decode the secondary IFP packet */
 367                                         //fprintf(stderr, "Secondary %d, len %d\n", seq_no - i, lengths[i - 1]);
 368                                         s->f[ifp_no].frametype = AST_FRAME_MODEM;
 369                                         s->f[ifp_no].subclass = AST_MODEM_T38;
 370
 371                                         s->f[ifp_no].mallocd = 0;
 372                                         //s->f[ifp_no].???seq_no = seq_no - i;
 373                                         s->f[ifp_no].datalen = lengths[i - 1];
 374                                         s->f[ifp_no].data = (uint8_t *) bufs[i - 1];
 375                                         s->f[ifp_no].offset = 0;
 376                                         s->f[ifp_no].src = "UDPTL";
 377                                         if (ifp_no > 0)
 378                                                 AST_LIST_NEXT(&s->f[ifp_no - 1], frame_list) = &s->f[ifp_no];
 379                                         AST_LIST_NEXT(&s->f[ifp_no], frame_list) = NULL;
 380                                         ifp_no++;
 381                                 }
 382                         }
 383                 }
 384                 /* If packets are received out of sequence, we may have already processed this packet from the error
 385                    recovery information in a packet already received. */
 386                 if (seq_no >= s->rx_seq_no) {
 387                         /* Decode the primary IFP packet */
 388                         s->f[ifp_no].frametype = AST_FRAME_MODEM;
 389                         s->f[ifp_no].subclass = AST_MODEM_T38;
 390
 391                         s->f[ifp_no].mallocd = 0;
 392                         //s->f[ifp_no].???seq_no = seq_no;
 393                         s->f[ifp_no].datalen = ifp_len;
 394                         s->f[ifp_no].data = (uint8_t *) ifp;
 395                         s->f[ifp_no].offset = 0;
 396                         s->f[ifp_no].src = "UDPTL";
 397                         if (ifp_no > 0)
 398                                 AST_LIST_NEXT(&s->f[ifp_no - 1], frame_list) = &s->f[ifp_no];
 399                         AST_LIST_NEXT(&s->f[ifp_no], frame_list) = NULL;
 400                 }
 401         }
 402         else
 403         {
 404                 /* FEC mode for error recovery */
 405                 /* Our buffers cannot tolerate overlength IFP packets in FEC mode */
 406                 if (ifp_len > LOCAL_FAX_MAX_DATAGRAM)
 407                         return -1;
 408                 /* Update any missed slots in the buffer */
 409                 for ( ; seq_no > s->rx_seq_no; s->rx_seq_no++) {
 410                         x = s->rx_seq_no & UDPTL_BUF_MASK;
 411                         s->rx[x].buf_len = -1;
 412                         s->rx[x].fec_len[0] = 0;
 413                         s->rx[x].fec_span = 0;
 414                         s->rx[x].fec_entries = 0;
 415                 }
 416
 417                 x = seq_no & UDPTL_BUF_MASK;
 418
 419                 memset(repaired, 0, sizeof(repaired));
 420
 421                 /* Save the new IFP packet */
 422                 memcpy(s->rx[x].buf, ifp, ifp_len);
 423                 s->rx[x].buf_len = ifp_len;
 424                 repaired[x] = TRUE;
 425
 426                 /* Decode the FEC packets */
 427                 /* The span is defined as an unconstrained integer, but will never be more
 428                    than a small value. */
 429                 if (ptr + 2 > len)
 430                         return -1;
 431                 if (buf[ptr++] != 1)
 432                         return -1;
 433                 span = buf[ptr++];
 434                 s->rx[x].fec_span = span;
 435
 436                 /* The number of entries is defined as a length, but will only ever be a small
 437                    value. Treat it as such. */
 438                 if (ptr + 1 > len)
 439                         return -1;
 440                 entries = buf[ptr++];
 441                 s->rx[x].fec_entries = entries;
 442
 443                 /* Decode the elements */
 444                 for (i = 0; i < entries; i++) {
 445                         if ((stat = decode_open_type(buf, len, &ptr, &data, &s->rx[x].fec_len[i])) != 0)
 446                                 return -1;
 447                         if (s->rx[x].fec_len[i] > LOCAL_FAX_MAX_DATAGRAM)
 448                                 return -1;
 449
 450                         /* Save the new FEC data */
 451                         memcpy(s->rx[x].fec[i], data, s->rx[x].fec_len[i]);
 452 #if 0
 453                         fprintf(stderr, "FEC: ");
 454                         for (j = 0; j < s->rx[x].fec_len[i]; j++)
 455                                 fprintf(stderr, "%02X ", data[j]);
 456                         fprintf(stderr, "\n");
 457 #endif
 458                 }
 459
 460                 /* See if we can reconstruct anything which is missing */
 461                 /* TODO: this does not comprehensively hunt back and repair everything that is possible */
 462                 for (l = x; l != ((x - (16 - span*entries)) & UDPTL_BUF_MASK); l = (l - 1) & UDPTL_BUF_MASK) {
 463                         if (s->rx[l].fec_len[0] <= 0)
 464                                 continue;
 465                         for (m = 0; m < s->rx[l].fec_entries; m++) {
 466                                 limit = (l + m) & UDPTL_BUF_MASK;
 467                                 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) {
 468                                         if (s->rx[k].buf_len <= 0)
 469                                                 which = (which == -1) ? k : -2;
 470                                 }
 471                                 if (which >= 0) {
 472                                         /* Repairable */
 473                                         for (j = 0; j < s->rx[l].fec_len[m]; j++) {
 474                                                 s->rx[which].buf[j] = s->rx[l].fec[m][j];
 475                                                 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)
 476                                                         s->rx[which].buf[j] ^= (s->rx[k].buf_len > j) ? s->rx[k].buf[j] : 0;
 477                                         }
 478                                         s->rx[which].buf_len = s->rx[l].fec_len[m];
 479                                         repaired[which] = TRUE;
 480                                 }
 481                         }
 482                 }
 483                 /* Now play any new packets forwards in time */
 484                 for (l = (x + 1) & UDPTL_BUF_MASK, j = seq_no - UDPTL_BUF_MASK; l != x; l = (l + 1) & UDPTL_BUF_MASK, j++) {
 485                         if (repaired[l]) {
 486                                 //fprintf(stderr, "Fixed packet %d, len %d\n", j, l);
 487                                 s->f[ifp_no].frametype = AST_FRAME_MODEM;
 488                                 s->f[ifp_no].subclass = AST_MODEM_T38;
 489
 490                                 s->f[ifp_no].mallocd = 0;
 491                                 //s->f[ifp_no].???seq_no = j;
 492                                 s->f[ifp_no].datalen = s->rx[l].buf_len;
 493                                 s->f[ifp_no].data = s->rx[l].buf;
 494                                 s->f[ifp_no].offset = 0;
 495                                 s->f[ifp_no].src = "UDPTL";
 496                                 if (ifp_no > 0)
 497                                         AST_LIST_NEXT(&s->f[ifp_no - 1], frame_list) = &s->f[ifp_no];
 498                                 AST_LIST_NEXT(&s->f[ifp_no], frame_list) = NULL;
 499                                 ifp_no++;
 500                         }
 501                 }
 502                 /* Decode the primary IFP packet */
 503                 s->f[ifp_no].frametype = AST_FRAME_MODEM;
 504                 s->f[ifp_no].subclass = AST_MODEM_T38;
 505
 506                 s->f[ifp_no].mallocd = 0;
 507                 //s->f[ifp_no].???seq_no = j;
 508                 s->f[ifp_no].datalen = ifp_len;
 509                 s->f[ifp_no].data = (uint8_t *) ifp;
 510                 s->f[ifp_no].offset = 0;
 511                 s->f[ifp_no].src = "UDPTL";
 512                 if (ifp_no > 0)
 513                         AST_LIST_NEXT(&s->f[ifp_no - 1], frame_list) = &s->f[ifp_no];
 514                 AST_LIST_NEXT(&s->f[ifp_no], frame_list) = NULL;
 515         }
 516
 517         s->rx_seq_no = seq_no + 1;
 518         return 0;
 519 }
 520 /*- End of function --------------------------------------------------------*/
 521
 522 static int udptl_build_packet(struct ast_udptl *s, uint8_t *buf, uint8_t *ifp, int ifp_len)
 523 {
 524         uint8_t fec[LOCAL_FAX_MAX_DATAGRAM];
 525         int i;
 526         int j;
 527         int seq;
 528         int entry;
 529         int entries;
 530         int span;
 531         int m;
 532         int len;
 533         int limit;
 534         int high_tide;
 535
 536         seq = s->tx_seq_no & 0xFFFF;
 537
 538         /* Map the sequence number to an entry in the circular buffer */
 539         entry = seq & UDPTL_BUF_MASK;
 540
 541         /* We save the message in a circular buffer, for generating FEC or
 542            redundancy sets later on. */
 543         s->tx[entry].buf_len = ifp_len;
 544         memcpy(s->tx[entry].buf, ifp, ifp_len);
 545
 546         /* Build the UDPTLPacket */
 547
 548         len = 0;
 549         /* Encode the sequence number */
 550         buf[len++] = (seq >> 8) & 0xFF;
 551         buf[len++] = seq & 0xFF;
 552
 553         /* Encode the primary IFP packet */
 554         if (encode_open_type(buf, &len, ifp, ifp_len) < 0)
 555                 return -1;
 556
 557         /* Encode the appropriate type of error recovery information */
 558         switch (s->error_correction_scheme)
 559         {
 560         case UDPTL_ERROR_CORRECTION_NONE:
 561                 /* Encode the error recovery type */
 562                 buf[len++] = 0x00;
 563                 /* The number of entries will always be zero, so it is pointless allowing
 564                    for the fragmented case here. */
 565                 if (encode_length(buf, &len, 0) < 0)
 566                         return -1;
 567                 break;
 568         case UDPTL_ERROR_CORRECTION_REDUNDANCY:
 569                 /* Encode the error recovery type */
 570                 buf[len++] = 0x00;
 571                 if (s->tx_seq_no > s->error_correction_entries)
 572                         entries = s->error_correction_entries;
 573                 else
 574                         entries = s->tx_seq_no;
 575                 /* The number of entries will always be small, so it is pointless allowing
 576                    for the fragmented case here. */
 577                 if (encode_length(buf, &len, entries) < 0)
 578                         return -1;
 579                 /* Encode the elements */
 580                 for (i = 0; i < entries; i++) {
 581                         j = (entry - i - 1) & UDPTL_BUF_MASK;
 582                         if (encode_open_type(buf, &len, s->tx[j].buf, s->tx[j].buf_len) < 0)
 583                                 return -1;
 584                 }
 585                 break;
 586         case UDPTL_ERROR_CORRECTION_FEC:
 587                 span = s->error_correction_span;
 588                 entries = s->error_correction_entries;
 589                 if (seq < s->error_correction_span*s->error_correction_entries) {
 590                         /* In the initial stages, wind up the FEC smoothly */
 591                         entries = seq/s->error_correction_span;
 592                         if (seq < s->error_correction_span)
 593                                 span = 0;
 594                 }
 595                 /* Encode the error recovery type */
 596                 buf[len++] = 0x80;
 597                 /* Span is defined as an inconstrained integer, which it dumb. It will only
 598                    ever be a small value. Treat it as such. */
 599                 buf[len++] = 1;
 600                 buf[len++] = span;
 601                 /* The number of entries is defined as a length, but will only ever be a small
 602                    value. Treat it as such. */
 603                 buf[len++] = entries;
 604                 for (m = 0; m < entries; m++) {
 605                         /* Make an XOR'ed entry the maximum length */
 606                         limit = (entry + m) & UDPTL_BUF_MASK;
 607                         high_tide = 0;
 608                         for (i = (limit - span*entries) & UDPTL_BUF_MASK; i != limit; i = (i + entries) & UDPTL_BUF_MASK) {
 609                                 if (high_tide < s->tx[i].buf_len) {
 610                                         for (j = 0; j < high_tide; j++)
 611                                                 fec[j] ^= s->tx[i].buf[j];
 612                                         for ( ; j < s->tx[i].buf_len; j++)
 613                                                 fec[j] = s->tx[i].buf[j];
 614                                         high_tide = s->tx[i].buf_len;
 615                                 } else {
 616                                         for (j = 0; j < s->tx[i].buf_len; j++)
 617                                                 fec[j] ^= s->tx[i].buf[j];
 618                                 }
 619                         }
 620                         if (encode_open_type(buf, &len, fec, high_tide) < 0)
 621                                 return -1;
 622                 }
 623                 break;
 624         }
 625
 626         if (s->verbose)
 627                 fprintf(stderr, "\n");
 628
 629         s->tx_seq_no++;
 630         return len;
 631 }
 632
 633 int ast_udptl_fd(struct ast_udptl *udptl)
 634 {
 635         return udptl->fd;
 636 }
 637
 638 void ast_udptl_set_data(struct ast_udptl *udptl, void *data)
 639 {
 640         udptl->data = data;
 641 }
 642
 643 void ast_udptl_set_callback(struct ast_udptl *udptl, ast_udptl_callback callback)
 644 {
 645         udptl->callback = callback;
 646 }
 647
 648 void ast_udptl_setnat(struct ast_udptl *udptl, int nat)
 649 {
 650         udptl->nat = nat;
 651 }
 652
 653 static int udptlread(int *id, int fd, short events, void *cbdata)
 654 {
 655         struct ast_udptl *udptl = cbdata;
 656         struct ast_frame *f;
 657
 658         if ((f = ast_udptl_read(udptl))) {
 659                 if (udptl->callback)
 660                         udptl->callback(udptl, f, udptl->data);
 661         }
 662         return 1;
 663 }
 664
 665 struct ast_frame *ast_udptl_read(struct ast_udptl *udptl)
 666 {
 667         int res;
 668         struct sockaddr_in sin;
 669         socklen_t len;
 670         uint16_t seqno = 0;
 671         uint16_t *udptlheader;
 672
 673         len = sizeof(sin);
 674
 675         /* Cache where the header will go */
 676         res = recvfrom(udptl->fd,
 677                         udptl->rawdata + AST_FRIENDLY_OFFSET,
 678                         sizeof(udptl->rawdata) - AST_FRIENDLY_OFFSET,
 679                         0,
 680                         (struct sockaddr *) &sin,
 681                         &len);
 682         udptlheader = (uint16_t *)(udptl->rawdata + AST_FRIENDLY_OFFSET);
 683         if (res < 0) {
 684                 if (errno != EAGAIN)
 685                         ast_log(LOG_WARNING, "UDPTL read error: %s\n", strerror(errno));
 686                 if (errno == EBADF)
 687                         CRASH;
 688                 return &ast_null_frame;
 689         }
 690
 691         /* Ignore if the other side hasn't been given an address yet. */
 692         if (!udptl->them.sin_addr.s_addr || !udptl->them.sin_port)
 693                 return &ast_null_frame;
 694
 695         if (udptl->nat) {
 696                 /* Send to whoever sent to us */
 697                 if ((udptl->them.sin_addr.s_addr != sin.sin_addr.s_addr) ||
 698                         (udptl->them.sin_port != sin.sin_port)) {
 699                         memcpy(&udptl->them, &sin, sizeof(udptl->them));
 700                         ast_debug(1, "UDPTL NAT: Using address %s:%d\n", ast_inet_ntoa(udptl->them.sin_addr), ntohs(udptl->them.sin_port));
 701                 }
 702         }
 703
 704         if (udptl_debug_test_addr(&sin)) {
 705                 if (option_verbose)
 706                         ast_verbose("Got UDPTL packet from %s:%d (type %d, seq %d, len %d)\n",
 707                                 ast_inet_ntoa(sin.sin_addr), ntohs(sin.sin_port), 0, seqno, res);
 708         }
 709 #if 0
 710         printf("Got UDPTL packet from %s:%d (seq %d, len = %d)\n", ast_inet_ntoa(sin.sin_addr), ntohs(sin.sin_port), seqno, res);
 711 #endif
 712         udptl_rx_packet(udptl, udptl->rawdata + AST_FRIENDLY_OFFSET, res);
 713
 714         return &udptl->f[0];
 715 }
 716
 717 void ast_udptl_offered_from_local(struct ast_udptl* udptl, int local)
 718 {
 719         if (udptl)
 720                 udptl->udptl_offered_from_local = local;
 721         else
 722                 ast_log(LOG_WARNING, "udptl structure is null\n");
 723 }
 724
 725 int ast_udptl_get_error_correction_scheme(struct ast_udptl* udptl)
 726 {
 727         if (udptl)
 728                 return udptl->error_correction_scheme;
 729         else {
 730                 ast_log(LOG_WARNING, "udptl structure is null\n");
 731                 return -1;
 732         }
 733 }
 734
 735 void ast_udptl_set_error_correction_scheme(struct ast_udptl* udptl, int ec)
 736 {
 737         if (udptl) {
 738                 switch (ec) {
 739                 case UDPTL_ERROR_CORRECTION_FEC:
 740                         udptl->error_correction_scheme = UDPTL_ERROR_CORRECTION_FEC;
 741                         break;
 742                 case UDPTL_ERROR_CORRECTION_REDUNDANCY:
 743                         udptl->error_correction_scheme = UDPTL_ERROR_CORRECTION_REDUNDANCY;
 744                         break;
 745                 case UDPTL_ERROR_CORRECTION_NONE:
 746                         udptl->error_correction_scheme = UDPTL_ERROR_CORRECTION_NONE;
 747                         break;
 748                 default:
 749                         ast_log(LOG_WARNING, "error correction parameter invalid\n");
 750                 };
 751         } else
 752                 ast_log(LOG_WARNING, "udptl structure is null\n");
 753 }
 754
 755 int ast_udptl_get_local_max_datagram(struct ast_udptl* udptl)
 756 {
 757         if (udptl)
 758                 return udptl->local_max_datagram_size;
 759         else {
 760                 ast_log(LOG_WARNING, "udptl structure is null\n");
 761                 return -1;
 762         }
 763 }
 764
 765 int ast_udptl_get_far_max_datagram(struct ast_udptl* udptl)
 766 {
 767         if (udptl)
 768                 return udptl->far_max_datagram_size;
 769         else {
 770                 ast_log(LOG_WARNING, "udptl structure is null\n");
 771                 return -1;
 772         }
 773 }
 774
 775 void ast_udptl_set_local_max_datagram(struct ast_udptl* udptl, int max_datagram)
 776 {
 777         if (udptl)
 778                 udptl->local_max_datagram_size = max_datagram;
 779         else
 780                 ast_log(LOG_WARNING, "udptl structure is null\n");
 781 }
 782
 783 void ast_udptl_set_far_max_datagram(struct ast_udptl* udptl, int max_datagram)
 784 {
 785         if (udptl)
 786                 udptl->far_max_datagram_size = max_datagram;
 787         else
 788                 ast_log(LOG_WARNING, "udptl structure is null\n");
 789 }
 790
 791 struct ast_udptl *ast_udptl_new_with_bindaddr(struct sched_context *sched, struct io_context *io, int callbackmode, struct in_addr addr)
 792 {
 793         struct ast_udptl *udptl;
 794         int x;
 795         int startplace;
 796         int i;
 797         long int flags;
 798
 799         if (!(udptl = ast_calloc(1, sizeof(*udptl))))
 800                 return NULL;
 801
 802         if (udptlfectype == 2)
 803                 udptl->error_correction_scheme = UDPTL_ERROR_CORRECTION_FEC;
 804         else if (udptlfectype == 1)
 805                 udptl->error_correction_scheme = UDPTL_ERROR_CORRECTION_REDUNDANCY;
 806         else
 807                 udptl->error_correction_scheme = UDPTL_ERROR_CORRECTION_NONE;
 808         udptl->error_correction_span = udptlfecspan;
 809         udptl->error_correction_entries = udptlfecentries;
 810
 811         udptl->far_max_datagram_size = udptlmaxdatagram;
 812         udptl->local_max_datagram_size = udptlmaxdatagram;
 813
 814         memset(&udptl->rx, 0, sizeof(udptl->rx));
 815         memset(&udptl->tx, 0, sizeof(udptl->tx));
 816         for (i = 0; i <= UDPTL_BUF_MASK; i++) {
 817                 udptl->rx[i].buf_len = -1;
 818                 udptl->tx[i].buf_len = -1;
 819         }
 820
 821         udptl->seqno = ast_random() & 0xffff;
 822         udptl->them.sin_family = AF_INET;
 823         udptl->us.sin_family = AF_INET;
 824
 825         if ((udptl->fd = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
 826                 ast_free(udptl);
 827                 ast_log(LOG_WARNING, "Unable to allocate socket: %s\n", strerror(errno));
 828                 return NULL;
 829         }
 830         flags = fcntl(udptl->fd, F_GETFL);
 831         fcntl(udptl->fd, F_SETFL, flags | O_NONBLOCK);
 832 #ifdef SO_NO_CHECK
 833         if (nochecksums)
 834                 setsockopt(udptl->fd, SOL_SOCKET, SO_NO_CHECK, &nochecksums, sizeof(nochecksums));
 835 #endif
 836         /* Find us a place */
 837         x = (ast_random() % (udptlend - udptlstart)) + udptlstart;
 838         startplace = x;
 839         for (;;) {
 840                 udptl->us.sin_port = htons(x);
 841                 udptl->us.sin_addr = addr;
 842                 if (bind(udptl->fd, (struct sockaddr *) &udptl->us, sizeof(udptl->us)) == 0)
 843                         break;
 844                 if (errno != EADDRINUSE) {
 845                         ast_log(LOG_WARNING, "Unexpected bind error: %s\n", strerror(errno));
 846                         close(udptl->fd);
 847                         ast_free(udptl);
 848                         return NULL;
 849                 }
 850                 if (++x > udptlend)
 851                         x = udptlstart;
 852                 if (x == startplace) {
 853                         ast_log(LOG_WARNING, "No UDPTL ports remaining\n");
 854                         close(udptl->fd);
 855                         ast_free(udptl);
 856                         return NULL;
 857                 }
 858         }
 859         if (io && sched && callbackmode) {
 860                 /* Operate this one in a callback mode */
 861                 udptl->sched = sched;
 862                 udptl->io = io;
 863                 udptl->ioid = ast_io_add(udptl->io, udptl->fd, udptlread, AST_IO_IN, udptl);
 864         }
 865         return udptl;
 866 }
 867
 868 struct ast_udptl *ast_udptl_new(struct sched_context *sched, struct io_context *io, int callbackmode)
 869 {
 870         struct in_addr ia;
 871         memset(&ia, 0, sizeof(ia));
 872         return ast_udptl_new_with_bindaddr(sched, io, callbackmode, ia);
 873 }
 874
 875 int ast_udptl_setqos(struct ast_udptl *udptl, int tos, int cos)
 876 {
 877         return ast_netsock_set_qos(udptl->fd, tos, cos);
 878 }
 879
 880 void ast_udptl_set_peer(struct ast_udptl *udptl, struct sockaddr_in *them)
 881 {
 882         udptl->them.sin_port = them->sin_port;
 883         udptl->them.sin_addr = them->sin_addr;
 884 }
 885
 886 void ast_udptl_get_peer(struct ast_udptl *udptl, struct sockaddr_in *them)
 887 {
 888         them->sin_family = AF_INET;
 889         them->sin_port = udptl->them.sin_port;
 890         them->sin_addr = udptl->them.sin_addr;
 891 }
 892
 893 void ast_udptl_get_us(struct ast_udptl *udptl, struct sockaddr_in *us)
 894 {
 895         memcpy(us, &udptl->us, sizeof(udptl->us));
 896 }
 897
 898 void ast_udptl_stop(struct ast_udptl *udptl)
 899 {
 900         memset(&udptl->them.sin_addr, 0, sizeof(udptl->them.sin_addr));
 901         memset(&udptl->them.sin_port, 0, sizeof(udptl->them.sin_port));
 902 }
 903
 904 void ast_udptl_destroy(struct ast_udptl *udptl)
 905 {
 906         if (udptl->ioid)
 907                 ast_io_remove(udptl->io, udptl->ioid);
 908         if (udptl->fd > -1)
 909                 close(udptl->fd);
 910         ast_free(udptl);
 911 }
 912
 913 int ast_udptl_write(struct ast_udptl *s, struct ast_frame *f)
 914 {
 915         int len;
 916         int res;
 917         uint8_t buf[LOCAL_FAX_MAX_DATAGRAM];
 918
 919         /* If we have no peer, return immediately */
 920         if (s->them.sin_addr.s_addr == INADDR_ANY)
 921                 return 0;
 922
 923         /* If there is no data length, return immediately */
 924         if (f->datalen == 0)
 925                 return 0;
 926
 927         if (f->frametype != AST_FRAME_MODEM) {
 928                 ast_log(LOG_WARNING, "UDPTL can only send T.38 data\n");
 929                 return -1;
 930         }
 931
 932         /* Cook up the UDPTL packet, with the relevant EC info. */
 933         len = udptl_build_packet(s, buf, f->data, f->datalen);
 934
 935         if (len > 0 && s->them.sin_port && s->them.sin_addr.s_addr) {
 936                 if ((res = sendto(s->fd, buf, len, 0, (struct sockaddr *) &s->them, sizeof(s->them))) < 0)
 937                         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));
 938 #if 0
 939                 printf("Sent %d bytes of UDPTL data to %s:%d\n", res, ast_inet_ntoa(udptl->them.sin_addr), ntohs(udptl->them.sin_port));
 940 #endif
 941                 if (udptl_debug_test_addr(&s->them))
 942                         ast_verbose("Sent UDPTL packet to %s:%d (type %d, seq %d, len %d)\n",
 943                                         ast_inet_ntoa(s->them.sin_addr),
 944                                         ntohs(s->them.sin_port), 0, s->seqno, len);
 945         }
 946
 947         return 0;
 948 }
 949
 950 void ast_udptl_proto_unregister(struct ast_udptl_protocol *proto)
 951 {
 952         struct ast_udptl_protocol *cur;
 953         struct ast_udptl_protocol *prev;
 954
 955         cur = protos;
 956         prev = NULL;
 957         while (cur) {
 958                 if (cur == proto) {
 959                         if (prev)
 960                                 prev->next = proto->next;
 961                         else
 962                                 protos = proto->next;
 963                         return;
 964                 }
 965                 prev = cur;
 966                 cur = cur->next;
 967         }
 968 }
 969
 970 int ast_udptl_proto_register(struct ast_udptl_protocol *proto)
 971 {
 972         struct ast_udptl_protocol *cur;
 973
 974         cur = protos;
 975         while (cur) {
 976                 if (cur->type == proto->type) {
 977                         ast_log(LOG_WARNING, "Tried to register same protocol '%s' twice\n", cur->type);
 978                         return -1;
 979                 }
 980                 cur = cur->next;
 981         }
 982         proto->next = protos;
 983         protos = proto;
 984         return 0;
 985 }
 986
 987 static struct ast_udptl_protocol *get_proto(struct ast_channel *chan)
 988 {
 989         struct ast_udptl_protocol *cur;
 990
 991         cur = protos;
 992         while (cur) {
 993                 if (cur->type == chan->tech->type)
 994                         return cur;
 995                 cur = cur->next;
 996         }
 997         return NULL;
 998 }
 999
1000 int ast_udptl_bridge(struct ast_channel *c0, struct ast_channel *c1, int flags, struct ast_frame **fo, struct ast_channel **rc)
1001 {
1002         struct ast_frame *f;
1003         struct ast_channel *who;
1004         struct ast_channel *cs[3];
1005         struct ast_udptl *p0;
1006         struct ast_udptl *p1;
1007         struct ast_udptl_protocol *pr0;
1008         struct ast_udptl_protocol *pr1;
1009         struct sockaddr_in ac0;
1010         struct sockaddr_in ac1;
1011         struct sockaddr_in t0;
1012         struct sockaddr_in t1;
1013         void *pvt0;
1014         void *pvt1;
1015         int to;
1016
1017         ast_channel_lock(c0);
1018         while (ast_channel_trylock(c1)) {
1019                 ast_channel_unlock(c0);
1020                 usleep(1);
1021                 ast_channel_lock(c0);
1022         }
1023         pr0 = get_proto(c0);
1024         pr1 = get_proto(c1);
1025         if (!pr0) {
1026                 ast_log(LOG_WARNING, "Can't find native functions for channel '%s'\n", c0->name);
1027                 ast_channel_unlock(c0);
1028                 ast_channel_unlock(c1);
1029                 return -1;
1030         }
1031         if (!pr1) {
1032                 ast_log(LOG_WARNING, "Can't find native functions for channel '%s'\n", c1->name);
1033                 ast_channel_unlock(c0);
1034                 ast_channel_unlock(c1);
1035                 return -1;
1036         }
1037         pvt0 = c0->tech_pvt;
1038         pvt1 = c1->tech_pvt;
1039         p0 = pr0->get_udptl_info(c0);
1040         p1 = pr1->get_udptl_info(c1);
1041         if (!p0 || !p1) {
1042                 /* Somebody doesn't want to play... */
1043                 ast_channel_unlock(c0);
1044                 ast_channel_unlock(c1);
1045                 return -2;
1046         }
1047         if (pr0->set_udptl_peer(c0, p1)) {
1048                 ast_log(LOG_WARNING, "Channel '%s' failed to talk to '%s'\n", c0->name, c1->name);
1049         } else {
1050                 /* Store UDPTL peer */
1051                 ast_udptl_get_peer(p1, &ac1);
1052         }
1053         if (pr1->set_udptl_peer(c1, p0))
1054                 ast_log(LOG_WARNING, "Channel '%s' failed to talk back to '%s'\n", c1->name, c0->name);
1055         else {
1056                 /* Store UDPTL peer */
1057                 ast_udptl_get_peer(p0, &ac0);
1058         }
1059         ast_channel_unlock(c0);
1060         ast_channel_unlock(c1);
1061         cs[0] = c0;
1062         cs[1] = c1;
1063         cs[2] = NULL;
1064         for (;;) {
1065                 if ((c0->tech_pvt != pvt0) ||
1066                         (c1->tech_pvt != pvt1) ||
1067                         (c0->masq || c0->masqr || c1->masq || c1->masqr)) {
1068                                 ast_debug(1, "Oooh, something is weird, backing out\n");
1069                                 /* Tell it to try again later */
1070                                 return -3;
1071                 }
1072                 to = -1;
1073                 ast_udptl_get_peer(p1, &t1);
1074                 ast_udptl_get_peer(p0, &t0);
1075                 if (inaddrcmp(&t1, &ac1)) {
1076                         ast_debug(1, "Oooh, '%s' changed end address to %s:%d\n",
1077                                 c1->name, ast_inet_ntoa(t1.sin_addr), ntohs(t1.sin_port));
1078                         ast_debug(1, "Oooh, '%s' was %s:%d\n",
1079                                 c1->name, ast_inet_ntoa(ac1.sin_addr), ntohs(ac1.sin_port));
1080                         memcpy(&ac1, &t1, sizeof(ac1));
1081                 }
1082                 if (inaddrcmp(&t0, &ac0)) {
1083                         ast_debug(1, "Oooh, '%s' changed end address to %s:%d\n",
1084                                 c0->name, ast_inet_ntoa(t0.sin_addr), ntohs(t0.sin_port));
1085                         ast_debug(1, "Oooh, '%s' was %s:%d\n",
1086                                 c0->name, ast_inet_ntoa(ac0.sin_addr), ntohs(ac0.sin_port));
1087                         memcpy(&ac0, &t0, sizeof(ac0));
1088                 }
1089                 who = ast_waitfor_n(cs, 2, &to);
1090                 if (!who) {
1091                         ast_debug(1, "Ooh, empty read...\n");
1092                         /* check for hangup / whentohangup */
1093                         if (ast_check_hangup(c0) || ast_check_hangup(c1))
1094                                 break;
1095                         continue;
1096                 }
1097                 f = ast_read(who);
1098                 if (!f) {
1099                         *fo = f;
1100                         *rc = who;
1101                         ast_debug(1, "Oooh, got a %s\n", f ? "digit" : "hangup");
1102                         /* That's all we needed */
1103                         return 0;
1104                 } else {
1105                         if (f->frametype == AST_FRAME_MODEM) {
1106                                 /* Forward T.38 frames if they happen upon us */
1107                                 if (who == c0) {
1108                                         ast_write(c1, f);
1109                                 } else if (who == c1) {
1110                                         ast_write(c0, f);
1111                                 }
1112                         }
1113                         ast_frfree(f);
1114                 }
1115                 /* Swap priority. Not that it's a big deal at this point */
1116                 cs[2] = cs[0];
1117                 cs[0] = cs[1];
1118                 cs[1] = cs[2];
1119         }
1120         return -1;
1121 }
1122
1123 static int udptl_do_debug_ip(int fd, int argc, char *argv[])
1124 {
1125         struct hostent *hp;
1126         struct ast_hostent ahp;
1127         int port;
1128         char *p;
1129         char *arg;
1130
1131         port = 0;
1132         if (argc != 4)
1133                 return RESULT_SHOWUSAGE;
1134         arg = argv[3];
1135         p = strstr(arg, ":");
1136         if (p) {
1137                 *p = '\0';
1138                 p++;
1139                 port = atoi(p);
1140         }
1141         hp = ast_gethostbyname(arg, &ahp);
1142         if (hp == NULL)
1143                 return RESULT_SHOWUSAGE;
1144         udptldebugaddr.sin_family = AF_INET;
1145         memcpy(&udptldebugaddr.sin_addr, hp->h_addr, sizeof(udptldebugaddr.sin_addr));
1146         udptldebugaddr.sin_port = htons(port);
1147         if (port == 0)
1148                 ast_cli(fd, "UDPTL Debugging Enabled for IP: %s\n", ast_inet_ntoa(udptldebugaddr.sin_addr));
1149         else
1150                 ast_cli(fd, "UDPTL Debugging Enabled for IP: %s:%d\n", ast_inet_ntoa(udptldebugaddr.sin_addr), port);
1151         udptldebug = 1;
1152         return RESULT_SUCCESS;
1153 }
1154
1155 static int udptl_do_debug(int fd, int argc, char *argv[])
1156 {
1157         if (argc != 2) {
1158                 if (argc != 4)
1159                         return RESULT_SHOWUSAGE;
1160                 return udptl_do_debug_ip(fd, argc, argv);
1161         }
1162         udptldebug = 1;
1163         memset(&udptldebugaddr,0,sizeof(udptldebugaddr));
1164         ast_cli(fd, "UDPTL Debugging Enabled\n");
1165         return RESULT_SUCCESS;
1166 }
1167
1168 static int udptl_nodebug(int fd, int argc, char *argv[])
1169 {
1170         if (argc != 3)
1171                 return RESULT_SHOWUSAGE;
1172         udptldebug = 0;
1173         ast_cli(fd,"UDPTL Debugging Disabled\n");
1174         return RESULT_SUCCESS;
1175 }
1176
1177 static const char debug_usage[] =
1178   "Usage: udptl debug [ip host[:port]]\n"
1179   "       Enable dumping of all UDPTL packets to and from host.\n";
1180
1181 static const char nodebug_usage[] =
1182   "Usage: udptl debug off\n"
1183   "       Disable all UDPTL debugging\n";
1184
1185 static struct ast_cli_entry cli_udptl[] = {
1186         { { "udptl", "debug", NULL },
1187         udptl_do_debug, "Enable UDPTL debugging",
1188         debug_usage },
1189
1190         { { "udptl", "debug", "ip", NULL },
1191         udptl_do_debug, "Enable UDPTL debugging on IP",
1192         debug_usage },
1193
1194         { { "udptl", "debug", "off", NULL },
1195         udptl_nodebug, "Disable UDPTL debugging",
1196         nodebug_usage },
1197 };
1198
1199 void ast_udptl_reload(void)
1200 {
1201         struct ast_config *cfg;
1202         const char *s;
1203
1204         udptlstart = 4500;
1205         udptlend = 4999;
1206         udptlfectype = 0;
1207         udptlfecentries = 0;
1208         udptlfecspan = 0;
1209         udptlmaxdatagram = 0;
1210
1211         if ((cfg = ast_config_load("udptl.conf"))) {
1212                 if ((s = ast_variable_retrieve(cfg, "general", "udptlstart"))) {
1213                         udptlstart = atoi(s);
1214                         if (udptlstart < 1024)
1215                                 udptlstart = 1024;
1216                         if (udptlstart > 65535)
1217                                 udptlstart = 65535;
1218                 }
1219                 if ((s = ast_variable_retrieve(cfg, "general", "udptlend"))) {
1220                         udptlend = atoi(s);
1221                         if (udptlend < 1024)
1222                                 udptlend = 1024;
1223                         if (udptlend > 65535)
1224                                 udptlend = 65535;
1225                 }
1226                 if ((s = ast_variable_retrieve(cfg, "general", "udptlchecksums"))) {
1227 #ifdef SO_NO_CHECK
1228                         if (ast_false(s))
1229                                 nochecksums = 1;
1230                         else
1231                                 nochecksums = 0;
1232 #else
1233                         if (ast_false(s))
1234                                 ast_log(LOG_WARNING, "Disabling UDPTL checksums is not supported on this operating system!\n");
1235 #endif
1236                 }
1237                 if ((s = ast_variable_retrieve(cfg, "general", "T38FaxUdpEC"))) {
1238                         if (strcmp(s, "t38UDPFEC") == 0)
1239                                 udptlfectype = 2;
1240                         else if (strcmp(s, "t38UDPRedundancy") == 0)
1241                                 udptlfectype = 1;
1242                 }
1243                 if ((s = ast_variable_retrieve(cfg, "general", "T38FaxMaxDatagram"))) {
1244                         udptlmaxdatagram = atoi(s);
1245                         if (udptlmaxdatagram < 0)
1246                                 udptlmaxdatagram = 0;
1247                         if (udptlmaxdatagram > LOCAL_FAX_MAX_DATAGRAM)
1248                                 udptlmaxdatagram = LOCAL_FAX_MAX_DATAGRAM;
1249                 }
1250                 if ((s = ast_variable_retrieve(cfg, "general", "UDPTLFECentries"))) {
1251                         udptlfecentries = atoi(s);
1252                         if (udptlfecentries < 0)
1253                                 udptlfecentries = 0;
1254                         if (udptlfecentries > MAX_FEC_ENTRIES)
1255                                 udptlfecentries = MAX_FEC_ENTRIES;
1256                 }
1257                 if ((s = ast_variable_retrieve(cfg, "general", "UDPTLFECspan"))) {
1258                         udptlfecspan = atoi(s);
1259                         if (udptlfecspan < 0)
1260                                 udptlfecspan = 0;
1261                         if (udptlfecspan > MAX_FEC_SPAN)
1262                                 udptlfecspan = MAX_FEC_SPAN;
1263                 }
1264                 ast_config_destroy(cfg);
1265         }
1266         if (udptlstart >= udptlend) {
1267                 ast_log(LOG_WARNING, "Unreasonable values for UDPTL start/end\n");
1268                 udptlstart = 4500;
1269                 udptlend = 4999;
1270         }
1271         if (option_verbose > 1)
1272                 ast_verbose(VERBOSE_PREFIX_2 "UDPTL allocating from port range %d -> %d\n", udptlstart, udptlend);
1273 }
1274
1275 void ast_udptl_init(void)
1276 {
1277         ast_cli_register_multiple(cli_udptl, sizeof(cli_udptl) / sizeof(struct ast_cli_entry));
1278         ast_udptl_reload();
1279 }