diff --git a/Godeps/Godeps.json b/Godeps/Godeps.json
new file mode 100644
index 0000000000000000000000000000000000000000..2d71c16f38ed4e7ac3cb6b0d3d7c357361cea729
--- /dev/null
+++ b/Godeps/Godeps.json
@@ -0,0 +1,50 @@
+{
+ "ImportPath": "git.autistici.org/ale/autoradio",
+ "GoVersion": "go1.4",
+ "Packages": [
+ "./..."
+ ],
+ "Deps": [
+ {
+ "ImportPath": "github.com/PuerkitoBio/ghost",
+ "Rev": "a0146f2f931611b8bfe40f07018c97a7c881c76a"
+ },
+ {
+ "ImportPath": "github.com/cactus/go-statsd-client/statsd",
+ "Rev": "a99092dcd2d2f2a604a6f2502ba9ebba6a1165e5"
+ },
+ {
+ "ImportPath": "github.com/coreos/go-etcd/etcd",
+ "Comment": "v0.2.0-rc1-127-g6fe04d5",
+ "Rev": "6fe04d580dfb71c9e34cbce2f4df9eefd1e1241e"
+ },
+ {
+ "ImportPath": "github.com/garyburd/redigo/redis",
+ "Rev": "08550c8cc5b9d419fc472629d749d33b98f1d785"
+ },
+ {
+ "ImportPath": "github.com/gonuts/commander",
+ "Rev": "f8ba4e959ca914268227c3ebbd7f6bf0bb35541a"
+ },
+ {
+ "ImportPath": "github.com/gonuts/flag",
+ "Rev": "741a6cbd37a30dedc93f817e7de6aaf0ca38a493"
+ },
+ {
+ "ImportPath": "github.com/gorilla/securecookie",
+ "Rev": "1b0c7f6e9ab3d7f500fd7d50c7ad835ff428139b"
+ },
+ {
+ "ImportPath": "github.com/jmcvetta/randutil",
+ "Rev": "53e1e064d354a2d879935e250c1445526d73b96c"
+ },
+ {
+ "ImportPath": "github.com/miekg/dns",
+ "Rev": "3f504e8dabd5d562e997d19ce0200aa41973e1b2"
+ },
+ {
+ "ImportPath": "github.com/nu7hatch/gouuid",
+ "Rev": "179d4d0c4d8d407a32af483c2354df1d2c91e6c3"
+ }
+ ]
+}
diff --git a/Godeps/Readme b/Godeps/Readme
new file mode 100644
index 0000000000000000000000000000000000000000..4cdaa53d56d71d3ec11dc34a2811ca57cb6fa35b
--- /dev/null
+++ b/Godeps/Readme
@@ -0,0 +1,5 @@
+This directory tree is generated automatically by godep.
+
+Please do not edit.
+
+See https://github.com/tools/godep for more information.
diff --git a/Godeps/_workspace/.gitignore b/Godeps/_workspace/.gitignore
new file mode 100644
index 0000000000000000000000000000000000000000..f037d684ef2bd64c0ed8a87d7e85977324b277de
--- /dev/null
+++ b/Godeps/_workspace/.gitignore
@@ -0,0 +1,2 @@
+/pkg
+/bin
diff --git a/Godeps/_workspace/src/github.com/PuerkitoBio/ghost/.gitignore b/Godeps/_workspace/src/github.com/PuerkitoBio/ghost/.gitignore
new file mode 100644
index 0000000000000000000000000000000000000000..05bd35e397261fa880911db686aa68003dc0e0bc
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/PuerkitoBio/ghost/.gitignore
@@ -0,0 +1,7 @@
+*.sublime-*
+.DS_Store
+#*#
+*~
+*.swp
+*.swo
+*.rdb
diff --git a/Godeps/_workspace/src/github.com/PuerkitoBio/ghost/LICENSE b/Godeps/_workspace/src/github.com/PuerkitoBio/ghost/LICENSE
new file mode 100644
index 0000000000000000000000000000000000000000..d88451f3f02ae9e1ff5c25100c59c729596c1494
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/PuerkitoBio/ghost/LICENSE
@@ -0,0 +1,12 @@
+Copyright (c) 2013, Martin Angers
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
+
+* Neither the name of the author nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/Godeps/_workspace/src/github.com/PuerkitoBio/ghost/README.md b/Godeps/_workspace/src/github.com/PuerkitoBio/ghost/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..5843b3eea3f0ae30cc9136fb73e97b3fba81ebba
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/PuerkitoBio/ghost/README.md
@@ -0,0 +1,83 @@
+# Ghost
+
+Ghost is a web development library loosely inspired by node's [Connect library][connect]. It provides a number of simple, single-responsibility HTTP handlers that can be combined to build a full-featured web server, and a generic template engine integration interface.
+
+It stays close to the metal, not abstracting Go's standard library away. As a matter of fact, any stdlib handler can be used with Ghost's handlers, they simply are `net/http.Handler`'s.
+
+## Installation and documentation
+
+`go get github.com/PuerkitoBio/ghost`
+
+[API reference][godoc]
+
+*Status* : Still under development, things will change.
+
+## Example
+
+See the /ghostest directory for a complete working example of a website built with Ghost. It shows all handlers and template support of Ghost.
+
+## Handlers
+
+Ghost offers the following handlers:
+
+* BasicAuthHandler : basic authentication support.
+* ContextHandler : key-value map provider for the duration of the request.
+* FaviconHandler : simple and efficient favicon renderer.
+* GZIPHandler : gzip-compresser for the body of the response.
+* LogHandler : fully customizable request logger.
+* PanicHandler : panic-catching handler to control the error response.
+* SessionHandler : store-agnostic server-side session provider.
+* StaticHandler : convenience handler that wraps a call to `net/http.ServeFile`.
+
+Two stores are provided for the session persistence, `MemoryStore`, an in-memory map that is not suited for production environment, and `RedisStore`, a more robust and scalable [redigo][]-based Redis store. Because of the generic `SessionStore` interface, custom stores can easily be created as needed.
+
+The `handlers` package also offers the `ChainableHandler` interface, which supports combining HTTP handlers in a sequential fashion, and the `ChainHandlers()` function that creates a new handler from the sequential combination of any number of handlers.
+
+As a convenience, all functions that take a `http.Handler` as argument also have a corresponding function with the `Func` suffix that take a `http.HandlerFunc` instead as argument. This saves the type-cast when a simple handler function is passed (for example, `SessionHandler()` and `SessionHandlerFunc()`).
+
+### Handlers Design
+
+The HTTP handlers such as Basic Auth and Context need to store some state information to provide their functionality. Instead of using variables and a mutex to control shared access, Ghost augments the `http.ResponseWriter` interface that is part of the Handler's `ServeHTTP()` function signature. Because this instance is unique for each request and is not shared, there is no locking involved to access the state information.
+
+However, when combining such handlers, Ghost needs a way to move through the chain of augmented ResponseWriters. This is why these *augmented writers* need to implement the `WrapWriter` interface. A single method is required, `WrappedWriter() http.ResponseWriter`, which returns the wrapped ResponseWriter.
+
+And to get back a specific augmented writer, the `GetResponseWriter()` function is provided. It takes a ResponseWriter and a predicate function as argument, and returns the requested specific writer using the *comma-ok* pattern. Example, for the session writer:
+
+```Go
+func getSessionWriter(w http.ResponseWriter) (*sessResponseWriter, bool) {
+ ss, ok := GetResponseWriter(w, func(tst http.ResponseWriter) bool {
+ _, ok := tst.(*sessResponseWriter)
+ return ok
+ })
+ if ok {
+ return ss.(*sessResponseWriter), true
+ }
+ return nil, false
+}
+```
+
+Ghost does not provide a muxer, there are already many great ones available, but I would recommend Go's native `http.ServeMux` or [pat][] because it has great features and plays well with Ghost's design. Gorilla's muxer is very popular, but since it depends on Gorilla's (mutex-based) context provider, this is redundant with Ghost's context.
+
+## Templates
+
+Ghost supports the following template engines:
+
+* Go's native templates (needs work, at the moment does not work with nested templates)
+* [Amber][]
+
+TODO : Go's mustache implementation.
+
+### Templates Design
+
+The template engines can be registered much in the same way as database drivers, just by importing for side effects (using `_ "import/path"`). The `init()` function of the template engine's package registers the template compiler with the correct file extension, and the engine can be used.
+
+## License
+
+The [BSD 3-Clause license][lic].
+
+[connect]: https://github.com/senchalabs/connect
+[godoc]: http://godoc.org/github.com/PuerkitoBio/ghost
+[lic]: http://opensource.org/licenses/BSD-3-Clause
+[redigo]: https://github.com/garyburd/redigo
+[pat]: https://github.com/bmizerany/pat
+[amber]: https://github.com/eknkc/amber
diff --git a/Godeps/_workspace/src/github.com/PuerkitoBio/ghost/app.go b/Godeps/_workspace/src/github.com/PuerkitoBio/ghost/app.go
new file mode 100644
index 0000000000000000000000000000000000000000..5635f4c2692f07fdf5ed60fb5f1913fa5562168a
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/PuerkitoBio/ghost/app.go
@@ -0,0 +1,12 @@
+package ghost
+
+import (
+ "log"
+)
+
+// Logging function, defaults to Go's native log.Printf function. The idea to use
+// this instead of a *log.Logger struct is that it can be set to any of log.{Printf,Fatalf, Panicf},
+// but also to more flexible userland loggers like SeeLog (https://github.com/cihub/seelog).
+// It could be set, for example, to SeeLog's Debugf function. Any function with the
+// signature func(fmt string, params ...interface{}).
+var LogFn = log.Printf
diff --git a/Godeps/_workspace/src/github.com/PuerkitoBio/ghost/ghostest/index.html b/Godeps/_workspace/src/github.com/PuerkitoBio/ghost/ghostest/index.html
new file mode 100644
index 0000000000000000000000000000000000000000..ec844b0c938668de22105fd71d44169106017af3
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/PuerkitoBio/ghost/ghostest/index.html
@@ -0,0 +1,22 @@
+<html>
+ <head>
+ <title>Ghost Test</title>
+ <link type="text/css" rel="stylesheet" href="/public/styles.css">
+ <link type="text/css" rel="stylesheet" href="/public/bootstrap-combined.min.css">
+ </head>
+ <body>
+ <h1>Welcome to Ghost Test</h1>
+ <img src="/public/logo.png" alt="peace" />
+ <ol>
+ <li><a href="/session">Session</a></li>
+ <li><a href="/session/auth">Authenticated Session</a></li>
+ <li><a href="/context">Chained Context</a></li>
+ <li><a href="/panic">Panic</a></li>
+ <li><a href="/public/styles.css">Styles.css</a></li>
+ <li><a href="/public/jquery-2.0.0.min.js">JQuery</a></li>
+ <li><a href="/public/logo.png">Logo</a></li>
+ </ol>
+
+ <script src="/public/jquery-2.0.0.min.js"></script>
+ </body>
+</html>
diff --git a/Godeps/_workspace/src/github.com/PuerkitoBio/ghost/ghostest/main.go b/Godeps/_workspace/src/github.com/PuerkitoBio/ghost/ghostest/main.go
new file mode 100644
index 0000000000000000000000000000000000000000..7f1d817e8501fdc7b04f7c20084f6274e1ac2e87
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/PuerkitoBio/ghost/ghostest/main.go
@@ -0,0 +1,169 @@
+// Ghostest is an interactive end-to-end Web site application to test
+// the ghost packages. It serves the following URLs, with the specified
+// features (handlers):
+//
+// / : panic;log;gzip;static; -> serve file index.html
+// /public/styles.css : panic;log;gzip;StripPrefix;FileServer; -> serve directory public/
+// /public/script.js : panic;log;gzip;StripPrefix;FileServer; -> serve directory public/
+// /public/logo.pn : panic;log;gzip;StripPrefix;FileServer; -> serve directory public/
+// /session : panic;log;gzip;session;context;Custom; -> serve dynamic Go template
+// /session/auth : panic;log;gzip;session;context;basicAuth;Custom; -> serve dynamic template
+// /panic : panic;log;gzip;Custom; -> panics
+// /context : panic;log;gzip;context;Custom1;Custom2; -> serve dynamic Amber template
+package main
+
+import (
+ "log"
+ "net/http"
+ "time"
+
+ "github.com/PuerkitoBio/ghost/handlers"
+ "github.com/PuerkitoBio/ghost/templates"
+ _ "github.com/PuerkitoBio/ghost/templates/amber"
+ _ "github.com/PuerkitoBio/ghost/templates/gotpl"
+ "github.com/bmizerany/pat"
+)
+
+const (
+ sessionPageTitle = "Session Page"
+ sessionPageAuthTitle = "Authenticated Session Page"
+ sessionPageKey = "txt"
+ contextPageKey = "time"
+ sessionExpiration = 10 // Session expires after 10 seconds
+)
+
+var (
+ // Create the common session store and secret
+ memStore = handlers.NewMemoryStore(1)
+ secret = "testimony of the ancients"
+)
+
+// The struct used to pass data to the session template.
+type sessionPageInfo struct {
+ SessionID string
+ Title string
+ Text string
+}
+
+// Authenticate the Basic Auth credentials.
+func authenticate(u, p string) (interface{}, bool) {
+ if u == "user" && p == "pwd" {
+ return u + p, true
+ }
+ return nil, false
+}
+
+// Handle the session page requests.
+func sessionPageRenderer(w handlers.GhostWriter, r *http.Request) {
+ var (
+ txt interface{}
+ data sessionPageInfo
+ title string
+ )
+
+ ssn := w.Session()
+ if r.Method == "GET" {
+ txt = ssn.Data[sessionPageKey]
+ } else {
+ txt = r.FormValue(sessionPageKey)
+ ssn.Data[sessionPageKey] = txt
+ }
+ if r.URL.Path == "/session/auth" {
+ title = sessionPageAuthTitle
+ } else {
+ title = sessionPageTitle
+ }
+ if txt != nil {
+ data = sessionPageInfo{ssn.ID(), title, txt.(string)}
+ } else {
+ data = sessionPageInfo{ssn.ID(), title, "[nil]"}
+ }
+ err := templates.Render("templates/session.tmpl", w, data)
+ if err != nil {
+ panic(err)
+ }
+}
+
+// Prepare the context value for the chained handlers context page.
+func setContext(w handlers.GhostWriter, r *http.Request) {
+ w.Context()[contextPageKey] = time.Now().String()
+}
+
+// Retrieve the context value and render the chained handlers context page.
+func renderContextPage(w handlers.GhostWriter, r *http.Request) {
+ err := templates.Render("templates/amber/context.amber",
+ w, &struct{ Val string }{w.Context()[contextPageKey].(string)})
+ if err != nil {
+ panic(err)
+ }
+}
+
+// Prepare the web server and kick it off.
+func main() {
+ // Blank the default logger's prefixes
+ log.SetFlags(0)
+
+ // Compile the dynamic templates (native Go templates and Amber
+ // templates are both registered via the for-side-effects-only imports)
+ err := templates.CompileDir("./templates/")
+ if err != nil {
+ panic(err)
+ }
+
+ // Set the simple routes for static files
+ mux := pat.New()
+ mux.Get("/", handlers.StaticFileHandler("./index.html"))
+ mux.Get("/public/", http.StripPrefix("/public/", http.FileServer(http.Dir("./public/"))))
+
+ // Set the more complex routes for session handling and dynamic page (same
+ // handler is used for both GET and POST).
+ ssnOpts := handlers.NewSessionOptions(memStore, secret)
+ ssnOpts.CookieTemplate.MaxAge = sessionExpiration
+ hSsn := handlers.SessionHandler(
+ handlers.ContextHandlerFunc(
+ handlers.GhostHandlerFunc(sessionPageRenderer),
+ 1),
+ ssnOpts)
+ mux.Get("/session", hSsn)
+ mux.Post("/session", hSsn)
+
+ hAuthSsn := handlers.BasicAuthHandler(hSsn, authenticate, "")
+ mux.Get("/session/auth", hAuthSsn)
+ mux.Post("/session/auth", hAuthSsn)
+
+ // Set the handler for the chained context route
+ mux.Get("/context", handlers.ContextHandler(handlers.ChainHandlerFuncs(
+ handlers.GhostHandlerFunc(setContext),
+ handlers.GhostHandlerFunc(renderContextPage)),
+ 1))
+
+ // Set the panic route, which simply panics
+ mux.Get("/panic", http.HandlerFunc(
+ func(w http.ResponseWriter, r *http.Request) {
+ panic("explicit panic")
+ }))
+
+ // Combine the top level handlers, that wrap around the muxer.
+ // Panic is the outermost, so that any panic is caught and responded to with a code 500.
+ // Log is next, so that every request is logged along with the URL, status code and response time.
+ // GZIP is then applied, so that content is compressed.
+ // Finally, the muxer finds the specific handler that applies to the route.
+ h := handlers.FaviconHandler(
+ handlers.PanicHandler(
+ handlers.LogHandler(
+ handlers.GZIPHandler(
+ mux,
+ nil),
+ handlers.NewLogOptions(nil, handlers.Ltiny)),
+ nil),
+ "./public/favicon.ico",
+ 48*time.Hour)
+
+ // Assign the combined handler to the server.
+ http.Handle("/", h)
+
+ // Start it up.
+ if err := http.ListenAndServe(":9000", nil); err != nil {
+ panic(err)
+ }
+}
diff --git a/Godeps/_workspace/src/github.com/PuerkitoBio/ghost/ghostest/public/bootstrap-combined.min.css b/Godeps/_workspace/src/github.com/PuerkitoBio/ghost/ghostest/public/bootstrap-combined.min.css
new file mode 100644
index 0000000000000000000000000000000000000000..0f48a96415efefe8fe170a4747482c18ddba8958
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/PuerkitoBio/ghost/ghostest/public/bootstrap-combined.min.css
@@ -0,0 +1,873 @@
+/*!
+ * Bootstrap v2.3.1
+ *
+ * Copyright 2012 Twitter, Inc
+ * Licensed under the Apache License v2.0
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Designed and built with all the love in the world @twitter by @mdo and @fat.
+ */
+.clearfix{*zoom:1;}.clearfix:before,.clearfix:after{display:table;content:"";line-height:0;}
+.clearfix:after{clear:both;}
+.hide-text{font:0/0 a;color:transparent;text-shadow:none;background-color:transparent;border:0;}
+.input-block-level{display:block;width:100%;min-height:30px;-webkit-box-sizing:border-box;-moz-box-sizing:border-box;box-sizing:border-box;}
+article,aside,details,figcaption,figure,footer,header,hgroup,nav,section{display:block;}
+audio,canvas,video{display:inline-block;*display:inline;*zoom:1;}
+audio:not([controls]){display:none;}
+html{font-size:100%;-webkit-text-size-adjust:100%;-ms-text-size-adjust:100%;}
+a:focus{outline:thin dotted #333;outline:5px auto -webkit-focus-ring-color;outline-offset:-2px;}
+a:hover,a:active{outline:0;}
+sub,sup{position:relative;font-size:75%;line-height:0;vertical-align:baseline;}
+sup{top:-0.5em;}
+sub{bottom:-0.25em;}
+img{max-width:100%;width:auto\9;height:auto;vertical-align:middle;border:0;-ms-interpolation-mode:bicubic;}
+#map_canvas img,.google-maps img{max-width:none;}
+button,input,select,textarea{margin:0;font-size:100%;vertical-align:middle;}
+button,input{*overflow:visible;line-height:normal;}
+button::-moz-focus-inner,input::-moz-focus-inner{padding:0;border:0;}
+button,html input[type="button"],input[type="reset"],input[type="submit"]{-webkit-appearance:button;cursor:pointer;}
+label,select,button,input[type="button"],input[type="reset"],input[type="submit"],input[type="radio"],input[type="checkbox"]{cursor:pointer;}
+input[type="search"]{-webkit-box-sizing:content-box;-moz-box-sizing:content-box;box-sizing:content-box;-webkit-appearance:textfield;}
+input[type="search"]::-webkit-search-decoration,input[type="search"]::-webkit-search-cancel-button{-webkit-appearance:none;}
+textarea{overflow:auto;vertical-align:top;}
+@media print{*{text-shadow:none !important;color:#000 !important;background:transparent !important;box-shadow:none !important;} a,a:visited{text-decoration:underline;} a[href]:after{content:" (" attr(href) ")";} abbr[title]:after{content:" (" attr(title) ")";} .ir a:after,a[href^="javascript:"]:after,a[href^="#"]:after{content:"";} pre,blockquote{border:1px solid #999;page-break-inside:avoid;} thead{display:table-header-group;} tr,img{page-break-inside:avoid;} img{max-width:100% !important;} @page {margin:0.5cm;}p,h2,h3{orphans:3;widows:3;} h2,h3{page-break-after:avoid;}}body{margin:0;font-family:"Helvetica Neue",Helvetica,Arial,sans-serif;font-size:14px;line-height:20px;color:#333333;background-color:#ffffff;}
+a{color:#0088cc;text-decoration:none;}
+a:hover,a:focus{color:#005580;text-decoration:underline;}
+.img-rounded{-webkit-border-radius:6px;-moz-border-radius:6px;border-radius:6px;}
+.img-polaroid{padding:4px;background-color:#fff;border:1px solid #ccc;border:1px solid rgba(0, 0, 0, 0.2);-webkit-box-shadow:0 1px 3px rgba(0, 0, 0, 0.1);-moz-box-shadow:0 1px 3px rgba(0, 0, 0, 0.1);box-shadow:0 1px 3px rgba(0, 0, 0, 0.1);}
+.img-circle{-webkit-border-radius:500px;-moz-border-radius:500px;border-radius:500px;}
+.row{margin-left:-20px;*zoom:1;}.row:before,.row:after{display:table;content:"";line-height:0;}
+.row:after{clear:both;}
+[class*="span"]{float:left;min-height:1px;margin-left:20px;}
+.container,.navbar-static-top .container,.navbar-fixed-top .container,.navbar-fixed-bottom .container{width:940px;}
+.span12{width:940px;}
+.span11{width:860px;}
+.span10{width:780px;}
+.span9{width:700px;}
+.span8{width:620px;}
+.span7{width:540px;}
+.span6{width:460px;}
+.span5{width:380px;}
+.span4{width:300px;}
+.span3{width:220px;}
+.span2{width:140px;}
+.span1{width:60px;}
+.offset12{margin-left:980px;}
+.offset11{margin-left:900px;}
+.offset10{margin-left:820px;}
+.offset9{margin-left:740px;}
+.offset8{margin-left:660px;}
+.offset7{margin-left:580px;}
+.offset6{margin-left:500px;}
+.offset5{margin-left:420px;}
+.offset4{margin-left:340px;}
+.offset3{margin-left:260px;}
+.offset2{margin-left:180px;}
+.offset1{margin-left:100px;}
+.row-fluid{width:100%;*zoom:1;}.row-fluid:before,.row-fluid:after{display:table;content:"";line-height:0;}
+.row-fluid:after{clear:both;}
+.row-fluid [class*="span"]{display:block;width:100%;min-height:30px;-webkit-box-sizing:border-box;-moz-box-sizing:border-box;box-sizing:border-box;float:left;margin-left:2.127659574468085%;*margin-left:2.074468085106383%;}
+.row-fluid [class*="span"]:first-child{margin-left:0;}
+.row-fluid .controls-row [class*="span"]+[class*="span"]{margin-left:2.127659574468085%;}
+.row-fluid .span12{width:100%;*width:99.94680851063829%;}
+.row-fluid .span11{width:91.48936170212765%;*width:91.43617021276594%;}
+.row-fluid .span10{width:82.97872340425532%;*width:82.92553191489361%;}
+.row-fluid .span9{width:74.46808510638297%;*width:74.41489361702126%;}
+.row-fluid .span8{width:65.95744680851064%;*width:65.90425531914893%;}
+.row-fluid .span7{width:57.44680851063829%;*width:57.39361702127659%;}
+.row-fluid .span6{width:48.93617021276595%;*width:48.88297872340425%;}
+.row-fluid .span5{width:40.42553191489362%;*width:40.37234042553192%;}
+.row-fluid .span4{width:31.914893617021278%;*width:31.861702127659576%;}
+.row-fluid .span3{width:23.404255319148934%;*width:23.351063829787233%;}
+.row-fluid .span2{width:14.893617021276595%;*width:14.840425531914894%;}
+.row-fluid .span1{width:6.382978723404255%;*width:6.329787234042553%;}
+.row-fluid .offset12{margin-left:104.25531914893617%;*margin-left:104.14893617021275%;}
+.row-fluid .offset12:first-child{margin-left:102.12765957446808%;*margin-left:102.02127659574467%;}
+.row-fluid .offset11{margin-left:95.74468085106382%;*margin-left:95.6382978723404%;}
+.row-fluid .offset11:first-child{margin-left:93.61702127659574%;*margin-left:93.51063829787232%;}
+.row-fluid .offset10{margin-left:87.23404255319149%;*margin-left:87.12765957446807%;}
+.row-fluid .offset10:first-child{margin-left:85.1063829787234%;*margin-left:84.99999999999999%;}
+.row-fluid .offset9{margin-left:78.72340425531914%;*margin-left:78.61702127659572%;}
+.row-fluid .offset9:first-child{margin-left:76.59574468085106%;*margin-left:76.48936170212764%;}
+.row-fluid .offset8{margin-left:70.2127659574468%;*margin-left:70.10638297872339%;}
+.row-fluid .offset8:first-child{margin-left:68.08510638297872%;*margin-left:67.9787234042553%;}
+.row-fluid .offset7{margin-left:61.70212765957446%;*margin-left:61.59574468085106%;}
+.row-fluid .offset7:first-child{margin-left:59.574468085106375%;*margin-left:59.46808510638297%;}
+.row-fluid .offset6{margin-left:53.191489361702125%;*margin-left:53.085106382978715%;}
+.row-fluid .offset6:first-child{margin-left:51.063829787234035%;*margin-left:50.95744680851063%;}
+.row-fluid .offset5{margin-left:44.68085106382979%;*margin-left:44.57446808510638%;}
+.row-fluid .offset5:first-child{margin-left:42.5531914893617%;*margin-left:42.4468085106383%;}
+.row-fluid .offset4{margin-left:36.170212765957444%;*margin-left:36.06382978723405%;}
+.row-fluid .offset4:first-child{margin-left:34.04255319148936%;*margin-left:33.93617021276596%;}
+.row-fluid .offset3{margin-left:27.659574468085104%;*margin-left:27.5531914893617%;}
+.row-fluid .offset3:first-child{margin-left:25.53191489361702%;*margin-left:25.425531914893618%;}
+.row-fluid .offset2{margin-left:19.148936170212764%;*margin-left:19.04255319148936%;}
+.row-fluid .offset2:first-child{margin-left:17.02127659574468%;*margin-left:16.914893617021278%;}
+.row-fluid .offset1{margin-left:10.638297872340425%;*margin-left:10.53191489361702%;}
+.row-fluid .offset1:first-child{margin-left:8.51063829787234%;*margin-left:8.404255319148938%;}
+[class*="span"].hide,.row-fluid [class*="span"].hide{display:none;}
+[class*="span"].pull-right,.row-fluid [class*="span"].pull-right{float:right;}
+.container{margin-right:auto;margin-left:auto;*zoom:1;}.container:before,.container:after{display:table;content:"";line-height:0;}
+.container:after{clear:both;}
+.container-fluid{padding-right:20px;padding-left:20px;*zoom:1;}.container-fluid:before,.container-fluid:after{display:table;content:"";line-height:0;}
+.container-fluid:after{clear:both;}
+p{margin:0 0 10px;}
+.lead{margin-bottom:20px;font-size:21px;font-weight:200;line-height:30px;}
+small{font-size:85%;}
+strong{font-weight:bold;}
+em{font-style:italic;}
+cite{font-style:normal;}
+.muted{color:#999999;}
+a.muted:hover,a.muted:focus{color:#808080;}
+.text-warning{color:#c09853;}
+a.text-warning:hover,a.text-warning:focus{color:#a47e3c;}
+.text-error{color:#b94a48;}
+a.text-error:hover,a.text-error:focus{color:#953b39;}
+.text-info{color:#3a87ad;}
+a.text-info:hover,a.text-info:focus{color:#2d6987;}
+.text-success{color:#468847;}
+a.text-success:hover,a.text-success:focus{color:#356635;}
+.text-left{text-align:left;}
+.text-right{text-align:right;}
+.text-center{text-align:center;}
+h1,h2,h3,h4,h5,h6{margin:10px 0;font-family:inherit;font-weight:bold;line-height:20px;color:inherit;text-rendering:optimizelegibility;}h1 small,h2 small,h3 small,h4 small,h5 small,h6 small{font-weight:normal;line-height:1;color:#999999;}
+h1,h2,h3{line-height:40px;}
+h1{font-size:38.5px;}
+h2{font-size:31.5px;}
+h3{font-size:24.5px;}
+h4{font-size:17.5px;}
+h5{font-size:14px;}
+h6{font-size:11.9px;}
+h1 small{font-size:24.5px;}
+h2 small{font-size:17.5px;}
+h3 small{font-size:14px;}
+h4 small{font-size:14px;}
+.page-header{padding-bottom:9px;margin:20px 0 30px;border-bottom:1px solid #eeeeee;}
+ul,ol{padding:0;margin:0 0 10px 25px;}
+ul ul,ul ol,ol ol,ol ul{margin-bottom:0;}
+li{line-height:20px;}
+ul.unstyled,ol.unstyled{margin-left:0;list-style:none;}
+ul.inline,ol.inline{margin-left:0;list-style:none;}ul.inline>li,ol.inline>li{display:inline-block;*display:inline;*zoom:1;padding-left:5px;padding-right:5px;}
+dl{margin-bottom:20px;}
+dt,dd{line-height:20px;}
+dt{font-weight:bold;}
+dd{margin-left:10px;}
+.dl-horizontal{*zoom:1;}.dl-horizontal:before,.dl-horizontal:after{display:table;content:"";line-height:0;}
+.dl-horizontal:after{clear:both;}
+.dl-horizontal dt{float:left;width:160px;clear:left;text-align:right;overflow:hidden;text-overflow:ellipsis;white-space:nowrap;}
+.dl-horizontal dd{margin-left:180px;}
+hr{margin:20px 0;border:0;border-top:1px solid #eeeeee;border-bottom:1px solid #ffffff;}
+abbr[title],abbr[data-original-title]{cursor:help;border-bottom:1px dotted #999999;}
+abbr.initialism{font-size:90%;text-transform:uppercase;}
+blockquote{padding:0 0 0 15px;margin:0 0 20px;border-left:5px solid #eeeeee;}blockquote p{margin-bottom:0;font-size:17.5px;font-weight:300;line-height:1.25;}
+blockquote small{display:block;line-height:20px;color:#999999;}blockquote small:before{content:'\2014 \00A0';}
+blockquote.pull-right{float:right;padding-right:15px;padding-left:0;border-right:5px solid #eeeeee;border-left:0;}blockquote.pull-right p,blockquote.pull-right small{text-align:right;}
+blockquote.pull-right small:before{content:'';}
+blockquote.pull-right small:after{content:'\00A0 \2014';}
+q:before,q:after,blockquote:before,blockquote:after{content:"";}
+address{display:block;margin-bottom:20px;font-style:normal;line-height:20px;}
+code,pre{padding:0 3px 2px;font-family:Monaco,Menlo,Consolas,"Courier New",monospace;font-size:12px;color:#333333;-webkit-border-radius:3px;-moz-border-radius:3px;border-radius:3px;}
+code{padding:2px 4px;color:#d14;background-color:#f7f7f9;border:1px solid #e1e1e8;white-space:nowrap;}
+pre{display:block;padding:9.5px;margin:0 0 10px;font-size:13px;line-height:20px;word-break:break-all;word-wrap:break-word;white-space:pre;white-space:pre-wrap;background-color:#f5f5f5;border:1px solid #ccc;border:1px solid rgba(0, 0, 0, 0.15);-webkit-border-radius:4px;-moz-border-radius:4px;border-radius:4px;}pre.prettyprint{margin-bottom:20px;}
+pre code{padding:0;color:inherit;white-space:pre;white-space:pre-wrap;background-color:transparent;border:0;}
+.pre-scrollable{max-height:340px;overflow-y:scroll;}
+.label,.badge{display:inline-block;padding:2px 4px;font-size:11.844px;font-weight:bold;line-height:14px;color:#ffffff;vertical-align:baseline;white-space:nowrap;text-shadow:0 -1px 0 rgba(0, 0, 0, 0.25);background-color:#999999;}
+.label{-webkit-border-radius:3px;-moz-border-radius:3px;border-radius:3px;}
+.badge{padding-left:9px;padding-right:9px;-webkit-border-radius:9px;-moz-border-radius:9px;border-radius:9px;}
+.label:empty,.badge:empty{display:none;}
+a.label:hover,a.label:focus,a.badge:hover,a.badge:focus{color:#ffffff;text-decoration:none;cursor:pointer;}
+.label-important,.badge-important{background-color:#b94a48;}
+.label-important[href],.badge-important[href]{background-color:#953b39;}
+.label-warning,.badge-warning{background-color:#f89406;}
+.label-warning[href],.badge-warning[href]{background-color:#c67605;}
+.label-success,.badge-success{background-color:#468847;}
+.label-success[href],.badge-success[href]{background-color:#356635;}
+.label-info,.badge-info{background-color:#3a87ad;}
+.label-info[href],.badge-info[href]{background-color:#2d6987;}
+.label-inverse,.badge-inverse{background-color:#333333;}
+.label-inverse[href],.badge-inverse[href]{background-color:#1a1a1a;}
+.btn .label,.btn .badge{position:relative;top:-1px;}
+.btn-mini .label,.btn-mini .badge{top:0;}
+table{max-width:100%;background-color:transparent;border-collapse:collapse;border-spacing:0;}
+.table{width:100%;margin-bottom:20px;}.table th,.table td{padding:8px;line-height:20px;text-align:left;vertical-align:top;border-top:1px solid #dddddd;}
+.table th{font-weight:bold;}
+.table thead th{vertical-align:bottom;}
+.table caption+thead tr:first-child th,.table caption+thead tr:first-child td,.table colgroup+thead tr:first-child th,.table colgroup+thead tr:first-child td,.table thead:first-child tr:first-child th,.table thead:first-child tr:first-child td{border-top:0;}
+.table tbody+tbody{border-top:2px solid #dddddd;}
+.table .table{background-color:#ffffff;}
+.table-condensed th,.table-condensed td{padding:4px 5px;}
+.table-bordered{border:1px solid #dddddd;border-collapse:separate;*border-collapse:collapse;border-left:0;-webkit-border-radius:4px;-moz-border-radius:4px;border-radius:4px;}.table-bordered th,.table-bordered td{border-left:1px solid #dddddd;}
+.table-bordered caption+thead tr:first-child th,.table-bordered caption+tbody tr:first-child th,.table-bordered caption+tbody tr:first-child td,.table-bordered colgroup+thead tr:first-child th,.table-bordered colgroup+tbody tr:first-child th,.table-bordered colgroup+tbody tr:first-child td,.table-bordered thead:first-child tr:first-child th,.table-bordered tbody:first-child tr:first-child th,.table-bordered tbody:first-child tr:first-child td{border-top:0;}
+.table-bordered thead:first-child tr:first-child>th:first-child,.table-bordered tbody:first-child tr:first-child>td:first-child,.table-bordered tbody:first-child tr:first-child>th:first-child{-webkit-border-top-left-radius:4px;-moz-border-radius-topleft:4px;border-top-left-radius:4px;}
+.table-bordered thead:first-child tr:first-child>th:last-child,.table-bordered tbody:first-child tr:first-child>td:last-child,.table-bordered tbody:first-child tr:first-child>th:last-child{-webkit-border-top-right-radius:4px;-moz-border-radius-topright:4px;border-top-right-radius:4px;}
+.table-bordered thead:last-child tr:last-child>th:first-child,.table-bordered tbody:last-child tr:last-child>td:first-child,.table-bordered tbody:last-child tr:last-child>th:first-child,.table-bordered tfoot:last-child tr:last-child>td:first-child,.table-bordered tfoot:last-child tr:last-child>th:first-child{-webkit-border-bottom-left-radius:4px;-moz-border-radius-bottomleft:4px;border-bottom-left-radius:4px;}
+.table-bordered thead:last-child tr:last-child>th:last-child,.table-bordered tbody:last-child tr:last-child>td:last-child,.table-bordered tbody:last-child tr:last-child>th:last-child,.table-bordered tfoot:last-child tr:last-child>td:last-child,.table-bordered tfoot:last-child tr:last-child>th:last-child{-webkit-border-bottom-right-radius:4px;-moz-border-radius-bottomright:4px;border-bottom-right-radius:4px;}
+.table-bordered tfoot+tbody:last-child tr:last-child td:first-child{-webkit-border-bottom-left-radius:0;-moz-border-radius-bottomleft:0;border-bottom-left-radius:0;}
+.table-bordered tfoot+tbody:last-child tr:last-child td:last-child{-webkit-border-bottom-right-radius:0;-moz-border-radius-bottomright:0;border-bottom-right-radius:0;}
+.table-bordered caption+thead tr:first-child th:first-child,.table-bordered caption+tbody tr:first-child td:first-child,.table-bordered colgroup+thead tr:first-child th:first-child,.table-bordered colgroup+tbody tr:first-child td:first-child{-webkit-border-top-left-radius:4px;-moz-border-radius-topleft:4px;border-top-left-radius:4px;}
+.table-bordered caption+thead tr:first-child th:last-child,.table-bordered caption+tbody tr:first-child td:last-child,.table-bordered colgroup+thead tr:first-child th:last-child,.table-bordered colgroup+tbody tr:first-child td:last-child{-webkit-border-top-right-radius:4px;-moz-border-radius-topright:4px;border-top-right-radius:4px;}
+.table-striped tbody>tr:nth-child(odd)>td,.table-striped tbody>tr:nth-child(odd)>th{background-color:#f9f9f9;}
+.table-hover tbody tr:hover>td,.table-hover tbody tr:hover>th{background-color:#f5f5f5;}
+table td[class*="span"],table th[class*="span"],.row-fluid table td[class*="span"],.row-fluid table th[class*="span"]{display:table-cell;float:none;margin-left:0;}
+.table td.span1,.table th.span1{float:none;width:44px;margin-left:0;}
+.table td.span2,.table th.span2{float:none;width:124px;margin-left:0;}
+.table td.span3,.table th.span3{float:none;width:204px;margin-left:0;}
+.table td.span4,.table th.span4{float:none;width:284px;margin-left:0;}
+.table td.span5,.table th.span5{float:none;width:364px;margin-left:0;}
+.table td.span6,.table th.span6{float:none;width:444px;margin-left:0;}
+.table td.span7,.table th.span7{float:none;width:524px;margin-left:0;}
+.table td.span8,.table th.span8{float:none;width:604px;margin-left:0;}
+.table td.span9,.table th.span9{float:none;width:684px;margin-left:0;}
+.table td.span10,.table th.span10{float:none;width:764px;margin-left:0;}
+.table td.span11,.table th.span11{float:none;width:844px;margin-left:0;}
+.table td.span12,.table th.span12{float:none;width:924px;margin-left:0;}
+.table tbody tr.success>td{background-color:#dff0d8;}
+.table tbody tr.error>td{background-color:#f2dede;}
+.table tbody tr.warning>td{background-color:#fcf8e3;}
+.table tbody tr.info>td{background-color:#d9edf7;}
+.table-hover tbody tr.success:hover>td{background-color:#d0e9c6;}
+.table-hover tbody tr.error:hover>td{background-color:#ebcccc;}
+.table-hover tbody tr.warning:hover>td{background-color:#faf2cc;}
+.table-hover tbody tr.info:hover>td{background-color:#c4e3f3;}
+form{margin:0 0 20px;}
+fieldset{padding:0;margin:0;border:0;}
+legend{display:block;width:100%;padding:0;margin-bottom:20px;font-size:21px;line-height:40px;color:#333333;border:0;border-bottom:1px solid #e5e5e5;}legend small{font-size:15px;color:#999999;}
+label,input,button,select,textarea{font-size:14px;font-weight:normal;line-height:20px;}
+input,button,select,textarea{font-family:"Helvetica Neue",Helvetica,Arial,sans-serif;}
+label{display:block;margin-bottom:5px;}
+select,textarea,input[type="text"],input[type="password"],input[type="datetime"],input[type="datetime-local"],input[type="date"],input[type="month"],input[type="time"],input[type="week"],input[type="number"],input[type="email"],input[type="url"],input[type="search"],input[type="tel"],input[type="color"],.uneditable-input{display:inline-block;height:20px;padding:4px 6px;margin-bottom:10px;font-size:14px;line-height:20px;color:#555555;-webkit-border-radius:4px;-moz-border-radius:4px;border-radius:4px;vertical-align:middle;}
+input,textarea,.uneditable-input{width:206px;}
+textarea{height:auto;}
+textarea,input[type="text"],input[type="password"],input[type="datetime"],input[type="datetime-local"],input[type="date"],input[type="month"],input[type="time"],input[type="week"],input[type="number"],input[type="email"],input[type="url"],input[type="search"],input[type="tel"],input[type="color"],.uneditable-input{background-color:#ffffff;border:1px solid #cccccc;-webkit-box-shadow:inset 0 1px 1px rgba(0, 0, 0, 0.075);-moz-box-shadow:inset 0 1px 1px rgba(0, 0, 0, 0.075);box-shadow:inset 0 1px 1px rgba(0, 0, 0, 0.075);-webkit-transition:border linear .2s, box-shadow linear .2s;-moz-transition:border linear .2s, box-shadow linear .2s;-o-transition:border linear .2s, box-shadow linear .2s;transition:border linear .2s, box-shadow linear .2s;}textarea:focus,input[type="text"]:focus,input[type="password"]:focus,input[type="datetime"]:focus,input[type="datetime-local"]:focus,input[type="date"]:focus,input[type="month"]:focus,input[type="time"]:focus,input[type="week"]:focus,input[type="number"]:focus,input[type="email"]:focus,input[type="url"]:focus,input[type="search"]:focus,input[type="tel"]:focus,input[type="color"]:focus,.uneditable-input:focus{border-color:rgba(82, 168, 236, 0.8);outline:0;outline:thin dotted \9;-webkit-box-shadow:inset 0 1px 1px rgba(0,0,0,.075), 0 0 8px rgba(82,168,236,.6);-moz-box-shadow:inset 0 1px 1px rgba(0,0,0,.075), 0 0 8px rgba(82,168,236,.6);box-shadow:inset 0 1px 1px rgba(0,0,0,.075), 0 0 8px rgba(82,168,236,.6);}
+input[type="radio"],input[type="checkbox"]{margin:4px 0 0;*margin-top:0;margin-top:1px \9;line-height:normal;}
+input[type="file"],input[type="image"],input[type="submit"],input[type="reset"],input[type="button"],input[type="radio"],input[type="checkbox"]{width:auto;}
+select,input[type="file"]{height:30px;*margin-top:4px;line-height:30px;}
+select{width:220px;border:1px solid #cccccc;background-color:#ffffff;}
+select[multiple],select[size]{height:auto;}
+select:focus,input[type="file"]:focus,input[type="radio"]:focus,input[type="checkbox"]:focus{outline:thin dotted #333;outline:5px auto -webkit-focus-ring-color;outline-offset:-2px;}
+.uneditable-input,.uneditable-textarea{color:#999999;background-color:#fcfcfc;border-color:#cccccc;-webkit-box-shadow:inset 0 1px 2px rgba(0, 0, 0, 0.025);-moz-box-shadow:inset 0 1px 2px rgba(0, 0, 0, 0.025);box-shadow:inset 0 1px 2px rgba(0, 0, 0, 0.025);cursor:not-allowed;}
+.uneditable-input{overflow:hidden;white-space:nowrap;}
+.uneditable-textarea{width:auto;height:auto;}
+input:-moz-placeholder,textarea:-moz-placeholder{color:#999999;}
+input:-ms-input-placeholder,textarea:-ms-input-placeholder{color:#999999;}
+input::-webkit-input-placeholder,textarea::-webkit-input-placeholder{color:#999999;}
+.radio,.checkbox{min-height:20px;padding-left:20px;}
+.radio input[type="radio"],.checkbox input[type="checkbox"]{float:left;margin-left:-20px;}
+.controls>.radio:first-child,.controls>.checkbox:first-child{padding-top:5px;}
+.radio.inline,.checkbox.inline{display:inline-block;padding-top:5px;margin-bottom:0;vertical-align:middle;}
+.radio.inline+.radio.inline,.checkbox.inline+.checkbox.inline{margin-left:10px;}
+.input-mini{width:60px;}
+.input-small{width:90px;}
+.input-medium{width:150px;}
+.input-large{width:210px;}
+.input-xlarge{width:270px;}
+.input-xxlarge{width:530px;}
+input[class*="span"],select[class*="span"],textarea[class*="span"],.uneditable-input[class*="span"],.row-fluid input[class*="span"],.row-fluid select[class*="span"],.row-fluid textarea[class*="span"],.row-fluid .uneditable-input[class*="span"]{float:none;margin-left:0;}
+.input-append input[class*="span"],.input-append .uneditable-input[class*="span"],.input-prepend input[class*="span"],.input-prepend .uneditable-input[class*="span"],.row-fluid input[class*="span"],.row-fluid select[class*="span"],.row-fluid textarea[class*="span"],.row-fluid .uneditable-input[class*="span"],.row-fluid .input-prepend [class*="span"],.row-fluid .input-append [class*="span"]{display:inline-block;}
+input,textarea,.uneditable-input{margin-left:0;}
+.controls-row [class*="span"]+[class*="span"]{margin-left:20px;}
+input.span12,textarea.span12,.uneditable-input.span12{width:926px;}
+input.span11,textarea.span11,.uneditable-input.span11{width:846px;}
+input.span10,textarea.span10,.uneditable-input.span10{width:766px;}
+input.span9,textarea.span9,.uneditable-input.span9{width:686px;}
+input.span8,textarea.span8,.uneditable-input.span8{width:606px;}
+input.span7,textarea.span7,.uneditable-input.span7{width:526px;}
+input.span6,textarea.span6,.uneditable-input.span6{width:446px;}
+input.span5,textarea.span5,.uneditable-input.span5{width:366px;}
+input.span4,textarea.span4,.uneditable-input.span4{width:286px;}
+input.span3,textarea.span3,.uneditable-input.span3{width:206px;}
+input.span2,textarea.span2,.uneditable-input.span2{width:126px;}
+input.span1,textarea.span1,.uneditable-input.span1{width:46px;}
+.controls-row{*zoom:1;}.controls-row:before,.controls-row:after{display:table;content:"";line-height:0;}
+.controls-row:after{clear:both;}
+.controls-row [class*="span"],.row-fluid .controls-row [class*="span"]{float:left;}
+.controls-row .checkbox[class*="span"],.controls-row .radio[class*="span"]{padding-top:5px;}
+input[disabled],select[disabled],textarea[disabled],input[readonly],select[readonly],textarea[readonly]{cursor:not-allowed;background-color:#eeeeee;}
+input[type="radio"][disabled],input[type="checkbox"][disabled],input[type="radio"][readonly],input[type="checkbox"][readonly]{background-color:transparent;}
+.control-group.warning .control-label,.control-group.warning .help-block,.control-group.warning .help-inline{color:#c09853;}
+.control-group.warning .checkbox,.control-group.warning .radio,.control-group.warning input,.control-group.warning select,.control-group.warning textarea{color:#c09853;}
+.control-group.warning input,.control-group.warning select,.control-group.warning textarea{border-color:#c09853;-webkit-box-shadow:inset 0 1px 1px rgba(0, 0, 0, 0.075);-moz-box-shadow:inset 0 1px 1px rgba(0, 0, 0, 0.075);box-shadow:inset 0 1px 1px rgba(0, 0, 0, 0.075);}.control-group.warning input:focus,.control-group.warning select:focus,.control-group.warning textarea:focus{border-color:#a47e3c;-webkit-box-shadow:inset 0 1px 1px rgba(0, 0, 0, 0.075),0 0 6px #dbc59e;-moz-box-shadow:inset 0 1px 1px rgba(0, 0, 0, 0.075),0 0 6px #dbc59e;box-shadow:inset 0 1px 1px rgba(0, 0, 0, 0.075),0 0 6px #dbc59e;}
+.control-group.warning .input-prepend .add-on,.control-group.warning .input-append .add-on{color:#c09853;background-color:#fcf8e3;border-color:#c09853;}
+.control-group.error .control-label,.control-group.error .help-block,.control-group.error .help-inline{color:#b94a48;}
+.control-group.error .checkbox,.control-group.error .radio,.control-group.error input,.control-group.error select,.control-group.error textarea{color:#b94a48;}
+.control-group.error input,.control-group.error select,.control-group.error textarea{border-color:#b94a48;-webkit-box-shadow:inset 0 1px 1px rgba(0, 0, 0, 0.075);-moz-box-shadow:inset 0 1px 1px rgba(0, 0, 0, 0.075);box-shadow:inset 0 1px 1px rgba(0, 0, 0, 0.075);}.control-group.error input:focus,.control-group.error select:focus,.control-group.error textarea:focus{border-color:#953b39;-webkit-box-shadow:inset 0 1px 1px rgba(0, 0, 0, 0.075),0 0 6px #d59392;-moz-box-shadow:inset 0 1px 1px rgba(0, 0, 0, 0.075),0 0 6px #d59392;box-shadow:inset 0 1px 1px rgba(0, 0, 0, 0.075),0 0 6px #d59392;}
+.control-group.error .input-prepend .add-on,.control-group.error .input-append .add-on{color:#b94a48;background-color:#f2dede;border-color:#b94a48;}
+.control-group.success .control-label,.control-group.success .help-block,.control-group.success .help-inline{color:#468847;}
+.control-group.success .checkbox,.control-group.success .radio,.control-group.success input,.control-group.success select,.control-group.success textarea{color:#468847;}
+.control-group.success input,.control-group.success select,.control-group.success textarea{border-color:#468847;-webkit-box-shadow:inset 0 1px 1px rgba(0, 0, 0, 0.075);-moz-box-shadow:inset 0 1px 1px rgba(0, 0, 0, 0.075);box-shadow:inset 0 1px 1px rgba(0, 0, 0, 0.075);}.control-group.success input:focus,.control-group.success select:focus,.control-group.success textarea:focus{border-color:#356635;-webkit-box-shadow:inset 0 1px 1px rgba(0, 0, 0, 0.075),0 0 6px #7aba7b;-moz-box-shadow:inset 0 1px 1px rgba(0, 0, 0, 0.075),0 0 6px #7aba7b;box-shadow:inset 0 1px 1px rgba(0, 0, 0, 0.075),0 0 6px #7aba7b;}
+.control-group.success .input-prepend .add-on,.control-group.success .input-append .add-on{color:#468847;background-color:#dff0d8;border-color:#468847;}
+.control-group.info .control-label,.control-group.info .help-block,.control-group.info .help-inline{color:#3a87ad;}
+.control-group.info .checkbox,.control-group.info .radio,.control-group.info input,.control-group.info select,.control-group.info textarea{color:#3a87ad;}
+.control-group.info input,.control-group.info select,.control-group.info textarea{border-color:#3a87ad;-webkit-box-shadow:inset 0 1px 1px rgba(0, 0, 0, 0.075);-moz-box-shadow:inset 0 1px 1px rgba(0, 0, 0, 0.075);box-shadow:inset 0 1px 1px rgba(0, 0, 0, 0.075);}.control-group.info input:focus,.control-group.info select:focus,.control-group.info textarea:focus{border-color:#2d6987;-webkit-box-shadow:inset 0 1px 1px rgba(0, 0, 0, 0.075),0 0 6px #7ab5d3;-moz-box-shadow:inset 0 1px 1px rgba(0, 0, 0, 0.075),0 0 6px #7ab5d3;box-shadow:inset 0 1px 1px rgba(0, 0, 0, 0.075),0 0 6px #7ab5d3;}
+.control-group.info .input-prepend .add-on,.control-group.info .input-append .add-on{color:#3a87ad;background-color:#d9edf7;border-color:#3a87ad;}
+input:focus:invalid,textarea:focus:invalid,select:focus:invalid{color:#b94a48;border-color:#ee5f5b;}input:focus:invalid:focus,textarea:focus:invalid:focus,select:focus:invalid:focus{border-color:#e9322d;-webkit-box-shadow:0 0 6px #f8b9b7;-moz-box-shadow:0 0 6px #f8b9b7;box-shadow:0 0 6px #f8b9b7;}
+.form-actions{padding:19px 20px 20px;margin-top:20px;margin-bottom:20px;background-color:#f5f5f5;border-top:1px solid #e5e5e5;*zoom:1;}.form-actions:before,.form-actions:after{display:table;content:"";line-height:0;}
+.form-actions:after{clear:both;}
+.help-block,.help-inline{color:#595959;}
+.help-block{display:block;margin-bottom:10px;}
+.help-inline{display:inline-block;*display:inline;*zoom:1;vertical-align:middle;padding-left:5px;}
+.input-append,.input-prepend{display:inline-block;margin-bottom:10px;vertical-align:middle;font-size:0;white-space:nowrap;}.input-append input,.input-prepend input,.input-append select,.input-prepend select,.input-append .uneditable-input,.input-prepend .uneditable-input,.input-append .dropdown-menu,.input-prepend .dropdown-menu,.input-append .popover,.input-prepend .popover{font-size:14px;}
+.input-append input,.input-prepend input,.input-append select,.input-prepend select,.input-append .uneditable-input,.input-prepend .uneditable-input{position:relative;margin-bottom:0;*margin-left:0;vertical-align:top;-webkit-border-radius:0 4px 4px 0;-moz-border-radius:0 4px 4px 0;border-radius:0 4px 4px 0;}.input-append input:focus,.input-prepend input:focus,.input-append select:focus,.input-prepend select:focus,.input-append .uneditable-input:focus,.input-prepend .uneditable-input:focus{z-index:2;}
+.input-append .add-on,.input-prepend .add-on{display:inline-block;width:auto;height:20px;min-width:16px;padding:4px 5px;font-size:14px;font-weight:normal;line-height:20px;text-align:center;text-shadow:0 1px 0 #ffffff;background-color:#eeeeee;border:1px solid #ccc;}
+.input-append .add-on,.input-prepend .add-on,.input-append .btn,.input-prepend .btn,.input-append .btn-group>.dropdown-toggle,.input-prepend .btn-group>.dropdown-toggle{vertical-align:top;-webkit-border-radius:0;-moz-border-radius:0;border-radius:0;}
+.input-append .active,.input-prepend .active{background-color:#a9dba9;border-color:#46a546;}
+.input-prepend .add-on,.input-prepend .btn{margin-right:-1px;}
+.input-prepend .add-on:first-child,.input-prepend .btn:first-child{-webkit-border-radius:4px 0 0 4px;-moz-border-radius:4px 0 0 4px;border-radius:4px 0 0 4px;}
+.input-append input,.input-append select,.input-append .uneditable-input{-webkit-border-radius:4px 0 0 4px;-moz-border-radius:4px 0 0 4px;border-radius:4px 0 0 4px;}.input-append input+.btn-group .btn:last-child,.input-append select+.btn-group .btn:last-child,.input-append .uneditable-input+.btn-group .btn:last-child{-webkit-border-radius:0 4px 4px 0;-moz-border-radius:0 4px 4px 0;border-radius:0 4px 4px 0;}
+.input-append .add-on,.input-append .btn,.input-append .btn-group{margin-left:-1px;}
+.input-append .add-on:last-child,.input-append .btn:last-child,.input-append .btn-group:last-child>.dropdown-toggle{-webkit-border-radius:0 4px 4px 0;-moz-border-radius:0 4px 4px 0;border-radius:0 4px 4px 0;}
+.input-prepend.input-append input,.input-prepend.input-append select,.input-prepend.input-append .uneditable-input{-webkit-border-radius:0;-moz-border-radius:0;border-radius:0;}.input-prepend.input-append input+.btn-group .btn,.input-prepend.input-append select+.btn-group .btn,.input-prepend.input-append .uneditable-input+.btn-group .btn{-webkit-border-radius:0 4px 4px 0;-moz-border-radius:0 4px 4px 0;border-radius:0 4px 4px 0;}
+.input-prepend.input-append .add-on:first-child,.input-prepend.input-append .btn:first-child{margin-right:-1px;-webkit-border-radius:4px 0 0 4px;-moz-border-radius:4px 0 0 4px;border-radius:4px 0 0 4px;}
+.input-prepend.input-append .add-on:last-child,.input-prepend.input-append .btn:last-child{margin-left:-1px;-webkit-border-radius:0 4px 4px 0;-moz-border-radius:0 4px 4px 0;border-radius:0 4px 4px 0;}
+.input-prepend.input-append .btn-group:first-child{margin-left:0;}
+input.search-query{padding-right:14px;padding-right:4px \9;padding-left:14px;padding-left:4px \9;margin-bottom:0;-webkit-border-radius:15px;-moz-border-radius:15px;border-radius:15px;}
+.form-search .input-append .search-query,.form-search .input-prepend .search-query{-webkit-border-radius:0;-moz-border-radius:0;border-radius:0;}
+.form-search .input-append .search-query{-webkit-border-radius:14px 0 0 14px;-moz-border-radius:14px 0 0 14px;border-radius:14px 0 0 14px;}
+.form-search .input-append .btn{-webkit-border-radius:0 14px 14px 0;-moz-border-radius:0 14px 14px 0;border-radius:0 14px 14px 0;}
+.form-search .input-prepend .search-query{-webkit-border-radius:0 14px 14px 0;-moz-border-radius:0 14px 14px 0;border-radius:0 14px 14px 0;}
+.form-search .input-prepend .btn{-webkit-border-radius:14px 0 0 14px;-moz-border-radius:14px 0 0 14px;border-radius:14px 0 0 14px;}
+.form-search input,.form-inline input,.form-horizontal input,.form-search textarea,.form-inline textarea,.form-horizontal textarea,.form-search select,.form-inline select,.form-horizontal select,.form-search .help-inline,.form-inline .help-inline,.form-horizontal .help-inline,.form-search .uneditable-input,.form-inline .uneditable-input,.form-horizontal .uneditable-input,.form-search .input-prepend,.form-inline .input-prepend,.form-horizontal .input-prepend,.form-search .input-append,.form-inline .input-append,.form-horizontal .input-append{display:inline-block;*display:inline;*zoom:1;margin-bottom:0;vertical-align:middle;}
+.form-search .hide,.form-inline .hide,.form-horizontal .hide{display:none;}
+.form-search label,.form-inline label,.form-search .btn-group,.form-inline .btn-group{display:inline-block;}
+.form-search .input-append,.form-inline .input-append,.form-search .input-prepend,.form-inline .input-prepend{margin-bottom:0;}
+.form-search .radio,.form-search .checkbox,.form-inline .radio,.form-inline .checkbox{padding-left:0;margin-bottom:0;vertical-align:middle;}
+.form-search .radio input[type="radio"],.form-search .checkbox input[type="checkbox"],.form-inline .radio input[type="radio"],.form-inline .checkbox input[type="checkbox"]{float:left;margin-right:3px;margin-left:0;}
+.control-group{margin-bottom:10px;}
+legend+.control-group{margin-top:20px;-webkit-margin-top-collapse:separate;}
+.form-horizontal .control-group{margin-bottom:20px;*zoom:1;}.form-horizontal .control-group:before,.form-horizontal .control-group:after{display:table;content:"";line-height:0;}
+.form-horizontal .control-group:after{clear:both;}
+.form-horizontal .control-label{float:left;width:160px;padding-top:5px;text-align:right;}
+.form-horizontal .controls{*display:inline-block;*padding-left:20px;margin-left:180px;*margin-left:0;}.form-horizontal .controls:first-child{*padding-left:180px;}
+.form-horizontal .help-block{margin-bottom:0;}
+.form-horizontal input+.help-block,.form-horizontal select+.help-block,.form-horizontal textarea+.help-block,.form-horizontal .uneditable-input+.help-block,.form-horizontal .input-prepend+.help-block,.form-horizontal .input-append+.help-block{margin-top:10px;}
+.form-horizontal .form-actions{padding-left:180px;}
+.btn{display:inline-block;*display:inline;*zoom:1;padding:4px 12px;margin-bottom:0;font-size:14px;line-height:20px;text-align:center;vertical-align:middle;cursor:pointer;color:#333333;text-shadow:0 1px 1px rgba(255, 255, 255, 0.75);background-color:#f5f5f5;background-image:-moz-linear-gradient(top, #ffffff, #e6e6e6);background-image:-webkit-gradient(linear, 0 0, 0 100%, from(#ffffff), to(#e6e6e6));background-image:-webkit-linear-gradient(top, #ffffff, #e6e6e6);background-image:-o-linear-gradient(top, #ffffff, #e6e6e6);background-image:linear-gradient(to bottom, #ffffff, #e6e6e6);background-repeat:repeat-x;filter:progid:DXImageTransform.Microsoft.gradient(startColorstr='#ffffffff', endColorstr='#ffe6e6e6', GradientType=0);border-color:#e6e6e6 #e6e6e6 #bfbfbf;border-color:rgba(0, 0, 0, 0.1) rgba(0, 0, 0, 0.1) rgba(0, 0, 0, 0.25);*background-color:#e6e6e6;filter:progid:DXImageTransform.Microsoft.gradient(enabled = false);border:1px solid #cccccc;*border:0;border-bottom-color:#b3b3b3;-webkit-border-radius:4px;-moz-border-radius:4px;border-radius:4px;*margin-left:.3em;-webkit-box-shadow:inset 0 1px 0 rgba(255,255,255,.2), 0 1px 2px rgba(0,0,0,.05);-moz-box-shadow:inset 0 1px 0 rgba(255,255,255,.2), 0 1px 2px rgba(0,0,0,.05);box-shadow:inset 0 1px 0 rgba(255,255,255,.2), 0 1px 2px rgba(0,0,0,.05);}.btn:hover,.btn:focus,.btn:active,.btn.active,.btn.disabled,.btn[disabled]{color:#333333;background-color:#e6e6e6;*background-color:#d9d9d9;}
+.btn:active,.btn.active{background-color:#cccccc \9;}
+.btn:first-child{*margin-left:0;}
+.btn:hover,.btn:focus{color:#333333;text-decoration:none;background-position:0 -15px;-webkit-transition:background-position 0.1s linear;-moz-transition:background-position 0.1s linear;-o-transition:background-position 0.1s linear;transition:background-position 0.1s linear;}
+.btn:focus{outline:thin dotted #333;outline:5px auto -webkit-focus-ring-color;outline-offset:-2px;}
+.btn.active,.btn:active{background-image:none;outline:0;-webkit-box-shadow:inset 0 2px 4px rgba(0,0,0,.15), 0 1px 2px rgba(0,0,0,.05);-moz-box-shadow:inset 0 2px 4px rgba(0,0,0,.15), 0 1px 2px rgba(0,0,0,.05);box-shadow:inset 0 2px 4px rgba(0,0,0,.15), 0 1px 2px rgba(0,0,0,.05);}
+.btn.disabled,.btn[disabled]{cursor:default;background-image:none;opacity:0.65;filter:alpha(opacity=65);-webkit-box-shadow:none;-moz-box-shadow:none;box-shadow:none;}
+.btn-large{padding:11px 19px;font-size:17.5px;-webkit-border-radius:6px;-moz-border-radius:6px;border-radius:6px;}
+.btn-large [class^="icon-"],.btn-large [class*=" icon-"]{margin-top:4px;}
+.btn-small{padding:2px 10px;font-size:11.9px;-webkit-border-radius:3px;-moz-border-radius:3px;border-radius:3px;}
+.btn-small [class^="icon-"],.btn-small [class*=" icon-"]{margin-top:0;}
+.btn-mini [class^="icon-"],.btn-mini [class*=" icon-"]{margin-top:-1px;}
+.btn-mini{padding:0 6px;font-size:10.5px;-webkit-border-radius:3px;-moz-border-radius:3px;border-radius:3px;}
+.btn-block{display:block;width:100%;padding-left:0;padding-right:0;-webkit-box-sizing:border-box;-moz-box-sizing:border-box;box-sizing:border-box;}
+.btn-block+.btn-block{margin-top:5px;}
+input[type="submit"].btn-block,input[type="reset"].btn-block,input[type="button"].btn-block{width:100%;}
+.btn-primary.active,.btn-warning.active,.btn-danger.active,.btn-success.active,.btn-info.active,.btn-inverse.active{color:rgba(255, 255, 255, 0.75);}
+.btn-primary{color:#ffffff;text-shadow:0 -1px 0 rgba(0, 0, 0, 0.25);background-color:#006dcc;background-image:-moz-linear-gradient(top, #0088cc, #0044cc);background-image:-webkit-gradient(linear, 0 0, 0 100%, from(#0088cc), to(#0044cc));background-image:-webkit-linear-gradient(top, #0088cc, #0044cc);background-image:-o-linear-gradient(top, #0088cc, #0044cc);background-image:linear-gradient(to bottom, #0088cc, #0044cc);background-repeat:repeat-x;filter:progid:DXImageTransform.Microsoft.gradient(startColorstr='#ff0088cc', endColorstr='#ff0044cc', GradientType=0);border-color:#0044cc #0044cc #002a80;border-color:rgba(0, 0, 0, 0.1) rgba(0, 0, 0, 0.1) rgba(0, 0, 0, 0.25);*background-color:#0044cc;filter:progid:DXImageTransform.Microsoft.gradient(enabled = false);}.btn-primary:hover,.btn-primary:focus,.btn-primary:active,.btn-primary.active,.btn-primary.disabled,.btn-primary[disabled]{color:#ffffff;background-color:#0044cc;*background-color:#003bb3;}
+.btn-primary:active,.btn-primary.active{background-color:#003399 \9;}
+.btn-warning{color:#ffffff;text-shadow:0 -1px 0 rgba(0, 0, 0, 0.25);background-color:#faa732;background-image:-moz-linear-gradient(top, #fbb450, #f89406);background-image:-webkit-gradient(linear, 0 0, 0 100%, from(#fbb450), to(#f89406));background-image:-webkit-linear-gradient(top, #fbb450, #f89406);background-image:-o-linear-gradient(top, #fbb450, #f89406);background-image:linear-gradient(to bottom, #fbb450, #f89406);background-repeat:repeat-x;filter:progid:DXImageTransform.Microsoft.gradient(startColorstr='#fffbb450', endColorstr='#fff89406', GradientType=0);border-color:#f89406 #f89406 #ad6704;border-color:rgba(0, 0, 0, 0.1) rgba(0, 0, 0, 0.1) rgba(0, 0, 0, 0.25);*background-color:#f89406;filter:progid:DXImageTransform.Microsoft.gradient(enabled = false);}.btn-warning:hover,.btn-warning:focus,.btn-warning:active,.btn-warning.active,.btn-warning.disabled,.btn-warning[disabled]{color:#ffffff;background-color:#f89406;*background-color:#df8505;}
+.btn-warning:active,.btn-warning.active{background-color:#c67605 \9;}
+.btn-danger{color:#ffffff;text-shadow:0 -1px 0 rgba(0, 0, 0, 0.25);background-color:#da4f49;background-image:-moz-linear-gradient(top, #ee5f5b, #bd362f);background-image:-webkit-gradient(linear, 0 0, 0 100%, from(#ee5f5b), to(#bd362f));background-image:-webkit-linear-gradient(top, #ee5f5b, #bd362f);background-image:-o-linear-gradient(top, #ee5f5b, #bd362f);background-image:linear-gradient(to bottom, #ee5f5b, #bd362f);background-repeat:repeat-x;filter:progid:DXImageTransform.Microsoft.gradient(startColorstr='#ffee5f5b', endColorstr='#ffbd362f', GradientType=0);border-color:#bd362f #bd362f #802420;border-color:rgba(0, 0, 0, 0.1) rgba(0, 0, 0, 0.1) rgba(0, 0, 0, 0.25);*background-color:#bd362f;filter:progid:DXImageTransform.Microsoft.gradient(enabled = false);}.btn-danger:hover,.btn-danger:focus,.btn-danger:active,.btn-danger.active,.btn-danger.disabled,.btn-danger[disabled]{color:#ffffff;background-color:#bd362f;*background-color:#a9302a;}
+.btn-danger:active,.btn-danger.active{background-color:#942a25 \9;}
+.btn-success{color:#ffffff;text-shadow:0 -1px 0 rgba(0, 0, 0, 0.25);background-color:#5bb75b;background-image:-moz-linear-gradient(top, #62c462, #51a351);background-image:-webkit-gradient(linear, 0 0, 0 100%, from(#62c462), to(#51a351));background-image:-webkit-linear-gradient(top, #62c462, #51a351);background-image:-o-linear-gradient(top, #62c462, #51a351);background-image:linear-gradient(to bottom, #62c462, #51a351);background-repeat:repeat-x;filter:progid:DXImageTransform.Microsoft.gradient(startColorstr='#ff62c462', endColorstr='#ff51a351', GradientType=0);border-color:#51a351 #51a351 #387038;border-color:rgba(0, 0, 0, 0.1) rgba(0, 0, 0, 0.1) rgba(0, 0, 0, 0.25);*background-color:#51a351;filter:progid:DXImageTransform.Microsoft.gradient(enabled = false);}.btn-success:hover,.btn-success:focus,.btn-success:active,.btn-success.active,.btn-success.disabled,.btn-success[disabled]{color:#ffffff;background-color:#51a351;*background-color:#499249;}
+.btn-success:active,.btn-success.active{background-color:#408140 \9;}
+.btn-info{color:#ffffff;text-shadow:0 -1px 0 rgba(0, 0, 0, 0.25);background-color:#49afcd;background-image:-moz-linear-gradient(top, #5bc0de, #2f96b4);background-image:-webkit-gradient(linear, 0 0, 0 100%, from(#5bc0de), to(#2f96b4));background-image:-webkit-linear-gradient(top, #5bc0de, #2f96b4);background-image:-o-linear-gradient(top, #5bc0de, #2f96b4);background-image:linear-gradient(to bottom, #5bc0de, #2f96b4);background-repeat:repeat-x;filter:progid:DXImageTransform.Microsoft.gradient(startColorstr='#ff5bc0de', endColorstr='#ff2f96b4', GradientType=0);border-color:#2f96b4 #2f96b4 #1f6377;border-color:rgba(0, 0, 0, 0.1) rgba(0, 0, 0, 0.1) rgba(0, 0, 0, 0.25);*background-color:#2f96b4;filter:progid:DXImageTransform.Microsoft.gradient(enabled = false);}.btn-info:hover,.btn-info:focus,.btn-info:active,.btn-info.active,.btn-info.disabled,.btn-info[disabled]{color:#ffffff;background-color:#2f96b4;*background-color:#2a85a0;}
+.btn-info:active,.btn-info.active{background-color:#24748c \9;}
+.btn-inverse{color:#ffffff;text-shadow:0 -1px 0 rgba(0, 0, 0, 0.25);background-color:#363636;background-image:-moz-linear-gradient(top, #444444, #222222);background-image:-webkit-gradient(linear, 0 0, 0 100%, from(#444444), to(#222222));background-image:-webkit-linear-gradient(top, #444444, #222222);background-image:-o-linear-gradient(top, #444444, #222222);background-image:linear-gradient(to bottom, #444444, #222222);background-repeat:repeat-x;filter:progid:DXImageTransform.Microsoft.gradient(startColorstr='#ff444444', endColorstr='#ff222222', GradientType=0);border-color:#222222 #222222 #000000;border-color:rgba(0, 0, 0, 0.1) rgba(0, 0, 0, 0.1) rgba(0, 0, 0, 0.25);*background-color:#222222;filter:progid:DXImageTransform.Microsoft.gradient(enabled = false);}.btn-inverse:hover,.btn-inverse:focus,.btn-inverse:active,.btn-inverse.active,.btn-inverse.disabled,.btn-inverse[disabled]{color:#ffffff;background-color:#222222;*background-color:#151515;}
+.btn-inverse:active,.btn-inverse.active{background-color:#080808 \9;}
+button.btn,input[type="submit"].btn{*padding-top:3px;*padding-bottom:3px;}button.btn::-moz-focus-inner,input[type="submit"].btn::-moz-focus-inner{padding:0;border:0;}
+button.btn.btn-large,input[type="submit"].btn.btn-large{*padding-top:7px;*padding-bottom:7px;}
+button.btn.btn-small,input[type="submit"].btn.btn-small{*padding-top:3px;*padding-bottom:3px;}
+button.btn.btn-mini,input[type="submit"].btn.btn-mini{*padding-top:1px;*padding-bottom:1px;}
+.btn-link,.btn-link:active,.btn-link[disabled]{background-color:transparent;background-image:none;-webkit-box-shadow:none;-moz-box-shadow:none;box-shadow:none;}
+.btn-link{border-color:transparent;cursor:pointer;color:#0088cc;-webkit-border-radius:0;-moz-border-radius:0;border-radius:0;}
+.btn-link:hover,.btn-link:focus{color:#005580;text-decoration:underline;background-color:transparent;}
+.btn-link[disabled]:hover,.btn-link[disabled]:focus{color:#333333;text-decoration:none;}
+[class^="icon-"],[class*=" icon-"]{display:inline-block;width:14px;height:14px;*margin-right:.3em;line-height:14px;vertical-align:text-top;background-image:url("../img/glyphicons-halflings.png");background-position:14px 14px;background-repeat:no-repeat;margin-top:1px;}
+.icon-white,.nav-pills>.active>a>[class^="icon-"],.nav-pills>.active>a>[class*=" icon-"],.nav-list>.active>a>[class^="icon-"],.nav-list>.active>a>[class*=" icon-"],.navbar-inverse .nav>.active>a>[class^="icon-"],.navbar-inverse .nav>.active>a>[class*=" icon-"],.dropdown-menu>li>a:hover>[class^="icon-"],.dropdown-menu>li>a:focus>[class^="icon-"],.dropdown-menu>li>a:hover>[class*=" icon-"],.dropdown-menu>li>a:focus>[class*=" icon-"],.dropdown-menu>.active>a>[class^="icon-"],.dropdown-menu>.active>a>[class*=" icon-"],.dropdown-submenu:hover>a>[class^="icon-"],.dropdown-submenu:focus>a>[class^="icon-"],.dropdown-submenu:hover>a>[class*=" icon-"],.dropdown-submenu:focus>a>[class*=" icon-"]{background-image:url("../img/glyphicons-halflings-white.png");}
+.icon-glass{background-position:0 0;}
+.icon-music{background-position:-24px 0;}
+.icon-search{background-position:-48px 0;}
+.icon-envelope{background-position:-72px 0;}
+.icon-heart{background-position:-96px 0;}
+.icon-star{background-position:-120px 0;}
+.icon-star-empty{background-position:-144px 0;}
+.icon-user{background-position:-168px 0;}
+.icon-film{background-position:-192px 0;}
+.icon-th-large{background-position:-216px 0;}
+.icon-th{background-position:-240px 0;}
+.icon-th-list{background-position:-264px 0;}
+.icon-ok{background-position:-288px 0;}
+.icon-remove{background-position:-312px 0;}
+.icon-zoom-in{background-position:-336px 0;}
+.icon-zoom-out{background-position:-360px 0;}
+.icon-off{background-position:-384px 0;}
+.icon-signal{background-position:-408px 0;}
+.icon-cog{background-position:-432px 0;}
+.icon-trash{background-position:-456px 0;}
+.icon-home{background-position:0 -24px;}
+.icon-file{background-position:-24px -24px;}
+.icon-time{background-position:-48px -24px;}
+.icon-road{background-position:-72px -24px;}
+.icon-download-alt{background-position:-96px -24px;}
+.icon-download{background-position:-120px -24px;}
+.icon-upload{background-position:-144px -24px;}
+.icon-inbox{background-position:-168px -24px;}
+.icon-play-circle{background-position:-192px -24px;}
+.icon-repeat{background-position:-216px -24px;}
+.icon-refresh{background-position:-240px -24px;}
+.icon-list-alt{background-position:-264px -24px;}
+.icon-lock{background-position:-287px -24px;}
+.icon-flag{background-position:-312px -24px;}
+.icon-headphones{background-position:-336px -24px;}
+.icon-volume-off{background-position:-360px -24px;}
+.icon-volume-down{background-position:-384px -24px;}
+.icon-volume-up{background-position:-408px -24px;}
+.icon-qrcode{background-position:-432px -24px;}
+.icon-barcode{background-position:-456px -24px;}
+.icon-tag{background-position:0 -48px;}
+.icon-tags{background-position:-25px -48px;}
+.icon-book{background-position:-48px -48px;}
+.icon-bookmark{background-position:-72px -48px;}
+.icon-print{background-position:-96px -48px;}
+.icon-camera{background-position:-120px -48px;}
+.icon-font{background-position:-144px -48px;}
+.icon-bold{background-position:-167px -48px;}
+.icon-italic{background-position:-192px -48px;}
+.icon-text-height{background-position:-216px -48px;}
+.icon-text-width{background-position:-240px -48px;}
+.icon-align-left{background-position:-264px -48px;}
+.icon-align-center{background-position:-288px -48px;}
+.icon-align-right{background-position:-312px -48px;}
+.icon-align-justify{background-position:-336px -48px;}
+.icon-list{background-position:-360px -48px;}
+.icon-indent-left{background-position:-384px -48px;}
+.icon-indent-right{background-position:-408px -48px;}
+.icon-facetime-video{background-position:-432px -48px;}
+.icon-picture{background-position:-456px -48px;}
+.icon-pencil{background-position:0 -72px;}
+.icon-map-marker{background-position:-24px -72px;}
+.icon-adjust{background-position:-48px -72px;}
+.icon-tint{background-position:-72px -72px;}
+.icon-edit{background-position:-96px -72px;}
+.icon-share{background-position:-120px -72px;}
+.icon-check{background-position:-144px -72px;}
+.icon-move{background-position:-168px -72px;}
+.icon-step-backward{background-position:-192px -72px;}
+.icon-fast-backward{background-position:-216px -72px;}
+.icon-backward{background-position:-240px -72px;}
+.icon-play{background-position:-264px -72px;}
+.icon-pause{background-position:-288px -72px;}
+.icon-stop{background-position:-312px -72px;}
+.icon-forward{background-position:-336px -72px;}
+.icon-fast-forward{background-position:-360px -72px;}
+.icon-step-forward{background-position:-384px -72px;}
+.icon-eject{background-position:-408px -72px;}
+.icon-chevron-left{background-position:-432px -72px;}
+.icon-chevron-right{background-position:-456px -72px;}
+.icon-plus-sign{background-position:0 -96px;}
+.icon-minus-sign{background-position:-24px -96px;}
+.icon-remove-sign{background-position:-48px -96px;}
+.icon-ok-sign{background-position:-72px -96px;}
+.icon-question-sign{background-position:-96px -96px;}
+.icon-info-sign{background-position:-120px -96px;}
+.icon-screenshot{background-position:-144px -96px;}
+.icon-remove-circle{background-position:-168px -96px;}
+.icon-ok-circle{background-position:-192px -96px;}
+.icon-ban-circle{background-position:-216px -96px;}
+.icon-arrow-left{background-position:-240px -96px;}
+.icon-arrow-right{background-position:-264px -96px;}
+.icon-arrow-up{background-position:-289px -96px;}
+.icon-arrow-down{background-position:-312px -96px;}
+.icon-share-alt{background-position:-336px -96px;}
+.icon-resize-full{background-position:-360px -96px;}
+.icon-resize-small{background-position:-384px -96px;}
+.icon-plus{background-position:-408px -96px;}
+.icon-minus{background-position:-433px -96px;}
+.icon-asterisk{background-position:-456px -96px;}
+.icon-exclamation-sign{background-position:0 -120px;}
+.icon-gift{background-position:-24px -120px;}
+.icon-leaf{background-position:-48px -120px;}
+.icon-fire{background-position:-72px -120px;}
+.icon-eye-open{background-position:-96px -120px;}
+.icon-eye-close{background-position:-120px -120px;}
+.icon-warning-sign{background-position:-144px -120px;}
+.icon-plane{background-position:-168px -120px;}
+.icon-calendar{background-position:-192px -120px;}
+.icon-random{background-position:-216px -120px;width:16px;}
+.icon-comment{background-position:-240px -120px;}
+.icon-magnet{background-position:-264px -120px;}
+.icon-chevron-up{background-position:-288px -120px;}
+.icon-chevron-down{background-position:-313px -119px;}
+.icon-retweet{background-position:-336px -120px;}
+.icon-shopping-cart{background-position:-360px -120px;}
+.icon-folder-close{background-position:-384px -120px;width:16px;}
+.icon-folder-open{background-position:-408px -120px;width:16px;}
+.icon-resize-vertical{background-position:-432px -119px;}
+.icon-resize-horizontal{background-position:-456px -118px;}
+.icon-hdd{background-position:0 -144px;}
+.icon-bullhorn{background-position:-24px -144px;}
+.icon-bell{background-position:-48px -144px;}
+.icon-certificate{background-position:-72px -144px;}
+.icon-thumbs-up{background-position:-96px -144px;}
+.icon-thumbs-down{background-position:-120px -144px;}
+.icon-hand-right{background-position:-144px -144px;}
+.icon-hand-left{background-position:-168px -144px;}
+.icon-hand-up{background-position:-192px -144px;}
+.icon-hand-down{background-position:-216px -144px;}
+.icon-circle-arrow-right{background-position:-240px -144px;}
+.icon-circle-arrow-left{background-position:-264px -144px;}
+.icon-circle-arrow-up{background-position:-288px -144px;}
+.icon-circle-arrow-down{background-position:-312px -144px;}
+.icon-globe{background-position:-336px -144px;}
+.icon-wrench{background-position:-360px -144px;}
+.icon-tasks{background-position:-384px -144px;}
+.icon-filter{background-position:-408px -144px;}
+.icon-briefcase{background-position:-432px -144px;}
+.icon-fullscreen{background-position:-456px -144px;}
+.btn-group{position:relative;display:inline-block;*display:inline;*zoom:1;font-size:0;vertical-align:middle;white-space:nowrap;*margin-left:.3em;}.btn-group:first-child{*margin-left:0;}
+.btn-group+.btn-group{margin-left:5px;}
+.btn-toolbar{font-size:0;margin-top:10px;margin-bottom:10px;}.btn-toolbar>.btn+.btn,.btn-toolbar>.btn-group+.btn,.btn-toolbar>.btn+.btn-group{margin-left:5px;}
+.btn-group>.btn{position:relative;-webkit-border-radius:0;-moz-border-radius:0;border-radius:0;}
+.btn-group>.btn+.btn{margin-left:-1px;}
+.btn-group>.btn,.btn-group>.dropdown-menu,.btn-group>.popover{font-size:14px;}
+.btn-group>.btn-mini{font-size:10.5px;}
+.btn-group>.btn-small{font-size:11.9px;}
+.btn-group>.btn-large{font-size:17.5px;}
+.btn-group>.btn:first-child{margin-left:0;-webkit-border-top-left-radius:4px;-moz-border-radius-topleft:4px;border-top-left-radius:4px;-webkit-border-bottom-left-radius:4px;-moz-border-radius-bottomleft:4px;border-bottom-left-radius:4px;}
+.btn-group>.btn:last-child,.btn-group>.dropdown-toggle{-webkit-border-top-right-radius:4px;-moz-border-radius-topright:4px;border-top-right-radius:4px;-webkit-border-bottom-right-radius:4px;-moz-border-radius-bottomright:4px;border-bottom-right-radius:4px;}
+.btn-group>.btn.large:first-child{margin-left:0;-webkit-border-top-left-radius:6px;-moz-border-radius-topleft:6px;border-top-left-radius:6px;-webkit-border-bottom-left-radius:6px;-moz-border-radius-bottomleft:6px;border-bottom-left-radius:6px;}
+.btn-group>.btn.large:last-child,.btn-group>.large.dropdown-toggle{-webkit-border-top-right-radius:6px;-moz-border-radius-topright:6px;border-top-right-radius:6px;-webkit-border-bottom-right-radius:6px;-moz-border-radius-bottomright:6px;border-bottom-right-radius:6px;}
+.btn-group>.btn:hover,.btn-group>.btn:focus,.btn-group>.btn:active,.btn-group>.btn.active{z-index:2;}
+.btn-group .dropdown-toggle:active,.btn-group.open .dropdown-toggle{outline:0;}
+.btn-group>.btn+.dropdown-toggle{padding-left:8px;padding-right:8px;-webkit-box-shadow:inset 1px 0 0 rgba(255,255,255,.125), inset 0 1px 0 rgba(255,255,255,.2), 0 1px 2px rgba(0,0,0,.05);-moz-box-shadow:inset 1px 0 0 rgba(255,255,255,.125), inset 0 1px 0 rgba(255,255,255,.2), 0 1px 2px rgba(0,0,0,.05);box-shadow:inset 1px 0 0 rgba(255,255,255,.125), inset 0 1px 0 rgba(255,255,255,.2), 0 1px 2px rgba(0,0,0,.05);*padding-top:5px;*padding-bottom:5px;}
+.btn-group>.btn-mini+.dropdown-toggle{padding-left:5px;padding-right:5px;*padding-top:2px;*padding-bottom:2px;}
+.btn-group>.btn-small+.dropdown-toggle{*padding-top:5px;*padding-bottom:4px;}
+.btn-group>.btn-large+.dropdown-toggle{padding-left:12px;padding-right:12px;*padding-top:7px;*padding-bottom:7px;}
+.btn-group.open .dropdown-toggle{background-image:none;-webkit-box-shadow:inset 0 2px 4px rgba(0,0,0,.15), 0 1px 2px rgba(0,0,0,.05);-moz-box-shadow:inset 0 2px 4px rgba(0,0,0,.15), 0 1px 2px rgba(0,0,0,.05);box-shadow:inset 0 2px 4px rgba(0,0,0,.15), 0 1px 2px rgba(0,0,0,.05);}
+.btn-group.open .btn.dropdown-toggle{background-color:#e6e6e6;}
+.btn-group.open .btn-primary.dropdown-toggle{background-color:#0044cc;}
+.btn-group.open .btn-warning.dropdown-toggle{background-color:#f89406;}
+.btn-group.open .btn-danger.dropdown-toggle{background-color:#bd362f;}
+.btn-group.open .btn-success.dropdown-toggle{background-color:#51a351;}
+.btn-group.open .btn-info.dropdown-toggle{background-color:#2f96b4;}
+.btn-group.open .btn-inverse.dropdown-toggle{background-color:#222222;}
+.btn .caret{margin-top:8px;margin-left:0;}
+.btn-large .caret{margin-top:6px;}
+.btn-large .caret{border-left-width:5px;border-right-width:5px;border-top-width:5px;}
+.btn-mini .caret,.btn-small .caret{margin-top:8px;}
+.dropup .btn-large .caret{border-bottom-width:5px;}
+.btn-primary .caret,.btn-warning .caret,.btn-danger .caret,.btn-info .caret,.btn-success .caret,.btn-inverse .caret{border-top-color:#ffffff;border-bottom-color:#ffffff;}
+.btn-group-vertical{display:inline-block;*display:inline;*zoom:1;}
+.btn-group-vertical>.btn{display:block;float:none;max-width:100%;-webkit-border-radius:0;-moz-border-radius:0;border-radius:0;}
+.btn-group-vertical>.btn+.btn{margin-left:0;margin-top:-1px;}
+.btn-group-vertical>.btn:first-child{-webkit-border-radius:4px 4px 0 0;-moz-border-radius:4px 4px 0 0;border-radius:4px 4px 0 0;}
+.btn-group-vertical>.btn:last-child{-webkit-border-radius:0 0 4px 4px;-moz-border-radius:0 0 4px 4px;border-radius:0 0 4px 4px;}
+.btn-group-vertical>.btn-large:first-child{-webkit-border-radius:6px 6px 0 0;-moz-border-radius:6px 6px 0 0;border-radius:6px 6px 0 0;}
+.btn-group-vertical>.btn-large:last-child{-webkit-border-radius:0 0 6px 6px;-moz-border-radius:0 0 6px 6px;border-radius:0 0 6px 6px;}
+.nav{margin-left:0;margin-bottom:20px;list-style:none;}
+.nav>li>a{display:block;}
+.nav>li>a:hover,.nav>li>a:focus{text-decoration:none;background-color:#eeeeee;}
+.nav>li>a>img{max-width:none;}
+.nav>.pull-right{float:right;}
+.nav-header{display:block;padding:3px 15px;font-size:11px;font-weight:bold;line-height:20px;color:#999999;text-shadow:0 1px 0 rgba(255, 255, 255, 0.5);text-transform:uppercase;}
+.nav li+.nav-header{margin-top:9px;}
+.nav-list{padding-left:15px;padding-right:15px;margin-bottom:0;}
+.nav-list>li>a,.nav-list .nav-header{margin-left:-15px;margin-right:-15px;text-shadow:0 1px 0 rgba(255, 255, 255, 0.5);}
+.nav-list>li>a{padding:3px 15px;}
+.nav-list>.active>a,.nav-list>.active>a:hover,.nav-list>.active>a:focus{color:#ffffff;text-shadow:0 -1px 0 rgba(0, 0, 0, 0.2);background-color:#0088cc;}
+.nav-list [class^="icon-"],.nav-list [class*=" icon-"]{margin-right:2px;}
+.nav-list .divider{*width:100%;height:1px;margin:9px 1px;*margin:-5px 0 5px;overflow:hidden;background-color:#e5e5e5;border-bottom:1px solid #ffffff;}
+.nav-tabs,.nav-pills{*zoom:1;}.nav-tabs:before,.nav-pills:before,.nav-tabs:after,.nav-pills:after{display:table;content:"";line-height:0;}
+.nav-tabs:after,.nav-pills:after{clear:both;}
+.nav-tabs>li,.nav-pills>li{float:left;}
+.nav-tabs>li>a,.nav-pills>li>a{padding-right:12px;padding-left:12px;margin-right:2px;line-height:14px;}
+.nav-tabs{border-bottom:1px solid #ddd;}
+.nav-tabs>li{margin-bottom:-1px;}
+.nav-tabs>li>a{padding-top:8px;padding-bottom:8px;line-height:20px;border:1px solid transparent;-webkit-border-radius:4px 4px 0 0;-moz-border-radius:4px 4px 0 0;border-radius:4px 4px 0 0;}.nav-tabs>li>a:hover,.nav-tabs>li>a:focus{border-color:#eeeeee #eeeeee #dddddd;}
+.nav-tabs>.active>a,.nav-tabs>.active>a:hover,.nav-tabs>.active>a:focus{color:#555555;background-color:#ffffff;border:1px solid #ddd;border-bottom-color:transparent;cursor:default;}
+.nav-pills>li>a{padding-top:8px;padding-bottom:8px;margin-top:2px;margin-bottom:2px;-webkit-border-radius:5px;-moz-border-radius:5px;border-radius:5px;}
+.nav-pills>.active>a,.nav-pills>.active>a:hover,.nav-pills>.active>a:focus{color:#ffffff;background-color:#0088cc;}
+.nav-stacked>li{float:none;}
+.nav-stacked>li>a{margin-right:0;}
+.nav-tabs.nav-stacked{border-bottom:0;}
+.nav-tabs.nav-stacked>li>a{border:1px solid #ddd;-webkit-border-radius:0;-moz-border-radius:0;border-radius:0;}
+.nav-tabs.nav-stacked>li:first-child>a{-webkit-border-top-right-radius:4px;-moz-border-radius-topright:4px;border-top-right-radius:4px;-webkit-border-top-left-radius:4px;-moz-border-radius-topleft:4px;border-top-left-radius:4px;}
+.nav-tabs.nav-stacked>li:last-child>a{-webkit-border-bottom-right-radius:4px;-moz-border-radius-bottomright:4px;border-bottom-right-radius:4px;-webkit-border-bottom-left-radius:4px;-moz-border-radius-bottomleft:4px;border-bottom-left-radius:4px;}
+.nav-tabs.nav-stacked>li>a:hover,.nav-tabs.nav-stacked>li>a:focus{border-color:#ddd;z-index:2;}
+.nav-pills.nav-stacked>li>a{margin-bottom:3px;}
+.nav-pills.nav-stacked>li:last-child>a{margin-bottom:1px;}
+.nav-tabs .dropdown-menu{-webkit-border-radius:0 0 6px 6px;-moz-border-radius:0 0 6px 6px;border-radius:0 0 6px 6px;}
+.nav-pills .dropdown-menu{-webkit-border-radius:6px;-moz-border-radius:6px;border-radius:6px;}
+.nav .dropdown-toggle .caret{border-top-color:#0088cc;border-bottom-color:#0088cc;margin-top:6px;}
+.nav .dropdown-toggle:hover .caret,.nav .dropdown-toggle:focus .caret{border-top-color:#005580;border-bottom-color:#005580;}
+.nav-tabs .dropdown-toggle .caret{margin-top:8px;}
+.nav .active .dropdown-toggle .caret{border-top-color:#fff;border-bottom-color:#fff;}
+.nav-tabs .active .dropdown-toggle .caret{border-top-color:#555555;border-bottom-color:#555555;}
+.nav>.dropdown.active>a:hover,.nav>.dropdown.active>a:focus{cursor:pointer;}
+.nav-tabs .open .dropdown-toggle,.nav-pills .open .dropdown-toggle,.nav>li.dropdown.open.active>a:hover,.nav>li.dropdown.open.active>a:focus{color:#ffffff;background-color:#999999;border-color:#999999;}
+.nav li.dropdown.open .caret,.nav li.dropdown.open.active .caret,.nav li.dropdown.open a:hover .caret,.nav li.dropdown.open a:focus .caret{border-top-color:#ffffff;border-bottom-color:#ffffff;opacity:1;filter:alpha(opacity=100);}
+.tabs-stacked .open>a:hover,.tabs-stacked .open>a:focus{border-color:#999999;}
+.tabbable{*zoom:1;}.tabbable:before,.tabbable:after{display:table;content:"";line-height:0;}
+.tabbable:after{clear:both;}
+.tab-content{overflow:auto;}
+.tabs-below>.nav-tabs,.tabs-right>.nav-tabs,.tabs-left>.nav-tabs{border-bottom:0;}
+.tab-content>.tab-pane,.pill-content>.pill-pane{display:none;}
+.tab-content>.active,.pill-content>.active{display:block;}
+.tabs-below>.nav-tabs{border-top:1px solid #ddd;}
+.tabs-below>.nav-tabs>li{margin-top:-1px;margin-bottom:0;}
+.tabs-below>.nav-tabs>li>a{-webkit-border-radius:0 0 4px 4px;-moz-border-radius:0 0 4px 4px;border-radius:0 0 4px 4px;}.tabs-below>.nav-tabs>li>a:hover,.tabs-below>.nav-tabs>li>a:focus{border-bottom-color:transparent;border-top-color:#ddd;}
+.tabs-below>.nav-tabs>.active>a,.tabs-below>.nav-tabs>.active>a:hover,.tabs-below>.nav-tabs>.active>a:focus{border-color:transparent #ddd #ddd #ddd;}
+.tabs-left>.nav-tabs>li,.tabs-right>.nav-tabs>li{float:none;}
+.tabs-left>.nav-tabs>li>a,.tabs-right>.nav-tabs>li>a{min-width:74px;margin-right:0;margin-bottom:3px;}
+.tabs-left>.nav-tabs{float:left;margin-right:19px;border-right:1px solid #ddd;}
+.tabs-left>.nav-tabs>li>a{margin-right:-1px;-webkit-border-radius:4px 0 0 4px;-moz-border-radius:4px 0 0 4px;border-radius:4px 0 0 4px;}
+.tabs-left>.nav-tabs>li>a:hover,.tabs-left>.nav-tabs>li>a:focus{border-color:#eeeeee #dddddd #eeeeee #eeeeee;}
+.tabs-left>.nav-tabs .active>a,.tabs-left>.nav-tabs .active>a:hover,.tabs-left>.nav-tabs .active>a:focus{border-color:#ddd transparent #ddd #ddd;*border-right-color:#ffffff;}
+.tabs-right>.nav-tabs{float:right;margin-left:19px;border-left:1px solid #ddd;}
+.tabs-right>.nav-tabs>li>a{margin-left:-1px;-webkit-border-radius:0 4px 4px 0;-moz-border-radius:0 4px 4px 0;border-radius:0 4px 4px 0;}
+.tabs-right>.nav-tabs>li>a:hover,.tabs-right>.nav-tabs>li>a:focus{border-color:#eeeeee #eeeeee #eeeeee #dddddd;}
+.tabs-right>.nav-tabs .active>a,.tabs-right>.nav-tabs .active>a:hover,.tabs-right>.nav-tabs .active>a:focus{border-color:#ddd #ddd #ddd transparent;*border-left-color:#ffffff;}
+.nav>.disabled>a{color:#999999;}
+.nav>.disabled>a:hover,.nav>.disabled>a:focus{text-decoration:none;background-color:transparent;cursor:default;}
+.navbar{overflow:visible;margin-bottom:20px;*position:relative;*z-index:2;}
+.navbar-inner{min-height:40px;padding-left:20px;padding-right:20px;background-color:#fafafa;background-image:-moz-linear-gradient(top, #ffffff, #f2f2f2);background-image:-webkit-gradient(linear, 0 0, 0 100%, from(#ffffff), to(#f2f2f2));background-image:-webkit-linear-gradient(top, #ffffff, #f2f2f2);background-image:-o-linear-gradient(top, #ffffff, #f2f2f2);background-image:linear-gradient(to bottom, #ffffff, #f2f2f2);background-repeat:repeat-x;filter:progid:DXImageTransform.Microsoft.gradient(startColorstr='#ffffffff', endColorstr='#fff2f2f2', GradientType=0);border:1px solid #d4d4d4;-webkit-border-radius:4px;-moz-border-radius:4px;border-radius:4px;-webkit-box-shadow:0 1px 4px rgba(0, 0, 0, 0.065);-moz-box-shadow:0 1px 4px rgba(0, 0, 0, 0.065);box-shadow:0 1px 4px rgba(0, 0, 0, 0.065);*zoom:1;}.navbar-inner:before,.navbar-inner:after{display:table;content:"";line-height:0;}
+.navbar-inner:after{clear:both;}
+.navbar .container{width:auto;}
+.nav-collapse.collapse{height:auto;overflow:visible;}
+.navbar .brand{float:left;display:block;padding:10px 20px 10px;margin-left:-20px;font-size:20px;font-weight:200;color:#777777;text-shadow:0 1px 0 #ffffff;}.navbar .brand:hover,.navbar .brand:focus{text-decoration:none;}
+.navbar-text{margin-bottom:0;line-height:40px;color:#777777;}
+.navbar-link{color:#777777;}.navbar-link:hover,.navbar-link:focus{color:#333333;}
+.navbar .divider-vertical{height:40px;margin:0 9px;border-left:1px solid #f2f2f2;border-right:1px solid #ffffff;}
+.navbar .btn,.navbar .btn-group{margin-top:5px;}
+.navbar .btn-group .btn,.navbar .input-prepend .btn,.navbar .input-append .btn,.navbar .input-prepend .btn-group,.navbar .input-append .btn-group{margin-top:0;}
+.navbar-form{margin-bottom:0;*zoom:1;}.navbar-form:before,.navbar-form:after{display:table;content:"";line-height:0;}
+.navbar-form:after{clear:both;}
+.navbar-form input,.navbar-form select,.navbar-form .radio,.navbar-form .checkbox{margin-top:5px;}
+.navbar-form input,.navbar-form select,.navbar-form .btn{display:inline-block;margin-bottom:0;}
+.navbar-form input[type="image"],.navbar-form input[type="checkbox"],.navbar-form input[type="radio"]{margin-top:3px;}
+.navbar-form .input-append,.navbar-form .input-prepend{margin-top:5px;white-space:nowrap;}.navbar-form .input-append input,.navbar-form .input-prepend input{margin-top:0;}
+.navbar-search{position:relative;float:left;margin-top:5px;margin-bottom:0;}.navbar-search .search-query{margin-bottom:0;padding:4px 14px;font-family:"Helvetica Neue",Helvetica,Arial,sans-serif;font-size:13px;font-weight:normal;line-height:1;-webkit-border-radius:15px;-moz-border-radius:15px;border-radius:15px;}
+.navbar-static-top{position:static;margin-bottom:0;}.navbar-static-top .navbar-inner{-webkit-border-radius:0;-moz-border-radius:0;border-radius:0;}
+.navbar-fixed-top,.navbar-fixed-bottom{position:fixed;right:0;left:0;z-index:1030;margin-bottom:0;}
+.navbar-fixed-top .navbar-inner,.navbar-static-top .navbar-inner{border-width:0 0 1px;}
+.navbar-fixed-bottom .navbar-inner{border-width:1px 0 0;}
+.navbar-fixed-top .navbar-inner,.navbar-fixed-bottom .navbar-inner{padding-left:0;padding-right:0;-webkit-border-radius:0;-moz-border-radius:0;border-radius:0;}
+.navbar-static-top .container,.navbar-fixed-top .container,.navbar-fixed-bottom .container{width:940px;}
+.navbar-fixed-top{top:0;}
+.navbar-fixed-top .navbar-inner,.navbar-static-top .navbar-inner{-webkit-box-shadow:0 1px 10px rgba(0,0,0,.1);-moz-box-shadow:0 1px 10px rgba(0,0,0,.1);box-shadow:0 1px 10px rgba(0,0,0,.1);}
+.navbar-fixed-bottom{bottom:0;}.navbar-fixed-bottom .navbar-inner{-webkit-box-shadow:0 -1px 10px rgba(0,0,0,.1);-moz-box-shadow:0 -1px 10px rgba(0,0,0,.1);box-shadow:0 -1px 10px rgba(0,0,0,.1);}
+.navbar .nav{position:relative;left:0;display:block;float:left;margin:0 10px 0 0;}
+.navbar .nav.pull-right{float:right;margin-right:0;}
+.navbar .nav>li{float:left;}
+.navbar .nav>li>a{float:none;padding:10px 15px 10px;color:#777777;text-decoration:none;text-shadow:0 1px 0 #ffffff;}
+.navbar .nav .dropdown-toggle .caret{margin-top:8px;}
+.navbar .nav>li>a:focus,.navbar .nav>li>a:hover{background-color:transparent;color:#333333;text-decoration:none;}
+.navbar .nav>.active>a,.navbar .nav>.active>a:hover,.navbar .nav>.active>a:focus{color:#555555;text-decoration:none;background-color:#e5e5e5;-webkit-box-shadow:inset 0 3px 8px rgba(0, 0, 0, 0.125);-moz-box-shadow:inset 0 3px 8px rgba(0, 0, 0, 0.125);box-shadow:inset 0 3px 8px rgba(0, 0, 0, 0.125);}
+.navbar .btn-navbar{display:none;float:right;padding:7px 10px;margin-left:5px;margin-right:5px;color:#ffffff;text-shadow:0 -1px 0 rgba(0, 0, 0, 0.25);background-color:#ededed;background-image:-moz-linear-gradient(top, #f2f2f2, #e5e5e5);background-image:-webkit-gradient(linear, 0 0, 0 100%, from(#f2f2f2), to(#e5e5e5));background-image:-webkit-linear-gradient(top, #f2f2f2, #e5e5e5);background-image:-o-linear-gradient(top, #f2f2f2, #e5e5e5);background-image:linear-gradient(to bottom, #f2f2f2, #e5e5e5);background-repeat:repeat-x;filter:progid:DXImageTransform.Microsoft.gradient(startColorstr='#fff2f2f2', endColorstr='#ffe5e5e5', GradientType=0);border-color:#e5e5e5 #e5e5e5 #bfbfbf;border-color:rgba(0, 0, 0, 0.1) rgba(0, 0, 0, 0.1) rgba(0, 0, 0, 0.25);*background-color:#e5e5e5;filter:progid:DXImageTransform.Microsoft.gradient(enabled = false);-webkit-box-shadow:inset 0 1px 0 rgba(255,255,255,.1), 0 1px 0 rgba(255,255,255,.075);-moz-box-shadow:inset 0 1px 0 rgba(255,255,255,.1), 0 1px 0 rgba(255,255,255,.075);box-shadow:inset 0 1px 0 rgba(255,255,255,.1), 0 1px 0 rgba(255,255,255,.075);}.navbar .btn-navbar:hover,.navbar .btn-navbar:focus,.navbar .btn-navbar:active,.navbar .btn-navbar.active,.navbar .btn-navbar.disabled,.navbar .btn-navbar[disabled]{color:#ffffff;background-color:#e5e5e5;*background-color:#d9d9d9;}
+.navbar .btn-navbar:active,.navbar .btn-navbar.active{background-color:#cccccc \9;}
+.navbar .btn-navbar .icon-bar{display:block;width:18px;height:2px;background-color:#f5f5f5;-webkit-border-radius:1px;-moz-border-radius:1px;border-radius:1px;-webkit-box-shadow:0 1px 0 rgba(0, 0, 0, 0.25);-moz-box-shadow:0 1px 0 rgba(0, 0, 0, 0.25);box-shadow:0 1px 0 rgba(0, 0, 0, 0.25);}
+.btn-navbar .icon-bar+.icon-bar{margin-top:3px;}
+.navbar .nav>li>.dropdown-menu:before{content:'';display:inline-block;border-left:7px solid transparent;border-right:7px solid transparent;border-bottom:7px solid #ccc;border-bottom-color:rgba(0, 0, 0, 0.2);position:absolute;top:-7px;left:9px;}
+.navbar .nav>li>.dropdown-menu:after{content:'';display:inline-block;border-left:6px solid transparent;border-right:6px solid transparent;border-bottom:6px solid #ffffff;position:absolute;top:-6px;left:10px;}
+.navbar-fixed-bottom .nav>li>.dropdown-menu:before{border-top:7px solid #ccc;border-top-color:rgba(0, 0, 0, 0.2);border-bottom:0;bottom:-7px;top:auto;}
+.navbar-fixed-bottom .nav>li>.dropdown-menu:after{border-top:6px solid #ffffff;border-bottom:0;bottom:-6px;top:auto;}
+.navbar .nav li.dropdown>a:hover .caret,.navbar .nav li.dropdown>a:focus .caret{border-top-color:#333333;border-bottom-color:#333333;}
+.navbar .nav li.dropdown.open>.dropdown-toggle,.navbar .nav li.dropdown.active>.dropdown-toggle,.navbar .nav li.dropdown.open.active>.dropdown-toggle{background-color:#e5e5e5;color:#555555;}
+.navbar .nav li.dropdown>.dropdown-toggle .caret{border-top-color:#777777;border-bottom-color:#777777;}
+.navbar .nav li.dropdown.open>.dropdown-toggle .caret,.navbar .nav li.dropdown.active>.dropdown-toggle .caret,.navbar .nav li.dropdown.open.active>.dropdown-toggle .caret{border-top-color:#555555;border-bottom-color:#555555;}
+.navbar .pull-right>li>.dropdown-menu,.navbar .nav>li>.dropdown-menu.pull-right{left:auto;right:0;}.navbar .pull-right>li>.dropdown-menu:before,.navbar .nav>li>.dropdown-menu.pull-right:before{left:auto;right:12px;}
+.navbar .pull-right>li>.dropdown-menu:after,.navbar .nav>li>.dropdown-menu.pull-right:after{left:auto;right:13px;}
+.navbar .pull-right>li>.dropdown-menu .dropdown-menu,.navbar .nav>li>.dropdown-menu.pull-right .dropdown-menu{left:auto;right:100%;margin-left:0;margin-right:-1px;-webkit-border-radius:6px 0 6px 6px;-moz-border-radius:6px 0 6px 6px;border-radius:6px 0 6px 6px;}
+.navbar-inverse .navbar-inner{background-color:#1b1b1b;background-image:-moz-linear-gradient(top, #222222, #111111);background-image:-webkit-gradient(linear, 0 0, 0 100%, from(#222222), to(#111111));background-image:-webkit-linear-gradient(top, #222222, #111111);background-image:-o-linear-gradient(top, #222222, #111111);background-image:linear-gradient(to bottom, #222222, #111111);background-repeat:repeat-x;filter:progid:DXImageTransform.Microsoft.gradient(startColorstr='#ff222222', endColorstr='#ff111111', GradientType=0);border-color:#252525;}
+.navbar-inverse .brand,.navbar-inverse .nav>li>a{color:#999999;text-shadow:0 -1px 0 rgba(0, 0, 0, 0.25);}.navbar-inverse .brand:hover,.navbar-inverse .nav>li>a:hover,.navbar-inverse .brand:focus,.navbar-inverse .nav>li>a:focus{color:#ffffff;}
+.navbar-inverse .brand{color:#999999;}
+.navbar-inverse .navbar-text{color:#999999;}
+.navbar-inverse .nav>li>a:focus,.navbar-inverse .nav>li>a:hover{background-color:transparent;color:#ffffff;}
+.navbar-inverse .nav .active>a,.navbar-inverse .nav .active>a:hover,.navbar-inverse .nav .active>a:focus{color:#ffffff;background-color:#111111;}
+.navbar-inverse .navbar-link{color:#999999;}.navbar-inverse .navbar-link:hover,.navbar-inverse .navbar-link:focus{color:#ffffff;}
+.navbar-inverse .divider-vertical{border-left-color:#111111;border-right-color:#222222;}
+.navbar-inverse .nav li.dropdown.open>.dropdown-toggle,.navbar-inverse .nav li.dropdown.active>.dropdown-toggle,.navbar-inverse .nav li.dropdown.open.active>.dropdown-toggle{background-color:#111111;color:#ffffff;}
+.navbar-inverse .nav li.dropdown>a:hover .caret,.navbar-inverse .nav li.dropdown>a:focus .caret{border-top-color:#ffffff;border-bottom-color:#ffffff;}
+.navbar-inverse .nav li.dropdown>.dropdown-toggle .caret{border-top-color:#999999;border-bottom-color:#999999;}
+.navbar-inverse .nav li.dropdown.open>.dropdown-toggle .caret,.navbar-inverse .nav li.dropdown.active>.dropdown-toggle .caret,.navbar-inverse .nav li.dropdown.open.active>.dropdown-toggle .caret{border-top-color:#ffffff;border-bottom-color:#ffffff;}
+.navbar-inverse .navbar-search .search-query{color:#ffffff;background-color:#515151;border-color:#111111;-webkit-box-shadow:inset 0 1px 2px rgba(0,0,0,.1), 0 1px 0 rgba(255,255,255,.15);-moz-box-shadow:inset 0 1px 2px rgba(0,0,0,.1), 0 1px 0 rgba(255,255,255,.15);box-shadow:inset 0 1px 2px rgba(0,0,0,.1), 0 1px 0 rgba(255,255,255,.15);-webkit-transition:none;-moz-transition:none;-o-transition:none;transition:none;}.navbar-inverse .navbar-search .search-query:-moz-placeholder{color:#cccccc;}
+.navbar-inverse .navbar-search .search-query:-ms-input-placeholder{color:#cccccc;}
+.navbar-inverse .navbar-search .search-query::-webkit-input-placeholder{color:#cccccc;}
+.navbar-inverse .navbar-search .search-query:focus,.navbar-inverse .navbar-search .search-query.focused{padding:5px 15px;color:#333333;text-shadow:0 1px 0 #ffffff;background-color:#ffffff;border:0;-webkit-box-shadow:0 0 3px rgba(0, 0, 0, 0.15);-moz-box-shadow:0 0 3px rgba(0, 0, 0, 0.15);box-shadow:0 0 3px rgba(0, 0, 0, 0.15);outline:0;}
+.navbar-inverse .btn-navbar{color:#ffffff;text-shadow:0 -1px 0 rgba(0, 0, 0, 0.25);background-color:#0e0e0e;background-image:-moz-linear-gradient(top, #151515, #040404);background-image:-webkit-gradient(linear, 0 0, 0 100%, from(#151515), to(#040404));background-image:-webkit-linear-gradient(top, #151515, #040404);background-image:-o-linear-gradient(top, #151515, #040404);background-image:linear-gradient(to bottom, #151515, #040404);background-repeat:repeat-x;filter:progid:DXImageTransform.Microsoft.gradient(startColorstr='#ff151515', endColorstr='#ff040404', GradientType=0);border-color:#040404 #040404 #000000;border-color:rgba(0, 0, 0, 0.1) rgba(0, 0, 0, 0.1) rgba(0, 0, 0, 0.25);*background-color:#040404;filter:progid:DXImageTransform.Microsoft.gradient(enabled = false);}.navbar-inverse .btn-navbar:hover,.navbar-inverse .btn-navbar:focus,.navbar-inverse .btn-navbar:active,.navbar-inverse .btn-navbar.active,.navbar-inverse .btn-navbar.disabled,.navbar-inverse .btn-navbar[disabled]{color:#ffffff;background-color:#040404;*background-color:#000000;}
+.navbar-inverse .btn-navbar:active,.navbar-inverse .btn-navbar.active{background-color:#000000 \9;}
+.breadcrumb{padding:8px 15px;margin:0 0 20px;list-style:none;background-color:#f5f5f5;-webkit-border-radius:4px;-moz-border-radius:4px;border-radius:4px;}.breadcrumb>li{display:inline-block;*display:inline;*zoom:1;text-shadow:0 1px 0 #ffffff;}.breadcrumb>li>.divider{padding:0 5px;color:#ccc;}
+.breadcrumb>.active{color:#999999;}
+.pagination{margin:20px 0;}
+.pagination ul{display:inline-block;*display:inline;*zoom:1;margin-left:0;margin-bottom:0;-webkit-border-radius:4px;-moz-border-radius:4px;border-radius:4px;-webkit-box-shadow:0 1px 2px rgba(0, 0, 0, 0.05);-moz-box-shadow:0 1px 2px rgba(0, 0, 0, 0.05);box-shadow:0 1px 2px rgba(0, 0, 0, 0.05);}
+.pagination ul>li{display:inline;}
+.pagination ul>li>a,.pagination ul>li>span{float:left;padding:4px 12px;line-height:20px;text-decoration:none;background-color:#ffffff;border:1px solid #dddddd;border-left-width:0;}
+.pagination ul>li>a:hover,.pagination ul>li>a:focus,.pagination ul>.active>a,.pagination ul>.active>span{background-color:#f5f5f5;}
+.pagination ul>.active>a,.pagination ul>.active>span{color:#999999;cursor:default;}
+.pagination ul>.disabled>span,.pagination ul>.disabled>a,.pagination ul>.disabled>a:hover,.pagination ul>.disabled>a:focus{color:#999999;background-color:transparent;cursor:default;}
+.pagination ul>li:first-child>a,.pagination ul>li:first-child>span{border-left-width:1px;-webkit-border-top-left-radius:4px;-moz-border-radius-topleft:4px;border-top-left-radius:4px;-webkit-border-bottom-left-radius:4px;-moz-border-radius-bottomleft:4px;border-bottom-left-radius:4px;}
+.pagination ul>li:last-child>a,.pagination ul>li:last-child>span{-webkit-border-top-right-radius:4px;-moz-border-radius-topright:4px;border-top-right-radius:4px;-webkit-border-bottom-right-radius:4px;-moz-border-radius-bottomright:4px;border-bottom-right-radius:4px;}
+.pagination-centered{text-align:center;}
+.pagination-right{text-align:right;}
+.pagination-large ul>li>a,.pagination-large ul>li>span{padding:11px 19px;font-size:17.5px;}
+.pagination-large ul>li:first-child>a,.pagination-large ul>li:first-child>span{-webkit-border-top-left-radius:6px;-moz-border-radius-topleft:6px;border-top-left-radius:6px;-webkit-border-bottom-left-radius:6px;-moz-border-radius-bottomleft:6px;border-bottom-left-radius:6px;}
+.pagination-large ul>li:last-child>a,.pagination-large ul>li:last-child>span{-webkit-border-top-right-radius:6px;-moz-border-radius-topright:6px;border-top-right-radius:6px;-webkit-border-bottom-right-radius:6px;-moz-border-radius-bottomright:6px;border-bottom-right-radius:6px;}
+.pagination-mini ul>li:first-child>a,.pagination-small ul>li:first-child>a,.pagination-mini ul>li:first-child>span,.pagination-small ul>li:first-child>span{-webkit-border-top-left-radius:3px;-moz-border-radius-topleft:3px;border-top-left-radius:3px;-webkit-border-bottom-left-radius:3px;-moz-border-radius-bottomleft:3px;border-bottom-left-radius:3px;}
+.pagination-mini ul>li:last-child>a,.pagination-small ul>li:last-child>a,.pagination-mini ul>li:last-child>span,.pagination-small ul>li:last-child>span{-webkit-border-top-right-radius:3px;-moz-border-radius-topright:3px;border-top-right-radius:3px;-webkit-border-bottom-right-radius:3px;-moz-border-radius-bottomright:3px;border-bottom-right-radius:3px;}
+.pagination-small ul>li>a,.pagination-small ul>li>span{padding:2px 10px;font-size:11.9px;}
+.pagination-mini ul>li>a,.pagination-mini ul>li>span{padding:0 6px;font-size:10.5px;}
+.pager{margin:20px 0;list-style:none;text-align:center;*zoom:1;}.pager:before,.pager:after{display:table;content:"";line-height:0;}
+.pager:after{clear:both;}
+.pager li{display:inline;}
+.pager li>a,.pager li>span{display:inline-block;padding:5px 14px;background-color:#fff;border:1px solid #ddd;-webkit-border-radius:15px;-moz-border-radius:15px;border-radius:15px;}
+.pager li>a:hover,.pager li>a:focus{text-decoration:none;background-color:#f5f5f5;}
+.pager .next>a,.pager .next>span{float:right;}
+.pager .previous>a,.pager .previous>span{float:left;}
+.pager .disabled>a,.pager .disabled>a:hover,.pager .disabled>a:focus,.pager .disabled>span{color:#999999;background-color:#fff;cursor:default;}
+.thumbnails{margin-left:-20px;list-style:none;*zoom:1;}.thumbnails:before,.thumbnails:after{display:table;content:"";line-height:0;}
+.thumbnails:after{clear:both;}
+.row-fluid .thumbnails{margin-left:0;}
+.thumbnails>li{float:left;margin-bottom:20px;margin-left:20px;}
+.thumbnail{display:block;padding:4px;line-height:20px;border:1px solid #ddd;-webkit-border-radius:4px;-moz-border-radius:4px;border-radius:4px;-webkit-box-shadow:0 1px 3px rgba(0, 0, 0, 0.055);-moz-box-shadow:0 1px 3px rgba(0, 0, 0, 0.055);box-shadow:0 1px 3px rgba(0, 0, 0, 0.055);-webkit-transition:all 0.2s ease-in-out;-moz-transition:all 0.2s ease-in-out;-o-transition:all 0.2s ease-in-out;transition:all 0.2s ease-in-out;}
+a.thumbnail:hover,a.thumbnail:focus{border-color:#0088cc;-webkit-box-shadow:0 1px 4px rgba(0, 105, 214, 0.25);-moz-box-shadow:0 1px 4px rgba(0, 105, 214, 0.25);box-shadow:0 1px 4px rgba(0, 105, 214, 0.25);}
+.thumbnail>img{display:block;max-width:100%;margin-left:auto;margin-right:auto;}
+.thumbnail .caption{padding:9px;color:#555555;}
+.alert{padding:8px 35px 8px 14px;margin-bottom:20px;text-shadow:0 1px 0 rgba(255, 255, 255, 0.5);background-color:#fcf8e3;border:1px solid #fbeed5;-webkit-border-radius:4px;-moz-border-radius:4px;border-radius:4px;}
+.alert,.alert h4{color:#c09853;}
+.alert h4{margin:0;}
+.alert .close{position:relative;top:-2px;right:-21px;line-height:20px;}
+.alert-success{background-color:#dff0d8;border-color:#d6e9c6;color:#468847;}
+.alert-success h4{color:#468847;}
+.alert-danger,.alert-error{background-color:#f2dede;border-color:#eed3d7;color:#b94a48;}
+.alert-danger h4,.alert-error h4{color:#b94a48;}
+.alert-info{background-color:#d9edf7;border-color:#bce8f1;color:#3a87ad;}
+.alert-info h4{color:#3a87ad;}
+.alert-block{padding-top:14px;padding-bottom:14px;}
+.alert-block>p,.alert-block>ul{margin-bottom:0;}
+.alert-block p+p{margin-top:5px;}
+@-webkit-keyframes progress-bar-stripes{from{background-position:40px 0;} to{background-position:0 0;}}@-moz-keyframes progress-bar-stripes{from{background-position:40px 0;} to{background-position:0 0;}}@-ms-keyframes progress-bar-stripes{from{background-position:40px 0;} to{background-position:0 0;}}@-o-keyframes progress-bar-stripes{from{background-position:0 0;} to{background-position:40px 0;}}@keyframes progress-bar-stripes{from{background-position:40px 0;} to{background-position:0 0;}}.progress{overflow:hidden;height:20px;margin-bottom:20px;background-color:#f7f7f7;background-image:-moz-linear-gradient(top, #f5f5f5, #f9f9f9);background-image:-webkit-gradient(linear, 0 0, 0 100%, from(#f5f5f5), to(#f9f9f9));background-image:-webkit-linear-gradient(top, #f5f5f5, #f9f9f9);background-image:-o-linear-gradient(top, #f5f5f5, #f9f9f9);background-image:linear-gradient(to bottom, #f5f5f5, #f9f9f9);background-repeat:repeat-x;filter:progid:DXImageTransform.Microsoft.gradient(startColorstr='#fff5f5f5', endColorstr='#fff9f9f9', GradientType=0);-webkit-box-shadow:inset 0 1px 2px rgba(0, 0, 0, 0.1);-moz-box-shadow:inset 0 1px 2px rgba(0, 0, 0, 0.1);box-shadow:inset 0 1px 2px rgba(0, 0, 0, 0.1);-webkit-border-radius:4px;-moz-border-radius:4px;border-radius:4px;}
+.progress .bar{width:0%;height:100%;color:#ffffff;float:left;font-size:12px;text-align:center;text-shadow:0 -1px 0 rgba(0, 0, 0, 0.25);background-color:#0e90d2;background-image:-moz-linear-gradient(top, #149bdf, #0480be);background-image:-webkit-gradient(linear, 0 0, 0 100%, from(#149bdf), to(#0480be));background-image:-webkit-linear-gradient(top, #149bdf, #0480be);background-image:-o-linear-gradient(top, #149bdf, #0480be);background-image:linear-gradient(to bottom, #149bdf, #0480be);background-repeat:repeat-x;filter:progid:DXImageTransform.Microsoft.gradient(startColorstr='#ff149bdf', endColorstr='#ff0480be', GradientType=0);-webkit-box-shadow:inset 0 -1px 0 rgba(0, 0, 0, 0.15);-moz-box-shadow:inset 0 -1px 0 rgba(0, 0, 0, 0.15);box-shadow:inset 0 -1px 0 rgba(0, 0, 0, 0.15);-webkit-box-sizing:border-box;-moz-box-sizing:border-box;box-sizing:border-box;-webkit-transition:width 0.6s ease;-moz-transition:width 0.6s ease;-o-transition:width 0.6s ease;transition:width 0.6s ease;}
+.progress .bar+.bar{-webkit-box-shadow:inset 1px 0 0 rgba(0,0,0,.15), inset 0 -1px 0 rgba(0,0,0,.15);-moz-box-shadow:inset 1px 0 0 rgba(0,0,0,.15), inset 0 -1px 0 rgba(0,0,0,.15);box-shadow:inset 1px 0 0 rgba(0,0,0,.15), inset 0 -1px 0 rgba(0,0,0,.15);}
+.progress-striped .bar{background-color:#149bdf;background-image:-webkit-gradient(linear, 0 100%, 100% 0, color-stop(0.25, rgba(255, 255, 255, 0.15)), color-stop(0.25, transparent), color-stop(0.5, transparent), color-stop(0.5, rgba(255, 255, 255, 0.15)), color-stop(0.75, rgba(255, 255, 255, 0.15)), color-stop(0.75, transparent), to(transparent));background-image:-webkit-linear-gradient(45deg, rgba(255, 255, 255, 0.15) 25%, transparent 25%, transparent 50%, rgba(255, 255, 255, 0.15) 50%, rgba(255, 255, 255, 0.15) 75%, transparent 75%, transparent);background-image:-moz-linear-gradient(45deg, rgba(255, 255, 255, 0.15) 25%, transparent 25%, transparent 50%, rgba(255, 255, 255, 0.15) 50%, rgba(255, 255, 255, 0.15) 75%, transparent 75%, transparent);background-image:-o-linear-gradient(45deg, rgba(255, 255, 255, 0.15) 25%, transparent 25%, transparent 50%, rgba(255, 255, 255, 0.15) 50%, rgba(255, 255, 255, 0.15) 75%, transparent 75%, transparent);background-image:linear-gradient(45deg, rgba(255, 255, 255, 0.15) 25%, transparent 25%, transparent 50%, rgba(255, 255, 255, 0.15) 50%, rgba(255, 255, 255, 0.15) 75%, transparent 75%, transparent);-webkit-background-size:40px 40px;-moz-background-size:40px 40px;-o-background-size:40px 40px;background-size:40px 40px;}
+.progress.active .bar{-webkit-animation:progress-bar-stripes 2s linear infinite;-moz-animation:progress-bar-stripes 2s linear infinite;-ms-animation:progress-bar-stripes 2s linear infinite;-o-animation:progress-bar-stripes 2s linear infinite;animation:progress-bar-stripes 2s linear infinite;}
+.progress-danger .bar,.progress .bar-danger{background-color:#dd514c;background-image:-moz-linear-gradient(top, #ee5f5b, #c43c35);background-image:-webkit-gradient(linear, 0 0, 0 100%, from(#ee5f5b), to(#c43c35));background-image:-webkit-linear-gradient(top, #ee5f5b, #c43c35);background-image:-o-linear-gradient(top, #ee5f5b, #c43c35);background-image:linear-gradient(to bottom, #ee5f5b, #c43c35);background-repeat:repeat-x;filter:progid:DXImageTransform.Microsoft.gradient(startColorstr='#ffee5f5b', endColorstr='#ffc43c35', GradientType=0);}
+.progress-danger.progress-striped .bar,.progress-striped .bar-danger{background-color:#ee5f5b;background-image:-webkit-gradient(linear, 0 100%, 100% 0, color-stop(0.25, rgba(255, 255, 255, 0.15)), color-stop(0.25, transparent), color-stop(0.5, transparent), color-stop(0.5, rgba(255, 255, 255, 0.15)), color-stop(0.75, rgba(255, 255, 255, 0.15)), color-stop(0.75, transparent), to(transparent));background-image:-webkit-linear-gradient(45deg, rgba(255, 255, 255, 0.15) 25%, transparent 25%, transparent 50%, rgba(255, 255, 255, 0.15) 50%, rgba(255, 255, 255, 0.15) 75%, transparent 75%, transparent);background-image:-moz-linear-gradient(45deg, rgba(255, 255, 255, 0.15) 25%, transparent 25%, transparent 50%, rgba(255, 255, 255, 0.15) 50%, rgba(255, 255, 255, 0.15) 75%, transparent 75%, transparent);background-image:-o-linear-gradient(45deg, rgba(255, 255, 255, 0.15) 25%, transparent 25%, transparent 50%, rgba(255, 255, 255, 0.15) 50%, rgba(255, 255, 255, 0.15) 75%, transparent 75%, transparent);background-image:linear-gradient(45deg, rgba(255, 255, 255, 0.15) 25%, transparent 25%, transparent 50%, rgba(255, 255, 255, 0.15) 50%, rgba(255, 255, 255, 0.15) 75%, transparent 75%, transparent);}
+.progress-success .bar,.progress .bar-success{background-color:#5eb95e;background-image:-moz-linear-gradient(top, #62c462, #57a957);background-image:-webkit-gradient(linear, 0 0, 0 100%, from(#62c462), to(#57a957));background-image:-webkit-linear-gradient(top, #62c462, #57a957);background-image:-o-linear-gradient(top, #62c462, #57a957);background-image:linear-gradient(to bottom, #62c462, #57a957);background-repeat:repeat-x;filter:progid:DXImageTransform.Microsoft.gradient(startColorstr='#ff62c462', endColorstr='#ff57a957', GradientType=0);}
+.progress-success.progress-striped .bar,.progress-striped .bar-success{background-color:#62c462;background-image:-webkit-gradient(linear, 0 100%, 100% 0, color-stop(0.25, rgba(255, 255, 255, 0.15)), color-stop(0.25, transparent), color-stop(0.5, transparent), color-stop(0.5, rgba(255, 255, 255, 0.15)), color-stop(0.75, rgba(255, 255, 255, 0.15)), color-stop(0.75, transparent), to(transparent));background-image:-webkit-linear-gradient(45deg, rgba(255, 255, 255, 0.15) 25%, transparent 25%, transparent 50%, rgba(255, 255, 255, 0.15) 50%, rgba(255, 255, 255, 0.15) 75%, transparent 75%, transparent);background-image:-moz-linear-gradient(45deg, rgba(255, 255, 255, 0.15) 25%, transparent 25%, transparent 50%, rgba(255, 255, 255, 0.15) 50%, rgba(255, 255, 255, 0.15) 75%, transparent 75%, transparent);background-image:-o-linear-gradient(45deg, rgba(255, 255, 255, 0.15) 25%, transparent 25%, transparent 50%, rgba(255, 255, 255, 0.15) 50%, rgba(255, 255, 255, 0.15) 75%, transparent 75%, transparent);background-image:linear-gradient(45deg, rgba(255, 255, 255, 0.15) 25%, transparent 25%, transparent 50%, rgba(255, 255, 255, 0.15) 50%, rgba(255, 255, 255, 0.15) 75%, transparent 75%, transparent);}
+.progress-info .bar,.progress .bar-info{background-color:#4bb1cf;background-image:-moz-linear-gradient(top, #5bc0de, #339bb9);background-image:-webkit-gradient(linear, 0 0, 0 100%, from(#5bc0de), to(#339bb9));background-image:-webkit-linear-gradient(top, #5bc0de, #339bb9);background-image:-o-linear-gradient(top, #5bc0de, #339bb9);background-image:linear-gradient(to bottom, #5bc0de, #339bb9);background-repeat:repeat-x;filter:progid:DXImageTransform.Microsoft.gradient(startColorstr='#ff5bc0de', endColorstr='#ff339bb9', GradientType=0);}
+.progress-info.progress-striped .bar,.progress-striped .bar-info{background-color:#5bc0de;background-image:-webkit-gradient(linear, 0 100%, 100% 0, color-stop(0.25, rgba(255, 255, 255, 0.15)), color-stop(0.25, transparent), color-stop(0.5, transparent), color-stop(0.5, rgba(255, 255, 255, 0.15)), color-stop(0.75, rgba(255, 255, 255, 0.15)), color-stop(0.75, transparent), to(transparent));background-image:-webkit-linear-gradient(45deg, rgba(255, 255, 255, 0.15) 25%, transparent 25%, transparent 50%, rgba(255, 255, 255, 0.15) 50%, rgba(255, 255, 255, 0.15) 75%, transparent 75%, transparent);background-image:-moz-linear-gradient(45deg, rgba(255, 255, 255, 0.15) 25%, transparent 25%, transparent 50%, rgba(255, 255, 255, 0.15) 50%, rgba(255, 255, 255, 0.15) 75%, transparent 75%, transparent);background-image:-o-linear-gradient(45deg, rgba(255, 255, 255, 0.15) 25%, transparent 25%, transparent 50%, rgba(255, 255, 255, 0.15) 50%, rgba(255, 255, 255, 0.15) 75%, transparent 75%, transparent);background-image:linear-gradient(45deg, rgba(255, 255, 255, 0.15) 25%, transparent 25%, transparent 50%, rgba(255, 255, 255, 0.15) 50%, rgba(255, 255, 255, 0.15) 75%, transparent 75%, transparent);}
+.progress-warning .bar,.progress .bar-warning{background-color:#faa732;background-image:-moz-linear-gradient(top, #fbb450, #f89406);background-image:-webkit-gradient(linear, 0 0, 0 100%, from(#fbb450), to(#f89406));background-image:-webkit-linear-gradient(top, #fbb450, #f89406);background-image:-o-linear-gradient(top, #fbb450, #f89406);background-image:linear-gradient(to bottom, #fbb450, #f89406);background-repeat:repeat-x;filter:progid:DXImageTransform.Microsoft.gradient(startColorstr='#fffbb450', endColorstr='#fff89406', GradientType=0);}
+.progress-warning.progress-striped .bar,.progress-striped .bar-warning{background-color:#fbb450;background-image:-webkit-gradient(linear, 0 100%, 100% 0, color-stop(0.25, rgba(255, 255, 255, 0.15)), color-stop(0.25, transparent), color-stop(0.5, transparent), color-stop(0.5, rgba(255, 255, 255, 0.15)), color-stop(0.75, rgba(255, 255, 255, 0.15)), color-stop(0.75, transparent), to(transparent));background-image:-webkit-linear-gradient(45deg, rgba(255, 255, 255, 0.15) 25%, transparent 25%, transparent 50%, rgba(255, 255, 255, 0.15) 50%, rgba(255, 255, 255, 0.15) 75%, transparent 75%, transparent);background-image:-moz-linear-gradient(45deg, rgba(255, 255, 255, 0.15) 25%, transparent 25%, transparent 50%, rgba(255, 255, 255, 0.15) 50%, rgba(255, 255, 255, 0.15) 75%, transparent 75%, transparent);background-image:-o-linear-gradient(45deg, rgba(255, 255, 255, 0.15) 25%, transparent 25%, transparent 50%, rgba(255, 255, 255, 0.15) 50%, rgba(255, 255, 255, 0.15) 75%, transparent 75%, transparent);background-image:linear-gradient(45deg, rgba(255, 255, 255, 0.15) 25%, transparent 25%, transparent 50%, rgba(255, 255, 255, 0.15) 50%, rgba(255, 255, 255, 0.15) 75%, transparent 75%, transparent);}
+.hero-unit{padding:60px;margin-bottom:30px;font-size:18px;font-weight:200;line-height:30px;color:inherit;background-color:#eeeeee;-webkit-border-radius:6px;-moz-border-radius:6px;border-radius:6px;}.hero-unit h1{margin-bottom:0;font-size:60px;line-height:1;color:inherit;letter-spacing:-1px;}
+.hero-unit li{line-height:30px;}
+.media,.media-body{overflow:hidden;*overflow:visible;zoom:1;}
+.media,.media .media{margin-top:15px;}
+.media:first-child{margin-top:0;}
+.media-object{display:block;}
+.media-heading{margin:0 0 5px;}
+.media>.pull-left{margin-right:10px;}
+.media>.pull-right{margin-left:10px;}
+.media-list{margin-left:0;list-style:none;}
+.tooltip{position:absolute;z-index:1030;display:block;visibility:visible;font-size:11px;line-height:1.4;opacity:0;filter:alpha(opacity=0);}.tooltip.in{opacity:0.8;filter:alpha(opacity=80);}
+.tooltip.top{margin-top:-3px;padding:5px 0;}
+.tooltip.right{margin-left:3px;padding:0 5px;}
+.tooltip.bottom{margin-top:3px;padding:5px 0;}
+.tooltip.left{margin-left:-3px;padding:0 5px;}
+.tooltip-inner{max-width:200px;padding:8px;color:#ffffff;text-align:center;text-decoration:none;background-color:#000000;-webkit-border-radius:4px;-moz-border-radius:4px;border-radius:4px;}
+.tooltip-arrow{position:absolute;width:0;height:0;border-color:transparent;border-style:solid;}
+.tooltip.top .tooltip-arrow{bottom:0;left:50%;margin-left:-5px;border-width:5px 5px 0;border-top-color:#000000;}
+.tooltip.right .tooltip-arrow{top:50%;left:0;margin-top:-5px;border-width:5px 5px 5px 0;border-right-color:#000000;}
+.tooltip.left .tooltip-arrow{top:50%;right:0;margin-top:-5px;border-width:5px 0 5px 5px;border-left-color:#000000;}
+.tooltip.bottom .tooltip-arrow{top:0;left:50%;margin-left:-5px;border-width:0 5px 5px;border-bottom-color:#000000;}
+.popover{position:absolute;top:0;left:0;z-index:1010;display:none;max-width:276px;padding:1px;text-align:left;background-color:#ffffff;-webkit-background-clip:padding-box;-moz-background-clip:padding;background-clip:padding-box;border:1px solid #ccc;border:1px solid rgba(0, 0, 0, 0.2);-webkit-border-radius:6px;-moz-border-radius:6px;border-radius:6px;-webkit-box-shadow:0 5px 10px rgba(0, 0, 0, 0.2);-moz-box-shadow:0 5px 10px rgba(0, 0, 0, 0.2);box-shadow:0 5px 10px rgba(0, 0, 0, 0.2);white-space:normal;}.popover.top{margin-top:-10px;}
+.popover.right{margin-left:10px;}
+.popover.bottom{margin-top:10px;}
+.popover.left{margin-left:-10px;}
+.popover-title{margin:0;padding:8px 14px;font-size:14px;font-weight:normal;line-height:18px;background-color:#f7f7f7;border-bottom:1px solid #ebebeb;-webkit-border-radius:5px 5px 0 0;-moz-border-radius:5px 5px 0 0;border-radius:5px 5px 0 0;}.popover-title:empty{display:none;}
+.popover-content{padding:9px 14px;}
+.popover .arrow,.popover .arrow:after{position:absolute;display:block;width:0;height:0;border-color:transparent;border-style:solid;}
+.popover .arrow{border-width:11px;}
+.popover .arrow:after{border-width:10px;content:"";}
+.popover.top .arrow{left:50%;margin-left:-11px;border-bottom-width:0;border-top-color:#999;border-top-color:rgba(0, 0, 0, 0.25);bottom:-11px;}.popover.top .arrow:after{bottom:1px;margin-left:-10px;border-bottom-width:0;border-top-color:#ffffff;}
+.popover.right .arrow{top:50%;left:-11px;margin-top:-11px;border-left-width:0;border-right-color:#999;border-right-color:rgba(0, 0, 0, 0.25);}.popover.right .arrow:after{left:1px;bottom:-10px;border-left-width:0;border-right-color:#ffffff;}
+.popover.bottom .arrow{left:50%;margin-left:-11px;border-top-width:0;border-bottom-color:#999;border-bottom-color:rgba(0, 0, 0, 0.25);top:-11px;}.popover.bottom .arrow:after{top:1px;margin-left:-10px;border-top-width:0;border-bottom-color:#ffffff;}
+.popover.left .arrow{top:50%;right:-11px;margin-top:-11px;border-right-width:0;border-left-color:#999;border-left-color:rgba(0, 0, 0, 0.25);}.popover.left .arrow:after{right:1px;border-right-width:0;border-left-color:#ffffff;bottom:-10px;}
+.modal-backdrop{position:fixed;top:0;right:0;bottom:0;left:0;z-index:1040;background-color:#000000;}.modal-backdrop.fade{opacity:0;}
+.modal-backdrop,.modal-backdrop.fade.in{opacity:0.8;filter:alpha(opacity=80);}
+.modal{position:fixed;top:10%;left:50%;z-index:1050;width:560px;margin-left:-280px;background-color:#ffffff;border:1px solid #999;border:1px solid rgba(0, 0, 0, 0.3);*border:1px solid #999;-webkit-border-radius:6px;-moz-border-radius:6px;border-radius:6px;-webkit-box-shadow:0 3px 7px rgba(0, 0, 0, 0.3);-moz-box-shadow:0 3px 7px rgba(0, 0, 0, 0.3);box-shadow:0 3px 7px rgba(0, 0, 0, 0.3);-webkit-background-clip:padding-box;-moz-background-clip:padding-box;background-clip:padding-box;outline:none;}.modal.fade{-webkit-transition:opacity .3s linear, top .3s ease-out;-moz-transition:opacity .3s linear, top .3s ease-out;-o-transition:opacity .3s linear, top .3s ease-out;transition:opacity .3s linear, top .3s ease-out;top:-25%;}
+.modal.fade.in{top:10%;}
+.modal-header{padding:9px 15px;border-bottom:1px solid #eee;}.modal-header .close{margin-top:2px;}
+.modal-header h3{margin:0;line-height:30px;}
+.modal-body{position:relative;overflow-y:auto;max-height:400px;padding:15px;}
+.modal-form{margin-bottom:0;}
+.modal-footer{padding:14px 15px 15px;margin-bottom:0;text-align:right;background-color:#f5f5f5;border-top:1px solid #ddd;-webkit-border-radius:0 0 6px 6px;-moz-border-radius:0 0 6px 6px;border-radius:0 0 6px 6px;-webkit-box-shadow:inset 0 1px 0 #ffffff;-moz-box-shadow:inset 0 1px 0 #ffffff;box-shadow:inset 0 1px 0 #ffffff;*zoom:1;}.modal-footer:before,.modal-footer:after{display:table;content:"";line-height:0;}
+.modal-footer:after{clear:both;}
+.modal-footer .btn+.btn{margin-left:5px;margin-bottom:0;}
+.modal-footer .btn-group .btn+.btn{margin-left:-1px;}
+.modal-footer .btn-block+.btn-block{margin-left:0;}
+.dropup,.dropdown{position:relative;}
+.dropdown-toggle{*margin-bottom:-3px;}
+.dropdown-toggle:active,.open .dropdown-toggle{outline:0;}
+.caret{display:inline-block;width:0;height:0;vertical-align:top;border-top:4px solid #000000;border-right:4px solid transparent;border-left:4px solid transparent;content:"";}
+.dropdown .caret{margin-top:8px;margin-left:2px;}
+.dropdown-menu{position:absolute;top:100%;left:0;z-index:1000;display:none;float:left;min-width:160px;padding:5px 0;margin:2px 0 0;list-style:none;background-color:#ffffff;border:1px solid #ccc;border:1px solid rgba(0, 0, 0, 0.2);*border-right-width:2px;*border-bottom-width:2px;-webkit-border-radius:6px;-moz-border-radius:6px;border-radius:6px;-webkit-box-shadow:0 5px 10px rgba(0, 0, 0, 0.2);-moz-box-shadow:0 5px 10px rgba(0, 0, 0, 0.2);box-shadow:0 5px 10px rgba(0, 0, 0, 0.2);-webkit-background-clip:padding-box;-moz-background-clip:padding;background-clip:padding-box;}.dropdown-menu.pull-right{right:0;left:auto;}
+.dropdown-menu .divider{*width:100%;height:1px;margin:9px 1px;*margin:-5px 0 5px;overflow:hidden;background-color:#e5e5e5;border-bottom:1px solid #ffffff;}
+.dropdown-menu>li>a{display:block;padding:3px 20px;clear:both;font-weight:normal;line-height:20px;color:#333333;white-space:nowrap;}
+.dropdown-menu>li>a:hover,.dropdown-menu>li>a:focus,.dropdown-submenu:hover>a,.dropdown-submenu:focus>a{text-decoration:none;color:#ffffff;background-color:#0081c2;background-image:-moz-linear-gradient(top, #0088cc, #0077b3);background-image:-webkit-gradient(linear, 0 0, 0 100%, from(#0088cc), to(#0077b3));background-image:-webkit-linear-gradient(top, #0088cc, #0077b3);background-image:-o-linear-gradient(top, #0088cc, #0077b3);background-image:linear-gradient(to bottom, #0088cc, #0077b3);background-repeat:repeat-x;filter:progid:DXImageTransform.Microsoft.gradient(startColorstr='#ff0088cc', endColorstr='#ff0077b3', GradientType=0);}
+.dropdown-menu>.active>a,.dropdown-menu>.active>a:hover,.dropdown-menu>.active>a:focus{color:#ffffff;text-decoration:none;outline:0;background-color:#0081c2;background-image:-moz-linear-gradient(top, #0088cc, #0077b3);background-image:-webkit-gradient(linear, 0 0, 0 100%, from(#0088cc), to(#0077b3));background-image:-webkit-linear-gradient(top, #0088cc, #0077b3);background-image:-o-linear-gradient(top, #0088cc, #0077b3);background-image:linear-gradient(to bottom, #0088cc, #0077b3);background-repeat:repeat-x;filter:progid:DXImageTransform.Microsoft.gradient(startColorstr='#ff0088cc', endColorstr='#ff0077b3', GradientType=0);}
+.dropdown-menu>.disabled>a,.dropdown-menu>.disabled>a:hover,.dropdown-menu>.disabled>a:focus{color:#999999;}
+.dropdown-menu>.disabled>a:hover,.dropdown-menu>.disabled>a:focus{text-decoration:none;background-color:transparent;background-image:none;filter:progid:DXImageTransform.Microsoft.gradient(enabled = false);cursor:default;}
+.open{*z-index:1000;}.open>.dropdown-menu{display:block;}
+.pull-right>.dropdown-menu{right:0;left:auto;}
+.dropup .caret,.navbar-fixed-bottom .dropdown .caret{border-top:0;border-bottom:4px solid #000000;content:"";}
+.dropup .dropdown-menu,.navbar-fixed-bottom .dropdown .dropdown-menu{top:auto;bottom:100%;margin-bottom:1px;}
+.dropdown-submenu{position:relative;}
+.dropdown-submenu>.dropdown-menu{top:0;left:100%;margin-top:-6px;margin-left:-1px;-webkit-border-radius:0 6px 6px 6px;-moz-border-radius:0 6px 6px 6px;border-radius:0 6px 6px 6px;}
+.dropdown-submenu:hover>.dropdown-menu{display:block;}
+.dropup .dropdown-submenu>.dropdown-menu{top:auto;bottom:0;margin-top:0;margin-bottom:-2px;-webkit-border-radius:5px 5px 5px 0;-moz-border-radius:5px 5px 5px 0;border-radius:5px 5px 5px 0;}
+.dropdown-submenu>a:after{display:block;content:" ";float:right;width:0;height:0;border-color:transparent;border-style:solid;border-width:5px 0 5px 5px;border-left-color:#cccccc;margin-top:5px;margin-right:-10px;}
+.dropdown-submenu:hover>a:after{border-left-color:#ffffff;}
+.dropdown-submenu.pull-left{float:none;}.dropdown-submenu.pull-left>.dropdown-menu{left:-100%;margin-left:10px;-webkit-border-radius:6px 0 6px 6px;-moz-border-radius:6px 0 6px 6px;border-radius:6px 0 6px 6px;}
+.dropdown .dropdown-menu .nav-header{padding-left:20px;padding-right:20px;}
+.typeahead{z-index:1051;margin-top:2px;-webkit-border-radius:4px;-moz-border-radius:4px;border-radius:4px;}
+.accordion{margin-bottom:20px;}
+.accordion-group{margin-bottom:2px;border:1px solid #e5e5e5;-webkit-border-radius:4px;-moz-border-radius:4px;border-radius:4px;}
+.accordion-heading{border-bottom:0;}
+.accordion-heading .accordion-toggle{display:block;padding:8px 15px;}
+.accordion-toggle{cursor:pointer;}
+.accordion-inner{padding:9px 15px;border-top:1px solid #e5e5e5;}
+.carousel{position:relative;margin-bottom:20px;line-height:1;}
+.carousel-inner{overflow:hidden;width:100%;position:relative;}
+.carousel-inner>.item{display:none;position:relative;-webkit-transition:0.6s ease-in-out left;-moz-transition:0.6s ease-in-out left;-o-transition:0.6s ease-in-out left;transition:0.6s ease-in-out left;}.carousel-inner>.item>img,.carousel-inner>.item>a>img{display:block;line-height:1;}
+.carousel-inner>.active,.carousel-inner>.next,.carousel-inner>.prev{display:block;}
+.carousel-inner>.active{left:0;}
+.carousel-inner>.next,.carousel-inner>.prev{position:absolute;top:0;width:100%;}
+.carousel-inner>.next{left:100%;}
+.carousel-inner>.prev{left:-100%;}
+.carousel-inner>.next.left,.carousel-inner>.prev.right{left:0;}
+.carousel-inner>.active.left{left:-100%;}
+.carousel-inner>.active.right{left:100%;}
+.carousel-control{position:absolute;top:40%;left:15px;width:40px;height:40px;margin-top:-20px;font-size:60px;font-weight:100;line-height:30px;color:#ffffff;text-align:center;background:#222222;border:3px solid #ffffff;-webkit-border-radius:23px;-moz-border-radius:23px;border-radius:23px;opacity:0.5;filter:alpha(opacity=50);}.carousel-control.right{left:auto;right:15px;}
+.carousel-control:hover,.carousel-control:focus{color:#ffffff;text-decoration:none;opacity:0.9;filter:alpha(opacity=90);}
+.carousel-indicators{position:absolute;top:15px;right:15px;z-index:5;margin:0;list-style:none;}.carousel-indicators li{display:block;float:left;width:10px;height:10px;margin-left:5px;text-indent:-999px;background-color:#ccc;background-color:rgba(255, 255, 255, 0.25);border-radius:5px;}
+.carousel-indicators .active{background-color:#fff;}
+.carousel-caption{position:absolute;left:0;right:0;bottom:0;padding:15px;background:#333333;background:rgba(0, 0, 0, 0.75);}
+.carousel-caption h4,.carousel-caption p{color:#ffffff;line-height:20px;}
+.carousel-caption h4{margin:0 0 5px;}
+.carousel-caption p{margin-bottom:0;}
+.well{min-height:20px;padding:19px;margin-bottom:20px;background-color:#f5f5f5;border:1px solid #e3e3e3;-webkit-border-radius:4px;-moz-border-radius:4px;border-radius:4px;-webkit-box-shadow:inset 0 1px 1px rgba(0, 0, 0, 0.05);-moz-box-shadow:inset 0 1px 1px rgba(0, 0, 0, 0.05);box-shadow:inset 0 1px 1px rgba(0, 0, 0, 0.05);}.well blockquote{border-color:#ddd;border-color:rgba(0, 0, 0, 0.15);}
+.well-large{padding:24px;-webkit-border-radius:6px;-moz-border-radius:6px;border-radius:6px;}
+.well-small{padding:9px;-webkit-border-radius:3px;-moz-border-radius:3px;border-radius:3px;}
+.close{float:right;font-size:20px;font-weight:bold;line-height:20px;color:#000000;text-shadow:0 1px 0 #ffffff;opacity:0.2;filter:alpha(opacity=20);}.close:hover,.close:focus{color:#000000;text-decoration:none;cursor:pointer;opacity:0.4;filter:alpha(opacity=40);}
+button.close{padding:0;cursor:pointer;background:transparent;border:0;-webkit-appearance:none;}
+.pull-right{float:right;}
+.pull-left{float:left;}
+.hide{display:none;}
+.show{display:block;}
+.invisible{visibility:hidden;}
+.affix{position:fixed;}
+.fade{opacity:0;-webkit-transition:opacity 0.15s linear;-moz-transition:opacity 0.15s linear;-o-transition:opacity 0.15s linear;transition:opacity 0.15s linear;}.fade.in{opacity:1;}
+.collapse{position:relative;height:0;overflow:hidden;-webkit-transition:height 0.35s ease;-moz-transition:height 0.35s ease;-o-transition:height 0.35s ease;transition:height 0.35s ease;}.collapse.in{height:auto;}
+@-ms-viewport{width:device-width;}.hidden{display:none;visibility:hidden;}
+.visible-phone{display:none !important;}
+.visible-tablet{display:none !important;}
+.hidden-desktop{display:none !important;}
+.visible-desktop{display:inherit !important;}
+@media (min-width:768px) and (max-width:979px){.hidden-desktop{display:inherit !important;} .visible-desktop{display:none !important ;} .visible-tablet{display:inherit !important;} .hidden-tablet{display:none !important;}}@media (max-width:767px){.hidden-desktop{display:inherit !important;} .visible-desktop{display:none !important;} .visible-phone{display:inherit !important;} .hidden-phone{display:none !important;}}.visible-print{display:none !important;}
+@media print{.visible-print{display:inherit !important;} .hidden-print{display:none !important;}}@media (max-width:767px){body{padding-left:20px;padding-right:20px;} .navbar-fixed-top,.navbar-fixed-bottom,.navbar-static-top{margin-left:-20px;margin-right:-20px;} .container-fluid{padding:0;} .dl-horizontal dt{float:none;clear:none;width:auto;text-align:left;} .dl-horizontal dd{margin-left:0;} .container{width:auto;} .row-fluid{width:100%;} .row,.thumbnails{margin-left:0;} .thumbnails>li{float:none;margin-left:0;} [class*="span"],.uneditable-input[class*="span"],.row-fluid [class*="span"]{float:none;display:block;width:100%;margin-left:0;-webkit-box-sizing:border-box;-moz-box-sizing:border-box;box-sizing:border-box;} .span12,.row-fluid .span12{width:100%;-webkit-box-sizing:border-box;-moz-box-sizing:border-box;box-sizing:border-box;} .row-fluid [class*="offset"]:first-child{margin-left:0;} .input-large,.input-xlarge,.input-xxlarge,input[class*="span"],select[class*="span"],textarea[class*="span"],.uneditable-input{display:block;width:100%;min-height:30px;-webkit-box-sizing:border-box;-moz-box-sizing:border-box;box-sizing:border-box;} .input-prepend input,.input-append input,.input-prepend input[class*="span"],.input-append input[class*="span"]{display:inline-block;width:auto;} .controls-row [class*="span"]+[class*="span"]{margin-left:0;} .modal{position:fixed;top:20px;left:20px;right:20px;width:auto;margin:0;}.modal.fade{top:-100px;} .modal.fade.in{top:20px;}}@media (max-width:480px){.nav-collapse{-webkit-transform:translate3d(0, 0, 0);} .page-header h1 small{display:block;line-height:20px;} input[type="checkbox"],input[type="radio"]{border:1px solid #ccc;} .form-horizontal .control-label{float:none;width:auto;padding-top:0;text-align:left;} .form-horizontal .controls{margin-left:0;} .form-horizontal .control-list{padding-top:0;} .form-horizontal .form-actions{padding-left:10px;padding-right:10px;} .media .pull-left,.media .pull-right{float:none;display:block;margin-bottom:10px;} .media-object{margin-right:0;margin-left:0;} .modal{top:10px;left:10px;right:10px;} .modal-header .close{padding:10px;margin:-10px;} .carousel-caption{position:static;}}@media (min-width:768px) and (max-width:979px){.row{margin-left:-20px;*zoom:1;}.row:before,.row:after{display:table;content:"";line-height:0;} .row:after{clear:both;} [class*="span"]{float:left;min-height:1px;margin-left:20px;} .container,.navbar-static-top .container,.navbar-fixed-top .container,.navbar-fixed-bottom .container{width:724px;} .span12{width:724px;} .span11{width:662px;} .span10{width:600px;} .span9{width:538px;} .span8{width:476px;} .span7{width:414px;} .span6{width:352px;} .span5{width:290px;} .span4{width:228px;} .span3{width:166px;} .span2{width:104px;} .span1{width:42px;} .offset12{margin-left:764px;} .offset11{margin-left:702px;} .offset10{margin-left:640px;} .offset9{margin-left:578px;} .offset8{margin-left:516px;} .offset7{margin-left:454px;} .offset6{margin-left:392px;} .offset5{margin-left:330px;} .offset4{margin-left:268px;} .offset3{margin-left:206px;} .offset2{margin-left:144px;} .offset1{margin-left:82px;} .row-fluid{width:100%;*zoom:1;}.row-fluid:before,.row-fluid:after{display:table;content:"";line-height:0;} .row-fluid:after{clear:both;} .row-fluid [class*="span"]{display:block;width:100%;min-height:30px;-webkit-box-sizing:border-box;-moz-box-sizing:border-box;box-sizing:border-box;float:left;margin-left:2.7624309392265194%;*margin-left:2.709239449864817%;} .row-fluid [class*="span"]:first-child{margin-left:0;} .row-fluid .controls-row [class*="span"]+[class*="span"]{margin-left:2.7624309392265194%;} .row-fluid .span12{width:100%;*width:99.94680851063829%;} .row-fluid .span11{width:91.43646408839778%;*width:91.38327259903608%;} .row-fluid .span10{width:82.87292817679558%;*width:82.81973668743387%;} .row-fluid .span9{width:74.30939226519337%;*width:74.25620077583166%;} .row-fluid .span8{width:65.74585635359117%;*width:65.69266486422946%;} .row-fluid .span7{width:57.18232044198895%;*width:57.12912895262725%;} .row-fluid .span6{width:48.61878453038674%;*width:48.56559304102504%;} .row-fluid .span5{width:40.05524861878453%;*width:40.00205712942283%;} .row-fluid .span4{width:31.491712707182323%;*width:31.43852121782062%;} .row-fluid .span3{width:22.92817679558011%;*width:22.87498530621841%;} .row-fluid .span2{width:14.3646408839779%;*width:14.311449394616199%;} .row-fluid .span1{width:5.801104972375691%;*width:5.747913483013988%;} .row-fluid .offset12{margin-left:105.52486187845304%;*margin-left:105.41847889972962%;} .row-fluid .offset12:first-child{margin-left:102.76243093922652%;*margin-left:102.6560479605031%;} .row-fluid .offset11{margin-left:96.96132596685082%;*margin-left:96.8549429881274%;} .row-fluid .offset11:first-child{margin-left:94.1988950276243%;*margin-left:94.09251204890089%;} .row-fluid .offset10{margin-left:88.39779005524862%;*margin-left:88.2914070765252%;} .row-fluid .offset10:first-child{margin-left:85.6353591160221%;*margin-left:85.52897613729868%;} .row-fluid .offset9{margin-left:79.8342541436464%;*margin-left:79.72787116492299%;} .row-fluid .offset9:first-child{margin-left:77.07182320441989%;*margin-left:76.96544022569647%;} .row-fluid .offset8{margin-left:71.2707182320442%;*margin-left:71.16433525332079%;} .row-fluid .offset8:first-child{margin-left:68.50828729281768%;*margin-left:68.40190431409427%;} .row-fluid .offset7{margin-left:62.70718232044199%;*margin-left:62.600799341718584%;} .row-fluid .offset7:first-child{margin-left:59.94475138121547%;*margin-left:59.838368402492065%;} .row-fluid .offset6{margin-left:54.14364640883978%;*margin-left:54.037263430116376%;} .row-fluid .offset6:first-child{margin-left:51.38121546961326%;*margin-left:51.27483249088986%;} .row-fluid .offset5{margin-left:45.58011049723757%;*margin-left:45.47372751851417%;} .row-fluid .offset5:first-child{margin-left:42.81767955801105%;*margin-left:42.71129657928765%;} .row-fluid .offset4{margin-left:37.01657458563536%;*margin-left:36.91019160691196%;} .row-fluid .offset4:first-child{margin-left:34.25414364640884%;*margin-left:34.14776066768544%;} .row-fluid .offset3{margin-left:28.45303867403315%;*margin-left:28.346655695309746%;} .row-fluid .offset3:first-child{margin-left:25.69060773480663%;*margin-left:25.584224756083227%;} .row-fluid .offset2{margin-left:19.88950276243094%;*margin-left:19.783119783707537%;} .row-fluid .offset2:first-child{margin-left:17.12707182320442%;*margin-left:17.02068884448102%;} .row-fluid .offset1{margin-left:11.32596685082873%;*margin-left:11.219583872105325%;} .row-fluid .offset1:first-child{margin-left:8.56353591160221%;*margin-left:8.457152932878806%;} input,textarea,.uneditable-input{margin-left:0;} .controls-row [class*="span"]+[class*="span"]{margin-left:20px;} input.span12,textarea.span12,.uneditable-input.span12{width:710px;} input.span11,textarea.span11,.uneditable-input.span11{width:648px;} input.span10,textarea.span10,.uneditable-input.span10{width:586px;} input.span9,textarea.span9,.uneditable-input.span9{width:524px;} input.span8,textarea.span8,.uneditable-input.span8{width:462px;} input.span7,textarea.span7,.uneditable-input.span7{width:400px;} input.span6,textarea.span6,.uneditable-input.span6{width:338px;} input.span5,textarea.span5,.uneditable-input.span5{width:276px;} input.span4,textarea.span4,.uneditable-input.span4{width:214px;} input.span3,textarea.span3,.uneditable-input.span3{width:152px;} input.span2,textarea.span2,.uneditable-input.span2{width:90px;} input.span1,textarea.span1,.uneditable-input.span1{width:28px;}}@media (min-width:1200px){.row{margin-left:-30px;*zoom:1;}.row:before,.row:after{display:table;content:"";line-height:0;} .row:after{clear:both;} [class*="span"]{float:left;min-height:1px;margin-left:30px;} .container,.navbar-static-top .container,.navbar-fixed-top .container,.navbar-fixed-bottom .container{width:1170px;} .span12{width:1170px;} .span11{width:1070px;} .span10{width:970px;} .span9{width:870px;} .span8{width:770px;} .span7{width:670px;} .span6{width:570px;} .span5{width:470px;} .span4{width:370px;} .span3{width:270px;} .span2{width:170px;} .span1{width:70px;} .offset12{margin-left:1230px;} .offset11{margin-left:1130px;} .offset10{margin-left:1030px;} .offset9{margin-left:930px;} .offset8{margin-left:830px;} .offset7{margin-left:730px;} .offset6{margin-left:630px;} .offset5{margin-left:530px;} .offset4{margin-left:430px;} .offset3{margin-left:330px;} .offset2{margin-left:230px;} .offset1{margin-left:130px;} .row-fluid{width:100%;*zoom:1;}.row-fluid:before,.row-fluid:after{display:table;content:"";line-height:0;} .row-fluid:after{clear:both;} .row-fluid [class*="span"]{display:block;width:100%;min-height:30px;-webkit-box-sizing:border-box;-moz-box-sizing:border-box;box-sizing:border-box;float:left;margin-left:2.564102564102564%;*margin-left:2.5109110747408616%;} .row-fluid [class*="span"]:first-child{margin-left:0;} .row-fluid .controls-row [class*="span"]+[class*="span"]{margin-left:2.564102564102564%;} .row-fluid .span12{width:100%;*width:99.94680851063829%;} .row-fluid .span11{width:91.45299145299145%;*width:91.39979996362975%;} .row-fluid .span10{width:82.90598290598291%;*width:82.8527914166212%;} .row-fluid .span9{width:74.35897435897436%;*width:74.30578286961266%;} .row-fluid .span8{width:65.81196581196582%;*width:65.75877432260411%;} .row-fluid .span7{width:57.26495726495726%;*width:57.21176577559556%;} .row-fluid .span6{width:48.717948717948715%;*width:48.664757228587014%;} .row-fluid .span5{width:40.17094017094017%;*width:40.11774868157847%;} .row-fluid .span4{width:31.623931623931625%;*width:31.570740134569924%;} .row-fluid .span3{width:23.076923076923077%;*width:23.023731587561375%;} .row-fluid .span2{width:14.52991452991453%;*width:14.476723040552828%;} .row-fluid .span1{width:5.982905982905983%;*width:5.929714493544281%;} .row-fluid .offset12{margin-left:105.12820512820512%;*margin-left:105.02182214948171%;} .row-fluid .offset12:first-child{margin-left:102.56410256410257%;*margin-left:102.45771958537915%;} .row-fluid .offset11{margin-left:96.58119658119658%;*margin-left:96.47481360247316%;} .row-fluid .offset11:first-child{margin-left:94.01709401709402%;*margin-left:93.91071103837061%;} .row-fluid .offset10{margin-left:88.03418803418803%;*margin-left:87.92780505546462%;} .row-fluid .offset10:first-child{margin-left:85.47008547008548%;*margin-left:85.36370249136206%;} .row-fluid .offset9{margin-left:79.48717948717949%;*margin-left:79.38079650845607%;} .row-fluid .offset9:first-child{margin-left:76.92307692307693%;*margin-left:76.81669394435352%;} .row-fluid .offset8{margin-left:70.94017094017094%;*margin-left:70.83378796144753%;} .row-fluid .offset8:first-child{margin-left:68.37606837606839%;*margin-left:68.26968539734497%;} .row-fluid .offset7{margin-left:62.393162393162385%;*margin-left:62.28677941443899%;} .row-fluid .offset7:first-child{margin-left:59.82905982905982%;*margin-left:59.72267685033642%;} .row-fluid .offset6{margin-left:53.84615384615384%;*margin-left:53.739770867430444%;} .row-fluid .offset6:first-child{margin-left:51.28205128205128%;*margin-left:51.175668303327875%;} .row-fluid .offset5{margin-left:45.299145299145295%;*margin-left:45.1927623204219%;} .row-fluid .offset5:first-child{margin-left:42.73504273504273%;*margin-left:42.62865975631933%;} .row-fluid .offset4{margin-left:36.75213675213675%;*margin-left:36.645753773413354%;} .row-fluid .offset4:first-child{margin-left:34.18803418803419%;*margin-left:34.081651209310785%;} .row-fluid .offset3{margin-left:28.205128205128204%;*margin-left:28.0987452264048%;} .row-fluid .offset3:first-child{margin-left:25.641025641025642%;*margin-left:25.53464266230224%;} .row-fluid .offset2{margin-left:19.65811965811966%;*margin-left:19.551736679396257%;} .row-fluid .offset2:first-child{margin-left:17.094017094017094%;*margin-left:16.98763411529369%;} .row-fluid .offset1{margin-left:11.11111111111111%;*margin-left:11.004728132387708%;} .row-fluid .offset1:first-child{margin-left:8.547008547008547%;*margin-left:8.440625568285142%;} input,textarea,.uneditable-input{margin-left:0;} .controls-row [class*="span"]+[class*="span"]{margin-left:30px;} input.span12,textarea.span12,.uneditable-input.span12{width:1156px;} input.span11,textarea.span11,.uneditable-input.span11{width:1056px;} input.span10,textarea.span10,.uneditable-input.span10{width:956px;} input.span9,textarea.span9,.uneditable-input.span9{width:856px;} input.span8,textarea.span8,.uneditable-input.span8{width:756px;} input.span7,textarea.span7,.uneditable-input.span7{width:656px;} input.span6,textarea.span6,.uneditable-input.span6{width:556px;} input.span5,textarea.span5,.uneditable-input.span5{width:456px;} input.span4,textarea.span4,.uneditable-input.span4{width:356px;} input.span3,textarea.span3,.uneditable-input.span3{width:256px;} input.span2,textarea.span2,.uneditable-input.span2{width:156px;} input.span1,textarea.span1,.uneditable-input.span1{width:56px;} .thumbnails{margin-left:-30px;} .thumbnails>li{margin-left:30px;} .row-fluid .thumbnails{margin-left:0;}}@media (max-width:979px){body{padding-top:0;} .navbar-fixed-top,.navbar-fixed-bottom{position:static;} .navbar-fixed-top{margin-bottom:20px;} .navbar-fixed-bottom{margin-top:20px;} .navbar-fixed-top .navbar-inner,.navbar-fixed-bottom .navbar-inner{padding:5px;} .navbar .container{width:auto;padding:0;} .navbar .brand{padding-left:10px;padding-right:10px;margin:0 0 0 -5px;} .nav-collapse{clear:both;} .nav-collapse .nav{float:none;margin:0 0 10px;} .nav-collapse .nav>li{float:none;} .nav-collapse .nav>li>a{margin-bottom:2px;} .nav-collapse .nav>.divider-vertical{display:none;} .nav-collapse .nav .nav-header{color:#777777;text-shadow:none;} .nav-collapse .nav>li>a,.nav-collapse .dropdown-menu a{padding:9px 15px;font-weight:bold;color:#777777;-webkit-border-radius:3px;-moz-border-radius:3px;border-radius:3px;} .nav-collapse .btn{padding:4px 10px 4px;font-weight:normal;-webkit-border-radius:4px;-moz-border-radius:4px;border-radius:4px;} .nav-collapse .dropdown-menu li+li a{margin-bottom:2px;} .nav-collapse .nav>li>a:hover,.nav-collapse .nav>li>a:focus,.nav-collapse .dropdown-menu a:hover,.nav-collapse .dropdown-menu a:focus{background-color:#f2f2f2;} .navbar-inverse .nav-collapse .nav>li>a,.navbar-inverse .nav-collapse .dropdown-menu a{color:#999999;} .navbar-inverse .nav-collapse .nav>li>a:hover,.navbar-inverse .nav-collapse .nav>li>a:focus,.navbar-inverse .nav-collapse .dropdown-menu a:hover,.navbar-inverse .nav-collapse .dropdown-menu a:focus{background-color:#111111;} .nav-collapse.in .btn-group{margin-top:5px;padding:0;} .nav-collapse .dropdown-menu{position:static;top:auto;left:auto;float:none;display:none;max-width:none;margin:0 15px;padding:0;background-color:transparent;border:none;-webkit-border-radius:0;-moz-border-radius:0;border-radius:0;-webkit-box-shadow:none;-moz-box-shadow:none;box-shadow:none;} .nav-collapse .open>.dropdown-menu{display:block;} .nav-collapse .dropdown-menu:before,.nav-collapse .dropdown-menu:after{display:none;} .nav-collapse .dropdown-menu .divider{display:none;} .nav-collapse .nav>li>.dropdown-menu:before,.nav-collapse .nav>li>.dropdown-menu:after{display:none;} .nav-collapse .navbar-form,.nav-collapse .navbar-search{float:none;padding:10px 15px;margin:10px 0;border-top:1px solid #f2f2f2;border-bottom:1px solid #f2f2f2;-webkit-box-shadow:inset 0 1px 0 rgba(255,255,255,.1), 0 1px 0 rgba(255,255,255,.1);-moz-box-shadow:inset 0 1px 0 rgba(255,255,255,.1), 0 1px 0 rgba(255,255,255,.1);box-shadow:inset 0 1px 0 rgba(255,255,255,.1), 0 1px 0 rgba(255,255,255,.1);} .navbar-inverse .nav-collapse .navbar-form,.navbar-inverse .nav-collapse .navbar-search{border-top-color:#111111;border-bottom-color:#111111;} .navbar .nav-collapse .nav.pull-right{float:none;margin-left:0;} .nav-collapse,.nav-collapse.collapse{overflow:hidden;height:0;} .navbar .btn-navbar{display:block;} .navbar-static .navbar-inner{padding-left:10px;padding-right:10px;}}@media (min-width:980px){.nav-collapse.collapse{height:auto !important;overflow:visible !important;}}
diff --git a/Godeps/_workspace/src/github.com/PuerkitoBio/ghost/ghostest/public/favicon.ico b/Godeps/_workspace/src/github.com/PuerkitoBio/ghost/ghostest/public/favicon.ico
new file mode 100644
index 0000000000000000000000000000000000000000..e277138dcf5f882a66b7961cd060d30294ca8a1d
Binary files /dev/null and b/Godeps/_workspace/src/github.com/PuerkitoBio/ghost/ghostest/public/favicon.ico differ
diff --git a/Godeps/_workspace/src/github.com/PuerkitoBio/ghost/ghostest/public/jquery-2.0.0.min.js b/Godeps/_workspace/src/github.com/PuerkitoBio/ghost/ghostest/public/jquery-2.0.0.min.js
new file mode 100644
index 0000000000000000000000000000000000000000..b18e05a957c90b9b096e5749a2049d7810bbb3f3
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/PuerkitoBio/ghost/ghostest/public/jquery-2.0.0.min.js
@@ -0,0 +1,6 @@
+/*! jQuery v2.0.0 | (c) 2005, 2013 jQuery Foundation, Inc. | jquery.org/license
+//@ sourceMappingURL=jquery.min.map
+*/
+(function(e,undefined){var t,n,r=typeof undefined,i=e.location,o=e.document,s=o.documentElement,a=e.jQuery,u=e.$,l={},c=[],f="2.0.0",p=c.concat,h=c.push,d=c.slice,g=c.indexOf,m=l.toString,y=l.hasOwnProperty,v=f.trim,x=function(e,n){return new x.fn.init(e,n,t)},b=/[+-]?(?:\d*\.|)\d+(?:[eE][+-]?\d+|)/.source,w=/\S+/g,T=/^(?:(<[\w\W]+>)[^>]*|#([\w-]*))$/,C=/^<(\w+)\s*\/?>(?:<\/\1>|)$/,k=/^-ms-/,N=/-([\da-z])/gi,E=function(e,t){return t.toUpperCase()},S=function(){o.removeEventListener("DOMContentLoaded",S,!1),e.removeEventListener("load",S,!1),x.ready()};x.fn=x.prototype={jquery:f,constructor:x,init:function(e,t,n){var r,i;if(!e)return this;if("string"==typeof e){if(r="<"===e.charAt(0)&&">"===e.charAt(e.length-1)&&e.length>=3?[null,e,null]:T.exec(e),!r||!r[1]&&t)return!t||t.jquery?(t||n).find(e):this.constructor(t).find(e);if(r[1]){if(t=t instanceof x?t[0]:t,x.merge(this,x.parseHTML(r[1],t&&t.nodeType?t.ownerDocument||t:o,!0)),C.test(r[1])&&x.isPlainObject(t))for(r in t)x.isFunction(this[r])?this[r](t[r]):this.attr(r,t[r]);return this}return i=o.getElementById(r[2]),i&&i.parentNode&&(this.length=1,this[0]=i),this.context=o,this.selector=e,this}return e.nodeType?(this.context=this[0]=e,this.length=1,this):x.isFunction(e)?n.ready(e):(e.selector!==undefined&&(this.selector=e.selector,this.context=e.context),x.makeArray(e,this))},selector:"",length:0,toArray:function(){return d.call(this)},get:function(e){return null==e?this.toArray():0>e?this[this.length+e]:this[e]},pushStack:function(e){var t=x.merge(this.constructor(),e);return t.prevObject=this,t.context=this.context,t},each:function(e,t){return x.each(this,e,t)},ready:function(e){return x.ready.promise().done(e),this},slice:function(){return this.pushStack(d.apply(this,arguments))},first:function(){return this.eq(0)},last:function(){return this.eq(-1)},eq:function(e){var t=this.length,n=+e+(0>e?t:0);return this.pushStack(n>=0&&t>n?[this[n]]:[])},map:function(e){return this.pushStack(x.map(this,function(t,n){return e.call(t,n,t)}))},end:function(){return this.prevObject||this.constructor(null)},push:h,sort:[].sort,splice:[].splice},x.fn.init.prototype=x.fn,x.extend=x.fn.extend=function(){var e,t,n,r,i,o,s=arguments[0]||{},a=1,u=arguments.length,l=!1;for("boolean"==typeof s&&(l=s,s=arguments[1]||{},a=2),"object"==typeof s||x.isFunction(s)||(s={}),u===a&&(s=this,--a);u>a;a++)if(null!=(e=arguments[a]))for(t in e)n=s[t],r=e[t],s!==r&&(l&&r&&(x.isPlainObject(r)||(i=x.isArray(r)))?(i?(i=!1,o=n&&x.isArray(n)?n:[]):o=n&&x.isPlainObject(n)?n:{},s[t]=x.extend(l,o,r)):r!==undefined&&(s[t]=r));return s},x.extend({expando:"jQuery"+(f+Math.random()).replace(/\D/g,""),noConflict:function(t){return e.$===x&&(e.$=u),t&&e.jQuery===x&&(e.jQuery=a),x},isReady:!1,readyWait:1,holdReady:function(e){e?x.readyWait++:x.ready(!0)},ready:function(e){(e===!0?--x.readyWait:x.isReady)||(x.isReady=!0,e!==!0&&--x.readyWait>0||(n.resolveWith(o,[x]),x.fn.trigger&&x(o).trigger("ready").off("ready")))},isFunction:function(e){return"function"===x.type(e)},isArray:Array.isArray,isWindow:function(e){return null!=e&&e===e.window},isNumeric:function(e){return!isNaN(parseFloat(e))&&isFinite(e)},type:function(e){return null==e?e+"":"object"==typeof e||"function"==typeof e?l[m.call(e)]||"object":typeof e},isPlainObject:function(e){if("object"!==x.type(e)||e.nodeType||x.isWindow(e))return!1;try{if(e.constructor&&!y.call(e.constructor.prototype,"isPrototypeOf"))return!1}catch(t){return!1}return!0},isEmptyObject:function(e){var t;for(t in e)return!1;return!0},error:function(e){throw Error(e)},parseHTML:function(e,t,n){if(!e||"string"!=typeof e)return null;"boolean"==typeof t&&(n=t,t=!1),t=t||o;var r=C.exec(e),i=!n&&[];return r?[t.createElement(r[1])]:(r=x.buildFragment([e],t,i),i&&x(i).remove(),x.merge([],r.childNodes))},parseJSON:JSON.parse,parseXML:function(e){var t,n;if(!e||"string"!=typeof e)return null;try{n=new DOMParser,t=n.parseFromString(e,"text/xml")}catch(r){t=undefined}return(!t||t.getElementsByTagName("parsererror").length)&&x.error("Invalid XML: "+e),t},noop:function(){},globalEval:function(e){var t,n=eval;e=x.trim(e),e&&(1===e.indexOf("use strict")?(t=o.createElement("script"),t.text=e,o.head.appendChild(t).parentNode.removeChild(t)):n(e))},camelCase:function(e){return e.replace(k,"ms-").replace(N,E)},nodeName:function(e,t){return e.nodeName&&e.nodeName.toLowerCase()===t.toLowerCase()},each:function(e,t,n){var r,i=0,o=e.length,s=j(e);if(n){if(s){for(;o>i;i++)if(r=t.apply(e[i],n),r===!1)break}else for(i in e)if(r=t.apply(e[i],n),r===!1)break}else if(s){for(;o>i;i++)if(r=t.call(e[i],i,e[i]),r===!1)break}else for(i in e)if(r=t.call(e[i],i,e[i]),r===!1)break;return e},trim:function(e){return null==e?"":v.call(e)},makeArray:function(e,t){var n=t||[];return null!=e&&(j(Object(e))?x.merge(n,"string"==typeof e?[e]:e):h.call(n,e)),n},inArray:function(e,t,n){return null==t?-1:g.call(t,e,n)},merge:function(e,t){var n=t.length,r=e.length,i=0;if("number"==typeof n)for(;n>i;i++)e[r++]=t[i];else while(t[i]!==undefined)e[r++]=t[i++];return e.length=r,e},grep:function(e,t,n){var r,i=[],o=0,s=e.length;for(n=!!n;s>o;o++)r=!!t(e[o],o),n!==r&&i.push(e[o]);return i},map:function(e,t,n){var r,i=0,o=e.length,s=j(e),a=[];if(s)for(;o>i;i++)r=t(e[i],i,n),null!=r&&(a[a.length]=r);else for(i in e)r=t(e[i],i,n),null!=r&&(a[a.length]=r);return p.apply([],a)},guid:1,proxy:function(e,t){var n,r,i;return"string"==typeof t&&(n=e[t],t=e,e=n),x.isFunction(e)?(r=d.call(arguments,2),i=function(){return e.apply(t||this,r.concat(d.call(arguments)))},i.guid=e.guid=e.guid||x.guid++,i):undefined},access:function(e,t,n,r,i,o,s){var a=0,u=e.length,l=null==n;if("object"===x.type(n)){i=!0;for(a in n)x.access(e,t,a,n[a],!0,o,s)}else if(r!==undefined&&(i=!0,x.isFunction(r)||(s=!0),l&&(s?(t.call(e,r),t=null):(l=t,t=function(e,t,n){return l.call(x(e),n)})),t))for(;u>a;a++)t(e[a],n,s?r:r.call(e[a],a,t(e[a],n)));return i?e:l?t.call(e):u?t(e[0],n):o},now:Date.now,swap:function(e,t,n,r){var i,o,s={};for(o in t)s[o]=e.style[o],e.style[o]=t[o];i=n.apply(e,r||[]);for(o in t)e.style[o]=s[o];return i}}),x.ready.promise=function(t){return n||(n=x.Deferred(),"complete"===o.readyState?setTimeout(x.ready):(o.addEventListener("DOMContentLoaded",S,!1),e.addEventListener("load",S,!1))),n.promise(t)},x.each("Boolean Number String Function Array Date RegExp Object Error".split(" "),function(e,t){l["[object "+t+"]"]=t.toLowerCase()});function j(e){var t=e.length,n=x.type(e);return x.isWindow(e)?!1:1===e.nodeType&&t?!0:"array"===n||"function"!==n&&(0===t||"number"==typeof t&&t>0&&t-1 in e)}t=x(o),function(e,undefined){var t,n,r,i,o,s,a,u,l,c,f,p,h,d,g,m,y="sizzle"+-new Date,v=e.document,b={},w=0,T=0,C=ot(),k=ot(),N=ot(),E=!1,S=function(){return 0},j=typeof undefined,D=1<<31,A=[],L=A.pop,q=A.push,H=A.push,O=A.slice,F=A.indexOf||function(e){var t=0,n=this.length;for(;n>t;t++)if(this[t]===e)return t;return-1},P="checked|selected|async|autofocus|autoplay|controls|defer|disabled|hidden|ismap|loop|multiple|open|readonly|required|scoped",R="[\\x20\\t\\r\\n\\f]",M="(?:\\\\.|[\\w-]|[^\\x00-\\xa0])+",W=M.replace("w","w#"),$="\\["+R+"*("+M+")"+R+"*(?:([*^$|!~]?=)"+R+"*(?:(['\"])((?:\\\\.|[^\\\\])*?)\\3|("+W+")|)|)"+R+"*\\]",B=":("+M+")(?:\\(((['\"])((?:\\\\.|[^\\\\])*?)\\3|((?:\\\\.|[^\\\\()[\\]]|"+$.replace(3,8)+")*)|.*)\\)|)",I=RegExp("^"+R+"+|((?:^|[^\\\\])(?:\\\\.)*)"+R+"+$","g"),z=RegExp("^"+R+"*,"+R+"*"),_=RegExp("^"+R+"*([>+~]|"+R+")"+R+"*"),X=RegExp(R+"*[+~]"),U=RegExp("="+R+"*([^\\]'\"]*)"+R+"*\\]","g"),Y=RegExp(B),V=RegExp("^"+W+"$"),G={ID:RegExp("^#("+M+")"),CLASS:RegExp("^\\.("+M+")"),TAG:RegExp("^("+M.replace("w","w*")+")"),ATTR:RegExp("^"+$),PSEUDO:RegExp("^"+B),CHILD:RegExp("^:(only|first|last|nth|nth-last)-(child|of-type)(?:\\("+R+"*(even|odd|(([+-]|)(\\d*)n|)"+R+"*(?:([+-]|)"+R+"*(\\d+)|))"+R+"*\\)|)","i"),"boolean":RegExp("^(?:"+P+")$","i"),needsContext:RegExp("^"+R+"*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\\("+R+"*((?:-\\d)?\\d*)"+R+"*\\)|)(?=[^-]|$)","i")},J=/^[^{]+\{\s*\[native \w/,Q=/^(?:#([\w-]+)|(\w+)|\.([\w-]+))$/,K=/^(?:input|select|textarea|button)$/i,Z=/^h\d$/i,et=/'|\\/g,tt=/\\([\da-fA-F]{1,6}[\x20\t\r\n\f]?|.)/g,nt=function(e,t){var n="0x"+t-65536;return n!==n?t:0>n?String.fromCharCode(n+65536):String.fromCharCode(55296|n>>10,56320|1023&n)};try{H.apply(A=O.call(v.childNodes),v.childNodes),A[v.childNodes.length].nodeType}catch(rt){H={apply:A.length?function(e,t){q.apply(e,O.call(t))}:function(e,t){var n=e.length,r=0;while(e[n++]=t[r++]);e.length=n-1}}}function it(e){return J.test(e+"")}function ot(){var e,t=[];return e=function(n,i){return t.push(n+=" ")>r.cacheLength&&delete e[t.shift()],e[n]=i}}function st(e){return e[y]=!0,e}function at(e){var t=c.createElement("div");try{return!!e(t)}catch(n){return!1}finally{t.parentNode&&t.parentNode.removeChild(t),t=null}}function ut(e,t,n,r){var i,o,s,a,u,f,d,g,x,w;if((t?t.ownerDocument||t:v)!==c&&l(t),t=t||c,n=n||[],!e||"string"!=typeof e)return n;if(1!==(a=t.nodeType)&&9!==a)return[];if(p&&!r){if(i=Q.exec(e))if(s=i[1]){if(9===a){if(o=t.getElementById(s),!o||!o.parentNode)return n;if(o.id===s)return n.push(o),n}else if(t.ownerDocument&&(o=t.ownerDocument.getElementById(s))&&m(t,o)&&o.id===s)return n.push(o),n}else{if(i[2])return H.apply(n,t.getElementsByTagName(e)),n;if((s=i[3])&&b.getElementsByClassName&&t.getElementsByClassName)return H.apply(n,t.getElementsByClassName(s)),n}if(b.qsa&&(!h||!h.test(e))){if(g=d=y,x=t,w=9===a&&e,1===a&&"object"!==t.nodeName.toLowerCase()){f=gt(e),(d=t.getAttribute("id"))?g=d.replace(et,"\\$&"):t.setAttribute("id",g),g="[id='"+g+"'] ",u=f.length;while(u--)f[u]=g+mt(f[u]);x=X.test(e)&&t.parentNode||t,w=f.join(",")}if(w)try{return H.apply(n,x.querySelectorAll(w)),n}catch(T){}finally{d||t.removeAttribute("id")}}}return kt(e.replace(I,"$1"),t,n,r)}o=ut.isXML=function(e){var t=e&&(e.ownerDocument||e).documentElement;return t?"HTML"!==t.nodeName:!1},l=ut.setDocument=function(e){var t=e?e.ownerDocument||e:v;return t!==c&&9===t.nodeType&&t.documentElement?(c=t,f=t.documentElement,p=!o(t),b.getElementsByTagName=at(function(e){return e.appendChild(t.createComment("")),!e.getElementsByTagName("*").length}),b.attributes=at(function(e){return e.className="i",!e.getAttribute("className")}),b.getElementsByClassName=at(function(e){return e.innerHTML="<div class='a'></div><div class='a i'></div>",e.firstChild.className="i",2===e.getElementsByClassName("i").length}),b.sortDetached=at(function(e){return 1&e.compareDocumentPosition(c.createElement("div"))}),b.getById=at(function(e){return f.appendChild(e).id=y,!t.getElementsByName||!t.getElementsByName(y).length}),b.getById?(r.find.ID=function(e,t){if(typeof t.getElementById!==j&&p){var n=t.getElementById(e);return n&&n.parentNode?[n]:[]}},r.filter.ID=function(e){var t=e.replace(tt,nt);return function(e){return e.getAttribute("id")===t}}):(r.find.ID=function(e,t){if(typeof t.getElementById!==j&&p){var n=t.getElementById(e);return n?n.id===e||typeof n.getAttributeNode!==j&&n.getAttributeNode("id").value===e?[n]:undefined:[]}},r.filter.ID=function(e){var t=e.replace(tt,nt);return function(e){var n=typeof e.getAttributeNode!==j&&e.getAttributeNode("id");return n&&n.value===t}}),r.find.TAG=b.getElementsByTagName?function(e,t){return typeof t.getElementsByTagName!==j?t.getElementsByTagName(e):undefined}:function(e,t){var n,r=[],i=0,o=t.getElementsByTagName(e);if("*"===e){while(n=o[i++])1===n.nodeType&&r.push(n);return r}return o},r.find.CLASS=b.getElementsByClassName&&function(e,t){return typeof t.getElementsByClassName!==j&&p?t.getElementsByClassName(e):undefined},d=[],h=[],(b.qsa=it(t.querySelectorAll))&&(at(function(e){e.innerHTML="<select><option selected=''></option></select>",e.querySelectorAll("[selected]").length||h.push("\\["+R+"*(?:value|"+P+")"),e.querySelectorAll(":checked").length||h.push(":checked")}),at(function(e){var t=c.createElement("input");t.setAttribute("type","hidden"),e.appendChild(t).setAttribute("t",""),e.querySelectorAll("[t^='']").length&&h.push("[*^$]="+R+"*(?:''|\"\")"),e.querySelectorAll(":enabled").length||h.push(":enabled",":disabled"),e.querySelectorAll("*,:x"),h.push(",.*:")})),(b.matchesSelector=it(g=f.webkitMatchesSelector||f.mozMatchesSelector||f.oMatchesSelector||f.msMatchesSelector))&&at(function(e){b.disconnectedMatch=g.call(e,"div"),g.call(e,"[s!='']:x"),d.push("!=",B)}),h=h.length&&RegExp(h.join("|")),d=d.length&&RegExp(d.join("|")),m=it(f.contains)||f.compareDocumentPosition?function(e,t){var n=9===e.nodeType?e.documentElement:e,r=t&&t.parentNode;return e===r||!(!r||1!==r.nodeType||!(n.contains?n.contains(r):e.compareDocumentPosition&&16&e.compareDocumentPosition(r)))}:function(e,t){if(t)while(t=t.parentNode)if(t===e)return!0;return!1},S=f.compareDocumentPosition?function(e,n){if(e===n)return E=!0,0;var r=n.compareDocumentPosition&&e.compareDocumentPosition&&e.compareDocumentPosition(n);return r?1&r||!b.sortDetached&&n.compareDocumentPosition(e)===r?e===t||m(v,e)?-1:n===t||m(v,n)?1:u?F.call(u,e)-F.call(u,n):0:4&r?-1:1:e.compareDocumentPosition?-1:1}:function(e,n){var r,i=0,o=e.parentNode,s=n.parentNode,a=[e],l=[n];if(e===n)return E=!0,0;if(!o||!s)return e===t?-1:n===t?1:o?-1:s?1:u?F.call(u,e)-F.call(u,n):0;if(o===s)return lt(e,n);r=e;while(r=r.parentNode)a.unshift(r);r=n;while(r=r.parentNode)l.unshift(r);while(a[i]===l[i])i++;return i?lt(a[i],l[i]):a[i]===v?-1:l[i]===v?1:0},c):c},ut.matches=function(e,t){return ut(e,null,null,t)},ut.matchesSelector=function(e,t){if((e.ownerDocument||e)!==c&&l(e),t=t.replace(U,"='$1']"),!(!b.matchesSelector||!p||d&&d.test(t)||h&&h.test(t)))try{var n=g.call(e,t);if(n||b.disconnectedMatch||e.document&&11!==e.document.nodeType)return n}catch(r){}return ut(t,c,null,[e]).length>0},ut.contains=function(e,t){return(e.ownerDocument||e)!==c&&l(e),m(e,t)},ut.attr=function(e,t){(e.ownerDocument||e)!==c&&l(e);var n=r.attrHandle[t.toLowerCase()],i=n&&n(e,t,!p);return i===undefined?b.attributes||!p?e.getAttribute(t):(i=e.getAttributeNode(t))&&i.specified?i.value:null:i},ut.error=function(e){throw Error("Syntax error, unrecognized expression: "+e)},ut.uniqueSort=function(e){var t,n=[],r=0,i=0;if(E=!b.detectDuplicates,u=!b.sortStable&&e.slice(0),e.sort(S),E){while(t=e[i++])t===e[i]&&(r=n.push(i));while(r--)e.splice(n[r],1)}return e};function lt(e,t){var n=t&&e,r=n&&(~t.sourceIndex||D)-(~e.sourceIndex||D);if(r)return r;if(n)while(n=n.nextSibling)if(n===t)return-1;return e?1:-1}function ct(e,t,n){var r;return n?undefined:(r=e.getAttributeNode(t))&&r.specified?r.value:e[t]===!0?t.toLowerCase():null}function ft(e,t,n){var r;return n?undefined:r=e.getAttribute(t,"type"===t.toLowerCase()?1:2)}function pt(e){return function(t){var n=t.nodeName.toLowerCase();return"input"===n&&t.type===e}}function ht(e){return function(t){var n=t.nodeName.toLowerCase();return("input"===n||"button"===n)&&t.type===e}}function dt(e){return st(function(t){return t=+t,st(function(n,r){var i,o=e([],n.length,t),s=o.length;while(s--)n[i=o[s]]&&(n[i]=!(r[i]=n[i]))})})}i=ut.getText=function(e){var t,n="",r=0,o=e.nodeType;if(o){if(1===o||9===o||11===o){if("string"==typeof e.textContent)return e.textContent;for(e=e.firstChild;e;e=e.nextSibling)n+=i(e)}else if(3===o||4===o)return e.nodeValue}else for(;t=e[r];r++)n+=i(t);return n},r=ut.selectors={cacheLength:50,createPseudo:st,match:G,attrHandle:{},find:{},relative:{">":{dir:"parentNode",first:!0}," ":{dir:"parentNode"},"+":{dir:"previousSibling",first:!0},"~":{dir:"previousSibling"}},preFilter:{ATTR:function(e){return e[1]=e[1].replace(tt,nt),e[3]=(e[4]||e[5]||"").replace(tt,nt),"~="===e[2]&&(e[3]=" "+e[3]+" "),e.slice(0,4)},CHILD:function(e){return e[1]=e[1].toLowerCase(),"nth"===e[1].slice(0,3)?(e[3]||ut.error(e[0]),e[4]=+(e[4]?e[5]+(e[6]||1):2*("even"===e[3]||"odd"===e[3])),e[5]=+(e[7]+e[8]||"odd"===e[3])):e[3]&&ut.error(e[0]),e},PSEUDO:function(e){var t,n=!e[5]&&e[2];return G.CHILD.test(e[0])?null:(e[4]?e[2]=e[4]:n&&Y.test(n)&&(t=gt(n,!0))&&(t=n.indexOf(")",n.length-t)-n.length)&&(e[0]=e[0].slice(0,t),e[2]=n.slice(0,t)),e.slice(0,3))}},filter:{TAG:function(e){var t=e.replace(tt,nt).toLowerCase();return"*"===e?function(){return!0}:function(e){return e.nodeName&&e.nodeName.toLowerCase()===t}},CLASS:function(e){var t=C[e+" "];return t||(t=RegExp("(^|"+R+")"+e+"("+R+"|$)"))&&C(e,function(e){return t.test("string"==typeof e.className&&e.className||typeof e.getAttribute!==j&&e.getAttribute("class")||"")})},ATTR:function(e,t,n){return function(r){var i=ut.attr(r,e);return null==i?"!="===t:t?(i+="","="===t?i===n:"!="===t?i!==n:"^="===t?n&&0===i.indexOf(n):"*="===t?n&&i.indexOf(n)>-1:"$="===t?n&&i.slice(-n.length)===n:"~="===t?(" "+i+" ").indexOf(n)>-1:"|="===t?i===n||i.slice(0,n.length+1)===n+"-":!1):!0}},CHILD:function(e,t,n,r,i){var o="nth"!==e.slice(0,3),s="last"!==e.slice(-4),a="of-type"===t;return 1===r&&0===i?function(e){return!!e.parentNode}:function(t,n,u){var l,c,f,p,h,d,g=o!==s?"nextSibling":"previousSibling",m=t.parentNode,v=a&&t.nodeName.toLowerCase(),x=!u&&!a;if(m){if(o){while(g){f=t;while(f=f[g])if(a?f.nodeName.toLowerCase()===v:1===f.nodeType)return!1;d=g="only"===e&&!d&&"nextSibling"}return!0}if(d=[s?m.firstChild:m.lastChild],s&&x){c=m[y]||(m[y]={}),l=c[e]||[],h=l[0]===w&&l[1],p=l[0]===w&&l[2],f=h&&m.childNodes[h];while(f=++h&&f&&f[g]||(p=h=0)||d.pop())if(1===f.nodeType&&++p&&f===t){c[e]=[w,h,p];break}}else if(x&&(l=(t[y]||(t[y]={}))[e])&&l[0]===w)p=l[1];else while(f=++h&&f&&f[g]||(p=h=0)||d.pop())if((a?f.nodeName.toLowerCase()===v:1===f.nodeType)&&++p&&(x&&((f[y]||(f[y]={}))[e]=[w,p]),f===t))break;return p-=i,p===r||0===p%r&&p/r>=0}}},PSEUDO:function(e,t){var n,i=r.pseudos[e]||r.setFilters[e.toLowerCase()]||ut.error("unsupported pseudo: "+e);return i[y]?i(t):i.length>1?(n=[e,e,"",t],r.setFilters.hasOwnProperty(e.toLowerCase())?st(function(e,n){var r,o=i(e,t),s=o.length;while(s--)r=F.call(e,o[s]),e[r]=!(n[r]=o[s])}):function(e){return i(e,0,n)}):i}},pseudos:{not:st(function(e){var t=[],n=[],r=s(e.replace(I,"$1"));return r[y]?st(function(e,t,n,i){var o,s=r(e,null,i,[]),a=e.length;while(a--)(o=s[a])&&(e[a]=!(t[a]=o))}):function(e,i,o){return t[0]=e,r(t,null,o,n),!n.pop()}}),has:st(function(e){return function(t){return ut(e,t).length>0}}),contains:st(function(e){return function(t){return(t.textContent||t.innerText||i(t)).indexOf(e)>-1}}),lang:st(function(e){return V.test(e||"")||ut.error("unsupported lang: "+e),e=e.replace(tt,nt).toLowerCase(),function(t){var n;do if(n=p?t.lang:t.getAttribute("xml:lang")||t.getAttribute("lang"))return n=n.toLowerCase(),n===e||0===n.indexOf(e+"-");while((t=t.parentNode)&&1===t.nodeType);return!1}}),target:function(t){var n=e.location&&e.location.hash;return n&&n.slice(1)===t.id},root:function(e){return e===f},focus:function(e){return e===c.activeElement&&(!c.hasFocus||c.hasFocus())&&!!(e.type||e.href||~e.tabIndex)},enabled:function(e){return e.disabled===!1},disabled:function(e){return e.disabled===!0},checked:function(e){var t=e.nodeName.toLowerCase();return"input"===t&&!!e.checked||"option"===t&&!!e.selected},selected:function(e){return e.parentNode&&e.parentNode.selectedIndex,e.selected===!0},empty:function(e){for(e=e.firstChild;e;e=e.nextSibling)if(e.nodeName>"@"||3===e.nodeType||4===e.nodeType)return!1;return!0},parent:function(e){return!r.pseudos.empty(e)},header:function(e){return Z.test(e.nodeName)},input:function(e){return K.test(e.nodeName)},button:function(e){var t=e.nodeName.toLowerCase();return"input"===t&&"button"===e.type||"button"===t},text:function(e){var t;return"input"===e.nodeName.toLowerCase()&&"text"===e.type&&(null==(t=e.getAttribute("type"))||t.toLowerCase()===e.type)},first:dt(function(){return[0]}),last:dt(function(e,t){return[t-1]}),eq:dt(function(e,t,n){return[0>n?n+t:n]}),even:dt(function(e,t){var n=0;for(;t>n;n+=2)e.push(n);return e}),odd:dt(function(e,t){var n=1;for(;t>n;n+=2)e.push(n);return e}),lt:dt(function(e,t,n){var r=0>n?n+t:n;for(;--r>=0;)e.push(r);return e}),gt:dt(function(e,t,n){var r=0>n?n+t:n;for(;t>++r;)e.push(r);return e})}};for(t in{radio:!0,checkbox:!0,file:!0,password:!0,image:!0})r.pseudos[t]=pt(t);for(t in{submit:!0,reset:!0})r.pseudos[t]=ht(t);function gt(e,t){var n,i,o,s,a,u,l,c=k[e+" "];if(c)return t?0:c.slice(0);a=e,u=[],l=r.preFilter;while(a){(!n||(i=z.exec(a)))&&(i&&(a=a.slice(i[0].length)||a),u.push(o=[])),n=!1,(i=_.exec(a))&&(n=i.shift(),o.push({value:n,type:i[0].replace(I," ")}),a=a.slice(n.length));for(s in r.filter)!(i=G[s].exec(a))||l[s]&&!(i=l[s](i))||(n=i.shift(),o.push({value:n,type:s,matches:i}),a=a.slice(n.length));if(!n)break}return t?a.length:a?ut.error(e):k(e,u).slice(0)}function mt(e){var t=0,n=e.length,r="";for(;n>t;t++)r+=e[t].value;return r}function yt(e,t,r){var i=t.dir,o=r&&"parentNode"===i,s=T++;return t.first?function(t,n,r){while(t=t[i])if(1===t.nodeType||o)return e(t,n,r)}:function(t,r,a){var u,l,c,f=w+" "+s;if(a){while(t=t[i])if((1===t.nodeType||o)&&e(t,r,a))return!0}else while(t=t[i])if(1===t.nodeType||o)if(c=t[y]||(t[y]={}),(l=c[i])&&l[0]===f){if((u=l[1])===!0||u===n)return u===!0}else if(l=c[i]=[f],l[1]=e(t,r,a)||n,l[1]===!0)return!0}}function vt(e){return e.length>1?function(t,n,r){var i=e.length;while(i--)if(!e[i](t,n,r))return!1;return!0}:e[0]}function xt(e,t,n,r,i){var o,s=[],a=0,u=e.length,l=null!=t;for(;u>a;a++)(o=e[a])&&(!n||n(o,r,i))&&(s.push(o),l&&t.push(a));return s}function bt(e,t,n,r,i,o){return r&&!r[y]&&(r=bt(r)),i&&!i[y]&&(i=bt(i,o)),st(function(o,s,a,u){var l,c,f,p=[],h=[],d=s.length,g=o||Ct(t||"*",a.nodeType?[a]:a,[]),m=!e||!o&&t?g:xt(g,p,e,a,u),y=n?i||(o?e:d||r)?[]:s:m;if(n&&n(m,y,a,u),r){l=xt(y,h),r(l,[],a,u),c=l.length;while(c--)(f=l[c])&&(y[h[c]]=!(m[h[c]]=f))}if(o){if(i||e){if(i){l=[],c=y.length;while(c--)(f=y[c])&&l.push(m[c]=f);i(null,y=[],l,u)}c=y.length;while(c--)(f=y[c])&&(l=i?F.call(o,f):p[c])>-1&&(o[l]=!(s[l]=f))}}else y=xt(y===s?y.splice(d,y.length):y),i?i(null,s,y,u):H.apply(s,y)})}function wt(e){var t,n,i,o=e.length,s=r.relative[e[0].type],u=s||r.relative[" "],l=s?1:0,c=yt(function(e){return e===t},u,!0),f=yt(function(e){return F.call(t,e)>-1},u,!0),p=[function(e,n,r){return!s&&(r||n!==a)||((t=n).nodeType?c(e,n,r):f(e,n,r))}];for(;o>l;l++)if(n=r.relative[e[l].type])p=[yt(vt(p),n)];else{if(n=r.filter[e[l].type].apply(null,e[l].matches),n[y]){for(i=++l;o>i;i++)if(r.relative[e[i].type])break;return bt(l>1&&vt(p),l>1&&mt(e.slice(0,l-1)).replace(I,"$1"),n,i>l&&wt(e.slice(l,i)),o>i&&wt(e=e.slice(i)),o>i&&mt(e))}p.push(n)}return vt(p)}function Tt(e,t){var i=0,o=t.length>0,s=e.length>0,u=function(u,l,f,p,h){var d,g,m,y=[],v=0,x="0",b=u&&[],T=null!=h,C=a,k=u||s&&r.find.TAG("*",h&&l.parentNode||l),N=w+=null==C?1:Math.random()||.1;for(T&&(a=l!==c&&l,n=i);null!=(d=k[x]);x++){if(s&&d){g=0;while(m=e[g++])if(m(d,l,f)){p.push(d);break}T&&(w=N,n=++i)}o&&((d=!m&&d)&&v--,u&&b.push(d))}if(v+=x,o&&x!==v){g=0;while(m=t[g++])m(b,y,l,f);if(u){if(v>0)while(x--)b[x]||y[x]||(y[x]=L.call(p));y=xt(y)}H.apply(p,y),T&&!u&&y.length>0&&v+t.length>1&&ut.uniqueSort(p)}return T&&(w=N,a=C),b};return o?st(u):u}s=ut.compile=function(e,t){var n,r=[],i=[],o=N[e+" "];if(!o){t||(t=gt(e)),n=t.length;while(n--)o=wt(t[n]),o[y]?r.push(o):i.push(o);o=N(e,Tt(i,r))}return o};function Ct(e,t,n){var r=0,i=t.length;for(;i>r;r++)ut(e,t[r],n);return n}function kt(e,t,n,i){var o,a,u,l,c,f=gt(e);if(!i&&1===f.length){if(a=f[0]=f[0].slice(0),a.length>2&&"ID"===(u=a[0]).type&&9===t.nodeType&&p&&r.relative[a[1].type]){if(t=(r.find.ID(u.matches[0].replace(tt,nt),t)||[])[0],!t)return n;e=e.slice(a.shift().value.length)}o=G.needsContext.test(e)?0:a.length;while(o--){if(u=a[o],r.relative[l=u.type])break;if((c=r.find[l])&&(i=c(u.matches[0].replace(tt,nt),X.test(a[0].type)&&t.parentNode||t))){if(a.splice(o,1),e=i.length&&mt(a),!e)return H.apply(n,i),n;break}}}return s(e,f)(i,t,!p,n,X.test(e)),n}r.pseudos.nth=r.pseudos.eq;function Nt(){}Nt.prototype=r.filters=r.pseudos,r.setFilters=new Nt,b.sortStable=y.split("").sort(S).join("")===y,l(),[0,0].sort(S),b.detectDuplicates=E,at(function(e){if(e.innerHTML="<a href='#'></a>","#"!==e.firstChild.getAttribute("href")){var t="type|href|height|width".split("|"),n=t.length;while(n--)r.attrHandle[t[n]]=ft}}),at(function(e){if(null!=e.getAttribute("disabled")){var t=P.split("|"),n=t.length;while(n--)r.attrHandle[t[n]]=ct}}),x.find=ut,x.expr=ut.selectors,x.expr[":"]=x.expr.pseudos,x.unique=ut.uniqueSort,x.text=ut.getText,x.isXMLDoc=ut.isXML,x.contains=ut.contains}(e);var D={};function A(e){var t=D[e]={};return x.each(e.match(w)||[],function(e,n){t[n]=!0}),t}x.Callbacks=function(e){e="string"==typeof e?D[e]||A(e):x.extend({},e);var t,n,r,i,o,s,a=[],u=!e.once&&[],l=function(f){for(t=e.memory&&f,n=!0,s=i||0,i=0,o=a.length,r=!0;a&&o>s;s++)if(a[s].apply(f[0],f[1])===!1&&e.stopOnFalse){t=!1;break}r=!1,a&&(u?u.length&&l(u.shift()):t?a=[]:c.disable())},c={add:function(){if(a){var n=a.length;(function s(t){x.each(t,function(t,n){var r=x.type(n);"function"===r?e.unique&&c.has(n)||a.push(n):n&&n.length&&"string"!==r&&s(n)})})(arguments),r?o=a.length:t&&(i=n,l(t))}return this},remove:function(){return a&&x.each(arguments,function(e,t){var n;while((n=x.inArray(t,a,n))>-1)a.splice(n,1),r&&(o>=n&&o--,s>=n&&s--)}),this},has:function(e){return e?x.inArray(e,a)>-1:!(!a||!a.length)},empty:function(){return a=[],o=0,this},disable:function(){return a=u=t=undefined,this},disabled:function(){return!a},lock:function(){return u=undefined,t||c.disable(),this},locked:function(){return!u},fireWith:function(e,t){return t=t||[],t=[e,t.slice?t.slice():t],!a||n&&!u||(r?u.push(t):l(t)),this},fire:function(){return c.fireWith(this,arguments),this},fired:function(){return!!n}};return c},x.extend({Deferred:function(e){var t=[["resolve","done",x.Callbacks("once memory"),"resolved"],["reject","fail",x.Callbacks("once memory"),"rejected"],["notify","progress",x.Callbacks("memory")]],n="pending",r={state:function(){return n},always:function(){return i.done(arguments).fail(arguments),this},then:function(){var e=arguments;return x.Deferred(function(n){x.each(t,function(t,o){var s=o[0],a=x.isFunction(e[t])&&e[t];i[o[1]](function(){var e=a&&a.apply(this,arguments);e&&x.isFunction(e.promise)?e.promise().done(n.resolve).fail(n.reject).progress(n.notify):n[s+"With"](this===r?n.promise():this,a?[e]:arguments)})}),e=null}).promise()},promise:function(e){return null!=e?x.extend(e,r):r}},i={};return r.pipe=r.then,x.each(t,function(e,o){var s=o[2],a=o[3];r[o[1]]=s.add,a&&s.add(function(){n=a},t[1^e][2].disable,t[2][2].lock),i[o[0]]=function(){return i[o[0]+"With"](this===i?r:this,arguments),this},i[o[0]+"With"]=s.fireWith}),r.promise(i),e&&e.call(i,i),i},when:function(e){var t=0,n=d.call(arguments),r=n.length,i=1!==r||e&&x.isFunction(e.promise)?r:0,o=1===i?e:x.Deferred(),s=function(e,t,n){return function(r){t[e]=this,n[e]=arguments.length>1?d.call(arguments):r,n===a?o.notifyWith(t,n):--i||o.resolveWith(t,n)}},a,u,l;if(r>1)for(a=Array(r),u=Array(r),l=Array(r);r>t;t++)n[t]&&x.isFunction(n[t].promise)?n[t].promise().done(s(t,l,n)).fail(o.reject).progress(s(t,u,a)):--i;return i||o.resolveWith(l,n),o.promise()}}),x.support=function(t){var n=o.createElement("input"),r=o.createDocumentFragment(),i=o.createElement("div"),s=o.createElement("select"),a=s.appendChild(o.createElement("option"));return n.type?(n.type="checkbox",t.checkOn=""!==n.value,t.optSelected=a.selected,t.reliableMarginRight=!0,t.boxSizingReliable=!0,t.pixelPosition=!1,n.checked=!0,t.noCloneChecked=n.cloneNode(!0).checked,s.disabled=!0,t.optDisabled=!a.disabled,n=o.createElement("input"),n.value="t",n.type="radio",t.radioValue="t"===n.value,n.setAttribute("checked","t"),n.setAttribute("name","t"),r.appendChild(n),t.checkClone=r.cloneNode(!0).cloneNode(!0).lastChild.checked,t.focusinBubbles="onfocusin"in e,i.style.backgroundClip="content-box",i.cloneNode(!0).style.backgroundClip="",t.clearCloneStyle="content-box"===i.style.backgroundClip,x(function(){var n,r,s="padding:0;margin:0;border:0;display:block;-webkit-box-sizing:content-box;-moz-box-sizing:content-box;box-sizing:content-box",a=o.getElementsByTagName("body")[0];a&&(n=o.createElement("div"),n.style.cssText="border:0;width:0;height:0;position:absolute;top:0;left:-9999px;margin-top:1px",a.appendChild(n).appendChild(i),i.innerHTML="",i.style.cssText="-webkit-box-sizing:border-box;-moz-box-sizing:border-box;box-sizing:border-box;padding:1px;border:1px;display:block;width:4px;margin-top:1%;position:absolute;top:1%",x.swap(a,null!=a.style.zoom?{zoom:1}:{},function(){t.boxSizing=4===i.offsetWidth}),e.getComputedStyle&&(t.pixelPosition="1%"!==(e.getComputedStyle(i,null)||{}).top,t.boxSizingReliable="4px"===(e.getComputedStyle(i,null)||{width:"4px"}).width,r=i.appendChild(o.createElement("div")),r.style.cssText=i.style.cssText=s,r.style.marginRight=r.style.width="0",i.style.width="1px",t.reliableMarginRight=!parseFloat((e.getComputedStyle(r,null)||{}).marginRight)),a.removeChild(n))}),t):t}({});var L,q,H=/(?:\{[\s\S]*\}|\[[\s\S]*\])$/,O=/([A-Z])/g;function F(){Object.defineProperty(this.cache={},0,{get:function(){return{}}}),this.expando=x.expando+Math.random()}F.uid=1,F.accepts=function(e){return e.nodeType?1===e.nodeType||9===e.nodeType:!0},F.prototype={key:function(e){if(!F.accepts(e))return 0;var t={},n=e[this.expando];if(!n){n=F.uid++;try{t[this.expando]={value:n},Object.defineProperties(e,t)}catch(r){t[this.expando]=n,x.extend(e,t)}}return this.cache[n]||(this.cache[n]={}),n},set:function(e,t,n){var r,i=this.key(e),o=this.cache[i];if("string"==typeof t)o[t]=n;else if(x.isEmptyObject(o))this.cache[i]=t;else for(r in t)o[r]=t[r]},get:function(e,t){var n=this.cache[this.key(e)];return t===undefined?n:n[t]},access:function(e,t,n){return t===undefined||t&&"string"==typeof t&&n===undefined?this.get(e,t):(this.set(e,t,n),n!==undefined?n:t)},remove:function(e,t){var n,r,i=this.key(e),o=this.cache[i];if(t===undefined)this.cache[i]={};else{x.isArray(t)?r=t.concat(t.map(x.camelCase)):t in o?r=[t]:(r=x.camelCase(t),r=r in o?[r]:r.match(w)||[]),n=r.length;while(n--)delete o[r[n]]}},hasData:function(e){return!x.isEmptyObject(this.cache[e[this.expando]]||{})},discard:function(e){delete this.cache[this.key(e)]}},L=new F,q=new F,x.extend({acceptData:F.accepts,hasData:function(e){return L.hasData(e)||q.hasData(e)},data:function(e,t,n){return L.access(e,t,n)},removeData:function(e,t){L.remove(e,t)},_data:function(e,t,n){return q.access(e,t,n)},_removeData:function(e,t){q.remove(e,t)}}),x.fn.extend({data:function(e,t){var n,r,i=this[0],o=0,s=null;if(e===undefined){if(this.length&&(s=L.get(i),1===i.nodeType&&!q.get(i,"hasDataAttrs"))){for(n=i.attributes;n.length>o;o++)r=n[o].name,0===r.indexOf("data-")&&(r=x.camelCase(r.substring(5)),P(i,r,s[r]));q.set(i,"hasDataAttrs",!0)}return s}return"object"==typeof e?this.each(function(){L.set(this,e)}):x.access(this,function(t){var n,r=x.camelCase(e);if(i&&t===undefined){if(n=L.get(i,e),n!==undefined)return n;if(n=L.get(i,r),n!==undefined)return n;if(n=P(i,r,undefined),n!==undefined)return n}else this.each(function(){var n=L.get(this,r);L.set(this,r,t),-1!==e.indexOf("-")&&n!==undefined&&L.set(this,e,t)})},null,t,arguments.length>1,null,!0)},removeData:function(e){return this.each(function(){L.remove(this,e)})}});function P(e,t,n){var r;if(n===undefined&&1===e.nodeType)if(r="data-"+t.replace(O,"-$1").toLowerCase(),n=e.getAttribute(r),"string"==typeof n){try{n="true"===n?!0:"false"===n?!1:"null"===n?null:+n+""===n?+n:H.test(n)?JSON.parse(n):n}catch(i){}L.set(e,t,n)}else n=undefined;return n}x.extend({queue:function(e,t,n){var r;return e?(t=(t||"fx")+"queue",r=q.get(e,t),n&&(!r||x.isArray(n)?r=q.access(e,t,x.makeArray(n)):r.push(n)),r||[]):undefined},dequeue:function(e,t){t=t||"fx";var n=x.queue(e,t),r=n.length,i=n.shift(),o=x._queueHooks(e,t),s=function(){x.dequeue(e,t)};"inprogress"===i&&(i=n.shift(),r--),o.cur=i,i&&("fx"===t&&n.unshift("inprogress"),delete o.stop,i.call(e,s,o)),!r&&o&&o.empty.fire()},_queueHooks:function(e,t){var n=t+"queueHooks";return q.get(e,n)||q.access(e,n,{empty:x.Callbacks("once memory").add(function(){q.remove(e,[t+"queue",n])})})}}),x.fn.extend({queue:function(e,t){var n=2;return"string"!=typeof e&&(t=e,e="fx",n--),n>arguments.length?x.queue(this[0],e):t===undefined?this:this.each(function(){var n=x.queue(this,e,t);
+x._queueHooks(this,e),"fx"===e&&"inprogress"!==n[0]&&x.dequeue(this,e)})},dequeue:function(e){return this.each(function(){x.dequeue(this,e)})},delay:function(e,t){return e=x.fx?x.fx.speeds[e]||e:e,t=t||"fx",this.queue(t,function(t,n){var r=setTimeout(t,e);n.stop=function(){clearTimeout(r)}})},clearQueue:function(e){return this.queue(e||"fx",[])},promise:function(e,t){var n,r=1,i=x.Deferred(),o=this,s=this.length,a=function(){--r||i.resolveWith(o,[o])};"string"!=typeof e&&(t=e,e=undefined),e=e||"fx";while(s--)n=q.get(o[s],e+"queueHooks"),n&&n.empty&&(r++,n.empty.add(a));return a(),i.promise(t)}});var R,M,W=/[\t\r\n]/g,$=/\r/g,B=/^(?:input|select|textarea|button)$/i;x.fn.extend({attr:function(e,t){return x.access(this,x.attr,e,t,arguments.length>1)},removeAttr:function(e){return this.each(function(){x.removeAttr(this,e)})},prop:function(e,t){return x.access(this,x.prop,e,t,arguments.length>1)},removeProp:function(e){return this.each(function(){delete this[x.propFix[e]||e]})},addClass:function(e){var t,n,r,i,o,s=0,a=this.length,u="string"==typeof e&&e;if(x.isFunction(e))return this.each(function(t){x(this).addClass(e.call(this,t,this.className))});if(u)for(t=(e||"").match(w)||[];a>s;s++)if(n=this[s],r=1===n.nodeType&&(n.className?(" "+n.className+" ").replace(W," "):" ")){o=0;while(i=t[o++])0>r.indexOf(" "+i+" ")&&(r+=i+" ");n.className=x.trim(r)}return this},removeClass:function(e){var t,n,r,i,o,s=0,a=this.length,u=0===arguments.length||"string"==typeof e&&e;if(x.isFunction(e))return this.each(function(t){x(this).removeClass(e.call(this,t,this.className))});if(u)for(t=(e||"").match(w)||[];a>s;s++)if(n=this[s],r=1===n.nodeType&&(n.className?(" "+n.className+" ").replace(W," "):"")){o=0;while(i=t[o++])while(r.indexOf(" "+i+" ")>=0)r=r.replace(" "+i+" "," ");n.className=e?x.trim(r):""}return this},toggleClass:function(e,t){var n=typeof e,i="boolean"==typeof t;return x.isFunction(e)?this.each(function(n){x(this).toggleClass(e.call(this,n,this.className,t),t)}):this.each(function(){if("string"===n){var o,s=0,a=x(this),u=t,l=e.match(w)||[];while(o=l[s++])u=i?u:!a.hasClass(o),a[u?"addClass":"removeClass"](o)}else(n===r||"boolean"===n)&&(this.className&&q.set(this,"__className__",this.className),this.className=this.className||e===!1?"":q.get(this,"__className__")||"")})},hasClass:function(e){var t=" "+e+" ",n=0,r=this.length;for(;r>n;n++)if(1===this[n].nodeType&&(" "+this[n].className+" ").replace(W," ").indexOf(t)>=0)return!0;return!1},val:function(e){var t,n,r,i=this[0];{if(arguments.length)return r=x.isFunction(e),this.each(function(n){var i,o=x(this);1===this.nodeType&&(i=r?e.call(this,n,o.val()):e,null==i?i="":"number"==typeof i?i+="":x.isArray(i)&&(i=x.map(i,function(e){return null==e?"":e+""})),t=x.valHooks[this.type]||x.valHooks[this.nodeName.toLowerCase()],t&&"set"in t&&t.set(this,i,"value")!==undefined||(this.value=i))});if(i)return t=x.valHooks[i.type]||x.valHooks[i.nodeName.toLowerCase()],t&&"get"in t&&(n=t.get(i,"value"))!==undefined?n:(n=i.value,"string"==typeof n?n.replace($,""):null==n?"":n)}}}),x.extend({valHooks:{option:{get:function(e){var t=e.attributes.value;return!t||t.specified?e.value:e.text}},select:{get:function(e){var t,n,r=e.options,i=e.selectedIndex,o="select-one"===e.type||0>i,s=o?null:[],a=o?i+1:r.length,u=0>i?a:o?i:0;for(;a>u;u++)if(n=r[u],!(!n.selected&&u!==i||(x.support.optDisabled?n.disabled:null!==n.getAttribute("disabled"))||n.parentNode.disabled&&x.nodeName(n.parentNode,"optgroup"))){if(t=x(n).val(),o)return t;s.push(t)}return s},set:function(e,t){var n,r,i=e.options,o=x.makeArray(t),s=i.length;while(s--)r=i[s],(r.selected=x.inArray(x(r).val(),o)>=0)&&(n=!0);return n||(e.selectedIndex=-1),o}}},attr:function(e,t,n){var i,o,s=e.nodeType;if(e&&3!==s&&8!==s&&2!==s)return typeof e.getAttribute===r?x.prop(e,t,n):(1===s&&x.isXMLDoc(e)||(t=t.toLowerCase(),i=x.attrHooks[t]||(x.expr.match.boolean.test(t)?M:R)),n===undefined?i&&"get"in i&&null!==(o=i.get(e,t))?o:(o=x.find.attr(e,t),null==o?undefined:o):null!==n?i&&"set"in i&&(o=i.set(e,n,t))!==undefined?o:(e.setAttribute(t,n+""),n):(x.removeAttr(e,t),undefined))},removeAttr:function(e,t){var n,r,i=0,o=t&&t.match(w);if(o&&1===e.nodeType)while(n=o[i++])r=x.propFix[n]||n,x.expr.match.boolean.test(n)&&(e[r]=!1),e.removeAttribute(n)},attrHooks:{type:{set:function(e,t){if(!x.support.radioValue&&"radio"===t&&x.nodeName(e,"input")){var n=e.value;return e.setAttribute("type",t),n&&(e.value=n),t}}}},propFix:{"for":"htmlFor","class":"className"},prop:function(e,t,n){var r,i,o,s=e.nodeType;if(e&&3!==s&&8!==s&&2!==s)return o=1!==s||!x.isXMLDoc(e),o&&(t=x.propFix[t]||t,i=x.propHooks[t]),n!==undefined?i&&"set"in i&&(r=i.set(e,n,t))!==undefined?r:e[t]=n:i&&"get"in i&&null!==(r=i.get(e,t))?r:e[t]},propHooks:{tabIndex:{get:function(e){return e.hasAttribute("tabindex")||B.test(e.nodeName)||e.href?e.tabIndex:-1}}}}),M={set:function(e,t,n){return t===!1?x.removeAttr(e,n):e.setAttribute(n,n),n}},x.each(x.expr.match.boolean.source.match(/\w+/g),function(e,t){var n=x.expr.attrHandle[t]||x.find.attr;x.expr.attrHandle[t]=function(e,t,r){var i=x.expr.attrHandle[t],o=r?undefined:(x.expr.attrHandle[t]=undefined)!=n(e,t,r)?t.toLowerCase():null;return x.expr.attrHandle[t]=i,o}}),x.support.optSelected||(x.propHooks.selected={get:function(e){var t=e.parentNode;return t&&t.parentNode&&t.parentNode.selectedIndex,null}}),x.each(["tabIndex","readOnly","maxLength","cellSpacing","cellPadding","rowSpan","colSpan","useMap","frameBorder","contentEditable"],function(){x.propFix[this.toLowerCase()]=this}),x.each(["radio","checkbox"],function(){x.valHooks[this]={set:function(e,t){return x.isArray(t)?e.checked=x.inArray(x(e).val(),t)>=0:undefined}},x.support.checkOn||(x.valHooks[this].get=function(e){return null===e.getAttribute("value")?"on":e.value})});var I=/^key/,z=/^(?:mouse|contextmenu)|click/,_=/^(?:focusinfocus|focusoutblur)$/,X=/^([^.]*)(?:\.(.+)|)$/;function U(){return!0}function Y(){return!1}function V(){try{return o.activeElement}catch(e){}}x.event={global:{},add:function(e,t,n,i,o){var s,a,u,l,c,f,p,h,d,g,m,y=q.get(e);if(y){n.handler&&(s=n,n=s.handler,o=s.selector),n.guid||(n.guid=x.guid++),(l=y.events)||(l=y.events={}),(a=y.handle)||(a=y.handle=function(e){return typeof x===r||e&&x.event.triggered===e.type?undefined:x.event.dispatch.apply(a.elem,arguments)},a.elem=e),t=(t||"").match(w)||[""],c=t.length;while(c--)u=X.exec(t[c])||[],d=m=u[1],g=(u[2]||"").split(".").sort(),d&&(p=x.event.special[d]||{},d=(o?p.delegateType:p.bindType)||d,p=x.event.special[d]||{},f=x.extend({type:d,origType:m,data:i,handler:n,guid:n.guid,selector:o,needsContext:o&&x.expr.match.needsContext.test(o),namespace:g.join(".")},s),(h=l[d])||(h=l[d]=[],h.delegateCount=0,p.setup&&p.setup.call(e,i,g,a)!==!1||e.addEventListener&&e.addEventListener(d,a,!1)),p.add&&(p.add.call(e,f),f.handler.guid||(f.handler.guid=n.guid)),o?h.splice(h.delegateCount++,0,f):h.push(f),x.event.global[d]=!0);e=null}},remove:function(e,t,n,r,i){var o,s,a,u,l,c,f,p,h,d,g,m=q.hasData(e)&&q.get(e);if(m&&(u=m.events)){t=(t||"").match(w)||[""],l=t.length;while(l--)if(a=X.exec(t[l])||[],h=g=a[1],d=(a[2]||"").split(".").sort(),h){f=x.event.special[h]||{},h=(r?f.delegateType:f.bindType)||h,p=u[h]||[],a=a[2]&&RegExp("(^|\\.)"+d.join("\\.(?:.*\\.|)")+"(\\.|$)"),s=o=p.length;while(o--)c=p[o],!i&&g!==c.origType||n&&n.guid!==c.guid||a&&!a.test(c.namespace)||r&&r!==c.selector&&("**"!==r||!c.selector)||(p.splice(o,1),c.selector&&p.delegateCount--,f.remove&&f.remove.call(e,c));s&&!p.length&&(f.teardown&&f.teardown.call(e,d,m.handle)!==!1||x.removeEvent(e,h,m.handle),delete u[h])}else for(h in u)x.event.remove(e,h+t[l],n,r,!0);x.isEmptyObject(u)&&(delete m.handle,q.remove(e,"events"))}},trigger:function(t,n,r,i){var s,a,u,l,c,f,p,h=[r||o],d=y.call(t,"type")?t.type:t,g=y.call(t,"namespace")?t.namespace.split("."):[];if(a=u=r=r||o,3!==r.nodeType&&8!==r.nodeType&&!_.test(d+x.event.triggered)&&(d.indexOf(".")>=0&&(g=d.split("."),d=g.shift(),g.sort()),c=0>d.indexOf(":")&&"on"+d,t=t[x.expando]?t:new x.Event(d,"object"==typeof t&&t),t.isTrigger=i?2:3,t.namespace=g.join("."),t.namespace_re=t.namespace?RegExp("(^|\\.)"+g.join("\\.(?:.*\\.|)")+"(\\.|$)"):null,t.result=undefined,t.target||(t.target=r),n=null==n?[t]:x.makeArray(n,[t]),p=x.event.special[d]||{},i||!p.trigger||p.trigger.apply(r,n)!==!1)){if(!i&&!p.noBubble&&!x.isWindow(r)){for(l=p.delegateType||d,_.test(l+d)||(a=a.parentNode);a;a=a.parentNode)h.push(a),u=a;u===(r.ownerDocument||o)&&h.push(u.defaultView||u.parentWindow||e)}s=0;while((a=h[s++])&&!t.isPropagationStopped())t.type=s>1?l:p.bindType||d,f=(q.get(a,"events")||{})[t.type]&&q.get(a,"handle"),f&&f.apply(a,n),f=c&&a[c],f&&x.acceptData(a)&&f.apply&&f.apply(a,n)===!1&&t.preventDefault();return t.type=d,i||t.isDefaultPrevented()||p._default&&p._default.apply(h.pop(),n)!==!1||!x.acceptData(r)||c&&x.isFunction(r[d])&&!x.isWindow(r)&&(u=r[c],u&&(r[c]=null),x.event.triggered=d,r[d](),x.event.triggered=undefined,u&&(r[c]=u)),t.result}},dispatch:function(e){e=x.event.fix(e);var t,n,r,i,o,s=[],a=d.call(arguments),u=(q.get(this,"events")||{})[e.type]||[],l=x.event.special[e.type]||{};if(a[0]=e,e.delegateTarget=this,!l.preDispatch||l.preDispatch.call(this,e)!==!1){s=x.event.handlers.call(this,e,u),t=0;while((i=s[t++])&&!e.isPropagationStopped()){e.currentTarget=i.elem,n=0;while((o=i.handlers[n++])&&!e.isImmediatePropagationStopped())(!e.namespace_re||e.namespace_re.test(o.namespace))&&(e.handleObj=o,e.data=o.data,r=((x.event.special[o.origType]||{}).handle||o.handler).apply(i.elem,a),r!==undefined&&(e.result=r)===!1&&(e.preventDefault(),e.stopPropagation()))}return l.postDispatch&&l.postDispatch.call(this,e),e.result}},handlers:function(e,t){var n,r,i,o,s=[],a=t.delegateCount,u=e.target;if(a&&u.nodeType&&(!e.button||"click"!==e.type))for(;u!==this;u=u.parentNode||this)if(u.disabled!==!0||"click"!==e.type){for(r=[],n=0;a>n;n++)o=t[n],i=o.selector+" ",r[i]===undefined&&(r[i]=o.needsContext?x(i,this).index(u)>=0:x.find(i,this,null,[u]).length),r[i]&&r.push(o);r.length&&s.push({elem:u,handlers:r})}return t.length>a&&s.push({elem:this,handlers:t.slice(a)}),s},props:"altKey bubbles cancelable ctrlKey currentTarget eventPhase metaKey relatedTarget shiftKey target timeStamp view which".split(" "),fixHooks:{},keyHooks:{props:"char charCode key keyCode".split(" "),filter:function(e,t){return null==e.which&&(e.which=null!=t.charCode?t.charCode:t.keyCode),e}},mouseHooks:{props:"button buttons clientX clientY offsetX offsetY pageX pageY screenX screenY toElement".split(" "),filter:function(e,t){var n,r,i,s=t.button;return null==e.pageX&&null!=t.clientX&&(n=e.target.ownerDocument||o,r=n.documentElement,i=n.body,e.pageX=t.clientX+(r&&r.scrollLeft||i&&i.scrollLeft||0)-(r&&r.clientLeft||i&&i.clientLeft||0),e.pageY=t.clientY+(r&&r.scrollTop||i&&i.scrollTop||0)-(r&&r.clientTop||i&&i.clientTop||0)),e.which||s===undefined||(e.which=1&s?1:2&s?3:4&s?2:0),e}},fix:function(e){if(e[x.expando])return e;var t,n,r,i=e.type,o=e,s=this.fixHooks[i];s||(this.fixHooks[i]=s=z.test(i)?this.mouseHooks:I.test(i)?this.keyHooks:{}),r=s.props?this.props.concat(s.props):this.props,e=new x.Event(o),t=r.length;while(t--)n=r[t],e[n]=o[n];return 3===e.target.nodeType&&(e.target=e.target.parentNode),s.filter?s.filter(e,o):e},special:{load:{noBubble:!0},focus:{trigger:function(){return this!==V()&&this.focus?(this.focus(),!1):undefined},delegateType:"focusin"},blur:{trigger:function(){return this===V()&&this.blur?(this.blur(),!1):undefined},delegateType:"focusout"},click:{trigger:function(){return"checkbox"===this.type&&this.click&&x.nodeName(this,"input")?(this.click(),!1):undefined},_default:function(e){return x.nodeName(e.target,"a")}},beforeunload:{postDispatch:function(e){e.result!==undefined&&(e.originalEvent.returnValue=e.result)}}},simulate:function(e,t,n,r){var i=x.extend(new x.Event,n,{type:e,isSimulated:!0,originalEvent:{}});r?x.event.trigger(i,null,t):x.event.dispatch.call(t,i),i.isDefaultPrevented()&&n.preventDefault()}},x.removeEvent=function(e,t,n){e.removeEventListener&&e.removeEventListener(t,n,!1)},x.Event=function(e,t){return this instanceof x.Event?(e&&e.type?(this.originalEvent=e,this.type=e.type,this.isDefaultPrevented=e.defaultPrevented||e.getPreventDefault&&e.getPreventDefault()?U:Y):this.type=e,t&&x.extend(this,t),this.timeStamp=e&&e.timeStamp||x.now(),this[x.expando]=!0,undefined):new x.Event(e,t)},x.Event.prototype={isDefaultPrevented:Y,isPropagationStopped:Y,isImmediatePropagationStopped:Y,preventDefault:function(){var e=this.originalEvent;this.isDefaultPrevented=U,e&&e.preventDefault&&e.preventDefault()},stopPropagation:function(){var e=this.originalEvent;this.isPropagationStopped=U,e&&e.stopPropagation&&e.stopPropagation()},stopImmediatePropagation:function(){this.isImmediatePropagationStopped=U,this.stopPropagation()}},x.each({mouseenter:"mouseover",mouseleave:"mouseout"},function(e,t){x.event.special[e]={delegateType:t,bindType:t,handle:function(e){var n,r=this,i=e.relatedTarget,o=e.handleObj;return(!i||i!==r&&!x.contains(r,i))&&(e.type=o.origType,n=o.handler.apply(this,arguments),e.type=t),n}}}),x.support.focusinBubbles||x.each({focus:"focusin",blur:"focusout"},function(e,t){var n=0,r=function(e){x.event.simulate(t,e.target,x.event.fix(e),!0)};x.event.special[t]={setup:function(){0===n++&&o.addEventListener(e,r,!0)},teardown:function(){0===--n&&o.removeEventListener(e,r,!0)}}}),x.fn.extend({on:function(e,t,n,r,i){var o,s;if("object"==typeof e){"string"!=typeof t&&(n=n||t,t=undefined);for(s in e)this.on(s,t,n,e[s],i);return this}if(null==n&&null==r?(r=t,n=t=undefined):null==r&&("string"==typeof t?(r=n,n=undefined):(r=n,n=t,t=undefined)),r===!1)r=Y;else if(!r)return this;return 1===i&&(o=r,r=function(e){return x().off(e),o.apply(this,arguments)},r.guid=o.guid||(o.guid=x.guid++)),this.each(function(){x.event.add(this,e,r,n,t)})},one:function(e,t,n,r){return this.on(e,t,n,r,1)},off:function(e,t,n){var r,i;if(e&&e.preventDefault&&e.handleObj)return r=e.handleObj,x(e.delegateTarget).off(r.namespace?r.origType+"."+r.namespace:r.origType,r.selector,r.handler),this;if("object"==typeof e){for(i in e)this.off(i,t,e[i]);return this}return(t===!1||"function"==typeof t)&&(n=t,t=undefined),n===!1&&(n=Y),this.each(function(){x.event.remove(this,e,n,t)})},trigger:function(e,t){return this.each(function(){x.event.trigger(e,t,this)})},triggerHandler:function(e,t){var n=this[0];return n?x.event.trigger(e,t,n,!0):undefined}});var G=/^.[^:#\[\.,]*$/,J=x.expr.match.needsContext,Q={children:!0,contents:!0,next:!0,prev:!0};x.fn.extend({find:function(e){var t,n,r,i=this.length;if("string"!=typeof e)return t=this,this.pushStack(x(e).filter(function(){for(r=0;i>r;r++)if(x.contains(t[r],this))return!0}));for(n=[],r=0;i>r;r++)x.find(e,this[r],n);return n=this.pushStack(i>1?x.unique(n):n),n.selector=(this.selector?this.selector+" ":"")+e,n},has:function(e){var t=x(e,this),n=t.length;return this.filter(function(){var e=0;for(;n>e;e++)if(x.contains(this,t[e]))return!0})},not:function(e){return this.pushStack(Z(this,e||[],!0))},filter:function(e){return this.pushStack(Z(this,e||[],!1))},is:function(e){return!!e&&("string"==typeof e?J.test(e)?x(e,this.context).index(this[0])>=0:x.filter(e,this).length>0:this.filter(e).length>0)},closest:function(e,t){var n,r=0,i=this.length,o=[],s=J.test(e)||"string"!=typeof e?x(e,t||this.context):0;for(;i>r;r++)for(n=this[r];n&&n!==t;n=n.parentNode)if(11>n.nodeType&&(s?s.index(n)>-1:1===n.nodeType&&x.find.matchesSelector(n,e))){n=o.push(n);break}return this.pushStack(o.length>1?x.unique(o):o)},index:function(e){return e?"string"==typeof e?g.call(x(e),this[0]):g.call(this,e.jquery?e[0]:e):this[0]&&this[0].parentNode?this.first().prevAll().length:-1},add:function(e,t){var n="string"==typeof e?x(e,t):x.makeArray(e&&e.nodeType?[e]:e),r=x.merge(this.get(),n);return this.pushStack(x.unique(r))},addBack:function(e){return this.add(null==e?this.prevObject:this.prevObject.filter(e))}});function K(e,t){while((e=e[t])&&1!==e.nodeType);return e}x.each({parent:function(e){var t=e.parentNode;return t&&11!==t.nodeType?t:null},parents:function(e){return x.dir(e,"parentNode")},parentsUntil:function(e,t,n){return x.dir(e,"parentNode",n)},next:function(e){return K(e,"nextSibling")},prev:function(e){return K(e,"previousSibling")},nextAll:function(e){return x.dir(e,"nextSibling")},prevAll:function(e){return x.dir(e,"previousSibling")},nextUntil:function(e,t,n){return x.dir(e,"nextSibling",n)},prevUntil:function(e,t,n){return x.dir(e,"previousSibling",n)},siblings:function(e){return x.sibling((e.parentNode||{}).firstChild,e)},children:function(e){return x.sibling(e.firstChild)},contents:function(e){return x.nodeName(e,"iframe")?e.contentDocument||e.contentWindow.document:x.merge([],e.childNodes)}},function(e,t){x.fn[e]=function(n,r){var i=x.map(this,t,n);return"Until"!==e.slice(-5)&&(r=n),r&&"string"==typeof r&&(i=x.filter(r,i)),this.length>1&&(Q[e]||x.unique(i),"p"===e[0]&&i.reverse()),this.pushStack(i)}}),x.extend({filter:function(e,t,n){var r=t[0];return n&&(e=":not("+e+")"),1===t.length&&1===r.nodeType?x.find.matchesSelector(r,e)?[r]:[]:x.find.matches(e,x.grep(t,function(e){return 1===e.nodeType}))},dir:function(e,t,n){var r=[],i=n!==undefined;while((e=e[t])&&9!==e.nodeType)if(1===e.nodeType){if(i&&x(e).is(n))break;r.push(e)}return r},sibling:function(e,t){var n=[];for(;e;e=e.nextSibling)1===e.nodeType&&e!==t&&n.push(e);return n}});function Z(e,t,n){if(x.isFunction(t))return x.grep(e,function(e,r){return!!t.call(e,r,e)!==n});if(t.nodeType)return x.grep(e,function(e){return e===t!==n});if("string"==typeof t){if(G.test(t))return x.filter(t,e,n);t=x.filter(t,e)}return x.grep(e,function(e){return g.call(t,e)>=0!==n})}var et=/<(?!area|br|col|embed|hr|img|input|link|meta|param)(([\w:]+)[^>]*)\/>/gi,tt=/<([\w:]+)/,nt=/<|&#?\w+;/,rt=/<(?:script|style|link)/i,it=/^(?:checkbox|radio)$/i,ot=/checked\s*(?:[^=]|=\s*.checked.)/i,st=/^$|\/(?:java|ecma)script/i,at=/^true\/(.*)/,ut=/^\s*<!(?:\[CDATA\[|--)|(?:\]\]|--)>\s*$/g,lt={option:[1,"<select multiple='multiple'>","</select>"],thead:[1,"<table>","</table>"],tr:[2,"<table><tbody>","</tbody></table>"],td:[3,"<table><tbody><tr>","</tr></tbody></table>"],_default:[0,"",""]};lt.optgroup=lt.option,lt.tbody=lt.tfoot=lt.colgroup=lt.caption=lt.col=lt.thead,lt.th=lt.td,x.fn.extend({text:function(e){return x.access(this,function(e){return e===undefined?x.text(this):this.empty().append((this[0]&&this[0].ownerDocument||o).createTextNode(e))},null,e,arguments.length)},append:function(){return this.domManip(arguments,function(e){if(1===this.nodeType||11===this.nodeType||9===this.nodeType){var t=ct(this,e);t.appendChild(e)}})},prepend:function(){return this.domManip(arguments,function(e){if(1===this.nodeType||11===this.nodeType||9===this.nodeType){var t=ct(this,e);t.insertBefore(e,t.firstChild)}})},before:function(){return this.domManip(arguments,function(e){this.parentNode&&this.parentNode.insertBefore(e,this)})},after:function(){return this.domManip(arguments,function(e){this.parentNode&&this.parentNode.insertBefore(e,this.nextSibling)})},remove:function(e,t){var n,r=e?x.filter(e,this):this,i=0;for(;null!=(n=r[i]);i++)t||1!==n.nodeType||x.cleanData(gt(n)),n.parentNode&&(t&&x.contains(n.ownerDocument,n)&&ht(gt(n,"script")),n.parentNode.removeChild(n));return this},empty:function(){var e,t=0;for(;null!=(e=this[t]);t++)1===e.nodeType&&(x.cleanData(gt(e,!1)),e.textContent="");return this},clone:function(e,t){return e=null==e?!1:e,t=null==t?e:t,this.map(function(){return x.clone(this,e,t)})},html:function(e){return x.access(this,function(e){var t=this[0]||{},n=0,r=this.length;if(e===undefined&&1===t.nodeType)return t.innerHTML;if("string"==typeof e&&!rt.test(e)&&!lt[(tt.exec(e)||["",""])[1].toLowerCase()]){e=e.replace(et,"<$1></$2>");try{for(;r>n;n++)t=this[n]||{},1===t.nodeType&&(x.cleanData(gt(t,!1)),t.innerHTML=e);t=0}catch(i){}}t&&this.empty().append(e)},null,e,arguments.length)},replaceWith:function(){var e=x.map(this,function(e){return[e.nextSibling,e.parentNode]}),t=0;return this.domManip(arguments,function(n){var r=e[t++],i=e[t++];i&&(x(this).remove(),i.insertBefore(n,r))},!0),t?this:this.remove()},detach:function(e){return this.remove(e,!0)},domManip:function(e,t,n){e=p.apply([],e);var r,i,o,s,a,u,l=0,c=this.length,f=this,h=c-1,d=e[0],g=x.isFunction(d);if(g||!(1>=c||"string"!=typeof d||x.support.checkClone)&&ot.test(d))return this.each(function(r){var i=f.eq(r);g&&(e[0]=d.call(this,r,i.html())),i.domManip(e,t,n)});if(c&&(r=x.buildFragment(e,this[0].ownerDocument,!1,!n&&this),i=r.firstChild,1===r.childNodes.length&&(r=i),i)){for(o=x.map(gt(r,"script"),ft),s=o.length;c>l;l++)a=r,l!==h&&(a=x.clone(a,!0,!0),s&&x.merge(o,gt(a,"script"))),t.call(this[l],a,l);if(s)for(u=o[o.length-1].ownerDocument,x.map(o,pt),l=0;s>l;l++)a=o[l],st.test(a.type||"")&&!q.access(a,"globalEval")&&x.contains(u,a)&&(a.src?x._evalUrl(a.src):x.globalEval(a.textContent.replace(ut,"")))}return this}}),x.each({appendTo:"append",prependTo:"prepend",insertBefore:"before",insertAfter:"after",replaceAll:"replaceWith"},function(e,t){x.fn[e]=function(e){var n,r=[],i=x(e),o=i.length-1,s=0;for(;o>=s;s++)n=s===o?this:this.clone(!0),x(i[s])[t](n),h.apply(r,n.get());return this.pushStack(r)}}),x.extend({clone:function(e,t,n){var r,i,o,s,a=e.cloneNode(!0),u=x.contains(e.ownerDocument,e);if(!(x.support.noCloneChecked||1!==e.nodeType&&11!==e.nodeType||x.isXMLDoc(e)))for(s=gt(a),o=gt(e),r=0,i=o.length;i>r;r++)mt(o[r],s[r]);if(t)if(n)for(o=o||gt(e),s=s||gt(a),r=0,i=o.length;i>r;r++)dt(o[r],s[r]);else dt(e,a);return s=gt(a,"script"),s.length>0&&ht(s,!u&>(e,"script")),a},buildFragment:function(e,t,n,r){var i,o,s,a,u,l,c=0,f=e.length,p=t.createDocumentFragment(),h=[];for(;f>c;c++)if(i=e[c],i||0===i)if("object"===x.type(i))x.merge(h,i.nodeType?[i]:i);else if(nt.test(i)){o=o||p.appendChild(t.createElement("div")),s=(tt.exec(i)||["",""])[1].toLowerCase(),a=lt[s]||lt._default,o.innerHTML=a[1]+i.replace(et,"<$1></$2>")+a[2],l=a[0];while(l--)o=o.firstChild;x.merge(h,o.childNodes),o=p.firstChild,o.textContent=""}else h.push(t.createTextNode(i));p.textContent="",c=0;while(i=h[c++])if((!r||-1===x.inArray(i,r))&&(u=x.contains(i.ownerDocument,i),o=gt(p.appendChild(i),"script"),u&&ht(o),n)){l=0;while(i=o[l++])st.test(i.type||"")&&n.push(i)}return p},cleanData:function(e){var t,n,r,i=e.length,o=0,s=x.event.special;for(;i>o;o++){if(n=e[o],x.acceptData(n)&&(t=q.access(n)))for(r in t.events)s[r]?x.event.remove(n,r):x.removeEvent(n,r,t.handle);L.discard(n),q.discard(n)}},_evalUrl:function(e){return x.ajax({url:e,type:"GET",dataType:"text",async:!1,global:!1,success:x.globalEval})}});function ct(e,t){return x.nodeName(e,"table")&&x.nodeName(1===t.nodeType?t:t.firstChild,"tr")?e.getElementsByTagName("tbody")[0]||e.appendChild(e.ownerDocument.createElement("tbody")):e}function ft(e){return e.type=(null!==e.getAttribute("type"))+"/"+e.type,e}function pt(e){var t=at.exec(e.type);return t?e.type=t[1]:e.removeAttribute("type"),e}function ht(e,t){var n=e.length,r=0;for(;n>r;r++)q.set(e[r],"globalEval",!t||q.get(t[r],"globalEval"))}function dt(e,t){var n,r,i,o,s,a,u,l;if(1===t.nodeType){if(q.hasData(e)&&(o=q.access(e),s=x.extend({},o),l=o.events,q.set(t,s),l)){delete s.handle,s.events={};for(i in l)for(n=0,r=l[i].length;r>n;n++)x.event.add(t,i,l[i][n])}L.hasData(e)&&(a=L.access(e),u=x.extend({},a),L.set(t,u))}}function gt(e,t){var n=e.getElementsByTagName?e.getElementsByTagName(t||"*"):e.querySelectorAll?e.querySelectorAll(t||"*"):[];return t===undefined||t&&x.nodeName(e,t)?x.merge([e],n):n}function mt(e,t){var n=t.nodeName.toLowerCase();"input"===n&&it.test(e.type)?t.checked=e.checked:("input"===n||"textarea"===n)&&(t.defaultValue=e.defaultValue)}x.fn.extend({wrapAll:function(e){var t;return x.isFunction(e)?this.each(function(t){x(this).wrapAll(e.call(this,t))}):(this[0]&&(t=x(e,this[0].ownerDocument).eq(0).clone(!0),this[0].parentNode&&t.insertBefore(this[0]),t.map(function(){var e=this;while(e.firstElementChild)e=e.firstElementChild;return e}).append(this)),this)},wrapInner:function(e){return x.isFunction(e)?this.each(function(t){x(this).wrapInner(e.call(this,t))}):this.each(function(){var t=x(this),n=t.contents();n.length?n.wrapAll(e):t.append(e)})},wrap:function(e){var t=x.isFunction(e);return this.each(function(n){x(this).wrapAll(t?e.call(this,n):e)})},unwrap:function(){return this.parent().each(function(){x.nodeName(this,"body")||x(this).replaceWith(this.childNodes)}).end()}});var yt,vt,xt=/^(none|table(?!-c[ea]).+)/,bt=/^margin/,wt=RegExp("^("+b+")(.*)$","i"),Tt=RegExp("^("+b+")(?!px)[a-z%]+$","i"),Ct=RegExp("^([+-])=("+b+")","i"),kt={BODY:"block"},Nt={position:"absolute",visibility:"hidden",display:"block"},Et={letterSpacing:0,fontWeight:400},St=["Top","Right","Bottom","Left"],jt=["Webkit","O","Moz","ms"];function Dt(e,t){if(t in e)return t;var n=t.charAt(0).toUpperCase()+t.slice(1),r=t,i=jt.length;while(i--)if(t=jt[i]+n,t in e)return t;return r}function At(e,t){return e=t||e,"none"===x.css(e,"display")||!x.contains(e.ownerDocument,e)}function Lt(t){return e.getComputedStyle(t,null)}function qt(e,t){var n,r,i,o=[],s=0,a=e.length;for(;a>s;s++)r=e[s],r.style&&(o[s]=q.get(r,"olddisplay"),n=r.style.display,t?(o[s]||"none"!==n||(r.style.display=""),""===r.style.display&&At(r)&&(o[s]=q.access(r,"olddisplay",Pt(r.nodeName)))):o[s]||(i=At(r),(n&&"none"!==n||!i)&&q.set(r,"olddisplay",i?n:x.css(r,"display"))));for(s=0;a>s;s++)r=e[s],r.style&&(t&&"none"!==r.style.display&&""!==r.style.display||(r.style.display=t?o[s]||"":"none"));return e}x.fn.extend({css:function(e,t){return x.access(this,function(e,t,n){var r,i,o={},s=0;if(x.isArray(t)){for(r=Lt(e),i=t.length;i>s;s++)o[t[s]]=x.css(e,t[s],!1,r);return o}return n!==undefined?x.style(e,t,n):x.css(e,t)},e,t,arguments.length>1)},show:function(){return qt(this,!0)},hide:function(){return qt(this)},toggle:function(e){var t="boolean"==typeof e;return this.each(function(){(t?e:At(this))?x(this).show():x(this).hide()})}}),x.extend({cssHooks:{opacity:{get:function(e,t){if(t){var n=yt(e,"opacity");return""===n?"1":n}}}},cssNumber:{columnCount:!0,fillOpacity:!0,fontWeight:!0,lineHeight:!0,opacity:!0,orphans:!0,widows:!0,zIndex:!0,zoom:!0},cssProps:{"float":"cssFloat"},style:function(e,t,n,r){if(e&&3!==e.nodeType&&8!==e.nodeType&&e.style){var i,o,s,a=x.camelCase(t),u=e.style;return t=x.cssProps[a]||(x.cssProps[a]=Dt(u,a)),s=x.cssHooks[t]||x.cssHooks[a],n===undefined?s&&"get"in s&&(i=s.get(e,!1,r))!==undefined?i:u[t]:(o=typeof n,"string"===o&&(i=Ct.exec(n))&&(n=(i[1]+1)*i[2]+parseFloat(x.css(e,t)),o="number"),null==n||"number"===o&&isNaN(n)||("number"!==o||x.cssNumber[a]||(n+="px"),x.support.clearCloneStyle||""!==n||0!==t.indexOf("background")||(u[t]="inherit"),s&&"set"in s&&(n=s.set(e,n,r))===undefined||(u[t]=n)),undefined)}},css:function(e,t,n,r){var i,o,s,a=x.camelCase(t);return t=x.cssProps[a]||(x.cssProps[a]=Dt(e.style,a)),s=x.cssHooks[t]||x.cssHooks[a],s&&"get"in s&&(i=s.get(e,!0,n)),i===undefined&&(i=yt(e,t,r)),"normal"===i&&t in Et&&(i=Et[t]),""===n||n?(o=parseFloat(i),n===!0||x.isNumeric(o)?o||0:i):i}}),yt=function(e,t,n){var r,i,o,s=n||Lt(e),a=s?s.getPropertyValue(t)||s[t]:undefined,u=e.style;return s&&(""!==a||x.contains(e.ownerDocument,e)||(a=x.style(e,t)),Tt.test(a)&&bt.test(t)&&(r=u.width,i=u.minWidth,o=u.maxWidth,u.minWidth=u.maxWidth=u.width=a,a=s.width,u.width=r,u.minWidth=i,u.maxWidth=o)),a};function Ht(e,t,n){var r=wt.exec(t);return r?Math.max(0,r[1]-(n||0))+(r[2]||"px"):t}function Ot(e,t,n,r,i){var o=n===(r?"border":"content")?4:"width"===t?1:0,s=0;for(;4>o;o+=2)"margin"===n&&(s+=x.css(e,n+St[o],!0,i)),r?("content"===n&&(s-=x.css(e,"padding"+St[o],!0,i)),"margin"!==n&&(s-=x.css(e,"border"+St[o]+"Width",!0,i))):(s+=x.css(e,"padding"+St[o],!0,i),"padding"!==n&&(s+=x.css(e,"border"+St[o]+"Width",!0,i)));return s}function Ft(e,t,n){var r=!0,i="width"===t?e.offsetWidth:e.offsetHeight,o=Lt(e),s=x.support.boxSizing&&"border-box"===x.css(e,"boxSizing",!1,o);if(0>=i||null==i){if(i=yt(e,t,o),(0>i||null==i)&&(i=e.style[t]),Tt.test(i))return i;r=s&&(x.support.boxSizingReliable||i===e.style[t]),i=parseFloat(i)||0}return i+Ot(e,t,n||(s?"border":"content"),r,o)+"px"}function Pt(e){var t=o,n=kt[e];return n||(n=Rt(e,t),"none"!==n&&n||(vt=(vt||x("<iframe frameborder='0' width='0' height='0'/>").css("cssText","display:block !important")).appendTo(t.documentElement),t=(vt[0].contentWindow||vt[0].contentDocument).document,t.write("<!doctype html><html><body>"),t.close(),n=Rt(e,t),vt.detach()),kt[e]=n),n}function Rt(e,t){var n=x(t.createElement(e)).appendTo(t.body),r=x.css(n[0],"display");return n.remove(),r}x.each(["height","width"],function(e,t){x.cssHooks[t]={get:function(e,n,r){return n?0===e.offsetWidth&&xt.test(x.css(e,"display"))?x.swap(e,Nt,function(){return Ft(e,t,r)}):Ft(e,t,r):undefined},set:function(e,n,r){var i=r&&Lt(e);return Ht(e,n,r?Ot(e,t,r,x.support.boxSizing&&"border-box"===x.css(e,"boxSizing",!1,i),i):0)}}}),x(function(){x.support.reliableMarginRight||(x.cssHooks.marginRight={get:function(e,t){return t?x.swap(e,{display:"inline-block"},yt,[e,"marginRight"]):undefined}}),!x.support.pixelPosition&&x.fn.position&&x.each(["top","left"],function(e,t){x.cssHooks[t]={get:function(e,n){return n?(n=yt(e,t),Tt.test(n)?x(e).position()[t]+"px":n):undefined}}})}),x.expr&&x.expr.filters&&(x.expr.filters.hidden=function(e){return 0>=e.offsetWidth&&0>=e.offsetHeight},x.expr.filters.visible=function(e){return!x.expr.filters.hidden(e)}),x.each({margin:"",padding:"",border:"Width"},function(e,t){x.cssHooks[e+t]={expand:function(n){var r=0,i={},o="string"==typeof n?n.split(" "):[n];for(;4>r;r++)i[e+St[r]+t]=o[r]||o[r-2]||o[0];return i}},bt.test(e)||(x.cssHooks[e+t].set=Ht)});var Mt=/%20/g,Wt=/\[\]$/,$t=/\r?\n/g,Bt=/^(?:submit|button|image|reset|file)$/i,It=/^(?:input|select|textarea|keygen)/i;x.fn.extend({serialize:function(){return x.param(this.serializeArray())},serializeArray:function(){return this.map(function(){var e=x.prop(this,"elements");return e?x.makeArray(e):this}).filter(function(){var e=this.type;return this.name&&!x(this).is(":disabled")&&It.test(this.nodeName)&&!Bt.test(e)&&(this.checked||!it.test(e))}).map(function(e,t){var n=x(this).val();return null==n?null:x.isArray(n)?x.map(n,function(e){return{name:t.name,value:e.replace($t,"\r\n")}}):{name:t.name,value:n.replace($t,"\r\n")}}).get()}}),x.param=function(e,t){var n,r=[],i=function(e,t){t=x.isFunction(t)?t():null==t?"":t,r[r.length]=encodeURIComponent(e)+"="+encodeURIComponent(t)};if(t===undefined&&(t=x.ajaxSettings&&x.ajaxSettings.traditional),x.isArray(e)||e.jquery&&!x.isPlainObject(e))x.each(e,function(){i(this.name,this.value)});else for(n in e)zt(n,e[n],t,i);return r.join("&").replace(Mt,"+")};function zt(e,t,n,r){var i;if(x.isArray(t))x.each(t,function(t,i){n||Wt.test(e)?r(e,i):zt(e+"["+("object"==typeof i?t:"")+"]",i,n,r)});else if(n||"object"!==x.type(t))r(e,t);else for(i in t)zt(e+"["+i+"]",t[i],n,r)}x.each("blur focus focusin focusout load resize scroll unload click dblclick mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave change select submit keydown keypress keyup error contextmenu".split(" "),function(e,t){x.fn[t]=function(e,n){return arguments.length>0?this.on(t,null,e,n):this.trigger(t)}}),x.fn.extend({hover:function(e,t){return this.mouseenter(e).mouseleave(t||e)},bind:function(e,t,n){return this.on(e,null,t,n)},unbind:function(e,t){return this.off(e,null,t)},delegate:function(e,t,n,r){return this.on(t,e,n,r)},undelegate:function(e,t,n){return 1===arguments.length?this.off(e,"**"):this.off(t,e||"**",n)}});var _t,Xt,Ut=x.now(),Yt=/\?/,Vt=/#.*$/,Gt=/([?&])_=[^&]*/,Jt=/^(.*?):[ \t]*([^\r\n]*)$/gm,Qt=/^(?:about|app|app-storage|.+-extension|file|res|widget):$/,Kt=/^(?:GET|HEAD)$/,Zt=/^\/\//,en=/^([\w.+-]+:)(?:\/\/([^\/?#:]*)(?::(\d+)|)|)/,tn=x.fn.load,nn={},rn={},on="*/".concat("*");try{Xt=i.href}catch(sn){Xt=o.createElement("a"),Xt.href="",Xt=Xt.href}_t=en.exec(Xt.toLowerCase())||[];function an(e){return function(t,n){"string"!=typeof t&&(n=t,t="*");var r,i=0,o=t.toLowerCase().match(w)||[];
+if(x.isFunction(n))while(r=o[i++])"+"===r[0]?(r=r.slice(1)||"*",(e[r]=e[r]||[]).unshift(n)):(e[r]=e[r]||[]).push(n)}}function un(e,t,n,r){var i={},o=e===rn;function s(a){var u;return i[a]=!0,x.each(e[a]||[],function(e,a){var l=a(t,n,r);return"string"!=typeof l||o||i[l]?o?!(u=l):undefined:(t.dataTypes.unshift(l),s(l),!1)}),u}return s(t.dataTypes[0])||!i["*"]&&s("*")}function ln(e,t){var n,r,i=x.ajaxSettings.flatOptions||{};for(n in t)t[n]!==undefined&&((i[n]?e:r||(r={}))[n]=t[n]);return r&&x.extend(!0,e,r),e}x.fn.load=function(e,t,n){if("string"!=typeof e&&tn)return tn.apply(this,arguments);var r,i,o,s=this,a=e.indexOf(" ");return a>=0&&(r=e.slice(a),e=e.slice(0,a)),x.isFunction(t)?(n=t,t=undefined):t&&"object"==typeof t&&(i="POST"),s.length>0&&x.ajax({url:e,type:i,dataType:"html",data:t}).done(function(e){o=arguments,s.html(r?x("<div>").append(x.parseHTML(e)).find(r):e)}).complete(n&&function(e,t){s.each(n,o||[e.responseText,t,e])}),this},x.each(["ajaxStart","ajaxStop","ajaxComplete","ajaxError","ajaxSuccess","ajaxSend"],function(e,t){x.fn[t]=function(e){return this.on(t,e)}}),x.extend({active:0,lastModified:{},etag:{},ajaxSettings:{url:Xt,type:"GET",isLocal:Qt.test(_t[1]),global:!0,processData:!0,async:!0,contentType:"application/x-www-form-urlencoded; charset=UTF-8",accepts:{"*":on,text:"text/plain",html:"text/html",xml:"application/xml, text/xml",json:"application/json, text/javascript"},contents:{xml:/xml/,html:/html/,json:/json/},responseFields:{xml:"responseXML",text:"responseText",json:"responseJSON"},converters:{"* text":String,"text html":!0,"text json":x.parseJSON,"text xml":x.parseXML},flatOptions:{url:!0,context:!0}},ajaxSetup:function(e,t){return t?ln(ln(e,x.ajaxSettings),t):ln(x.ajaxSettings,e)},ajaxPrefilter:an(nn),ajaxTransport:an(rn),ajax:function(e,t){"object"==typeof e&&(t=e,e=undefined),t=t||{};var n,r,i,o,s,a,u,l,c=x.ajaxSetup({},t),f=c.context||c,p=c.context&&(f.nodeType||f.jquery)?x(f):x.event,h=x.Deferred(),d=x.Callbacks("once memory"),g=c.statusCode||{},m={},y={},v=0,b="canceled",T={readyState:0,getResponseHeader:function(e){var t;if(2===v){if(!o){o={};while(t=Jt.exec(i))o[t[1].toLowerCase()]=t[2]}t=o[e.toLowerCase()]}return null==t?null:t},getAllResponseHeaders:function(){return 2===v?i:null},setRequestHeader:function(e,t){var n=e.toLowerCase();return v||(e=y[n]=y[n]||e,m[e]=t),this},overrideMimeType:function(e){return v||(c.mimeType=e),this},statusCode:function(e){var t;if(e)if(2>v)for(t in e)g[t]=[g[t],e[t]];else T.always(e[T.status]);return this},abort:function(e){var t=e||b;return n&&n.abort(t),k(0,t),this}};if(h.promise(T).complete=d.add,T.success=T.done,T.error=T.fail,c.url=((e||c.url||Xt)+"").replace(Vt,"").replace(Zt,_t[1]+"//"),c.type=t.method||t.type||c.method||c.type,c.dataTypes=x.trim(c.dataType||"*").toLowerCase().match(w)||[""],null==c.crossDomain&&(a=en.exec(c.url.toLowerCase()),c.crossDomain=!(!a||a[1]===_t[1]&&a[2]===_t[2]&&(a[3]||("http:"===a[1]?"80":"443"))===(_t[3]||("http:"===_t[1]?"80":"443")))),c.data&&c.processData&&"string"!=typeof c.data&&(c.data=x.param(c.data,c.traditional)),un(nn,c,t,T),2===v)return T;u=c.global,u&&0===x.active++&&x.event.trigger("ajaxStart"),c.type=c.type.toUpperCase(),c.hasContent=!Kt.test(c.type),r=c.url,c.hasContent||(c.data&&(r=c.url+=(Yt.test(r)?"&":"?")+c.data,delete c.data),c.cache===!1&&(c.url=Gt.test(r)?r.replace(Gt,"$1_="+Ut++):r+(Yt.test(r)?"&":"?")+"_="+Ut++)),c.ifModified&&(x.lastModified[r]&&T.setRequestHeader("If-Modified-Since",x.lastModified[r]),x.etag[r]&&T.setRequestHeader("If-None-Match",x.etag[r])),(c.data&&c.hasContent&&c.contentType!==!1||t.contentType)&&T.setRequestHeader("Content-Type",c.contentType),T.setRequestHeader("Accept",c.dataTypes[0]&&c.accepts[c.dataTypes[0]]?c.accepts[c.dataTypes[0]]+("*"!==c.dataTypes[0]?", "+on+"; q=0.01":""):c.accepts["*"]);for(l in c.headers)T.setRequestHeader(l,c.headers[l]);if(c.beforeSend&&(c.beforeSend.call(f,T,c)===!1||2===v))return T.abort();b="abort";for(l in{success:1,error:1,complete:1})T[l](c[l]);if(n=un(rn,c,t,T)){T.readyState=1,u&&p.trigger("ajaxSend",[T,c]),c.async&&c.timeout>0&&(s=setTimeout(function(){T.abort("timeout")},c.timeout));try{v=1,n.send(m,k)}catch(C){if(!(2>v))throw C;k(-1,C)}}else k(-1,"No Transport");function k(e,t,o,a){var l,m,y,b,w,C=t;2!==v&&(v=2,s&&clearTimeout(s),n=undefined,i=a||"",T.readyState=e>0?4:0,l=e>=200&&300>e||304===e,o&&(b=cn(c,T,o)),b=fn(c,b,T,l),l?(c.ifModified&&(w=T.getResponseHeader("Last-Modified"),w&&(x.lastModified[r]=w),w=T.getResponseHeader("etag"),w&&(x.etag[r]=w)),204===e?C="nocontent":304===e?C="notmodified":(C=b.state,m=b.data,y=b.error,l=!y)):(y=C,(e||!C)&&(C="error",0>e&&(e=0))),T.status=e,T.statusText=(t||C)+"",l?h.resolveWith(f,[m,C,T]):h.rejectWith(f,[T,C,y]),T.statusCode(g),g=undefined,u&&p.trigger(l?"ajaxSuccess":"ajaxError",[T,c,l?m:y]),d.fireWith(f,[T,C]),u&&(p.trigger("ajaxComplete",[T,c]),--x.active||x.event.trigger("ajaxStop")))}return T},getJSON:function(e,t,n){return x.get(e,t,n,"json")},getScript:function(e,t){return x.get(e,undefined,t,"script")}}),x.each(["get","post"],function(e,t){x[t]=function(e,n,r,i){return x.isFunction(n)&&(i=i||r,r=n,n=undefined),x.ajax({url:e,type:t,dataType:i,data:n,success:r})}});function cn(e,t,n){var r,i,o,s,a=e.contents,u=e.dataTypes;while("*"===u[0])u.shift(),r===undefined&&(r=e.mimeType||t.getResponseHeader("Content-Type"));if(r)for(i in a)if(a[i]&&a[i].test(r)){u.unshift(i);break}if(u[0]in n)o=u[0];else{for(i in n){if(!u[0]||e.converters[i+" "+u[0]]){o=i;break}s||(s=i)}o=o||s}return o?(o!==u[0]&&u.unshift(o),n[o]):undefined}function fn(e,t,n,r){var i,o,s,a,u,l={},c=e.dataTypes.slice();if(c[1])for(s in e.converters)l[s.toLowerCase()]=e.converters[s];o=c.shift();while(o)if(e.responseFields[o]&&(n[e.responseFields[o]]=t),!u&&r&&e.dataFilter&&(t=e.dataFilter(t,e.dataType)),u=o,o=c.shift())if("*"===o)o=u;else if("*"!==u&&u!==o){if(s=l[u+" "+o]||l["* "+o],!s)for(i in l)if(a=i.split(" "),a[1]===o&&(s=l[u+" "+a[0]]||l["* "+a[0]])){s===!0?s=l[i]:l[i]!==!0&&(o=a[0],c.unshift(a[1]));break}if(s!==!0)if(s&&e["throws"])t=s(t);else try{t=s(t)}catch(f){return{state:"parsererror",error:s?f:"No conversion from "+u+" to "+o}}}return{state:"success",data:t}}x.ajaxSetup({accepts:{script:"text/javascript, application/javascript, application/ecmascript, application/x-ecmascript"},contents:{script:/(?:java|ecma)script/},converters:{"text script":function(e){return x.globalEval(e),e}}}),x.ajaxPrefilter("script",function(e){e.cache===undefined&&(e.cache=!1),e.crossDomain&&(e.type="GET")}),x.ajaxTransport("script",function(e){if(e.crossDomain){var t,n;return{send:function(r,i){t=x("<script>").prop({async:!0,charset:e.scriptCharset,src:e.url}).on("load error",n=function(e){t.remove(),n=null,e&&i("error"===e.type?404:200,e.type)}),o.head.appendChild(t[0])},abort:function(){n&&n()}}}});var pn=[],hn=/(=)\?(?=&|$)|\?\?/;x.ajaxSetup({jsonp:"callback",jsonpCallback:function(){var e=pn.pop()||x.expando+"_"+Ut++;return this[e]=!0,e}}),x.ajaxPrefilter("json jsonp",function(t,n,r){var i,o,s,a=t.jsonp!==!1&&(hn.test(t.url)?"url":"string"==typeof t.data&&!(t.contentType||"").indexOf("application/x-www-form-urlencoded")&&hn.test(t.data)&&"data");return a||"jsonp"===t.dataTypes[0]?(i=t.jsonpCallback=x.isFunction(t.jsonpCallback)?t.jsonpCallback():t.jsonpCallback,a?t[a]=t[a].replace(hn,"$1"+i):t.jsonp!==!1&&(t.url+=(Yt.test(t.url)?"&":"?")+t.jsonp+"="+i),t.converters["script json"]=function(){return s||x.error(i+" was not called"),s[0]},t.dataTypes[0]="json",o=e[i],e[i]=function(){s=arguments},r.always(function(){e[i]=o,t[i]&&(t.jsonpCallback=n.jsonpCallback,pn.push(i)),s&&x.isFunction(o)&&o(s[0]),s=o=undefined}),"script"):undefined}),x.ajaxSettings.xhr=function(){try{return new XMLHttpRequest}catch(e){}};var dn=x.ajaxSettings.xhr(),gn={0:200,1223:204},mn=0,yn={};e.ActiveXObject&&x(e).on("unload",function(){for(var e in yn)yn[e]();yn=undefined}),x.support.cors=!!dn&&"withCredentials"in dn,x.support.ajax=dn=!!dn,x.ajaxTransport(function(e){var t;return x.support.cors||dn&&!e.crossDomain?{send:function(n,r){var i,o,s=e.xhr();if(s.open(e.type,e.url,e.async,e.username,e.password),e.xhrFields)for(i in e.xhrFields)s[i]=e.xhrFields[i];e.mimeType&&s.overrideMimeType&&s.overrideMimeType(e.mimeType),e.crossDomain||n["X-Requested-With"]||(n["X-Requested-With"]="XMLHttpRequest");for(i in n)s.setRequestHeader(i,n[i]);t=function(e){return function(){t&&(delete yn[o],t=s.onload=s.onerror=null,"abort"===e?s.abort():"error"===e?r(s.status||404,s.statusText):r(gn[s.status]||s.status,s.statusText,"string"==typeof s.responseText?{text:s.responseText}:undefined,s.getAllResponseHeaders()))}},s.onload=t(),s.onerror=t("error"),t=yn[o=mn++]=t("abort"),s.send(e.hasContent&&e.data||null)},abort:function(){t&&t()}}:undefined});var vn,xn,bn=/^(?:toggle|show|hide)$/,wn=RegExp("^(?:([+-])=|)("+b+")([a-z%]*)$","i"),Tn=/queueHooks$/,Cn=[Dn],kn={"*":[function(e,t){var n,r,i=this.createTween(e,t),o=wn.exec(t),s=i.cur(),a=+s||0,u=1,l=20;if(o){if(n=+o[2],r=o[3]||(x.cssNumber[e]?"":"px"),"px"!==r&&a){a=x.css(i.elem,e,!0)||n||1;do u=u||".5",a/=u,x.style(i.elem,e,a+r);while(u!==(u=i.cur()/s)&&1!==u&&--l)}i.unit=r,i.start=a,i.end=o[1]?a+(o[1]+1)*n:n}return i}]};function Nn(){return setTimeout(function(){vn=undefined}),vn=x.now()}function En(e,t){x.each(t,function(t,n){var r=(kn[t]||[]).concat(kn["*"]),i=0,o=r.length;for(;o>i;i++)if(r[i].call(e,t,n))return})}function Sn(e,t,n){var r,i,o=0,s=Cn.length,a=x.Deferred().always(function(){delete u.elem}),u=function(){if(i)return!1;var t=vn||Nn(),n=Math.max(0,l.startTime+l.duration-t),r=n/l.duration||0,o=1-r,s=0,u=l.tweens.length;for(;u>s;s++)l.tweens[s].run(o);return a.notifyWith(e,[l,o,n]),1>o&&u?n:(a.resolveWith(e,[l]),!1)},l=a.promise({elem:e,props:x.extend({},t),opts:x.extend(!0,{specialEasing:{}},n),originalProperties:t,originalOptions:n,startTime:vn||Nn(),duration:n.duration,tweens:[],createTween:function(t,n){var r=x.Tween(e,l.opts,t,n,l.opts.specialEasing[t]||l.opts.easing);return l.tweens.push(r),r},stop:function(t){var n=0,r=t?l.tweens.length:0;if(i)return this;for(i=!0;r>n;n++)l.tweens[n].run(1);return t?a.resolveWith(e,[l,t]):a.rejectWith(e,[l,t]),this}}),c=l.props;for(jn(c,l.opts.specialEasing);s>o;o++)if(r=Cn[o].call(l,e,c,l.opts))return r;return En(l,c),x.isFunction(l.opts.start)&&l.opts.start.call(e,l),x.fx.timer(x.extend(u,{elem:e,anim:l,queue:l.opts.queue})),l.progress(l.opts.progress).done(l.opts.done,l.opts.complete).fail(l.opts.fail).always(l.opts.always)}function jn(e,t){var n,r,i,o,s;for(n in e)if(r=x.camelCase(n),i=t[r],o=e[n],x.isArray(o)&&(i=o[1],o=e[n]=o[0]),n!==r&&(e[r]=o,delete e[n]),s=x.cssHooks[r],s&&"expand"in s){o=s.expand(o),delete e[r];for(n in o)n in e||(e[n]=o[n],t[n]=i)}else t[r]=i}x.Animation=x.extend(Sn,{tweener:function(e,t){x.isFunction(e)?(t=e,e=["*"]):e=e.split(" ");var n,r=0,i=e.length;for(;i>r;r++)n=e[r],kn[n]=kn[n]||[],kn[n].unshift(t)},prefilter:function(e,t){t?Cn.unshift(e):Cn.push(e)}});function Dn(e,t,n){var r,i,o,s,a,u,l,c,f,p=this,h=e.style,d={},g=[],m=e.nodeType&&At(e);n.queue||(c=x._queueHooks(e,"fx"),null==c.unqueued&&(c.unqueued=0,f=c.empty.fire,c.empty.fire=function(){c.unqueued||f()}),c.unqueued++,p.always(function(){p.always(function(){c.unqueued--,x.queue(e,"fx").length||c.empty.fire()})})),1===e.nodeType&&("height"in t||"width"in t)&&(n.overflow=[h.overflow,h.overflowX,h.overflowY],"inline"===x.css(e,"display")&&"none"===x.css(e,"float")&&(h.display="inline-block")),n.overflow&&(h.overflow="hidden",p.always(function(){h.overflow=n.overflow[0],h.overflowX=n.overflow[1],h.overflowY=n.overflow[2]})),a=q.get(e,"fxshow");for(r in t)if(o=t[r],bn.exec(o)){if(delete t[r],u=u||"toggle"===o,o===(m?"hide":"show")){if("show"!==o||a===undefined||a[r]===undefined)continue;m=!0}g.push(r)}if(s=g.length){a=q.get(e,"fxshow")||q.access(e,"fxshow",{}),"hidden"in a&&(m=a.hidden),u&&(a.hidden=!m),m?x(e).show():p.done(function(){x(e).hide()}),p.done(function(){var t;q.remove(e,"fxshow");for(t in d)x.style(e,t,d[t])});for(r=0;s>r;r++)i=g[r],l=p.createTween(i,m?a[i]:0),d[i]=a[i]||x.style(e,i),i in a||(a[i]=l.start,m&&(l.end=l.start,l.start="width"===i||"height"===i?1:0))}}function An(e,t,n,r,i){return new An.prototype.init(e,t,n,r,i)}x.Tween=An,An.prototype={constructor:An,init:function(e,t,n,r,i,o){this.elem=e,this.prop=n,this.easing=i||"swing",this.options=t,this.start=this.now=this.cur(),this.end=r,this.unit=o||(x.cssNumber[n]?"":"px")},cur:function(){var e=An.propHooks[this.prop];return e&&e.get?e.get(this):An.propHooks._default.get(this)},run:function(e){var t,n=An.propHooks[this.prop];return this.pos=t=this.options.duration?x.easing[this.easing](e,this.options.duration*e,0,1,this.options.duration):e,this.now=(this.end-this.start)*t+this.start,this.options.step&&this.options.step.call(this.elem,this.now,this),n&&n.set?n.set(this):An.propHooks._default.set(this),this}},An.prototype.init.prototype=An.prototype,An.propHooks={_default:{get:function(e){var t;return null==e.elem[e.prop]||e.elem.style&&null!=e.elem.style[e.prop]?(t=x.css(e.elem,e.prop,""),t&&"auto"!==t?t:0):e.elem[e.prop]},set:function(e){x.fx.step[e.prop]?x.fx.step[e.prop](e):e.elem.style&&(null!=e.elem.style[x.cssProps[e.prop]]||x.cssHooks[e.prop])?x.style(e.elem,e.prop,e.now+e.unit):e.elem[e.prop]=e.now}}},An.propHooks.scrollTop=An.propHooks.scrollLeft={set:function(e){e.elem.nodeType&&e.elem.parentNode&&(e.elem[e.prop]=e.now)}},x.each(["toggle","show","hide"],function(e,t){var n=x.fn[t];x.fn[t]=function(e,r,i){return null==e||"boolean"==typeof e?n.apply(this,arguments):this.animate(Ln(t,!0),e,r,i)}}),x.fn.extend({fadeTo:function(e,t,n,r){return this.filter(At).css("opacity",0).show().end().animate({opacity:t},e,n,r)},animate:function(e,t,n,r){var i=x.isEmptyObject(e),o=x.speed(t,n,r),s=function(){var t=Sn(this,x.extend({},e),o);s.finish=function(){t.stop(!0)},(i||q.get(this,"finish"))&&t.stop(!0)};return s.finish=s,i||o.queue===!1?this.each(s):this.queue(o.queue,s)},stop:function(e,t,n){var r=function(e){var t=e.stop;delete e.stop,t(n)};return"string"!=typeof e&&(n=t,t=e,e=undefined),t&&e!==!1&&this.queue(e||"fx",[]),this.each(function(){var t=!0,i=null!=e&&e+"queueHooks",o=x.timers,s=q.get(this);if(i)s[i]&&s[i].stop&&r(s[i]);else for(i in s)s[i]&&s[i].stop&&Tn.test(i)&&r(s[i]);for(i=o.length;i--;)o[i].elem!==this||null!=e&&o[i].queue!==e||(o[i].anim.stop(n),t=!1,o.splice(i,1));(t||!n)&&x.dequeue(this,e)})},finish:function(e){return e!==!1&&(e=e||"fx"),this.each(function(){var t,n=q.get(this),r=n[e+"queue"],i=n[e+"queueHooks"],o=x.timers,s=r?r.length:0;for(n.finish=!0,x.queue(this,e,[]),i&&i.cur&&i.cur.finish&&i.cur.finish.call(this),t=o.length;t--;)o[t].elem===this&&o[t].queue===e&&(o[t].anim.stop(!0),o.splice(t,1));for(t=0;s>t;t++)r[t]&&r[t].finish&&r[t].finish.call(this);delete n.finish})}});function Ln(e,t){var n,r={height:e},i=0;for(t=t?1:0;4>i;i+=2-t)n=St[i],r["margin"+n]=r["padding"+n]=e;return t&&(r.opacity=r.width=e),r}x.each({slideDown:Ln("show"),slideUp:Ln("hide"),slideToggle:Ln("toggle"),fadeIn:{opacity:"show"},fadeOut:{opacity:"hide"},fadeToggle:{opacity:"toggle"}},function(e,t){x.fn[e]=function(e,n,r){return this.animate(t,e,n,r)}}),x.speed=function(e,t,n){var r=e&&"object"==typeof e?x.extend({},e):{complete:n||!n&&t||x.isFunction(e)&&e,duration:e,easing:n&&t||t&&!x.isFunction(t)&&t};return r.duration=x.fx.off?0:"number"==typeof r.duration?r.duration:r.duration in x.fx.speeds?x.fx.speeds[r.duration]:x.fx.speeds._default,(null==r.queue||r.queue===!0)&&(r.queue="fx"),r.old=r.complete,r.complete=function(){x.isFunction(r.old)&&r.old.call(this),r.queue&&x.dequeue(this,r.queue)},r},x.easing={linear:function(e){return e},swing:function(e){return.5-Math.cos(e*Math.PI)/2}},x.timers=[],x.fx=An.prototype.init,x.fx.tick=function(){var e,t=x.timers,n=0;for(vn=x.now();t.length>n;n++)e=t[n],e()||t[n]!==e||t.splice(n--,1);t.length||x.fx.stop(),vn=undefined},x.fx.timer=function(e){e()&&x.timers.push(e)&&x.fx.start()},x.fx.interval=13,x.fx.start=function(){xn||(xn=setInterval(x.fx.tick,x.fx.interval))},x.fx.stop=function(){clearInterval(xn),xn=null},x.fx.speeds={slow:600,fast:200,_default:400},x.fx.step={},x.expr&&x.expr.filters&&(x.expr.filters.animated=function(e){return x.grep(x.timers,function(t){return e===t.elem}).length}),x.fn.offset=function(e){if(arguments.length)return e===undefined?this:this.each(function(t){x.offset.setOffset(this,e,t)});var t,n,i=this[0],o={top:0,left:0},s=i&&i.ownerDocument;if(s)return t=s.documentElement,x.contains(t,i)?(typeof i.getBoundingClientRect!==r&&(o=i.getBoundingClientRect()),n=qn(s),{top:o.top+n.pageYOffset-t.clientTop,left:o.left+n.pageXOffset-t.clientLeft}):o},x.offset={setOffset:function(e,t,n){var r,i,o,s,a,u,l,c=x.css(e,"position"),f=x(e),p={};"static"===c&&(e.style.position="relative"),a=f.offset(),o=x.css(e,"top"),u=x.css(e,"left"),l=("absolute"===c||"fixed"===c)&&(o+u).indexOf("auto")>-1,l?(r=f.position(),s=r.top,i=r.left):(s=parseFloat(o)||0,i=parseFloat(u)||0),x.isFunction(t)&&(t=t.call(e,n,a)),null!=t.top&&(p.top=t.top-a.top+s),null!=t.left&&(p.left=t.left-a.left+i),"using"in t?t.using.call(e,p):f.css(p)}},x.fn.extend({position:function(){if(this[0]){var e,t,n=this[0],r={top:0,left:0};return"fixed"===x.css(n,"position")?t=n.getBoundingClientRect():(e=this.offsetParent(),t=this.offset(),x.nodeName(e[0],"html")||(r=e.offset()),r.top+=x.css(e[0],"borderTopWidth",!0),r.left+=x.css(e[0],"borderLeftWidth",!0)),{top:t.top-r.top-x.css(n,"marginTop",!0),left:t.left-r.left-x.css(n,"marginLeft",!0)}}},offsetParent:function(){return this.map(function(){var e=this.offsetParent||s;while(e&&!x.nodeName(e,"html")&&"static"===x.css(e,"position"))e=e.offsetParent;return e||s})}}),x.each({scrollLeft:"pageXOffset",scrollTop:"pageYOffset"},function(t,n){var r="pageYOffset"===n;x.fn[t]=function(i){return x.access(this,function(t,i,o){var s=qn(t);return o===undefined?s?s[n]:t[i]:(s?s.scrollTo(r?e.pageXOffset:o,r?o:e.pageYOffset):t[i]=o,undefined)},t,i,arguments.length,null)}});function qn(e){return x.isWindow(e)?e:9===e.nodeType&&e.defaultView}x.each({Height:"height",Width:"width"},function(e,t){x.each({padding:"inner"+e,content:t,"":"outer"+e},function(n,r){x.fn[r]=function(r,i){var o=arguments.length&&(n||"boolean"!=typeof r),s=n||(r===!0||i===!0?"margin":"border");return x.access(this,function(t,n,r){var i;return x.isWindow(t)?t.document.documentElement["client"+e]:9===t.nodeType?(i=t.documentElement,Math.max(t.body["scroll"+e],i["scroll"+e],t.body["offset"+e],i["offset"+e],i["client"+e])):r===undefined?x.css(t,n,s):x.style(t,n,r,s)},t,o?r:undefined,o,null)}})}),x.fn.size=function(){return this.length},x.fn.andSelf=x.fn.addBack,"object"==typeof module&&"object"==typeof module.exports?module.exports=x:"function"==typeof define&&define.amd&&define("jquery",[],function(){return x}),"object"==typeof e&&"object"==typeof e.document&&(e.jQuery=e.$=x)})(window);
\ No newline at end of file
diff --git a/Godeps/_workspace/src/github.com/PuerkitoBio/ghost/ghostest/public/logo.png b/Godeps/_workspace/src/github.com/PuerkitoBio/ghost/ghostest/public/logo.png
new file mode 100644
index 0000000000000000000000000000000000000000..0999e972edd33d6f1a158b749c12db52ca9bc21b
Binary files /dev/null and b/Godeps/_workspace/src/github.com/PuerkitoBio/ghost/ghostest/public/logo.png differ
diff --git a/Godeps/_workspace/src/github.com/PuerkitoBio/ghost/ghostest/public/styles.css b/Godeps/_workspace/src/github.com/PuerkitoBio/ghost/ghostest/public/styles.css
new file mode 100644
index 0000000000000000000000000000000000000000..417330f5419edcd45e2b8caebd9441072d13b075
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/PuerkitoBio/ghost/ghostest/public/styles.css
@@ -0,0 +1,3 @@
+body {
+ background-color: silver;
+}
diff --git a/Godeps/_workspace/src/github.com/PuerkitoBio/ghost/ghostest/templates/amber/context.amber b/Godeps/_workspace/src/github.com/PuerkitoBio/ghost/ghostest/templates/amber/context.amber
new file mode 100644
index 0000000000000000000000000000000000000000..d560ec69dae0a121d4ff214183a2ebd011b8c7a1
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/PuerkitoBio/ghost/ghostest/templates/amber/context.amber
@@ -0,0 +1,8 @@
+!!! 5
+html
+ head
+ title Chained Context
+ link[type="text/css"][rel="stylesheet"][href="/public/bootstrap-combined.min.css"]
+ body
+ h1 Chained Context
+ h2 Value found: #{Val}
diff --git a/Godeps/_workspace/src/github.com/PuerkitoBio/ghost/ghostest/templates/session.tmpl b/Godeps/_workspace/src/github.com/PuerkitoBio/ghost/ghostest/templates/session.tmpl
new file mode 100644
index 0000000000000000000000000000000000000000..240cae5e4cc05b8a4ac5dc29c3195b0628a69366
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/PuerkitoBio/ghost/ghostest/templates/session.tmpl
@@ -0,0 +1,28 @@
+<html>
+ <head>
+ <title>{{ .Title }}</title>
+ <link type="text/css" rel="stylesheet" href="/public/styles.css">
+ <link type="text/css" rel="stylesheet" href="/public/bootstrap-combined.min.css">
+ </head>
+ <body>
+ <h1>Session: {{ .SessionID }}</h1>
+ <ol>
+ <li><a href="/">Home</a></li>
+ <li><a href="/session">Session</a></li>
+ <li><a href="/session/auth">Authenticated Session</a></li>
+ <li><a href="/context">Chained Context</a></li>
+ <li><a href="/panic">Panic</a></li>
+ <li><a href="/public/styles.css">Styles.css</a></li>
+ <li><a href="/public/jquery-2.0.0.min.js">JQuery</a></li>
+ <li><a href="/public/logo.png">Logo</a></li>
+ </ol>
+ <h2>Current Value: {{ .Text }}</h2>
+ <form method="POST">
+ <input type="text" name="txt" placeholder="some value to save to session"></input>
+ <button type="submit">Submit</button>
+ </form>
+
+ <script src="/public/jquery-2.0.0.min.js"></script>
+ </body>
+</html>
+
diff --git a/Godeps/_workspace/src/github.com/PuerkitoBio/ghost/handlers/basicauth.go b/Godeps/_workspace/src/github.com/PuerkitoBio/ghost/handlers/basicauth.go
new file mode 100644
index 0000000000000000000000000000000000000000..d77f13981e9d5f14a6296498027bf4839e042302
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/PuerkitoBio/ghost/handlers/basicauth.go
@@ -0,0 +1,123 @@
+package handlers
+
+// Inspired by node.js' Connect library implementation of the basicAuth middleware.
+// https://github.com/senchalabs/connect
+
+import (
+ "bytes"
+ "encoding/base64"
+ "fmt"
+ "net/http"
+ "strings"
+)
+
+// Internal writer that keeps track of the currently authenticated user.
+type userResponseWriter struct {
+ http.ResponseWriter
+ user interface{}
+ userName string
+}
+
+// Implement the WrapWriter interface.
+func (this *userResponseWriter) WrappedWriter() http.ResponseWriter {
+ return this.ResponseWriter
+}
+
+// Writes an unauthorized response to the client, specifying the expected authentication
+// information.
+func Unauthorized(w http.ResponseWriter, realm string) {
+ w.Header().Set("Www-Authenticate", fmt.Sprintf(`Basic realm="%s"`, realm))
+ w.WriteHeader(http.StatusUnauthorized)
+ w.Write([]byte("Unauthorized"))
+}
+
+// Writes a bad request response to the client, with an optional message.
+func BadRequest(w http.ResponseWriter, msg string) {
+ w.WriteHeader(http.StatusBadRequest)
+ if msg == "" {
+ msg = "Bad Request"
+ }
+ w.Write([]byte(msg))
+}
+
+// BasicAuthHandlerFunc is the same as BasicAuthHandler, it is just a convenience
+// signature that accepts a func(http.ResponseWriter, *http.Request) instead of
+// a http.Handler interface. It saves the boilerplate http.HandlerFunc() cast.
+func BasicAuthHandlerFunc(h http.HandlerFunc,
+ authFn func(string, string) (interface{}, bool), realm string) http.HandlerFunc {
+ return BasicAuthHandler(h, authFn, realm)
+}
+
+// Returns a Basic Authentication handler, protecting the wrapped handler from
+// being accessed if the authentication function is not successful.
+func BasicAuthHandler(h http.Handler,
+ authFn func(string, string) (interface{}, bool), realm string) http.HandlerFunc {
+
+ if realm == "" {
+ realm = "Authorization Required"
+ }
+ return func(w http.ResponseWriter, r *http.Request) {
+ // Self-awareness
+ if _, ok := GetUser(w); ok {
+ h.ServeHTTP(w, r)
+ return
+ }
+ authInfo := r.Header.Get("Authorization")
+ if authInfo == "" {
+ // No authorization info, return 401
+ Unauthorized(w, realm)
+ return
+ }
+ parts := strings.Split(authInfo, " ")
+ if len(parts) != 2 {
+ BadRequest(w, "Bad authorization header")
+ return
+ }
+ scheme := parts[0]
+ creds, err := base64.StdEncoding.DecodeString(parts[1])
+ if err != nil {
+ BadRequest(w, "Bad credentials encoding")
+ return
+ }
+ index := bytes.Index(creds, []byte(":"))
+ if scheme != "Basic" || index < 0 {
+ BadRequest(w, "Bad authorization header")
+ return
+ }
+ user, pwd := string(creds[:index]), string(creds[index+1:])
+ udata, ok := authFn(user, pwd)
+ if ok {
+ // Save user data and continue
+ uw := &userResponseWriter{w, udata, user}
+ h.ServeHTTP(uw, r)
+ } else {
+ Unauthorized(w, realm)
+ }
+ }
+}
+
+// Return the currently authenticated user. This is the same data that was returned
+// by the authentication function passed to BasicAuthHandler.
+func GetUser(w http.ResponseWriter) (interface{}, bool) {
+ usr, ok := GetResponseWriter(w, func(tst http.ResponseWriter) bool {
+ _, ok := tst.(*userResponseWriter)
+ return ok
+ })
+ if ok {
+ return usr.(*userResponseWriter).user, true
+ }
+ return nil, false
+}
+
+// Return the currently authenticated user name. This is the user name that was
+// authenticated for the current request.
+func GetUserName(w http.ResponseWriter) (string, bool) {
+ usr, ok := GetResponseWriter(w, func(tst http.ResponseWriter) bool {
+ _, ok := tst.(*userResponseWriter)
+ return ok
+ })
+ if ok {
+ return usr.(*userResponseWriter).userName, true
+ }
+ return "", false
+}
diff --git a/Godeps/_workspace/src/github.com/PuerkitoBio/ghost/handlers/basicauth_test.go b/Godeps/_workspace/src/github.com/PuerkitoBio/ghost/handlers/basicauth_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..3181e547745777c1022fb7b9fed0ffafc3864118
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/PuerkitoBio/ghost/handlers/basicauth_test.go
@@ -0,0 +1,62 @@
+package handlers
+
+import (
+ "fmt"
+ "net/http"
+ "net/http/httptest"
+ "testing"
+)
+
+func TestUnauth(t *testing.T) {
+ h := BasicAuthHandler(StaticFileHandler("./testdata/script.js"), func(u, pwd string) (interface{}, bool) {
+ if u == "me" && pwd == "you" {
+ return u, true
+ }
+ return nil, false
+ }, "foo")
+ s := httptest.NewServer(h)
+ defer s.Close()
+
+ res, err := http.Get(s.URL)
+ if err != nil {
+ panic(err)
+ }
+ assertStatus(http.StatusUnauthorized, res.StatusCode, t)
+ assertHeader("Www-Authenticate", `Basic realm="foo"`, res, t)
+}
+
+func TestGzippedAuth(t *testing.T) {
+ h := GZIPHandler(BasicAuthHandler(http.HandlerFunc(
+ func(w http.ResponseWriter, r *http.Request) {
+ usr, ok := GetUser(w)
+ if assertTrue(ok, "expected authenticated user, got false", t) {
+ assertTrue(usr.(string) == "meyou", fmt.Sprintf("expected user data to be 'meyou', got '%s'", usr), t)
+ }
+ usr, ok = GetUserName(w)
+ if assertTrue(ok, "expected authenticated user name, got false", t) {
+ assertTrue(usr == "me", fmt.Sprintf("expected user name to be 'me', got '%s'", usr), t)
+ }
+ w.Header().Set("Content-Type", "text/plain")
+ w.Write([]byte(usr.(string)))
+ }), func(u, pwd string) (interface{}, bool) {
+ if u == "me" && pwd == "you" {
+ return u + pwd, true
+ }
+ return nil, false
+ }, ""), nil)
+
+ s := httptest.NewServer(h)
+ defer s.Close()
+
+ req, err := http.NewRequest("GET", "http://me:you@"+s.URL[7:], nil)
+ if err != nil {
+ panic(err)
+ }
+ req.Header.Set("Accept-Encoding", "gzip")
+ res, err := http.DefaultClient.Do(req)
+ if err != nil {
+ panic(err)
+ }
+ assertStatus(http.StatusOK, res.StatusCode, t)
+ assertGzippedBody([]byte("me"), res, t)
+}
diff --git a/Godeps/_workspace/src/github.com/PuerkitoBio/ghost/handlers/chain.go b/Godeps/_workspace/src/github.com/PuerkitoBio/ghost/handlers/chain.go
new file mode 100644
index 0000000000000000000000000000000000000000..e3ae5dea160ca54aff55118e8dff75fc627dbc2b
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/PuerkitoBio/ghost/handlers/chain.go
@@ -0,0 +1,63 @@
+package handlers
+
+import (
+ "net/http"
+)
+
+// ChainableHandler is a valid Handler interface, and adds the possibility to
+// chain other handlers.
+type ChainableHandler interface {
+ http.Handler
+ Chain(http.Handler) ChainableHandler
+ ChainFunc(http.HandlerFunc) ChainableHandler
+}
+
+// Default implementation of a simple ChainableHandler
+type chainHandler struct {
+ http.Handler
+}
+
+func (this *chainHandler) ChainFunc(h http.HandlerFunc) ChainableHandler {
+ return this.Chain(h)
+}
+
+// Implementation of the ChainableHandler interface, calls the chained handler
+// after the current one (sequential).
+func (this *chainHandler) Chain(h http.Handler) ChainableHandler {
+ return &chainHandler{
+ http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ // Add the chained handler after the call to this handler
+ this.ServeHTTP(w, r)
+ h.ServeHTTP(w, r)
+ }),
+ }
+}
+
+// Convert a standard http handler to a chainable handler interface.
+func NewChainableHandler(h http.Handler) ChainableHandler {
+ return &chainHandler{
+ h,
+ }
+}
+
+// Helper function to chain multiple handler functions in a single call.
+func ChainHandlerFuncs(h ...http.HandlerFunc) ChainableHandler {
+ return &chainHandler{
+ http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ for _, v := range h {
+ v(w, r)
+ }
+ }),
+ }
+}
+
+// Helper function to chain multiple handlers in a single call.
+func ChainHandlers(h ...http.Handler) ChainableHandler {
+ return &chainHandler{
+ http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ for _, v := range h {
+ v.ServeHTTP(w, r)
+ }
+ }),
+ }
+}
diff --git a/Godeps/_workspace/src/github.com/PuerkitoBio/ghost/handlers/chain_test.go b/Godeps/_workspace/src/github.com/PuerkitoBio/ghost/handlers/chain_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..b788c526b9dfd342442fc7b80bb88ba7cdefc8f5
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/PuerkitoBio/ghost/handlers/chain_test.go
@@ -0,0 +1,73 @@
+package handlers
+
+import (
+ "bytes"
+ "net/http"
+ "testing"
+)
+
+func TestChaining(t *testing.T) {
+ var buf bytes.Buffer
+
+ a := func(w http.ResponseWriter, r *http.Request) {
+ buf.WriteRune('a')
+ }
+ b := func(w http.ResponseWriter, r *http.Request) {
+ buf.WriteRune('b')
+ }
+ c := func(w http.ResponseWriter, r *http.Request) {
+ buf.WriteRune('c')
+ }
+ f := NewChainableHandler(http.HandlerFunc(a)).Chain(http.HandlerFunc(b)).Chain(http.HandlerFunc(c))
+ f.ServeHTTP(nil, nil)
+
+ if buf.String() != "abc" {
+ t.Errorf("expected 'abc', got %s", buf.String())
+ }
+}
+
+func TestChainingWithHelperFunc(t *testing.T) {
+ var buf bytes.Buffer
+
+ a := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ buf.WriteRune('a')
+ })
+ b := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ buf.WriteRune('b')
+ })
+ c := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ buf.WriteRune('c')
+ })
+ d := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ buf.WriteRune('d')
+ })
+ f := ChainHandlers(a, b, c, d)
+ f.ServeHTTP(nil, nil)
+
+ if buf.String() != "abcd" {
+ t.Errorf("expected 'abcd', got %s", buf.String())
+ }
+}
+
+func TestChainingMixed(t *testing.T) {
+ var buf bytes.Buffer
+
+ a := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ buf.WriteRune('a')
+ })
+ b := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ buf.WriteRune('b')
+ })
+ c := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ buf.WriteRune('c')
+ })
+ d := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ buf.WriteRune('d')
+ })
+ f := NewChainableHandler(a).Chain(ChainHandlers(b, c)).Chain(d)
+ f.ServeHTTP(nil, nil)
+
+ if buf.String() != "abcd" {
+ t.Errorf("expected 'abcd', got %s", buf.String())
+ }
+}
diff --git a/Godeps/_workspace/src/github.com/PuerkitoBio/ghost/handlers/context.go b/Godeps/_workspace/src/github.com/PuerkitoBio/ghost/handlers/context.go
new file mode 100644
index 0000000000000000000000000000000000000000..ccac8c30249c22e728a0d826865a4d983eae6b23
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/PuerkitoBio/ghost/handlers/context.go
@@ -0,0 +1,55 @@
+package handlers
+
+import (
+ "net/http"
+)
+
+// Structure that holds the context map and exposes the ResponseWriter interface.
+type contextResponseWriter struct {
+ http.ResponseWriter
+ m map[interface{}]interface{}
+}
+
+// Implement the WrapWriter interface.
+func (this *contextResponseWriter) WrappedWriter() http.ResponseWriter {
+ return this.ResponseWriter
+}
+
+// ContextHandlerFunc is the same as ContextHandler, it is just a convenience
+// signature that accepts a func(http.ResponseWriter, *http.Request) instead of
+// a http.Handler interface. It saves the boilerplate http.HandlerFunc() cast.
+func ContextHandlerFunc(h http.HandlerFunc, cap int) http.HandlerFunc {
+ return ContextHandler(h, cap)
+}
+
+// ContextHandler gives a context storage that lives only for the duration of
+// the request, with no locking involved.
+func ContextHandler(h http.Handler, cap int) http.HandlerFunc {
+ return func(w http.ResponseWriter, r *http.Request) {
+ if _, ok := GetContext(w); ok {
+ // Self-awareness, context handler is already set up
+ h.ServeHTTP(w, r)
+ return
+ }
+
+ // Create the context-providing ResponseWriter replacement.
+ ctxw := &contextResponseWriter{
+ w,
+ make(map[interface{}]interface{}, cap),
+ }
+ // Call the wrapped handler with the context-aware writer
+ h.ServeHTTP(ctxw, r)
+ }
+}
+
+// Helper function to retrieve the context map from the ResponseWriter interface.
+func GetContext(w http.ResponseWriter) (map[interface{}]interface{}, bool) {
+ ctxw, ok := GetResponseWriter(w, func(tst http.ResponseWriter) bool {
+ _, ok := tst.(*contextResponseWriter)
+ return ok
+ })
+ if ok {
+ return ctxw.(*contextResponseWriter).m, true
+ }
+ return nil, false
+}
diff --git a/Godeps/_workspace/src/github.com/PuerkitoBio/ghost/handlers/context_test.go b/Godeps/_workspace/src/github.com/PuerkitoBio/ghost/handlers/context_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..3ef3f4009dea7648d15576ae068a334e15ae7b06
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/PuerkitoBio/ghost/handlers/context_test.go
@@ -0,0 +1,83 @@
+package handlers
+
+import (
+ "fmt"
+ "net/http"
+ "net/http/httptest"
+ "testing"
+)
+
+func TestContext(t *testing.T) {
+ key := "key"
+ val := 10
+ body := "this is the output"
+
+ h2 := wrappedHandler(t, key, val, body)
+ // Create the context handler with a wrapped handler
+ h := ContextHandler(http.HandlerFunc(
+ func(w http.ResponseWriter, r *http.Request) {
+ ctx, _ := GetContext(w)
+ assertTrue(ctx != nil, "expected context to be non-nil", t)
+ assertTrue(len(ctx) == 0, fmt.Sprintf("expected context to be empty, got %d", len(ctx)), t)
+ ctx[key] = val
+ h2.ServeHTTP(w, r)
+ }), 2)
+ s := httptest.NewServer(h)
+ defer s.Close()
+
+ // First call
+ res, err := http.DefaultClient.Get(s.URL)
+ if err != nil {
+ panic(err)
+ }
+ res.Body.Close()
+ // Second call, context should be cleaned at start
+ res, err = http.DefaultClient.Get(s.URL)
+ if err != nil {
+ panic(err)
+ }
+ assertStatus(http.StatusOK, res.StatusCode, t)
+ assertBody([]byte(body), res, t)
+}
+
+func TestWrappedContext(t *testing.T) {
+ key := "key"
+ val := 10
+ body := "this is the output"
+
+ h2 := wrappedHandler(t, key, val, body)
+ h := ContextHandler(LogHandler(http.HandlerFunc(
+ func(w http.ResponseWriter, r *http.Request) {
+ ctx, _ := GetContext(w)
+ if !assertTrue(ctx != nil, "expected context to be non-nil", t) {
+ panic("ctx is nil")
+ }
+ assertTrue(len(ctx) == 0, fmt.Sprintf("expected context to be empty, got %d", len(ctx)), t)
+ ctx[key] = val
+ h2.ServeHTTP(w, r)
+ }), NewLogOptions(nil, "%s", "url")), 2)
+ s := httptest.NewServer(h)
+ defer s.Close()
+
+ res, err := http.DefaultClient.Get(s.URL)
+ if err != nil {
+ panic(err)
+ }
+ assertStatus(http.StatusOK, res.StatusCode, t)
+ assertBody([]byte(body), res, t)
+}
+
+func wrappedHandler(t *testing.T, k, v interface{}, body string) http.Handler {
+ return http.HandlerFunc(
+ func(w http.ResponseWriter, r *http.Request) {
+ ctx, _ := GetContext(w)
+ ac := ctx[k]
+ assertTrue(ac == v, fmt.Sprintf("expected value to be %v, got %v", v, ac), t)
+
+ // Actually write something
+ _, err := w.Write([]byte(body))
+ if err != nil {
+ panic(err)
+ }
+ })
+}
diff --git a/Godeps/_workspace/src/github.com/PuerkitoBio/ghost/handlers/doc.go b/Godeps/_workspace/src/github.com/PuerkitoBio/ghost/handlers/doc.go
new file mode 100644
index 0000000000000000000000000000000000000000..642c2991aaf99480c0e295f6cf951c876002f6fb
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/PuerkitoBio/ghost/handlers/doc.go
@@ -0,0 +1,29 @@
+// Package handlers define reusable handler components that focus on offering
+// a single well-defined feature. Note that any http.Handler implementation
+// can be used with Ghost's chainable or wrappable handlers design.
+//
+// Go's standard library provides a number of such useful handlers in net/http:
+//
+// - FileServer(http.FileSystem)
+// - NotFoundHandler()
+// - RedirectHandler(string, int)
+// - StripPrefix(string, http.Handler)
+// - TimeoutHandler(http.Handler, time.Duration, string)
+//
+// This package adds the following list of handlers:
+//
+// - BasicAuthHandler(http.Handler, func(string, string) (interface{}, bool), string)
+// a Basic Authentication handler.
+// - ContextHandler(http.Handler, int) : a volatile storage map valid only
+// for the duration of the request, with no locking required.
+// - FaviconHandler(http.Handler, string, time.Duration) : an efficient favicon
+// handler.
+// - GZIPHandler(http.Handler) : compress the content of the body if the client
+// accepts gzip compression.
+// - LogHandler(http.Handler, *LogOptions) : customizable request logger.
+// - PanicHandler(http.Handler) : handle panics gracefully so that the client
+// receives a response (status code 500).
+// - SessionHandler(http.Handler, *SessionOptions) : a cookie-based, store-agnostic
+// persistent session handler.
+// - StaticFileHandler(string) : serve the contents of a specific file.
+package handlers
diff --git a/Godeps/_workspace/src/github.com/PuerkitoBio/ghost/handlers/favicon.go b/Godeps/_workspace/src/github.com/PuerkitoBio/ghost/handlers/favicon.go
new file mode 100644
index 0000000000000000000000000000000000000000..0f460fa96d95aba21ed1206d049d5cdc06644d43
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/PuerkitoBio/ghost/handlers/favicon.go
@@ -0,0 +1,71 @@
+package handlers
+
+import (
+ "crypto/md5"
+ "io/ioutil"
+ "net/http"
+ "strconv"
+ "time"
+
+ "github.com/PuerkitoBio/ghost"
+)
+
+// FaviconHandlerFunc is the same as FaviconHandler, it is just a convenience
+// signature that accepts a func(http.ResponseWriter, *http.Request) instead of
+// a http.Handler interface. It saves the boilerplate http.HandlerFunc() cast.
+func FaviconHandlerFunc(h http.HandlerFunc, path string, maxAge time.Duration) http.HandlerFunc {
+ return FaviconHandler(h, path, maxAge)
+}
+
+// Efficient favicon handler, mostly a port of node's Connect library implementation
+// of the favicon middleware.
+// https://github.com/senchalabs/connect
+func FaviconHandler(h http.Handler, path string, maxAge time.Duration) http.HandlerFunc {
+ var buf []byte
+ var hash string
+
+ return func(w http.ResponseWriter, r *http.Request) {
+ var err error
+ if r.URL.Path == "/favicon.ico" {
+ if buf == nil {
+ // Read from file and cache
+ ghost.LogFn("ghost.favicon : serving from %s", path)
+ buf, err = ioutil.ReadFile(path)
+ if err != nil {
+ ghost.LogFn("ghost.favicon : error reading file : %s", err)
+ http.NotFound(w, r)
+ return
+ }
+ hash = hashContent(buf)
+ }
+ writeHeaders(w.Header(), buf, maxAge, hash)
+ writeBody(w, r, buf)
+ } else {
+ h.ServeHTTP(w, r)
+ }
+ }
+}
+
+// Write the content of the favicon, or respond with a 404 not found
+// in case of error (hardly a critical error).
+func writeBody(w http.ResponseWriter, r *http.Request, buf []byte) {
+ _, err := w.Write(buf)
+ if err != nil {
+ ghost.LogFn("ghost.favicon : error writing response : %s", err)
+ http.NotFound(w, r)
+ }
+}
+
+// Correctly set the http headers.
+func writeHeaders(hdr http.Header, buf []byte, maxAge time.Duration, hash string) {
+ hdr.Set("Content-Type", "image/x-icon")
+ hdr.Set("Content-Length", strconv.Itoa(len(buf)))
+ hdr.Set("Etag", hash)
+ hdr.Set("Cache-Control", "public, max-age="+strconv.Itoa(int(maxAge.Seconds())))
+}
+
+// Get the MD5 hash of the content.
+func hashContent(buf []byte) string {
+ h := md5.New()
+ return string(h.Sum(buf))
+}
diff --git a/Godeps/_workspace/src/github.com/PuerkitoBio/ghost/handlers/favicon_test.go b/Godeps/_workspace/src/github.com/PuerkitoBio/ghost/handlers/favicon_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..b9d40679b32185974b975dd316a039a652803f28
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/PuerkitoBio/ghost/handlers/favicon_test.go
@@ -0,0 +1,72 @@
+package handlers
+
+import (
+ "net/http"
+ "net/http/httptest"
+ "os"
+ "testing"
+ "time"
+)
+
+func TestFavicon(t *testing.T) {
+ s := httptest.NewServer(FaviconHandlerFunc(
+ func(w http.ResponseWriter, r *http.Request) {
+ w.Write([]byte("ok"))
+ }, "./testdata/favicon.ico", time.Second))
+ defer s.Close()
+
+ res, err := http.Get(s.URL + "/favicon.ico")
+ if err != nil {
+ panic(err)
+ }
+ defer res.Body.Close()
+ assertStatus(http.StatusOK, res.StatusCode, t)
+ assertHeader("Content-Type", "image/x-icon", res, t)
+ assertHeader("Cache-Control", "public, max-age=1", res, t)
+ assertHeader("Content-Length", "1406", res, t)
+}
+
+func TestFaviconInvalidPath(t *testing.T) {
+ s := httptest.NewServer(FaviconHandlerFunc(
+ func(w http.ResponseWriter, r *http.Request) {
+ w.Write([]byte("ok"))
+ }, "./testdata/xfavicon.ico", time.Second))
+ defer s.Close()
+
+ res, err := http.Get(s.URL + "/favicon.ico")
+ if err != nil {
+ panic(err)
+ }
+ defer res.Body.Close()
+ assertStatus(http.StatusNotFound, res.StatusCode, t)
+}
+
+func TestFaviconFromCache(t *testing.T) {
+ s := httptest.NewServer(FaviconHandlerFunc(
+ func(w http.ResponseWriter, r *http.Request) {
+ w.Write([]byte("ok"))
+ }, "./testdata/favicon.ico", time.Second))
+ defer s.Close()
+
+ res, err := http.Get(s.URL + "/favicon.ico")
+ if err != nil {
+ panic(err)
+ }
+ defer res.Body.Close()
+
+ // Rename the file temporarily
+ err = os.Rename("./testdata/favicon.ico", "./testdata/xfavicon.ico")
+ if err != nil {
+ panic(err)
+ }
+ defer os.Rename("./testdata/xfavicon.ico", "./testdata/favicon.ico")
+ res, err = http.Get(s.URL + "/favicon.ico")
+ if err != nil {
+ panic(err)
+ }
+ defer res.Body.Close()
+ assertStatus(http.StatusOK, res.StatusCode, t)
+ assertHeader("Content-Type", "image/x-icon", res, t)
+ assertHeader("Cache-Control", "public, max-age=1", res, t)
+ assertHeader("Content-Length", "1406", res, t)
+}
diff --git a/Godeps/_workspace/src/github.com/PuerkitoBio/ghost/handlers/ghost.go b/Godeps/_workspace/src/github.com/PuerkitoBio/ghost/handlers/ghost.go
new file mode 100644
index 0000000000000000000000000000000000000000..2707e75f22ba28bcc6d782b1116f72a53c18c6da
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/PuerkitoBio/ghost/handlers/ghost.go
@@ -0,0 +1,75 @@
+package handlers
+
+import (
+ "net/http"
+)
+
+// Interface giving easy access to the most common augmented features.
+type GhostWriter interface {
+ http.ResponseWriter
+ UserName() string
+ User() interface{}
+ Context() map[interface{}]interface{}
+ Session() *Session
+}
+
+// Internal implementation of the GhostWriter interface.
+type ghostWriter struct {
+ http.ResponseWriter
+ userName string
+ user interface{}
+ ctx map[interface{}]interface{}
+ ssn *Session
+}
+
+func (this *ghostWriter) UserName() string {
+ return this.userName
+}
+
+func (this *ghostWriter) User() interface{} {
+ return this.user
+}
+
+func (this *ghostWriter) Context() map[interface{}]interface{} {
+ return this.ctx
+}
+
+func (this *ghostWriter) Session() *Session {
+ return this.ssn
+}
+
+// Convenience handler that wraps a custom function with direct access to the
+// authenticated user, context and session on the writer.
+func GhostHandlerFunc(h func(w GhostWriter, r *http.Request)) http.HandlerFunc {
+ return func(w http.ResponseWriter, r *http.Request) {
+ if gw, ok := getGhostWriter(w); ok {
+ // Self-awareness
+ h(gw, r)
+ return
+ }
+ uid, _ := GetUserName(w)
+ usr, _ := GetUser(w)
+ ctx, _ := GetContext(w)
+ ssn, _ := GetSession(w)
+ gw := &ghostWriter{
+ w,
+ uid,
+ usr,
+ ctx,
+ ssn,
+ }
+ h(gw, r)
+ }
+}
+
+// Check the writer chain to find a ghostWriter.
+func getGhostWriter(w http.ResponseWriter) (*ghostWriter, bool) {
+ gw, ok := GetResponseWriter(w, func(tst http.ResponseWriter) bool {
+ _, ok := tst.(*ghostWriter)
+ return ok
+ })
+ if ok {
+ return gw.(*ghostWriter), true
+ }
+ return nil, false
+}
diff --git a/Godeps/_workspace/src/github.com/PuerkitoBio/ghost/handlers/gzip.go b/Godeps/_workspace/src/github.com/PuerkitoBio/ghost/handlers/gzip.go
new file mode 100644
index 0000000000000000000000000000000000000000..0d772a85935aadbb74db75f3548c82c9350129de
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/PuerkitoBio/ghost/handlers/gzip.go
@@ -0,0 +1,168 @@
+package handlers
+
+import (
+ "compress/gzip"
+ "io"
+ "net/http"
+)
+
+// Thanks to Andrew Gerrand for inspiration:
+// https://groups.google.com/d/msg/golang-nuts/eVnTcMwNVjM/4vYU8id9Q2UJ
+//
+// Also, node's Connect library implementation of the compress middleware:
+// https://github.com/senchalabs/connect/blob/master/lib/middleware/compress.js
+//
+// And StackOverflow's explanation of Vary: Accept-Encoding header:
+// http://stackoverflow.com/questions/7848796/what-does-varyaccept-encoding-mean
+
+// Internal gzipped writer that satisfies both the (body) writer in gzipped format,
+// and maintains the rest of the ResponseWriter interface for header manipulation.
+type gzipResponseWriter struct {
+ io.Writer
+ http.ResponseWriter
+ r *http.Request // Keep a hold of the Request, for the filter function
+ filtered bool // Has the request been run through the filter function?
+ dogzip bool // Should we do GZIP compression for this request?
+ filterFn func(http.ResponseWriter, *http.Request) bool
+}
+
+// Make sure the filter function is applied.
+func (w *gzipResponseWriter) applyFilter() {
+ if !w.filtered {
+ if w.dogzip = w.filterFn(w, w.r); w.dogzip {
+ setGzipHeaders(w.Header())
+ }
+ w.filtered = true
+ }
+}
+
+// Unambiguous Write() implementation (otherwise both ResponseWriter and Writer
+// want to claim this method).
+func (w *gzipResponseWriter) Write(b []byte) (int, error) {
+ w.applyFilter()
+ if w.dogzip {
+ // Write compressed
+ return w.Writer.Write(b)
+ }
+ // Write uncompressed
+ return w.ResponseWriter.Write(b)
+}
+
+// Intercept the WriteHeader call to correctly set the GZIP headers.
+func (w *gzipResponseWriter) WriteHeader(code int) {
+ w.applyFilter()
+ w.ResponseWriter.WriteHeader(code)
+}
+
+// Implement WrapWriter interface
+func (w *gzipResponseWriter) WrappedWriter() http.ResponseWriter {
+ return w.ResponseWriter
+}
+
+var (
+ defaultFilterTypes = [...]string{
+ "text",
+ "javascript",
+ "json",
+ }
+)
+
+// Default filter to check if the response should be GZIPped.
+// By default, all text (html, css, xml, ...), javascript and json
+// content types are candidates for GZIP.
+func defaultFilter(w http.ResponseWriter, r *http.Request) bool {
+ hdr := w.Header()
+ for _, tp := range defaultFilterTypes {
+ ok := HeaderMatch(hdr, "Content-Type", HmContains, tp)
+ if ok {
+ return true
+ }
+ }
+ return false
+}
+
+// GZIPHandlerFunc is the same as GZIPHandler, it is just a convenience
+// signature that accepts a func(http.ResponseWriter, *http.Request) instead of
+// a http.Handler interface. It saves the boilerplate http.HandlerFunc() cast.
+func GZIPHandlerFunc(h http.HandlerFunc, filterFn func(http.ResponseWriter, *http.Request) bool) http.HandlerFunc {
+ return GZIPHandler(h, filterFn)
+}
+
+// Gzip compression HTTP handler. If the client supports it, it compresses the response
+// written by the wrapped handler. The filter function is called when the response is about
+// to be written to determine if compression should be applied. If this argument is nil,
+// the default filter will GZIP only content types containing /json|text|javascript/.
+func GZIPHandler(h http.Handler, filterFn func(http.ResponseWriter, *http.Request) bool) http.HandlerFunc {
+ if filterFn == nil {
+ filterFn = defaultFilter
+ }
+ return func(w http.ResponseWriter, r *http.Request) {
+ if _, ok := getGzipWriter(w); ok {
+ // Self-awareness, gzip handler is already set up
+ h.ServeHTTP(w, r)
+ return
+ }
+ hdr := w.Header()
+ setVaryHeader(hdr)
+
+ // Do nothing on a HEAD request
+ if r.Method == "HEAD" {
+ h.ServeHTTP(w, r)
+ return
+ }
+ if !acceptsGzip(r.Header) {
+ // No gzip support from the client, return uncompressed
+ h.ServeHTTP(w, r)
+ return
+ }
+
+ // Prepare a gzip response container
+ gz := gzip.NewWriter(w)
+ gzw := &gzipResponseWriter{
+ Writer: gz,
+ ResponseWriter: w,
+ r: r,
+ filterFn: filterFn,
+ }
+ h.ServeHTTP(gzw, r)
+ // Iff the handler completed successfully (no panic) and GZIP was indeed used, close the gzip writer,
+ // which seems to generate a Write to the underlying writer.
+ if gzw.dogzip {
+ gz.Close()
+ }
+ }
+}
+
+// Add the vary by "accept-encoding" header if it is not already set.
+func setVaryHeader(hdr http.Header) {
+ if !HeaderMatch(hdr, "Vary", HmContains, "accept-encoding") {
+ hdr.Add("Vary", "Accept-Encoding")
+ }
+}
+
+// Checks if the client accepts GZIP-encoded responses.
+func acceptsGzip(hdr http.Header) bool {
+ ok := HeaderMatch(hdr, "Accept-Encoding", HmContains, "gzip")
+ if !ok {
+ ok = HeaderMatch(hdr, "Accept-Encoding", HmEquals, "*")
+ }
+ return ok
+}
+
+func setGzipHeaders(hdr http.Header) {
+ // The content-type will be explicitly set somewhere down the path of handlers
+ hdr.Set("Content-Encoding", "gzip")
+ hdr.Del("Content-Length")
+}
+
+// Helper function to retrieve the gzip writer.
+func getGzipWriter(w http.ResponseWriter) (*gzipResponseWriter, bool) {
+ gz, ok := GetResponseWriter(w, func(tst http.ResponseWriter) bool {
+ _, ok := tst.(*gzipResponseWriter)
+ return ok
+ })
+ if ok {
+ return gz.(*gzipResponseWriter), true
+ }
+ return nil, false
+}
diff --git a/Godeps/_workspace/src/github.com/PuerkitoBio/ghost/handlers/gzip_test.go b/Godeps/_workspace/src/github.com/PuerkitoBio/ghost/handlers/gzip_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..94cdbd1badd5e38fbc095108a1eef3fcbfc3530e
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/PuerkitoBio/ghost/handlers/gzip_test.go
@@ -0,0 +1,178 @@
+package handlers
+
+import (
+ "net/http"
+ "net/http/httptest"
+ "testing"
+)
+
+func TestGzipped(t *testing.T) {
+ body := "This is the body"
+ headers := []string{"gzip", "*", "gzip, deflate, sdch"}
+
+ h := GZIPHandler(http.HandlerFunc(
+ func(w http.ResponseWriter, r *http.Request) {
+ w.Header().Set("Content-Type", "text/plain")
+ _, err := w.Write([]byte(body))
+ if err != nil {
+ panic(err)
+ }
+ }), nil)
+ s := httptest.NewServer(h)
+ defer s.Close()
+
+ for _, hdr := range headers {
+ t.Logf("running with Accept-Encoding header %s", hdr)
+ req, err := http.NewRequest("GET", s.URL, nil)
+ if err != nil {
+ panic(err)
+ }
+ req.Header.Set("Accept-Encoding", hdr)
+ res, err := http.DefaultClient.Do(req)
+ if err != nil {
+ panic(err)
+ }
+ assertStatus(http.StatusOK, res.StatusCode, t)
+ assertHeader("Content-Encoding", "gzip", res, t)
+ assertGzippedBody([]byte(body), res, t)
+ }
+}
+
+func TestNoGzip(t *testing.T) {
+ body := "This is the body"
+
+ h := GZIPHandler(http.HandlerFunc(
+ func(w http.ResponseWriter, r *http.Request) {
+ w.Header().Set("Content-Type", "text/plain")
+ _, err := w.Write([]byte(body))
+ if err != nil {
+ panic(err)
+ }
+ }), nil)
+ s := httptest.NewServer(h)
+ defer s.Close()
+
+ req, err := http.NewRequest("GET", s.URL, nil)
+ if err != nil {
+ panic(err)
+ }
+ res, err := http.DefaultClient.Do(req)
+ if err != nil {
+ panic(err)
+ }
+ assertStatus(http.StatusOK, res.StatusCode, t)
+ assertHeader("Content-Encoding", "", res, t)
+ assertBody([]byte(body), res, t)
+}
+
+func TestGzipOuterPanic(t *testing.T) {
+ msg := "ko"
+
+ h := PanicHandler(
+ GZIPHandler(http.HandlerFunc(
+ func(w http.ResponseWriter, r *http.Request) {
+ panic(msg)
+ }), nil), nil)
+ s := httptest.NewServer(h)
+ defer s.Close()
+
+ req, err := http.NewRequest("GET", s.URL, nil)
+ if err != nil {
+ panic(err)
+ }
+ res, err := http.DefaultClient.Do(req)
+ if err != nil {
+ panic(err)
+ }
+ assertStatus(http.StatusInternalServerError, res.StatusCode, t)
+ assertHeader("Content-Encoding", "", res, t)
+ assertBody([]byte(msg+"\n"), res, t)
+}
+
+func TestNoGzipOnFilter(t *testing.T) {
+ body := "This is the body"
+
+ h := GZIPHandler(http.HandlerFunc(
+ func(w http.ResponseWriter, r *http.Request) {
+ w.Header().Set("Content-Type", "x/x")
+ _, err := w.Write([]byte(body))
+ if err != nil {
+ panic(err)
+ }
+ }), nil)
+ s := httptest.NewServer(h)
+ defer s.Close()
+
+ req, err := http.NewRequest("GET", s.URL, nil)
+ if err != nil {
+ panic(err)
+ }
+ req.Header.Set("Accept-Encoding", "gzip")
+ res, err := http.DefaultClient.Do(req)
+ if err != nil {
+ panic(err)
+ }
+ assertStatus(http.StatusOK, res.StatusCode, t)
+ assertHeader("Content-Encoding", "", res, t)
+ assertBody([]byte(body), res, t)
+}
+
+func TestNoGzipOnCustomFilter(t *testing.T) {
+ body := "This is the body"
+
+ h := GZIPHandler(http.HandlerFunc(
+ func(w http.ResponseWriter, r *http.Request) {
+ w.Header().Set("Content-Type", "text/plain")
+ _, err := w.Write([]byte(body))
+ if err != nil {
+ panic(err)
+ }
+ }), func(w http.ResponseWriter, r *http.Request) bool {
+ return false
+ })
+ s := httptest.NewServer(h)
+ defer s.Close()
+
+ req, err := http.NewRequest("GET", s.URL, nil)
+ if err != nil {
+ panic(err)
+ }
+ req.Header.Set("Accept-Encoding", "gzip")
+ res, err := http.DefaultClient.Do(req)
+ if err != nil {
+ panic(err)
+ }
+ assertStatus(http.StatusOK, res.StatusCode, t)
+ assertHeader("Content-Encoding", "", res, t)
+ assertBody([]byte(body), res, t)
+}
+
+func TestGzipOnCustomFilter(t *testing.T) {
+ body := "This is the body"
+
+ h := GZIPHandler(http.HandlerFunc(
+ func(w http.ResponseWriter, r *http.Request) {
+ w.Header().Set("Content-Type", "x/x")
+ _, err := w.Write([]byte(body))
+ if err != nil {
+ panic(err)
+ }
+ }), func(w http.ResponseWriter, r *http.Request) bool {
+ return true
+ })
+ s := httptest.NewServer(h)
+ defer s.Close()
+
+ req, err := http.NewRequest("GET", s.URL, nil)
+ if err != nil {
+ panic(err)
+ }
+ req.Header.Set("Accept-Encoding", "gzip")
+ res, err := http.DefaultClient.Do(req)
+ if err != nil {
+ panic(err)
+ }
+ assertStatus(http.StatusOK, res.StatusCode, t)
+ assertHeader("Content-Encoding", "gzip", res, t)
+ assertGzippedBody([]byte(body), res, t)
+}
diff --git a/Godeps/_workspace/src/github.com/PuerkitoBio/ghost/handlers/header.go b/Godeps/_workspace/src/github.com/PuerkitoBio/ghost/handlers/header.go
new file mode 100644
index 0000000000000000000000000000000000000000..f015bfca6c8f73d6b619f6a4a51296dc1d528e12
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/PuerkitoBio/ghost/handlers/header.go
@@ -0,0 +1,50 @@
+package handlers
+
+import (
+ "net/http"
+ "strings"
+)
+
+// Kind of match to apply to the header check.
+type HeaderMatchType int
+
+const (
+ HmEquals HeaderMatchType = iota
+ HmStartsWith
+ HmEndsWith
+ HmContains
+)
+
+// Check if the specified header matches the test string, applying the header match type
+// specified.
+func HeaderMatch(hdr http.Header, nm string, matchType HeaderMatchType, test string) bool {
+ // First get the header value
+ val := hdr[http.CanonicalHeaderKey(nm)]
+ if len(val) == 0 {
+ return false
+ }
+ // Prepare the match test
+ test = strings.ToLower(test)
+ for _, v := range val {
+ v = strings.Trim(strings.ToLower(v), " \n\t")
+ switch matchType {
+ case HmEquals:
+ if v == test {
+ return true
+ }
+ case HmStartsWith:
+ if strings.HasPrefix(v, test) {
+ return true
+ }
+ case HmEndsWith:
+ if strings.HasSuffix(v, test) {
+ return true
+ }
+ case HmContains:
+ if strings.Contains(v, test) {
+ return true
+ }
+ }
+ }
+ return false
+}
diff --git a/Godeps/_workspace/src/github.com/PuerkitoBio/ghost/handlers/log.go b/Godeps/_workspace/src/github.com/PuerkitoBio/ghost/handlers/log.go
new file mode 100644
index 0000000000000000000000000000000000000000..5a43a71710861d43d13c826c02e58af14518ff61
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/PuerkitoBio/ghost/handlers/log.go
@@ -0,0 +1,231 @@
+package handlers
+
+// Inspired by node's Connect library implementation of the logging middleware
+// https://github.com/senchalabs/connect
+
+import (
+ "fmt"
+ "net/http"
+ "regexp"
+ "strings"
+ "time"
+
+ "github.com/PuerkitoBio/ghost"
+)
+
+const (
+ // Predefined logging formats that can be passed as format string.
+ Ldefault = "_default_"
+ Lshort = "_short_"
+ Ltiny = "_tiny_"
+)
+
+var (
+ // Token parser for request and response headers
+ rxHeaders = regexp.MustCompile(`^(req|res)\[([^\]]+)\]$`)
+
+ // Lookup table for predefined formats
+ predefFormats = map[string]struct {
+ fmt string
+ toks []string
+ }{
+ Ldefault: {
+ `%s - - [%s] "%s %s HTTP/%s" %d %s "%s" "%s"`,
+ []string{"remote-addr", "date", "method", "url", "http-version", "status", "res[Content-Length]", "referrer", "user-agent"},
+ },
+ Lshort: {
+ `%s - %s %s HTTP/%s %d %s - %.3f s`,
+ []string{"remote-addr", "method", "url", "http-version", "status", "res[Content-Length]", "response-time"},
+ },
+ Ltiny: {
+ `%s %s %d %s - %.3f s`,
+ []string{"method", "url", "status", "res[Content-Length]", "response-time"},
+ },
+ }
+)
+
+// Augmented ResponseWriter implementation that captures the status code for the logger.
+type statusResponseWriter struct {
+ http.ResponseWriter
+ code int
+ oriURL string
+}
+
+// Intercept the WriteHeader call to save the status code.
+func (this *statusResponseWriter) WriteHeader(code int) {
+ this.code = code
+ this.ResponseWriter.WriteHeader(code)
+}
+
+// Intercept the Write call to save the default status code.
+func (this *statusResponseWriter) Write(data []byte) (int, error) {
+ if this.code == 0 {
+ this.code = http.StatusOK
+ }
+ return this.ResponseWriter.Write(data)
+}
+
+// Implement the WrapWriter interface.
+func (this *statusResponseWriter) WrappedWriter() http.ResponseWriter {
+ return this.ResponseWriter
+}
+
+// LogHandler options
+type LogOptions struct {
+ LogFn func(string, ...interface{}) // Defaults to ghost.LogFn if nil
+ Format string
+ Tokens []string
+ CustomTokens map[string]func(http.ResponseWriter, *http.Request) string
+ Immediate bool
+ DateFormat string
+}
+
+// Create a new LogOptions struct. The DateFormat defaults to time.RFC3339.
+func NewLogOptions(l func(string, ...interface{}), ft string, tok ...string) *LogOptions {
+ return &LogOptions{
+ LogFn: l,
+ Format: ft,
+ Tokens: tok,
+ CustomTokens: make(map[string]func(http.ResponseWriter, *http.Request) string),
+ DateFormat: time.RFC3339,
+ }
+}
+
+// LogHandlerFunc is the same as LogHandler, it is just a convenience
+// signature that accepts a func(http.ResponseWriter, *http.Request) instead of
+// a http.Handler interface. It saves the boilerplate http.HandlerFunc() cast.
+func LogHandlerFunc(h http.HandlerFunc, opts *LogOptions) http.HandlerFunc {
+ return LogHandler(h, opts)
+}
+
+// Create a log handler for every request it receives.
+func LogHandler(h http.Handler, opts *LogOptions) http.HandlerFunc {
+ return func(w http.ResponseWriter, r *http.Request) {
+ if _, ok := getStatusWriter(w); ok {
+ // Self-awareness, logging handler already set up
+ h.ServeHTTP(w, r)
+ return
+ }
+
+ // Save the response start time
+ st := time.Now()
+ // Call the wrapped handler, with the augmented ResponseWriter to handle the status code
+ stw := &statusResponseWriter{w, 0, ""}
+
+ // Log immediately if requested, otherwise on exit
+ if opts.Immediate {
+ logRequest(stw, r, st, opts)
+ } else {
+ // Store original URL, may get modified by handlers (i.e. StripPrefix)
+ stw.oriURL = r.URL.String()
+ defer logRequest(stw, r, st, opts)
+ }
+ h.ServeHTTP(stw, r)
+ }
+}
+
+func getIpAddress(r *http.Request) string {
+ hdr := r.Header
+ hdrRealIp := hdr.Get("X-Real-Ip")
+ hdrForwardedFor := hdr.Get("X-Forwarded-For")
+ if hdrRealIp == "" && hdrForwardedFor == "" {
+ return r.RemoteAddr
+ }
+ if hdrForwardedFor != "" {
+ // X-Forwarded-For is potentially a list of addresses separated with ","
+ part := strings.Split(hdrForwardedFor, ",")[0]
+ return strings.TrimSpace(part) + ":0"
+ }
+ return hdrRealIp
+}
+
+// Check if the specified token is a predefined one, and if so return its current value.
+func getPredefinedTokenValue(t string, w *statusResponseWriter, r *http.Request,
+ st time.Time, opts *LogOptions) (interface{}, bool) {
+
+ switch t {
+ case "http-version":
+ return fmt.Sprintf("%d.%d", r.ProtoMajor, r.ProtoMinor), true
+ case "response-time":
+ return time.Now().Sub(st).Seconds(), true
+ case "remote-addr":
+ return getIpAddress(r), true
+ case "date":
+ return time.Now().Format(opts.DateFormat), true
+ case "method":
+ return r.Method, true
+ case "url":
+ if w.oriURL != "" {
+ return w.oriURL, true
+ }
+ return r.URL.String(), true
+ case "referrer", "referer":
+ return r.Referer(), true
+ case "user-agent":
+ return r.UserAgent(), true
+ case "status":
+ return w.code, true
+ }
+
+ // Handle special cases for header
+ mtch := rxHeaders.FindStringSubmatch(t)
+ if len(mtch) > 2 {
+ if mtch[1] == "req" {
+ return r.Header.Get(mtch[2]), true
+ } else {
+ // This only works for headers explicitly set via the Header() map of
+ // the writer, not those added by the http package under the covers.
+ return w.Header().Get(mtch[2]), true
+ }
+ }
+ return nil, false
+}
+
+// Do the actual logging.
+func logRequest(w *statusResponseWriter, r *http.Request, st time.Time, opts *LogOptions) {
+ var (
+ fn func(string, ...interface{})
+ ok bool
+ format string
+ toks []string
+ )
+
+ // If no specific log function, use the default one from the ghost package
+ if opts.LogFn == nil {
+ fn = ghost.LogFn
+ } else {
+ fn = opts.LogFn
+ }
+
+ // If this is a predefined format, use it instead
+ if v, ok := predefFormats[opts.Format]; ok {
+ format = v.fmt
+ toks = v.toks
+ } else {
+ format = opts.Format
+ toks = opts.Tokens
+ }
+ args := make([]interface{}, len(toks))
+ for i, t := range toks {
+ if args[i], ok = getPredefinedTokenValue(t, w, r, st, opts); !ok {
+ if f, ok := opts.CustomTokens[t]; ok && f != nil {
+ args[i] = f(w, r)
+ } else {
+ args[i] = "?"
+ }
+ }
+ }
+ fn(format, args...)
+}
+
+// Helper function to retrieve the status writer.
+func getStatusWriter(w http.ResponseWriter) (*statusResponseWriter, bool) {
+ st, ok := GetResponseWriter(w, func(tst http.ResponseWriter) bool {
+ _, ok := tst.(*statusResponseWriter)
+ return ok
+ })
+ if ok {
+ return st.(*statusResponseWriter), true
+ }
+ return nil, false
+}
diff --git a/Godeps/_workspace/src/github.com/PuerkitoBio/ghost/handlers/log_test.go b/Godeps/_workspace/src/github.com/PuerkitoBio/ghost/handlers/log_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..8bd213fc8caa61d72ed00d8f86796d12cfe15fd3
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/PuerkitoBio/ghost/handlers/log_test.go
@@ -0,0 +1,217 @@
+package handlers
+
+import (
+ "bytes"
+ "fmt"
+ "log"
+ "net/http"
+ "net/http/httptest"
+ "regexp"
+ "testing"
+ "time"
+)
+
+type testCase struct {
+ tok string
+ fmt string
+ rx *regexp.Regexp
+}
+
+func TestLog(t *testing.T) {
+ log.SetFlags(0)
+ now := time.Now()
+
+ formats := []testCase{
+ testCase{"remote-addr",
+ "%s",
+ regexp.MustCompile(`^127\.0\.0\.1:\d+\n$`),
+ },
+ testCase{"date",
+ "%s",
+ regexp.MustCompile(`^` + fmt.Sprintf("%04d-%02d-%02d", now.Year(), now.Month(), now.Day()) + `\n$`),
+ },
+ testCase{"method",
+ "%s",
+ regexp.MustCompile(`^GET\n$`),
+ },
+ testCase{"url",
+ "%s",
+ regexp.MustCompile(`^/\n$`),
+ },
+ testCase{"http-version",
+ "%s",
+ regexp.MustCompile(`^1\.1\n$`),
+ },
+ testCase{"status",
+ "%d",
+ regexp.MustCompile(`^200\n$`),
+ },
+ testCase{"referer",
+ "%s",
+ regexp.MustCompile(`^http://www\.test\.com\n$`),
+ },
+ testCase{"referrer",
+ "%s",
+ regexp.MustCompile(`^http://www\.test\.com\n$`),
+ },
+ testCase{"user-agent",
+ "%s",
+ regexp.MustCompile(`^Go \d+\.\d+ package http\n$`),
+ },
+ testCase{"bidon",
+ "%s",
+ regexp.MustCompile(`^\?\n$`),
+ },
+ testCase{"response-time",
+ "%.3f",
+ regexp.MustCompile(`^0\.1\d\d\n$`),
+ },
+ testCase{"req[Accept-Encoding]",
+ "%s",
+ regexp.MustCompile(`^gzip\n$`),
+ },
+ testCase{"res[blah]",
+ "%s",
+ regexp.MustCompile(`^$`),
+ },
+ testCase{"tiny",
+ Ltiny,
+ regexp.MustCompile(`^GET / 200 - 0\.1\d\d s\n$`),
+ },
+ testCase{"short",
+ Lshort,
+ regexp.MustCompile(`^127\.0\.0\.1:\d+ - GET / HTTP/1\.1 200 - 0\.1\d\d s\n$`),
+ },
+ testCase{"default",
+ Ldefault,
+ regexp.MustCompile(`^127\.0\.0\.1:\d+ - - \[\d{4}-\d{2}-\d{2}\] "GET / HTTP/1\.1" 200 "http://www\.test\.com" "Go \d+\.\d+ package http"\n$`),
+ },
+ testCase{"res[Content-Type]",
+ "%s",
+ regexp.MustCompile(`^text/plain\n$`),
+ },
+ }
+ for _, tc := range formats {
+ testLogCase(tc, t)
+ }
+}
+
+func testLogCase(tc testCase, t *testing.T) {
+ buf := bytes.NewBuffer(nil)
+ log.SetOutput(buf)
+ opts := NewLogOptions(log.Printf, tc.fmt, tc.tok)
+ opts.DateFormat = "2006-01-02"
+ h := LogHandler(http.HandlerFunc(
+ func(w http.ResponseWriter, r *http.Request) {
+ time.Sleep(100 * time.Millisecond)
+ w.Header().Set("Content-Type", "text/plain")
+ w.WriteHeader(200)
+ w.Write([]byte("body"))
+ }), opts)
+
+ s := httptest.NewServer(h)
+ defer s.Close()
+ t.Logf("running %s...", tc.tok)
+ req, err := http.NewRequest("GET", s.URL, nil)
+ if err != nil {
+ panic(err)
+ }
+ req.Header.Set("Referer", "http://www.test.com")
+ req.Header.Set("Accept-Encoding", "gzip")
+ res, err := http.DefaultClient.Do(req)
+ if err != nil {
+ panic(err)
+ }
+ assertStatus(http.StatusOK, res.StatusCode, t)
+ ac := buf.String()
+ assertTrue(tc.rx.MatchString(ac), fmt.Sprintf("expected log to match '%s', got '%s'", tc.rx.String(), ac), t)
+}
+
+func TestForwardedFor(t *testing.T) {
+ rx := regexp.MustCompile(`^1\.1\.1\.1:0 - - \[\d{4}-\d{2}-\d{2}\] "GET / HTTP/1\.1" 200 "http://www\.test\.com" "Go \d+\.\d+ package http"\n$`)
+
+ buf := bytes.NewBuffer(nil)
+ log.SetOutput(buf)
+ opts := NewLogOptions(log.Printf, Ldefault)
+ opts.DateFormat = "2006-01-02"
+
+ h := LogHandler(http.HandlerFunc(
+ func(w http.ResponseWriter, r *http.Request) {
+ time.Sleep(100 * time.Millisecond)
+ w.Header().Set("Content-Type", "text/plain")
+ w.WriteHeader(200)
+ w.Write([]byte("body"))
+ }), opts)
+
+ s := httptest.NewServer(h)
+ defer s.Close()
+ t.Logf("running ForwardedFor...")
+ req, err := http.NewRequest("GET", s.URL, nil)
+ if err != nil {
+ panic(err)
+ }
+ req.Header.Set("Referer", "http://www.test.com")
+ req.Header.Set("X-Forwarded-For", "1.1.1.1")
+ req.Header.Set("Accept-Encoding", "gzip")
+ res, err := http.DefaultClient.Do(req)
+ if err != nil {
+ panic(err)
+ }
+ assertStatus(http.StatusOK, res.StatusCode, t)
+ ac := buf.String()
+ assertTrue(rx.MatchString(ac), fmt.Sprintf("expected log to match '%s', got '%s'", rx.String(), ac), t)
+}
+
+func TestImmediate(t *testing.T) {
+ buf := bytes.NewBuffer(nil)
+ log.SetFlags(0)
+ log.SetOutput(buf)
+ opts := NewLogOptions(nil, Ltiny)
+ opts.Immediate = true
+ h := LogHandler(http.HandlerFunc(
+ func(w http.ResponseWriter, r *http.Request) {
+ time.Sleep(100 * time.Millisecond)
+ w.WriteHeader(200)
+ w.Write([]byte("body"))
+ }), opts)
+ s := httptest.NewServer(h)
+ defer s.Close()
+
+ res, err := http.Get(s.URL)
+ if err != nil {
+ panic(err)
+ }
+ assertStatus(http.StatusOK, res.StatusCode, t)
+ ac := buf.String()
+ // Since it is Immediate logging, status is still 0 and response time is less than 100ms
+ rx := regexp.MustCompile(`GET / 0 - 0\.0\d\d s\n`)
+ assertTrue(rx.MatchString(ac), fmt.Sprintf("expected log to match '%s', got '%s'", rx.String(), ac), t)
+}
+
+func TestCustom(t *testing.T) {
+ buf := bytes.NewBuffer(nil)
+ log.SetFlags(0)
+ log.SetOutput(buf)
+ opts := NewLogOptions(nil, "%s %s", "method", "custom")
+ opts.CustomTokens["custom"] = func(w http.ResponseWriter, r *http.Request) string {
+ return "toto"
+ }
+
+ h := LogHandler(http.HandlerFunc(
+ func(w http.ResponseWriter, r *http.Request) {
+ time.Sleep(100 * time.Millisecond)
+ w.WriteHeader(200)
+ w.Write([]byte("body"))
+ }), opts)
+ s := httptest.NewServer(h)
+ defer s.Close()
+
+ res, err := http.Get(s.URL)
+ if err != nil {
+ panic(err)
+ }
+ assertStatus(http.StatusOK, res.StatusCode, t)
+ ac := buf.String()
+ rx := regexp.MustCompile(`GET toto`)
+ assertTrue(rx.MatchString(ac), fmt.Sprintf("expected log to match '%s', got '%s'", rx.String(), ac), t)
+}
diff --git a/Godeps/_workspace/src/github.com/PuerkitoBio/ghost/handlers/panic.go b/Godeps/_workspace/src/github.com/PuerkitoBio/ghost/handlers/panic.go
new file mode 100644
index 0000000000000000000000000000000000000000..e1362c22bb18257d3d9183eb41408ef32870d848
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/PuerkitoBio/ghost/handlers/panic.go
@@ -0,0 +1,57 @@
+package handlers
+
+import (
+ "fmt"
+ "net/http"
+)
+
+// Augmented response writer to hold the panic data (can be anything, not necessarily an error
+// interface).
+type errResponseWriter struct {
+ http.ResponseWriter
+ perr interface{}
+}
+
+// Implement the WrapWriter interface.
+func (this *errResponseWriter) WrappedWriter() http.ResponseWriter {
+ return this.ResponseWriter
+}
+
+// PanicHandlerFunc is the same as PanicHandler, it is just a convenience
+// signature that accepts a func(http.ResponseWriter, *http.Request) instead of
+// a http.Handler interface. It saves the boilerplate http.HandlerFunc() cast.
+func PanicHandlerFunc(h http.HandlerFunc, errH http.HandlerFunc) http.HandlerFunc {
+ return PanicHandler(h, errH)
+}
+
+// Calls the wrapped handler and on panic calls the specified error handler. If the error handler is nil,
+// responds with a 500 error message.
+func PanicHandler(h http.Handler, errH http.Handler) http.HandlerFunc {
+ return func(w http.ResponseWriter, r *http.Request) {
+ defer func() {
+ if err := recover(); err != nil {
+ if errH != nil {
+ ew := &errResponseWriter{w, err}
+ errH.ServeHTTP(ew, r)
+ } else {
+ http.Error(w, fmt.Sprintf("%s", err), http.StatusInternalServerError)
+ }
+ }
+ }()
+
+ // Call the protected handler
+ h.ServeHTTP(w, r)
+ }
+}
+
+// Helper function to retrieve the panic error, if any.
+func GetPanicError(w http.ResponseWriter) (interface{}, bool) {
+ er, ok := GetResponseWriter(w, func(tst http.ResponseWriter) bool {
+ _, ok := tst.(*errResponseWriter)
+ return ok
+ })
+ if ok {
+ return er.(*errResponseWriter).perr, true
+ }
+ return nil, false
+}
diff --git a/Godeps/_workspace/src/github.com/PuerkitoBio/ghost/handlers/panic_test.go b/Godeps/_workspace/src/github.com/PuerkitoBio/ghost/handlers/panic_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..de54d0be9560cad483ff51afdba774ee538f0f91
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/PuerkitoBio/ghost/handlers/panic_test.go
@@ -0,0 +1,62 @@
+package handlers
+
+import (
+ "net/http"
+ "net/http/httptest"
+ "testing"
+)
+
+func TestPanic(t *testing.T) {
+ h := PanicHandler(http.HandlerFunc(
+ func(w http.ResponseWriter, r *http.Request) {
+ panic("test")
+ }), nil)
+ s := httptest.NewServer(h)
+ defer s.Close()
+
+ res, err := http.Get(s.URL)
+ if err != nil {
+ panic(err)
+ }
+ assertStatus(http.StatusInternalServerError, res.StatusCode, t)
+}
+
+func TestNoPanic(t *testing.T) {
+ h := PanicHandler(http.HandlerFunc(
+ func(w http.ResponseWriter, r *http.Request) {
+
+ }), nil)
+ s := httptest.NewServer(h)
+ defer s.Close()
+
+ res, err := http.Get(s.URL)
+ if err != nil {
+ panic(err)
+ }
+ assertStatus(http.StatusOK, res.StatusCode, t)
+}
+
+func TestPanicCustom(t *testing.T) {
+ h := PanicHandler(http.HandlerFunc(
+ func(w http.ResponseWriter, r *http.Request) {
+ panic("ok")
+ }),
+ http.HandlerFunc(
+ func(w http.ResponseWriter, r *http.Request) {
+ err, ok := GetPanicError(w)
+ if !ok {
+ panic("no panic error found")
+ }
+ w.WriteHeader(501)
+ w.Write([]byte(err.(string)))
+ }))
+ s := httptest.NewServer(h)
+ defer s.Close()
+
+ res, err := http.Get(s.URL)
+ if err != nil {
+ panic(err)
+ }
+ assertStatus(501, res.StatusCode, t)
+ assertBody([]byte("ok"), res, t)
+}
diff --git a/Godeps/_workspace/src/github.com/PuerkitoBio/ghost/handlers/redisstore.go b/Godeps/_workspace/src/github.com/PuerkitoBio/ghost/handlers/redisstore.go
new file mode 100644
index 0000000000000000000000000000000000000000..2974e2205a090da64a9cc7c8343f1b8c127c13cb
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/PuerkitoBio/ghost/handlers/redisstore.go
@@ -0,0 +1,135 @@
+package handlers
+
+import (
+ "encoding/json"
+ "errors"
+ "time"
+
+ "github.com/garyburd/redigo/redis"
+)
+
+var (
+ ErrNoKeyPrefix = errors.New("cannot get session keys without a key prefix")
+)
+
+type RedisStoreOptions struct {
+ Network string
+ Address string
+ ConnectTimeout time.Duration
+ ReadTimeout time.Duration
+ WriteTimeout time.Duration
+ Database int // Redis database to use for session keys
+ KeyPrefix string // If set, keys will be KeyPrefix:SessionID (semicolon added)
+ BrowserSessServerTTL time.Duration // Defaults to 2 days
+}
+
+type RedisStore struct {
+ opts *RedisStoreOptions
+ conn redis.Conn
+}
+
+// Create a redis session store with the specified options.
+func NewRedisStore(opts *RedisStoreOptions) *RedisStore {
+ var err error
+ rs := &RedisStore{opts, nil}
+ rs.conn, err = redis.DialTimeout(opts.Network, opts.Address, opts.ConnectTimeout,
+ opts.ReadTimeout, opts.WriteTimeout)
+ if err != nil {
+ panic(err)
+ }
+ return rs
+}
+
+// Get the session from the store.
+func (this *RedisStore) Get(id string) (*Session, error) {
+ key := id
+ if this.opts.KeyPrefix != "" {
+ key = this.opts.KeyPrefix + ":" + id
+ }
+ b, err := redis.Bytes(this.conn.Do("GET", key))
+ if err != nil {
+ return nil, err
+ }
+ var sess Session
+ err = json.Unmarshal(b, &sess)
+ if err != nil {
+ return nil, err
+ }
+ return &sess, nil
+}
+
+// Save the session into the store.
+func (this *RedisStore) Set(sess *Session) error {
+ b, err := json.Marshal(sess)
+ if err != nil {
+ return err
+ }
+ key := sess.ID()
+ if this.opts.KeyPrefix != "" {
+ key = this.opts.KeyPrefix + ":" + sess.ID()
+ }
+ ttl := sess.MaxAge()
+ if ttl == 0 {
+ // Browser session, set to specified TTL
+ ttl = this.opts.BrowserSessServerTTL
+ if ttl == 0 {
+ ttl = 2 * 24 * time.Hour // Default to 2 days
+ }
+ }
+ _, err = this.conn.Do("SETEX", key, int(ttl.Seconds()), b)
+ if err != nil {
+ return err
+ }
+ return nil
+}
+
+// Delete the session from the store.
+func (this *RedisStore) Delete(id string) error {
+ key := id
+ if this.opts.KeyPrefix != "" {
+ key = this.opts.KeyPrefix + ":" + id
+ }
+ _, err := this.conn.Do("DEL", key)
+ if err != nil {
+ return err
+ }
+ return nil
+}
+
+// Clear all sessions from the store. Requires the use of a key
+// prefix in the store options, otherwise the method refuses to delete all keys.
+func (this *RedisStore) Clear() error {
+ vals, err := this.getSessionKeys()
+ if err != nil {
+ return err
+ }
+ if len(vals) > 0 {
+ this.conn.Send("MULTI")
+ for _, v := range vals {
+ this.conn.Send("DEL", v)
+ }
+ _, err = this.conn.Do("EXEC")
+ if err != nil {
+ return err
+ }
+ }
+ return nil
+}
+
+// Get the number of session keys in the store. Requires the use of a
+// key prefix in the store options, otherwise returns -1 (cannot tell
+// session keys from other keys).
+func (this *RedisStore) Len() int {
+ vals, err := this.getSessionKeys()
+ if err != nil {
+ return -1
+ }
+ return len(vals)
+}
+
+func (this *RedisStore) getSessionKeys() ([]interface{}, error) {
+ if this.opts.KeyPrefix != "" {
+ return redis.Values(this.conn.Do("KEYS", this.opts.KeyPrefix+":*"))
+ }
+ return nil, ErrNoKeyPrefix
+}
diff --git a/Godeps/_workspace/src/github.com/PuerkitoBio/ghost/handlers/reswriter.go b/Godeps/_workspace/src/github.com/PuerkitoBio/ghost/handlers/reswriter.go
new file mode 100644
index 0000000000000000000000000000000000000000..1ae6ad397a9cc603078a3f22b7e26f38cb785654
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/PuerkitoBio/ghost/handlers/reswriter.go
@@ -0,0 +1,30 @@
+package handlers
+
+import (
+ "net/http"
+)
+
+// This interface can be implemented by an augmented ResponseWriter, so that
+// it doesn't hide other augmented writers in the chain.
+type WrapWriter interface {
+ http.ResponseWriter
+ WrappedWriter() http.ResponseWriter
+}
+
+// Helper function to retrieve a specific ResponseWriter.
+func GetResponseWriter(w http.ResponseWriter,
+ predicate func(http.ResponseWriter) bool) (http.ResponseWriter, bool) {
+
+ for {
+ // Check if this writer is the one we're looking for
+ if w != nil && predicate(w) {
+ return w, true
+ }
+ // If it is a WrapWriter, move back the chain of wrapped writers
+ ww, ok := w.(WrapWriter)
+ if !ok {
+ return nil, false
+ }
+ w = ww.WrappedWriter()
+ }
+}
diff --git a/Godeps/_workspace/src/github.com/PuerkitoBio/ghost/handlers/reswriter_test.go b/Godeps/_workspace/src/github.com/PuerkitoBio/ghost/handlers/reswriter_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..37db8b42881c1f92a85818b170760b50f358f0bb
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/PuerkitoBio/ghost/handlers/reswriter_test.go
@@ -0,0 +1,52 @@
+package handlers
+
+import (
+ "fmt"
+ "net/http"
+ "testing"
+)
+
+type baseWriter struct{}
+
+func (b *baseWriter) Write(data []byte) (int, error) { return 0, nil }
+func (b *baseWriter) WriteHeader(code int) {}
+func (b *baseWriter) Header() http.Header { return nil }
+
+func TestNilWriter(t *testing.T) {
+ rw, ok := GetResponseWriter(nil, func(w http.ResponseWriter) bool {
+ return true
+ })
+ assertTrue(rw == nil, "expected nil, got non-nil", t)
+ assertTrue(!ok, "expected false, got true", t)
+}
+
+func TestBaseWriter(t *testing.T) {
+ bw := &baseWriter{}
+ rw, ok := GetResponseWriter(bw, func(w http.ResponseWriter) bool {
+ return true
+ })
+ assertTrue(rw == bw, fmt.Sprintf("expected %#v, got %#v", bw, rw), t)
+ assertTrue(ok, "expected true, got false", t)
+}
+
+func TestWrappedWriter(t *testing.T) {
+ bw := &baseWriter{}
+ ctx := &contextResponseWriter{bw, nil}
+ rw, ok := GetResponseWriter(ctx, func(w http.ResponseWriter) bool {
+ _, ok := w.(*baseWriter)
+ return ok
+ })
+ assertTrue(rw == bw, fmt.Sprintf("expected %#v, got %#v", bw, rw), t)
+ assertTrue(ok, "expected true, got false", t)
+}
+
+func TestWrappedNotFoundWriter(t *testing.T) {
+ bw := &baseWriter{}
+ ctx := &contextResponseWriter{bw, nil}
+ rw, ok := GetResponseWriter(ctx, func(w http.ResponseWriter) bool {
+ _, ok := w.(*statusResponseWriter)
+ return ok
+ })
+ assertTrue(rw == nil, fmt.Sprintf("expected nil, got %#v", rw), t)
+ assertTrue(!ok, "expected false, got true", t)
+}
diff --git a/Godeps/_workspace/src/github.com/PuerkitoBio/ghost/handlers/session.go b/Godeps/_workspace/src/github.com/PuerkitoBio/ghost/handlers/session.go
new file mode 100644
index 0000000000000000000000000000000000000000..fb96faa749874735223242b52a97640456adfc9a
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/PuerkitoBio/ghost/handlers/session.go
@@ -0,0 +1,321 @@
+package handlers
+
+import (
+ "encoding/json"
+ "errors"
+ "hash/crc32"
+ "net/http"
+ "strings"
+ "time"
+
+ "github.com/PuerkitoBio/ghost"
+ "github.com/gorilla/securecookie"
+ "github.com/nu7hatch/gouuid"
+)
+
+const defaultCookieName = "ghost.sid"
+
+var (
+ ErrSessionSecretMissing = errors.New("session secret is missing")
+ ErrNoSessionID = errors.New("session ID could not be generated")
+)
+
+// The Session holds the data map that persists for the duration of the session.
+// The information stored in this map should be marshalable for the target Session store
+// format (i.e. json, sql, gob, etc. depending on how the store persists the data).
+type Session struct {
+ isNew bool // keep private, not saved to JSON, will be false once read from the store
+ internalSession
+}
+
+// Use a separate private struct to hold the private fields of the Session,
+// although those fields are exposed (public). This is a trick to simplify
+// JSON encoding.
+type internalSession struct {
+ Data map[string]interface{} // JSON cannot marshal a map[interface{}]interface{}
+ ID string
+ Created time.Time
+ MaxAge time.Duration
+}
+
+// Create a new Session instance. It panics in the unlikely event that a new random ID cannot be generated.
+func newSession(maxAge int) *Session {
+ uid, err := uuid.NewV4()
+ if err != nil {
+ panic(ErrNoSessionID)
+ }
+ return &Session{
+ true, // is new
+ internalSession{
+ make(map[string]interface{}),
+ uid.String(),
+ time.Now(),
+ time.Duration(maxAge) * time.Second,
+ },
+ }
+}
+
+// Gets the ID of the session.
+func (ø *Session) ID() string {
+ return ø.internalSession.ID
+}
+
+// Get the max age duration
+func (ø *Session) MaxAge() time.Duration {
+ return ø.internalSession.MaxAge
+}
+
+// Get the creation time of the session.
+func (ø *Session) Created() time.Time {
+ return ø.internalSession.Created
+}
+
+// Is this a new Session (created by the current request)
+func (ø *Session) IsNew() bool {
+ return ø.isNew
+}
+
+// TODO : Resets the max age property of the session to its original value (sliding expiration).
+func (ø *Session) resetMaxAge() {
+}
+
+// Marshal the session to JSON.
+func (ø *Session) MarshalJSON() ([]byte, error) {
+ return json.Marshal(ø.internalSession)
+}
+
+// Unmarshal the JSON into the internal session struct.
+func (ø *Session) UnmarshalJSON(b []byte) error {
+ return json.Unmarshal(b, &ø.internalSession)
+}
+
+// Options object for the session handler. It specified the Session store to use for
+// persistence, the template for the session cookie (name, path, maxage, etc.),
+// whether or not the proxy should be trusted to determine if the connection is secure,
+// and the required secret to sign the session cookie.
+type SessionOptions struct {
+ Store SessionStore
+ CookieTemplate http.Cookie
+ TrustProxy bool
+ Secret string
+}
+
+// Create a new SessionOptions struct, using default cookie and proxy values.
+func NewSessionOptions(store SessionStore, secret string) *SessionOptions {
+ return &SessionOptions{
+ Store: store,
+ Secret: secret,
+ }
+}
+
+// The augmented ResponseWriter struct for the session handler. It holds the current
+// Session object and Session store, as well as flags and function to send the actual
+// session cookie at the end of the request.
+type sessResponseWriter struct {
+ http.ResponseWriter
+ sess *Session
+ sessStore SessionStore
+ sessSent bool
+ sendCookieFn func()
+}
+
+// Implement the WrapWriter interface.
+func (ø *sessResponseWriter) WrappedWriter() http.ResponseWriter {
+ return ø.ResponseWriter
+}
+
+// Intercept the Write() method to add the Set-Cookie header before it's too late.
+func (ø *sessResponseWriter) Write(data []byte) (int, error) {
+ if !ø.sessSent {
+ ø.sendCookieFn()
+ ø.sessSent = true
+ }
+ return ø.ResponseWriter.Write(data)
+}
+
+// Intercept the WriteHeader() method to add the Set-Cookie header before it's too late.
+func (ø *sessResponseWriter) WriteHeader(code int) {
+ if !ø.sessSent {
+ ø.sendCookieFn()
+ ø.sessSent = true
+ }
+ ø.ResponseWriter.WriteHeader(code)
+}
+
+// SessionHandlerFunc is the same as SessionHandler, it is just a convenience
+// signature that accepts a func(http.ResponseWriter, *http.Request) instead of
+// a http.Handler interface. It saves the boilerplate http.HandlerFunc() cast.
+func SessionHandlerFunc(h http.HandlerFunc, opts *SessionOptions) http.HandlerFunc {
+ return SessionHandler(h, opts)
+}
+
+// Create a Session handler to offer the Session behaviour to the specified handler.
+func SessionHandler(h http.Handler, opts *SessionOptions) http.HandlerFunc {
+ // Make sure the required cookie fields are set
+ if opts.CookieTemplate.Name == "" {
+ opts.CookieTemplate.Name = defaultCookieName
+ }
+ if opts.CookieTemplate.Path == "" {
+ opts.CookieTemplate.Path = "/"
+ }
+ // Secret is required
+ if opts.Secret == "" {
+ panic(ErrSessionSecretMissing)
+ }
+
+ // Return the actual handler
+ return func(w http.ResponseWriter, r *http.Request) {
+ if _, ok := getSessionWriter(w); ok {
+ // Self-awareness
+ h.ServeHTTP(w, r)
+ return
+ }
+
+ if strings.Index(r.URL.Path, opts.CookieTemplate.Path) != 0 {
+ // Session does not apply to this path
+ h.ServeHTTP(w, r)
+ return
+ }
+
+ // Create a new Session or retrieve the existing session based on the
+ // session cookie received.
+ var sess *Session
+ var ckSessId string
+ exCk, err := r.Cookie(opts.CookieTemplate.Name)
+ if err != nil {
+ sess = newSession(opts.CookieTemplate.MaxAge)
+ ghost.LogFn("ghost.session : error getting session cookie : %s", err)
+ } else {
+ ckSessId, err = parseSignedCookie(exCk, opts.Secret)
+ if err != nil {
+ sess = newSession(opts.CookieTemplate.MaxAge)
+ ghost.LogFn("ghost.session : error parsing signed cookie : %s", err)
+ } else if ckSessId == "" {
+ sess = newSession(opts.CookieTemplate.MaxAge)
+ ghost.LogFn("ghost.session : no existing session ID")
+ } else {
+ // Get the session
+ sess, err = opts.Store.Get(ckSessId)
+ if err != nil {
+ sess = newSession(opts.CookieTemplate.MaxAge)
+ ghost.LogFn("ghost.session : error getting session from store : %s", err)
+ } else if sess == nil {
+ sess = newSession(opts.CookieTemplate.MaxAge)
+ ghost.LogFn("ghost.session : nil session")
+ }
+ }
+ }
+ // Save the original hash of the session, used to compare if the contents
+ // have changed during the handling of the request, so that it has to be
+ // saved to the stored.
+ oriHash := hash(sess)
+
+ // Create the augmented ResponseWriter.
+ srw := &sessResponseWriter{w, sess, opts.Store, false, func() {
+ // This function is called when the header is about to be written, so that
+ // the session cookie is correctly set.
+
+ // Check if the connection is secure
+ proto := strings.Trim(strings.ToLower(r.Header.Get("X-Forwarded-Proto")), " ")
+ tls := r.TLS != nil || (strings.HasPrefix(proto, "https") && opts.TrustProxy)
+ if opts.CookieTemplate.Secure && !tls {
+ ghost.LogFn("ghost.session : secure cookie on a non-secure connection, cookie not sent")
+ return
+ }
+ if !sess.IsNew() {
+ // If this is not a new session, no need to send back the cookie
+ // TODO : Handle expires?
+ return
+ }
+
+ // Send the session cookie
+ ck := opts.CookieTemplate
+ ck.Value = sess.ID()
+ err := signCookie(&ck, opts.Secret)
+ if err != nil {
+ ghost.LogFn("ghost.session : error signing cookie : %s", err)
+ return
+ }
+ http.SetCookie(w, &ck)
+ }}
+
+ // Call wrapped handler
+ h.ServeHTTP(srw, r)
+
+ // TODO : Expiration management? srw.sess.resetMaxAge()
+ // Do not save if content is the same, unless session is new (to avoid
+ // creating a new session and sending a cookie on each successive request).
+ if newHash := hash(sess); !sess.IsNew() && oriHash == newHash && newHash != 0 {
+ // No changes to the session, no need to save
+ ghost.LogFn("ghost.session : no changes to save to store")
+ return
+ }
+ err = opts.Store.Set(sess)
+ if err != nil {
+ ghost.LogFn("ghost.session : error saving session to store : %s", err)
+ }
+ }
+}
+
+// Helper function to retrieve the session for the current request.
+func GetSession(w http.ResponseWriter) (*Session, bool) {
+ ss, ok := getSessionWriter(w)
+ if ok {
+ return ss.sess, true
+ }
+ return nil, false
+}
+
+// Helper function to retrieve the session store
+func GetSessionStore(w http.ResponseWriter) (SessionStore, bool) {
+ ss, ok := getSessionWriter(w)
+ if ok {
+ return ss.sessStore, true
+ }
+ return nil, false
+}
+
+// Internal helper function to retrieve the session writer object.
+func getSessionWriter(w http.ResponseWriter) (*sessResponseWriter, bool) {
+ ss, ok := GetResponseWriter(w, func(tst http.ResponseWriter) bool {
+ _, ok := tst.(*sessResponseWriter)
+ return ok
+ })
+ if ok {
+ return ss.(*sessResponseWriter), true
+ }
+ return nil, false
+}
+
+// Parse a signed cookie and return the cookie value
+func parseSignedCookie(ck *http.Cookie, secret string) (string, error) {
+ var val string
+
+ sck := securecookie.New([]byte(secret), nil)
+ err := sck.Decode(ck.Name, ck.Value, &val)
+ if err != nil {
+ return "", err
+ }
+ return val, nil
+}
+
+// Sign the specified cookie's value
+func signCookie(ck *http.Cookie, secret string) error {
+ sck := securecookie.New([]byte(secret), nil)
+ enc, err := sck.Encode(ck.Name, ck.Value)
+ if err != nil {
+ return err
+ }
+ ck.Value = enc
+ return nil
+}
+
+// Compute a CRC32 hash of the session's JSON-encoded contents.
+func hash(s *Session) uint32 {
+ data, err := json.Marshal(s)
+ if err != nil {
+ ghost.LogFn("ghost.session : error hash : %s", err)
+ return 0 // 0 is always treated as "modified" session content
+ }
+ return crc32.ChecksumIEEE(data)
+}
diff --git a/Godeps/_workspace/src/github.com/PuerkitoBio/ghost/handlers/session_test.go b/Godeps/_workspace/src/github.com/PuerkitoBio/ghost/handlers/session_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..ac91dd2c68b7cb2815f5ff4c570178651d631b08
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/PuerkitoBio/ghost/handlers/session_test.go
@@ -0,0 +1,258 @@
+package handlers
+
+import (
+ "fmt"
+ "io/ioutil"
+ "net/http"
+ "net/http/cookiejar"
+ "net/http/httptest"
+ "testing"
+ "time"
+)
+
+var (
+ store SessionStore
+ secret = "butchered at birth"
+)
+
+func TestSession(t *testing.T) {
+ stores := map[string]SessionStore{
+ "memory": NewMemoryStore(1),
+ "redis": NewRedisStore(&RedisStoreOptions{
+ Network: "tcp",
+ Address: ":6379",
+ Database: 1,
+ KeyPrefix: "sess",
+ }),
+ }
+ for k, v := range stores {
+ t.Logf("testing session with %s store\n", k)
+ store = v
+ t.Log("SessionExists")
+ testSessionExists(t)
+ t.Log("SessionPersists")
+ testSessionPersists(t)
+ t.Log("SessionExpires")
+ testSessionExpires(t)
+ t.Log("SessionBeforeExpires")
+ testSessionBeforeExpires(t)
+ t.Log("PanicIfNoSecret")
+ testPanicIfNoSecret(t)
+ t.Log("InvalidPath")
+ testInvalidPath(t)
+ t.Log("ValidSubPath")
+ testValidSubPath(t)
+ t.Log("SecureOverHttp")
+ testSecureOverHttp(t)
+ }
+}
+
+func setupTest(f func(w http.ResponseWriter, r *http.Request), ckPath string, secure bool, maxAge int) *httptest.Server {
+ opts := NewSessionOptions(store, secret)
+ if ckPath != "" {
+ opts.CookieTemplate.Path = ckPath
+ }
+ opts.CookieTemplate.Secure = secure
+ opts.CookieTemplate.MaxAge = maxAge
+ h := SessionHandler(http.HandlerFunc(f), opts)
+ return httptest.NewServer(h)
+}
+
+func doRequest(u string, newJar bool) *http.Response {
+ var err error
+ if newJar {
+ http.DefaultClient.Jar, err = cookiejar.New(new(cookiejar.Options))
+ if err != nil {
+ panic(err)
+ }
+ }
+ res, err := http.Get(u)
+ if err != nil {
+ panic(err)
+ }
+ return res
+}
+
+func testSessionExists(t *testing.T) {
+ s := setupTest(func(w http.ResponseWriter, r *http.Request) {
+ ssn, ok := GetSession(w)
+ if assertTrue(ok, "expected session to be non-nil, got nil", t) {
+ ssn.Data["foo"] = "bar"
+ assertTrue(ssn.Data["foo"] == "bar", fmt.Sprintf("expected ssn[foo] to be 'bar', got %v", ssn.Data["foo"]), t)
+ }
+ w.Write([]byte("ok"))
+ }, "", false, 0)
+ defer s.Close()
+
+ res := doRequest(s.URL, true)
+ assertStatus(http.StatusOK, res.StatusCode, t)
+ assertBody([]byte("ok"), res, t)
+ assertTrue(len(res.Cookies()) == 1, fmt.Sprintf("expected response to have 1 cookie, got %d", len(res.Cookies())), t)
+}
+
+func testSessionPersists(t *testing.T) {
+ cnt := 0
+ s := setupTest(func(w http.ResponseWriter, r *http.Request) {
+ ssn, ok := GetSession(w)
+ if !ok {
+ panic("session not found!")
+ }
+ if cnt == 0 {
+ ssn.Data["foo"] = "bar"
+ w.Write([]byte("ok"))
+ cnt++
+ } else {
+ w.Write([]byte(ssn.Data["foo"].(string)))
+ }
+ }, "", false, 0)
+ defer s.Close()
+
+ // 1st call, set the session value
+ res := doRequest(s.URL, true)
+ assertStatus(http.StatusOK, res.StatusCode, t)
+ assertBody([]byte("ok"), res, t)
+
+ // 2nd call, get the session value
+ res = doRequest(s.URL, false)
+ assertStatus(http.StatusOK, res.StatusCode, t)
+ assertBody([]byte("bar"), res, t)
+ assertTrue(len(res.Cookies()) == 0, fmt.Sprintf("expected 2nd response to have 0 cookie, got %d", len(res.Cookies())), t)
+}
+
+func testSessionExpires(t *testing.T) {
+ cnt := 0
+ s := setupTest(func(w http.ResponseWriter, r *http.Request) {
+ ssn, ok := GetSession(w)
+ if !ok {
+ panic("session not found!")
+ }
+ if cnt == 0 {
+ w.Write([]byte(ssn.ID()))
+ cnt++
+ } else {
+ w.Write([]byte(ssn.ID()))
+ }
+ }, "", false, 1) // Expire in 1 second
+ defer s.Close()
+
+ // 1st call, set the session value
+ res := doRequest(s.URL, true)
+ assertStatus(http.StatusOK, res.StatusCode, t)
+ id1, err := ioutil.ReadAll(res.Body)
+ if err != nil {
+ panic(err)
+ }
+ res.Body.Close()
+ time.Sleep(1001 * time.Millisecond)
+
+ // 2nd call, get the session value
+ res = doRequest(s.URL, false)
+ assertStatus(http.StatusOK, res.StatusCode, t)
+ id2, err := ioutil.ReadAll(res.Body)
+ if err != nil {
+ panic(err)
+ }
+ res.Body.Close()
+ sid1, sid2 := string(id1), string(id2)
+ assertTrue(len(res.Cookies()) == 1, fmt.Sprintf("expected 2nd response to have 1 cookie, got %d", len(res.Cookies())), t)
+ assertTrue(sid1 != sid2, "expected session IDs to be different, got same", t)
+}
+
+func testSessionBeforeExpires(t *testing.T) {
+ s := setupTest(func(w http.ResponseWriter, r *http.Request) {
+ ssn, ok := GetSession(w)
+ if !ok {
+ panic("session not found!")
+ }
+ w.Write([]byte(ssn.ID()))
+ }, "", false, 1) // Expire in 1 second
+ defer s.Close()
+
+ // 1st call, set the session value
+ res := doRequest(s.URL, true)
+ assertStatus(http.StatusOK, res.StatusCode, t)
+ id1, err := ioutil.ReadAll(res.Body)
+ if err != nil {
+ panic(err)
+ }
+ res.Body.Close()
+ time.Sleep(500 * time.Millisecond)
+
+ // 2nd call, get the session value
+ res = doRequest(s.URL, false)
+ assertStatus(http.StatusOK, res.StatusCode, t)
+ id2, err := ioutil.ReadAll(res.Body)
+ if err != nil {
+ panic(err)
+ }
+ res.Body.Close()
+ sid1, sid2 := string(id1), string(id2)
+ assertTrue(len(res.Cookies()) == 0, fmt.Sprintf("expected 2nd response to have no cookie, got %d", len(res.Cookies())), t)
+ assertTrue(sid1 == sid2, "expected session IDs to be the same, got different", t)
+}
+
+func testPanicIfNoSecret(t *testing.T) {
+ defer assertPanic(t)
+ SessionHandler(http.NotFoundHandler(), NewSessionOptions(nil, ""))
+}
+
+func testInvalidPath(t *testing.T) {
+ s := setupTest(func(w http.ResponseWriter, r *http.Request) {
+ _, ok := GetSession(w)
+ assertTrue(!ok, "expected session to be nil, got non-nil", t)
+ w.Write([]byte("ok"))
+ }, "/foo", false, 0)
+ defer s.Close()
+
+ res := doRequest(s.URL, true)
+ assertStatus(http.StatusOK, res.StatusCode, t)
+ assertBody([]byte("ok"), res, t)
+ assertTrue(len(res.Cookies()) == 0, fmt.Sprintf("expected response to have no cookie, got %d", len(res.Cookies())), t)
+}
+
+func testValidSubPath(t *testing.T) {
+ s := setupTest(func(w http.ResponseWriter, r *http.Request) {
+ _, ok := GetSession(w)
+ assertTrue(ok, "expected session to be non-nil, got nil", t)
+ w.Write([]byte("ok"))
+ }, "/foo", false, 0)
+ defer s.Close()
+
+ res := doRequest(s.URL+"/foo/bar", true)
+ assertStatus(http.StatusOK, res.StatusCode, t)
+ assertBody([]byte("ok"), res, t)
+ assertTrue(len(res.Cookies()) == 1, fmt.Sprintf("expected response to have 1 cookie, got %d", len(res.Cookies())), t)
+}
+
+func testSecureOverHttp(t *testing.T) {
+ s := setupTest(func(w http.ResponseWriter, r *http.Request) {
+ _, ok := GetSession(w)
+ assertTrue(ok, "expected session to be non-nil, got nil", t)
+ w.Write([]byte("ok"))
+ }, "", true, 0)
+ defer s.Close()
+
+ res := doRequest(s.URL, true)
+ assertStatus(http.StatusOK, res.StatusCode, t)
+ assertBody([]byte("ok"), res, t)
+ assertTrue(len(res.Cookies()) == 0, fmt.Sprintf("expected response to have no cookie, got %d", len(res.Cookies())), t)
+}
+
+// TODO : commented, certificate problem
+func xtestSecureOverHttps(t *testing.T) {
+ opts := NewSessionOptions(store, secret)
+ opts.CookieTemplate.Secure = true
+ h := SessionHandler(http.HandlerFunc(
+ func(w http.ResponseWriter, r *http.Request) {
+ _, ok := GetSession(w)
+ assertTrue(ok, "expected session to be non-nil, got nil", t)
+ w.Write([]byte("ok"))
+ }), opts)
+ s := httptest.NewTLSServer(h)
+ defer s.Close()
+
+ res := doRequest(s.URL, true)
+ assertStatus(http.StatusOK, res.StatusCode, t)
+ assertBody([]byte("ok"), res, t)
+ assertTrue(len(res.Cookies()) == 1, fmt.Sprintf("expected response to have 1 cookie, got %d", len(res.Cookies())), t)
+}
diff --git a/Godeps/_workspace/src/github.com/PuerkitoBio/ghost/handlers/sstore.go b/Godeps/_workspace/src/github.com/PuerkitoBio/ghost/handlers/sstore.go
new file mode 100644
index 0000000000000000000000000000000000000000..624993f49e9dfebf986734ff9b8c479470b95cbc
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/PuerkitoBio/ghost/handlers/sstore.go
@@ -0,0 +1,90 @@
+package handlers
+
+import (
+ "sync"
+ "time"
+)
+
+// SessionStore interface, must be implemented by any store to be used
+// for session storage.
+type SessionStore interface {
+ Get(id string) (*Session, error) // Get the session from the store
+ Set(sess *Session) error // Save the session in the store
+ Delete(id string) error // Delete the session from the store
+ Clear() error // Delete all sessions from the store
+ Len() int // Get the number of sessions in the store
+}
+
+// In-memory implementation of a session store. Not recommended for production
+// use.
+type MemoryStore struct {
+ l sync.RWMutex
+ m map[string]*Session
+ capc int
+}
+
+// Create a new memory store.
+func NewMemoryStore(capc int) *MemoryStore {
+ m := &MemoryStore{}
+ m.capc = capc
+ m.newMap()
+ return m
+}
+
+// Get the number of sessions saved in the store.
+func (this *MemoryStore) Len() int {
+ return len(this.m)
+}
+
+// Get the requested session from the store.
+func (this *MemoryStore) Get(id string) (*Session, error) {
+ this.l.RLock()
+ defer this.l.RUnlock()
+ return this.m[id], nil
+}
+
+// Save the session to the store.
+func (this *MemoryStore) Set(sess *Session) error {
+ this.l.Lock()
+ defer this.l.Unlock()
+ this.m[sess.ID()] = sess
+ if sess.IsNew() {
+ // Since the memory store doesn't marshal to a string without the isNew, if it is left
+ // to true, it will stay true forever.
+ sess.isNew = false
+ // Expire in the given time. If the maxAge is 0 (which means browser-session lifetime),
+ // expire in a reasonable delay, 2 days. The weird case of a negative maxAge will
+ // cause the immediate Delete call.
+ wait := sess.MaxAge()
+ if wait == 0 {
+ wait = 2 * 24 * time.Hour
+ }
+ go func() {
+ // Clear the session after the specified delay
+ <-time.After(wait)
+ this.Delete(sess.ID())
+ }()
+ }
+ return nil
+}
+
+// Delete the specified session ID from the store.
+func (this *MemoryStore) Delete(id string) error {
+ this.l.Lock()
+ defer this.l.Unlock()
+ delete(this.m, id)
+ return nil
+}
+
+// Clear all sessions from the store.
+func (this *MemoryStore) Clear() error {
+ this.l.Lock()
+ defer this.l.Unlock()
+ this.newMap()
+ return nil
+}
+
+// Re-create the internal map, dropping all existing sessions.
+func (this *MemoryStore) newMap() {
+ this.m = make(map[string]*Session, this.capc)
+}
diff --git a/Godeps/_workspace/src/github.com/PuerkitoBio/ghost/handlers/static.go b/Godeps/_workspace/src/github.com/PuerkitoBio/ghost/handlers/static.go
new file mode 100644
index 0000000000000000000000000000000000000000..7d070551f561fbfb2779d6bc57d5d93c3325c8fb
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/PuerkitoBio/ghost/handlers/static.go
@@ -0,0 +1,13 @@
+package handlers
+
+import (
+ "net/http"
+)
+
+// StaticFileHandler, unlike net/http.FileServer, serves the contents of a specific
+// file when it is called.
+func StaticFileHandler(path string) http.HandlerFunc {
+ return func(w http.ResponseWriter, r *http.Request) {
+ http.ServeFile(w, r, path)
+ }
+}
diff --git a/Godeps/_workspace/src/github.com/PuerkitoBio/ghost/handlers/static_test.go b/Godeps/_workspace/src/github.com/PuerkitoBio/ghost/handlers/static_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..259079d7a997947ae0187701950a41cfe438b293
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/PuerkitoBio/ghost/handlers/static_test.go
@@ -0,0 +1,46 @@
+package handlers
+
+import (
+ "net/http"
+ "net/http/httptest"
+ "testing"
+)
+
+func TestServeFile(t *testing.T) {
+ h := StaticFileHandler("./testdata/styles.css")
+ s := httptest.NewServer(h)
+ defer s.Close()
+
+ res, err := http.Get(s.URL)
+ if err != nil {
+ panic(err)
+ }
+ assertStatus(http.StatusOK, res.StatusCode, t)
+ assertHeader("Content-Type", "text/css; charset=utf-8", res, t)
+ assertHeader("Content-Encoding", "", res, t)
+ assertBody([]byte(`* {
+ background-color: white;
+}`), res, t)
+}
+
+func TestGzippedFile(t *testing.T) {
+ h := GZIPHandler(StaticFileHandler("./testdata/styles.css"), nil)
+ s := httptest.NewServer(h)
+ defer s.Close()
+
+ req, err := http.NewRequest("GET", s.URL, nil)
+ if err != nil {
+ panic(err)
+ }
+ req.Header.Set("Accept-Encoding", "*")
+ res, err := http.DefaultClient.Do(req)
+ if err != nil {
+ panic(err)
+ }
+ assertStatus(http.StatusOK, res.StatusCode, t)
+ assertHeader("Content-Encoding", "gzip", res, t)
+ assertHeader("Content-Type", "text/css; charset=utf-8", res, t)
+ assertGzippedBody([]byte(`* {
+ background-color: white;
+}`), res, t)
+}
diff --git a/Godeps/_workspace/src/github.com/PuerkitoBio/ghost/handlers/testdata/favicon.ico b/Godeps/_workspace/src/github.com/PuerkitoBio/ghost/handlers/testdata/favicon.ico
new file mode 100644
index 0000000000000000000000000000000000000000..e277138dcf5f882a66b7961cd060d30294ca8a1d
Binary files /dev/null and b/Godeps/_workspace/src/github.com/PuerkitoBio/ghost/handlers/testdata/favicon.ico differ
diff --git a/Godeps/_workspace/src/github.com/PuerkitoBio/ghost/handlers/testdata/script.js b/Godeps/_workspace/src/github.com/PuerkitoBio/ghost/handlers/testdata/script.js
new file mode 100644
index 0000000000000000000000000000000000000000..6fcc9b95f027588967798c4dd06b60de8205eaf4
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/PuerkitoBio/ghost/handlers/testdata/script.js
@@ -0,0 +1 @@
+var a = 0;
diff --git a/Godeps/_workspace/src/github.com/PuerkitoBio/ghost/handlers/testdata/styles.css b/Godeps/_workspace/src/github.com/PuerkitoBio/ghost/handlers/testdata/styles.css
new file mode 100644
index 0000000000000000000000000000000000000000..616bdba691a11f63d3ce92ab1736b452b31fa6be
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/PuerkitoBio/ghost/handlers/testdata/styles.css
@@ -0,0 +1,3 @@
+* {
+ background-color: white;
+}
\ No newline at end of file
diff --git a/Godeps/_workspace/src/github.com/PuerkitoBio/ghost/handlers/utils_test.go b/Godeps/_workspace/src/github.com/PuerkitoBio/ghost/handlers/utils_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..d7a79b339f722f8d6d1c49a0915fa155e7cac46d
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/PuerkitoBio/ghost/handlers/utils_test.go
@@ -0,0 +1,68 @@
+package handlers
+
+import (
+ "bytes"
+ "compress/gzip"
+ "io"
+ "io/ioutil"
+ "net/http"
+ "testing"
+)
+
+func assertTrue(cond bool, msg string, t *testing.T) bool {
+ if !cond {
+ t.Error(msg)
+ return false
+ }
+ return true
+}
+
+func assertStatus(ex, ac int, t *testing.T) {
+ if ex != ac {
+ t.Errorf("expected status code to be %d, got %d", ex, ac)
+ }
+}
+
+func assertBody(ex []byte, res *http.Response, t *testing.T) {
+ buf, err := ioutil.ReadAll(res.Body)
+ if err != nil {
+ panic(err)
+ }
+ defer res.Body.Close()
+
+ if !bytes.Equal(ex, buf) {
+ t.Errorf("expected body to be '%s' (%d), got '%s' (%d)", ex, len(ex), buf, len(buf))
+ }
+}
+
+func assertGzippedBody(ex []byte, res *http.Response, t *testing.T) {
+ gr, err := gzip.NewReader(res.Body)
+ if err != nil {
+ panic(err)
+ }
+ defer res.Body.Close()
+
+ buf := bytes.NewBuffer(nil)
+ _, err = io.Copy(buf, gr)
+ if err != nil {
+ panic(err)
+ }
+ if !bytes.Equal(ex, buf.Bytes()) {
+ t.Errorf("expected unzipped body to be '%s' (%d), got '%s' (%d)", ex, len(ex), buf.Bytes(), buf.Len())
+ }
+}
+
+func assertHeader(hName, ex string, res *http.Response, t *testing.T) {
+ hVal, ok := res.Header[hName]
+ if (!ok || len(hVal) == 0) && len(ex) > 0 {
+ t.Errorf("expected header %s to be %s, was not set", hName, ex)
+ } else if len(hVal) > 0 && hVal[0] != ex {
+ t.Errorf("expected header %s to be %s, got %s", hName, ex, hVal)
+ }
+}
+
+func assertPanic(t *testing.T) {
+ if err := recover(); err == nil {
+ t.Error("expected a panic, got none")
+ }
+}
diff --git a/Godeps/_workspace/src/github.com/PuerkitoBio/ghost/tags b/Godeps/_workspace/src/github.com/PuerkitoBio/ghost/tags
new file mode 100644
index 0000000000000000000000000000000000000000..6ea162cabb1aa40859806555274741afa05ab58b
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/PuerkitoBio/ghost/tags
@@ -0,0 +1,203 @@
+!_TAG_FILE_FORMAT 2 /extended format; --format=1 will not append ;" to lines/
+!_TAG_FILE_SORTED 1 /0=unsorted, 1=sorted, 2=foldcase/
+!_TAG_PROGRAM_AUTHOR Darren Hiebert /dhiebert@users.sourceforge.net/
+!_TAG_PROGRAM_NAME Exuberant Ctags //
+!_TAG_PROGRAM_URL http://ctags.sourceforge.net /official site/
+!_TAG_PROGRAM_VERSION 5.8 //
+AmberCompiler templates/amber/amber.go /^type AmberCompiler struct {$/;" t
+BadRequest handlers/basicauth.go /^func BadRequest(w http.ResponseWriter, msg string) {$/;" f
+BasicAuthHandler handlers/basicauth.go /^func BasicAuthHandler(h http.Handler,$/;" f
+BasicAuthHandlerFunc handlers/basicauth.go /^func BasicAuthHandlerFunc(h http.HandlerFunc,$/;" f
+Chain handlers/chain.go /^func (this *chainHandler) Chain(h http.Handler) ChainableHandler {$/;" f
+ChainFunc handlers/chain.go /^func (this *chainHandler) ChainFunc(h http.HandlerFunc) ChainableHandler {$/;" f
+ChainHandlerFuncs handlers/chain.go /^func ChainHandlerFuncs(h ...http.HandlerFunc) ChainableHandler {$/;" f
+ChainHandlers handlers/chain.go /^func ChainHandlers(h ...http.Handler) ChainableHandler {$/;" f
+ChainableHandler handlers/chain.go /^type ChainableHandler interface {$/;" t
+Clear handlers/redisstore.go /^func (this *RedisStore) Clear() error {$/;" f
+Clear handlers/sstore.go /^func (this *MemoryStore) Clear() error {$/;" f
+Compile templates/amber/amber.go /^func (this *AmberCompiler) Compile(f string) (templates.Templater, error) {$/;" f
+Compile templates/gotpl/gotpl.go /^func (this *GoTemplateCompiler) Compile(f string) (templates.Templater, error) {$/;" f
+Compile templates/template.go /^func Compile(path, base string) error {$/;" f
+CompileDir templates/template.go /^func CompileDir(dir string) error {$/;" f
+Context handlers/ghost.go /^func (this *ghostWriter) Context() map[interface{}]interface{} {$/;" f
+ContextHandler handlers/context.go /^func ContextHandler(h http.Handler, cap int) http.HandlerFunc {$/;" f
+ContextHandlerFunc handlers/context.go /^func ContextHandlerFunc(h http.HandlerFunc, cap int) http.HandlerFunc {$/;" f
+Created handlers/session.go /^func (ø *Session) Created() time.Time {$/;" f
+Delete handlers/redisstore.go /^func (this *RedisStore) Delete(id string) error {$/;" f
+Delete handlers/sstore.go /^func (this *MemoryStore) Delete(id string) error {$/;" f
+Execute templates/template.go /^func Execute(tplName string, w io.Writer, data interface{}) error {$/;" f
+FaviconHandler handlers/favicon.go /^func FaviconHandler(h http.Handler, path string, maxAge time.Duration) http.HandlerFunc {$/;" f
+FaviconHandlerFunc handlers/favicon.go /^func FaviconHandlerFunc(h http.HandlerFunc, path string, maxAge time.Duration) http.HandlerFunc {$/;" f
+GZIPHandler handlers/gzip.go /^func GZIPHandler(h http.Handler, filterFn func(http.ResponseWriter, *http.Request) bool) http.HandlerFunc {$/;" f
+GZIPHandlerFunc handlers/gzip.go /^func GZIPHandlerFunc(h http.HandlerFunc, filterFn func(http.ResponseWriter, *http.Request) bool) http.HandlerFunc {$/;" f
+Get handlers/redisstore.go /^func (this *RedisStore) Get(id string) (*Session, error) {$/;" f
+Get handlers/sstore.go /^func (this *MemoryStore) Get(id string) (*Session, error) {$/;" f
+GetContext handlers/context.go /^func GetContext(w http.ResponseWriter) (map[interface{}]interface{}, bool) {$/;" f
+GetPanicError handlers/panic.go /^func GetPanicError(w http.ResponseWriter) (interface{}, bool) {$/;" f
+GetResponseWriter handlers/reswriter.go /^func GetResponseWriter(w http.ResponseWriter,$/;" f
+GetSession handlers/session.go /^func GetSession(w http.ResponseWriter) (*Session, bool) {$/;" f
+GetSessionStore handlers/session.go /^func GetSessionStore(w http.ResponseWriter) (SessionStore, bool) {$/;" f
+GetUser handlers/basicauth.go /^func GetUser(w http.ResponseWriter) (interface{}, bool) {$/;" f
+GetUserName handlers/basicauth.go /^func GetUserName(w http.ResponseWriter) (string, bool) {$/;" f
+GhostHandlerFunc handlers/ghost.go /^func GhostHandlerFunc(h func(w GhostWriter, r *http.Request)) http.HandlerFunc {$/;" f
+GhostWriter handlers/ghost.go /^type GhostWriter interface {$/;" t
+GoTemplateCompiler templates/gotpl/gotpl.go /^type GoTemplateCompiler struct{}$/;" t
+Header handlers/reswriter_test.go /^func (b *baseWriter) Header() http.Header { return nil }$/;" f
+HeaderMatch handlers/header.go /^func HeaderMatch(hdr http.Header, nm string, matchType HeaderMatchType, test string) bool {$/;" f
+HeaderMatchType handlers/header.go /^type HeaderMatchType int$/;" t
+ID handlers/session.go /^func (ø *Session) ID() string {$/;" f
+IsNew handlers/session.go /^func (ø *Session) IsNew() bool {$/;" f
+Len handlers/redisstore.go /^func (this *RedisStore) Len() int {$/;" f
+Len handlers/sstore.go /^func (this *MemoryStore) Len() int {$/;" f
+LogFn app.go /^var LogFn = log.Printf$/;" v
+LogHandler handlers/log.go /^func LogHandler(h http.Handler, opts *LogOptions) http.HandlerFunc {$/;" f
+LogHandlerFunc handlers/log.go /^func LogHandlerFunc(h http.HandlerFunc, opts *LogOptions) http.HandlerFunc {$/;" f
+LogOptions handlers/log.go /^type LogOptions struct {$/;" t
+MarshalJSON handlers/session.go /^func (ø *Session) MarshalJSON() ([]byte, error) {$/;" f
+MaxAge handlers/session.go /^func (ø *Session) MaxAge() time.Duration {$/;" f
+MemoryStore handlers/sstore.go /^type MemoryStore struct {$/;" t
+NewAmberCompiler templates/amber/amber.go /^func NewAmberCompiler(opts amber.Options) *AmberCompiler {$/;" f
+NewChainableHandler handlers/chain.go /^func NewChainableHandler(h http.Handler) ChainableHandler {$/;" f
+NewLogOptions handlers/log.go /^func NewLogOptions(l func(string, ...interface{}), ft string, tok ...string) *LogOptions {$/;" f
+NewMemoryStore handlers/sstore.go /^func NewMemoryStore(capc int) *MemoryStore {$/;" f
+NewRedisStore handlers/redisstore.go /^func NewRedisStore(opts *RedisStoreOptions) *RedisStore {$/;" f
+NewSessionOptions handlers/session.go /^func NewSessionOptions(store SessionStore, secret string) *SessionOptions {$/;" f
+PanicHandler handlers/panic.go /^func PanicHandler(h http.Handler, errH http.Handler) http.HandlerFunc {$/;" f
+PanicHandlerFunc handlers/panic.go /^func PanicHandlerFunc(h http.HandlerFunc, errH http.HandlerFunc) http.HandlerFunc {$/;" f
+RedisStore handlers/redisstore.go /^type RedisStore struct {$/;" t
+RedisStoreOptions handlers/redisstore.go /^type RedisStoreOptions struct {$/;" t
+Register templates/template.go /^func Register(ext string, c TemplateCompiler) {$/;" f
+Render templates/template.go /^func Render(tplName string, w http.ResponseWriter, data interface{}) (err error) {$/;" f
+Session handlers/ghost.go /^func (this *ghostWriter) Session() *Session {$/;" f
+Session handlers/session.go /^type Session struct {$/;" t
+SessionHandler handlers/session.go /^func SessionHandler(h http.Handler, opts *SessionOptions) http.HandlerFunc {$/;" f
+SessionHandlerFunc handlers/session.go /^func SessionHandlerFunc(h http.HandlerFunc, opts *SessionOptions) http.HandlerFunc {$/;" f
+SessionOptions handlers/session.go /^type SessionOptions struct {$/;" t
+SessionStore handlers/sstore.go /^type SessionStore interface {$/;" t
+Set handlers/redisstore.go /^func (this *RedisStore) Set(sess *Session) error {$/;" f
+Set handlers/sstore.go /^func (this *MemoryStore) Set(sess *Session) error {$/;" f
+StaticFileHandler handlers/static.go /^func StaticFileHandler(path string) http.HandlerFunc {$/;" f
+TemplateCompiler templates/template.go /^type TemplateCompiler interface {$/;" t
+Templater templates/template.go /^type Templater interface {$/;" t
+TestBaseWriter handlers/reswriter_test.go /^func TestBaseWriter(t *testing.T) {$/;" f
+TestChaining handlers/chain_test.go /^func TestChaining(t *testing.T) {$/;" f
+TestChainingMixed handlers/chain_test.go /^func TestChainingMixed(t *testing.T) {$/;" f
+TestChainingWithHelperFunc handlers/chain_test.go /^func TestChainingWithHelperFunc(t *testing.T) {$/;" f
+TestContext handlers/context_test.go /^func TestContext(t *testing.T) {$/;" f
+TestCustom handlers/log_test.go /^func TestCustom(t *testing.T) {$/;" f
+TestFavicon handlers/favicon_test.go /^func TestFavicon(t *testing.T) {$/;" f
+TestFaviconFromCache handlers/favicon_test.go /^func TestFaviconFromCache(t *testing.T) {$/;" f
+TestFaviconInvalidPath handlers/favicon_test.go /^func TestFaviconInvalidPath(t *testing.T) {$/;" f
+TestGzipOnCustomFilter handlers/gzip_test.go /^func TestGzipOnCustomFilter(t *testing.T) {$/;" f
+TestGzipOuterPanic handlers/gzip_test.go /^func TestGzipOuterPanic(t *testing.T) {$/;" f
+TestGzipped handlers/gzip_test.go /^func TestGzipped(t *testing.T) {$/;" f
+TestGzippedAuth handlers/basicauth_test.go /^func TestGzippedAuth(t *testing.T) {$/;" f
+TestGzippedFile handlers/static_test.go /^func TestGzippedFile(t *testing.T) {$/;" f
+TestImmediate handlers/log_test.go /^func TestImmediate(t *testing.T) {$/;" f
+TestLog handlers/log_test.go /^func TestLog(t *testing.T) {$/;" f
+TestNilWriter handlers/reswriter_test.go /^func TestNilWriter(t *testing.T) {$/;" f
+TestNoGzip handlers/gzip_test.go /^func TestNoGzip(t *testing.T) {$/;" f
+TestNoGzipOnCustomFilter handlers/gzip_test.go /^func TestNoGzipOnCustomFilter(t *testing.T) {$/;" f
+TestNoGzipOnFilter handlers/gzip_test.go /^func TestNoGzipOnFilter(t *testing.T) {$/;" f
+TestNoPanic handlers/panic_test.go /^func TestNoPanic(t *testing.T) {$/;" f
+TestPanic handlers/panic_test.go /^func TestPanic(t *testing.T) {$/;" f
+TestPanicCustom handlers/panic_test.go /^func TestPanicCustom(t *testing.T) {$/;" f
+TestServeFile handlers/static_test.go /^func TestServeFile(t *testing.T) {$/;" f
+TestSession handlers/session_test.go /^func TestSession(t *testing.T) {$/;" f
+TestUnauth handlers/basicauth_test.go /^func TestUnauth(t *testing.T) {$/;" f
+TestWrappedContext handlers/context_test.go /^func TestWrappedContext(t *testing.T) {$/;" f
+TestWrappedNotFoundWriter handlers/reswriter_test.go /^func TestWrappedNotFoundWriter(t *testing.T) {$/;" f
+TestWrappedWriter handlers/reswriter_test.go /^func TestWrappedWriter(t *testing.T) {$/;" f
+Unauthorized handlers/basicauth.go /^func Unauthorized(w http.ResponseWriter, realm string) {$/;" f
+UnmarshalJSON handlers/session.go /^func (ø *Session) UnmarshalJSON(b []byte) error {$/;" f
+User handlers/ghost.go /^func (this *ghostWriter) User() interface{} {$/;" f
+UserName handlers/ghost.go /^func (this *ghostWriter) UserName() string {$/;" f
+WrapWriter handlers/reswriter.go /^type WrapWriter interface {$/;" t
+WrappedWriter handlers/basicauth.go /^func (this *userResponseWriter) WrappedWriter() http.ResponseWriter {$/;" f
+WrappedWriter handlers/context.go /^func (this *contextResponseWriter) WrappedWriter() http.ResponseWriter {$/;" f
+WrappedWriter handlers/gzip.go /^func (w *gzipResponseWriter) WrappedWriter() http.ResponseWriter {$/;" f
+WrappedWriter handlers/log.go /^func (this *statusResponseWriter) WrappedWriter() http.ResponseWriter {$/;" f
+WrappedWriter handlers/panic.go /^func (this *errResponseWriter) WrappedWriter() http.ResponseWriter {$/;" f
+WrappedWriter handlers/session.go /^func (ø *sessResponseWriter) WrappedWriter() http.ResponseWriter {$/;" f
+Write handlers/gzip.go /^func (w *gzipResponseWriter) Write(b []byte) (int, error) {$/;" f
+Write handlers/log.go /^func (this *statusResponseWriter) Write(data []byte) (int, error) {$/;" f
+Write handlers/reswriter_test.go /^func (b *baseWriter) Write(data []byte) (int, error) { return 0, nil }$/;" f
+Write handlers/session.go /^func (ø *sessResponseWriter) Write(data []byte) (int, error) {$/;" f
+WriteHeader handlers/gzip.go /^func (w *gzipResponseWriter) WriteHeader(code int) {$/;" f
+WriteHeader handlers/log.go /^func (this *statusResponseWriter) WriteHeader(code int) {$/;" f
+WriteHeader handlers/reswriter_test.go /^func (b *baseWriter) WriteHeader(code int) {}$/;" f
+WriteHeader handlers/session.go /^func (ø *sessResponseWriter) WriteHeader(code int) {$/;" f
+a handlers/testdata/script.js /^var a = 0;$/;" v
+acceptsGzip handlers/gzip.go /^func acceptsGzip(hdr http.Header) bool {$/;" f
+applyFilter handlers/gzip.go /^func (w *gzipResponseWriter) applyFilter() {$/;" f
+assertBody handlers/utils_test.go /^func assertBody(ex []byte, res *http.Response, t *testing.T) {$/;" f
+assertGzippedBody handlers/utils_test.go /^func assertGzippedBody(ex []byte, res *http.Response, t *testing.T) {$/;" f
+assertHeader handlers/utils_test.go /^func assertHeader(hName, ex string, res *http.Response, t *testing.T) {$/;" f
+assertPanic handlers/utils_test.go /^func assertPanic(t *testing.T) {$/;" f
+assertStatus handlers/utils_test.go /^func assertStatus(ex, ac int, t *testing.T) {$/;" f
+assertTrue handlers/utils_test.go /^func assertTrue(cond bool, msg string, t *testing.T) bool {$/;" f
+authenticate ghostest/main.go /^func authenticate(u, p string) (interface{}, bool) {$/;" f
+baseWriter handlers/reswriter_test.go /^type baseWriter struct{}$/;" t
+buf handlers/chain_test.go /^ var buf bytes.Buffer$/;" v
+buf handlers/favicon.go /^ var buf []byte$/;" v
+chainHandler handlers/chain.go /^type chainHandler struct {$/;" t
+ckSessId handlers/session.go /^ var ckSessId string$/;" v
+compileTemplate templates/template.go /^func compileTemplate(p, base string) error {$/;" f
+contextResponseWriter handlers/context.go /^type contextResponseWriter struct {$/;" t
+defaultFilter handlers/gzip.go /^func defaultFilter(w http.ResponseWriter, r *http.Request) bool {$/;" f
+doRequest handlers/session_test.go /^func doRequest(u string, newJar bool) *http.Response {$/;" f
+err handlers/favicon.go /^ var err error$/;" v
+err handlers/redisstore.go /^ var err error$/;" v
+err handlers/session_test.go /^ var err error$/;" v
+errResponseWriter handlers/panic.go /^type errResponseWriter struct {$/;" t
+fn.init ghostest/public/jquery-2.0.0.min.js /^(function(e,undefined){var t,n,r=typeof undefined,i=e.location,o=e.document,s=o.documentElement,a=e.jQuery,u=e.$,l={},c=[],f="2.0.0",p=c.concat,h=c.push,d=c.slice,g=c.indexOf,m=l.toString,y=l.hasOwnProperty,v=f.trim,x=function(e,n){return new x.fn.init(e,n,t)},b=\/[+-]?(?:\\d*\\.|)\\d+(?:[eE][+-]?\\d+|)\/.source,w=\/\\S+\/g,T=\/^(?:(<[\\w\\W]+>)[^>]*|#([\\w-]*))$\/,C=\/^<(\\w+)\\s*\\\/?>(?:<\\\/\\1>|)$\/,k=\/^-ms-\/,N=\/-([\\da-z])\/gi,E=function(e,t){return t.toUpperCase()},S=function(){o.removeEventListener("DOMContentLoaded",S,!1),e.removeEventListener("load",S,!1),x.ready()};x.fn=x.prototype={jquery:f,constructor:x,init:function(e,t,n){var r,i;if(!e)return this;if("string"==typeof e){if(r="<"===e.charAt(0)&&">"===e.charAt(e.length-1)&&e.length>=3?[null,e,null]:T.exec(e),!r||!r[1]&&t)return!t||t.jquery?(t||n).find(e):this.constructor(t).find(e);if(r[1]){if(t=t instanceof x?t[0]:t,x.merge(this,x.parseHTML(r[1],t&&t.nodeType?t.ownerDocument||t:o,!0)),C.test(r[1])&&x.isPlainObject(t))for(r in t)x.isFunction(this[r])?this[r](t[r]):this.attr(r,t[r]);return this}return i=o.getElementById(r[2]),i&&i.parentNode&&(this.length=1,this[0]=i),this.context=o,this.selector=e,this}return e.nodeType?(this.context=this[0]=e,this.length=1,this):x.isFunction(e)?n.ready(e):(e.selector!==undefined&&(this.selector=e.selector,this.context=e.context),x.makeArray(e,this))},selector:"",length:0,toArray:function(){return d.call(this)},get:function(e){return null==e?this.toArray():0>e?this[this.length+e]:this[e]},pushStack:function(e){var t=x.merge(this.constructor(),e);return t.prevObject=this,t.context=this.context,t},each:function(e,t){return x.each(this,e,t)},ready:function(e){return x.ready.promise().done(e),this},slice:function(){return this.pushStack(d.apply(this,arguments))},first:function(){return this.eq(0)},last:function(){return this.eq(-1)},eq:function(e){var t=this.length,n=+e+(0>e?t:0);return this.pushStack(n>=0&&t>n?[this[n]]:[])},map:function(e){return this.pushStack(x.map(this,function(t,n){return e.call(t,n,t)}))},end:function(){return this.prevObject||this.constructor(null)},push:h,sort:[].sort,splice:[].splice},x.fn.init.prototype=x.fn,x.extend=x.fn.extend=function(){var e,t,n,r,i,o,s=arguments[0]||{},a=1,u=arguments.length,l=!1;for("boolean"==typeof s&&(l=s,s=arguments[1]||{},a=2),"object"==typeof s||x.isFunction(s)||(s={}),u===a&&(s=this,--a);u>a;a++)if(null!=(e=arguments[a]))for(t in e)n=s[t],r=e[t],s!==r&&(l&&r&&(x.isPlainObject(r)||(i=x.isArray(r)))?(i?(i=!1,o=n&&x.isArray(n)?n:[]):o=n&&x.isPlainObject(n)?n:{},s[t]=x.extend(l,o,r)):r!==undefined&&(s[t]=r));return s},x.extend({expando:"jQuery"+(f+Math.random()).replace(\/\\D\/g,""),noConflict:function(t){return e.$===x&&(e.$=u),t&&e.jQuery===x&&(e.jQuery=a),x},isReady:!1,readyWait:1,holdReady:function(e){e?x.readyWait++:x.ready(!0)},ready:function(e){(e===!0?--x.readyWait:x.isReady)||(x.isReady=!0,e!==!0&&--x.readyWait>0||(n.resolveWith(o,[x]),x.fn.trigger&&x(o).trigger("ready").off("ready")))},isFunction:function(e){return"function"===x.type(e)},isArray:Array.isArray,isWindow:function(e){return null!=e&&e===e.window},isNumeric:function(e){return!isNaN(parseFloat(e))&&isFinite(e)},type:function(e){return null==e?e+"":"object"==typeof e||"function"==typeof e?l[m.call(e)]||"object":typeof e},isPlainObject:function(e){if("object"!==x.type(e)||e.nodeType||x.isWindow(e))return!1;try{if(e.constructor&&!y.call(e.constructor.prototype,"isPrototypeOf"))return!1}catch(t){return!1}return!0},isEmptyObject:function(e){var t;for(t in e)return!1;return!0},error:function(e){throw Error(e)},parseHTML:function(e,t,n){if(!e||"string"!=typeof e)return null;"boolean"==typeof t&&(n=t,t=!1),t=t||o;var r=C.exec(e),i=!n&&[];return r?[t.createElement(r[1])]:(r=x.buildFragment([e],t,i),i&&x(i).remove(),x.merge([],r.childNodes))},parseJSON:JSON.parse,parseXML:function(e){var t,n;if(!e||"string"!=typeof e)return null;try{n=new DOMParser,t=n.parseFromString(e,"text\/xml")}catch(r){t=undefined}return(!t||t.getElementsByTagName("parsererror").length)&&x.error("Invalid XML: "+e),t},noop:function(){},globalEval:function(e){var t,n=eval;e=x.trim(e),e&&(1===e.indexOf("use strict")?(t=o.createElement("script"),t.text=e,o.head.appendChild(t).parentNode.removeChild(t)):n(e))},camelCase:function(e){return e.replace(k,"ms-").replace(N,E)},nodeName:function(e,t){return e.nodeName&&e.nodeName.toLowerCase()===t.toLowerCase()},each:function(e,t,n){var r,i=0,o=e.length,s=j(e);if(n){if(s){for(;o>i;i++)if(r=t.apply(e[i],n),r===!1)break}else for(i in e)if(r=t.apply(e[i],n),r===!1)break}else if(s){for(;o>i;i++)if(r=t.call(e[i],i,e[i]),r===!1)break}else for(i in e)if(r=t.call(e[i],i,e[i]),r===!1)break;return e},trim:function(e){return null==e?"":v.call(e)},makeArray:function(e,t){var n=t||[];return null!=e&&(j(Object(e))?x.merge(n,"string"==typeof e?[e]:e):h.call(n,e)),n},inArray:function(e,t,n){return null==t?-1:g.call(t,e,n)},merge:function(e,t){var n=t.length,r=e.length,i=0;if("number"==typeof n)for(;n>i;i++)e[r++]=t[i];else while(t[i]!==undefined)e[r++]=t[i++];return e.length=r,e},grep:function(e,t,n){var r,i=[],o=0,s=e.length;for(n=!!n;s>o;o++)r=!!t(e[o],o),n!==r&&i.push(e[o]);return i},map:function(e,t,n){var r,i=0,o=e.length,s=j(e),a=[];if(s)for(;o>i;i++)r=t(e[i],i,n),null!=r&&(a[a.length]=r);else for(i in e)r=t(e[i],i,n),null!=r&&(a[a.length]=r);return p.apply([],a)},guid:1,proxy:function(e,t){var n,r,i;return"string"==typeof t&&(n=e[t],t=e,e=n),x.isFunction(e)?(r=d.call(arguments,2),i=function(){return e.apply(t||this,r.concat(d.call(arguments)))},i.guid=e.guid=e.guid||x.guid++,i):undefined},access:function(e,t,n,r,i,o,s){var a=0,u=e.length,l=null==n;if("object"===x.type(n)){i=!0;for(a in n)x.access(e,t,a,n[a],!0,o,s)}else if(r!==undefined&&(i=!0,x.isFunction(r)||(s=!0),l&&(s?(t.call(e,r),t=null):(l=t,t=function(e,t,n){return l.call(x(e),n)})),t))for(;u>a;a++)t(e[a],n,s?r:r.call(e[a],a,t(e[a],n)));return i?e:l?t.call(e):u?t(e[0],n):o},now:Date.now,swap:function(e,t,n,r){var i,o,s={};for(o in t)s[o]=e.style[o],e.style[o]=t[o];i=n.apply(e,r||[]);for(o in t)e.style[o]=s[o];return i}}),x.ready.promise=function(t){return n||(n=x.Deferred(),"complete"===o.readyState?setTimeout(x.ready):(o.addEventListener("DOMContentLoaded",S,!1),e.addEventListener("load",S,!1))),n.promise(t)},x.each("Boolean Number String Function Array Date RegExp Object Error".split(" "),function(e,t){l["[object "+t+"]"]=t.toLowerCase()});function j(e){var t=e.length,n=x.type(e);return x.isWindow(e)?!1:1===e.nodeType&&t?!0:"array"===n||"function"!==n&&(0===t||"number"==typeof t&&t>0&&t-1 in e)}t=x(o),function(e,undefined){var t,n,r,i,o,s,a,u,l,c,f,p,h,d,g,m,y="sizzle"+-new Date,v=e.document,b={},w=0,T=0,C=ot(),k=ot(),N=ot(),E=!1,S=function(){return 0},j=typeof undefined,D=1<<31,A=[],L=A.pop,q=A.push,H=A.push,O=A.slice,F=A.indexOf||function(e){var t=0,n=this.length;for(;n>t;t++)if(this[t]===e)return t;return-1},P="checked|selected|async|autofocus|autoplay|controls|defer|disabled|hidden|ismap|loop|multiple|open|readonly|required|scoped",R="[\\\\x20\\\\t\\\\r\\\\n\\\\f]",M="(?:\\\\\\\\.|[\\\\w-]|[^\\\\x00-\\\\xa0])+",W=M.replace("w","w#"),$="\\\\["+R+"*("+M+")"+R+"*(?:([*^$|!~]?=)"+R+"*(?:(['\\"])((?:\\\\\\\\.|[^\\\\\\\\])*?)\\\\3|("+W+")|)|)"+R+"*\\\\]",B=":("+M+")(?:\\\\(((['\\"])((?:\\\\\\\\.|[^\\\\\\\\])*?)\\\\3|((?:\\\\\\\\.|[^\\\\\\\\()[\\\\]]|"+$.replace(3,8)+")*)|.*)\\\\)|)",I=RegExp("^"+R+"+|((?:^|[^\\\\\\\\])(?:\\\\\\\\.)*)"+R+"+$","g"),z=RegExp("^"+R+"*,"+R+"*"),_=RegExp("^"+R+"*([>+~]|"+R+")"+R+"*"),X=RegExp(R+"*[+~]"),U=RegExp("="+R+"*([^\\\\]'\\"]*)"+R+"*\\\\]","g"),Y=RegExp(B),V=RegExp("^"+W+"$"),G={ID:RegExp("^#("+M+")"),CLASS:RegExp("^\\\\.("+M+")"),TAG:RegExp("^("+M.replace("w","w*")+")"),ATTR:RegExp("^"+$),PSEUDO:RegExp("^"+B),CHILD:RegExp("^:(only|first|last|nth|nth-last)-(child|of-type)(?:\\\\("+R+"*(even|odd|(([+-]|)(\\\\d*)n|)"+R+"*(?:([+-]|)"+R+"*(\\\\d+)|))"+R+"*\\\\)|)","i"),"boolean":RegExp("^(?:"+P+")$","i"),needsContext:RegExp("^"+R+"*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\\\\("+R+"*((?:-\\\\d)?\\\\d*)"+R+"*\\\\)|)(?=[^-]|$)","i")},J=\/^[^{]+\\{\\s*\\[native \\w\/,Q=\/^(?:#([\\w-]+)|(\\w+)|\\.([\\w-]+))$\/,K=\/^(?:input|select|textarea|button)$\/i,Z=\/^h\\d$\/i,et=\/'|\\\\\/g,tt=\/\\\\([\\da-fA-F]{1,6}[\\x20\\t\\r\\n\\f]?|.)\/g,nt=function(e,t){var n="0x"+t-65536;return n!==n?t:0>n?String.fromCharCode(n+65536):String.fromCharCode(55296|n>>10,56320|1023&n)};try{H.apply(A=O.call(v.childNodes),v.childNodes),A[v.childNodes.length].nodeType}catch(rt){H={apply:A.length?function(e,t){q.apply(e,O.call(t))}:function(e,t){var n=e.length,r=0;while(e[n++]=t[r++]);e.length=n-1}}}function it(e){return J.test(e+"")}function ot(){var e,t=[];return e=function(n,i){return t.push(n+=" ")>r.cacheLength&&delete e[t.shift()],e[n]=i}}function st(e){return e[y]=!0,e}function at(e){var t=c.createElement("div");try{return!!e(t)}catch(n){return!1}finally{t.parentNode&&t.parentNode.removeChild(t),t=null}}function ut(e,t,n,r){var i,o,s,a,u,f,d,g,x,w;if((t?t.ownerDocument||t:v)!==c&&l(t),t=t||c,n=n||[],!e||"string"!=typeof e)return n;if(1!==(a=t.nodeType)&&9!==a)return[];if(p&&!r){if(i=Q.exec(e))if(s=i[1]){if(9===a){if(o=t.getElementById(s),!o||!o.parentNode)return n;if(o.id===s)return n.push(o),n}else if(t.ownerDocument&&(o=t.ownerDocument.getElementById(s))&&m(t,o)&&o.id===s)return n.push(o),n}else{if(i[2])return H.apply(n,t.getElementsByTagName(e)),n;if((s=i[3])&&b.getElementsByClassName&&t.getElementsByClassName)return H.apply(n,t.getElementsByClassName(s)),n}if(b.qsa&&(!h||!h.test(e))){if(g=d=y,x=t,w=9===a&&e,1===a&&"object"!==t.nodeName.toLowerCase()){f=gt(e),(d=t.getAttribute("id"))?g=d.replace(et,"\\\\$&"):t.setAttribute("id",g),g="[id='"+g+"'] ",u=f.length;while(u--)f[u]=g+mt(f[u]);x=X.test(e)&&t.parentNode||t,w=f.join(",")}if(w)try{return H.apply(n,x.querySelectorAll(w)),n}catch(T){}finally{d||t.removeAttribute("id")}}}return kt(e.replace(I,"$1"),t,n,r)}o=ut.isXML=function(e){var t=e&&(e.ownerDocument||e).documentElement;return t?"HTML"!==t.nodeName:!1},l=ut.setDocument=function(e){var t=e?e.ownerDocument||e:v;return t!==c&&9===t.nodeType&&t.documentElement?(c=t,f=t.documentElement,p=!o(t),b.getElementsByTagName=at(function(e){return e.appendChild(t.createComment("")),!e.getElementsByTagName("*").length}),b.attributes=at(function(e){return e.className="i",!e.getAttribute("className")}),b.getElementsByClassName=at(function(e){return e.innerHTML="<div class='a'><\/div><div class='a i'><\/div>",e.firstChild.className="i",2===e.getElementsByClassName("i").length}),b.sortDetached=at(function(e){return 1&e.compareDocumentPosition(c.createElement("div"))}),b.getById=at(function(e){return f.appendChild(e).id=y,!t.getElementsByName||!t.getElementsByName(y).length}),b.getById?(r.find.ID=function(e,t){if(typeof t.getElementById!==j&&p){var n=t.getElementById(e);return n&&n.parentNode?[n]:[]}},r.filter.ID=function(e){var t=e.replace(tt,nt);return function(e){return e.getAttribute("id")===t}}):(r.find.ID=function(e,t){if(typeof t.getElementById!==j&&p){var n=t.getElementById(e);return n?n.id===e||typeof n.getAttributeNode!==j&&n.getAttributeNode("id").value===e?[n]:undefined:[]}},r.filter.ID=function(e){var t=e.replace(tt,nt);return function(e){var n=typeof e.getAttributeNode!==j&&e.getAttributeNode("id");return n&&n.value===t}}),r.find.TAG=b.getElementsByTagName?function(e,t){return typeof t.getElementsByTagName!==j?t.getElementsByTagName(e):undefined}:function(e,t){var n,r=[],i=0,o=t.getElementsByTagName(e);if("*"===e){while(n=o[i++])1===n.nodeType&&r.push(n);return r}return o},r.find.CLASS=b.getElementsByClassName&&function(e,t){return typeof t.getElementsByClassName!==j&&p?t.getElementsByClassName(e):undefined},d=[],h=[],(b.qsa=it(t.querySelectorAll))&&(at(function(e){e.innerHTML="<select><option selected=''><\/option><\/select>",e.querySelectorAll("[selected]").length||h.push("\\\\["+R+"*(?:value|"+P+")"),e.querySelectorAll(":checked").length||h.push(":checked")}),at(function(e){var t=c.createElement("input");t.setAttribute("type","hidden"),e.appendChild(t).setAttribute("t",""),e.querySelectorAll("[t^='']").length&&h.push("[*^$]="+R+"*(?:''|\\"\\")"),e.querySelectorAll(":enabled").length||h.push(":enabled",":disabled"),e.querySelectorAll("*,:x"),h.push(",.*:")})),(b.matchesSelector=it(g=f.webkitMatchesSelector||f.mozMatchesSelector||f.oMatchesSelector||f.msMatchesSelector))&&at(function(e){b.disconnectedMatch=g.call(e,"div"),g.call(e,"[s!='']:x"),d.push("!=",B)}),h=h.length&&RegExp(h.join("|")),d=d.length&&RegExp(d.join("|")),m=it(f.contains)||f.compareDocumentPosition?function(e,t){var n=9===e.nodeType?e.documentElement:e,r=t&&t.parentNode;return e===r||!(!r||1!==r.nodeType||!(n.contains?n.contains(r):e.compareDocumentPosition&&16&e.compareDocumentPosition(r)))}:function(e,t){if(t)while(t=t.parentNode)if(t===e)return!0;return!1},S=f.compareDocumentPosition?function(e,n){if(e===n)return E=!0,0;var r=n.compareDocumentPosition&&e.compareDocumentPosition&&e.compareDocumentPosition(n);return r?1&r||!b.sortDetached&&n.compareDocumentPosition(e)===r?e===t||m(v,e)?-1:n===t||m(v,n)?1:u?F.call(u,e)-F.call(u,n):0:4&r?-1:1:e.compareDocumentPosition?-1:1}:function(e,n){var r,i=0,o=e.parentNode,s=n.parentNode,a=[e],l=[n];if(e===n)return E=!0,0;if(!o||!s)return e===t?-1:n===t?1:o?-1:s?1:u?F.call(u,e)-F.call(u,n):0;if(o===s)return lt(e,n);r=e;while(r=r.parentNode)a.unshift(r);r=n;while(r=r.parentNode)l.unshift(r);while(a[i]===l[i])i++;return i?lt(a[i],l[i]):a[i]===v?-1:l[i]===v?1:0},c):c},ut.matches=function(e,t){return ut(e,null,null,t)},ut.matchesSelector=function(e,t){if((e.ownerDocument||e)!==c&&l(e),t=t.replace(U,"='$1']"),!(!b.matchesSelector||!p||d&&d.test(t)||h&&h.test(t)))try{var n=g.call(e,t);if(n||b.disconnectedMatch||e.document&&11!==e.document.nodeType)return n}catch(r){}return ut(t,c,null,[e]).length>0},ut.contains=function(e,t){return(e.ownerDocument||e)!==c&&l(e),m(e,t)},ut.attr=function(e,t){(e.ownerDocument||e)!==c&&l(e);var n=r.attrHandle[t.toLowerCase()],i=n&&n(e,t,!p);return i===undefined?b.attributes||!p?e.getAttribute(t):(i=e.getAttributeNode(t))&&i.specified?i.value:null:i},ut.error=function(e){throw Error("Syntax error, unrecognized expression: "+e)},ut.uniqueSort=function(e){var t,n=[],r=0,i=0;if(E=!b.detectDuplicates,u=!b.sortStable&&e.slice(0),e.sort(S),E){while(t=e[i++])t===e[i]&&(r=n.push(i));while(r--)e.splice(n[r],1)}return e};function lt(e,t){var n=t&&e,r=n&&(~t.sourceIndex||D)-(~e.sourceIndex||D);if(r)return r;if(n)while(n=n.nextSibling)if(n===t)return-1;return e?1:-1}function ct(e,t,n){var r;return n?undefined:(r=e.getAttributeNode(t))&&r.specified?r.value:e[t]===!0?t.toLowerCase():null}function ft(e,t,n){var r;return n?undefined:r=e.getAttribute(t,"type"===t.toLowerCase()?1:2)}function pt(e){return function(t){var n=t.nodeName.toLowerCase();return"input"===n&&t.type===e}}function ht(e){return function(t){var n=t.nodeName.toLowerCase();return("input"===n||"button"===n)&&t.type===e}}function dt(e){return st(function(t){return t=+t,st(function(n,r){var i,o=e([],n.length,t),s=o.length;while(s--)n[i=o[s]]&&(n[i]=!(r[i]=n[i]))})})}i=ut.getText=function(e){var t,n="",r=0,o=e.nodeType;if(o){if(1===o||9===o||11===o){if("string"==typeof e.textContent)return e.textContent;for(e=e.firstChild;e;e=e.nextSibling)n+=i(e)}else if(3===o||4===o)return e.nodeValue}else for(;t=e[r];r++)n+=i(t);return n},r=ut.selectors={cacheLength:50,createPseudo:st,match:G,attrHandle:{},find:{},relative:{">":{dir:"parentNode",first:!0}," ":{dir:"parentNode"},"+":{dir:"previousSibling",first:!0},"~":{dir:"previousSibling"}},preFilter:{ATTR:function(e){return e[1]=e[1].replace(tt,nt),e[3]=(e[4]||e[5]||"").replace(tt,nt),"~="===e[2]&&(e[3]=" "+e[3]+" "),e.slice(0,4)},CHILD:function(e){return e[1]=e[1].toLowerCase(),"nth"===e[1].slice(0,3)?(e[3]||ut.error(e[0]),e[4]=+(e[4]?e[5]+(e[6]||1):2*("even"===e[3]||"odd"===e[3])),e[5]=+(e[7]+e[8]||"odd"===e[3])):e[3]&&ut.error(e[0]),e},PSEUDO:function(e){var t,n=!e[5]&&e[2];return G.CHILD.test(e[0])?null:(e[4]?e[2]=e[4]:n&&Y.test(n)&&(t=gt(n,!0))&&(t=n.indexOf(")",n.length-t)-n.length)&&(e[0]=e[0].slice(0,t),e[2]=n.slice(0,t)),e.slice(0,3))}},filter:{TAG:function(e){var t=e.replace(tt,nt).toLowerCase();return"*"===e?function(){return!0}:function(e){return e.nodeName&&e.nodeName.toLowerCase()===t}},CLASS:function(e){var t=C[e+" "];return t||(t=RegExp("(^|"+R+")"+e+"("+R+"|$)"))&&C(e,function(e){return t.test("string"==typeof e.className&&e.className||typeof e.getAttribute!==j&&e.getAttribute("class")||"")})},ATTR:function(e,t,n){return function(r){var i=ut.attr(r,e);return null==i?"!="===t:t?(i+="","="===t?i===n:"!="===t?i!==n:"^="===t?n&&0===i.indexOf(n):"*="===t?n&&i.indexOf(n)>-1:"$="===t?n&&i.slice(-n.length)===n:"~="===t?(" "+i+" ").indexOf(n)>-1:"|="===t?i===n||i.slice(0,n.length+1)===n+"-":!1):!0}},CHILD:function(e,t,n,r,i){var o="nth"!==e.slice(0,3),s="last"!==e.slice(-4),a="of-type"===t;return 1===r&&0===i?function(e){return!!e.parentNode}:function(t,n,u){var l,c,f,p,h,d,g=o!==s?"nextSibling":"previousSibling",m=t.parentNode,v=a&&t.nodeName.toLowerCase(),x=!u&&!a;if(m){if(o){while(g){f=t;while(f=f[g])if(a?f.nodeName.toLowerCase()===v:1===f.nodeType)return!1;d=g="only"===e&&!d&&"nextSibling"}return!0}if(d=[s?m.firstChild:m.lastChild],s&&x){c=m[y]||(m[y]={}),l=c[e]||[],h=l[0]===w&&l[1],p=l[0]===w&&l[2],f=h&&m.childNodes[h];while(f=++h&&f&&f[g]||(p=h=0)||d.pop())if(1===f.nodeType&&++p&&f===t){c[e]=[w,h,p];break}}else if(x&&(l=(t[y]||(t[y]={}))[e])&&l[0]===w)p=l[1];else while(f=++h&&f&&f[g]||(p=h=0)||d.pop())if((a?f.nodeName.toLowerCase()===v:1===f.nodeType)&&++p&&(x&&((f[y]||(f[y]={}))[e]=[w,p]),f===t))break;return p-=i,p===r||0===p%r&&p\/r>=0}}},PSEUDO:function(e,t){var n,i=r.pseudos[e]||r.setFilters[e.toLowerCase()]||ut.error("unsupported pseudo: "+e);return i[y]?i(t):i.length>1?(n=[e,e,"",t],r.setFilters.hasOwnProperty(e.toLowerCase())?st(function(e,n){var r,o=i(e,t),s=o.length;while(s--)r=F.call(e,o[s]),e[r]=!(n[r]=o[s])}):function(e){return i(e,0,n)}):i}},pseudos:{not:st(function(e){var t=[],n=[],r=s(e.replace(I,"$1"));return r[y]?st(function(e,t,n,i){var o,s=r(e,null,i,[]),a=e.length;while(a--)(o=s[a])&&(e[a]=!(t[a]=o))}):function(e,i,o){return t[0]=e,r(t,null,o,n),!n.pop()}}),has:st(function(e){return function(t){return ut(e,t).length>0}}),contains:st(function(e){return function(t){return(t.textContent||t.innerText||i(t)).indexOf(e)>-1}}),lang:st(function(e){return V.test(e||"")||ut.error("unsupported lang: "+e),e=e.replace(tt,nt).toLowerCase(),function(t){var n;do if(n=p?t.lang:t.getAttribute("xml:lang")||t.getAttribute("lang"))return n=n.toLowerCase(),n===e||0===n.indexOf(e+"-");while((t=t.parentNode)&&1===t.nodeType);return!1}}),target:function(t){var n=e.location&&e.location.hash;return n&&n.slice(1)===t.id},root:function(e){return e===f},focus:function(e){return e===c.activeElement&&(!c.hasFocus||c.hasFocus())&&!!(e.type||e.href||~e.tabIndex)},enabled:function(e){return e.disabled===!1},disabled:function(e){return e.disabled===!0},checked:function(e){var t=e.nodeName.toLowerCase();return"input"===t&&!!e.checked||"option"===t&&!!e.selected},selected:function(e){return e.parentNode&&e.parentNode.selectedIndex,e.selected===!0},empty:function(e){for(e=e.firstChild;e;e=e.nextSibling)if(e.nodeName>"@"||3===e.nodeType||4===e.nodeType)return!1;return!0},parent:function(e){return!r.pseudos.empty(e)},header:function(e){return Z.test(e.nodeName)},input:function(e){return K.test(e.nodeName)},button:function(e){var t=e.nodeName.toLowerCase();return"input"===t&&"button"===e.type||"button"===t},text:function(e){var t;return"input"===e.nodeName.toLowerCase()&&"text"===e.type&&(null==(t=e.getAttribute("type"))||t.toLowerCase()===e.type)},first:dt(function(){return[0]}),last:dt(function(e,t){return[t-1]}),eq:dt(function(e,t,n){return[0>n?n+t:n]}),even:dt(function(e,t){var n=0;for(;t>n;n+=2)e.push(n);return e}),odd:dt(function(e,t){var n=1;for(;t>n;n+=2)e.push(n);return e}),lt:dt(function(e,t,n){var r=0>n?n+t:n;for(;--r>=0;)e.push(r);return e}),gt:dt(function(e,t,n){var r=0>n?n+t:n;for(;t>++r;)e.push(r);return e})}};for(t in{radio:!0,checkbox:!0,file:!0,password:!0,image:!0})r.pseudos[t]=pt(t);for(t in{submit:!0,reset:!0})r.pseudos[t]=ht(t);function gt(e,t){var n,i,o,s,a,u,l,c=k[e+" "];if(c)return t?0:c.slice(0);a=e,u=[],l=r.preFilter;while(a){(!n||(i=z.exec(a)))&&(i&&(a=a.slice(i[0].length)||a),u.push(o=[])),n=!1,(i=_.exec(a))&&(n=i.shift(),o.push({value:n,type:i[0].replace(I," ")}),a=a.slice(n.length));for(s in r.filter)!(i=G[s].exec(a))||l[s]&&!(i=l[s](i))||(n=i.shift(),o.push({value:n,type:s,matches:i}),a=a.slice(n.length));if(!n)break}return t?a.length:a?ut.error(e):k(e,u).slice(0)}function mt(e){var t=0,n=e.length,r="";for(;n>t;t++)r+=e[t].value;return r}function yt(e,t,r){var i=t.dir,o=r&&"parentNode"===i,s=T++;return t.first?function(t,n,r){while(t=t[i])if(1===t.nodeType||o)return e(t,n,r)}:function(t,r,a){var u,l,c,f=w+" "+s;if(a){while(t=t[i])if((1===t.nodeType||o)&&e(t,r,a))return!0}else while(t=t[i])if(1===t.nodeType||o)if(c=t[y]||(t[y]={}),(l=c[i])&&l[0]===f){if((u=l[1])===!0||u===n)return u===!0}else if(l=c[i]=[f],l[1]=e(t,r,a)||n,l[1]===!0)return!0}}function vt(e){return e.length>1?function(t,n,r){var i=e.length;while(i--)if(!e[i](t,n,r))return!1;return!0}:e[0]}function xt(e,t,n,r,i){var o,s=[],a=0,u=e.length,l=null!=t;for(;u>a;a++)(o=e[a])&&(!n||n(o,r,i))&&(s.push(o),l&&t.push(a));return s}function bt(e,t,n,r,i,o){return r&&!r[y]&&(r=bt(r)),i&&!i[y]&&(i=bt(i,o)),st(function(o,s,a,u){var l,c,f,p=[],h=[],d=s.length,g=o||Ct(t||"*",a.nodeType?[a]:a,[]),m=!e||!o&&t?g:xt(g,p,e,a,u),y=n?i||(o?e:d||r)?[]:s:m;if(n&&n(m,y,a,u),r){l=xt(y,h),r(l,[],a,u),c=l.length;while(c--)(f=l[c])&&(y[h[c]]=!(m[h[c]]=f))}if(o){if(i||e){if(i){l=[],c=y.length;while(c--)(f=y[c])&&l.push(m[c]=f);i(null,y=[],l,u)}c=y.length;while(c--)(f=y[c])&&(l=i?F.call(o,f):p[c])>-1&&(o[l]=!(s[l]=f))}}else y=xt(y===s?y.splice(d,y.length):y),i?i(null,s,y,u):H.apply(s,y)})}function wt(e){var t,n,i,o=e.length,s=r.relative[e[0].type],u=s||r.relative[" "],l=s?1:0,c=yt(function(e){return e===t},u,!0),f=yt(function(e){return F.call(t,e)>-1},u,!0),p=[function(e,n,r){return!s&&(r||n!==a)||((t=n).nodeType?c(e,n,r):f(e,n,r))}];for(;o>l;l++)if(n=r.relative[e[l].type])p=[yt(vt(p),n)];else{if(n=r.filter[e[l].type].apply(null,e[l].matches),n[y]){for(i=++l;o>i;i++)if(r.relative[e[i].type])break;return bt(l>1&&vt(p),l>1&&mt(e.slice(0,l-1)).replace(I,"$1"),n,i>l&&wt(e.slice(l,i)),o>i&&wt(e=e.slice(i)),o>i&&mt(e))}p.push(n)}return vt(p)}function Tt(e,t){var i=0,o=t.length>0,s=e.length>0,u=function(u,l,f,p,h){var d,g,m,y=[],v=0,x="0",b=u&&[],T=null!=h,C=a,k=u||s&&r.find.TAG("*",h&&l.parentNode||l),N=w+=null==C?1:Math.random()||.1;for(T&&(a=l!==c&&l,n=i);null!=(d=k[x]);x++){if(s&&d){g=0;while(m=e[g++])if(m(d,l,f)){p.push(d);break}T&&(w=N,n=++i)}o&&((d=!m&&d)&&v--,u&&b.push(d))}if(v+=x,o&&x!==v){g=0;while(m=t[g++])m(b,y,l,f);if(u){if(v>0)while(x--)b[x]||y[x]||(y[x]=L.call(p));y=xt(y)}H.apply(p,y),T&&!u&&y.length>0&&v+t.length>1&&ut.uniqueSort(p)}return T&&(w=N,a=C),b};return o?st(u):u}s=ut.compile=function(e,t){var n,r=[],i=[],o=N[e+" "];if(!o){t||(t=gt(e)),n=t.length;while(n--)o=wt(t[n]),o[y]?r.push(o):i.push(o);o=N(e,Tt(i,r))}return o};function Ct(e,t,n){var r=0,i=t.length;for(;i>r;r++)ut(e,t[r],n);return n}function kt(e,t,n,i){var o,a,u,l,c,f=gt(e);if(!i&&1===f.length){if(a=f[0]=f[0].slice(0),a.length>2&&"ID"===(u=a[0]).type&&9===t.nodeType&&p&&r.relative[a[1].type]){if(t=(r.find.ID(u.matches[0].replace(tt,nt),t)||[])[0],!t)return n;e=e.slice(a.shift().value.length)}o=G.needsContext.test(e)?0:a.length;while(o--){if(u=a[o],r.relative[l=u.type])break;if((c=r.find[l])&&(i=c(u.matches[0].replace(tt,nt),X.test(a[0].type)&&t.parentNode||t))){if(a.splice(o,1),e=i.length&&mt(a),!e)return H.apply(n,i),n;break}}}return s(e,f)(i,t,!p,n,X.test(e)),n}r.pseudos.nth=r.pseudos.eq;function Nt(){}Nt.prototype=r.filters=r.pseudos,r.setFilters=new Nt,b.sortStable=y.split("").sort(S).join("")===y,l(),[0,0].sort(S),b.detectDuplicates=E,at(function(e){if(e.innerHTML="<a href='#'><\/a>","#"!==e.firstChild.getAttribute("href")){var t="type|href|height|width".split("|"),n=t.length;while(n--)r.attrHandle[t[n]]=ft}}),at(function(e){if(null!=e.getAttribute("disabled")){var t=P.split("|"),n=t.length;while(n--)r.attrHandle[t[n]]=ct}}),x.find=ut,x.expr=ut.selectors,x.expr[":"]=x.expr.pseudos,x.unique=ut.uniqueSort,x.text=ut.getText,x.isXMLDoc=ut.isXML,x.contains=ut.contains}(e);var D={};function A(e){var t=D[e]={};return x.each(e.match(w)||[],function(e,n){t[n]=!0}),t}x.Callbacks=function(e){e="string"==typeof e?D[e]||A(e):x.extend({},e);var t,n,r,i,o,s,a=[],u=!e.once&&[],l=function(f){for(t=e.memory&&f,n=!0,s=i||0,i=0,o=a.length,r=!0;a&&o>s;s++)if(a[s].apply(f[0],f[1])===!1&&e.stopOnFalse){t=!1;break}r=!1,a&&(u?u.length&&l(u.shift()):t?a=[]:c.disable())},c={add:function(){if(a){var n=a.length;(function s(t){x.each(t,function(t,n){var r=x.type(n);"function"===r?e.unique&&c.has(n)||a.push(n):n&&n.length&&"string"!==r&&s(n)})})(arguments),r?o=a.length:t&&(i=n,l(t))}return this},remove:function(){return a&&x.each(arguments,function(e,t){var n;while((n=x.inArray(t,a,n))>-1)a.splice(n,1),r&&(o>=n&&o--,s>=n&&s--)}),this},has:function(e){return e?x.inArray(e,a)>-1:!(!a||!a.length)},empty:function(){return a=[],o=0,this},disable:function(){return a=u=t=undefined,this},disabled:function(){return!a},lock:function(){return u=undefined,t||c.disable(),this},locked:function(){return!u},fireWith:function(e,t){return t=t||[],t=[e,t.slice?t.slice():t],!a||n&&!u||(r?u.push(t):l(t)),this},fire:function(){return c.fireWith(this,arguments),this},fired:function(){return!!n}};return c},x.extend({Deferred:function(e){var t=[["resolve","done",x.Callbacks("once memory"),"resolved"],["reject","fail",x.Callbacks("once memory"),"rejected"],["notify","progress",x.Callbacks("memory")]],n="pending",r={state:function(){return n},always:function(){return i.done(arguments).fail(arguments),this},then:function(){var e=arguments;return x.Deferred(function(n){x.each(t,function(t,o){var s=o[0],a=x.isFunction(e[t])&&e[t];i[o[1]](function(){var e=a&&a.apply(this,arguments);e&&x.isFunction(e.promise)?e.promise().done(n.resolve).fail(n.reject).progress(n.notify):n[s+"With"](this===r?n.promise():this,a?[e]:arguments)})}),e=null}).promise()},promise:function(e){return null!=e?x.extend(e,r):r}},i={};return r.pipe=r.then,x.each(t,function(e,o){var s=o[2],a=o[3];r[o[1]]=s.add,a&&s.add(function(){n=a},t[1^e][2].disable,t[2][2].lock),i[o[0]]=function(){return i[o[0]+"With"](this===i?r:this,arguments),this},i[o[0]+"With"]=s.fireWith}),r.promise(i),e&&e.call(i,i),i},when:function(e){var t=0,n=d.call(arguments),r=n.length,i=1!==r||e&&x.isFunction(e.promise)?r:0,o=1===i?e:x.Deferred(),s=function(e,t,n){return function(r){t[e]=this,n[e]=arguments.length>1?d.call(arguments):r,n===a?o.notifyWith(t,n):--i||o.resolveWith(t,n)}},a,u,l;if(r>1)for(a=Array(r),u=Array(r),l=Array(r);r>t;t++)n[t]&&x.isFunction(n[t].promise)?n[t].promise().done(s(t,l,n)).fail(o.reject).progress(s(t,u,a)):--i;return i||o.resolveWith(l,n),o.promise()}}),x.support=function(t){var n=o.createElement("input"),r=o.createDocumentFragment(),i=o.createElement("div"),s=o.createElement("select"),a=s.appendChild(o.createElement("option"));return n.type?(n.type="checkbox",t.checkOn=""!==n.value,t.optSelected=a.selected,t.reliableMarginRight=!0,t.boxSizingReliable=!0,t.pixelPosition=!1,n.checked=!0,t.noCloneChecked=n.cloneNode(!0).checked,s.disabled=!0,t.optDisabled=!a.disabled,n=o.createElement("input"),n.value="t",n.type="radio",t.radioValue="t"===n.value,n.setAttribute("checked","t"),n.setAttribute("name","t"),r.appendChild(n),t.checkClone=r.cloneNode(!0).cloneNode(!0).lastChild.checked,t.focusinBubbles="onfocusin"in e,i.style.backgroundClip="content-box",i.cloneNode(!0).style.backgroundClip="",t.clearCloneStyle="content-box"===i.style.backgroundClip,x(function(){var n,r,s="padding:0;margin:0;border:0;display:block;-webkit-box-sizing:content-box;-moz-box-sizing:content-box;box-sizing:content-box",a=o.getElementsByTagName("body")[0];a&&(n=o.createElement("div"),n.style.cssText="border:0;width:0;height:0;position:absolute;top:0;left:-9999px;margin-top:1px",a.appendChild(n).appendChild(i),i.innerHTML="",i.style.cssText="-webkit-box-sizing:border-box;-moz-box-sizing:border-box;box-sizing:border-box;padding:1px;border:1px;display:block;width:4px;margin-top:1%;position:absolute;top:1%",x.swap(a,null!=a.style.zoom?{zoom:1}:{},function(){t.boxSizing=4===i.offsetWidth}),e.getComputedStyle&&(t.pixelPosition="1%"!==(e.getComputedStyle(i,null)||{}).top,t.boxSizingReliable="4px"===(e.getComputedStyle(i,null)||{width:"4px"}).width,r=i.appendChild(o.createElement("div")),r.style.cssText=i.style.cssText=s,r.style.marginRight=r.style.width="0",i.style.width="1px",t.reliableMarginRight=!parseFloat((e.getComputedStyle(r,null)||{}).marginRight)),a.removeChild(n))}),t):t}({});var L,q,H=\/(?:\\{[\\s\\S]*\\}|\\[[\\s\\S]*\\])$\/,O=\/([A-Z])\/g;function F(){Object.defineProperty(this.cache={},0,{get:function(){return{}}}),this.expando=x.expando+Math.random()}F.uid=1,F.accepts=function(e){return e.nodeType?1===e.nodeType||9===e.nodeType:!0},F.prototype={key:function(e){if(!F.accepts(e))return 0;var t={},n=e[this.expando];if(!n){n=F.uid++;try{t[this.expando]={value:n},Object.defineProperties(e,t)}catch(r){t[this.expando]=n,x.extend(e,t)}}return this.cache[n]||(this.cache[n]={}),n},set:function(e,t,n){var r,i=this.key(e),o=this.cache[i];if("string"==typeof t)o[t]=n;else if(x.isEmptyObject(o))this.cache[i]=t;else for(r in t)o[r]=t[r]},get:function(e,t){var n=this.cache[this.key(e)];return t===undefined?n:n[t]},access:function(e,t,n){return t===undefined||t&&"string"==typeof t&&n===undefined?this.get(e,t):(this.set(e,t,n),n!==undefined?n:t)},remove:function(e,t){var n,r,i=this.key(e),o=this.cache[i];if(t===undefined)this.cache[i]={};else{x.isArray(t)?r=t.concat(t.map(x.camelCase)):t in o?r=[t]:(r=x.camelCase(t),r=r in o?[r]:r.match(w)||[]),n=r.length;while(n--)delete o[r[n]]}},hasData:function(e){return!x.isEmptyObject(this.cache[e[this.expando]]||{})},discard:function(e){delete this.cache[this.key(e)]}},L=new F,q=new F,x.extend({acceptData:F.accepts,hasData:function(e){return L.hasData(e)||q.hasData(e)},data:function(e,t,n){return L.access(e,t,n)},removeData:function(e,t){L.remove(e,t)},_data:function(e,t,n){return q.access(e,t,n)},_removeData:function(e,t){q.remove(e,t)}}),x.fn.extend({data:function(e,t){var n,r,i=this[0],o=0,s=null;if(e===undefined){if(this.length&&(s=L.get(i),1===i.nodeType&&!q.get(i,"hasDataAttrs"))){for(n=i.attributes;n.length>o;o++)r=n[o].name,0===r.indexOf("data-")&&(r=x.camelCase(r.substring(5)),P(i,r,s[r]));q.set(i,"hasDataAttrs",!0)}return s}return"object"==typeof e?this.each(function(){L.set(this,e)}):x.access(this,function(t){var n,r=x.camelCase(e);if(i&&t===undefined){if(n=L.get(i,e),n!==undefined)return n;if(n=L.get(i,r),n!==undefined)return n;if(n=P(i,r,undefined),n!==undefined)return n}else this.each(function(){var n=L.get(this,r);L.set(this,r,t),-1!==e.indexOf("-")&&n!==undefined&&L.set(this,e,t)})},null,t,arguments.length>1,null,!0)},removeData:function(e){return this.each(function(){L.remove(this,e)})}});function P(e,t,n){var r;if(n===undefined&&1===e.nodeType)if(r="data-"+t.replace(O,"-$1").toLowerCase(),n=e.getAttribute(r),"string"==typeof n){try{n="true"===n?!0:"false"===n?!1:"null"===n?null:+n+""===n?+n:H.test(n)?JSON.parse(n):n}catch(i){}L.set(e,t,n)}else n=undefined;return n}x.extend({queue:function(e,t,n){var r;return e?(t=(t||"fx")+"queue",r=q.get(e,t),n&&(!r||x.isArray(n)?r=q.access(e,t,x.makeArray(n)):r.push(n)),r||[]):undefined},dequeue:function(e,t){t=t||"fx";var n=x.queue(e,t),r=n.length,i=n.shift(),o=x._queueHooks(e,t),s=function(){x.dequeue(e,t)};"inprogress"===i&&(i=n.shift(),r--),o.cur=i,i&&("fx"===t&&n.unshift("inprogress"),delete o.stop,i.call(e,s,o)),!r&&o&&o.empty.fire()},_queueHooks:function(e,t){var n=t+"queueHooks";return q.get(e,n)||q.access(e,n,{empty:x.Callbacks("once memory").add(function(){q.remove(e,[t+"queue",n])})})}}),x.fn.extend({queue:function(e,t){var n=2;return"string"!=typeof e&&(t=e,e="fx",n--),n>arguments.length?x.queue(this[0],e):t===undefined?this:this.each(function(){var n=x.queue(this,e,t);$/;" c
+fn.init.extend.ready.promise ghostest/public/jquery-2.0.0.min.js /^(function(e,undefined){var t,n,r=typeof undefined,i=e.location,o=e.document,s=o.documentElement,a=e.jQuery,u=e.$,l={},c=[],f="2.0.0",p=c.concat,h=c.push,d=c.slice,g=c.indexOf,m=l.toString,y=l.hasOwnProperty,v=f.trim,x=function(e,n){return new x.fn.init(e,n,t)},b=\/[+-]?(?:\\d*\\.|)\\d+(?:[eE][+-]?\\d+|)\/.source,w=\/\\S+\/g,T=\/^(?:(<[\\w\\W]+>)[^>]*|#([\\w-]*))$\/,C=\/^<(\\w+)\\s*\\\/?>(?:<\\\/\\1>|)$\/,k=\/^-ms-\/,N=\/-([\\da-z])\/gi,E=function(e,t){return t.toUpperCase()},S=function(){o.removeEventListener("DOMContentLoaded",S,!1),e.removeEventListener("load",S,!1),x.ready()};x.fn=x.prototype={jquery:f,constructor:x,init:function(e,t,n){var r,i;if(!e)return this;if("string"==typeof e){if(r="<"===e.charAt(0)&&">"===e.charAt(e.length-1)&&e.length>=3?[null,e,null]:T.exec(e),!r||!r[1]&&t)return!t||t.jquery?(t||n).find(e):this.constructor(t).find(e);if(r[1]){if(t=t instanceof x?t[0]:t,x.merge(this,x.parseHTML(r[1],t&&t.nodeType?t.ownerDocument||t:o,!0)),C.test(r[1])&&x.isPlainObject(t))for(r in t)x.isFunction(this[r])?this[r](t[r]):this.attr(r,t[r]);return this}return i=o.getElementById(r[2]),i&&i.parentNode&&(this.length=1,this[0]=i),this.context=o,this.selector=e,this}return e.nodeType?(this.context=this[0]=e,this.length=1,this):x.isFunction(e)?n.ready(e):(e.selector!==undefined&&(this.selector=e.selector,this.context=e.context),x.makeArray(e,this))},selector:"",length:0,toArray:function(){return d.call(this)},get:function(e){return null==e?this.toArray():0>e?this[this.length+e]:this[e]},pushStack:function(e){var t=x.merge(this.constructor(),e);return t.prevObject=this,t.context=this.context,t},each:function(e,t){return x.each(this,e,t)},ready:function(e){return x.ready.promise().done(e),this},slice:function(){return this.pushStack(d.apply(this,arguments))},first:function(){return this.eq(0)},last:function(){return this.eq(-1)},eq:function(e){var t=this.length,n=+e+(0>e?t:0);return this.pushStack(n>=0&&t>n?[this[n]]:[])},map:function(e){return this.pushStack(x.map(this,function(t,n){return e.call(t,n,t)}))},end:function(){return this.prevObject||this.constructor(null)},push:h,sort:[].sort,splice:[].splice},x.fn.init.prototype=x.fn,x.extend=x.fn.extend=function(){var e,t,n,r,i,o,s=arguments[0]||{},a=1,u=arguments.length,l=!1;for("boolean"==typeof s&&(l=s,s=arguments[1]||{},a=2),"object"==typeof s||x.isFunction(s)||(s={}),u===a&&(s=this,--a);u>a;a++)if(null!=(e=arguments[a]))for(t in e)n=s[t],r=e[t],s!==r&&(l&&r&&(x.isPlainObject(r)||(i=x.isArray(r)))?(i?(i=!1,o=n&&x.isArray(n)?n:[]):o=n&&x.isPlainObject(n)?n:{},s[t]=x.extend(l,o,r)):r!==undefined&&(s[t]=r));return s},x.extend({expando:"jQuery"+(f+Math.random()).replace(\/\\D\/g,""),noConflict:function(t){return e.$===x&&(e.$=u),t&&e.jQuery===x&&(e.jQuery=a),x},isReady:!1,readyWait:1,holdReady:function(e){e?x.readyWait++:x.ready(!0)},ready:function(e){(e===!0?--x.readyWait:x.isReady)||(x.isReady=!0,e!==!0&&--x.readyWait>0||(n.resolveWith(o,[x]),x.fn.trigger&&x(o).trigger("ready").off("ready")))},isFunction:function(e){return"function"===x.type(e)},isArray:Array.isArray,isWindow:function(e){return null!=e&&e===e.window},isNumeric:function(e){return!isNaN(parseFloat(e))&&isFinite(e)},type:function(e){return null==e?e+"":"object"==typeof e||"function"==typeof e?l[m.call(e)]||"object":typeof e},isPlainObject:function(e){if("object"!==x.type(e)||e.nodeType||x.isWindow(e))return!1;try{if(e.constructor&&!y.call(e.constructor.prototype,"isPrototypeOf"))return!1}catch(t){return!1}return!0},isEmptyObject:function(e){var t;for(t in e)return!1;return!0},error:function(e){throw Error(e)},parseHTML:function(e,t,n){if(!e||"string"!=typeof e)return null;"boolean"==typeof t&&(n=t,t=!1),t=t||o;var r=C.exec(e),i=!n&&[];return r?[t.createElement(r[1])]:(r=x.buildFragment([e],t,i),i&&x(i).remove(),x.merge([],r.childNodes))},parseJSON:JSON.parse,parseXML:function(e){var t,n;if(!e||"string"!=typeof e)return null;try{n=new DOMParser,t=n.parseFromString(e,"text\/xml")}catch(r){t=undefined}return(!t||t.getElementsByTagName("parsererror").length)&&x.error("Invalid XML: "+e),t},noop:function(){},globalEval:function(e){var t,n=eval;e=x.trim(e),e&&(1===e.indexOf("use strict")?(t=o.createElement("script"),t.text=e,o.head.appendChild(t).parentNode.removeChild(t)):n(e))},camelCase:function(e){return e.replace(k,"ms-").replace(N,E)},nodeName:function(e,t){return e.nodeName&&e.nodeName.toLowerCase()===t.toLowerCase()},each:function(e,t,n){var r,i=0,o=e.length,s=j(e);if(n){if(s){for(;o>i;i++)if(r=t.apply(e[i],n),r===!1)break}else for(i in e)if(r=t.apply(e[i],n),r===!1)break}else if(s){for(;o>i;i++)if(r=t.call(e[i],i,e[i]),r===!1)break}else for(i in e)if(r=t.call(e[i],i,e[i]),r===!1)break;return e},trim:function(e){return null==e?"":v.call(e)},makeArray:function(e,t){var n=t||[];return null!=e&&(j(Object(e))?x.merge(n,"string"==typeof e?[e]:e):h.call(n,e)),n},inArray:function(e,t,n){return null==t?-1:g.call(t,e,n)},merge:function(e,t){var n=t.length,r=e.length,i=0;if("number"==typeof n)for(;n>i;i++)e[r++]=t[i];else while(t[i]!==undefined)e[r++]=t[i++];return e.length=r,e},grep:function(e,t,n){var r,i=[],o=0,s=e.length;for(n=!!n;s>o;o++)r=!!t(e[o],o),n!==r&&i.push(e[o]);return i},map:function(e,t,n){var r,i=0,o=e.length,s=j(e),a=[];if(s)for(;o>i;i++)r=t(e[i],i,n),null!=r&&(a[a.length]=r);else for(i in e)r=t(e[i],i,n),null!=r&&(a[a.length]=r);return p.apply([],a)},guid:1,proxy:function(e,t){var n,r,i;return"string"==typeof t&&(n=e[t],t=e,e=n),x.isFunction(e)?(r=d.call(arguments,2),i=function(){return e.apply(t||this,r.concat(d.call(arguments)))},i.guid=e.guid=e.guid||x.guid++,i):undefined},access:function(e,t,n,r,i,o,s){var a=0,u=e.length,l=null==n;if("object"===x.type(n)){i=!0;for(a in n)x.access(e,t,a,n[a],!0,o,s)}else if(r!==undefined&&(i=!0,x.isFunction(r)||(s=!0),l&&(s?(t.call(e,r),t=null):(l=t,t=function(e,t,n){return l.call(x(e),n)})),t))for(;u>a;a++)t(e[a],n,s?r:r.call(e[a],a,t(e[a],n)));return i?e:l?t.call(e):u?t(e[0],n):o},now:Date.now,swap:function(e,t,n,r){var i,o,s={};for(o in t)s[o]=e.style[o],e.style[o]=t[o];i=n.apply(e,r||[]);for(o in t)e.style[o]=s[o];return i}}),x.ready.promise=function(t){return n||(n=x.Deferred(),"complete"===o.readyState?setTimeout(x.ready):(o.addEventListener("DOMContentLoaded",S,!1),e.addEventListener("load",S,!1))),n.promise(t)},x.each("Boolean Number String Function Array Date RegExp Object Error".split(" "),function(e,t){l["[object "+t+"]"]=t.toLowerCase()});function j(e){var t=e.length,n=x.type(e);return x.isWindow(e)?!1:1===e.nodeType&&t?!0:"array"===n||"function"!==n&&(0===t||"number"==typeof t&&t>0&&t-1 in e)}t=x(o),function(e,undefined){var t,n,r,i,o,s,a,u,l,c,f,p,h,d,g,m,y="sizzle"+-new Date,v=e.document,b={},w=0,T=0,C=ot(),k=ot(),N=ot(),E=!1,S=function(){return 0},j=typeof undefined,D=1<<31,A=[],L=A.pop,q=A.push,H=A.push,O=A.slice,F=A.indexOf||function(e){var t=0,n=this.length;for(;n>t;t++)if(this[t]===e)return t;return-1},P="checked|selected|async|autofocus|autoplay|controls|defer|disabled|hidden|ismap|loop|multiple|open|readonly|required|scoped",R="[\\\\x20\\\\t\\\\r\\\\n\\\\f]",M="(?:\\\\\\\\.|[\\\\w-]|[^\\\\x00-\\\\xa0])+",W=M.replace("w","w#"),$="\\\\["+R+"*("+M+")"+R+"*(?:([*^$|!~]?=)"+R+"*(?:(['\\"])((?:\\\\\\\\.|[^\\\\\\\\])*?)\\\\3|("+W+")|)|)"+R+"*\\\\]",B=":("+M+")(?:\\\\(((['\\"])((?:\\\\\\\\.|[^\\\\\\\\])*?)\\\\3|((?:\\\\\\\\.|[^\\\\\\\\()[\\\\]]|"+$.replace(3,8)+")*)|.*)\\\\)|)",I=RegExp("^"+R+"+|((?:^|[^\\\\\\\\])(?:\\\\\\\\.)*)"+R+"+$","g"),z=RegExp("^"+R+"*,"+R+"*"),_=RegExp("^"+R+"*([>+~]|"+R+")"+R+"*"),X=RegExp(R+"*[+~]"),U=RegExp("="+R+"*([^\\\\]'\\"]*)"+R+"*\\\\]","g"),Y=RegExp(B),V=RegExp("^"+W+"$"),G={ID:RegExp("^#("+M+")"),CLASS:RegExp("^\\\\.("+M+")"),TAG:RegExp("^("+M.replace("w","w*")+")"),ATTR:RegExp("^"+$),PSEUDO:RegExp("^"+B),CHILD:RegExp("^:(only|first|last|nth|nth-last)-(child|of-type)(?:\\\\("+R+"*(even|odd|(([+-]|)(\\\\d*)n|)"+R+"*(?:([+-]|)"+R+"*(\\\\d+)|))"+R+"*\\\\)|)","i"),"boolean":RegExp("^(?:"+P+")$","i"),needsContext:RegExp("^"+R+"*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\\\\("+R+"*((?:-\\\\d)?\\\\d*)"+R+"*\\\\)|)(?=[^-]|$)","i")},J=\/^[^{]+\\{\\s*\\[native \\w\/,Q=\/^(?:#([\\w-]+)|(\\w+)|\\.([\\w-]+))$\/,K=\/^(?:input|select|textarea|button)$\/i,Z=\/^h\\d$\/i,et=\/'|\\\\\/g,tt=\/\\\\([\\da-fA-F]{1,6}[\\x20\\t\\r\\n\\f]?|.)\/g,nt=function(e,t){var n="0x"+t-65536;return n!==n?t:0>n?String.fromCharCode(n+65536):String.fromCharCode(55296|n>>10,56320|1023&n)};try{H.apply(A=O.call(v.childNodes),v.childNodes),A[v.childNodes.length].nodeType}catch(rt){H={apply:A.length?function(e,t){q.apply(e,O.call(t))}:function(e,t){var n=e.length,r=0;while(e[n++]=t[r++]);e.length=n-1}}}function it(e){return J.test(e+"")}function ot(){var e,t=[];return e=function(n,i){return t.push(n+=" ")>r.cacheLength&&delete e[t.shift()],e[n]=i}}function st(e){return e[y]=!0,e}function at(e){var t=c.createElement("div");try{return!!e(t)}catch(n){return!1}finally{t.parentNode&&t.parentNode.removeChild(t),t=null}}function ut(e,t,n,r){var i,o,s,a,u,f,d,g,x,w;if((t?t.ownerDocument||t:v)!==c&&l(t),t=t||c,n=n||[],!e||"string"!=typeof e)return n;if(1!==(a=t.nodeType)&&9!==a)return[];if(p&&!r){if(i=Q.exec(e))if(s=i[1]){if(9===a){if(o=t.getElementById(s),!o||!o.parentNode)return n;if(o.id===s)return n.push(o),n}else if(t.ownerDocument&&(o=t.ownerDocument.getElementById(s))&&m(t,o)&&o.id===s)return n.push(o),n}else{if(i[2])return H.apply(n,t.getElementsByTagName(e)),n;if((s=i[3])&&b.getElementsByClassName&&t.getElementsByClassName)return H.apply(n,t.getElementsByClassName(s)),n}if(b.qsa&&(!h||!h.test(e))){if(g=d=y,x=t,w=9===a&&e,1===a&&"object"!==t.nodeName.toLowerCase()){f=gt(e),(d=t.getAttribute("id"))?g=d.replace(et,"\\\\$&"):t.setAttribute("id",g),g="[id='"+g+"'] ",u=f.length;while(u--)f[u]=g+mt(f[u]);x=X.test(e)&&t.parentNode||t,w=f.join(",")}if(w)try{return H.apply(n,x.querySelectorAll(w)),n}catch(T){}finally{d||t.removeAttribute("id")}}}return kt(e.replace(I,"$1"),t,n,r)}o=ut.isXML=function(e){var t=e&&(e.ownerDocument||e).documentElement;return t?"HTML"!==t.nodeName:!1},l=ut.setDocument=function(e){var t=e?e.ownerDocument||e:v;return t!==c&&9===t.nodeType&&t.documentElement?(c=t,f=t.documentElement,p=!o(t),b.getElementsByTagName=at(function(e){return e.appendChild(t.createComment("")),!e.getElementsByTagName("*").length}),b.attributes=at(function(e){return e.className="i",!e.getAttribute("className")}),b.getElementsByClassName=at(function(e){return e.innerHTML="<div class='a'><\/div><div class='a i'><\/div>",e.firstChild.className="i",2===e.getElementsByClassName("i").length}),b.sortDetached=at(function(e){return 1&e.compareDocumentPosition(c.createElement("div"))}),b.getById=at(function(e){return f.appendChild(e).id=y,!t.getElementsByName||!t.getElementsByName(y).length}),b.getById?(r.find.ID=function(e,t){if(typeof t.getElementById!==j&&p){var n=t.getElementById(e);return n&&n.parentNode?[n]:[]}},r.filter.ID=function(e){var t=e.replace(tt,nt);return function(e){return e.getAttribute("id")===t}}):(r.find.ID=function(e,t){if(typeof t.getElementById!==j&&p){var n=t.getElementById(e);return n?n.id===e||typeof n.getAttributeNode!==j&&n.getAttributeNode("id").value===e?[n]:undefined:[]}},r.filter.ID=function(e){var t=e.replace(tt,nt);return function(e){var n=typeof e.getAttributeNode!==j&&e.getAttributeNode("id");return n&&n.value===t}}),r.find.TAG=b.getElementsByTagName?function(e,t){return typeof t.getElementsByTagName!==j?t.getElementsByTagName(e):undefined}:function(e,t){var n,r=[],i=0,o=t.getElementsByTagName(e);if("*"===e){while(n=o[i++])1===n.nodeType&&r.push(n);return r}return o},r.find.CLASS=b.getElementsByClassName&&function(e,t){return typeof t.getElementsByClassName!==j&&p?t.getElementsByClassName(e):undefined},d=[],h=[],(b.qsa=it(t.querySelectorAll))&&(at(function(e){e.innerHTML="<select><option selected=''><\/option><\/select>",e.querySelectorAll("[selected]").length||h.push("\\\\["+R+"*(?:value|"+P+")"),e.querySelectorAll(":checked").length||h.push(":checked")}),at(function(e){var t=c.createElement("input");t.setAttribute("type","hidden"),e.appendChild(t).setAttribute("t",""),e.querySelectorAll("[t^='']").length&&h.push("[*^$]="+R+"*(?:''|\\"\\")"),e.querySelectorAll(":enabled").length||h.push(":enabled",":disabled"),e.querySelectorAll("*,:x"),h.push(",.*:")})),(b.matchesSelector=it(g=f.webkitMatchesSelector||f.mozMatchesSelector||f.oMatchesSelector||f.msMatchesSelector))&&at(function(e){b.disconnectedMatch=g.call(e,"div"),g.call(e,"[s!='']:x"),d.push("!=",B)}),h=h.length&&RegExp(h.join("|")),d=d.length&&RegExp(d.join("|")),m=it(f.contains)||f.compareDocumentPosition?function(e,t){var n=9===e.nodeType?e.documentElement:e,r=t&&t.parentNode;return e===r||!(!r||1!==r.nodeType||!(n.contains?n.contains(r):e.compareDocumentPosition&&16&e.compareDocumentPosition(r)))}:function(e,t){if(t)while(t=t.parentNode)if(t===e)return!0;return!1},S=f.compareDocumentPosition?function(e,n){if(e===n)return E=!0,0;var r=n.compareDocumentPosition&&e.compareDocumentPosition&&e.compareDocumentPosition(n);return r?1&r||!b.sortDetached&&n.compareDocumentPosition(e)===r?e===t||m(v,e)?-1:n===t||m(v,n)?1:u?F.call(u,e)-F.call(u,n):0:4&r?-1:1:e.compareDocumentPosition?-1:1}:function(e,n){var r,i=0,o=e.parentNode,s=n.parentNode,a=[e],l=[n];if(e===n)return E=!0,0;if(!o||!s)return e===t?-1:n===t?1:o?-1:s?1:u?F.call(u,e)-F.call(u,n):0;if(o===s)return lt(e,n);r=e;while(r=r.parentNode)a.unshift(r);r=n;while(r=r.parentNode)l.unshift(r);while(a[i]===l[i])i++;return i?lt(a[i],l[i]):a[i]===v?-1:l[i]===v?1:0},c):c},ut.matches=function(e,t){return ut(e,null,null,t)},ut.matchesSelector=function(e,t){if((e.ownerDocument||e)!==c&&l(e),t=t.replace(U,"='$1']"),!(!b.matchesSelector||!p||d&&d.test(t)||h&&h.test(t)))try{var n=g.call(e,t);if(n||b.disconnectedMatch||e.document&&11!==e.document.nodeType)return n}catch(r){}return ut(t,c,null,[e]).length>0},ut.contains=function(e,t){return(e.ownerDocument||e)!==c&&l(e),m(e,t)},ut.attr=function(e,t){(e.ownerDocument||e)!==c&&l(e);var n=r.attrHandle[t.toLowerCase()],i=n&&n(e,t,!p);return i===undefined?b.attributes||!p?e.getAttribute(t):(i=e.getAttributeNode(t))&&i.specified?i.value:null:i},ut.error=function(e){throw Error("Syntax error, unrecognized expression: "+e)},ut.uniqueSort=function(e){var t,n=[],r=0,i=0;if(E=!b.detectDuplicates,u=!b.sortStable&&e.slice(0),e.sort(S),E){while(t=e[i++])t===e[i]&&(r=n.push(i));while(r--)e.splice(n[r],1)}return e};function lt(e,t){var n=t&&e,r=n&&(~t.sourceIndex||D)-(~e.sourceIndex||D);if(r)return r;if(n)while(n=n.nextSibling)if(n===t)return-1;return e?1:-1}function ct(e,t,n){var r;return n?undefined:(r=e.getAttributeNode(t))&&r.specified?r.value:e[t]===!0?t.toLowerCase():null}function ft(e,t,n){var r;return n?undefined:r=e.getAttribute(t,"type"===t.toLowerCase()?1:2)}function pt(e){return function(t){var n=t.nodeName.toLowerCase();return"input"===n&&t.type===e}}function ht(e){return function(t){var n=t.nodeName.toLowerCase();return("input"===n||"button"===n)&&t.type===e}}function dt(e){return st(function(t){return t=+t,st(function(n,r){var i,o=e([],n.length,t),s=o.length;while(s--)n[i=o[s]]&&(n[i]=!(r[i]=n[i]))})})}i=ut.getText=function(e){var t,n="",r=0,o=e.nodeType;if(o){if(1===o||9===o||11===o){if("string"==typeof e.textContent)return e.textContent;for(e=e.firstChild;e;e=e.nextSibling)n+=i(e)}else if(3===o||4===o)return e.nodeValue}else for(;t=e[r];r++)n+=i(t);return n},r=ut.selectors={cacheLength:50,createPseudo:st,match:G,attrHandle:{},find:{},relative:{">":{dir:"parentNode",first:!0}," ":{dir:"parentNode"},"+":{dir:"previousSibling",first:!0},"~":{dir:"previousSibling"}},preFilter:{ATTR:function(e){return e[1]=e[1].replace(tt,nt),e[3]=(e[4]||e[5]||"").replace(tt,nt),"~="===e[2]&&(e[3]=" "+e[3]+" "),e.slice(0,4)},CHILD:function(e){return e[1]=e[1].toLowerCase(),"nth"===e[1].slice(0,3)?(e[3]||ut.error(e[0]),e[4]=+(e[4]?e[5]+(e[6]||1):2*("even"===e[3]||"odd"===e[3])),e[5]=+(e[7]+e[8]||"odd"===e[3])):e[3]&&ut.error(e[0]),e},PSEUDO:function(e){var t,n=!e[5]&&e[2];return G.CHILD.test(e[0])?null:(e[4]?e[2]=e[4]:n&&Y.test(n)&&(t=gt(n,!0))&&(t=n.indexOf(")",n.length-t)-n.length)&&(e[0]=e[0].slice(0,t),e[2]=n.slice(0,t)),e.slice(0,3))}},filter:{TAG:function(e){var t=e.replace(tt,nt).toLowerCase();return"*"===e?function(){return!0}:function(e){return e.nodeName&&e.nodeName.toLowerCase()===t}},CLASS:function(e){var t=C[e+" "];return t||(t=RegExp("(^|"+R+")"+e+"("+R+"|$)"))&&C(e,function(e){return t.test("string"==typeof e.className&&e.className||typeof e.getAttribute!==j&&e.getAttribute("class")||"")})},ATTR:function(e,t,n){return function(r){var i=ut.attr(r,e);return null==i?"!="===t:t?(i+="","="===t?i===n:"!="===t?i!==n:"^="===t?n&&0===i.indexOf(n):"*="===t?n&&i.indexOf(n)>-1:"$="===t?n&&i.slice(-n.length)===n:"~="===t?(" "+i+" ").indexOf(n)>-1:"|="===t?i===n||i.slice(0,n.length+1)===n+"-":!1):!0}},CHILD:function(e,t,n,r,i){var o="nth"!==e.slice(0,3),s="last"!==e.slice(-4),a="of-type"===t;return 1===r&&0===i?function(e){return!!e.parentNode}:function(t,n,u){var l,c,f,p,h,d,g=o!==s?"nextSibling":"previousSibling",m=t.parentNode,v=a&&t.nodeName.toLowerCase(),x=!u&&!a;if(m){if(o){while(g){f=t;while(f=f[g])if(a?f.nodeName.toLowerCase()===v:1===f.nodeType)return!1;d=g="only"===e&&!d&&"nextSibling"}return!0}if(d=[s?m.firstChild:m.lastChild],s&&x){c=m[y]||(m[y]={}),l=c[e]||[],h=l[0]===w&&l[1],p=l[0]===w&&l[2],f=h&&m.childNodes[h];while(f=++h&&f&&f[g]||(p=h=0)||d.pop())if(1===f.nodeType&&++p&&f===t){c[e]=[w,h,p];break}}else if(x&&(l=(t[y]||(t[y]={}))[e])&&l[0]===w)p=l[1];else while(f=++h&&f&&f[g]||(p=h=0)||d.pop())if((a?f.nodeName.toLowerCase()===v:1===f.nodeType)&&++p&&(x&&((f[y]||(f[y]={}))[e]=[w,p]),f===t))break;return p-=i,p===r||0===p%r&&p\/r>=0}}},PSEUDO:function(e,t){var n,i=r.pseudos[e]||r.setFilters[e.toLowerCase()]||ut.error("unsupported pseudo: "+e);return i[y]?i(t):i.length>1?(n=[e,e,"",t],r.setFilters.hasOwnProperty(e.toLowerCase())?st(function(e,n){var r,o=i(e,t),s=o.length;while(s--)r=F.call(e,o[s]),e[r]=!(n[r]=o[s])}):function(e){return i(e,0,n)}):i}},pseudos:{not:st(function(e){var t=[],n=[],r=s(e.replace(I,"$1"));return r[y]?st(function(e,t,n,i){var o,s=r(e,null,i,[]),a=e.length;while(a--)(o=s[a])&&(e[a]=!(t[a]=o))}):function(e,i,o){return t[0]=e,r(t,null,o,n),!n.pop()}}),has:st(function(e){return function(t){return ut(e,t).length>0}}),contains:st(function(e){return function(t){return(t.textContent||t.innerText||i(t)).indexOf(e)>-1}}),lang:st(function(e){return V.test(e||"")||ut.error("unsupported lang: "+e),e=e.replace(tt,nt).toLowerCase(),function(t){var n;do if(n=p?t.lang:t.getAttribute("xml:lang")||t.getAttribute("lang"))return n=n.toLowerCase(),n===e||0===n.indexOf(e+"-");while((t=t.parentNode)&&1===t.nodeType);return!1}}),target:function(t){var n=e.location&&e.location.hash;return n&&n.slice(1)===t.id},root:function(e){return e===f},focus:function(e){return e===c.activeElement&&(!c.hasFocus||c.hasFocus())&&!!(e.type||e.href||~e.tabIndex)},enabled:function(e){return e.disabled===!1},disabled:function(e){return e.disabled===!0},checked:function(e){var t=e.nodeName.toLowerCase();return"input"===t&&!!e.checked||"option"===t&&!!e.selected},selected:function(e){return e.parentNode&&e.parentNode.selectedIndex,e.selected===!0},empty:function(e){for(e=e.firstChild;e;e=e.nextSibling)if(e.nodeName>"@"||3===e.nodeType||4===e.nodeType)return!1;return!0},parent:function(e){return!r.pseudos.empty(e)},header:function(e){return Z.test(e.nodeName)},input:function(e){return K.test(e.nodeName)},button:function(e){var t=e.nodeName.toLowerCase();return"input"===t&&"button"===e.type||"button"===t},text:function(e){var t;return"input"===e.nodeName.toLowerCase()&&"text"===e.type&&(null==(t=e.getAttribute("type"))||t.toLowerCase()===e.type)},first:dt(function(){return[0]}),last:dt(function(e,t){return[t-1]}),eq:dt(function(e,t,n){return[0>n?n+t:n]}),even:dt(function(e,t){var n=0;for(;t>n;n+=2)e.push(n);return e}),odd:dt(function(e,t){var n=1;for(;t>n;n+=2)e.push(n);return e}),lt:dt(function(e,t,n){var r=0>n?n+t:n;for(;--r>=0;)e.push(r);return e}),gt:dt(function(e,t,n){var r=0>n?n+t:n;for(;t>++r;)e.push(r);return e})}};for(t in{radio:!0,checkbox:!0,file:!0,password:!0,image:!0})r.pseudos[t]=pt(t);for(t in{submit:!0,reset:!0})r.pseudos[t]=ht(t);function gt(e,t){var n,i,o,s,a,u,l,c=k[e+" "];if(c)return t?0:c.slice(0);a=e,u=[],l=r.preFilter;while(a){(!n||(i=z.exec(a)))&&(i&&(a=a.slice(i[0].length)||a),u.push(o=[])),n=!1,(i=_.exec(a))&&(n=i.shift(),o.push({value:n,type:i[0].replace(I," ")}),a=a.slice(n.length));for(s in r.filter)!(i=G[s].exec(a))||l[s]&&!(i=l[s](i))||(n=i.shift(),o.push({value:n,type:s,matches:i}),a=a.slice(n.length));if(!n)break}return t?a.length:a?ut.error(e):k(e,u).slice(0)}function mt(e){var t=0,n=e.length,r="";for(;n>t;t++)r+=e[t].value;return r}function yt(e,t,r){var i=t.dir,o=r&&"parentNode"===i,s=T++;return t.first?function(t,n,r){while(t=t[i])if(1===t.nodeType||o)return e(t,n,r)}:function(t,r,a){var u,l,c,f=w+" "+s;if(a){while(t=t[i])if((1===t.nodeType||o)&&e(t,r,a))return!0}else while(t=t[i])if(1===t.nodeType||o)if(c=t[y]||(t[y]={}),(l=c[i])&&l[0]===f){if((u=l[1])===!0||u===n)return u===!0}else if(l=c[i]=[f],l[1]=e(t,r,a)||n,l[1]===!0)return!0}}function vt(e){return e.length>1?function(t,n,r){var i=e.length;while(i--)if(!e[i](t,n,r))return!1;return!0}:e[0]}function xt(e,t,n,r,i){var o,s=[],a=0,u=e.length,l=null!=t;for(;u>a;a++)(o=e[a])&&(!n||n(o,r,i))&&(s.push(o),l&&t.push(a));return s}function bt(e,t,n,r,i,o){return r&&!r[y]&&(r=bt(r)),i&&!i[y]&&(i=bt(i,o)),st(function(o,s,a,u){var l,c,f,p=[],h=[],d=s.length,g=o||Ct(t||"*",a.nodeType?[a]:a,[]),m=!e||!o&&t?g:xt(g,p,e,a,u),y=n?i||(o?e:d||r)?[]:s:m;if(n&&n(m,y,a,u),r){l=xt(y,h),r(l,[],a,u),c=l.length;while(c--)(f=l[c])&&(y[h[c]]=!(m[h[c]]=f))}if(o){if(i||e){if(i){l=[],c=y.length;while(c--)(f=y[c])&&l.push(m[c]=f);i(null,y=[],l,u)}c=y.length;while(c--)(f=y[c])&&(l=i?F.call(o,f):p[c])>-1&&(o[l]=!(s[l]=f))}}else y=xt(y===s?y.splice(d,y.length):y),i?i(null,s,y,u):H.apply(s,y)})}function wt(e){var t,n,i,o=e.length,s=r.relative[e[0].type],u=s||r.relative[" "],l=s?1:0,c=yt(function(e){return e===t},u,!0),f=yt(function(e){return F.call(t,e)>-1},u,!0),p=[function(e,n,r){return!s&&(r||n!==a)||((t=n).nodeType?c(e,n,r):f(e,n,r))}];for(;o>l;l++)if(n=r.relative[e[l].type])p=[yt(vt(p),n)];else{if(n=r.filter[e[l].type].apply(null,e[l].matches),n[y]){for(i=++l;o>i;i++)if(r.relative[e[i].type])break;return bt(l>1&&vt(p),l>1&&mt(e.slice(0,l-1)).replace(I,"$1"),n,i>l&&wt(e.slice(l,i)),o>i&&wt(e=e.slice(i)),o>i&&mt(e))}p.push(n)}return vt(p)}function Tt(e,t){var i=0,o=t.length>0,s=e.length>0,u=function(u,l,f,p,h){var d,g,m,y=[],v=0,x="0",b=u&&[],T=null!=h,C=a,k=u||s&&r.find.TAG("*",h&&l.parentNode||l),N=w+=null==C?1:Math.random()||.1;for(T&&(a=l!==c&&l,n=i);null!=(d=k[x]);x++){if(s&&d){g=0;while(m=e[g++])if(m(d,l,f)){p.push(d);break}T&&(w=N,n=++i)}o&&((d=!m&&d)&&v--,u&&b.push(d))}if(v+=x,o&&x!==v){g=0;while(m=t[g++])m(b,y,l,f);if(u){if(v>0)while(x--)b[x]||y[x]||(y[x]=L.call(p));y=xt(y)}H.apply(p,y),T&&!u&&y.length>0&&v+t.length>1&&ut.uniqueSort(p)}return T&&(w=N,a=C),b};return o?st(u):u}s=ut.compile=function(e,t){var n,r=[],i=[],o=N[e+" "];if(!o){t||(t=gt(e)),n=t.length;while(n--)o=wt(t[n]),o[y]?r.push(o):i.push(o);o=N(e,Tt(i,r))}return o};function Ct(e,t,n){var r=0,i=t.length;for(;i>r;r++)ut(e,t[r],n);return n}function kt(e,t,n,i){var o,a,u,l,c,f=gt(e);if(!i&&1===f.length){if(a=f[0]=f[0].slice(0),a.length>2&&"ID"===(u=a[0]).type&&9===t.nodeType&&p&&r.relative[a[1].type]){if(t=(r.find.ID(u.matches[0].replace(tt,nt),t)||[])[0],!t)return n;e=e.slice(a.shift().value.length)}o=G.needsContext.test(e)?0:a.length;while(o--){if(u=a[o],r.relative[l=u.type])break;if((c=r.find[l])&&(i=c(u.matches[0].replace(tt,nt),X.test(a[0].type)&&t.parentNode||t))){if(a.splice(o,1),e=i.length&&mt(a),!e)return H.apply(n,i),n;break}}}return s(e,f)(i,t,!p,n,X.test(e)),n}r.pseudos.nth=r.pseudos.eq;function Nt(){}Nt.prototype=r.filters=r.pseudos,r.setFilters=new Nt,b.sortStable=y.split("").sort(S).join("")===y,l(),[0,0].sort(S),b.detectDuplicates=E,at(function(e){if(e.innerHTML="<a href='#'><\/a>","#"!==e.firstChild.getAttribute("href")){var t="type|href|height|width".split("|"),n=t.length;while(n--)r.attrHandle[t[n]]=ft}}),at(function(e){if(null!=e.getAttribute("disabled")){var t=P.split("|"),n=t.length;while(n--)r.attrHandle[t[n]]=ct}}),x.find=ut,x.expr=ut.selectors,x.expr[":"]=x.expr.pseudos,x.unique=ut.uniqueSort,x.text=ut.getText,x.isXMLDoc=ut.isXML,x.contains=ut.contains}(e);var D={};function A(e){var t=D[e]={};return x.each(e.match(w)||[],function(e,n){t[n]=!0}),t}x.Callbacks=function(e){e="string"==typeof e?D[e]||A(e):x.extend({},e);var t,n,r,i,o,s,a=[],u=!e.once&&[],l=function(f){for(t=e.memory&&f,n=!0,s=i||0,i=0,o=a.length,r=!0;a&&o>s;s++)if(a[s].apply(f[0],f[1])===!1&&e.stopOnFalse){t=!1;break}r=!1,a&&(u?u.length&&l(u.shift()):t?a=[]:c.disable())},c={add:function(){if(a){var n=a.length;(function s(t){x.each(t,function(t,n){var r=x.type(n);"function"===r?e.unique&&c.has(n)||a.push(n):n&&n.length&&"string"!==r&&s(n)})})(arguments),r?o=a.length:t&&(i=n,l(t))}return this},remove:function(){return a&&x.each(arguments,function(e,t){var n;while((n=x.inArray(t,a,n))>-1)a.splice(n,1),r&&(o>=n&&o--,s>=n&&s--)}),this},has:function(e){return e?x.inArray(e,a)>-1:!(!a||!a.length)},empty:function(){return a=[],o=0,this},disable:function(){return a=u=t=undefined,this},disabled:function(){return!a},lock:function(){return u=undefined,t||c.disable(),this},locked:function(){return!u},fireWith:function(e,t){return t=t||[],t=[e,t.slice?t.slice():t],!a||n&&!u||(r?u.push(t):l(t)),this},fire:function(){return c.fireWith(this,arguments),this},fired:function(){return!!n}};return c},x.extend({Deferred:function(e){var t=[["resolve","done",x.Callbacks("once memory"),"resolved"],["reject","fail",x.Callbacks("once memory"),"rejected"],["notify","progress",x.Callbacks("memory")]],n="pending",r={state:function(){return n},always:function(){return i.done(arguments).fail(arguments),this},then:function(){var e=arguments;return x.Deferred(function(n){x.each(t,function(t,o){var s=o[0],a=x.isFunction(e[t])&&e[t];i[o[1]](function(){var e=a&&a.apply(this,arguments);e&&x.isFunction(e.promise)?e.promise().done(n.resolve).fail(n.reject).progress(n.notify):n[s+"With"](this===r?n.promise():this,a?[e]:arguments)})}),e=null}).promise()},promise:function(e){return null!=e?x.extend(e,r):r}},i={};return r.pipe=r.then,x.each(t,function(e,o){var s=o[2],a=o[3];r[o[1]]=s.add,a&&s.add(function(){n=a},t[1^e][2].disable,t[2][2].lock),i[o[0]]=function(){return i[o[0]+"With"](this===i?r:this,arguments),this},i[o[0]+"With"]=s.fireWith}),r.promise(i),e&&e.call(i,i),i},when:function(e){var t=0,n=d.call(arguments),r=n.length,i=1!==r||e&&x.isFunction(e.promise)?r:0,o=1===i?e:x.Deferred(),s=function(e,t,n){return function(r){t[e]=this,n[e]=arguments.length>1?d.call(arguments):r,n===a?o.notifyWith(t,n):--i||o.resolveWith(t,n)}},a,u,l;if(r>1)for(a=Array(r),u=Array(r),l=Array(r);r>t;t++)n[t]&&x.isFunction(n[t].promise)?n[t].promise().done(s(t,l,n)).fail(o.reject).progress(s(t,u,a)):--i;return i||o.resolveWith(l,n),o.promise()}}),x.support=function(t){var n=o.createElement("input"),r=o.createDocumentFragment(),i=o.createElement("div"),s=o.createElement("select"),a=s.appendChild(o.createElement("option"));return n.type?(n.type="checkbox",t.checkOn=""!==n.value,t.optSelected=a.selected,t.reliableMarginRight=!0,t.boxSizingReliable=!0,t.pixelPosition=!1,n.checked=!0,t.noCloneChecked=n.cloneNode(!0).checked,s.disabled=!0,t.optDisabled=!a.disabled,n=o.createElement("input"),n.value="t",n.type="radio",t.radioValue="t"===n.value,n.setAttribute("checked","t"),n.setAttribute("name","t"),r.appendChild(n),t.checkClone=r.cloneNode(!0).cloneNode(!0).lastChild.checked,t.focusinBubbles="onfocusin"in e,i.style.backgroundClip="content-box",i.cloneNode(!0).style.backgroundClip="",t.clearCloneStyle="content-box"===i.style.backgroundClip,x(function(){var n,r,s="padding:0;margin:0;border:0;display:block;-webkit-box-sizing:content-box;-moz-box-sizing:content-box;box-sizing:content-box",a=o.getElementsByTagName("body")[0];a&&(n=o.createElement("div"),n.style.cssText="border:0;width:0;height:0;position:absolute;top:0;left:-9999px;margin-top:1px",a.appendChild(n).appendChild(i),i.innerHTML="",i.style.cssText="-webkit-box-sizing:border-box;-moz-box-sizing:border-box;box-sizing:border-box;padding:1px;border:1px;display:block;width:4px;margin-top:1%;position:absolute;top:1%",x.swap(a,null!=a.style.zoom?{zoom:1}:{},function(){t.boxSizing=4===i.offsetWidth}),e.getComputedStyle&&(t.pixelPosition="1%"!==(e.getComputedStyle(i,null)||{}).top,t.boxSizingReliable="4px"===(e.getComputedStyle(i,null)||{width:"4px"}).width,r=i.appendChild(o.createElement("div")),r.style.cssText=i.style.cssText=s,r.style.marginRight=r.style.width="0",i.style.width="1px",t.reliableMarginRight=!parseFloat((e.getComputedStyle(r,null)||{}).marginRight)),a.removeChild(n))}),t):t}({});var L,q,H=\/(?:\\{[\\s\\S]*\\}|\\[[\\s\\S]*\\])$\/,O=\/([A-Z])\/g;function F(){Object.defineProperty(this.cache={},0,{get:function(){return{}}}),this.expando=x.expando+Math.random()}F.uid=1,F.accepts=function(e){return e.nodeType?1===e.nodeType||9===e.nodeType:!0},F.prototype={key:function(e){if(!F.accepts(e))return 0;var t={},n=e[this.expando];if(!n){n=F.uid++;try{t[this.expando]={value:n},Object.defineProperties(e,t)}catch(r){t[this.expando]=n,x.extend(e,t)}}return this.cache[n]||(this.cache[n]={}),n},set:function(e,t,n){var r,i=this.key(e),o=this.cache[i];if("string"==typeof t)o[t]=n;else if(x.isEmptyObject(o))this.cache[i]=t;else for(r in t)o[r]=t[r]},get:function(e,t){var n=this.cache[this.key(e)];return t===undefined?n:n[t]},access:function(e,t,n){return t===undefined||t&&"string"==typeof t&&n===undefined?this.get(e,t):(this.set(e,t,n),n!==undefined?n:t)},remove:function(e,t){var n,r,i=this.key(e),o=this.cache[i];if(t===undefined)this.cache[i]={};else{x.isArray(t)?r=t.concat(t.map(x.camelCase)):t in o?r=[t]:(r=x.camelCase(t),r=r in o?[r]:r.match(w)||[]),n=r.length;while(n--)delete o[r[n]]}},hasData:function(e){return!x.isEmptyObject(this.cache[e[this.expando]]||{})},discard:function(e){delete this.cache[this.key(e)]}},L=new F,q=new F,x.extend({acceptData:F.accepts,hasData:function(e){return L.hasData(e)||q.hasData(e)},data:function(e,t,n){return L.access(e,t,n)},removeData:function(e,t){L.remove(e,t)},_data:function(e,t,n){return q.access(e,t,n)},_removeData:function(e,t){q.remove(e,t)}}),x.fn.extend({data:function(e,t){var n,r,i=this[0],o=0,s=null;if(e===undefined){if(this.length&&(s=L.get(i),1===i.nodeType&&!q.get(i,"hasDataAttrs"))){for(n=i.attributes;n.length>o;o++)r=n[o].name,0===r.indexOf("data-")&&(r=x.camelCase(r.substring(5)),P(i,r,s[r]));q.set(i,"hasDataAttrs",!0)}return s}return"object"==typeof e?this.each(function(){L.set(this,e)}):x.access(this,function(t){var n,r=x.camelCase(e);if(i&&t===undefined){if(n=L.get(i,e),n!==undefined)return n;if(n=L.get(i,r),n!==undefined)return n;if(n=P(i,r,undefined),n!==undefined)return n}else this.each(function(){var n=L.get(this,r);L.set(this,r,t),-1!==e.indexOf("-")&&n!==undefined&&L.set(this,e,t)})},null,t,arguments.length>1,null,!0)},removeData:function(e){return this.each(function(){L.remove(this,e)})}});function P(e,t,n){var r;if(n===undefined&&1===e.nodeType)if(r="data-"+t.replace(O,"-$1").toLowerCase(),n=e.getAttribute(r),"string"==typeof n){try{n="true"===n?!0:"false"===n?!1:"null"===n?null:+n+""===n?+n:H.test(n)?JSON.parse(n):n}catch(i){}L.set(e,t,n)}else n=undefined;return n}x.extend({queue:function(e,t,n){var r;return e?(t=(t||"fx")+"queue",r=q.get(e,t),n&&(!r||x.isArray(n)?r=q.access(e,t,x.makeArray(n)):r.push(n)),r||[]):undefined},dequeue:function(e,t){t=t||"fx";var n=x.queue(e,t),r=n.length,i=n.shift(),o=x._queueHooks(e,t),s=function(){x.dequeue(e,t)};"inprogress"===i&&(i=n.shift(),r--),o.cur=i,i&&("fx"===t&&n.unshift("inprogress"),delete o.stop,i.call(e,s,o)),!r&&o&&o.empty.fire()},_queueHooks:function(e,t){var n=t+"queueHooks";return q.get(e,n)||q.access(e,n,{empty:x.Callbacks("once memory").add(function(){q.remove(e,[t+"queue",n])})})}}),x.fn.extend({queue:function(e,t){var n=2;return"string"!=typeof e&&(t=e,e="fx",n--),n>arguments.length?x.queue(this[0],e):t===undefined?this:this.each(function(){var n=x.queue(this,e,t);$/;" f
+getGhostWriter handlers/ghost.go /^func getGhostWriter(w http.ResponseWriter) (*ghostWriter, bool) {$/;" f
+getGzipWriter handlers/gzip.go /^func getGzipWriter(w http.ResponseWriter) (*gzipResponseWriter, bool) {$/;" f
+getPredefinedTokenValue handlers/log.go /^func getPredefinedTokenValue(t string, w *statusResponseWriter, r *http.Request,$/;" f
+getSessionKeys handlers/redisstore.go /^func (this *RedisStore) getSessionKeys() ([]interface{}, error) {$/;" f
+getSessionWriter handlers/session.go /^func getSessionWriter(w http.ResponseWriter) (*sessResponseWriter, bool) {$/;" f
+getStatusWriter handlers/log.go /^func getStatusWriter(w http.ResponseWriter) (*statusResponseWriter, bool) {$/;" f
+ghostWriter handlers/ghost.go /^type ghostWriter struct {$/;" t
+gzipResponseWriter handlers/gzip.go /^type gzipResponseWriter struct {$/;" t
+hash handlers/favicon.go /^ var hash string$/;" v
+hash handlers/session.go /^func hash(s *Session) uint32 {$/;" f
+hashContent handlers/favicon.go /^func hashContent(buf []byte) string {$/;" f
+init templates/amber/amber.go /^func init() {$/;" f
+init templates/gotpl/gotpl.go /^func init() {$/;" f
+internalSession handlers/session.go /^type internalSession struct {$/;" t
+logRequest handlers/log.go /^func logRequest(w *statusResponseWriter, r *http.Request, st time.Time, opts *LogOptions) {$/;" f
+main ghostest/main.go /^func main() {$/;" f
+newMap handlers/sstore.go /^func (this *MemoryStore) newMap() {$/;" f
+newSession handlers/session.go /^func newSession(maxAge int) *Session {$/;" f
+parseSignedCookie handlers/session.go /^func parseSignedCookie(ck *http.Cookie, secret string) (string, error) {$/;" f
+renderContextPage ghostest/main.go /^func renderContextPage(w handlers.GhostWriter, r *http.Request) {$/;" f
+resetMaxAge handlers/session.go /^func (ø *Session) resetMaxAge() {$/;" f
+sess handlers/redisstore.go /^ var sess Session$/;" v
+sess handlers/session.go /^ var sess *Session$/;" v
+sessResponseWriter handlers/session.go /^type sessResponseWriter struct {$/;" t
+sessionPageInfo ghostest/main.go /^type sessionPageInfo struct {$/;" t
+sessionPageRenderer ghostest/main.go /^func sessionPageRenderer(w handlers.GhostWriter, r *http.Request) {$/;" f
+setContext ghostest/main.go /^func setContext(w handlers.GhostWriter, r *http.Request) {$/;" f
+setGzipHeaders handlers/gzip.go /^func setGzipHeaders(hdr http.Header) {$/;" f
+setVaryHeader handlers/gzip.go /^func setVaryHeader(hdr http.Header) {$/;" f
+setupTest handlers/session_test.go /^func setupTest(f func(w http.ResponseWriter, r *http.Request), ckPath string, secure bool, maxAge int) *httptest.Server {$/;" f
+signCookie handlers/session.go /^func signCookie(ck *http.Cookie, secret string) error {$/;" f
+statusResponseWriter handlers/log.go /^type statusResponseWriter struct {$/;" t
+testCase handlers/log_test.go /^type testCase struct {$/;" t
+testInvalidPath handlers/session_test.go /^func testInvalidPath(t *testing.T) {$/;" f
+testLogCase handlers/log_test.go /^func testLogCase(tc testCase, t *testing.T) {$/;" f
+testPanicIfNoSecret handlers/session_test.go /^func testPanicIfNoSecret(t *testing.T) {$/;" f
+testSecureOverHttp handlers/session_test.go /^func testSecureOverHttp(t *testing.T) {$/;" f
+testSessionBeforeExpires handlers/session_test.go /^func testSessionBeforeExpires(t *testing.T) {$/;" f
+testSessionExists handlers/session_test.go /^func testSessionExists(t *testing.T) {$/;" f
+testSessionExpires handlers/session_test.go /^func testSessionExpires(t *testing.T) {$/;" f
+testSessionPersists handlers/session_test.go /^func testSessionPersists(t *testing.T) {$/;" f
+testValidSubPath handlers/session_test.go /^func testValidSubPath(t *testing.T) {$/;" f
+userResponseWriter handlers/basicauth.go /^type userResponseWriter struct {$/;" t
+val handlers/session.go /^ var val string$/;" v
+will handlers/gzip.go /^ \/\/ The content-type will be explicitly set somewhere down the path of handlers$/;" t
+wrappedHandler handlers/context_test.go /^func wrappedHandler(t *testing.T, k, v interface{}, body string) http.Handler {$/;" f
+writeBody handlers/favicon.go /^func writeBody(w http.ResponseWriter, r *http.Request, buf []byte) {$/;" f
+writeHeaders handlers/favicon.go /^func writeHeaders(hdr http.Header, buf []byte, maxAge time.Duration, hash string) {$/;" f
+xtestSecureOverHttps handlers/session_test.go /^func xtestSecureOverHttps(t *testing.T) {$/;" f
diff --git a/Godeps/_workspace/src/github.com/PuerkitoBio/ghost/templates/amber/amber.go b/Godeps/_workspace/src/github.com/PuerkitoBio/ghost/templates/amber/amber.go
new file mode 100644
index 0000000000000000000000000000000000000000..81e67e14f76ae59d50dacb49fc0b53e8e6cf61d0
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/PuerkitoBio/ghost/templates/amber/amber.go
@@ -0,0 +1,38 @@
+package amber
+
+import (
+ "github.com/PuerkitoBio/ghost/templates"
+ "github.com/eknkc/amber"
+)
+
+// The template compiler for Amber templates.
+type AmberCompiler struct {
+ Options amber.Options
+ c *amber.Compiler
+}
+
+// Create a new Amber compiler with the specified Amber-specific options.
+func NewAmberCompiler(opts amber.Options) *AmberCompiler {
+ return &AmberCompiler{
+ opts,
+ nil,
+ }
+}
+
+// Implementation of the TemplateCompiler interface.
+func (this *AmberCompiler) Compile(f string) (templates.Templater, error) {
+ // amber.CompileFile creates a new compiler each time. To limit the number
+ // of allocations, reuse a compiler.
+ if this.c == nil {
+ this.c = amber.New()
+ }
+ this.c.Options = this.Options
+ if err := this.c.ParseFile(f); err != nil {
+ return nil, err
+ }
+ return this.c.Compile()
+}
+
+func init() {
+ templates.Register(".amber", NewAmberCompiler(amber.DefaultOptions))
+}
diff --git a/Godeps/_workspace/src/github.com/PuerkitoBio/ghost/templates/gotpl/gotpl.go b/Godeps/_workspace/src/github.com/PuerkitoBio/ghost/templates/gotpl/gotpl.go
new file mode 100644
index 0000000000000000000000000000000000000000..c012f52a37763413d3c74b339581fa79434a0ca0
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/PuerkitoBio/ghost/templates/gotpl/gotpl.go
@@ -0,0 +1,19 @@
+package gotpl
+
+import (
+ "html/template"
+
+ "github.com/PuerkitoBio/ghost/templates"
+)
+
+// The template compiler for native Go templates.
+type GoTemplateCompiler struct{}
+
+// Implementation of the TemplateCompiler interface.
+func (this *GoTemplateCompiler) Compile(f string) (templates.Templater, error) {
+ return template.ParseFiles(f)
+}
+
+func init() {
+ templates.Register(".tmpl", new(GoTemplateCompiler))
+}
diff --git a/Godeps/_workspace/src/github.com/PuerkitoBio/ghost/templates/template.go b/Godeps/_workspace/src/github.com/PuerkitoBio/ghost/templates/template.go
new file mode 100644
index 0000000000000000000000000000000000000000..1e1250af9469a50d784d5bd265b93aa204155c27
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/PuerkitoBio/ghost/templates/template.go
@@ -0,0 +1,129 @@
+package templates
+
+import (
+ "errors"
+ "io"
+ "net/http"
+ "os"
+ "path"
+ "path/filepath"
+ "sync"
+
+ "github.com/PuerkitoBio/ghost"
+)
+
+var (
+ ErrTemplateNotExist = errors.New("template does not exist")
+ ErrDirNotExist = errors.New("directory does not exist")
+
+ compilers = make(map[string]TemplateCompiler)
+
+ // The mutex guards the templaters map
+ mu sync.RWMutex
+ templaters = make(map[string]Templater)
+)
+
+// Defines the interface that the template compiler must return. The Go native
+// templates implement this interface.
+type Templater interface {
+ Execute(wr io.Writer, data interface{}) error
+}
+
+// The interface that a template engine must implement to be used by Ghost.
+type TemplateCompiler interface {
+ Compile(fileName string) (Templater, error)
+}
+
+// TODO : How to manage Go nested templates?
+// TODO : Support Go's port of the mustache template?
+
+// Register a template compiler for the specified extension. Extensions are case-sensitive.
+// The extension must start with a dot (it is compared to the result of path.Ext() on a
+// given file name).
+//
+// Registering is not thread-safe. Compilers should be registered before the http server
+// is started.
+// Compiling templates, on the other hand, is thread-safe.
+func Register(ext string, c TemplateCompiler) {
+ if c == nil {
+ panic("ghost: Register TemplateCompiler is nil")
+ }
+ if _, dup := compilers[ext]; dup {
+ panic("ghost: Register called twice for extension " + ext)
+ }
+ compilers[ext] = c
+}
+
+// Compile all templates that have a matching compiler (based on their extension) in the
+// specified directory.
+func CompileDir(dir string) error {
+ mu.Lock()
+ defer mu.Unlock()
+
+ return filepath.Walk(dir, func(path string, fi os.FileInfo, err error) error {
+ if fi == nil {
+ return ErrDirNotExist
+ }
+ if !fi.IsDir() {
+ err = compileTemplate(path, dir)
+ if err != nil {
+ ghost.LogFn("ghost.templates : error compiling template %s : %s", path, err)
+ return err
+ }
+ }
+ return nil
+ })
+}
+
+// Compile a single template file, using the specified base directory. The base
+// directory is used to set the name of the template (the part of the path relative to this
+// base directory is used as the name of the template).
+func Compile(path, base string) error {
+ mu.Lock()
+ defer mu.Unlock()
+
+ return compileTemplate(path, base)
+}
+
+// Compile the specified template file if there is a matching compiler.
+func compileTemplate(p, base string) error {
+ ext := path.Ext(p)
+ c, ok := compilers[ext]
+ // Ignore file if no template compiler exist for this extension
+ if ok {
+ t, err := c.Compile(p)
+ if err != nil {
+ return err
+ }
+ key, err := filepath.Rel(base, p)
+ if err != nil {
+ return err
+ }
+ ghost.LogFn("ghost.templates : storing template for file %s", key)
+ templaters[key] = t
+ }
+ return nil
+}
+
+// Execute the template.
+func Execute(tplName string, w io.Writer, data interface{}) error {
+ mu.RLock()
+ t, ok := templaters[tplName]
+ mu.RUnlock()
+ if !ok {
+ return ErrTemplateNotExist
+ }
+ return t.Execute(w, data)
+}
+
+// Render is the same as Execute, except that it takes a http.ResponseWriter
+// instead of a generic io.Writer, and sets the Content-Type to text/html.
+func Render(tplName string, w http.ResponseWriter, data interface{}) (err error) {
+ w.Header().Set("Content-Type", "text/html")
+ defer func() {
+ if err != nil {
+ w.Header().Del("Content-Type")
+ }
+ }()
+ return Execute(tplName, w, data)
+}
diff --git a/Godeps/_workspace/src/github.com/cactus/go-statsd-client/statsd/doc.go b/Godeps/_workspace/src/github.com/cactus/go-statsd-client/statsd/doc.go
new file mode 100644
index 0000000000000000000000000000000000000000..722e98046f3bf07bb0bd37e8b4b71977840e10d3
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/cactus/go-statsd-client/statsd/doc.go
@@ -0,0 +1,25 @@
+/*
+Package statsd provides a StatsD client implementation that is safe for
+concurrent use by multiple goroutines and for efficiency can be created and
+reused.
+
+Example usage:
+
+ // first create a client
+ client, err := statsd.New("127.0.0.1:8125", "test-client")
+ // handle any errors
+ if err != nil {
+ log.Fatal(err)
+ }
+ // make sure to clean up
+ defer client.Close()
+
+ // Send a stat
+ err = client.Inc("stat1", 42, 1.0)
+ // handle any errors
+ if err != nil {
+ log.Printf("Error sending metric: %+v", err)
+ }
+
+*/
+package statsd
diff --git a/Godeps/_workspace/src/github.com/cactus/go-statsd-client/statsd/main.go b/Godeps/_workspace/src/github.com/cactus/go-statsd-client/statsd/main.go
new file mode 100644
index 0000000000000000000000000000000000000000..8ab09e2787dfe7cdee90833de5356be2dd6e49f2
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/cactus/go-statsd-client/statsd/main.go
@@ -0,0 +1,159 @@
+package statsd
+
+import (
+ "errors"
+ "fmt"
+ "math/rand"
+ "net"
+)
+
+type Statter interface {
+ Inc(stat string, value int64, rate float32) error
+ Dec(stat string, value int64, rate float32) error
+ Gauge(stat string, value int64, rate float32) error
+ GaugeDelta(stat string, value int64, rate float32) error
+ Timing(stat string, delta int64, rate float32) error
+ Raw(stat string, value string, rate float32) error
+ SetPrefix(prefix string)
+ Close() error
+}
+
+type Client struct {
+ // underlying connection
+ c net.PacketConn
+ // resolved udp address
+ ra *net.UDPAddr
+ // prefix for statsd name
+ prefix string
+}
+
+// Close closes the connection and cleans up.
+func (s *Client) Close() error {
+ if s == nil {
+ return nil
+ }
+ err := s.c.Close()
+ return err
+}
+
+// Increments a statsd count type.
+// stat is a string name for the metric.
+// value is the integer value
+// rate is the sample rate (0.0 to 1.0)
+func (s *Client) Inc(stat string, value int64, rate float32) error {
+ dap := fmt.Sprintf("%d|c", value)
+ return s.Raw(stat, dap, rate)
+}
+
+// Decrements a statsd count type.
+// stat is a string name for the metric.
+// value is the integer value.
+// rate is the sample rate (0.0 to 1.0).
+func (s *Client) Dec(stat string, value int64, rate float32) error {
+ return s.Inc(stat, -value, rate)
+}
+
+// Submits/Updates a statsd gauge type.
+// stat is a string name for the metric.
+// value is the integer value.
+// rate is the sample rate (0.0 to 1.0).
+func (s *Client) Gauge(stat string, value int64, rate float32) error {
+ dap := fmt.Sprintf("%d|g", value)
+ return s.Raw(stat, dap, rate)
+}
+
+// Submits a delta to a statsd gauge.
+// stat is the string name for the metric.
+// value is the (positive or negative) change.
+// rate is the sample rate (0.0 to 1.0).
+func (s *Client) GaugeDelta(stat string, value int64, rate float32) error {
+ dap := fmt.Sprintf("%+d|g", value)
+ return s.Raw(stat, dap, rate)
+}
+
+// Submits a statsd timing type.
+// stat is a string name for the metric.
+// value is the integer value.
+// rate is the sample rate (0.0 to 1.0).
+func (s *Client) Timing(stat string, delta int64, rate float32) error {
+ dap := fmt.Sprintf("%d|ms", delta)
+ return s.Raw(stat, dap, rate)
+}
+
+// Raw formats the statsd event data, handles sampling, prepares it,
+// and sends it to the server.
+// stat is the string name for the metric.
+// value is a preformatted "raw" value string.
+// rate is the sample rate (0.0 to 1.0).
+func (s *Client) Raw(stat string, value string, rate float32) error {
+ if s == nil {
+ return nil
+ }
+ if rate < 1 {
+ if rand.Float32() < rate {
+ value = fmt.Sprintf("%s|@%f", value, rate)
+ } else {
+ return nil
+ }
+ }
+
+ if s.prefix != "" {
+ stat = fmt.Sprintf("%s.%s", s.prefix, stat)
+ }
+
+ data := fmt.Sprintf("%s:%s", stat, value)
+
+ _, err := s.send([]byte(data))
+ if err != nil {
+ return err
+ }
+ return nil
+}
+
+// Sets/Updates the statsd client prefix
+func (s *Client) SetPrefix(prefix string) {
+ if s == nil {
+ return
+ }
+ s.prefix = prefix
+}
+
+// sends the data to the server endpoint
+func (s *Client) send(data []byte) (int, error) {
+ // no need for locking here, as the underlying fdNet
+ // already serialized writes
+ n, err := s.c.(*net.UDPConn).WriteToUDP([]byte(data), s.ra)
+ if err != nil {
+ return 0, err
+ }
+ if n == 0 {
+ return n, errors.New("Wrote no bytes")
+ }
+ return n, nil
+}
+
+// Returns a pointer to a new Client, and an error.
+// addr is a string of the format "hostname:port", and must be parsable by
+// net.ResolveUDPAddr.
+// prefix is the statsd client prefix. Can be "" if no prefix is desired.
+func New(addr, prefix string) (*Client, error) {
+ c, err := net.ListenPacket("udp", ":0")
+ if err != nil {
+ return nil, err
+ }
+
+ ra, err := net.ResolveUDPAddr("udp", addr)
+ if err != nil {
+ return nil, err
+ }
+
+ client := &Client{
+ c: c,
+ ra: ra,
+ prefix: prefix}
+
+ return client, nil
+}
+
+// Compatibility alias
+var Dial = New
diff --git a/Godeps/_workspace/src/github.com/cactus/go-statsd-client/statsd/main_test.go b/Godeps/_workspace/src/github.com/cactus/go-statsd-client/statsd/main_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..586f03bb6403d5661d2df23b370f7932df8d40aa
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/cactus/go-statsd-client/statsd/main_test.go
@@ -0,0 +1,196 @@
+package statsd
+
+import (
+ "bytes"
+ "log"
+ "net"
+ "reflect"
+ "testing"
+ "time"
+)
+
+var statsdPacketTests = []struct {
+ Prefix string
+ Method string
+ Stat string
+ Value int64
+ Rate float32
+ Expected string
+}{
+ {"test", "Gauge", "gauge", 1, 1.0, "test.gauge:1|g"},
+ {"test", "Inc", "count", 1, 0.999999, "test.count:1|c|@0.999999"},
+ {"test", "Inc", "count", 1, 1.0, "test.count:1|c"},
+ {"test", "Dec", "count", 1, 1.0, "test.count:-1|c"},
+ {"test", "Timing", "timing", 1, 1.0, "test.timing:1|ms"},
+ {"", "Inc", "count", 1, 1.0, "count:1|c"},
+ {"", "GaugeDelta", "gauge", 1, 1.0, "gauge:+1|g"},
+ {"", "GaugeDelta", "gauge", -1, 1.0, "gauge:-1|g"},
+}
+
+func TestClient(t *testing.T) {
+ l, err := newUDPListener("127.0.0.1:0")
+ if err != nil {
+ t.Fatal(err)
+ }
+ defer l.Close()
+ for _, tt := range statsdPacketTests {
+ c, err := New(l.LocalAddr().String(), tt.Prefix)
+ if err != nil {
+ t.Fatal(err)
+ }
+ method := reflect.ValueOf(c).MethodByName(tt.Method)
+ e := method.Call([]reflect.Value{
+ reflect.ValueOf(tt.Stat),
+ reflect.ValueOf(tt.Value),
+ reflect.ValueOf(tt.Rate)})[0]
+ errInter := e.Interface()
+ if errInter != nil {
+ t.Fatal(errInter.(error))
+ }
+
+ data := make([]byte, 128)
+ _, _, err = l.ReadFrom(data)
+ if err != nil {
+ c.Close()
+ t.Fatal(err)
+ }
+
+ data = bytes.TrimRight(data, "\x00")
+ if bytes.Equal(data, []byte(tt.Expected)) != true {
+ c.Close()
+ t.Fatalf("%s got '%s' expected '%s'", tt.Method, data, tt.Expected)
+ }
+ c.Close()
+ }
+}
+
+func TestNilClient(t *testing.T) {
+ l, err := newUDPListener("127.0.0.1:0")
+ if err != nil {
+ t.Fatal(err)
+ }
+ defer l.Close()
+ for _, tt := range statsdPacketTests {
+ var c *Client
+
+ method := reflect.ValueOf(c).MethodByName(tt.Method)
+ e := method.Call([]reflect.Value{
+ reflect.ValueOf(tt.Stat),
+ reflect.ValueOf(tt.Value),
+ reflect.ValueOf(tt.Rate)})[0]
+ errInter := e.Interface()
+ if errInter != nil {
+ t.Fatal(errInter.(error))
+ }
+
+ data := make([]byte, 128)
+ n, _, err := l.ReadFrom(data)
+ // this is expected to error, since there should
+ // be no udp data sent, so the read will time out
+ if err == nil || n != 0 {
+ c.Close()
+ t.Fatal(err)
+ }
+ c.Close()
+ }
+}
+
+func TestNoopClient(t *testing.T) {
+ l, err := newUDPListener("127.0.0.1:0")
+ if err != nil {
+ t.Fatal(err)
+ }
+ defer l.Close()
+ for _, tt := range statsdPacketTests {
+ c, err := NewNoop(l.LocalAddr().String(), tt.Prefix)
+ if err != nil {
+ t.Fatal(err)
+ }
+ method := reflect.ValueOf(c).MethodByName(tt.Method)
+ e := method.Call([]reflect.Value{
+ reflect.ValueOf(tt.Stat),
+ reflect.ValueOf(tt.Value),
+ reflect.ValueOf(tt.Rate)})[0]
+ errInter := e.Interface()
+ if errInter != nil {
+ t.Fatal(errInter.(error))
+ }
+
+ data := make([]byte, 128)
+ n, _, err := l.ReadFrom(data)
+ // this is expected to error, since there should
+ // be no udp data sent, so the read will time out
+ if err == nil || n != 0 {
+ c.Close()
+ t.Fatal(err)
+ }
+ c.Close()
+ }
+}
+
+func newUDPListener(addr string) (*net.UDPConn, error) {
+ l, err := net.ListenPacket("udp", addr)
+ if err != nil {
+ return nil, err
+ }
+ l.SetDeadline(time.Now().Add(100 * time.Millisecond))
+ l.SetReadDeadline(time.Now().Add(100 * time.Millisecond))
+ l.SetWriteDeadline(time.Now().Add(100 * time.Millisecond))
+ return l.(*net.UDPConn), nil
+}
+
+func ExampleClient() {
+ // first create a client
+ client, err := Dial("127.0.0.1:8125", "test-client")
+ // handle any errors
+ if err != nil {
+ log.Fatal(err)
+ }
+ // make sure to clean up
+ defer client.Close()
+
+ // Send a stat
+ err = client.Inc("stat1", 42, 1.0)
+ // handle any errors
+ if err != nil {
+ log.Printf("Error sending metric: %+v", err)
+ }
+}
+
+func ExampleNilClient() {
+ // use interface so we can sub noop client if needed
+ var client *Client
+ var err error
+
+ // Send a stat
+ err = client.Inc("stat1", 42, 1.0)
+ // handle any errors
+ if err != nil {
+ log.Printf("Error sending metric: %+v", err)
+ }
+}
+
+func ExampleNoopClient() {
+ // use interface so we can sub noop client if needed
+ var client Statter
+ var err error
+
+ // first try to create a real client
+ client, err = Dial("not-resolvable:8125", "test-client")
+ // Lets say real client creation fails, but you don't care enough about
+ // stats that you don't want your program to run. Just log an error and
+ // make a NoopClient instead
+ if err != nil {
+ log.Println("Remote endpoint did not resolve. Disabling stats", err)
+ client, err = NewNoop()
+ }
+ // make sure to clean up
+ defer client.Close()
+
+ // Send a stat
+ err = client.Inc("stat1", 42, 1.0)
+ // handle any errors
+ if err != nil {
+ log.Printf("Error sending metric: %+v", err)
+ }
+}
diff --git a/Godeps/_workspace/src/github.com/cactus/go-statsd-client/statsd/noop.go b/Godeps/_workspace/src/github.com/cactus/go-statsd-client/statsd/noop.go
new file mode 100644
index 0000000000000000000000000000000000000000..ee11e74a9791847846aa6ba2745ed47bdb0309f5
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/cactus/go-statsd-client/statsd/noop.go
@@ -0,0 +1,74 @@
+package statsd
+
+type NoopClient struct {
+ // prefix for statsd name
+ prefix string
+}
+
+// Close closes the connection and cleans up.
+func (s *NoopClient) Close() error {
+ return nil
+}
+
+// Increments a statsd count type.
+// stat is a string name for the metric.
+// value is the integer value
+// rate is the sample rate (0.0 to 1.0)
+func (s *NoopClient) Inc(stat string, value int64, rate float32) error {
+ return nil
+}
+
+// Decrements a statsd count type.
+// stat is a string name for the metric.
+// value is the integer value.
+// rate is the sample rate (0.0 to 1.0).
+func (s *NoopClient) Dec(stat string, value int64, rate float32) error {
+ return nil
+}
+
+// Submits/Updates a statsd gauge type.
+// stat is a string name for the metric.
+// value is the integer value.
+// rate is the sample rate (0.0 to 1.0).
+func (s *NoopClient) Gauge(stat string, value int64, rate float32) error {
+ return nil
+}
+
+// Submits a delta to a statsd gauge.
+// stat is the string name for the metric.
+// value is the (positive or negative) change.
+// rate is the sample rate (0.0 to 1.0).
+func (s *NoopClient) GaugeDelta(stat string, value int64, rate float32) error {
+ return nil
+}
+
+// Submits a statsd timing type.
+// stat is a string name for the metric.
+// value is the integer value.
+// rate is the sample rate (0.0 to 1.0).
+func (s *NoopClient) Timing(stat string, delta int64, rate float32) error {
+ return nil
+}
+
+// Raw formats the statsd event data, handles sampling, prepares it,
+// and sends it to the server.
+// stat is the string name for the metric.
+// value is the preformatted "raw" value string.
+// rate is the sample rate (0.0 to 1.0).
+func (s *NoopClient) Raw(stat string, value string, rate float32) error {
+ return nil
+}
+
+// Sets/Updates the statsd client prefix
+func (s *NoopClient) SetPrefix(prefix string) {
+ s.prefix = prefix
+}
+
+// Returns a pointer to a new NoopClient, and an error (always nil, just
+// supplied to support api convention).
+// Use variadic arguments to support identical format as New, or a more
+// conventional no argument form.
+func NewNoop(a ...interface{}) (*NoopClient, error) {
+ noopClient := &NoopClient{}
+ return noopClient, nil
+}
diff --git a/Godeps/_workspace/src/github.com/cactus/go-statsd-client/statsd/test-client/main.go b/Godeps/_workspace/src/github.com/cactus/go-statsd-client/statsd/test-client/main.go
new file mode 100644
index 0000000000000000000000000000000000000000..7a7786e19ca6affa9db5220b6fec6f52b622aace
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/cactus/go-statsd-client/statsd/test-client/main.go
@@ -0,0 +1,88 @@
+package main
+
+import (
+ "fmt"
+ "github.com/cactus/go-statsd-client/statsd"
+ flags "github.com/jessevdk/go-flags"
+ "log"
+ "os"
+ "time"
+)
+
+func main() {
+
+ // command line flags
+ var opts struct {
+ HostPort string `long:"host" default:"127.0.0.1:8125" description:"host:port of statsd server"`
+ Prefix string `long:"prefix" default:"test-client" description:"Statsd prefix"`
+ StatType string `long:"type" default:"count" description:"stat type to send. Can be timing, count, guage"`
+ StatValue int64 `long:"value" default:"1" description:"Value to send"`
+ Name string `short:"n" long:"name" default:"counter" description:"stat name"`
+ Rate float32 `short:"r" long:"rate" default:"1.0" description:"sample rate"`
+ Volume int `short:"c" long:"count" default:"1000" description:"Number of stats to send. Volume."`
+ Nil bool `long:"nil" default:"false" description:"Use nil client"`
+ Duration time.Duration `short:"d" long:"duration" default:"10s" description:"How long to spread the volume across. Each second of duration volume/seconds events will be sent."`
+ }
+
+ // parse said flags
+ _, err := flags.Parse(&opts)
+ if err != nil {
+ if e, ok := err.(*flags.Error); ok {
+ if e.Type == flags.ErrHelp {
+ os.Exit(0)
+ }
+ }
+ fmt.Printf("Error: %+v\n", err)
+ os.Exit(1)
+ }
+
+ var client *statsd.Client
+ if !opts.Nil {
+ client, err = statsd.New(opts.HostPort, opts.Prefix)
+ if err != nil {
+ log.Fatal(err)
+ }
+ defer client.Close()
+ }
+
+ var stat func(stat string, value int64, rate float32) error
+ switch opts.StatType {
+ case "count":
+ stat = func(stat string, value int64, rate float32) error {
+ return client.Inc(stat, value, rate)
+ }
+ case "gauge":
+ stat = func(stat string, value int64, rate float32) error {
+ return client.Gauge(stat, value, rate)
+ }
+ case "timing":
+ stat = func(stat string, value int64, rate float32) error {
+ return client.Timing(stat, value, rate)
+ }
+ default:
+ log.Fatal("Unsupported state type")
+ }
+
+ pertick := opts.Volume / int(opts.Duration.Seconds()) / 10
+ // add some extra tiem, because the first tick takes a while
+ ender := time.After(opts.Duration + 100*time.Millisecond)
+ c := time.Tick(time.Second / 10)
+ count := 0
+ for {
+ select {
+ case <-c:
+ for x := 0; x < pertick; x++ {
+ err := stat(opts.Name, opts.StatValue, opts.Rate)
+ if err != nil {
+ log.Printf("Got Error: %+v", err)
+ break
+ }
+ count += 1
+ }
+ case <-ender:
+ log.Printf("%d events called", count)
+ os.Exit(0)
+ return
+ }
+ }
+}
diff --git a/third_party/github.com/coreos/go-etcd/etcd/add_child.go b/Godeps/_workspace/src/github.com/coreos/go-etcd/etcd/add_child.go
similarity index 100%
rename from third_party/github.com/coreos/go-etcd/etcd/add_child.go
rename to Godeps/_workspace/src/github.com/coreos/go-etcd/etcd/add_child.go
diff --git a/third_party/github.com/coreos/go-etcd/etcd/add_child_test.go b/Godeps/_workspace/src/github.com/coreos/go-etcd/etcd/add_child_test.go
similarity index 100%
rename from third_party/github.com/coreos/go-etcd/etcd/add_child_test.go
rename to Godeps/_workspace/src/github.com/coreos/go-etcd/etcd/add_child_test.go
diff --git a/third_party/github.com/coreos/go-etcd/etcd/client.go b/Godeps/_workspace/src/github.com/coreos/go-etcd/etcd/client.go
similarity index 100%
rename from third_party/github.com/coreos/go-etcd/etcd/client.go
rename to Godeps/_workspace/src/github.com/coreos/go-etcd/etcd/client.go
diff --git a/third_party/github.com/coreos/go-etcd/etcd/client_test.go b/Godeps/_workspace/src/github.com/coreos/go-etcd/etcd/client_test.go
similarity index 100%
rename from third_party/github.com/coreos/go-etcd/etcd/client_test.go
rename to Godeps/_workspace/src/github.com/coreos/go-etcd/etcd/client_test.go
diff --git a/third_party/github.com/coreos/go-etcd/etcd/cluster.go b/Godeps/_workspace/src/github.com/coreos/go-etcd/etcd/cluster.go
similarity index 100%
rename from third_party/github.com/coreos/go-etcd/etcd/cluster.go
rename to Godeps/_workspace/src/github.com/coreos/go-etcd/etcd/cluster.go
diff --git a/third_party/github.com/coreos/go-etcd/etcd/compare_and_delete.go b/Godeps/_workspace/src/github.com/coreos/go-etcd/etcd/compare_and_delete.go
similarity index 100%
rename from third_party/github.com/coreos/go-etcd/etcd/compare_and_delete.go
rename to Godeps/_workspace/src/github.com/coreos/go-etcd/etcd/compare_and_delete.go
diff --git a/third_party/github.com/coreos/go-etcd/etcd/compare_and_delete_test.go b/Godeps/_workspace/src/github.com/coreos/go-etcd/etcd/compare_and_delete_test.go
similarity index 100%
rename from third_party/github.com/coreos/go-etcd/etcd/compare_and_delete_test.go
rename to Godeps/_workspace/src/github.com/coreos/go-etcd/etcd/compare_and_delete_test.go
diff --git a/third_party/github.com/coreos/go-etcd/etcd/compare_and_swap.go b/Godeps/_workspace/src/github.com/coreos/go-etcd/etcd/compare_and_swap.go
similarity index 100%
rename from third_party/github.com/coreos/go-etcd/etcd/compare_and_swap.go
rename to Godeps/_workspace/src/github.com/coreos/go-etcd/etcd/compare_and_swap.go
diff --git a/third_party/github.com/coreos/go-etcd/etcd/compare_and_swap_test.go b/Godeps/_workspace/src/github.com/coreos/go-etcd/etcd/compare_and_swap_test.go
similarity index 100%
rename from third_party/github.com/coreos/go-etcd/etcd/compare_and_swap_test.go
rename to Godeps/_workspace/src/github.com/coreos/go-etcd/etcd/compare_and_swap_test.go
diff --git a/third_party/github.com/coreos/go-etcd/etcd/debug.go b/Godeps/_workspace/src/github.com/coreos/go-etcd/etcd/debug.go
similarity index 100%
rename from third_party/github.com/coreos/go-etcd/etcd/debug.go
rename to Godeps/_workspace/src/github.com/coreos/go-etcd/etcd/debug.go
diff --git a/third_party/github.com/coreos/go-etcd/etcd/debug_test.go b/Godeps/_workspace/src/github.com/coreos/go-etcd/etcd/debug_test.go
similarity index 100%
rename from third_party/github.com/coreos/go-etcd/etcd/debug_test.go
rename to Godeps/_workspace/src/github.com/coreos/go-etcd/etcd/debug_test.go
diff --git a/third_party/github.com/coreos/go-etcd/etcd/delete.go b/Godeps/_workspace/src/github.com/coreos/go-etcd/etcd/delete.go
similarity index 100%
rename from third_party/github.com/coreos/go-etcd/etcd/delete.go
rename to Godeps/_workspace/src/github.com/coreos/go-etcd/etcd/delete.go
diff --git a/third_party/github.com/coreos/go-etcd/etcd/delete_test.go b/Godeps/_workspace/src/github.com/coreos/go-etcd/etcd/delete_test.go
similarity index 100%
rename from third_party/github.com/coreos/go-etcd/etcd/delete_test.go
rename to Godeps/_workspace/src/github.com/coreos/go-etcd/etcd/delete_test.go
diff --git a/third_party/github.com/coreos/go-etcd/etcd/error.go b/Godeps/_workspace/src/github.com/coreos/go-etcd/etcd/error.go
similarity index 100%
rename from third_party/github.com/coreos/go-etcd/etcd/error.go
rename to Godeps/_workspace/src/github.com/coreos/go-etcd/etcd/error.go
diff --git a/third_party/github.com/coreos/go-etcd/etcd/get.go b/Godeps/_workspace/src/github.com/coreos/go-etcd/etcd/get.go
similarity index 100%
rename from third_party/github.com/coreos/go-etcd/etcd/get.go
rename to Godeps/_workspace/src/github.com/coreos/go-etcd/etcd/get.go
diff --git a/third_party/github.com/coreos/go-etcd/etcd/get_test.go b/Godeps/_workspace/src/github.com/coreos/go-etcd/etcd/get_test.go
similarity index 100%
rename from third_party/github.com/coreos/go-etcd/etcd/get_test.go
rename to Godeps/_workspace/src/github.com/coreos/go-etcd/etcd/get_test.go
diff --git a/third_party/github.com/coreos/go-etcd/etcd/options.go b/Godeps/_workspace/src/github.com/coreos/go-etcd/etcd/options.go
similarity index 100%
rename from third_party/github.com/coreos/go-etcd/etcd/options.go
rename to Godeps/_workspace/src/github.com/coreos/go-etcd/etcd/options.go
diff --git a/third_party/github.com/coreos/go-etcd/etcd/requests.go b/Godeps/_workspace/src/github.com/coreos/go-etcd/etcd/requests.go
similarity index 87%
rename from third_party/github.com/coreos/go-etcd/etcd/requests.go
rename to Godeps/_workspace/src/github.com/coreos/go-etcd/etcd/requests.go
index 5d8b45a2d39386b576987620effbc9abc0016bd5..fa6d36a9f2e1df6774c0a9cb4913ab7cc331dbe3 100644
--- a/third_party/github.com/coreos/go-etcd/etcd/requests.go
+++ b/Godeps/_workspace/src/github.com/coreos/go-etcd/etcd/requests.go
@@ -3,6 +3,7 @@ package etcd
import (
"errors"
"fmt"
+ "io"
"io/ioutil"
"math/rand"
"net/http"
@@ -179,6 +180,7 @@ func (c *Client) SendRequest(rr *RawRequest) (*RawResponse, error) {
// we connect to a leader
sleep := 25 * time.Millisecond
maxSleep := time.Second
+
for attempt := 0; ; attempt++ {
if attempt > 0 {
select {
@@ -192,7 +194,7 @@ func (c *Client) SendRequest(rr *RawRequest) (*RawResponse, error) {
}
}
- logger.Debug("Connecting to etcd: attempt", attempt+1, "for", rr.RelativePath)
+ logger.Debug("Connecting to etcd: attempt ", attempt+1, " for ", rr.RelativePath)
if rr.Method == "GET" && c.config.Consistency == WEAK_CONSISTENCY {
// If it's a GET and consistency level is set to WEAK,
@@ -214,21 +216,29 @@ func (c *Client) SendRequest(rr *RawRequest) (*RawResponse, error) {
logger.Debug("send.request.to ", httpPath, " | method ", rr.Method)
- reqLock.Lock()
- if rr.Values == nil {
- if req, err = http.NewRequest(rr.Method, httpPath, nil); err != nil {
- return nil, err
- }
- } else {
- body := strings.NewReader(rr.Values.Encode())
- if req, err = http.NewRequest(rr.Method, httpPath, body); err != nil {
- return nil, err
+ req, err := func() (*http.Request, error) {
+ reqLock.Lock()
+ defer reqLock.Unlock()
+
+ if rr.Values == nil {
+ if req, err = http.NewRequest(rr.Method, httpPath, nil); err != nil {
+ return nil, err
+ }
+ } else {
+ body := strings.NewReader(rr.Values.Encode())
+ if req, err = http.NewRequest(rr.Method, httpPath, body); err != nil {
+ return nil, err
+ }
+
+ req.Header.Set("Content-Type",
+ "application/x-www-form-urlencoded; param=value")
}
+ return req, nil
+ }()
- req.Header.Set("Content-Type",
- "application/x-www-form-urlencoded; param=value")
+ if err != nil {
+ return nil, err
}
- reqLock.Unlock()
resp, err = c.httpClient.Do(req)
defer func() {
@@ -248,7 +258,7 @@ func (c *Client) SendRequest(rr *RawRequest) (*RawResponse, error) {
// network error, change a machine!
if err != nil {
- logger.Debug("network error:", err.Error())
+ logger.Debug("network error: ", err.Error())
lastResp := http.Response{}
if checkErr := checkRetry(c.cluster, numReqs, lastResp, err); checkErr != nil {
return nil, checkErr
@@ -259,13 +269,13 @@ func (c *Client) SendRequest(rr *RawRequest) (*RawResponse, error) {
}
// if there is no error, it should receive response
- logger.Debug("recv.response.from", httpPath)
+ logger.Debug("recv.response.from ", httpPath)
if validHttpStatusCode[resp.StatusCode] {
// try to read byte code and break the loop
respBody, err = ioutil.ReadAll(resp.Body)
if err == nil {
- logger.Debug("recv.success.", httpPath)
+ logger.Debug("recv.success ", httpPath)
break
}
// ReadAll error may be caused due to cancel request
@@ -274,6 +284,15 @@ func (c *Client) SendRequest(rr *RawRequest) (*RawResponse, error) {
return nil, ErrRequestCancelled
default:
}
+
+ if err == io.ErrUnexpectedEOF {
+ // underlying connection was closed prematurely, probably by timeout
+ // TODO: empty body or unexpectedEOF can cause http.Transport to get hosed;
+ // this allows the client to detect that and take evasive action. Need
+ // to revisit once code.google.com/p/go/issues/detail?id=8648 gets fixed.
+ respBody = []byte{}
+ break
+ }
}
// if resp is TemporaryRedirect, set the new leader and retry
@@ -286,7 +305,7 @@ func (c *Client) SendRequest(rr *RawRequest) (*RawResponse, error) {
// Update cluster leader based on redirect location
// because it should point to the leader address
c.cluster.updateLeaderFromURL(u)
- logger.Debug("recv.response.relocate", u.String())
+ logger.Debug("recv.response.relocate ", u.String())
}
resp.Body.Close()
continue
diff --git a/third_party/github.com/coreos/go-etcd/etcd/response.go b/Godeps/_workspace/src/github.com/coreos/go-etcd/etcd/response.go
similarity index 100%
rename from third_party/github.com/coreos/go-etcd/etcd/response.go
rename to Godeps/_workspace/src/github.com/coreos/go-etcd/etcd/response.go
diff --git a/third_party/github.com/coreos/go-etcd/etcd/set_curl_chan_test.go b/Godeps/_workspace/src/github.com/coreos/go-etcd/etcd/set_curl_chan_test.go
similarity index 100%
rename from third_party/github.com/coreos/go-etcd/etcd/set_curl_chan_test.go
rename to Godeps/_workspace/src/github.com/coreos/go-etcd/etcd/set_curl_chan_test.go
diff --git a/third_party/github.com/coreos/go-etcd/etcd/set_update_create.go b/Godeps/_workspace/src/github.com/coreos/go-etcd/etcd/set_update_create.go
similarity index 98%
rename from third_party/github.com/coreos/go-etcd/etcd/set_update_create.go
rename to Godeps/_workspace/src/github.com/coreos/go-etcd/etcd/set_update_create.go
index cb0d5674775c615c00c76623e7e1a993fc9cf6aa..e2840cf356704265a934bb86d29fe76291e8b43d 100644
--- a/third_party/github.com/coreos/go-etcd/etcd/set_update_create.go
+++ b/Godeps/_workspace/src/github.com/coreos/go-etcd/etcd/set_update_create.go
@@ -13,7 +13,7 @@ func (c *Client) Set(key string, value string, ttl uint64) (*Response, error) {
return raw.Unmarshal()
}
-// Set sets the given key to a directory.
+// SetDir sets the given key to a directory.
// It will create a new directory or replace the old key value pair by a directory.
// It will not replace a existing directory.
func (c *Client) SetDir(key string, ttl uint64) (*Response, error) {
diff --git a/third_party/github.com/coreos/go-etcd/etcd/set_update_create_test.go b/Godeps/_workspace/src/github.com/coreos/go-etcd/etcd/set_update_create_test.go
similarity index 100%
rename from third_party/github.com/coreos/go-etcd/etcd/set_update_create_test.go
rename to Godeps/_workspace/src/github.com/coreos/go-etcd/etcd/set_update_create_test.go
diff --git a/third_party/github.com/coreos/go-etcd/etcd/version.go b/Godeps/_workspace/src/github.com/coreos/go-etcd/etcd/version.go
similarity index 100%
rename from third_party/github.com/coreos/go-etcd/etcd/version.go
rename to Godeps/_workspace/src/github.com/coreos/go-etcd/etcd/version.go
diff --git a/third_party/github.com/coreos/go-etcd/etcd/watch.go b/Godeps/_workspace/src/github.com/coreos/go-etcd/etcd/watch.go
similarity index 100%
rename from third_party/github.com/coreos/go-etcd/etcd/watch.go
rename to Godeps/_workspace/src/github.com/coreos/go-etcd/etcd/watch.go
diff --git a/third_party/github.com/coreos/go-etcd/etcd/watch_test.go b/Godeps/_workspace/src/github.com/coreos/go-etcd/etcd/watch_test.go
similarity index 100%
rename from third_party/github.com/coreos/go-etcd/etcd/watch_test.go
rename to Godeps/_workspace/src/github.com/coreos/go-etcd/etcd/watch_test.go
diff --git a/Godeps/_workspace/src/github.com/garyburd/redigo/redis/commandinfo.go b/Godeps/_workspace/src/github.com/garyburd/redigo/redis/commandinfo.go
new file mode 100644
index 0000000000000000000000000000000000000000..7e6cf37d21dfd06ba3742da05d6026f37bfe0c15
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/garyburd/redigo/redis/commandinfo.go
@@ -0,0 +1,45 @@
+// Copyright 2014 Gary Burd
+//
+// Licensed under the Apache License, Version 2.0 (the "License"): you may
+// not use this file except in compliance with the License. You may obtain
+// a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+// License for the specific language governing permissions and limitations
+// under the License.
+
+package redis
+
+import (
+ "strings"
+)
+
+const (
+ watchState = 1 << iota
+ multiState
+ subscribeState
+ monitorState
+)
+
+type commandInfo struct {
+ set, clear int
+}
+
+var commandInfos = map[string]commandInfo{
+ "WATCH": {set: watchState},
+ "UNWATCH": {clear: watchState},
+ "MULTI": {set: multiState},
+ "EXEC": {clear: watchState | multiState},
+ "DISCARD": {clear: watchState | multiState},
+ "PSUBSCRIBE": {set: subscribeState},
+ "SUBSCRIBE": {set: subscribeState},
+ "MONITOR": {set: monitorState},
+}
+
+func lookupCommandInfo(commandName string) commandInfo {
+ return commandInfos[strings.ToUpper(commandName)]
+}
diff --git a/Godeps/_workspace/src/github.com/garyburd/redigo/redis/conn.go b/Godeps/_workspace/src/github.com/garyburd/redigo/redis/conn.go
new file mode 100644
index 0000000000000000000000000000000000000000..0d2511d45510694a994c31ea7ac4dc261bd5a6c5
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/garyburd/redigo/redis/conn.go
@@ -0,0 +1,428 @@
+// Copyright 2012 Gary Burd
+//
+// Licensed under the Apache License, Version 2.0 (the "License"): you may
+// not use this file except in compliance with the License. You may obtain
+// a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+// License for the specific language governing permissions and limitations
+// under the License.
+
+package redis
+
+import (
+ "bufio"
+ "bytes"
+ "errors"
+ "fmt"
+ "io"
+ "net"
+ "strconv"
+ "sync"
+ "time"
+)
+
+// conn is the low-level implementation of Conn
+type conn struct {
+
+ // Shared
+ mu sync.Mutex
+ pending int
+ err error
+ conn net.Conn
+
+ // Read
+ readTimeout time.Duration
+ br *bufio.Reader
+
+ // Write
+ writeTimeout time.Duration
+ bw *bufio.Writer
+
+ // Scratch space for formatting argument length.
+ // '*' or '$', length, "\r\n"
+ lenScratch [32]byte
+
+ // Scratch space for formatting integers and floats.
+ numScratch [40]byte
+}
+
+// Dial connects to the Redis server at the given network and address.
+func Dial(network, address string) (Conn, error) {
+ c, err := net.Dial(network, address)
+ if err != nil {
+ return nil, err
+ }
+ return NewConn(c, 0, 0), nil
+}
+
+// DialTimeout acts like Dial but takes timeouts for establishing the
+// connection to the server, writing a command and reading a reply.
+func DialTimeout(network, address string, connectTimeout, readTimeout, writeTimeout time.Duration) (Conn, error) {
+ var c net.Conn
+ var err error
+ if connectTimeout > 0 {
+ c, err = net.DialTimeout(network, address, connectTimeout)
+ } else {
+ c, err = net.Dial(network, address)
+ }
+ if err != nil {
+ return nil, err
+ }
+ return NewConn(c, readTimeout, writeTimeout), nil
+}
+
+// NewConn returns a new Redigo connection for the given net connection.
+func NewConn(netConn net.Conn, readTimeout, writeTimeout time.Duration) Conn {
+ return &conn{
+ conn: netConn,
+ bw: bufio.NewWriter(netConn),
+ br: bufio.NewReader(netConn),
+ readTimeout: readTimeout,
+ writeTimeout: writeTimeout,
+ }
+}
+
+func (c *conn) Close() error {
+ c.mu.Lock()
+ err := c.err
+ if c.err == nil {
+ c.err = errors.New("redigo: closed")
+ err = c.conn.Close()
+ }
+ c.mu.Unlock()
+ return err
+}
+
+func (c *conn) fatal(err error) error {
+ c.mu.Lock()
+ if c.err == nil {
+ c.err = err
+ // Close connection to force errors on subsequent calls and to unblock
+ // other reader or writer.
+ c.conn.Close()
+ }
+ c.mu.Unlock()
+ return err
+}
+
+func (c *conn) Err() error {
+ c.mu.Lock()
+ err := c.err
+ c.mu.Unlock()
+ return err
+}
+
+func (c *conn) writeLen(prefix byte, n int) error {
+ c.lenScratch[len(c.lenScratch)-1] = '\n'
+ c.lenScratch[len(c.lenScratch)-2] = '\r'
+ i := len(c.lenScratch) - 3
+ for {
+ c.lenScratch[i] = byte('0' + n%10)
+ i -= 1
+ n = n / 10
+ if n == 0 {
+ break
+ }
+ }
+ c.lenScratch[i] = prefix
+ _, err := c.bw.Write(c.lenScratch[i:])
+ return err
+}
+
+func (c *conn) writeString(s string) error {
+ c.writeLen('$', len(s))
+ c.bw.WriteString(s)
+ _, err := c.bw.WriteString("\r\n")
+ return err
+}
+
+func (c *conn) writeBytes(p []byte) error {
+ c.writeLen('$', len(p))
+ c.bw.Write(p)
+ _, err := c.bw.WriteString("\r\n")
+ return err
+}
+
+func (c *conn) writeInt64(n int64) error {
+ return c.writeBytes(strconv.AppendInt(c.numScratch[:0], n, 10))
+}
+
+func (c *conn) writeFloat64(n float64) error {
+ return c.writeBytes(strconv.AppendFloat(c.numScratch[:0], n, 'g', -1, 64))
+}
+
+func (c *conn) writeCommand(cmd string, args []interface{}) (err error) {
+ c.writeLen('*', 1+len(args))
+ err = c.writeString(cmd)
+ for _, arg := range args {
+ if err != nil {
+ break
+ }
+ switch arg := arg.(type) {
+ case string:
+ err = c.writeString(arg)
+ case []byte:
+ err = c.writeBytes(arg)
+ case int:
+ err = c.writeInt64(int64(arg))
+ case int64:
+ err = c.writeInt64(arg)
+ case float64:
+ err = c.writeFloat64(arg)
+ case bool:
+ if arg {
+ err = c.writeString("1")
+ } else {
+ err = c.writeString("0")
+ }
+ case nil:
+ err = c.writeString("")
+ default:
+ var buf bytes.Buffer
+ fmt.Fprint(&buf, arg)
+ err = c.writeBytes(buf.Bytes())
+ }
+ }
+ return err
+}
+
+type protocolError string
+
+func (pe protocolError) Error() string {
+ return fmt.Sprintf("redigo: %s (possible server error or unsupported concurrent read by application)", string(pe))
+}
+
+func (c *conn) readLine() ([]byte, error) {
+ p, err := c.br.ReadSlice('\n')
+ if err == bufio.ErrBufferFull {
+ return nil, protocolError("long response line")
+ }
+ if err != nil {
+ return nil, err
+ }
+ i := len(p) - 2
+ if i < 0 || p[i] != '\r' {
+ return nil, protocolError("bad response line terminator")
+ }
+ return p[:i], nil
+}
+
+// parseLen parses bulk string and array lengths.
+func parseLen(p []byte) (int, error) {
+ if len(p) == 0 {
+ return -1, protocolError("malformed length")
+ }
+
+ if p[0] == '-' && len(p) == 2 && p[1] == '1' {
+ // handle $-1 and $-1 null replies.
+ return -1, nil
+ }
+
+ var n int
+ for _, b := range p {
+ n *= 10
+ if b < '0' || b > '9' {
+ return -1, protocolError("illegal bytes in length")
+ }
+ n += int(b - '0')
+ }
+
+ return n, nil
+}
+
+// parseInt parses an integer reply.
+func parseInt(p []byte) (interface{}, error) {
+ if len(p) == 0 {
+ return 0, protocolError("malformed integer")
+ }
+
+ var negate bool
+ if p[0] == '-' {
+ negate = true
+ p = p[1:]
+ if len(p) == 0 {
+ return 0, protocolError("malformed integer")
+ }
+ }
+
+ var n int64
+ for _, b := range p {
+ n *= 10
+ if b < '0' || b > '9' {
+ return 0, protocolError("illegal bytes in length")
+ }
+ n += int64(b - '0')
+ }
+
+ if negate {
+ n = -n
+ }
+ return n, nil
+}
+
+var (
+ okReply interface{} = "OK"
+ pongReply interface{} = "PONG"
+)
+
+func (c *conn) readReply() (interface{}, error) {
+ line, err := c.readLine()
+ if err != nil {
+ return nil, err
+ }
+ if len(line) == 0 {
+ return nil, protocolError("short response line")
+ }
+ switch line[0] {
+ case '+':
+ switch {
+ case len(line) == 3 && line[1] == 'O' && line[2] == 'K':
+ // Avoid allocation for frequent "+OK" response.
+ return okReply, nil
+ case len(line) == 5 && line[1] == 'P' && line[2] == 'O' && line[3] == 'N' && line[4] == 'G':
+ // Avoid allocation in PING command benchmarks :)
+ return pongReply, nil
+ default:
+ return string(line[1:]), nil
+ }
+ case '-':
+ return Error(string(line[1:])), nil
+ case ':':
+ return parseInt(line[1:])
+ case '$':
+ n, err := parseLen(line[1:])
+ if n < 0 || err != nil {
+ return nil, err
+ }
+ p := make([]byte, n)
+ _, err = io.ReadFull(c.br, p)
+ if err != nil {
+ return nil, err
+ }
+ if line, err := c.readLine(); err != nil {
+ return nil, err
+ } else if len(line) != 0 {
+ return nil, protocolError("bad bulk string format")
+ }
+ return p, nil
+ case '*':
+ n, err := parseLen(line[1:])
+ if n < 0 || err != nil {
+ return nil, err
+ }
+ r := make([]interface{}, n)
+ for i := range r {
+ r[i], err = c.readReply()
+ if err != nil {
+ return nil, err
+ }
+ }
+ return r, nil
+ }
+ return nil, protocolError("unexpected response line")
+}
+
+func (c *conn) Send(cmd string, args ...interface{}) error {
+ c.mu.Lock()
+ c.pending += 1
+ c.mu.Unlock()
+ if c.writeTimeout != 0 {
+ c.conn.SetWriteDeadline(time.Now().Add(c.writeTimeout))
+ }
+ if err := c.writeCommand(cmd, args); err != nil {
+ return c.fatal(err)
+ }
+ return nil
+}
+
+func (c *conn) Flush() error {
+ if c.writeTimeout != 0 {
+ c.conn.SetWriteDeadline(time.Now().Add(c.writeTimeout))
+ }
+ if err := c.bw.Flush(); err != nil {
+ return c.fatal(err)
+ }
+ return nil
+}
+
+func (c *conn) Receive() (reply interface{}, err error) {
+ if c.readTimeout != 0 {
+ c.conn.SetReadDeadline(time.Now().Add(c.readTimeout))
+ }
+ if reply, err = c.readReply(); err != nil {
+ return nil, c.fatal(err)
+ }
+ // When using pub/sub, the number of receives can be greater than the
+ // number of sends. To enable normal use of the connection after
+ // unsubscribing from all channels, we do not decrement pending to a
+ // negative value.
+ //
+ // The pending field is decremented after the reply is read to handle the
+ // case where Receive is called before Send.
+ c.mu.Lock()
+ if c.pending > 0 {
+ c.pending -= 1
+ }
+ c.mu.Unlock()
+ if err, ok := reply.(Error); ok {
+ return nil, err
+ }
+ return
+}
+
+func (c *conn) Do(cmd string, args ...interface{}) (interface{}, error) {
+ c.mu.Lock()
+ pending := c.pending
+ c.pending = 0
+ c.mu.Unlock()
+
+ if cmd == "" && pending == 0 {
+ return nil, nil
+ }
+
+ if c.writeTimeout != 0 {
+ c.conn.SetWriteDeadline(time.Now().Add(c.writeTimeout))
+ }
+
+ if cmd != "" {
+ c.writeCommand(cmd, args)
+ }
+
+ if err := c.bw.Flush(); err != nil {
+ return nil, c.fatal(err)
+ }
+
+ if c.readTimeout != 0 {
+ c.conn.SetReadDeadline(time.Now().Add(c.readTimeout))
+ }
+
+ if cmd == "" {
+ reply := make([]interface{}, pending)
+ for i := range reply {
+ r, e := c.readReply()
+ if e != nil {
+ return nil, c.fatal(e)
+ }
+ reply[i] = r
+ }
+ return reply, nil
+ }
+
+ var err error
+ var reply interface{}
+ for i := 0; i <= pending; i++ {
+ var e error
+ if reply, e = c.readReply(); e != nil {
+ return nil, c.fatal(e)
+ }
+ if e, ok := reply.(Error); ok && err == nil {
+ err = e
+ }
+ }
+ return reply, err
+}
diff --git a/Godeps/_workspace/src/github.com/garyburd/redigo/redis/conn_test.go b/Godeps/_workspace/src/github.com/garyburd/redigo/redis/conn_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..06cd7706afee8efa952e857ff14d2f3ddd20a3b2
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/garyburd/redigo/redis/conn_test.go
@@ -0,0 +1,506 @@
+// Copyright 2012 Gary Burd
+//
+// Licensed under the Apache License, Version 2.0 (the "License"): you may
+// not use this file except in compliance with the License. You may obtain
+// a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+// License for the specific language governing permissions and limitations
+// under the License.
+
+package redis_test
+
+import (
+ "bufio"
+ "bytes"
+ "math"
+ "net"
+ "reflect"
+ "strings"
+ "testing"
+ "time"
+
+ "github.com/garyburd/redigo/redis"
+)
+
+var writeTests = []struct {
+ args []interface{}
+ expected string
+}{
+ {
+ []interface{}{"SET", "foo", "bar"},
+ "*3\r\n$3\r\nSET\r\n$3\r\nfoo\r\n$3\r\nbar\r\n",
+ },
+ {
+ []interface{}{"SET", "foo", "bar"},
+ "*3\r\n$3\r\nSET\r\n$3\r\nfoo\r\n$3\r\nbar\r\n",
+ },
+ {
+ []interface{}{"SET", "foo", byte(100)},
+ "*3\r\n$3\r\nSET\r\n$3\r\nfoo\r\n$3\r\n100\r\n",
+ },
+ {
+ []interface{}{"SET", "foo", 100},
+ "*3\r\n$3\r\nSET\r\n$3\r\nfoo\r\n$3\r\n100\r\n",
+ },
+ {
+ []interface{}{"SET", "foo", int64(math.MinInt64)},
+ "*3\r\n$3\r\nSET\r\n$3\r\nfoo\r\n$20\r\n-9223372036854775808\r\n",
+ },
+ {
+ []interface{}{"SET", "foo", float64(1349673917.939762)},
+ "*3\r\n$3\r\nSET\r\n$3\r\nfoo\r\n$21\r\n1.349673917939762e+09\r\n",
+ },
+ {
+ []interface{}{"SET", "", []byte("foo")},
+ "*3\r\n$3\r\nSET\r\n$0\r\n\r\n$3\r\nfoo\r\n",
+ },
+ {
+ []interface{}{"SET", nil, []byte("foo")},
+ "*3\r\n$3\r\nSET\r\n$0\r\n\r\n$3\r\nfoo\r\n",
+ },
+}
+
+func TestWrite(t *testing.T) {
+ for _, tt := range writeTests {
+ var buf bytes.Buffer
+ rw := bufio.ReadWriter{Writer: bufio.NewWriter(&buf)}
+ c := redis.NewConnBufio(rw)
+ err := c.Send(tt.args[0].(string), tt.args[1:]...)
+ if err != nil {
+ t.Errorf("Send(%v) returned error %v", tt.args, err)
+ continue
+ }
+ rw.Flush()
+ actual := buf.String()
+ if actual != tt.expected {
+ t.Errorf("Send(%v) = %q, want %q", tt.args, actual, tt.expected)
+ }
+ }
+}
+
+var errorSentinel = &struct{}{}
+
+var readTests = []struct {
+ reply string
+ expected interface{}
+}{
+ {
+ "+OK\r\n",
+ "OK",
+ },
+ {
+ "+PONG\r\n",
+ "PONG",
+ },
+ {
+ "@OK\r\n",
+ errorSentinel,
+ },
+ {
+ "$6\r\nfoobar\r\n",
+ []byte("foobar"),
+ },
+ {
+ "$-1\r\n",
+ nil,
+ },
+ {
+ ":1\r\n",
+ int64(1),
+ },
+ {
+ ":-2\r\n",
+ int64(-2),
+ },
+ {
+ "*0\r\n",
+ []interface{}{},
+ },
+ {
+ "*-1\r\n",
+ nil,
+ },
+ {
+ "*4\r\n$3\r\nfoo\r\n$3\r\nbar\r\n$5\r\nHello\r\n$5\r\nWorld\r\n",
+ []interface{}{[]byte("foo"), []byte("bar"), []byte("Hello"), []byte("World")},
+ },
+ {
+ "*3\r\n$3\r\nfoo\r\n$-1\r\n$3\r\nbar\r\n",
+ []interface{}{[]byte("foo"), nil, []byte("bar")},
+ },
+}
+
+func TestRead(t *testing.T) {
+ for _, tt := range readTests {
+ rw := bufio.ReadWriter{
+ Reader: bufio.NewReader(strings.NewReader(tt.reply)),
+ Writer: bufio.NewWriter(nil), // writer need to support Flush
+ }
+ c := redis.NewConnBufio(rw)
+ actual, err := c.Receive()
+ if tt.expected == errorSentinel {
+ if err == nil {
+ t.Errorf("Receive(%q) did not return expected error", tt.reply)
+ }
+ } else {
+ if err != nil {
+ t.Errorf("Receive(%q) returned error %v", tt.reply, err)
+ continue
+ }
+ if !reflect.DeepEqual(actual, tt.expected) {
+ t.Errorf("Receive(%q) = %v, want %v", tt.reply, actual, tt.expected)
+ }
+ }
+ }
+}
+
+var testCommands = []struct {
+ args []interface{}
+ expected interface{}
+}{
+ {
+ []interface{}{"PING"},
+ "PONG",
+ },
+ {
+ []interface{}{"SET", "foo", "bar"},
+ "OK",
+ },
+ {
+ []interface{}{"GET", "foo"},
+ []byte("bar"),
+ },
+ {
+ []interface{}{"GET", "nokey"},
+ nil,
+ },
+ {
+ []interface{}{"MGET", "nokey", "foo"},
+ []interface{}{nil, []byte("bar")},
+ },
+ {
+ []interface{}{"INCR", "mycounter"},
+ int64(1),
+ },
+ {
+ []interface{}{"LPUSH", "mylist", "foo"},
+ int64(1),
+ },
+ {
+ []interface{}{"LPUSH", "mylist", "bar"},
+ int64(2),
+ },
+ {
+ []interface{}{"LRANGE", "mylist", 0, -1},
+ []interface{}{[]byte("bar"), []byte("foo")},
+ },
+ {
+ []interface{}{"MULTI"},
+ "OK",
+ },
+ {
+ []interface{}{"LRANGE", "mylist", 0, -1},
+ "QUEUED",
+ },
+ {
+ []interface{}{"PING"},
+ "QUEUED",
+ },
+ {
+ []interface{}{"EXEC"},
+ []interface{}{
+ []interface{}{[]byte("bar"), []byte("foo")},
+ "PONG",
+ },
+ },
+}
+
+func TestDoCommands(t *testing.T) {
+ c, err := redis.DialTestDB()
+ if err != nil {
+ t.Fatalf("error connection to database, %v", err)
+ }
+ defer c.Close()
+
+ for _, cmd := range testCommands {
+ actual, err := c.Do(cmd.args[0].(string), cmd.args[1:]...)
+ if err != nil {
+ t.Errorf("Do(%v) returned error %v", cmd.args, err)
+ continue
+ }
+ if !reflect.DeepEqual(actual, cmd.expected) {
+ t.Errorf("Do(%v) = %v, want %v", cmd.args, actual, cmd.expected)
+ }
+ }
+}
+
+func TestPipelineCommands(t *testing.T) {
+ c, err := redis.DialTestDB()
+ if err != nil {
+ t.Fatalf("error connection to database, %v", err)
+ }
+ defer c.Close()
+
+ for _, cmd := range testCommands {
+ if err := c.Send(cmd.args[0].(string), cmd.args[1:]...); err != nil {
+ t.Fatalf("Send(%v) returned error %v", cmd.args, err)
+ }
+ }
+ if err := c.Flush(); err != nil {
+ t.Errorf("Flush() returned error %v", err)
+ }
+ for _, cmd := range testCommands {
+ actual, err := c.Receive()
+ if err != nil {
+ t.Fatalf("Receive(%v) returned error %v", cmd.args, err)
+ }
+ if !reflect.DeepEqual(actual, cmd.expected) {
+ t.Errorf("Receive(%v) = %v, want %v", cmd.args, actual, cmd.expected)
+ }
+ }
+}
+
+func TestBlankCommmand(t *testing.T) {
+ c, err := redis.DialTestDB()
+ if err != nil {
+ t.Fatalf("error connection to database, %v", err)
+ }
+ defer c.Close()
+
+ for _, cmd := range testCommands {
+ if err := c.Send(cmd.args[0].(string), cmd.args[1:]...); err != nil {
+ t.Fatalf("Send(%v) returned error %v", cmd.args, err)
+ }
+ }
+ reply, err := redis.Values(c.Do(""))
+ if err != nil {
+ t.Fatalf("Do() returned error %v", err)
+ }
+ if len(reply) != len(testCommands) {
+ t.Fatalf("len(reply)=%d, want %d", len(reply), len(testCommands))
+ }
+ for i, cmd := range testCommands {
+ actual := reply[i]
+ if !reflect.DeepEqual(actual, cmd.expected) {
+ t.Errorf("Receive(%v) = %v, want %v", cmd.args, actual, cmd.expected)
+ }
+ }
+}
+
+func TestRecvBeforeSend(t *testing.T) {
+ c, err := redis.DialTestDB()
+ if err != nil {
+ t.Fatalf("error connection to database, %v", err)
+ }
+ defer c.Close()
+ done := make(chan struct{})
+ go func() {
+ c.Receive()
+ close(done)
+ }()
+ time.Sleep(time.Millisecond)
+ c.Send("PING")
+ c.Flush()
+ <-done
+ _, err = c.Do("")
+ if err != nil {
+ t.Fatalf("error=%v", err)
+ }
+}
+
+func TestError(t *testing.T) {
+ c, err := redis.DialTestDB()
+ if err != nil {
+ t.Fatalf("error connection to database, %v", err)
+ }
+ defer c.Close()
+
+ c.Do("SET", "key", "val")
+ _, err = c.Do("HSET", "key", "fld", "val")
+ if err == nil {
+ t.Errorf("Expected err for HSET on string key.")
+ }
+ if c.Err() != nil {
+ t.Errorf("Conn has Err()=%v, expect nil", c.Err())
+ }
+ _, err = c.Do("SET", "key", "val")
+ if err != nil {
+ t.Errorf("Do(SET, key, val) returned error %v, expected nil.", err)
+ }
+}
+
+func TestReadDeadline(t *testing.T) {
+ l, err := net.Listen("tcp", "127.0.0.1:0")
+ if err != nil {
+ t.Fatalf("net.Listen returned %v", err)
+ }
+ defer l.Close()
+
+ go func() {
+ for {
+ c, err := l.Accept()
+ if err != nil {
+ return
+ }
+ go func() {
+ time.Sleep(time.Second)
+ c.Write([]byte("+OK\r\n"))
+ c.Close()
+ }()
+ }
+ }()
+
+ c1, err := redis.DialTimeout(l.Addr().Network(), l.Addr().String(), 0, time.Millisecond, 0)
+ if err != nil {
+ t.Fatalf("redis.Dial returned %v", err)
+ }
+ defer c1.Close()
+
+ _, err = c1.Do("PING")
+ if err == nil {
+ t.Fatalf("c1.Do() returned nil, expect error")
+ }
+ if c1.Err() == nil {
+ t.Fatalf("c1.Err() = nil, expect error")
+ }
+
+ c2, err := redis.DialTimeout(l.Addr().Network(), l.Addr().String(), 0, time.Millisecond, 0)
+ if err != nil {
+ t.Fatalf("redis.Dial returned %v", err)
+ }
+ defer c2.Close()
+
+ c2.Send("PING")
+ c2.Flush()
+ _, err = c2.Receive()
+ if err == nil {
+ t.Fatalf("c2.Receive() returned nil, expect error")
+ }
+ if c2.Err() == nil {
+ t.Fatalf("c2.Err() = nil, expect error")
+ }
+}
+
+// Connect to local instance of Redis running on the default port.
+func ExampleDial(x int) {
+ c, err := redis.Dial("tcp", ":6379")
+ if err != nil {
+ // handle error
+ }
+ defer c.Close()
+}
+
+// TextExecError tests handling of errors in a transaction. See
+// http://redis.io/topics/transactions for information on how Redis handles
+// errors in a transaction.
+func TestExecError(t *testing.T) {
+ c, err := redis.DialTestDB()
+ if err != nil {
+ t.Fatalf("error connection to database, %v", err)
+ }
+ defer c.Close()
+
+ // Execute commands that fail before EXEC is called.
+
+ c.Do("ZADD", "k0", 0, 0)
+ c.Send("MULTI")
+ c.Send("NOTACOMMAND", "k0", 0, 0)
+ c.Send("ZINCRBY", "k0", 0, 0)
+ v, err := c.Do("EXEC")
+ if err == nil {
+ t.Fatalf("EXEC returned values %v, expected error", v)
+ }
+
+ // Execute commands that fail after EXEC is called. The first command
+ // returns an error.
+
+ c.Do("ZADD", "k1", 0, 0)
+ c.Send("MULTI")
+ c.Send("HSET", "k1", 0, 0)
+ c.Send("ZINCRBY", "k1", 0, 0)
+ v, err = c.Do("EXEC")
+ if err != nil {
+ t.Fatalf("EXEC returned error %v", err)
+ }
+
+ vs, err := redis.Values(v, nil)
+ if err != nil {
+ t.Fatalf("Values(v) returned error %v", err)
+ }
+
+ if len(vs) != 2 {
+ t.Fatalf("len(vs) == %d, want 2", len(vs))
+ }
+
+ if _, ok := vs[0].(error); !ok {
+ t.Fatalf("first result is type %T, expected error", vs[0])
+ }
+
+ if _, ok := vs[1].([]byte); !ok {
+ t.Fatalf("second result is type %T, expected []byte", vs[2])
+ }
+
+ // Execute commands that fail after EXEC is called. The second command
+ // returns an error.
+
+ c.Do("ZADD", "k2", 0, 0)
+ c.Send("MULTI")
+ c.Send("ZINCRBY", "k2", 0, 0)
+ c.Send("HSET", "k2", 0, 0)
+ v, err = c.Do("EXEC")
+ if err != nil {
+ t.Fatalf("EXEC returned error %v", err)
+ }
+
+ vs, err = redis.Values(v, nil)
+ if err != nil {
+ t.Fatalf("Values(v) returned error %v", err)
+ }
+
+ if len(vs) != 2 {
+ t.Fatalf("len(vs) == %d, want 2", len(vs))
+ }
+
+ if _, ok := vs[0].([]byte); !ok {
+ t.Fatalf("first result is type %T, expected []byte", vs[0])
+ }
+
+ if _, ok := vs[1].(error); !ok {
+ t.Fatalf("second result is type %T, expected error", vs[2])
+ }
+}
+
+func BenchmarkDoEmpty(b *testing.B) {
+ b.StopTimer()
+ c, err := redis.DialTestDB()
+ if err != nil {
+ b.Fatal(err)
+ }
+ defer c.Close()
+ b.StartTimer()
+ for i := 0; i < b.N; i++ {
+ if _, err := c.Do(""); err != nil {
+ b.Fatal(err)
+ }
+ }
+}
+
+func BenchmarkDoPing(b *testing.B) {
+ b.StopTimer()
+ c, err := redis.DialTestDB()
+ if err != nil {
+ b.Fatal(err)
+ }
+ defer c.Close()
+ b.StartTimer()
+ for i := 0; i < b.N; i++ {
+ if _, err := c.Do("PING"); err != nil {
+ b.Fatal(err)
+ }
+ }
+}
diff --git a/Godeps/_workspace/src/github.com/garyburd/redigo/redis/doc.go b/Godeps/_workspace/src/github.com/garyburd/redigo/redis/doc.go
new file mode 100644
index 0000000000000000000000000000000000000000..63e6ffe2b58dab93bc8f19c6709330e4f0ead53b
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/garyburd/redigo/redis/doc.go
@@ -0,0 +1,167 @@
+// Copyright 2012 Gary Burd
+//
+// Licensed under the Apache License, Version 2.0 (the "License"): you may
+// not use this file except in compliance with the License. You may obtain
+// a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+// License for the specific language governing permissions and limitations
+// under the License.
+
+// Package redis is a client for the Redis database.
+//
+// The Redigo FAQ (https://github.com/garyburd/redigo/wiki/FAQ) contains more
+// documentation about this package.
+//
+// Connections
+//
+// The Conn interface is the primary interface for working with Redis.
+// Applications create connections by calling the Dial, DialWithTimeout or
+// NewConn functions. In the future, functions will be added for creating
+// sharded and other types of connections.
+//
+// The application must call the connection Close method when the application
+// is done with the connection.
+//
+// Executing Commands
+//
+// The Conn interface has a generic method for executing Redis commands:
+//
+// Do(commandName string, args ...interface{}) (reply interface{}, err error)
+//
+// The Redis command reference (http://redis.io/commands) lists the available
+// commands. An example of using the Redis APPEND command is:
+//
+// n, err := conn.Do("APPEND", "key", "value")
+//
+// The Do method converts command arguments to binary strings for transmission
+// to the server as follows:
+//
+// Go Type Conversion
+// []byte Sent as is
+// string Sent as is
+// int, int64 strconv.FormatInt(v)
+// float64 strconv.FormatFloat(v, 'g', -1, 64)
+// bool true -> "1", false -> "0"
+// nil ""
+// all other types fmt.Print(v)
+//
+// Redis command reply types are represented using the following Go types:
+//
+// Redis type Go type
+// error redis.Error
+// integer int64
+// simple string string
+// bulk string []byte or nil if value not present.
+// array []interface{} or nil if value not present.
+//
+// Use type assertions or the reply helper functions to convert from
+// interface{} to the specific Go type for the command result.
+//
+// Pipelining
+//
+// Connections support pipelining using the Send, Flush and Receive methods.
+//
+// Send(commandName string, args ...interface{}) error
+// Flush() error
+// Receive() (reply interface{}, err error)
+//
+// Send writes the command to the connection's output buffer. Flush flushes the
+// connection's output buffer to the server. Receive reads a single reply from
+// the server. The following example shows a simple pipeline.
+//
+// c.Send("SET", "foo", "bar")
+// c.Send("GET", "foo")
+// c.Flush()
+// c.Receive() // reply from SET
+// v, err = c.Receive() // reply from GET
+//
+// The Do method combines the functionality of the Send, Flush and Receive
+// methods. The Do method starts by writing the command and flushing the output
+// buffer. Next, the Do method receives all pending replies including the reply
+// for the command just sent by Do. If any of the received replies is an error,
+// then Do returns the error. If there are no errors, then Do returns the last
+// reply. If the command argument to the Do method is "", then the Do method
+// will flush the output buffer and receive pending replies without sending a
+// command.
+//
+// Use the Send and Do methods to implement pipelined transactions.
+//
+// c.Send("MULTI")
+// c.Send("INCR", "foo")
+// c.Send("INCR", "bar")
+// r, err := c.Do("EXEC")
+// fmt.Println(r) // prints [1, 1]
+//
+// Concurrency
+//
+// Connections support a single concurrent caller to the write methods (Send,
+// Flush) and a single concurrent caller to the read method (Receive). Because
+// Do method combines the functionality of Send, Flush and Receive, the Do
+// method cannot be called concurrently with the other methods.
+//
+// For full concurrent access to Redis, use the thread-safe Pool to get and
+// release connections from within a goroutine.
+//
+// Publish and Subscribe
+//
+// Use the Send, Flush and Receive methods to implement Pub/Sub subscribers.
+//
+// c.Send("SUBSCRIBE", "example")
+// c.Flush()
+// for {
+// reply, err := c.Receive()
+// if err != nil {
+// return err
+// }
+// // process pushed message
+// }
+//
+// The PubSubConn type wraps a Conn with convenience methods for implementing
+// subscribers. The Subscribe, PSubscribe, Unsubscribe and PUnsubscribe methods
+// send and flush a subscription management command. The receive method
+// converts a pushed message to convenient types for use in a type switch.
+//
+// psc := PubSubConn{c}
+// psc.Subscribe("example")
+// for {
+// switch v := psc.Receive().(type) {
+// case redis.Message:
+// fmt.Printf("%s: message: %s\n", v.Channel, v.Data)
+// case redis.Subscription:
+// fmt.Printf("%s: %s %d\n", v.Channel, v.Kind, v.Count)
+// case error:
+// return v
+// }
+// }
+//
+// Reply Helpers
+//
+// The Bool, Int, Bytes, String, Strings and Values functions convert a reply
+// to a value of a specific type. To allow convenient wrapping of calls to the
+// connection Do and Receive methods, the functions take a second argument of
+// type error. If the error is non-nil, then the helper function returns the
+// error. If the error is nil, the function converts the reply to the specified
+// type:
+//
+// exists, err := redis.Bool(c.Do("EXISTS", "foo"))
+// if err != nil {
+// // handle error return from c.Do or type conversion error.
+// }
+//
+// The Scan function converts elements of a array reply to Go types:
+//
+// var value1 int
+// var value2 string
+// reply, err := redis.Values(c.Do("MGET", "key1", "key2"))
+// if err != nil {
+// // handle error
+// }
+// if _, err := redis.Scan(reply, &value1, &value2); err != nil {
+// // handle error
+// }
+package redis
diff --git a/Godeps/_workspace/src/github.com/garyburd/redigo/redis/log.go b/Godeps/_workspace/src/github.com/garyburd/redigo/redis/log.go
new file mode 100644
index 0000000000000000000000000000000000000000..129b86d6708ee3f4173c4319e7ab7247d49b1dbb
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/garyburd/redigo/redis/log.go
@@ -0,0 +1,117 @@
+// Copyright 2012 Gary Burd
+//
+// Licensed under the Apache License, Version 2.0 (the "License"): you may
+// not use this file except in compliance with the License. You may obtain
+// a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+// License for the specific language governing permissions and limitations
+// under the License.
+
+package redis
+
+import (
+ "bytes"
+ "fmt"
+ "log"
+)
+
+// NewLoggingConn returns a logging wrapper around a connection.
+func NewLoggingConn(conn Conn, logger *log.Logger, prefix string) Conn {
+ if prefix != "" {
+ prefix = prefix + "."
+ }
+ return &loggingConn{conn, logger, prefix}
+}
+
+type loggingConn struct {
+ Conn
+ logger *log.Logger
+ prefix string
+}
+
+func (c *loggingConn) Close() error {
+ err := c.Conn.Close()
+ var buf bytes.Buffer
+ fmt.Fprintf(&buf, "%sClose() -> (%v)", c.prefix, err)
+ c.logger.Output(2, buf.String())
+ return err
+}
+
+func (c *loggingConn) printValue(buf *bytes.Buffer, v interface{}) {
+ const chop = 32
+ switch v := v.(type) {
+ case []byte:
+ if len(v) > chop {
+ fmt.Fprintf(buf, "%q...", v[:chop])
+ } else {
+ fmt.Fprintf(buf, "%q", v)
+ }
+ case string:
+ if len(v) > chop {
+ fmt.Fprintf(buf, "%q...", v[:chop])
+ } else {
+ fmt.Fprintf(buf, "%q", v)
+ }
+ case []interface{}:
+ if len(v) == 0 {
+ buf.WriteString("[]")
+ } else {
+ sep := "["
+ fin := "]"
+ if len(v) > chop {
+ v = v[:chop]
+ fin = "...]"
+ }
+ for _, vv := range v {
+ buf.WriteString(sep)
+ c.printValue(buf, vv)
+ sep = ", "
+ }
+ buf.WriteString(fin)
+ }
+ default:
+ fmt.Fprint(buf, v)
+ }
+}
+
+func (c *loggingConn) print(method, commandName string, args []interface{}, reply interface{}, err error) {
+ var buf bytes.Buffer
+ fmt.Fprintf(&buf, "%s%s(", c.prefix, method)
+ if method != "Receive" {
+ buf.WriteString(commandName)
+ for _, arg := range args {
+ buf.WriteString(", ")
+ c.printValue(&buf, arg)
+ }
+ }
+ buf.WriteString(") -> (")
+ if method != "Send" {
+ c.printValue(&buf, reply)
+ buf.WriteString(", ")
+ }
+ fmt.Fprintf(&buf, "%v)", err)
+ c.logger.Output(3, buf.String())
+}
+
+func (c *loggingConn) Do(commandName string, args ...interface{}) (interface{}, error) {
+ reply, err := c.Conn.Do(commandName, args...)
+ c.print("Do", commandName, args, reply, err)
+ return reply, err
+}
+
+func (c *loggingConn) Send(commandName string, args ...interface{}) error {
+ err := c.Conn.Send(commandName, args...)
+ c.print("Send", commandName, args, nil, err)
+ return err
+}
+
+func (c *loggingConn) Receive() (interface{}, error) {
+ reply, err := c.Conn.Receive()
+ c.print("Receive", "", nil, reply, err)
+ return reply, err
+}
diff --git a/Godeps/_workspace/src/github.com/garyburd/redigo/redis/pool.go b/Godeps/_workspace/src/github.com/garyburd/redigo/redis/pool.go
new file mode 100644
index 0000000000000000000000000000000000000000..fa5e958c85873805ba4a25641f13056b780bc3fd
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/garyburd/redigo/redis/pool.go
@@ -0,0 +1,355 @@
+// Copyright 2012 Gary Burd
+//
+// Licensed under the Apache License, Version 2.0 (the "License"): you may
+// not use this file except in compliance with the License. You may obtain
+// a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+// License for the specific language governing permissions and limitations
+// under the License.
+
+package redis
+
+import (
+ "bytes"
+ "container/list"
+ "crypto/rand"
+ "crypto/sha1"
+ "errors"
+ "io"
+ "strconv"
+ "sync"
+ "time"
+)
+
+var nowFunc = time.Now // for testing
+
+// ErrPoolExhausted is returned from a pool connection method (Do, Send,
+// Receive, Flush, Err) when the maximum number of database connections in the
+// pool has been reached.
+var ErrPoolExhausted = errors.New("redigo: connection pool exhausted")
+
+var (
+ errPoolClosed = errors.New("redigo: connection pool closed")
+ errConnClosed = errors.New("redigo: connection closed")
+)
+
+// Pool maintains a pool of connections. The application calls the Get method
+// to get a connection from the pool and the connection's Close method to
+// return the connection's resources to the pool.
+//
+// The following example shows how to use a pool in a web application. The
+// application creates a pool at application startup and makes it available to
+// request handlers using a global variable.
+//
+// func newPool(server, password string) *redis.Pool {
+// return &redis.Pool{
+// MaxIdle: 3,
+// IdleTimeout: 240 * time.Second,
+// Dial: func () (redis.Conn, error) {
+// c, err := redis.Dial("tcp", server)
+// if err != nil {
+// return nil, err
+// }
+// if _, err := c.Do("AUTH", password); err != nil {
+// c.Close()
+// return nil, err
+// }
+// return c, err
+// },
+// TestOnBorrow: func(c redis.Conn, t time.Time) error {
+// _, err := c.Do("PING")
+// return err
+// },
+// }
+// }
+//
+// var (
+// pool *redis.Pool
+// redisServer = flag.String("redisServer", ":6379", "")
+// redisPassword = flag.String("redisPassword", "", "")
+// )
+//
+// func main() {
+// flag.Parse()
+// pool = newPool(*redisServer, *redisPassword)
+// ...
+// }
+//
+// A request handler gets a connection from the pool and closes the connection
+// when the handler is done:
+//
+// func serveHome(w http.ResponseWriter, r *http.Request) {
+// conn := pool.Get()
+// defer conn.Close()
+// ....
+// }
+//
+type Pool struct {
+
+ // Dial is an application supplied function for creating and configuring a
+ // connection
+ Dial func() (Conn, error)
+
+ // TestOnBorrow is an optional application supplied function for checking
+ // the health of an idle connection before the connection is used again by
+ // the application. Argument t is the time that the connection was returned
+ // to the pool. If the function returns an error, then the connection is
+ // closed.
+ TestOnBorrow func(c Conn, t time.Time) error
+
+ // Maximum number of idle connections in the pool.
+ MaxIdle int
+
+ // Maximum number of connections allocated by the pool at a given time.
+ // When zero, there is no limit on the number of connections in the pool.
+ MaxActive int
+
+ // Close connections after remaining idle for this duration. If the value
+ // is zero, then idle connections are not closed. Applications should set
+ // the timeout to a value less than the server's timeout.
+ IdleTimeout time.Duration
+
+ // mu protects fields defined below.
+ mu sync.Mutex
+ closed bool
+ active int
+
+ // Stack of idleConn with most recently used at the front.
+ idle list.List
+}
+
+type idleConn struct {
+ c Conn
+ t time.Time
+}
+
+// NewPool creates a new pool. This function is deprecated. Applications should
+// initialize the Pool fields directly as shown in example.
+func NewPool(newFn func() (Conn, error), maxIdle int) *Pool {
+ return &Pool{Dial: newFn, MaxIdle: maxIdle}
+}
+
+// Get gets a connection. The application must close the returned connection.
+// This method always returns a valid connection so that applications can defer
+// error handling to the first use of the connection. If there is an error
+// getting an underlying connection, then the connection Err, Do, Send, Flush
+// and Receive methods return that error.
+func (p *Pool) Get() Conn {
+ c, err := p.get()
+ if err != nil {
+ return errorConnection{err}
+ }
+ return &pooledConnection{p: p, c: c}
+}
+
+// ActiveCount returns the number of active connections in the pool.
+func (p *Pool) ActiveCount() int {
+ p.mu.Lock()
+ active := p.active
+ p.mu.Unlock()
+ return active
+}
+
+// Close releases the resources used by the pool.
+func (p *Pool) Close() error {
+ p.mu.Lock()
+ idle := p.idle
+ p.idle.Init()
+ p.closed = true
+ p.active -= idle.Len()
+ p.mu.Unlock()
+ for e := idle.Front(); e != nil; e = e.Next() {
+ e.Value.(idleConn).c.Close()
+ }
+ return nil
+}
+
+// get prunes stale connections and returns a connection from the idle list or
+// creates a new connection.
+func (p *Pool) get() (Conn, error) {
+ p.mu.Lock()
+
+ if p.closed {
+ p.mu.Unlock()
+ return nil, errors.New("redigo: get on closed pool")
+ }
+
+ // Prune stale connections.
+
+ if timeout := p.IdleTimeout; timeout > 0 {
+ for i, n := 0, p.idle.Len(); i < n; i++ {
+ e := p.idle.Back()
+ if e == nil {
+ break
+ }
+ ic := e.Value.(idleConn)
+ if ic.t.Add(timeout).After(nowFunc()) {
+ break
+ }
+ p.idle.Remove(e)
+ p.active -= 1
+ p.mu.Unlock()
+ ic.c.Close()
+ p.mu.Lock()
+ }
+ }
+
+ // Get idle connection.
+
+ for i, n := 0, p.idle.Len(); i < n; i++ {
+ e := p.idle.Front()
+ if e == nil {
+ break
+ }
+ ic := e.Value.(idleConn)
+ p.idle.Remove(e)
+ test := p.TestOnBorrow
+ p.mu.Unlock()
+ if test == nil || test(ic.c, ic.t) == nil {
+ return ic.c, nil
+ }
+ ic.c.Close()
+ p.mu.Lock()
+ p.active -= 1
+ }
+
+ if p.MaxActive > 0 && p.active >= p.MaxActive {
+ p.mu.Unlock()
+ return nil, ErrPoolExhausted
+ }
+
+ // No idle connection, create new.
+
+ dial := p.Dial
+ p.active += 1
+ p.mu.Unlock()
+ c, err := dial()
+ if err != nil {
+ p.mu.Lock()
+ p.active -= 1
+ p.mu.Unlock()
+ c = nil
+ }
+ return c, err
+}
+
+func (p *Pool) put(c Conn, forceClose bool) error {
+ if c.Err() == nil && !forceClose {
+ p.mu.Lock()
+ if !p.closed {
+ p.idle.PushFront(idleConn{t: nowFunc(), c: c})
+ if p.idle.Len() > p.MaxIdle {
+ c = p.idle.Remove(p.idle.Back()).(idleConn).c
+ } else {
+ c = nil
+ }
+ }
+ p.mu.Unlock()
+ }
+ if c != nil {
+ p.mu.Lock()
+ p.active -= 1
+ p.mu.Unlock()
+ return c.Close()
+ }
+ return nil
+}
+
+type pooledConnection struct {
+ p *Pool
+ c Conn
+ state int
+}
+
+var (
+ sentinel []byte
+ sentinelOnce sync.Once
+)
+
+func initSentinel() {
+ p := make([]byte, 64)
+ if _, err := rand.Read(p); err == nil {
+ sentinel = p
+ } else {
+ h := sha1.New()
+ io.WriteString(h, "Oops, rand failed. Use time instead.")
+ io.WriteString(h, strconv.FormatInt(time.Now().UnixNano(), 10))
+ sentinel = h.Sum(nil)
+ }
+}
+
+func (pc *pooledConnection) Close() error {
+ c := pc.c
+ if _, ok := c.(errorConnection); ok {
+ return nil
+ }
+ pc.c = errorConnection{errConnClosed}
+
+ if pc.state&multiState != 0 {
+ c.Send("DISCARD")
+ pc.state &^= (multiState | watchState)
+ } else if pc.state&watchState != 0 {
+ c.Send("UNWATCH")
+ pc.state &^= watchState
+ }
+ if pc.state&subscribeState != 0 {
+ c.Send("UNSUBSCRIBE")
+ c.Send("PUNSUBSCRIBE")
+ // To detect the end of the message stream, ask the server to echo
+ // a sentinel value and read until we see that value.
+ sentinelOnce.Do(initSentinel)
+ c.Send("ECHO", sentinel)
+ c.Flush()
+ for {
+ p, err := c.Receive()
+ if err != nil {
+ break
+ }
+ if p, ok := p.([]byte); ok && bytes.Equal(p, sentinel) {
+ pc.state &^= subscribeState
+ break
+ }
+ }
+ }
+ c.Do("")
+ pc.p.put(c, pc.state != 0)
+ return nil
+}
+
+func (pc *pooledConnection) Err() error {
+ return pc.c.Err()
+}
+
+func (pc *pooledConnection) Do(commandName string, args ...interface{}) (reply interface{}, err error) {
+ ci := lookupCommandInfo(commandName)
+ pc.state = (pc.state | ci.set) &^ ci.clear
+ return pc.c.Do(commandName, args...)
+}
+
+func (pc *pooledConnection) Send(commandName string, args ...interface{}) error {
+ ci := lookupCommandInfo(commandName)
+ pc.state = (pc.state | ci.set) &^ ci.clear
+ return pc.c.Send(commandName, args...)
+}
+
+func (pc *pooledConnection) Flush() error {
+ return pc.c.Flush()
+}
+
+func (pc *pooledConnection) Receive() (reply interface{}, err error) {
+ return pc.c.Receive()
+}
+
+type errorConnection struct{ err error }
+
+func (ec errorConnection) Do(string, ...interface{}) (interface{}, error) { return nil, ec.err }
+func (ec errorConnection) Send(string, ...interface{}) error { return ec.err }
+func (ec errorConnection) Err() error { return ec.err }
+func (ec errorConnection) Close() error { return ec.err }
+func (ec errorConnection) Flush() error { return ec.err }
+func (ec errorConnection) Receive() (interface{}, error) { return nil, ec.err }
diff --git a/Godeps/_workspace/src/github.com/garyburd/redigo/redis/pool_test.go b/Godeps/_workspace/src/github.com/garyburd/redigo/redis/pool_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..9efdb407ef0810e8716af100a29c2d5d0cde362e
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/garyburd/redigo/redis/pool_test.go
@@ -0,0 +1,532 @@
+// Copyright 2011 Gary Burd
+//
+// Licensed under the Apache License, Version 2.0 (the "License"): you may
+// not use this file except in compliance with the License. You may obtain
+// a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+// License for the specific language governing permissions and limitations
+// under the License.
+
+package redis
+
+import (
+ "io"
+ "net/textproto"
+ "reflect"
+ "sync"
+ "testing"
+ "time"
+)
+
+type poolTestConn struct {
+ d *poolDialer
+ err error
+ Conn
+}
+
+func (c *poolTestConn) Close() error { c.d.open -= 1; return nil }
+func (c *poolTestConn) Err() error { return c.err }
+
+func (c *poolTestConn) Do(commandName string, args ...interface{}) (reply interface{}, err error) {
+ if commandName == "ERR" {
+ c.err = args[0].(error)
+ }
+ if commandName != "" {
+ c.d.commands = append(c.d.commands, commandName)
+ }
+ return c.Conn.Do(commandName, args...)
+}
+
+func (c *poolTestConn) Send(commandName string, args ...interface{}) error {
+ c.d.commands = append(c.d.commands, commandName)
+ return c.Conn.Send(commandName, args...)
+}
+
+type poolDialer struct {
+ t *testing.T
+ dialed, open int
+ commands []string
+}
+
+func (d *poolDialer) dial() (Conn, error) {
+ d.open += 1
+ d.dialed += 1
+ c, err := DialTestDB()
+ if err != nil {
+ return nil, err
+ }
+ return &poolTestConn{d: d, Conn: c}, nil
+}
+
+func (d *poolDialer) check(message string, p *Pool, dialed, open int) {
+ if d.dialed != dialed {
+ d.t.Errorf("%s: dialed=%d, want %d", message, d.dialed, dialed)
+ }
+ if d.open != open {
+ d.t.Errorf("%s: open=%d, want %d", message, d.open, open)
+ }
+ if active := p.ActiveCount(); active != open {
+ d.t.Errorf("%s: active=%d, want %d", message, active, open)
+ }
+}
+
+func TestPoolReuse(t *testing.T) {
+ d := poolDialer{t: t}
+ p := &Pool{
+ MaxIdle: 2,
+ Dial: d.dial,
+ }
+
+ for i := 0; i < 10; i++ {
+ c1 := p.Get()
+ c1.Do("PING")
+ c2 := p.Get()
+ c2.Do("PING")
+ c1.Close()
+ c2.Close()
+ }
+
+ d.check("before close", p, 2, 2)
+ p.Close()
+ d.check("after close", p, 2, 0)
+}
+
+func TestPoolMaxIdle(t *testing.T) {
+ d := poolDialer{t: t}
+ p := &Pool{
+ MaxIdle: 2,
+ Dial: d.dial,
+ }
+ for i := 0; i < 10; i++ {
+ c1 := p.Get()
+ c1.Do("PING")
+ c2 := p.Get()
+ c2.Do("PING")
+ c3 := p.Get()
+ c3.Do("PING")
+ c1.Close()
+ c2.Close()
+ c3.Close()
+ }
+ d.check("before close", p, 12, 2)
+ p.Close()
+ d.check("after close", p, 12, 0)
+}
+
+func TestPoolError(t *testing.T) {
+ d := poolDialer{t: t}
+ p := &Pool{
+ MaxIdle: 2,
+ Dial: d.dial,
+ }
+
+ c := p.Get()
+ c.Do("ERR", io.EOF)
+ if c.Err() == nil {
+ t.Errorf("expected c.Err() != nil")
+ }
+ c.Close()
+
+ c = p.Get()
+ c.Do("ERR", io.EOF)
+ c.Close()
+
+ d.check(".", p, 2, 0)
+}
+
+func TestPoolClose(t *testing.T) {
+ d := poolDialer{t: t}
+ p := &Pool{
+ MaxIdle: 2,
+ Dial: d.dial,
+ }
+
+ c1 := p.Get()
+ c1.Do("PING")
+ c2 := p.Get()
+ c2.Do("PING")
+ c3 := p.Get()
+ c3.Do("PING")
+
+ c1.Close()
+ if _, err := c1.Do("PING"); err == nil {
+ t.Errorf("expected error after connection closed")
+ }
+
+ c2.Close()
+ c2.Close()
+
+ p.Close()
+
+ d.check("after pool close", p, 3, 1)
+
+ if _, err := c1.Do("PING"); err == nil {
+ t.Errorf("expected error after connection and pool closed")
+ }
+
+ c3.Close()
+
+ d.check("after conn close", p, 3, 0)
+
+ c1 = p.Get()
+ if _, err := c1.Do("PING"); err == nil {
+ t.Errorf("expected error after pool closed")
+ }
+}
+
+func TestPoolTimeout(t *testing.T) {
+ d := poolDialer{t: t}
+ p := &Pool{
+ MaxIdle: 2,
+ IdleTimeout: 300 * time.Second,
+ Dial: d.dial,
+ }
+
+ now := time.Now()
+ nowFunc = func() time.Time { return now }
+ defer func() { nowFunc = time.Now }()
+
+ c := p.Get()
+ c.Do("PING")
+ c.Close()
+
+ d.check("1", p, 1, 1)
+
+ now = now.Add(p.IdleTimeout)
+
+ c = p.Get()
+ c.Do("PING")
+ c.Close()
+
+ d.check("2", p, 2, 1)
+
+ p.Close()
+}
+
+func TestPoolConcurrenSendReceive(t *testing.T) {
+ p := &Pool{
+ Dial: DialTestDB,
+ }
+ c := p.Get()
+ done := make(chan error, 1)
+ go func() {
+ _, err := c.Receive()
+ done <- err
+ }()
+ c.Send("PING")
+ c.Flush()
+ err := <-done
+ if err != nil {
+ t.Fatalf("Receive() returned error %v", err)
+ }
+ _, err = c.Do("")
+ if err != nil {
+ t.Fatalf("Do() returned error %v", err)
+ }
+ c.Close()
+ p.Close()
+}
+
+func TestPoolBorrowCheck(t *testing.T) {
+ d := poolDialer{t: t}
+ p := &Pool{
+ MaxIdle: 2,
+ Dial: d.dial,
+ TestOnBorrow: func(Conn, time.Time) error { return Error("BLAH") },
+ }
+
+ for i := 0; i < 10; i++ {
+ c := p.Get()
+ c.Do("PING")
+ c.Close()
+ }
+ d.check("1", p, 10, 1)
+ p.Close()
+}
+
+func TestPoolMaxActive(t *testing.T) {
+ d := poolDialer{t: t}
+ p := &Pool{
+ MaxIdle: 2,
+ MaxActive: 2,
+ Dial: d.dial,
+ }
+ c1 := p.Get()
+ c1.Do("PING")
+ c2 := p.Get()
+ c2.Do("PING")
+
+ d.check("1", p, 2, 2)
+
+ c3 := p.Get()
+ if _, err := c3.Do("PING"); err != ErrPoolExhausted {
+ t.Errorf("expected pool exhausted")
+ }
+
+ c3.Close()
+ d.check("2", p, 2, 2)
+ c2.Close()
+ d.check("3", p, 2, 2)
+
+ c3 = p.Get()
+ if _, err := c3.Do("PING"); err != nil {
+ t.Errorf("expected good channel, err=%v", err)
+ }
+ c3.Close()
+
+ d.check("4", p, 2, 2)
+ p.Close()
+}
+
+func TestPoolMonitorCleanup(t *testing.T) {
+ d := poolDialer{t: t}
+ p := &Pool{
+ MaxIdle: 2,
+ MaxActive: 2,
+ Dial: d.dial,
+ }
+ c := p.Get()
+ c.Send("MONITOR")
+ c.Close()
+
+ d.check("", p, 1, 0)
+ p.Close()
+}
+
+func TestPoolPubSubCleanup(t *testing.T) {
+ d := poolDialer{t: t}
+ p := &Pool{
+ MaxIdle: 2,
+ MaxActive: 2,
+ Dial: d.dial,
+ }
+
+ c := p.Get()
+ c.Send("SUBSCRIBE", "x")
+ c.Close()
+
+ want := []string{"SUBSCRIBE", "UNSUBSCRIBE", "PUNSUBSCRIBE", "ECHO"}
+ if !reflect.DeepEqual(d.commands, want) {
+ t.Errorf("got commands %v, want %v", d.commands, want)
+ }
+ d.commands = nil
+
+ c = p.Get()
+ c.Send("PSUBSCRIBE", "x*")
+ c.Close()
+
+ want = []string{"PSUBSCRIBE", "UNSUBSCRIBE", "PUNSUBSCRIBE", "ECHO"}
+ if !reflect.DeepEqual(d.commands, want) {
+ t.Errorf("got commands %v, want %v", d.commands, want)
+ }
+ d.commands = nil
+
+ p.Close()
+}
+
+func TestPoolTransactionCleanup(t *testing.T) {
+ d := poolDialer{t: t}
+ p := &Pool{
+ MaxIdle: 2,
+ MaxActive: 2,
+ Dial: d.dial,
+ }
+
+ c := p.Get()
+ c.Do("WATCH", "key")
+ c.Do("PING")
+ c.Close()
+
+ want := []string{"WATCH", "PING", "UNWATCH"}
+ if !reflect.DeepEqual(d.commands, want) {
+ t.Errorf("got commands %v, want %v", d.commands, want)
+ }
+ d.commands = nil
+
+ c = p.Get()
+ c.Do("WATCH", "key")
+ c.Do("UNWATCH")
+ c.Do("PING")
+ c.Close()
+
+ want = []string{"WATCH", "UNWATCH", "PING"}
+ if !reflect.DeepEqual(d.commands, want) {
+ t.Errorf("got commands %v, want %v", d.commands, want)
+ }
+ d.commands = nil
+
+ c = p.Get()
+ c.Do("WATCH", "key")
+ c.Do("MULTI")
+ c.Do("PING")
+ c.Close()
+
+ want = []string{"WATCH", "MULTI", "PING", "DISCARD"}
+ if !reflect.DeepEqual(d.commands, want) {
+ t.Errorf("got commands %v, want %v", d.commands, want)
+ }
+ d.commands = nil
+
+ c = p.Get()
+ c.Do("WATCH", "key")
+ c.Do("MULTI")
+ c.Do("DISCARD")
+ c.Do("PING")
+ c.Close()
+
+ want = []string{"WATCH", "MULTI", "DISCARD", "PING"}
+ if !reflect.DeepEqual(d.commands, want) {
+ t.Errorf("got commands %v, want %v", d.commands, want)
+ }
+ d.commands = nil
+
+ c = p.Get()
+ c.Do("WATCH", "key")
+ c.Do("MULTI")
+ c.Do("EXEC")
+ c.Do("PING")
+ c.Close()
+
+ want = []string{"WATCH", "MULTI", "EXEC", "PING"}
+ if !reflect.DeepEqual(d.commands, want) {
+ t.Errorf("got commands %v, want %v", d.commands, want)
+ }
+ d.commands = nil
+
+ p.Close()
+}
+
+func BenchmarkPoolGet(b *testing.B) {
+ b.StopTimer()
+ p := Pool{Dial: DialTestDB, MaxIdle: 2}
+ c := p.Get()
+ if err := c.Err(); err != nil {
+ b.Fatal(err)
+ }
+ c.Close()
+ defer p.Close()
+ b.StartTimer()
+ for i := 0; i < b.N; i++ {
+ c = p.Get()
+ c.Close()
+ }
+}
+
+func BenchmarkPoolGetErr(b *testing.B) {
+ b.StopTimer()
+ p := Pool{Dial: DialTestDB, MaxIdle: 2}
+ c := p.Get()
+ if err := c.Err(); err != nil {
+ b.Fatal(err)
+ }
+ c.Close()
+ defer p.Close()
+ b.StartTimer()
+ for i := 0; i < b.N; i++ {
+ c = p.Get()
+ if err := c.Err(); err != nil {
+ b.Fatal(err)
+ }
+ c.Close()
+ }
+}
+
+func BenchmarkPoolGetPing(b *testing.B) {
+ b.StopTimer()
+ p := Pool{Dial: DialTestDB, MaxIdle: 2}
+ c := p.Get()
+ if err := c.Err(); err != nil {
+ b.Fatal(err)
+ }
+ c.Close()
+ defer p.Close()
+ b.StartTimer()
+ for i := 0; i < b.N; i++ {
+ c = p.Get()
+ if _, err := c.Do("PING"); err != nil {
+ b.Fatal(err)
+ }
+ c.Close()
+ }
+}
+
+const numConcurrent = 10
+
+func BenchmarkPipelineConcurrency(b *testing.B) {
+ b.StopTimer()
+ c, err := DialTestDB()
+ if err != nil {
+ b.Fatalf("error connection to database, %v", err)
+ }
+ defer c.Close()
+
+ var wg sync.WaitGroup
+ wg.Add(numConcurrent)
+
+ var pipeline textproto.Pipeline
+
+ b.StartTimer()
+
+ for i := 0; i < numConcurrent; i++ {
+ go func() {
+ defer wg.Done()
+ for i := 0; i < b.N; i++ {
+ id := pipeline.Next()
+ pipeline.StartRequest(id)
+ c.Send("PING")
+ c.Flush()
+ pipeline.EndRequest(id)
+ pipeline.StartResponse(id)
+ _, err := c.Receive()
+ if err != nil {
+ b.Fatal(err)
+ }
+ c.Flush()
+ pipeline.EndResponse(id)
+ }
+ }()
+ }
+ wg.Wait()
+}
+
+func BenchmarkPoolConcurrency(b *testing.B) {
+ b.StopTimer()
+
+ p := Pool{Dial: DialTestDB, MaxIdle: numConcurrent}
+ defer p.Close()
+
+ // fill the pool
+ conns := make([]Conn, numConcurrent)
+ for i := range conns {
+ c := p.Get()
+ if err := c.Err(); err != nil {
+ b.Fatal(err)
+ }
+ conns[i] = c
+ }
+ for _, c := range conns {
+ c.Close()
+ }
+
+ var wg sync.WaitGroup
+ wg.Add(numConcurrent)
+
+ b.StartTimer()
+
+ for i := 0; i < numConcurrent; i++ {
+ go func() {
+ defer wg.Done()
+ for i := 0; i < b.N; i++ {
+ c := p.Get()
+ c.Do("PING")
+ c.Close()
+ }
+ }()
+ }
+ wg.Wait()
+}
diff --git a/Godeps/_workspace/src/github.com/garyburd/redigo/redis/pubsub.go b/Godeps/_workspace/src/github.com/garyburd/redigo/redis/pubsub.go
new file mode 100644
index 0000000000000000000000000000000000000000..f0790429fd06ac46703c536ee9af99fcad75f512
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/garyburd/redigo/redis/pubsub.go
@@ -0,0 +1,129 @@
+// Copyright 2012 Gary Burd
+//
+// Licensed under the Apache License, Version 2.0 (the "License"): you may
+// not use this file except in compliance with the License. You may obtain
+// a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+// License for the specific language governing permissions and limitations
+// under the License.
+
+package redis
+
+import (
+ "errors"
+)
+
+// Subscription represents a subscribe or unsubscribe notification.
+type Subscription struct {
+
+ // Kind is "subscribe", "unsubscribe", "psubscribe" or "punsubscribe"
+ Kind string
+
+ // The channel that was changed.
+ Channel string
+
+ // The current number of subscriptions for connection.
+ Count int
+}
+
+// Message represents a message notification.
+type Message struct {
+
+ // The originating channel.
+ Channel string
+
+ // The message data.
+ Data []byte
+}
+
+// PMessage represents a pmessage notification.
+type PMessage struct {
+
+ // The matched pattern.
+ Pattern string
+
+ // The originating channel.
+ Channel string
+
+ // The message data.
+ Data []byte
+}
+
+// PubSubConn wraps a Conn with convenience methods for subscribers.
+type PubSubConn struct {
+ Conn Conn
+}
+
+// Close closes the connection.
+func (c PubSubConn) Close() error {
+ return c.Conn.Close()
+}
+
+// Subscribe subscribes the connection to the specified channels.
+func (c PubSubConn) Subscribe(channel ...interface{}) error {
+ c.Conn.Send("SUBSCRIBE", channel...)
+ return c.Conn.Flush()
+}
+
+// PSubscribe subscribes the connection to the given patterns.
+func (c PubSubConn) PSubscribe(channel ...interface{}) error {
+ c.Conn.Send("PSUBSCRIBE", channel...)
+ return c.Conn.Flush()
+}
+
+// Unsubscribe unsubscribes the connection from the given channels, or from all
+// of them if none is given.
+func (c PubSubConn) Unsubscribe(channel ...interface{}) error {
+ c.Conn.Send("UNSUBSCRIBE", channel...)
+ return c.Conn.Flush()
+}
+
+// PUnsubscribe unsubscribes the connection from the given patterns, or from all
+// of them if none is given.
+func (c PubSubConn) PUnsubscribe(channel ...interface{}) error {
+ c.Conn.Send("PUNSUBSCRIBE", channel...)
+ return c.Conn.Flush()
+}
+
+// Receive returns a pushed message as a Subscription, Message, PMessage or
+// error. The return value is intended to be used directly in a type switch as
+// illustrated in the PubSubConn example.
+func (c PubSubConn) Receive() interface{} {
+ reply, err := Values(c.Conn.Receive())
+ if err != nil {
+ return err
+ }
+
+ var kind string
+ reply, err = Scan(reply, &kind)
+ if err != nil {
+ return err
+ }
+
+ switch kind {
+ case "message":
+ var m Message
+ if _, err := Scan(reply, &m.Channel, &m.Data); err != nil {
+ return err
+ }
+ return m
+ case "pmessage":
+ var pm PMessage
+ if _, err := Scan(reply, &pm.Pattern, &pm.Channel, &pm.Data); err != nil {
+ return err
+ }
+ return pm
+ case "subscribe", "psubscribe", "unsubscribe", "punsubscribe":
+ s := Subscription{Kind: kind}
+ if _, err := Scan(reply, &s.Channel, &s.Count); err != nil {
+ return err
+ }
+ return s
+ }
+ return errors.New("redigo: unknown pubsub notification")
+}
diff --git a/Godeps/_workspace/src/github.com/garyburd/redigo/redis/pubsub_test.go b/Godeps/_workspace/src/github.com/garyburd/redigo/redis/pubsub_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..f5a095ed49f7ad605166c2e8f0242a90727b559c
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/garyburd/redigo/redis/pubsub_test.go
@@ -0,0 +1,141 @@
+// Copyright 2012 Gary Burd
+//
+// Licensed under the Apache License, Version 2.0 (the "License"): you may
+// not use this file except in compliance with the License. You may obtain
+// a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+// License for the specific language governing permissions and limitations
+// under the License.
+
+package redis_test
+
+import (
+ "fmt"
+ "github.com/garyburd/redigo/redis"
+ "net"
+ "reflect"
+ "sync"
+ "testing"
+ "time"
+)
+
+func publish(channel, value interface{}) {
+ c, err := dial()
+ if err != nil {
+ panic(err)
+ }
+ defer c.Close()
+ c.Do("PUBLISH", channel, value)
+}
+
+// Applications can receive pushed messages from one goroutine and manage subscriptions from another goroutine.
+func ExamplePubSubConn() {
+ c, err := dial()
+ if err != nil {
+ panic(err)
+ }
+ defer c.Close()
+ var wg sync.WaitGroup
+ wg.Add(2)
+
+ psc := redis.PubSubConn{Conn: c}
+
+ // This goroutine receives and prints pushed notifications from the server.
+ // The goroutine exits when the connection is unsubscribed from all
+ // channels or there is an error.
+ go func() {
+ defer wg.Done()
+ for {
+ switch n := psc.Receive().(type) {
+ case redis.Message:
+ fmt.Printf("Message: %s %s\n", n.Channel, n.Data)
+ case redis.PMessage:
+ fmt.Printf("PMessage: %s %s %s\n", n.Pattern, n.Channel, n.Data)
+ case redis.Subscription:
+ fmt.Printf("Subscription: %s %s %d\n", n.Kind, n.Channel, n.Count)
+ if n.Count == 0 {
+ return
+ }
+ case error:
+ fmt.Printf("error: %v\n", n)
+ return
+ }
+ }
+ }()
+
+ // This goroutine manages subscriptions for the connection.
+ go func() {
+ defer wg.Done()
+
+ psc.Subscribe("example")
+ psc.PSubscribe("p*")
+
+ // The following function calls publish a message using another
+ // connection to the Redis server.
+ publish("example", "hello")
+ publish("example", "world")
+ publish("pexample", "foo")
+ publish("pexample", "bar")
+
+ // Unsubscribe from all connections. This will cause the receiving
+ // goroutine to exit.
+ psc.Unsubscribe()
+ psc.PUnsubscribe()
+ }()
+
+ wg.Wait()
+
+ // Output:
+ // Subscription: subscribe example 1
+ // Subscription: psubscribe p* 2
+ // Message: example hello
+ // Message: example world
+ // PMessage: p* pexample foo
+ // PMessage: p* pexample bar
+ // Subscription: unsubscribe example 1
+ // Subscription: punsubscribe p* 0
+}
+
+func expectPushed(t *testing.T, c redis.PubSubConn, message string, expected interface{}) {
+ actual := c.Receive()
+ if !reflect.DeepEqual(actual, expected) {
+ t.Errorf("%s = %v, want %v", message, actual, expected)
+ }
+}
+
+func TestPushed(t *testing.T) {
+ pc, err := redis.DialTestDB()
+ if err != nil {
+ t.Fatalf("error connection to database, %v", err)
+ }
+ defer pc.Close()
+
+ nc, err := net.Dial("tcp", ":6379")
+ if err != nil {
+ t.Fatal(err)
+ }
+ defer nc.Close()
+ nc.SetReadDeadline(time.Now().Add(4 * time.Second))
+
+ c := redis.PubSubConn{Conn: redis.NewConn(nc, 0, 0)}
+
+ c.Subscribe("c1")
+ expectPushed(t, c, "Subscribe(c1)", redis.Subscription{Kind: "subscribe", Channel: "c1", Count: 1})
+ c.Subscribe("c2")
+ expectPushed(t, c, "Subscribe(c2)", redis.Subscription{Kind: "subscribe", Channel: "c2", Count: 2})
+ c.PSubscribe("p1")
+ expectPushed(t, c, "PSubscribe(p1)", redis.Subscription{Kind: "psubscribe", Channel: "p1", Count: 3})
+ c.PSubscribe("p2")
+ expectPushed(t, c, "PSubscribe(p2)", redis.Subscription{Kind: "psubscribe", Channel: "p2", Count: 4})
+ c.PUnsubscribe()
+ expectPushed(t, c, "Punsubscribe(p1)", redis.Subscription{Kind: "punsubscribe", Channel: "p1", Count: 3})
+ expectPushed(t, c, "Punsubscribe()", redis.Subscription{Kind: "punsubscribe", Channel: "p2", Count: 2})
+
+ pc.Do("PUBLISH", "c1", "hello")
+ expectPushed(t, c, "PUBLISH c1 hello", redis.Message{Channel: "c1", Data: []byte("hello")})
+}
diff --git a/Godeps/_workspace/src/github.com/garyburd/redigo/redis/redis.go b/Godeps/_workspace/src/github.com/garyburd/redigo/redis/redis.go
new file mode 100644
index 0000000000000000000000000000000000000000..c90a48ed44b10c0fd257b96793ed596ae8fa8bec
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/garyburd/redigo/redis/redis.go
@@ -0,0 +1,44 @@
+// Copyright 2012 Gary Burd
+//
+// Licensed under the Apache License, Version 2.0 (the "License"): you may
+// not use this file except in compliance with the License. You may obtain
+// a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+// License for the specific language governing permissions and limitations
+// under the License.
+
+package redis
+
+// Error represents an error returned in a command reply.
+type Error string
+
+func (err Error) Error() string { return string(err) }
+
+// Conn represents a connection to a Redis server.
+type Conn interface {
+ // Close closes the connection.
+ Close() error
+
+ // Err returns a non-nil value if the connection is broken. The returned
+ // value is either the first non-nil value returned from the underlying
+ // network connection or a protocol parsing error. Applications should
+ // close broken connections.
+ Err() error
+
+ // Do sends a command to the server and returns the received reply.
+ Do(commandName string, args ...interface{}) (reply interface{}, err error)
+
+ // Send writes the command to the client's output buffer.
+ Send(commandName string, args ...interface{}) error
+
+ // Flush flushes the output buffer to the Redis server.
+ Flush() error
+
+ // Receive receives a single reply from the Redis server
+ Receive() (reply interface{}, err error)
+}
diff --git a/Godeps/_workspace/src/github.com/garyburd/redigo/redis/reply.go b/Godeps/_workspace/src/github.com/garyburd/redigo/redis/reply.go
new file mode 100644
index 0000000000000000000000000000000000000000..161a147b00ee411a966c5393bab101a8e5859949
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/garyburd/redigo/redis/reply.go
@@ -0,0 +1,271 @@
+// Copyright 2012 Gary Burd
+//
+// Licensed under the Apache License, Version 2.0 (the "License"): you may
+// not use this file except in compliance with the License. You may obtain
+// a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+// License for the specific language governing permissions and limitations
+// under the License.
+
+package redis
+
+import (
+ "errors"
+ "fmt"
+ "strconv"
+)
+
+// ErrNil indicates that a reply value is nil.
+var ErrNil = errors.New("redigo: nil returned")
+
+// Int is a helper that converts a command reply to an integer. If err is not
+// equal to nil, then Int returns 0, err. Otherwise, Int converts the
+// reply to an int as follows:
+//
+// Reply type Result
+// integer int(reply), nil
+// bulk string parsed reply, nil
+// nil 0, ErrNil
+// other 0, error
+func Int(reply interface{}, err error) (int, error) {
+ if err != nil {
+ return 0, err
+ }
+ switch reply := reply.(type) {
+ case int64:
+ x := int(reply)
+ if int64(x) != reply {
+ return 0, strconv.ErrRange
+ }
+ return x, nil
+ case []byte:
+ n, err := strconv.ParseInt(string(reply), 10, 0)
+ return int(n), err
+ case nil:
+ return 0, ErrNil
+ case Error:
+ return 0, reply
+ }
+ return 0, fmt.Errorf("redigo: unexpected type for Int, got type %T", reply)
+}
+
+// Int64 is a helper that converts a command reply to 64 bit integer. If err is
+// not equal to nil, then Int returns 0, err. Otherwise, Int64 converts the
+// reply to an int64 as follows:
+//
+// Reply type Result
+// integer reply, nil
+// bulk string parsed reply, nil
+// nil 0, ErrNil
+// other 0, error
+func Int64(reply interface{}, err error) (int64, error) {
+ if err != nil {
+ return 0, err
+ }
+ switch reply := reply.(type) {
+ case int64:
+ return reply, nil
+ case []byte:
+ n, err := strconv.ParseInt(string(reply), 10, 64)
+ return n, err
+ case nil:
+ return 0, ErrNil
+ case Error:
+ return 0, reply
+ }
+ return 0, fmt.Errorf("redigo: unexpected type for Int64, got type %T", reply)
+}
+
+var errNegativeInt = errors.New("redigo: unexpected value for Uint64")
+
+// Uint64 is a helper that converts a command reply to 64 bit integer. If err is
+// not equal to nil, then Int returns 0, err. Otherwise, Int64 converts the
+// reply to an int64 as follows:
+//
+// Reply type Result
+// integer reply, nil
+// bulk string parsed reply, nil
+// nil 0, ErrNil
+// other 0, error
+func Uint64(reply interface{}, err error) (uint64, error) {
+ if err != nil {
+ return 0, err
+ }
+ switch reply := reply.(type) {
+ case int64:
+ if reply < 0 {
+ return 0, errNegativeInt
+ }
+ return uint64(reply), nil
+ case []byte:
+ n, err := strconv.ParseUint(string(reply), 10, 64)
+ return n, err
+ case nil:
+ return 0, ErrNil
+ case Error:
+ return 0, reply
+ }
+ return 0, fmt.Errorf("redigo: unexpected type for Uint64, got type %T", reply)
+}
+
+// Float64 is a helper that converts a command reply to 64 bit float. If err is
+// not equal to nil, then Float64 returns 0, err. Otherwise, Float64 converts
+// the reply to an int as follows:
+//
+// Reply type Result
+// bulk string parsed reply, nil
+// nil 0, ErrNil
+// other 0, error
+func Float64(reply interface{}, err error) (float64, error) {
+ if err != nil {
+ return 0, err
+ }
+ switch reply := reply.(type) {
+ case []byte:
+ n, err := strconv.ParseFloat(string(reply), 64)
+ return n, err
+ case nil:
+ return 0, ErrNil
+ case Error:
+ return 0, reply
+ }
+ return 0, fmt.Errorf("redigo: unexpected type for Float64, got type %T", reply)
+}
+
+// String is a helper that converts a command reply to a string. If err is not
+// equal to nil, then String returns "", err. Otherwise String converts the
+// reply to a string as follows:
+//
+// Reply type Result
+// bulk string string(reply), nil
+// simple string reply, nil
+// nil "", ErrNil
+// other "", error
+func String(reply interface{}, err error) (string, error) {
+ if err != nil {
+ return "", err
+ }
+ switch reply := reply.(type) {
+ case []byte:
+ return string(reply), nil
+ case string:
+ return reply, nil
+ case nil:
+ return "", ErrNil
+ case Error:
+ return "", reply
+ }
+ return "", fmt.Errorf("redigo: unexpected type for String, got type %T", reply)
+}
+
+// Bytes is a helper that converts a command reply to a slice of bytes. If err
+// is not equal to nil, then Bytes returns nil, err. Otherwise Bytes converts
+// the reply to a slice of bytes as follows:
+//
+// Reply type Result
+// bulk string reply, nil
+// simple string []byte(reply), nil
+// nil nil, ErrNil
+// other nil, error
+func Bytes(reply interface{}, err error) ([]byte, error) {
+ if err != nil {
+ return nil, err
+ }
+ switch reply := reply.(type) {
+ case []byte:
+ return reply, nil
+ case string:
+ return []byte(reply), nil
+ case nil:
+ return nil, ErrNil
+ case Error:
+ return nil, reply
+ }
+ return nil, fmt.Errorf("redigo: unexpected type for Bytes, got type %T", reply)
+}
+
+// Bool is a helper that converts a command reply to a boolean. If err is not
+// equal to nil, then Bool returns false, err. Otherwise Bool converts the
+// reply to boolean as follows:
+//
+// Reply type Result
+// integer value != 0, nil
+// bulk string strconv.ParseBool(reply)
+// nil false, ErrNil
+// other false, error
+func Bool(reply interface{}, err error) (bool, error) {
+ if err != nil {
+ return false, err
+ }
+ switch reply := reply.(type) {
+ case int64:
+ return reply != 0, nil
+ case []byte:
+ return strconv.ParseBool(string(reply))
+ case nil:
+ return false, ErrNil
+ case Error:
+ return false, reply
+ }
+ return false, fmt.Errorf("redigo: unexpected type for Bool, got type %T", reply)
+}
+
+// MultiBulk is deprecated. Use Values.
+func MultiBulk(reply interface{}, err error) ([]interface{}, error) { return Values(reply, err) }
+
+// Values is a helper that converts an array command reply to a []interface{}.
+// If err is not equal to nil, then Values returns nil, err. Otherwise, Values
+// converts the reply as follows:
+//
+// Reply type Result
+// array reply, nil
+// nil nil, ErrNil
+// other nil, error
+func Values(reply interface{}, err error) ([]interface{}, error) {
+ if err != nil {
+ return nil, err
+ }
+ switch reply := reply.(type) {
+ case []interface{}:
+ return reply, nil
+ case nil:
+ return nil, ErrNil
+ case Error:
+ return nil, reply
+ }
+ return nil, fmt.Errorf("redigo: unexpected type for Values, got type %T", reply)
+}
+
+// Strings is a helper that converts an array command reply to a []string. If
+// err is not equal to nil, then Strings returns nil, err. If one of the array
+// items is not a bulk string or nil, then Strings returns an error.
+func Strings(reply interface{}, err error) ([]string, error) {
+ if err != nil {
+ return nil, err
+ }
+ switch reply := reply.(type) {
+ case []interface{}:
+ result := make([]string, len(reply))
+ for i := range reply {
+ if reply[i] == nil {
+ continue
+ }
+ p, ok := reply[i].([]byte)
+ if !ok {
+ return nil, fmt.Errorf("redigo: unexpected element type for Strings, got type %T", reply[i])
+ }
+ result[i] = string(p)
+ }
+ return result, nil
+ case nil:
+ return nil, ErrNil
+ case Error:
+ return nil, reply
+ }
+ return nil, fmt.Errorf("redigo: unexpected type for Strings, got type %T", reply)
+}
diff --git a/Godeps/_workspace/src/github.com/garyburd/redigo/redis/reply_test.go b/Godeps/_workspace/src/github.com/garyburd/redigo/redis/reply_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..057a154a39be91455bd6e4144afdca3c0f083561
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/garyburd/redigo/redis/reply_test.go
@@ -0,0 +1,141 @@
+// Copyright 2012 Gary Burd
+//
+// Licensed under the Apache License, Version 2.0 (the "License"): you may
+// not use this file except in compliance with the License. You may obtain
+// a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+// License for the specific language governing permissions and limitations
+// under the License.
+
+package redis_test
+
+import (
+ "fmt"
+ "reflect"
+ "testing"
+
+ "github.com/garyburd/redigo/redis"
+)
+
+type valueError struct {
+ v interface{}
+ err error
+}
+
+func ve(v interface{}, err error) valueError {
+ return valueError{v, err}
+}
+
+var replyTests = []struct {
+ name interface{}
+ actual valueError
+ expected valueError
+}{
+ {
+ "strings([v1, v2])",
+ ve(redis.Strings([]interface{}{[]byte("v1"), []byte("v2")}, nil)),
+ ve([]string{"v1", "v2"}, nil),
+ },
+ {
+ "strings(nil)",
+ ve(redis.Strings(nil, nil)),
+ ve([]string(nil), redis.ErrNil),
+ },
+ {
+ "values([v1, v2])",
+ ve(redis.Values([]interface{}{[]byte("v1"), []byte("v2")}, nil)),
+ ve([]interface{}{[]byte("v1"), []byte("v2")}, nil),
+ },
+ {
+ "values(nil)",
+ ve(redis.Values(nil, nil)),
+ ve([]interface{}(nil), redis.ErrNil),
+ },
+ {
+ "float64(1.0)",
+ ve(redis.Float64([]byte("1.0"), nil)),
+ ve(float64(1.0), nil),
+ },
+ {
+ "float64(nil)",
+ ve(redis.Float64(nil, nil)),
+ ve(float64(0.0), redis.ErrNil),
+ },
+ {
+ "uint64(1)",
+ ve(redis.Uint64(int64(1), nil)),
+ ve(uint64(1), nil),
+ },
+ {
+ "uint64(-1)",
+ ve(redis.Uint64(int64(-1), nil)),
+ ve(uint64(0), redis.ErrNegativeInt),
+ },
+}
+
+func TestReply(t *testing.T) {
+ for _, rt := range replyTests {
+ if rt.actual.err != rt.expected.err {
+ t.Errorf("%s returned err %v, want %v", rt.name, rt.actual.err, rt.expected.err)
+ continue
+ }
+ if !reflect.DeepEqual(rt.actual.v, rt.expected.v) {
+ t.Errorf("%s=%+v, want %+v", rt.name, rt.actual.v, rt.expected.v)
+ }
+ }
+}
+
+// dial wraps DialTestDB() with a more suitable function name for examples.
+func dial() (redis.Conn, error) {
+ return redis.DialTestDB()
+}
+
+func ExampleBool() {
+ c, err := dial()
+ if err != nil {
+ panic(err)
+ }
+ defer c.Close()
+
+ c.Do("SET", "foo", 1)
+ exists, _ := redis.Bool(c.Do("EXISTS", "foo"))
+ fmt.Printf("%#v\n", exists)
+ // Output:
+ // true
+}
+
+func ExampleInt() {
+ c, err := dial()
+ if err != nil {
+ panic(err)
+ }
+ defer c.Close()
+
+ c.Do("SET", "k1", 1)
+ n, _ := redis.Int(c.Do("GET", "k1"))
+ fmt.Printf("%#v\n", n)
+ n, _ = redis.Int(c.Do("INCR", "k1"))
+ fmt.Printf("%#v\n", n)
+ // Output:
+ // 1
+ // 2
+}
+
+func ExampleString() {
+ c, err := dial()
+ if err != nil {
+ panic(err)
+ }
+ defer c.Close()
+
+ c.Do("SET", "hello", "world")
+ s, err := redis.String(c.Do("GET", "hello"))
+ fmt.Printf("%#v\n", s)
+ // Output:
+ // "world"
+}
diff --git a/Godeps/_workspace/src/github.com/garyburd/redigo/redis/scan.go b/Godeps/_workspace/src/github.com/garyburd/redigo/redis/scan.go
new file mode 100644
index 0000000000000000000000000000000000000000..8c9cfa18d479177fcde1dbd763cbf327472beefc
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/garyburd/redigo/redis/scan.go
@@ -0,0 +1,513 @@
+// Copyright 2012 Gary Burd
+//
+// Licensed under the Apache License, Version 2.0 (the "License"): you may
+// not use this file except in compliance with the License. You may obtain
+// a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+// License for the specific language governing permissions and limitations
+// under the License.
+
+package redis
+
+import (
+ "errors"
+ "fmt"
+ "reflect"
+ "strconv"
+ "strings"
+ "sync"
+)
+
+func ensureLen(d reflect.Value, n int) {
+ if n > d.Cap() {
+ d.Set(reflect.MakeSlice(d.Type(), n, n))
+ } else {
+ d.SetLen(n)
+ }
+}
+
+func cannotConvert(d reflect.Value, s interface{}) error {
+ return fmt.Errorf("redigo: Scan cannot convert from %s to %s",
+ reflect.TypeOf(s), d.Type())
+}
+
+func convertAssignBytes(d reflect.Value, s []byte) (err error) {
+ switch d.Type().Kind() {
+ case reflect.Float32, reflect.Float64:
+ var x float64
+ x, err = strconv.ParseFloat(string(s), d.Type().Bits())
+ d.SetFloat(x)
+ case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+ var x int64
+ x, err = strconv.ParseInt(string(s), 10, d.Type().Bits())
+ d.SetInt(x)
+ case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
+ var x uint64
+ x, err = strconv.ParseUint(string(s), 10, d.Type().Bits())
+ d.SetUint(x)
+ case reflect.Bool:
+ var x bool
+ x, err = strconv.ParseBool(string(s))
+ d.SetBool(x)
+ case reflect.String:
+ d.SetString(string(s))
+ case reflect.Slice:
+ if d.Type().Elem().Kind() != reflect.Uint8 {
+ err = cannotConvert(d, s)
+ } else {
+ d.SetBytes(s)
+ }
+ default:
+ err = cannotConvert(d, s)
+ }
+ return
+}
+
+func convertAssignInt(d reflect.Value, s int64) (err error) {
+ switch d.Type().Kind() {
+ case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+ d.SetInt(s)
+ if d.Int() != s {
+ err = strconv.ErrRange
+ d.SetInt(0)
+ }
+ case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
+ if s < 0 {
+ err = strconv.ErrRange
+ } else {
+ x := uint64(s)
+ d.SetUint(x)
+ if d.Uint() != x {
+ err = strconv.ErrRange
+ d.SetUint(0)
+ }
+ }
+ case reflect.Bool:
+ d.SetBool(s != 0)
+ default:
+ err = cannotConvert(d, s)
+ }
+ return
+}
+
+func convertAssignValue(d reflect.Value, s interface{}) (err error) {
+ switch s := s.(type) {
+ case []byte:
+ err = convertAssignBytes(d, s)
+ case int64:
+ err = convertAssignInt(d, s)
+ default:
+ err = cannotConvert(d, s)
+ }
+ return err
+}
+
+func convertAssignValues(d reflect.Value, s []interface{}) error {
+ if d.Type().Kind() != reflect.Slice {
+ return cannotConvert(d, s)
+ }
+ ensureLen(d, len(s))
+ for i := 0; i < len(s); i++ {
+ if err := convertAssignValue(d.Index(i), s[i]); err != nil {
+ return err
+ }
+ }
+ return nil
+}
+
+func convertAssign(d interface{}, s interface{}) (err error) {
+ // Handle the most common destination types using type switches and
+ // fall back to reflection for all other types.
+ switch s := s.(type) {
+ case nil:
+ // ingore
+ case []byte:
+ switch d := d.(type) {
+ case *string:
+ *d = string(s)
+ case *int:
+ *d, err = strconv.Atoi(string(s))
+ case *bool:
+ *d, err = strconv.ParseBool(string(s))
+ case *[]byte:
+ *d = s
+ case *interface{}:
+ *d = s
+ case nil:
+ // skip value
+ default:
+ if d := reflect.ValueOf(d); d.Type().Kind() != reflect.Ptr {
+ err = cannotConvert(d, s)
+ } else {
+ err = convertAssignBytes(d.Elem(), s)
+ }
+ }
+ case int64:
+ switch d := d.(type) {
+ case *int:
+ x := int(s)
+ if int64(x) != s {
+ err = strconv.ErrRange
+ x = 0
+ }
+ *d = x
+ case *bool:
+ *d = s != 0
+ case *interface{}:
+ *d = s
+ case nil:
+ // skip value
+ default:
+ if d := reflect.ValueOf(d); d.Type().Kind() != reflect.Ptr {
+ err = cannotConvert(d, s)
+ } else {
+ err = convertAssignInt(d.Elem(), s)
+ }
+ }
+ case []interface{}:
+ switch d := d.(type) {
+ case *[]interface{}:
+ *d = s
+ case *interface{}:
+ *d = s
+ case nil:
+ // skip value
+ default:
+ if d := reflect.ValueOf(d); d.Type().Kind() != reflect.Ptr {
+ err = cannotConvert(d, s)
+ } else {
+ err = convertAssignValues(d.Elem(), s)
+ }
+ }
+ case Error:
+ err = s
+ default:
+ err = cannotConvert(reflect.ValueOf(d), s)
+ }
+ return
+}
+
+// Scan copies from src to the values pointed at by dest.
+//
+// The values pointed at by dest must be an integer, float, boolean, string,
+// []byte, interface{} or slices of these types. Scan uses the standard strconv
+// package to convert bulk strings to numeric and boolean types.
+//
+// If a dest value is nil, then the corresponding src value is skipped.
+//
+// If a src element is nil, then the corresponding dest value is not modified.
+//
+// To enable easy use of Scan in a loop, Scan returns the slice of src
+// following the copied values.
+func Scan(src []interface{}, dest ...interface{}) ([]interface{}, error) {
+ if len(src) < len(dest) {
+ return nil, errors.New("redigo: Scan array short")
+ }
+ var err error
+ for i, d := range dest {
+ err = convertAssign(d, src[i])
+ if err != nil {
+ break
+ }
+ }
+ return src[len(dest):], err
+}
+
+type fieldSpec struct {
+ name string
+ index []int
+ //omitEmpty bool
+}
+
+type structSpec struct {
+ m map[string]*fieldSpec
+ l []*fieldSpec
+}
+
+func (ss *structSpec) fieldSpec(name []byte) *fieldSpec {
+ return ss.m[string(name)]
+}
+
+func compileStructSpec(t reflect.Type, depth map[string]int, index []int, ss *structSpec) {
+ for i := 0; i < t.NumField(); i++ {
+ f := t.Field(i)
+ switch {
+ case f.PkgPath != "":
+ // Ignore unexported fields.
+ case f.Anonymous:
+ // TODO: Handle pointers. Requires change to decoder and
+ // protection against infinite recursion.
+ if f.Type.Kind() == reflect.Struct {
+ compileStructSpec(f.Type, depth, append(index, i), ss)
+ }
+ default:
+ fs := &fieldSpec{name: f.Name}
+ tag := f.Tag.Get("redis")
+ p := strings.Split(tag, ",")
+ if len(p) > 0 {
+ if p[0] == "-" {
+ continue
+ }
+ if len(p[0]) > 0 {
+ fs.name = p[0]
+ }
+ for _, s := range p[1:] {
+ switch s {
+ //case "omitempty":
+ // fs.omitempty = true
+ default:
+ panic(errors.New("redigo: unknown field flag " + s + " for type " + t.Name()))
+ }
+ }
+ }
+ d, found := depth[fs.name]
+ if !found {
+ d = 1 << 30
+ }
+ switch {
+ case len(index) == d:
+ // At same depth, remove from result.
+ delete(ss.m, fs.name)
+ j := 0
+ for i := 0; i < len(ss.l); i++ {
+ if fs.name != ss.l[i].name {
+ ss.l[j] = ss.l[i]
+ j += 1
+ }
+ }
+ ss.l = ss.l[:j]
+ case len(index) < d:
+ fs.index = make([]int, len(index)+1)
+ copy(fs.index, index)
+ fs.index[len(index)] = i
+ depth[fs.name] = len(index)
+ ss.m[fs.name] = fs
+ ss.l = append(ss.l, fs)
+ }
+ }
+ }
+}
+
+var (
+ structSpecMutex sync.RWMutex
+ structSpecCache = make(map[reflect.Type]*structSpec)
+ defaultFieldSpec = &fieldSpec{}
+)
+
+func structSpecForType(t reflect.Type) *structSpec {
+
+ structSpecMutex.RLock()
+ ss, found := structSpecCache[t]
+ structSpecMutex.RUnlock()
+ if found {
+ return ss
+ }
+
+ structSpecMutex.Lock()
+ defer structSpecMutex.Unlock()
+ ss, found = structSpecCache[t]
+ if found {
+ return ss
+ }
+
+ ss = &structSpec{m: make(map[string]*fieldSpec)}
+ compileStructSpec(t, make(map[string]int), nil, ss)
+ structSpecCache[t] = ss
+ return ss
+}
+
+var errScanStructValue = errors.New("redigo: ScanStruct value must be non-nil pointer to a struct")
+
+// ScanStruct scans alternating names and values from src to a struct. The
+// HGETALL and CONFIG GET commands return replies in this format.
+//
+// ScanStruct uses exported field names to match values in the response. Use
+// 'redis' field tag to override the name:
+//
+// Field int `redis:"myName"`
+//
+// Fields with the tag redis:"-" are ignored.
+//
+// Integer, float, boolean, string and []byte fields are supported. Scan uses the
+// standard strconv package to convert bulk string values to numeric and
+// boolean types.
+//
+// If a src element is nil, then the corresponding field is not modified.
+func ScanStruct(src []interface{}, dest interface{}) error {
+ d := reflect.ValueOf(dest)
+ if d.Kind() != reflect.Ptr || d.IsNil() {
+ return errScanStructValue
+ }
+ d = d.Elem()
+ if d.Kind() != reflect.Struct {
+ return errScanStructValue
+ }
+ ss := structSpecForType(d.Type())
+
+ if len(src)%2 != 0 {
+ return errors.New("redigo: ScanStruct expects even number of values in values")
+ }
+
+ for i := 0; i < len(src); i += 2 {
+ s := src[i+1]
+ if s == nil {
+ continue
+ }
+ name, ok := src[i].([]byte)
+ if !ok {
+ return errors.New("redigo: ScanStruct key not a bulk string value")
+ }
+ fs := ss.fieldSpec(name)
+ if fs == nil {
+ continue
+ }
+ if err := convertAssignValue(d.FieldByIndex(fs.index), s); err != nil {
+ return err
+ }
+ }
+ return nil
+}
+
+var (
+ errScanSliceValue = errors.New("redigo: ScanSlice dest must be non-nil pointer to a struct")
+)
+
+// ScanSlice scans src to the slice pointed to by dest. The elements the dest
+// slice must be integer, float, boolean, string, struct or pointer to struct
+// values.
+//
+// Struct fields must be integer, float, boolean or string values. All struct
+// fields are used unless a subset is specified using fieldNames.
+func ScanSlice(src []interface{}, dest interface{}, fieldNames ...string) error {
+ d := reflect.ValueOf(dest)
+ if d.Kind() != reflect.Ptr || d.IsNil() {
+ return errScanSliceValue
+ }
+ d = d.Elem()
+ if d.Kind() != reflect.Slice {
+ return errScanSliceValue
+ }
+
+ isPtr := false
+ t := d.Type().Elem()
+ if t.Kind() == reflect.Ptr && t.Elem().Kind() == reflect.Struct {
+ isPtr = true
+ t = t.Elem()
+ }
+
+ if t.Kind() != reflect.Struct {
+ ensureLen(d, len(src))
+ for i, s := range src {
+ if s == nil {
+ continue
+ }
+ if err := convertAssignValue(d.Index(i), s); err != nil {
+ return err
+ }
+ }
+ return nil
+ }
+
+ ss := structSpecForType(t)
+ fss := ss.l
+ if len(fieldNames) > 0 {
+ fss = make([]*fieldSpec, len(fieldNames))
+ for i, name := range fieldNames {
+ fss[i] = ss.m[name]
+ if fss[i] == nil {
+ return errors.New("redigo: ScanSlice bad field name " + name)
+ }
+ }
+ }
+
+ if len(fss) == 0 {
+ return errors.New("redigo: ScanSlice no struct fields")
+ }
+
+ n := len(src) / len(fss)
+ if n*len(fss) != len(src) {
+ return errors.New("redigo: ScanSlice length not a multiple of struct field count")
+ }
+
+ ensureLen(d, n)
+ for i := 0; i < n; i++ {
+ d := d.Index(i)
+ if isPtr {
+ if d.IsNil() {
+ d.Set(reflect.New(t))
+ }
+ d = d.Elem()
+ }
+ for j, fs := range fss {
+ s := src[i*len(fss)+j]
+ if s == nil {
+ continue
+ }
+ if err := convertAssignValue(d.FieldByIndex(fs.index), s); err != nil {
+ return err
+ }
+ }
+ }
+ return nil
+}
+
+// Args is a helper for constructing command arguments from structured values.
+type Args []interface{}
+
+// Add returns the result of appending value to args.
+func (args Args) Add(value ...interface{}) Args {
+ return append(args, value...)
+}
+
+// AddFlat returns the result of appending the flattened value of v to args.
+//
+// Maps are flattened by appending the alternating keys and map values to args.
+//
+// Slices are flattened by appending the slice elements to args.
+//
+// Structs are flattened by appending the alternating names and values of
+// exported fields to args. If v is a nil struct pointer, then nothing is
+// appended. The 'redis' field tag overrides struct field names. See ScanStruct
+// for more information on the use of the 'redis' field tag.
+//
+// Other types are appended to args as is.
+func (args Args) AddFlat(v interface{}) Args {
+ rv := reflect.ValueOf(v)
+ switch rv.Kind() {
+ case reflect.Struct:
+ args = flattenStruct(args, rv)
+ case reflect.Slice:
+ for i := 0; i < rv.Len(); i++ {
+ args = append(args, rv.Index(i).Interface())
+ }
+ case reflect.Map:
+ for _, k := range rv.MapKeys() {
+ args = append(args, k.Interface(), rv.MapIndex(k).Interface())
+ }
+ case reflect.Ptr:
+ if rv.Type().Elem().Kind() == reflect.Struct {
+ if !rv.IsNil() {
+ args = flattenStruct(args, rv.Elem())
+ }
+ } else {
+ args = append(args, v)
+ }
+ default:
+ args = append(args, v)
+ }
+ return args
+}
+
+func flattenStruct(args Args, v reflect.Value) Args {
+ ss := structSpecForType(v.Type())
+ for _, fs := range ss.l {
+ fv := v.FieldByIndex(fs.index)
+ args = append(args, fs.name, fv.Interface())
+ }
+ return args
+}
diff --git a/Godeps/_workspace/src/github.com/garyburd/redigo/redis/scan_test.go b/Godeps/_workspace/src/github.com/garyburd/redigo/redis/scan_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..b57dd89695e16909cf4609456b7bba36e038c86c
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/garyburd/redigo/redis/scan_test.go
@@ -0,0 +1,412 @@
+// Copyright 2012 Gary Burd
+//
+// Licensed under the Apache License, Version 2.0 (the "License"): you may
+// not use this file except in compliance with the License. You may obtain
+// a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+// License for the specific language governing permissions and limitations
+// under the License.
+
+package redis_test
+
+import (
+ "fmt"
+ "github.com/garyburd/redigo/redis"
+ "math"
+ "reflect"
+ "testing"
+)
+
+var scanConversionTests = []struct {
+ src interface{}
+ dest interface{}
+}{
+ {[]byte("-inf"), math.Inf(-1)},
+ {[]byte("+inf"), math.Inf(1)},
+ {[]byte("0"), float64(0)},
+ {[]byte("3.14159"), float64(3.14159)},
+ {[]byte("3.14"), float32(3.14)},
+ {[]byte("-100"), int(-100)},
+ {[]byte("101"), int(101)},
+ {int64(102), int(102)},
+ {[]byte("103"), uint(103)},
+ {int64(104), uint(104)},
+ {[]byte("105"), int8(105)},
+ {int64(106), int8(106)},
+ {[]byte("107"), uint8(107)},
+ {int64(108), uint8(108)},
+ {[]byte("0"), false},
+ {int64(0), false},
+ {[]byte("f"), false},
+ {[]byte("1"), true},
+ {int64(1), true},
+ {[]byte("t"), true},
+ {[]byte("hello"), "hello"},
+ {[]byte("world"), []byte("world")},
+ {[]interface{}{[]byte("foo")}, []interface{}{[]byte("foo")}},
+ {[]interface{}{[]byte("foo")}, []string{"foo"}},
+ {[]interface{}{[]byte("hello"), []byte("world")}, []string{"hello", "world"}},
+ {[]interface{}{[]byte("bar")}, [][]byte{[]byte("bar")}},
+ {[]interface{}{[]byte("1")}, []int{1}},
+ {[]interface{}{[]byte("1"), []byte("2")}, []int{1, 2}},
+ {[]interface{}{[]byte("1"), []byte("2")}, []float64{1, 2}},
+ {[]interface{}{[]byte("1")}, []byte{1}},
+ {[]interface{}{[]byte("1")}, []bool{true}},
+}
+
+func TestScanConversion(t *testing.T) {
+ for _, tt := range scanConversionTests {
+ values := []interface{}{tt.src}
+ dest := reflect.New(reflect.TypeOf(tt.dest))
+ values, err := redis.Scan(values, dest.Interface())
+ if err != nil {
+ t.Errorf("Scan(%v) returned error %v", tt, err)
+ continue
+ }
+ if !reflect.DeepEqual(tt.dest, dest.Elem().Interface()) {
+ t.Errorf("Scan(%v) returned %v, want %v", tt, dest.Elem().Interface(), tt.dest)
+ }
+ }
+}
+
+var scanConversionErrorTests = []struct {
+ src interface{}
+ dest interface{}
+}{
+ {[]byte("1234"), byte(0)},
+ {int64(1234), byte(0)},
+ {[]byte("-1"), byte(0)},
+ {int64(-1), byte(0)},
+ {[]byte("junk"), false},
+ {redis.Error("blah"), false},
+}
+
+func TestScanConversionError(t *testing.T) {
+ for _, tt := range scanConversionErrorTests {
+ values := []interface{}{tt.src}
+ dest := reflect.New(reflect.TypeOf(tt.dest))
+ values, err := redis.Scan(values, dest.Interface())
+ if err == nil {
+ t.Errorf("Scan(%v) did not return error", tt)
+ }
+ }
+}
+
+func ExampleScan() {
+ c, err := dial()
+ if err != nil {
+ panic(err)
+ }
+ defer c.Close()
+
+ c.Send("HMSET", "album:1", "title", "Red", "rating", 5)
+ c.Send("HMSET", "album:2", "title", "Earthbound", "rating", 1)
+ c.Send("HMSET", "album:3", "title", "Beat")
+ c.Send("LPUSH", "albums", "1")
+ c.Send("LPUSH", "albums", "2")
+ c.Send("LPUSH", "albums", "3")
+ values, err := redis.Values(c.Do("SORT", "albums",
+ "BY", "album:*->rating",
+ "GET", "album:*->title",
+ "GET", "album:*->rating"))
+ if err != nil {
+ panic(err)
+ }
+
+ for len(values) > 0 {
+ var title string
+ rating := -1 // initialize to illegal value to detect nil.
+ values, err = redis.Scan(values, &title, &rating)
+ if err != nil {
+ panic(err)
+ }
+ if rating == -1 {
+ fmt.Println(title, "not-rated")
+ } else {
+ fmt.Println(title, rating)
+ }
+ }
+ // Output:
+ // Beat not-rated
+ // Earthbound 1
+ // Red 5
+}
+
+type s0 struct {
+ X int
+ Y int `redis:"y"`
+ Bt bool
+}
+
+type s1 struct {
+ X int `redis:"-"`
+ I int `redis:"i"`
+ U uint `redis:"u"`
+ S string `redis:"s"`
+ P []byte `redis:"p"`
+ B bool `redis:"b"`
+ Bt bool
+ Bf bool
+ s0
+}
+
+var scanStructTests = []struct {
+ title string
+ reply []string
+ value interface{}
+}{
+ {"basic",
+ []string{"i", "-1234", "u", "5678", "s", "hello", "p", "world", "b", "t", "Bt", "1", "Bf", "0", "X", "123", "y", "456"},
+ &s1{I: -1234, U: 5678, S: "hello", P: []byte("world"), B: true, Bt: true, Bf: false, s0: s0{X: 123, Y: 456}},
+ },
+}
+
+func TestScanStruct(t *testing.T) {
+ for _, tt := range scanStructTests {
+
+ var reply []interface{}
+ for _, v := range tt.reply {
+ reply = append(reply, []byte(v))
+ }
+
+ value := reflect.New(reflect.ValueOf(tt.value).Type().Elem())
+
+ if err := redis.ScanStruct(reply, value.Interface()); err != nil {
+ t.Fatalf("ScanStruct(%s) returned error %v", tt.title, err)
+ }
+
+ if !reflect.DeepEqual(value.Interface(), tt.value) {
+ t.Fatalf("ScanStruct(%s) returned %v, want %v", tt.title, value.Interface(), tt.value)
+ }
+ }
+}
+
+func TestBadScanStructArgs(t *testing.T) {
+ x := []interface{}{"A", "b"}
+ test := func(v interface{}) {
+ if err := redis.ScanStruct(x, v); err == nil {
+ t.Errorf("Expect error for ScanStruct(%T, %T)", x, v)
+ }
+ }
+
+ test(nil)
+
+ var v0 *struct{}
+ test(v0)
+
+ var v1 int
+ test(&v1)
+
+ x = x[:1]
+ v2 := struct{ A string }{}
+ test(&v2)
+}
+
+var scanSliceTests = []struct {
+ src []interface{}
+ fieldNames []string
+ ok bool
+ dest interface{}
+}{
+ {
+ []interface{}{[]byte("1"), nil, []byte("-1")},
+ nil,
+ true,
+ []int{1, 0, -1},
+ },
+ {
+ []interface{}{[]byte("1"), nil, []byte("2")},
+ nil,
+ true,
+ []uint{1, 0, 2},
+ },
+ {
+ []interface{}{[]byte("-1")},
+ nil,
+ false,
+ []uint{1},
+ },
+ {
+ []interface{}{[]byte("hello"), nil, []byte("world")},
+ nil,
+ true,
+ [][]byte{[]byte("hello"), nil, []byte("world")},
+ },
+ {
+ []interface{}{[]byte("hello"), nil, []byte("world")},
+ nil,
+ true,
+ []string{"hello", "", "world"},
+ },
+ {
+ []interface{}{[]byte("a1"), []byte("b1"), []byte("a2"), []byte("b2")},
+ nil,
+ true,
+ []struct{ A, B string }{{"a1", "b1"}, {"a2", "b2"}},
+ },
+ {
+ []interface{}{[]byte("a1"), []byte("b1")},
+ nil,
+ false,
+ []struct{ A, B, C string }{{"a1", "b1", ""}},
+ },
+ {
+ []interface{}{[]byte("a1"), []byte("b1"), []byte("a2"), []byte("b2")},
+ nil,
+ true,
+ []*struct{ A, B string }{{"a1", "b1"}, {"a2", "b2"}},
+ },
+ {
+ []interface{}{[]byte("a1"), []byte("b1"), []byte("a2"), []byte("b2")},
+ []string{"A", "B"},
+ true,
+ []struct{ A, C, B string }{{"a1", "", "b1"}, {"a2", "", "b2"}},
+ },
+ {
+ []interface{}{[]byte("a1"), []byte("b1"), []byte("a2"), []byte("b2")},
+ nil,
+ false,
+ []struct{}{},
+ },
+}
+
+func TestScanSlice(t *testing.T) {
+ for _, tt := range scanSliceTests {
+
+ typ := reflect.ValueOf(tt.dest).Type()
+ dest := reflect.New(typ)
+
+ err := redis.ScanSlice(tt.src, dest.Interface(), tt.fieldNames...)
+ if tt.ok != (err == nil) {
+ t.Errorf("ScanSlice(%v, []%s, %v) returned error %v", tt.src, typ, tt.fieldNames, err)
+ continue
+ }
+ if tt.ok && !reflect.DeepEqual(dest.Elem().Interface(), tt.dest) {
+ t.Errorf("ScanSlice(src, []%s) returned %#v, want %#v", typ, dest.Elem().Interface(), tt.dest)
+ }
+ }
+}
+
+func ExampleScanSlice() {
+ c, err := dial()
+ if err != nil {
+ panic(err)
+ }
+ defer c.Close()
+
+ c.Send("HMSET", "album:1", "title", "Red", "rating", 5)
+ c.Send("HMSET", "album:2", "title", "Earthbound", "rating", 1)
+ c.Send("HMSET", "album:3", "title", "Beat", "rating", 4)
+ c.Send("LPUSH", "albums", "1")
+ c.Send("LPUSH", "albums", "2")
+ c.Send("LPUSH", "albums", "3")
+ values, err := redis.Values(c.Do("SORT", "albums",
+ "BY", "album:*->rating",
+ "GET", "album:*->title",
+ "GET", "album:*->rating"))
+ if err != nil {
+ panic(err)
+ }
+
+ var albums []struct {
+ Title string
+ Rating int
+ }
+ if err := redis.ScanSlice(values, &albums); err != nil {
+ panic(err)
+ }
+ fmt.Printf("%v\n", albums)
+ // Output:
+ // [{Earthbound 1} {Beat 4} {Red 5}]
+}
+
+var argsTests = []struct {
+ title string
+ actual redis.Args
+ expected redis.Args
+}{
+ {"struct ptr",
+ redis.Args{}.AddFlat(&struct {
+ I int `redis:"i"`
+ U uint `redis:"u"`
+ S string `redis:"s"`
+ P []byte `redis:"p"`
+ Bt bool
+ Bf bool
+ }{
+ -1234, 5678, "hello", []byte("world"), true, false,
+ }),
+ redis.Args{"i", int(-1234), "u", uint(5678), "s", "hello", "p", []byte("world"), "Bt", true, "Bf", false},
+ },
+ {"struct",
+ redis.Args{}.AddFlat(struct{ I int }{123}),
+ redis.Args{"I", 123},
+ },
+ {"slice",
+ redis.Args{}.Add(1).AddFlat([]string{"a", "b", "c"}).Add(2),
+ redis.Args{1, "a", "b", "c", 2},
+ },
+}
+
+func TestArgs(t *testing.T) {
+ for _, tt := range argsTests {
+ if !reflect.DeepEqual(tt.actual, tt.expected) {
+ t.Fatalf("%s is %v, want %v", tt.title, tt.actual, tt.expected)
+ }
+ }
+}
+
+func ExampleArgs() {
+ c, err := dial()
+ if err != nil {
+ panic(err)
+ }
+ defer c.Close()
+
+ var p1, p2 struct {
+ Title string `redis:"title"`
+ Author string `redis:"author"`
+ Body string `redis:"body"`
+ }
+
+ p1.Title = "Example"
+ p1.Author = "Gary"
+ p1.Body = "Hello"
+
+ if _, err := c.Do("HMSET", redis.Args{}.Add("id1").AddFlat(&p1)...); err != nil {
+ panic(err)
+ }
+
+ m := map[string]string{
+ "title": "Example2",
+ "author": "Steve",
+ "body": "Map",
+ }
+
+ if _, err := c.Do("HMSET", redis.Args{}.Add("id2").AddFlat(m)...); err != nil {
+ panic(err)
+ }
+
+ for _, id := range []string{"id1", "id2"} {
+
+ v, err := redis.Values(c.Do("HGETALL", id))
+ if err != nil {
+ panic(err)
+ }
+
+ if err := redis.ScanStruct(v, &p2); err != nil {
+ panic(err)
+ }
+
+ fmt.Printf("%+v\n", p2)
+ }
+
+ // Output:
+ // {Title:Example Author:Gary Body:Hello}
+ // {Title:Example2 Author:Steve Body:Map}
+}
diff --git a/Godeps/_workspace/src/github.com/garyburd/redigo/redis/script.go b/Godeps/_workspace/src/github.com/garyburd/redigo/redis/script.go
new file mode 100644
index 0000000000000000000000000000000000000000..78605a90a83f3eb0378cb75fba1adb9482cc006b
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/garyburd/redigo/redis/script.go
@@ -0,0 +1,86 @@
+// Copyright 2012 Gary Burd
+//
+// Licensed under the Apache License, Version 2.0 (the "License"): you may
+// not use this file except in compliance with the License. You may obtain
+// a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+// License for the specific language governing permissions and limitations
+// under the License.
+
+package redis
+
+import (
+ "crypto/sha1"
+ "encoding/hex"
+ "io"
+ "strings"
+)
+
+// Script encapsulates the source, hash and key count for a Lua script. See
+// http://redis.io/commands/eval for information on scripts in Redis.
+type Script struct {
+ keyCount int
+ src string
+ hash string
+}
+
+// NewScript returns a new script object. If keyCount is greater than or equal
+// to zero, then the count is automatically inserted in the EVAL command
+// argument list. If keyCount is less than zero, then the application supplies
+// the count as the first value in the keysAndArgs argument to the Do, Send and
+// SendHash methods.
+func NewScript(keyCount int, src string) *Script {
+ h := sha1.New()
+ io.WriteString(h, src)
+ return &Script{keyCount, src, hex.EncodeToString(h.Sum(nil))}
+}
+
+func (s *Script) args(spec string, keysAndArgs []interface{}) []interface{} {
+ var args []interface{}
+ if s.keyCount < 0 {
+ args = make([]interface{}, 1+len(keysAndArgs))
+ args[0] = spec
+ copy(args[1:], keysAndArgs)
+ } else {
+ args = make([]interface{}, 2+len(keysAndArgs))
+ args[0] = spec
+ args[1] = s.keyCount
+ copy(args[2:], keysAndArgs)
+ }
+ return args
+}
+
+// Do evaluates the script. Under the covers, Do optimistically evaluates the
+// script using the EVALSHA command. If the command fails because the script is
+// not loaded, then Do evaluates the script using the EVAL command (thus
+// causing the script to load).
+func (s *Script) Do(c Conn, keysAndArgs ...interface{}) (interface{}, error) {
+ v, err := c.Do("EVALSHA", s.args(s.hash, keysAndArgs)...)
+ if e, ok := err.(Error); ok && strings.HasPrefix(string(e), "NOSCRIPT ") {
+ v, err = c.Do("EVAL", s.args(s.src, keysAndArgs)...)
+ }
+ return v, err
+}
+
+// SendHash evaluates the script without waiting for the reply. The script is
+// evaluated with the EVALSHA command. The application must ensure that the
+// script is loaded by a previous call to Send, Do or Load methods.
+func (s *Script) SendHash(c Conn, keysAndArgs ...interface{}) error {
+ return c.Send("EVALSHA", s.args(s.hash, keysAndArgs)...)
+}
+
+// Send evaluates the script without waiting for the reply.
+func (s *Script) Send(c Conn, keysAndArgs ...interface{}) error {
+ return c.Send("EVAL", s.args(s.src, keysAndArgs)...)
+}
+
+// Load loads the script without evaluating it.
+func (s *Script) Load(c Conn) error {
+ _, err := c.Do("SCRIPT", "LOAD", s.src)
+ return err
+}
diff --git a/Godeps/_workspace/src/github.com/garyburd/redigo/redis/script_test.go b/Godeps/_workspace/src/github.com/garyburd/redigo/redis/script_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..6627f4b613508673e4e28412f4991d04ef6fb880
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/garyburd/redigo/redis/script_test.go
@@ -0,0 +1,91 @@
+// Copyright 2012 Gary Burd
+//
+// Licensed under the Apache License, Version 2.0 (the "License"): you may
+// not use this file except in compliance with the License. You may obtain
+// a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+// License for the specific language governing permissions and limitations
+// under the License.
+
+package redis_test
+
+import (
+ "fmt"
+ "github.com/garyburd/redigo/redis"
+ "reflect"
+ "testing"
+ "time"
+)
+
+func ExampleScript(c redis.Conn, reply interface{}, err error) {
+ // Initialize a package-level variable with a script.
+ var getScript = redis.NewScript(1, `return redis.call('get', KEYS[1])`)
+
+ // In a function, use the script Do method to evaluate the script. The Do
+ // method optimistically uses the EVALSHA command. If the script is not
+ // loaded, then the Do method falls back to the EVAL command.
+ reply, err = getScript.Do(c, "foo")
+}
+
+func TestScript(t *testing.T) {
+ c, err := redis.DialTestDB()
+ if err != nil {
+ t.Fatalf("error connection to database, %v", err)
+ }
+ defer c.Close()
+
+ // To test fall back in Do, we make script unique by adding comment with current time.
+ script := fmt.Sprintf("--%d\nreturn {KEYS[1],KEYS[2],ARGV[1],ARGV[2]}", time.Now().UnixNano())
+ s := redis.NewScript(2, script)
+ reply := []interface{}{[]byte("key1"), []byte("key2"), []byte("arg1"), []byte("arg2")}
+
+ v, err := s.Do(c, "key1", "key2", "arg1", "arg2")
+ if err != nil {
+ t.Errorf("s.Do(c, ...) returned %v", err)
+ }
+
+ if !reflect.DeepEqual(v, reply) {
+ t.Errorf("s.Do(c, ..); = %v, want %v", v, reply)
+ }
+
+ err = s.Load(c)
+ if err != nil {
+ t.Errorf("s.Load(c) returned %v", err)
+ }
+
+ err = s.SendHash(c, "key1", "key2", "arg1", "arg2")
+ if err != nil {
+ t.Errorf("s.SendHash(c, ...) returned %v", err)
+ }
+
+ err = c.Flush()
+ if err != nil {
+ t.Errorf("c.Flush() returned %v", err)
+ }
+
+ v, err = c.Receive()
+ if !reflect.DeepEqual(v, reply) {
+ t.Errorf("s.SendHash(c, ..); c.Receive() = %v, want %v", v, reply)
+ }
+
+ err = s.Send(c, "key1", "key2", "arg1", "arg2")
+ if err != nil {
+ t.Errorf("s.Send(c, ...) returned %v", err)
+ }
+
+ err = c.Flush()
+ if err != nil {
+ t.Errorf("c.Flush() returned %v", err)
+ }
+
+ v, err = c.Receive()
+ if !reflect.DeepEqual(v, reply) {
+ t.Errorf("s.Send(c, ..); c.Receive() = %v, want %v", v, reply)
+ }
+
+}
diff --git a/Godeps/_workspace/src/github.com/garyburd/redigo/redis/test_test.go b/Godeps/_workspace/src/github.com/garyburd/redigo/redis/test_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..65258278e97d77e376d4b5502e0c069203e97833
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/garyburd/redigo/redis/test_test.go
@@ -0,0 +1,77 @@
+// Copyright 2012 Gary Burd
+//
+// Licensed under the Apache License, Version 2.0 (the "License"): you may
+// not use this file except in compliance with the License. You may obtain
+// a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+// License for the specific language governing permissions and limitations
+// under the License.
+
+package redis
+
+import (
+ "bufio"
+ "errors"
+ "net"
+ "time"
+)
+
+type testConn struct {
+ Conn
+}
+
+func (t testConn) Close() error {
+ _, err := t.Conn.Do("SELECT", "9")
+ if err != nil {
+ return nil
+ }
+ _, err = t.Conn.Do("FLUSHDB")
+ if err != nil {
+ return err
+ }
+ return t.Conn.Close()
+}
+
+// DialTestDB dials the local Redis server and selects database 9. To prevent
+// stomping on real data, DialTestDB fails if database 9 contains data. The
+// returned connection flushes database 9 on close.
+func DialTestDB() (Conn, error) {
+ c, err := DialTimeout("tcp", ":6379", 0, 1*time.Second, 1*time.Second)
+ if err != nil {
+ return nil, err
+ }
+
+ _, err = c.Do("SELECT", "9")
+ if err != nil {
+ return nil, err
+ }
+
+ n, err := Int(c.Do("DBSIZE"))
+ if err != nil {
+ return nil, err
+ }
+
+ if n != 0 {
+ return nil, errors.New("database #9 is not empty, test can not continue")
+ }
+
+ return testConn{c}, nil
+}
+
+type dummyClose struct{ net.Conn }
+
+func (dummyClose) Close() error { return nil }
+
+// NewConnBufio is a hook for tests.
+func NewConnBufio(rw bufio.ReadWriter) Conn {
+ return &conn{br: rw.Reader, bw: rw.Writer, conn: dummyClose{}}
+}
+
+var (
+ ErrNegativeInt = errNegativeInt
+)
diff --git a/Godeps/_workspace/src/github.com/garyburd/redigo/redis/zpop_example_test.go b/Godeps/_workspace/src/github.com/garyburd/redigo/redis/zpop_example_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..1d86ee6ce8c53664d5ed66274630c58205f61611
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/garyburd/redigo/redis/zpop_example_test.go
@@ -0,0 +1,113 @@
+// Copyright 2013 Gary Burd
+//
+// Licensed under the Apache License, Version 2.0 (the "License"): you may
+// not use this file except in compliance with the License. You may obtain
+// a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+// License for the specific language governing permissions and limitations
+// under the License.
+
+package redis_test
+
+import (
+ "fmt"
+ "github.com/garyburd/redigo/redis"
+)
+
+// zpop pops a value from the ZSET key using WATCH/MULTI/EXEC commands.
+func zpop(c redis.Conn, key string) (result string, err error) {
+
+ defer func() {
+ // Return connection to normal state on error.
+ if err != nil {
+ c.Do("DISCARD")
+ }
+ }()
+
+ // Loop until transaction is successful.
+ for {
+ if _, err := c.Do("WATCH", key); err != nil {
+ return "", err
+ }
+
+ members, err := redis.Strings(c.Do("ZRANGE", key, 0, 0))
+ if err != nil {
+ return "", err
+ }
+ if len(members) != 1 {
+ return "", redis.ErrNil
+ }
+
+ c.Send("MULTI")
+ c.Send("ZREM", key, members[0])
+ queued, err := c.Do("EXEC")
+ if err != nil {
+ return "", err
+ }
+
+ if queued != nil {
+ result = members[0]
+ break
+ }
+ }
+
+ return result, nil
+}
+
+// zpopScript pops a value from a ZSET.
+var zpopScript = redis.NewScript(1, `
+ local r = redis.call('ZRANGE', KEYS[1], 0, 0)
+ if r ~= nil then
+ r = r[1]
+ redis.call('ZREM', KEYS[1], r)
+ end
+ return r
+`)
+
+// This example implements ZPOP as described at
+// http://redis.io/topics/transactions using WATCH/MULTI/EXEC and scripting.
+func Example_zpop() {
+ c, err := dial()
+ if err != nil {
+ fmt.Println(err)
+ return
+ }
+ defer c.Close()
+
+ // Add test data using a pipeline.
+
+ for i, member := range []string{"red", "blue", "green"} {
+ c.Send("ZADD", "zset", i, member)
+ }
+ if _, err := c.Do(""); err != nil {
+ fmt.Println(err)
+ return
+ }
+
+ // Pop using WATCH/MULTI/EXEC
+
+ v, err := zpop(c, "zset")
+ if err != nil {
+ fmt.Println(err)
+ return
+ }
+ fmt.Println(v)
+
+ // Pop using a script.
+
+ v, err = redis.String(zpopScript.Do(c, "zset"))
+ if err != nil {
+ fmt.Println(err)
+ return
+ }
+ fmt.Println(v)
+
+ // Output:
+ // red
+ // blue
+}
diff --git a/Godeps/_workspace/src/github.com/gonuts/commander/AUTHORS b/Godeps/_workspace/src/github.com/gonuts/commander/AUTHORS
new file mode 100644
index 0000000000000000000000000000000000000000..be7ce33fc81d3420fa1ce03c2da6927d5b47a17d
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/gonuts/commander/AUTHORS
@@ -0,0 +1,11 @@
+# This is the official list of Go-Commander authors for copyright purposes.
+# This file is distinct from the CONTRIBUTORS files.
+# See the latter for an explanation.
+
+# Names should be added to this file as
+# Name or Organization <email address>
+# The email address is not required for organizations.
+
+# Please keep the list sorted.
+
+Google Inc
diff --git a/Godeps/_workspace/src/github.com/gonuts/commander/CONTRIBUTORS b/Godeps/_workspace/src/github.com/gonuts/commander/CONTRIBUTORS
new file mode 100644
index 0000000000000000000000000000000000000000..b38ea4974b536f35b2a27271a1788cda3b977cd3
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/gonuts/commander/CONTRIBUTORS
@@ -0,0 +1,31 @@
+# This is the official list of people who can contribute
+# (and typically have contributed) code to the Go-Commander repository.
+# The AUTHORS file lists the copyright holders; this file
+# lists people. For example, Google employees are listed here
+# but not in AUTHORS, because Google holds the copyright.
+#
+# The submission process automatically checks to make sure
+# that people submitting code are listed in this file (by email address).
+#
+# Names should be added to this file only after verifying that
+# the individual or the individual's organization has agreed to
+# the appropriate Contributor License Agreement, found here:
+#
+# http://code.google.com/legal/individual-cla-v1.0.html
+# http://code.google.com/legal/corporate-cla-v1.0.html
+#
+# The agreement for individuals can be filled out on the web.
+#
+# When adding J Random Contributor's name to this file,
+# either J's name or J's organization's name should be
+# added to the AUTHORS file, depending on whether the
+# individual or corporate CLA was used.
+
+# Names should be added to this file like so:
+# Name <email address>
+
+# Please keep the list sorted.
+
+Juan Batiz-Benet <juan@benet.ai>
+Sebastien Binet <seb.binet@gmail.com>
+Yves Junqueira <yves.junqueira@gmail.com>
diff --git a/Godeps/_workspace/src/github.com/gonuts/commander/LICENSE b/Godeps/_workspace/src/github.com/gonuts/commander/LICENSE
new file mode 100644
index 0000000000000000000000000000000000000000..811abfed508ef790f5c1491f1e76a2efca12cd73
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/gonuts/commander/LICENSE
@@ -0,0 +1,27 @@
+Copyright (c) 2012 The Go-Commander Authors. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+ * Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above
+copyright notice, this list of conditions and the following disclaimer
+in the documentation and/or other materials provided with the
+distribution.
+ * Neither the name of Google Inc. nor the names of its
+contributors may be used to endorse or promote products derived from
+this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/Godeps/_workspace/src/github.com/gonuts/commander/README.md b/Godeps/_workspace/src/github.com/gonuts/commander/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..5a773a8435a9d2d61cfe659a6952932b2955b7ce
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/gonuts/commander/README.md
@@ -0,0 +1,107 @@
+commander
+============
+
+[](https://drone.io/github.com/gonuts/commander/latest)
+
+``commander`` is a spin off of [golang](http://golang.org) ``go tool`` infrastructure to provide commands and sub-commands.
+
+A ``commander.Command`` has a ``Subcommands`` field holding ``[]*commander.Command`` subcommands, referenced by name from the command line.
+
+So a ``Command`` can have sub commands.
+
+So you can have, _e.g._:
+```sh
+$ mycmd action1 [options...]
+$ mycmd subcmd1 action1 [options...]
+```
+
+Example provided by:
+- [hwaf](https://github.com/hwaf/hwaf)
+- [examples/my-cmd](examples/my-cmd)
+
+## Documentation
+Is available on [godoc](http://godoc.org/github.com/gonuts/commander)
+
+## Installation
+Is performed with the usual:
+```sh
+$ go get github.com/gonuts/commander
+```
+
+## Example
+
+See the simple ``my-cmd`` example command for how this all hangs
+together [there](http://github.com/gonuts/commander/blob/master/examples/my-cmd/main.go):
+
+```sh
+$ my-cmd cmd1
+my-cmd-cmd1: hello from cmd1 (quiet=true)
+
+$ my-cmd cmd1 -q
+my-cmd-cmd1: hello from cmd1 (quiet=true)
+
+$ my-cmd cmd1 -q=0
+my-cmd-cmd1: hello from cmd1 (quiet=false)
+
+$ my-cmd cmd2
+my-cmd-cmd2: hello from cmd2 (quiet=true)
+
+$ my-cmd subcmd1 cmd1
+my-cmd-subcmd1-cmd1: hello from subcmd1-cmd1 (quiet=true)
+
+$ my-cmd subcmd1 cmd2
+my-cmd-subcmd1-cmd2: hello from subcmd1-cmd2 (quiet=true)
+
+$ my-cmd subcmd2 cmd1
+my-cmd-subcmd2-cmd1: hello from subcmd2-cmd1 (quiet=true)
+
+$ my-cmd subcmd2 cmd2
+my-cmd-subcmd2-cmd2: hello from subcmd2-cmd2 (quiet=true)
+
+$ my-cmd help
+Usage:
+
+ my-cmd command [arguments]
+
+The commands are:
+
+ cmd1 runs cmd1 and exits
+ cmd2 runs cmd2 and exits
+ subcmd1 subcmd1 subcommand. does subcmd1 thingies
+ subcmd2 subcmd2 subcommand. does subcmd2 thingies
+
+Use "my-cmd help [command]" for more information about a command.
+
+Additional help topics:
+
+
+Use "my-cmd help [topic]" for more information about that topic.
+
+
+$ my-cmd help subcmd1
+Usage:
+
+ subcmd1 command [arguments]
+
+The commands are:
+
+ cmd1 runs cmd1 and exits
+ cmd2 runs cmd2 and exits
+
+
+Use "subcmd1 help [command]" for more information about a command.
+
+Additional help topics:
+
+
+Use "subcmd1 help [topic]" for more information about that topic.
+
+```
+
+
+## TODO
+
+- automatically generate the bash/zsh/csh autocompletion lists
+- automatically generate Readme examples text
+- test cases
+
diff --git a/Godeps/_workspace/src/github.com/gonuts/commander/commands.go b/Godeps/_workspace/src/github.com/gonuts/commander/commands.go
new file mode 100644
index 0000000000000000000000000000000000000000..dabad4039c4188c0f50f71fe9f1588462473b926
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/gonuts/commander/commands.go
@@ -0,0 +1,358 @@
+// Copyright 2012 The Go-Commander Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+//
+// Based on the original work by The Go Authors:
+// Copyright 2011 The Go Authors. All rights reserved.
+
+// commander helps creating command line programs whose arguments are flags,
+// commands and subcommands.
+package commander
+
+import (
+ "bytes"
+ "fmt"
+ "io"
+ "os"
+ "os/exec"
+ "sort"
+ "strings"
+ "text/template"
+
+ "github.com/gonuts/flag"
+)
+
+// UsageSection differentiates between sections in the usage text.
+type Listing int
+
+const (
+ CommandsList = iota
+ HelpTopicsList
+ Unlisted
+)
+
+// A Command is an implementation of a subcommand.
+type Command struct {
+
+ // UsageLine is the short usage message.
+ // The first word in the line is taken to be the command name.
+ UsageLine string
+
+ // Short is the short description line shown in command lists.
+ Short string
+
+ // Long is the long description shown in the 'help <this-command>' output.
+ Long string
+
+ // List reports which list to show this command in Usage and Help.
+ // Choose between {CommandsList (default), HelpTopicsList, Unlisted}
+ List Listing
+
+ // Run runs the command.
+ // The args are the arguments after the command name.
+ Run func(cmd *Command, args []string) error
+
+ // Flag is a set of flags specific to this command.
+ Flag flag.FlagSet
+
+ // CustomFlags indicates that the command will do its own
+ // flag parsing.
+ CustomFlags bool
+
+ // Subcommands are dispatched from this command
+ Subcommands []*Command
+
+ // Parent command, nil for root.
+ Parent *Command
+
+ // UsageTemplate formats the usage (short) information displayed to the user
+ // (leave empty for default)
+ UsageTemplate string
+
+ // HelpTemplate formats the help (long) information displayed to the user
+ // (leave empty for default)
+ HelpTemplate string
+
+ // Stdout and Stderr by default are os.Stdout and os.Stderr, but you can
+ // point them at any io.Writer
+ Stdout io.Writer
+ Stderr io.Writer
+}
+
+// Name returns the command's name: the first word in the usage line.
+func (c *Command) Name() string {
+ name := c.UsageLine
+ i := strings.Index(name, " ")
+ if i >= 0 {
+ name = name[:i]
+ }
+ return name
+}
+
+// Usage prints the usage details to the standard error output.
+func (c *Command) Usage() {
+ c.usage()
+}
+
+// FlagOptions returns the flag's options as a string
+func (c *Command) FlagOptions() string {
+ var buf bytes.Buffer
+ c.Flag.SetOutput(&buf)
+ c.Flag.PrintDefaults()
+
+ str := string(buf.Bytes())
+ if len(str) > 0 {
+ return fmt.Sprintf("\nOptions:\n%s", str)
+ }
+ return ""
+}
+
+// Runnable reports whether the command can be run; otherwise
+// it is a documentation pseudo-command such as importpath.
+func (c *Command) Runnable() bool {
+ return c.Run != nil
+}
+
+// Type to allow us to use sort.Sort on a slice of Commands
+type CommandSlice []*Command
+
+func (c CommandSlice) Len() int {
+ return len(c)
+}
+
+func (c CommandSlice) Less(i, j int) bool {
+ return c[i].Name() < c[j].Name()
+}
+
+func (c CommandSlice) Swap(i, j int) {
+ c[i], c[j] = c[j], c[i]
+}
+
+// Sort the commands
+func (c *Command) SortCommands() {
+ sort.Sort(CommandSlice(c.Subcommands))
+}
+
+// Init the command
+func (c *Command) init() {
+ if c.Parent != nil {
+ return // already initialized.
+ }
+
+ // setup strings
+ if len(c.UsageLine) < 1 {
+ c.UsageLine = Defaults.UsageLine
+ }
+ if len(c.UsageTemplate) < 1 {
+ c.UsageTemplate = Defaults.UsageTemplate
+ }
+ if len(c.HelpTemplate) < 1 {
+ c.HelpTemplate = Defaults.HelpTemplate
+ }
+
+ if c.Stderr == nil {
+ c.Stderr = os.Stderr
+ }
+ if c.Stdout == nil {
+ c.Stdout = os.Stdout
+ }
+
+ // init subcommands
+ for _, cmd := range c.Subcommands {
+ cmd.init()
+ }
+
+ // init hierarchy...
+ for _, cmd := range c.Subcommands {
+ cmd.Parent = c
+ }
+}
+
+// Dispatch executes the command using the provided arguments.
+// If a subcommand exists matching the first argument, it is dispatched.
+// Otherwise, the command's Run function is called.
+func (c *Command) Dispatch(args []string) error {
+ if c == nil {
+ return fmt.Errorf("Called Run() on a nil Command")
+ }
+
+ // Ensure command is initialized.
+ c.init()
+
+ // First, try a sub-command
+ if len(args) > 0 {
+ for _, cmd := range c.Subcommands {
+ n := cmd.Name()
+ if n == args[0] {
+ return cmd.Dispatch(args[1:])
+ }
+ }
+
+ // help is builtin (but after, to allow overriding)
+ if args[0] == "help" {
+ return c.help(args[1:])
+ }
+
+ // then, try out an external binary (git-style)
+ bin, err := exec.LookPath(c.FullName() + "-" + args[0])
+ if err == nil {
+ cmd := exec.Command(bin, args[1:]...)
+ cmd.Stdin = os.Stdin
+ cmd.Stdout = c.Stdout
+ cmd.Stderr = c.Stderr
+ return cmd.Run()
+ }
+ }
+
+ // then, try running this command
+ if c.Runnable() {
+ if !c.CustomFlags {
+ var err = error(nil)
+ c.Flag.Usage = func() {
+ c.Usage()
+ err = fmt.Errorf("Failed to parse flags.")
+ }
+ c.Flag.Parse(args)
+ if err != nil {
+ return err
+ }
+ args = c.Flag.Args()
+ }
+ return c.Run(c, args)
+ }
+
+ // TODO: try an alias
+ //...
+
+ // Last, print usage
+ if err := c.usage(); err != nil {
+ return err
+ }
+ return nil
+}
+
+func (c *Command) usage() error {
+ c.SortCommands()
+ err := tmpl(c.Stderr, c.UsageTemplate, c)
+ if err != nil {
+ fmt.Println(err)
+ }
+ return err
+}
+
+// help implements the 'help' command.
+func (c *Command) help(args []string) error {
+
+ // help exactly for this command?
+ if len(args) == 0 {
+ if len(c.Long) > 0 {
+ return tmpl(c.Stdout, c.HelpTemplate, c)
+ } else {
+ return c.usage()
+ }
+ }
+
+ arg := args[0]
+
+ // is this help for a subcommand?
+ for _, cmd := range c.Subcommands {
+ n := cmd.Name()
+ // strip out "<parent>-"" name
+ if strings.HasPrefix(n, c.Name()+"-") {
+ n = n[len(c.Name()+"-"):]
+ }
+ if n == arg {
+ return cmd.help(args[1:])
+ }
+ }
+
+ return fmt.Errorf("Unknown help topic %#q. Run '%v help'.\n", arg, c.Name())
+}
+
+func (c *Command) MaxLen() (res int) {
+ res = 0
+ for _, cmd := range c.Subcommands {
+ i := len(cmd.Name())
+ if i > res {
+ res = i
+ }
+ }
+ return
+}
+
+// ColFormat returns the column header size format for printing in the template
+func (c *Command) ColFormat() string {
+ sz := c.MaxLen()
+ if sz < 11 {
+ sz = 11
+ }
+ return fmt.Sprintf("%%-%ds", sz)
+}
+
+// FullName returns the full name of the command, prefixed with parent commands
+func (c *Command) FullName() string {
+ n := c.Name()
+ if c.Parent != nil {
+ n = c.Parent.FullName() + "-" + n
+ }
+ return n
+}
+
+// FullSpacedName returns the full name of the command, with ' ' instead of '-'
+func (c *Command) FullSpacedName() string {
+ n := c.Name()
+ if c.Parent != nil {
+ n = c.Parent.FullSpacedName() + " " + n
+ }
+ return n
+}
+
+func (c *Command) SubcommandList(list Listing) []*Command {
+ var cmds []*Command
+ for _, cmd := range c.Subcommands {
+ if cmd.List == list {
+ cmds = append(cmds, cmd)
+ }
+ }
+ return cmds
+}
+
+var Defaults = Command{
+ UsageTemplate: `{{if .Runnable}}Usage: {{if .Parent}}{{.Parent.FullSpacedName}}{{end}} {{.UsageLine}}
+
+{{end}}{{.FullSpacedName}} - {{.Short}}
+
+{{if commandList}}Commands:
+{{range commandList}}
+ {{.Name | printf (colfmt)}} {{.Short}}{{end}}
+
+Use "{{.Name}} help <command>" for more information about a command.
+
+{{end}}{{.FlagOptions}}{{if helpList}}
+Additional help topics:
+{{range helpList}}
+ {{.Name | printf (colfmt)}} {{.Short}}{{end}}
+
+Use "{{.Name}} help <topic>" for more information about that topic.
+
+{{end}}`,
+
+ HelpTemplate: `{{if .Runnable}}Usage: {{if .Parent}}{{.Parent.FullSpacedName}}{{end}} {{.UsageLine}}
+
+{{end}}{{.Long | trim}}
+{{.FlagOptions}}
+`,
+}
+
+// tmpl executes the given template text on data, writing the result to w.
+func tmpl(w io.Writer, text string, data interface{}) error {
+ t := template.New("top")
+ t.Funcs(template.FuncMap{
+ "trim": strings.TrimSpace,
+ "colfmt": func() string { return data.(*Command).ColFormat() },
+ "commandList": func() []*Command { return data.(*Command).SubcommandList(CommandsList) },
+ "helpList": func() []*Command { return data.(*Command).SubcommandList(HelpTopicsList) },
+ })
+ template.Must(t.Parse(text))
+ return t.Execute(w, data)
+}
diff --git a/Godeps/_workspace/src/github.com/gonuts/commander/examples/my-cmd/cmd_cmd1.go b/Godeps/_workspace/src/github.com/gonuts/commander/examples/my-cmd/cmd_cmd1.go
new file mode 100644
index 0000000000000000000000000000000000000000..3dff0f30947e9774f5af093cc5d00eea4b1f797b
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/gonuts/commander/examples/my-cmd/cmd_cmd1.go
@@ -0,0 +1,34 @@
+package main
+
+import (
+ "fmt"
+
+ "github.com/gonuts/commander"
+ "github.com/gonuts/flag"
+)
+
+var cmd_cmd1 = &commander.Command{
+ Run: ex_run_cmd_cmd1,
+ UsageLine: "cmd1 [options]",
+ Short: "runs cmd1 and exits",
+ Long: `
+runs cmd1 and exits.
+
+ex:
+$ my-cmd cmd1
+`,
+ Flag: *flag.NewFlagSet("my-cmd-cmd1", flag.ExitOnError),
+}
+
+func init() {
+ cmd_cmd1.Flag.Bool("q", true, "only print error and warning messages, all other output will be suppressed")
+}
+
+func ex_run_cmd_cmd1(cmd *commander.Command, args []string) error {
+ name := "my-cmd-" + cmd.Name()
+ quiet := cmd.Flag.Lookup("q").Value.Get().(bool)
+ fmt.Printf("%s: hello from cmd1 (quiet=%v)\n", name, quiet)
+ return nil
+}
+
+// EOF
diff --git a/Godeps/_workspace/src/github.com/gonuts/commander/examples/my-cmd/cmd_cmd2.go b/Godeps/_workspace/src/github.com/gonuts/commander/examples/my-cmd/cmd_cmd2.go
new file mode 100644
index 0000000000000000000000000000000000000000..d63c2d263dadb0adf20559223406db196eab5180
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/gonuts/commander/examples/my-cmd/cmd_cmd2.go
@@ -0,0 +1,34 @@
+package main
+
+import (
+ "fmt"
+
+ "github.com/gonuts/commander"
+ "github.com/gonuts/flag"
+)
+
+func ex_make_cmd_cmd2() *commander.Command {
+ cmd := &commander.Command{
+ Run: ex_run_cmd_cmd2,
+ UsageLine: "cmd2 [options]",
+ Short: "runs cmd2 and exits",
+ Long: `
+runs cmd2 and exits.
+
+ex:
+ $ my-cmd cmd2
+`,
+ Flag: *flag.NewFlagSet("my-cmd-cmd2", flag.ExitOnError),
+ }
+ cmd.Flag.Bool("q", true, "only print error and warning messages, all other output will be suppressed")
+ return cmd
+}
+
+func ex_run_cmd_cmd2(cmd *commander.Command, args []string) error {
+ name := "my-cmd-" + cmd.Name()
+ quiet := cmd.Flag.Lookup("q").Value.Get().(bool)
+ fmt.Printf("%s: hello from cmd2 (quiet=%v)\n", name, quiet)
+ return nil
+}
+
+// EOF
diff --git a/Godeps/_workspace/src/github.com/gonuts/commander/examples/my-cmd/cmd_subcmd1.go b/Godeps/_workspace/src/github.com/gonuts/commander/examples/my-cmd/cmd_subcmd1.go
new file mode 100644
index 0000000000000000000000000000000000000000..87f741385f36b7f41ec604f5be99ec7a3b030efa
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/gonuts/commander/examples/my-cmd/cmd_subcmd1.go
@@ -0,0 +1,18 @@
+package main
+
+import (
+ "github.com/gonuts/commander"
+ "github.com/gonuts/flag"
+)
+
+var cmd_subcmd1 = &commander.Command{
+ UsageLine: "subcmd1 <command>",
+ Short: "subcmd1 subcommand. does subcmd1 thingies",
+ Subcommands: []*commander.Command{
+ cmd_subcmd1_cmd1,
+ cmd_subcmd1_cmd2,
+ },
+ Flag: *flag.NewFlagSet("my-cmd-subcmd1", flag.ExitOnError),
+}
+
+// EOF
diff --git a/Godeps/_workspace/src/github.com/gonuts/commander/examples/my-cmd/cmd_subcmd1_cmd1.go b/Godeps/_workspace/src/github.com/gonuts/commander/examples/my-cmd/cmd_subcmd1_cmd1.go
new file mode 100644
index 0000000000000000000000000000000000000000..f59aad66ed802b746db92ff36b2cfd932b63b528
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/gonuts/commander/examples/my-cmd/cmd_subcmd1_cmd1.go
@@ -0,0 +1,34 @@
+package main
+
+import (
+ "fmt"
+
+ "github.com/gonuts/commander"
+ "github.com/gonuts/flag"
+)
+
+var cmd_subcmd1_cmd1 = &commander.Command{
+ Run: ex_run_cmd_subcmd1_cmd1,
+ UsageLine: "cmd1 [options]",
+ Short: "runs cmd1 and exits",
+ Long: `
+runs cmd1 and exits.
+
+ex:
+$ my-cmd subcmd1 cmd1
+`,
+ Flag: *flag.NewFlagSet("my-cmd-subcmd1-cmd1", flag.ExitOnError),
+}
+
+func init() {
+ cmd_subcmd1_cmd1.Flag.Bool("q", true, "only print error and warning messages, all other output will be suppressed")
+}
+
+func ex_run_cmd_subcmd1_cmd1(cmd *commander.Command, args []string) error {
+ name := "my-cmd-subcmd1-" + cmd.Name()
+ quiet := cmd.Flag.Lookup("q").Value.Get().(bool)
+ fmt.Printf("%s: hello from subcmd1-cmd1 (quiet=%v)\n", name, quiet)
+ return nil
+}
+
+// EOF
diff --git a/Godeps/_workspace/src/github.com/gonuts/commander/examples/my-cmd/cmd_subcmd1_cmd2.go b/Godeps/_workspace/src/github.com/gonuts/commander/examples/my-cmd/cmd_subcmd1_cmd2.go
new file mode 100644
index 0000000000000000000000000000000000000000..e53134aff8a6a39c6a98bed0c93ff42e5fec0343
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/gonuts/commander/examples/my-cmd/cmd_subcmd1_cmd2.go
@@ -0,0 +1,34 @@
+package main
+
+import (
+ "fmt"
+
+ "github.com/gonuts/commander"
+ "github.com/gonuts/flag"
+)
+
+var cmd_subcmd1_cmd2 = &commander.Command{
+ Run: ex_run_cmd_subcmd1_cmd2,
+ UsageLine: "cmd2 [options]",
+ Short: "runs cmd2 and exits",
+ Long: `
+runs cmd2 and exits.
+
+ex:
+$ my-cmd subcmd1 cmd2
+`,
+ Flag: *flag.NewFlagSet("my-cmd-subcmd1-cmd2", flag.ExitOnError),
+}
+
+func init() {
+ cmd_subcmd1_cmd2.Flag.Bool("q", true, "only print error and warning messages, all other output will be suppressed")
+}
+
+func ex_run_cmd_subcmd1_cmd2(cmd *commander.Command, args []string) error {
+ name := "my-cmd-subcmd1-" + cmd.Name()
+ quiet := cmd.Flag.Lookup("q").Value.Get().(bool)
+ fmt.Printf("%s: hello from subcmd1-cmd2 (quiet=%v)\n", name, quiet)
+ return nil
+}
+
+// EOF
diff --git a/Godeps/_workspace/src/github.com/gonuts/commander/examples/my-cmd/cmd_subcmd2.go b/Godeps/_workspace/src/github.com/gonuts/commander/examples/my-cmd/cmd_subcmd2.go
new file mode 100644
index 0000000000000000000000000000000000000000..d8b42da6fbca89e839abaf6dade4599cce044d9f
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/gonuts/commander/examples/my-cmd/cmd_subcmd2.go
@@ -0,0 +1,22 @@
+package main
+
+import (
+ "github.com/gonuts/commander"
+ "github.com/gonuts/flag"
+)
+
+func ex_make_cmd_subcmd2() *commander.Command {
+ cmd := &commander.Command{
+ UsageLine: "subcmd2",
+ Short: "subcmd2 subcommand. does subcmd2 thingies (help list)",
+ List: commander.HelpTopicsList,
+ Subcommands: []*commander.Command{
+ ex_make_cmd_subcmd2_cmd1(),
+ ex_make_cmd_subcmd2_cmd2(),
+ },
+ Flag: *flag.NewFlagSet("my-cmd-subcmd2", flag.ExitOnError),
+ }
+ return cmd
+}
+
+// EOF
diff --git a/Godeps/_workspace/src/github.com/gonuts/commander/examples/my-cmd/cmd_subcmd2_cmd1.go b/Godeps/_workspace/src/github.com/gonuts/commander/examples/my-cmd/cmd_subcmd2_cmd1.go
new file mode 100644
index 0000000000000000000000000000000000000000..e882e09d8baeba6aa2319e1796b5c36cd2082d59
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/gonuts/commander/examples/my-cmd/cmd_subcmd2_cmd1.go
@@ -0,0 +1,34 @@
+package main
+
+import (
+ "fmt"
+
+ "github.com/gonuts/commander"
+ "github.com/gonuts/flag"
+)
+
+func ex_make_cmd_subcmd2_cmd1() *commander.Command {
+ cmd := &commander.Command{
+ Run: ex_run_cmd_subcmd2_cmd1,
+ UsageLine: "cmd1 [options]",
+ Short: "runs cmd1 and exits",
+ Long: `
+runs cmd1 and exits.
+
+ex:
+ $ my-cmd subcmd2 cmd1
+`,
+ Flag: *flag.NewFlagSet("my-cmd-subcmd2-cmd1", flag.ExitOnError),
+ }
+ cmd.Flag.Bool("q", true, "only print error and warning messages, all other output will be suppressed")
+ return cmd
+}
+
+func ex_run_cmd_subcmd2_cmd1(cmd *commander.Command, args []string) error {
+ name := "my-cmd-subcmd2-" + cmd.Name()
+ quiet := cmd.Flag.Lookup("q").Value.Get().(bool)
+ fmt.Printf("%s: hello from subcmd2-cmd1 (quiet=%v)\n", name, quiet)
+ return nil
+}
+
+// EOF
diff --git a/Godeps/_workspace/src/github.com/gonuts/commander/examples/my-cmd/cmd_subcmd2_cmd2.go b/Godeps/_workspace/src/github.com/gonuts/commander/examples/my-cmd/cmd_subcmd2_cmd2.go
new file mode 100644
index 0000000000000000000000000000000000000000..aa0fc8cfc545511ac0e110f6e913a73dcd4ace78
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/gonuts/commander/examples/my-cmd/cmd_subcmd2_cmd2.go
@@ -0,0 +1,34 @@
+package main
+
+import (
+ "fmt"
+
+ "github.com/gonuts/commander"
+ "github.com/gonuts/flag"
+)
+
+func ex_make_cmd_subcmd2_cmd2() *commander.Command {
+ cmd := &commander.Command{
+ Run: ex_run_cmd_subcmd2_cmd2,
+ UsageLine: "cmd2 [options]",
+ Short: "runs cmd2 and exits",
+ Long: `
+runs cmd2 and exits.
+
+ex:
+ $ my-cmd subcmd2 cmd2
+`,
+ Flag: *flag.NewFlagSet("my-cmd-subcmd2-cmd2", flag.ExitOnError),
+ }
+ cmd.Flag.Bool("q", true, "only print error and warning messages, all other output will be suppressed")
+ return cmd
+}
+
+func ex_run_cmd_subcmd2_cmd2(cmd *commander.Command, args []string) error {
+ name := "my-cmd-subcmd2-" + cmd.Name()
+ quiet := cmd.Flag.Lookup("q").Value.Get().(bool)
+ fmt.Printf("%s: hello from subcmd2-cmd2 (quiet=%v)\n", name, quiet)
+ return nil
+}
+
+// EOF
diff --git a/Godeps/_workspace/src/github.com/gonuts/commander/examples/my-cmd/main.go b/Godeps/_workspace/src/github.com/gonuts/commander/examples/my-cmd/main.go
new file mode 100644
index 0000000000000000000000000000000000000000..3a16f609f4324e523f8b9716d735a674fc1cc269
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/gonuts/commander/examples/my-cmd/main.go
@@ -0,0 +1,33 @@
+package main
+
+import (
+ "fmt"
+ "os"
+
+ "github.com/gonuts/commander"
+)
+
+var g_cmd = &commander.Command{
+ UsageLine: os.Args[0] + " does cool things",
+}
+
+func init() {
+ g_cmd.Subcommands = []*commander.Command{
+ cmd_cmd1,
+ ex_make_cmd_cmd2(),
+ cmd_subcmd1,
+ ex_make_cmd_subcmd2(),
+ }
+}
+
+func main() {
+ err := g_cmd.Dispatch(os.Args[1:])
+ if err != nil {
+ fmt.Printf("%v\n", err)
+ os.Exit(1)
+ }
+
+ return
+}
+
+// EOF
diff --git a/Godeps/_workspace/src/github.com/gonuts/flag/LICENSE b/Godeps/_workspace/src/github.com/gonuts/flag/LICENSE
new file mode 100644
index 0000000000000000000000000000000000000000..74487567632c8f137ef3971b0f5912ca50bebcda
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/gonuts/flag/LICENSE
@@ -0,0 +1,27 @@
+Copyright (c) 2012 The Go Authors. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+ * Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above
+copyright notice, this list of conditions and the following disclaimer
+in the documentation and/or other materials provided with the
+distribution.
+ * Neither the name of Google Inc. nor the names of its
+contributors may be used to endorse or promote products derived from
+this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/Godeps/_workspace/src/github.com/gonuts/flag/README.md b/Godeps/_workspace/src/github.com/gonuts/flag/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..06b7a02be7d941c511d7f04bfe6c08741141f812
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/gonuts/flag/README.md
@@ -0,0 +1,6 @@
+flag
+=======
+
+[](https://drone.io/github.com/gonuts/flag/latest)
+
+A fork of the official "flag" package but with the flag.Value interface extended to provide a ``Get() interface{}`` method.
diff --git a/Godeps/_workspace/src/github.com/gonuts/flag/example_test.go b/Godeps/_workspace/src/github.com/gonuts/flag/example_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..04a0d20ee4ed827f668bcd05df477a21f8371016
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/gonuts/flag/example_test.go
@@ -0,0 +1,83 @@
+// Copyright 2012 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.
+
+// These examples demonstrate more intricate uses of the flag package.
+package flag_test
+
+import (
+ "errors"
+ "flag"
+ "fmt"
+ "strings"
+ "time"
+)
+
+// Example 1: A single string flag called "species" with default value "gopher".
+var species = flag.String("species", "gopher", "the species we are studying")
+
+// Example 2: Two flags sharing a variable, so we can have a shorthand.
+// The order of initialization is undefined, so make sure both use the
+// same default value. They must be set up with an init function.
+var gopherType string
+
+func init() {
+ const (
+ defaultGopher = "pocket"
+ usage = "the variety of gopher"
+ )
+ flag.StringVar(&gopherType, "gopher_type", defaultGopher, usage)
+ flag.StringVar(&gopherType, "g", defaultGopher, usage+" (shorthand)")
+}
+
+// Example 3: A user-defined flag type, a slice of durations.
+type interval []time.Duration
+
+// String is the method to format the flag's value, part of the flag.Value interface.
+// The String method's output will be used in diagnostics.
+func (i *interval) String() string {
+ return fmt.Sprint(*i)
+}
+
+// Set is the method to set the flag value, part of the flag.Value interface.
+// Set's argument is a string to be parsed to set the flag.
+// It's a comma-separated list, so we split it.
+func (i *interval) Set(value string) error {
+ // If we wanted to allow the flag to be set multiple times,
+ // accumulating values, we would delete this if statement.
+ // That would permit usages such as
+ // -deltaT 10s -deltaT 15s
+ // and other combinations.
+ if len(*i) > 0 {
+ return errors.New("interval flag already set")
+ }
+ for _, dt := range strings.Split(value, ",") {
+ duration, err := time.ParseDuration(dt)
+ if err != nil {
+ return err
+ }
+ *i = append(*i, duration)
+ }
+ return nil
+}
+
+// Define a flag to accumulate durations. Because it has a special type,
+// we need to use the Var function and therefore create the flag during
+// init.
+
+var intervalFlag interval
+
+func init() {
+ // Tie the command-line flag to the intervalFlag variable and
+ // set a usage message.
+ flag.Var(&intervalFlag, "deltaT", "comma-separated list of intervals to use between events")
+}
+
+func Example() {
+ // All the interesting pieces are with the variables declared above, but
+ // to enable the flag package to see the flags defined there, one must
+ // execute, typically at the start of main (not init!):
+ // flag.Parse()
+ // We don't run it here because this is not a main function and
+ // the testing suite has already parsed the flags.
+}
diff --git a/Godeps/_workspace/src/github.com/gonuts/flag/export_test.go b/Godeps/_workspace/src/github.com/gonuts/flag/export_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..7b190807a8a5253e489284d519daf929ad8f7e13
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/gonuts/flag/export_test.go
@@ -0,0 +1,22 @@
+// Copyright 2010 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.
+
+package flag
+
+import "os"
+
+// Additional routines compiled into the package only during testing.
+
+// ResetForTesting clears all flag state and sets the usage function as directed.
+// After calling ResetForTesting, parse errors in flag handling will not
+// exit the program.
+func ResetForTesting(usage func()) {
+ commandLine = NewFlagSet(os.Args[0], ContinueOnError)
+ Usage = usage
+}
+
+// CommandLine returns the default FlagSet.
+func CommandLine() *FlagSet {
+ return commandLine
+}
diff --git a/Godeps/_workspace/src/github.com/gonuts/flag/flag.go b/Godeps/_workspace/src/github.com/gonuts/flag/flag.go
new file mode 100644
index 0000000000000000000000000000000000000000..1e939e9efa11d662b04f6edaf856ee921eb7cf9f
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/gonuts/flag/flag.go
@@ -0,0 +1,816 @@
+// 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.
+
+/*
+ Package flag implements command-line flag parsing.
+
+ Usage:
+
+ Define flags using flag.String(), Bool(), Int(), etc.
+
+ This declares an integer flag, -flagname, stored in the pointer ip, with type *int.
+ import "flag"
+ var ip = flag.Int("flagname", 1234, "help message for flagname")
+ If you like, you can bind the flag to a variable using the Var() functions.
+ var flagvar int
+ func init() {
+ flag.IntVar(&flagvar, "flagname", 1234, "help message for flagname")
+ }
+ Or you can create custom flags that satisfy the Value interface (with
+ pointer receivers) and couple them to flag parsing by
+ flag.Var(&flagVal, "name", "help message for flagname")
+ For such flags, the default value is just the initial value of the variable.
+
+ After all flags are defined, call
+ flag.Parse()
+ to parse the command line into the defined flags.
+
+ Flags may then be used directly. If you're using the flags themselves,
+ they are all pointers; if you bind to variables, they're values.
+ fmt.Println("ip has value ", *ip)
+ fmt.Println("flagvar has value ", flagvar)
+
+ After parsing, the arguments after the flag are available as the
+ slice flag.Args() or individually as flag.Arg(i).
+ The arguments are indexed from 0 up to flag.NArg().
+
+ Command line flag syntax:
+ -flag
+ -flag=x
+ -flag x // non-boolean flags only
+ One or two minus signs may be used; they are equivalent.
+ The last form is not permitted for boolean flags because the
+ meaning of the command
+ cmd -x *
+ will change if there is a file called 0, false, etc. You must
+ use the -flag=false form to turn off a boolean flag.
+
+ Flag parsing stops just before the first non-flag argument
+ ("-" is a non-flag argument) or after the terminator "--".
+
+ Integer flags accept 1234, 0664, 0x1234 and may be negative.
+ Boolean flags may be 1, 0, t, f, true, false, TRUE, FALSE, True, False.
+ Duration flags accept any input valid for time.ParseDuration.
+
+ The default set of command-line flags is controlled by
+ top-level functions. The FlagSet type allows one to define
+ independent sets of flags, such as to implement subcommands
+ in a command-line interface. The methods of FlagSet are
+ analogous to the top-level functions for the command-line
+ flag set.
+*/
+package flag
+
+import (
+ "errors"
+ "fmt"
+ "io"
+ "os"
+ "sort"
+ "strconv"
+ "time"
+)
+
+// ErrHelp is the error returned if the flag -help is invoked but no such flag is defined.
+var ErrHelp = errors.New("flag: help requested")
+
+// -- bool Value
+type boolValue bool
+
+func newBoolValue(val bool, p *bool) *boolValue {
+ *p = val
+ return (*boolValue)(p)
+}
+
+func (b *boolValue) Set(s string) error {
+ v, err := strconv.ParseBool(s)
+ *b = boolValue(v)
+ return err
+}
+
+func (b *boolValue) Get() interface{} { return bool(*b) }
+
+func (b *boolValue) String() string { return fmt.Sprintf("%v", *b) }
+
+// -- int Value
+type intValue int
+
+func newIntValue(val int, p *int) *intValue {
+ *p = val
+ return (*intValue)(p)
+}
+
+func (i *intValue) Set(s string) error {
+ v, err := strconv.ParseInt(s, 0, 64)
+ *i = intValue(v)
+ return err
+}
+
+func (i *intValue) Get() interface{} { return int(*i) }
+
+func (i *intValue) String() string { return fmt.Sprintf("%v", *i) }
+
+// -- int64 Value
+type int64Value int64
+
+func newInt64Value(val int64, p *int64) *int64Value {
+ *p = val
+ return (*int64Value)(p)
+}
+
+func (i *int64Value) Set(s string) error {
+ v, err := strconv.ParseInt(s, 0, 64)
+ *i = int64Value(v)
+ return err
+}
+
+func (i *int64Value) Get() interface{} { return int64(*i) }
+
+func (i *int64Value) String() string { return fmt.Sprintf("%v", *i) }
+
+// -- uint Value
+type uintValue uint
+
+func newUintValue(val uint, p *uint) *uintValue {
+ *p = val
+ return (*uintValue)(p)
+}
+
+func (i *uintValue) Set(s string) error {
+ v, err := strconv.ParseUint(s, 0, 64)
+ *i = uintValue(v)
+ return err
+}
+
+func (i *uintValue) Get() interface{} { return uint(*i) }
+
+func (i *uintValue) String() string { return fmt.Sprintf("%v", *i) }
+
+// -- uint64 Value
+type uint64Value uint64
+
+func newUint64Value(val uint64, p *uint64) *uint64Value {
+ *p = val
+ return (*uint64Value)(p)
+}
+
+func (i *uint64Value) Set(s string) error {
+ v, err := strconv.ParseUint(s, 0, 64)
+ *i = uint64Value(v)
+ return err
+}
+
+func (i *uint64Value) Get() interface{} { return uint64(*i) }
+
+func (i *uint64Value) String() string { return fmt.Sprintf("%v", *i) }
+
+// -- string Value
+type stringValue string
+
+func newStringValue(val string, p *string) *stringValue {
+ *p = val
+ return (*stringValue)(p)
+}
+
+func (s *stringValue) Set(val string) error {
+ *s = stringValue(val)
+ return nil
+}
+
+func (s *stringValue) Get() interface{} { return s.String() }
+
+func (s *stringValue) String() string { return fmt.Sprintf("%s", *s) }
+
+// -- float64 Value
+type float64Value float64
+
+func newFloat64Value(val float64, p *float64) *float64Value {
+ *p = val
+ return (*float64Value)(p)
+}
+
+func (f *float64Value) Set(s string) error {
+ v, err := strconv.ParseFloat(s, 64)
+ *f = float64Value(v)
+ return err
+}
+
+func (f *float64Value) Get() interface{} { return float64(*f) }
+
+func (f *float64Value) String() string { return fmt.Sprintf("%v", *f) }
+
+// -- time.Duration Value
+type durationValue time.Duration
+
+func newDurationValue(val time.Duration, p *time.Duration) *durationValue {
+ *p = val
+ return (*durationValue)(p)
+}
+
+func (d *durationValue) Set(s string) error {
+ v, err := time.ParseDuration(s)
+ *d = durationValue(v)
+ return err
+}
+
+func (d *durationValue) Get() interface{} { return *(*time.Duration)(d) }
+
+func (d *durationValue) String() string { return (*time.Duration)(d).String() }
+
+// Value is the interface to the dynamic value stored in a flag.
+// (The default value is represented as a string.)
+type Value interface {
+ String() string
+ Set(string) error
+ Get() interface{}
+}
+
+// ErrorHandling defines how to handle flag parsing errors.
+type ErrorHandling int
+
+const (
+ ContinueOnError ErrorHandling = iota
+ ExitOnError
+ PanicOnError
+)
+
+// A FlagSet represents a set of defined flags.
+type FlagSet struct {
+ // Usage is the function called when an error occurs while parsing flags.
+ // The field is a function (not a method) that may be changed to point to
+ // a custom error handler.
+ Usage func()
+
+ name string
+ parsed bool
+ actual map[string]*Flag
+ formal map[string]*Flag
+ args []string // arguments after flags
+ exitOnError bool // does the program exit if there's an error?
+ errorHandling ErrorHandling
+ output io.Writer // nil means stderr; use out() accessor
+}
+
+// A Flag represents the state of a flag.
+type Flag struct {
+ Name string // name as it appears on command line
+ Usage string // help message
+ Value Value // value as set
+ DefValue string // default value (as text); for usage message
+}
+
+// sortFlags returns the flags as a slice in lexicographical sorted order.
+func sortFlags(flags map[string]*Flag) []*Flag {
+ list := make(sort.StringSlice, len(flags))
+ i := 0
+ for _, f := range flags {
+ list[i] = f.Name
+ i++
+ }
+ list.Sort()
+ result := make([]*Flag, len(list))
+ for i, name := range list {
+ result[i] = flags[name]
+ }
+ return result
+}
+
+func (f *FlagSet) out() io.Writer {
+ if f.output == nil {
+ return os.Stderr
+ }
+ return f.output
+}
+
+// SetOutput sets the destination for usage and error messages.
+// If output is nil, os.Stderr is used.
+func (f *FlagSet) SetOutput(output io.Writer) {
+ f.output = output
+}
+
+// VisitAll visits the flags in lexicographical order, calling fn for each.
+// It visits all flags, even those not set.
+func (f *FlagSet) VisitAll(fn func(*Flag)) {
+ for _, flag := range sortFlags(f.formal) {
+ fn(flag)
+ }
+}
+
+// VisitAll visits the command-line flags in lexicographical order, calling
+// fn for each. It visits all flags, even those not set.
+func VisitAll(fn func(*Flag)) {
+ commandLine.VisitAll(fn)
+}
+
+// Visit visits the flags in lexicographical order, calling fn for each.
+// It visits only those flags that have been set.
+func (f *FlagSet) Visit(fn func(*Flag)) {
+ for _, flag := range sortFlags(f.actual) {
+ fn(flag)
+ }
+}
+
+// Visit visits the command-line flags in lexicographical order, calling fn
+// for each. It visits only those flags that have been set.
+func Visit(fn func(*Flag)) {
+ commandLine.Visit(fn)
+}
+
+// Lookup returns the Flag structure of the named flag, returning nil if none exists.
+func (f *FlagSet) Lookup(name string) *Flag {
+ return f.formal[name]
+}
+
+// Lookup returns the Flag structure of the named command-line flag,
+// returning nil if none exists.
+func Lookup(name string) *Flag {
+ return commandLine.formal[name]
+}
+
+// Set sets the value of the named flag.
+func (f *FlagSet) Set(name, value string) error {
+ flag, ok := f.formal[name]
+ if !ok {
+ return fmt.Errorf("no such flag -%v", name)
+ }
+ err := flag.Value.Set(value)
+ if err != nil {
+ return err
+ }
+ if f.actual == nil {
+ f.actual = make(map[string]*Flag)
+ }
+ f.actual[name] = flag
+ return nil
+}
+
+// Set sets the value of the named command-line flag.
+func Set(name, value string) error {
+ return commandLine.Set(name, value)
+}
+
+// PrintDefaults prints, to standard error unless configured
+// otherwise, the default values of all defined flags in the set.
+func (f *FlagSet) PrintDefaults() {
+ f.VisitAll(func(flag *Flag) {
+ format := " -%s=%s: %s\n"
+ if _, ok := flag.Value.(*stringValue); ok {
+ // put quotes on the value
+ format = " -%s=%q: %s\n"
+ }
+ fmt.Fprintf(f.out(), format, flag.Name, flag.DefValue, flag.Usage)
+ })
+}
+
+// PrintDefaults prints to standard error the default values of all defined command-line flags.
+func PrintDefaults() {
+ commandLine.PrintDefaults()
+}
+
+// defaultUsage is the default function to print a usage message.
+func defaultUsage(f *FlagSet) {
+ fmt.Fprintf(f.out(), "Usage of %s:\n", f.name)
+ f.PrintDefaults()
+}
+
+// NOTE: Usage is not just defaultUsage(commandLine)
+// because it serves (via godoc flag Usage) as the example
+// for how to write your own usage function.
+
+// Usage prints to standard error a usage message documenting all defined command-line flags.
+// The function is a variable that may be changed to point to a custom function.
+var Usage = func() {
+ fmt.Fprintf(os.Stderr, "Usage of %s:\n", os.Args[0])
+ PrintDefaults()
+}
+
+// NFlag returns the number of flags that have been set.
+func (f *FlagSet) NFlag() int { return len(f.actual) }
+
+// NFlag returns the number of command-line flags that have been set.
+func NFlag() int { return len(commandLine.actual) }
+
+// Arg returns the i'th argument. Arg(0) is the first remaining argument
+// after flags have been processed.
+func (f *FlagSet) Arg(i int) string {
+ if i < 0 || i >= len(f.args) {
+ return ""
+ }
+ return f.args[i]
+}
+
+// Arg returns the i'th command-line argument. Arg(0) is the first remaining argument
+// after flags have been processed.
+func Arg(i int) string {
+ return commandLine.Arg(i)
+}
+
+// NArg is the number of arguments remaining after flags have been processed.
+func (f *FlagSet) NArg() int { return len(f.args) }
+
+// NArg is the number of arguments remaining after flags have been processed.
+func NArg() int { return len(commandLine.args) }
+
+// Args returns the non-flag arguments.
+func (f *FlagSet) Args() []string { return f.args }
+
+// Args returns the non-flag command-line arguments.
+func Args() []string { return commandLine.args }
+
+// BoolVar defines a bool flag with specified name, default value, and usage string.
+// The argument p points to a bool variable in which to store the value of the flag.
+func (f *FlagSet) BoolVar(p *bool, name string, value bool, usage string) {
+ f.Var(newBoolValue(value, p), name, usage)
+}
+
+// BoolVar defines a bool flag with specified name, default value, and usage string.
+// The argument p points to a bool variable in which to store the value of the flag.
+func BoolVar(p *bool, name string, value bool, usage string) {
+ commandLine.Var(newBoolValue(value, p), name, usage)
+}
+
+// Bool defines a bool flag with specified name, default value, and usage string.
+// The return value is the address of a bool variable that stores the value of the flag.
+func (f *FlagSet) Bool(name string, value bool, usage string) *bool {
+ p := new(bool)
+ f.BoolVar(p, name, value, usage)
+ return p
+}
+
+// Bool defines a bool flag with specified name, default value, and usage string.
+// The return value is the address of a bool variable that stores the value of the flag.
+func Bool(name string, value bool, usage string) *bool {
+ return commandLine.Bool(name, value, usage)
+}
+
+// IntVar defines an int flag with specified name, default value, and usage string.
+// The argument p points to an int variable in which to store the value of the flag.
+func (f *FlagSet) IntVar(p *int, name string, value int, usage string) {
+ f.Var(newIntValue(value, p), name, usage)
+}
+
+// IntVar defines an int flag with specified name, default value, and usage string.
+// The argument p points to an int variable in which to store the value of the flag.
+func IntVar(p *int, name string, value int, usage string) {
+ commandLine.Var(newIntValue(value, p), name, usage)
+}
+
+// Int defines an int flag with specified name, default value, and usage string.
+// The return value is the address of an int variable that stores the value of the flag.
+func (f *FlagSet) Int(name string, value int, usage string) *int {
+ p := new(int)
+ f.IntVar(p, name, value, usage)
+ return p
+}
+
+// Int defines an int flag with specified name, default value, and usage string.
+// The return value is the address of an int variable that stores the value of the flag.
+func Int(name string, value int, usage string) *int {
+ return commandLine.Int(name, value, usage)
+}
+
+// Int64Var defines an int64 flag with specified name, default value, and usage string.
+// The argument p points to an int64 variable in which to store the value of the flag.
+func (f *FlagSet) Int64Var(p *int64, name string, value int64, usage string) {
+ f.Var(newInt64Value(value, p), name, usage)
+}
+
+// Int64Var defines an int64 flag with specified name, default value, and usage string.
+// The argument p points to an int64 variable in which to store the value of the flag.
+func Int64Var(p *int64, name string, value int64, usage string) {
+ commandLine.Var(newInt64Value(value, p), name, usage)
+}
+
+// Int64 defines an int64 flag with specified name, default value, and usage string.
+// The return value is the address of an int64 variable that stores the value of the flag.
+func (f *FlagSet) Int64(name string, value int64, usage string) *int64 {
+ p := new(int64)
+ f.Int64Var(p, name, value, usage)
+ return p
+}
+
+// Int64 defines an int64 flag with specified name, default value, and usage string.
+// The return value is the address of an int64 variable that stores the value of the flag.
+func Int64(name string, value int64, usage string) *int64 {
+ return commandLine.Int64(name, value, usage)
+}
+
+// UintVar defines a uint flag with specified name, default value, and usage string.
+// The argument p points to a uint variable in which to store the value of the flag.
+func (f *FlagSet) UintVar(p *uint, name string, value uint, usage string) {
+ f.Var(newUintValue(value, p), name, usage)
+}
+
+// UintVar defines a uint flag with specified name, default value, and usage string.
+// The argument p points to a uint variable in which to store the value of the flag.
+func UintVar(p *uint, name string, value uint, usage string) {
+ commandLine.Var(newUintValue(value, p), name, usage)
+}
+
+// Uint defines a uint flag with specified name, default value, and usage string.
+// The return value is the address of a uint variable that stores the value of the flag.
+func (f *FlagSet) Uint(name string, value uint, usage string) *uint {
+ p := new(uint)
+ f.UintVar(p, name, value, usage)
+ return p
+}
+
+// Uint defines a uint flag with specified name, default value, and usage string.
+// The return value is the address of a uint variable that stores the value of the flag.
+func Uint(name string, value uint, usage string) *uint {
+ return commandLine.Uint(name, value, usage)
+}
+
+// Uint64Var defines a uint64 flag with specified name, default value, and usage string.
+// The argument p points to a uint64 variable in which to store the value of the flag.
+func (f *FlagSet) Uint64Var(p *uint64, name string, value uint64, usage string) {
+ f.Var(newUint64Value(value, p), name, usage)
+}
+
+// Uint64Var defines a uint64 flag with specified name, default value, and usage string.
+// The argument p points to a uint64 variable in which to store the value of the flag.
+func Uint64Var(p *uint64, name string, value uint64, usage string) {
+ commandLine.Var(newUint64Value(value, p), name, usage)
+}
+
+// Uint64 defines a uint64 flag with specified name, default value, and usage string.
+// The return value is the address of a uint64 variable that stores the value of the flag.
+func (f *FlagSet) Uint64(name string, value uint64, usage string) *uint64 {
+ p := new(uint64)
+ f.Uint64Var(p, name, value, usage)
+ return p
+}
+
+// Uint64 defines a uint64 flag with specified name, default value, and usage string.
+// The return value is the address of a uint64 variable that stores the value of the flag.
+func Uint64(name string, value uint64, usage string) *uint64 {
+ return commandLine.Uint64(name, value, usage)
+}
+
+// StringVar defines a string flag with specified name, default value, and usage string.
+// The argument p points to a string variable in which to store the value of the flag.
+func (f *FlagSet) StringVar(p *string, name string, value string, usage string) {
+ f.Var(newStringValue(value, p), name, usage)
+}
+
+// StringVar defines a string flag with specified name, default value, and usage string.
+// The argument p points to a string variable in which to store the value of the flag.
+func StringVar(p *string, name string, value string, usage string) {
+ commandLine.Var(newStringValue(value, p), name, usage)
+}
+
+// String defines a string flag with specified name, default value, and usage string.
+// The return value is the address of a string variable that stores the value of the flag.
+func (f *FlagSet) String(name string, value string, usage string) *string {
+ p := new(string)
+ f.StringVar(p, name, value, usage)
+ return p
+}
+
+// String defines a string flag with specified name, default value, and usage string.
+// The return value is the address of a string variable that stores the value of the flag.
+func String(name string, value string, usage string) *string {
+ return commandLine.String(name, value, usage)
+}
+
+// Float64Var defines a float64 flag with specified name, default value, and usage string.
+// The argument p points to a float64 variable in which to store the value of the flag.
+func (f *FlagSet) Float64Var(p *float64, name string, value float64, usage string) {
+ f.Var(newFloat64Value(value, p), name, usage)
+}
+
+// Float64Var defines a float64 flag with specified name, default value, and usage string.
+// The argument p points to a float64 variable in which to store the value of the flag.
+func Float64Var(p *float64, name string, value float64, usage string) {
+ commandLine.Var(newFloat64Value(value, p), name, usage)
+}
+
+// Float64 defines a float64 flag with specified name, default value, and usage string.
+// The return value is the address of a float64 variable that stores the value of the flag.
+func (f *FlagSet) Float64(name string, value float64, usage string) *float64 {
+ p := new(float64)
+ f.Float64Var(p, name, value, usage)
+ return p
+}
+
+// Float64 defines a float64 flag with specified name, default value, and usage string.
+// The return value is the address of a float64 variable that stores the value of the flag.
+func Float64(name string, value float64, usage string) *float64 {
+ return commandLine.Float64(name, value, usage)
+}
+
+// DurationVar defines a time.Duration flag with specified name, default value, and usage string.
+// The argument p points to a time.Duration variable in which to store the value of the flag.
+func (f *FlagSet) DurationVar(p *time.Duration, name string, value time.Duration, usage string) {
+ f.Var(newDurationValue(value, p), name, usage)
+}
+
+// DurationVar defines a time.Duration flag with specified name, default value, and usage string.
+// The argument p points to a time.Duration variable in which to store the value of the flag.
+func DurationVar(p *time.Duration, name string, value time.Duration, usage string) {
+ commandLine.Var(newDurationValue(value, p), name, usage)
+}
+
+// Duration defines a time.Duration flag with specified name, default value, and usage string.
+// The return value is the address of a time.Duration variable that stores the value of the flag.
+func (f *FlagSet) Duration(name string, value time.Duration, usage string) *time.Duration {
+ p := new(time.Duration)
+ f.DurationVar(p, name, value, usage)
+ return p
+}
+
+// Duration defines a time.Duration flag with specified name, default value, and usage string.
+// The return value is the address of a time.Duration variable that stores the value of the flag.
+func Duration(name string, value time.Duration, usage string) *time.Duration {
+ return commandLine.Duration(name, value, usage)
+}
+
+// Var defines a flag with the specified name and usage string. The type and
+// value of the flag are represented by the first argument, of type Value, which
+// typically holds a user-defined implementation of Value. For instance, the
+// caller could create a flag that turns a comma-separated string into a slice
+// of strings by giving the slice the methods of Value; in particular, Set would
+// decompose the comma-separated string into the slice.
+func (f *FlagSet) Var(value Value, name string, usage string) {
+ // Remember the default value as a string; it won't change.
+ flag := &Flag{name, usage, value, value.String()}
+ _, alreadythere := f.formal[name]
+ if alreadythere {
+ msg := fmt.Sprintf("%s flag redefined: %s", f.name, name)
+ fmt.Fprintln(f.out(), msg)
+ panic(msg) // Happens only if flags are declared with identical names
+ }
+ if f.formal == nil {
+ f.formal = make(map[string]*Flag)
+ }
+ f.formal[name] = flag
+}
+
+// Var defines a flag with the specified name and usage string. The type and
+// value of the flag are represented by the first argument, of type Value, which
+// typically holds a user-defined implementation of Value. For instance, the
+// caller could create a flag that turns a comma-separated string into a slice
+// of strings by giving the slice the methods of Value; in particular, Set would
+// decompose the comma-separated string into the slice.
+func Var(value Value, name string, usage string) {
+ commandLine.Var(value, name, usage)
+}
+
+// failf prints to standard error a formatted error and usage message and
+// returns the error.
+func (f *FlagSet) failf(format string, a ...interface{}) error {
+ err := fmt.Errorf(format, a...)
+ fmt.Fprintln(f.out(), err)
+ f.usage()
+ return err
+}
+
+// usage calls the Usage method for the flag set, or the usage function if
+// the flag set is commandLine.
+func (f *FlagSet) usage() {
+ if f == commandLine {
+ Usage()
+ } else if f.Usage == nil {
+ defaultUsage(f)
+ } else {
+ f.Usage()
+ }
+}
+
+// parseOne parses one flag. It returns whether a flag was seen.
+func (f *FlagSet) parseOne() (bool, error) {
+ if len(f.args) == 0 {
+ return false, nil
+ }
+ s := f.args[0]
+ if len(s) == 0 || s[0] != '-' || len(s) == 1 {
+ return false, nil
+ }
+ num_minuses := 1
+ if s[1] == '-' {
+ num_minuses++
+ if len(s) == 2 { // "--" terminates the flags
+ f.args = f.args[1:]
+ return false, nil
+ }
+ }
+ name := s[num_minuses:]
+ if len(name) == 0 || name[0] == '-' || name[0] == '=' {
+ return false, f.failf("bad flag syntax: %s", s)
+ }
+
+ // it's a flag. does it have an argument?
+ f.args = f.args[1:]
+ has_value := false
+ value := ""
+ for i := 1; i < len(name); i++ { // equals cannot be first
+ if name[i] == '=' {
+ value = name[i+1:]
+ has_value = true
+ name = name[0:i]
+ break
+ }
+ }
+ m := f.formal
+ flag, alreadythere := m[name] // BUG
+ if !alreadythere {
+ if name == "help" || name == "h" { // special case for nice help message.
+ f.usage()
+ return false, ErrHelp
+ }
+ return false, f.failf("flag provided but not defined: -%s", name)
+ }
+ if fv, ok := flag.Value.(*boolValue); ok { // special case: doesn't need an arg
+ if has_value {
+ if err := fv.Set(value); err != nil {
+ f.failf("invalid boolean value %q for -%s: %v", value, name, err)
+ }
+ } else {
+ fv.Set("true")
+ }
+ } else {
+ // It must have a value, which might be the next argument.
+ if !has_value && len(f.args) > 0 {
+ // value is the next arg
+ has_value = true
+ value, f.args = f.args[0], f.args[1:]
+ }
+ if !has_value {
+ return false, f.failf("flag needs an argument: -%s", name)
+ }
+ if err := flag.Value.Set(value); err != nil {
+ return false, f.failf("invalid value %q for flag -%s: %v", value, name, err)
+ }
+ }
+ if f.actual == nil {
+ f.actual = make(map[string]*Flag)
+ }
+ f.actual[name] = flag
+ return true, nil
+}
+
+// Parse parses flag definitions from the argument list, which should not
+// include the command name. Must be called after all flags in the FlagSet
+// are defined and before flags are accessed by the program.
+// The return value will be ErrHelp if -help was set but not defined.
+func (f *FlagSet) Parse(arguments []string) error {
+ f.parsed = true
+ f.args = arguments
+ for {
+ seen, err := f.parseOne()
+ if seen {
+ continue
+ }
+ if err == nil {
+ break
+ }
+ switch f.errorHandling {
+ case ContinueOnError:
+ return err
+ case ExitOnError:
+ os.Exit(2)
+ case PanicOnError:
+ panic(err)
+ }
+ }
+ return nil
+}
+
+// Parsed reports whether f.Parse has been called.
+func (f *FlagSet) Parsed() bool {
+ return f.parsed
+}
+
+// Parse parses the command-line flags from os.Args[1:]. Must be called
+// after all flags are defined and before flags are accessed by the program.
+func Parse() {
+ // Ignore errors; commandLine is set for ExitOnError.
+ commandLine.Parse(os.Args[1:])
+}
+
+// Parsed returns true if the command-line flags have been parsed.
+func Parsed() bool {
+ return commandLine.Parsed()
+}
+
+// The default set of command-line flags, parsed from os.Args.
+var commandLine = NewFlagSet(os.Args[0], ExitOnError)
+
+// NewFlagSet returns a new, empty flag set with the specified name and
+// error handling property.
+func NewFlagSet(name string, errorHandling ErrorHandling) *FlagSet {
+ f := &FlagSet{
+ name: name,
+ errorHandling: errorHandling,
+ }
+ return f
+}
+
+// Init sets the name and error handling property for a flag set.
+// By default, the zero FlagSet uses an empty name and the
+// ContinueOnError error handling policy.
+func (f *FlagSet) Init(name string, errorHandling ErrorHandling) {
+ f.name = name
+ f.errorHandling = errorHandling
+}
diff --git a/Godeps/_workspace/src/github.com/gonuts/flag/flag_test.go b/Godeps/_workspace/src/github.com/gonuts/flag/flag_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..d3aa24156d457fc1839239e5de8234f751b5a405
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/gonuts/flag/flag_test.go
@@ -0,0 +1,288 @@
+// 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.
+
+package flag_test
+
+import (
+ "bytes"
+ "fmt"
+ "os"
+ "sort"
+ "strings"
+ "testing"
+ "time"
+
+ . "github.com/gonuts/flag"
+)
+
+var (
+ test_bool = Bool("test_bool", false, "bool value")
+ test_int = Int("test_int", 0, "int value")
+ test_int64 = Int64("test_int64", 0, "int64 value")
+ test_uint = Uint("test_uint", 0, "uint value")
+ test_uint64 = Uint64("test_uint64", 0, "uint64 value")
+ test_string = String("test_string", "0", "string value")
+ test_float64 = Float64("test_float64", 0, "float64 value")
+ test_duration = Duration("test_duration", 0, "time.Duration value")
+)
+
+func boolString(s string) string {
+ if s == "0" {
+ return "false"
+ }
+ return "true"
+}
+
+func TestEverything(t *testing.T) {
+ m := make(map[string]*Flag)
+ desired := "0"
+ visitor := func(f *Flag) {
+ if len(f.Name) > 5 && f.Name[0:5] == "test_" {
+ m[f.Name] = f
+ ok := false
+ switch {
+ case f.Value.String() == desired:
+ ok = true
+ case f.Name == "test_bool" && f.Value.String() == boolString(desired):
+ ok = true
+ case f.Name == "test_duration" && f.Value.String() == desired+"s":
+ ok = true
+ }
+ if !ok {
+ t.Error("Visit: bad value", f.Value.String(), "for", f.Name)
+ }
+ }
+ }
+ VisitAll(visitor)
+ if len(m) != 8 {
+ t.Error("VisitAll misses some flags")
+ for k, v := range m {
+ t.Log(k, *v)
+ }
+ }
+ m = make(map[string]*Flag)
+ Visit(visitor)
+ if len(m) != 0 {
+ t.Errorf("Visit sees unset flags")
+ for k, v := range m {
+ t.Log(k, *v)
+ }
+ }
+ // Now set all flags
+ Set("test_bool", "true")
+ Set("test_int", "1")
+ Set("test_int64", "1")
+ Set("test_uint", "1")
+ Set("test_uint64", "1")
+ Set("test_string", "1")
+ Set("test_float64", "1")
+ Set("test_duration", "1s")
+ desired = "1"
+ Visit(visitor)
+ if len(m) != 8 {
+ t.Error("Visit fails after set")
+ for k, v := range m {
+ t.Log(k, *v)
+ }
+ }
+ // Now test they're visited in sort order.
+ var flagNames []string
+ Visit(func(f *Flag) { flagNames = append(flagNames, f.Name) })
+ if !sort.StringsAreSorted(flagNames) {
+ t.Errorf("flag names not sorted: %v", flagNames)
+ }
+}
+
+func TestUsage(t *testing.T) {
+ called := false
+ ResetForTesting(func() { called = true })
+ if CommandLine().Parse([]string{"-x"}) == nil {
+ t.Error("parse did not fail for unknown flag")
+ }
+ if !called {
+ t.Error("did not call Usage for unknown flag")
+ }
+}
+
+func testParse(f *FlagSet, t *testing.T) {
+ if f.Parsed() {
+ t.Error("f.Parse() = true before Parse")
+ }
+ boolFlag := f.Bool("bool", false, "bool value")
+ bool2Flag := f.Bool("bool2", false, "bool2 value")
+ intFlag := f.Int("int", 0, "int value")
+ int64Flag := f.Int64("int64", 0, "int64 value")
+ uintFlag := f.Uint("uint", 0, "uint value")
+ uint64Flag := f.Uint64("uint64", 0, "uint64 value")
+ stringFlag := f.String("string", "0", "string value")
+ float64Flag := f.Float64("float64", 0, "float64 value")
+ durationFlag := f.Duration("duration", 5*time.Second, "time.Duration value")
+ extra := "one-extra-argument"
+ args := []string{
+ "-bool",
+ "-bool2=true",
+ "--int", "22",
+ "--int64", "0x23",
+ "-uint", "24",
+ "--uint64", "25",
+ "-string", "hello",
+ "-float64", "2718e28",
+ "-duration", "2m",
+ extra,
+ }
+ if err := f.Parse(args); err != nil {
+ t.Fatal(err)
+ }
+ if !f.Parsed() {
+ t.Error("f.Parse() = false after Parse")
+ }
+ if *boolFlag != true {
+ t.Error("bool flag should be true, is ", *boolFlag)
+ }
+ if *bool2Flag != true {
+ t.Error("bool2 flag should be true, is ", *bool2Flag)
+ }
+ if *intFlag != 22 {
+ t.Error("int flag should be 22, is ", *intFlag)
+ }
+ if *int64Flag != 0x23 {
+ t.Error("int64 flag should be 0x23, is ", *int64Flag)
+ }
+ if *uintFlag != 24 {
+ t.Error("uint flag should be 24, is ", *uintFlag)
+ }
+ if *uint64Flag != 25 {
+ t.Error("uint64 flag should be 25, is ", *uint64Flag)
+ }
+ if *stringFlag != "hello" {
+ t.Error("string flag should be `hello`, is ", *stringFlag)
+ }
+ if *float64Flag != 2718e28 {
+ t.Error("float64 flag should be 2718e28, is ", *float64Flag)
+ }
+ if *durationFlag != 2*time.Minute {
+ t.Error("duration flag should be 2m, is ", *durationFlag)
+ }
+ if len(f.Args()) != 1 {
+ t.Error("expected one argument, got", len(f.Args()))
+ } else if f.Args()[0] != extra {
+ t.Errorf("expected argument %q got %q", extra, f.Args()[0])
+ }
+}
+
+func TestParse(t *testing.T) {
+ ResetForTesting(func() { t.Error("bad parse") })
+ testParse(CommandLine(), t)
+}
+
+func TestFlagSetParse(t *testing.T) {
+ testParse(NewFlagSet("test", ContinueOnError), t)
+}
+
+// Declare a user-defined flag type.
+type flagVar []string
+
+func (f *flagVar) String() string {
+ return fmt.Sprint([]string(*f))
+}
+
+func (f *flagVar) Set(value string) error {
+ *f = append(*f, value)
+ return nil
+}
+
+func (f *flagVar) Get() interface{} { return []string(*f) }
+
+func TestUserDefined(t *testing.T) {
+ var flags FlagSet
+ flags.Init("test", ContinueOnError)
+ var v flagVar
+ flags.Var(&v, "v", "usage")
+ if err := flags.Parse([]string{"-v", "1", "-v", "2", "-v=3"}); err != nil {
+ t.Error(err)
+ }
+ if len(v) != 3 {
+ t.Fatal("expected 3 args; got ", len(v))
+ }
+ expect := "[1 2 3]"
+ if v.String() != expect {
+ t.Errorf("expected value %q got %q", expect, v.String())
+ }
+}
+
+func TestSetOutput(t *testing.T) {
+ var flags FlagSet
+ var buf bytes.Buffer
+ flags.SetOutput(&buf)
+ flags.Init("test", ContinueOnError)
+ flags.Parse([]string{"-unknown"})
+ if out := buf.String(); !strings.Contains(out, "-unknown") {
+ t.Logf("expected output mentioning unknown; got %q", out)
+ }
+}
+
+// This tests that one can reset the flags. This still works but not well, and is
+// superseded by FlagSet.
+func TestChangingArgs(t *testing.T) {
+ ResetForTesting(func() { t.Fatal("bad parse") })
+ oldArgs := os.Args
+ defer func() { os.Args = oldArgs }()
+ os.Args = []string{"cmd", "-before", "subcmd", "-after", "args"}
+ before := Bool("before", false, "")
+ if err := CommandLine().Parse(os.Args[1:]); err != nil {
+ t.Fatal(err)
+ }
+ cmd := Arg(0)
+ os.Args = Args()
+ after := Bool("after", false, "")
+ Parse()
+ args := Args()
+
+ if !*before || cmd != "subcmd" || !*after || len(args) != 1 || args[0] != "args" {
+ t.Fatalf("expected true subcmd true [args] got %v %v %v %v", *before, cmd, *after, args)
+ }
+}
+
+// Test that -help invokes the usage message and returns ErrHelp.
+func TestHelp(t *testing.T) {
+ var helpCalled = false
+ fs := NewFlagSet("help test", ContinueOnError)
+ fs.Usage = func() { helpCalled = true }
+ var flag bool
+ fs.BoolVar(&flag, "flag", false, "regular flag")
+ // Regular flag invocation should work
+ err := fs.Parse([]string{"-flag=true"})
+ if err != nil {
+ t.Fatal("expected no error; got ", err)
+ }
+ if !flag {
+ t.Error("flag was not set by -flag")
+ }
+ if helpCalled {
+ t.Error("help called for regular flag")
+ helpCalled = false // reset for next test
+ }
+ // Help flag should work as expected.
+ err = fs.Parse([]string{"-help"})
+ if err == nil {
+ t.Fatal("error expected")
+ }
+ if err != ErrHelp {
+ t.Fatal("expected ErrHelp; got ", err)
+ }
+ if !helpCalled {
+ t.Fatal("help was not called")
+ }
+ // If we define a help flag, that should override.
+ var help bool
+ fs.BoolVar(&help, "help", false, "help flag")
+ helpCalled = false
+ err = fs.Parse([]string{"-help"})
+ if err != nil {
+ t.Fatal("expected no error for defined -help; got ", err)
+ }
+ if helpCalled {
+ t.Fatal("help was called; should not have been for defined help flag")
+ }
+}
diff --git a/Godeps/_workspace/src/github.com/gorilla/securecookie/.travis.yml b/Godeps/_workspace/src/github.com/gorilla/securecookie/.travis.yml
new file mode 100644
index 0000000000000000000000000000000000000000..d87d4657686743eff53951131c0831d9aaac0ab3
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/gorilla/securecookie/.travis.yml
@@ -0,0 +1,7 @@
+language: go
+
+go:
+ - 1.0
+ - 1.1
+ - 1.2
+ - tip
diff --git a/Godeps/_workspace/src/github.com/gorilla/securecookie/LICENSE b/Godeps/_workspace/src/github.com/gorilla/securecookie/LICENSE
new file mode 100644
index 0000000000000000000000000000000000000000..0e5fb872800da9557f75a5650bb9d80c1c2cf715
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/gorilla/securecookie/LICENSE
@@ -0,0 +1,27 @@
+Copyright (c) 2012 Rodrigo Moraes. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+ * Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above
+copyright notice, this list of conditions and the following disclaimer
+in the documentation and/or other materials provided with the
+distribution.
+ * Neither the name of Google Inc. nor the names of its
+contributors may be used to endorse or promote products derived from
+this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/Godeps/_workspace/src/github.com/gorilla/securecookie/README.md b/Godeps/_workspace/src/github.com/gorilla/securecookie/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..2f0d5d48c25fee562cff4e9aca96b8412635da36
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/gorilla/securecookie/README.md
@@ -0,0 +1,3 @@
+securecookie
+============
+[](https://travis-ci.org/gorilla/securecookie)
diff --git a/Godeps/_workspace/src/github.com/gorilla/securecookie/doc.go b/Godeps/_workspace/src/github.com/gorilla/securecookie/doc.go
new file mode 100644
index 0000000000000000000000000000000000000000..e80e3aed2e2e2a9a68be16c22976dce837b0edc2
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/gorilla/securecookie/doc.go
@@ -0,0 +1,61 @@
+// Copyright 2012 The Gorilla Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+/*
+Package gorilla/securecookie encodes and decodes authenticated and optionally
+encrypted cookie values.
+
+Secure cookies can't be forged, because their values are validated using HMAC.
+When encrypted, the content is also inaccessible to malicious eyes.
+
+To use it, first create a new SecureCookie instance:
+
+ var hashKey = []byte("very-secret")
+ var blockKey = []byte("a-lot-secret")
+ var s = securecookie.New(hashKey, blockKey)
+
+The hashKey is required, used to authenticate the cookie value using HMAC.
+It is recommended to use a key with 32 or 64 bytes.
+
+The blockKey is optional, used to encrypt the cookie value -- set it to nil
+to not use encryption. If set, the length must correspond to the block size
+of the encryption algorithm. For AES, used by default, valid lengths are
+16, 24, or 32 bytes to select AES-128, AES-192, or AES-256.
+
+Strong keys can be created using the convenience function GenerateRandomKey().
+
+Once a SecureCookie instance is set, use it to encode a cookie value:
+
+ func SetCookieHandler(w http.ResponseWriter, r *http.Request) {
+ value := map[string]string{
+ "foo": "bar",
+ }
+ if encoded, err := s.Encode("cookie-name", value); err == nil {
+ cookie := &http.Cookie{
+ Name: "cookie-name",
+ Value: encoded,
+ Path: "/",
+ }
+ http.SetCookie(w, cookie)
+ }
+ }
+
+Later, use the same SecureCookie instance to decode and validate a cookie
+value:
+
+ func ReadCookieHandler(w http.ResponseWriter, r *http.Request) {
+ if cookie, err := r.Cookie("cookie-name"); err == nil {
+ value := make(map[string]string)
+ if err = s2.Decode("cookie-name", cookie.Value, &value); err == nil {
+ fmt.Fprintf(w, "The value of foo is %q", value["foo"])
+ }
+ }
+ }
+
+We stored a map[string]string, but secure cookies can hold any value that
+can be encoded using encoding/gob. To store custom types, they must be
+registered first using gob.Register(). For basic types this is not needed;
+it works out of the box.
+*/
+package securecookie
diff --git a/Godeps/_workspace/src/github.com/gorilla/securecookie/securecookie.go b/Godeps/_workspace/src/github.com/gorilla/securecookie/securecookie.go
new file mode 100644
index 0000000000000000000000000000000000000000..74b8acc5c43cf95a6ba23590598872bd7b3360ab
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/gorilla/securecookie/securecookie.go
@@ -0,0 +1,429 @@
+// Copyright 2012 The Gorilla Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package securecookie
+
+import (
+ "bytes"
+ "crypto/aes"
+ "crypto/cipher"
+ "crypto/hmac"
+ "crypto/rand"
+ "crypto/sha256"
+ "crypto/subtle"
+ "encoding/base64"
+ "encoding/gob"
+ "errors"
+ "fmt"
+ "hash"
+ "io"
+ "strconv"
+ "time"
+)
+
+var (
+ errNoCodecs = errors.New("securecookie: no codecs provided")
+ errHashKeyNotSet = errors.New("securecookie: hash key is not set")
+
+ ErrMacInvalid = errors.New("securecookie: the value is not valid")
+)
+
+// Codec defines an interface to encode and decode cookie values.
+type Codec interface {
+ Encode(name string, value interface{}) (string, error)
+ Decode(name, value string, dst interface{}) error
+}
+
+// New returns a new SecureCookie.
+//
+// hashKey is required, used to authenticate values using HMAC. Create it using
+// GenerateRandomKey(). It is recommended to use a key with 32 or 64 bytes.
+//
+// blockKey is optional, used to encrypt values. Create it using
+// GenerateRandomKey(). The key length must correspond to the block size
+// of the encryption algorithm. For AES, used by default, valid lengths are
+// 16, 24, or 32 bytes to select AES-128, AES-192, or AES-256.
+func New(hashKey, blockKey []byte) *SecureCookie {
+ s := &SecureCookie{
+ hashKey: hashKey,
+ blockKey: blockKey,
+ hashFunc: sha256.New,
+ maxAge: 86400 * 30,
+ maxLength: 4096,
+ }
+ if hashKey == nil {
+ s.err = errHashKeyNotSet
+ }
+ if blockKey != nil {
+ s.BlockFunc(aes.NewCipher)
+ }
+ return s
+}
+
+// SecureCookie encodes and decodes authenticated and optionally encrypted
+// cookie values.
+type SecureCookie struct {
+ hashKey []byte
+ hashFunc func() hash.Hash
+ blockKey []byte
+ block cipher.Block
+ maxLength int
+ maxAge int64
+ minAge int64
+ err error
+ // For testing purposes, the function that returns the current timestamp.
+ // If not set, it will use time.Now().UTC().Unix().
+ timeFunc func() int64
+}
+
+// MaxLength restricts the maximum length, in bytes, for the cookie value.
+//
+// Default is 4096, which is the maximum value accepted by Internet Explorer.
+func (s *SecureCookie) MaxLength(value int) *SecureCookie {
+ s.maxLength = value
+ return s
+}
+
+// MaxAge restricts the maximum age, in seconds, for the cookie value.
+//
+// Default is 86400 * 30. Set it to 0 for no restriction.
+func (s *SecureCookie) MaxAge(value int) *SecureCookie {
+ s.maxAge = int64(value)
+ return s
+}
+
+// MinAge restricts the minimum age, in seconds, for the cookie value.
+//
+// Default is 0 (no restriction).
+func (s *SecureCookie) MinAge(value int) *SecureCookie {
+ s.minAge = int64(value)
+ return s
+}
+
+// HashFunc sets the hash function used to create HMAC.
+//
+// Default is crypto/sha256.New.
+func (s *SecureCookie) HashFunc(f func() hash.Hash) *SecureCookie {
+ s.hashFunc = f
+ return s
+}
+
+// BlockFunc sets the encryption function used to create a cipher.Block.
+//
+// Default is crypto/aes.New.
+func (s *SecureCookie) BlockFunc(f func([]byte) (cipher.Block, error)) *SecureCookie {
+ if s.blockKey == nil {
+ s.err = errors.New("securecookie: block key is not set")
+ } else if block, err := f(s.blockKey); err == nil {
+ s.block = block
+ } else {
+ s.err = err
+ }
+ return s
+}
+
+// Encode encodes a cookie value.
+//
+// It serializes, optionally encrypts, signs with a message authentication code, and
+// finally encodes the value.
+//
+// The name argument is the cookie name. It is stored with the encoded value.
+// The value argument is the value to be encoded. It can be any value that can
+// be encoded using encoding/gob. To store special structures, they must be
+// registered first using gob.Register().
+func (s *SecureCookie) Encode(name string, value interface{}) (string, error) {
+ if s.err != nil {
+ return "", s.err
+ }
+ if s.hashKey == nil {
+ s.err = errHashKeyNotSet
+ return "", s.err
+ }
+ var err error
+ var b []byte
+ // 1. Serialize.
+ if b, err = serialize(value); err != nil {
+ return "", err
+ }
+ // 2. Encrypt (optional).
+ if s.block != nil {
+ if b, err = encrypt(s.block, b); err != nil {
+ return "", err
+ }
+ }
+ b = encode(b)
+ // 3. Create MAC for "name|date|value". Extra pipe to be used later.
+ b = []byte(fmt.Sprintf("%s|%d|%s|", name, s.timestamp(), b))
+ mac := createMac(hmac.New(s.hashFunc, s.hashKey), b[:len(b)-1])
+ // Append mac, remove name.
+ b = append(b, mac...)[len(name)+1:]
+ // 4. Encode to base64.
+ b = encode(b)
+ // 5. Check length.
+ if s.maxLength != 0 && len(b) > s.maxLength {
+ return "", errors.New("securecookie: the value is too long")
+ }
+ // Done.
+ return string(b), nil
+}
+
+// Decode decodes a cookie value.
+//
+// It decodes, verifies a message authentication code, optionally decrypts and
+// finally deserializes the value.
+//
+// The name argument is the cookie name. It must be the same name used when
+// it was stored. The value argument is the encoded cookie value. The dst
+// argument is where the cookie will be decoded. It must be a pointer.
+func (s *SecureCookie) Decode(name, value string, dst interface{}) error {
+ if s.err != nil {
+ return s.err
+ }
+ if s.hashKey == nil {
+ s.err = errHashKeyNotSet
+ return s.err
+ }
+ // 1. Check length.
+ if s.maxLength != 0 && len(value) > s.maxLength {
+ return errors.New("securecookie: the value is too long")
+ }
+ // 2. Decode from base64.
+ b, err := decode([]byte(value))
+ if err != nil {
+ return err
+ }
+ // 3. Verify MAC. Value is "date|value|mac".
+ parts := bytes.SplitN(b, []byte("|"), 3)
+ if len(parts) != 3 {
+ return errors.New("securecookie: invalid value %v")
+ }
+ h := hmac.New(s.hashFunc, s.hashKey)
+ b = append([]byte(name+"|"), b[:len(b)-len(parts[2])-1]...)
+ if err = verifyMac(h, b, parts[2]); err != nil {
+ return err
+ }
+ // 4. Verify date ranges.
+ var t1 int64
+ if t1, err = strconv.ParseInt(string(parts[0]), 10, 64); err != nil {
+ return errors.New("securecookie: invalid timestamp")
+ }
+ t2 := s.timestamp()
+ if s.minAge != 0 && t1 > t2-s.minAge {
+ return errors.New("securecookie: timestamp is too new")
+ }
+ if s.maxAge != 0 && t1 < t2-s.maxAge {
+ return errors.New("securecookie: expired timestamp")
+ }
+ // 5. Decrypt (optional).
+ b, err = decode(parts[1])
+ if err != nil {
+ return err
+ }
+ if s.block != nil {
+ if b, err = decrypt(s.block, b); err != nil {
+ return err
+ }
+ }
+ // 6. Deserialize.
+ if err = deserialize(b, dst); err != nil {
+ return err
+ }
+ // Done.
+ return nil
+}
+
+// timestamp returns the current timestamp, in seconds.
+//
+// For testing purposes, the function that generates the timestamp can be
+// overridden. If not set, it will return time.Now().UTC().Unix().
+func (s *SecureCookie) timestamp() int64 {
+ if s.timeFunc == nil {
+ return time.Now().UTC().Unix()
+ }
+ return s.timeFunc()
+}
+
+// Authentication -------------------------------------------------------------
+
+// createMac creates a message authentication code (MAC).
+func createMac(h hash.Hash, value []byte) []byte {
+ h.Write(value)
+ return h.Sum(nil)
+}
+
+// verifyMac verifies that a message authentication code (MAC) is valid.
+func verifyMac(h hash.Hash, value []byte, mac []byte) error {
+ mac2 := createMac(h, value)
+ if len(mac) == len(mac2) && subtle.ConstantTimeCompare(mac, mac2) == 1 {
+ return nil
+ }
+ return ErrMacInvalid
+}
+
+// Encryption -----------------------------------------------------------------
+
+// encrypt encrypts a value using the given block in counter mode.
+//
+// A random initialization vector (http://goo.gl/zF67k) with the length of the
+// block size is prepended to the resulting ciphertext.
+func encrypt(block cipher.Block, value []byte) ([]byte, error) {
+ iv := GenerateRandomKey(block.BlockSize())
+ if iv == nil {
+ return nil, errors.New("securecookie: failed to generate random iv")
+ }
+ // Encrypt it.
+ stream := cipher.NewCTR(block, iv)
+ stream.XORKeyStream(value, value)
+ // Return iv + ciphertext.
+ return append(iv, value...), nil
+}
+
+// decrypt decrypts a value using the given block in counter mode.
+//
+// The value to be decrypted must be prepended by a initialization vector
+// (http://goo.gl/zF67k) with the length of the block size.
+func decrypt(block cipher.Block, value []byte) ([]byte, error) {
+ size := block.BlockSize()
+ if len(value) > size {
+ // Extract iv.
+ iv := value[:size]
+ // Extract ciphertext.
+ value = value[size:]
+ // Decrypt it.
+ stream := cipher.NewCTR(block, iv)
+ stream.XORKeyStream(value, value)
+ return value, nil
+ }
+ return nil, errors.New("securecookie: the value could not be decrypted")
+}
+
+// Serialization --------------------------------------------------------------
+
+// serialize encodes a value using gob.
+func serialize(src interface{}) ([]byte, error) {
+ buf := new(bytes.Buffer)
+ enc := gob.NewEncoder(buf)
+ if err := enc.Encode(src); err != nil {
+ return nil, err
+ }
+ return buf.Bytes(), nil
+}
+
+// deserialize decodes a value using gob.
+func deserialize(src []byte, dst interface{}) error {
+ dec := gob.NewDecoder(bytes.NewBuffer(src))
+ if err := dec.Decode(dst); err != nil {
+ return err
+ }
+ return nil
+}
+
+// Encoding -------------------------------------------------------------------
+
+// encode encodes a value using base64.
+func encode(value []byte) []byte {
+ encoded := make([]byte, base64.URLEncoding.EncodedLen(len(value)))
+ base64.URLEncoding.Encode(encoded, value)
+ return encoded
+}
+
+// decode decodes a cookie using base64.
+func decode(value []byte) ([]byte, error) {
+ decoded := make([]byte, base64.URLEncoding.DecodedLen(len(value)))
+ b, err := base64.URLEncoding.Decode(decoded, value)
+ if err != nil {
+ return nil, err
+ }
+ return decoded[:b], nil
+}
+
+// Helpers --------------------------------------------------------------------
+
+// GenerateRandomKey creates a random key with the given strength.
+func GenerateRandomKey(strength int) []byte {
+ k := make([]byte, strength)
+ if _, err := io.ReadFull(rand.Reader, k); err != nil {
+ return nil
+ }
+ return k
+}
+
+// CodecsFromPairs returns a slice of SecureCookie instances.
+//
+// It is a convenience function to create a list of codecs for key rotation.
+func CodecsFromPairs(keyPairs ...[]byte) []Codec {
+ codecs := make([]Codec, len(keyPairs)/2+len(keyPairs)%2)
+ for i := 0; i < len(keyPairs); i += 2 {
+ var blockKey []byte
+ if i+1 < len(keyPairs) {
+ blockKey = keyPairs[i+1]
+ }
+ codecs[i/2] = New(keyPairs[i], blockKey)
+ }
+ return codecs
+}
+
+// EncodeMulti encodes a cookie value using a group of codecs.
+//
+// The codecs are tried in order. Multiple codecs are accepted to allow
+// key rotation.
+func EncodeMulti(name string, value interface{}, codecs ...Codec) (string, error) {
+ if len(codecs) == 0 {
+ return "", errNoCodecs
+ }
+
+ var errors MultiError
+ for _, codec := range codecs {
+ if encoded, err := codec.Encode(name, value); err == nil {
+ return encoded, nil
+ } else {
+ errors = append(errors, err)
+ }
+ }
+ return "", errors
+}
+
+// DecodeMulti decodes a cookie value using a group of codecs.
+//
+// The codecs are tried in order. Multiple codecs are accepted to allow
+// key rotation.
+func DecodeMulti(name string, value string, dst interface{}, codecs ...Codec) error {
+ if len(codecs) == 0 {
+ return errNoCodecs
+ }
+
+ var errors MultiError
+ for _, codec := range codecs {
+ if err := codec.Decode(name, value, dst); err == nil {
+ return nil
+ } else {
+ errors = append(errors, err)
+ }
+ }
+ return errors
+}
+
+// MultiError groups multiple errors.
+type MultiError []error
+
+func (m MultiError) Error() string {
+ s, n := "", 0
+ for _, e := range m {
+ if e != nil {
+ if n == 0 {
+ s = e.Error()
+ }
+ n++
+ }
+ }
+ switch n {
+ case 0:
+ return "(0 errors)"
+ case 1:
+ return s
+ case 2:
+ return s + " (and 1 other error)"
+ }
+ return fmt.Sprintf("%s (and %d other errors)", s, n-1)
+}
diff --git a/Godeps/_workspace/src/github.com/gorilla/securecookie/securecookie_test.go b/Godeps/_workspace/src/github.com/gorilla/securecookie/securecookie_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..fe0cdb109858cbdca39f36baf249d65afa22ed38
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/gorilla/securecookie/securecookie_test.go
@@ -0,0 +1,178 @@
+// Copyright 2012 The Gorilla Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package securecookie
+
+import (
+ "crypto/aes"
+ "crypto/hmac"
+ "crypto/sha256"
+ "errors"
+ "fmt"
+ "strings"
+ "testing"
+)
+
+var testCookies = []interface{}{
+ map[string]string{"foo": "bar"},
+ map[string]string{"baz": "ding"},
+}
+
+var testStrings = []string{"foo", "bar", "baz"}
+
+func TestSecureCookie(t *testing.T) {
+ // TODO test too old / too new timestamps
+ compareMaps := func(m1, m2 map[string]interface{}) error {
+ if len(m1) != len(m2) {
+ return errors.New("different maps")
+ }
+ for k, v := range m1 {
+ if m2[k] != v {
+ return fmt.Errorf("Different value for key %v: expected %v, got %v", k, m2[k], v)
+ }
+ }
+ return nil
+ }
+
+ s1 := New([]byte("12345"), []byte("1234567890123456"))
+ s2 := New([]byte("54321"), []byte("6543210987654321"))
+ value := map[string]interface{}{
+ "foo": "bar",
+ "baz": 128,
+ }
+
+ for i := 0; i < 50; i++ {
+ // Running this multiple times to check if any special character
+ // breaks encoding/decoding.
+ encoded, err1 := s1.Encode("sid", value)
+ if err1 != nil {
+ t.Error(err1)
+ continue
+ }
+ dst := make(map[string]interface{})
+ err2 := s1.Decode("sid", encoded, &dst)
+ if err2 != nil {
+ t.Fatalf("%v: %v", err2, encoded)
+ }
+ if err := compareMaps(dst, value); err != nil {
+ t.Fatalf("Expected %v, got %v.", value, dst)
+ }
+ dst2 := make(map[string]interface{})
+ err3 := s2.Decode("sid", encoded, &dst2)
+ if err3 == nil {
+ t.Fatalf("Expected failure decoding.")
+ }
+ }
+}
+
+func TestAuthentication(t *testing.T) {
+ hash := hmac.New(sha256.New, []byte("secret-key"))
+ for _, value := range testStrings {
+ hash.Reset()
+ signed := createMac(hash, []byte(value))
+ hash.Reset()
+ err := verifyMac(hash, []byte(value), signed)
+ if err != nil {
+ t.Error(err)
+ }
+ }
+}
+
+func TestEncription(t *testing.T) {
+ block, err := aes.NewCipher([]byte("1234567890123456"))
+ if err != nil {
+ t.Fatalf("Block could not be created")
+ }
+ var encrypted, decrypted []byte
+ for _, value := range testStrings {
+ if encrypted, err = encrypt(block, []byte(value)); err != nil {
+ t.Error(err)
+ } else {
+ if decrypted, err = decrypt(block, encrypted); err != nil {
+ t.Error(err)
+ }
+ if string(decrypted) != value {
+ t.Errorf("Expected %v, got %v.", value, string(decrypted))
+ }
+ }
+ }
+}
+
+func TestSerialization(t *testing.T) {
+ var (
+ serialized []byte
+ deserialized map[string]string
+ err error
+ )
+ for _, value := range testCookies {
+ if serialized, err = serialize(value); err != nil {
+ t.Error(err)
+ } else {
+ deserialized = make(map[string]string)
+ if err = deserialize(serialized, &deserialized); err != nil {
+ t.Error(err)
+ }
+ if fmt.Sprintf("%v", deserialized) != fmt.Sprintf("%v", value) {
+ t.Errorf("Expected %v, got %v.", value, deserialized)
+ }
+ }
+ }
+}
+
+func TestEncoding(t *testing.T) {
+ for _, value := range testStrings {
+ encoded := encode([]byte(value))
+ decoded, err := decode(encoded)
+ if err != nil {
+ t.Error(err)
+ } else if string(decoded) != value {
+ t.Errorf("Expected %v, got %s.", value, string(decoded))
+ }
+ }
+}
+
+func TestMultiError(t *testing.T) {
+ s1, s2 := New(nil, nil), New(nil, nil)
+ _, err := EncodeMulti("sid", "value", s1, s2)
+ if len(err.(MultiError)) != 2 {
+ t.Errorf("Expected 2 errors, got %s.", err)
+ } else {
+ if strings.Index(err.Error(), "hash key is not set") == -1 {
+ t.Errorf("Expected missing hash key error, got %s.", err.Error())
+ }
+ }
+}
+
+func TestMultiNoCodecs(t *testing.T) {
+ _, err := EncodeMulti("foo", "bar")
+ if err != errNoCodecs {
+ t.Errorf("EncodeMulti: bad value for error, got: %v", err)
+ }
+
+ var dst []byte
+ err = DecodeMulti("foo", "bar", &dst)
+ if err != errNoCodecs {
+ t.Errorf("DecodeMulti: bad value for error, got: %v", err)
+ }
+}
+
+// ----------------------------------------------------------------------------
+
+type FooBar struct {
+ Foo int
+ Bar string
+}
+
+func TestCustomType(t *testing.T) {
+ s1 := New([]byte("12345"), []byte("1234567890123456"))
+ // Type is not registered in gob. (!!!)
+ src := &FooBar{42, "bar"}
+ encoded, _ := s1.Encode("sid", src)
+
+ dst := &FooBar{}
+ _ = s1.Decode("sid", encoded, dst)
+ if dst.Foo != 42 || dst.Bar != "bar" {
+ t.Fatalf("Expected %#v, got %#v", src, dst)
+ }
+}
diff --git a/Godeps/_workspace/src/github.com/jmcvetta/randutil/LICENSE.txt b/Godeps/_workspace/src/github.com/jmcvetta/randutil/LICENSE.txt
new file mode 100644
index 0000000000000000000000000000000000000000..94a9ed024d3859793618152ea559a168bbcbb5e2
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/jmcvetta/randutil/LICENSE.txt
@@ -0,0 +1,674 @@
+ GNU GENERAL PUBLIC LICENSE
+ Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+ Preamble
+
+ The GNU General Public License is a free, copyleft license for
+software and other kinds of works.
+
+ The licenses for most software and other practical works are designed
+to take away your freedom to share and change the works. By contrast,
+the GNU General Public License is intended to guarantee your freedom to
+share and change all versions of a program--to make sure it remains free
+software for all its users. We, the Free Software Foundation, use the
+GNU General Public License for most of our software; it applies also to
+any other work released this way by its authors. You can apply it to
+your programs, too.
+
+ When we speak of free software, we are referring to freedom, not
+price. Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+them if you wish), that you receive source code or can get it if you
+want it, that you can change the software or use pieces of it in new
+free programs, and that you know you can do these things.
+
+ To protect your rights, we need to prevent others from denying you
+these rights or asking you to surrender the rights. Therefore, you have
+certain responsibilities if you distribute copies of the software, or if
+you modify it: responsibilities to respect the freedom of others.
+
+ For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must pass on to the recipients the same
+freedoms that you received. You must make sure that they, too, receive
+or can get the source code. And you must show them these terms so they
+know their rights.
+
+ Developers that use the GNU GPL protect your rights with two steps:
+(1) assert copyright on the software, and (2) offer you this License
+giving you legal permission to copy, distribute and/or modify it.
+
+ For the developers' and authors' protection, the GPL clearly explains
+that there is no warranty for this free software. For both users' and
+authors' sake, the GPL requires that modified versions be marked as
+changed, so that their problems will not be attributed erroneously to
+authors of previous versions.
+
+ Some devices are designed to deny users access to install or run
+modified versions of the software inside them, although the manufacturer
+can do so. This is fundamentally incompatible with the aim of
+protecting users' freedom to change the software. The systematic
+pattern of such abuse occurs in the area of products for individuals to
+use, which is precisely where it is most unacceptable. Therefore, we
+have designed this version of the GPL to prohibit the practice for those
+products. If such problems arise substantially in other domains, we
+stand ready to extend this provision to those domains in future versions
+of the GPL, as needed to protect the freedom of users.
+
+ Finally, every program is threatened constantly by software patents.
+States should not allow patents to restrict development and use of
+software on general-purpose computers, but in those that do, we wish to
+avoid the special danger that patents applied to a free program could
+make it effectively proprietary. To prevent this, the GPL assures that
+patents cannot be used to render the program non-free.
+
+ The precise terms and conditions for copying, distribution and
+modification follow.
+
+ TERMS AND CONDITIONS
+
+ 0. Definitions.
+
+ "This License" refers to version 3 of the GNU General Public License.
+
+ "Copyright" also means copyright-like laws that apply to other kinds of
+works, such as semiconductor masks.
+
+ "The Program" refers to any copyrightable work licensed under this
+License. Each licensee is addressed as "you". "Licensees" and
+"recipients" may be individuals or organizations.
+
+ To "modify" a work means to copy from or adapt all or part of the work
+in a fashion requiring copyright permission, other than the making of an
+exact copy. The resulting work is called a "modified version" of the
+earlier work or a work "based on" the earlier work.
+
+ A "covered work" means either the unmodified Program or a work based
+on the Program.
+
+ To "propagate" a work means to do anything with it that, without
+permission, would make you directly or secondarily liable for
+infringement under applicable copyright law, except executing it on a
+computer or modifying a private copy. Propagation includes copying,
+distribution (with or without modification), making available to the
+public, and in some countries other activities as well.
+
+ To "convey" a work means any kind of propagation that enables other
+parties to make or receive copies. Mere interaction with a user through
+a computer network, with no transfer of a copy, is not conveying.
+
+ An interactive user interface displays "Appropriate Legal Notices"
+to the extent that it includes a convenient and prominently visible
+feature that (1) displays an appropriate copyright notice, and (2)
+tells the user that there is no warranty for the work (except to the
+extent that warranties are provided), that licensees may convey the
+work under this License, and how to view a copy of this License. If
+the interface presents a list of user commands or options, such as a
+menu, a prominent item in the list meets this criterion.
+
+ 1. Source Code.
+
+ The "source code" for a work means the preferred form of the work
+for making modifications to it. "Object code" means any non-source
+form of a work.
+
+ A "Standard Interface" means an interface that either is an official
+standard defined by a recognized standards body, or, in the case of
+interfaces specified for a particular programming language, one that
+is widely used among developers working in that language.
+
+ The "System Libraries" of an executable work include anything, other
+than the work as a whole, that (a) is included in the normal form of
+packaging a Major Component, but which is not part of that Major
+Component, and (b) serves only to enable use of the work with that
+Major Component, or to implement a Standard Interface for which an
+implementation is available to the public in source code form. A
+"Major Component", in this context, means a major essential component
+(kernel, window system, and so on) of the specific operating system
+(if any) on which the executable work runs, or a compiler used to
+produce the work, or an object code interpreter used to run it.
+
+ The "Corresponding Source" for a work in object code form means all
+the source code needed to generate, install, and (for an executable
+work) run the object code and to modify the work, including scripts to
+control those activities. However, it does not include the work's
+System Libraries, or general-purpose tools or generally available free
+programs which are used unmodified in performing those activities but
+which are not part of the work. For example, Corresponding Source
+includes interface definition files associated with source files for
+the work, and the source code for shared libraries and dynamically
+linked subprograms that the work is specifically designed to require,
+such as by intimate data communication or control flow between those
+subprograms and other parts of the work.
+
+ The Corresponding Source need not include anything that users
+can regenerate automatically from other parts of the Corresponding
+Source.
+
+ The Corresponding Source for a work in source code form is that
+same work.
+
+ 2. Basic Permissions.
+
+ All rights granted under this License are granted for the term of
+copyright on the Program, and are irrevocable provided the stated
+conditions are met. This License explicitly affirms your unlimited
+permission to run the unmodified Program. The output from running a
+covered work is covered by this License only if the output, given its
+content, constitutes a covered work. This License acknowledges your
+rights of fair use or other equivalent, as provided by copyright law.
+
+ You may make, run and propagate covered works that you do not
+convey, without conditions so long as your license otherwise remains
+in force. You may convey covered works to others for the sole purpose
+of having them make modifications exclusively for you, or provide you
+with facilities for running those works, provided that you comply with
+the terms of this License in conveying all material for which you do
+not control copyright. Those thus making or running the covered works
+for you must do so exclusively on your behalf, under your direction
+and control, on terms that prohibit them from making any copies of
+your copyrighted material outside their relationship with you.
+
+ Conveying under any other circumstances is permitted solely under
+the conditions stated below. Sublicensing is not allowed; section 10
+makes it unnecessary.
+
+ 3. Protecting Users' Legal Rights From Anti-Circumvention Law.
+
+ No covered work shall be deemed part of an effective technological
+measure under any applicable law fulfilling obligations under article
+11 of the WIPO copyright treaty adopted on 20 December 1996, or
+similar laws prohibiting or restricting circumvention of such
+measures.
+
+ When you convey a covered work, you waive any legal power to forbid
+circumvention of technological measures to the extent such circumvention
+is effected by exercising rights under this License with respect to
+the covered work, and you disclaim any intention to limit operation or
+modification of the work as a means of enforcing, against the work's
+users, your or third parties' legal rights to forbid circumvention of
+technological measures.
+
+ 4. Conveying Verbatim Copies.
+
+ You may convey verbatim copies of the Program's source code as you
+receive it, in any medium, provided that you conspicuously and
+appropriately publish on each copy an appropriate copyright notice;
+keep intact all notices stating that this License and any
+non-permissive terms added in accord with section 7 apply to the code;
+keep intact all notices of the absence of any warranty; and give all
+recipients a copy of this License along with the Program.
+
+ You may charge any price or no price for each copy that you convey,
+and you may offer support or warranty protection for a fee.
+
+ 5. Conveying Modified Source Versions.
+
+ You may convey a work based on the Program, or the modifications to
+produce it from the Program, in the form of source code under the
+terms of section 4, provided that you also meet all of these conditions:
+
+ a) The work must carry prominent notices stating that you modified
+ it, and giving a relevant date.
+
+ b) The work must carry prominent notices stating that it is
+ released under this License and any conditions added under section
+ 7. This requirement modifies the requirement in section 4 to
+ "keep intact all notices".
+
+ c) You must license the entire work, as a whole, under this
+ License to anyone who comes into possession of a copy. This
+ License will therefore apply, along with any applicable section 7
+ additional terms, to the whole of the work, and all its parts,
+ regardless of how they are packaged. This License gives no
+ permission to license the work in any other way, but it does not
+ invalidate such permission if you have separately received it.
+
+ d) If the work has interactive user interfaces, each must display
+ Appropriate Legal Notices; however, if the Program has interactive
+ interfaces that do not display Appropriate Legal Notices, your
+ work need not make them do so.
+
+ A compilation of a covered work with other separate and independent
+works, which are not by their nature extensions of the covered work,
+and which are not combined with it such as to form a larger program,
+in or on a volume of a storage or distribution medium, is called an
+"aggregate" if the compilation and its resulting copyright are not
+used to limit the access or legal rights of the compilation's users
+beyond what the individual works permit. Inclusion of a covered work
+in an aggregate does not cause this License to apply to the other
+parts of the aggregate.
+
+ 6. Conveying Non-Source Forms.
+
+ You may convey a covered work in object code form under the terms
+of sections 4 and 5, provided that you also convey the
+machine-readable Corresponding Source under the terms of this License,
+in one of these ways:
+
+ a) Convey the object code in, or embodied in, a physical product
+ (including a physical distribution medium), accompanied by the
+ Corresponding Source fixed on a durable physical medium
+ customarily used for software interchange.
+
+ b) Convey the object code in, or embodied in, a physical product
+ (including a physical distribution medium), accompanied by a
+ written offer, valid for at least three years and valid for as
+ long as you offer spare parts or customer support for that product
+ model, to give anyone who possesses the object code either (1) a
+ copy of the Corresponding Source for all the software in the
+ product that is covered by this License, on a durable physical
+ medium customarily used for software interchange, for a price no
+ more than your reasonable cost of physically performing this
+ conveying of source, or (2) access to copy the
+ Corresponding Source from a network server at no charge.
+
+ c) Convey individual copies of the object code with a copy of the
+ written offer to provide the Corresponding Source. This
+ alternative is allowed only occasionally and noncommercially, and
+ only if you received the object code with such an offer, in accord
+ with subsection 6b.
+
+ d) Convey the object code by offering access from a designated
+ place (gratis or for a charge), and offer equivalent access to the
+ Corresponding Source in the same way through the same place at no
+ further charge. You need not require recipients to copy the
+ Corresponding Source along with the object code. If the place to
+ copy the object code is a network server, the Corresponding Source
+ may be on a different server (operated by you or a third party)
+ that supports equivalent copying facilities, provided you maintain
+ clear directions next to the object code saying where to find the
+ Corresponding Source. Regardless of what server hosts the
+ Corresponding Source, you remain obligated to ensure that it is
+ available for as long as needed to satisfy these requirements.
+
+ e) Convey the object code using peer-to-peer transmission, provided
+ you inform other peers where the object code and Corresponding
+ Source of the work are being offered to the general public at no
+ charge under subsection 6d.
+
+ A separable portion of the object code, whose source code is excluded
+from the Corresponding Source as a System Library, need not be
+included in conveying the object code work.
+
+ A "User Product" is either (1) a "consumer product", which means any
+tangible personal property which is normally used for personal, family,
+or household purposes, or (2) anything designed or sold for incorporation
+into a dwelling. In determining whether a product is a consumer product,
+doubtful cases shall be resolved in favor of coverage. For a particular
+product received by a particular user, "normally used" refers to a
+typical or common use of that class of product, regardless of the status
+of the particular user or of the way in which the particular user
+actually uses, or expects or is expected to use, the product. A product
+is a consumer product regardless of whether the product has substantial
+commercial, industrial or non-consumer uses, unless such uses represent
+the only significant mode of use of the product.
+
+ "Installation Information" for a User Product means any methods,
+procedures, authorization keys, or other information required to install
+and execute modified versions of a covered work in that User Product from
+a modified version of its Corresponding Source. The information must
+suffice to ensure that the continued functioning of the modified object
+code is in no case prevented or interfered with solely because
+modification has been made.
+
+ If you convey an object code work under this section in, or with, or
+specifically for use in, a User Product, and the conveying occurs as
+part of a transaction in which the right of possession and use of the
+User Product is transferred to the recipient in perpetuity or for a
+fixed term (regardless of how the transaction is characterized), the
+Corresponding Source conveyed under this section must be accompanied
+by the Installation Information. But this requirement does not apply
+if neither you nor any third party retains the ability to install
+modified object code on the User Product (for example, the work has
+been installed in ROM).
+
+ The requirement to provide Installation Information does not include a
+requirement to continue to provide support service, warranty, or updates
+for a work that has been modified or installed by the recipient, or for
+the User Product in which it has been modified or installed. Access to a
+network may be denied when the modification itself materially and
+adversely affects the operation of the network or violates the rules and
+protocols for communication across the network.
+
+ Corresponding Source conveyed, and Installation Information provided,
+in accord with this section must be in a format that is publicly
+documented (and with an implementation available to the public in
+source code form), and must require no special password or key for
+unpacking, reading or copying.
+
+ 7. Additional Terms.
+
+ "Additional permissions" are terms that supplement the terms of this
+License by making exceptions from one or more of its conditions.
+Additional permissions that are applicable to the entire Program shall
+be treated as though they were included in this License, to the extent
+that they are valid under applicable law. If additional permissions
+apply only to part of the Program, that part may be used separately
+under those permissions, but the entire Program remains governed by
+this License without regard to the additional permissions.
+
+ When you convey a copy of a covered work, you may at your option
+remove any additional permissions from that copy, or from any part of
+it. (Additional permissions may be written to require their own
+removal in certain cases when you modify the work.) You may place
+additional permissions on material, added by you to a covered work,
+for which you have or can give appropriate copyright permission.
+
+ Notwithstanding any other provision of this License, for material you
+add to a covered work, you may (if authorized by the copyright holders of
+that material) supplement the terms of this License with terms:
+
+ a) Disclaiming warranty or limiting liability differently from the
+ terms of sections 15 and 16 of this License; or
+
+ b) Requiring preservation of specified reasonable legal notices or
+ author attributions in that material or in the Appropriate Legal
+ Notices displayed by works containing it; or
+
+ c) Prohibiting misrepresentation of the origin of that material, or
+ requiring that modified versions of such material be marked in
+ reasonable ways as different from the original version; or
+
+ d) Limiting the use for publicity purposes of names of licensors or
+ authors of the material; or
+
+ e) Declining to grant rights under trademark law for use of some
+ trade names, trademarks, or service marks; or
+
+ f) Requiring indemnification of licensors and authors of that
+ material by anyone who conveys the material (or modified versions of
+ it) with contractual assumptions of liability to the recipient, for
+ any liability that these contractual assumptions directly impose on
+ those licensors and authors.
+
+ All other non-permissive additional terms are considered "further
+restrictions" within the meaning of section 10. If the Program as you
+received it, or any part of it, contains a notice stating that it is
+governed by this License along with a term that is a further
+restriction, you may remove that term. If a license document contains
+a further restriction but permits relicensing or conveying under this
+License, you may add to a covered work material governed by the terms
+of that license document, provided that the further restriction does
+not survive such relicensing or conveying.
+
+ If you add terms to a covered work in accord with this section, you
+must place, in the relevant source files, a statement of the
+additional terms that apply to those files, or a notice indicating
+where to find the applicable terms.
+
+ Additional terms, permissive or non-permissive, may be stated in the
+form of a separately written license, or stated as exceptions;
+the above requirements apply either way.
+
+ 8. Termination.
+
+ You may not propagate or modify a covered work except as expressly
+provided under this License. Any attempt otherwise to propagate or
+modify it is void, and will automatically terminate your rights under
+this License (including any patent licenses granted under the third
+paragraph of section 11).
+
+ However, if you cease all violation of this License, then your
+license from a particular copyright holder is reinstated (a)
+provisionally, unless and until the copyright holder explicitly and
+finally terminates your license, and (b) permanently, if the copyright
+holder fails to notify you of the violation by some reasonable means
+prior to 60 days after the cessation.
+
+ Moreover, your license from a particular copyright holder is
+reinstated permanently if the copyright holder notifies you of the
+violation by some reasonable means, this is the first time you have
+received notice of violation of this License (for any work) from that
+copyright holder, and you cure the violation prior to 30 days after
+your receipt of the notice.
+
+ Termination of your rights under this section does not terminate the
+licenses of parties who have received copies or rights from you under
+this License. If your rights have been terminated and not permanently
+reinstated, you do not qualify to receive new licenses for the same
+material under section 10.
+
+ 9. Acceptance Not Required for Having Copies.
+
+ You are not required to accept this License in order to receive or
+run a copy of the Program. Ancillary propagation of a covered work
+occurring solely as a consequence of using peer-to-peer transmission
+to receive a copy likewise does not require acceptance. However,
+nothing other than this License grants you permission to propagate or
+modify any covered work. These actions infringe copyright if you do
+not accept this License. Therefore, by modifying or propagating a
+covered work, you indicate your acceptance of this License to do so.
+
+ 10. Automatic Licensing of Downstream Recipients.
+
+ Each time you convey a covered work, the recipient automatically
+receives a license from the original licensors, to run, modify and
+propagate that work, subject to this License. You are not responsible
+for enforcing compliance by third parties with this License.
+
+ An "entity transaction" is a transaction transferring control of an
+organization, or substantially all assets of one, or subdividing an
+organization, or merging organizations. If propagation of a covered
+work results from an entity transaction, each party to that
+transaction who receives a copy of the work also receives whatever
+licenses to the work the party's predecessor in interest had or could
+give under the previous paragraph, plus a right to possession of the
+Corresponding Source of the work from the predecessor in interest, if
+the predecessor has it or can get it with reasonable efforts.
+
+ You may not impose any further restrictions on the exercise of the
+rights granted or affirmed under this License. For example, you may
+not impose a license fee, royalty, or other charge for exercise of
+rights granted under this License, and you may not initiate litigation
+(including a cross-claim or counterclaim in a lawsuit) alleging that
+any patent claim is infringed by making, using, selling, offering for
+sale, or importing the Program or any portion of it.
+
+ 11. Patents.
+
+ A "contributor" is a copyright holder who authorizes use under this
+License of the Program or a work on which the Program is based. The
+work thus licensed is called the contributor's "contributor version".
+
+ A contributor's "essential patent claims" are all patent claims
+owned or controlled by the contributor, whether already acquired or
+hereafter acquired, that would be infringed by some manner, permitted
+by this License, of making, using, or selling its contributor version,
+but do not include claims that would be infringed only as a
+consequence of further modification of the contributor version. For
+purposes of this definition, "control" includes the right to grant
+patent sublicenses in a manner consistent with the requirements of
+this License.
+
+ Each contributor grants you a non-exclusive, worldwide, royalty-free
+patent license under the contributor's essential patent claims, to
+make, use, sell, offer for sale, import and otherwise run, modify and
+propagate the contents of its contributor version.
+
+ In the following three paragraphs, a "patent license" is any express
+agreement or commitment, however denominated, not to enforce a patent
+(such as an express permission to practice a patent or covenant not to
+sue for patent infringement). To "grant" such a patent license to a
+party means to make such an agreement or commitment not to enforce a
+patent against the party.
+
+ If you convey a covered work, knowingly relying on a patent license,
+and the Corresponding Source of the work is not available for anyone
+to copy, free of charge and under the terms of this License, through a
+publicly available network server or other readily accessible means,
+then you must either (1) cause the Corresponding Source to be so
+available, or (2) arrange to deprive yourself of the benefit of the
+patent license for this particular work, or (3) arrange, in a manner
+consistent with the requirements of this License, to extend the patent
+license to downstream recipients. "Knowingly relying" means you have
+actual knowledge that, but for the patent license, your conveying the
+covered work in a country, or your recipient's use of the covered work
+in a country, would infringe one or more identifiable patents in that
+country that you have reason to believe are valid.
+
+ If, pursuant to or in connection with a single transaction or
+arrangement, you convey, or propagate by procuring conveyance of, a
+covered work, and grant a patent license to some of the parties
+receiving the covered work authorizing them to use, propagate, modify
+or convey a specific copy of the covered work, then the patent license
+you grant is automatically extended to all recipients of the covered
+work and works based on it.
+
+ A patent license is "discriminatory" if it does not include within
+the scope of its coverage, prohibits the exercise of, or is
+conditioned on the non-exercise of one or more of the rights that are
+specifically granted under this License. You may not convey a covered
+work if you are a party to an arrangement with a third party that is
+in the business of distributing software, under which you make payment
+to the third party based on the extent of your activity of conveying
+the work, and under which the third party grants, to any of the
+parties who would receive the covered work from you, a discriminatory
+patent license (a) in connection with copies of the covered work
+conveyed by you (or copies made from those copies), or (b) primarily
+for and in connection with specific products or compilations that
+contain the covered work, unless you entered into that arrangement,
+or that patent license was granted, prior to 28 March 2007.
+
+ Nothing in this License shall be construed as excluding or limiting
+any implied license or other defenses to infringement that may
+otherwise be available to you under applicable patent law.
+
+ 12. No Surrender of Others' Freedom.
+
+ If conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License. If you cannot convey a
+covered work so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you may
+not convey it at all. For example, if you agree to terms that obligate you
+to collect a royalty for further conveying from those to whom you convey
+the Program, the only way you could satisfy both those terms and this
+License would be to refrain entirely from conveying the Program.
+
+ 13. Use with the GNU Affero General Public License.
+
+ Notwithstanding any other provision of this License, you have
+permission to link or combine any covered work with a work licensed
+under version 3 of the GNU Affero General Public License into a single
+combined work, and to convey the resulting work. The terms of this
+License will continue to apply to the part which is the covered work,
+but the special requirements of the GNU Affero General Public License,
+section 13, concerning interaction through a network will apply to the
+combination as such.
+
+ 14. Revised Versions of this License.
+
+ The Free Software Foundation may publish revised and/or new versions of
+the GNU General Public License from time to time. Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+ Each version is given a distinguishing version number. If the
+Program specifies that a certain numbered version of the GNU General
+Public License "or any later version" applies to it, you have the
+option of following the terms and conditions either of that numbered
+version or of any later version published by the Free Software
+Foundation. If the Program does not specify a version number of the
+GNU General Public License, you may choose any version ever published
+by the Free Software Foundation.
+
+ If the Program specifies that a proxy can decide which future
+versions of the GNU General Public License can be used, that proxy's
+public statement of acceptance of a version permanently authorizes you
+to choose that version for the Program.
+
+ Later license versions may give you additional or different
+permissions. However, no additional obligations are imposed on any
+author or copyright holder as a result of your choosing to follow a
+later version.
+
+ 15. Disclaimer of Warranty.
+
+ THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
+APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
+HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
+OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
+IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
+ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+ 16. Limitation of Liability.
+
+ IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
+THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
+GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
+USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
+DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
+PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
+EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGES.
+
+ 17. Interpretation of Sections 15 and 16.
+
+ If the disclaimer of warranty and limitation of liability provided
+above cannot be given local legal effect according to their terms,
+reviewing courts shall apply local law that most closely approximates
+an absolute waiver of all civil liability in connection with the
+Program, unless a warranty or assumption of liability accompanies a
+copy of the Program in return for a fee.
+
+ END OF TERMS AND CONDITIONS
+
+ How to Apply These Terms to Your New Programs
+
+ If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+ To do so, attach the following notices to the program. It is safest
+to attach them to the start of each source file to most effectively
+state the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+ <one line to give the program's name and a brief idea of what it does.>
+ Copyright (C) <year> <name of author>
+
+ This program is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program. If not, see <http://www.gnu.org/licenses/>.
+
+Also add information on how to contact you by electronic and paper mail.
+
+ If the program does terminal interaction, make it output a short
+notice like this when it starts in an interactive mode:
+
+ <program> Copyright (C) <year> <name of author>
+ This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+ This is free software, and you are welcome to redistribute it
+ under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License. Of course, your program's commands
+might be different; for a GUI interface, you would use an "about box".
+
+ You should also get your employer (if you work as a programmer) or school,
+if any, to sign a "copyright disclaimer" for the program, if necessary.
+For more information on this, and how to apply and follow the GNU GPL, see
+<http://www.gnu.org/licenses/>.
+
+ The GNU General Public License does not permit incorporating your program
+into proprietary programs. If your program is a subroutine library, you
+may consider it more useful to permit linking proprietary applications with
+the library. If this is what you want to do, use the GNU Lesser General
+Public License instead of this License. But first, please read
+<http://www.gnu.org/philosophy/why-not-lgpl.html>.
diff --git a/Godeps/_workspace/src/github.com/jmcvetta/randutil/README.md b/Godeps/_workspace/src/github.com/jmcvetta/randutil/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..47e3b66c89343d7cbb9350f76660a17b88703c1f
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/jmcvetta/randutil/README.md
@@ -0,0 +1,17 @@
+# randutil - Random number/string utilities for the Go language
+
+This package contains assorted utility functions for creating random numbers
+and strings. I use this package quite a bit, especially when testing other
+projects. However I make no claims about the cryptographic security or other
+properties of the random(-ish?) numbers and strings it produces. Use at your
+own risk.
+
+## API Documentation
+
+See GoDoc for [automatically generated
+documentation](http://godoc.org/github.com/jmcvetta/randutil).
+
+
+## Status
+
+[](https://drone.io/github.com/jmcvetta/randutil/latest)
diff --git a/Godeps/_workspace/src/github.com/jmcvetta/randutil/randutil.go b/Godeps/_workspace/src/github.com/jmcvetta/randutil/randutil.go
new file mode 100644
index 0000000000000000000000000000000000000000..d088b3f0c72dd0cf1d16fd230503a66bed2da9d3
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/jmcvetta/randutil/randutil.go
@@ -0,0 +1,143 @@
+// Copyright (c) 2012 Jason McVetta. This is Free Software, released under the
+// terms of the GPL v3. See http://www.gnu.org/copyleft/gpl.html for details.
+
+// Package randutil provides various convenience functions for dealing with
+// random numbers and strings.
+package randutil
+
+import (
+ "crypto/rand"
+ "errors"
+ "math/big"
+)
+
+const (
+ // Set of characters to use for generating random strings
+ Alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
+ Numerals = "1234567890"
+ Alphanumeric = Alphabet + Numerals
+ Ascii = Alphanumeric + "~!@#$%^&*()-_+={}[]\\|<,>.?/\"';:`"
+)
+
+var MinMaxError = errors.New("Min cannot be greater than max.")
+
+// IntRange returns a random integer in the range from min to max.
+func IntRange(min, max int) (int, error) {
+ var result int
+ switch {
+ case min > max:
+ // Fail with error
+ return result, MinMaxError
+ case max == min:
+ result = max
+ case max > min:
+ maxRand := max - min
+ b, err := rand.Int(rand.Reader, big.NewInt(int64(maxRand)))
+ if err != nil {
+ return result, err
+ }
+ result = min + int(b.Int64())
+ }
+ return result, nil
+}
+
+// String returns a random string n characters long, composed of entities
+// from charset.
+func String(n int, charset string) (string, error) {
+ var randstr string // Random string to return
+ charlen := len(charset)
+ // This is probably not the most efficient algorithm
+ for i := 0; i < n; i++ {
+ b, err := rand.Int(rand.Reader, big.NewInt(int64(charlen-1)))
+ if err != nil {
+ return randstr, err
+ }
+ r := int(b.Int64())
+ c := string(charset[r])
+ randstr += c
+ }
+ return randstr, nil
+}
+
+// StringRange returns a random string at least min and no more than max
+// characters long, composed of entitites from charset.
+func StringRange(min, max int, charset string) (string, error) {
+ //
+ // First determine the length of string to be generated
+ //
+ var err error // Holds errors
+ var strlen int // Length of random string to generate
+ var randstr string // Random string to return
+ strlen, err = IntRange(min, max)
+ if err != nil {
+ return randstr, err
+ }
+ randstr, err = String(strlen, charset)
+ if err != nil {
+ return randstr, err
+ }
+ return randstr, nil
+}
+
+// AlphaRange returns a random alphanumeric string at least min and no more
+// than max characters long.
+func AlphaStringRange(min, max int) (string, error) {
+ return StringRange(min, max, Alphanumeric)
+}
+
+// AlphaString returns a random alphanumeric string n characters long.
+func AlphaString(n int) (string, error) {
+ return String(n, Alphanumeric)
+}
+
+// ChoiceString returns a random selection from an array of strings.
+func ChoiceString(choices []string) (string, error) {
+ var winner string
+ length := len(choices)
+ i, err := IntRange(0, length)
+ winner = choices[i]
+ return winner, err
+}
+
+// ChoiceInt returns a random selection from an array of integers.
+func ChoiceInt(choices []int) (int, error) {
+ var winner int
+ length := len(choices)
+ i, err := IntRange(0, length)
+ winner = choices[i]
+ return winner, err
+}
+
+// A Choice contains a generic item and a weight controlling the frequency with
+// which it will be selected.
+type Choice struct {
+ Weight int
+ Item interface{}
+}
+
+// WeightedChoice used weighted random selection to return one of the supplied
+// choices. Weights of 0 are never selected. All other weight values are
+// relative. E.g. if you have two choices both weighted 3, they will be
+// returned equally often; and each will be returned 3 times as often as a
+// choice weighted 1.
+func WeightedChoice(choices []Choice) (Choice, error) {
+ // Based on this algorithm:
+ // http://eli.thegreenplace.net/2010/01/22/weighted-random-generation-in-python/
+ var ret Choice
+ sum := 0
+ for _, c := range choices {
+ sum += c.Weight
+ }
+ r, err := IntRange(0, sum)
+ if err != nil {
+ return ret, err
+ }
+ for _, c := range choices {
+ r -= c.Weight
+ if r < 0 {
+ return c, nil
+ }
+ }
+ err = errors.New("Internal error - code should not reach this point")
+ return ret, err
+}
diff --git a/Godeps/_workspace/src/github.com/jmcvetta/randutil/randutil_test.go b/Godeps/_workspace/src/github.com/jmcvetta/randutil/randutil_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..b88c214008cfec5b21e01df774a5b314f21637ab
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/jmcvetta/randutil/randutil_test.go
@@ -0,0 +1,221 @@
+// Copyright (c) 2012 Jason McVetta. This is Free Software, released under the
+// terms of the GPL v3. See http://www.gnu.org/copyleft/gpl.html for details.
+
+package randutil
+
+import (
+ "fmt"
+ "github.com/bmizerany/assert"
+ "log"
+ "math"
+ "math/rand"
+ "testing"
+)
+
+const (
+ maxIntRange = 999999
+)
+
+var (
+ stringChoices []string
+ intChoices []int
+)
+
+// Test that AlphaStringRange produces a string within specified min/max length
+// parameters. The actual randonimity of the string is not tested.
+func TestAlphaStringRange(t *testing.T) {
+ min := rand.Intn(100)
+ max := min + 1 + rand.Intn(100)
+ s, err := AlphaStringRange(min, max)
+ if err != nil {
+ t.Error(err)
+ }
+ switch true {
+ case len(s) < min:
+ t.Error("Random string is too short")
+ case len(s) > max:
+ t.Error("Random string is too short")
+ }
+ return
+}
+
+// Test that IntRange produces an integer between min and max
+func TestIntRange(t *testing.T) {
+ min := 567
+ max := 890
+ i, err := IntRange(min, max)
+ if err != nil {
+ t.Error(err)
+ }
+ if i > max || i < min {
+ t.Error("IntRange returned an out-of-range integer")
+ }
+ // Check that we get an error when min > max
+ i, err = IntRange(max, min)
+ if err != MinMaxError {
+ msg := fmt.Sprintf("Expected error when min > max, but got:", err)
+ t.Error(msg)
+ }
+}
+
+// Test that the strings we produce are actually random. This is done by
+// comparing two 50,000 character generated random strings and checking that
+// they differ. It is quite unlikely, but not strictly impossible, that two
+// truly random strings will be identical.
+func TestRandonimity(t *testing.T) {
+ l := 50000
+ s1, err := AlphaString(l)
+ if err != nil {
+ t.Error(err)
+ }
+ s2, err := AlphaString(l)
+ if err != nil {
+ t.Error(err)
+ }
+ if s1 == s2 {
+ msg := "Generated two identical 'random' strings - this is probably an error"
+ t.Error(msg)
+ }
+}
+
+// TestChoice tests that over the course of 1,000,000 calls on the same 100
+// possible choices, the Choice() function returns every possible choice at
+// least once. Note, there is a VERY small chance this test could fail by
+// random chance even when the code is working correctly.
+func TestChoice(t *testing.T) {
+ // Create a map associating each possible choice with a bool.
+ chosen := make(map[int]bool)
+ for _, v := range intChoices {
+ chosen[v] = false
+ }
+ // Run Choice() a million times, and record which of the possible choices it returns.
+ for i := 0; i < 1000000; i++ {
+ c, err := ChoiceInt(intChoices)
+ if err != nil {
+ t.Error(err)
+ }
+ chosen[c] = true
+ }
+ // Fail if any of the choices was not chosen even once.
+ for _, v := range chosen {
+ if v == false {
+ msg := "In 1,000,000 passes Choice() failed to return all 100 possible choices. Something is probably wrong."
+ t.Error(msg)
+ }
+ }
+}
+
+// TestWeightedChoice assembles a list of choices, weighted 0-9, and tests that
+// over the course of 1,000,000 calls to WeightedChoice() each choice is
+// returned more often than choices with a lower weight.
+func TestWeightedChoice(t *testing.T) {
+ // Make weighted choices
+ var choices []Choice
+ chosenCount := make(map[Choice]int)
+ for i := 0; i < 10; i++ {
+ c := Choice{
+ Weight: i,
+ Item: i,
+ }
+ choices = append(choices, c)
+ chosenCount[c] = 0
+ }
+ // Run WeightedChoice() a million times, and record how often it returns each
+ // of the possible choices.
+ for i := 0; i < 1000000; i++ {
+ c, err := WeightedChoice(choices)
+ if err != nil {
+ t.Error(err)
+ }
+ chosenCount[c] += 1
+ }
+ // Test that higher weighted choices were chosen more often than their lower
+ // weighted peers.
+ for i, c := range choices[0 : len(choices)-1] {
+ next := choices[i+1]
+ expr := chosenCount[c] < chosenCount[next]
+ assert.T(t, expr)
+ }
+}
+
+// BenchmarkChoiceInt runs a benchmark on the ChoiceInt function.
+func BenchmarkChoiceInt(b *testing.B) {
+ for i := 0; i < b.N; i++ {
+ _, err := ChoiceInt(intChoices)
+ if err != nil {
+ b.Error(err)
+ }
+ }
+}
+
+// BenchmarkChoiceString runs a benchmark on the ChoiceString function.
+func BenchmarkChoiceString(b *testing.B) {
+ for i := 0; i < b.N; i++ {
+ _, err := ChoiceString(stringChoices)
+ if err != nil {
+ b.Error(err)
+ }
+ }
+}
+
+// BenchmarkIntRange runs a benchmark on the IntRange function.
+func BenchmarkIntRange(b *testing.B) {
+ for i := 0; i < b.N; i++ {
+ _, err := IntRange(0, math.MaxInt32)
+ if err != nil {
+ b.Error(err)
+ }
+ }
+}
+
+// BenchmarkIntRange runs a benchmark on the WeightedChoice function.
+func BenchmarkWeightedChoice(b *testing.B) {
+ // Create some random choices and weights before we start
+ b.StopTimer()
+ choices := []Choice{}
+ for i := 0; i < 100; i++ {
+ s, err := AlphaString(64)
+ if err != nil {
+ b.Error(err)
+ }
+ w, err := IntRange(1, 10)
+ if err != nil {
+ b.Error(err)
+ }
+ c := Choice{
+ Item: s,
+ Weight: w,
+ }
+ choices = append(choices, c)
+ }
+ // Run the benchmark
+ b.StartTimer()
+ for i := 0; i < b.N; i++ {
+ _, err := WeightedChoice(choices)
+ if err != nil {
+ b.Error(err)
+ }
+ }
+}
+
+// init populates two arrays of random choices, intChoices and stringChoices,
+// which will be used by various test and benchmark functions.
+func init() {
+ log.SetFlags(log.Ltime | log.Lshortfile)
+ // Random integers
+ for i := 0; i < 100; i++ {
+ randint, err := IntRange(0, maxIntRange)
+ if err != nil {
+ log.Panicln(err)
+ }
+ intChoices = append(intChoices, randint)
+ }
+ // Random strings
+ for i := 0; i < 100; i++ {
+ randstr, err := AlphaString(32)
+ if err != nil {
+ log.Panicln(err)
+ }
+ stringChoices = append(stringChoices, randstr)
+ }
+}
diff --git a/Godeps/_workspace/src/github.com/miekg/dns/.gitignore b/Godeps/_workspace/src/github.com/miekg/dns/.gitignore
new file mode 100644
index 0000000000000000000000000000000000000000..776cd950c25c28d0809d92dfdadbf0464c6c4364
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/miekg/dns/.gitignore
@@ -0,0 +1,4 @@
+*.6
+tags
+test.out
+a.out
diff --git a/Godeps/_workspace/src/github.com/miekg/dns/.travis.yml b/Godeps/_workspace/src/github.com/miekg/dns/.travis.yml
new file mode 100644
index 0000000000000000000000000000000000000000..4485679769dca9ef33a6c9f5828dbf2a9bcedede
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/miekg/dns/.travis.yml
@@ -0,0 +1,21 @@
+language: go
+go:
+ - 1.2
+ - 1.3
+env:
+ # "gvm update" resets GOOS and GOARCH environment variable, workaround it by setting
+ # BUILD_GOOS and BUILD_GOARCH and overriding GOARCH and GOOS in the build script
+ global:
+ - BUILD_GOARCH=amd64
+ matrix:
+ - BUILD_GOOS=linux
+ - BUILD_GOOS=darwin
+ - BUILD_GOOS=windows
+script:
+ - gvm cross $BUILD_GOOS $BUILD_GOARCH
+ - GOARCH=$BUILD_GOARCH GOOS=$BUILD_GOOS go build
+
+ # only test on linux
+ # also specify -short; the crypto tests fail in weird ways *sometimes*
+ # See issue #151
+ - if [ $BUILD_GOOS == "linux" ]; then GOARCH=$BUILD_GOARCH GOOS=$BUILD_GOOS go test -short -bench=.; fi
diff --git a/Godeps/_workspace/src/github.com/miekg/dns/AUTHORS b/Godeps/_workspace/src/github.com/miekg/dns/AUTHORS
new file mode 100644
index 0000000000000000000000000000000000000000..1965683525addf5b9e195995e8e82a9a695e9664
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/miekg/dns/AUTHORS
@@ -0,0 +1 @@
+Miek Gieben <miek@miek.nl>
diff --git a/Godeps/_workspace/src/github.com/miekg/dns/CONTRIBUTORS b/Godeps/_workspace/src/github.com/miekg/dns/CONTRIBUTORS
new file mode 100644
index 0000000000000000000000000000000000000000..f77e8a895f91bb1624ca2a8ede0d4961418822f4
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/miekg/dns/CONTRIBUTORS
@@ -0,0 +1,9 @@
+Alex A. Skinner
+Andrew Tunnell-Jones
+Ask Bjørn Hansen
+Dave Cheney
+Dusty Wilson
+Marek Majkowski
+Peter van Dijk
+Omri Bahumi
+Alex Sergeyev
diff --git a/Godeps/_workspace/src/github.com/miekg/dns/COPYRIGHT b/Godeps/_workspace/src/github.com/miekg/dns/COPYRIGHT
new file mode 100644
index 0000000000000000000000000000000000000000..35702b10e87ecd129b3374f554ab57cd59f7dcc9
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/miekg/dns/COPYRIGHT
@@ -0,0 +1,9 @@
+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.
+Extensions of the original work are copyright (c) 2011 Miek Gieben
+
+Copyright 2011 Miek Gieben. All rights reserved. Use of this source code is
+governed by a BSD-style license that can be found in the LICENSE file.
+
+Copyright 2014 CloudFlare. All rights reserved. Use of this source code is
+governed by a BSD-style license that can be found in the LICENSE file.
diff --git a/Godeps/_workspace/src/github.com/miekg/dns/LICENSE b/Godeps/_workspace/src/github.com/miekg/dns/LICENSE
new file mode 100644
index 0000000000000000000000000000000000000000..5763fa7fe5d963c854627c7fd5b8a76534f5c0d1
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/miekg/dns/LICENSE
@@ -0,0 +1,32 @@
+Extensions of the original work are copyright (c) 2011 Miek Gieben
+
+As this is fork of the official Go code the same license applies:
+
+Copyright (c) 2009 The Go Authors. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+ * Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above
+copyright notice, this list of conditions and the following disclaimer
+in the documentation and/or other materials provided with the
+distribution.
+ * Neither the name of Google Inc. nor the names of its
+contributors may be used to endorse or promote products derived from
+this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
diff --git a/Godeps/_workspace/src/github.com/miekg/dns/README.md b/Godeps/_workspace/src/github.com/miekg/dns/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..3cb850a0b07dab687d595b23e9659e46240f9118
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/miekg/dns/README.md
@@ -0,0 +1,140 @@
+[](https://travis-ci.org/miekg/dns)
+
+# Alternative (more granular) approach to a DNS library
+
+> Less is more.
+
+Complete and usable DNS library. All widely used Resource Records are
+supported, including the DNSSEC types. It follows a lean and mean philosophy.
+If there is stuff you should know as a DNS programmer there isn't a convenience
+function for it. Server side and client side programming is supported, i.e. you
+can build servers and resolvers with it.
+
+If you like this, you may also be interested in:
+
+* https://github.com/miekg/unbound -- Go wrapper for the Unbound resolver.
+
+# Goals
+
+* KISS;
+* Fast;
+* Small API, if its easy to code in Go, don't make a function for it.
+
+# Users
+
+A not-so-up-to-date-list-that-may-be-actually-current:
+
+* https://github.com/abh/geodns
+* http://www.statdns.com/
+* http://www.dnsinspect.com/
+* https://github.com/chuangbo/jianbing-dictionary-dns
+* http://www.dns-lg.com/
+* https://github.com/fcambus/rrda
+* https://github.com/kenshinx/godns
+* https://github.com/skynetservices/skydns
+* https://github.com/DevelopersPL/godnsagent
+* https://github.com/duedil-ltd/discodns
+
+Send pull request if you want to be listed here.
+
+# Features
+
+* UDP/TCP queries, IPv4 and IPv6;
+* RFC 1035 zone file parsing ($INCLUDE, $ORIGIN, $TTL and $GENERATE (for all record types) are supported;
+* Fast:
+ * Reply speed around ~ 80K qps (faster hardware results in more qps);
+ * Parsing RRs ~ 100K RR/s, that's 5M records in about 50 seconds;
+* Server side programming (mimicking the net/http package);
+* Client side programming;
+* DNSSEC: signing, validating and key generation for DSA, RSA and ECDSA;
+* EDNS0, NSID;
+* AXFR/IXFR;
+* TSIG, SIG(0);
+* DNS name compression;
+* Depends only on the standard library.
+
+Have fun!
+
+Miek Gieben - 2010-2012 - <miek@miek.nl>
+
+# Building
+
+Building is done with the `go` tool. If you have setup your GOPATH
+correctly, the following should work:
+
+ go get github.com/miekg/dns
+ go build github.com/miekg/dns
+
+## Examples
+
+A short "how to use the API" is at the beginning of dns.go (this also will show
+when you call `godoc github.com/miekg/dns`).
+
+Example programs can be found in the `github.com/miekg/exdns` repository.
+
+## Supported RFCs
+
+*all of them*
+
+* 103{4,5} - DNS standard
+* 1348 - NSAP record
+* 1982 - Serial Arithmetic
+* 1876 - LOC record
+* 1995 - IXFR
+* 1996 - DNS notify
+* 2136 - DNS Update (dynamic updates)
+* 2181 - RRset definition - there is no RRset type though, just []RR
+* 2537 - RSAMD5 DNS keys
+* 2065 - DNSSEC (updated in later RFCs)
+* 2671 - EDNS record
+* 2782 - SRV record
+* 2845 - TSIG record
+* 2915 - NAPTR record
+* 2929 - DNS IANA Considerations
+* 3110 - RSASHA1 DNS keys
+* 3225 - DO bit (DNSSEC OK)
+* 340{1,2,3} - NAPTR record
+* 3445 - Limiting the scope of (DNS)KEY
+* 3597 - Unkown RRs
+* 403{3,4,5} - DNSSEC + validation functions
+* 4255 - SSHFP record
+* 4343 - Case insensitivity
+* 4408 - SPF record
+* 4509 - SHA256 Hash in DS
+* 4592 - Wildcards in the DNS
+* 4635 - HMAC SHA TSIG
+* 4701 - DHCID
+* 4892 - id.server
+* 5001 - NSID
+* 5155 - NSEC3 record
+* 5205 - HIP record
+* 5702 - SHA2 in the DNS
+* 5936 - AXFR
+* 5966 - TCP implementation recommendations
+* 6605 - ECDSA
+* 6725 - IANA Registry Update
+* 6742 - ILNP DNS
+* 6891 - EDNS0 update
+* 6895 - DNS IANA considerations
+* 6975 - Algorithm Understanding in DNSSEC
+* 7043 - EUI48/EUI64 records
+* 7314 - DNS (EDNS) EXPIRE Option
+* xxxx - URI record (draft)
+* xxxx - EDNS0 DNS Update Lease (draft)
+
+## Loosely based upon
+
+* `ldns`
+* `NSD`
+* `Net::DNS`
+* `GRONG`
+
+## TODO
+
+* privatekey.Precompute() when signing?
+* Last remaining RRs: APL, ATMA, A6 and NXT;
+* Missing in parsing: ISDN, UNSPEC, ATMA;
+* CAA parsing is broken;
+* NSEC(3) cover/match/closest enclose;
+* Replies with TC bit are not parsed to the end;
+* Create IsMsg to validate a message before fully parsing it.
diff --git a/Godeps/_workspace/src/github.com/miekg/dns/client.go b/Godeps/_workspace/src/github.com/miekg/dns/client.go
new file mode 100644
index 0000000000000000000000000000000000000000..ee8e22333b1ab05756b03a9600d597c9d776605b
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/miekg/dns/client.go
@@ -0,0 +1,319 @@
+package dns
+
+// A client implementation.
+
+import (
+ "bytes"
+ "io"
+ "net"
+ "time"
+)
+
+const dnsTimeout time.Duration = 2 * 1e9
+const tcpIdleTimeout time.Duration = 8 * time.Second
+
+// A Conn represents a connection to a DNS server.
+type Conn struct {
+ net.Conn // a net.Conn holding the connection
+ UDPSize uint16 // minimum receive buffer for UDP messages
+ TsigSecret map[string]string // secret(s) for Tsig map[<zonename>]<base64 secret>, zonename must be fully qualified
+ rtt time.Duration
+ t time.Time
+ tsigRequestMAC string
+}
+
+// A Client defines parameters for a DNS client.
+type Client struct {
+ Net string // if "tcp" a TCP query will be initiated, otherwise an UDP one (default is "" for UDP)
+ UDPSize uint16 // minimum receive buffer for UDP messages
+ DialTimeout time.Duration // net.DialTimeout (ns), defaults to 2 * 1e9
+ ReadTimeout time.Duration // net.Conn.SetReadTimeout value for connections (ns), defaults to 2 * 1e9
+ WriteTimeout time.Duration // net.Conn.SetWriteTimeout value for connections (ns), defaults to 2 * 1e9
+ TsigSecret map[string]string // secret(s) for Tsig map[<zonename>]<base64 secret>, zonename must be fully qualified
+ SingleInflight bool // if true suppress multiple outstanding queries for the same Qname, Qtype and Qclass
+ group singleflight
+}
+
+// Exchange performs a synchronous UDP query. It sends the message m to the address
+// contained in a and waits for an reply. Exchange does not retry a failed query, nor
+// will it fall back to TCP in case of truncation.
+// If you need to send a DNS message on an already existing connection, you can use the
+// following:
+//
+// co := &dns.Conn{Conn: c} // c is your net.Conn
+// co.WriteMsg(m)
+// in, err := co.ReadMsg()
+// co.Close()
+//
+func Exchange(m *Msg, a string) (r *Msg, err error) {
+ var co *Conn
+ co, err = DialTimeout("udp", a, dnsTimeout)
+ if err != nil {
+ return nil, err
+ }
+
+ defer co.Close()
+ co.SetReadDeadline(time.Now().Add(dnsTimeout))
+ co.SetWriteDeadline(time.Now().Add(dnsTimeout))
+ if err = co.WriteMsg(m); err != nil {
+ return nil, err
+ }
+ r, err = co.ReadMsg()
+ return r, err
+}
+
+// ExchangeConn performs a synchronous query. It sends the message m via the connection
+// c and waits for a reply. The connection c is not closed by ExchangeConn.
+// This function is going away, but can easily be mimicked:
+//
+// co := &dns.Conn{Conn: c} // c is your net.Conn
+// co.WriteMsg(m)
+// in, _ := co.ReadMsg()
+// co.Close()
+//
+func ExchangeConn(c net.Conn, m *Msg) (r *Msg, err error) {
+ println("dns: this function is deprecated")
+ co := new(Conn)
+ co.Conn = c
+ if err = co.WriteMsg(m); err != nil {
+ return nil, err
+ }
+ r, err = co.ReadMsg()
+ return r, err
+}
+
+// Exchange performs an synchronous query. It sends the message m to the address
+// contained in a and waits for an reply. Basic use pattern with a *dns.Client:
+//
+// c := new(dns.Client)
+// in, rtt, err := c.Exchange(message, "127.0.0.1:53")
+//
+// Exchange does not retry a failed query, nor will it fall back to TCP in
+// case of truncation.
+func (c *Client) Exchange(m *Msg, a string) (r *Msg, rtt time.Duration, err error) {
+ if !c.SingleInflight {
+ return c.exchange(m, a)
+ }
+ // This adds a bunch of garbage, TODO(miek).
+ t := "nop"
+ if t1, ok := TypeToString[m.Question[0].Qtype]; ok {
+ t = t1
+ }
+ cl := "nop"
+ if cl1, ok := ClassToString[m.Question[0].Qclass]; ok {
+ cl = cl1
+ }
+ r, rtt, err, shared := c.group.Do(m.Question[0].Name+t+cl, func() (*Msg, time.Duration, error) {
+ return c.exchange(m, a)
+ })
+ if err != nil {
+ return r, rtt, err
+ }
+ if shared {
+ return r.Copy(), rtt, nil
+ }
+ return r, rtt, nil
+}
+
+func (c *Client) exchange(m *Msg, a string) (r *Msg, rtt time.Duration, err error) {
+ timeout := dnsTimeout
+ var co *Conn
+ if c.DialTimeout != 0 {
+ timeout = c.DialTimeout
+ }
+ if c.Net == "" {
+ co, err = DialTimeout("udp", a, timeout)
+ } else {
+ co, err = DialTimeout(c.Net, a, timeout)
+ }
+ if err != nil {
+ return nil, 0, err
+ }
+ timeout = dnsTimeout
+ if c.ReadTimeout != 0 {
+ timeout = c.ReadTimeout
+ }
+ co.SetReadDeadline(time.Now().Add(timeout))
+ timeout = dnsTimeout
+ if c.WriteTimeout != 0 {
+ timeout = c.WriteTimeout
+ }
+ co.SetWriteDeadline(time.Now().Add(timeout))
+ defer co.Close()
+ opt := m.IsEdns0()
+ // If EDNS0 is used use that for size.
+ if opt != nil && opt.UDPSize() >= MinMsgSize {
+ co.UDPSize = opt.UDPSize()
+ }
+ // Otherwise use the client's configured UDP size.
+ if opt == nil && c.UDPSize >= MinMsgSize {
+ co.UDPSize = c.UDPSize
+ }
+ co.TsigSecret = c.TsigSecret
+ if err = co.WriteMsg(m); err != nil {
+ return nil, 0, err
+ }
+ r, err = co.ReadMsg()
+ return r, co.rtt, err
+}
+
+// ReadMsg reads a message from the connection co.
+// If the received message contains a TSIG record the transaction
+// signature is verified.
+func (co *Conn) ReadMsg() (*Msg, error) {
+ var p []byte
+ m := new(Msg)
+ if _, ok := co.Conn.(*net.TCPConn); ok {
+ p = make([]byte, MaxMsgSize)
+ } else {
+ if co.UDPSize >= 512 {
+ p = make([]byte, co.UDPSize)
+ } else {
+ p = make([]byte, MinMsgSize)
+ }
+ }
+ n, err := co.Read(p)
+ if err != nil && n == 0 {
+ return nil, err
+ }
+ p = p[:n]
+ if err := m.Unpack(p); err != nil {
+ return nil, err
+ }
+ co.rtt = time.Since(co.t)
+ if t := m.IsTsig(); t != nil {
+ if _, ok := co.TsigSecret[t.Hdr.Name]; !ok {
+ return m, ErrSecret
+ }
+ // Need to work on the original message p, as that was used to calculate the tsig.
+ err = TsigVerify(p, co.TsigSecret[t.Hdr.Name], co.tsigRequestMAC, false)
+ }
+ return m, err
+}
+
+// Read implements the net.Conn read method.
+func (co *Conn) Read(p []byte) (n int, err error) {
+ if co.Conn == nil {
+ return 0, ErrConnEmpty
+ }
+ if len(p) < 2 {
+ return 0, io.ErrShortBuffer
+ }
+ if t, ok := co.Conn.(*net.TCPConn); ok {
+ n, err = t.Read(p[0:2])
+ if err != nil || n != 2 {
+ return n, err
+ }
+ l, _ := unpackUint16(p[0:2], 0)
+ if l == 0 {
+ return 0, ErrShortRead
+ }
+ if int(l) > len(p) {
+ return int(l), io.ErrShortBuffer
+ }
+ n, err = t.Read(p[:l])
+ if err != nil {
+ return n, err
+ }
+ i := n
+ for i < int(l) {
+ j, err := t.Read(p[i:int(l)])
+ if err != nil {
+ return i, err
+ }
+ i += j
+ }
+ n = i
+ return n, err
+ }
+ // UDP connection
+ n, err = co.Conn.Read(p)
+ if err != nil {
+ return n, err
+ }
+ return n, err
+}
+
+// WriteMsg sends a message throught the connection co.
+// If the message m contains a TSIG record the transaction
+// signature is calculated.
+func (co *Conn) WriteMsg(m *Msg) (err error) {
+ var out []byte
+ if t := m.IsTsig(); t != nil {
+ mac := ""
+ if _, ok := co.TsigSecret[t.Hdr.Name]; !ok {
+ return ErrSecret
+ }
+ out, mac, err = TsigGenerate(m, co.TsigSecret[t.Hdr.Name], co.tsigRequestMAC, false)
+ // Set for the next read, allthough only used in zone transfers
+ co.tsigRequestMAC = mac
+ } else {
+ out, err = m.Pack()
+ }
+ if err != nil {
+ return err
+ }
+ co.t = time.Now()
+ if _, err = co.Write(out); err != nil {
+ return err
+ }
+ return nil
+}
+
+// Write implements the net.Conn Write method.
+func (co *Conn) Write(p []byte) (n int, err error) {
+ if t, ok := co.Conn.(*net.TCPConn); ok {
+ lp := len(p)
+ if lp < 2 {
+ return 0, io.ErrShortBuffer
+ }
+ if lp > MaxMsgSize {
+ return 0, &Error{err: "message too large"}
+ }
+ l := make([]byte, 2, lp+2)
+ l[0], l[1] = packUint16(uint16(lp))
+ p = append(l, p...)
+ n, err := io.Copy(t, bytes.NewReader(p))
+ return int(n), err
+ }
+ n, err = co.Conn.(*net.UDPConn).Write(p)
+ return n, err
+}
+
+// Dial connects to the address on the named network.
+func Dial(network, address string) (conn *Conn, err error) {
+ conn = new(Conn)
+ conn.Conn, err = net.Dial(network, address)
+ if err != nil {
+ return nil, err
+ }
+ return conn, nil
+}
+
+// Dialtimeout acts like Dial but takes a timeout.
+func DialTimeout(network, address string, timeout time.Duration) (conn *Conn, err error) {
+ conn = new(Conn)
+ conn.Conn, err = net.DialTimeout(network, address, timeout)
+ if err != nil {
+ return nil, err
+ }
+ return conn, nil
+}
+
+// Close implements the net.Conn Close method.
+func (co *Conn) Close() error { return co.Conn.Close() }
+
+// LocalAddr implements the net.Conn LocalAddr method.
+func (co *Conn) LocalAddr() net.Addr { return co.Conn.LocalAddr() }
+
+// RemoteAddr implements the net.Conn RemoteAddr method.
+func (co *Conn) RemoteAddr() net.Addr { return co.Conn.RemoteAddr() }
+
+// SetDeadline implements the net.Conn SetDeadline method.
+func (co *Conn) SetDeadline(t time.Time) error { return co.Conn.SetDeadline(t) }
+
+// SetReadDeadline implements the net.Conn SetReadDeadline method.
+func (co *Conn) SetReadDeadline(t time.Time) error { return co.Conn.SetReadDeadline(t) }
+
+// SetWriteDeadline implements the net.Conn SetWriteDeadline method.
+func (co *Conn) SetWriteDeadline(t time.Time) error { return co.Conn.SetWriteDeadline(t) }
diff --git a/Godeps/_workspace/src/github.com/miekg/dns/client_test.go b/Godeps/_workspace/src/github.com/miekg/dns/client_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..2113f3b0e5bbabfdd27eaa90ab94386b0e5f1f97
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/miekg/dns/client_test.go
@@ -0,0 +1,195 @@
+package dns
+
+import (
+ "testing"
+ "time"
+)
+
+func TestClientSync(t *testing.T) {
+ HandleFunc("miek.nl.", HelloServer)
+ defer HandleRemove("miek.nl.")
+
+ s, addrstr, err := RunLocalUDPServer("127.0.0.1:0")
+ if err != nil {
+ t.Fatalf("Unable to run test server: %s", err)
+ }
+ defer s.Shutdown()
+
+ m := new(Msg)
+ m.SetQuestion("miek.nl.", TypeSOA)
+
+ c := new(Client)
+ r, _, e := c.Exchange(m, addrstr)
+ if e != nil {
+ t.Logf("failed to exchange: %s", e.Error())
+ t.Fail()
+ }
+ if r != nil && r.Rcode != RcodeSuccess {
+ t.Log("failed to get an valid answer")
+ t.Fail()
+ t.Logf("%v\n", r)
+ }
+ // And now with plain Exchange().
+ r, e = Exchange(m, addrstr)
+ if e != nil {
+ t.Logf("failed to exchange: %s", e.Error())
+ t.Fail()
+ }
+ if r != nil && r.Rcode != RcodeSuccess {
+ t.Log("failed to get an valid answer")
+ t.Fail()
+ t.Logf("%v\n", r)
+ }
+}
+
+func TestClientEDNS0(t *testing.T) {
+ HandleFunc("miek.nl.", HelloServer)
+ defer HandleRemove("miek.nl.")
+
+ s, addrstr, err := RunLocalUDPServer("127.0.0.1:0")
+ if err != nil {
+ t.Fatalf("Unable to run test server: %s", err)
+ }
+ defer s.Shutdown()
+
+ m := new(Msg)
+ m.SetQuestion("miek.nl.", TypeDNSKEY)
+
+ m.SetEdns0(2048, true)
+
+ c := new(Client)
+ r, _, e := c.Exchange(m, addrstr)
+ if e != nil {
+ t.Logf("failed to exchange: %s", e.Error())
+ t.Fail()
+ }
+
+ if r != nil && r.Rcode != RcodeSuccess {
+ t.Log("failed to get an valid answer")
+ t.Fail()
+ t.Logf("%v\n", r)
+ }
+}
+
+func TestSingleSingleInflight(t *testing.T) {
+ HandleFunc("miek.nl.", HelloServer)
+ defer HandleRemove("miek.nl.")
+
+ s, addrstr, err := RunLocalUDPServer("127.0.0.1:0")
+ if err != nil {
+ t.Fatalf("Unable to run test server: %s", err)
+ }
+ defer s.Shutdown()
+
+ m := new(Msg)
+ m.SetQuestion("miek.nl.", TypeDNSKEY)
+
+ c := new(Client)
+ c.SingleInflight = true
+ nr := 10
+ ch := make(chan time.Duration)
+ for i := 0; i < nr; i++ {
+ go func() {
+ _, rtt, _ := c.Exchange(m, addrstr)
+ ch <- rtt
+ }()
+ }
+ i := 0
+ var first time.Duration
+ // With inflight *all* rtt are identical, and by doing actual lookups
+ // the changes that this is a coincidence is small.
+Loop:
+ for {
+ select {
+ case rtt := <-ch:
+ if i == 0 {
+ first = rtt
+ } else {
+ if first != rtt {
+ t.Log("all rtts should be equal")
+ t.Fail()
+ }
+ }
+ i++
+ if i == 10 {
+ break Loop
+ }
+ }
+ }
+}
+
+/*
+func TestClientTsigAXFR(t *testing.T) {
+ m := new(Msg)
+ m.SetAxfr("example.nl.")
+ m.SetTsig("axfr.", HmacMD5, 300, time.Now().Unix())
+
+ tr := new(Transfer)
+ tr.TsigSecret = map[string]string{"axfr.": "so6ZGir4GPAqINNh9U5c3A=="}
+
+ if a, err := tr.In(m, "176.58.119.54:53"); err != nil {
+ t.Log("failed to setup axfr: " + err.Error())
+ t.Fatal()
+ } else {
+ for ex := range a {
+ if ex.Error != nil {
+ t.Logf("error %s\n", ex.Error.Error())
+ t.Fail()
+ break
+ }
+ for _, rr := range ex.RR {
+ t.Logf("%s\n", rr.String())
+ }
+ }
+ }
+}
+
+func TestClientAXFRMultipleEnvelopes(t *testing.T) {
+ m := new(Msg)
+ m.SetAxfr("nlnetlabs.nl.")
+
+ tr := new(Transfer)
+ if a, err := tr.In(m, "213.154.224.1:53"); err != nil {
+ t.Log("Failed to setup axfr" + err.Error())
+ t.Fail()
+ return
+ } else {
+ for ex := range a {
+ if ex.Error != nil {
+ t.Logf("Error %s\n", ex.Error.Error())
+ t.Fail()
+ break
+ }
+ }
+ }
+}
+*/
+
+// ExampleUpdateLeaseTSIG shows how to update a lease signed with TSIG.
+func ExampleUpdateLeaseTSIG(t *testing.T) {
+ m := new(Msg)
+ m.SetUpdate("t.local.ip6.io.")
+ rr, _ := NewRR("t.local.ip6.io. 30 A 127.0.0.1")
+ rrs := make([]RR, 1)
+ rrs[0] = rr
+ m.Insert(rrs)
+
+ lease_rr := new(OPT)
+ lease_rr.Hdr.Name = "."
+ lease_rr.Hdr.Rrtype = TypeOPT
+ e := new(EDNS0_UL)
+ e.Code = EDNS0UL
+ e.Lease = 120
+ lease_rr.Option = append(lease_rr.Option, e)
+ m.Extra = append(m.Extra, lease_rr)
+
+ c := new(Client)
+ m.SetTsig("polvi.", HmacMD5, 300, time.Now().Unix())
+ c.TsigSecret = map[string]string{"polvi.": "pRZgBrBvI4NAHZYhxmhs/Q=="}
+
+ _, _, err := c.Exchange(m, "127.0.0.1:53")
+ if err != nil {
+ t.Log(err.Error())
+ t.Fail()
+ }
+}
diff --git a/Godeps/_workspace/src/github.com/miekg/dns/clientconfig.go b/Godeps/_workspace/src/github.com/miekg/dns/clientconfig.go
new file mode 100644
index 0000000000000000000000000000000000000000..87cf89618622ff970105f6a08ff00d27e55436a7
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/miekg/dns/clientconfig.go
@@ -0,0 +1,94 @@
+package dns
+
+import (
+ "bufio"
+ "os"
+ "strconv"
+ "strings"
+)
+
+// Wraps the contents of the /etc/resolv.conf.
+type ClientConfig struct {
+ Servers []string // servers to use
+ Search []string // suffixes to append to local name
+ Port string // what port to use
+ Ndots int // number of dots in name to trigger absolute lookup
+ Timeout int // seconds before giving up on packet
+ Attempts int // lost packets before giving up on server, not used in the package dns
+}
+
+// ClientConfigFromFile parses a resolv.conf(5) like file and returns
+// a *ClientConfig.
+func ClientConfigFromFile(resolvconf string) (*ClientConfig, error) {
+ file, err := os.Open(resolvconf)
+ if err != nil {
+ return nil, err
+ }
+ defer file.Close()
+ c := new(ClientConfig)
+ b := bufio.NewReader(file)
+ c.Servers = make([]string, 0)
+ c.Search = make([]string, 0)
+ c.Port = "53"
+ c.Ndots = 1
+ c.Timeout = 5
+ c.Attempts = 2
+ for line, ok := b.ReadString('\n'); ok == nil; line, ok = b.ReadString('\n') {
+ f := strings.Fields(line)
+ if len(f) < 1 {
+ continue
+ }
+ switch f[0] {
+ case "nameserver": // add one name server
+ if len(f) > 1 {
+ // One more check: make sure server name is
+ // just an IP address. Otherwise we need DNS
+ // to look it up.
+ name := f[1]
+ c.Servers = append(c.Servers, name)
+ }
+
+ case "domain": // set search path to just this domain
+ if len(f) > 1 {
+ c.Search = make([]string, 1)
+ c.Search[0] = f[1]
+ } else {
+ c.Search = make([]string, 0)
+ }
+
+ case "search": // set search path to given servers
+ c.Search = make([]string, len(f)-1)
+ for i := 0; i < len(c.Search); i++ {
+ c.Search[i] = f[i+1]
+ }
+
+ case "options": // magic options
+ for i := 1; i < len(f); i++ {
+ s := f[i]
+ switch {
+ case len(s) >= 6 && s[:6] == "ndots:":
+ n, _ := strconv.Atoi(s[6:])
+ if n < 1 {
+ n = 1
+ }
+ c.Ndots = n
+ case len(s) >= 8 && s[:8] == "timeout:":
+ n, _ := strconv.Atoi(s[8:])
+ if n < 1 {
+ n = 1
+ }
+ c.Timeout = n
+ case len(s) >= 8 && s[:9] == "attempts:":
+ n, _ := strconv.Atoi(s[9:])
+ if n < 1 {
+ n = 1
+ }
+ c.Attempts = n
+ case s == "rotate":
+ /* not imp */
+ }
+ }
+ }
+ }
+ return c, nil
+}
diff --git a/Godeps/_workspace/src/github.com/miekg/dns/defaults.go b/Godeps/_workspace/src/github.com/miekg/dns/defaults.go
new file mode 100644
index 0000000000000000000000000000000000000000..0c8fa9c84b6b3cc80db07b2bb0db5ffca7069294
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/miekg/dns/defaults.go
@@ -0,0 +1,242 @@
+package dns
+
+import (
+ "errors"
+ "net"
+ "strconv"
+)
+
+const hexDigit = "0123456789abcdef"
+
+// Everything is assumed in ClassINET.
+
+// SetReply creates a reply message from a request message.
+func (dns *Msg) SetReply(request *Msg) *Msg {
+ dns.Id = request.Id
+ dns.RecursionDesired = request.RecursionDesired // Copy rd bit
+ dns.Response = true
+ dns.Opcode = OpcodeQuery
+ dns.Rcode = RcodeSuccess
+ if len(request.Question) > 0 {
+ dns.Question = make([]Question, 1)
+ dns.Question[0] = request.Question[0]
+ }
+ return dns
+}
+
+// SetQuestion creates a question message.
+func (dns *Msg) SetQuestion(z string, t uint16) *Msg {
+ dns.Id = Id()
+ dns.RecursionDesired = true
+ dns.Question = make([]Question, 1)
+ dns.Question[0] = Question{z, t, ClassINET}
+ return dns
+}
+
+// SetNotify creates a notify message.
+func (dns *Msg) SetNotify(z string) *Msg {
+ dns.Opcode = OpcodeNotify
+ dns.Authoritative = true
+ dns.Id = Id()
+ dns.Question = make([]Question, 1)
+ dns.Question[0] = Question{z, TypeSOA, ClassINET}
+ return dns
+}
+
+// SetRcode creates an error message suitable for the request.
+func (dns *Msg) SetRcode(request *Msg, rcode int) *Msg {
+ dns.SetReply(request)
+ dns.Rcode = rcode
+ return dns
+}
+
+// SetRcodeFormatError creates a message with FormError set.
+func (dns *Msg) SetRcodeFormatError(request *Msg) *Msg {
+ dns.Rcode = RcodeFormatError
+ dns.Opcode = OpcodeQuery
+ dns.Response = true
+ dns.Authoritative = false
+ dns.Id = request.Id
+ return dns
+}
+
+// SetUpdate makes the message a dynamic update message. It
+// sets the ZONE section to: z, TypeSOA, ClassINET.
+func (dns *Msg) SetUpdate(z string) *Msg {
+ dns.Id = Id()
+ dns.Response = false
+ dns.Opcode = OpcodeUpdate
+ dns.Compress = false // BIND9 cannot handle compression
+ dns.Question = make([]Question, 1)
+ dns.Question[0] = Question{z, TypeSOA, ClassINET}
+ return dns
+}
+
+// SetIxfr creates message for requesting an IXFR.
+func (dns *Msg) SetIxfr(z string, serial uint32) *Msg {
+ dns.Id = Id()
+ dns.Question = make([]Question, 1)
+ dns.Ns = make([]RR, 1)
+ s := new(SOA)
+ s.Hdr = RR_Header{z, TypeSOA, ClassINET, defaultTtl, 0}
+ s.Serial = serial
+ dns.Question[0] = Question{z, TypeIXFR, ClassINET}
+ dns.Ns[0] = s
+ return dns
+}
+
+// SetAxfr creates message for requesting an AXFR.
+func (dns *Msg) SetAxfr(z string) *Msg {
+ dns.Id = Id()
+ dns.Question = make([]Question, 1)
+ dns.Question[0] = Question{z, TypeAXFR, ClassINET}
+ return dns
+}
+
+// SetTsig appends a TSIG RR to the message.
+// This is only a skeleton TSIG RR that is added as the last RR in the
+// additional section. The Tsig is calculated when the message is being send.
+func (dns *Msg) SetTsig(z, algo string, fudge, timesigned int64) *Msg {
+ t := new(TSIG)
+ t.Hdr = RR_Header{z, TypeTSIG, ClassANY, 0, 0}
+ t.Algorithm = algo
+ t.Fudge = 300
+ t.TimeSigned = uint64(timesigned)
+ t.OrigId = dns.Id
+ dns.Extra = append(dns.Extra, t)
+ return dns
+}
+
+// SetEdns0 appends a EDNS0 OPT RR to the message.
+// TSIG should always the last RR in a message.
+func (dns *Msg) SetEdns0(udpsize uint16, do bool) *Msg {
+ e := new(OPT)
+ e.Hdr.Name = "."
+ e.Hdr.Rrtype = TypeOPT
+ e.SetUDPSize(udpsize)
+ if do {
+ e.SetDo()
+ }
+ dns.Extra = append(dns.Extra, e)
+ return dns
+}
+
+// IsTsig checks if the message has a TSIG record as the last record
+// in the additional section. It returns the TSIG record found or nil.
+func (dns *Msg) IsTsig() *TSIG {
+ if len(dns.Extra) > 0 {
+ if dns.Extra[len(dns.Extra)-1].Header().Rrtype == TypeTSIG {
+ return dns.Extra[len(dns.Extra)-1].(*TSIG)
+ }
+ }
+ return nil
+}
+
+// IsEdns0 checks if the message has a EDNS0 (OPT) record, any EDNS0
+// record in the additional section will do. It returns the OPT record
+// found or nil.
+func (dns *Msg) IsEdns0() *OPT {
+ for _, r := range dns.Extra {
+ if r.Header().Rrtype == TypeOPT {
+ return r.(*OPT)
+ }
+ }
+ return nil
+}
+
+// IsDomainName checks if s is a valid domainname, it returns
+// the number of labels and true, when a domain name is valid.
+// Note that non fully qualified domain name is considered valid, in this case the
+// last label is counted in the number of labels.
+// When false is returned the number of labels is not defined.
+func IsDomainName(s string) (labels int, ok bool) {
+ _, labels, err := packDomainName(s, nil, 0, nil, false)
+ return labels, err == nil
+}
+
+// IsSubDomain checks if child is indeed a child of the parent. Both child and
+// parent are *not* downcased before doing the comparison.
+func IsSubDomain(parent, child string) bool {
+ // Entire child is contained in parent
+ return CompareDomainName(parent, child) == CountLabel(parent)
+}
+
+// IsMsg sanity checks buf and returns an error if it isn't a valid DNS packet.
+// The checking is performed on the binary payload.
+func IsMsg(buf []byte) error {
+ // Header
+ if len(buf) < 12 {
+ return errors.New("dns: bad message header")
+ }
+ // Header: Opcode
+ // TODO(miek): more checks here, e.g. check all header bits.
+ return nil
+}
+
+// IsFqdn checks if a domain name is fully qualified.
+func IsFqdn(s string) bool {
+ l := len(s)
+ if l == 0 {
+ return false
+ }
+ return s[l-1] == '.'
+}
+
+// Fqdns return the fully qualified domain name from s.
+// If s is already fully qualified, it behaves as the identity function.
+func Fqdn(s string) string {
+ if IsFqdn(s) {
+ return s
+ }
+ return s + "."
+}
+
+// Copied from the official Go code.
+
+// ReverseAddr returns the in-addr.arpa. or ip6.arpa. hostname of the IP
+// address suitable for reverse DNS (PTR) record lookups or an error if it fails
+// to parse the IP address.
+func ReverseAddr(addr string) (arpa string, err error) {
+ ip := net.ParseIP(addr)
+ if ip == nil {
+ return "", &Error{err: "unrecognized address: " + addr}
+ }
+ if ip.To4() != nil {
+ return strconv.Itoa(int(ip[15])) + "." + strconv.Itoa(int(ip[14])) + "." + strconv.Itoa(int(ip[13])) + "." +
+ strconv.Itoa(int(ip[12])) + ".in-addr.arpa.", nil
+ }
+ // Must be IPv6
+ buf := make([]byte, 0, len(ip)*4+len("ip6.arpa."))
+ // Add it, in reverse, to the buffer
+ for i := len(ip) - 1; i >= 0; i-- {
+ v := ip[i]
+ buf = append(buf, hexDigit[v&0xF])
+ buf = append(buf, '.')
+ buf = append(buf, hexDigit[v>>4])
+ buf = append(buf, '.')
+ }
+ // Append "ip6.arpa." and return (buf already has the final .)
+ buf = append(buf, "ip6.arpa."...)
+ return string(buf), nil
+}
+
+// String returns the string representation for the type t.
+func (t Type) String() string {
+ if t1, ok := TypeToString[uint16(t)]; ok {
+ return t1
+ }
+ return "TYPE" + strconv.Itoa(int(t))
+}
+
+// String returns the string representation for the class c.
+func (c Class) String() string {
+ if c1, ok := ClassToString[uint16(c)]; ok {
+ return c1
+ }
+ return "CLASS" + strconv.Itoa(int(c))
+}
+
+// String returns the string representation for the name n.
+func (n Name) String() string {
+ return sprintName(string(n))
+}
diff --git a/Godeps/_workspace/src/github.com/miekg/dns/dns.go b/Godeps/_workspace/src/github.com/miekg/dns/dns.go
new file mode 100644
index 0000000000000000000000000000000000000000..7540c0d5bca1cfeb462df8cbaa0be046b3e8400c
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/miekg/dns/dns.go
@@ -0,0 +1,193 @@
+// Package dns implements a full featured interface to the Domain Name System.
+// Server- and client-side programming is supported.
+// The package allows complete control over what is send out to the DNS. The package
+// API follows the less-is-more principle, by presenting a small, clean interface.
+//
+// The package dns supports (asynchronous) querying/replying, incoming/outgoing zone transfers,
+// TSIG, EDNS0, dynamic updates, notifies and DNSSEC validation/signing.
+// Note that domain names MUST be fully qualified, before sending them, unqualified
+// names in a message will result in a packing failure.
+//
+// Resource records are native types. They are not stored in wire format.
+// Basic usage pattern for creating a new resource record:
+//
+// r := new(dns.MX)
+// r.Hdr = dns.RR_Header{Name: "miek.nl.", Rrtype: dns.TypeMX, Class: dns.ClassINET, Ttl: 3600}
+// r.Preference = 10
+// r.Mx = "mx.miek.nl."
+//
+// Or directly from a string:
+//
+// mx, err := dns.NewRR("miek.nl. 3600 IN MX 10 mx.miek.nl.")
+//
+// Or when the default TTL (3600) and class (IN) suit you:
+//
+// mx, err := dns.NewRR("miek.nl. MX 10 mx.miek.nl.")
+//
+// Or even:
+//
+// mx, err := dns.NewRR("$ORIGIN nl.\nmiek 1H IN MX 10 mx.miek")
+//
+// In the DNS messages are exchanged, these messages contain resource
+// records (sets). Use pattern for creating a message:
+//
+// m := new(dns.Msg)
+// m.SetQuestion("miek.nl.", dns.TypeMX)
+//
+// Or when not certain if the domain name is fully qualified:
+//
+// m.SetQuestion(dns.Fqdn("miek.nl"), dns.TypeMX)
+//
+// The message m is now a message with the question section set to ask
+// the MX records for the miek.nl. zone.
+//
+// The following is slightly more verbose, but more flexible:
+//
+// m1 := new(dns.Msg)
+// m1.Id = dns.Id()
+// m1.RecursionDesired = true
+// m1.Question = make([]dns.Question, 1)
+// m1.Question[0] = dns.Question{"miek.nl.", dns.TypeMX, dns.ClassINET}
+//
+// After creating a message it can be send.
+// Basic use pattern for synchronous querying the DNS at a
+// server configured on 127.0.0.1 and port 53:
+//
+// c := new(dns.Client)
+// in, rtt, err := c.Exchange(m1, "127.0.0.1:53")
+//
+// Suppressing
+// multiple outstanding queries (with the same question, type and class) is as easy as setting:
+//
+// c.SingleInflight = true
+//
+// If these "advanced" features are not needed, a simple UDP query can be send,
+// with:
+//
+// in, err := dns.Exchange(m1, "127.0.0.1:53")
+//
+// When this functions returns you will get dns message. A dns message consists
+// out of four sections.
+// The question section: in.Question, the answer section: in.Answer,
+// the authority section: in.Ns and the additional section: in.Extra.
+//
+// Each of these sections (except the Question section) contain a []RR. Basic
+// use pattern for accessing the rdata of a TXT RR as the first RR in
+// the Answer section:
+//
+// if t, ok := in.Answer[0].(*dns.TXT); ok {
+// // do something with t.Txt
+// }
+//
+// Domain Name and TXT Character String Representations
+//
+// Both domain names and TXT character strings are converted to presentation
+// form both when unpacked and when converted to strings.
+//
+// For TXT character strings, tabs, carriage returns and line feeds will be
+// converted to \t, \r and \n respectively. Back slashes and quotations marks
+// will be escaped. Bytes below 32 and above 127 will be converted to \DDD
+// form.
+//
+// For domain names, in addition to the above rules brackets, periods,
+// spaces, semicolons and the at symbol are escaped.
+package dns
+
+import (
+ "strconv"
+)
+
+const (
+ year68 = 1 << 31 // For RFC1982 (Serial Arithmetic) calculations in 32 bits.
+ DefaultMsgSize = 4096 // Standard default for larger than 512 bytes.
+ MinMsgSize = 512 // Minimal size of a DNS packet.
+ MaxMsgSize = 65536 // Largest possible DNS packet.
+ defaultTtl = 3600 // Default TTL.
+)
+
+// Error represents a DNS error
+type Error struct{ err string }
+
+func (e *Error) Error() string {
+ if e == nil {
+ return "dns: <nil>"
+ }
+ return "dns: " + e.err
+}
+
+// An RR represents a resource record.
+type RR interface {
+ // Header returns the header of an resource record. The header contains
+ // everything up to the rdata.
+ Header() *RR_Header
+ // String returns the text representation of the resource record.
+ String() string
+ // copy returns a copy of the RR
+ copy() RR
+ // len returns the length (in octects) of the uncompressed RR in wire format.
+ len() int
+}
+
+// DNS resource records.
+// There are many types of RRs,
+// but they all share the same header.
+type RR_Header struct {
+ Name string `dns:"cdomain-name"`
+ Rrtype uint16
+ Class uint16
+ Ttl uint32
+ Rdlength uint16 // length of data after header
+}
+
+func (h *RR_Header) Header() *RR_Header { return h }
+
+// Just to imlement the RR interface
+func (h *RR_Header) copy() RR { return nil }
+
+func (h *RR_Header) copyHeader() *RR_Header {
+ r := new(RR_Header)
+ r.Name = h.Name
+ r.Rrtype = h.Rrtype
+ r.Class = h.Class
+ r.Ttl = h.Ttl
+ r.Rdlength = h.Rdlength
+ return r
+}
+
+func (h *RR_Header) String() string {
+ var s string
+
+ if h.Rrtype == TypeOPT {
+ s = ";"
+ // and maybe other things
+ }
+
+ s += sprintName(h.Name) + "\t"
+ s += strconv.FormatInt(int64(h.Ttl), 10) + "\t"
+ s += Class(h.Class).String() + "\t"
+ s += Type(h.Rrtype).String() + "\t"
+ return s
+}
+
+func (h *RR_Header) len() int {
+ l := len(h.Name) + 1
+ l += 10 // rrtype(2) + class(2) + ttl(4) + rdlength(2)
+ return l
+}
+
+// ToRFC3597 converts a known RR to the unknown RR representation
+// from RFC 3597.
+func (rr *RFC3597) ToRFC3597(r RR) error {
+ buf := make([]byte, r.len()*2)
+ off, err := PackStruct(r, buf, 0)
+ if err != nil {
+ return err
+ }
+ buf = buf[:off]
+ rawSetRdlength(buf, 0, off)
+ _, err = UnpackStruct(rr, buf, 0)
+ if err != nil {
+ return err
+ }
+ return nil
+}
diff --git a/Godeps/_workspace/src/github.com/miekg/dns/dns_test.go b/Godeps/_workspace/src/github.com/miekg/dns/dns_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..16c86f474f176859d51deee16023377691e8c3a4
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/miekg/dns/dns_test.go
@@ -0,0 +1,511 @@
+package dns
+
+import (
+ "encoding/hex"
+ "net"
+ "testing"
+)
+
+func TestPackUnpack(t *testing.T) {
+ out := new(Msg)
+ out.Answer = make([]RR, 1)
+ key := new(DNSKEY)
+ key = &DNSKEY{Flags: 257, Protocol: 3, Algorithm: RSASHA1}
+ key.Hdr = RR_Header{Name: "miek.nl.", Rrtype: TypeDNSKEY, Class: ClassINET, Ttl: 3600}
+ key.PublicKey = "AwEAAaHIwpx3w4VHKi6i1LHnTaWeHCL154Jug0Rtc9ji5qwPXpBo6A5sRv7cSsPQKPIwxLpyCrbJ4mr2L0EPOdvP6z6YfljK2ZmTbogU9aSU2fiq/4wjxbdkLyoDVgtO+JsxNN4bjr4WcWhsmk1Hg93FV9ZpkWb0Tbad8DFqNDzr//kZ"
+
+ out.Answer[0] = key
+ msg, err := out.Pack()
+ if err != nil {
+ t.Log("failed to pack msg with DNSKEY")
+ t.Fail()
+ }
+ in := new(Msg)
+ if in.Unpack(msg) != nil {
+ t.Log("failed to unpack msg with DNSKEY")
+ t.Fail()
+ }
+
+ sig := new(RRSIG)
+ sig = &RRSIG{TypeCovered: TypeDNSKEY, Algorithm: RSASHA1, Labels: 2,
+ OrigTtl: 3600, Expiration: 4000, Inception: 4000, KeyTag: 34641, SignerName: "miek.nl.",
+ Signature: "AwEAAaHIwpx3w4VHKi6i1LHnTaWeHCL154Jug0Rtc9ji5qwPXpBo6A5sRv7cSsPQKPIwxLpyCrbJ4mr2L0EPOdvP6z6YfljK2ZmTbogU9aSU2fiq/4wjxbdkLyoDVgtO+JsxNN4bjr4WcWhsmk1Hg93FV9ZpkWb0Tbad8DFqNDzr//kZ"}
+ sig.Hdr = RR_Header{Name: "miek.nl.", Rrtype: TypeRRSIG, Class: ClassINET, Ttl: 3600}
+
+ out.Answer[0] = sig
+ msg, err = out.Pack()
+ if err != nil {
+ t.Log("failed to pack msg with RRSIG")
+ t.Fail()
+ }
+
+ if in.Unpack(msg) != nil {
+ t.Log("failed to unpack msg with RRSIG")
+ t.Fail()
+ }
+}
+
+func TestPackUnpack2(t *testing.T) {
+ m := new(Msg)
+ m.Extra = make([]RR, 1)
+ m.Answer = make([]RR, 1)
+ dom := "miek.nl."
+ rr := new(A)
+ rr.Hdr = RR_Header{Name: dom, Rrtype: TypeA, Class: ClassINET, Ttl: 0}
+ rr.A = net.IPv4(127, 0, 0, 1)
+
+ x := new(TXT)
+ x.Hdr = RR_Header{Name: dom, Rrtype: TypeTXT, Class: ClassINET, Ttl: 0}
+ x.Txt = []string{"heelalaollo"}
+
+ m.Extra[0] = x
+ m.Answer[0] = rr
+ _, err := m.Pack()
+ if err != nil {
+ t.Log("Packing failed: " + err.Error())
+ t.Fail()
+ return
+ }
+}
+
+func TestPackUnpack3(t *testing.T) {
+ m := new(Msg)
+ m.Extra = make([]RR, 2)
+ m.Answer = make([]RR, 1)
+ dom := "miek.nl."
+ rr := new(A)
+ rr.Hdr = RR_Header{Name: dom, Rrtype: TypeA, Class: ClassINET, Ttl: 0}
+ rr.A = net.IPv4(127, 0, 0, 1)
+
+ x1 := new(TXT)
+ x1.Hdr = RR_Header{Name: dom, Rrtype: TypeTXT, Class: ClassINET, Ttl: 0}
+ x1.Txt = []string{}
+
+ x2 := new(TXT)
+ x2.Hdr = RR_Header{Name: dom, Rrtype: TypeTXT, Class: ClassINET, Ttl: 0}
+ x2.Txt = []string{"heelalaollo"}
+
+ m.Extra[0] = x1
+ m.Extra[1] = x2
+ m.Answer[0] = rr
+ b, err := m.Pack()
+ if err != nil {
+ t.Log("packing failed: " + err.Error())
+ t.Fail()
+ return
+ }
+
+ var unpackMsg Msg
+ err = unpackMsg.Unpack(b)
+ if err != nil {
+ t.Log("unpacking failed")
+ t.Fail()
+ return
+ }
+}
+
+func TestBailiwick(t *testing.T) {
+ yes := map[string]string{
+ "miek.nl": "ns.miek.nl",
+ ".": "miek.nl",
+ }
+ for parent, child := range yes {
+ if !IsSubDomain(parent, child) {
+ t.Logf("%s should be child of %s\n", child, parent)
+ t.Logf("comparelabels %d", CompareDomainName(parent, child))
+ t.Logf("lenlabels %d %d", CountLabel(parent), CountLabel(child))
+ t.Fail()
+ }
+ }
+ no := map[string]string{
+ "www.miek.nl": "ns.miek.nl",
+ "m\\.iek.nl": "ns.miek.nl",
+ "w\\.iek.nl": "w.iek.nl",
+ "p\\\\.iek.nl": "ns.p.iek.nl", // p\\.iek.nl , literal \ in domain name
+ "miek.nl": ".",
+ }
+ for parent, child := range no {
+ if IsSubDomain(parent, child) {
+ t.Logf("%s should not be child of %s\n", child, parent)
+ t.Logf("comparelabels %d", CompareDomainName(parent, child))
+ t.Logf("lenlabels %d %d", CountLabel(parent), CountLabel(child))
+ t.Fail()
+ }
+ }
+}
+
+func TestPack(t *testing.T) {
+ rr := []string{"US. 86400 IN NSEC 0-.us. NS SOA RRSIG NSEC DNSKEY TYPE65534"}
+ m := new(Msg)
+ var err error
+ m.Answer = make([]RR, 1)
+ for _, r := range rr {
+ m.Answer[0], err = NewRR(r)
+ if err != nil {
+ t.Logf("failed to create RR: %s\n", err.Error())
+ t.Fail()
+ continue
+ }
+ if _, err := m.Pack(); err != nil {
+ t.Logf("packing failed: %s\n", err.Error())
+ t.Fail()
+ }
+ }
+ x := new(Msg)
+ ns, _ := NewRR("pool.ntp.org. 390 IN NS a.ntpns.org")
+ ns.(*NS).Ns = "a.ntpns.org"
+ x.Ns = append(m.Ns, ns)
+ x.Ns = append(m.Ns, ns)
+ x.Ns = append(m.Ns, ns)
+ // This crashes due to the fact the a.ntpns.org isn't a FQDN
+ // How to recover() from a remove panic()?
+ if _, err := x.Pack(); err == nil {
+ t.Log("packing should fail")
+ t.Fail()
+ }
+ x.Answer = make([]RR, 1)
+ x.Answer[0], err = NewRR(rr[0])
+ if _, err := x.Pack(); err == nil {
+ t.Log("packing should fail")
+ t.Fail()
+ }
+ x.Question = make([]Question, 1)
+ x.Question[0] = Question{";sd#eddddsé›↙èµÂ‘℅∥↙xzztsestxssweewwsssstx@s@Z嵌e@cn.pool.ntp.org.", TypeA, ClassINET}
+ if _, err := x.Pack(); err == nil {
+ t.Log("packing should fail")
+ t.Fail()
+ }
+}
+
+func TestPackNAPTR(t *testing.T) {
+ for _, n := range []string{
+ `apple.com. IN NAPTR 100 50 "se" "SIP+D2U" "" _sip._udp.apple.com.`,
+ `apple.com. IN NAPTR 90 50 "se" "SIP+D2T" "" _sip._tcp.apple.com.`,
+ `apple.com. IN NAPTR 50 50 "se" "SIPS+D2T" "" _sips._tcp.apple.com.`,
+ } {
+ rr, _ := NewRR(n)
+ msg := make([]byte, rr.len())
+ if off, err := PackRR(rr, msg, 0, nil, false); err != nil {
+ t.Logf("packing failed: %s", err.Error())
+ t.Logf("length %d, need more than %d\n", rr.len(), off)
+ t.Fail()
+ } else {
+ t.Logf("buf size needed: %d\n", off)
+ }
+ }
+}
+
+func TestCompressLength(t *testing.T) {
+ m := new(Msg)
+ m.SetQuestion("miek.nl", TypeMX)
+ ul := m.Len()
+ m.Compress = true
+ if ul != m.Len() {
+ t.Fatalf("should be equal")
+ }
+}
+
+// Does the predicted length match final packed length?
+func TestMsgCompressLength(t *testing.T) {
+ makeMsg := func(question string, ans, ns, e []RR) *Msg {
+ msg := new(Msg)
+ msg.SetQuestion(Fqdn(question), TypeANY)
+ msg.Answer = append(msg.Answer, ans...)
+ msg.Ns = append(msg.Ns, ns...)
+ msg.Extra = append(msg.Extra, e...)
+ msg.Compress = true
+ return msg
+ }
+
+ name1 := "12345678901234567890123456789012345.12345678.123."
+ rrA, _ := NewRR(name1 + " 3600 IN A 192.0.2.1")
+ rrMx, _ := NewRR(name1 + " 3600 IN MX 10 " + name1)
+ tests := []*Msg{
+ makeMsg(name1, []RR{rrA}, nil, nil),
+ makeMsg(name1, []RR{rrMx, rrMx}, nil, nil)}
+
+ for _, msg := range tests {
+ predicted := msg.Len()
+ buf, err := msg.Pack()
+ if err != nil {
+ t.Error(err)
+ t.Fail()
+ }
+ if predicted < len(buf) {
+ t.Errorf("predicted compressed length is wrong: predicted %s (len=%d) %d, actual %d\n",
+ msg.Question[0].Name, len(msg.Answer), predicted, len(buf))
+ t.Fail()
+ }
+ }
+}
+
+func TestMsgLength(t *testing.T) {
+ makeMsg := func(question string, ans, ns, e []RR) *Msg {
+ msg := new(Msg)
+ msg.SetQuestion(Fqdn(question), TypeANY)
+ msg.Answer = append(msg.Answer, ans...)
+ msg.Ns = append(msg.Ns, ns...)
+ msg.Extra = append(msg.Extra, e...)
+ return msg
+ }
+
+ name1 := "12345678901234567890123456789012345.12345678.123."
+ rrA, _ := NewRR(name1 + " 3600 IN A 192.0.2.1")
+ rrMx, _ := NewRR(name1 + " 3600 IN MX 10 " + name1)
+ tests := []*Msg{
+ makeMsg(name1, []RR{rrA}, nil, nil),
+ makeMsg(name1, []RR{rrMx, rrMx}, nil, nil)}
+
+ for _, msg := range tests {
+ predicted := msg.Len()
+ buf, err := msg.Pack()
+ if err != nil {
+ t.Error(err)
+ t.Fail()
+ }
+ if predicted < len(buf) {
+ t.Errorf("predicted length is wrong: predicted %s (len=%d), actual %d\n",
+ msg.Question[0].Name, predicted, len(buf))
+ t.Fail()
+ }
+ }
+}
+
+func TestMsgLength2(t *testing.T) {
+ // Serialized replies
+ var testMessages = []string{
+ // google.com. IN A?
+ "064e81800001000b0004000506676f6f676c6503636f6d0000010001c00c00010001000000050004adc22986c00c00010001000000050004adc22987c00c00010001000000050004adc22988c00c00010001000000050004adc22989c00c00010001000000050004adc2298ec00c00010001000000050004adc22980c00c00010001000000050004adc22981c00c00010001000000050004adc22982c00c00010001000000050004adc22983c00c00010001000000050004adc22984c00c00010001000000050004adc22985c00c00020001000000050006036e7331c00cc00c00020001000000050006036e7332c00cc00c00020001000000050006036e7333c00cc00c00020001000000050006036e7334c00cc0d800010001000000050004d8ef200ac0ea00010001000000050004d8ef220ac0fc00010001000000050004d8ef240ac10e00010001000000050004d8ef260a0000290500000000050000",
+ // amazon.com. IN A? (reply has no EDNS0 record)
+ // TODO(miek): this one is off-by-one, need to find out why
+ //"6de1818000010004000a000806616d617a6f6e03636f6d0000010001c00c000100010000000500044815c2d4c00c000100010000000500044815d7e8c00c00010001000000050004b02062a6c00c00010001000000050004cdfbf236c00c000200010000000500140570646e733408756c747261646e73036f726700c00c000200010000000500150570646e733508756c747261646e7304696e666f00c00c000200010000000500160570646e733608756c747261646e7302636f02756b00c00c00020001000000050014036e7331037033310664796e656374036e657400c00c00020001000000050006036e7332c0cfc00c00020001000000050006036e7333c0cfc00c00020001000000050006036e7334c0cfc00c000200010000000500110570646e733108756c747261646e73c0dac00c000200010000000500080570646e7332c127c00c000200010000000500080570646e7333c06ec0cb00010001000000050004d04e461fc0eb00010001000000050004cc0dfa1fc0fd00010001000000050004d04e471fc10f00010001000000050004cc0dfb1fc12100010001000000050004cc4a6c01c121001c000100000005001020010502f3ff00000000000000000001c13e00010001000000050004cc4a6d01c13e001c0001000000050010261000a1101400000000000000000001",
+ // yahoo.com. IN A?
+ "fc2d81800001000300070008057961686f6f03636f6d0000010001c00c00010001000000050004628afd6dc00c00010001000000050004628bb718c00c00010001000000050004cebe242dc00c00020001000000050006036e7336c00cc00c00020001000000050006036e7338c00cc00c00020001000000050006036e7331c00cc00c00020001000000050006036e7332c00cc00c00020001000000050006036e7333c00cc00c00020001000000050006036e7334c00cc00c00020001000000050006036e7335c00cc07b0001000100000005000444b48310c08d00010001000000050004448eff10c09f00010001000000050004cb54dd35c0b100010001000000050004628a0b9dc0c30001000100000005000477a0f77cc05700010001000000050004ca2bdfaac06900010001000000050004caa568160000290500000000050000",
+ // microsoft.com. IN A?
+ "f4368180000100020005000b096d6963726f736f667403636f6d0000010001c00c0001000100000005000440040b25c00c0001000100000005000441373ac9c00c0002000100000005000e036e7331046d736674036e657400c00c00020001000000050006036e7332c04fc00c00020001000000050006036e7333c04fc00c00020001000000050006036e7334c04fc00c00020001000000050006036e7335c04fc04b000100010000000500044137253ec04b001c00010000000500102a010111200500000000000000010001c0650001000100000005000440043badc065001c00010000000500102a010111200600060000000000010001c07700010001000000050004d5c7b435c077001c00010000000500102a010111202000000000000000010001c08900010001000000050004cf2e4bfec089001c00010000000500102404f800200300000000000000010001c09b000100010000000500044137e28cc09b001c00010000000500102a010111200f000100000000000100010000290500000000050000",
+ // google.com. IN MX?
+ "724b8180000100050004000b06676f6f676c6503636f6d00000f0001c00c000f000100000005000c000a056173706d78016cc00cc00c000f0001000000050009001404616c7431c02ac00c000f0001000000050009001e04616c7432c02ac00c000f0001000000050009002804616c7433c02ac00c000f0001000000050009003204616c7434c02ac00c00020001000000050006036e7332c00cc00c00020001000000050006036e7333c00cc00c00020001000000050006036e7334c00cc00c00020001000000050006036e7331c00cc02a00010001000000050004adc2421bc02a001c00010000000500102a00145040080c01000000000000001bc04200010001000000050004adc2461bc05700010001000000050004adc2451bc06c000100010000000500044a7d8f1bc081000100010000000500044a7d191bc0ca00010001000000050004d8ef200ac09400010001000000050004d8ef220ac0a600010001000000050004d8ef240ac0b800010001000000050004d8ef260a0000290500000000050000",
+ // reddit.com. IN A?
+ "12b98180000100080000000c0672656464697403636f6d0000020001c00c0002000100000005000f046175733204616b616d036e657400c00c000200010000000500070475736534c02dc00c000200010000000500070475737733c02dc00c000200010000000500070475737735c02dc00c00020001000000050008056173696131c02dc00c00020001000000050008056173696139c02dc00c00020001000000050008056e73312d31c02dc00c0002000100000005000a076e73312d313935c02dc02800010001000000050004c30a242ec04300010001000000050004451f1d39c05600010001000000050004451f3bc7c0690001000100000005000460073240c07c000100010000000500046007fb81c090000100010000000500047c283484c090001c00010000000500102a0226f0006700000000000000000064c0a400010001000000050004c16c5b01c0a4001c000100000005001026001401000200000000000000000001c0b800010001000000050004c16c5bc3c0b8001c0001000000050010260014010002000000000000000000c30000290500000000050000",
+ }
+
+ for i, hexData := range testMessages {
+ // we won't fail the decoding of the hex
+ input, _ := hex.DecodeString(hexData)
+ m := new(Msg)
+ m.Unpack(input)
+ //println(m.String())
+ m.Compress = true
+ lenComp := m.Len()
+ b, _ := m.Pack()
+ pacComp := len(b)
+ m.Compress = false
+ lenUnComp := m.Len()
+ b, _ = m.Pack()
+ pacUnComp := len(b)
+ if pacComp+1 != lenComp {
+ t.Errorf("msg.Len(compressed)=%d actual=%d for test %d", lenComp, pacComp, i)
+ }
+ if pacUnComp+1 != lenUnComp {
+ t.Errorf("msg.Len(uncompressed)=%d actual=%d for test %d", lenUnComp, pacUnComp, i)
+ }
+ }
+}
+
+func TestMsgLengthCompressionMalformed(t *testing.T) {
+ // SOA with empty hostmaster, which is illegal
+ soa := &SOA{Hdr: RR_Header{Name: ".", Rrtype: TypeSOA, Class: ClassINET, Ttl: 12345},
+ Ns: ".",
+ Mbox: "",
+ Serial: 0,
+ Refresh: 28800,
+ Retry: 7200,
+ Expire: 604800,
+ Minttl: 60}
+ m := new(Msg)
+ m.Compress = true
+ m.Ns = []RR{soa}
+ m.Len() // Should not crash.
+}
+
+func BenchmarkMsgLength(b *testing.B) {
+ b.StopTimer()
+ makeMsg := func(question string, ans, ns, e []RR) *Msg {
+ msg := new(Msg)
+ msg.SetQuestion(Fqdn(question), TypeANY)
+ msg.Answer = append(msg.Answer, ans...)
+ msg.Ns = append(msg.Ns, ns...)
+ msg.Extra = append(msg.Extra, e...)
+ msg.Compress = true
+ return msg
+ }
+ name1 := "12345678901234567890123456789012345.12345678.123."
+ rrMx, _ := NewRR(name1 + " 3600 IN MX 10 " + name1)
+ msg := makeMsg(name1, []RR{rrMx, rrMx}, nil, nil)
+ b.StartTimer()
+ for i := 0; i < b.N; i++ {
+ msg.Len()
+ }
+}
+
+func BenchmarkMsgLengthPack(b *testing.B) {
+ makeMsg := func(question string, ans, ns, e []RR) *Msg {
+ msg := new(Msg)
+ msg.SetQuestion(Fqdn(question), TypeANY)
+ msg.Answer = append(msg.Answer, ans...)
+ msg.Ns = append(msg.Ns, ns...)
+ msg.Extra = append(msg.Extra, e...)
+ msg.Compress = true
+ return msg
+ }
+ name1 := "12345678901234567890123456789012345.12345678.123."
+ rrMx, _ := NewRR(name1 + " 3600 IN MX 10 " + name1)
+ msg := makeMsg(name1, []RR{rrMx, rrMx}, nil, nil)
+ b.ResetTimer()
+ for i := 0; i < b.N; i++ {
+ _, _ = msg.Pack()
+ }
+}
+
+func BenchmarkMsgPackBuffer(b *testing.B) {
+ makeMsg := func(question string, ans, ns, e []RR) *Msg {
+ msg := new(Msg)
+ msg.SetQuestion(Fqdn(question), TypeANY)
+ msg.Answer = append(msg.Answer, ans...)
+ msg.Ns = append(msg.Ns, ns...)
+ msg.Extra = append(msg.Extra, e...)
+ msg.Compress = true
+ return msg
+ }
+ name1 := "12345678901234567890123456789012345.12345678.123."
+ rrMx, _ := NewRR(name1 + " 3600 IN MX 10 " + name1)
+ msg := makeMsg(name1, []RR{rrMx, rrMx}, nil, nil)
+ buf := make([]byte, 512)
+ b.ResetTimer()
+ for i := 0; i < b.N; i++ {
+ _, _ = msg.PackBuffer(buf)
+ }
+}
+
+func BenchmarkMsgUnpack(b *testing.B) {
+ makeMsg := func(question string, ans, ns, e []RR) *Msg {
+ msg := new(Msg)
+ msg.SetQuestion(Fqdn(question), TypeANY)
+ msg.Answer = append(msg.Answer, ans...)
+ msg.Ns = append(msg.Ns, ns...)
+ msg.Extra = append(msg.Extra, e...)
+ msg.Compress = true
+ return msg
+ }
+ name1 := "12345678901234567890123456789012345.12345678.123."
+ rrMx, _ := NewRR(name1 + " 3600 IN MX 10 " + name1)
+ msg := makeMsg(name1, []RR{rrMx, rrMx}, nil, nil)
+ msg_buf, _ := msg.Pack()
+ b.ResetTimer()
+ for i := 0; i < b.N; i++ {
+ _ = msg.Unpack(msg_buf)
+ }
+}
+
+func BenchmarkPackDomainName(b *testing.B) {
+ name1 := "12345678901234567890123456789012345.12345678.123."
+ buf := make([]byte, len(name1)+1)
+ b.ResetTimer()
+ for i := 0; i < b.N; i++ {
+ _, _ = PackDomainName(name1, buf, 0, nil, false)
+ }
+}
+
+func BenchmarkUnpackDomainName(b *testing.B) {
+ name1 := "12345678901234567890123456789012345.12345678.123."
+ buf := make([]byte, len(name1)+1)
+ _, _ = PackDomainName(name1, buf, 0, nil, false)
+ b.ResetTimer()
+ for i := 0; i < b.N; i++ {
+ _, _, _ = UnpackDomainName(buf, 0)
+ }
+}
+
+func BenchmarkUnpackDomainNameUnprintable(b *testing.B) {
+ name1 := "\x02\x02\x02\x025\x02\x02\x02\x02.12345678.123."
+ buf := make([]byte, len(name1)+1)
+ _, _ = PackDomainName(name1, buf, 0, nil, false)
+ b.ResetTimer()
+ for i := 0; i < b.N; i++ {
+ _, _, _ = UnpackDomainName(buf, 0)
+ }
+}
+
+func TestToRFC3597(t *testing.T) {
+ a, _ := NewRR("miek.nl. IN A 10.0.1.1")
+ x := new(RFC3597)
+ x.ToRFC3597(a)
+ if x.String() != `miek.nl. 3600 CLASS1 TYPE1 \# 4 0a000101` {
+ t.Fail()
+ }
+}
+
+func TestNoRdataPack(t *testing.T) {
+ data := make([]byte, 1024)
+ for typ, fn := range typeToRR {
+ if typ == TypeCAA {
+ continue // TODO(miek): known omission
+ }
+ r := fn()
+ *r.Header() = RR_Header{Name: "miek.nl.", Rrtype: typ, Class: ClassINET, Ttl: 3600}
+ _, e := PackRR(r, data, 0, nil, false)
+ if e != nil {
+ t.Logf("failed to pack RR with zero rdata: %s: %s\n", TypeToString[typ], e.Error())
+ t.Fail()
+ }
+ }
+}
+
+// TODO(miek): fix dns buffer too small errors this throws
+func TestNoRdataUnpack(t *testing.T) {
+ data := make([]byte, 1024)
+ for typ, fn := range typeToRR {
+ if typ == TypeSOA || typ == TypeTSIG || typ == TypeWKS {
+ // SOA, TSIG will not be seen (like this) in dyn. updates?
+ // WKS is an bug, but...deprecated record.
+ continue
+ }
+ r := fn()
+ *r.Header() = RR_Header{Name: "miek.nl.", Rrtype: typ, Class: ClassINET, Ttl: 3600}
+ off, e := PackRR(r, data, 0, nil, false)
+ if e != nil {
+ // Should always works, TestNoDataPack should have catched this
+ continue
+ }
+ rr, _, e := UnpackRR(data[:off], 0)
+ if e != nil {
+ t.Logf("failed to unpack RR with zero rdata: %s: %s\n", TypeToString[typ], e.Error())
+ t.Fail()
+ }
+ t.Logf("%s\n", rr)
+ }
+}
+
+func TestRdataOverflow(t *testing.T) {
+ rr := new(RFC3597)
+ rr.Hdr.Name = "."
+ rr.Hdr.Class = ClassINET
+ rr.Hdr.Rrtype = 65280
+ rr.Rdata = hex.EncodeToString(make([]byte, 0xFFFF))
+ buf := make([]byte, 0xFFFF*2)
+ if _, err := PackRR(rr, buf, 0, nil, false); err != nil {
+ t.Fatalf("maximum size rrdata pack failed: %v", err)
+ }
+ rr.Rdata += "00"
+ if _, err := PackRR(rr, buf, 0, nil, false); err != ErrRdata {
+ t.Fatalf("oversize rrdata pack didn't return ErrRdata - instead: %v", err)
+ }
+}
+
+func TestCopy(t *testing.T) {
+ rr, _ := NewRR("miek.nl. 2311 IN A 127.0.0.1") // Weird TTL to avoid catching TTL
+ rr1 := Copy(rr)
+ if rr.String() != rr1.String() {
+ t.Fatalf("Copy() failed %s != %s", rr.String(), rr1.String())
+ }
+}
diff --git a/Godeps/_workspace/src/github.com/miekg/dns/dnssec.go b/Godeps/_workspace/src/github.com/miekg/dns/dnssec.go
new file mode 100644
index 0000000000000000000000000000000000000000..d1c2ae62582fdd93cfb5ac5110df299919561b17
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/miekg/dns/dnssec.go
@@ -0,0 +1,756 @@
+// DNSSEC
+//
+// DNSSEC (DNS Security Extension) adds a layer of security to the DNS. It
+// uses public key cryptography to sign resource records. The
+// public keys are stored in DNSKEY records and the signatures in RRSIG records.
+//
+// Requesting DNSSEC information for a zone is done by adding the DO (DNSSEC OK) bit
+// to an request.
+//
+// m := new(dns.Msg)
+// m.SetEdns0(4096, true)
+//
+// Signature generation, signature verification and key generation are all supported.
+package dns
+
+import (
+ "bytes"
+ "crypto"
+ "crypto/dsa"
+ "crypto/ecdsa"
+ "crypto/elliptic"
+ "crypto/md5"
+ "crypto/rand"
+ "crypto/rsa"
+ "crypto/sha1"
+ "crypto/sha256"
+ "crypto/sha512"
+ "encoding/hex"
+ "hash"
+ "io"
+ "math/big"
+ "sort"
+ "strings"
+ "time"
+)
+
+// DNSSEC encryption algorithm codes.
+const (
+ _ uint8 = iota
+ RSAMD5
+ DH
+ DSA
+ _ // Skip 4, RFC 6725, section 2.1
+ RSASHA1
+ DSANSEC3SHA1
+ RSASHA1NSEC3SHA1
+ RSASHA256
+ _ // Skip 9, RFC 6725, section 2.1
+ RSASHA512
+ _ // Skip 11, RFC 6725, section 2.1
+ ECCGOST
+ ECDSAP256SHA256
+ ECDSAP384SHA384
+ INDIRECT uint8 = 252
+ PRIVATEDNS uint8 = 253 // Private (experimental keys)
+ PRIVATEOID uint8 = 254
+)
+
+// DNSSEC hashing algorithm codes.
+const (
+ _ uint8 = iota
+ SHA1 // RFC 4034
+ SHA256 // RFC 4509
+ GOST94 // RFC 5933
+ SHA384 // Experimental
+ SHA512 // Experimental
+)
+
+// DNSKEY flag values.
+const (
+ SEP = 1
+ REVOKE = 1 << 7
+ ZONE = 1 << 8
+)
+
+// The RRSIG needs to be converted to wireformat with some of
+// the rdata (the signature) missing. Use this struct to easy
+// the conversion (and re-use the pack/unpack functions).
+type rrsigWireFmt struct {
+ TypeCovered uint16
+ Algorithm uint8
+ Labels uint8
+ OrigTtl uint32
+ Expiration uint32
+ Inception uint32
+ KeyTag uint16
+ SignerName string `dns:"domain-name"`
+ /* No Signature */
+}
+
+// Used for converting DNSKEY's rdata to wirefmt.
+type dnskeyWireFmt struct {
+ Flags uint16
+ Protocol uint8
+ Algorithm uint8
+ PublicKey string `dns:"base64"`
+ /* Nothing is left out */
+}
+
+func divRoundUp(a, b int) int {
+ return (a + b - 1) / b
+}
+
+// KeyTag calculates the keytag (or key-id) of the DNSKEY.
+func (k *DNSKEY) KeyTag() uint16 {
+ if k == nil {
+ return 0
+ }
+ var keytag int
+ switch k.Algorithm {
+ case RSAMD5:
+ // Look at the bottom two bytes of the modules, which the last
+ // item in the pubkey. We could do this faster by looking directly
+ // at the base64 values. But I'm lazy.
+ modulus, _ := fromBase64([]byte(k.PublicKey))
+ if len(modulus) > 1 {
+ x, _ := unpackUint16(modulus, len(modulus)-2)
+ keytag = int(x)
+ }
+ default:
+ keywire := new(dnskeyWireFmt)
+ keywire.Flags = k.Flags
+ keywire.Protocol = k.Protocol
+ keywire.Algorithm = k.Algorithm
+ keywire.PublicKey = k.PublicKey
+ wire := make([]byte, DefaultMsgSize)
+ n, err := PackStruct(keywire, wire, 0)
+ if err != nil {
+ return 0
+ }
+ wire = wire[:n]
+ for i, v := range wire {
+ if i&1 != 0 {
+ keytag += int(v) // must be larger than uint32
+ } else {
+ keytag += int(v) << 8
+ }
+ }
+ keytag += (keytag >> 16) & 0xFFFF
+ keytag &= 0xFFFF
+ }
+ return uint16(keytag)
+}
+
+// ToDS converts a DNSKEY record to a DS record.
+func (k *DNSKEY) ToDS(h uint8) *DS {
+ if k == nil {
+ return nil
+ }
+ ds := new(DS)
+ ds.Hdr.Name = k.Hdr.Name
+ ds.Hdr.Class = k.Hdr.Class
+ ds.Hdr.Rrtype = TypeDS
+ ds.Hdr.Ttl = k.Hdr.Ttl
+ ds.Algorithm = k.Algorithm
+ ds.DigestType = h
+ ds.KeyTag = k.KeyTag()
+
+ keywire := new(dnskeyWireFmt)
+ keywire.Flags = k.Flags
+ keywire.Protocol = k.Protocol
+ keywire.Algorithm = k.Algorithm
+ keywire.PublicKey = k.PublicKey
+ wire := make([]byte, DefaultMsgSize)
+ n, err := PackStruct(keywire, wire, 0)
+ if err != nil {
+ return nil
+ }
+ wire = wire[:n]
+
+ owner := make([]byte, 255)
+ off, err1 := PackDomainName(strings.ToLower(k.Hdr.Name), owner, 0, nil, false)
+ if err1 != nil {
+ return nil
+ }
+ owner = owner[:off]
+ // RFC4034:
+ // digest = digest_algorithm( DNSKEY owner name | DNSKEY RDATA);
+ // "|" denotes concatenation
+ // DNSKEY RDATA = Flags | Protocol | Algorithm | Public Key.
+
+ // digest buffer
+ digest := append(owner, wire...) // another copy
+
+ switch h {
+ case SHA1:
+ s := sha1.New()
+ io.WriteString(s, string(digest))
+ ds.Digest = hex.EncodeToString(s.Sum(nil))
+ case SHA256:
+ s := sha256.New()
+ io.WriteString(s, string(digest))
+ ds.Digest = hex.EncodeToString(s.Sum(nil))
+ case SHA384:
+ s := sha512.New384()
+ io.WriteString(s, string(digest))
+ ds.Digest = hex.EncodeToString(s.Sum(nil))
+ case GOST94:
+ /* I have no clue */
+ default:
+ return nil
+ }
+ return ds
+}
+
+// Sign signs an RRSet. The signature needs to be filled in with
+// the values: Inception, Expiration, KeyTag, SignerName and Algorithm.
+// The rest is copied from the RRset. Sign returns true when the signing went OK,
+// otherwise false.
+// There is no check if RRSet is a proper (RFC 2181) RRSet.
+// If OrigTTL is non zero, it is used as-is, otherwise the TTL of the RRset
+// is used as the OrigTTL.
+func (rr *RRSIG) Sign(k PrivateKey, rrset []RR) error {
+ if k == nil {
+ return ErrPrivKey
+ }
+ // s.Inception and s.Expiration may be 0 (rollover etc.), the rest must be set
+ if rr.KeyTag == 0 || len(rr.SignerName) == 0 || rr.Algorithm == 0 {
+ return ErrKey
+ }
+
+ rr.Hdr.Rrtype = TypeRRSIG
+ rr.Hdr.Name = rrset[0].Header().Name
+ rr.Hdr.Class = rrset[0].Header().Class
+ if rr.OrigTtl == 0 { // If set don't override
+ rr.OrigTtl = rrset[0].Header().Ttl
+ }
+ rr.TypeCovered = rrset[0].Header().Rrtype
+ rr.Labels = uint8(CountLabel(rrset[0].Header().Name))
+
+ if strings.HasPrefix(rrset[0].Header().Name, "*") {
+ rr.Labels-- // wildcard, remove from label count
+ }
+
+ sigwire := new(rrsigWireFmt)
+ sigwire.TypeCovered = rr.TypeCovered
+ sigwire.Algorithm = rr.Algorithm
+ sigwire.Labels = rr.Labels
+ sigwire.OrigTtl = rr.OrigTtl
+ sigwire.Expiration = rr.Expiration
+ sigwire.Inception = rr.Inception
+ sigwire.KeyTag = rr.KeyTag
+ // For signing, lowercase this name
+ sigwire.SignerName = strings.ToLower(rr.SignerName)
+
+ // Create the desired binary blob
+ signdata := make([]byte, DefaultMsgSize)
+ n, err := PackStruct(sigwire, signdata, 0)
+ if err != nil {
+ return err
+ }
+ signdata = signdata[:n]
+ wire, err := rawSignatureData(rrset, rr)
+ if err != nil {
+ return err
+ }
+ signdata = append(signdata, wire...)
+
+ var sighash []byte
+ var h hash.Hash
+ var ch crypto.Hash // Only need for RSA
+ var intlen int
+ switch rr.Algorithm {
+ case DSA, DSANSEC3SHA1:
+ // Implicit in the ParameterSizes
+ case RSASHA1, RSASHA1NSEC3SHA1:
+ h = sha1.New()
+ ch = crypto.SHA1
+ case RSASHA256, ECDSAP256SHA256:
+ h = sha256.New()
+ ch = crypto.SHA256
+ intlen = 32
+ case ECDSAP384SHA384:
+ h = sha512.New384()
+ intlen = 48
+ case RSASHA512:
+ h = sha512.New()
+ ch = crypto.SHA512
+ case RSAMD5:
+ fallthrough // Deprecated in RFC 6725
+ default:
+ return ErrAlg
+ }
+ io.WriteString(h, string(signdata))
+ sighash = h.Sum(nil)
+
+ switch p := k.(type) {
+ case *dsa.PrivateKey:
+ r1, s1, err := dsa.Sign(rand.Reader, p, sighash)
+ if err != nil {
+ return err
+ }
+ signature := []byte{0x4D} // T value, here the ASCII M for Miek (not used in DNSSEC)
+ signature = append(signature, intToBytes(r1, 20)...)
+ signature = append(signature, intToBytes(s1, 20)...)
+ rr.Signature = toBase64(signature)
+ case *rsa.PrivateKey:
+ // We can use nil as rand.Reader here (says AGL)
+ signature, err := rsa.SignPKCS1v15(nil, p, ch, sighash)
+ if err != nil {
+ return err
+ }
+ rr.Signature = toBase64(signature)
+ case *ecdsa.PrivateKey:
+ r1, s1, err := ecdsa.Sign(rand.Reader, p, sighash)
+ if err != nil {
+ return err
+ }
+ signature := intToBytes(r1, intlen)
+ signature = append(signature, intToBytes(s1, intlen)...)
+ rr.Signature = toBase64(signature)
+ default:
+ // Not given the correct key
+ return ErrKeyAlg
+ }
+ return nil
+}
+
+// Verify validates an RRSet with the signature and key. This is only the
+// cryptographic test, the signature validity period must be checked separately.
+// This function copies the rdata of some RRs (to lowercase domain names) for the validation to work.
+func (rr *RRSIG) Verify(k *DNSKEY, rrset []RR) error {
+ // First the easy checks
+ if len(rrset) == 0 {
+ return ErrRRset
+ }
+ if rr.KeyTag != k.KeyTag() {
+ return ErrKey
+ }
+ if rr.Hdr.Class != k.Hdr.Class {
+ return ErrKey
+ }
+ if rr.Algorithm != k.Algorithm {
+ return ErrKey
+ }
+ if strings.ToLower(rr.SignerName) != strings.ToLower(k.Hdr.Name) {
+ return ErrKey
+ }
+ if k.Protocol != 3 {
+ return ErrKey
+ }
+ for _, r := range rrset {
+ if r.Header().Class != rr.Hdr.Class {
+ return ErrRRset
+ }
+ if r.Header().Rrtype != rr.TypeCovered {
+ return ErrRRset
+ }
+ }
+ // RFC 4035 5.3.2. Reconstructing the Signed Data
+ // Copy the sig, except the rrsig data
+ sigwire := new(rrsigWireFmt)
+ sigwire.TypeCovered = rr.TypeCovered
+ sigwire.Algorithm = rr.Algorithm
+ sigwire.Labels = rr.Labels
+ sigwire.OrigTtl = rr.OrigTtl
+ sigwire.Expiration = rr.Expiration
+ sigwire.Inception = rr.Inception
+ sigwire.KeyTag = rr.KeyTag
+ sigwire.SignerName = strings.ToLower(rr.SignerName)
+ // Create the desired binary blob
+ signeddata := make([]byte, DefaultMsgSize)
+ n, err := PackStruct(sigwire, signeddata, 0)
+ if err != nil {
+ return err
+ }
+ signeddata = signeddata[:n]
+ wire, err := rawSignatureData(rrset, rr)
+ if err != nil {
+ return err
+ }
+ signeddata = append(signeddata, wire...)
+
+ sigbuf := rr.sigBuf() // Get the binary signature data
+ if rr.Algorithm == PRIVATEDNS { // PRIVATEOID
+ // TODO(mg)
+ // remove the domain name and assume its our
+ }
+
+ switch rr.Algorithm {
+ case RSASHA1, RSASHA1NSEC3SHA1, RSASHA256, RSASHA512, RSAMD5:
+ // TODO(mg): this can be done quicker, ie. cache the pubkey data somewhere??
+ pubkey := k.publicKeyRSA() // Get the key
+ if pubkey == nil {
+ return ErrKey
+ }
+ // Setup the hash as defined for this alg.
+ var h hash.Hash
+ var ch crypto.Hash
+ switch rr.Algorithm {
+ case RSAMD5:
+ h = md5.New()
+ ch = crypto.MD5
+ case RSASHA1, RSASHA1NSEC3SHA1:
+ h = sha1.New()
+ ch = crypto.SHA1
+ case RSASHA256:
+ h = sha256.New()
+ ch = crypto.SHA256
+ case RSASHA512:
+ h = sha512.New()
+ ch = crypto.SHA512
+ }
+ io.WriteString(h, string(signeddata))
+ sighash := h.Sum(nil)
+ return rsa.VerifyPKCS1v15(pubkey, ch, sighash, sigbuf)
+ case ECDSAP256SHA256, ECDSAP384SHA384:
+ pubkey := k.publicKeyCurve()
+ if pubkey == nil {
+ return ErrKey
+ }
+ var h hash.Hash
+ switch rr.Algorithm {
+ case ECDSAP256SHA256:
+ h = sha256.New()
+ case ECDSAP384SHA384:
+ h = sha512.New384()
+ }
+ io.WriteString(h, string(signeddata))
+ sighash := h.Sum(nil)
+ // Split sigbuf into the r and s coordinates
+ r := big.NewInt(0)
+ r.SetBytes(sigbuf[:len(sigbuf)/2])
+ s := big.NewInt(0)
+ s.SetBytes(sigbuf[len(sigbuf)/2:])
+ if ecdsa.Verify(pubkey, sighash, r, s) {
+ return nil
+ }
+ return ErrSig
+ }
+ // Unknown alg
+ return ErrAlg
+}
+
+// ValidityPeriod uses RFC1982 serial arithmetic to calculate
+// if a signature period is valid. If t is the zero time, the
+// current time is taken other t is.
+func (rr *RRSIG) ValidityPeriod(t time.Time) bool {
+ var utc int64
+ if t.IsZero() {
+ utc = time.Now().UTC().Unix()
+ } else {
+ utc = t.UTC().Unix()
+ }
+ modi := (int64(rr.Inception) - utc) / year68
+ mode := (int64(rr.Expiration) - utc) / year68
+ ti := int64(rr.Inception) + (modi * year68)
+ te := int64(rr.Expiration) + (mode * year68)
+ return ti <= utc && utc <= te
+}
+
+// Return the signatures base64 encodedig sigdata as a byte slice.
+func (s *RRSIG) sigBuf() []byte {
+ sigbuf, err := fromBase64([]byte(s.Signature))
+ if err != nil {
+ return nil
+ }
+ return sigbuf
+}
+
+// setPublicKeyInPrivate sets the public key in the private key.
+func (k *DNSKEY) setPublicKeyInPrivate(p PrivateKey) bool {
+ switch t := p.(type) {
+ case *dsa.PrivateKey:
+ x := k.publicKeyDSA()
+ if x == nil {
+ return false
+ }
+ t.PublicKey = *x
+ case *rsa.PrivateKey:
+ x := k.publicKeyRSA()
+ if x == nil {
+ return false
+ }
+ t.PublicKey = *x
+ case *ecdsa.PrivateKey:
+ x := k.publicKeyCurve()
+ if x == nil {
+ return false
+ }
+ t.PublicKey = *x
+ }
+ return true
+}
+
+// publicKeyRSA returns the RSA public key from a DNSKEY record.
+func (k *DNSKEY) publicKeyRSA() *rsa.PublicKey {
+ keybuf, err := fromBase64([]byte(k.PublicKey))
+ if err != nil {
+ return nil
+ }
+
+ // RFC 2537/3110, section 2. RSA Public KEY Resource Records
+ // Length is in the 0th byte, unless its zero, then it
+ // it in bytes 1 and 2 and its a 16 bit number
+ explen := uint16(keybuf[0])
+ keyoff := 1
+ if explen == 0 {
+ explen = uint16(keybuf[1])<<8 | uint16(keybuf[2])
+ keyoff = 3
+ }
+ pubkey := new(rsa.PublicKey)
+
+ pubkey.N = big.NewInt(0)
+ shift := uint64((explen - 1) * 8)
+ expo := uint64(0)
+ for i := int(explen - 1); i > 0; i-- {
+ expo += uint64(keybuf[keyoff+i]) << shift
+ shift -= 8
+ }
+ // Remainder
+ expo += uint64(keybuf[keyoff])
+ if expo > 2<<31 {
+ // Larger expo than supported.
+ // println("dns: F5 primes (or larger) are not supported")
+ return nil
+ }
+ pubkey.E = int(expo)
+
+ pubkey.N.SetBytes(keybuf[keyoff+int(explen):])
+ return pubkey
+}
+
+// publicKeyCurve returns the Curve public key from the DNSKEY record.
+func (k *DNSKEY) publicKeyCurve() *ecdsa.PublicKey {
+ keybuf, err := fromBase64([]byte(k.PublicKey))
+ if err != nil {
+ return nil
+ }
+ pubkey := new(ecdsa.PublicKey)
+ switch k.Algorithm {
+ case ECDSAP256SHA256:
+ pubkey.Curve = elliptic.P256()
+ if len(keybuf) != 64 {
+ // wrongly encoded key
+ return nil
+ }
+ case ECDSAP384SHA384:
+ pubkey.Curve = elliptic.P384()
+ if len(keybuf) != 96 {
+ // Wrongly encoded key
+ return nil
+ }
+ }
+ pubkey.X = big.NewInt(0)
+ pubkey.X.SetBytes(keybuf[:len(keybuf)/2])
+ pubkey.Y = big.NewInt(0)
+ pubkey.Y.SetBytes(keybuf[len(keybuf)/2:])
+ return pubkey
+}
+
+func (k *DNSKEY) publicKeyDSA() *dsa.PublicKey {
+ keybuf, err := fromBase64([]byte(k.PublicKey))
+ if err != nil {
+ return nil
+ }
+ if len(keybuf) < 22 {
+ return nil
+ }
+ t, keybuf := int(keybuf[0]), keybuf[1:]
+ size := 64 + t*8
+ q, keybuf := keybuf[:20], keybuf[20:]
+ if len(keybuf) != 3*size {
+ return nil
+ }
+ p, keybuf := keybuf[:size], keybuf[size:]
+ g, y := keybuf[:size], keybuf[size:]
+ pubkey := new(dsa.PublicKey)
+ pubkey.Parameters.Q = big.NewInt(0).SetBytes(q)
+ pubkey.Parameters.P = big.NewInt(0).SetBytes(p)
+ pubkey.Parameters.G = big.NewInt(0).SetBytes(g)
+ pubkey.Y = big.NewInt(0).SetBytes(y)
+ return pubkey
+}
+
+// Set the public key (the value E and N)
+func (k *DNSKEY) setPublicKeyRSA(_E int, _N *big.Int) bool {
+ if _E == 0 || _N == nil {
+ return false
+ }
+ buf := exponentToBuf(_E)
+ buf = append(buf, _N.Bytes()...)
+ k.PublicKey = toBase64(buf)
+ return true
+}
+
+// Set the public key for Elliptic Curves
+func (k *DNSKEY) setPublicKeyCurve(_X, _Y *big.Int) bool {
+ if _X == nil || _Y == nil {
+ return false
+ }
+ var intlen int
+ switch k.Algorithm {
+ case ECDSAP256SHA256:
+ intlen = 32
+ case ECDSAP384SHA384:
+ intlen = 48
+ }
+ k.PublicKey = toBase64(curveToBuf(_X, _Y, intlen))
+ return true
+}
+
+// Set the public key for DSA
+func (k *DNSKEY) setPublicKeyDSA(_Q, _P, _G, _Y *big.Int) bool {
+ if _Q == nil || _P == nil || _G == nil || _Y == nil {
+ return false
+ }
+ buf := dsaToBuf(_Q, _P, _G, _Y)
+ k.PublicKey = toBase64(buf)
+ return true
+}
+
+// Set the public key (the values E and N) for RSA
+// RFC 3110: Section 2. RSA Public KEY Resource Records
+func exponentToBuf(_E int) []byte {
+ var buf []byte
+ i := big.NewInt(int64(_E))
+ if len(i.Bytes()) < 256 {
+ buf = make([]byte, 1)
+ buf[0] = uint8(len(i.Bytes()))
+ } else {
+ buf = make([]byte, 3)
+ buf[0] = 0
+ buf[1] = uint8(len(i.Bytes()) >> 8)
+ buf[2] = uint8(len(i.Bytes()))
+ }
+ buf = append(buf, i.Bytes()...)
+ return buf
+}
+
+// Set the public key for X and Y for Curve. The two
+// values are just concatenated.
+func curveToBuf(_X, _Y *big.Int, intlen int) []byte {
+ buf := intToBytes(_X, intlen)
+ buf = append(buf, intToBytes(_Y, intlen)...)
+ return buf
+}
+
+// Set the public key for X and Y for Curve. The two
+// values are just concatenated.
+func dsaToBuf(_Q, _P, _G, _Y *big.Int) []byte {
+ t := divRoundUp(divRoundUp(_G.BitLen(), 8)-64, 8)
+ buf := []byte{byte(t)}
+ buf = append(buf, intToBytes(_Q, 20)...)
+ buf = append(buf, intToBytes(_P, 64+t*8)...)
+ buf = append(buf, intToBytes(_G, 64+t*8)...)
+ buf = append(buf, intToBytes(_Y, 64+t*8)...)
+ return buf
+}
+
+type wireSlice [][]byte
+
+func (p wireSlice) Len() int { return len(p) }
+func (p wireSlice) Swap(i, j int) { p[i], p[j] = p[j], p[i] }
+func (p wireSlice) Less(i, j int) bool {
+ _, ioff, _ := UnpackDomainName(p[i], 0)
+ _, joff, _ := UnpackDomainName(p[j], 0)
+ return bytes.Compare(p[i][ioff+10:], p[j][joff+10:]) < 0
+}
+
+// Return the raw signature data.
+func rawSignatureData(rrset []RR, s *RRSIG) (buf []byte, err error) {
+ wires := make(wireSlice, len(rrset))
+ for i, r := range rrset {
+ r1 := r.copy()
+ r1.Header().Ttl = s.OrigTtl
+ labels := SplitDomainName(r1.Header().Name)
+ // 6.2. Canonical RR Form. (4) - wildcards
+ if len(labels) > int(s.Labels) {
+ // Wildcard
+ r1.Header().Name = "*." + strings.Join(labels[len(labels)-int(s.Labels):], ".") + "."
+ }
+ // RFC 4034: 6.2. Canonical RR Form. (2) - domain name to lowercase
+ r1.Header().Name = strings.ToLower(r1.Header().Name)
+ // 6.2. Canonical RR Form. (3) - domain rdata to lowercase.
+ // NS, MD, MF, CNAME, SOA, MB, MG, MR, PTR,
+ // HINFO, MINFO, MX, RP, AFSDB, RT, SIG, PX, NXT, NAPTR, KX,
+ // SRV, DNAME, A6
+ switch x := r1.(type) {
+ case *NS:
+ x.Ns = strings.ToLower(x.Ns)
+ case *CNAME:
+ x.Target = strings.ToLower(x.Target)
+ case *SOA:
+ x.Ns = strings.ToLower(x.Ns)
+ x.Mbox = strings.ToLower(x.Mbox)
+ case *MB:
+ x.Mb = strings.ToLower(x.Mb)
+ case *MG:
+ x.Mg = strings.ToLower(x.Mg)
+ case *MR:
+ x.Mr = strings.ToLower(x.Mr)
+ case *PTR:
+ x.Ptr = strings.ToLower(x.Ptr)
+ case *MINFO:
+ x.Rmail = strings.ToLower(x.Rmail)
+ x.Email = strings.ToLower(x.Email)
+ case *MX:
+ x.Mx = strings.ToLower(x.Mx)
+ case *NAPTR:
+ x.Replacement = strings.ToLower(x.Replacement)
+ case *KX:
+ x.Exchanger = strings.ToLower(x.Exchanger)
+ case *SRV:
+ x.Target = strings.ToLower(x.Target)
+ case *DNAME:
+ x.Target = strings.ToLower(x.Target)
+ }
+ // 6.2. Canonical RR Form. (5) - origTTL
+ wire := make([]byte, r1.len()+1) // +1 to be safe(r)
+ off, err1 := PackRR(r1, wire, 0, nil, false)
+ if err1 != nil {
+ return nil, err1
+ }
+ wire = wire[:off]
+ wires[i] = wire
+ }
+ sort.Sort(wires)
+ for _, wire := range wires {
+ buf = append(buf, wire...)
+ }
+ return buf, nil
+}
+
+// Map for algorithm names.
+var AlgorithmToString = map[uint8]string{
+ RSAMD5: "RSAMD5",
+ DH: "DH",
+ DSA: "DSA",
+ RSASHA1: "RSASHA1",
+ DSANSEC3SHA1: "DSA-NSEC3-SHA1",
+ RSASHA1NSEC3SHA1: "RSASHA1-NSEC3-SHA1",
+ RSASHA256: "RSASHA256",
+ RSASHA512: "RSASHA512",
+ ECCGOST: "ECC-GOST",
+ ECDSAP256SHA256: "ECDSAP256SHA256",
+ ECDSAP384SHA384: "ECDSAP384SHA384",
+ INDIRECT: "INDIRECT",
+ PRIVATEDNS: "PRIVATEDNS",
+ PRIVATEOID: "PRIVATEOID",
+}
+
+// Map of algorithm strings.
+var StringToAlgorithm = reverseInt8(AlgorithmToString)
+
+// Map for hash names.
+var HashToString = map[uint8]string{
+ SHA1: "SHA1",
+ SHA256: "SHA256",
+ GOST94: "GOST94",
+ SHA384: "SHA384",
+ SHA512: "SHA512",
+}
+
+// Map of hash strings.
+var StringToHash = reverseInt8(HashToString)
diff --git a/Godeps/_workspace/src/github.com/miekg/dns/dnssec_test.go b/Godeps/_workspace/src/github.com/miekg/dns/dnssec_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..f6263d505f46acb84ecebffcd1dccc7f2956611c
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/miekg/dns/dnssec_test.go
@@ -0,0 +1,672 @@
+package dns
+
+import (
+ "crypto/rsa"
+ "reflect"
+ "strings"
+ "testing"
+ "time"
+)
+
+func getKey() *DNSKEY {
+ key := new(DNSKEY)
+ key.Hdr.Name = "miek.nl."
+ key.Hdr.Class = ClassINET
+ key.Hdr.Ttl = 14400
+ key.Flags = 256
+ key.Protocol = 3
+ key.Algorithm = RSASHA256
+ key.PublicKey = "AwEAAcNEU67LJI5GEgF9QLNqLO1SMq1EdoQ6E9f85ha0k0ewQGCblyW2836GiVsm6k8Kr5ECIoMJ6fZWf3CQSQ9ycWfTyOHfmI3eQ/1Covhb2y4bAmL/07PhrL7ozWBW3wBfM335Ft9xjtXHPy7ztCbV9qZ4TVDTW/Iyg0PiwgoXVesz"
+ return key
+}
+
+func getSoa() *SOA {
+ soa := new(SOA)
+ soa.Hdr = RR_Header{"miek.nl.", TypeSOA, ClassINET, 14400, 0}
+ soa.Ns = "open.nlnetlabs.nl."
+ soa.Mbox = "miekg.atoom.net."
+ soa.Serial = 1293945905
+ soa.Refresh = 14400
+ soa.Retry = 3600
+ soa.Expire = 604800
+ soa.Minttl = 86400
+ return soa
+}
+
+func TestGenerateEC(t *testing.T) {
+ if testing.Short() {
+ t.Skip("skipping test in short mode.")
+ }
+ key := new(DNSKEY)
+ key.Hdr.Rrtype = TypeDNSKEY
+ key.Hdr.Name = "miek.nl."
+ key.Hdr.Class = ClassINET
+ key.Hdr.Ttl = 14400
+ key.Flags = 256
+ key.Protocol = 3
+ key.Algorithm = ECDSAP256SHA256
+ privkey, _ := key.Generate(256)
+ t.Logf("%s\n", key.String())
+ t.Logf("%s\n", key.PrivateKeyString(privkey))
+}
+
+func TestGenerateDSA(t *testing.T) {
+ if testing.Short() {
+ t.Skip("skipping test in short mode.")
+ }
+ key := new(DNSKEY)
+ key.Hdr.Rrtype = TypeDNSKEY
+ key.Hdr.Name = "miek.nl."
+ key.Hdr.Class = ClassINET
+ key.Hdr.Ttl = 14400
+ key.Flags = 256
+ key.Protocol = 3
+ key.Algorithm = DSA
+ privkey, _ := key.Generate(1024)
+ t.Logf("%s\n", key.String())
+ t.Logf("%s\n", key.PrivateKeyString(privkey))
+}
+
+func TestGenerateRSA(t *testing.T) {
+ if testing.Short() {
+ t.Skip("skipping test in short mode.")
+ }
+ key := new(DNSKEY)
+ key.Hdr.Rrtype = TypeDNSKEY
+ key.Hdr.Name = "miek.nl."
+ key.Hdr.Class = ClassINET
+ key.Hdr.Ttl = 14400
+ key.Flags = 256
+ key.Protocol = 3
+ key.Algorithm = RSASHA256
+ privkey, _ := key.Generate(1024)
+ t.Logf("%s\n", key.String())
+ t.Logf("%s\n", key.PrivateKeyString(privkey))
+}
+
+func TestSecure(t *testing.T) {
+ soa := getSoa()
+
+ sig := new(RRSIG)
+ sig.Hdr = RR_Header{"miek.nl.", TypeRRSIG, ClassINET, 14400, 0}
+ sig.TypeCovered = TypeSOA
+ sig.Algorithm = RSASHA256
+ sig.Labels = 2
+ sig.Expiration = 1296534305 // date -u '+%s' -d"2011-02-01 04:25:05"
+ sig.Inception = 1293942305 // date -u '+%s' -d"2011-01-02 04:25:05"
+ sig.OrigTtl = 14400
+ sig.KeyTag = 12051
+ sig.SignerName = "miek.nl."
+ sig.Signature = "oMCbslaAVIp/8kVtLSms3tDABpcPRUgHLrOR48OOplkYo+8TeEGWwkSwaz/MRo2fB4FxW0qj/hTlIjUGuACSd+b1wKdH5GvzRJc2pFmxtCbm55ygAh4EUL0F6U5cKtGJGSXxxg6UFCQ0doJCmiGFa78LolaUOXImJrk6AFrGa0M="
+
+ key := new(DNSKEY)
+ key.Hdr.Name = "miek.nl."
+ key.Hdr.Class = ClassINET
+ key.Hdr.Ttl = 14400
+ key.Flags = 256
+ key.Protocol = 3
+ key.Algorithm = RSASHA256
+ key.PublicKey = "AwEAAcNEU67LJI5GEgF9QLNqLO1SMq1EdoQ6E9f85ha0k0ewQGCblyW2836GiVsm6k8Kr5ECIoMJ6fZWf3CQSQ9ycWfTyOHfmI3eQ/1Covhb2y4bAmL/07PhrL7ozWBW3wBfM335Ft9xjtXHPy7ztCbV9qZ4TVDTW/Iyg0PiwgoXVesz"
+
+ // It should validate. Period is checked seperately, so this will keep on working
+ if sig.Verify(key, []RR{soa}) != nil {
+ t.Log("failure to validate")
+ t.Fail()
+ }
+}
+
+func TestSignature(t *testing.T) {
+ sig := new(RRSIG)
+ sig.Hdr.Name = "miek.nl."
+ sig.Hdr.Class = ClassINET
+ sig.Hdr.Ttl = 3600
+ sig.TypeCovered = TypeDNSKEY
+ sig.Algorithm = RSASHA1
+ sig.Labels = 2
+ sig.OrigTtl = 4000
+ sig.Expiration = 1000 //Thu Jan 1 02:06:40 CET 1970
+ sig.Inception = 800 //Thu Jan 1 01:13:20 CET 1970
+ sig.KeyTag = 34641
+ sig.SignerName = "miek.nl."
+ sig.Signature = "AwEAAaHIwpx3w4VHKi6i1LHnTaWeHCL154Jug0Rtc9ji5qwPXpBo6A5sRv7cSsPQKPIwxLpyCrbJ4mr2L0EPOdvP6z6YfljK2ZmTbogU9aSU2fiq/4wjxbdkLyoDVgtO+JsxNN4bjr4WcWhsmk1Hg93FV9ZpkWb0Tbad8DFqNDzr//kZ"
+
+ // Should not be valid
+ if sig.ValidityPeriod(time.Now()) {
+ t.Log("should not be valid")
+ t.Fail()
+ }
+
+ sig.Inception = 315565800 //Tue Jan 1 10:10:00 CET 1980
+ sig.Expiration = 4102477800 //Fri Jan 1 10:10:00 CET 2100
+ if !sig.ValidityPeriod(time.Now()) {
+ t.Log("should be valid")
+ t.Fail()
+ }
+}
+
+func TestSignVerify(t *testing.T) {
+ // The record we want to sign
+ soa := new(SOA)
+ soa.Hdr = RR_Header{"miek.nl.", TypeSOA, ClassINET, 14400, 0}
+ soa.Ns = "open.nlnetlabs.nl."
+ soa.Mbox = "miekg.atoom.net."
+ soa.Serial = 1293945905
+ soa.Refresh = 14400
+ soa.Retry = 3600
+ soa.Expire = 604800
+ soa.Minttl = 86400
+
+ soa1 := new(SOA)
+ soa1.Hdr = RR_Header{"*.miek.nl.", TypeSOA, ClassINET, 14400, 0}
+ soa1.Ns = "open.nlnetlabs.nl."
+ soa1.Mbox = "miekg.atoom.net."
+ soa1.Serial = 1293945905
+ soa1.Refresh = 14400
+ soa1.Retry = 3600
+ soa1.Expire = 604800
+ soa1.Minttl = 86400
+
+ srv := new(SRV)
+ srv.Hdr = RR_Header{"srv.miek.nl.", TypeSRV, ClassINET, 14400, 0}
+ srv.Port = 1000
+ srv.Weight = 800
+ srv.Target = "web1.miek.nl."
+
+ // With this key
+ key := new(DNSKEY)
+ key.Hdr.Rrtype = TypeDNSKEY
+ key.Hdr.Name = "miek.nl."
+ key.Hdr.Class = ClassINET
+ key.Hdr.Ttl = 14400
+ key.Flags = 256
+ key.Protocol = 3
+ key.Algorithm = RSASHA256
+ privkey, _ := key.Generate(512)
+
+ // Fill in the values of the Sig, before signing
+ sig := new(RRSIG)
+ sig.Hdr = RR_Header{"miek.nl.", TypeRRSIG, ClassINET, 14400, 0}
+ sig.TypeCovered = soa.Hdr.Rrtype
+ sig.Labels = uint8(CountLabel(soa.Hdr.Name)) // works for all 3
+ sig.OrigTtl = soa.Hdr.Ttl
+ sig.Expiration = 1296534305 // date -u '+%s' -d"2011-02-01 04:25:05"
+ sig.Inception = 1293942305 // date -u '+%s' -d"2011-01-02 04:25:05"
+ sig.KeyTag = key.KeyTag() // Get the keyfrom the Key
+ sig.SignerName = key.Hdr.Name
+ sig.Algorithm = RSASHA256
+
+ for _, r := range []RR{soa, soa1, srv} {
+ if sig.Sign(privkey, []RR{r}) != nil {
+ t.Log("failure to sign the record")
+ t.Fail()
+ continue
+ }
+ if sig.Verify(key, []RR{r}) != nil {
+ t.Log("failure to validate")
+ t.Fail()
+ continue
+ }
+ t.Logf("validated: %s\n", r.Header().Name)
+ }
+}
+
+func Test65534(t *testing.T) {
+ t6 := new(RFC3597)
+ t6.Hdr = RR_Header{"miek.nl.", 65534, ClassINET, 14400, 0}
+ t6.Rdata = "505D870001"
+ key := new(DNSKEY)
+ key.Hdr.Name = "miek.nl."
+ key.Hdr.Rrtype = TypeDNSKEY
+ key.Hdr.Class = ClassINET
+ key.Hdr.Ttl = 14400
+ key.Flags = 256
+ key.Protocol = 3
+ key.Algorithm = RSASHA256
+ privkey, _ := key.Generate(1024)
+
+ sig := new(RRSIG)
+ sig.Hdr = RR_Header{"miek.nl.", TypeRRSIG, ClassINET, 14400, 0}
+ sig.TypeCovered = t6.Hdr.Rrtype
+ sig.Labels = uint8(CountLabel(t6.Hdr.Name))
+ sig.OrigTtl = t6.Hdr.Ttl
+ sig.Expiration = 1296534305 // date -u '+%s' -d"2011-02-01 04:25:05"
+ sig.Inception = 1293942305 // date -u '+%s' -d"2011-01-02 04:25:05"
+ sig.KeyTag = key.KeyTag()
+ sig.SignerName = key.Hdr.Name
+ sig.Algorithm = RSASHA256
+ if err := sig.Sign(privkey, []RR{t6}); err != nil {
+ t.Log(err)
+ t.Log("failure to sign the TYPE65534 record")
+ t.Fail()
+ }
+ if err := sig.Verify(key, []RR{t6}); err != nil {
+ t.Log(err)
+ t.Log("failure to validate")
+ t.Fail()
+ } else {
+ t.Logf("validated: %s\n", t6.Header().Name)
+ }
+}
+
+func TestDnskey(t *testing.T) {
+ // f, _ := os.Open("t/Kmiek.nl.+010+05240.key")
+ pubkey, _ := ReadRR(strings.NewReader(`
+miek.nl. IN DNSKEY 256 3 10 AwEAAZuMCu2FdugHkTrXYgl5qixvcDw1aDDlvL46/xJKbHBAHY16fNUb2b65cwko2Js/aJxUYJbZk5dwCDZxYfrfbZVtDPQuc3o8QaChVxC7/JYz2AHc9qHvqQ1j4VrH71RWINlQo6VYjzN/BGpMhOZoZOEwzp1HfsOE3lNYcoWU1smL ;{id = 5240 (zsk), size = 1024b}
+`), "Kmiek.nl.+010+05240.key")
+ privkey, _ := pubkey.(*DNSKEY).ReadPrivateKey(strings.NewReader(`
+Private-key-format: v1.2
+Algorithm: 10 (RSASHA512)
+Modulus: m4wK7YV26AeROtdiCXmqLG9wPDVoMOW8vjr/EkpscEAdjXp81RvZvrlzCSjYmz9onFRgltmTl3AINnFh+t9tlW0M9C5zejxBoKFXELv8ljPYAdz2oe+pDWPhWsfvVFYg2VCjpViPM38EakyE5mhk4TDOnUd+w4TeU1hyhZTWyYs=
+PublicExponent: AQAB
+PrivateExponent: UfCoIQ/Z38l8vB6SSqOI/feGjHEl/fxIPX4euKf0D/32k30fHbSaNFrFOuIFmWMB3LimWVEs6u3dpbB9CQeCVg7hwU5puG7OtuiZJgDAhNeOnxvo5btp4XzPZrJSxR4WNQnwIiYWbl0aFlL1VGgHC/3By89ENZyWaZcMLW4KGWE=
+Prime1: yxwC6ogAu8aVcDx2wg1V0b5M5P6jP8qkRFVMxWNTw60Vkn+ECvw6YAZZBHZPaMyRYZLzPgUlyYRd0cjupy4+fQ==
+Prime2: xA1bF8M0RTIQ6+A11AoVG6GIR/aPGg5sogRkIZ7ID/sF6g9HMVU/CM2TqVEBJLRPp73cv6ZeC3bcqOCqZhz+pw==
+Exponent1: xzkblyZ96bGYxTVZm2/vHMOXswod4KWIyMoOepK6B/ZPcZoIT6omLCgtypWtwHLfqyCz3MK51Nc0G2EGzg8rFQ==
+Exponent2: Pu5+mCEb7T5F+kFNZhQadHUklt0JUHbi3hsEvVoHpEGSw3BGDQrtIflDde0/rbWHgDPM4WQY+hscd8UuTXrvLw==
+Coefficient: UuRoNqe7YHnKmQzE6iDWKTMIWTuoqqrFAmXPmKQnC+Y+BQzOVEHUo9bXdDnoI9hzXP1gf8zENMYwYLeWpuYlFQ==
+`), "Kmiek.nl.+010+05240.private")
+ if pubkey.(*DNSKEY).PublicKey != "AwEAAZuMCu2FdugHkTrXYgl5qixvcDw1aDDlvL46/xJKbHBAHY16fNUb2b65cwko2Js/aJxUYJbZk5dwCDZxYfrfbZVtDPQuc3o8QaChVxC7/JYz2AHc9qHvqQ1j4VrH71RWINlQo6VYjzN/BGpMhOZoZOEwzp1HfsOE3lNYcoWU1smL" {
+ t.Log("pubkey is not what we've read")
+ t.Fail()
+ }
+ // Coefficient looks fishy...
+ t.Logf("%s", pubkey.(*DNSKEY).PrivateKeyString(privkey))
+}
+
+func TestTag(t *testing.T) {
+ key := new(DNSKEY)
+ key.Hdr.Name = "miek.nl."
+ key.Hdr.Rrtype = TypeDNSKEY
+ key.Hdr.Class = ClassINET
+ key.Hdr.Ttl = 3600
+ key.Flags = 256
+ key.Protocol = 3
+ key.Algorithm = RSASHA256
+ key.PublicKey = "AwEAAcNEU67LJI5GEgF9QLNqLO1SMq1EdoQ6E9f85ha0k0ewQGCblyW2836GiVsm6k8Kr5ECIoMJ6fZWf3CQSQ9ycWfTyOHfmI3eQ/1Covhb2y4bAmL/07PhrL7ozWBW3wBfM335Ft9xjtXHPy7ztCbV9qZ4TVDTW/Iyg0PiwgoXVesz"
+
+ tag := key.KeyTag()
+ if tag != 12051 {
+ t.Logf("wrong key tag: %d for key %v\n", tag, key)
+ t.Fail()
+ }
+}
+
+func TestKeyRSA(t *testing.T) {
+ if testing.Short() {
+ t.Skip("skipping test in short mode.")
+ }
+ key := new(DNSKEY)
+ key.Hdr.Name = "miek.nl."
+ key.Hdr.Rrtype = TypeDNSKEY
+ key.Hdr.Class = ClassINET
+ key.Hdr.Ttl = 3600
+ key.Flags = 256
+ key.Protocol = 3
+ key.Algorithm = RSASHA256
+ priv, _ := key.Generate(2048)
+
+ soa := new(SOA)
+ soa.Hdr = RR_Header{"miek.nl.", TypeSOA, ClassINET, 14400, 0}
+ soa.Ns = "open.nlnetlabs.nl."
+ soa.Mbox = "miekg.atoom.net."
+ soa.Serial = 1293945905
+ soa.Refresh = 14400
+ soa.Retry = 3600
+ soa.Expire = 604800
+ soa.Minttl = 86400
+
+ sig := new(RRSIG)
+ sig.Hdr = RR_Header{"miek.nl.", TypeRRSIG, ClassINET, 14400, 0}
+ sig.TypeCovered = TypeSOA
+ sig.Algorithm = RSASHA256
+ sig.Labels = 2
+ sig.Expiration = 1296534305 // date -u '+%s' -d"2011-02-01 04:25:05"
+ sig.Inception = 1293942305 // date -u '+%s' -d"2011-01-02 04:25:05"
+ sig.OrigTtl = soa.Hdr.Ttl
+ sig.KeyTag = key.KeyTag()
+ sig.SignerName = key.Hdr.Name
+
+ if err := sig.Sign(priv, []RR{soa}); err != nil {
+ t.Logf("failed to sign")
+ t.Fail()
+ return
+ }
+ if err := sig.Verify(key, []RR{soa}); err != nil {
+ t.Logf("failed to verify")
+ t.Fail()
+ }
+}
+
+func TestKeyToDS(t *testing.T) {
+ key := new(DNSKEY)
+ key.Hdr.Name = "miek.nl."
+ key.Hdr.Rrtype = TypeDNSKEY
+ key.Hdr.Class = ClassINET
+ key.Hdr.Ttl = 3600
+ key.Flags = 256
+ key.Protocol = 3
+ key.Algorithm = RSASHA256
+ key.PublicKey = "AwEAAcNEU67LJI5GEgF9QLNqLO1SMq1EdoQ6E9f85ha0k0ewQGCblyW2836GiVsm6k8Kr5ECIoMJ6fZWf3CQSQ9ycWfTyOHfmI3eQ/1Covhb2y4bAmL/07PhrL7ozWBW3wBfM335Ft9xjtXHPy7ztCbV9qZ4TVDTW/Iyg0PiwgoXVesz"
+
+ ds := key.ToDS(SHA1)
+ if strings.ToUpper(ds.Digest) != "B5121BDB5B8D86D0CC5FFAFBAAABE26C3E20BAC1" {
+ t.Logf("wrong DS digest for SHA1\n%v\n", ds)
+ t.Fail()
+ }
+}
+
+func TestSignRSA(t *testing.T) {
+ pub := "miek.nl. IN DNSKEY 256 3 5 AwEAAb+8lGNCxJgLS8rYVer6EnHVuIkQDghdjdtewDzU3G5R7PbMbKVRvH2Ma7pQyYceoaqWZQirSj72euPWfPxQnMy9ucCylA+FuH9cSjIcPf4PqJfdupHk9X6EBYjxrCLY4p1/yBwgyBIRJtZtAqM3ceAH2WovEJD6rTtOuHo5AluJ"
+
+ priv := `Private-key-format: v1.3
+Algorithm: 5 (RSASHA1)
+Modulus: v7yUY0LEmAtLythV6voScdW4iRAOCF2N217APNTcblHs9sxspVG8fYxrulDJhx6hqpZlCKtKPvZ649Z8/FCczL25wLKUD4W4f1xKMhw9/g+ol926keT1foQFiPGsItjinX/IHCDIEhEm1m0Cozdx4AfZai8QkPqtO064ejkCW4k=
+PublicExponent: AQAB
+PrivateExponent: YPwEmwjk5HuiROKU4xzHQ6l1hG8Iiha4cKRG3P5W2b66/EN/GUh07ZSf0UiYB67o257jUDVEgwCuPJz776zfApcCB4oGV+YDyEu7Hp/rL8KcSN0la0k2r9scKwxTp4BTJT23zyBFXsV/1wRDK1A5NxsHPDMYi2SoK63Enm/1ptk=
+Prime1: /wjOG+fD0ybNoSRn7nQ79udGeR1b0YhUA5mNjDx/x2fxtIXzygYk0Rhx9QFfDy6LOBvz92gbNQlzCLz3DJt5hw==
+Prime2: wHZsJ8OGhkp5p3mrJFZXMDc2mbYusDVTA+t+iRPdS797Tj0pjvU2HN4vTnTj8KBQp6hmnY7dLp9Y1qserySGbw==
+Exponent1: N0A7FsSRIg+IAN8YPQqlawoTtG1t1OkJ+nWrurPootScApX6iMvn8fyvw3p2k51rv84efnzpWAYiC8SUaQDNxQ==
+Exponent2: SvuYRaGyvo0zemE3oS+WRm2scxR8eiA8WJGeOc+obwOKCcBgeZblXzfdHGcEC1KaOcetOwNW/vwMA46lpLzJNw==
+Coefficient: 8+7ZN/JgByqv0NfULiFKTjtyegUcijRuyij7yNxYbCBneDvZGxJwKNi4YYXWx743pcAj4Oi4Oh86gcmxLs+hGw==
+Created: 20110302104537
+Publish: 20110302104537
+Activate: 20110302104537`
+
+ xk, _ := NewRR(pub)
+ k := xk.(*DNSKEY)
+ p, err := k.NewPrivateKey(priv)
+ if err != nil {
+ t.Logf("%v\n", err)
+ t.Fail()
+ }
+ switch priv := p.(type) {
+ case *rsa.PrivateKey:
+ if 65537 != priv.PublicKey.E {
+ t.Log("exponenent should be 65537")
+ t.Fail()
+ }
+ default:
+ t.Logf("we should have read an RSA key: %v", priv)
+ t.Fail()
+ }
+ if k.KeyTag() != 37350 {
+ t.Logf("%d %v\n", k.KeyTag(), k)
+ t.Log("keytag should be 37350")
+ t.Fail()
+ }
+
+ soa := new(SOA)
+ soa.Hdr = RR_Header{"miek.nl.", TypeSOA, ClassINET, 14400, 0}
+ soa.Ns = "open.nlnetlabs.nl."
+ soa.Mbox = "miekg.atoom.net."
+ soa.Serial = 1293945905
+ soa.Refresh = 14400
+ soa.Retry = 3600
+ soa.Expire = 604800
+ soa.Minttl = 86400
+
+ sig := new(RRSIG)
+ sig.Hdr = RR_Header{"miek.nl.", TypeRRSIG, ClassINET, 14400, 0}
+ sig.Expiration = 1296534305 // date -u '+%s' -d"2011-02-01 04:25:05"
+ sig.Inception = 1293942305 // date -u '+%s' -d"2011-01-02 04:25:05"
+ sig.KeyTag = k.KeyTag()
+ sig.SignerName = k.Hdr.Name
+ sig.Algorithm = k.Algorithm
+
+ sig.Sign(p, []RR{soa})
+ if sig.Signature != "D5zsobpQcmMmYsUMLxCVEtgAdCvTu8V/IEeP4EyLBjqPJmjt96bwM9kqihsccofA5LIJ7DN91qkCORjWSTwNhzCv7bMyr2o5vBZElrlpnRzlvsFIoAZCD9xg6ZY7ZyzUJmU6IcTwG4v3xEYajcpbJJiyaw/RqR90MuRdKPiBzSo=" {
+ t.Log("signature is not correct")
+ t.Logf("%v\n", sig)
+ t.Fail()
+ }
+}
+
+func TestSignVerifyECDSA(t *testing.T) {
+ pub := `example.net. 3600 IN DNSKEY 257 3 14 (
+ xKYaNhWdGOfJ+nPrL8/arkwf2EY3MDJ+SErKivBVSum1
+ w/egsXvSADtNJhyem5RCOpgQ6K8X1DRSEkrbYQ+OB+v8
+ /uX45NBwY8rp65F6Glur8I/mlVNgF6W/qTI37m40 )`
+ priv := `Private-key-format: v1.2
+Algorithm: 14 (ECDSAP384SHA384)
+PrivateKey: WURgWHCcYIYUPWgeLmiPY2DJJk02vgrmTfitxgqcL4vwW7BOrbawVmVe0d9V94SR`
+
+ eckey, err := NewRR(pub)
+ if err != nil {
+ t.Fatal(err.Error())
+ }
+ privkey, err := eckey.(*DNSKEY).NewPrivateKey(priv)
+ if err != nil {
+ t.Fatal(err.Error())
+ }
+ // TODO: Create seperate test for this
+ ds := eckey.(*DNSKEY).ToDS(SHA384)
+ if ds.KeyTag != 10771 {
+ t.Fatal("wrong keytag on DS")
+ }
+ if ds.Digest != "72d7b62976ce06438e9c0bf319013cf801f09ecc84b8d7e9495f27e305c6a9b0563a9b5f4d288405c3008a946df983d6" {
+ t.Fatal("wrong DS Digest")
+ }
+ a, _ := NewRR("www.example.net. 3600 IN A 192.0.2.1")
+ sig := new(RRSIG)
+ sig.Hdr = RR_Header{"example.net.", TypeRRSIG, ClassINET, 14400, 0}
+ sig.Expiration, _ = StringToTime("20100909102025")
+ sig.Inception, _ = StringToTime("20100812102025")
+ sig.KeyTag = eckey.(*DNSKEY).KeyTag()
+ sig.SignerName = eckey.(*DNSKEY).Hdr.Name
+ sig.Algorithm = eckey.(*DNSKEY).Algorithm
+
+ if sig.Sign(privkey, []RR{a}) != nil {
+ t.Fatal("failure to sign the record")
+ }
+
+ if e := sig.Verify(eckey.(*DNSKEY), []RR{a}); e != nil {
+ t.Logf("\n%s\n%s\n%s\n\n%s\n\n",
+ eckey.(*DNSKEY).String(),
+ a.String(),
+ sig.String(),
+ eckey.(*DNSKEY).PrivateKeyString(privkey),
+ )
+
+ t.Fatalf("failure to validate: %s", e.Error())
+ }
+}
+
+func TestSignVerifyECDSA2(t *testing.T) {
+ srv1, err := NewRR("srv.miek.nl. IN SRV 1000 800 0 web1.miek.nl.")
+ if err != nil {
+ t.Fatalf(err.Error())
+ }
+ srv := srv1.(*SRV)
+
+ // With this key
+ key := new(DNSKEY)
+ key.Hdr.Rrtype = TypeDNSKEY
+ key.Hdr.Name = "miek.nl."
+ key.Hdr.Class = ClassINET
+ key.Hdr.Ttl = 14400
+ key.Flags = 256
+ key.Protocol = 3
+ key.Algorithm = ECDSAP256SHA256
+ privkey, err := key.Generate(256)
+ if err != nil {
+ t.Fatal("failure to generate key")
+ }
+
+ // Fill in the values of the Sig, before signing
+ sig := new(RRSIG)
+ sig.Hdr = RR_Header{"miek.nl.", TypeRRSIG, ClassINET, 14400, 0}
+ sig.TypeCovered = srv.Hdr.Rrtype
+ sig.Labels = uint8(CountLabel(srv.Hdr.Name)) // works for all 3
+ sig.OrigTtl = srv.Hdr.Ttl
+ sig.Expiration = 1296534305 // date -u '+%s' -d"2011-02-01 04:25:05"
+ sig.Inception = 1293942305 // date -u '+%s' -d"2011-01-02 04:25:05"
+ sig.KeyTag = key.KeyTag() // Get the keyfrom the Key
+ sig.SignerName = key.Hdr.Name
+ sig.Algorithm = ECDSAP256SHA256
+
+ if sig.Sign(privkey, []RR{srv}) != nil {
+ t.Fatal("failure to sign the record")
+ }
+
+ err = sig.Verify(key, []RR{srv})
+ if err != nil {
+ t.Logf("\n%s\n%s\n%s\n\n%s\n\n",
+ key.String(),
+ srv.String(),
+ sig.String(),
+ key.PrivateKeyString(privkey),
+ )
+
+ t.Fatal("Failure to validate:", err)
+ }
+}
+
+// Here the test vectors from the relevant RFCs are checked.
+// rfc6605 6.1
+func TestRFC6605P256(t *testing.T) {
+ exDNSKEY := `example.net. 3600 IN DNSKEY 257 3 13 (
+ GojIhhXUN/u4v54ZQqGSnyhWJwaubCvTmeexv7bR6edb
+ krSqQpF64cYbcB7wNcP+e+MAnLr+Wi9xMWyQLc8NAA== )`
+ exPriv := `Private-key-format: v1.2
+Algorithm: 13 (ECDSAP256SHA256)
+PrivateKey: GU6SnQ/Ou+xC5RumuIUIuJZteXT2z0O/ok1s38Et6mQ=`
+ rrDNSKEY, err := NewRR(exDNSKEY)
+ if err != nil {
+ t.Fatal(err.Error())
+ }
+ priv, err := rrDNSKEY.(*DNSKEY).NewPrivateKey(exPriv)
+ if err != nil {
+ t.Fatal(err.Error())
+ }
+
+ exDS := `example.net. 3600 IN DS 55648 13 2 (
+ b4c8c1fe2e7477127b27115656ad6256f424625bf5c1
+ e2770ce6d6e37df61d17 )`
+ rrDS, err := NewRR(exDS)
+ if err != nil {
+ t.Fatal(err.Error())
+ }
+ ourDS := rrDNSKEY.(*DNSKEY).ToDS(SHA256)
+ if !reflect.DeepEqual(ourDS, rrDS.(*DS)) {
+ t.Errorf("DS record differs:\n%v\n%v\n", ourDS, rrDS.(*DS))
+ }
+
+ exA := `www.example.net. 3600 IN A 192.0.2.1`
+ exRRSIG := `www.example.net. 3600 IN RRSIG A 13 3 3600 (
+ 20100909100439 20100812100439 55648 example.net.
+ qx6wLYqmh+l9oCKTN6qIc+bw6ya+KJ8oMz0YP107epXA
+ yGmt+3SNruPFKG7tZoLBLlUzGGus7ZwmwWep666VCw== )`
+ rrA, err := NewRR(exA)
+ if err != nil {
+ t.Fatal(err.Error())
+ }
+ rrRRSIG, err := NewRR(exRRSIG)
+ if err != nil {
+ t.Fatal(err.Error())
+ }
+ if err = rrRRSIG.(*RRSIG).Verify(rrDNSKEY.(*DNSKEY), []RR{rrA}); err != nil {
+ t.Errorf("Failure to validate the spec RRSIG: %v", err)
+ }
+
+ ourRRSIG := &RRSIG{
+ Hdr: RR_Header{
+ Ttl: rrA.Header().Ttl,
+ },
+ KeyTag: rrDNSKEY.(*DNSKEY).KeyTag(),
+ SignerName: rrDNSKEY.(*DNSKEY).Hdr.Name,
+ Algorithm: rrDNSKEY.(*DNSKEY).Algorithm,
+ }
+ ourRRSIG.Expiration, _ = StringToTime("20100909100439")
+ ourRRSIG.Inception, _ = StringToTime("20100812100439")
+ err = ourRRSIG.Sign(priv, []RR{rrA})
+ if err != nil {
+ t.Fatal(err.Error())
+ }
+
+ if err = ourRRSIG.Verify(rrDNSKEY.(*DNSKEY), []RR{rrA}); err != nil {
+ t.Errorf("Failure to validate our RRSIG: %v", err)
+ }
+
+ // Signatures are randomized
+ rrRRSIG.(*RRSIG).Signature = ""
+ ourRRSIG.Signature = ""
+ if !reflect.DeepEqual(ourRRSIG, rrRRSIG.(*RRSIG)) {
+ t.Fatalf("RRSIG record differs:\n%v\n%v\n", ourRRSIG, rrRRSIG.(*RRSIG))
+ }
+}
+
+// rfc6605 6.2
+func TestRFC6605P384(t *testing.T) {
+ exDNSKEY := `example.net. 3600 IN DNSKEY 257 3 14 (
+ xKYaNhWdGOfJ+nPrL8/arkwf2EY3MDJ+SErKivBVSum1
+ w/egsXvSADtNJhyem5RCOpgQ6K8X1DRSEkrbYQ+OB+v8
+ /uX45NBwY8rp65F6Glur8I/mlVNgF6W/qTI37m40 )`
+ exPriv := `Private-key-format: v1.2
+Algorithm: 14 (ECDSAP384SHA384)
+PrivateKey: WURgWHCcYIYUPWgeLmiPY2DJJk02vgrmTfitxgqcL4vwW7BOrbawVmVe0d9V94SR`
+ rrDNSKEY, err := NewRR(exDNSKEY)
+ if err != nil {
+ t.Fatal(err.Error())
+ }
+ priv, err := rrDNSKEY.(*DNSKEY).NewPrivateKey(exPriv)
+ if err != nil {
+ t.Fatal(err.Error())
+ }
+
+ exDS := `example.net. 3600 IN DS 10771 14 4 (
+ 72d7b62976ce06438e9c0bf319013cf801f09ecc84b8
+ d7e9495f27e305c6a9b0563a9b5f4d288405c3008a94
+ 6df983d6 )`
+ rrDS, err := NewRR(exDS)
+ if err != nil {
+ t.Fatal(err.Error())
+ }
+ ourDS := rrDNSKEY.(*DNSKEY).ToDS(SHA384)
+ if !reflect.DeepEqual(ourDS, rrDS.(*DS)) {
+ t.Fatalf("DS record differs:\n%v\n%v\n", ourDS, rrDS.(*DS))
+ }
+
+ exA := `www.example.net. 3600 IN A 192.0.2.1`
+ exRRSIG := `www.example.net. 3600 IN RRSIG A 14 3 3600 (
+ 20100909102025 20100812102025 10771 example.net.
+ /L5hDKIvGDyI1fcARX3z65qrmPsVz73QD1Mr5CEqOiLP
+ 95hxQouuroGCeZOvzFaxsT8Glr74hbavRKayJNuydCuz
+ WTSSPdz7wnqXL5bdcJzusdnI0RSMROxxwGipWcJm )`
+ rrA, err := NewRR(exA)
+ if err != nil {
+ t.Fatal(err.Error())
+ }
+ rrRRSIG, err := NewRR(exRRSIG)
+ if err != nil {
+ t.Fatal(err.Error())
+ }
+ if err = rrRRSIG.(*RRSIG).Verify(rrDNSKEY.(*DNSKEY), []RR{rrA}); err != nil {
+ t.Errorf("Failure to validate the spec RRSIG: %v", err)
+ }
+
+ ourRRSIG := &RRSIG{
+ Hdr: RR_Header{
+ Ttl: rrA.Header().Ttl,
+ },
+ KeyTag: rrDNSKEY.(*DNSKEY).KeyTag(),
+ SignerName: rrDNSKEY.(*DNSKEY).Hdr.Name,
+ Algorithm: rrDNSKEY.(*DNSKEY).Algorithm,
+ }
+ ourRRSIG.Expiration, _ = StringToTime("20100909102025")
+ ourRRSIG.Inception, _ = StringToTime("20100812102025")
+ err = ourRRSIG.Sign(priv, []RR{rrA})
+ if err != nil {
+ t.Fatal(err.Error())
+ }
+
+ if err = ourRRSIG.Verify(rrDNSKEY.(*DNSKEY), []RR{rrA}); err != nil {
+ t.Errorf("Failure to validate our RRSIG: %v", err)
+ }
+
+ // Signatures are randomized
+ rrRRSIG.(*RRSIG).Signature = ""
+ ourRRSIG.Signature = ""
+ if !reflect.DeepEqual(ourRRSIG, rrRRSIG.(*RRSIG)) {
+ t.Fatalf("RRSIG record differs:\n%v\n%v\n", ourRRSIG, rrRRSIG.(*RRSIG))
+ }
+}
diff --git a/Godeps/_workspace/src/github.com/miekg/dns/dyn_test.go b/Godeps/_workspace/src/github.com/miekg/dns/dyn_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..09986a5e4ef835d00177ad46cc454bbca5461a12
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/miekg/dns/dyn_test.go
@@ -0,0 +1,3 @@
+package dns
+
+// Find better solution
diff --git a/Godeps/_workspace/src/github.com/miekg/dns/edns.go b/Godeps/_workspace/src/github.com/miekg/dns/edns.go
new file mode 100644
index 0000000000000000000000000000000000000000..8b676e6124158d295a85baba59dfd6945b6e171a
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/miekg/dns/edns.go
@@ -0,0 +1,501 @@
+// EDNS0
+//
+// EDNS0 is an extension mechanism for the DNS defined in RFC 2671 and updated
+// by RFC 6891. It defines an new RR type, the OPT RR, which is then completely
+// abused.
+// Basic use pattern for creating an (empty) OPT RR:
+//
+// o := new(dns.OPT)
+// o.Hdr.Name = "." // MUST be the root zone, per definition.
+// o.Hdr.Rrtype = dns.TypeOPT
+//
+// The rdata of an OPT RR consists out of a slice of EDNS0 (RFC 6891)
+// interfaces. Currently only a few have been standardized: EDNS0_NSID
+// (RFC 5001) and EDNS0_SUBNET (draft-vandergaast-edns-client-subnet-02). Note
+// that these options may be combined in an OPT RR.
+// Basic use pattern for a server to check if (and which) options are set:
+//
+// // o is a dns.OPT
+// for _, s := range o.Option {
+// switch e := s.(type) {
+// case *dns.EDNS0_NSID:
+// // do stuff with e.Nsid
+// case *dns.EDNS0_SUBNET:
+// // access e.Family, e.Address, etc.
+// }
+// }
+package dns
+
+import (
+ "encoding/hex"
+ "errors"
+ "net"
+ "strconv"
+)
+
+// EDNS0 Option codes.
+const (
+ EDNS0LLQ = 0x1 // long lived queries: http://tools.ietf.org/html/draft-sekar-dns-llq-01
+ EDNS0UL = 0x2 // update lease draft: http://files.dns-sd.org/draft-sekar-dns-ul.txt
+ EDNS0NSID = 0x3 // nsid (RFC5001)
+ EDNS0DAU = 0x5 // DNSSEC Algorithm Understood
+ EDNS0DHU = 0x6 // DS Hash Understood
+ EDNS0N3U = 0x7 // NSEC3 Hash Understood
+ EDNS0SUBNET = 0x8 // client-subnet (RFC6891)
+ EDNS0EXPIRE = 0x9 // EDNS0 expire
+ EDNS0SUBNETDRAFT = 0x50fa // Don't use! Use EDNS0SUBNET
+ _DO = 1 << 15 // dnssec ok
+)
+
+type OPT struct {
+ Hdr RR_Header
+ Option []EDNS0 `dns:"opt"`
+}
+
+func (rr *OPT) Header() *RR_Header {
+ return &rr.Hdr
+}
+
+func (rr *OPT) String() string {
+ s := "\n;; OPT PSEUDOSECTION:\n; EDNS: version " + strconv.Itoa(int(rr.Version())) + "; "
+ if rr.Do() {
+ s += "flags: do; "
+ } else {
+ s += "flags: ; "
+ }
+ s += "udp: " + strconv.Itoa(int(rr.UDPSize()))
+
+ for _, o := range rr.Option {
+ switch o.(type) {
+ case *EDNS0_NSID:
+ s += "\n; NSID: " + o.String()
+ h, e := o.pack()
+ var r string
+ if e == nil {
+ for _, c := range h {
+ r += "(" + string(c) + ")"
+ }
+ s += " " + r
+ }
+ case *EDNS0_SUBNET:
+ s += "\n; SUBNET: " + o.String()
+ if o.(*EDNS0_SUBNET).DraftOption {
+ s += " (draft)"
+ }
+ case *EDNS0_UL:
+ s += "\n; UPDATE LEASE: " + o.String()
+ case *EDNS0_LLQ:
+ s += "\n; LONG LIVED QUERIES: " + o.String()
+ case *EDNS0_DAU:
+ s += "\n; DNSSEC ALGORITHM UNDERSTOOD: " + o.String()
+ case *EDNS0_DHU:
+ s += "\n; DS HASH UNDERSTOOD: " + o.String()
+ case *EDNS0_N3U:
+ s += "\n; NSEC3 HASH UNDERSTOOD: " + o.String()
+ }
+ }
+ return s
+}
+
+func (rr *OPT) len() int {
+ l := rr.Hdr.len()
+ for i := 0; i < len(rr.Option); i++ {
+ lo, _ := rr.Option[i].pack()
+ l += 2 + len(lo)
+ }
+ return l
+}
+
+func (rr *OPT) copy() RR {
+ return &OPT{*rr.Hdr.copyHeader(), rr.Option}
+}
+
+// return the old value -> delete SetVersion?
+
+// Version returns the EDNS version used. Only zero is defined.
+func (rr *OPT) Version() uint8 {
+ return uint8((rr.Hdr.Ttl & 0x00FF0000) >> 16)
+}
+
+// SetVersion sets the version of EDNS. This is usually zero.
+func (rr *OPT) SetVersion(v uint8) {
+ rr.Hdr.Ttl = rr.Hdr.Ttl&0xFF00FFFF | (uint32(v) << 16)
+}
+
+// ExtendedRcode returns the EDNS extended RCODE field (the upper 8 bits of the TTL).
+func (rr *OPT) ExtendedRcode() uint8 {
+ return uint8((rr.Hdr.Ttl & 0xFF000000) >> 24)
+}
+
+// SetExtendedRcode sets the EDNS extended RCODE field.
+func (rr *OPT) SetExtendedRcode(v uint8) {
+ rr.Hdr.Ttl = rr.Hdr.Ttl&0x00FFFFFF | (uint32(v) << 24)
+}
+
+// UDPSize returns the UDP buffer size.
+func (rr *OPT) UDPSize() uint16 {
+ return rr.Hdr.Class
+}
+
+// SetUDPSize sets the UDP buffer size.
+func (rr *OPT) SetUDPSize(size uint16) {
+ rr.Hdr.Class = size
+}
+
+// Do returns the value of the DO (DNSSEC OK) bit.
+func (rr *OPT) Do() bool {
+ return rr.Hdr.Ttl&_DO == _DO
+}
+
+// SetDo sets the DO (DNSSEC OK) bit.
+func (rr *OPT) SetDo() {
+ rr.Hdr.Ttl |= _DO
+}
+
+// EDNS0 defines an EDNS0 Option. An OPT RR can have multiple options appended to
+// it.
+type EDNS0 interface {
+ // Option returns the option code for the option.
+ Option() uint16
+ // pack returns the bytes of the option data.
+ pack() ([]byte, error)
+ // unpack sets the data as found in the buffer. Is also sets
+ // the length of the slice as the length of the option data.
+ unpack([]byte) error
+ // String returns the string representation of the option.
+ String() string
+}
+
+// The nsid EDNS0 option is used to retrieve a nameserver
+// identifier. When sending a request Nsid must be set to the empty string
+// The identifier is an opaque string encoded as hex.
+// Basic use pattern for creating an nsid option:
+//
+// o := new(dns.OPT)
+// o.Hdr.Name = "."
+// o.Hdr.Rrtype = dns.TypeOPT
+// e := new(dns.EDNS0_NSID)
+// e.Code = dns.EDNS0NSID
+// e.Nsid = "AA"
+// o.Option = append(o.Option, e)
+type EDNS0_NSID struct {
+ Code uint16 // Always EDNS0NSID
+ Nsid string // This string needs to be hex encoded
+}
+
+func (e *EDNS0_NSID) pack() ([]byte, error) {
+ h, err := hex.DecodeString(e.Nsid)
+ if err != nil {
+ return nil, err
+ }
+ return h, nil
+}
+
+func (e *EDNS0_NSID) Option() uint16 { return EDNS0NSID }
+func (e *EDNS0_NSID) unpack(b []byte) error { e.Nsid = hex.EncodeToString(b); return nil }
+func (e *EDNS0_NSID) String() string { return string(e.Nsid) }
+
+// The subnet EDNS0 option is used to give the remote nameserver
+// an idea of where the client lives. It can then give back a different
+// answer depending on the location or network topology.
+// Basic use pattern for creating an subnet option:
+//
+// o := new(dns.OPT)
+// o.Hdr.Name = "."
+// o.Hdr.Rrtype = dns.TypeOPT
+// e := new(dns.EDNS0_SUBNET)
+// e.Code = dns.EDNS0SUBNET
+// e.Family = 1 // 1 for IPv4 source address, 2 for IPv6
+// e.NetMask = 32 // 32 for IPV4, 128 for IPv6
+// e.SourceScope = 0
+// e.Address = net.ParseIP("127.0.0.1").To4() // for IPv4
+// // e.Address = net.ParseIP("2001:7b8:32a::2") // for IPV6
+// o.Option = append(o.Option, e)
+type EDNS0_SUBNET struct {
+ Code uint16 // Always EDNS0SUBNET
+ Family uint16 // 1 for IP, 2 for IP6
+ SourceNetmask uint8
+ SourceScope uint8
+ Address net.IP
+ DraftOption bool // Set to true if using the old (0x50fa) option code
+}
+
+func (e *EDNS0_SUBNET) Option() uint16 {
+ if e.DraftOption {
+ return EDNS0SUBNETDRAFT
+ }
+ return EDNS0SUBNET
+}
+
+func (e *EDNS0_SUBNET) pack() ([]byte, error) {
+ b := make([]byte, 4)
+ b[0], b[1] = packUint16(e.Family)
+ b[2] = e.SourceNetmask
+ b[3] = e.SourceScope
+ switch e.Family {
+ case 1:
+ if e.SourceNetmask > net.IPv4len*8 {
+ return nil, errors.New("dns: bad netmask")
+ }
+ ip := make([]byte, net.IPv4len)
+ a := e.Address.To4().Mask(net.CIDRMask(int(e.SourceNetmask), net.IPv4len*8))
+ for i := 0; i < net.IPv4len; i++ {
+ if i+1 > len(e.Address) {
+ break
+ }
+ ip[i] = a[i]
+ }
+ needLength := e.SourceNetmask / 8
+ if e.SourceNetmask%8 > 0 {
+ needLength++
+ }
+ ip = ip[:needLength]
+ b = append(b, ip...)
+ case 2:
+ if e.SourceNetmask > net.IPv6len*8 {
+ return nil, errors.New("dns: bad netmask")
+ }
+ ip := make([]byte, net.IPv6len)
+ a := e.Address.Mask(net.CIDRMask(int(e.SourceNetmask), net.IPv6len*8))
+ for i := 0; i < net.IPv6len; i++ {
+ if i+1 > len(e.Address) {
+ break
+ }
+ ip[i] = a[i]
+ }
+ needLength := e.SourceNetmask / 8
+ if e.SourceNetmask%8 > 0 {
+ needLength++
+ }
+ ip = ip[:needLength]
+ b = append(b, ip...)
+ default:
+ return nil, errors.New("dns: bad address family")
+ }
+ return b, nil
+}
+
+func (e *EDNS0_SUBNET) unpack(b []byte) error {
+ lb := len(b)
+ if lb < 4 {
+ return ErrBuf
+ }
+ e.Family, _ = unpackUint16(b, 0)
+ e.SourceNetmask = b[2]
+ e.SourceScope = b[3]
+ switch e.Family {
+ case 1:
+ addr := make([]byte, 4)
+ for i := 0; i < int(e.SourceNetmask/8); i++ {
+ if i >= len(addr) || 4+i >= len(b) {
+ return ErrBuf
+ }
+ addr[i] = b[4+i]
+ }
+ e.Address = net.IPv4(addr[0], addr[1], addr[2], addr[3])
+ case 2:
+ addr := make([]byte, 16)
+ for i := 0; i < int(e.SourceNetmask/8); i++ {
+ if i >= len(addr) || 4+i >= len(b) {
+ return ErrBuf
+ }
+ addr[i] = b[4+i]
+ }
+ e.Address = net.IP{addr[0], addr[1], addr[2], addr[3], addr[4],
+ addr[5], addr[6], addr[7], addr[8], addr[9], addr[10],
+ addr[11], addr[12], addr[13], addr[14], addr[15]}
+ }
+ return nil
+}
+
+func (e *EDNS0_SUBNET) String() (s string) {
+ if e.Address == nil {
+ s = "<nil>"
+ } else if e.Address.To4() != nil {
+ s = e.Address.String()
+ } else {
+ s = "[" + e.Address.String() + "]"
+ }
+ s += "/" + strconv.Itoa(int(e.SourceNetmask)) + "/" + strconv.Itoa(int(e.SourceScope))
+ return
+}
+
+// The UL (Update Lease) EDNS0 (draft RFC) option is used to tell the server to set
+// an expiration on an update RR. This is helpful for clients that cannot clean
+// up after themselves. This is a draft RFC and more information can be found at
+// http://files.dns-sd.org/draft-sekar-dns-ul.txt
+//
+// o := new(dns.OPT)
+// o.Hdr.Name = "."
+// o.Hdr.Rrtype = dns.TypeOPT
+// e := new(dns.EDNS0_UL)
+// e.Code = dns.EDNS0UL
+// e.Lease = 120 // in seconds
+// o.Option = append(o.Option, e)
+type EDNS0_UL struct {
+ Code uint16 // Always EDNS0UL
+ Lease uint32
+}
+
+func (e *EDNS0_UL) Option() uint16 { return EDNS0UL }
+func (e *EDNS0_UL) String() string { return strconv.FormatUint(uint64(e.Lease), 10) }
+
+// Copied: http://golang.org/src/pkg/net/dnsmsg.go
+func (e *EDNS0_UL) pack() ([]byte, error) {
+ b := make([]byte, 4)
+ b[0] = byte(e.Lease >> 24)
+ b[1] = byte(e.Lease >> 16)
+ b[2] = byte(e.Lease >> 8)
+ b[3] = byte(e.Lease)
+ return b, nil
+}
+
+func (e *EDNS0_UL) unpack(b []byte) error {
+ if len(b) < 4 {
+ return ErrBuf
+ }
+ e.Lease = uint32(b[0])<<24 | uint32(b[1])<<16 | uint32(b[2])<<8 | uint32(b[3])
+ return nil
+}
+
+// Long Lived Queries: http://tools.ietf.org/html/draft-sekar-dns-llq-01
+// Implemented for completeness, as the EDNS0 type code is assigned.
+type EDNS0_LLQ struct {
+ Code uint16 // Always EDNS0LLQ
+ Version uint16
+ Opcode uint16
+ Error uint16
+ Id uint64
+ LeaseLife uint32
+}
+
+func (e *EDNS0_LLQ) Option() uint16 { return EDNS0LLQ }
+
+func (e *EDNS0_LLQ) pack() ([]byte, error) {
+ b := make([]byte, 18)
+ b[0], b[1] = packUint16(e.Version)
+ b[2], b[3] = packUint16(e.Opcode)
+ b[4], b[5] = packUint16(e.Error)
+ b[6] = byte(e.Id >> 56)
+ b[7] = byte(e.Id >> 48)
+ b[8] = byte(e.Id >> 40)
+ b[9] = byte(e.Id >> 32)
+ b[10] = byte(e.Id >> 24)
+ b[11] = byte(e.Id >> 16)
+ b[12] = byte(e.Id >> 8)
+ b[13] = byte(e.Id)
+ b[14] = byte(e.LeaseLife >> 24)
+ b[15] = byte(e.LeaseLife >> 16)
+ b[16] = byte(e.LeaseLife >> 8)
+ b[17] = byte(e.LeaseLife)
+ return b, nil
+}
+
+func (e *EDNS0_LLQ) unpack(b []byte) error {
+ if len(b) < 18 {
+ return ErrBuf
+ }
+ e.Version, _ = unpackUint16(b, 0)
+ e.Opcode, _ = unpackUint16(b, 2)
+ e.Error, _ = unpackUint16(b, 4)
+ e.Id = uint64(b[6])<<56 | uint64(b[6+1])<<48 | uint64(b[6+2])<<40 |
+ uint64(b[6+3])<<32 | uint64(b[6+4])<<24 | uint64(b[6+5])<<16 | uint64(b[6+6])<<8 | uint64(b[6+7])
+ e.LeaseLife = uint32(b[14])<<24 | uint32(b[14+1])<<16 | uint32(b[14+2])<<8 | uint32(b[14+3])
+ return nil
+}
+
+func (e *EDNS0_LLQ) String() string {
+ s := strconv.FormatUint(uint64(e.Version), 10) + " " + strconv.FormatUint(uint64(e.Opcode), 10) +
+ " " + strconv.FormatUint(uint64(e.Error), 10) + " " + strconv.FormatUint(uint64(e.Id), 10) +
+ " " + strconv.FormatUint(uint64(e.LeaseLife), 10)
+ return s
+}
+
+type EDNS0_DAU struct {
+ Code uint16 // Always EDNS0DAU
+ AlgCode []uint8
+}
+
+func (e *EDNS0_DAU) Option() uint16 { return EDNS0DAU }
+func (e *EDNS0_DAU) pack() ([]byte, error) { return e.AlgCode, nil }
+func (e *EDNS0_DAU) unpack(b []byte) error { e.AlgCode = b; return nil }
+
+func (e *EDNS0_DAU) String() string {
+ s := ""
+ for i := 0; i < len(e.AlgCode); i++ {
+ if a, ok := AlgorithmToString[e.AlgCode[i]]; ok {
+ s += " " + a
+ } else {
+ s += " " + strconv.Itoa(int(e.AlgCode[i]))
+ }
+ }
+ return s
+}
+
+type EDNS0_DHU struct {
+ Code uint16 // Always EDNS0DHU
+ AlgCode []uint8
+}
+
+func (e *EDNS0_DHU) Option() uint16 { return EDNS0DHU }
+func (e *EDNS0_DHU) pack() ([]byte, error) { return e.AlgCode, nil }
+func (e *EDNS0_DHU) unpack(b []byte) error { e.AlgCode = b; return nil }
+
+func (e *EDNS0_DHU) String() string {
+ s := ""
+ for i := 0; i < len(e.AlgCode); i++ {
+ if a, ok := HashToString[e.AlgCode[i]]; ok {
+ s += " " + a
+ } else {
+ s += " " + strconv.Itoa(int(e.AlgCode[i]))
+ }
+ }
+ return s
+}
+
+type EDNS0_N3U struct {
+ Code uint16 // Always EDNS0N3U
+ AlgCode []uint8
+}
+
+func (e *EDNS0_N3U) Option() uint16 { return EDNS0N3U }
+func (e *EDNS0_N3U) pack() ([]byte, error) { return e.AlgCode, nil }
+func (e *EDNS0_N3U) unpack(b []byte) error { e.AlgCode = b; return nil }
+
+func (e *EDNS0_N3U) String() string {
+ // Re-use the hash map
+ s := ""
+ for i := 0; i < len(e.AlgCode); i++ {
+ if a, ok := HashToString[e.AlgCode[i]]; ok {
+ s += " " + a
+ } else {
+ s += " " + strconv.Itoa(int(e.AlgCode[i]))
+ }
+ }
+ return s
+}
+
+type EDNS0_EXPIRE struct {
+ Code uint16 // Always EDNS0EXPIRE
+ Expire uint32
+}
+
+func (e *EDNS0_EXPIRE) Option() uint16 { return EDNS0EXPIRE }
+func (e *EDNS0_EXPIRE) String() string { return strconv.FormatUint(uint64(e.Expire), 10) }
+
+func (e *EDNS0_EXPIRE) pack() ([]byte, error) {
+ b := make([]byte, 4)
+ b[0] = byte(e.Expire >> 24)
+ b[1] = byte(e.Expire >> 16)
+ b[2] = byte(e.Expire >> 8)
+ b[3] = byte(e.Expire)
+ return b, nil
+}
+
+func (e *EDNS0_EXPIRE) unpack(b []byte) error {
+ if len(b) < 4 {
+ return ErrBuf
+ }
+ e.Expire = uint32(b[0])<<24 | uint32(b[1])<<16 | uint32(b[2])<<8 | uint32(b[3])
+ return nil
+}
diff --git a/Godeps/_workspace/src/github.com/miekg/dns/edns_test.go b/Godeps/_workspace/src/github.com/miekg/dns/edns_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..8ee82ab426414fe71ccdb2073a3a347c12f5fc20
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/miekg/dns/edns_test.go
@@ -0,0 +1,48 @@
+package dns
+
+import "testing"
+
+func TestOPTTtl(t *testing.T) {
+ e := &OPT{}
+ e.Hdr.Name = "."
+ e.Hdr.Rrtype = TypeOPT
+
+ if e.Do() {
+ t.Fail()
+ }
+
+ e.SetDo()
+ if !e.Do() {
+ t.Fail()
+ }
+
+ oldTtl := e.Hdr.Ttl
+
+ if e.Version() != 0 {
+ t.Fail()
+ }
+
+ e.SetVersion(42)
+ if e.Version() != 42 {
+ t.Fail()
+ }
+
+ e.SetVersion(0)
+ if e.Hdr.Ttl != oldTtl {
+ t.Fail()
+ }
+
+ if e.ExtendedRcode() != 0 {
+ t.Fail()
+ }
+
+ e.SetExtendedRcode(42)
+ if e.ExtendedRcode() != 42 {
+ t.Fail()
+ }
+
+ e.SetExtendedRcode(0)
+ if e.Hdr.Ttl != oldTtl {
+ t.Fail()
+ }
+}
diff --git a/Godeps/_workspace/src/github.com/miekg/dns/example_test.go b/Godeps/_workspace/src/github.com/miekg/dns/example_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..1578a4d0539b329618d94602680e90704728503e
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/miekg/dns/example_test.go
@@ -0,0 +1,147 @@
+package dns_test
+
+import (
+ "errors"
+ "fmt"
+ "github.com/miekg/dns"
+ "log"
+ "net"
+)
+
+// Retrieve the MX records for miek.nl.
+func ExampleMX() {
+ config, _ := dns.ClientConfigFromFile("/etc/resolv.conf")
+ c := new(dns.Client)
+ m := new(dns.Msg)
+ m.SetQuestion("miek.nl.", dns.TypeMX)
+ m.RecursionDesired = true
+ r, _, err := c.Exchange(m, config.Servers[0]+":"+config.Port)
+ if err != nil {
+ return
+ }
+ if r.Rcode != dns.RcodeSuccess {
+ return
+ }
+ for _, a := range r.Answer {
+ if mx, ok := a.(*dns.MX); ok {
+ fmt.Printf("%s\n", mx.String())
+ }
+ }
+}
+
+// Retrieve the DNSKEY records of a zone and convert them
+// to DS records for SHA1, SHA256 and SHA384.
+func ExampleDS(zone string) {
+ config, _ := dns.ClientConfigFromFile("/etc/resolv.conf")
+ c := new(dns.Client)
+ m := new(dns.Msg)
+ if zone == "" {
+ zone = "miek.nl"
+ }
+ m.SetQuestion(dns.Fqdn(zone), dns.TypeDNSKEY)
+ m.SetEdns0(4096, true)
+ r, _, err := c.Exchange(m, config.Servers[0]+":"+config.Port)
+ if err != nil {
+ return
+ }
+ if r.Rcode != dns.RcodeSuccess {
+ return
+ }
+ for _, k := range r.Answer {
+ if key, ok := k.(*dns.DNSKEY); ok {
+ for _, alg := range []uint8{dns.SHA1, dns.SHA256, dns.SHA384} {
+ fmt.Printf("%s; %d\n", key.ToDS(alg).String(), key.Flags)
+ }
+ }
+ }
+}
+
+const TypeAPAIR = 0x0F99
+
+type APAIR struct {
+ addr [2]net.IP
+}
+
+func NewAPAIR() dns.PrivateRdata { return new(APAIR) }
+
+func (rd *APAIR) String() string { return rd.addr[0].String() + " " + rd.addr[1].String() }
+func (rd *APAIR) Parse(txt []string) error {
+ if len(txt) != 2 {
+ return errors.New("two addresses required for APAIR")
+ }
+ for i, s := range txt {
+ ip := net.ParseIP(s)
+ if ip == nil {
+ return errors.New("invalid IP in APAIR text representation")
+ }
+ rd.addr[i] = ip
+ }
+ return nil
+}
+
+func (rd *APAIR) Pack(buf []byte) (int, error) {
+ b := append([]byte(rd.addr[0]), []byte(rd.addr[1])...)
+ n := copy(buf, b)
+ if n != len(b) {
+ return n, dns.ErrBuf
+ }
+ return n, nil
+}
+
+func (rd *APAIR) Unpack(buf []byte) (int, error) {
+ ln := net.IPv4len * 2
+ if len(buf) != ln {
+ return 0, errors.New("invalid length of APAIR rdata")
+ }
+ cp := make([]byte, ln)
+ copy(cp, buf) // clone bytes to use them in IPs
+
+ rd.addr[0] = net.IP(cp[:3])
+ rd.addr[1] = net.IP(cp[4:])
+
+ return len(buf), nil
+}
+
+func (rd *APAIR) Copy(dest dns.PrivateRdata) error {
+ cp := make([]byte, rd.Len())
+ _, err := rd.Pack(cp)
+ if err != nil {
+ return err
+ }
+
+ d := dest.(*APAIR)
+ d.addr[0] = net.IP(cp[:3])
+ d.addr[1] = net.IP(cp[4:])
+ return nil
+}
+
+func (rd *APAIR) Len() int {
+ return net.IPv4len * 2
+}
+
+func ExamplePrivateHandle() {
+ dns.PrivateHandle("APAIR", TypeAPAIR, NewAPAIR)
+ defer dns.PrivateHandleRemove(TypeAPAIR)
+
+ rr, err := dns.NewRR("miek.nl. APAIR (1.2.3.4 1.2.3.5)")
+ if err != nil {
+ log.Fatal("could not parse APAIR record: ", err)
+ }
+ fmt.Println(rr)
+ // Output: miek.nl. 3600 IN APAIR 1.2.3.4 1.2.3.5
+
+ m := new(dns.Msg)
+ m.Id = 12345
+ m.SetQuestion("miek.nl.", TypeAPAIR)
+ m.Answer = append(m.Answer, rr)
+
+ fmt.Println(m)
+ // ;; opcode: QUERY, status: NOERROR, id: 12345
+ // ;; flags: rd; QUERY: 1, ANSWER: 1, AUTHORITY: 0, ADDITIONAL: 0
+ //
+ // ;; QUESTION SECTION:
+ // ;miek.nl. IN APAIR
+ //
+ // ;; ANSWER SECTION:
+ // miek.nl. 3600 IN APAIR 1.2.3.4 1.2.3.5
+}
diff --git a/Godeps/_workspace/src/github.com/miekg/dns/idn/example_test.go b/Godeps/_workspace/src/github.com/miekg/dns/idn/example_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..8833cd91de138e988b0e7d34c71422f5cc76ab08
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/miekg/dns/idn/example_test.go
@@ -0,0 +1,18 @@
+package idn_test
+
+import (
+ "fmt"
+ "github.com/miekg/dns/idn"
+)
+
+func ExampleToPunycode() {
+ name := "インターãƒãƒƒãƒˆ.テスト"
+ fmt.Printf("%s -> %s", name, idn.ToPunycode(name))
+ // Output: インターãƒãƒƒãƒˆ.テスト -> xn--eckucmux0ukc.xn--zckzah
+}
+
+func ExampleFromPunycode() {
+ name := "xn--mgbaja8a1hpac.xn--mgbachtv"
+ fmt.Printf("%s -> %s", name, idn.FromPunycode(name))
+ // Output: xn--mgbaja8a1hpac.xn--mgbachtv -> الانترنت.اختبار
+}
diff --git a/Godeps/_workspace/src/github.com/miekg/dns/idn/punycode.go b/Godeps/_workspace/src/github.com/miekg/dns/idn/punycode.go
new file mode 100644
index 0000000000000000000000000000000000000000..faab4027b9055397e784a5bb22e40c2a8e0d13e5
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/miekg/dns/idn/punycode.go
@@ -0,0 +1,268 @@
+// Package idn implements encoding from and to punycode as speficied by RFC 3492.
+package idn
+
+import (
+ "bytes"
+ "github.com/miekg/dns"
+ "strings"
+ "unicode"
+)
+
+// Implementation idea from RFC itself and from from IDNA::Punycode created by
+// Tatsuhiko Miyagawa <miyagawa@bulknews.net> and released under Perl Artistic
+// License in 2002.
+
+const (
+ _MIN rune = 1
+ _MAX rune = 26
+ _SKEW rune = 38
+ _BASE rune = 36
+ _BIAS rune = 72
+ _N rune = 128
+ _DAMP rune = 700
+
+ _DELIMITER = '-'
+ _PREFIX = "xn--"
+)
+
+// ToPunycode converts unicode domain names to DNS-appropriate punycode names.
+// This function would return incorrect result for strings for non-canonical
+// unicode strings.
+func ToPunycode(s string) string {
+ tokens := dns.SplitDomainName(s)
+ switch {
+ case s == "":
+ return ""
+ case tokens == nil: // s == .
+ return "."
+ case s[len(s)-1] == '.':
+ tokens = append(tokens, "")
+ }
+
+ for i := range tokens {
+ tokens[i] = string(encode([]byte(tokens[i])))
+ }
+ return strings.Join(tokens, ".")
+}
+
+// FromPunycode returns unicode domain name from provided punycode string.
+func FromPunycode(s string) string {
+ tokens := dns.SplitDomainName(s)
+ switch {
+ case s == "":
+ return ""
+ case tokens == nil: // s == .
+ return "."
+ case s[len(s)-1] == '.':
+ tokens = append(tokens, "")
+ }
+ for i := range tokens {
+ tokens[i] = string(decode([]byte(tokens[i])))
+ }
+ return strings.Join(tokens, ".")
+}
+
+// digitval converts single byte into meaningful value that's used to calculate decoded unicode character.
+const errdigit = 0xffff
+
+func digitval(code rune) rune {
+ switch {
+ case code >= 'A' && code <= 'Z':
+ return code - 'A'
+ case code >= 'a' && code <= 'z':
+ return code - 'a'
+ case code >= '0' && code <= '9':
+ return code - '0' + 26
+ }
+ return errdigit
+}
+
+// lettercode finds BASE36 byte (a-z0-9) based on calculated number.
+func lettercode(digit rune) rune {
+ switch {
+ case digit >= 0 && digit <= 25:
+ return digit + 'a'
+ case digit >= 26 && digit <= 36:
+ return digit - 26 + '0'
+ }
+ panic("dns: not reached")
+}
+
+// adapt calculates next bias to be used for next iteration delta.
+func adapt(delta rune, numpoints int, firsttime bool) rune {
+ if firsttime {
+ delta /= _DAMP
+ } else {
+ delta /= 2
+ }
+
+ var k rune
+ for delta = delta + delta/rune(numpoints); delta > (_BASE-_MIN)*_MAX/2; k += _BASE {
+ delta /= _BASE - _MIN
+ }
+
+ return k + ((_BASE-_MIN+1)*delta)/(delta+_SKEW)
+}
+
+// next finds minimal rune (one with lowest codepoint value) that should be equal or above boundary.
+func next(b []rune, boundary rune) rune {
+ if len(b) == 0 {
+ panic("dns: invalid set of runes to determine next one")
+ }
+ m := b[0]
+ for _, x := range b[1:] {
+ if x >= boundary && (m < boundary || x < m) {
+ m = x
+ }
+ }
+ return m
+}
+
+// preprune converts unicode rune to lower case. At this time it's not
+// supporting all things described in RFCs
+func preprune(r rune) rune {
+ if unicode.IsUpper(r) {
+ r = unicode.ToLower(r)
+ }
+ return r
+}
+
+// tfunc is a function that helps calculate each character weight
+func tfunc(k, bias rune) rune {
+ switch {
+ case k <= bias:
+ return _MIN
+ case k >= bias+_MAX:
+ return _MAX
+ }
+ return k - bias
+}
+
+// encode transforms Unicode input bytes (that represent DNS label) into punycode bytestream
+func encode(input []byte) []byte {
+ n, bias := _N, _BIAS
+
+ b := bytes.Runes(input)
+ for i := range b {
+ b[i] = preprune(b[i])
+ }
+
+ basic := make([]byte, 0, len(b))
+ for _, ltr := range b {
+ if ltr <= 0x7f {
+ basic = append(basic, byte(ltr))
+ }
+ }
+ basiclen := len(basic)
+ fulllen := len(b)
+ if basiclen == fulllen {
+ return basic
+ }
+
+ var out bytes.Buffer
+
+ out.WriteString(_PREFIX)
+ if basiclen > 0 {
+ out.Write(basic)
+ out.WriteByte(_DELIMITER)
+ }
+
+ var (
+ ltr, nextltr rune
+ delta, q rune // delta calculation (see rfc)
+ t, k, cp rune // weight and codepoint calculation
+ )
+
+ s := &bytes.Buffer{}
+ for h := basiclen; h < fulllen; n, delta = n+1, delta+1 {
+ nextltr = next(b, n)
+ s.Truncate(0)
+ s.WriteRune(nextltr)
+ delta, n = delta+(nextltr-n)*rune(h+1), nextltr
+
+ for _, ltr = range b {
+ if ltr < n {
+ delta++
+ }
+ if ltr == n {
+ q = delta
+ for k = _BASE; ; k += _BASE {
+ t = tfunc(k, bias)
+ if q < t {
+ break
+ }
+ cp = t + ((q - t) % (_BASE - t))
+ out.WriteRune(lettercode(cp))
+ q = (q - t) / (_BASE - t)
+ }
+
+ out.WriteRune(lettercode(q))
+
+ bias = adapt(delta, h+1, h == basiclen)
+ h, delta = h+1, 0
+ }
+ }
+ }
+ return out.Bytes()
+}
+
+// decode transforms punycode input bytes (that represent DNS label) into Unicode bytestream
+func decode(b []byte) []byte {
+ src := b // b would move and we need to keep it
+
+ n, bias := _N, _BIAS
+ if !bytes.HasPrefix(b, []byte(_PREFIX)) {
+ return b
+ }
+ out := make([]rune, 0, len(b))
+ b = b[len(_PREFIX):]
+ for pos, x := range b {
+ if x == _DELIMITER {
+ out = append(out, bytes.Runes(b[:pos])...)
+ b = b[pos+1:] // trim source string
+ break
+ }
+ }
+ if len(b) == 0 {
+ return src
+ }
+ var (
+ i, oldi, w rune
+ ch byte
+ t, digit rune
+ ln int
+ )
+
+ for i = 0; len(b) > 0; i++ {
+ oldi, w = i, 1
+ for k := _BASE; len(b) > 0; k += _BASE {
+ ch, b = b[0], b[1:]
+ digit = digitval(rune(ch))
+ if digit == errdigit {
+ return src
+ }
+ i += digit * w
+
+ t = tfunc(k, bias)
+ if digit < t {
+ break
+ }
+
+ w *= _BASE - t
+ }
+ ln = len(out) + 1
+ bias = adapt(i-oldi, ln, oldi == 0)
+ n += i / rune(ln)
+ i = i % rune(ln)
+ // insert
+ out = append(out, 0)
+ copy(out[i+1:], out[i:])
+ out[i] = n
+ }
+
+ var ret bytes.Buffer
+ for _, r := range out {
+ ret.WriteRune(r)
+ }
+ return ret.Bytes()
+}
diff --git a/Godeps/_workspace/src/github.com/miekg/dns/idn/punycode_test.go b/Godeps/_workspace/src/github.com/miekg/dns/idn/punycode_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..3202450aa52aea0db620068a0986c2ab4dfb8638
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/miekg/dns/idn/punycode_test.go
@@ -0,0 +1,94 @@
+package idn
+
+import (
+ "strings"
+ "testing"
+)
+
+var testcases = [][2]string{
+ {"", ""},
+ {"a", "a"},
+ {"A-B", "a-b"},
+ {"AbC", "abc"},
+ {"Ñ", "xn--41a"},
+ {"zÑ", "xn--z-0ub"},
+ {"ЯZ", "xn--z-zub"},
+ {"إختبار", "xn--kgbechtv"},
+ {"آزمایشی", "xn--hgbk6aj7f53bba"},
+ {"测试", "xn--0zwm56d"},
+ {"測試", "xn--g6w251d"},
+ {"ИÑпытание", "xn--80akhbyknj4f"},
+ {"परीकà¥à¤·à¤¾", "xn--11b5bs3a9aj6g"},
+ {"δοκιμή", "xn--jxalpdlp"},
+ {"테스트", "xn--9t4b11yi5a"},
+ {"טעסט", "xn--deba0ad"},
+ {"テスト", "xn--zckzah"},
+ {"பரிடà¯à®šà¯ˆ", "xn--hlcj6aya9esc7a"},
+}
+
+func TestEncodeDecodePunycode(t *testing.T) {
+ for _, tst := range testcases {
+ enc := encode([]byte(tst[0]))
+ if string(enc) != tst[1] {
+ t.Errorf("%s encodeded as %s but should be %s", tst[0], enc, tst[1])
+ }
+ dec := decode([]byte(tst[1]))
+ if string(dec) != strings.ToLower(tst[0]) {
+ t.Errorf("%s decoded as %s but should be %s", tst[1], dec, strings.ToLower(tst[0]))
+ }
+ }
+}
+
+func TestToFromPunycode(t *testing.T) {
+ for _, tst := range testcases {
+ // assert unicode.com == punycode.com
+ full := ToPunycode(tst[0] + ".com")
+ if full != tst[1]+".com" {
+ t.Errorf("invalid result from string conversion to punycode, %s and should be %s.com", full, tst[1])
+ }
+ // assert punycode.punycode == unicode.unicode
+ decoded := FromPunycode(tst[1] + "." + tst[1])
+ if decoded != strings.ToLower(tst[0]+"."+tst[0]) {
+ t.Errorf("invalid result from string conversion to punycode, %s and should be %s.%s", decoded, tst[0], tst[0])
+ }
+ }
+}
+
+func TestEncodeDecodeFinalPeriod(t *testing.T) {
+ for _, tst := range testcases {
+ // assert unicode.com. == punycode.com.
+ full := ToPunycode(tst[0] + ".")
+ if full != tst[1]+"." {
+ t.Errorf("invalid result from string conversion to punycode when period added at the end, %#v and should be %#v", full, tst[1]+".")
+ }
+ // assert punycode.com. == unicode.com.
+ decoded := FromPunycode(tst[1] + ".")
+ if decoded != strings.ToLower(tst[0]+".") {
+ t.Errorf("invalid result from string conversion to punycode when period added, %#v and should be %#v", decoded, tst[0]+".")
+ }
+ full = ToPunycode(tst[0])
+ if full != tst[1] {
+ t.Errorf("invalid result from string conversion to punycode when no period added at the end, %#v and should be %#v", full, tst[1]+".")
+ }
+ // assert punycode.com. == unicode.com.
+ decoded = FromPunycode(tst[1])
+ if decoded != strings.ToLower(tst[0]) {
+ t.Errorf("invalid result from string conversion to punycode when no period added, %#v and should be %#v", decoded, tst[0]+".")
+ }
+ }
+}
+
+var invalid = []string{
+ "xn--*",
+ "xn--",
+ "xn---",
+}
+
+func TestInvalidPunycode(t *testing.T) {
+ for _, d := range invalid {
+ s := FromPunycode(d)
+ if s != d {
+ t.Errorf("Changed invalid name %s to %#v", d, s)
+ }
+ }
+}
diff --git a/Godeps/_workspace/src/github.com/miekg/dns/keygen.go b/Godeps/_workspace/src/github.com/miekg/dns/keygen.go
new file mode 100644
index 0000000000000000000000000000000000000000..dfe328ecd436db3120fd137d4ce3e94ee3dedf8e
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/miekg/dns/keygen.go
@@ -0,0 +1,157 @@
+package dns
+
+import (
+ "crypto/dsa"
+ "crypto/ecdsa"
+ "crypto/elliptic"
+ "crypto/rand"
+ "crypto/rsa"
+ "math/big"
+ "strconv"
+)
+
+const _FORMAT = "Private-key-format: v1.3\n"
+
+// Empty interface that is used as a wrapper around all possible
+// private key implementations from the crypto package.
+type PrivateKey interface{}
+
+// Generate generates a DNSKEY of the given bit size.
+// The public part is put inside the DNSKEY record.
+// The Algorithm in the key must be set as this will define
+// what kind of DNSKEY will be generated.
+// The ECDSA algorithms imply a fixed keysize, in that case
+// bits should be set to the size of the algorithm.
+func (r *DNSKEY) Generate(bits int) (PrivateKey, error) {
+ switch r.Algorithm {
+ case DSA, DSANSEC3SHA1:
+ if bits != 1024 {
+ return nil, ErrKeySize
+ }
+ case RSAMD5, RSASHA1, RSASHA256, RSASHA1NSEC3SHA1:
+ if bits < 512 || bits > 4096 {
+ return nil, ErrKeySize
+ }
+ case RSASHA512:
+ if bits < 1024 || bits > 4096 {
+ return nil, ErrKeySize
+ }
+ case ECDSAP256SHA256:
+ if bits != 256 {
+ return nil, ErrKeySize
+ }
+ case ECDSAP384SHA384:
+ if bits != 384 {
+ return nil, ErrKeySize
+ }
+ }
+
+ switch r.Algorithm {
+ case DSA, DSANSEC3SHA1:
+ params := new(dsa.Parameters)
+ if err := dsa.GenerateParameters(params, rand.Reader, dsa.L1024N160); err != nil {
+ return nil, err
+ }
+ priv := new(dsa.PrivateKey)
+ priv.PublicKey.Parameters = *params
+ err := dsa.GenerateKey(priv, rand.Reader)
+ if err != nil {
+ return nil, err
+ }
+ r.setPublicKeyDSA(params.Q, params.P, params.G, priv.PublicKey.Y)
+ return priv, nil
+ case RSAMD5, RSASHA1, RSASHA256, RSASHA512, RSASHA1NSEC3SHA1:
+ priv, err := rsa.GenerateKey(rand.Reader, bits)
+ if err != nil {
+ return nil, err
+ }
+ r.setPublicKeyRSA(priv.PublicKey.E, priv.PublicKey.N)
+ return priv, nil
+ case ECDSAP256SHA256, ECDSAP384SHA384:
+ var c elliptic.Curve
+ switch r.Algorithm {
+ case ECDSAP256SHA256:
+ c = elliptic.P256()
+ case ECDSAP384SHA384:
+ c = elliptic.P384()
+ }
+ priv, err := ecdsa.GenerateKey(c, rand.Reader)
+ if err != nil {
+ return nil, err
+ }
+ r.setPublicKeyCurve(priv.PublicKey.X, priv.PublicKey.Y)
+ return priv, nil
+ default:
+ return nil, ErrAlg
+ }
+ return nil, nil // Dummy return
+}
+
+// PrivateKeyString converts a PrivateKey to a string. This
+// string has the same format as the private-key-file of BIND9 (Private-key-format: v1.3).
+// It needs some info from the key (hashing, keytag), so its a method of the DNSKEY.
+func (r *DNSKEY) PrivateKeyString(p PrivateKey) (s string) {
+ switch t := p.(type) {
+ case *rsa.PrivateKey:
+ algorithm := strconv.Itoa(int(r.Algorithm)) + " (" + AlgorithmToString[r.Algorithm] + ")"
+ modulus := toBase64(t.PublicKey.N.Bytes())
+ e := big.NewInt(int64(t.PublicKey.E))
+ publicExponent := toBase64(e.Bytes())
+ privateExponent := toBase64(t.D.Bytes())
+ prime1 := toBase64(t.Primes[0].Bytes())
+ prime2 := toBase64(t.Primes[1].Bytes())
+ // Calculate Exponent1/2 and Coefficient as per: http://en.wikipedia.org/wiki/RSA#Using_the_Chinese_remainder_algorithm
+ // and from: http://code.google.com/p/go/issues/detail?id=987
+ one := big.NewInt(1)
+ minusone := big.NewInt(-1)
+ p_1 := big.NewInt(0).Sub(t.Primes[0], one)
+ q_1 := big.NewInt(0).Sub(t.Primes[1], one)
+ exp1 := big.NewInt(0).Mod(t.D, p_1)
+ exp2 := big.NewInt(0).Mod(t.D, q_1)
+ coeff := big.NewInt(0).Exp(t.Primes[1], minusone, t.Primes[0])
+
+ exponent1 := toBase64(exp1.Bytes())
+ exponent2 := toBase64(exp2.Bytes())
+ coefficient := toBase64(coeff.Bytes())
+
+ s = _FORMAT +
+ "Algorithm: " + algorithm + "\n" +
+ "Modules: " + modulus + "\n" +
+ "PublicExponent: " + publicExponent + "\n" +
+ "PrivateExponent: " + privateExponent + "\n" +
+ "Prime1: " + prime1 + "\n" +
+ "Prime2: " + prime2 + "\n" +
+ "Exponent1: " + exponent1 + "\n" +
+ "Exponent2: " + exponent2 + "\n" +
+ "Coefficient: " + coefficient + "\n"
+ case *ecdsa.PrivateKey:
+ algorithm := strconv.Itoa(int(r.Algorithm)) + " (" + AlgorithmToString[r.Algorithm] + ")"
+ var intlen int
+ switch r.Algorithm {
+ case ECDSAP256SHA256:
+ intlen = 32
+ case ECDSAP384SHA384:
+ intlen = 48
+ }
+ private := toBase64(intToBytes(t.D, intlen))
+ s = _FORMAT +
+ "Algorithm: " + algorithm + "\n" +
+ "PrivateKey: " + private + "\n"
+ case *dsa.PrivateKey:
+ algorithm := strconv.Itoa(int(r.Algorithm)) + " (" + AlgorithmToString[r.Algorithm] + ")"
+ T := divRoundUp(divRoundUp(t.PublicKey.Parameters.G.BitLen(), 8)-64, 8)
+ prime := toBase64(intToBytes(t.PublicKey.Parameters.P, 64+T*8))
+ subprime := toBase64(intToBytes(t.PublicKey.Parameters.Q, 20))
+ base := toBase64(intToBytes(t.PublicKey.Parameters.G, 64+T*8))
+ priv := toBase64(intToBytes(t.X, 20))
+ pub := toBase64(intToBytes(t.PublicKey.Y, 64+T*8))
+ s = _FORMAT +
+ "Algorithm: " + algorithm + "\n" +
+ "Prime(p): " + prime + "\n" +
+ "Subprime(q): " + subprime + "\n" +
+ "Base(g): " + base + "\n" +
+ "Private_value(x): " + priv + "\n" +
+ "Public_value(y): " + pub + "\n"
+ }
+ return
+}
diff --git a/Godeps/_workspace/src/github.com/miekg/dns/kscan.go b/Godeps/_workspace/src/github.com/miekg/dns/kscan.go
new file mode 100644
index 0000000000000000000000000000000000000000..c48ca2d24b71cce6330033ea16cad569b7afaa4f
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/miekg/dns/kscan.go
@@ -0,0 +1,244 @@
+package dns
+
+import (
+ "crypto/dsa"
+ "crypto/ecdsa"
+ "crypto/rsa"
+ "io"
+ "math/big"
+ "strings"
+)
+
+func (k *DNSKEY) NewPrivateKey(s string) (PrivateKey, error) {
+ if s[len(s)-1] != '\n' { // We need a closing newline
+ return k.ReadPrivateKey(strings.NewReader(s+"\n"), "")
+ }
+ return k.ReadPrivateKey(strings.NewReader(s), "")
+}
+
+// ReadPrivateKey reads a private key from the io.Reader q. The string file is
+// only used in error reporting.
+// The public key must be
+// known, because some cryptographic algorithms embed the public inside the privatekey.
+func (k *DNSKEY) ReadPrivateKey(q io.Reader, file string) (PrivateKey, error) {
+ m, e := parseKey(q, file)
+ if m == nil {
+ return nil, e
+ }
+ if _, ok := m["private-key-format"]; !ok {
+ return nil, ErrPrivKey
+ }
+ if m["private-key-format"] != "v1.2" && m["private-key-format"] != "v1.3" {
+ return nil, ErrPrivKey
+ }
+ // TODO(mg): check if the pubkey matches the private key
+ switch m["algorithm"] {
+ case "3 (DSA)":
+ p, e := readPrivateKeyDSA(m)
+ if e != nil {
+ return nil, e
+ }
+ if !k.setPublicKeyInPrivate(p) {
+ return nil, ErrKey
+ }
+ return p, e
+ case "1 (RSAMD5)":
+ fallthrough
+ case "5 (RSASHA1)":
+ fallthrough
+ case "7 (RSASHA1NSEC3SHA1)":
+ fallthrough
+ case "8 (RSASHA256)":
+ fallthrough
+ case "10 (RSASHA512)":
+ p, e := readPrivateKeyRSA(m)
+ if e != nil {
+ return nil, e
+ }
+ if !k.setPublicKeyInPrivate(p) {
+ return nil, ErrKey
+ }
+ return p, e
+ case "12 (ECC-GOST)":
+ p, e := readPrivateKeyGOST(m)
+ if e != nil {
+ return nil, e
+ }
+ // setPublicKeyInPrivate(p)
+ return p, e
+ case "13 (ECDSAP256SHA256)":
+ fallthrough
+ case "14 (ECDSAP384SHA384)":
+ p, e := readPrivateKeyECDSA(m)
+ if e != nil {
+ return nil, e
+ }
+ if !k.setPublicKeyInPrivate(p) {
+ return nil, ErrKey
+ }
+ return p, e
+ }
+ return nil, ErrPrivKey
+}
+
+// Read a private key (file) string and create a public key. Return the private key.
+func readPrivateKeyRSA(m map[string]string) (PrivateKey, error) {
+ p := new(rsa.PrivateKey)
+ p.Primes = []*big.Int{nil, nil}
+ for k, v := range m {
+ switch k {
+ case "modulus", "publicexponent", "privateexponent", "prime1", "prime2":
+ v1, err := fromBase64([]byte(v))
+ if err != nil {
+ return nil, err
+ }
+ switch k {
+ case "modulus":
+ p.PublicKey.N = big.NewInt(0)
+ p.PublicKey.N.SetBytes(v1)
+ case "publicexponent":
+ i := big.NewInt(0)
+ i.SetBytes(v1)
+ p.PublicKey.E = int(i.Int64()) // int64 should be large enough
+ case "privateexponent":
+ p.D = big.NewInt(0)
+ p.D.SetBytes(v1)
+ case "prime1":
+ p.Primes[0] = big.NewInt(0)
+ p.Primes[0].SetBytes(v1)
+ case "prime2":
+ p.Primes[1] = big.NewInt(0)
+ p.Primes[1].SetBytes(v1)
+ }
+ case "exponent1", "exponent2", "coefficient":
+ // not used in Go (yet)
+ case "created", "publish", "activate":
+ // not used in Go (yet)
+ }
+ }
+ return p, nil
+}
+
+func readPrivateKeyDSA(m map[string]string) (PrivateKey, error) {
+ p := new(dsa.PrivateKey)
+ p.X = big.NewInt(0)
+ for k, v := range m {
+ switch k {
+ case "private_value(x)":
+ v1, err := fromBase64([]byte(v))
+ if err != nil {
+ return nil, err
+ }
+ p.X.SetBytes(v1)
+ case "created", "publish", "activate":
+ /* not used in Go (yet) */
+ }
+ }
+ return p, nil
+}
+
+func readPrivateKeyECDSA(m map[string]string) (PrivateKey, error) {
+ p := new(ecdsa.PrivateKey)
+ p.D = big.NewInt(0)
+ // TODO: validate that the required flags are present
+ for k, v := range m {
+ switch k {
+ case "privatekey":
+ v1, err := fromBase64([]byte(v))
+ if err != nil {
+ return nil, err
+ }
+ p.D.SetBytes(v1)
+ case "created", "publish", "activate":
+ /* not used in Go (yet) */
+ }
+ }
+ return p, nil
+}
+
+func readPrivateKeyGOST(m map[string]string) (PrivateKey, error) {
+ // TODO(miek)
+ return nil, nil
+}
+
+// parseKey reads a private key from r. It returns a map[string]string,
+// with the key-value pairs, or an error when the file is not correct.
+func parseKey(r io.Reader, file string) (map[string]string, error) {
+ s := scanInit(r)
+ m := make(map[string]string)
+ c := make(chan lex)
+ k := ""
+ // Start the lexer
+ go klexer(s, c)
+ for l := range c {
+ // It should alternate
+ switch l.value {
+ case _KEY:
+ k = l.token
+ case _VALUE:
+ if k == "" {
+ return nil, &ParseError{file, "no private key seen", l}
+ }
+ //println("Setting", strings.ToLower(k), "to", l.token, "b")
+ m[strings.ToLower(k)] = l.token
+ k = ""
+ }
+ }
+ return m, nil
+}
+
+// klexer scans the sourcefile and returns tokens on the channel c.
+func klexer(s *scan, c chan lex) {
+ var l lex
+ str := "" // Hold the current read text
+ commt := false
+ key := true
+ x, err := s.tokenText()
+ defer close(c)
+ for err == nil {
+ l.column = s.position.Column
+ l.line = s.position.Line
+ switch x {
+ case ':':
+ if commt {
+ break
+ }
+ l.token = str
+ if key {
+ l.value = _KEY
+ c <- l
+ // Next token is a space, eat it
+ s.tokenText()
+ key = false
+ str = ""
+ } else {
+ l.value = _VALUE
+ }
+ case ';':
+ commt = true
+ case '\n':
+ if commt {
+ // Reset a comment
+ commt = false
+ }
+ l.value = _VALUE
+ l.token = str
+ c <- l
+ str = ""
+ commt = false
+ key = true
+ default:
+ if commt {
+ break
+ }
+ str += string(x)
+ }
+ x, err = s.tokenText()
+ }
+ if len(str) > 0 {
+ // Send remainder
+ l.token = str
+ l.value = _VALUE
+ c <- l
+ }
+}
diff --git a/Godeps/_workspace/src/github.com/miekg/dns/labels.go b/Godeps/_workspace/src/github.com/miekg/dns/labels.go
new file mode 100644
index 0000000000000000000000000000000000000000..758e5783de5a83d5da629712f633552060e955fb
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/miekg/dns/labels.go
@@ -0,0 +1,162 @@
+package dns
+
+// Holds a bunch of helper functions for dealing with labels.
+
+// SplitDomainName splits a name string into it's labels.
+// www.miek.nl. returns []string{"www", "miek", "nl"}
+// The root label (.) returns nil. Note that using
+// strings.Split(s) will work in most cases, but does not handle
+// escaped dots (\.) for instance.
+func SplitDomainName(s string) (labels []string) {
+ if len(s) == 0 {
+ return nil
+ }
+ fqdnEnd := 0 // offset of the final '.' or the length of the name
+ idx := Split(s)
+ begin := 0
+ if s[len(s)-1] == '.' {
+ fqdnEnd = len(s) - 1
+ } else {
+ fqdnEnd = len(s)
+ }
+
+ switch len(idx) {
+ case 0:
+ return nil
+ case 1:
+ // no-op
+ default:
+ end := 0
+ for i := 1; i < len(idx); i++ {
+ end = idx[i]
+ labels = append(labels, s[begin:end-1])
+ begin = end
+ }
+ }
+
+ labels = append(labels, s[begin:fqdnEnd])
+ return labels
+}
+
+// CompareDomainName compares the names s1 and s2 and
+// returns how many labels they have in common starting from the *right*.
+// The comparison stops at the first inequality. The names are not downcased
+// before the comparison.
+//
+// www.miek.nl. and miek.nl. have two labels in common: miek and nl
+// www.miek.nl. and www.bla.nl. have one label in common: nl
+func CompareDomainName(s1, s2 string) (n int) {
+ s1 = Fqdn(s1)
+ s2 = Fqdn(s2)
+ l1 := Split(s1)
+ l2 := Split(s2)
+
+ // the first check: root label
+ if l1 == nil || l2 == nil {
+ return
+ }
+
+ j1 := len(l1) - 1 // end
+ i1 := len(l1) - 2 // start
+ j2 := len(l2) - 1
+ i2 := len(l2) - 2
+ // the second check can be done here: last/only label
+ // before we fall through into the for-loop below
+ if s1[l1[j1]:] == s2[l2[j2]:] {
+ n++
+ } else {
+ return
+ }
+ for {
+ if i1 < 0 || i2 < 0 {
+ break
+ }
+ if s1[l1[i1]:l1[j1]] == s2[l2[i2]:l2[j2]] {
+ n++
+ } else {
+ break
+ }
+ j1--
+ i1--
+ j2--
+ i2--
+ }
+ return
+}
+
+// CountLabel counts the the number of labels in the string s.
+func CountLabel(s string) (labels int) {
+ if s == "." {
+ return
+ }
+ off := 0
+ end := false
+ for {
+ off, end = NextLabel(s, off)
+ labels++
+ if end {
+ return
+ }
+ }
+ panic("dns: not reached")
+}
+
+// Split splits a name s into its label indexes.
+// www.miek.nl. returns []int{0, 4, 9}, www.miek.nl also returns []int{0, 4, 9}.
+// The root name (.) returns nil. Also see dns.SplitDomainName.
+func Split(s string) []int {
+ if s == "." {
+ return nil
+ }
+ idx := make([]int, 1, 3)
+ off := 0
+ end := false
+
+ for {
+ off, end = NextLabel(s, off)
+ if end {
+ return idx
+ }
+ idx = append(idx, off)
+ }
+ panic("dns: not reached")
+}
+
+// NextLabel returns the index of the start of the next label in the
+// string s starting at offset.
+// The bool end is true when the end of the string has been reached.
+func NextLabel(s string, offset int) (i int, end bool) {
+ quote := false
+ for i = offset; i < len(s)-1; i++ {
+ switch s[i] {
+ case '\\':
+ quote = !quote
+ default:
+ quote = false
+ case '.':
+ if quote {
+ quote = !quote
+ continue
+ }
+ return i + 1, false
+ }
+ }
+ return i + 1, true
+}
+
+// PrevLabel returns the index of the label when starting from the right and
+// jumping n labels to the left.
+// The bool start is true when the start of the string has been overshot.
+func PrevLabel(s string, n int) (i int, start bool) {
+ if n == 0 {
+ return len(s), false
+ }
+ lab := Split(s)
+ if lab == nil {
+ return 0, true
+ }
+ if n > len(lab) {
+ return 0, true
+ }
+ return lab[len(lab)-n], false
+}
diff --git a/Godeps/_workspace/src/github.com/miekg/dns/labels_test.go b/Godeps/_workspace/src/github.com/miekg/dns/labels_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..1d8da155fd55848e39ff0e860801a949e242d0f1
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/miekg/dns/labels_test.go
@@ -0,0 +1,214 @@
+package dns
+
+import (
+ "testing"
+)
+
+func TestCompareDomainName(t *testing.T) {
+ s1 := "www.miek.nl."
+ s2 := "miek.nl."
+ s3 := "www.bla.nl."
+ s4 := "nl.www.bla."
+ s5 := "nl"
+ s6 := "miek.nl"
+
+ if CompareDomainName(s1, s2) != 2 {
+ t.Logf("%s with %s should be %d", s1, s2, 2)
+ t.Fail()
+ }
+ if CompareDomainName(s1, s3) != 1 {
+ t.Logf("%s with %s should be %d", s1, s3, 1)
+ t.Fail()
+ }
+ if CompareDomainName(s3, s4) != 0 {
+ t.Logf("%s with %s should be %d", s3, s4, 0)
+ t.Fail()
+ }
+ // Non qualified tests
+ if CompareDomainName(s1, s5) != 1 {
+ t.Logf("%s with %s should be %d", s1, s5, 1)
+ t.Fail()
+ }
+ if CompareDomainName(s1, s6) != 2 {
+ t.Logf("%s with %s should be %d", s1, s5, 2)
+ t.Fail()
+ }
+
+ if CompareDomainName(s1, ".") != 0 {
+ t.Logf("%s with %s should be %d", s1, s5, 0)
+ t.Fail()
+ }
+ if CompareDomainName(".", ".") != 0 {
+ t.Logf("%s with %s should be %d", ".", ".", 0)
+ t.Fail()
+ }
+}
+
+func TestSplit(t *testing.T) {
+ splitter := map[string]int{
+ "www.miek.nl.": 3,
+ "www.miek.nl": 3,
+ "www..miek.nl": 4,
+ `www\.miek.nl.`: 2,
+ `www\\.miek.nl.`: 3,
+ ".": 0,
+ "nl.": 1,
+ "nl": 1,
+ "com.": 1,
+ ".com.": 2,
+ }
+ for s, i := range splitter {
+ if x := len(Split(s)); x != i {
+ t.Logf("labels should be %d, got %d: %s %v\n", i, x, s, Split(s))
+ t.Fail()
+ } else {
+ t.Logf("%s %v\n", s, Split(s))
+ }
+ }
+}
+
+func TestSplit2(t *testing.T) {
+ splitter := map[string][]int{
+ "www.miek.nl.": []int{0, 4, 9},
+ "www.miek.nl": []int{0, 4, 9},
+ "nl": []int{0},
+ }
+ for s, i := range splitter {
+ x := Split(s)
+ switch len(i) {
+ case 1:
+ if x[0] != i[0] {
+ t.Logf("labels should be %v, got %v: %s\n", i, x, s)
+ t.Fail()
+ }
+ default:
+ if x[0] != i[0] || x[1] != i[1] || x[2] != i[2] {
+ t.Logf("labels should be %v, got %v: %s\n", i, x, s)
+ t.Fail()
+ }
+ }
+ }
+}
+
+func TestPrevLabel(t *testing.T) {
+ type prev struct {
+ string
+ int
+ }
+ prever := map[prev]int{
+ prev{"www.miek.nl.", 0}: 12,
+ prev{"www.miek.nl.", 1}: 9,
+ prev{"www.miek.nl.", 2}: 4,
+
+ prev{"www.miek.nl", 0}: 11,
+ prev{"www.miek.nl", 1}: 9,
+ prev{"www.miek.nl", 2}: 4,
+
+ prev{"www.miek.nl.", 5}: 0,
+ prev{"www.miek.nl", 5}: 0,
+
+ prev{"www.miek.nl.", 3}: 0,
+ prev{"www.miek.nl", 3}: 0,
+ }
+ for s, i := range prever {
+ x, ok := PrevLabel(s.string, s.int)
+ if i != x {
+ t.Logf("label should be %d, got %d, %t: preving %d, %s\n", i, x, ok, s.int, s.string)
+ t.Fail()
+ }
+ }
+}
+
+func TestCountLabel(t *testing.T) {
+ splitter := map[string]int{
+ "www.miek.nl.": 3,
+ "www.miek.nl": 3,
+ "nl": 1,
+ ".": 0,
+ }
+ for s, i := range splitter {
+ x := CountLabel(s)
+ if x != i {
+ t.Logf("CountLabel should have %d, got %d\n", i, x)
+ t.Fail()
+ }
+ }
+}
+
+func TestSplitDomainName(t *testing.T) {
+ labels := map[string][]string{
+ "miek.nl": []string{"miek", "nl"},
+ ".": nil,
+ "www.miek.nl.": []string{"www", "miek", "nl"},
+ "www.miek.nl": []string{"www", "miek", "nl"},
+ "www..miek.nl": []string{"www", "", "miek", "nl"},
+ `www\.miek.nl`: []string{`www\.miek`, "nl"},
+ `www\\.miek.nl`: []string{`www\\`, "miek", "nl"},
+ }
+domainLoop:
+ for domain, splits := range labels {
+ parts := SplitDomainName(domain)
+ if len(parts) != len(splits) {
+ t.Logf("SplitDomainName returned %v for %s, expected %v", parts, domain, splits)
+ t.Fail()
+ continue domainLoop
+ }
+ for i := range parts {
+ if parts[i] != splits[i] {
+ t.Logf("SplitDomainName returned %v for %s, expected %v", parts, domain, splits)
+ t.Fail()
+ continue domainLoop
+ }
+ }
+ }
+}
+
+func TestIsDomainName(t *testing.T) {
+ type ret struct {
+ ok bool
+ lab int
+ }
+ names := map[string]*ret{
+ "..": &ret{false, 1},
+ "@.": &ret{true, 1},
+ "www.example.com": &ret{true, 3},
+ "www.e%ample.com": &ret{true, 3},
+ "www.example.com.": &ret{true, 3},
+ "mi\\k.nl.": &ret{true, 2},
+ "mi\\k.nl": &ret{true, 2},
+ }
+ for d, ok := range names {
+ l, k := IsDomainName(d)
+ if ok.ok != k || ok.lab != l {
+ t.Logf(" got %v %d for %s ", k, l, d)
+ t.Logf("have %v %d for %s ", ok.ok, ok.lab, d)
+ t.Fail()
+ }
+ }
+}
+
+func BenchmarkSplitLabels(b *testing.B) {
+ for i := 0; i < b.N; i++ {
+ Split("www.example.com")
+ }
+}
+
+func BenchmarkLenLabels(b *testing.B) {
+ for i := 0; i < b.N; i++ {
+ CountLabel("www.example.com")
+ }
+}
+
+func BenchmarkCompareLabels(b *testing.B) {
+ for i := 0; i < b.N; i++ {
+ CompareDomainName("www.example.com", "aa.example.com")
+ }
+}
+
+func BenchmarkIsSubDomain(b *testing.B) {
+ for i := 0; i < b.N; i++ {
+ IsSubDomain("www.example.com", "aa.example.com")
+ IsSubDomain("example.com", "aa.example.com")
+ IsSubDomain("miek.nl", "aa.example.com")
+ }
+}
diff --git a/Godeps/_workspace/src/github.com/miekg/dns/msg.go b/Godeps/_workspace/src/github.com/miekg/dns/msg.go
new file mode 100644
index 0000000000000000000000000000000000000000..ecba463dddaba22ae145f39c83c92e005dd3c2c8
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/miekg/dns/msg.go
@@ -0,0 +1,1899 @@
+// DNS packet assembly, see RFC 1035. Converting from - Unpack() -
+// and to - Pack() - wire format.
+// All the packers and unpackers take a (msg []byte, off int)
+// and return (off1 int, ok bool). If they return ok==false, they
+// also return off1==len(msg), so that the next unpacker will
+// also fail. This lets us avoid checks of ok until the end of a
+// packing sequence.
+
+package dns
+
+import (
+ "encoding/base32"
+ "encoding/base64"
+ "encoding/hex"
+ "math/big"
+ "math/rand"
+ "net"
+ "reflect"
+ "strconv"
+ "time"
+)
+
+const maxCompressionOffset = 2 << 13 // We have 14 bits for the compression pointer
+
+var (
+ ErrAlg error = &Error{err: "bad algorithm"}
+ ErrAuth error = &Error{err: "bad authentication"}
+ ErrBuf error = &Error{err: "buffer size too small"}
+ ErrConnEmpty error = &Error{err: "conn has no connection"}
+ ErrConn error = &Error{err: "conn holds both UDP and TCP connection"}
+ ErrExtendedRcode error = &Error{err: "bad extended rcode"}
+ ErrFqdn error = &Error{err: "domain must be fully qualified"}
+ ErrId error = &Error{err: "id mismatch"}
+ ErrKeyAlg error = &Error{err: "bad key algorithm"}
+ ErrKey error = &Error{err: "bad key"}
+ ErrKeySize error = &Error{err: "bad key size"}
+ ErrNoSig error = &Error{err: "no signature found"}
+ ErrPrivKey error = &Error{err: "bad private key"}
+ ErrRcode error = &Error{err: "bad rcode"}
+ ErrRdata error = &Error{err: "bad rdata"}
+ ErrRRset error = &Error{err: "bad rrset"}
+ ErrSecret error = &Error{err: "no secrets defined"}
+ ErrServ error = &Error{err: "no servers could be reached"}
+ ErrShortRead error = &Error{err: "short read"}
+ ErrSig error = &Error{err: "bad signature"}
+ ErrSigGen error = &Error{err: "bad signature generation"}
+ ErrSoa error = &Error{err: "no SOA"}
+ ErrTime error = &Error{err: "bad time"}
+)
+
+// Id, by default, returns a 16 bits random number to be used as a
+// message id. The random provided should be good enough. This being a
+// variable the function can be reassigned to a custom function.
+// For instance, to make it return a static value:
+//
+// dns.Id = func() uint16 { return 3 }
+var Id func() uint16 = id
+
+// A manually-unpacked version of (id, bits).
+// This is in its own struct for easy printing.
+type MsgHdr struct {
+ Id uint16
+ Response bool
+ Opcode int
+ Authoritative bool
+ Truncated bool
+ RecursionDesired bool
+ RecursionAvailable bool
+ Zero bool
+ AuthenticatedData bool
+ CheckingDisabled bool
+ Rcode int
+}
+
+// The layout of a DNS message.
+type Msg struct {
+ MsgHdr
+ Compress bool `json:"-"` // If true, the message will be compressed when converted to wire format. This not part of the official DNS packet format.
+ Question []Question // Holds the RR(s) of the question section.
+ Answer []RR // Holds the RR(s) of the answer section.
+ Ns []RR // Holds the RR(s) of the authority section.
+ Extra []RR // Holds the RR(s) of the additional section.
+}
+
+// Map of strings for each RR wire type.
+var TypeToString = map[uint16]string{
+ TypeA: "A",
+ TypeAAAA: "AAAA",
+ TypeAFSDB: "AFSDB",
+ TypeANY: "ANY", // Meta RR
+ TypeATMA: "ATMA",
+ TypeAXFR: "AXFR", // Meta RR
+ TypeCAA: "CAA",
+ TypeCDNSKEY: "CDNSKEY",
+ TypeCDS: "CDS",
+ TypeCERT: "CERT",
+ TypeCNAME: "CNAME",
+ TypeDHCID: "DHCID",
+ TypeDLV: "DLV",
+ TypeDNAME: "DNAME",
+ TypeDNSKEY: "DNSKEY",
+ TypeDS: "DS",
+ TypeEID: "EID",
+ TypeEUI48: "EUI48",
+ TypeEUI64: "EUI64",
+ TypeGID: "GID",
+ TypeGPOS: "GPOS",
+ TypeHINFO: "HINFO",
+ TypeHIP: "HIP",
+ TypeIPSECKEY: "IPSECKEY",
+ TypeISDN: "ISDN",
+ TypeIXFR: "IXFR", // Meta RR
+ TypeKEY: "KEY",
+ TypeKX: "KX",
+ TypeL32: "L32",
+ TypeL64: "L64",
+ TypeLOC: "LOC",
+ TypeLP: "LP",
+ TypeMB: "MB",
+ TypeMD: "MD",
+ TypeMF: "MF",
+ TypeMG: "MG",
+ TypeMINFO: "MINFO",
+ TypeMR: "MR",
+ TypeMX: "MX",
+ TypeNAPTR: "NAPTR",
+ TypeNID: "NID",
+ TypeNINFO: "NINFO",
+ TypeNIMLOC: "NIMLOC",
+ TypeNS: "NS",
+ TypeNSAP: "NSAP",
+ TypeNSAPPTR: "NSAP-PTR",
+ TypeNSEC3: "NSEC3",
+ TypeNSEC3PARAM: "NSEC3PARAM",
+ TypeNSEC: "NSEC",
+ TypeNULL: "NULL",
+ TypeOPT: "OPT",
+ TypeOPENPGPKEY: "OPENPGPKEY",
+ TypePTR: "PTR",
+ TypeRKEY: "RKEY",
+ TypeRP: "RP",
+ TypeRRSIG: "RRSIG",
+ TypeRT: "RT",
+ TypeSIG: "SIG",
+ TypeSOA: "SOA",
+ TypeSPF: "SPF",
+ TypeSRV: "SRV",
+ TypeSSHFP: "SSHFP",
+ TypeTA: "TA",
+ TypeTALINK: "TALINK",
+ TypeTKEY: "TKEY", // Meta RR
+ TypeTLSA: "TLSA",
+ TypeTSIG: "TSIG", // Meta RR
+ TypeTXT: "TXT",
+ TypePX: "PX",
+ TypeUID: "UID",
+ TypeUINFO: "UINFO",
+ TypeUNSPEC: "UNSPEC",
+ TypeURI: "URI",
+ TypeWKS: "WKS",
+ TypeX25: "X25",
+}
+
+// Reverse, needed for string parsing.
+var StringToType = reverseInt16(TypeToString)
+var StringToClass = reverseInt16(ClassToString)
+
+// Map of opcodes strings.
+var StringToOpcode = reverseInt(OpcodeToString)
+
+// Map of rcodes strings.
+var StringToRcode = reverseInt(RcodeToString)
+
+// Map of strings for each CLASS wire type.
+var ClassToString = map[uint16]string{
+ ClassINET: "IN",
+ ClassCSNET: "CS",
+ ClassCHAOS: "CH",
+ ClassHESIOD: "HS",
+ ClassNONE: "NONE",
+ ClassANY: "ANY",
+}
+
+// Map of strings for opcodes.
+var OpcodeToString = map[int]string{
+ OpcodeQuery: "QUERY",
+ OpcodeIQuery: "IQUERY",
+ OpcodeStatus: "STATUS",
+ OpcodeNotify: "NOTIFY",
+ OpcodeUpdate: "UPDATE",
+}
+
+// Map of strings for rcodes.
+var RcodeToString = map[int]string{
+ RcodeSuccess: "NOERROR",
+ RcodeFormatError: "FORMERR",
+ RcodeServerFailure: "SERVFAIL",
+ RcodeNameError: "NXDOMAIN",
+ RcodeNotImplemented: "NOTIMPL",
+ RcodeRefused: "REFUSED",
+ RcodeYXDomain: "YXDOMAIN", // From RFC 2136
+ RcodeYXRrset: "YXRRSET",
+ RcodeNXRrset: "NXRRSET",
+ RcodeNotAuth: "NOTAUTH",
+ RcodeNotZone: "NOTZONE",
+ RcodeBadSig: "BADSIG", // Also known as RcodeBadVers, see RFC 6891
+ // RcodeBadVers: "BADVERS",
+ RcodeBadKey: "BADKEY",
+ RcodeBadTime: "BADTIME",
+ RcodeBadMode: "BADMODE",
+ RcodeBadName: "BADNAME",
+ RcodeBadAlg: "BADALG",
+ RcodeBadTrunc: "BADTRUNC",
+}
+
+// Rather than write the usual handful of routines to pack and
+// unpack every message that can appear on the wire, we use
+// reflection to write a generic pack/unpack for structs and then
+// use it. Thus, if in the future we need to define new message
+// structs, no new pack/unpack/printing code needs to be written.
+
+// Domain names are a sequence of counted strings
+// split at the dots. They end with a zero-length string.
+
+// PackDomainName packs a domain name s into msg[off:].
+// If compression is wanted compress must be true and the compression
+// map needs to hold a mapping between domain names and offsets
+// pointing into msg[].
+func PackDomainName(s string, msg []byte, off int, compression map[string]int, compress bool) (off1 int, err error) {
+ off1, _, err = packDomainName(s, msg, off, compression, compress)
+ return
+}
+
+func packDomainName(s string, msg []byte, off int, compression map[string]int, compress bool) (off1 int, labels int, err error) {
+ // special case if msg == nil
+ lenmsg := 256
+ if msg != nil {
+ lenmsg = len(msg)
+ }
+ ls := len(s)
+ if ls == 0 { // Ok, for instance when dealing with update RR without any rdata.
+ return off, 0, nil
+ }
+ // If not fully qualified, error out, but only if msg == nil #ugly
+ switch {
+ case msg == nil:
+ if s[ls-1] != '.' {
+ s += "."
+ ls++
+ }
+ case msg != nil:
+ if s[ls-1] != '.' {
+ return lenmsg, 0, ErrFqdn
+ }
+ }
+ // Each dot ends a segment of the name.
+ // We trade each dot byte for a length byte.
+ // Except for escaped dots (\.), which are normal dots.
+ // There is also a trailing zero.
+
+ // Compression
+ nameoffset := -1
+ pointer := -1
+ // Emit sequence of counted strings, chopping at dots.
+ begin := 0
+ bs := []byte(s)
+ ro_bs, bs_fresh, escaped_dot := s, true, false
+ for i := 0; i < ls; i++ {
+ if bs[i] == '\\' {
+ for j := i; j < ls-1; j++ {
+ bs[j] = bs[j+1]
+ }
+ ls--
+ if off+1 > lenmsg {
+ return lenmsg, labels, ErrBuf
+ }
+ // check for \DDD
+ if i+2 < ls && isDigit(bs[i]) && isDigit(bs[i+1]) && isDigit(bs[i+2]) {
+ bs[i] = dddToByte(bs[i:])
+ for j := i + 1; j < ls-2; j++ {
+ bs[j] = bs[j+2]
+ }
+ ls -= 2
+ } else if bs[i] == 't' {
+ bs[i] = '\t'
+ } else if bs[i] == 'r' {
+ bs[i] = '\r'
+ } else if bs[i] == 'n' {
+ bs[i] = '\n'
+ }
+ escaped_dot = bs[i] == '.'
+ bs_fresh = false
+ continue
+ }
+
+ if bs[i] == '.' {
+ if i > 0 && bs[i-1] == '.' && !escaped_dot {
+ // two dots back to back is not legal
+ return lenmsg, labels, ErrRdata
+ }
+ if i-begin >= 1<<6 { // top two bits of length must be clear
+ return lenmsg, labels, ErrRdata
+ }
+ // off can already (we're in a loop) be bigger than len(msg)
+ // this happens when a name isn't fully qualified
+ if off+1 > lenmsg {
+ return lenmsg, labels, ErrBuf
+ }
+ if msg != nil {
+ msg[off] = byte(i - begin)
+ }
+ offset := off
+ off++
+ for j := begin; j < i; j++ {
+ if off+1 > lenmsg {
+ return lenmsg, labels, ErrBuf
+ }
+ if msg != nil {
+ msg[off] = bs[j]
+ }
+ off++
+ }
+ if compress && !bs_fresh {
+ ro_bs = string(bs)
+ bs_fresh = true
+ }
+ // Dont try to compress '.'
+ if compress && ro_bs[begin:] != "." {
+ if p, ok := compression[ro_bs[begin:]]; !ok {
+ // Only offsets smaller than this can be used.
+ if offset < maxCompressionOffset {
+ compression[ro_bs[begin:]] = offset
+ }
+ } else {
+ // The first hit is the longest matching dname
+ // keep the pointer offset we get back and store
+ // the offset of the current name, because that's
+ // where we need to insert the pointer later
+
+ // If compress is true, we're allowed to compress this dname
+ if pointer == -1 && compress {
+ pointer = p // Where to point to
+ nameoffset = offset // Where to point from
+ break
+ }
+ }
+ }
+ labels++
+ begin = i + 1
+ }
+ escaped_dot = false
+ }
+ // Root label is special
+ if len(bs) == 1 && bs[0] == '.' {
+ return off, labels, nil
+ }
+ // If we did compression and we find something add the pointer here
+ if pointer != -1 {
+ // We have two bytes (14 bits) to put the pointer in
+ // if msg == nil, we will never do compression
+ msg[nameoffset], msg[nameoffset+1] = packUint16(uint16(pointer ^ 0xC000))
+ off = nameoffset + 1
+ goto End
+ }
+ if msg != nil {
+ msg[off] = 0
+ }
+End:
+ off++
+ return off, labels, nil
+}
+
+// Unpack a domain name.
+// In addition to the simple sequences of counted strings above,
+// domain names are allowed to refer to strings elsewhere in the
+// packet, to avoid repeating common suffixes when returning
+// many entries in a single domain. The pointers are marked
+// by a length byte with the top two bits set. Ignoring those
+// two bits, that byte and the next give a 14 bit offset from msg[0]
+// where we should pick up the trail.
+// Note that if we jump elsewhere in the packet,
+// we return off1 == the offset after the first pointer we found,
+// which is where the next record will start.
+// In theory, the pointers are only allowed to jump backward.
+// We let them jump anywhere and stop jumping after a while.
+
+// UnpackDomainName unpacks a domain name into a string.
+func UnpackDomainName(msg []byte, off int) (string, int, error) {
+ s := make([]byte, 0, 64)
+ off1 := 0
+ lenmsg := len(msg)
+ ptr := 0 // number of pointers followed
+Loop:
+ for {
+ if off >= lenmsg {
+ return "", lenmsg, ErrBuf
+ }
+ c := int(msg[off])
+ off++
+ switch c & 0xC0 {
+ case 0x00:
+ if c == 0x00 {
+ // end of name
+ if len(s) == 0 {
+ return ".", off, nil
+ }
+ break Loop
+ }
+ // literal string
+ if off+c > lenmsg {
+ return "", lenmsg, ErrBuf
+ }
+ for j := off; j < off+c; j++ {
+ switch b := msg[j]; b {
+ case '.', '(', ')', ';', ' ', '@':
+ fallthrough
+ case '"', '\\':
+ s = append(s, '\\', b)
+ case '\t':
+ s = append(s, '\\', 't')
+ case '\r':
+ s = append(s, '\\', 'r')
+ default:
+ if b < 32 || b >= 127 { // unprintable use \DDD
+ var buf [3]byte
+ bufs := strconv.AppendInt(buf[:0], int64(b), 10)
+ s = append(s, '\\')
+ for i := 0; i < 3-len(bufs); i++ {
+ s = append(s, '0')
+ }
+ for _, r := range bufs {
+ s = append(s, r)
+ }
+ } else {
+ s = append(s, b)
+ }
+ }
+ }
+ s = append(s, '.')
+ off += c
+ case 0xC0:
+ // pointer to somewhere else in msg.
+ // remember location after first ptr,
+ // since that's how many bytes we consumed.
+ // also, don't follow too many pointers --
+ // maybe there's a loop.
+ if off >= lenmsg {
+ return "", lenmsg, ErrBuf
+ }
+ c1 := msg[off]
+ off++
+ if ptr == 0 {
+ off1 = off
+ }
+ if ptr++; ptr > 10 {
+ return "", lenmsg, &Error{err: "too many compression pointers"}
+ }
+ off = (c^0xC0)<<8 | int(c1)
+ default:
+ // 0x80 and 0x40 are reserved
+ return "", lenmsg, ErrRdata
+ }
+ }
+ if ptr == 0 {
+ off1 = off
+ }
+ return string(s), off1, nil
+}
+
+func packTxt(txt []string, msg []byte, offset int, tmp []byte) (int, error) {
+ var err error
+ if len(txt) == 0 {
+ if offset >= len(msg) {
+ return offset, ErrBuf
+ }
+ msg[offset] = 0
+ return offset, nil
+ }
+ for i := range txt {
+ if len(txt[i]) > len(tmp) {
+ return offset, ErrBuf
+ }
+ offset, err = packTxtString(txt[i], msg, offset, tmp)
+ if err != nil {
+ return offset, err
+ }
+ }
+ return offset, err
+}
+
+func packTxtString(s string, msg []byte, offset int, tmp []byte) (int, error) {
+ lenByteOffset := offset
+ if offset >= len(msg) {
+ return offset, ErrBuf
+ }
+ offset++
+ bs := tmp[:len(s)]
+ copy(bs, s)
+ for i := 0; i < len(bs); i++ {
+ if len(msg) <= offset {
+ return offset, ErrBuf
+ }
+ if bs[i] == '\\' {
+ i++
+ if i == len(bs) {
+ break
+ }
+ // check for \DDD
+ if i+2 < len(bs) && isDigit(bs[i]) && isDigit(bs[i+1]) && isDigit(bs[i+2]) {
+ msg[offset] = dddToByte(bs[i:])
+ i += 2
+ } else if bs[i] == 't' {
+ msg[offset] = '\t'
+ } else if bs[i] == 'r' {
+ msg[offset] = '\r'
+ } else if bs[i] == 'n' {
+ msg[offset] = '\n'
+ } else {
+ msg[offset] = bs[i]
+ }
+ } else {
+ msg[offset] = bs[i]
+ }
+ offset++
+ }
+ l := offset - lenByteOffset - 1
+ if l > 255 {
+ return offset, &Error{err: "string exceeded 255 bytes in txt"}
+ }
+ msg[lenByteOffset] = byte(l)
+ return offset, nil
+}
+
+func unpackTxt(msg []byte, offset, rdend int) ([]string, int, error) {
+ var err error
+ var ss []string
+ var s string
+ for offset < rdend && err == nil {
+ s, offset, err = unpackTxtString(msg, offset)
+ if err == nil {
+ ss = append(ss, s)
+ }
+ }
+ return ss, offset, err
+}
+
+func unpackTxtString(msg []byte, offset int) (string, int, error) {
+ if offset+1 > len(msg) {
+ return "", offset, &Error{err: "overflow unpacking txt"}
+ }
+ l := int(msg[offset])
+ if offset+l+1 > len(msg) {
+ return "", offset, &Error{err: "overflow unpacking txt"}
+ }
+ s := make([]byte, 0, l)
+ for _, b := range msg[offset+1 : offset+1+l] {
+ switch b {
+ case '"', '\\':
+ s = append(s, '\\', b)
+ case '\t':
+ s = append(s, `\t`...)
+ case '\r':
+ s = append(s, `\r`...)
+ case '\n':
+ s = append(s, `\n`...)
+ default:
+ if b < 32 || b > 127 { // unprintable
+ var buf [3]byte
+ bufs := strconv.AppendInt(buf[:0], int64(b), 10)
+ s = append(s, '\\')
+ for i := 0; i < 3-len(bufs); i++ {
+ s = append(s, '0')
+ }
+ for _, r := range bufs {
+ s = append(s, r)
+ }
+ } else {
+ s = append(s, b)
+ }
+ }
+ }
+ offset += 1 + l
+ return string(s), offset, nil
+}
+
+// Pack a reflect.StructValue into msg. Struct members can only be uint8, uint16, uint32, string,
+// slices and other (often anonymous) structs.
+func packStructValue(val reflect.Value, msg []byte, off int, compression map[string]int, compress bool) (off1 int, err error) {
+ var txtTmp []byte
+ lenmsg := len(msg)
+ numfield := val.NumField()
+ for i := 0; i < numfield; i++ {
+ typefield := val.Type().Field(i)
+ if typefield.Tag == `dns:"-"` {
+ continue
+ }
+ switch fv := val.Field(i); fv.Kind() {
+ default:
+ return lenmsg, &Error{err: "bad kind packing"}
+ case reflect.Interface:
+ // PrivateRR is the only RR implementation that has interface field.
+ // therefore it's expected that this interface would be PrivateRdata
+ switch data := fv.Interface().(type) {
+ case PrivateRdata:
+ n, err := data.Pack(msg[off:])
+ if err != nil {
+ return lenmsg, err
+ }
+ off += n
+ default:
+ return lenmsg, &Error{err: "bad kind interface packing"}
+ }
+ case reflect.Slice:
+ switch typefield.Tag {
+ default:
+ return lenmsg, &Error{"bad tag packing slice: " + typefield.Tag.Get("dns")}
+ case `dns:"domain-name"`:
+ for j := 0; j < val.Field(i).Len(); j++ {
+ element := val.Field(i).Index(j).String()
+ off, err = PackDomainName(element, msg, off, compression, false && compress)
+ if err != nil {
+ return lenmsg, err
+ }
+ }
+ case `dns:"txt"`:
+ if txtTmp == nil {
+ txtTmp = make([]byte, 256*4+1)
+ }
+ off, err = packTxt(fv.Interface().([]string), msg, off, txtTmp)
+ if err != nil {
+ return lenmsg, err
+ }
+ case `dns:"opt"`: // edns
+ for j := 0; j < val.Field(i).Len(); j++ {
+ element := val.Field(i).Index(j).Interface()
+ b, e := element.(EDNS0).pack()
+ if e != nil {
+ return lenmsg, &Error{err: "overflow packing opt"}
+ }
+ // Option code
+ msg[off], msg[off+1] = packUint16(element.(EDNS0).Option())
+ // Length
+ msg[off+2], msg[off+3] = packUint16(uint16(len(b)))
+ off += 4
+ if off+len(b) > lenmsg {
+ copy(msg[off:], b)
+ off = lenmsg
+ continue
+ }
+ // Actual data
+ copy(msg[off:off+len(b)], b)
+ off += len(b)
+ }
+ case `dns:"a"`:
+ // It must be a slice of 4, even if it is 16, we encode
+ // only the first 4
+ if off+net.IPv4len > lenmsg {
+ return lenmsg, &Error{err: "overflow packing a"}
+ }
+ switch fv.Len() {
+ case net.IPv6len:
+ msg[off] = byte(fv.Index(12).Uint())
+ msg[off+1] = byte(fv.Index(13).Uint())
+ msg[off+2] = byte(fv.Index(14).Uint())
+ msg[off+3] = byte(fv.Index(15).Uint())
+ off += net.IPv4len
+ case net.IPv4len:
+ msg[off] = byte(fv.Index(0).Uint())
+ msg[off+1] = byte(fv.Index(1).Uint())
+ msg[off+2] = byte(fv.Index(2).Uint())
+ msg[off+3] = byte(fv.Index(3).Uint())
+ off += net.IPv4len
+ case 0:
+ // Allowed, for dynamic updates
+ default:
+ return lenmsg, &Error{err: "overflow packing a"}
+ }
+ case `dns:"aaaa"`:
+ if fv.Len() == 0 {
+ break
+ }
+ if fv.Len() > net.IPv6len || off+fv.Len() > lenmsg {
+ return lenmsg, &Error{err: "overflow packing aaaa"}
+ }
+ for j := 0; j < net.IPv6len; j++ {
+ msg[off] = byte(fv.Index(j).Uint())
+ off++
+ }
+ case `dns:"wks"`:
+ // TODO(miek): this is wrong should be lenrd
+ if off == lenmsg {
+ break // dyn. updates
+ }
+ if val.Field(i).Len() == 0 {
+ break
+ }
+ var bitmapbyte uint16
+ for j := 0; j < val.Field(i).Len(); j++ {
+ serv := uint16((fv.Index(j).Uint()))
+ bitmapbyte = uint16(serv / 8)
+ if int(bitmapbyte) > lenmsg {
+ return lenmsg, &Error{err: "overflow packing wks"}
+ }
+ bit := uint16(serv) - bitmapbyte*8
+ msg[bitmapbyte] = byte(1 << (7 - bit))
+ }
+ off += int(bitmapbyte)
+ case `dns:"nsec"`: // NSEC/NSEC3
+ // This is the uint16 type bitmap
+ if val.Field(i).Len() == 0 {
+ // Do absolutely nothing
+ break
+ }
+
+ lastwindow := uint16(0)
+ length := uint16(0)
+ if off+2 > lenmsg {
+ return lenmsg, &Error{err: "overflow packing nsecx"}
+ }
+ for j := 0; j < val.Field(i).Len(); j++ {
+ t := uint16((fv.Index(j).Uint()))
+ window := uint16(t / 256)
+ if lastwindow != window {
+ // New window, jump to the new offset
+ off += int(length) + 3
+ if off > lenmsg {
+ return lenmsg, &Error{err: "overflow packing nsecx bitmap"}
+ }
+ }
+ length = (t - window*256) / 8
+ bit := t - (window * 256) - (length * 8)
+ if off+2+int(length) > lenmsg {
+ return lenmsg, &Error{err: "overflow packing nsecx bitmap"}
+ }
+
+ // Setting the window #
+ msg[off] = byte(window)
+ // Setting the octets length
+ msg[off+1] = byte(length + 1)
+ // Setting the bit value for the type in the right octet
+ msg[off+2+int(length)] |= byte(1 << (7 - bit))
+ lastwindow = window
+ }
+ off += 2 + int(length)
+ off++
+ if off > lenmsg {
+ return lenmsg, &Error{err: "overflow packing nsecx bitmap"}
+ }
+ }
+ case reflect.Struct:
+ off, err = packStructValue(fv, msg, off, compression, compress)
+ if err != nil {
+ return lenmsg, err
+ }
+ case reflect.Uint8:
+ if off+1 > lenmsg {
+ return lenmsg, &Error{err: "overflow packing uint8"}
+ }
+ msg[off] = byte(fv.Uint())
+ off++
+ case reflect.Uint16:
+ if off+2 > lenmsg {
+ return lenmsg, &Error{err: "overflow packing uint16"}
+ }
+ i := fv.Uint()
+ msg[off] = byte(i >> 8)
+ msg[off+1] = byte(i)
+ off += 2
+ case reflect.Uint32:
+ if off+4 > lenmsg {
+ return lenmsg, &Error{err: "overflow packing uint32"}
+ }
+ i := fv.Uint()
+ msg[off] = byte(i >> 24)
+ msg[off+1] = byte(i >> 16)
+ msg[off+2] = byte(i >> 8)
+ msg[off+3] = byte(i)
+ off += 4
+ case reflect.Uint64:
+ switch typefield.Tag {
+ default:
+ if off+8 > lenmsg {
+ return lenmsg, &Error{err: "overflow packing uint64"}
+ }
+ i := fv.Uint()
+ msg[off] = byte(i >> 56)
+ msg[off+1] = byte(i >> 48)
+ msg[off+2] = byte(i >> 40)
+ msg[off+3] = byte(i >> 32)
+ msg[off+4] = byte(i >> 24)
+ msg[off+5] = byte(i >> 16)
+ msg[off+6] = byte(i >> 8)
+ msg[off+7] = byte(i)
+ off += 8
+ case `dns:"uint48"`:
+ // Used in TSIG, where it stops at 48 bits, so we discard the upper 16
+ if off+6 > lenmsg {
+ return lenmsg, &Error{err: "overflow packing uint64 as uint48"}
+ }
+ i := fv.Uint()
+ msg[off] = byte(i >> 40)
+ msg[off+1] = byte(i >> 32)
+ msg[off+2] = byte(i >> 24)
+ msg[off+3] = byte(i >> 16)
+ msg[off+4] = byte(i >> 8)
+ msg[off+5] = byte(i)
+ off += 6
+ }
+ case reflect.String:
+ // There are multiple string encodings.
+ // The tag distinguishes ordinary strings from domain names.
+ s := fv.String()
+ switch typefield.Tag {
+ default:
+ return lenmsg, &Error{"bad tag packing string: " + typefield.Tag.Get("dns")}
+ case `dns:"base64"`:
+ b64, e := fromBase64([]byte(s))
+ if e != nil {
+ return lenmsg, e
+ }
+ copy(msg[off:off+len(b64)], b64)
+ off += len(b64)
+ case `dns:"domain-name"`:
+ if off, err = PackDomainName(s, msg, off, compression, false && compress); err != nil {
+ return lenmsg, err
+ }
+ case `dns:"cdomain-name"`:
+ if off, err = PackDomainName(s, msg, off, compression, true && compress); err != nil {
+ return lenmsg, err
+ }
+ case `dns:"size-base32"`:
+ // This is purely for NSEC3 atm, the previous byte must
+ // holds the length of the encoded string. As NSEC3
+ // is only defined to SHA1, the hashlength is 20 (160 bits)
+ msg[off-1] = 20
+ fallthrough
+ case `dns:"base32"`:
+ b32, e := fromBase32([]byte(s))
+ if e != nil {
+ return lenmsg, e
+ }
+ copy(msg[off:off+len(b32)], b32)
+ off += len(b32)
+ case `dns:"size-hex"`:
+ fallthrough
+ case `dns:"hex"`:
+ // There is no length encoded here
+ h, e := hex.DecodeString(s)
+ if e != nil {
+ return lenmsg, e
+ }
+ if off+hex.DecodedLen(len(s)) > lenmsg {
+ return lenmsg, &Error{err: "overflow packing hex"}
+ }
+ copy(msg[off:off+hex.DecodedLen(len(s))], h)
+ off += hex.DecodedLen(len(s))
+ case `dns:"size"`:
+ // the size is already encoded in the RR, we can safely use the
+ // length of string. String is RAW (not encoded in hex, nor base64)
+ copy(msg[off:off+len(s)], s)
+ off += len(s)
+ case `dns:"txt"`:
+ fallthrough
+ case "":
+ if txtTmp == nil {
+ txtTmp = make([]byte, 256*4+1)
+ }
+ off, err = packTxtString(fv.String(), msg, off, txtTmp)
+ if err != nil {
+ return lenmsg, err
+ }
+ }
+ }
+ }
+ return off, nil
+}
+
+func structValue(any interface{}) reflect.Value {
+ return reflect.ValueOf(any).Elem()
+}
+
+// PackStruct packs any structure to wire format.
+func PackStruct(any interface{}, msg []byte, off int) (off1 int, err error) {
+ off, err = packStructValue(structValue(any), msg, off, nil, false)
+ return off, err
+}
+
+func packStructCompress(any interface{}, msg []byte, off int, compression map[string]int, compress bool) (off1 int, err error) {
+ off, err = packStructValue(structValue(any), msg, off, compression, compress)
+ return off, err
+}
+
+// TODO(miek): Fix use of rdlength here
+
+// Unpack a reflect.StructValue from msg.
+// Same restrictions as packStructValue.
+func unpackStructValue(val reflect.Value, msg []byte, off int) (off1 int, err error) {
+ var lenrd int
+ lenmsg := len(msg)
+ for i := 0; i < val.NumField(); i++ {
+ if lenrd != 0 && lenrd == off {
+ break
+ }
+ if off > lenmsg {
+ return lenmsg, &Error{"bad offset unpacking"}
+ }
+ switch fv := val.Field(i); fv.Kind() {
+ default:
+ return lenmsg, &Error{err: "bad kind unpacking"}
+ case reflect.Interface:
+ // PrivateRR is the only RR implementation that has interface field.
+ // therefore it's expected that this interface would be PrivateRdata
+ switch data := fv.Interface().(type) {
+ case PrivateRdata:
+ n, err := data.Unpack(msg[off:lenrd])
+ if err != nil {
+ return lenmsg, err
+ }
+ off += n
+ default:
+ return lenmsg, &Error{err: "bad kind interface unpacking"}
+ }
+ case reflect.Slice:
+ switch val.Type().Field(i).Tag {
+ default:
+ return lenmsg, &Error{"bad tag unpacking slice: " + val.Type().Field(i).Tag.Get("dns")}
+ case `dns:"domain-name"`:
+ // HIP record slice of name (or none)
+ servers := make([]string, 0)
+ var s string
+ for off < lenrd {
+ s, off, err = UnpackDomainName(msg, off)
+ if err != nil {
+ return lenmsg, err
+ }
+ servers = append(servers, s)
+ }
+ fv.Set(reflect.ValueOf(servers))
+ case `dns:"txt"`:
+ if off == lenmsg || lenrd == off {
+ break
+ }
+ var txt []string
+ txt, off, err = unpackTxt(msg, off, lenrd)
+ if err != nil {
+ return lenmsg, err
+ }
+ fv.Set(reflect.ValueOf(txt))
+ case `dns:"opt"`: // edns0
+ if off == lenrd {
+ // This is an EDNS0 (OPT Record) with no rdata
+ // We can safely return here.
+ break
+ }
+ edns := make([]EDNS0, 0)
+ Option:
+ code := uint16(0)
+ if off+2 > lenmsg {
+ return lenmsg, &Error{err: "overflow unpacking opt"}
+ }
+ code, off = unpackUint16(msg, off)
+ optlen, off1 := unpackUint16(msg, off)
+ if off1+int(optlen) > lenrd {
+ return lenmsg, &Error{err: "overflow unpacking opt"}
+ }
+ switch code {
+ case EDNS0NSID:
+ e := new(EDNS0_NSID)
+ if err := e.unpack(msg[off1 : off1+int(optlen)]); err != nil {
+ return lenmsg, err
+ }
+ edns = append(edns, e)
+ off = off1 + int(optlen)
+ case EDNS0SUBNET, EDNS0SUBNETDRAFT:
+ e := new(EDNS0_SUBNET)
+ if err := e.unpack(msg[off1 : off1+int(optlen)]); err != nil {
+ return lenmsg, err
+ }
+ edns = append(edns, e)
+ off = off1 + int(optlen)
+ if code == EDNS0SUBNETDRAFT {
+ e.DraftOption = true
+ }
+ case EDNS0UL:
+ e := new(EDNS0_UL)
+ if err := e.unpack(msg[off1 : off1+int(optlen)]); err != nil {
+ return lenmsg, err
+ }
+ edns = append(edns, e)
+ off = off1 + int(optlen)
+ case EDNS0LLQ:
+ e := new(EDNS0_LLQ)
+ if err := e.unpack(msg[off1 : off1+int(optlen)]); err != nil {
+ return lenmsg, err
+ }
+ edns = append(edns, e)
+ off = off1 + int(optlen)
+ case EDNS0DAU:
+ e := new(EDNS0_DAU)
+ if err := e.unpack(msg[off1 : off1+int(optlen)]); err != nil {
+ return lenmsg, err
+ }
+ edns = append(edns, e)
+ off = off1 + int(optlen)
+ case EDNS0DHU:
+ e := new(EDNS0_DHU)
+ if err := e.unpack(msg[off1 : off1+int(optlen)]); err != nil {
+ return lenmsg, err
+ }
+ edns = append(edns, e)
+ off = off1 + int(optlen)
+ case EDNS0N3U:
+ e := new(EDNS0_N3U)
+ if err := e.unpack(msg[off1 : off1+int(optlen)]); err != nil {
+ return lenmsg, err
+ }
+ edns = append(edns, e)
+ off = off1 + int(optlen)
+ default:
+ // do nothing?
+ off = off1 + int(optlen)
+ }
+ if off < lenrd {
+ goto Option
+ }
+ fv.Set(reflect.ValueOf(edns))
+ case `dns:"a"`:
+ if off == lenrd {
+ break // dyn. update
+ }
+ if off+net.IPv4len > lenrd || off+net.IPv4len > lenmsg {
+ return lenmsg, &Error{err: "overflow unpacking a"}
+ }
+ fv.Set(reflect.ValueOf(net.IPv4(msg[off], msg[off+1], msg[off+2], msg[off+3])))
+ off += net.IPv4len
+ case `dns:"aaaa"`:
+ if off == lenrd {
+ break
+ }
+ if off+net.IPv6len > lenrd || off+net.IPv6len > lenmsg {
+ return lenmsg, &Error{err: "overflow unpacking aaaa"}
+ }
+ fv.Set(reflect.ValueOf(net.IP{msg[off], msg[off+1], msg[off+2], msg[off+3], msg[off+4],
+ msg[off+5], msg[off+6], msg[off+7], msg[off+8], msg[off+9], msg[off+10],
+ msg[off+11], msg[off+12], msg[off+13], msg[off+14], msg[off+15]}))
+ off += net.IPv6len
+ case `dns:"wks"`:
+ // Rest of the record is the bitmap
+ serv := make([]uint16, 0)
+ j := 0
+ for off < lenrd {
+ if off+1 > lenmsg {
+ return lenmsg, &Error{err: "overflow unpacking wks"}
+ }
+ b := msg[off]
+ // Check the bits one by one, and set the type
+ if b&0x80 == 0x80 {
+ serv = append(serv, uint16(j*8+0))
+ }
+ if b&0x40 == 0x40 {
+ serv = append(serv, uint16(j*8+1))
+ }
+ if b&0x20 == 0x20 {
+ serv = append(serv, uint16(j*8+2))
+ }
+ if b&0x10 == 0x10 {
+ serv = append(serv, uint16(j*8+3))
+ }
+ if b&0x8 == 0x8 {
+ serv = append(serv, uint16(j*8+4))
+ }
+ if b&0x4 == 0x4 {
+ serv = append(serv, uint16(j*8+5))
+ }
+ if b&0x2 == 0x2 {
+ serv = append(serv, uint16(j*8+6))
+ }
+ if b&0x1 == 0x1 {
+ serv = append(serv, uint16(j*8+7))
+ }
+ j++
+ off++
+ }
+ fv.Set(reflect.ValueOf(serv))
+ case `dns:"nsec"`: // NSEC/NSEC3
+ if off == lenrd {
+ break
+ }
+ // Rest of the record is the type bitmap
+ if off+2 > lenrd || off+2 > lenmsg {
+ return lenmsg, &Error{err: "overflow unpacking nsecx"}
+ }
+ nsec := make([]uint16, 0)
+ length := 0
+ window := 0
+ for off+2 < lenrd {
+ window = int(msg[off])
+ length = int(msg[off+1])
+ //println("off, windows, length, end", off, window, length, endrr)
+ if length == 0 {
+ // A length window of zero is strange. If there
+ // the window should not have been specified. Bail out
+ // println("dns: length == 0 when unpacking NSEC")
+ return lenmsg, &Error{err: "overflow unpacking nsecx"}
+ }
+ if length > 32 {
+ return lenmsg, &Error{err: "overflow unpacking nsecx"}
+ }
+
+ // Walk the bytes in the window - and check the bit settings...
+ off += 2
+ for j := 0; j < length; j++ {
+ if off+j+1 > lenmsg {
+ return lenmsg, &Error{err: "overflow unpacking nsecx"}
+ }
+ b := msg[off+j]
+ // Check the bits one by one, and set the type
+ if b&0x80 == 0x80 {
+ nsec = append(nsec, uint16(window*256+j*8+0))
+ }
+ if b&0x40 == 0x40 {
+ nsec = append(nsec, uint16(window*256+j*8+1))
+ }
+ if b&0x20 == 0x20 {
+ nsec = append(nsec, uint16(window*256+j*8+2))
+ }
+ if b&0x10 == 0x10 {
+ nsec = append(nsec, uint16(window*256+j*8+3))
+ }
+ if b&0x8 == 0x8 {
+ nsec = append(nsec, uint16(window*256+j*8+4))
+ }
+ if b&0x4 == 0x4 {
+ nsec = append(nsec, uint16(window*256+j*8+5))
+ }
+ if b&0x2 == 0x2 {
+ nsec = append(nsec, uint16(window*256+j*8+6))
+ }
+ if b&0x1 == 0x1 {
+ nsec = append(nsec, uint16(window*256+j*8+7))
+ }
+ }
+ off += length
+ }
+ fv.Set(reflect.ValueOf(nsec))
+ }
+ case reflect.Struct:
+ off, err = unpackStructValue(fv, msg, off)
+ if err != nil {
+ return lenmsg, err
+ }
+ if val.Type().Field(i).Name == "Hdr" {
+ lenrd = off + int(val.FieldByName("Hdr").FieldByName("Rdlength").Uint())
+ }
+ case reflect.Uint8:
+ if off == lenmsg {
+ break
+ }
+ if off+1 > lenmsg {
+ return lenmsg, &Error{err: "overflow unpacking uint8"}
+ }
+ fv.SetUint(uint64(uint8(msg[off])))
+ off++
+ case reflect.Uint16:
+ if off == lenmsg {
+ break
+ }
+ var i uint16
+ if off+2 > lenmsg {
+ return lenmsg, &Error{err: "overflow unpacking uint16"}
+ }
+ i, off = unpackUint16(msg, off)
+ fv.SetUint(uint64(i))
+ case reflect.Uint32:
+ if off == lenmsg {
+ break
+ }
+ if off+4 > lenmsg {
+ return lenmsg, &Error{err: "overflow unpacking uint32"}
+ }
+ fv.SetUint(uint64(uint32(msg[off])<<24 | uint32(msg[off+1])<<16 | uint32(msg[off+2])<<8 | uint32(msg[off+3])))
+ off += 4
+ case reflect.Uint64:
+ switch val.Type().Field(i).Tag {
+ default:
+ if off+8 > lenmsg {
+ return lenmsg, &Error{err: "overflow unpacking uint64"}
+ }
+ fv.SetUint(uint64(uint64(msg[off])<<56 | uint64(msg[off+1])<<48 | uint64(msg[off+2])<<40 |
+ uint64(msg[off+3])<<32 | uint64(msg[off+4])<<24 | uint64(msg[off+5])<<16 | uint64(msg[off+6])<<8 | uint64(msg[off+7])))
+ off += 8
+ case `dns:"uint48"`:
+ // Used in TSIG where the last 48 bits are occupied, so for now, assume a uint48 (6 bytes)
+ if off+6 > lenmsg {
+ return lenmsg, &Error{err: "overflow unpacking uint64 as uint48"}
+ }
+ fv.SetUint(uint64(uint64(msg[off])<<40 | uint64(msg[off+1])<<32 | uint64(msg[off+2])<<24 | uint64(msg[off+3])<<16 |
+ uint64(msg[off+4])<<8 | uint64(msg[off+5])))
+ off += 6
+ }
+ case reflect.String:
+ var s string
+ if off == lenmsg {
+ break
+ }
+ switch val.Type().Field(i).Tag {
+ default:
+ return lenmsg, &Error{"bad tag unpacking string: " + val.Type().Field(i).Tag.Get("dns")}
+ case `dns:"hex"`:
+ hexend := lenrd
+ if val.FieldByName("Hdr").FieldByName("Rrtype").Uint() == uint64(TypeHIP) {
+ hexend = off + int(val.FieldByName("HitLength").Uint())
+ }
+ if hexend > lenrd || hexend > lenmsg {
+ return lenmsg, &Error{err: "overflow unpacking hex"}
+ }
+ s = hex.EncodeToString(msg[off:hexend])
+ off = hexend
+ case `dns:"base64"`:
+ // Rest of the RR is base64 encoded value
+ b64end := lenrd
+ if val.FieldByName("Hdr").FieldByName("Rrtype").Uint() == uint64(TypeHIP) {
+ b64end = off + int(val.FieldByName("PublicKeyLength").Uint())
+ }
+ if b64end > lenrd || b64end > lenmsg {
+ return lenmsg, &Error{err: "overflow unpacking base64"}
+ }
+ s = toBase64(msg[off:b64end])
+ off = b64end
+ case `dns:"cdomain-name"`:
+ fallthrough
+ case `dns:"domain-name"`:
+ if off == lenmsg {
+ // zero rdata foo, OK for dyn. updates
+ break
+ }
+ s, off, err = UnpackDomainName(msg, off)
+ if err != nil {
+ return lenmsg, err
+ }
+ case `dns:"size-base32"`:
+ var size int
+ switch val.Type().Name() {
+ case "NSEC3":
+ switch val.Type().Field(i).Name {
+ case "NextDomain":
+ name := val.FieldByName("HashLength")
+ size = int(name.Uint())
+ }
+ }
+ if off+size > lenmsg {
+ return lenmsg, &Error{err: "overflow unpacking base32"}
+ }
+ s = toBase32(msg[off : off+size])
+ off += size
+ case `dns:"size-hex"`:
+ // a "size" string, but it must be encoded in hex in the string
+ var size int
+ switch val.Type().Name() {
+ case "NSEC3":
+ switch val.Type().Field(i).Name {
+ case "Salt":
+ name := val.FieldByName("SaltLength")
+ size = int(name.Uint())
+ case "NextDomain":
+ name := val.FieldByName("HashLength")
+ size = int(name.Uint())
+ }
+ case "TSIG":
+ switch val.Type().Field(i).Name {
+ case "MAC":
+ name := val.FieldByName("MACSize")
+ size = int(name.Uint())
+ case "OtherData":
+ name := val.FieldByName("OtherLen")
+ size = int(name.Uint())
+ }
+ }
+ if off+size > lenmsg {
+ return lenmsg, &Error{err: "overflow unpacking hex"}
+ }
+ s = hex.EncodeToString(msg[off : off+size])
+ off += size
+ case `dns:"txt"`:
+ fallthrough
+ case "":
+ s, off, err = unpackTxtString(msg, off)
+ }
+ fv.SetString(s)
+ }
+ }
+ return off, nil
+}
+
+// Helpers for dealing with escaped bytes
+func isDigit(b byte) bool { return b >= '0' && b <= '9' }
+
+func dddToByte(s []byte) byte {
+ return byte((s[0]-'0')*100 + (s[1]-'0')*10 + (s[2] - '0'))
+}
+
+// UnpackStruct unpacks a binary message from offset off to the interface
+// value given.
+func UnpackStruct(any interface{}, msg []byte, off int) (int, error) {
+ return unpackStructValue(structValue(any), msg, off)
+}
+
+// Helper function for packing and unpacking
+func intToBytes(i *big.Int, length int) []byte {
+ buf := i.Bytes()
+ if len(buf) < length {
+ b := make([]byte, length)
+ copy(b[length-len(buf):], buf)
+ return b
+ }
+ return buf
+}
+
+func unpackUint16(msg []byte, off int) (uint16, int) {
+ return uint16(msg[off])<<8 | uint16(msg[off+1]), off + 2
+}
+
+func packUint16(i uint16) (byte, byte) {
+ return byte(i >> 8), byte(i)
+}
+
+func toBase32(b []byte) string {
+ return base32.HexEncoding.EncodeToString(b)
+}
+
+func fromBase32(s []byte) (buf []byte, err error) {
+ buflen := base32.HexEncoding.DecodedLen(len(s))
+ buf = make([]byte, buflen)
+ n, err := base32.HexEncoding.Decode(buf, s)
+ buf = buf[:n]
+ return
+}
+
+func toBase64(b []byte) string {
+ return base64.StdEncoding.EncodeToString(b)
+}
+
+func fromBase64(s []byte) (buf []byte, err error) {
+ buflen := base64.StdEncoding.DecodedLen(len(s))
+ buf = make([]byte, buflen)
+ n, err := base64.StdEncoding.Decode(buf, s)
+ buf = buf[:n]
+ return
+}
+
+// PackRR packs a resource record rr into msg[off:].
+// See PackDomainName for documentation about the compression.
+func PackRR(rr RR, msg []byte, off int, compression map[string]int, compress bool) (off1 int, err error) {
+ if rr == nil {
+ return len(msg), &Error{err: "nil rr"}
+ }
+
+ off1, err = packStructCompress(rr, msg, off, compression, compress)
+ if err != nil {
+ return len(msg), err
+ }
+ if rawSetRdlength(msg, off, off1) {
+ return off1, nil
+ }
+ return off, ErrRdata
+}
+
+// UnpackRR unpacks msg[off:] into an RR.
+func UnpackRR(msg []byte, off int) (rr RR, off1 int, err error) {
+ // unpack just the header, to find the rr type and length
+ var h RR_Header
+ off0 := off
+ if off, err = UnpackStruct(&h, msg, off); err != nil {
+ return nil, len(msg), err
+ }
+ end := off + int(h.Rdlength)
+ // make an rr of that type and re-unpack.
+ mk, known := typeToRR[h.Rrtype]
+ if !known {
+ rr = new(RFC3597)
+ } else {
+ rr = mk()
+ }
+ off, err = UnpackStruct(rr, msg, off0)
+ if off != end {
+ return &h, end, &Error{err: "bad rdlength"}
+ }
+ return rr, off, err
+}
+
+// Reverse a map
+func reverseInt8(m map[uint8]string) map[string]uint8 {
+ n := make(map[string]uint8)
+ for u, s := range m {
+ n[s] = u
+ }
+ return n
+}
+
+func reverseInt16(m map[uint16]string) map[string]uint16 {
+ n := make(map[string]uint16)
+ for u, s := range m {
+ n[s] = u
+ }
+ return n
+}
+
+func reverseInt(m map[int]string) map[string]int {
+ n := make(map[string]int)
+ for u, s := range m {
+ n[s] = u
+ }
+ return n
+}
+
+// Convert a MsgHdr to a string, with dig-like headers:
+//
+//;; opcode: QUERY, status: NOERROR, id: 48404
+//
+//;; flags: qr aa rd ra;
+func (h *MsgHdr) String() string {
+ if h == nil {
+ return "<nil> MsgHdr"
+ }
+
+ s := ";; opcode: " + OpcodeToString[h.Opcode]
+ s += ", status: " + RcodeToString[h.Rcode]
+ s += ", id: " + strconv.Itoa(int(h.Id)) + "\n"
+
+ s += ";; flags:"
+ if h.Response {
+ s += " qr"
+ }
+ if h.Authoritative {
+ s += " aa"
+ }
+ if h.Truncated {
+ s += " tc"
+ }
+ if h.RecursionDesired {
+ s += " rd"
+ }
+ if h.RecursionAvailable {
+ s += " ra"
+ }
+ if h.Zero { // Hmm
+ s += " z"
+ }
+ if h.AuthenticatedData {
+ s += " ad"
+ }
+ if h.CheckingDisabled {
+ s += " cd"
+ }
+
+ s += ";"
+ return s
+}
+
+// Pack packs a Msg: it is converted to to wire format.
+// If the dns.Compress is true the message will be in compressed wire format.
+func (dns *Msg) Pack() (msg []byte, err error) {
+ return dns.PackBuffer(nil)
+}
+
+// PackBuffer packs a Msg, using the given buffer buf. If buf is too small
+// a new buffer is allocated.
+func (dns *Msg) PackBuffer(buf []byte) (msg []byte, err error) {
+ var dh Header
+ var compression map[string]int
+ if dns.Compress {
+ compression = make(map[string]int) // Compression pointer mappings
+ }
+
+ if dns.Rcode < 0 || dns.Rcode > 0xFFF {
+ return nil, ErrRcode
+ }
+ if dns.Rcode > 0xF {
+ // Regular RCODE field is 4 bits
+ opt := dns.IsEdns0()
+ if opt == nil {
+ return nil, ErrExtendedRcode
+ }
+ opt.SetExtendedRcode(uint8(dns.Rcode >> 4))
+ dns.Rcode &= 0xF
+ }
+
+ // Convert convenient Msg into wire-like Header.
+ dh.Id = dns.Id
+ dh.Bits = uint16(dns.Opcode)<<11 | uint16(dns.Rcode)
+ if dns.Response {
+ dh.Bits |= _QR
+ }
+ if dns.Authoritative {
+ dh.Bits |= _AA
+ }
+ if dns.Truncated {
+ dh.Bits |= _TC
+ }
+ if dns.RecursionDesired {
+ dh.Bits |= _RD
+ }
+ if dns.RecursionAvailable {
+ dh.Bits |= _RA
+ }
+ if dns.Zero {
+ dh.Bits |= _Z
+ }
+ if dns.AuthenticatedData {
+ dh.Bits |= _AD
+ }
+ if dns.CheckingDisabled {
+ dh.Bits |= _CD
+ }
+
+ // Prepare variable sized arrays.
+ question := dns.Question
+ answer := dns.Answer
+ ns := dns.Ns
+ extra := dns.Extra
+
+ dh.Qdcount = uint16(len(question))
+ dh.Ancount = uint16(len(answer))
+ dh.Nscount = uint16(len(ns))
+ dh.Arcount = uint16(len(extra))
+
+ // We need the uncompressed length here, because we first pack it and then compress it.
+ msg = buf
+ compress := dns.Compress
+ dns.Compress = false
+ if packLen := dns.Len() + 1; len(msg) < packLen {
+ msg = make([]byte, packLen)
+ }
+ dns.Compress = compress
+
+ // Pack it in: header and then the pieces.
+ off := 0
+ off, err = packStructCompress(&dh, msg, off, compression, dns.Compress)
+ if err != nil {
+ return nil, err
+ }
+ for i := 0; i < len(question); i++ {
+ off, err = packStructCompress(&question[i], msg, off, compression, dns.Compress)
+ if err != nil {
+ return nil, err
+ }
+ }
+ for i := 0; i < len(answer); i++ {
+ off, err = PackRR(answer[i], msg, off, compression, dns.Compress)
+ if err != nil {
+ return nil, err
+ }
+ }
+ for i := 0; i < len(ns); i++ {
+ off, err = PackRR(ns[i], msg, off, compression, dns.Compress)
+ if err != nil {
+ return nil, err
+ }
+ }
+ for i := 0; i < len(extra); i++ {
+ off, err = PackRR(extra[i], msg, off, compression, dns.Compress)
+ if err != nil {
+ return nil, err
+ }
+ }
+ return msg[:off], nil
+}
+
+// Unpack unpacks a binary message to a Msg structure.
+func (dns *Msg) Unpack(msg []byte) (err error) {
+ // Header.
+ var dh Header
+ off := 0
+ if off, err = UnpackStruct(&dh, msg, off); err != nil {
+ return err
+ }
+ dns.Id = dh.Id
+ dns.Response = (dh.Bits & _QR) != 0
+ dns.Opcode = int(dh.Bits>>11) & 0xF
+ dns.Authoritative = (dh.Bits & _AA) != 0
+ dns.Truncated = (dh.Bits & _TC) != 0
+ dns.RecursionDesired = (dh.Bits & _RD) != 0
+ dns.RecursionAvailable = (dh.Bits & _RA) != 0
+ dns.Zero = (dh.Bits & _Z) != 0
+ dns.AuthenticatedData = (dh.Bits & _AD) != 0
+ dns.CheckingDisabled = (dh.Bits & _CD) != 0
+ dns.Rcode = int(dh.Bits & 0xF)
+
+ // Arrays.
+ dns.Question = make([]Question, dh.Qdcount)
+ dns.Answer = make([]RR, dh.Ancount)
+ dns.Ns = make([]RR, dh.Nscount)
+ dns.Extra = make([]RR, dh.Arcount)
+
+ for i := 0; i < len(dns.Question); i++ {
+ off, err = UnpackStruct(&dns.Question[i], msg, off)
+ if err != nil {
+ return err
+ }
+ }
+ // If we see a TC bit being set we return here, without
+ // an error, because technically it isn't an error. So return
+ // without parsing the potentially corrupt packet and hitting an error.
+ // TODO(miek): this isn't the best strategy!
+ if dns.Truncated {
+ dns.Answer = nil
+ dns.Ns = nil
+ dns.Extra = nil
+ return nil
+ }
+ for i := 0; i < len(dns.Answer); i++ {
+ dns.Answer[i], off, err = UnpackRR(msg, off)
+ if err != nil {
+ return err
+ }
+ }
+ for i := 0; i < len(dns.Ns); i++ {
+ dns.Ns[i], off, err = UnpackRR(msg, off)
+ if err != nil {
+ return err
+ }
+ }
+ for i := 0; i < len(dns.Extra); i++ {
+ dns.Extra[i], off, err = UnpackRR(msg, off)
+ if err != nil {
+ return err
+ }
+ }
+ if off != len(msg) {
+ // TODO(miek) make this an error?
+ // use PackOpt to let people tell how detailed the error reporting should be?
+ // println("dns: extra bytes in dns packet", off, "<", len(msg))
+ }
+ return nil
+}
+
+// Convert a complete message to a string with dig-like output.
+func (dns *Msg) String() string {
+ if dns == nil {
+ return "<nil> MsgHdr"
+ }
+ s := dns.MsgHdr.String() + " "
+ s += "QUERY: " + strconv.Itoa(len(dns.Question)) + ", "
+ s += "ANSWER: " + strconv.Itoa(len(dns.Answer)) + ", "
+ s += "AUTHORITY: " + strconv.Itoa(len(dns.Ns)) + ", "
+ s += "ADDITIONAL: " + strconv.Itoa(len(dns.Extra)) + "\n"
+ if len(dns.Question) > 0 {
+ s += "\n;; QUESTION SECTION:\n"
+ for i := 0; i < len(dns.Question); i++ {
+ s += dns.Question[i].String() + "\n"
+ }
+ }
+ if len(dns.Answer) > 0 {
+ s += "\n;; ANSWER SECTION:\n"
+ for i := 0; i < len(dns.Answer); i++ {
+ if dns.Answer[i] != nil {
+ s += dns.Answer[i].String() + "\n"
+ }
+ }
+ }
+ if len(dns.Ns) > 0 {
+ s += "\n;; AUTHORITY SECTION:\n"
+ for i := 0; i < len(dns.Ns); i++ {
+ if dns.Ns[i] != nil {
+ s += dns.Ns[i].String() + "\n"
+ }
+ }
+ }
+ if len(dns.Extra) > 0 {
+ s += "\n;; ADDITIONAL SECTION:\n"
+ for i := 0; i < len(dns.Extra); i++ {
+ if dns.Extra[i] != nil {
+ s += dns.Extra[i].String() + "\n"
+ }
+ }
+ }
+ return s
+}
+
+// Len returns the message length when in (un)compressed wire format.
+// If dns.Compress is true compression it is taken into account. Len()
+// is provided to be a faster way to get the size of the resulting packet,
+// than packing it, measuring the size and discarding the buffer.
+func (dns *Msg) Len() int {
+ // We always return one more than needed.
+ l := 12 // Message header is always 12 bytes
+ var compression map[string]int
+ if dns.Compress {
+ compression = make(map[string]int)
+ }
+ for i := 0; i < len(dns.Question); i++ {
+ l += dns.Question[i].len()
+ if dns.Compress {
+ compressionLenHelper(compression, dns.Question[i].Name)
+ }
+ }
+ for i := 0; i < len(dns.Answer); i++ {
+ l += dns.Answer[i].len()
+ if dns.Compress {
+ k, ok := compressionLenSearch(compression, dns.Answer[i].Header().Name)
+ if ok {
+ l += 1 - k
+ }
+ compressionLenHelper(compression, dns.Answer[i].Header().Name)
+ k, ok = compressionLenSearchType(compression, dns.Answer[i])
+ if ok {
+ l += 1 - k
+ }
+ compressionLenHelperType(compression, dns.Answer[i])
+ }
+ }
+ for i := 0; i < len(dns.Ns); i++ {
+ l += dns.Ns[i].len()
+ if dns.Compress {
+ k, ok := compressionLenSearch(compression, dns.Ns[i].Header().Name)
+ if ok {
+ l += 1 - k
+ }
+ compressionLenHelper(compression, dns.Ns[i].Header().Name)
+ k, ok = compressionLenSearchType(compression, dns.Ns[i])
+ if ok {
+ l += 1 - k
+ }
+ compressionLenHelperType(compression, dns.Ns[i])
+ }
+ }
+ for i := 0; i < len(dns.Extra); i++ {
+ l += dns.Extra[i].len()
+ if dns.Compress {
+ k, ok := compressionLenSearch(compression, dns.Extra[i].Header().Name)
+ if ok {
+ l += 1 - k
+ }
+ compressionLenHelper(compression, dns.Extra[i].Header().Name)
+ k, ok = compressionLenSearchType(compression, dns.Extra[i])
+ if ok {
+ l += 1 - k
+ }
+ compressionLenHelperType(compression, dns.Extra[i])
+ }
+ }
+ return l
+}
+
+// Put the parts of the name in the compression map.
+func compressionLenHelper(c map[string]int, s string) {
+ pref := ""
+ lbs := Split(s)
+ for j := len(lbs) - 1; j >= 0; j-- {
+ pref = s[lbs[j]:]
+ if _, ok := c[pref]; !ok {
+ c[pref] = len(pref)
+ }
+ }
+}
+
+// Look for each part in the compression map and returns its length,
+// keep on searching so we get the longest match.
+func compressionLenSearch(c map[string]int, s string) (int, bool) {
+ off := 0
+ end := false
+ if s == "" { // don't bork on bogus data
+ return 0, false
+ }
+ for {
+ if _, ok := c[s[off:]]; ok {
+ return len(s[off:]), true
+ }
+ if end {
+ break
+ }
+ off, end = NextLabel(s, off)
+ }
+ return 0, false
+}
+
+// TODO(miek): should add all types, because the all can be *used* for compression.
+func compressionLenHelperType(c map[string]int, r RR) {
+ switch x := r.(type) {
+ case *NS:
+ compressionLenHelper(c, x.Ns)
+ case *MX:
+ compressionLenHelper(c, x.Mx)
+ case *CNAME:
+ compressionLenHelper(c, x.Target)
+ case *PTR:
+ compressionLenHelper(c, x.Ptr)
+ case *SOA:
+ compressionLenHelper(c, x.Ns)
+ compressionLenHelper(c, x.Mbox)
+ case *MB:
+ compressionLenHelper(c, x.Mb)
+ case *MG:
+ compressionLenHelper(c, x.Mg)
+ case *MR:
+ compressionLenHelper(c, x.Mr)
+ case *MF:
+ compressionLenHelper(c, x.Mf)
+ case *MD:
+ compressionLenHelper(c, x.Md)
+ case *RT:
+ compressionLenHelper(c, x.Host)
+ case *MINFO:
+ compressionLenHelper(c, x.Rmail)
+ compressionLenHelper(c, x.Email)
+ case *AFSDB:
+ compressionLenHelper(c, x.Hostname)
+ }
+}
+
+// Only search on compressing these types.
+func compressionLenSearchType(c map[string]int, r RR) (int, bool) {
+ switch x := r.(type) {
+ case *NS:
+ return compressionLenSearch(c, x.Ns)
+ case *MX:
+ return compressionLenSearch(c, x.Mx)
+ case *CNAME:
+ return compressionLenSearch(c, x.Target)
+ case *PTR:
+ return compressionLenSearch(c, x.Ptr)
+ case *SOA:
+ k, ok := compressionLenSearch(c, x.Ns)
+ k1, ok1 := compressionLenSearch(c, x.Mbox)
+ if !ok && !ok1 {
+ return 0, false
+ }
+ return k + k1, true
+ case *MB:
+ return compressionLenSearch(c, x.Mb)
+ case *MG:
+ return compressionLenSearch(c, x.Mg)
+ case *MR:
+ return compressionLenSearch(c, x.Mr)
+ case *MF:
+ return compressionLenSearch(c, x.Mf)
+ case *MD:
+ return compressionLenSearch(c, x.Md)
+ case *RT:
+ return compressionLenSearch(c, x.Host)
+ case *MINFO:
+ k, ok := compressionLenSearch(c, x.Rmail)
+ k1, ok1 := compressionLenSearch(c, x.Email)
+ if !ok && !ok1 {
+ return 0, false
+ }
+ return k + k1, true
+ case *AFSDB:
+ return compressionLenSearch(c, x.Hostname)
+ }
+ return 0, false
+}
+
+// id returns a 16 bits random number to be used as a
+// message id. The random provided should be good enough.
+func id() uint16 {
+ return uint16(rand.Int()) ^ uint16(time.Now().Nanosecond())
+}
+
+// Copy returns a new RR which is a deep-copy of r.
+func Copy(r RR) RR {
+ r1 := r.copy()
+ return r1
+}
+
+// Copy returns a new *Msg which is a deep-copy of dns.
+func (dns *Msg) Copy() *Msg {
+ r1 := new(Msg)
+ r1.MsgHdr = dns.MsgHdr
+ r1.Compress = dns.Compress
+
+ if len(dns.Question) > 0 {
+ r1.Question = make([]Question, len(dns.Question))
+ copy(r1.Question, dns.Question) // TODO(miek): Question is an immutable value, ok to do a shallow-copy
+ }
+
+ if len(dns.Answer) > 0 {
+ r1.Answer = make([]RR, len(dns.Answer))
+ for i := 0; i < len(dns.Answer); i++ {
+ r1.Answer[i] = dns.Answer[i].copy()
+ }
+ }
+
+ if len(dns.Ns) > 0 {
+ r1.Ns = make([]RR, len(dns.Ns))
+ for i := 0; i < len(dns.Ns); i++ {
+ r1.Ns[i] = dns.Ns[i].copy()
+ }
+ }
+
+ if len(dns.Extra) > 0 {
+ r1.Extra = make([]RR, len(dns.Extra))
+ for i := 0; i < len(dns.Extra); i++ {
+ r1.Extra[i] = dns.Extra[i].copy()
+ }
+ }
+
+ return r1
+}
diff --git a/Godeps/_workspace/src/github.com/miekg/dns/nsecx.go b/Godeps/_workspace/src/github.com/miekg/dns/nsecx.go
new file mode 100644
index 0000000000000000000000000000000000000000..ac48da0f5ac960d7cb2b275af8d29d3aeba3fdb9
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/miekg/dns/nsecx.go
@@ -0,0 +1,110 @@
+package dns
+
+import (
+ "crypto/sha1"
+ "hash"
+ "io"
+ "strings"
+)
+
+type saltWireFmt struct {
+ Salt string `dns:"size-hex"`
+}
+
+// HashName hashes a string (label) according to RFC 5155. It returns the hashed string in
+// uppercase.
+func HashName(label string, ha uint8, iter uint16, salt string) string {
+ saltwire := new(saltWireFmt)
+ saltwire.Salt = salt
+ wire := make([]byte, DefaultMsgSize)
+ n, err := PackStruct(saltwire, wire, 0)
+ if err != nil {
+ return ""
+ }
+ wire = wire[:n]
+ name := make([]byte, 255)
+ off, err := PackDomainName(strings.ToLower(label), name, 0, nil, false)
+ if err != nil {
+ return ""
+ }
+ name = name[:off]
+ var s hash.Hash
+ switch ha {
+ case SHA1:
+ s = sha1.New()
+ default:
+ return ""
+ }
+
+ // k = 0
+ name = append(name, wire...)
+ io.WriteString(s, string(name))
+ nsec3 := s.Sum(nil)
+ // k > 0
+ for k := uint16(0); k < iter; k++ {
+ s.Reset()
+ nsec3 = append(nsec3, wire...)
+ io.WriteString(s, string(nsec3))
+ nsec3 = s.Sum(nil)
+ }
+ return toBase32(nsec3)
+}
+
+type Denialer interface {
+ // Cover will check if the (unhashed) name is being covered by this NSEC or NSEC3.
+ Cover(name string) bool
+ // Match will check if the ownername matches the (unhashed) name for this NSEC3 or NSEC3.
+ Match(name string) bool
+}
+
+// Cover implements the Denialer interface.
+func (rr *NSEC) Cover(name string) bool {
+ return true
+}
+
+// Match implements the Denialer interface.
+func (rr *NSEC) Match(name string) bool {
+ return true
+}
+
+// Cover implements the Denialer interface.
+func (rr *NSEC3) Cover(name string) bool {
+ // FIXME(miek): check if the zones match
+ // FIXME(miek): check if we're not dealing with parent nsec3
+ hname := HashName(name, rr.Hash, rr.Iterations, rr.Salt)
+ labels := Split(rr.Hdr.Name)
+ if len(labels) < 2 {
+ return false
+ }
+ hash := strings.ToUpper(rr.Hdr.Name[labels[0] : labels[1]-1]) // -1 to remove the dot
+ if hash == rr.NextDomain {
+ return false // empty interval
+ }
+ if hash > rr.NextDomain { // last name, points to apex
+ // hname > hash
+ // hname > rr.NextDomain
+ // TODO(miek)
+ }
+ if hname <= hash {
+ return false
+ }
+ if hname >= rr.NextDomain {
+ return false
+ }
+ return true
+}
+
+// Match implements the Denialer interface.
+func (rr *NSEC3) Match(name string) bool {
+ // FIXME(miek): Check if we are in the same zone
+ hname := HashName(name, rr.Hash, rr.Iterations, rr.Salt)
+ labels := Split(rr.Hdr.Name)
+ if len(labels) < 2 {
+ return false
+ }
+ hash := strings.ToUpper(rr.Hdr.Name[labels[0] : labels[1]-1]) // -1 to remove the .
+ if hash == hname {
+ return true
+ }
+ return false
+}
diff --git a/Godeps/_workspace/src/github.com/miekg/dns/nsecx_test.go b/Godeps/_workspace/src/github.com/miekg/dns/nsecx_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..72f641a66731cbbfdb257b053c6f50a5fc66d2d4
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/miekg/dns/nsecx_test.go
@@ -0,0 +1,33 @@
+package dns
+
+import (
+ "testing"
+)
+
+func TestPackNsec3(t *testing.T) {
+ nsec3 := HashName("dnsex.nl.", SHA1, 0, "DEAD")
+ if nsec3 != "ROCCJAE8BJJU7HN6T7NG3TNM8ACRS87J" {
+ t.Logf("%v\n", nsec3)
+ t.Fail()
+ }
+
+ nsec3 = HashName("a.b.c.example.org.", SHA1, 2, "DEAD")
+ if nsec3 != "6LQ07OAHBTOOEU2R9ANI2AT70K5O0RCG" {
+ t.Logf("%v\n", nsec3)
+ t.Fail()
+ }
+}
+
+func TestNsec3(t *testing.T) {
+ // examples taken from .nl
+ nsec3, _ := NewRR("39p91242oslggest5e6a7cci4iaeqvnk.nl. IN NSEC3 1 1 5 F10E9F7EA83FC8F3 39P99DCGG0MDLARTCRMCF6OFLLUL7PR6 NS DS RRSIG")
+ if !nsec3.(*NSEC3).Cover("snasajsksasasa.nl.") { // 39p94jrinub66hnpem8qdpstrec86pg3
+ t.Logf("39p94jrinub66hnpem8qdpstrec86pg3. should be covered by 39p91242oslggest5e6a7cci4iaeqvnk.nl. - 39P99DCGG0MDLARTCRMCF6OFLLUL7PR6")
+ t.Fail()
+ }
+ nsec3, _ = NewRR("sk4e8fj94u78smusb40o1n0oltbblu2r.nl. IN NSEC3 1 1 5 F10E9F7EA83FC8F3 SK4F38CQ0ATIEI8MH3RGD0P5I4II6QAN NS SOA TXT RRSIG DNSKEY NSEC3PARAM")
+ if !nsec3.(*NSEC3).Match("nl.") { // sk4e8fj94u78smusb40o1n0oltbblu2r.nl.
+ t.Logf("sk4e8fj94u78smusb40o1n0oltbblu2r.nl. should match sk4e8fj94u78smusb40o1n0oltbblu2r.nl.")
+ t.Fail()
+ }
+}
diff --git a/Godeps/_workspace/src/github.com/miekg/dns/parse_test.go b/Godeps/_workspace/src/github.com/miekg/dns/parse_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..dd2799d1f14ac068efb566a9423f65dff1d5ee9e
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/miekg/dns/parse_test.go
@@ -0,0 +1,1276 @@
+package dns
+
+import (
+ "bytes"
+ "crypto/rsa"
+ "encoding/hex"
+ "fmt"
+ "math/rand"
+ "net"
+ "reflect"
+ "strconv"
+ "strings"
+ "testing"
+ "testing/quick"
+ "time"
+)
+
+func TestDotInName(t *testing.T) {
+ buf := make([]byte, 20)
+ PackDomainName("aa\\.bb.nl.", buf, 0, nil, false)
+ // index 3 must be a real dot
+ if buf[3] != '.' {
+ t.Log("dot should be a real dot")
+ t.Fail()
+ }
+
+ if buf[6] != 2 {
+ t.Log("this must have the value 2")
+ t.Fail()
+ }
+ dom, _, _ := UnpackDomainName(buf, 0)
+ // printing it should yield the backspace again
+ if dom != "aa\\.bb.nl." {
+ t.Log("dot should have been escaped: " + dom)
+ t.Fail()
+ }
+}
+
+func TestDotLastInLabel(t *testing.T) {
+ sample := "aa\\..au."
+ buf := make([]byte, 20)
+ _, err := PackDomainName(sample, buf, 0, nil, false)
+ if err != nil {
+ t.Fatalf("unexpected error packing domain: %s", err)
+ }
+ dom, _, _ := UnpackDomainName(buf, 0)
+ if dom != sample {
+ t.Fatalf("unpacked domain `%s' doesn't match packed domain", dom)
+ }
+}
+
+func TestTooLongDomainName(t *testing.T) {
+ l := "aaabbbcccdddeeefffggghhhiiijjjkkklllmmmnnnooopppqqqrrrsssttt."
+ dom := l + l + l + l + l + l + l
+ _, e := NewRR(dom + " IN A 127.0.0.1")
+ if e == nil {
+ t.Log("should be too long")
+ t.Fail()
+ } else {
+ t.Logf("error is %s", e.Error())
+ }
+ _, e = NewRR("..com. IN A 127.0.0.1")
+ if e == nil {
+ t.Log("should fail")
+ t.Fail()
+ } else {
+ t.Logf("error is %s", e.Error())
+ }
+}
+
+func TestDomainName(t *testing.T) {
+ tests := []string{"r\\.gieben.miek.nl.", "www\\.www.miek.nl.",
+ "www.*.miek.nl.", "www.*.miek.nl.",
+ }
+ dbuff := make([]byte, 40)
+
+ for _, ts := range tests {
+ if _, err := PackDomainName(ts, dbuff, 0, nil, false); err != nil {
+ t.Log("not a valid domain name")
+ t.Fail()
+ continue
+ }
+ n, _, err := UnpackDomainName(dbuff, 0)
+ if err != nil {
+ t.Log("failed to unpack packed domain name")
+ t.Fail()
+ continue
+ }
+ if ts != n {
+ t.Logf("must be equal: in: %s, out: %s\n", ts, n)
+ t.Fail()
+ }
+ }
+}
+
+func TestDomainNameAndTXTEscapes(t *testing.T) {
+ tests := []byte{'.', '(', ')', ';', ' ', '@', '"', '\\', '\t', '\r', '\n', 0, 255}
+ for _, b := range tests {
+ rrbytes := []byte{
+ 1, b, 0, // owner
+ byte(TypeTXT >> 8), byte(TypeTXT),
+ byte(ClassINET >> 8), byte(ClassINET),
+ 0, 0, 0, 1, // TTL
+ 0, 2, 1, b, // Data
+ }
+ rr1, _, err := UnpackRR(rrbytes, 0)
+ if err != nil {
+ panic(err)
+ }
+ s := rr1.String()
+ rr2, err := NewRR(s)
+ if err != nil {
+ t.Logf("Error parsing unpacked RR's string: %v", err)
+ t.Logf(" Bytes: %v\n", rrbytes)
+ t.Logf("String: %v\n", s)
+ t.Fail()
+ }
+ repacked := make([]byte, len(rrbytes))
+ if _, err := PackRR(rr2, repacked, 0, nil, false); err != nil {
+ t.Logf("error packing parsed RR: %v", err)
+ t.Logf(" original Bytes: %v\n", rrbytes)
+ t.Logf("unpacked Struct: %V\n", rr1)
+ t.Logf(" parsed Struct: %V\n", rr2)
+ t.Fail()
+ }
+ if !bytes.Equal(repacked, rrbytes) {
+ t.Log("packed bytes don't match original bytes")
+ t.Logf(" original bytes: %v", rrbytes)
+ t.Logf(" packed bytes: %v", repacked)
+ t.Logf("unpacked struct: %V", rr1)
+ t.Logf(" parsed struct: %V", rr2)
+ t.Fail()
+ }
+ }
+}
+
+func TestTXTEscapeParsing(t *testing.T) {
+ test := [][]string{
+ {`";"`, `";"`},
+ {`\;`, `";"`},
+ {`"\t"`, `"\t"`},
+ {`"\r"`, `"\r"`},
+ {`"\ "`, `" "`},
+ {`"\;"`, `";"`},
+ {`"\;\""`, `";\""`},
+ {`"\(a\)"`, `"(a)"`},
+ {`"\(a)"`, `"(a)"`},
+ {`"(a\)"`, `"(a)"`},
+ {`"(a)"`, `"(a)"`},
+ {`"\048"`, `"0"`},
+ {`"\` + "\n" + `"`, `"\n"`},
+ {`"\` + "\r" + `"`, `"\r"`},
+ {`"\` + "\x11" + `"`, `"\017"`},
+ {`"\'"`, `"'"`},
+ }
+ for _, s := range test {
+ rr, err := NewRR(fmt.Sprintf("example.com. IN TXT %v", s[0]))
+ if err != nil {
+ t.Errorf("Could not parse %v TXT: %s", s[0], err)
+ continue
+ }
+
+ txt := sprintTxt(rr.(*TXT).Txt)
+ if txt != s[1] {
+ t.Errorf("Mismatch after parsing `%v` TXT record: `%v` != `%v`", s[0], txt, s[1])
+ }
+ }
+}
+
+func GenerateDomain(r *rand.Rand, size int) []byte {
+ dnLen := size % 70 // artificially limit size so there's less to intrepret if a failure occurs
+ var dn []byte
+ done := false
+ for i := 0; i < dnLen && !done; {
+ max := dnLen - i
+ if max > 63 {
+ max = 63
+ }
+ lLen := max
+ if lLen != 0 {
+ lLen = int(r.Int31()) % max
+ }
+ done = lLen == 0
+ if done {
+ continue
+ }
+ l := make([]byte, lLen+1)
+ l[0] = byte(lLen)
+ for j := 0; j < lLen; j++ {
+ l[j+1] = byte(rand.Int31())
+ }
+ dn = append(dn, l...)
+ i += 1 + lLen
+ }
+ return append(dn, 0)
+}
+
+func TestDomainQuick(t *testing.T) {
+ r := rand.New(rand.NewSource(0))
+ f := func(l int) bool {
+ db := GenerateDomain(r, l)
+ ds, _, err := UnpackDomainName(db, 0)
+ if err != nil {
+ panic(err)
+ }
+ buf := make([]byte, 255)
+ off, err := PackDomainName(ds, buf, 0, nil, false)
+ if err != nil {
+ t.Logf("error packing domain: %s", err.Error())
+ t.Logf(" bytes: %v\n", db)
+ t.Logf("string: %v\n", ds)
+ return false
+ }
+ if !bytes.Equal(db, buf[:off]) {
+ t.Logf("repacked domain doesn't match original:")
+ t.Logf("src bytes: %v", db)
+ t.Logf(" string: %v", ds)
+ t.Logf("out bytes: %v", buf[:off])
+ return false
+ }
+ return true
+ }
+ if err := quick.Check(f, nil); err != nil {
+ t.Error(err)
+ }
+}
+
+func GenerateTXT(r *rand.Rand, size int) []byte {
+ rdLen := size % 300 // artificially limit size so there's less to intrepret if a failure occurs
+ var rd []byte
+ for i := 0; i < rdLen; {
+ max := rdLen - 1
+ if max > 255 {
+ max = 255
+ }
+ sLen := max
+ if max != 0 {
+ sLen = int(r.Int31()) % max
+ }
+ s := make([]byte, sLen+1)
+ s[0] = byte(sLen)
+ for j := 0; j < sLen; j++ {
+ s[j+1] = byte(rand.Int31())
+ }
+ rd = append(rd, s...)
+ i += 1 + sLen
+ }
+ return rd
+}
+
+func TestTXTRRQuick(t *testing.T) {
+ s := rand.NewSource(0)
+ r := rand.New(s)
+ typeAndClass := []byte{
+ byte(TypeTXT >> 8), byte(TypeTXT),
+ byte(ClassINET >> 8), byte(ClassINET),
+ 0, 0, 0, 1, // TTL
+ }
+ f := func(l int) bool {
+ owner := GenerateDomain(r, l)
+ rdata := GenerateTXT(r, l)
+ rrbytes := make([]byte, 0, len(owner)+2+2+4+2+len(rdata))
+ rrbytes = append(rrbytes, owner...)
+ rrbytes = append(rrbytes, typeAndClass...)
+ rrbytes = append(rrbytes, byte(len(rdata)>>8))
+ rrbytes = append(rrbytes, byte(len(rdata)))
+ rrbytes = append(rrbytes, rdata...)
+ rr, _, err := UnpackRR(rrbytes, 0)
+ if err != nil {
+ panic(err)
+ }
+ buf := make([]byte, len(rrbytes)*3)
+ off, err := PackRR(rr, buf, 0, nil, false)
+ if err != nil {
+ t.Logf("pack Error: %s\nRR: %V", err.Error(), rr)
+ return false
+ }
+ buf = buf[:off]
+ if !bytes.Equal(buf, rrbytes) {
+ t.Logf("packed bytes don't match original bytes")
+ t.Logf("src bytes: %v", rrbytes)
+ t.Logf(" struct: %V", rr)
+ t.Logf("oUt bytes: %v", buf)
+ return false
+ }
+ if len(rdata) == 0 {
+ // string'ing won't produce any data to parse
+ return true
+ }
+ rrString := rr.String()
+ rr2, err := NewRR(rrString)
+ if err != nil {
+ t.Logf("error parsing own output: %s", err.Error())
+ t.Logf("struct: %V", rr)
+ t.Logf("string: %v", rrString)
+ return false
+ }
+ if rr2.String() != rrString {
+ t.Logf("parsed rr.String() doesn't match original string")
+ t.Logf("original: %v", rrString)
+ t.Logf(" parsed: %v", rr2.String())
+ return false
+ }
+
+ buf = make([]byte, len(rrbytes)*3)
+ off, err = PackRR(rr2, buf, 0, nil, false)
+ if err != nil {
+ t.Logf("error packing parsed rr: %s", err.Error())
+ t.Logf("unpacked Struct: %V", rr)
+ t.Logf(" string: %v", rrString)
+ t.Logf(" parsed Struct: %V", rr2)
+ return false
+ }
+ buf = buf[:off]
+ if !bytes.Equal(buf, rrbytes) {
+ t.Logf("parsed packed bytes don't match original bytes")
+ t.Logf(" source bytes: %v", rrbytes)
+ t.Logf("unpacked struct: %V", rr)
+ t.Logf(" string: %v", rrString)
+ t.Logf(" parsed struct: %V", rr2)
+ t.Logf(" repacked bytes: %v", buf)
+ return false
+ }
+ return true
+ }
+ c := &quick.Config{MaxCountScale: 10}
+ if err := quick.Check(f, c); err != nil {
+ t.Error(err)
+ }
+}
+
+func TestParseDirectiveMisc(t *testing.T) {
+ tests := map[string]string{
+ "$ORIGIN miek.nl.\na IN NS b": "a.miek.nl.\t3600\tIN\tNS\tb.miek.nl.",
+ "$TTL 2H\nmiek.nl. IN NS b.": "miek.nl.\t7200\tIN\tNS\tb.",
+ "miek.nl. 1D IN NS b.": "miek.nl.\t86400\tIN\tNS\tb.",
+ `name. IN SOA a6.nstld.com. hostmaster.nic.name. (
+ 203362132 ; serial
+ 5m ; refresh (5 minutes)
+ 5m ; retry (5 minutes)
+ 2w ; expire (2 weeks)
+ 300 ; minimum (5 minutes)
+)`: "name.\t3600\tIN\tSOA\ta6.nstld.com. hostmaster.nic.name. 203362132 300 300 1209600 300",
+ ". 3600000 IN NS ONE.MY-ROOTS.NET.": ".\t3600000\tIN\tNS\tONE.MY-ROOTS.NET.",
+ "ONE.MY-ROOTS.NET. 3600000 IN A 192.168.1.1": "ONE.MY-ROOTS.NET.\t3600000\tIN\tA\t192.168.1.1",
+ }
+ for i, o := range tests {
+ rr, e := NewRR(i)
+ if e != nil {
+ t.Log("failed to parse RR: " + e.Error())
+ t.Fail()
+ continue
+ }
+ if rr.String() != o {
+ t.Logf("`%s' should be equal to\n`%s', but is `%s'\n", i, o, rr.String())
+ t.Fail()
+ } else {
+ t.Logf("RR is OK: `%s'", rr.String())
+ }
+ }
+}
+
+func TestNSEC(t *testing.T) {
+ nsectests := map[string]string{
+ "nl. IN NSEC3PARAM 1 0 5 30923C44C6CBBB8F": "nl.\t3600\tIN\tNSEC3PARAM\t1 0 5 30923C44C6CBBB8F",
+ "p2209hipbpnm681knjnu0m1febshlv4e.nl. IN NSEC3 1 1 5 30923C44C6CBBB8F P90DG1KE8QEAN0B01613LHQDG0SOJ0TA NS SOA TXT RRSIG DNSKEY NSEC3PARAM": "p2209hipbpnm681knjnu0m1febshlv4e.nl.\t3600\tIN\tNSEC3\t1 1 5 30923C44C6CBBB8F P90DG1KE8QEAN0B01613LHQDG0SOJ0TA NS SOA TXT RRSIG DNSKEY NSEC3PARAM",
+ "localhost.dnssex.nl. IN NSEC www.dnssex.nl. A RRSIG NSEC": "localhost.dnssex.nl.\t3600\tIN\tNSEC\twww.dnssex.nl. A RRSIG NSEC",
+ "localhost.dnssex.nl. IN NSEC www.dnssex.nl. A RRSIG NSEC TYPE65534": "localhost.dnssex.nl.\t3600\tIN\tNSEC\twww.dnssex.nl. A RRSIG NSEC TYPE65534",
+ "localhost.dnssex.nl. IN NSEC www.dnssex.nl. A RRSIG NSec Type65534": "localhost.dnssex.nl.\t3600\tIN\tNSEC\twww.dnssex.nl. A RRSIG NSEC TYPE65534",
+ }
+ for i, o := range nsectests {
+ rr, e := NewRR(i)
+ if e != nil {
+ t.Log("failed to parse RR: " + e.Error())
+ t.Fail()
+ continue
+ }
+ if rr.String() != o {
+ t.Logf("`%s' should be equal to\n`%s', but is `%s'\n", i, o, rr.String())
+ t.Fail()
+ } else {
+ t.Logf("RR is OK: `%s'", rr.String())
+ }
+ }
+}
+
+func TestParseLOC(t *testing.T) {
+ lt := map[string]string{
+ "SW1A2AA.find.me.uk. LOC 51 30 12.748 N 00 07 39.611 W 0.00m 0.00m 0.00m 0.00m": "SW1A2AA.find.me.uk.\t3600\tIN\tLOC\t51 30 12.748 N 00 07 39.611 W 0m 0.00m 0.00m 0.00m",
+ "SW1A2AA.find.me.uk. LOC 51 0 0.0 N 00 07 39.611 W 0.00m 0.00m 0.00m 0.00m": "SW1A2AA.find.me.uk.\t3600\tIN\tLOC\t51 00 0.000 N 00 07 39.611 W 0m 0.00m 0.00m 0.00m",
+ }
+ for i, o := range lt {
+ rr, e := NewRR(i)
+ if e != nil {
+ t.Log("failed to parse RR: " + e.Error())
+ t.Fail()
+ continue
+ }
+ if rr.String() != o {
+ t.Logf("`%s' should be equal to\n`%s', but is `%s'\n", i, o, rr.String())
+ t.Fail()
+ } else {
+ t.Logf("RR is OK: `%s'", rr.String())
+ }
+ }
+}
+
+func TestParseDS(t *testing.T) {
+ dt := map[string]string{
+ "example.net. 3600 IN DS 40692 12 3 22261A8B0E0D799183E35E24E2AD6BB58533CBA7E3B14D659E9CA09B 2071398F": "example.net.\t3600\tIN\tDS\t40692 12 3 22261A8B0E0D799183E35E24E2AD6BB58533CBA7E3B14D659E9CA09B2071398F",
+ }
+ for i, o := range dt {
+ rr, e := NewRR(i)
+ if e != nil {
+ t.Log("failed to parse RR: " + e.Error())
+ t.Fail()
+ continue
+ }
+ if rr.String() != o {
+ t.Logf("`%s' should be equal to\n`%s', but is `%s'\n", i, o, rr.String())
+ t.Fail()
+ } else {
+ t.Logf("RR is OK: `%s'", rr.String())
+ }
+ }
+}
+
+func TestQuotes(t *testing.T) {
+ tests := map[string]string{
+ `t.example.com. IN TXT "a bc"`: "t.example.com.\t3600\tIN\tTXT\t\"a bc\"",
+ `t.example.com. IN TXT "a
+ bc"`: "t.example.com.\t3600\tIN\tTXT\t\"a\\n bc\"",
+ `t.example.com. IN TXT ""`: "t.example.com.\t3600\tIN\tTXT\t\"\"",
+ `t.example.com. IN TXT "a"`: "t.example.com.\t3600\tIN\tTXT\t\"a\"",
+ `t.example.com. IN TXT "aa"`: "t.example.com.\t3600\tIN\tTXT\t\"aa\"",
+ `t.example.com. IN TXT "aaa" ;`: "t.example.com.\t3600\tIN\tTXT\t\"aaa\"",
+ `t.example.com. IN TXT "abc" "DEF"`: "t.example.com.\t3600\tIN\tTXT\t\"abc\" \"DEF\"",
+ `t.example.com. IN TXT "abc" ( "DEF" )`: "t.example.com.\t3600\tIN\tTXT\t\"abc\" \"DEF\"",
+ `t.example.com. IN TXT aaa ;`: "t.example.com.\t3600\tIN\tTXT\t\"aaa \"",
+ `t.example.com. IN TXT aaa aaa;`: "t.example.com.\t3600\tIN\tTXT\t\"aaa aaa\"",
+ `t.example.com. IN TXT aaa aaa`: "t.example.com.\t3600\tIN\tTXT\t\"aaa aaa\"",
+ `t.example.com. IN TXT aaa`: "t.example.com.\t3600\tIN\tTXT\t\"aaa\"",
+ "cid.urn.arpa. NAPTR 100 50 \"s\" \"z3950+I2L+I2C\" \"\" _z3950._tcp.gatech.edu.": "cid.urn.arpa.\t3600\tIN\tNAPTR\t100 50 \"s\" \"z3950+I2L+I2C\" \"\" _z3950._tcp.gatech.edu.",
+ "cid.urn.arpa. NAPTR 100 50 \"s\" \"rcds+I2C\" \"\" _rcds._udp.gatech.edu.": "cid.urn.arpa.\t3600\tIN\tNAPTR\t100 50 \"s\" \"rcds+I2C\" \"\" _rcds._udp.gatech.edu.",
+ "cid.urn.arpa. NAPTR 100 50 \"s\" \"http+I2L+I2C+I2R\" \"\" _http._tcp.gatech.edu.": "cid.urn.arpa.\t3600\tIN\tNAPTR\t100 50 \"s\" \"http+I2L+I2C+I2R\" \"\" _http._tcp.gatech.edu.",
+ "cid.urn.arpa. NAPTR 100 10 \"\" \"\" \"/urn:cid:.+@([^\\.]+\\.)(.*)$/\\2/i\" .": "cid.urn.arpa.\t3600\tIN\tNAPTR\t100 10 \"\" \"\" \"/urn:cid:.+@([^\\.]+\\.)(.*)$/\\2/i\" .",
+ }
+ for i, o := range tests {
+ rr, e := NewRR(i)
+ if e != nil {
+ t.Log("failed to parse RR: " + e.Error())
+ t.Fail()
+ continue
+ }
+ if rr.String() != o {
+ t.Logf("`%s' should be equal to\n`%s', but is\n`%s'\n", i, o, rr.String())
+ t.Fail()
+ } else {
+ t.Logf("RR is OK: `%s'", rr.String())
+ }
+ }
+}
+
+func TestParseClass(t *testing.T) {
+ tests := map[string]string{
+ "t.example.com. IN A 127.0.0.1": "t.example.com. 3600 IN A 127.0.0.1",
+ "t.example.com. CS A 127.0.0.1": "t.example.com. 3600 CS A 127.0.0.1",
+ "t.example.com. CH A 127.0.0.1": "t.example.com. 3600 CH A 127.0.0.1",
+ // ClassANY can not occur in zone files
+ // "t.example.com. ANY A 127.0.0.1": "t.example.com. 3600 ANY A 127.0.0.1",
+ "t.example.com. NONE A 127.0.0.1": "t.example.com. 3600 NONE A 127.0.0.1",
+ }
+ for i, o := range tests {
+ rr, e := NewRR(i)
+ if e != nil {
+ t.Log("failed to parse RR: " + e.Error())
+ t.Fail()
+ continue
+ }
+ if rr.String() != o {
+ t.Logf("`%s' should be equal to\n`%s', but is\n`%s'\n", i, o, rr.String())
+ t.Fail()
+ } else {
+ t.Logf("RR is OK: `%s'", rr.String())
+ }
+ }
+}
+
+func TestBrace(t *testing.T) {
+ tests := map[string]string{
+ "(miek.nl.) 3600 IN A 127.0.1.1": "miek.nl.\t3600\tIN\tA\t127.0.1.1",
+ "miek.nl. (3600) IN MX (10) elektron.atoom.net.": "miek.nl.\t3600\tIN\tMX\t10 elektron.atoom.net.",
+ `miek.nl. IN (
+ 3600 A 127.0.0.1)`: "miek.nl.\t3600\tIN\tA\t127.0.0.1",
+ "(miek.nl.) (A) (127.0.2.1)": "miek.nl.\t3600\tIN\tA\t127.0.2.1",
+ "miek.nl A 127.0.3.1": "miek.nl.\t3600\tIN\tA\t127.0.3.1",
+ "_ssh._tcp.local. 60 IN (PTR) stora._ssh._tcp.local.": "_ssh._tcp.local.\t60\tIN\tPTR\tstora._ssh._tcp.local.",
+ "miek.nl. NS ns.miek.nl": "miek.nl.\t3600\tIN\tNS\tns.miek.nl.",
+ `(miek.nl.) (
+ (IN)
+ (AAAA)
+ (::1) )`: "miek.nl.\t3600\tIN\tAAAA\t::1",
+ `(miek.nl.) (
+ (IN)
+ (AAAA)
+ (::1))`: "miek.nl.\t3600\tIN\tAAAA\t::1",
+ "miek.nl. IN AAAA ::2": "miek.nl.\t3600\tIN\tAAAA\t::2",
+ `((m)(i)ek.(n)l.) (SOA) (soa.) (soa.) (
+ 2009032802 ; serial
+ 21600 ; refresh (6 hours)
+ 7(2)00 ; retry (2 hours)
+ 604()800 ; expire (1 week)
+ 3600 ; minimum (1 hour)
+ )`: "miek.nl.\t3600\tIN\tSOA\tsoa. soa. 2009032802 21600 7200 604800 3600",
+ "miek\\.nl. IN A 127.0.0.10": "miek\\.nl.\t3600\tIN\tA\t127.0.0.10",
+ "miek.nl. IN A 127.0.0.11": "miek.nl.\t3600\tIN\tA\t127.0.0.11",
+ "miek.nl. A 127.0.0.12": "miek.nl.\t3600\tIN\tA\t127.0.0.12",
+ `miek.nl. 86400 IN SOA elektron.atoom.net. miekg.atoom.net. (
+ 2009032802 ; serial
+ 21600 ; refresh (6 hours)
+ 7200 ; retry (2 hours)
+ 604800 ; expire (1 week)
+ 3600 ; minimum (1 hour)
+ )`: "miek.nl.\t86400\tIN\tSOA\telektron.atoom.net. miekg.atoom.net. 2009032802 21600 7200 604800 3600",
+ }
+ for i, o := range tests {
+ rr, e := NewRR(i)
+ if e != nil {
+ t.Log("failed to parse RR: " + e.Error() + "\n\t" + i)
+ t.Fail()
+ continue
+ }
+ if rr.String() != o {
+ t.Logf("`%s' should be equal to\n`%s', but is `%s'\n", i, o, rr.String())
+ t.Fail()
+ } else {
+ t.Logf("RR is OK: `%s'", rr.String())
+ }
+ }
+}
+
+func TestParseFailure(t *testing.T) {
+ tests := []string{"miek.nl. IN A 327.0.0.1",
+ "miek.nl. IN AAAA ::x",
+ "miek.nl. IN MX a0 miek.nl.",
+ "miek.nl aap IN MX mx.miek.nl.",
+ "miek.nl 200 IN mxx 10 mx.miek.nl.",
+ "miek.nl. inn MX 10 mx.miek.nl.",
+ // "miek.nl. IN CNAME ", // actually valid nowadays, zero size rdata
+ "miek.nl. IN CNAME ..",
+ "miek.nl. PA MX 10 miek.nl.",
+ "miek.nl. ) IN MX 10 miek.nl.",
+ }
+
+ for _, s := range tests {
+ _, err := NewRR(s)
+ if err == nil {
+ t.Logf("should have triggered an error: \"%s\"", s)
+ t.Fail()
+ }
+ }
+}
+
+func TestZoneParsing(t *testing.T) {
+ // parse_test.db
+ db := `
+a.example.com. IN A 127.0.0.1
+8db7._openpgpkey.example.com. IN OPENPGPKEY mQCNAzIG
+$ORIGIN a.example.com.
+test IN A 127.0.0.1
+$ORIGIN b.example.com.
+test IN CNAME test.a.example.com.
+`
+ start := time.Now().UnixNano()
+ to := ParseZone(strings.NewReader(db), "", "parse_test.db")
+ var i int
+ for x := range to {
+ i++
+ if x.Error != nil {
+ t.Logf("%s\n", x.Error)
+ t.Fail()
+ continue
+ }
+ t.Logf("%s\n", x.RR)
+ }
+ delta := time.Now().UnixNano() - start
+ t.Logf("%d RRs parsed in %.2f s (%.2f RR/s)", i, float32(delta)/1e9, float32(i)/(float32(delta)/1e9))
+}
+
+func ExampleZone() {
+ zone := `$ORIGIN .
+$TTL 3600 ; 1 hour
+name IN SOA a6.nstld.com. hostmaster.nic.name. (
+ 203362132 ; serial
+ 300 ; refresh (5 minutes)
+ 300 ; retry (5 minutes)
+ 1209600 ; expire (2 weeks)
+ 300 ; minimum (5 minutes)
+ )
+$TTL 10800 ; 3 hours
+name. 10800 IN NS name.
+ IN NS g6.nstld.com.
+ 7200 NS h6.nstld.com.
+ 3600 IN NS j6.nstld.com.
+ IN 3600 NS k6.nstld.com.
+ NS l6.nstld.com.
+ NS a6.nstld.com.
+ NS c6.nstld.com.
+ NS d6.nstld.com.
+ NS f6.nstld.com.
+ NS m6.nstld.com.
+(
+ NS m7.nstld.com.
+)
+$ORIGIN name.
+0-0onlus NS ns7.ehiweb.it.
+ NS ns8.ehiweb.it.
+0-g MX 10 mx01.nic
+ MX 10 mx02.nic
+ MX 10 mx03.nic
+ MX 10 mx04.nic
+$ORIGIN 0-g.name
+moutamassey NS ns01.yahoodomains.jp.
+ NS ns02.yahoodomains.jp.
+`
+ to := ParseZone(strings.NewReader(zone), "", "testzone")
+ for x := range to {
+ fmt.Printf("%s\n", x.RR)
+ }
+ // Output:
+ // name. 3600 IN SOA a6.nstld.com. hostmaster.nic.name. 203362132 300 300 1209600 300
+ // name. 10800 IN NS name.
+ // name. 10800 IN NS g6.nstld.com.
+ // name. 7200 IN NS h6.nstld.com.
+ // name. 3600 IN NS j6.nstld.com.
+ // name. 3600 IN NS k6.nstld.com.
+ // name. 10800 IN NS l6.nstld.com.
+ // name. 10800 IN NS a6.nstld.com.
+ // name. 10800 IN NS c6.nstld.com.
+ // name. 10800 IN NS d6.nstld.com.
+ // name. 10800 IN NS f6.nstld.com.
+ // name. 10800 IN NS m6.nstld.com.
+ // name. 10800 IN NS m7.nstld.com.
+ // 0-0onlus.name. 10800 IN NS ns7.ehiweb.it.
+ // 0-0onlus.name. 10800 IN NS ns8.ehiweb.it.
+ // 0-g.name. 10800 IN MX 10 mx01.nic.name.
+ // 0-g.name. 10800 IN MX 10 mx02.nic.name.
+ // 0-g.name. 10800 IN MX 10 mx03.nic.name.
+ // 0-g.name. 10800 IN MX 10 mx04.nic.name.
+ // moutamassey.0-g.name.name. 10800 IN NS ns01.yahoodomains.jp.
+ // moutamassey.0-g.name.name. 10800 IN NS ns02.yahoodomains.jp.
+}
+
+func ExampleHIP() {
+ h := `www.example.com IN HIP ( 2 200100107B1A74DF365639CC39F1D578
+ AwEAAbdxyhNuSutc5EMzxTs9LBPCIkOFH8cIvM4p
+9+LrV4e19WzK00+CI6zBCQTdtWsuxKbWIy87UOoJTwkUs7lBu+Upr1gsNrut79ryra+bSRGQ
+b1slImA8YVJyuIDsj7kwzG7jnERNqnWxZ48AWkskmdHaVDP4BcelrTI3rMXdXF5D
+ rvs.example.com. )`
+ if hip, err := NewRR(h); err == nil {
+ fmt.Printf("%s\n", hip.String())
+ }
+ // Output:
+ // www.example.com. 3600 IN HIP 2 200100107B1A74DF365639CC39F1D578 AwEAAbdxyhNuSutc5EMzxTs9LBPCIkOFH8cIvM4p9+LrV4e19WzK00+CI6zBCQTdtWsuxKbWIy87UOoJTwkUs7lBu+Upr1gsNrut79ryra+bSRGQb1slImA8YVJyuIDsj7kwzG7jnERNqnWxZ48AWkskmdHaVDP4BcelrTI3rMXdXF5D rvs.example.com.
+}
+
+func TestHIP(t *testing.T) {
+ h := `www.example.com. IN HIP ( 2 200100107B1A74DF365639CC39F1D578
+ AwEAAbdxyhNuSutc5EMzxTs9LBPCIkOFH8cIvM4p
+9+LrV4e19WzK00+CI6zBCQTdtWsuxKbWIy87UOoJTwkUs7lBu+Upr1gsNrut79ryra+bSRGQ
+b1slImA8YVJyuIDsj7kwzG7jnERNqnWxZ48AWkskmdHaVDP4BcelrTI3rMXdXF5D
+ rvs1.example.com.
+ rvs2.example.com. )`
+ rr, err := NewRR(h)
+ if err != nil {
+ t.Fatalf("failed to parse RR: %s", err)
+ }
+ t.Logf("RR: %s", rr)
+ msg := new(Msg)
+ msg.Answer = []RR{rr, rr}
+ bytes, err := msg.Pack()
+ if err != nil {
+ t.Fatalf("failed to pack msg: %s", err)
+ }
+ if err := msg.Unpack(bytes); err != nil {
+ t.Fatalf("failed to unpack msg: %s", err)
+ }
+ if len(msg.Answer) != 2 {
+ t.Fatalf("2 answers expected: %V", msg)
+ }
+ for i, rr := range msg.Answer {
+ rr := rr.(*HIP)
+ t.Logf("RR: %s", rr)
+ if l := len(rr.RendezvousServers); l != 2 {
+ t.Fatalf("2 servers expected, only %d in record %d:\n%V", l, i, msg)
+ }
+ for j, s := range []string{"rvs1.example.com.", "rvs2.example.com."} {
+ if rr.RendezvousServers[j] != s {
+ t.Fatalf("expected server %d of record %d to be %s:\n%V", j, i, s, msg)
+ }
+ }
+ }
+}
+
+func ExampleSOA() {
+ s := "example.com. 1000 SOA master.example.com. admin.example.com. 1 4294967294 4294967293 4294967295 100"
+ if soa, err := NewRR(s); err == nil {
+ fmt.Printf("%s\n", soa.String())
+ }
+ // Output:
+ // example.com. 1000 IN SOA master.example.com. admin.example.com. 1 4294967294 4294967293 4294967295 100
+}
+
+func TestLineNumberError(t *testing.T) {
+ s := "example.com. 1000 SOA master.example.com. admin.example.com. monkey 4294967294 4294967293 4294967295 100"
+ if _, err := NewRR(s); err != nil {
+ if err.Error() != "dns: bad SOA zone parameter: \"monkey\" at line: 1:68" {
+ t.Logf("not expecting this error: " + err.Error())
+ t.Fail()
+ }
+ }
+}
+
+// Test with no known RR on the line
+func TestLineNumberError2(t *testing.T) {
+ tests := map[string]string{
+ "example.com. 1000 SO master.example.com. admin.example.com. 1 4294967294 4294967293 4294967295 100": "dns: expecting RR type or class, not this...: \"SO\" at line: 1:21",
+ "example.com 1000 IN TALINK a.example.com. b..example.com.": "dns: bad TALINK NextName: \"b..example.com.\" at line: 1:57",
+ "example.com 1000 IN TALINK ( a.example.com. b..example.com. )": "dns: bad TALINK NextName: \"b..example.com.\" at line: 1:60",
+ `example.com 1000 IN TALINK ( a.example.com.
+ bb..example.com. )`: "dns: bad TALINK NextName: \"bb..example.com.\" at line: 2:18",
+ // This is a bug, it should report an error on line 1, but the new is already processed.
+ `example.com 1000 IN TALINK ( a.example.com. b...example.com.
+ )`: "dns: bad TALINK NextName: \"b...example.com.\" at line: 2:1"}
+
+ for in, err := range tests {
+ _, e := NewRR(in)
+ if e == nil {
+ t.Fail()
+ } else {
+ if e.Error() != err {
+ t.Logf("%s\n", in)
+ t.Logf("error should be %s is %s\n", err, e.Error())
+ t.Fail()
+ }
+ }
+ }
+}
+
+// Test if the calculations are correct
+func TestRfc1982(t *testing.T) {
+ // If the current time and the timestamp are more than 68 years apart
+ // it means the date has wrapped. 0 is 1970
+
+ // fall in the current 68 year span
+ strtests := []string{"20120525134203", "19700101000000", "20380119031408"}
+ for _, v := range strtests {
+ if x, _ := StringToTime(v); v != TimeToString(x) {
+ t.Logf("1982 arithmetic string failure %s (%s:%d)", v, TimeToString(x), x)
+ t.Fail()
+ }
+ }
+
+ inttests := map[uint32]string{0: "19700101000000",
+ 1 << 31: "20380119031408",
+ 1<<32 - 1: "21060207062815",
+ }
+ for i, v := range inttests {
+ if TimeToString(i) != v {
+ t.Logf("1982 arithmetic int failure %d:%s (%s)", i, v, TimeToString(i))
+ t.Fail()
+ }
+ }
+
+ // Future tests, these dates get parsed to a date within the current 136 year span
+ future := map[string]string{"22680119031408": "20631123173144",
+ "19010101121212": "20370206184028",
+ "19210101121212": "20570206184028",
+ "19500101121212": "20860206184028",
+ "19700101000000": "19700101000000",
+ "19690101000000": "21050207062816",
+ "29210101121212": "21040522212236",
+ }
+ for from, to := range future {
+ x, _ := StringToTime(from)
+ y := TimeToString(x)
+ if y != to {
+ t.Logf("1982 arithmetic future failure %s:%s (%s)", from, to, y)
+ t.Fail()
+ }
+ }
+}
+
+func TestEmpty(t *testing.T) {
+ for _ = range ParseZone(strings.NewReader(""), "", "") {
+ t.Logf("should be empty")
+ t.Fail()
+ }
+}
+
+func TestLowercaseTokens(t *testing.T) {
+ var testrecords = []string{
+ "example.org. 300 IN a 1.2.3.4",
+ "example.org. 300 in A 1.2.3.4",
+ "example.org. 300 in a 1.2.3.4",
+ "example.org. 300 a 1.2.3.4",
+ "example.org. 300 A 1.2.3.4",
+ "example.org. IN a 1.2.3.4",
+ "example.org. in A 1.2.3.4",
+ "example.org. in a 1.2.3.4",
+ "example.org. a 1.2.3.4",
+ "example.org. A 1.2.3.4",
+ "example.org. a 1.2.3.4",
+ "$ORIGIN example.org.\n a 1.2.3.4",
+ "$Origin example.org.\n a 1.2.3.4",
+ "$origin example.org.\n a 1.2.3.4",
+ "example.org. Class1 Type1 1.2.3.4",
+ }
+ for _, testrr := range testrecords {
+ _, err := NewRR(testrr)
+ if err != nil {
+ t.Errorf("failed to parse %#v, got %s", testrr, err.Error())
+ }
+ }
+}
+
+func ExampleGenerate() {
+ // From the manual: http://www.bind9.net/manual/bind/9.3.2/Bv9ARM.ch06.html#id2566761
+ zone := "$GENERATE 1-2 0 NS SERVER$.EXAMPLE.\n$GENERATE 1-8 $ CNAME $.0"
+ to := ParseZone(strings.NewReader(zone), "0.0.192.IN-ADDR.ARPA.", "")
+ for x := range to {
+ if x.Error == nil {
+ fmt.Printf("%s\n", x.RR.String())
+ }
+ }
+ // Output:
+ // 0.0.0.192.IN-ADDR.ARPA. 3600 IN NS SERVER1.EXAMPLE.
+ // 0.0.0.192.IN-ADDR.ARPA. 3600 IN NS SERVER2.EXAMPLE.
+ // 1.0.0.192.IN-ADDR.ARPA. 3600 IN CNAME 1.0.0.0.192.IN-ADDR.ARPA.
+ // 2.0.0.192.IN-ADDR.ARPA. 3600 IN CNAME 2.0.0.0.192.IN-ADDR.ARPA.
+ // 3.0.0.192.IN-ADDR.ARPA. 3600 IN CNAME 3.0.0.0.192.IN-ADDR.ARPA.
+ // 4.0.0.192.IN-ADDR.ARPA. 3600 IN CNAME 4.0.0.0.192.IN-ADDR.ARPA.
+ // 5.0.0.192.IN-ADDR.ARPA. 3600 IN CNAME 5.0.0.0.192.IN-ADDR.ARPA.
+ // 6.0.0.192.IN-ADDR.ARPA. 3600 IN CNAME 6.0.0.0.192.IN-ADDR.ARPA.
+ // 7.0.0.192.IN-ADDR.ARPA. 3600 IN CNAME 7.0.0.0.192.IN-ADDR.ARPA.
+ // 8.0.0.192.IN-ADDR.ARPA. 3600 IN CNAME 8.0.0.0.192.IN-ADDR.ARPA.
+}
+
+func TestSRVPacking(t *testing.T) {
+ msg := Msg{}
+
+ things := []string{"1.2.3.4:8484",
+ "45.45.45.45:8484",
+ "84.84.84.84:8484",
+ }
+
+ for i, n := range things {
+ h, p, err := net.SplitHostPort(n)
+ if err != nil {
+ continue
+ }
+ port := 8484
+ tmp, err := strconv.Atoi(p)
+ if err == nil {
+ port = tmp
+ }
+
+ rr := &SRV{
+ Hdr: RR_Header{Name: "somename.",
+ Rrtype: TypeSRV,
+ Class: ClassINET,
+ Ttl: 5},
+ Priority: uint16(i),
+ Weight: 5,
+ Port: uint16(port),
+ Target: h + ".",
+ }
+
+ msg.Answer = append(msg.Answer, rr)
+ }
+
+ _, err := msg.Pack()
+ if err != nil {
+ t.Fatalf("couldn't pack %v\n", msg)
+ }
+}
+
+func TestParseBackslash(t *testing.T) {
+ if r, e := NewRR("nul\\000gap.test.globnix.net. 600 IN A 192.0.2.10"); e != nil {
+ t.Fatalf("could not create RR with \\000 in it")
+ } else {
+ t.Logf("parsed %s\n", r.String())
+ }
+ if r, e := NewRR(`nul\000gap.test.globnix.net. 600 IN TXT "Hello\123"`); e != nil {
+ t.Fatalf("could not create RR with \\000 in it")
+ } else {
+ t.Logf("parsed %s\n", r.String())
+ }
+ if r, e := NewRR(`m\ @\ iek.nl. IN 3600 A 127.0.0.1`); e != nil {
+ t.Fatalf("could not create RR with \\ and \\@ in it")
+ } else {
+ t.Logf("parsed %s\n", r.String())
+ }
+}
+
+func TestILNP(t *testing.T) {
+ tests := []string{
+ "host1.example.com.\t3600\tIN\tNID\t10 0014:4fff:ff20:ee64",
+ "host1.example.com.\t3600\tIN\tNID\t20 0015:5fff:ff21:ee65",
+ "host2.example.com.\t3600\tIN\tNID\t10 0016:6fff:ff22:ee66",
+ "host1.example.com.\t3600\tIN\tL32\t10 10.1.2.0",
+ "host1.example.com.\t3600\tIN\tL32\t20 10.1.4.0",
+ "host2.example.com.\t3600\tIN\tL32\t10 10.1.8.0",
+ "host1.example.com.\t3600\tIN\tL64\t10 2001:0DB8:1140:1000",
+ "host1.example.com.\t3600\tIN\tL64\t20 2001:0DB8:2140:2000",
+ "host2.example.com.\t3600\tIN\tL64\t10 2001:0DB8:4140:4000",
+ "host1.example.com.\t3600\tIN\tLP\t10 l64-subnet1.example.com.",
+ "host1.example.com.\t3600\tIN\tLP\t10 l64-subnet2.example.com.",
+ "host1.example.com.\t3600\tIN\tLP\t20 l32-subnet1.example.com.",
+ }
+ for _, t1 := range tests {
+ r, e := NewRR(t1)
+ if e != nil {
+ t.Fatalf("an error occured: %s\n", e.Error())
+ } else {
+ if t1 != r.String() {
+ t.Fatalf("strings should be equal %s %s", t1, r.String())
+ }
+ }
+ }
+}
+
+func TestNsapGposEidNimloc(t *testing.T) {
+ dt := map[string]string{
+ "foo.bar.com. IN NSAP 21 47000580ffff000000321099991111222233334444": "foo.bar.com.\t3600\tIN\tNSAP\t21 47000580ffff000000321099991111222233334444",
+ "host.school.de IN NSAP 17 39276f3100111100002222333344449876": "host.school.de.\t3600\tIN\tNSAP\t17 39276f3100111100002222333344449876",
+ "444433332222111199990123000000ff. NSAP-PTR foo.bar.com.": "444433332222111199990123000000ff.\t3600\tIN\tNSAP-PTR\tfoo.bar.com.",
+ "lillee. IN GPOS -32.6882 116.8652 10.0": "lillee.\t3600\tIN\tGPOS\t-32.6882 116.8652 10.0",
+ "hinault. IN GPOS -22.6882 116.8652 250.0": "hinault.\t3600\tIN\tGPOS\t-22.6882 116.8652 250.0",
+ "VENERA. IN NIMLOC 75234159EAC457800920": "VENERA.\t3600\tIN\tNIMLOC\t75234159EAC457800920",
+ "VAXA. IN EID 3141592653589793": "VAXA.\t3600\tIN\tEID\t3141592653589793",
+ }
+ for i, o := range dt {
+ rr, e := NewRR(i)
+ if e != nil {
+ t.Log("failed to parse RR: " + e.Error())
+ t.Fail()
+ continue
+ }
+ if rr.String() != o {
+ t.Logf("`%s' should be equal to\n`%s', but is `%s'\n", i, o, rr.String())
+ t.Fail()
+ } else {
+ t.Logf("RR is OK: `%s'", rr.String())
+ }
+ }
+}
+
+func TestPX(t *testing.T) {
+ dt := map[string]string{
+ "*.net2.it. IN PX 10 net2.it. PRMD-net2.ADMD-p400.C-it.": "*.net2.it.\t3600\tIN\tPX\t10 net2.it. PRMD-net2.ADMD-p400.C-it.",
+ "ab.net2.it. IN PX 10 ab.net2.it. O-ab.PRMD-net2.ADMDb.C-it.": "ab.net2.it.\t3600\tIN\tPX\t10 ab.net2.it. O-ab.PRMD-net2.ADMDb.C-it.",
+ }
+ for i, o := range dt {
+ rr, e := NewRR(i)
+ if e != nil {
+ t.Log("failed to parse RR: " + e.Error())
+ t.Fail()
+ continue
+ }
+ if rr.String() != o {
+ t.Logf("`%s' should be equal to\n`%s', but is `%s'\n", i, o, rr.String())
+ t.Fail()
+ } else {
+ t.Logf("RR is OK: `%s'", rr.String())
+ }
+ }
+}
+
+func TestComment(t *testing.T) {
+ // Comments we must see
+ comments := map[string]bool{"; this is comment 1": true,
+ "; this is comment 4": true, "; this is comment 6": true,
+ "; this is comment 7": true, "; this is comment 8": true}
+ zone := `
+foo. IN A 10.0.0.1 ; this is comment 1
+foo. IN A (
+ 10.0.0.2 ; this is comment2
+)
+; this is comment3
+foo. IN A 10.0.0.3
+foo. IN A ( 10.0.0.4 ); this is comment 4
+
+foo. IN A 10.0.0.5
+; this is comment5
+
+foo. IN A 10.0.0.6
+
+foo. IN DNSKEY 256 3 5 AwEAAb+8l ; this is comment 6
+foo. IN NSEC miek.nl. TXT RRSIG NSEC; this is comment 7
+foo. IN TXT "THIS IS TEXT MAN"; this is comment 8
+`
+ for x := range ParseZone(strings.NewReader(zone), ".", "") {
+ if x.Error == nil {
+ if x.Comment != "" {
+ if _, ok := comments[x.Comment]; !ok {
+ t.Logf("wrong comment %s", x.Comment)
+ t.Fail()
+ }
+ }
+ }
+ }
+}
+
+func TestEUIxx(t *testing.T) {
+ tests := map[string]string{
+ "host.example. IN EUI48 00-00-5e-90-01-2a": "host.example.\t3600\tIN\tEUI48\t00-00-5e-90-01-2a",
+ "host.example. IN EUI64 00-00-5e-ef-00-00-00-2a": "host.example.\t3600\tIN\tEUI64\t00-00-5e-ef-00-00-00-2a",
+ }
+ for i, o := range tests {
+ r, e := NewRR(i)
+ if e != nil {
+ t.Logf("failed to parse %s: %s\n", i, e.Error())
+ t.Fail()
+ }
+ if r.String() != o {
+ t.Logf("want %s, got %s\n", o, r.String())
+ t.Fail()
+ }
+ }
+}
+
+func TestUserRR(t *testing.T) {
+ tests := map[string]string{
+ "host.example. IN UID 1234": "host.example.\t3600\tIN\tUID\t1234",
+ "host.example. IN GID 1234556": "host.example.\t3600\tIN\tGID\t1234556",
+ "host.example. IN UINFO \"Miek Gieben\"": "host.example.\t3600\tIN\tUINFO\t\"Miek Gieben\"",
+ }
+ for i, o := range tests {
+ r, e := NewRR(i)
+ if e != nil {
+ t.Logf("failed to parse %s: %s\n", i, e.Error())
+ t.Fail()
+ }
+ if r.String() != o {
+ t.Logf("want %s, got %s\n", o, r.String())
+ t.Fail()
+ }
+ }
+}
+
+func TestTXT(t *testing.T) {
+ // Test single entry TXT record
+ rr, err := NewRR(`_raop._tcp.local. 60 IN TXT "single value"`)
+ if err != nil {
+ t.Error("failed to parse single value TXT record", err)
+ } else if rr, ok := rr.(*TXT); !ok {
+ t.Error("wrong type, record should be of type TXT")
+ } else {
+ if len(rr.Txt) != 1 {
+ t.Error("bad size of TXT value:", len(rr.Txt))
+ } else if rr.Txt[0] != "single value" {
+ t.Error("bad single value")
+ }
+ if rr.String() != `_raop._tcp.local. 60 IN TXT "single value"` {
+ t.Error("bad representation of TXT record:", rr.String())
+ }
+ if rr.len() != 28+1+12 {
+ t.Error("bad size of serialized record:", rr.len())
+ }
+ }
+
+ // Test multi entries TXT record
+ rr, err = NewRR(`_raop._tcp.local. 60 IN TXT "a=1" "b=2" "c=3" "d=4"`)
+ if err != nil {
+ t.Error("failed to parse multi-values TXT record", err)
+ } else if rr, ok := rr.(*TXT); !ok {
+ t.Error("wrong type, record should be of type TXT")
+ } else {
+ if len(rr.Txt) != 4 {
+ t.Error("bad size of TXT multi-value:", len(rr.Txt))
+ } else if rr.Txt[0] != "a=1" || rr.Txt[1] != "b=2" || rr.Txt[2] != "c=3" || rr.Txt[3] != "d=4" {
+ t.Error("bad values in TXT records")
+ }
+ if rr.String() != `_raop._tcp.local. 60 IN TXT "a=1" "b=2" "c=3" "d=4"` {
+ t.Error("bad representation of TXT multi value record:", rr.String())
+ }
+ if rr.len() != 28+1+3+1+3+1+3+1+3 {
+ t.Error("bad size of serialized multi value record:", rr.len())
+ }
+ }
+
+ // Test empty-string in TXT record
+ rr, err = NewRR(`_raop._tcp.local. 60 IN TXT ""`)
+ if err != nil {
+ t.Error("failed to parse empty-string TXT record", err)
+ } else if rr, ok := rr.(*TXT); !ok {
+ t.Error("wrong type, record should be of type TXT")
+ } else {
+ if len(rr.Txt) != 1 {
+ t.Error("bad size of TXT empty-string value:", len(rr.Txt))
+ } else if rr.Txt[0] != "" {
+ t.Error("bad value for empty-string TXT record")
+ }
+ if rr.String() != `_raop._tcp.local. 60 IN TXT ""` {
+ t.Error("bad representation of empty-string TXT record:", rr.String())
+ }
+ if rr.len() != 28+1 {
+ t.Error("bad size of serialized record:", rr.len())
+ }
+ }
+}
+
+func TestTypeXXXX(t *testing.T) {
+ _, err := NewRR("example.com IN TYPE1234 \\# 4 aabbccdd")
+ if err != nil {
+ t.Logf("failed to parse TYPE1234 RR: %s", err.Error())
+ t.Fail()
+ }
+ _, err = NewRR("example.com IN TYPE655341 \\# 8 aabbccddaabbccdd")
+ if err == nil {
+ t.Logf("this should not work, for TYPE655341")
+ t.Fail()
+ }
+ _, err = NewRR("example.com IN TYPE1 \\# 4 0a000001")
+ if err == nil {
+ t.Logf("this should not work")
+ t.Fail()
+ }
+}
+
+func TestPTR(t *testing.T) {
+ _, err := NewRR("144.2.0.192.in-addr.arpa. 900 IN PTR ilouse03146p0\\(.example.com.")
+ if err != nil {
+ t.Error("failed to parse ", err.Error())
+ }
+}
+
+func TestDigit(t *testing.T) {
+ tests := map[string]byte{
+ "miek\\000.nl. 100 IN TXT \"A\"": 0,
+ "miek\\001.nl. 100 IN TXT \"A\"": 1,
+ "miek\\254.nl. 100 IN TXT \"A\"": 254,
+ "miek\\255.nl. 100 IN TXT \"A\"": 255,
+ "miek\\256.nl. 100 IN TXT \"A\"": 0,
+ "miek\\257.nl. 100 IN TXT \"A\"": 1,
+ "miek\\004.nl. 100 IN TXT \"A\"": 4,
+ }
+ for s, i := range tests {
+ r, e := NewRR(s)
+ buf := make([]byte, 40)
+ if e != nil {
+ t.Fatalf("failed to parse %s\n", e.Error())
+ }
+ PackRR(r, buf, 0, nil, false)
+ t.Logf("%v\n", buf)
+ if buf[5] != i {
+ t.Fatalf("5 pos must be %d, is %d", i, buf[5])
+ }
+ r1, _, _ := UnpackRR(buf, 0)
+ if r1.Header().Ttl != 100 {
+ t.Fatalf("TTL should %d, is %d", 100, r1.Header().Ttl)
+ }
+ }
+}
+
+func TestParseRRSIGTimestamp(t *testing.T) {
+ tests := map[string]bool{
+ `miek.nl. IN RRSIG SOA 8 2 43200 20140210031301 20140111031301 12051 miek.nl. MVZUyrYwq0iZhMFDDnVXD2BvuNiUJjSYlJAgzyAE6CF875BMvvZa+Sb0 RlSCL7WODQSQHhCx/fegHhVVF+Iz8N8kOLrmXD1+jO3Bm6Prl5UhcsPx WTBsg/kmxbp8sR1kvH4oZJtVfakG3iDerrxNaf0sQwhZzyfJQAqpC7pcBoc=`: true,
+ `miek.nl. IN RRSIG SOA 8 2 43200 315565800 4102477800 12051 miek.nl. MVZUyrYwq0iZhMFDDnVXD2BvuNiUJjSYlJAgzyAE6CF875BMvvZa+Sb0 RlSCL7WODQSQHhCx/fegHhVVF+Iz8N8kOLrmXD1+jO3Bm6Prl5UhcsPx WTBsg/kmxbp8sR1kvH4oZJtVfakG3iDerrxNaf0sQwhZzyfJQAqpC7pcBoc=`: true,
+ }
+ for r, _ := range tests {
+ _, e := NewRR(r)
+ if e != nil {
+ t.Fail()
+ t.Logf("%s\n", e.Error())
+ }
+ }
+}
+
+func TestTxtEqual(t *testing.T) {
+ rr1 := new(TXT)
+ rr1.Hdr = RR_Header{Name: ".", Rrtype: TypeTXT, Class: ClassINET, Ttl: 0}
+ rr1.Txt = []string{"a\"a", "\"", "b"}
+ rr2, _ := NewRR(rr1.String())
+ if rr1.String() != rr2.String() {
+ t.Logf("these two TXT records should match")
+ t.Logf("\n%s\n%s\n", rr1.String(), rr2.String())
+ t.Fail() // This is not an error, but keep this test.
+ }
+ t.Logf("\n%s\n%s\n", rr1.String(), rr2.String())
+}
+
+func TestTxtLong(t *testing.T) {
+ rr1 := new(TXT)
+ rr1.Hdr = RR_Header{Name: ".", Rrtype: TypeTXT, Class: ClassINET, Ttl: 0}
+ // Make a long txt record, this breaks when sending the packet,
+ // but not earlier.
+ rr1.Txt = []string{"start-"}
+ for i := 0; i < 200; i++ {
+ rr1.Txt[0] += "start-"
+ }
+ str := rr1.String()
+ if len(str) < len(rr1.Txt[0]) {
+ t.Logf("string conversion should work")
+ t.Fail()
+ }
+}
+
+// Basically, don't crash.
+func TestMalformedPackets(t *testing.T) {
+ var packets = []string{
+ "0021641c0000000100000000000078787878787878787878787303636f6d0000100001",
+ }
+
+ // com = 63 6f 6d
+ for _, packet := range packets {
+ data, _ := hex.DecodeString(packet)
+ // for _, v := range data {
+ // t.Logf("%s ", string(v))
+ // }
+ var msg Msg
+ msg.Unpack(data)
+ // println(msg.String())
+ }
+}
+
+type algorithm struct {
+ name uint8
+ bits int
+}
+
+func TestNewPrivateKey(t *testing.T) {
+ if testing.Short() {
+ t.Skip("skipping test in short mode.")
+ }
+ algorithms := []algorithm{
+ algorithm{ECDSAP256SHA256, 256},
+ algorithm{ECDSAP384SHA384, 384},
+ algorithm{RSASHA1, 1024},
+ algorithm{RSASHA256, 2048},
+ algorithm{DSA, 1024},
+ }
+
+ for _, algo := range algorithms {
+ key := new(DNSKEY)
+ key.Hdr.Rrtype = TypeDNSKEY
+ key.Hdr.Name = "miek.nl."
+ key.Hdr.Class = ClassINET
+ key.Hdr.Ttl = 14400
+ key.Flags = 256
+ key.Protocol = 3
+ key.Algorithm = algo.name
+ privkey, err := key.Generate(algo.bits)
+ if err != nil {
+ t.Fatal(err.Error())
+ }
+
+ newPrivKey, err := key.NewPrivateKey(key.PrivateKeyString(privkey))
+ if err != nil {
+ t.Log(key.String())
+ t.Log(key.PrivateKeyString(privkey))
+
+ t.Fatal(err.Error())
+ }
+
+ switch newPrivKey := newPrivKey.(type) {
+ case *rsa.PrivateKey:
+ newPrivKey.Precompute()
+ }
+
+ if !reflect.DeepEqual(privkey, newPrivKey) {
+ t.Errorf("[%v] Private keys differ:\n%#v\n%#v\n", AlgorithmToString[algo.name], privkey, newPrivKey)
+ }
+ }
+}
diff --git a/Godeps/_workspace/src/github.com/miekg/dns/privaterr.go b/Godeps/_workspace/src/github.com/miekg/dns/privaterr.go
new file mode 100644
index 0000000000000000000000000000000000000000..225713743c94882dbeb0ad3758a049b46557ff76
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/miekg/dns/privaterr.go
@@ -0,0 +1,122 @@
+/*
+PRIVATE RR
+
+RFC 6895 sets aside a range of type codes for private use. This range
+is 65,280 - 65,534 (0xFF00 - 0xFFFE). When experimenting with new Resource Records these
+can be used, before requesting an official type code from IANA.
+*/
+package dns
+
+import (
+ "fmt"
+ "strings"
+)
+
+// PrivateRdata is an interface used for implementing "Private Use" RR types, see
+// RFC 6895. This allows one to experiment with new RR types, without requesting an
+// official type code. Also see dns.PrivateHandle and dns.PrivateHandleRemove.
+type PrivateRdata interface {
+ // String returns the text presentaton of the Rdata of the Private RR.
+ String() string
+ // Parse parses the Rdata of the private RR.
+ Parse([]string) error
+ // Pack is used when packing a private RR into a buffer.
+ Pack([]byte) (int, error)
+ // Unpack is used when unpacking a private RR from a buffer.
+ // TODO(miek): diff. signature than Pack, see edns0.go for instance.
+ Unpack([]byte) (int, error)
+ // Copy copies the Rdata.
+ Copy(PrivateRdata) error
+ // Len returns the length in octets of the Rdata.
+ Len() int
+}
+
+// PrivateRR represents an RR that uses a PrivateRdata user-defined type.
+// It mocks normal RRs and implements dns.RR interface.
+type PrivateRR struct {
+ Hdr RR_Header
+ Data PrivateRdata
+}
+
+func mkPrivateRR(rrtype uint16) *PrivateRR {
+ // Panics if RR is not an instance of PrivateRR.
+ rrfunc, ok := typeToRR[rrtype]
+ if !ok {
+ panic(fmt.Sprintf("dns: invalid operation with Private RR type %d", rrtype))
+ }
+
+ anyrr := rrfunc()
+ switch rr := anyrr.(type) {
+ case *PrivateRR:
+ return rr
+ }
+ panic(fmt.Sprintf("dns: RR is not a PrivateRR, typeToRR[%d] generator returned %T", rrtype, anyrr))
+}
+
+func (r *PrivateRR) Header() *RR_Header { return &r.Hdr }
+func (r *PrivateRR) String() string { return r.Hdr.String() + r.Data.String() }
+
+// Private len and copy parts to satisfy RR interface.
+func (r *PrivateRR) len() int { return r.Hdr.len() + r.Data.Len() }
+func (r *PrivateRR) copy() RR {
+ // make new RR like this:
+ rr := mkPrivateRR(r.Hdr.Rrtype)
+ newh := r.Hdr.copyHeader()
+ rr.Hdr = *newh
+
+ err := r.Data.Copy(rr.Data)
+ if err != nil {
+ panic("dns: got value that could not be used to copy Private rdata")
+ }
+ return rr
+}
+
+// PrivateHandle registers a private resource record type. It requires
+// string and numeric representation of private RR type and generator function as argument.
+func PrivateHandle(rtypestr string, rtype uint16, generator func() PrivateRdata) {
+ rtypestr = strings.ToUpper(rtypestr)
+
+ typeToRR[rtype] = func() RR { return &PrivateRR{RR_Header{}, generator()} }
+ TypeToString[rtype] = rtypestr
+ StringToType[rtypestr] = rtype
+
+ setPrivateRR := func(h RR_Header, c chan lex, o, f string) (RR, *ParseError, string) {
+ rr := mkPrivateRR(h.Rrtype)
+ rr.Hdr = h
+
+ var l lex
+ text := make([]string, 0, 2) // could be 0..N elements, median is probably 1
+ FETCH:
+ for {
+ // TODO(miek): we could also be returning _QUOTE, this might or might not
+ // be an issue (basically parsing TXT becomes hard)
+ switch l = <-c; l.value {
+ case _NEWLINE, _EOF:
+ break FETCH
+ case _STRING:
+ text = append(text, l.token)
+ }
+ }
+
+ err := rr.Data.Parse(text)
+ if err != nil {
+ return nil, &ParseError{f, err.Error(), l}, ""
+ }
+
+ return rr, nil, ""
+ }
+
+ typeToparserFunc[rtype] = parserFunc{setPrivateRR, true}
+}
+
+// PrivateHandleRemove removes defenitions required to support private RR type.
+func PrivateHandleRemove(rtype uint16) {
+ rtypestr, ok := TypeToString[rtype]
+ if ok {
+ delete(typeToRR, rtype)
+ delete(TypeToString, rtype)
+ delete(typeToparserFunc, rtype)
+ delete(StringToType, rtypestr)
+ }
+ return
+}
diff --git a/Godeps/_workspace/src/github.com/miekg/dns/privaterr_test.go b/Godeps/_workspace/src/github.com/miekg/dns/privaterr_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..6f1dff89c6aa84e2ac1c8247e51476cc2ba1a0a5
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/miekg/dns/privaterr_test.go
@@ -0,0 +1,169 @@
+package dns_test
+
+import (
+ "github.com/miekg/dns"
+ "strings"
+ "testing"
+)
+
+const TypeISBN uint16 = 0x0F01
+
+// A crazy new RR type :)
+type ISBN struct {
+ x string // rdata with 10 or 13 numbers, dashes or spaces allowed
+}
+
+func NewISBN() dns.PrivateRdata { return &ISBN{""} }
+
+func (rd *ISBN) Len() int { return len([]byte(rd.x)) }
+func (rd *ISBN) String() string { return rd.x }
+
+func (rd *ISBN) Parse(txt []string) error {
+ rd.x = strings.TrimSpace(strings.Join(txt, " "))
+ return nil
+}
+
+func (rd *ISBN) Pack(buf []byte) (int, error) {
+ b := []byte(rd.x)
+ n := copy(buf, b)
+ if n != len(b) {
+ return n, dns.ErrBuf
+ }
+ return n, nil
+}
+
+func (rd *ISBN) Unpack(buf []byte) (int, error) {
+ rd.x = string(buf)
+ return len(buf), nil
+}
+
+func (rd *ISBN) Copy(dest dns.PrivateRdata) error {
+ isbn, ok := dest.(*ISBN)
+ if !ok {
+ return dns.ErrRdata
+ }
+ isbn.x = rd.x
+ return nil
+}
+
+var testrecord = strings.Join([]string{"example.org.", "3600", "IN", "ISBN", "12-3 456789-0-123"}, "\t")
+
+func TestPrivateText(t *testing.T) {
+ dns.PrivateHandle("ISBN", TypeISBN, NewISBN)
+ defer dns.PrivateHandleRemove(TypeISBN)
+
+ rr, err := dns.NewRR(testrecord)
+ if err != nil {
+ t.Fatal(err)
+ }
+ if rr.String() != testrecord {
+ t.Errorf("record string representation did not match original %#v != %#v", rr.String(), testrecord)
+ } else {
+ t.Log(rr.String())
+ }
+}
+
+func TestPrivateByteSlice(t *testing.T) {
+ dns.PrivateHandle("ISBN", TypeISBN, NewISBN)
+ defer dns.PrivateHandleRemove(TypeISBN)
+
+ rr, err := dns.NewRR(testrecord)
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ buf := make([]byte, 100)
+ off, err := dns.PackRR(rr, buf, 0, nil, false)
+ if err != nil {
+ t.Errorf("got error packing ISBN: %s", err)
+ }
+
+ custrr := rr.(*dns.PrivateRR)
+ if ln := custrr.Data.Len() + len(custrr.Header().Name) + 11; ln != off {
+ t.Errorf("offset is not matching to length of Private RR: %d!=%d", off, ln)
+ }
+
+ rr1, off1, err := dns.UnpackRR(buf[:off], 0)
+ if err != nil {
+ t.Errorf("got error unpacking ISBN: %s", err)
+ }
+
+ if off1 != off {
+ t.Errorf("Offset after unpacking differs: %d != %d", off1, off)
+ }
+
+ if rr1.String() != testrecord {
+ t.Errorf("Record string representation did not match original %#v != %#v", rr1.String(), testrecord)
+ } else {
+ t.Log(rr1.String())
+ }
+}
+
+const TypeVERSION uint16 = 0x0F02
+
+type VERSION struct {
+ x string
+}
+
+func NewVersion() dns.PrivateRdata { return &VERSION{""} }
+
+func (rd *VERSION) String() string { return rd.x }
+func (rd *VERSION) Parse(txt []string) error {
+ rd.x = strings.TrimSpace(strings.Join(txt, " "))
+ return nil
+}
+
+func (rd *VERSION) Pack(buf []byte) (int, error) {
+ b := []byte(rd.x)
+ n := copy(buf, b)
+ if n != len(b) {
+ return n, dns.ErrBuf
+ }
+ return n, nil
+}
+
+func (rd *VERSION) Unpack(buf []byte) (int, error) {
+ rd.x = string(buf)
+ return len(buf), nil
+}
+
+func (rd *VERSION) Copy(dest dns.PrivateRdata) error {
+ isbn, ok := dest.(*VERSION)
+ if !ok {
+ return dns.ErrRdata
+ }
+ isbn.x = rd.x
+ return nil
+}
+
+func (rd *VERSION) Len() int {
+ return len([]byte(rd.x))
+}
+
+var smallzone = `$ORIGIN example.org.
+@ SOA sns.dns.icann.org. noc.dns.icann.org. (
+ 2014091518 7200 3600 1209600 3600
+)
+ A 1.2.3.4
+ok ISBN 1231-92110-12
+go VERSION (
+ 1.3.1 ; comment
+)
+www ISBN 1231-92110-16
+* CNAME @
+`
+
+func TestPrivateZoneParser(t *testing.T) {
+ dns.PrivateHandle("ISBN", TypeISBN, NewISBN)
+ dns.PrivateHandle("VERSION", TypeVERSION, NewVersion)
+ defer dns.PrivateHandleRemove(TypeISBN)
+ defer dns.PrivateHandleRemove(TypeVERSION)
+
+ r := strings.NewReader(smallzone)
+ for x := range dns.ParseZone(r, ".", "") {
+ if err := x.Error; err != nil {
+ t.Fatal(err)
+ }
+ t.Log(x.RR)
+ }
+}
diff --git a/Godeps/_workspace/src/github.com/miekg/dns/rawmsg.go b/Godeps/_workspace/src/github.com/miekg/dns/rawmsg.go
new file mode 100644
index 0000000000000000000000000000000000000000..f138b7761dfd5cfcdc3fb8911de870126f1c1b0e
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/miekg/dns/rawmsg.go
@@ -0,0 +1,95 @@
+package dns
+
+// These raw* functions do not use reflection, they directly set the values
+// in the buffer. There are faster than their reflection counterparts.
+
+// RawSetId sets the message id in buf.
+func rawSetId(msg []byte, i uint16) bool {
+ if len(msg) < 2 {
+ return false
+ }
+ msg[0], msg[1] = packUint16(i)
+ return true
+}
+
+// rawSetQuestionLen sets the length of the question section.
+func rawSetQuestionLen(msg []byte, i uint16) bool {
+ if len(msg) < 6 {
+ return false
+ }
+ msg[4], msg[5] = packUint16(i)
+ return true
+}
+
+// rawSetAnswerLen sets the lenght of the answer section.
+func rawSetAnswerLen(msg []byte, i uint16) bool {
+ if len(msg) < 8 {
+ return false
+ }
+ msg[6], msg[7] = packUint16(i)
+ return true
+}
+
+// rawSetsNsLen sets the lenght of the authority section.
+func rawSetNsLen(msg []byte, i uint16) bool {
+ if len(msg) < 10 {
+ return false
+ }
+ msg[8], msg[9] = packUint16(i)
+ return true
+}
+
+// rawSetExtraLen sets the lenght of the additional section.
+func rawSetExtraLen(msg []byte, i uint16) bool {
+ if len(msg) < 12 {
+ return false
+ }
+ msg[10], msg[11] = packUint16(i)
+ return true
+}
+
+// rawSetRdlength sets the rdlength in the header of
+// the RR. The offset 'off' must be positioned at the
+// start of the header of the RR, 'end' must be the
+// end of the RR.
+func rawSetRdlength(msg []byte, off, end int) bool {
+ l := len(msg)
+Loop:
+ for {
+ if off+1 > l {
+ return false
+ }
+ c := int(msg[off])
+ off++
+ switch c & 0xC0 {
+ case 0x00:
+ if c == 0x00 {
+ // End of the domainname
+ break Loop
+ }
+ if off+c > l {
+ return false
+ }
+ off += c
+
+ case 0xC0:
+ // pointer, next byte included, ends domainname
+ off++
+ break Loop
+ }
+ }
+ // The domainname has been seen, we at the start of the fixed part in the header.
+ // Type is 2 bytes, class is 2 bytes, ttl 4 and then 2 bytes for the length.
+ off += 2 + 2 + 4
+ if off+2 > l {
+ return false
+ }
+ //off+1 is the end of the header, 'end' is the end of the rr
+ //so 'end' - 'off+2' is the length of the rdata
+ rdatalen := end - (off + 2)
+ if rdatalen > 0xFFFF {
+ return false
+ }
+ msg[off], msg[off+1] = packUint16(uint16(rdatalen))
+ return true
+}
diff --git a/Godeps/_workspace/src/github.com/miekg/dns/scanner.go b/Godeps/_workspace/src/github.com/miekg/dns/scanner.go
new file mode 100644
index 0000000000000000000000000000000000000000..c29bc2f388e84c292ceb3ec58431c4f03abf3b6b
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/miekg/dns/scanner.go
@@ -0,0 +1,43 @@
+package dns
+
+// Implement a simple scanner, return a byte stream from an io reader.
+
+import (
+ "bufio"
+ "io"
+ "text/scanner"
+)
+
+type scan struct {
+ src *bufio.Reader
+ position scanner.Position
+ eof bool // Have we just seen a eof
+}
+
+func scanInit(r io.Reader) *scan {
+ s := new(scan)
+ s.src = bufio.NewReader(r)
+ s.position.Line = 1
+ return s
+}
+
+// tokenText returns the next byte from the input
+func (s *scan) tokenText() (byte, error) {
+ c, err := s.src.ReadByte()
+ if err != nil {
+ return c, err
+ }
+ // delay the newline handling until the next token is delivered,
+ // fixes off-by-one errors when reporting a parse error.
+ if s.eof == true {
+ s.position.Line++
+ s.position.Column = 0
+ s.eof = false
+ }
+ if c == '\n' {
+ s.eof = true
+ return c, nil
+ }
+ s.position.Column++
+ return c, nil
+}
diff --git a/Godeps/_workspace/src/github.com/miekg/dns/server.go b/Godeps/_workspace/src/github.com/miekg/dns/server.go
new file mode 100644
index 0000000000000000000000000000000000000000..c250ccc26a16439a352f4c06d002da5b2e039454
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/miekg/dns/server.go
@@ -0,0 +1,626 @@
+// DNS server implementation.
+
+package dns
+
+import (
+ "bytes"
+ "io"
+ "net"
+ "sync"
+ "time"
+)
+
+type Handler interface {
+ ServeDNS(w ResponseWriter, r *Msg)
+}
+
+// A ResponseWriter interface is used by an DNS handler to
+// construct an DNS response.
+type ResponseWriter interface {
+ // LocalAddr returns the net.Addr of the server
+ LocalAddr() net.Addr
+ // RemoteAddr returns the net.Addr of the client that sent the current request.
+ RemoteAddr() net.Addr
+ // WriteMsg writes a reply back to the client.
+ WriteMsg(*Msg) error
+ // Write writes a raw buffer back to the client.
+ Write([]byte) (int, error)
+ // Close closes the connection.
+ Close() error
+ // TsigStatus returns the status of the Tsig.
+ TsigStatus() error
+ // TsigTimersOnly sets the tsig timers only boolean.
+ TsigTimersOnly(bool)
+ // Hijack lets the caller take over the connection.
+ // After a call to Hijack(), the DNS package will not do anything with the connection.
+ Hijack()
+}
+
+type response struct {
+ hijacked bool // connection has been hijacked by handler
+ tsigStatus error
+ tsigTimersOnly bool
+ tsigRequestMAC string
+ tsigSecret map[string]string // the tsig secrets
+ udp *net.UDPConn // i/o connection if UDP was used
+ tcp *net.TCPConn // i/o connection if TCP was used
+ udpSession *sessionUDP // oob data to get egress interface right
+ remoteAddr net.Addr // address of the client
+}
+
+// ServeMux is an DNS request multiplexer. It matches the
+// zone name of each incoming request against a list of
+// registered patterns add calls the handler for the pattern
+// that most closely matches the zone name. ServeMux is DNSSEC aware, meaning
+// that queries for the DS record are redirected to the parent zone (if that
+// is also registered), otherwise the child gets the query.
+// ServeMux is also safe for concurrent access from multiple goroutines.
+type ServeMux struct {
+ z map[string]Handler
+ m *sync.RWMutex
+}
+
+// NewServeMux allocates and returns a new ServeMux.
+func NewServeMux() *ServeMux { return &ServeMux{z: make(map[string]Handler), m: new(sync.RWMutex)} }
+
+// DefaultServeMux is the default ServeMux used by Serve.
+var DefaultServeMux = NewServeMux()
+
+// The HandlerFunc type is an adapter to allow the use of
+// ordinary functions as DNS handlers. If f is a function
+// with the appropriate signature, HandlerFunc(f) is a
+// Handler object that calls f.
+type HandlerFunc func(ResponseWriter, *Msg)
+
+// ServerDNS calls f(w, r)
+func (f HandlerFunc) ServeDNS(w ResponseWriter, r *Msg) {
+ f(w, r)
+}
+
+// FailedHandler returns a HandlerFunc that returns SERVFAIL for every request it gets.
+func HandleFailed(w ResponseWriter, r *Msg) {
+ m := new(Msg)
+ m.SetRcode(r, RcodeServerFailure)
+ // does not matter if this write fails
+ w.WriteMsg(m)
+}
+
+func failedHandler() Handler { return HandlerFunc(HandleFailed) }
+
+// ListenAndServe Starts a server on addresss and network speficied. Invoke handler
+// for incoming queries.
+func ListenAndServe(addr string, network string, handler Handler) error {
+ server := &Server{Addr: addr, Net: network, Handler: handler}
+ return server.ListenAndServe()
+}
+
+// ActivateAndServe activates a server with a listener from systemd,
+// l and p should not both be non-nil.
+// If both l and p are not nil only p will be used.
+// Invoke handler for incoming queries.
+func ActivateAndServe(l net.Listener, p net.PacketConn, handler Handler) error {
+ server := &Server{Listener: l, PacketConn: p, Handler: handler}
+ return server.ActivateAndServe()
+}
+
+func (mux *ServeMux) match(q string, t uint16) Handler {
+ mux.m.RLock()
+ defer mux.m.RUnlock()
+ var handler Handler
+ b := make([]byte, len(q)) // worst case, one label of length q
+ off := 0
+ end := false
+ for {
+ l := len(q[off:])
+ for i := 0; i < l; i++ {
+ b[i] = q[off+i]
+ if b[i] >= 'A' && b[i] <= 'Z' {
+ b[i] |= ('a' - 'A')
+ }
+ }
+ if h, ok := mux.z[string(b[:l])]; ok { // 'causes garbage, might want to change the map key
+ if t != TypeDS {
+ return h
+ } else {
+ // Continue for DS to see if we have a parent too, if so delegeate to the parent
+ handler = h
+ }
+ }
+ off, end = NextLabel(q, off)
+ if end {
+ break
+ }
+ }
+ // Wildcard match, if we have found nothing try the root zone as a last resort.
+ if h, ok := mux.z["."]; ok {
+ return h
+ }
+ return handler
+}
+
+// Handle adds a handler to the ServeMux for pattern.
+func (mux *ServeMux) Handle(pattern string, handler Handler) {
+ if pattern == "" {
+ panic("dns: invalid pattern " + pattern)
+ }
+ mux.m.Lock()
+ mux.z[Fqdn(pattern)] = handler
+ mux.m.Unlock()
+}
+
+// Handle adds a handler to the ServeMux for pattern.
+func (mux *ServeMux) HandleFunc(pattern string, handler func(ResponseWriter, *Msg)) {
+ mux.Handle(pattern, HandlerFunc(handler))
+}
+
+// HandleRemove deregistrars the handler specific for pattern from the ServeMux.
+func (mux *ServeMux) HandleRemove(pattern string) {
+ if pattern == "" {
+ panic("dns: invalid pattern " + pattern)
+ }
+ // don't need a mutex here, because deleting is OK, even if the
+ // entry is note there.
+ delete(mux.z, Fqdn(pattern))
+}
+
+// ServeDNS dispatches the request to the handler whose
+// pattern most closely matches the request message. If DefaultServeMux
+// is used the correct thing for DS queries is done: a possible parent
+// is sought.
+// If no handler is found a standard SERVFAIL message is returned
+// If the request message does not have exactly one question in the
+// question section a SERVFAIL is returned, unlesss Unsafe is true.
+func (mux *ServeMux) ServeDNS(w ResponseWriter, request *Msg) {
+ var h Handler
+ if len(request.Question) < 1 { // allow more than one question
+ h = failedHandler()
+ } else {
+ if h = mux.match(request.Question[0].Name, request.Question[0].Qtype); h == nil {
+ h = failedHandler()
+ }
+ }
+ h.ServeDNS(w, request)
+}
+
+// Handle registers the handler with the given pattern
+// in the DefaultServeMux. The documentation for
+// ServeMux explains how patterns are matched.
+func Handle(pattern string, handler Handler) { DefaultServeMux.Handle(pattern, handler) }
+
+// HandleRemove deregisters the handle with the given pattern
+// in the DefaultServeMux.
+func HandleRemove(pattern string) { DefaultServeMux.HandleRemove(pattern) }
+
+// HandleFunc registers the handler function with the given pattern
+// in the DefaultServeMux.
+func HandleFunc(pattern string, handler func(ResponseWriter, *Msg)) {
+ DefaultServeMux.HandleFunc(pattern, handler)
+}
+
+// A Server defines parameters for running an DNS server.
+type Server struct {
+ // Address to listen on, ":dns" if empty.
+ Addr string
+ // if "tcp" it will invoke a TCP listener, otherwise an UDP one.
+ Net string
+ // TCP Listener to use, this is to aid in systemd's socket activation.
+ Listener net.Listener
+ // UDP "Listener" to use, this is to aid in systemd's socket activation.
+ PacketConn net.PacketConn
+ // Handler to invoke, dns.DefaultServeMux if nil.
+ Handler Handler
+ // Default buffer size to use to read incoming UDP messages. If not set
+ // it defaults to MinMsgSize (512 B).
+ UDPSize int
+ // The net.Conn.SetReadTimeout value for new connections, defaults to 2 * time.Second.
+ ReadTimeout time.Duration
+ // The net.Conn.SetWriteTimeout value for new connections, defaults to 2 * time.Second.
+ WriteTimeout time.Duration
+ // TCP idle timeout for multiple queries, if nil, defaults to 8 * time.Second (RFC 5966).
+ IdleTimeout func() time.Duration
+ // Secret(s) for Tsig map[<zonename>]<base64 secret>.
+ TsigSecret map[string]string
+ // Unsafe instructs the server to disregard any sanity checks and directly hand the message to
+ // the handler. It will specfically not check if the query has the QR bit not set.
+ Unsafe bool
+ // If NotifyStartedFunc is set is is called, once the server has started listening.
+ NotifyStartedFunc func()
+
+ // For graceful shutdown.
+ stopUDP chan bool
+ stopTCP chan bool
+ wgUDP sync.WaitGroup
+ wgTCP sync.WaitGroup
+
+ // make start/shutdown not racy
+ lock sync.Mutex
+ started bool
+}
+
+// ListenAndServe starts a nameserver on the configured address in *Server.
+func (srv *Server) ListenAndServe() error {
+ srv.lock.Lock()
+ if srv.started {
+ return &Error{err: "server already started"}
+ }
+ srv.stopUDP, srv.stopTCP = make(chan bool), make(chan bool)
+ srv.started = true
+ srv.lock.Unlock()
+ addr := srv.Addr
+ if addr == "" {
+ addr = ":domain"
+ }
+ if srv.UDPSize == 0 {
+ srv.UDPSize = MinMsgSize
+ }
+ switch srv.Net {
+ case "tcp", "tcp4", "tcp6":
+ a, e := net.ResolveTCPAddr(srv.Net, addr)
+ if e != nil {
+ return e
+ }
+ l, e := net.ListenTCP(srv.Net, a)
+ if e != nil {
+ return e
+ }
+ return srv.serveTCP(l)
+ case "udp", "udp4", "udp6":
+ a, e := net.ResolveUDPAddr(srv.Net, addr)
+ if e != nil {
+ return e
+ }
+ l, e := net.ListenUDP(srv.Net, a)
+ if e != nil {
+ return e
+ }
+ if e := setUDPSocketOptions(l); e != nil {
+ return e
+ }
+ return srv.serveUDP(l)
+ }
+ return &Error{err: "bad network"}
+}
+
+// ActivateAndServe starts a nameserver with the PacketConn or Listener
+// configured in *Server. Its main use is to start a server from systemd.
+func (srv *Server) ActivateAndServe() error {
+ srv.lock.Lock()
+ if srv.started {
+ return &Error{err: "server already started"}
+ }
+ srv.stopUDP, srv.stopTCP = make(chan bool), make(chan bool)
+ srv.started = true
+ srv.lock.Unlock()
+ if srv.PacketConn != nil {
+ if srv.UDPSize == 0 {
+ srv.UDPSize = MinMsgSize
+ }
+ if t, ok := srv.PacketConn.(*net.UDPConn); ok {
+ if e := setUDPSocketOptions(t); e != nil {
+ return e
+ }
+ return srv.serveUDP(t)
+ }
+ }
+ if srv.Listener != nil {
+ if t, ok := srv.Listener.(*net.TCPListener); ok {
+ return srv.serveTCP(t)
+ }
+ }
+ return &Error{err: "bad listeners"}
+}
+
+// Shutdown gracefully shuts down a server. After a call to Shutdown, ListenAndServe and
+// ActivateAndServe will return. All in progress queries are completed before the server
+// is taken down. If the Shutdown is taking longer than the reading timeout and error
+// is returned.
+func (srv *Server) Shutdown() error {
+ srv.lock.Lock()
+ if !srv.started {
+ return &Error{err: "server not started"}
+ }
+ srv.started = false
+ srv.lock.Unlock()
+ net, addr := srv.Net, srv.Addr
+ switch {
+ case srv.Listener != nil:
+ a := srv.Listener.Addr()
+ net, addr = a.Network(), a.String()
+ case srv.PacketConn != nil:
+ a := srv.PacketConn.LocalAddr()
+ net, addr = a.Network(), a.String()
+ }
+
+ fin := make(chan bool)
+ switch net {
+ case "tcp", "tcp4", "tcp6":
+ go func() {
+ srv.stopTCP <- true
+ srv.wgTCP.Wait()
+ fin <- true
+ }()
+
+ case "udp", "udp4", "udp6":
+ go func() {
+ srv.stopUDP <- true
+ srv.wgUDP.Wait()
+ fin <- true
+ }()
+ }
+
+ c := &Client{Net: net}
+ go c.Exchange(new(Msg), addr) // extra query to help ReadXXX loop to pass
+
+ select {
+ case <-time.After(srv.getReadTimeout()):
+ return &Error{err: "server shutdown is pending"}
+ case <-fin:
+ return nil
+ }
+}
+
+// getReadTimeout is a helper func to use system timeout if server did not intend to change it.
+func (srv *Server) getReadTimeout() time.Duration {
+ rtimeout := dnsTimeout
+ if srv.ReadTimeout != 0 {
+ rtimeout = srv.ReadTimeout
+ }
+ return rtimeout
+}
+
+// serveTCP starts a TCP listener for the server.
+// Each request is handled in a seperate goroutine.
+func (srv *Server) serveTCP(l *net.TCPListener) error {
+ defer l.Close()
+
+ if srv.NotifyStartedFunc != nil {
+ srv.NotifyStartedFunc()
+ }
+
+ handler := srv.Handler
+ if handler == nil {
+ handler = DefaultServeMux
+ }
+ rtimeout := srv.getReadTimeout()
+ // deadline is not used here
+ for {
+ rw, e := l.AcceptTCP()
+ if e != nil {
+ continue
+ }
+ m, e := srv.readTCP(rw, rtimeout)
+ select {
+ case <-srv.stopTCP:
+ return nil
+ default:
+ }
+ if e != nil {
+ continue
+ }
+ srv.wgTCP.Add(1)
+ go srv.serve(rw.RemoteAddr(), handler, m, nil, nil, rw)
+ }
+ panic("dns: not reached")
+}
+
+// serveUDP starts a UDP listener for the server.
+// Each request is handled in a seperate goroutine.
+func (srv *Server) serveUDP(l *net.UDPConn) error {
+ defer l.Close()
+
+ if srv.NotifyStartedFunc != nil {
+ srv.NotifyStartedFunc()
+ }
+
+ handler := srv.Handler
+ if handler == nil {
+ handler = DefaultServeMux
+ }
+ rtimeout := srv.getReadTimeout()
+ // deadline is not used here
+ for {
+ m, s, e := srv.readUDP(l, rtimeout)
+ select {
+ case <-srv.stopUDP:
+ return nil
+ default:
+ }
+ if e != nil {
+ continue
+ }
+ srv.wgUDP.Add(1)
+ go srv.serve(s.RemoteAddr(), handler, m, l, s, nil)
+ }
+ panic("dns: not reached")
+}
+
+// Serve a new connection.
+func (srv *Server) serve(a net.Addr, h Handler, m []byte, u *net.UDPConn, s *sessionUDP, t *net.TCPConn) {
+ w := &response{tsigSecret: srv.TsigSecret, udp: u, tcp: t, remoteAddr: a, udpSession: s}
+ q := 0
+ defer func() {
+ if u != nil {
+ srv.wgUDP.Done()
+ }
+ if t != nil {
+ srv.wgTCP.Done()
+ }
+ }()
+Redo:
+ // Ideally we want use isMsg here before we allocate memory to actually parse the packet.
+ req := new(Msg)
+ err := req.Unpack(m)
+ if err != nil { // Send a FormatError back
+ x := new(Msg)
+ x.SetRcodeFormatError(req)
+ w.WriteMsg(x)
+ goto Exit
+ }
+ if !srv.Unsafe && req.Response {
+ goto Exit
+ }
+
+ w.tsigStatus = nil
+ if w.tsigSecret != nil {
+ if t := req.IsTsig(); t != nil {
+ secret := t.Hdr.Name
+ if _, ok := w.tsigSecret[secret]; !ok {
+ w.tsigStatus = ErrKeyAlg
+ }
+ w.tsigStatus = TsigVerify(m, w.tsigSecret[secret], "", false)
+ w.tsigTimersOnly = false
+ w.tsigRequestMAC = req.Extra[len(req.Extra)-1].(*TSIG).MAC
+ }
+ }
+ h.ServeDNS(w, req) // Writes back to the client
+
+Exit:
+ if w.hijacked {
+ return // client calls Close()
+ }
+ if u != nil { // UDP, "close" and return
+ w.Close()
+ return
+ }
+ idleTimeout := tcpIdleTimeout
+ if srv.IdleTimeout != nil {
+ idleTimeout = srv.IdleTimeout()
+ }
+ m, e := srv.readTCP(w.tcp, idleTimeout)
+ if e == nil {
+ q++
+ // TODO(miek): make this number configurable?
+ if q > 128 { // close socket after this many queries
+ w.Close()
+ return
+ }
+ goto Redo
+ }
+ w.Close()
+ return
+}
+
+func (srv *Server) readTCP(conn *net.TCPConn, timeout time.Duration) ([]byte, error) {
+ conn.SetReadDeadline(time.Now().Add(timeout))
+ l := make([]byte, 2)
+ n, err := conn.Read(l)
+ if err != nil || n != 2 {
+ if err != nil {
+ return nil, err
+ }
+ return nil, ErrShortRead
+ }
+ length, _ := unpackUint16(l, 0)
+ if length == 0 {
+ return nil, ErrShortRead
+ }
+ m := make([]byte, int(length))
+ n, err = conn.Read(m[:int(length)])
+ if err != nil || n == 0 {
+ if err != nil {
+ return nil, err
+ }
+ return nil, ErrShortRead
+ }
+ i := n
+ for i < int(length) {
+ j, err := conn.Read(m[i:int(length)])
+ if err != nil {
+ return nil, err
+ }
+ i += j
+ }
+ n = i
+ m = m[:n]
+ return m, nil
+}
+
+func (srv *Server) readUDP(conn *net.UDPConn, timeout time.Duration) ([]byte, *sessionUDP, error) {
+ conn.SetReadDeadline(time.Now().Add(timeout))
+ m := make([]byte, srv.UDPSize)
+ n, s, e := readFromSessionUDP(conn, m)
+ if e != nil || n == 0 {
+ if e != nil {
+ return nil, nil, e
+ }
+ return nil, nil, ErrShortRead
+ }
+ m = m[:n]
+ return m, s, nil
+}
+
+// WriteMsg implements the ResponseWriter.WriteMsg method.
+func (w *response) WriteMsg(m *Msg) (err error) {
+ var data []byte
+ if w.tsigSecret != nil { // if no secrets, dont check for the tsig (which is a longer check)
+ if t := m.IsTsig(); t != nil {
+ data, w.tsigRequestMAC, err = TsigGenerate(m, w.tsigSecret[t.Hdr.Name], w.tsigRequestMAC, w.tsigTimersOnly)
+ if err != nil {
+ return err
+ }
+ _, err = w.Write(data)
+ return err
+ }
+ }
+ data, err = m.Pack()
+ if err != nil {
+ return err
+ }
+ _, err = w.Write(data)
+ return err
+}
+
+// Write implements the ResponseWriter.Write method.
+func (w *response) Write(m []byte) (int, error) {
+ switch {
+ case w.udp != nil:
+ n, err := writeToSessionUDP(w.udp, m, w.udpSession)
+ return n, err
+ case w.tcp != nil:
+ lm := len(m)
+ if lm < 2 {
+ return 0, io.ErrShortBuffer
+ }
+ if lm > MaxMsgSize {
+ return 0, &Error{err: "message too large"}
+ }
+ l := make([]byte, 2, 2+lm)
+ l[0], l[1] = packUint16(uint16(lm))
+ m = append(l, m...)
+
+ n, err := io.Copy(w.tcp, bytes.NewReader(m))
+ return int(n), err
+ }
+ panic("not reached")
+}
+
+// LocalAddr implements the ResponseWriter.LocalAddr method.
+func (w *response) LocalAddr() net.Addr {
+ if w.tcp != nil {
+ return w.tcp.LocalAddr()
+ }
+ return w.udp.LocalAddr()
+}
+
+// RemoteAddr implements the ResponseWriter.RemoteAddr method.
+func (w *response) RemoteAddr() net.Addr { return w.remoteAddr }
+
+// TsigStatus implements the ResponseWriter.TsigStatus method.
+func (w *response) TsigStatus() error { return w.tsigStatus }
+
+// TsigTimersOnly implements the ResponseWriter.TsigTimersOnly method.
+func (w *response) TsigTimersOnly(b bool) { w.tsigTimersOnly = b }
+
+// Hijack implements the ResponseWriter.Hijack method.
+func (w *response) Hijack() { w.hijacked = true }
+
+// Close implements the ResponseWriter.Close method
+func (w *response) Close() error {
+ // Can't close the udp conn, as that is actually the listener.
+ if w.tcp != nil {
+ e := w.tcp.Close()
+ w.tcp = nil
+ return e
+ }
+ return nil
+}
diff --git a/Godeps/_workspace/src/github.com/miekg/dns/server_test.go b/Godeps/_workspace/src/github.com/miekg/dns/server_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..5efb1cf89734bd66ec490233a8b34c58c0660725
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/miekg/dns/server_test.go
@@ -0,0 +1,401 @@
+package dns
+
+import (
+ "fmt"
+ "net"
+ "runtime"
+ "sync"
+ "testing"
+)
+
+func HelloServer(w ResponseWriter, req *Msg) {
+ m := new(Msg)
+ m.SetReply(req)
+
+ m.Extra = make([]RR, 1)
+ m.Extra[0] = &TXT{Hdr: RR_Header{Name: m.Question[0].Name, Rrtype: TypeTXT, Class: ClassINET, Ttl: 0}, Txt: []string{"Hello world"}}
+ w.WriteMsg(m)
+}
+
+func AnotherHelloServer(w ResponseWriter, req *Msg) {
+ m := new(Msg)
+ m.SetReply(req)
+
+ m.Extra = make([]RR, 1)
+ m.Extra[0] = &TXT{Hdr: RR_Header{Name: m.Question[0].Name, Rrtype: TypeTXT, Class: ClassINET, Ttl: 0}, Txt: []string{"Hello example"}}
+ w.WriteMsg(m)
+}
+
+func RunLocalUDPServer(laddr string) (*Server, string, error) {
+ pc, err := net.ListenPacket("udp", laddr)
+ if err != nil {
+ return nil, "", err
+ }
+ server := &Server{PacketConn: pc}
+
+ waitLock := sync.Mutex{}
+ waitLock.Lock()
+ server.NotifyStartedFunc = waitLock.Unlock
+
+ go func() {
+ server.ActivateAndServe()
+ pc.Close()
+ }()
+
+ waitLock.Lock()
+ return server, pc.LocalAddr().String(), nil
+}
+
+func RunLocalUDPServerUnsafe(laddr string) (*Server, string, error) {
+ pc, err := net.ListenPacket("udp", laddr)
+ if err != nil {
+ return nil, "", err
+ }
+ server := &Server{PacketConn: pc, Unsafe: true}
+
+ waitLock := sync.Mutex{}
+ waitLock.Lock()
+ server.NotifyStartedFunc = waitLock.Unlock
+
+ go func() {
+ server.ActivateAndServe()
+ pc.Close()
+ }()
+
+ waitLock.Lock()
+ return server, pc.LocalAddr().String(), nil
+}
+
+func RunLocalTCPServer(laddr string) (*Server, string, error) {
+ l, err := net.Listen("tcp", laddr)
+ if err != nil {
+ return nil, "", err
+ }
+
+ server := &Server{Listener: l}
+
+ waitLock := sync.Mutex{}
+ waitLock.Lock()
+ server.NotifyStartedFunc = waitLock.Unlock
+
+ go func() {
+ server.ActivateAndServe()
+ l.Close()
+ }()
+
+ waitLock.Lock()
+ return server, l.Addr().String(), nil
+}
+
+func TestServing(t *testing.T) {
+ HandleFunc("miek.nl.", HelloServer)
+ HandleFunc("example.com.", AnotherHelloServer)
+ defer HandleRemove("miek.nl.")
+ defer HandleRemove("example.com.")
+
+ s, addrstr, err := RunLocalUDPServer("127.0.0.1:0")
+ if err != nil {
+ t.Fatalf("Unable to run test server: %s", err)
+ }
+ defer s.Shutdown()
+
+ c := new(Client)
+ m := new(Msg)
+ m.SetQuestion("miek.nl.", TypeTXT)
+ r, _, err := c.Exchange(m, addrstr)
+ if err != nil || len(r.Extra) == 0 {
+ t.Log("failed to exchange miek.nl", err)
+ t.Fatal()
+ }
+ txt := r.Extra[0].(*TXT).Txt[0]
+ if txt != "Hello world" {
+ t.Log("Unexpected result for miek.nl", txt, "!= Hello world")
+ t.Fail()
+ }
+
+ m.SetQuestion("example.com.", TypeTXT)
+ r, _, err = c.Exchange(m, addrstr)
+ if err != nil {
+ t.Log("failed to exchange example.com", err)
+ t.Fatal()
+ }
+ txt = r.Extra[0].(*TXT).Txt[0]
+ if txt != "Hello example" {
+ t.Log("Unexpected result for example.com", txt, "!= Hello example")
+ t.Fail()
+ }
+
+ // Test Mixes cased as noticed by Ask.
+ m.SetQuestion("eXaMplE.cOm.", TypeTXT)
+ r, _, err = c.Exchange(m, addrstr)
+ if err != nil {
+ t.Log("failed to exchange eXaMplE.cOm", err)
+ t.Fail()
+ }
+ txt = r.Extra[0].(*TXT).Txt[0]
+ if txt != "Hello example" {
+ t.Log("Unexpected result for example.com", txt, "!= Hello example")
+ t.Fail()
+ }
+}
+
+func BenchmarkServe(b *testing.B) {
+ b.StopTimer()
+ HandleFunc("miek.nl.", HelloServer)
+ defer HandleRemove("miek.nl.")
+ a := runtime.GOMAXPROCS(4)
+
+ s, addrstr, err := RunLocalUDPServer("127.0.0.1:0")
+ if err != nil {
+ b.Fatalf("Unable to run test server: %s", err)
+ }
+ defer s.Shutdown()
+
+ c := new(Client)
+ m := new(Msg)
+ m.SetQuestion("miek.nl", TypeSOA)
+
+ b.StartTimer()
+ for i := 0; i < b.N; i++ {
+ c.Exchange(m, addrstr)
+ }
+ runtime.GOMAXPROCS(a)
+}
+
+func benchmarkServe6(b *testing.B) {
+ b.StopTimer()
+ HandleFunc("miek.nl.", HelloServer)
+ defer HandleRemove("miek.nl.")
+ a := runtime.GOMAXPROCS(4)
+ s, addrstr, err := RunLocalUDPServer("[::1]:0")
+ if err != nil {
+ b.Fatalf("Unable to run test server: %s", err)
+ }
+ defer s.Shutdown()
+
+ c := new(Client)
+ m := new(Msg)
+ m.SetQuestion("miek.nl", TypeSOA)
+
+ b.StartTimer()
+ for i := 0; i < b.N; i++ {
+ c.Exchange(m, addrstr)
+ }
+ runtime.GOMAXPROCS(a)
+}
+
+func HelloServerCompress(w ResponseWriter, req *Msg) {
+ m := new(Msg)
+ m.SetReply(req)
+ m.Extra = make([]RR, 1)
+ m.Extra[0] = &TXT{Hdr: RR_Header{Name: m.Question[0].Name, Rrtype: TypeTXT, Class: ClassINET, Ttl: 0}, Txt: []string{"Hello world"}}
+ m.Compress = true
+ w.WriteMsg(m)
+}
+
+func BenchmarkServeCompress(b *testing.B) {
+ b.StopTimer()
+ HandleFunc("miek.nl.", HelloServerCompress)
+ defer HandleRemove("miek.nl.")
+ a := runtime.GOMAXPROCS(4)
+ s, addrstr, err := RunLocalUDPServer("127.0.0.1:0")
+ if err != nil {
+ b.Fatalf("Unable to run test server: %s", err)
+ }
+ defer s.Shutdown()
+
+ c := new(Client)
+ m := new(Msg)
+ m.SetQuestion("miek.nl", TypeSOA)
+ b.StartTimer()
+ for i := 0; i < b.N; i++ {
+ c.Exchange(m, addrstr)
+ }
+ runtime.GOMAXPROCS(a)
+}
+
+func TestDotAsCatchAllWildcard(t *testing.T) {
+ mux := NewServeMux()
+ mux.Handle(".", HandlerFunc(HelloServer))
+ mux.Handle("example.com.", HandlerFunc(AnotherHelloServer))
+
+ handler := mux.match("www.miek.nl.", TypeTXT)
+ if handler == nil {
+ t.Error("wildcard match failed")
+ }
+
+ handler = mux.match("www.example.com.", TypeTXT)
+ if handler == nil {
+ t.Error("example.com match failed")
+ }
+
+ handler = mux.match("a.www.example.com.", TypeTXT)
+ if handler == nil {
+ t.Error("a.www.example.com match failed")
+ }
+
+ handler = mux.match("boe.", TypeTXT)
+ if handler == nil {
+ t.Error("boe. match failed")
+ }
+}
+
+func TestCaseFolding(t *testing.T) {
+ mux := NewServeMux()
+ mux.Handle("_udp.example.com.", HandlerFunc(HelloServer))
+
+ handler := mux.match("_dns._udp.example.com.", TypeSRV)
+ if handler == nil {
+ t.Error("case sensitive characters folded")
+ }
+
+ handler = mux.match("_DNS._UDP.EXAMPLE.COM.", TypeSRV)
+ if handler == nil {
+ t.Error("case insensitive characters not folded")
+ }
+}
+
+func TestRootServer(t *testing.T) {
+ mux := NewServeMux()
+ mux.Handle(".", HandlerFunc(HelloServer))
+
+ handler := mux.match(".", TypeNS)
+ if handler == nil {
+ t.Error("root match failed")
+ }
+}
+
+type maxRec struct {
+ max int
+ sync.RWMutex
+}
+
+var M = new(maxRec)
+
+func HelloServerLargeResponse(resp ResponseWriter, req *Msg) {
+ m := new(Msg)
+ m.SetReply(req)
+ m.Authoritative = true
+ m1 := 0
+ M.RLock()
+ m1 = M.max
+ M.RUnlock()
+ for i := 0; i < m1; i++ {
+ aRec := &A{
+ Hdr: RR_Header{
+ Name: req.Question[0].Name,
+ Rrtype: TypeA,
+ Class: ClassINET,
+ Ttl: 0,
+ },
+ A: net.ParseIP(fmt.Sprintf("127.0.0.%d", i+1)).To4(),
+ }
+ m.Answer = append(m.Answer, aRec)
+ }
+ resp.WriteMsg(m)
+}
+
+func TestServingLargeResponses(t *testing.T) {
+ HandleFunc("example.", HelloServerLargeResponse)
+ defer HandleRemove("example.")
+
+ s, addrstr, err := RunLocalUDPServer("127.0.0.1:0")
+ if err != nil {
+ t.Fatalf("Unable to run test server: %s", err)
+ }
+ defer s.Shutdown()
+
+ // Create request
+ m := new(Msg)
+ m.SetQuestion("web.service.example.", TypeANY)
+
+ c := new(Client)
+ c.Net = "udp"
+ M.Lock()
+ M.max = 2
+ M.Unlock()
+ _, _, err = c.Exchange(m, addrstr)
+ if err != nil {
+ t.Logf("failed to exchange: %s", err.Error())
+ t.Fail()
+ }
+ // This must fail
+ M.Lock()
+ M.max = 20
+ M.Unlock()
+ _, _, err = c.Exchange(m, addrstr)
+ if err == nil {
+ t.Logf("failed to fail exchange, this should generate packet error")
+ t.Fail()
+ }
+ // But this must work again
+ c.UDPSize = 7000
+ _, _, err = c.Exchange(m, addrstr)
+ if err != nil {
+ t.Logf("failed to exchange: %s", err.Error())
+ t.Fail()
+ }
+}
+
+func TestServingResponse(t *testing.T) {
+ if testing.Short() {
+ t.Skip("skipping test in short mode.")
+ }
+ HandleFunc("miek.nl.", HelloServer)
+ s, addrstr, err := RunLocalUDPServer("127.0.0.1:0")
+ if err != nil {
+ t.Fatalf("Unable to run test server: %s", err)
+ }
+
+ c := new(Client)
+ m := new(Msg)
+ m.SetQuestion("miek.nl.", TypeTXT)
+ m.Response = false
+ _, _, err = c.Exchange(m, addrstr)
+ if err != nil {
+ t.Log("failed to exchange", err)
+ t.Fatal()
+ }
+ m.Response = true
+ _, _, err = c.Exchange(m, addrstr)
+ if err == nil {
+ t.Log("exchanged response message")
+ t.Fatal()
+ }
+
+ s.Shutdown()
+ s, addrstr, err = RunLocalUDPServerUnsafe("127.0.0.1:0")
+ if err != nil {
+ t.Fatalf("Unable to run test server: %s", err)
+ }
+ defer s.Shutdown()
+
+ m.Response = true
+ _, _, err = c.Exchange(m, addrstr)
+ if err != nil {
+ t.Log("could exchanged response message in Unsafe mode")
+ t.Fatal()
+ }
+}
+
+func TestShutdownTCP(t *testing.T) {
+ s, _, err := RunLocalTCPServer("127.0.0.1:0")
+ if err != nil {
+ t.Fatalf("Unable to run test server: %s", err)
+ }
+ err = s.Shutdown()
+ if err != nil {
+ t.Errorf("Could not shutdown test TCP server, %s", err)
+ }
+}
+
+func TestShutdownUDP(t *testing.T) {
+ s, _, err := RunLocalUDPServer("127.0.0.1:0")
+ if err != nil {
+ t.Fatalf("Unable to run test server: %s", err)
+ }
+ err = s.Shutdown()
+ if err != nil {
+ t.Errorf("Could not shutdown test UDP server, %s", err)
+ }
+}
diff --git a/Godeps/_workspace/src/github.com/miekg/dns/sig0.go b/Godeps/_workspace/src/github.com/miekg/dns/sig0.go
new file mode 100644
index 0000000000000000000000000000000000000000..d96b31be06b4508f3f115cf819f522a1264fd6df
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/miekg/dns/sig0.go
@@ -0,0 +1,262 @@
+// SIG(0)
+//
+// From RFC 2931:
+//
+// SIG(0) provides protection for DNS transactions and requests ....
+// ... protection for glue records, DNS requests, protection for message headers
+// on requests and responses, and protection of the overall integrity of a response.
+//
+// It works like TSIG, except that SIG(0) uses public key cryptography, instead of the shared
+// secret approach in TSIG.
+// Supported algorithms: DSA, ECDSAP256SHA256, ECDSAP384SHA384, RSASHA1, RSASHA256 and
+// RSASHA512.
+//
+// Signing subsequent messages in multi-message sessions is not implemented.
+//
+package dns
+
+import (
+ "crypto"
+ "crypto/dsa"
+ "crypto/ecdsa"
+ "crypto/rand"
+ "crypto/rsa"
+ "math/big"
+ "strings"
+ "time"
+)
+
+// Sign signs a dns.Msg. It fills the signature with the appropriate data.
+// The SIG record should have the SignerName, KeyTag, Algorithm, Inception
+// and Expiration set.
+func (rr *SIG) Sign(k PrivateKey, m *Msg) ([]byte, error) {
+ if k == nil {
+ return nil, ErrPrivKey
+ }
+ if rr.KeyTag == 0 || len(rr.SignerName) == 0 || rr.Algorithm == 0 {
+ return nil, ErrKey
+ }
+ rr.Header().Rrtype = TypeSIG
+ rr.Header().Class = ClassANY
+ rr.Header().Ttl = 0
+ rr.Header().Name = "."
+ rr.OrigTtl = 0
+ rr.TypeCovered = 0
+ rr.Labels = 0
+
+ buf := make([]byte, m.Len()+rr.len())
+ mbuf, err := m.PackBuffer(buf)
+ if err != nil {
+ return nil, err
+ }
+ if &buf[0] != &mbuf[0] {
+ return nil, ErrBuf
+ }
+ off, err := PackRR(rr, buf, len(mbuf), nil, false)
+ if err != nil {
+ return nil, err
+ }
+ buf = buf[:off:cap(buf)]
+ var hash crypto.Hash
+ var intlen int
+ switch rr.Algorithm {
+ case DSA, RSASHA1:
+ hash = crypto.SHA1
+ case RSASHA256, ECDSAP256SHA256:
+ hash = crypto.SHA256
+ intlen = 32
+ case ECDSAP384SHA384:
+ hash = crypto.SHA384
+ intlen = 48
+ case RSASHA512:
+ hash = crypto.SHA512
+ default:
+ return nil, ErrAlg
+ }
+ hasher := hash.New()
+ // Write SIG rdata
+ hasher.Write(buf[len(mbuf)+1+2+2+4+2:])
+ // Write message
+ hasher.Write(buf[:len(mbuf)])
+ hashed := hasher.Sum(nil)
+
+ var sig []byte
+ switch p := k.(type) {
+ case *dsa.PrivateKey:
+ t := divRoundUp(divRoundUp(p.PublicKey.Y.BitLen(), 8)-64, 8)
+ r1, s1, err := dsa.Sign(rand.Reader, p, hashed)
+ if err != nil {
+ return nil, err
+ }
+ sig = append(sig, byte(t))
+ sig = append(sig, intToBytes(r1, 20)...)
+ sig = append(sig, intToBytes(s1, 20)...)
+ case *rsa.PrivateKey:
+ sig, err = rsa.SignPKCS1v15(rand.Reader, p, hash, hashed)
+ if err != nil {
+ return nil, err
+ }
+ case *ecdsa.PrivateKey:
+ r1, s1, err := ecdsa.Sign(rand.Reader, p, hashed)
+ if err != nil {
+ return nil, err
+ }
+ sig = intToBytes(r1, intlen)
+ sig = append(sig, intToBytes(s1, intlen)...)
+ default:
+ return nil, ErrAlg
+ }
+ rr.Signature = toBase64(sig)
+ buf = append(buf, sig...)
+ if len(buf) > int(^uint16(0)) {
+ return nil, ErrBuf
+ }
+ // Adjust sig data length
+ rdoff := len(mbuf) + 1 + 2 + 2 + 4
+ rdlen, _ := unpackUint16(buf, rdoff)
+ rdlen += uint16(len(sig))
+ buf[rdoff], buf[rdoff+1] = packUint16(rdlen)
+ // Adjust additional count
+ adc, _ := unpackUint16(buf, 10)
+ adc += 1
+ buf[10], buf[11] = packUint16(adc)
+ return buf, nil
+}
+
+// Verify validates the message buf using the key k.
+// It's assumed that buf is a valid message from which rr was unpacked.
+func (rr *SIG) Verify(k *KEY, buf []byte) error {
+ if k == nil {
+ return ErrKey
+ }
+ if rr.KeyTag == 0 || len(rr.SignerName) == 0 || rr.Algorithm == 0 {
+ return ErrKey
+ }
+
+ var hash crypto.Hash
+ switch rr.Algorithm {
+ case DSA, RSASHA1:
+ hash = crypto.SHA1
+ case RSASHA256, ECDSAP256SHA256:
+ hash = crypto.SHA256
+ case ECDSAP384SHA384:
+ hash = crypto.SHA384
+ case RSASHA512:
+ hash = crypto.SHA512
+ default:
+ return ErrAlg
+ }
+ hasher := hash.New()
+
+ buflen := len(buf)
+ qdc, _ := unpackUint16(buf, 4)
+ anc, _ := unpackUint16(buf, 6)
+ auc, _ := unpackUint16(buf, 8)
+ adc, offset := unpackUint16(buf, 10)
+ var err error
+ for i := uint16(0); i < qdc && offset < buflen; i++ {
+ _, offset, err = UnpackDomainName(buf, offset)
+ if err != nil {
+ return err
+ }
+ // Skip past Type and Class
+ offset += 2 + 2
+ }
+ for i := uint16(1); i < anc+auc+adc && offset < buflen; i++ {
+ _, offset, err = UnpackDomainName(buf, offset)
+ if err != nil {
+ return err
+ }
+ // Skip past Type, Class and TTL
+ offset += 2 + 2 + 4
+ if offset+1 >= buflen {
+ continue
+ }
+ var rdlen uint16
+ rdlen, offset = unpackUint16(buf, offset)
+ offset += int(rdlen)
+ }
+ if offset >= buflen {
+ return &Error{err: "overflowing unpacking signed message"}
+ }
+
+ // offset should be just prior to SIG
+ bodyend := offset
+ // owner name SHOULD be root
+ _, offset, err = UnpackDomainName(buf, offset)
+ if err != nil {
+ return err
+ }
+ // Skip Type, Class, TTL, RDLen
+ offset += 2 + 2 + 4 + 2
+ sigstart := offset
+ // Skip Type Covered, Algorithm, Labels, Original TTL
+ offset += 2 + 1 + 1 + 4
+ if offset+4+4 >= buflen {
+ return &Error{err: "overflow unpacking signed message"}
+ }
+ expire := uint32(buf[offset])<<24 | uint32(buf[offset+1])<<16 | uint32(buf[offset+2])<<8 | uint32(buf[offset+3])
+ offset += 4
+ incept := uint32(buf[offset])<<24 | uint32(buf[offset+1])<<16 | uint32(buf[offset+2])<<8 | uint32(buf[offset+3])
+ offset += 4
+ now := uint32(time.Now().Unix())
+ if now < incept || now > expire {
+ return ErrTime
+ }
+ // Skip key tag
+ offset += 2
+ var signername string
+ signername, offset, err = UnpackDomainName(buf, offset)
+ if err != nil {
+ return err
+ }
+ // If key has come from the DNS name compression might
+ // have mangled the case of the name
+ if strings.ToLower(signername) != strings.ToLower(k.Header().Name) {
+ return &Error{err: "signer name doesn't match key name"}
+ }
+ sigend := offset
+ hasher.Write(buf[sigstart:sigend])
+ hasher.Write(buf[:10])
+ hasher.Write([]byte{
+ byte((adc - 1) << 8),
+ byte(adc - 1),
+ })
+ hasher.Write(buf[12:bodyend])
+
+ hashed := hasher.Sum(nil)
+ sig := buf[sigend:]
+ switch k.Algorithm {
+ case DSA:
+ pk := k.publicKeyDSA()
+ sig = sig[1:]
+ r := big.NewInt(0)
+ r.SetBytes(sig[:len(sig)/2])
+ s := big.NewInt(0)
+ s.SetBytes(sig[len(sig)/2:])
+ if pk != nil {
+ if dsa.Verify(pk, hashed, r, s) {
+ return nil
+ }
+ return ErrSig
+ }
+ case RSASHA1, RSASHA256, RSASHA512:
+ pk := k.publicKeyRSA()
+ if pk != nil {
+ return rsa.VerifyPKCS1v15(pk, hash, hashed, sig)
+ }
+ case ECDSAP256SHA256, ECDSAP384SHA384:
+ pk := k.publicKeyCurve()
+ r := big.NewInt(0)
+ r.SetBytes(sig[:len(sig)/2])
+ s := big.NewInt(0)
+ s.SetBytes(sig[len(sig)/2:])
+ if pk != nil {
+ if ecdsa.Verify(pk, hashed, r, s) {
+ return nil
+ }
+ return ErrSig
+ }
+ }
+ return ErrKeyAlg
+}
diff --git a/Godeps/_workspace/src/github.com/miekg/dns/sig0_test.go b/Godeps/_workspace/src/github.com/miekg/dns/sig0_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..6ca76fb848a224d376be4b2504373f8765fd21c0
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/miekg/dns/sig0_test.go
@@ -0,0 +1,96 @@
+package dns
+
+import (
+ "testing"
+ "time"
+)
+
+func TestSIG0(t *testing.T) {
+ if testing.Short() {
+ t.Skip("skipping test in short mode.")
+ }
+ m := new(Msg)
+ m.SetQuestion("example.org.", TypeSOA)
+ for _, alg := range []uint8{DSA, ECDSAP256SHA256, ECDSAP384SHA384, RSASHA1, RSASHA256, RSASHA512} {
+ algstr := AlgorithmToString[alg]
+ keyrr := new(KEY)
+ keyrr.Hdr.Name = algstr + "."
+ keyrr.Hdr.Rrtype = TypeKEY
+ keyrr.Hdr.Class = ClassINET
+ keyrr.Algorithm = alg
+ keysize := 1024
+ switch alg {
+ case ECDSAP256SHA256:
+ keysize = 256
+ case ECDSAP384SHA384:
+ keysize = 384
+ }
+ pk, err := keyrr.Generate(keysize)
+ if err != nil {
+ t.Logf("Failed to generate key for “%sâ€: %v", algstr, err)
+ t.Fail()
+ continue
+ }
+ now := uint32(time.Now().Unix())
+ sigrr := new(SIG)
+ sigrr.Hdr.Name = "."
+ sigrr.Hdr.Rrtype = TypeSIG
+ sigrr.Hdr.Class = ClassANY
+ sigrr.Algorithm = alg
+ sigrr.Expiration = now + 300
+ sigrr.Inception = now - 300
+ sigrr.KeyTag = keyrr.KeyTag()
+ sigrr.SignerName = keyrr.Hdr.Name
+ mb, err := sigrr.Sign(pk, m)
+ if err != nil {
+ t.Logf("Failed to sign message using “%sâ€: %v", algstr, err)
+ t.Fail()
+ continue
+ }
+ m := new(Msg)
+ if err := m.Unpack(mb); err != nil {
+ t.Logf("Failed to unpack message signed using “%sâ€: %v", algstr, err)
+ t.Fail()
+ continue
+ }
+ if len(m.Extra) != 1 {
+ t.Logf("Missing SIG for message signed using “%sâ€", algstr)
+ t.Fail()
+ continue
+ }
+ var sigrrwire *SIG
+ switch rr := m.Extra[0].(type) {
+ case *SIG:
+ sigrrwire = rr
+ default:
+ t.Logf("Expected SIG RR, instead: %v", rr)
+ t.Fail()
+ continue
+ }
+ for _, rr := range []*SIG{sigrr, sigrrwire} {
+ id := "sigrr"
+ if rr == sigrrwire {
+ id = "sigrrwire"
+ }
+ if err := rr.Verify(keyrr, mb); err != nil {
+ t.Logf("Failed to verify “%s†signed SIG(%s): %v", algstr, id, err)
+ t.Fail()
+ continue
+ }
+ }
+ mb[13]++
+ if err := sigrr.Verify(keyrr, mb); err == nil {
+ t.Logf("Verify succeeded on an altered message using “%sâ€", algstr)
+ t.Fail()
+ continue
+ }
+ sigrr.Expiration = 2
+ sigrr.Inception = 1
+ mb, _ = sigrr.Sign(pk, m)
+ if err := sigrr.Verify(keyrr, mb); err == nil {
+ t.Logf("Verify succeeded on an expired message using “%sâ€", algstr)
+ t.Fail()
+ continue
+ }
+ }
+}
diff --git a/Godeps/_workspace/src/github.com/miekg/dns/singleinflight.go b/Godeps/_workspace/src/github.com/miekg/dns/singleinflight.go
new file mode 100644
index 0000000000000000000000000000000000000000..9573c7d0b8c25225662ee7909af985cc7bf607e0
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/miekg/dns/singleinflight.go
@@ -0,0 +1,57 @@
+// Copyright 2013 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.
+
+// Adapted for dns package usage by Miek Gieben.
+
+package dns
+
+import "sync"
+import "time"
+
+// call is an in-flight or completed singleflight.Do call
+type call struct {
+ wg sync.WaitGroup
+ val *Msg
+ rtt time.Duration
+ err error
+ dups int
+}
+
+// singleflight represents a class of work and forms a namespace in
+// which units of work can be executed with duplicate suppression.
+type singleflight struct {
+ sync.Mutex // protects m
+ m map[string]*call // lazily initialized
+}
+
+// Do executes and returns the results of the given function, making
+// sure that only one execution is in-flight for a given key at a
+// time. If a duplicate comes in, the duplicate caller waits for the
+// original to complete and receives the same results.
+// The return value shared indicates whether v was given to multiple callers.
+func (g *singleflight) Do(key string, fn func() (*Msg, time.Duration, error)) (v *Msg, rtt time.Duration, err error, shared bool) {
+ g.Lock()
+ if g.m == nil {
+ g.m = make(map[string]*call)
+ }
+ if c, ok := g.m[key]; ok {
+ c.dups++
+ g.Unlock()
+ c.wg.Wait()
+ return c.val, c.rtt, c.err, true
+ }
+ c := new(call)
+ c.wg.Add(1)
+ g.m[key] = c
+ g.Unlock()
+
+ c.val, c.rtt, c.err = fn()
+ c.wg.Done()
+
+ g.Lock()
+ delete(g.m, key)
+ g.Unlock()
+
+ return c.val, c.rtt, c.err, c.dups > 0
+}
diff --git a/Godeps/_workspace/src/github.com/miekg/dns/tlsa.go b/Godeps/_workspace/src/github.com/miekg/dns/tlsa.go
new file mode 100644
index 0000000000000000000000000000000000000000..d3bc3b0217fe4aa532a323158ea8dcf0b749ef04
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/miekg/dns/tlsa.go
@@ -0,0 +1,84 @@
+package dns
+
+import (
+ "crypto/sha256"
+ "crypto/sha512"
+ "crypto/x509"
+ "encoding/hex"
+ "errors"
+ "io"
+ "net"
+ "strconv"
+)
+
+// CertificateToDANE converts a certificate to a hex string as used in the TLSA record.
+func CertificateToDANE(selector, matchingType uint8, cert *x509.Certificate) (string, error) {
+ switch matchingType {
+ case 0:
+ switch selector {
+ case 0:
+ return hex.EncodeToString(cert.Raw), nil
+ case 1:
+ return hex.EncodeToString(cert.RawSubjectPublicKeyInfo), nil
+ }
+ case 1:
+ h := sha256.New()
+ switch selector {
+ case 0:
+ return hex.EncodeToString(cert.Raw), nil
+ case 1:
+ io.WriteString(h, string(cert.RawSubjectPublicKeyInfo))
+ return hex.EncodeToString(h.Sum(nil)), nil
+ }
+ case 2:
+ h := sha512.New()
+ switch selector {
+ case 0:
+ return hex.EncodeToString(cert.Raw), nil
+ case 1:
+ io.WriteString(h, string(cert.RawSubjectPublicKeyInfo))
+ return hex.EncodeToString(h.Sum(nil)), nil
+ }
+ }
+ return "", errors.New("dns: bad TLSA MatchingType or TLSA Selector")
+}
+
+// Sign creates a TLSA record from an SSL certificate.
+func (r *TLSA) Sign(usage, selector, matchingType int, cert *x509.Certificate) (err error) {
+ r.Hdr.Rrtype = TypeTLSA
+ r.Usage = uint8(usage)
+ r.Selector = uint8(selector)
+ r.MatchingType = uint8(matchingType)
+
+ r.Certificate, err = CertificateToDANE(r.Selector, r.MatchingType, cert)
+ if err != nil {
+ return err
+ }
+ return nil
+}
+
+// Verify verifies a TLSA record against an SSL certificate. If it is OK
+// a nil error is returned.
+func (r *TLSA) Verify(cert *x509.Certificate) error {
+ c, err := CertificateToDANE(r.Selector, r.MatchingType, cert)
+ if err != nil {
+ return err // Not also ErrSig?
+ }
+ if r.Certificate == c {
+ return nil
+ }
+ return ErrSig // ErrSig, really?
+}
+
+// TLSAName returns the ownername of a TLSA resource record as per the
+// rules specified in RFC 6698, Section 3.
+func TLSAName(name, service, network string) (string, error) {
+ if !IsFqdn(name) {
+ return "", ErrFqdn
+ }
+ p, e := net.LookupPort(network, service)
+ if e != nil {
+ return "", e
+ }
+ return "_" + strconv.Itoa(p) + "_" + network + "." + name, nil
+}
diff --git a/Godeps/_workspace/src/github.com/miekg/dns/tsig.go b/Godeps/_workspace/src/github.com/miekg/dns/tsig.go
new file mode 100644
index 0000000000000000000000000000000000000000..2c64ee8d548d68a429d64422f9f2c73f3dda28e6
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/miekg/dns/tsig.go
@@ -0,0 +1,378 @@
+// TRANSACTION SIGNATURE
+//
+// An TSIG or transaction signature adds a HMAC TSIG record to each message sent.
+// The supported algorithms include: HmacMD5, HmacSHA1 and HmacSHA256.
+//
+// Basic use pattern when querying with a TSIG name "axfr." (note that these key names
+// must be fully qualified - as they are domain names) and the base64 secret
+// "so6ZGir4GPAqINNh9U5c3A==":
+//
+// c := new(dns.Client)
+// c.TsigSecret = map[string]string{"axfr.": "so6ZGir4GPAqINNh9U5c3A=="}
+// m := new(dns.Msg)
+// m.SetQuestion("miek.nl.", dns.TypeMX)
+// m.SetTsig("axfr.", dns.HmacMD5, 300, time.Now().Unix())
+// ...
+// // When sending the TSIG RR is calculated and filled in before sending
+//
+// When requesting an zone transfer (almost all TSIG usage is when requesting zone transfers), with
+// TSIG, this is the basic use pattern. In this example we request an AXFR for
+// miek.nl. with TSIG key named "axfr." and secret "so6ZGir4GPAqINNh9U5c3A=="
+// and using the server 176.58.119.54:
+//
+// t := new(dns.Transfer)
+// m := new(dns.Msg)
+// t.TsigSecret = map[string]string{"axfr.": "so6ZGir4GPAqINNh9U5c3A=="}
+// m.SetAxfr("miek.nl.")
+// m.SetTsig("axfr.", dns.HmacMD5, 300, time.Now().Unix())
+// c, err := t.In(m, "176.58.119.54:53")
+// for r := range c { /* r.RR */ }
+//
+// You can now read the records from the transfer as they come in. Each envelope is checked with TSIG.
+// If something is not correct an error is returned.
+//
+// Basic use pattern validating and replying to a message that has TSIG set.
+//
+// server := &dns.Server{Addr: ":53", Net: "udp"}
+// server.TsigSecret = map[string]string{"axfr.": "so6ZGir4GPAqINNh9U5c3A=="}
+// go server.ListenAndServe()
+// dns.HandleFunc(".", handleRequest)
+//
+// func handleRequest(w dns.ResponseWriter, r *dns.Msg) {
+// m := new(Msg)
+// m.SetReply(r)
+// if r.IsTsig() {
+// if w.TsigStatus() == nil {
+// // *Msg r has an TSIG record and it was validated
+// m.SetTsig("axfr.", dns.HmacMD5, 300, time.Now().Unix())
+// } else {
+// // *Msg r has an TSIG records and it was not valided
+// }
+// }
+// w.WriteMsg(m)
+// }
+package dns
+
+import (
+ "crypto/hmac"
+ "crypto/md5"
+ "crypto/sha1"
+ "crypto/sha256"
+ "encoding/hex"
+ "hash"
+ "io"
+ "strconv"
+ "strings"
+ "time"
+)
+
+// HMAC hashing codes. These are transmitted as domain names.
+const (
+ HmacMD5 = "hmac-md5.sig-alg.reg.int."
+ HmacSHA1 = "hmac-sha1."
+ HmacSHA256 = "hmac-sha256."
+)
+
+type TSIG struct {
+ Hdr RR_Header
+ Algorithm string `dns:"domain-name"`
+ TimeSigned uint64 `dns:"uint48"`
+ Fudge uint16
+ MACSize uint16
+ MAC string `dns:"size-hex"`
+ OrigId uint16
+ Error uint16
+ OtherLen uint16
+ OtherData string `dns:"size-hex"`
+}
+
+func (rr *TSIG) Header() *RR_Header {
+ return &rr.Hdr
+}
+
+// TSIG has no official presentation format, but this will suffice.
+
+func (rr *TSIG) String() string {
+ s := "\n;; TSIG PSEUDOSECTION:\n"
+ s += rr.Hdr.String() +
+ " " + rr.Algorithm +
+ " " + tsigTimeToString(rr.TimeSigned) +
+ " " + strconv.Itoa(int(rr.Fudge)) +
+ " " + strconv.Itoa(int(rr.MACSize)) +
+ " " + strings.ToUpper(rr.MAC) +
+ " " + strconv.Itoa(int(rr.OrigId)) +
+ " " + strconv.Itoa(int(rr.Error)) + // BIND prints NOERROR
+ " " + strconv.Itoa(int(rr.OtherLen)) +
+ " " + rr.OtherData
+ return s
+}
+
+func (rr *TSIG) len() int {
+ return rr.Hdr.len() + len(rr.Algorithm) + 1 + 6 +
+ 4 + len(rr.MAC)/2 + 1 + 6 + len(rr.OtherData)/2 + 1
+}
+
+func (rr *TSIG) copy() RR {
+ return &TSIG{*rr.Hdr.copyHeader(), rr.Algorithm, rr.TimeSigned, rr.Fudge, rr.MACSize, rr.MAC, rr.OrigId, rr.Error, rr.OtherLen, rr.OtherData}
+}
+
+// The following values must be put in wireformat, so that the MAC can be calculated.
+// RFC 2845, section 3.4.2. TSIG Variables.
+type tsigWireFmt struct {
+ // From RR_Header
+ Name string `dns:"domain-name"`
+ Class uint16
+ Ttl uint32
+ // Rdata of the TSIG
+ Algorithm string `dns:"domain-name"`
+ TimeSigned uint64 `dns:"uint48"`
+ Fudge uint16
+ // MACSize, MAC and OrigId excluded
+ Error uint16
+ OtherLen uint16
+ OtherData string `dns:"size-hex"`
+}
+
+// If we have the MAC use this type to convert it to wiredata.
+// Section 3.4.3. Request MAC
+type macWireFmt struct {
+ MACSize uint16
+ MAC string `dns:"size-hex"`
+}
+
+// 3.3. Time values used in TSIG calculations
+type timerWireFmt struct {
+ TimeSigned uint64 `dns:"uint48"`
+ Fudge uint16
+}
+
+// TsigGenerate fills out the TSIG record attached to the message.
+// The message should contain
+// a "stub" TSIG RR with the algorithm, key name (owner name of the RR),
+// time fudge (defaults to 300 seconds) and the current time
+// The TSIG MAC is saved in that Tsig RR.
+// When TsigGenerate is called for the first time requestMAC is set to the empty string and
+// timersOnly is false.
+// If something goes wrong an error is returned, otherwise it is nil.
+func TsigGenerate(m *Msg, secret, requestMAC string, timersOnly bool) ([]byte, string, error) {
+ if m.IsTsig() == nil {
+ panic("dns: TSIG not last RR in additional")
+ }
+ // If we barf here, the caller is to blame
+ rawsecret, err := fromBase64([]byte(secret))
+ if err != nil {
+ return nil, "", err
+ }
+
+ rr := m.Extra[len(m.Extra)-1].(*TSIG)
+ m.Extra = m.Extra[0 : len(m.Extra)-1] // kill the TSIG from the msg
+ mbuf, err := m.Pack()
+ if err != nil {
+ return nil, "", err
+ }
+ buf := tsigBuffer(mbuf, rr, requestMAC, timersOnly)
+
+ t := new(TSIG)
+ var h hash.Hash
+ switch rr.Algorithm {
+ case HmacMD5:
+ h = hmac.New(md5.New, []byte(rawsecret))
+ case HmacSHA1:
+ h = hmac.New(sha1.New, []byte(rawsecret))
+ case HmacSHA256:
+ h = hmac.New(sha256.New, []byte(rawsecret))
+ default:
+ return nil, "", ErrKeyAlg
+ }
+ io.WriteString(h, string(buf))
+ t.MAC = hex.EncodeToString(h.Sum(nil))
+ t.MACSize = uint16(len(t.MAC) / 2) // Size is half!
+
+ t.Hdr = RR_Header{Name: rr.Hdr.Name, Rrtype: TypeTSIG, Class: ClassANY, Ttl: 0}
+ t.Fudge = rr.Fudge
+ t.TimeSigned = rr.TimeSigned
+ t.Algorithm = rr.Algorithm
+ t.OrigId = m.Id
+
+ tbuf := make([]byte, t.len())
+ if off, err := PackRR(t, tbuf, 0, nil, false); err == nil {
+ tbuf = tbuf[:off] // reset to actual size used
+ } else {
+ return nil, "", err
+ }
+ mbuf = append(mbuf, tbuf...)
+ rawSetExtraLen(mbuf, uint16(len(m.Extra)+1))
+ return mbuf, t.MAC, nil
+}
+
+// TsigVerify verifies the TSIG on a message.
+// If the signature does not validate err contains the
+// error, otherwise it is nil.
+func TsigVerify(msg []byte, secret, requestMAC string, timersOnly bool) error {
+ rawsecret, err := fromBase64([]byte(secret))
+ if err != nil {
+ return err
+ }
+ // Strip the TSIG from the incoming msg
+ stripped, tsig, err := stripTsig(msg)
+ if err != nil {
+ return err
+ }
+
+ msgMAC, err := hex.DecodeString(tsig.MAC)
+ if err != nil {
+ return err
+ }
+
+ buf := tsigBuffer(stripped, tsig, requestMAC, timersOnly)
+
+ // Fudge factor works both ways. A message can arrive before it was signed because
+ // of clock skew.
+ now := uint64(time.Now().Unix())
+ ti := now - tsig.TimeSigned
+ if now < tsig.TimeSigned {
+ ti = tsig.TimeSigned - now
+ }
+ if uint64(tsig.Fudge) < ti {
+ return ErrTime
+ }
+
+ var h hash.Hash
+ switch tsig.Algorithm {
+ case HmacMD5:
+ h = hmac.New(md5.New, rawsecret)
+ case HmacSHA1:
+ h = hmac.New(sha1.New, rawsecret)
+ case HmacSHA256:
+ h = hmac.New(sha256.New, rawsecret)
+ default:
+ return ErrKeyAlg
+ }
+ h.Write(buf)
+ if !hmac.Equal(h.Sum(nil), msgMAC) {
+ return ErrSig
+ }
+ return nil
+}
+
+// Create a wiredata buffer for the MAC calculation.
+func tsigBuffer(msgbuf []byte, rr *TSIG, requestMAC string, timersOnly bool) []byte {
+ var buf []byte
+ if rr.TimeSigned == 0 {
+ rr.TimeSigned = uint64(time.Now().Unix())
+ }
+ if rr.Fudge == 0 {
+ rr.Fudge = 300 // Standard (RFC) default.
+ }
+
+ if requestMAC != "" {
+ m := new(macWireFmt)
+ m.MACSize = uint16(len(requestMAC) / 2)
+ m.MAC = requestMAC
+ buf = make([]byte, len(requestMAC)) // long enough
+ n, _ := PackStruct(m, buf, 0)
+ buf = buf[:n]
+ }
+
+ tsigvar := make([]byte, DefaultMsgSize)
+ if timersOnly {
+ tsig := new(timerWireFmt)
+ tsig.TimeSigned = rr.TimeSigned
+ tsig.Fudge = rr.Fudge
+ n, _ := PackStruct(tsig, tsigvar, 0)
+ tsigvar = tsigvar[:n]
+ } else {
+ tsig := new(tsigWireFmt)
+ tsig.Name = strings.ToLower(rr.Hdr.Name)
+ tsig.Class = ClassANY
+ tsig.Ttl = rr.Hdr.Ttl
+ tsig.Algorithm = strings.ToLower(rr.Algorithm)
+ tsig.TimeSigned = rr.TimeSigned
+ tsig.Fudge = rr.Fudge
+ tsig.Error = rr.Error
+ tsig.OtherLen = rr.OtherLen
+ tsig.OtherData = rr.OtherData
+ n, _ := PackStruct(tsig, tsigvar, 0)
+ tsigvar = tsigvar[:n]
+ }
+
+ if requestMAC != "" {
+ x := append(buf, msgbuf...)
+ buf = append(x, tsigvar...)
+ } else {
+ buf = append(msgbuf, tsigvar...)
+ }
+ return buf
+}
+
+// Strip the TSIG from the raw message.
+func stripTsig(msg []byte) ([]byte, *TSIG, error) {
+ // Copied from msg.go's Unpack()
+ // Header.
+ var dh Header
+ var err error
+ dns := new(Msg)
+ rr := new(TSIG)
+ off := 0
+ tsigoff := 0
+ if off, err = UnpackStruct(&dh, msg, off); err != nil {
+ return nil, nil, err
+ }
+ if dh.Arcount == 0 {
+ return nil, nil, ErrNoSig
+ }
+ // Rcode, see msg.go Unpack()
+ if int(dh.Bits&0xF) == RcodeNotAuth {
+ return nil, nil, ErrAuth
+ }
+
+ // Arrays.
+ dns.Question = make([]Question, dh.Qdcount)
+ dns.Answer = make([]RR, dh.Ancount)
+ dns.Ns = make([]RR, dh.Nscount)
+ dns.Extra = make([]RR, dh.Arcount)
+
+ for i := 0; i < len(dns.Question); i++ {
+ off, err = UnpackStruct(&dns.Question[i], msg, off)
+ if err != nil {
+ return nil, nil, err
+ }
+ }
+ for i := 0; i < len(dns.Answer); i++ {
+ dns.Answer[i], off, err = UnpackRR(msg, off)
+ if err != nil {
+ return nil, nil, err
+ }
+ }
+ for i := 0; i < len(dns.Ns); i++ {
+ dns.Ns[i], off, err = UnpackRR(msg, off)
+ if err != nil {
+ return nil, nil, err
+ }
+ }
+ for i := 0; i < len(dns.Extra); i++ {
+ tsigoff = off
+ dns.Extra[i], off, err = UnpackRR(msg, off)
+ if err != nil {
+ return nil, nil, err
+ }
+ if dns.Extra[i].Header().Rrtype == TypeTSIG {
+ rr = dns.Extra[i].(*TSIG)
+ // Adjust Arcount.
+ arcount, _ := unpackUint16(msg, 10)
+ msg[10], msg[11] = packUint16(arcount - 1)
+ break
+ }
+ }
+ if rr == nil {
+ return nil, nil, ErrNoSig
+ }
+ return msg[:tsigoff], rr, nil
+}
+
+// Translate the TSIG time signed into a date. There is no
+// need for RFC1982 calculations as this date is 48 bits.
+func tsigTimeToString(t uint64) string {
+ ti := time.Unix(int64(t), 0).UTC()
+ return ti.Format("20060102150405")
+}
diff --git a/Godeps/_workspace/src/github.com/miekg/dns/types.go b/Godeps/_workspace/src/github.com/miekg/dns/types.go
new file mode 100644
index 0000000000000000000000000000000000000000..16bb181b9b0cadcbfd46e33ea058ef3b1f2a574a
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/miekg/dns/types.go
@@ -0,0 +1,1697 @@
+package dns
+
+import (
+ "encoding/base64"
+ "fmt"
+ "net"
+ "strconv"
+ "strings"
+ "time"
+)
+
+type (
+ Type uint16 // Type is a DNS type.
+ Class uint16 // Class is a DNS class.
+ Name string // Name is a DNS domain name.
+)
+
+// Packet formats
+
+// Wire constants and supported types.
+const (
+ // valid RR_Header.Rrtype and Question.qtype
+ TypeNone uint16 = 0
+ TypeA uint16 = 1
+ TypeNS uint16 = 2
+ TypeMD uint16 = 3
+ TypeMF uint16 = 4
+ TypeCNAME uint16 = 5
+ TypeSOA uint16 = 6
+ TypeMB uint16 = 7
+ TypeMG uint16 = 8
+ TypeMR uint16 = 9
+ TypeNULL uint16 = 10
+ TypeWKS uint16 = 11
+ TypePTR uint16 = 12
+ TypeHINFO uint16 = 13
+ TypeMINFO uint16 = 14
+ TypeMX uint16 = 15
+ TypeTXT uint16 = 16
+ TypeRP uint16 = 17
+ TypeAFSDB uint16 = 18
+ TypeX25 uint16 = 19
+ TypeISDN uint16 = 20
+ TypeRT uint16 = 21
+ TypeNSAP uint16 = 22
+ TypeNSAPPTR uint16 = 23
+ TypeSIG uint16 = 24
+ TypeKEY uint16 = 25
+ TypePX uint16 = 26
+ TypeGPOS uint16 = 27
+ TypeAAAA uint16 = 28
+ TypeLOC uint16 = 29
+ TypeNXT uint16 = 30
+ TypeEID uint16 = 31
+ TypeNIMLOC uint16 = 32
+ TypeSRV uint16 = 33
+ TypeATMA uint16 = 34
+ TypeNAPTR uint16 = 35
+ TypeKX uint16 = 36
+ TypeCERT uint16 = 37
+ TypeDNAME uint16 = 39
+ TypeOPT uint16 = 41 // EDNS
+ TypeDS uint16 = 43
+ TypeSSHFP uint16 = 44
+ TypeIPSECKEY uint16 = 45
+ TypeRRSIG uint16 = 46
+ TypeNSEC uint16 = 47
+ TypeDNSKEY uint16 = 48
+ TypeDHCID uint16 = 49
+ TypeNSEC3 uint16 = 50
+ TypeNSEC3PARAM uint16 = 51
+ TypeTLSA uint16 = 52
+ TypeHIP uint16 = 55
+ TypeNINFO uint16 = 56
+ TypeRKEY uint16 = 57
+ TypeTALINK uint16 = 58
+ TypeCDS uint16 = 59
+ TypeCDNSKEY uint16 = 60
+ TypeOPENPGPKEY uint16 = 61
+ TypeSPF uint16 = 99
+ TypeUINFO uint16 = 100
+ TypeUID uint16 = 101
+ TypeGID uint16 = 102
+ TypeUNSPEC uint16 = 103
+ TypeNID uint16 = 104
+ TypeL32 uint16 = 105
+ TypeL64 uint16 = 106
+ TypeLP uint16 = 107
+ TypeEUI48 uint16 = 108
+ TypeEUI64 uint16 = 109
+
+ TypeTKEY uint16 = 249
+ TypeTSIG uint16 = 250
+ // valid Question.Qtype only
+ TypeIXFR uint16 = 251
+ TypeAXFR uint16 = 252
+ TypeMAILB uint16 = 253
+ TypeMAILA uint16 = 254
+ TypeANY uint16 = 255
+
+ TypeURI uint16 = 256
+ TypeCAA uint16 = 257
+ TypeTA uint16 = 32768
+ TypeDLV uint16 = 32769
+ TypeReserved uint16 = 65535
+
+ // valid Question.Qclass
+ ClassINET = 1
+ ClassCSNET = 2
+ ClassCHAOS = 3
+ ClassHESIOD = 4
+ ClassNONE = 254
+ ClassANY = 255
+
+ // Msg.rcode
+ RcodeSuccess = 0
+ RcodeFormatError = 1
+ RcodeServerFailure = 2
+ RcodeNameError = 3
+ RcodeNotImplemented = 4
+ RcodeRefused = 5
+ RcodeYXDomain = 6
+ RcodeYXRrset = 7
+ RcodeNXRrset = 8
+ RcodeNotAuth = 9
+ RcodeNotZone = 10
+ RcodeBadSig = 16 // TSIG
+ RcodeBadVers = 16 // EDNS0
+ RcodeBadKey = 17
+ RcodeBadTime = 18
+ RcodeBadMode = 19 // TKEY
+ RcodeBadName = 20
+ RcodeBadAlg = 21
+ RcodeBadTrunc = 22 // TSIG
+
+ // Opcode
+ OpcodeQuery = 0
+ OpcodeIQuery = 1
+ OpcodeStatus = 2
+ // There is no 3
+ OpcodeNotify = 4
+ OpcodeUpdate = 5
+)
+
+// The wire format for the DNS packet header.
+type Header struct {
+ Id uint16
+ Bits uint16
+ Qdcount, Ancount, Nscount, Arcount uint16
+}
+
+const (
+ // Header.Bits
+ _QR = 1 << 15 // query/response (response=1)
+ _AA = 1 << 10 // authoritative
+ _TC = 1 << 9 // truncated
+ _RD = 1 << 8 // recursion desired
+ _RA = 1 << 7 // recursion available
+ _Z = 1 << 6 // Z
+ _AD = 1 << 5 // authticated data
+ _CD = 1 << 4 // checking disabled
+
+ LOC_EQUATOR = 1 << 31 // RFC 1876, Section 2.
+ LOC_PRIMEMERIDIAN = 1 << 31 // RFC 1876, Section 2.
+
+ LOC_HOURS = 60 * 1000
+ LOC_DEGREES = 60 * LOC_HOURS
+
+ LOC_ALTITUDEBASE = 100000
+)
+
+// RFC 4398, Section 2.1
+const (
+ CertPKIX = 1 + iota
+ CertSPKI
+ CertPGP
+ CertIPIX
+ CertISPKI
+ CertIPGP
+ CertACPKIX
+ CertIACPKIX
+ CertURI = 253
+ CertOID = 254
+)
+
+var CertTypeToString = map[uint16]string{
+ CertPKIX: "PKIX",
+ CertSPKI: "SPKI",
+ CertPGP: "PGP",
+ CertIPIX: "IPIX",
+ CertISPKI: "ISPKI",
+ CertIPGP: "IPGP",
+ CertACPKIX: "ACPKIX",
+ CertIACPKIX: "IACPKIX",
+ CertURI: "URI",
+ CertOID: "OID",
+}
+
+var StringToCertType = reverseInt16(CertTypeToString)
+
+// DNS queries.
+type Question struct {
+ Name string `dns:"cdomain-name"` // "cdomain-name" specifies encoding (and may be compressed)
+ Qtype uint16
+ Qclass uint16
+}
+
+func (q *Question) String() (s string) {
+ // prefix with ; (as in dig)
+ s = ";" + sprintName(q.Name) + "\t"
+ s += Class(q.Qclass).String() + "\t"
+ s += " " + Type(q.Qtype).String()
+ return s
+}
+
+func (q *Question) len() int {
+ l := len(q.Name) + 1
+ return l + 4
+}
+
+type ANY struct {
+ Hdr RR_Header
+ // Does not have any rdata
+}
+
+func (rr *ANY) Header() *RR_Header { return &rr.Hdr }
+func (rr *ANY) copy() RR { return &ANY{*rr.Hdr.copyHeader()} }
+func (rr *ANY) String() string { return rr.Hdr.String() }
+func (rr *ANY) len() int { return rr.Hdr.len() }
+
+type CNAME struct {
+ Hdr RR_Header
+ Target string `dns:"cdomain-name"`
+}
+
+func (rr *CNAME) Header() *RR_Header { return &rr.Hdr }
+func (rr *CNAME) copy() RR { return &CNAME{*rr.Hdr.copyHeader(), sprintName(rr.Target)} }
+func (rr *CNAME) String() string { return rr.Hdr.String() + rr.Target }
+func (rr *CNAME) len() int { return rr.Hdr.len() + len(rr.Target) + 1 }
+
+type HINFO struct {
+ Hdr RR_Header
+ Cpu string
+ Os string
+}
+
+func (rr *HINFO) Header() *RR_Header { return &rr.Hdr }
+func (rr *HINFO) copy() RR { return &HINFO{*rr.Hdr.copyHeader(), rr.Cpu, rr.Os} }
+func (rr *HINFO) String() string { return rr.Hdr.String() + rr.Cpu + " " + rr.Os }
+func (rr *HINFO) len() int { return rr.Hdr.len() + len(rr.Cpu) + len(rr.Os) }
+
+type MB struct {
+ Hdr RR_Header
+ Mb string `dns:"cdomain-name"`
+}
+
+func (rr *MB) Header() *RR_Header { return &rr.Hdr }
+func (rr *MB) copy() RR { return &MB{*rr.Hdr.copyHeader(), sprintName(rr.Mb)} }
+
+func (rr *MB) String() string { return rr.Hdr.String() + rr.Mb }
+func (rr *MB) len() int { return rr.Hdr.len() + len(rr.Mb) + 1 }
+
+type MG struct {
+ Hdr RR_Header
+ Mg string `dns:"cdomain-name"`
+}
+
+func (rr *MG) Header() *RR_Header { return &rr.Hdr }
+func (rr *MG) copy() RR { return &MG{*rr.Hdr.copyHeader(), rr.Mg} }
+func (rr *MG) len() int { l := len(rr.Mg) + 1; return rr.Hdr.len() + l }
+func (rr *MG) String() string { return rr.Hdr.String() + sprintName(rr.Mg) }
+
+type MINFO struct {
+ Hdr RR_Header
+ Rmail string `dns:"cdomain-name"`
+ Email string `dns:"cdomain-name"`
+}
+
+func (rr *MINFO) Header() *RR_Header { return &rr.Hdr }
+func (rr *MINFO) copy() RR { return &MINFO{*rr.Hdr.copyHeader(), rr.Rmail, rr.Email} }
+
+func (rr *MINFO) String() string {
+ return rr.Hdr.String() + sprintName(rr.Rmail) + " " + sprintName(rr.Email)
+}
+
+func (rr *MINFO) len() int {
+ l := len(rr.Rmail) + 1
+ n := len(rr.Email) + 1
+ return rr.Hdr.len() + l + n
+}
+
+type MR struct {
+ Hdr RR_Header
+ Mr string `dns:"cdomain-name"`
+}
+
+func (rr *MR) Header() *RR_Header { return &rr.Hdr }
+func (rr *MR) copy() RR { return &MR{*rr.Hdr.copyHeader(), rr.Mr} }
+func (rr *MR) len() int { l := len(rr.Mr) + 1; return rr.Hdr.len() + l }
+
+func (rr *MR) String() string {
+ return rr.Hdr.String() + sprintName(rr.Mr)
+}
+
+type MF struct {
+ Hdr RR_Header
+ Mf string `dns:"cdomain-name"`
+}
+
+func (rr *MF) Header() *RR_Header { return &rr.Hdr }
+func (rr *MF) copy() RR { return &MF{*rr.Hdr.copyHeader(), rr.Mf} }
+func (rr *MF) len() int { return rr.Hdr.len() + len(rr.Mf) + 1 }
+
+func (rr *MF) String() string {
+ return rr.Hdr.String() + sprintName(rr.Mf)
+}
+
+type MD struct {
+ Hdr RR_Header
+ Md string `dns:"cdomain-name"`
+}
+
+func (rr *MD) Header() *RR_Header { return &rr.Hdr }
+func (rr *MD) copy() RR { return &MD{*rr.Hdr.copyHeader(), rr.Md} }
+func (rr *MD) len() int { return rr.Hdr.len() + len(rr.Md) + 1 }
+
+func (rr *MD) String() string {
+ return rr.Hdr.String() + sprintName(rr.Md)
+}
+
+type MX struct {
+ Hdr RR_Header
+ Preference uint16
+ Mx string `dns:"cdomain-name"`
+}
+
+func (rr *MX) Header() *RR_Header { return &rr.Hdr }
+func (rr *MX) copy() RR { return &MX{*rr.Hdr.copyHeader(), rr.Preference, rr.Mx} }
+func (rr *MX) len() int { l := len(rr.Mx) + 1; return rr.Hdr.len() + l + 2 }
+
+func (rr *MX) String() string {
+ return rr.Hdr.String() + strconv.Itoa(int(rr.Preference)) + " " + sprintName(rr.Mx)
+}
+
+type AFSDB struct {
+ Hdr RR_Header
+ Subtype uint16
+ Hostname string `dns:"cdomain-name"`
+}
+
+func (rr *AFSDB) Header() *RR_Header { return &rr.Hdr }
+func (rr *AFSDB) copy() RR { return &AFSDB{*rr.Hdr.copyHeader(), rr.Subtype, rr.Hostname} }
+func (rr *AFSDB) len() int { l := len(rr.Hostname) + 1; return rr.Hdr.len() + l + 2 }
+
+func (rr *AFSDB) String() string {
+ return rr.Hdr.String() + strconv.Itoa(int(rr.Subtype)) + " " + sprintName(rr.Hostname)
+}
+
+type X25 struct {
+ Hdr RR_Header
+ PSDNAddress string
+}
+
+func (rr *X25) Header() *RR_Header { return &rr.Hdr }
+func (rr *X25) copy() RR { return &X25{*rr.Hdr.copyHeader(), rr.PSDNAddress} }
+func (rr *X25) len() int { return rr.Hdr.len() + len(rr.PSDNAddress) + 1 }
+
+func (rr *X25) String() string {
+ return rr.Hdr.String() + rr.PSDNAddress
+}
+
+type RT struct {
+ Hdr RR_Header
+ Preference uint16
+ Host string `dns:"cdomain-name"`
+}
+
+func (rr *RT) Header() *RR_Header { return &rr.Hdr }
+func (rr *RT) copy() RR { return &RT{*rr.Hdr.copyHeader(), rr.Preference, rr.Host} }
+func (rr *RT) len() int { l := len(rr.Host) + 1; return rr.Hdr.len() + l + 2 }
+
+func (rr *RT) String() string {
+ return rr.Hdr.String() + strconv.Itoa(int(rr.Preference)) + " " + sprintName(rr.Host)
+}
+
+type NS struct {
+ Hdr RR_Header
+ Ns string `dns:"cdomain-name"`
+}
+
+func (rr *NS) Header() *RR_Header { return &rr.Hdr }
+func (rr *NS) len() int { l := len(rr.Ns) + 1; return rr.Hdr.len() + l }
+func (rr *NS) copy() RR { return &NS{*rr.Hdr.copyHeader(), rr.Ns} }
+
+func (rr *NS) String() string {
+ return rr.Hdr.String() + sprintName(rr.Ns)
+}
+
+type PTR struct {
+ Hdr RR_Header
+ Ptr string `dns:"cdomain-name"`
+}
+
+func (rr *PTR) Header() *RR_Header { return &rr.Hdr }
+func (rr *PTR) copy() RR { return &PTR{*rr.Hdr.copyHeader(), rr.Ptr} }
+func (rr *PTR) len() int { l := len(rr.Ptr) + 1; return rr.Hdr.len() + l }
+
+func (rr *PTR) String() string {
+ return rr.Hdr.String() + sprintName(rr.Ptr)
+}
+
+type RP struct {
+ Hdr RR_Header
+ Mbox string `dns:"domain-name"`
+ Txt string `dns:"domain-name"`
+}
+
+func (rr *RP) Header() *RR_Header { return &rr.Hdr }
+func (rr *RP) copy() RR { return &RP{*rr.Hdr.copyHeader(), rr.Mbox, rr.Txt} }
+func (rr *RP) len() int { return rr.Hdr.len() + len(rr.Mbox) + 1 + len(rr.Txt) + 1 }
+
+func (rr *RP) String() string {
+ return rr.Hdr.String() + rr.Mbox + " " + sprintTxt([]string{rr.Txt})
+}
+
+type SOA struct {
+ Hdr RR_Header
+ Ns string `dns:"cdomain-name"`
+ Mbox string `dns:"cdomain-name"`
+ Serial uint32
+ Refresh uint32
+ Retry uint32
+ Expire uint32
+ Minttl uint32
+}
+
+func (rr *SOA) Header() *RR_Header { return &rr.Hdr }
+func (rr *SOA) copy() RR {
+ return &SOA{*rr.Hdr.copyHeader(), rr.Ns, rr.Mbox, rr.Serial, rr.Refresh, rr.Retry, rr.Expire, rr.Minttl}
+}
+
+func (rr *SOA) String() string {
+ return rr.Hdr.String() + sprintName(rr.Ns) + " " + sprintName(rr.Mbox) +
+ " " + strconv.FormatInt(int64(rr.Serial), 10) +
+ " " + strconv.FormatInt(int64(rr.Refresh), 10) +
+ " " + strconv.FormatInt(int64(rr.Retry), 10) +
+ " " + strconv.FormatInt(int64(rr.Expire), 10) +
+ " " + strconv.FormatInt(int64(rr.Minttl), 10)
+}
+
+func (rr *SOA) len() int {
+ l := len(rr.Ns) + 1
+ n := len(rr.Mbox) + 1
+ return rr.Hdr.len() + l + n + 20
+}
+
+type TXT struct {
+ Hdr RR_Header
+ Txt []string `dns:"txt"`
+}
+
+func (rr *TXT) Header() *RR_Header { return &rr.Hdr }
+func (rr *TXT) copy() RR {
+ cp := make([]string, len(rr.Txt), cap(rr.Txt))
+ copy(cp, rr.Txt)
+ return &TXT{*rr.Hdr.copyHeader(), cp}
+}
+
+func (rr *TXT) String() string { return rr.Hdr.String() + sprintTxt(rr.Txt) }
+
+func sprintName(s string) string {
+ src := []byte(s)
+ dst := make([]byte, 0, len(src))
+ for i := 0; i < len(src); {
+ if i+1 < len(src) && src[i] == '\\' && src[i+1] == '.' {
+ dst = append(dst, src[i:i+2]...)
+ i += 2
+ } else {
+ b, n := nextByte(src, i)
+ if n == 0 {
+ i++ // dangling back slash
+ } else if b == '.' {
+ dst = append(dst, b)
+ } else {
+ dst = appendDomainNameByte(dst, b)
+ }
+ i += n
+ }
+ }
+ return string(dst)
+}
+
+func sprintTxt(txt []string) string {
+ var out []byte
+ for i, s := range txt {
+ if i > 0 {
+ out = append(out, ` "`...)
+ } else {
+ out = append(out, '"')
+ }
+ bs := []byte(s)
+ for j := 0; j < len(bs); {
+ b, n := nextByte(bs, j)
+ if n == 0 {
+ break
+ }
+ out = appendTXTStringByte(out, b)
+ j += n
+ }
+ out = append(out, '"')
+ }
+ return string(out)
+}
+
+func appendDomainNameByte(s []byte, b byte) []byte {
+ switch b {
+ case '.', ' ', '\'', '@', ';', '(', ')': // additional chars to escape
+ return append(s, '\\', b)
+ }
+ return appendTXTStringByte(s, b)
+}
+
+func appendTXTStringByte(s []byte, b byte) []byte {
+ switch b {
+ case '\t':
+ return append(s, '\\', 't')
+ case '\r':
+ return append(s, '\\', 'r')
+ case '\n':
+ return append(s, '\\', 'n')
+ case '"', '\\':
+ return append(s, '\\', b)
+ }
+ if b < ' ' || b > '~' {
+ var buf [3]byte
+ bufs := strconv.AppendInt(buf[:0], int64(b), 10)
+ s = append(s, '\\')
+ for i := 0; i < 3-len(bufs); i++ {
+ s = append(s, '0')
+ }
+ for _, r := range bufs {
+ s = append(s, r)
+ }
+ return s
+
+ }
+ return append(s, b)
+}
+
+func nextByte(b []byte, offset int) (byte, int) {
+ if offset >= len(b) {
+ return 0, 0
+ }
+ if b[offset] != '\\' {
+ // not an escape sequence
+ return b[offset], 1
+ }
+ switch len(b) - offset {
+ case 1: // dangling escape
+ return 0, 0
+ case 2, 3: // too short to be \ddd
+ default: // maybe \ddd
+ if isDigit(b[offset+1]) && isDigit(b[offset+2]) && isDigit(b[offset+3]) {
+ return dddToByte(b[offset+1:]), 4
+ }
+ }
+ // not \ddd, maybe a control char
+ switch b[offset+1] {
+ case 't':
+ return '\t', 2
+ case 'r':
+ return '\r', 2
+ case 'n':
+ return '\n', 2
+ default:
+ return b[offset+1], 2
+ }
+}
+
+func (rr *TXT) len() int {
+ l := rr.Hdr.len()
+ for _, t := range rr.Txt {
+ l += len(t) + 1
+ }
+ return l
+}
+
+type SPF struct {
+ Hdr RR_Header
+ Txt []string `dns:"txt"`
+}
+
+func (rr *SPF) Header() *RR_Header { return &rr.Hdr }
+func (rr *SPF) copy() RR {
+ cp := make([]string, len(rr.Txt), cap(rr.Txt))
+ copy(cp, rr.Txt)
+ return &SPF{*rr.Hdr.copyHeader(), cp}
+}
+
+func (rr *SPF) String() string { return rr.Hdr.String() + sprintTxt(rr.Txt) }
+
+func (rr *SPF) len() int {
+ l := rr.Hdr.len()
+ for _, t := range rr.Txt {
+ l += len(t) + 1
+ }
+ return l
+}
+
+type SRV struct {
+ Hdr RR_Header
+ Priority uint16
+ Weight uint16
+ Port uint16
+ Target string `dns:"domain-name"`
+}
+
+func (rr *SRV) Header() *RR_Header { return &rr.Hdr }
+func (rr *SRV) len() int { l := len(rr.Target) + 1; return rr.Hdr.len() + l + 6 }
+func (rr *SRV) copy() RR {
+ return &SRV{*rr.Hdr.copyHeader(), rr.Priority, rr.Weight, rr.Port, rr.Target}
+}
+
+func (rr *SRV) String() string {
+ return rr.Hdr.String() +
+ strconv.Itoa(int(rr.Priority)) + " " +
+ strconv.Itoa(int(rr.Weight)) + " " +
+ strconv.Itoa(int(rr.Port)) + " " + sprintName(rr.Target)
+}
+
+type NAPTR struct {
+ Hdr RR_Header
+ Order uint16
+ Preference uint16
+ Flags string
+ Service string
+ Regexp string
+ Replacement string `dns:"domain-name"`
+}
+
+func (rr *NAPTR) Header() *RR_Header { return &rr.Hdr }
+func (rr *NAPTR) copy() RR {
+ return &NAPTR{*rr.Hdr.copyHeader(), rr.Order, rr.Preference, rr.Flags, rr.Service, rr.Regexp, rr.Replacement}
+}
+
+func (rr *NAPTR) String() string {
+ return rr.Hdr.String() +
+ strconv.Itoa(int(rr.Order)) + " " +
+ strconv.Itoa(int(rr.Preference)) + " " +
+ "\"" + rr.Flags + "\" " +
+ "\"" + rr.Service + "\" " +
+ "\"" + rr.Regexp + "\" " +
+ rr.Replacement
+}
+
+func (rr *NAPTR) len() int {
+ return rr.Hdr.len() + 4 + len(rr.Flags) + 1 + len(rr.Service) + 1 +
+ len(rr.Regexp) + 1 + len(rr.Replacement) + 1
+}
+
+// See RFC 4398.
+type CERT struct {
+ Hdr RR_Header
+ Type uint16
+ KeyTag uint16
+ Algorithm uint8
+ Certificate string `dns:"base64"`
+}
+
+func (rr *CERT) Header() *RR_Header { return &rr.Hdr }
+func (rr *CERT) copy() RR {
+ return &CERT{*rr.Hdr.copyHeader(), rr.Type, rr.KeyTag, rr.Algorithm, rr.Certificate}
+}
+
+func (rr *CERT) String() string {
+ var (
+ ok bool
+ certtype, algorithm string
+ )
+ if certtype, ok = CertTypeToString[rr.Type]; !ok {
+ certtype = strconv.Itoa(int(rr.Type))
+ }
+ if algorithm, ok = AlgorithmToString[rr.Algorithm]; !ok {
+ algorithm = strconv.Itoa(int(rr.Algorithm))
+ }
+ return rr.Hdr.String() + certtype +
+ " " + strconv.Itoa(int(rr.KeyTag)) +
+ " " + algorithm +
+ " " + rr.Certificate
+}
+
+func (rr *CERT) len() int {
+ return rr.Hdr.len() + 5 +
+ base64.StdEncoding.DecodedLen(len(rr.Certificate))
+}
+
+// See RFC 2672.
+type DNAME struct {
+ Hdr RR_Header
+ Target string `dns:"domain-name"`
+}
+
+func (rr *DNAME) Header() *RR_Header { return &rr.Hdr }
+func (rr *DNAME) copy() RR { return &DNAME{*rr.Hdr.copyHeader(), rr.Target} }
+func (rr *DNAME) len() int { l := len(rr.Target) + 1; return rr.Hdr.len() + l }
+
+func (rr *DNAME) String() string {
+ return rr.Hdr.String() + sprintName(rr.Target)
+}
+
+type A struct {
+ Hdr RR_Header
+ A net.IP `dns:"a"`
+}
+
+func (rr *A) Header() *RR_Header { return &rr.Hdr }
+func (rr *A) copy() RR { return &A{*rr.Hdr.copyHeader(), copyIP(rr.A)} }
+func (rr *A) len() int { return rr.Hdr.len() + net.IPv4len }
+
+func (rr *A) String() string {
+ if rr.A == nil {
+ return rr.Hdr.String()
+ }
+ return rr.Hdr.String() + rr.A.String()
+}
+
+type AAAA struct {
+ Hdr RR_Header
+ AAAA net.IP `dns:"aaaa"`
+}
+
+func (rr *AAAA) Header() *RR_Header { return &rr.Hdr }
+func (rr *AAAA) copy() RR { return &AAAA{*rr.Hdr.copyHeader(), copyIP(rr.AAAA)} }
+func (rr *AAAA) len() int { return rr.Hdr.len() + net.IPv6len }
+
+func (rr *AAAA) String() string {
+ if rr.AAAA == nil {
+ return rr.Hdr.String()
+ }
+ return rr.Hdr.String() + rr.AAAA.String()
+}
+
+type PX struct {
+ Hdr RR_Header
+ Preference uint16
+ Map822 string `dns:"domain-name"`
+ Mapx400 string `dns:"domain-name"`
+}
+
+func (rr *PX) Header() *RR_Header { return &rr.Hdr }
+func (rr *PX) copy() RR { return &PX{*rr.Hdr.copyHeader(), rr.Preference, rr.Map822, rr.Mapx400} }
+func (rr *PX) String() string {
+ return rr.Hdr.String() + strconv.Itoa(int(rr.Preference)) + " " + sprintName(rr.Map822) + " " + sprintName(rr.Mapx400)
+}
+func (rr *PX) len() int { return rr.Hdr.len() + 2 + len(rr.Map822) + 1 + len(rr.Mapx400) + 1 }
+
+type GPOS struct {
+ Hdr RR_Header
+ Longitude string
+ Latitude string
+ Altitude string
+}
+
+func (rr *GPOS) Header() *RR_Header { return &rr.Hdr }
+func (rr *GPOS) copy() RR { return &GPOS{*rr.Hdr.copyHeader(), rr.Longitude, rr.Latitude, rr.Altitude} }
+func (rr *GPOS) len() int {
+ return rr.Hdr.len() + len(rr.Longitude) + len(rr.Latitude) + len(rr.Altitude) + 3
+}
+func (rr *GPOS) String() string {
+ return rr.Hdr.String() + rr.Longitude + " " + rr.Latitude + " " + rr.Altitude
+}
+
+type LOC struct {
+ Hdr RR_Header
+ Version uint8
+ Size uint8
+ HorizPre uint8
+ VertPre uint8
+ Latitude uint32
+ Longitude uint32
+ Altitude uint32
+}
+
+func (rr *LOC) Header() *RR_Header { return &rr.Hdr }
+func (rr *LOC) len() int { return rr.Hdr.len() + 4 + 12 }
+func (rr *LOC) copy() RR {
+ return &LOC{*rr.Hdr.copyHeader(), rr.Version, rr.Size, rr.HorizPre, rr.VertPre, rr.Latitude, rr.Longitude, rr.Altitude}
+}
+
+// cmToM takes a cm value expressed in RFC1876 SIZE mantissa/exponent
+// format and returns a string in m (two decimals for the cm)
+func cmToM(m, e uint8) string {
+ if e < 2 {
+ if e == 1 {
+ m *= 10
+ }
+
+ return fmt.Sprintf("0.%02d", m)
+ }
+
+ s := fmt.Sprintf("%d", m)
+ for e > 2 {
+ s += "0"
+ e -= 1
+ }
+ return s
+}
+
+// String returns a string version of a LOC
+func (rr *LOC) String() string {
+ s := rr.Hdr.String()
+
+ lat := rr.Latitude
+ ns := "N"
+ if lat > LOC_EQUATOR {
+ lat = lat - LOC_EQUATOR
+ } else {
+ ns = "S"
+ lat = LOC_EQUATOR - lat
+ }
+ h := lat / LOC_DEGREES
+ lat = lat % LOC_DEGREES
+ m := lat / LOC_HOURS
+ lat = lat % LOC_HOURS
+ s += fmt.Sprintf("%02d %02d %0.3f %s ", h, m, (float64(lat) / 1000), ns)
+
+ lon := rr.Longitude
+ ew := "E"
+ if lon > LOC_PRIMEMERIDIAN {
+ lon = lon - LOC_PRIMEMERIDIAN
+ } else {
+ ew = "W"
+ lon = LOC_PRIMEMERIDIAN - lon
+ }
+ h = lon / LOC_DEGREES
+ lon = lon % LOC_DEGREES
+ m = lon / LOC_HOURS
+ lon = lon % LOC_HOURS
+ s += fmt.Sprintf("%02d %02d %0.3f %s ", h, m, (float64(lon) / 1000), ew)
+
+ var alt float64 = float64(rr.Altitude) / 100
+ alt -= LOC_ALTITUDEBASE
+ if rr.Altitude%100 != 0 {
+ s += fmt.Sprintf("%.2fm ", alt)
+ } else {
+ s += fmt.Sprintf("%.0fm ", alt)
+ }
+
+ s += cmToM((rr.Size&0xf0)>>4, rr.Size&0x0f) + "m "
+ s += cmToM((rr.HorizPre&0xf0)>>4, rr.HorizPre&0x0f) + "m "
+ s += cmToM((rr.VertPre&0xf0)>>4, rr.VertPre&0x0f) + "m"
+
+ return s
+}
+
+// SIG is identical to RRSIG and nowadays only used for SIG(0), RFC2931.
+type SIG struct {
+ RRSIG
+}
+
+type RRSIG struct {
+ Hdr RR_Header
+ TypeCovered uint16
+ Algorithm uint8
+ Labels uint8
+ OrigTtl uint32
+ Expiration uint32
+ Inception uint32
+ KeyTag uint16
+ SignerName string `dns:"domain-name"`
+ Signature string `dns:"base64"`
+}
+
+func (rr *RRSIG) Header() *RR_Header { return &rr.Hdr }
+func (rr *RRSIG) copy() RR {
+ return &RRSIG{*rr.Hdr.copyHeader(), rr.TypeCovered, rr.Algorithm, rr.Labels, rr.OrigTtl, rr.Expiration, rr.Inception, rr.KeyTag, rr.SignerName, rr.Signature}
+}
+
+func (rr *RRSIG) String() string {
+ s := rr.Hdr.String()
+ s += Type(rr.TypeCovered).String()
+ s += " " + strconv.Itoa(int(rr.Algorithm)) +
+ " " + strconv.Itoa(int(rr.Labels)) +
+ " " + strconv.FormatInt(int64(rr.OrigTtl), 10) +
+ " " + TimeToString(rr.Expiration) +
+ " " + TimeToString(rr.Inception) +
+ " " + strconv.Itoa(int(rr.KeyTag)) +
+ " " + sprintName(rr.SignerName) +
+ " " + rr.Signature
+ return s
+}
+
+func (rr *RRSIG) len() int {
+ return rr.Hdr.len() + len(rr.SignerName) + 1 +
+ base64.StdEncoding.DecodedLen(len(rr.Signature)) + 18
+}
+
+type NSEC struct {
+ Hdr RR_Header
+ NextDomain string `dns:"domain-name"`
+ TypeBitMap []uint16 `dns:"nsec"`
+}
+
+func (rr *NSEC) Header() *RR_Header { return &rr.Hdr }
+func (rr *NSEC) copy() RR {
+ cp := make([]uint16, len(rr.TypeBitMap), cap(rr.TypeBitMap))
+ copy(cp, rr.TypeBitMap)
+ return &NSEC{*rr.Hdr.copyHeader(), rr.NextDomain, cp}
+}
+
+func (rr *NSEC) String() string {
+ s := rr.Hdr.String() + sprintName(rr.NextDomain)
+ for i := 0; i < len(rr.TypeBitMap); i++ {
+ s += " " + Type(rr.TypeBitMap[i]).String()
+ }
+ return s
+}
+
+func (rr *NSEC) len() int {
+ l := rr.Hdr.len() + len(rr.NextDomain) + 1
+ lastwindow := uint32(2 ^ 32 + 1)
+ for _, t := range rr.TypeBitMap {
+ window := t / 256
+ if uint32(window) != lastwindow {
+ l += 1 + 32
+ }
+ lastwindow = uint32(window)
+ }
+ return l
+}
+
+type DLV struct {
+ DS
+}
+
+type CDS struct {
+ DS
+}
+
+type DS struct {
+ Hdr RR_Header
+ KeyTag uint16
+ Algorithm uint8
+ DigestType uint8
+ Digest string `dns:"hex"`
+}
+
+func (rr *DS) Header() *RR_Header { return &rr.Hdr }
+func (rr *DS) len() int { return rr.Hdr.len() + 4 + len(rr.Digest)/2 }
+func (rr *DS) copy() RR {
+ return &DS{*rr.Hdr.copyHeader(), rr.KeyTag, rr.Algorithm, rr.DigestType, rr.Digest}
+}
+
+func (rr *DS) String() string {
+ return rr.Hdr.String() + strconv.Itoa(int(rr.KeyTag)) +
+ " " + strconv.Itoa(int(rr.Algorithm)) +
+ " " + strconv.Itoa(int(rr.DigestType)) +
+ " " + strings.ToUpper(rr.Digest)
+}
+
+type KX struct {
+ Hdr RR_Header
+ Preference uint16
+ Exchanger string `dns:"domain-name"`
+}
+
+func (rr *KX) Header() *RR_Header { return &rr.Hdr }
+func (rr *KX) len() int { return rr.Hdr.len() + 2 + len(rr.Exchanger) + 1 }
+func (rr *KX) copy() RR { return &KX{*rr.Hdr.copyHeader(), rr.Preference, rr.Exchanger} }
+
+func (rr *KX) String() string {
+ return rr.Hdr.String() + strconv.Itoa(int(rr.Preference)) +
+ " " + sprintName(rr.Exchanger)
+}
+
+type TA struct {
+ Hdr RR_Header
+ KeyTag uint16
+ Algorithm uint8
+ DigestType uint8
+ Digest string `dns:"hex"`
+}
+
+func (rr *TA) Header() *RR_Header { return &rr.Hdr }
+func (rr *TA) len() int { return rr.Hdr.len() + 4 + len(rr.Digest)/2 }
+func (rr *TA) copy() RR {
+ return &TA{*rr.Hdr.copyHeader(), rr.KeyTag, rr.Algorithm, rr.DigestType, rr.Digest}
+}
+
+func (rr *TA) String() string {
+ return rr.Hdr.String() + strconv.Itoa(int(rr.KeyTag)) +
+ " " + strconv.Itoa(int(rr.Algorithm)) +
+ " " + strconv.Itoa(int(rr.DigestType)) +
+ " " + strings.ToUpper(rr.Digest)
+}
+
+type TALINK struct {
+ Hdr RR_Header
+ PreviousName string `dns:"domain-name"`
+ NextName string `dns:"domain-name"`
+}
+
+func (rr *TALINK) Header() *RR_Header { return &rr.Hdr }
+func (rr *TALINK) copy() RR { return &TALINK{*rr.Hdr.copyHeader(), rr.PreviousName, rr.NextName} }
+func (rr *TALINK) len() int { return rr.Hdr.len() + len(rr.PreviousName) + len(rr.NextName) + 2 }
+
+func (rr *TALINK) String() string {
+ return rr.Hdr.String() +
+ sprintName(rr.PreviousName) + " " + sprintName(rr.NextName)
+}
+
+type SSHFP struct {
+ Hdr RR_Header
+ Algorithm uint8
+ Type uint8
+ FingerPrint string `dns:"hex"`
+}
+
+func (rr *SSHFP) Header() *RR_Header { return &rr.Hdr }
+func (rr *SSHFP) len() int { return rr.Hdr.len() + 2 + len(rr.FingerPrint)/2 }
+func (rr *SSHFP) copy() RR {
+ return &SSHFP{*rr.Hdr.copyHeader(), rr.Algorithm, rr.Type, rr.FingerPrint}
+}
+
+func (rr *SSHFP) String() string {
+ return rr.Hdr.String() + strconv.Itoa(int(rr.Algorithm)) +
+ " " + strconv.Itoa(int(rr.Type)) +
+ " " + strings.ToUpper(rr.FingerPrint)
+}
+
+type IPSECKEY struct {
+ Hdr RR_Header
+ Precedence uint8
+ GatewayType uint8
+ Algorithm uint8
+ Gateway string `dns:"ipseckey"`
+ PublicKey string `dns:"base64"`
+}
+
+func (rr *IPSECKEY) Header() *RR_Header { return &rr.Hdr }
+func (rr *IPSECKEY) copy() RR {
+ return &IPSECKEY{*rr.Hdr.copyHeader(), rr.Precedence, rr.GatewayType, rr.Algorithm, rr.Gateway, rr.PublicKey}
+}
+
+func (rr *IPSECKEY) String() string {
+ return rr.Hdr.String() + strconv.Itoa(int(rr.Precedence)) +
+ " " + strconv.Itoa(int(rr.GatewayType)) +
+ " " + strconv.Itoa(int(rr.Algorithm)) +
+ " " + rr.Gateway +
+ " " + rr.PublicKey
+}
+
+func (rr *IPSECKEY) len() int {
+ return rr.Hdr.len() + 3 + len(rr.Gateway) + 1 +
+ base64.StdEncoding.DecodedLen(len(rr.PublicKey))
+}
+
+type KEY struct {
+ DNSKEY
+}
+
+type CDNSKEY struct {
+ DNSKEY
+}
+
+type DNSKEY struct {
+ Hdr RR_Header
+ Flags uint16
+ Protocol uint8
+ Algorithm uint8
+ PublicKey string `dns:"base64"`
+}
+
+func (rr *DNSKEY) Header() *RR_Header { return &rr.Hdr }
+func (rr *DNSKEY) len() int {
+ return rr.Hdr.len() + 4 + base64.StdEncoding.DecodedLen(len(rr.PublicKey))
+}
+func (rr *DNSKEY) copy() RR {
+ return &DNSKEY{*rr.Hdr.copyHeader(), rr.Flags, rr.Protocol, rr.Algorithm, rr.PublicKey}
+}
+
+func (rr *DNSKEY) String() string {
+ return rr.Hdr.String() + strconv.Itoa(int(rr.Flags)) +
+ " " + strconv.Itoa(int(rr.Protocol)) +
+ " " + strconv.Itoa(int(rr.Algorithm)) +
+ " " + rr.PublicKey
+}
+
+type RKEY struct {
+ Hdr RR_Header
+ Flags uint16
+ Protocol uint8
+ Algorithm uint8
+ PublicKey string `dns:"base64"`
+}
+
+func (rr *RKEY) Header() *RR_Header { return &rr.Hdr }
+func (rr *RKEY) len() int { return rr.Hdr.len() + 4 + base64.StdEncoding.DecodedLen(len(rr.PublicKey)) }
+func (rr *RKEY) copy() RR {
+ return &RKEY{*rr.Hdr.copyHeader(), rr.Flags, rr.Protocol, rr.Algorithm, rr.PublicKey}
+}
+
+func (rr *RKEY) String() string {
+ return rr.Hdr.String() + strconv.Itoa(int(rr.Flags)) +
+ " " + strconv.Itoa(int(rr.Protocol)) +
+ " " + strconv.Itoa(int(rr.Algorithm)) +
+ " " + rr.PublicKey
+}
+
+type NSAP struct {
+ Hdr RR_Header
+ Length uint8
+ Nsap string
+}
+
+func (rr *NSAP) Header() *RR_Header { return &rr.Hdr }
+func (rr *NSAP) copy() RR { return &NSAP{*rr.Hdr.copyHeader(), rr.Length, rr.Nsap} }
+func (rr *NSAP) String() string { return rr.Hdr.String() + strconv.Itoa(int(rr.Length)) + " " + rr.Nsap }
+func (rr *NSAP) len() int { return rr.Hdr.len() + 1 + len(rr.Nsap) + 1 }
+
+type NSAPPTR struct {
+ Hdr RR_Header
+ Ptr string `dns:"domain-name"`
+}
+
+func (rr *NSAPPTR) Header() *RR_Header { return &rr.Hdr }
+func (rr *NSAPPTR) copy() RR { return &NSAPPTR{*rr.Hdr.copyHeader(), rr.Ptr} }
+func (rr *NSAPPTR) String() string { return rr.Hdr.String() + sprintName(rr.Ptr) }
+func (rr *NSAPPTR) len() int { return rr.Hdr.len() + len(rr.Ptr) }
+
+type NSEC3 struct {
+ Hdr RR_Header
+ Hash uint8
+ Flags uint8
+ Iterations uint16
+ SaltLength uint8
+ Salt string `dns:"size-hex"`
+ HashLength uint8
+ NextDomain string `dns:"size-base32"`
+ TypeBitMap []uint16 `dns:"nsec"`
+}
+
+func (rr *NSEC3) Header() *RR_Header { return &rr.Hdr }
+func (rr *NSEC3) copy() RR {
+ cp := make([]uint16, len(rr.TypeBitMap), cap(rr.TypeBitMap))
+ copy(cp, rr.TypeBitMap)
+ return &NSEC3{*rr.Hdr.copyHeader(), rr.Hash, rr.Flags, rr.Iterations, rr.SaltLength, rr.Salt, rr.HashLength, rr.NextDomain, cp}
+}
+
+func (rr *NSEC3) String() string {
+ s := rr.Hdr.String()
+ s += strconv.Itoa(int(rr.Hash)) +
+ " " + strconv.Itoa(int(rr.Flags)) +
+ " " + strconv.Itoa(int(rr.Iterations)) +
+ " " + saltToString(rr.Salt) +
+ " " + rr.NextDomain
+ for i := 0; i < len(rr.TypeBitMap); i++ {
+ s += " " + Type(rr.TypeBitMap[i]).String()
+ }
+ return s
+}
+
+func (rr *NSEC3) len() int {
+ l := rr.Hdr.len() + 6 + len(rr.Salt)/2 + 1 + len(rr.NextDomain) + 1
+ lastwindow := uint32(2 ^ 32 + 1)
+ for _, t := range rr.TypeBitMap {
+ window := t / 256
+ if uint32(window) != lastwindow {
+ l += 1 + 32
+ }
+ lastwindow = uint32(window)
+ }
+ return l
+}
+
+type NSEC3PARAM struct {
+ Hdr RR_Header
+ Hash uint8
+ Flags uint8
+ Iterations uint16
+ SaltLength uint8
+ Salt string `dns:"hex"`
+}
+
+func (rr *NSEC3PARAM) Header() *RR_Header { return &rr.Hdr }
+func (rr *NSEC3PARAM) len() int { return rr.Hdr.len() + 2 + 4 + 1 + len(rr.Salt)/2 }
+func (rr *NSEC3PARAM) copy() RR {
+ return &NSEC3PARAM{*rr.Hdr.copyHeader(), rr.Hash, rr.Flags, rr.Iterations, rr.SaltLength, rr.Salt}
+}
+
+func (rr *NSEC3PARAM) String() string {
+ s := rr.Hdr.String()
+ s += strconv.Itoa(int(rr.Hash)) +
+ " " + strconv.Itoa(int(rr.Flags)) +
+ " " + strconv.Itoa(int(rr.Iterations)) +
+ " " + saltToString(rr.Salt)
+ return s
+}
+
+type TKEY struct {
+ Hdr RR_Header
+ Algorithm string `dns:"domain-name"`
+ Inception uint32
+ Expiration uint32
+ Mode uint16
+ Error uint16
+ KeySize uint16
+ Key string
+ OtherLen uint16
+ OtherData string
+}
+
+func (rr *TKEY) Header() *RR_Header { return &rr.Hdr }
+func (rr *TKEY) copy() RR {
+ return &TKEY{*rr.Hdr.copyHeader(), rr.Algorithm, rr.Inception, rr.Expiration, rr.Mode, rr.Error, rr.KeySize, rr.Key, rr.OtherLen, rr.OtherData}
+}
+
+func (rr *TKEY) String() string {
+ // It has no presentation format
+ return ""
+}
+
+func (rr *TKEY) len() int {
+ return rr.Hdr.len() + len(rr.Algorithm) + 1 + 4 + 4 + 6 +
+ len(rr.Key) + 2 + len(rr.OtherData)
+}
+
+// RFC3597 represents an unknown/generic RR.
+type RFC3597 struct {
+ Hdr RR_Header
+ Rdata string `dns:"hex"`
+}
+
+func (rr *RFC3597) Header() *RR_Header { return &rr.Hdr }
+func (rr *RFC3597) copy() RR { return &RFC3597{*rr.Hdr.copyHeader(), rr.Rdata} }
+func (rr *RFC3597) len() int { return rr.Hdr.len() + len(rr.Rdata)/2 + 2 }
+
+func (rr *RFC3597) String() string {
+ // Let's call it a hack
+ s := rfc3597Header(rr.Hdr)
+
+ s += "\\# " + strconv.Itoa(len(rr.Rdata)/2) + " " + rr.Rdata
+ return s
+}
+
+func rfc3597Header(h RR_Header) string {
+ var s string
+
+ s += sprintName(h.Name) + "\t"
+ s += strconv.FormatInt(int64(h.Ttl), 10) + "\t"
+ s += "CLASS" + strconv.Itoa(int(h.Class)) + "\t"
+ s += "TYPE" + strconv.Itoa(int(h.Rrtype)) + "\t"
+ return s
+}
+
+type URI struct {
+ Hdr RR_Header
+ Priority uint16
+ Weight uint16
+ Target []string `dns:"txt"`
+}
+
+func (rr *URI) Header() *RR_Header { return &rr.Hdr }
+func (rr *URI) copy() RR {
+ cp := make([]string, len(rr.Target), cap(rr.Target))
+ copy(cp, rr.Target)
+ return &URI{*rr.Hdr.copyHeader(), rr.Weight, rr.Priority, cp}
+}
+
+func (rr *URI) String() string {
+ return rr.Hdr.String() + strconv.Itoa(int(rr.Priority)) +
+ " " + strconv.Itoa(int(rr.Weight)) + sprintTxt(rr.Target)
+}
+
+func (rr *URI) len() int {
+ l := rr.Hdr.len() + 4
+ for _, t := range rr.Target {
+ l += len(t) + 1
+ }
+ return l
+}
+
+type DHCID struct {
+ Hdr RR_Header
+ Digest string `dns:"base64"`
+}
+
+func (rr *DHCID) Header() *RR_Header { return &rr.Hdr }
+func (rr *DHCID) copy() RR { return &DHCID{*rr.Hdr.copyHeader(), rr.Digest} }
+func (rr *DHCID) String() string { return rr.Hdr.String() + rr.Digest }
+func (rr *DHCID) len() int { return rr.Hdr.len() + base64.StdEncoding.DecodedLen(len(rr.Digest)) }
+
+type TLSA struct {
+ Hdr RR_Header
+ Usage uint8
+ Selector uint8
+ MatchingType uint8
+ Certificate string `dns:"hex"`
+}
+
+func (rr *TLSA) Header() *RR_Header { return &rr.Hdr }
+func (rr *TLSA) len() int { return rr.Hdr.len() + 3 + len(rr.Certificate)/2 }
+
+func (rr *TLSA) copy() RR {
+ return &TLSA{*rr.Hdr.copyHeader(), rr.Usage, rr.Selector, rr.MatchingType, rr.Certificate}
+}
+
+func (rr *TLSA) String() string {
+ return rr.Hdr.String() +
+ strconv.Itoa(int(rr.Usage)) +
+ " " + strconv.Itoa(int(rr.Selector)) +
+ " " + strconv.Itoa(int(rr.MatchingType)) +
+ " " + rr.Certificate
+}
+
+type HIP struct {
+ Hdr RR_Header
+ HitLength uint8
+ PublicKeyAlgorithm uint8
+ PublicKeyLength uint16
+ Hit string `dns:"hex"`
+ PublicKey string `dns:"base64"`
+ RendezvousServers []string `dns:"domain-name"`
+}
+
+func (rr *HIP) Header() *RR_Header { return &rr.Hdr }
+func (rr *HIP) copy() RR {
+ cp := make([]string, len(rr.RendezvousServers), cap(rr.RendezvousServers))
+ copy(cp, rr.RendezvousServers)
+ return &HIP{*rr.Hdr.copyHeader(), rr.HitLength, rr.PublicKeyAlgorithm, rr.PublicKeyLength, rr.Hit, rr.PublicKey, cp}
+}
+
+func (rr *HIP) String() string {
+ s := rr.Hdr.String() +
+ strconv.Itoa(int(rr.PublicKeyAlgorithm)) +
+ " " + rr.Hit +
+ " " + rr.PublicKey
+ for _, d := range rr.RendezvousServers {
+ s += " " + sprintName(d)
+ }
+ return s
+}
+
+func (rr *HIP) len() int {
+ l := rr.Hdr.len() + 4 +
+ len(rr.Hit)/2 +
+ base64.StdEncoding.DecodedLen(len(rr.PublicKey))
+ for _, d := range rr.RendezvousServers {
+ l += len(d) + 1
+ }
+ return l
+}
+
+type NINFO struct {
+ Hdr RR_Header
+ ZSData []string `dns:"txt"`
+}
+
+func (rr *NINFO) Header() *RR_Header { return &rr.Hdr }
+func (rr *NINFO) copy() RR {
+ cp := make([]string, len(rr.ZSData), cap(rr.ZSData))
+ copy(cp, rr.ZSData)
+ return &NINFO{*rr.Hdr.copyHeader(), cp}
+}
+
+func (rr *NINFO) String() string { return rr.Hdr.String() + sprintTxt(rr.ZSData) }
+
+func (rr *NINFO) len() int {
+ l := rr.Hdr.len()
+ for _, t := range rr.ZSData {
+ l += len(t) + 1
+ }
+ return l
+}
+
+type WKS struct {
+ Hdr RR_Header
+ Address net.IP `dns:"a"`
+ Protocol uint8
+ BitMap []uint16 `dns:"wks"`
+}
+
+func (rr *WKS) Header() *RR_Header { return &rr.Hdr }
+func (rr *WKS) len() int { return rr.Hdr.len() + net.IPv4len + 1 }
+
+func (rr *WKS) copy() RR {
+ cp := make([]uint16, len(rr.BitMap), cap(rr.BitMap))
+ copy(cp, rr.BitMap)
+ return &WKS{*rr.Hdr.copyHeader(), copyIP(rr.Address), rr.Protocol, cp}
+}
+
+func (rr *WKS) String() (s string) {
+ s = rr.Hdr.String()
+ if rr.Address != nil {
+ s += rr.Address.String()
+ }
+ for i := 0; i < len(rr.BitMap); i++ {
+ // should lookup the port
+ s += " " + strconv.Itoa(int(rr.BitMap[i]))
+ }
+ return s
+}
+
+type NID struct {
+ Hdr RR_Header
+ Preference uint16
+ NodeID uint64
+}
+
+func (rr *NID) Header() *RR_Header { return &rr.Hdr }
+func (rr *NID) copy() RR { return &NID{*rr.Hdr.copyHeader(), rr.Preference, rr.NodeID} }
+func (rr *NID) len() int { return rr.Hdr.len() + 2 + 8 }
+
+func (rr *NID) String() string {
+ s := rr.Hdr.String() + strconv.Itoa(int(rr.Preference))
+ node := fmt.Sprintf("%0.16x", rr.NodeID)
+ s += " " + node[0:4] + ":" + node[4:8] + ":" + node[8:12] + ":" + node[12:16]
+ return s
+}
+
+type L32 struct {
+ Hdr RR_Header
+ Preference uint16
+ Locator32 net.IP `dns:"a"`
+}
+
+func (rr *L32) Header() *RR_Header { return &rr.Hdr }
+func (rr *L32) copy() RR { return &L32{*rr.Hdr.copyHeader(), rr.Preference, copyIP(rr.Locator32)} }
+func (rr *L32) len() int { return rr.Hdr.len() + net.IPv4len }
+
+func (rr *L32) String() string {
+ if rr.Locator32 == nil {
+ return rr.Hdr.String() + strconv.Itoa(int(rr.Preference))
+ }
+ return rr.Hdr.String() + strconv.Itoa(int(rr.Preference)) +
+ " " + rr.Locator32.String()
+}
+
+type L64 struct {
+ Hdr RR_Header
+ Preference uint16
+ Locator64 uint64
+}
+
+func (rr *L64) Header() *RR_Header { return &rr.Hdr }
+func (rr *L64) copy() RR { return &L64{*rr.Hdr.copyHeader(), rr.Preference, rr.Locator64} }
+func (rr *L64) len() int { return rr.Hdr.len() + 2 + 8 }
+
+func (rr *L64) String() string {
+ s := rr.Hdr.String() + strconv.Itoa(int(rr.Preference))
+ node := fmt.Sprintf("%0.16X", rr.Locator64)
+ s += " " + node[0:4] + ":" + node[4:8] + ":" + node[8:12] + ":" + node[12:16]
+ return s
+}
+
+type LP struct {
+ Hdr RR_Header
+ Preference uint16
+ Fqdn string `dns:"domain-name"`
+}
+
+func (rr *LP) Header() *RR_Header { return &rr.Hdr }
+func (rr *LP) copy() RR { return &LP{*rr.Hdr.copyHeader(), rr.Preference, rr.Fqdn} }
+func (rr *LP) len() int { return rr.Hdr.len() + 2 + len(rr.Fqdn) + 1 }
+
+func (rr *LP) String() string {
+ return rr.Hdr.String() + strconv.Itoa(int(rr.Preference)) + " " + sprintName(rr.Fqdn)
+}
+
+type EUI48 struct {
+ Hdr RR_Header
+ Address uint64 `dns:"uint48"`
+}
+
+func (rr *EUI48) Header() *RR_Header { return &rr.Hdr }
+func (rr *EUI48) copy() RR { return &EUI48{*rr.Hdr.copyHeader(), rr.Address} }
+func (rr *EUI48) String() string { return rr.Hdr.String() + euiToString(rr.Address, 48) }
+func (rr *EUI48) len() int { return rr.Hdr.len() + 6 }
+
+type EUI64 struct {
+ Hdr RR_Header
+ Address uint64
+}
+
+func (rr *EUI64) Header() *RR_Header { return &rr.Hdr }
+func (rr *EUI64) copy() RR { return &EUI64{*rr.Hdr.copyHeader(), rr.Address} }
+func (rr *EUI64) String() string { return rr.Hdr.String() + euiToString(rr.Address, 64) }
+func (rr *EUI64) len() int { return rr.Hdr.len() + 8 }
+
+// Support in incomplete - just handle it as unknown record
+/*
+type CAA struct {
+ Hdr RR_Header
+ Flag uint8
+ Tag string
+ Value string `dns:"octet"`
+}
+
+func (rr *CAA) Header() *RR_Header { return &rr.Hdr }
+func (rr *CAA) copy() RR { return &CAA{*rr.Hdr.copyHeader(), rr.Flag, rr.Tag, rr.Value} }
+func (rr *CAA) len() int { return rr.Hdr.len() + 1 + len(rr.Tag) + 1 + len(rr.Value) }
+
+func (rr *CAA) String() string {
+ s := rr.Hdr.String() + strconv.FormatInt(int64(rr.Flag), 10) + " " + rr.Tag
+ s += strconv.QuoteToASCII(rr.Value)
+ return s
+}
+*/
+
+type UID struct {
+ Hdr RR_Header
+ Uid uint32
+}
+
+func (rr *UID) Header() *RR_Header { return &rr.Hdr }
+func (rr *UID) copy() RR { return &UID{*rr.Hdr.copyHeader(), rr.Uid} }
+func (rr *UID) String() string { return rr.Hdr.String() + strconv.FormatInt(int64(rr.Uid), 10) }
+func (rr *UID) len() int { return rr.Hdr.len() + 4 }
+
+type GID struct {
+ Hdr RR_Header
+ Gid uint32
+}
+
+func (rr *GID) Header() *RR_Header { return &rr.Hdr }
+func (rr *GID) copy() RR { return &GID{*rr.Hdr.copyHeader(), rr.Gid} }
+func (rr *GID) String() string { return rr.Hdr.String() + strconv.FormatInt(int64(rr.Gid), 10) }
+func (rr *GID) len() int { return rr.Hdr.len() + 4 }
+
+type UINFO struct {
+ Hdr RR_Header
+ Uinfo string
+}
+
+func (rr *UINFO) Header() *RR_Header { return &rr.Hdr }
+func (rr *UINFO) copy() RR { return &UINFO{*rr.Hdr.copyHeader(), rr.Uinfo} }
+func (rr *UINFO) String() string { return rr.Hdr.String() + sprintTxt([]string{rr.Uinfo}) }
+func (rr *UINFO) len() int { return rr.Hdr.len() + len(rr.Uinfo) + 1 }
+
+type EID struct {
+ Hdr RR_Header
+ Endpoint string `dns:"hex"`
+}
+
+func (rr *EID) Header() *RR_Header { return &rr.Hdr }
+func (rr *EID) copy() RR { return &EID{*rr.Hdr.copyHeader(), rr.Endpoint} }
+func (rr *EID) String() string { return rr.Hdr.String() + strings.ToUpper(rr.Endpoint) }
+func (rr *EID) len() int { return rr.Hdr.len() + len(rr.Endpoint)/2 }
+
+type NIMLOC struct {
+ Hdr RR_Header
+ Locator string `dns:"hex"`
+}
+
+func (rr *NIMLOC) Header() *RR_Header { return &rr.Hdr }
+func (rr *NIMLOC) copy() RR { return &NIMLOC{*rr.Hdr.copyHeader(), rr.Locator} }
+func (rr *NIMLOC) String() string { return rr.Hdr.String() + strings.ToUpper(rr.Locator) }
+func (rr *NIMLOC) len() int { return rr.Hdr.len() + len(rr.Locator)/2 }
+
+type OPENPGPKEY struct {
+ Hdr RR_Header
+ PublicKey string `dns:"base64"`
+}
+
+func (rr *OPENPGPKEY) Header() *RR_Header { return &rr.Hdr }
+func (rr *OPENPGPKEY) copy() RR { return &OPENPGPKEY{*rr.Hdr.copyHeader(), rr.PublicKey} }
+func (rr *OPENPGPKEY) String() string { return rr.Hdr.String() + rr.PublicKey }
+func (rr *OPENPGPKEY) len() int {
+ return rr.Hdr.len() + base64.StdEncoding.DecodedLen(len(rr.PublicKey))
+}
+
+// TimeToString translates the RRSIG's incep. and expir. times to the
+// string representation used when printing the record.
+// It takes serial arithmetic (RFC 1982) into account.
+func TimeToString(t uint32) string {
+ mod := ((int64(t) - time.Now().Unix()) / year68) - 1
+ if mod < 0 {
+ mod = 0
+ }
+ ti := time.Unix(int64(t)-(mod*year68), 0).UTC()
+ return ti.Format("20060102150405")
+}
+
+// StringToTime translates the RRSIG's incep. and expir. times from
+// string values like "20110403154150" to an 32 bit integer.
+// It takes serial arithmetic (RFC 1982) into account.
+func StringToTime(s string) (uint32, error) {
+ t, e := time.Parse("20060102150405", s)
+ if e != nil {
+ return 0, e
+ }
+ mod := (t.Unix() / year68) - 1
+ if mod < 0 {
+ mod = 0
+ }
+ return uint32(t.Unix() - (mod * year68)), nil
+}
+
+// saltToString converts a NSECX salt to uppercase and
+// returns "-" when it is empty
+func saltToString(s string) string {
+ if len(s) == 0 {
+ return "-"
+ }
+ return strings.ToUpper(s)
+}
+
+func euiToString(eui uint64, bits int) (hex string) {
+ switch bits {
+ case 64:
+ hex = fmt.Sprintf("%16.16x", eui)
+ hex = hex[0:2] + "-" + hex[2:4] + "-" + hex[4:6] + "-" + hex[6:8] +
+ "-" + hex[8:10] + "-" + hex[10:12] + "-" + hex[12:14] + "-" + hex[14:16]
+ case 48:
+ hex = fmt.Sprintf("%12.12x", eui)
+ hex = hex[0:2] + "-" + hex[2:4] + "-" + hex[4:6] + "-" + hex[6:8] +
+ "-" + hex[8:10] + "-" + hex[10:12]
+ }
+ return
+}
+
+// copyIP returns a copy of ip.
+func copyIP(ip net.IP) net.IP {
+ p := make(net.IP, len(ip))
+ copy(p, ip)
+ return p
+}
+
+// Map of constructors for each RR type.
+var typeToRR = map[uint16]func() RR{
+ TypeA: func() RR { return new(A) },
+ TypeAAAA: func() RR { return new(AAAA) },
+ TypeAFSDB: func() RR { return new(AFSDB) },
+ // TypeCAA: func() RR { return new(CAA) },
+ TypeCDS: func() RR { return new(CDS) },
+ TypeCERT: func() RR { return new(CERT) },
+ TypeCNAME: func() RR { return new(CNAME) },
+ TypeDHCID: func() RR { return new(DHCID) },
+ TypeDLV: func() RR { return new(DLV) },
+ TypeDNAME: func() RR { return new(DNAME) },
+ TypeKEY: func() RR { return new(KEY) },
+ TypeDNSKEY: func() RR { return new(DNSKEY) },
+ TypeDS: func() RR { return new(DS) },
+ TypeEUI48: func() RR { return new(EUI48) },
+ TypeEUI64: func() RR { return new(EUI64) },
+ TypeGID: func() RR { return new(GID) },
+ TypeGPOS: func() RR { return new(GPOS) },
+ TypeEID: func() RR { return new(EID) },
+ TypeHINFO: func() RR { return new(HINFO) },
+ TypeHIP: func() RR { return new(HIP) },
+ TypeKX: func() RR { return new(KX) },
+ TypeL32: func() RR { return new(L32) },
+ TypeL64: func() RR { return new(L64) },
+ TypeLOC: func() RR { return new(LOC) },
+ TypeLP: func() RR { return new(LP) },
+ TypeMB: func() RR { return new(MB) },
+ TypeMD: func() RR { return new(MD) },
+ TypeMF: func() RR { return new(MF) },
+ TypeMG: func() RR { return new(MG) },
+ TypeMINFO: func() RR { return new(MINFO) },
+ TypeMR: func() RR { return new(MR) },
+ TypeMX: func() RR { return new(MX) },
+ TypeNAPTR: func() RR { return new(NAPTR) },
+ TypeNID: func() RR { return new(NID) },
+ TypeNINFO: func() RR { return new(NINFO) },
+ TypeNIMLOC: func() RR { return new(NIMLOC) },
+ TypeNS: func() RR { return new(NS) },
+ TypeNSAP: func() RR { return new(NSAP) },
+ TypeNSAPPTR: func() RR { return new(NSAPPTR) },
+ TypeNSEC3: func() RR { return new(NSEC3) },
+ TypeNSEC3PARAM: func() RR { return new(NSEC3PARAM) },
+ TypeNSEC: func() RR { return new(NSEC) },
+ TypeOPENPGPKEY: func() RR { return new(OPENPGPKEY) },
+ TypeOPT: func() RR { return new(OPT) },
+ TypePTR: func() RR { return new(PTR) },
+ TypeRKEY: func() RR { return new(RKEY) },
+ TypeRP: func() RR { return new(RP) },
+ TypePX: func() RR { return new(PX) },
+ TypeSIG: func() RR { return new(SIG) },
+ TypeRRSIG: func() RR { return new(RRSIG) },
+ TypeRT: func() RR { return new(RT) },
+ TypeSOA: func() RR { return new(SOA) },
+ TypeSPF: func() RR { return new(SPF) },
+ TypeSRV: func() RR { return new(SRV) },
+ TypeSSHFP: func() RR { return new(SSHFP) },
+ TypeTA: func() RR { return new(TA) },
+ TypeTALINK: func() RR { return new(TALINK) },
+ TypeTKEY: func() RR { return new(TKEY) },
+ TypeTLSA: func() RR { return new(TLSA) },
+ TypeTSIG: func() RR { return new(TSIG) },
+ TypeTXT: func() RR { return new(TXT) },
+ TypeUID: func() RR { return new(UID) },
+ TypeUINFO: func() RR { return new(UINFO) },
+ TypeURI: func() RR { return new(URI) },
+ TypeWKS: func() RR { return new(WKS) },
+ TypeX25: func() RR { return new(X25) },
+}
diff --git a/Godeps/_workspace/src/github.com/miekg/dns/types_test.go b/Godeps/_workspace/src/github.com/miekg/dns/types_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..118612946bce5fcd48794910cb47bf78d70855bd
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/miekg/dns/types_test.go
@@ -0,0 +1,42 @@
+package dns
+
+import (
+ "testing"
+)
+
+func TestCmToM(t *testing.T) {
+ s := cmToM(0, 0)
+ if s != "0.00" {
+ t.Error("0, 0")
+ }
+
+ s = cmToM(1, 0)
+ if s != "0.01" {
+ t.Error("1, 0")
+ }
+
+ s = cmToM(3, 1)
+ if s != "0.30" {
+ t.Error("3, 1")
+ }
+
+ s = cmToM(4, 2)
+ if s != "4" {
+ t.Error("4, 2")
+ }
+
+ s = cmToM(5, 3)
+ if s != "50" {
+ t.Error("5, 3")
+ }
+
+ s = cmToM(7, 5)
+ if s != "7000" {
+ t.Error("7, 5")
+ }
+
+ s = cmToM(9, 9)
+ if s != "90000000" {
+ t.Error("9, 9")
+ }
+}
diff --git a/Godeps/_workspace/src/github.com/miekg/dns/udp.go b/Godeps/_workspace/src/github.com/miekg/dns/udp.go
new file mode 100644
index 0000000000000000000000000000000000000000..0342543bf7316bee0967f971364c9e4454562bd3
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/miekg/dns/udp.go
@@ -0,0 +1,55 @@
+// +build !windows
+
+package dns
+
+import (
+ "net"
+ "syscall"
+)
+
+type sessionUDP struct {
+ raddr *net.UDPAddr
+ context []byte
+}
+
+func (s *sessionUDP) RemoteAddr() net.Addr { return s.raddr }
+
+// setUDPSocketOptions sets the UDP socket options.
+// This function is implemented on a per platform basis. See udp_*.go for more details
+func setUDPSocketOptions(conn *net.UDPConn) error {
+ sa, err := getUDPSocketName(conn)
+ if err != nil {
+ return err
+ }
+ switch sa.(type) {
+ case *syscall.SockaddrInet6:
+ v6only, err := getUDPSocketOptions6Only(conn)
+ if err != nil {
+ return err
+ }
+ setUDPSocketOptions6(conn)
+ if !v6only {
+ setUDPSocketOptions4(conn)
+ }
+ case *syscall.SockaddrInet4:
+ setUDPSocketOptions4(conn)
+ }
+ return nil
+}
+
+// readFromSessionUDP acts just like net.UDPConn.ReadFrom(), but returns a session object instead of a
+// net.UDPAddr.
+func readFromSessionUDP(conn *net.UDPConn, b []byte) (int, *sessionUDP, error) {
+ oob := make([]byte, 40)
+ n, oobn, _, raddr, err := conn.ReadMsgUDP(b, oob)
+ if err != nil {
+ return n, nil, err
+ }
+ return n, &sessionUDP{raddr, oob[:oobn]}, err
+}
+
+// writeToSessionUDP acts just like net.UDPConn.WritetTo(), but uses a *sessionUDP instead of a net.Addr.
+func writeToSessionUDP(conn *net.UDPConn, b []byte, session *sessionUDP) (int, error) {
+ n, _, err := conn.WriteMsgUDP(b, session.context, session.raddr)
+ return n, err
+}
diff --git a/Godeps/_workspace/src/github.com/miekg/dns/udp_linux.go b/Godeps/_workspace/src/github.com/miekg/dns/udp_linux.go
new file mode 100644
index 0000000000000000000000000000000000000000..7a107857e13338f356410720bedcf9617714cefe
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/miekg/dns/udp_linux.go
@@ -0,0 +1,63 @@
+// +build linux
+
+package dns
+
+// See:
+// * http://stackoverflow.com/questions/3062205/setting-the-source-ip-for-a-udp-socket and
+// * http://blog.powerdns.com/2012/10/08/on-binding-datagram-udp-sockets-to-the-any-addresses/
+//
+// Why do we need this: When listening on 0.0.0.0 with UDP so kernel decides what is the outgoing
+// interface, this might not always be the correct one. This code will make sure the egress
+// packet's interface matched the ingress' one.
+
+import (
+ "net"
+ "syscall"
+)
+
+// setUDPSocketOptions4 prepares the v4 socket for sessions.
+func setUDPSocketOptions4(conn *net.UDPConn) error {
+ file, err := conn.File()
+ if err != nil {
+ return err
+ }
+ if err := syscall.SetsockoptInt(int(file.Fd()), syscall.IPPROTO_IP, syscall.IP_PKTINFO, 1); err != nil {
+ return err
+ }
+ return nil
+}
+
+// setUDPSocketOptions6 prepares the v6 socket for sessions.
+func setUDPSocketOptions6(conn *net.UDPConn) error {
+ file, err := conn.File()
+ if err != nil {
+ return err
+ }
+ if err := syscall.SetsockoptInt(int(file.Fd()), syscall.IPPROTO_IPV6, syscall.IPV6_RECVPKTINFO, 1); err != nil {
+ return err
+ }
+ return nil
+}
+
+// getUDPSocketOption6Only return true if the socket is v6 only and false when it is v4/v6 combined
+// (dualstack).
+func getUDPSocketOptions6Only(conn *net.UDPConn) (bool, error) {
+ file, err := conn.File()
+ if err != nil {
+ return false, err
+ }
+ // dual stack. See http://stackoverflow.com/questions/1618240/how-to-support-both-ipv4-and-ipv6-connections
+ v6only, err := syscall.GetsockoptInt(int(file.Fd()), syscall.IPPROTO_IPV6, syscall.IPV6_V6ONLY)
+ if err != nil {
+ return false, err
+ }
+ return v6only == 1, nil
+}
+
+func getUDPSocketName(conn *net.UDPConn) (syscall.Sockaddr, error) {
+ file, err := conn.File()
+ if err != nil {
+ return nil, err
+ }
+ return syscall.Getsockname(int(file.Fd()))
+}
diff --git a/Godeps/_workspace/src/github.com/miekg/dns/udp_other.go b/Godeps/_workspace/src/github.com/miekg/dns/udp_other.go
new file mode 100644
index 0000000000000000000000000000000000000000..c38dd3e7f0edf4d39dec9b684bf4179bc75a69fd
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/miekg/dns/udp_other.go
@@ -0,0 +1,17 @@
+// +build !linux
+
+package dns
+
+import (
+ "net"
+ "syscall"
+)
+
+// These do nothing. See udp_linux.go for an example of how to implement this.
+
+// We tried to adhire to some kind of naming scheme.
+
+func setUDPSocketOptions4(conn *net.UDPConn) error { return nil }
+func setUDPSocketOptions6(conn *net.UDPConn) error { return nil }
+func getUDPSocketOptions6Only(conn *net.UDPConn) (bool, error) { return false, nil }
+func getUDPSocketName(conn *net.UDPConn) (syscall.Sockaddr, error) { return nil, nil }
diff --git a/Godeps/_workspace/src/github.com/miekg/dns/udp_windows.go b/Godeps/_workspace/src/github.com/miekg/dns/udp_windows.go
new file mode 100644
index 0000000000000000000000000000000000000000..4c48723b565faeee4f947b39322177ad8ab57562
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/miekg/dns/udp_windows.go
@@ -0,0 +1,34 @@
+// +build windows
+
+package dns
+
+import "net"
+
+type sessionUDP struct {
+ raddr *net.UDPAddr
+}
+
+// readFromSessionUDP acts just like net.UDPConn.ReadFrom(), but returns a session object instead of a
+// net.UDPAddr.
+func readFromSessionUDP(conn *net.UDPConn, b []byte) (int, *sessionUDP, error) {
+ n, raddr, err := conn.ReadFrom(b)
+ if err != nil {
+ return n, nil, err
+ }
+ session := &sessionUDP{raddr.(*net.UDPAddr)}
+ return n, session, err
+}
+
+// writeToSessionUDP acts just like net.UDPConn.WritetTo(), but uses a *sessionUDP instead of a net.Addr.
+func writeToSessionUDP(conn *net.UDPConn, b []byte, session *sessionUDP) (int, error) {
+ n, err := conn.WriteTo(b, session.raddr)
+ return n, err
+}
+
+func (s *sessionUDP) RemoteAddr() net.Addr { return s.raddr }
+
+// setUDPSocketOptions sets the UDP socket options.
+// This function is implemented on a per platform basis. See udp_*.go for more details
+func setUDPSocketOptions(conn *net.UDPConn) error {
+ return nil
+}
diff --git a/Godeps/_workspace/src/github.com/miekg/dns/update.go b/Godeps/_workspace/src/github.com/miekg/dns/update.go
new file mode 100644
index 0000000000000000000000000000000000000000..275d4e6cc279576b1a930349bc931be570bf40bb
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/miekg/dns/update.go
@@ -0,0 +1,138 @@
+// DYNAMIC UPDATES
+//
+// Dynamic updates reuses the DNS message format, but renames three of
+// the sections. Question is Zone, Answer is Prerequisite, Authority is
+// Update, only the Additional is not renamed. See RFC 2136 for the gory details.
+//
+// You can set a rather complex set of rules for the existence of absence of
+// certain resource records or names in a zone to specify if resource records
+// should be added or removed. The table from RFC 2136 supplemented with the Go
+// DNS function shows which functions exist to specify the prerequisites.
+//
+// 3.2.4 - Table Of Metavalues Used In Prerequisite Section
+//
+// CLASS TYPE RDATA Meaning Function
+// --------------------------------------------------------------
+// ANY ANY empty Name is in use dns.NameUsed
+// ANY rrset empty RRset exists (value indep) dns.RRsetUsed
+// NONE ANY empty Name is not in use dns.NameNotUsed
+// NONE rrset empty RRset does not exist dns.RRsetNotUsed
+// zone rrset rr RRset exists (value dep) dns.Used
+//
+// The prerequisite section can also be left empty.
+// If you have decided on the prerequisites you can tell what RRs should
+// be added or deleted. The next table shows the options you have and
+// what functions to call.
+//
+// 3.4.2.6 - Table Of Metavalues Used In Update Section
+//
+// CLASS TYPE RDATA Meaning Function
+// ---------------------------------------------------------------
+// ANY ANY empty Delete all RRsets from name dns.RemoveName
+// ANY rrset empty Delete an RRset dns.RemoveRRset
+// NONE rrset rr Delete an RR from RRset dns.Remove
+// zone rrset rr Add to an RRset dns.Insert
+//
+package dns
+
+// NameUsed sets the RRs in the prereq section to
+// "Name is in use" RRs. RFC 2136 section 2.4.4.
+func (u *Msg) NameUsed(rr []RR) {
+ u.Answer = make([]RR, len(rr))
+ for i, r := range rr {
+ u.Answer[i] = &ANY{Hdr: RR_Header{Name: r.Header().Name, Ttl: 0, Rrtype: TypeANY, Class: ClassANY}}
+ }
+}
+
+// NameNotUsed sets the RRs in the prereq section to
+// "Name is in not use" RRs. RFC 2136 section 2.4.5.
+func (u *Msg) NameNotUsed(rr []RR) {
+ u.Answer = make([]RR, len(rr))
+ for i, r := range rr {
+ u.Answer[i] = &ANY{Hdr: RR_Header{Name: r.Header().Name, Ttl: 0, Rrtype: TypeANY, Class: ClassNONE}}
+ }
+}
+
+// Used sets the RRs in the prereq section to
+// "RRset exists (value dependent -- with rdata)" RRs. RFC 2136 section 2.4.2.
+func (u *Msg) Used(rr []RR) {
+ if len(u.Question) == 0 {
+ panic("dns: empty question section")
+ }
+ u.Answer = make([]RR, len(rr))
+ for i, r := range rr {
+ u.Answer[i] = r
+ u.Answer[i].Header().Class = u.Question[0].Qclass
+ }
+}
+
+// RRsetUsed sets the RRs in the prereq section to
+// "RRset exists (value independent -- no rdata)" RRs. RFC 2136 section 2.4.1.
+func (u *Msg) RRsetUsed(rr []RR) {
+ u.Answer = make([]RR, len(rr))
+ for i, r := range rr {
+ u.Answer[i] = r
+ u.Answer[i].Header().Class = ClassANY
+ u.Answer[i].Header().Ttl = 0
+ u.Answer[i].Header().Rdlength = 0
+ }
+}
+
+// RRsetNotUsed sets the RRs in the prereq section to
+// "RRset does not exist" RRs. RFC 2136 section 2.4.3.
+func (u *Msg) RRsetNotUsed(rr []RR) {
+ u.Answer = make([]RR, len(rr))
+ for i, r := range rr {
+ u.Answer[i] = r
+ u.Answer[i].Header().Class = ClassNONE
+ u.Answer[i].Header().Rdlength = 0
+ u.Answer[i].Header().Ttl = 0
+ }
+}
+
+// Insert creates a dynamic update packet that adds an complete RRset, see RFC 2136 section 2.5.1.
+func (u *Msg) Insert(rr []RR) {
+ if len(u.Question) == 0 {
+ panic("dns: empty question section")
+ }
+ u.Ns = make([]RR, len(rr))
+ for i, r := range rr {
+ u.Ns[i] = r
+ u.Ns[i].Header().Class = u.Question[0].Qclass
+ }
+}
+
+// RemoveRRset creates a dynamic update packet that deletes an RRset, see RFC 2136 section 2.5.2.
+func (u *Msg) RemoveRRset(rr []RR) {
+ m := make(map[RR_Header]struct{})
+ u.Ns = make([]RR, 0, len(rr))
+ for _, r := range rr {
+ h := *r.Header().copyHeader()
+ h.Class = ClassANY
+ h.Ttl = 0
+ h.Rdlength = 0
+ if _, ok := m[h]; ok {
+ continue
+ }
+ m[h] = struct{}{}
+ u.Ns = append(u.Ns, &ANY{h})
+ }
+}
+
+// RemoveName creates a dynamic update packet that deletes all RRsets of a name, see RFC 2136 section 2.5.3
+func (u *Msg) RemoveName(rr []RR) {
+ u.Ns = make([]RR, len(rr))
+ for i, r := range rr {
+ u.Ns[i] = &ANY{Hdr: RR_Header{Name: r.Header().Name, Ttl: 0, Rrtype: TypeANY, Class: ClassANY}}
+ }
+}
+
+// Remove creates a dynamic update packet deletes RR from the RRSset, see RFC 2136 section 2.5.4
+func (u *Msg) Remove(rr []RR) {
+ u.Ns = make([]RR, len(rr))
+ for i, r := range rr {
+ u.Ns[i] = r
+ u.Ns[i].Header().Class = ClassNONE
+ u.Ns[i].Header().Ttl = 0
+ }
+}
diff --git a/Godeps/_workspace/src/github.com/miekg/dns/update_test.go b/Godeps/_workspace/src/github.com/miekg/dns/update_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..fc22536e38e6af701432ef04680d7af76b73d24c
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/miekg/dns/update_test.go
@@ -0,0 +1,105 @@
+package dns
+
+import (
+ "bytes"
+ "testing"
+)
+
+func TestDynamicUpdateParsing(t *testing.T) {
+ prefix := "example.com. IN "
+ for _, typ := range TypeToString {
+ if typ == "CAA" || typ == "OPT" || typ == "AXFR" || typ == "IXFR" || typ == "ANY" || typ == "TKEY" ||
+ typ == "TSIG" || typ == "ISDN" || typ == "UNSPEC" || typ == "NULL" || typ == "ATMA" {
+ continue
+ }
+ r, e := NewRR(prefix + typ)
+ if e != nil {
+ t.Log("failure to parse: " + prefix + typ)
+ t.Fail()
+ } else {
+ t.Logf("parsed: %s", r.String())
+ }
+ }
+}
+
+func TestDynamicUpdateUnpack(t *testing.T) {
+ // From https://github.com/miekg/dns/issues/150#issuecomment-62296803
+ // It should be an update message for the zone "example.",
+ // deleting the A RRset "example." and then adding an A record at "example.".
+ // class ANY, TYPE A
+ buf := []byte{171, 68, 40, 0, 0, 1, 0, 0, 0, 2, 0, 0, 7, 101, 120, 97, 109, 112, 108, 101, 0, 0, 6, 0, 1, 192, 12, 0, 1, 0, 255, 0, 0, 0, 0, 0, 0, 192, 12, 0, 1, 0, 1, 0, 0, 0, 0, 0, 4, 127, 0, 0, 1}
+ msg := new(Msg)
+ err := msg.Unpack(buf)
+ if err != nil {
+ t.Log("failed to unpack: " + err.Error() + "\n" + msg.String())
+ t.Fail()
+ }
+}
+
+func TestDynamicUpdateZeroRdataUnpack(t *testing.T) {
+ m := new(Msg)
+ rr := &RR_Header{Name: ".", Rrtype: 0, Class: 1, Ttl: ^uint32(0), Rdlength: 0}
+ m.Answer = []RR{rr, rr, rr, rr, rr}
+ m.Ns = m.Answer
+ for n, s := range TypeToString {
+ rr.Rrtype = n
+ bytes, err := m.Pack()
+ if err != nil {
+ t.Logf("failed to pack %s: %v", s, err)
+ t.Fail()
+ continue
+ }
+ if err := new(Msg).Unpack(bytes); err != nil {
+ t.Logf("failed to unpack %s: %v", s, err)
+ t.Fail()
+ }
+ }
+}
+
+func TestRemoveRRset(t *testing.T) {
+ // Should add a zero data RR in Class ANY with a TTL of 0
+ // for each set mentioned in the RRs provided to it.
+ rr, err := NewRR(". 100 IN A 127.0.0.1")
+ if err != nil {
+ t.Fatalf("Error constructing RR: %v", err)
+ }
+ m := new(Msg)
+ m.Ns = []RR{&RR_Header{Name: ".", Rrtype: TypeA, Class: ClassANY, Ttl: 0, Rdlength: 0}}
+ expectstr := m.String()
+ expect, err := m.Pack()
+ if err != nil {
+ t.Fatalf("Error packing expected msg: %v", err)
+ }
+
+ m.Ns = nil
+ m.RemoveRRset([]RR{rr})
+ actual, err := m.Pack()
+ if err != nil {
+ t.Fatalf("Error packing actual msg: %v", err)
+ }
+ if !bytes.Equal(actual, expect) {
+ tmp := new(Msg)
+ if err := tmp.Unpack(actual); err != nil {
+ t.Fatalf("Error unpacking actual msg: %v", err)
+ }
+ t.Logf("Expected msg:\n%s", expectstr)
+ t.Logf("Actual msg:\n%v", tmp)
+ t.Fail()
+ }
+
+ m.Ns = nil
+ m.RemoveRRset([]RR{rr, rr})
+ actual, err = m.Pack()
+ if err != nil {
+ t.Fatalf("Error packing actual msg: %v", err)
+ }
+ if !bytes.Equal(actual, expect) {
+ tmp := new(Msg)
+ if err := tmp.Unpack(actual); err != nil {
+ t.Fatalf("Error unpacking actual msg: %v", err)
+ }
+ t.Logf("Expected msg:\n%v", expectstr)
+ t.Logf("Actual msg:\n%v", tmp)
+ t.Fail()
+ }
+}
diff --git a/Godeps/_workspace/src/github.com/miekg/dns/xfr.go b/Godeps/_workspace/src/github.com/miekg/dns/xfr.go
new file mode 100644
index 0000000000000000000000000000000000000000..57bfb1676f9174b60a4368b06a96452c6ca76934
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/miekg/dns/xfr.go
@@ -0,0 +1,236 @@
+package dns
+
+import (
+ "time"
+)
+
+// Envelope is used when doing a zone transfer with a remote server.
+type Envelope struct {
+ RR []RR // The set of RRs in the answer section of the xfr reply message.
+ Error error // If something went wrong, this contains the error.
+}
+
+// A Transfer defines parameters that are used during a zone transfer.
+type Transfer struct {
+ *Conn
+ DialTimeout time.Duration // net.DialTimeout (ns), defaults to 2 * 1e9
+ ReadTimeout time.Duration // net.Conn.SetReadTimeout value for connections (ns), defaults to 2 * 1e9
+ WriteTimeout time.Duration // net.Conn.SetWriteTimeout value for connections (ns), defaults to 2 * 1e9
+ TsigSecret map[string]string // Secret(s) for Tsig map[<zonename>]<base64 secret>, zonename must be fully qualified
+ tsigTimersOnly bool
+}
+
+// Think we need to away to stop the transfer
+
+// In performs an incoming transfer with the server in a.
+func (t *Transfer) In(q *Msg, a string) (env chan *Envelope, err error) {
+ timeout := dnsTimeout
+ if t.DialTimeout != 0 {
+ timeout = t.DialTimeout
+ }
+ t.Conn, err = DialTimeout("tcp", a, timeout)
+ if err != nil {
+ return nil, err
+ }
+ if err := t.WriteMsg(q); err != nil {
+ return nil, err
+ }
+ env = make(chan *Envelope)
+ go func() {
+ if q.Question[0].Qtype == TypeAXFR {
+ go t.inAxfr(q.Id, env)
+ return
+ }
+ if q.Question[0].Qtype == TypeIXFR {
+ go t.inIxfr(q.Id, env)
+ return
+ }
+ }()
+ return env, nil
+}
+
+func (t *Transfer) inAxfr(id uint16, c chan *Envelope) {
+ first := true
+ defer t.Close()
+ defer close(c)
+ timeout := dnsTimeout
+ if t.ReadTimeout != 0 {
+ timeout = t.ReadTimeout
+ }
+ for {
+ t.Conn.SetReadDeadline(time.Now().Add(timeout))
+ in, err := t.ReadMsg()
+ if err != nil {
+ c <- &Envelope{nil, err}
+ return
+ }
+ if id != in.Id {
+ c <- &Envelope{in.Answer, ErrId}
+ return
+ }
+ if first {
+ if !isSOAFirst(in) {
+ c <- &Envelope{in.Answer, ErrSoa}
+ return
+ }
+ first = !first
+ // only one answer that is SOA, receive more
+ if len(in.Answer) == 1 {
+ t.tsigTimersOnly = true
+ c <- &Envelope{in.Answer, nil}
+ continue
+ }
+ }
+
+ if !first {
+ t.tsigTimersOnly = true // Subsequent envelopes use this.
+ if isSOALast(in) {
+ c <- &Envelope{in.Answer, nil}
+ return
+ }
+ c <- &Envelope{in.Answer, nil}
+ }
+ }
+ panic("dns: not reached")
+}
+
+func (t *Transfer) inIxfr(id uint16, c chan *Envelope) {
+ serial := uint32(0) // The first serial seen is the current server serial
+ first := true
+ defer t.Close()
+ defer close(c)
+ timeout := dnsTimeout
+ if t.ReadTimeout != 0 {
+ timeout = t.ReadTimeout
+ }
+ for {
+ t.SetReadDeadline(time.Now().Add(timeout))
+ in, err := t.ReadMsg()
+ if err != nil {
+ c <- &Envelope{in.Answer, err}
+ return
+ }
+ if id != in.Id {
+ c <- &Envelope{in.Answer, ErrId}
+ return
+ }
+ if first {
+ // A single SOA RR signals "no changes"
+ if len(in.Answer) == 1 && isSOAFirst(in) {
+ c <- &Envelope{in.Answer, nil}
+ return
+ }
+
+ // Check if the returned answer is ok
+ if !isSOAFirst(in) {
+ c <- &Envelope{in.Answer, ErrSoa}
+ return
+ }
+ // This serial is important
+ serial = in.Answer[0].(*SOA).Serial
+ first = !first
+ }
+
+ // Now we need to check each message for SOA records, to see what we need to do
+ if !first {
+ t.tsigTimersOnly = true
+ // If the last record in the IXFR contains the servers' SOA, we should quit
+ if v, ok := in.Answer[len(in.Answer)-1].(*SOA); ok {
+ if v.Serial == serial {
+ c <- &Envelope{in.Answer, nil}
+ return
+ }
+ }
+ c <- &Envelope{in.Answer, nil}
+ }
+ }
+}
+
+// Out performs an outgoing transfer with the client connecting in w.
+// Basic use pattern:
+//
+// ch := make(chan *dns.Envelope)
+// tr := new(dns.Transfer)
+// tr.Out(w, r, ch)
+// c <- &dns.Envelope{RR: []dns.RR{soa, rr1, rr2, rr3, soa}}
+// close(ch)
+// w.Hijack()
+// // w.Close() // Client closes connection
+//
+// The server is responsible for sending the correct sequence of RRs through the
+// channel ch.
+func (t *Transfer) Out(w ResponseWriter, q *Msg, ch chan *Envelope) error {
+ r := new(Msg)
+ // Compress?
+ r.SetReply(q)
+ r.Authoritative = true
+
+ go func() {
+ for x := range ch {
+ // assume it fits TODO(miek): fix
+ r.Answer = append(r.Answer, x.RR...)
+ if err := w.WriteMsg(r); err != nil {
+ return
+ }
+ }
+ w.TsigTimersOnly(true)
+ r.Answer = nil
+ }()
+ return nil
+}
+
+// ReadMsg reads a message from the transfer connection t.
+func (t *Transfer) ReadMsg() (*Msg, error) {
+ m := new(Msg)
+ p := make([]byte, MaxMsgSize)
+ n, err := t.Read(p)
+ if err != nil && n == 0 {
+ return nil, err
+ }
+ p = p[:n]
+ if err := m.Unpack(p); err != nil {
+ return nil, err
+ }
+ if ts := m.IsTsig(); ts != nil && t.TsigSecret != nil {
+ if _, ok := t.TsigSecret[ts.Hdr.Name]; !ok {
+ return m, ErrSecret
+ }
+ // Need to work on the original message p, as that was used to calculate the tsig.
+ err = TsigVerify(p, t.TsigSecret[ts.Hdr.Name], t.tsigRequestMAC, t.tsigTimersOnly)
+ }
+ return m, err
+}
+
+// WriteMsg writes a message through the transfer connection t.
+func (t *Transfer) WriteMsg(m *Msg) (err error) {
+ var out []byte
+ if ts := m.IsTsig(); ts != nil && t.TsigSecret != nil {
+ if _, ok := t.TsigSecret[ts.Hdr.Name]; !ok {
+ return ErrSecret
+ }
+ out, t.tsigRequestMAC, err = TsigGenerate(m, t.TsigSecret[ts.Hdr.Name], t.tsigRequestMAC, t.tsigTimersOnly)
+ } else {
+ out, err = m.Pack()
+ }
+ if err != nil {
+ return err
+ }
+ if _, err = t.Write(out); err != nil {
+ return err
+ }
+ return nil
+}
+
+func isSOAFirst(in *Msg) bool {
+ if len(in.Answer) > 0 {
+ return in.Answer[0].Header().Rrtype == TypeSOA
+ }
+ return false
+}
+
+func isSOALast(in *Msg) bool {
+ if len(in.Answer) > 0 {
+ return in.Answer[len(in.Answer)-1].Header().Rrtype == TypeSOA
+ }
+ return false
+}
diff --git a/Godeps/_workspace/src/github.com/miekg/dns/zgenerate.go b/Godeps/_workspace/src/github.com/miekg/dns/zgenerate.go
new file mode 100644
index 0000000000000000000000000000000000000000..7f1183e87403fc43a678f914d1568acf879d558f
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/miekg/dns/zgenerate.go
@@ -0,0 +1,157 @@
+package dns
+
+import (
+ "fmt"
+ "strconv"
+ "strings"
+)
+
+// Parse the $GENERATE statement as used in BIND9 zones.
+// See http://www.zytrax.com/books/dns/ch8/generate.html for instance.
+// We are called after '$GENERATE '. After which we expect:
+// * the range (12-24/2)
+// * lhs (ownername)
+// * [[ttl][class]]
+// * type
+// * rhs (rdata)
+// But we are lazy here, only the range is parsed *all* occurences
+// of $ after that are interpreted.
+// Any error are returned as a string value, the empty string signals
+// "no error".
+func generate(l lex, c chan lex, t chan *Token, o string) string {
+ step := 1
+ if i := strings.IndexAny(l.token, "/"); i != -1 {
+ if i+1 == len(l.token) {
+ return "bad step in $GENERATE range"
+ }
+ if s, e := strconv.Atoi(l.token[i+1:]); e != nil {
+ return "bad step in $GENERATE range"
+ } else {
+ if s < 0 {
+ return "bad step in $GENERATE range"
+ }
+ step = s
+ }
+ l.token = l.token[:i]
+ }
+ sx := strings.SplitN(l.token, "-", 2)
+ if len(sx) != 2 {
+ return "bad start-stop in $GENERATE range"
+ }
+ start, err := strconv.Atoi(sx[0])
+ if err != nil {
+ return "bad start in $GENERATE range"
+ }
+ end, err := strconv.Atoi(sx[1])
+ if err != nil {
+ return "bad stop in $GENERATE range"
+ }
+ if end < 0 || start < 0 || end <= start {
+ return "bad range in $GENERATE range"
+ }
+
+ <-c // _BLANK
+ // Create a complete new string, which we then parse again.
+ s := ""
+BuildRR:
+ l = <-c
+ if l.value != _NEWLINE && l.value != _EOF {
+ s += l.token
+ goto BuildRR
+ }
+ for i := start; i <= end; i += step {
+ var (
+ escape bool
+ dom string
+ mod string
+ err string
+ offset int
+ )
+
+ for j := 0; j < len(s); j++ { // No 'range' because we need to jump around
+ switch s[j] {
+ case '\\':
+ if escape {
+ dom += "\\"
+ escape = false
+ continue
+ }
+ escape = true
+ case '$':
+ mod = "%d"
+ offset = 0
+ if escape {
+ dom += "$"
+ escape = false
+ continue
+ }
+ escape = false
+ if j+1 >= len(s) { // End of the string
+ dom += fmt.Sprintf(mod, i+offset)
+ continue
+ } else {
+ if s[j+1] == '$' {
+ dom += "$"
+ j++
+ continue
+ }
+ }
+ // Search for { and }
+ if s[j+1] == '{' { // Modifier block
+ sep := strings.Index(s[j+2:], "}")
+ if sep == -1 {
+ return "bad modifier in $GENERATE"
+ }
+ mod, offset, err = modToPrintf(s[j+2 : j+2+sep])
+ if err != "" {
+ return err
+ }
+ j += 2 + sep // Jump to it
+ }
+ dom += fmt.Sprintf(mod, i+offset)
+ default:
+ if escape { // Pretty useless here
+ escape = false
+ continue
+ }
+ dom += string(s[j])
+ }
+ }
+ // Re-parse the RR and send it on the current channel t
+ rx, e := NewRR("$ORIGIN " + o + "\n" + dom)
+ if e != nil {
+ return e.(*ParseError).err
+ }
+ t <- &Token{RR: rx}
+ // Its more efficient to first built the rrlist and then parse it in
+ // one go! But is this a problem?
+ }
+ return ""
+}
+
+// Convert a $GENERATE modifier 0,0,d to something Printf can deal with.
+func modToPrintf(s string) (string, int, string) {
+ xs := strings.SplitN(s, ",", 3)
+ if len(xs) != 3 {
+ return "", 0, "bad modifier in $GENERATE"
+ }
+ // xs[0] is offset, xs[1] is width, xs[2] is base
+ if xs[2] != "o" && xs[2] != "d" && xs[2] != "x" && xs[2] != "X" {
+ return "", 0, "bad base in $GENERATE"
+ }
+ offset, err := strconv.Atoi(xs[0])
+ if err != nil {
+ return "", 0, "bad offset in $GENERATE"
+ }
+ width, err := strconv.Atoi(xs[1])
+ if err != nil {
+ return "", offset, "bad width in $GENERATE"
+ }
+ switch {
+ case width < 0:
+ return "", offset, "bad width in $GENERATE"
+ case width == 0:
+ return "%" + xs[1] + xs[2], offset, ""
+ }
+ return "%0" + xs[1] + xs[2], offset, ""
+}
diff --git a/Godeps/_workspace/src/github.com/miekg/dns/zscan.go b/Godeps/_workspace/src/github.com/miekg/dns/zscan.go
new file mode 100644
index 0000000000000000000000000000000000000000..7ba51986953c505bb8839b178f8490aedd1bf2a3
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/miekg/dns/zscan.go
@@ -0,0 +1,956 @@
+package dns
+
+import (
+ "io"
+ "log"
+ "os"
+ "strconv"
+ "strings"
+)
+
+type debugging bool
+
+const debug debugging = false
+
+func (d debugging) Printf(format string, args ...interface{}) {
+ if d {
+ log.Printf(format, args...)
+ }
+}
+
+const maxTok = 2048 // Largest token we can return.
+const maxUint16 = 1<<16 - 1
+
+// Tokinize a RFC 1035 zone file. The tokenizer will normalize it:
+// * Add ownernames if they are left blank;
+// * Suppress sequences of spaces;
+// * Make each RR fit on one line (_NEWLINE is send as last)
+// * Handle comments: ;
+// * Handle braces - anywhere.
+const (
+ // Zonefile
+ _EOF = iota
+ _STRING
+ _BLANK
+ _QUOTE
+ _NEWLINE
+ _RRTYPE
+ _OWNER
+ _CLASS
+ _DIRORIGIN // $ORIGIN
+ _DIRTTL // $TTL
+ _DIRINCLUDE // $INCLUDE
+ _DIRGENERATE // $GENERATE
+
+ // Privatekey file
+ _VALUE
+ _KEY
+
+ _EXPECT_OWNER_DIR // Ownername
+ _EXPECT_OWNER_BL // Whitespace after the ownername
+ _EXPECT_ANY // Expect rrtype, ttl or class
+ _EXPECT_ANY_NOCLASS // Expect rrtype or ttl
+ _EXPECT_ANY_NOCLASS_BL // The whitespace after _EXPECT_ANY_NOCLASS
+ _EXPECT_ANY_NOTTL // Expect rrtype or class
+ _EXPECT_ANY_NOTTL_BL // Whitespace after _EXPECT_ANY_NOTTL
+ _EXPECT_RRTYPE // Expect rrtype
+ _EXPECT_RRTYPE_BL // Whitespace BEFORE rrtype
+ _EXPECT_RDATA // The first element of the rdata
+ _EXPECT_DIRTTL_BL // Space after directive $TTL
+ _EXPECT_DIRTTL // Directive $TTL
+ _EXPECT_DIRORIGIN_BL // Space after directive $ORIGIN
+ _EXPECT_DIRORIGIN // Directive $ORIGIN
+ _EXPECT_DIRINCLUDE_BL // Space after directive $INCLUDE
+ _EXPECT_DIRINCLUDE // Directive $INCLUDE
+ _EXPECT_DIRGENERATE // Directive $GENERATE
+ _EXPECT_DIRGENERATE_BL // Space after directive $GENERATE
+)
+
+// ParseError is a parsing error. It contains the parse error and the location in the io.Reader
+// where the error occured.
+type ParseError struct {
+ file string
+ err string
+ lex lex
+}
+
+func (e *ParseError) Error() (s string) {
+ if e.file != "" {
+ s = e.file + ": "
+ }
+ s += "dns: " + e.err + ": " + strconv.QuoteToASCII(e.lex.token) + " at line: " +
+ strconv.Itoa(e.lex.line) + ":" + strconv.Itoa(e.lex.column)
+ return
+}
+
+type lex struct {
+ token string // text of the token
+ tokenUpper string // uppercase text of the token
+ length int // lenght of the token
+ err bool // when true, token text has lexer error
+ value uint8 // value: _STRING, _BLANK, etc.
+ line int // line in the file
+ column int // column in the file
+ torc uint16 // type or class as parsed in the lexer, we only need to look this up in the grammar
+ comment string // any comment text seen
+}
+
+// *Tokens are returned when a zone file is parsed.
+type Token struct {
+ RR // the scanned resource record when error is not nil
+ Error *ParseError // when an error occured, this has the error specifics
+ Comment string // a potential comment positioned after the RR and on the same line
+}
+
+// NewRR reads the RR contained in the string s. Only the first RR is returned.
+// The class defaults to IN and TTL defaults to 3600. The full zone file
+// syntax like $TTL, $ORIGIN, etc. is supported.
+// All fields of the returned RR are set, except RR.Header().Rdlength which is set to 0.
+func NewRR(s string) (RR, error) {
+ if s[len(s)-1] != '\n' { // We need a closing newline
+ return ReadRR(strings.NewReader(s+"\n"), "")
+ }
+ return ReadRR(strings.NewReader(s), "")
+}
+
+// ReadRR reads the RR contained in q.
+// See NewRR for more documentation.
+func ReadRR(q io.Reader, filename string) (RR, error) {
+ r := <-parseZoneHelper(q, ".", filename, 1)
+ if r.Error != nil {
+ return nil, r.Error
+ }
+ return r.RR, nil
+}
+
+// ParseZone reads a RFC 1035 style one from r. It returns *Tokens on the
+// returned channel, which consist out the parsed RR, a potential comment or an error.
+// If there is an error the RR is nil. The string file is only used
+// in error reporting. The string origin is used as the initial origin, as
+// if the file would start with: $ORIGIN origin .
+// The directives $INCLUDE, $ORIGIN, $TTL and $GENERATE are supported.
+// The channel t is closed by ParseZone when the end of r is reached.
+//
+// Basic usage pattern when reading from a string (z) containing the
+// zone data:
+//
+// for x := range dns.ParseZone(strings.NewReader(z), "", "") {
+// if x.Error != nil {
+// // Do something with x.RR
+// }
+// }
+//
+// Comments specified after an RR (and on the same line!) are returned too:
+//
+// foo. IN A 10.0.0.1 ; this is a comment
+//
+// The text "; this is comment" is returned in Token.Comment . Comments inside the
+// RR are discarded. Comments on a line by themselves are discarded too.
+func ParseZone(r io.Reader, origin, file string) chan *Token {
+ return parseZoneHelper(r, origin, file, 10000)
+}
+
+func parseZoneHelper(r io.Reader, origin, file string, chansize int) chan *Token {
+ t := make(chan *Token, chansize)
+ go parseZone(r, origin, file, t, 0)
+ return t
+}
+
+func parseZone(r io.Reader, origin, f string, t chan *Token, include int) {
+ defer func() {
+ if include == 0 {
+ close(t)
+ }
+ }()
+ s := scanInit(r)
+ c := make(chan lex, 1000)
+ // Start the lexer
+ go zlexer(s, c)
+ // 6 possible beginnings of a line, _ is a space
+ // 0. _RRTYPE -> all omitted until the rrtype
+ // 1. _OWNER _ _RRTYPE -> class/ttl omitted
+ // 2. _OWNER _ _STRING _ _RRTYPE -> class omitted
+ // 3. _OWNER _ _STRING _ _CLASS _ _RRTYPE -> ttl/class
+ // 4. _OWNER _ _CLASS _ _RRTYPE -> ttl omitted
+ // 5. _OWNER _ _CLASS _ _STRING _ _RRTYPE -> class/ttl (reversed)
+ // After detecting these, we know the _RRTYPE so we can jump to functions
+ // handling the rdata for each of these types.
+
+ if origin == "" {
+ origin = "."
+ }
+ origin = Fqdn(origin)
+ if _, ok := IsDomainName(origin); !ok {
+ t <- &Token{Error: &ParseError{f, "bad initial origin name", lex{}}}
+ return
+ }
+
+ st := _EXPECT_OWNER_DIR // initial state
+ var h RR_Header
+ var defttl uint32 = defaultTtl
+ var prevName string
+ for l := range c {
+ // Lexer spotted an error already
+ if l.err == true {
+ t <- &Token{Error: &ParseError{f, l.token, l}}
+ return
+
+ }
+ switch st {
+ case _EXPECT_OWNER_DIR:
+ // We can also expect a directive, like $TTL or $ORIGIN
+ h.Ttl = defttl
+ h.Class = ClassINET
+ switch l.value {
+ case _NEWLINE: // Empty line
+ st = _EXPECT_OWNER_DIR
+ case _OWNER:
+ h.Name = l.token
+ if l.token[0] == '@' {
+ h.Name = origin
+ prevName = h.Name
+ st = _EXPECT_OWNER_BL
+ break
+ }
+ if h.Name[l.length-1] != '.' {
+ h.Name = appendOrigin(h.Name, origin)
+ }
+ _, ok := IsDomainName(l.token)
+ if !ok {
+ t <- &Token{Error: &ParseError{f, "bad owner name", l}}
+ return
+ }
+ prevName = h.Name
+ st = _EXPECT_OWNER_BL
+ case _DIRTTL:
+ st = _EXPECT_DIRTTL_BL
+ case _DIRORIGIN:
+ st = _EXPECT_DIRORIGIN_BL
+ case _DIRINCLUDE:
+ st = _EXPECT_DIRINCLUDE_BL
+ case _DIRGENERATE:
+ st = _EXPECT_DIRGENERATE_BL
+ case _RRTYPE: // Everthing has been omitted, this is the first thing on the line
+ h.Name = prevName
+ h.Rrtype = l.torc
+ st = _EXPECT_RDATA
+ case _CLASS: // First thing on the line is the class
+ h.Name = prevName
+ h.Class = l.torc
+ st = _EXPECT_ANY_NOCLASS_BL
+ case _BLANK:
+ // Discard, can happen when there is nothing on the
+ // line except the RR type
+ case _STRING: // First thing on the is the ttl
+ if ttl, ok := stringToTtl(l.token); !ok {
+ t <- &Token{Error: &ParseError{f, "not a TTL", l}}
+ return
+ } else {
+ h.Ttl = ttl
+ // Don't about the defttl, we should take the $TTL value
+ // defttl = ttl
+ }
+ st = _EXPECT_ANY_NOTTL_BL
+
+ default:
+ t <- &Token{Error: &ParseError{f, "syntax error at beginning", l}}
+ return
+ }
+ case _EXPECT_DIRINCLUDE_BL:
+ if l.value != _BLANK {
+ t <- &Token{Error: &ParseError{f, "no blank after $INCLUDE-directive", l}}
+ return
+ }
+ st = _EXPECT_DIRINCLUDE
+ case _EXPECT_DIRINCLUDE:
+ if l.value != _STRING {
+ t <- &Token{Error: &ParseError{f, "expecting $INCLUDE value, not this...", l}}
+ return
+ }
+ neworigin := origin // There may be optionally a new origin set after the filename, if not use current one
+ l := <-c
+ switch l.value {
+ case _BLANK:
+ l := <-c
+ if l.value == _STRING {
+ if _, ok := IsDomainName(l.token); !ok {
+ t <- &Token{Error: &ParseError{f, "bad origin name", l}}
+ return
+ }
+ // a new origin is specified.
+ if l.token[l.length-1] != '.' {
+ if origin != "." { // Prevent .. endings
+ neworigin = l.token + "." + origin
+ } else {
+ neworigin = l.token + origin
+ }
+ } else {
+ neworigin = l.token
+ }
+ }
+ case _NEWLINE, _EOF:
+ // Ok
+ default:
+ t <- &Token{Error: &ParseError{f, "garbage after $INCLUDE", l}}
+ return
+ }
+ // Start with the new file
+ r1, e1 := os.Open(l.token)
+ if e1 != nil {
+ t <- &Token{Error: &ParseError{f, "failed to open `" + l.token + "'", l}}
+ return
+ }
+ if include+1 > 7 {
+ t <- &Token{Error: &ParseError{f, "too deeply nested $INCLUDE", l}}
+ return
+ }
+ parseZone(r1, l.token, neworigin, t, include+1)
+ st = _EXPECT_OWNER_DIR
+ case _EXPECT_DIRTTL_BL:
+ if l.value != _BLANK {
+ t <- &Token{Error: &ParseError{f, "no blank after $TTL-directive", l}}
+ return
+ }
+ st = _EXPECT_DIRTTL
+ case _EXPECT_DIRTTL:
+ if l.value != _STRING {
+ t <- &Token{Error: &ParseError{f, "expecting $TTL value, not this...", l}}
+ return
+ }
+ if e, _ := slurpRemainder(c, f); e != nil {
+ t <- &Token{Error: e}
+ return
+ }
+ if ttl, ok := stringToTtl(l.token); !ok {
+ t <- &Token{Error: &ParseError{f, "expecting $TTL value, not this...", l}}
+ return
+ } else {
+ defttl = ttl
+ }
+ st = _EXPECT_OWNER_DIR
+ case _EXPECT_DIRORIGIN_BL:
+ if l.value != _BLANK {
+ t <- &Token{Error: &ParseError{f, "no blank after $ORIGIN-directive", l}}
+ return
+ }
+ st = _EXPECT_DIRORIGIN
+ case _EXPECT_DIRORIGIN:
+ if l.value != _STRING {
+ t <- &Token{Error: &ParseError{f, "expecting $ORIGIN value, not this...", l}}
+ return
+ }
+ if e, _ := slurpRemainder(c, f); e != nil {
+ t <- &Token{Error: e}
+ }
+ if _, ok := IsDomainName(l.token); !ok {
+ t <- &Token{Error: &ParseError{f, "bad origin name", l}}
+ return
+ }
+ if l.token[l.length-1] != '.' {
+ if origin != "." { // Prevent .. endings
+ origin = l.token + "." + origin
+ } else {
+ origin = l.token + origin
+ }
+ } else {
+ origin = l.token
+ }
+ st = _EXPECT_OWNER_DIR
+ case _EXPECT_DIRGENERATE_BL:
+ if l.value != _BLANK {
+ t <- &Token{Error: &ParseError{f, "no blank after $GENERATE-directive", l}}
+ return
+ }
+ st = _EXPECT_DIRGENERATE
+ case _EXPECT_DIRGENERATE:
+ if l.value != _STRING {
+ t <- &Token{Error: &ParseError{f, "expecting $GENERATE value, not this...", l}}
+ return
+ }
+ if e := generate(l, c, t, origin); e != "" {
+ t <- &Token{Error: &ParseError{f, e, l}}
+ return
+ }
+ st = _EXPECT_OWNER_DIR
+ case _EXPECT_OWNER_BL:
+ if l.value != _BLANK {
+ t <- &Token{Error: &ParseError{f, "no blank after owner", l}}
+ return
+ }
+ st = _EXPECT_ANY
+ case _EXPECT_ANY:
+ switch l.value {
+ case _RRTYPE:
+ h.Rrtype = l.torc
+ st = _EXPECT_RDATA
+ case _CLASS:
+ h.Class = l.torc
+ st = _EXPECT_ANY_NOCLASS_BL
+ case _STRING: // TTL is this case
+ if ttl, ok := stringToTtl(l.token); !ok {
+ t <- &Token{Error: &ParseError{f, "not a TTL", l}}
+ return
+ } else {
+ h.Ttl = ttl
+ // defttl = ttl // don't set the defttl here
+ }
+ st = _EXPECT_ANY_NOTTL_BL
+ default:
+ t <- &Token{Error: &ParseError{f, "expecting RR type, TTL or class, not this...", l}}
+ return
+ }
+ case _EXPECT_ANY_NOCLASS_BL:
+ if l.value != _BLANK {
+ t <- &Token{Error: &ParseError{f, "no blank before class", l}}
+ return
+ }
+ st = _EXPECT_ANY_NOCLASS
+ case _EXPECT_ANY_NOTTL_BL:
+ if l.value != _BLANK {
+ t <- &Token{Error: &ParseError{f, "no blank before TTL", l}}
+ return
+ }
+ st = _EXPECT_ANY_NOTTL
+ case _EXPECT_ANY_NOTTL:
+ switch l.value {
+ case _CLASS:
+ h.Class = l.torc
+ st = _EXPECT_RRTYPE_BL
+ case _RRTYPE:
+ h.Rrtype = l.torc
+ st = _EXPECT_RDATA
+ default:
+ t <- &Token{Error: &ParseError{f, "expecting RR type or class, not this...", l}}
+ return
+ }
+ case _EXPECT_ANY_NOCLASS:
+ switch l.value {
+ case _STRING: // TTL
+ if ttl, ok := stringToTtl(l.token); !ok {
+ t <- &Token{Error: &ParseError{f, "not a TTL", l}}
+ return
+ } else {
+ h.Ttl = ttl
+ // defttl = ttl // don't set the def ttl anymore
+ }
+ st = _EXPECT_RRTYPE_BL
+ case _RRTYPE:
+ h.Rrtype = l.torc
+ st = _EXPECT_RDATA
+ default:
+ t <- &Token{Error: &ParseError{f, "expecting RR type or TTL, not this...", l}}
+ return
+ }
+ case _EXPECT_RRTYPE_BL:
+ if l.value != _BLANK {
+ t <- &Token{Error: &ParseError{f, "no blank before RR type", l}}
+ return
+ }
+ st = _EXPECT_RRTYPE
+ case _EXPECT_RRTYPE:
+ if l.value != _RRTYPE {
+ t <- &Token{Error: &ParseError{f, "unknown RR type", l}}
+ return
+ }
+ h.Rrtype = l.torc
+ st = _EXPECT_RDATA
+ case _EXPECT_RDATA:
+ r, e, c1 := setRR(h, c, origin, f)
+ if e != nil {
+ // If e.lex is nil than we have encounter a unknown RR type
+ // in that case we substitute our current lex token
+ if e.lex.token == "" && e.lex.value == 0 {
+ e.lex = l // Uh, dirty
+ }
+ t <- &Token{Error: e}
+ return
+ }
+ t <- &Token{RR: r, Comment: c1}
+ st = _EXPECT_OWNER_DIR
+ }
+ }
+ // If we get here, we and the h.Rrtype is still zero, we haven't parsed anything, this
+ // is not an error, because an empty zone file is still a zone file.
+}
+
+// zlexer scans the sourcefile and returns tokens on the channel c.
+func zlexer(s *scan, c chan lex) {
+ var l lex
+ str := make([]byte, maxTok) // Should be enough for any token
+ stri := 0 // Offset in str (0 means empty)
+ com := make([]byte, maxTok) // Hold comment text
+ comi := 0
+ quote := false
+ escape := false
+ space := false
+ commt := false
+ rrtype := false
+ owner := true
+ brace := 0
+ x, err := s.tokenText()
+ defer close(c)
+ for err == nil {
+ l.column = s.position.Column
+ l.line = s.position.Line
+ if stri > maxTok {
+ l.token = "token length insufficient for parsing"
+ l.err = true
+ debug.Printf("[%+v]", l.token)
+ c <- l
+ return
+ }
+ if comi > maxTok {
+ l.token = "comment length insufficient for parsing"
+ l.err = true
+ debug.Printf("[%+v]", l.token)
+ c <- l
+ return
+ }
+
+ switch x {
+ case ' ', '\t':
+ if escape {
+ escape = false
+ str[stri] = x
+ stri++
+ break
+ }
+ if quote {
+ // Inside quotes this is legal
+ str[stri] = x
+ stri++
+ break
+ }
+ if commt {
+ com[comi] = x
+ comi++
+ break
+ }
+ if stri == 0 {
+ // Space directly in the beginning, handled in the grammar
+ } else if owner {
+ // If we have a string and its the first, make it an owner
+ l.value = _OWNER
+ l.token = string(str[:stri])
+ l.tokenUpper = strings.ToUpper(l.token)
+ l.length = stri
+ // escape $... start with a \ not a $, so this will work
+ switch l.tokenUpper {
+ case "$TTL":
+ l.value = _DIRTTL
+ case "$ORIGIN":
+ l.value = _DIRORIGIN
+ case "$INCLUDE":
+ l.value = _DIRINCLUDE
+ case "$GENERATE":
+ l.value = _DIRGENERATE
+ }
+ debug.Printf("[7 %+v]", l.token)
+ c <- l
+ } else {
+ l.value = _STRING
+ l.token = string(str[:stri])
+ l.tokenUpper = strings.ToUpper(l.token)
+ l.length = stri
+ if !rrtype {
+ if t, ok := StringToType[l.tokenUpper]; ok {
+ l.value = _RRTYPE
+ l.torc = t
+ rrtype = true
+ } else {
+ if strings.HasPrefix(l.tokenUpper, "TYPE") {
+ if t, ok := typeToInt(l.token); !ok {
+ l.token = "unknown RR type"
+ l.err = true
+ c <- l
+ return
+ } else {
+ l.value = _RRTYPE
+ l.torc = t
+ }
+ }
+ }
+ if t, ok := StringToClass[l.tokenUpper]; ok {
+ l.value = _CLASS
+ l.torc = t
+ } else {
+ if strings.HasPrefix(l.tokenUpper, "CLASS") {
+ if t, ok := classToInt(l.token); !ok {
+ l.token = "unknown class"
+ l.err = true
+ c <- l
+ return
+ } else {
+ l.value = _CLASS
+ l.torc = t
+ }
+ }
+ }
+ }
+ debug.Printf("[6 %+v]", l.token)
+ c <- l
+ }
+ stri = 0
+ // I reverse space stuff here
+ if !space && !commt {
+ l.value = _BLANK
+ l.token = " "
+ l.length = 1
+ debug.Printf("[5 %+v]", l.token)
+ c <- l
+ }
+ owner = false
+ space = true
+ case ';':
+ if escape {
+ escape = false
+ str[stri] = x
+ stri++
+ break
+ }
+ if quote {
+ // Inside quotes this is legal
+ str[stri] = x
+ stri++
+ break
+ }
+ if stri > 0 {
+ l.value = _STRING
+ l.token = string(str[:stri])
+ l.length = stri
+ debug.Printf("[4 %+v]", l.token)
+ c <- l
+ stri = 0
+ }
+ commt = true
+ com[comi] = ';'
+ comi++
+ case '\r':
+ escape = false
+ if quote {
+ str[stri] = x
+ stri++
+ break
+ }
+ // discard if outside of quotes
+ case '\n':
+ escape = false
+ // Escaped newline
+ if quote {
+ str[stri] = x
+ stri++
+ break
+ }
+ // inside quotes this is legal
+ if commt {
+ // Reset a comment
+ commt = false
+ rrtype = false
+ stri = 0
+ // If not in a brace this ends the comment AND the RR
+ if brace == 0 {
+ owner = true
+ owner = true
+ l.value = _NEWLINE
+ l.token = "\n"
+ l.length = 1
+ l.comment = string(com[:comi])
+ debug.Printf("[3 %+v %+v]", l.token, l.comment)
+ c <- l
+ l.comment = ""
+ comi = 0
+ break
+ }
+ com[comi] = ' ' // convert newline to space
+ comi++
+ break
+ }
+
+ if brace == 0 {
+ // If there is previous text, we should output it here
+ if stri != 0 {
+ l.value = _STRING
+ l.token = string(str[:stri])
+ l.tokenUpper = strings.ToUpper(l.token)
+
+ l.length = stri
+ if !rrtype {
+ if t, ok := StringToType[l.tokenUpper]; ok {
+ l.value = _RRTYPE
+ l.torc = t
+ rrtype = true
+ }
+ }
+ debug.Printf("[2 %+v]", l.token)
+ c <- l
+ }
+ l.value = _NEWLINE
+ l.token = "\n"
+ l.length = 1
+ debug.Printf("[1 %+v]", l.token)
+ c <- l
+ stri = 0
+ commt = false
+ rrtype = false
+ owner = true
+ comi = 0
+ }
+ case '\\':
+ // comments do not get escaped chars, everything is copied
+ if commt {
+ com[comi] = x
+ comi++
+ break
+ }
+ // something already escaped must be in string
+ if escape {
+ str[stri] = x
+ stri++
+ escape = false
+ break
+ }
+ // something escaped outside of string gets added to string
+ str[stri] = x
+ stri++
+ escape = true
+ case '"':
+ if commt {
+ com[comi] = x
+ comi++
+ break
+ }
+ if escape {
+ str[stri] = x
+ stri++
+ escape = false
+ break
+ }
+ space = false
+ // send previous gathered text and the quote
+ if stri != 0 {
+ l.value = _STRING
+ l.token = string(str[:stri])
+ l.length = stri
+
+ debug.Printf("[%+v]", l.token)
+ c <- l
+ stri = 0
+ }
+
+ // send quote itself as separate token
+ l.value = _QUOTE
+ l.token = "\""
+ l.length = 1
+ c <- l
+ quote = !quote
+ case '(', ')':
+ if commt {
+ com[comi] = x
+ comi++
+ break
+ }
+ if escape {
+ str[stri] = x
+ stri++
+ escape = false
+ break
+ }
+ if quote {
+ str[stri] = x
+ stri++
+ break
+ }
+ switch x {
+ case ')':
+ brace--
+ if brace < 0 {
+ l.token = "extra closing brace"
+ l.err = true
+ debug.Printf("[%+v]", l.token)
+ c <- l
+ return
+ }
+ case '(':
+ brace++
+ }
+ default:
+ escape = false
+ if commt {
+ com[comi] = x
+ comi++
+ break
+ }
+ str[stri] = x
+ stri++
+ space = false
+ }
+ x, err = s.tokenText()
+ }
+ if stri > 0 {
+ // Send remainder
+ l.token = string(str[:stri])
+ l.length = stri
+ l.value = _STRING
+ debug.Printf("[%+v]", l.token)
+ c <- l
+ }
+}
+
+// Extract the class number from CLASSxx
+func classToInt(token string) (uint16, bool) {
+ class, ok := strconv.Atoi(token[5:])
+ if ok != nil || class > maxUint16 {
+ return 0, false
+ }
+ return uint16(class), true
+}
+
+// Extract the rr number from TYPExxx
+func typeToInt(token string) (uint16, bool) {
+ typ, ok := strconv.Atoi(token[4:])
+ if ok != nil || typ > maxUint16 {
+ return 0, false
+ }
+ return uint16(typ), true
+}
+
+// Parse things like 2w, 2m, etc, Return the time in seconds.
+func stringToTtl(token string) (uint32, bool) {
+ s := uint32(0)
+ i := uint32(0)
+ for _, c := range token {
+ switch c {
+ case 's', 'S':
+ s += i
+ i = 0
+ case 'm', 'M':
+ s += i * 60
+ i = 0
+ case 'h', 'H':
+ s += i * 60 * 60
+ i = 0
+ case 'd', 'D':
+ s += i * 60 * 60 * 24
+ i = 0
+ case 'w', 'W':
+ s += i * 60 * 60 * 24 * 7
+ i = 0
+ case '0', '1', '2', '3', '4', '5', '6', '7', '8', '9':
+ i *= 10
+ i += uint32(c) - '0'
+ default:
+ return 0, false
+ }
+ }
+ return s + i, true
+}
+
+// Parse LOC records' <digits>[.<digits>][mM] into a
+// mantissa exponent format. Token should contain the entire
+// string (i.e. no spaces allowed)
+func stringToCm(token string) (e, m uint8, ok bool) {
+ if token[len(token)-1] == 'M' || token[len(token)-1] == 'm' {
+ token = token[0 : len(token)-1]
+ }
+ s := strings.SplitN(token, ".", 2)
+ var meters, cmeters, val int
+ var err error
+ switch len(s) {
+ case 2:
+ if cmeters, err = strconv.Atoi(s[1]); err != nil {
+ return
+ }
+ fallthrough
+ case 1:
+ if meters, err = strconv.Atoi(s[0]); err != nil {
+ return
+ }
+ case 0:
+ // huh?
+ return 0, 0, false
+ }
+ ok = true
+ if meters > 0 {
+ e = 2
+ val = meters
+ } else {
+ e = 0
+ val = cmeters
+ }
+ for val > 10 {
+ e++
+ val /= 10
+ }
+ if e > 9 {
+ ok = false
+ }
+ m = uint8(val)
+ return
+}
+
+func appendOrigin(name, origin string) string {
+ if origin == "." {
+ return name + origin
+ }
+ return name + "." + origin
+}
+
+// LOC record helper function
+func locCheckNorth(token string, latitude uint32) (uint32, bool) {
+ switch token {
+ case "n", "N":
+ return LOC_EQUATOR + latitude, true
+ case "s", "S":
+ return LOC_EQUATOR - latitude, true
+ }
+ return latitude, false
+}
+
+// LOC record helper function
+func locCheckEast(token string, longitude uint32) (uint32, bool) {
+ switch token {
+ case "e", "E":
+ return LOC_EQUATOR + longitude, true
+ case "w", "W":
+ return LOC_EQUATOR - longitude, true
+ }
+ return longitude, false
+}
+
+// "Eat" the rest of the "line". Return potential comments
+func slurpRemainder(c chan lex, f string) (*ParseError, string) {
+ l := <-c
+ com := ""
+ switch l.value {
+ case _BLANK:
+ l = <-c
+ com = l.comment
+ if l.value != _NEWLINE && l.value != _EOF {
+ return &ParseError{f, "garbage after rdata", l}, ""
+ }
+ case _NEWLINE:
+ com = l.comment
+ case _EOF:
+ default:
+ return &ParseError{f, "garbage after rdata", l}, ""
+ }
+ return nil, com
+}
+
+// Parse a 64 bit-like ipv6 address: "0014:4fff:ff20:ee64"
+// Used for NID and L64 record.
+func stringToNodeID(l lex) (uint64, *ParseError) {
+ if len(l.token) < 19 {
+ return 0, &ParseError{l.token, "bad NID/L64 NodeID/Locator64", l}
+ }
+ // There must be three colons at fixes postitions, if not its a parse error
+ if l.token[4] != ':' && l.token[9] != ':' && l.token[14] != ':' {
+ return 0, &ParseError{l.token, "bad NID/L64 NodeID/Locator64", l}
+ }
+ s := l.token[0:4] + l.token[5:9] + l.token[10:14] + l.token[15:19]
+ u, e := strconv.ParseUint(s, 16, 64)
+ if e != nil {
+ return 0, &ParseError{l.token, "bad NID/L64 NodeID/Locator64", l}
+ }
+ return u, nil
+}
diff --git a/Godeps/_workspace/src/github.com/miekg/dns/zscan_rr.go b/Godeps/_workspace/src/github.com/miekg/dns/zscan_rr.go
new file mode 100644
index 0000000000000000000000000000000000000000..5088cdb58e26171aa345a626a8b92cea6e4ba8a2
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/miekg/dns/zscan_rr.go
@@ -0,0 +1,2155 @@
+package dns
+
+import (
+ "encoding/base64"
+ "net"
+ "strconv"
+ "strings"
+)
+
+type parserFunc struct {
+ // Func defines the function that parses the tokens and returns the RR
+ // or an error. The last string contains any comments in the line as
+ // they returned by the lexer as well.
+ Func func(h RR_Header, c chan lex, origin string, file string) (RR, *ParseError, string)
+ // Signals if the RR ending is of variable length, like TXT or records
+ // that have Hexadecimal or Base64 as their last element in the Rdata. Records
+ // that have a fixed ending or for instance A, AAAA, SOA and etc.
+ Variable bool
+}
+
+// Parse the rdata of each rrtype.
+// All data from the channel c is either _STRING or _BLANK.
+// After the rdata there may come a _BLANK and then a _NEWLINE
+// or immediately a _NEWLINE. If this is not the case we flag
+// an *ParseError: garbage after rdata.
+func setRR(h RR_Header, c chan lex, o, f string) (RR, *ParseError, string) {
+ parserfunc, ok := typeToparserFunc[h.Rrtype]
+ if ok {
+ r, e, cm := parserfunc.Func(h, c, o, f)
+ if parserfunc.Variable {
+ return r, e, cm
+ }
+ if e != nil {
+ return nil, e, ""
+ }
+ e, cm = slurpRemainder(c, f)
+ if e != nil {
+ return nil, e, ""
+ }
+ return r, nil, cm
+ }
+ // RFC3957 RR (Unknown RR handling)
+ return setRFC3597(h, c, o, f)
+}
+
+// A remainder of the rdata with embedded spaces, return the parsed string (sans the spaces)
+// or an error
+func endingToString(c chan lex, errstr, f string) (string, *ParseError, string) {
+ s := ""
+ l := <-c // _STRING
+ for l.value != _NEWLINE && l.value != _EOF {
+ switch l.value {
+ case _STRING:
+ s += l.token
+ case _BLANK: // Ok
+ default:
+ return "", &ParseError{f, errstr, l}, ""
+ }
+ l = <-c
+ }
+ return s, nil, l.comment
+}
+
+// A remainder of the rdata with embedded spaces, return the parsed string slice (sans the spaces)
+// or an error
+func endingToTxtSlice(c chan lex, errstr, f string) ([]string, *ParseError, string) {
+ // Get the remaining data until we see a NEWLINE
+ quote := false
+ l := <-c
+ var s []string
+ switch l.value == _QUOTE {
+ case true: // A number of quoted string
+ s = make([]string, 0)
+ empty := true
+ for l.value != _NEWLINE && l.value != _EOF {
+ switch l.value {
+ case _STRING:
+ empty = false
+ s = append(s, l.token)
+ case _BLANK:
+ if quote {
+ // _BLANK can only be seen in between txt parts.
+ return nil, &ParseError{f, errstr, l}, ""
+ }
+ case _QUOTE:
+ if empty && quote {
+ s = append(s, "")
+ }
+ quote = !quote
+ empty = true
+ default:
+ return nil, &ParseError{f, errstr, l}, ""
+ }
+ l = <-c
+ }
+ if quote {
+ return nil, &ParseError{f, errstr, l}, ""
+ }
+ case false: // Unquoted text record
+ s = make([]string, 1)
+ for l.value != _NEWLINE && l.value != _EOF {
+ s[0] += l.token
+ l = <-c
+ }
+ }
+ return s, nil, l.comment
+}
+
+func setA(h RR_Header, c chan lex, o, f string) (RR, *ParseError, string) {
+ rr := new(A)
+ rr.Hdr = h
+
+ l := <-c
+ if l.length == 0 { // Dynamic updates.
+ return rr, nil, ""
+ }
+ rr.A = net.ParseIP(l.token)
+ if rr.A == nil {
+ return nil, &ParseError{f, "bad A A", l}, ""
+ }
+ return rr, nil, ""
+}
+
+func setAAAA(h RR_Header, c chan lex, o, f string) (RR, *ParseError, string) {
+ rr := new(AAAA)
+ rr.Hdr = h
+
+ l := <-c
+ if l.length == 0 {
+ return rr, nil, ""
+ }
+ rr.AAAA = net.ParseIP(l.token)
+ if rr.AAAA == nil {
+ return nil, &ParseError{f, "bad AAAA AAAA", l}, ""
+ }
+ return rr, nil, ""
+}
+
+func setNS(h RR_Header, c chan lex, o, f string) (RR, *ParseError, string) {
+ rr := new(NS)
+ rr.Hdr = h
+
+ l := <-c
+ rr.Ns = l.token
+ if l.length == 0 {
+ return rr, nil, ""
+ }
+ if l.token == "@" {
+ rr.Ns = o
+ return rr, nil, ""
+ }
+ _, ok := IsDomainName(l.token)
+ if !ok {
+ return nil, &ParseError{f, "bad NS Ns", l}, ""
+ }
+ if rr.Ns[l.length-1] != '.' {
+ rr.Ns = appendOrigin(rr.Ns, o)
+ }
+ return rr, nil, ""
+}
+
+func setPTR(h RR_Header, c chan lex, o, f string) (RR, *ParseError, string) {
+ rr := new(PTR)
+ rr.Hdr = h
+
+ l := <-c
+ rr.Ptr = l.token
+ if l.length == 0 { // dynamic update rr.
+ return rr, nil, ""
+ }
+ if l.token == "@" {
+ rr.Ptr = o
+ return rr, nil, ""
+ }
+ _, ok := IsDomainName(l.token)
+ if !ok {
+ return nil, &ParseError{f, "bad PTR Ptr", l}, ""
+ }
+ if rr.Ptr[l.length-1] != '.' {
+ rr.Ptr = appendOrigin(rr.Ptr, o)
+ }
+ return rr, nil, ""
+}
+
+func setNSAPPTR(h RR_Header, c chan lex, o, f string) (RR, *ParseError, string) {
+ rr := new(NSAPPTR)
+ rr.Hdr = h
+
+ l := <-c
+ rr.Ptr = l.token
+ if l.length == 0 {
+ return rr, nil, ""
+ }
+ if l.token == "@" {
+ rr.Ptr = o
+ return rr, nil, ""
+ }
+ _, ok := IsDomainName(l.token)
+ if !ok {
+ return nil, &ParseError{f, "bad NSAP-PTR Ptr", l}, ""
+ }
+ if rr.Ptr[l.length-1] != '.' {
+ rr.Ptr = appendOrigin(rr.Ptr, o)
+ }
+ return rr, nil, ""
+}
+
+func setRP(h RR_Header, c chan lex, o, f string) (RR, *ParseError, string) {
+ rr := new(RP)
+ rr.Hdr = h
+
+ l := <-c
+ rr.Mbox = l.token
+ if l.length == 0 {
+ return rr, nil, ""
+ }
+ if l.token == "@" {
+ rr.Mbox = o
+ } else {
+ _, ok := IsDomainName(l.token)
+ if !ok {
+ return nil, &ParseError{f, "bad RP Mbox", l}, ""
+ }
+ if rr.Mbox[l.length-1] != '.' {
+ rr.Mbox = appendOrigin(rr.Mbox, o)
+ }
+ }
+ <-c // _BLANK
+ l = <-c
+ rr.Txt = l.token
+ if l.token == "@" {
+ rr.Txt = o
+ return rr, nil, ""
+ }
+ _, ok := IsDomainName(l.token)
+ if !ok {
+ return nil, &ParseError{f, "bad RP Txt", l}, ""
+ }
+ if rr.Txt[l.length-1] != '.' {
+ rr.Txt = appendOrigin(rr.Txt, o)
+ }
+ return rr, nil, ""
+}
+
+func setMR(h RR_Header, c chan lex, o, f string) (RR, *ParseError, string) {
+ rr := new(MR)
+ rr.Hdr = h
+
+ l := <-c
+ rr.Mr = l.token
+ if l.length == 0 {
+ return rr, nil, ""
+ }
+ if l.token == "@" {
+ rr.Mr = o
+ return rr, nil, ""
+ }
+ _, ok := IsDomainName(l.token)
+ if !ok {
+ return nil, &ParseError{f, "bad MR Mr", l}, ""
+ }
+ if rr.Mr[l.length-1] != '.' {
+ rr.Mr = appendOrigin(rr.Mr, o)
+ }
+ return rr, nil, ""
+}
+
+func setMB(h RR_Header, c chan lex, o, f string) (RR, *ParseError, string) {
+ rr := new(MB)
+ rr.Hdr = h
+
+ l := <-c
+ rr.Mb = l.token
+ if l.length == 0 {
+ return rr, nil, ""
+ }
+ if l.token == "@" {
+ rr.Mb = o
+ return rr, nil, ""
+ }
+ _, ok := IsDomainName(l.token)
+ if !ok {
+ return nil, &ParseError{f, "bad MB Mb", l}, ""
+ }
+ if rr.Mb[l.length-1] != '.' {
+ rr.Mb = appendOrigin(rr.Mb, o)
+ }
+ return rr, nil, ""
+}
+
+func setMG(h RR_Header, c chan lex, o, f string) (RR, *ParseError, string) {
+ rr := new(MG)
+ rr.Hdr = h
+
+ l := <-c
+ rr.Mg = l.token
+ if l.length == 0 {
+ return rr, nil, ""
+ }
+ if l.token == "@" {
+ rr.Mg = o
+ return rr, nil, ""
+ }
+ _, ok := IsDomainName(l.token)
+ if !ok {
+ return nil, &ParseError{f, "bad MG Mg", l}, ""
+ }
+ if rr.Mg[l.length-1] != '.' {
+ rr.Mg = appendOrigin(rr.Mg, o)
+ }
+ return rr, nil, ""
+}
+
+func setHINFO(h RR_Header, c chan lex, o, f string) (RR, *ParseError, string) {
+ rr := new(HINFO)
+ rr.Hdr = h
+
+ l := <-c
+ rr.Cpu = l.token
+ <-c // _BLANK
+ l = <-c // _STRING
+ rr.Os = l.token
+
+ return rr, nil, ""
+}
+
+func setMINFO(h RR_Header, c chan lex, o, f string) (RR, *ParseError, string) {
+ rr := new(MINFO)
+ rr.Hdr = h
+
+ l := <-c
+ rr.Rmail = l.token
+ if l.length == 0 {
+ return rr, nil, ""
+ }
+ if l.token == "@" {
+ rr.Rmail = o
+ } else {
+ _, ok := IsDomainName(l.token)
+ if !ok {
+ return nil, &ParseError{f, "bad MINFO Rmail", l}, ""
+ }
+ if rr.Rmail[l.length-1] != '.' {
+ rr.Rmail = appendOrigin(rr.Rmail, o)
+ }
+ }
+ <-c // _BLANK
+ l = <-c
+ rr.Email = l.token
+ if l.token == "@" {
+ rr.Email = o
+ return rr, nil, ""
+ }
+ _, ok := IsDomainName(l.token)
+ if !ok {
+ return nil, &ParseError{f, "bad MINFO Email", l}, ""
+ }
+ if rr.Email[l.length-1] != '.' {
+ rr.Email = appendOrigin(rr.Email, o)
+ }
+ return rr, nil, ""
+}
+
+func setMF(h RR_Header, c chan lex, o, f string) (RR, *ParseError, string) {
+ rr := new(MF)
+ rr.Hdr = h
+
+ l := <-c
+ rr.Mf = l.token
+ if l.length == 0 {
+ return rr, nil, ""
+ }
+ if l.token == "@" {
+ rr.Mf = o
+ return rr, nil, ""
+ }
+ _, ok := IsDomainName(l.token)
+ if !ok {
+ return nil, &ParseError{f, "bad MF Mf", l}, ""
+ }
+ if rr.Mf[l.length-1] != '.' {
+ rr.Mf = appendOrigin(rr.Mf, o)
+ }
+ return rr, nil, ""
+}
+
+func setMD(h RR_Header, c chan lex, o, f string) (RR, *ParseError, string) {
+ rr := new(MD)
+ rr.Hdr = h
+
+ l := <-c
+ rr.Md = l.token
+ if l.length == 0 {
+ return rr, nil, ""
+ }
+ if l.token == "@" {
+ rr.Md = o
+ return rr, nil, ""
+ }
+ _, ok := IsDomainName(l.token)
+ if !ok {
+ return nil, &ParseError{f, "bad MD Md", l}, ""
+ }
+ if rr.Md[l.length-1] != '.' {
+ rr.Md = appendOrigin(rr.Md, o)
+ }
+ return rr, nil, ""
+}
+
+func setMX(h RR_Header, c chan lex, o, f string) (RR, *ParseError, string) {
+ rr := new(MX)
+ rr.Hdr = h
+
+ l := <-c
+ if l.length == 0 {
+ return rr, nil, ""
+ }
+ if i, e := strconv.Atoi(l.token); e != nil {
+ return nil, &ParseError{f, "bad MX Pref", l}, ""
+ } else {
+ rr.Preference = uint16(i)
+ }
+ <-c // _BLANK
+ l = <-c // _STRING
+ rr.Mx = l.token
+ if l.token == "@" {
+ rr.Mx = o
+ return rr, nil, ""
+ }
+ _, ok := IsDomainName(l.token)
+ if !ok || l.length == 0 {
+ return nil, &ParseError{f, "bad MX Mx", l}, ""
+ }
+ if rr.Mx[l.length-1] != '.' {
+ rr.Mx = appendOrigin(rr.Mx, o)
+ }
+ return rr, nil, ""
+}
+
+func setRT(h RR_Header, c chan lex, o, f string) (RR, *ParseError, string) {
+ rr := new(RT)
+ rr.Hdr = h
+ l := <-c
+ if l.length == 0 {
+ return rr, nil, ""
+ }
+ if i, e := strconv.Atoi(l.token); e != nil {
+ return nil, &ParseError{f, "bad RT Preference", l}, ""
+ } else {
+ rr.Preference = uint16(i)
+ }
+ <-c // _BLANK
+ l = <-c // _STRING
+ rr.Host = l.token
+ if l.token == "@" {
+ rr.Host = o
+ return rr, nil, ""
+ }
+ _, ok := IsDomainName(l.token)
+ if !ok || l.length == 0 {
+ return nil, &ParseError{f, "bad RT Host", l}, ""
+ }
+ if rr.Host[l.length-1] != '.' {
+ rr.Host = appendOrigin(rr.Host, o)
+ }
+ return rr, nil, ""
+}
+
+func setAFSDB(h RR_Header, c chan lex, o, f string) (RR, *ParseError, string) {
+ rr := new(AFSDB)
+ rr.Hdr = h
+
+ l := <-c
+ if l.length == 0 {
+ return rr, nil, ""
+ }
+ if i, e := strconv.Atoi(l.token); e != nil {
+ return nil, &ParseError{f, "bad AFSDB Subtype", l}, ""
+ } else {
+ rr.Subtype = uint16(i)
+ }
+ <-c // _BLANK
+ l = <-c // _STRING
+ rr.Hostname = l.token
+ if l.token == "@" {
+ rr.Hostname = o
+ return rr, nil, ""
+ }
+ _, ok := IsDomainName(l.token)
+ if !ok || l.length == 0 {
+ return nil, &ParseError{f, "bad AFSDB Hostname", l}, ""
+ }
+ if rr.Hostname[l.length-1] != '.' {
+ rr.Hostname = appendOrigin(rr.Hostname, o)
+ }
+ return rr, nil, ""
+}
+
+func setX25(h RR_Header, c chan lex, o, f string) (RR, *ParseError, string) {
+ rr := new(X25)
+ rr.Hdr = h
+
+ l := <-c
+ rr.PSDNAddress = l.token
+ return rr, nil, ""
+}
+
+func setKX(h RR_Header, c chan lex, o, f string) (RR, *ParseError, string) {
+ rr := new(KX)
+ rr.Hdr = h
+
+ l := <-c
+ if l.length == 0 {
+ return rr, nil, ""
+ }
+ if i, e := strconv.Atoi(l.token); e != nil {
+ return nil, &ParseError{f, "bad KX Pref", l}, ""
+ } else {
+ rr.Preference = uint16(i)
+ }
+ <-c // _BLANK
+ l = <-c // _STRING
+ rr.Exchanger = l.token
+ if l.token == "@" {
+ rr.Exchanger = o
+ return rr, nil, ""
+ }
+ _, ok := IsDomainName(l.token)
+ if !ok || l.length == 0 {
+ return nil, &ParseError{f, "bad KX Exchanger", l}, ""
+ }
+ if rr.Exchanger[l.length-1] != '.' {
+ rr.Exchanger = appendOrigin(rr.Exchanger, o)
+ }
+ return rr, nil, ""
+}
+
+func setCNAME(h RR_Header, c chan lex, o, f string) (RR, *ParseError, string) {
+ rr := new(CNAME)
+ rr.Hdr = h
+
+ l := <-c
+ rr.Target = l.token
+ if l.length == 0 {
+ return rr, nil, ""
+ }
+ if l.token == "@" {
+ rr.Target = o
+ return rr, nil, ""
+ }
+ _, ok := IsDomainName(l.token)
+ if !ok || l.length == 0 {
+ return nil, &ParseError{f, "bad CNAME Target", l}, ""
+ }
+ if rr.Target[l.length-1] != '.' {
+ rr.Target = appendOrigin(rr.Target, o)
+ }
+ return rr, nil, ""
+}
+
+func setDNAME(h RR_Header, c chan lex, o, f string) (RR, *ParseError, string) {
+ rr := new(DNAME)
+ rr.Hdr = h
+
+ l := <-c
+ rr.Target = l.token
+ if l.length == 0 {
+ return rr, nil, ""
+ }
+ if l.token == "@" {
+ rr.Target = o
+ return rr, nil, ""
+ }
+ _, ok := IsDomainName(l.token)
+ if !ok {
+ return nil, &ParseError{f, "bad CNAME Target", l}, ""
+ }
+ if rr.Target[l.length-1] != '.' {
+ rr.Target = appendOrigin(rr.Target, o)
+ }
+ return rr, nil, ""
+}
+
+func setSOA(h RR_Header, c chan lex, o, f string) (RR, *ParseError, string) {
+ rr := new(SOA)
+ rr.Hdr = h
+
+ l := <-c
+ rr.Ns = l.token
+ if l.length == 0 {
+ return rr, nil, ""
+ }
+ <-c // _BLANK
+ if l.token == "@" {
+ rr.Ns = o
+ } else {
+ _, ok := IsDomainName(l.token)
+ if !ok {
+ return nil, &ParseError{f, "bad SOA Ns", l}, ""
+ }
+ if rr.Ns[l.length-1] != '.' {
+ rr.Ns = appendOrigin(rr.Ns, o)
+ }
+ }
+
+ l = <-c
+ rr.Mbox = l.token
+ if l.token == "@" {
+ rr.Mbox = o
+ } else {
+ _, ok := IsDomainName(l.token)
+ if !ok || l.length == 0 {
+ return nil, &ParseError{f, "bad SOA Mbox", l}, ""
+ }
+ if rr.Mbox[l.length-1] != '.' {
+ rr.Mbox = appendOrigin(rr.Mbox, o)
+ }
+ }
+ <-c // _BLANK
+
+ var (
+ v uint32
+ ok bool
+ )
+ for i := 0; i < 5; i++ {
+ l = <-c
+ if j, e := strconv.Atoi(l.token); e != nil {
+ if i == 0 {
+ // Serial should be a number
+ return nil, &ParseError{f, "bad SOA zone parameter", l}, ""
+ }
+ if v, ok = stringToTtl(l.token); !ok {
+ return nil, &ParseError{f, "bad SOA zone parameter", l}, ""
+
+ }
+ } else {
+ v = uint32(j)
+ }
+ switch i {
+ case 0:
+ rr.Serial = v
+ <-c // _BLANK
+ case 1:
+ rr.Refresh = v
+ <-c // _BLANK
+ case 2:
+ rr.Retry = v
+ <-c // _BLANK
+ case 3:
+ rr.Expire = v
+ <-c // _BLANK
+ case 4:
+ rr.Minttl = v
+ }
+ }
+ return rr, nil, ""
+}
+
+func setSRV(h RR_Header, c chan lex, o, f string) (RR, *ParseError, string) {
+ rr := new(SRV)
+ rr.Hdr = h
+
+ l := <-c
+ if l.length == 0 {
+ return rr, nil, ""
+ }
+ if i, e := strconv.Atoi(l.token); e != nil {
+ return nil, &ParseError{f, "bad SRV Priority", l}, ""
+ } else {
+ rr.Priority = uint16(i)
+ }
+ <-c // _BLANK
+ l = <-c // _STRING
+ if i, e := strconv.Atoi(l.token); e != nil {
+ return nil, &ParseError{f, "bad SRV Weight", l}, ""
+ } else {
+ rr.Weight = uint16(i)
+ }
+ <-c // _BLANK
+ l = <-c // _STRING
+ if i, e := strconv.Atoi(l.token); e != nil {
+ return nil, &ParseError{f, "bad SRV Port", l}, ""
+ } else {
+ rr.Port = uint16(i)
+ }
+ <-c // _BLANK
+ l = <-c // _STRING
+ rr.Target = l.token
+ if l.token == "@" {
+ rr.Target = o
+ return rr, nil, ""
+ }
+ _, ok := IsDomainName(l.token)
+ if !ok || l.length == 0 {
+ return nil, &ParseError{f, "bad SRV Target", l}, ""
+ }
+ if rr.Target[l.length-1] != '.' {
+ rr.Target = appendOrigin(rr.Target, o)
+ }
+ return rr, nil, ""
+}
+
+func setNAPTR(h RR_Header, c chan lex, o, f string) (RR, *ParseError, string) {
+ rr := new(NAPTR)
+ rr.Hdr = h
+
+ l := <-c
+ if l.length == 0 {
+ return rr, nil, ""
+ }
+ if i, e := strconv.Atoi(l.token); e != nil {
+ return nil, &ParseError{f, "bad NAPTR Order", l}, ""
+ } else {
+ rr.Order = uint16(i)
+ }
+ <-c // _BLANK
+ l = <-c // _STRING
+ if i, e := strconv.Atoi(l.token); e != nil {
+ return nil, &ParseError{f, "bad NAPTR Preference", l}, ""
+ } else {
+ rr.Preference = uint16(i)
+ }
+ // Flags
+ <-c // _BLANK
+ l = <-c // _QUOTE
+ if l.value != _QUOTE {
+ return nil, &ParseError{f, "bad NAPTR Flags", l}, ""
+ }
+ l = <-c // Either String or Quote
+ if l.value == _STRING {
+ rr.Flags = l.token
+ l = <-c // _QUOTE
+ if l.value != _QUOTE {
+ return nil, &ParseError{f, "bad NAPTR Flags", l}, ""
+ }
+ } else if l.value == _QUOTE {
+ rr.Flags = ""
+ } else {
+ return nil, &ParseError{f, "bad NAPTR Flags", l}, ""
+ }
+
+ // Service
+ <-c // _BLANK
+ l = <-c // _QUOTE
+ if l.value != _QUOTE {
+ return nil, &ParseError{f, "bad NAPTR Service", l}, ""
+ }
+ l = <-c // Either String or Quote
+ if l.value == _STRING {
+ rr.Service = l.token
+ l = <-c // _QUOTE
+ if l.value != _QUOTE {
+ return nil, &ParseError{f, "bad NAPTR Service", l}, ""
+ }
+ } else if l.value == _QUOTE {
+ rr.Service = ""
+ } else {
+ return nil, &ParseError{f, "bad NAPTR Service", l}, ""
+ }
+
+ // Regexp
+ <-c // _BLANK
+ l = <-c // _QUOTE
+ if l.value != _QUOTE {
+ return nil, &ParseError{f, "bad NAPTR Regexp", l}, ""
+ }
+ l = <-c // Either String or Quote
+ if l.value == _STRING {
+ rr.Regexp = l.token
+ l = <-c // _QUOTE
+ if l.value != _QUOTE {
+ return nil, &ParseError{f, "bad NAPTR Regexp", l}, ""
+ }
+ } else if l.value == _QUOTE {
+ rr.Regexp = ""
+ } else {
+ return nil, &ParseError{f, "bad NAPTR Regexp", l}, ""
+ }
+ // After quote no space??
+ <-c // _BLANK
+ l = <-c // _STRING
+ rr.Replacement = l.token
+ if l.token == "@" {
+ rr.Replacement = o
+ return rr, nil, ""
+ }
+ _, ok := IsDomainName(l.token)
+ if !ok || l.length == 0 {
+ return nil, &ParseError{f, "bad NAPTR Replacement", l}, ""
+ }
+ if rr.Replacement[l.length-1] != '.' {
+ rr.Replacement = appendOrigin(rr.Replacement, o)
+ }
+ return rr, nil, ""
+}
+
+func setTALINK(h RR_Header, c chan lex, o, f string) (RR, *ParseError, string) {
+ rr := new(TALINK)
+ rr.Hdr = h
+
+ l := <-c
+ rr.PreviousName = l.token
+ if l.length == 0 {
+ return rr, nil, ""
+ }
+ if l.token == "@" {
+ rr.PreviousName = o
+ } else {
+ _, ok := IsDomainName(l.token)
+ if !ok {
+ return nil, &ParseError{f, "bad TALINK PreviousName", l}, ""
+ }
+ if rr.PreviousName[l.length-1] != '.' {
+ rr.PreviousName = appendOrigin(rr.PreviousName, o)
+ }
+ }
+ <-c // _BLANK
+ l = <-c
+ rr.NextName = l.token
+ if l.token == "@" {
+ rr.NextName = o
+ return rr, nil, ""
+ }
+ _, ok := IsDomainName(l.token)
+ if !ok || l.length == 0 {
+ return nil, &ParseError{f, "bad TALINK NextName", l}, ""
+ }
+ if rr.NextName[l.length-1] != '.' {
+ rr.NextName = appendOrigin(rr.NextName, o)
+ }
+ return rr, nil, ""
+}
+
+func setLOC(h RR_Header, c chan lex, o, f string) (RR, *ParseError, string) {
+ rr := new(LOC)
+ rr.Hdr = h
+ // Non zero defaults for LOC record, see RFC 1876, Section 3.
+ rr.HorizPre = 165 // 10000
+ rr.VertPre = 162 // 10
+ rr.Size = 18 // 1
+ ok := false
+ // North
+ l := <-c
+ if l.length == 0 {
+ return rr, nil, ""
+ }
+ if i, e := strconv.Atoi(l.token); e != nil {
+ return nil, &ParseError{f, "bad LOC Latitude", l}, ""
+ } else {
+ rr.Latitude = 1000 * 60 * 60 * uint32(i)
+ }
+ <-c // _BLANK
+ // Either number, 'N' or 'S'
+ l = <-c
+ if rr.Latitude, ok = locCheckNorth(l.token, rr.Latitude); ok {
+ goto East
+ }
+ if i, e := strconv.Atoi(l.token); e != nil {
+ return nil, &ParseError{f, "bad LOC Latitude minutes", l}, ""
+ } else {
+ rr.Latitude += 1000 * 60 * uint32(i)
+ }
+ <-c // _BLANK
+ l = <-c
+ if i, e := strconv.ParseFloat(l.token, 32); e != nil {
+ return nil, &ParseError{f, "bad LOC Latitude seconds", l}, ""
+ } else {
+ rr.Latitude += uint32(1000 * i)
+ }
+ <-c // _BLANK
+ // Either number, 'N' or 'S'
+ l = <-c
+ if rr.Latitude, ok = locCheckNorth(l.token, rr.Latitude); ok {
+ goto East
+ }
+ // If still alive, flag an error
+ return nil, &ParseError{f, "bad LOC Latitude North/South", l}, ""
+
+East:
+ // East
+ <-c // _BLANK
+ l = <-c
+ if i, e := strconv.Atoi(l.token); e != nil {
+ return nil, &ParseError{f, "bad LOC Longitude", l}, ""
+ } else {
+ rr.Longitude = 1000 * 60 * 60 * uint32(i)
+ }
+ <-c // _BLANK
+ // Either number, 'E' or 'W'
+ l = <-c
+ if rr.Longitude, ok = locCheckEast(l.token, rr.Longitude); ok {
+ goto Altitude
+ }
+ if i, e := strconv.Atoi(l.token); e != nil {
+ return nil, &ParseError{f, "bad LOC Longitude minutes", l}, ""
+ } else {
+ rr.Longitude += 1000 * 60 * uint32(i)
+ }
+ <-c // _BLANK
+ l = <-c
+ if i, e := strconv.ParseFloat(l.token, 32); e != nil {
+ return nil, &ParseError{f, "bad LOC Longitude seconds", l}, ""
+ } else {
+ rr.Longitude += uint32(1000 * i)
+ }
+ <-c // _BLANK
+ // Either number, 'E' or 'W'
+ l = <-c
+ if rr.Longitude, ok = locCheckEast(l.token, rr.Longitude); ok {
+ goto Altitude
+ }
+ // If still alive, flag an error
+ return nil, &ParseError{f, "bad LOC Longitude East/West", l}, ""
+
+Altitude:
+ <-c // _BLANK
+ l = <-c
+ if l.token[len(l.token)-1] == 'M' || l.token[len(l.token)-1] == 'm' {
+ l.token = l.token[0 : len(l.token)-1]
+ }
+ if i, e := strconv.ParseFloat(l.token, 32); e != nil {
+ return nil, &ParseError{f, "bad LOC Altitude", l}, ""
+ } else {
+ rr.Altitude = uint32(i*100.0 + 10000000.0 + 0.5)
+ }
+
+ // And now optionally the other values
+ l = <-c
+ count := 0
+ for l.value != _NEWLINE && l.value != _EOF {
+ switch l.value {
+ case _STRING:
+ switch count {
+ case 0: // Size
+ if e, m, ok := stringToCm(l.token); !ok {
+ return nil, &ParseError{f, "bad LOC Size", l}, ""
+ } else {
+ rr.Size = (e & 0x0f) | (m << 4 & 0xf0)
+ }
+ case 1: // HorizPre
+ if e, m, ok := stringToCm(l.token); !ok {
+ return nil, &ParseError{f, "bad LOC HorizPre", l}, ""
+ } else {
+ rr.HorizPre = (e & 0x0f) | (m << 4 & 0xf0)
+ }
+ case 2: // VertPre
+ if e, m, ok := stringToCm(l.token); !ok {
+ return nil, &ParseError{f, "bad LOC VertPre", l}, ""
+ } else {
+ rr.VertPre = (e & 0x0f) | (m << 4 & 0xf0)
+ }
+ }
+ count++
+ case _BLANK:
+ // Ok
+ default:
+ return nil, &ParseError{f, "bad LOC Size, HorizPre or VertPre", l}, ""
+ }
+ l = <-c
+ }
+ return rr, nil, ""
+}
+
+func setHIP(h RR_Header, c chan lex, o, f string) (RR, *ParseError, string) {
+ rr := new(HIP)
+ rr.Hdr = h
+
+ // HitLength is not represented
+ l := <-c
+ if l.length == 0 {
+ return rr, nil, l.comment
+ }
+ if i, e := strconv.Atoi(l.token); e != nil {
+ return nil, &ParseError{f, "bad HIP PublicKeyAlgorithm", l}, ""
+ } else {
+ rr.PublicKeyAlgorithm = uint8(i)
+ }
+ <-c // _BLANK
+ l = <-c // _STRING
+ rr.Hit = l.token // This can not contain spaces, see RFC 5205 Section 6.
+ rr.HitLength = uint8(len(rr.Hit)) / 2
+
+ <-c // _BLANK
+ l = <-c // _STRING
+ rr.PublicKey = l.token // This cannot contain spaces
+ rr.PublicKeyLength = uint16(base64.StdEncoding.DecodedLen(len(rr.PublicKey)))
+
+ // RendezvousServers (if any)
+ l = <-c
+ xs := make([]string, 0)
+ for l.value != _NEWLINE && l.value != _EOF {
+ switch l.value {
+ case _STRING:
+ if l.token == "@" {
+ xs = append(xs, o)
+ continue
+ }
+ _, ok := IsDomainName(l.token)
+ if !ok || l.length == 0 {
+ return nil, &ParseError{f, "bad HIP RendezvousServers", l}, ""
+ }
+ if l.token[l.length-1] != '.' {
+ l.token = appendOrigin(l.token, o)
+ }
+ xs = append(xs, l.token)
+ case _BLANK:
+ // Ok
+ default:
+ return nil, &ParseError{f, "bad HIP RendezvousServers", l}, ""
+ }
+ l = <-c
+ }
+ rr.RendezvousServers = xs
+ return rr, nil, l.comment
+}
+
+func setCERT(h RR_Header, c chan lex, o, f string) (RR, *ParseError, string) {
+ rr := new(CERT)
+ rr.Hdr = h
+
+ l := <-c
+ if l.length == 0 {
+ return rr, nil, l.comment
+ }
+ if v, ok := StringToCertType[l.token]; ok {
+ rr.Type = v
+ } else if i, e := strconv.Atoi(l.token); e != nil {
+ return nil, &ParseError{f, "bad CERT Type", l}, ""
+ } else {
+ rr.Type = uint16(i)
+ }
+ <-c // _BLANK
+ l = <-c // _STRING
+ if i, e := strconv.Atoi(l.token); e != nil {
+ return nil, &ParseError{f, "bad CERT KeyTag", l}, ""
+ } else {
+ rr.KeyTag = uint16(i)
+ }
+ <-c // _BLANK
+ l = <-c // _STRING
+ if v, ok := StringToAlgorithm[l.token]; ok {
+ rr.Algorithm = v
+ } else if i, e := strconv.Atoi(l.token); e != nil {
+ return nil, &ParseError{f, "bad CERT Algorithm", l}, ""
+ } else {
+ rr.Algorithm = uint8(i)
+ }
+ s, e, c1 := endingToString(c, "bad CERT Certificate", f)
+ if e != nil {
+ return nil, e, c1
+ }
+ rr.Certificate = s
+ return rr, nil, c1
+}
+
+func setOPENPGPKEY(h RR_Header, c chan lex, o, f string) (RR, *ParseError, string) {
+ rr := new(OPENPGPKEY)
+ rr.Hdr = h
+
+ s, e, c1 := endingToString(c, "bad OPENPGPKEY PublicKey", f)
+ if e != nil {
+ return nil, e, c1
+ }
+ rr.PublicKey = s
+ return rr, nil, c1
+}
+
+func setSIG(h RR_Header, c chan lex, o, f string) (RR, *ParseError, string) {
+ r, e, s := setRRSIG(h, c, o, f)
+ if r != nil {
+ return &SIG{*r.(*RRSIG)}, e, s
+ }
+ return nil, e, s
+}
+
+func setRRSIG(h RR_Header, c chan lex, o, f string) (RR, *ParseError, string) {
+ rr := new(RRSIG)
+ rr.Hdr = h
+ l := <-c
+ if l.length == 0 {
+ return rr, nil, l.comment
+ }
+ if t, ok := StringToType[l.tokenUpper]; !ok {
+ if strings.HasPrefix(l.tokenUpper, "TYPE") {
+ if t, ok = typeToInt(l.tokenUpper); !ok {
+ return nil, &ParseError{f, "bad RRSIG Typecovered", l}, ""
+ } else {
+ rr.TypeCovered = t
+ }
+ } else {
+ return nil, &ParseError{f, "bad RRSIG Typecovered", l}, ""
+ }
+ } else {
+ rr.TypeCovered = t
+ }
+ <-c // _BLANK
+ l = <-c
+ if i, err := strconv.Atoi(l.token); err != nil {
+ return nil, &ParseError{f, "bad RRSIG Algorithm", l}, ""
+ } else {
+ rr.Algorithm = uint8(i)
+ }
+ <-c // _BLANK
+ l = <-c
+ if i, err := strconv.Atoi(l.token); err != nil {
+ return nil, &ParseError{f, "bad RRSIG Labels", l}, ""
+ } else {
+ rr.Labels = uint8(i)
+ }
+ <-c // _BLANK
+ l = <-c
+ if i, err := strconv.Atoi(l.token); err != nil {
+ return nil, &ParseError{f, "bad RRSIG OrigTtl", l}, ""
+ } else {
+ rr.OrigTtl = uint32(i)
+ }
+ <-c // _BLANK
+ l = <-c
+ if i, err := StringToTime(l.token); err != nil {
+ // Try to see if all numeric and use it as epoch
+ if i, err := strconv.ParseInt(l.token, 10, 64); err == nil {
+ // TODO(miek): error out on > MAX_UINT32, same below
+ rr.Expiration = uint32(i)
+ } else {
+ return nil, &ParseError{f, "bad RRSIG Expiration", l}, ""
+ }
+ } else {
+ rr.Expiration = i
+ }
+ <-c // _BLANK
+ l = <-c
+ if i, err := StringToTime(l.token); err != nil {
+ if i, err := strconv.ParseInt(l.token, 10, 64); err == nil {
+ rr.Inception = uint32(i)
+ } else {
+ return nil, &ParseError{f, "bad RRSIG Inception", l}, ""
+ }
+ } else {
+ rr.Inception = i
+ }
+ <-c // _BLANK
+ l = <-c
+ if i, err := strconv.Atoi(l.token); err != nil {
+ return nil, &ParseError{f, "bad RRSIG KeyTag", l}, ""
+ } else {
+ rr.KeyTag = uint16(i)
+ }
+ <-c // _BLANK
+ l = <-c
+ rr.SignerName = l.token
+ if l.token == "@" {
+ rr.SignerName = o
+ } else {
+ _, ok := IsDomainName(l.token)
+ if !ok || l.length == 0 {
+ return nil, &ParseError{f, "bad RRSIG SignerName", l}, ""
+ }
+ if rr.SignerName[l.length-1] != '.' {
+ rr.SignerName = appendOrigin(rr.SignerName, o)
+ }
+ }
+ s, e, c1 := endingToString(c, "bad RRSIG Signature", f)
+ if e != nil {
+ return nil, e, c1
+ }
+ rr.Signature = s
+ return rr, nil, c1
+}
+
+func setNSEC(h RR_Header, c chan lex, o, f string) (RR, *ParseError, string) {
+ rr := new(NSEC)
+ rr.Hdr = h
+
+ l := <-c
+ rr.NextDomain = l.token
+ if l.length == 0 {
+ return rr, nil, l.comment
+ }
+ if l.token == "@" {
+ rr.NextDomain = o
+ } else {
+ _, ok := IsDomainName(l.token)
+ if !ok {
+ return nil, &ParseError{f, "bad NSEC NextDomain", l}, ""
+ }
+ if rr.NextDomain[l.length-1] != '.' {
+ rr.NextDomain = appendOrigin(rr.NextDomain, o)
+ }
+ }
+
+ rr.TypeBitMap = make([]uint16, 0)
+ var (
+ k uint16
+ ok bool
+ )
+ l = <-c
+ for l.value != _NEWLINE && l.value != _EOF {
+ switch l.value {
+ case _BLANK:
+ // Ok
+ case _STRING:
+ if k, ok = StringToType[l.tokenUpper]; !ok {
+ if k, ok = typeToInt(l.tokenUpper); !ok {
+ return nil, &ParseError{f, "bad NSEC TypeBitMap", l}, ""
+ }
+ }
+ rr.TypeBitMap = append(rr.TypeBitMap, k)
+ default:
+ return nil, &ParseError{f, "bad NSEC TypeBitMap", l}, ""
+ }
+ l = <-c
+ }
+ return rr, nil, l.comment
+}
+
+func setNSEC3(h RR_Header, c chan lex, o, f string) (RR, *ParseError, string) {
+ rr := new(NSEC3)
+ rr.Hdr = h
+
+ l := <-c
+ if l.length == 0 {
+ return rr, nil, l.comment
+ }
+ if i, e := strconv.Atoi(l.token); e != nil {
+ return nil, &ParseError{f, "bad NSEC3 Hash", l}, ""
+ } else {
+ rr.Hash = uint8(i)
+ }
+ <-c // _BLANK
+ l = <-c
+ if i, e := strconv.Atoi(l.token); e != nil {
+ return nil, &ParseError{f, "bad NSEC3 Flags", l}, ""
+ } else {
+ rr.Flags = uint8(i)
+ }
+ <-c // _BLANK
+ l = <-c
+ if i, e := strconv.Atoi(l.token); e != nil {
+ return nil, &ParseError{f, "bad NSEC3 Iterations", l}, ""
+ } else {
+ rr.Iterations = uint16(i)
+ }
+ <-c
+ l = <-c
+ if len(l.token) == 0 {
+ return nil, &ParseError{f, "bad NSEC3 Salt", l}, ""
+ }
+ rr.SaltLength = uint8(len(l.token)) / 2
+ rr.Salt = l.token
+
+ <-c
+ l = <-c
+ rr.HashLength = 20 // Fix for NSEC3 (sha1 160 bits)
+ rr.NextDomain = l.token
+
+ rr.TypeBitMap = make([]uint16, 0)
+ var (
+ k uint16
+ ok bool
+ )
+ l = <-c
+ for l.value != _NEWLINE && l.value != _EOF {
+ switch l.value {
+ case _BLANK:
+ // Ok
+ case _STRING:
+ if k, ok = StringToType[l.tokenUpper]; !ok {
+ if k, ok = typeToInt(l.tokenUpper); !ok {
+ return nil, &ParseError{f, "bad NSEC3 TypeBitMap", l}, ""
+ }
+ }
+ rr.TypeBitMap = append(rr.TypeBitMap, k)
+ default:
+ return nil, &ParseError{f, "bad NSEC3 TypeBitMap", l}, ""
+ }
+ l = <-c
+ }
+ return rr, nil, l.comment
+}
+
+func setNSEC3PARAM(h RR_Header, c chan lex, o, f string) (RR, *ParseError, string) {
+ rr := new(NSEC3PARAM)
+ rr.Hdr = h
+
+ l := <-c
+ if l.length == 0 {
+ return rr, nil, ""
+ }
+ if i, e := strconv.Atoi(l.token); e != nil {
+ return nil, &ParseError{f, "bad NSEC3PARAM Hash", l}, ""
+ } else {
+ rr.Hash = uint8(i)
+ }
+ <-c // _BLANK
+ l = <-c
+ if i, e := strconv.Atoi(l.token); e != nil {
+ return nil, &ParseError{f, "bad NSEC3PARAM Flags", l}, ""
+ } else {
+ rr.Flags = uint8(i)
+ }
+ <-c // _BLANK
+ l = <-c
+ if i, e := strconv.Atoi(l.token); e != nil {
+ return nil, &ParseError{f, "bad NSEC3PARAM Iterations", l}, ""
+ } else {
+ rr.Iterations = uint16(i)
+ }
+ <-c
+ l = <-c
+ rr.SaltLength = uint8(len(l.token))
+ rr.Salt = l.token
+ return rr, nil, ""
+}
+
+func setEUI48(h RR_Header, c chan lex, o, f string) (RR, *ParseError, string) {
+ rr := new(EUI48)
+ rr.Hdr = h
+
+ l := <-c
+ if l.length == 0 {
+ return rr, nil, ""
+ }
+ if l.length != 17 {
+ return nil, &ParseError{f, "bad EUI48 Address", l}, ""
+ }
+ addr := make([]byte, 12)
+ dash := 0
+ for i := 0; i < 10; i += 2 {
+ addr[i] = l.token[i+dash]
+ addr[i+1] = l.token[i+1+dash]
+ dash++
+ if l.token[i+1+dash] != '-' {
+ return nil, &ParseError{f, "bad EUI48 Address", l}, ""
+ }
+ }
+ addr[10] = l.token[15]
+ addr[11] = l.token[16]
+
+ if i, e := strconv.ParseUint(string(addr), 16, 48); e != nil {
+ return nil, &ParseError{f, "bad EUI48 Address", l}, ""
+ } else {
+ rr.Address = i
+ }
+ return rr, nil, ""
+}
+
+func setEUI64(h RR_Header, c chan lex, o, f string) (RR, *ParseError, string) {
+ rr := new(EUI64)
+ rr.Hdr = h
+
+ l := <-c
+ if l.length == 0 {
+ return rr, nil, ""
+ }
+ if l.length != 23 {
+ return nil, &ParseError{f, "bad EUI64 Address", l}, ""
+ }
+ addr := make([]byte, 16)
+ dash := 0
+ for i := 0; i < 14; i += 2 {
+ addr[i] = l.token[i+dash]
+ addr[i+1] = l.token[i+1+dash]
+ dash++
+ if l.token[i+1+dash] != '-' {
+ return nil, &ParseError{f, "bad EUI64 Address", l}, ""
+ }
+ }
+ addr[14] = l.token[21]
+ addr[15] = l.token[22]
+
+ if i, e := strconv.ParseUint(string(addr), 16, 64); e != nil {
+ return nil, &ParseError{f, "bad EUI68 Address", l}, ""
+ } else {
+ rr.Address = uint64(i)
+ }
+ return rr, nil, ""
+}
+
+func setWKS(h RR_Header, c chan lex, o, f string) (RR, *ParseError, string) {
+ rr := new(WKS)
+ rr.Hdr = h
+
+ l := <-c
+ if l.length == 0 {
+ return rr, nil, l.comment
+ }
+ rr.Address = net.ParseIP(l.token)
+ if rr.Address == nil {
+ return nil, &ParseError{f, "bad WKS Address", l}, ""
+ }
+
+ <-c // _BLANK
+ l = <-c
+ proto := "tcp"
+ if i, e := strconv.Atoi(l.token); e != nil {
+ return nil, &ParseError{f, "bad WKS Protocol", l}, ""
+ } else {
+ rr.Protocol = uint8(i)
+ switch rr.Protocol {
+ case 17:
+ proto = "udp"
+ case 6:
+ proto = "tcp"
+ default:
+ return nil, &ParseError{f, "bad WKS Protocol", l}, ""
+ }
+ }
+
+ <-c
+ l = <-c
+ rr.BitMap = make([]uint16, 0)
+ var (
+ k int
+ err error
+ )
+ for l.value != _NEWLINE && l.value != _EOF {
+ switch l.value {
+ case _BLANK:
+ // Ok
+ case _STRING:
+ if k, err = net.LookupPort(proto, l.token); err != nil {
+ if i, e := strconv.Atoi(l.token); e != nil { // If a number use that
+ rr.BitMap = append(rr.BitMap, uint16(i))
+ } else {
+ return nil, &ParseError{f, "bad WKS BitMap", l}, ""
+ }
+ }
+ rr.BitMap = append(rr.BitMap, uint16(k))
+ default:
+ return nil, &ParseError{f, "bad WKS BitMap", l}, ""
+ }
+ l = <-c
+ }
+ return rr, nil, l.comment
+}
+
+func setSSHFP(h RR_Header, c chan lex, o, f string) (RR, *ParseError, string) {
+ rr := new(SSHFP)
+ rr.Hdr = h
+
+ l := <-c
+ if l.length == 0 {
+ return rr, nil, ""
+ }
+ if i, e := strconv.Atoi(l.token); e != nil {
+ return nil, &ParseError{f, "bad SSHFP Algorithm", l}, ""
+ } else {
+ rr.Algorithm = uint8(i)
+ }
+ <-c // _BLANK
+ l = <-c
+ if i, e := strconv.Atoi(l.token); e != nil {
+ return nil, &ParseError{f, "bad SSHFP Type", l}, ""
+ } else {
+ rr.Type = uint8(i)
+ }
+ <-c // _BLANK
+ l = <-c
+ rr.FingerPrint = l.token
+ return rr, nil, ""
+}
+
+func setDNSKEYs(h RR_Header, c chan lex, o, f, typ string) (RR, *ParseError, string) {
+ rr := new(DNSKEY)
+ rr.Hdr = h
+
+ l := <-c
+ if l.length == 0 {
+ return rr, nil, l.comment
+ }
+ if i, e := strconv.Atoi(l.token); e != nil {
+ return nil, &ParseError{f, "bad " + typ + " Flags", l}, ""
+ } else {
+ rr.Flags = uint16(i)
+ }
+ <-c // _BLANK
+ l = <-c // _STRING
+ if i, e := strconv.Atoi(l.token); e != nil {
+ return nil, &ParseError{f, "bad " + typ + " Protocol", l}, ""
+ } else {
+ rr.Protocol = uint8(i)
+ }
+ <-c // _BLANK
+ l = <-c // _STRING
+ if i, e := strconv.Atoi(l.token); e != nil {
+ return nil, &ParseError{f, "bad " + typ + " Algorithm", l}, ""
+ } else {
+ rr.Algorithm = uint8(i)
+ }
+ s, e, c1 := endingToString(c, "bad "+typ+" PublicKey", f)
+ if e != nil {
+ return nil, e, c1
+ }
+ rr.PublicKey = s
+ return rr, nil, c1
+}
+
+func setKEY(h RR_Header, c chan lex, o, f string) (RR, *ParseError, string) {
+ r, e, s := setDNSKEYs(h, c, o, f, "KEY")
+ if r != nil {
+ return &KEY{*r.(*DNSKEY)}, e, s
+ }
+ return nil, e, s
+}
+
+func setDNSKEY(h RR_Header, c chan lex, o, f string) (RR, *ParseError, string) {
+ r, e, s := setDNSKEYs(h, c, o, f, "DNSKEY")
+ return r, e, s
+}
+
+func setCDNSKEY(h RR_Header, c chan lex, o, f string) (RR, *ParseError, string) {
+ r, e, s := setDNSKEYs(h, c, o, f, "CDNSKEY")
+ if r != nil {
+ return &CDNSKEY{*r.(*DNSKEY)}, e, s
+ }
+ return nil, e, s
+}
+
+func setRKEY(h RR_Header, c chan lex, o, f string) (RR, *ParseError, string) {
+ rr := new(RKEY)
+ rr.Hdr = h
+
+ l := <-c
+ if l.length == 0 {
+ return rr, nil, l.comment
+ }
+ if i, e := strconv.Atoi(l.token); e != nil {
+ return nil, &ParseError{f, "bad RKEY Flags", l}, ""
+ } else {
+ rr.Flags = uint16(i)
+ }
+ <-c // _BLANK
+ l = <-c // _STRING
+ if i, e := strconv.Atoi(l.token); e != nil {
+ return nil, &ParseError{f, "bad RKEY Protocol", l}, ""
+ } else {
+ rr.Protocol = uint8(i)
+ }
+ <-c // _BLANK
+ l = <-c // _STRING
+ if i, e := strconv.Atoi(l.token); e != nil {
+ return nil, &ParseError{f, "bad RKEY Algorithm", l}, ""
+ } else {
+ rr.Algorithm = uint8(i)
+ }
+ s, e, c1 := endingToString(c, "bad RKEY PublicKey", f)
+ if e != nil {
+ return nil, e, c1
+ }
+ rr.PublicKey = s
+ return rr, nil, c1
+}
+
+func setEID(h RR_Header, c chan lex, o, f string) (RR, *ParseError, string) {
+ rr := new(EID)
+ rr.Hdr = h
+ s, e, c1 := endingToString(c, "bad EID Endpoint", f)
+ if e != nil {
+ return nil, e, c1
+ }
+ rr.Endpoint = s
+ return rr, nil, c1
+}
+
+func setNIMLOC(h RR_Header, c chan lex, o, f string) (RR, *ParseError, string) {
+ rr := new(NIMLOC)
+ rr.Hdr = h
+ s, e, c1 := endingToString(c, "bad NIMLOC Locator", f)
+ if e != nil {
+ return nil, e, c1
+ }
+ rr.Locator = s
+ return rr, nil, c1
+}
+
+func setNSAP(h RR_Header, c chan lex, o, f string) (RR, *ParseError, string) {
+ rr := new(NSAP)
+ rr.Hdr = h
+ l := <-c
+ if l.length == 0 {
+ return rr, nil, l.comment
+ }
+ if i, e := strconv.Atoi(l.token); e != nil {
+ return nil, &ParseError{f, "bad NSAP Length", l}, ""
+ } else {
+ rr.Length = uint8(i)
+ }
+ <-c // _BLANK
+ s, e, c1 := endingToString(c, "bad NSAP Nsap", f)
+ if e != nil {
+ return nil, e, c1
+ }
+ rr.Nsap = s
+ return rr, nil, c1
+}
+
+func setGPOS(h RR_Header, c chan lex, o, f string) (RR, *ParseError, string) {
+ rr := new(GPOS)
+ rr.Hdr = h
+ l := <-c
+ if l.length == 0 {
+ return rr, nil, ""
+ }
+ if _, e := strconv.ParseFloat(l.token, 64); e != nil {
+ return nil, &ParseError{f, "bad GPOS Longitude", l}, ""
+ } else {
+ rr.Longitude = l.token
+ }
+ <-c // _BLANK
+ l = <-c
+ if _, e := strconv.ParseFloat(l.token, 64); e != nil {
+ return nil, &ParseError{f, "bad GPOS Latitude", l}, ""
+ } else {
+ rr.Latitude = l.token
+ }
+ <-c // _BLANK
+ l = <-c
+ if _, e := strconv.ParseFloat(l.token, 64); e != nil {
+ return nil, &ParseError{f, "bad GPOS Altitude", l}, ""
+ } else {
+ rr.Altitude = l.token
+ }
+ return rr, nil, ""
+}
+
+func setDSs(h RR_Header, c chan lex, o, f, typ string) (RR, *ParseError, string) {
+ rr := new(DS)
+ rr.Hdr = h
+ l := <-c
+ if l.length == 0 {
+ return rr, nil, l.comment
+ }
+ if i, e := strconv.Atoi(l.token); e != nil {
+ return nil, &ParseError{f, "bad " + typ + " KeyTag", l}, ""
+ } else {
+ rr.KeyTag = uint16(i)
+ }
+ <-c // _BLANK
+ l = <-c
+ if i, e := strconv.Atoi(l.token); e != nil {
+ if i, ok := StringToAlgorithm[l.tokenUpper]; !ok {
+ return nil, &ParseError{f, "bad " + typ + " Algorithm", l}, ""
+ } else {
+ rr.Algorithm = i
+ }
+ } else {
+ rr.Algorithm = uint8(i)
+ }
+ <-c // _BLANK
+ l = <-c
+ if i, e := strconv.Atoi(l.token); e != nil {
+ return nil, &ParseError{f, "bad " + typ + " DigestType", l}, ""
+ } else {
+ rr.DigestType = uint8(i)
+ }
+ s, e, c1 := endingToString(c, "bad "+typ+" Digest", f)
+ if e != nil {
+ return nil, e, c1
+ }
+ rr.Digest = s
+ return rr, nil, c1
+}
+
+func setDS(h RR_Header, c chan lex, o, f string) (RR, *ParseError, string) {
+ r, e, s := setDSs(h, c, o, f, "DS")
+ return r, e, s
+}
+
+func setDLV(h RR_Header, c chan lex, o, f string) (RR, *ParseError, string) {
+ r, e, s := setDSs(h, c, o, f, "DLV")
+ if r != nil {
+ return &DLV{*r.(*DS)}, e, s
+ }
+ return nil, e, s
+}
+
+func setCDS(h RR_Header, c chan lex, o, f string) (RR, *ParseError, string) {
+ r, e, s := setDSs(h, c, o, f, "DLV")
+ if r != nil {
+ return &CDS{*r.(*DS)}, e, s
+ }
+ return nil, e, s
+}
+
+func setTA(h RR_Header, c chan lex, o, f string) (RR, *ParseError, string) {
+ rr := new(TA)
+ rr.Hdr = h
+ l := <-c
+ if l.length == 0 {
+ return rr, nil, l.comment
+ }
+ if i, e := strconv.Atoi(l.token); e != nil {
+ return nil, &ParseError{f, "bad TA KeyTag", l}, ""
+ } else {
+ rr.KeyTag = uint16(i)
+ }
+ <-c // _BLANK
+ l = <-c
+ if i, e := strconv.Atoi(l.token); e != nil {
+ if i, ok := StringToAlgorithm[l.tokenUpper]; !ok {
+ return nil, &ParseError{f, "bad TA Algorithm", l}, ""
+ } else {
+ rr.Algorithm = i
+ }
+ } else {
+ rr.Algorithm = uint8(i)
+ }
+ <-c // _BLANK
+ l = <-c
+ if i, e := strconv.Atoi(l.token); e != nil {
+ return nil, &ParseError{f, "bad TA DigestType", l}, ""
+ } else {
+ rr.DigestType = uint8(i)
+ }
+ s, e, c1 := endingToString(c, "bad TA Digest", f)
+ if e != nil {
+ return nil, e, c1
+ }
+ rr.Digest = s
+ return rr, nil, c1
+}
+
+func setTLSA(h RR_Header, c chan lex, o, f string) (RR, *ParseError, string) {
+ rr := new(TLSA)
+ rr.Hdr = h
+ l := <-c
+ if l.length == 0 {
+ return rr, nil, l.comment
+ }
+ if i, e := strconv.Atoi(l.token); e != nil {
+ return nil, &ParseError{f, "bad TLSA Usage", l}, ""
+ } else {
+ rr.Usage = uint8(i)
+ }
+ <-c // _BLANK
+ l = <-c
+ if i, e := strconv.Atoi(l.token); e != nil {
+ return nil, &ParseError{f, "bad TLSA Selector", l}, ""
+ } else {
+ rr.Selector = uint8(i)
+ }
+ <-c // _BLANK
+ l = <-c
+ if i, e := strconv.Atoi(l.token); e != nil {
+ return nil, &ParseError{f, "bad TLSA MatchingType", l}, ""
+ } else {
+ rr.MatchingType = uint8(i)
+ }
+ s, e, c1 := endingToString(c, "bad TLSA Certificate", f)
+ if e != nil {
+ return nil, e, c1
+ }
+ rr.Certificate = s
+ return rr, nil, c1
+}
+
+func setRFC3597(h RR_Header, c chan lex, o, f string) (RR, *ParseError, string) {
+ rr := new(RFC3597)
+ rr.Hdr = h
+ l := <-c
+ if l.token != "\\#" {
+ return nil, &ParseError{f, "bad RFC3597 Rdata", l}, ""
+ }
+ <-c // _BLANK
+ l = <-c
+ rdlength, e := strconv.Atoi(l.token)
+ if e != nil {
+ return nil, &ParseError{f, "bad RFC3597 Rdata ", l}, ""
+ }
+
+ s, e1, c1 := endingToString(c, "bad RFC3597 Rdata", f)
+ if e1 != nil {
+ return nil, e1, c1
+ }
+ if rdlength*2 != len(s) {
+ return nil, &ParseError{f, "bad RFC3597 Rdata", l}, ""
+ }
+ rr.Rdata = s
+ return rr, nil, c1
+}
+
+func setSPF(h RR_Header, c chan lex, o, f string) (RR, *ParseError, string) {
+ rr := new(SPF)
+ rr.Hdr = h
+
+ s, e, c1 := endingToTxtSlice(c, "bad SPF Txt", f)
+ if e != nil {
+ return nil, e, ""
+ }
+ rr.Txt = s
+ return rr, nil, c1
+}
+
+func setTXT(h RR_Header, c chan lex, o, f string) (RR, *ParseError, string) {
+ rr := new(TXT)
+ rr.Hdr = h
+
+ // No _BLANK reading here, because this is all rdata is TXT
+ s, e, c1 := endingToTxtSlice(c, "bad TXT Txt", f)
+ if e != nil {
+ return nil, e, ""
+ }
+ rr.Txt = s
+ return rr, nil, c1
+}
+
+// identical to setTXT
+func setNINFO(h RR_Header, c chan lex, o, f string) (RR, *ParseError, string) {
+ rr := new(NINFO)
+ rr.Hdr = h
+
+ s, e, c1 := endingToTxtSlice(c, "bad NINFO ZSData", f)
+ if e != nil {
+ return nil, e, ""
+ }
+ rr.ZSData = s
+ return rr, nil, c1
+}
+
+func setURI(h RR_Header, c chan lex, o, f string) (RR, *ParseError, string) {
+ rr := new(URI)
+ rr.Hdr = h
+
+ l := <-c
+ if l.length == 0 {
+ return rr, nil, l.comment
+ }
+ if i, e := strconv.Atoi(l.token); e != nil {
+ return nil, &ParseError{f, "bad URI Priority", l}, ""
+ } else {
+ rr.Priority = uint16(i)
+ }
+ <-c // _BLANK
+ l = <-c
+ if i, e := strconv.Atoi(l.token); e != nil {
+ return nil, &ParseError{f, "bad URI Weight", l}, ""
+ } else {
+ rr.Weight = uint16(i)
+ }
+
+ <-c // _BLANK
+ s, e, c1 := endingToTxtSlice(c, "bad URI Target", f)
+ if e != nil {
+ return nil, e, ""
+ }
+ rr.Target = s
+ return rr, nil, c1
+}
+
+func setIPSECKEY(h RR_Header, c chan lex, o, f string) (RR, *ParseError, string) {
+ rr := new(IPSECKEY)
+ rr.Hdr = h
+
+ l := <-c
+ if l.length == 0 {
+ return rr, nil, l.comment
+ }
+ if i, e := strconv.Atoi(l.token); e != nil {
+ return nil, &ParseError{f, "bad IPSECKEY Precedence", l}, ""
+ } else {
+ rr.Precedence = uint8(i)
+ }
+ <-c // _BLANK
+ l = <-c
+ if i, e := strconv.Atoi(l.token); e != nil {
+ return nil, &ParseError{f, "bad IPSECKEY GatewayType", l}, ""
+ } else {
+ rr.GatewayType = uint8(i)
+ }
+ <-c // _BLANK
+ l = <-c
+ if i, e := strconv.Atoi(l.token); e != nil {
+ return nil, &ParseError{f, "bad IPSECKEY Algorithm", l}, ""
+ } else {
+ rr.Algorithm = uint8(i)
+ }
+ <-c
+ l = <-c
+ rr.Gateway = l.token
+ s, e, c1 := endingToString(c, "bad IPSECKEY PublicKey", f)
+ if e != nil {
+ return nil, e, c1
+ }
+ rr.PublicKey = s
+ return rr, nil, c1
+}
+
+func setDHCID(h RR_Header, c chan lex, o, f string) (RR, *ParseError, string) {
+ // awesome record to parse!
+ rr := new(DHCID)
+ rr.Hdr = h
+
+ s, e, c1 := endingToString(c, "bad DHCID Digest", f)
+ if e != nil {
+ return nil, e, c1
+ }
+ rr.Digest = s
+ return rr, nil, c1
+}
+
+func setNID(h RR_Header, c chan lex, o, f string) (RR, *ParseError, string) {
+ rr := new(NID)
+ rr.Hdr = h
+
+ l := <-c
+ if l.length == 0 {
+ return rr, nil, ""
+ }
+ if i, e := strconv.Atoi(l.token); e != nil {
+ return nil, &ParseError{f, "bad NID Preference", l}, ""
+ } else {
+ rr.Preference = uint16(i)
+ }
+ <-c // _BLANK
+ l = <-c // _STRING
+ u, err := stringToNodeID(l)
+ if err != nil {
+ return nil, err, ""
+ }
+ rr.NodeID = u
+ return rr, nil, ""
+}
+
+func setL32(h RR_Header, c chan lex, o, f string) (RR, *ParseError, string) {
+ rr := new(L32)
+ rr.Hdr = h
+
+ l := <-c
+ if l.length == 0 {
+ return rr, nil, ""
+ }
+ if i, e := strconv.Atoi(l.token); e != nil {
+ return nil, &ParseError{f, "bad L32 Preference", l}, ""
+ } else {
+ rr.Preference = uint16(i)
+ }
+ <-c // _BLANK
+ l = <-c // _STRING
+ rr.Locator32 = net.ParseIP(l.token)
+ if rr.Locator32 == nil {
+ return nil, &ParseError{f, "bad L32 Locator", l}, ""
+ }
+ return rr, nil, ""
+}
+
+func setLP(h RR_Header, c chan lex, o, f string) (RR, *ParseError, string) {
+ rr := new(LP)
+ rr.Hdr = h
+
+ l := <-c
+ if l.length == 0 {
+ return rr, nil, ""
+ }
+ if i, e := strconv.Atoi(l.token); e != nil {
+ return nil, &ParseError{f, "bad LP Preference", l}, ""
+ } else {
+ rr.Preference = uint16(i)
+ }
+ <-c // _BLANK
+ l = <-c // _STRING
+ rr.Fqdn = l.token
+ if l.length == 0 {
+ return rr, nil, ""
+ }
+ if l.token == "@" {
+ rr.Fqdn = o
+ return rr, nil, ""
+ }
+ _, ok := IsDomainName(l.token)
+ if !ok || l.length == 0 {
+ return nil, &ParseError{f, "bad LP Fqdn", l}, ""
+ }
+ if rr.Fqdn[l.length-1] != '.' {
+ rr.Fqdn = appendOrigin(rr.Fqdn, o)
+ }
+ return rr, nil, ""
+}
+
+func setL64(h RR_Header, c chan lex, o, f string) (RR, *ParseError, string) {
+ rr := new(L64)
+ rr.Hdr = h
+
+ l := <-c
+ if l.length == 0 {
+ return rr, nil, ""
+ }
+ if i, e := strconv.Atoi(l.token); e != nil {
+ return nil, &ParseError{f, "bad L64 Preference", l}, ""
+ } else {
+ rr.Preference = uint16(i)
+ }
+ <-c // _BLANK
+ l = <-c // _STRING
+ u, err := stringToNodeID(l)
+ if err != nil {
+ return nil, err, ""
+ }
+ rr.Locator64 = u
+ return rr, nil, ""
+}
+
+func setUID(h RR_Header, c chan lex, o, f string) (RR, *ParseError, string) {
+ rr := new(UID)
+ rr.Hdr = h
+ l := <-c
+ if l.length == 0 {
+ return rr, nil, ""
+ }
+ if i, e := strconv.Atoi(l.token); e != nil {
+ return nil, &ParseError{f, "bad UID Uid", l}, ""
+ } else {
+ rr.Uid = uint32(i)
+ }
+ return rr, nil, ""
+}
+
+func setGID(h RR_Header, c chan lex, o, f string) (RR, *ParseError, string) {
+ rr := new(GID)
+ rr.Hdr = h
+ l := <-c
+ if l.length == 0 {
+ return rr, nil, ""
+ }
+ if i, e := strconv.Atoi(l.token); e != nil {
+ return nil, &ParseError{f, "bad GID Gid", l}, ""
+ } else {
+ rr.Gid = uint32(i)
+ }
+ return rr, nil, ""
+}
+
+func setUINFO(h RR_Header, c chan lex, o, f string) (RR, *ParseError, string) {
+ rr := new(UINFO)
+ rr.Hdr = h
+ s, e, c1 := endingToTxtSlice(c, "bad UINFO Uinfo", f)
+ if e != nil {
+ return nil, e, ""
+ }
+ rr.Uinfo = s[0] // silently discard anything above
+ return rr, nil, c1
+}
+
+func setPX(h RR_Header, c chan lex, o, f string) (RR, *ParseError, string) {
+ rr := new(PX)
+ rr.Hdr = h
+
+ l := <-c
+ if l.length == 0 {
+ return rr, nil, ""
+ }
+ if i, e := strconv.Atoi(l.token); e != nil {
+ return nil, &ParseError{f, "bad PX Preference", l}, ""
+ } else {
+ rr.Preference = uint16(i)
+ }
+ <-c // _BLANK
+ l = <-c // _STRING
+ rr.Map822 = l.token
+ if l.length == 0 {
+ return rr, nil, ""
+ }
+ if l.token == "@" {
+ rr.Map822 = o
+ return rr, nil, ""
+ }
+ _, ok := IsDomainName(l.token)
+ if !ok {
+ return nil, &ParseError{f, "bad PX Map822", l}, ""
+ }
+ if rr.Map822[l.length-1] != '.' {
+ rr.Map822 = appendOrigin(rr.Map822, o)
+ }
+ <-c // _BLANK
+ l = <-c // _STRING
+ rr.Mapx400 = l.token
+ if l.token == "@" {
+ rr.Mapx400 = o
+ return rr, nil, ""
+ }
+ _, ok = IsDomainName(l.token)
+ if !ok || l.length == 0 {
+ return nil, &ParseError{f, "bad PX Mapx400", l}, ""
+ }
+ if rr.Mapx400[l.length-1] != '.' {
+ rr.Mapx400 = appendOrigin(rr.Mapx400, o)
+ }
+ return rr, nil, ""
+}
+
+var typeToparserFunc = map[uint16]parserFunc{
+ TypeAAAA: parserFunc{setAAAA, false},
+ TypeAFSDB: parserFunc{setAFSDB, false},
+ TypeA: parserFunc{setA, false},
+ TypeCDS: parserFunc{setCDS, true},
+ TypeCDNSKEY: parserFunc{setCDNSKEY, true},
+ TypeCERT: parserFunc{setCERT, true},
+ TypeCNAME: parserFunc{setCNAME, false},
+ TypeDHCID: parserFunc{setDHCID, true},
+ TypeDLV: parserFunc{setDLV, true},
+ TypeDNAME: parserFunc{setDNAME, false},
+ TypeKEY: parserFunc{setKEY, true},
+ TypeDNSKEY: parserFunc{setDNSKEY, true},
+ TypeDS: parserFunc{setDS, true},
+ TypeEID: parserFunc{setEID, true},
+ TypeEUI48: parserFunc{setEUI48, false},
+ TypeEUI64: parserFunc{setEUI64, false},
+ TypeGID: parserFunc{setGID, false},
+ TypeGPOS: parserFunc{setGPOS, false},
+ TypeHINFO: parserFunc{setHINFO, false},
+ TypeHIP: parserFunc{setHIP, true},
+ TypeIPSECKEY: parserFunc{setIPSECKEY, true},
+ TypeKX: parserFunc{setKX, false},
+ TypeL32: parserFunc{setL32, false},
+ TypeL64: parserFunc{setL64, false},
+ TypeLOC: parserFunc{setLOC, true},
+ TypeLP: parserFunc{setLP, false},
+ TypeMB: parserFunc{setMB, false},
+ TypeMD: parserFunc{setMD, false},
+ TypeMF: parserFunc{setMF, false},
+ TypeMG: parserFunc{setMG, false},
+ TypeMINFO: parserFunc{setMINFO, false},
+ TypeMR: parserFunc{setMR, false},
+ TypeMX: parserFunc{setMX, false},
+ TypeNAPTR: parserFunc{setNAPTR, false},
+ TypeNID: parserFunc{setNID, false},
+ TypeNIMLOC: parserFunc{setNIMLOC, true},
+ TypeNINFO: parserFunc{setNINFO, true},
+ TypeNSAP: parserFunc{setNSAP, true},
+ TypeNSAPPTR: parserFunc{setNSAPPTR, false},
+ TypeNSEC3PARAM: parserFunc{setNSEC3PARAM, false},
+ TypeNSEC3: parserFunc{setNSEC3, true},
+ TypeNSEC: parserFunc{setNSEC, true},
+ TypeNS: parserFunc{setNS, false},
+ TypeOPENPGPKEY: parserFunc{setOPENPGPKEY, true},
+ TypePTR: parserFunc{setPTR, false},
+ TypePX: parserFunc{setPX, false},
+ TypeSIG: parserFunc{setSIG, true},
+ TypeRKEY: parserFunc{setRKEY, true},
+ TypeRP: parserFunc{setRP, false},
+ TypeRRSIG: parserFunc{setRRSIG, true},
+ TypeRT: parserFunc{setRT, false},
+ TypeSOA: parserFunc{setSOA, false},
+ TypeSPF: parserFunc{setSPF, true},
+ TypeSRV: parserFunc{setSRV, false},
+ TypeSSHFP: parserFunc{setSSHFP, false},
+ TypeTALINK: parserFunc{setTALINK, false},
+ TypeTA: parserFunc{setTA, true},
+ TypeTLSA: parserFunc{setTLSA, true},
+ TypeTXT: parserFunc{setTXT, true},
+ TypeUID: parserFunc{setUID, false},
+ TypeUINFO: parserFunc{setUINFO, true},
+ TypeURI: parserFunc{setURI, true},
+ TypeWKS: parserFunc{setWKS, true},
+ TypeX25: parserFunc{setX25, false},
+}
diff --git a/Godeps/_workspace/src/github.com/nu7hatch/gouuid/.gitignore b/Godeps/_workspace/src/github.com/nu7hatch/gouuid/.gitignore
new file mode 100644
index 0000000000000000000000000000000000000000..f9d9cd8abe0d41c7bfeef71c98ac516b6c6e86e1
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/nu7hatch/gouuid/.gitignore
@@ -0,0 +1,11 @@
+_obj
+_test
+*.6
+*.out
+_testmain.go
+\#*
+.\#*
+*.log
+_cgo*
+*.o
+*.a
diff --git a/Godeps/_workspace/src/github.com/nu7hatch/gouuid/COPYING b/Godeps/_workspace/src/github.com/nu7hatch/gouuid/COPYING
new file mode 100644
index 0000000000000000000000000000000000000000..d7849fd8fb877b4f2bd0f9a2fd016de7b8636041
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/nu7hatch/gouuid/COPYING
@@ -0,0 +1,19 @@
+Copyright (C) 2011 by Krzysztof Kowalik <chris@nu7hat.ch>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
\ No newline at end of file
diff --git a/Godeps/_workspace/src/github.com/nu7hatch/gouuid/README.md b/Godeps/_workspace/src/github.com/nu7hatch/gouuid/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..e3d025d5e5b60339df7af52e3244887a4db420d9
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/nu7hatch/gouuid/README.md
@@ -0,0 +1,21 @@
+# Pure Go UUID implementation
+
+This package provides immutable UUID structs and the functions
+NewV3, NewV4, NewV5 and Parse() for generating versions 3, 4
+and 5 UUIDs as specified in [RFC 4122](http://www.ietf.org/rfc/rfc4122.txt).
+
+## Installation
+
+Use the `go` tool:
+
+ $ go get github.com/nu7hatch/gouuid
+
+## Usage
+
+See [documentation and examples](http://godoc.org/github.com/nu7hatch/gouuid)
+for more information.
+
+## Copyright
+
+Copyright (C) 2011 by Krzysztof Kowalik <chris@nu7hat.ch>. See [COPYING](https://github.com/nu7hatch/gouuid/tree/master/COPYING)
+file for details.
diff --git a/Godeps/_workspace/src/github.com/nu7hatch/gouuid/example_test.go b/Godeps/_workspace/src/github.com/nu7hatch/gouuid/example_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..9e86fdc3db5f13b88116e89ff20b993cafac392b
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/nu7hatch/gouuid/example_test.go
@@ -0,0 +1,33 @@
+package uuid_test
+
+import (
+ "fmt"
+ "github.com/nu7hatch/gouuid"
+)
+
+func ExampleNewV4() {
+ u4, err := uuid.NewV4()
+ if err != nil {
+ fmt.Println("error:", err)
+ return
+ }
+ fmt.Println(u4)
+}
+
+func ExampleNewV5() {
+ u5, err := uuid.NewV5(uuid.NamespaceURL, []byte("nu7hat.ch"))
+ if err != nil {
+ fmt.Println("error:", err)
+ return
+ }
+ fmt.Println(u5)
+}
+
+func ExampleParseHex() {
+ u, err := uuid.ParseHex("6ba7b810-9dad-11d1-80b4-00c04fd430c8")
+ if err != nil {
+ fmt.Println("error:", err)
+ return
+ }
+ fmt.Println(u)
+}
diff --git a/Godeps/_workspace/src/github.com/nu7hatch/gouuid/uuid.go b/Godeps/_workspace/src/github.com/nu7hatch/gouuid/uuid.go
new file mode 100644
index 0000000000000000000000000000000000000000..ac9623b729f6432d6afeeda14914f82f4e9a5b9a
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/nu7hatch/gouuid/uuid.go
@@ -0,0 +1,173 @@
+// This package provides immutable UUID structs and the functions
+// NewV3, NewV4, NewV5 and Parse() for generating versions 3, 4
+// and 5 UUIDs as specified in RFC 4122.
+//
+// Copyright (C) 2011 by Krzysztof Kowalik <chris@nu7hat.ch>
+package uuid
+
+import (
+ "crypto/md5"
+ "crypto/rand"
+ "crypto/sha1"
+ "encoding/hex"
+ "errors"
+ "fmt"
+ "hash"
+ "regexp"
+)
+
+// The UUID reserved variants.
+const (
+ ReservedNCS byte = 0x80
+ ReservedRFC4122 byte = 0x40
+ ReservedMicrosoft byte = 0x20
+ ReservedFuture byte = 0x00
+)
+
+// The following standard UUIDs are for use with NewV3() or NewV5().
+var (
+ NamespaceDNS, _ = ParseHex("6ba7b810-9dad-11d1-80b4-00c04fd430c8")
+ NamespaceURL, _ = ParseHex("6ba7b811-9dad-11d1-80b4-00c04fd430c8")
+ NamespaceOID, _ = ParseHex("6ba7b812-9dad-11d1-80b4-00c04fd430c8")
+ NamespaceX500, _ = ParseHex("6ba7b814-9dad-11d1-80b4-00c04fd430c8")
+)
+
+// Pattern used to parse hex string representation of the UUID.
+// FIXME: do something to consider both brackets at one time,
+// current one allows to parse string with only one opening
+// or closing bracket.
+const hexPattern = "^(urn\\:uuid\\:)?\\{?([a-z0-9]{8})-([a-z0-9]{4})-" +
+ "([1-5][a-z0-9]{3})-([a-z0-9]{4})-([a-z0-9]{12})\\}?$"
+
+var re = regexp.MustCompile(hexPattern)
+
+// A UUID representation compliant with specification in
+// RFC 4122 document.
+type UUID [16]byte
+
+// ParseHex creates a UUID object from given hex string
+// representation. Function accepts UUID string in following
+// formats:
+//
+// uuid.ParseHex("6ba7b814-9dad-11d1-80b4-00c04fd430c8")
+// uuid.ParseHex("{6ba7b814-9dad-11d1-80b4-00c04fd430c8}")
+// uuid.ParseHex("urn:uuid:6ba7b814-9dad-11d1-80b4-00c04fd430c8")
+//
+func ParseHex(s string) (u *UUID, err error) {
+ md := re.FindStringSubmatch(s)
+ if md == nil {
+ err = errors.New("Invalid UUID string")
+ return
+ }
+ hash := md[2] + md[3] + md[4] + md[5] + md[6]
+ b, err := hex.DecodeString(hash)
+ if err != nil {
+ return
+ }
+ u = new(UUID)
+ copy(u[:], b)
+ return
+}
+
+// Parse creates a UUID object from given bytes slice.
+func Parse(b []byte) (u *UUID, err error) {
+ if len(b) != 16 {
+ err = errors.New("Given slice is not valid UUID sequence")
+ return
+ }
+ u = new(UUID)
+ copy(u[:], b)
+ return
+}
+
+// Generate a UUID based on the MD5 hash of a namespace identifier
+// and a name.
+func NewV3(ns *UUID, name []byte) (u *UUID, err error) {
+ if ns == nil {
+ err = errors.New("Invalid namespace UUID")
+ return
+ }
+ u = new(UUID)
+ // Set all bits to MD5 hash generated from namespace and name.
+ u.setBytesFromHash(md5.New(), ns[:], name)
+ u.setVariant(ReservedRFC4122)
+ u.setVersion(3)
+ return
+}
+
+// Generate a random UUID.
+func NewV4() (u *UUID, err error) {
+ u = new(UUID)
+ // Set all bits to randomly (or pseudo-randomly) chosen values.
+ _, err = rand.Read(u[:])
+ if err != nil {
+ return
+ }
+ u.setVariant(ReservedRFC4122)
+ u.setVersion(4)
+ return
+}
+
+// Generate a UUID based on the SHA-1 hash of a namespace identifier
+// and a name.
+func NewV5(ns *UUID, name []byte) (u *UUID, err error) {
+ u = new(UUID)
+ // Set all bits to truncated SHA1 hash generated from namespace
+ // and name.
+ u.setBytesFromHash(sha1.New(), ns[:], name)
+ u.setVariant(ReservedRFC4122)
+ u.setVersion(5)
+ return
+}
+
+// Generate a MD5 hash of a namespace and a name, and copy it to the
+// UUID slice.
+func (u *UUID) setBytesFromHash(hash hash.Hash, ns, name []byte) {
+ hash.Write(ns[:])
+ hash.Write(name)
+ copy(u[:], hash.Sum([]byte{})[:16])
+}
+
+// Set the two most significant bits (bits 6 and 7) of the
+// clock_seq_hi_and_reserved to zero and one, respectively.
+func (u *UUID) setVariant(v byte) {
+ switch v {
+ case ReservedNCS:
+ u[8] = (u[8] | ReservedNCS) & 0xBF
+ case ReservedRFC4122:
+ u[8] = (u[8] | ReservedRFC4122) & 0x7F
+ case ReservedMicrosoft:
+ u[8] = (u[8] | ReservedMicrosoft) & 0x3F
+ }
+}
+
+// Variant returns the UUID Variant, which determines the internal
+// layout of the UUID. This will be one of the constants: RESERVED_NCS,
+// RFC_4122, RESERVED_MICROSOFT, RESERVED_FUTURE.
+func (u *UUID) Variant() byte {
+ if u[8]&ReservedNCS == ReservedNCS {
+ return ReservedNCS
+ } else if u[8]&ReservedRFC4122 == ReservedRFC4122 {
+ return ReservedRFC4122
+ } else if u[8]&ReservedMicrosoft == ReservedMicrosoft {
+ return ReservedMicrosoft
+ }
+ return ReservedFuture
+}
+
+// Set the four most significant bits (bits 12 through 15) of the
+// time_hi_and_version field to the 4-bit version number.
+func (u *UUID) setVersion(v byte) {
+ u[6] = (u[6] & 0xF) | (v << 4)
+}
+
+// Version returns a version number of the algorithm used to
+// generate the UUID sequence.
+func (u *UUID) Version() uint {
+ return uint(u[6] >> 4)
+}
+
+// Returns unparsed version of the generated UUID sequence.
+func (u *UUID) String() string {
+ return fmt.Sprintf("%x-%x-%x-%x-%x", u[0:4], u[4:6], u[6:8], u[8:10], u[10:])
+}
diff --git a/Godeps/_workspace/src/github.com/nu7hatch/gouuid/uuid_test.go b/Godeps/_workspace/src/github.com/nu7hatch/gouuid/uuid_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..70ed346f0844210ba28ea3f4253662a0a25fe76e
--- /dev/null
+++ b/Godeps/_workspace/src/github.com/nu7hatch/gouuid/uuid_test.go
@@ -0,0 +1,135 @@
+// This package provides immutable UUID structs and the functions
+// NewV3, NewV4, NewV5 and Parse() for generating versions 3, 4
+// and 5 UUIDs as specified in RFC 4122.
+//
+// Copyright (C) 2011 by Krzysztof Kowalik <chris@nu7hat.ch>
+package uuid
+
+import (
+ "regexp"
+ "testing"
+)
+
+const format = "^[a-z0-9]{8}-[a-z0-9]{4}-[1-5][a-z0-9]{3}-[a-z0-9]{4}-[a-z0-9]{12}$"
+
+func TestParse(t *testing.T) {
+ _, err := Parse([]byte{1, 2, 3, 4, 5})
+ if err == nil {
+ t.Errorf("Expected error due to invalid UUID sequence")
+ }
+ base, _ := NewV4()
+ u, err := Parse(base[:])
+ if err != nil {
+ t.Errorf("Expected to parse UUID sequence without problems")
+ return
+ }
+ if u.String() != base.String() {
+ t.Errorf("Expected parsed UUID to be the same as base, %s != %s", u.String(), base.String())
+ }
+}
+
+func TestParseString(t *testing.T) {
+ _, err := ParseHex("foo")
+ if err == nil {
+ t.Errorf("Expected error due to invalid UUID string")
+ }
+ base, _ := NewV4()
+ u, err := ParseHex(base.String())
+ if err != nil {
+ t.Errorf("Expected to parse UUID sequence without problems")
+ return
+ }
+ if u.String() != base.String() {
+ t.Errorf("Expected parsed UUID to be the same as base, %s != %s", u.String(), base.String())
+ }
+}
+
+func TestNewV3(t *testing.T) {
+ u, err := NewV3(NamespaceURL, []byte("golang.org"))
+ if err != nil {
+ t.Errorf("Expected to generate UUID without problems, error thrown: %d", err.Error())
+ return
+ }
+ if u.Version() != 3 {
+ t.Errorf("Expected to generate UUIDv3, given %d", u.Version())
+ }
+ if u.Variant() != ReservedRFC4122 {
+ t.Errorf("Expected to generate UUIDv3 RFC4122 variant, given %x", u.Variant())
+ }
+ re := regexp.MustCompile(format)
+ if !re.MatchString(u.String()) {
+ t.Errorf("Expected string representation to be valid, given %s", u.String())
+ }
+ u2, _ := NewV3(NamespaceURL, []byte("golang.org"))
+ if u2.String() != u.String() {
+ t.Errorf("Expected UUIDs generated of the same namespace and name to be the same")
+ }
+ u3, _ := NewV3(NamespaceDNS, []byte("golang.org"))
+ if u3.String() == u.String() {
+ t.Errorf("Expected UUIDs generated of different namespace and the same name to be different")
+ }
+ u4, _ := NewV3(NamespaceURL, []byte("code.google.com"))
+ if u4.String() == u.String() {
+ t.Errorf("Expected UUIDs generated of the same namespace and different names to be different")
+ }
+}
+
+func TestNewV4(t *testing.T) {
+ u, err := NewV4()
+ if err != nil {
+ t.Errorf("Expected to generate UUID without problems, error thrown: %s", err.Error())
+ return
+ }
+ if u.Version() != 4 {
+ t.Errorf("Expected to generate UUIDv4, given %d", u.Version())
+ }
+ if u.Variant() != ReservedRFC4122 {
+ t.Errorf("Expected to generate UUIDv4 RFC4122 variant, given %x", u.Variant())
+ }
+ re := regexp.MustCompile(format)
+ if !re.MatchString(u.String()) {
+ t.Errorf("Expected string representation to be valid, given %s", u.String())
+ }
+}
+
+func TestNewV5(t *testing.T) {
+ u, err := NewV5(NamespaceURL, []byte("golang.org"))
+ if err != nil {
+ t.Errorf("Expected to generate UUID without problems, error thrown: %d", err.Error())
+ return
+ }
+ if u.Version() != 5 {
+ t.Errorf("Expected to generate UUIDv5, given %d", u.Version())
+ }
+ if u.Variant() != ReservedRFC4122 {
+ t.Errorf("Expected to generate UUIDv5 RFC4122 variant, given %x", u.Variant())
+ }
+ re := regexp.MustCompile(format)
+ if !re.MatchString(u.String()) {
+ t.Errorf("Expected string representation to be valid, given %s", u.String())
+ }
+ u2, _ := NewV5(NamespaceURL, []byte("golang.org"))
+ if u2.String() != u.String() {
+ t.Errorf("Expected UUIDs generated of the same namespace and name to be the same")
+ }
+ u3, _ := NewV5(NamespaceDNS, []byte("golang.org"))
+ if u3.String() == u.String() {
+ t.Errorf("Expected UUIDs generated of different namespace and the same name to be different")
+ }
+ u4, _ := NewV5(NamespaceURL, []byte("code.google.com"))
+ if u4.String() == u.String() {
+ t.Errorf("Expected UUIDs generated of the same namespace and different names to be different")
+ }
+}
+
+func BenchmarkParseHex(b *testing.B) {
+ s := "f3593cff-ee92-40df-4086-87825b523f13"
+ for i := 0; i < b.N; i++ {
+ _, err := ParseHex(s)
+ if err != nil {
+ b.Fatal(err)
+ }
+ }
+ b.StopTimer()
+ b.ReportAllocs()
+}
diff --git a/etcd_client.go b/etcd_client.go
index 8bfc3a0243340cc01efbd4507e85e3b7f967e9bd..bb687062a655058d038cc26c21a7d5b302529092 100644
--- a/etcd_client.go
+++ b/etcd_client.go
@@ -7,7 +7,7 @@ import (
"net"
"strings"
- "git.autistici.org/ale/autoradio/third_party/github.com/coreos/go-etcd/etcd"
+ "github.com/coreos/go-etcd/etcd"
)
var (
diff --git a/masterelection/masterelection.go b/masterelection/masterelection.go
index 2ace742cbdf367a7f4ec6b1d2e7c615cfdac97a1..97c8d8851037ed1ae433af9d4386f1b3be45e679 100644
--- a/masterelection/masterelection.go
+++ b/masterelection/masterelection.go
@@ -5,7 +5,7 @@ import (
"time"
"git.autistici.org/ale/autoradio"
- "git.autistici.org/ale/autoradio/third_party/github.com/coreos/go-etcd/etcd"
+ "github.com/coreos/go-etcd/etcd"
)
const (
diff --git a/node/node.go b/node/node.go
index 73a77fc89083ef9ef79fa1958eea3c5545f9ce89..e937b9d53f158d26dcdbb0e78c3f177f90ef7213 100644
--- a/node/node.go
+++ b/node/node.go
@@ -13,7 +13,7 @@ import (
"git.autistici.org/ale/autoradio/instrumentation"
"git.autistici.org/ale/autoradio/masterelection"
"git.autistici.org/ale/autoradio/node/bwmonitor"
- "git.autistici.org/ale/autoradio/third_party/github.com/coreos/go-etcd/etcd"
+ "github.com/coreos/go-etcd/etcd"
)
var (
diff --git a/third_party/github.com/coreos/go-etcd/etcd/requests_test.go b/third_party/github.com/coreos/go-etcd/etcd/requests_test.go
deleted file mode 100644
index a7160c126c692dd1f7126c233ff391183d9e6367..0000000000000000000000000000000000000000
--- a/third_party/github.com/coreos/go-etcd/etcd/requests_test.go
+++ /dev/null
@@ -1,50 +0,0 @@
-package etcd
-
-import (
- "path"
- "testing"
-)
-
-func testKey(t *testing.T, in, exp string) {
- if keyToPath(in) != exp {
- t.Errorf("Expected %s got %s", exp, keyToPath(in))
- }
-}
-
-// TestKeyToPath ensures the key cleaning funciton keyToPath works in a number
-// of cases.
-func TestKeyToPath(t *testing.T) {
- testKey(t, "", "/")
- testKey(t, "/", "/")
- testKey(t, "///", "/")
- testKey(t, "hello/world/", "hello/world")
- testKey(t, "///hello////world/../", "/hello")
-}
-
-func testPath(t *testing.T, c *Client, in, exp string) {
- out := c.getHttpPath(false, in)
-
- if out != exp {
- t.Errorf("Expected %s got %s", exp, out)
- }
-}
-
-// TestHttpPath ensures that the URLs generated make sense for the given keys
-func TestHttpPath(t *testing.T) {
- c := NewClient(nil)
-
- testPath(t, c,
- path.Join(c.keyPrefix, "hello") + "?prevInit=true",
- "http://127.0.0.1:4001/v2/keys/hello?prevInit=true")
-
- testPath(t, c,
- path.Join(c.keyPrefix, "///hello///world") + "?prevInit=true",
- "http://127.0.0.1:4001/v2/keys/hello/world?prevInit=true")
-
- c = NewClient([]string{"https://discovery.etcd.io"})
- c.SetKeyPrefix("")
-
- testPath(t, c,
- path.Join(c.keyPrefix, "hello") + "?prevInit=true",
- "https://discovery.etcd.io/hello?prevInit=true")
-}