void clean(){
int i;
int flag = FALSE;
lock_repo();
for (i=0; i<REPO_SIZE; ++i) {
if (SHM_SERVER_IDS_ADRESS[i] == MSG_RECEIVER) {
SHM_SERVER_IDS_ADRESS[i] = -1;
} else if (SHM_SERVER_IDS_ADRESS[i] != -1) {
flag = TRUE;
}
}
unlock_repo();
for(i=0; i<MAX_USERS_NUMBER; ++i) {
if (LOCAL_REPO[i].client_id != -1){
MSG_LOGIN user;
user.ipc_num = LOCAL_REPO[i].client_id;
strcpy(user.username, LOCAL_REPO[i].user_name);
unregister_user(user);
}
}
log_data("DEAD");
//we are last server so we clean whole repo
if(!flag){
log_data("CLEANING REPOSITORY");
clean_repo();
}
release_resources();
signal(SIGINT, SIG_DFL);
exit(EXIT_SUCCESS);
}
void kick_user(const char* username, int client_id){
MSG_LOGIN user;
user.type = LOGOUT;
user.ipc_num = client_id;
strcpy(user.username, username);
unregister_user(user);
remove_user_from_local_repo(client_id);
}
static void register_with_outbound(const char *transport, int use_transaction,const char* outbound ) {
belle_sip_request_t *req;
req=register_user(stack, prov, transport,use_transaction,"tester",outbound);
if (req) {
unregister_user(stack,prov,req,use_transaction);
belle_sip_object_unref(req);
}
}
static void test_register_authenticate(void) {
belle_sip_request_t *reg;
number_of_challenge=0;
authorized_request=NULL;
reg=register_user_at_domain(stack, prov, "udp",1,"bellesip",auth_domain,NULL);
if (authorized_request) {
unregister_user(stack,prov,authorized_request,1);
belle_sip_object_unref(authorized_request);
}
belle_sip_object_unref(reg);
}
static void test_register_client_authenticated(void) {
belle_sip_request_t *reg;
authorized_request=NULL;
/*we don't care to check sercer cert*/
belle_sip_tls_listening_point_set_verify_exceptions( (belle_sip_tls_listening_point_t*)belle_sip_provider_get_listening_point(prov,"tls")
,BELLE_SIP_TLS_LISTENING_POINT_BADCERT_ANY_REASON);
reg=register_user_at_domain(stack, prov, "tls",1,"tester",client_auth_domain,client_auth_outbound_proxy);
if (authorized_request) {
unregister_user(stack,prov,authorized_request,1);
belle_sip_object_unref(authorized_request);
}
if (reg) belle_sip_object_unref(reg);
}
void handle_logout(void* received, int msg_type){
MSG_LOGIN temp = *(MSG_LOGIN*)(received);
MSG_RESPONSE response;
response.type = RESPONSE;
switch (unregister_user(temp)) {
case SUCCESS:
remove_user_from_local_repo(temp.ipc_num);
response.response_type = LOGOUT_SUCCESS;
strcpy(response.content, "LOGOUT SUCCESS - 200");
msgsnd(temp.ipc_num, &response, _size(MSG_RESPONSE), 0);
break;
case FAIL:
response.response_type = LOGOUT_FAILED;
strcpy(response.content, "LOGOUT FAILED");
msgsnd(temp.ipc_num, &response, _size(MSG_RESPONSE), 0);
break;
}
}
static void reuse_nonce(void) {
belle_sip_request_t *register_request;
int initial_auth_context_count=belle_sip_list_size(prov->auth_contexts);
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)*/
CU_ASSERT_EQUAL(belle_sip_list_size(prov->auth_contexts), initial_auth_context_count+1);
/*this should reuse previous nonce*/
message_request=send_message(register_request, auth_domain);
CU_ASSERT_EQUAL(is_register_ok, 404);
h = BELLE_SIP_HEADER_AUTHORIZATION(belle_sip_message_get_header_by_type(
BELLE_SIP_MESSAGE(message_request), belle_sip_header_proxy_authorization_t
));
CU_ASSERT_PTR_NOT_NULL_FATAL(h);
CU_ASSERT_EQUAL(2, belle_sip_header_authorization_get_nonce_count(h));
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);
CU_ASSERT_EQUAL(is_register_ok, 407);
h = BELLE_SIP_HEADER_AUTHORIZATION(belle_sip_message_get_header_by_type(
BELLE_SIP_MESSAGE(message_request), belle_sip_header_proxy_authorization_t
));
CU_ASSERT_PTR_NULL_FATAL(h);
belle_sip_object_unref(message_request);
/*new nonce should be created here too*/
message_request=send_message(register_request, "wrongrealm");
CU_ASSERT_EQUAL(is_register_ok, 407);
h = BELLE_SIP_HEADER_AUTHORIZATION(belle_sip_message_get_header_by_type(
BELLE_SIP_MESSAGE(message_request), belle_sip_header_proxy_authorization_t
));
CU_ASSERT_PTR_NULL_FATAL(h);
belle_sip_object_unref(message_request);
/*first nonce created should be reused*/
message_request=send_message(register_request, auth_domain);
CU_ASSERT_EQUAL(is_register_ok, 404);
h = BELLE_SIP_HEADER_AUTHORIZATION(belle_sip_message_get_header_by_type(
BELLE_SIP_MESSAGE(message_request), belle_sip_header_proxy_authorization_t
));
CU_ASSERT_PTR_NOT_NULL_FATAL(h);
CU_ASSERT_EQUAL(3, belle_sip_header_authorization_get_nonce_count(h));
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);
}
}
