httpd.go

   1 package main
   2
   3 import(
   4     "fmt"
   5     "os"
   6
   7     "io"
   8 //    "io/ioutil"
   9     "bufio"
  10
  11     "strings"
  12     "strconv"
  13     "text/scanner"
  14
  15     "net/http"
  16
  17     "github.com/wsxiaoys/terminal/color"
  18 )
  19
  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 {
  23
  24     black    [3]byte
  25     bblack   [3]byte
  26
  27     red      [3]byte
  28     bred     [3]byte
  29
  30     green    [3]byte
  31     bgreen   [3]byte
  32
  33     yellow   [3]byte
  34     byellow  [3]byte
  35
  36     blue     [3]byte
  37     bblue    [3]byte
  38
  39     purple   [3]byte
  40     bpurple  [3]byte
  41
  42     cyan     [3]byte
  43     bcyan    [3]byte
  44
  45     white    [3]byte
  46     bwhite   [3]byte
  47
  48     fg       [3]byte
  49     bg       [3]byte
  50 }
  51
  52 /* the default "control" ANSI color set (boring) */
  53 var ansiColors = ktPalette {
  54
  55     black   : [3]byte {0,0,0},
  56     bblack  : [3]byte {128,128,128},
  57
  58     red     : [3]byte {128,0,0},
  59     bred    : [3]byte {255,0,0},
  60
  61     green   : [3]byte {0,128,0},
  62     bgreen  : [3]byte {0,255,0},
  63
  64     yellow  : [3]byte {128,128,0},
  65     byellow : [3]byte {255,255,0},
  66
  67     blue    : [3]byte {0,0,128},
  68     bblue   : [3]byte {0,0,255},
  69
  70     purple  : [3]byte {128,0,128},
  71     bpurple : [3]byte {255,0,255},
  72
  73     cyan    : [3]byte {0,128,128},
  74     bcyan   : [3]byte {0,255,255},
  75
  76     white   : [3]byte {128,128,128},
  77     bwhite  : [3]byte {255,255,255},
  78
  79     fg      : [3]byte {0,0,0},
  80     bg      : [3]byte {255,255,255},
  81 }
  82
  83 /* lets get our money's worth out of this utf-8 crap */
  84 var checkM = "✓"
  85 var xM     = "✗"
  86
  87 /* parses a colorfile, returns palette struct. given a nil file pointer,
  88    returns standard ANSI color set (our "control") */
  89 func parseColors(colorfile *os.File) (pal ktPalette, err error) {
  90
  91     if colorfile == nil { return ansiColors, nil }
  92
  93     ret := ktPalette {}
  94     var e errConsumer
  95
  96     scanner := bufio.NewScanner(colorfile)
  97     for scanner.Scan() {
  98
  99         if strings.Contains(scanner.Text(), "color") &&
 100             !strings.Contains(scanner.Text(), "!") {
 101
 102             /* i am so sorry */
 103             cur      := strings.Replace(scanner.Text(), " ", "", -1)
 104             split    := strings.Split(cur, ":")
 105             hexColor := strings.Replace(split[1], "#", "", -1)
 106             coNumStr := strings.Replace(split[0], "URxvt*color", "", -1)
 107
 108             r, err := strconv.ParseUint(hexColor[0:2], 16, 8); e.Consume(err)
 109             g, err := strconv.ParseUint(hexColor[2:4], 16, 8); e.Consume(err)
 110             b, err := strconv.ParseUint(hexColor[4:], 16, 8);  e.Consume(err)
 111
 112             colorNo, err := strconv.Atoi(coNumStr); e.Consume(err)
 113
 114             if e.err != nil {
 115                 return ktPalette{}, e.err
 116             }
 117
 118             switch(colorNo) {
 119                 case 0:  ret.black[0]   = byte(r); ret.black[1]   = byte(g); ret.black[2]   = byte(b)
 120                 case 1:  ret.red[0]     = byte(r); ret.red[1]     = byte(g); ret.red[2]     = byte(b)
 121                 case 2:  ret.green[0]   = byte(r); ret.green[1]   = byte(g); ret.green[2]   = byte(b)
 122                 case 3:  ret.yellow[0]  = byte(r); ret.yellow[1]  = byte(g); ret.yellow[2]  = byte(b)
 123                 case 4:  ret.blue[0]    = byte(r); ret.blue[1]    = byte(g); ret.blue[2]    = byte(b)
 124                 case 5:  ret.purple[0]  = byte(r); ret.purple[1]  = byte(g); ret.purple[2]  = byte(b)
 125                 case 6:  ret.cyan[0]    = byte(r); ret.cyan[1]    = byte(g); ret.cyan[2]    = byte(b)
 126                 case 7:  ret.white[0]   = byte(r); ret.white[1]   = byte(g); ret.white[2]   = byte(b)
 127                 case 8:  ret.bblack[0]  = byte(r); ret.bblack[1]  = byte(g); ret.bblack[2]  = byte(b)
 128                 case 9:  ret.bred[0]    = byte(r); ret.bred[1]    = byte(g); ret.bred[2]    = byte(b)
 129                 case 10: ret.bgreen[0]  = byte(r); ret.bgreen[1]  = byte(g); ret.bgreen[2]  = byte(b)
 130                 case 11: ret.byellow[0] = byte(r); ret.byellow[1] = byte(g); ret.byellow[2] = byte(b)
 131                 case 12: ret.bblue[0]   = byte(r); ret.bblue[1]   = byte(g); ret.bblue[2]   = byte(b)
 132                 case 13: ret.bpurple[0] = byte(r); ret.bpurple[1] = byte(g); ret.bpurple[2] = byte(b)
 133                 case 14: ret.bcyan[0]   = byte(r); ret.bcyan[1]   = byte(g); ret.bcyan[2]   = byte(b)
 134                 case 15: ret.bwhite[0]  = byte(r); ret.bwhite[1]  = byte(g); ret.bwhite[2]  = byte(b)
 135             }
 136
 137         } else if strings.Contains(scanner.Text(), "background") {
 138
 139             hex := strings.Split(scanner.Text(), "#")
 140             het := hex[1]
 141
 142             r, err := strconv.ParseUint(het[0:2], 16, 8); e.Consume(err)
 143             g, err := strconv.ParseUint(het[2:4], 16, 8); e.Consume(err)
 144             b, err := strconv.ParseUint(het[4:], 16, 8); e.Consume(err)
 145
 146             if e.err != nil {
 147                 return ktPalette{}, e.err
 148             }
 149
 150             ret.bg[0] = byte(r)
 151             ret.bg[1] = byte(g)
 152             ret.bg[2] = byte(b)
 153
 154         } else if strings.Contains(scanner.Text(), "foreground") {
 155
 156             hex := strings.Split(scanner.Text(), "#")
 157             het := hex[1]
 158
 159             r, err := strconv.ParseUint(het[0:2], 16, 8); e.Consume(err)
 160             g, err := strconv.ParseUint(het[2:4], 16, 8); e.Consume(err)
 161             b, err := strconv.ParseUint(het[4:], 16, 8); e.Consume(err)
 162
 163             if e.err != nil {
 164                 return ktPalette{}, e.err
 165             }
 166
 167             ret.fg[0] = byte(r)
 168             ret.fg[1] = byte(g)
 169             ret.fg[2] = byte(b)
 170         }
 171     }
 172
 173     return ret, e.err
 174 }
 175
 176 func ktInit(dirPrepend string, port int, colorfilePath string) error {
 177
 178     color.Print("@yparsing colorfile :: @{|}")
 179     file, err := os.Open(colorfilePath)
 180     if err != nil {
 181         color.Printf("@r[%s]@{|} - bad colorfile path\n", xM)
 182         return fmt.Errorf("%s\n", "bad colorfile path")
 183     }
 184
 185     pal, err := parseColors(file)
 186
 187     if err != nil {
 188         color.Printf("@r[%s]@{|} - malformed colorfile [%s]\n", xM, err)
 189         return fmt.Errorf("%s\n", "malformed colorfile")
 190     }
 191
 192     color.Printf("@g[%s]@{|}\n", checkM)
 193
 194     if pal == ansiColors {}
 195
 196     color.Printf("@yverifying & preprocessing colorsets@{|} :: @y[SKIP]\n")
 197     color.Printf("@ygenerating transpositional colorspace@{|} :: @y[SKIP]\n")
 198
 199     color.Printf("@ystarting httpd on port @b%d@{|} :: ", port)
 200     http.HandleFunc("/kt/", transposePage)
 201
 202     var portString string
 203     fmt.Sprintf(portString, ":%d", port)
 204     err = http.ListenAndServe(portString, nil)
 205     if err != nil {
 206
 207         color.Printf("@r[%s]@{-} - run me as root!\n", xM)
 208         return fmt.Errorf("%s\n", "failed to start httpd")
 209     }
 210
 211     color.Printf("@g[%s]@{-}\n", checkM)
 212
 213     return nil
 214 }
 215
 216 func transposePage(writer http.ResponseWriter, req *http.Request) {
 217
 218     fqdn      := req.URL.Path[4:]
 219     targetURL := fmt.Sprintf("http://%s", fqdn)
 220
 221     resp, err := http.Get(targetURL)
 222     if err != nil {
 223
 224         io.WriteString(writer, "failed to get that page! -kt\n")
 225         io.WriteString(writer, targetURL)
 226         return
 227     }
 228
 229     var s scanner.Scanner
 230     s.Init(req.Body)
 231     //tok := s.Scan
 232
 233     resp.Body.Close()
 234 }
 235
 236 func main() {
 237
 238     err := ktInit("kolors", 999, "/home/kremlin/.Xresources")
 239
 240     if err != nil {}
 241 }
 242
 243 type errConsumer struct {
 244     err error
 245 }
 246
 247 func (e *errConsumer) Consume(err error) {
 248     if e.err == nil && err != nil {
 249         e.err = err
 250     }
 251 }
 252