static int http_make_request(struct http_request *r)
{
switch (r->type) {
case HTTP_TYPE_GET:
return http_get_request(r);
break;
default:
printc("unknown request type\n");
return -1;
}
return 0;
}
BOOL Cmeetphonemeet::ReloadMemberList()
{
if(!m_sConfUID.IsEmpty())
{
LinphoneCore *lc = theApp.GetCore();
CString restMethod;
restMethod.Format(_T("/mcuWeb/controller/getConferenceMember?confid=%s"), m_sConfUID);
Json::Value response;
if(http_get_request(restMethod, response))
{
m_hListMember.DeleteAllItems();
int real_index = 0;
for ( unsigned int index = 0; index < response.size(); ++index )
{
const char* strName = response[index]["name"].asCString();
const char *ip = response[index]["ip"].asCString();
const char *state = response[index]["state"].asCString();
int memberId = response[index]["id"].asInt();
bool muted = response[index]["ismute"].asBool();
if(state != NULL && strcasecmp("CONNECTED", state) == 0) {
state = _(state);
} else {
continue;
}
CString cStrName;
convert_utf8_to_unicode(strName, cStrName);
m_hListMember.InsertItem(index, _T(""));
m_hListMember.SetItemText(real_index, 1, cStrName);
m_hListMember.SetItemText(real_index, 2, CString(ip));
m_hListMember.SetItem(real_index, 3, LVIF_IMAGE, NULL, 0,LVIS_SELECTED, LVIS_SELECTED, NULL );
if(lc->is_admin)
{
int image_pos = muted ? 3 : 1;
m_hListMember.SetItem(real_index, 4, LVIF_IMAGE, NULL, image_pos,LVIS_SELECTED, LVIS_SELECTED, NULL );
m_hListMember.SetItem(real_index, 5, LVIF_IMAGE, NULL, 2,LVIS_SELECTED, LVIS_SELECTED, NULL );
}
MemberData *memberData = new MemberData;
memberData->memberId = memberId;
memberData->muted = muted;
m_hListMember.SetItemData(real_index, (DWORD_PTR)memberData);
real_index++;
}
}
}
return TRUE;
}
//
// The function to handle a client connection
//
void handle_connection(int fd)
{
http_req req;
FILE *rx, *tx;
exit_msg((fd < 0) || (fd > FD_SETSIZE), "bad fd");
// for streams with sockets, need one for read and one for write
rx = fdopen(fd, "r");
tx = fdopen(dup(fd), "w");
init_req(&req);
http_get_request(rx, &req);
http_process_request(&req);
http_response(tx, &req);
shutdown(fileno(rx), SHUT_RDWR);
fclose(rx);
fclose(tx);
free_req(&req);
return;
}
int token_verify(char* request_token,char* mac)
{
char buf[MAX_BUF];
char ip[16];
s_config *config;
config = config_get_config();
int res=resolve_host(config->auth_server,ip);
if(res<0){
debug(LOG_INFO,"Resolve auth server[%s] error.",config->auth_server);
return -1;
}
ip[15]=0;
char query[128]={0};
snprintf(query,sizeof(query),"?uid=%d&token=%s&mac=%s",config->uid,request_token,mac);
res = http_get_request(ip,config->auth_port,config->token_verify_path,query,VERSION,buf,MAX_BUF);
if(res<0){
debug(LOG_INFO,"verify token[%s]from auth server[%s] error.",request_token,config->auth_server);
return -1;
}
int i;
char* result=strstr(buf,"\r\n\r\n");
if(result==NULL)
{
debug(LOG_INFO,"verify token[%s] from auth server[%s] return null.",request_token,config->auth_server);
return;
}
result=result+4;
debug(LOG_DEBUG,"verify token[%s] result: %s",request_token,result);
if(strcmp(result,"1")==0)
{
return 1;
}
else{
return 0;
}
}
int main()
{
std::cout << std::endl;
int nb_test = 0;
// Get a HTTP Get with Boost.Asio to validate the HTTP GET http_get_request
auto validate = [&nb_test](hnc::http::get const & http_get_request)
{
try
{
std::vector<std::string> result = http_get_request.request();
--nb_test;
for (std::size_t i = 0; i < std::min(std::size_t(15), result.size()); ++i)
{
std::cout << result[i] << std::endl;
}
std::cout << "... (" << result.size() << " lines in total)" << std::endl;
}
catch (std::string const & e)
{
hnc::test::warning(false, "Can not connect: " + e + "\n");
--nb_test;
}
};
// HTML code to validate
std::string const xhtml_code =
"<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Strict//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd\">" "\n"
"" "\n"
"<html xmlns=\"http://www.w3.org/1999/xhtml\" xml:lang=\"fr\" lang=\"fr\">" "\n"
"" "\n"
"\t" "<head>" "\n"
"\t" "\t" "<title>Title</title>" "\n"
"\t" "\t" "<meta http-equiv=\"Content-Type\" content=\"text/html; charset=utf-8\" />" "\n" "\n"
"\t" "</head>" "\n"
"" "\n"
"<body>\n"
"</body>\n"
"" "\n"
"</html>\n";
// Tests
// Base
++nb_test;
{
hnc::url url("www.boost.org", "/", "http");
std::cout << hnc::terminal::info << url << hnc::terminal::reset << std::endl;
hnc::http::get http_get_request(url);
std::cout << http_get_request << std::endl;
validate(http_get_request);
}
std::cout << std::endl;
// Without path
++nb_test;
{
hnc::url url("www.boost.org", "", "http");
std::cout << hnc::terminal::info << url << hnc::terminal::reset << std::endl;
hnc::http::get http_get_request(url);
std::cout << http_get_request << std::endl;
validate(http_get_request);
}
std::cout << std::endl;
// With user agent
++nb_test;
{
hnc::url url("www.boost.org", "/", "http");
std::cout << hnc::terminal::info << url << hnc::terminal::reset << std::endl;
hnc::http::get http_get_request(url, "hnc_http_get_test_program");
std::cout << http_get_request << std::endl;
validate(http_get_request);
}
std::cout << std::endl;
// Wrong result (not HTTP/1.1 200 OK)
++nb_test;
{
hnc::url url("localhost", "/w3c-validator/check", "http");
std::cout << hnc::terminal::info << url << hnc::terminal::reset << std::endl;
hnc::http::get http_get_request(url);
std::cout << http_get_request << std::endl;
validate(http_get_request);
}
std::cout << std::endl;
// Resul ok with parameter
++nb_test;
{
hnc::url url("localhost", "/w3c-validator/check", "http");
std::cout << hnc::terminal::info << url << hnc::terminal::reset << std::endl;
hnc::http::get http_get_request(url, "fragment", xhtml_code);
std::cout << http_get_request << std::endl;
validate(http_get_request);
}
std::cout << std::endl;
// Resul ok with parameter and user agent
++nb_test;
{
hnc::url url("localhost", "/w3c-validator/check", "http");
std::cout << hnc::terminal::info << url << hnc::terminal::reset << std::endl;
hnc::http::get http_get_request(url, "fragment", xhtml_code, "hnc_http_get_test_program");
std::cout << http_get_request << std::endl;
validate(http_get_request);
}
std::cout << std::endl;
// Resul ok with parameters
++nb_test;
{
hnc::url url("localhost", "/w3c-validator/check", "http");
std::cout << hnc::terminal::info << url << hnc::terminal::reset << std::endl;
hnc::http::get http_get_request(url, "fragment", xhtml_code, "output", "soap12");
std::cout << http_get_request << std::endl;
validate(http_get_request);
}
std::cout << std::endl;
// Resul ok with parameters and user agent
++nb_test;
{
hnc::url url("localhost", "/w3c-validator/check", "http");
std::cout << hnc::terminal::info << url << hnc::terminal::reset << std::endl;
hnc::http::get http_get_request(url, "fragment", xhtml_code, "output", "soap12", "hnc_http_get_test_program");
std::cout << http_get_request << std::endl;
validate(http_get_request);
}
std::cout << std::endl;
// Resul ok with parameters and user agent
++nb_test;
{
hnc::url url("localhost", "/w3c-validator/check", "http");
std::cout << hnc::terminal::info << url << hnc::terminal::reset << std::endl;
hnc::http::get http_get_request(url, "fragment", xhtml_code, "output", "soap12", "verbose", 1, "hnc_http_get_test_program");
std::cout << http_get_request << std::endl;
validate(http_get_request);
}
std::cout << std::endl;
hnc::test::warning(nb_test == 0, "hnc::http::get: " + hnc::to_string(nb_test) + " test fail!\n");
return nb_test;
}
void natclient_connect_with_user(struct ice_trans_s* icetrans, const char *usr_id)
{
char linebuf[80];
unsigned media_cnt = 0;
unsigned comp0_port = 0;
char comp0_addr[80];
pj_bool_t done = PJ_FALSE;
reset_rem_info(icetrans);
comp0_addr[0] = '\0';
int af, cnt;
char foundation[32], transport[12], ipaddr[80], type[32];
pj_str_t tmpaddr;
int comp_id, prio, port;
pj_ice_sess_cand *cand;
pj_status_t status;
char full_url[1024];
char buff[5*1024];
strcpy(full_url, gUrl); // plus URL
sprintf(&full_url[strlen(full_url)], "/peer/getPeer/%s", usr_id); // plus API
PJ_LOG(4, ("[Debug] URL: %s \n", full_url));
http_get_request(full_url, &buff[0]);
char *value;
xmlNode *cur_node = NULL;
xmlNode *a_node = xml_get_node_by_name(buff, "registerPeer");
assert(a_node != NULL);
//printf("DEBUG %s, %d \n", __FILE__, __LINE__);
value = (char *)xml_xmlnode_get_content_by_name(a_node->children, "ufrag");
strcpy(icetrans->rem.ufrag, value);
free(value);
value = (char *)xml_xmlnode_get_content_by_name(a_node->children, "pwd");
strcpy(icetrans->rem.pwd, value);
free(value);
a_node = xml_get_node_by_name(buff, "candidateList");
//printf("DEBUG %s, %d \n", __FILE__, __LINE__);
for (cur_node = a_node->children; cur_node; cur_node = cur_node->next) {
// printf("[DEBUG] %s \n", cur_node->name);
if (cur_node->type == XML_ELEMENT_NODE)
{
if (strcmp(cur_node->name, "comp_1") == 0)
{
value = (char *)xml_xmlnode_get_content_by_name(cur_node, "ip");
strcpy(comp0_addr, value);
free(value);
value = (char *)xml_xmlnode_get_content_by_name(cur_node, "port");
comp0_port = atoi(value);
free(value);
}else
{
value = (char *)xml_xmlnode_get_content_by_name(cur_node, "foundation");
strcpy(foundation, value);
free(value);
value = (char *)xml_xmlnode_get_content_by_name(cur_node, "comp_id");
comp_id = atoi(value);
free(value);
value = (char *)xml_xmlnode_get_content_by_name(cur_node, "transport");
strcpy(transport, value);
free(value);
value = (char *)xml_xmlnode_get_content_by_name(cur_node, "prio");
prio = atoi(value);
free(value);
value = (char *)xml_xmlnode_get_content_by_name(cur_node, "ip");
strcpy(ipaddr, value);
//if (cur_node == a_node->children)
// strcpy(comp0_addr, value);
free(value);
value = (char *)xml_xmlnode_get_content_by_name(cur_node, "port");
port = atoi(value);
if (cur_node == a_node->children)
comp0_port = atoi(value);
free(value);
value = (char *)xml_xmlnode_get_content_by_name(cur_node, "type");
strcpy(type, value);
free(value);
PJ_LOG(4,(__FUNCTION__, "DEBUG %s %d %s %d %s %d typ %s",
foundation,
comp_id,
transport,
prio,
ipaddr,
port,
type));
cand = &icetrans->rem.cand[icetrans->rem.cand_cnt];
pj_bzero(cand, sizeof(*cand));
if (strcmp(type, "host")==0)
cand->type = PJ_ICE_CAND_TYPE_HOST;
else if (strcmp(type, "srflx")==0)
cand->type = PJ_ICE_CAND_TYPE_SRFLX;
else if (strcmp(type, "relay")==0)
cand->type = PJ_ICE_CAND_TYPE_RELAYED;
else {
PJ_LOG(1, (THIS_FILE, "Error: invalid candidate type '%s'",
type));
goto on_error;
}
cand->comp_id = (pj_uint8_t)comp_id;
pj_strdup2(icetrans->pool, &cand->foundation, foundation);
cand->prio = prio;
if (strchr(ipaddr, ':'))
af = pj_AF_INET6();
else
af = pj_AF_INET();
tmpaddr = pj_str(ipaddr);
pj_sockaddr_init(af, &cand->addr, NULL, 0);
status = pj_sockaddr_set_str_addr(af, &cand->addr, &tmpaddr);
if (status != PJ_SUCCESS) {
PJ_LOG(1,(THIS_FILE, "Error: invalid IP address '%s'",
ipaddr));
goto on_error;
}
pj_sockaddr_set_port(&cand->addr, (pj_uint16_t)port);
++icetrans->rem.cand_cnt;
if (cand->comp_id > icetrans->rem.comp_cnt)
icetrans->rem.comp_cnt = cand->comp_id;
}
}
}
if (icetrans->rem.cand_cnt==0 ||
icetrans->rem.ufrag[0]==0 ||
icetrans->rem.pwd[0]==0 ||
icetrans->rem.comp_cnt == 0)
{
PJ_LOG(1, (THIS_FILE, "Error: not enough info"));
goto on_error;
}
if (comp0_port==0 || comp0_addr[0]=='\0') {
PJ_LOG(1, (THIS_FILE, "Error: default address for component 0 not found"));
goto on_error;
} else {
int af;
pj_str_t tmp_addr;
pj_status_t status;
if (strchr(comp0_addr, ':'))
af = pj_AF_INET6();
else
af = pj_AF_INET();
pj_sockaddr_init(af, &icetrans->rem.def_addr[0], NULL, 0);
tmp_addr = pj_str(comp0_addr);
status = pj_sockaddr_set_str_addr(af, &icetrans->rem.def_addr[0],
&tmp_addr);
if (status != PJ_SUCCESS) {
PJ_LOG(1,(THIS_FILE, "Invalid IP address in c= line"));
goto on_error;
}
pj_sockaddr_set_port(&icetrans->rem.def_addr[0], (pj_uint16_t)comp0_port);
}
PJ_LOG(3, (THIS_FILE, "Done, %d remote candidate(s) added",
icetrans->rem.cand_cnt));
return;
on_error:
reset_rem_info(icetrans);
}
int main(void)
{
int socket_client;
int socket_serveur = creer_serveur(8080);
initialiser_signaux();
const char* message_bienvenue = "#############################################################\n# #\n# BONJOUR ! #\n# Bienvenue sur le serveur Wichita #\n# #\n# ------ #\n# #\n# Wichita tient son nom d'une langue amérindienne. #\n# Cette langue est en voie de disparition... #\n# ... comme beaucoup d'autres. #\n# #\n# Quoi qu'il en soit, amusez-vous bien avec Wichita ! :-) #\n# #\n#############################################################\n";
const char *bad_request = "HTTP/1.1 400 Bad Request\nConnection: close\nContent-Length: 17\n\n400 Bad Request\n";
const char *connected = "HTTP/1.1 200 OK\nConnection: open\nContent-Length: 80\n\n";
while(1)
{
socket_client = accept(socket_serveur, NULL ,NULL);
if (socket_client == -1)
{
perror("socket_client accept error");
continue;
}
if (fork() == 0)
{
char buffer[BUF_SIZE];
FILE * client_file = fdopen(socket_client, "w+");
if (fgets(buffer, BUF_SIZE, client_file) == NULL)
{
perror("fgets en-tete");
close(socket_client);
exit(EXIT_FAILURE);
}
printf(buffer);
if (http_get_request(buffer) != 0)
{
fprintf(client_file, "%s", bad_request);
fflush(client_file);
close(socket_client);
exit(EXIT_FAILURE);
}
else
{
fprintf(client_file, "%s", connected);
fflush(client_file);
}
skip_until(client_file, "\r\n");
fprintf(client_file, "%s", message_bienvenue);
fflush(client_file);
while(strcmp("FIN\n", buffer) != 0)
{
memset(buffer, '\0', strlen(buffer));
if (fgets(buffer, BUF_SIZE, client_file) != NULL)
{
// writes to the client
//fprintf(client_file, "<Wichita> %s", buffer);
// writes to the server
printf("%s", buffer);
}
}
close(socket_client);
break;
}
else
{
close(socket_client);
}
}
close(socket_serveur);
return EXIT_SUCCESS;
}
