code review 4893043: url: new package

src/pkg/http/server.go

 // Copyright 2009 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.
 
 // HTTP server.  See RFC 2616.
 
 // TODO(rsc):
 //      logging
 
 package http
@@ skipping 699 matching lines @@
                         NotFound(w, r)
                         return
                 }
                 r.URL.Path = r.URL.Path[len(prefix):]
                 h.ServeHTTP(w, r)
         })
 }
 
 // Redirect replies to the request with a redirect to url,
 // which may be a path relative to the request path.
-func Redirect(w ResponseWriter, r *Request, uri string, code int) {

[dsymonds, 2011/08/15 09:20:23]

uri -> urlStr

-        if u, err := url.Parse(uri); err == nil {
+func Redirect(w ResponseWriter, r *Request, urlStr string, code int) {
+        if u, err := url.Parse(urlStr); err == nil {
                 // If url was relative, make absolute by
                 // combining with request path.
                 // The browser would probably do this for us,
                 // but doing it ourselves is more reliable.
 
                 // NOTE(rsc): RFC 2616 says that the Location
                 // line must be an absolute URI, like
                 // "http://www.google.com/redirect/",
                 // not a path like "/redirect/".
                 // Unfortunately, we don't know what to
                 // put in the host name section to get the
                 // client to connect to us again, so we can't
                 // know the right absolute URI to send back.
                 // Because of this problem, no one pays attention
                 // to the RFC; they all send back just a new path.
                 // So do we.
                 oldpath := r.URL.Path
                 if oldpath == "" { // should not happen, but avoid a crash if it does
                         oldpath = "/"
                 }
                 if u.Scheme == "" {
                         // no leading http://server
-                        if uri == "" || uri[0] != '/' {
+                        if urlStr == "" || urlStr[0] != '/' {
                                 // make relative path absolute
                                 olddir, _ := path.Split(oldpath)
-                                uri = olddir + uri
+                                urlStr = olddir + urlStr
                         }
 
                         var query string
-                        if i := strings.Index(uri, "?"); i != -1 {
-                                uri, query = uri[:i], uri[i:]
+                        if i := strings.Index(urlStr, "?"); i != -1 {
+                                urlStr, query = urlStr[:i], urlStr[i:]
                         }
 
                         // clean up but preserve trailing slash
-                        trailing := uri[len(uri)-1] == '/'
-                        uri = path.Clean(uri)
-                        if trailing && uri[len(uri)-1] != '/' {
-                                uri += "/"
+                        trailing := urlStr[len(urlStr)-1] == '/'
+                        urlStr = path.Clean(urlStr)
+                        if trailing && urlStr[len(urlStr)-1] != '/' {
+                                urlStr += "/"
                         }
-                        uri += query
-                }
-        }
-
-        w.Header().Set("Location", uri)
+                        urlStr += query
+                }
+        }
+
+        w.Header().Set("Location", urlStr)
         w.WriteHeader(code)
 
         // RFC2616 recommends that a short note "SHOULD" be included in the
         // response because older user agents may not understand 301/307.
         // Shouldn't send the response for POST or HEAD; that leaves GET.
         if r.Method == "GET" {
-                note := "<a href=\"" + htmlEscape(uri) + "\">" + statusText[code] + "</a>.\n"
+                note := "<a href=\"" + htmlEscape(urlStr) + "\">" + statusText[code] + "</a>.\n"
                 fmt.Fprintln(w, note)
         }
 }
 
 func htmlEscape(s string) string {
         s = strings.Replace(s, "&", "&amp;", -1)
         s = strings.Replace(s, "<", "&lt;", -1)
         s = strings.Replace(s, ">", "&gt;", -1)
         s = strings.Replace(s, "\"", "&quot;", -1)
         s = strings.Replace(s, "'", "&apos;", -1)
@@ skipping 391 matching lines @@
 func (tw *timeoutWriter) WriteHeader(code int) {
         tw.mu.Lock()
         if tw.timedOut || tw.wroteHeader {
                 tw.mu.Unlock()
                 return
         }
         tw.wroteHeader = true
         tw.mu.Unlock()
         tw.w.WriteHeader(code)
 }