func (h *Handler) StoreMessage(c web.C, w http.ResponseWriter, r *http.Request) {
room := r.PostFormValue("room")
if room == "" {
fmt.Fprintf(w, response.New().WithError(errors.New("No room specified. Skipping.")).Json())
return
}
msg := map[string]interface{}{
"room": html.EscapeString(r.PostFormValue("room")),
"author": html.EscapeString(r.PostFormValue("author")),
"message": html.EscapeString(r.PostFormValue("message")),
"at": serializer.ParseJavaScriptTime(r.PostFormValue("time")),
}
logForReq(c, fmt.Sprintf("Inserting %s", msg))
message, err := h.DB.InsertMessage(msg)
if err != nil {
errMsg := fmt.Sprintf("Could not insert message %s: %s", msg, err.Error())
http.Error(w, response.New().WithError(errors.New(errMsg)).Json(), 500)
return
}
fmt.Fprintf(w, response.New().WithMessage(message).Json())
}
func (HTMLFormatter) Format(element Element) string {
switch el := element.(type) {
case *Document:
return `<!DOCTYPE html>
<html>
<head>
` + HTML.documentHeader(el) + `
</head>
<body>
<div class="container">
<h1 class="page-header">` + html.EscapeString(el.Title) + `</h1>
` + HTML.formatContent(el.Contents()) + `
</div>
<script src="/js/bootstrap.js" async></script>
</body>
</html>`
case *Italic:
return "<em>" + HTML.formatContent(el.Contents()) + "</em>"
case *Bold:
return "<strong>" + HTML.formatContent(el.Contents()) + "</strong>"
case *LineBreak:
return "<br>"
case *Paragraph:
return "<p>" + HTML.formatContent(el.Contents()) + "</p>"
case *Image:
return "<img src=\"" + html.EscapeString(el.URL) + "\" alt=\"" + html.EscapeString(el.Description) + "\" title=\"" + html.EscapeString(el.Description) + "\">"
case *Link:
return "<a href=\"" + html.EscapeString(el.URL) + "\">" + HTML.formatContent(el.Contents()) + "</a>"
case *LeafElement:
return html.EscapeString(el.Text)
case *Article:
return "<article><h1>" + el.Title + " <small>" + el.Timestamp.Format("15:04 2 Jan 2006") + "</small></h1>\n" + HTML.formatContent(el.Contents()) + "</article>"
}
return fmt.Sprintf("%#v", element)
}
func getPackageNodes(goCode []ParsedCode) (packageNodes []graph.PackageNode) {
packagesMap := make(map[string]*graph.PackageNode)
//Map the files to their graph.PackageNode
for _, parsedCode := range goCode {
//Get packageNode from map
nodePtr := packagesMap[parsedCode.PackageName()]
if nodePtr == nil {
node := graph.CreatePackageNode(
html.EscapeString(parsedCode.PackageName()),
html.EscapeString(parsedCode.PackagePath()),
nil)
nodePtr = &node
}
//add row
nodePtr.AddPackageNodeRow(graph.CreatePackageNodeRow(
html.EscapeString(parsedCode.FileName()),
htmlEscapeStringArray(parsedCode.Functions()),
htmlEscapeStringArray(parsedCode.Types()),
htmlEscapeStringArray(parsedCode.Variables())))
//put back in map
packagesMap[parsedCode.PackageName()] = nodePtr
}
//Take the graph.PackageNode out of the map and put in an array.
for _, packageNode := range packagesMap {
packageNodes = append(packageNodes, *packageNode)
}
return packageNodes
}
func (sh *SyncHandler) ServeHTTP(rw http.ResponseWriter, req *http.Request) {
sh.lk.Lock()
defer sh.lk.Unlock()
fmt.Fprintf(rw, "<h1>%s to %s Sync Status</h1><p><b>Current status: </b>%s</p>",
sh.fromName, sh.toName, html.EscapeString(sh.status))
fmt.Fprintf(rw, "<h2>Stats:</h2><ul>")
fmt.Fprintf(rw, "<li>Blobs copied: %d</li>", sh.totalCopies)
fmt.Fprintf(rw, "<li>Bytes copied: %d</li>", sh.totalCopyBytes)
if !sh.recentCopyTime.IsZero() {
fmt.Fprintf(rw, "<li>Most recent copy: %s</li>", sh.recentCopyTime.Format(time.RFC3339))
}
fmt.Fprintf(rw, "<li>Copy errors: %d</li>", sh.totalErrors)
fmt.Fprintf(rw, "</ul>")
if len(sh.blobStatus) > 0 {
fmt.Fprintf(rw, "<h2>Current Copies:</h2><ul>")
for blobstr, sfn := range sh.blobStatus {
fmt.Fprintf(rw, "<li>%s: %s</li>\n",
blobstr, html.EscapeString(sfn.String()))
}
fmt.Fprintf(rw, "</ul>")
}
if len(sh.recentErrors) > 0 {
fmt.Fprintf(rw, "<h2>Recent Errors:</h2><ul>")
for _, te := range sh.recentErrors {
fmt.Fprintf(rw, "<li>%s: %s</li>\n",
te.t.Format(time.RFC3339),
html.EscapeString(te.err.Error()))
}
fmt.Fprintf(rw, "</ul>")
}
}
// HTTP handler for _dump
func (h *handler) handleDump() error {
viewName := h.PathVar("view")
base.LogTo("HTTP", "Dump view %q", viewName)
opts := db.Body{"stale": false, "reduce": false}
result, err := h.db.Bucket.View(db.DesignDocSyncGateway, viewName, opts)
if err != nil {
return err
}
title := fmt.Sprintf("/%s: “%s” View", html.EscapeString(h.db.Name), html.EscapeString(viewName))
h.setHeader("Content-Type", `text/html; charset="UTF-8"`)
h.response.Write([]byte(fmt.Sprintf(
`<!DOCTYPE html><html><head><title>%s</title></head><body>
<h1>%s</h1><code>
<table border=1>
`,
title, title)))
h.response.Write([]byte("\t<tr><th>Key</th><th>Value</th><th>ID</th></tr>\n"))
for _, row := range result.Rows {
key, _ := json.Marshal(row.Key)
value, _ := json.Marshal(row.Value)
h.response.Write([]byte(fmt.Sprintf("\t<tr><td>%s</td><td>%s</td><td><em>%s</em></td>",
html.EscapeString(string(key)), html.EscapeString(string(value)), html.EscapeString(row.ID))))
h.response.Write([]byte("</tr>\n"))
}
h.response.Write([]byte("</table>\n</code></html></body>"))
return nil
}
func (pr *publishRequest) serveHTTP() {
if !pr.rootpn.Valid() {
pr.rw.WriteHeader(404)
return
}
if pr.Debug() {
pr.rw.Header().Set("Content-Type", "text/html")
pr.pf("I am publish handler at base %q, serving root %q (permanode=%s), suffix %q, subreq %q<hr>",
pr.base, pr.ph.RootName, pr.rootpn, html.EscapeString(pr.suffix), html.EscapeString(pr.subres))
}
if err := pr.findSubject(); err != nil {
if err == os.ErrNotExist {
pr.rw.WriteHeader(404)
return
}
log.Printf("Error looking up %s/%q: %v", pr.rootpn, pr.suffix, err)
pr.rw.WriteHeader(500)
return
}
if pr.Debug() {
pr.pf("<p><b>Subject:</b> <a href='/ui/?p=%s'>%s</a></p>", pr.subject, pr.subject)
return
}
switch pr.SubresourceType() {
case "":
pr.serveSubjectTemplate()
case "b":
// TODO: download a raw blob
case "f": // file download
pr.serveSubresFileDownload()
case "i": // image, scaled
pr.serveSubresImage()
case "s": // static
pr.req.URL.Path = pr.subres[len("/=s"):]
if len(pr.req.URL.Path) <= 1 {
http.Error(pr.rw, "Illegal URL.", http.StatusNotFound)
return
}
file := pr.req.URL.Path[1:]
if m := closurePattern.FindStringSubmatch(file); m != nil {
pr.req.URL.Path = "/" + m[1]
pr.ph.closureHandler.ServeHTTP(pr.rw, pr.req)
return
}
if file == "deps.js" {
serveDepsJS(pr.rw, pr.req, pr.ph.uiDir)
return
}
serveStaticFile(pr.rw, pr.req, uistatic.Files, file)
case "z":
pr.serveZip()
default:
pr.rw.WriteHeader(400)
pr.pf("<p>Invalid or unsupported resource request.</p>")
}
}
func nodeTable(name string, urls []string) string {
// escape name
name = html.EscapeString(name)
// turn big things like 'how do we eat bananas' into 'how ... bananas'
nameshow := name
if len(name) > 45 {
nameshow = name[:28] + " ... " + name[len(name)-12:]
}
// escape urls
for i := range urls {
urls[i] = html.EscapeString(urls[i])
}
table := fmt.Sprintf("<<table tooltip=\"%s\" border=\"0\" cellborder=\"0\" cellpadding=\"4\">", name)
table += fmt.Sprintf("<tr><td bgcolor=\"black\" align=\"center\"><font color=\"white\"><b> %s </b></font></td></tr>", nameshow)
for _, url := range urls {
// remove url endings on show
urlshow := url
if len(urlshow) > 45 {
urlshow = urlshow[:42] + "..."
}
table += fmt.Sprintf("<tr><td href=\"%s\" target=\"_blank\" tooltip=\"%s\">%s</td></tr>", url, url, url[7:])
}
table += "</table>>"
return table
}
//line _test\conents.ego:1
func MyContents(w io.Writer, u *User) error {
//line _test\conents.ego:2
_, _ = fmt.Fprint(w, "\n\n")
//line _test\conents.ego:4
_, _ = fmt.Fprint(w, "\n\n <h1>Hello ")
//line _test\conents.ego:5
_, _ = fmt.Fprint(w, html.EscapeString(fmt.Sprintf("%v", strings.TrimSpace(u.FirstName))))
//line _test\conents.ego:5
_, _ = fmt.Fprint(w, "!</h1>\n\n <p>Here's a list of your favorite colors:</p>\n <ul>\n ")
//line _test\conents.ego:9
for _, colorName := range u.FavoriteColors {
//line _test\conents.ego:10
_, _ = fmt.Fprint(w, "\n <li>")
//line _test\conents.ego:10
_, _ = fmt.Fprint(w, html.EscapeString(fmt.Sprintf("%v", colorName)))
//line _test\conents.ego:10
_, _ = fmt.Fprint(w, "</li>\n ")
//line _test\conents.ego:11
}
//line _test\conents.ego:12
_, _ = fmt.Fprint(w, "\n </ul>\n\n")
//line _test\conents.ego:14
EgoLayout(w, MyLayout)
//line _test\conents.ego:15
_, _ = fmt.Fprint(w, "\n")
return nil
}
func (node *tagOptionNode) Execute(ctx *p2.ExecutionContext, writer p2.TemplateWriter) *p2.Error {
fieldObj := ctx.Public[node.field]
if nil == fieldObj {
return ctx.Error("field '"+node.field+"' is missing.", nil)
}
field, _ := fieldObj.(*revel.Field)
if nil == field {
return ctx.Error(fmt.Sprintf("field '"+node.field+"' isn't Field - %T.", fieldObj), nil)
}
val, err := node.value.Evaluate(ctx)
if err != nil {
return err
}
val_str := val.String()
selected := ""
if field.Flash() == val_str || (field.Flash() == "" && field.Value() == val_str) {
selected = " selected"
}
fmt.Fprintf(writer, `<option value="%s"%s>%s</option>`,
html.EscapeString(val_str), selected, html.EscapeString(node.label))
return nil
}
func escHtml(s string) string {
ns := ""
noesc := false
w := ""
for _, r := range s {
switch {
case r == 1:
noesc = true
if w != "" {
ns += html.EscapeString(w)
w = ""
}
continue
case r == 2:
noesc = false
continue
case noesc:
ns += string(r)
default:
w += string(r)
}
}
if w != "" {
ns += html.EscapeString(w)
}
return ns
}
func handlerLeader(w http.ResponseWriter, r *http.Request) {
fmt.Fprintf(w, "Hello, %q", html.EscapeString(r.URL.Path))
fmt.Fprintf(w, "trying to set leader \n")
s := r.URL.Path
fmt.Fprintf(w, "\n\n", s, " \n\n")
x := html.EscapeString(r.URL.Path)
fmt.Fprintf(w, "\n x => ", x, " \n")
parts1 := strings.Split(s, "%")
for k1, v1 := range parts1 {
fmt.Fprintf(w, "\n k=", k1, ",v=", v1)
}
//fmt.Fprintf(w, parts[1]," \n")
u, err := url.Parse(s)
if err != nil {
fmt.Fprintf(w, "error receiving parameters, "+err.Error())
} else {
//fmt.Fprintf(w, "raw: ",u.RawQuery)
parts := strings.Split(u.Path, "/")
for k, v := range parts {
fmt.Fprintf(w, "\n k=", k, ",v=", v)
}
/*
if len(parts) != 2 {
fmt.Fprintf(w, "usage: setleader/ip-of-the-leader")
} else {
leaderIP := parts[1]
fmt.Fprintf(w, "leader = ",leaderIP)
}
*/
}
}
func markupById(id, text string) string {
color := generateRandomColorFromId(id)
format := "<span foreground=\"%s\">%s</span>"
return fmt.Sprintf(format,
html.EscapeString(color),
html.EscapeString(text))
}
//line home.ego:1
func Home(w io.Writer, p *Page) error {
//line home.ego:2
_, _ = io.WriteString(w, "\n\n")
//line home.ego:3
Header(w, p)
//line home.ego:4
_, _ = io.WriteString(w, "\n<h1>Hello ")
//line home.ego:4
_, _ = io.WriteString(w, html.EscapeString(fmt.Sprintf("%v", p.Title)))
//line home.ego:4
_, _ = io.WriteString(w, "</h1>\n\n<p>Here's a list of your favorite colors:</p>\n\n<ul>\n\t")
//line home.ego:9
for _, colorName := range p.FavoriteColors {
//line home.ego:10
_, _ = io.WriteString(w, "\n\t<li>")
//line home.ego:10
_, _ = io.WriteString(w, html.EscapeString(fmt.Sprintf("%v", colorName)))
//line home.ego:10
_, _ = io.WriteString(w, "</li>\n\t")
//line home.ego:11
}
//line home.ego:12
_, _ = io.WriteString(w, "\n</ul>\n")
//line home.ego:13
Footer(w, p)
//line home.ego:14
_, _ = io.WriteString(w, "\n")
return nil
}
func writeBrowsePage(w http.ResponseWriter, r *http.Request, diskSpace string, breadcrumbName []string, breadcrumbLink []string, listing []*pathEntry, uploadUrl string) {
shtml := assetAsString("static/index.html")
pathPart := assetAsString("static/path.htmlpart")
breadcrumbHtml := ""
for i, bn := range breadcrumbName {
bn = html.EscapeString(bn)
bl := html.EscapeString(breadcrumbLink[i])
if i < len(breadcrumbName)-1 {
breadcrumbHtml += " <li><a href='" + bl + "'>" + bn + "</a></li>"
} else {
breadcrumbHtml += " <li class='active'><a href='" + bl + "'>" + bn + "</a></li>"
}
}
pathHtml := ""
for _, path := range listing {
pp := strings.Replace(pathPart, "$PATH_LINK", path.pathLink, 1)
pp = strings.Replace(pp, "$PATH_ICON", path.pathIcon, 1)
pp = strings.Replace(pp, "$PATH_NAME", path.pathName, 1)
pp = strings.Replace(pp, "$FILE_SIZE", path.fileSize, 1)
pathHtml += pp
}
shtml = strings.Replace(shtml, "$DISK_SPACE", diskSpace, 1)
shtml = strings.Replace(shtml, "$BREADCRUMB", breadcrumbHtml, 1)
shtml = strings.Replace(shtml, "$DIRECTORY_LISTING", pathHtml, 1)
shtml = strings.Replace(shtml, "$UPLOAD_URL", uploadUrl, 1)
shtml = strings.Replace(shtml, "$PUBLIC_URL", public_url, 10)
fmt.Fprint(w, shtml)
}
func formatline(line string) (markup string) {
line = strings.Trim(line, "\t\r\n ")
if len(line) > 0 {
if strings.HasPrefix(line, ">") && !(strings.HasPrefix(line, ">>") && re_backlink.MatchString(strings.Split(line, " ")[0])) {
// le ebin meme arrows
markup += "<p><span class='memearrows'>"
markup += html.EscapeString(line)
markup += "</span></p>"
} else if strings.HasPrefix(line, "==") && strings.HasSuffix(line, "==") {
// redtext
markup += "<p><span class='redtext'>"
markup += html.EscapeString(line[2 : len(line)-2])
markup += "</span></p>"
} else {
// regular line
markup += "<p>"
// for each word
for _, word := range strings.Split(line, " ") {
// check for backlink
if re_backlink.MatchString(word) {
markup += backlink(word)
} else {
// linkify as needed
word = html.EscapeString(word)
markup += xurls.Strict.ReplaceAllString(word, `<a href="$1">$1</a>`)
}
markup += " "
}
markup += "</p>"
}
}
return
}
//line web/frontend/views/expenses_list.ego:1
func writeExpensesList(w io.Writer, v *ExpensesList) error {
//line web/frontend/views/expenses_list.ego:2
_, _ = io.WriteString(w, "\n\n<h1>Expenses</h1>\n\n")
//line web/frontend/views/expenses_list.ego:5
for _, e := range v.Expenses {
//line web/frontend/views/expenses_list.ego:6
_, _ = io.WriteString(w, "\n<div>\n ")
//line web/frontend/views/expenses_list.ego:7
_, _ = io.WriteString(w, html.EscapeString(fmt.Sprintf("%v", e.Description)))
//line web/frontend/views/expenses_list.ego:7
_, _ = io.WriteString(w, " - ")
//line web/frontend/views/expenses_list.ego:7
_, _ = io.WriteString(w, html.EscapeString(fmt.Sprintf("%v", e.Amount)))
//line web/frontend/views/expenses_list.ego:8
_, _ = io.WriteString(w, "\n</div>\n")
//line web/frontend/views/expenses_list.ego:9
}
//line web/frontend/views/expenses_list.ego:10
_, _ = io.WriteString(w, "\n\n<h1>New Expense</h1>\n\n")
//line web/frontend/views/expenses_list.ego:13
new(ExpenseForm).Render(w)
//line web/frontend/views/expenses_list.ego:14
_, _ = io.WriteString(w, "\n")
return nil
}
func (g *Graph) targetURL(a *String) string {
if _, ok := g.TargetByName[a]; ok {
return fmt.Sprintf("<a href=\"/target?t=%s\">%s</a>\n", a.String(), html.EscapeString(a.String()))
} else {
return html.EscapeString(a.String())
}
}
// computes inline diff for the given line
func (diffSection *DiffSection) GetComputedInlineDiffFor(diffLine *DiffLine) template.HTML {
if setting.Git.DisableDiffHighlight {
return template.HTML(html.EscapeString(diffLine.Content[1:]))
}
var (
compareDiffLine *DiffLine
diff1 string
diff2 string
)
// try to find equivalent diff line. ignore, otherwise
switch diffLine.Type {
case DIFF_LINE_ADD:
compareDiffLine = diffSection.GetLine(DIFF_LINE_DEL, diffLine.RightIdx)
if compareDiffLine == nil {
return template.HTML(html.EscapeString(diffLine.Content))
}
diff1 = compareDiffLine.Content
diff2 = diffLine.Content
case DIFF_LINE_DEL:
compareDiffLine = diffSection.GetLine(DIFF_LINE_ADD, diffLine.LeftIdx)
if compareDiffLine == nil {
return template.HTML(html.EscapeString(diffLine.Content))
}
diff1 = diffLine.Content
diff2 = compareDiffLine.Content
default:
return template.HTML(html.EscapeString(diffLine.Content))
}
diffRecord := diffMatchPatch.DiffMain(diff1[1:], diff2[1:], true)
diffRecord = diffMatchPatch.DiffCleanupEfficiency(diffRecord)
return diffToHTML(diffRecord, diffLine.Type)
}
func writeDiffHTML(out *bytes.Buffer, from, to, header string) {
dmp := diffmatchpatch.New()
diff := dmp.DiffMain(from, to, true)
diff = dmp.DiffCleanupSemantic(diff)
out.WriteString("<h1>" + html.EscapeString(header) + "</h1>\n<pre>")
// write the diff
for _, chunk := range diff {
txt := html.EscapeString(chunk.Text)
txt = strings.Replace(txt, "\n", "↩\n", -1)
switch chunk.Type {
case diffmatchpatch.DiffInsert:
out.WriteString(`<ins style="background:#e6ffe6;">`)
out.WriteString(txt)
out.WriteString(`</ins>`)
case diffmatchpatch.DiffDelete:
out.WriteString(`<del style="background:#ffe6e6;">`)
out.WriteString(txt)
out.WriteString(`</del>`)
case diffmatchpatch.DiffEqual:
out.WriteString(`<span>`)
out.WriteString(txt)
out.WriteString(`</span>`)
}
}
if out.Len() > MaxDetailsLen {
out.Truncate(MaxDetailsLen)
out.WriteString("\n\n[TRUNCATED]")
}
out.WriteString("</pre>")
}
func diffToHTML(diffs []diffmatchpatch.Diff, lineType DiffLineType) template.HTML {
buf := bytes.NewBuffer(nil)
// Reproduce signs which are cutted for inline diff before.
switch lineType {
case DIFF_LINE_ADD:
buf.WriteByte('+')
case DIFF_LINE_DEL:
buf.WriteByte('-')
}
for i := range diffs {
switch {
case diffs[i].Type == diffmatchpatch.DiffInsert && lineType == DIFF_LINE_ADD:
buf.Write(addedCodePrefix)
buf.WriteString(html.EscapeString(diffs[i].Text))
buf.Write(codeTagSuffix)
case diffs[i].Type == diffmatchpatch.DiffDelete && lineType == DIFF_LINE_DEL:
buf.Write(removedCodePrefix)
buf.WriteString(html.EscapeString(diffs[i].Text))
buf.Write(codeTagSuffix)
case diffs[i].Type == diffmatchpatch.DiffEqual:
buf.WriteString(html.EscapeString(diffs[i].Text))
}
}
return template.HTML(buf.Bytes())
}
func Handle(c HTTPContextLogger, f func() error, scopes ...string) {
defer func() {
if e := recover(); e != nil {
c.Errorf("PANIC\n%v\nRequest: %+v\nStack: %s", e, c.Req(), utils.Stack())
panic(e)
}
}()
err := c.CheckScopes(scopes)
if err == nil {
err = f()
}
if err != nil {
if errResponse, ok := err.(Responder); ok {
if err2 := errResponse.Respond(c); err2 != nil {
c.Resp().WriteHeader(500)
fmt.Fprintf(c.Resp(), html.EscapeString(fmt.Sprintf("Unable to render the proper error %+v: %v", err, err2)))
}
} else {
c.Resp().WriteHeader(500)
fmt.Fprintf(c.Resp(), html.EscapeString(fmt.Sprintf("%v", err)))
}
if c.Resp().Status() >= 500 {
c.Errorf("%v\n%v\n\n", c.Req().URL, err)
} else {
c.Warningf("%v\n%v\n\n", c.Req().URL, err)
}
stackErr := errors.Wrap(err, 1)
c.Infof("%s", stackErr.ErrorStack())
}
}
func main() {
raw := []string{
"hello",
"<i>Hello</i>",
"alert('hello');",
"foo & bar",
`"how are you?" He asked.`,
}
log.Println("html.EscapeString")
for _, s := range raw {
log.Printf("\t%s -> %s", s, html.EscapeString(s))
}
log.Println("html.UnescapeString(html.EscapeString)")
for _, s := range raw {
flipped := html.UnescapeString(html.EscapeString(s))
log.Printf("\t%s -> %s", s, flipped)
}
escaped := []string{
"á",
"»",
"·",
"<i>htllo</i>",
}
log.Println("html.UnescapeString")
for _, s := range escaped {
log.Printf("\t%s -> %s", s, html.UnescapeString(s))
}
}
// Should produce original html as seen by parser.
// Two differences: a) selfclosing tags are selfclosing in the output
// and b) attribute values and text is escaped.
func (n *Node) Html() (s string) {
s = "<" + n.Name
for _, a := range n.Attr {
s += " " + a.Key + "=\"" + html.EscapeString(a.Val) + "\""
}
if len(n.class) > 0 {
s += " class=\""
for i, c := range n.class {
if i > 0 {
s += " "
}
s += c
}
s += "\""
}
s += ">"
for _, c := range n.subs {
if c.Name == TEXT_NODE {
s += html.EscapeString(c.Text)
} else {
s += c.Html()
}
}
switch n.Name {
case "img", "meta", "br", "input":
s += " />"
default:
s += "</" + n.Name + ">"
}
return
}
// Formats the block content as html, without enclosing tags
func (b *BaseBlock) FormatHtmlText() string {
t := html.EscapeString(b.Text)
// store one more to be able to compute offsets[len(text)]
offsets := make([]int, len(b.Text)+1)
// compute byte offsets for utf8 string
off := 0
index := 0
for k, r := range b.Text {
offsets[index] = k + off
off += len([]rune(html.EscapeString(string([]rune{r})))) - 1
index++
}
offsets[index] = len(b.Text) + off
for _, s := range b.Spans {
begin := s.HtmlBeginTag()
end := s.HtmlEndTag()
t = t[:offsets[s.GetStart()]] + begin + t[offsets[s.GetStart()]:offsets[s.GetEnd()]] + end + t[offsets[s.GetEnd()]:]
for i := s.GetStart(); i < s.GetEnd(); i++ {
offsets[i] += len(begin)
}
for i := s.GetEnd(); i < len(offsets); i++ {
offsets[i] += len(begin) + len(end)
}
}
return t
}
// HTTP handler for _dumpchannel
func (h *handler) handleDumpChannel() error {
channelName := h.PathVar("channel")
since := h.getIntQuery("since", 0)
base.LogTo("HTTP", "Dump channel %q", channelName)
chanLog := h.db.GetChangeLog(channelName, since)
if chanLog == nil {
return base.HTTPErrorf(http.StatusNotFound, "no such channel")
}
title := fmt.Sprintf("/%s: “%s” Channel", html.EscapeString(h.db.Name), html.EscapeString(channelName))
h.setHeader("Content-Type", `text/html; charset="UTF-8"`)
h.response.Write([]byte(fmt.Sprintf(
`<!DOCTYPE html><html><head><title>%s</title></head><body>
<h1>%s</h1><code>
<p>Since = %d</p>
<table border=1>
`,
title, title, chanLog[0].Sequence-1)))
h.response.Write([]byte("\t<tr><th>Seq</th><th>Doc</th><th>Rev</th><th>Flags</th></tr>\n"))
for _, entry := range chanLog {
h.response.Write([]byte(fmt.Sprintf("\t<tr><td>%d</td><td>%s</td><td>%s</td><td>%08b</td>",
entry.Sequence,
html.EscapeString(entry.DocID), html.EscapeString(entry.RevID), entry.Flags)))
h.response.Write([]byte("</tr>\n"))
}
h.response.Write([]byte("</table>\n</code></html></body>"))
return nil
}
// AuthAuthenticate performs an API request for op=auth_authenticate
//
// This method requires one argument of type innGateApi.AuthAuthenticateRequest.
// See the ANTLabs API for more information regarding elements of the argument.
// The example below demonstrates how to send a request.
//
//Example:
// ant := innGateApi.Host{
// Host : "ant.example.com", //can be an IP or hostname
// }
// resp, err := ant.AuthAuthenticate(innGateApi.AuthAuthenticateRequest{Code: "abc123"})
// if(err != nil){ panic(err) }
// fmt.Println("\n\nResult of authentication request:", resp.Result)
func (api *Host) AuthAuthenticate(request AuthAuthenticateRequest) (result *authAuthenticateResponse, err error) {
ant := api.ant()
request.op = "auth_authenticate"
result = &authAuthenticateResponse{}
query := "api_password="******"&op=" + request.op
if request.Code != "" {
query += "&code=" + request.Code
}
if request.UserId != "" {
query += "&userid=" + html.EscapeString(request.UserId)
}
if request.Password != "" {
query += "&password="******"radiusattrs":
result.RadiusAttrs = strings.Split(v[2], "|")
}
}
return result, nil
}
/*
添加管理员
*/
func (this *Model) AddUser(name, psw string) error {
username := html.EscapeString(name)
password := html.EscapeString(psw)
db, err := sql.Open("mysql", "root:dumx@tcp(localhost:3306)/myblog?charset=utf8")
if nil != err {
logger.Errorln(err)
return err
}
defer db.Close()
querySql := "select 1 from myblog.users WHERE name = ' " + username + "'"
rows, err := db.Query(querySql)
if nil != err {
logger.Errorln(err)
return err
}
if rows.Next() {
return errors.New("user " + username + "exsited")
}
insertSql := "INSERT myblog.users SET name=?, password=?"
stmt, err := db.Prepare(insertSql)
if nil != err {
logger.Errorln(err)
return err
}
defer stmt.Close()
_, err = stmt.Exec(username, password)
if nil != err {
logger.Errorln(err)
return err
}
return nil
}
// AuthLogout performs the an API request for op=auth_logout
//
// This method requires one argument of type innGateApi.AuthLoginRequest.
// See the ANTLabs API for more information regarding elements of the argument.
// The example below demonstrates how to send a request.
//
//Example:
// ant := innGateApi.Host{
// Host : "ant.example.com", //can be an IP or hostname
// }
// resp, err := ant.AuthLogout(innGateApi.AuthLogoutRequest{Sid : "86cb1a5deb036467a9c2bc36e13971ef"})
// if(err != nil){ panic(err) }
// fmt.Println("\n\nLogout result:", resp.Result)
func (api *Host) AuthLogout(request AuthLogoutRequest) (result *authLogoutResponse, err error) {
ant := api.ant()
request.op = "auth_logout"
result = &authLogoutResponse{}
query := "api_password="******"&op=" + request.op
if request.Sid != "" {
query += "&sid=" + html.EscapeString(request.Sid)
}
if request.ClientMac != "" {
query += "&client_mac=" + html.EscapeString(request.ClientMac)
}
parsed_body, err := ant.InnGateApiRequest(query)
if err != nil {
return nil, err
}
err = result.findCommoners(parsed_body)
//if( err != nil){ return nil, err }
for _, v := range parsed_body {
switch v[1] {
case "accounting":
result.Accounting = v[2]
case "sid":
result.Sid = v[2]
case "client_mac":
result.ClientMac = v[2]
}
}
return result, nil
}
func xml_balance(w http.ResponseWriter, r *http.Request) {
if !ipchecker(r) {
return
}
w.Header()["Content-Type"] = []string{"text/xml"}
w.Write([]byte("<unspent>"))
wallet.LockBal()
for i := range wallet.MyBalance {
w.Write([]byte("<output>"))
fmt.Fprint(w, "<txid>", btc.NewUint256(wallet.MyBalance[i].TxPrevOut.Hash[:]).String(), "</txid>")
fmt.Fprint(w, "<vout>", wallet.MyBalance[i].TxPrevOut.Vout, "</vout>")
fmt.Fprint(w, "<value>", wallet.MyBalance[i].Value, "</value>")
fmt.Fprint(w, "<inblock>", wallet.MyBalance[i].MinedAt, "</inblock>")
fmt.Fprint(w, "<blocktime>", get_block_time(wallet.MyBalance[i].MinedAt), "</blocktime>")
fmt.Fprint(w, "<addr>", wallet.MyBalance[i].BtcAddr.String(), "</addr>")
fmt.Fprint(w, "<wallet>", html.EscapeString(wallet.MyBalance[i].BtcAddr.Extra.Wallet), "</wallet>")
fmt.Fprint(w, "<label>", html.EscapeString(wallet.MyBalance[i].BtcAddr.Extra.Label), "</label>")
fmt.Fprint(w, "<virgin>", fmt.Sprint(wallet.MyBalance[i].BtcAddr.Extra.Virgin), "</virgin>")
w.Write([]byte("</output>"))
}
wallet.UnlockBal()
w.Write([]byte("</unspent>"))
}
func apiSearch(store StuffStore, out http.ResponseWriter, r *http.Request) {
defer ElapsedPrint("Query", time.Now())
// Allow very brief caching, so that editing the query does not
// necessarily has to trigger a new server roundtrip.
out.Header().Set("Cache-Control", "max-age=10")
query := r.FormValue("q")
if query == "" {
out.Write([]byte("{\"count\":0, \"info\":\"\", \"items\":[]}"))
return
}
start := time.Now()
searchResults := store.Search(query)
elapsed := time.Now().Sub(start)
elapsed = time.Microsecond * ((elapsed + time.Microsecond/2) / time.Microsecond)
outlen := 24 // Limit max output
if len(searchResults) < outlen {
outlen = len(searchResults)
}
jsonResult := &JsonSearchResult{
Count: len(searchResults),
Info: fmt.Sprintf("%d results (%s)", len(searchResults), elapsed),
Items: make([]JsonSearchResultRecord, outlen),
}
for i := 0; i < outlen; i++ {
var c = searchResults[i]
jsonResult.Items[i].Id = c.Id
jsonResult.Items[i].Label = "<b>" + html.EscapeString(c.Value) + "</b> " +
html.EscapeString(c.Description) +
fmt.Sprintf(" <span class='idtxt'>(ID:%d)</span>", c.Id)
}
json, _ := json.Marshal(jsonResult)
out.Write(json)
}