void JointSliders::UDPReceiverWorker() {
double *data = new double[m_TotNumLinks];
UDPSocket sockfd(12345);
cout << "\nListening in port 12345...\n";
cout << flush;
string sourceAddress; // Address of datagram source
unsigned short sourcePort; // Port of datagram source
while (m_Running) {
int rc = sockfd.recvFrom((char *)data, 8*m_TotNumLinks, sourceAddress, sourcePort);
size_t k = 0;
for (size_t h = 0; h < m_Robots->size(); h ++) {
Robot *robot = m_Robots->at(h);
size_t n = robot->GetLinks().size();
for (size_t i = 0; i < n; i++) {
robot->ActuateJoint((int) i, data[k]);
k = k + 1;
}
robot->Update(m_Verbose);
}
} //while (m_Running)
delete [] data;
}
int main(int argc, char* argv[]){
if(argc <= 2){
printf("usage: %s ip_address port_number\n", basename(argv[0]));
return 1;
}
const char* ip = argv[1];
int port = atoi(argv[2]);
struct sockaddr_in address;
bzero(&address, sizeof(address));
address.sin_family = AF_INET;
inet_pton(AF_INET, ip, &address.sin_addr);
address.sin_port = htons(port);
int listenfd = sockfd(PF_INET, SOCK_STREAM, 0);
assert(listenfd >= 0);
int ret = 0;
ret = bind(listenfd, (struct sockaddr*)&address, sizeof(address));
assert(ret != -1);
ret = listen(listenfd, 5);
assert(ret != -1);
epoll_event events[MAX_EVENT_NUMBER];
int epollfd = epoll_create(5);
assert(epollfd != -1);
addfd(epollfd, listenfd, false);
while(1){
ret = epoll_wait(epollfd, &events, MAX_EVENT_NUMBER, -1);
if(ret < 0){
printf("epoll failure\n");
continue;
}
for(int i = 0; i < ret; i++){
int sockfd = events[i].data.fd;
if(sockfd == listenfd){
struct sockaddr_in client_address;
socklen_t client_addrlength = sizeof(client_address);
int connfd = accept(listenfd, (struct sockaddr*)&client_address, &client_addrlength);
/*对每个非监听描述符都注册EPOLLONESHOT事件*/
addfd(epollfd, connfd, true);
} else if(events[i].events & EPOLLIN) {
pthread_t thread;
fds fds_for_new_worker;
fds_for_new_worker.sockfd = sockfd;
fds_for_new_worker.epollfd = epollfd;
/*启动一个新线程为sockfd服务*/
pthread_create(&thread, NULL, worker, (void *)&fds_for_new_worker);
} else {
printf("something else happened\n");
}
}
}
close(listenfd);
return 0;
}
int
main(int argc, char *argv[]) try
{
std::locale::global(std::locale(""));
prog_name = Util::prog(argv[0]);
if (argc != 3)
{
Util::out_message(false, std::cerr, 0, "Usage: %s hostname port", prog_name);
exit(EXIT_FAILURE);
}
char *host_name = argv[1];
char *port = argv[2];
Net::AddrInfo hints;
hints.get().ai_socktype = SOCK_STREAM;
hints.get().ai_flags = AI_ADDRCONFIG | AI_CANONNAME;
Net::Resolver res(host_name, port, hints);
Net::Resolver::const_iterator it = res.begin();
Net::Resolver::const_iterator it_end = res.end();
for (;it != it_end; ++it)
{
Net::PSockAddrIn servaddr(it->ai_addr);
Net::AddrToStr trans(*it);
Net::Socket sockfd(servaddr->sin_family, it->ai_socktype, it->ai_protocol);
try
{
sockfd.Connect(servaddr, it->ai_addrlen);
}
catch (Net::SocketErr& err)
{
Util::out_message(false, std::cerr, 0, "%s: %s %s", prog_name, trans.get(), err.what());
continue;
}
char recvline[BUFSIZ];
ssize_t len;
while ( (len = sockfd.Read(recvline, BUFSIZ)) > 0)
{
recvline[len] = '\0'; /* null terminate */
std::cout << recvline;
}
break;
}
if (it == it_end)
return EXIT_FAILURE;
else
return EXIT_SUCCESS;
}
catch(std::exception& err)
{
Util::out_message(false, std::cerr, 0, "%s: %s", prog_name, err.what());
exit(EXIT_FAILURE);
}
catch(...)
{
Util::out_message(false, std::cerr, 0, "%s: %s", prog_name, "unknown exception");
exit(EXIT_FAILURE);
}
void HTTPSimple::send(std::string &data)
{
SocketClient sockfd(AF_INET, SOCK_STREAM, IPPROTO_TCP, "", host, HTTP_PORT);
sockfd.Connect();
start_time = std::chrono::high_resolution_clock::now();
sockfd.Send(data);
data.clear();
sockfd.Recv(data, true);
end_time = std::chrono::high_resolution_clock::now();
return;
}
int main(int argc, char *argv[])
{
if (3 != argc)
{
LOG_ERROR("usage : tcp_client x.x.x.x msg");
return 0;
}
int isockfd;
if ((isockfd = sockfd(argv[1])) < 0) return 0;
if (strlen(argv[2]) > 0) echo(isockfd, argv[2], strlen(argv[2]));
close(isockfd);
return 0;
}
int tcp_listen(const char *host,const char *serv,socklen_t *addrlenp)
{
int listenfd,n;
const int on = 1;
struct addrinfo hints,*res,*ressave;
bzero(&hints,sizeof(struct addrinfo));
hints.ai_flags = AI_PASSIVES;
hints.ai_family = AF_UNSPEC;
hints.ai_socktype = SOCK_STREAM;
if( (n = getaddrinfo(host,serv,&hints,&res)) != 0)
err_quit("tcp_listen error for %s,%s:%s",
host,serv,gai_strerror(n));
ressave = res;
do{
listenfd =
sockfd(res->ai_family,res->ai_socktype,res->ai_protocol);
if(listenfd < 0)
continue;
Setsockopt(listenfd,SOL_SOCKET,SO_REUSEADDR,&on,sizeof(on));
if(bind(listenfd,res->ai_addr,res->ai_addrlen) == 0)
break;
Close(listenfd);
}while( (res = res->ai_next) != NULL);
if(res == NULL)
err_sys("tcp_listen error for %s,%s",host,serv);
Listen(listenfd,LISTENQ);
if(addrlenp)
*addrlenp = res->ai_addrlen;/* return size of protocol address */
freeaddrinfo(ressave);
return(listenfd);
}
int32_t main(int32_t argc, char** argv) {
string address="127.0.0.1";
uint32_t nelements, elebytelen, ntasks=1, nruns=1, symsecbits=128;
uint64_t rnd;
role_type role = (role_type) 0;
vector<CSocket> sockfd(ntasks);
uint16_t port=7766;
uint8_t* seed = (uint8_t*) malloc(AES_BYTES);
read_psi_test_options(&argc, &argv, &role, &nruns);
memcpy(seed, const_seed, AES_BYTES);
seed[0] = role;
crypto* crypt = new crypto(symsecbits, seed);
crypt->gen_rnd((uint8_t*) &rnd, sizeof(uint64_t));
srand((unsigned)rnd+time(0));
if(role == SERVER) {
listen(address.c_str(), port, sockfd.data(), ntasks);
} else {
for(uint32_t i = 0; i < ntasks; i++)
connect(address.c_str(), port, sockfd[i]);
}
for(uint32_t i = 0; i < nruns; i++) {
if(role == CLIENT) cout << "Running test on iteration " << i << std::flush;
nelements = rand() % (1<<12);
elebytelen = (rand() % 12) + 4;
test_psi_prot(role, sockfd.data(), nelements, elebytelen, crypt);
if(role == CLIENT) cout << endl;
}
if(role == CLIENT) cout << "All tests successfully passed" << endl;
}
int32_t psi_demonstrator(int32_t argc, char** argv) {
double epsilon=1.2;
uint64_t bytes_sent=0, bytes_received=0, mbfac;
uint32_t nelements=0, elebytelen=16, symsecbits=128, intersect_size = 0, i, j, ntasks=1,
pnelements, *elebytelens, *res_bytelens, nclients = 2;
uint16_t port=7766;
uint8_t **elements, **intersection;
bool detailed_timings=false;
string address="127.0.0.1";
timeval t_start, t_end;
vector<CSocket> sockfd(ntasks);
string filename;
role_type role = (role_type) 0;
psi_prot protocol;
mbfac=1024*1024;
read_psi_demo_options(&argc, &argv, &role, &protocol, &filename, &address, &nelements, &detailed_timings);
if(role == FOLLOWER) {
if(protocol == TTP) {
sockfd.resize(nclients);
listen(address.c_str(), port, sockfd.data(), nclients);
}
else
listen(address.c_str(), port, sockfd.data(), ntasks);
} else {
for(i = 0; i < ntasks; i++)
connect(address.c_str(), port, sockfd[i]);
}
gettimeofday(&t_start, NULL);
//read in files and get elements and byte-length from there
read_elements(&elements, &elebytelens, &nelements, filename);
if(detailed_timings) {
gettimeofday(&t_end, NULL);
}
if(protocol != TTP)
pnelements = exchange_information(nelements, elebytelen, symsecbits, ntasks, protocol, sockfd[0]);
//cout << "Performing private set-intersection between " << nelements << " and " << pnelements << " element sets" << endl;
if(detailed_timings) {
cout << "Time for reading elements:\t" << fixed << std::setprecision(2) << getMillies(t_start, t_end)/1000 << " s" << endl;
}
crypto crypto(symsecbits);//, (uint8_t*) const_seed);
switch(protocol) {
case NAIVE:
intersect_size = naivepsi(role, nelements, pnelements, elebytelens, elements, &intersection, &res_bytelens,
&crypto, sockfd.data(), ntasks);
break;
case TTP:
intersect_size = ttppsi(role, nelements, elebytelens, elements, &intersection, &res_bytelens,
&crypto, sockfd.data(), ntasks);
break;
case DH_ECC:
intersect_size = dhpsi(role, nelements, pnelements, elebytelens, elements, &intersection, &res_bytelens, &crypto,
sockfd.data(), ntasks);
break;
case OT_PSI:
intersect_size = otpsi(role, nelements, pnelements, elebytelens, elements, &intersection, &res_bytelens,
&crypto, sockfd.data(), ntasks, epsilon, detailed_timings);
break;
default:
intersect_size = otpsi(role, nelements, pnelements, elebytelens, elements, &intersection, &res_bytelens,
&crypto, sockfd.data(), ntasks, epsilon, detailed_timings);
break;
}
gettimeofday(&t_end, NULL);
if(role == LEADER) {
cout << "Computation finished. Found " << intersect_size << " intersecting elements:" << endl;
if(!detailed_timings) {
for(i = 0; i < intersect_size; i++) {
//cout << i << ": \t";
for(j = 0; j < res_bytelens[i]; j++) {
cout << intersection[i][j];
}
cout << endl;
}
}
for(i = 0; i < intersect_size; i++) {
free(intersection[i]);
}
if(intersect_size > 0)
free(res_bytelens);
}
for(i = 0; i < sockfd.size(); i++) {
bytes_sent += sockfd[i].get_bytes_sent();
bytes_received += sockfd[i].get_bytes_received();
}
if(detailed_timings) {
cout << "Required time:\t" << fixed << std::setprecision(1) << getMillies(t_start, t_end)/1000 << " s" << endl;
cout << "Data sent:\t" << ((double)bytes_sent)/mbfac << " MB" << endl;
cout << "Data received:\t" << ((double)bytes_received)/mbfac << " MB" << endl;
}
for(i = 0; i < nelements; i++)
free(elements[i]);
free(elements);
free(elebytelens);
return 1;
}
void CSocketHTTPDataSource::SendHelper(const char *pzRequest, int nRequestLen, GString &destinationStream, const char *pzNamespace)
{
int fd, numbytes;
#ifdef _WIN32
WSADATA wsaData;
WSAStartup(MAKEWORD( 1, 0 ), &wsaData);
#endif
int nNamespaceLen = (int)strlen(pzNamespace);
struct sockaddr_in their_addr;
their_addr.sin_family = AF_INET;
their_addr.sin_port = htons(m_nPort);
their_addr.sin_addr.s_addr = inet_addr (GetServerAddress());
if (their_addr.sin_addr.s_addr == -1)
{
// resolve a DNS server name if inet_addr() came up empty.
struct hostent *pHE = (struct hostent *)gethostbyname(GetServerAddress());
if (pHE == 0)
{
GString strError;
strError.Format("gethostbyname() failed to resolve[%s]",GetServerAddress());
throw CSocketError(errno,(const char *)strError);
}
memcpy((char *)&(their_addr.sin_addr), pHE->h_addr,pHE->h_length);
}
memset(&(their_addr.sin_zero),0, 8);//zero the rest of the struct
if ((fd = socket(AF_INET, SOCK_STREAM, 0)) == -1)
{
throw CSocketError(0,"socket");
}
CSocketWrap sockfd(fd);
// local bind() is not required on WIN32 platform
struct sockaddr_in localAddr;
localAddr.sin_family = AF_INET;
localAddr.sin_addr.s_addr = htonl(INADDR_ANY);
localAddr.sin_port = htons(0);
int rc = bind(fd, (struct sockaddr *) &localAddr, sizeof(localAddr));
if(rc<0)
{
GString strError;
strError.Format("failed to bind([%s]:%d)",GetServerAddress(),(int)m_nPort);
throw CSocketError(errno,(const char *)strError);
}
if (connect(fd, (struct sockaddr *)&their_addr, sizeof(struct sockaddr)) == -1)
{
GString strError;
strError.Format("failed to connect([%s]:%d)",GetServerAddress(),(int)m_nPort);
throw CSocketError(errno,(const char *)strError);
}
// 200 bytes in excess
char *pSendBuf = new char[200 + nRequestLen + nNamespaceLen];
sprintf(pSendBuf,"POST /XMLServer/UBT.dll?%s HTTP/1.1\r\nUser-Agent: XML_Object_Framework_DataSource\r\nHost: 100.100.100.100\r\nContent-Length: ",pzNamespace);
GString strTemp;
strTemp.Format("%d\r\n\r\n%s",(int)nNamespaceLen + nRequestLen,pzNamespace);
strcat(&pSendBuf[120],(const char *)strTemp);
int nHeaderLen = (int)strlen(&pSendBuf[120]) + 120;
strcat(&pSendBuf[120],pzRequest);
int nTotalMessageLength = nHeaderLen + nRequestLen;
if ((numbytes=sendto(sockfd, pSendBuf, nTotalMessageLength, 0,
(struct sockaddr *)&their_addr, sizeof(struct sockaddr))) == -1)
{
delete[] pSendBuf;
throw CSocketError(sockfd,"sendto");
}
delete[] pSendBuf;
int nCumulativeBytes = 0;
numbytes = 0;
do
{
if ((numbytes=recv(sockfd, m_winsockBuffer, sizeof(m_winsockBuffer), 0)) == -1)
{
continue;
}
destinationStream.write(m_winsockBuffer,numbytes);
nCumulativeBytes += numbytes;
}while( numbytes != 0 );
}
