diff options
Diffstat (limited to 'toxrtp')
-rw-r--r-- | toxrtp/Makefile.inc | 34 | ||||
-rw-r--r-- | toxrtp/tests/Makefile.inc | 1 | ||||
-rw-r--r-- | toxrtp/tests/test_bidirect.c | 109 | ||||
-rw-r--r-- | toxrtp/tests/test_headers.c | 316 | ||||
-rw-r--r-- | toxrtp/tests/test_helper.c | 83 | ||||
-rw-r--r-- | toxrtp/tests/test_helper.h | 61 | ||||
-rw-r--r-- | toxrtp/toxrtp.c | 693 | ||||
-rw-r--r-- | toxrtp/toxrtp.h | 188 | ||||
-rw-r--r-- | toxrtp/toxrtp_error.c | 68 | ||||
-rw-r--r-- | toxrtp/toxrtp_error.h | 25 | ||||
-rw-r--r-- | toxrtp/toxrtp_error_id.h | 32 | ||||
-rw-r--r-- | toxrtp/toxrtp_helper.c | 208 | ||||
-rw-r--r-- | toxrtp/toxrtp_helper.h | 77 | ||||
-rw-r--r-- | toxrtp/toxrtp_message.c | 351 | ||||
-rw-r--r-- | toxrtp/toxrtp_message.h | 111 |
15 files changed, 0 insertions, 2357 deletions
diff --git a/toxrtp/Makefile.inc b/toxrtp/Makefile.inc deleted file mode 100644 index 801a7fd3..00000000 --- a/toxrtp/Makefile.inc +++ /dev/null | |||
@@ -1,34 +0,0 @@ | |||
1 | if BUILD_AV | ||
2 | |||
3 | lib_LTLIBRARIES += libtoxrtp.la | ||
4 | |||
5 | libtoxrtp_la_include_HEADERS = \ | ||
6 | ../toxrtp/toxrtp.h | ||
7 | |||
8 | libtoxrtp_la_includedir = $(includedir)/tox | ||
9 | |||
10 | libtoxrtp_la_SOURCES = ../toxrtp/toxrtp_error.h \ | ||
11 | ../toxrtp/toxrtp_error.c \ | ||
12 | ../toxrtp/toxrtp_error_id.h \ | ||
13 | ../toxrtp/toxrtp_helper.h \ | ||
14 | ../toxrtp/toxrtp_helper.c \ | ||
15 | ../toxrtp/toxrtp.h \ | ||
16 | ../toxrtp/toxrtp.c \ | ||
17 | ../toxrtp/toxrtp_message.h \ | ||
18 | ../toxrtp/toxrtp_message.c \ | ||
19 | ../toxcore/network.h \ | ||
20 | ../toxcore/network.c \ | ||
21 | ../toxcore/util.h \ | ||
22 | ../toxcore/util.c | ||
23 | |||
24 | libtoxrtp_la_CFLAGS = -I../toxcore \ | ||
25 | -I../toxrtp \ | ||
26 | $(NACL_CFLAGS) | ||
27 | |||
28 | libtoxrtp_la_LDFLAGS = $(TOXRTP_LT_LDFLAGS) \ | ||
29 | $(NACL_LDFLAGS) \ | ||
30 | $(EXTRA_LT_LDFLAGS) | ||
31 | |||
32 | libtoxrtp_la_LIBS = $(NACL_LIBS) | ||
33 | |||
34 | endif | ||
diff --git a/toxrtp/tests/Makefile.inc b/toxrtp/tests/Makefile.inc deleted file mode 100644 index 8d1c8b69..00000000 --- a/toxrtp/tests/Makefile.inc +++ /dev/null | |||
@@ -1 +0,0 @@ | |||
1 | |||
diff --git a/toxrtp/tests/test_bidirect.c b/toxrtp/tests/test_bidirect.c deleted file mode 100644 index b5a0899e..00000000 --- a/toxrtp/tests/test_bidirect.c +++ /dev/null | |||
@@ -1,109 +0,0 @@ | |||
1 | #define _BSD_SOURCE | ||
2 | |||
3 | #include "../toxrtp.h" | ||
4 | #include "../toxrtp_message.h" | ||
5 | #include <stdio.h> | ||
6 | #include <stdlib.h> | ||
7 | #include <string.h> | ||
8 | #include <utime.h> | ||
9 | #include <assert.h> | ||
10 | |||
11 | #include "test_helper.h" | ||
12 | #include "../../toxcore/tox.h" | ||
13 | |||
14 | #ifdef _CT_BIDIRECT | ||
15 | |||
16 | int _print_help( const char* name ) | ||
17 | { | ||
18 | char* _help = malloc( 300 ); | ||
19 | memset(_help, '\0', 300); | ||
20 | |||
21 | strcat(_help, " Usage: "); | ||
22 | strcat(_help, name); | ||
23 | strcat(_help, "\n -d IP ( destination )\n" | ||
24 | " -p PORT ( dest Port )\n" | ||
25 | " -l PORT ( listen Port ) \n"); | ||
26 | |||
27 | puts ( _help ); | ||
28 | |||
29 | free(_help); | ||
30 | return FAILURE; | ||
31 | } | ||
32 | |||
33 | int main( int argc, char* argv[] ) | ||
34 | { | ||
35 | int status; | ||
36 | tox_IP_Port Ip_port; | ||
37 | const char* ip, *psend, *plisten; | ||
38 | uint16_t port_send, port_listen; | ||
39 | const uint8_t* test_bytes = "0123456789012345678901234567890123456789012345678901234567890123456789" | ||
40 | "0123456789012345678901234567890123456789012345678901234567890123456789" | ||
41 | "0123456789012345678901234567890123456789012345678901234567890123456789" | ||
42 | "0123456789012345678901234567890123456789012345678901234567890123456789"; | ||
43 | |||
44 | |||
45 | rtp_session_t* _m_session; | ||
46 | rtp_msg_t *_m_msg_R, *_m_msg_S; | ||
47 | arg_t* _list = parse_args ( argc, argv ); | ||
48 | |||
49 | ip = find_arg_duble(_list, "-d"); | ||
50 | psend = find_arg_duble(_list, "-p"); | ||
51 | plisten = find_arg_duble(_list, "-l"); | ||
52 | |||
53 | if ( !ip || !plisten || !psend ) | ||
54 | return _print_help(argv[0]); | ||
55 | |||
56 | port_send = atoi(psend); | ||
57 | port_listen = atoi(plisten); | ||
58 | |||
59 | IP_Port local, remote; | ||
60 | |||
61 | /* | ||
62 | * This is the Local ip. We initiate networking on | ||
63 | * this value for it's the local one. To make stuff simpler we receive over this value | ||
64 | * and send on the other one ( see remote ) | ||
65 | */ | ||
66 | local.ip.i = htonl(INADDR_ANY); | ||
67 | local.port = port_listen; | ||
68 | Networking_Core* _networking = new_networking(local.ip, port_listen); | ||
69 | |||
70 | if ( !_networking ) | ||
71 | return FAILURE; | ||
72 | |||
73 | int _socket = _networking->sock; | ||
74 | /* | ||
75 | * Now this is the remote. It's used by rtp_session_t to determine the receivers ip etc. | ||
76 | */ | ||
77 | t_setipport ( ip, port_send, &remote ); | ||
78 | _m_session = rtp_init_session(-1, -1); | ||
79 | rtp_add_receiver( _m_session, &remote ); | ||
80 | |||
81 | /* Now let's start our main loop in both recv and send mode */ | ||
82 | |||
83 | for ( ;; ) | ||
84 | { | ||
85 | /* | ||
86 | * This part checks for received messages and if gotten one | ||
87 | * display 'Received msg!' indicator and free message | ||
88 | */ | ||
89 | _m_msg_R = rtp_recv_msg ( _m_session ); | ||
90 | |||
91 | if ( _m_msg_R ) { | ||
92 | puts ( "Received msg!" ); | ||
93 | rtp_free_msg(_m_session, _m_msg_R); | ||
94 | } | ||
95 | /* -------------------- */ | ||
96 | |||
97 | /* | ||
98 | * This one makes a test msg and sends that message to the 'remote' | ||
99 | */ | ||
100 | _m_msg_S = rtp_msg_new ( _m_session, test_bytes, 280 ) ; | ||
101 | rtp_send_msg ( _m_session, _m_msg_S, _socket ); | ||
102 | usleep ( 10000 ); | ||
103 | /* -------------------- */ | ||
104 | } | ||
105 | |||
106 | return SUCCESS; | ||
107 | } | ||
108 | |||
109 | #endif /* _CT_BIDIRECT */ | ||
diff --git a/toxrtp/tests/test_headers.c b/toxrtp/tests/test_headers.c deleted file mode 100644 index be3f1375..00000000 --- a/toxrtp/tests/test_headers.c +++ /dev/null | |||
@@ -1,316 +0,0 @@ | |||
1 | /* test_headers.c | ||
2 | * | ||
3 | * Tests header parsing. You probably won't need this. !Red! | ||
4 | * | ||
5 | * | ||
6 | * Copyright (C) 2013 Tox project All Rights Reserved. | ||
7 | * | ||
8 | * This file is part of Tox. | ||
9 | * | ||
10 | * Tox is free software: you can redistribute it and/or modify | ||
11 | * it under the terms of the GNU General Public License as published by | ||
12 | * the Free Software Foundation, either version 3 of the License, or | ||
13 | * (at your option) any later version. | ||
14 | * | ||
15 | * Tox is distributed in the hope that it will be useful, | ||
16 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
17 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | ||
18 | * GNU General Public License for more details. | ||
19 | * | ||
20 | * You should have received a copy of the GNU General Public License | ||
21 | * along with Tox. If not, see <http://www.gnu.org/licenses/>. | ||
22 | * | ||
23 | */ | ||
24 | |||
25 | #include "test_helper.h" | ||
26 | #include "../toxrtp.h" | ||
27 | #include "../toxrtp_message.h" | ||
28 | |||
29 | #include <stdio.h> | ||
30 | #include <stdlib.h> | ||
31 | #include <string.h> | ||
32 | #include <utime.h> | ||
33 | #include <assert.h> | ||
34 | #include "../toxrtp_error_id.h" | ||
35 | |||
36 | #define _CT_HEADERS_ | ||
37 | |||
38 | #ifdef _CT_HEADERS | ||
39 | |||
40 | int _socket; | ||
41 | pthread_mutex_t _mutex; | ||
42 | |||
43 | int print_help() | ||
44 | { | ||
45 | puts ( | ||
46 | " Usage: Tuxrtp [-s (send mode) -d IP ( destination ) -p PORT ( dest Port )] \n" | ||
47 | " [-r ( recv mode ) ]" | ||
48 | ); | ||
49 | return FAILURE; | ||
50 | } | ||
51 | |||
52 | void print_session_stats ( rtp_session_t* _m_session ) | ||
53 | { | ||
54 | printf | ||
55 | ( | ||
56 | "Session test:\n" | ||
57 | "\tPackets sent:%d\n" | ||
58 | "\tPackets recv:%d\n\n" | ||
59 | "\tBytes sent:%d\n" | ||
60 | "\tBytes recv:%d\n\n" | ||
61 | "\tHeader CCSRs:%d\n" | ||
62 | , | ||
63 | _m_session->_packets_sent, | ||
64 | _m_session->_packets_recv, | ||
65 | _m_session->_bytes_sent, | ||
66 | _m_session->_bytes_recv, | ||
67 | _m_session->_cc | ||
68 | ); | ||
69 | |||
70 | uint8_t i; | ||
71 | for ( i = 0; i < _m_session->_cc; i++ ) { | ||
72 | printf ( | ||
73 | "\t%d > :%d\n", i, _m_session->_csrc[i] | ||
74 | ); | ||
75 | } | ||
76 | } | ||
77 | |||
78 | void print_header_info ( rtp_header_t* _header ) | ||
79 | { | ||
80 | printf | ||
81 | ( | ||
82 | "Header info:\n" | ||
83 | "\tVersion :%d\n" | ||
84 | "\tPadding :%d\n" | ||
85 | "\tExtension :%d\n" | ||
86 | "\tCSRC count :%d\n" | ||
87 | "\tPayload type :%d\n" | ||
88 | "\tMarker :%d\n\n" | ||
89 | |||
90 | "\tSSrc :%d\n" | ||
91 | "\tSequence num :%d\n" | ||
92 | "\tLenght: :%d\n" | ||
93 | "\tCSRC's:\n" | ||
94 | , | ||
95 | rtp_header_get_flag_version ( _header ), | ||
96 | rtp_header_get_flag_padding ( _header ), | ||
97 | rtp_header_get_flag_extension ( _header ), | ||
98 | rtp_header_get_flag_CSRC_count ( _header ), | ||
99 | rtp_header_get_setting_payload_type ( _header ), | ||
100 | rtp_header_get_setting_marker ( _header ), | ||
101 | |||
102 | _header->_ssrc, | ||
103 | _header->_sequence_number, | ||
104 | _header->_length | ||
105 | ); | ||
106 | |||
107 | |||
108 | uint8_t i; | ||
109 | for ( i = 0; i < rtp_header_get_flag_CSRC_count ( _header ); i++ ) { | ||
110 | printf ( | ||
111 | "\t%d > :%d\n", i, _header->_csrc[i] | ||
112 | ); | ||
113 | } | ||
114 | |||
115 | puts ( "\n" ); | ||
116 | } | ||
117 | |||
118 | void print_ext_header_info(rtp_ext_header_t* _ext_header) | ||
119 | { | ||
120 | printf | ||
121 | ( | ||
122 | "External Header info: \n" | ||
123 | "\tLenght :%d\n" | ||
124 | "\tID :%d\n" | ||
125 | "\tValue H :%d\n" | ||
126 | "\tValue W :%d\n\n", | ||
127 | _ext_header->_ext_len, | ||
128 | _ext_header->_ext_type, | ||
129 | rtp_get_resolution_marking_height(_ext_header, 0), | ||
130 | rtp_get_resolution_marking_width(_ext_header, 0) | ||
131 | ); | ||
132 | } | ||
133 | |||
134 | int rtp_handlepacket ( rtp_session_t* _session, rtp_msg_t* _msg ) | ||
135 | { | ||
136 | if ( !_msg ) | ||
137 | return FAILURE; | ||
138 | |||
139 | if ( rtp_check_late_message(_session, _msg) < 0 ) { | ||
140 | rtp_register_msg(_session, _msg); | ||
141 | } | ||
142 | |||
143 | if ( _session->_last_msg ) { | ||
144 | _session->_last_msg->_next = _msg; | ||
145 | _session->_last_msg = _msg; | ||
146 | } else { | ||
147 | _session->_last_msg = _session->_oldest_msg = _msg; | ||
148 | } | ||
149 | |||
150 | |||
151 | return SUCCESS; | ||
152 | } | ||
153 | |||
154 | void* receivepacket_callback(void* _p_session) | ||
155 | { | ||
156 | rtp_msg_t* _msg; | ||
157 | rtp_session_t* _session = _p_session; | ||
158 | |||
159 | uint32_t _bytes; | ||
160 | tox_IP_Port _from; | ||
161 | uint8_t _socket_data[MAX_UDP_PACKET_SIZE]; | ||
162 | |||
163 | int _m_socket = _socket; | ||
164 | |||
165 | while ( 1 ) | ||
166 | { | ||
167 | int _status = receivepacket ( _m_socket, &_from, _socket_data, &_bytes ); | ||
168 | |||
169 | if ( _status == FAILURE ) { /* nothing recved */ | ||
170 | usleep(1000); | ||
171 | continue; | ||
172 | } | ||
173 | |||
174 | pthread_mutex_lock ( &_mutex ); | ||
175 | |||
176 | _msg = rtp_msg_parse ( NULL, _socket_data, _bytes ); | ||
177 | rtp_handlepacket(_session, _msg); | ||
178 | |||
179 | pthread_mutex_unlock ( &_mutex ); | ||
180 | } | ||
181 | |||
182 | pthread_exit(NULL); | ||
183 | } | ||
184 | |||
185 | int main ( int argc, char* argv[] ) | ||
186 | { | ||
187 | arg_t* _list = parse_args ( argc, argv ); | ||
188 | |||
189 | if ( _list == NULL ) { /* failed */ | ||
190 | return print_help(); | ||
191 | } | ||
192 | |||
193 | pthread_mutex_init ( &_mutex, NULL ); | ||
194 | |||
195 | int status; | ||
196 | IP_Port Ip_port; | ||
197 | const char* ip; | ||
198 | uint16_t port; | ||
199 | |||
200 | |||
201 | const uint8_t* test_bytes [300]; | ||
202 | memset(test_bytes, 'a', 300); | ||
203 | |||
204 | rtp_session_t* _m_session; | ||
205 | rtp_msg_t* _m_msg; | ||
206 | |||
207 | if ( find_arg_simple ( _list, "-r" ) != FAILURE ) { /* Server mode */ | ||
208 | |||
209 | IP_Port LOCAL_IP; /* since you need at least 1 recv-er */ | ||
210 | LOCAL_IP.ip.i = htonl(INADDR_ANY); | ||
211 | LOCAL_IP.port = RTP_PORT; | ||
212 | LOCAL_IP.padding = -1; | ||
213 | |||
214 | _m_session = rtp_init_session ( -1, -1 ); | ||
215 | Networking_Core* _networking = new_networking(LOCAL_IP.ip, RTP_PORT_LISTEN); | ||
216 | _socket = _networking->sock; | ||
217 | |||
218 | |||
219 | if ( !_networking ){ | ||
220 | pthread_mutex_destroy ( &_mutex ); | ||
221 | return FAILURE; | ||
222 | } | ||
223 | |||
224 | int _socket = _networking->sock; | ||
225 | |||
226 | if ( status < 0 ) { | ||
227 | pthread_mutex_destroy ( &_mutex ); | ||
228 | return FAILURE; | ||
229 | } | ||
230 | /* -- start in recv mode, get 1 message and then analyze it -- */ | ||
231 | pthread_t _tid; | ||
232 | RUN_IN_THREAD(receivepacket_callback, _tid, _m_session) | ||
233 | |||
234 | for ( ; ; ) { /* Recv for x seconds */ | ||
235 | _m_msg = rtp_recv_msg ( _m_session ); | ||
236 | |||
237 | /* _m_msg = rtp_session_get_message_queded ( _m_session ); DEPRECATED */ | ||
238 | if ( _m_msg ) { | ||
239 | /*rtp_free_msg(_m_session, _m_msg); | ||
240 | _m_msg = NULL;*/ | ||
241 | printf("Timestamp: %d\n", _m_msg->_header->_timestamp); | ||
242 | } | ||
243 | |||
244 | usleep ( 10000 ); | ||
245 | } | ||
246 | |||
247 | if ( _m_msg->_header ) { | ||
248 | rtp_header_print ( _m_msg->_header ); | ||
249 | } | ||
250 | if ( _m_msg->_ext_header ){ | ||
251 | print_ext_header_info(_m_msg->_ext_header); | ||
252 | } | ||
253 | |||
254 | //print_session_stats ( _m_session ); | ||
255 | |||
256 | |||
257 | //printf ( "Payload: ( %d ) \n%s\n", _m_msg->_length, _m_msg->_data ); | ||
258 | |||
259 | |||
260 | } else if ( find_arg_simple ( _list, "-s" ) != FAILURE ) { | ||
261 | ip = find_arg_duble ( _list, "-d" ); | ||
262 | |||
263 | if ( ip == NULL ) { | ||
264 | pthread_mutex_destroy ( &_mutex ); | ||
265 | return FAILURE; | ||
266 | } | ||
267 | |||
268 | const char* _port = find_arg_duble ( _list, "-p" ); | ||
269 | |||
270 | if ( _port != NULL ) { | ||
271 | port = atoi ( _port ); | ||
272 | } | ||
273 | |||
274 | t_setipport ( ip, port, &Ip_port ); | ||
275 | printf ( "Remote: %s:%d\n", ip, port ); | ||
276 | |||
277 | Networking_Core* _networking = new_networking(Ip_port.ip, RTP_PORT); | ||
278 | |||
279 | if ( !_networking ){ | ||
280 | pthread_mutex_destroy ( &_mutex ); | ||
281 | return FAILURE; | ||
282 | } | ||
283 | |||
284 | int _socket = _networking->sock; | ||
285 | |||
286 | _m_session = rtp_init_session ( -1, -1 ); | ||
287 | rtp_add_receiver( _m_session, &Ip_port ); | ||
288 | //rtp_add_resolution_marking(_m_session, 1920, 1080); | ||
289 | //rtp_add_framerate_marking(_m_session, 1000); | ||
290 | |||
291 | puts ( "Now sending payload!\n" ); | ||
292 | uint16_t _first_sequ = _m_session->_sequence_number; | ||
293 | |||
294 | /* use already defined buffer lenght */ | ||
295 | while ( 1 ){ | ||
296 | _m_msg = rtp_msg_new ( _m_session, test_bytes, 300 ); | ||
297 | rtp_send_msg ( _m_session, _m_msg, _socket ); | ||
298 | usleep(10000); | ||
299 | } | ||
300 | |||
301 | if ( _m_session->_last_error ) { | ||
302 | puts ( _m_session->_last_error ); | ||
303 | } | ||
304 | |||
305 | return rtp_terminate_session(_m_session); | ||
306 | |||
307 | } else { | ||
308 | pthread_mutex_destroy ( &_mutex ); | ||
309 | return FAILURE; | ||
310 | } | ||
311 | pthread_mutex_destroy ( &_mutex ); | ||
312 | |||
313 | return SUCCESS; | ||
314 | } | ||
315 | |||
316 | #endif /* _CT_HEADERS */ | ||
diff --git a/toxrtp/tests/test_helper.c b/toxrtp/tests/test_helper.c deleted file mode 100644 index 526b6b38..00000000 --- a/toxrtp/tests/test_helper.c +++ /dev/null | |||
@@ -1,83 +0,0 @@ | |||
1 | /* test_helper.c | ||
2 | * | ||
3 | * Tests support. !Red! | ||
4 | * | ||
5 | * | ||
6 | * Copyright (C) 2013 Tox project All Rights Reserved. | ||
7 | * | ||
8 | * This file is part of Tox. | ||
9 | * | ||
10 | * Tox is free software: you can redistribute it and/or modify | ||
11 | * it under the terms of the GNU General Public License as published by | ||
12 | * the Free Software Foundation, either version 3 of the License, or | ||
13 | * (at your option) any later version. | ||
14 | * | ||
15 | * Tox is distributed in the hope that it will be useful, | ||
16 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
17 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | ||
18 | * GNU General Public License for more details. | ||
19 | * | ||
20 | * You should have received a copy of the GNU General Public License | ||
21 | * along with Tox. If not, see <http://www.gnu.org/licenses/>. | ||
22 | * | ||
23 | */ | ||
24 | |||
25 | #include "test_helper.h" | ||
26 | |||
27 | #include <string.h> | ||
28 | #include <stdlib.h> | ||
29 | |||
30 | arg_t* parse_args ( int argc, char* argv[] ) | ||
31 | { | ||
32 | arg_t* _list = calloc(sizeof(arg_t), 1); | ||
33 | _list->next = _list->prev = NULL; | ||
34 | |||
35 | arg_t* it = _list; | ||
36 | |||
37 | size_t val; | ||
38 | for ( val = 0; val < argc; val ++ ) { | ||
39 | it->value = argv[val]; | ||
40 | |||
41 | if ( val < argc - 1 ) { /* just about to end */ | ||
42 | it->next = calloc(sizeof(arg_t), 1); | ||
43 | it->next->prev = it; | ||
44 | it = it->next; | ||
45 | it->next = NULL; | ||
46 | } | ||
47 | } | ||
48 | |||
49 | return _list; | ||
50 | } | ||
51 | |||
52 | int find_arg_simple ( arg_t* _head, const char* _id ) | ||
53 | { | ||
54 | arg_t* it = _head; | ||
55 | |||
56 | int i; | ||
57 | for ( i = 1; it != NULL; it = it->next ) { | ||
58 | if ( strcmp ( _id, it->value ) == 0 ) { | ||
59 | return i; | ||
60 | } | ||
61 | |||
62 | i++; | ||
63 | } | ||
64 | |||
65 | return FAILURE; | ||
66 | } | ||
67 | |||
68 | const char* find_arg_duble ( arg_t* _head, const char* _id ) | ||
69 | { | ||
70 | arg_t* _it; | ||
71 | for ( _it = _head; _it != NULL; _it = _it->next ) { | ||
72 | if ( strcmp ( _id, _it->value ) == 0 ) { | ||
73 | if ( _it->next && _it->next->value[0] != '-' ) { /* exclude option */ | ||
74 | return _it->next->value; | ||
75 | } else { | ||
76 | return NULL; | ||
77 | } | ||
78 | } | ||
79 | } | ||
80 | |||
81 | return NULL; | ||
82 | } | ||
83 | |||
diff --git a/toxrtp/tests/test_helper.h b/toxrtp/tests/test_helper.h deleted file mode 100644 index de654743..00000000 --- a/toxrtp/tests/test_helper.h +++ /dev/null | |||
@@ -1,61 +0,0 @@ | |||
1 | /* test_helper.h | ||
2 | * | ||
3 | * Tests support. !Red! | ||
4 | * | ||
5 | * | ||
6 | * Copyright (C) 2013 Tox project All Rights Reserved. | ||
7 | * | ||
8 | * This file is part of Tox. | ||
9 | * | ||
10 | * Tox is free software: you can redistribute it and/or modify | ||
11 | * it under the terms of the GNU General Public License as published by | ||
12 | * the Free Software Foundation, either version 3 of the License, or | ||
13 | * (at your option) any later version. | ||
14 | * | ||
15 | * Tox is distributed in the hope that it will be useful, | ||
16 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
17 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | ||
18 | * GNU General Public License for more details. | ||
19 | * | ||
20 | * You should have received a copy of the GNU General Public License | ||
21 | * along with Tox. If not, see <http://www.gnu.org/licenses/>. | ||
22 | * | ||
23 | */ | ||
24 | |||
25 | #ifndef _TEST__HELPER_ | ||
26 | #define _TEST__HELPER_ | ||
27 | |||
28 | #include "../toxrtp_helper.h" | ||
29 | |||
30 | #define RTP_PORT 31003 | ||
31 | #define RTP_PORT_LISTEN 31001 | ||
32 | |||
33 | #define _SLEEP_INTERVAL 1000 | ||
34 | |||
35 | typedef struct arg_s { | ||
36 | const char* value; | ||
37 | struct arg_s* next; | ||
38 | struct arg_s* prev; | ||
39 | |||
40 | } arg_t; | ||
41 | |||
42 | |||
43 | |||
44 | /* Parses arguments into d-list arg_t */ | ||
45 | arg_t* parse_args ( int argc, char* argv[] ); | ||
46 | |||
47 | /* Get a single argument ( i.e. ./test -s |find if has 's' >> | find_arg_simple(_t, "-s") ) | ||
48 | * A little error checking, of course, returns FAILURE if not found and if found returns position | ||
49 | * where it's found. | ||
50 | */ | ||
51 | int find_arg_simple ( arg_t* _head, const char* _id ); | ||
52 | |||
53 | /* Get a single argument ( i.e. ./test -d 127.0.0.1 |get 'd' value >> | find_arg_duble(_t, "-d") ) | ||
54 | * A little error checking, of course, returns NULL if not found and if found returns value | ||
55 | * of that argument ( i.e. '127.0.0.1'). | ||
56 | */ | ||
57 | const char* find_arg_duble ( arg_t* _head, const char* _id ); | ||
58 | |||
59 | #endif /* _TEST__HELPER_ */ | ||
60 | |||
61 | |||
diff --git a/toxrtp/toxrtp.c b/toxrtp/toxrtp.c deleted file mode 100644 index 6844b0b1..00000000 --- a/toxrtp/toxrtp.c +++ /dev/null | |||
@@ -1,693 +0,0 @@ | |||
1 | /* rtp_impl.c | ||
2 | * | ||
3 | * Rtp implementation includes rtp_session_s struct which is a session identifier. | ||
4 | * It contains session information and it's a must for every session. | ||
5 | * It's best if you don't touch any variable directly but use callbacks to do so. !Red! | ||
6 | * | ||
7 | * | ||
8 | * Copyright (C) 2013 Tox project All Rights Reserved. | ||
9 | * | ||
10 | * This file is part of Tox. | ||
11 | * | ||
12 | * Tox is free software: you can redistribute it and/or modify | ||
13 | * it under the terms of the GNU General Public License as published by | ||
14 | * the Free Software Foundation, either version 3 of the License, or | ||
15 | * (at your option) any later version. | ||
16 | * | ||
17 | * Tox is distributed in the hope that it will be useful, | ||
18 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
19 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | ||
20 | * GNU General Public License for more details. | ||
21 | * | ||
22 | * You should have received a copy of the GNU General Public License | ||
23 | * along with Tox. If not, see <http://www.gnu.org/licenses/>. | ||
24 | * | ||
25 | */ | ||
26 | |||
27 | #ifdef HAVE_CONFIG_H | ||
28 | #include "config.h" | ||
29 | #endif /* HAVE_CONFIG_H */ | ||
30 | |||
31 | #include "toxrtp.h" | ||
32 | #include "toxrtp_message.h" | ||
33 | #include "toxrtp_helper.h" | ||
34 | #include <assert.h> | ||
35 | #include <pthread.h> | ||
36 | #include "../toxcore/util.h" | ||
37 | #include "../toxcore/network.h" | ||
38 | |||
39 | /* Some defines */ | ||
40 | #define PAYLOAD_ID_VALUE_OPUS 1 | ||
41 | #define PAYLOAD_ID_VALUE_VP8 2 | ||
42 | |||
43 | #define size_32 4 | ||
44 | /* End of defines */ | ||
45 | |||
46 | #ifdef _USE_ERRORS | ||
47 | #include "toxrtp_error_id.h" | ||
48 | #endif /* _USE_ERRORS */ | ||
49 | |||
50 | static const uint32_t _payload_table[] = /* PAYLOAD TABLE */ | ||
51 | { | ||
52 | 8000, 8000, 8000, 8000, 8000, 8000, 16000, 8000, 8000, 8000, /* 0-9 */ | ||
53 | 44100, 44100, 0, 0, 90000, 8000, 11025, 22050, 0, 0, /* 10-19 */ | ||
54 | 0, 0, 0, 0, 0, 90000, 90000, 0, 90000, 0, /* 20-29 */ | ||
55 | 0, 90000, 90000, 90000, 90000, 0, 0, 0, 0, 0, /* 30-39 */ | ||
56 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 40-49 */ | ||
57 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 50-59 */ | ||
58 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 60-69 */ | ||
59 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 70-79 */ | ||
60 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 80-89 */ | ||
61 | 0, 0, 0, 0, 0, 0, PAYLOAD_ID_VALUE_OPUS, 0, 0, 0, /* 90-99 */ | ||
62 | 0, 0, 0, 0, 0, 0, PAYLOAD_ID_VALUE_VP8, 0, 0, 0, /* 100-109 */ | ||
63 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 110-119 */ | ||
64 | 0, 0, 0, 0, 0, 0, 0, 0 /* 120-127 */ | ||
65 | }; | ||
66 | |||
67 | /* Current compatibility solution */ | ||
68 | int m_sendpacket(Networking_Core* _core_handler, void *ip_port, uint8_t *data, uint32_t length) | ||
69 | { | ||
70 | return sendpacket(_core_handler, *((IP_Port*) ip_port), data, length); | ||
71 | } | ||
72 | |||
73 | rtp_session_t* rtp_init_session ( int max_users, int _multi_session ) | ||
74 | { | ||
75 | #ifdef _USE_ERRORS | ||
76 | REGISTER_RTP_ERRORS | ||
77 | #endif /* _USE_ERRORS */ | ||
78 | |||
79 | rtp_session_t* _retu = calloc(sizeof(rtp_session_t), 1); | ||
80 | assert(_retu); | ||
81 | |||
82 | _retu->_dest_list = _retu->_last_user = NULL; | ||
83 | |||
84 | _retu->_max_users = max_users; | ||
85 | _retu->_packets_recv = 0; | ||
86 | _retu->_packets_sent = 0; | ||
87 | _retu->_bytes_sent = 0; | ||
88 | _retu->_bytes_recv = 0; | ||
89 | _retu->_last_error = NULL; | ||
90 | _retu->_packet_loss = 0; | ||
91 | |||
92 | /* | ||
93 | * SET HEADER FIELDS | ||
94 | */ | ||
95 | |||
96 | _retu->_version = RTP_VERSION; /* It's always 2 */ | ||
97 | _retu->_padding = 0; /* If some additional data is needed about | ||
98 | * the packet */ | ||
99 | _retu->_extension = 0; /* If extension to header is needed */ | ||
100 | _retu->_cc = 1; /* It basically represents amount of contributors */ | ||
101 | _retu->_csrc = NULL; /* Container */ | ||
102 | _retu->_ssrc = t_random ( -1 ); | ||
103 | _retu->_marker = 0; | ||
104 | _retu->_payload_type = 0; /* You should specify payload type */ | ||
105 | |||
106 | /* Sequence starts at random number and goes to _MAX_SEQU_NUM */ | ||
107 | _retu->_sequence_number = t_random ( _MAX_SEQU_NUM ); | ||
108 | _retu->_last_sequence_number = _retu->_sequence_number; /* Do not touch this variable */ | ||
109 | |||
110 | _retu->_initial_time = t_time(); /* In seconds */ | ||
111 | assert(_retu->_initial_time); | ||
112 | _retu->_time_elapsed = 0; /* In seconds */ | ||
113 | |||
114 | _retu->_ext_header = NULL; /* When needed allocate */ | ||
115 | _retu->_exthdr_framerate = -1; | ||
116 | _retu->_exthdr_resolution = -1; | ||
117 | |||
118 | _retu->_csrc = calloc(sizeof(uint32_t), 1); | ||
119 | assert(_retu->_csrc); | ||
120 | |||
121 | _retu->_csrc[0] = _retu->_ssrc; /* Set my ssrc to the list receive */ | ||
122 | |||
123 | _retu->_prefix_length = 0; | ||
124 | _retu->_prefix = NULL; | ||
125 | |||
126 | _retu->_multi_session = _multi_session; | ||
127 | |||
128 | /* Initial */ | ||
129 | _retu->_current_framerate = 0; | ||
130 | |||
131 | |||
132 | _retu->_oldest_msg = _retu->_last_msg = NULL; | ||
133 | |||
134 | pthread_mutex_init(&_retu->_mutex, NULL); | ||
135 | /* | ||
136 | * | ||
137 | */ | ||
138 | return _retu; | ||
139 | } | ||
140 | |||
141 | int rtp_terminate_session ( rtp_session_t* _session ) | ||
142 | { | ||
143 | if ( !_session ) | ||
144 | return FAILURE; | ||
145 | |||
146 | if ( _session->_dest_list ){ | ||
147 | rtp_dest_list_t* _fordel = NULL; | ||
148 | rtp_dest_list_t* _tmp = _session->_dest_list; | ||
149 | |||
150 | while( _tmp ){ | ||
151 | _fordel = _tmp; | ||
152 | _tmp = _tmp->next; | ||
153 | free(_fordel); | ||
154 | } | ||
155 | } | ||
156 | |||
157 | if ( _session->_ext_header ) | ||
158 | free ( _session->_ext_header ); | ||
159 | |||
160 | if ( _session->_csrc ) | ||
161 | free ( _session->_csrc ); | ||
162 | |||
163 | if ( _session->_prefix ) | ||
164 | free ( _session->_prefix ); | ||
165 | |||
166 | pthread_mutex_destroy(&_session->_mutex); | ||
167 | |||
168 | /* And finally free session */ | ||
169 | free ( _session ); | ||
170 | |||
171 | return SUCCESS; | ||
172 | } | ||
173 | |||
174 | uint16_t rtp_get_resolution_marking_height ( rtp_ext_header_t* _header, uint32_t _position ) | ||
175 | { | ||
176 | if ( _header->_ext_type & RTP_EXT_TYPE_RESOLUTION ) | ||
177 | return _header->_hd_ext[_position]; | ||
178 | else | ||
179 | return 0; | ||
180 | } | ||
181 | |||
182 | uint16_t rtp_get_resolution_marking_width ( rtp_ext_header_t* _header, uint32_t _position ) | ||
183 | { | ||
184 | if ( _header->_ext_type & RTP_EXT_TYPE_RESOLUTION ) | ||
185 | return ( _header->_hd_ext[_position] >> 16 ); | ||
186 | else | ||
187 | return 0; | ||
188 | } | ||
189 | |||
190 | void rtp_free_msg ( rtp_session_t* _session, rtp_msg_t* _message ) | ||
191 | { | ||
192 | free ( _message->_data ); | ||
193 | |||
194 | if ( !_session ){ | ||
195 | free ( _message->_header->_csrc ); | ||
196 | if ( _message->_ext_header ){ | ||
197 | free ( _message->_ext_header->_hd_ext ); | ||
198 | free ( _message->_ext_header ); | ||
199 | } | ||
200 | } else { | ||
201 | if ( _session->_csrc != _message->_header->_csrc ) | ||
202 | free ( _message->_header->_csrc ); | ||
203 | if ( _message->_ext_header && _session->_ext_header != _message->_ext_header ) { | ||
204 | free ( _message->_ext_header->_hd_ext ); | ||
205 | free ( _message->_ext_header ); | ||
206 | } | ||
207 | } | ||
208 | |||
209 | free ( _message->_header ); | ||
210 | free ( _message ); | ||
211 | } | ||
212 | |||
213 | rtp_header_t* rtp_build_header ( rtp_session_t* _session ) | ||
214 | { | ||
215 | rtp_header_t* _retu; | ||
216 | _retu = calloc ( sizeof * _retu, 1 ); | ||
217 | assert(_retu); | ||
218 | |||
219 | rtp_header_add_flag_version ( _retu, _session->_version ); | ||
220 | rtp_header_add_flag_padding ( _retu, _session->_padding ); | ||
221 | rtp_header_add_flag_extension ( _retu, _session->_extension ); | ||
222 | rtp_header_add_flag_CSRC_count ( _retu, _session->_cc ); | ||
223 | rtp_header_add_setting_marker ( _retu, _session->_marker ); | ||
224 | rtp_header_add_setting_payload ( _retu, _session->_payload_type ); | ||
225 | |||
226 | _retu->_sequence_number = _session->_sequence_number; | ||
227 | _session->_time_elapsed = t_time() - _session->_initial_time; | ||
228 | _retu->_timestamp = t_time(); | ||
229 | _retu->_ssrc = _session->_ssrc; | ||
230 | |||
231 | if ( _session->_cc > 0 ) { | ||
232 | _retu->_csrc = calloc(sizeof(uint32_t), _session->_cc); | ||
233 | assert(_retu->_csrc); | ||
234 | |||
235 | int i; | ||
236 | |||
237 | for ( i = 0; i < _session->_cc; i++ ) { | ||
238 | _retu->_csrc[i] = _session->_csrc[i]; | ||
239 | } | ||
240 | } else { | ||
241 | _retu->_csrc = NULL; | ||
242 | } | ||
243 | |||
244 | _retu->_length = _MIN_HEADER_LENGTH + ( _session->_cc * size_32 ); | ||
245 | |||
246 | return _retu; | ||
247 | } | ||
248 | |||
249 | void rtp_set_payload_type ( rtp_session_t* _session, uint8_t _payload_value ) | ||
250 | { | ||
251 | _session->_payload_type = _payload_value; | ||
252 | } | ||
253 | uint32_t rtp_get_payload_type ( rtp_session_t* _session ) | ||
254 | { | ||
255 | return _payload_table[_session->_payload_type]; | ||
256 | } | ||
257 | |||
258 | int rtp_add_receiver ( rtp_session_t* _session, tox_IP_Port* _dest ) | ||
259 | { | ||
260 | if ( !_session ) | ||
261 | return FAILURE; | ||
262 | |||
263 | rtp_dest_list_t* _new_user = calloc(sizeof(rtp_dest_list_t), 1); | ||
264 | assert(_new_user); | ||
265 | |||
266 | _new_user->next = NULL; | ||
267 | _new_user->_dest = *_dest; | ||
268 | |||
269 | if ( _session->_last_user == NULL ) { /* New member */ | ||
270 | _session->_dest_list = _session->_last_user = _new_user; | ||
271 | |||
272 | } else { /* Append */ | ||
273 | _session->_last_user->next = _new_user; | ||
274 | _session->_last_user = _new_user; | ||
275 | } | ||
276 | |||
277 | return SUCCESS; | ||
278 | } | ||
279 | |||
280 | int rtp_send_msg ( rtp_session_t* _session, rtp_msg_t* _msg, void* _core_handler ) | ||
281 | { | ||
282 | if ( !_msg || _msg->_data == NULL || _msg->_length <= 0 ) { | ||
283 | t_perror ( RTP_ERROR_EMPTY_MESSAGE ); | ||
284 | return FAILURE; | ||
285 | } | ||
286 | |||
287 | int _last; | ||
288 | unsigned long long _total = 0; | ||
289 | |||
290 | size_t _length = _msg->_length; | ||
291 | uint8_t _send_data [ MAX_UDP_PACKET_SIZE ]; | ||
292 | |||
293 | uint16_t _prefix_length = _session->_prefix_length; | ||
294 | |||
295 | _send_data[0] = 70; | ||
296 | |||
297 | if ( _session->_prefix && _length + _prefix_length < MAX_UDP_PACKET_SIZE ) { | ||
298 | /*t_memcpy(_send_data, _session->_prefix, _prefix_length);*/ | ||
299 | t_memcpy ( _send_data + 1, _msg->_data, _length ); | ||
300 | } else { | ||
301 | t_memcpy ( _send_data + 1, _msg->_data, _length ); | ||
302 | } | ||
303 | |||
304 | /* Set sequ number */ | ||
305 | if ( _session->_sequence_number >= _MAX_SEQU_NUM ) { | ||
306 | _session->_sequence_number = 0; | ||
307 | } else { | ||
308 | _session->_sequence_number++; | ||
309 | } | ||
310 | |||
311 | /* Start sending loop */ | ||
312 | rtp_dest_list_t* _it; | ||
313 | for ( _it = _session->_dest_list; _it != NULL; _it = _it->next ) { | ||
314 | |||
315 | _last = m_sendpacket ( _core_handler, &_it->_dest, _send_data, _length + 1); | ||
316 | |||
317 | if ( _last < 0 ) { | ||
318 | t_perror ( RTP_ERROR_STD_SEND_FAILURE ); | ||
319 | printf("Stderror: %s", strerror(errno)); | ||
320 | } else { | ||
321 | _session->_packets_sent ++; | ||
322 | _total += _last; | ||
323 | } | ||
324 | |||
325 | } | ||
326 | |||
327 | rtp_free_msg ( _session, _msg ); | ||
328 | _session->_bytes_sent += _total; | ||
329 | return SUCCESS; | ||
330 | } | ||
331 | |||
332 | rtp_msg_t* rtp_recv_msg ( rtp_session_t* _session ) | ||
333 | { | ||
334 | if ( !_session ) | ||
335 | return NULL; | ||
336 | |||
337 | rtp_msg_t* _retu = _session->_oldest_msg; | ||
338 | |||
339 | pthread_mutex_lock(&_session->_mutex); | ||
340 | |||
341 | if ( _retu ) | ||
342 | _session->_oldest_msg = _retu->_next; | ||
343 | |||
344 | if ( !_session->_oldest_msg ) | ||
345 | _session->_last_msg = NULL; | ||
346 | |||
347 | pthread_mutex_unlock(&_session->_mutex); | ||
348 | |||
349 | return _retu; | ||
350 | } | ||
351 | |||
352 | void rtp_store_msg ( rtp_session_t* _session, rtp_msg_t* _msg ) | ||
353 | { | ||
354 | if ( rtp_check_late_message(_session, _msg) < 0 ) { | ||
355 | rtp_register_msg(_session, _msg); | ||
356 | } | ||
357 | |||
358 | pthread_mutex_lock(&_session->_mutex); | ||
359 | |||
360 | if ( _session->_last_msg ) { | ||
361 | _session->_last_msg->_next = _msg; | ||
362 | _session->_last_msg = _msg; | ||
363 | } else { | ||
364 | _session->_last_msg = _session->_oldest_msg = _msg; | ||
365 | } | ||
366 | |||
367 | pthread_mutex_unlock(&_session->_mutex); | ||
368 | return; | ||
369 | } | ||
370 | |||
371 | int rtp_release_session_recv ( rtp_session_t* _session ) | ||
372 | { | ||
373 | if ( !_session ){ | ||
374 | return FAILURE; | ||
375 | } | ||
376 | |||
377 | rtp_msg_t* _tmp,* _it; | ||
378 | |||
379 | pthread_mutex_lock(&_session->_mutex); | ||
380 | |||
381 | for ( _it = _session->_oldest_msg; _it; _it = _tmp ){ | ||
382 | _tmp = _it->_next; | ||
383 | rtp_free_msg(_session, _it); | ||
384 | } | ||
385 | |||
386 | _session->_last_msg = _session->_oldest_msg = NULL; | ||
387 | |||
388 | pthread_mutex_unlock(&_session->_mutex); | ||
389 | |||
390 | return SUCCESS; | ||
391 | } | ||
392 | |||
393 | rtp_msg_t* rtp_msg_new ( rtp_session_t* _session, const uint8_t* _data, uint32_t _length ) | ||
394 | { | ||
395 | if ( !_session ) | ||
396 | return NULL; | ||
397 | |||
398 | uint8_t* _from_pos; | ||
399 | rtp_msg_t* _retu = calloc(sizeof(rtp_msg_t), 1); | ||
400 | assert(_retu); | ||
401 | |||
402 | /* Sets header values and copies the extension header in _retu */ | ||
403 | _retu->_header = rtp_build_header ( _session ); /* It allocates memory and all */ | ||
404 | _retu->_ext_header = _session->_ext_header; | ||
405 | |||
406 | uint32_t _total_lenght = _length + _retu->_header->_length; | ||
407 | |||
408 | if ( _retu->_ext_header ) { | ||
409 | |||
410 | _total_lenght += ( _MIN_EXT_HEADER_LENGTH + _retu->_ext_header->_ext_len * size_32 ); | ||
411 | /* Allocate Memory for _retu->_data */ | ||
412 | _retu->_data = calloc ( sizeof _retu->_data, _total_lenght ); | ||
413 | assert(_retu->_data); | ||
414 | |||
415 | _from_pos = rtp_add_header ( _retu->_header, _retu->_data ); | ||
416 | _from_pos = rtp_add_extention_header ( _retu->_ext_header, _from_pos + 1 ); | ||
417 | } else { | ||
418 | /* Allocate Memory for _retu->_data */ | ||
419 | _retu->_data = calloc ( sizeof _retu->_data, _total_lenght ); | ||
420 | assert(_retu->_data); | ||
421 | |||
422 | _from_pos = rtp_add_header ( _retu->_header, _retu->_data ); | ||
423 | } | ||
424 | |||
425 | /* | ||
426 | * Parses the extension header into the message | ||
427 | * Of course if any | ||
428 | */ | ||
429 | |||
430 | /* Appends _data on to _retu->_data */ | ||
431 | t_memcpy ( _from_pos + 1, _data, _length ); | ||
432 | |||
433 | _retu->_length = _total_lenght; | ||
434 | |||
435 | _retu->_next = NULL; | ||
436 | |||
437 | return _retu; | ||
438 | } | ||
439 | |||
440 | rtp_msg_t* rtp_msg_parse ( rtp_session_t* _session, const uint8_t* _data, uint32_t _length ) | ||
441 | { | ||
442 | rtp_msg_t* _retu = calloc(sizeof(rtp_msg_t), 1); | ||
443 | assert(_retu); | ||
444 | |||
445 | _retu->_header = rtp_extract_header ( _data, _length ); /* It allocates memory and all */ | ||
446 | if ( !_retu->_header ){ | ||
447 | free(_retu); | ||
448 | return NULL; | ||
449 | } | ||
450 | |||
451 | _retu->_length = _length - _retu->_header->_length; | ||
452 | |||
453 | uint16_t _from_pos = _retu->_header->_length; | ||
454 | |||
455 | |||
456 | if ( rtp_header_get_flag_extension ( _retu->_header ) ) { | ||
457 | _retu->_ext_header = rtp_extract_ext_header ( _data + _from_pos, _length ); | ||
458 | if ( _retu->_ext_header ){ | ||
459 | _retu->_length -= ( _MIN_EXT_HEADER_LENGTH + _retu->_ext_header->_ext_len * size_32 ); | ||
460 | _from_pos += ( _MIN_EXT_HEADER_LENGTH + _retu->_ext_header->_ext_len * size_32 ); | ||
461 | } else { | ||
462 | free (_retu->_ext_header); | ||
463 | free (_retu->_header); | ||
464 | free (_retu); | ||
465 | return NULL; | ||
466 | } | ||
467 | } else { | ||
468 | _retu->_ext_header = NULL; | ||
469 | } | ||
470 | |||
471 | /* Get the payload */ | ||
472 | _retu->_data = calloc ( sizeof ( uint8_t ), _retu->_length ); | ||
473 | assert(_retu->_data); | ||
474 | |||
475 | t_memcpy ( _retu->_data, _data + _from_pos, _length - _from_pos ); | ||
476 | |||
477 | _retu->_next = NULL; | ||
478 | |||
479 | |||
480 | if ( _session && !_session->_multi_session && rtp_check_late_message(_session, _retu) < 0 ){ | ||
481 | rtp_register_msg(_session, _retu); | ||
482 | } | ||
483 | |||
484 | return _retu; | ||
485 | } | ||
486 | |||
487 | int rtp_check_late_message (rtp_session_t* _session, rtp_msg_t* _msg) | ||
488 | { | ||
489 | /* | ||
490 | * Check Sequence number. If this new msg has lesser number then the _session->_last_sequence_number | ||
491 | * it shows that the message came in late | ||
492 | */ | ||
493 | if ( _msg->_header->_sequence_number < _session->_last_sequence_number && | ||
494 | _msg->_header->_timestamp < _session->_current_timestamp | ||
495 | ) { | ||
496 | return SUCCESS; /* Drop the packet. You can check if the packet dropped by checking _packet_loss increment. */ | ||
497 | } | ||
498 | return FAILURE; | ||
499 | } | ||
500 | |||
501 | void rtp_register_msg ( rtp_session_t* _session, rtp_msg_t* _msg ) | ||
502 | { | ||
503 | _session->_last_sequence_number = _msg->_header->_sequence_number; | ||
504 | _session->_current_timestamp = _msg->_header->_timestamp; | ||
505 | } | ||
506 | |||
507 | |||
508 | int rtp_add_resolution_marking ( rtp_session_t* _session, uint16_t _width, uint16_t _height ) | ||
509 | { | ||
510 | if ( !_session ) | ||
511 | return FAILURE; | ||
512 | |||
513 | rtp_ext_header_t* _ext_header = _session->_ext_header; | ||
514 | _session->_exthdr_resolution = 0; | ||
515 | |||
516 | if ( ! ( _ext_header ) ) { | ||
517 | _session->_ext_header = calloc (sizeof(rtp_ext_header_t), 1); | ||
518 | assert(_session->_ext_header); | ||
519 | |||
520 | _session->_extension = 1; | ||
521 | _session->_ext_header->_ext_len = 1; | ||
522 | _ext_header = _session->_ext_header; | ||
523 | _session->_ext_header->_hd_ext = calloc(sizeof(uint32_t), 1); | ||
524 | assert(_session->_ext_header->_hd_ext); | ||
525 | |||
526 | } else { /* If there is need for more headers this will be needed to change */ | ||
527 | if ( !(_ext_header->_ext_type & RTP_EXT_TYPE_RESOLUTION) ){ | ||
528 | uint32_t _exthdr_framerate = _ext_header->_hd_ext[_session->_exthdr_framerate]; | ||
529 | /* it's position is at 2nd place by default */ | ||
530 | _session->_exthdr_framerate ++; | ||
531 | |||
532 | /* Update length */ | ||
533 | _ext_header->_ext_len++; | ||
534 | |||
535 | /* Allocate the value */ | ||
536 | _ext_header->_hd_ext = realloc(_ext_header->_hd_ext, sizeof(rtp_ext_header_t) * _ext_header->_ext_len); | ||
537 | assert(_ext_header->_hd_ext); | ||
538 | |||
539 | /* Reset other values */ | ||
540 | _ext_header->_hd_ext[_session->_exthdr_framerate] = _exthdr_framerate; | ||
541 | } | ||
542 | } | ||
543 | |||
544 | /* Add flag */ | ||
545 | _ext_header->_ext_type |= RTP_EXT_TYPE_RESOLUTION; | ||
546 | |||
547 | _ext_header->_hd_ext[_session->_exthdr_resolution] = _width << 16 | ( uint32_t ) _height; | ||
548 | |||
549 | return SUCCESS; | ||
550 | } | ||
551 | |||
552 | int rtp_remove_resolution_marking ( rtp_session_t* _session ) | ||
553 | { | ||
554 | if ( _session->_extension == 0 || ! ( _session->_ext_header ) ) { | ||
555 | t_perror ( RTP_ERROR_INVALID_EXTERNAL_HEADER ); | ||
556 | return FAILURE; | ||
557 | } | ||
558 | |||
559 | if ( !( _session->_ext_header->_ext_type & RTP_EXT_TYPE_RESOLUTION ) ) { | ||
560 | t_perror ( RTP_ERROR_INVALID_EXTERNAL_HEADER ); | ||
561 | return FAILURE; | ||
562 | } | ||
563 | |||
564 | _session->_ext_header->_ext_type &= ~RTP_EXT_TYPE_RESOLUTION; /* Remove the flag */ | ||
565 | _session->_exthdr_resolution = -1; /* Remove identifier */ | ||
566 | |||
567 | /* Check if extension is empty */ | ||
568 | if ( _session->_ext_header->_ext_type == 0 ){ | ||
569 | |||
570 | free ( _session->_ext_header->_hd_ext ); | ||
571 | free ( _session->_ext_header ); | ||
572 | |||
573 | _session->_ext_header = NULL; /* It's very important */ | ||
574 | _session->_extension = 0; | ||
575 | |||
576 | } else { | ||
577 | _session->_ext_header->_ext_len --; | ||
578 | |||
579 | /* this will also be needed to change if there are more than 2 headers */ | ||
580 | if ( _session->_ext_header->_ext_type & RTP_EXT_TYPE_FRAMERATE ){ | ||
581 | memcpy(_session->_ext_header->_hd_ext + 1, _session->_ext_header->_hd_ext, _session->_ext_header->_ext_len); | ||
582 | _session->_exthdr_framerate = 0; | ||
583 | _session->_ext_header->_hd_ext = realloc( _session->_ext_header->_hd_ext, sizeof( rtp_ext_header_t ) * _session->_ext_header->_ext_len ); | ||
584 | assert(_session->_ext_header->_hd_ext); | ||
585 | } | ||
586 | } | ||
587 | |||
588 | return SUCCESS; | ||
589 | } | ||
590 | |||
591 | int rtp_add_framerate_marking ( rtp_session_t* _session, uint32_t _value ) | ||
592 | { | ||
593 | if ( !_session ) | ||
594 | return FAILURE; | ||
595 | |||
596 | rtp_ext_header_t* _ext_header = _session->_ext_header; | ||
597 | _session->_exthdr_framerate = 0; | ||
598 | |||
599 | if ( ! ( _ext_header ) ) { | ||
600 | _session->_ext_header = calloc (sizeof(rtp_ext_header_t), 1); | ||
601 | assert(_session->_ext_header); | ||
602 | |||
603 | _session->_extension = 1; | ||
604 | _session->_ext_header->_ext_len = 1; | ||
605 | _ext_header = _session->_ext_header; | ||
606 | _session->_ext_header->_hd_ext = calloc(sizeof(uint32_t), 1); | ||
607 | assert(_session->_ext_header->_hd_ext); | ||
608 | } else { /* If there is need for more headers this will be needed to change */ | ||
609 | if ( !(_ext_header->_ext_type & RTP_EXT_TYPE_FRAMERATE) ){ | ||
610 | /* it's position is at 2nd place by default */ | ||
611 | _session->_exthdr_framerate ++; | ||
612 | |||
613 | /* Update length */ | ||
614 | _ext_header->_ext_len++; | ||
615 | |||
616 | /* Allocate the value */ | ||
617 | _ext_header->_hd_ext = realloc(_ext_header->_hd_ext, sizeof(rtp_ext_header_t) * _ext_header->_ext_len); | ||
618 | assert(_ext_header->_hd_ext); | ||
619 | |||
620 | } | ||
621 | } | ||
622 | |||
623 | /* Add flag */ | ||
624 | _ext_header->_ext_type |= RTP_EXT_TYPE_FRAMERATE; | ||
625 | |||
626 | _ext_header->_hd_ext[_session->_exthdr_framerate] = _value; | ||
627 | |||
628 | return SUCCESS; | ||
629 | } | ||
630 | |||
631 | |||
632 | int rtp_remove_framerate_marking ( rtp_session_t* _session ) | ||
633 | { | ||
634 | if ( _session->_extension == 0 || ! ( _session->_ext_header ) ) { | ||
635 | t_perror ( RTP_ERROR_INVALID_EXTERNAL_HEADER ); | ||
636 | return FAILURE; | ||
637 | } | ||
638 | |||
639 | if ( !( _session->_ext_header->_ext_type & RTP_EXT_TYPE_FRAMERATE ) ) { | ||
640 | t_perror ( RTP_ERROR_INVALID_EXTERNAL_HEADER ); | ||
641 | return FAILURE; | ||
642 | } | ||
643 | |||
644 | _session->_ext_header->_ext_type &= ~RTP_EXT_TYPE_FRAMERATE; /* Remove the flag */ | ||
645 | _session->_exthdr_framerate = -1; /* Remove identifier */ | ||
646 | _session->_ext_header->_ext_len --; | ||
647 | |||
648 | /* Check if extension is empty */ | ||
649 | if ( _session->_ext_header->_ext_type == 0 ){ | ||
650 | |||
651 | free ( _session->_ext_header->_hd_ext ); | ||
652 | free ( _session->_ext_header ); | ||
653 | |||
654 | _session->_ext_header = NULL; /* It's very important */ | ||
655 | _session->_extension = 0; | ||
656 | |||
657 | } else if ( !_session->_ext_header->_ext_len ) { | ||
658 | |||
659 | /* this will also be needed to change if there are more than 2 headers */ | ||
660 | _session->_ext_header->_hd_ext = realloc( _session->_ext_header->_hd_ext, sizeof( rtp_ext_header_t ) * _session->_ext_header->_ext_len ); | ||
661 | assert(_session->_ext_header->_hd_ext); | ||
662 | |||
663 | } | ||
664 | |||
665 | return SUCCESS; | ||
666 | } | ||
667 | |||
668 | uint32_t rtp_get_framerate_marking ( rtp_ext_header_t* _header ) | ||
669 | { | ||
670 | if ( _header->_ext_len == 1 ){ | ||
671 | return _header->_hd_ext[0]; | ||
672 | } else { | ||
673 | return _header->_hd_ext[1]; | ||
674 | } | ||
675 | } | ||
676 | |||
677 | int rtp_set_prefix ( rtp_session_t* _session, uint8_t* _prefix, uint16_t _prefix_length ) | ||
678 | { | ||
679 | if ( !_session ) | ||
680 | return FAILURE; | ||
681 | |||
682 | if ( _session->_prefix ) { | ||
683 | free ( _session->_prefix ); | ||
684 | } | ||
685 | |||
686 | _session->_prefix = calloc ( ( sizeof * _session->_prefix ), _prefix_length ); | ||
687 | assert(_session->_prefix); | ||
688 | |||
689 | t_memcpy ( _session->_prefix, _prefix, _prefix_length ); | ||
690 | _session->_prefix_length = _prefix_length; | ||
691 | |||
692 | return SUCCESS; | ||
693 | } | ||
diff --git a/toxrtp/toxrtp.h b/toxrtp/toxrtp.h deleted file mode 100644 index 0aa89993..00000000 --- a/toxrtp/toxrtp.h +++ /dev/null | |||
@@ -1,188 +0,0 @@ | |||
1 | /* rtp_impl.h | ||
2 | * | ||
3 | * Rtp implementation includes rtp_session_s struct which is a session identifier. | ||
4 | * It contains session information and it's a must for every session. | ||
5 | * It's best if you don't touch any variable directly but use callbacks to do so. !Red! | ||
6 | * | ||
7 | * | ||
8 | * Copyright (C) 2013 Tox project All Rights Reserved. | ||
9 | * | ||
10 | * This file is part of Tox. | ||
11 | * | ||
12 | * Tox is free software: you can redistribute it and/or modify | ||
13 | * it under the terms of the GNU General Public License as published by | ||
14 | * the Free Software Foundation, either version 3 of the License, or | ||
15 | * (at your option) any later version. | ||
16 | * | ||
17 | * Tox is distributed in the hope that it will be useful, | ||
18 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
19 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | ||
20 | * GNU General Public License for more details. | ||
21 | * | ||
22 | * You should have received a copy of the GNU General Public License | ||
23 | * along with Tox. If not, see <http://www.gnu.org/licenses/>. | ||
24 | * | ||
25 | */ | ||
26 | |||
27 | |||
28 | #ifndef _RTP__IMPL_H_ | ||
29 | #define _RTP__IMPL_H_ | ||
30 | |||
31 | #define RTP_VERSION 2 | ||
32 | #include <inttypes.h> | ||
33 | #include "tox.h" | ||
34 | #include <pthread.h> | ||
35 | /* Extension header flags */ | ||
36 | #define RTP_EXT_TYPE_RESOLUTION 0x01 | ||
37 | #define RTP_EXT_TYPE_FRAMERATE 0x02 | ||
38 | |||
39 | /* Some defines */ | ||
40 | |||
41 | #define RTP_PACKET 70 | ||
42 | |||
43 | /* Payload identifiers */ | ||
44 | |||
45 | /* Audio */ | ||
46 | #define _PAYLOAD_OPUS 96 | ||
47 | |||
48 | /* Video */ | ||
49 | #define _PAYLOAD_VP8 106 | ||
50 | |||
51 | /* End of Payload identifiers */ | ||
52 | |||
53 | /* End of defines */ | ||
54 | |||
55 | |||
56 | /* Our main session descriptor. | ||
57 | * It measures the session variables and controls | ||
58 | * the entire session. There are functions for manipulating | ||
59 | * the session so tend to use those instead of directly accessing | ||
60 | * session parameters. | ||
61 | */ | ||
62 | typedef struct rtp_session_s { | ||
63 | uint8_t _version; | ||
64 | uint8_t _padding; | ||
65 | uint8_t _extension; | ||
66 | uint8_t _cc; | ||
67 | uint8_t _marker; | ||
68 | uint8_t _payload_type; | ||
69 | uint16_t _sequence_number; /* Set when sending */ | ||
70 | uint16_t _last_sequence_number; /* Check when recving msg */ | ||
71 | uint32_t _initial_time; | ||
72 | uint32_t _time_elapsed; | ||
73 | uint32_t _current_timestamp; | ||
74 | uint32_t _ssrc; | ||
75 | uint32_t *_csrc; | ||
76 | |||
77 | |||
78 | /* If some additional data must be sent via message | ||
79 | * apply it here. Only by allocating this member you will be | ||
80 | * automatically placing it within a message. | ||
81 | */ | ||
82 | |||
83 | struct rtp_ext_header_s *_ext_header; | ||
84 | /* External header identifiers */ | ||
85 | int _exthdr_resolution; | ||
86 | int _exthdr_framerate; | ||
87 | |||
88 | int _max_users; /* -1 undefined */ | ||
89 | |||
90 | uint64_t _packets_sent; /* measure packets */ | ||
91 | uint64_t _packets_recv; | ||
92 | |||
93 | uint64_t _bytes_sent; | ||
94 | uint64_t _bytes_recv; | ||
95 | |||
96 | uint64_t _packet_loss; | ||
97 | |||
98 | const char *_last_error; | ||
99 | |||
100 | struct rtp_dest_list_s *_dest_list; | ||
101 | struct rtp_dest_list_s *_last_user; /* a tail for faster appending */ | ||
102 | |||
103 | struct rtp_msg_s *_oldest_msg; | ||
104 | struct rtp_msg_s *_last_msg; /* tail */ | ||
105 | |||
106 | uint16_t _prefix_length; | ||
107 | uint8_t *_prefix; | ||
108 | |||
109 | /* Specifies multiple session use. | ||
110 | * When using one session it uses default value ( -1 ) | ||
111 | * Otherwise it's set to 1 and rtp_register_msg () is required | ||
112 | */ | ||
113 | int _multi_session; | ||
114 | |||
115 | uint32_t _current_framerate; | ||
116 | |||
117 | pthread_mutex_t _mutex; | ||
118 | |||
119 | } rtp_session_t; | ||
120 | |||
121 | |||
122 | /* | ||
123 | * Now i don't believe we need to store this _from thing every time | ||
124 | * since we have csrc table but will leave it like this for a while | ||
125 | */ | ||
126 | |||
127 | |||
128 | void rtp_free_msg ( rtp_session_t *_session, struct rtp_msg_s *_msg ); | ||
129 | int rtp_release_session_recv ( rtp_session_t *_session ); | ||
130 | |||
131 | /* Functions handling receiving */ | ||
132 | struct rtp_msg_s *rtp_recv_msg ( rtp_session_t *_session ); | ||
133 | void rtp_store_msg ( rtp_session_t *_session, struct rtp_msg_s *_msg ); | ||
134 | |||
135 | /* | ||
136 | * rtp_msg_parse() stores headers separately from the payload data | ||
137 | * and so the _length variable is set accordingly | ||
138 | */ | ||
139 | struct rtp_msg_s *rtp_msg_parse ( rtp_session_t *_session, const uint8_t *_data, uint32_t _length ); | ||
140 | |||
141 | int rtp_check_late_message (rtp_session_t *_session, struct rtp_msg_s *_msg); | ||
142 | void rtp_register_msg ( rtp_session_t *_session, struct rtp_msg_s * ); | ||
143 | |||
144 | /* Functions handling sending */ | ||
145 | int rtp_send_msg ( rtp_session_t *_session, struct rtp_msg_s *_msg, void *_core_handler ); | ||
146 | |||
147 | /* | ||
148 | * rtp_msg_new() stores headers and payload data in one container ( _data ) | ||
149 | * and the _length is set accordingly. Returned message is used for sending only | ||
150 | * so there is not much use of the headers there | ||
151 | */ | ||
152 | struct rtp_msg_s *rtp_msg_new ( rtp_session_t *_session, const uint8_t *_data, uint32_t _length ); | ||
153 | |||
154 | |||
155 | /* Convenient functions for creating a header */ | ||
156 | struct rtp_header_s *rtp_build_header ( rtp_session_t *_session ); | ||
157 | |||
158 | /* Functions handling session control */ | ||
159 | |||
160 | /* Handling an rtp packet */ | ||
161 | /* int rtp_handlepacket(uint8_t * packet, uint32_t length, IP_Port source); */ | ||
162 | |||
163 | /* Session initiation and termination. | ||
164 | * Set _multi_session to -1 if not using multiple sessions | ||
165 | */ | ||
166 | rtp_session_t *rtp_init_session ( int _max_users, int _multi_session ); | ||
167 | int rtp_terminate_session ( rtp_session_t *_session ); | ||
168 | |||
169 | /* Adding receiver */ | ||
170 | int rtp_add_receiver ( rtp_session_t *_session, tox_IP_Port *_dest ); | ||
171 | |||
172 | /* Convenient functions for marking the resolution */ | ||
173 | int rtp_add_resolution_marking ( rtp_session_t *_session, uint16_t _width, uint16_t _height ); | ||
174 | int rtp_remove_resolution_marking ( rtp_session_t *_session ); | ||
175 | uint16_t rtp_get_resolution_marking_height ( struct rtp_ext_header_s *_header, uint32_t _position ); | ||
176 | uint16_t rtp_get_resolution_marking_width ( struct rtp_ext_header_s *_header, uint32_t _position ); | ||
177 | |||
178 | int rtp_add_framerate_marking ( rtp_session_t *_session, uint32_t _value ); | ||
179 | int rtp_remove_framerate_marking ( rtp_session_t *_session ); | ||
180 | uint32_t rtp_get_framerate_marking ( struct rtp_ext_header_s *_header ); | ||
181 | /* Convenient functions for marking the payload */ | ||
182 | void rtp_set_payload_type ( rtp_session_t *_session, uint8_t _payload_value ); | ||
183 | uint32_t rtp_get_payload_type ( rtp_session_t *_session ); | ||
184 | |||
185 | /* When using RTP in core be sure to set prefix when sending via rtp_send_msg */ | ||
186 | int rtp_set_prefix ( rtp_session_t *_session, uint8_t *_prefix, uint16_t _prefix_length ); | ||
187 | |||
188 | #endif /* _RTP__IMPL_H_ */ | ||
diff --git a/toxrtp/toxrtp_error.c b/toxrtp/toxrtp_error.c deleted file mode 100644 index 3a7ff9a5..00000000 --- a/toxrtp/toxrtp_error.c +++ /dev/null | |||
@@ -1,68 +0,0 @@ | |||
1 | |||
2 | #ifdef HAVE_CONFIG_H | ||
3 | #include "config.h" | ||
4 | #endif /* HAVE_CONFIG_H */ | ||
5 | |||
6 | #include "toxrtp_error.h" | ||
7 | #include "toxrtp_helper.h" | ||
8 | |||
9 | #include <stdio.h> | ||
10 | #include <stdarg.h> | ||
11 | #include <string.h> | ||
12 | #include <stdlib.h> | ||
13 | #include <assert.h> | ||
14 | |||
15 | typedef struct rtp_error_s { | ||
16 | char* _message; | ||
17 | int _id; | ||
18 | |||
19 | } rtp_error_t; | ||
20 | |||
21 | static rtp_error_t* _register = NULL; | ||
22 | static size_t _it = 0; | ||
23 | |||
24 | void t_rtperr_register ( int _id, const char* _info ) | ||
25 | { | ||
26 | size_t _info_size = strlen ( _info ); | ||
27 | |||
28 | if ( !_register ) { | ||
29 | _register = calloc ( sizeof ( rtp_error_t ), 1 ); | ||
30 | } else { | ||
31 | _register = realloc ( _register, sizeof ( rtp_error_t ) * ( _it + 1 ) ); | ||
32 | } | ||
33 | assert(_register); | ||
34 | |||
35 | |||
36 | rtp_error_t* _current = & _register[_it]; | ||
37 | |||
38 | _current->_id = _id; | ||
39 | _current->_message = calloc ( sizeof(char), _info_size ); | ||
40 | assert(_current->_message); | ||
41 | |||
42 | t_memcpy ( (uint8_t*)_current->_message, (const uint8_t*)_info, _info_size ); | ||
43 | _it ++; | ||
44 | } | ||
45 | |||
46 | const char* t_rtperr ( int _errno ) | ||
47 | { | ||
48 | if ( !_register ) | ||
49 | return "Unregistered"; | ||
50 | |||
51 | uint32_t _i; | ||
52 | |||
53 | for ( _i = _it; _i--; ) { | ||
54 | if ( _register[_i]._id == _errno ) { | ||
55 | return _register[_i]._message; | ||
56 | } | ||
57 | } | ||
58 | |||
59 | return "Invalid error id!"; | ||
60 | } | ||
61 | |||
62 | void t_rtperr_print ( const char* _val, ... ) | ||
63 | { | ||
64 | va_list _args; | ||
65 | va_start ( _args, _val ); | ||
66 | vfprintf ( stderr, _val, _args ); | ||
67 | va_end ( _args ); | ||
68 | } | ||
diff --git a/toxrtp/toxrtp_error.h b/toxrtp/toxrtp_error.h deleted file mode 100644 index 0e017246..00000000 --- a/toxrtp/toxrtp_error.h +++ /dev/null | |||
@@ -1,25 +0,0 @@ | |||
1 | #ifndef _RTP_ERROR_ | ||
2 | #define _RTP_ERROR_ | ||
3 | |||
4 | #define PRINT_FORMAT "Error %d: %s at %s:%d\n" | ||
5 | #define PRINT_ARGS( _errno ) _errno, t_rtperr(_errno), __FILE__, __LINE__ | ||
6 | |||
7 | |||
8 | const char* t_rtperr ( int _errno ); | ||
9 | void t_rtperr_register ( int _id, const char* _info ); | ||
10 | |||
11 | void t_invoke_error ( int _id ); | ||
12 | void t_rtperr_print ( const char* _val, ... ); | ||
13 | |||
14 | |||
15 | #ifdef _USE_ERRORS | ||
16 | #define t_perror( _errno ) t_rtperr_print ( PRINT_FORMAT, PRINT_ARGS ( _errno ) ) | ||
17 | #else | ||
18 | #define t_perror( _errno )do { } while(0) | ||
19 | #endif /* _USE_ERRORS */ | ||
20 | |||
21 | #ifdef _STDIO_H | ||
22 | #define t_errexit( _errno ) exit(-_errno) | ||
23 | #endif /* _STDIO_H */ | ||
24 | |||
25 | #endif /* _RTP_ERROR_ */ | ||
diff --git a/toxrtp/toxrtp_error_id.h b/toxrtp/toxrtp_error_id.h deleted file mode 100644 index 201aa936..00000000 --- a/toxrtp/toxrtp_error_id.h +++ /dev/null | |||
@@ -1,32 +0,0 @@ | |||
1 | #ifndef _RTP_ERROR_ID_ | ||
2 | #define _RTP_ERROR_ID_ | ||
3 | |||
4 | #include "toxrtp_error.h" | ||
5 | |||
6 | typedef enum error_s { | ||
7 | RTP_ERROR_PACKET_DROPED = 1, | ||
8 | RTP_ERROR_EMPTY_MESSAGE, | ||
9 | RTP_ERROR_STD_SEND_FAILURE, | ||
10 | RTP_ERROR_NO_EXTERNAL_HEADER, | ||
11 | RTP_ERROR_INVALID_EXTERNAL_HEADER, | ||
12 | RTP_ERROR_HEADER_PARSING, | ||
13 | RTP_ERROR_PAYLOAD_NULL, | ||
14 | RTP_ERROR_PAYLOAD_INVALID, | ||
15 | |||
16 | } error_t; | ||
17 | |||
18 | |||
19 | /* Only needed to be called once */ | ||
20 | #ifndef REGISTER_RTP_ERRORS | ||
21 | #define REGISTER_RTP_ERRORS \ | ||
22 | t_rtperr_register( RTP_ERROR_PACKET_DROPED, "Ivalid sequence number, packet is late" ); \ | ||
23 | t_rtperr_register( RTP_ERROR_EMPTY_MESSAGE, "Tried to send an empty message" ); \ | ||
24 | t_rtperr_register( RTP_ERROR_STD_SEND_FAILURE, "Failed call function: sendto" ); \ | ||
25 | t_rtperr_register( RTP_ERROR_NO_EXTERNAL_HEADER, "While parsing external header" ); \ | ||
26 | t_rtperr_register( RTP_ERROR_INVALID_EXTERNAL_HEADER, "While parsing external header" ); \ | ||
27 | t_rtperr_register( RTP_ERROR_HEADER_PARSING, "While parsing header" ); \ | ||
28 | t_rtperr_register( RTP_ERROR_PAYLOAD_NULL, "Payload is NULL" ); \ | ||
29 | t_rtperr_register( RTP_ERROR_PAYLOAD_INVALID, "Invalid payload size" ); | ||
30 | #endif /* REGISTER_RTP_ERRORS */ | ||
31 | |||
32 | #endif /* _RTP_ERROR_ID_ */ | ||
diff --git a/toxrtp/toxrtp_helper.c b/toxrtp/toxrtp_helper.c deleted file mode 100644 index 6f952359..00000000 --- a/toxrtp/toxrtp_helper.c +++ /dev/null | |||
@@ -1,208 +0,0 @@ | |||
1 | /* rtp_helper.c | ||
2 | * | ||
3 | * Has some standard functions. !Red! | ||
4 | * | ||
5 | * | ||
6 | * Copyright (C) 2013 Tox project All Rights Reserved. | ||
7 | * | ||
8 | * This file is part of Tox. | ||
9 | * | ||
10 | * Tox is free software: you can redistribute it and/or modify | ||
11 | * it under the terms of the GNU General Public License as published by | ||
12 | * the Free Software Foundation, either version 3 of the License, or | ||
13 | * (at your option) any later version. | ||
14 | * | ||
15 | * Tox is distributed in the hope that it will be useful, | ||
16 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
17 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | ||
18 | * GNU General Public License for more details. | ||
19 | * | ||
20 | * You should have received a copy of the GNU General Public License | ||
21 | * along with Tox. If not, see <http://www.gnu.org/licenses/>. | ||
22 | * | ||
23 | */ | ||
24 | |||
25 | |||
26 | |||
27 | #ifdef HAVE_CONFIG_H | ||
28 | #include "config.h" | ||
29 | #endif /* HAVE_CONFIG_H */ | ||
30 | |||
31 | #include "toxrtp_helper.h" | ||
32 | #include "../toxcore/network.h" | ||
33 | |||
34 | #include <assert.h> | ||
35 | |||
36 | #ifdef WIN | ||
37 | #include <windows.h> | ||
38 | #endif /* WIN */ | ||
39 | |||
40 | |||
41 | static int _seed = 0; /* Not initiated */ | ||
42 | |||
43 | int t_setipport ( const char *_ip, unsigned short _port, void *_dest ) | ||
44 | { | ||
45 | assert(_dest); | ||
46 | |||
47 | IP_Port *_dest_c = ( IP_Port * ) _dest; | ||
48 | ip_init(&_dest_c->ip, 0); | ||
49 | |||
50 | IP_Port _ipv6_garbage; | ||
51 | |||
52 | if ( !addr_resolve(_ip, &_dest_c->ip, &_ipv6_garbage.ip) ) | ||
53 | return FAILURE; | ||
54 | |||
55 | _dest_c->port = htons ( _port ); | ||
56 | |||
57 | return SUCCESS; | ||
58 | } | ||
59 | |||
60 | uint32_t t_random ( uint32_t _max ) | ||
61 | { | ||
62 | if ( !_seed ) { | ||
63 | srand ( t_time() ); | ||
64 | _seed++; | ||
65 | } | ||
66 | |||
67 | if ( _max <= 0 ) { | ||
68 | return ( unsigned ) rand(); | ||
69 | } else { | ||
70 | return ( unsigned ) rand() % _max; | ||
71 | } | ||
72 | } | ||
73 | |||
74 | void t_memcpy ( uint8_t *_dest, const uint8_t *_source, size_t _size ) | ||
75 | { | ||
76 | /* | ||
77 | * Using countdown to zero method | ||
78 | * It's faster than for(_it = 0; _it < _size; _it++); | ||
79 | */ | ||
80 | size_t _it = _size; | ||
81 | |||
82 | do { | ||
83 | _it--; | ||
84 | _dest[_it] = _source[_it]; | ||
85 | } while ( _it ); | ||
86 | |||
87 | } | ||
88 | |||
89 | uint8_t *t_memset ( uint8_t *_dest, uint8_t _valu, size_t _size ) | ||
90 | { | ||
91 | /* | ||
92 | * Again using countdown to zero method | ||
93 | */ | ||
94 | size_t _it = _size; | ||
95 | |||
96 | do { | ||
97 | _it--; | ||
98 | _dest[_it] = _valu; | ||
99 | } while ( _it ); | ||
100 | |||
101 | return _dest; | ||
102 | } | ||
103 | |||
104 | size_t t_memlen ( const uint8_t *_valu) | ||
105 | { | ||
106 | const uint8_t *_it; | ||
107 | size_t _retu = 0; | ||
108 | |||
109 | for ( _it = _valu; *_it; ++_it ) ++_retu; | ||
110 | |||
111 | return _retu; | ||
112 | } | ||
113 | |||
114 | uint8_t *t_strallcpy ( const uint8_t *_source ) /* string alloc and copy */ | ||
115 | { | ||
116 | assert(_source); | ||
117 | |||
118 | size_t _length = t_memlen(_source) + 1; /* make space for null character */ | ||
119 | |||
120 | uint8_t *_dest = calloc( sizeof ( uint8_t ), _length ); | ||
121 | assert(_dest); | ||
122 | |||
123 | t_memcpy(_dest, _source, _length); | ||
124 | |||
125 | return _dest; | ||
126 | } | ||
127 | |||
128 | size_t t_strfind ( const uint8_t *_str, const uint8_t *_substr ) | ||
129 | { | ||
130 | size_t _pos = 0; | ||
131 | size_t _it, _delit = 0; | ||
132 | |||
133 | for ( _it = 0; _str[_it] != '\0'; _it++ ) { | ||
134 | if ( _str[_it] == _substr[_delit] ) { | ||
135 | _pos = _it; | ||
136 | |||
137 | while ( _str[_it] == _substr[_delit] && _str[_it] != '\0' ) { | ||
138 | _it ++; | ||
139 | _delit++; | ||
140 | |||
141 | if ( _substr[_delit] == '\0' ) { | ||
142 | return _pos; | ||
143 | } | ||
144 | } | ||
145 | |||
146 | _delit = 0; | ||
147 | _pos = 0; | ||
148 | } | ||
149 | } | ||
150 | |||
151 | return _pos; | ||
152 | } | ||
153 | |||
154 | #ifdef WIN | ||
155 | #if defined(_MSC_VER) || defined(_MSC_EXTENSIONS) | ||
156 | #define DELTA_EPOCH_IN_MICROSECS 11644473600000000Ui64 | ||
157 | #else | ||
158 | #define DELTA_EPOCH_IN_MICROSECS 11644473600000000ULL | ||
159 | #endif | ||
160 | |||
161 | struct timezone { | ||
162 | int tz_minuteswest; /* minutes W of Greenwich */ | ||
163 | int tz_dsttime; /* type of dst correction */ | ||
164 | }; | ||
165 | |||
166 | int gettimeofday(struct timeval *tv, struct timezone *tz) | ||
167 | { | ||
168 | FILETIME ft; | ||
169 | unsigned __int64 tmpres = 0; | ||
170 | static int tzflag; | ||
171 | |||
172 | if (NULL != tv) { | ||
173 | GetSystemTimeAsFileTime(&ft); | ||
174 | |||
175 | tmpres |= ft.dwHighDateTime; | ||
176 | tmpres <<= 32; | ||
177 | tmpres |= ft.dwLowDateTime; | ||
178 | |||
179 | /*converting file time to unix epoch*/ | ||
180 | tmpres -= DELTA_EPOCH_IN_MICROSECS; | ||
181 | tmpres /= 10; /*convert into microseconds*/ | ||
182 | tv->tv_sec = (long)(tmpres / 1000000UL); | ||
183 | tv->tv_usec = (long)(tmpres % 1000000UL); | ||
184 | } | ||
185 | |||
186 | if (NULL != tz) { | ||
187 | if (!tzflag) { | ||
188 | _tzset(); | ||
189 | tzflag++; | ||
190 | } | ||
191 | |||
192 | tz->tz_minuteswest = _timezone / 60; | ||
193 | tz->tz_dsttime = _daylight; | ||
194 | } | ||
195 | |||
196 | return 0; | ||
197 | } | ||
198 | #endif /* WIN */ | ||
199 | |||
200 | |||
201 | uint64_t t_time() | ||
202 | { | ||
203 | struct timeval _tv; | ||
204 | gettimeofday(&_tv, NULL); | ||
205 | uint64_t _retu_usec = _tv.tv_sec % 1000000; /* get 6 digits an leave space for 3 more */ | ||
206 | _retu_usec = _retu_usec * 1000 + (_tv.tv_usec / 1000 ); | ||
207 | return _retu_usec; | ||
208 | } | ||
diff --git a/toxrtp/toxrtp_helper.h b/toxrtp/toxrtp_helper.h deleted file mode 100644 index c9bcfcca..00000000 --- a/toxrtp/toxrtp_helper.h +++ /dev/null | |||
@@ -1,77 +0,0 @@ | |||
1 | /* rtp_helper.h | ||
2 | * | ||
3 | * Has some standard functions. !Red! | ||
4 | * | ||
5 | * | ||
6 | * Copyright (C) 2013 Tox project All Rights Reserved. | ||
7 | * | ||
8 | * This file is part of Tox. | ||
9 | * | ||
10 | * Tox is free software: you can redistribute it and/or modify | ||
11 | * it under the terms of the GNU General Public License as published by | ||
12 | * the Free Software Foundation, either version 3 of the License, or | ||
13 | * (at your option) any later version. | ||
14 | * | ||
15 | * Tox is distributed in the hope that it will be useful, | ||
16 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
17 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | ||
18 | * GNU General Public License for more details. | ||
19 | * | ||
20 | * You should have received a copy of the GNU General Public License | ||
21 | * along with Tox. If not, see <http://www.gnu.org/licenses/>. | ||
22 | * | ||
23 | */ | ||
24 | |||
25 | #ifndef _RTP__HELPER_H_ | ||
26 | #define _RTP__HELPER_H_ | ||
27 | |||
28 | #include <time.h> | ||
29 | #include <inttypes.h> | ||
30 | |||
31 | /* Current time, unix format */ | ||
32 | /*#define _time ((uint32_t)time(NULL))*/ | ||
33 | |||
34 | #define SUCCESS 0 | ||
35 | #define FAILURE -1 | ||
36 | |||
37 | #define _USE_ERRORS | ||
38 | |||
39 | #define RUN_IN_THREAD(_func, _thread_id, _arg_ptr) \ | ||
40 | if ( pthread_create ( &_thread_id, NULL, _func, _arg_ptr ) ) { \ | ||
41 | pthread_detach ( _thread_id ); \ | ||
42 | } | ||
43 | |||
44 | /* Core adaptation helper */ | ||
45 | int t_setipport ( const char* _ip, unsigned short _port, void* _cont ); | ||
46 | uint32_t t_random ( uint32_t _max ); | ||
47 | |||
48 | /* It's a bit faster than the memcpy it self and more optimized for using | ||
49 | * a uint8_t since memcpy has optimizations when copying "words" i.e. long type. | ||
50 | * Otherwise it just copies char's while we need only uint8_t | ||
51 | */ | ||
52 | void t_memcpy ( uint8_t* _dest, const uint8_t* _source, size_t _size ); | ||
53 | |||
54 | |||
55 | /* This is our memset. It's also a bit faster than the memset for it | ||
56 | * does not cast _dest to char* and uses faster loop algorithm. | ||
57 | */ | ||
58 | uint8_t* t_memset ( uint8_t* _dest, uint8_t _valu, size_t _size ); | ||
59 | |||
60 | /* Get null terminated len */ | ||
61 | size_t t_memlen ( const uint8_t* _valu ); | ||
62 | |||
63 | /* finds location of substring */ | ||
64 | size_t t_strfind ( const uint8_t* _str, const uint8_t* _substr ); | ||
65 | |||
66 | /* string alloc and copy ( ! must be null terminated ) */ | ||
67 | uint8_t* t_strallcpy ( const uint8_t* _source ); | ||
68 | |||
69 | /* Get current time in milliseconds */ | ||
70 | uint64_t t_time(); | ||
71 | |||
72 | |||
73 | #endif /* _RTP__HELPER_H_ */ | ||
74 | |||
75 | |||
76 | |||
77 | |||
diff --git a/toxrtp/toxrtp_message.c b/toxrtp/toxrtp_message.c deleted file mode 100644 index e7f1f2c0..00000000 --- a/toxrtp/toxrtp_message.c +++ /dev/null | |||
@@ -1,351 +0,0 @@ | |||
1 | /* rtp_message.c | ||
2 | * | ||
3 | * Rtp Message handler. It handles message/header parsing. | ||
4 | * Refer to RTP: A Transport Protocol for Real-Time Applications ( RFC 3550 ) for more info. !Red! | ||
5 | * | ||
6 | * | ||
7 | * Copyright (C) 2013 Tox project All Rights Reserved. | ||
8 | * | ||
9 | * This file is part of Tox. | ||
10 | * | ||
11 | * Tox is free software: you can redistribute it and/or modify | ||
12 | * it under the terms of the GNU General Public License as published by | ||
13 | * the Free Software Foundation, either version 3 of the License, or | ||
14 | * (at your option) any later version. | ||
15 | * | ||
16 | * Tox is distributed in the hope that it will be useful, | ||
17 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
18 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | ||
19 | * GNU General Public License for more details. | ||
20 | * | ||
21 | * You should have received a copy of the GNU General Public License | ||
22 | * along with Tox. If not, see <http://www.gnu.org/licenses/>. | ||
23 | * | ||
24 | */ | ||
25 | |||
26 | #ifdef HAVE_CONFIG_H | ||
27 | #include "config.h" | ||
28 | #endif /* HAVE_CONFIG_H */ | ||
29 | |||
30 | #include "toxrtp_message.h" | ||
31 | #include "toxrtp.h" | ||
32 | #include <stdio.h> | ||
33 | |||
34 | #ifdef _USE_ERRORS | ||
35 | #include "toxrtp_error_id.h" | ||
36 | #endif /* _USE_ERRORS */ | ||
37 | |||
38 | #include <assert.h> | ||
39 | |||
40 | /* Some defines */ | ||
41 | |||
42 | /* End of defines */ | ||
43 | |||
44 | void rtp_header_print (const rtp_header_t* _header) | ||
45 | { | ||
46 | printf("Header: \n" | ||
47 | "Version: %d\n" | ||
48 | "Padding: %d\n" | ||
49 | "Ext: %d\n" | ||
50 | "CC: %d\n" | ||
51 | "marker: %d\n" | ||
52 | "payload typ:%d\n\n" | ||
53 | "sequ num: %d\n" | ||
54 | "Timestamp: %d\n" | ||
55 | "SSrc: %d\n" | ||
56 | "CSrc: %d\n" | ||
57 | "Lenght: %d\n" | ||
58 | ,rtp_header_get_flag_version(_header) | ||
59 | ,rtp_header_get_flag_padding(_header) | ||
60 | ,rtp_header_get_flag_extension(_header) | ||
61 | ,rtp_header_get_flag_CSRC_count(_header) | ||
62 | ,rtp_header_get_setting_marker(_header) | ||
63 | ,rtp_header_get_setting_payload_type(_header) | ||
64 | ,_header->_sequence_number | ||
65 | ,_header->_timestamp | ||
66 | ,_header->_ssrc | ||
67 | ,_header->_csrc[0] | ||
68 | ,_header->_length | ||
69 | ); | ||
70 | } | ||
71 | |||
72 | rtp_header_t* rtp_extract_header ( const uint8_t* _payload, size_t _bytes ) | ||
73 | { | ||
74 | if ( !_payload ) { | ||
75 | t_perror ( RTP_ERROR_PAYLOAD_NULL ); | ||
76 | return NULL; | ||
77 | } | ||
78 | const uint8_t* _it = _payload; | ||
79 | |||
80 | rtp_header_t* _retu = calloc(sizeof(rtp_header_t), 1); | ||
81 | assert(_retu); | ||
82 | |||
83 | _retu->_flags = *_it; ++_it; | ||
84 | |||
85 | /* This indicates if the first 2 bytes are valid. | ||
86 | * Now it my happen that this is out of order but | ||
87 | * it cuts down chances of parsing some invalid value | ||
88 | */ | ||
89 | if ( rtp_header_get_flag_version(_retu) != RTP_VERSION ){ | ||
90 | printf("Invalid version: %d\n", rtp_header_get_flag_version(_retu)); | ||
91 | //assert(rtp_header_get_flag_version(_retu) == RTP_VERSION); | ||
92 | /* Deallocate */ | ||
93 | //DEALLOCATOR(_retu); | ||
94 | //return NULL; | ||
95 | } | ||
96 | |||
97 | /* | ||
98 | * Added a check for the size of the header little sooner so | ||
99 | * I don't need to parse the other stuff if it's bad | ||
100 | */ | ||
101 | uint8_t cc = rtp_header_get_flag_CSRC_count ( _retu ); | ||
102 | uint32_t _lenght = _MIN_HEADER_LENGTH + ( cc * 4 ); | ||
103 | |||
104 | if ( _bytes < _lenght ) { | ||
105 | t_perror ( RTP_ERROR_PAYLOAD_INVALID ); | ||
106 | return NULL; | ||
107 | } | ||
108 | |||
109 | if ( cc > 0 ) { | ||
110 | _retu->_csrc = calloc ( sizeof ( uint32_t ), cc ); | ||
111 | assert(_retu->_csrc); | ||
112 | |||
113 | } else { /* But this should not happen ever */ | ||
114 | t_perror ( RTP_ERROR_HEADER_PARSING ); | ||
115 | return NULL; | ||
116 | } | ||
117 | |||
118 | |||
119 | _retu->_marker_payload_t = *_it; ++_it; | ||
120 | _retu->_length = _lenght; | ||
121 | _retu->_sequence_number = ( ( uint16_t ) * _it << 8 ) | * ( _it + 1 ); | ||
122 | |||
123 | _it += 2; | ||
124 | |||
125 | _retu->_timestamp = ( ( uint32_t ) * _it << 24 ) | | ||
126 | ( ( uint32_t ) * ( _it + 1 ) << 16 ) | | ||
127 | ( ( uint32_t ) * ( _it + 2 ) << 8 ) | | ||
128 | ( * ( _it + 3 ) ) ; | ||
129 | |||
130 | _it += 4; | ||
131 | |||
132 | _retu->_ssrc = ( ( uint32_t ) * _it << 24 ) | | ||
133 | ( ( uint32_t ) * ( _it + 1 ) << 16 ) | | ||
134 | ( ( uint32_t ) * ( _it + 2 ) << 8 ) | | ||
135 | ( ( uint32_t ) * ( _it + 3 ) ) ; | ||
136 | |||
137 | |||
138 | size_t x; | ||
139 | for ( x = 0; x < cc; x++ ) { | ||
140 | _it += 4; | ||
141 | _retu->_csrc[x] = ( ( uint32_t ) * _it << 24 ) | | ||
142 | ( ( uint32_t ) * ( _it + 1 ) << 16 ) | | ||
143 | ( ( uint32_t ) * ( _it + 2 ) << 8 ) | | ||
144 | ( ( uint32_t ) * ( _it + 3 ) ) ; | ||
145 | } | ||
146 | |||
147 | return _retu; | ||
148 | } | ||
149 | |||
150 | rtp_ext_header_t* rtp_extract_ext_header ( const uint8_t* _payload, size_t _bytes ) | ||
151 | { | ||
152 | if ( !_payload ) { | ||
153 | t_perror ( RTP_ERROR_PAYLOAD_NULL ); | ||
154 | return NULL; | ||
155 | } | ||
156 | |||
157 | |||
158 | |||
159 | const uint8_t* _it = _payload; | ||
160 | |||
161 | rtp_ext_header_t* _retu = calloc(sizeof(rtp_ext_header_t), 1); | ||
162 | assert(_retu); | ||
163 | |||
164 | uint16_t _ext_len = ( ( uint16_t ) * _it << 8 ) | * ( _it + 1 ); _it += 2; | ||
165 | |||
166 | if ( _bytes < ( _ext_len * sizeof(uint32_t) ) ) { | ||
167 | t_perror ( RTP_ERROR_PAYLOAD_INVALID ); | ||
168 | return NULL; | ||
169 | } | ||
170 | |||
171 | _retu->_ext_len = _ext_len; | ||
172 | _retu->_ext_type = ( ( uint16_t ) * _it << 8 ) | * ( _it + 1 ); _it -= 2; | ||
173 | |||
174 | _retu->_hd_ext = calloc(sizeof(uint32_t), _ext_len); | ||
175 | assert(_retu->_hd_ext); | ||
176 | |||
177 | uint32_t* _hd_ext = _retu->_hd_ext; | ||
178 | size_t i; | ||
179 | for ( i = 0; i < _ext_len; i++ ) { | ||
180 | _it += 4; | ||
181 | _hd_ext[i] = ( ( uint32_t ) * _it << 24 ) | | ||
182 | ( ( uint32_t ) * ( _it + 1 ) << 16 ) | | ||
183 | ( ( uint32_t ) * ( _it + 2 ) << 8 ) | | ||
184 | ( ( uint32_t ) * ( _it + 3 ) ) ; | ||
185 | } | ||
186 | |||
187 | return _retu; | ||
188 | } | ||
189 | |||
190 | uint8_t* rtp_add_header ( rtp_header_t* _header, uint8_t* _payload ) | ||
191 | { | ||
192 | uint8_t cc = rtp_header_get_flag_CSRC_count ( _header ); | ||
193 | |||
194 | uint8_t* _it = _payload; | ||
195 | |||
196 | *_it = _header->_flags; ++_it; | ||
197 | *_it = _header->_marker_payload_t; ++_it; | ||
198 | |||
199 | *_it = ( _header->_sequence_number >> 8 ); ++_it; | ||
200 | *_it = ( _header->_sequence_number ); ++_it; | ||
201 | |||
202 | uint32_t _timestamp = _header->_timestamp; | ||
203 | *_it = ( _timestamp >> 24 ); ++_it; | ||
204 | *_it = ( _timestamp >> 16 ); ++_it; | ||
205 | *_it = ( _timestamp >> 8 ); ++_it; | ||
206 | *_it = ( _timestamp ); ++_it; | ||
207 | |||
208 | uint32_t _ssrc = _header->_ssrc; | ||
209 | *_it = ( _ssrc >> 24 ); ++_it; | ||
210 | *_it = ( _ssrc >> 16 ); ++_it; | ||
211 | *_it = ( _ssrc >> 8 ); ++_it; | ||
212 | *_it = ( _ssrc ); | ||
213 | |||
214 | uint32_t *_csrc = _header->_csrc; | ||
215 | size_t x; | ||
216 | for ( x = 0; x < cc; x++ ) { | ||
217 | ++_it; | ||
218 | *_it = ( _csrc[x] >> 24 ); ++_it; | ||
219 | *_it = ( _csrc[x] >> 16 ); ++_it; | ||
220 | *_it = ( _csrc[x] >> 8 ); ++_it; | ||
221 | *_it = ( _csrc[x] ); | ||
222 | } | ||
223 | |||
224 | return _it; | ||
225 | } | ||
226 | |||
227 | uint8_t* rtp_add_extention_header ( rtp_ext_header_t* _header, uint8_t* _payload ) | ||
228 | { | ||
229 | uint8_t* _it = _payload; | ||
230 | |||
231 | *_it = ( _header->_ext_len >> 8 ); _it++; | ||
232 | *_it = ( _header->_ext_len ); _it++; | ||
233 | |||
234 | *_it = ( _header->_ext_type >> 8 ); ++_it; | ||
235 | *_it = ( _header->_ext_type ); | ||
236 | |||
237 | size_t x; | ||
238 | |||
239 | uint32_t* _hd_ext = _header->_hd_ext; | ||
240 | for ( x = 0; x < _header->_ext_len; x++ ) { | ||
241 | ++_it; | ||
242 | *_it = ( _hd_ext[x] >> 24 ); ++_it; | ||
243 | *_it = ( _hd_ext[x] >> 16 ); ++_it; | ||
244 | *_it = ( _hd_ext[x] >> 8 ); ++_it; | ||
245 | *_it = ( _hd_ext[x] ); | ||
246 | } | ||
247 | |||
248 | return _it; | ||
249 | } | ||
250 | |||
251 | size_t rtp_header_get_size ( const rtp_header_t* _header ) | ||
252 | { | ||
253 | return ( 8 + ( rtp_header_get_flag_CSRC_count ( _header ) * 4 ) ); | ||
254 | } | ||
255 | /* Setting flags */ | ||
256 | |||
257 | void rtp_header_add_flag_version ( rtp_header_t* _header, uint32_t value ) | ||
258 | { | ||
259 | ( _header->_flags ) &= 0x3F; | ||
260 | ( _header->_flags ) |= ( ( ( value ) << 6 ) & 0xC0 ); | ||
261 | } | ||
262 | |||
263 | void rtp_header_add_flag_padding ( rtp_header_t* _header, uint32_t value ) | ||
264 | { | ||
265 | if ( value > 0 ) { | ||
266 | value = 1; /* It can only be 1 */ | ||
267 | } | ||
268 | |||
269 | ( _header->_flags ) &= 0xDF; | ||
270 | ( _header->_flags ) |= ( ( ( value ) << 5 ) & 0x20 ); | ||
271 | } | ||
272 | |||
273 | void rtp_header_add_flag_extension ( rtp_header_t* _header, uint32_t value ) | ||
274 | { | ||
275 | if ( value > 0 ) { | ||
276 | value = 1; /* It can only be 1 */ | ||
277 | } | ||
278 | |||
279 | ( _header->_flags ) &= 0xEF; | ||
280 | ( _header->_flags ) |= ( ( ( value ) << 4 ) & 0x10 ); | ||
281 | } | ||
282 | |||
283 | void rtp_header_add_flag_CSRC_count ( rtp_header_t* _header, uint32_t value ) | ||
284 | { | ||
285 | ( _header->_flags ) &= 0xF0; | ||
286 | ( _header->_flags ) |= ( ( value ) & 0x0F ); | ||
287 | } | ||
288 | |||
289 | void rtp_header_add_setting_marker ( rtp_header_t* _header, uint32_t value ) | ||
290 | { | ||
291 | if ( value > 1 ) | ||
292 | value = 1; | ||
293 | |||
294 | ( _header->_marker_payload_t ) &= 0x7F; | ||
295 | ( _header->_marker_payload_t ) |= ( ( ( value ) << 7 ) /*& 0x80 */ ); | ||
296 | } | ||
297 | |||
298 | void rtp_header_add_setting_payload ( rtp_header_t* _header, uint32_t value ) | ||
299 | { | ||
300 | if ( value > 127 ) | ||
301 | value = 127; /* Well set to maximum */ | ||
302 | |||
303 | ( _header->_marker_payload_t ) &= 0x80; | ||
304 | ( _header->_marker_payload_t ) |= ( ( value ) /* & 0x7F */ ); | ||
305 | } | ||
306 | |||
307 | /* Getting values from flags */ | ||
308 | uint8_t rtp_header_get_flag_version ( const rtp_header_t* _header ) | ||
309 | { | ||
310 | return ( _header->_flags & 0xd0 ) >> 6; | ||
311 | } | ||
312 | |||
313 | uint8_t rtp_header_get_flag_padding ( const rtp_header_t* _header ) | ||
314 | { | ||
315 | return ( _header->_flags & 0x20 ) >> 5; | ||
316 | } | ||
317 | |||
318 | uint8_t rtp_header_get_flag_extension ( const rtp_header_t* _header ) | ||
319 | { | ||
320 | return ( _header->_flags & 0x10 ) >> 4; | ||
321 | } | ||
322 | |||
323 | uint8_t rtp_header_get_flag_CSRC_count ( const rtp_header_t* _header ) | ||
324 | { | ||
325 | return ( _header->_flags & 0x0f ); | ||
326 | } | ||
327 | uint8_t rtp_header_get_setting_marker ( const rtp_header_t* _header ) | ||
328 | { | ||
329 | return ( _header->_marker_payload_t ) >> 7; | ||
330 | } | ||
331 | uint8_t rtp_header_get_setting_payload_type ( const rtp_header_t* _header ) | ||
332 | { | ||
333 | /* | ||
334 | uint8_t _retu; | ||
335 | |||
336 | if ( _header->_marker_payload_t >> 7 == 1 ) { | ||
337 | _header->_marker_payload_t ^= 0x80; | ||
338 | _retu = _header->_marker_payload_t; | ||
339 | _header->_marker_payload_t ^= 0x80; | ||
340 | } else { | ||
341 | _retu = _header->_marker_payload_t; | ||
342 | } | ||
343 | */ | ||
344 | /* return to start value | ||
345 | return _retu; */ | ||
346 | return _header->_marker_payload_t & 0x7f; | ||
347 | } | ||
348 | |||
349 | /* */ | ||
350 | |||
351 | |||
diff --git a/toxrtp/toxrtp_message.h b/toxrtp/toxrtp_message.h deleted file mode 100644 index 8feea5d9..00000000 --- a/toxrtp/toxrtp_message.h +++ /dev/null | |||
@@ -1,111 +0,0 @@ | |||
1 | /* rtp_message.h | ||
2 | * | ||
3 | * Rtp Message handler. It handles message/header parsing. | ||
4 | * Refer to RTP: A Transport Protocol for Real-Time Applications ( RFC 3550 ) for more info. !Red! | ||
5 | * | ||
6 | * | ||
7 | * Copyright (C) 2013 Tox project All Rights Reserved. | ||
8 | * | ||
9 | * This file is part of Tox. | ||
10 | * | ||
11 | * Tox is free software: you can redistribute it and/or modify | ||
12 | * it under the terms of the GNU General Public License as published by | ||
13 | * the Free Software Foundation, either version 3 of the License, or | ||
14 | * (at your option) any later version. | ||
15 | * | ||
16 | * Tox is distributed in the hope that it will be useful, | ||
17 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
18 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | ||
19 | * GNU General Public License for more details. | ||
20 | * | ||
21 | * You should have received a copy of the GNU General Public License | ||
22 | * along with Tox. If not, see <http://www.gnu.org/licenses/>. | ||
23 | * | ||
24 | */ | ||
25 | |||
26 | #ifndef _RTP__MESSAGE_H_ | ||
27 | #define _RTP__MESSAGE_H_ | ||
28 | |||
29 | #include "../toxcore/network.h" | ||
30 | #include "toxrtp_helper.h" | ||
31 | #include "../toxcore/tox.h" | ||
32 | /* Defines */ | ||
33 | |||
34 | #define _MAX_SEQU_NUM 65535 | ||
35 | |||
36 | /* Minimum size */ | ||
37 | #define _MIN_HEADER_LENGTH 12 | ||
38 | #define _MIN_EXT_HEADER_LENGTH 4 | ||
39 | |||
40 | /* End of defines */ | ||
41 | |||
42 | |||
43 | typedef struct rtp_dest_list_s { | ||
44 | tox_IP_Port _dest; | ||
45 | struct rtp_dest_list_s* next; | ||
46 | |||
47 | } rtp_dest_list_t; | ||
48 | |||
49 | typedef struct rtp_header_s { | ||
50 | uint8_t _flags; /* Version(2),Padding(1), Ext(1), Cc(4) */ | ||
51 | uint8_t _marker_payload_t; /* Marker(1), PlayLoad Type(7) */ | ||
52 | uint16_t _sequence_number; /* Sequence Number */ | ||
53 | uint32_t _timestamp; /* Timestamp */ | ||
54 | uint32_t _ssrc; /* SSRC */ | ||
55 | uint32_t* _csrc; /* CSRC's table */ | ||
56 | |||
57 | uint32_t _length; /* A little something for allocation */ | ||
58 | |||
59 | } rtp_header_t; | ||
60 | |||
61 | typedef struct rtp_ext_header_s { | ||
62 | uint16_t _ext_type; /* Extension profile */ | ||
63 | uint16_t _ext_len; /* Number of extensions */ | ||
64 | uint32_t* _hd_ext; /* Extension's table */ | ||
65 | |||
66 | |||
67 | } rtp_ext_header_t; | ||
68 | |||
69 | typedef struct rtp_msg_s { | ||
70 | struct rtp_header_s* _header; | ||
71 | struct rtp_ext_header_s* _ext_header; | ||
72 | uint32_t _header_lenght; | ||
73 | |||
74 | uint8_t* _data; | ||
75 | uint32_t _length; | ||
76 | tox_IP_Port _from; | ||
77 | |||
78 | struct rtp_msg_s* _next; | ||
79 | } rtp_msg_t; | ||
80 | |||
81 | /* Extracts the header from the payload starting at _from */ | ||
82 | rtp_header_t* rtp_extract_header ( const uint8_t* _payload, size_t _bytes ); | ||
83 | rtp_ext_header_t* rtp_extract_ext_header ( const uint8_t* _payload, size_t _bytes ); | ||
84 | |||
85 | |||
86 | uint8_t* rtp_add_header ( rtp_header_t* _header, uint8_t* _payload ); | ||
87 | uint8_t* rtp_add_extention_header ( rtp_ext_header_t* _header, uint8_t* _payload ); | ||
88 | |||
89 | /* Gets the size of the header _header in bytes */ | ||
90 | size_t rtp_header_get_size ( const rtp_header_t* _header ); | ||
91 | |||
92 | void rtp_header_print (const rtp_header_t* _header); | ||
93 | |||
94 | /* Adding flags and settings */ | ||
95 | void rtp_header_add_flag_version ( rtp_header_t* _header, uint32_t value ); | ||
96 | void rtp_header_add_flag_padding ( rtp_header_t* _header, uint32_t value ); | ||
97 | void rtp_header_add_flag_extension ( rtp_header_t* _header, uint32_t value ); | ||
98 | void rtp_header_add_flag_CSRC_count ( rtp_header_t* _header, uint32_t value ); | ||
99 | void rtp_header_add_setting_marker ( rtp_header_t* _header, uint32_t value ); | ||
100 | void rtp_header_add_setting_payload ( rtp_header_t* _header, uint32_t value ); | ||
101 | |||
102 | |||
103 | /* Getting values from flags and settings */ | ||
104 | uint8_t rtp_header_get_flag_version ( const rtp_header_t* _header ); | ||
105 | uint8_t rtp_header_get_flag_padding ( const rtp_header_t* _header ); | ||
106 | uint8_t rtp_header_get_flag_extension ( const rtp_header_t* _header ); | ||
107 | uint8_t rtp_header_get_flag_CSRC_count ( const rtp_header_t* _header ); | ||
108 | uint8_t rtp_header_get_setting_marker ( const rtp_header_t* _header ); | ||
109 | uint8_t rtp_header_get_setting_payload_type ( const rtp_header_t* _header ); | ||
110 | |||
111 | #endif /* _RTP__MESSAGE_H_ */ | ||