[Freeswitch-svn] [commit] r8321 - in freeswitch/trunk: . libs/iax src/mod/endpoints/mod_iax

Author: anthm Date: Thu May 8 19:25:36 2008 New Revision: 8321 Added: freeswitch/trunk/src/mod/endpoints/mod_iax/answer.h freeswitch/trunk/src/mod/endpoints/mod_iax/frame.h freeswitch/trunk/src/mod/endpoints/mod_iax/iax-client.h freeswitch/trunk/src/mod/endpoints/mod_iax/iax-mutex.c freeswitch/trunk/src/mod/endpoints/mod_iax/iax-mutex.h freeswitch/trunk/src/mod/endpoints/mod_iax/iax.c freeswitch/trunk/src/mod/endpoints/mod_iax/iax.h freeswitch/trunk/src/mod/endpoints/mod_iax/iax2-parser.c freeswitch/trunk/src/mod/endpoints/mod_iax/iax2-parser.h freeswitch/trunk/src/mod/endpoints/mod_iax/iax2.h freeswitch/trunk/src/mod/endpoints/mod_iax/jitterbuf.c freeswitch/trunk/src/mod/endpoints/mod_iax/jitterbuf.h freeswitch/trunk/src/mod/endpoints/mod_iax/md5.c freeswitch/trunk/src/mod/endpoints/mod_iax/md5.h freeswitch/trunk/src/mod/endpoints/mod_iax/winiphone.c freeswitch/trunk/src/mod/endpoints/mod_iax/winpoop.h Removed: freeswitch/trunk/libs/iax/ Modified: freeswitch/trunk/configure.in freeswitch/trunk/src/mod/endpoints/mod_iax/Makefile Log: slim down iax build Modified: freeswitch/trunk/configure.in ============================================================================== --- freeswitch/trunk/configure.in (original) +++ freeswitch/trunk/configure.in Thu May 8 19:25:36 2008 @@ -593,7 +593,6 @@ AC_CONFIG_SUBDIRS(libs/voipcodecs) AC_CONFIG_SUBDIRS(libs/codec/ilbc) AC_CONFIG_SUBDIRS(libs/curl) -AC_CONFIG_SUBDIRS(libs/iax) AC_CONFIG_SUBDIRS(libs/iksemel) AC_CONFIG_SUBDIRS(libs/js/nsprpub) AC_CONFIG_SUBDIRS(libs/js) Modified: freeswitch/trunk/src/mod/endpoints/mod_iax/Makefile ============================================================================== --- freeswitch/trunk/src/mod/endpoints/mod_iax/Makefile (original) +++ freeswitch/trunk/src/mod/endpoints/mod_iax/Makefile Thu May 8 19:25:36 2008 @@ -1,11 +1,6 @@ BASE=../../../.. +LOCAL_CFLAGS=-I. -DNEWJB -DLIBIAX +LOCAL_OBJS=iax2-parser.o iax.o md5.o jitterbuf.o iax-mutex.o -IAX_DIR=$(BASE)/libs/iax -IAXLA=$(IAX_DIR)/src/libiax.la -LOCAL_CFLAGS=-I$(IAX_DIR)/src -LOCAL_LIBADD=$(IAXLA) include $(BASE)/build/modmake.rules -$(IAXLA): $(IAX_DIR) $(IAX_DIR)/.update - cd $(IAX_DIR) && $(MAKE) - Added: freeswitch/trunk/src/mod/endpoints/mod_iax/answer.h ============================================================================== --- (empty file) +++ freeswitch/trunk/src/mod/endpoints/mod_iax/answer.h Thu May 8 19:25:36 2008 @@ -0,0 +1,237 @@ +/* + * Signed 16-bit audio data + * + * Source: answer.raw + * + * Copyright (C) 1999, Mark Spencer and Linux Support Services + * + * Distributed under the terms of the GNU General Public License + * + */ + +static signed short answer[] = { +000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, +000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, +000000, 000000, 0x19b7, 0x0245, 0xeee5, 0xb875, 0xd9a4, 0x6018, 0x660a, 0xc3c6, +0x8741, 0xff55, 0x4c2e, 0x2146, 0xfed2, 0xf079, 0xcbd4, 0xe561, 0x3c41, 0x3166, +0xd425, 0xdc59, 0x2748, 0x087d, 0xc72b, 0xfe3a, 0x4681, 0x14c6, 0xcf45, 0xdd38, +0xf8dd, 0x0a39, 0x3a5a, 0x32b9, 0xbfec, 0x957f, 0x15a3, 0x70f4, 0x1d95, 0xbfc4, +0xd367, 0xfda0, 0x0dc0, 0x29eb, 0x1fc2, 0xd684, 0xcab1, 0x19c7, 0x29ef, 0xe679, +0xe9d0, 0x2b82, 0x151a, 0xca9f, 0xdb68, 0x1f4a, 0x271c, 0x0e2a, 0xfb32, 0xd1b2, +0xc8ff, 0x2382, 0x6380, 0x0a52, 0xa118, 0xccbf, 0x2ddc, 0x33fd, 0x0964, 0xf2a4, +0xdd81, 0xe092, 0x1a00, 0x325c, 0xf5e3, 0xd6a1, 0x0b6c, 0x1c75, 0xe4f8, 0xe07c, +0x2082, 0x2b3e, 0xf445, 0xdaa9, 0xea13, 0xff3c, 0x245c, 0x35c1, 0xf308, 0xab53, +0xdf59, 0x4698, 0x3f3b, 0xe7f7, 0xca84, 0xed4d, 0x0c3f, 0x1e94, 0x1c2d, 0xf06f, +0xd4df, 0xff34, 0x23d8, 0x001e, 0xe3f1, 0x0b15, 0x2113, 0xf3fd, 0xd768, 0xf9a0, +0x1d31, 0x1c6e, 0x0797, 0xe3a0, 0xce6c, 0xfd7b, 0x422a, 0x2c4c, 0xd364, 0xbf42, +0x0278, 0x303e, 0x1c51, 0xf737, 0xe25a, 0xe75f, 0x0a8f, 0x22ab, 0x05f4, 0xe3f9, +0xf8c4, 0x1705, 0x0162, 0xe49f, 0xfb8b, 0x1e2b, 0x13ac, 0xf044, 0xe07b, 0xf01a, +0x1567, 0x2cbf, 0x0b75, 0xd01b, 0xd206, 0x1563, 0x38d7, 0x0f2e, 0xdb32, 0xdc30, +0x023b, 0x1e44, 0x16eb, 0xf5f7, 0xe425, 0xfa33, 0x14d5, 0x0968, 0xeff2, 0xf762, +0x1137, 0x0e59, 0xf13a, 0xe651, 0xff41, 0x1d60, 0x18fd, 0xf1e6, 0xd75f, 0xf097, +0x20ec, 0x27fa, 0xfba4, 0xd5b8, 0xe68e, 0x1657, 0x2518, 0x04f6, 0xe5a3, 0xe976, +0x0578, 0x18fa, 0x0a92, 0xec0a, 0xef2a, 0x111f, 0x12f4, 0xeec3, 0xe95e, 0x0d3a, +0x18fd, 0xff72, 0xeefc, 0xf114, 0xfaaa, 0x14ee, 0x21db, 0xf56e, 0xcb49, 0xf621, +0x3323, 0x1947, 0xe017, 0xe7e9, 0x0819, 0x0707, 0x084c, 0x0f57, 0xf152, 0xdf92, +0x104a, 0x28eb, 0xedcc, 0xd4ad, 0x1415, 0x296d, 0xed9a, 0xdf57, 0x0cc2, 0x0d95, +0xf7b5, 0x0deb, 0x0b34, 0xd713, 0xea08, 0x38d6, 0x216d, 0xc727, 0xdc32, 0x2cd2, +0x1822, 0xe2d5, 0xfeb3, 0x106c, 0xe6e5, 0xf81e, 0x2fe8, 0x01af, 0xc180, 0x037a, +0x42d8, 0xf88d, 0xc344, 0x0a4f, 0x2c4e, 0xf19d, 0xebeb, 0x162c, 0xf9e9, 0xde93, +0x1b56, 0x2c60, 0xd8aa, 0xce3e, 0x2a41, 0x2eeb, 0xdab1, 0xde32, 0x1c32, 0x0aba, +0xeabe, 0x1008, 0x136d, 0xda2f, 0xec3b, 0x31dd, 0x1130, 0xca79, 0xf5b8, 0x3423, +0x0274, 0xd27d, 0x035e, 0x1e68, 0xf641, 0xf904, 0x1691, 0xef7d, 0xd57a, 0x1c3b, +0x3c23, 0xe881, 0xc274, 0x0af5, 0x2962, 0xfa34, 0xf676, 0x0f71, 0xefcc, 0xe01f, +0x19e7, 0x276f, 0xe694, 0xe134, 0x1c3a, 0x0e8b, 0xd8e7, 0xfa81, 0x2f8b, 0x07c5, +0xd904, 0xf6fa, 0x0ca5, 0xf9a2, 0x0dc7, 0x2623, 0xec54, 0xbe23, 0x02b6, 0x4296, +0x10cd, 0xda61, 0xf11c, 0x0103, 0xf41c, 0x10b4, 0x2a03, 0xf63c, 0xce1a, 0xfdbd, +0x1fb4, 0xfc51, 0xf727, 0x1c8a, 0x04ff, 0xcf41, 0xec05, 0x2913, 0x1ce8, 0xf70c, +0xf744, 0xede8, 0xdd77, 0x0d99, 0x43f1, 0x119c, 0xc14f, 0xd60e, 0x17cb, 0x1e19, +0x0d4e, 0x0c95, 0xeed1, 0xcdf4, 0xf7a5, 0x331f, 0x1cd0, 0xeb17, 0xf082, 0xfb19, +0xe899, 0xfdeb, 0x323c, 0x2036, 0xdad3, 0xd134, 0xfd03, 0x1345, 0x1c10, 0x2239, +0xf656, 0xbc22, 0xdc3f, 0x3392, 0x3d59, 0xfd77, 0xdb4d, 0xe23f, 0xedbe, 0x0f7e, +0x35cc, 0x1947, 0xd5dc, 0xd1bf, 0x035d, 0x16fc, 0x1174, 0x1675, 0x0249, 0xd2d4, +0xd851, 0x184d, 0x32fe, 0x0f91, 0xee14, 0xe1e6, 0xdf9b, 0x016b, 0x3668, 0x2b2b, +0xe20c, 0xc554, 0xf257, 0x1c05, 0x1fc5, 0x14f0, 0xf891, 0xd41c, 0xdf83, 0x1865, +0x2de1, 0x0b16, 0xed58, 0xea0c, 0xea79, 0xfbd9, 0x22af, 0x2732, 0xf62f, 0xd389, +0xe7d9, 0x0b39, 0x1cdc, 0x1de3, 0x038a, 0xd809, 0xd5f7, 0x0b55, 0x305e, 0x1910, +0xf02e, 0xe089, 0xe7c7, 0x0195, 0x2265, 0x21da, 0xf743, 0xd8f2, 0xe978, 0x09a1, +0x190a, 0x17c5, 0x045a, 0xe46d, 0xdd06, 0xffb2, 0x2293, 0x1cfe, 0xfd4d, 0xe4f9, +0xe310, 0xfaf1, 0x1d22, 0x2376, 0x0113, 0xde3a, 0xe21b, 0x0204, 0x1ba1, 0x1bd6, +0x0333, 0xe563, 0xe104, 0xfd51, 0x1bc1, 0x1ccf, 0x0285, 0xe757, 0xe35e, 0xfaf2, +0x185d, 0x1d46, 0x06b7, 0xec13, 0xe108, 0xef6e, 0x121d, 0x2a17, 0x16a6, 0xe32c, +0xc9a9, 0xf070, 0x2f48, 0x3788, 0xfa4e, 0xc32a, 0xd9c2, 0x1fa1, 0x36fe, 0x07fa, +0xd9e4, 0xe577, 0x0e5e, 0x1755, 0xfb53, 0xed71, 0x0540, 0x19e0, 0x0301, 0xdc97, +0xe391, 0x1937, 0x367c, 0x0bc9, 0xca4c, 0xc96b, 0x105d, 0x461f, 0x2416, 0xd481, +0xbc97, 0xf8b7, 0x39af, 0x2ec9, 0xecc6, 0xcb50, 0xeee3, 0x1ffe, 0x1e8e, 0xf700, +0xe66a, 0xff58, 0x149f, 0x02e5, 0xe792, 0xf2d8, 0x1a4d, 0x225a, 0xf642, 0xce7f, +0xe6a6, 0x25e2, 0x38f5, 0x01d0, 0xc50f, 0xd243, 0x19bd, 0x3fc6, 0x14f0, 0xd2d7, +0xcdb6, 0x069a, 0x2ffe, 0x1847, 0xe6f8, 0xdf0a, 0x0337, 0x1a90, 0x067a, 0xeb5b, +0xf541, 0x143b, 0x14f2, 0xf092, 0xdc02, 0xfb91, 0x28a3, 0x2274, 0xeaa8, 0xc9e7, +0xef48, 0x2d01, 0x322e, 0xf6d2, 0xc7cb, 0xe13b, 0x1fda, 0x3217, 0x0458, 0xd690, +0xe2bf, 0x11c4, 0x21d5, 0x0291, 0xe5c8, 0xf3a9, 0x12ba, 0x11aa, 0xf22b, 0xe627, +0x03ec, 0x219a, 0x1036, 0xe2f2, 0xd93f, 0x059c, 0x2ed6, 0x1b75, 0xe227, 0xce55, +0xfb19, 0x2de0, 0x2477, 0xed08, 0xd148, 0xf307, 0x21d4, 0x2002, 0xf543, 0xdeac, +0xf7f9, 0x18a9, 0x11d6, 0xf0ef, 0xe8e4, 0x05ea, 0x1ba5, 0x0727, 0xe448, 0xe748, +0x100e, 0x265e, 0x07fc, 0xdbae, 0xde78, 0x0efa, 0x2ce0, 0x0f94, 0xddf1, 0xd9ea, +0x0797, 0x28f6, 0x12eb, 0xe60c, 0xdf46, 0x0469, 0x1fbb, 0x0ced, 0xe9f6, 0xe95f, +0x09fe, 0x1ab9, 0x02cb, 0xe5a4, 0xef2a, 0x1327, 0x1d7b, 0xfd07, 0xde3d, 0xed9c, +0x17e5, 0x22e7, 0xfe3a, 0xdb38, 0xe9b9, 0x161a, 0x2416, 0x0175, 0xde3d, 0xe9de, +0x1294, 0x1fc9, 0x00ea, 0xe2a7, 0xeee2, 0x1298, 0x1a7d, 0xfc1d, 0xe3bb, 0xf47a, +0x1642, 0x185e, 0xf727, 0xe1af, 0xf709, 0x19c3, 0x18e7, 0xf50d, 0xe010, 0xf75b, +0x1a9c, 0x18d8, 0xf4c5, 0xe0c9, 0xf865, 0x1a1c, 0x16d5, 0xf3a6, 0xe257, 0xfaf2, +0x1a44, 0x14d5, 0xf34f, 0xe4b6, 0xfc77, 0x17d5, 0x0ff8, 0xf133, 0xe8b7, 0x0344, +0x1a37, 0x0ad5, 0xe95e, 0xe61a, 0x08a5, 0x227e, 0x0e33, 0xe4a7, 0xdd70, 0x03b0, +0x25f4, 0x17b2, 0xec0a, 0xdb4e, 0xf898, 0x1ba3, 0x18f6, 0xf973, 0xe87f, 0xf77a, +0x0b93, 0x096c, 0xfb0e, 0xfb03, 0x0896, 0x0940, 0xf51d, 0xe904, 0xfdc7, 0x1dda, +0x1bf9, 0xf29b, 0xd37f, 0xea1b, 0x1f37, 0x3175, 0x07eb, 0xd3f7, 0xd46b, 0x077d, +0x2eeb, 0x1e67, 0xeeae, 0xd8c7, 0xef85, 0x1119, 0x18d3, 0x088e, 0xf953, 0xf5ad, +0xf556, 0xf63d, 0x0234, 0x167a, 0x19a1, 0xfbf9, 0xd873, 0xdd4b, 0x0f06, 0x3748, +0x21e6, 0xe181, 0xc032, 0xe79a, 0x2bec, 0x3e76, 0x0b1b, 0xce41, 0xcb23, 0xff96, +0x2d79, 0x26d1, 0xfcc7, 0xdf8a, 0xe525, 0xfd83, 0x10f1, 0x16d7, 0x0f50, 0xfaea, +0xe3f1, 0xe20f, 0x0158, 0x27d9, 0x2866, 0xf96f, 0xcb34, 0xd563, 0x11d6, 0x3d25, +0x2424, 0xe254, 0xc2c9, 0xe7cd, 0x248d, 0x34f5, 0x0c42, 0xdcd0, 0xd827, 0xfa65, +0x19eb, 0x1b50, 0x0721, 0xf396, 0xeb9c, 0xefde, 0x0016, 0x1594, 0x1cc1, 0x0658, +0xe22b, 0xd852, 0xfb3e, 0x2923, 0x2c78, 0xfc87, 0xcdb5, 0xd69c, 0x0e3c, 0x3527, +0x201f, 0xe993, 0xcf9e, 0xeb21, 0x183f, 0x25ea, 0x0c93, 0xed4d, 0xe5f9, 0xf548, +0x07fb, 0x117c, 0x0ff2, 0x0398, 0xf08c, 0xe628, 0xf489, 0x143b, 0x2419, 0x0ccf, +0xe2cc, 0xd5a6, 0xf861, 0x2615, 0x2a1b, 0xfeb4, 0xd543, 0xdc53, 0x09b4, 0x2901, +0x19ff, 0xf24a, 0xde86, 0xeec4, 0x0b7b, 0x1733, 0x0d0a, 0xfc24, 0xf1bb, 0xf110, +0xfa03, 0x0a0f, 0x15d4, 0x0e21, 0xf435, 0xe17e, 0xee90, 0x1225, 0x2527, 0x0efa, +0xe61f, 0xd916, 0xf7b8, 0x1f50, 0x2326, 0x0099, 0xe01e, 0xe473, 0x0491, 0x1b37, +0x1360, 0xfb17, 0xecd9, 0xf20d, 0x0051, 0x0aec, 0x0d4a, 0x073d, 0xfa5a, 0xeeb8, +0xf165, 0x0516, 0x17dc, 0x12da, 0xf71b, 0xe213, 0xed85, 0x0eef, 0x20c8, 0x0e09, +0xebcc, 0xe0d4, 0xf848, 0x1637, 0x19d6, 0x026b, 0xec09, 0xed00, 0xff9b, 0x0e5a, +0x0d6b, 0x026c, 0xf865, 0xf4da, 0xf888, 0x025a, 0x0cbb, 0x0d53, 0xff96, 0xeefa, +0xee80, 0x021c, 0x15d6, 0x126a, 0xf9c1, 0xe724, 0xf017, 0x0aa1, 0x18b6, 0x0b4e, +0xf2d7, 0xea91, 0xf957, 0x0cac, 0x1061, 0x03f4, 0xf6ad, 0xf476, 0xfbdf, 0x0489, +0x08b1, 0x06df, 0xffcf, 0xf766, 0xf537, 0xfddf, 0x0ad4, 0x0e15, 0x01da, 0xf205, +0xf0a0, 0x0082, 0x1066, 0x0e41, 0xfc71, 0xef1b, 0xf4ad, 0x05cd, 0x0f32, 0x07ed, +0xf9c8, 0xf401, 0xfa93, 0x04af, 0x088c, 0x04a7, 0xfe15, 0xf9f1, 0xfa64, 0xff1e, +0x0539, 0x078c, 0x02af, 0xfa1a, 0xf69d, 0xfd09, 0x075b, 0x0a3d, 0x01f2, 0xf761, +0xf642, 0xffa7, 0x08f3, 0x0830, 0xff05, 0xf7db, 0xf9bc, 0x0174, 0x068b, 0x04b2, +0xfeff, 0xfb39, 0xfc1a, 000000, 0x0371, 0x03d7, 0x00fe, 0xfd37, 0xfbe0, 0xfe78, +0x02af, 0x044a, 0x0180, 0xfd43, 0xfc00, 0xfed1, 0x02aa, 0x0346, 0x00dd, 0xfde0, +0xfbfe, 0x0114, 0x0987, 0x04bc, 0xf49d, 0xf23a, 0x06ab, 0x162e, 0x0544, 0xe76b, +0xea25, 0x1015, 0x2474, 0x0431, 0xd7d3, 0xe1ec, 0x1923, 0x2df5, 0x01cd, 0xd386, +0xe3d9, 0x1b9d, 0x2c62, 0xfeb8, 0xd31a, 0xe6ba, 0x1dbd, 0x2abb, 0xfbab, 0xd2ed, +0xe9ab, 0x1fa7, 0x28ef, 0xf8b3, 0xd2f5, 0xeca5, 0x2160, 0x26fd, 0xf5d7, 0xd334, +0xefa1, 0x22e5, 0x24ea, 0xf31b, 0xd3a9, 0xf29f, 0x2435, 0x22b6, 0xf07e, 0xd44e, +0xf59b, 0x2551, 0x2067, 0xee08, 0xd527, 0xf88e, 0x2639, 0x1e00, 0xebb6, 0xd62d, +0xfb77, 0x26eb, 0x1b85, 0xe98b, 0xd75f, 0xfe51, 0x276b, 0x18f9, 0xe78e, 0xd8b9, +0x011a, 0x27b6, 0x1660, 0xe5bb, 0xda3a, 0x03cc, 0x27cf, 0x13bd, 0xe415, 0xdbdf, +0x066a, 0x27b7, 0x1117, 0xe29e, 0xdda5, 0x08ec, 0x276e, 0x0e6d, 0xe154, 0xdf89, +0x0b52, 0x26f6, 0x0bc7, 0xe039, 0xe185, 0x0d96, 0x2653, 0x0924, 0xdf4e, 0xe399, +0x0fb9, 0x2584, 0x068b, 0xde93, 0xe5c0, 0x11b8, 0x248e, 0x03fd, 0xde08, 0xe7f8, +0x1390, 0x2372, 0x0180, 0xddaa, 0xea3c, 0x1544, 0x2231, 0xff12, 0xdd7a, 0xec89, +0x16cf, 0x20d0, 0xfcb9, 0xdd77, 0xeedb, 0x1831, 0x1f52, 0xfa77, 0xdd9f, 0xf132, +0x1969, 0x1db7, 0xf850, 0xddf1, 0xf385, 0x1a75, 0x1c06, 0xf645, 0xde6b, 0xf5d7, +0x1b5b, 0x1a3f, 0xf457, 0xdf0d, 0xf820, 0x1c13, 0x1867, 0xf288, 0xdfd2, 0xfa5f, +0x1ca1, 0x167f, 0xf0db, 0xe0ba, 0xfc92, 0x1d06, 0x148b, 0xef50, 0xe1c1, 0xfeb5, +0x1d43, 0x1290, 0xede9, 0xe2e6, 0x00c6, 0x1d58, 0x108e, 0xeca7, 0xe426, 0x02c4, +0x1d45, 0x0e8a, 0xeb8a, 0xe57f, 0x04a9, 0x1d0e, 0x0c87, 0xea92, 0xe6ec, 0x0677, +0x1cb2, 0x0a87, 0xe9be, 0xe86e, 0x082a, 0x1c34, 0x088b, 0xe912, 0xe9fe, 0x09c1, +0x1b95, 0x069c, 0xe88c, 0xeb9c, 0x0b3a, 0x1ad9, 0x04b6, 0xe82a, 0xed43, 0x0c96, +0x1a00, 0x02df, 0xe7eb, 0xeef3, 0x0dd0, 0x190d, 0x0116, 0xe7d0, 0xf0a8, 0x0eec, +0x1804, 0xff61, 0xe7d8, 0xf25d, 0x0fe6, 0x16e3, 0xfdc0, 0xe800, 0xf412, 0x10bf, +0x15b1, 0xfc36, 0xe848, 0xf5c5, 0x1176, 0x146e, 0xfac2, 0xe8ad, 0xf771, 0x120d, +0x1320, 0xf969, 0xe92e, 0xf913, 0x1282, 0x11c4, 0xf828, 0xe9cb, 0xfaac, 0x12d8, +0x1062, 0xf703, 0xea7e, 0xfc38, 0x130e, 0x0efa, 0xf5fb, 0xeb49, 0xfdb5, 0x1325, +0x0d8e, 0xf50e, 0xec26, 0xff20, 0x131e, 0x0c21, 0xf43f, 0xed15, 0x007a, 0x12fa, +0x0ab6, 0xf38d, 0xee15, 0x01be, 0x12bd, 0x094f, 0xf2f9, 0xef22, 0x02ef, 0x1265, +0x07f0, 0xf283, 0xf037, 0x0408, 0x11f6, 0x0699, 0xf226, 0xf156, 0x050a, 0x1170, +0x054b, 0xf1e8, 0xf27a, 0x05f4, 0x10d8, 0x040c, 0xf1c5, 0xf3a3, 0x06c2, 0x102c, +0x02da, 0xf1bc, 0xf4cc, 0x0779, 0x0f71, 0x01b7, 0xf1cc, 0xf5f5, 0x0815, 0x0ea7, +0x00a8, 0xf1f4, 0xf719, 0x0899, 0x0dd2, 0xffab, 0xf233, 0xf839, 0x0902, 0x0cf4, +0xfec0, 0xf288, 0xf950, 0x0952, 0x0c0e, 0xfdec, 0xf2ee, 0xfa5d, 0x0989, 0x0b23, +0xfd2d, 0xf368, 0xfb62, 0x09a7, 0x0a35, 0xfc85, 0xf3f1, 0xfc58, 0x09af, 0x0946, +0xfbf2, 0xf488, 0xfd3f, 0x09a1, 0x0859, 0xfb77, 0xf52c, 0xfe17, 0x097d, 0x076f, +0xfb14, 0xf5d8, 0xfede, 0x0945, 0x068a, 0xfac6, 0xf68d, 0xff93, 0x08fb, 0x05ad, +0xfa8e, 0xf747, 0x0034, 0x08a1, 0x04da, 0xfa6f, 0xf805, 0x00c2, 0x0836, 0x0410, +0xfa63, 0xf8c6, 0x013c, 0x07bf, 0x0354, 0xfa6c, 0xf985, 0x01a1, 0x073b, 0x02a4, +0xfa8a, 0xfa43, 0x01f1, 0x06af, 0x0204, 0xfab9, 0xfafc, 0x022c, 0x0619, 0x0175, +0xfafa, 0xfbae, 0x0252, 0x057f, 0x00f6, 0xfb4b, 0xfc5a, 0x0263, 0x04e0, 0x008b, +0xfbaa, 0xfcfa, 0x0262, 0x0440, 0x0032, 0xfc16, 0xfd90, 0x024b, 0x03a0, 0xffec, +0xfc8c, 0xfe19, 0x0225, 0x0301, 0xffb9, 0xfd0c, 0xfe93, 0x01ea, 0x0267, 0xff9c, +0xfd95, 0xfefe, 0x01a0, 0x01d3, 0xff90, 0xfe22, 0xff5a, 0x0147, 0x0145, 0xff99, +0xfeb3, 0xffa1, 0x00e0, 0x00c3, 0xffb6, 0xff46, 0xffd9, 0x006d, 0x004b, 0xffe5, +0xffda, 0xfffc, 000000, 0xfffe, 000000, 0xffff, 000000, 0xffff, 0xffff, 000000, +000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, +000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, +000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, +000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, +000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, +000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, +000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, +000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, +000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, +000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, +000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, +000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, +000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, +000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, +000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, +000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, +000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, +000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, +000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, +000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, +000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, +000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, +000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, +000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, +000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, +000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, +000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, +000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, +000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, +000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, +000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, +000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, +000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, +000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, +000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, +000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, +000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, +000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, +000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, +000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, +000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, +000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, +000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, +000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, +000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, +000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, +000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, +000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, +000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, +000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, +000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, +000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, +000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, +000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, +000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, +000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, +000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, +000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, +000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, +000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, +000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, +000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, +000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, +000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, +000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, +000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, +000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, +000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, +000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, +000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, +000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, +000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, +000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, +000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, +000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, +000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, +000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, +000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, +000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, 000000, +000000 }; Added: freeswitch/trunk/src/mod/endpoints/mod_iax/frame.h ============================================================================== --- (empty file) +++ freeswitch/trunk/src/mod/endpoints/mod_iax/frame.h Thu May 8 19:25:36 2008 @@ -0,0 +1,134 @@ +/* + * libiax: An implementation of the Inter-Asterisk eXchange protocol + * + * Asterisk internal frame definitions. + * + * Copyright (C) 1999, Mark Spencer + * + * Mark Spencer <markster@linux-support.net> + * + * This program is free software, distributed under the terms of + * the GNU Lesser General Public License. Other components of + * Asterisk are distributed under The GNU General Public License + * only. + */ + +#ifndef _LIBIAX_FRAME_H +#define _LIBIAX_FRAME_H + +#if defined(__cplusplus) || defined(c_plusplus) +extern "C" { +#endif + +/* Frame types */ +#define AST_FRAME_DTMF 1 /* A DTMF digit, subclass is the digit */ +#define AST_FRAME_VOICE 2 /* Voice data, subclass is AST_FORMAT_* */ +#define AST_FRAME_VIDEO 3 /* Video frame, maybe?? :) */ +#define AST_FRAME_CONTROL 4 /* A control frame, subclass is AST_CONTROL_* */ +#define AST_FRAME_NULL 5 /* An empty, useless frame */ +#define AST_FRAME_IAX 6 /* Inter Aterisk Exchange private frame type */ +#define AST_FRAME_TEXT 7 /* Text messages */ +#define AST_FRAME_IMAGE 8 /* Image Frames */ +#define AST_FRAME_HTML 9 /* HTML Frames */ +#define AST_FRAME_CNG 10 /* Comfort Noise frame (subclass is level of CNG in -dBov) */ + +/* HTML subclasses */ +#define AST_HTML_URL 1 /* Sending a URL */ +#define AST_HTML_DATA 2 /* Data frame */ +#define AST_HTML_BEGIN 4 /* Beginning frame */ +#define AST_HTML_END 8 /* End frame */ +#define AST_HTML_LDCOMPLETE 16 /* Load is complete */ +#define AST_HTML_NOSUPPORT 17 /* Peer is unable to support HTML */ +#define AST_HTML_LINKURL 18 /* Send URL and track */ +#define AST_HTML_UNLINK 19 /* Request no more linkage */ +#define AST_HTML_LINKREJECT 20 /* Reject LINKURL */ + +/* Data formats for capabilities and frames alike */ +/*! G.723.1 compression */ +#define AST_FORMAT_G723_1 (1 << 0) + /*! GSM compression */ +#define AST_FORMAT_GSM (1 << 1) + /*! Raw mu-law data (G.711) */ +#define AST_FORMAT_ULAW (1 << 2) + /*! Raw A-law data (G.711) */ +#define AST_FORMAT_ALAW (1 << 3) + /*! ADPCM (G.726, 32kbps) */ +#define AST_FORMAT_G726 (1 << 4) + /*! ADPCM (IMA) */ +#define AST_FORMAT_ADPCM (1 << 5) + /*! Raw 16-bit Signed Linear (8000 Hz) PCM */ +#define AST_FORMAT_SLINEAR (1 << 6) + /*! LPC10, 180 samples/frame */ +#define AST_FORMAT_LPC10 (1 << 7) + /*! G.729A audio */ +#define AST_FORMAT_G729A (1 << 8) + /*! SpeeX Free Compression */ +#define AST_FORMAT_SPEEX (1 << 9) + /*! iLBC Free Compression */ +#define AST_FORMAT_ILBC (1 << 10) + /*! Maximum audio format */ +#define AST_FORMAT_MAX_AUDIO (1 << 15) + /*! JPEG Images */ +#define AST_FORMAT_JPEG (1 << 16) + /*! PNG Images */ +#define AST_FORMAT_PNG (1 << 17) + /*! H.261 Video */ +#define AST_FORMAT_H261 (1 << 18) + /*! H.263 Video */ +#define AST_FORMAT_H263 (1 << 19) + /*! Max one */ +#define AST_FORMAT_MAX_VIDEO (1 << 24) + +/* Control frame types */ +#define AST_CONTROL_HANGUP 1 /* Other end has hungup */ +#define AST_CONTROL_RING 2 /* Local ring */ +#define AST_CONTROL_RINGING 3 /* Remote end is ringing */ +#define AST_CONTROL_ANSWER 4 /* Remote end has answered */ +#define AST_CONTROL_BUSY 5 /* Remote end is busy */ +#define AST_CONTROL_TAKEOFFHOOK 6 /* Make it go off hook */ +#define AST_CONTROL_OFFHOOK 7 /* Line is off hook */ +#define AST_CONTROL_CONGESTION 8 /* Congestion (circuits busy) */ +#define AST_CONTROL_FLASH 9 /* Flash hook */ +#define AST_CONTROL_WINK 10 /* Wink */ +#define AST_CONTROL_OPTION 11 /* Set an option */ + +#define AST_FRIENDLY_OFFSET 64 /* Reserved header space */ + +struct ast_frame { + /*! Kind of frame */ + int frametype; + /*! Subclass, frame dependent */ + int subclass; + /*! Length of data */ + int datalen; + /*! Number of 8khz samples in this frame */ + int samples; + /*! Was the data malloc'd? i.e. should we free it when we discard the f +rame? */ + int mallocd; + /*! How far into "data" the data really starts */ + int offset; + /*! Optional source of frame for debugging */ + char *src; + /*! Pointer to actual data */ + void *data; + /*! Next/Prev for linking stand alone frames */ + struct ast_frame *prev; + /*! Next/Prev for linking stand alone frames */ + struct ast_frame *next; + /* Unused except + if debugging is turned on, but left + in the struct + so that it can be turned on without + requiring a r +ecompile of the whole thing */ +}; + + + +#if defined(__cplusplus) || defined(c_plusplus) +} +#endif + + +#endif Added: freeswitch/trunk/src/mod/endpoints/mod_iax/iax-client.h ============================================================================== --- (empty file) +++ freeswitch/trunk/src/mod/endpoints/mod_iax/iax-client.h Thu May 8 19:25:36 2008 @@ -0,0 +1,244 @@ +/* + * Asterisk -- A telephony toolkit for Linux. + * + * Implementation of Inter-Asterisk eXchange + * + * Copyright (C) 1999, Mark Spencer + * + * Mark Spencer <markster@linux-support.net> + * + * This program is free software, distributed under the terms of + * the GNU Lesser General Public License (LGPL) + */ + +#ifndef _ASTERISK_IAX_CLIENT_H +#define _ASTERISK_IAX_CLIENT_H + +#ifdef WIN32_TIME_GET_TIME +#include <Mmsystem.h> +#endif + +#if defined(_MSC_VER) +/* disable zero-sized array in struct/union warning */ +#pragma warning(disable:4200) +#endif + +#if !defined(LINUX) && !defined(NETBSD) +#define socklen_t int +#endif + +#include "frame.h" +#include "iax2.h" +#include "iax2-parser.h" + +#define MAXSTRLEN 80 + +#define IAX_AUTHMETHOD_PLAINTEXT IAX_AUTH_PLAINTEXT +#define IAX_AUTHMETHOD_MD5 IAX_AUTH_MD5 + +extern char iax_errstr[]; + +struct iax_session; + + +#define IAX_EVENT_CONNECT 0 /* Connect a new call */ +#define IAX_EVENT_ACCEPT 1 /* Accept a call */ +#define IAX_EVENT_HANGUP 2 /* Hang up a call */ +#define IAX_EVENT_REJECT 3 /* Rejected call */ +#define IAX_EVENT_VOICE 4 /* Voice Data */ +#define IAX_EVENT_DTMF 5 /* A DTMF Tone */ +#define IAX_EVENT_TIMEOUT 6 /* Connection timeout... session will be + a pointer to free()'d memory! */ +#define IAX_EVENT_LAGRQ 7 /* Lag request -- Internal use only */ +#define IAX_EVENT_LAGRP 8 /* Lag Measurement. See event.lag */ +#define IAX_EVENT_RINGA 9 /* Announce we/they are ringing */ +#define IAX_EVENT_PING 10 /* Ping -- internal use only */ +#define IAX_EVENT_PONG 11 /* Pong -- internal use only */ +#define IAX_EVENT_BUSY 12 /* Report a line busy */ +#define IAX_EVENT_ANSWER 13 /* Answer the line */ + +#define IAX_EVENT_IMAGE 14 /* Send/Receive an image */ +#define IAX_EVENT_AUTHRQ 15 /* Authentication request */ +#define IAX_EVENT_AUTHRP 16 /* Authentication reply */ + +#define IAX_EVENT_REGREQ 17 /* Registration request */ +#define IAX_EVENT_REGACK 18 /* Registration reply */ +#define IAX_EVENT_URL 19 /* URL received */ +#define IAX_EVENT_LDCOMPLETE 20 /* URL loading complete */ + +#define IAX_EVENT_TRANSFER 21 /* Transfer has taken place */ + +#define IAX_EVENT_DPREQ 22 /* Dialplan request */ +#define IAX_EVENT_DPREP 23 /* Dialplan reply */ +#define IAX_EVENT_DIAL 24 /* Dial on a TBD call */ + +#define IAX_EVENT_QUELCH 25 /* Quelch Audio */ +#define IAX_EVENT_UNQUELCH 26 /* Unquelch Audio */ + +#define IAX_EVENT_UNLINK 27 /* Unlink */ +#define IAX_EVENT_LINKREJECT 28 /* Link Rejection */ +#define IAX_EVENT_TEXT 29 /* Text Frame :-) */ +#define IAX_EVENT_REGREJ 30 /* Registration reply */ +#define IAX_EVENT_LINKURL 31 /* Unlink */ +#define IAX_EVENT_CNG 32 /* Comfort-noise (almost silence) */ +#define IAX_EVENT_POKE 33 + +/* moved from iax.c to support attended transfer */ +#define IAX_EVENT_REREQUEST 999 +#define IAX_EVENT_TXREPLY 1000 +#define IAX_EVENT_TXREJECT 1001 +#define IAX_EVENT_TXACCEPT 1002 +#define IAX_EVENT_TXREADY 1003 + +#define IAX_SCHEDULE_FUZZ 0 /* ms of fuzz to drop */ + +#ifdef WIN32 +#if defined(_MSC_VER) +typedef int (__stdcall *sendto_t)(SOCKET, const char *, int, int, const struct sockaddr *, int); +typedef int (__stdcall *recvfrom_t)(SOCKET, char *, int, int, struct sockaddr *, int *); +#else +typedef int PASCAL (*sendto_t)(SOCKET, const char *, int, int, const struct sockaddr *, int); +typedef int PASCAL (*recvfrom_t)(SOCKET, char *buf, int len, int flags, struct sockaddr *from, int *fromlen); +#endif +#else +typedef int (*sendto_t)(int, const void *, size_t, int, const struct sockaddr *, socklen_t); +typedef int (*recvfrom_t)(int s, void *buf, size_t len, int flags, struct sockaddr *from, socklen_t *fromlen); +#endif + +struct iax_event { + int etype; /* Type of event */ + int subclass; /* Subclass data (event specific) */ + time_in_ms_t ts; /* Timestamp */ + struct iax_session *session; /* Applicable session */ + int datalen; /* Length of raw data */ + struct iax_ies ies; /* IE's for IAX2 frames */ + unsigned char data[]; /* Raw data if applicable */ +}; + +#if defined(__cplusplus) +extern "C" +{ +#endif + +/* All functions return 0 on success and -1 on failure unless otherwise + specified */ + +/* Called to initialize IAX structures and sockets. Returns actual + portnumber (which it will try preferred portno first, but if not + take what it can get */ +extern int iax_init(char *ip, int preferredportno); + +extern int iax_shutdown(void); + +/* Get filedescriptor for IAX to use with select or gtk_input_add */ +extern int iax_get_fd(void); + +/* Find out how many milliseconds until the next scheduled event */ +extern time_in_ms_t iax_time_to_next_event(void); + +/* Generate a new IAX session */ +extern struct iax_session *iax_session_new(void); + +/* Return exactly one iax event (if there is one pending). If blocking is + non-zero, IAX will block until some event is received */ +extern struct iax_event *iax_get_event(int blocking); + + +extern int iax_auth_reply(struct iax_session *session, char *password, + char *challenge, int methods); + +/* Free an event */ +extern void iax_event_free(struct iax_event *event); + +struct sockaddr_in; + +/* Front ends for sending events */ +extern int iax_send_dtmf(struct iax_session *session, char digit); +extern int iax_send_voice(struct iax_session *session, int format, unsigned char *data, int datalen, int samples); +extern int iax_send_cng(struct iax_session *session, int level, unsigned char *data, int datalen); +extern int iax_send_image(struct iax_session *session, int format, unsigned char *data, int datalen); +extern int iax_send_url(struct iax_session *session, char *url, int link); +extern int iax_send_text(struct iax_session *session, char *text); +extern int iax_send_ping(struct iax_session *session); +extern int iax_load_complete(struct iax_session *session); +extern int iax_reject(struct iax_session *session, const char *reason); +int iax_reject_registration(struct iax_session *session, char *reason); +int iax_ack_registration(struct iax_session *session); +int iax_auth_registration(struct iax_session *session); +extern int iax_busy(struct iax_session *session); +extern int iax_congestion(struct iax_session *session); +extern int iax_hangup(struct iax_session *session, char *byemsg); +extern int iax_call(struct iax_session *session, const char *cidnum, const char *cidname, char *ich, char *lang, int wait, int format, int capability); +extern int iax_accept(struct iax_session *session, int format); +extern int iax_answer(struct iax_session *session); +extern int iax_sendurl(struct iax_session *session, char *url); +extern int iax_send_unlink(struct iax_session *session); +extern int iax_send_link_reject(struct iax_session *session); +extern int iax_ring_announce(struct iax_session *session); +extern struct sockaddr_in iax_get_peer_addr(struct iax_session *session); +extern int iax_register(struct iax_session *session, char *hostname, char *peer, char *secret, int refresh); +extern int iax_lag_request(struct iax_session *session); +extern int iax_dial(struct iax_session *session, char *number); /* Dial on a TBD call */ +extern int iax_dialplan_request(struct iax_session *session, char *number); /* Request dialplan status for number */ +extern int iax_quelch(struct iax_session *session); +extern int iax_unquelch(struct iax_session * session); +extern int iax_transfer(struct iax_session *session, char *number); +extern int iax_quelch_moh(struct iax_session *session, int MOH); + +extern void iax_destroy(struct iax_session * session); + +extern void iax_enable_debug(void); +extern void iax_disable_debug(void); + +/* For attended transfer, application create a new session, + * make a call on the new session. + * On answer of the new session, call iax_setup_transfer and wait for + * IAX_EVENT_TXREADY when both sides are completed succefully or + * IAX_EVENT_TXREJECT for either side. + * If there are music on hold the it will be stopped by this library. + */ +extern int iax_setup_transfer(struct iax_session *s0, struct iax_session *s1); + +struct iax_netstat { + time_in_ms_t jitter; + int losspct; + int losscnt; + int packets; + time_in_ms_t delay; + int dropped; + int ooo; +}; +/* fills in rtt, and an iax_netstat structure for each of local/remote directions of call */ +extern int iax_get_netstats(struct iax_session *s, time_in_ms_t *rtt, struct iax_netstat *local, struct iax_netstat *remote); + + +extern void iax_set_private(struct iax_session *s, void *pvt); +extern void *iax_get_private(struct iax_session *s); +extern void iax_set_sendto(struct iax_session *s, sendto_t sendto); + +/* to use application networking instead of internal, set call this instead of iax_init, + * and pass in sendto and recvfrom replacements. blocking reads may not be implemented */ +extern void iax_set_networking(sendto_t st, recvfrom_t rf); + +/* destroy an iax session */ +extern void iax_session_destroy(struct iax_session **session); + +/* Handle externally received frames */ +struct iax_event *iax_net_process(unsigned char *buf, int len, struct sockaddr_in *sin); +extern unsigned int iax_session_get_capability(struct iax_session *s); +extern char iax_pref_codec_add(struct iax_session *session, unsigned int format); +extern void iax_pref_codec_del(struct iax_session *session, unsigned int format); +extern int iax_pref_codec_get(struct iax_session *session, unsigned int *array, int len); + +/* Fine tune jitterbuffer */ +extern void iax_set_jb_target_extra( long value ); + +extern char *iax_get_peer_ip(struct iax_session *session); +extern char *iax_event_get_apparent_ip(struct iax_event *event); +extern void iax_set_samplerate(struct iax_session *session, unsigned short samplemask); + +#if defined(__cplusplus) +} +#endif + +#endif /* _ASTERISK_IAX_CLIENT_H */ Added: freeswitch/trunk/src/mod/endpoints/mod_iax/iax-mutex.c ============================================================================== --- (empty file) +++ freeswitch/trunk/src/mod/endpoints/mod_iax/iax-mutex.c Thu May 8 19:25:36 2008 @@ -0,0 +1,124 @@ +/* + * Simple Mutex abstraction + * Copyright(C) 2007 Michael Jerris + * + * You may opt to use, copy, modify, merge, publish, distribute and/or sell + * copies of the Software, and permit persons to whom the Software is + * furnished to do so. + * + * This work is provided under this license on an "as is" basis, without warranty of any kind, + * either expressed or implied, including, without limitation, warranties that the covered code + * is free of defects, merchantable, fit for a particular purpose or non-infringing. The entire + * risk as to the quality and performance of the covered code is with you. Should any covered + * code prove defective in any respect, you (not the initial developer or any other contributor) + * assume the cost of any necessary servicing, repair or correction. This disclaimer of warranty + * constitutes an essential part of this license. No use of any covered code is authorized hereunder + * except under this disclaimer. + * + */ + +#define _XOPEN_SOURCE 600 +#include <stdlib.h> +#include "iax-mutex.h" + + +#ifdef WIN32 +#define _WIN32_WINNT 0x0400 +#include <windows.h> +struct mutex { + CRITICAL_SECTION mutex; +}; + +#else + +#include <pthread.h> +struct mutex { + pthread_mutex_t mutex; +}; + +#endif + + +mutex_status_t iax_mutex_create(mutex_t **mutex) +{ + mutex_status_t status = MUTEX_FAILURE; +#ifndef WIN32 + pthread_mutexattr_t attr; +#endif + mutex_t *check = NULL; + + check = (mutex_t *)malloc(sizeof(**mutex)); + if (!check) + goto done; +#ifdef WIN32 + InitializeCriticalSection(&check->mutex); +#else + if (pthread_mutexattr_init(&attr)) + goto done; + + if (pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE)) + goto fail; + + if (pthread_mutex_init(&check->mutex, &attr)) + goto fail; + + goto success; + +fail: + pthread_mutexattr_destroy(&attr); + goto done; + +success: +#endif + *mutex = check; + status = MUTEX_SUCCESS; + +done: + return status; +} + +mutex_status_t iax_mutex_destroy(mutex_t *mutex) +{ +#ifdef WIN32 + DeleteCriticalSection(&mutex->mutex); +#else + if (pthread_mutex_destroy(&mutex->mutex)) + return MUTEX_FAILURE; +#endif + free(mutex); + return MUTEX_SUCCESS; +} + +mutex_status_t iax_mutex_lock(mutex_t *mutex) +{ +#ifdef WIN32 + EnterCriticalSection(&mutex->mutex); +#else + if (pthread_mutex_lock(&mutex->mutex)) + return MUTEX_FAILURE; +#endif + return MUTEX_SUCCESS; +} + +mutex_status_t iax_mutex_trylock(mutex_t *mutex) +{ +#ifdef WIN32 + if (!TryEnterCriticalSection(&mutex->mutex)) + return MUTEX_FAILURE; +#else + if (pthread_mutex_trylock(&mutex->mutex)) + return MUTEX_FAILURE; +#endif + return MUTEX_SUCCESS; +} + +mutex_status_t iax_mutex_unlock(mutex_t *mutex) +{ +#ifdef WIN32 + LeaveCriticalSection(&mutex->mutex); +#else + if (pthread_mutex_unlock(&mutex->mutex)) + return MUTEX_FAILURE; +#endif + return MUTEX_SUCCESS; +} Added: freeswitch/trunk/src/mod/endpoints/mod_iax/iax-mutex.h ============================================================================== --- (empty file) +++ freeswitch/trunk/src/mod/endpoints/mod_iax/iax-mutex.h Thu May 8 19:25:36 2008 @@ -0,0 +1,37 @@ +/* + * Simple Mutex abstraction + * Copyright(C) 2007 Michael Jerris + * + * You may opt to use, copy, modify, merge, publish, distribute and/or sell + * copies of the Software, and permit persons to whom the Software is + * furnished to do so. + * + * This work is provided under this license on an "as is" basis, without warranty of any kind, + * either expressed or implied, including, without limitation, warranties that the covered code + * is free of defects, merchantable, fit for a particular purpose or non-infringing. The entire + * risk as to the quality and performance of the covered code is with you. Should any covered + * code prove defective in any respect, you (not the initial developer or any other contributor) + * assume the cost of any necessary servicing, repair or correction. This disclaimer of warranty + * constitutes an essential part of this license. No use of any covered code is authorized hereunder + * except under this disclaimer. + * + */ + + +#ifndef _SIMPLE_ABSTRACT_MUTEX_H +#define _SIMPLE_ABSTRACT_MUTEX_H + +typedef struct mutex mutex_t; + +typedef enum mutex_status { + MUTEX_SUCCESS, + MUTEX_FAILURE +} mutex_status_t; + +mutex_status_t iax_mutex_create(mutex_t **mutex); +mutex_status_t iax_mutex_destroy(mutex_t *mutex); +mutex_status_t iax_mutex_lock(mutex_t *mutex); +mutex_status_t iax_mutex_trylock(mutex_t *mutex); +mutex_status_t iax_mutex_unlock(mutex_t *mutex); + +#endif Added: freeswitch/trunk/src/mod/endpoints/mod_iax/iax.c ============================================================================== --- (empty file) +++ freeswitch/trunk/src/mod/endpoints/mod_iax/iax.c Thu May 8 19:25:36 2008 @@ -0,0 +1,3366 @@ + /* + * libiax: An implementation of Inter-Asterisk eXchange + * + * Copyright (C) 2001, Linux Support Services, Inc. + * + * Mark Spencer <markster@linux-support.net> + * + * This program is free software, distributed under the terms of + * the GNU Lesser (Library) General Public License + */ + +#ifdef WIN32 +#undef __STRICT_ANSI__ //for strdup with ms + +#include <string.h> +#include <process.h> +#include <windows.h> +#include <winsock.h> +#include <time.h> +#include <stdlib.h> +#include <malloc.h> +#include <stdarg.h> +#include <stdio.h> +#include <fcntl.h> +#include <io.h> +#include <errno.h> +#include <limits.h> + + +#define snprintf _snprintf + +#if defined(_MSC_VER) +#define close _close +#define inline __inline +#define strdup _strdup +#endif + +void gettimeofday(struct timeval *tv, void /*struct timezone*/ *tz); +#include "winpoop.h" + +#else + +#define _BSD_SOURCE 1 +#include <netdb.h> +#include <sys/socket.h> +#include <netinet/in.h> +#include <sys/time.h> +#include <stdlib.h> +#include <string.h> +#include <stdarg.h> +#include <stdio.h> +#include <unistd.h> +#include <fcntl.h> +#include <errno.h> +#include <sys/select.h> +#include <netinet/in.h> +#include <arpa/inet.h> +#include <time.h> + +#endif + +#include "iax2.h" +#include "iax-client.h" +#include "md5.h" + +#ifdef NEWJB +#include "jitterbuf.h" +#endif +#include "iax-mutex.h" +/* + work around jitter-buffer shrinking in asterisk: + channels/chan_iax2.c:schedule_delivery() shrinks jitter buffer by 2. + this causes frames timestamped 1ms apart to ( sometimes ) be delivered + out of order, and results in garbled audio. our temporary fix is to increase + the minimum number of ( timestamped ) milliseconds between frames to 3 ( 2 + 1 ). +*/ +#define IAX_MIN_TIMESTAMP_INCREMENT 3 + +/* Define socket options for IAX2 sockets, based on platform + * availability of flags */ +#ifdef WIN32 + #define IAX_SOCKOPTS 0 +#else + #ifdef LINUX + #define IAX_SOCKOPTS MSG_DONTWAIT | MSG_NOSIGNAL + #else + #define IAX_SOCKOPTS MSG_DONTWAIT + #endif +#endif + + + +#ifdef SNOM_HACK +/* The snom phone seems to improperly execute memset in some cases */ +#include "../../snom_phonecore2/include/snom_memset.h" +#endif + +/* Voice TS Prediction causes libiax2 to clean up the timestamps on + * outgoing frames. It works best with either continuous voice, or + * callers who call iax_send_cng to indicate DTX for silence */ +#define USE_VOICE_TS_PREDICTION + +/* Define Voice Smoothing to try to make some judgements and adjust timestamps + on incoming packets to what they "ought to be" */ + +#define VOICE_SMOOTHING +#undef VOICE_SMOOTHING + +/* Define Drop Whole Frames to make IAX shrink its jitter buffer by dropping entire + frames rather than simply delivering them faster. Dropping encoded frames, + before they're decoded, usually leads to better results than dropping + decoded frames. */ + +#define DROP_WHOLE_FRAMES + +#define MIN_RETRY_TIME 10 +#define MAX_RETRY_TIME 4000 +#define MEMORY_SIZE 1000 + +#define TRANSFER_NONE 0 +#define TRANSFER_BEGIN 1 +#define TRANSFER_READY 2 +#define TRANSFER_REL 3 + +#ifndef NEWJB +/* No more than 4 seconds of jitter buffer */ +static int max_jitterbuffer = 4000; +/* No more than 50 extra milliseconds of jitterbuffer than needed */ +static int max_extra_jitterbuffer = 50; +/* To use or not to use the jitterbuffer */ +static int iax_use_jitterbuffer = 1; + +/* Dropcount (in per-MEMORY_SIZE) usually percent */ +static int iax_dropcount = 3; +#endif + +/* UDP Socket (file descriptor) */ +static int netfd = -1; + +/* Max timeouts */ +static int maxretries = 10; + +/* configurable jitterbuffer options */ +static long jb_target_extra = -1; + +static int do_shutdown = 0; + +/* external global networking replacements */ +static sendto_t iax_sendto = (sendto_t) sendto; +static recvfrom_t iax_recvfrom = (recvfrom_t) recvfrom; + +/* ping interval (seconds) */ +static int ping_time = 10; +static void send_ping(void *session); + +struct iax_session { + /* Private data */ + void *pvt; + /* session-local Sendto function */ + sendto_t sendto; + /* Is voice quelched (e.g. hold) */ + int quelch; + /* Codec Pref Order */ + char codec_order[32]; + /* Codec Pref Order Index*/ + int codec_order_len; + /* Last received voice format */ + int voiceformat; + /* Last transmitted voice format */ + int svoiceformat; + /* Per session capability */ + int capability; + /* Last received timestamp */ + time_in_ms_t last_ts; + /* Last transmitted timestamp */ + time_in_ms_t lastsent; + /* Last transmitted voice timestamp */ + unsigned int lastvoicets; + /* Next predicted voice ts */ + time_in_ms_t nextpred; + /* True if the last voice we transmitted was not silence/CNG */ + int notsilenttx; + /* Our last measured ping time */ + time_in_ms_t pingtime; + /* Address of peer */ + struct sockaddr_in peeraddr; + /* Our call number */ + int callno; + /* Peer's call number */ + int peercallno; + /* Our next outgoing sequence number */ + unsigned char oseqno; + /* Next sequence number they have not yet acknowledged */ + unsigned char rseqno; + /* Our last received incoming sequence number */ + unsigned char iseqno; + /* Last acknowledged sequence number */ + unsigned char aseqno; + /* Peer supported formats */ + int peerformats; + /* Time value that we base our transmission on */ + time_in_ms_t offset; + /* Time value we base our delivery on */ + time_in_ms_t rxcore; + /* History of lags */ + int history[MEMORY_SIZE]; + /* Current base jitterbuffer */ + int jitterbuffer; + /* Informational jitter */ + int jitter; + /* Measured lag */ + int lag; + /* Current link state */ + int state; + /* Peer name */ + char peer[MAXSTRLEN]; + /* Default Context */ + char context[MAXSTRLEN]; + /* Caller ID if available */ + char callerid[MAXSTRLEN]; + /* DNID */ + char dnid[MAXSTRLEN]; + /* Requested Extension */ + char exten[MAXSTRLEN]; + /* Expected Username */ + char username[MAXSTRLEN]; + /* Expected Secret */ + char secret[MAXSTRLEN]; + /* permitted authentication methods */ + char methods[MAXSTRLEN]; + /* MD5 challenge */ + char challenge[12]; +#ifdef VOICE_SMOOTHING + unsigned int lastts; +#endif + /* Refresh if applicable */ + int refresh; + + /* ping scheduler id */ + int pingid; + + /* Transfer stuff */ + struct sockaddr_in transfer; + int transferring; + int transfercallno; + int transferid; + int transferpeer; /* for attended transfer */ + int transfer_moh; /* for music on hold while performing attended transfer */ + +#ifdef NEWJB + jitterbuf *jb; +#endif + struct iax_netstat remote_netstats; + + unsigned short samplemask; + /* For linking if there are multiple connections */ + struct iax_session *next; +}; + +char iax_errstr[256]; + +static void destroy_session(struct iax_session *session); + +#define IAXERROR snprintf(iax_errstr, sizeof(iax_errstr), + +#ifdef DEBUG_SUPPORT + +#ifdef DEBUG_DEFAULT +static int debug = 1; +#else +static int debug = 0; +#endif + +void iax_enable_debug(void) +{ + debug = 1; +} + +void iax_disable_debug(void) +{ + debug = 0; +} + +/* This is a little strange, but to debug you call DEBU(G "Hello World!\n"); */ +#ifdef WIN32 +#define G __FILE__, __LINE__, __FUNCTION__, +#else +#define G __FILE__, __LINE__, (const char *)__func__, +#endif + +#define DEBU __debug +static int __debug(char *file, int lineno, const char *func, char *fmt, ...) +{ + va_list args; + va_start(args, fmt); + if (debug) { + fprintf(stderr, "%s line %d in %s: ", file, lineno, func); + vfprintf(stderr, fmt, args); + } + va_end(args); + return 0; +} + +#else /* No debug support */ + +#ifdef WIN32 +#define DEBU +#else +#define DEBU(...) (void)(0) +#endif +#define G +#endif + +typedef void (*sched_func)(void *); + +struct iax_sched { + /* These are scheduled things to be delivered */ + time_in_ms_t when; + /* If event is non-NULL then we're delivering an event */ + struct iax_event *event; + /* If frame is non-NULL then we're transmitting a frame */ + struct iax_frame *frame; + /* If func is non-NULL then we should call it */ + sched_func func; + /* and pass it this argument */ + void *arg; + /* Easy linking */ + struct iax_sched *next; +}; + +static mutex_t *sched_mutex = NULL; +static mutex_t *session_mutex = NULL; +static struct iax_sched *schedq = NULL; +static struct iax_session *sessions = NULL; +static int callnums = 1; +static int transfer_id = 1; /* for attended transfer */ +static int time_init = 0; + +static void init_time(void) +{ +#ifdef WIN32_TIME_GET_TIME + timeBeginPeriod(1); +#endif + time_init = 1; +} + +static void time_end(void) +{ +#ifdef WIN32_TIME_GET_TIME + timeEndPeriod(1); +#endif + time_init = 0; +} + +static time_in_ms_t current_time_in_ms(void) +{ +#ifdef WIN32_TIME_GET_TIME + return timeGetTime(); +#else + struct timeval tv; + gettimeofday(&tv, NULL); + return ((tv.tv_sec * 1000) + (tv.tv_usec / 1000)); +#endif +} + +void iax_set_private(struct iax_session *s, void *ptr) +{ + s->pvt = ptr; +} + +void *iax_get_private(struct iax_session *s) +{ + return s->pvt; +} + +void iax_set_sendto(struct iax_session *s, sendto_t ptr) +{ + s->sendto = ptr; +} + + +unsigned int iax_session_get_capability(struct iax_session *s) +{ + return s->capability; +} + + +static int inaddrcmp(struct sockaddr_in *sin1, struct sockaddr_in *sin2) +{ + return (sin1->sin_addr.s_addr != sin2->sin_addr.s_addr) || (sin1->sin_port != sin2->sin_port); +} + +static int iax_sched_add(struct iax_event *event, struct iax_frame *frame, sched_func func, void *arg, time_in_ms_t ms) +{ + + /* Schedule event to be delivered to the client + in ms milliseconds from now, or a reliable frame to be retransmitted */ + struct iax_sched *sched, *cur, *prev = NULL; + + if (!event && !frame && !func) { + DEBU(G "No event, no frame, no func? what are we scheduling?\n"); + return -1; + } + + + sched = (struct iax_sched*)malloc(sizeof(struct iax_sched)); + if (sched) { + memset(sched, 0, sizeof(struct iax_sched)); + sched->when = current_time_in_ms() + ms; + sched->event = event; + sched->frame = frame; + sched->func = func; + sched->arg = arg; + /* Put it in the list, in order */ + iax_mutex_lock(sched_mutex); + cur = schedq; + while(cur && cur->when <= sched->when) { + prev = cur; + cur = cur->next; + } + sched->next = cur; + if (prev) { + prev->next = sched; + } else { + schedq = sched; + } + iax_mutex_unlock(sched_mutex); + return 0; + } else { + DEBU(G "Out of memory!\n"); + return -1; + } +} + +static int iax_sched_del(struct iax_event *event, struct iax_frame *frame, sched_func func, void *arg, int all) +{ + struct iax_sched *cur, *tmp, *prev = NULL; + int ret = 0; + + iax_mutex_lock(sched_mutex); + cur = schedq; + while (cur) { + if (cur->event == event && cur->frame == frame && cur->func == func && cur->arg == arg) { + if (prev) + prev->next = cur->next; + else + schedq = cur->next; + tmp = cur; + cur = cur->next; + free(tmp); + if (!all) { + ret = -1; + goto done; + } + } else { + prev = cur; + cur = cur->next; + } + } + done: + iax_mutex_unlock(sched_mutex); + + return 0; + +} + + +time_in_ms_t iax_time_to_next_event(void) +{ + struct iax_sched *cur = NULL; + time_in_ms_t minimum = 999999999; + + iax_mutex_lock(sched_mutex); + cur = schedq; + + /* If there are no pending events, we don't need to timeout */ + if (!cur) { + iax_mutex_unlock(sched_mutex); + return -1; + } + while(cur) { + if (cur->when < minimum) { + minimum = cur->when; + } + cur = cur->next; + } + iax_mutex_unlock(sched_mutex); + + if (minimum <= 0) { + return -1; + } + + + + return minimum - current_time_in_ms(); +} + +struct iax_session *iax_session_new(void) +{ + struct iax_session *s; + s = (struct iax_session *)malloc(sizeof(struct iax_session)); + if (s) { + memset(s, 0, sizeof(struct iax_session)); + /* Initialize important fields */ + s->voiceformat = -1; + s->svoiceformat = -1; + /* Default pingtime to 30 ms */ + s->pingtime = 30; + /* XXX Not quite right -- make sure it's not in use, but that won't matter + unless you've had at least 65k calls. XXX */ + s->callno = callnums++; + if (callnums > 32767) + callnums = 1; + s->peercallno = 0; + s->transferpeer = 0; /* for attended transfer */ + + s->sendto = iax_sendto; + s->pingid = -1; +#ifdef NEWJB + s->jb = jb_new(); + { + jb_conf jbconf; + jbconf.max_jitterbuf = 0; + jbconf.resync_threshold = 1000; + jbconf.max_contig_interp = 0; + jbconf.target_extra = jb_target_extra; + jb_setconf(s->jb, &jbconf); + } +#endif + iax_mutex_lock(session_mutex); + s->next = sessions; + sessions = s; + iax_mutex_unlock(session_mutex); + } + return s; +} + +static int iax_session_valid(struct iax_session *session) +{ + /* Return -1 on a valid iax session pointer, 0 on a failure */ + struct iax_session *cur; + + iax_mutex_lock(session_mutex); + cur = sessions; + while(cur) { + if (session == cur) { + iax_mutex_unlock(session_mutex); + return -1; + } + cur = cur->next; + } + iax_mutex_unlock(session_mutex); + + return 0; +} + +int iax_get_netstats(struct iax_session *session, time_in_ms_t *rtt, struct iax_netstat *local, struct iax_netstat *remote) { + + if(!iax_session_valid(session)) return -1; + + *rtt = session->pingtime; + + *remote = session->remote_netstats; + +#ifdef NEWJB + { + jb_info stats; + jb_getinfo(session->jb, &stats); + + local->jitter = stats.jitter; + /* XXX: should be short-term loss pct.. */ + if(stats.frames_in == 0) stats.frames_in = 1; + local->losspct = stats.losspct/1000; + local->losscnt = stats.frames_lost; + local->packets = stats.frames_in; + local->delay = stats.current - stats.min; + local->dropped = stats.frames_dropped; + local->ooo = stats.frames_ooo; + } +#endif + return 0; +} + +static time_in_ms_t calc_timestamp(struct iax_session *session, time_in_ms_t ts, struct ast_frame *f) +{ + time_in_ms_t ms; + time_in_ms_t time_in_ms; + int voice = 0; + int genuine = 0; + + if (f && f->frametype == AST_FRAME_VOICE) { + voice = 1; + } else if (!f || f->frametype == AST_FRAME_IAX) { + genuine = 1; + } + + /* If this is the first packet we're sending, get our + offset now. */ + if (!session->offset) { + session->offset = current_time_in_ms(); + } + /* If the timestamp is specified, just use their specified + timestamp no matter what. Usually this is done for + special cases. */ + if (ts) { + return ts; + } + /* Otherwise calculate the timestamp from the current time */ + time_in_ms = current_time_in_ms(); + + + /* Calculate the number of milliseconds since we sent the first packet */ + ms = time_in_ms - session->offset; + + if (ms < 0) { + ms = 0; + } + + if(voice) { +#ifdef USE_VOICE_TS_PREDICTION + + /* If we haven't most recently sent silence, and we're + * close in time, use predicted time */ + if(session->notsilenttx && iax_abs(ms - session->nextpred) <= 240) { + /* Adjust our txcore, keeping voice and non-voice + * synchronized */ + session->offset += (int)(ms - session->nextpred)/10; + + if(!session->nextpred) { + session->nextpred = ms; + } + ms = session->nextpred; + } else { + /* in this case, just use the actual time, since + * we're either way off (shouldn't happen), or we're + * ending a silent period -- and seed the next predicted + * time. Also, round ms to the next multiple of + * frame size (so our silent periods are multiples + * of frame size too) */ + time_in_ms_t diff = ms % (f->samples / 8); + if(diff) + ms += f->samples/8 - diff; + session->nextpred = ms; + } +#else + if(ms <= session->lastsent) + ms = session->lastsent + 3; +#endif + session->notsilenttx = 1; + } else { + /* On a dataframe, use last value + 3 (to accomodate jitter buffer shrinking) + if appropriate unless it's a genuine frame */ + if (genuine) { + if (ms <= session->lastsent) + ms = session->lastsent + 3; + } else if (iax_abs(ms - session->lastsent) <= 240) { + ms = session->lastsent + 3; + } + + } + + /* Record the last sent packet for future reference */ + /* unless an AST_FRAME_IAX */ + if (!genuine) + session->lastsent = ms; + +#ifdef USE_VOICE_TS_PREDICTION + /* set next predicted ts based on 8khz samples */ + if(voice) + session->nextpred = session->nextpred + f->samples / 8; +#endif + + return ms; +} + +#ifdef NEWJB +static unsigned char get_n_bits_at(unsigned char *data, int n, int bit) +{ + int byte = bit / 8; /* byte containing first bit */ + int rem = 8 - (bit % 8); /* remaining bits in first byte */ + unsigned char ret = 0; + + if (n <= 0 || n > 8) + return 0; + + if (rem < n) { + ret = (data[byte] << (n - rem)); + ret |= (data[byte + 1] >> (8 - n + rem)); + } else { + ret = (data[byte] >> (rem - n)); + } + + return (ret & (0xff >> (8 - n))); +} + +static int speex_get_wb_sz_at(unsigned char *data, int len, int bit) +{ + static int SpeexWBSubModeSz[] = { + 0, 36, 112, 192, + 352, 0, 0, 0 }; + int off = bit; + unsigned char c; + + /* skip up to two wideband frames */ + if (((len * 8 - off) >= 5) && + get_n_bits_at(data, 1, off)) { + c = get_n_bits_at(data, 3, off + 1); + off += SpeexWBSubModeSz[c]; + + if (((len * 8 - off) >= 5) && + get_n_bits_at(data, 1, off)) { + c = get_n_bits_at(data, 3, off + 1); + off += SpeexWBSubModeSz[c]; + + if (((len * 8 - off) >= 5) && + get_n_bits_at(data, 1, off)) { + /* too many in a row */ + DEBU(G "\tCORRUPT too many wideband streams in a row\n"); + return -1; + } + } + + } + return off - bit; +} + +static int speex_get_samples(unsigned char *data, int len) +{ + static int SpeexSubModeSz[] = { + 0, 43, 119, 160, + 220, 300, 364, 492, + 79, 0, 0, 0, + 0, 0, 0, 0 }; + static int SpeexInBandSz[] = { + 1, 1, 4, 4, + 4, 4, 4, 4, + 8, 8, 16, 16, + 32, 32, 64, 64 }; + int bit = 0; + int cnt = 0; + int off = 0; + unsigned char c; + + DEBU(G "speex_get_samples(%d)\n", len); + while ((len * 8 - bit) >= 5) { + /* skip wideband frames */ + off = speex_get_wb_sz_at(data, len, bit); + if (off < 0) { + DEBU(G "\tERROR reading wideband frames\n"); + break; + } + bit += off; + + if ((len * 8 - bit) < 5) { + DEBU(G "\tERROR not enough bits left after wb\n"); + break; + } + + /* get control bits */ + c = get_n_bits_at(data, 5, bit); + DEBU(G "\tCONTROL: %d at %d\n", c, bit); + bit += 5; + + if (c == 15) { + DEBU(G "\tTERMINATOR\n"); + break; + } else if (c == 14) { + /* in-band signal; next 4 bits contain signal id */ + c = get_n_bits_at(data, 4, bit); + bit += 4; + DEBU(G "\tIN-BAND %d bits\n", SpeexInBandSz[c]); + bit += SpeexInBandSz[c]; + } else if (c == 13) { + /* user in-band; next 5 bits contain msg len */ + c = get_n_bits_at(data, 5, bit); + bit += 5; + DEBU(G "\tUSER-BAND %d bytes\n", c); + bit += c * 8; + } else if (c > 8) { + DEBU(G "\tUNKNOWN sub-mode %d\n", c); + break; + } else { + /* skip number bits for submode (less the 5 control bits) */ + DEBU(G "\tSUBMODE %d %d bits\n", c, SpeexSubModeSz[c]); + bit += SpeexSubModeSz[c] - 5; + + cnt += 160; /* new frame */ + } + } + DEBU(G "\tSAMPLES: %d\n", cnt); + return cnt; +} + +static inline int get_interp_len(int format) +{ + return (format == AST_FORMAT_ILBC) ? 30 : 20; +} + +static int get_sample_cnt(struct iax_event *e) +{ + int cnt = 0; + + /* + * In the case of zero length frames, do not return a cnt of 0 + */ + if ( e->datalen == 0 ) { + return get_interp_len( e->subclass ) * 8; + } + + switch (e->subclass) { + case AST_FORMAT_SPEEX: + cnt = speex_get_samples(e->data, e->datalen); + break; + case AST_FORMAT_G723_1: + cnt = 240; /* FIXME Not always the case */ + break; + case AST_FORMAT_ILBC: + cnt = 240 * (e->datalen / 50); + break; + case AST_FORMAT_GSM: + cnt = 160 * (e->datalen / 33); + break; + case AST_FORMAT_G729A: + cnt = 160 * (e->datalen / 20); + break; + case AST_FORMAT_SLINEAR: + cnt = e->datalen / 2; + break; + case AST_FORMAT_LPC10: + cnt = 22 * 8 + (((char *)(e->data))[7] & 0x1) * 8; + break; + case AST_FORMAT_ULAW: + case AST_FORMAT_ALAW: + cnt = e->datalen; + break; + case AST_FORMAT_ADPCM: + case AST_FORMAT_G726: + cnt = e->datalen * 2; + break; + default: + return 0; + } + return cnt; +} +#endif + +static int iax_xmit_frame(struct iax_frame *f) +{ + /* Send the frame raw */ +#ifdef DEBUG_SUPPORT + struct ast_iax2_full_hdr *h = (f->data); + if (ntohs(h->scallno) & IAX_FLAG_FULL) + iax_showframe(f, NULL, 0, f->transfer ? + &(f->session->transfer) : + &(f->session->peeraddr), f->datalen - sizeof(struct ast_iax2_full_hdr)); +#endif + + return f->session->sendto(netfd, (const char *) f->data, f->datalen, + IAX_SOCKOPTS, + f->transfer ? + (struct sockaddr *)&(f->session->transfer) : + (struct sockaddr *)&(f->session->peeraddr), sizeof(f->session->peeraddr)); +} + +static int iax_reliable_xmit(struct iax_frame *f) +{ + struct iax_frame *fc; + struct ast_iax2_full_hdr *fh; + fh = (struct ast_iax2_full_hdr *) f->data; + if (!fh->type) { + DEBU(G "Asked to reliably transmit a non-packet. Crashing.\n"); + *((char *)0)=0; + } + fc = (struct iax_frame *)malloc(sizeof(struct iax_frame)); + if (fc) { + /* Make a copy of the frame */ + memcpy(fc, f, sizeof(struct iax_frame)); + /* And a copy of the data if applicable */ + if (!fc->data || !fc->datalen) { + IAXERROR "No frame data?"); + DEBU(G "No frame data?\n"); + return -1; + } else { + fc->data = (char *)malloc(fc->datalen); + if (!fc->data) { + DEBU(G "Out of memory\n"); + IAXERROR "Out of memory\n"); + return -1; + } + memcpy(fc->data, f->data, f->datalen); + iax_sched_add(NULL, fc, NULL, NULL, fc->retrytime); + return iax_xmit_frame(fc); + } + } else + return -1; +} + +void iax_set_networking(sendto_t st, recvfrom_t rf) +{ + + init_time(); + iax_sendto = st; + iax_recvfrom = rf; +} + +int __iax_shutdown(void) +{ + struct iax_sched *sp, *fp; + + /* Hangup Calls */ + if (sessions) { + struct iax_session *sp = NULL, *fp = NULL; + iax_mutex_lock(session_mutex); + for(sp = sessions; sp ;) { + iax_hangup(sp, "System Shutdown"); + fp = sp; + sp = sp->next; + destroy_session(fp); + } + iax_mutex_unlock(session_mutex); + } + + /* Clear Scheduler */ + iax_mutex_lock(sched_mutex); + for(sp = schedq; sp ;) { + fp = sp; + sp = sp->next; + free(fp); + } + iax_mutex_unlock(sched_mutex); + + if (netfd > -1) { + shutdown(netfd, 2); + close(netfd); + } + + time_end(); + + iax_mutex_destroy(sched_mutex); + iax_mutex_destroy(session_mutex); + + return 0; +} + +int iax_shutdown(void) +{ + return do_shutdown++; +} + +void iax_set_jb_target_extra( long value ) +{ + /* store in jb_target_extra, a static global */ + jb_target_extra = value ; +} + +int iax_init(char *ip, int preferredportno) +{ + int portno = preferredportno; + struct sockaddr_in sin; + unsigned int sinlen; + int flags; + + init_time(); + + iax_mutex_create(&sched_mutex); + iax_mutex_create(&session_mutex); + + if(iax_recvfrom == (recvfrom_t) recvfrom) { + if (netfd > -1) { + /* Sokay, just don't do anything */ + DEBU(G "Already initialized."); + return 0; + } + netfd = (int)socket(AF_INET, SOCK_DGRAM, IPPROTO_IP); + if (netfd < 0) { + DEBU(G "Unable to allocate UDP socket\n"); + IAXERROR "Unable to allocate UDP socket\n"); + return -1; + } + + if (preferredportno == 0) preferredportno = IAX_DEFAULT_PORTNO; + if (preferredportno < 0) preferredportno = 0; + + sin.sin_family = AF_INET; + sin.sin_addr.s_addr = 0; + sin.sin_port = htons((short)preferredportno); + if (bind(netfd, (struct sockaddr *) &sin, sizeof(sin)) < 0) + { +#if defined(WIN32) || defined(_WIN32_WCE) + if (WSAGetLastError() == WSAEADDRINUSE) +#else + if (errno == EADDRINUSE) +#endif + { + /*the port is already in use, so bind to a free port chosen by the IP stack*/ + DEBU(G "Unable to bind to preferred port - port is in use. Trying to bind to a free one"); + sin.sin_port = htons((short)0); + if (bind(netfd, (struct sockaddr *) &sin, sizeof(sin)) < 0) + { + IAXERROR "Unable to bind UDP socket\n"); + return -1; + } + } else + { + IAXERROR "Unable to bind UDP socket\n"); + return -1; + } + } + sinlen = sizeof(sin); + if (getsockname(netfd, (struct sockaddr *) &sin, &sinlen) < 0) { + close(netfd); + netfd = -1; + DEBU(G "Unable to figure out what I'm bound to."); + IAXERROR "Unable to determine bound port number."); + } +#ifdef WIN32 + flags = 1; + if (ioctlsocket(netfd,FIONBIO,(unsigned long *) &flags)) { + closesocket(netfd); + netfd = -1; + DEBU(G "Unable to set non-blocking mode."); + IAXERROR "Unable to set non-blocking mode."); + } + +#else + if ((flags = fcntl(netfd, F_GETFL)) < 0) { + close(netfd); + netfd = -1; + DEBU(G "Unable to retrieve socket flags."); + IAXERROR "Unable to retrieve socket flags."); + } + if (fcntl(netfd, F_SETFL, flags | O_NONBLOCK) < 0) { + close(netfd); + netfd = -1; + DEBU(G "Unable to set non-blocking mode."); + IAXERROR "Unable to set non-blocking mode."); + } +#endif + portno = ntohs(sin.sin_port); + } + srand((unsigned int)time(NULL)); + callnums = rand() % 32767 + 1; + transfer_id = rand() % 32767 + 1; + DEBU(G "Started on port %d\n", portno); + return portno; +} + + + +static void convert_reply(char *out, unsigned char *in) +{ + int x; + for (x=0;x<16;x++) + out += sprintf(out, "%2.2x", (int)in[x]); +} + +static unsigned char compress_subclass(int subclass) +{ + int x; + int power=-1; + /* If it's 128 or smaller, just return it */ + if (subclass < IAX_FLAG_SC_LOG) + return subclass; + /* Otherwise find its power */ + for (x = 0; x < IAX_MAX_SHIFT; x++) { + if (subclass & (1 << x)) { + if (power > -1) { + DEBU(G "Can't compress subclass %d\n", subclass); + return 0; + } else + power = x; + } + } + return power | IAX_FLAG_SC_LOG; +} + +static int iax_send(struct iax_session *pvt, struct ast_frame *f, time_in_ms_t ts, int seqno, int now, int transfer, int final) +{ + /* Queue a packet for delivery on a given private structure. Use "ts" for + timestamp, or calculate if ts is 0. Send immediately without retransmission + or delayed, with retransmission */ + struct ast_iax2_full_hdr *fh; + struct ast_iax2_mini_hdr *mh; + unsigned char buf[5120]; + struct iax_frame *fr; + int res; + int sendmini=0; + time_in_ms_t lastsent; + time_in_ms_t fts; + + if (!pvt) { + IAXERROR "No private structure for packet?\n"); + return -1; + } + + /* this must come before the next call to calc_timestamp() since + calc_timestamp() will change lastsent to the returned value */ + lastsent = pvt->lastsent; + + /* Calculate actual timestamp */ + fts = calc_timestamp(pvt, ts, f); + + if (((fts & 0xFFFF0000L) == (lastsent & 0xFFFF0000L)) + /* High two bits are the same on timestamp, or sending on a trunk */ && + (f->frametype == AST_FRAME_VOICE) + /* is a voice frame */ && + (f->subclass == pvt->svoiceformat) + /* is the same type */ ) { + /* Force immediate rather than delayed transmission */ + now = 1; + /* Mark that mini-style frame is appropriate */ + sendmini = 1; + } + /* Allocate an iax_frame */ + if (now) { + fr = (struct iax_frame *) buf; + } else + fr = iax_frame_new(DIRECTION_OUTGRESS, f->datalen); + if (!fr) { + IAXERROR "Out of memory\n"); + return -1; + } + /* Copy our prospective frame into our immediate or retransmitted wrapper */ + iax_frame_wrap(fr, f); + + fr->ts = fts; + if (!fr->ts) { + IAXERROR "timestamp is 0?\n"); + if (!now) + iax_frame_free(fr); + return -1; + } + + fr->callno = pvt->callno; + fr->transfer = transfer; + fr->final = final; + fr->session = pvt; + if (!sendmini) { + /* We need a full frame */ + if (seqno > -1) + fr->oseqno = seqno; + else + fr->oseqno = pvt->oseqno++; + fr->iseqno = pvt->iseqno; + fh = (struct ast_iax2_full_hdr *)(((char *)fr->af.data) - sizeof(struct ast_iax2_full_hdr)); + fh->scallno = htons(fr->callno | IAX_FLAG_FULL); + fh->ts = htonl((long)(fr->ts)); + fh->oseqno = fr->oseqno; + if (transfer) { + fh->iseqno = 0; + } else + fh->iseqno = fr->iseqno; + /* Keep track of the last thing we've acknowledged */ + pvt->aseqno = fr->iseqno; + fh->type = fr->af.frametype & 0xFF; + fh->csub = compress_subclass(fr->af.subclass); + if (transfer) { + fr->dcallno = pvt->transfercallno; + } else + fr->dcallno = pvt->peercallno; + fh->dcallno = htons(fr->dcallno); + fr->datalen = fr->af.datalen + sizeof(struct ast_iax2_full_hdr); + fr->data = fh; + fr->retries = maxretries; + /* Retry after 2x the ping time has passed */ + fr->retrytime = pvt->pingtime * 2; + if (fr->retrytime < MIN_RETRY_TIME) + fr->retrytime = MIN_RETRY_TIME; + if (fr->retrytime > MAX_RETRY_TIME) + fr->retrytime = MAX_RETRY_TIME; + /* Acks' don't get retried */ + if ((f->frametype == AST_FRAME_IAX) && (f->subclass == IAX_COMMAND_ACK)) + fr->retries = -1; + if (f->frametype == AST_FRAME_VOICE) { + pvt->svoiceformat = f->subclass; + } + if (now) { + res = iax_xmit_frame(fr); + } else + res = iax_reliable_xmit(fr); + } else { + /* Mini-frames have no sequence number */ + fr->oseqno = -1; + fr->iseqno = -1; + /* Mini frame will do */ + mh = (struct ast_iax2_mini_hdr *)(((char *)fr->af.data) - sizeof(struct ast_iax2_mini_hdr)); + mh->callno = htons(fr->callno); + mh->ts = htons((short)(fr->ts & 0xFFFF)); + fr->datalen = fr->af.datalen + sizeof(struct ast_iax2_mini_hdr); + fr->data = mh; + fr->retries = -1; + res = iax_xmit_frame(fr); + } + if( !now && fr!=NULL ) + iax_frame_free( fr ); + return res; +} + +#if 0 +static int iax_predestroy(struct iax_session *pvt) +{ + if (!pvt) { + return -1; + } + if (!pvt->alreadygone) { + /* No more pings or lagrq's */ + if (pvt->pingid > -1) + ast_sched_del(sched, pvt->pingid); + if (pvt->lagid > -1) + ast_sched_del(sched, pvt->lagid); + if (pvt->autoid > -1) + ast_sched_del(sched, pvt->autoid); + if (pvt->initid > -1) + ast_sched_del(sched, pvt->initid); + pvt->pingid = -1; + pvt->lagid = -1; + pvt->autoid = -1; + pvt->initid = -1; + pvt->alreadygone = 1; + } + return 0; +} +#endif + +static int __send_command(struct iax_session *i, char type, int command, time_in_ms_t ts, unsigned char *data, int datalen, int seqno, + int now, int transfer, int final, int samples) +{ + struct ast_frame f; + f.frametype = type; + f.subclass = command; + f.datalen = datalen; + f.samples = samples; + f.mallocd = 0; + f.offset = 0; +#ifdef __GNUC__ + f.src = (char *) __FUNCTION__; +#else + f.src = (char *) __FILE__; +#endif + f.data = data; + return iax_send(i, &f, ts, seqno, now, transfer, final); +} + +static int send_command(struct iax_session *i, char type, int command, time_in_ms_t ts, unsigned char *data, int datalen, int seqno) +{ + return __send_command(i, type, command, ts, data, datalen, seqno, 0, 0, 0, 0); +} + +static int send_command_final(struct iax_session *i, char type, int command, unsigned int ts, unsigned char *data, int datalen, int seqno) +{ +#if 0 + /* It is assumed that the callno has already been locked */ + iax_predestroy(i); +#endif + int r; + r = __send_command(i, type, command, ts, data, datalen, seqno, 0, 0, 1, 0); + if (r >= 0) { + iax_mutex_lock(session_mutex); + destroy_session(i); + iax_mutex_unlock(session_mutex); + } + return r; +} + +static int send_command_immediate(struct iax_session *i, char type, int command, unsigned int ts, unsigned char *data, int datalen, int seqno) +{ + return __send_command(i, type, command, ts, data, datalen, seqno, 1, 0, 0, 0); +} + +static int send_command_transfer(struct iax_session *i, char type, int command, unsigned int ts, unsigned char *data, int datalen) +{ + return __send_command(i, type, command, ts, data, datalen, 0, 0, 1, 0, 0); +} + +static int send_command_samples(struct iax_session *i, char type, int command, unsigned int ts, unsigned char *data, int datalen, int seqno, int samples) +{ + return __send_command(i, type, command, ts, data, datalen, seqno, 0, 0, 0, samples); +} + + +int iax_transfer(struct iax_session *session, char *number) +{ + static int res; //Return Code + struct iax_ie_data ied; //IE Data Structure (Stuff To Send) + + // Clear The Memory Used For IE Buffer + memset(&ied, 0, sizeof(ied)); + + // Copy The Transfer Destination Into The IE Structure + iax_ie_append_str(&ied, IAX_IE_CALLED_NUMBER, (unsigned char *) number); + + // Send The Transfer Command - Asterisk Will Handle The Rest! + res = send_command(session, AST_FRAME_IAX, IAX_COMMAND_TRANSFER, 0, ied.buf, ied.pos, -1); + + // Return Success + return 0; +} + +static void stop_transfer(struct iax_session *session) +{ + struct iax_sched *sch; + + iax_mutex_lock(sched_mutex); + sch = schedq; + while(sch) { + if (sch->frame && (sch->frame->session == session)) + sch->frame->retries = -1; + sch = sch->next; + } + iax_mutex_unlock(sched_mutex); +} /* stop_transfer */ + +static void complete_transfer(struct iax_session *session, int peercallno, int xfr2peer, int preserveSeq) +{ + session->peercallno = peercallno; + /* Change from transfer to session now */ + if (xfr2peer) { + memcpy(&session->peeraddr, &session->transfer, sizeof(session->peeraddr)); + memset(&session->transfer, 0, sizeof(session->transfer)); + session->transferring = TRANSFER_NONE; + session->transferpeer = 0; + session->transfer_moh = 0; + /* Force retransmission of a real voice packet, and reset all timing */ + session->svoiceformat = -1; + session->voiceformat = 0; + } + session->rxcore = session->offset = 0; + memset(&session->history, 0, sizeof(session->history)); +#ifdef NEWJB + { /* Reset jitterbuffer */ + jb_frame frame; + while(jb_getall(session->jb,&frame) == JB_OK) + iax_event_free(frame.data); + + jb_reset(session->jb); + } +#endif + session->jitterbuffer = 0; + session->jitter = 0; + session->lag = 0; + + if (! preserveSeq) + { + /* Reset sequence numbers */ + session->aseqno = 0; + session->oseqno = 0; + session->iseqno = 0; + } + + session->lastsent = 0; + session->last_ts = 0; + session->lastvoicets = 0; + session->pingtime = 30; + /* We have to dump anything we were going to (re)transmit now that we've been + transferred since they're all invalid and for the old host. */ + stop_transfer(session); +} /* complete_transfer */ + +int iax_setup_transfer(struct iax_session *org_session, struct iax_session *new_session) +{ + int res; + struct iax_ie_data ied0; + struct iax_ie_data ied1; + + struct iax_session *s0 = org_session; + struct iax_session *s1 = new_session; + + memset(&ied0, 0, sizeof(ied0)); + memset(&ied1, 0, sizeof(ied1)); + + /* reversed setup */ + iax_ie_append_addr(&ied0, IAX_IE_APPARENT_ADDR, &s1->peeraddr); + iax_ie_append_short(&ied0, IAX_IE_CALLNO, s1->peercallno); + iax_ie_append_int(&ied0, IAX_IE_TRANSFERID, transfer_id); + + iax_ie_append_addr(&ied1, IAX_IE_APPARENT_ADDR, &s0->peeraddr); + iax_ie_append_short(&ied1, IAX_IE_CALLNO, s0->peercallno); + iax_ie_append_int(&ied1, IAX_IE_TRANSFERID, transfer_id); + + s0->transfer = s1->peeraddr; + s1->transfer = s0->peeraddr; + + s0->transferid = transfer_id; + s1->transferid = transfer_id; + + s0->transfercallno = s0->peercallno; + s1->transfercallno = s1->peercallno; + + s0->transferring = TRANSFER_BEGIN; + s1->transferring = TRANSFER_BEGIN; + + s0->transferpeer = s1->callno; + s1->transferpeer = s0->callno; + + transfer_id++; + + if (transfer_id > 32767) + transfer_id = 1; + + res = send_command(s0, AST_FRAME_IAX, IAX_COMMAND_TXREQ, 0, ied0.buf, ied0.pos, -1); + if (res < 0) { + return -1; + } + + res = send_command(s1, AST_FRAME_IAX, IAX_COMMAND_TXREQ, 0, ied1.buf, ied1.pos, -1); + if (res < 0) { + return -1; + } + + return 0; +} + +static int iax_finish_transfer(struct iax_session *s, short new_peer) +{ + int res; + struct iax_ie_data ied; + + memset(&ied, 0, sizeof(ied)); + + iax_ie_append_short(&ied, IAX_IE_CALLNO, new_peer); + + res = send_command(s, AST_FRAME_IAX, IAX_COMMAND_TXREL, 0, ied.buf, ied.pos, -1); + + complete_transfer(s, new_peer, 0, 1); + + return res; + +} + +static struct iax_session *iax_find_session2(short callno) +{ + struct iax_session *cur; + + iax_mutex_lock(session_mutex); + cur = sessions; + while(cur) { + if (callno == cur->callno && callno != 0) { + iax_mutex_unlock(session_mutex); + return cur; + } + cur = cur->next; + } + iax_mutex_unlock(session_mutex); + + return NULL; +} + +static int iax_handle_txready(struct iax_session *s) +{ + struct iax_session *s0, *s1; + short s0_org_peer, s1_org_peer; + + if (s->transfer_moh) { + s->transfer_moh = 0; + iax_unquelch(s); + } + + complete_transfer(s, s->peercallno, 0, 1); + + s->transferring = TRANSFER_REL; + + s0 = s; + s1 = iax_find_session2(s0->transferpeer); + + if (s1 != NULL && + s1->callno == s0->transferpeer && + s0->transferring == TRANSFER_REL && + s1->transferring == TRANSFER_REL) { + + s0_org_peer = s0->peercallno; + s1_org_peer = s1->peercallno; + + iax_finish_transfer(s0, s1_org_peer); + iax_finish_transfer(s1, s0_org_peer); + return 1; + } + + return 0; +} + +static void iax_handle_txreject(struct iax_session *s) +{ + struct iax_session *s0, *s1; + + s0 = s; + s1 = iax_find_session2(s0->transferpeer); + if (s1 != NULL && + s0->transferpeer == s1->callno && + s1->transferring) { + if (s1->transfer_moh) { + s1->transfer_moh = 0; + send_command_immediate(s1, AST_FRAME_IAX, IAX_COMMAND_UNQUELCH, 0, NULL, 0, s1->iseqno); + } + } + if (s0->transfer_moh) { + s0->transfer_moh = 0; + send_command_immediate(s0, AST_FRAME_IAX, IAX_COMMAND_UNQUELCH, 0, NULL, 0, s0->iseqno); + } + + memset(&s->transfer, 0, sizeof(s->transfer)); + s->transferring = TRANSFER_NONE; + s->transferpeer = 0; + s->transfer_moh = 0; +} + +static void destroy_session(struct iax_session *session) +{ + struct iax_session *cur, *prev=NULL; + struct iax_sched *curs, *prevs=NULL, *nexts=NULL; + int loop_cnt=0; + + iax_mutex_lock(sched_mutex); + curs = schedq; + while(curs) { + nexts = curs->next; + if (curs->frame && curs->frame->session == session) { + /* Just mark these frames as if they've been sent */ + curs->frame->retries = -1; + } else if (curs->event && curs->event->session == session) { + if (prevs) + prevs->next = nexts; + else + schedq = nexts; + if (curs->event) + iax_event_free(curs->event); + free(curs); + } else { + prevs = curs; + } + curs = nexts; + loop_cnt++; + } + iax_mutex_unlock(sched_mutex); + + + cur = sessions; + while(cur) { + if (cur == session) { + if (prev) + prev->next = session->next; + else + sessions = session->next; +#ifdef NEWJB + { + jb_frame frame; + while(jb_getall(session->jb,&frame) == JB_OK) + iax_event_free(frame.data); + + jb_destroy(session->jb); + } +#endif + free(session); + return; + } + prev = cur; + cur = cur->next; + } +} + +static int iax_send_lagrp(struct iax_session *session, time_in_ms_t ts); +static int iax_send_pong(struct iax_session *session, time_in_ms_t ts); + +static struct iax_event *handle_event(struct iax_event *event) +{ + /* We have a candidate event to be delievered. Be sure + the session still exists. */ + if (event) { + if (iax_session_valid(event->session)) { + /* Lag requests are never actually sent to the client, but + other than that are handled as normal packets */ + switch(event->etype) { + /* the user on the outside may need to look at the session so we will not free + it here anymore we will test for hangup event in iax_event_free and do it + there. + */ + case IAX_EVENT_REJECT: + case IAX_EVENT_HANGUP: + return event; + case IAX_EVENT_LAGRQ: + event->etype = IAX_EVENT_LAGRP; + iax_send_lagrp(event->session, event->ts); + iax_event_free(event); + break; + case IAX_EVENT_PING: + event->etype = IAX_EVENT_PONG; + iax_send_pong(event->session, event->ts); + iax_event_free(event); + break; + case IAX_EVENT_POKE: + event->etype = IAX_EVENT_PONG; + iax_send_pong(event->session, event->ts); + iax_destroy(event->session); + iax_event_free(event); + break; + default: + return event; + } + } else + iax_event_free(event); + } + return NULL; +} + +static int iax2_vnak(struct iax_session *session) +{ + return send_command_immediate(session, AST_FRAME_IAX, IAX_COMMAND_VNAK, 0, NULL, 0, session->iseqno); +} + +int iax_send_dtmf(struct iax_session *session, char digit) +{ + return send_command(session, AST_FRAME_DTMF, digit, 0, NULL, 0, -1); +} + +int iax_send_voice(struct iax_session *session, int format, unsigned char *data, int datalen, int samples) +{ + /* Send a (possibly compressed) voice frame */ + if (!session->quelch) + return send_command_samples(session, AST_FRAME_VOICE, format, 0, data, datalen, -1, samples); + return 0; +} + +int iax_send_cng(struct iax_session *session, int level, unsigned char *data, int datalen) +{ + session->notsilenttx = 0; + return send_command(session, AST_FRAME_CNG, level, 0, data, datalen, -1); +} + +int iax_send_image(struct iax_session *session, int format, unsigned char *data, int datalen) +{ + /* Send an image frame */ + return send_command(session, AST_FRAME_IMAGE, format, 0, data, datalen, -1); +} + +int iax_register(struct iax_session *session, char *server, char *peer, char *secret, int refresh) +{ + /* Send a registration request */ + char tmp[256]; + char *p; + int res; + int portno = IAX_DEFAULT_PORTNO; + struct iax_ie_data ied; + struct hostent *hp; + + tmp[255] = '\0'; + strncpy(tmp, server, sizeof(tmp) - 1); + p = strchr(tmp, ':'); + if (p) { + *p = '\0'; + portno = atoi(p+1); + } + + memset(&ied, 0, sizeof(ied)); + if (secret) + strncpy(session->secret, secret, sizeof(session->secret) - 1); + else + strcpy(session->secret, ""); + + /* Connect first */ + hp = gethostbyname(tmp); + if (!hp) { + snprintf(iax_errstr, sizeof(iax_errstr), "Invalid hostname: %s", tmp); + return -1; + } + memcpy(&session->peeraddr.sin_addr, hp->h_addr, sizeof(session->peeraddr.sin_addr)); + session->peeraddr.sin_port = htons(portno); + session->peeraddr.sin_family = AF_INET; + strncpy(session->username, peer, sizeof(session->username) - 1); + session->refresh = refresh; + iax_ie_append_str(&ied, IAX_IE_USERNAME, (unsigned char *) peer); + iax_ie_append_short(&ied, IAX_IE_REFRESH, refresh); + res = send_command(session, AST_FRAME_IAX, IAX_COMMAND_REGREQ, 0, ied.buf, ied.pos, -1); + return res; +} + +int iax_reject_registration(struct iax_session *session, char *reason) +{ + struct iax_ie_data ied; + memset(&ied, 0, sizeof(ied)); + iax_ie_append_str(&ied, IAX_IE_CAUSE, reason ? (unsigned char *) reason : (unsigned char *) "Unspecified"); + return send_command_final(session, AST_FRAME_IAX, IAX_COMMAND_REGREJ, 0, ied.buf, ied.pos, -1); +} + +int iax_ack_registration(struct iax_session *session) +{ + return send_command_final(session, AST_FRAME_IAX, IAX_COMMAND_REGACK, 0, NULL, 0, -1); +} + +int iax_auth_registration(struct iax_session *session) +{ + return send_command_final(session, AST_FRAME_IAX, IAX_COMMAND_REGAUTH, 0, NULL, 0, -1); +} + +int iax_reject(struct iax_session *session, const char *reason) +{ + struct iax_ie_data ied; + memset(&ied, 0, sizeof(ied)); + iax_ie_append_str(&ied, IAX_IE_CAUSE, reason ? (unsigned char *) reason : (unsigned char *) "Unspecified"); + return send_command_final(session, AST_FRAME_IAX, IAX_COMMAND_REJECT, 0, ied.buf, ied.pos, -1); +} + +int iax_hangup(struct iax_session *session, char *byemsg) +{ + struct iax_ie_data ied; + iax_sched_del(NULL, NULL, send_ping, (void *) session, 1); + memset(&ied, 0, sizeof(ied)); + iax_ie_append_str(&ied, IAX_IE_CAUSE, byemsg ? (unsigned char *) byemsg : (unsigned char *) "Normal clearing"); + return send_command_final(session, AST_FRAME_IAX, IAX_COMMAND_HANGUP, 0, ied.buf, ied.pos, -1); +} + +int iax_sendurl(struct iax_session *session, char *url) +{ + return send_command(session, AST_FRAME_HTML, AST_HTML_URL, 0, (unsigned char *) url, (int)strlen(url), -1); +} + +int iax_ring_announce(struct iax_session *session) +{ + return send_command(session, AST_FRAME_CONTROL, AST_CONTROL_RINGING, 0, NULL, 0, -1); +} + +int iax_lag_request(struct iax_session *session) +{ + return send_command(session, AST_FRAME_IAX, IAX_COMMAND_LAGRQ, 0, NULL, 0, -1); +} + +int iax_busy(struct iax_session *session) +{ + return send_command(session, AST_FRAME_CONTROL, AST_CONTROL_BUSY, 0, NULL, 0, -1); +} + +int iax_congestion(struct iax_session *session) +{ + return send_command(session, AST_FRAME_CONTROL, AST_CONTROL_CONGESTION, 0, NULL, 0, -1); +} + + +int iax_accept(struct iax_session *session, int format) +{ + struct iax_ie_data ied; + memset(&ied, 0, sizeof(ied)); + iax_ie_append_int(&ied, IAX_IE_FORMAT, format); + return send_command(session, AST_FRAME_IAX, IAX_COMMAND_ACCEPT, 0, ied.buf, ied.pos, -1); +} + +int iax_answer(struct iax_session *session) +{ + return send_command(session, AST_FRAME_CONTROL, AST_CONTROL_ANSWER, 0, NULL, 0, -1); +} + +int iax_load_complete(struct iax_session *session) +{ + return send_command(session, AST_FRAME_HTML, AST_HTML_LDCOMPLETE, 0, NULL, 0, -1); +} + +int iax_send_url(struct iax_session *session, char *url, int link) +{ + return send_command(session, AST_FRAME_HTML, link ? AST_HTML_LINKURL : AST_HTML_URL, 0, (unsigned char *) url, (int)strlen(url), -1); +} + +int iax_send_text(struct iax_session *session, char *text) +{ + return send_command(session, AST_FRAME_TEXT, 0, 0, (unsigned char *) text, (int)strlen(text) + 1, -1); +} + +int iax_send_unlink(struct iax_session *session) +{ + return send_command(session, AST_FRAME_HTML, AST_HTML_UNLINK, 0, NULL, 0, -1); +} + +int iax_send_link_reject(struct iax_session *session) +{ + return send_command(session, AST_FRAME_HTML, AST_HTML_LINKREJECT, 0, NULL, 0, -1); +} + +static int iax_send_pong(struct iax_session *session, time_in_ms_t ts) +{ + struct iax_ie_data ied; + + memset(&ied, 0, sizeof(ied)); +#ifdef NEWJB + { + jb_info stats; + jb_getinfo(session->jb, &stats); + + iax_ie_append_int(&ied,IAX_IE_RR_JITTER, (int)stats.jitter); + /* XXX: should be short-term loss pct.. */ + if(stats.frames_in == 0) stats.frames_in = 1; + iax_ie_append_int(&ied,IAX_IE_RR_LOSS, + ((0xff & (stats.losspct/1000)) << 24 | (stats.frames_lost & 0x00ffffff))); + iax_ie_append_int(&ied,IAX_IE_RR_PKTS, stats.frames_in); + iax_ie_append_short(&ied,IAX_IE_RR_DELAY, (unsigned short)(stats.current - stats.min)); + iax_ie_append_int(&ied,IAX_IE_RR_DROPPED, stats.frames_dropped); + iax_ie_append_int(&ied,IAX_IE_RR_OOO, stats.frames_ooo); + } +#else + iax_ie_append_int(&ied,IAX_IE_RR_JITTER, session->jitter); + /* don't know, don't send! iax_ie_append_int(&ied,IAX_IE_RR_LOSS, 0); */ + /* don't know, don't send! iax_ie_append_int(&ied,IAX_IE_RR_PKTS, stats.frames_in); */ + /* don't know, don't send! iax_ie_append_short(&ied,IAX_IE_RR_DELAY, stats.current - stats.min); */ +#endif + + return send_command(session, AST_FRAME_IAX, IAX_COMMAND_PONG, ts, ied.buf, ied.pos, -1); +} + +/* external API; deprecated since we send pings ourselves now (finally) */ +int iax_send_ping(struct iax_session *session) +{ + return send_command(session, AST_FRAME_IAX, IAX_COMMAND_PING, 0, NULL, 0, -1); +} + +/* scheduled ping sender; sends ping, then reschedules */ +static void send_ping(void *s) +{ + struct iax_session *session = (struct iax_session *)s; + + /* important, eh? */ + if(!iax_session_valid(session)) return; + + send_command(session, AST_FRAME_IAX, IAX_COMMAND_PING, 0, NULL, 0, -1); + session->pingid = iax_sched_add(NULL,NULL, send_ping, (void *)session, ping_time * 1000); + return; +} + +static int iax_send_lagrp(struct iax_session *session, time_in_ms_t ts) +{ + return send_command(session, AST_FRAME_IAX, IAX_COMMAND_LAGRP, ts, NULL, 0, -1); +} + +static int iax_send_txcnt(struct iax_session *session) +{ + struct iax_ie_data ied; + memset(&ied, 0, sizeof(ied)); + iax_ie_append_int(&ied, IAX_IE_TRANSFERID, session->transferid); + return send_command_transfer(session, AST_FRAME_IAX, IAX_COMMAND_TXCNT, 0, ied.buf, ied.pos); +} + +static int iax_send_txrej(struct iax_session *session) +{ + struct iax_ie_data ied; + memset(&ied, 0, sizeof(ied)); + iax_ie_append_int(&ied, IAX_IE_TRANSFERID, session->transferid); + return send_command_transfer(session, AST_FRAME_IAX, IAX_COMMAND_TXREJ, 0, ied.buf, ied.pos); +} + +static int iax_send_txaccept(struct iax_session *session) +{ + struct iax_ie_data ied; + memset(&ied, 0, sizeof(ied)); + iax_ie_append_int(&ied, IAX_IE_TRANSFERID, session->transferid); + return send_command_transfer(session, AST_FRAME_IAX, IAX_COMMAND_TXACC, 0, ied.buf, ied.pos); +} + +static int iax_send_txready(struct iax_session *session) +{ + struct iax_ie_data ied; + memset(&ied, 0, sizeof(ied)); + /* see asterisk chan_iax2.c */ + iax_ie_append_short(&ied, IAX_IE_CALLNO, session->callno); + return send_command(session, AST_FRAME_IAX, IAX_COMMAND_TXREADY, 0, ied.buf, ied.pos, -1); +} + +int iax_auth_reply(struct iax_session *session, char *password, char *challenge, int methods) +{ + char reply[16]; + struct MD5Context md5; + char realreply[256]; + struct iax_ie_data ied; + memset(&ied, 0, sizeof(ied)); + if ((methods & IAX_AUTH_MD5) && challenge) { + MD5Init(&md5); + MD5Update(&md5, (const unsigned char *) challenge, (unsigned int)strlen(challenge)); + MD5Update(&md5, (const unsigned char *) password, (unsigned int)strlen(password)); + MD5Final((unsigned char *) reply, &md5); + memset(realreply, 0, sizeof(realreply)); + convert_reply(realreply, (unsigned char *) reply); + iax_ie_append_str(&ied, IAX_IE_MD5_RESULT, (unsigned char *) realreply); + } else { + iax_ie_append_str(&ied, IAX_IE_PASSWORD, (unsigned char *) password); + } + return send_command(session, AST_FRAME_IAX, IAX_COMMAND_AUTHREP, 0, ied.buf, ied.pos, -1); +} + +static int iax_regauth_reply(struct iax_session *session, char *password, char *challenge, int methods) +{ + char reply[16]; + struct MD5Context md5; + char realreply[256]; + struct iax_ie_data ied; + memset(&ied, 0, sizeof(ied)); + iax_ie_append_str(&ied, IAX_IE_USERNAME, (unsigned char *) session->username); + iax_ie_append_short(&ied, IAX_IE_REFRESH, session->refresh); + if ((methods & IAX_AUTHMETHOD_MD5) && challenge) { + MD5Init(&md5); + MD5Update(&md5, (const unsigned char *) challenge, (unsigned int)strlen(challenge)); + MD5Update(&md5, (const unsigned char *) password, (unsigned int)strlen(password)); + MD5Final((unsigned char *) reply, &md5); + memset(realreply, 0, sizeof(realreply)); + convert_reply(realreply, (unsigned char *) reply); + iax_ie_append_str(&ied, IAX_IE_MD5_RESULT, (unsigned char *) realreply); + } else { + iax_ie_append_str(&ied, IAX_IE_PASSWORD, (unsigned char *) password); + } + return send_command(session, AST_FRAME_IAX, IAX_COMMAND_REGREQ, 0, ied.buf, ied.pos, -1); +} + + +int iax_dial(struct iax_session *session, char *number) +{ + struct iax_ie_data ied; + memset(&ied, 0, sizeof(ied)); + iax_ie_append_str(&ied, IAX_IE_CALLED_NUMBER, (unsigned char *) number); + return send_command(session, AST_FRAME_IAX, IAX_COMMAND_DIAL, 0, ied.buf, ied.pos, -1); +} + +int iax_quelch(struct iax_session *session) +{ + return send_command(session, AST_FRAME_IAX, IAX_COMMAND_QUELCH, 0, NULL, 0, -1); +} + +int iax_unquelch(struct iax_session *session) +{ + return send_command(session, AST_FRAME_IAX, IAX_COMMAND_UNQUELCH, 0, NULL, 0, -1); +} + +int iax_dialplan_request(struct iax_session *session, char *number) +{ + struct iax_ie_data ied; + memset(&ied, 0, sizeof(ied)); + iax_ie_append_str(&ied, IAX_IE_CALLED_NUMBER, (unsigned char *) number); + return send_command(session, AST_FRAME_IAX, IAX_COMMAND_DPREQ, 0, ied.buf, ied.pos, -1); +} + +static inline int which_bit(unsigned int i) +{ + char x; + for(x = 0; x < 32; x++) { + if ((1 << x) == i) { + return x + 1; + } + } + return 0; +} + +char iax_pref_codec_add(struct iax_session *session, unsigned int format) +{ + int diff = (int) 'A'; + session->codec_order[session->codec_order_len++] = (which_bit(format)) + diff; + session->codec_order[session->codec_order_len] = '\0'; + return session->codec_order[session->codec_order_len-1]; +} + + +void iax_pref_codec_del(struct iax_session *session, unsigned int format) +{ + int diff = (int) 'A'; + size_t x; + char old[32]; + char remove = which_bit(format) + diff; + + strncpy(old, session->codec_order, sizeof(old)); + session->codec_order_len = 0; + + for (x = 0; x < strlen(old) ; x++) { + if (old[x] != remove) { + session->codec_order[session->codec_order_len++] = old[x]; + } + } + session->codec_order[session->codec_order_len] = '\0'; +} + +int iax_pref_codec_get(struct iax_session *session, unsigned int *array, int len) +{ + int diff = (int) 'A'; + int x; + + for (x = 0; x < session->codec_order_len && x < len; x++) { + array[x] = (1 << (session->codec_order[x] - diff - 1)); + } + + return x; +} + +void iax_set_samplerate(struct iax_session *session, unsigned short samplemask) +{ + session->samplemask = samplemask; +} + + +int iax_call(struct iax_session *session, const char *cidnum, const char *cidname, char *ich, char *lang, int wait, int formats, int capabilities) +{ + char tmp[256]=""; + char *part1, *part2; + int res; + int portno; + char *username, *hostname, *secret, *context, *exten, *dnid; + struct iax_ie_data ied; + struct hostent *hp; + /* We start by parsing up the temporary variable which is of the form of: + [user@]peer[:portno][/exten[@context]] */ + if (!ich) { + IAXERROR "Invalid IAX Call Handle\n"); + DEBU(G "Invalid IAX Call Handle\n"); + return -1; + } + memset(&ied, 0, sizeof(ied)); + strncpy(tmp, ich, sizeof(tmp) - 1); + + iax_ie_append_short(&ied, IAX_IE_VERSION, IAX_PROTO_VERSION); + if (session->samplemask) { + iax_ie_append_short(&ied, IAX_IE_SAMPLINGRATE, session->samplemask); + } + if (cidnum) + iax_ie_append_str(&ied, IAX_IE_CALLING_NUMBER, (unsigned char *) cidnum); + if (cidname) + iax_ie_append_str(&ied, IAX_IE_CALLING_NAME, (unsigned char *) cidname); + + if (session->codec_order_len) { + iax_ie_append_str(&ied, IAX_IE_CODEC_PREFS, (unsigned char *) session->codec_order); + } + + session->capability = capabilities; + session->pingid = iax_sched_add(NULL,NULL, send_ping, (void *)session, 2 * 1000); + + /* XXX We should have a preferred format XXX */ + iax_ie_append_int(&ied, IAX_IE_FORMAT, formats); + iax_ie_append_int(&ied, IAX_IE_CAPABILITY, capabilities); + if (lang) + iax_ie_append_str(&ied, IAX_IE_LANGUAGE, (unsigned char *) lang); + + /* Part 1 is [user[:password]@]peer[:port] */ + part1 = strtok(tmp, "/"); + + /* Part 2 is exten[@context] if it is anything all */ + part2 = strtok(NULL, "/"); + + if (strchr(part1, '@')) { + username = strtok(part1, "@"); + hostname = strtok(NULL, "@"); + } else { + username = NULL; + hostname = part1; + } + + if (username && strchr(username, ':')) { + username = strtok(username, ":"); + secret = strtok(NULL, ":"); + } else + secret = NULL; + + if(username) + strncpy(session->username, username, sizeof(session->username) - 1); + + if(secret) + strncpy(session->secret, secret, sizeof(session->secret) - 1); + + if (strchr(hostname, ':')) { + strtok(hostname, ":"); + portno = atoi(strtok(NULL, ":")); + } else { + portno = IAX_DEFAULT_PORTNO; + } + if (part2) { + exten = strtok(part2, "@"); + dnid = exten; + context = strtok(NULL, "@"); + } else { + exten = NULL; + dnid = NULL; + context = NULL; + } + if (username) + iax_ie_append_str(&ied, IAX_IE_USERNAME, (unsigned char *) username); + if (exten && strlen(exten)) + iax_ie_append_str(&ied, IAX_IE_CALLED_NUMBER, (unsigned char *) exten); + if (dnid && strlen(dnid)) + iax_ie_append_str(&ied, IAX_IE_DNID, (unsigned char *) dnid); + if (context && strlen(context)) + iax_ie_append_str(&ied, IAX_IE_CALLED_CONTEXT, (unsigned char *) context); + + /* Setup host connection */ + hp = gethostbyname(hostname); + if (!hp) { + snprintf(iax_errstr, sizeof(iax_errstr), "Invalid hostname: %s", hostname); + return -1; + } + memcpy(&session->peeraddr.sin_addr, hp->h_addr, sizeof(session->peeraddr.sin_addr)); + session->peeraddr.sin_port = htons(portno); + session->peeraddr.sin_family = AF_INET; + res = send_command(session, AST_FRAME_IAX, IAX_COMMAND_NEW, 0, ied.buf, ied.pos, -1); + if (res < 0) + return res; + if (wait) { + DEBU(G "Waiting not yet implemented\n"); + return -1; + } + return res; +} + +static time_in_ms_t calc_rxstamp(struct iax_session *session) +{ + time_in_ms_t time_in_ms; + + time_in_ms = current_time_in_ms(); + + if (!session->rxcore) { + session->rxcore = time_in_ms; + } + + return time_in_ms - session->rxcore; +} + +#ifdef notdef_cruft +static int match(struct sockaddr_in *sin, short callno, short dcallno, struct iax_session *cur) +{ + if ((cur->peeraddr.sin_addr.s_addr == sin->sin_addr.s_addr) && + (cur->peeraddr.sin_port == sin->sin_port)) { + /* This is the main host */ + if ((cur->peercallno == callno) || + ((dcallno == cur->callno) && !cur->peercallno)) { + /* That's us. Be sure we keep track of the peer call number */ + cur->peercallno = callno; + return 1; + } + } + if ((cur->transfer.sin_addr.s_addr == sin->sin_addr.s_addr) && + (cur->transfer.sin_port == sin->sin_port) && (cur->transferring)) { + /* We're transferring */ + if (dcallno == cur->callno) + return 1; + } + return 0; +} +#endif + +/* splitted match into 2 passes otherwise causing problem of matching + up the wrong session using the dcallno and the peercallno because + during a transfer (2 IAX channels on the same client/system) the + same peercallno (from two different asterisks) exist in more than + one session. + */ +static int forward_match(struct sockaddr_in *sin, short callno, short dcallno, struct iax_session *cur) +{ + if ((cur->transfer.sin_addr.s_addr == sin->sin_addr.s_addr) && + (cur->transfer.sin_port == sin->sin_port) && (cur->transferring)) { + /* We're transferring */ + if (dcallno == cur->callno) + { + return 1; + } + } + + if ((cur->peeraddr.sin_addr.s_addr == sin->sin_addr.s_addr) && + (cur->peeraddr.sin_port == sin->sin_port)) { + if (dcallno == cur->callno && dcallno != 0) { + /* That's us. Be sure we keep track of the peer call number */ + if (cur->peercallno == 0) { + cur->peercallno = callno; + } + return 1; + } + } + + return 0; +} + +static int reverse_match(struct sockaddr_in *sin, short callno, struct iax_session *cur) +{ + if ((cur->transfer.sin_addr.s_addr == sin->sin_addr.s_addr) && + (cur->transfer.sin_port == sin->sin_port) && (cur->transferring)) { + /* We're transferring */ + if (callno == cur->peercallno) { + return 1; + } + } + if ((cur->peeraddr.sin_addr.s_addr == sin->sin_addr.s_addr) && + (cur->peeraddr.sin_port == sin->sin_port)) { + if (callno == cur->peercallno) { + return 1; + } + } + + return 0; +} + +static struct iax_session *iax_find_session(struct sockaddr_in *sin, + short callno, + short dcallno, + int makenew) +{ + struct iax_session *cur; + + iax_mutex_lock(session_mutex); + cur = sessions; + while(cur) { + if (forward_match(sin, callno, dcallno, cur)) { + iax_mutex_unlock(session_mutex); + return cur; + } + cur = cur->next; + } + + cur = sessions; + while(cur) { + if (reverse_match(sin, callno, cur)) { + iax_mutex_unlock(session_mutex); + return cur; + } + cur = cur->next; + } + + iax_mutex_unlock(session_mutex); + + if (makenew && !dcallno) { + cur = iax_session_new(); + cur->peercallno = callno; + cur->peeraddr.sin_addr.s_addr = sin->sin_addr.s_addr; + cur->peeraddr.sin_port = sin->sin_port; + cur->peeraddr.sin_family = AF_INET; + cur->pingid = iax_sched_add(NULL,NULL, send_ping, (void *)cur, 2 * 1000); + DEBU(G "Making new session, peer callno %d, our callno %d\n", callno, cur->callno); + } else { + DEBU(G "No session, peer = %d, us = %d\n", callno, dcallno); + } + + return cur; +} + +#ifdef EXTREME_DEBUG +static int display_time(int ms) +{ + static int oldms = -1; + if (oldms < 0) { + DEBU(G "First measure\n"); + oldms = ms; + return 0; + } + DEBU(G "Time from last frame is %d ms\n", ms - oldms); + oldms = ms; + return 0; +} +#endif + +#define FUDGE 1 + +#ifdef NEWJB +/* From chan_iax2/steve davies: need to get permission from steve or digium, I guess */ +static time_in_ms_t unwrap_timestamp(time_in_ms_t ts, time_in_ms_t last) +{ + time_in_ms_t x; + + if ( (ts & 0xFFFF0000) == (last & 0xFFFF0000) ) { + x = ts - last; + if (x < -50000) { + /* Sudden big jump backwards in timestamp: + What likely happened here is that miniframe timestamp has circled but we haven't + gotten the update from the main packet. We'll just pretend that we did, and + update the timestamp appropriately. */ + ts = ( (last & 0xFFFF0000) + 0x10000) | (ts & 0xFFFF); + DEBU(G "schedule_delivery: pushed forward timestamp\n"); + } + if (x > 50000) { + /* Sudden apparent big jump forwards in timestamp: + What's likely happened is this is an old miniframe belonging to the previous + top-16-bit timestamp that has turned up out of order. + Adjust the timestamp appropriately. */ + ts = ( (last & 0xFFFF0000) - 0x10000) | (ts & 0xFFFF); + DEBU(G "schedule_delivery: pushed back timestamp\n"); + } + } + return ts; +} +#endif + + +static struct iax_event *schedule_delivery(struct iax_event *e, time_in_ms_t ts, int updatehistory) +{ + /* + * This is the core of the IAX jitterbuffer delivery mechanism: + * Dynamically adjust the jitterbuffer and decide how time_in_ms_t to wait + * before delivering the packet. + */ +#ifndef NEWJB + int ms, x; + int drops[MEMORY_SIZE]; + int min, max=0, maxone=0, y, z, match; +#endif + +#ifdef EXTREME_DEBUG + DEBU(G "[%p] We are at %d, packet is for %d\n", e->session, calc_rxstamp(e->session), ts); +#endif + +#ifdef VOICE_SMOOTHING + if (e->etype == IAX_EVENT_VOICE) { + /* Smooth voices if we know enough about the format */ + switch(e->event.voice.format) { + case AST_FORMAT_GSM: + /* GSM frames are 20 ms long, although there could be periods of + silence. If the time is < 50 ms, assume it ought to be 20 ms */ + if (ts - e->session->lastts < 50) + ts = e->session->lastts + 20; +#ifdef EXTREME_DEBUG + display_time(ts); +#endif + break; + default: + /* Can't do anything */ + } + e->session->lastts = ts; + } +#endif + +#ifdef NEWJB + { + int type = JB_TYPE_CONTROL; + int len = 0; + + if(e->etype == IAX_EVENT_VOICE) { + type = JB_TYPE_VOICE; + len = get_sample_cnt(e) / 8; + } else if(e->etype == IAX_EVENT_CNG) { + type = JB_TYPE_SILENCE; + } + + /* unwrap timestamp */ + ts = unwrap_timestamp(ts,e->session->last_ts); + + /* move forward last_ts if it's greater. We do this _after_ unwrapping, because + * asterisk _still_ has cases where it doesn't send full frames when it ought to */ + if(ts > e->session->last_ts) { + e->session->last_ts = ts; + } + + + /* insert into jitterbuffer */ + /* TODO: Perhaps we could act immediately if it's not droppable and late */ + if(jb_put(e->session->jb, e, type, len, ts, calc_rxstamp(e->session)) == JB_DROP) { + iax_event_free(e); + } + + } +#else + + /* How many ms from now should this packet be delivered? (remember + this can be a negative number, too */ + ms = (int)(calc_rxstamp(e->session) - ts); + + /* + Drop voice frame if timestamp is way off + if ((e->etype == IAX_EVENT_VOICE) && ((ms > 65536) || (ms < -65536))) { + DEBU(G "Dropping a voice packet with odd ts (ts = %d; ms = %d)\n", ts, ms); + free(e); + return NULL; + } + */ + + /* Adjust if voice frame timestamp is off by a step */ + if (ms > 32768) { + /* What likely happened here is that our counter has circled but we haven't + gotten the update from the main packet. We'll just pretend that we did, and + update the timestamp appropriately. */ + ms -= 65536; + } + if (ms < -32768) { + /* We got this packet out of order. Lets add 65536 to it to bring it into our new + time frame */ + ms += 65536; + } + +#if 0 + printf("rxstamp is %d, timestamp is %d, ms is %d\n", calc_rxstamp(e->session), ts, ms); +#endif + /* Rotate history queue. Leading 0's are irrelevant. */ + if (updatehistory) { + for (x=0; x < MEMORY_SIZE - 1; x++) + e->session->history[x] = e->session->history[x+1]; + + /* Add new entry for this time */ + e->session->history[x] = ms; + } + + /* We have to find the maximum and minimum time delay we've had to deliver. */ + min = e->session->history[0]; + for (z=0;z < iax_dropcount + 1; z++) { + /* We drop the top iax_dropcount entries. iax_dropcount represents + a tradeoff between quality of voice and latency. 3% drop seems to + be unnoticable to the client and can significantly improve latency. + We add one more to our droplist, but that's the one we actually use, + and don't drop. */ + max = -99999999; + for (x=0;x<MEMORY_SIZE;x++) { + if (max < e->session->history[x]) { + /* New candidate value. Make sure we haven't dropped it. */ + match=0; + for(y=0;!match && (y<z); y++) + match |= (drops[y] == x); + /* If there is no match, this is our new maximum */ + if (!match) { + max = e->session->history[x]; + maxone = x; + } + } + if (!z) { + /* First pass, calcualte our minimum, too */ + if (min > e->session->history[x]) + min = e->session->history[x]; + } + } + drops[z] = maxone; + } + /* Again, just for reference. The "jitter buffer" is the max. The difference + is the perceived jitter correction. */ + e->session->jitter = max - min; + + /* If the jitter buffer is substantially too large, shrink it, slowly enough + that the client won't notice ;-) . */ + if (max < e->session->jitterbuffer - max_extra_jitterbuffer) { +#ifdef EXTREME_DEBUG + DEBU(G "Shrinking jitterbuffer (target = %d, current = %d...\n", max, e->session->jitterbuffer); +#endif + e->session->jitterbuffer -= 1; + } + + /* Keep the jitter buffer from becoming unreasonably large */ + if (max > min + max_jitterbuffer) { + DEBU(G "Constraining jitter buffer (min = %d, max = %d)...\n", min, max); + max = min + max_jitterbuffer; + } + + /* If the jitter buffer is too small, we immediately grow our buffer to + accomodate */ + if (max > e->session->jitterbuffer) + e->session->jitterbuffer = max; + + /* Start with our jitter buffer delay, and subtract the lateness (or earliness). + Remember these times are all relative to the first packet, so their absolute + values are really irrelevant. */ + ms = e->session->jitterbuffer - ms - IAX_SCHEDULE_FUZZ; + + /* If the jitterbuffer is disabled, always deliver immediately */ + if (!iax_use_jitterbuffer) + ms = 0; + + if (ms < 1) { +#ifdef EXTREME_DEBUG + DEBU(G "Calculated delay is only %d\n", ms); +#endif + if ((ms > -4) || (e->etype != IAX_EVENT_VOICE)) { + /* Return the event immediately if it's it's less than 3 milliseconds + too late, or if it's not voice (believe me, you don't want to + just drop a hangup frame because it's late, or a ping, or some such. + That kinda ruins retransmissions too ;-) */ + /* Queue for immediate delivery */ + iax_sched_add(e, NULL, NULL, NULL, 0); + return NULL; + //return e; + } + DEBU(G "(not so) Silently dropping a packet (ms = %d)\n", ms); + /* Silently discard this as if it were to be delivered */ + free(e); + return NULL; + } + /* We need this to be delivered in the future, so we use our scheduler */ + iax_sched_add(e, NULL, NULL, NULL, ms); +#ifdef EXTREME_DEBUG + DEBU(G "Delivering packet in %d ms\n", ms); +#endif +#endif /* NEWJB */ + return NULL; + +} + +static int uncompress_subclass(unsigned char csub) +{ + /* If the SC_LOG flag is set, return 2^csub otherwise csub */ + if (csub & IAX_FLAG_SC_LOG) + return 1 << (csub & ~IAX_FLAG_SC_LOG & IAX_MAX_SHIFT); + else + return csub; +} + +static inline char *extract(char *src, char *string) +{ + /* Extract and duplicate what we need from a string */ + char *s, *t; + s = strstr(src, string); + if (s) { + s += strlen(string); + s = strdup(s); + /* End at ; */ + t = strchr(s, ';'); + if (t) { + *t = '\0'; + } + } + return s; + +} + +static struct iax_event *iax_header_to_event(struct iax_session *session, + struct ast_iax2_full_hdr *fh, + int datalen, struct sockaddr_in *sin) +{ + struct iax_event *e; + struct iax_sched *sch; + unsigned int ts; + int subclass = uncompress_subclass(fh->csub); + time_in_ms_t nowts; + int updatehistory = 1; + ts = ntohl(fh->ts); + /* don't run last_ts backwards; i.e. for retransmits and the like */ + if (ts > session->last_ts && + (fh->type == AST_FRAME_IAX && + subclass != IAX_COMMAND_ACK && + subclass != IAX_COMMAND_PONG && + subclass != IAX_COMMAND_LAGRP)) { + session->last_ts = ts; + } + + +#ifdef DEBUG_SUPPORT + iax_showframe(NULL, fh, 1, sin, datalen); +#endif + + /* Get things going with it, timestamp wise, if we + haven't already. */ + + /* Handle implicit ACKing unless this is an INVAL, and only if this is + from the real peer, not the transfer peer */ + if (!inaddrcmp(sin, &session->peeraddr) && + (((subclass != IAX_COMMAND_INVAL)) || + (fh->type != AST_FRAME_IAX))) { + unsigned char x; + /* XXX This code is not very efficient. Surely there is a better way which still + properly handles boundary conditions? XXX */ + /* First we have to qualify that the ACKed value is within our window */ + for (x=session->rseqno; x != session->oseqno; x++) + if (fh->iseqno == x) + break; + if ((x != session->oseqno) || (session->oseqno == fh->iseqno)) { + /* The acknowledgement is within our window. Time to acknowledge everything + that it says to */ + for (x=session->rseqno; x != fh->iseqno; x++) { + /* Ack the packet with the given timestamp */ + DEBU(G "Cancelling transmission of packet %d\n", x); + iax_mutex_lock(sched_mutex); + sch = schedq; + while(sch) { + if (sch->frame && (sch->frame->session == session) && + (sch->frame->oseqno == x)) + sch->frame->retries = -1; + sch = sch->next; + } + iax_mutex_unlock(sched_mutex); + } + /* Note how much we've received acknowledgement for */ + session->rseqno = fh->iseqno; + } else + DEBU(G "Received iseqno %d not within window %d->%d\n", fh->iseqno, session->rseqno, session->oseqno); + } + + /* Check where we are */ + if ((ntohs(fh->dcallno) & IAX_FLAG_RETRANS) || (fh->type != AST_FRAME_VOICE)) + updatehistory = 0; + if ((session->iseqno != fh->oseqno) && + (session->iseqno || + ((subclass != IAX_COMMAND_TXREADY) && + (subclass != IAX_COMMAND_TXREL) && + (subclass != IAX_COMMAND_TXCNT) && + (subclass != IAX_COMMAND_TXACC)) || + (fh->type != AST_FRAME_IAX))) { + if ( + ((subclass != IAX_COMMAND_ACK) && + (subclass != IAX_COMMAND_INVAL) && + (subclass != IAX_COMMAND_TXREADY) && + (subclass != IAX_COMMAND_TXREL) && + (subclass != IAX_COMMAND_TXCNT) && + (subclass != IAX_COMMAND_TXACC) && + (subclass != IAX_COMMAND_VNAK)) || + (fh->type != AST_FRAME_IAX)) { + /* If it's not an ACK packet, it's out of order. */ + DEBU(G "Packet arrived out of order (expecting %d, got %d) (frametype = %d, subclass = %d)\n", + session->iseqno, fh->oseqno, fh->type, subclass); + if (session->iseqno > fh->oseqno) { + /* If we've already seen it, ack it XXX There's a border condition here XXX */ + if ((fh->type != AST_FRAME_IAX) || + ((subclass != IAX_COMMAND_ACK) && (subclass != IAX_COMMAND_INVAL))) { + DEBU(G "Acking anyway\n"); + /* XXX Maybe we should handle its ack to us, but then again, it's probably outdated anyway, and if + we have anything to send, we'll retransmit and get an ACK back anyway XXX */ + send_command_immediate(session, AST_FRAME_IAX, IAX_COMMAND_ACK, ts, NULL, 0,fh->iseqno); + } + } else { + /* Send a VNAK requesting retransmission */ + iax2_vnak(session); + } + return NULL; + } + } else { + /* Increment unless it's an ACK or VNAK */ + if (((subclass != IAX_COMMAND_ACK) && + (subclass != IAX_COMMAND_INVAL) && + (subclass != IAX_COMMAND_TXCNT) && + (subclass != IAX_COMMAND_TXACC) && + (subclass != IAX_COMMAND_VNAK)) || + (fh->type != AST_FRAME_IAX)) + session->iseqno++; + } + + e = (struct iax_event *)malloc(sizeof(struct iax_event) + datalen + 1); + + if (e) { + memset(e, 0, sizeof(struct iax_event) + datalen); + /* Set etype to some unknown value so do not inavertently + sending IAX_EVENT_CONNECT event, which is 0 to application. + */ + e->etype = -1; + e->session = session; + switch(fh->type) { + case AST_FRAME_DTMF: + e->etype = IAX_EVENT_DTMF; + e->subclass = subclass; + /* + We want the DTMF event deliver immediately so all I/O can be + terminate quickly in an IVR system. + e = schedule_delivery(e, ts, updatehistory); */ + break; + case AST_FRAME_VOICE: + e->etype = IAX_EVENT_VOICE; + e->subclass = subclass; + session->voiceformat = subclass; + if (datalen) { + memcpy(e->data, fh->iedata, datalen); + e->datalen = datalen; + } + e = schedule_delivery(e, ts, updatehistory); + break; + case AST_FRAME_CNG: + e->etype = IAX_EVENT_CNG; + e->subclass = subclass; + if (datalen) { + memcpy(e->data, fh->iedata, datalen); + e->datalen = datalen; + } + e = schedule_delivery(e, ts, updatehistory); + break; + case AST_FRAME_IAX: + /* Parse IE's */ + if (datalen) { + memcpy(e->data, fh->iedata, datalen); + e->datalen = datalen; + } + if (iax_parse_ies(&e->ies, e->data, e->datalen)) { + IAXERROR "Unable to parse IE's"); + free(e); + e = NULL; + break; + } + switch(subclass) { + case IAX_COMMAND_NEW: + /* This is a new, incoming call */ + /* save the capability for validation */ + session->capability = e->ies.capability; + if (e->ies.codec_prefs) { + strncpy(session->codec_order, e->ies.codec_prefs, sizeof(session->codec_order)); + session->codec_order_len = (int)strlen(session->codec_order); + } + e->etype = IAX_EVENT_CONNECT; + e = schedule_delivery(e, ts, updatehistory); + break; + case IAX_COMMAND_AUTHREQ: + /* This is a request for a call */ + e->etype = IAX_EVENT_AUTHRQ; + if (strlen(session->username) && !strcmp(e->ies.username, session->username) && + strlen(session->secret)) { + /* Hey, we already know this one */ + iax_auth_reply(session, session->secret, e->ies.challenge, e->ies.authmethods); + free(e); + e = NULL; + break; + } + e = schedule_delivery(e, ts, updatehistory); + break; + case IAX_COMMAND_HANGUP: + e->etype = IAX_EVENT_HANGUP; + e = schedule_delivery(e, ts, updatehistory); + break; + case IAX_COMMAND_INVAL: + e->etype = IAX_EVENT_HANGUP; + e = schedule_delivery(e, ts, updatehistory); + break; + case IAX_COMMAND_REJECT: + e->etype = IAX_EVENT_REJECT; + e = schedule_delivery(e, ts, updatehistory); + break; + case IAX_COMMAND_ACK: + free(e); + e = NULL; + break; + case IAX_COMMAND_LAGRQ: + /* Pass this atime_in_ms_t for later handling */ + e->etype = IAX_EVENT_LAGRQ; + e->ts = ts; + e = schedule_delivery(e, ts, updatehistory); + break; + case IAX_COMMAND_POKE: + e->etype = IAX_EVENT_POKE; + e->ts = ts; + break; + case IAX_COMMAND_PING: + /* PINGS and PONGS don't get scheduled; */ + e->etype = IAX_EVENT_PING; + e->ts = ts; + break; + case IAX_COMMAND_PONG: + e->etype = IAX_EVENT_PONG; + /* track weighted average of ping time */ + session->pingtime = ((2 * session->pingtime) + (calc_timestamp(session,0,NULL) - ts)) / 3; + session->remote_netstats.jitter = e->ies.rr_jitter; + session->remote_netstats.losspct = e->ies.rr_loss >> 24;; + session->remote_netstats.losscnt = e->ies.rr_loss & 0xffffff; + session->remote_netstats.packets = e->ies.rr_pkts; + session->remote_netstats.delay = e->ies.rr_delay; + session->remote_netstats.dropped = e->ies.rr_dropped; + session->remote_netstats.ooo = e->ies.rr_ooo; + break; + case IAX_COMMAND_ACCEPT: + if (e->ies.format & session->capability) { + e->etype = IAX_EVENT_ACCEPT; + } + else { + struct iax_ie_data ied; + /* Although this should not happen, we added this to make sure + the negotiation protocol is enforced. + For lack of event to notify the application we use the defined + REJECT event. + */ + memset(&ied, 0, sizeof(ied)); + iax_ie_append_str(&ied, IAX_IE_CAUSE, (unsigned char *) "Unable to negotiate codec"); + send_command_final(session, AST_FRAME_IAX, IAX_COMMAND_REJECT, 0, ied.buf, ied.pos, -1); + e->etype = IAX_EVENT_REJECT; + } + e = schedule_delivery(e, ts, updatehistory); + break; + case IAX_COMMAND_REGREQ: + e->etype = IAX_EVENT_REGREQ; + e = schedule_delivery(e, ts, updatehistory); + break; + case IAX_COMMAND_REGREL: + e->etype = IAX_EVENT_REGREQ; + e = schedule_delivery(e, ts, updatehistory); + break; + case IAX_COMMAND_REGACK: + e->etype = IAX_EVENT_REGACK; + e = schedule_delivery(e, ts, updatehistory); + break; + case IAX_COMMAND_REGAUTH: + iax_regauth_reply(session, session->secret, e->ies.challenge, e->ies.authmethods); + free(e); + e = NULL; + break; + case IAX_COMMAND_REGREJ: + e->etype = IAX_EVENT_REGREJ; + e = schedule_delivery(e, ts, updatehistory); + break; + case IAX_COMMAND_LAGRP: + e->etype = IAX_EVENT_LAGRP; + nowts = calc_timestamp(session, 0, NULL); + e->ts = nowts - ts; + e->subclass = session->jitter; + /* Can't call schedule_delivery since timestamp is non-normal */ + break;; + case IAX_COMMAND_TXREQ: + /* added check for defensive programming + * - in case the asterisk server + * or another client does not send the + * apparent transfer address + */ + if (e->ies.apparent_addr != NULL) { + /* so a full voice frame is sent on the + next voice output */ + session->svoiceformat = -1; + session->transfer = *e->ies.apparent_addr; + session->transfer.sin_family = AF_INET; + session->transfercallno = e->ies.callno; + session->transferring = TRANSFER_BEGIN; + session->transferid = e->ies.transferid; + iax_send_txcnt(session); + } + free(e); + e = NULL; + break; + case IAX_COMMAND_DPREP: + /* Received dialplan reply */ + e->etype = IAX_EVENT_DPREP; + /* Return immediately, makes no sense to schedule */ + break; + case IAX_COMMAND_TXCNT: + if (session->transferring) { + session->transfer = *sin; + iax_send_txaccept(session); + } + free(e); + e = NULL; + break; + case IAX_COMMAND_TXACC: + if (session->transferring) { + stop_transfer(session); + session->transferring = TRANSFER_READY; + iax_send_txready(session); + } + free(e); + e = NULL; + break; + case IAX_COMMAND_TXREL: + /* Release the transfer */ + send_command_immediate(session, AST_FRAME_IAX, IAX_COMMAND_ACK, fh->ts, NULL, 0, fh->iseqno); + if (session->transferring) { + complete_transfer(session, e->ies.callno, 1, 0); + } + else { + complete_transfer(session, session->peercallno, 0, 1); + } + e->etype = IAX_EVENT_TRANSFER; + /* notify that asterisk no longer sitting between peers */ + e = schedule_delivery(e, ts, updatehistory); + break; + case IAX_COMMAND_QUELCH: + e->etype = IAX_EVENT_QUELCH; + session->quelch = 1; + break; + case IAX_COMMAND_UNQUELCH: + e->etype = IAX_EVENT_UNQUELCH; + session->quelch = 0; + break; + case IAX_COMMAND_TXREJ: + e->etype = IAX_EVENT_TXREJECT; + iax_handle_txreject(session); + break; + + case IAX_COMMAND_TXREADY: + send_command_immediate(session, AST_FRAME_IAX, IAX_COMMAND_ACK, ts, NULL, 0, fh->iseqno); + if (iax_handle_txready(session)) { + e->etype = IAX_EVENT_TXREADY; + } + else { + free(e); + e = NULL; + } + break; + default: + DEBU(G "Don't know what to do with IAX command %d\n", subclass); + free(e); + e = NULL; + } + break; + case AST_FRAME_CONTROL: + switch(subclass) { + case AST_CONTROL_ANSWER: + e->etype = IAX_EVENT_ANSWER; + e = schedule_delivery(e, ts, updatehistory); + break; + case AST_CONTROL_CONGESTION: + case AST_CONTROL_BUSY: + e->etype = IAX_EVENT_BUSY; + e = schedule_delivery(e, ts, updatehistory); + break; + case AST_CONTROL_RINGING: + e->etype = IAX_EVENT_RINGA; + e = schedule_delivery(e, ts, updatehistory); + break; + default: + DEBU(G "Don't know what to do with AST control %d\n", subclass); + free(e); + return NULL; + } + break; + case AST_FRAME_IMAGE: + e->etype = IAX_EVENT_IMAGE; + e->subclass = subclass; + if (datalen) { + memcpy(e->data, fh->iedata, datalen); + } + e = schedule_delivery(e, ts, updatehistory); + break; + + case AST_FRAME_TEXT: + e->etype = IAX_EVENT_TEXT; + if (datalen) { + memcpy(e->data, fh->iedata, datalen); + } + e = schedule_delivery(e, ts, updatehistory); + break; + + case AST_FRAME_HTML: + switch(fh->csub) { + case AST_HTML_LINKURL: + e->etype = IAX_EVENT_LINKURL; + /* Fall through */ + case AST_HTML_URL: + if (e->etype == -1) + e->etype = IAX_EVENT_URL; + e->subclass = fh->csub; + e->datalen = datalen; + if (datalen) { + memcpy(e->data, fh->iedata, datalen); + } + e = schedule_delivery(e, ts, updatehistory); + break; + case AST_HTML_LDCOMPLETE: + e->etype = IAX_EVENT_LDCOMPLETE; + e = schedule_delivery(e, ts, updatehistory); + break; + case AST_HTML_UNLINK: + e->etype = IAX_EVENT_UNLINK; + e = schedule_delivery(e, ts, updatehistory); + break; + case AST_HTML_LINKREJECT: + e->etype = IAX_EVENT_LINKREJECT; + e = schedule_delivery(e, ts, updatehistory); + break; + default: + DEBU(G "Don't know how to handle HTML type %d frames\n", fh->csub); + free(e); + return NULL; + } + break; + default: + DEBU(G "Don't know what to do with frame type %d\n", fh->type); + free(e); + return NULL; + } + } else + DEBU(G "Out of memory\n"); + + /* Already ack'd iax frames */ + if (session->aseqno != session->iseqno) { + send_command_immediate(session, AST_FRAME_IAX, IAX_COMMAND_ACK, ts, NULL, 0, fh->iseqno); + } + return e; +} + +static struct iax_event *iax_miniheader_to_event(struct iax_session *session, + struct ast_iax2_mini_hdr *mh, + int datalen) +{ + struct iax_event *e; + time_in_ms_t ts; + int updatehistory = 1; + e = (struct iax_event *)malloc(sizeof(struct iax_event) + datalen); + if (e) { + if (session->voiceformat > 0) { + e->etype = IAX_EVENT_VOICE; + e->session = session; + e->subclass = session->voiceformat; + e->datalen = datalen; + if (datalen) { +#ifdef EXTREME_DEBUG + DEBU(G "%d bytes of voice\n", datalen); +#endif + memcpy(e->data, mh->data, datalen); + } + ts = (session->last_ts & 0xFFFF0000) | ntohs(mh->ts); + return schedule_delivery(e, ts, updatehistory); + } else { + DEBU(G "No last format received on session %d\n", session->callno); + free(e); + e = NULL; + } + } else + DEBU(G "Out of memory\n"); + return e; +} + +void iax_destroy(struct iax_session *session) +{ + iax_mutex_lock(session_mutex); + destroy_session(session); + iax_mutex_unlock(session_mutex); +} + +static struct iax_event *iax_net_read(void) +{ + unsigned char buf[65536]; + int res, sinlen; + struct sockaddr_in sin; + + sinlen = sizeof(sin); + res = iax_recvfrom(netfd, buf, sizeof(buf), 0, (struct sockaddr *) &sin, &sinlen); + + if (res < 0) { +#ifdef WIN32 + if (WSAGetLastError() != WSAEWOULDBLOCK) { + DEBU(G "Error on read: %d\n", WSAGetLastError()); + IAXERROR "Read error on network socket: %s", strerror(errno)); + } +#else + if (errno != EAGAIN) { + DEBU(G "Error on read: %s\n", strerror(errno)); + IAXERROR "Read error on network socket: %s", strerror(errno)); + } +#endif + return NULL; + } + return iax_net_process(buf, res, &sin); +} + +static struct iax_session *iax_txcnt_session(struct ast_iax2_full_hdr *fh, int datalen, + struct sockaddr_in *sin, short callno, short dcallno) +{ + int subclass = uncompress_subclass(fh->csub); + unsigned char buf[ 65536 ]; /* allocated on stack with same size as iax_net_read() */ + struct iax_ies ies; + struct iax_session *cur; + + if ((fh->type != AST_FRAME_IAX) || (subclass != IAX_COMMAND_TXCNT) || (!datalen)) { + return NULL; /* special handling for TXCNT only */ + } + memcpy(buf, fh->iedata, datalen); /* prepare local buf for iax_parse_ies() */ + + if (iax_parse_ies(&ies, buf, datalen)) { + return NULL; /* Unable to parse IE's */ + } + if (!ies.transferid) { + return NULL; /* TXCNT without proper IAX_IE_TRANSFERID */ + } + iax_mutex_lock(session_mutex); + for( cur=sessions; cur; cur=cur->next ) { + if ((cur->transferring) && (cur->transferid == ies.transferid) && + (cur->callno == dcallno) && (cur->transfercallno == callno)) { + /* We're transferring --- + * skip address/port checking which would fail while remote peer behind symmetric NAT + * verify transferid instead + */ + cur->transfer.sin_addr.s_addr = sin->sin_addr.s_addr; /* setup for further handling */ + cur->transfer.sin_port = sin->sin_port; + break; + } + } + iax_mutex_unlock(session_mutex); + return cur; +} + +struct iax_event *iax_net_process(unsigned char *buf, int len, struct sockaddr_in *sin) +{ + struct ast_iax2_full_hdr *fh = (struct ast_iax2_full_hdr *)buf; + struct ast_iax2_mini_hdr *mh = (struct ast_iax2_mini_hdr *)buf; + struct iax_session *session; + + if (ntohs(fh->scallno) & IAX_FLAG_FULL) { + int subclass = uncompress_subclass(fh->csub); + int makenew = 0; + + /* Full size header */ + if (len < sizeof(struct ast_iax2_full_hdr)) { + DEBU(G "Short header received from %s\n", inet_ntoa(sin->sin_addr)); + IAXERROR "Short header received from %s\n", inet_ntoa(sin->sin_addr)); + return NULL; + } + /* Only allow it to make new sessions on types where that makes sense */ + if ((fh->type == AST_FRAME_IAX) && ((subclass == IAX_COMMAND_NEW) || + (subclass == IAX_COMMAND_POKE) || + (subclass == IAX_COMMAND_REGREL) || + (subclass == IAX_COMMAND_REGREQ))) { + makenew = 1; + } + + /* We have a full header, process appropriately */ + session = iax_find_session(sin, ntohs(fh->scallno) & ~IAX_FLAG_FULL, ntohs(fh->dcallno) & ~IAX_FLAG_RETRANS, makenew); + if (!session) + session = iax_txcnt_session(fh, len-sizeof(struct ast_iax2_full_hdr), sin, ntohs(fh->scallno) & ~IAX_FLAG_FULL, ntohs(fh->dcallno) & ~IAX_FLAG_RETRANS); + if (session) + return iax_header_to_event(session, fh, len - sizeof(struct ast_iax2_full_hdr), sin); + /* if we get here, the frame was invalid for some reason, we should probably send IAX_COMMAND_INVAL (as long as the subclass was not already IAX_COMMAND_INVAL) */ + DEBU(G "No session?\n"); + return NULL; + } else { + if (len < sizeof(struct ast_iax2_mini_hdr)) { + DEBU(G "Short header received from %s\n", inet_ntoa(sin->sin_addr)); + IAXERROR "Short header received from %s\n", inet_ntoa(sin->sin_addr)); + return NULL; + } + /* Miniature, voice frame */ + session = iax_find_session(sin, ntohs(fh->scallno), 0, 0); + if (session) + return iax_miniheader_to_event(session, mh, len - sizeof(struct ast_iax2_mini_hdr)); + DEBU(G "No session?\n"); + return NULL; + } +} + +static struct iax_sched *iax_get_sched(time_in_ms_t time_in_ms) +{ + struct iax_sched *cur, *prev=NULL; + iax_mutex_lock(sched_mutex); + cur = schedq; + /* Check the event schedule first. */ + while(cur) { + if (time_in_ms > cur->when) { + /* Take it out of the event queue */ + if (prev) { + prev->next = cur->next; + } else { + schedq = cur->next; + } + iax_mutex_unlock(sched_mutex); + return cur; + } + cur = cur->next; + } + iax_mutex_unlock(sched_mutex); + return NULL; +} + +struct iax_event *iax_get_event(int blocking) +{ + struct iax_event *event; + struct iax_frame *frame; + time_in_ms_t time_in_ms; + struct iax_sched *cur; + + if (do_shutdown) { + __iax_shutdown(); + do_shutdown = 0; + return NULL; + } + time_in_ms = current_time_in_ms(); + while((cur = iax_get_sched(time_in_ms))) { + + event = cur->event; + frame = cur->frame; + if (event) { + + /* See if this is an event we need to handle */ + event = handle_event(event); + if (event) { + free(cur); + return event; + } + } else if(frame) { + /* It's a frame, transmit it and schedule a retry */ + if (frame->retries < 0) { + /* It's been acked. No need to send it. Destroy the old + frame. If final, destroy the session. */ + if (frame->final) { + iax_mutex_lock(session_mutex); + destroy_session(frame->session); + iax_mutex_unlock(session_mutex); + } + if (frame->data) + free(frame->data); + free(frame); + } else if (frame->retries == 0) { + if (frame->transfer) { + /* Send a transfer reject since we weren't able to connect */ + iax_send_txrej(frame->session); + if (frame->data) + free(frame->data); + free(frame); + free(cur); + break; + } else { + /* We haven't been able to get an ACK on this packet. If a + final frame, destroy the session, otherwise, pass up timeout */ + if (frame->final) { + iax_mutex_lock(session_mutex); + destroy_session(frame->session); + iax_mutex_unlock(session_mutex); + if (frame->data) + free(frame->data); + free(frame); + } else { + event = (struct iax_event *)malloc(sizeof(struct iax_event)); + if (event) { + event->etype = IAX_EVENT_TIMEOUT; + event->session = frame->session; + if (frame->data) + free(frame->data); + free(frame); + free(cur); + return handle_event(event); + } + } + } + } else { + struct ast_iax2_full_hdr *fh; + /* Decrement remaining retries */ + frame->retries--; + /* Multiply next retry time by 4, not above MAX_RETRY_TIME though */ + frame->retrytime *= 4; + /* Keep under 1000 ms if this is a transfer packet */ + if (!frame->transfer) { + if (frame->retrytime > MAX_RETRY_TIME) + frame->retrytime = MAX_RETRY_TIME; + } else if (frame->retrytime > 1000) + frame->retrytime = 1000; + fh = (struct ast_iax2_full_hdr *)(frame->data); + fh->dcallno = htons(IAX_FLAG_RETRANS | frame->dcallno); + iax_xmit_frame(frame); + /* Schedule another retransmission */ + DEBU(G "Scheduling retransmission %d\n", frame->retries); + iax_sched_add(NULL, frame, NULL, NULL, frame->retrytime); + } + } else if (cur->func) { + cur->func(cur->arg); + } + free(cur); + } + +#ifdef NEWJB + /* get jitterbuffer-scheduled events */ + { + struct iax_session *cur; + jb_frame frame; + iax_mutex_lock(session_mutex); + for(cur=sessions; cur; cur=cur->next) { + int ret; + time_in_ms_t now; + time_in_ms_t next; + + now = time_in_ms - cur->rxcore; + if(now > (next = jb_next(cur->jb))) { + ret = jb_get(cur->jb,&frame,now,get_interp_len(cur->voiceformat)); + switch(ret) { + case JB_OK: + // if(frame.type == JB_TYPE_VOICE && next + 20 != jb_next(cur->jb)) fprintf(stderr, "NEXT %ld is not %ld+20!\n", jb_next(cur->jb), next); + event = frame.data; + event = handle_event(event); + if (event) { + iax_mutex_unlock(session_mutex); + return event; + } + break; + case JB_INTERP: + // if(next + 20 != jb_next(cur->jb)) fprintf(stderr, "NEXT %ld is not %ld+20!\n", jb_next(cur->jb), next); + /* create an interpolation frame */ + //fprintf(stderr, "Making Interpolation frame\n"); + event = (struct iax_event *)malloc(sizeof(struct iax_event)); + if (event) { + event->etype = IAX_EVENT_VOICE; + event->subclass = cur->voiceformat; + event->ts = now; /* XXX: ??? applications probably ignore this anyway */ + event->session = cur; + event->datalen = 0; + event = handle_event(event); + if(event) { + iax_mutex_unlock(session_mutex); + return event; + } + } + break; + case JB_DROP: + // if(next != jb_next(cur->jb)) fprintf(stderr, "NEXT %ld is not next %ld!\n", jb_next(cur->jb), next); + iax_event_free(frame.data); + break; + case JB_NOFRAME: + case JB_EMPTY: + /* do nothing */ + break; + default: + /* shouldn't happen */ + break; + } + } + } + iax_mutex_unlock(session_mutex); + } + +#endif + /* Now look for networking events */ + if (blocking) { + /* Block until there is data if desired */ + fd_set fds; + time_in_ms_t nextEventTime; + + FD_ZERO(&fds); + FD_SET(netfd, &fds); + + nextEventTime = iax_time_to_next_event(); + if(nextEventTime < 0 && blocking > 1) { + nextEventTime = blocking; + } + if(nextEventTime < 0) + select(netfd + 1, &fds, NULL, NULL, NULL); + else + { + struct timeval nextEvent; + + nextEvent.tv_sec = (long)(nextEventTime / 1000); + nextEvent.tv_usec = (long)((nextEventTime % 1000) * 1000); + + select(netfd + 1, &fds, NULL, NULL, &nextEvent); + } + + } + event = iax_net_read(); + + return handle_event(event); +} + +struct sockaddr_in iax_get_peer_addr(struct iax_session *session) +{ + return session->peeraddr; +} + +char *iax_get_peer_ip(struct iax_session *session) +{ + return inet_ntoa(session->peeraddr.sin_addr); +} + +char *iax_event_get_apparent_ip(struct iax_event *event) +{ + return inet_ntoa(event->ies.apparent_addr->sin_addr); +} + +void iax_session_destroy(struct iax_session **session) +{ + iax_mutex_lock(session_mutex); + destroy_session(*session); + *session = NULL; + iax_mutex_unlock(session_mutex); +} + +void iax_event_free(struct iax_event *event) +{ + /* + We gave the user a chance to play with the session now we need to destroy it + if you are not calling this function on every event you read you are now going + to leak sessions as well as events! + */ + switch(event->etype) { + case IAX_EVENT_REJECT: + case IAX_EVENT_HANGUP: + /* Destroy this session -- it's no longer valid */ + if (event->session) { /* maybe the user did it already */ + iax_mutex_lock(session_mutex); + destroy_session(event->session); + iax_mutex_unlock(session_mutex); + } + break; + } + free(event); +} + +int iax_get_fd(void) +{ + /* Return our network file descriptor. The client can select on this (probably with other + things, or can add it to a network add sort of gtk_input_add for example */ + return netfd; +} + +int iax_quelch_moh(struct iax_session *session, int MOH) +{ + + struct iax_ie_data ied; //IE Data Structure (Stuff To Send) + memset(&ied, 0, sizeof(ied)); + + // You can't quelch the quelched + if (session->quelch == 1) + return -1; + + if (MOH) { + iax_ie_append(&ied, IAX_IE_MUSICONHOLD); + session->transfer_moh = 1; + } + + return send_command(session, AST_FRAME_IAX, IAX_COMMAND_QUELCH, 0, ied.buf, ied.pos, -1); +} Added: freeswitch/trunk/src/mod/endpoints/mod_iax/iax.h ============================================================================== --- (empty file) +++ freeswitch/trunk/src/mod/endpoints/mod_iax/iax.h Thu May 8 19:25:36 2008 @@ -0,0 +1,86 @@ +/* + * libIAX + * + * Implementation of Inter-IAXerisk eXchange + * + * Copyright (C) 1999, Mark Spencer + * + * Mark Spencer <markster@linux-support.net> + * + * This program is free software, distributed under the terms of + * the GNU Lesser (Library) General Public License + */ + +#ifndef _IAX_H +#define _IAX_H + +/* Max version of IAX protocol we support */ +#define IAX_PROTO_VERSION 1 + +#define IAX_MAX_CALLS 32768 + +#define IAX_FLAG_FULL 0x8000 + +#define IAX_FLAG_SC_LOG 0x80 + +#define IAX_MAX_SHIFT 0x1F + +/* Maximum size of an IAX frame (max size of UDP frame) */ +#define IAX_MAX_BUF_SIZE 65536 + +/* Subclass for IAX_FRAME_IAX */ +#define IAX_COMMAND_NEW 1 +#define IAX_COMMAND_PING 2 +#define IAX_COMMAND_PONG 3 +#define IAX_COMMAND_ACK 4 +#define IAX_COMMAND_HANGUP 5 +#define IAX_COMMAND_REJECT 6 +#define IAX_COMMAND_ACCEPT 7 +#define IAX_COMMAND_AUTHREQ 8 +#define IAX_COMMAND_AUTHREP 9 +#define IAX_COMMAND_INVAL 10 +#define IAX_COMMAND_LAGRQ 11 +#define IAX_COMMAND_LAGRP 12 +#define IAX_COMMAND_REGREQ 13 /* Registration request */ +#define IAX_COMMAND_REGAUTH 14 /* Registration authentication required */ +#define IAX_COMMAND_REGACK 15 /* Registration accepted */ +#define IAX_COMMAND_REGREJ 16 /* Registration rejected */ +#define IAX_COMMAND_REGREL 17 /* Force release of registration */ +#define IAX_COMMAND_VNAK 18 /* If we receive voice before valid first voice frame, send this */ +#define IAX_COMMAND_DPREQ 19 /* Request status of a dialplan entry */ +#define IAX_COMMAND_DPREP 20 /* Request status of a dialplan entry */ +#define IAX_COMMAND_DIAL 21 /* Request a dial on channel brought up TBD */ +#define IAX_COMMAND_TXREQ 22 /* Transfer Request */ +#define IAX_COMMAND_TXCNT 23 /* Transfer Connect */ +#define IAX_COMMAND_TXACC 24 /* Transfer Accepted */ +#define IAX_COMMAND_TXREADY 25 /* Transfer ready */ +#define IAX_COMMAND_TXREL 26 /* Transfer release */ +#define IAX_COMMAND_TXREJ 27 /* Transfer reject */ +#define IAX_COMMAND_QUELCH 28 /* Stop audio/video transmission */ +#define IAX_COMMAND_UNQUELCH 29 /* Resume audio/video transmission */ + +#define IAX_DEFAULT_REG_EXPIRE 60 + +#define IAX_DEFAULT_PORTNO 5036 + +/* Full frames are always delivered reliably */ +struct iax_full_hdr { + short callno; /* Source call number -- high bit must be 1 */ + short dcallno; /* Destination call number */ + unsigned int ts; /* 32-bit timestamp in milliseconds */ + unsigned short seqno; /* Packet number */ + char type; /* Frame type */ + unsigned char csub; /* Compressed subclass */ + char data[]; +}; + +/* Mini header is used only for voice frames -- delivered unreliably */ +struct iax_mini_hdr { + short callno; /* Source call number -- high bit must be 0 */ + unsigned short ts; /* 16-bit Timestamp (high 16 bits from last IAX_full_hdr) */ + /* Frametype implicitly VOICE_FRAME */ + /* subclass implicit from last IAX_full_hdr */ + char data[]; +}; + +#endif Added: freeswitch/trunk/src/mod/endpoints/mod_iax/iax2-parser.c ============================================================================== --- (empty file) +++ freeswitch/trunk/src/mod/endpoints/mod_iax/iax2-parser.c Thu May 8 19:25:36 2008 @@ -0,0 +1,840 @@ +/* + * Asterisk -- A telephony toolkit for Linux. + * + * Implementation of Inter-Asterisk eXchange + * + * Copyright (C) 2003-2004, Digium + * + * Mark Spencer <markster@digium.com> + * + * This program is free software, distributed under the terms of + * the GNU Lesser (Library) General Public License + */ + +#ifdef WIN32 +#include <winsock.h> +#define snprintf _snprintf +#else +#include <sys/types.h> +#include <sys/socket.h> +#include <netinet/in.h> +#include <arpa/inet.h> +#endif + +#ifndef _MSC_VER +#include <unistd.h> +#endif + +#include <string.h> +#include <stdlib.h> +#include <stdio.h> + +#include "frame.h" +#include "iax2.h" +#include "iax2-parser.h" + +static int frames = 0; +static int iframes = 0; +static int oframes = 0; + +#ifdef ALIGN32 +static unsigned int get_uint32(unsigned char *p) +{ + return (p[0] << 24) | (p[1] << 16) | (p[2] << 8) | p[3]; +} + +static unsigned short get_uint16(unsigned char *p) +{ + return (p[0] << 8) | p[1] ; +} + +#else +#define get_uint32(p) (*((unsigned int *)(p))) +#define get_uint16(p) (*((unsigned short *)(p))) +#endif + + +static void internaloutput(const char *str) +{ + printf(str); +} + +static void internalerror(const char *str) +{ + fprintf(stderr, "WARNING: %s", str); +} + +static void (*outputf)(const char *str) = internaloutput; +static void (*errorf)(const char *str) = internalerror; + +static void dump_addr(char *output, int maxlen, void *value, int len) +{ + struct sockaddr_in sin; + if (len == sizeof(sin)) { + memcpy(&sin, value, len); + snprintf(output, maxlen, "IPV4 %s:%d", inet_ntoa(sin.sin_addr), ntohs(sin.sin_port)); + } else { + snprintf(output, maxlen, "Invalid Address"); + } +} + +static void dump_string(char *output, int maxlen, void *value, int len) +{ + maxlen--; + if (maxlen > len) + maxlen = len; + strncpy(output,value, maxlen); + output[maxlen] = '\0'; +} + +static void dump_int(char *output, int maxlen, void *value, int len) +{ + if (len == (int)sizeof(unsigned int)) + snprintf(output, maxlen, "%lu", (unsigned long)ntohl(get_uint32(value))); + else + snprintf(output, maxlen, "Invalid INT"); +} + +static void dump_short(char *output, int maxlen, void *value, int len) +{ + if (len == (int)sizeof(unsigned short)) + snprintf(output, maxlen, "%d", ntohs(get_uint16(value))); + else + snprintf(output, maxlen, "Invalid SHORT"); +} + +static void dump_byte(char *output, int maxlen, void *value, int len) +{ + if (len == (int)sizeof(unsigned char)) + snprintf(output, maxlen, "%d", *((unsigned char *)value)); + else + snprintf(output, maxlen, "Invalid BYTE"); +} + +#if 0 +static void dump_ipaddr(char *output, int maxlen, void *value, int len) +{ + struct sockaddr_in sin; + if (len == (int)sizeof(unsigned int)) { + memcpy(&sin.sin_addr, value, len); + snprintf(output, maxlen, "%s", inet_ntoa(sin.sin_addr)); + } else + snprintf(output, maxlen, "Invalid IPADDR"); +} + +static void dump_prov_flags(char *output, int maxlen, void *value, int len) +{ + if (len == (int)sizeof(unsigned int)) + snprintf(output, maxlen, "%lu (%s)", (unsigned long)ntohl(get_uint32(value)), + "PROVISION_PARSING_NOT_IMPLEMENTED"); + else + snprintf(output, maxlen, "Invalid INT"); +} +#endif + +static void dump_samprate(char *output, int maxlen, void *value, int len) +{ + char tmp[256]=""; + int sr; + if (len == (int)sizeof(unsigned short)) { + sr = ntohs(*((unsigned short *)value)); + if (sr & IAX_RATE_8KHZ) + strcat(tmp, ",8khz"); + if (sr & IAX_RATE_11KHZ) + strcat(tmp, ",11.025khz"); + if (sr & IAX_RATE_16KHZ) + strcat(tmp, ",16khz"); + if (sr & IAX_RATE_32KHZ) + strcat(tmp, ",32khz"); + if (sr & IAX_RATE_22KHZ) + strcat(tmp, ",22.05khz"); + if (sr & IAX_RATE_44KHZ) + strcat(tmp, ",44.1khz"); + if (sr & IAX_RATE_48KHZ) + strcat(tmp, ",48khz"); + if (strlen(tmp)) + strncpy(output, &tmp[1], maxlen - 1); + else + strncpy(output, "None specified!\n", maxlen - 1); + } else + snprintf(output, maxlen, "Invalid SHORT"); + +} + +static void dump_prov_ies(char *output, int maxlen, unsigned char *iedata, int len); +static void dump_prov(char *output, int maxlen, void *value, int len) +{ + dump_prov_ies(output, maxlen, value, len); +} + +static struct iax2_ie { + int ie; + char *name; + void (*dump)(char *output, int maxlen, void *value, int len); +} ies[] = { + { IAX_IE_CALLED_NUMBER, "CALLED NUMBER", dump_string }, + { IAX_IE_CALLING_NUMBER, "CALLING NUMBER", dump_string }, + { IAX_IE_CALLING_ANI, "ANI", dump_string }, + { IAX_IE_CALLING_NAME, "CALLING NAME", dump_string }, + { IAX_IE_CALLED_CONTEXT, "CALLED CONTEXT", dump_string }, + { IAX_IE_USERNAME, "USERNAME", dump_string }, + { IAX_IE_PASSWORD, "PASSWORD", dump_string }, + { IAX_IE_CAPABILITY, "CAPABILITY", dump_int }, + { IAX_IE_FORMAT, "FORMAT", dump_int }, + { IAX_IE_LANGUAGE, "LANGUAGE", dump_string }, + { IAX_IE_CODEC_PREFS, "CODEC_PREFS", dump_string }, + { IAX_IE_VERSION, "VERSION", dump_short }, + { IAX_IE_ADSICPE, "ADSICPE", dump_short }, + { IAX_IE_DNID, "DNID", dump_string }, + { IAX_IE_AUTHMETHODS, "AUTHMETHODS", dump_short }, + { IAX_IE_CHALLENGE, "CHALLENGE", dump_string }, + { IAX_IE_MD5_RESULT, "MD5 RESULT", dump_string }, + { IAX_IE_RSA_RESULT, "RSA RESULT", dump_string }, + { IAX_IE_APPARENT_ADDR, "APPARENT ADDRESS", dump_addr }, + { IAX_IE_REFRESH, "REFRESH", dump_short }, + { IAX_IE_DPSTATUS, "DIALPLAN STATUS", dump_short }, + { IAX_IE_CALLNO, "CALL NUMBER", dump_short }, + { IAX_IE_CAUSE, "CAUSE", dump_string }, + { IAX_IE_IAX_UNKNOWN, "UNKNOWN IAX CMD", dump_byte }, + { IAX_IE_MSGCOUNT, "MESSAGE COUNT", dump_short }, + { IAX_IE_AUTOANSWER, "AUTO ANSWER REQ" }, + { IAX_IE_TRANSFERID, "TRANSFER ID", dump_int }, + { IAX_IE_RDNIS, "REFERRING DNIS", dump_string }, + { IAX_IE_PROVISIONING, "PROVISIONING", dump_prov }, + { IAX_IE_AESPROVISIONING, "AES PROVISIONG" }, + { IAX_IE_DATETIME, "DATE TIME", dump_int }, + { IAX_IE_DEVICETYPE, "DEVICE TYPE", dump_string }, + { IAX_IE_SERVICEIDENT, "SERVICE IDENT", dump_string }, + { IAX_IE_FIRMWAREVER, "FIRMWARE VER", dump_short }, + { IAX_IE_FWBLOCKDESC, "FW BLOCK DESC", dump_int }, + { IAX_IE_FWBLOCKDATA, "FW BLOCK DATA" }, + { IAX_IE_PROVVER, "PROVISIONG VER", dump_int }, + { IAX_IE_CALLINGPRES, "CALLING PRESNTN", dump_byte }, + { IAX_IE_CALLINGTON, "CALLING TYPEOFNUM", dump_byte }, + { IAX_IE_CALLINGTNS, "CALLING TRANSITNET", dump_short }, + { IAX_IE_SAMPLINGRATE, "SAMPLINGRATE", dump_samprate }, + { IAX_IE_RR_JITTER, "RR_JITTER", dump_int }, + { IAX_IE_RR_LOSS, "RR_LOSS", dump_int }, + { IAX_IE_RR_PKTS, "RR_PKTS", dump_int }, + { IAX_IE_RR_DELAY, "RR_DELAY", dump_short }, + { IAX_IE_RR_DROPPED, "RR_DROPPED", dump_int }, + { IAX_IE_RR_OOO, "RR_OOO", dump_int }, +}; + +const char *iax_ie2str(int ie) +{ + int x; + for (x=0;x<(int)sizeof(ies) / (int)sizeof(ies[0]); x++) { + if (ies[x].ie == ie) + return ies[x].name; + } + return "Unknown IE"; +} + + +static void dump_prov_ies(char *output, int maxlen, unsigned char *iedata, int len) +{ + int ielen; + int ie; + int found; + char tmp[256]; + if (len < 2) + return; + strcpy(output, "\n"); + maxlen -= (int)strlen(output); output += strlen(output); + while(len > 2) { + ie = iedata[0]; + ielen = iedata[1]; + if (ielen + 2> len) { + snprintf(tmp, (int)sizeof(tmp), "Total Prov IE length of %d bytes exceeds remaining prov frame length of %d bytes\n", ielen + 2, len); + strncpy(output, tmp, maxlen - 1); + maxlen -= (int)strlen(output); output += strlen(output); + return; + } + found = 0; + if (!found) { + snprintf(tmp, (int)sizeof(tmp), " Unknown Prov IE %03d : Present\n", ie); + strncpy(output, tmp, maxlen - 1); + maxlen -= (int)strlen(output); output += strlen(output); + } + iedata += (2 + ielen); + len -= (2 + ielen); + } +} + +static void dump_ies(unsigned char *iedata, int len) +{ + int ielen; + int ie; + int x; + int found; + char interp[1024]; + char tmp[1024]; + if (len < 2) + return; + while(len > 2) { + ie = iedata[0]; + ielen = iedata[1]; + if (ielen + 2> len) { + snprintf(tmp, (int)sizeof(tmp), "Total IE length of %d bytes exceeds remaining frame length of %d bytes\n", ielen + 2, len); + outputf(tmp); + return; + } + found = 0; + for (x=0;x<(int)sizeof(ies) / (int)sizeof(ies[0]); x++) { + if (ies[x].ie == ie) { + if (ies[x].dump) { + ies[x].dump(interp, (int)sizeof(interp), iedata + 2, ielen); + snprintf(tmp, (int)sizeof(tmp), " %-15.15s : %s\n", ies[x].name, interp); + outputf(tmp); + } else { + if (ielen) + snprintf(interp, (int)sizeof(interp), "%d bytes", ielen); + else + strcpy(interp, "Present"); + snprintf(tmp, (int)sizeof(tmp), " %-15.15s : %s\n", ies[x].name, interp); + outputf(tmp); + } + found++; + } + } + if (!found) { + snprintf(tmp, (int)sizeof(tmp), " Unknown IE %03d : Present\n", ie); + outputf(tmp); + } + iedata += (2 + ielen); + len -= (2 + ielen); + } + outputf("\n"); +} + +void iax_showframe(struct iax_frame *f, struct ast_iax2_full_hdr *fhi, int rx, struct sockaddr_in *sin, int datalen) +{ + const char *frames[] = { + "(0?)", + "DTMF ", + "VOICE ", + "VIDEO ", + "CONTROL", + "NULL ", + "IAX ", + "TEXT ", + "IMAGE " }; + const char *iaxs[] = { + "(0?)", + "NEW ", + "PING ", + "PONG ", + "ACK ", + "HANGUP ", + "REJECT ", + "ACCEPT ", + "AUTHREQ", + "AUTHREP", + "INVAL ", + "LAGRQ ", + "LAGRP ", + "REGREQ ", + "REGAUTH", + "REGACK ", + "REGREJ ", + "REGREL ", + "VNAK ", + "DPREQ ", + "DPREP ", + "DIAL ", + "TXREQ ", + "TXCNT ", + "TXACC ", + "TXREADY", + "TXREL ", + "TXREJ ", + "QUELCH ", + "UNQULCH", + "POKE", + "PAGE", + "MWI", + "UNSUPPORTED", + "TRANSFER", + "PROVISION", + "FWDOWNLD", + "FWDATA" + }; + const char *cmds[] = { + "(0?)", + "HANGUP ", + "RING ", + "RINGING", + "ANSWER ", + "BUSY ", + "TKOFFHK ", + "OFFHOOK" }; + struct ast_iax2_full_hdr *fh; + char retries[20]; + char class2[20]; + char subclass2[20]; + const char *class; + const char *subclass; + char tmp[256]; + + if (f) { + fh = f->data; + snprintf(retries, (int)sizeof(retries), "%03d", f->retries); + } else { + fh = fhi; + if (ntohs(fh->dcallno) & IAX_FLAG_RETRANS) + strcpy(retries, "Yes"); + else + strcpy(retries, " No"); + } + if (!(ntohs(fh->scallno) & IAX_FLAG_FULL)) { + /* Don't mess with mini-frames */ + return; + } + if (fh->type > (int)sizeof(frames)/(int)sizeof(char *)) { + snprintf(class2, (int)sizeof(class2), "(%d?)", fh->type); + class = class2; + } else { + class = frames[(int)fh->type]; + } + if (fh->type == AST_FRAME_DTMF) { + sprintf(subclass2, "%c", fh->csub); + subclass = subclass2; + } else if (fh->type == AST_FRAME_IAX) { + if (fh->csub >= (int)sizeof(iaxs)/(int)sizeof(iaxs[0])) { + snprintf(subclass2, (int)sizeof(subclass2), "(%d?)", fh->csub); + subclass = subclass2; + } else { + subclass = iaxs[(int)fh->csub]; + } + } else if (fh->type == AST_FRAME_CONTROL) { + if (fh->csub > (int)sizeof(cmds)/(int)sizeof(char *)) { + snprintf(subclass2, (int)sizeof(subclass2), "(%d?)", fh->csub); + subclass = subclass2; + } else { + subclass = cmds[(int)fh->csub]; + } + } else { + snprintf(subclass2, (int)sizeof(subclass2), "%d", fh->csub); + subclass = subclass2; + } +snprintf(tmp, (int)sizeof(tmp), +"%s-Frame Retry[%s] -- OSeqno: %3.3d ISeqno: %3.3d Type: %s Subclass: %s\n", + (rx ? "Rx" : "Tx"), + retries, fh->oseqno, fh->iseqno, class, subclass); + outputf(tmp); +snprintf(tmp, (int)sizeof(tmp), +" Timestamp: %05lums SCall: %5.5d DCall: %5.5d [%s:%d]\n", + (unsigned long)ntohl(fh->ts), + ntohs(fh->scallno) & ~IAX_FLAG_FULL, ntohs(fh->dcallno) & ~IAX_FLAG_RETRANS, + inet_ntoa(sin->sin_addr), ntohs(sin->sin_port)); + outputf(tmp); + if (fh->type == AST_FRAME_IAX) + dump_ies(fh->iedata, datalen); +} + +int iax_ie_append_raw(struct iax_ie_data *ied, unsigned char ie, const void *data, int datalen) +{ + char tmp[256]; + if (datalen > ((int)sizeof(ied->buf) - ied->pos)) { + snprintf(tmp, (int)sizeof(tmp), "Out of space for ie '%s' (%d), need %d have %d\n", iax_ie2str(ie), ie, datalen, (int)sizeof(ied->buf) - ied->pos); + errorf(tmp); + return -1; + } + ied->buf[ied->pos++] = ie; + ied->buf[ied->pos++] = datalen; + memcpy(ied->buf + ied->pos, data, datalen); + ied->pos += datalen; + return 0; +} + +int iax_ie_append_addr(struct iax_ie_data *ied, unsigned char ie, struct sockaddr_in *sin) +{ + return iax_ie_append_raw(ied, ie, sin, (int)sizeof(struct sockaddr_in)); +} + +int iax_ie_append_int(struct iax_ie_data *ied, unsigned char ie, unsigned int value) +{ + unsigned int newval; + newval = htonl(value); + return iax_ie_append_raw(ied, ie, &newval, (int)sizeof(newval)); +} + +int iax_ie_append_short(struct iax_ie_data *ied, unsigned char ie, unsigned short value) +{ + unsigned short newval; + newval = htons(value); + return iax_ie_append_raw(ied, ie, &newval, (int)sizeof(newval)); +} + +int iax_ie_append_str(struct iax_ie_data *ied, unsigned char ie, const unsigned char *str) +{ + return iax_ie_append_raw(ied, ie, str, (int)strlen((char *) str)); +} + +int iax_ie_append_byte(struct iax_ie_data *ied, unsigned char ie, unsigned char dat) +{ + return iax_ie_append_raw(ied, ie, &dat, 1); +} + +int iax_ie_append(struct iax_ie_data *ied, unsigned char ie) +{ + return iax_ie_append_raw(ied, ie, NULL, 0); +} + +void iax_set_output(void (*func)(const char *)) +{ + outputf = func; +} + +void iax_set_error(void (*func)(const char *)) +{ + errorf = func; +} + +int iax_parse_ies(struct iax_ies *ies, unsigned char *data, int datalen) +{ + /* Parse data into information elements */ + int len; + int ie; + char tmp[256]; + memset(ies, 0, (int)sizeof(struct iax_ies)); + ies->msgcount = -1; + ies->firmwarever = -1; + ies->calling_ton = -1; + ies->calling_tns = -1; + ies->calling_pres = -1; + ies->samprate = IAX_RATE_8KHZ; + while(datalen >= 2) { + ie = data[0]; + len = data[1]; + if (len > datalen - 2) { + errorf("Information element length exceeds message size\n"); + return -1; + } + switch(ie) { + case IAX_IE_CALLED_NUMBER: + ies->called_number = (char *) data + 2; + break; + case IAX_IE_CALLING_NUMBER: + ies->calling_number = (char *) data + 2; + break; + case IAX_IE_CALLING_ANI: + ies->calling_ani = (char *) data + 2; + break; + case IAX_IE_CALLING_NAME: + ies->calling_name = (char *) data + 2; + break; + case IAX_IE_CALLED_CONTEXT: + ies->called_context = (char *) data + 2; + break; + case IAX_IE_USERNAME: + ies->username = (char *) data + 2; + break; + case IAX_IE_PASSWORD: + ies->password = (char *) data + 2; + break; + case IAX_IE_CAPABILITY: + if (len != (int)sizeof(unsigned int)) { + snprintf(tmp, (int)sizeof(tmp), "Expecting capability to be %d bytes long but was %d\n", (int)sizeof(unsigned int), len); + errorf(tmp); + } else + ies->capability = ntohl(get_uint32(data + 2)); + break; + case IAX_IE_FORMAT: + if (len != (int)sizeof(unsigned int)) { + snprintf(tmp, (int)sizeof(tmp), "Expecting format to be %d bytes long but was %d\n", (int)sizeof(unsigned int), len); + errorf(tmp); + } else + ies->format = ntohl(get_uint32(data + 2)); + break; + case IAX_IE_LANGUAGE: + ies->language = (char *) data + 2; + break; + case IAX_IE_CODEC_PREFS: + ies->codec_prefs = (char *) data + 2; + break; + case IAX_IE_VERSION: + if (len != (int)sizeof(unsigned short)) { + snprintf(tmp, (int)sizeof(tmp), "Expecting version to be %d bytes long but was %d\n", (int)sizeof(unsigned short), len); + errorf(tmp); + } else + ies->version = ntohs(get_uint16(data + 2)); + break; + case IAX_IE_ADSICPE: + if (len != (int)sizeof(unsigned short)) { + snprintf(tmp, (int)sizeof(tmp), "Expecting adsicpe to be %d bytes long but was %d\n", (int)sizeof(unsigned short), len); + errorf(tmp); + } else + ies->adsicpe = ntohs(get_uint16(data + 2)); + break; + case IAX_IE_SAMPLINGRATE: + if (len != (int)sizeof(unsigned short)) { + snprintf(tmp, (int)sizeof(tmp), "Expecting samplingrate to be %d bytes long but was %d\n", (int)sizeof(unsigned short), len); + errorf(tmp); + } else + ies->samprate = ntohs(get_uint16(data + 2)); + break; + case IAX_IE_DNID: + ies->dnid = (char *) data + 2; + break; + case IAX_IE_RDNIS: + ies->rdnis = (char *) data + 2; + break; + case IAX_IE_AUTHMETHODS: + if (len != (int)sizeof(unsigned short)) { + snprintf(tmp, (int)sizeof(tmp), "Expecting authmethods to be %d bytes long but was %d\n", (int)sizeof(unsigned short), len); + errorf(tmp); + } else + ies->authmethods = ntohs(get_uint16(data + 2)); + break; + case IAX_IE_CHALLENGE: + ies->challenge = (char *) data + 2; + break; + case IAX_IE_MD5_RESULT: + ies->md5_result = (char *) data + 2; + break; + case IAX_IE_RSA_RESULT: + ies->rsa_result = (char *) data + 2; + break; + case IAX_IE_APPARENT_ADDR: + ies->apparent_addr = ((struct sockaddr_in *)(data + 2)); + break; + case IAX_IE_REFRESH: + if (len != (int)sizeof(unsigned short)) { + snprintf(tmp, (int)sizeof(tmp), "Expecting refresh to be %d bytes long but was %d\n", (int)sizeof(unsigned short), len); + errorf(tmp); + } else + ies->refresh = ntohs(get_uint16(data + 2)); + break; + case IAX_IE_DPSTATUS: + if (len != (int)sizeof(unsigned short)) { + snprintf(tmp, (int)sizeof(tmp), "Expecting dpstatus to be %d bytes long but was %d\n", (int)sizeof(unsigned short), len); + errorf(tmp); + } else + ies->dpstatus = ntohs(get_uint16(data + 2)); + break; + case IAX_IE_CALLNO: + if (len != (int)sizeof(unsigned short)) { + snprintf(tmp, (int)sizeof(tmp), "Expecting callno to be %d bytes long but was %d\n", (int)sizeof(unsigned short), len); + errorf(tmp); + } else + ies->callno = ntohs(get_uint16(data + 2)); + break; + case IAX_IE_CAUSE: + ies->cause = (char *) data + 2; + break; + case IAX_IE_CAUSECODE: + if (len != 1) { + snprintf(tmp, (int)sizeof(tmp), "Expecting causecode to be single byte but was %d\n", len); + errorf(tmp); + } else { + ies->causecode = data[2]; + } + break; + case IAX_IE_IAX_UNKNOWN: + if (len == 1) + ies->iax_unknown = data[2]; + else { + snprintf(tmp, (int)sizeof(tmp), "Expected single byte Unknown command, but was %d long\n", len); + errorf(tmp); + } + break; + case IAX_IE_MSGCOUNT: + if (len != (int)sizeof(unsigned short)) { + snprintf(tmp, (int)sizeof(tmp), "Expecting msgcount to be %d bytes long but was %d\n", (int)sizeof(unsigned short), len); + errorf(tmp); + } else + ies->msgcount = ntohs(get_uint16(data + 2)); + break; + case IAX_IE_AUTOANSWER: + ies->autoanswer = 1; + break; + case IAX_IE_MUSICONHOLD: + ies->musiconhold = 1; + break; + case IAX_IE_TRANSFERID: + if (len != (int)sizeof(unsigned int)) { + snprintf(tmp, (int)sizeof(tmp), "Expecting transferid to be %d bytes long but was %d\n", (int)sizeof(unsigned int), len); + errorf(tmp); + } else + ies->transferid = ntohl(get_uint32(data + 2)); + break; + case IAX_IE_DATETIME: + if (len != (int)sizeof(unsigned int)) { + snprintf(tmp, (int)sizeof(tmp), "Expecting date/time to be %d bytes long but was %d\n", (int)sizeof(unsigned int), len); + errorf(tmp); + } else + ies->datetime = ntohl(get_uint32(data + 2)); + break; + case IAX_IE_FIRMWAREVER: + if (len != (int)sizeof(unsigned short)) { + snprintf(tmp, (int)sizeof(tmp), "Expecting firmwarever to be %d bytes long but was %d\n", (int)sizeof(unsigned short), len); + errorf(tmp); + } else + ies->firmwarever = ntohs(get_uint16(data + 2)); + break; + case IAX_IE_DEVICETYPE: + ies->devicetype = (char *) data + 2; + break; + case IAX_IE_SERVICEIDENT: + ies->serviceident = (char *) data + 2; + break; + case IAX_IE_FWBLOCKDESC: + if (len != (int)sizeof(unsigned int)) { + snprintf(tmp, (int)sizeof(tmp), "Expected block desc to be %d bytes long but was %d\n", (int)sizeof(unsigned int), len); + errorf(tmp); + } else + ies->fwdesc = ntohl(get_uint32(data + 2)); + break; + case IAX_IE_FWBLOCKDATA: + ies->fwdata = data + 2; + ies->fwdatalen = len; + break; + case IAX_IE_PROVVER: + if (len != (int)sizeof(unsigned int)) { + snprintf(tmp, (int)sizeof(tmp), "Expected provisioning version to be %d bytes long but was %d\n", (int)sizeof(unsigned int), len); + errorf(tmp); + } else { + ies->provverpres = 1; + ies->provver = ntohl(get_uint32(data + 2)); + } + break; + case IAX_IE_CALLINGPRES: + if (len == 1) + ies->calling_pres = data[2]; + else { + snprintf(tmp, (int)sizeof(tmp), "Expected single byte callingpres, but was %d long\n", len); + errorf(tmp); + } + break; + case IAX_IE_CALLINGTON: + if (len == 1) + ies->calling_ton = data[2]; + else { + snprintf(tmp, (int)sizeof(tmp), "Expected single byte callington, but was %d long\n", len); + errorf(tmp); + } + break; + case IAX_IE_CALLINGTNS: + if (len != (int)sizeof(unsigned short)) { + snprintf(tmp, (int)sizeof(tmp), "Expecting callingtns to be %d bytes long but was %d\n", (int)sizeof(unsigned short), len); + errorf(tmp); + } else + ies->calling_tns = ntohs(get_uint16(data + 2)); + break; + case IAX_IE_RR_JITTER: + if (len != (int)sizeof(unsigned int)) { + snprintf(tmp, (int)sizeof(tmp), "Expected jitter rr to be %d bytes long but was %d\n", (int)sizeof(unsigned int), len); + errorf(tmp); + } else { + ies->rr_jitter = ntohl(get_uint32(data + 2)); + } + break; + case IAX_IE_RR_LOSS: + if (len != (int)sizeof(unsigned int)) { + snprintf(tmp, (int)sizeof(tmp), "Expected loss rr to be %d bytes long but was %d\n", (int)sizeof(unsigned int), len); + errorf(tmp); + } else { + ies->rr_loss = ntohl(get_uint32(data + 2)); + } + break; + case IAX_IE_RR_PKTS: + if (len != (int)sizeof(unsigned int)) { + snprintf(tmp, (int)sizeof(tmp), "Expected packets rr to be %d bytes long but was %d\n", (int)sizeof(unsigned int), len); + errorf(tmp); + } else { + ies->rr_pkts = ntohl(get_uint32(data + 2)); + } + break; + case IAX_IE_RR_DELAY: + if (len != (int)sizeof(unsigned short)) { + snprintf(tmp, (int)sizeof(tmp), "Expected loss rr to be %d bytes long but was %d\n", (int)sizeof(unsigned short), len); + errorf(tmp); + } else { + ies->rr_delay = ntohs(get_uint16(data + 2)); + } + break; + case IAX_IE_RR_DROPPED: + if (len != (int)sizeof(unsigned int)) { + snprintf(tmp, (int)sizeof(tmp), "Expected packets rr to be %d bytes long but was %d\n", (int)sizeof(unsigned int), len); + errorf(tmp); + } else { + ies->rr_dropped = ntohl(get_uint32(data + 2)); + } + break; + case IAX_IE_RR_OOO: + if (len != (int)sizeof(unsigned int)) { + snprintf(tmp, (int)sizeof(tmp), "Expected packets rr to be %d bytes long but was %d\n", (int)sizeof(unsigned int), len); + errorf(tmp); + } else { + ies->rr_ooo = ntohl(get_uint32(data + 2)); + } + break; + default: + snprintf(tmp, (int)sizeof(tmp), "Ignoring unknown information element '%s' (%d) of length %d\n", iax_ie2str(ie), ie, len); + outputf(tmp); + } + /* Overwrite information element with 0, to null terminate previous portion */ + data[0] = 0; + datalen -= (len + 2); + data += (len + 2); + } + /* Null-terminate last field */ + *data = '\0'; + if (datalen) { + errorf("Invalid information element contents, strange boundary\n"); + return -1; + } + return 0; +} + +void iax_frame_wrap(struct iax_frame *fr, struct ast_frame *f) +{ + fr->af.frametype = f->frametype; + fr->af.subclass = f->subclass; + fr->af.mallocd = 0; /* Our frame is static relative to the container */ + fr->af.datalen = f->datalen; + fr->af.samples = f->samples; + fr->af.offset = AST_FRIENDLY_OFFSET; + fr->af.src = f->src; + fr->af.data = fr->afdata; + if (fr->af.datalen) + memcpy(fr->af.data, f->data, fr->af.datalen); +} + +struct iax_frame *iax_frame_new(int direction, int datalen) +{ + struct iax_frame *fr; + fr = malloc((int)sizeof(struct iax_frame) + datalen); + if (fr) { + fr->direction = direction; + fr->retrans = -1; + frames++; + if (fr->direction == DIRECTION_INGRESS) + iframes++; + else + oframes++; + } + return fr; +} + +void iax_frame_free(struct iax_frame *fr) +{ + /* Note: does not remove from scheduler! */ + if (fr->direction == DIRECTION_INGRESS) + iframes--; + else if (fr->direction == DIRECTION_OUTGRESS) + oframes--; + else { + errorf("Attempt to double free frame detected\n"); + return; + } + fr->direction = 0; + free(fr); + frames--; +} + +int iax_get_frames(void) { return frames; } +int iax_get_iframes(void) { return iframes; } +int iax_get_oframes(void) { return oframes; } Added: freeswitch/trunk/src/mod/endpoints/mod_iax/iax2-parser.h ============================================================================== --- (empty file) +++ freeswitch/trunk/src/mod/endpoints/mod_iax/iax2-parser.h Thu May 8 19:25:36 2008 @@ -0,0 +1,145 @@ +/* + * Asterisk -- A telephony toolkit for Linux. + * + * Implementation of Inter-Asterisk eXchange + * + * Copyright (C) 2003, Digium + * + * Mark Spencer <markster@digium.com> + * + * This program is free software, distributed under the terms of + * the GNU Lesser (Library) General Public License + */ + +#ifndef _IAX2_PARSER_H +#define _IAX2_PARSER_H + +struct iax_ies { + char *called_number; + char *calling_number; + char *calling_ani; + char *calling_name; + int calling_ton; + int calling_tns; + int calling_pres; + char *called_context; + char *username; + char *password; + unsigned int capability; + unsigned int format; + char *codec_prefs; + char *language; + int version; + unsigned short adsicpe; + char *dnid; + char *rdnis; + unsigned int authmethods; + char *challenge; + char *md5_result; + char *rsa_result; + struct sockaddr_in *apparent_addr; + unsigned short refresh; + unsigned short dpstatus; + unsigned short callno; + char *cause; + unsigned char causecode; + unsigned char iax_unknown; + int msgcount; + int autoanswer; + int musiconhold; + unsigned int transferid; + unsigned int datetime; + char *devicetype; + char *serviceident; + int firmwarever; + unsigned int fwdesc; + unsigned char *fwdata; + unsigned char fwdatalen; + unsigned int provver; + unsigned short samprate; + unsigned int provverpres; + unsigned int rr_jitter; + unsigned int rr_loss; + unsigned int rr_pkts; + unsigned short rr_delay; + unsigned int rr_dropped; + unsigned int rr_ooo; +}; + +#define DIRECTION_INGRESS 1 +#define DIRECTION_OUTGRESS 2 + +struct iax_frame { +#ifdef LIBIAX + struct iax_session *session; + struct iax_event *event; +#endif + + /* /Our/ call number */ + unsigned short callno; + /* /Their/ call number */ + unsigned short dcallno; + /* Start of raw frame (outgoing only) */ + void *data; + /* Length of frame (outgoing only) */ + int datalen; + /* How many retries so far? */ + int retries; + /* Outgoing relative timestamp (ms) */ + time_in_ms_t ts; + /* How long to wait before retrying */ + time_in_ms_t retrytime; + /* Are we received out of order? */ + int outoforder; + /* Have we been sent at all yet? */ + int sentyet; + /* Outgoing Packet sequence number */ + int oseqno; + /* Next expected incoming packet sequence number */ + int iseqno; + /* Non-zero if should be sent to transfer peer */ + int transfer; + /* Non-zero if this is the final message */ + int final; + /* Ingress or outgres */ + int direction; + /* Retransmission ID */ + int retrans; + /* Easy linking */ + struct iax_frame *next; + struct iax_frame *prev; + /* Actual, isolated frame header */ + struct ast_frame af; + unsigned char unused[AST_FRIENDLY_OFFSET]; + unsigned char afdata[]; /* Data for frame */ +}; + +struct iax_ie_data { + unsigned char buf[1024]; + int pos; +}; + +/* Choose a different function for output */ +extern void iax_set_output(void (*output)(const char *data)); +/* Choose a different function for errors */ +extern void iax_set_error(void (*output)(const char *data)); +extern void iax_showframe(struct iax_frame *f, struct ast_iax2_full_hdr *fhi, int rx, struct sockaddr_in *sin, int datalen); + +extern const char *iax_ie2str(int ie); + +extern int iax_ie_append_raw(struct iax_ie_data *ied, unsigned char ie, const void *data, int datalen); +extern int iax_ie_append_addr(struct iax_ie_data *ied, unsigned char ie, struct sockaddr_in *sin); +extern int iax_ie_append_int(struct iax_ie_data *ied, unsigned char ie, unsigned int value); +extern int iax_ie_append_short(struct iax_ie_data *ied, unsigned char ie, unsigned short value); +extern int iax_ie_append_str(struct iax_ie_data *ied, unsigned char ie, const unsigned char *str); +extern int iax_ie_append_byte(struct iax_ie_data *ied, unsigned char ie, unsigned char dat); +extern int iax_ie_append(struct iax_ie_data *ied, unsigned char ie); +extern int iax_parse_ies(struct iax_ies *ies, unsigned char *data, int datalen); + +extern int iax_get_frames(void); +extern int iax_get_iframes(void); +extern int iax_get_oframes(void); +extern void iax_frame_wrap(struct iax_frame *fr, struct ast_frame *f); +extern struct iax_frame *iax_frame_new(int direction, int datalen); +extern void iax_frame_free(struct iax_frame *fr); +#endif Added: freeswitch/trunk/src/mod/endpoints/mod_iax/iax2.h ============================================================================== --- (empty file) +++ freeswitch/trunk/src/mod/endpoints/mod_iax/iax2.h Thu May 8 19:25:36 2008 @@ -0,0 +1,236 @@ +/* + * Asterisk -- A telephony toolkit for Linux. + * + * Implementation of Inter-Asterisk eXchange + * + * Copyright (C) 2003, Digium + * + * Mark Spencer <markster@linux-support.net> + * + * This program is free software, distributed under the terms of + * the GNU Lesser (Library) General Public License + */ + +#ifndef _IAX2_H +#define _IAX2_H + +typedef long long time_in_ms_t; +#define iax_abs(x) ((x) >= 0 ? (x) : -(x)) + +/* Max version of IAX protocol we support */ +#define IAX_PROTO_VERSION 2 + +#define IAX_MAX_CALLS 32768 + +#define IAX_FLAG_FULL 0x8000 + +#define IAX_FLAG_RETRANS 0x8000 + +#define IAX_FLAG_SC_LOG 0x80 + +#define IAX_MAX_SHIFT 0x1F + +#define IAX_WINDOW 64 + +/* Subclass for AST_FRAME_IAX */ +#define IAX_COMMAND_NEW 1 +#define IAX_COMMAND_PING 2 +#define IAX_COMMAND_PONG 3 +#define IAX_COMMAND_ACK 4 +#define IAX_COMMAND_HANGUP 5 +#define IAX_COMMAND_REJECT 6 +#define IAX_COMMAND_ACCEPT 7 +#define IAX_COMMAND_AUTHREQ 8 +#define IAX_COMMAND_AUTHREP 9 +#define IAX_COMMAND_INVAL 10 +#define IAX_COMMAND_LAGRQ 11 +#define IAX_COMMAND_LAGRP 12 +#define IAX_COMMAND_REGREQ 13 /* Registration request */ +#define IAX_COMMAND_REGAUTH 14 /* Registration authentication required */ +#define IAX_COMMAND_REGACK 15 /* Registration accepted */ +#define IAX_COMMAND_REGREJ 16 /* Registration rejected */ +#define IAX_COMMAND_REGREL 17 /* Force release of registration */ +#define IAX_COMMAND_VNAK 18 /* If we receive voice before valid first voice frame, send this */ +#define IAX_COMMAND_DPREQ 19 /* Request status of a dialplan entry */ +#define IAX_COMMAND_DPREP 20 /* Request status of a dialplan entry */ +#define IAX_COMMAND_DIAL 21 /* Request a dial on channel brought up TBD */ +#define IAX_COMMAND_TXREQ 22 /* Transfer Request */ +#define IAX_COMMAND_TXCNT 23 /* Transfer Connect */ +#define IAX_COMMAND_TXACC 24 /* Transfer Accepted */ +#define IAX_COMMAND_TXREADY 25 /* Transfer ready */ +#define IAX_COMMAND_TXREL 26 /* Transfer release */ +#define IAX_COMMAND_TXREJ 27 /* Transfer reject */ +#define IAX_COMMAND_QUELCH 28 /* Stop audio/video transmission */ +#define IAX_COMMAND_UNQUELCH 29 /* Resume audio/video transmission */ +#define IAX_COMMAND_POKE 30 /* Like ping, but does not require an open connection */ +#define IAX_COMMAND_PAGE 31 /* Paging description */ +#define IAX_COMMAND_MWI 32 /* Stand-alone message waiting indicator */ +#define IAX_COMMAND_UNSUPPORT 33 /* Unsupported message received */ +#define IAX_COMMAND_TRANSFER 34 /* Request remote transfer */ +#define IAX_COMMAND_PROVISION 35 /* Provision device */ +#define IAX_COMMAND_FWDOWNL 36 /* Download firmware */ +#define IAX_COMMAND_FWDATA 37 /* Firmware Data */ + +#define IAX_DEFAULT_REG_EXPIRE 60 /* By default require re-registration once per minute */ + +#define IAX_LINGER_TIMEOUT 10 /* How long to wait before closing bridged call */ + +#define IAX_DEFAULT_PORTNO 4569 + +/* IAX Information elements */ +#define IAX_IE_CALLED_NUMBER 1 /* Number/extension being called - string */ +#define IAX_IE_CALLING_NUMBER 2 /* Calling number - string */ +#define IAX_IE_CALLING_ANI 3 /* Calling number ANI for billing - string */ +#define IAX_IE_CALLING_NAME 4 /* Name of caller - string */ +#define IAX_IE_CALLED_CONTEXT 5 /* Context for number - string */ +#define IAX_IE_USERNAME 6 /* Username (peer or user) for authentication - string */ +#define IAX_IE_PASSWORD 7 /* Password for authentication - string */ +#define IAX_IE_CAPABILITY 8 /* Actual codec capability - unsigned int */ +#define IAX_IE_FORMAT 9 /* Desired codec format - unsigned int */ +#define IAX_IE_LANGUAGE 10 /* Desired language - string */ +#define IAX_IE_VERSION 11 /* Protocol version - short */ +#define IAX_IE_ADSICPE 12 /* CPE ADSI capability - short */ +#define IAX_IE_DNID 13 /* Originally dialed DNID - string */ +#define IAX_IE_AUTHMETHODS 14 /* Authentication method(s) - short */ +#define IAX_IE_CHALLENGE 15 /* Challenge data for MD5/RSA - string */ +#define IAX_IE_MD5_RESULT 16 /* MD5 challenge result - string */ +#define IAX_IE_RSA_RESULT 17 /* RSA challenge result - string */ +#define IAX_IE_APPARENT_ADDR 18 /* Apparent address of peer - struct sockaddr_in */ +#define IAX_IE_REFRESH 19 /* When to refresh registration - short */ +#define IAX_IE_DPSTATUS 20 /* Dialplan status - short */ +#define IAX_IE_CALLNO 21 /* Call number of peer - short */ +#define IAX_IE_CAUSE 22 /* Cause - string */ +#define IAX_IE_IAX_UNKNOWN 23 /* Unknown IAX command - byte */ +#define IAX_IE_MSGCOUNT 24 /* How many messages waiting - short */ +#define IAX_IE_AUTOANSWER 25 /* Request auto-answering -- none */ +#define IAX_IE_MUSICONHOLD 26 /* Request musiconhold with QUELCH -- none or string */ +#define IAX_IE_TRANSFERID 27 /* Transfer Request Identifier -- int */ +#define IAX_IE_RDNIS 28 /* Referring DNIS -- string */ +#define IAX_IE_PROVISIONING 29 /* Provisioning info */ +#define IAX_IE_AESPROVISIONING 30 /* AES Provisioning info */ +#define IAX_IE_DATETIME 31 /* Date/Time */ +#define IAX_IE_DEVICETYPE 32 /* Device Type -- string */ +#define IAX_IE_SERVICEIDENT 33 /* Service Identifier -- string */ +#define IAX_IE_FIRMWAREVER 34 /* Firmware revision -- u16 */ +#define IAX_IE_FWBLOCKDESC 35 /* Firmware block description -- u32 */ +#define IAX_IE_FWBLOCKDATA 36 /* Firmware block of data -- raw */ +#define IAX_IE_PROVVER 37 /* Provisioning Version (u32) */ +#define IAX_IE_CALLINGPRES 38 /* Calling presentation (u8) */ +#define IAX_IE_CALLINGTON 39 /* Calling type of number (u8) */ +#define IAX_IE_CALLINGTNS 40 /* Calling transit network select (u16) */ +#define IAX_IE_SAMPLINGRATE 41 /* Supported sampling rates (u16) */ +#define IAX_IE_CAUSECODE 42 /* Hangup cause (u8) */ +#define IAX_IE_ENCRYPTION 43 /* Encryption format (u16) */ +#define IAX_IE_ENCKEY 44 /* Encryption key (raw) */ +#define IAX_IE_CODEC_PREFS 45 /* Codec Negotiation */ + +#define IAX_IE_RR_JITTER 46 /* Received jitter (as in RFC1889) u32 */ +#define IAX_IE_RR_LOSS 47 /* Received loss (high byte loss pct, low 24 bits loss count, as in rfc1889 */ +#define IAX_IE_RR_PKTS 48 /* Received frames (total frames received) u32 */ +#define IAX_IE_RR_DELAY 49 /* Max playout delay for received frames (in ms) u16 */ +#define IAX_IE_RR_DROPPED 50 /* Dropped frames (presumably by jitterbuf) u32 */ +#define IAX_IE_RR_OOO 51 /* Frames received Out of Order u32 */ + + + +#define IAX_AUTH_PLAINTEXT (1 << 0) +#define IAX_AUTH_MD5 (1 << 1) +#define IAX_AUTH_RSA (1 << 2) + +#define IAX_META_TRUNK 1 /* Trunk meta-message */ +#define IAX_META_VIDEO 2 /* Video frame */ + +#define IAX_RATE_8KHZ (1 << 0) /* 8khz sampling (default if absent) */ +#define IAX_RATE_11KHZ (1 << 1) /* 11.025khz sampling */ +#define IAX_RATE_16KHZ (1 << 2) /* 16khz sampling */ +#define IAX_RATE_22KHZ (1 << 3) /* 22.05khz sampling */ +#define IAX_RATE_44KHZ (1 << 4) /* 44.1khz sampling */ +#define IAX_RATE_48KHZ (1 << 5) /* 48khz sampling */ +#define IAX_RATE_32KHZ (1 << 6) /* 32khz sampling */ + +#define IAX_DPSTATUS_EXISTS (1 << 0) +#define IAX_DPSTATUS_CANEXIST (1 << 1) +#define IAX_DPSTATUS_NONEXISTANT (1 << 2) +#define IAX_DPSTATUS_IGNOREPAT (1 << 14) +#define IAX_DPSTATUS_MATCHMORE (1 << 15) + +#if defined __GNUC__ +#define __PACKED __attribute__ ((__packed__)) +#else +#if defined (_MSC_VER) +#pragma pack(push,1) +#define __PACKED +#else +#pragma pack(1) +#define __PACKED +#endif +#endif + +/* Full frames are always delivered reliably */ +struct ast_iax2_full_hdr { + unsigned short scallno; /* Source call number -- high bit must be 1 */ + unsigned short dcallno; /* Destination call number -- high bit is 1 if retransmission */ + unsigned int ts; /* 32-bit timestamp in milliseconds (from 1st transmission) */ + unsigned char oseqno; /* Packet number (outgoing) */ + unsigned char iseqno; /* Packet number (next incoming expected) */ + char type; /* Frame type */ + unsigned char csub; /* Compressed subclass */ + unsigned char iedata[]; +} __PACKED; + +/* Mini header is used only for voice frames -- delivered unreliably */ +struct ast_iax2_mini_hdr { + unsigned short callno; /* Source call number -- high bit must be 0, rest must be non-zero */ + unsigned short ts; /* 16-bit Timestamp (high 16 bits from last ast_iax2_full_hdr) */ + /* Frametype implicitly VOICE_FRAME */ + /* subclass implicit from last ast_iax2_full_hdr */ + unsigned char data[]; +} __PACKED; + +struct ast_iax2_meta_hdr { + unsigned short zeros; /* Zeros field -- must be zero */ + unsigned char metacmd; /* Meta command */ + unsigned char cmddata; /* Command Data */ + unsigned char data[]; +} __PACKED; + +struct ast_iax2_video_hdr { + unsigned short zeros; /* Zeros field -- must be zero */ + unsigned short callno; /* Video call number */ + unsigned short ts; /* Timestamp and mark if present */ + unsigned char data[]; +} __PACKED; + +struct ast_iax2_meta_trunk_hdr { + unsigned int ts; /* 32-bit timestamp for all messages */ + unsigned char data[]; +} __PACKED; + +struct ast_iax2_meta_trunk_entry { + unsigned short callno; /* Call number */ + unsigned short len; /* Length of data for this callno */ +} __PACKED; + +#define IAX_FIRMWARE_MAGIC 0x69617879 + +struct ast_iax2_firmware_header { + unsigned int magic; /* Magic number */ + unsigned short version; /* Software version */ + unsigned char devname[16]; /* Device */ + unsigned int datalen; /* Data length of file beyond header */ + unsigned char chksum[16]; /* Checksum of all data */ + unsigned char data[]; +} __PACKED; + + +#ifdef _MSC_VER +#pragma pack(pop) +#else +#ifndef __GNUC__ +#pragma pack() +#endif +#endif + +#undef __PACKED + +#endif Added: freeswitch/trunk/src/mod/endpoints/mod_iax/jitterbuf.c ============================================================================== --- (empty file) +++ freeswitch/trunk/src/mod/endpoints/mod_iax/jitterbuf.c Thu May 8 19:25:36 2008 @@ -0,0 +1,834 @@ +/* + * jitterbuf: an application-independent jitterbuffer + * + * Copyrights: + * Copyright (C) 2004-2005, Horizon Wimba, Inc. + * + * Contributors: + * Steve Kann <stevek@stevek.com> + * + * This program is free software, distributed under the terms of + * the GNU Lesser (Library) General Public License + * + * Copyright on this file is disclaimed to Digium for inclusion in Asterisk + */ + +#include "iax2.h" +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <sys/types.h> + +#include "jitterbuf.h" + +/* define these here, just for ancient compiler systems */ +#define JB_LONGMAX 2147483647L +#define JB_LONGMIN (-JB_LONGMAX - 1L) + +/* MS VC can't do __VA_ARGS__ */ +#if (defined(WIN32) || defined(_WIN32_WCE)) && defined(_MSC_VER) +#define jb_warn if (warnf) warnf +#define jb_err if (errf) errf +#define jb_dbg if (dbgf) dbgf + +#ifdef DEEP_DEBUG + #define jb_dbg2 if (dbgf) dbgf +#else + #define jb_dbg2 if (0) dbgf +#endif + +#else + +#define jb_warn(...) (warnf ? warnf(__VA_ARGS__) : (void)0) +#define jb_err(...) (errf ? errf(__VA_ARGS__) : (void)0) +#define jb_dbg(...) (dbgf ? dbgf(__VA_ARGS__) : (void)0) + +#ifdef DEEP_DEBUG +#define jb_dbg2(...) (dbgf ? dbgf(__VA_ARGS__) : (void)0) +#else +#define jb_dbg2(...) ((void)0) +#endif + +#endif + +static jb_output_function_t warnf, errf, dbgf; + +void jb_setoutput(jb_output_function_t err, jb_output_function_t warn, jb_output_function_t dbg) +{ + errf = err; + warnf = warn; + dbgf = dbg; +} + +static void increment_losspct(jitterbuf *jb) +{ + jb->info.losspct = (100000 + 499 * jb->info.losspct)/500; +} + +static void decrement_losspct(jitterbuf *jb) +{ + jb->info.losspct = (499 * jb->info.losspct)/500; +} + +void jb_reset(jitterbuf *jb) +{ + /* only save settings */ + jb_conf s = jb->info.conf; + memset(jb, 0, sizeof(*jb)); + jb->info.conf = s; + + /* initialize length, using the configured value */ + jb->info.current = jb->info.target = jb->info.conf.target_extra; + jb->info.silence_begin_ts = -1; +} + +jitterbuf * jb_new() +{ + jitterbuf *jb; + + if (!(jb = (jitterbuf *)malloc(sizeof(*jb)))) + return NULL; + + jb->info.conf.target_extra = JB_TARGET_EXTRA; + + jb_reset(jb); + + jb_dbg2("jb_new() = %x\n", jb); + return jb; +} + +void jb_destroy(jitterbuf *jb) +{ + jb_frame *frame; + jb_dbg2("jb_destroy(%x)\n", jb); + + /* free all the frames on the "free list" */ + frame = jb->free; + while (frame != NULL) { + jb_frame *next = frame->next; + free(frame); + frame = next; + } + + /* free ourselves! */ + free(jb); +} + + + +#if 0 +static int longcmp(const void *a, const void *b) +{ + return *(long *)a - *(long *)b; +} +#endif + +/* simple history manipulation */ +/* maybe later we can make the history buckets variable size, or something? */ +/* drop parameter determines whether we will drop outliers to minimize + * delay */ +static int history_put(jitterbuf *jb, time_in_ms_t ts, time_in_ms_t now, long ms) +{ + time_in_ms_t delay = now - (ts - jb->info.resync_offset); + time_in_ms_t threshold = 2 * jb->info.jitter + jb->info.conf.resync_threshold; + time_in_ms_t kicked; + + /* don't add special/negative times to history */ + if (ts <= 0) + return 0; + + /* check for drastic change in delay */ + if (jb->info.conf.resync_threshold != -1) { + if (iax_abs(delay - jb->info.last_delay) > threshold) { + jb->info.cnt_delay_discont++; + if (jb->info.cnt_delay_discont > 3) { + /* resync the jitterbuffer */ + jb->info.cnt_delay_discont = 0; + jb->hist_ptr = 0; + jb->hist_maxbuf_valid = 0; + + jb_warn("Resyncing the jb. last_delay %ld, this delay %ld, threshold %ld, new offset %ld\n", jb->info.last_delay, delay, threshold, ts - now); + jb->info.resync_offset = ts - now; + jb->info.last_delay = delay = 0; /* after resync, frame is right on time */ + } else { + return -1; + } + } else { + jb->info.last_delay = delay; + jb->info.cnt_delay_discont = 0; + } + } + + kicked = jb->history[jb->hist_ptr % JB_HISTORY_SZ]; + + jb->history[(jb->hist_ptr++) % JB_HISTORY_SZ] = delay; + + /* optimization; the max/min buffers don't need to be recalculated, + * if this packet's entry doesn't change them. This happens if this + * packet is not involved, _and_ any packet that got kicked out of + * the history is also not involved. We do a number of comparisons, + * but it's probably still worthwhile, because it will usually + * succeed, and should be a lot faster than going through all 500 + * packets in history */ + if (!jb->hist_maxbuf_valid) + return 0; + + /* don't do this until we've filled history + * (reduces some edge cases below) */ + if (jb->hist_ptr < JB_HISTORY_SZ) + goto invalidate; + + /* if the new delay would go into min */ + if (delay < jb->hist_minbuf[JB_HISTORY_MAXBUF_SZ-1]) + goto invalidate; + + /* or max.. */ + if (delay > jb->hist_maxbuf[JB_HISTORY_MAXBUF_SZ-1]) + goto invalidate; + + /* or the kicked delay would be in min */ + if (kicked <= jb->hist_minbuf[JB_HISTORY_MAXBUF_SZ-1]) + goto invalidate; + + if (kicked >= jb->hist_maxbuf[JB_HISTORY_MAXBUF_SZ-1]) + goto invalidate; + + /* if we got here, we don't need to invalidate, 'cause this delay didn't + * affect things */ + return 0; + /* end optimization */ + + +invalidate: + jb->hist_maxbuf_valid = 0; + return 0; +} + +static void history_calc_maxbuf(jitterbuf *jb) +{ + int i,j; + + if (jb->hist_ptr == 0) + return; + + + /* initialize maxbuf/minbuf to the latest value */ + for (i=0;i<JB_HISTORY_MAXBUF_SZ;i++) { + /* + * jb->hist_maxbuf[i] = jb->history[(jb->hist_ptr-1) % JB_HISTORY_SZ]; + * jb->hist_minbuf[i] = jb->history[(jb->hist_ptr-1) % JB_HISTORY_SZ]; + */ + jb->hist_maxbuf[i] = JB_LONGMIN; + jb->hist_minbuf[i] = JB_LONGMAX; + } + + /* use insertion sort to populate maxbuf */ + /* we want it to be the top "n" values, in order */ + + /* start at the beginning, or JB_HISTORY_SZ frames ago */ + i = (jb->hist_ptr > JB_HISTORY_SZ) ? (jb->hist_ptr - JB_HISTORY_SZ) : 0; + + for (;i<jb->hist_ptr;i++) { + time_in_ms_t toins = jb->history[i % JB_HISTORY_SZ]; + + /* if the maxbuf should get this */ + if (toins > jb->hist_maxbuf[JB_HISTORY_MAXBUF_SZ-1]) { + + /* insertion-sort it into the maxbuf */ + for (j=0;j<JB_HISTORY_MAXBUF_SZ;j++) { + /* found where it fits */ + if (toins > jb->hist_maxbuf[j]) { + /* move over */ + memmove(jb->hist_maxbuf + j + 1, jb->hist_maxbuf + j, (JB_HISTORY_MAXBUF_SZ - (j + 1)) * sizeof(jb->hist_maxbuf[0])); + /* insert */ + jb->hist_maxbuf[j] = toins; + + break; + } + } + } + + /* if the minbuf should get this */ + if (toins < jb->hist_minbuf[JB_HISTORY_MAXBUF_SZ-1]) { + + /* insertion-sort it into the maxbuf */ + for (j=0;j<JB_HISTORY_MAXBUF_SZ;j++) { + /* found where it fits */ + if (toins < jb->hist_minbuf[j]) { + /* move over */ + memmove(jb->hist_minbuf + j + 1, jb->hist_minbuf + j, (JB_HISTORY_MAXBUF_SZ - (j + 1)) * sizeof(jb->hist_minbuf[0])); + /* insert */ + jb->hist_minbuf[j] = toins; + + break; + } + } + } + +#if 0 + int k; + fprintf(stderr, "toins = %ld\n", toins); + fprintf(stderr, "maxbuf ="); + for (k=0;k<JB_HISTORY_MAXBUF_SZ;k++) + fprintf(stderr, "%ld ", jb->hist_maxbuf[k]); + fprintf(stderr, "\nminbuf ="); + for (k=0;k<JB_HISTORY_MAXBUF_SZ;k++) + fprintf(stderr, "%ld ", jb->hist_minbuf[k]); + fprintf(stderr, "\n"); +#endif + } + + jb->hist_maxbuf_valid = 1; +} + +static void history_get(jitterbuf *jb) +{ + time_in_ms_t max, min, jitter; + int index; + int count; + + if (!jb->hist_maxbuf_valid) + history_calc_maxbuf(jb); + + /* count is how many items in history we're examining */ + count = (jb->hist_ptr < JB_HISTORY_SZ) ? jb->hist_ptr : JB_HISTORY_SZ; + + /* index is the "n"ths highest/lowest that we'll look for */ + index = count * JB_HISTORY_DROPPCT / 100; + + /* sanity checks for index */ + if (index > (JB_HISTORY_MAXBUF_SZ - 1)) + index = JB_HISTORY_MAXBUF_SZ - 1; + + + if (index < 0) { + jb->info.min = 0; + jb->info.jitter = 0; + return; + } + + max = jb->hist_maxbuf[index]; + min = jb->hist_minbuf[index]; + + jitter = max - min; + + /* these debug stmts compare the difference between looking at the absolute jitter, and the + * values we get by throwing away the outliers */ + /* + fprintf(stderr, "[%d] min=%d, max=%d, jitter=%d\n", index, min, max, jitter); + fprintf(stderr, "[%d] min=%d, max=%d, jitter=%d\n", 0, jb->hist_minbuf[0], jb->hist_maxbuf[0], jb->hist_maxbuf[0]-jb->hist_minbuf[0]); + */ + + jb->info.min = min; + jb->info.jitter = jitter; +} + +/* returns 1 if frame was inserted into head of queue, 0 otherwise */ +static int queue_put(jitterbuf *jb, void *data, const enum jb_frame_type type, long ms, time_in_ms_t ts) +{ + jb_frame *frame; + jb_frame *p; + int head = 0; + time_in_ms_t resync_ts = ts - jb->info.resync_offset; + + if ((frame = jb->free)) { + jb->free = frame->next; + } else if (!(frame = (jb_frame *)malloc(sizeof(*frame)))) { + jb_err("cannot allocate frame\n"); + return 0; + } + + jb->info.frames_cur++; + + frame->data = data; + frame->ts = resync_ts; + frame->ms = ms; + frame->type = type; + + /* + * frames are a circular list, jb-frames points to to the lowest ts, + * jb->frames->prev points to the highest ts + */ + + if (!jb->frames) { /* queue is empty */ + jb->frames = frame; + frame->next = frame; + frame->prev = frame; + head = 1; + } else if (resync_ts < jb->frames->ts) { + frame->next = jb->frames; + frame->prev = jb->frames->prev; + + frame->next->prev = frame; + frame->prev->next = frame; + + /* frame is out of order */ + jb->info.frames_ooo++; + + jb->frames = frame; + head = 1; + } else { + p = jb->frames; + + /* frame is out of order */ + if (resync_ts < p->prev->ts) jb->info.frames_ooo++; + + while (resync_ts < p->prev->ts && p->prev != jb->frames) + p = p->prev; + + frame->next = p; + frame->prev = p->prev; + + frame->next->prev = frame; + frame->prev->next = frame; + } + return head; +} + +static time_in_ms_t queue_next(jitterbuf *jb) +{ + if (jb->frames) + return jb->frames->ts; + else + return -1; +} + +static time_in_ms_t queue_last(jitterbuf *jb) +{ + if (jb->frames) + return jb->frames->prev->ts; + else + return -1; +} + +static jb_frame *_queue_get(jitterbuf *jb, time_in_ms_t ts, int all) +{ + jb_frame *frame; + frame = jb->frames; + + if (!frame) + return NULL; + + /*jb_warn("queue_get: ASK %ld FIRST %ld\n", ts, frame->ts); */ + + if (all || ts >= frame->ts) { + /* remove this frame */ + frame->prev->next = frame->next; + frame->next->prev = frame->prev; + + if (frame->next == frame) + jb->frames = NULL; + else + jb->frames = frame->next; + + + /* insert onto "free" single-linked list */ + frame->next = jb->free; + jb->free = frame; + + jb->info.frames_cur--; + + /* we return the frame pointer, even though it's on free list, + * but caller must copy data */ + return frame; + } + + return NULL; +} + +static jb_frame *queue_get(jitterbuf *jb, time_in_ms_t ts) +{ + return _queue_get(jb,ts,0); +} + +static jb_frame *queue_getall(jitterbuf *jb) +{ + return _queue_get(jb,0,1); +} + +#if 0 +/* some diagnostics */ +static void jb_dbginfo(jitterbuf *jb) +{ + if (dbgf == NULL) + return; + + jb_dbg("\njb info: fin=%ld fout=%ld flate=%ld flost=%ld fdrop=%ld fcur=%ld\n", + jb->info.frames_in, jb->info.frames_out, jb->info.frames_late, jb->info.frames_lost, jb->info.frames_dropped, jb->info.frames_cur); + + jb_dbg("jitter=%ld current=%ld target=%ld min=%ld sil=%d len=%d len/fcur=%ld\n", + jb->info.jitter, jb->info.current, jb->info.target, jb->info.min, jb->info.silence_begin_ts, jb->info.current - jb->info.min, + jb->info.frames_cur ? (jb->info.current - jb->info.min)/jb->info.frames_cur : -8); + if (jb->info.frames_in > 0) + jb_dbg("jb info: Loss PCT = %ld%%, Late PCT = %ld%%\n", + jb->info.frames_lost * 100/(jb->info.frames_in + jb->info.frames_lost), + jb->info.frames_late * 100/jb->info.frames_in); + jb_dbg("jb info: queue %d -> %d. last_ts %d (queue len: %d) last_ms %d\n", + queue_next(jb), + queue_last(jb), + jb->info.next_voice_ts, + queue_last(jb) - queue_next(jb), + jb->info.last_voice_ms); +} +#endif + +#ifdef DEEP_DEBUG +static void jb_chkqueue(jitterbuf *jb) +{ + int i=0; + jb_frame *p = jb->frames; + + if (!p) { + return; + } + + do { + if (p->next == NULL) { + jb_err("Queue is BROKEN at item [%d]", i); + } + i++; + p=p->next; + } while (p->next != jb->frames); +} + +static void jb_dbgqueue(jitterbuf *jb) +{ + int i=0; + jb_frame *p = jb->frames; + + jb_dbg("queue: "); + + if (!p) { + jb_dbg("EMPTY\n"); + return; + } + + do { + jb_dbg("[%d]=%ld ", i++, p->ts); + p=p->next; + } while (p->next != jb->frames); + + jb_dbg("\n"); +} +#endif + +enum jb_return_code jb_put(jitterbuf *jb, void *data, const enum jb_frame_type type, long ms, time_in_ms_t ts, time_in_ms_t now) +{ + jb_dbg2("jb_put(%x,%x,%ld,%ld,%ld)\n", jb, data, ms, ts, now); + + jb->info.frames_in++; + + if (type == JB_TYPE_VOICE) { + /* presently, I'm only adding VOICE frames to history and drift + * calculations; mostly because with the IAX integrations, I'm + * sending retransmitted control frames with their awkward + * timestamps through + */ + if (history_put(jb,ts,now,ms)) + return JB_DROP; + } + + /* if put into head of queue, caller needs to reschedule */ + if (queue_put(jb,data,type,ms,ts)) { + return JB_SCHED; + } + + return JB_OK; +} + + +static enum jb_return_code _jb_get(jitterbuf *jb, jb_frame *frameout, time_in_ms_t now, long interpl) +{ + jb_frame *frame; + time_in_ms_t diff; + + /*if ((now - jb_next(jb)) > 2 * jb->info.last_voice_ms) jb_warn("SCHED: %ld", (now - jb_next(jb))); */ + /* get jitter info */ + history_get(jb); + + + /* target */ + jb->info.target = jb->info.jitter + jb->info.min + jb->info.conf.target_extra; + + /* if a hard clamp was requested, use it */ + if ((jb->info.conf.max_jitterbuf) && ((jb->info.target - jb->info.min) > jb->info.conf.max_jitterbuf)) { + jb_dbg("clamping target from %d to %d\n", (jb->info.target - jb->info.min), jb->info.conf.max_jitterbuf); + jb->info.target = jb->info.min + jb->info.conf.max_jitterbuf; + } + + diff = jb->info.target - jb->info.current; + + /* jb_warn("diff = %d lms=%d last = %d now = %d\n", diff, */ + /* jb->info.last_voice_ms, jb->info.last_adjustment, now); */ + + /* let's work on non-silent case first */ + if (!jb->info.silence_begin_ts) { + /* we want to grow */ + if ((diff > 0) && + /* we haven't grown in the delay length */ + (((jb->info.last_adjustment + JB_ADJUST_DELAY) < now) || + /* we need to grow more than the "length" we have left */ + (diff > queue_last(jb) - queue_next(jb)) ) ) { + /* grow by interp frame length */ + jb->info.current += interpl; + jb->info.next_voice_ts += interpl; + jb->info.last_voice_ms = interpl; + jb->info.last_adjustment = now; + jb->info.cnt_contig_interp++; + /* assume silence instead of continuing to interpolate */ + if (jb->info.conf.max_contig_interp && jb->info.cnt_contig_interp >= jb->info.conf.max_contig_interp) { + jb->info.silence_begin_ts = jb->info.next_voice_ts - jb->info.current; + } + jb_dbg("G"); + return JB_INTERP; + } + + frame = queue_get(jb, jb->info.next_voice_ts - jb->info.current); + + /* not a voice frame; just return it. */ + if (frame && frame->type != JB_TYPE_VOICE) { + /* track start of silence */ + if (frame->type == JB_TYPE_SILENCE) { + jb->info.silence_begin_ts = frame->ts; + jb->info.cnt_contig_interp = 0; + } + + *frameout = *frame; + jb->info.frames_out++; + jb_dbg("o"); + return JB_OK; + } + + /* voice frame is later than expected */ + if (frame && frame->ts + jb->info.current < jb->info.next_voice_ts) { + if (frame->ts + jb->info.current > jb->info.next_voice_ts - jb->info.last_voice_ms) { + /* either we interpolated past this frame in the last jb_get */ + /* or the frame is still in order, but came a little too quick */ + *frameout = *frame; + /* reset expectation for next frame */ + jb->info.next_voice_ts = frame->ts + jb->info.current + frame->ms; + jb->info.frames_out++; + decrement_losspct(jb); + jb->info.cnt_contig_interp = 0; + jb_dbg("v"); + return JB_OK; + } else { + /* voice frame is late */ + *frameout = *frame; + jb->info.frames_out++; + decrement_losspct(jb); + jb->info.frames_late++; + jb->info.frames_lost--; + jb_dbg("l"); + /*jb_warn("\nlate: wanted=%ld, this=%ld, next=%ld\n", jb->info.next_voice_ts - jb->info.current, frame->ts, queue_next(jb)); + jb_warninfo(jb); */ + return JB_DROP; + } + } + + /* keep track of frame sizes, to allow for variable sized-frames */ + if (frame && frame->ms > 0) { + jb->info.last_voice_ms = frame->ms; + } + + /* we want to shrink; shrink at 1 frame / 500ms */ + /* unless we don't have a frame, then shrink 1 frame */ + /* every 80ms (though perhaps we can shrink even faster */ + /* in this case) */ + if (diff < -jb->info.conf.target_extra && + ((!frame && jb->info.last_adjustment + 80 < now) || + (jb->info.last_adjustment + 500 < now))) { + + jb->info.last_adjustment = now; + jb->info.cnt_contig_interp = 0; + + if (frame) { + *frameout = *frame; + /* shrink by frame size we're throwing out */ + jb->info.current -= frame->ms; + jb->info.frames_out++; + decrement_losspct(jb); + jb->info.frames_dropped++; + jb_dbg("s"); + return JB_DROP; + } else { + /* shrink by last_voice_ms */ + jb->info.current -= jb->info.last_voice_ms; + jb->info.frames_lost++; + increment_losspct(jb); + jb_dbg("S"); + return JB_NOFRAME; + } + } + + /* lost frame */ + if (!frame) { + /* this is a bit of a hack for now, but if we're close to + * target, and we find a missing frame, it makes sense to + * grow, because the frame might just be a bit late; + * otherwise, we presently get into a pattern where we return + * INTERP for the lost frame, then it shows up next, and we + * throw it away because it's late */ + /* I've recently only been able to replicate this using + * iaxclient talking to app_echo on asterisk. In this case, + * my outgoing packets go through asterisk's (old) + * jitterbuffer, and then might get an unusual increasing delay + * there if it decides to grow?? */ + /* Update: that might have been a different bug, that has been fixed.. + * But, this still seemed like a good idea, except that it ended up making a single actual + * lost frame get interpolated two or more times, when there was "room" to grow, so it might + * be a bit of a bad idea overall */ + /*if (diff > -1 * jb->info.last_voice_ms) { + jb->info.current += jb->info.last_voice_ms; + jb->info.last_adjustment = now; + jb_warn("g"); + return JB_INTERP; + } */ + jb->info.frames_lost++; + increment_losspct(jb); + jb->info.next_voice_ts += interpl; + jb->info.last_voice_ms = interpl; + jb->info.cnt_contig_interp++; + /* assume silence instead of continuing to interpolate */ + if (jb->info.conf.max_contig_interp && jb->info.cnt_contig_interp >= jb->info.conf.max_contig_interp) { + jb->info.silence_begin_ts = jb->info.next_voice_ts - jb->info.current; + } + jb_dbg("L"); + return JB_INTERP; + } + + /* normal case; return the frame, increment stuff */ + *frameout = *frame; + jb->info.next_voice_ts += frame->ms; + jb->info.frames_out++; + jb->info.cnt_contig_interp = 0; + decrement_losspct(jb); + jb_dbg("v"); + return JB_OK; + } else { + /* TODO: after we get the non-silent case down, we'll make the + * silent case -- basically, we'll just grow and shrink faster + * here, plus handle next_voice_ts a bit differently */ + + /* to disable silent special case altogether, just uncomment this: */ + /* jb->info.silence_begin_ts = 0; */ + + /* shrink interpl len every 10ms during silence */ + if (diff < -jb->info.conf.target_extra && + jb->info.last_adjustment + 10 <= now) { + jb->info.current -= interpl; + jb->info.last_adjustment = now; + } + + frame = queue_get(jb, now - jb->info.current); + if (!frame) { + return JB_NOFRAME; + } else if (frame->type != JB_TYPE_VOICE) { + /* normal case; in silent mode, got a non-voice frame */ + *frameout = *frame; + jb->info.frames_out++; + return JB_OK; + } + if (frame->ts < jb->info.silence_begin_ts) { + /* voice frame is late */ + *frameout = *frame; + jb->info.frames_out++; + decrement_losspct(jb); + jb->info.frames_late++; + jb->info.frames_lost--; + jb_dbg("l"); + /*jb_warn("\nlate: wanted=%ld, this=%ld, next=%ld\n", jb->info.next_voice_ts - jb->info.current, frame->ts, queue_next(jb)); + jb_warninfo(jb); */ + return JB_DROP; + } else { + /* voice frame */ + /* try setting current to target right away here */ + jb->info.current = jb->info.target; + jb->info.silence_begin_ts = 0; + jb->info.next_voice_ts = frame->ts + jb->info.current + frame->ms; + jb->info.last_voice_ms = frame->ms; + jb->info.frames_out++; + decrement_losspct(jb); + *frameout = *frame; + jb_dbg("V"); + return JB_OK; + } + } +} + +time_in_ms_t jb_next(jitterbuf *jb) +{ + if (jb->info.silence_begin_ts) { + if (jb->frames) { + time_in_ms_t next = queue_next(jb); + history_get(jb); + /* shrink during silence */ + if (jb->info.target - jb->info.current < -jb->info.conf.target_extra) + return jb->info.last_adjustment + 10; + return next + jb->info.target; + } + else + return JB_LONGMAX; + } else { + return jb->info.next_voice_ts; + } +} + +enum jb_return_code jb_get(jitterbuf *jb, jb_frame *frameout, time_in_ms_t now, long interpl) +{ + enum jb_return_code ret = _jb_get(jb, frameout, now, interpl); +#if 0 + static int lastts=0; + int thists = ((ret == JB_OK) || (ret == JB_DROP)) ? frameout->ts : 0; + jb_warn("jb_get(%x,%x,%ld) = %d (%d)\n", jb, frameout, now, ret, thists); + if (thists && thists < lastts) jb_warn("XXXX timestamp roll-back!!!\n"); + lastts = thists; +#endif + return ret; +} + +enum jb_return_code jb_getall(jitterbuf *jb, jb_frame *frameout) +{ + jb_frame *frame; + frame = queue_getall(jb); + + if (!frame) { + return JB_NOFRAME; + } + + *frameout = *frame; + return JB_OK; +} + + +enum jb_return_code jb_getinfo(jitterbuf *jb, jb_info *stats) +{ + history_get(jb); + + *stats = jb->info; + + return JB_OK; +} + +enum jb_return_code jb_setconf(jitterbuf *jb, jb_conf *conf) +{ + /* take selected settings from the struct */ + + jb->info.conf.max_jitterbuf = conf->max_jitterbuf; + jb->info.conf.resync_threshold = conf->resync_threshold; + jb->info.conf.max_contig_interp = conf->max_contig_interp; + + /* -1 indicates use of the default JB_TARGET_EXTRA value */ + jb->info.conf.target_extra = ( conf->target_extra == -1 ) + ? JB_TARGET_EXTRA + : conf->target_extra + ; + + /* update these to match new target_extra setting */ + jb->info.current = jb->info.conf.target_extra; + jb->info.target = jb->info.conf.target_extra; + + return JB_OK; +} + + Added: freeswitch/trunk/src/mod/endpoints/mod_iax/jitterbuf.h ============================================================================== --- (empty file) +++ freeswitch/trunk/src/mod/endpoints/mod_iax/jitterbuf.h Thu May 8 19:25:36 2008 @@ -0,0 +1,162 @@ +/* + * jitterbuf: an application-independent jitterbuffer + * + * Copyrights: + * Copyright (C) 2004-2005, Horizon Wimba, Inc. + * + * Contributors: + * Steve Kann <stevek@stevek.com> + * + * This program is free software, distributed under the terms of + * the GNU Lesser (Library) General Public License + * + * Copyright on this file is disclaimed to Digium for inclusion in Asterisk + */ + +#ifndef _JITTERBUF_H_ +#define _JITTERBUF_H_ + +#ifdef __cplusplus +extern "C" { +#endif + +/* configuration constants */ + /* Number of historical timestamps to use in calculating jitter and drift */ +#define JB_HISTORY_SZ 500 + /* what percentage of timestamps should we drop from the history when we examine it; + * this might eventually be something made configurable */ +#define JB_HISTORY_DROPPCT 3 + /* the maximum droppct we can handle (say it was configurable). */ +#define JB_HISTORY_DROPPCT_MAX 4 + /* the size of the buffer we use to keep the top and botton timestamps for dropping */ +#define JB_HISTORY_MAXBUF_SZ JB_HISTORY_SZ * JB_HISTORY_DROPPCT_MAX / 100 + /* amount of additional jitterbuffer adjustment */ +#define JB_TARGET_EXTRA 40 + /* ms between growing and shrinking; may not be honored if jitterbuffer runs out of space */ +#define JB_ADJUST_DELAY 40 + +enum jb_return_code { + /* return codes */ + JB_OK, /* 0 */ + JB_EMPTY, /* 1 */ + JB_NOFRAME, /* 2 */ + JB_INTERP, /* 3 */ + JB_DROP, /* 4 */ + JB_SCHED /* 5 */ +}; + +enum jb_frame_type { +/* frame types */ + JB_TYPE_CONTROL, /* 0 */ + JB_TYPE_VOICE, /* 1 */ + JB_TYPE_VIDEO, /* 2 - reserved */ + JB_TYPE_SILENCE /* 3 */ +}; + +typedef struct jb_conf { + /* settings */ + long max_jitterbuf; /* defines a hard clamp to use in setting the jitter buffer delay */ + long resync_threshold; /* the jb will resync when delay increases to (2 * jitter) + this param */ + long max_contig_interp; /* the max interp frames to return in a row */ + long target_extra; /* amount of additional jitterbuffer adjustment, overrides JB_TARGET_EXTRA */ +} jb_conf; + +typedef struct jb_info { + jb_conf conf; + + /* statistics */ + long frames_in; /* number of frames input to the jitterbuffer.*/ + long frames_out; /* number of frames output from the jitterbuffer.*/ + long frames_late; /* number of frames which were too late, and dropped.*/ + long frames_lost; /* number of missing frames.*/ + long frames_dropped; /* number of frames dropped (shrinkage) */ + long frames_ooo; /* number of frames received out-of-order */ + long frames_cur; /* number of frames presently in jb, awaiting delivery.*/ + time_in_ms_t jitter; /* jitter measured within current history interval*/ + time_in_ms_t min; /* minimum lateness within current history interval */ + time_in_ms_t current; /* the present jitterbuffer adjustment */ + time_in_ms_t target; /* the target jitterbuffer adjustment */ + long losspct; /* recent lost frame percentage (* 1000) */ + time_in_ms_t next_voice_ts; /* the ts of the next frame to be read from the jb - in receiver's time */ + long last_voice_ms; /* the duration of the last voice frame */ + time_in_ms_t silence_begin_ts; /* the time of the last CNG frame, when in silence */ + time_in_ms_t last_adjustment; /* the time of the last adjustment */ + time_in_ms_t last_delay; /* the last now added to history */ + long cnt_delay_discont; /* the count of discontinuous delays */ + time_in_ms_t resync_offset; /* the amount to offset ts to support resyncs */ + long cnt_contig_interp; /* the number of contiguous interp frames returned */ +} jb_info; + +typedef struct jb_frame { + void *data; /* the frame data */ + time_in_ms_t ts; /* the relative delivery time expected */ + long ms; /* the time covered by this frame, in sec/8000 */ + enum jb_frame_type type; /* the type of frame */ + struct jb_frame *next, *prev; +} jb_frame; + +typedef struct jitterbuf { + jb_info info; + + /* history */ + time_in_ms_t history[JB_HISTORY_SZ]; /* history */ + int hist_ptr; /* points to index in history for next entry */ + time_in_ms_t hist_maxbuf[JB_HISTORY_MAXBUF_SZ]; /* a sorted buffer of the max delays (highest first) */ + time_in_ms_t hist_minbuf[JB_HISTORY_MAXBUF_SZ]; /* a sorted buffer of the min delays (lowest first) */ + int hist_maxbuf_valid; /* are the "maxbuf"/minbuf valid? */ + + jb_frame *frames; /* queued frames */ + jb_frame *free; /* free frames (avoid malloc?) */ +} jitterbuf; + + +/* new jitterbuf */ +jitterbuf * jb_new(void); + +/* destroy jitterbuf */ +void jb_destroy(jitterbuf *jb); + +/* reset jitterbuf */ +/* NOTE: The jitterbuffer should be empty before you call this, otherwise + * you will leak queued frames, and some internal structures */ +void jb_reset(jitterbuf *jb); + +/* queue a frame data=frame data, timings (in ms): ms=length of frame (for voice), ts=ts (sender's time) + * now=now (in receiver's time) return value is one of + * JB_OK: Frame added. Last call to jb_next() still valid + * JB_DROP: Drop this frame immediately + * JB_SCHED: Frame added. Call jb_next() to get a new time for the next frame + */ +enum jb_return_code jb_put(jitterbuf *jb, void *data, const enum jb_frame_type type, long ms, time_in_ms_t ts, time_in_ms_t now); + +/* get a frame for time now (receiver's time) return value is one of + * JB_OK: You've got frame! + * JB_DROP: Here's an audio frame you should just drop. Ask me again for this time.. + * JB_NOFRAME: There's no frame scheduled for this time. + * JB_INTERP: Please interpolate an interpl-length frame for this time (either we need to grow, or there was a lost frame) + * JB_EMPTY: The jb is empty. + */ +enum jb_return_code jb_get(jitterbuf *jb, jb_frame *frame, time_in_ms_t now, long interpl); + +/* unconditionally get frames from jitterbuf until empty */ +enum jb_return_code jb_getall(jitterbuf *jb, jb_frame *frameout); + +/* when is the next frame due out, in receiver's time (0=EMPTY) + * This value may change as frames are added (esp non-audio frames) */ +time_in_ms_t jb_next(jitterbuf *jb); + +/* get jitterbuf info: only "statistics" may be valid */ +enum jb_return_code jb_getinfo(jitterbuf *jb, jb_info *stats); + +/* set jitterbuf conf */ +enum jb_return_code jb_setconf(jitterbuf *jb, jb_conf *conf); + +typedef void (*jb_output_function_t)(const char *fmt, ...); +extern void jb_setoutput(jb_output_function_t err, jb_output_function_t warn, jb_output_function_t dbg); + +#ifdef __cplusplus +} +#endif + + +#endif Added: freeswitch/trunk/src/mod/endpoints/mod_iax/md5.c ============================================================================== --- (empty file) +++ freeswitch/trunk/src/mod/endpoints/mod_iax/md5.c Thu May 8 19:25:36 2008 @@ -0,0 +1,297 @@ +/* MD5 checksum routines used for authentication. Not covered by GPL, but + in the public domain as per the copyright below */ + +#ifdef FREEBSD +# include <machine/endian.h> +#elif defined(LINUX) +# include <endian.h> +# include <features.h> +# include <sys/types.h> +#elif defined(SOLARIS) + /* each solaris is different -- this won't work on 2.6 or 2.7 */ +# include <sys/isa_defs.h> /* Defines either _LITTLE_ENDIAN or _BIG_ENDIAN */ +# define __BIG_ENDIAN 4321 +# define __LITTLE_ENDIAN 1234 +# define BIG_ENDIAN 4321 +# define LITTLE_ENDIAN 1234 +# ifdef _LITTLE_ENDIAN +# define __BYTE_ORDER __LITTLE_ENDIAN +# define BYTE_ORDER LITTLE_ENDIAN +# else +# define __BYTE_ORDER __BIG_ENDIAN +# define BYTE_ORDER BIG_ENDIAN +# endif +#endif + +#ifdef _MSC_VER +#ifndef __LITTLE_ENDIAN +#define __LITTLE_ENDIAN 1234 +#endif +#ifndef __BIG_ENDIAN +#define __BIG_ENDIAN 4321 +#endif +#ifndef __BYTE_ORDER +#define __BYTE_ORDER __LITTLE_ENDIAN +#endif +#endif + +#if __BYTE_ORDER == __BIG_ENDIAN || BYTE_ORDER == BIG_ENDIAN +# define HIGHFIRST 1 +#elif __BYTE_ORDER == __LITTLE_ENDIAN || BYTE_ORDER == LITLE_ENDIAN +# undef HIGHFIRST +#else +# error "Please fix <bits/endian.h>" +#endif + +/* + * This code implements the MD5 message-digest algorithm. + * The algorithm is due to Ron Rivest. This code was + * written by Colin Plumb in 1993, no copyright is claimed. + * This code is in the public domain; do with it what you wish. + * + * Equivalent code is available from RSA Data Security, Inc. + * This code has been tested against that, and is equivalent, + * except that you don't need to include two pages of legalese + * with every copy. + * + * To compute the message digest of a chunk of bytes, declare an + * MD5Context structure, pass it to MD5Init, call MD5Update as + * needed on buffers full of bytes, and then call MD5Final, which + * will fill a supplied 16-byte array with the digest. + */ +#include <string.h> /* for memcpy() */ +#include "md5.h" + +#ifndef HIGHFIRST +#define byteReverse(buf, len) /* Nothing */ +#else +void byteReverse(unsigned char *buf, unsigned longs); + +#ifndef ASM_MD5 +/* + * Note: this code is harmless on little-endian machines. + */ +void byteReverse(unsigned char *buf, unsigned longs) +{ + uint32 t; + do { + t = (uint32) ((unsigned) buf[3] << 8 | buf[2]) << 16 | + ((unsigned) buf[1] << 8 | buf[0]); + *(uint32 *) buf = t; + buf += 4; + } while (--longs); +} +#endif +#endif + +/* + * Start MD5 accumulation. Set bit count to 0 and buffer to mysterious + * initialization constants. + */ +void MD5Init(struct MD5Context *ctx) +{ + ctx->buf[0] = 0x67452301; + ctx->buf[1] = 0xefcdab89; + ctx->buf[2] = 0x98badcfe; + ctx->buf[3] = 0x10325476; + + ctx->bits[0] = 0; + ctx->bits[1] = 0; +} + +/* + * Update context to reflect the concatenation of another buffer full + * of bytes. + */ +void MD5Update(struct MD5Context *ctx, unsigned char const *buf, unsigned len) +{ + uint32 t; + + /* Update bitcount */ + + t = ctx->bits[0]; + if ((ctx->bits[0] = t + ((uint32) len << 3)) < t) + ctx->bits[1]++; /* Carry from low to high */ + ctx->bits[1] += len >> 29; + + t = (t >> 3) & 0x3f; /* Bytes already in shsInfo->data */ + + /* Handle any leading odd-sized chunks */ + + if (t) { + unsigned char *p = (unsigned char *) ctx->in + t; + + t = 64 - t; + if (len < t) { + memcpy(p, buf, len); + return; + } + memcpy(p, buf, t); + byteReverse(ctx->in, 16); + MD5Transform(ctx->buf, (uint32 *) ctx->in); + buf += t; + len -= t; + } + /* Process data in 64-byte chunks */ + + while (len >= 64) { + memcpy(ctx->in, buf, 64); + byteReverse(ctx->in, 16); + MD5Transform(ctx->buf, (uint32 *) ctx->in); + buf += 64; + len -= 64; + } + + /* Handle any remaining bytes of data. */ + + memcpy(ctx->in, buf, len); +} + +/* + * Final wrapup - pad to 64-byte boundary with the bit pattern + * 1 0* (64-bit count of bits processed, MSB-first) + */ +void MD5Final(unsigned char digest[16], struct MD5Context *ctx) +{ + unsigned count; + unsigned char *p; + + /* Compute number of bytes mod 64 */ + count = (ctx->bits[0] >> 3) & 0x3F; + + /* Set the first char of padding to 0x80. This is safe since there is + always at least one byte free */ + p = ctx->in + count; + *p++ = 0x80; + + /* Bytes of padding needed to make 64 bytes */ + count = 64 - 1 - count; + + /* Pad out to 56 mod 64 */ + if (count < 8) { + /* Two lots of padding: Pad the first block to 64 bytes */ + memset(p, 0, count); + byteReverse(ctx->in, 16); + MD5Transform(ctx->buf, (uint32 *) ctx->in); + + /* Now fill the next block with 56 bytes */ + memset(ctx->in, 0, 56); + } else { + /* Pad block to 56 bytes */ + memset(p, 0, count - 8); + } + byteReverse(ctx->in, 14); + + /* Append length in bits and transform */ + ((uint32 *) ctx->in)[14] = ctx->bits[0]; + ((uint32 *) ctx->in)[15] = ctx->bits[1]; + + MD5Transform(ctx->buf, (uint32 *) ctx->in); + byteReverse((unsigned char *) ctx->buf, 4); + memcpy(digest, ctx->buf, 16); + memset(ctx, 0, sizeof(ctx)); /* In case it's sensitive */ +} + +#ifndef ASM_MD5 + +/* The four core functions - F1 is optimized somewhat */ + +/* #define F1(x, y, z) (x & y | ~x & z) */ +#define F1(x, y, z) (z ^ (x & (y ^ z))) +#define F2(x, y, z) F1(z, x, y) +#define F3(x, y, z) (x ^ y ^ z) +#define F4(x, y, z) (y ^ (x | ~z)) + +/* This is the central step in the MD5 algorithm. */ +#define MD5STEP(f, w, x, y, z, data, s) \ + ( w += f(x, y, z) + data, w = w<<s | w>>(32-s), w += x ) + +/* + * The core of the MD5 algorithm, this alters an existing MD5 hash to + * reflect the addition of 16 longwords of new data. MD5Update blocks + * the data and converts bytes into longwords for this routine. + */ +void MD5Transform(uint32 buf[4], uint32 const in[16]) +{ + register uint32 a, b, c, d; + + a = buf[0]; + b = buf[1]; + c = buf[2]; + d = buf[3]; + + MD5STEP(F1, a, b, c, d, in[0] + 0xd76aa478, 7); + MD5STEP(F1, d, a, b, c, in[1] + 0xe8c7b756, 12); + MD5STEP(F1, c, d, a, b, in[2] + 0x242070db, 17); + MD5STEP(F1, b, c, d, a, in[3] + 0xc1bdceee, 22); + MD5STEP(F1, a, b, c, d, in[4] + 0xf57c0faf, 7); + MD5STEP(F1, d, a, b, c, in[5] + 0x4787c62a, 12); + MD5STEP(F1, c, d, a, b, in[6] + 0xa8304613, 17); + MD5STEP(F1, b, c, d, a, in[7] + 0xfd469501, 22); + MD5STEP(F1, a, b, c, d, in[8] + 0x698098d8, 7); + MD5STEP(F1, d, a, b, c, in[9] + 0x8b44f7af, 12); + MD5STEP(F1, c, d, a, b, in[10] + 0xffff5bb1, 17); + MD5STEP(F1, b, c, d, a, in[11] + 0x895cd7be, 22); + MD5STEP(F1, a, b, c, d, in[12] + 0x6b901122, 7); + MD5STEP(F1, d, a, b, c, in[13] + 0xfd987193, 12); + MD5STEP(F1, c, d, a, b, in[14] + 0xa679438e, 17); + MD5STEP(F1, b, c, d, a, in[15] + 0x49b40821, 22); + + MD5STEP(F2, a, b, c, d, in[1] + 0xf61e2562, 5); + MD5STEP(F2, d, a, b, c, in[6] + 0xc040b340, 9); + MD5STEP(F2, c, d, a, b, in[11] + 0x265e5a51, 14); + MD5STEP(F2, b, c, d, a, in[0] + 0xe9b6c7aa, 20); + MD5STEP(F2, a, b, c, d, in[5] + 0xd62f105d, 5); + MD5STEP(F2, d, a, b, c, in[10] + 0x02441453, 9); + MD5STEP(F2, c, d, a, b, in[15] + 0xd8a1e681, 14); + MD5STEP(F2, b, c, d, a, in[4] + 0xe7d3fbc8, 20); + MD5STEP(F2, a, b, c, d, in[9] + 0x21e1cde6, 5); + MD5STEP(F2, d, a, b, c, in[14] + 0xc33707d6, 9); + MD5STEP(F2, c, d, a, b, in[3] + 0xf4d50d87, 14); + MD5STEP(F2, b, c, d, a, in[8] + 0x455a14ed, 20); + MD5STEP(F2, a, b, c, d, in[13] + 0xa9e3e905, 5); + MD5STEP(F2, d, a, b, c, in[2] + 0xfcefa3f8, 9); + MD5STEP(F2, c, d, a, b, in[7] + 0x676f02d9, 14); + MD5STEP(F2, b, c, d, a, in[12] + 0x8d2a4c8a, 20); + + MD5STEP(F3, a, b, c, d, in[5] + 0xfffa3942, 4); + MD5STEP(F3, d, a, b, c, in[8] + 0x8771f681, 11); + MD5STEP(F3, c, d, a, b, in[11] + 0x6d9d6122, 16); + MD5STEP(F3, b, c, d, a, in[14] + 0xfde5380c, 23); + MD5STEP(F3, a, b, c, d, in[1] + 0xa4beea44, 4); + MD5STEP(F3, d, a, b, c, in[4] + 0x4bdecfa9, 11); + MD5STEP(F3, c, d, a, b, in[7] + 0xf6bb4b60, 16); + MD5STEP(F3, b, c, d, a, in[10] + 0xbebfbc70, 23); + MD5STEP(F3, a, b, c, d, in[13] + 0x289b7ec6, 4); + MD5STEP(F3, d, a, b, c, in[0] + 0xeaa127fa, 11); + MD5STEP(F3, c, d, a, b, in[3] + 0xd4ef3085, 16); + MD5STEP(F3, b, c, d, a, in[6] + 0x04881d05, 23); + MD5STEP(F3, a, b, c, d, in[9] + 0xd9d4d039, 4); + MD5STEP(F3, d, a, b, c, in[12] + 0xe6db99e5, 11); + MD5STEP(F3, c, d, a, b, in[15] + 0x1fa27cf8, 16); + MD5STEP(F3, b, c, d, a, in[2] + 0xc4ac5665, 23); + + MD5STEP(F4, a, b, c, d, in[0] + 0xf4292244, 6); + MD5STEP(F4, d, a, b, c, in[7] + 0x432aff97, 10); + MD5STEP(F4, c, d, a, b, in[14] + 0xab9423a7, 15); + MD5STEP(F4, b, c, d, a, in[5] + 0xfc93a039, 21); + MD5STEP(F4, a, b, c, d, in[12] + 0x655b59c3, 6); + MD5STEP(F4, d, a, b, c, in[3] + 0x8f0ccc92, 10); + MD5STEP(F4, c, d, a, b, in[10] + 0xffeff47d, 15); + MD5STEP(F4, b, c, d, a, in[1] + 0x85845dd1, 21); + MD5STEP(F4, a, b, c, d, in[8] + 0x6fa87e4f, 6); + MD5STEP(F4, d, a, b, c, in[15] + 0xfe2ce6e0, 10); + MD5STEP(F4, c, d, a, b, in[6] + 0xa3014314, 15); + MD5STEP(F4, b, c, d, a, in[13] + 0x4e0811a1, 21); + MD5STEP(F4, a, b, c, d, in[4] + 0xf7537e82, 6); + MD5STEP(F4, d, a, b, c, in[11] + 0xbd3af235, 10); + MD5STEP(F4, c, d, a, b, in[2] + 0x2ad7d2bb, 15); + MD5STEP(F4, b, c, d, a, in[9] + 0xeb86d391, 21); + + buf[0] += a; + buf[1] += b; + buf[2] += c; + buf[3] += d; +} + +#endif Added: freeswitch/trunk/src/mod/endpoints/mod_iax/md5.h ============================================================================== --- (empty file) +++ freeswitch/trunk/src/mod/endpoints/mod_iax/md5.h Thu May 8 19:25:36 2008 @@ -0,0 +1,27 @@ +#ifndef MD5_H +#define MD5_H + +#if defined(__alpha) || defined(__x86_64) +typedef unsigned int uint32; +#else +typedef unsigned long uint32; +#endif + +struct MD5Context { + uint32 buf[4]; + uint32 bits[2]; + unsigned char in[64]; +}; + +void MD5Init(struct MD5Context *context); +void MD5Update(struct MD5Context *context, unsigned char const *buf, + unsigned len); +void MD5Final(unsigned char digest[16], struct MD5Context *context); +void MD5Transform(uint32 buf[4], uint32 const in[16]); + +/* + * This is needed to make RSAREF happy on some MS-DOS compilers. + */ +typedef struct MD5Context MD5_CTX; + +#endif /* !MD5_H */ Added: freeswitch/trunk/src/mod/endpoints/mod_iax/winiphone.c ============================================================================== --- (empty file) +++ freeswitch/trunk/src/mod/endpoints/mod_iax/winiphone.c Thu May 8 19:25:36 2008 @@ -0,0 +1,761 @@ +/* + * Miniphone: A simple, command line telephone + * + * IAX Support for talking to Asterisk and other Gnophone clients + * + * Copyright (C) 1999, Linux Support Services, Inc. + * + * Mark Spencer <markster@linux-support.net> + * + * This program is free software, distributed under the terms of + * the GNU General Public License + */ + +/* #define PRINTCHUCK /* enable this to indicate chucked incomming packets */ + +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <fcntl.h> +#include <io.h> +#include <conio.h> +#include <stdio.h> +#include <errno.h> +#include <time.h> +#include <process.h> +#include <windows.h> +#include <winsock.h> +#include <mmsystem.h> +#include <malloc.h> +#include "gsm.h" +#include "iax-client.h" +#include "frame.h" +#include "miniphone.h" + + +struct peer { + int time; + gsm gsmin; + gsm gsmout; + + struct iax_session *session; + struct peer *next; +}; + +static struct peer *peers; +static int answered_call = 0; + +/* stuff for wave audio device */ +HWAVEOUT wout; +HWAVEIN win; + +typedef struct whout { + WAVEHDR w; + short data[160]; + struct whout *next; +} WHOUT; + +WHOUT *outqueue = NULL; + +/* parameters for audio in */ +#define NWHIN 8 /* number of input buffer entries */ +/* NOTE the OUT_INTERVAL parameter *SHOULD* be more around 18 to 20 or so, since the packets should +be spaced by 20 milliseconds. However, in practice, especially in Windoze-95, setting it that high +caused underruns. 10 is just ever so slightly agressive, and the receiver has to chuck a packet +every now and then. Thats about the way it should be to be happy. */ +#define OUT_INTERVAL 10 /* number of ms to wait before sending more data to peer */ +/* parameters for audio out */ +#define OUT_DEPTH 12 /* number of outbut buffer entries */ +#define OUT_PAUSE_THRESHOLD 2 /* number of active entries needed to start output (for smoothing) */ + +/* audio input buffer headers */ +WAVEHDR whin[NWHIN]; +/* audio input buffers */ +char bufin[NWHIN][320]; + +/* initialize the sequence variables for the audio in stuff */ +unsigned int whinserial = 1,nextwhin = 1; + +static struct peer *find_peer(struct iax_session *); +static void parse_args(FILE *, unsigned char *); +void do_iax_event(FILE *); +void call(FILE *, char *); +void answer_call(void); +void reject_call(void); +static void handle_event(FILE *, struct iax_event *e, struct peer *p); +void parse_cmd(FILE *, int, char **); +void issue_prompt(FILE *); +void dump_array(FILE *, char **); + +static char *help[] = { +"Welcome to the miniphone telephony client, the commands are as follows:\n", +"Help\t\t-\tDisplays this screen.", +"Call <Number>\t-\tDials the number supplied.", +"Answer\t\t-\tAnswers an Inbound call.", +"Reject\t\t-\tRejects an Inbound call.", +"Dump\t\t-\tDumps (disconnects) the current call.", +"Dtmf <Digit>\t-\tSends specified DTMF digit.", +"Status\t\t-\tLists the current sessions and their current status.", +"Quit\t\t-\tShuts down the client.", +"", +0 +}; + +static struct peer *most_recent_answer; +static struct iax_session *newcall = 0; + +/* holder of the time, relative to startup in system ticks. See our +gettimeofday() implementation */ +time_t startuptime; + +/* routine called at exit to shutdown audio I/O and close nicely. +NOTE: If all this isnt done, the system doesnt not handle this +cleanly and has to be rebooted. What a pile of doo doo!! */ +void killem(void) +{ + waveInStop(win); + waveInReset(win); + waveInClose(win); + waveOutReset(wout); + waveOutClose(wout); + WSACleanup(); /* dont forget socket stuff too */ + return; +} + +/* Win-doze doenst have gettimeofday(). This sux. So, what we did is +provide some gettimeofday-like functionality that works for our purposes. +In the main(), we take a sample of the system tick counter (into startuptime). +This function returns the relative time since program startup, more or less, +which is certainly good enough for our purposes. */ +void gettimeofday(struct timeval *tv, struct timezone *tz) +{ + long l = startuptime + GetTickCount(); + + tv->tv_sec = l / 1000; + tv->tv_usec = (l % 1000) * 1000; + return; +} + + +static struct peer *find_peer(struct iax_session *session) +{ + struct peer *cur = peers; + while(cur) { + if (cur->session == session) + return cur; + cur = cur->next; + } + return NULL; +} + +void +parse_args(FILE *f, unsigned char *cmd) +{ + static char *argv[MAXARGS]; + unsigned char *parse = cmd; + int argc = 0, t = 0; + + // Don't mess with anything that doesn't exist... + if(!*parse) + return; + + memset(argv, 0, sizeof(argv)); + while(*parse) { + if(*parse < 33 || *parse > 128) { + *parse = 0, t++; + if(t > MAXARG) { + fprintf(f, "Warning: Argument exceeds maximum argument size, command ignored!\n"); + return; + } + } else if(t || !argc) { + if(argc == MAXARGS) { + fprintf(f, "Warning: Command ignored, too many arguments\n"); + return; + } + argv[argc++] = parse; + t = 0; + } + + parse++; + } + + if(argc) + parse_cmd(f, argc, argv); +} + +/* handle all network requests, and a pending scheduled event, if any */ +void service_network(int netfd, FILE *f) +{ + fd_set readfd; + struct timeval dumbtimer; + + /* set up a timer that falls-through */ + dumbtimer.tv_sec = 0; + dumbtimer.tv_usec = 0; + + + for(;;) /* suck everything outa network stuff */ + { + FD_ZERO(&readfd); + FD_SET(netfd, &readfd); + if (select(netfd + 1, &readfd, 0, 0, &dumbtimer) > 0) + { + if (FD_ISSET(netfd,&readfd)) + { + do_iax_event(f); + (void) iax_time_to_next_event(); + } else break; + } else break; + } + do_iax_event(f); /* do pending event if any */ +} + + +int +main(int argc, char *argv[]) +{ + int port; + int netfd; + int c, i; + FILE *f; + char rcmd[RBUFSIZE]; + gsm_frame fo; + WSADATA foop; + time_t t; + WAVEFORMATEX wf; + WHOUT *wh,*wh1,*wh2; + unsigned long lastouttick = 0; + + + + /* get time of day in milliseconds, offset by tick count (see our + gettimeofday() implementation) */ + time(&t); + startuptime = ((t % 86400) * 1000) - GetTickCount(); + + f = stdout; + _dup2(fileno(stdout),fileno(stderr)); + + /* start up the windoze-socket layer stuff */ + if (WSAStartup(0x0101,&foop)) { + fprintf(stderr,"Fatal error: Falied to startup windows sockets\n"); + return -1; + } + + + /* setup the format for opening audio channels */ + wf.wFormatTag = WAVE_FORMAT_PCM; + wf.nChannels = 1; + wf.nSamplesPerSec = 8000; + wf.nAvgBytesPerSec = 16000; + wf.nBlockAlign = 2; + wf.wBitsPerSample = 16; + wf.cbSize = 0; + /* open the audio out channel */ + if (waveOutOpen(&wout,0,&wf,0,0,CALLBACK_NULL) != MMSYSERR_NOERROR) + { + fprintf(stderr,"Fatal Error: Failed to open wave output device\n"); + return -1; + } + /* open the audio in channel */ + if (waveInOpen(&win,0,&wf,0,0,CALLBACK_NULL) != MMSYSERR_NOERROR) + { + fprintf(stderr,"Fatal Error: Failed to open wave input device\n"); + waveOutReset(wout); + waveOutClose(wout); + return -1; + } + /* activate the exit handler */ + atexit(killem); + /* initialize the audio in buffer structures */ + memset(&whin,0,sizeof(whin)); + + if ( (port = iax_init(0) < 0)) { + fprintf(stderr, "Fatal error: failed to initialize iax with port %d\n", port); + return -1; + } + + + iax_set_formats(AST_FORMAT_GSM); + netfd = iax_get_fd(); + + fprintf(f, "Text Based Telephony Client.\n\n"); + issue_prompt(f); + + /* main tight loop */ + while(1) { + /* service the network stuff */ + service_network(netfd,f); + if (outqueue) /* if stuff in audio output queue, free it up if its available */ + { + /* go through audio output queue */ + for(wh = outqueue,wh1 = wh2 = NULL,i = 0; wh != NULL; wh = wh->next) + { + service_network(netfd,f); /* service network here for better performance */ + /* if last one was removed from queue, zot it here */ + if (i && wh1) + { + free(wh1); + wh1 = wh2; + } + i = 0; /* reset "last one removed" flag */ + if (wh->w.dwFlags & WHDR_DONE) /* if this one is done */ + { + /* prepare audio header */ + if ((c = waveOutUnprepareHeader(wout,&wh->w,sizeof(WAVEHDR))) != MMSYSERR_NOERROR) + { + fprintf(stderr,"Cannot unprepare audio out header, error %d\n",c); + exit(255); + } + if (wh1 != NULL) /* if there was a last one */ + { + wh1->next = wh->next; + } + if (outqueue == wh) /* is first one, so set outqueue to next one */ + { + outqueue = wh->next; + } + i = 1; /* set 'to free' flag */ + } + wh2 = wh1; /* save old,old wh pointer */ + wh1 = wh; /* save the old wh pointer */ + } + } + /* go through all audio in buffers, and prepare and queue ones that are currently idle */ + for(i = 0; i < NWHIN; i++) + { + service_network(netfd,f); /* service network stuff here for better performance */ + if (!(whin[i].dwFlags & WHDR_PREPARED)) /* if not prepared, do so */ + { + /* setup this input buffer header */ + memset(&whin[i],0,sizeof(WAVEHDR)); + whin[i].lpData = bufin[i]; + whin[i].dwBufferLength = 320; + whin[i].dwUser = whinserial++; /* set 'user data' to current serial number */ + /* prepare the buffer */ + if (waveInPrepareHeader(win,&whin[i],sizeof(WAVEHDR))) + { + fprintf(stderr,"Unable to prepare header for input\n"); + return -1; + } + /* add it to device (queue) */ + if (waveInAddBuffer(win,&whin[i],sizeof(WAVEHDR))) + { + fprintf(stderr,"Unable to prepare header for input\n"); + return -1; + } + } + waveInStart(win); /* start it (if not already started) */ + } + + /* if key pressed, do command stuff */ + if(_kbhit()) + { + if ( ( fgets(&*rcmd, 256, stdin))) { + rcmd[strlen(rcmd)-1] = 0; + parse_args(f, &*rcmd); + } else fprintf(f, "Fatal error: failed to read data!\n"); + + issue_prompt(f); + } + /* do audio input stuff for buffers that have received data from audio in device already. Must + do them in serial number order (the order in which they were originally queued). */ + if(answered_call) /* send audio only if call answered */ + { + for(;;) /* loop until all are found */ + { + for(i = 0; i < NWHIN; i++) /* find an available one that's the one we are looking for */ + { + service_network(netfd,f); /* service network here for better performance */ + /* if not time to send any more, dont */ + if (GetTickCount() < (lastouttick + OUT_INTERVAL)) + { + i = NWHIN; /* set to value that WILL exit loop */ + break; + } + if ((whin[i].dwUser == nextwhin) && (whin[i].dwFlags & WHDR_DONE)) { /* if audio is ready */ + + /* must have read exactly 320 bytes */ + if (whin[i].dwBytesRecorded != whin[i].dwBufferLength) + { + fprintf(stderr,"Short audio read, got %d bytes, expected %d bytes\n", whin[i].dwBytesRecorded, + whin[i].dwBufferLength); + return -1; + } + if(!most_recent_answer->gsmout) + most_recent_answer->gsmout = gsm_create(); + + service_network(netfd,f); /* service network here for better performance */ + /* encode the audio from the buffer into GSM format */ + gsm_encode(most_recent_answer->gsmout, (short *) ((char *) whin[i].lpData), fo); + if(iax_send_voice(most_recent_answer->session, + AST_FORMAT_GSM, (char *)fo, sizeof(gsm_frame)) == -1) + puts("Failed to send voice!"); + lastouttick = GetTickCount(); /* save time of last output */ + + /* unprepare (free) the header */ + waveInUnprepareHeader(win,&whin[i],sizeof(WAVEHDR)); + /* initialize the buffer */ + memset(&whin[i],0,sizeof(WAVEHDR)); + /* bump the serial number to look for the next time */ + nextwhin++; + /* exit the loop so that we can start at lowest buffer again */ + break; + } + } + if (i >= NWHIN) break; /* if all found, get out of loop */ + } + } + + } + return 0; +} + +void +do_iax_event(FILE *f) { + int sessions = 0; + struct iax_event *e = 0; + struct peer *peer; + + while ( (e = iax_get_event(0))) { + peer = find_peer(e->session); + if(peer) { + handle_event(f, e, peer); + } else { + if(e->etype != IAX_EVENT_CONNECT) { + fprintf(stderr, "Huh? This is an event for a non-existant session?\n"); + } + sessions++; + + if(sessions >= MAX_SESSIONS) { + fprintf(f, "Missed a call... too many sessions open.\n"); + } + + + if(e->event.connect.callerid && e->event.connect.dnid) + fprintf(f, "Call from '%s' for '%s'", e->event.connect.callerid, + e->event.connect.dnid); + else if(e->event.connect.dnid) { + fprintf(f, "Call from '%s'", e->event.connect.dnid); + } else if(e->event.connect.callerid) { + fprintf(f, "Call from '%s'", e->event.connect.callerid); + } else printf("Call from"); + fprintf(f, " (%s)\n", inet_ntoa(iax_get_peer_addr(e->session).sin_addr)); + + if(most_recent_answer) { + fprintf(f, "Incoming call ignored, there's already a call waiting for answer... \ +please accept or reject first\n"); + iax_reject(e->session, "Too many calls, we're busy!"); + } else { + if ( !(peer = malloc(sizeof(struct peer)))) { + fprintf(f, "Warning: Unable to allocate memory!\n"); + return; + } + + peer->time = time(0); + peer->session = e->session; + peer->gsmin = 0; + peer->gsmout = 0; + + peer->next = peers; + peers = peer; + + iax_accept(peer->session); + iax_ring_announce(peer->session); + most_recent_answer = peer; + fprintf(f, "Incoming call!\n"); + } + iax_event_free(e); + issue_prompt(f); + } + } +} + +void +call(FILE *f, char *num) +{ + struct peer *peer; + + if(!newcall) + newcall = iax_session_new(); + else { + fprintf(f, "Already attempting to call somewhere, please cancel first!\n"); + return; + } + + if ( !(peer = malloc(sizeof(struct peer)))) { + fprintf(f, "Warning: Unable to allocate memory!\n"); + return; + } + + peer->time = time(0); + peer->session = newcall; + peer->gsmin = 0; + peer->gsmout = 0; + + peer->next = peers; + peers = peer; + + most_recent_answer = peer; + + iax_call(peer->session, num, 10); +} + +void +answer_call(void) +{ + if(most_recent_answer) + iax_answer(most_recent_answer->session); + printf("Answering call!\n"); + answered_call = 1; +} + +void +dump_call(void) +{ + if(most_recent_answer) + { + iax_hangup(most_recent_answer->session,""); + free(most_recent_answer); + } + printf("Dumping call!\n"); + answered_call = 0; + most_recent_answer = 0; + answered_call = 0; + peers = 0; + newcall = 0; +} + +void +reject_call(void) +{ + iax_reject(most_recent_answer->session, "Call rejected manually."); + most_recent_answer = 0; +} + +void +handle_event(FILE *f, struct iax_event *e, struct peer *p) +{ + int len,n; + WHOUT *wh,*wh1; + short fr[160]; + static paused_xmit = 0; + + + switch(e->etype) { + case IAX_EVENT_HANGUP: + iax_hangup(most_recent_answer->session, "Byeee!"); + fprintf(f, "Call disconnected by peer\n"); + free(most_recent_answer); + most_recent_answer = 0; + answered_call = 0; + peers = 0; + newcall = 0; + + break; + + case IAX_EVENT_REJECT: + fprintf(f, "Authentication was rejected\n"); + break; + case IAX_EVENT_ACCEPT: + fprintf(f, "Waiting for answer... RING RING\n"); + issue_prompt(f); + break; + case IAX_EVENT_ANSWER: + answer_call(); + break; + case IAX_EVENT_VOICE: + switch(e->event.voice.format) { + case AST_FORMAT_GSM: + if(e->event.voice.datalen % 33) { + fprintf(stderr, "Weird gsm frame, not a multiple of 33.\n"); + break; + } + + if (!p->gsmin) + p->gsmin = gsm_create(); + + len = 0; + while(len < e->event.voice.datalen) { + if(gsm_decode(p->gsmin, (char *) e->event.voice.data + len, fr)) { + fprintf(stderr, "Bad GSM data\n"); + break; + } else { /* its an audio packet to be output to user */ + + /* get count of pending items in audio output queue */ + n = 0; + if (outqueue) + { /* determine number of pending out queue items */ + for(wh = outqueue; wh != NULL; wh = wh->next) + { + if (!(wh->w.dwFlags & WHDR_DONE)) n++; + } + } + /* if not too many, send to user, otherwise chuck packet */ + if (n <= OUT_DEPTH) /* if not to chuck packet */ + { + /* malloc the memory for the queue item */ + wh = (WHOUT *) malloc(sizeof(WHOUT)); + if (wh == (WHOUT *) NULL) /* if error, bail */ + { + fprintf(stderr,"Outa memory!!!!\n"); + exit(255); + } + /* initialize the queue entry */ + memset(wh,0,sizeof(WHOUT)); + /* copy the PCM data from the gsm conversion buffer */ + memcpy((char *)wh->data,(char *)fr,sizeof(fr)); + /* set parameters for data */ + wh->w.lpData = (char *) wh->data; + wh->w.dwBufferLength = 320; + + /* prepare buffer for output */ + if (waveOutPrepareHeader(wout,&wh->w,sizeof(WAVEHDR))) + { + fprintf(stderr,"Cannot prepare header for audio out\n"); + exit(255); + } + /* if not currently transmitting, hold off a couple of packets for + smooth sounding output */ + if ((!n) && (!paused_xmit)) + { + /* pause output (before starting) */ + waveOutPause(wout); + /* indicate as such */ + paused_xmit = 1; + } + /* queue packet for output on audio device */ + if (waveOutWrite(wout,&wh->w,sizeof(WAVEHDR))) + { + fprintf(stderr,"Cannot output to wave output device\n"); + exit(255); + } + /* if we are paused, and we have enough packets, start audio */ + if ((n > OUT_PAUSE_THRESHOLD) && paused_xmit) + { + /* start the output */ + waveOutRestart(wout); + /* indicate as such */ + paused_xmit = 0; + } + /* insert it onto tail of outqueue */ + if (outqueue == NULL) /* if empty queue */ + outqueue = wh; /* point queue to new entry */ + else /* otherwise is non-empty queue */ + { + wh1 = outqueue; + while(wh1->next) wh1 = wh1->next; /* find last entry in queue */ + wh1->next = wh; /* point it to new entry */ + } + } +#ifdef PRINTCHUCK + else printf("Chucking packet!!\n"); +#endif + } + len += 33; + } + break; + default : + fprintf(f, "Don't know how to handle that format %d\n", e->event.voice.format); + } + break; + case IAX_EVENT_RINGA: + break; + default: + fprintf(f, "Unknown event: %d\n", e->etype); + break; + } +} + +void +parse_cmd(FILE *f, int argc, char **argv) +{ + _strupr(argv[0]); + if(!strcmp(argv[0], "HELP")) { + if(argc == 1) + dump_array(f, help); + else if(argc == 2) { + if(!strcmp(argv[1], "HELP")) + fprintf(f, "Help <Command>\t-\tDisplays general help or specific help on command if supplied an arguement\n"); + else if(!strcmp(argv[1], "QUIT")) + fprintf(f, "Quit\t\t-\tShuts down the miniphone\n"); + else fprintf(f, "No help available on %s\n", argv[1]); + } else { + fprintf(f, "Too many arguements for command help.\n"); + } + } else if(!strcmp(argv[0], "STATUS")) { + if(argc == 1) { + int c = 0; + struct peer *peerptr = peers; + + if(!peerptr) + fprintf(f, "No session matches found.\n"); + else while(peerptr) { + fprintf(f, "Listing sessions:\n\n"); + fprintf(f, "Session %d\n", ++c); + fprintf(f, "Session existed for %d seconds\n", (int)time(0)-peerptr->time); + if(answered_call) + fprintf(f, "Call answered.\n"); + else fprintf(f, "Call ringing.\n"); + + peerptr = peerptr->next; + } + } else fprintf(f, "Too many arguments for command status.\n"); + } else if(!strcmp(argv[0], "ANSWER")) { + if(argc > 1) + fprintf(f, "Too many arguements for command answer\n"); + else answer_call(); + } else if(!strcmp(argv[0], "REJECT")) { + if(argc > 1) + fprintf(f, "Too many arguements for command reject\n"); + else { + fprintf(f, "Rejecting current phone call.\n"); + reject_call(); + } + } else if(!strcmp(argv[0], "CALL")) { + if(argc > 2) + fprintf(f, "Too many arguements for command call\n"); + else { + call(f, argv[1]); + } + } else if(!strcmp(argv[0], "DUMP")) { + if(argc > 1) + fprintf(f, "Too many arguements for command dump\n"); + else { + dump_call(); + } + } else if(!strcmp(argv[0], "DTMF")) { + if(argc > 2) + { + fprintf(f, "Too many arguements for command dtmf\n"); + return; + } + if (argc < 1) + { + fprintf(f, "Too many arguements for command dtmf\n"); + return; + } + if(most_recent_answer) + iax_send_dtmf(most_recent_answer->session,*argv[1]); + } else if(!strcmp(argv[0], "QUIT")) { + if(argc > 1) + fprintf(f, "Too many arguements for command quit\n"); + else { + fprintf(f, "Good bye!\n"); + exit(1); + } + } else fprintf(f, "Unknown command of %s\n", argv[0]); +} + +void +issue_prompt(FILE *f) +{ + fprintf(f, "TeleClient> "); + fflush(f); +} + +void +dump_array(FILE *f, char **array) { + while(*array) + fprintf(f, "%s\n", *array++); +} Added: freeswitch/trunk/src/mod/endpoints/mod_iax/winpoop.h ============================================================================== --- (empty file) +++ freeswitch/trunk/src/mod/endpoints/mod_iax/winpoop.h Thu May 8 19:25:36 2008 @@ -0,0 +1,40 @@ +/* + * Functions Windows doesn't have... but should + * Copyright(C) 2001, Linux Support Services, Inc. + * + * Distributed under GNU LGPL. + * + * These are NOT fully compliant with BSD 4.3 and are not + * threadsafe. + * + */ + +#ifndef _winpoop_h +#define _winpoop_h + +#if defined(_MSC_VER) +#define INLINE __inline +#else +#define INLINE inline +#endif + +#include <winsock.h> + +void gettimeofday(struct timeval *tv, void /*struct timezone*/ *tz); + +static INLINE int inet_aton(char *cp, struct in_addr *inp) +{ + int a1, a2, a3, a4; + unsigned int saddr; + if (sscanf(cp, "%d.%d.%d.%d", &a1, &a2, &a3, &a4) != 4) + return 0; + a1 &= 0xff; + a2 &= 0xff; + a3 &= 0xff; + a4 &= 0xff; + saddr = (a1 << 24) | (a2 << 16) | (a3 << 8) | a4; + inp->s_addr = htonl(saddr); + return 1; +} + +#endif