package main import ( "bytes" "errors" "flag" "html/template" "io" "log" "net" "net/http" "net/url" "path" "sort" "strconv" "strings" "time" "github.com/kballard/go-shellquote" "contnet.org/lib/cnm-go" "contnet.org/lib/cnm-go/cnmfmt" "contnet.org/lib/cnp-go" ) var ( listen = flag.String("listen", "localhost:8080", "address for HTTP server to listen on") cnphost = flag.String("cnp-host", "", "the CNP host to proxy (disables browser mode)") nohighlight = flag.Bool("no-highlight", false, "do not include highlight.js scripts and stylesheets") nostatic = flag.Bool("no-static", false, "do not serve static files on /static") templates = template.Must(template.New("").Funcs(map[string]interface{}{ "inc": func(s string) string { return "" }, "dec": func() string { return "" }, "depth": func() int { return 0 }, "sanchor": func() string { return "" }, "lanchor": func() string { return "" }, "anchor": func() string { return "" }, "lang": func(s string) string { return strings.Map(func(r rune) rune { if (r >= 'a' && r <= 'z') || (r >= 'A' && r <= 'Z') || (r >= '0' && r <= '9') || r == '_' || r == '-' { return r } return '_' }, s) }, "href": func(s string) template.HTMLAttr { return "href=\"" + template.HTMLAttr(template.HTMLEscapeString(s)) + "\"" }, "cnmfmt": (func(cnmfmt.Text) template.HTML)(nil), "tourl": (func(string) string)(nil), }).ParseGlob("templates/*.html")) ) const ( anchorCNPSchema = "cnp://" anchorHTTPSchema = "http://" anchorPrefix = `` ) var ( anchorTemplate = template.Must(template.New("").Parse(anchorPrefix + "{{.}}" + anchorSuffix)) ) func escapeURL(urlStr string) string { isCNP := len(urlStr) >= len(anchorCNPSchema) && strings.EqualFold(urlStr[:len(anchorCNPSchema)], anchorCNPSchema) if isCNP { urlStr = anchorHTTPSchema + urlStr[len(anchorCNPSchema):] } var buf bytes.Buffer anchorTemplate.Execute(&buf, urlStr) urlStr = buf.String() urlStr = urlStr[len(anchorPrefix) : len(urlStr)-len(anchorSuffix)] if isCNP { urlStr = anchorCNPSchema + urlStr[len(anchorHTTPSchema):] } return urlStr } type server struct { host string highlighting bool } func newServer(host string, highlighting bool) *server { return &server{host, highlighting} } func (srv *server) handleError(w http.ResponseWriter, err error) { code := http.StatusInternalServerError switch err.(type) { case cnp.ErrorDenied: code = http.StatusForbidden case cnp.ErrorInvalid: code = http.StatusInternalServerError case cnp.ErrorNotFound: code = http.StatusNotFound case cnp.ErrorNotSupported: code = http.StatusInternalServerError case cnp.ErrorRejected: code = http.StatusUnprocessableEntity case cnp.ErrorServerError: code = http.StatusBadGateway case cnp.ErrorSyntax: code = http.StatusInternalServerError case cnp.ErrorTooLarge: code = http.StatusRequestEntityTooLarge case cnp.ErrorVersion: code = http.StatusInternalServerError } log.Printf("error: %T %v", err, err) http.Error(w, http.StatusText(code), code) } func (srv *server) handleIndex(w http.ResponseWriter, r *http.Request) { req, _ := cnp.NewRequest("", "/", nil) resp, _ := cnp.NewResponse(cnp.IntentOK, []byte{}) srv.cnpCNMToHTML(w, r, req, resp) } func (srv *server) handleCNP(w http.ResponseWriter, r *http.Request, path string) { host := srv.host if host == "" { ss := strings.SplitN(strings.TrimLeft(path, "/"), "/", 2) if len(ss) != 2 { if len(ss[0]) > 0 { http.Redirect(w, r, path+"/", http.StatusFound) return } srv.handleIndex(w, r) return } host = ss[0] path = "/" + ss[1] } req, err := cnp.NewRequest(host, path, nil) if err != nil { srv.handleError(w, err) return } if ims := r.Header.Get("If-Modified-Since"); ims != "" { var t time.Time t, err = http.ParseTime(ims) if err == nil && !t.IsZero() { req.SetIfModified(t) } } resp, err := cnp.Send(req) intent := "n/a" if resp != nil { intent = resp.Intent() } log.Printf("req: %q -> %q", req.Intent(), intent) if err != nil { if e, ok := err.(*net.OpError); ok && e.Op == "dial" { err = cnp.NewError(cnp.ReasonServerError) } srv.handleError(w, err) return } r.ParseForm() _, preq := r.Form["req"] _, phdr := r.Form["hdr"] _, presp := r.Form["resp"] _, praw := r.Form["raw"] if preq || phdr || presp { srv.cnpParamsToHTTP(w, resp) w.Header().Set("Content-Type", "text/plain") w.Header().Del("Content-Length") if preq { req.Write(w) } if presp { resp.Write(w) } else if phdr { resp.Header.Write(w) } } else { srv.cnpToWeb(w, r, req, resp, praw) } } func (srv *server) cnpToWeb(w http.ResponseWriter, r *http.Request, req *cnp.Request, resp *cnp.Response, raw bool) { if err := resp.Validate(); err != nil { srv.handleError(w, err) return } switch resp.ResponseIntent() { case cnp.IntentOK: srv.cnpParamsToHTTP(w, resp) if !raw && resp.Type() == "text/cnm" { srv.cnpCNMToHTML(w, r, req, resp) } else { io.Copy(w, resp.Body) } case cnp.IntentNotModified: w.WriteHeader(http.StatusNotModified) case cnp.IntentRedirect: host, pth, _ := resp.Location() // already validated loc, err := srv.cnpRedirectToHTTP(req, host, pth) if err != nil { srv.handleError(w, err) return } log.Println("redirecting to", loc) http.Redirect(w, r, loc, http.StatusFound) case cnp.IntentError: srv.handleError(w, cnp.NewError(resp.Reason())) default: srv.handleError(w, errors.New("unknown CNP response intent: "+resp.ResponseIntent())) } } func (srv *server) cnpRedirectToHTTP(req *cnp.Request, host, pth string) (string, error) { var loc string if host == "" || host == "." || host == srv.host { loc = pth if host == "." { loc = path.Join(path.Dir(req.Path()), loc) } if srv.host == "" { loc = path.Join("/", req.Host(), loc) } } else { rr, err := cnp.NewRequest(host, pth, nil) if err != nil { return "", err } if srv.host == "" { loc = path.Join("?", rr.Host(), rr.Path()) } else { loc = rr.URL().String() } } if strings.HasSuffix(pth, "/") { loc = loc + "/" } return loc, nil } func (srv *server) cnpParamsToHTTP(w http.ResponseWriter, resp *cnp.Response) { if l := resp.Length(); l > 0 { w.Header().Set("Content-Length", strconv.FormatInt(l, 10)) } if t := resp.Type(); t != "" { w.Header().Set("Content-Type", t) } if m := resp.Modified(); !m.IsZero() { w.Header().Set("Last-Modified", m.Format(http.TimeFormat)) } if t := resp.Time(); !t.IsZero() { w.Header().Set("Date", t.Format(http.TimeFormat)) } if n := resp.Name(); n != "" { w.Header().Set("Content-Disposition", "inline; filename=\""+strings.Map(func(r rune) rune { if r < ' ' || r == ' ' || r == '\'' { // filter out nulls, control codes, newlines and quotes return -1 } return r }, n)+"\"") } } type cnmPage struct { URL string Req string Resp string Doc *cnm.Document Site []site Netcat string Toc tocSection Highlight bool Browser bool depth int } type tocSection struct { Title string Children []tocSection } type site struct { Path string Name string Children []site } func genToc(b cnm.Block) []tocSection { var res []tocSection switch v := b.(type) { case *cnm.SectionBlock: if t := v.Title(); t != "" { var ch []tocSection for _, c := range v.Children() { ch = append(ch, genToc(c)...) } res = append(res, tocSection{ Title: v.Title(), Children: ch, }) } else { for _, bl := range v.Children() { res = append(res, genToc(bl)...) } } case *cnm.TableBlock: for _, bl := range v.Rows() { res = append(res, genToc(bl)...) } case *cnm.HeaderBlock: for _, bl := range v.Children() { res = append(res, genToc(bl)...) } case *cnm.RowBlock: for _, bl := range v.Children() { res = append(res, genToc(bl)...) } case *cnm.ContentBlock: if v == nil { break } for _, bl := range v.Children() { res = append(res, genToc(bl)...) } case *cnm.ListBlock: for _, bl := range v.Children() { res = append(res, genToc(bl)...) } } return res } func cnmSite(prefix string, s cnm.Site) (st site) { if ss := strings.Split(path.Clean(s.Path), "/"); len(ss) > 1 { s.Path = strings.Join(ss[1:], "/") return site{ Path: path.Join(prefix, ss[0]), Name: ss[0], Children: []site{ cnmSite(path.Join(prefix, ss[0]), s), }, } } st.Path = path.Join(prefix, s.Path) if s.Name == "" { st.Name = s.Path } else { st.Name = s.Name } if len(s.Children) > 0 { chs := make(map[string]site) for _, ch := range s.Children { chs[ch.Name] = cnmSite(st.Path, ch) } keys := make([]string, len(chs)) i := 0 for k := range chs { keys[i] = k i++ } sort.Slice(keys, func(i, j int) bool { a, b := chs[keys[i]], chs[keys[j]] da, db := strings.HasSuffix(a.Name, "/"), strings.HasSuffix(b.Name, "/") if da && !db { return true } if !da && db { return false } return a.Name < b.Name }) st.Children = make([]site, len(keys)) for i := range keys { st.Children[i] = chs[keys[i]] } } return } func (srv *server) cnpCNMToHTML(w http.ResponseWriter, r *http.Request, req *cnp.Request, resp *cnp.Response) { doc, err := cnm.ParseDocument(resp.Body) if err != nil { srv.handleError(w, err) return } w.Header().Set("Content-Type", "text/html") w.Header().Del("Content-Length") var breq, bresp, buf bytes.Buffer req.Header.Write(&breq) resp.Header.Write(&bresp) var st []site if len(doc.Site.Children) > 0 { st = []site{ site{"/", "/", cnmSite("/", doc.Site).Children}, } } u := req.URL() port := u.Port() if port == "" { port = strconv.Itoa(cnp.DefaultPort) } hdrs := req.Header.String() hdrs = hdrs[:len(hdrs)-1] host, _, _ := net.SplitHostPort(r.Host) if host == "" && r.Host != "" { host = r.Host } if host == "" { host = r.URL.Hostname() } if host == "" { host = req.Host() } sections := []string{} sanchors := map[string]bool{} lanchors := map[string]bool{} anchor := func() template.URL { var secs []string for _, s := range sections { if s = url.PathEscape(s); s != "" { secs = append(secs, s) } } return template.URL(strings.Join(secs, "/")) } err = templates.Funcs(map[string]interface{}{ "inc": func(s string) string { sections = append(sections, s); return "" }, "dec": func() string { sections = sections[:len(sections)-1]; return "" }, "depth": func() int { d := len(sections) + 1 if d > 6 { return 6 } return d }, "anchor": anchor, "sanchor": func() template.URL { s := url.PathEscape(sections[len(sections)-1]) if sanchors[s] { return "" } sanchors[s] = true return template.URL(s) }, "lanchor": func() template.URL { s := string(anchor()) if lanchors[s] { return "" } lanchors[s] = true return template.URL(s) }, "cnmfmt": func(txt cnmfmt.Text) template.HTML { return srv.fmtToHTML(req, txt) }, "tourl": func(s string) string { u, _ := srv.linkToURL(req, s) return u }, }).ExecuteTemplate(&buf, "page.html", cnmPage{ URL: u.String(), Req: breq.String(), Resp: bresp.String(), Doc: doc, Netcat: shellquote.Join("echo", hdrs) + " | " + shellquote.Join("nc", host, port), Site: st, Toc: tocSection{Children: genToc(doc.Content)}, Highlight: srv.highlighting, Browser: srv.host == "", }) if err != nil { srv.handleError(w, err) return } io.Copy(w, &buf) } func (srv *server) fmtToHTML(req *cnp.Request, text cnmfmt.Text) template.HTML { if len(text.Spans) == 0 { return "" } var last cnmfmt.Span var buf bytes.Buffer hadText := true spans := make([]cnmfmt.Span, len(text.Spans)+1) copy(spans, text.Spans) spans[len(spans)-1] = cnmfmt.Span{} // end all formats var tags []string for _, span := range spans { if last.Format.Link != span.Format.Link { if !hadText && last.Format.Link != "" { // no text in link template.HTMLEscape(&buf, []byte(last.Format.Link)) } hadText = false } srv.handleTags(req, &buf, &tags, last.Format, span.Format) if span.Text != "" { hadText = true template.HTMLEscape(&buf, []byte(span.Text)) } last = span } return template.HTML("

" + buf.String() + "

") } func (srv *server) handleTags(req *cnp.Request, buf *bytes.Buffer, tags *[]string, old, new cnmfmt.Format) { if old == new { return } close := map[string]bool{ "b": old.Bold && !new.Bold, "i": old.Italic && !new.Italic, "u": old.Underline && !new.Underline, "code": old.Monospace && !new.Monospace, "a": old.Link != "" && old.Link != new.Link, } open := map[string]bool{ "b": !old.Bold && new.Bold, "i": !old.Italic && new.Italic, "u": !old.Underline && new.Underline, "code": !old.Monospace && new.Monospace, "a": new.Link != "" && old.Link != new.Link, } t := *tags pop := len(t) for i := len(t) - 1; i >= 0; i-- { if close[t[i]] { pop = i } } for i := len(t) - 1; i >= pop; i-- { if !close[t[i]] { open[t[i]] = true } buf.WriteString("") } *tags = t[:pop] tagPush(buf, tags, open, "b", "") tagPush(buf, tags, open, "i", "") tagPush(buf, tags, open, "u", "") tagPush(buf, tags, open, "code", "") link, extern := srv.linkToURL(req, new.Link) tagPush(buf, tags, open, "a", "") } func (srv *server) linkToURL(req *cnp.Request, link string) (urlStr, extern string) { urlStr = "#ZcnpfmtZ" host := srv.host if host == "" { host = req.Host() } if u, err := url.Parse(link); err == nil { if u.Scheme == "cnp" && (srv.host == "" || u.Host == srv.host) { var lhost, lpath string lhost = u.Host lpath = u.Path if u.Host == srv.host { lhost = "" } else { extern = " class=\"cnp-external cnp-external-cnp\"" } urlStr = path.Join("/", lhost, lpath) if strings.HasSuffix(link, "/") { urlStr += "/" } if u.Fragment != "" { urlStr += "#" + u.Fragment } } else if u.Scheme != "" { extern = " class=\"cnp-external cnp-external-" + template.HTMLEscapeString(u.Scheme) + "\"" urlStr = u.String() } else { urlStr = u.Path if srv.host == "" { if !strings.HasPrefix(urlStr, "/") { urlStr = req.Path() + "/" + urlStr } urlStr = "/" + host + cnp.Clean("/"+urlStr) } if u.Fragment != "" { urlStr += "#" + u.Fragment } } } return } func tagPush(buf *bytes.Buffer, tags *[]string, ok map[string]bool, name, tag string) { if ok[name] { buf.WriteString(tag) *tags = append(*tags, name) } } func (srv *server) ServeHTTP(w http.ResponseWriter, r *http.Request) { log.Printf("access: %s %s %q", r.RemoteAddr, r.Method, r.URL) if r.Method == http.MethodPost { u := r.FormValue("url") req, err := cnp.NewRequestURL(u, nil) if err != nil { http.Error(w, err.Error(), http.StatusUnprocessableEntity) return } http.Redirect(w, r, path.Join("/", req.Host(), req.Path()), http.StatusFound) } else { srv.handleCNP(w, r, r.URL.Path) } } func main() { flag.Parse() srv := newServer(*cnphost, !*nohighlight) if !*nostatic { http.Handle("/static/", http.StripPrefix("/static/", http.FileServer(http.Dir("static")))) } http.Handle("/", srv) log.Printf("listening on %s", *listen) panic(http.ListenAndServe(*listen, nil)) }