Add identicons to device prompts

Hash blocks after receipt, try multiple peers (fixes #1166)

.gitignore

@@ -3,3 +3,15 @@ syncthing.exe
 *.tar.gz
 *.zip
 *.asc
+*.sublime*
+.idea/
+.jshintrc
+coverage.out
+files/pidx
+bin
+perfstats*.csv
+coverage.xml
+!gui/scripts/syncthing
+.DS_Store
+syncthing.md5
+syncthing.exe.md5

.mailmap

@@ -0,0 +1 @@
+NICKS

AUTHORS

@@ -0,0 +1,35 @@
+# This is the official list of Syncthing authors for copyright purposes.
+
+Aaron Bieber <qbit@deftly.net>
+Alexander Graf <register-github@alex-graf.de>
+Andrew Dunham <andrew@du.nham.ca>
+Audrius Butkevicius <audrius.butkevicius@gmail.com>
+Arthur Axel fREW Schmidt <frew@afoolishmanifesto.com> <frioux@gmail.com>
+Ben Schulz <ueomkail@gmail.com> <uok@users.noreply.github.com>
+Ben Sidhom <bsidhom@gmail.com>
+Brandon Philips <brandon@ifup.org>
+Caleb Callaway <enlightened.despot@gmail.com>
+Cathryne Linenweaver <cathryne.linenweaver@gmail.com> <Cathryne@users.noreply.github.com>
+Chris Joel <chris@scriptolo.gy>
+Daniel Martí <mvdan@mvdan.cc>
+Dennis Wilson <dw@risu.io>
+Dominik Heidler <dominik@heidler.eu>
+Emil Hessman <emil@hessman.se>
+Felix Ableitner <me@nutomic.com>
+Felix Unterpaintner <bigbear2nd@gmail.com>
+Gilli Sigurdsson <gilli@vx.is>
+Jakob Borg <jakob@nym.se>
+James Patterson <jamespatterson@operamail.com> <jpjp@users.noreply.github.com>
+Jens Diemer <github.com@jensdiemer.de> <git@jensdiemer.de>
+Jochen Voss <voss@seehuhn.de>
+Lode Hoste <zillode@zillode.be>
+Marcin Dziadus <dziadus.marcin@gmail.com>
+Michael Tilli <pyfisch@gmail.com>
+Philippe Schommers <philippe@schommers.be>
+Phill Luby <phill.luby@newredo.com>
+Piotr Bejda <piotrb10@gmail.com>
+Ryan Sullivan <kayoticsully@gmail.com>
+Tomas Cerveny <kozec@kozec.com>
+Tully Robinson <tully@tojr.org>
+Veeti Paananen <veeti.paananen@rojekti.fi>
+Vil Brekin <vilbrekin@gmail.com>

CONDUCT.md

@@ -0,0 +1,92 @@
+## Conduct
+
+* We are committed to providing a friendly, safe and welcoming
+  environment for all, regardless of gender, sexual orientation,
+  disability, ethnicity, religion, or similar personal characteristic.
+
+* On IRC, please avoid using overtly sexual nicknames or other nicknames
+  that might detract from a friendly, safe and welcoming environment for
+  all.
+
+* Please be kind and courteous. There's no need to be mean or rude.
+
+* Respect that people have differences of opinion and that every design
+  or implementation choice carries a trade-off and numerous costs. There
+  is seldom a right answer.
+
+* Please keep unstructured critique to a minimum. If you have solid
+  ideas you want to experiment with, make a fork and see how it works.
+
+* We will exclude you from interaction if you insult, demean or harass
+  anyone. That is not welcome behaviour. We interpret the term
+  "harassment" as including the definition in the <a
+  href="http://citizencodeofconduct.org/">Citizen Code of Conduct</a>;
+  if you have any lack of clarity about what might be included in that
+  concept, please read their definition. In particular, we don't
+  tolerate behavior that excludes people in socially marginalized
+  groups.
+
+* Private harassment is also unacceptable. No matter who you are, if you
+  feel you have been or are being harassed or made uncomfortable by a
+  community member, please contact one of the channel ops or any of the
+  Syncthing core team immediately. Whether you're a regular  contributor
+  or a newcomer, we care about making this community a safe place for
+  you and we've got your back.
+
+* Likewise any spamming, trolling, flaming, baiting or other
+  attention-stealing behaviour is not welcome.
+
+## Moderation
+
+These are the policies for upholding our community's standards of
+conduct in our communication channels, most notably in Syncthing-related
+IRC channels and on the web forum.
+
+1. Remarks that violate the Syncthing standards of conduct, including
+   hateful, hurtful, oppressive, or exclusionary remarks, are not
+   allowed. (Cursing is allowed, but never targeting another user, and
+   never in a hateful manner.)
+
+2. Remarks that moderators find inappropriate, whether listed in the
+   code of conduct or not, are also not allowed.
+
+3. Moderators will first respond to such remarks with a warning.
+
+4. If the warning is unheeded, the user will be "kicked," i.e., kicked
+   out of the communication channel to cool off.
+
+5. If the user comes back and continues to make trouble, they will be
+   banned, i.e., indefinitely excluded.
+
+6. Moderators may choose at their discretion to un-ban the user if it
+   was a first offense and they offer the offended party a genuine
+   apology.
+
+7. If a moderator bans someone and you think it was unjustified, please
+   take it up with that moderator, or with a different moderator, **in
+   private**. Complaints about bans in-channel are not allowed.
+
+8. Moderators are held to a higher standard than other community
+   members. If a moderator creates an inappropriate situation, they
+   should expect less leeway than others.
+
+In the Syncthing community we strive to go the extra step to look out
+for each other. Don't just aim to be technically unimpeachable, try to
+be your best self. In particular, avoid flirting with offensive or
+sensitive issues, particularly if they're off-topic; this all too
+often leads to unnecessary fights, hurt feelings, and damaged trust;
+worse, it can drive people away from the community entirely.
+
+And if someone takes issue with something you said or did, resist the
+urge to be defensive. Just stop doing what it was they complained about
+and apologize. Even if you feel you were misinterpreted or unfairly
+accused, chances are good there was something you could've communicated
+better — remember that it's your responsibility to make your fellow
+community members comfortable. Everyone wants to get along and we are
+all here first and foremost because we want to talk about cool
+technology. You will find that people will be eager to assume good
+intent and forgive as long as you earn their trust.
+
+*Adapted from the [Rust Code of Conduct](https://github.com/rust-lang/rust/wiki/Note-development-policy#conduct)*
+
+*Adapted from the [Node.js Policy on Trolling](http://blog.izs.me/post/30036893703/policy-on-trolling)*

CONTRIBUTING.md

@@ -1,22 +1,140 @@
-Please do contribute!
+## Reporting Bugs
+
+Please file bugs in the [Github Issue
+Tracker](https://github.com/syncthing/syncthing/issues). Include at
+least the following:
+
+ - What happened
+
+ - What did you expect to happen instead of what *did* happen, if it's
+   not crazy obvious
+
+ - What operating system, operating system version and version of
+   Syncthing you are running
+
+ - The same for other connected devices, where relevant
+
+ - Screenshot if the issue concerns something visible in the GUI
+
+ - Console log entries, where possible and relevant
+
+If you're not sure whether something is relevant, erring on the side of
+too much information will never get you yelled at. :)
+
+## Contributing Translations
+
+All translations are done via
+[Transifex](https://www.transifex.com/projects/p/syncthing/). If you
+wish to contribute to a translation, just head over there and sign up.
+Before every release, the language resources are updated from the
+latest info on Transifex.
+
+## Contributing Code
+
+Every contribution is welcome. If you want to contribute but are unsure
+where to start, any open issues are fair game! Be prepared for a
+[certain amount of review](https://discourse.syncthing.net/t/733); it's
+all in the name of quality. :) Following the points below will make this
+a smoother process.
+
+Individuals making significant and valuable contributions are given
+commit-access to the project. If you make a significant contribution and
+are not considered for commit-access, please contact any of the
+Syncthing core team members.
+
+All nontrivial contributions should go through the pull request
+mechanism for internal review. Determining what is "nontrivial" is left
+at the discretion of the contributor.
+
+### Authorship
+
+All code authors are listed in the AUTHORS file. Commits must be made
+with the same name and email as listed in the AUTHORS file. To
+accomplish this, ensure that your git configuration is set correctly
+prior to making your first commit;
+
+    $ git config --global user.name "Jane Doe"
+    $ git config --global user.email janedoe@example.com
+
+You must be reachable on the given email address. If you do not wish to
+use your real name for whatever reason, using a nickname or pseudonym is
+perfectly acceptable.
+
+### Core Team
+
+The Syncthing core team currently consists of the following members;
+
+ - Jakob Borg (@calmh)
+ - Audrius Butkevicius (@AudriusButkevicius)
+
+## Coding Style
+
+- Follow the conventions laid out in [Effective Go](https://golang.org/doc/effective_go.html)
+  as much as makes sense.
+
+- All text files use Unix line endings.
+
+- Each commit should be `go fmt` clean.
+
+- The commit message subject should be a single short sentence
+  describing the change, starting with a capital letter.
+
+- Commits that resolve an existing issue must include the issue number
+  as `(fixes #123)` at the end of the commit message subject.
+
+- Imports are grouped per `goimports` standard; that is, standard
+  library first, then third party libraries after a blank line.
+
+- A contribution solving a single issue or introducing a single new
+  feature should probably be a single commit based on the current
+  `master` branch. You may be asked to "rebase" or "squash" your pull
+  request to make sure this is the case, especially if there have been
+  amendments during review.
+
+## Licensing
+
+All contributions are made under the same GPL license as the rest of the
+project, except documentation, user interface text and translation
+strings which are licensed under the Creative Commons Attribution 4.0
+International License. You retain the copyright to code you have
+written.
+
+When accepting your first contribution, the maintainer of the project
+will ensure that you are added to the AUTHORS file. You are welcome to
+add yourself as a separate commit in your first pull request.
 
 ## Building
 
-[See the wiki](https://github.com/calmh/syncthing/wiki/Building)
+[See the documentation](http://discourse.syncthing.net/t/44) on how to
+get started with a build environment.
+
+## Branches
+
+ - `master` is the main branch containing good code that will end up in
+   the next release. You should base your work on it. It won't ever be
+   rebased or force-pushed to.
+
+ - `vx.y` branches exist to make patch releases on otherwise obsolete
+   minor releases. Should only contain fixes cherry picked from master.
+   Don't base any work on them.
+
+ - Other branches are probably topic branches and may be subject to
+   rebasing. Don't base any work on them unless you specifically know
+   otherwise.
+
+## Tags
+
+All releases are tagged semver style as `vx.y.z`. Release tags are
+signed by GPG key BCE524C7.
 
 ## Tests
 
 Yes please!
 
-## Style
-
-`go fmt`
-
 ## Documentation
 
-[Hack it here](https://github.com/calmh/syncthing/wiki)
+[Over here!](http://discourse.syncthing.net/category/documentation)
 
 ## License
 
-MIT
-
+GPLv3

Godeps/Godeps.json

@@ -1,37 +1,69 @@
 {
-	"ImportPath": "github.com/calmh/syncthing",
-	"GoVersion": "devel +3ca54dd30864 Sat Mar 22 11:05:40 2014 -0700",
+	"ImportPath": "github.com/syncthing/syncthing",
+	"GoVersion": "go1.4",
 	"Packages": [
-		"./cmd/syncthing"
+		"./cmd/..."
 	],
 	"Deps": [
 		{
-			"ImportPath": "code.google.com/p/go.net/ipv6",
-			"Comment": "null-117",
-			"Rev": "c17ad62118ea511e1051721b429779fa40bddc74"
+			"ImportPath": "github.com/AudriusButkevicius/lfu-go",
+			"Rev": "164bcecceb92fd6037f4d18a8d97b495ec6ef669"
 		},
 		{
-			"ImportPath": "code.google.com/p/go.text/transform",
-			"Comment": "null-81",
-			"Rev": "9cbe983aed9b0dfc73954433fead5e00866342ac"
+			"ImportPath": "github.com/bkaradzic/go-lz4",
+			"Rev": "93a831dcee242be64a9cc9803dda84af25932de7"
 		},
 		{
-			"ImportPath": "code.google.com/p/go.text/unicode/norm",
-			"Comment": "null-81",
-			"Rev": "9cbe983aed9b0dfc73954433fead5e00866342ac"
+			"ImportPath": "github.com/calmh/logger",
+			"Rev": "f50d32b313bec2933a3e1049f7416a29f3413d29"
 		},
 		{
-			"ImportPath": "github.com/calmh/ini",
-			"Rev": "386c4240a9684d91d9ec4d93651909b49c7269e1"
+			"ImportPath": "github.com/calmh/osext",
+			"Rev": "9bf61584e5f1f172e8766ddc9022d9c401faaa5e"
 		},
 		{
-			"ImportPath": "github.com/codegangsta/inject",
-			"Rev": "9aea7a2fa5b79ef7fc00f63a575e72df33b4e886"
+			"ImportPath": "github.com/calmh/xdr",
+			"Rev": "45c46b7db7ff83b8b9ee09bbd95f36ab50043ece"
 		},
 		{
-			"ImportPath": "github.com/codegangsta/martini",
-			"Comment": "v0.1-142-g8659df7",
-			"Rev": "8659df7a51aebe6c6120268cd5a8b4c34fa8441a"
+			"ImportPath": "github.com/juju/ratelimit",
+			"Rev": "f9f36d11773655c0485207f0ad30dc2655f69d56"
+		},
+		{
+			"ImportPath": "github.com/syndtr/goleveldb/leveldb",
+			"Rev": "63c9e642efad852f49e20a6f90194cae112fd2ac"
+		},
+		{
+			"ImportPath": "github.com/syndtr/gosnappy/snappy",
+			"Rev": "ce8acff4829e0c2458a67ead32390ac0a381c862"
+		},
+		{
+			"ImportPath": "github.com/vitrun/qart/coding",
+			"Rev": "ccb109cf25f0cd24474da73b9fee4e7a3e8a8ce0"
+		},
+		{
+			"ImportPath": "github.com/vitrun/qart/gf256",
+			"Rev": "ccb109cf25f0cd24474da73b9fee4e7a3e8a8ce0"
+		},
+		{
+			"ImportPath": "github.com/vitrun/qart/qr",
+			"Rev": "ccb109cf25f0cd24474da73b9fee4e7a3e8a8ce0"
+		},
+		{
+			"ImportPath": "golang.org/x/crypto/bcrypt",
+			"Rev": "731db29863ea7213d9556d0170afb38987f401d4"
+		},
+		{
+			"ImportPath": "golang.org/x/crypto/blowfish",
+			"Rev": "731db29863ea7213d9556d0170afb38987f401d4"
+		},
+		{
+			"ImportPath": "golang.org/x/text/transform",
+			"Rev": "985ee5acfaf1ff6712c7c99438752f8e09416ccb"
+		},
+		{
+			"ImportPath": "golang.org/x/text/unicode/norm",
+			"Rev": "985ee5acfaf1ff6712c7c99438752f8e09416ccb"
 		}
 	]
 }

Godeps/_workspace/src/code.google.com/p/go.net/ipv6/control.go

@@ -1,83 +0,0 @@
-// 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.
-
-package ipv6
-
-import (
-	"errors"
-	"fmt"
-	"net"
-	"sync"
-)
-
-var (
-	errMissingAddress  = errors.New("missing address")
-	errInvalidConnType = errors.New("invalid conn type")
-	errNoSuchInterface = errors.New("no such interface")
-)
-
-// References:
-//
-// RFC 2292  Advanced Sockets API for IPv6
-//	http://tools.ietf.org/html/rfc2292
-// RFC 2460  Internet Protocol, Version 6 (IPv6) Specification
-//	http://tools.ietf.org/html/rfc2460
-// RFC 3493  Basic Socket Interface Extensions for IPv6
-//	http://tools.ietf.org/html/rfc3493.html
-// RFC 3542  Advanced Sockets Application Program Interface (API) for IPv6
-//	http://tools.ietf.org/html/rfc3542
-//
-// Note that RFC 3542 obsoltes RFC 2292 but OS X Snow Leopard and the
-// former still support RFC 2292 only.  Please be aware that almost
-// all protocol implementations prohibit using a combination of RFC
-// 2292 and RFC 3542 for some practical reasons.
-
-type rawOpt struct {
-	sync.Mutex
-	cflags ControlFlags
-}
-
-func (c *rawOpt) set(f ControlFlags)        { c.cflags |= f }
-func (c *rawOpt) clear(f ControlFlags)      { c.cflags &^= f }
-func (c *rawOpt) isset(f ControlFlags) bool { return c.cflags&f != 0 }
-
-// A ControlFlags reprensents per packet basis IP-level socket option
-// control flags.
-type ControlFlags uint
-
-const (
-	FlagTrafficClass ControlFlags = 1 << iota // pass the traffic class on the received packet
-	FlagHopLimit                              // pass the hop limit on the received packet
-	FlagSrc                                   // pass the source address on the received packet
-	FlagDst                                   // pass the destination address on the received packet
-	FlagInterface                             // pass the interface index on the received packet
-	FlagPathMTU                               // pass the path MTU on the received packet path
-)
-
-// A ControlMessage represents per packet basis IP-level socket
-// options.
-type ControlMessage struct {
-	// Receiving socket options: SetControlMessage allows to
-	// receive the options from the protocol stack using ReadFrom
-	// method of PacketConn.
-	//
-	// Specifying socket options: ControlMessage for WriteTo
-	// method of PacketConn allows to send the options to the
-	// protocol stack.
-	//
-	TrafficClass int    // traffic class, must be 1 <= value <= 255 when specifying
-	HopLimit     int    // hop limit, must be 1 <= value <= 255 when specifying
-	Src          net.IP // source address, specifying only
-	Dst          net.IP // destination address, receiving only
-	IfIndex      int    // interface index, must be 1 <= value when specifying
-	NextHop      net.IP // next hop address, specifying only
-	MTU          int    // path MTU, receiving only
-}
-
-func (cm *ControlMessage) String() string {
-	if cm == nil {
-		return "<nil>"
-	}
-	return fmt.Sprintf("tclass: %#x, hoplim: %v, src: %v, dst: %v, ifindex: %v, nexthop: %v, mtu: %v", cm.TrafficClass, cm.HopLimit, cm.Src, cm.Dst, cm.IfIndex, cm.NextHop, cm.MTU)
-}

Godeps/_workspace/src/code.google.com/p/go.net/ipv6/control_rfc2292_unix.go

@@ -1,151 +0,0 @@
-// 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.
-
-// +build darwin
-
-package ipv6
-
-import (
-	"net"
-	"os"
-	"syscall"
-	"unsafe"
-)
-
-const pktinfo = FlagDst | FlagInterface
-
-func setControlMessage(fd int, opt *rawOpt, cf ControlFlags, on bool) error {
-	opt.Lock()
-	defer opt.Unlock()
-	if cf&FlagHopLimit != 0 {
-		if err := setIPv6ReceiveHopLimit(fd, on); err != nil {
-			return err
-		}
-		if on {
-			opt.set(FlagHopLimit)
-		} else {
-			opt.clear(FlagHopLimit)
-		}
-	}
-	if cf&pktinfo != 0 {
-		if err := setIPv6ReceivePacketInfo(fd, on); err != nil {
-			return err
-		}
-		if on {
-			opt.set(cf & pktinfo)
-		} else {
-			opt.clear(cf & pktinfo)
-		}
-	}
-	return nil
-}
-
-func newControlMessage(opt *rawOpt) (oob []byte) {
-	opt.Lock()
-	defer opt.Unlock()
-	l, off := 0, 0
-	if opt.isset(FlagHopLimit) {
-		l += syscall.CmsgSpace(4)
-	}
-	if opt.isset(pktinfo) {
-		l += syscall.CmsgSpace(sysSizeofPacketInfo)
-	}
-	if l > 0 {
-		oob = make([]byte, l)
-		if opt.isset(FlagHopLimit) {
-			m := (*syscall.Cmsghdr)(unsafe.Pointer(&oob[off]))
-			m.Level = ianaProtocolIPv6
-			m.Type = sysSockopt2292HopLimit
-			m.SetLen(syscall.CmsgLen(4))
-			off += syscall.CmsgSpace(4)
-		}
-		if opt.isset(pktinfo) {
-			m := (*syscall.Cmsghdr)(unsafe.Pointer(&oob[off]))
-			m.Level = ianaProtocolIPv6
-			m.Type = sysSockopt2292PacketInfo
-			m.SetLen(syscall.CmsgLen(sysSizeofPacketInfo))
-			off += syscall.CmsgSpace(sysSizeofPacketInfo)
-		}
-	}
-	return
-}
-
-func parseControlMessage(b []byte) (*ControlMessage, error) {
-	if len(b) == 0 {
-		return nil, nil
-	}
-	cmsgs, err := syscall.ParseSocketControlMessage(b)
-	if err != nil {
-		return nil, os.NewSyscallError("parse socket control message", err)
-	}
-	cm := &ControlMessage{}
-	for _, m := range cmsgs {
-		if m.Header.Level != ianaProtocolIPv6 {
-			continue
-		}
-		switch m.Header.Type {
-		case sysSockopt2292HopLimit:
-			cm.HopLimit = int(*(*byte)(unsafe.Pointer(&m.Data[:1][0])))
-		case sysSockopt2292PacketInfo:
-			pi := (*sysPacketInfo)(unsafe.Pointer(&m.Data[0]))
-			cm.IfIndex = int(pi.IfIndex)
-			cm.Dst = pi.IP[:]
-		}
-	}
-	return cm, nil
-}
-
-func marshalControlMessage(cm *ControlMessage) (oob []byte) {
-	if cm == nil {
-		return
-	}
-	l, off := 0, 0
-	if cm.HopLimit > 0 {
-		l += syscall.CmsgSpace(4)
-	}
-	pion := false
-	if cm.Src.To4() == nil && cm.Src.To16() != nil || cm.IfIndex != 0 {
-		pion = true
-		l += syscall.CmsgSpace(sysSizeofPacketInfo)
-	}
-	if len(cm.NextHop) == net.IPv6len {
-		l += syscall.CmsgSpace(syscall.SizeofSockaddrInet6)
-	}
-	if l > 0 {
-		oob = make([]byte, l)
-		if cm.HopLimit > 0 {
-			m := (*syscall.Cmsghdr)(unsafe.Pointer(&oob[off]))
-			m.Level = ianaProtocolIPv6
-			m.Type = sysSockopt2292HopLimit
-			m.SetLen(syscall.CmsgLen(4))
-			data := oob[off+syscall.CmsgLen(0):]
-			*(*byte)(unsafe.Pointer(&data[:1][0])) = byte(cm.HopLimit)
-			off += syscall.CmsgSpace(4)
-		}
-		if pion {
-			m := (*syscall.Cmsghdr)(unsafe.Pointer(&oob[off]))
-			m.Level = ianaProtocolIPv6
-			m.Type = sysSockopt2292PacketInfo
-			m.SetLen(syscall.CmsgLen(sysSizeofPacketInfo))
-			pi := (*sysPacketInfo)(unsafe.Pointer(&oob[off+syscall.CmsgLen(0)]))
-			if ip := cm.Src.To16(); ip != nil && ip.To4() == nil {
-				copy(pi.IP[:], ip)
-			}
-			if cm.IfIndex != 0 {
-				pi.IfIndex = uint32(cm.IfIndex)
-			}
-			off += syscall.CmsgSpace(sysSizeofPacketInfo)
-		}
-		if len(cm.NextHop) == net.IPv6len {
-			m := (*syscall.Cmsghdr)(unsafe.Pointer(&oob[off]))
-			m.Level = ianaProtocolIPv6
-			m.Type = sysSockopt2292NextHop
-			m.SetLen(syscall.CmsgLen(syscall.SizeofSockaddrInet6))
-			sa := (*syscall.RawSockaddrInet6)(unsafe.Pointer(&oob[off+syscall.CmsgLen(0)]))
-			setSockaddr(sa, cm.NextHop, cm.IfIndex)
-			off += syscall.CmsgSpace(syscall.SizeofSockaddrInet6)
-		}
-	}
-	return
-}

Godeps/_workspace/src/code.google.com/p/go.net/ipv6/control_rfc3542_stub.go

@@ -1,27 +0,0 @@
-// 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.
-
-// +build dragonfly plan9 solaris
-
-package ipv6
-
-func setControlMessage(fd int, opt *rawOpt, cf ControlFlags, on bool) error {
-	// TODO(mikio): Implement this
-	return errOpNoSupport
-}
-
-func newControlMessage(opt *rawOpt) (oob []byte) {
-	// TODO(mikio): Implement this
-	return nil
-}
-
-func parseControlMessage(b []byte) (*ControlMessage, error) {
-	// TODO(mikio): Implement this
-	return nil, errOpNoSupport
-}
-
-func marshalControlMessage(cm *ControlMessage) (oob []byte) {
-	// TODO(mikio): Implement this
-	return nil
-}

Godeps/_workspace/src/code.google.com/p/go.net/ipv6/control_rfc3542_unix.go

@@ -1,210 +0,0 @@
-// 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.
-
-// +build freebsd linux netbsd openbsd
-
-package ipv6
-
-import (
-	"net"
-	"os"
-	"syscall"
-	"unsafe"
-)
-
-const pktinfo = FlagDst | FlagInterface
-
-func setControlMessage(fd int, opt *rawOpt, cf ControlFlags, on bool) error {
-	opt.Lock()
-	defer opt.Unlock()
-	if cf&FlagTrafficClass != 0 {
-		if err := setIPv6ReceiveTrafficClass(fd, on); err != nil {
-			return err
-		}
-		if on {
-			opt.set(FlagTrafficClass)
-		} else {
-			opt.clear(FlagTrafficClass)
-		}
-	}
-	if cf&FlagHopLimit != 0 {
-		if err := setIPv6ReceiveHopLimit(fd, on); err != nil {
-			return err
-		}
-		if on {
-			opt.set(FlagHopLimit)
-		} else {
-			opt.clear(FlagHopLimit)
-		}
-	}
-	if cf&pktinfo != 0 {
-		if err := setIPv6ReceivePacketInfo(fd, on); err != nil {
-			return err
-		}
-		if on {
-			opt.set(cf & pktinfo)
-		} else {
-			opt.clear(cf & pktinfo)
-		}
-	}
-	if cf&FlagPathMTU != 0 {
-		if err := setIPv6ReceivePathMTU(fd, on); err != nil {
-			return err
-		}
-		if on {
-			opt.set(FlagPathMTU)
-		} else {
-			opt.clear(FlagPathMTU)
-		}
-	}
-	return nil
-}
-
-func newControlMessage(opt *rawOpt) (oob []byte) {
-	opt.Lock()
-	defer opt.Unlock()
-	l, off := 0, 0
-	if opt.isset(FlagTrafficClass) {
-		l += syscall.CmsgSpace(4)
-	}
-	if opt.isset(FlagHopLimit) {
-		l += syscall.CmsgSpace(4)
-	}
-	if opt.isset(pktinfo) {
-		l += syscall.CmsgSpace(sysSizeofPacketInfo)
-	}
-	if opt.isset(FlagPathMTU) {
-		l += syscall.CmsgSpace(sysSizeofMTUInfo)
-	}
-	if l > 0 {
-		oob = make([]byte, l)
-		if opt.isset(FlagTrafficClass) {
-			m := (*syscall.Cmsghdr)(unsafe.Pointer(&oob[off]))
-			m.Level = ianaProtocolIPv6
-			m.Type = sysSockoptReceiveTrafficClass
-			m.SetLen(syscall.CmsgLen(4))
-			off += syscall.CmsgSpace(4)
-		}
-		if opt.isset(FlagHopLimit) {
-			m := (*syscall.Cmsghdr)(unsafe.Pointer(&oob[off]))
-			m.Level = ianaProtocolIPv6
-			m.Type = sysSockoptReceiveHopLimit
-			m.SetLen(syscall.CmsgLen(4))
-			off += syscall.CmsgSpace(4)
-		}
-		if opt.isset(pktinfo) {
-			m := (*syscall.Cmsghdr)(unsafe.Pointer(&oob[off]))
-			m.Level = ianaProtocolIPv6
-			m.Type = sysSockoptReceivePacketInfo
-			m.SetLen(syscall.CmsgLen(sysSizeofPacketInfo))
-			off += syscall.CmsgSpace(sysSizeofPacketInfo)
-		}
-		if opt.isset(FlagPathMTU) {
-			m := (*syscall.Cmsghdr)(unsafe.Pointer(&oob[off]))
-			m.Level = ianaProtocolIPv6
-			m.Type = sysSockoptReceivePathMTU
-			m.SetLen(syscall.CmsgLen(sysSizeofMTUInfo))
-			off += syscall.CmsgSpace(sysSizeofMTUInfo)
-		}
-	}
-	return
-}
-
-func parseControlMessage(b []byte) (*ControlMessage, error) {
-	if len(b) == 0 {
-		return nil, nil
-	}
-	cmsgs, err := syscall.ParseSocketControlMessage(b)
-	if err != nil {
-		return nil, os.NewSyscallError("parse socket control message", err)
-	}
-	cm := &ControlMessage{}
-	for _, m := range cmsgs {
-		if m.Header.Level != ianaProtocolIPv6 {
-			continue
-		}
-		switch m.Header.Type {
-		case sysSockoptTrafficClass:
-			cm.TrafficClass = int(*(*byte)(unsafe.Pointer(&m.Data[:1][0])))
-		case sysSockoptHopLimit:
-			cm.HopLimit = int(*(*byte)(unsafe.Pointer(&m.Data[:1][0])))
-		case sysSockoptPacketInfo:
-			pi := (*sysPacketInfo)(unsafe.Pointer(&m.Data[0]))
-			cm.Dst = pi.IP[:]
-			cm.IfIndex = int(pi.IfIndex)
-		case sysSockoptPathMTU:
-			mi := (*sysMTUInfo)(unsafe.Pointer(&m.Data[0]))
-			cm.Dst = mi.Addr.Addr[:]
-			cm.IfIndex = int(mi.Addr.Scope_id)
-			cm.MTU = int(mi.MTU)
-		}
-	}
-	return cm, nil
-}
-
-func marshalControlMessage(cm *ControlMessage) (oob []byte) {
-	if cm == nil {
-		return
-	}
-	l, off := 0, 0
-	if cm.TrafficClass > 0 {
-		l += syscall.CmsgSpace(4)
-	}
-	if cm.HopLimit > 0 {
-		l += syscall.CmsgSpace(4)
-	}
-	pion := false
-	if cm.Src.To4() == nil && cm.Src.To16() != nil || cm.IfIndex != 0 {
-		pion = true
-		l += syscall.CmsgSpace(sysSizeofPacketInfo)
-	}
-	if len(cm.NextHop) == net.IPv6len {
-		l += syscall.CmsgSpace(syscall.SizeofSockaddrInet6)
-	}
-	if l > 0 {
-		oob = make([]byte, l)
-		if cm.TrafficClass > 0 {
-			m := (*syscall.Cmsghdr)(unsafe.Pointer(&oob[off]))
-			m.Level = ianaProtocolIPv6
-			m.Type = sysSockoptTrafficClass
-			m.SetLen(syscall.CmsgLen(4))
-			data := oob[off+syscall.CmsgLen(0):]
-			*(*byte)(unsafe.Pointer(&data[:1][0])) = byte(cm.TrafficClass)
-			off += syscall.CmsgSpace(4)
-		}
-		if cm.HopLimit > 0 {
-			m := (*syscall.Cmsghdr)(unsafe.Pointer(&oob[off]))
-			m.Level = ianaProtocolIPv6
-			m.Type = sysSockoptHopLimit
-			m.SetLen(syscall.CmsgLen(4))
-			data := oob[off+syscall.CmsgLen(0):]
-			*(*byte)(unsafe.Pointer(&data[:1][0])) = byte(cm.HopLimit)
-			off += syscall.CmsgSpace(4)
-		}
-		if pion {
-			m := (*syscall.Cmsghdr)(unsafe.Pointer(&oob[off]))
-			m.Level = ianaProtocolIPv6
-			m.Type = sysSockoptPacketInfo
-			m.SetLen(syscall.CmsgLen(sysSizeofPacketInfo))
-			pi := (*sysPacketInfo)(unsafe.Pointer(&oob[off+syscall.CmsgLen(0)]))
-			if ip := cm.Src.To16(); ip != nil && ip.To4() == nil {
-				copy(pi.IP[:], ip)
-			}
-			if cm.IfIndex != 0 {
-				pi.IfIndex = uint32(cm.IfIndex)
-			}
-			off += syscall.CmsgSpace(sysSizeofPacketInfo)
-		}
-		if len(cm.NextHop) == net.IPv6len {
-			m := (*syscall.Cmsghdr)(unsafe.Pointer(&oob[off]))
-			m.Level = ianaProtocolIPv6
-			m.Type = sysSockoptNextHop
-			m.SetLen(syscall.CmsgLen(syscall.SizeofSockaddrInet6))
-			sa := (*syscall.RawSockaddrInet6)(unsafe.Pointer(&oob[off+syscall.CmsgLen(0)]))
-			setSockaddr(sa, cm.NextHop, cm.IfIndex)
-			off += syscall.CmsgSpace(syscall.SizeofSockaddrInet6)
-		}
-	}
-	return
-}

Godeps/_workspace/src/code.google.com/p/go.net/ipv6/control_rfc3542_windows.go

@@ -1,27 +0,0 @@
-// 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.
-
-package ipv6
-
-import "syscall"
-
-func setControlMessage(fd syscall.Handle, opt *rawOpt, cf ControlFlags, on bool) error {
-	// TODO(mikio): Implement this
-	return syscall.EWINDOWS
-}
-
-func newControlMessage(opt *rawOpt) (oob []byte) {
-	// TODO(mikio): Implement this
-	return nil
-}
-
-func parseControlMessage(b []byte) (*ControlMessage, error) {
-	// TODO(mikio): Implement this
-	return nil, syscall.EWINDOWS
-}
-
-func marshalControlMessage(cm *ControlMessage) (oob []byte) {
-	// TODO(mikio): Implement this
-	return nil
-}

Godeps/_workspace/src/code.google.com/p/go.net/ipv6/dgramopt_posix.go

@@ -1,178 +0,0 @@
-// 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.
-
-// +build darwin freebsd linux netbsd openbsd windows
-
-package ipv6
-
-import (
-	"net"
-	"syscall"
-)
-
-// MulticastHopLimit returns the hop limit field value for outgoing
-// multicast packets.
-func (c *dgramOpt) MulticastHopLimit() (int, error) {
-	if !c.ok() {
-		return 0, syscall.EINVAL
-	}
-	fd, err := c.sysfd()
-	if err != nil {
-		return 0, err
-	}
-	return ipv6MulticastHopLimit(fd)
-}
-
-// SetMulticastHopLimit sets the hop limit field value for future
-// outgoing multicast packets.
-func (c *dgramOpt) SetMulticastHopLimit(hoplim int) error {
-	if !c.ok() {
-		return syscall.EINVAL
-	}
-	fd, err := c.sysfd()
-	if err != nil {
-		return err
-	}
-	return setIPv6MulticastHopLimit(fd, hoplim)
-}
-
-// MulticastInterface returns the default interface for multicast
-// packet transmissions.
-func (c *dgramOpt) MulticastInterface() (*net.Interface, error) {
-	if !c.ok() {
-		return nil, syscall.EINVAL
-	}
-	fd, err := c.sysfd()
-	if err != nil {
-		return nil, err
-	}
-	return ipv6MulticastInterface(fd)
-}
-
-// SetMulticastInterface sets the default interface for future
-// multicast packet transmissions.
-func (c *dgramOpt) SetMulticastInterface(ifi *net.Interface) error {
-	if !c.ok() {
-		return syscall.EINVAL
-	}
-	fd, err := c.sysfd()
-	if err != nil {
-		return err
-	}
-	return setIPv6MulticastInterface(fd, ifi)
-}
-
-// MulticastLoopback reports whether transmitted multicast packets
-// should be copied and send back to the originator.
-func (c *dgramOpt) MulticastLoopback() (bool, error) {
-	if !c.ok() {
-		return false, syscall.EINVAL
-	}
-	fd, err := c.sysfd()
-	if err != nil {
-		return false, err
-	}
-	return ipv6MulticastLoopback(fd)
-}
-
-// SetMulticastLoopback sets whether transmitted multicast packets
-// should be copied and send back to the originator.
-func (c *dgramOpt) SetMulticastLoopback(on bool) error {
-	if !c.ok() {
-		return syscall.EINVAL
-	}
-	fd, err := c.sysfd()
-	if err != nil {
-		return err
-	}
-	return setIPv6MulticastLoopback(fd, on)
-}
-
-// JoinGroup joins the group address group on the interface ifi.
-// It uses the system assigned multicast interface when ifi is nil,
-// although this is not recommended because the assignment depends on
-// platforms and sometimes it might require routing configuration.
-func (c *dgramOpt) JoinGroup(ifi *net.Interface, group net.Addr) error {
-	if !c.ok() {
-		return syscall.EINVAL
-	}
-	fd, err := c.sysfd()
-	if err != nil {
-		return err
-	}
-	grp := netAddrToIP16(group)
-	if grp == nil {
-		return errMissingAddress
-	}
-	return joinIPv6Group(fd, ifi, grp)
-}
-
-// LeaveGroup leaves the group address group on the interface ifi.
-func (c *dgramOpt) LeaveGroup(ifi *net.Interface, group net.Addr) error {
-	if !c.ok() {
-		return syscall.EINVAL
-	}
-	fd, err := c.sysfd()
-	if err != nil {
-		return err
-	}
-	grp := netAddrToIP16(group)
-	if grp == nil {
-		return errMissingAddress
-	}
-	return leaveIPv6Group(fd, ifi, grp)
-}
-
-// Checksum reports whether the kernel will compute, store or verify a
-// checksum for both incoming and outgoing packets.  If on is true, it
-// returns an offset in bytes into the data of where the checksum
-// field is located.
-func (c *dgramOpt) Checksum() (on bool, offset int, err error) {
-	if !c.ok() {
-		return false, 0, syscall.EINVAL
-	}
-	fd, err := c.sysfd()
-	if err != nil {
-		return false, 0, err
-	}
-	return ipv6Checksum(fd)
-}
-
-// SetChecksum enables the kernel checksum processing.  If on is ture,
-// the offset should be an offset in bytes into the data of where the
-// checksum field is located.
-func (c *dgramOpt) SetChecksum(on bool, offset int) error {
-	if !c.ok() {
-		return syscall.EINVAL
-	}
-	fd, err := c.sysfd()
-	if err != nil {
-		return err
-	}
-	return setIPv6Checksum(fd, on, offset)
-}
-
-// ICMPFilter returns an ICMP filter.
-func (c *dgramOpt) ICMPFilter() (*ICMPFilter, error) {
-	if !c.ok() {
-		return nil, syscall.EINVAL
-	}
-	fd, err := c.sysfd()
-	if err != nil {
-		return nil, err
-	}
-	return ipv6ICMPFilter(fd)
-}
-
-// SetICMPFilter deploys the ICMP filter.
-func (c *dgramOpt) SetICMPFilter(f *ICMPFilter) error {
-	if !c.ok() {
-		return syscall.EINVAL
-	}
-	fd, err := c.sysfd()
-	if err != nil {
-		return err
-	}
-	return setIPv6ICMPFilter(fd, f)
-}

Godeps/_workspace/src/code.google.com/p/go.net/ipv6/dgramopt_stub.go

@@ -1,95 +0,0 @@
-// 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.
-
-// +build dragonfly plan9 solaris
-
-package ipv6
-
-import "net"
-
-// MulticastHopLimit returns the hop limit field value for outgoing
-// multicast packets.
-func (c *dgramOpt) MulticastHopLimit() (int, error) {
-	// TODO(mikio): Implement this
-	return 0, errOpNoSupport
-}
-
-// SetMulticastHopLimit sets the hop limit field value for future
-// outgoing multicast packets.
-func (c *dgramOpt) SetMulticastHopLimit(hoplim int) error {
-	// TODO(mikio): Implement this
-	return errOpNoSupport
-}
-
-// MulticastInterface returns the default interface for multicast
-// packet transmissions.
-func (c *dgramOpt) MulticastInterface() (*net.Interface, error) {
-	// TODO(mikio): Implement this
-	return nil, errOpNoSupport
-}
-
-// SetMulticastInterface sets the default interface for future
-// multicast packet transmissions.
-func (c *dgramOpt) SetMulticastInterface(ifi *net.Interface) error {
-	// TODO(mikio): Implement this
-	return errOpNoSupport
-}
-
-// MulticastLoopback reports whether transmitted multicast packets
-// should be copied and send back to the originator.
-func (c *dgramOpt) MulticastLoopback() (bool, error) {
-	// TODO(mikio): Implement this
-	return false, errOpNoSupport
-}
-
-// SetMulticastLoopback sets whether transmitted multicast packets
-// should be copied and send back to the originator.
-func (c *dgramOpt) SetMulticastLoopback(on bool) error {
-	// TODO(mikio): Implement this
-	return errOpNoSupport
-}
-
-// JoinGroup joins the group address group on the interface ifi.
-// It uses the system assigned multicast interface when ifi is nil,
-// although this is not recommended because the assignment depends on
-// platforms and sometimes it might require routing configuration.
-func (c *dgramOpt) JoinGroup(ifi *net.Interface, group net.Addr) error {
-	// TODO(mikio): Implement this
-	return errOpNoSupport
-}
-
-// LeaveGroup leaves the group address group on the interface ifi.
-func (c *dgramOpt) LeaveGroup(ifi *net.Interface, group net.Addr) error {
-	// TODO(mikio): Implement this
-	return errOpNoSupport
-}
-
-// Checksum reports whether the kernel will compute, store or verify a
-// checksum for both incoming and outgoing packets.  If on is true, it
-// returns an offset in bytes into the data of where the checksum
-// field is located.
-func (c *dgramOpt) Checksum() (on bool, offset int, err error) {
-	// TODO(mikio): Implement this
-	return false, 0, errOpNoSupport
-}
-
-// SetChecksum enables the kernel checksum processing.  If on is ture,
-// the offset should be an offset in bytes into the data of where the
-// checksum field is located.
-func (c *dgramOpt) SetChecksum(on bool, offset int) error {
-	// TODO(mikio): Implement this
-	return errOpNoSupport
-}
-
-// ICMPFilter returns an ICMP filter.
-func (c *dgramOpt) ICMPFilter() (*ICMPFilter, error) {
-	// TODO(mikio): Implement this
-	return nil, errOpNoSupport
-}
-
-// SetICMPFilter deploys the ICMP filter.
-func (c *dgramOpt) SetICMPFilter(f *ICMPFilter) error {
-	// TODO(mikio): Implement this
-	return errOpNoSupport
-}

Godeps/_workspace/src/code.google.com/p/go.net/ipv6/doc.go

@@ -1,193 +0,0 @@
-// 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.
-
-// Package ipv6 implements IP-level socket options for the Internet
-// Protocol version 6.
-//
-// The package provides IP-level socket options that allow
-// manipulation of IPv6 facilities.  The IPv6 and socket options for
-// IPv6 are defined in RFC 2460, RFC 3493 and RFC 3542.
-//
-//
-// Unicasting
-//
-// The options for unicasting are available for net.TCPConn,
-// net.UDPConn and net.IPConn which are created as network connections
-// that use the IPv6 transport.  When a single TCP connection carrying
-// a data flow of multiple packets needs to indicate the flow is
-// important, ipv6.Conn is used to set the traffic class field on the
-// IPv6 header for each packet.
-//
-//	ln, err := net.Listen("tcp6", "[::]:1024")
-//	if err != nil {
-//		// error handling
-//	}
-//	defer ln.Close()
-//	for {
-//		c, err := ln.Accept()
-//		if err != nil {
-//			// error handling
-//		}
-//		go func(c net.Conn) {
-//			defer c.Close()
-//
-// The outgoing packets will be labeled DiffServ assured forwarding
-// class 1 low drop precedence, as known as AF11 packets.
-//
-//			if err := ipv6.NewConn(c).SetTrafficClass(DiffServAF11); err != nil {
-//				// error handling
-//			}
-//			if _, err := c.Write(data); err != nil {
-//				// error handling
-//			}
-//		}(c)
-//	}
-//
-//
-// Multicasting
-//
-// The options for multicasting are available for net.UDPConn and
-// net.IPconn which are created as network connections that use the
-// IPv6 transport.  A few network facilities must be prepared before
-// you begin multicasting, at a minimum joining network interfaces and
-// multicast groups.
-//
-//	en0, err := net.InterfaceByName("en0")
-//	if err != nil {
-//		// error handling
-//	}
-//	en1, err := net.InterfaceByIndex(911)
-//	if err != nil {
-//		// error handling
-//	}
-//	group := net.ParseIP("ff02::114")
-//
-// First, an application listens to an appropriate address with an
-// appropriate service port.
-//
-//	c, err := net.ListenPacket("udp6", "[::]:1024")
-//	if err != nil {
-//		// error handling
-//	}
-//	defer c.Close()
-//
-// Second, the application joins multicast groups, starts listening to
-// the groups on the specified network interfaces.  Note that the
-// service port for transport layer protocol does not matter with this
-// operation as joining groups affects only network and link layer
-// protocols, such as IPv6 and Ethernet.
-//
-//	p := ipv6.NewPacketConn(c)
-//	if err := p.JoinGroup(en0, &net.UDPAddr{IP: group}); err != nil {
-//		// error handling
-//	}
-//	if err := p.JoinGroup(en1, &net.UDPAddr{IP: group}); err != nil {
-//		// error handling
-//	}
-//
-// The application might set per packet control message transmissions
-// between the protocol stack within the kernel.  When the application
-// needs a destination address on an incoming packet,
-// SetControlMessage of ipv6.PacketConn is used to enable control
-// message transmissons.
-//
-//	if err := p.SetControlMessage(ipv6.FlagDst, true); err != nil {
-//		// error handling
-//	}
-//
-// The application could identify whether the received packets are
-// of interest by using the control message that contains the
-// destination address of the received packet.
-//
-//	b := make([]byte, 1500)
-//	for {
-//		n, rcm, src, err := p.ReadFrom(b)
-//		if err != nil {
-//			// error handling
-//		}
-//		if rcm.Dst.IsMulticast() {
-//			if rcm.Dst.Equal(group)
-//				// joined group, do something
-//			} else {
-//				// unknown group, discard
-//				continue
-//			}
-//		}
-//
-// The application can also send both unicast and multicast packets.
-//
-//		p.SetTrafficClass(DiffServCS0)
-//		p.SetHopLimit(16)
-//		if _, err := p.WriteTo(data[:n], nil, src); err != nil {
-//			// error handling
-//		}
-//		dst := &net.UDPAddr{IP: group, Port: 1024}
-//		wcm := ipv6.ControlMessage{TrafficClass: DiffServCS7, HopLimit: 1}
-//		for _, ifi := range []*net.Interface{en0, en1} {
-//			wcm.IfIndex = ifi.Index
-//			if _, err := p.WriteTo(data[:n], &wcm, dst); err != nil {
-//				// error handling
-//			}
-//		}
-//	}
-//
-//
-// More multicasting
-//
-// An application that uses PacketConn may join multiple multicast
-// groups.  For example, a UDP listener with port 1024 might join two
-// different groups across over two different network interfaces by
-// using:
-//
-//	c, err := net.ListenPacket("udp6", "[::]:1024")
-//	if err != nil {
-//		// error handling
-//	}
-//	defer c.Close()
-//	p := ipv6.NewPacketConn(c)
-//	if err := p.JoinGroup(en0, &net.UDPAddr{IP: net.ParseIP("ff02::1:114")}); err != nil {
-//		// error handling
-//	}
-//	if err := p.JoinGroup(en0, &net.UDPAddr{IP: net.ParseIP("ff02::2:114")}); err != nil {
-//		// error handling
-//	}
-//	if err := p.JoinGroup(en1, &net.UDPAddr{IP: net.ParseIP("ff02::2:114")}); err != nil {
-//		// error handling
-//	}
-//
-// It is possible for multiple UDP listeners that listen on the same
-// UDP port to join the same multicast group.  The net package will
-// provide a socket that listens to a wildcard address with reusable
-// UDP port when an appropriate multicast address prefix is passed to
-// the net.ListenPacket or net.ListenUDP.
-//
-//	c1, err := net.ListenPacket("udp6", "[ff02::]:1024")
-//	if err != nil {
-//		// error handling
-//	}
-//	defer c1.Close()
-//	c2, err := net.ListenPacket("udp6", "[ff02::]:1024")
-//	if err != nil {
-//		// error handling
-//	}
-//	defer c2.Close()
-//	p1 := ipv6.NewPacketConn(c1)
-//	if err := p1.JoinGroup(en0, &net.UDPAddr{IP: net.ParseIP("ff02::114")}); err != nil {
-//		// error handling
-//	}
-//	p2 := ipv6.NewPacketConn(c2)
-//	if err := p2.JoinGroup(en0, &net.UDPAddr{IP: net.ParseIP("ff02::114")}); err != nil {
-//		// error handling
-//	}
-//
-// Also it is possible for the application to leave or rejoin a
-// multicast group on the network interface.
-//
-//	if err := p.LeaveGroup(en0, &net.UDPAddr{IP: net.ParseIP("ff02::114")}); err != nil {
-//		// error handling
-//	}
-//	if err := p.JoinGroup(en0, &net.UDPAddr{IP: net.ParseIP("ff01::114")}); err != nil {
-//		// error handling
-//	}
-package ipv6

Godeps/_workspace/src/code.google.com/p/go.net/ipv6/endpoint.go

@@ -1,119 +0,0 @@
-// 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.
-
-package ipv6
-
-import (
-	"net"
-	"syscall"
-	"time"
-)
-
-// A Conn represents a network endpoint that uses IPv6 transport.
-// It allows to set basic IP-level socket options such as traffic
-// class and hop limit.
-type Conn struct {
-	genericOpt
-}
-
-type genericOpt struct {
-	net.Conn
-}
-
-func (c *genericOpt) ok() bool { return c != nil && c.Conn != nil }
-
-// PathMTU returns a path MTU value for the destination associated
-// with the endpoint.
-func (c *Conn) PathMTU() (int, error) {
-	if !c.genericOpt.ok() {
-		return 0, syscall.EINVAL
-	}
-	fd, err := c.genericOpt.sysfd()
-	if err != nil {
-		return 0, err
-	}
-	return ipv6PathMTU(fd)
-}
-
-// NewConn returns a new Conn.
-func NewConn(c net.Conn) *Conn {
-	return &Conn{
-		genericOpt: genericOpt{Conn: c},
-	}
-}
-
-// A PacketConn represents a packet network endpoint that uses IPv6
-// transport.  It is used to control several IP-level socket options
-// including IPv6 header manipulation.  It also provides datagram
-// based network I/O methods specific to the IPv6 and higher layer
-// protocols such as OSPF, GRE, and UDP.
-type PacketConn struct {
-	genericOpt
-	dgramOpt
-	payloadHandler
-}
-
-type dgramOpt struct {
-	net.PacketConn
-}
-
-func (c *dgramOpt) ok() bool { return c != nil && c.PacketConn != nil }
-
-// SetControlMessage allows to receive the per packet basis IP-level
-// socket options.
-func (c *PacketConn) SetControlMessage(cf ControlFlags, on bool) error {
-	if !c.payloadHandler.ok() {
-		return syscall.EINVAL
-	}
-	fd, err := c.payloadHandler.sysfd()
-	if err != nil {
-		return err
-	}
-	return setControlMessage(fd, &c.payloadHandler.rawOpt, cf, on)
-}
-
-// SetDeadline sets the read and write deadlines associated with the
-// endpoint.
-func (c *PacketConn) SetDeadline(t time.Time) error {
-	if !c.payloadHandler.ok() {
-		return syscall.EINVAL
-	}
-	return c.payloadHandler.SetDeadline(t)
-}
-
-// SetReadDeadline sets the read deadline associated with the
-// endpoint.
-func (c *PacketConn) SetReadDeadline(t time.Time) error {
-	if !c.payloadHandler.ok() {
-		return syscall.EINVAL
-	}
-	return c.payloadHandler.SetReadDeadline(t)
-}
-
-// SetWriteDeadline sets the write deadline associated with the
-// endpoint.
-func (c *PacketConn) SetWriteDeadline(t time.Time) error {
-	if !c.payloadHandler.ok() {
-		return syscall.EINVAL
-	}
-	return c.payloadHandler.SetWriteDeadline(t)
-}
-
-// Close closes the endpoint.
-func (c *PacketConn) Close() error {
-	if !c.payloadHandler.ok() {
-		return syscall.EINVAL
-	}
-	return c.payloadHandler.Close()
-}
-
-// NewPacketConn returns a new PacketConn using c as its underlying
-// transport.
-func NewPacketConn(c net.PacketConn) *PacketConn {
-	return &PacketConn{
-		genericOpt:     genericOpt{Conn: c.(net.Conn)},
-		dgramOpt:       dgramOpt{PacketConn: c},
-		payloadHandler: payloadHandler{PacketConn: c},
-	}
-}

Godeps/_workspace/src/code.google.com/p/go.net/ipv6/gen.go

@@ -1,241 +0,0 @@
-// 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.
-
-// +build ignore
-
-// This program generates internet protocol constatns and tables by
-// reading IANA protocol registries.
-//
-// Usage:
-//	go run gen.go > iana.go
-package main
-
-import (
-	"bytes"
-	"encoding/xml"
-	"fmt"
-	"go/format"
-	"io"
-	"net/http"
-	"os"
-	"strconv"
-	"strings"
-)
-
-var registries = []struct {
-	url   string
-	parse func(io.Writer, io.Reader) error
-}{
-	{
-		"http://www.iana.org/assignments/icmpv6-parameters/icmpv6-parameters.xml",
-		parseICMPv6Parameters,
-	},
-	{
-		"http://www.iana.org/assignments/protocol-numbers/protocol-numbers.xml",
-		parseProtocolNumbers,
-	},
-}
-
-func main() {
-	var bb bytes.Buffer
-	fmt.Fprintf(&bb, "// go run gen.go\n")
-	fmt.Fprintf(&bb, "// GENERATED BY THE COMMAND ABOVE; DO NOT EDIT\n\n")
-	fmt.Fprintf(&bb, "package ipv6\n\n")
-	for _, r := range registries {
-		resp, err := http.Get(r.url)
-		if err != nil {
-			fmt.Fprintln(os.Stderr, err)
-			os.Exit(1)
-		}
-		defer resp.Body.Close()
-		if resp.StatusCode != http.StatusOK {
-			fmt.Fprintf(os.Stderr, "got HTTP status code %v for %v\n", resp.StatusCode, r.url)
-			os.Exit(1)
-		}
-		if err := r.parse(&bb, resp.Body); err != nil {
-			fmt.Fprintln(os.Stderr, err)
-			os.Exit(1)
-		}
-		fmt.Fprintf(&bb, "\n")
-	}
-	b, err := format.Source(bb.Bytes())
-	if err != nil {
-		fmt.Fprintln(os.Stderr, err)
-		os.Exit(1)
-	}
-	os.Stdout.Write(b)
-}
-
-func parseICMPv6Parameters(w io.Writer, r io.Reader) error {
-	dec := xml.NewDecoder(r)
-	var icp icmpv6Parameters
-	if err := dec.Decode(&icp); err != nil {
-		return err
-	}
-	prs := icp.escape()
-	fmt.Fprintf(w, "// %s, Updated: %s\n", icp.Title, icp.Updated)
-	fmt.Fprintf(w, "const (\n")
-	for _, pr := range prs {
-		if pr.Name == "" {
-			continue
-		}
-		fmt.Fprintf(w, "ICMPType%s ICMPType = %d", pr.Name, pr.Value)
-		fmt.Fprintf(w, "// %s\n", pr.OrigName)
-	}
-	fmt.Fprintf(w, ")\n\n")
-	fmt.Fprintf(w, "// %s, Updated: %s\n", icp.Title, icp.Updated)
-	fmt.Fprintf(w, "var icmpTypes = map[ICMPType]string{\n")
-	for _, pr := range prs {
-		if pr.Name == "" {
-			continue
-		}
-		fmt.Fprintf(w, "%d: %q,\n", pr.Value, strings.ToLower(pr.OrigName))
-	}
-	fmt.Fprintf(w, "}\n")
-	return nil
-}
-
-type icmpv6Parameters struct {
-	XMLName    xml.Name `xml:"registry"`
-	Title      string   `xml:"title"`
-	Updated    string   `xml:"updated"`
-	Registries []struct {
-		Title   string `xml:"title"`
-		Records []struct {
-			Value string `xml:"value"`
-			Name  string `xml:"name"`
-		} `xml:"record"`
-	} `xml:"registry"`
-}
-
-type canonICMPv6ParamRecord struct {
-	OrigName string
-	Name     string
-	Value    int
-}
-
-func (icp *icmpv6Parameters) escape() []canonICMPv6ParamRecord {
-	id := -1
-	for i, r := range icp.Registries {
-		if strings.Contains(r.Title, "Type") || strings.Contains(r.Title, "type") {
-			id = i
-			break
-		}
-	}
-	if id < 0 {
-		return nil
-	}
-	prs := make([]canonICMPv6ParamRecord, len(icp.Registries[id].Records))
-	sr := strings.NewReplacer(
-		"Messages", "",
-		"Message", "",
-		"ICMP", "",
-		"+", "P",
-		"-", "",
-		"/", "",
-		".", "",
-		" ", "",
-	)
-	for i, pr := range icp.Registries[id].Records {
-		if strings.Contains(pr.Name, "Reserved") ||
-			strings.Contains(pr.Name, "Unassigned") ||
-			strings.Contains(pr.Name, "Deprecated") ||
-			strings.Contains(pr.Name, "Experiment") ||
-			strings.Contains(pr.Name, "experiment") {
-			continue
-		}
-		ss := strings.Split(pr.Name, "\n")
-		if len(ss) > 1 {
-			prs[i].Name = strings.Join(ss, " ")
-		} else {
-			prs[i].Name = ss[0]
-		}
-		s := strings.TrimSpace(prs[i].Name)
-		prs[i].OrigName = s
-		prs[i].Name = sr.Replace(s)
-		prs[i].Value, _ = strconv.Atoi(pr.Value)
-	}
-	return prs
-}
-
-func parseProtocolNumbers(w io.Writer, r io.Reader) error {
-	dec := xml.NewDecoder(r)
-	var pn protocolNumbers
-	if err := dec.Decode(&pn); err != nil {
-		return err
-	}
-	prs := pn.escape()
-	fmt.Fprintf(w, "// %s, Updated: %s\n", pn.Title, pn.Updated)
-	fmt.Fprintf(w, "const (\n")
-	for _, pr := range prs {
-		if pr.Name == "" {
-			continue
-		}
-		fmt.Fprintf(w, "ianaProtocol%s = %d", pr.Name, pr.Value)
-		s := pr.Descr
-		if s == "" {
-			s = pr.OrigName
-		}
-		fmt.Fprintf(w, "// %s\n", s)
-	}
-	fmt.Fprintf(w, ")\n")
-	return nil
-}
-
-type protocolNumbers struct {
-	XMLName  xml.Name `xml:"registry"`
-	Title    string   `xml:"title"`
-	Updated  string   `xml:"updated"`
-	RegTitle string   `xml:"registry>title"`
-	Note     string   `xml:"registry>note"`
-	Records  []struct {
-		Value string `xml:"value"`
-		Name  string `xml:"name"`
-		Descr string `xml:"description"`
-	} `xml:"registry>record"`
-}
-
-type canonProtocolRecord struct {
-	OrigName string
-	Name     string
-	Descr    string
-	Value    int
-}
-
-func (pn *protocolNumbers) escape() []canonProtocolRecord {
-	prs := make([]canonProtocolRecord, len(pn.Records))
-	sr := strings.NewReplacer(
-		"-in-", "in",
-		"-within-", "within",
-		"-over-", "over",
-		"+", "P",
-		"-", "",
-		"/", "",
-		".", "",
-		" ", "",
-	)
-	for i, pr := range pn.Records {
-		prs[i].OrigName = pr.Name
-		s := strings.TrimSpace(pr.Name)
-		switch pr.Name {
-		case "ISIS over IPv4":
-			prs[i].Name = "ISIS"
-		case "manet":
-			prs[i].Name = "MANET"
-		default:
-			prs[i].Name = sr.Replace(s)
-		}
-		ss := strings.Split(pr.Descr, "\n")
-		for i := range ss {
-			ss[i] = strings.TrimSpace(ss[i])
-		}
-		if len(ss) > 1 {
-			prs[i].Descr = strings.Join(ss, " ")
-		} else {
-			prs[i].Descr = ss[0]
-		}
-		prs[i].Value, _ = strconv.Atoi(pr.Value)
-	}
-	return prs
-}

Godeps/_workspace/src/code.google.com/p/go.net/ipv6/genericopt_posix.go

@@ -1,60 +0,0 @@
-// 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.
-
-// +build darwin freebsd linux netbsd openbsd windows
-
-package ipv6
-
-import "syscall"
-
-// TrafficClass returns the traffic class field value for outgoing
-// packets.
-func (c *genericOpt) TrafficClass() (int, error) {
-	if !c.ok() {
-		return 0, syscall.EINVAL
-	}
-	fd, err := c.sysfd()
-	if err != nil {
-		return 0, err
-	}
-	return ipv6TrafficClass(fd)
-}
-
-// SetTrafficClass sets the traffic class field value for future
-// outgoing packets.
-func (c *genericOpt) SetTrafficClass(tclass int) error {
-	if !c.ok() {
-		return syscall.EINVAL
-	}
-	fd, err := c.sysfd()
-	if err != nil {
-		return err
-	}
-	return setIPv6TrafficClass(fd, tclass)
-}
-
-// HopLimit returns the hop limit field value for outgoing packets.
-func (c *genericOpt) HopLimit() (int, error) {
-	if !c.ok() {
-		return 0, syscall.EINVAL
-	}
-	fd, err := c.sysfd()
-	if err != nil {
-		return 0, err
-	}
-	return ipv6HopLimit(fd)
-}
-
-// SetHopLimit sets the hop limit field value for future outgoing
-// packets.
-func (c *genericOpt) SetHopLimit(hoplim int) error {
-	if !c.ok() {
-		return syscall.EINVAL
-	}
-	fd, err := c.sysfd()
-	if err != nil {
-		return err
-	}
-	return setIPv6HopLimit(fd, hoplim)
-}

Godeps/_workspace/src/code.google.com/p/go.net/ipv6/genericopt_stub.go

@@ -1,34 +0,0 @@
-// 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.
-
-// +build dragonfly plan9 solaris
-
-package ipv6
-
-// TrafficClass returns the traffic class field value for outgoing
-// packets.
-func (c *genericOpt) TrafficClass() (int, error) {
-	// TODO(mikio): Implement this
-	return 0, errOpNoSupport
-}
-
-// SetTrafficClass sets the traffic class field value for future
-// outgoing packets.
-func (c *genericOpt) SetTrafficClass(tclass int) error {
-	// TODO(mikio): Implement this
-	return errOpNoSupport
-}
-
-// HopLimit returns the hop limit field value for outgoing packets.
-func (c *genericOpt) HopLimit() (int, error) {
-	// TODO(mikio): Implement this
-	return 0, errOpNoSupport
-}
-
-// SetHopLimit sets the hop limit field value for future outgoing
-// packets.
-func (c *genericOpt) SetHopLimit(hoplim int) error {
-	// TODO(mikio): Implement this
-	return errOpNoSupport
-}

Godeps/_workspace/src/code.google.com/p/go.net/ipv6/gentest.go

@@ -1,195 +0,0 @@
-// 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.
-
-// +build ignore
-
-// This program generates internet protocol constants by reading IANA
-// protocol registries.
-//
-// Usage:
-//	go run gentest.go > iana_test.go
-package main
-
-import (
-	"bytes"
-	"encoding/xml"
-	"fmt"
-	"go/format"
-	"io"
-	"net/http"
-	"os"
-	"strconv"
-	"strings"
-)
-
-var registries = []struct {
-	url   string
-	parse func(io.Writer, io.Reader) error
-}{
-	{
-		"http://www.iana.org/assignments/dscp-registry/dscp-registry.xml",
-		parseDSCPRegistry,
-	},
-	{
-		"http://www.iana.org/assignments/ipv4-tos-byte/ipv4-tos-byte.xml",
-		parseTOSTCByte,
-	},
-}
-
-func main() {
-	var bb bytes.Buffer
-	fmt.Fprintf(&bb, "// go run gentest.go\n")
-	fmt.Fprintf(&bb, "// GENERATED BY THE COMMAND ABOVE; DO NOT EDIT\n\n")
-	fmt.Fprintf(&bb, "package ipv6_test\n\n")
-	for _, r := range registries {
-		resp, err := http.Get(r.url)
-		if err != nil {
-			fmt.Fprintln(os.Stderr, err)
-			os.Exit(1)
-		}
-		defer resp.Body.Close()
-		if resp.StatusCode != http.StatusOK {
-			fmt.Fprintf(os.Stderr, "got HTTP status code %v for %v\n", resp.StatusCode, r.url)
-			os.Exit(1)
-		}
-		if err := r.parse(&bb, resp.Body); err != nil {
-			fmt.Fprintln(os.Stderr, err)
-			os.Exit(1)
-		}
-		fmt.Fprintf(&bb, "\n")
-	}
-	b, err := format.Source(bb.Bytes())
-	if err != nil {
-		fmt.Fprintln(os.Stderr, err)
-		os.Exit(1)
-	}
-	os.Stdout.Write(b)
-}
-
-func parseDSCPRegistry(w io.Writer, r io.Reader) error {
-	dec := xml.NewDecoder(r)
-	var dr dscpRegistry
-	if err := dec.Decode(&dr); err != nil {
-		return err
-	}
-	drs := dr.escape()
-	fmt.Fprintf(w, "// %s, Updated: %s\n", dr.Title, dr.Updated)
-	fmt.Fprintf(w, "const (\n")
-	for _, dr := range drs {
-		fmt.Fprintf(w, "DiffServ%s = %#x", dr.Name, dr.Value)
-		fmt.Fprintf(w, "// %s\n", dr.OrigName)
-	}
-	fmt.Fprintf(w, ")\n")
-	return nil
-}
-
-type dscpRegistry struct {
-	XMLName     xml.Name `xml:"registry"`
-	Title       string   `xml:"title"`
-	Updated     string   `xml:"updated"`
-	Note        string   `xml:"note"`
-	RegTitle    string   `xml:"registry>title"`
-	PoolRecords []struct {
-		Name  string `xml:"name"`
-		Space string `xml:"space"`
-	} `xml:"registry>record"`
-	Records []struct {
-		Name  string `xml:"name"`
-		Space string `xml:"space"`
-	} `xml:"registry>registry>record"`
-}
-
-type canonDSCPRecord struct {
-	OrigName string
-	Name     string
-	Value    int
-}
-
-func (drr *dscpRegistry) escape() []canonDSCPRecord {
-	drs := make([]canonDSCPRecord, len(drr.Records))
-	sr := strings.NewReplacer(
-		"+", "",
-		"-", "",
-		"/", "",
-		".", "",
-		" ", "",
-	)
-	for i, dr := range drr.Records {
-		s := strings.TrimSpace(dr.Name)
-		drs[i].OrigName = s
-		drs[i].Name = sr.Replace(s)
-		n, err := strconv.ParseUint(dr.Space, 2, 8)
-		if err != nil {
-			continue
-		}
-		drs[i].Value = int(n) << 2
-	}
-	return drs
-}
-
-func parseTOSTCByte(w io.Writer, r io.Reader) error {
-	dec := xml.NewDecoder(r)
-	var ttb tosTCByte
-	if err := dec.Decode(&ttb); err != nil {
-		return err
-	}
-	trs := ttb.escape()
-	fmt.Fprintf(w, "// %s, Updated: %s\n", ttb.Title, ttb.Updated)
-	fmt.Fprintf(w, "const (\n")
-	for _, tr := range trs {
-		fmt.Fprintf(w, "%s = %#x", tr.Keyword, tr.Value)
-		fmt.Fprintf(w, "// %s\n", tr.OrigKeyword)
-	}
-	fmt.Fprintf(w, ")\n")
-	return nil
-}
-
-type tosTCByte struct {
-	XMLName  xml.Name `xml:"registry"`
-	Title    string   `xml:"title"`
-	Updated  string   `xml:"updated"`
-	Note     string   `xml:"note"`
-	RegTitle string   `xml:"registry>title"`
-	Records  []struct {
-		Binary  string `xml:"binary"`
-		Keyword string `xml:"keyword"`
-	} `xml:"registry>record"`
-}
-
-type canonTOSTCByteRecord struct {
-	OrigKeyword string
-	Keyword     string
-	Value       int
-}
-
-func (ttb *tosTCByte) escape() []canonTOSTCByteRecord {
-	trs := make([]canonTOSTCByteRecord, len(ttb.Records))
-	sr := strings.NewReplacer(
-		"Capable", "",
-		"(", "",
-		")", "",
-		"+", "",
-		"-", "",
-		"/", "",
-		".", "",
-		" ", "",
-	)
-	for i, tr := range ttb.Records {
-		s := strings.TrimSpace(tr.Keyword)
-		trs[i].OrigKeyword = s
-		ss := strings.Split(s, " ")
-		if len(ss) > 1 {
-			trs[i].Keyword = strings.Join(ss[1:], " ")
-		} else {
-			trs[i].Keyword = ss[0]
-		}
-		trs[i].Keyword = sr.Replace(trs[i].Keyword)
-		n, err := strconv.ParseUint(tr.Binary, 2, 8)
-		if err != nil {
-			continue
-		}
-		trs[i].Value = int(n)
-	}
-	return trs
-}

Godeps/_workspace/src/code.google.com/p/go.net/ipv6/helper.go

@@ -1,33 +0,0 @@
-// 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.
-
-package ipv6
-
-import (
-	"errors"
-	"net"
-)
-
-var errOpNoSupport = errors.New("operation not supported")
-
-func boolint(b bool) int {
-	if b {
-		return 1
-	}
-	return 0
-}
-
-func netAddrToIP16(a net.Addr) net.IP {
-	switch v := a.(type) {
-	case *net.UDPAddr:
-		if ip := v.IP.To16(); ip != nil && ip.To4() == nil {
-			return ip
-		}
-	case *net.IPAddr:
-		if ip := v.IP.To16(); ip != nil && ip.To4() == nil {
-			return ip
-		}
-	}
-	return nil
-}

Godeps/_workspace/src/code.google.com/p/go.net/ipv6/helper_stub.go

@@ -1,22 +0,0 @@
-// 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.
-
-// +build dragonfly plan9 solaris
-
-package ipv6
-
-func (c *genericOpt) sysfd() (int, error) {
-	// TODO(mikio): Implement this
-	return 0, errOpNoSupport
-}
-
-func (c *dgramOpt) sysfd() (int, error) {
-	// TODO(mikio): Implement this
-	return 0, errOpNoSupport
-}
-
-func (c *payloadHandler) sysfd() (int, error) {
-	// TODO(mikio): Implement this
-	return 0, errOpNoSupport
-}

Godeps/_workspace/src/code.google.com/p/go.net/ipv6/helper_unix.go

@@ -1,46 +0,0 @@
-// 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.
-
-// +build darwin freebsd linux netbsd openbsd
-
-package ipv6
-
-import (
-	"net"
-	"reflect"
-)
-
-func (c *genericOpt) sysfd() (int, error) {
-	switch p := c.Conn.(type) {
-	case *net.TCPConn, *net.UDPConn, *net.IPConn:
-		return sysfd(p)
-	}
-	return 0, errInvalidConnType
-}
-
-func (c *dgramOpt) sysfd() (int, error) {
-	switch p := c.PacketConn.(type) {
-	case *net.UDPConn, *net.IPConn:
-		return sysfd(p.(net.Conn))
-	}
-	return 0, errInvalidConnType
-}
-
-func (c *payloadHandler) sysfd() (int, error) {
-	return sysfd(c.PacketConn.(net.Conn))
-}
-
-func sysfd(c net.Conn) (int, error) {
-	cv := reflect.ValueOf(c)
-	switch ce := cv.Elem(); ce.Kind() {
-	case reflect.Struct:
-		nfd := ce.FieldByName("conn").FieldByName("fd")
-		switch fe := nfd.Elem(); fe.Kind() {
-		case reflect.Struct:
-			fd := fe.FieldByName("sysfd")
-			return int(fd.Int()), nil
-		}
-	}
-	return 0, errInvalidConnType
-}

Godeps/_workspace/src/code.google.com/p/go.net/ipv6/helper_windows.go

@@ -1,45 +0,0 @@
-// 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.
-
-package ipv6
-
-import (
-	"net"
-	"reflect"
-	"syscall"
-)
-
-func (c *genericOpt) sysfd() (syscall.Handle, error) {
-	switch p := c.Conn.(type) {
-	case *net.TCPConn, *net.UDPConn, *net.IPConn:
-		return sysfd(p)
-	}
-	return syscall.InvalidHandle, errInvalidConnType
-}
-
-func (c *dgramOpt) sysfd() (syscall.Handle, error) {
-	switch p := c.PacketConn.(type) {
-	case *net.UDPConn, *net.IPConn:
-		return sysfd(p.(net.Conn))
-	}
-	return syscall.InvalidHandle, errInvalidConnType
-}
-
-func (c *payloadHandler) sysfd() (syscall.Handle, error) {
-	return sysfd(c.PacketConn.(net.Conn))
-}
-
-func sysfd(c net.Conn) (syscall.Handle, error) {
-	cv := reflect.ValueOf(c)
-	switch ce := cv.Elem(); ce.Kind() {
-	case reflect.Struct:
-		netfd := ce.FieldByName("conn").FieldByName("fd")
-		switch fe := netfd.Elem(); fe.Kind() {
-		case reflect.Struct:
-			fd := fe.FieldByName("sysfd")
-			return syscall.Handle(fd.Uint()), nil
-		}
-	}
-	return syscall.InvalidHandle, errInvalidConnType
-}

Godeps/_workspace/src/code.google.com/p/go.net/ipv6/iana.go

@@ -1,224 +0,0 @@
-// go run gen.go
-// GENERATED BY THE COMMAND ABOVE; DO NOT EDIT
-
-package ipv6
-
-// Internet Control Message Protocol version 6 (ICMPv6) Parameters, Updated: 2013-07-03
-const (
-	ICMPTypeDestinationUnreachable                ICMPType = 1   // Destination Unreachable
-	ICMPTypePacketTooBig                          ICMPType = 2   // Packet Too Big
-	ICMPTypeTimeExceeded                          ICMPType = 3   // Time Exceeded
-	ICMPTypeParameterProblem                      ICMPType = 4   // Parameter Problem
-	ICMPTypeEchoRequest                           ICMPType = 128 // Echo Request
-	ICMPTypeEchoReply                             ICMPType = 129 // Echo Reply
-	ICMPTypeMulticastListenerQuery                ICMPType = 130 // Multicast Listener Query
-	ICMPTypeMulticastListenerReport               ICMPType = 131 // Multicast Listener Report
-	ICMPTypeMulticastListenerDone                 ICMPType = 132 // Multicast Listener Done
-	ICMPTypeRouterSolicitation                    ICMPType = 133 // Router Solicitation
-	ICMPTypeRouterAdvertisement                   ICMPType = 134 // Router Advertisement
-	ICMPTypeNeighborSolicitation                  ICMPType = 135 // Neighbor Solicitation
-	ICMPTypeNeighborAdvertisement                 ICMPType = 136 // Neighbor Advertisement
-	ICMPTypeRedirect                              ICMPType = 137 // Redirect Message
-	ICMPTypeRouterRenumbering                     ICMPType = 138 // Router Renumbering
-	ICMPTypeNodeInformationQuery                  ICMPType = 139 // ICMP Node Information Query
-	ICMPTypeNodeInformationResponse               ICMPType = 140 // ICMP Node Information Response
-	ICMPTypeInverseNeighborDiscoverySolicitation  ICMPType = 141 // Inverse Neighbor Discovery Solicitation Message
-	ICMPTypeInverseNeighborDiscoveryAdvertisement ICMPType = 142 // Inverse Neighbor Discovery Advertisement Message
-	ICMPTypeVersion2MulticastListenerReport       ICMPType = 143 // Version 2 Multicast Listener Report
-	ICMPTypeHomeAgentAddressDiscoveryRequest      ICMPType = 144 // Home Agent Address Discovery Request Message
-	ICMPTypeHomeAgentAddressDiscoveryReply        ICMPType = 145 // Home Agent Address Discovery Reply Message
-	ICMPTypeMobilePrefixSolicitation              ICMPType = 146 // Mobile Prefix Solicitation
-	ICMPTypeMobilePrefixAdvertisement             ICMPType = 147 // Mobile Prefix Advertisement
-	ICMPTypeCertificationPathSolicitation         ICMPType = 148 // Certification Path Solicitation Message
-	ICMPTypeCertificationPathAdvertisement        ICMPType = 149 // Certification Path Advertisement Message
-	ICMPTypeMulticastRouterAdvertisement          ICMPType = 151 // Multicast Router Advertisement
-	ICMPTypeMulticastRouterSolicitation           ICMPType = 152 // Multicast Router Solicitation
-	ICMPTypeMulticastRouterTermination            ICMPType = 153 // Multicast Router Termination
-	ICMPTypeFMIPv6                                ICMPType = 154 // FMIPv6 Messages
-	ICMPTypeRPLControl                            ICMPType = 155 // RPL Control Message
-	ICMPTypeILNPv6LocatorUpdate                   ICMPType = 156 // ILNPv6 Locator Update Message
-	ICMPTypeDuplicateAddressRequest               ICMPType = 157 // Duplicate Address Request
-	ICMPTypeDuplicateAddressConfirmation          ICMPType = 158 // Duplicate Address Confirmation
-)
-
-// Internet Control Message Protocol version 6 (ICMPv6) Parameters, Updated: 2013-07-03
-var icmpTypes = map[ICMPType]string{
-	1:   "destination unreachable",
-	2:   "packet too big",
-	3:   "time exceeded",
-	4:   "parameter problem",
-	128: "echo request",
-	129: "echo reply",
-	130: "multicast listener query",
-	131: "multicast listener report",
-	132: "multicast listener done",
-	133: "router solicitation",
-	134: "router advertisement",
-	135: "neighbor solicitation",
-	136: "neighbor advertisement",
-	137: "redirect message",
-	138: "router renumbering",
-	139: "icmp node information query",
-	140: "icmp node information response",
-	141: "inverse neighbor discovery solicitation message",
-	142: "inverse neighbor discovery advertisement message",
-	143: "version 2 multicast listener report",
-	144: "home agent address discovery request message",
-	145: "home agent address discovery reply message",
-	146: "mobile prefix solicitation",
-	147: "mobile prefix advertisement",
-	148: "certification path solicitation message",
-	149: "certification path advertisement message",
-	151: "multicast router advertisement",
-	152: "multicast router solicitation",
-	153: "multicast router termination",
-	154: "fmipv6 messages",
-	155: "rpl control message",
-	156: "ilnpv6 locator update message",
-	157: "duplicate address request",
-	158: "duplicate address confirmation",
-}
-
-// Protocol Numbers, Updated: 2013-02-17
-const (
-	ianaProtocolHOPOPT         = 0   // IPv6 Hop-by-Hop Option
-	ianaProtocolICMP           = 1   // Internet Control Message
-	ianaProtocolIGMP           = 2   // Internet Group Management
-	ianaProtocolGGP            = 3   // Gateway-to-Gateway
-	ianaProtocolIPv4           = 4   // IPv4 encapsulation
-	ianaProtocolST             = 5   // Stream
-	ianaProtocolTCP            = 6   // Transmission Control
-	ianaProtocolCBT            = 7   // CBT
-	ianaProtocolEGP            = 8   // Exterior Gateway Protocol
-	ianaProtocolIGP            = 9   // any private interior gateway (used by Cisco for their IGRP)
-	ianaProtocolBBNRCCMON      = 10  // BBN RCC Monitoring
-	ianaProtocolNVPII          = 11  // Network Voice Protocol
-	ianaProtocolPUP            = 12  // PUP
-	ianaProtocolARGUS          = 13  // ARGUS
-	ianaProtocolEMCON          = 14  // EMCON
-	ianaProtocolXNET           = 15  // Cross Net Debugger
-	ianaProtocolCHAOS          = 16  // Chaos
-	ianaProtocolUDP            = 17  // User Datagram
-	ianaProtocolMUX            = 18  // Multiplexing
-	ianaProtocolDCNMEAS        = 19  // DCN Measurement Subsystems
-	ianaProtocolHMP            = 20  // Host Monitoring
-	ianaProtocolPRM            = 21  // Packet Radio Measurement
-	ianaProtocolXNSIDP         = 22  // XEROX NS IDP
-	ianaProtocolTRUNK1         = 23  // Trunk-1
-	ianaProtocolTRUNK2         = 24  // Trunk-2
-	ianaProtocolLEAF1          = 25  // Leaf-1
-	ianaProtocolLEAF2          = 26  // Leaf-2
-	ianaProtocolRDP            = 27  // Reliable Data Protocol
-	ianaProtocolIRTP           = 28  // Internet Reliable Transaction
-	ianaProtocolISOTP4         = 29  // ISO Transport Protocol Class 4
-	ianaProtocolNETBLT         = 30  // Bulk Data Transfer Protocol
-	ianaProtocolMFENSP         = 31  // MFE Network Services Protocol
-	ianaProtocolMERITINP       = 32  // MERIT Internodal Protocol
-	ianaProtocolDCCP           = 33  // Datagram Congestion Control Protocol
-	ianaProtocol3PC            = 34  // Third Party Connect Protocol
-	ianaProtocolIDPR           = 35  // Inter-Domain Policy Routing Protocol
-	ianaProtocolXTP            = 36  // XTP
-	ianaProtocolDDP            = 37  // Datagram Delivery Protocol
-	ianaProtocolIDPRCMTP       = 38  // IDPR Control Message Transport Proto
-	ianaProtocolTPPP           = 39  // TP++ Transport Protocol
-	ianaProtocolIL             = 40  // IL Transport Protocol
-	ianaProtocolIPv6           = 41  // IPv6 encapsulation
-	ianaProtocolSDRP           = 42  // Source Demand Routing Protocol
-	ianaProtocolIPv6Route      = 43  // Routing Header for IPv6
-	ianaProtocolIPv6Frag       = 44  // Fragment Header for IPv6
-	ianaProtocolIDRP           = 45  // Inter-Domain Routing Protocol
-	ianaProtocolRSVP           = 46  // Reservation Protocol
-	ianaProtocolGRE            = 47  // Generic Routing Encapsulation
-	ianaProtocolDSR            = 48  // Dynamic Source Routing Protocol
-	ianaProtocolBNA            = 49  // BNA
-	ianaProtocolESP            = 50  // Encap Security Payload
-	ianaProtocolAH             = 51  // Authentication Header
-	ianaProtocolINLSP          = 52  // Integrated Net Layer Security  TUBA
-	ianaProtocolSWIPE          = 53  // IP with Encryption
-	ianaProtocolNARP           = 54  // NBMA Address Resolution Protocol
-	ianaProtocolMOBILE         = 55  // IP Mobility
-	ianaProtocolTLSP           = 56  // Transport Layer Security Protocol using Kryptonet key management
-	ianaProtocolSKIP           = 57  // SKIP
-	ianaProtocolIPv6ICMP       = 58  // ICMP for IPv6
-	ianaProtocolIPv6NoNxt      = 59  // No Next Header for IPv6
-	ianaProtocolIPv6Opts       = 60  // Destination Options for IPv6
-	ianaProtocolCFTP           = 62  // CFTP
-	ianaProtocolSATEXPAK       = 64  // SATNET and Backroom EXPAK
-	ianaProtocolKRYPTOLAN      = 65  // Kryptolan
-	ianaProtocolRVD            = 66  // MIT Remote Virtual Disk Protocol
-	ianaProtocolIPPC           = 67  // Internet Pluribus Packet Core
-	ianaProtocolSATMON         = 69  // SATNET Monitoring
-	ianaProtocolVISA           = 70  // VISA Protocol
-	ianaProtocolIPCV           = 71  // Internet Packet Core Utility
-	ianaProtocolCPNX           = 72  // Computer Protocol Network Executive
-	ianaProtocolCPHB           = 73  // Computer Protocol Heart Beat
-	ianaProtocolWSN            = 74  // Wang Span Network
-	ianaProtocolPVP            = 75  // Packet Video Protocol
-	ianaProtocolBRSATMON       = 76  // Backroom SATNET Monitoring
-	ianaProtocolSUNND          = 77  // SUN ND PROTOCOL-Temporary
-	ianaProtocolWBMON          = 78  // WIDEBAND Monitoring
-	ianaProtocolWBEXPAK        = 79  // WIDEBAND EXPAK
-	ianaProtocolISOIP          = 80  // ISO Internet Protocol
-	ianaProtocolVMTP           = 81  // VMTP
-	ianaProtocolSECUREVMTP     = 82  // SECURE-VMTP
-	ianaProtocolVINES          = 83  // VINES
-	ianaProtocolTTP            = 84  // TTP
-	ianaProtocolIPTM           = 84  // Protocol Internet Protocol Traffic Manager
-	ianaProtocolNSFNETIGP      = 85  // NSFNET-IGP
-	ianaProtocolDGP            = 86  // Dissimilar Gateway Protocol
-	ianaProtocolTCF            = 87  // TCF
-	ianaProtocolEIGRP          = 88  // EIGRP
-	ianaProtocolOSPFIGP        = 89  // OSPFIGP
-	ianaProtocolSpriteRPC      = 90  // Sprite RPC Protocol
-	ianaProtocolLARP           = 91  // Locus Address Resolution Protocol
-	ianaProtocolMTP            = 92  // Multicast Transport Protocol
-	ianaProtocolAX25           = 93  // AX.25 Frames
-	ianaProtocolIPIP           = 94  // IP-within-IP Encapsulation Protocol
-	ianaProtocolMICP           = 95  // Mobile Internetworking Control Pro.
-	ianaProtocolSCCSP          = 96  // Semaphore Communications Sec. Pro.
-	ianaProtocolETHERIP        = 97  // Ethernet-within-IP Encapsulation
-	ianaProtocolENCAP          = 98  // Encapsulation Header
-	ianaProtocolGMTP           = 100 // GMTP
-	ianaProtocolIFMP           = 101 // Ipsilon Flow Management Protocol
-	ianaProtocolPNNI           = 102 // PNNI over IP
-	ianaProtocolPIM            = 103 // Protocol Independent Multicast
-	ianaProtocolARIS           = 104 // ARIS
-	ianaProtocolSCPS           = 105 // SCPS
-	ianaProtocolQNX            = 106 // QNX
-	ianaProtocolAN             = 107 // Active Networks
-	ianaProtocolIPComp         = 108 // IP Payload Compression Protocol
-	ianaProtocolSNP            = 109 // Sitara Networks Protocol
-	ianaProtocolCompaqPeer     = 110 // Compaq Peer Protocol
-	ianaProtocolIPXinIP        = 111 // IPX in IP
-	ianaProtocolVRRP           = 112 // Virtual Router Redundancy Protocol
-	ianaProtocolPGM            = 113 // PGM Reliable Transport Protocol
-	ianaProtocolL2TP           = 115 // Layer Two Tunneling Protocol
-	ianaProtocolDDX            = 116 // D-II Data Exchange (DDX)
-	ianaProtocolIATP           = 117 // Interactive Agent Transfer Protocol
-	ianaProtocolSTP            = 118 // Schedule Transfer Protocol
-	ianaProtocolSRP            = 119 // SpectraLink Radio Protocol
-	ianaProtocolUTI            = 120 // UTI
-	ianaProtocolSMP            = 121 // Simple Message Protocol
-	ianaProtocolSM             = 122 // SM
-	ianaProtocolPTP            = 123 // Performance Transparency Protocol
-	ianaProtocolISIS           = 124 // ISIS over IPv4
-	ianaProtocolFIRE           = 125 // FIRE
-	ianaProtocolCRTP           = 126 // Combat Radio Transport Protocol
-	ianaProtocolCRUDP          = 127 // Combat Radio User Datagram
-	ianaProtocolSSCOPMCE       = 128 // SSCOPMCE
-	ianaProtocolIPLT           = 129 // IPLT
-	ianaProtocolSPS            = 130 // Secure Packet Shield
-	ianaProtocolPIPE           = 131 // Private IP Encapsulation within IP
-	ianaProtocolSCTP           = 132 // Stream Control Transmission Protocol
-	ianaProtocolFC             = 133 // Fibre Channel
-	ianaProtocolRSVPE2EIGNORE  = 134 // RSVP-E2E-IGNORE
-	ianaProtocolMobilityHeader = 135 // Mobility Header
-	ianaProtocolUDPLite        = 136 // UDPLite
-	ianaProtocolMPLSinIP       = 137 // MPLS-in-IP
-	ianaProtocolMANET          = 138 // MANET Protocols
-	ianaProtocolHIP            = 139 // Host Identity Protocol
-	ianaProtocolShim6          = 140 // Shim6 Protocol
-	ianaProtocolWESP           = 141 // Wrapped Encapsulating Security Payload
-	ianaProtocolROHC           = 142 // Robust Header Compression
-	ianaProtocolReserved       = 255 // Reserved
-)

Godeps/_workspace/src/code.google.com/p/go.net/ipv6/iana_test.go

@@ -1,38 +0,0 @@
-// go run gentest.go
-// GENERATED BY THE COMMAND ABOVE; DO NOT EDIT
-
-package ipv6_test
-
-// Differentiated Services Field Codepoints (DSCP), Updated: 2013-06-25
-const (
-	DiffServCS0        = 0x0  // CS0
-	DiffServCS1        = 0x20 // CS1
-	DiffServCS2        = 0x40 // CS2
-	DiffServCS3        = 0x60 // CS3
-	DiffServCS4        = 0x80 // CS4
-	DiffServCS5        = 0xa0 // CS5
-	DiffServCS6        = 0xc0 // CS6
-	DiffServCS7        = 0xe0 // CS7
-	DiffServAF11       = 0x28 // AF11
-	DiffServAF12       = 0x30 // AF12
-	DiffServAF13       = 0x38 // AF13
-	DiffServAF21       = 0x48 // AF21
-	DiffServAF22       = 0x50 // AF22
-	DiffServAF23       = 0x58 // AF23
-	DiffServAF31       = 0x68 // AF31
-	DiffServAF32       = 0x70 // AF32
-	DiffServAF33       = 0x78 // AF33
-	DiffServAF41       = 0x88 // AF41
-	DiffServAF42       = 0x90 // AF42
-	DiffServAF43       = 0x98 // AF43
-	DiffServEFPHB      = 0xb8 // EF PHB
-	DiffServVOICEADMIT = 0xb0 // VOICE-ADMIT
-)
-
-// IPv4 TOS Byte and IPv6 Traffic Class Octet, Updated: 2001-09-06
-const (
-	NotECNTransport       = 0x0 // Not-ECT (Not ECN-Capable Transport)
-	ECNTransport1         = 0x1 // ECT(1) (ECN-Capable Transport(1))
-	ECNTransport0         = 0x2 // ECT(0) (ECN-Capable Transport(0))
-	CongestionExperienced = 0x3 // CE (Congestion Experienced)
-)

Godeps/_workspace/src/code.google.com/p/go.net/ipv6/icmp.go

@@ -1,47 +0,0 @@
-// 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.
-
-package ipv6
-
-import "sync"
-
-// An ICMPType represents a type of ICMP message.
-type ICMPType int
-
-func (typ ICMPType) String() string {
-	s, ok := icmpTypes[typ]
-	if !ok {
-		return "<nil>"
-	}
-	return s
-}
-
-// An ICMPFilter represents an ICMP message filter for incoming
-// packets.
-type ICMPFilter struct {
-	mu sync.RWMutex
-	sysICMPFilter
-}
-
-// Set sets the ICMP type and filter action to the filter.
-func (f *ICMPFilter) Set(typ ICMPType, block bool) {
-	f.mu.Lock()
-	f.set(typ, block)
-	f.mu.Unlock()
-}
-
-// SetAll sets the filter action to the filter.
-func (f *ICMPFilter) SetAll(block bool) {
-	f.mu.Lock()
-	f.setAll(block)
-	f.mu.Unlock()
-}
-
-// WillBlock reports whether the ICMP type will be blocked.
-func (f *ICMPFilter) WillBlock(typ ICMPType) bool {
-	f.mu.RLock()
-	ok := f.willBlock(typ)
-	f.mu.RUnlock()
-	return ok
-}

Godeps/_workspace/src/code.google.com/p/go.net/ipv6/icmp_bsd.go

@@ -1,33 +0,0 @@
-// 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.
-
-// +build darwin freebsd netbsd openbsd
-
-package ipv6
-
-type sysICMPFilter struct {
-	Filt [8]uint32
-}
-
-func (f *sysICMPFilter) set(typ ICMPType, block bool) {
-	if block {
-		f.Filt[typ>>5] &^= 1 << (uint32(typ) & 31)
-	} else {
-		f.Filt[typ>>5] |= 1 << (uint32(typ) & 31)
-	}
-}
-
-func (f *sysICMPFilter) setAll(block bool) {
-	for i := range f.Filt {
-		if block {
-			f.Filt[i] = 0
-		} else {
-			f.Filt[i] = 1<<32 - 1
-		}
-	}
-}
-
-func (f *sysICMPFilter) willBlock(typ ICMPType) bool {
-	return f.Filt[typ>>5]&(1<<(uint32(typ)&31)) == 0
-}

Godeps/_workspace/src/code.google.com/p/go.net/ipv6/icmp_linux.go

@@ -1,31 +0,0 @@
-// 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.
-
-package ipv6
-
-type sysICMPFilter struct {
-	Data [8]uint32
-}
-
-func (f *sysICMPFilter) set(typ ICMPType, block bool) {
-	if block {
-		f.Data[typ>>5] |= 1 << (uint32(typ) & 31)
-	} else {
-		f.Data[typ>>5] &^= 1 << (uint32(typ) & 31)
-	}
-}
-
-func (f *sysICMPFilter) setAll(block bool) {
-	for i := range f.Data {
-		if block {
-			f.Data[i] = 1<<32 - 1
-		} else {
-			f.Data[i] = 0
-		}
-	}
-}
-
-func (f *sysICMPFilter) willBlock(typ ICMPType) bool {
-	return f.Data[typ>>5]&(1<<(uint32(typ)&31)) != 0
-}

Godeps/_workspace/src/code.google.com/p/go.net/ipv6/icmp_stub.go

@@ -1,24 +0,0 @@
-// 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.
-
-// +build dragonfly plan9 solaris
-
-package ipv6
-
-type sysICMPFilter struct {
-	// TODO(mikio): Implement this
-}
-
-func (f *sysICMPFilter) set(typ ICMPType, block bool) {
-	// TODO(mikio): Implement this
-}
-
-func (f *sysICMPFilter) setAll(block bool) {
-	// TODO(mikio): Implement this
-}
-
-func (f *sysICMPFilter) willBlock(typ ICMPType) bool {
-	// TODO(mikio): Implement this
-	return false
-}

Godeps/_workspace/src/code.google.com/p/go.net/ipv6/icmp_test.go

@@ -1,102 +0,0 @@
-// 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.
-
-package ipv6_test
-
-import (
-	"code.google.com/p/go.net/ipv6"
-	"net"
-	"os"
-	"reflect"
-	"runtime"
-	"sync"
-	"testing"
-)
-
-var icmpStringTests = []struct {
-	in  ipv6.ICMPType
-	out string
-}{
-	{ipv6.ICMPTypeDestinationUnreachable, "destination unreachable"},
-
-	{256, "<nil>"},
-}
-
-func TestICMPString(t *testing.T) {
-	for _, tt := range icmpStringTests {
-		s := tt.in.String()
-		if s != tt.out {
-			t.Errorf("got %s; expected %s", s, tt.out)
-		}
-	}
-}
-
-func TestICMPFilter(t *testing.T) {
-	switch runtime.GOOS {
-	case "dragonfly", "plan9", "solaris", "windows":
-		t.Skipf("not supported on %q", runtime.GOOS)
-	}
-
-	var f ipv6.ICMPFilter
-	for _, toggle := range []bool{false, true} {
-		f.SetAll(toggle)
-		var wg sync.WaitGroup
-		for _, typ := range []ipv6.ICMPType{
-			ipv6.ICMPTypeDestinationUnreachable,
-			ipv6.ICMPTypeEchoReply,
-			ipv6.ICMPTypeNeighborSolicitation,
-			ipv6.ICMPTypeDuplicateAddressConfirmation,
-		} {
-			wg.Add(1)
-			go func(typ ipv6.ICMPType) {
-				defer wg.Done()
-				f.Set(typ, false)
-				if f.WillBlock(typ) {
-					t.Errorf("ipv6.ICMPFilter.Set(%v, false) failed", typ)
-				}
-				f.Set(typ, true)
-				if !f.WillBlock(typ) {
-					t.Errorf("ipv6.ICMPFilter.Set(%v, true) failed", typ)
-				}
-			}(typ)
-		}
-		wg.Wait()
-	}
-}
-
-func TestSetICMPFilter(t *testing.T) {
-	switch runtime.GOOS {
-	case "dragonfly", "plan9", "solaris", "windows":
-		t.Skipf("not supported on %q", runtime.GOOS)
-	}
-	if !supportsIPv6 {
-		t.Skip("ipv6 is not supported")
-	}
-	if os.Getuid() != 0 {
-		t.Skip("must be root")
-	}
-
-	c, err := net.ListenPacket("ip6:ipv6-icmp", "::1")
-	if err != nil {
-		t.Fatalf("net.ListenPacket failed: %v", err)
-	}
-	defer c.Close()
-
-	p := ipv6.NewPacketConn(c)
-
-	var f ipv6.ICMPFilter
-	f.SetAll(true)
-	f.Set(ipv6.ICMPTypeEchoRequest, false)
-	f.Set(ipv6.ICMPTypeEchoReply, false)
-	if err := p.SetICMPFilter(&f); err != nil {
-		t.Fatalf("ipv6.PacketConn.SetICMPFilter failed: %v", err)
-	}
-	kf, err := p.ICMPFilter()
-	if err != nil {
-		t.Fatalf("ipv6.PacketConn.ICMPFilter failed: %v", err)
-	}
-	if !reflect.DeepEqual(kf, &f) {
-		t.Fatalf("got unexpected filter %#v; expected %#v", kf, f)
-	}
-}

Godeps/_workspace/src/code.google.com/p/go.net/ipv6/icmp_windows.go

@@ -1,22 +0,0 @@
-// 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.
-
-package ipv6
-
-type sysICMPFilter struct {
-	// TODO(mikio): Implement this
-}
-
-func (f *sysICMPFilter) set(typ ICMPType, block bool) {
-	// TODO(mikio): Implement this
-}
-
-func (f *sysICMPFilter) setAll(block bool) {
-	// TODO(mikio): Implement this
-}
-
-func (f *sysICMPFilter) willBlock(typ ICMPType) bool {
-	// TODO(mikio): Implement this
-	return false
-}

Godeps/_workspace/src/code.google.com/p/go.net/ipv6/mockicmp_test.go

@@ -1,130 +0,0 @@
-// 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.
-
-package ipv6_test
-
-import (
-	"code.google.com/p/go.net/ipv6"
-	"errors"
-	"net"
-)
-
-const (
-	ipv6PseudoHeaderLen  = 2*net.IPv6len + 8
-	ianaProtocolIPv6ICMP = 58
-)
-
-func ipv6PseudoHeader(src, dst net.IP, nextHeader int) []byte {
-	b := make([]byte, ipv6PseudoHeaderLen)
-	copy(b[:net.IPv6len], src)
-	copy(b[net.IPv6len:], dst)
-	b[len(b)-1] = byte(nextHeader)
-	return b
-}
-
-// icmpMessage represents an ICMP message.
-type icmpMessage struct {
-	Type     ipv6.ICMPType   // type
-	Code     int             // code
-	Checksum int             // checksum
-	Body     icmpMessageBody // body
-}
-
-// icmpMessageBody represents an ICMP message body.
-type icmpMessageBody interface {
-	Len() int
-	Marshal() ([]byte, error)
-}
-
-// Marshal returns the binary enconding of the ICMP echo request or
-// reply message m.
-func (m *icmpMessage) Marshal(psh []byte) ([]byte, error) {
-	b := []byte{byte(m.Type), byte(m.Code), 0, 0}
-	if psh != nil {
-		b = append(psh, b...)
-	}
-	if m.Body != nil && m.Body.Len() != 0 {
-		mb, err := m.Body.Marshal()
-		if err != nil {
-			return nil, err
-		}
-		b = append(b, mb...)
-	}
-	if psh == nil {
-		return b, nil
-	}
-	off, l := 2*net.IPv6len, len(b)-len(psh)
-	b[off], b[off+1], b[off+2], b[off+3] = byte(l>>24), byte(l>>16), byte(l>>8), byte(l)
-	csumcv := len(b) - 1 // checksum coverage
-	s := uint32(0)
-	for i := 0; i < csumcv; i += 2 {
-		s += uint32(b[i+1])<<8 | uint32(b[i])
-	}
-	if csumcv&1 == 0 {
-		s += uint32(b[csumcv])
-	}
-	s = s>>16 + s&0xffff
-	s = s + s>>16
-	// Place checksum back in header; using ^= avoids the
-	// assumption the checksum bytes are zero.
-	b[len(psh)+2] ^= byte(^s)
-	b[len(psh)+3] ^= byte(^s >> 8)
-	return b[len(psh):], nil
-}
-
-// parseICMPMessage parses b as an ICMP message.
-func parseICMPMessage(b []byte) (*icmpMessage, error) {
-	msglen := len(b)
-	if msglen < 4 {
-		return nil, errors.New("message too short")
-	}
-	m := &icmpMessage{Type: ipv6.ICMPType(b[0]), Code: int(b[1]), Checksum: int(b[2])<<8 | int(b[3])}
-	if msglen > 4 {
-		var err error
-		switch m.Type {
-		case ipv6.ICMPTypeEchoRequest, ipv6.ICMPTypeEchoReply:
-			m.Body, err = parseICMPEcho(b[4:])
-			if err != nil {
-				return nil, err
-			}
-		}
-	}
-	return m, nil
-}
-
-// imcpEcho represenets an ICMP echo request or reply message body.
-type icmpEcho struct {
-	ID   int    // identifier
-	Seq  int    // sequence number
-	Data []byte // data
-}
-
-func (p *icmpEcho) Len() int {
-	if p == nil {
-		return 0
-	}
-	return 4 + len(p.Data)
-}
-
-// Marshal returns the binary enconding of the ICMP echo request or
-// reply message body p.
-func (p *icmpEcho) Marshal() ([]byte, error) {
-	b := make([]byte, 4+len(p.Data))
-	b[0], b[1] = byte(p.ID>>8), byte(p.ID)
-	b[2], b[3] = byte(p.Seq>>8), byte(p.Seq)
-	copy(b[4:], p.Data)
-	return b, nil
-}
-
-// parseICMPEcho parses b as an ICMP echo request or reply message
-// body.
-func parseICMPEcho(b []byte) (*icmpEcho, error) {
-	bodylen := len(b)
-	p := &icmpEcho{ID: int(b[0])<<8 | int(b[1]), Seq: int(b[2])<<8 | int(b[3])}
-	if bodylen > 4 {
-		p.Data = make([]byte, bodylen-4)
-		copy(p.Data, b[4:])
-	}
-	return p, nil
-}

Godeps/_workspace/src/code.google.com/p/go.net/ipv6/mocktransponder_test.go

@@ -1,88 +0,0 @@
-// 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.
-
-package ipv6_test
-
-import (
-	"net"
-	"testing"
-)
-
-func isLinkLocalUnicast(ip net.IP) bool {
-	return ip.To4() == nil && ip.To16() != nil && ip.IsLinkLocalUnicast()
-}
-
-func loopbackInterface() *net.Interface {
-	ift, err := net.Interfaces()
-	if err != nil {
-		return nil
-	}
-	for _, ifi := range ift {
-		if ifi.Flags&net.FlagLoopback == 0 || ifi.Flags&net.FlagUp == 0 {
-			continue
-		}
-		ifat, err := ifi.Addrs()
-		if err != nil {
-			continue
-		}
-		for _, ifa := range ifat {
-			switch ifa := ifa.(type) {
-			case *net.IPAddr:
-				if isLinkLocalUnicast(ifa.IP) {
-					return &ifi
-				}
-			case *net.IPNet:
-				if isLinkLocalUnicast(ifa.IP) {
-					return &ifi
-				}
-			}
-		}
-	}
-	return nil
-}
-
-func isMulticastAvailable(ifi *net.Interface) (net.IP, bool) {
-	if ifi == nil || ifi.Flags&net.FlagUp == 0 || ifi.Flags&net.FlagMulticast == 0 {
-		return nil, false
-	}
-	ifat, err := ifi.Addrs()
-	if err != nil {
-		return nil, false
-	}
-	for _, ifa := range ifat {
-		switch ifa := ifa.(type) {
-		case *net.IPAddr:
-			if isLinkLocalUnicast(ifa.IP) {
-				return ifa.IP, true
-			}
-		case *net.IPNet:
-			if isLinkLocalUnicast(ifa.IP) {
-				return ifa.IP, true
-			}
-		}
-	}
-	return nil, false
-}
-
-func connector(t *testing.T, network, addr string, done chan<- bool) {
-	defer func() { done <- true }()
-
-	c, err := net.Dial(network, addr)
-	if err != nil {
-		t.Errorf("net.Dial failed: %v", err)
-		return
-	}
-	c.Close()
-}
-
-func acceptor(t *testing.T, ln net.Listener, done chan<- bool) {
-	defer func() { done <- true }()
-
-	c, err := ln.Accept()
-	if err != nil {
-		t.Errorf("net.Listener.Accept failed: %v", err)
-		return
-	}
-	c.Close()
-}

Godeps/_workspace/src/code.google.com/p/go.net/ipv6/multicast_test.go

@@ -1,205 +0,0 @@
-// 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.
-
-package ipv6_test
-
-import (
-	"bytes"
-	"code.google.com/p/go.net/ipv6"
-	"net"
-	"os"
-	"runtime"
-	"testing"
-	"time"
-)
-
-func TestPacketConnReadWriteMulticastUDP(t *testing.T) {
-	switch runtime.GOOS {
-	case "freebsd": // due to a bug on loopback marking
-		// See http://www.freebsd.org/cgi/query-pr.cgi?pr=180065.
-		t.Skipf("not supported on %q", runtime.GOOS)
-	case "dragonfly", "plan9", "solaris", "windows":
-		t.Skipf("not supported on %q", runtime.GOOS)
-	}
-	if !supportsIPv6 {
-		t.Skip("ipv6 is not supported")
-	}
-	ifi := loopbackInterface()
-	if ifi == nil {
-		t.Skipf("not available on %q", runtime.GOOS)
-	}
-
-	c, err := net.ListenPacket("udp6", "[ff02::114]:0") // see RFC 4727
-	if err != nil {
-		t.Fatalf("net.ListenPacket failed: %v", err)
-	}
-	defer c.Close()
-
-	_, port, err := net.SplitHostPort(c.LocalAddr().String())
-	if err != nil {
-		t.Fatalf("net.SplitHostPort failed: %v", err)
-	}
-	dst, err := net.ResolveUDPAddr("udp6", "[ff02::114]:"+port) // see RFC 4727
-	if err != nil {
-		t.Fatalf("net.ResolveUDPAddr failed: %v", err)
-	}
-
-	p := ipv6.NewPacketConn(c)
-	defer p.Close()
-	if err := p.JoinGroup(ifi, dst); err != nil {
-		t.Fatalf("ipv6.PacketConn.JoinGroup on %v failed: %v", ifi, err)
-	}
-	if err := p.SetMulticastInterface(ifi); err != nil {
-		t.Fatalf("ipv6.PacketConn.SetMulticastInterface failed: %v", err)
-	}
-	if _, err := p.MulticastInterface(); err != nil {
-		t.Fatalf("ipv6.PacketConn.MulticastInterface failed: %v", err)
-	}
-	if err := p.SetMulticastLoopback(true); err != nil {
-		t.Fatalf("ipv6.PacketConn.SetMulticastLoopback failed: %v", err)
-	}
-	if _, err := p.MulticastLoopback(); err != nil {
-		t.Fatalf("ipv6.PacketConn.MulticastLoopback failed: %v", err)
-	}
-
-	cm := ipv6.ControlMessage{
-		TrafficClass: DiffServAF11 | CongestionExperienced,
-		Src:          net.IPv6loopback,
-		IfIndex:      ifi.Index,
-	}
-	cf := ipv6.FlagTrafficClass | ipv6.FlagHopLimit | ipv6.FlagSrc | ipv6.FlagDst | ipv6.FlagInterface | ipv6.FlagPathMTU
-	wb := []byte("HELLO-R-U-THERE")
-
-	for i, toggle := range []bool{true, false, true} {
-		if err := p.SetControlMessage(cf, toggle); err != nil {
-			t.Fatalf("ipv6.PacketConn.SetControlMessage failed: %v", err)
-		}
-		if err := p.SetDeadline(time.Now().Add(200 * time.Millisecond)); err != nil {
-			t.Fatalf("ipv6.PacketConn.SetDeadline failed: %v", err)
-		}
-		cm.HopLimit = i + 1
-		if n, err := p.WriteTo(wb, &cm, dst); err != nil {
-			t.Fatalf("ipv6.PacketConn.WriteTo failed: %v", err)
-		} else if n != len(wb) {
-			t.Fatalf("ipv6.PacketConn.WriteTo failed: short write: %v", n)
-		}
-		rb := make([]byte, 128)
-		if n, cm, _, err := p.ReadFrom(rb); err != nil {
-			t.Fatalf("ipv6.PacketConn.ReadFrom failed: %v", err)
-		} else if !bytes.Equal(rb[:n], wb) {
-			t.Fatalf("got %v; expected %v", rb[:n], wb)
-		} else {
-			t.Logf("rcvd cmsg: %v", cm)
-		}
-	}
-}
-
-func TestPacketConnReadWriteMulticastICMP(t *testing.T) {
-	switch runtime.GOOS {
-	case "dragonfly", "plan9", "solaris", "windows":
-		t.Skipf("not supported on %q", runtime.GOOS)
-	}
-	if !supportsIPv6 {
-		t.Skip("ipv6 is not supported")
-	}
-	if os.Getuid() != 0 {
-		t.Skip("must be root")
-	}
-	ifi := loopbackInterface()
-	if ifi == nil {
-		t.Skipf("not available on %q", runtime.GOOS)
-	}
-
-	c, err := net.ListenPacket("ip6:ipv6-icmp", "::")
-	if err != nil {
-		t.Fatalf("net.ListenPacket failed: %v", err)
-	}
-	defer c.Close()
-
-	dst, err := net.ResolveIPAddr("ip6", "ff02::114") // see RFC 4727
-	if err != nil {
-		t.Fatalf("net.ResolveIPAddr failed: %v", err)
-	}
-
-	pshicmp := ipv6PseudoHeader(c.LocalAddr().(*net.IPAddr).IP, dst.IP, ianaProtocolIPv6ICMP)
-	p := ipv6.NewPacketConn(c)
-	defer p.Close()
-	if err := p.JoinGroup(ifi, dst); err != nil {
-		t.Fatalf("ipv6.PacketConn.JoinGroup on %v failed: %v", ifi, err)
-	}
-	if err := p.SetMulticastInterface(ifi); err != nil {
-		t.Fatalf("ipv6.PacketConn.SetMulticastInterface failed: %v", err)
-	}
-	if _, err := p.MulticastInterface(); err != nil {
-		t.Fatalf("ipv6.PacketConn.MulticastInterface failed: %v", err)
-	}
-	if err := p.SetMulticastLoopback(true); err != nil {
-		t.Fatalf("ipv6.PacketConn.SetMulticastLoopback failed: %v", err)
-	}
-	if _, err := p.MulticastLoopback(); err != nil {
-		t.Fatalf("ipv6.PacketConn.MulticastLoopback failed: %v", err)
-	}
-
-	cm := ipv6.ControlMessage{
-		TrafficClass: DiffServAF11 | CongestionExperienced,
-		Src:          net.IPv6loopback,
-		IfIndex:      ifi.Index,
-	}
-	cf := ipv6.FlagTrafficClass | ipv6.FlagHopLimit | ipv6.FlagSrc | ipv6.FlagDst | ipv6.FlagInterface | ipv6.FlagPathMTU
-
-	var f ipv6.ICMPFilter
-	f.SetAll(true)
-	f.Set(ipv6.ICMPTypeEchoReply, false)
-	if err := p.SetICMPFilter(&f); err != nil {
-		t.Fatalf("ipv6.PacketConn.SetICMPFilter failed: %v", err)
-	}
-
-	var psh []byte
-	for i, toggle := range []bool{true, false, true} {
-		if toggle {
-			psh = nil
-			if err := p.SetChecksum(true, 2); err != nil {
-				t.Fatalf("ipv6.PacketConn.SetChecksum failed: %v", err)
-			}
-		} else {
-			psh = pshicmp
-			// Some platforms never allow to disable the
-			// kernel checksum processing.
-			p.SetChecksum(false, -1)
-		}
-		wb, err := (&icmpMessage{
-			Type: ipv6.ICMPTypeEchoRequest, Code: 0,
-			Body: &icmpEcho{
-				ID: os.Getpid() & 0xffff, Seq: i + 1,
-				Data: []byte("HELLO-R-U-THERE"),
-			},
-		}).Marshal(psh)
-		if err != nil {
-			t.Fatalf("icmpMessage.Marshal failed: %v", err)
-		}
-		if err := p.SetControlMessage(cf, toggle); err != nil {
-			t.Fatalf("ipv6.PacketConn.SetControlMessage failed: %v", err)
-		}
-		if err := p.SetDeadline(time.Now().Add(200 * time.Millisecond)); err != nil {
-			t.Fatalf("ipv6.PacketConn.SetDeadline failed: %v", err)
-		}
-		cm.HopLimit = i + 1
-		if n, err := p.WriteTo(wb, &cm, dst); err != nil {
-			t.Fatalf("ipv6.PacketConn.WriteTo failed: %v", err)
-		} else if n != len(wb) {
-			t.Fatalf("ipv6.PacketConn.WriteTo failed: short write: %v", n)
-		}
-		rb := make([]byte, 128)
-		if n, cm, _, err := p.ReadFrom(rb); err != nil {
-			t.Fatalf("ipv6.PacketConn.ReadFrom failed: %v", err)
-		} else {
-			t.Logf("rcvd cmsg: %v", cm)
-			if m, err := parseICMPMessage(rb[:n]); err != nil {
-				t.Fatalf("parseICMPMessage failed: %v", err)
-			} else if m.Type != ipv6.ICMPTypeEchoReply || m.Code != 0 {
-				t.Fatalf("got type=%v, code=%v; expected type=%v, code=%v", m.Type, m.Code, ipv6.ICMPTypeEchoReply, 0)
-			}
-		}
-	}
-}

Godeps/_workspace/src/code.google.com/p/go.net/ipv6/multicastlistener_test.go

@@ -1,243 +0,0 @@
-// 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.
-
-package ipv6_test
-
-import (
-	"code.google.com/p/go.net/ipv6"
-	"fmt"
-	"net"
-	"os"
-	"runtime"
-	"testing"
-)
-
-var udpMultipleGroupListenerTests = []net.Addr{
-	&net.UDPAddr{IP: net.ParseIP("ff02::114")}, // see RFC 4727
-	&net.UDPAddr{IP: net.ParseIP("ff02::1:114")},
-	&net.UDPAddr{IP: net.ParseIP("ff02::2:114")},
-}
-
-func TestUDPSinglePacketConnWithMultipleGroupListeners(t *testing.T) {
-	switch runtime.GOOS {
-	case "dragonfly", "plan9", "solaris", "windows":
-		t.Skipf("not supported on %q", runtime.GOOS)
-	}
-	if !supportsIPv6 {
-		t.Skip("ipv6 is not supported")
-	}
-
-	for _, gaddr := range udpMultipleGroupListenerTests {
-		c, err := net.ListenPacket("udp6", "[::]:0") // wildcard address with non-reusable port
-		if err != nil {
-			t.Fatalf("net.ListenPacket failed: %v", err)
-		}
-		defer c.Close()
-
-		p := ipv6.NewPacketConn(c)
-		var mift []*net.Interface
-
-		ift, err := net.Interfaces()
-		if err != nil {
-			t.Fatalf("net.Interfaces failed: %v", err)
-		}
-		for i, ifi := range ift {
-			if _, ok := isMulticastAvailable(&ifi); !ok {
-				continue
-			}
-			if err := p.JoinGroup(&ifi, gaddr); err != nil {
-				t.Fatalf("ipv6.PacketConn.JoinGroup %v on %v failed: %v", gaddr, ifi, err)
-			}
-			mift = append(mift, &ift[i])
-		}
-		for _, ifi := range mift {
-			if err := p.LeaveGroup(ifi, gaddr); err != nil {
-				t.Fatalf("ipv6.PacketConn.LeaveGroup %v on %v failed: %v", gaddr, ifi, err)
-			}
-		}
-	}
-}
-
-func TestUDPMultiplePacketConnWithMultipleGroupListeners(t *testing.T) {
-	switch runtime.GOOS {
-	case "dragonfly", "plan9", "solaris", "windows":
-		t.Skipf("not supported on %q", runtime.GOOS)
-	}
-	if !supportsIPv6 {
-		t.Skip("ipv6 is not supported")
-	}
-
-	for _, gaddr := range udpMultipleGroupListenerTests {
-		c1, err := net.ListenPacket("udp6", "[ff02::]:1024") // wildcard address with reusable port
-		if err != nil {
-			t.Fatalf("net.ListenPacket failed: %v", err)
-		}
-		defer c1.Close()
-
-		c2, err := net.ListenPacket("udp6", "[ff02::]:1024") // wildcard address with reusable port
-		if err != nil {
-			t.Fatalf("net.ListenPacket failed: %v", err)
-		}
-		defer c2.Close()
-
-		var ps [2]*ipv6.PacketConn
-		ps[0] = ipv6.NewPacketConn(c1)
-		ps[1] = ipv6.NewPacketConn(c2)
-		var mift []*net.Interface
-
-		ift, err := net.Interfaces()
-		if err != nil {
-			t.Fatalf("net.Interfaces failed: %v", err)
-		}
-		for i, ifi := range ift {
-			if _, ok := isMulticastAvailable(&ifi); !ok {
-				continue
-			}
-			for _, p := range ps {
-				if err := p.JoinGroup(&ifi, gaddr); err != nil {
-					t.Fatalf("ipv6.PacketConn.JoinGroup %v on %v failed: %v", gaddr, ifi, err)
-				}
-			}
-			mift = append(mift, &ift[i])
-		}
-		for _, ifi := range mift {
-			for _, p := range ps {
-				if err := p.LeaveGroup(ifi, gaddr); err != nil {
-					t.Fatalf("ipv6.PacketConn.LeaveGroup %v on %v failed: %v", gaddr, ifi, err)
-				}
-			}
-		}
-	}
-}
-
-func TestUDPPerInterfaceSinglePacketConnWithSingleGroupListener(t *testing.T) {
-	switch runtime.GOOS {
-	case "dragonfly", "plan9", "solaris", "windows":
-		t.Skipf("not supported on %q", runtime.GOOS)
-	}
-	if !supportsIPv6 {
-		t.Skip("ipv6 is not supported")
-	}
-
-	gaddr := net.IPAddr{IP: net.ParseIP("ff02::114")} // see RFC 4727
-	type ml struct {
-		c   *ipv6.PacketConn
-		ifi *net.Interface
-	}
-	var mlt []*ml
-
-	ift, err := net.Interfaces()
-	if err != nil {
-		t.Fatalf("net.Interfaces failed: %v", err)
-	}
-	for i, ifi := range ift {
-		ip, ok := isMulticastAvailable(&ifi)
-		if !ok {
-			continue
-		}
-		c, err := net.ListenPacket("udp6", fmt.Sprintf("[%s%%%s]:1024", ip.String(), ifi.Name)) // unicast address with non-reusable port
-		if err != nil {
-			t.Fatalf("net.ListenPacket with %v failed: %v", ip, err)
-		}
-		defer c.Close()
-		p := ipv6.NewPacketConn(c)
-		if err := p.JoinGroup(&ifi, &gaddr); err != nil {
-			t.Fatalf("ipv6.PacketConn.JoinGroup on %v failed: %v", ifi, err)
-		}
-		mlt = append(mlt, &ml{p, &ift[i]})
-	}
-	for _, m := range mlt {
-		if err := m.c.LeaveGroup(m.ifi, &gaddr); err != nil {
-			t.Fatalf("ipv6.PacketConn.LeaveGroup on %v failed: %v", m.ifi, err)
-		}
-	}
-}
-
-func TestIPSinglePacketConnWithSingleGroupListener(t *testing.T) {
-	switch runtime.GOOS {
-	case "dragonfly", "plan9", "solaris", "windows":
-		t.Skipf("not supported on %q", runtime.GOOS)
-	}
-	if !supportsIPv6 {
-		t.Skip("ipv6 is not supported")
-	}
-	if os.Getuid() != 0 {
-		t.Skip("must be root")
-	}
-
-	c, err := net.ListenPacket("ip6:ipv6-icmp", "::") // wildcard address
-	if err != nil {
-		t.Fatalf("net.ListenPacket failed: %v", err)
-	}
-	defer c.Close()
-
-	p := ipv6.NewPacketConn(c)
-	gaddr := net.IPAddr{IP: net.ParseIP("ff02::114")} // see RFC 4727
-	var mift []*net.Interface
-
-	ift, err := net.Interfaces()
-	if err != nil {
-		t.Fatalf("net.Interfaces failed: %v", err)
-	}
-	for i, ifi := range ift {
-		if _, ok := isMulticastAvailable(&ifi); !ok {
-			continue
-		}
-		if err := p.JoinGroup(&ifi, &gaddr); err != nil {
-			t.Fatalf("ipv6.PacketConn.JoinGroup on %v failed: %v", ifi, err)
-		}
-		mift = append(mift, &ift[i])
-	}
-	for _, ifi := range mift {
-		if err := p.LeaveGroup(ifi, &gaddr); err != nil {
-			t.Fatalf("ipv6.PacketConn.LeaveGroup on %v failed: %v", ifi, err)
-		}
-	}
-}
-
-func TestIPPerInterfaceSinglePacketConnWithSingleGroupListener(t *testing.T) {
-	switch runtime.GOOS {
-	case "darwin", "dragonfly", "plan9", "solaris", "windows":
-		t.Skipf("not supported on %q", runtime.GOOS)
-	}
-	if !supportsIPv6 {
-		t.Skip("ipv6 is not supported")
-	}
-	if os.Getuid() != 0 {
-		t.Skip("must be root")
-	}
-
-	gaddr := net.IPAddr{IP: net.ParseIP("ff02::114")} // see RFC 4727
-	type ml struct {
-		c   *ipv6.PacketConn
-		ifi *net.Interface
-	}
-	var mlt []*ml
-
-	ift, err := net.Interfaces()
-	if err != nil {
-		t.Fatalf("net.Interfaces failed: %v", err)
-	}
-	for i, ifi := range ift {
-		ip, ok := isMulticastAvailable(&ifi)
-		if !ok {
-			continue
-		}
-		c, err := net.ListenPacket("ip6:ipv6-icmp", fmt.Sprintf("%s%%%s", ip.String(), ifi.Name)) // unicast address
-		if err != nil {
-			t.Fatalf("net.ListenPacket failed: %v", err)
-		}
-		defer c.Close()
-		p := ipv6.NewPacketConn(c)
-		if err := p.JoinGroup(&ifi, &gaddr); err != nil {
-			t.Fatalf("ipv6.PacketConn.JoinGroup on %v failed: %v", ifi, err)
-		}
-		mlt = append(mlt, &ml{p, &ift[i]})
-	}
-	for _, m := range mlt {
-		if err := m.c.LeaveGroup(m.ifi, &gaddr); err != nil {
-			t.Fatalf("ipv6.PacketConn.LeaveGroup on %v failed: %v", m.ifi, err)
-		}
-	}
-}

Godeps/_workspace/src/code.google.com/p/go.net/ipv6/multicastsockopt_test.go

@@ -1,76 +0,0 @@
-// 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.
-
-package ipv6_test
-
-import (
-	"code.google.com/p/go.net/ipv6"
-	"net"
-	"os"
-	"runtime"
-	"testing"
-)
-
-var packetConnMulticastSocketOptionTests = []struct {
-	net, proto, addr string
-	gaddr            net.Addr
-}{
-	{"udp6", "", "[ff02::]:0", &net.UDPAddr{IP: net.ParseIP("ff02::114")}}, // see RFC 4727
-	{"ip6", ":ipv6-icmp", "::", &net.IPAddr{IP: net.ParseIP("ff02::114")}}, // see RFC 4727
-}
-
-func TestPacketConnMulticastSocketOptions(t *testing.T) {
-	switch runtime.GOOS {
-	case "dragonfly", "plan9", "solaris", "windows":
-		t.Skipf("not supported on %q", runtime.GOOS)
-	}
-	if !supportsIPv6 {
-		t.Skip("ipv6 is not supported")
-	}
-	ifi := loopbackInterface()
-	if ifi == nil {
-		t.Skipf("not available on %q", runtime.GOOS)
-	}
-
-	for _, tt := range packetConnMulticastSocketOptionTests {
-		if tt.net == "ip6" && os.Getuid() != 0 {
-			t.Skip("must be root")
-		}
-		c, err := net.ListenPacket(tt.net+tt.proto, tt.addr)
-		if err != nil {
-			t.Fatalf("net.ListenPacket failed: %v", err)
-		}
-		defer c.Close()
-
-		p := ipv6.NewPacketConn(c)
-
-		hoplim := 255
-		if err := p.SetMulticastHopLimit(hoplim); err != nil {
-			t.Fatalf("ipv6.PacketConn.SetMulticastHopLimit failed: %v", err)
-		}
-		if v, err := p.MulticastHopLimit(); err != nil {
-			t.Fatalf("ipv6.PacketConn.MulticastHopLimit failed: %v", err)
-		} else if v != hoplim {
-			t.Fatalf("got unexpected multicast hop limit %v; expected %v", v, hoplim)
-		}
-
-		for _, toggle := range []bool{true, false} {
-			if err := p.SetMulticastLoopback(toggle); err != nil {
-				t.Fatalf("ipv6.PacketConn.SetMulticastLoopback failed: %v", err)
-			}
-			if v, err := p.MulticastLoopback(); err != nil {
-				t.Fatalf("ipv6.PacketConn.MulticastLoopback failed: %v", err)
-			} else if v != toggle {
-				t.Fatalf("got unexpected multicast loopback %v; expected %v", v, toggle)
-			}
-		}
-
-		if err := p.JoinGroup(ifi, tt.gaddr); err != nil {
-			t.Fatalf("ipv6.PacketConn.JoinGroup(%v, %v) failed: %v", ifi, tt.gaddr, err)
-		}
-		if err := p.LeaveGroup(ifi, tt.gaddr); err != nil {
-			t.Fatalf("ipv6.PacketConn.LeaveGroup(%v, %v) failed: %v", ifi, tt.gaddr, err)
-		}
-	}
-}

Godeps/_workspace/src/code.google.com/p/go.net/ipv6/payload.go

@@ -1,15 +0,0 @@
-// 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.
-
-package ipv6
-
-import "net"
-
-// A payloadHandler represents the IPv6 datagram payload handler.
-type payloadHandler struct {
-	net.PacketConn
-	rawOpt
-}
-
-func (c *payloadHandler) ok() bool { return c != nil && c.PacketConn != nil }

Godeps/_workspace/src/code.google.com/p/go.net/ipv6/payload_cmsg.go

@@ -1,70 +0,0 @@
-// 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.
-
-// +build !plan9,!windows
-
-package ipv6
-
-import (
-	"net"
-	"syscall"
-)
-
-// ReadFrom reads a payload of the received IPv6 datagram, from the
-// endpoint c, copying the payload into b.  It returns the number of
-// bytes copied into b, the control message cm and the source address
-// src of the received datagram.
-func (c *payloadHandler) ReadFrom(b []byte) (n int, cm *ControlMessage, src net.Addr, err error) {
-	if !c.ok() {
-		return 0, nil, nil, syscall.EINVAL
-	}
-	oob := newControlMessage(&c.rawOpt)
-	var oobn int
-	switch c := c.PacketConn.(type) {
-	case *net.UDPConn:
-		if n, oobn, _, src, err = c.ReadMsgUDP(b, oob); err != nil {
-			return 0, nil, nil, err
-		}
-	case *net.IPConn:
-		if n, oobn, _, src, err = c.ReadMsgIP(b, oob); err != nil {
-			return 0, nil, nil, err
-		}
-	default:
-		return 0, nil, nil, errInvalidConnType
-	}
-	if cm, err = parseControlMessage(oob[:oobn]); err != nil {
-		return 0, nil, nil, err
-	}
-	if cm != nil {
-		cm.Src = netAddrToIP16(src)
-	}
-	return
-}
-
-// WriteTo writes a payload of the IPv6 datagram, to the destination
-// address dst through the endpoint c, copying the payload from b.  It
-// returns the number of bytes written.  The control message cm allows
-// the IPv6 header fields and the datagram path to be specified.  The
-// cm may be nil if control of the outgoing datagram is not required.
-func (c *payloadHandler) WriteTo(b []byte, cm *ControlMessage, dst net.Addr) (n int, err error) {
-	if !c.ok() {
-		return 0, syscall.EINVAL
-	}
-	oob := marshalControlMessage(cm)
-	if dst == nil {
-		return 0, errMissingAddress
-	}
-	switch c := c.PacketConn.(type) {
-	case *net.UDPConn:
-		n, _, err = c.WriteMsgUDP(b, oob, dst.(*net.UDPAddr))
-	case *net.IPConn:
-		n, _, err = c.WriteMsgIP(b, oob, dst.(*net.IPAddr))
-	default:
-		return 0, errInvalidConnType
-	}
-	if err != nil {
-		return 0, err
-	}
-	return
-}

Godeps/_workspace/src/code.google.com/p/go.net/ipv6/payload_noncmsg.go

@@ -1,41 +0,0 @@
-// 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.
-
-// +build plan9 windows
-
-package ipv6
-
-import (
-	"net"
-	"syscall"
-)
-
-// ReadFrom reads a payload of the received IPv6 datagram, from the
-// endpoint c, copying the payload into b.  It returns the number of
-// bytes copied into b, the control message cm and the source address
-// src of the received datagram.
-func (c *payloadHandler) ReadFrom(b []byte) (n int, cm *ControlMessage, src net.Addr, err error) {
-	if !c.ok() {
-		return 0, nil, nil, syscall.EINVAL
-	}
-	if n, src, err = c.PacketConn.ReadFrom(b); err != nil {
-		return 0, nil, nil, err
-	}
-	return
-}
-
-// WriteTo writes a payload of the IPv6 datagram, to the destination
-// address dst through the endpoint c, copying the payload from b.  It
-// returns the number of bytes written.  The control message cm allows
-// the IPv6 header fields and the datagram path to be specified.  The
-// cm may be nil if control of the outgoing datagram is not required.
-func (c *payloadHandler) WriteTo(b []byte, cm *ControlMessage, dst net.Addr) (n int, err error) {
-	if !c.ok() {
-		return 0, syscall.EINVAL
-	}
-	if dst == nil {
-		return 0, errMissingAddress
-	}
-	return c.PacketConn.WriteTo(b, dst)
-}

Godeps/_workspace/src/code.google.com/p/go.net/ipv6/readwrite_test.go

@@ -1,168 +0,0 @@
-// 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.
-
-package ipv6_test
-
-import (
-	"bytes"
-	"code.google.com/p/go.net/ipv6"
-	"net"
-	"runtime"
-	"sync"
-	"testing"
-)
-
-func benchmarkUDPListener() (net.PacketConn, net.Addr, error) {
-	c, err := net.ListenPacket("udp6", "[::1]:0")
-	if err != nil {
-		return nil, nil, err
-	}
-	dst, err := net.ResolveUDPAddr("udp6", c.LocalAddr().String())
-	if err != nil {
-		c.Close()
-		return nil, nil, err
-	}
-	return c, dst, nil
-}
-
-func BenchmarkReadWriteNetUDP(b *testing.B) {
-	c, dst, err := benchmarkUDPListener()
-	if err != nil {
-		b.Fatalf("benchmarkUDPListener failed: %v", err)
-	}
-	defer c.Close()
-
-	wb, rb := []byte("HELLO-R-U-THERE"), make([]byte, 128)
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
-		benchmarkReadWriteNetUDP(b, c, wb, rb, dst)
-	}
-}
-
-func benchmarkReadWriteNetUDP(b *testing.B, c net.PacketConn, wb, rb []byte, dst net.Addr) {
-	if _, err := c.WriteTo(wb, dst); err != nil {
-		b.Fatalf("net.PacketConn.WriteTo failed: %v", err)
-	}
-	if _, _, err := c.ReadFrom(rb); err != nil {
-		b.Fatalf("net.PacketConn.ReadFrom failed: %v", err)
-	}
-}
-
-func BenchmarkReadWriteIPv6UDP(b *testing.B) {
-	c, dst, err := benchmarkUDPListener()
-	if err != nil {
-		b.Fatalf("benchmarkUDPListener failed: %v", err)
-	}
-	defer c.Close()
-
-	p := ipv6.NewPacketConn(c)
-	cf := ipv6.FlagTrafficClass | ipv6.FlagHopLimit | ipv6.FlagInterface | ipv6.FlagPathMTU
-	if err := p.SetControlMessage(cf, true); err != nil {
-		b.Fatalf("ipv6.PacketConn.SetControlMessage failed: %v", err)
-	}
-	ifi := loopbackInterface()
-
-	wb, rb := []byte("HELLO-R-U-THERE"), make([]byte, 128)
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
-		benchmarkReadWriteIPv6UDP(b, p, wb, rb, dst, ifi)
-	}
-}
-
-func benchmarkReadWriteIPv6UDP(b *testing.B, p *ipv6.PacketConn, wb, rb []byte, dst net.Addr, ifi *net.Interface) {
-	cm := ipv6.ControlMessage{
-		TrafficClass: DiffServAF11 | CongestionExperienced,
-		HopLimit:     1,
-	}
-	if ifi != nil {
-		cm.IfIndex = ifi.Index
-	}
-	if n, err := p.WriteTo(wb, &cm, dst); err != nil {
-		b.Fatalf("ipv6.PacketConn.WriteTo failed: %v", err)
-	} else if n != len(wb) {
-		b.Fatalf("ipv6.PacketConn.WriteTo failed: short write: %v", n)
-	}
-	if _, _, _, err := p.ReadFrom(rb); err != nil {
-		b.Fatalf("ipv6.PacketConn.ReadFrom failed: %v", err)
-	}
-}
-
-func TestPacketConnConcurrentReadWriteUnicastUDP(t *testing.T) {
-	switch runtime.GOOS {
-	case "dragonfly", "plan9", "solaris", "windows":
-		t.Skipf("not supported on %q", runtime.GOOS)
-	}
-	if !supportsIPv6 {
-		t.Skip("ipv6 is not supported")
-	}
-
-	c, err := net.ListenPacket("udp6", "[::1]:0")
-	if err != nil {
-		t.Fatalf("net.ListenPacket failed: %v", err)
-	}
-	defer c.Close()
-	p := ipv6.NewPacketConn(c)
-	defer p.Close()
-
-	dst, err := net.ResolveUDPAddr("udp6", c.LocalAddr().String())
-	if err != nil {
-		t.Fatalf("net.ResolveUDPAddr failed: %v", err)
-	}
-
-	ifi := loopbackInterface()
-	cf := ipv6.FlagTrafficClass | ipv6.FlagHopLimit | ipv6.FlagSrc | ipv6.FlagDst | ipv6.FlagInterface | ipv6.FlagPathMTU
-	wb := []byte("HELLO-R-U-THERE")
-
-	var wg sync.WaitGroup
-	reader := func() {
-		defer wg.Done()
-		rb := make([]byte, 128)
-		if n, cm, _, err := p.ReadFrom(rb); err != nil {
-			t.Errorf("ipv6.PacketConn.ReadFrom failed: %v", err)
-			return
-		} else if !bytes.Equal(rb[:n], wb) {
-			t.Errorf("got %v; expected %v", rb[:n], wb)
-			return
-		} else {
-			t.Logf("rcvd cmsg: %v", cm)
-		}
-	}
-	writer := func(toggle bool) {
-		defer wg.Done()
-		cm := ipv6.ControlMessage{
-			TrafficClass: DiffServAF11 | CongestionExperienced,
-			Src:          net.IPv6loopback,
-			Dst:          net.IPv6loopback,
-		}
-		if ifi != nil {
-			cm.IfIndex = ifi.Index
-		}
-		if err := p.SetControlMessage(cf, toggle); err != nil {
-			t.Errorf("ipv6.PacketConn.SetControlMessage failed: %v", err)
-			return
-		}
-		if n, err := p.WriteTo(wb, &cm, dst); err != nil {
-			t.Errorf("ipv6.PacketConn.WriteTo failed: %v", err)
-			return
-		} else if n != len(wb) {
-			t.Errorf("ipv6.PacketConn.WriteTo failed: short write: %v", n)
-			return
-		}
-	}
-
-	const N = 10
-	wg.Add(N)
-	for i := 0; i < N; i++ {
-		go reader()
-	}
-	wg.Add(2 * N)
-	for i := 0; i < 2*N; i++ {
-		go writer(i%2 != 0)
-	}
-	wg.Add(N)
-	for i := 0; i < N; i++ {
-		go reader()
-	}
-	wg.Wait()
-}

Godeps/_workspace/src/code.google.com/p/go.net/ipv6/sockopt_rfc2292_unix.go

@@ -1,73 +0,0 @@
-// 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.
-
-// +build darwin
-
-package ipv6
-
-import (
-	"os"
-	"unsafe"
-)
-
-func ipv6ReceiveTrafficClass(fd int) (bool, error) {
-	return false, errOpNoSupport
-}
-
-func setIPv6ReceiveTrafficClass(fd int, v bool) error {
-	return errOpNoSupport
-}
-
-func ipv6ReceiveHopLimit(fd int) (bool, error) {
-	var v int32
-	l := sysSockoptLen(4)
-	if err := getsockopt(fd, ianaProtocolIPv6, sysSockopt2292HopLimit, uintptr(unsafe.Pointer(&v)), &l); err != nil {
-		return false, os.NewSyscallError("getsockopt", err)
-	}
-	return v == 1, nil
-}
-
-func setIPv6ReceiveHopLimit(fd int, v bool) error {
-	vv := int32(boolint(v))
-	return os.NewSyscallError("setsockopt", setsockopt(fd, ianaProtocolIPv6, sysSockopt2292HopLimit, uintptr(unsafe.Pointer(&vv)), 4))
-}
-
-func ipv6ReceivePacketInfo(fd int) (bool, error) {
-	var v int32
-	l := sysSockoptLen(4)
-	if err := getsockopt(fd, ianaProtocolIPv6, sysSockopt2292PacketInfo, uintptr(unsafe.Pointer(&v)), &l); err != nil {
-		return false, os.NewSyscallError("getsockopt", err)
-	}
-	return v == 1, nil
-}
-
-func setIPv6ReceivePacketInfo(fd int, v bool) error {
-	vv := int32(boolint(v))
-	return os.NewSyscallError("setsockopt", setsockopt(fd, ianaProtocolIPv6, sysSockopt2292PacketInfo, uintptr(unsafe.Pointer(&vv)), 4))
-}
-
-func ipv6PathMTU(fd int) (int, error) {
-	return 0, errOpNoSupport
-}
-
-func ipv6ReceivePathMTU(fd int) (bool, error) {
-	return false, errOpNoSupport
-}
-
-func setIPv6ReceivePathMTU(fd int, v bool) error {
-	return errOpNoSupport
-}
-
-func ipv6ICMPFilter(fd int) (*ICMPFilter, error) {
-	var v ICMPFilter
-	l := sysSockoptLen(sysSizeofICMPFilter)
-	if err := getsockopt(fd, ianaProtocolIPv6ICMP, sysSockoptICMPFilter, uintptr(unsafe.Pointer(&v.sysICMPFilter)), &l); err != nil {
-		return nil, os.NewSyscallError("getsockopt", err)
-	}
-	return &v, nil
-}
-
-func setIPv6ICMPFilter(fd int, f *ICMPFilter) error {
-	return os.NewSyscallError("setsockopt", setsockopt(fd, ianaProtocolIPv6ICMP, sysSockoptICMPFilter, uintptr(unsafe.Pointer(&f.sysICMPFilter)), sysSizeofICMPFilter))
-}

Godeps/_workspace/src/code.google.com/p/go.net/ipv6/sockopt_rfc3493_bsd.go

@@ -1,20 +0,0 @@
-// 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.
-
-// +build darwin freebsd netbsd openbsd
-
-package ipv6
-
-import (
-	"os"
-	"unsafe"
-)
-
-func setIPv6Checksum(fd int, on bool, offset int) error {
-	if !on {
-		offset = -1
-	}
-	v := int32(offset)
-	return os.NewSyscallError("setsockopt", setsockopt(fd, ianaProtocolIPv6, sysSockoptChecksum, uintptr(unsafe.Pointer(&v)), 4))
-}

Godeps/_workspace/src/code.google.com/p/go.net/ipv6/sockopt_rfc3493_linux.go

@@ -1,18 +0,0 @@
-// 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.
-
-package ipv6
-
-import (
-	"os"
-	"unsafe"
-)
-
-func setIPv6Checksum(fd int, on bool, offset int) error {
-	if !on {
-		offset = -1
-	}
-	v := int32(offset)
-	return os.NewSyscallError("setsockopt", setsockopt(fd, ianaProtocolReserved, sysSockoptChecksum, uintptr(unsafe.Pointer(&v)), 4))
-}

Godeps/_workspace/src/code.google.com/p/go.net/ipv6/sockopt_rfc3493_unix.go

@@ -1,124 +0,0 @@
-// 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.
-
-// +build darwin freebsd linux netbsd openbsd
-
-package ipv6
-
-import (
-	"net"
-	"os"
-	"unsafe"
-)
-
-func ipv6TrafficClass(fd int) (int, error) {
-	var v int32
-	l := sysSockoptLen(4)
-	if err := getsockopt(fd, ianaProtocolIPv6, sysSockoptTrafficClass, uintptr(unsafe.Pointer(&v)), &l); err != nil {
-		return 0, os.NewSyscallError("getsockopt", err)
-	}
-	return int(v), nil
-}
-
-func setIPv6TrafficClass(fd, v int) error {
-	vv := int32(v)
-	return os.NewSyscallError("setsockopt", setsockopt(fd, ianaProtocolIPv6, sysSockoptTrafficClass, uintptr(unsafe.Pointer(&vv)), 4))
-}
-
-func ipv6HopLimit(fd int) (int, error) {
-	var v int32
-	l := sysSockoptLen(4)
-	if err := getsockopt(fd, ianaProtocolIPv6, sysSockoptUnicastHopLimit, uintptr(unsafe.Pointer(&v)), &l); err != nil {
-		return 0, os.NewSyscallError("getsockopt", err)
-	}
-	return int(v), nil
-}
-
-func setIPv6HopLimit(fd, v int) error {
-	vv := int32(v)
-	return os.NewSyscallError("setsockopt", setsockopt(fd, ianaProtocolIPv6, sysSockoptUnicastHopLimit, uintptr(unsafe.Pointer(&vv)), 4))
-}
-
-func ipv6Checksum(fd int) (bool, int, error) {
-	var v int32
-	l := sysSockoptLen(4)
-	if err := getsockopt(fd, ianaProtocolIPv6, sysSockoptChecksum, uintptr(unsafe.Pointer(&v)), &l); err != nil {
-		return false, 0, os.NewSyscallError("getsockopt", err)
-	}
-	on := true
-	if v == -1 {
-		on = false
-	}
-	return on, int(v), nil
-}
-
-func ipv6MulticastHopLimit(fd int) (int, error) {
-	var v int32
-	l := sysSockoptLen(4)
-	if err := getsockopt(fd, ianaProtocolIPv6, sysSockoptMulticastHopLimit, uintptr(unsafe.Pointer(&v)), &l); err != nil {
-		return 0, os.NewSyscallError("getsockopt", err)
-	}
-	return int(v), nil
-}
-
-func setIPv6MulticastHopLimit(fd, v int) error {
-	vv := int32(v)
-	return os.NewSyscallError("setsockopt", setsockopt(fd, ianaProtocolIPv6, sysSockoptMulticastHopLimit, uintptr(unsafe.Pointer(&vv)), 4))
-}
-
-func ipv6MulticastInterface(fd int) (*net.Interface, error) {
-	var v int32
-	l := sysSockoptLen(4)
-	if err := getsockopt(fd, ianaProtocolIPv6, sysSockoptMulticastInterface, uintptr(unsafe.Pointer(&v)), &l); err != nil {
-		return nil, os.NewSyscallError("getsockopt", err)
-	}
-	if v == 0 {
-		return nil, nil
-	}
-	ifi, err := net.InterfaceByIndex(int(v))
-	if err != nil {
-		return nil, err
-	}
-	return ifi, nil
-}
-
-func setIPv6MulticastInterface(fd int, ifi *net.Interface) error {
-	var v int32
-	if ifi != nil {
-		v = int32(ifi.Index)
-	}
-	return os.NewSyscallError("setsockopt", setsockopt(fd, ianaProtocolIPv6, sysSockoptMulticastInterface, uintptr(unsafe.Pointer(&v)), 4))
-}
-
-func ipv6MulticastLoopback(fd int) (bool, error) {
-	var v int32
-	l := sysSockoptLen(4)
-	if err := getsockopt(fd, ianaProtocolIPv6, sysSockoptMulticastLoopback, uintptr(unsafe.Pointer(&v)), &l); err != nil {
-		return false, os.NewSyscallError("getsockopt", err)
-	}
-	return v == 1, nil
-}
-
-func setIPv6MulticastLoopback(fd int, v bool) error {
-	vv := int32(boolint(v))
-	return os.NewSyscallError("setsockopt", setsockopt(fd, ianaProtocolIPv6, sysSockoptMulticastLoopback, uintptr(unsafe.Pointer(&vv)), 4))
-}
-
-func joinIPv6Group(fd int, ifi *net.Interface, grp net.IP) error {
-	mreq := sysMulticastReq{}
-	copy(mreq.IP[:], grp)
-	if ifi != nil {
-		mreq.IfIndex = uint32(ifi.Index)
-	}
-	return os.NewSyscallError("setsockopt", setsockopt(fd, ianaProtocolIPv6, sysSockoptJoinGroup, uintptr(unsafe.Pointer(&mreq)), sysSizeofMulticastReq))
-}
-
-func leaveIPv6Group(fd int, ifi *net.Interface, grp net.IP) error {
-	mreq := sysMulticastReq{}
-	copy(mreq.IP[:], grp)
-	if ifi != nil {
-		mreq.IfIndex = uint32(ifi.Index)
-	}
-	return os.NewSyscallError("setsockopt", setsockopt(fd, ianaProtocolIPv6, sysSockoptLeaveGroup, uintptr(unsafe.Pointer(&mreq)), sysSizeofMulticastReq))
-}

Godeps/_workspace/src/code.google.com/p/go.net/ipv6/sockopt_rfc3493_windows.go

@@ -1,116 +0,0 @@
-// 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.
-
-package ipv6
-
-import (
-	"net"
-	"os"
-	"syscall"
-	"unsafe"
-)
-
-func ipv6TrafficClass(fd syscall.Handle) (int, error) {
-	// TODO(mikio): Implement this
-	return 0, syscall.EWINDOWS
-}
-
-func setIPv6TrafficClass(fd syscall.Handle, v int) error {
-	// TODO(mikio): Implement this
-	return syscall.EWINDOWS
-}
-
-func ipv6HopLimit(fd syscall.Handle) (int, error) {
-	var v int32
-	l := int32(4)
-	if err := syscall.Getsockopt(fd, ianaProtocolIPv6, sysSockoptUnicastHopLimit, (*byte)(unsafe.Pointer(&v)), &l); err != nil {
-		return 0, os.NewSyscallError("getsockopt", err)
-	}
-	return int(v), nil
-}
-
-func setIPv6HopLimit(fd syscall.Handle, v int) error {
-	vv := int32(v)
-	return os.NewSyscallError("setsockopt", syscall.Setsockopt(fd, ianaProtocolIPv6, sysSockoptUnicastHopLimit, (*byte)(unsafe.Pointer(&vv)), 4))
-}
-
-func ipv6Checksum(fd syscall.Handle) (bool, int, error) {
-	// TODO(mikio): Implement this
-	return false, 0, syscall.EWINDOWS
-}
-
-func ipv6MulticastHopLimit(fd syscall.Handle) (int, error) {
-	var v int32
-	l := int32(4)
-	if err := syscall.Getsockopt(fd, ianaProtocolIPv6, sysSockoptMulticastHopLimit, (*byte)(unsafe.Pointer(&v)), &l); err != nil {
-		return 0, os.NewSyscallError("getsockopt", err)
-	}
-	return int(v), nil
-}
-
-func setIPv6MulticastHopLimit(fd syscall.Handle, v int) error {
-	vv := int32(v)
-	return os.NewSyscallError("setsockopt", syscall.Setsockopt(fd, ianaProtocolIPv6, sysSockoptMulticastHopLimit, (*byte)(unsafe.Pointer(&vv)), 4))
-}
-
-func ipv6MulticastInterface(fd syscall.Handle) (*net.Interface, error) {
-	var v int32
-	l := int32(4)
-	if err := syscall.Getsockopt(fd, ianaProtocolIPv6, sysSockoptMulticastInterface, (*byte)(unsafe.Pointer(&v)), &l); err != nil {
-		return nil, os.NewSyscallError("getsockopt", err)
-	}
-	if v == 0 {
-		return nil, nil
-	}
-	ifi, err := net.InterfaceByIndex(int(v))
-	if err != nil {
-		return nil, err
-	}
-	return ifi, nil
-}
-
-func setIPv6MulticastInterface(fd syscall.Handle, ifi *net.Interface) error {
-	var v int32
-	if ifi != nil {
-		v = int32(ifi.Index)
-	}
-	return os.NewSyscallError("setsockopt", syscall.Setsockopt(fd, ianaProtocolIPv6, sysSockoptMulticastInterface, (*byte)(unsafe.Pointer(&v)), 4))
-}
-
-func ipv6MulticastLoopback(fd syscall.Handle) (bool, error) {
-	var v int32
-	l := int32(4)
-	if err := syscall.Getsockopt(fd, ianaProtocolIPv6, sysSockoptMulticastLoopback, (*byte)(unsafe.Pointer(&v)), &l); err != nil {
-		return false, os.NewSyscallError("getsockopt", err)
-	}
-	return v == 1, nil
-}
-
-func setIPv6MulticastLoopback(fd syscall.Handle, v bool) error {
-	vv := int32(boolint(v))
-	return os.NewSyscallError("setsockopt", syscall.Setsockopt(fd, ianaProtocolIPv6, sysSockoptMulticastLoopback, (*byte)(unsafe.Pointer(&vv)), 4))
-}
-
-func joinIPv6Group(fd syscall.Handle, ifi *net.Interface, grp net.IP) error {
-	mreq := sysMulticastReq{}
-	copy(mreq.IP[:], grp)
-	if ifi != nil {
-		mreq.IfIndex = uint32(ifi.Index)
-	}
-	return os.NewSyscallError("setsockopt", syscall.Setsockopt(fd, ianaProtocolIPv6, sysSockoptJoinGroup, (*byte)(unsafe.Pointer(&mreq)), int32(sysSizeofMulticastReq)))
-}
-
-func leaveIPv6Group(fd syscall.Handle, ifi *net.Interface, grp net.IP) error {
-	mreq := sysMulticastReq{}
-	copy(mreq.IP[:], grp)
-	if ifi != nil {
-		mreq.IfIndex = uint32(ifi.Index)
-	}
-	return os.NewSyscallError("setsockopt", syscall.Setsockopt(fd, ianaProtocolIPv6, sysSockoptLeaveGroup, (*byte)(unsafe.Pointer(&mreq)), int32(sysSizeofMulticastReq)))
-}
-
-func setIPv6Checksum(fd syscall.Handle, on bool, offset int) error {
-	// TODO(mikio): Implement this
-	return syscall.EWINDOWS
-}

Godeps/_workspace/src/code.google.com/p/go.net/ipv6/sockopt_rfc3542_stub.go

@@ -1,12 +0,0 @@
-// 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.
-
-// +build dragonfly plan9 solaris
-
-package ipv6
-
-func ipv6PathMTU(fd int) (int, error) {
-	// TODO(mikio): Implement this
-	return 0, errOpNoSupport
-}

Godeps/_workspace/src/code.google.com/p/go.net/ipv6/sockopt_rfc3542_unix.go

@@ -1,90 +0,0 @@
-// 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.
-
-// +build freebsd linux netbsd openbsd
-
-package ipv6
-
-import (
-	"os"
-	"unsafe"
-)
-
-func ipv6ReceiveTrafficClass(fd int) (bool, error) {
-	var v int32
-	l := sysSockoptLen(4)
-	if err := getsockopt(fd, ianaProtocolIPv6, sysSockoptReceiveTrafficClass, uintptr(unsafe.Pointer(&v)), &l); err != nil {
-		return false, os.NewSyscallError("getsockopt", err)
-	}
-	return v == 1, nil
-}
-
-func setIPv6ReceiveTrafficClass(fd int, v bool) error {
-	vv := int32(boolint(v))
-	return os.NewSyscallError("setsockopt", setsockopt(fd, ianaProtocolIPv6, sysSockoptReceiveTrafficClass, uintptr(unsafe.Pointer(&vv)), 4))
-}
-
-func ipv6ReceiveHopLimit(fd int) (bool, error) {
-	var v int32
-	l := sysSockoptLen(4)
-	if err := getsockopt(fd, ianaProtocolIPv6, sysSockoptReceiveHopLimit, uintptr(unsafe.Pointer(&v)), &l); err != nil {
-		return false, os.NewSyscallError("getsockopt", err)
-	}
-	return v == 1, nil
-}
-
-func setIPv6ReceiveHopLimit(fd int, v bool) error {
-	vv := int32(boolint(v))
-	return os.NewSyscallError("setsockopt", setsockopt(fd, ianaProtocolIPv6, sysSockoptReceiveHopLimit, uintptr(unsafe.Pointer(&vv)), 4))
-}
-
-func ipv6ReceivePacketInfo(fd int) (bool, error) {
-	var v int32
-	l := sysSockoptLen(4)
-	if err := getsockopt(fd, ianaProtocolIPv6, sysSockoptReceivePacketInfo, uintptr(unsafe.Pointer(&v)), &l); err != nil {
-		return false, os.NewSyscallError("getsockopt", err)
-	}
-	return v == 1, nil
-}
-
-func setIPv6ReceivePacketInfo(fd int, v bool) error {
-	vv := int32(boolint(v))
-	return os.NewSyscallError("setsockopt", setsockopt(fd, ianaProtocolIPv6, sysSockoptReceivePacketInfo, uintptr(unsafe.Pointer(&vv)), 4))
-}
-
-func ipv6PathMTU(fd int) (int, error) {
-	var v sysMTUInfo
-	l := sysSockoptLen(sysSizeofMTUInfo)
-	if err := getsockopt(fd, ianaProtocolIPv6, sysSockoptPathMTU, uintptr(unsafe.Pointer(&v)), &l); err != nil {
-		return 0, os.NewSyscallError("getsockopt", err)
-	}
-	return int(v.MTU), nil
-}
-
-func ipv6ReceivePathMTU(fd int) (bool, error) {
-	var v int32
-	l := sysSockoptLen(4)
-	if err := getsockopt(fd, ianaProtocolIPv6, sysSockoptReceivePathMTU, uintptr(unsafe.Pointer(&v)), &l); err != nil {
-		return false, os.NewSyscallError("getsockopt", err)
-	}
-	return v == 1, nil
-}
-
-func setIPv6ReceivePathMTU(fd int, v bool) error {
-	vv := int32(boolint(v))
-	return os.NewSyscallError("setsockopt", setsockopt(fd, ianaProtocolIPv6, sysSockoptReceivePathMTU, uintptr(unsafe.Pointer(&vv)), 4))
-}
-
-func ipv6ICMPFilter(fd int) (*ICMPFilter, error) {
-	var v ICMPFilter
-	l := sysSockoptLen(sysSizeofICMPFilter)
-	if err := getsockopt(fd, ianaProtocolIPv6ICMP, sysSockoptICMPFilter, uintptr(unsafe.Pointer(&v.sysICMPFilter)), &l); err != nil {
-		return nil, os.NewSyscallError("getsockopt", err)
-	}
-	return &v, nil
-}
-
-func setIPv6ICMPFilter(fd int, f *ICMPFilter) error {
-	return os.NewSyscallError("setsockopt", setsockopt(fd, ianaProtocolIPv6ICMP, sysSockoptICMPFilter, uintptr(unsafe.Pointer(&f.sysICMPFilter)), sysSizeofICMPFilter))
-}

Godeps/_workspace/src/code.google.com/p/go.net/ipv6/sockopt_rfc3542_windows.go

@@ -1,62 +0,0 @@
-// 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.
-
-package ipv6
-
-import "syscall"
-
-func ipv6ReceiveTrafficClass(fd syscall.Handle) (bool, error) {
-	// TODO(mikio): Implement this
-	return false, syscall.EWINDOWS
-}
-
-func setIPv6ReceiveTrafficClass(fd syscall.Handle, v bool) error {
-	// TODO(mikio): Implement this
-	return syscall.EWINDOWS
-}
-
-func ipv6ReceiveHopLimit(fd syscall.Handle) (bool, error) {
-	// TODO(mikio): Implement this
-	return false, syscall.EWINDOWS
-}
-
-func setIPv6ReceiveHopLimit(fd syscall.Handle, v bool) error {
-	// TODO(mikio): Implement this
-	return syscall.EWINDOWS
-}
-
-func ipv6ReceivePacketInfo(fd syscall.Handle) (bool, error) {
-	// TODO(mikio): Implement this
-	return false, syscall.EWINDOWS
-}
-
-func setIPv6ReceivePacketInfo(fd syscall.Handle, v bool) error {
-	// TODO(mikio): Implement this
-	return syscall.EWINDOWS
-}
-
-func ipv6PathMTU(fd syscall.Handle) (int, error) {
-	// TODO(mikio): Implement this
-	return 0, syscall.EWINDOWS
-}
-
-func ipv6ReceivePathMTU(fd syscall.Handle) (bool, error) {
-	// TODO(mikio): Implement this
-	return false, syscall.EWINDOWS
-}
-
-func setIPv6ReceivePathMTU(fd syscall.Handle, v bool) error {
-	// TODO(mikio): Implement this
-	return syscall.EWINDOWS
-}
-
-func ipv6ICMPFilter(fd syscall.Handle) (*ICMPFilter, error) {
-	// TODO(mikio): Implement this
-	return nil, syscall.EWINDOWS
-}
-
-func setIPv6ICMPFilter(fd syscall.Handle, f *ICMPFilter) error {
-	// TODO(mikio): Implement this
-	return syscall.EWINDOWS
-}

Godeps/_workspace/src/code.google.com/p/go.net/ipv6/sockopt_test.go

@@ -1,136 +0,0 @@
-// 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.
-
-package ipv6_test
-
-import (
-	"code.google.com/p/go.net/ipv6"
-	"net"
-	"os"
-	"runtime"
-	"testing"
-)
-
-var supportsIPv6 bool
-
-func init() {
-	if ln, err := net.Listen("tcp6", "[::1]:0"); err == nil {
-		ln.Close()
-		supportsIPv6 = true
-	}
-}
-
-var condFatalf = func() func(*testing.T, string, ...interface{}) {
-	// A few APIs are not implemented yet on some platforms.
-	switch runtime.GOOS {
-	case "darwin", "dragonfly", "plan9", "solaris", "windows":
-		return (*testing.T).Logf
-	}
-	return (*testing.T).Fatalf
-}()
-
-func TestConnInitiatorPathMTU(t *testing.T) {
-	switch runtime.GOOS {
-	case "dragonfly", "plan9", "solaris", "windows":
-		t.Skipf("not supported on %q", runtime.GOOS)
-	}
-	if !supportsIPv6 {
-		t.Skip("ipv6 is not supported")
-	}
-
-	ln, err := net.Listen("tcp6", "[::1]:0")
-	if err != nil {
-		t.Fatalf("net.Listen failed: %v", err)
-	}
-	defer ln.Close()
-
-	done := make(chan bool)
-	go acceptor(t, ln, done)
-
-	c, err := net.Dial("tcp6", ln.Addr().String())
-	if err != nil {
-		t.Fatalf("net.Dial failed: %v", err)
-	}
-	defer c.Close()
-
-	if pmtu, err := ipv6.NewConn(c).PathMTU(); err != nil {
-		condFatalf(t, "ipv6.Conn.PathMTU failed: %v", err)
-	} else {
-		t.Logf("path mtu for %v: %v", c.RemoteAddr(), pmtu)
-	}
-
-	<-done
-}
-
-func TestConnResponderPathMTU(t *testing.T) {
-	switch runtime.GOOS {
-	case "dragonfly", "plan9", "solaris", "windows":
-		t.Skipf("not supported on %q", runtime.GOOS)
-	}
-	if !supportsIPv6 {
-		t.Skip("ipv6 is not supported")
-	}
-
-	ln, err := net.Listen("tcp6", "[::1]:0")
-	if err != nil {
-		t.Fatalf("net.Listen failed: %v", err)
-	}
-	defer ln.Close()
-
-	done := make(chan bool)
-	go connector(t, "tcp6", ln.Addr().String(), done)
-
-	c, err := ln.Accept()
-	if err != nil {
-		t.Fatalf("net.Accept failed: %v", err)
-	}
-	defer c.Close()
-
-	if pmtu, err := ipv6.NewConn(c).PathMTU(); err != nil {
-		condFatalf(t, "ipv6.Conn.PathMTU failed: %v", err)
-	} else {
-		t.Logf("path mtu for %v: %v", c.RemoteAddr(), pmtu)
-	}
-
-	<-done
-}
-
-func TestPacketConnChecksum(t *testing.T) {
-	switch runtime.GOOS {
-	case "dragonfly", "plan9", "solaris", "windows":
-		t.Skipf("not supported on %q", runtime.GOOS)
-	}
-	if !supportsIPv6 {
-		t.Skip("ipv6 is not supported")
-	}
-	if os.Getuid() != 0 {
-		t.Skip("must be root")
-	}
-
-	c, err := net.ListenPacket("ip6:89", "::") // OSPF for IPv6
-	if err != nil {
-		t.Fatalf("net.ListenPacket failed: %v", err)
-	}
-	defer c.Close()
-
-	p := ipv6.NewPacketConn(c)
-	offset := 12 // see RFC 5340
-
-	for _, toggle := range []bool{false, true} {
-		if err := p.SetChecksum(toggle, offset); err != nil {
-			if toggle {
-				t.Fatalf("ipv6.PacketConn.SetChecksum(%v, %v) failed: %v", toggle, offset, err)
-			} else {
-				// Some platforms never allow to disable the kernel
-				// checksum processing.
-				t.Logf("ipv6.PacketConn.SetChecksum(%v, %v) failed: %v", toggle, offset, err)
-			}
-		}
-		if on, offset, err := p.Checksum(); err != nil {
-			t.Fatalf("ipv6.PacketConn.Checksum failed: %v", err)
-		} else {
-			t.Logf("kernel checksum processing enabled=%v, offset=%v", on, offset)
-		}
-	}
-}

Godeps/_workspace/src/code.google.com/p/go.net/ipv6/sys.go

@@ -1,23 +0,0 @@
-// 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.
-
-package ipv6
-
-type sysSockoptLen uint32
-
-const (
-	sysSizeofPacketInfo   = 0x14
-	sysSizeofMulticastReq = 0x14
-	sysSizeofICMPFilter   = 0x20
-)
-
-type sysPacketInfo struct {
-	IP      [16]byte
-	IfIndex uint32
-}
-
-type sysMulticastReq struct {
-	IP      [16]byte
-	IfIndex uint32
-}

Godeps/_workspace/src/code.google.com/p/go.net/ipv6/sys_bsd.go

@@ -1,48 +0,0 @@
-// 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.
-
-// +build freebsd netbsd openbsd
-
-package ipv6
-
-import (
-	"net"
-	"syscall"
-)
-
-// RFC 3493 options
-const (
-	// See /usr/include/netinet6/in6.h.
-	sysSockoptUnicastHopLimit    = 0x4
-	sysSockoptMulticastHopLimit  = 0xa
-	sysSockoptMulticastInterface = 0x9
-	sysSockoptMulticastLoopback  = 0xb
-	sysSockoptJoinGroup          = 0xc
-	sysSockoptLeaveGroup         = 0xd
-)
-
-// RFC 3542 options
-const (
-	// See /usr/include/netinet6/in6.h.
-	sysSockoptReceiveTrafficClass = 0x39
-	sysSockoptTrafficClass        = 0x3d
-	sysSockoptReceiveHopLimit     = 0x25
-	sysSockoptHopLimit            = 0x2f
-	sysSockoptReceivePacketInfo   = 0x24
-	sysSockoptPacketInfo          = 0x2e
-	sysSockoptReceivePathMTU      = 0x2b
-	sysSockoptPathMTU             = 0x2c
-	sysSockoptNextHop             = 0x30
-	sysSockoptChecksum            = 0x1a
-
-	// See /usr/include/netinet6/in6.h.
-	sysSockoptICMPFilter = 0x12
-)
-
-func setSockaddr(sa *syscall.RawSockaddrInet6, ip net.IP, ifindex int) {
-	sa.Len = syscall.SizeofSockaddrInet6
-	sa.Family = syscall.AF_INET6
-	copy(sa.Addr[:], ip)
-	sa.Scope_id = uint32(ifindex)
-}

Godeps/_workspace/src/code.google.com/p/go.net/ipv6/sys_darwin.go

@@ -1,54 +0,0 @@
-// 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.
-
-package ipv6
-
-import (
-	"net"
-	"syscall"
-)
-
-// RFC 2292 options
-const (
-	// See /usr/include/netinet6/in6.h.
-	sysSockopt2292HopLimit   = 0x14
-	sysSockopt2292PacketInfo = 0x13
-	sysSockopt2292NextHop    = 0x15
-)
-
-// RFC 3493 options
-const (
-	// See /usr/include/netinet6/in6.h.
-	sysSockoptUnicastHopLimit    = 0x4
-	sysSockoptMulticastHopLimit  = 0xa
-	sysSockoptMulticastInterface = 0x9
-	sysSockoptMulticastLoopback  = 0xb
-	sysSockoptJoinGroup          = 0xc
-	sysSockoptLeaveGroup         = 0xd
-)
-
-// RFC 3542 options
-const (
-	// See /usr/include/netinet6/in6.h.
-	sysSockoptReceiveTrafficClass = 0x23
-	sysSockoptTrafficClass        = 0x24
-	sysSockoptReceiveHopLimit     = 0x25
-	sysSockoptHopLimit            = 0x2f
-	sysSockoptReceivePacketInfo   = 0x3d
-	sysSockoptPacketInfo          = 0x2e
-	sysSockoptReceivePathMTU      = 0x2b
-	sysSockoptPathMTU             = 0x2c
-	sysSockoptNextHop             = 0x30
-	sysSockoptChecksum            = 0x1a
-
-	// See /usr/include/netinet6/in6.h.
-	sysSockoptICMPFilter = 0x12
-)
-
-func setSockaddr(sa *syscall.RawSockaddrInet6, ip net.IP, ifindex int) {
-	sa.Len = syscall.SizeofSockaddrInet6
-	sa.Family = syscall.AF_INET6
-	copy(sa.Addr[:], ip)
-	sa.Scope_id = uint32(ifindex)
-}

Godeps/_workspace/src/code.google.com/p/go.net/ipv6/sys_linux.go

@@ -1,45 +0,0 @@
-// 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.
-
-package ipv6
-
-import (
-	"net"
-	"syscall"
-)
-
-// RFC 3493 options
-const (
-	// See /usr/include/linux/in6.h.
-	sysSockoptUnicastHopLimit    = 0x10
-	sysSockoptMulticastHopLimit  = 0x12
-	sysSockoptMulticastInterface = 0x11
-	sysSockoptMulticastLoopback  = 0x13
-	sysSockoptJoinGroup          = 0x14
-	sysSockoptLeaveGroup         = 0x15
-)
-
-// RFC 3542 options
-const (
-	// See /usr/include/linux/ipv6.h,in6.h.
-	sysSockoptReceiveTrafficClass = 0x42
-	sysSockoptTrafficClass        = 0x43
-	sysSockoptReceiveHopLimit     = 0x33
-	sysSockoptHopLimit            = 0x34
-	sysSockoptReceivePacketInfo   = 0x31
-	sysSockoptPacketInfo          = 0x32
-	sysSockoptReceivePathMTU      = 0x3c
-	sysSockoptPathMTU             = 0x3d
-	sysSockoptNextHop             = 0x9
-	sysSockoptChecksum            = 0x7
-
-	// See /usr/include/linux/icmpv6.h.
-	sysSockoptICMPFilter = 0x1
-)
-
-func setSockaddr(sa *syscall.RawSockaddrInet6, ip net.IP, ifindex int) {
-	sa.Family = syscall.AF_INET6
-	copy(sa.Addr[:], ip)
-	sa.Scope_id = uint32(ifindex)
-}

Godeps/_workspace/src/code.google.com/p/go.net/ipv6/sys_unix.go

@@ -1,16 +0,0 @@
-// 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.
-
-// +build darwin freebsd linux netbsd openbsd
-
-package ipv6
-
-import "syscall"
-
-const sysSizeofMTUInfo = 0x20
-
-type sysMTUInfo struct {
-	Addr syscall.RawSockaddrInet6
-	MTU  uint32
-}

Godeps/_workspace/src/code.google.com/p/go.net/ipv6/sys_windows.go

@@ -1,33 +0,0 @@
-// 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.
-
-package ipv6
-
-import (
-	"net"
-	"syscall"
-)
-
-// RFC 3493 options
-const (
-	// See ws2tcpip.h.
-	sysSockoptUnicastHopLimit    = 0x4
-	sysSockoptMulticastHopLimit  = 0xa
-	sysSockoptMulticastInterface = 0x9
-	sysSockoptMulticastLoopback  = 0xb
-	sysSockoptJoinGroup          = 0xc
-	sysSockoptLeaveGroup         = 0xd
-)
-
-// RFC 3542 options
-const (
-	// See ws2tcpip.h.
-	sysSockoptPacketInfo = 0x13
-)
-
-func setSockaddr(sa *syscall.RawSockaddrInet6, ip net.IP, ifindex int) {
-	sa.Family = syscall.AF_INET6
-	copy(sa.Addr[:], ip)
-	sa.Scope_id = uint32(ifindex)
-}

Godeps/_workspace/src/code.google.com/p/go.net/ipv6/syscall_linux_386.go

@@ -1,42 +0,0 @@
-// 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.
-
-// This code is a duplicate of syscall/syscall_linux_386.go with small
-// modifications.
-
-package ipv6
-
-import (
-	"syscall"
-	"unsafe"
-)
-
-// On x86 Linux, all the socket calls go through an extra indirection,
-// I think because the 5-register system call interface can't handle
-// the 6-argument calls like sendto and recvfrom. Instead the
-// arguments to the underlying system call are the number below and a
-// pointer to an array of uintptr. We hide the pointer in the
-// socketcall assembly to avoid allocation on every system call.
-
-const (
-	// See /usr/include/linux/net.h.
-	_SETSOCKOPT = 14
-	_GETSOCKOPT = 15
-)
-
-var socketcall func(call int, a0, a1, a2, a3, a4, a5 uintptr) (int, syscall.Errno)
-
-func getsockopt(fd int, level int, name int, v uintptr, l *sysSockoptLen) error {
-	if _, errno := socketcall(_GETSOCKOPT, uintptr(fd), uintptr(level), uintptr(name), uintptr(v), uintptr(unsafe.Pointer(l)), 0); errno != 0 {
-		return error(errno)
-	}
-	return nil
-}
-
-func setsockopt(fd int, level int, name int, v uintptr, l uintptr) error {
-	if _, errno := socketcall(_SETSOCKOPT, uintptr(fd), uintptr(level), uintptr(name), v, l, 0); errno != 0 {
-		return error(errno)
-	}
-	return nil
-}

Godeps/_workspace/src/code.google.com/p/go.net/ipv6/syscall_linux_386.s

@@ -1,56 +0,0 @@
-// 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.
-
-// This code is a duplicate of syscall/syscall_linux_386.s with small
-// modifications.
-
-#define SYS_SOCKETCALL	102	// from zsysnum_linux_386.go
-
-// func socketcallnosplit7(call int, a0, a1, a2, a3, a4, a5 uintptr) (n int, errno int)
-// Kernel interface gets call sub-number and pointer to a0 for Go 1.1.
-TEXT ·socketcallnosplit7(SB),7,$0
-	CALL	runtime·entersyscall(SB)
-	MOVL	$SYS_SOCKETCALL, AX	// syscall entry
-	MOVL	4(SP), BX		// socket call number
-	LEAL	8(SP), CX		// pointer to call arguments
-	MOVL	$0, DX
-	MOVL	$0, SI
-	MOVL	$0, DI
-	CALL	*runtime·_vdso(SB)
-	CMPL	AX, $0xfffff001
-	JLS	ok1
-	MOVL	$-1, 32(SP)		// n
-	NEGL	AX
-	MOVL	AX, 36(SP)		// errno
-	CALL	runtime·exitsyscall(SB)
-	RET
-ok1:
-	MOVL	AX, 32(SP)		// n
-	MOVL	$0, 36(SP)		// errno
-	CALL	runtime·exitsyscall(SB)
-	RET
-
-// func socketcallnosplit4(call int, a0, a1, a2, a3, a4, a5 uintptr) (n int, errno int)
-// Kernel interface gets call sub-number and pointer to a0 for Go 1.2.
-TEXT ·socketcallnosplit4(SB),4,$0-40
-	CALL	runtime·entersyscall(SB)
-	MOVL	$SYS_SOCKETCALL, AX	// syscall entry
-	MOVL	4(SP), BX		// socket call number
-	LEAL	8(SP), CX		// pointer to call arguments
-	MOVL	$0, DX
-	MOVL	$0, SI
-	MOVL	$0, DI
-	CALL	*runtime·_vdso(SB)
-	CMPL	AX, $0xfffff001
-	JLS	ok2
-	MOVL	$-1, 32(SP)		// n
-	NEGL	AX
-	MOVL	AX, 36(SP)		// errno
-	CALL	runtime·exitsyscall(SB)
-	RET
-ok2:
-	MOVL	AX, 32(SP)		// n
-	MOVL	$0, 36(SP)		// errno
-	CALL	runtime·exitsyscall(SB)
-	RET

Godeps/_workspace/src/code.google.com/p/go.net/ipv6/syscall_nosplit4_linux_386.go

@@ -1,15 +0,0 @@
-// 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.
-
-// +build go1.2
-
-package ipv6
-
-import "syscall"
-
-func socketcallnosplit4(call int, a0, a1, a2, a3, a4, a5 uintptr) (int, syscall.Errno)
-
-func init() {
-	socketcall = socketcallnosplit4
-}

Godeps/_workspace/src/code.google.com/p/go.net/ipv6/syscall_nosplit7_linux_386.go

@@ -1,15 +0,0 @@
-// 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.
-
-// +build go1.1,!go1.2
-
-package ipv6
-
-import "syscall"
-
-func socketcallnosplit7(call int, a0, a1, a2, a3, a4, a5 uintptr) (int, syscall.Errno)
-
-func init() {
-	socketcall = socketcallnosplit7
-}

Godeps/_workspace/src/code.google.com/p/go.net/ipv6/syscall_unix.go

@@ -1,26 +0,0 @@
-// 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.
-
-// +build darwin freebsd linux,amd64 linux,arm netbsd openbsd
-
-package ipv6
-
-import (
-	"syscall"
-	"unsafe"
-)
-
-func getsockopt(fd int, level, name int, v uintptr, l *sysSockoptLen) error {
-	if _, _, errno := syscall.Syscall6(syscall.SYS_GETSOCKOPT, uintptr(fd), uintptr(level), uintptr(name), uintptr(v), uintptr(unsafe.Pointer(l)), 0); errno != 0 {
-		return error(errno)
-	}
-	return nil
-}
-
-func setsockopt(fd int, level int, name int, v uintptr, l uintptr) error {
-	if _, _, errno := syscall.Syscall6(syscall.SYS_SETSOCKOPT, uintptr(fd), uintptr(level), uintptr(name), uintptr(v), uintptr(l), 0); errno != 0 {
-		return error(errno)
-	}
-	return nil
-}

Godeps/_workspace/src/code.google.com/p/go.net/ipv6/unicast_test.go

@@ -1,172 +0,0 @@
-// 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.
-
-package ipv6_test
-
-import (
-	"bytes"
-	"code.google.com/p/go.net/ipv6"
-	"net"
-	"os"
-	"runtime"
-	"testing"
-	"time"
-)
-
-func TestPacketConnReadWriteUnicastUDP(t *testing.T) {
-	switch runtime.GOOS {
-	case "dragonfly", "plan9", "solaris", "windows":
-		t.Skipf("not supported on %q", runtime.GOOS)
-	}
-	if !supportsIPv6 {
-		t.Skip("ipv6 is not supported")
-	}
-
-	c, err := net.ListenPacket("udp6", "[::1]:0")
-	if err != nil {
-		t.Fatalf("net.ListenPacket failed: %v", err)
-	}
-	defer c.Close()
-	p := ipv6.NewPacketConn(c)
-	defer p.Close()
-
-	dst, err := net.ResolveUDPAddr("udp6", c.LocalAddr().String())
-	if err != nil {
-		t.Fatalf("net.ResolveUDPAddr failed: %v", err)
-	}
-
-	cm := ipv6.ControlMessage{
-		TrafficClass: DiffServAF11 | CongestionExperienced,
-		Src:          net.IPv6loopback,
-		Dst:          net.IPv6loopback,
-	}
-	cf := ipv6.FlagTrafficClass | ipv6.FlagHopLimit | ipv6.FlagSrc | ipv6.FlagDst | ipv6.FlagInterface | ipv6.FlagPathMTU
-	ifi := loopbackInterface()
-	if ifi != nil {
-		cm.IfIndex = ifi.Index
-	}
-	wb := []byte("HELLO-R-U-THERE")
-
-	for i, toggle := range []bool{true, false, true} {
-		if err := p.SetControlMessage(cf, toggle); err != nil {
-			t.Fatalf("ipv6.PacketConn.SetControlMessage failed: %v", err)
-		}
-		cm.HopLimit = i + 1
-		if err := p.SetWriteDeadline(time.Now().Add(100 * time.Millisecond)); err != nil {
-			t.Fatalf("ipv6.PacketConn.SetWriteDeadline failed: %v", err)
-		}
-		if n, err := p.WriteTo(wb, &cm, dst); err != nil {
-			t.Fatalf("ipv6.PacketConn.WriteTo failed: %v", err)
-		} else if n != len(wb) {
-			t.Fatalf("ipv6.PacketConn.WriteTo failed: short write: %v", n)
-		}
-		rb := make([]byte, 128)
-		if err := p.SetReadDeadline(time.Now().Add(100 * time.Millisecond)); err != nil {
-			t.Fatalf("ipv6.PacketConn.SetReadDeadline failed: %v", err)
-		}
-		if n, cm, _, err := p.ReadFrom(rb); err != nil {
-			t.Fatalf("ipv6.PacketConn.ReadFrom failed: %v", err)
-		} else if !bytes.Equal(rb[:n], wb) {
-			t.Fatalf("got %v; expected %v", rb[:n], wb)
-		} else {
-			t.Logf("rcvd cmsg: %v", cm)
-		}
-	}
-}
-
-func TestPacketConnReadWriteUnicastICMP(t *testing.T) {
-	switch runtime.GOOS {
-	case "dragonfly", "plan9", "solaris", "windows":
-		t.Skipf("not supported on %q", runtime.GOOS)
-	}
-	if !supportsIPv6 {
-		t.Skip("ipv6 is not supported")
-	}
-	if os.Getuid() != 0 {
-		t.Skip("must be root")
-	}
-
-	c, err := net.ListenPacket("ip6:ipv6-icmp", "::1")
-	if err != nil {
-		t.Fatalf("net.ListenPacket failed: %v", err)
-	}
-	defer c.Close()
-	p := ipv6.NewPacketConn(c)
-	defer p.Close()
-
-	dst, err := net.ResolveIPAddr("ip6", "::1")
-	if err != nil {
-		t.Fatalf("net.ResolveIPAddr failed: %v", err)
-	}
-
-	pshicmp := ipv6PseudoHeader(c.LocalAddr().(*net.IPAddr).IP, dst.IP, ianaProtocolIPv6ICMP)
-	cm := ipv6.ControlMessage{
-		TrafficClass: DiffServAF11 | CongestionExperienced,
-		Src:          net.IPv6loopback,
-		Dst:          net.IPv6loopback,
-	}
-	cf := ipv6.FlagTrafficClass | ipv6.FlagHopLimit | ipv6.FlagSrc | ipv6.FlagDst | ipv6.FlagInterface | ipv6.FlagPathMTU
-	ifi := loopbackInterface()
-	if ifi != nil {
-		cm.IfIndex = ifi.Index
-	}
-
-	var f ipv6.ICMPFilter
-	f.SetAll(true)
-	f.Set(ipv6.ICMPTypeEchoReply, false)
-	if err := p.SetICMPFilter(&f); err != nil {
-		t.Fatalf("ipv6.PacketConn.SetICMPFilter failed: %v", err)
-	}
-
-	var psh []byte
-	for i, toggle := range []bool{true, false, true} {
-		if toggle {
-			psh = nil
-			if err := p.SetChecksum(true, 2); err != nil {
-				t.Fatalf("ipv6.PacketConn.SetChecksum failed: %v", err)
-			}
-		} else {
-			psh = pshicmp
-			// Some platforms never allow to disable the
-			// kernel checksum processing.
-			p.SetChecksum(false, -1)
-		}
-		wb, err := (&icmpMessage{
-			Type: ipv6.ICMPTypeEchoRequest, Code: 0,
-			Body: &icmpEcho{
-				ID: os.Getpid() & 0xffff, Seq: i + 1,
-				Data: []byte("HELLO-R-U-THERE"),
-			},
-		}).Marshal(psh)
-		if err != nil {
-			t.Fatalf("icmpMessage.Marshal failed: %v", err)
-		}
-		if err := p.SetControlMessage(cf, toggle); err != nil {
-			t.Fatalf("ipv6.PacketConn.SetControlMessage failed: %v", err)
-		}
-		cm.HopLimit = i + 1
-		if err := p.SetWriteDeadline(time.Now().Add(100 * time.Millisecond)); err != nil {
-			t.Fatalf("ipv6.PacketConn.SetWriteDeadline failed: %v", err)
-		}
-		if n, err := p.WriteTo(wb, &cm, dst); err != nil {
-			t.Fatalf("ipv6.PacketConn.WriteTo failed: %v", err)
-		} else if n != len(wb) {
-			t.Fatalf("ipv6.PacketConn.WriteTo failed: short write: %v", n)
-		}
-		rb := make([]byte, 128)
-		if err := p.SetReadDeadline(time.Now().Add(100 * time.Millisecond)); err != nil {
-			t.Fatalf("ipv6.PacketConn.SetReadDeadline failed: %v", err)
-		}
-		if n, cm, _, err := p.ReadFrom(rb); err != nil {
-			t.Fatalf("ipv6.PacketConn.ReadFrom failed: %v", err)
-		} else {
-			t.Logf("rcvd cmsg: %v", cm)
-			if m, err := parseICMPMessage(rb[:n]); err != nil {
-				t.Fatalf("parseICMPMessage failed: %v", err)
-			} else if m.Type != ipv6.ICMPTypeEchoReply || m.Code != 0 {
-				t.Fatalf("got type=%v, code=%v; expected type=%v, code=%v", m.Type, m.Code, ipv6.ICMPTypeEchoReply, 0)
-			}
-		}
-	}
-}

Godeps/_workspace/src/code.google.com/p/go.net/ipv6/unicastsockopt_test.go

@@ -1,101 +0,0 @@
-// 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.
-
-package ipv6_test
-
-import (
-	"code.google.com/p/go.net/ipv6"
-	"net"
-	"os"
-	"runtime"
-	"testing"
-)
-
-func TestConnUnicastSocketOptions(t *testing.T) {
-	switch runtime.GOOS {
-	case "dragonfly", "plan9", "solaris", "windows":
-		t.Skipf("not supported on %q", runtime.GOOS)
-	}
-	if !supportsIPv6 {
-		t.Skip("ipv6 is not supported")
-	}
-
-	ln, err := net.Listen("tcp6", "[::1]:0")
-	if err != nil {
-		t.Fatalf("net.Listen failed: %v", err)
-	}
-	defer ln.Close()
-
-	done := make(chan bool)
-	go acceptor(t, ln, done)
-
-	c, err := net.Dial("tcp6", ln.Addr().String())
-	if err != nil {
-		t.Fatalf("net.Dial failed: %v", err)
-	}
-	defer c.Close()
-
-	testUnicastSocketOptions(t, ipv6.NewConn(c))
-
-	<-done
-}
-
-var packetConnUnicastSocketOptionTests = []struct {
-	net, proto, addr string
-}{
-	{"udp6", "", "[::1]:0"},
-	{"ip6", ":ipv6-icmp", "::1"},
-}
-
-func TestPacketConnUnicastSocketOptions(t *testing.T) {
-	switch runtime.GOOS {
-	case "dragonfly", "plan9", "solaris", "windows":
-		t.Skipf("not supported on %q", runtime.GOOS)
-	}
-	if !supportsIPv6 {
-		t.Skip("ipv6 is not supported")
-	}
-
-	for _, tt := range packetConnUnicastSocketOptionTests {
-		if tt.net == "ip6" && os.Getuid() != 0 {
-			t.Skip("must be root")
-		}
-		c, err := net.ListenPacket(tt.net+tt.proto, tt.addr)
-		if err != nil {
-			t.Fatalf("net.ListenPacket(%q, %q) failed: %v", tt.net+tt.proto, tt.addr, err)
-		}
-		defer c.Close()
-
-		testUnicastSocketOptions(t, ipv6.NewPacketConn(c))
-	}
-}
-
-type testIPv6UnicastConn interface {
-	TrafficClass() (int, error)
-	SetTrafficClass(int) error
-	HopLimit() (int, error)
-	SetHopLimit(int) error
-}
-
-func testUnicastSocketOptions(t *testing.T, c testIPv6UnicastConn) {
-	tclass := DiffServCS0 | NotECNTransport
-	if err := c.SetTrafficClass(tclass); err != nil {
-		t.Fatalf("ipv6.Conn.SetTrafficClass failed: %v", err)
-	}
-	if v, err := c.TrafficClass(); err != nil {
-		t.Fatalf("ipv6.Conn.TrafficClass failed: %v", err)
-	} else if v != tclass {
-		t.Fatalf("got unexpected traffic class %v; expected %v", v, tclass)
-	}
-
-	hoplim := 255
-	if err := c.SetHopLimit(hoplim); err != nil {
-		t.Fatalf("ipv6.Conn.SetHopLimit failed: %v", err)
-	}
-	if v, err := c.HopLimit(); err != nil {
-		t.Fatalf("ipv6.Conn.HopLimit failed: %v", err)
-	} else if v != hoplim {
-		t.Fatalf("got unexpected hop limit %v; expected %v", v, hoplim)
-	}
-}

Godeps/_workspace/src/code.google.com/p/go.text/unicode/norm/maketesttables.go

@@ -1,45 +0,0 @@
-// Copyright 2011 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// +build ignore
-
-// Generate test data for trie code.
-
-package main
-
-import (
-	"fmt"
-)
-
-func main() {
-	printTestTables()
-}
-
-// We take the smallest, largest and an arbitrary value for each
-// of the UTF-8 sequence lengths.
-var testRunes = []rune{
-	0x01, 0x0C, 0x7F, // 1-byte sequences
-	0x80, 0x100, 0x7FF, // 2-byte sequences
-	0x800, 0x999, 0xFFFF, // 3-byte sequences
-	0x10000, 0x10101, 0x10FFFF, // 4-byte sequences
-	0x200, 0x201, 0x202, 0x210, 0x215, // five entries in one sparse block
-}
-
-const fileHeader = `// Generated by running
-//	maketesttables
-// DO NOT EDIT
-
-package norm
-
-`
-
-func printTestTables() {
-	fmt.Print(fileHeader)
-	fmt.Printf("var testRunes = %#v\n\n", testRunes)
-	t := newNode()
-	for i, r := range testRunes {
-		t.insert(r, uint16(i))
-	}
-	t.printTables("testdata")
-}

Godeps/_workspace/src/code.google.com/p/go.text/unicode/norm/trie.go

@@ -1,232 +0,0 @@
-// Copyright 2011 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package norm
-
-type valueRange struct {
-	value  uint16 // header: value:stride
-	lo, hi byte   // header: lo:n
-}
-
-type trie struct {
-	index        []uint8
-	values       []uint16
-	sparse       []valueRange
-	sparseOffset []uint16
-	cutoff       uint8 // indices >= cutoff are sparse
-}
-
-// lookupValue determines the type of block n and looks up the value for b.
-// For n < t.cutoff, the block is a simple lookup table. Otherwise, the block
-// is a list of ranges with an accompanying value. Given a matching range r,
-// the value for b is by r.value + (b - r.lo) * stride.
-func (t *trie) lookupValue(n uint8, b byte) uint16 {
-	if n < t.cutoff {
-		return t.values[uint16(n)<<6+uint16(b)]
-	}
-	offset := t.sparseOffset[n-t.cutoff]
-	header := t.sparse[offset]
-	lo := offset + 1
-	hi := lo + uint16(header.lo)
-	for lo < hi {
-		m := lo + (hi-lo)/2
-		r := t.sparse[m]
-		if r.lo <= b && b <= r.hi {
-			return r.value + uint16(b-r.lo)*header.value
-		}
-		if b < r.lo {
-			hi = m
-		} else {
-			lo = m + 1
-		}
-	}
-	return 0
-}
-
-const (
-	t1 = 0x00 // 0000 0000
-	tx = 0x80 // 1000 0000
-	t2 = 0xC0 // 1100 0000
-	t3 = 0xE0 // 1110 0000
-	t4 = 0xF0 // 1111 0000
-	t5 = 0xF8 // 1111 1000
-	t6 = 0xFC // 1111 1100
-	te = 0xFE // 1111 1110
-)
-
-// lookup returns the trie value for the first UTF-8 encoding in s and
-// the width in bytes of this encoding. The size will be 0 if s does not
-// hold enough bytes to complete the encoding. len(s) must be greater than 0.
-func (t *trie) lookup(s []byte) (v uint16, sz int) {
-	c0 := s[0]
-	switch {
-	case c0 < tx:
-		return t.values[c0], 1
-	case c0 < t2:
-		return 0, 1
-	case c0 < t3:
-		if len(s) < 2 {
-			return 0, 0
-		}
-		i := t.index[c0]
-		c1 := s[1]
-		if c1 < tx || t2 <= c1 {
-			return 0, 1
-		}
-		return t.lookupValue(i, c1), 2
-	case c0 < t4:
-		if len(s) < 3 {
-			return 0, 0
-		}
-		i := t.index[c0]
-		c1 := s[1]
-		if c1 < tx || t2 <= c1 {
-			return 0, 1
-		}
-		o := uint16(i)<<6 + uint16(c1)
-		i = t.index[o]
-		c2 := s[2]
-		if c2 < tx || t2 <= c2 {
-			return 0, 2
-		}
-		return t.lookupValue(i, c2), 3
-	case c0 < t5:
-		if len(s) < 4 {
-			return 0, 0
-		}
-		i := t.index[c0]
-		c1 := s[1]
-		if c1 < tx || t2 <= c1 {
-			return 0, 1
-		}
-		o := uint16(i)<<6 + uint16(c1)
-		i = t.index[o]
-		c2 := s[2]
-		if c2 < tx || t2 <= c2 {
-			return 0, 2
-		}
-		o = uint16(i)<<6 + uint16(c2)
-		i = t.index[o]
-		c3 := s[3]
-		if c3 < tx || t2 <= c3 {
-			return 0, 3
-		}
-		return t.lookupValue(i, c3), 4
-	}
-	// Illegal rune
-	return 0, 1
-}
-
-// lookupString returns the trie value for the first UTF-8 encoding in s and
-// the width in bytes of this encoding. The size will be 0 if s does not
-// hold enough bytes to complete the encoding. len(s) must be greater than 0.
-func (t *trie) lookupString(s string) (v uint16, sz int) {
-	c0 := s[0]
-	switch {
-	case c0 < tx:
-		return t.values[c0], 1
-	case c0 < t2:
-		return 0, 1
-	case c0 < t3:
-		if len(s) < 2 {
-			return 0, 0
-		}
-		i := t.index[c0]
-		c1 := s[1]
-		if c1 < tx || t2 <= c1 {
-			return 0, 1
-		}
-		return t.lookupValue(i, c1), 2
-	case c0 < t4:
-		if len(s) < 3 {
-			return 0, 0
-		}
-		i := t.index[c0]
-		c1 := s[1]
-		if c1 < tx || t2 <= c1 {
-			return 0, 1
-		}
-		o := uint16(i)<<6 + uint16(c1)
-		i = t.index[o]
-		c2 := s[2]
-		if c2 < tx || t2 <= c2 {
-			return 0, 2
-		}
-		return t.lookupValue(i, c2), 3
-	case c0 < t5:
-		if len(s) < 4 {
-			return 0, 0
-		}
-		i := t.index[c0]
-		c1 := s[1]
-		if c1 < tx || t2 <= c1 {
-			return 0, 1
-		}
-		o := uint16(i)<<6 + uint16(c1)
-		i = t.index[o]
-		c2 := s[2]
-		if c2 < tx || t2 <= c2 {
-			return 0, 2
-		}
-		o = uint16(i)<<6 + uint16(c2)
-		i = t.index[o]
-		c3 := s[3]
-		if c3 < tx || t2 <= c3 {
-			return 0, 3
-		}
-		return t.lookupValue(i, c3), 4
-	}
-	// Illegal rune
-	return 0, 1
-}
-
-// lookupUnsafe returns the trie value for the first UTF-8 encoding in s.
-// s must hold a full encoding.
-func (t *trie) lookupUnsafe(s []byte) uint16 {
-	c0 := s[0]
-	if c0 < tx {
-		return t.values[c0]
-	}
-	if c0 < t2 {
-		return 0
-	}
-	i := t.index[c0]
-	if c0 < t3 {
-		return t.lookupValue(i, s[1])
-	}
-	i = t.index[uint16(i)<<6+uint16(s[1])]
-	if c0 < t4 {
-		return t.lookupValue(i, s[2])
-	}
-	i = t.index[uint16(i)<<6+uint16(s[2])]
-	if c0 < t5 {
-		return t.lookupValue(i, s[3])
-	}
-	return 0
-}
-
-// lookupStringUnsafe returns the trie value for the first UTF-8 encoding in s.
-// s must hold a full encoding.
-func (t *trie) lookupStringUnsafe(s string) uint16 {
-	c0 := s[0]
-	if c0 < tx {
-		return t.values[c0]
-	}
-	if c0 < t2 {
-		return 0
-	}
-	i := t.index[c0]
-	if c0 < t3 {
-		return t.lookupValue(i, s[1])
-	}
-	i = t.index[uint16(i)<<6+uint16(s[1])]
-	if c0 < t4 {
-		return t.lookupValue(i, s[2])
-	}
-	i = t.index[uint16(i)<<6+uint16(s[2])]
-	if c0 < t5 {
-		return t.lookupValue(i, s[3])
-	}
-	return 0
-}

Godeps/_workspace/src/code.google.com/p/go.text/unicode/norm/trie_test.go

@@ -1,152 +0,0 @@
-// Copyright 2011 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package norm
-
-import (
-	"testing"
-	"unicode/utf8"
-)
-
-// Test data is located in triedata_test.go; generated by maketesttables.
-var testdata = testdataTrie
-
-type rangeTest struct {
-	block   uint8
-	lookup  byte
-	result  uint16
-	table   []valueRange
-	offsets []uint16
-}
-
-var range1Off = []uint16{0, 2}
-var range1 = []valueRange{
-	{0, 1, 0},
-	{1, 0x80, 0x80},
-	{0, 2, 0},
-	{1, 0x80, 0x80},
-	{9, 0xff, 0xff},
-}
-
-var rangeTests = []rangeTest{
-	{10, 0x80, 1, range1, range1Off},
-	{10, 0x00, 0, range1, range1Off},
-	{11, 0x80, 1, range1, range1Off},
-	{11, 0xff, 9, range1, range1Off},
-	{11, 0x00, 0, range1, range1Off},
-}
-
-func TestLookupSparse(t *testing.T) {
-	for i, test := range rangeTests {
-		n := trie{sparse: test.table, sparseOffset: test.offsets, cutoff: 10}
-		v := n.lookupValue(test.block, test.lookup)
-		if v != test.result {
-			t.Errorf("LookupSparse:%d: found %X; want %X", i, v, test.result)
-		}
-	}
-}
-
-// Test cases for illegal runes.
-type trietest struct {
-	size  int
-	bytes []byte
-}
-
-var tests = []trietest{
-	// illegal runes
-	{1, []byte{0x80}},
-	{1, []byte{0xFF}},
-	{1, []byte{t2, tx - 1}},
-	{1, []byte{t2, t2}},
-	{2, []byte{t3, tx, tx - 1}},
-	{2, []byte{t3, tx, t2}},
-	{1, []byte{t3, tx - 1, tx}},
-	{3, []byte{t4, tx, tx, tx - 1}},
-	{3, []byte{t4, tx, tx, t2}},
-	{1, []byte{t4, t2, tx, tx - 1}},
-	{2, []byte{t4, tx, t2, tx - 1}},
-
-	// short runes
-	{0, []byte{t2}},
-	{0, []byte{t3, tx}},
-	{0, []byte{t4, tx, tx}},
-
-	// we only support UTF-8 up to utf8.UTFMax bytes (4 bytes)
-	{1, []byte{t5, tx, tx, tx, tx}},
-	{1, []byte{t6, tx, tx, tx, tx, tx}},
-}
-
-func mkUTF8(r rune) ([]byte, int) {
-	var b [utf8.UTFMax]byte
-	sz := utf8.EncodeRune(b[:], r)
-	return b[:sz], sz
-}
-
-func TestLookup(t *testing.T) {
-	for i, tt := range testRunes {
-		b, szg := mkUTF8(tt)
-		v, szt := testdata.lookup(b)
-		if int(v) != i {
-			t.Errorf("lookup(%U): found value %#x, expected %#x", tt, v, i)
-		}
-		if szt != szg {
-			t.Errorf("lookup(%U): found size %d, expected %d", tt, szt, szg)
-		}
-	}
-	for i, tt := range tests {
-		v, sz := testdata.lookup(tt.bytes)
-		if v != 0 {
-			t.Errorf("lookup of illegal rune, case %d: found value %#x, expected 0", i, v)
-		}
-		if sz != tt.size {
-			t.Errorf("lookup of illegal rune, case %d: found size %d, expected %d", i, sz, tt.size)
-		}
-	}
-	// Verify defaults.
-	if v, _ := testdata.lookup([]byte{0xC1, 0x8C}); v != 0 {
-		t.Errorf("lookup of non-existing rune should be 0; found %X", v)
-	}
-}
-
-func TestLookupUnsafe(t *testing.T) {
-	for i, tt := range testRunes {
-		b, _ := mkUTF8(tt)
-		v := testdata.lookupUnsafe(b)
-		if int(v) != i {
-			t.Errorf("lookupUnsafe(%U): found value %#x, expected %#x", i, v, i)
-		}
-	}
-}
-
-func TestLookupString(t *testing.T) {
-	for i, tt := range testRunes {
-		b, szg := mkUTF8(tt)
-		v, szt := testdata.lookupString(string(b))
-		if int(v) != i {
-			t.Errorf("lookup(%U): found value %#x, expected %#x", i, v, i)
-		}
-		if szt != szg {
-			t.Errorf("lookup(%U): found size %d, expected %d", i, szt, szg)
-		}
-	}
-	for i, tt := range tests {
-		v, sz := testdata.lookupString(string(tt.bytes))
-		if int(v) != 0 {
-			t.Errorf("lookup of illegal rune, case %d: found value %#x, expected 0", i, v)
-		}
-		if sz != tt.size {
-			t.Errorf("lookup of illegal rune, case %d: found size %d, expected %d", i, sz, tt.size)
-		}
-	}
-}
-
-func TestLookupStringUnsafe(t *testing.T) {
-	for i, tt := range testRunes {
-		b, _ := mkUTF8(tt)
-		v := testdata.lookupStringUnsafe(string(b))
-		if int(v) != i {
-			t.Errorf("lookupUnsafe(%U): found value %#x, expected %#x", i, v, i)
-		}
-	}
-}

Godeps/_workspace/src/code.google.com/p/go.text/unicode/norm/triedata_test.go

@@ -1,85 +0,0 @@
-// Generated by running
-//	maketesttables
-// DO NOT EDIT
-
-package norm
-
-var testRunes = []int32{1, 12, 127, 128, 256, 2047, 2048, 2457, 65535, 65536, 65793, 1114111, 512, 513, 514, 528, 533}
-
-// testdataValues: 192 entries, 384 bytes
-// Block 2 is the null block.
-var testdataValues = [192]uint16{
-	// Block 0x0, offset 0x0
-	0x000c: 0x0001,
-	// Block 0x1, offset 0x40
-	0x007f: 0x0002,
-	// Block 0x2, offset 0x80
-}
-
-// testdataSparseOffset: 10 entries, 20 bytes
-var testdataSparseOffset = []uint16{0x0, 0x2, 0x4, 0x8, 0xa, 0xc, 0xe, 0x10, 0x12, 0x14}
-
-// testdataSparseValues: 22 entries, 88 bytes
-var testdataSparseValues = [22]valueRange{
-	// Block 0x0, offset 0x1
-	{value: 0x0000, lo: 0x01},
-	{value: 0x0003, lo: 0x80, hi: 0x80},
-	// Block 0x1, offset 0x2
-	{value: 0x0000, lo: 0x01},
-	{value: 0x0004, lo: 0x80, hi: 0x80},
-	// Block 0x2, offset 0x3
-	{value: 0x0001, lo: 0x03},
-	{value: 0x000c, lo: 0x80, hi: 0x82},
-	{value: 0x000f, lo: 0x90, hi: 0x90},
-	{value: 0x0010, lo: 0x95, hi: 0x95},
-	// Block 0x3, offset 0x4
-	{value: 0x0000, lo: 0x01},
-	{value: 0x0005, lo: 0xbf, hi: 0xbf},
-	// Block 0x4, offset 0x5
-	{value: 0x0000, lo: 0x01},
-	{value: 0x0006, lo: 0x80, hi: 0x80},
-	// Block 0x5, offset 0x6
-	{value: 0x0000, lo: 0x01},
-	{value: 0x0007, lo: 0x99, hi: 0x99},
-	// Block 0x6, offset 0x7
-	{value: 0x0000, lo: 0x01},
-	{value: 0x0008, lo: 0xbf, hi: 0xbf},
-	// Block 0x7, offset 0x8
-	{value: 0x0000, lo: 0x01},
-	{value: 0x0009, lo: 0x80, hi: 0x80},
-	// Block 0x8, offset 0x9
-	{value: 0x0000, lo: 0x01},
-	{value: 0x000a, lo: 0x81, hi: 0x81},
-	// Block 0x9, offset 0xa
-	{value: 0x0000, lo: 0x01},
-	{value: 0x000b, lo: 0xbf, hi: 0xbf},
-}
-
-// testdataLookup: 640 bytes
-// Block 0 is the null block.
-var testdataLookup = [640]uint8{
-	// Block 0x0, offset 0x0
-	// Block 0x1, offset 0x40
-	// Block 0x2, offset 0x80
-	// Block 0x3, offset 0xc0
-	0x0c2: 0x01, 0x0c4: 0x02,
-	0x0c8: 0x03,
-	0x0df: 0x04,
-	0x0e0: 0x02,
-	0x0ef: 0x03,
-	0x0f0: 0x05, 0x0f4: 0x07,
-	// Block 0x4, offset 0x100
-	0x120: 0x05, 0x126: 0x06,
-	// Block 0x5, offset 0x140
-	0x17f: 0x07,
-	// Block 0x6, offset 0x180
-	0x180: 0x08, 0x184: 0x09,
-	// Block 0x7, offset 0x1c0
-	0x1d0: 0x04,
-	// Block 0x8, offset 0x200
-	0x23f: 0x0a,
-	// Block 0x9, offset 0x240
-	0x24f: 0x06,
-}
-
-var testdataTrie = trie{testdataLookup[:], testdataValues[:], testdataSparseValues[:], testdataSparseOffset[:], 1}

Godeps/_workspace/src/code.google.com/p/go.text/unicode/norm/triegen.go

@@ -1,317 +0,0 @@
-// Copyright 2011 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// +build ignore
-
-// Trie table generator.
-// Used by make*tables tools to generate a go file with trie data structures
-// for mapping UTF-8 to a 16-bit value. All but the last byte in a UTF-8 byte
-// sequence are used to lookup offsets in the index table to be used for the
-// next byte. The last byte is used to index into a table with 16-bit values.
-
-package main
-
-import (
-	"fmt"
-	"hash/crc32"
-	"log"
-	"unicode/utf8"
-)
-
-const (
-	blockSize        = 64
-	blockOffset      = 2 // Subtract two blocks to compensate for the 0x80 added to continuation bytes.
-	maxSparseEntries = 16
-)
-
-// Intermediate trie structure
-type trieNode struct {
-	table [256]*trieNode
-	value int
-	b     byte
-	leaf  bool
-}
-
-func newNode() *trieNode {
-	return new(trieNode)
-}
-
-func (n trieNode) String() string {
-	s := fmt.Sprint("trieNode{table: { non-nil at index: ")
-	for i, v := range n.table {
-		if v != nil {
-			s += fmt.Sprintf("%d, ", i)
-		}
-	}
-	s += fmt.Sprintf("}, value:%#x, b:%#x leaf:%v}", n.value, n.b, n.leaf)
-	return s
-}
-
-func (n trieNode) isInternal() bool {
-	internal := true
-	for i := 0; i < 256; i++ {
-		if nn := n.table[i]; nn != nil {
-			if !internal && !nn.leaf {
-				log.Fatalf("triegen: isInternal: node contains both leaf and non-leaf children (%v)", n)
-			}
-			internal = internal && !nn.leaf
-		}
-	}
-	return internal
-}
-
-func (n trieNode) mostFrequentStride() int {
-	counts := make(map[int]int)
-	v := 0
-	for _, t := range n.table[0x80 : 0x80+blockSize] {
-		if t != nil {
-			if stride := t.value - v; v != 0 && stride >= 0 {
-				counts[stride]++
-			}
-			v = t.value
-		} else {
-			v = 0
-		}
-	}
-	var maxs, maxc int
-	for stride, cnt := range counts {
-		if cnt > maxc || (cnt == maxc && stride < maxs) {
-			maxs, maxc = stride, cnt
-		}
-	}
-	return maxs
-}
-
-func (n trieNode) countSparseEntries() int {
-	stride := n.mostFrequentStride()
-	var count, v int
-	for _, t := range n.table[0x80 : 0x80+blockSize] {
-		tv := 0
-		if t != nil {
-			tv = t.value
-		}
-		if tv-v != stride {
-			if tv != 0 {
-				count++
-			}
-		}
-		v = tv
-	}
-	return count
-}
-
-func (n *trieNode) insert(r rune, value uint16) {
-	var p [utf8.UTFMax]byte
-	sz := utf8.EncodeRune(p[:], r)
-
-	for i := 0; i < sz; i++ {
-		if n.leaf {
-			log.Fatalf("triegen: insert: node (%#v) should not be a leaf", n)
-		}
-		nn := n.table[p[i]]
-		if nn == nil {
-			nn = newNode()
-			nn.b = p[i]
-			n.table[p[i]] = nn
-		}
-		n = nn
-	}
-	n.value = int(value)
-	n.leaf = true
-}
-
-type nodeIndex struct {
-	lookupBlocks []*trieNode
-	valueBlocks  []*trieNode
-	sparseBlocks []*trieNode
-	sparseOffset []uint16
-	sparseCount  int
-
-	lookupBlockIdx map[uint32]int
-	valueBlockIdx  map[uint32]int
-}
-
-func newIndex() *nodeIndex {
-	index := &nodeIndex{}
-	index.lookupBlocks = make([]*trieNode, 0)
-	index.valueBlocks = make([]*trieNode, 0)
-	index.sparseBlocks = make([]*trieNode, 0)
-	index.sparseOffset = make([]uint16, 1)
-	index.lookupBlockIdx = make(map[uint32]int)
-	index.valueBlockIdx = make(map[uint32]int)
-	return index
-}
-
-func computeOffsets(index *nodeIndex, n *trieNode) int {
-	if n.leaf {
-		return n.value
-	}
-	hasher := crc32.New(crc32.MakeTable(crc32.IEEE))
-	// We only index continuation bytes.
-	for i := 0; i < blockSize; i++ {
-		v := 0
-		if nn := n.table[0x80+i]; nn != nil {
-			v = computeOffsets(index, nn)
-		}
-		hasher.Write([]byte{uint8(v >> 8), uint8(v)})
-	}
-	h := hasher.Sum32()
-	if n.isInternal() {
-		v, ok := index.lookupBlockIdx[h]
-		if !ok {
-			v = len(index.lookupBlocks) - blockOffset
-			index.lookupBlocks = append(index.lookupBlocks, n)
-			index.lookupBlockIdx[h] = v
-		}
-		n.value = v
-	} else {
-		v, ok := index.valueBlockIdx[h]
-		if !ok {
-			if c := n.countSparseEntries(); c > maxSparseEntries {
-				v = len(index.valueBlocks) - blockOffset
-				index.valueBlocks = append(index.valueBlocks, n)
-				index.valueBlockIdx[h] = v
-			} else {
-				v = -len(index.sparseOffset)
-				index.sparseBlocks = append(index.sparseBlocks, n)
-				index.sparseOffset = append(index.sparseOffset, uint16(index.sparseCount))
-				index.sparseCount += c + 1
-				index.valueBlockIdx[h] = v
-			}
-		}
-		n.value = v
-	}
-	return n.value
-}
-
-func printValueBlock(nr int, n *trieNode, offset int) {
-	boff := nr * blockSize
-	fmt.Printf("\n// Block %#x, offset %#x", nr, boff)
-	var printnewline bool
-	for i := 0; i < blockSize; i++ {
-		if i%6 == 0 {
-			printnewline = true
-		}
-		v := 0
-		if nn := n.table[i+offset]; nn != nil {
-			v = nn.value
-		}
-		if v != 0 {
-			if printnewline {
-				fmt.Printf("\n")
-				printnewline = false
-			}
-			fmt.Printf("%#04x:%#04x, ", boff+i, v)
-		}
-	}
-}
-
-func printSparseBlock(nr int, n *trieNode) {
-	boff := -n.value
-	fmt.Printf("\n// Block %#x, offset %#x", nr, boff)
-	v := 0
-	//stride := f(n)
-	stride := n.mostFrequentStride()
-	c := n.countSparseEntries()
-	fmt.Printf("\n{value:%#04x,lo:%#02x},", stride, uint8(c))
-	for i, nn := range n.table[0x80 : 0x80+blockSize] {
-		nv := 0
-		if nn != nil {
-			nv = nn.value
-		}
-		if nv-v != stride {
-			if v != 0 {
-				fmt.Printf(",hi:%#02x},", 0x80+i-1)
-			}
-			if nv != 0 {
-				fmt.Printf("\n{value:%#04x,lo:%#02x", nv, nn.b)
-			}
-		}
-		v = nv
-	}
-	if v != 0 {
-		fmt.Printf(",hi:%#02x},", 0x80+blockSize-1)
-	}
-}
-
-func printLookupBlock(nr int, n *trieNode, offset, cutoff int) {
-	boff := nr * blockSize
-	fmt.Printf("\n// Block %#x, offset %#x", nr, boff)
-	var printnewline bool
-	for i := 0; i < blockSize; i++ {
-		if i%8 == 0 {
-			printnewline = true
-		}
-		v := 0
-		if nn := n.table[i+offset]; nn != nil {
-			v = nn.value
-		}
-		if v != 0 {
-			if v < 0 {
-				v = -v - 1 + cutoff
-			}
-			if printnewline {
-				fmt.Printf("\n")
-				printnewline = false
-			}
-			fmt.Printf("%#03x:%#02x, ", boff+i, v)
-		}
-	}
-}
-
-// printTables returns the size in bytes of the generated tables.
-func (t *trieNode) printTables(name string) int {
-	index := newIndex()
-	// Values for 7-bit ASCII are stored in first two block, followed by nil block.
-	index.valueBlocks = append(index.valueBlocks, nil, nil, nil)
-	// First byte of multi-byte UTF-8 codepoints are indexed in 4th block.
-	index.lookupBlocks = append(index.lookupBlocks, nil, nil, nil, nil)
-	// Index starter bytes of multi-byte UTF-8.
-	for i := 0xC0; i < 0x100; i++ {
-		if t.table[i] != nil {
-			computeOffsets(index, t.table[i])
-		}
-	}
-
-	nv := len(index.valueBlocks) * blockSize
-	fmt.Printf("// %sValues: %d entries, %d bytes\n", name, nv, nv*2)
-	fmt.Printf("// Block 2 is the null block.\n")
-	fmt.Printf("var %sValues = [%d]uint16 {", name, nv)
-	printValueBlock(0, t, 0)
-	printValueBlock(1, t, 64)
-	printValueBlock(2, newNode(), 0)
-	for i := 3; i < len(index.valueBlocks); i++ {
-		printValueBlock(i, index.valueBlocks[i], 0x80)
-	}
-	fmt.Print("\n}\n\n")
-
-	ls := len(index.sparseBlocks)
-	fmt.Printf("// %sSparseOffset: %d entries, %d bytes\n", name, ls, ls*2)
-	fmt.Printf("var %sSparseOffset = %#v\n\n", name, index.sparseOffset[1:])
-
-	ns := index.sparseCount
-	fmt.Printf("// %sSparseValues: %d entries, %d bytes\n", name, ns, ns*4)
-	fmt.Printf("var %sSparseValues = [%d]valueRange {", name, ns)
-	for i, n := range index.sparseBlocks {
-		printSparseBlock(i, n)
-	}
-	fmt.Print("\n}\n\n")
-
-	cutoff := len(index.valueBlocks) - blockOffset
-	ni := len(index.lookupBlocks) * blockSize
-	fmt.Printf("// %sLookup: %d bytes\n", name, ni)
-	fmt.Printf("// Block 0 is the null block.\n")
-	fmt.Printf("var %sLookup = [%d]uint8 {", name, ni)
-	printLookupBlock(0, newNode(), 0, cutoff)
-	printLookupBlock(1, newNode(), 0, cutoff)
-	printLookupBlock(2, newNode(), 0, cutoff)
-	printLookupBlock(3, t, 0xC0, cutoff)
-	for i := 4; i < len(index.lookupBlocks); i++ {
-		printLookupBlock(i, index.lookupBlocks[i], 0x80, cutoff)
-	}
-	fmt.Print("\n}\n\n")
-	fmt.Printf("var %sTrie = trie{ %sLookup[:], %sValues[:], %sSparseValues[:], %sSparseOffset[:], %d}\n\n",
-		name, name, name, name, name, cutoff)
-	return nv*2 + ns*4 + ni + ls*2
-}

Godeps/_workspace/src/github.com/AudriusButkevicius/lfu-go/LICENSE

@@ -0,0 +1,19 @@
+Copyright (C) 2012 Dave Grijalva
+
+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.

Godeps/_workspace/src/github.com/AudriusButkevicius/lfu-go/README.md

@@ -0,0 +1,19 @@
+A simple LFU cache for golang.  Based on the paper [An O(1) algorithm for implementing the LFU cache eviction scheme](http://dhruvbird.com/lfu.pdf).
+
+Usage:
+
+```go
+import "github.com/dgrijalva/lfu-go"
+
+// Make a new thing
+c := lfu.New()
+
+// Set some values
+c.Set("myKey", myValue)
+
+// Retrieve some values
+myValue = c.Get("myKey")
+
+// Evict some values
+c.Evict(1)
+```

Godeps/_workspace/src/github.com/AudriusButkevicius/lfu-go/lfu.go

@@ -0,0 +1,156 @@
+package lfu
+
+import (
+	"container/list"
+	"sync"
+)
+
+type Eviction struct {
+	Key   string
+	Value interface{}
+}
+
+type Cache struct {
+	// If len > UpperBound, cache will automatically evict
+	// down to LowerBound.  If either value is 0, this behavior
+	// is disabled.
+	UpperBound      int
+	LowerBound      int
+	values          map[string]*cacheEntry
+	freqs           *list.List
+	len             int
+	lock            *sync.Mutex
+	EvictionChannel chan<- Eviction
+}
+
+type cacheEntry struct {
+	key      string
+	value    interface{}
+	freqNode *list.Element
+}
+
+type listEntry struct {
+	entries map[*cacheEntry]byte
+	freq    int
+}
+
+func New() *Cache {
+	c := new(Cache)
+	c.values = make(map[string]*cacheEntry)
+	c.freqs = list.New()
+	c.lock = new(sync.Mutex)
+	return c
+}
+
+func (c *Cache) Get(key string) interface{} {
+	c.lock.Lock()
+	defer c.lock.Unlock()
+	if e, ok := c.values[key]; ok {
+		c.increment(e)
+		return e.value
+	}
+	return nil
+}
+
+func (c *Cache) Set(key string, value interface{}) {
+	c.lock.Lock()
+	defer c.lock.Unlock()
+	if e, ok := c.values[key]; ok {
+		// value already exists for key.  overwrite
+		e.value = value
+		c.increment(e)
+	} else {
+		// value doesn't exist.  insert
+		e := new(cacheEntry)
+		e.key = key
+		e.value = value
+		c.values[key] = e
+		c.increment(e)
+		c.len++
+		// bounds mgmt
+		if c.UpperBound > 0 && c.LowerBound > 0 {
+			if c.len > c.UpperBound {
+				c.evict(c.len - c.LowerBound)
+			}
+		}
+	}
+}
+
+func (c *Cache) Len() int {
+	c.lock.Lock()
+	defer c.lock.Unlock()
+	return c.len
+}
+
+func (c *Cache) Evict(count int) int {
+	c.lock.Lock()
+	defer c.lock.Unlock()
+	return c.evict(count)
+}
+
+func (c *Cache) evict(count int) int {
+	// No lock here so it can be called
+	// from within the lock (during Set)
+	var evicted int
+	for i := 0; i < count; {
+		if place := c.freqs.Front(); place != nil {
+			for entry, _ := range place.Value.(*listEntry).entries {
+				if i < count {
+					if c.EvictionChannel != nil {
+						c.EvictionChannel <- Eviction{
+							Key:   entry.key,
+							Value: entry.value,
+						}
+					}
+					delete(c.values, entry.key)
+					c.remEntry(place, entry)
+					evicted++
+					c.len--
+					i++
+				}
+			}
+		}
+	}
+	return evicted
+}
+
+func (c *Cache) increment(e *cacheEntry) {
+	currentPlace := e.freqNode
+	var nextFreq int
+	var nextPlace *list.Element
+	if currentPlace == nil {
+		// new entry
+		nextFreq = 1
+		nextPlace = c.freqs.Front()
+	} else {
+		// move up
+		nextFreq = currentPlace.Value.(*listEntry).freq + 1
+		nextPlace = currentPlace.Next()
+	}
+
+	if nextPlace == nil || nextPlace.Value.(*listEntry).freq != nextFreq {
+		// create a new list entry
+		li := new(listEntry)
+		li.freq = nextFreq
+		li.entries = make(map[*cacheEntry]byte)
+		if currentPlace != nil {
+			nextPlace = c.freqs.InsertAfter(li, currentPlace)
+		} else {
+			nextPlace = c.freqs.PushFront(li)
+		}
+	}
+	e.freqNode = nextPlace
+	nextPlace.Value.(*listEntry).entries[e] = 1
+	if currentPlace != nil {
+		// remove from current position
+		c.remEntry(currentPlace, e)
+	}
+}
+
+func (c *Cache) remEntry(place *list.Element, entry *cacheEntry) {
+	entries := place.Value.(*listEntry).entries
+	delete(entries, entry)
+	if len(entries) == 0 {
+		c.freqs.Remove(place)
+	}
+}

Godeps/_workspace/src/github.com/AudriusButkevicius/lfu-go/lfu_test.go

@@ -0,0 +1,68 @@
+package lfu
+
+import (
+	"fmt"
+	"testing"
+)
+
+func TestLFU(t *testing.T) {
+	c := New()
+	c.Set("a", "a")
+	if v := c.Get("a"); v != "a" {
+		t.Errorf("Value was not saved: %v != 'a'", v)
+	}
+	if l := c.Len(); l != 1 {
+		t.Errorf("Length was not updated: %v != 1", l)
+	}
+
+	c.Set("b", "b")
+	if v := c.Get("b"); v != "b" {
+		t.Errorf("Value was not saved: %v != 'b'", v)
+	}
+	if l := c.Len(); l != 2 {
+		t.Errorf("Length was not updated: %v != 2", l)
+	}
+
+	c.Get("a")
+	evicted := c.Evict(1)
+	if v := c.Get("a"); v != "a" {
+		t.Errorf("Value was improperly evicted: %v != 'a'", v)
+	}
+	if v := c.Get("b"); v != nil {
+		t.Errorf("Value was not evicted: %v", v)
+	}
+	if l := c.Len(); l != 1 {
+		t.Errorf("Length was not updated: %v != 1", l)
+	}
+	if evicted != 1 {
+		t.Errorf("Number of evicted items is wrong: %v != 1", evicted)
+	}
+}
+
+func TestBoundsMgmt(t *testing.T) {
+	c := New()
+	c.UpperBound = 10
+	c.LowerBound = 5
+
+	for i := 0; i < 100; i++ {
+		c.Set(fmt.Sprintf("%v", i), i)
+	}
+	if c.Len() > 10 {
+		t.Errorf("Bounds management failed to evict properly: %v", c.Len())
+	}
+}
+
+func TestEviction(t *testing.T) {
+	ch := make(chan Eviction, 1)
+
+	c := New()
+	c.EvictionChannel = ch
+	c.Set("a", "b")
+	c.Evict(1)
+
+	ev := <-ch
+
+	if ev.Key != "a" || ev.Value.(string) != "b" {
+		t.Error("Incorrect item")
+	}
+}

Godeps/_workspace/src/github.com/bkaradzic/go-lz4/.gitignore

@@ -0,0 +1 @@
+/lz4-example/lz4-example

Godeps/_workspace/src/github.com/bkaradzic/go-lz4/.travis.yml

@@ -0,0 +1,7 @@
+language: go
+
+go:
+  - 1.1
+  - 1.2
+  - 1.3
+  - tip

Godeps/_workspace/src/github.com/bkaradzic/go-lz4/LICENSE

@@ -0,0 +1,24 @@
+Copyright 2011-2012 Branimir Karadzic. All rights reserved.
+Copyright 2013 Damian Gryski. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+   1. Redistributions of source code must retain the above copyright notice, this
+      list of conditions and the following disclaimer.
+
+   2. 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.
+
+THIS SOFTWARE IS PROVIDED BY COPYRIGHT HOLDER ``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 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.
+

Godeps/_workspace/src/github.com/bkaradzic/go-lz4/README.md

@@ -0,0 +1,71 @@
+go-lz4
+======
+
+go-lz4 is port of LZ4 lossless compression algorithm to Go. The original C code
+is located at:
+
+https://code.google.com/p/lz4/
+
+Status
+------
+[![Build Status](https://secure.travis-ci.org/bkaradzic/go-lz4.png)](http://travis-ci.org/bkaradzic/go-lz4)  
+[![GoDoc](https://godoc.org/github.com/bkaradzic/go-lz4?status.png)](https://godoc.org/github.com/bkaradzic/go-lz4)
+
+Usage
+-----
+
+    go get github.com/bkaradzic/go-lz4
+
+    import "github.com/bkaradzic/go-lz4"
+
+The package name is `lz4`
+
+Notes
+-----
+
+* go-lz4 saves a uint32 with the original uncompressed length at the beginning
+  of the encoded buffer.  They may get in the way of interoperability with
+  other implementations.
+
+Contributors
+------------
+
+Damian Gryski ([@dgryski](https://github.com/dgryski))  
+Dustin Sallings ([@dustin](https://github.com/dustin))
+
+Contact
+-------
+
+[@bkaradzic](https://twitter.com/bkaradzic)  
+http://www.stuckingeometry.com
+
+Project page  
+https://github.com/bkaradzic/go-lz4
+
+License
+-------
+
+Copyright 2011-2012 Branimir Karadzic. All rights reserved.  
+Copyright 2013 Damian Gryski. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+   1. Redistributions of source code must retain the above copyright notice, this
+      list of conditions and the following disclaimer.
+
+   2. 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.
+
+THIS SOFTWARE IS PROVIDED BY COPYRIGHT HOLDER ``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 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.
+

Godeps/_workspace/src/github.com/bkaradzic/go-lz4/fuzzer/main.go

@@ -0,0 +1,74 @@
+package main
+
+import (
+	"math/rand"
+
+	"github.com/bkaradzic/go-lz4"
+
+	// lz4's API matches snappy's, so we can easily see how it performs
+	// lz4 "code.google.com/p/snappy-go/snappy"
+)
+
+var input = `
+ADVENTURE I. A SCANDAL IN BOHEMIA
+
+I.
+
+To Sherlock Holmes she is always THE woman. I have seldom heard
+him mention her under any other name. In his eyes she eclipses
+and predominates the whole of her sex. It was not that he felt
+any emotion akin to love for Irene Adler. All emotions, and that
+one particularly, were abhorrent to his cold, precise but
+admirably balanced mind. He was, I take it, the most perfect
+reasoning and observing machine that the world has seen, but as a
+lover he would have placed himself in a false position. He never
+spoke of the softer passions, save with a gibe and a sneer. They
+were admirable things for the observer--excellent for drawing the
+veil from men's motives and actions. But for the trained reasoner
+to admit such intrusions into his own delicate and finely
+adjusted temperament was to introduce a distracting factor which
+might throw a doubt upon all his mental results. Grit in a
+sensitive instrument, or a crack in one of his own high-power
+lenses, would not be more disturbing than a strong emotion in a
+nature such as his. And yet there was but one woman to him, and
+that woman was the late Irene Adler, of dubious and questionable
+memory.
+
+I had seen little of Holmes lately. My marriage had drifted us
+away from each other. My own complete happiness, and the
+home-centred interests which rise up around the man who first
+finds himself master of his own establishment, were sufficient to
+absorb all my attention, while Holmes, who loathed every form of
+society with his whole Bohemian soul, remained in our lodgings in
+Baker Street, buried among his old books, and alternating from
+week to week between cocaine and ambition, the drowsiness of the
+drug, and the fierce energy of his own keen nature. He was still,
+as ever, deeply attracted by the study of crime, and occupied his
+immense faculties and extraordinary powers of observation in
+following out those clues, and clearing up those mysteries which
+had been abandoned as hopeless by the official police. From time
+to time I heard some vague account of his doings: of his summons
+to Odessa in the case of the Trepoff murder, of his clearing up
+of the singular tragedy of the Atkinson brothers at Trincomalee,
+and finally of the mission which he had accomplished so
+delicately and successfully for the reigning family of Holland.
+Beyond these signs of his activity, however, which I merely
+shared with all the readers of the daily press, I knew little of
+my former friend and companion.
+`
+
+func main() {
+
+	compressed, _ := lz4.Encode(nil, []byte(input))
+
+	modified := make([]byte, len(compressed))
+
+	for {
+		copy(modified, compressed)
+		for i := 0; i < 100; i++ {
+			modified[rand.Intn(len(compressed)-4)+4] = byte(rand.Intn(256))
+		}
+		lz4.Decode(nil, modified)
+	}
+
+}

Godeps/_workspace/src/github.com/bkaradzic/go-lz4/lz4-example/main.go

@@ -0,0 +1,94 @@
+/*
+ * Copyright 2011 Branimir Karadzic. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ *
+ *    1. Redistributions of source code must retain the above copyright notice, this
+ *       list of conditions and the following disclaimer.
+ *
+ *    2. 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.
+ *
+ * THIS SOFTWARE IS PROVIDED BY COPYRIGHT HOLDER ``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 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.
+ */
+
+package main
+
+import (
+	"flag"
+	"fmt"
+	"io/ioutil"
+	"log"
+	"os"
+	"runtime/pprof"
+
+	lz4 "github.com/bkaradzic/go-lz4"
+)
+
+var (
+	decompress = flag.Bool("d", false, "decompress")
+)
+
+func main() {
+
+	var optCPUProfile = flag.String("cpuprofile", "", "profile")
+	flag.Parse()
+
+	if *optCPUProfile != "" {
+		f, err := os.Create(*optCPUProfile)
+		if err != nil {
+			log.Fatal(err)
+		}
+		pprof.StartCPUProfile(f)
+		defer pprof.StopCPUProfile()
+	}
+
+	args := flag.Args()
+
+	var data []byte
+
+	if len(args) < 2 {
+		fmt.Print("Usage: lz4 [-d] <input> <output>\n")
+		os.Exit(1)
+	}
+
+	input, err := os.OpenFile(args[0], os.O_RDONLY, 0644)
+	if err != nil {
+		fmt.Printf("Failed to open input file %s\n", args[0])
+		os.Exit(1)
+	}
+	defer input.Close()
+
+	if *decompress {
+		data, _ = ioutil.ReadAll(input)
+		data, err = lz4.Decode(nil, data)
+		if err != nil {
+			fmt.Println("Failed to decode:", err)
+			return
+		}
+	} else {
+		data, _ = ioutil.ReadAll(input)
+		data, err = lz4.Encode(nil, data)
+		if err != nil {
+			fmt.Println("Failed to encode:", err)
+			return
+		}
+	}
+
+	err = ioutil.WriteFile(args[1], data, 0644)
+	if err != nil {
+		fmt.Printf("Failed to open output file %s\n", args[1])
+		os.Exit(1)
+	}
+}

Godeps/_workspace/src/github.com/bkaradzic/go-lz4/lz4_test.go

@@ -0,0 +1,63 @@
+package lz4
+
+import (
+	"bytes"
+	"io/ioutil"
+	"testing"
+)
+
+var testfile, _ = ioutil.ReadFile("testdata/pg1661.txt")
+
+func roundtrip(t *testing.T, input []byte) {
+
+	dst, err := Encode(nil, input)
+	if err != nil {
+		t.Errorf("got error during compression: %s", err)
+	}
+
+	output, err := Decode(nil, dst)
+
+	if err != nil {
+		t.Errorf("got error during decompress: %s", err)
+	}
+
+	if !bytes.Equal(output, input) {
+		t.Errorf("roundtrip failed")
+	}
+}
+
+func TestEmpty(t *testing.T) {
+	roundtrip(t, nil)
+}
+
+func TestLengths(t *testing.T) {
+
+	for i := 0; i < 1024; i++ {
+		roundtrip(t, testfile[:i])
+	}
+
+	for i := 1024; i < 4096; i += 23 {
+		roundtrip(t, testfile[:i])
+	}
+}
+
+func TestWords(t *testing.T) {
+	roundtrip(t, testfile)
+}
+
+func BenchmarkLZ4Encode(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		Encode(nil, testfile)
+	}
+}
+
+func BenchmarkLZ4Decode(b *testing.B) {
+
+	var compressed, _ = Encode(nil, testfile)
+
+	b.ResetTimer()
+
+	for i := 0; i < b.N; i++ {
+		Decode(nil, compressed)
+	}
+}

Godeps/_workspace/src/github.com/bkaradzic/go-lz4/reader.go

@@ -0,0 +1,194 @@
+/*
+ * Copyright 2011-2012 Branimir Karadzic. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ *
+ *    1. Redistributions of source code must retain the above copyright notice, this
+ *       list of conditions and the following disclaimer.
+ *
+ *    2. 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.
+ *
+ * THIS SOFTWARE IS PROVIDED BY COPYRIGHT HOLDER ``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 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.
+ */
+
+package lz4
+
+import (
+	"encoding/binary"
+	"errors"
+	"io"
+)
+
+var (
+	// ErrCorrupt indicates the input was corrupt
+	ErrCorrupt = errors.New("corrupt input")
+)
+
+const (
+	mlBits  = 4
+	mlMask  = (1 << mlBits) - 1
+	runBits = 8 - mlBits
+	runMask = (1 << runBits) - 1
+)
+
+type decoder struct {
+	src  []byte
+	dst  []byte
+	spos uint32
+	dpos uint32
+	ref  uint32
+}
+
+func (d *decoder) readByte() (uint8, error) {
+	if int(d.spos) == len(d.src) {
+		return 0, io.EOF
+	}
+	b := d.src[d.spos]
+	d.spos++
+	return b, nil
+}
+
+func (d *decoder) getLen() (uint32, error) {
+
+	length := uint32(0)
+	ln, err := d.readByte()
+	if err != nil {
+		return 0, ErrCorrupt
+	}
+	for ln == 255 {
+		length += 255
+		ln, err = d.readByte()
+		if err != nil {
+			return 0, ErrCorrupt
+		}
+	}
+	length += uint32(ln)
+
+	return length, nil
+}
+
+func (d *decoder) cp(length, decr uint32) {
+
+	if int(d.ref+length) < int(d.dpos) {
+		copy(d.dst[d.dpos:], d.dst[d.ref:d.ref+length])
+	} else {
+		for ii := uint32(0); ii < length; ii++ {
+			d.dst[d.dpos+ii] = d.dst[d.ref+ii]
+		}
+	}
+	d.dpos += length
+	d.ref += length - decr
+}
+
+func (d *decoder) finish(err error) error {
+	if err == io.EOF {
+		return nil
+	}
+
+	return err
+}
+
+// Decode returns the decoded form of src.  The returned slice may be a
+// subslice of dst if it was large enough to hold the entire decoded block.
+func Decode(dst, src []byte) ([]byte, error) {
+
+	if len(src) < 4 {
+		return nil, ErrCorrupt
+	}
+
+	uncompressedLen := binary.LittleEndian.Uint32(src)
+
+	if uncompressedLen == 0 {
+		return nil, nil
+	}
+
+	if uncompressedLen > MaxInputSize {
+		return nil, ErrTooLarge
+	}
+
+	if dst == nil || len(dst) < int(uncompressedLen) {
+		dst = make([]byte, uncompressedLen)
+	}
+
+	d := decoder{src: src, dst: dst[:uncompressedLen], spos: 4}
+
+	decr := []uint32{0, 3, 2, 3}
+
+	for {
+		code, err := d.readByte()
+		if err != nil {
+			return d.dst, d.finish(err)
+		}
+
+		length := uint32(code >> mlBits)
+		if length == runMask {
+			ln, err := d.getLen()
+			if err != nil {
+				return nil, ErrCorrupt
+			}
+			length += ln
+		}
+
+		if int(d.spos+length) > len(d.src) {
+			return nil, ErrCorrupt
+		}
+
+		for ii := uint32(0); ii < length; ii++ {
+			d.dst[d.dpos+ii] = d.src[d.spos+ii]
+		}
+
+		d.spos += length
+		d.dpos += length
+
+		if int(d.spos) == len(d.src) {
+			return d.dst, nil
+		}
+
+		if int(d.spos+2) >= len(d.src) {
+			return nil, ErrCorrupt
+		}
+
+		back := uint32(d.src[d.spos]) | uint32(d.src[d.spos+1])<<8
+
+		if back > d.dpos {
+			return nil, ErrCorrupt
+		}
+
+		d.spos += 2
+		d.ref = d.dpos - back
+
+		length = uint32(code & mlMask)
+		if length == mlMask {
+			ln, err := d.getLen()
+			if err != nil {
+				return nil, ErrCorrupt
+			}
+			length += ln
+		}
+
+		literal := d.dpos - d.ref
+		if literal < 4 {
+			d.cp(4, decr[literal])
+		} else {
+			length += 4
+		}
+
+		if d.dpos+length > uncompressedLen {
+			return nil, ErrCorrupt
+		}
+
+		d.cp(length, 0)
+	}
+}

Godeps/_workspace/src/github.com/bkaradzic/go-lz4/writer.go

@@ -0,0 +1,188 @@
+/*
+ * Copyright 2011-2012 Branimir Karadzic. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ *
+ *    1. Redistributions of source code must retain the above copyright notice, this
+ *       list of conditions and the following disclaimer.
+ *
+ *    2. 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.
+ *
+ * THIS SOFTWARE IS PROVIDED BY COPYRIGHT HOLDER ``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 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.
+ */
+
+package lz4
+
+import "encoding/binary"
+import "errors"
+
+const (
+	minMatch              = 4
+	hashLog               = 17
+	hashTableSize         = 1 << hashLog
+	hashShift             = (minMatch * 8) - hashLog
+	incompressible uint32 = 128
+	uninitHash            = 0x88888888
+
+	// MaxInputSize is the largest buffer than can be compressed in a single block
+	MaxInputSize = 0x7E000000
+)
+
+var (
+	// ErrTooLarge indicates the input buffer was too large
+	ErrTooLarge = errors.New("input too large")
+)
+
+type encoder struct {
+	src       []byte
+	dst       []byte
+	hashTable []uint32
+	pos       uint32
+	anchor    uint32
+	dpos      uint32
+}
+
+// CompressBound returns the maximum length of a lz4 block, given it's uncompressed length
+func CompressBound(isize int) int {
+	if isize > MaxInputSize {
+		return 0
+	}
+	return isize + ((isize) / 255) + 16 + 4
+}
+
+func (e *encoder) writeLiterals(length, mlLen, pos uint32) {
+
+	ln := length
+
+	var code byte
+	if ln > runMask-1 {
+		code = runMask
+	} else {
+		code = byte(ln)
+	}
+
+	if mlLen > mlMask-1 {
+		e.dst[e.dpos] = (code << mlBits) + byte(mlMask)
+	} else {
+		e.dst[e.dpos] = (code << mlBits) + byte(mlLen)
+	}
+	e.dpos++
+
+	if code == runMask {
+		ln -= runMask
+		for ; ln > 254; ln -= 255 {
+			e.dst[e.dpos] = 255
+			e.dpos++
+		}
+
+		e.dst[e.dpos] = byte(ln)
+		e.dpos++
+	}
+
+	for ii := uint32(0); ii < length; ii++ {
+		e.dst[e.dpos+ii] = e.src[pos+ii]
+	}
+
+	e.dpos += length
+}
+
+// Encode returns the encoded form of src.  The returned array may be a
+// sub-slice of dst if it was large enough to hold the entire output.
+func Encode(dst, src []byte) ([]byte, error) {
+
+	if len(src) >= MaxInputSize {
+		return nil, ErrTooLarge
+	}
+
+	if n := CompressBound(len(src)); len(dst) < n {
+		dst = make([]byte, n)
+	}
+
+	e := encoder{src: src, dst: dst, hashTable: make([]uint32, hashTableSize)}
+
+	binary.LittleEndian.PutUint32(dst, uint32(len(src)))
+	e.dpos = 4
+
+	var (
+		step  uint32 = 1
+		limit        = incompressible
+	)
+
+	for {
+		if int(e.pos)+12 >= len(e.src) {
+			e.writeLiterals(uint32(len(e.src))-e.anchor, 0, e.anchor)
+			return e.dst[:e.dpos], nil
+		}
+
+		sequence := uint32(e.src[e.pos+3])<<24 | uint32(e.src[e.pos+2])<<16 | uint32(e.src[e.pos+1])<<8 | uint32(e.src[e.pos+0])
+
+		hash := (sequence * 2654435761) >> hashShift
+		ref := e.hashTable[hash] + uninitHash
+		e.hashTable[hash] = e.pos - uninitHash
+
+		if ((e.pos-ref)>>16) != 0 || uint32(e.src[ref+3])<<24|uint32(e.src[ref+2])<<16|uint32(e.src[ref+1])<<8|uint32(e.src[ref+0]) != sequence {
+			if e.pos-e.anchor > limit {
+				limit <<= 1
+				step += 1 + (step >> 2)
+			}
+			e.pos += step
+			continue
+		}
+
+		if step > 1 {
+			e.hashTable[hash] = ref - uninitHash
+			e.pos -= step - 1
+			step = 1
+			continue
+		}
+		limit = incompressible
+
+		ln := e.pos - e.anchor
+		back := e.pos - ref
+
+		anchor := e.anchor
+
+		e.pos += minMatch
+		ref += minMatch
+		e.anchor = e.pos
+
+		for int(e.pos) < len(e.src)-5 && e.src[e.pos] == e.src[ref] {
+			e.pos++
+			ref++
+		}
+
+		mlLen := e.pos - e.anchor
+
+		e.writeLiterals(ln, mlLen, anchor)
+		e.dst[e.dpos] = uint8(back)
+		e.dst[e.dpos+1] = uint8(back >> 8)
+		e.dpos += 2
+
+		if mlLen > mlMask-1 {
+			mlLen -= mlMask
+			for mlLen > 254 {
+				mlLen -= 255
+
+				e.dst[e.dpos] = 255
+				e.dpos++
+			}
+
+			e.dst[e.dpos] = byte(mlLen)
+			e.dpos++
+		}
+
+		e.anchor = e.pos
+	}
+}

Godeps/_workspace/src/github.com/calmh/ini/README.md

@@ -1,39 +0,0 @@
-ini [![Build Status](https://drone.io/github.com/calmh/ini/status.png)](https://drone.io/github.com/calmh/ini/latest)
-===
-
-Yet another .INI file parser / writer. Created because the existing ones
-were either not general enough (allowing easy access to all parts of the
-original file) or made annoying assumptions about the format. And
-probably equal parts NIH. You might want to just write your own instead
-of using this one, you know that's where you'll end up in the end
-anyhow.
-
-Documentation
--------------
-
-http://godoc.org/github.com/calmh/ini
-
-Example
--------
-
-```go
-fd, _ := os.Open("foo.ini")
-cfg := ini.Parse(fd)
-fd.Close()
-
-val := cfg.Get("general", "foo")
-cfg.Set("general", "bar", "baz")
-
-fd, _ = os.Create("bar.ini")
-err := cfg.Write(fd)
-if err != nil {
-	// ...
-}
-err = fd.Close()
-
-```
-
-License
--------
-
-MIT

Godeps/_workspace/src/github.com/calmh/ini/ini.go

@@ -1,235 +0,0 @@
-// Package ini provides trivial parsing of .INI format files.
-package ini
-
-import (
-	"bufio"
-	"fmt"
-	"io"
-	"regexp"
-	"strconv"
-	"strings"
-)
-
-// Config is a parsed INI format file.
-type Config struct {
-	sections []section
-	comments []string
-}
-
-type section struct {
-	name     string
-	comments []string
-	options  []option
-}
-
-type option struct {
-	name, value string
-}
-
-var (
-	iniSectionRe = regexp.MustCompile(`^\[(.+)\]$`)
-	iniOptionRe  = regexp.MustCompile(`^([^\s=]+)\s*=\s*(.+?)$`)
-)
-
-// Sections returns the list of sections in the file.
-func (c *Config) Sections() []string {
-	var sections []string
-	for _, sect := range c.sections {
-		sections = append(sections, sect.name)
-	}
-	return sections
-}
-
-// Options returns the list of options in a given section.
-func (c *Config) Options(section string) []string {
-	var options []string
-	for _, sect := range c.sections {
-		if sect.name == section {
-			for _, opt := range sect.options {
-				options = append(options, opt.name)
-			}
-			break
-		}
-	}
-	return options
-}
-
-// OptionMap returns the map option => value for a given section.
-func (c *Config) OptionMap(section string) map[string]string {
-	options := make(map[string]string)
-	for _, sect := range c.sections {
-		if sect.name == section {
-			for _, opt := range sect.options {
-				options[opt.name] = opt.value
-			}
-			break
-		}
-	}
-	return options
-}
-
-// Comments returns the list of comments in a given section.
-// For the empty string, returns the file comments.
-func (c *Config) Comments(section string) []string {
-	if section == "" {
-		return c.comments
-	}
-	for _, sect := range c.sections {
-		if sect.name == section {
-			return sect.comments
-		}
-	}
-	return nil
-}
-
-// AddComments appends the comment to the list of comments for the section.
-func (c *Config) AddComment(sect, comment string) {
-	if sect == "" {
-		c.comments = append(c.comments, comment)
-		return
-	}
-
-	for i, s := range c.sections {
-		if s.name == sect {
-			c.sections[i].comments = append(s.comments, comment)
-			return
-		}
-	}
-
-	c.sections = append(c.sections, section{
-		name:     sect,
-		comments: []string{comment},
-	})
-}
-
-// Parse reads the given io.Reader and returns a parsed Config object.
-func Parse(stream io.Reader) Config {
-	var cfg Config
-	var curSection string
-
-	scanner := bufio.NewScanner(bufio.NewReader(stream))
-	for scanner.Scan() {
-		line := strings.TrimSpace(scanner.Text())
-		if strings.HasPrefix(line, "#") || strings.HasPrefix(line, ";") {
-			comment := strings.TrimLeft(line, ";# ")
-			cfg.AddComment(curSection, comment)
-		} else if len(line) > 0 {
-			if m := iniSectionRe.FindStringSubmatch(line); len(m) > 0 {
-				curSection = m[1]
-			} else if m := iniOptionRe.FindStringSubmatch(line); len(m) > 0 {
-				key := m[1]
-				val := m[2]
-				if !strings.Contains(val, "\"") {
-					// If val does not contain any quote characers, we can make it
-					// a quoted string and safely let strconv.Unquote sort out any
-					// escapes
-					val = "\"" + val + "\""
-				}
-				if val[0] == '"' {
-					val, _ = strconv.Unquote(val)
-				}
-
-				cfg.Set(curSection, key, val)
-			}
-		}
-	}
-	return cfg
-}
-
-// Write writes the sections and options to the io.Writer in INI format.
-func (c *Config) Write(out io.Writer) error {
-	for _, cmt := range c.comments {
-		fmt.Fprintln(out, "; "+cmt)
-	}
-	if len(c.comments) > 0 {
-		fmt.Fprintln(out)
-	}
-
-	for _, sect := range c.sections {
-		fmt.Fprintf(out, "[%s]\n", sect.name)
-		for _, cmt := range sect.comments {
-			fmt.Fprintln(out, "; "+cmt)
-		}
-		for _, opt := range sect.options {
-			val := opt.value
-			if len(val) == 0 {
-				continue
-			}
-
-			// Quote the string if it begins or ends with space
-			needsQuoting := val[0] == ' ' || val[len(val)-1] == ' '
-
-			if !needsQuoting {
-				// Quote the string if it contains any unprintable characters
-				for _, r := range val {
-					if !strconv.IsPrint(r) {
-						needsQuoting = true
-						break
-					}
-				}
-			}
-
-			if needsQuoting {
-				val = strconv.Quote(val)
-			}
-
-			fmt.Fprintf(out, "%s=%s\n", opt.name, val)
-		}
-		fmt.Fprintln(out)
-	}
-	return nil
-}
-
-// Get gets the value from the specified section and key name, or the empty
-// string if either the section or the key is missing.
-func (c *Config) Get(section, key string) string {
-	for _, sect := range c.sections {
-		if sect.name == section {
-			for _, opt := range sect.options {
-				if opt.name == key {
-					return opt.value
-				}
-			}
-			return ""
-		}
-	}
-	return ""
-}
-
-// Set sets a value for an option in a section. If the option exists, it's
-// value will be overwritten. If the option does not exist, it will be added.
-// If the section does not exist, it will be added and the option added to it.
-func (c *Config) Set(sectionName, key, value string) {
-	for i, sect := range c.sections {
-		if sect.name == sectionName {
-			for j, opt := range sect.options {
-				if opt.name == key {
-					c.sections[i].options[j].value = value
-					return
-				}
-			}
-			c.sections[i].options = append(sect.options, option{key, value})
-			return
-		}
-	}
-
-	c.sections = append(c.sections, section{
-		name:    sectionName,
-		options: []option{{key, value}},
-	})
-}
-
-// Delete removes the option from the specified section.
-func (c *Config) Delete(section, key string) {
-	for sn, sect := range c.sections {
-		if sect.name == section {
-			for i, opt := range sect.options {
-				if opt.name == key {
-					c.sections[sn].options = append(sect.options[:i], sect.options[i+1:]...)
-					return
-				}
-			}
-			return
-		}
-	}
-}

Godeps/_workspace/src/github.com/calmh/ini/ini_test.go

@@ -1,214 +0,0 @@
-package ini_test
-
-import (
-	"bytes"
-	"strings"
-	"testing"
-
-	"github.com/calmh/ini"
-)
-
-func TestParseValues(t *testing.T) {
-	strs := []string{
-		`[general]`,
-		`k1=v1`,
-		`k2 = v2`,
-		` k3 = v3 `,
-		`k4=" quoted spaces "`,
-		`k5 = " quoted spaces " `,
-		`k6 = with\nnewline`,
-		`k7 = "with\nnewline"`,
-		`k8 = a "quoted" word`,
-		`k9 = "a \"quoted\" word"`,
-	}
-	buf := bytes.NewBufferString(strings.Join(strs, "\n"))
-	cfg := ini.Parse(buf)
-
-	correct := map[string]string{
-		"k1": "v1",
-		"k2": "v2",
-		"k3": "v3",
-		"k4": " quoted spaces ",
-		"k5": " quoted spaces ",
-		"k6": "with\nnewline",
-		"k7": "with\nnewline",
-		"k8": "a \"quoted\" word",
-		"k9": "a \"quoted\" word",
-	}
-
-	for k, v := range correct {
-		if v2 := cfg.Get("general", k); v2 != v {
-			t.Errorf("Incorrect general.%s, %q != %q", k, v2, v)
-		}
-	}
-
-	if v := cfg.Get("general", "nonexistant"); v != "" {
-		t.Errorf("Unexpected non-empty value %q", v)
-	}
-}
-
-func TestParseComments(t *testing.T) {
-	strs := []string{
-		";file comment 1",   // No leading space
-		"; file comment 2 ", // Trailing space
-		";  file comment 3", // Multiple leading spaces
-		"[general]",
-		"; b general comment 1", // Comments in unsorted order
-		"somekey = somevalue",
-		"; a general comment 2",
-		"[other]",
-		"; other comment 1", // Comments in section with no values
-		"; other comment 2",
-		"[other2]",
-		"; other2 comment 1",
-		"; other2 comment 2", // Comments on last section
-		"somekey = somevalue",
-	}
-	buf := bytes.NewBufferString(strings.Join(strs, "\n"))
-
-	correct := map[string][]string{
-		"":        []string{"file comment 1", "file comment 2", "file comment 3"},
-		"general": []string{"b general comment 1", "a general comment 2"},
-		"other":   []string{"other comment 1", "other comment 2"},
-		"other2":  []string{"other2 comment 1", "other2 comment 2"},
-	}
-
-	cfg := ini.Parse(buf)
-
-	for section, comments := range correct {
-		cmts := cfg.Comments(section)
-		if len(cmts) != len(comments) {
-			t.Errorf("Incorrect number of comments for section %q: %d != %d", section, len(cmts), len(comments))
-		} else {
-			for i := range comments {
-				if cmts[i] != comments[i] {
-					t.Errorf("Incorrect comment: %q != %q", cmts[i], comments[i])
-				}
-			}
-		}
-	}
-}
-
-func TestWrite(t *testing.T) {
-	cfg := ini.Config{}
-	cfg.Set("general", "k1", "v1")
-	cfg.Set("general", "k2", "foo bar")
-	cfg.Set("general", "k3", " foo bar ")
-	cfg.Set("general", "k4", "foo\nbar")
-
-	var out bytes.Buffer
-	cfg.Write(&out)
-
-	correct := `[general]
-k1=v1
-k2=foo bar
-k3=" foo bar "
-k4="foo\nbar"
-
-`
-	if s := out.String(); s != correct {
-		t.Errorf("Incorrect written .INI:\n%s\ncorrect:\n%s", s, correct)
-	}
-}
-
-func TestSet(t *testing.T) {
-	buf := bytes.NewBufferString("[general]\nfoo=bar\nfoo2=bar2\n")
-	cfg := ini.Parse(buf)
-
-	cfg.Set("general", "foo", "baz")  // Overwrite existing
-	cfg.Set("general", "baz", "quux") // Create new value
-	cfg.Set("other", "baz2", "quux2") // Create new section + value
-
-	var out bytes.Buffer
-	cfg.Write(&out)
-
-	correct := `[general]
-foo=baz
-foo2=bar2
-baz=quux
-
-[other]
-baz2=quux2
-
-`
-
-	if s := out.String(); s != correct {
-		t.Errorf("Incorrect INI after set:\n%s", s)
-	}
-}
-
-func TestDelete(t *testing.T) {
-	buf := bytes.NewBufferString("[general]\nfoo=bar\nfoo2=bar2\nfoo3=baz\n")
-	cfg := ini.Parse(buf)
-	cfg.Delete("general", "foo")
-	out := new(bytes.Buffer)
-	cfg.Write(out)
-	correct := "[general]\nfoo2=bar2\nfoo3=baz\n\n"
-
-	if s := out.String(); s != correct {
-		t.Errorf("Incorrect INI after delete:\n%s", s)
-	}
-
-	buf = bytes.NewBufferString("[general]\nfoo=bar\nfoo2=bar2\nfoo3=baz\n")
-	cfg = ini.Parse(buf)
-	cfg.Delete("general", "foo2")
-	out = new(bytes.Buffer)
-	cfg.Write(out)
-	correct = "[general]\nfoo=bar\nfoo3=baz\n\n"
-
-	if s := out.String(); s != correct {
-		t.Errorf("Incorrect INI after delete:\n%s", s)
-	}
-
-	buf = bytes.NewBufferString("[general]\nfoo=bar\nfoo2=bar2\nfoo3=baz\n")
-	cfg = ini.Parse(buf)
-	cfg.Delete("general", "foo3")
-	out = new(bytes.Buffer)
-	cfg.Write(out)
-	correct = "[general]\nfoo=bar\nfoo2=bar2\n\n"
-
-	if s := out.String(); s != correct {
-		t.Errorf("Incorrect INI after delete:\n%s", s)
-	}
-}
-
-func TestSetManyEquals(t *testing.T) {
-	buf := bytes.NewBufferString("[general]\nfoo=bar==\nfoo2=bar2==\n")
-	cfg := ini.Parse(buf)
-
-	cfg.Set("general", "foo", "baz==")
-
-	var out bytes.Buffer
-	cfg.Write(&out)
-
-	correct := `[general]
-foo=baz==
-foo2=bar2==
-
-`
-
-	if s := out.String(); s != correct {
-		t.Errorf("Incorrect INI after set:\n%s", s)
-	}
-}
-
-func TestRewriteDuplicate(t *testing.T) {
-	buf := bytes.NewBufferString("[general]\nfoo=bar==\nfoo=bar2==\n")
-	cfg := ini.Parse(buf)
-
-	if v := cfg.Get("general", "foo"); v != "bar2==" {
-		t.Errorf("incorrect get %q", v)
-	}
-
-	var out bytes.Buffer
-	cfg.Write(&out)
-
-	correct := `[general]
-foo=bar2==
-
-`
-
-	if s := out.String(); s != correct {
-		t.Errorf("Incorrect INI after set:\n%s", s)
-	}
-}

Godeps/_workspace/src/github.com/calmh/logger/README.md

@@ -0,0 +1,15 @@
+logger
+======
+
+A small wrapper around `log` to provide log levels.
+
+Documentation
+-------------
+
+http://godoc.org/github.com/calmh/logger
+
+License
+-------
+
+MIT
+

Godeps/_workspace/src/github.com/calmh/logger/logger.go

@@ -0,0 +1,160 @@
+// Copyright (C) 2014 Jakob Borg. All rights reserved. Use of this source code
+// is governed by an MIT-style license that can be found in the LICENSE file.
+
+// Package logger implements a standardized logger with callback functionality
+package logger
+
+import (
+	"fmt"
+	"log"
+	"os"
+	"strings"
+	"sync"
+)
+
+type LogLevel int
+
+const (
+	LevelDebug LogLevel = iota
+	LevelInfo
+	LevelOK
+	LevelWarn
+	LevelFatal
+	NumLevels
+)
+
+// A MessageHandler is called with the log level and message text.
+type MessageHandler func(l LogLevel, msg string)
+
+type Logger struct {
+	logger   *log.Logger
+	handlers [NumLevels][]MessageHandler
+	mut      sync.Mutex
+}
+
+// The default logger logs to standard output with a time prefix.
+var DefaultLogger = New()
+
+func New() *Logger {
+	return &Logger{
+		logger: log.New(os.Stdout, "", log.Ltime),
+	}
+}
+
+// AddHandler registers a new MessageHandler to receive messages with the
+// specified log level or above.
+func (l *Logger) AddHandler(level LogLevel, h MessageHandler) {
+	l.mut.Lock()
+	defer l.mut.Unlock()
+	l.handlers[level] = append(l.handlers[level], h)
+}
+
+// See log.SetFlags
+func (l *Logger) SetFlags(flag int) {
+	l.logger.SetFlags(flag)
+}
+
+// See log.SetPrefix
+func (l *Logger) SetPrefix(prefix string) {
+	l.logger.SetPrefix(prefix)
+}
+
+func (l *Logger) callHandlers(level LogLevel, s string) {
+	for _, h := range l.handlers[level] {
+		h(level, strings.TrimSpace(s))
+	}
+}
+
+// Debugln logs a line with a DEBUG prefix.
+func (l *Logger) Debugln(vals ...interface{}) {
+	l.mut.Lock()
+	defer l.mut.Unlock()
+	s := fmt.Sprintln(vals...)
+	l.logger.Output(2, "DEBUG: "+s)
+	l.callHandlers(LevelDebug, s)
+}
+
+// Debugf logs a formatted line with a DEBUG prefix.
+func (l *Logger) Debugf(format string, vals ...interface{}) {
+	l.mut.Lock()
+	defer l.mut.Unlock()
+	s := fmt.Sprintf(format, vals...)
+	l.logger.Output(2, "DEBUG: "+s)
+	l.callHandlers(LevelDebug, s)
+}
+
+// Infoln logs a line with an INFO prefix.
+func (l *Logger) Infoln(vals ...interface{}) {
+	l.mut.Lock()
+	defer l.mut.Unlock()
+	s := fmt.Sprintln(vals...)
+	l.logger.Output(2, "INFO: "+s)
+	l.callHandlers(LevelInfo, s)
+}
+
+// Infof logs a formatted line with an INFO prefix.
+func (l *Logger) Infof(format string, vals ...interface{}) {
+	l.mut.Lock()
+	defer l.mut.Unlock()
+	s := fmt.Sprintf(format, vals...)
+	l.logger.Output(2, "INFO: "+s)
+	l.callHandlers(LevelInfo, s)
+}
+
+// Okln logs a line with an OK prefix.
+func (l *Logger) Okln(vals ...interface{}) {
+	l.mut.Lock()
+	defer l.mut.Unlock()
+	s := fmt.Sprintln(vals...)
+	l.logger.Output(2, "OK: "+s)
+	l.callHandlers(LevelOK, s)
+}
+
+// Okf logs a formatted line with an OK prefix.
+func (l *Logger) Okf(format string, vals ...interface{}) {
+	l.mut.Lock()
+	defer l.mut.Unlock()
+	s := fmt.Sprintf(format, vals...)
+	l.logger.Output(2, "OK: "+s)
+	l.callHandlers(LevelOK, s)
+}
+
+// Warnln logs a formatted line with a WARNING prefix.
+func (l *Logger) Warnln(vals ...interface{}) {
+	l.mut.Lock()
+	defer l.mut.Unlock()
+	s := fmt.Sprintln(vals...)
+	l.logger.Output(2, "WARNING: "+s)
+	l.callHandlers(LevelWarn, s)
+}
+
+// Warnf logs a formatted line with a WARNING prefix.
+func (l *Logger) Warnf(format string, vals ...interface{}) {
+	l.mut.Lock()
+	defer l.mut.Unlock()
+	s := fmt.Sprintf(format, vals...)
+	l.logger.Output(2, "WARNING: "+s)
+	l.callHandlers(LevelWarn, s)
+}
+
+// Fatalln logs a line with a FATAL prefix and exits the process with exit
+// code 1.
+func (l *Logger) Fatalln(vals ...interface{}) {
+	l.mut.Lock()
+	defer l.mut.Unlock()
+	s := fmt.Sprintln(vals...)
+	l.logger.Output(2, "FATAL: "+s)
+	l.callHandlers(LevelFatal, s)
+	os.Exit(1)
+}
+
+// Fatalf logs a formatted line with a FATAL prefix and exits the process with
+// exit code 1.
+func (l *Logger) Fatalf(format string, vals ...interface{}) {
+	l.mut.Lock()
+	defer l.mut.Unlock()
+	s := fmt.Sprintf(format, vals...)
+	l.logger.Output(2, "FATAL: "+s)
+	l.callHandlers(LevelFatal, s)
+	os.Exit(1)
+}

Godeps/_workspace/src/github.com/calmh/logger/logger_test.go

@@ -0,0 +1,58 @@
+// Copyright (C) 2014 Jakob Borg. All rights reserved. Use of this source code
+// is governed by an MIT-style license that can be found in the LICENSE file.
+
+package logger
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestAPI(t *testing.T) {
+	l := New()
+	l.SetFlags(0)
+	l.SetPrefix("testing")
+
+	debug := 0
+	l.AddHandler(LevelDebug, checkFunc(t, LevelDebug, "test 0", &debug))
+	info := 0
+	l.AddHandler(LevelInfo, checkFunc(t, LevelInfo, "test 1", &info))
+	warn := 0
+	l.AddHandler(LevelWarn, checkFunc(t, LevelWarn, "test 2", &warn))
+	ok := 0
+	l.AddHandler(LevelOK, checkFunc(t, LevelOK, "test 3", &ok))
+
+	l.Debugf("test %d", 0)
+	l.Debugln("test", 0)
+	l.Infof("test %d", 1)
+	l.Infoln("test", 1)
+	l.Warnf("test %d", 2)
+	l.Warnln("test", 2)
+	l.Okf("test %d", 3)
+	l.Okln("test", 3)
+
+	if debug != 2 {
+		t.Errorf("Debug handler called %d != 2 times", debug)
+	}
+	if info != 2 {
+		t.Errorf("Info handler called %d != 2 times", info)
+	}
+	if warn != 2 {
+		t.Errorf("Warn handler called %d != 2 times", warn)
+	}
+	if ok != 2 {
+		t.Errorf("Ok handler called %d != 2 times", ok)
+	}
+}
+
+func checkFunc(t *testing.T, expectl LogLevel, expectmsg string, counter *int) func(LogLevel, string) {
+	return func(l LogLevel, msg string) {
+		*counter++
+		if l != expectl {
+			t.Errorf("Incorrect message level %d != %d", l, expectl)
+		}
+		if !strings.HasSuffix(msg, expectmsg) {
+			t.Errorf("%q does not end with %q", msg, expectmsg)
+		}
+	}
+}

Godeps/_workspace/src/github.com/calmh/osext/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2012 Daniel Theophanes
+
+This software is provided 'as-is', without any express or implied
+warranty. In no event will the authors be held liable for any damages
+arising from the use of this software.
+
+Permission is granted to anyone to use this software for any purpose,
+including commercial applications, and to alter it and redistribute it
+freely, subject to the following restrictions:
+
+   1. The origin of this software must not be misrepresented; you must not
+   claim that you wrote the original software. If you use this software
+   in a product, an acknowledgment in the product documentation would be
+   appreciated but is not required.
+
+   2. Altered source versions must be plainly marked as such, and must not be
+   misrepresented as being the original software.
+
+   3. This notice may not be removed or altered from any source
+   distribution.

Godeps/_workspace/src/github.com/calmh/osext/osext.go

@@ -0,0 +1,32 @@
+// 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.
+
+// Extensions to the standard "os" package.
+package osext
+
+import "path/filepath"
+
+// Executable returns an absolute path that can be used to
+// re-invoke the current program.
+// It may not be valid after the current program exits.
+func Executable() (string, error) {
+	p, err := executable()
+	return filepath.Clean(p), err
+}
+
+// Returns same path as Executable, returns just the folder
+// path. Excludes the executable name.
+func ExecutableFolder() (string, error) {
+	p, err := Executable()
+	if err != nil {
+		return "", err
+	}
+	folder, _ := filepath.Split(p)
+	return folder, nil
+}
+
+// Depricated. Same as Executable().
+func GetExePath() (exePath string, err error) {
+	return Executable()
+}

Godeps/_workspace/src/github.com/calmh/osext/osext_plan9.go

@@ -0,0 +1,20 @@
+// 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.
+
+package osext
+
+import (
+    "syscall"
+    "os"
+    "strconv"
+)
+
+func executable() (string, error) {
+    f, err := os.Open("/proc/" + strconv.Itoa(os.Getpid()) + "/text")
+    if err != nil {
+        return "", err
+    }
+    defer f.Close()
+    return syscall.Fd2path(int(f.Fd()))
+}

Godeps/_workspace/src/github.com/calmh/osext/osext_procfs.go

@@ -0,0 +1,28 @@
+// 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.
+
+// +build linux netbsd openbsd solaris
+
+package osext
+
+import (
+	"errors"
+	"fmt"
+	"os"
+	"runtime"
+)
+
+func executable() (string, error) {
+	switch runtime.GOOS {
+	case "linux":
+		return os.Readlink("/proc/self/exe")
+	case "netbsd":
+		return os.Readlink("/proc/curproc/exe")
+	case "openbsd":
+		return os.Readlink("/proc/curproc/file")
+	case "solaris":
+		return os.Readlink(fmt.Sprintf("/proc/%d/path/a.out", os.Getpid()))
+	}
+	return "", errors.New("ExecPath not implemented for " + runtime.GOOS)
+}

Godeps/_workspace/src/github.com/calmh/osext/osext_sysctl.go

@@ -0,0 +1,79 @@
+// 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.
+
+// +build darwin freebsd
+
+package osext
+
+import (
+	"os"
+	"path/filepath"
+	"runtime"
+	"syscall"
+	"unsafe"
+)
+
+var initCwd, initCwdErr = os.Getwd()
+
+func executable() (string, error) {
+	var mib [4]int32
+	switch runtime.GOOS {
+	case "freebsd":
+		mib = [4]int32{1 /* CTL_KERN */, 14 /* KERN_PROC */, 12 /* KERN_PROC_PATHNAME */, -1}
+	case "darwin":
+		mib = [4]int32{1 /* CTL_KERN */, 38 /* KERN_PROCARGS */, int32(os.Getpid()), -1}
+	}
+
+	n := uintptr(0)
+	// Get length.
+	_, _, errNum := syscall.Syscall6(syscall.SYS___SYSCTL, uintptr(unsafe.Pointer(&mib[0])), 4, 0, uintptr(unsafe.Pointer(&n)), 0, 0)
+	if errNum != 0 {
+		return "", errNum
+	}
+	if n == 0 { // This shouldn't happen.
+		return "", nil
+	}
+	buf := make([]byte, n)
+	_, _, errNum = syscall.Syscall6(syscall.SYS___SYSCTL, uintptr(unsafe.Pointer(&mib[0])), 4, uintptr(unsafe.Pointer(&buf[0])), uintptr(unsafe.Pointer(&n)), 0, 0)
+	if errNum != 0 {
+		return "", errNum
+	}
+	if n == 0 { // This shouldn't happen.
+		return "", nil
+	}
+	for i, v := range buf {
+		if v == 0 {
+			buf = buf[:i]
+			break
+		}
+	}
+	var err error
+	execPath := string(buf)
+	// execPath will not be empty due to above checks.
+	// Try to get the absolute path if the execPath is not rooted.
+	if execPath[0] != '/' {
+		execPath, err = getAbs(execPath)
+		if err != nil {
+			return execPath, err
+		}
+	}
+	// For darwin KERN_PROCARGS may return the path to a symlink rather than the
+	// actual executable.
+	if runtime.GOOS == "darwin" {
+		if execPath, err = filepath.EvalSymlinks(execPath); err != nil {
+			return execPath, err
+		}
+	}
+	return execPath, nil
+}
+
+func getAbs(execPath string) (string, error) {
+	if initCwdErr != nil {
+		return execPath, initCwdErr
+	}
+	// The execPath may begin with a "../" or a "./" so clean it first.
+	// Join the two paths, trailing and starting slashes undetermined, so use
+	// the generic Join function.
+	return filepath.Join(initCwd, filepath.Clean(execPath)), nil
+}

Godeps/_workspace/src/github.com/calmh/osext/osext_test.go

@@ -0,0 +1,79 @@
+// 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.
+
+// +build darwin linux freebsd netbsd windows
+
+package osext
+
+import (
+	"fmt"
+	"os"
+	oexec "os/exec"
+	"path/filepath"
+	"runtime"
+	"testing"
+)
+
+const execPath_EnvVar = "OSTEST_OUTPUT_EXECPATH"
+
+func TestExecPath(t *testing.T) {
+	ep, err := Executable()
+	if err != nil {
+		t.Fatalf("ExecPath failed: %v", err)
+	}
+	// we want fn to be of the form "dir/prog"
+	dir := filepath.Dir(filepath.Dir(ep))
+	fn, err := filepath.Rel(dir, ep)
+	if err != nil {
+		t.Fatalf("filepath.Rel: %v", err)
+	}
+	cmd := &oexec.Cmd{}
+	// make child start with a relative program path
+	cmd.Dir = dir
+	cmd.Path = fn
+	// forge argv[0] for child, so that we can verify we could correctly
+	// get real path of the executable without influenced by argv[0].
+	cmd.Args = []string{"-", "-test.run=XXXX"}
+	cmd.Env = []string{fmt.Sprintf("%s=1", execPath_EnvVar)}
+	out, err := cmd.CombinedOutput()
+	if err != nil {
+		t.Fatalf("exec(self) failed: %v", err)
+	}
+	outs := string(out)
+	if !filepath.IsAbs(outs) {
+		t.Fatalf("Child returned %q, want an absolute path", out)
+	}
+	if !sameFile(outs, ep) {
+		t.Fatalf("Child returned %q, not the same file as %q", out, ep)
+	}
+}
+
+func sameFile(fn1, fn2 string) bool {
+	fi1, err := os.Stat(fn1)
+	if err != nil {
+		return false
+	}
+	fi2, err := os.Stat(fn2)
+	if err != nil {
+		return false
+	}
+	return os.SameFile(fi1, fi2)
+}
+
+func init() {
+	if e := os.Getenv(execPath_EnvVar); e != "" {
+		// first chdir to another path
+		dir := "/"
+		if runtime.GOOS == "windows" {
+			dir = filepath.VolumeName(".")
+		}
+		os.Chdir(dir)
+		if ep, err := Executable(); err != nil {
+			fmt.Fprint(os.Stderr, "ERROR: ", err)
+		} else {
+			fmt.Fprint(os.Stderr, ep)
+		}
+		os.Exit(0)
+	}
+}

Godeps/_workspace/src/github.com/calmh/osext/osext_windows.go

@@ -0,0 +1,34 @@
+// 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.
+
+package osext
+
+import (
+	"syscall"
+	"unicode/utf16"
+	"unsafe"
+)
+
+var (
+	kernel                = syscall.MustLoadDLL("kernel32.dll")
+	getModuleFileNameProc = kernel.MustFindProc("GetModuleFileNameW")
+)
+
+// GetModuleFileName() with hModule = NULL
+func executable() (exePath string, err error) {
+	return getModuleFileName()
+}
+
+func getModuleFileName() (string, error) {
+	var n uint32
+	b := make([]uint16, syscall.MAX_PATH)
+	size := uint32(len(b))
+
+	r0, _, e1 := getModuleFileNameProc.Call(0, uintptr(unsafe.Pointer(&b[0])), uintptr(size))
+	n = uint32(r0)
+	if n == 0 {
+		return "", e1
+	}
+	return string(utf16.Decode(b[0:n])), nil
+}

Godeps/_workspace/src/github.com/calmh/xdr/.gitignore

@@ -0,0 +1 @@
+coverage.out

Godeps/_workspace/src/github.com/calmh/xdr/.travis.yml

@@ -0,0 +1,19 @@
+language: go
+go:
+- tip
+
+install:
+- export PATH=$PATH:$HOME/gopath/bin
+- go get code.google.com/p/go.tools/cmd/cover
+- go get github.com/mattn/goveralls
+
+script:
+- ./generate.sh
+- go test -coverprofile=coverage.out
+
+after_success:
+- goveralls -coverprofile=coverage.out -service=travis-ci -package=calmh/xdr -repotoken="$COVERALLS_TOKEN"
+
+env:
+  global:
+    secure: SmgnrGfp2zLrA44ChRMpjPeujubt9veZ8Fx/OseMWECmacyV5N/TuDhzIbwo6QwV4xB0sBacoPzvxQbJRVjNKsPiSu72UbcQmQ7flN4Tf7nW09tSh1iW8NgrpBCq/3UYLoBu2iPBEBKm93IK0aGNAKs6oEkB0fU27iTVBwiTXOY=

Godeps/_workspace/src/github.com/calmh/xdr/LICENSE

@@ -0,0 +1,19 @@
+Copyright (C) 2014 Jakob Borg.
+
+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.

Godeps/_workspace/src/github.com/calmh/xdr/README.md

@@ -0,0 +1,12 @@
+xdr
+===
+
+[![Build Status](https://img.shields.io/travis/calmh/xdr.svg?style=flat)](https://travis-ci.org/calmh/xdr)
+[![Coverage Status](https://img.shields.io/coveralls/calmh/xdr.svg?style=flat)](https://coveralls.io/r/calmh/xdr?branch=master)
+[![API Documentation](http://img.shields.io/badge/api-Godoc-blue.svg?style=flat)](http://godoc.org/github.com/calmh/xdr)
+[![MIT License](http://img.shields.io/badge/license-MIT-blue.svg?style=flat)](http://opensource.org/licenses/MIT)
+
+This is an XDR encoding/decoding library. It uses code generation and
+not reflection. It supports the IPDR bastardized XDR format when built
+with `-tags ipdr`.
+