httpd.go

   1 package main
   2
   3 import(
   4     "fmt"
   5     "os"
   6
   7     "strings"
   8     "strconv"
   9     "bufio"
  10
  11     "net/http"
  12
  13     "github.com/wsxiaoys/terminal/color"
  14 )
  15
  16 /* holds our palette, or 16 ANSI colors (8 normal colors + bright complements)
  17    and two foreground/background colors. colors are 3 byte arrays (RGB) */
  18 type ktPalette struct {
  19
  20     black    [3]byte
  21     bblack   [3]byte
  22
  23     red      [3]byte
  24     bred     [3]byte
  25
  26     green    [3]byte
  27     bgreen   [3]byte
  28
  29     yellow   [3]byte
  30     byellow  [3]byte
  31
  32     blue     [3]byte
  33     bblue    [3]byte
  34
  35     purple   [3]byte
  36     bpurple  [3]byte
  37
  38     cyan     [3]byte
  39     bcyan    [3]byte
  40
  41     white    [3]byte
  42     bwhite   [3]byte
  43
  44     fg       [3]byte
  45     bg       [3]byte
  46 }
  47
  48 /* the default "control" ANSI color set (boring) */
  49 var ansiColors = ktPalette {
  50
  51     black   : [3]byte {0,0,0},
  52     bblack  : [3]byte {128,128,128},
  53
  54     red     : [3]byte {128,0,0},
  55     bred    : [3]byte {255,0,0},
  56
  57     green   : [3]byte {0,128,0},
  58     bgreen  : [3]byte {0,255,0},
  59
  60     yellow  : [3]byte {128,128,0},
  61     byellow : [3]byte {255,255,0},
  62
  63     blue    : [3]byte {0,0,128},
  64     bblue   : [3]byte {0,0,255},
  65
  66     purple  : [3]byte {128,0,128},
  67     bpurple : [3]byte {255,0,255},
  68
  69     cyan    : [3]byte {0,128,128},
  70     bcyan   : [3]byte {0,255,255},
  71
  72     white   : [3]byte {128,128,128},
  73     bwhite  : [3]byte {255,255,255},
  74
  75     fg      : [3]byte {0,0,0},
  76     bg      : [3]byte {255,255,255},
  77 }
  78
  79 /* lets get our money's worth out of this utf-8 crap */
  80 var checkM = "✓"
  81 var xM     = "✗"
  82
  83 /* parses a colorfile, returns palette struct. given a nil file pointer,
  84    returns standard ANSI color set (our "control") */
  85 func parseColors(colorfile *os.File) (pal ktPalette, err error) {
  86
  87     if colorfile == nil { return ansiColors, nil }
  88
  89     ret := ktPalette {}
  90     var e errConsumer
  91
  92     scanner := bufio.NewScanner(colorfile)
  93     for scanner.Scan() {
  94
  95         if strings.Contains(scanner.Text(), "color") &&
  96             !strings.Contains(scanner.Text(), "!") {
  97
  98             /* i am so sorry */
  99             cur      := strings.Replace(scanner.Text(), " ", "", -1)
 100             split    := strings.Split(cur, ":")
 101             hexColor := strings.Replace(split[1], "#", "", -1)
 102             coNumStr := strings.Replace(split[0], "URxvt*color", "", -1)
 103
 104             r, err := strconv.ParseUint(hexColor[0:2], 16, 8); e.Consume(err)
 105             g, err := strconv.ParseUint(hexColor[2:4], 16, 8); e.Consume(err)
 106             b, err := strconv.ParseUint(hexColor[4:], 16, 8);  e.Consume(err)
 107
 108             colorNo, err := strconv.Atoi(coNumStr); e.Consume(err)
 109
 110             if e.err != nil {
 111                 return ktPalette{}, e.err
 112             }
 113
 114             switch(colorNo) {
 115                 case 0:  ret.black[0]   = byte(r); ret.black[1]   = byte(g); ret.black[2]   = byte(b)
 116                 case 1:  ret.red[0]     = byte(r); ret.red[1]     = byte(g); ret.red[2]     = byte(b)
 117                 case 2:  ret.green[0]   = byte(r); ret.green[1]   = byte(g); ret.green[2]   = byte(b)
 118                 case 3:  ret.yellow[0]  = byte(r); ret.yellow[1]  = byte(g); ret.yellow[2]  = byte(b)
 119                 case 4:  ret.blue[0]    = byte(r); ret.blue[1]    = byte(g); ret.blue[2]    = byte(b)
 120                 case 5:  ret.purple[0]  = byte(r); ret.purple[1]  = byte(g); ret.purple[2]  = byte(b)
 121                 case 6:  ret.cyan[0]    = byte(r); ret.cyan[1]    = byte(g); ret.cyan[2]    = byte(b)
 122                 case 7:  ret.white[0]   = byte(r); ret.white[1]   = byte(g); ret.white[2]   = byte(b)
 123                 case 8:  ret.bblack[0]  = byte(r); ret.bblack[1]  = byte(g); ret.bblack[2]  = byte(b)
 124                 case 9:  ret.bred[0]    = byte(r); ret.bred[1]    = byte(g); ret.bred[2]    = byte(b)
 125                 case 10: ret.bgreen[0]  = byte(r); ret.bgreen[1]  = byte(g); ret.bgreen[2]  = byte(b)
 126                 case 11: ret.byellow[0] = byte(r); ret.byellow[1] = byte(g); ret.byellow[2] = byte(b)
 127                 case 12: ret.bblue[0]   = byte(r); ret.bblue[1]   = byte(g); ret.bblue[2]   = byte(b)
 128                 case 13: ret.bpurple[0] = byte(r); ret.bpurple[1] = byte(g); ret.bpurple[2] = byte(b)
 129                 case 14: ret.bcyan[0]   = byte(r); ret.bcyan[1]   = byte(g); ret.bcyan[2]   = byte(b)
 130                 case 15: ret.bwhite[0]  = byte(r); ret.bwhite[1]  = byte(g); ret.bwhite[2]  = byte(b)
 131             }
 132
 133         } else if strings.Contains(scanner.Text(), "background") {
 134
 135             hex := strings.Split(scanner.Text(), "#")
 136             het := hex[1]
 137
 138             r, err := strconv.ParseUint(het[0:2], 16, 8); e.Consume(err)
 139             g, err := strconv.ParseUint(het[2:4], 16, 8); e.Consume(err)
 140             b, err := strconv.ParseUint(het[4:], 16, 8); e.Consume(err)
 141
 142             if e.err != nil {
 143                 return ktPalette{}, e.err
 144             }
 145
 146             ret.bg[0] = byte(r)
 147             ret.bg[1] = byte(g)
 148             ret.bg[2] = byte(b)
 149
 150         } else if strings.Contains(scanner.Text(), "foreground") {
 151
 152             hex := strings.Split(scanner.Text(), "#")
 153             het := hex[1]
 154
 155             r, err := strconv.ParseUint(het[0:2], 16, 8); e.Consume(err)
 156             g, err := strconv.ParseUint(het[2:4], 16, 8); e.Consume(err)
 157             b, err := strconv.ParseUint(het[4:], 16, 8); e.Consume(err)
 158
 159             if e.err != nil {
 160                 return ktPalette{}, e.err
 161             }
 162
 163             ret.fg[0] = byte(r)
 164             ret.fg[1] = byte(g)
 165             ret.fg[2] = byte(b)
 166         }
 167     }
 168
 169     return ret, e.err
 170 }
 171
 172 func ktInit(dirPrepend string, port int, colorfilePath string) error {
 173
 174     color.Print("@yparsing colorfile :: @{|}")
 175     file, err := os.Open(colorfilePath)
 176     if err != nil {
 177         color.Printf("@r[%s]@{|} - bad colorfile path\n", xM)
 178         return fmt.Errorf("%s\n", "bad colorfile path")
 179     }
 180
 181     pal, err := parseColors(file)
 182
 183     if err != nil {
 184         color.Printf("@r[%s]@{|} - malformed colorfile [%s]\n", xM, err)
 185         return fmt.Errorf("%s\n", "malformed colorfile")
 186     }
 187
 188     color.Printf("@g[%s]@{|}\n", checkM)
 189
 190     if pal == ansiColors {}
 191
 192     color.Printf("@ystarting httpd on port @b%d@{|} :: ", port)
 193
 194
 195     return nil
 196 }
 197
 198 func main() {
 199
 200     err := ktInit("kolors", 999, "/home/kremlin/.Xresources")
 201
 202     /* make sure to close() anything you need to (you need to) */
 203     _, err = http.Get("http://kremlin.cc")
 204
 205     if err != nil {}
 206 }
 207
 208 type errConsumer struct {
 209     err error
 210 }
 211
 212 func (e *errConsumer) Consume(err error) {
 213     if e.err == nil && err != nil {
 214         e.err = err
 215     }
 216 }
 217