17 "github.com/wsxiaoys/terminal/color"
20 /* holds our palette, or 16 ANSI colors (8 normal colors + bright complements)
21 and two foreground/background colors. colors are 3 byte arrays (RGB) */
22 type ktPalette struct {
51 /* the default "control" ANSI color set (boring) */
52 var ansiColors = ktPalette{
54 black: [3]byte{0, 0, 0},
55 bblack: [3]byte{128, 128, 128},
57 red: [3]byte{128, 0, 0},
58 bred: [3]byte{255, 0, 0},
60 green: [3]byte{0, 128, 0},
61 bgreen: [3]byte{0, 255, 0},
63 yellow: [3]byte{128, 128, 0},
64 byellow: [3]byte{255, 255, 0},
66 blue: [3]byte{0, 0, 128},
67 bblue: [3]byte{0, 0, 255},
69 purple: [3]byte{128, 0, 128},
70 bpurple: [3]byte{255, 0, 255},
72 cyan: [3]byte{0, 128, 128},
73 bcyan: [3]byte{0, 255, 255},
75 white: [3]byte{128, 128, 128},
76 bwhite: [3]byte{255, 255, 255},
79 bg: [3]byte{255, 255, 255},
82 /* lets get our money's worth out of this utf-8 crap */
86 /* parses a colorfile, returns palette struct. given a nil file pointer,
87 returns standard ANSI color set (our "control") */
88 func parseColors(colorfile *os.File) (pal ktPalette, err error) {
91 return ansiColors, nil
97 scanner := bufio.NewScanner(colorfile)
100 if strings.Contains(scanner.Text(), "color") &&
101 !strings.Contains(scanner.Text(), "!") {
104 cur := strings.Replace(scanner.Text(), " ", "", -1)
105 split := strings.Split(cur, ":")
106 hexColor := strings.Replace(split[1], "#", "", -1)
107 coNumStr := strings.Replace(split[0], "URxvt*color", "", -1)
109 r, err := strconv.ParseUint(hexColor[0:2], 16, 8)
111 g, err := strconv.ParseUint(hexColor[2:4], 16, 8)
113 b, err := strconv.ParseUint(hexColor[4:], 16, 8)
116 colorNo, err := strconv.Atoi(coNumStr)
120 return ktPalette{}, e.err
125 ret.black[0] = byte(r)
126 ret.black[1] = byte(g)
127 ret.black[2] = byte(b)
133 ret.green[0] = byte(r)
134 ret.green[1] = byte(g)
135 ret.green[2] = byte(b)
137 ret.yellow[0] = byte(r)
138 ret.yellow[1] = byte(g)
139 ret.yellow[2] = byte(b)
141 ret.blue[0] = byte(r)
142 ret.blue[1] = byte(g)
143 ret.blue[2] = byte(b)
145 ret.purple[0] = byte(r)
146 ret.purple[1] = byte(g)
147 ret.purple[2] = byte(b)
149 ret.cyan[0] = byte(r)
150 ret.cyan[1] = byte(g)
151 ret.cyan[2] = byte(b)
153 ret.white[0] = byte(r)
154 ret.white[1] = byte(g)
155 ret.white[2] = byte(b)
157 ret.bblack[0] = byte(r)
158 ret.bblack[1] = byte(g)
159 ret.bblack[2] = byte(b)
161 ret.bred[0] = byte(r)
162 ret.bred[1] = byte(g)
163 ret.bred[2] = byte(b)
165 ret.bgreen[0] = byte(r)
166 ret.bgreen[1] = byte(g)
167 ret.bgreen[2] = byte(b)
169 ret.byellow[0] = byte(r)
170 ret.byellow[1] = byte(g)
171 ret.byellow[2] = byte(b)
173 ret.bblue[0] = byte(r)
174 ret.bblue[1] = byte(g)
175 ret.bblue[2] = byte(b)
177 ret.bpurple[0] = byte(r)
178 ret.bpurple[1] = byte(g)
179 ret.bpurple[2] = byte(b)
181 ret.bcyan[0] = byte(r)
182 ret.bcyan[1] = byte(g)
183 ret.bcyan[2] = byte(b)
185 ret.bwhite[0] = byte(r)
186 ret.bwhite[1] = byte(g)
187 ret.bwhite[2] = byte(b)
190 } else if strings.Contains(scanner.Text(), "background") {
192 hex := strings.Split(scanner.Text(), "#")
195 r, err := strconv.ParseUint(het[0:2], 16, 8)
197 g, err := strconv.ParseUint(het[2:4], 16, 8)
199 b, err := strconv.ParseUint(het[4:], 16, 8)
203 return ktPalette{}, e.err
210 } else if strings.Contains(scanner.Text(), "foreground") {
212 hex := strings.Split(scanner.Text(), "#")
215 r, err := strconv.ParseUint(het[0:2], 16, 8)
217 g, err := strconv.ParseUint(het[2:4], 16, 8)
219 b, err := strconv.ParseUint(het[4:], 16, 8)
223 return ktPalette{}, e.err
237 func ktInit(dirPrepend string, port int, colorfilePath string) error {
241 color.Print("@yparsing colorfile :: @{|}")
242 file, err := os.Open(colorfilePath)
244 color.Printf("@r[%s]@{|} - bad colorfile path\n", xM)
245 return fmt.Errorf("%s\n", "bad colorfile path")
248 pal, err := parseColors(file)
251 color.Printf("@r[%s]@{|} - malformed colorfile [%s]\n", xM, err)
252 return fmt.Errorf("%s\n", "malformed colorfile")
255 color.Printf("@g[%s]@{|}\n", checkM)
257 if pal == ansiColors {
260 color.Printf("@yverifying & preprocessing colorsets@{|} :: @y[SKIP]\n")
261 color.Printf("@ygenerating transpositional colorspace@{|} :: @y[SKIP]\n")
263 color.Printf("@ystarting httpd on port @b%d@{|} :: ", port)
264 http.HandleFunc("/kt/", transposePage)
266 var portString string
267 fmt.Sprintf(portString, ":%d", port)
268 err = http.ListenAndServe(portString, nil)
271 color.Printf("@r[%s]@{-} - run me as root!\n", xM)
272 return fmt.Errorf("%s\n", "failed to start httpd")
275 color.Printf("@g[%s]@{-}\n", checkM)
280 func transposePage(writer http.ResponseWriter, req *http.Request) {
285 color.Printf("@g[%s]@{|}\n", checkM)
288 if req.URL.Path == "/kt/" {
289 writer.Write([]byte("wtf"))
293 fqdn := req.URL.Path[4:]
294 targetURL := fmt.Sprintf("http://%s", fqdn)
296 resp, err := http.Get(targetURL)
298 if err != nil || resp.StatusCode != 200 {
300 io.WriteString(writer, "failed to get that page! -kt\n")
301 io.WriteString(writer, targetURL+"\n")
303 io.WriteString(writer, resp.Status)
307 conType := resp.Header.Get("Content-Type")
309 switch conType[0:strings.Index(conType, ";")] {
312 writer.Write(transposeHTML(bufio.NewScanner(resp.Body), fqdn))
315 writer.Write(transposeCSS(bufio.NewScanner(resp.Body), fqdn))
318 page, _ := ioutil.ReadAll(resp.Body)
325 /* swap href="" & src="" */
326 func transposeHTML(scan *bufio.Scanner, fqdn string) []byte {
331 scan.Split(bufio.ScanWords)
337 //fmt.Printf("%s\n", cur)
341 } else if cur[0:6] == "href=\\" {
343 urlStr := cur[7 : strings.Index(cur[7:], "\\")+7]
345 u, err := url.Parse(urlStr)
347 fmt.Printf("malformed URL: %s\n", urlStr)
352 u.Host = fmt.Sprintf("localhost/kt/%s", fqdn)
353 // cur = append(cur[0:6],
356 fmt.Printf("[F] URL: %s // PATH: %s\n", u.Host, u.Path)
360 } else if cur[0:5] == "href=" {
362 urlStr := cur[6 : strings.Index(cur[6:], "\"")+6]
364 u, err := url.Parse(urlStr)
366 fmt.Printf("malformed URL: %s\n", urlStr)
371 fmt.Printf("URL: %s // PATH: %s\n", u.Host, u.Path)
373 } else if cur[0:5] == "src=\"" {
375 //fmt.Printf("%s\n", cur)
376 urlStr := cur[5 : strings.Index(cur[5:], "\"")+5]
378 u, err := url.Parse(urlStr)
380 fmt.Printf("malformed URL: %s\n", urlStr)
385 u.Host = fmt.Sprintf("localhost/kt/%s", fqdn)
386 // cur = append(cur[0:6],
388 fmt.Printf("[S] URL: %s // PATH: %s\n", u.Host, u.Path)
395 ret = append(ret, byte(' '))
396 ret = append(ret, cur...)
399 fmt.Printf("%d\n", i)
404 func transposeCSS(scan *bufio.Scanner, fqdn string) []byte {
413 err := ktInit("kolors", 999, "/home/kremlin/.Xresources")
419 type errConsumer struct {
423 func (e *errConsumer) Consume(err error) {
424 if e.err == nil && err != nil {