Subversion Repositories openrisc

// Copyright 2011 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// This file implements CGI from the perspective of a child
// process.

package cgi

import (
        "bufio"
        "crypto/tls"
        "errors"
        "fmt"
        "io"
        "io/ioutil"
        "net"
        "net/http"
        "net/url"
        "os"
        "strconv"
        "strings"
)

// Request returns the HTTP request as represented in the current
// environment. This assumes the current program is being run
// by a web server in a CGI environment.
// The returned Request's Body is populated, if applicable.
func Request() (*http.Request, error) {
        r, err := RequestFromMap(envMap(os.Environ()))
        if err != nil {
                return nil, err
        }
        if r.ContentLength > 0 {
                r.Body = ioutil.NopCloser(io.LimitReader(os.Stdin, r.ContentLength))
        }
        return r, nil
}

func envMap(env []string) map[string]string {
        m := make(map[string]string)
        for _, kv := range env {
                if idx := strings.Index(kv, "="); idx != -1 {
                        m[kv[:idx]] = kv[idx+1:]
                }
        }
        return m
}

// RequestFromMap creates an http.Request from CGI variables.
// The returned Request's Body field is not populated.
func RequestFromMap(params map[string]string) (*http.Request, error) {
        r := new(http.Request)
        r.Method = params["REQUEST_METHOD"]
        if r.Method == "" {
                return nil, errors.New("cgi: no REQUEST_METHOD in environment")
        }

        r.Proto = params["SERVER_PROTOCOL"]
        var ok bool
        r.ProtoMajor, r.ProtoMinor, ok = http.ParseHTTPVersion(r.Proto)
        if !ok {
                return nil, errors.New("cgi: invalid SERVER_PROTOCOL version")
        }

        r.Close = true
        r.Trailer = http.Header{}
        r.Header = http.Header{}

        r.Host = params["HTTP_HOST"]

        if lenstr := params["CONTENT_LENGTH"]; lenstr != "" {
                clen, err := strconv.ParseInt(lenstr, 10, 64)
                if err != nil {
                        return nil, errors.New("cgi: bad CONTENT_LENGTH in environment: " + lenstr)
                }
                r.ContentLength = clen
        }

        if ct := params["CONTENT_TYPE"]; ct != "" {
                r.Header.Set("Content-Type", ct)
        }

        // Copy "HTTP_FOO_BAR" variables to "Foo-Bar" Headers
        for k, v := range params {
                if !strings.HasPrefix(k, "HTTP_") || k == "HTTP_HOST" {
                        continue
                }
                r.Header.Add(strings.Replace(k[5:], "_", "-", -1), v)
        }

        // TODO: cookies.  parsing them isn't exported, though.

        if r.Host != "" {
                // Hostname is provided, so we can reasonably construct a URL,
                // even if we have to assume 'http' for the scheme.
                rawurl := "http://" + r.Host + params["REQUEST_URI"]
                url, err := url.Parse(rawurl)
                if err != nil {
                        return nil, errors.New("cgi: failed to parse host and REQUEST_URI into a URL: " + rawurl)
                }
                r.URL = url
        }
        // Fallback logic if we don't have a Host header or the URL
        // failed to parse
        if r.URL == nil {
                uriStr := params["REQUEST_URI"]
                url, err := url.Parse(uriStr)
                if err != nil {
                        return nil, errors.New("cgi: failed to parse REQUEST_URI into a URL: " + uriStr)
                }
                r.URL = url
        }

        // There's apparently a de-facto standard for this.
        // http://docstore.mik.ua/orelly/linux/cgi/ch03_02.htm#ch03-35636
        if s := params["HTTPS"]; s == "on" || s == "ON" || s == "1" {
                r.TLS = &tls.ConnectionState{HandshakeComplete: true}
        }

        // Request.RemoteAddr has its port set by Go's standard http
        // server, so we do here too. We don't have one, though, so we
        // use a dummy one.
        r.RemoteAddr = net.JoinHostPort(params["REMOTE_ADDR"], "0")

        return r, nil
}

// Serve executes the provided Handler on the currently active CGI
// request, if any. If there's no current CGI environment
// an error is returned. The provided handler may be nil to use
// http.DefaultServeMux.
func Serve(handler http.Handler) error {
        req, err := Request()
        if err != nil {
                return err
        }
        if handler == nil {
                handler = http.DefaultServeMux
        }
        rw := &response{
                req:    req,
                header: make(http.Header),
                bufw:   bufio.NewWriter(os.Stdout),
        }
        handler.ServeHTTP(rw, req)
        if err = rw.bufw.Flush(); err != nil {
                return err
        }
        return nil
}

type response struct {
        req        *http.Request
        header     http.Header
        bufw       *bufio.Writer
        headerSent bool
}

func (r *response) Flush() {
        r.bufw.Flush()
}

func (r *response) Header() http.Header {
        return r.header
}

func (r *response) Write(p []byte) (n int, err error) {
        if !r.headerSent {
                r.WriteHeader(http.StatusOK)
        }
        return r.bufw.Write(p)
}

func (r *response) WriteHeader(code int) {
        if r.headerSent {
                // Note: explicitly using Stderr, as Stdout is our HTTP output.
                fmt.Fprintf(os.Stderr, "CGI attempted to write header twice on request for %s", r.req.URL)
                return
        }
        r.headerSent = true
        fmt.Fprintf(r.bufw, "Status: %d %s\r\n", code, http.StatusText(code))

        // Set a default Content-Type
        if _, hasType := r.header["Content-Type"]; !hasType {
                r.header.Add("Content-Type", "text/html; charset=utf-8")
        }

        r.header.Write(r.bufw)
        r.bufw.WriteString("\r\n")
        r.bufw.Flush()
}