!752

static S vmArgs = "-XX:+PrintGC -Xmx32m";

static int port = 80;
static S forwardServer =
  //"ai1.lol";
  //"google.de";
  "localhost";

static Map<S, Integer> forwardMap = litmap(
  "thedevchannel.com", 3000,
  "default", 8080);

p {
  // Safety Rebooter - to hold up thedevchannel.com and ai1.lol when admin sleeps!
  
  thread "Rebooter" {
    sleepSeconds(60*60*24);
    nohupJavax(programID(), vmArgs);
    System.exit (0);
  }
  
  // turn off memory leak
  
  noPrintLog();
  
  // Now for the actual server...
  
  final ServerSocket serverSocket = new ServerSocket(port);

  Thread thread = new Thread("HTTP Proxy Accept Port " + port) { public void run() {
   try {
    while (true) {
      try {
        final Socket s = serverSocket.accept();
        
        thread "Lister" {
          sleepSeconds(5);
          listThreads();
        }
        
        final S client = dropPrefix("/", s.getInetAddress().toString()); // Hmm... how to get the actual IP properly?
        String threadName = "PROXY: Handling client " + client;

        Thread t2 = new Thread(threadName) {
          public void run() ctex {
            Socket outSocket = null;
            final new AtomicLong transmitted;
            final new AtomicLong outTransmitted;
            try {
              print("HTTP Proxy Incoming!");
              
              final OutputStream out = s.getOutputStream();
              final InputStream in = s.getInputStream();
              
              // collect headers
              
              new ByteArrayOutputStream headersOut;
              BufferedReader headerReader = new BufferedReader(new InputStreamReader(in, "US-ASCII"), 1);
              boolean forwardedFor = false;
              S host = null;
              while (true) {
                S line = headerReader.readLine();
                if (line == null) ret;
                print("Header line read: " + quote(line));
                
                if (startsWithIgnoreCase(line, "Host:"))
                  host = dropPrefix("Host:", line).trim();
                else {
                  S rewritten;
                  if (startsWithIgnoreCase(line, "X-Forwarded-For:")) {
                    forwardedFor = true;
                    rewritten = line + ", " + client;
                  } else
                    rewritten = empty(line) ? line : rewriteHeaderLine(line);
                  if (!eq(rewritten, line))
                    print("Rewritten as: " + quote(rewritten));
                  if (nempty(rewritten)) {
                    byte[] bytes = (rewritten + "\r\n").getBytes("US-ASCII");
                    //print("Sending: " + bytesToHex(bytes));
                    headersOut.write(bytes);
                  }
                }
                
                if (l(line) == 0)
                  break;
              }
              
              int port = getForwardPort(host);
              
              outSocket = new Socket(forwardServer, port);
              print("Connected to " + forwardServer + ":" + port);
              final OutputStream outOut = outSocket.getOutputStream();
              final InputStream outIn = outSocket.getInputStream();
              
              outOut.write(headersOut.toByteArray());
              
              if (!forwardedFor)
                headerSend(outOut, "X-Forwarded-For: " + client);
                
              headerSend(outOut, "Host: " + hostToPort(host, port));
              
              headerSend(outOut, ""); // end of headers
                
              outOut.flush();
              
              // forward content in both directions
              
              //copyStream(outIn, out);
              
              Thread inThread = new Thread("Proxy In") {
                public void run() ctex {
                  byte[] buf = new byte[1];
                  while (true) {
                    int n = outIn.read(buf);
                    if (n <= 0) return;
                    out.write(buf, 0, n);
                    long t = transmitted.addAndGet(n);
                    if (t % 100000 == 0) print("Transmitted to client: " + t);
                  }
                }
              };
              inThread.start();
              
              Thread outThread = new Thread("Proxy Out") {
                public void run() ctex {
                  byte[] buf = new byte[1];
                  while (true) {
                    int n = in.read(buf);
                    if (n <= 0) return;
                    outOut.write(buf, 0, n);
                    long t = outTransmitted.addAndGet(n);
                    if (t % 100000 == 0) print("Transmitted to server: " + t);
                  }
                }
              };
              outThread.start();
              
              inThread.join();
              //outThread.join();
            } catch (IOException e) {
              print("[internal] " + e);
            } finally {
              print("Proxy request done, got " + transmitted.get() + ", sent " + outTransmitted.get() + " + headers");
              pcall { s.close(); }
              pcall { if (outSocket != null) outSocket.close(); }
            }
          }
        }; // Thread t2
        t2.setDaemon(true);
        t2.start();
      } catch (SocketTimeoutException e) {
      }
    }   
   } catch (IOException e) {
     print("[internal] " + e);
   }
  }};
  thread.start();
 
  print("HTTP proxy on port " + port + " started."); 
}

static S rewriteHeaderLine(S line) {
  /*if (startsWithIgnoreCase(line, "Host:"))
    line = "Host: " + forwardServer + ":" + forwardPort;*/
  ret line;
}

static int getForwardPort(S host) {
  int i = host.indexOf(':');
  if (i >= 0)
    host = host.substring(0, i);
  host = host.toLowerCase();
  for (S key : forwardMap.keySet())
    if (eq(host, key) || host.endsWith("." + key))
      ret forwardMap.get(key);
  ret forwardMap.get("default");
}

static S hostToPort(S host, int port) {
  int i = host.indexOf(':');
  if (i >= 0)
    host = host.substring(0, i);
  ret host + ":" + port;
}

static void headerSend(OutputStream out, S header) ctex {
  print("Sending header: " + header);
  out.write((header + "\r\n").getBytes("US-ASCII"));
}