9004l1.txt0100664000175300003300000003067110440071022011433 0ustar jillljeditListing 1. Rendezvous Code /* Copyright Girish Venkatachalam 2006 * girish1729@gmail.com * * You are free to modify it to suit your requirements. * The licensing terms of this program is along the lines * of the BSD license. You are free to use this for commercial * purposes provide you retain this notice. * * * */ #include "p2pcommon.h" struct cs_st cs[1024]; int tcp1,tcp2,udp; /* One tcp port for 80 and another for 1234 */ void setnonblock(int sock) { int fl = fcntl(sock, F_GETFL); if (fl < 0) syslog(LOG_ERR,"fcntl() problem"); if (fcntl(sock, F_SETFL, fl | O_NONBLOCK) < 0) syslog(LOG_ERR,"fcntl() problem"); } void settimeouts(int sock, int secs) { struct timeval tv; tv.tv_sec = secs; tv.tv_usec = 0; if (setsockopt(sock, SOL_SOCKET, SO_SNDTIMEO, &tv, sizeof(tv)) < 0) syslog(LOG_ERR,"setsockopt(SO_SNDTIMEO) problem"); if (setsockopt(sock, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(tv)) < 0) syslog(LOG_ERR,"setsockopt(SO_RCVTIMEO) problem"); } int update_desc_list(fd_set *rfds, fd_set *wfds) { int i,fds; FD_ZERO(rfds); FD_ZERO(wfds); FD_SET(tcp1,rfds); FD_SET(tcp2,rfds); FD_SET(udp,rfds); if(tcp1 > tcp2) { if(udp > tcp1) fds = udp + 1; else fds = tcp1 + 1; } else { if(udp > tcp2) fds = udp + 1; else fds = tcp2 + 1; } for(i = 0; cs[i].fd != -1;i++) { fds = cs[i].fd + 1; FD_SET(cs[i].fd,rfds); } return fds; } void adddescr(int ntcp) { int i =0; while(cs[i].fd != -1) i++; cs[i].fd = ntcp; cs[i+1].fd = -1; } int hdl_register(int sock,struct register_payload *st) { int i = 0,n; struct msg m; while(cs[i].fd != -1) { if(cs[i].id == ntohl(st->id)) { m.op = DUPLICATE_ID; break; } if(cs[i].fd == sock) { m.op = REGISTRATION_COMPLETED; break; } i++; } /* Now send the result back to client indicating * successful registration or duplicate */ do { n = send(sock,(char *)&m,sizeof(m),0); }while(eblock()); if(n == -1) { /* send() failed */ syslog(LOG_ERR,"TCP send() problem, closing socket"); close(sock); } if(m.op == DUPLICATE_ID) return 0; cs[i].id = ntohl(st->id); cs[i].priv = st->priv; cs[i].pub = st->pub; syslog(LOG_INFO,"<>",cs[i].id,cs[i].fd); syslog(LOG_INFO,"Successfully registered with public %s:%d", inet_ntoa(cs[i].pub.sin_addr), ntohs(cs[i].pub.sin_port)); syslog(LOG_INFO,"Successfully registered with private %s:%d", inet_ntoa(cs[i].priv.sin_addr), ntohs(cs[i].priv.sin_port)); return 0; } int hdl_clreqob(struct req_payload *st) { struct msg m; struct cs_st *cp; int n; int peersock; cp = lookup_entry(ntohl(st->peer.id)); peersock = cp->fd; m.op = NEW_CLIENT_REQ_INBOUND; m_st.reqpl = *st; do { n = send(peersock,(char *)&m,sizeof(m),0); }while(eblock()); if(n == -1) { /* send() failed */ syslog(LOG_ERR,"TCP send() problem, closing socket"); close(peersock); cp->fd = -2; cp->id = 0; } return 0; } int hdl_peer(int sock,struct peercoord_payload *st) { struct msg m; struct cs_st *cp; int n; cp = lookup_entry(ntohl(st->id)); if(cp == NULL) { m.op = PEERID_WRONG; } else { m.op = PEER_COORD; m_st.peerpl.id = cp->id; m_st.peerpl.priv = cp->priv; m_st.peerpl.pub = cp->pub; } do { n = send(sock,(char *)&m,sizeof(m),0); }while(eblock()); if(n == -1) { /* send() failed */ syslog(LOG_ERR,"TCP send() problem, closing socket"); close(sock); cp->fd = -2; cp->id = 0; } return 0; } int hdl_end(int sock,struct peercoord_payload *st) { struct msg m; int n; struct cs_st *cp = lookup_entry(ntohl(st->id)); m.op = HOLEPUNCH_COMPLETED; do { n = send(sock,(char *)&m,sizeof(m),0); }while(eblock()); if(cp != NULL) { do { n = send(cp->fd,(char *)&m,sizeof(m),0); }while(eblock()); } if(n == -1) { /* send() failed */ syslog(LOG_ERR,"TCP send() problem, closing socket"); close(sock); cp->fd = -2; cp->id = 0; } return 0; } /* This is the body of the client loop. * The p2p clients stay connected and await for intimation * from the server for connection requests * */ int serve(int sock,int ind) { int b; struct msg m; b = recv(sock,(void *)&m,sizeof(m),0); if(b == -1 || b == 0) { close(sock); cs[ind].fd = -2; cs[ind].id = 0; syslog(LOG_ERR,"Socket %d closed ",sock); return 0; } switch(m.op) { case REGISTER: syslog(LOG_INFO,"Register payload"); hdl_register(sock,&m_st.rpl); break; case NEW_CLIENT_REQ_OUTBOUND: syslog(LOG_INFO,"New outbound holepunch req payload"); hdl_clreqob(&m_st.reqpl); break; case GET_PEER: syslog(LOG_INFO,"Get peer payload"); hdl_peer(sock,&m_st.peerpl); break; case HOLEPUNCHING_COMPLETE: syslog(LOG_INFO,"<<>>"); hdl_end(sock,&m_st.peerpl); break; default: /*syslog(LOG_ERR,"Garbled message from client");*/ break; } return 0; } void setreuse(int sock) { const int one = 1; #ifdef SO_REUSEADDR if (setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, (const void*)&one, sizeof(one)) < 0) syslog(LOG_ERR,"setsockopt(SO_REUSEADDR) problem"); #endif #ifdef SO_REUSEPORT if (setsockopt(sock, SOL_SOCKET, SO_REUSEPORT, (const void*)&one, sizeof(one)) < 0) syslog(LOG_ERR,"setsockopt(SO_REUSEPORT) problem"); #endif } void bounceudp(int udpsock) { struct sockaddr_in ssin; socklen_t sinlen; struct request rq; struct reply rp; int rc; sinlen = sizeof(ssin); rc = recvfrom(udpsock, &rq, sizeof(rq), 0, (struct sockaddr*)&ssin, &sinlen); if (rc < 0) { syslog(LOG_ERR,"recvfrom() problem"); return; } if (rc < (signed)sizeof(rq)) { syslog(LOG_ERR, "Runt UDP request from %s:%d\n", inet_ntoa(ssin.sin_addr), ntohs(ssin.sin_port)); return; /* drop */ } if (rq.magic != htonl(REQMAGIC)) { syslog(LOG_ERR, "Invalid UDP request from %s:%d\n", inet_ntoa(ssin.sin_addr), ntohs(ssin.sin_port)); return; /* drop */ } /* Build the reply and send it to the client */ rp.magic = htonl(REPLMAGIC); rp.pubaddr = ssin.sin_addr; rp.pubport = ssin.sin_port; if (sendto(udpsock, &rp, sizeof(rp), 0,(struct sockaddr*)&ssin, sizeof(ssin)) < 0) { syslog(LOG_ERR,"sendto() problem"); } syslog(LOG_INFO, "UDP request from %s:%d\n", inet_ntoa(ssin.sin_addr), ntohs(ssin.sin_port)); } int createconn(int tcpsock) { struct sockaddr_in sa; socklen_t l = sizeof(sa); int ntcp = accept(tcpsock,(struct sockaddr*)&sa,&l); if(ntcp != -1) { syslog(LOG_INFO,"New TCP connection from %s:%d,Socket = %d",inet_ntoa(sa.sin_addr),ntohs(sa.sin_port),ntcp); adddescr(ntcp); return 0; } syslog(LOG_ERR,"TCP accept() returns -1"); return -1; } int main() { int ret,i; int on = 1,fds; struct sockaddr_in tcpsa,udpsa; fd_set rfds,wfds; socklen_t l; cs[0].fd = -1; if(geteuid() != 0) { fprintf(stderr,"You are not root, dying\n"); syslog(LOG_ERR,"You are not root, no point in continuing"); exit(128); } /* Daemonize */ if(fork() != 0) exit(0); else setsid(); signal(SIGPIPE,SIG_IGN); chdir("/"); openlog("mediator",LOG_PID | LOG_CONS | LOG_PERROR,LOG_LOCAL2); syslog(LOG_INFO,"Starting the mediator daemon..."); FD_ZERO(&rfds); FD_ZERO(&wfds); tcp1 = socket(AF_INET,SOCK_STREAM,0); tcp2 = socket(AF_INET,SOCK_STREAM,0); setnonblock(tcp1); setnonblock(tcp2); ret = setsockopt(tcp1,SOL_SOCKET,SO_KEEPALIVE,&on,sizeof(on)); if(ret < 0) syslog(LOG_ERR,"setsockopt(SO_KEEPALIVE) problem on tcp1"); ret = setsockopt(tcp2,SOL_SOCKET,SO_KEEPALIVE,&on,sizeof(on)); if(ret < 0) syslog(LOG_ERR,"setsockopt(SO_KEEPALIVE) problem on tcp2"); if(tcp1 == -1 || tcp2 == -1) { syslog(LOG_ERR," TCP Socket creation problem.. Exiting"); exit(128); } setreuse(tcp1); setreuse(tcp2); /* make sure we don't linger a long time if the other end * disappears */ settimeouts(tcp1,20); /* 20 seconds */ settimeouts(tcp2,20); tcpsa.sin_addr.s_addr = INADDR_ANY; tcpsa.sin_port = htons(1234); tcpsa.sin_family = AF_INET; ret = bind(tcp1,(struct sockaddr *)&tcpsa,sizeof(tcpsa)); if(ret) { syslog(LOG_ERR,"TCP port 1234 Bind.. Exiting"); exit(128); } tcpsa.sin_addr.s_addr = INADDR_ANY; tcpsa.sin_port = htons(80); tcpsa.sin_family = AF_INET; ret = bind(tcp2,(struct sockaddr *)&tcpsa,sizeof(tcpsa)); if(ret) { syslog(LOG_ERR,"TCP port 80 Bind.. Exiting"); exit(128); } /* Now let us proceed to bind to our UDP ping server */ udp = socket(AF_INET,SOCK_DGRAM,0); if(udp == -1) { syslog(LOG_ERR," UDP Socket creation.. Exiting"); exit(128); } setreuse(udp); udpsa.sin_addr.s_addr = INADDR_ANY; udpsa.sin_port = htons(17000); udpsa.sin_family = AF_INET; ret = bind(udp,(struct sockaddr *)&udpsa,sizeof(udpsa)); if(ret) { syslog(LOG_ERR,"UDP ping server port 17000 Bind.. Exiting"); exit(128); } l = sizeof(struct sockaddr); listen(tcp1,1024); listen(tcp2,1024); for(;;) { update_socket_list(); fds = update_desc_list(&rfds,&wfds); select(fds,&rfds,NULL,NULL,NULL); if(FD_ISSET(udp,&rfds)) { bounceudp(udp); } if(FD_ISSET(tcp1,&rfds)) { createconn(tcp1); } if(FD_ISSET(tcp2,&rfds)) { createconn(tcp2); } for(i=0;cs[i].fd != -1;i++) { if(FD_ISSET(cs[i].fd,&rfds)) { serve(cs[i].fd,i); } } } return 0; } 9004l2.txt0100664000175300003300000004213610440071022011433 0ustar jillljeditListing 2. Hole-Punching Implementation /* Copyright Girish Venkatachalam 2006 * girish1729@gmail.com * * You are free to modify it to suit your requirements. * The licensing terms of this program is along the lines * of the BSD license. You are free to use this for commercial * purposes provide you retain this notice. * * * */ #include "p2pcommon.h" struct sockaddr_in sa[4]; struct sockaddr_in myu[4]; void setreuse(int sock) { const int one = 1; #ifdef SO_REUSEADDR if (setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, (const void*)&one, sizeof(one)) < 0) perrdie("setsockopt(SO_REUSEADDR)"); #endif #ifdef SO_REUSEPORT if (setsockopt(sock, SOL_SOCKET, SO_REUSEPORT, (const void*)&one, sizeof(one)) < 0) perrdie("setsockopt(SO_REUSEPORT)"); #endif } void setnonblock(int sock) { #ifdef WIN32 unsigned long fl = 1; if (ioctlsocket(sock, FIONBIO, &fl) < 0) perrdie("socketioctl"); #else int fl = fcntl(sock, F_GETFL); if (fl < 0) perrdie("fcntl"); if (fcntl(sock, F_SETFL, fl | O_NONBLOCK) < 0) perrdie("fcntl"); #endif } void setblock(int sock) { #ifdef WIN32 unsigned long fl = 0; if (ioctlsocket(sock, FIOBIO, &fl) < 0) perrdie("socketioctl"); #else int fl = fcntl(sock, F_GETFL); if (fl < 0) perrdie("fcntl"); if (fcntl(sock, F_SETFL, fl & ~O_NONBLOCK) < 0) perrdie("fcntl"); #endif } int recvudp(int udp,struct sockaddr_in *privpeer,struct sockaddr_in *pubpeer,struct connection *conn) { struct sockaddr_in tsin; socklen_t sinlen; struct reply rp; int rc; sinlen = sizeof(tsin); rc = recvfrom(udp,(char*)&rp, sizeof(rp), 0, (struct sockaddr*)&tsin, &sinlen); if (rc < (signed)sizeof(rp)) { syslog(LOG_INFO, "Received runt packet\n"); return -1; } if (rp.magic != htonl(REPLMAGIC)) { syslog(LOG_INFO, "Reply with bad magic value\n"); return -1; } syslog(LOG_INFO, "Server reports my UDP address as %s:%d\n", inet_ntoa(rp.pubaddr), ntohs(rp.pubport)); if(pubpeer) { /* hole punch packet */ if(rp.pubaddr.s_addr == conn->ctx->mypriv.sin_addr.s_addr) return 1; else if(rp.pubaddr.s_addr == conn->ctx->mypub.sin_addr.s_addr) return 0; return -1; } else { /* UDP bounce packet */ /* record the address reported by the server */ privpeer->sin_family = AF_INET; privpeer->sin_addr = rp.pubaddr; privpeer->sin_port = rp.pubport; } return 0; } int holepunch(struct connection *conn) { struct msg m; int ret; if(conn->peerid == 0) /* We are just starting the p2p app */ return holepunch_algo(conn,0,0,OUTBOUND); /* XXX What happens here actually is a bit confusing and * I am not too happy with this design. Hopefully if time * permits I will change it one day... * * Once I get a holepunch request I send a request to the * mediation server to locate the private and public address * of the peer whose ID is given to me. * So all that happens here is send the request to mediation * server. Once the request is processed, two things can * happen. * * 1) The peer's address information is returned in a PEER_COORD * message. Then this is recevied by the p2p code and the * function holepunch_algo() is called with the appropriate * arguments. Then once the holepunching finishes or fails, * control is returned back to the user. * 2) The ID given is wrong and hence no matching peer could * be found, so we have to return to the user saying that * he has to try again with the right ID. * */ m.op = GET_PEER; m_st.peerpl.id = conn->peerid; do { ret = send(conn->ctx->tcpsock,(char *)&m,sizeof(m),0); } while(eblock()); if(ret == 0 || ret == -1) { perror("Send"); } return 0; } /* The UDP hole punching algorithm * * It is a very simple algorithm. How it works is, first it sends UDP * packets to five different hosts from the same port number to the same * port number. The last request is sent to the actual peer with which * we want to communicate. * * The peer's NAT drops the packet since it was an unsolicited packet. * At the same time the peer also sends these five packets. So this * packet arrives at our NAT device but our NAT lets it in since * we first sent out the packet to the same host and port... * * We are interested in finding out the port number * allocated to all these requests at the NAT device. * * In case we find that all these numbers match then we are happy and * happily return the UDP socket to the user. * The way we figure out the port number allocated at the NAT device is * by sending the NAT device's source port number in the body of the * response to the packets sent above. * * The real fun starts when there is a difference between the port * numbers allocated in the NAT device for the two requests. * In this case we find out the delta, the difference between these two * numbers and the algorithm assumes that the delta will be constant * under favourable circumstances. * * Now this is only half the story. Determining the source port is * important but it is not everything. In the next step, the peer sends * a packet to the same port number. Once the peers are able * to communicate using the peer's port number and NAT IP, then we * hand over control pack to the p2p app. * * There is another twist to the algo. In case both peers are behind * the same NAT device and in the same network, then they can * communicate directly without UDP hole punching. * This is attempted first. Only when this approach doesn't succeed when * we go in for hole punching. * */ int holepunch_algo(struct connection *conn,struct sockaddr_in *privpeer,struct sockaddr_in *pubpeer,int direction) { struct sockaddr_in sinudp1,tmpsin; uint16_t tpport = 9856,ourport = 17000; struct request rq; struct timeval t; int udp1,udprecv; fd_set rfds,wfds; int ret,diff,diff2,consistent = 0,linkdown = 0; int i = 0,first,third,fds,selret; #ifdef WIN32 WSADATA wsaData; if (WSAStartup(MAKEWORD(2, 2), &wsaData) != 0) perrdie("Windows sockets 2.2 startup"); { syslog(LOG_INFO, "Using %s (Status: %s)\n", wsaData.szDescription, wsaData.szSystemStatus); syslog(LOG_INFO, "with API versions %d.%d to %d.%d\n\n", LOBYTE(wsaData.wVersion), HIBYTE(wsaData.wVersion), LOBYTE(wsaData.wHighVersion), HIBYTE(wsaData.wHighVersion)); } #endif udp1 = mksock(SOCK_DGRAM); setreuse(udp1); /* Lookup the mediators */ lookup(SERV1, &sa[0],tpport); lookup(SERV2, &sa[1],tpport); lookup(SERV3, &sa[2],ourport); lookup(SERV4, &sa[3],ourport); sinudp1.sin_family = AF_INET; sinudp1.sin_addr.s_addr = INADDR_ANY; sinudp1.sin_port = htons(tpport); if (bind(udp1, (struct sockaddr*)&sinudp1, sizeof(sinudp1)) < 0){ perrdie("Bind 9856 UDP port"); syslog(LOG_ERR,"Problem binding to UDP port 9856"); } /* Clear the variables in which we collect * our various NATted public addresses * as we discover them. */ tmpsin.sin_family = AF_INET; tmpsin.sin_addr.s_addr = INADDR_ANY; tmpsin.sin_port = 0; if((privpeer != NULL) && (pubpeer != NULL) && direction == OUTBOUND) { /* We are NOT connecting for the first time */ udprecv = conn->ctx->clientsock; } else { udprecv = conn->ctx->udpsock; } for(i=0;i<4;i++) myu[i] = tmpsin; /* Send ping datagrams from our primary UDP socket to servers 1 and 2. */ rq.magic = htonl(REQMAGIC); syslog(LOG_INFO,"Proceeding to punch hole"); for(i=0;i<4;i++) { int sock; if(i == 0 || i == 1) sock = udp1; else sock = conn->ctx->udpsock; if (sendto(sock, (const char*)&rq, sizeof(rq), 0, (struct sockaddr*)&sa[i], sizeof(sa[i])) < 0) { syslog(LOG_ERR,"Problem sending to %s:%d",inet_ntoa(sa[i].sin_addr),ntohs(sa[i].sin_port)); perrdie("sendto"); } } first = 0, third = 0; for(;;) { fds = 0; FD_ZERO(&rfds); FD_ZERO(&wfds); if(first != 2) { FD_SET(udp1,&rfds); FD_SET(udp1,&wfds); fds = udp1 + 1; } if(third != 2) { FD_SET(udprecv,&rfds); FD_SET(udprecv,&wfds); fds = udprecv + 1 > fds ? udprecv + 1 : fds; } /* Right now we just assume that 4 seconds * timeout is enough for most practical purposes */ t.tv_sec = 6; t.tv_usec = 0; if(fds == 0) /* We are done */ break; ret = select(fds,&rfds,NULL,NULL,&t); if(ret == -1) { perror("Select"); syslog(LOG_ERR,"Select() failed,Yuck!"); } if(ret == 0) { linkdown = 1; syslog(LOG_ERR,"Didn't get reply from UDP bounce server(s)"); break; } else { if(FD_ISSET(udp1,&rfds)) { if(first == 0) { recvudp(udp1,&myu[0],NULL,conn); first = 1; } else { recvudp(udp1,&myu[1],NULL,conn); first = 2; close(udp1); } } if(FD_ISSET(udprecv,&rfds)) { if(third == 0) { recvudp(udprecv,&myu[2],NULL,conn); third = 1; } else { recvudp(udprecv,&myu[3],NULL,conn); third = 2; } } } } close(udp1); /* We are unable to contact any mediation servers possibly * because Internet is down. But still we run the hole * punching code to reach the peer. And then * declare the hole punching failed */ if(linkdown) { close(conn->ctx->udpsock); return LINK_DOWN; } /* Check for public address/port number consistency */ if (myu[0].sin_addr.s_addr == myu[1].sin_addr.s_addr && myu[0].sin_port == myu[1].sin_port) { if (myu[2].sin_addr.s_addr == myu[3].sin_addr.s_addr && myu[3].sin_port == myu[3].sin_port) { if((myu[0].sin_port != 0) || (myu[3].sin_port != 0)) { consistent = 1; syslog(LOG_INFO,"We do consistent UDP translation, that is good news"); } } } else { diff = abs(ntohs(myu[1].sin_port) - ntohs(myu[0].sin_port)); diff2 = abs(ntohs(myu[3].sin_port) - ntohs(myu[2].sin_port)); } if((privpeer != NULL) && (pubpeer != NULL)) { /* Now send packets to both the private and the public * addreses of the peer*/ ret = sendto(conn->ctx->udpsock, (const char *)&rq, sizeof(rq), 0, (struct sockaddr *)privpeer, sizeof(*privpeer)); if(ret == -1) { perrdie("Hole punch to private address sendto"); } ret = sendto(conn->ctx->udpsock, sizeof(rq), 0, (struct sockaddr *)pubpeer, sizeof(*pubpeer)); if(ret == -1) { perrdie("Hole punch to public address sendto"); } /* Right now we just assume that 4 seconds * timeout is enough for most practical purposes */ do { t.tv_sec = 4; t.tv_usec = 0; FD_ZERO(&rfds); FD_SET(udprecv,&rfds); fds = udprecv + 1; selret = select(fds,&rfds,NULL,NULL,&t); if(selret == -1) { perror("Select"); syslog(LOG_ERR,"Select() failed,Yuck!"); } if(selret == 0) { syslog(LOG_ERR,"Didn't get reply from holepunching the peer"); ret = -1; break; } ret = recvudp(udprecv,privpeer,pubpeer,conn); }while(0); } else { /* we are connecting for the first time */ syslog(LOG_INFO,"Proceeding to return after first time invocation of holepunching"); conn->ctx->mypub = myu[3]; if(!consistent && (diff == diff2)) { uint16_t tmp; tmp = ntohs(myu[3].sin_port); tmp += 2*diff; conn->ctx->mypub.sin_port = htons(tmp); } return 0; } if(ret == 0) { /* The public address is hole punched */ struct msg m; int n; syslog(LOG_INFO,"The peer's public address is responding"); conn->peer = *pubpeer; conn->ctx->mypub = myu[3]; m.op = HOLEPUNCHING_COMPLETE; m_st.peerpl.id = conn->peerid; do { n = send(conn->ctx->tcpsock,&m,sizeof(m),0); }while(eblock()); } else if (ret == 1) { /* The private address is hole punched */ struct msg m; int n; syslog(LOG_INFO,"The peer's private address is responding"); conn->peer = *privpeer; conn->ctx->mypub = myu[3]; m.op = HOLEPUNCHING_COMPLETE; m_st.peerpl.id = conn->peerid; do { n = send(conn->ctx->tcpsock,&m,sizeof(m),0); }while(eblock()); } else if(ret == -1) { /* Good, no response :-) */ if(consistent) { /* no problem, we only have to ask * the peer to send a datagram and * then we are set */ syslog(LOG_INFO,"No response but consistent translation"); conn->ctx->mypub = myu[3]; conn->peer = *pubpeer; peer_holepunch(conn); } else { if(diff == diff2) { syslog(LOG_INFO,"I get the same delta during translation, this may WORK"); uint16_t tmp; conn->peer = *pubpeer; conn->ctx->mypub = myu[3]; tmp = ntohs(myu[3].sin_port); tmp += 2*diff; conn->ctx->mypub.sin_port = htons(tmp); peer_holepunch(conn); } else { /* Hard luck, we have to give up :-( */ close(conn->ctx->udpsock); } } } return 0; } 9004l3.txt0100664000175300003300000004413610440071022011436 0ustar jillljeditListing 3. p2p Client /* Copyright Girish Venkatachalam 2006 * girish1729@gmail.com * * You are free to modify it to suit your requirements. * The licensing terms of this program is along the lines * of the BSD license. You are free to use this for commercial * purposes provide you retain this notice. * * * */ #include "p2pcommon.h" int registermediator(struct context *ctx) { int n; struct msg m; struct sockaddr_in mypriv; m.op = REGISTER; m_st.rpl.id = htonl(getmyid()); mypriv.sin_port = htons(17000); mypriv.sin_addr = getprivip(); syslog(LOG_INFO,"My private address is %s:%d",inet_ntoa(mypriv.sin_addr),ntohs(mypriv.sin_port)); m_st.rpl.priv = mypriv; m_st.rpl.pub = ctx->mypub; ctx->mypriv = mypriv; do { n = send(ctx->tcpsock,(char *)&m,sizeof(m),0); }while(eblock()); if(n == 0 || n == -1) { syslog(LOG_ERR,"Couldn't send registration message.. Exiting"); exit(128); } n = recv(ctx->tcpsock,(char *)&m,sizeof(m),0); if(n == 0 || n == -1) { syslog(LOG_ERR,"Couldn't recv registration result.. Exiting"); exit(128); } if(m.op == REGISTRATION_COMPLETED) { syslog(LOG_INFO,"Successfully registered with mediator,id=%d",getmyid()); } else { syslog(LOG_ERR,"Duplicate ID, can't register.. exiting"); exit(128); } return 0; } int hdl_clreqib(struct context *ctx,struct req_payload *st) { int ret; struct connection *conn = (struct connection *)malloc(sizeof(struct connection)); conn->ctx = ctx; st->my.priv.sin_family = AF_INET; st->my.pub.sin_family = AF_INET; ret = holepunch_algo(conn,&st->my.priv,&st->my.pub,INBOUND); if(conn) { free(conn); } return 0; } int hdl_punchhole(int serversock,struct peercoord_payload *st) { struct sockaddr_in p2p; socklen_t l; p2p.sin_family = PF_INET; p2p.sin_port = htons(15001); inet_aton("127.0.0.1",&p2p.sin_addr); l = sizeof(p2p); st->pub.sin_family = AF_INET; st->priv.sin_family = AF_INET; sendto(serversock,st,sizeof(*st),0,(struct sockaddr *)&p2p,l); return 0; } int peer_holepunch(struct connection *conn) { struct msg m; int ret; m.op = NEW_CLIENT_REQ_OUTBOUND; m_st.reqpl.my.pub = conn->ctx->mypub; m_st.reqpl.my.priv = conn->ctx->mypriv; m_st.reqpl.peer.id = conn->peerid; do { ret = send(conn->ctx->tcpsock,(char *)&m,sizeof(m),0); }while(eblock()); if(ret == 0 || ret == -1) { syslog(LOG_ERR,"Send() problem with mediator.. Exiting"); exit(128); } return 0; } int hdl_wrongid(int serversock) { struct sockaddr_in p2p; struct peercoord_payload pl; socklen_t l; p2p.sin_family = PF_INET; p2p.sin_port = htons(15001); inet_aton("127.0.0.1",&p2p.sin_addr); l = sizeof(p2p); pl.id = 0; sendto(serversock,&pl,sizeof(pl),0,(struct sockaddr *)&p2p,l); return 0; } int hdl_hpend(int serversock) { struct msg m; struct sockaddr_in p2p; socklen_t l; p2p.sin_family = PF_INET; p2p.sin_port = htons(15001); inet_aton("127.0.0.1",&p2p.sin_addr); l = sizeof(p2p); m.op = HOLEPUNCH_COMPLETED; sendto(serversock,&m,sizeof(m),0,(struct sockaddr *)&p2p,l); return 0; } /* This is the body of the client loop. * */ int servemediator(int sock,int serversock,struct context *ctx) { int b; struct msg m; b = recv(sock,(void *)&m,sizeof(m),0); if( b == -1 || b == 0) { perror("Recv() error from mediator.. Exiting"); close(sock); exit(128); } switch(m.op) { case NEW_CLIENT_REQ_INBOUND: syslog(LOG_INFO,"New client inbound holepunch req payload"); hdl_clreqib(ctx,&m_st.reqpl); break; case PEER_COORD: syslog(LOG_INFO,"Peer coord payload to initiate hole punching"); hdl_punchhole(serversock,&m_st.peerpl); break; case PEERID_WRONG: syslog(LOG_INFO,"Wrong peer ID holepunch request"); hdl_wrongid(serversock); break; case HOLEPUNCH_COMPLETED: syslog(LOG_INFO,"*********** Holepunching complete *********"); break; default: syslog(LOG_ERR,"Garbled message from mediator , m.op = %d",m.op); } return 0; } int doecho(int udpsock,char *buf,int len,struct sockaddr_in *tsin) { /* Just bounce it back baby :-) */ /* But send the ack first */ struct request rq; char mybuf[4096]; char c; if(!dataintegrity(buf,len-20,CHECK_INTEGRITY)) { c = 1; } else c = 2; sendto(udpsock,&c,1,0,(struct sockaddr *)tsin,sizeof(*tsin)); memcpy(mybuf,buf+sizeof(rq),len-20-sizeof(rq)); /* Now whatever is in mybuf is the payload sent by peer */ sendreply(udpsock,buf+sizeof(rq),len-20-sizeof(rq),tsin); return 0; } void serveudp(int udpsock,int serversock) { struct sockaddr_in tsin; socklen_t sinlen; unsigned char buf[4096]; struct request rq; struct reply rp; int rc; sinlen = sizeof(tsin); rc = recvfrom(udpsock, buf, sizeof(buf), 0, (struct sockaddr*)&tsin, &sinlen); rq = *(struct request *)buf; if((rc == sizeof(rq)) && ( rq.magic == htonl(REQMAGIC) ) ) { /* This is definitely a UDP bounce request */ /* Build the reply and send it to the client */ rp.magic = htonl(REPLMAGIC); rp.pubaddr = tsin.sin_addr; rp.pubport = tsin.sin_port; if (sendto(udpsock, &rp, sizeof(rp), 0, (struct sockaddr*)&tsin, sizeof(tsin)) < 0) { syslog(LOG_ERR,"Problem sending on udpsock to %s:%d",inet_ntoa(tsin.sin_addr),ntohs(tsin.sin_port)); perror("sendto"); } syslog(LOG_INFO, "UDP bounce request from %s:%d\n", inet_ntoa(tsin.sin_addr), ntohs(tsin.sin_port)); } else { struct sockaddr_in p2p; socklen_t l; struct p2p_payload payload; p2p.sin_family = PF_INET; p2p.sin_port = htons(15001); inet_aton("127.0.0.1",&p2p.sin_addr); l = sizeof(p2p); if(rq.magic == htonl(SERVMAGIC)) { /* XXX act as p2p server */ /* This is a dummy function just for testing * purposes, to be replaced with actual p2p *server code */ doecho(udpsock,buf,rc,&tsin); syslog(LOG_INFO, "p2p Server UDP request from %s:%d\n", inet_ntoa(tsin.sin_addr), ntohs(tsin.sin_port)); } else { /* If code reaches here , we are damn sure it is a * response to a client request packet */ if( (rq.magic == htonl(REPLMAGIC)) || rc == 1) { /* We have got a UDP bounce reply, * as part of hole punching, what * we have to do is bounce it to * our local socket * or else it is an ack packet */ sendto(serversock,buf,rc,0,(struct sockaddr *)&p2p,l); } else { /* Fill the payload to send for p2p * protocol backend */ payload.peer = tsin; memcpy(payload.buf,buf,rc); payload.len = rc; sendto(serversock,&payload,sizeof(payload),0,(struct sockaddr *)&p2p,l); syslog(LOG_INFO, "Response to p2p client request from %s:%d\n", inet_ntoa(tsin.sin_addr), ntohs(tsin.sin_port)); } } } } struct context *initializep2p() { struct sockaddr_in sintcp,sinudp,udplocal; socklen_t sinlen; struct context *ctx; struct connection *conn; fd_set rfds,wfds; int udpsock,tcpsock,serversock; int ret,on = 1,fds; uint16_t servport1 = 1234,servport2 = 80; #ifdef WIN32 WSADATA wsaData; if (WSAStartup(MAKEWORD(2, 2), &wsaData) != 0) perrdie("Windows sockets 2.2 startup"); { syslog(LOG_INFO, "Using %s (Status: %s)\n", wsaData.szDescription, wsaData.szSystemStatus); syslog(LOG_INFO, "with API versions %d.%d to %d.%d\n\n", LOBYTE(wsaData.wVersion), HIBYTE(wsaData.wVersion), LOBYTE(wsaData.wHighVersion), HIBYTE(wsaData.wHighVersion)); } #endif /* XXX Make this work on Windoze */ openlog("vembu-p2p",LOG_PERROR | LOG_CONS | LOG_PID,LOG_LOCAL2); syslog(LOG_INFO,"Starting p2p ...."); ctx = (struct context *)malloc(sizeof(struct context)); lookup(MEDIATOR, &sintcp,servport1); tcpsock = mksock(SOCK_STREAM); sinlen = sizeof(sintcp); setsockopt(tcpsock,SOL_SOCKET,SO_KEEPALIVE,&on,sizeof(on)); serversock = socket(PF_INET,SOCK_DGRAM,0); sinudp.sin_family = PF_INET; sinudp.sin_port = htons(15000); sinudp.sin_addr.s_addr = INADDR_ANY; if(bind(serversock,(struct sockaddr *)&sinudp,sizeof(sinudp)) == -1) { syslog(LOG_ERR,"Coulnd't bind UDP loopback socket .. dying"); exit(128); } ctx->clientsock = socket(AF_INET,SOCK_DGRAM,0); udplocal.sin_family = PF_INET; udplocal.sin_port = htons(15001); udplocal.sin_addr.s_addr = INADDR_ANY; if(bind(ctx->clientsock,(struct sockaddr *)&udplocal,sizeof(udplocal)) != 0) { syslog(LOG_ERR,"Loopback UDP bind problem"); } udpsock = socket(AF_INET,SOCK_DGRAM,0); sinudp.sin_family = PF_INET; sinudp.sin_port = htons(17000); sinudp.sin_addr.s_addr = INADDR_ANY; if(bind(udpsock,(struct sockaddr *)&sinudp,sizeof(sinudp)) == -1) { syslog(LOG_ERR,"Coulnd't bind p2p UDP socket .. dying"); exit(128); } ret = connect(tcpsock,(struct sockaddr *)&sintcp,sinlen); if(ret != 0) { perrdie("Mediator port 1234 connect"); syslog(LOG_INFO,"Trying port 80"); sintcp.sin_port = htons(servport2); ret = connect(tcpsock,(struct sockaddr *)&sintcp,sinlen); if(ret != 0) { syslog(LOG_ERR,"Too bad, we coulnd't connect to mediator,dying..."); exit(128); } } syslog(LOG_INFO,"Successfully connected to mediator"); /* Good, now that we are connected let us first register */ /* But hey before we register we have to punch a hole :-) */ conn = (struct connection *)malloc (sizeof(struct connection)); conn->peerid = 0; conn->ctx = ctx; conn->ctx->tcpsock = tcpsock; conn->ctx->udpsock = udpsock; ret = holepunch(conn); if(ret == LINK_DOWN) { syslog(LOG_ERR,"My probes are not going through, kindly restart the daemon after you fix your network problem.. Exiting"); exit(128); } registermediator(ctx); /* Now we have to fork into a separate process */ /* XXX do something like fork() for Windoze ... */ if ( fork() != 0) { return ctx; } fds = udpsock > tcpsock ? udpsock + 1 : tcpsock + 1; for(;;) { FD_ZERO(&rfds); FD_ZERO(&wfds); FD_SET(udpsock,&rfds); FD_SET(udpsock,&wfds); FD_SET(tcpsock,&rfds); FD_SET(tcpsock,&wfds); select(fds,&rfds,NULL,NULL,NULL); if(FD_ISSET(udpsock,&rfds)) { serveudp(udpsock,serversock); } if(FD_ISSET(tcpsock,&rfds)) { servemediator(tcpsock,serversock,ctx); } } return 0; } /* Now our user API functions */ struct connection *connectpeer(struct context *ctx,uint32_t peerid) { struct sockaddr_in peer; struct connection *conn; struct peercoord_payload st; socklen_t l = sizeof(peer); conn = (struct connection *)malloc(sizeof(struct connection)); conn->ctx = ctx; conn->peerid = htonl(peerid); holepunch(conn); recvfrom(conn->ctx->clientsock,&st,sizeof(st),0,(struct sockaddr *)&peer,&l); if(st.id == 0) /* Wrong peer id passed */ { return NULL; } holepunch_algo(conn,&st.priv,&st.pub,OUTBOUND); return conn; } int sendrequest(struct connection *conn,char *buf,int len) { int ret ; char c; struct sockaddr_in peer; struct request rq; unsigned char mybuf[4096]; socklen_t l = sizeof(conn->peer); rq.magic = htonl(SERVMAGIC); memcpy(mybuf,&rq,sizeof(rq)); memcpy(mybuf+sizeof(rq),buf,len); dataintegrity(mybuf,len+sizeof(rq),ADD_INTEGRITY); ret = sendto(conn->ctx->udpsock,mybuf,len+sizeof(rq)+20,0,(struct sockaddr *)&conn->peer,l); if(ret == 0 || ret == -1) { perror("p2p Send"); syslog(LOG_ERR,"Problem sending p2p protocol data to peer"); } /* Check whether the data reached safely */ ret = recvfrom(conn->ctx->clientsock,&c,1,0,(struct sockaddr *)&peer,&l); if(c == 1) return 0; else return -1; /* Data integrity failed */ } int sendreply(int udpsock,char *buf,int len,struct sockaddr_in *tsin) { int ret ; char c; struct sockaddr_in peer; struct request rq; unsigned char mybuf[4096]; socklen_t l = sizeof(peer); rq.magic = htonl(CLIMAGIC); memcpy(mybuf,&rq,sizeof(rq)); memcpy(mybuf+sizeof(rq),buf,len); dataintegrity(mybuf,len+sizeof(rq),ADD_INTEGRITY); ret = sendto(udpsock,mybuf,len+sizeof(rq)+20,0,(struct sockaddr *)tsin,sizeof(*tsin)); if(ret == 0 || ret == -1) { perror("p2p Send"); syslog(LOG_ERR,"Problem sending p2p protocol data to peer"); } /* Check whether the data reached safely */ ret = recvfrom(udpsock,&c,1,0,(struct sockaddr *)&peer,&l); if(c == 1) return 0; else return -1; /* Data integrity failed */ } int receivepeer(struct connection *conn,char *buf,int *len) { struct p2p_payload payload; struct sockaddr_in local; struct request rq; char c; socklen_t l = sizeof(local); recvfrom(conn->ctx->clientsock,&payload,sizeof(payload),0,(struct sockaddr *)&local,&l); *len = payload.len-20-sizeof(rq); if(conn->peer.sin_addr.s_addr == payload.peer.sin_addr.s_addr) { if(!dataintegrity(payload.buf,payload.len-20,CHECK_INTEGRITY)) { memcpy(buf,payload.buf+sizeof(rq),*len); c = 1; /* Sending ACK packet */ sendto(conn->ctx->udpsock,&c,1,0,(struct sockaddr *)&conn->peer,l); return 0; } else { c = 2; /* Sending NACK packet */ sendto(conn->ctx->udpsock,&c,1,0,(struct sockaddr *)&conn->peer,l); return -1; /* Our integrity check failed */ } } return -1; } int closepeer(struct connection *conn) { if(conn) { free(conn); } conn = NULL; return 0; } Now an example application using this library. #include "p2pcommon.h" int main () { struct context *ctx = NULL; struct connection *conn = NULL; char buf[1024],output[1024]; int len,ret = -1; ctx = initializep2p(); conn = connectpeer(ctx,12345678); if(conn == NULL) { printf("Wrong ID passed or peer offline.. exiting\n"); close(ctx->tcpsock); exit(128); } strcpy(buf,"God is great!"); len = strlen(buf); ret = sendrequest(conn,buf,len); if(ret != 0) { printf("Reliable UDP sending failed, have to try again\n"); exit(128); } ret = receivepeer(conn,output,&len); if(ret != 0) { printf("Reliable UDP reception failed\n"); exit(128); } printf("I received %d bytes from peer\n",len); printf("Data received is [%s]\n",output); closepeer(conn); /* Good, if the program did not crash,then memory has * been freed successfully and there has not been any * memory corruption */ return 0; }