/*---------------------------------------------------------------
Author:  HJY
Func:  To provide a udp data pipe from LAN to the internet bypassing the 
  annoying firewall.(udp port redirect).
  It can be used to play OICQ behind firewall.
Email:  hujiaying@263.net
Note:  Want to use the tcp data pipe(tcp port redirect)?Refer to datapipe.c
---------------------------------------------------------------*/
#include <sys/socket.h>
#include <linux/socket.h>
#include <netinet/in.h>
#include <signal.h>
#include <errno.h>
#include <string.h>
#include <netdb.h>

#define max(a,b) (((a)>(b))?(a):(b))

typedef void Sigfunc (int);
int sd1,sd2;
void dispose(int signo);
int Socket(int family, int type, int protocol);
void Bind(int fd, const struct sockaddr *sa, socklen_t salen);
void fillsock(struct sockaddr_in *addr,char *ip,char *port);
char *Sock_ntop(struct sockaddr *cliaddr,int len);
Sigfunc *Signal(int signo, Sigfunc *func);
int Select(int nfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds,
           struct timeval *timeout);
ssize_t Recvfrom(int fd, void *ptr, size_t nbytes, int flags,
                 struct sockaddr *sa, socklen_t *salenptr);
void Sendto(int fd, const void *ptr, size_t nbytes, int flags,
           const struct sockaddr *sa, socklen_t salen);
u_int32_t domain2ip_n(const char *domain);
int service2port(const char *service);

main(int argc,char **argv)
{
  char msg_detail[4096];
  char msg[4096];
  int maxfd1,len,n;
  struct sockaddr_in addr1,addr2;
  struct sockaddr cliaddr;
  fd_set fdsr,fdse;

  if(argc!=4)
  {
    printf("Usage: %s localport remoteport remotehost\n",argv[0]);
    return;
  }
  sd1=Socket(AF_INET,SOCK_DGRAM,0);
  fillsock(&addr1,INADDR_ANY,argv[1]);
  Bind(sd1,(struct sockaddr *)&addr1,sizeof(addr1));
  fillsock(&addr2,argv[3],argv[2]);
  sd2=Socket(AF_INET,SOCK_DGRAM,0);
  Signal(SIGINT,dispose);
  for(;;)
  {
    FD_ZERO(&fdsr);
    FD_ZERO(&fdse);
    FD_SET(sd1,&fdsr);
    FD_SET(sd2,&fdsr);
    FD_SET(sd1,&fdse);
    FD_SET(sd2,&fdse);
    maxfd1=max(sd1,sd2)+1;
    Select(maxfd1,&fdsr,NULL,&fdse,NULL);
    if(FD_ISSET(sd1,&fdsr)||FD_ISSET(sd1,&fdse))
    {
      len=sizeof(cliaddr);
      memset(msg,0,sizeof(msg));
      n=Recvfrom(sd1,msg,4096,0,&cliaddr,&len);
      printf("from client[%s]\n",
        Sock_ntop(&cliaddr,sizeof(cliaddr)));
      memset(msg_detail,0,sizeof(msg_detail));
      sprintf(msg_detail,"->[%s]\n",msg);
      Sendto(sd2,msg,n,0,(struct sockaddr *)&addr2,
        sizeof(addr2));
    }
    else if(FD_ISSET(sd2,&fdsr)||FD_ISSET(sd2,&fdse))
    {
      printf("from server\n");
      len=sizeof(addr2);
      memset(msg,0,sizeof(msg));
      n=Recvfrom(sd2,msg,4096,0,NULL,NULL);
      memset(msg_detail,0,sizeof(msg_detail));
      sprintf(msg_detail,"<-[%s]\n",msg);
      Sendto(sd1,msg,n,0,&cliaddr,sizeof(cliaddr));
    }
  }
}

void dispose(int signo)
{
  close(sd1);
  close(sd2);
}

int Socket(int family, int type, int protocol)
{
        int             n;

        if ( (n = socket(family, type, protocol)) < 0)
  {
                printf("socket error");
    exit(0);
  }
        return(n);
}

void Bind(int fd, const struct sockaddr *sa, socklen_t salen)
{
        if (bind(fd, sa, salen) < 0)
  {
                printf("bind error");
    exit(0);
  }
}

void fillsock(struct sockaddr_in *addr,char *ip,char *port)
{
        u_int32_t ip_n;
        int port_no;
        addr->sin_family=AF_INET;

        bzero(addr,sizeof(addr));
        if(ip==NULL||(!strcmp(ip,"0")))
                addr->sin_addr.s_addr=htonl(INADDR_ANY);
        else
        {
                if(inet_pton(AF_INET,ip,&addr->sin_addr)==0)
                {
                        ip_n=domain2ip_n(ip);
                        memcpy(&addr->sin_addr.s_addr,&ip_n,4);
                }
        }
        if(isdigit(port[0]))
                port_no=atoi(port);
        else
                port_no=service2port(port);
        addr->sin_port=htons(port_no);
}

char *Sock_ntop(struct sockaddr *cliaddr,int len)//sockaddr->ip:port
{
        struct sockaddr_in cli;
        char ip[100];
        int port;
        static char str[4096];

        memcpy(&cli,cliaddr,sizeof(cli));
        inet_ntop(AF_INET,&cli.sin_addr,ip,sizeof(ip));
        port=ntohs(cli.sin_port);
        snprintf(str,sizeof(str),"%s:%d",ip,port);
        return str;
}


Sigfunc *
Signal(int signo, Sigfunc *func)        /* for our signal() function */
{
        Sigfunc *sigfunc;

        if ( (sigfunc = signal(signo, func)) == SIG_ERR)
  {
                printf("signal error");
    exit(0);
  }
        return(sigfunc);
}

int
Select(int nfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds,
       struct timeval *timeout)
{
        int             n;

        if ( (n = select(nfds, readfds, writefds, exceptfds, timeout)) < 0)
  {
                printf("select error");
    exit(0);
  }
        return(n);              /* can return 0 on timeout */
}

ssize_t
Recvfrom(int fd, void *ptr, size_t nbytes, int flags,
                 struct sockaddr *sa, socklen_t *salenptr)
{
        ssize_t         n;

        if ( (n = recvfrom(fd, ptr, nbytes, flags, sa, salenptr)) < 0)
  {
                printf("recvfrom error");
          exit(0);
  }
  return(n);
}

void
Sendto(int fd, const void *ptr, size_t nbytes, int flags,
           const struct sockaddr *sa, socklen_t salen)
{
        if (sendto(fd, ptr, nbytes, flags, sa, salen) != nbytes)
  {
                printf("sendto error");
    exit(0);
  }
}

u_int32_t domain2ip_n(const char *domain)       //return network order(binary)
{
        static u_int32_t ip_n;
        struct hostent *ht;

        if((ht=gethostbyname(domain))==NULL)
  {
                printf("gethostbyname() error for host:%s:%s",domain,
                        hstrerror(h_errno));
    exit(0);
  }
        memcpy(&ip_n,ht->h_addr,4);
        return ip_n;
}

int service2port(const char *service)
{
        static int port;
        struct servent *sv;

        if((port=atoi(service))==0)
        {
                if((sv=getservbyname(service,NULL))==NULL)
    {
                        printf("getservbyname() error for %s\n",port);
      exit(0);
    }
                port=ntohs(sv->s_port);
        }
        return port;
}