/* int ZHTClient::str2Sock(string str) { //give socket and update the vector of network entity int sock = 0; int index = -1; struct HostEntity dest = this->str2Host(str, index); cout<<"str2Sock: dest.sock = "<<dest.sock<<endl; if (dest.sock < 0) { sock = makeClientSocket(dest.host.c_str(), dest.port, 1); reuseSock(sock); dest.sock = sock; this->memberList.erase(this->memberList.begin() + index); this->memberList.insert(this->memberList.begin() + index, dest); } cout<<"str2Sock: after update: sock = "<<this->str2Host(str).sock<<endl; return dest.sock; } */ int ZHTClient::str2Sock(string str) { //give socket and update the vector of network entity int sock = 0; int index = -1; struct HostEntity dest = this->str2Host(str, index); if (TCP == true) { // int sock = 0; // int index = -1; // struct HostEntity dest = this->str2Host(str, index); // cout<<"str2Sock: dest.sock = "<<dest.sock<<endl; if (dest.sock < 0) { sock = makeClientSocket(dest.host.c_str(), dest.port, TCP); reuseSock(sock); dest.sock = sock; this->memberList.erase(this->memberList.begin() + index); this->memberList.insert(this->memberList.begin() + index, dest); } // cout<<"str2Sock: after update: sock = "<<this->str2Host(str).sock<<endl; return dest.sock; } else { //UDP if (UDP_SOCKET < 0) { UDP_SOCKET = makeClientSocket(dest.host.c_str(), dest.port, TCP); } return UDP_SOCKET; } }
int ZHTClient::removeMeta(string path) { Package package; package.set_operation(2); // 3 for insert, 1 for look up, 2 for remove package.set_replicano(3); //5: original, 3 not original package.set_virtualpath(path); string str = package.SerializeAsString(); int sock = this->str2SockLRU(str, TCP); reuseSock(sock); // cout<<"sock = "<<sock<<endl; struct HostEntity dest = this->str2Host(str); sockaddr_in recvAddr; int sentSize = generalSendTo(dest.host.data() ,dest.port, sock, str.c_str(), TCP); // cout<<"remove sentSize "<< sentSize <<endl; int32_t* ret_buf = (int32_t*) malloc(sizeof(int32_t)); // generalReveiveTCP(sock, (void*) ret_buf, sizeof(int32_t), 0); generalReceive(sock, (void*)ret_buf, sizeof(int32_t),recvAddr,0, TCP); // generalSendTCP(sock, str.c_str()); // int32_t* ret = (int32_t*) malloc(sizeof(int32_t)); // generalReveiveTCP(sock, (void*) ret, sizeof(int32_t), 0); int ret_1 = *(int32_t*) ret_buf; // cout<<"remove got: "<< ret_1 <<endl; // cout <<"Returned status: "<< *(int32_t*) ret<<endl; // d3_closeConnection(sock); free(ret_buf); return ret_1; }
int ZHTClient::remove(string str) { Package package; package.ParseFromString(str); char *c_str; int size = str.length(); c_str = (char*) malloc((size + 5 + 1) * sizeof(char)); if (c_str == NULL) { cout << "ZHTClient::svrtosvr: " << strerror(errno) << endl; exit(1); } int len = copystring(c_str, str); if (package.virtualpath().empty()) //empty key not allowed. return -1; /*if (package.realfullpath().empty()) //coup, to fix ridiculous bug of protobuf! package.set_realfullpath(" ");*/ package.set_operation(2); //1 for look up, 2 for remove, 3 for insert package.set_replicano(3); //5: original, 3 not original str = package.SerializeAsString(); int sock = this->str2SockLRU(str, TCP); reuseSock(sock); // cout<<"sock = "<<sock<<endl; struct HostEntity dest = this->str2Host(str); sockaddr_in recvAddr; //pthread_mutex_lock(&msg_lock); int sentSize = generalSendTo(dest.host.data(), dest.port, sock, c_str, len, TCP); //pthread_mutex_unlock(&msg_lock); //int sentSize = generalSendTo(dest.host.data(), dest.port, sock, str.c_str(), str.size(), TCP); // cout<<"remove sentSize "<< sentSize <<endl; int32_t* ret_buf = (int32_t*) malloc(sizeof(int32_t)); // generalReveiveTCP(sock, (void*) ret_buf, sizeof(int32_t), 0); //pthread_mutex_lock(&msg_lock); generalReceive(sock, (void*) ret_buf, sizeof(int32_t), recvAddr, 0, TCP); //pthread_mutex_unlock(&msg_lock); // generalSendTCP(sock, str.c_str()); // int32_t* ret = (int32_t*) malloc(sizeof(int32_t)); // generalReveiveTCP(sock, (void*) ret, sizeof(int32_t), 0); int ret_1 = *(int32_t*) ret_buf; // cout<<"remove got: "<< ret_1 <<endl; //cout <<"Returned status: "<< *(int32_t*) ret<<endl; // d3_closeConnection(sock); free(ret_buf); return ret_1; }
// general server to server send (for load information and task stealing) int32_t ZHTClient::svrtosvr(string str, int size, int index) { Package package; package.ParseFromString(str); if (package.virtualpath().empty()) //empty key not allowed. { return -1; } str = package.SerializeAsString(); char *c_str; c_str = (char*) malloc((size + 5 + 1) * sizeof(char)); if (c_str == NULL) { cout << "ZHTClient::svrtosvr: " << strerror(errno) << endl; exit(1); } int len = copystring(c_str, str); if (package.virtualpath().empty()) //empty key not allowed. { return -1; } //cout << "C++ string len = " << str.length() << endl; cout << "C++ string: \n" << str << endl; /*cout << "C string: " << endl; for(int i = 0; i < len; i++) cout << c_str[i]; cout << endl; return 1;*/ int sock = this->index2SockLRU(index, TCP); reuseSock(sock); struct HostEntity dest = this->index2Host(index); sockaddr_in recvAddr; //cout << "going to acquire lock" << endl; //pthread_mutex_lock(&msg_lock); //cout << "lock acquired" << endl; //int sentSize = generalSendTo(dest.host.data(), dest.port, sock, str.c_str(), str.size(), TCP); //cout << "what is the f**k!" << dest.host.data() << endl; int sentSize = generalSendTo(dest.host.data(), dest.port, sock, c_str, len, TCP); //cout << "svrsvr sent" << endl; //pthread_mutex_unlock(&msg_lock); int32_t* ret_buf = (int32_t*) malloc(sizeof(int32_t)); //pthread_mutex_lock(&msg_lock); generalReceive(sock, (void*) ret_buf, sizeof(int32_t), recvAddr, 0, TCP); //cout << "svrsvr recv" << endl; //pthread_mutex_unlock(&msg_lock); //cout << "lock released" << endl; int32_t ret_1 = *(int32_t*) ret_buf; free(ret_buf); //if(package.operation() == 14) { // cout << "ZHTClient::svrtosvr num_task = " << ret_1 << endl; //} return ret_1; }
//send a plain string to destination, receive return state. int ZHTClient::insert(string str) { /* int sock = -1; struct HostEntity dest = this->str2Host(str); // cout<<"Client: will send to "<<dest.host<<endl; //int ret = simpleSend(str, dest, sock); sock = makeClientSocket(dest.host.c_str(), dest.port, 1); // cout<<"client sock = "<< sock<<endl; reuseSock(sock); generalSendTCP(sock, str.c_str()); */ Package package; package.ParseFromString(str); if (package.virtualpath().empty()) //empty key not allowed. return -1; if (package.realfullpath().empty()) //coup, to fix ridiculous bug of protobuf! package.set_realfullpath(" "); package.set_operation(3); //1 for look up, 2 for remove, 3 for insert package.set_replicano(5); //5: original, 3 not original str = package.SerializeAsString(); int sock = this->str2SockLRU(str, TCP); reuseSock(sock); // cout<<"sock = "<<sock<<endl; // int sentSize = generalSendTCP(sock, str.c_str()); struct HostEntity dest = this->str2Host(str); sockaddr_in recvAddr; int sentSize = generalSendTo(dest.host.data(), dest.port, sock, str.c_str(), TCP); // cout <<"Client inseret sent: "<<sentSize<<endl; int32_t* ret_buf = (int32_t*) malloc(sizeof(int32_t)); // generalReveiveTCP(sock, (void*) ret_buf, sizeof(int32_t), 0); generalReceive(sock, (void*) ret_buf, 4, recvAddr, 0, TCP); int ret = *(int32_t*) ret_buf; if (ret < 0) { // cerr << "zht_util.h: Failed to insert." << endl; } //cout <<"Returned status: "<< *(int32_t*) ret<<endl; // d3_closeConnection(sock); free(ret_buf); //return ret_1; // cout<<"insert got: "<< *ret <<endl; return ret; }
int32_t ZHTClient::send(string str, int size) { Package package; package.ParseFromString(str); char *c_str; c_str = (char*) malloc((size + 5 + 1) * sizeof(char)); if (c_str == NULL) { cout << "ZHTClient::send: " << strerror(errno) << endl; exit(1); } int len = copystring(c_str, str); if (package.virtualpath().empty()) //empty key not allowed. return -1; //cout << "C++ string len = " << str.length() << endl; cout << "C++ string: \n" << str << endl; /*cout << "C string: " << endl; for(int i = 0; i < len; i++) cout << c_str[i]; cout << endl; return 1;*/ int sock = this->str2SockLRU(str, TCP); reuseSock(sock); struct HostEntity dest = this->str2Host(str); sockaddr_in recvAddr; //pthread_mutex_lock(&msg_lock); //int sentSize = generalSendTo(dest.host.data(), dest.port, sock, str.c_str(), str.size(), TCP); int sentSize = generalSendTo(dest.host.data(), dest.port, sock, c_str, len, TCP); //pthread_mutex_unlock(&msg_lock); //cout << " Sent size = " << sentSize << endl; int32_t* ret_buf = (int32_t*) malloc(sizeof(int32_t)); //pthread_mutex_lock(&msg_lock); generalReceive(sock, (void*) ret_buf, sizeof(int32_t), recvAddr, 0, TCP); //pthread_mutex_unlock(&msg_lock); int ret_1 = *(int32_t*) ret_buf; free(ret_buf); return ret_1; }
//send a serialized string to destination, receive return state. int ZHTClient::insert(string str) { /* int sock = -1; struct HostEntity dest = this->str2Host(str); // cout<<"Client: will send to "<<dest.host<<endl; //int ret = simpleSend(str, dest, sock); sock = makeClientSocket(dest.host.c_str(), dest.port, 1); // cout<<"client sock = "<< sock<<endl; reuseSock(sock); generalSendTCP(sock, str.c_str()); */ int sock = this->str2SockLRU(str, TCP); reuseSock(sock); // cout<<"sock = "<<sock<<endl; // int sentSize = generalSendTCP(sock, str.c_str()); struct HostEntity dest = this->str2Host(str); sockaddr_in recvAddr; int sentSize = generalSendTo(dest.host.data(),dest.port, sock, str.c_str(), TCP); // cout <<"Client inseret sent: "<<sentSize<<endl; int32_t* ret_buf = (int32_t*) malloc(sizeof(int32_t)); // generalReveiveTCP(sock, (void*) ret_buf, sizeof(int32_t), 0); generalReceive(sock, (void*)ret_buf, 4,recvAddr,0, TCP); int32_t* ret = (int32_t*) ret_buf; if (*ret < 0) { // cerr << "zht_util.h: Failed to insert." << endl; } //cout <<"Returned status: "<< *(int32_t*) ret<<endl; // d3_closeConnection(sock); free(ret_buf); //return ret_1; // cout<<"insert got: "<< *ret <<endl; return *ret; }
void EpollServer::serve() { #ifdef THREADED_SERVE init_thread(); #endif int sfd, s; int efd; struct epoll_event event; struct epoll_event *events; sfd = makeSvrSocket(); if (sfd == -1) abort(); s = make_socket_non_blocking(sfd); if (s == -1) abort(); reuseSock(sfd); efd = epoll_create(1); if (efd == -1) { perror("epoll_create"); abort(); } event.data.ptr = new EpollData(sfd, NULL); event.events = EPOLLIN | EPOLLET; s = epoll_ctl(efd, EPOLL_CTL_ADD, sfd, &event); if (s == -1) { perror("epoll_ctl"); abort(); } /* Buffer where events are returned */ events = (epoll_event *) calloc(MAX_EVENTS, sizeof event); /* The event loop */ while (1) { int n, i; n = epoll_wait(efd, events, MAX_EVENTS, -1); for (i = 0; i < n; i++) { EpollData *edata = (EpollData*) events[i].data.ptr; if ((events[i].events & EPOLLERR) || (events[i].events & EPOLLHUP) || (!(events[i].events & EPOLLIN))) { /* An error has occured on this fd, or the socket is not ready for reading (why were we notified then?) */ fprintf(stderr, "epoll error\n"); close(edata->fd()); delete edata; continue; } else if (sfd == edata->fd()) { if (_tcp == true) { /* We have a notification on the listening socket, which means one or more incoming connections. */ while (1) { sockaddr *in_addr = (sockaddr *) calloc(1, sizeof(struct sockaddr)); socklen_t in_len = sizeof(struct sockaddr); int infd = accept(sfd, in_addr, &in_len); if (infd == -1) { free(in_addr); if ((errno == EAGAIN) || (errno == EWOULDBLOCK)) { /* We have processed all incoming connections. */ break; } else { perror("accept"); break; } } /* fprintf(stdout, "sin_family[%hu], sin_zero[%s], sin_addr.s_addr[%u], sin_port[%hu]\n", in_addr.sin_family, in_addr.sin_zero, in_addr.sin_addr.s_addr, in_addr.sin_port); */ /* char hbuf[NI_MAXHOST], sbuf[NI_MAXSERV]; getnameinfo(in_addr, in_len, hbuf, sizeof hbuf, sbuf, sizeof sbuf, 0); if (s == 0) { printf("Accepted connection on descriptor %d " "(host=%s, _port=%s)\n", infd, hbuf, sbuf); }*/ /* Make the incoming socket non-blocking and add it to the list of fds to monitor. */ s = make_socket_non_blocking(infd); if (s == -1) { free(in_addr); abort(); } reuseSock(infd); event.data.ptr = new EpollData(infd, in_addr); event.events = EPOLLIN | EPOLLET; s = epoll_ctl(efd, EPOLL_CTL_ADD, infd, &event); if (s == -1) { free(in_addr); perror("epoll_ctl"); abort(); } } continue; } else { int done = 0; while (1) { char buf[Env::BUF_SIZE]; memset(buf, 0, sizeof(buf)); //char *buf = (char*) calloc(Env::BUF_SIZE, sizeof(char)); sockaddr fromaddr; socklen_t sender_len = sizeof(struct sockaddr); ssize_t count = recvfrom(edata->fd(), buf, sizeof buf, 0, &fromaddr, &sender_len); //cout << "EpollServer.cpp: serve(): received "<< count << " bytes."<<endl; if (count == -1) { if (errno != EAGAIN) { perror("read"); done = 1; } } else if (count == 0) { done = 1; break; } else { #ifdef BIG_MSG bool ready = false; string bd = pbrb->getBdStr(sfd, buf, count, ready); if (ready) { #ifdef THREADED_SERVE EventData eventData(edata->fd(), bd.c_str(), bd.size(), fromaddr); _eventQueue.push(eventData); #else _ZProcessor->process(edata->fd(), bd.c_str(), fromaddr); #endif } #endif #ifdef SML_MSG #ifdef THREADED_SERVE EventData eventData(edata->fd(), buf, sizeof(buf), fromaddr); _eventQueue.push(eventData); #else string bufstr(buf); _ZProcessor->process(edata->fd(), bufstr.c_str(), fromaddr); #endif #endif } //memset(buf, 0, sizeof(buf)); //free(buf); } /*if (done) { close(edata->fd()); delete edata; }*/ } } else { if (_tcp == true) { /* We have data on the fd waiting to be read. Read and display it. We must read whatever data is available completely, as we are running in edge-triggered mode and won't get a notification again for the same data. */ int done = 0; while (1) { char buf[Env::BUF_SIZE]; memset(buf, 0, sizeof(buf)); //char *buf = (char*) calloc(Env::BUF_SIZE, sizeof(char)); ssize_t count = recv(edata->fd(), buf, sizeof(buf), 0); if (count == -1) { /* If errno == EAGAIN, that means we have read all data. So go back to the main loop. */ if (errno != EAGAIN) { perror("read"); done = 1; } /*else { printf( "Closed connection on descriptor %d, -1<--recv\n", edata->fd()); close(edata->fd()); delete edata; }*/ break; } else if (count == 0) { /* End of file. The remote has closed the connection. */ done = 1; break; } else { #ifdef BIG_MSG bool ready = false; string bd = pbrb->getBdStr(sfd, buf, count, ready); if (ready) { #ifdef THREADED_SERVE EventData eventData(edata->fd(), bd.c_str(), bd.size(), *edata->sender()); _eventQueue.push(eventData); #else _ZProcessor->process(edata->fd(), bd.c_str(), *edata->sender()); #endif } #endif #ifdef SML_MSG #ifdef THREADED_SERVE EventData eventData(edata->fd(), buf, sizeof(buf), *edata->sender()); _eventQueue.push(eventData); #else string bufstr(buf); _ZProcessor->process(edata->fd(), bufstr.c_str(), *edata->sender()); #endif #endif } //memset(buf, 0, sizeof(buf)); //free(buf); } if (done) { /*printf("Closed connection on descriptor %d, done.\n", edata->fd());*/ /* Closing the descriptor will make epoll remove it from the set of descriptors which are monitored. */ close(edata->fd()); delete edata; } } //if TCP == true } } } free(events); close(sfd); EpollData *edata = (EpollData*) event.data.ptr; delete edata; }
int ZHTClient::lookup(string str, string &returnStr) { Package package; package.ParseFromString(str); if (package.virtualpath().empty()) //empty key not allowed. return -1; if (package.realfullpath().empty()) //coup, to fix ridiculous bug of protobuf! package.set_realfullpath(" "); package.set_operation(1); // 1 for look up, 2 for remove, 3 for insert package.set_replicano(3); //5: original, 3 not original str = package.SerializeAsString(); struct HostEntity dest = this->str2Host(str); // cout << "client::lookup is called, now send request..." << endl; Package pack; pack.ParseFromString(str); // cout<<"ZHTClient::lookup: operation = "<<pack.operation()<<endl; // int ret = simpleSend(str, dest, sock); // sock = makeClientSocket(dest.host.c_str(), dest.port, 1); // cout<<"client sock = "<< sock<<endl; int sock = this->str2SockLRU(str, TCP); reuseSock(sock); // cout<<"sock = "<<sock<<endl; sockaddr_in recvAddr; int sentSize = generalSendTo(dest.host.data(), dest.port, sock, str.c_str(), TCP); // int ret = generalSendTCP(sock, str.c_str()); // cout << "ZHTClient::lookup: simpleSend return = " << ret << endl; char buff[MAX_MSG_SIZE]; //MAX_MSG_SIZE memset(buff, 0, sizeof(buff)); int rcv_size = -1; int status = -1; string sRecv; string sStatus; if (sentSize == str.length()) { //this only work for TCP. UDP need to make a new one so accept returns from server. // cout << "before protocol judge" << endl; rcv_size = generalReceive(sock, (void*) buff, sizeof(buff), recvAddr, 0, TCP); if (rcv_size < 0) { cout << "Lookup receive error." << endl; } else { sRecv.assign(buff); returnStr = sRecv.substr(3); //the left is real thing need to be deserilized. sStatus = sRecv.substr(0, 3); //the first three chars means status code, like -1, -2, 0, -98, -99 and so on. } // cout << "after protocol judge" << endl; } // d3_closeConnection(sock); if (!sStatus.empty()) status = atoi(sStatus.c_str()); return status; }
int ZHTClient::lookup(string str, string &returnStr) { Package package; package.ParseFromString(str); if (package.virtualpath().empty()) //empty key not allowed. return -1; /*if (package.realfullpath().empty()) //coup, to fix ridiculous bug of protobuf! package.set_realfullpath(" ");*/ package.set_operation(1); // 1 for look up, 2 for remove, 3 for insert package.set_replicano(3); //5: original, 3 not original str = package.SerializeAsString(); struct HostEntity dest = this->str2Host(str); // cout << "client::lookup is called, now send request..." << endl; char *c_str; int size = str.length(); c_str = (char*) malloc((size + 5 + 1) * sizeof(char)); if (c_str == NULL) { cout << "ZHTClient::svrtosvr: " << strerror(errno) << endl; exit(1); } int len = copystring(c_str, str); Package pack; pack.ParseFromString(str); // cout<<"ZHTClient::lookup: operation = "<<pack.operation()<<endl; // int ret = simpleSend(str, dest, sock); // sock = makeClientSocket(dest.host.c_str(), dest.port, 1); // cout<<"client sock = "<< sock<<endl; int sock = this->str2SockLRU(str, TCP); reuseSock(sock); // cout<<"sock = "<<sock<<endl; sockaddr_in recvAddr; //cout << "lookup str = " << str << endl; //pthread_mutex_lock(&msg_lock); int sentSize = generalSendTo(dest.host.data(), dest.port, sock, c_str, len, TCP); //pthread_mutex_unlock(&msg_lock); //int sentSize = generalSendTo(dest.host.data(), dest.port, sock, str.c_str(), str.size(), TCP); // int ret = generalSendTCP(sock, str.c_str()); // cout << "ZHTClient::lookup: simpleSend return = " << ret << endl; char buff[Env::MAX_MSG_SIZE]; //Env::MAX_MSG_SIZE memset(buff, 0, sizeof(buff)); int rcv_size = -1; int status = -1; string sRecv; string sStatus; //if (sentSize == str.length()) { //this only work for TCP. UDP need to make a new one so accept returns from server. if (sentSize == len) { // cout << "before protocol judge" << endl; //pthread_mutex_lock(&msg_lock); rcv_size = generalReceive(sock, (void*) buff, sizeof(buff), recvAddr, 0, TCP); //pthread_mutex_unlock(&msg_lock); if (rcv_size < 0) { cout << "Lookup receive error." << endl; } else { //cout << "ZHTClient::lookup: buff = " << buff << " size = " << rcv_size << endl; sRecv.assign(buff); //cout << "ZHTClient::lookup: for key " << package.virtualpath() << " recd = " << sRecv << endl; try { returnStr = sRecv.substr(3); //the left is real thing need to be deserilized. } catch (exception& e) { cout << "ZHTClient::lookup: (substr(3)) " << " " << e.what() << endl; exit(1); } try { sStatus = sRecv.substr(0, 3); //the first three chars means status code, like 001, 002, -98, -99 and so on. } catch (exception& e) { cout << "ZHTClient::lookup: (substr(0, 3)) " << " " << e.what() << endl; exit(1); } } // cout << "after protocol judge" << endl; } // d3_closeConnection(sock); if (!sStatus.empty()) status = atoi(sStatus.c_str()); return status; }
int ZHTClient::lookup(string path, string &returnStr) { Package package; package.set_operation(1); // 3 for insert, 1 for look up, 2 for remove package.set_replicano(3); //5: original, 3 not original package.set_virtualpath(path); string str = package.SerializeAsString(); struct HostEntity dest = this->str2Host(str); // cout << "client::lookup is called, now send request..." << endl; Package pack; pack.ParseFromString(str); // cout<<"ZHTClient::lookup: operation = "<<pack.operation()<<endl; // int ret = simpleSend(str, dest, sock); // sock = makeClientSocket(dest.host.c_str(), dest.port, 1); // cout<<"client sock = "<< sock<<endl; int sock = this->str2SockLRU(str, TCP); reuseSock(sock); // cout<<"sock = "<<sock<<endl; sockaddr_in recvAddr; int sentSize = generalSendTo(dest.host.data(), dest.port, sock, str.c_str(), TCP); // int ret = generalSendTCP(sock, str.c_str()); // cout << "ZHTClient::lookup: simpleSend return = " << ret << endl; char buff[MAX_MSG_SIZE]; //MAX_MSG_SIZE memset(buff, 0, sizeof(buff)); int rcv_size = -1; if (sentSize == str.length()) { //this only work for TCP. UDP need to make a new one so accept returns from server. // cout << "before protocol judge" << endl; rcv_size = generalReceive(sock, (void*)buff, sizeof(buff),recvAddr,0, TCP); /* if (TRANS_PROTOCOL == USE_TCP) { rcv_size = d3_recv_data(sock, buff, MAX_MSG_SIZE, 0); //MAX_MSG_SIZE } else if (TRANS_PROTOCOL == USE_UDP) { //int svrPort = dest.port;//surely wrong, it's just the 50000 port //int svrPort = 50001; srand(getpid() + clock()); // int z = rand() % 10000 + 10000; // cout<<"Client:lookup: random port: "<<z<<endl; // int server_sock = d3_svr_makeSocket(rand() % 10000 + 10000);// use random port to send, and receive lookup result from it too. // cout<<"Client:lookup: UDP socket: "<<server_sock<<endl; sockaddr_in tmp_sockaddr; memset(&tmp_sockaddr, 0, sizeof(sockaddr_in)); // cout << "lookup: before receive..." << endl; rcv_size = d3_svr_recv(sock, buff, MAX_MSG_SIZE, 0, &tmp_sockaddr); //receive lookup result //d3_closeConnection(server_sock); // cout << "lookup received " << rcv_size << " bytes." << endl; }*/ if (rcv_size < 0) { cout << "Lookup receive error." << endl; return rcv_size; } else { returnStr.assign(buff); } // cout << "after protocol judge" << endl; } // d3_closeConnection(sock); return rcv_size; }