belle_sip_register_tester.c 32.8 KB
Newer Older
Simon Morlat's avatar
Simon Morlat committed
1 2
/*
	belle-sip - SIP (RFC3261) library.
3
	Copyright (C) 2010  Belledonne Communications SARL
Simon Morlat's avatar
Simon Morlat committed
4

5 6 7 8
	This program is free software: you can redistribute it and/or modify
	it under the terms of the GNU General Public License as published by
	the Free Software Foundation, either version 2 of the License, or
	(at your option) any later version.
Simon Morlat's avatar
Simon Morlat committed
9

10 11 12 13
	This program is distributed in the hope that it will be useful,
	but WITHOUT ANY WARRANTY; without even the implied warranty of
	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
	GNU General Public License for more details.
Simon Morlat's avatar
Simon Morlat committed
14

15 16
	You should have received a copy of the GNU General Public License
	along with this program.  If not, see <http://www.gnu.org/licenses/>.
Simon Morlat's avatar
Simon Morlat committed
17 18 19
*/

#include "belle-sip/belle-sip.h"
20
#include "belle_sip_internal.h"
Ghislain MARY's avatar
Ghislain MARY committed
21
#include "belle_sip_tester.h"
22

Simon Morlat's avatar
Simon Morlat committed
23 24
#include "register_tester.h"

Ghislain MARY's avatar
Ghislain MARY committed
25

26
const char *test_domain="sip2.linphone.org";
27
const char *auth_domain="sip.linphone.org";
jehan's avatar
jehan committed
28
const char *client_auth_domain="client.example.org";
Simon Morlat's avatar
Simon Morlat committed
29
const char *client_auth_outbound_proxy="sips:sip2.linphone.org:5063";
30
const char *no_server_running_here="sip:test.linphone.org:3;transport=tcp";
31
const char *no_response_here="sip:78.220.48.77:3;transport=%s";
32
const char *test_domain_tls_to_tcp="sip:sip2.linphone.org:5060;transport=tls";
33 34
const char *test_http_proxy_addr="sip.linphone.org";
int test_http_proxy_port = 3128 ;
jehan's avatar
jehan committed
35

jehan's avatar
jehan committed
36
static int is_register_ok;
37
static int number_of_challenge;
38
static int using_transaction;
39 40
static int io_error_count=0;

jehan's avatar
jehan committed
41 42 43
belle_sip_stack_t * stack;
belle_sip_provider_t *prov;
static belle_sip_listener_t* l;
Ghislain MARY's avatar
Ghislain MARY committed
44 45 46 47
belle_sip_request_t* authorized_request;
belle_sip_listener_callbacks_t listener_callbacks;
belle_sip_listener_t *listener;

jehan's avatar
jehan committed
48

49
static void process_dialog_terminated(void *user_ctx, const belle_sip_dialog_terminated_event_t *event){
50 51
	BELLESIP_UNUSED(user_ctx);
	BELLESIP_UNUSED(event);
52 53
	belle_sip_message("process_dialog_terminated called");
}
Ghislain MARY's avatar
Ghislain MARY committed
54

55
static void process_io_error(void *user_ctx, const belle_sip_io_error_event_t *event){
56 57
	BELLESIP_UNUSED(user_ctx);
	BELLESIP_UNUSED(event);
58
	belle_sip_message("process_io_error, exiting main loop");
59
	belle_sip_main_loop_quit(belle_sip_stack_get_main_loop(stack));
60
	io_error_count++;
61
	/*BC_ASSERT(CU_FALSE);*/
62
}
Ghislain MARY's avatar
Ghislain MARY committed
63

64
static void process_request_event(void *user_ctx, const belle_sip_request_event_t *event){
65 66
	BELLESIP_UNUSED(user_ctx);
	BELLESIP_UNUSED(event);
67 68
	belle_sip_message("process_request_event");
}
Ghislain MARY's avatar
Ghislain MARY committed
69

70
static void process_response_event(void *user_ctx, const belle_sip_response_event_t *event){
71 72
	int status;
	belle_sip_request_t* request;
73
	BELLESIP_UNUSED(user_ctx);
74
	BC_ASSERT_PTR_NOT_NULL_FATAL(belle_sip_response_event_get_response(event));
75 76 77
	belle_sip_message("process_response_event [%i] [%s]"
					,status=belle_sip_response_get_status_code(belle_sip_response_event_get_response(event))
					,belle_sip_response_get_reason_phrase(belle_sip_response_event_get_response(event)));
78 79 80


	if (status==401){
81 82
		belle_sip_header_cseq_t* cseq;
		belle_sip_client_transaction_t *t;
83
		belle_sip_uri_t *dest;
84 85
		// BC_ASSERT_NOT_EQUAL_FATAL(number_of_challenge,2);
		BC_ASSERT_PTR_NOT_NULL_FATAL(belle_sip_response_event_get_client_transaction(event)); /*require transaction mode*/
86
		dest=belle_sip_client_transaction_get_route(belle_sip_response_event_get_client_transaction(event));
87
		request=belle_sip_transaction_get_request(BELLE_SIP_TRANSACTION(belle_sip_response_event_get_client_transaction(event)));
88
		cseq=(belle_sip_header_cseq_t*)belle_sip_message_get_header(BELLE_SIP_MESSAGE(request),BELLE_SIP_CSEQ);
89
		belle_sip_header_cseq_set_seq_number(cseq,belle_sip_header_cseq_get_seq_number(cseq)+1);
90 91
		belle_sip_message_remove_header(BELLE_SIP_MESSAGE(request),BELLE_SIP_AUTHORIZATION);
		belle_sip_message_remove_header(BELLE_SIP_MESSAGE(request),BELLE_SIP_PROXY_AUTHORIZATION);
92
		BC_ASSERT_TRUE_FATAL(belle_sip_provider_add_authorization(prov,request,belle_sip_response_event_get_response(event),NULL,NULL,auth_domain));
93

94
		t=belle_sip_provider_create_client_transaction(prov,request);
95
		belle_sip_client_transaction_send_request_to(t,dest);
96
		number_of_challenge++;
97
		authorized_request=request;
98
		belle_sip_object_ref(authorized_request);
99
	}  else {
100
		BC_ASSERT_EQUAL(status,200,int,"%d");
101 102 103 104
		is_register_ok=1;
		using_transaction=belle_sip_response_event_get_client_transaction(event)!=NULL;
		belle_sip_main_loop_quit(belle_sip_stack_get_main_loop(stack));
	}
105
}
Ghislain MARY's avatar
Ghislain MARY committed
106

107
static void process_timeout(void *user_ctx, const belle_sip_timeout_event_t *event){
108 109
	BELLESIP_UNUSED(user_ctx);
	BELLESIP_UNUSED(event);
110 111
	belle_sip_message("process_timeout");
}
Ghislain MARY's avatar
Ghislain MARY committed
112

113
static void process_transaction_terminated(void *user_ctx, const belle_sip_transaction_terminated_event_t *event){
114 115
	BELLESIP_UNUSED(user_ctx);
	BELLESIP_UNUSED(event);
116 117
	belle_sip_message("process_transaction_terminated");
}
Ghislain MARY's avatar
Ghislain MARY committed
118

Simon Morlat's avatar
Simon Morlat committed
119
const char* belle_sip_tester_client_cert = /*for URI:sip:tester@client.example.org*/
jehan's avatar
jehan committed
120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141
		"-----BEGIN CERTIFICATE-----\n"
		"MIIDYzCCAsygAwIBAgIBCDANBgkqhkiG9w0BAQUFADCBuzELMAkGA1UEBhMCRlIx\n"
		"EzARBgNVBAgMClNvbWUtU3RhdGUxETAPBgNVBAcMCEdyZW5vYmxlMSIwIAYDVQQK\n"
		"DBlCZWxsZWRvbm5lIENvbW11bmljYXRpb25zMQwwCgYDVQQLDANMQUIxFjAUBgNV\n"
		"BAMMDUplaGFuIE1vbm5pZXIxOjA4BgkqhkiG9w0BCQEWK2plaGFuLm1vbm5pZXJA\n"
		"YmVsbGVkb25uZS1jb21tdW5pY2F0aW9ucy5jb20wHhcNMTMxMDAzMTQ0MTEwWhcN\n"
		"MjMxMDAxMTQ0MTEwWjCBtTELMAkGA1UEBhMCRlIxDzANBgNVBAgMBkZyYW5jZTER\n"
		"MA8GA1UEBwwIR3Jlbm9ibGUxIjAgBgNVBAoMGUJlbGxlZG9ubmUgQ29tbXVuaWNh\n"
		"dGlvbnMxDDAKBgNVBAsMA0xBQjEUMBIGA1UEAwwLY2xpZW50IGNlcnQxOjA4Bgkq\n"
		"hkiG9w0BCQEWK2plaGFuLm1vbm5pZXJAYmVsbGVkb25uZS1jb21tdW5pY2F0aW9u\n"
		"cy5jb20wgZ8wDQYJKoZIhvcNAQEBBQADgY0AMIGJAoGBALZxC/qBi/zB/4lgI7V7\n"
		"I5TsmMmOp0+R/TCyVnYvKQuaJXh9i+CobVM7wj/pQg8RgsY1x+4mVwH1QbhOdIN0\n"
		"ExYHKgLTPlo9FaN6oHPOcHxU/wt552aZhCHC+ushwUUyjy8+T09UOP+xK9V7y5uD\n"
		"ZY+vIOvi6QNwc5cqyy8TREwNAgMBAAGjezB5MAkGA1UdEwQCMAAwLAYJYIZIAYb4\n"
		"QgENBB8WHU9wZW5TU0wgR2VuZXJhdGVkIENlcnRpZmljYXRlMB0GA1UdDgQWBBTL\n"
		"eWEg7jewRbQbKXSdBvsyygGIFzAfBgNVHSMEGDAWgBQGX13HFq9i+C1ucQOIoNYd\n"
		"KwR/ujANBgkqhkiG9w0BAQUFAAOBgQBTbEoi94pVfevbK22Oj8PJFsuy+el1pJG+\n"
		"h0XGM9SQGfbcS7PsV/MhFXtmpnmj3vQB3u5QtMGtWcLA2uxXi79i82gw+oEpBKHR\n"
		"sLqsNCzWNCL9n1pjpNSdqqBFGUdB9pSpnYalujAbuzkqq1ZLyzsElvK7pCaLQcSs\n"
		"oEncRDdPOA==\n"
		"-----END CERTIFICATE-----";

142 143 144
/* fingerprint of certificate generated using openssl x509 -fingerprint */
const char* belle_sip_tester_client_cert_fingerprint =
		"SHA-1 79:2F:9E:8B:28:CC:38:53:90:1D:71:DC:8F:70:66:75:E5:34:CE:C4";
jehan's avatar
jehan committed
145

Simon Morlat's avatar
Simon Morlat committed
146
const char* belle_sip_tester_private_key =
jehan's avatar
jehan committed
147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164
		"-----BEGIN ENCRYPTED PRIVATE KEY-----\n"
		"MIICxjBABgkqhkiG9w0BBQ0wMzAbBgkqhkiG9w0BBQwwDgQIbEHnQwhgRwoCAggA\n"
		"MBQGCCqGSIb3DQMHBAgmrtCEBCP9kASCAoCq9EKInROalaBSLWY44U4RVAC+CKdx\n"
		"Q8ooT7Bz/grgZuCiaGf0UKINJeV4LYHoP+AWjCH8EeebIA8dldNy5rGcBTt7sXd1\n"
		"QOGmnkBplXTW/NTsb9maYRK56kNJhLE4DR5X5keziV1Tdy2KBmTlpllsCXWsSOBq\n"
		"iI63PTaakIvZxA0TEmie5QQWpH777e/LmW3vVHdH8hhp2zeDDjfSW2E290+ce4Yj\n"
		"SDW9oFXvauzhzhSYRkUdfoJSbpu5MYwyzhjAXQpmBJDauu7+jAU/rQw6TLmYjDNZ\n"
		"3PYHzyD4N7tCG9u4mPBo33dhUirP+8E1BftHB+i/VIn6pI3ypMyiFZ1ZCHqi4vhW\n"
		"z7aChRrUY/8XWCpln3azcfj4SW+Mz62sAChY8rn+yyxFgIno8d9rrx67jyAnYJ6Q\n"
		"sfIMwKp3Sz5oI7IDk8If5SuBVkpqlRV+eZFT6zRRFk65beYpq70BN2mYaKzSV8A7\n"
		"rnciho/dfa9wvyWmkqXciBgWh18UTACOM9HPLmQef3FGaUDLiTAGS1osyypGUEPt\n"
		"Ox3u51qpYkibwyQZo1+ujQkh9PiKfevIAXmty0nTFWMEED15G2SJKjunw5N1rEAh\n"
		"M9jlYpLnATcfigPfGo19QrIPQ1c0LB4BqdwAWN3ZLe0QqYdgwzdcwIoLQRp9iDcw\n"
		"Omc31+38cTc2yGQ2Y2XHZkL8GY/rkqkbhVt9Rnh+VJxFeB6FlsL66EycApe07ngx\n"
		"QimGP57yp4aBzpJyW+6GPf8A/Ogsv3ay1QBLUiGEJtUglRHnl9F6nm5Nxm7wubVx\n"
		"WEuSefVM4xgB+mfQauAJu2N9yKhzXOytslZflpa06qJedlLYFk9njvcv\n"
		"-----END ENCRYPTED PRIVATE KEY-----\n";

Simon Morlat's avatar
Simon Morlat committed
165
const char* belle_sip_tester_private_key_passwd="secret";
jehan's avatar
jehan committed
166 167


168
static void process_auth_requested(void *user_ctx, belle_sip_auth_event_t *event){
169
	BELLESIP_UNUSED(user_ctx);
170
	if (belle_sip_auth_event_get_mode(event) == BELLE_SIP_AUTH_MODE_HTTP_DIGEST) {
171 172
		const char *username = belle_sip_auth_event_get_username(event);
		const char *realm = belle_sip_auth_event_get_realm(event);
jehan's avatar
jehan committed
173
		belle_sip_message("process_auth_requested requested for [%s@%s]"
174 175
				,username?username:""
				,realm?realm:"");
jehan's avatar
jehan committed
176 177
		belle_sip_auth_event_set_passwd(event,"secret");
	} else if (belle_sip_auth_event_get_mode(event) == BELLE_SIP_AUTH_MODE_TLS) {
178
		const char *distinguished_name = NULL;
Simon Morlat's avatar
Simon Morlat committed
179 180
		belle_sip_certificates_chain_t* cert = belle_sip_certificates_chain_parse(belle_sip_tester_client_cert,strlen(belle_sip_tester_client_cert),BELLE_SIP_CERTIFICATE_RAW_FORMAT_PEM);
		belle_sip_signing_key_t* key = belle_sip_signing_key_parse(belle_sip_tester_private_key,strlen(belle_sip_tester_private_key),belle_sip_tester_private_key_passwd);
jehan's avatar
jehan committed
181 182
		belle_sip_auth_event_set_client_certificates_chain(event,cert);
		belle_sip_auth_event_set_signing_key(event,key);
183 184
		distinguished_name = belle_sip_auth_event_get_distinguished_name(event);
		belle_sip_message("process_auth_requested requested for  DN[%s]",distinguished_name?distinguished_name:"");
jehan's avatar
jehan committed
185 186 187 188

	} else {
		belle_sip_error("Unexpected auth mode");
	}
189
}
190

191
int register_before_all(void) {
192
	belle_sip_listening_point_t *lp;
jehan's avatar
jehan committed
193
	stack=belle_sip_stack_new(NULL);
194
	lp=belle_sip_stack_create_listening_point(stack,"0.0.0.0",7060,"UDP");
195
	prov=belle_sip_stack_create_provider(stack,lp);
196

197 198
	lp=belle_sip_stack_create_listening_point(stack,"0.0.0.0",7060,"TCP");
	belle_sip_provider_add_listening_point(prov,lp);
199
	lp=belle_sip_stack_create_listening_point(stack,"0.0.0.0",7061,"TLS");
jehan's avatar
jehan committed
200
	if (lp) {
201
		belle_tls_crypto_config_t *crypto_config=belle_tls_crypto_config_new();
202
		/* since test.linphone.org does not have proper certificates, don't verify anything*/
203
		belle_tls_crypto_config_set_verify_exceptions(crypto_config, BELLE_TLS_VERIFY_ANY_REASON);
204
		if (belle_sip_tester_get_root_ca_path() != NULL) {
205
			belle_tls_crypto_config_set_root_ca(crypto_config,belle_sip_tester_get_root_ca_path());
206
		}
207
		belle_sip_tls_listening_point_set_crypto_config(BELLE_SIP_TLS_LISTENING_POINT(lp), crypto_config);
jehan's avatar
jehan committed
208
		belle_sip_provider_add_listening_point(prov,lp);
jehan's avatar
jehan committed
209
		belle_sip_object_unref(crypto_config);
jehan's avatar
jehan committed
210
	}
jehan's avatar
jehan committed
211

212 213 214 215 216 217 218 219 220
	listener_callbacks.process_dialog_terminated=process_dialog_terminated;
	listener_callbacks.process_io_error=process_io_error;
	listener_callbacks.process_request_event=process_request_event;
	listener_callbacks.process_response_event=process_response_event;
	listener_callbacks.process_timeout=process_timeout;
	listener_callbacks.process_transaction_terminated=process_transaction_terminated;
	listener_callbacks.process_auth_requested=process_auth_requested;
	listener_callbacks.listener_destroyed=NULL;
	listener=belle_sip_listener_create_from_callbacks(&listener_callbacks,NULL);
jehan's avatar
jehan committed
221 222
	return 0;
}
Ghislain MARY's avatar
Ghislain MARY committed
223

224
int register_after_all(void) {
225
	belle_sip_object_unref(prov);
jehan's avatar
jehan committed
226
	belle_sip_object_unref(stack);
227
	belle_sip_object_unref(listener);
jehan's avatar
jehan committed
228 229
	return 0;
}
jehan's avatar
jehan committed
230 231 232 233 234 235

void unregister_user(belle_sip_stack_t * stack
					,belle_sip_provider_t *prov
					,belle_sip_request_t* initial_request
					,int use_transaction) {
	belle_sip_request_t *req;
236 237 238
	belle_sip_header_cseq_t* cseq;
	belle_sip_header_expires_t* expires_header;
	int i;
jehan's avatar
jehan committed
239 240 241 242
	belle_sip_provider_add_sip_listener(prov,l);
	is_register_ok=0;
	using_transaction=0;
	req=(belle_sip_request_t*)belle_sip_object_clone((belle_sip_object_t*)initial_request);
243
	belle_sip_object_ref(req);
244
	cseq=(belle_sip_header_cseq_t*)belle_sip_message_get_header((belle_sip_message_t*)req,BELLE_SIP_CSEQ);
jehan's avatar
jehan committed
245
	belle_sip_header_cseq_set_seq_number(cseq,belle_sip_header_cseq_get_seq_number(cseq)+2); /*+2 if initial reg was challenged*/
246
	expires_header=(belle_sip_header_expires_t*)belle_sip_message_get_header(BELLE_SIP_MESSAGE(req),BELLE_SIP_EXPIRES);
jehan's avatar
jehan committed
247 248
	belle_sip_header_expires_set_expires(expires_header,0);
	if (use_transaction){
249
		belle_sip_client_transaction_t *t;
250
		belle_sip_provider_add_authorization(prov,req,NULL,NULL,NULL,NULL); /*just in case*/
251
		t=belle_sip_provider_create_client_transaction(prov,req);
jehan's avatar
jehan committed
252 253
		belle_sip_client_transaction_send_request(t);
	}else belle_sip_provider_send_request(prov,req);
254 255 256 257 258 259 260 261
	for(i=0;!is_register_ok && i<20 ;i++) {
		belle_sip_stack_sleep(stack,500);
		if (!use_transaction && !is_register_ok) {
			belle_sip_object_ref(req);
			belle_sip_provider_send_request(prov,req); /*manage retransmitions*/
		}
	}

262 263
	BC_ASSERT_EQUAL(is_register_ok,1,int,"%d");
	BC_ASSERT_EQUAL(using_transaction,use_transaction,int,"%d");
264
	belle_sip_object_unref(req);
jehan's avatar
jehan committed
265 266
	belle_sip_provider_remove_sip_listener(prov,l);
}
Ghislain MARY's avatar
Ghislain MARY committed
267

jehan's avatar
jehan committed
268
belle_sip_request_t* try_register_user_at_domain(belle_sip_stack_t * stack
269 270 271 272 273 274 275
	,belle_sip_provider_t *prov
	,const char *transport
	,int use_transaction
	,const char* username
	,const char* domain
	,const char* outbound_proxy
	,int success_expected) {
276
	belle_sip_request_t *req,*copy;
277 278
	char identity[256];
	char uri[256];
279
	int i;
Simon Morlat's avatar
Simon Morlat committed
280
	char *outbound=NULL;
281
	int do_manual_retransmissions = FALSE;
282

283
	number_of_challenge=0;
284
	if (transport)
285 286
		snprintf(uri,sizeof(uri),"sip:%s;transport=%s",domain,transport);
	else snprintf(uri,sizeof(uri),"sip:%s",domain);
jehan's avatar
jehan committed
287

Simon Morlat's avatar
Simon Morlat committed
288 289
	if (transport && strcasecmp("tls",transport)==0 && belle_sip_provider_get_listening_point(prov,"tls")==NULL){
		belle_sip_error("No TLS support, test skipped.");
jehan's avatar
jehan committed
290
		return NULL;
Simon Morlat's avatar
Simon Morlat committed
291
	}
292

Simon Morlat's avatar
Simon Morlat committed
293
	if (outbound_proxy){
jehan's avatar
jehan committed
294
		if (strstr(outbound_proxy,"sip:")==NULL && strstr(outbound_proxy,"sips:")==NULL){
Simon Morlat's avatar
Simon Morlat committed
295 296 297
			outbound=belle_sip_strdup_printf("sip:%s",outbound_proxy);
		}else outbound=belle_sip_strdup(outbound_proxy);
	}
Simon Morlat's avatar
Simon Morlat committed
298

299
	snprintf(identity,sizeof(identity),"Tester <sip:%s@%s>",username,domain);
Simon Morlat's avatar
Simon Morlat committed
300
	req=belle_sip_request_create(
301 302 303 304 305 306 307 308
						belle_sip_uri_parse(uri),
						"REGISTER",
						belle_sip_provider_create_call_id(prov),
						belle_sip_header_cseq_create(20,"REGISTER"),
						belle_sip_header_from_create2(identity,BELLE_SIP_RANDOM_TAG),
						belle_sip_header_to_create2(identity,NULL),
						belle_sip_header_via_new(),
						70);
309
	belle_sip_object_ref(req);
jehan's avatar
jehan committed
310
	is_register_ok=0;
311
	io_error_count=0;
312
	using_transaction=0;
jehan's avatar
jehan committed
313
	belle_sip_message_add_header(BELLE_SIP_MESSAGE(req),BELLE_SIP_HEADER(belle_sip_header_expires_create(600)));
314
	belle_sip_message_add_header(BELLE_SIP_MESSAGE(req),BELLE_SIP_HEADER(belle_sip_header_contact_new()));
315
	copy=(belle_sip_request_t*)belle_sip_object_ref(belle_sip_object_clone((belle_sip_object_t*)req));
jehan's avatar
jehan committed
316
	belle_sip_provider_add_sip_listener(prov,l=BELLE_SIP_LISTENER(listener));
317 318
	if (use_transaction){
		belle_sip_client_transaction_t *t=belle_sip_provider_create_client_transaction(prov,req);
Simon Morlat's avatar
Simon Morlat committed
319
		belle_sip_client_transaction_send_request_to(t,outbound?belle_sip_uri_parse(outbound):NULL);
320 321
	}else{
		belle_sip_provider_send_request(prov,req);
322
		do_manual_retransmissions = (transport == NULL) || (strcasecmp(transport,"udp") == 0);
323
	}
324 325
	for(i=0;!is_register_ok && i<20 && io_error_count==0;i++) {
		belle_sip_stack_sleep(stack,500);
326
		if (do_manual_retransmissions && !is_register_ok) {
327 328 329 330
			belle_sip_object_ref(req);
			belle_sip_provider_send_request(prov,req); /*manage retransmitions*/
		}
	}
331 332
	BC_ASSERT_EQUAL(is_register_ok,success_expected,int,"%d");
	if (success_expected) BC_ASSERT_EQUAL(using_transaction,use_transaction,int,"%d");
333

334
	belle_sip_object_unref(req);
jehan's avatar
jehan committed
335
	belle_sip_provider_remove_sip_listener(prov,l);
Simon Morlat's avatar
Simon Morlat committed
336
	if (outbound) belle_sip_free(outbound);
337
	return copy;
Simon Morlat's avatar
Simon Morlat committed
338
}
Ghislain MARY's avatar
Ghislain MARY committed
339

jehan's avatar
jehan committed
340 341 342 343 344
belle_sip_request_t* register_user_at_domain(belle_sip_stack_t * stack
					,belle_sip_provider_t *prov
					,const char *transport
					,int use_transaction
					,const char* username
345
					,const char* domain
Simon Morlat's avatar
Simon Morlat committed
346 347
					,const char* outbound) {
	return try_register_user_at_domain(stack,prov,transport,use_transaction,username,domain,outbound,1);
348

jehan's avatar
jehan committed
349
}
Ghislain MARY's avatar
Ghislain MARY committed
350

351 352 353 354
belle_sip_request_t* register_user(belle_sip_stack_t * stack
					,belle_sip_provider_t *prov
					,const char *transport
					,int use_transaction
355
					,const char* username
Simon Morlat's avatar
Simon Morlat committed
356 357
					,const char* outbound) {
	return register_user_at_domain(stack,prov,transport,use_transaction,username,test_domain,outbound);
358
}
359

Simon Morlat's avatar
Simon Morlat committed
360
static void register_with_outbound(const char *transport, int use_transaction,const char* outbound ) {
jehan's avatar
jehan committed
361
	belle_sip_request_t *req;
362

Simon Morlat's avatar
Simon Morlat committed
363
	req=register_user(stack, prov, transport,use_transaction,"tester",outbound);
364 365 366 367
	if (req) {
		unregister_user(stack,prov,req,use_transaction);
		belle_sip_object_unref(req);
	}
jehan's avatar
jehan committed
368
}
Ghislain MARY's avatar
Ghislain MARY committed
369

370
static void register_test(const char *transport, int use_transaction) {
Simon Morlat's avatar
Simon Morlat committed
371
	register_with_outbound(transport,use_transaction,NULL);
372
}
Ghislain MARY's avatar
Ghislain MARY committed
373

374 375
static void stateless_register_udp(void){
	register_test(NULL,0);
jehan's avatar
jehan committed
376
}
377

jehan's avatar
jehan committed
378 379 380 381
static void stateless_register_tls(void){
	register_test("tls",0);
}

382 383 384 385 386 387 388
static void stateless_register_tcp(void){
	register_test("tcp",0);
}

static void stateful_register_udp(void){
	register_test(NULL,1);
}
Ghislain MARY's avatar
Ghislain MARY committed
389

390
static void stateful_register_udp_with_keep_alive(void) {
jehan's avatar
jehan committed
391 392 393 394 395
	belle_sip_listening_point_set_keep_alive(belle_sip_provider_get_listening_point(prov,"udp"),200);
	register_test(NULL,1);
	belle_sip_main_loop_sleep(belle_sip_stack_get_main_loop(stack),500);
	belle_sip_listening_point_set_keep_alive(belle_sip_provider_get_listening_point(prov,"udp"),-1);
}
Ghislain MARY's avatar
Ghislain MARY committed
396

Simon Morlat's avatar
Simon Morlat committed
397 398
static void stateful_register_udp_with_outbound_proxy(void){
	register_with_outbound("udp",1,test_domain);
399 400
}

Simon Morlat's avatar
Simon Morlat committed
401
static void stateful_register_udp_delayed(void){
402
	belle_sip_stack_set_tx_delay(stack,3000);
Simon Morlat's avatar
Simon Morlat committed
403 404 405 406
	register_test(NULL,1);
	belle_sip_stack_set_tx_delay(stack,0);
}

407
static void stateful_register_udp_with_send_error(void){
408
	belle_sip_request_t *req;
409
	belle_sip_stack_set_send_error(stack,-1);
410
	req=try_register_user_at_domain(stack, prov, NULL,1,"tester",test_domain,NULL,0);
411
	belle_sip_stack_set_send_error(stack,0);
412
	if (req) belle_sip_object_unref(req);
413 414
}

415 416
static void stateful_register_tcp(void){
	register_test("tcp",1);
jehan's avatar
jehan committed
417
}
Simon Morlat's avatar
Simon Morlat committed
418

419 420 421
static void stateful_register_tls(void){
	register_test("tls",1);
}
jehan's avatar
jehan committed
422

423 424 425 426 427 428
static void stateful_register_tls_with_http_proxy(void) {
	belle_sip_tls_listening_point_t * lp = (belle_sip_tls_listening_point_t*)belle_sip_provider_get_listening_point(prov, "tls");
	if (!lp) {
		belle_sip_error("No TLS support, test skipped.");
		return;
	}
429
	belle_sip_provider_clean_channels(prov);
430 431
	belle_sip_stack_set_http_proxy_host(stack, test_http_proxy_addr);
	belle_sip_stack_set_http_proxy_port(stack, test_http_proxy_port);
432
	register_test("tls",1);
433 434
	belle_sip_stack_set_http_proxy_host(stack, NULL);
	belle_sip_stack_set_http_proxy_port(stack, 0);
435 436 437 438 439 440 441 442 443 444

}

static void stateful_register_tls_with_wrong_http_proxy(void){
	
	belle_sip_tls_listening_point_t * lp = (belle_sip_tls_listening_point_t*)belle_sip_provider_get_listening_point(prov, "tls");
	if (!lp) {
		belle_sip_error("No TLS support, test skipped.");
		return;
	}
445
	belle_sip_provider_clean_channels(prov);
446 447
	belle_sip_stack_set_http_proxy_host(stack, "mauvaisproxy.linphone.org");
	belle_sip_stack_set_http_proxy_port(stack, test_http_proxy_port);
448
	try_register_user_at_domain(stack,prov,"tls",1,"tester",test_domain,NULL,0);
449 450
	belle_sip_stack_set_http_proxy_host(stack, NULL);
	belle_sip_stack_set_http_proxy_port(stack, 0);
451 452 453 454
	
}


jehan's avatar
jehan committed
455
static void bad_req_process_io_error(void *user_ctx, const belle_sip_io_error_event_t *event){
456 457
	BELLESIP_UNUSED(user_ctx);
	BELLESIP_UNUSED(event);
jehan's avatar
jehan committed
458 459
	belle_sip_message("bad_req_process_io_error not implemented yet");
}
Ghislain MARY's avatar
Ghislain MARY committed
460

jehan's avatar
jehan committed
461
static void bad_req_process_response_event(void *user_ctx, const belle_sip_response_event_t *event){
462
	belle_sip_response_t *resp=belle_sip_response_event_get_response(event);
jehan's avatar
jehan committed
463 464 465 466 467 468
	int *bad_request_response_received=(int*)user_ctx;
	if (belle_sip_response_event_get_client_transaction(event) != NULL) {
		BC_ASSERT_TRUE(resp && belle_sip_response_get_status_code(resp)==400);
		*bad_request_response_received=1;
		belle_sip_main_loop_quit(belle_sip_stack_get_main_loop(stack));
	}
jehan's avatar
jehan committed
469 470
}

471
static void test_bad_request(void) {
jehan's avatar
jehan committed
472
	belle_sip_request_t *req;
473 474
	belle_sip_listener_t *bad_req_listener;
	belle_sip_client_transaction_t *t;
jehan's avatar
jehan committed
475 476 477 478
	belle_sip_header_address_t* route_address=belle_sip_header_address_create(NULL,belle_sip_uri_create(NULL,test_domain));
	belle_sip_header_route_t* route;
	belle_sip_header_to_t* to = belle_sip_header_to_create2("sip:toto@titi.com",NULL);
	belle_sip_listener_callbacks_t cbs;
479
	belle_sip_listening_point_t *lp=belle_sip_provider_get_listening_point(prov,"TCP");
480
	int bad_request_response_received=0;
jehan's avatar
jehan committed
481 482 483 484
	memset(&cbs,0,sizeof(cbs));

	cbs.process_io_error=bad_req_process_io_error;
	cbs.process_response_event=bad_req_process_response_event;
485

486
	bad_req_listener = belle_sip_listener_create_from_callbacks(&cbs,&bad_request_response_received);
jehan's avatar
jehan committed
487 488

	req=belle_sip_request_create(
489 490 491 492 493 494 495 496
						BELLE_SIP_URI(belle_sip_object_clone(BELLE_SIP_OBJECT(belle_sip_header_address_get_uri(route_address)))),
						"REGISTER",
						belle_sip_provider_create_call_id(prov),
						belle_sip_header_cseq_create(20,"REGISTER"),
						belle_sip_header_from_create2("sip:toto@titi.com",BELLE_SIP_RANDOM_TAG),
						to,
						belle_sip_header_via_new(),
						70);
jehan's avatar
jehan committed
497 498 499 500 501 502 503 504 505

	belle_sip_uri_set_transport_param(belle_sip_header_address_get_uri(route_address),"tcp");
	route = belle_sip_header_route_create(route_address);
	belle_sip_header_set_name(BELLE_SIP_HEADER(to),"BrokenHeader");

	belle_sip_message_add_header(BELLE_SIP_MESSAGE(req),BELLE_SIP_HEADER(belle_sip_header_expires_create(600)));
	belle_sip_message_add_header(BELLE_SIP_MESSAGE(req),BELLE_SIP_HEADER(route));
	belle_sip_message_add_header(BELLE_SIP_MESSAGE(req),BELLE_SIP_HEADER(belle_sip_header_contact_new()));
	belle_sip_provider_add_sip_listener(prov,bad_req_listener);
506
	t=belle_sip_provider_create_client_transaction(prov,req);
jehan's avatar
jehan committed
507
	belle_sip_client_transaction_send_request(t);
508
	belle_sip_stack_sleep(stack,3000);
509
	BC_ASSERT_TRUE(bad_request_response_received==1);
jehan's avatar
jehan committed
510
	belle_sip_provider_remove_sip_listener(prov,bad_req_listener);
511
	belle_sip_object_unref(bad_req_listener);
512

513
	belle_sip_listening_point_clean_channels(lp);
jehan's avatar
jehan committed
514
}
Simon Morlat's avatar
Simon Morlat committed
515

516
static void test_register_authenticate(void) {
517
	belle_sip_request_t *reg;
518
	number_of_challenge=0;
519
	authorized_request=NULL;
520
	reg=register_user_at_domain(stack, prov, "udp",1,"bellesip",auth_domain,NULL);
521 522 523 524 525
	if (authorized_request) {
		unregister_user(stack,prov,authorized_request,1);
		belle_sip_object_unref(authorized_request);
	}
	belle_sip_object_unref(reg);
526
}
jehan's avatar
jehan committed
527

528 529
static void test_register_channel_inactive(void){
	belle_sip_listening_point_t *lp=belle_sip_provider_get_listening_point(prov,"TCP");
530
	BC_ASSERT_PTR_NOT_NULL_FATAL(lp);
531 532
	belle_sip_stack_set_inactive_transport_timeout(stack,5);
	belle_sip_listening_point_clean_channels(lp);
533
	BC_ASSERT_EQUAL(belle_sip_listening_point_get_channel_count(lp),0,int,"%d");
534
	register_test("tcp",1);
535
	BC_ASSERT_EQUAL(belle_sip_listening_point_get_channel_count(lp),1,int,"%d");
536
	belle_sip_stack_sleep(stack,5000);
537
	BC_ASSERT_EQUAL(belle_sip_listening_point_get_channel_count(lp),0,int,"%d");
538 539
	belle_sip_stack_set_inactive_transport_timeout(stack,3600);
}
jehan's avatar
jehan committed
540

jehan's avatar
jehan committed
541 542 543 544 545


static void test_register_client_authenticated(void) {
	belle_sip_request_t *reg;
	authorized_request=NULL;
546

Simon Morlat's avatar
Simon Morlat committed
547
	reg=register_user_at_domain(stack, prov, "tls",1,"tester",client_auth_domain,client_auth_outbound_proxy);
jehan's avatar
jehan committed
548 549 550 551
	if (authorized_request) {
		unregister_user(stack,prov,authorized_request,1);
		belle_sip_object_unref(authorized_request);
	}
552
	if (reg) belle_sip_object_unref(reg);
jehan's avatar
jehan committed
553 554
}

555 556 557 558
static void test_connection_failure(void){
	belle_sip_request_t *req;
	io_error_count=0;
	req=try_register_user_at_domain(stack, prov, "TCP",1,"tester","sip.linphone.org",no_server_running_here,0);
559
	BC_ASSERT_TRUE(io_error_count>=1);
560 561 562
	if (req) belle_sip_object_unref(req);
}

563
static void test_connection_too_long(const char *transport){
564 565
	belle_sip_request_t *req;
	int orig=belle_sip_stack_get_transport_timeout(stack);
566
	char *no_response_here_with_transport = belle_sip_strdup_printf(no_response_here, transport);
567
	io_error_count=0;
568 569 570 571
	if (transport && strcasecmp("tls",transport)==0 && belle_sip_provider_get_listening_point(prov,"tls")==NULL){
		belle_sip_error("No TLS support, test skipped.");
		return;
	}
572
	belle_sip_stack_set_transport_timeout(stack,2000);
573
	req=try_register_user_at_domain(stack, prov, transport,1,"tester","sip.linphone.org",no_response_here_with_transport,0);
574
	BC_ASSERT_GREATER(io_error_count, 1, int, "%d");
575
	belle_sip_stack_set_transport_timeout(stack,orig);
576
	belle_sip_free(no_response_here_with_transport);
577 578 579
	if (req) belle_sip_object_unref(req);
}

580 581 582 583 584 585 586 587
static void test_connection_too_long_tcp(void){
	test_connection_too_long("tcp");
}

static void test_connection_too_long_tls(void){
	test_connection_too_long("tls");
}

588 589 590
static void test_tls_to_tcp(void){
	belle_sip_request_t *req;
	int orig=belle_sip_stack_get_transport_timeout(stack);
591
	io_error_count=0;
592 593 594
	belle_sip_stack_set_transport_timeout(stack,2000);
	req=try_register_user_at_domain(stack, prov, "TLS",1,"tester",test_domain,test_domain_tls_to_tcp,0);
	if (req){
595
		BC_ASSERT_TRUE(io_error_count>=1);
596 597 598 599
		belle_sip_object_unref(req);
	}
	belle_sip_stack_set_transport_timeout(stack,orig);
}
jehan's avatar
jehan committed
600

601
static void register_dns_srv_tcp(void){
602 603 604
	belle_sip_request_t *req;
	io_error_count=0;
	req=try_register_user_at_domain(stack, prov, "TCP",1,"tester",client_auth_domain,"sip:linphone.net;transport=tcp",1);
605
	BC_ASSERT_TRUE(io_error_count==0);
606 607 608
	if (req) belle_sip_object_unref(req);
}

609 610 611 612
static void register_dns_srv_tls(void){
	belle_sip_request_t *req;
	io_error_count=0;
	req=try_register_user_at_domain(stack, prov, "TLS",1,"tester",client_auth_domain,"sip:linphone.net;transport=tls",1);
613
	BC_ASSERT_EQUAL(io_error_count, 0, int, "%d");
614 615 616
	if (req) belle_sip_object_unref(req);
}

617 618 619 620 621 622 623 624
static void register_dns_srv_tls_with_http_proxy(void){
	belle_sip_request_t *req;
	belle_sip_tls_listening_point_t * lp = (belle_sip_tls_listening_point_t*)belle_sip_provider_get_listening_point(prov, "tls");
	if (!lp) {
		belle_sip_error("No TLS support, test skipped.");
		return;
	}
	io_error_count=0;
625
	belle_sip_provider_clean_channels(prov);
626 627
	belle_sip_stack_set_http_proxy_host(stack, test_http_proxy_addr);
	belle_sip_stack_set_http_proxy_port(stack, test_http_proxy_port);
628
	req=try_register_user_at_domain(stack, prov, "TLS",1,"tester",client_auth_domain,"sip:linphone.net;transport=tls",1);
629 630
	belle_sip_stack_set_http_proxy_host(stack, NULL);
	belle_sip_stack_set_http_proxy_port(stack, 0);
631 632 633 634
	BC_ASSERT_EQUAL(io_error_count, 0, int, "%d");
	if (req) belle_sip_object_unref(req);
}

635 636 637 638
static void register_dns_load_balancing(void) {
	belle_sip_request_t *req;
	io_error_count = 0;
	req = try_register_user_at_domain(stack, prov, "TCP", 1, "tester", client_auth_domain, "sip:belle-sip.net;transport=tcp", 1);
639
	BC_ASSERT_EQUAL(io_error_count, 0, int, "%d");
640 641 642
	if (req) belle_sip_object_unref(req);
}

643 644 645
static void process_message_response_event(void *user_ctx, const belle_sip_response_event_t *event){
	int status;
	BELLESIP_UNUSED(user_ctx);
646
	BC_ASSERT_PTR_NOT_NULL_FATAL(belle_sip_response_event_get_response(event));
647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690
	belle_sip_message("process_response_event [%i] [%s]"
					,status=belle_sip_response_get_status_code(belle_sip_response_event_get_response(event))
					,belle_sip_response_get_reason_phrase(belle_sip_response_event_get_response(event)));

	if (status >= 200){
		is_register_ok=status;
		belle_sip_main_loop_quit(belle_sip_stack_get_main_loop(stack));
	}
}
static belle_sip_request_t* send_message(belle_sip_request_t *initial_request, const char* realm){
	int i;
	int io_error_count=0;
	belle_sip_request_t *message_request=NULL;
	belle_sip_request_t *clone_request=NULL;
	// belle_sip_header_authorization_t * h=NULL;

	is_register_ok = 0;

	message_request=belle_sip_request_create(
								belle_sip_uri_parse("sip:sip.linphone.org;transport=tcp")
								,"MESSAGE"
								,belle_sip_provider_create_call_id(prov)
								,belle_sip_header_cseq_create(22,"MESSAGE")
								,belle_sip_message_get_header_by_type(BELLE_SIP_MESSAGE(initial_request), belle_sip_header_from_t)
								,belle_sip_header_to_parse("To: sip:marie@sip.linphone.org")
								,belle_sip_header_via_new()
								,70);
	belle_sip_message_add_header(BELLE_SIP_MESSAGE(message_request),BELLE_SIP_HEADER(belle_sip_header_expires_create(600)));
	belle_sip_message_add_header(BELLE_SIP_MESSAGE(message_request),BELLE_SIP_HEADER(belle_sip_header_contact_new()));
	belle_sip_provider_add_authorization(prov,message_request,NULL,NULL,NULL,realm);
	// h = belle_sip_message_get_header_by_type(BELLE_SIP_MESSAGE(message_request), belle_sip_header_authorization_t);
	/*if a matching authorization was found, use it as a proxy authorization*/
	// if (h != NULL){
	// 	belle_sip_header_set_name(BELLE_SIP_HEADER(h), BELLE_SIP_PROXY_AUTHORIZATION);
	// }
	clone_request = (belle_sip_request_t*)belle_sip_object_ref(belle_sip_object_clone((belle_sip_object_t*)message_request));
	belle_sip_client_transaction_send_request_to(belle_sip_provider_create_client_transaction(prov,message_request),NULL);
	for(i=0; i<2 && io_error_count==0 &&is_register_ok==0;i++)
		belle_sip_stack_sleep(stack,5000);

	return clone_request;
}
static void reuse_nonce(void) {
	belle_sip_request_t *register_request;
691
	int initial_auth_context_count=belle_sip_list_size(prov->auth_contexts);
692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709
	register_request=register_user_at_domain(stack, prov, "tcp",1,"marie","sip.linphone.org",NULL);
	if (register_request) {
		char * first_nonce_used;
		belle_sip_header_authorization_t * h = NULL;
		belle_sip_request_t *message_request;
		listener_callbacks.process_dialog_terminated=process_dialog_terminated;
		listener_callbacks.process_io_error=process_io_error;
		listener_callbacks.process_request_event=process_request_event;
		listener_callbacks.process_response_event=process_message_response_event;
		listener_callbacks.process_timeout=process_timeout;
		listener_callbacks.process_transaction_terminated=process_transaction_terminated;
		listener_callbacks.process_auth_requested=process_auth_requested;
		listener_callbacks.listener_destroyed=NULL;
		listener=belle_sip_listener_create_from_callbacks(&listener_callbacks,NULL);

		belle_sip_provider_add_sip_listener(prov,BELLE_SIP_LISTENER(listener));

		/*currently only one nonce should have been used (the one for the REGISTER)*/
710
		BC_ASSERT_EQUAL(belle_sip_list_size(prov->auth_contexts), initial_auth_context_count+1,int,"%d");
711 712 713

		/*this should reuse previous nonce*/
		message_request=send_message(register_request, auth_domain);
714
		BC_ASSERT_EQUAL(is_register_ok, 404,int,"%d");
715 716 717
		 h = BELLE_SIP_HEADER_AUTHORIZATION(belle_sip_message_get_header_by_type(
					BELLE_SIP_MESSAGE(message_request), belle_sip_header_proxy_authorization_t
				));
718 719
		BC_ASSERT_PTR_NOT_NULL_FATAL(h);
		BC_ASSERT_EQUAL(2, belle_sip_header_authorization_get_nonce_count(h),int,"%d");
720 721 722 723 724 725 726
		first_nonce_used = belle_sip_strdup(belle_sip_header_authorization_get_nonce(h));

		belle_sip_object_unref(message_request);


		/*new nonce should be created when not using outbound proxy realm*/
		message_request=send_message(register_request, NULL);
727
		BC_ASSERT_EQUAL(is_register_ok, 407,int,"%d");
728 729 730
		h = BELLE_SIP_HEADER_AUTHORIZATION(belle_sip_message_get_header_by_type(
				BELLE_SIP_MESSAGE(message_request), belle_sip_header_proxy_authorization_t
			));
731
		BC_ASSERT_PTR_NULL_FATAL(h);
732 733 734 735 736
		belle_sip_object_unref(message_request);


		/*new nonce should be created here too*/
		message_request=send_message(register_request, "wrongrealm");
737
		BC_ASSERT_EQUAL(is_register_ok, 407,int,"%d");
738 739 740
		h = BELLE_SIP_HEADER_AUTHORIZATION(belle_sip_message_get_header_by_type(
				BELLE_SIP_MESSAGE(message_request), belle_sip_header_proxy_authorization_t
			));
741
		BC_ASSERT_PTR_NULL_FATAL(h);
742 743 744 745 746
		belle_sip_object_unref(message_request);


		/*first nonce created should be reused*/
		message_request=send_message(register_request, auth_domain);
747
		BC_ASSERT_EQUAL(is_register_ok, 404,int,"%d");
748 749 750
		h = BELLE_SIP_HEADER_AUTHORIZATION(belle_sip_message_get_header_by_type(
				BELLE_SIP_MESSAGE(message_request), belle_sip_header_proxy_authorization_t
			));
751 752
		BC_ASSERT_PTR_NOT_NULL_FATAL(h);
		BC_ASSERT_EQUAL(3, belle_sip_header_authorization_get_nonce_count(h),int,"%d");
753 754 755 756 757 758 759 760 761
		belle_sip_object_unref(message_request);

		belle_sip_provider_remove_sip_listener(prov,BELLE_SIP_LISTENER(listener));
		unregister_user(stack,prov,register_request,1);
		belle_sip_object_unref(register_request);
		belle_sip_free(first_nonce_used);
	}
}

762

Ghislain MARY's avatar
Ghislain MARY committed
763 764 765 766 767 768 769 770
test_t register_tests[] = {
	{ "Stateful UDP", stateful_register_udp },
	{ "Stateful UDP with keep-alive", stateful_register_udp_with_keep_alive },
	{ "Stateful UDP with network delay", stateful_register_udp_delayed },
	{ "Stateful UDP with send error", stateful_register_udp_with_send_error },
	{ "Stateful UDP with outbound proxy", stateful_register_udp_with_outbound_proxy },
	{ "Stateful TCP", stateful_register_tcp },
	{ "Stateful TLS", stateful_register_tls },
771
	{ "Stateful TLS with http proxy", stateful_register_tls_with_http_proxy },
jehan's avatar
jehan committed
772
	{ "Stateful TLS with wrong http proxy", stateful_register_tls_with_wrong_http_proxy },
Ghislain MARY's avatar
Ghislain MARY committed
773 774 775 776
	{ "Stateless UDP", stateless_register_udp },
	{ "Stateless TCP", stateless_register_tcp },
	{ "Stateless TLS", stateless_register_tls },
	{ "Bad TCP request", test_bad_request },
777
	{ "Authenticate", test_register_authenticate },
jehan's avatar
jehan committed
778
	{ "TLS client cert authentication", test_register_client_authenticated },
779 780
	{ "Channel inactive", test_register_channel_inactive },
	{ "TCP connection failure", test_connection_failure },
781 782
	{ "TCP connection too long", test_connection_too_long_tcp },
	{ "TLS connection too long", test_connection_too_long_tls },
783
	{ "TLS connection to TCP server", test_tls_to_tcp },
784
	{ "Register with DNS SRV failover TCP", register_dns_srv_tcp },
785
	{ "Register with DNS SRV failover TLS", register_dns_srv_tls },
786
	{ "Register with DNS SRV failover TLS with http proxy", register_dns_srv_tls_with_http_proxy },
787 788
	{ "Register with DNS load-balancing", register_dns_load_balancing },
	{ "Nonce reutilization", reuse_nonce }
Ghislain MARY's avatar
Ghislain MARY committed
789 790
};

Simon Morlat's avatar
Simon Morlat committed
791 792
test_suite_t register_test_suite = {"REGISTER", register_before_all, register_after_all, NULL,
									NULL, sizeof(register_tests) / sizeof(register_tests[0]),
793
									register_tests};