#include "asterisk.h"
#include <sys/time.h>
#include <signal.h>
#include <fcntl.h>
#include "asterisk/udptl.h"
#include "asterisk/frame.h"
#include "asterisk/channel.h"
#include "asterisk/acl.h"
#include "asterisk/config.h"
#include "asterisk/lock.h"
#include "asterisk/utils.h"
#include "asterisk/netsock.h"
#include "asterisk/cli.h"
#include "asterisk/unaligned.h"
Go to the source code of this file.
Data Structures | |
struct | ast_udptl |
Structure for an UDPTL session. More... | |
struct | protos |
struct | udptl_fec_rx_buffer_t |
struct | udptl_fec_tx_buffer_t |
Defines | |
#define | DEFAULT_FAX_MAX_DATAGRAM 400 |
#define | FALSE 0 |
#define | FAX_MAX_DATAGRAM_LIMIT 1400 |
#define | LOCAL_FAX_MAX_DATAGRAM 1400 |
#define | LOG_TAG(u) S_OR(u->tag, "no tag") |
#define | MAX_FEC_ENTRIES 5 |
#define | MAX_FEC_SPAN 5 |
#define | TRUE (!FALSE) |
#define | UDPTL_BUF_MASK 15 |
#define | UDPTL_MTU 1200 |
Functions | |
static void | __ast_udptl_reload (int reload) |
int | ast_udptl_bridge (struct ast_channel *c0, struct ast_channel *c1, int flags, struct ast_frame **fo, struct ast_channel **rc) |
void | ast_udptl_destroy (struct ast_udptl *udptl) |
int | ast_udptl_fd (const struct ast_udptl *udptl) |
enum ast_t38_ec_modes | ast_udptl_get_error_correction_scheme (const struct ast_udptl *udptl) |
unsigned int | ast_udptl_get_far_max_datagram (const struct ast_udptl *udptl) |
unsigned int | ast_udptl_get_far_max_ifp (struct ast_udptl *udptl) |
retrieves far max ifp | |
unsigned int | ast_udptl_get_local_max_datagram (struct ast_udptl *udptl) |
retrieves local_max_datagram. | |
void | ast_udptl_get_peer (const struct ast_udptl *udptl, struct ast_sockaddr *them) |
void | ast_udptl_get_us (const struct ast_udptl *udptl, struct ast_sockaddr *us) |
void | ast_udptl_init (void) |
ast_udptl * | ast_udptl_new_with_bindaddr (struct sched_context *sched, struct io_context *io, int callbackmode, struct ast_sockaddr *addr) |
int | ast_udptl_proto_register (struct ast_udptl_protocol *proto) |
void | ast_udptl_proto_unregister (struct ast_udptl_protocol *proto) |
ast_frame * | ast_udptl_read (struct ast_udptl *udptl) |
int | ast_udptl_reload (void) |
void | ast_udptl_set_callback (struct ast_udptl *udptl, ast_udptl_callback callback) |
void | ast_udptl_set_data (struct ast_udptl *udptl, void *data) |
void | ast_udptl_set_error_correction_scheme (struct ast_udptl *udptl, enum ast_t38_ec_modes ec) |
void | ast_udptl_set_far_max_datagram (struct ast_udptl *udptl, unsigned int max_datagram) |
sets far max datagram size. If max_datagram is = 0, the far max datagram size is set to a default value. | |
void | ast_udptl_set_local_max_ifp (struct ast_udptl *udptl, unsigned int max_ifp) |
void | ast_udptl_set_peer (struct ast_udptl *udptl, const struct ast_sockaddr *them) |
void | ast_udptl_set_tag (struct ast_udptl *udptl, const char *format,...) |
Associates a character string 'tag' with a UDPTL session. | |
void | ast_udptl_setnat (struct ast_udptl *udptl, int nat) |
int | ast_udptl_setqos (struct ast_udptl *udptl, unsigned int tos, unsigned int cos) |
void | ast_udptl_stop (struct ast_udptl *udptl) |
int | ast_udptl_write (struct ast_udptl *s, struct ast_frame *f) |
static void | calculate_far_max_ifp (struct ast_udptl *udptl) |
static void | calculate_local_max_datagram (struct ast_udptl *udptl) |
static int | decode_length (uint8_t *buf, unsigned int limit, unsigned int *len, unsigned int *pvalue) |
static int | decode_open_type (uint8_t *buf, unsigned int limit, unsigned int *len, const uint8_t **p_object, unsigned int *p_num_octets) |
static unsigned int | encode_length (uint8_t *buf, unsigned int *len, unsigned int value) |
static int | encode_open_type (const struct ast_udptl *udptl, uint8_t *buf, unsigned int buflen, unsigned int *len, const uint8_t *data, unsigned int num_octets) |
static struct ast_udptl_protocol * | get_proto (struct ast_channel *chan) |
static char * | handle_cli_udptl_set_debug (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a) |
static int | udptl_build_packet (struct ast_udptl *s, uint8_t *buf, unsigned int buflen, uint8_t *ifp, unsigned int ifp_len) |
static int | udptl_debug_test_addr (const struct ast_sockaddr *addr) |
static int | udptl_rx_packet (struct ast_udptl *s, uint8_t *buf, unsigned int len) |
static int | udptlread (int *id, int fd, short events, void *cbdata) |
Variables | |
static struct ast_cli_entry | cli_udptl [] |
static int | udptldebug |
static struct ast_sockaddr | udptldebugaddr |
static int | udptlend = 4599 |
static int | udptlfecentries |
static int | udptlfecspan |
static int | udptlstart = 4500 |
static int | use_even_ports |
Steve Underwood <steveu@coppice.org>
Kevin P. Fleming <kpfleming@digium.com>
Definition in file udptl.c.
#define DEFAULT_FAX_MAX_DATAGRAM 400 |
Definition at line 94 of file udptl.c.
Referenced by ast_udptl_set_far_max_datagram(), and ast_udptl_write().
#define FAX_MAX_DATAGRAM_LIMIT 1400 |
#define LOCAL_FAX_MAX_DATAGRAM 1400 |
Definition at line 93 of file udptl.c.
Referenced by calculate_local_max_datagram(), and udptl_build_packet().
#define LOG_TAG | ( | u | ) | S_OR(u->tag, "no tag") |
Definition at line 80 of file udptl.c.
Referenced by ast_udptl_read(), ast_udptl_write(), calculate_far_max_ifp(), calculate_local_max_datagram(), encode_open_type(), and udptl_build_packet().
#define MAX_FEC_ENTRIES 5 |
#define MAX_FEC_SPAN 5 |
static void __ast_udptl_reload | ( | int | reload | ) | [static] |
Definition at line 1304 of file udptl.c.
References ast_config_destroy(), ast_config_load2(), ast_false(), ast_log(), ast_true(), ast_variable_retrieve(), ast_verb, CONFIG_FLAG_FILEUNCHANGED, config_flags, CONFIG_STATUS_FILEINVALID, CONFIG_STATUS_FILEMISSING, CONFIG_STATUS_FILEUNCHANGED, LOG_NOTICE, LOG_WARNING, MAX_FEC_ENTRIES, and MAX_FEC_SPAN.
Referenced by ast_udptl_init(), and ast_udptl_reload().
01305 { 01306 struct ast_config *cfg; 01307 const char *s; 01308 struct ast_flags config_flags = { reload ? CONFIG_FLAG_FILEUNCHANGED : 0 }; 01309 01310 cfg = ast_config_load2("udptl.conf", "udptl", config_flags); 01311 if (cfg == CONFIG_STATUS_FILEMISSING || cfg == CONFIG_STATUS_FILEUNCHANGED || cfg == CONFIG_STATUS_FILEINVALID) { 01312 return; 01313 } 01314 01315 udptlstart = 4500; 01316 udptlend = 4999; 01317 udptlfecentries = 0; 01318 udptlfecspan = 0; 01319 use_even_ports = 0; 01320 01321 if (cfg) { 01322 if ((s = ast_variable_retrieve(cfg, "general", "udptlstart"))) { 01323 udptlstart = atoi(s); 01324 if (udptlstart < 1024) { 01325 ast_log(LOG_WARNING, "Ports under 1024 are not allowed for T.38.\n"); 01326 udptlstart = 1024; 01327 } 01328 if (udptlstart > 65535) { 01329 ast_log(LOG_WARNING, "Ports over 65535 are invalid.\n"); 01330 udptlstart = 65535; 01331 } 01332 } 01333 if ((s = ast_variable_retrieve(cfg, "general", "udptlend"))) { 01334 udptlend = atoi(s); 01335 if (udptlend < 1024) { 01336 ast_log(LOG_WARNING, "Ports under 1024 are not allowed for T.38.\n"); 01337 udptlend = 1024; 01338 } 01339 if (udptlend > 65535) { 01340 ast_log(LOG_WARNING, "Ports over 65535 are invalid.\n"); 01341 udptlend = 65535; 01342 } 01343 } 01344 if ((s = ast_variable_retrieve(cfg, "general", "udptlchecksums"))) { 01345 #ifdef SO_NO_CHECK 01346 if (ast_false(s)) 01347 nochecksums = 1; 01348 else 01349 nochecksums = 0; 01350 #else 01351 if (ast_false(s)) 01352 ast_log(LOG_WARNING, "Disabling UDPTL checksums is not supported on this operating system!\n"); 01353 #endif 01354 } 01355 if ((s = ast_variable_retrieve(cfg, "general", "T38FaxUdpEC"))) { 01356 ast_log(LOG_WARNING, "T38FaxUdpEC in udptl.conf is no longer supported; use the t38pt_udptl configuration option in sip.conf instead.\n"); 01357 } 01358 if ((s = ast_variable_retrieve(cfg, "general", "T38FaxMaxDatagram"))) { 01359 ast_log(LOG_WARNING, "T38FaxMaxDatagram in udptl.conf is no longer supported; value is now supplied by T.38 applications.\n"); 01360 } 01361 if ((s = ast_variable_retrieve(cfg, "general", "UDPTLFECEntries"))) { 01362 udptlfecentries = atoi(s); 01363 if (udptlfecentries < 1) { 01364 ast_log(LOG_WARNING, "Too small UDPTLFECEntries value. Defaulting to 1.\n"); 01365 udptlfecentries = 1; 01366 } 01367 if (udptlfecentries > MAX_FEC_ENTRIES) { 01368 ast_log(LOG_WARNING, "Too large UDPTLFECEntries value. Defaulting to %d.\n", MAX_FEC_ENTRIES); 01369 udptlfecentries = MAX_FEC_ENTRIES; 01370 } 01371 } 01372 if ((s = ast_variable_retrieve(cfg, "general", "UDPTLFECSpan"))) { 01373 udptlfecspan = atoi(s); 01374 if (udptlfecspan < 1) { 01375 ast_log(LOG_WARNING, "Too small UDPTLFECSpan value. Defaulting to 1.\n"); 01376 udptlfecspan = 1; 01377 } 01378 if (udptlfecspan > MAX_FEC_SPAN) { 01379 ast_log(LOG_WARNING, "Too large UDPTLFECSpan value. Defaulting to %d.\n", MAX_FEC_SPAN); 01380 udptlfecspan = MAX_FEC_SPAN; 01381 } 01382 } 01383 if ((s = ast_variable_retrieve(cfg, "general", "use_even_ports"))) { 01384 use_even_ports = ast_true(s); 01385 } 01386 ast_config_destroy(cfg); 01387 } 01388 if (udptlstart >= udptlend) { 01389 ast_log(LOG_WARNING, "Unreasonable values for UDPTL start/end ports; defaulting to 4500-4999.\n"); 01390 udptlstart = 4500; 01391 udptlend = 4999; 01392 } 01393 if (use_even_ports && (udptlstart & 1)) { 01394 ++udptlstart; 01395 ast_log(LOG_NOTICE, "Odd numbered udptlstart specified but use_even_ports enabled. udptlstart is now %d\n", udptlstart); 01396 } 01397 if (use_even_ports && (udptlend & 1)) { 01398 --udptlend; 01399 ast_log(LOG_NOTICE, "Odd numbered udptlend specified but use_event_ports enabled. udptlend is now %d\n", udptlend); 01400 } 01401 ast_verb(2, "UDPTL allocating from port range %d -> %d\n", udptlstart, udptlend); 01402 }
int ast_udptl_bridge | ( | struct ast_channel * | c0, | |
struct ast_channel * | c1, | |||
int | flags, | |||
struct ast_frame ** | fo, | |||
struct ast_channel ** | rc | |||
) |
Definition at line 1129 of file udptl.c.
References ast_channel_lock, ast_channel_trylock, ast_channel_unlock, ast_check_hangup(), ast_debug, AST_FRAME_MODEM, ast_frfree, ast_log(), ast_read(), ast_sockaddr_cmp(), ast_sockaddr_copy(), ast_sockaddr_stringify(), ast_udptl_get_peer(), ast_waitfor_n(), ast_write(), f, get_proto(), ast_udptl_protocol::get_udptl_info, LOG_WARNING, ast_channel::masq, ast_channel::masqr, ast_channel::name, ast_udptl_protocol::set_udptl_peer, t1, and ast_channel::tech_pvt.
01130 { 01131 struct ast_frame *f; 01132 struct ast_channel *who; 01133 struct ast_channel *cs[3]; 01134 struct ast_udptl *p0; 01135 struct ast_udptl *p1; 01136 struct ast_udptl_protocol *pr0; 01137 struct ast_udptl_protocol *pr1; 01138 struct ast_sockaddr ac0; 01139 struct ast_sockaddr ac1; 01140 struct ast_sockaddr t0; 01141 struct ast_sockaddr t1; 01142 void *pvt0; 01143 void *pvt1; 01144 int to; 01145 01146 ast_channel_lock(c0); 01147 while (ast_channel_trylock(c1)) { 01148 ast_channel_unlock(c0); 01149 usleep(1); 01150 ast_channel_lock(c0); 01151 } 01152 pr0 = get_proto(c0); 01153 pr1 = get_proto(c1); 01154 if (!pr0) { 01155 ast_log(LOG_WARNING, "Can't find native functions for channel '%s'\n", c0->name); 01156 ast_channel_unlock(c0); 01157 ast_channel_unlock(c1); 01158 return -1; 01159 } 01160 if (!pr1) { 01161 ast_log(LOG_WARNING, "Can't find native functions for channel '%s'\n", c1->name); 01162 ast_channel_unlock(c0); 01163 ast_channel_unlock(c1); 01164 return -1; 01165 } 01166 pvt0 = c0->tech_pvt; 01167 pvt1 = c1->tech_pvt; 01168 p0 = pr0->get_udptl_info(c0); 01169 p1 = pr1->get_udptl_info(c1); 01170 if (!p0 || !p1) { 01171 /* Somebody doesn't want to play... */ 01172 ast_channel_unlock(c0); 01173 ast_channel_unlock(c1); 01174 return -2; 01175 } 01176 if (pr0->set_udptl_peer(c0, p1)) { 01177 ast_log(LOG_WARNING, "Channel '%s' failed to talk to '%s'\n", c0->name, c1->name); 01178 memset(&ac1, 0, sizeof(ac1)); 01179 } else { 01180 /* Store UDPTL peer */ 01181 ast_udptl_get_peer(p1, &ac1); 01182 } 01183 if (pr1->set_udptl_peer(c1, p0)) { 01184 ast_log(LOG_WARNING, "Channel '%s' failed to talk back to '%s'\n", c1->name, c0->name); 01185 memset(&ac0, 0, sizeof(ac0)); 01186 } else { 01187 /* Store UDPTL peer */ 01188 ast_udptl_get_peer(p0, &ac0); 01189 } 01190 ast_channel_unlock(c0); 01191 ast_channel_unlock(c1); 01192 cs[0] = c0; 01193 cs[1] = c1; 01194 cs[2] = NULL; 01195 for (;;) { 01196 if ((c0->tech_pvt != pvt0) || 01197 (c1->tech_pvt != pvt1) || 01198 (c0->masq || c0->masqr || c1->masq || c1->masqr)) { 01199 ast_debug(1, "Oooh, something is weird, backing out\n"); 01200 /* Tell it to try again later */ 01201 return -3; 01202 } 01203 to = -1; 01204 ast_udptl_get_peer(p1, &t1); 01205 ast_udptl_get_peer(p0, &t0); 01206 if (ast_sockaddr_cmp(&t1, &ac1)) { 01207 ast_debug(1, "Oooh, '%s' changed end address to %s\n", 01208 c1->name, ast_sockaddr_stringify(&t1)); 01209 ast_debug(1, "Oooh, '%s' was %s\n", 01210 c1->name, ast_sockaddr_stringify(&ac1)); 01211 ast_sockaddr_copy(&ac1, &t1); 01212 } 01213 if (ast_sockaddr_cmp(&t0, &ac0)) { 01214 ast_debug(1, "Oooh, '%s' changed end address to %s\n", 01215 c0->name, ast_sockaddr_stringify(&t0)); 01216 ast_debug(1, "Oooh, '%s' was %s\n", 01217 c0->name, ast_sockaddr_stringify(&ac0)); 01218 ast_sockaddr_copy(&ac0, &t0); 01219 } 01220 who = ast_waitfor_n(cs, 2, &to); 01221 if (!who) { 01222 ast_debug(1, "Ooh, empty read...\n"); 01223 /* check for hangup / whentohangup */ 01224 if (ast_check_hangup(c0) || ast_check_hangup(c1)) 01225 break; 01226 continue; 01227 } 01228 f = ast_read(who); 01229 if (!f) { 01230 *fo = f; 01231 *rc = who; 01232 ast_debug(1, "Oooh, got a %s\n", f ? "digit" : "hangup"); 01233 /* That's all we needed */ 01234 return 0; 01235 } else { 01236 if (f->frametype == AST_FRAME_MODEM) { 01237 /* Forward T.38 frames if they happen upon us */ 01238 if (who == c0) { 01239 ast_write(c1, f); 01240 } else if (who == c1) { 01241 ast_write(c0, f); 01242 } 01243 } 01244 ast_frfree(f); 01245 } 01246 /* Swap priority. Not that it's a big deal at this point */ 01247 cs[2] = cs[0]; 01248 cs[0] = cs[1]; 01249 cs[1] = cs[2]; 01250 } 01251 return -1; 01252 }
void ast_udptl_destroy | ( | struct ast_udptl * | udptl | ) |
Definition at line 1027 of file udptl.c.
References ast_free, ast_io_remove(), ast_udptl::fd, ast_udptl::io, ast_udptl::ioid, and ast_udptl::tag.
Referenced by __sip_destroy(), and create_addr_from_peer().
01028 { 01029 if (udptl->ioid) 01030 ast_io_remove(udptl->io, udptl->ioid); 01031 if (udptl->fd > -1) 01032 close(udptl->fd); 01033 if (udptl->tag) 01034 ast_free(udptl->tag); 01035 ast_free(udptl); 01036 }
int ast_udptl_fd | ( | const struct ast_udptl * | udptl | ) |
Definition at line 635 of file udptl.c.
References ast_udptl::fd.
Referenced by __oh323_new(), and sip_new().
00636 { 00637 return udptl->fd; 00638 }
enum ast_t38_ec_modes ast_udptl_get_error_correction_scheme | ( | const struct ast_udptl * | udptl | ) |
Definition at line 822 of file udptl.c.
References ast_udptl::error_correction_scheme.
Referenced by add_sdp().
00823 { 00824 return udptl->error_correction_scheme; 00825 }
unsigned int ast_udptl_get_far_max_datagram | ( | const struct ast_udptl * | udptl | ) |
Definition at line 890 of file udptl.c.
References ast_udptl::far_max_datagram.
Referenced by process_sdp().
00891 { 00892 if (udptl->far_max_datagram < 0) { 00893 return 0; 00894 } 00895 return udptl->far_max_datagram; 00896 }
unsigned int ast_udptl_get_far_max_ifp | ( | struct ast_udptl * | udptl | ) |
retrieves far max ifp
positive | value representing max ifp size | |
0 | if no value is present |
Definition at line 898 of file udptl.c.
References calculate_far_max_ifp(), and ast_udptl::far_max_ifp.
Referenced by change_t38_state(), and interpret_t38_parameters().
00899 { 00900 if (udptl->far_max_ifp == -1) { 00901 calculate_far_max_ifp(udptl); 00902 } 00903 00904 if (udptl->far_max_ifp < 0) { 00905 return 0; 00906 } 00907 return udptl->far_max_ifp; 00908 }
unsigned int ast_udptl_get_local_max_datagram | ( | struct ast_udptl * | udptl | ) |
retrieves local_max_datagram.
positive | value representing max datagram size. | |
0 | if no value is present |
Definition at line 866 of file udptl.c.
References calculate_local_max_datagram(), and ast_udptl::local_max_datagram.
Referenced by add_sdp().
00867 { 00868 if (udptl->local_max_datagram == -1) { 00869 calculate_local_max_datagram(udptl); 00870 } 00871 00872 /* this function expects a unsigned value in return. */ 00873 if (udptl->local_max_datagram < 0) { 00874 return 0; 00875 } 00876 return udptl->local_max_datagram; 00877 }
void ast_udptl_get_peer | ( | const struct ast_udptl * | udptl, | |
struct ast_sockaddr * | them | |||
) |
Definition at line 1012 of file udptl.c.
References ast_sockaddr_copy(), and ast_udptl::them.
Referenced by ast_udptl_bridge(), and sip_set_udptl_peer().
01013 { 01014 ast_sockaddr_copy(them, &udptl->them); 01015 }
void ast_udptl_get_us | ( | const struct ast_udptl * | udptl, | |
struct ast_sockaddr * | us | |||
) |
Definition at line 1017 of file udptl.c.
References ast_sockaddr_copy(), and ast_udptl::us.
Referenced by add_sdp().
01018 { 01019 ast_sockaddr_copy(us, &udptl->us); 01020 }
void ast_udptl_init | ( | void | ) |
Definition at line 1410 of file udptl.c.
References __ast_udptl_reload(), ARRAY_LEN, ast_cli_register_multiple(), and cli_udptl.
Referenced by main().
01411 { 01412 ast_cli_register_multiple(cli_udptl, ARRAY_LEN(cli_udptl)); 01413 __ast_udptl_reload(0); 01414 }
struct ast_udptl* ast_udptl_new_with_bindaddr | ( | struct sched_context * | sched, | |
struct io_context * | io, | |||
int | callbackmode, | |||
struct ast_sockaddr * | addr | |||
) |
Definition at line 910 of file udptl.c.
References ast_bind(), ast_calloc, ast_free, ast_log(), ast_random(), ast_sockaddr_copy(), ast_sockaddr_is_ipv6(), ast_sockaddr_set_port, errno, ast_udptl::flags, and LOG_WARNING.
Referenced by create_addr_from_peer(), handle_request_invite(), and sip_alloc().
00911 { 00912 struct ast_udptl *udptl; 00913 int x; 00914 int startplace; 00915 int i; 00916 long int flags; 00917 00918 if (!(udptl = ast_calloc(1, sizeof(*udptl)))) 00919 return NULL; 00920 00921 udptl->error_correction_span = udptlfecspan; 00922 udptl->error_correction_entries = udptlfecentries; 00923 00924 udptl->far_max_datagram = -1; 00925 udptl->far_max_ifp = -1; 00926 udptl->local_max_ifp = -1; 00927 udptl->local_max_datagram = -1; 00928 00929 for (i = 0; i <= UDPTL_BUF_MASK; i++) { 00930 udptl->rx[i].buf_len = -1; 00931 udptl->tx[i].buf_len = -1; 00932 } 00933 00934 if ((udptl->fd = socket(ast_sockaddr_is_ipv6(addr) ? 00935 AF_INET6 : AF_INET, SOCK_DGRAM, 0)) < 0) { 00936 ast_free(udptl); 00937 ast_log(LOG_WARNING, "Unable to allocate socket: %s\n", strerror(errno)); 00938 return NULL; 00939 } 00940 flags = fcntl(udptl->fd, F_GETFL); 00941 fcntl(udptl->fd, F_SETFL, flags | O_NONBLOCK); 00942 #ifdef SO_NO_CHECK 00943 if (nochecksums) 00944 setsockopt(udptl->fd, SOL_SOCKET, SO_NO_CHECK, &nochecksums, sizeof(nochecksums)); 00945 #endif 00946 /* Find us a place */ 00947 x = (udptlstart == udptlend) ? udptlstart : (ast_random() % (udptlend - udptlstart)) + udptlstart; 00948 if (use_even_ports && (x & 1)) { 00949 ++x; 00950 } 00951 startplace = x; 00952 for (;;) { 00953 ast_sockaddr_copy(&udptl->us, addr); 00954 ast_sockaddr_set_port(&udptl->us, x); 00955 if (ast_bind(udptl->fd, &udptl->us) == 0) { 00956 break; 00957 } 00958 if (errno != EADDRINUSE) { 00959 ast_log(LOG_WARNING, "Unexpected bind error: %s\n", strerror(errno)); 00960 close(udptl->fd); 00961 ast_free(udptl); 00962 return NULL; 00963 } 00964 if (use_even_ports) { 00965 x += 2; 00966 } else { 00967 ++x; 00968 } 00969 if (x > udptlend) 00970 x = udptlstart; 00971 if (x == startplace) { 00972 ast_log(LOG_WARNING, "No UDPTL ports remaining\n"); 00973 close(udptl->fd); 00974 ast_free(udptl); 00975 return NULL; 00976 } 00977 } 00978 if (io && sched && callbackmode) { 00979 /* Operate this one in a callback mode */ 00980 udptl->sched = sched; 00981 udptl->io = io; 00982 udptl->ioid = ast_io_add(udptl->io, udptl->fd, udptlread, AST_IO_IN, udptl); 00983 } 00984 return udptl; 00985 }
int ast_udptl_proto_register | ( | struct ast_udptl_protocol * | proto | ) |
Definition at line 1098 of file udptl.c.
References ast_log(), AST_RWLIST_INSERT_TAIL, AST_RWLIST_TRAVERSE, AST_RWLIST_UNLOCK, AST_RWLIST_WRLOCK, ast_udptl_protocol::list, LOG_WARNING, and ast_udptl_protocol::type.
Referenced by load_module().
01099 { 01100 struct ast_udptl_protocol *cur; 01101 01102 AST_RWLIST_WRLOCK(&protos); 01103 AST_RWLIST_TRAVERSE(&protos, cur, list) { 01104 if (cur->type == proto->type) { 01105 ast_log(LOG_WARNING, "Tried to register same protocol '%s' twice\n", cur->type); 01106 AST_RWLIST_UNLOCK(&protos); 01107 return -1; 01108 } 01109 } 01110 AST_RWLIST_INSERT_TAIL(&protos, proto, list); 01111 AST_RWLIST_UNLOCK(&protos); 01112 return 0; 01113 }
void ast_udptl_proto_unregister | ( | struct ast_udptl_protocol * | proto | ) |
Definition at line 1091 of file udptl.c.
References AST_RWLIST_REMOVE, AST_RWLIST_UNLOCK, and AST_RWLIST_WRLOCK.
Referenced by unload_module().
01092 { 01093 AST_RWLIST_WRLOCK(&protos); 01094 AST_RWLIST_REMOVE(&protos, proto, list); 01095 AST_RWLIST_UNLOCK(&protos); 01096 }
Definition at line 667 of file udptl.c.
References ast_assert, ast_debug, AST_FRIENDLY_OFFSET, ast_log(), ast_null_frame, ast_recvfrom(), ast_sockaddr_cmp(), ast_sockaddr_copy(), ast_sockaddr_isnull(), ast_sockaddr_stringify(), ast_verb, errno, ast_udptl::f, ast_udptl::fd, LOG_TAG, LOG_WARNING, ast_udptl::nat, ast_udptl::rawdata, ast_udptl::them, udptl_debug_test_addr(), and udptl_rx_packet().
Referenced by sip_rtp_read(), skinny_rtp_read(), and udptlread().
00668 { 00669 int res; 00670 struct ast_sockaddr addr; 00671 uint16_t seqno = 0; 00672 uint16_t *udptlheader; 00673 00674 /* Cache where the header will go */ 00675 res = ast_recvfrom(udptl->fd, 00676 udptl->rawdata + AST_FRIENDLY_OFFSET, 00677 sizeof(udptl->rawdata) - AST_FRIENDLY_OFFSET, 00678 0, 00679 &addr); 00680 udptlheader = (uint16_t *)(udptl->rawdata + AST_FRIENDLY_OFFSET); 00681 if (res < 0) { 00682 if (errno != EAGAIN) 00683 ast_log(LOG_WARNING, "(%s): UDPTL read error: %s\n", 00684 LOG_TAG(udptl), strerror(errno)); 00685 ast_assert(errno != EBADF); 00686 return &ast_null_frame; 00687 } 00688 00689 /* Ignore if the other side hasn't been given an address yet. */ 00690 if (ast_sockaddr_isnull(&udptl->them)) { 00691 return &ast_null_frame; 00692 } 00693 00694 if (udptl->nat) { 00695 /* Send to whoever sent to us */ 00696 if (ast_sockaddr_cmp(&udptl->them, &addr)) { 00697 ast_sockaddr_copy(&udptl->them, &addr); 00698 ast_debug(1, "UDPTL NAT (%s): Using address %s\n", 00699 LOG_TAG(udptl), ast_sockaddr_stringify(&udptl->them)); 00700 } 00701 } 00702 00703 if (udptl_debug_test_addr(&addr)) { 00704 ast_verb(1, "UDPTL (%s): packet from %s (type %d, seq %d, len %d)\n", 00705 LOG_TAG(udptl), ast_sockaddr_stringify(&addr), 0, seqno, res); 00706 } 00707 if (udptl_rx_packet(udptl, udptl->rawdata + AST_FRIENDLY_OFFSET, res) < 1) 00708 return &ast_null_frame; 00709 00710 return &udptl->f[0]; 00711 }
int ast_udptl_reload | ( | void | ) |
Definition at line 1404 of file udptl.c.
References __ast_udptl_reload().
01405 { 01406 __ast_udptl_reload(1); 01407 return 0; 01408 }
void ast_udptl_set_callback | ( | struct ast_udptl * | udptl, | |
ast_udptl_callback | callback | |||
) |
Definition at line 645 of file udptl.c.
References ast_udptl::callback.
00646 { 00647 udptl->callback = callback; 00648 }
void ast_udptl_set_data | ( | struct ast_udptl * | udptl, | |
void * | data | |||
) |
Definition at line 640 of file udptl.c.
References ast_udptl::data.
00641 { 00642 udptl->data = data; 00643 }
void ast_udptl_set_error_correction_scheme | ( | struct ast_udptl * | udptl, | |
enum ast_t38_ec_modes | ec | |||
) |
Definition at line 827 of file udptl.c.
References ast_udptl::error_correction_entries, ast_udptl::error_correction_scheme, ast_udptl::error_correction_span, ast_udptl::far_max_ifp, ast_udptl::local_max_datagram, UDPTL_ERROR_CORRECTION_FEC, and UDPTL_ERROR_CORRECTION_REDUNDANCY.
Referenced by process_sdp(), process_sdp_a_image(), and set_t38_capabilities().
00828 { 00829 udptl->error_correction_scheme = ec; 00830 switch (ec) { 00831 case UDPTL_ERROR_CORRECTION_FEC: 00832 udptl->error_correction_scheme = UDPTL_ERROR_CORRECTION_FEC; 00833 if (udptl->error_correction_entries == 0) { 00834 udptl->error_correction_entries = 3; 00835 } 00836 if (udptl->error_correction_span == 0) { 00837 udptl->error_correction_span = 3; 00838 } 00839 break; 00840 case UDPTL_ERROR_CORRECTION_REDUNDANCY: 00841 udptl->error_correction_scheme = UDPTL_ERROR_CORRECTION_REDUNDANCY; 00842 if (udptl->error_correction_entries == 0) { 00843 udptl->error_correction_entries = 3; 00844 } 00845 break; 00846 default: 00847 /* nothing to do */ 00848 break; 00849 }; 00850 /* reset calculated values so they'll be computed again */ 00851 udptl->local_max_datagram = -1; 00852 udptl->far_max_ifp = -1; 00853 }
void ast_udptl_set_far_max_datagram | ( | struct ast_udptl * | udptl, | |
unsigned int | max_datagram | |||
) |
sets far max datagram size. If max_datagram is = 0, the far max datagram size is set to a default value.
Definition at line 879 of file udptl.c.
References DEFAULT_FAX_MAX_DATAGRAM, ast_udptl::far_max_datagram, ast_udptl::far_max_ifp, and FAX_MAX_DATAGRAM_LIMIT.
Referenced by process_sdp(), and process_sdp_a_image().
00880 { 00881 if (!max_datagram || (max_datagram > FAX_MAX_DATAGRAM_LIMIT)) { 00882 udptl->far_max_datagram = DEFAULT_FAX_MAX_DATAGRAM; 00883 } else { 00884 udptl->far_max_datagram = max_datagram; 00885 } 00886 /* reset calculated values so they'll be computed again */ 00887 udptl->far_max_ifp = -1; 00888 }
void ast_udptl_set_local_max_ifp | ( | struct ast_udptl * | udptl, | |
unsigned int | max_ifp | |||
) |
Definition at line 855 of file udptl.c.
References ast_udptl::local_max_datagram, and ast_udptl::local_max_ifp.
Referenced by interpret_t38_parameters().
00856 { 00857 /* make sure max_ifp is a positive value since a cast will take place when 00858 * when setting local_max_ifp */ 00859 if ((signed int) max_ifp > 0) { 00860 udptl->local_max_ifp = max_ifp; 00861 /* reset calculated values so they'll be computed again */ 00862 udptl->local_max_datagram = -1; 00863 } 00864 }
void ast_udptl_set_peer | ( | struct ast_udptl * | udptl, | |
const struct ast_sockaddr * | them | |||
) |
Definition at line 1007 of file udptl.c.
References ast_sockaddr_copy(), and ast_udptl::them.
Referenced by process_sdp().
01008 { 01009 ast_sockaddr_copy(&udptl->them, them); 01010 }
void ast_udptl_set_tag | ( | struct ast_udptl * | udptl, | |
const char * | format, | |||
... | ||||
) |
Associates a character string 'tag' with a UDPTL session.
udptl | The UDPTL session. | |
format | printf-style format string used to construct the tag |
none |
Definition at line 987 of file udptl.c.
References ast_free, ast_vasprintf, and ast_udptl::tag.
Referenced by change_t38_state().
00988 { 00989 va_list ap; 00990 00991 if (udptl->tag) { 00992 ast_free(udptl->tag); 00993 udptl->tag = NULL; 00994 } 00995 va_start(ap, format); 00996 if (ast_vasprintf(&udptl->tag, format, ap) == -1) { 00997 udptl->tag = NULL; 00998 } 00999 va_end(ap); 01000 }
void ast_udptl_setnat | ( | struct ast_udptl * | udptl, | |
int | nat | |||
) |
int ast_udptl_setqos | ( | struct ast_udptl * | udptl, | |
unsigned int | tos, | |||
unsigned int | cos | |||
) |
Definition at line 1002 of file udptl.c.
References ast_netsock_set_qos(), and ast_udptl::fd.
Referenced by sip_alloc().
01003 { 01004 return ast_netsock_set_qos(udptl->fd, tos, cos, "UDPTL"); 01005 }
void ast_udptl_stop | ( | struct ast_udptl * | udptl | ) |
Definition at line 1022 of file udptl.c.
References ast_sockaddr_setnull(), and ast_udptl::them.
Referenced by process_sdp(), and stop_media_flows().
01023 { 01024 ast_sockaddr_setnull(&udptl->them); 01025 }
Definition at line 1038 of file udptl.c.
References AST_FRAME_MODEM, ast_log(), AST_MODEM_T38, ast_sendto(), ast_sockaddr_isnull(), ast_sockaddr_stringify(), ast_verb, DEFAULT_FAX_MAX_DATAGRAM, errno, f, ast_udptl::far_max_datagram, ast_udptl::far_max_ifp, ast_udptl::fd, len(), LOG_NOTICE, LOG_TAG, LOG_WARNING, seq, ast_udptl::them, ast_udptl::tx_seq_no, udptl_build_packet(), and udptl_debug_test_addr().
Referenced by sip_write().
01039 { 01040 unsigned int seq; 01041 unsigned int len = f->datalen; 01042 int res; 01043 /* if no max datagram size is provided, use default value */ 01044 const int bufsize = (s->far_max_datagram > 0) ? s->far_max_datagram : DEFAULT_FAX_MAX_DATAGRAM; 01045 uint8_t buf[bufsize]; 01046 01047 memset(buf, 0, sizeof(buf)); 01048 01049 /* If we have no peer, return immediately */ 01050 if (ast_sockaddr_isnull(&s->them)) { 01051 return 0; 01052 } 01053 01054 /* If there is no data length, return immediately */ 01055 if (f->datalen == 0) 01056 return 0; 01057 01058 if ((f->frametype != AST_FRAME_MODEM) || 01059 (f->subclass.codec != AST_MODEM_T38)) { 01060 ast_log(LOG_WARNING, "(%s): UDPTL can only send T.38 data.\n", 01061 LOG_TAG(s)); 01062 return -1; 01063 } 01064 01065 if (len > s->far_max_ifp) { 01066 ast_log(LOG_WARNING, 01067 "(%s): UDPTL asked to send %d bytes of IFP when far end only prepared to accept %d bytes; data loss will occur." 01068 "You may need to override the T38FaxMaxDatagram value for this endpoint in the channel driver configuration.\n", 01069 LOG_TAG(s), len, s->far_max_ifp); 01070 len = s->far_max_ifp; 01071 } 01072 01073 /* Save seq_no for debug output because udptl_build_packet increments it */ 01074 seq = s->tx_seq_no & 0xFFFF; 01075 01076 /* Cook up the UDPTL packet, with the relevant EC info. */ 01077 len = udptl_build_packet(s, buf, sizeof(buf), f->data.ptr, len); 01078 01079 if ((signed int) len > 0 && !ast_sockaddr_isnull(&s->them)) { 01080 if ((res = ast_sendto(s->fd, buf, len, 0, &s->them)) < 0) 01081 ast_log(LOG_NOTICE, "(%s): UDPTL Transmission error to %s: %s\n", 01082 LOG_TAG(s), ast_sockaddr_stringify(&s->them), strerror(errno)); 01083 if (udptl_debug_test_addr(&s->them)) 01084 ast_verb(1, "UDPTL (%s): packet to %s (type %d, seq %d, len %d)\n", 01085 LOG_TAG(s), ast_sockaddr_stringify(&s->them), 0, seq, len); 01086 } 01087 01088 return 0; 01089 }
static void calculate_far_max_ifp | ( | struct ast_udptl * | udptl | ) | [static] |
Definition at line 754 of file udptl.c.
References ast_log(), ast_udptl::error_correction_entries, ast_udptl::error_correction_scheme, ast_udptl::far_max_datagram, ast_udptl::far_max_ifp, LOG_TAG, LOG_WARNING, UDPTL_ERROR_CORRECTION_FEC, UDPTL_ERROR_CORRECTION_NONE, and UDPTL_ERROR_CORRECTION_REDUNDANCY.
Referenced by ast_udptl_get_far_max_ifp().
00755 { 00756 unsigned new_max = 0; 00757 00758 if (udptl->far_max_datagram == -1) { 00759 ast_log(LOG_WARNING, "(%s): Cannot calculate far_max_ifp before far_max_datagram has been set.\n", 00760 LOG_TAG(udptl)); 00761 udptl->far_max_ifp = -1; 00762 return; 00763 } 00764 00765 /* the goal here is to supply the local endpoint (application 00766 * or bridged channel) a maximum IFP value that will allow it 00767 * to effectively and efficiently transfer image data at its 00768 * selected bit rate, taking into account the selected error 00769 * correction mode, but without overrunning the far endpoint's 00770 * datagram buffer. this is complicated by the fact that some 00771 * far endpoints send us bogus (small) max datagram values, 00772 * which would result in either buffer overrun or no error 00773 * correction. we try to accomodate those, but if the supplied 00774 * value is too small to do so, we'll emit warning messages and 00775 * the user will have to use configuration options to override 00776 * the max datagram value supplied by the far endpoint. 00777 */ 00778 switch (udptl->error_correction_scheme) { 00779 case UDPTL_ERROR_CORRECTION_NONE: 00780 /* need room for sequence number, length indicator, redundancy 00781 * indicator and following length indicator 00782 */ 00783 new_max = udptl->far_max_datagram - 5; 00784 break; 00785 case UDPTL_ERROR_CORRECTION_REDUNDANCY: 00786 /* for this case, we'd like to send as many error correction entries 00787 * as possible (up to the number we're configured for), but we'll settle 00788 * for sending fewer if the configured number would cause the 00789 * calculated max IFP to be too small for effective operation 00790 * 00791 * need room for sequence number, length indicators and the 00792 * configured number of redundant packets 00793 * 00794 * note: we purposely don't allow error_correction_entries to drop to 00795 * zero in this loop; we'd rather send smaller IFPs (and thus reduce 00796 * the image data transfer rate) than sacrifice redundancy completely 00797 */ 00798 for (;;) { 00799 new_max = (udptl->far_max_datagram - 8) / (udptl->error_correction_entries + 1); 00800 00801 if ((new_max < 80) && (udptl->error_correction_entries > 1)) { 00802 /* the max ifp is not large enough, subtract an 00803 * error correction entry and calculate again 00804 * */ 00805 --udptl->error_correction_entries; 00806 } else { 00807 break; 00808 } 00809 } 00810 break; 00811 case UDPTL_ERROR_CORRECTION_FEC: 00812 /* need room for sequence number, length indicators and a 00813 * a single IFP of the maximum size expected 00814 */ 00815 new_max = (udptl->far_max_datagram - 10) / 2; 00816 break; 00817 } 00818 /* subtract 5% of space for insurance */ 00819 udptl->far_max_ifp = new_max * 0.95; 00820 }
static void calculate_local_max_datagram | ( | struct ast_udptl * | udptl | ) | [static] |
Definition at line 713 of file udptl.c.
References ast_log(), ast_udptl::error_correction_scheme, LOCAL_FAX_MAX_DATAGRAM, ast_udptl::local_max_datagram, ast_udptl::local_max_ifp, LOG_TAG, LOG_WARNING, MIN, UDPTL_ERROR_CORRECTION_FEC, UDPTL_ERROR_CORRECTION_NONE, and UDPTL_ERROR_CORRECTION_REDUNDANCY.
Referenced by ast_udptl_get_local_max_datagram().
00714 { 00715 unsigned int new_max = 0; 00716 00717 if (udptl->local_max_ifp == -1) { 00718 ast_log(LOG_WARNING, "(%s): Cannot calculate local_max_datagram before local_max_ifp has been set.\n", 00719 LOG_TAG(udptl)); 00720 udptl->local_max_datagram = -1; 00721 return; 00722 } 00723 00724 /* calculate the amount of space required to receive an IFP 00725 * of the maximum size supported by the application/endpoint 00726 * that we are delivering them to (local endpoint), and add 00727 * the amount of space required to support the selected 00728 * error correction mode 00729 */ 00730 switch (udptl->error_correction_scheme) { 00731 case UDPTL_ERROR_CORRECTION_NONE: 00732 /* need room for sequence number, length indicator, redundancy 00733 * indicator and following length indicator 00734 */ 00735 new_max = 5 + udptl->local_max_ifp; 00736 break; 00737 case UDPTL_ERROR_CORRECTION_REDUNDANCY: 00738 /* need room for sequence number, length indicators, plus 00739 * room for up to 3 redundancy packets 00740 */ 00741 new_max = 5 + udptl->local_max_ifp + 2 + (3 * udptl->local_max_ifp); 00742 break; 00743 case UDPTL_ERROR_CORRECTION_FEC: 00744 /* need room for sequence number, length indicators and a 00745 * a single IFP of the maximum size expected 00746 */ 00747 new_max = 5 + udptl->local_max_ifp + 4 + udptl->local_max_ifp; 00748 break; 00749 } 00750 /* add 5% extra space for insurance, but no larger than LOCAL_FAX_MAX_DATAGRAM */ 00751 udptl->local_max_datagram = MIN(new_max * 1.05, LOCAL_FAX_MAX_DATAGRAM); 00752 }
static int decode_length | ( | uint8_t * | buf, | |
unsigned int | limit, | |||
unsigned int * | len, | |||
unsigned int * | pvalue | |||
) | [static] |
Definition at line 201 of file udptl.c.
References ast_debug.
Referenced by decode_open_type(), and udptl_rx_packet().
00202 { 00203 if (*len >= limit) 00204 return -1; 00205 if ((buf[*len] & 0x80) == 0) { 00206 *pvalue = buf[*len]; 00207 (*len)++; 00208 return 0; 00209 } 00210 if ((buf[*len] & 0x40) == 0) { 00211 if (*len == limit - 1) 00212 return -1; 00213 *pvalue = (buf[*len] & 0x3F) << 8; 00214 (*len)++; 00215 *pvalue |= buf[*len]; 00216 (*len)++; 00217 return 0; 00218 } 00219 *pvalue = (buf[*len] & 0x3F) << 14; 00220 (*len)++; 00221 /* We have a fragment. Currently we don't process fragments. */ 00222 ast_debug(1, "UDPTL packet with length greater than 16K received, decoding will fail\n"); 00223 return 1; 00224 }
static int decode_open_type | ( | uint8_t * | buf, | |
unsigned int | limit, | |||
unsigned int * | len, | |||
const uint8_t ** | p_object, | |||
unsigned int * | p_num_octets | |||
) | [static] |
Definition at line 227 of file udptl.c.
References decode_length().
Referenced by udptl_rx_packet().
00228 { 00229 unsigned int octet_cnt = 0; 00230 00231 if (decode_length(buf, limit, len, &octet_cnt) != 0) 00232 return -1; 00233 00234 if (octet_cnt > 0) { 00235 /* Make sure the buffer contains at least the number of bits requested */ 00236 if ((*len + octet_cnt) > limit) 00237 return -1; 00238 00239 *p_num_octets = octet_cnt; 00240 *p_object = &buf[*len]; 00241 *len += octet_cnt; 00242 } 00243 00244 return 0; 00245 }
static unsigned int encode_length | ( | uint8_t * | buf, | |
unsigned int * | len, | |||
unsigned int | value | |||
) | [static] |
Definition at line 248 of file udptl.c.
Referenced by encode_open_type(), and udptl_build_packet().
00249 { 00250 unsigned int multiplier; 00251 00252 if (value < 0x80) { 00253 /* 1 octet */ 00254 buf[*len] = value; 00255 (*len)++; 00256 return value; 00257 } 00258 if (value < 0x4000) { 00259 /* 2 octets */ 00260 /* Set the first bit of the first octet */ 00261 buf[*len] = ((0x8000 | value) >> 8) & 0xFF; 00262 (*len)++; 00263 buf[*len] = value & 0xFF; 00264 (*len)++; 00265 return value; 00266 } 00267 /* Fragmentation */ 00268 multiplier = (value < 0x10000) ? (value >> 14) : 4; 00269 /* Set the first 2 bits of the octet */ 00270 buf[*len] = 0xC0 | multiplier; 00271 (*len)++; 00272 return multiplier << 14; 00273 }
static int encode_open_type | ( | const struct ast_udptl * | udptl, | |
uint8_t * | buf, | |||
unsigned int | buflen, | |||
unsigned int * | len, | |||
const uint8_t * | data, | |||
unsigned int | num_octets | |||
) | [static] |
Definition at line 276 of file udptl.c.
References ast_log(), encode_length(), LOG_ERROR, and LOG_TAG.
Referenced by udptl_build_packet().
00278 { 00279 unsigned int enclen; 00280 unsigned int octet_idx; 00281 uint8_t zero_byte; 00282 00283 /* If open type is of zero length, add a single zero byte (10.1) */ 00284 if (num_octets == 0) { 00285 zero_byte = 0; 00286 data = &zero_byte; 00287 num_octets = 1; 00288 } 00289 /* Encode the open type */ 00290 for (octet_idx = 0; ; num_octets -= enclen, octet_idx += enclen) { 00291 if ((enclen = encode_length(buf, len, num_octets)) < 0) 00292 return -1; 00293 if (enclen + *len > buflen) { 00294 ast_log(LOG_ERROR, "(%s): Buffer overflow detected (%d + %d > %d)\n", 00295 LOG_TAG(udptl), enclen, *len, buflen); 00296 return -1; 00297 } 00298 if (enclen > 0) { 00299 memcpy(&buf[*len], &data[octet_idx], enclen); 00300 *len += enclen; 00301 } 00302 if (enclen >= num_octets) 00303 break; 00304 } 00305 00306 return 0; 00307 }
static struct ast_udptl_protocol* get_proto | ( | struct ast_channel * | chan | ) | [static] |
Definition at line 1115 of file udptl.c.
References AST_RWLIST_RDLOCK, AST_RWLIST_TRAVERSE, AST_RWLIST_UNLOCK, ast_udptl_protocol::list, ast_channel::tech, ast_channel_tech::type, and ast_udptl_protocol::type.
Referenced by ast_udptl_bridge().
01116 { 01117 struct ast_udptl_protocol *cur = NULL; 01118 01119 AST_RWLIST_RDLOCK(&protos); 01120 AST_RWLIST_TRAVERSE(&protos, cur, list) { 01121 if (cur->type == chan->tech->type) 01122 break; 01123 } 01124 AST_RWLIST_UNLOCK(&protos); 01125 01126 return cur; 01127 }
static char* handle_cli_udptl_set_debug | ( | struct ast_cli_entry * | e, | |
int | cmd, | |||
struct ast_cli_args * | a | |||
) | [static] |
Definition at line 1254 of file udptl.c.
References ast_cli_args::argc, ast_cli_args::argv, ast_cli(), ast_free, ast_sockaddr_copy(), ast_sockaddr_resolve(), ast_sockaddr_stringify(), CLI_GENERATE, CLI_INIT, CLI_SHOWUSAGE, CLI_SUCCESS, ast_cli_entry::command, ast_cli_args::fd, udptldebugaddr, and ast_cli_entry::usage.
01255 { 01256 switch (cmd) { 01257 case CLI_INIT: 01258 e->command = "udptl set debug {on|off|ip}"; 01259 e->usage = 01260 "Usage: udptl set debug {on|off|ip host[:port]}\n" 01261 " Enable or disable dumping of UDPTL packets.\n" 01262 " If ip is specified, limit the dumped packets to those to and from\n" 01263 " the specified 'host' with optional port.\n"; 01264 return NULL; 01265 case CLI_GENERATE: 01266 return NULL; 01267 } 01268 01269 if (a->argc < 4 || a->argc > 5) 01270 return CLI_SHOWUSAGE; 01271 01272 if (a->argc == 4) { 01273 if (!strncasecmp(a->argv[3], "on", 2)) { 01274 udptldebug = 1; 01275 memset(&udptldebugaddr, 0, sizeof(udptldebugaddr)); 01276 ast_cli(a->fd, "UDPTL Debugging Enabled\n"); 01277 } else if (!strncasecmp(a->argv[3], "off", 3)) { 01278 udptldebug = 0; 01279 ast_cli(a->fd, "UDPTL Debugging Disabled\n"); 01280 } else { 01281 return CLI_SHOWUSAGE; 01282 } 01283 } else { 01284 struct ast_sockaddr *addrs; 01285 if (strncasecmp(a->argv[3], "ip", 2)) 01286 return CLI_SHOWUSAGE; 01287 if (!ast_sockaddr_resolve(&addrs, a->argv[4], 0, 0)) { 01288 return CLI_SHOWUSAGE; 01289 } 01290 ast_sockaddr_copy(&udptldebugaddr, &addrs[0]); 01291 ast_cli(a->fd, "UDPTL Debugging Enabled for IP: %s\n", ast_sockaddr_stringify(&udptldebugaddr)); 01292 udptldebug = 1; 01293 ast_free(addrs); 01294 } 01295 01296 return CLI_SUCCESS; 01297 }
static int udptl_build_packet | ( | struct ast_udptl * | s, | |
uint8_t * | buf, | |||
unsigned int | buflen, | |||
uint8_t * | ifp, | |||
unsigned int | ifp_len | |||
) | [static] |
Definition at line 521 of file udptl.c.
References ast_debug, udptl_fec_tx_buffer_t::buf, udptl_fec_tx_buffer_t::buf_len, encode_length(), encode_open_type(), ast_udptl::error_correction_entries, ast_udptl::error_correction_scheme, ast_udptl::error_correction_span, len(), LOCAL_FAX_MAX_DATAGRAM, LOG_TAG, seq, ast_udptl::tx, ast_udptl::tx_seq_no, UDPTL_ERROR_CORRECTION_FEC, UDPTL_ERROR_CORRECTION_NONE, and UDPTL_ERROR_CORRECTION_REDUNDANCY.
Referenced by ast_udptl_write().
00522 { 00523 uint8_t fec[LOCAL_FAX_MAX_DATAGRAM * 2]; 00524 int i; 00525 int j; 00526 int seq; 00527 int entry; 00528 int entries; 00529 int span; 00530 int m; 00531 unsigned int len; 00532 int limit; 00533 int high_tide; 00534 00535 seq = s->tx_seq_no & 0xFFFF; 00536 00537 /* Map the sequence number to an entry in the circular buffer */ 00538 entry = seq & UDPTL_BUF_MASK; 00539 00540 /* We save the message in a circular buffer, for generating FEC or 00541 redundancy sets later on. */ 00542 s->tx[entry].buf_len = ifp_len; 00543 memcpy(s->tx[entry].buf, ifp, ifp_len); 00544 00545 /* Build the UDPTLPacket */ 00546 00547 len = 0; 00548 /* Encode the sequence number */ 00549 buf[len++] = (seq >> 8) & 0xFF; 00550 buf[len++] = seq & 0xFF; 00551 00552 /* Encode the primary IFP packet */ 00553 if (encode_open_type(s, buf, buflen, &len, ifp, ifp_len) < 0) 00554 return -1; 00555 00556 /* Encode the appropriate type of error recovery information */ 00557 switch (s->error_correction_scheme) 00558 { 00559 case UDPTL_ERROR_CORRECTION_NONE: 00560 /* Encode the error recovery type */ 00561 buf[len++] = 0x00; 00562 /* The number of entries will always be zero, so it is pointless allowing 00563 for the fragmented case here. */ 00564 if (encode_length(buf, &len, 0) < 0) 00565 return -1; 00566 break; 00567 case UDPTL_ERROR_CORRECTION_REDUNDANCY: 00568 /* Encode the error recovery type */ 00569 buf[len++] = 0x00; 00570 if (s->tx_seq_no > s->error_correction_entries) 00571 entries = s->error_correction_entries; 00572 else 00573 entries = s->tx_seq_no; 00574 /* The number of entries will always be small, so it is pointless allowing 00575 for the fragmented case here. */ 00576 if (encode_length(buf, &len, entries) < 0) 00577 return -1; 00578 /* Encode the elements */ 00579 for (i = 0; i < entries; i++) { 00580 j = (entry - i - 1) & UDPTL_BUF_MASK; 00581 if (encode_open_type(s, buf, buflen, &len, s->tx[j].buf, s->tx[j].buf_len) < 0) { 00582 ast_debug(1, "(%s): Encoding failed at i=%d, j=%d\n", 00583 LOG_TAG(s), i, j); 00584 return -1; 00585 } 00586 } 00587 break; 00588 case UDPTL_ERROR_CORRECTION_FEC: 00589 span = s->error_correction_span; 00590 entries = s->error_correction_entries; 00591 if (seq < s->error_correction_span*s->error_correction_entries) { 00592 /* In the initial stages, wind up the FEC smoothly */ 00593 entries = seq/s->error_correction_span; 00594 if (seq < s->error_correction_span) 00595 span = 0; 00596 } 00597 /* Encode the error recovery type */ 00598 buf[len++] = 0x80; 00599 /* Span is defined as an inconstrained integer, which it dumb. It will only 00600 ever be a small value. Treat it as such. */ 00601 buf[len++] = 1; 00602 buf[len++] = span; 00603 /* The number of entries is defined as a length, but will only ever be a small 00604 value. Treat it as such. */ 00605 buf[len++] = entries; 00606 for (m = 0; m < entries; m++) { 00607 /* Make an XOR'ed entry the maximum length */ 00608 limit = (entry + m) & UDPTL_BUF_MASK; 00609 high_tide = 0; 00610 for (i = (limit - span*entries) & UDPTL_BUF_MASK; i != limit; i = (i + entries) & UDPTL_BUF_MASK) { 00611 if (high_tide < s->tx[i].buf_len) { 00612 for (j = 0; j < high_tide; j++) 00613 fec[j] ^= s->tx[i].buf[j]; 00614 for ( ; j < s->tx[i].buf_len; j++) 00615 fec[j] = s->tx[i].buf[j]; 00616 high_tide = s->tx[i].buf_len; 00617 } else { 00618 for (j = 0; j < s->tx[i].buf_len; j++) 00619 fec[j] ^= s->tx[i].buf[j]; 00620 } 00621 } 00622 if (encode_open_type(s, buf, buflen, &len, fec, high_tide) < 0) 00623 return -1; 00624 } 00625 break; 00626 } 00627 00628 if (s->verbose) 00629 fprintf(stderr, "\n"); 00630 00631 s->tx_seq_no++; 00632 return len; 00633 }
static int udptl_debug_test_addr | ( | const struct ast_sockaddr * | addr | ) | [inline, static] |
Definition at line 185 of file udptl.c.
References ast_sockaddr_cmp(), ast_sockaddr_cmp_addr(), ast_sockaddr_isnull(), ast_sockaddr_port, and udptldebugaddr.
Referenced by ast_udptl_read(), and ast_udptl_write().
00186 { 00187 if (udptldebug == 0) 00188 return 0; 00189 00190 if (ast_sockaddr_isnull(&udptldebugaddr)) { 00191 return 1; 00192 } 00193 00194 if (ast_sockaddr_port(&udptldebugaddr)) { 00195 return !ast_sockaddr_cmp(&udptldebugaddr, addr); 00196 } else { 00197 return !ast_sockaddr_cmp_addr(&udptldebugaddr, addr); 00198 } 00199 }
static int udptl_rx_packet | ( | struct ast_udptl * | s, | |
uint8_t * | buf, | |||
unsigned int | len | |||
) | [static] |
Definition at line 310 of file udptl.c.
References ARRAY_LEN, AST_FRAME_MODEM, AST_LIST_NEXT, AST_MODEM_T38, ast_frame_subclass::codec, ast_frame::data, ast_frame::datalen, decode_length(), decode_open_type(), ast_udptl::f, ast_frame::frametype, ast_frame::mallocd, ast_frame::offset, ast_frame::ptr, ast_udptl::rx_seq_no, ast_frame::seqno, ast_frame::src, and ast_frame::subclass.
Referenced by ast_udptl_read().
00311 { 00312 int stat1; 00313 int stat2; 00314 int i; 00315 int j; 00316 int k; 00317 int l; 00318 int m; 00319 int x; 00320 int limit; 00321 int which; 00322 unsigned int ptr; 00323 unsigned int count; 00324 int total_count; 00325 int seq_no; 00326 const uint8_t *ifp; 00327 const uint8_t *data; 00328 unsigned int ifp_len; 00329 int repaired[16]; 00330 const uint8_t *bufs[ARRAY_LEN(s->f) - 1]; 00331 unsigned int lengths[ARRAY_LEN(s->f) - 1]; 00332 int span; 00333 int entries; 00334 int ifp_no; 00335 00336 ptr = 0; 00337 ifp_no = 0; 00338 memset(&s->f[0], 0, sizeof(s->f[0])); 00339 00340 /* Decode seq_number */ 00341 if (ptr + 2 > len) 00342 return -1; 00343 seq_no = (buf[0] << 8) | buf[1]; 00344 ptr += 2; 00345 00346 /* Break out the primary packet */ 00347 if ((stat1 = decode_open_type(buf, len, &ptr, &ifp, &ifp_len)) != 0) 00348 return -1; 00349 /* Decode error_recovery */ 00350 if (ptr + 1 > len) 00351 return -1; 00352 if ((buf[ptr++] & 0x80) == 0) { 00353 /* Secondary packet mode for error recovery */ 00354 if (seq_no > s->rx_seq_no) { 00355 /* We received a later packet than we expected, so we need to check if we can fill in the gap from the 00356 secondary packets. */ 00357 total_count = 0; 00358 do { 00359 if ((stat2 = decode_length(buf, len, &ptr, &count)) < 0) 00360 return -1; 00361 for (i = 0; i < count && total_count + i < ARRAY_LEN(bufs); i++) { 00362 if ((stat1 = decode_open_type(buf, len, &ptr, &bufs[total_count + i], &lengths[total_count + i])) != 0) 00363 return -1; 00364 } 00365 total_count += i; 00366 } 00367 while (stat2 > 0 && total_count < ARRAY_LEN(bufs)); 00368 /* Step through in reverse order, so we go oldest to newest */ 00369 for (i = total_count; i > 0; i--) { 00370 if (seq_no - i >= s->rx_seq_no) { 00371 /* This one wasn't seen before */ 00372 /* Decode the secondary IFP packet */ 00373 //fprintf(stderr, "Secondary %d, len %d\n", seq_no - i, lengths[i - 1]); 00374 s->f[ifp_no].frametype = AST_FRAME_MODEM; 00375 s->f[ifp_no].subclass.codec = AST_MODEM_T38; 00376 00377 s->f[ifp_no].mallocd = 0; 00378 s->f[ifp_no].seqno = seq_no - i; 00379 s->f[ifp_no].datalen = lengths[i - 1]; 00380 s->f[ifp_no].data.ptr = (uint8_t *) bufs[i - 1]; 00381 s->f[ifp_no].offset = 0; 00382 s->f[ifp_no].src = "UDPTL"; 00383 if (ifp_no > 0) 00384 AST_LIST_NEXT(&s->f[ifp_no - 1], frame_list) = &s->f[ifp_no]; 00385 AST_LIST_NEXT(&s->f[ifp_no], frame_list) = NULL; 00386 ifp_no++; 00387 } 00388 } 00389 } 00390 } 00391 else 00392 { 00393 /* FEC mode for error recovery */ 00394 /* Our buffers cannot tolerate overlength IFP packets in FEC mode */ 00395 if (ifp_len > LOCAL_FAX_MAX_DATAGRAM) 00396 return -1; 00397 /* Update any missed slots in the buffer */ 00398 for ( ; seq_no > s->rx_seq_no; s->rx_seq_no++) { 00399 x = s->rx_seq_no & UDPTL_BUF_MASK; 00400 s->rx[x].buf_len = -1; 00401 s->rx[x].fec_len[0] = 0; 00402 s->rx[x].fec_span = 0; 00403 s->rx[x].fec_entries = 0; 00404 } 00405 00406 x = seq_no & UDPTL_BUF_MASK; 00407 00408 memset(repaired, 0, sizeof(repaired)); 00409 00410 /* Save the new IFP packet */ 00411 memcpy(s->rx[x].buf, ifp, ifp_len); 00412 s->rx[x].buf_len = ifp_len; 00413 repaired[x] = TRUE; 00414 00415 /* Decode the FEC packets */ 00416 /* The span is defined as an unconstrained integer, but will never be more 00417 than a small value. */ 00418 if (ptr + 2 > len) 00419 return -1; 00420 if (buf[ptr++] != 1) 00421 return -1; 00422 span = buf[ptr++]; 00423 s->rx[x].fec_span = span; 00424 00425 /* The number of entries is defined as a length, but will only ever be a small 00426 value. Treat it as such. */ 00427 if (ptr + 1 > len) 00428 return -1; 00429 entries = buf[ptr++]; 00430 if (entries > MAX_FEC_ENTRIES) { 00431 return -1; 00432 } 00433 s->rx[x].fec_entries = entries; 00434 00435 /* Decode the elements */ 00436 for (i = 0; i < entries; i++) { 00437 if ((stat1 = decode_open_type(buf, len, &ptr, &data, &s->rx[x].fec_len[i])) != 0) 00438 return -1; 00439 if (s->rx[x].fec_len[i] > LOCAL_FAX_MAX_DATAGRAM) 00440 return -1; 00441 00442 /* Save the new FEC data */ 00443 memcpy(s->rx[x].fec[i], data, s->rx[x].fec_len[i]); 00444 #if 0 00445 fprintf(stderr, "FEC: "); 00446 for (j = 0; j < s->rx[x].fec_len[i]; j++) 00447 fprintf(stderr, "%02X ", data[j]); 00448 fprintf(stderr, "\n"); 00449 #endif 00450 } 00451 00452 /* See if we can reconstruct anything which is missing */ 00453 /* TODO: this does not comprehensively hunt back and repair everything that is possible */ 00454 for (l = x; l != ((x - (16 - span*entries)) & UDPTL_BUF_MASK); l = (l - 1) & UDPTL_BUF_MASK) { 00455 if (s->rx[l].fec_len[0] <= 0) 00456 continue; 00457 for (m = 0; m < s->rx[l].fec_entries; m++) { 00458 limit = (l + m) & UDPTL_BUF_MASK; 00459 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) { 00460 if (s->rx[k].buf_len <= 0) 00461 which = (which == -1) ? k : -2; 00462 } 00463 if (which >= 0) { 00464 /* Repairable */ 00465 for (j = 0; j < s->rx[l].fec_len[m]; j++) { 00466 s->rx[which].buf[j] = s->rx[l].fec[m][j]; 00467 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) 00468 s->rx[which].buf[j] ^= (s->rx[k].buf_len > j) ? s->rx[k].buf[j] : 0; 00469 } 00470 s->rx[which].buf_len = s->rx[l].fec_len[m]; 00471 repaired[which] = TRUE; 00472 } 00473 } 00474 } 00475 /* Now play any new packets forwards in time */ 00476 for (l = (x + 1) & UDPTL_BUF_MASK, j = seq_no - UDPTL_BUF_MASK; l != x; l = (l + 1) & UDPTL_BUF_MASK, j++) { 00477 if (repaired[l]) { 00478 //fprintf(stderr, "Fixed packet %d, len %d\n", j, l); 00479 s->f[ifp_no].frametype = AST_FRAME_MODEM; 00480 s->f[ifp_no].subclass.codec = AST_MODEM_T38; 00481 00482 s->f[ifp_no].mallocd = 0; 00483 s->f[ifp_no].seqno = j; 00484 s->f[ifp_no].datalen = s->rx[l].buf_len; 00485 s->f[ifp_no].data.ptr = s->rx[l].buf; 00486 s->f[ifp_no].offset = 0; 00487 s->f[ifp_no].src = "UDPTL"; 00488 if (ifp_no > 0) 00489 AST_LIST_NEXT(&s->f[ifp_no - 1], frame_list) = &s->f[ifp_no]; 00490 AST_LIST_NEXT(&s->f[ifp_no], frame_list) = NULL; 00491 ifp_no++; 00492 } 00493 } 00494 } 00495 00496 /* If packets are received out of sequence, we may have already processed this packet from the error 00497 recovery information in a packet already received. */ 00498 if (seq_no >= s->rx_seq_no) { 00499 /* Decode the primary IFP packet */ 00500 s->f[ifp_no].frametype = AST_FRAME_MODEM; 00501 s->f[ifp_no].subclass.codec = AST_MODEM_T38; 00502 00503 s->f[ifp_no].mallocd = 0; 00504 s->f[ifp_no].seqno = seq_no; 00505 s->f[ifp_no].datalen = ifp_len; 00506 s->f[ifp_no].data.ptr = (uint8_t *) ifp; 00507 s->f[ifp_no].offset = 0; 00508 s->f[ifp_no].src = "UDPTL"; 00509 if (ifp_no > 0) 00510 AST_LIST_NEXT(&s->f[ifp_no - 1], frame_list) = &s->f[ifp_no]; 00511 AST_LIST_NEXT(&s->f[ifp_no], frame_list) = NULL; 00512 00513 ifp_no++; 00514 } 00515 00516 s->rx_seq_no = seq_no + 1; 00517 return ifp_no; 00518 }
static int udptlread | ( | int * | id, | |
int | fd, | |||
short | events, | |||
void * | cbdata | |||
) | [static] |
Definition at line 655 of file udptl.c.
References ast_udptl_read(), ast_udptl::callback, and f.
00656 { 00657 struct ast_udptl *udptl = cbdata; 00658 struct ast_frame *f; 00659 00660 if ((f = ast_udptl_read(udptl))) { 00661 if (udptl->callback) 00662 udptl->callback(udptl, f, udptl->data); 00663 } 00664 return 1; 00665 }
struct ast_cli_entry cli_udptl[] [static] |
Initial value:
{ { .handler = handle_cli_udptl_set_debug , .summary = "Enable/Disable UDPTL debugging" ,__VA_ARGS__ } }
Definition at line 1300 of file udptl.c.
Referenced by ast_udptl_init().
int udptldebug [static] |
struct ast_sockaddr udptldebugaddr [static] |
Debug packets to/from this host
Definition at line 85 of file udptl.c.
Referenced by handle_cli_udptl_set_debug(), and udptl_debug_test_addr().
int udptlfecentries [static] |
int udptlfecspan [static] |
int udptlstart = 4500 [static] |
int use_even_ports [static] |