int main (int argc, char **argv) {
struct _u_response response;
int res;
struct _u_request req_list[6];
y_init_logs("auth_client", Y_LOG_MODE_CONSOLE, Y_LOG_LEVEL_DEBUG, NULL, "logs start");
ulfius_init_request(&req_list[0]);
req_list[0].http_verb = strdup("GET");
req_list[0].http_url = strdup(SERVER_URL);
ulfius_init_request(&req_list[1]);
req_list[1].http_verb = strdup("GET");
req_list[1].http_url = strdup(SERVER_URL);
req_list[1].auth_basic_user = strdup("test");
req_list[1].auth_basic_password = strdup("testpassword");
ulfius_init_request(&req_list[2]);
req_list[2].http_verb = strdup("GET");
req_list[2].http_url = strdup(SERVER_URL);
req_list[2].auth_basic_user = strdup("test");
req_list[2].auth_basic_password = strdup("wrongpassword");
ulfius_init_request(&req_list[3]);
req_list[3].http_verb = strdup("GET");
req_list[3].http_url = strdup(SERVER_URL "/404");
ulfius_init_request(&req_list[4]);
req_list[4].http_verb = strdup("GET");
req_list[4].http_url = strdup(SERVER_URL_DEFAULT);
req_list[4].auth_basic_user = strdup("test");
req_list[4].auth_basic_password = strdup("testpassword");
ulfius_init_request(&req_list[5]);
req_list[5].http_verb = strdup("GET");
req_list[5].http_url = strdup(SERVER_URL_DEFAULT);
req_list[5].auth_basic_user = strdup("test");
req_list[5].auth_basic_password = strdup("wrongpassword");
printf("Press <enter> to run auth tests no authentication\n");
getchar();
ulfius_init_response(&response);
res = ulfius_send_http_request(&req_list[0], &response);
if (res == U_OK) {
print_response(&response);
} else {
printf("Error in http request: %d\n", res);
}
ulfius_clean_response(&response);
printf("Press <enter> to run auth tests success authentication\n");
getchar();
ulfius_init_response(&response);
res = ulfius_send_http_request(&req_list[1], &response);
if (res == U_OK) {
print_response(&response);
} else {
printf("Error in http request: %d\n", res);
}
ulfius_clean_response(&response);
printf("Press <enter> to run auth tests error authentication\n");
getchar();
ulfius_init_response(&response);
res = ulfius_send_http_request(&req_list[2], &response);
if (res == U_OK) {
print_response(&response);
} else {
printf("Error in http request: %d\n", res);
}
ulfius_clean_response(&response);
printf("Press <enter> to run auth tests 404\n");
getchar();
ulfius_init_response(&response);
res = ulfius_send_http_request(&req_list[3], &response);
if (res == U_OK) {
print_response(&response);
} else {
printf("Error in http request: %d\n", res);
}
ulfius_clean_response(&response);
printf("Press <enter> to run default auth tests success authentication\n");
getchar();
ulfius_init_response(&response);
res = ulfius_send_http_request(&req_list[4], &response);
if (res == U_OK) {
print_response(&response);
} else {
printf("Error in http request: %d\n", res);
}
ulfius_clean_response(&response);
printf("Press <enter> to run default auth tests error authentication\n");
getchar();
ulfius_init_response(&response);
res = ulfius_send_http_request(&req_list[5], &response);
if (res == U_OK) {
print_response(&response);
} else {
printf("Error in http request: %d\n", res);
}
ulfius_clean_response(&response);
// Wait for the user to press <enter> on the console to quit the application
printf("Press <enter> to quit test\n");
getchar();
ulfius_clean_request(&req_list[0]);
ulfius_clean_request(&req_list[1]);
ulfius_clean_request(&req_list[2]);
ulfius_clean_request(&req_list[3]);
ulfius_clean_request(&req_list[4]);
ulfius_clean_request(&req_list[5]);
y_close_logs();
return 0;
}
/**
* create a new request based on the source elements
* returned value must be free'd
*/
struct _u_request * ulfius_duplicate_request(const struct _u_request * request) {
struct _u_request * new_request = NULL;
if (request != NULL) {
new_request = malloc(sizeof(struct _u_request));
if (new_request == NULL) {
y_log_message(Y_LOG_LEVEL_ERROR, "Ulfius - Error allocating memory for new_request");
return NULL;
}
if (ulfius_init_request(new_request) == U_OK) {
new_request->http_verb = nstrdup(request->http_verb);
new_request->http_url = nstrdup(request->http_url);
if (new_request->http_verb == NULL || new_request->http_url == NULL) {
y_log_message(Y_LOG_LEVEL_ERROR, "Ulfius - Error allocating memory for ulfius_duplicate_request");
ulfius_clean_request_full(new_request);
return NULL;
}
if (request->client_address != NULL) {
new_request->client_address = malloc(sizeof(struct sockaddr));
if (new_request->client_address == NULL) {
y_log_message(Y_LOG_LEVEL_ERROR, "Ulfius - Error allocating memory for new_request->client_address");
ulfius_clean_request_full(new_request);
return NULL;
}
memcpy(new_request->client_address, request->client_address, sizeof(struct sockaddr));
}
u_map_clean_full(new_request->map_url);
u_map_clean_full(new_request->map_header);
u_map_clean_full(new_request->map_cookie);
u_map_clean_full(new_request->map_post_body);
new_request->map_url = u_map_copy(request->map_url);
new_request->map_header = u_map_copy(request->map_header);
new_request->map_cookie = u_map_copy(request->map_cookie);
new_request->map_post_body = u_map_copy(request->map_post_body);
new_request->json_body = json_copy(request->json_body);
new_request->json_has_error = request->json_has_error;
if ((new_request->map_url == NULL && request->map_url != NULL) ||
(new_request->map_header == NULL && request->map_header != NULL) ||
(new_request->map_cookie == NULL && request->map_cookie != NULL) ||
(new_request->map_post_body == NULL && request->map_post_body != NULL) ||
(new_request->json_body == NULL && request->json_body != NULL)) {
ulfius_clean_request_full(new_request);
return NULL;
}
if (request->binary_body != NULL && request->binary_body_length > 0) {
new_request->binary_body = malloc(request->binary_body_length);
if (new_request->binary_body == NULL) {
y_log_message(Y_LOG_LEVEL_ERROR, "Ulfius - Error allocating memory for new_request->binary_body");
ulfius_clean_request_full(new_request);
return NULL;
}
memcpy(new_request->binary_body, request->binary_body, request->binary_body_length);
} else {
new_request->binary_body_length = 0;
new_request->binary_body = NULL;
}
new_request->binary_body_length = request->binary_body_length;
} else {
free(new_request);
new_request = NULL;
}
}
return new_request;
}
