// Symbol looks up the program counters listed in the request, // responding with a table mapping program counters to function names. // The package initialization registers it as /debug/pprof/symbol. func Symbol(c *http.Conn, r *http.Request) { c.SetHeader("content-type", "text/plain; charset=utf-8") // We don't know how many symbols we have, but we // do have symbol information. Pprof only cares whether // this number is 0 (no symbols available) or > 0. fmt.Fprintf(c, "num_symbols: 1\n") var b *bufio.Reader if r.Method == "POST" { b = bufio.NewReader(r.Body) } else { b = bufio.NewReader(strings.NewReader(r.URL.RawQuery)) } for { w, err := b.ReadSlice('+') if err == nil { w = w[0 : len(w)-1] // trim + } pc, _ := strconv.Btoui64(string(w), 0) if pc != 0 { f := runtime.FuncForPC(uintptr(pc)) if f != nil { fmt.Fprintf(c, "%#x %s\n", pc, f.Name()) } } // Wait until here to check for err; the last // symbol will have an err because it doesn't end in +. if err != nil { break } } }
func TWITTER_REPLIES(c *http.Conn, req *http.Request) { log.Stderrf(">REPLIES:"); s := session_service.GetSession(c,req); for k,v := range s.Data { log.Stderrf("session kv:%s:%s", k, v); } auth_token, atx := s.Data["oauth_token"]; if atx { log.Stderrf("TOKEN FOUND!"); auth_token_secret := s.Data["oauth_token_secret"]; r, finalUrl, err := twitter_client.MakeRequest("http://twitter.com/statuses/mentions.json", map[string]string{"oauth_token":auth_token}, auth_token_secret, false); //{"since_id":s.last_reply_id}) if err != nil { log.Stderrf(":REPLIES:err:%s",err); } else { log.Stderrf(":REPLIES:r:%s:finalUrl:%s", r, finalUrl); b, _ := io.ReadAll(r.Body); print ("REPLIES!"); str := bytes.NewBuffer(b).String(); println (str); j, ok, errtok := json.StringToJson(str); log.Stderr("REPLIES:j:%s:ok:%s:errtok:%s", j, ok, errtok); c.Write(strings.Bytes(j.String())); } } else { log.Stderrf("NO TOKEN FOUND!"); http.Redirect(c, "/login/twitter?returnto=/twitter/replies", http.StatusFound); // should be 303 instead of 302? } }
// exec a program, redirecting output func DateServer(c *http.Conn, req *http.Request) { c.SetHeader("content-type", "text/plain; charset=utf-8") r, w, err := os.Pipe() if err != nil { fmt.Fprintf(c, "pipe: %s\n", err) return } pid, err := os.ForkExec("/bin/date", []string{"date"}, os.Environ(), "", []*os.File{nil, w, w}) defer r.Close() w.Close() if err != nil { fmt.Fprintf(c, "fork/exec: %s\n", err) return } io.Copy(c, r) wait, err := os.Wait(pid, 0) if err != nil { fmt.Fprintf(c, "wait: %s\n", err) return } if !wait.Exited() || wait.ExitStatus() != 0 { fmt.Fprintf(c, "date: %v\n", wait) return } }
func Send(c *http.Conn, req *http.Request) { query_params, _ := http.ParseQuery(req.URL.RawQuery) arg_game, ok_game := query_params["game"] arg_msg, ok_msg := query_params["msg"] if !ok_game { c.Write([]byte("Game parameter not set")) return } if !ok_msg { c.Write([]byte("Msg parameter not set")) return } game := arg_game[0] msg := arg_msg[0] params := strings.Split(game, ",", 2) if len(params) != 2 { c.Write([]byte("Malformed game parameter")) return } game_id, player_id := params[0], params[1] game_instance := room.Find(game_id) if room == nil { c.Write([]byte("Game not found")) return } result := game_instance.Send(player_id, msg) c.Write([]byte(result)) }
func serveHTMLDoc(c *http.Conn, r *http.Request, path string) { // get HTML body contents src, err := ioutil.ReadFile(path) if err != nil { log.Stderrf("%v", err) http.NotFound(c, r) return } // if it begins with "<!DOCTYPE " assume it is standalone // html that doesn't need the template wrapping. if bytes.HasPrefix(src, strings.Bytes("<!DOCTYPE ")) { c.Write(src) return } // if it's the language spec, add tags to EBNF productions if strings.HasSuffix(path, "go_spec.html") { var buf bytes.Buffer linkify(&buf, src) src = buf.Bytes() } title := commentText(src) servePage(c, title, "", src) }
// url: /blog/entry/add func AddEntry(c *http.Conn, req *http.Request) { req.ParseForm(); heading, body := req.FormValue("heading"), req.FormValue("body"); if len(heading) > 0 && len(body) > 0 { blog.AddEntry(heading, body) } c.SetHeader("Location", "/blog"); c.WriteHeader(http.StatusFound); }
func (s *Swif) handleError(code int, c *http.Conn) { switch code { case http.StatusBadRequest: c.WriteHeader(code) io.WriteString(c, "Invalid Request") default: c.WriteHeader(http.StatusBadRequest) io.WriteString(c, "Invalid Request") } }
// hello world, the web server func HelloServer(c *http.Conn, req *http.Request) { var creq CRequest; creq.conn = c; creq.req = req; //fmt.Printf("%s\n", creq.req); var e os.Error; creq.rwc, creq.buf, e = c.Hijack(); if (e!=nil) {} req_channel <- creq; }
func FlagServer(c *http.Conn, req *http.Request) { c.SetHeader("content-type", "text/plain; charset=utf-8") fmt.Fprint(c, "Flags:\n") flag.VisitAll(func(f *flag.Flag) { if f.Value.String() != f.DefValue { fmt.Fprintf(c, "%s = %s [default = %s]\n", f.Name, f.Value.String(), f.DefValue) } else { fmt.Fprintf(c, "%s = %s\n", f.Name, f.Value.String()) } }) }
func (s FileServer) ServeHTTP(c *http.Conn, req *http.Request) { content, err := ioutil.ReadFile(s.loc) if err != nil { log.Stderr(err) } else { // get mime type mimeType := mime.TypeByExtension(path.Ext(s.loc)) // TODO cache this c.SetHeader("Content-Type", mimeType) fmt.Fprintf(c, "%s", content) } }
func TestCode2(c *http.Conn, req *http.Request) { dump, err := http.DumpRequest(req, true) if err != nil { io.WriteString(c, err.String()) return } _, err = c.Write(dump) if err != nil { io.WriteString(c, err.String()) return } log.Stdout(string(dump)) }
func Wait(c *http.Conn, req *http.Request) { query_params, _ := http.ParseQuery(req.URL.RawQuery) arg_owner_id, ok_owner_id := query_params["owner_id"] if ok_owner_id { fmt.Println("Create owner_id=", arg_owner_id) owner_id := arg_owner_id[0] game_id := room.Wait(owner_id) fmt.Println("Create ", game_id) c.Write([]byte(game_id)) } else { c.Write([]byte("Parameters not specified correctly")) } }
func Connect(c *http.Conn, req *http.Request) { query_params, _ := http.ParseQuery(req.URL.RawQuery) arg_owner, ok_owner := query_params["owner"] if ok_owner { fmt.Println("Connect owner=", arg_owner) owner := arg_owner[0] owner_id := room.Connect(owner) fmt.Println("Connected as ", owner_id) c.Write([]byte(owner_id)) } else { c.Write([]byte("Parameters not specified correctly")) } }
func expvarHandler(c *http.Conn, req *http.Request) { c.SetHeader("content-type", "application/json; charset=utf-8") fmt.Fprintf(c, "{\n") first := true for name, value := range vars { if !first { fmt.Fprintf(c, ",\n") } first = false fmt.Fprintf(c, "%q: %s", name, value) } fmt.Fprintf(c, "\n}\n") }
// url: /blog/comment/add func AddComment(c *http.Conn, req *http.Request) { req.ParseForm(); entryIDString, text := req.FormValue("entry_id"), req.FormValue("text"); if len(entryIDString) > 0 && len(text) > 0 { if entryID, parseErr := strconv.Atoi(entryIDString); parseErr == nil { if foundEntry := blog.FindEntry(entryID); foundEntry != nil { foundEntry.AddComment(text); } } } c.SetHeader("Location", "/blog/entry/" + entryIDString); c.WriteHeader(http.StatusFound); }
func (ss *SessionService) StartSession(c *http.Conn, req *http.Request, d map[string]string) *persist.Model { // d was json.Json log.Stderrf(">StartSession:"); // TODO: uuid4 generate sid instead of "sid-" plus random // s := new(Session); // s.Id = ss.Name + "-" + strconv.Itoa(rand.Int()); // s.Data = d; s := ss.persist_service.New(ss.Name+"-"+strconv.Itoa(rand.Int()), d); // TODO: refactor out cookie things // TODO: cookie domain c.SetHeader("Set-Cookie", ss.Name+"=" + s.Id + "; expires=Fri, 31-Dec-2011 23:59:59 GMT; path=/; domain=sol.caveman.org"); // TODO: real thing not unprotected (threadwise) in-memory only "sessions" // ss.sessions[s.Id] = *s; return s; }
// ServeHTTP implements the http.Handler interface for a Web Socket. func (f Draft75Handler) ServeHTTP(c *http.Conn, req *http.Request) { if req.Method != "GET" || req.Proto != "HTTP/1.1" { c.WriteHeader(http.StatusBadRequest) io.WriteString(c, "Unexpected request") return } if req.Header["Upgrade"] != "WebSocket" { c.WriteHeader(http.StatusBadRequest) io.WriteString(c, "missing Upgrade: WebSocket header") return } if req.Header["Connection"] != "Upgrade" { c.WriteHeader(http.StatusBadRequest) io.WriteString(c, "missing Connection: Upgrade header") return } origin, found := req.Header["Origin"] if !found { c.WriteHeader(http.StatusBadRequest) io.WriteString(c, "missing Origin header") return } rwc, buf, err := c.Hijack() if err != nil { panic("Hijack failed: " + err.String()) return } defer rwc.Close() location := "ws://" + req.Host + req.URL.RawPath // TODO(ukai): verify origin,location,protocol. buf.WriteString("HTTP/1.1 101 Web Socket Protocol Handshake\r\n") buf.WriteString("Upgrade: WebSocket\r\n") buf.WriteString("Connection: Upgrade\r\n") buf.WriteString("WebSocket-Origin: " + origin + "\r\n") buf.WriteString("WebSocket-Location: " + location + "\r\n") protocol, found := req.Header["Websocket-Protocol"] // canonical header key of WebSocket-Protocol. if found { buf.WriteString("WebSocket-Protocol: " + protocol + "\r\n") } buf.WriteString("\r\n") if err := buf.Flush(); err != nil { return } ws := newConn(origin, location, protocol, buf, rwc) f(ws) }
func serveError502(conn *http.Conn, host string) { conn.WriteHeader(http.StatusBadGateway) conn.SetHeader(contentType, textHTML) conn.SetHeader(contentLength, error502Length) conn.Write(error502) logRequest(http.StatusBadGateway, host, conn) }
func FileServer(c *http.Conn, req *http.Request) { c.SetHeader("content-type", "text/plain; charset=utf-8") pathVar.Add(req.URL.Path, 1) path := *webroot + req.URL.Path // TODO: insecure: use os.CleanName f, err := os.Open(path, os.O_RDONLY, 0) if err != nil { c.WriteHeader(http.StatusNotFound) fmt.Fprintf(c, "open %s: %v\n", path, err) return } n, _ := io.Copy(c, f) fmt.Fprintf(c, "[%d bytes]\n", n) f.Close() }
func home(c *http.Conn, req *http.Request) { if req.Method == "POST" && len(strings.TrimSpace(req.FormValue("code"))) > 0 { paste := savePaste(req.FormValue("code"), req.FormValue("private") != "") c.SetHeader("Content-type", "text/plain; charset=utf-8") c.Write(strings.Bytes("http://" + DOMAIN + "/view/" + paste + "\n")) } else { theme := curTheme(req) homePage.Execute(map[string]string{ "theme": theme, "theme_select": themeSelect(theme), }, c) } }
func handlePngChart(c *http.Conn, req *http.Request) { // Fehlerhandler registrieren defer handleErrors("handlePngChart", true) log("Erzeuge PNG Chart...") // CSV-Datei einlesen data, err := readCsvFile("./table.csv") if err == nil { // Content-Type im HTTP-Header c.SetHeader("Content-Type", "image/png") // Chart erzeugen und in den Ausgabestrom schreiben drawPngChart(600, 400, data, c) log("PNG Chart ausgeliefert.") } else { log("PNG Chart konnte nicht erstellt werden.") } }
// url: /blog func Index(c *http.Conn, req *http.Request) { revEntries := blog.EntriesReversed(); frontPageEntries := make([]frontPageEntry, len(revEntries)); for i, e := range revEntries { frontPageEntries[i].Entry = e; frontPageEntries[i].CommentCount = e.Comments.Len(); } if tmpl, err := loadTemplate("index.html"); err == nil { tmpl.Execute(frontPageEntries, c); } else { c.SetHeader("Content-Type", "text/plain; charset=utf-8"); c.WriteHeader(http.StatusInternalServerError); io.WriteString(c, "500 internal server error\n"); } }
func exec(c *http.Conn, args []string) (status int) { r, w, err := os.Pipe(); if err != nil { log.Stderrf("os.Pipe(): %v\n", err); return 2; } bin := args[0]; fds := []*os.File{nil, w, w}; if *verbose { log.Stderrf("executing %v", args); } pid, err := os.ForkExec(bin, args, os.Environ(), goroot, fds); defer r.Close(); w.Close(); if err != nil { log.Stderrf("os.ForkExec(%q): %v\n", bin, err); return 2; } var buf bytes.Buffer; io.Copy(&buf, r); wait, err := os.Wait(pid, 0); if err != nil { os.Stderr.Write(buf.Bytes()); log.Stderrf("os.Wait(%d, 0): %v\n", pid, err); return 2; } status = wait.ExitStatus(); if !wait.Exited() || status > 1 { os.Stderr.Write(buf.Bytes()); log.Stderrf("executing %v failed (exit status = %d)", args, status); return; } if *verbose { os.Stderr.Write(buf.Bytes()); } if c != nil { c.SetHeader("content-type", "text/plain; charset=utf-8"); c.Write(buf.Bytes()); } return; }
func (r *Robot) ServeHTTP(conn *http.Conn, req *http.Request) { log("Path:", req.URL.Path) switch req.URL.Path { case r.pathPrefix + "/robot/jsonrpc": // decode request bundle body, _ := ioutil.ReadAll(req.Body) logf("Request:\n%s\n\n", body) b := new(requestBundle) err := json.Unmarshal(body, b) if err != nil { http.Error(conn, "Bad request", http.StatusBadRequest) return } oq := NewOperationQueue() w := NewWavelet(b.Wavelet, b.Blips, r, oq) // handle events for _, e := range b.Events { if handler, ok := r.handlers[e.Type]; ok { handler(e, w) } } // output operation queue q, _ := json.Marshal(oq.pending) logf("Response:\n%s\n\n", q) conn.Write(q) case r.pathPrefix + "/capabilities.xml": fmt.Fprintf(conn, capabilitiesXMLstart, r.version()) for k, _ := range r.handlers { fmt.Fprintf(conn, capabilityXML, k) } fmt.Fprint(conn, capabilitiesXMLend) case r.pathPrefix + "/robot/profile": p, _ := json.Marshal(map[string]string{ "profileUrl": r.profileUrl, "imageUrl": r.imageUrl, "name": r.name, }) conn.Write(p) default: http.NotFound(conn, req) } }
func (redirector *Redirector) ServeHTTP(conn *http.Conn, req *http.Request) { var url string if len(req.URL.RawQuery) > 0 { url = fmt.Sprintf(redirectURLQuery, redirector.url, req.URL.Path, req.URL.RawQuery) } else { url = fmt.Sprintf(redirectURL, redirector.url, req.URL.Path) } if len(url) == 0 { url = "/" } conn.SetHeader("Location", url) conn.WriteHeader(http.StatusMovedPermanently) fmt.Fprintf(conn, redirectHTML, url) logRequest(http.StatusMovedPermanently, req.Host, conn) }
func httpHandler(c *http.Conn, req *http.Request) { path := req.URL.Path //try to serve a static file if strings.HasPrefix(path, "/static/") { staticFile := path[8:] if len(staticFile) > 0 { http.ServeFile(c, req, "static/"+staticFile) return } } req.ParseForm() resp := routeHandler((*Request)(req)) c.WriteHeader(resp.StatusCode) if resp.Body != nil { body, _ := ioutil.ReadAll(resp.Body) c.Write(body) } }
func (this *router) ServeHTTP(conn *http.Conn, httpReq *http.Request) { var reqs []*Request contentType := httpReq.Header["Content-Type"] switch { default: http.Error(conn, fmt.Sprintf("Illegal content type %v", contentType), http.StatusInternalServerError) return case strings.HasPrefix(contentType, "application/json"): reqs = this.decodeTransaction(httpReq.Body) case strings.HasPrefix(contentType, "application/x-www-form-urlencoded"): httpReq.ParseForm() reqs = this.decodeFormPost(httpReq.Form) } resps := new(vector.Vector) for _, req := range reqs { resps.Push(this.respond(req)) } conn.SetHeader("Content-Type", "application/json; charset=utf-8") json.NewEncoder(&keysToLowerWriter{conn}).Encode(resps) }
func createHandler(c *http.Conn, r *http.Request) { // read destAddr destAddr, err := ioutil.ReadAll(r.Body) r.Body.Close() if err != nil { http.Error(c, "Could not read destAddr", http.StatusInternalServerError) return } key := genKey() p, err := NewProxy(key, string(destAddr)) if err != nil { http.Error(c, "Could not connect", http.StatusInternalServerError) return } createQueue <- p c.Write([]byte(key)) }
func (set *TileServer) ServeHTTP(conn *http.Conn, req *http.Request) { req.ParseForm() var x, y, zoom int x, err := strconv.Atoi(req.Form["x"][0]) if err == nil { y, err = strconv.Atoi(req.Form["y"][0]) } if err == nil { zoom, err = strconv.Atoi(req.Form["z"][0]) } if err != nil { fmt.Println("Err:", err.String()) conn.WriteHeader(404) return } tile := set.GetTile(x, y, zoom) if tile == nil { fmt.Println("No tile at", x, y, zoom) conn.WriteHeader(404) return } conn.Write(tile) }
func add(c *http.Conn, req *http.Request) { if req.Method == "POST" && len(strings.TrimSpace(req.FormValue("code"))) > 0 { paste := savePaste(req.FormValue("code"), req.FormValue("private") != "") c.SetHeader("Location", "/view/"+paste) c.WriteHeader(http.StatusFound) } else { c.Write(strings.Bytes("No code submitted.\n")) } }