X-Git-Url: https://uglyman.kremlin.cc/gitweb/gitweb.cgi?p=k_transpose.git;a=blobdiff_plain;f=httpd.go;h=74c4acac0b955724ab68eb0aa7ce3e2ecc6ad563;hp=856d7dfe26909b38ee55c929c67bb4176e44b491;hb=HEAD;hpb=53d46aa3f7b18ebe0bdaf0061bc0218aa45afa4b

diff --git a/httpd.go b/httpd.go
index 856d7df..74c4aca 100644
--- a/httpd.go
+++ b/httpd.go
@@ -1,14 +1,427 @@
 package main
 
-import "fmt"
-import "net/http"
+import (
+	"fmt"
+	"os"
+
+	"bufio"
+	"io"
+	"io/ioutil"
+
+	"strconv"
+	"strings"
+
+	"net/http"
+	"net/url"
+
+	"github.com/wsxiaoys/terminal/color"
+)
+
+/* holds our palette, or 16 ANSI colors (8 normal colors + bright complements)
+   and two foreground/background colors. colors are 3 byte arrays (RGB) */
+type ktPalette struct {
+	black  [3]byte
+	bblack [3]byte
+
+	red  [3]byte
+	bred [3]byte
+
+	green  [3]byte
+	bgreen [3]byte
+
+	yellow  [3]byte
+	byellow [3]byte
+
+	blue  [3]byte
+	bblue [3]byte
+
+	purple  [3]byte
+	bpurple [3]byte
+
+	cyan  [3]byte
+	bcyan [3]byte
+
+	white  [3]byte
+	bwhite [3]byte
+
+	fg [3]byte
+	bg [3]byte
+}
+
+/* the default "control" ANSI color set (boring) */
+var ansiColors = ktPalette{
+
+	black:  [3]byte{0, 0, 0},
+	bblack: [3]byte{128, 128, 128},
+
+	red:  [3]byte{128, 0, 0},
+	bred: [3]byte{255, 0, 0},
+
+	green:  [3]byte{0, 128, 0},
+	bgreen: [3]byte{0, 255, 0},
+
+	yellow:  [3]byte{128, 128, 0},
+	byellow: [3]byte{255, 255, 0},
+
+	blue:  [3]byte{0, 0, 128},
+	bblue: [3]byte{0, 0, 255},
+
+	purple:  [3]byte{128, 0, 128},
+	bpurple: [3]byte{255, 0, 255},
+
+	cyan:  [3]byte{0, 128, 128},
+	bcyan: [3]byte{0, 255, 255},
+
+	white:  [3]byte{128, 128, 128},
+	bwhite: [3]byte{255, 255, 255},
+
+	fg: [3]byte{0, 0, 0},
+	bg: [3]byte{255, 255, 255},
+}
+
+/* lets get our money's worth out of this utf-8 crap */
+var checkM = "✓"
+var xM = "✗"
+
+/* parses a colorfile, returns palette struct. given a nil file pointer,
+   returns standard ANSI color set (our "control") */
+func parseColors(colorfile *os.File) (pal ktPalette, err error) {
+
+	if colorfile == nil {
+		return ansiColors, nil
+	}
+
+	ret := ktPalette{}
+	var e errConsumer
+
+	scanner := bufio.NewScanner(colorfile)
+	for scanner.Scan() {
+
+		if strings.Contains(scanner.Text(), "color") &&
+			!strings.Contains(scanner.Text(), "!") {
+
+			/* i am so sorry */
+			cur := strings.Replace(scanner.Text(), " ", "", -1)
+			split := strings.Split(cur, ":")
+			hexColor := strings.Replace(split[1], "#", "", -1)
+			coNumStr := strings.Replace(split[0], "URxvt*color", "", -1)
+
+			r, err := strconv.ParseUint(hexColor[0:2], 16, 8)
+			e.Consume(err)
+			g, err := strconv.ParseUint(hexColor[2:4], 16, 8)
+			e.Consume(err)
+			b, err := strconv.ParseUint(hexColor[4:], 16, 8)
+			e.Consume(err)
+
+			colorNo, err := strconv.Atoi(coNumStr)
+			e.Consume(err)
+
+			if e.err != nil {
+				return ktPalette{}, e.err
+			}
+
+			switch colorNo {
+			case 0:
+				ret.black[0] = byte(r)
+				ret.black[1] = byte(g)
+				ret.black[2] = byte(b)
+			case 1:
+				ret.red[0] = byte(r)
+				ret.red[1] = byte(g)
+				ret.red[2] = byte(b)
+			case 2:
+				ret.green[0] = byte(r)
+				ret.green[1] = byte(g)
+				ret.green[2] = byte(b)
+			case 3:
+				ret.yellow[0] = byte(r)
+				ret.yellow[1] = byte(g)
+				ret.yellow[2] = byte(b)
+			case 4:
+				ret.blue[0] = byte(r)
+				ret.blue[1] = byte(g)
+				ret.blue[2] = byte(b)
+			case 5:
+				ret.purple[0] = byte(r)
+				ret.purple[1] = byte(g)
+				ret.purple[2] = byte(b)
+			case 6:
+				ret.cyan[0] = byte(r)
+				ret.cyan[1] = byte(g)
+				ret.cyan[2] = byte(b)
+			case 7:
+				ret.white[0] = byte(r)
+				ret.white[1] = byte(g)
+				ret.white[2] = byte(b)
+			case 8:
+				ret.bblack[0] = byte(r)
+				ret.bblack[1] = byte(g)
+				ret.bblack[2] = byte(b)
+			case 9:
+				ret.bred[0] = byte(r)
+				ret.bred[1] = byte(g)
+				ret.bred[2] = byte(b)
+			case 10:
+				ret.bgreen[0] = byte(r)
+				ret.bgreen[1] = byte(g)
+				ret.bgreen[2] = byte(b)
+			case 11:
+				ret.byellow[0] = byte(r)
+				ret.byellow[1] = byte(g)
+				ret.byellow[2] = byte(b)
+			case 12:
+				ret.bblue[0] = byte(r)
+				ret.bblue[1] = byte(g)
+				ret.bblue[2] = byte(b)
+			case 13:
+				ret.bpurple[0] = byte(r)
+				ret.bpurple[1] = byte(g)
+				ret.bpurple[2] = byte(b)
+			case 14:
+				ret.bcyan[0] = byte(r)
+				ret.bcyan[1] = byte(g)
+				ret.bcyan[2] = byte(b)
+			case 15:
+				ret.bwhite[0] = byte(r)
+				ret.bwhite[1] = byte(g)
+				ret.bwhite[2] = byte(b)
+			}
+
+		} else if strings.Contains(scanner.Text(), "background") {
+
+			hex := strings.Split(scanner.Text(), "#")
+			het := hex[1]
+
+			r, err := strconv.ParseUint(het[0:2], 16, 8)
+			e.Consume(err)
+			g, err := strconv.ParseUint(het[2:4], 16, 8)
+			e.Consume(err)
+			b, err := strconv.ParseUint(het[4:], 16, 8)
+			e.Consume(err)
+
+			if e.err != nil {
+				return ktPalette{}, e.err
+			}
+
+			ret.bg[0] = byte(r)
+			ret.bg[1] = byte(g)
+			ret.bg[2] = byte(b)
+
+		} else if strings.Contains(scanner.Text(), "foreground") {
+
+			hex := strings.Split(scanner.Text(), "#")
+			het := hex[1]
+
+			r, err := strconv.ParseUint(het[0:2], 16, 8)
+			e.Consume(err)
+			g, err := strconv.ParseUint(het[2:4], 16, 8)
+			e.Consume(err)
+			b, err := strconv.ParseUint(het[4:], 16, 8)
+			e.Consume(err)
+
+			if e.err != nil {
+				return ktPalette{}, e.err
+			}
+
+			ret.fg[0] = byte(r)
+			ret.fg[1] = byte(g)
+			ret.fg[2] = byte(b)
+		}
+	}
+
+	return ret, e.err
+}
+
+var httpdStatus bool
+
+func ktInit(dirPrepend string, port int, colorfilePath string) error {
+
+	httpdStatus = false
+
+	color.Print("@yparsing colorfile :: @{|}")
+	file, err := os.Open(colorfilePath)
+	if err != nil {
+		color.Printf("@r[%s]@{|} - bad colorfile path\n", xM)
+		return fmt.Errorf("%s\n", "bad colorfile path")
+	}
+
+	pal, err := parseColors(file)
+
+	if err != nil {
+		color.Printf("@r[%s]@{|} - malformed colorfile [%s]\n", xM, err)
+		return fmt.Errorf("%s\n", "malformed colorfile")
+	}
+
+	color.Printf("@g[%s]@{|}\n", checkM)
+
+	if pal == ansiColors {
+	}
+
+	color.Printf("@yverifying & preprocessing colorsets@{|} :: @y[SKIP]\n")
+	color.Printf("@ygenerating transpositional colorspace@{|} :: @y[SKIP]\n")
+
+	color.Printf("@ystarting httpd on port @b%d@{|} :: ", port)
+	http.HandleFunc("/kt/", transposePage)
+
+	var portString string
+	fmt.Sprintf(portString, ":%d", port)
+	err = http.ListenAndServe(portString, nil)
+	if err != nil {
+
+		color.Printf("@r[%s]@{-} - run me as root!\n", xM)
+		return fmt.Errorf("%s\n", "failed to start httpd")
+	}
+
+	color.Printf("@g[%s]@{-}\n", checkM)
+
+	return nil
+}
+
+func transposePage(writer http.ResponseWriter, req *http.Request) {
+
+	if !httpdStatus {
+
+		httpdStatus = true
+		color.Printf("@g[%s]@{|}\n", checkM)
+	}
+
+	if req.URL.Path == "/kt/" {
+		writer.Write([]byte("wtf"))
+		return
+	}
+
+	fqdn := req.URL.Path[4:]
+	targetURL := fmt.Sprintf("http://%s", fqdn)
+
+	resp, err := http.Get(targetURL)
+
+	if err != nil || resp.StatusCode != 200 {
+
+		io.WriteString(writer, "failed to get that page! -kt\n")
+		io.WriteString(writer, targetURL+"\n")
+
+		io.WriteString(writer, resp.Status)
+		return
+	}
+
+	conType := resp.Header.Get("Content-Type")
+
+	switch conType[0:strings.Index(conType, ";")] {
+
+	case "text/html":
+		writer.Write(transposeHTML(bufio.NewScanner(resp.Body), fqdn))
+
+	case "text/css":
+		writer.Write(transposeCSS(bufio.NewScanner(resp.Body), fqdn))
+
+	default:
+		page, _ := ioutil.ReadAll(resp.Body)
+		writer.Write(page)
+	}
+
+	resp.Body.Close()
+}
+
+/* swap href="" & src="" */
+func transposeHTML(scan *bufio.Scanner, fqdn string) []byte {
+
+	var ret []byte
+	var i int
+
+	scan.Split(bufio.ScanWords)
+	for scan.Scan() {
+
+		i++
+		cur := scan.Text()
+
+		//fmt.Printf("%s\n", cur)
+
+		if len(cur) < 7 {
+
+		} else if cur[0:6] == "href=\\" {
+
+			urlStr := cur[7 : strings.Index(cur[7:], "\\")+7]
+
+			u, err := url.Parse(urlStr)
+			if err != nil {
+				fmt.Printf("malformed URL: %s\n", urlStr)
+			}
+
+			if u.Host == "" {
+
+				u.Host = fmt.Sprintf("localhost/kt/%s", fqdn)
+				//				cur = append(cur[0:6],
+			}
+
+			fmt.Printf("[F] URL: %s // PATH: %s\n", u.Host, u.Path)
+			if u == u {
+			}
+
+		} else if cur[0:5] == "href=" {
+
+			urlStr := cur[6 : strings.Index(cur[6:], "\"")+6]
+
+			u, err := url.Parse(urlStr)
+			if err != nil {
+				fmt.Printf("malformed URL: %s\n", urlStr)
+			}
+
+			if u == u {
+			}
+			fmt.Printf("URL: %s // PATH: %s\n", u.Host, u.Path)
+
+		} else if cur[0:5] == "src=\"" {
+
+			//fmt.Printf("%s\n", cur)
+			urlStr := cur[5 : strings.Index(cur[5:], "\"")+5]
+
+			u, err := url.Parse(urlStr)
+			if err != nil {
+				fmt.Printf("malformed URL: %s\n", urlStr)
+			}
+
+			if u.Host == "" {
+
+				u.Host = fmt.Sprintf("localhost/kt/%s", fqdn)
+				//				cur = append(cur[0:6],
+
+				fmt.Printf("[S] URL: %s // PATH: %s\n", u.Host, u.Path)
+				if u == u {
+				}
+			}
+
+		}
+
+		ret = append(ret, byte(' '))
+		ret = append(ret, cur...)
+	}
+
+	fmt.Printf("%d\n", i)
+
+	return ret
+}
+
+func transposeCSS(scan *bufio.Scanner, fqdn string) []byte {
+
+	var ret []byte
+
+	return ret
+}
 
 func main() {
 
-    /* make sure to close() anything you need to (you need to) */
-    fmt.Println("welp");
-    resp, err := http.Get("http://kremlin.cc")
+	err := ktInit("kolors", 999, "/home/kremlin/.Xresources")
+
+	if err != nil {
+	}
+}
+
+type errConsumer struct {
+	err error
+}
 
-    if err != nil {}
-    fmt.Println(resp)
+func (e *errConsumer) Consume(err error) {
+	if e.err == nil && err != nil {
+		e.err = err
+	}
 }