home *** CD-ROM | disk | FTP | other *** search
/ Hackers Toolkit 2.0 / Hackers_Toolkit_v2.0.iso / HTML / archive / Unix / c-src / a.c next >
Encoding:
C/C++ Source or Header  |  1999-11-04  |  8.8 KB  |  269 lines
  1. /* piped.c   PiPELiNE       v0.3a                            */
  2. /* by BlindPoet (Tiago Rodrigues)                            */
  3. /*                                                           */
  4. /*  7/4/97 ->  Dataflow logged to 'slog'                     */
  5. /*  8/4/97 ->  Commented source & improved logs              */
  6. /*  9/4/97 ->  Logfile is no longer killed upon restart      */
  7. /* 10/4/97 ->  HEADACHE                                      */
  8. /* 11/4/97 ->  Added SpyPort :) Please, try to avoid to use  */
  9. /*                this feature for unethical purposes        */
  10.  
  11. #include <sys/types.h>
  12. #include <sys/socket.h>
  13. #include <sys/wait.h>
  14. #include <netinet/in.h>
  15. #include <stdio.h>
  16. #include <stdlib.h>
  17. #include <errno.h>
  18. #include <unistd.h>
  19. #include <netdb.h>
  20.  
  21. #ifdef linux
  22. #include <linux/time.h>
  23. #elsif
  24. #define STRERROR
  25. #endif
  26.  
  27. #define mysig1 "piped - PiPELiNE v0.3a"
  28. #define mysig2 "by: BlindPoet (Tiago Rodrigues)"
  29.  
  30. #ifdef STRERROR
  31. extern char *sys_errlist[];
  32. extern int sys_nerr;
  33. char *undef = "Undefined error";
  34.  
  35. char *strerror(error)  
  36.   int error;
  37. {
  38.   if (error > sys_nerr)
  39.     return undef;
  40.   return sys_errlist[error];
  41. }
  42. #endif
  43.  
  44. main(argc, argv)
  45.   int argc;
  46.   char **argv;
  47. {
  48.   int lsock, csock, osock; /* lsock=listen / csock=client / osock=outgoing */
  49.   int ssock, dsock;
  50.   FILE *cfile, *p_fich;    /* cfile=client_sock / p_fich = dataflow_log    */
  51.   FILE *dfile;
  52.   char buf[4096];
  53.   int aaa=4096;
  54.   struct sockaddr_in laddr, caddr, oaddr;
  55.   struct sockaddr_in saddr, daddr;
  56.   int caddrlen = sizeof(caddr);             /* &fromlen (accept)           */
  57.   int daddrlen = sizeof(daddr);
  58.   fd_set fdsr, fdse;                        /* file descriptors            */
  59.   struct hostent *h;
  60.   struct servent *s;
  61.   struct hostent *t;
  62.   int nbyt, nbyt2;   
  63.   unsigned long a;
  64.   unsigned short oport;
  65.  
  66.   if (argc < 5) {
  67.     fprintf(stderr,"Usage: %s localport remoteport remotehost spyport\n",argv[0]);
  68.     return 30;
  69.   }
  70.           
  71.   a = inet_addr(argv[3]);                                   /* hostname    */
  72.   if (!(h = gethostbyname(argv[3])) &&
  73.       !(h = gethostbyaddr(&a, 4, AF_INET))) {
  74.     perror(argv[3]);
  75.     return 25;
  76.   }
  77.  
  78.   if ((p_fich = fopen ("slog", "a+")) == NULL)
  79.       {
  80.           printf("PANIC: cannot open log file");
  81.           return -1;
  82.       }  
  83.   
  84.   oport = atol(argv[2]);                                    /* remote port */
  85.   laddr.sin_port = htons((unsigned short)(atol(argv[1])));  /* local port  */
  86.   saddr.sin_port = htons((unsigned short)(atol(argv[4])));  /* spy port    */
  87.   
  88.     if ((ssock = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP)) == -1) {
  89.     perror("socket");                                       /* inet socket */
  90.     return 20;
  91.   }
  92.   
  93.   saddr.sin_family = htons(AF_INET);                        /* domain      */
  94.   saddr.sin_addr.s_addr = htonl(0);
  95.   /* bind(s, name, namelen)                                                */
  96.   if (bind(ssock, &saddr, sizeof(saddr))) {                 /* bind        */
  97.     perror("bind");
  98.     return 20;
  99.   }
  100.   /* listen(s, max_num_of_connections);                                    */
  101.   if (listen(ssock, 1)) {                                   /* listen      */
  102.     perror("listen");
  103.     return 20;
  104.   }
  105.   
  106.   if ((nbyt2 = fork()) == -1) {                           
  107.     perror("fork");
  108.     return 20;
  109.   } 
  110.  
  111.   
  112.     if (nbyt2 > 0)
  113.     return 0;
  114.   setsid();
  115.   /* fromlen = sizeof (from);                                              */
  116.   /* newsock = accept(s, (struct sockaddr *)&from, &fromlen);              */
  117.   while ((dsock = accept(ssock, &daddr, &daddrlen)) != -1) {
  118.     dfile = fdopen(dsock,"r+");                             /* open new r+ */
  119. fprintf(p_fich, "|piped| -> Client connecting on spy port...\n");
  120.     if ((nbyt2 = fork()) == -1) {                           /* fork new    */
  121.       fprintf(dfile, "500 fork: %s\n", strerror(errno));
  122.       shutdown(dsock,2);                                    /* end r/w     */
  123.       fclose(dfile);                                        /* discard     */
  124.       continue;
  125.     }
  126.     if (nbyt2 == 0)                                         /* ok?         */
  127.       goto sec;                                      /* yeah..      */
  128.     fclose(dfile);                                          /* nope! close */
  129.     while (waitpid(-1, NULL, WNOHANG) > 0);                 /* kill child? */
  130.   }
  131.  /* return 20; */
  132.   
  133.   
  134.   
  135.   
  136.   
  137.   
  138.   
  139.   
  140.   
  141.   
  142.   
  143.   
  144.   
  145.   
  146.   
  147.   
  148.   
  149.   
  150.   sec:
  151.   
  152.   /* s = socket(domain, type, protocol);                                   */
  153.   if ((lsock = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP)) == -1) {
  154.     perror("socket");                                       /* inet socket */
  155.     return 20;
  156.   }
  157.   
  158.   laddr.sin_family = htons(AF_INET);                        /* domain      */
  159.   laddr.sin_addr.s_addr = htonl(0);
  160.   /* bind(s, name, namelen)                                                */
  161.   if (bind(lsock, &laddr, sizeof(laddr))) {                 /* bind        */
  162.     perror("bind");
  163.     return 20;
  164.   }
  165.   /* listen(s, max_num_of_connections);                                    */
  166.   if (listen(lsock, 1)) {                                   /* listen      */
  167.     perror("listen");
  168.     return 20;
  169.   }
  170. /* */  if ((nbyt = fork()) == -1) {
  171.     perror("fork");
  172.     return 20;
  173.   }
  174.  
  175.   if (nbyt > 0)
  176.     return 0;
  177.   setsid();
  178.   /* fromlen = sizeof (from);                                              */
  179.   /* newsock = accept(s, (struct sockaddr *)&from, &fromlen);              */
  180.   while ((csock = accept(lsock, &caddr, &caddrlen)) != -1) {
  181.     cfile = fdopen(csock,"r+");                             /* open new r+ */
  182. fprintf(p_fich, "|piped| -> Client connecting...\n");
  183.     if ((nbyt = fork()) == -1) {                            /* fork new    */
  184.       fprintf(cfile, "500 fork: %s\n", strerror(errno));
  185.       shutdown(csock,2);                                    /* end r/w     */
  186.       fclose(cfile);                                        /* discard     */
  187.       continue;
  188.     }
  189.     if (nbyt == 0)                                          /* ok?         */
  190.       goto gotsock;                                         /* yeah..      */
  191.     fclose(cfile);                                          /* nope! close */
  192.     while (waitpid(-1, NULL, WNOHANG) > 0);                 /* kill child? */
  193.   }
  194.   return 20;
  195.  
  196.  gotsock:
  197.   if ((osock = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP)) == -1) {
  198.     fprintf(cfile, "500 socket: %s\n", strerror(errno));     /* rmote sock */
  199.     goto quit1;
  200.   }
  201.   oaddr.sin_family = h->h_addrtype;
  202.   oaddr.sin_port = htons(oport);
  203.   memcpy(&oaddr.sin_addr, h->h_addr, h->h_length);
  204.   
  205.  /* fprintf(p_fich, "|piped| -> Client connection from...: %s \n", caddr.sin_addr); */
  206.   
  207.   /* connect(s, (struct sockaddr *)&server, sizeof (server));              */
  208.   if (connect(osock, &oaddr, sizeof(oaddr))) {               /* connect to */
  209.     fprintf(cfile, "500 connect: %s\n", strerror(errno));    /* rmote sock */
  210.     goto quit1;
  211.   }
  212.   while (1) {
  213.     FD_ZERO(&fdsr);                 /* zero file descriptors before use    */
  214.     FD_ZERO(&fdse);
  215.     FD_SET(csock,&fdsr);            /* set fd masks                        */
  216.     FD_SET(csock,&fdse);
  217.     FD_SET(osock,&fdsr);
  218.     FD_SET(osock,&fdse);
  219.     /* I/O multiplexing                                                    */
  220.     /* nfds=range of file descriptors                                      */
  221.     /* select(nfds, &readmask, &writemask, &exceptmask, &timeout);         */
  222.     if (select(20, &fdsr, NULL, &fdse, NULL) == -1) {
  223.       fprintf(cfile, "500 select: %s\n", strerror(errno));
  224.       goto quit2;
  225.     }
  226.     if (FD_ISSET(csock,&fdsr) || FD_ISSET(csock,&fdse)) {
  227.       if ((nbyt = read(csock,buf,aaa)) <= 0)                 /* read clnt  */
  228.     goto quit2;
  229.     
  230.     fwrite(buf, sizeof(char), nbyt, p_fich);              /* write log  */
  231.     fflush(p_fich);
  232.         
  233.       /* write(s, buf, sizeof (buf)); */
  234.       /* read(s, buf, sizeof (buf));  */    
  235.       if ((write(osock,buf,nbyt)) <= 0)                      /* write remt */
  236.     goto quit2;
  237.     } else if (FD_ISSET(osock,&fdsr) || FD_ISSET(osock,&fdse)) {
  238.       if ((nbyt = read(osock,buf,aaa)) <= 0)                 /* read remt  */
  239.     goto quit2;
  240.     
  241.     fwrite(buf, sizeof(char), nbyt, p_fich);              /* write log  */
  242.     fflush(p_fich);    
  243.         
  244.       if ((write(dsock,buf,nbyt)) <= 0)
  245.         printf("Unable to write on spy socket...");        
  246.       if ((write(csock,buf,nbyt)) <= 0)                      /* write clnt */
  247.     goto quit2;
  248.     }
  249.   }
  250.  
  251.  
  252.  
  253.  quit2:
  254.   shutdown(osock,2);        /* no more r/w on sock      */
  255.   close(osock);             /* discard remote sock      */
  256.  quit1:
  257.   fflush(cfile);            /* flush sock               */
  258.   shutdown(csock,2);        /* no more r/w on sock      */
  259.  quit0:
  260.   fclose(cfile);            /* discard client sock      */
  261.   
  262.  fprintf(p_fich, "|piped| -> Closing connection...\n");
  263.   
  264.  fflush (p_fich);           /* flush dataflow log file  */
  265.  fclose (p_fich);           /* close dataflow log file  */
  266.   
  267.   return 0;                 /* the_end :)               */
  268. }
  269.