├── .editorconfig
├── .gitignore
├── .travis.yml
├── CHANGELOG
├── LICENSE
├── README.md
├── keygen
    └── keygen.go
├── main.go
├── main_test.go
├── slowseeder
    ├── slowseeder.go
    └── slowseeder_test.go
└── vendor
    ├── github.com
        ├── mikesmitty
        │   └── edkey
        │   │   ├── LICENSE
        │   │   ├── README.md
        │   │   └── edkey.go
        └── mitchellh
        │   └── go-homedir
        │       ├── LICENSE
        │       ├── README.md
        │       ├── go.mod
        │       └── homedir.go
    ├── golang.org
        └── x
        │   ├── crypto
        │       ├── LICENSE
        │       ├── PATENTS
        │       ├── argon2
        │       │   ├── argon2.go
        │       │   ├── blake2b.go
        │       │   ├── blamka_amd64.go
        │       │   ├── blamka_amd64.s
        │       │   ├── blamka_generic.go
        │       │   └── blamka_ref.go
        │       ├── blake2b
        │       │   ├── blake2b.go
        │       │   ├── blake2bAVX2_amd64.go
        │       │   ├── blake2bAVX2_amd64.s
        │       │   ├── blake2b_amd64.go
        │       │   ├── blake2b_amd64.s
        │       │   ├── blake2b_generic.go
        │       │   ├── blake2b_ref.go
        │       │   ├── blake2x.go
        │       │   └── register.go
        │       ├── curve25519
        │       │   ├── const_amd64.h
        │       │   ├── const_amd64.s
        │       │   ├── cswap_amd64.s
        │       │   ├── curve25519.go
        │       │   ├── doc.go
        │       │   ├── freeze_amd64.s
        │       │   ├── ladderstep_amd64.s
        │       │   ├── mont25519_amd64.go
        │       │   ├── mul_amd64.s
        │       │   └── square_amd64.s
        │       ├── ed25519
        │       │   ├── ed25519.go
        │       │   └── internal
        │       │   │   └── edwards25519
        │       │   │       ├── const.go
        │       │   │       └── edwards25519.go
        │       ├── internal
        │       │   ├── chacha20
        │       │   │   ├── chacha_generic.go
        │       │   │   ├── chacha_noasm.go
        │       │   │   ├── chacha_s390x.go
        │       │   │   ├── chacha_s390x.s
        │       │   │   └── xor.go
        │       │   └── subtle
        │       │   │   ├── aliasing.go
        │       │   │   └── aliasing_appengine.go
        │       ├── pbkdf2
        │       │   └── pbkdf2.go
        │       ├── poly1305
        │       │   ├── poly1305.go
        │       │   ├── sum_amd64.go
        │       │   ├── sum_amd64.s
        │       │   ├── sum_arm.go
        │       │   ├── sum_arm.s
        │       │   ├── sum_noasm.go
        │       │   ├── sum_ref.go
        │       │   ├── sum_s390x.go
        │       │   ├── sum_s390x.s
        │       │   └── sum_vmsl_s390x.s
        │       ├── ripemd160
        │       │   ├── ripemd160.go
        │       │   └── ripemd160block.go
        │       └── ssh
        │       │   ├── agent
        │       │       ├── client.go
        │       │       ├── forward.go
        │       │       ├── keyring.go
        │       │       └── server.go
        │       │   ├── buffer.go
        │       │   ├── certs.go
        │       │   ├── channel.go
        │       │   ├── cipher.go
        │       │   ├── client.go
        │       │   ├── client_auth.go
        │       │   ├── common.go
        │       │   ├── connection.go
        │       │   ├── doc.go
        │       │   ├── handshake.go
        │       │   ├── kex.go
        │       │   ├── keys.go
        │       │   ├── mac.go
        │       │   ├── messages.go
        │       │   ├── mux.go
        │       │   ├── server.go
        │       │   ├── session.go
        │       │   ├── streamlocal.go
        │       │   ├── tcpip.go
        │       │   ├── terminal
        │       │       ├── terminal.go
        │       │       ├── util.go
        │       │       ├── util_bsd.go
        │       │       ├── util_linux.go
        │       │       ├── util_plan9.go
        │       │       ├── util_solaris.go
        │       │       └── util_windows.go
        │       │   └── transport.go
        │   └── sys
        │       ├── LICENSE
        │       ├── PATENTS
        │       ├── cpu
        │           ├── cpu.go
        │           ├── cpu_arm.go
        │           ├── cpu_arm64.go
        │           ├── cpu_gc_x86.go
        │           ├── cpu_gccgo.c
        │           ├── cpu_gccgo.go
        │           ├── cpu_mips64x.go
        │           ├── cpu_mipsx.go
        │           ├── cpu_ppc64x.go
        │           ├── cpu_s390x.go
        │           ├── cpu_x86.go
        │           └── cpu_x86.s
        │       ├── unix
        │           ├── README.md
        │           ├── affinity_linux.go
        │           ├── aliases.go
        │           ├── asm_darwin_386.s
        │           ├── asm_darwin_amd64.s
        │           ├── asm_darwin_arm.s
        │           ├── asm_darwin_arm64.s
        │           ├── asm_dragonfly_amd64.s
        │           ├── asm_freebsd_386.s
        │           ├── asm_freebsd_amd64.s
        │           ├── asm_freebsd_arm.s
        │           ├── asm_linux_386.s
        │           ├── asm_linux_amd64.s
        │           ├── asm_linux_arm.s
        │           ├── asm_linux_arm64.s
        │           ├── asm_linux_mips64x.s
        │           ├── asm_linux_mipsx.s
        │           ├── asm_linux_ppc64x.s
        │           ├── asm_linux_s390x.s
        │           ├── asm_netbsd_386.s
        │           ├── asm_netbsd_amd64.s
        │           ├── asm_netbsd_arm.s
        │           ├── asm_openbsd_386.s
        │           ├── asm_openbsd_amd64.s
        │           ├── asm_openbsd_arm.s
        │           ├── asm_solaris_amd64.s
        │           ├── bluetooth_linux.go
        │           ├── cap_freebsd.go
        │           ├── constants.go
        │           ├── dev_aix_ppc.go
        │           ├── dev_aix_ppc64.go
        │           ├── dev_darwin.go
        │           ├── dev_dragonfly.go
        │           ├── dev_freebsd.go
        │           ├── dev_linux.go
        │           ├── dev_netbsd.go
        │           ├── dev_openbsd.go
        │           ├── dirent.go
        │           ├── endian_big.go
        │           ├── endian_little.go
        │           ├── env_unix.go
        │           ├── errors_freebsd_386.go
        │           ├── errors_freebsd_amd64.go
        │           ├── errors_freebsd_arm.go
        │           ├── fcntl.go
        │           ├── fcntl_linux_32bit.go
        │           ├── gccgo.go
        │           ├── gccgo_c.c
        │           ├── gccgo_linux_amd64.go
        │           ├── ioctl.go
        │           ├── mkall.sh
        │           ├── mkerrors.sh
        │           ├── mkpost.go
        │           ├── mksyscall.pl
        │           ├── mksyscall_aix.pl
        │           ├── mksyscall_solaris.pl
        │           ├── mksysctl_openbsd.pl
        │           ├── mksysnum_darwin.pl
        │           ├── mksysnum_dragonfly.pl
        │           ├── mksysnum_freebsd.pl
        │           ├── mksysnum_netbsd.pl
        │           ├── mksysnum_openbsd.pl
        │           ├── openbsd_pledge.go
        │           ├── pagesize_unix.go
        │           ├── race.go
        │           ├── race0.go
        │           ├── sockcmsg_linux.go
        │           ├── sockcmsg_unix.go
        │           ├── str.go
        │           ├── syscall.go
        │           ├── syscall_aix.go
        │           ├── syscall_aix_ppc.go
        │           ├── syscall_aix_ppc64.go
        │           ├── syscall_bsd.go
        │           ├── syscall_darwin.go
        │           ├── syscall_darwin_386.go
        │           ├── syscall_darwin_amd64.go
        │           ├── syscall_darwin_arm.go
        │           ├── syscall_darwin_arm64.go
        │           ├── syscall_dragonfly.go
        │           ├── syscall_dragonfly_amd64.go
        │           ├── syscall_freebsd.go
        │           ├── syscall_freebsd_386.go
        │           ├── syscall_freebsd_amd64.go
        │           ├── syscall_freebsd_arm.go
        │           ├── syscall_linux.go
        │           ├── syscall_linux_386.go
        │           ├── syscall_linux_amd64.go
        │           ├── syscall_linux_amd64_gc.go
        │           ├── syscall_linux_arm.go
        │           ├── syscall_linux_arm64.go
        │           ├── syscall_linux_gc.go
        │           ├── syscall_linux_gc_386.go
        │           ├── syscall_linux_gccgo_386.go
        │           ├── syscall_linux_gccgo_arm.go
        │           ├── syscall_linux_mips64x.go
        │           ├── syscall_linux_mipsx.go
        │           ├── syscall_linux_ppc64x.go
        │           ├── syscall_linux_riscv64.go
        │           ├── syscall_linux_s390x.go
        │           ├── syscall_linux_sparc64.go
        │           ├── syscall_netbsd.go
        │           ├── syscall_netbsd_386.go
        │           ├── syscall_netbsd_amd64.go
        │           ├── syscall_netbsd_arm.go
        │           ├── syscall_openbsd.go
        │           ├── syscall_openbsd_386.go
        │           ├── syscall_openbsd_amd64.go
        │           ├── syscall_openbsd_arm.go
        │           ├── syscall_solaris.go
        │           ├── syscall_solaris_amd64.go
        │           ├── syscall_unix.go
        │           ├── syscall_unix_gc.go
        │           ├── timestruct.go
        │           ├── types_aix.go
        │           ├── types_darwin.go
        │           ├── types_dragonfly.go
        │           ├── types_freebsd.go
        │           ├── types_netbsd.go
        │           ├── types_openbsd.go
        │           ├── types_solaris.go
        │           ├── xattr_bsd.go
        │           ├── zerrors_aix_ppc.go
        │           ├── zerrors_aix_ppc64.go
        │           ├── zerrors_darwin_386.go
        │           ├── zerrors_darwin_amd64.go
        │           ├── zerrors_darwin_arm.go
        │           ├── zerrors_darwin_arm64.go
        │           ├── zerrors_dragonfly_amd64.go
        │           ├── zerrors_freebsd_386.go
        │           ├── zerrors_freebsd_amd64.go
        │           ├── zerrors_freebsd_arm.go
        │           ├── zerrors_linux_386.go
        │           ├── zerrors_linux_amd64.go
        │           ├── zerrors_linux_arm.go
        │           ├── zerrors_linux_arm64.go
        │           ├── zerrors_linux_mips.go
        │           ├── zerrors_linux_mips64.go
        │           ├── zerrors_linux_mips64le.go
        │           ├── zerrors_linux_mipsle.go
        │           ├── zerrors_linux_ppc64.go
        │           ├── zerrors_linux_ppc64le.go
        │           ├── zerrors_linux_riscv64.go
        │           ├── zerrors_linux_s390x.go
        │           ├── zerrors_linux_sparc64.go
        │           ├── zerrors_netbsd_386.go
        │           ├── zerrors_netbsd_amd64.go
        │           ├── zerrors_netbsd_arm.go
        │           ├── zerrors_openbsd_386.go
        │           ├── zerrors_openbsd_amd64.go
        │           ├── zerrors_openbsd_arm.go
        │           ├── zerrors_solaris_amd64.go
        │           ├── zptrace386_linux.go
        │           ├── zptracearm_linux.go
        │           ├── zptracemips_linux.go
        │           ├── zptracemipsle_linux.go
        │           ├── zsyscall_aix_ppc.go
        │           ├── zsyscall_aix_ppc64.go
        │           ├── zsyscall_darwin_386.go
        │           ├── zsyscall_darwin_amd64.go
        │           ├── zsyscall_darwin_arm.go
        │           ├── zsyscall_darwin_arm64.go
        │           ├── zsyscall_dragonfly_amd64.go
        │           ├── zsyscall_freebsd_386.go
        │           ├── zsyscall_freebsd_amd64.go
        │           ├── zsyscall_freebsd_arm.go
        │           ├── zsyscall_linux_386.go
        │           ├── zsyscall_linux_amd64.go
        │           ├── zsyscall_linux_arm.go
        │           ├── zsyscall_linux_arm64.go
        │           ├── zsyscall_linux_mips.go
        │           ├── zsyscall_linux_mips64.go
        │           ├── zsyscall_linux_mips64le.go
        │           ├── zsyscall_linux_mipsle.go
        │           ├── zsyscall_linux_ppc64.go
        │           ├── zsyscall_linux_ppc64le.go
        │           ├── zsyscall_linux_riscv64.go
        │           ├── zsyscall_linux_s390x.go
        │           ├── zsyscall_linux_sparc64.go
        │           ├── zsyscall_netbsd_386.go
        │           ├── zsyscall_netbsd_amd64.go
        │           ├── zsyscall_netbsd_arm.go
        │           ├── zsyscall_openbsd_386.go
        │           ├── zsyscall_openbsd_amd64.go
        │           ├── zsyscall_openbsd_arm.go
        │           ├── zsyscall_solaris_amd64.go
        │           ├── zsysctl_openbsd_386.go
        │           ├── zsysctl_openbsd_amd64.go
        │           ├── zsysctl_openbsd_arm.go
        │           ├── zsysnum_darwin_386.go
        │           ├── zsysnum_darwin_amd64.go
        │           ├── zsysnum_darwin_arm.go
        │           ├── zsysnum_darwin_arm64.go
        │           ├── zsysnum_dragonfly_amd64.go
        │           ├── zsysnum_freebsd_386.go
        │           ├── zsysnum_freebsd_amd64.go
        │           ├── zsysnum_freebsd_arm.go
        │           ├── zsysnum_linux_386.go
        │           ├── zsysnum_linux_amd64.go
        │           ├── zsysnum_linux_arm.go
        │           ├── zsysnum_linux_arm64.go
        │           ├── zsysnum_linux_mips.go
        │           ├── zsysnum_linux_mips64.go
        │           ├── zsysnum_linux_mips64le.go
        │           ├── zsysnum_linux_mipsle.go
        │           ├── zsysnum_linux_ppc64.go
        │           ├── zsysnum_linux_ppc64le.go
        │           ├── zsysnum_linux_riscv64.go
        │           ├── zsysnum_linux_s390x.go
        │           ├── zsysnum_linux_sparc64.go
        │           ├── zsysnum_netbsd_386.go
        │           ├── zsysnum_netbsd_amd64.go
        │           ├── zsysnum_netbsd_arm.go
        │           ├── zsysnum_openbsd_386.go
        │           ├── zsysnum_openbsd_amd64.go
        │           ├── zsysnum_openbsd_arm.go
        │           ├── ztypes_aix_ppc.go
        │           ├── ztypes_aix_ppc64.go
        │           ├── ztypes_darwin_386.go
        │           ├── ztypes_darwin_amd64.go
        │           ├── ztypes_darwin_arm.go
        │           ├── ztypes_darwin_arm64.go
        │           ├── ztypes_dragonfly_amd64.go
        │           ├── ztypes_freebsd_386.go
        │           ├── ztypes_freebsd_amd64.go
        │           ├── ztypes_freebsd_arm.go
        │           ├── ztypes_linux_386.go
        │           ├── ztypes_linux_amd64.go
        │           ├── ztypes_linux_arm.go
        │           ├── ztypes_linux_arm64.go
        │           ├── ztypes_linux_mips.go
        │           ├── ztypes_linux_mips64.go
        │           ├── ztypes_linux_mips64le.go
        │           ├── ztypes_linux_mipsle.go
        │           ├── ztypes_linux_ppc64.go
        │           ├── ztypes_linux_ppc64le.go
        │           ├── ztypes_linux_riscv64.go
        │           ├── ztypes_linux_s390x.go
        │           ├── ztypes_linux_sparc64.go
        │           ├── ztypes_netbsd_386.go
        │           ├── ztypes_netbsd_amd64.go
        │           ├── ztypes_netbsd_arm.go
        │           ├── ztypes_openbsd_386.go
        │           ├── ztypes_openbsd_amd64.go
        │           ├── ztypes_openbsd_arm.go
        │           └── ztypes_solaris_amd64.go
        │       └── windows
        │           ├── aliases.go
        │           ├── asm_windows_386.s
        │           ├── asm_windows_amd64.s
        │           ├── dll_windows.go
        │           ├── env_windows.go
        │           ├── eventlog.go
        │           ├── exec_windows.go
        │           ├── memory_windows.go
        │           ├── mksyscall.go
        │           ├── race.go
        │           ├── race0.go
        │           ├── security_windows.go
        │           ├── service.go
        │           ├── str.go
        │           ├── syscall.go
        │           ├── syscall_windows.go
        │           ├── types_windows.go
        │           ├── types_windows_386.go
        │           ├── types_windows_amd64.go
        │           └── zsyscall_windows.go
    ├── gopkg.in
        └── urfave
        │   └── cli.v1
        │       ├── CHANGELOG.md
        │       ├── LICENSE
        │       ├── README.md
        │       ├── app.go
        │       ├── appveyor.yml
        │       ├── category.go
        │       ├── cli.go
        │       ├── command.go
        │       ├── context.go
        │       ├── errors.go
        │       ├── flag-types.json
        │       ├── flag.go
        │       ├── flag_generated.go
        │       ├── funcs.go
        │       ├── generate-flag-types
        │       ├── help.go
        │       └── runtests
    └── vendor.json


/.editorconfig:
--------------------------------------------------------------------------------
 1 | root = true
 2 | 
 3 | [**]
 4 | indent_style = tab
 5 | indent_size = 4
 6 | tab_width = 4
 7 | end_of_line = lf
 8 | charset = utf-8
 9 | trim_trailing_whitespace = true
10 | insert_final_newline = true
11 | max_line_length = 160
12 | 
13 | [**.md]
14 | indent_style = space
15 | indent_size = 2
16 | tab_width = 2
17 | 
18 | [**.travis.yml]
19 | indent_style = space
20 | indent_size = 2
21 | tab_width = 2
22 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
1 | ssh-keydgen*
2 | 


--------------------------------------------------------------------------------
/.travis.yml:
--------------------------------------------------------------------------------
 1 | language: go
 2 | 
 3 | go:
 4 |   - "1.9"
 5 |   - "1.10"
 6 | 
 7 | install: false
 8 | 
 9 | script:
10 |   - go test -v || travis_terminate 1
11 |   - go get github.com/mitchellh/gox
12 |   - CGO_ENABLED=0 gox -ldflags "-s" -rebuild
13 | 
14 | deploy:
15 |   on:
16 |     tags: true
17 |     go: 1.10
18 |   provider: releases
19 |   api_key:
20 |     secure: Fo3WhmhJB+gZ0wvUybQytg+tTcBnpCkafifnmOUj74zAbXbCnhoomIc9QhfNJciyrDV7bbVQCH9KmPiHP1bv/d6BE6Ft19hPtwdfreJ31TjuXEki0/WjH4iStv95AVhonxChMt4Whr96G0qPnEkmjF1+CurPA3v7FrqbAoYFrruO57I4uIIrHQYbW8N1fusX4AI4LgHqqJ5Kw5XHLvOqWd+ZsNd9t1O6rm49N7My3/xjYrG2T5uw/cycwIxFWYMD6joVNQ0r0DdPsjARkgKDqUZ0H9sbCem7FF/FnQN7bemJ5yiZKNnv5WBfOIpoh42fQFSnPyRLiIN8DQ+PualtEu4Y5Vn5xg80n9hcIV8wN9O8y8dGTd0vWnHpZaeHJ7mhBamahj5tHW7X444pLDPQTg6JYTI2javPj4hs4GpNnnieVkofVoTBsH3JxcxuSlLgNJ9dTZJFMF9wLDOfT9VSyAYpMx5GACLpoKFsVvWYbi9ZmjWtmJQfIas7DBOaWsLlimgb7Kk8Eh+CjaGPRWmvss+GwU2gbGBwQLWU/gZZabl8Y/E+aoL/UWziuv/X4fe0DHPHG6a3zviVVkkCuF6JxqfOf+8YU2zgdJqdPOwzQccMwTngvs+VMZ+7uXvJSg+COSDCziBSnnVEU7Spx8egzhabkJAGsFnvsKtDrkpEjpE=
21 |   skip_cleanup: true
22 |   file_glob: true
23 |   file: ssh-keydgen_*
24 | 


--------------------------------------------------------------------------------
/CHANGELOG:
--------------------------------------------------------------------------------
 1 | * Sat Sept 8 2018 cornfeedhobo 0.4.1
 2 | - Add seedphrase verification
 3 | - Update dependencies
 4 | 
 5 | * Thu Jun 21 2018 cornfeedhobo 0.4.0
 6 | - Switch to argon2 and use pbkdf2 for seed and salt derivation
 7 | - Refactor and add documentation
 8 | 
 9 | * Mon Jun 4 2018 cornfeedhobo 0.3.0
10 | - Add ssh-keygen test to validate output
11 | 
12 | * Mon Nov 20 2017 cornfeedhobo 0.2.0
13 | - Refactor key management to a struct-based approach
14 | - Drop printing to stdout and switch to writing files like OpenSSH's ssh-keygen
15 | - Refactor resource names
16 | - Style clean up
17 | - Add configurable work factor
18 | - Add tests
19 | 
20 | * Sun Nov 12 2017 cornfeedhobo 0.1.0
21 | - Initial draft
22 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | ssh-keydgen [![Go Report Card](https://goreportcard.com/badge/github.com/cornfeedhobo/ssh-keydgen)](https://goreportcard.com/report/github.com/cornfeedhobo/ssh-keydgen) [![Build Status](https://travis-ci.org/cornfeedhobo/ssh-keydgen.svg?branch=master)](https://travis-ci.org/cornfeedhobo/ssh-keydgen) [![Github All Releases](https://img.shields.io/github/downloads/cornfeedhobo/ssh-keydgen/total.svg)](https://github.com/cornfeedhobo/ssh-keydgen/releases)
 2 | ===========
 3 | 
 4 | Generate _Deterministic_ SSH keys
 5 | 
 6 | ```text
 7 | NAME:
 8 |    ssh-keydgen - deterministic authentication key generation
 9 | 
10 | USAGE:
11 |    ssh-keydgen [[-t <type>] [-b <bits>] [-c <curve>] [-f <filename>] [-a <rounds>] [--at <time>] [--am <memory>] [--as <seedphrase>] [--aa]]
12 | 
13 | AUTHOR:
14 |    cornfeedhobo
15 | 
16 | GLOBAL OPTIONS:
17 |    -t type          Specifies the type of key to create. The possible values are "dsa", "ecdsa", "rsa", or "ed25519". (default: "rsa")
18 |    -b bits          Specifies the number of bits in the key to create. Possible values are restricted by key type. (default: 2048)
19 |    -c curve         Specifies the elliptic curve to use. The possible values are 256, 384, or 521. (default: 256)
20 |    -f filename      Specifies the filename of the key file.
21 |    -a rounds        Specifies the number of hashing rounds applied during key generation. (default: 1000)
22 |    --at time        Specifies the time parameter for the Argon2 function. (default: 3)
23 |    --am memory      Specifies the memory parameter for the Argon2 function. (default: 16384)
24 |    --ap threads     Specifies the threads or parallelism for the Argon2 function. (default: 1)
25 |    --as seedphrase  Provides the deterministic seedphrase.
26 |    --aa             Add the generated key to the running ssh-agent.
27 | 
28 | COPYRIGHT:
29 |    (c) 2018 cornfeedhobo
30 | ```
31 | 
32 | 
33 | 
34 | ## Usage
35 | 
36 | 1) Generate your keys
37 | 
38 |    ```bash
39 |    keydgen -f path/to/deterministic_key
40 |    ls -lh path/to/deterministic_key*
41 |    ```
42 | 
43 | 2) Allow time to pass, hoping an emergency does not arise when you have no access to your keys ...
44 | 
45 |    _If_ the time comes where you need access but can't get to your keys, you can then obtain this
46 |    utility and re-generate, or even directly add your key to a running `ssh-agent`.
47 | 
48 |    ```bash
49 |    ssh-keydgen --aa
50 |    ```
51 | 
52 | 3) Profit!
53 | 
54 | 
55 | 
56 | ## FAQ
57 | 
58 | ### What Go versions are supported?
59 | 
60 | Go 1.9 or later
61 | 
62 | 
63 | ### How can I verify the generated key is valid?
64 | 
65 | Until there are more implementations of this generation scheme, you can
66 | at least verify the private key is usable and the public key matches what
67 | openssh generates.
68 | 
69 | ```bash
70 | cat path/to/deterministic_key.pub
71 | ssh-keygen -y -f path/to/deterministic_key
72 | ```
73 | 
74 | If the above outputs don't match, the public key was not generated properly.
75 | If you are prompted for a password, the private key was not generated properly.
76 | 
77 | 
78 | ### How can I encrypt my key after generation?
79 | 
80 | ```bash
81 | ssh-keygen -p -f path/to/deterministic_key
82 | ```
83 | 
84 | 
85 | 
86 | ## Is it any good?
87 | 
88 | [Yes](http://news.ycombinator.com/item?id=3067434)
89 | 


--------------------------------------------------------------------------------
/main_test.go:
--------------------------------------------------------------------------------
  1 | package main
  2 | 
  3 | import (
  4 | 	"bytes"
  5 | 	"fmt"
  6 | 	"io/ioutil"
  7 | 	"os"
  8 | 	"os/exec"
  9 | 	"path/filepath"
 10 | 	"testing"
 11 | 	"time"
 12 | 
 13 | 	"github.com/cornfeedhobo/ssh-keydgen/keygen"
 14 | 	"github.com/cornfeedhobo/ssh-keydgen/slowseeder"
 15 | )
 16 | 
 17 | func TestKeydgen(t *testing.T) {
 18 | 
 19 | 	cases := []*keygen.Keydgen{
 20 | 		{
 21 | 			Type: keygen.ED25519,
 22 | 		},
 23 | 		{
 24 | 			Type:  keygen.ECDSA,
 25 | 			Curve: 256,
 26 | 		},
 27 | 		{
 28 | 			Type:  keygen.ECDSA,
 29 | 			Curve: 384,
 30 | 		},
 31 | 		{
 32 | 			Type:  keygen.ECDSA,
 33 | 			Curve: 521,
 34 | 		},
 35 | 		{
 36 | 			Type: keygen.RSA,
 37 | 			Bits: 2048,
 38 | 		},
 39 | 		{
 40 | 			Type: keygen.RSA,
 41 | 			Bits: 4096,
 42 | 		},
 43 | 		{
 44 | 			Type: keygen.DSA,
 45 | 			Bits: 1024,
 46 | 		},
 47 | 		{
 48 | 			Type: keygen.DSA,
 49 | 			Bits: 2048,
 50 | 		},
 51 | 		{
 52 | 			Type: keygen.DSA,
 53 | 			Bits: 3072,
 54 | 		},
 55 | 	}
 56 | 
 57 | 	for _, k := range cases {
 58 | 
 59 | 		var name = k.Type
 60 | 		switch k.Type {
 61 | 		case keygen.RSA, keygen.DSA:
 62 | 			name += fmt.Sprintf("_%d", k.Bits)
 63 | 		case keygen.ECDSA:
 64 | 			name += fmt.Sprintf("_%d", k.Curve)
 65 | 		}
 66 | 
 67 | 		t.Run(name, func(t *testing.T) {
 68 | 
 69 | 			fmt.Print(name)
 70 | 			start := time.Now()
 71 | 
 72 | 			// use small parameters to keep tests short
 73 | 			d, err := slowseeder.New([]byte("keygen"), 1, 1, 512, 1)
 74 | 			if err != nil {
 75 | 				t.Fatal(err)
 76 | 			}
 77 | 
 78 | 			_, err = k.GenerateKey(d)
 79 | 			if err != nil {
 80 | 				t.Fatal(err)
 81 | 			}
 82 | 
 83 | 			privBytes, err := k.MarshalPrivateKey()
 84 | 			if err != nil {
 85 | 				t.Fatal(err)
 86 | 			}
 87 | 
 88 | 			pubBytes, err := k.MarshalPublicKey()
 89 | 			if err != nil {
 90 | 				t.Fatal(err)
 91 | 			}
 92 | 
 93 | 			filename, err := filepath.Abs(name)
 94 | 			if err != nil {
 95 | 				t.Fatal(err)
 96 | 			}
 97 | 
 98 | 			err = writeKeyToFile(k, filename)
 99 | 			if err != nil {
100 | 				t.Fatal(err)
101 | 			}
102 | 
103 | 			cmd := exec.Command("ssh-keygen", "-y", "-f", filename)
104 | 			outPipe, _ := cmd.StdoutPipe()
105 | 			errPipe, _ := cmd.StderrPipe()
106 | 			err = cmd.Start()
107 | 			if err != nil {
108 | 				t.Fatal(err)
109 | 			}
110 | 
111 | 			stdout, _ := ioutil.ReadAll(outPipe)
112 | 			stderr, _ := ioutil.ReadAll(errPipe)
113 | 
114 | 			if !bytes.Equal(pubBytes, stdout) {
115 | 				msg := "Unable to verify generated public key with ssh-keygen"
116 | 				msg += "\n\nGenerated Private Key:\n" + string(privBytes)
117 | 				msg += "\n\nGenerated Public Key:\n" + string(pubBytes)
118 | 				msg += "\n\nStdout:\n" + string(stdout)
119 | 				msg += "\n\nStderr:\n" + string(stderr)
120 | 				t.Fatal(msg)
121 | 			}
122 | 
123 | 			// don't defer in case inspection needs to be done with a failure
124 | 			os.Remove(filename)
125 | 			os.Remove(filename + ".pub")
126 | 
127 | 			fmt.Printf(" PASS %s\n", time.Since(start))
128 | 
129 | 		})
130 | 	}
131 | }
132 | 


--------------------------------------------------------------------------------
/slowseeder/slowseeder.go:
--------------------------------------------------------------------------------
 1 | // Package slowseeder implements a drop-in replacement for a rand source
 2 | // intended for cryptographic key generation.
 3 | //
 4 | // It has been designed to be simple and reproducible. Generation is
 5 | // deterministic from a seed, uses multiple layered hashing functions,
 6 | // and is parameterized to easily extend the time spent during each
 7 | // iteration, making brute force and pre-computation more difficult.
 8 | //
 9 | package slowseeder
10 | 
11 | import (
12 | 	"crypto/sha512"
13 | 	"errors"
14 | 	"io"
15 | 	"sync"
16 | 
17 | 	"golang.org/x/crypto/argon2"
18 | 	"golang.org/x/crypto/pbkdf2"
19 | 	"golang.org/x/crypto/ripemd160"
20 | )
21 | 
22 | // Reader represents a drop in replacement for a rand source
23 | type Reader struct {
24 | 	seed, salt, key      []byte
25 | 	rounds, time, memory uint32
26 | 	threads              uint8
27 | 
28 | 	mu    *sync.RWMutex
29 | 	reads int
30 | }
31 | 
32 | // New returns a Reader generator suitable for use with cryptographic functions
33 | func New(seed []byte, rounds, time, memory uint32, threads uint8) (io.Reader, error) {
34 | 
35 | 	var err error
36 | 
37 | 	if len(seed) == 0 {
38 | 		err = errors.New("Reader seed not set")
39 | 	}
40 | 
41 | 	if rounds < 1 {
42 | 		err = errors.New("Reader seeder requires rounds > 0")
43 | 	}
44 | 
45 | 	if time < 1 {
46 | 		err = errors.New("Reader seeder requires time > 0")
47 | 	}
48 | 
49 | 	if memory < 1 {
50 | 		err = errors.New("Reader seeder requires memory > 0")
51 | 	}
52 | 
53 | 	if threads < 1 {
54 | 		err = errors.New("Reader seeder requires threads > 0")
55 | 	}
56 | 
57 | 	return &Reader{
58 | 		seed:    seed,
59 | 		rounds:  rounds,
60 | 		time:    time,
61 | 		memory:  memory,
62 | 		threads: threads,
63 | 		mu:      &sync.RWMutex{},
64 | 	}, err
65 | 
66 | }
67 | 
68 | // Read implements a Reader that uses SHA512 and RIPEMD160 PBKDF2 to
69 | // iteratively hash the seed and salt, which are supplied to Argon2 to
70 | // generate the requested "entropy"
71 | func (r *Reader) Read(p []byte) (int, error) {
72 | 	r.mu.Lock()
73 | 	defer r.mu.Unlock()
74 | 	r.seed = pbkdf2.Key(r.seed, r.key, int(r.rounds), sha512.Size, sha512.New)
75 | 	r.salt = pbkdf2.Key(r.salt, r.key, int(r.reads), ripemd160.Size, ripemd160.New)
76 | 	r.key = argon2.Key(r.seed, r.salt, r.time, r.memory, r.threads, uint32(len(p)))
77 | 	return copy(p, r.key), nil
78 | }
79 | 


--------------------------------------------------------------------------------
/slowseeder/slowseeder_test.go:
--------------------------------------------------------------------------------
 1 | package slowseeder
 2 | 
 3 | import (
 4 | 	"crypto/rsa"
 5 | 	"crypto/x509"
 6 | 	"encoding/pem"
 7 | 	"fmt"
 8 | )
 9 | 
10 | func Example_generateRSA() {
11 | 	r, _ := New([]byte("slowseeder"), 1000, 3, 1024*16, 1)
12 | 	k, _ := rsa.GenerateKey(r, 2048)
13 | 	e := pem.EncodeToMemory(&pem.Block{
14 | 		Type:  "PRIVATE KEY",
15 | 		Bytes: x509.MarshalPKCS1PrivateKey(k),
16 | 	})
17 | 	fmt.Println(string(e))
18 | }
19 | 


--------------------------------------------------------------------------------
/vendor/github.com/mikesmitty/edkey/LICENSE:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) 2017 Michael Smith
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/vendor/github.com/mikesmitty/edkey/README.md:
--------------------------------------------------------------------------------
 1 | # edkey
 2 | edkey allows you to marshal/write ED25519 private keys in the OpenSSH private key format
 3 | 
 4 | ## Example
 5 | ```go
 6 | package main
 7 | 
 8 | import (
 9 | 	"crypto/rand"
10 | 	"encoding/pem"
11 | 	"io/ioutil"
12 | 	"github.com/mikesmitty/edkey"
13 | 	"golang.org/x/crypto/ed25519"
14 | 	"golang.org/x/crypto/ssh"
15 | )
16 | 
17 | func main() {
18 | 	// Generate a new private/public keypair for OpenSSH
19 | 	pubKey, privKey, _ := ed25519.GenerateKey(rand.Reader)
20 | 	publicKey, _ := ssh.NewPublicKey(pubKey)
21 | 
22 | 	pemKey := &pem.Block{
23 | 		Type:  "OPENSSH PRIVATE KEY",
24 | 		Bytes: edkey.MarshalED25519PrivateKey(privKey),
25 | 	}
26 | 	privateKey := pem.EncodeToMemory(pemKey)
27 | 	authorizedKey := ssh.MarshalAuthorizedKey(publicKey)
28 | 
29 | 	_ = ioutil.WriteFile("id_ed25519", privateKey, 0600)
30 | 	_ = ioutil.WriteFile("id_ed25519.pub", authorizedKey, 0644)
31 | }
32 | ```
33 | 


--------------------------------------------------------------------------------
/vendor/github.com/mikesmitty/edkey/edkey.go:
--------------------------------------------------------------------------------
 1 | package edkey
 2 | 
 3 | import (
 4 | 	"math/rand"
 5 | 
 6 | 	"golang.org/x/crypto/ed25519"
 7 | 	"golang.org/x/crypto/ssh"
 8 | )
 9 | 
10 | /* Writes ed25519 private keys into the new OpenSSH private key format.
11 | I have no idea why this isn't implemented anywhere yet, you can do seemingly
12 | everything except write it to disk in the OpenSSH private key format. */
13 | func MarshalED25519PrivateKey(key ed25519.PrivateKey) []byte {
14 | 	// Add our key header (followed by a null byte)
15 | 	magic := append([]byte("openssh-key-v1"), 0)
16 | 
17 | 	var w struct {
18 | 		CipherName   string
19 | 		KdfName      string
20 | 		KdfOpts      string
21 | 		NumKeys      uint32
22 | 		PubKey       []byte
23 | 		PrivKeyBlock []byte
24 | 	}
25 | 
26 | 	// Fill out the private key fields
27 | 	pk1 := struct {
28 | 		Check1  uint32
29 | 		Check2  uint32
30 | 		Keytype string
31 | 		Pub     []byte
32 | 		Priv    []byte
33 | 		Comment string
34 | 		Pad     []byte `ssh:"rest"`
35 | 	}{}
36 | 
37 | 	// Set our check ints
38 | 	ci := rand.Uint32()
39 | 	pk1.Check1 = ci
40 | 	pk1.Check2 = ci
41 | 
42 | 	// Set our key type
43 | 	pk1.Keytype = ssh.KeyAlgoED25519
44 | 
45 | 	// Add the pubkey to the optionally-encrypted block
46 | 	pk, ok := key.Public().(ed25519.PublicKey)
47 | 	if !ok {
48 | 		//fmt.Fprintln(os.Stderr, "ed25519.PublicKey type assertion failed on an ed25519 public key. This should never ever happen.")
49 | 		return nil
50 | 	}
51 | 	pubKey := []byte(pk)
52 | 	pk1.Pub = pubKey
53 | 
54 | 	// Add our private key
55 | 	pk1.Priv = []byte(key)
56 | 
57 | 	// Might be useful to put something in here at some point
58 | 	pk1.Comment = ""
59 | 
60 | 	// Add some padding to match the encryption block size within PrivKeyBlock (without Pad field)
61 | 	// 8 doesn't match the documentation, but that's what ssh-keygen uses for unencrypted keys. *shrug*
62 | 	bs := 8
63 | 	blockLen := len(ssh.Marshal(pk1))
64 | 	padLen := (bs - (blockLen % bs)) % bs
65 | 	pk1.Pad = make([]byte, padLen)
66 | 
67 | 	// Padding is a sequence of bytes like: 1, 2, 3...
68 | 	for i := 0; i < padLen; i++ {
69 | 		pk1.Pad[i] = byte(i + 1)
70 | 	}
71 | 
72 | 	// Generate the pubkey prefix "\0\0\0\nssh-ed25519\0\0\0 "
73 | 	prefix := []byte{0x0, 0x0, 0x0, 0x0b}
74 | 	prefix = append(prefix, []byte(ssh.KeyAlgoED25519)...)
75 | 	prefix = append(prefix, []byte{0x0, 0x0, 0x0, 0x20}...)
76 | 
77 | 	// Only going to support unencrypted keys for now
78 | 	w.CipherName = "none"
79 | 	w.KdfName = "none"
80 | 	w.KdfOpts = ""
81 | 	w.NumKeys = 1
82 | 	w.PubKey = append(prefix, pubKey...)
83 | 	w.PrivKeyBlock = ssh.Marshal(pk1)
84 | 
85 | 	magic = append(magic, ssh.Marshal(w)...)
86 | 
87 | 	return magic
88 | }
89 | 


--------------------------------------------------------------------------------
/vendor/github.com/mitchellh/go-homedir/LICENSE:
--------------------------------------------------------------------------------
 1 | The MIT License (MIT)
 2 | 
 3 | Copyright (c) 2013 Mitchell Hashimoto
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in
13 | all copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
21 | THE SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/vendor/github.com/mitchellh/go-homedir/README.md:
--------------------------------------------------------------------------------
 1 | # go-homedir
 2 | 
 3 | This is a Go library for detecting the user's home directory without
 4 | the use of cgo, so the library can be used in cross-compilation environments.
 5 | 
 6 | Usage is incredibly simple, just call `homedir.Dir()` to get the home directory
 7 | for a user, and `homedir.Expand()` to expand the `~` in a path to the home
 8 | directory.
 9 | 
10 | **Why not just use `os/user`?** The built-in `os/user` package requires
11 | cgo on Darwin systems. This means that any Go code that uses that package
12 | cannot cross compile. But 99% of the time the use for `os/user` is just to
13 | retrieve the home directory, which we can do for the current user without
14 | cgo. This library does that, enabling cross-compilation.
15 | 


--------------------------------------------------------------------------------
/vendor/github.com/mitchellh/go-homedir/go.mod:
--------------------------------------------------------------------------------
1 | module github.com/mitchellh/go-homedir
2 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/crypto/LICENSE:
--------------------------------------------------------------------------------
 1 | Copyright (c) 2009 The Go Authors. All rights reserved.
 2 | 
 3 | Redistribution and use in source and binary forms, with or without
 4 | modification, are permitted provided that the following conditions are
 5 | met:
 6 | 
 7 |    * Redistributions of source code must retain the above copyright
 8 | notice, this list of conditions and the following disclaimer.
 9 |    * Redistributions in binary form must reproduce the above
10 | copyright notice, this list of conditions and the following disclaimer
11 | in the documentation and/or other materials provided with the
12 | distribution.
13 |    * Neither the name of Google Inc. nor the names of its
14 | contributors may be used to endorse or promote products derived from
15 | this software without specific prior written permission.
16 | 
17 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
18 | "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
19 | LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
20 | A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
21 | OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
22 | SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
23 | LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
24 | DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
25 | THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
26 | (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
27 | OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/crypto/PATENTS:
--------------------------------------------------------------------------------
 1 | Additional IP Rights Grant (Patents)
 2 | 
 3 | "This implementation" means the copyrightable works distributed by
 4 | Google as part of the Go project.
 5 | 
 6 | Google hereby grants to You a perpetual, worldwide, non-exclusive,
 7 | no-charge, royalty-free, irrevocable (except as stated in this section)
 8 | patent license to make, have made, use, offer to sell, sell, import,
 9 | transfer and otherwise run, modify and propagate the contents of this
10 | implementation of Go, where such license applies only to those patent
11 | claims, both currently owned or controlled by Google and acquired in
12 | the future, licensable by Google that are necessarily infringed by this
13 | implementation of Go.  This grant does not include claims that would be
14 | infringed only as a consequence of further modification of this
15 | implementation.  If you or your agent or exclusive licensee institute or
16 | order or agree to the institution of patent litigation against any
17 | entity (including a cross-claim or counterclaim in a lawsuit) alleging
18 | that this implementation of Go or any code incorporated within this
19 | implementation of Go constitutes direct or contributory patent
20 | infringement, or inducement of patent infringement, then any patent
21 | rights granted to you under this License for this implementation of Go
22 | shall terminate as of the date such litigation is filed.
23 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/crypto/argon2/blake2b.go:
--------------------------------------------------------------------------------
 1 | // Copyright 2017 The Go Authors. All rights reserved.
 2 | // Use of this source code is governed by a BSD-style
 3 | // license that can be found in the LICENSE file.
 4 | 
 5 | package argon2
 6 | 
 7 | import (
 8 | 	"encoding/binary"
 9 | 	"hash"
10 | 
11 | 	"golang.org/x/crypto/blake2b"
12 | )
13 | 
14 | // blake2bHash computes an arbitrary long hash value of in
15 | // and writes the hash to out.
16 | func blake2bHash(out []byte, in []byte) {
17 | 	var b2 hash.Hash
18 | 	if n := len(out); n < blake2b.Size {
19 | 		b2, _ = blake2b.New(n, nil)
20 | 	} else {
21 | 		b2, _ = blake2b.New512(nil)
22 | 	}
23 | 
24 | 	var buffer [blake2b.Size]byte
25 | 	binary.LittleEndian.PutUint32(buffer[:4], uint32(len(out)))
26 | 	b2.Write(buffer[:4])
27 | 	b2.Write(in)
28 | 
29 | 	if len(out) <= blake2b.Size {
30 | 		b2.Sum(out[:0])
31 | 		return
32 | 	}
33 | 
34 | 	outLen := len(out)
35 | 	b2.Sum(buffer[:0])
36 | 	b2.Reset()
37 | 	copy(out, buffer[:32])
38 | 	out = out[32:]
39 | 	for len(out) > blake2b.Size {
40 | 		b2.Write(buffer[:])
41 | 		b2.Sum(buffer[:0])
42 | 		copy(out, buffer[:32])
43 | 		out = out[32:]
44 | 		b2.Reset()
45 | 	}
46 | 
47 | 	if outLen%blake2b.Size > 0 { // outLen > 64
48 | 		r := ((outLen + 31) / 32) - 2 // ⌈τ /32⌉-2
49 | 		b2, _ = blake2b.New(outLen-32*r, nil)
50 | 	}
51 | 	b2.Write(buffer[:])
52 | 	b2.Sum(out[:0])
53 | }
54 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/crypto/argon2/blamka_amd64.go:
--------------------------------------------------------------------------------
 1 | // Copyright 2017 The Go Authors. All rights reserved.
 2 | // Use of this source code is governed by a BSD-style
 3 | // license that can be found in the LICENSE file.
 4 | 
 5 | // +build amd64,!gccgo,!appengine
 6 | 
 7 | package argon2
 8 | 
 9 | import "golang.org/x/sys/cpu"
10 | 
11 | func init() {
12 | 	useSSE4 = cpu.X86.HasSSE41
13 | }
14 | 
15 | //go:noescape
16 | func mixBlocksSSE2(out, a, b, c *block)
17 | 
18 | //go:noescape
19 | func xorBlocksSSE2(out, a, b, c *block)
20 | 
21 | //go:noescape
22 | func blamkaSSE4(b *block)
23 | 
24 | func processBlockSSE(out, in1, in2 *block, xor bool) {
25 | 	var t block
26 | 	mixBlocksSSE2(&t, in1, in2, &t)
27 | 	if useSSE4 {
28 | 		blamkaSSE4(&t)
29 | 	} else {
30 | 		for i := 0; i < blockLength; i += 16 {
31 | 			blamkaGeneric(
32 | 				&t[i+0], &t[i+1], &t[i+2], &t[i+3],
33 | 				&t[i+4], &t[i+5], &t[i+6], &t[i+7],
34 | 				&t[i+8], &t[i+9], &t[i+10], &t[i+11],
35 | 				&t[i+12], &t[i+13], &t[i+14], &t[i+15],
36 | 			)
37 | 		}
38 | 		for i := 0; i < blockLength/8; i += 2 {
39 | 			blamkaGeneric(
40 | 				&t[i], &t[i+1], &t[16+i], &t[16+i+1],
41 | 				&t[32+i], &t[32+i+1], &t[48+i], &t[48+i+1],
42 | 				&t[64+i], &t[64+i+1], &t[80+i], &t[80+i+1],
43 | 				&t[96+i], &t[96+i+1], &t[112+i], &t[112+i+1],
44 | 			)
45 | 		}
46 | 	}
47 | 	if xor {
48 | 		xorBlocksSSE2(out, in1, in2, &t)
49 | 	} else {
50 | 		mixBlocksSSE2(out, in1, in2, &t)
51 | 	}
52 | }
53 | 
54 | func processBlock(out, in1, in2 *block) {
55 | 	processBlockSSE(out, in1, in2, false)
56 | }
57 | 
58 | func processBlockXOR(out, in1, in2 *block) {
59 | 	processBlockSSE(out, in1, in2, true)
60 | }
61 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/crypto/argon2/blamka_ref.go:
--------------------------------------------------------------------------------
 1 | // Copyright 2017 The Go Authors. All rights reserved.
 2 | // Use of this source code is governed by a BSD-style
 3 | // license that can be found in the LICENSE file.
 4 | 
 5 | // +build !amd64 appengine gccgo
 6 | 
 7 | package argon2
 8 | 
 9 | func processBlock(out, in1, in2 *block) {
10 | 	processBlockGeneric(out, in1, in2, false)
11 | }
12 | 
13 | func processBlockXOR(out, in1, in2 *block) {
14 | 	processBlockGeneric(out, in1, in2, true)
15 | }
16 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/crypto/blake2b/blake2bAVX2_amd64.go:
--------------------------------------------------------------------------------
 1 | // Copyright 2016 The Go Authors. All rights reserved.
 2 | // Use of this source code is governed by a BSD-style
 3 | // license that can be found in the LICENSE file.
 4 | 
 5 | // +build go1.7,amd64,!gccgo,!appengine
 6 | 
 7 | package blake2b
 8 | 
 9 | import "golang.org/x/sys/cpu"
10 | 
11 | func init() {
12 | 	useAVX2 = cpu.X86.HasAVX2
13 | 	useAVX = cpu.X86.HasAVX
14 | 	useSSE4 = cpu.X86.HasSSE41
15 | }
16 | 
17 | //go:noescape
18 | func hashBlocksAVX2(h *[8]uint64, c *[2]uint64, flag uint64, blocks []byte)
19 | 
20 | //go:noescape
21 | func hashBlocksAVX(h *[8]uint64, c *[2]uint64, flag uint64, blocks []byte)
22 | 
23 | //go:noescape
24 | func hashBlocksSSE4(h *[8]uint64, c *[2]uint64, flag uint64, blocks []byte)
25 | 
26 | func hashBlocks(h *[8]uint64, c *[2]uint64, flag uint64, blocks []byte) {
27 | 	switch {
28 | 	case useAVX2:
29 | 		hashBlocksAVX2(h, c, flag, blocks)
30 | 	case useAVX:
31 | 		hashBlocksAVX(h, c, flag, blocks)
32 | 	case useSSE4:
33 | 		hashBlocksSSE4(h, c, flag, blocks)
34 | 	default:
35 | 		hashBlocksGeneric(h, c, flag, blocks)
36 | 	}
37 | }
38 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/crypto/blake2b/blake2b_amd64.go:
--------------------------------------------------------------------------------
 1 | // Copyright 2016 The Go Authors. All rights reserved.
 2 | // Use of this source code is governed by a BSD-style
 3 | // license that can be found in the LICENSE file.
 4 | 
 5 | // +build !go1.7,amd64,!gccgo,!appengine
 6 | 
 7 | package blake2b
 8 | 
 9 | import "golang.org/x/sys/cpu"
10 | 
11 | func init() {
12 | 	useSSE4 = cpu.X86.HasSSE41
13 | }
14 | 
15 | //go:noescape
16 | func hashBlocksSSE4(h *[8]uint64, c *[2]uint64, flag uint64, blocks []byte)
17 | 
18 | func hashBlocks(h *[8]uint64, c *[2]uint64, flag uint64, blocks []byte) {
19 | 	if useSSE4 {
20 | 		hashBlocksSSE4(h, c, flag, blocks)
21 | 	} else {
22 | 		hashBlocksGeneric(h, c, flag, blocks)
23 | 	}
24 | }
25 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/crypto/blake2b/blake2b_ref.go:
--------------------------------------------------------------------------------
 1 | // Copyright 2016 The Go Authors. All rights reserved.
 2 | // Use of this source code is governed by a BSD-style
 3 | // license that can be found in the LICENSE file.
 4 | 
 5 | // +build !amd64 appengine gccgo
 6 | 
 7 | package blake2b
 8 | 
 9 | func hashBlocks(h *[8]uint64, c *[2]uint64, flag uint64, blocks []byte) {
10 | 	hashBlocksGeneric(h, c, flag, blocks)
11 | }
12 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/crypto/blake2b/register.go:
--------------------------------------------------------------------------------
 1 | // Copyright 2017 The Go Authors. All rights reserved.
 2 | // Use of this source code is governed by a BSD-style
 3 | // license that can be found in the LICENSE file.
 4 | 
 5 | // +build go1.9
 6 | 
 7 | package blake2b
 8 | 
 9 | import (
10 | 	"crypto"
11 | 	"hash"
12 | )
13 | 
14 | func init() {
15 | 	newHash256 := func() hash.Hash {
16 | 		h, _ := New256(nil)
17 | 		return h
18 | 	}
19 | 	newHash384 := func() hash.Hash {
20 | 		h, _ := New384(nil)
21 | 		return h
22 | 	}
23 | 
24 | 	newHash512 := func() hash.Hash {
25 | 		h, _ := New512(nil)
26 | 		return h
27 | 	}
28 | 
29 | 	crypto.RegisterHash(crypto.BLAKE2b_256, newHash256)
30 | 	crypto.RegisterHash(crypto.BLAKE2b_384, newHash384)
31 | 	crypto.RegisterHash(crypto.BLAKE2b_512, newHash512)
32 | }
33 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/crypto/curve25519/const_amd64.h:
--------------------------------------------------------------------------------
1 | // Copyright 2012 The Go Authors. All rights reserved.
2 | // Use of this source code is governed by a BSD-style
3 | // license that can be found in the LICENSE file.
4 | 
5 | // This code was translated into a form compatible with 6a from the public
6 | // domain sources in SUPERCOP: https://bench.cr.yp.to/supercop.html
7 | 
8 | #define REDMASK51     0x0007FFFFFFFFFFFF
9 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/crypto/curve25519/const_amd64.s:
--------------------------------------------------------------------------------
 1 | // Copyright 2012 The Go Authors. All rights reserved.
 2 | // Use of this source code is governed by a BSD-style
 3 | // license that can be found in the LICENSE file.
 4 | 
 5 | // This code was translated into a form compatible with 6a from the public
 6 | // domain sources in SUPERCOP: https://bench.cr.yp.to/supercop.html
 7 | 
 8 | // +build amd64,!gccgo,!appengine
 9 | 
10 | // These constants cannot be encoded in non-MOVQ immediates.
11 | // We access them directly from memory instead.
12 | 
13 | DATA ·_121666_213(SB)/8, $996687872
14 | GLOBL ·_121666_213(SB), 8, $8
15 | 
16 | DATA ·_2P0(SB)/8, $0xFFFFFFFFFFFDA
17 | GLOBL ·_2P0(SB), 8, $8
18 | 
19 | DATA ·_2P1234(SB)/8, $0xFFFFFFFFFFFFE
20 | GLOBL ·_2P1234(SB), 8, $8
21 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/crypto/curve25519/cswap_amd64.s:
--------------------------------------------------------------------------------
 1 | // Copyright 2012 The Go Authors. All rights reserved.
 2 | // Use of this source code is governed by a BSD-style
 3 | // license that can be found in the LICENSE file.
 4 | 
 5 | // +build amd64,!gccgo,!appengine
 6 | 
 7 | // func cswap(inout *[4][5]uint64, v uint64)
 8 | TEXT ·cswap(SB),7,$0
 9 | 	MOVQ inout+0(FP),DI
10 | 	MOVQ v+8(FP),SI
11 | 
12 | 	SUBQ $1, SI
13 | 	NOTQ SI
14 | 	MOVQ SI, X15
15 | 	PSHUFD $0x44, X15, X15
16 | 
17 | 	MOVOU 0(DI), X0
18 | 	MOVOU 16(DI), X2
19 | 	MOVOU 32(DI), X4
20 | 	MOVOU 48(DI), X6
21 | 	MOVOU 64(DI), X8
22 | 	MOVOU 80(DI), X1
23 | 	MOVOU 96(DI), X3
24 | 	MOVOU 112(DI), X5
25 | 	MOVOU 128(DI), X7
26 | 	MOVOU 144(DI), X9
27 | 
28 | 	MOVO X1, X10
29 | 	MOVO X3, X11
30 | 	MOVO X5, X12
31 | 	MOVO X7, X13
32 | 	MOVO X9, X14
33 | 
34 | 	PXOR X0, X10
35 | 	PXOR X2, X11
36 | 	PXOR X4, X12
37 | 	PXOR X6, X13
38 | 	PXOR X8, X14
39 | 	PAND X15, X10
40 | 	PAND X15, X11
41 | 	PAND X15, X12
42 | 	PAND X15, X13
43 | 	PAND X15, X14
44 | 	PXOR X10, X0
45 | 	PXOR X10, X1
46 | 	PXOR X11, X2
47 | 	PXOR X11, X3
48 | 	PXOR X12, X4
49 | 	PXOR X12, X5
50 | 	PXOR X13, X6
51 | 	PXOR X13, X7
52 | 	PXOR X14, X8
53 | 	PXOR X14, X9
54 | 
55 | 	MOVOU X0, 0(DI)
56 | 	MOVOU X2, 16(DI)
57 | 	MOVOU X4, 32(DI)
58 | 	MOVOU X6, 48(DI)
59 | 	MOVOU X8, 64(DI)
60 | 	MOVOU X1, 80(DI)
61 | 	MOVOU X3, 96(DI)
62 | 	MOVOU X5, 112(DI)
63 | 	MOVOU X7, 128(DI)
64 | 	MOVOU X9, 144(DI)
65 | 	RET
66 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/crypto/curve25519/doc.go:
--------------------------------------------------------------------------------
 1 | // Copyright 2012 The Go Authors. All rights reserved.
 2 | // Use of this source code is governed by a BSD-style
 3 | // license that can be found in the LICENSE file.
 4 | 
 5 | // Package curve25519 provides an implementation of scalar multiplication on
 6 | // the elliptic curve known as curve25519. See https://cr.yp.to/ecdh.html
 7 | package curve25519 // import "golang.org/x/crypto/curve25519"
 8 | 
 9 | // basePoint is the x coordinate of the generator of the curve.
10 | var basePoint = [32]byte{9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
11 | 
12 | // ScalarMult sets dst to the product in*base where dst and base are the x
13 | // coordinates of group points and all values are in little-endian form.
14 | func ScalarMult(dst, in, base *[32]byte) {
15 | 	scalarMult(dst, in, base)
16 | }
17 | 
18 | // ScalarBaseMult sets dst to the product in*base where dst and base are the x
19 | // coordinates of group points, base is the standard generator and all values
20 | // are in little-endian form.
21 | func ScalarBaseMult(dst, in *[32]byte) {
22 | 	ScalarMult(dst, in, &basePoint)
23 | }
24 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/crypto/curve25519/freeze_amd64.s:
--------------------------------------------------------------------------------
 1 | // Copyright 2012 The Go Authors. All rights reserved.
 2 | // Use of this source code is governed by a BSD-style
 3 | // license that can be found in the LICENSE file.
 4 | 
 5 | // This code was translated into a form compatible with 6a from the public
 6 | // domain sources in SUPERCOP: https://bench.cr.yp.to/supercop.html
 7 | 
 8 | // +build amd64,!gccgo,!appengine
 9 | 
10 | #include "const_amd64.h"
11 | 
12 | // func freeze(inout *[5]uint64)
13 | TEXT ·freeze(SB),7,$0-8
14 | 	MOVQ inout+0(FP), DI
15 | 
16 | 	MOVQ 0(DI),SI
17 | 	MOVQ 8(DI),DX
18 | 	MOVQ 16(DI),CX
19 | 	MOVQ 24(DI),R8
20 | 	MOVQ 32(DI),R9
21 | 	MOVQ $REDMASK51,AX
22 | 	MOVQ AX,R10
23 | 	SUBQ $18,R10
24 | 	MOVQ $3,R11
25 | REDUCELOOP:
26 | 	MOVQ SI,R12
27 | 	SHRQ $51,R12
28 | 	ANDQ AX,SI
29 | 	ADDQ R12,DX
30 | 	MOVQ DX,R12
31 | 	SHRQ $51,R12
32 | 	ANDQ AX,DX
33 | 	ADDQ R12,CX
34 | 	MOVQ CX,R12
35 | 	SHRQ $51,R12
36 | 	ANDQ AX,CX
37 | 	ADDQ R12,R8
38 | 	MOVQ R8,R12
39 | 	SHRQ $51,R12
40 | 	ANDQ AX,R8
41 | 	ADDQ R12,R9
42 | 	MOVQ R9,R12
43 | 	SHRQ $51,R12
44 | 	ANDQ AX,R9
45 | 	IMUL3Q $19,R12,R12
46 | 	ADDQ R12,SI
47 | 	SUBQ $1,R11
48 | 	JA REDUCELOOP
49 | 	MOVQ $1,R12
50 | 	CMPQ R10,SI
51 | 	CMOVQLT R11,R12
52 | 	CMPQ AX,DX
53 | 	CMOVQNE R11,R12
54 | 	CMPQ AX,CX
55 | 	CMOVQNE R11,R12
56 | 	CMPQ AX,R8
57 | 	CMOVQNE R11,R12
58 | 	CMPQ AX,R9
59 | 	CMOVQNE R11,R12
60 | 	NEGQ R12
61 | 	ANDQ R12,AX
62 | 	ANDQ R12,R10
63 | 	SUBQ R10,SI
64 | 	SUBQ AX,DX
65 | 	SUBQ AX,CX
66 | 	SUBQ AX,R8
67 | 	SUBQ AX,R9
68 | 	MOVQ SI,0(DI)
69 | 	MOVQ DX,8(DI)
70 | 	MOVQ CX,16(DI)
71 | 	MOVQ R8,24(DI)
72 | 	MOVQ R9,32(DI)
73 | 	RET
74 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/crypto/curve25519/mul_amd64.s:
--------------------------------------------------------------------------------
  1 | // Copyright 2012 The Go Authors. All rights reserved.
  2 | // Use of this source code is governed by a BSD-style
  3 | // license that can be found in the LICENSE file.
  4 | 
  5 | // This code was translated into a form compatible with 6a from the public
  6 | // domain sources in SUPERCOP: https://bench.cr.yp.to/supercop.html
  7 | 
  8 | // +build amd64,!gccgo,!appengine
  9 | 
 10 | #include "const_amd64.h"
 11 | 
 12 | // func mul(dest, a, b *[5]uint64)
 13 | TEXT ·mul(SB),0,$16-24
 14 | 	MOVQ dest+0(FP), DI
 15 | 	MOVQ a+8(FP), SI
 16 | 	MOVQ b+16(FP), DX
 17 | 
 18 | 	MOVQ DX,CX
 19 | 	MOVQ 24(SI),DX
 20 | 	IMUL3Q $19,DX,AX
 21 | 	MOVQ AX,0(SP)
 22 | 	MULQ 16(CX)
 23 | 	MOVQ AX,R8
 24 | 	MOVQ DX,R9
 25 | 	MOVQ 32(SI),DX
 26 | 	IMUL3Q $19,DX,AX
 27 | 	MOVQ AX,8(SP)
 28 | 	MULQ 8(CX)
 29 | 	ADDQ AX,R8
 30 | 	ADCQ DX,R9
 31 | 	MOVQ 0(SI),AX
 32 | 	MULQ 0(CX)
 33 | 	ADDQ AX,R8
 34 | 	ADCQ DX,R9
 35 | 	MOVQ 0(SI),AX
 36 | 	MULQ 8(CX)
 37 | 	MOVQ AX,R10
 38 | 	MOVQ DX,R11
 39 | 	MOVQ 0(SI),AX
 40 | 	MULQ 16(CX)
 41 | 	MOVQ AX,R12
 42 | 	MOVQ DX,R13
 43 | 	MOVQ 0(SI),AX
 44 | 	MULQ 24(CX)
 45 | 	MOVQ AX,R14
 46 | 	MOVQ DX,R15
 47 | 	MOVQ 0(SI),AX
 48 | 	MULQ 32(CX)
 49 | 	MOVQ AX,BX
 50 | 	MOVQ DX,BP
 51 | 	MOVQ 8(SI),AX
 52 | 	MULQ 0(CX)
 53 | 	ADDQ AX,R10
 54 | 	ADCQ DX,R11
 55 | 	MOVQ 8(SI),AX
 56 | 	MULQ 8(CX)
 57 | 	ADDQ AX,R12
 58 | 	ADCQ DX,R13
 59 | 	MOVQ 8(SI),AX
 60 | 	MULQ 16(CX)
 61 | 	ADDQ AX,R14
 62 | 	ADCQ DX,R15
 63 | 	MOVQ 8(SI),AX
 64 | 	MULQ 24(CX)
 65 | 	ADDQ AX,BX
 66 | 	ADCQ DX,BP
 67 | 	MOVQ 8(SI),DX
 68 | 	IMUL3Q $19,DX,AX
 69 | 	MULQ 32(CX)
 70 | 	ADDQ AX,R8
 71 | 	ADCQ DX,R9
 72 | 	MOVQ 16(SI),AX
 73 | 	MULQ 0(CX)
 74 | 	ADDQ AX,R12
 75 | 	ADCQ DX,R13
 76 | 	MOVQ 16(SI),AX
 77 | 	MULQ 8(CX)
 78 | 	ADDQ AX,R14
 79 | 	ADCQ DX,R15
 80 | 	MOVQ 16(SI),AX
 81 | 	MULQ 16(CX)
 82 | 	ADDQ AX,BX
 83 | 	ADCQ DX,BP
 84 | 	MOVQ 16(SI),DX
 85 | 	IMUL3Q $19,DX,AX
 86 | 	MULQ 24(CX)
 87 | 	ADDQ AX,R8
 88 | 	ADCQ DX,R9
 89 | 	MOVQ 16(SI),DX
 90 | 	IMUL3Q $19,DX,AX
 91 | 	MULQ 32(CX)
 92 | 	ADDQ AX,R10
 93 | 	ADCQ DX,R11
 94 | 	MOVQ 24(SI),AX
 95 | 	MULQ 0(CX)
 96 | 	ADDQ AX,R14
 97 | 	ADCQ DX,R15
 98 | 	MOVQ 24(SI),AX
 99 | 	MULQ 8(CX)
100 | 	ADDQ AX,BX
101 | 	ADCQ DX,BP
102 | 	MOVQ 0(SP),AX
103 | 	MULQ 24(CX)
104 | 	ADDQ AX,R10
105 | 	ADCQ DX,R11
106 | 	MOVQ 0(SP),AX
107 | 	MULQ 32(CX)
108 | 	ADDQ AX,R12
109 | 	ADCQ DX,R13
110 | 	MOVQ 32(SI),AX
111 | 	MULQ 0(CX)
112 | 	ADDQ AX,BX
113 | 	ADCQ DX,BP
114 | 	MOVQ 8(SP),AX
115 | 	MULQ 16(CX)
116 | 	ADDQ AX,R10
117 | 	ADCQ DX,R11
118 | 	MOVQ 8(SP),AX
119 | 	MULQ 24(CX)
120 | 	ADDQ AX,R12
121 | 	ADCQ DX,R13
122 | 	MOVQ 8(SP),AX
123 | 	MULQ 32(CX)
124 | 	ADDQ AX,R14
125 | 	ADCQ DX,R15
126 | 	MOVQ $REDMASK51,SI
127 | 	SHLQ $13,R9:R8
128 | 	ANDQ SI,R8
129 | 	SHLQ $13,R11:R10
130 | 	ANDQ SI,R10
131 | 	ADDQ R9,R10
132 | 	SHLQ $13,R13:R12
133 | 	ANDQ SI,R12
134 | 	ADDQ R11,R12
135 | 	SHLQ $13,R15:R14
136 | 	ANDQ SI,R14
137 | 	ADDQ R13,R14
138 | 	SHLQ $13,BP:BX
139 | 	ANDQ SI,BX
140 | 	ADDQ R15,BX
141 | 	IMUL3Q $19,BP,DX
142 | 	ADDQ DX,R8
143 | 	MOVQ R8,DX
144 | 	SHRQ $51,DX
145 | 	ADDQ R10,DX
146 | 	MOVQ DX,CX
147 | 	SHRQ $51,DX
148 | 	ANDQ SI,R8
149 | 	ADDQ R12,DX
150 | 	MOVQ DX,R9
151 | 	SHRQ $51,DX
152 | 	ANDQ SI,CX
153 | 	ADDQ R14,DX
154 | 	MOVQ DX,AX
155 | 	SHRQ $51,DX
156 | 	ANDQ SI,R9
157 | 	ADDQ BX,DX
158 | 	MOVQ DX,R10
159 | 	SHRQ $51,DX
160 | 	ANDQ SI,AX
161 | 	IMUL3Q $19,DX,DX
162 | 	ADDQ DX,R8
163 | 	ANDQ SI,R10
164 | 	MOVQ R8,0(DI)
165 | 	MOVQ CX,8(DI)
166 | 	MOVQ R9,16(DI)
167 | 	MOVQ AX,24(DI)
168 | 	MOVQ R10,32(DI)
169 | 	RET
170 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/crypto/curve25519/square_amd64.s:
--------------------------------------------------------------------------------
  1 | // Copyright 2012 The Go Authors. All rights reserved.
  2 | // Use of this source code is governed by a BSD-style
  3 | // license that can be found in the LICENSE file.
  4 | 
  5 | // This code was translated into a form compatible with 6a from the public
  6 | // domain sources in SUPERCOP: https://bench.cr.yp.to/supercop.html
  7 | 
  8 | // +build amd64,!gccgo,!appengine
  9 | 
 10 | #include "const_amd64.h"
 11 | 
 12 | // func square(out, in *[5]uint64)
 13 | TEXT ·square(SB),7,$0-16
 14 | 	MOVQ out+0(FP), DI
 15 | 	MOVQ in+8(FP), SI
 16 | 
 17 | 	MOVQ 0(SI),AX
 18 | 	MULQ 0(SI)
 19 | 	MOVQ AX,CX
 20 | 	MOVQ DX,R8
 21 | 	MOVQ 0(SI),AX
 22 | 	SHLQ $1,AX
 23 | 	MULQ 8(SI)
 24 | 	MOVQ AX,R9
 25 | 	MOVQ DX,R10
 26 | 	MOVQ 0(SI),AX
 27 | 	SHLQ $1,AX
 28 | 	MULQ 16(SI)
 29 | 	MOVQ AX,R11
 30 | 	MOVQ DX,R12
 31 | 	MOVQ 0(SI),AX
 32 | 	SHLQ $1,AX
 33 | 	MULQ 24(SI)
 34 | 	MOVQ AX,R13
 35 | 	MOVQ DX,R14
 36 | 	MOVQ 0(SI),AX
 37 | 	SHLQ $1,AX
 38 | 	MULQ 32(SI)
 39 | 	MOVQ AX,R15
 40 | 	MOVQ DX,BX
 41 | 	MOVQ 8(SI),AX
 42 | 	MULQ 8(SI)
 43 | 	ADDQ AX,R11
 44 | 	ADCQ DX,R12
 45 | 	MOVQ 8(SI),AX
 46 | 	SHLQ $1,AX
 47 | 	MULQ 16(SI)
 48 | 	ADDQ AX,R13
 49 | 	ADCQ DX,R14
 50 | 	MOVQ 8(SI),AX
 51 | 	SHLQ $1,AX
 52 | 	MULQ 24(SI)
 53 | 	ADDQ AX,R15
 54 | 	ADCQ DX,BX
 55 | 	MOVQ 8(SI),DX
 56 | 	IMUL3Q $38,DX,AX
 57 | 	MULQ 32(SI)
 58 | 	ADDQ AX,CX
 59 | 	ADCQ DX,R8
 60 | 	MOVQ 16(SI),AX
 61 | 	MULQ 16(SI)
 62 | 	ADDQ AX,R15
 63 | 	ADCQ DX,BX
 64 | 	MOVQ 16(SI),DX
 65 | 	IMUL3Q $38,DX,AX
 66 | 	MULQ 24(SI)
 67 | 	ADDQ AX,CX
 68 | 	ADCQ DX,R8
 69 | 	MOVQ 16(SI),DX
 70 | 	IMUL3Q $38,DX,AX
 71 | 	MULQ 32(SI)
 72 | 	ADDQ AX,R9
 73 | 	ADCQ DX,R10
 74 | 	MOVQ 24(SI),DX
 75 | 	IMUL3Q $19,DX,AX
 76 | 	MULQ 24(SI)
 77 | 	ADDQ AX,R9
 78 | 	ADCQ DX,R10
 79 | 	MOVQ 24(SI),DX
 80 | 	IMUL3Q $38,DX,AX
 81 | 	MULQ 32(SI)
 82 | 	ADDQ AX,R11
 83 | 	ADCQ DX,R12
 84 | 	MOVQ 32(SI),DX
 85 | 	IMUL3Q $19,DX,AX
 86 | 	MULQ 32(SI)
 87 | 	ADDQ AX,R13
 88 | 	ADCQ DX,R14
 89 | 	MOVQ $REDMASK51,SI
 90 | 	SHLQ $13,R8:CX
 91 | 	ANDQ SI,CX
 92 | 	SHLQ $13,R10:R9
 93 | 	ANDQ SI,R9
 94 | 	ADDQ R8,R9
 95 | 	SHLQ $13,R12:R11
 96 | 	ANDQ SI,R11
 97 | 	ADDQ R10,R11
 98 | 	SHLQ $13,R14:R13
 99 | 	ANDQ SI,R13
100 | 	ADDQ R12,R13
101 | 	SHLQ $13,BX:R15
102 | 	ANDQ SI,R15
103 | 	ADDQ R14,R15
104 | 	IMUL3Q $19,BX,DX
105 | 	ADDQ DX,CX
106 | 	MOVQ CX,DX
107 | 	SHRQ $51,DX
108 | 	ADDQ R9,DX
109 | 	ANDQ SI,CX
110 | 	MOVQ DX,R8
111 | 	SHRQ $51,DX
112 | 	ADDQ R11,DX
113 | 	ANDQ SI,R8
114 | 	MOVQ DX,R9
115 | 	SHRQ $51,DX
116 | 	ADDQ R13,DX
117 | 	ANDQ SI,R9
118 | 	MOVQ DX,AX
119 | 	SHRQ $51,DX
120 | 	ADDQ R15,DX
121 | 	ANDQ SI,AX
122 | 	MOVQ DX,R10
123 | 	SHRQ $51,DX
124 | 	IMUL3Q $19,DX,DX
125 | 	ADDQ DX,CX
126 | 	ANDQ SI,R10
127 | 	MOVQ CX,0(DI)
128 | 	MOVQ R8,8(DI)
129 | 	MOVQ R9,16(DI)
130 | 	MOVQ AX,24(DI)
131 | 	MOVQ R10,32(DI)
132 | 	RET
133 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/crypto/internal/chacha20/chacha_noasm.go:
--------------------------------------------------------------------------------
 1 | // Copyright 2018 The Go Authors. All rights reserved.
 2 | // Use of this source code is governed by a BSD-style
 3 | // license that can be found in the LICENSE file.
 4 | 
 5 | // +build !s390x gccgo appengine
 6 | 
 7 | package chacha20
 8 | 
 9 | const (
10 | 	bufSize = 64
11 | 	haveAsm = false
12 | )
13 | 
14 | func (*Cipher) xorKeyStreamAsm(dst, src []byte) {
15 | 	panic("not implemented")
16 | }
17 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/crypto/internal/chacha20/chacha_s390x.go:
--------------------------------------------------------------------------------
 1 | // Copyright 2018 The Go Authors. All rights reserved.
 2 | // Use of this source code is governed by a BSD-style
 3 | // license that can be found in the LICENSE file.
 4 | 
 5 | // +build s390x,!gccgo,!appengine
 6 | 
 7 | package chacha20
 8 | 
 9 | var haveAsm = hasVectorFacility()
10 | 
11 | const bufSize = 256
12 | 
13 | // hasVectorFacility reports whether the machine supports the vector
14 | // facility (vx).
15 | // Implementation in asm_s390x.s.
16 | func hasVectorFacility() bool
17 | 
18 | // xorKeyStreamVX is an assembly implementation of XORKeyStream. It must only
19 | // be called when the vector facility is available.
20 | // Implementation in asm_s390x.s.
21 | //go:noescape
22 | func xorKeyStreamVX(dst, src []byte, key *[8]uint32, nonce *[3]uint32, counter *uint32, buf *[256]byte, len *int)
23 | 
24 | func (c *Cipher) xorKeyStreamAsm(dst, src []byte) {
25 | 	xorKeyStreamVX(dst, src, &c.key, &c.nonce, &c.counter, &c.buf, &c.len)
26 | }
27 | 
28 | // EXRL targets, DO NOT CALL!
29 | func mvcSrcToBuf()
30 | func mvcBufToDst()
31 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/crypto/internal/chacha20/xor.go:
--------------------------------------------------------------------------------
 1 | // Copyright 2018 The Go Authors. All rights reserved.
 2 | // Use of this source code is governed by a BSD-style
 3 | // license that can be found src the LICENSE file.
 4 | 
 5 | package chacha20
 6 | 
 7 | import (
 8 | 	"runtime"
 9 | )
10 | 
11 | // Platforms that have fast unaligned 32-bit little endian accesses.
12 | const unaligned = runtime.GOARCH == "386" ||
13 | 	runtime.GOARCH == "amd64" ||
14 | 	runtime.GOARCH == "arm64" ||
15 | 	runtime.GOARCH == "ppc64le" ||
16 | 	runtime.GOARCH == "s390x"
17 | 
18 | // xor reads a little endian uint32 from src, XORs it with u and
19 | // places the result in little endian byte order in dst.
20 | func xor(dst, src []byte, u uint32) {
21 | 	_, _ = src[3], dst[3] // eliminate bounds checks
22 | 	if unaligned {
23 | 		// The compiler should optimize this code into
24 | 		// 32-bit unaligned little endian loads and stores.
25 | 		// TODO: delete once the compiler does a reliably
26 | 		// good job with the generic code below.
27 | 		// See issue #25111 for more details.
28 | 		v := uint32(src[0])
29 | 		v |= uint32(src[1]) << 8
30 | 		v |= uint32(src[2]) << 16
31 | 		v |= uint32(src[3]) << 24
32 | 		v ^= u
33 | 		dst[0] = byte(v)
34 | 		dst[1] = byte(v >> 8)
35 | 		dst[2] = byte(v >> 16)
36 | 		dst[3] = byte(v >> 24)
37 | 	} else {
38 | 		dst[0] = src[0] ^ byte(u)
39 | 		dst[1] = src[1] ^ byte(u>>8)
40 | 		dst[2] = src[2] ^ byte(u>>16)
41 | 		dst[3] = src[3] ^ byte(u>>24)
42 | 	}
43 | }
44 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/crypto/internal/subtle/aliasing.go:
--------------------------------------------------------------------------------
 1 | // Copyright 2018 The Go Authors. All rights reserved.
 2 | // Use of this source code is governed by a BSD-style
 3 | // license that can be found in the LICENSE file.
 4 | 
 5 | // +build !appengine
 6 | 
 7 | // Package subtle implements functions that are often useful in cryptographic
 8 | // code but require careful thought to use correctly.
 9 | package subtle // import "golang.org/x/crypto/internal/subtle"
10 | 
11 | import "unsafe"
12 | 
13 | // AnyOverlap reports whether x and y share memory at any (not necessarily
14 | // corresponding) index. The memory beyond the slice length is ignored.
15 | func AnyOverlap(x, y []byte) bool {
16 | 	return len(x) > 0 && len(y) > 0 &&
17 | 		uintptr(unsafe.Pointer(&x[0])) <= uintptr(unsafe.Pointer(&y[len(y)-1])) &&
18 | 		uintptr(unsafe.Pointer(&y[0])) <= uintptr(unsafe.Pointer(&x[len(x)-1]))
19 | }
20 | 
21 | // InexactOverlap reports whether x and y share memory at any non-corresponding
22 | // index. The memory beyond the slice length is ignored. Note that x and y can
23 | // have different lengths and still not have any inexact overlap.
24 | //
25 | // InexactOverlap can be used to implement the requirements of the crypto/cipher
26 | // AEAD, Block, BlockMode and Stream interfaces.
27 | func InexactOverlap(x, y []byte) bool {
28 | 	if len(x) == 0 || len(y) == 0 || &x[0] == &y[0] {
29 | 		return false
30 | 	}
31 | 	return AnyOverlap(x, y)
32 | }
33 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/crypto/internal/subtle/aliasing_appengine.go:
--------------------------------------------------------------------------------
 1 | // Copyright 2018 The Go Authors. All rights reserved.
 2 | // Use of this source code is governed by a BSD-style
 3 | // license that can be found in the LICENSE file.
 4 | 
 5 | // +build appengine
 6 | 
 7 | // Package subtle implements functions that are often useful in cryptographic
 8 | // code but require careful thought to use correctly.
 9 | package subtle // import "golang.org/x/crypto/internal/subtle"
10 | 
11 | // This is the Google App Engine standard variant based on reflect
12 | // because the unsafe package and cgo are disallowed.
13 | 
14 | import "reflect"
15 | 
16 | // AnyOverlap reports whether x and y share memory at any (not necessarily
17 | // corresponding) index. The memory beyond the slice length is ignored.
18 | func AnyOverlap(x, y []byte) bool {
19 | 	return len(x) > 0 && len(y) > 0 &&
20 | 		reflect.ValueOf(&x[0]).Pointer() <= reflect.ValueOf(&y[len(y)-1]).Pointer() &&
21 | 		reflect.ValueOf(&y[0]).Pointer() <= reflect.ValueOf(&x[len(x)-1]).Pointer()
22 | }
23 | 
24 | // InexactOverlap reports whether x and y share memory at any non-corresponding
25 | // index. The memory beyond the slice length is ignored. Note that x and y can
26 | // have different lengths and still not have any inexact overlap.
27 | //
28 | // InexactOverlap can be used to implement the requirements of the crypto/cipher
29 | // AEAD, Block, BlockMode and Stream interfaces.
30 | func InexactOverlap(x, y []byte) bool {
31 | 	if len(x) == 0 || len(y) == 0 || &x[0] == &y[0] {
32 | 		return false
33 | 	}
34 | 	return AnyOverlap(x, y)
35 | }
36 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/crypto/pbkdf2/pbkdf2.go:
--------------------------------------------------------------------------------
 1 | // Copyright 2012 The Go Authors. All rights reserved.
 2 | // Use of this source code is governed by a BSD-style
 3 | // license that can be found in the LICENSE file.
 4 | 
 5 | /*
 6 | Package pbkdf2 implements the key derivation function PBKDF2 as defined in RFC
 7 | 2898 / PKCS #5 v2.0.
 8 | 
 9 | A key derivation function is useful when encrypting data based on a password
10 | or any other not-fully-random data. It uses a pseudorandom function to derive
11 | a secure encryption key based on the password.
12 | 
13 | While v2.0 of the standard defines only one pseudorandom function to use,
14 | HMAC-SHA1, the drafted v2.1 specification allows use of all five FIPS Approved
15 | Hash Functions SHA-1, SHA-224, SHA-256, SHA-384 and SHA-512 for HMAC. To
16 | choose, you can pass the `New` functions from the different SHA packages to
17 | pbkdf2.Key.
18 | */
19 | package pbkdf2 // import "golang.org/x/crypto/pbkdf2"
20 | 
21 | import (
22 | 	"crypto/hmac"
23 | 	"hash"
24 | )
25 | 
26 | // Key derives a key from the password, salt and iteration count, returning a
27 | // []byte of length keylen that can be used as cryptographic key. The key is
28 | // derived based on the method described as PBKDF2 with the HMAC variant using
29 | // the supplied hash function.
30 | //
31 | // For example, to use a HMAC-SHA-1 based PBKDF2 key derivation function, you
32 | // can get a derived key for e.g. AES-256 (which needs a 32-byte key) by
33 | // doing:
34 | //
35 | // 	dk := pbkdf2.Key([]byte("some password"), salt, 4096, 32, sha1.New)
36 | //
37 | // Remember to get a good random salt. At least 8 bytes is recommended by the
38 | // RFC.
39 | //
40 | // Using a higher iteration count will increase the cost of an exhaustive
41 | // search but will also make derivation proportionally slower.
42 | func Key(password, salt []byte, iter, keyLen int, h func() hash.Hash) []byte {
43 | 	prf := hmac.New(h, password)
44 | 	hashLen := prf.Size()
45 | 	numBlocks := (keyLen + hashLen - 1) / hashLen
46 | 
47 | 	var buf [4]byte
48 | 	dk := make([]byte, 0, numBlocks*hashLen)
49 | 	U := make([]byte, hashLen)
50 | 	for block := 1; block <= numBlocks; block++ {
51 | 		// N.B.: || means concatenation, ^ means XOR
52 | 		// for each block T_i = U_1 ^ U_2 ^ ... ^ U_iter
53 | 		// U_1 = PRF(password, salt || uint(i))
54 | 		prf.Reset()
55 | 		prf.Write(salt)
56 | 		buf[0] = byte(block >> 24)
57 | 		buf[1] = byte(block >> 16)
58 | 		buf[2] = byte(block >> 8)
59 | 		buf[3] = byte(block)
60 | 		prf.Write(buf[:4])
61 | 		dk = prf.Sum(dk)
62 | 		T := dk[len(dk)-hashLen:]
63 | 		copy(U, T)
64 | 
65 | 		// U_n = PRF(password, U_(n-1))
66 | 		for n := 2; n <= iter; n++ {
67 | 			prf.Reset()
68 | 			prf.Write(U)
69 | 			U = U[:0]
70 | 			U = prf.Sum(U)
71 | 			for x := range U {
72 | 				T[x] ^= U[x]
73 | 			}
74 | 		}
75 | 	}
76 | 	return dk[:keyLen]
77 | }
78 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/crypto/poly1305/poly1305.go:
--------------------------------------------------------------------------------
 1 | // Copyright 2012 The Go Authors. All rights reserved.
 2 | // Use of this source code is governed by a BSD-style
 3 | // license that can be found in the LICENSE file.
 4 | 
 5 | /*
 6 | Package poly1305 implements Poly1305 one-time message authentication code as
 7 | specified in https://cr.yp.to/mac/poly1305-20050329.pdf.
 8 | 
 9 | Poly1305 is a fast, one-time authentication function. It is infeasible for an
10 | attacker to generate an authenticator for a message without the key. However, a
11 | key must only be used for a single message. Authenticating two different
12 | messages with the same key allows an attacker to forge authenticators for other
13 | messages with the same key.
14 | 
15 | Poly1305 was originally coupled with AES in order to make Poly1305-AES. AES was
16 | used with a fixed key in order to generate one-time keys from an nonce.
17 | However, in this package AES isn't used and the one-time key is specified
18 | directly.
19 | */
20 | package poly1305 // import "golang.org/x/crypto/poly1305"
21 | 
22 | import "crypto/subtle"
23 | 
24 | // TagSize is the size, in bytes, of a poly1305 authenticator.
25 | const TagSize = 16
26 | 
27 | // Verify returns true if mac is a valid authenticator for m with the given
28 | // key.
29 | func Verify(mac *[16]byte, m []byte, key *[32]byte) bool {
30 | 	var tmp [16]byte
31 | 	Sum(&tmp, m, key)
32 | 	return subtle.ConstantTimeCompare(tmp[:], mac[:]) == 1
33 | }
34 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/crypto/poly1305/sum_amd64.go:
--------------------------------------------------------------------------------
 1 | // Copyright 2012 The Go Authors. All rights reserved.
 2 | // Use of this source code is governed by a BSD-style
 3 | // license that can be found in the LICENSE file.
 4 | 
 5 | // +build amd64,!gccgo,!appengine
 6 | 
 7 | package poly1305
 8 | 
 9 | // This function is implemented in sum_amd64.s
10 | //go:noescape
11 | func poly1305(out *[16]byte, m *byte, mlen uint64, key *[32]byte)
12 | 
13 | // Sum generates an authenticator for m using a one-time key and puts the
14 | // 16-byte result into out. Authenticating two different messages with the same
15 | // key allows an attacker to forge messages at will.
16 | func Sum(out *[16]byte, m []byte, key *[32]byte) {
17 | 	var mPtr *byte
18 | 	if len(m) > 0 {
19 | 		mPtr = &m[0]
20 | 	}
21 | 	poly1305(out, mPtr, uint64(len(m)), key)
22 | }
23 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/crypto/poly1305/sum_arm.go:
--------------------------------------------------------------------------------
 1 | // Copyright 2015 The Go Authors. All rights reserved.
 2 | // Use of this source code is governed by a BSD-style
 3 | // license that can be found in the LICENSE file.
 4 | 
 5 | // +build arm,!gccgo,!appengine,!nacl
 6 | 
 7 | package poly1305
 8 | 
 9 | // This function is implemented in sum_arm.s
10 | //go:noescape
11 | func poly1305_auth_armv6(out *[16]byte, m *byte, mlen uint32, key *[32]byte)
12 | 
13 | // Sum generates an authenticator for m using a one-time key and puts the
14 | // 16-byte result into out. Authenticating two different messages with the same
15 | // key allows an attacker to forge messages at will.
16 | func Sum(out *[16]byte, m []byte, key *[32]byte) {
17 | 	var mPtr *byte
18 | 	if len(m) > 0 {
19 | 		mPtr = &m[0]
20 | 	}
21 | 	poly1305_auth_armv6(out, mPtr, uint32(len(m)), key)
22 | }
23 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/crypto/poly1305/sum_noasm.go:
--------------------------------------------------------------------------------
 1 | // Copyright 2018 The Go Authors. All rights reserved.
 2 | // Use of this source code is governed by a BSD-style
 3 | // license that can be found in the LICENSE file.
 4 | 
 5 | // +build s390x,!go1.11 !arm,!amd64,!s390x gccgo appengine nacl
 6 | 
 7 | package poly1305
 8 | 
 9 | // Sum generates an authenticator for msg using a one-time key and puts the
10 | // 16-byte result into out. Authenticating two different messages with the same
11 | // key allows an attacker to forge messages at will.
12 | func Sum(out *[TagSize]byte, msg []byte, key *[32]byte) {
13 | 	sumGeneric(out, msg, key)
14 | }
15 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/crypto/poly1305/sum_s390x.go:
--------------------------------------------------------------------------------
 1 | // Copyright 2018 The Go Authors. All rights reserved.
 2 | // Use of this source code is governed by a BSD-style
 3 | // license that can be found in the LICENSE file.
 4 | 
 5 | // +build s390x,go1.11,!gccgo,!appengine
 6 | 
 7 | package poly1305
 8 | 
 9 | // hasVectorFacility reports whether the machine supports
10 | // the vector facility (vx).
11 | func hasVectorFacility() bool
12 | 
13 | // hasVMSLFacility reports whether the machine supports
14 | // Vector Multiply Sum Logical (VMSL).
15 | func hasVMSLFacility() bool
16 | 
17 | var hasVX = hasVectorFacility()
18 | var hasVMSL = hasVMSLFacility()
19 | 
20 | // poly1305vx is an assembly implementation of Poly1305 that uses vector
21 | // instructions. It must only be called if the vector facility (vx) is
22 | // available.
23 | //go:noescape
24 | func poly1305vx(out *[16]byte, m *byte, mlen uint64, key *[32]byte)
25 | 
26 | // poly1305vmsl is an assembly implementation of Poly1305 that uses vector
27 | // instructions, including VMSL. It must only be called if the vector facility (vx) is
28 | // available and if VMSL is supported.
29 | //go:noescape
30 | func poly1305vmsl(out *[16]byte, m *byte, mlen uint64, key *[32]byte)
31 | 
32 | // Sum generates an authenticator for m using a one-time key and puts the
33 | // 16-byte result into out. Authenticating two different messages with the same
34 | // key allows an attacker to forge messages at will.
35 | func Sum(out *[16]byte, m []byte, key *[32]byte) {
36 | 	if hasVX {
37 | 		var mPtr *byte
38 | 		if len(m) > 0 {
39 | 			mPtr = &m[0]
40 | 		}
41 | 		if hasVMSL && len(m) > 256 {
42 | 			poly1305vmsl(out, mPtr, uint64(len(m)), key)
43 | 		} else {
44 | 			poly1305vx(out, mPtr, uint64(len(m)), key)
45 | 		}
46 | 	} else {
47 | 		sumGeneric(out, m, key)
48 | 	}
49 | }
50 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/crypto/ripemd160/ripemd160.go:
--------------------------------------------------------------------------------
  1 | // Copyright 2010 The Go Authors. All rights reserved.
  2 | // Use of this source code is governed by a BSD-style
  3 | // license that can be found in the LICENSE file.
  4 | 
  5 | // Package ripemd160 implements the RIPEMD-160 hash algorithm.
  6 | package ripemd160 // import "golang.org/x/crypto/ripemd160"
  7 | 
  8 | // RIPEMD-160 is designed by by Hans Dobbertin, Antoon Bosselaers, and Bart
  9 | // Preneel with specifications available at:
 10 | // http://homes.esat.kuleuven.be/~cosicart/pdf/AB-9601/AB-9601.pdf.
 11 | 
 12 | import (
 13 | 	"crypto"
 14 | 	"hash"
 15 | )
 16 | 
 17 | func init() {
 18 | 	crypto.RegisterHash(crypto.RIPEMD160, New)
 19 | }
 20 | 
 21 | // The size of the checksum in bytes.
 22 | const Size = 20
 23 | 
 24 | // The block size of the hash algorithm in bytes.
 25 | const BlockSize = 64
 26 | 
 27 | const (
 28 | 	_s0 = 0x67452301
 29 | 	_s1 = 0xefcdab89
 30 | 	_s2 = 0x98badcfe
 31 | 	_s3 = 0x10325476
 32 | 	_s4 = 0xc3d2e1f0
 33 | )
 34 | 
 35 | // digest represents the partial evaluation of a checksum.
 36 | type digest struct {
 37 | 	s  [5]uint32       // running context
 38 | 	x  [BlockSize]byte // temporary buffer
 39 | 	nx int             // index into x
 40 | 	tc uint64          // total count of bytes processed
 41 | }
 42 | 
 43 | func (d *digest) Reset() {
 44 | 	d.s[0], d.s[1], d.s[2], d.s[3], d.s[4] = _s0, _s1, _s2, _s3, _s4
 45 | 	d.nx = 0
 46 | 	d.tc = 0
 47 | }
 48 | 
 49 | // New returns a new hash.Hash computing the checksum.
 50 | func New() hash.Hash {
 51 | 	result := new(digest)
 52 | 	result.Reset()
 53 | 	return result
 54 | }
 55 | 
 56 | func (d *digest) Size() int { return Size }
 57 | 
 58 | func (d *digest) BlockSize() int { return BlockSize }
 59 | 
 60 | func (d *digest) Write(p []byte) (nn int, err error) {
 61 | 	nn = len(p)
 62 | 	d.tc += uint64(nn)
 63 | 	if d.nx > 0 {
 64 | 		n := len(p)
 65 | 		if n > BlockSize-d.nx {
 66 | 			n = BlockSize - d.nx
 67 | 		}
 68 | 		for i := 0; i < n; i++ {
 69 | 			d.x[d.nx+i] = p[i]
 70 | 		}
 71 | 		d.nx += n
 72 | 		if d.nx == BlockSize {
 73 | 			_Block(d, d.x[0:])
 74 | 			d.nx = 0
 75 | 		}
 76 | 		p = p[n:]
 77 | 	}
 78 | 	n := _Block(d, p)
 79 | 	p = p[n:]
 80 | 	if len(p) > 0 {
 81 | 		d.nx = copy(d.x[:], p)
 82 | 	}
 83 | 	return
 84 | }
 85 | 
 86 | func (d0 *digest) Sum(in []byte) []byte {
 87 | 	// Make a copy of d0 so that caller can keep writing and summing.
 88 | 	d := *d0
 89 | 
 90 | 	// Padding.  Add a 1 bit and 0 bits until 56 bytes mod 64.
 91 | 	tc := d.tc
 92 | 	var tmp [64]byte
 93 | 	tmp[0] = 0x80
 94 | 	if tc%64 < 56 {
 95 | 		d.Write(tmp[0 : 56-tc%64])
 96 | 	} else {
 97 | 		d.Write(tmp[0 : 64+56-tc%64])
 98 | 	}
 99 | 
100 | 	// Length in bits.
101 | 	tc <<= 3
102 | 	for i := uint(0); i < 8; i++ {
103 | 		tmp[i] = byte(tc >> (8 * i))
104 | 	}
105 | 	d.Write(tmp[0:8])
106 | 
107 | 	if d.nx != 0 {
108 | 		panic("d.nx != 0")
109 | 	}
110 | 
111 | 	var digest [Size]byte
112 | 	for i, s := range d.s {
113 | 		digest[i*4] = byte(s)
114 | 		digest[i*4+1] = byte(s >> 8)
115 | 		digest[i*4+2] = byte(s >> 16)
116 | 		digest[i*4+3] = byte(s >> 24)
117 | 	}
118 | 
119 | 	return append(in, digest[:]...)
120 | }
121 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/crypto/ssh/agent/forward.go:
--------------------------------------------------------------------------------
  1 | // Copyright 2014 The Go Authors. All rights reserved.
  2 | // Use of this source code is governed by a BSD-style
  3 | // license that can be found in the LICENSE file.
  4 | 
  5 | package agent
  6 | 
  7 | import (
  8 | 	"errors"
  9 | 	"io"
 10 | 	"net"
 11 | 	"sync"
 12 | 
 13 | 	"golang.org/x/crypto/ssh"
 14 | )
 15 | 
 16 | // RequestAgentForwarding sets up agent forwarding for the session.
 17 | // ForwardToAgent or ForwardToRemote should be called to route
 18 | // the authentication requests.
 19 | func RequestAgentForwarding(session *ssh.Session) error {
 20 | 	ok, err := session.SendRequest("auth-agent-req@openssh.com", true, nil)
 21 | 	if err != nil {
 22 | 		return err
 23 | 	}
 24 | 	if !ok {
 25 | 		return errors.New("forwarding request denied")
 26 | 	}
 27 | 	return nil
 28 | }
 29 | 
 30 | // ForwardToAgent routes authentication requests to the given keyring.
 31 | func ForwardToAgent(client *ssh.Client, keyring Agent) error {
 32 | 	channels := client.HandleChannelOpen(channelType)
 33 | 	if channels == nil {
 34 | 		return errors.New("agent: already have handler for " + channelType)
 35 | 	}
 36 | 
 37 | 	go func() {
 38 | 		for ch := range channels {
 39 | 			channel, reqs, err := ch.Accept()
 40 | 			if err != nil {
 41 | 				continue
 42 | 			}
 43 | 			go ssh.DiscardRequests(reqs)
 44 | 			go func() {
 45 | 				ServeAgent(keyring, channel)
 46 | 				channel.Close()
 47 | 			}()
 48 | 		}
 49 | 	}()
 50 | 	return nil
 51 | }
 52 | 
 53 | const channelType = "auth-agent@openssh.com"
 54 | 
 55 | // ForwardToRemote routes authentication requests to the ssh-agent
 56 | // process serving on the given unix socket.
 57 | func ForwardToRemote(client *ssh.Client, addr string) error {
 58 | 	channels := client.HandleChannelOpen(channelType)
 59 | 	if channels == nil {
 60 | 		return errors.New("agent: already have handler for " + channelType)
 61 | 	}
 62 | 	conn, err := net.Dial("unix", addr)
 63 | 	if err != nil {
 64 | 		return err
 65 | 	}
 66 | 	conn.Close()
 67 | 
 68 | 	go func() {
 69 | 		for ch := range channels {
 70 | 			channel, reqs, err := ch.Accept()
 71 | 			if err != nil {
 72 | 				continue
 73 | 			}
 74 | 			go ssh.DiscardRequests(reqs)
 75 | 			go forwardUnixSocket(channel, addr)
 76 | 		}
 77 | 	}()
 78 | 	return nil
 79 | }
 80 | 
 81 | func forwardUnixSocket(channel ssh.Channel, addr string) {
 82 | 	conn, err := net.Dial("unix", addr)
 83 | 	if err != nil {
 84 | 		return
 85 | 	}
 86 | 
 87 | 	var wg sync.WaitGroup
 88 | 	wg.Add(2)
 89 | 	go func() {
 90 | 		io.Copy(conn, channel)
 91 | 		conn.(*net.UnixConn).CloseWrite()
 92 | 		wg.Done()
 93 | 	}()
 94 | 	go func() {
 95 | 		io.Copy(channel, conn)
 96 | 		channel.CloseWrite()
 97 | 		wg.Done()
 98 | 	}()
 99 | 
100 | 	wg.Wait()
101 | 	conn.Close()
102 | 	channel.Close()
103 | }
104 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/crypto/ssh/buffer.go:
--------------------------------------------------------------------------------
 1 | // Copyright 2012 The Go Authors. All rights reserved.
 2 | // Use of this source code is governed by a BSD-style
 3 | // license that can be found in the LICENSE file.
 4 | 
 5 | package ssh
 6 | 
 7 | import (
 8 | 	"io"
 9 | 	"sync"
10 | )
11 | 
12 | // buffer provides a linked list buffer for data exchange
13 | // between producer and consumer. Theoretically the buffer is
14 | // of unlimited capacity as it does no allocation of its own.
15 | type buffer struct {
16 | 	// protects concurrent access to head, tail and closed
17 | 	*sync.Cond
18 | 
19 | 	head *element // the buffer that will be read first
20 | 	tail *element // the buffer that will be read last
21 | 
22 | 	closed bool
23 | }
24 | 
25 | // An element represents a single link in a linked list.
26 | type element struct {
27 | 	buf  []byte
28 | 	next *element
29 | }
30 | 
31 | // newBuffer returns an empty buffer that is not closed.
32 | func newBuffer() *buffer {
33 | 	e := new(element)
34 | 	b := &buffer{
35 | 		Cond: newCond(),
36 | 		head: e,
37 | 		tail: e,
38 | 	}
39 | 	return b
40 | }
41 | 
42 | // write makes buf available for Read to receive.
43 | // buf must not be modified after the call to write.
44 | func (b *buffer) write(buf []byte) {
45 | 	b.Cond.L.Lock()
46 | 	e := &element{buf: buf}
47 | 	b.tail.next = e
48 | 	b.tail = e
49 | 	b.Cond.Signal()
50 | 	b.Cond.L.Unlock()
51 | }
52 | 
53 | // eof closes the buffer. Reads from the buffer once all
54 | // the data has been consumed will receive io.EOF.
55 | func (b *buffer) eof() {
56 | 	b.Cond.L.Lock()
57 | 	b.closed = true
58 | 	b.Cond.Signal()
59 | 	b.Cond.L.Unlock()
60 | }
61 | 
62 | // Read reads data from the internal buffer in buf.  Reads will block
63 | // if no data is available, or until the buffer is closed.
64 | func (b *buffer) Read(buf []byte) (n int, err error) {
65 | 	b.Cond.L.Lock()
66 | 	defer b.Cond.L.Unlock()
67 | 
68 | 	for len(buf) > 0 {
69 | 		// if there is data in b.head, copy it
70 | 		if len(b.head.buf) > 0 {
71 | 			r := copy(buf, b.head.buf)
72 | 			buf, b.head.buf = buf[r:], b.head.buf[r:]
73 | 			n += r
74 | 			continue
75 | 		}
76 | 		// if there is a next buffer, make it the head
77 | 		if len(b.head.buf) == 0 && b.head != b.tail {
78 | 			b.head = b.head.next
79 | 			continue
80 | 		}
81 | 
82 | 		// if at least one byte has been copied, return
83 | 		if n > 0 {
84 | 			break
85 | 		}
86 | 
87 | 		// if nothing was read, and there is nothing outstanding
88 | 		// check to see if the buffer is closed.
89 | 		if b.closed {
90 | 			err = io.EOF
91 | 			break
92 | 		}
93 | 		// out of buffers, wait for producer
94 | 		b.Cond.Wait()
95 | 	}
96 | 	return
97 | }
98 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/crypto/ssh/doc.go:
--------------------------------------------------------------------------------
 1 | // Copyright 2011 The Go Authors. All rights reserved.
 2 | // Use of this source code is governed by a BSD-style
 3 | // license that can be found in the LICENSE file.
 4 | 
 5 | /*
 6 | Package ssh implements an SSH client and server.
 7 | 
 8 | SSH is a transport security protocol, an authentication protocol and a
 9 | family of application protocols. The most typical application level
10 | protocol is a remote shell and this is specifically implemented.  However,
11 | the multiplexed nature of SSH is exposed to users that wish to support
12 | others.
13 | 
14 | References:
15 |   [PROTOCOL.certkeys]: http://cvsweb.openbsd.org/cgi-bin/cvsweb/src/usr.bin/ssh/PROTOCOL.certkeys?rev=HEAD
16 |   [SSH-PARAMETERS]:    http://www.iana.org/assignments/ssh-parameters/ssh-parameters.xml#ssh-parameters-1
17 | 
18 | This package does not fall under the stability promise of the Go language itself,
19 | so its API may be changed when pressing needs arise.
20 | */
21 | package ssh // import "golang.org/x/crypto/ssh"
22 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/crypto/ssh/mac.go:
--------------------------------------------------------------------------------
 1 | // Copyright 2012 The Go Authors. All rights reserved.
 2 | // Use of this source code is governed by a BSD-style
 3 | // license that can be found in the LICENSE file.
 4 | 
 5 | package ssh
 6 | 
 7 | // Message authentication support
 8 | 
 9 | import (
10 | 	"crypto/hmac"
11 | 	"crypto/sha1"
12 | 	"crypto/sha256"
13 | 	"hash"
14 | )
15 | 
16 | type macMode struct {
17 | 	keySize int
18 | 	etm     bool
19 | 	new     func(key []byte) hash.Hash
20 | }
21 | 
22 | // truncatingMAC wraps around a hash.Hash and truncates the output digest to
23 | // a given size.
24 | type truncatingMAC struct {
25 | 	length int
26 | 	hmac   hash.Hash
27 | }
28 | 
29 | func (t truncatingMAC) Write(data []byte) (int, error) {
30 | 	return t.hmac.Write(data)
31 | }
32 | 
33 | func (t truncatingMAC) Sum(in []byte) []byte {
34 | 	out := t.hmac.Sum(in)
35 | 	return out[:len(in)+t.length]
36 | }
37 | 
38 | func (t truncatingMAC) Reset() {
39 | 	t.hmac.Reset()
40 | }
41 | 
42 | func (t truncatingMAC) Size() int {
43 | 	return t.length
44 | }
45 | 
46 | func (t truncatingMAC) BlockSize() int { return t.hmac.BlockSize() }
47 | 
48 | var macModes = map[string]*macMode{
49 | 	"hmac-sha2-256-etm@openssh.com": {32, true, func(key []byte) hash.Hash {
50 | 		return hmac.New(sha256.New, key)
51 | 	}},
52 | 	"hmac-sha2-256": {32, false, func(key []byte) hash.Hash {
53 | 		return hmac.New(sha256.New, key)
54 | 	}},
55 | 	"hmac-sha1": {20, false, func(key []byte) hash.Hash {
56 | 		return hmac.New(sha1.New, key)
57 | 	}},
58 | 	"hmac-sha1-96": {20, false, func(key []byte) hash.Hash {
59 | 		return truncatingMAC{12, hmac.New(sha1.New, key)}
60 | 	}},
61 | }
62 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/crypto/ssh/streamlocal.go:
--------------------------------------------------------------------------------
  1 | package ssh
  2 | 
  3 | import (
  4 | 	"errors"
  5 | 	"io"
  6 | 	"net"
  7 | )
  8 | 
  9 | // streamLocalChannelOpenDirectMsg is a struct used for SSH_MSG_CHANNEL_OPEN message
 10 | // with "direct-streamlocal@openssh.com" string.
 11 | //
 12 | // See openssh-portable/PROTOCOL, section 2.4. connection: Unix domain socket forwarding
 13 | // https://github.com/openssh/openssh-portable/blob/master/PROTOCOL#L235
 14 | type streamLocalChannelOpenDirectMsg struct {
 15 | 	socketPath string
 16 | 	reserved0  string
 17 | 	reserved1  uint32
 18 | }
 19 | 
 20 | // forwardedStreamLocalPayload is a struct used for SSH_MSG_CHANNEL_OPEN message
 21 | // with "forwarded-streamlocal@openssh.com" string.
 22 | type forwardedStreamLocalPayload struct {
 23 | 	SocketPath string
 24 | 	Reserved0  string
 25 | }
 26 | 
 27 | // streamLocalChannelForwardMsg is a struct used for SSH2_MSG_GLOBAL_REQUEST message
 28 | // with "streamlocal-forward@openssh.com"/"cancel-streamlocal-forward@openssh.com" string.
 29 | type streamLocalChannelForwardMsg struct {
 30 | 	socketPath string
 31 | }
 32 | 
 33 | // ListenUnix is similar to ListenTCP but uses a Unix domain socket.
 34 | func (c *Client) ListenUnix(socketPath string) (net.Listener, error) {
 35 | 	c.handleForwardsOnce.Do(c.handleForwards)
 36 | 	m := streamLocalChannelForwardMsg{
 37 | 		socketPath,
 38 | 	}
 39 | 	// send message
 40 | 	ok, _, err := c.SendRequest("streamlocal-forward@openssh.com", true, Marshal(&m))
 41 | 	if err != nil {
 42 | 		return nil, err
 43 | 	}
 44 | 	if !ok {
 45 | 		return nil, errors.New("ssh: streamlocal-forward@openssh.com request denied by peer")
 46 | 	}
 47 | 	ch := c.forwards.add(&net.UnixAddr{Name: socketPath, Net: "unix"})
 48 | 
 49 | 	return &unixListener{socketPath, c, ch}, nil
 50 | }
 51 | 
 52 | func (c *Client) dialStreamLocal(socketPath string) (Channel, error) {
 53 | 	msg := streamLocalChannelOpenDirectMsg{
 54 | 		socketPath: socketPath,
 55 | 	}
 56 | 	ch, in, err := c.OpenChannel("direct-streamlocal@openssh.com", Marshal(&msg))
 57 | 	if err != nil {
 58 | 		return nil, err
 59 | 	}
 60 | 	go DiscardRequests(in)
 61 | 	return ch, err
 62 | }
 63 | 
 64 | type unixListener struct {
 65 | 	socketPath string
 66 | 
 67 | 	conn *Client
 68 | 	in   <-chan forward
 69 | }
 70 | 
 71 | // Accept waits for and returns the next connection to the listener.
 72 | func (l *unixListener) Accept() (net.Conn, error) {
 73 | 	s, ok := <-l.in
 74 | 	if !ok {
 75 | 		return nil, io.EOF
 76 | 	}
 77 | 	ch, incoming, err := s.newCh.Accept()
 78 | 	if err != nil {
 79 | 		return nil, err
 80 | 	}
 81 | 	go DiscardRequests(incoming)
 82 | 
 83 | 	return &chanConn{
 84 | 		Channel: ch,
 85 | 		laddr: &net.UnixAddr{
 86 | 			Name: l.socketPath,
 87 | 			Net:  "unix",
 88 | 		},
 89 | 		raddr: &net.UnixAddr{
 90 | 			Name: "@",
 91 | 			Net:  "unix",
 92 | 		},
 93 | 	}, nil
 94 | }
 95 | 
 96 | // Close closes the listener.
 97 | func (l *unixListener) Close() error {
 98 | 	// this also closes the listener.
 99 | 	l.conn.forwards.remove(&net.UnixAddr{Name: l.socketPath, Net: "unix"})
100 | 	m := streamLocalChannelForwardMsg{
101 | 		l.socketPath,
102 | 	}
103 | 	ok, _, err := l.conn.SendRequest("cancel-streamlocal-forward@openssh.com", true, Marshal(&m))
104 | 	if err == nil && !ok {
105 | 		err = errors.New("ssh: cancel-streamlocal-forward@openssh.com failed")
106 | 	}
107 | 	return err
108 | }
109 | 
110 | // Addr returns the listener's network address.
111 | func (l *unixListener) Addr() net.Addr {
112 | 	return &net.UnixAddr{
113 | 		Name: l.socketPath,
114 | 		Net:  "unix",
115 | 	}
116 | }
117 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/crypto/ssh/terminal/util_bsd.go:
--------------------------------------------------------------------------------
 1 | // Copyright 2013 The Go Authors. All rights reserved.
 2 | // Use of this source code is governed by a BSD-style
 3 | // license that can be found in the LICENSE file.
 4 | 
 5 | // +build darwin dragonfly freebsd netbsd openbsd
 6 | 
 7 | package terminal
 8 | 
 9 | import "golang.org/x/sys/unix"
10 | 
11 | const ioctlReadTermios = unix.TIOCGETA
12 | const ioctlWriteTermios = unix.TIOCSETA
13 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/crypto/ssh/terminal/util_linux.go:
--------------------------------------------------------------------------------
 1 | // Copyright 2013 The Go Authors. All rights reserved.
 2 | // Use of this source code is governed by a BSD-style
 3 | // license that can be found in the LICENSE file.
 4 | 
 5 | package terminal
 6 | 
 7 | import "golang.org/x/sys/unix"
 8 | 
 9 | const ioctlReadTermios = unix.TCGETS
10 | const ioctlWriteTermios = unix.TCSETS
11 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/crypto/ssh/terminal/util_plan9.go:
--------------------------------------------------------------------------------
 1 | // Copyright 2016 The Go Authors. All rights reserved.
 2 | // Use of this source code is governed by a BSD-style
 3 | // license that can be found in the LICENSE file.
 4 | 
 5 | // Package terminal provides support functions for dealing with terminals, as
 6 | // commonly found on UNIX systems.
 7 | //
 8 | // Putting a terminal into raw mode is the most common requirement:
 9 | //
10 | // 	oldState, err := terminal.MakeRaw(0)
11 | // 	if err != nil {
12 | // 	        panic(err)
13 | // 	}
14 | // 	defer terminal.Restore(0, oldState)
15 | package terminal
16 | 
17 | import (
18 | 	"fmt"
19 | 	"runtime"
20 | )
21 | 
22 | type State struct{}
23 | 
24 | // IsTerminal returns true if the given file descriptor is a terminal.
25 | func IsTerminal(fd int) bool {
26 | 	return false
27 | }
28 | 
29 | // MakeRaw put the terminal connected to the given file descriptor into raw
30 | // mode and returns the previous state of the terminal so that it can be
31 | // restored.
32 | func MakeRaw(fd int) (*State, error) {
33 | 	return nil, fmt.Errorf("terminal: MakeRaw not implemented on %s/%s", runtime.GOOS, runtime.GOARCH)
34 | }
35 | 
36 | // GetState returns the current state of a terminal which may be useful to
37 | // restore the terminal after a signal.
38 | func GetState(fd int) (*State, error) {
39 | 	return nil, fmt.Errorf("terminal: GetState not implemented on %s/%s", runtime.GOOS, runtime.GOARCH)
40 | }
41 | 
42 | // Restore restores the terminal connected to the given file descriptor to a
43 | // previous state.
44 | func Restore(fd int, state *State) error {
45 | 	return fmt.Errorf("terminal: Restore not implemented on %s/%s", runtime.GOOS, runtime.GOARCH)
46 | }
47 | 
48 | // GetSize returns the dimensions of the given terminal.
49 | func GetSize(fd int) (width, height int, err error) {
50 | 	return 0, 0, fmt.Errorf("terminal: GetSize not implemented on %s/%s", runtime.GOOS, runtime.GOARCH)
51 | }
52 | 
53 | // ReadPassword reads a line of input from a terminal without local echo.  This
54 | // is commonly used for inputting passwords and other sensitive data. The slice
55 | // returned does not include the \n.
56 | func ReadPassword(fd int) ([]byte, error) {
57 | 	return nil, fmt.Errorf("terminal: ReadPassword not implemented on %s/%s", runtime.GOOS, runtime.GOARCH)
58 | }
59 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/LICENSE:
--------------------------------------------------------------------------------
 1 | Copyright (c) 2009 The Go Authors. All rights reserved.
 2 | 
 3 | Redistribution and use in source and binary forms, with or without
 4 | modification, are permitted provided that the following conditions are
 5 | met:
 6 | 
 7 |    * Redistributions of source code must retain the above copyright
 8 | notice, this list of conditions and the following disclaimer.
 9 |    * Redistributions in binary form must reproduce the above
10 | copyright notice, this list of conditions and the following disclaimer
11 | in the documentation and/or other materials provided with the
12 | distribution.
13 |    * Neither the name of Google Inc. nor the names of its
14 | contributors may be used to endorse or promote products derived from
15 | this software without specific prior written permission.
16 | 
17 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
18 | "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
19 | LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
20 | A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
21 | OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
22 | SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
23 | LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
24 | DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
25 | THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
26 | (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
27 | OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/PATENTS:
--------------------------------------------------------------------------------
 1 | Additional IP Rights Grant (Patents)
 2 | 
 3 | "This implementation" means the copyrightable works distributed by
 4 | Google as part of the Go project.
 5 | 
 6 | Google hereby grants to You a perpetual, worldwide, non-exclusive,
 7 | no-charge, royalty-free, irrevocable (except as stated in this section)
 8 | patent license to make, have made, use, offer to sell, sell, import,
 9 | transfer and otherwise run, modify and propagate the contents of this
10 | implementation of Go, where such license applies only to those patent
11 | claims, both currently owned or controlled by Google and acquired in
12 | the future, licensable by Google that are necessarily infringed by this
13 | implementation of Go.  This grant does not include claims that would be
14 | infringed only as a consequence of further modification of this
15 | implementation.  If you or your agent or exclusive licensee institute or
16 | order or agree to the institution of patent litigation against any
17 | entity (including a cross-claim or counterclaim in a lawsuit) alleging
18 | that this implementation of Go or any code incorporated within this
19 | implementation of Go constitutes direct or contributory patent
20 | infringement, or inducement of patent infringement, then any patent
21 | rights granted to you under this License for this implementation of Go
22 | shall terminate as of the date such litigation is filed.
23 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/cpu/cpu.go:
--------------------------------------------------------------------------------
 1 | // Copyright 2018 The Go Authors. All rights reserved.
 2 | // Use of this source code is governed by a BSD-style
 3 | // license that can be found in the LICENSE file.
 4 | 
 5 | // Package cpu implements processor feature detection for
 6 | // various CPU architectures.
 7 | package cpu
 8 | 
 9 | // CacheLinePad is used to pad structs to avoid false sharing.
10 | type CacheLinePad struct{ _ [cacheLineSize]byte }
11 | 
12 | // X86 contains the supported CPU features of the
13 | // current X86/AMD64 platform. If the current platform
14 | // is not X86/AMD64 then all feature flags are false.
15 | //
16 | // X86 is padded to avoid false sharing. Further the HasAVX
17 | // and HasAVX2 are only set if the OS supports XMM and YMM
18 | // registers in addition to the CPUID feature bit being set.
19 | var X86 struct {
20 | 	_            CacheLinePad
21 | 	HasAES       bool // AES hardware implementation (AES NI)
22 | 	HasADX       bool // Multi-precision add-carry instruction extensions
23 | 	HasAVX       bool // Advanced vector extension
24 | 	HasAVX2      bool // Advanced vector extension 2
25 | 	HasBMI1      bool // Bit manipulation instruction set 1
26 | 	HasBMI2      bool // Bit manipulation instruction set 2
27 | 	HasERMS      bool // Enhanced REP for MOVSB and STOSB
28 | 	HasFMA       bool // Fused-multiply-add instructions
29 | 	HasOSXSAVE   bool // OS supports XSAVE/XRESTOR for saving/restoring XMM registers.
30 | 	HasPCLMULQDQ bool // PCLMULQDQ instruction - most often used for AES-GCM
31 | 	HasPOPCNT    bool // Hamming weight instruction POPCNT.
32 | 	HasSSE2      bool // Streaming SIMD extension 2 (always available on amd64)
33 | 	HasSSE3      bool // Streaming SIMD extension 3
34 | 	HasSSSE3     bool // Supplemental streaming SIMD extension 3
35 | 	HasSSE41     bool // Streaming SIMD extension 4 and 4.1
36 | 	HasSSE42     bool // Streaming SIMD extension 4 and 4.2
37 | 	_            CacheLinePad
38 | }
39 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/cpu/cpu_arm.go:
--------------------------------------------------------------------------------
1 | // Copyright 2018 The Go Authors. All rights reserved.
2 | // Use of this source code is governed by a BSD-style
3 | // license that can be found in the LICENSE file.
4 | 
5 | package cpu
6 | 
7 | const cacheLineSize = 32
8 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/cpu/cpu_arm64.go:
--------------------------------------------------------------------------------
1 | // Copyright 2018 The Go Authors. All rights reserved.
2 | // Use of this source code is governed by a BSD-style
3 | // license that can be found in the LICENSE file.
4 | 
5 | package cpu
6 | 
7 | const cacheLineSize = 64
8 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/cpu/cpu_gc_x86.go:
--------------------------------------------------------------------------------
 1 | // Copyright 2018 The Go Authors. All rights reserved.
 2 | // Use of this source code is governed by a BSD-style
 3 | // license that can be found in the LICENSE file.
 4 | 
 5 | // +build 386 amd64 amd64p32
 6 | // +build !gccgo
 7 | 
 8 | package cpu
 9 | 
10 | // cpuid is implemented in cpu_x86.s for gc compiler
11 | // and in cpu_gccgo.c for gccgo.
12 | func cpuid(eaxArg, ecxArg uint32) (eax, ebx, ecx, edx uint32)
13 | 
14 | // xgetbv with ecx = 0 is implemented in cpu_x86.s for gc compiler
15 | // and in cpu_gccgo.c for gccgo.
16 | func xgetbv() (eax, edx uint32)
17 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/cpu/cpu_gccgo.c:
--------------------------------------------------------------------------------
 1 | // Copyright 2018 The Go Authors. All rights reserved.
 2 | // Use of this source code is governed by a BSD-style
 3 | // license that can be found in the LICENSE file.
 4 | 
 5 | // +build 386 amd64 amd64p32
 6 | // +build gccgo
 7 | 
 8 | #include <cpuid.h>
 9 | #include <stdint.h>
10 | 
11 | // Need to wrap __get_cpuid_count because it's declared as static.
12 | int
13 | gccgoGetCpuidCount(uint32_t leaf, uint32_t subleaf,
14 |                    uint32_t *eax, uint32_t *ebx,
15 |                    uint32_t *ecx, uint32_t *edx)
16 | {
17 | 	return __get_cpuid_count(leaf, subleaf, eax, ebx, ecx, edx);
18 | }
19 | 
20 | // xgetbv reads the contents of an XCR (Extended Control Register)
21 | // specified in the ECX register into registers EDX:EAX.
22 | // Currently, the only supported value for XCR is 0.
23 | //
24 | // TODO: Replace with a better alternative:
25 | //
26 | //     #include <xsaveintrin.h>
27 | //
28 | //     #pragma GCC target("xsave")
29 | //
30 | //     void gccgoXgetbv(uint32_t *eax, uint32_t *edx) {
31 | //       unsigned long long x = _xgetbv(0);
32 | //       *eax = x & 0xffffffff;
33 | //       *edx = (x >> 32) & 0xffffffff;
34 | //     }
35 | //
36 | // Note that _xgetbv is defined starting with GCC 8.
37 | void
38 | gccgoXgetbv(uint32_t *eax, uint32_t *edx)
39 | {
40 | 	__asm("  xorl %%ecx, %%ecx\n"
41 | 	      "  xgetbv"
42 | 	    : "=a"(*eax), "=d"(*edx));
43 | }
44 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/cpu/cpu_gccgo.go:
--------------------------------------------------------------------------------
 1 | // Copyright 2018 The Go Authors. All rights reserved.
 2 | // Use of this source code is governed by a BSD-style
 3 | // license that can be found in the LICENSE file.
 4 | 
 5 | // +build 386 amd64 amd64p32
 6 | // +build gccgo
 7 | 
 8 | package cpu
 9 | 
10 | //extern gccgoGetCpuidCount
11 | func gccgoGetCpuidCount(eaxArg, ecxArg uint32, eax, ebx, ecx, edx *uint32)
12 | 
13 | func cpuid(eaxArg, ecxArg uint32) (eax, ebx, ecx, edx uint32) {
14 | 	var a, b, c, d uint32
15 | 	gccgoGetCpuidCount(eaxArg, ecxArg, &a, &b, &c, &d)
16 | 	return a, b, c, d
17 | }
18 | 
19 | //extern gccgoXgetbv
20 | func gccgoXgetbv(eax, edx *uint32)
21 | 
22 | func xgetbv() (eax, edx uint32) {
23 | 	var a, d uint32
24 | 	gccgoXgetbv(&a, &d)
25 | 	return a, d
26 | }
27 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/cpu/cpu_mips64x.go:
--------------------------------------------------------------------------------
 1 | // Copyright 2018 The Go Authors. All rights reserved.
 2 | // Use of this source code is governed by a BSD-style
 3 | // license that can be found in the LICENSE file.
 4 | 
 5 | // +build mips64 mips64le
 6 | 
 7 | package cpu
 8 | 
 9 | const cacheLineSize = 32
10 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/cpu/cpu_mipsx.go:
--------------------------------------------------------------------------------
 1 | // Copyright 2018 The Go Authors. All rights reserved.
 2 | // Use of this source code is governed by a BSD-style
 3 | // license that can be found in the LICENSE file.
 4 | 
 5 | // +build mips mipsle
 6 | 
 7 | package cpu
 8 | 
 9 | const cacheLineSize = 32
10 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/cpu/cpu_ppc64x.go:
--------------------------------------------------------------------------------
 1 | // Copyright 2018 The Go Authors. All rights reserved.
 2 | // Use of this source code is governed by a BSD-style
 3 | // license that can be found in the LICENSE file.
 4 | 
 5 | // +build ppc64 ppc64le
 6 | 
 7 | package cpu
 8 | 
 9 | const cacheLineSize = 128
10 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/cpu/cpu_s390x.go:
--------------------------------------------------------------------------------
1 | // Copyright 2018 The Go Authors. All rights reserved.
2 | // Use of this source code is governed by a BSD-style
3 | // license that can be found in the LICENSE file.
4 | 
5 | package cpu
6 | 
7 | const cacheLineSize = 256
8 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/cpu/cpu_x86.go:
--------------------------------------------------------------------------------
 1 | // Copyright 2018 The Go Authors. All rights reserved.
 2 | // Use of this source code is governed by a BSD-style
 3 | // license that can be found in the LICENSE file.
 4 | 
 5 | // +build 386 amd64 amd64p32
 6 | 
 7 | package cpu
 8 | 
 9 | const cacheLineSize = 64
10 | 
11 | func init() {
12 | 	maxID, _, _, _ := cpuid(0, 0)
13 | 
14 | 	if maxID < 1 {
15 | 		return
16 | 	}
17 | 
18 | 	_, _, ecx1, edx1 := cpuid(1, 0)
19 | 	X86.HasSSE2 = isSet(26, edx1)
20 | 
21 | 	X86.HasSSE3 = isSet(0, ecx1)
22 | 	X86.HasPCLMULQDQ = isSet(1, ecx1)
23 | 	X86.HasSSSE3 = isSet(9, ecx1)
24 | 	X86.HasFMA = isSet(12, ecx1)
25 | 	X86.HasSSE41 = isSet(19, ecx1)
26 | 	X86.HasSSE42 = isSet(20, ecx1)
27 | 	X86.HasPOPCNT = isSet(23, ecx1)
28 | 	X86.HasAES = isSet(25, ecx1)
29 | 	X86.HasOSXSAVE = isSet(27, ecx1)
30 | 
31 | 	osSupportsAVX := false
32 | 	// For XGETBV, OSXSAVE bit is required and sufficient.
33 | 	if X86.HasOSXSAVE {
34 | 		eax, _ := xgetbv()
35 | 		// Check if XMM and YMM registers have OS support.
36 | 		osSupportsAVX = isSet(1, eax) && isSet(2, eax)
37 | 	}
38 | 
39 | 	X86.HasAVX = isSet(28, ecx1) && osSupportsAVX
40 | 
41 | 	if maxID < 7 {
42 | 		return
43 | 	}
44 | 
45 | 	_, ebx7, _, _ := cpuid(7, 0)
46 | 	X86.HasBMI1 = isSet(3, ebx7)
47 | 	X86.HasAVX2 = isSet(5, ebx7) && osSupportsAVX
48 | 	X86.HasBMI2 = isSet(8, ebx7)
49 | 	X86.HasERMS = isSet(9, ebx7)
50 | 	X86.HasADX = isSet(19, ebx7)
51 | }
52 | 
53 | func isSet(bitpos uint, value uint32) bool {
54 | 	return value&(1<<bitpos) != 0
55 | }
56 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/cpu/cpu_x86.s:
--------------------------------------------------------------------------------
 1 | // Copyright 2018 The Go Authors. All rights reserved.
 2 | // Use of this source code is governed by a BSD-style
 3 | // license that can be found in the LICENSE file.
 4 | 
 5 | // +build 386 amd64 amd64p32
 6 | // +build !gccgo
 7 | 
 8 | #include "textflag.h"
 9 | 
10 | // func cpuid(eaxArg, ecxArg uint32) (eax, ebx, ecx, edx uint32)
11 | TEXT ·cpuid(SB), NOSPLIT, $0-24
12 | 	MOVL eaxArg+0(FP), AX
13 | 	MOVL ecxArg+4(FP), CX
14 | 	CPUID
15 | 	MOVL AX, eax+8(FP)
16 | 	MOVL BX, ebx+12(FP)
17 | 	MOVL CX, ecx+16(FP)
18 | 	MOVL DX, edx+20(FP)
19 | 	RET
20 | 
21 | // func xgetbv() (eax, edx uint32)
22 | TEXT ·xgetbv(SB),NOSPLIT,$0-8
23 | 	MOVL $0, CX
24 | 	XGETBV
25 | 	MOVL AX, eax+0(FP)
26 | 	MOVL DX, edx+4(FP)
27 | 	RET
28 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/unix/aliases.go:
--------------------------------------------------------------------------------
 1 | // Copyright 2018 The Go Authors. All rights reserved.
 2 | // Use of this source code is governed by a BSD-style
 3 | // license that can be found in the LICENSE file.
 4 | 
 5 | // +build aix darwin dragonfly freebsd linux netbsd openbsd solaris
 6 | // +build go1.9
 7 | 
 8 | package unix
 9 | 
10 | import "syscall"
11 | 
12 | type Signal = syscall.Signal
13 | type Errno = syscall.Errno
14 | type SysProcAttr = syscall.SysProcAttr
15 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/unix/asm_darwin_386.s:
--------------------------------------------------------------------------------
 1 | // Copyright 2009 The Go Authors. All rights reserved.
 2 | // Use of this source code is governed by a BSD-style
 3 | // license that can be found in the LICENSE file.
 4 | 
 5 | // +build !gccgo
 6 | 
 7 | #include "textflag.h"
 8 | 
 9 | //
10 | // System call support for 386, Darwin
11 | //
12 | 
13 | // Just jump to package syscall's implementation for all these functions.
14 | // The runtime may know about them.
15 | 
16 | TEXT	·Syscall(SB),NOSPLIT,$0-28
17 | 	JMP	syscall·Syscall(SB)
18 | 
19 | TEXT	·Syscall6(SB),NOSPLIT,$0-40
20 | 	JMP	syscall·Syscall6(SB)
21 | 
22 | TEXT	·Syscall9(SB),NOSPLIT,$0-52
23 | 	JMP	syscall·Syscall9(SB)
24 | 
25 | TEXT ·RawSyscall(SB),NOSPLIT,$0-28
26 | 	JMP	syscall·RawSyscall(SB)
27 | 
28 | TEXT	·RawSyscall6(SB),NOSPLIT,$0-40
29 | 	JMP	syscall·RawSyscall6(SB)
30 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/unix/asm_darwin_amd64.s:
--------------------------------------------------------------------------------
 1 | // Copyright 2009 The Go Authors. All rights reserved.
 2 | // Use of this source code is governed by a BSD-style
 3 | // license that can be found in the LICENSE file.
 4 | 
 5 | // +build !gccgo
 6 | 
 7 | #include "textflag.h"
 8 | 
 9 | //
10 | // System call support for AMD64, Darwin
11 | //
12 | 
13 | // Just jump to package syscall's implementation for all these functions.
14 | // The runtime may know about them.
15 | 
16 | TEXT	·Syscall(SB),NOSPLIT,$0-56
17 | 	JMP	syscall·Syscall(SB)
18 | 
19 | TEXT	·Syscall6(SB),NOSPLIT,$0-80
20 | 	JMP	syscall·Syscall6(SB)
21 | 
22 | TEXT	·Syscall9(SB),NOSPLIT,$0-104
23 | 	JMP	syscall·Syscall9(SB)
24 | 
25 | TEXT	·RawSyscall(SB),NOSPLIT,$0-56
26 | 	JMP	syscall·RawSyscall(SB)
27 | 
28 | TEXT	·RawSyscall6(SB),NOSPLIT,$0-80
29 | 	JMP	syscall·RawSyscall6(SB)
30 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/unix/asm_darwin_arm.s:
--------------------------------------------------------------------------------
 1 | // Copyright 2015 The Go Authors. All rights reserved.
 2 | // Use of this source code is governed by a BSD-style
 3 | // license that can be found in the LICENSE file.
 4 | 
 5 | // +build !gccgo
 6 | // +build arm,darwin
 7 | 
 8 | #include "textflag.h"
 9 | 
10 | //
11 | // System call support for ARM, Darwin
12 | //
13 | 
14 | // Just jump to package syscall's implementation for all these functions.
15 | // The runtime may know about them.
16 | 
17 | TEXT	·Syscall(SB),NOSPLIT,$0-28
18 | 	B	syscall·Syscall(SB)
19 | 
20 | TEXT	·Syscall6(SB),NOSPLIT,$0-40
21 | 	B	syscall·Syscall6(SB)
22 | 
23 | TEXT	·Syscall9(SB),NOSPLIT,$0-52
24 | 	B	syscall·Syscall9(SB)
25 | 
26 | TEXT	·RawSyscall(SB),NOSPLIT,$0-28
27 | 	B	syscall·RawSyscall(SB)
28 | 
29 | TEXT	·RawSyscall6(SB),NOSPLIT,$0-40
30 | 	B	syscall·RawSyscall6(SB)
31 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/unix/asm_darwin_arm64.s:
--------------------------------------------------------------------------------
 1 | // Copyright 2015 The Go Authors. All rights reserved.
 2 | // Use of this source code is governed by a BSD-style
 3 | // license that can be found in the LICENSE file.
 4 | 
 5 | // +build !gccgo
 6 | // +build arm64,darwin
 7 | 
 8 | #include "textflag.h"
 9 | 
10 | //
11 | // System call support for AMD64, Darwin
12 | //
13 | 
14 | // Just jump to package syscall's implementation for all these functions.
15 | // The runtime may know about them.
16 | 
17 | TEXT	·Syscall(SB),NOSPLIT,$0-56
18 | 	B	syscall·Syscall(SB)
19 | 
20 | TEXT	·Syscall6(SB),NOSPLIT,$0-80
21 | 	B	syscall·Syscall6(SB)
22 | 
23 | TEXT	·Syscall9(SB),NOSPLIT,$0-104
24 | 	B	syscall·Syscall9(SB)
25 | 
26 | TEXT	·RawSyscall(SB),NOSPLIT,$0-56
27 | 	B	syscall·RawSyscall(SB)
28 | 
29 | TEXT	·RawSyscall6(SB),NOSPLIT,$0-80
30 | 	B	syscall·RawSyscall6(SB)
31 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/unix/asm_dragonfly_amd64.s:
--------------------------------------------------------------------------------
 1 | // Copyright 2009 The Go Authors. All rights reserved.
 2 | // Use of this source code is governed by a BSD-style
 3 | // license that can be found in the LICENSE file.
 4 | 
 5 | // +build !gccgo
 6 | 
 7 | #include "textflag.h"
 8 | 
 9 | //
10 | // System call support for AMD64, DragonFly
11 | //
12 | 
13 | // Just jump to package syscall's implementation for all these functions.
14 | // The runtime may know about them.
15 | 
16 | TEXT	·Syscall(SB),NOSPLIT,$0-56
17 | 	JMP	syscall·Syscall(SB)
18 | 
19 | TEXT	·Syscall6(SB),NOSPLIT,$0-80
20 | 	JMP	syscall·Syscall6(SB)
21 | 
22 | TEXT	·Syscall9(SB),NOSPLIT,$0-104
23 | 	JMP	syscall·Syscall9(SB)
24 | 
25 | TEXT ·RawSyscall(SB),NOSPLIT,$0-56
26 | 	JMP	syscall·RawSyscall(SB)
27 | 
28 | TEXT	·RawSyscall6(SB),NOSPLIT,$0-80
29 | 	JMP	syscall·RawSyscall6(SB)
30 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/unix/asm_freebsd_386.s:
--------------------------------------------------------------------------------
 1 | // Copyright 2009 The Go Authors. All rights reserved.
 2 | // Use of this source code is governed by a BSD-style
 3 | // license that can be found in the LICENSE file.
 4 | 
 5 | // +build !gccgo
 6 | 
 7 | #include "textflag.h"
 8 | 
 9 | //
10 | // System call support for 386, FreeBSD
11 | //
12 | 
13 | // Just jump to package syscall's implementation for all these functions.
14 | // The runtime may know about them.
15 | 
16 | TEXT	·Syscall(SB),NOSPLIT,$0-28
17 | 	JMP	syscall·Syscall(SB)
18 | 
19 | TEXT	·Syscall6(SB),NOSPLIT,$0-40
20 | 	JMP	syscall·Syscall6(SB)
21 | 
22 | TEXT	·Syscall9(SB),NOSPLIT,$0-52
23 | 	JMP	syscall·Syscall9(SB)
24 | 
25 | TEXT ·RawSyscall(SB),NOSPLIT,$0-28
26 | 	JMP	syscall·RawSyscall(SB)
27 | 
28 | TEXT	·RawSyscall6(SB),NOSPLIT,$0-40
29 | 	JMP	syscall·RawSyscall6(SB)
30 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/unix/asm_freebsd_amd64.s:
--------------------------------------------------------------------------------
 1 | // Copyright 2009 The Go Authors. All rights reserved.
 2 | // Use of this source code is governed by a BSD-style
 3 | // license that can be found in the LICENSE file.
 4 | 
 5 | // +build !gccgo
 6 | 
 7 | #include "textflag.h"
 8 | 
 9 | //
10 | // System call support for AMD64, FreeBSD
11 | //
12 | 
13 | // Just jump to package syscall's implementation for all these functions.
14 | // The runtime may know about them.
15 | 
16 | TEXT	·Syscall(SB),NOSPLIT,$0-56
17 | 	JMP	syscall·Syscall(SB)
18 | 
19 | TEXT	·Syscall6(SB),NOSPLIT,$0-80
20 | 	JMP	syscall·Syscall6(SB)
21 | 
22 | TEXT	·Syscall9(SB),NOSPLIT,$0-104
23 | 	JMP	syscall·Syscall9(SB)
24 | 
25 | TEXT ·RawSyscall(SB),NOSPLIT,$0-56
26 | 	JMP	syscall·RawSyscall(SB)
27 | 
28 | TEXT	·RawSyscall6(SB),NOSPLIT,$0-80
29 | 	JMP	syscall·RawSyscall6(SB)
30 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/unix/asm_freebsd_arm.s:
--------------------------------------------------------------------------------
 1 | // Copyright 2012 The Go Authors. All rights reserved.
 2 | // Use of this source code is governed by a BSD-style
 3 | // license that can be found in the LICENSE file.
 4 | 
 5 | // +build !gccgo
 6 | 
 7 | #include "textflag.h"
 8 | 
 9 | //
10 | // System call support for ARM, FreeBSD
11 | //
12 | 
13 | // Just jump to package syscall's implementation for all these functions.
14 | // The runtime may know about them.
15 | 
16 | TEXT	·Syscall(SB),NOSPLIT,$0-28
17 | 	B	syscall·Syscall(SB)
18 | 
19 | TEXT	·Syscall6(SB),NOSPLIT,$0-40
20 | 	B	syscall·Syscall6(SB)
21 | 
22 | TEXT	·Syscall9(SB),NOSPLIT,$0-52
23 | 	B	syscall·Syscall9(SB)
24 | 
25 | TEXT	·RawSyscall(SB),NOSPLIT,$0-28
26 | 	B	syscall·RawSyscall(SB)
27 | 
28 | TEXT	·RawSyscall6(SB),NOSPLIT,$0-40
29 | 	B	syscall·RawSyscall6(SB)
30 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/unix/asm_linux_386.s:
--------------------------------------------------------------------------------
 1 | // Copyright 2009 The Go Authors. All rights reserved.
 2 | // Use of this source code is governed by a BSD-style
 3 | // license that can be found in the LICENSE file.
 4 | 
 5 | // +build !gccgo
 6 | 
 7 | #include "textflag.h"
 8 | 
 9 | //
10 | // System calls for 386, Linux
11 | //
12 | 
13 | // See ../runtime/sys_linux_386.s for the reason why we always use int 0x80
14 | // instead of the glibc-specific "CALL 0x10(GS)".
15 | #define INVOKE_SYSCALL	INT	$0x80
16 | 
17 | // Just jump to package syscall's implementation for all these functions.
18 | // The runtime may know about them.
19 | 
20 | TEXT ·Syscall(SB),NOSPLIT,$0-28
21 | 	JMP	syscall·Syscall(SB)
22 | 
23 | TEXT ·Syscall6(SB),NOSPLIT,$0-40
24 | 	JMP	syscall·Syscall6(SB)
25 | 
26 | TEXT ·SyscallNoError(SB),NOSPLIT,$0-24
27 | 	CALL	runtime·entersyscall(SB)
28 | 	MOVL	trap+0(FP), AX  // syscall entry
29 | 	MOVL	a1+4(FP), BX
30 | 	MOVL	a2+8(FP), CX
31 | 	MOVL	a3+12(FP), DX
32 | 	MOVL	$0, SI
33 | 	MOVL	$0, DI
34 | 	INVOKE_SYSCALL
35 | 	MOVL	AX, r1+16(FP)
36 | 	MOVL	DX, r2+20(FP)
37 | 	CALL	runtime·exitsyscall(SB)
38 | 	RET
39 | 
40 | TEXT ·RawSyscall(SB),NOSPLIT,$0-28
41 | 	JMP	syscall·RawSyscall(SB)
42 | 
43 | TEXT ·RawSyscall6(SB),NOSPLIT,$0-40
44 | 	JMP	syscall·RawSyscall6(SB)
45 | 
46 | TEXT ·RawSyscallNoError(SB),NOSPLIT,$0-24
47 | 	MOVL	trap+0(FP), AX  // syscall entry
48 | 	MOVL	a1+4(FP), BX
49 | 	MOVL	a2+8(FP), CX
50 | 	MOVL	a3+12(FP), DX
51 | 	MOVL	$0, SI
52 | 	MOVL	$0, DI
53 | 	INVOKE_SYSCALL
54 | 	MOVL	AX, r1+16(FP)
55 | 	MOVL	DX, r2+20(FP)
56 | 	RET
57 | 
58 | TEXT ·socketcall(SB),NOSPLIT,$0-36
59 | 	JMP	syscall·socketcall(SB)
60 | 
61 | TEXT ·rawsocketcall(SB),NOSPLIT,$0-36
62 | 	JMP	syscall·rawsocketcall(SB)
63 | 
64 | TEXT ·seek(SB),NOSPLIT,$0-28
65 | 	JMP	syscall·seek(SB)
66 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/unix/asm_linux_amd64.s:
--------------------------------------------------------------------------------
 1 | // Copyright 2009 The Go Authors. All rights reserved.
 2 | // Use of this source code is governed by a BSD-style
 3 | // license that can be found in the LICENSE file.
 4 | 
 5 | // +build !gccgo
 6 | 
 7 | #include "textflag.h"
 8 | 
 9 | //
10 | // System calls for AMD64, Linux
11 | //
12 | 
13 | // Just jump to package syscall's implementation for all these functions.
14 | // The runtime may know about them.
15 | 
16 | TEXT ·Syscall(SB),NOSPLIT,$0-56
17 | 	JMP	syscall·Syscall(SB)
18 | 
19 | TEXT ·Syscall6(SB),NOSPLIT,$0-80
20 | 	JMP	syscall·Syscall6(SB)
21 | 
22 | TEXT ·SyscallNoError(SB),NOSPLIT,$0-48
23 | 	CALL	runtime·entersyscall(SB)
24 | 	MOVQ	a1+8(FP), DI
25 | 	MOVQ	a2+16(FP), SI
26 | 	MOVQ	a3+24(FP), DX
27 | 	MOVQ	$0, R10
28 | 	MOVQ	$0, R8
29 | 	MOVQ	$0, R9
30 | 	MOVQ	trap+0(FP), AX	// syscall entry
31 | 	SYSCALL
32 | 	MOVQ	AX, r1+32(FP)
33 | 	MOVQ	DX, r2+40(FP)
34 | 	CALL	runtime·exitsyscall(SB)
35 | 	RET
36 | 
37 | TEXT ·RawSyscall(SB),NOSPLIT,$0-56
38 | 	JMP	syscall·RawSyscall(SB)
39 | 
40 | TEXT ·RawSyscall6(SB),NOSPLIT,$0-80
41 | 	JMP	syscall·RawSyscall6(SB)
42 | 
43 | TEXT ·RawSyscallNoError(SB),NOSPLIT,$0-48
44 | 	MOVQ	a1+8(FP), DI
45 | 	MOVQ	a2+16(FP), SI
46 | 	MOVQ	a3+24(FP), DX
47 | 	MOVQ	$0, R10
48 | 	MOVQ	$0, R8
49 | 	MOVQ	$0, R9
50 | 	MOVQ	trap+0(FP), AX	// syscall entry
51 | 	SYSCALL
52 | 	MOVQ	AX, r1+32(FP)
53 | 	MOVQ	DX, r2+40(FP)
54 | 	RET
55 | 
56 | TEXT ·gettimeofday(SB),NOSPLIT,$0-16
57 | 	JMP	syscall·gettimeofday(SB)
58 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/unix/asm_linux_arm.s:
--------------------------------------------------------------------------------
 1 | // Copyright 2009 The Go Authors. All rights reserved.
 2 | // Use of this source code is governed by a BSD-style
 3 | // license that can be found in the LICENSE file.
 4 | 
 5 | // +build !gccgo
 6 | 
 7 | #include "textflag.h"
 8 | 
 9 | //
10 | // System calls for arm, Linux
11 | //
12 | 
13 | // Just jump to package syscall's implementation for all these functions.
14 | // The runtime may know about them.
15 | 
16 | TEXT ·Syscall(SB),NOSPLIT,$0-28
17 | 	B	syscall·Syscall(SB)
18 | 
19 | TEXT ·Syscall6(SB),NOSPLIT,$0-40
20 | 	B	syscall·Syscall6(SB)
21 | 
22 | TEXT ·SyscallNoError(SB),NOSPLIT,$0-24
23 | 	BL	runtime·entersyscall(SB)
24 | 	MOVW	trap+0(FP), R7
25 | 	MOVW	a1+4(FP), R0
26 | 	MOVW	a2+8(FP), R1
27 | 	MOVW	a3+12(FP), R2
28 | 	MOVW	$0, R3
29 | 	MOVW	$0, R4
30 | 	MOVW	$0, R5
31 | 	SWI	$0
32 | 	MOVW	R0, r1+16(FP)
33 | 	MOVW	$0, R0
34 | 	MOVW	R0, r2+20(FP)
35 | 	BL	runtime·exitsyscall(SB)
36 | 	RET
37 | 
38 | TEXT ·RawSyscall(SB),NOSPLIT,$0-28
39 | 	B	syscall·RawSyscall(SB)
40 | 
41 | TEXT ·RawSyscall6(SB),NOSPLIT,$0-40
42 | 	B	syscall·RawSyscall6(SB)
43 | 
44 | TEXT ·RawSyscallNoError(SB),NOSPLIT,$0-24
45 | 	MOVW	trap+0(FP), R7	// syscall entry
46 | 	MOVW	a1+4(FP), R0
47 | 	MOVW	a2+8(FP), R1
48 | 	MOVW	a3+12(FP), R2
49 | 	SWI	$0
50 | 	MOVW	R0, r1+16(FP)
51 | 	MOVW	$0, R0
52 | 	MOVW	R0, r2+20(FP)
53 | 	RET
54 | 
55 | TEXT ·seek(SB),NOSPLIT,$0-28
56 | 	B	syscall·seek(SB)
57 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/unix/asm_linux_arm64.s:
--------------------------------------------------------------------------------
 1 | // Copyright 2015 The Go Authors. All rights reserved.
 2 | // Use of this source code is governed by a BSD-style
 3 | // license that can be found in the LICENSE file.
 4 | 
 5 | // +build linux
 6 | // +build arm64
 7 | // +build !gccgo
 8 | 
 9 | #include "textflag.h"
10 | 
11 | // Just jump to package syscall's implementation for all these functions.
12 | // The runtime may know about them.
13 | 
14 | TEXT ·Syscall(SB),NOSPLIT,$0-56
15 | 	B	syscall·Syscall(SB)
16 | 
17 | TEXT ·Syscall6(SB),NOSPLIT,$0-80
18 | 	B	syscall·Syscall6(SB)
19 | 
20 | TEXT ·SyscallNoError(SB),NOSPLIT,$0-48
21 | 	BL	runtime·entersyscall(SB)
22 | 	MOVD	a1+8(FP), R0
23 | 	MOVD	a2+16(FP), R1
24 | 	MOVD	a3+24(FP), R2
25 | 	MOVD	$0, R3
26 | 	MOVD	$0, R4
27 | 	MOVD	$0, R5
28 | 	MOVD	trap+0(FP), R8	// syscall entry
29 | 	SVC
30 | 	MOVD	R0, r1+32(FP)	// r1
31 | 	MOVD	R1, r2+40(FP)	// r2
32 | 	BL	runtime·exitsyscall(SB)
33 | 	RET
34 | 
35 | TEXT ·RawSyscall(SB),NOSPLIT,$0-56
36 | 	B	syscall·RawSyscall(SB)
37 | 
38 | TEXT ·RawSyscall6(SB),NOSPLIT,$0-80
39 | 	B	syscall·RawSyscall6(SB)
40 | 
41 | TEXT ·RawSyscallNoError(SB),NOSPLIT,$0-48
42 | 	MOVD	a1+8(FP), R0
43 | 	MOVD	a2+16(FP), R1
44 | 	MOVD	a3+24(FP), R2
45 | 	MOVD	$0, R3
46 | 	MOVD	$0, R4
47 | 	MOVD	$0, R5
48 | 	MOVD	trap+0(FP), R8	// syscall entry
49 | 	SVC
50 | 	MOVD	R0, r1+32(FP)
51 | 	MOVD	R1, r2+40(FP)
52 | 	RET
53 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/unix/asm_linux_mips64x.s:
--------------------------------------------------------------------------------
 1 | // Copyright 2015 The Go Authors. All rights reserved.
 2 | // Use of this source code is governed by a BSD-style
 3 | // license that can be found in the LICENSE file.
 4 | 
 5 | // +build linux
 6 | // +build mips64 mips64le
 7 | // +build !gccgo
 8 | 
 9 | #include "textflag.h"
10 | 
11 | //
12 | // System calls for mips64, Linux
13 | //
14 | 
15 | // Just jump to package syscall's implementation for all these functions.
16 | // The runtime may know about them.
17 | 
18 | TEXT ·Syscall(SB),NOSPLIT,$0-56
19 | 	JMP	syscall·Syscall(SB)
20 | 
21 | TEXT ·Syscall6(SB),NOSPLIT,$0-80
22 | 	JMP	syscall·Syscall6(SB)
23 | 
24 | TEXT ·SyscallNoError(SB),NOSPLIT,$0-48
25 | 	JAL	runtime·entersyscall(SB)
26 | 	MOVV	a1+8(FP), R4
27 | 	MOVV	a2+16(FP), R5
28 | 	MOVV	a3+24(FP), R6
29 | 	MOVV	R0, R7
30 | 	MOVV	R0, R8
31 | 	MOVV	R0, R9
32 | 	MOVV	trap+0(FP), R2	// syscall entry
33 | 	SYSCALL
34 | 	MOVV	R2, r1+32(FP)
35 | 	MOVV	R3, r2+40(FP)
36 | 	JAL	runtime·exitsyscall(SB)
37 | 	RET
38 | 
39 | TEXT ·RawSyscall(SB),NOSPLIT,$0-56
40 | 	JMP	syscall·RawSyscall(SB)
41 | 
42 | TEXT ·RawSyscall6(SB),NOSPLIT,$0-80
43 | 	JMP	syscall·RawSyscall6(SB)
44 | 
45 | TEXT ·RawSyscallNoError(SB),NOSPLIT,$0-48
46 | 	MOVV	a1+8(FP), R4
47 | 	MOVV	a2+16(FP), R5
48 | 	MOVV	a3+24(FP), R6
49 | 	MOVV	R0, R7
50 | 	MOVV	R0, R8
51 | 	MOVV	R0, R9
52 | 	MOVV	trap+0(FP), R2	// syscall entry
53 | 	SYSCALL
54 | 	MOVV	R2, r1+32(FP)
55 | 	MOVV	R3, r2+40(FP)
56 | 	RET
57 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/unix/asm_linux_mipsx.s:
--------------------------------------------------------------------------------
 1 | // Copyright 2016 The Go Authors. All rights reserved.
 2 | // Use of this source code is governed by a BSD-style
 3 | // license that can be found in the LICENSE file.
 4 | 
 5 | // +build linux
 6 | // +build mips mipsle
 7 | // +build !gccgo
 8 | 
 9 | #include "textflag.h"
10 | 
11 | //
12 | // System calls for mips, Linux
13 | //
14 | 
15 | // Just jump to package syscall's implementation for all these functions.
16 | // The runtime may know about them.
17 | 
18 | TEXT ·Syscall(SB),NOSPLIT,$0-28
19 | 	JMP syscall·Syscall(SB)
20 | 
21 | TEXT ·Syscall6(SB),NOSPLIT,$0-40
22 | 	JMP syscall·Syscall6(SB)
23 | 
24 | TEXT ·Syscall9(SB),NOSPLIT,$0-52
25 | 	JMP syscall·Syscall9(SB)
26 | 
27 | TEXT ·SyscallNoError(SB),NOSPLIT,$0-24
28 | 	JAL	runtime·entersyscall(SB)
29 | 	MOVW	a1+4(FP), R4
30 | 	MOVW	a2+8(FP), R5
31 | 	MOVW	a3+12(FP), R6
32 | 	MOVW	R0, R7
33 | 	MOVW	trap+0(FP), R2	// syscall entry
34 | 	SYSCALL
35 | 	MOVW	R2, r1+16(FP)	// r1
36 | 	MOVW	R3, r2+20(FP)	// r2
37 | 	JAL	runtime·exitsyscall(SB)
38 | 	RET
39 | 
40 | TEXT ·RawSyscall(SB),NOSPLIT,$0-28
41 | 	JMP syscall·RawSyscall(SB)
42 | 
43 | TEXT ·RawSyscall6(SB),NOSPLIT,$0-40
44 | 	JMP syscall·RawSyscall6(SB)
45 | 
46 | TEXT ·RawSyscallNoError(SB),NOSPLIT,$0-24
47 | 	MOVW	a1+4(FP), R4
48 | 	MOVW	a2+8(FP), R5
49 | 	MOVW	a3+12(FP), R6
50 | 	MOVW	trap+0(FP), R2	// syscall entry
51 | 	SYSCALL
52 | 	MOVW	R2, r1+16(FP)
53 | 	MOVW	R3, r2+20(FP)
54 | 	RET
55 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/unix/asm_linux_ppc64x.s:
--------------------------------------------------------------------------------
 1 | // Copyright 2014 The Go Authors. All rights reserved.
 2 | // Use of this source code is governed by a BSD-style
 3 | // license that can be found in the LICENSE file.
 4 | 
 5 | // +build linux
 6 | // +build ppc64 ppc64le
 7 | // +build !gccgo
 8 | 
 9 | #include "textflag.h"
10 | 
11 | //
12 | // System calls for ppc64, Linux
13 | //
14 | 
15 | // Just jump to package syscall's implementation for all these functions.
16 | // The runtime may know about them.
17 | 
18 | TEXT ·Syscall(SB),NOSPLIT,$0-56
19 | 	BR	syscall·Syscall(SB)
20 | 
21 | TEXT ·Syscall6(SB),NOSPLIT,$0-80
22 | 	BR	syscall·Syscall6(SB)
23 | 
24 | TEXT ·SyscallNoError(SB),NOSPLIT,$0-48
25 | 	BL	runtime·entersyscall(SB)
26 | 	MOVD	a1+8(FP), R3
27 | 	MOVD	a2+16(FP), R4
28 | 	MOVD	a3+24(FP), R5
29 | 	MOVD	R0, R6
30 | 	MOVD	R0, R7
31 | 	MOVD	R0, R8
32 | 	MOVD	trap+0(FP), R9	// syscall entry
33 | 	SYSCALL R9
34 | 	MOVD	R3, r1+32(FP)
35 | 	MOVD	R4, r2+40(FP)
36 | 	BL	runtime·exitsyscall(SB)
37 | 	RET
38 | 
39 | TEXT ·RawSyscall(SB),NOSPLIT,$0-56
40 | 	BR	syscall·RawSyscall(SB)
41 | 
42 | TEXT ·RawSyscall6(SB),NOSPLIT,$0-80
43 | 	BR	syscall·RawSyscall6(SB)
44 | 
45 | TEXT ·RawSyscallNoError(SB),NOSPLIT,$0-48
46 | 	MOVD	a1+8(FP), R3
47 | 	MOVD	a2+16(FP), R4
48 | 	MOVD	a3+24(FP), R5
49 | 	MOVD	R0, R6
50 | 	MOVD	R0, R7
51 | 	MOVD	R0, R8
52 | 	MOVD	trap+0(FP), R9	// syscall entry
53 | 	SYSCALL R9
54 | 	MOVD	R3, r1+32(FP)
55 | 	MOVD	R4, r2+40(FP)
56 | 	RET
57 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/unix/asm_linux_s390x.s:
--------------------------------------------------------------------------------
 1 | // Copyright 2016 The Go Authors. All rights reserved.
 2 | // Use of this source code is governed by a BSD-style
 3 | // license that can be found in the LICENSE file.
 4 | 
 5 | // +build s390x
 6 | // +build linux
 7 | // +build !gccgo
 8 | 
 9 | #include "textflag.h"
10 | 
11 | //
12 | // System calls for s390x, Linux
13 | //
14 | 
15 | // Just jump to package syscall's implementation for all these functions.
16 | // The runtime may know about them.
17 | 
18 | TEXT ·Syscall(SB),NOSPLIT,$0-56
19 | 	BR	syscall·Syscall(SB)
20 | 
21 | TEXT ·Syscall6(SB),NOSPLIT,$0-80
22 | 	BR	syscall·Syscall6(SB)
23 | 
24 | TEXT ·SyscallNoError(SB),NOSPLIT,$0-48
25 | 	BL	runtime·entersyscall(SB)
26 | 	MOVD	a1+8(FP), R2
27 | 	MOVD	a2+16(FP), R3
28 | 	MOVD	a3+24(FP), R4
29 | 	MOVD	$0, R5
30 | 	MOVD	$0, R6
31 | 	MOVD	$0, R7
32 | 	MOVD	trap+0(FP), R1	// syscall entry
33 | 	SYSCALL
34 | 	MOVD	R2, r1+32(FP)
35 | 	MOVD	R3, r2+40(FP)
36 | 	BL	runtime·exitsyscall(SB)
37 | 	RET
38 | 
39 | TEXT ·RawSyscall(SB),NOSPLIT,$0-56
40 | 	BR	syscall·RawSyscall(SB)
41 | 
42 | TEXT ·RawSyscall6(SB),NOSPLIT,$0-80
43 | 	BR	syscall·RawSyscall6(SB)
44 | 
45 | TEXT ·RawSyscallNoError(SB),NOSPLIT,$0-48
46 | 	MOVD	a1+8(FP), R2
47 | 	MOVD	a2+16(FP), R3
48 | 	MOVD	a3+24(FP), R4
49 | 	MOVD	$0, R5
50 | 	MOVD	$0, R6
51 | 	MOVD	$0, R7
52 | 	MOVD	trap+0(FP), R1	// syscall entry
53 | 	SYSCALL
54 | 	MOVD	R2, r1+32(FP)
55 | 	MOVD	R3, r2+40(FP)
56 | 	RET
57 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/unix/asm_netbsd_386.s:
--------------------------------------------------------------------------------
 1 | // Copyright 2009 The Go Authors. All rights reserved.
 2 | // Use of this source code is governed by a BSD-style
 3 | // license that can be found in the LICENSE file.
 4 | 
 5 | // +build !gccgo
 6 | 
 7 | #include "textflag.h"
 8 | 
 9 | //
10 | // System call support for 386, NetBSD
11 | //
12 | 
13 | // Just jump to package syscall's implementation for all these functions.
14 | // The runtime may know about them.
15 | 
16 | TEXT	·Syscall(SB),NOSPLIT,$0-28
17 | 	JMP	syscall·Syscall(SB)
18 | 
19 | TEXT	·Syscall6(SB),NOSPLIT,$0-40
20 | 	JMP	syscall·Syscall6(SB)
21 | 
22 | TEXT	·Syscall9(SB),NOSPLIT,$0-52
23 | 	JMP	syscall·Syscall9(SB)
24 | 
25 | TEXT ·RawSyscall(SB),NOSPLIT,$0-28
26 | 	JMP	syscall·RawSyscall(SB)
27 | 
28 | TEXT	·RawSyscall6(SB),NOSPLIT,$0-40
29 | 	JMP	syscall·RawSyscall6(SB)
30 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/unix/asm_netbsd_amd64.s:
--------------------------------------------------------------------------------
 1 | // Copyright 2009 The Go Authors. All rights reserved.
 2 | // Use of this source code is governed by a BSD-style
 3 | // license that can be found in the LICENSE file.
 4 | 
 5 | // +build !gccgo
 6 | 
 7 | #include "textflag.h"
 8 | 
 9 | //
10 | // System call support for AMD64, NetBSD
11 | //
12 | 
13 | // Just jump to package syscall's implementation for all these functions.
14 | // The runtime may know about them.
15 | 
16 | TEXT	·Syscall(SB),NOSPLIT,$0-56
17 | 	JMP	syscall·Syscall(SB)
18 | 
19 | TEXT	·Syscall6(SB),NOSPLIT,$0-80
20 | 	JMP	syscall·Syscall6(SB)
21 | 
22 | TEXT	·Syscall9(SB),NOSPLIT,$0-104
23 | 	JMP	syscall·Syscall9(SB)
24 | 
25 | TEXT	·RawSyscall(SB),NOSPLIT,$0-56
26 | 	JMP	syscall·RawSyscall(SB)
27 | 
28 | TEXT	·RawSyscall6(SB),NOSPLIT,$0-80
29 | 	JMP	syscall·RawSyscall6(SB)
30 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/unix/asm_netbsd_arm.s:
--------------------------------------------------------------------------------
 1 | // Copyright 2013 The Go Authors. All rights reserved.
 2 | // Use of this source code is governed by a BSD-style
 3 | // license that can be found in the LICENSE file.
 4 | 
 5 | // +build !gccgo
 6 | 
 7 | #include "textflag.h"
 8 | 
 9 | //
10 | // System call support for ARM, NetBSD
11 | //
12 | 
13 | // Just jump to package syscall's implementation for all these functions.
14 | // The runtime may know about them.
15 | 
16 | TEXT	·Syscall(SB),NOSPLIT,$0-28
17 | 	B	syscall·Syscall(SB)
18 | 
19 | TEXT	·Syscall6(SB),NOSPLIT,$0-40
20 | 	B	syscall·Syscall6(SB)
21 | 
22 | TEXT	·Syscall9(SB),NOSPLIT,$0-52
23 | 	B	syscall·Syscall9(SB)
24 | 
25 | TEXT	·RawSyscall(SB),NOSPLIT,$0-28
26 | 	B	syscall·RawSyscall(SB)
27 | 
28 | TEXT	·RawSyscall6(SB),NOSPLIT,$0-40
29 | 	B	syscall·RawSyscall6(SB)
30 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/unix/asm_openbsd_386.s:
--------------------------------------------------------------------------------
 1 | // Copyright 2009 The Go Authors. All rights reserved.
 2 | // Use of this source code is governed by a BSD-style
 3 | // license that can be found in the LICENSE file.
 4 | 
 5 | // +build !gccgo
 6 | 
 7 | #include "textflag.h"
 8 | 
 9 | //
10 | // System call support for 386, OpenBSD
11 | //
12 | 
13 | // Just jump to package syscall's implementation for all these functions.
14 | // The runtime may know about them.
15 | 
16 | TEXT	·Syscall(SB),NOSPLIT,$0-28
17 | 	JMP	syscall·Syscall(SB)
18 | 
19 | TEXT	·Syscall6(SB),NOSPLIT,$0-40
20 | 	JMP	syscall·Syscall6(SB)
21 | 
22 | TEXT	·Syscall9(SB),NOSPLIT,$0-52
23 | 	JMP	syscall·Syscall9(SB)
24 | 
25 | TEXT ·RawSyscall(SB),NOSPLIT,$0-28
26 | 	JMP	syscall·RawSyscall(SB)
27 | 
28 | TEXT	·RawSyscall6(SB),NOSPLIT,$0-40
29 | 	JMP	syscall·RawSyscall6(SB)
30 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/unix/asm_openbsd_amd64.s:
--------------------------------------------------------------------------------
 1 | // Copyright 2009 The Go Authors. All rights reserved.
 2 | // Use of this source code is governed by a BSD-style
 3 | // license that can be found in the LICENSE file.
 4 | 
 5 | // +build !gccgo
 6 | 
 7 | #include "textflag.h"
 8 | 
 9 | //
10 | // System call support for AMD64, OpenBSD
11 | //
12 | 
13 | // Just jump to package syscall's implementation for all these functions.
14 | // The runtime may know about them.
15 | 
16 | TEXT	·Syscall(SB),NOSPLIT,$0-56
17 | 	JMP	syscall·Syscall(SB)
18 | 
19 | TEXT	·Syscall6(SB),NOSPLIT,$0-80
20 | 	JMP	syscall·Syscall6(SB)
21 | 
22 | TEXT	·Syscall9(SB),NOSPLIT,$0-104
23 | 	JMP	syscall·Syscall9(SB)
24 | 
25 | TEXT	·RawSyscall(SB),NOSPLIT,$0-56
26 | 	JMP	syscall·RawSyscall(SB)
27 | 
28 | TEXT	·RawSyscall6(SB),NOSPLIT,$0-80
29 | 	JMP	syscall·RawSyscall6(SB)
30 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/unix/asm_openbsd_arm.s:
--------------------------------------------------------------------------------
 1 | // Copyright 2017 The Go Authors. All rights reserved.
 2 | // Use of this source code is governed by a BSD-style
 3 | // license that can be found in the LICENSE file.
 4 | 
 5 | // +build !gccgo
 6 | 
 7 | #include "textflag.h"
 8 | 
 9 | //
10 | // System call support for ARM, OpenBSD
11 | //
12 | 
13 | // Just jump to package syscall's implementation for all these functions.
14 | // The runtime may know about them.
15 | 
16 | TEXT	·Syscall(SB),NOSPLIT,$0-28
17 | 	B	syscall·Syscall(SB)
18 | 
19 | TEXT	·Syscall6(SB),NOSPLIT,$0-40
20 | 	B	syscall·Syscall6(SB)
21 | 
22 | TEXT	·Syscall9(SB),NOSPLIT,$0-52
23 | 	B	syscall·Syscall9(SB)
24 | 
25 | TEXT	·RawSyscall(SB),NOSPLIT,$0-28
26 | 	B	syscall·RawSyscall(SB)
27 | 
28 | TEXT	·RawSyscall6(SB),NOSPLIT,$0-40
29 | 	B	syscall·RawSyscall6(SB)
30 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/unix/asm_solaris_amd64.s:
--------------------------------------------------------------------------------
 1 | // Copyright 2014 The Go Authors. All rights reserved.
 2 | // Use of this source code is governed by a BSD-style
 3 | // license that can be found in the LICENSE file.
 4 | 
 5 | // +build !gccgo
 6 | 
 7 | #include "textflag.h"
 8 | 
 9 | //
10 | // System calls for amd64, Solaris are implemented in runtime/syscall_solaris.go
11 | //
12 | 
13 | TEXT ·sysvicall6(SB),NOSPLIT,$0-88
14 | 	JMP	syscall·sysvicall6(SB)
15 | 
16 | TEXT ·rawSysvicall6(SB),NOSPLIT,$0-88
17 | 	JMP	syscall·rawSysvicall6(SB)
18 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/unix/bluetooth_linux.go:
--------------------------------------------------------------------------------
 1 | // Copyright 2016 The Go Authors. All rights reserved.
 2 | // Use of this source code is governed by a BSD-style
 3 | // license that can be found in the LICENSE file.
 4 | 
 5 | // Bluetooth sockets and messages
 6 | 
 7 | package unix
 8 | 
 9 | // Bluetooth Protocols
10 | const (
11 | 	BTPROTO_L2CAP  = 0
12 | 	BTPROTO_HCI    = 1
13 | 	BTPROTO_SCO    = 2
14 | 	BTPROTO_RFCOMM = 3
15 | 	BTPROTO_BNEP   = 4
16 | 	BTPROTO_CMTP   = 5
17 | 	BTPROTO_HIDP   = 6
18 | 	BTPROTO_AVDTP  = 7
19 | )
20 | 
21 | const (
22 | 	HCI_CHANNEL_RAW     = 0
23 | 	HCI_CHANNEL_USER    = 1
24 | 	HCI_CHANNEL_MONITOR = 2
25 | 	HCI_CHANNEL_CONTROL = 3
26 | )
27 | 
28 | // Socketoption Level
29 | const (
30 | 	SOL_BLUETOOTH = 0x112
31 | 	SOL_HCI       = 0x0
32 | 	SOL_L2CAP     = 0x6
33 | 	SOL_RFCOMM    = 0x12
34 | 	SOL_SCO       = 0x11
35 | )
36 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/unix/constants.go:
--------------------------------------------------------------------------------
 1 | // Copyright 2015 The Go Authors. All rights reserved.
 2 | // Use of this source code is governed by a BSD-style
 3 | // license that can be found in the LICENSE file.
 4 | 
 5 | // +build aix darwin dragonfly freebsd linux netbsd openbsd solaris
 6 | 
 7 | package unix
 8 | 
 9 | const (
10 | 	R_OK = 0x4
11 | 	W_OK = 0x2
12 | 	X_OK = 0x1
13 | )
14 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/unix/dev_aix_ppc.go:
--------------------------------------------------------------------------------
 1 | // Copyright 2018 The Go Authors. All rights reserved.
 2 | // Use of this source code is governed by a BSD-style
 3 | // license that can be found in the LICENSE file.
 4 | 
 5 | // +build aix
 6 | // +build ppc
 7 | 
 8 | // Functions to access/create device major and minor numbers matching the
 9 | // encoding used by the Linux kernel and glibc.
10 | //
11 | // The information below is extracted and adapted from bits/sysmacros.h in the
12 | // glibc sources:
13 | //
14 | // dev_t in glibc is 64-bit, with 32-bit major and minor numbers. glibc's
15 | // default encoding is MMMM Mmmm mmmM MMmm, where M is a hex digit of the major
16 | // number and m is a hex digit of the minor number. This is backward compatible
17 | // with legacy systems where dev_t is 16 bits wide, encoded as MMmm. It is also
18 | // backward compatible with the Linux kernel, which for some architectures uses
19 | // 32-bit dev_t, encoded as mmmM MMmm.
20 | 
21 | package unix
22 | 
23 | // Major returns the major component of a Linux device number.
24 | func Major(dev uint64) uint32 {
25 | 	return uint32((dev >> 16) & 0xffff)
26 | }
27 | 
28 | // Minor returns the minor component of a Linux device number.
29 | func Minor(dev uint64) uint32 {
30 | 	return uint32(dev & 0xffff)
31 | }
32 | 
33 | // Mkdev returns a Linux device number generated from the given major and minor
34 | // components.
35 | func Mkdev(major, minor uint32) uint64 {
36 | 	return uint64(((major) << 16) | (minor))
37 | }
38 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/unix/dev_aix_ppc64.go:
--------------------------------------------------------------------------------
 1 | // Copyright 2018 The Go Authors. All rights reserved.
 2 | // Use of this source code is governed by a BSD-style
 3 | // license that can be found in the LICENSE file.
 4 | 
 5 | // +build aix
 6 | // +build ppc64
 7 | 
 8 | // Functions to access/create device major and minor numbers matching the
 9 | // encoding used by the Linux kernel and glibc.
10 | //
11 | // The information below is extracted and adapted from bits/sysmacros.h in the
12 | // glibc sources:
13 | //
14 | // dev_t in glibc is 64-bit, with 32-bit major and minor numbers. glibc's
15 | // default encoding is MMMM Mmmm mmmM MMmm, where M is a hex digit of the major
16 | // number and m is a hex digit of the minor number. This is backward compatible
17 | // with legacy systems where dev_t is 16 bits wide, encoded as MMmm. It is also
18 | // backward compatible with the Linux kernel, which for some architectures uses
19 | // 32-bit dev_t, encoded as mmmM MMmm.
20 | 
21 | package unix
22 | 
23 | // Major returns the major component of a Linux device number.
24 | func Major(dev uint64) uint32 {
25 | 	return uint32((dev & 0x3fffffff00000000) >> 32)
26 | }
27 | 
28 | // Minor returns the minor component of a Linux device number.
29 | func Minor(dev uint64) uint32 {
30 | 	return uint32((dev & 0x00000000ffffffff) >> 0)
31 | }
32 | 
33 | // Mkdev returns a Linux device number generated from the given major and minor
34 | // components.
35 | func Mkdev(major, minor uint32) uint64 {
36 | 	var DEVNO64 uint64
37 | 	DEVNO64 = 0x8000000000000000
38 | 	return ((uint64(major) << 32) | (uint64(minor) & 0x00000000FFFFFFFF) | DEVNO64)
39 | }
40 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/unix/dev_darwin.go:
--------------------------------------------------------------------------------
 1 | // Copyright 2017 The Go Authors. All rights reserved.
 2 | // Use of this source code is governed by a BSD-style
 3 | // license that can be found in the LICENSE file.
 4 | 
 5 | // Functions to access/create device major and minor numbers matching the
 6 | // encoding used in Darwin's sys/types.h header.
 7 | 
 8 | package unix
 9 | 
10 | // Major returns the major component of a Darwin device number.
11 | func Major(dev uint64) uint32 {
12 | 	return uint32((dev >> 24) & 0xff)
13 | }
14 | 
15 | // Minor returns the minor component of a Darwin device number.
16 | func Minor(dev uint64) uint32 {
17 | 	return uint32(dev & 0xffffff)
18 | }
19 | 
20 | // Mkdev returns a Darwin device number generated from the given major and minor
21 | // components.
22 | func Mkdev(major, minor uint32) uint64 {
23 | 	return (uint64(major) << 24) | uint64(minor)
24 | }
25 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/unix/dev_dragonfly.go:
--------------------------------------------------------------------------------
 1 | // Copyright 2017 The Go Authors. All rights reserved.
 2 | // Use of this source code is governed by a BSD-style
 3 | // license that can be found in the LICENSE file.
 4 | 
 5 | // Functions to access/create device major and minor numbers matching the
 6 | // encoding used in Dragonfly's sys/types.h header.
 7 | //
 8 | // The information below is extracted and adapted from sys/types.h:
 9 | //
10 | // Minor gives a cookie instead of an index since in order to avoid changing the
11 | // meanings of bits 0-15 or wasting time and space shifting bits 16-31 for
12 | // devices that don't use them.
13 | 
14 | package unix
15 | 
16 | // Major returns the major component of a DragonFlyBSD device number.
17 | func Major(dev uint64) uint32 {
18 | 	return uint32((dev >> 8) & 0xff)
19 | }
20 | 
21 | // Minor returns the minor component of a DragonFlyBSD device number.
22 | func Minor(dev uint64) uint32 {
23 | 	return uint32(dev & 0xffff00ff)
24 | }
25 | 
26 | // Mkdev returns a DragonFlyBSD device number generated from the given major and
27 | // minor components.
28 | func Mkdev(major, minor uint32) uint64 {
29 | 	return (uint64(major) << 8) | uint64(minor)
30 | }
31 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/unix/dev_freebsd.go:
--------------------------------------------------------------------------------
 1 | // Copyright 2017 The Go Authors. All rights reserved.
 2 | // Use of this source code is governed by a BSD-style
 3 | // license that can be found in the LICENSE file.
 4 | 
 5 | // Functions to access/create device major and minor numbers matching the
 6 | // encoding used in FreeBSD's sys/types.h header.
 7 | //
 8 | // The information below is extracted and adapted from sys/types.h:
 9 | //
10 | // Minor gives a cookie instead of an index since in order to avoid changing the
11 | // meanings of bits 0-15 or wasting time and space shifting bits 16-31 for
12 | // devices that don't use them.
13 | 
14 | package unix
15 | 
16 | // Major returns the major component of a FreeBSD device number.
17 | func Major(dev uint64) uint32 {
18 | 	return uint32((dev >> 8) & 0xff)
19 | }
20 | 
21 | // Minor returns the minor component of a FreeBSD device number.
22 | func Minor(dev uint64) uint32 {
23 | 	return uint32(dev & 0xffff00ff)
24 | }
25 | 
26 | // Mkdev returns a FreeBSD device number generated from the given major and
27 | // minor components.
28 | func Mkdev(major, minor uint32) uint64 {
29 | 	return (uint64(major) << 8) | uint64(minor)
30 | }
31 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/unix/dev_linux.go:
--------------------------------------------------------------------------------
 1 | // Copyright 2017 The Go Authors. All rights reserved.
 2 | // Use of this source code is governed by a BSD-style
 3 | // license that can be found in the LICENSE file.
 4 | 
 5 | // Functions to access/create device major and minor numbers matching the
 6 | // encoding used by the Linux kernel and glibc.
 7 | //
 8 | // The information below is extracted and adapted from bits/sysmacros.h in the
 9 | // glibc sources:
10 | //
11 | // dev_t in glibc is 64-bit, with 32-bit major and minor numbers. glibc's
12 | // default encoding is MMMM Mmmm mmmM MMmm, where M is a hex digit of the major
13 | // number and m is a hex digit of the minor number. This is backward compatible
14 | // with legacy systems where dev_t is 16 bits wide, encoded as MMmm. It is also
15 | // backward compatible with the Linux kernel, which for some architectures uses
16 | // 32-bit dev_t, encoded as mmmM MMmm.
17 | 
18 | package unix
19 | 
20 | // Major returns the major component of a Linux device number.
21 | func Major(dev uint64) uint32 {
22 | 	major := uint32((dev & 0x00000000000fff00) >> 8)
23 | 	major |= uint32((dev & 0xfffff00000000000) >> 32)
24 | 	return major
25 | }
26 | 
27 | // Minor returns the minor component of a Linux device number.
28 | func Minor(dev uint64) uint32 {
29 | 	minor := uint32((dev & 0x00000000000000ff) >> 0)
30 | 	minor |= uint32((dev & 0x00000ffffff00000) >> 12)
31 | 	return minor
32 | }
33 | 
34 | // Mkdev returns a Linux device number generated from the given major and minor
35 | // components.
36 | func Mkdev(major, minor uint32) uint64 {
37 | 	dev := (uint64(major) & 0x00000fff) << 8
38 | 	dev |= (uint64(major) & 0xfffff000) << 32
39 | 	dev |= (uint64(minor) & 0x000000ff) << 0
40 | 	dev |= (uint64(minor) & 0xffffff00) << 12
41 | 	return dev
42 | }
43 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/unix/dev_netbsd.go:
--------------------------------------------------------------------------------
 1 | // Copyright 2017 The Go Authors. All rights reserved.
 2 | // Use of this source code is governed by a BSD-style
 3 | // license that can be found in the LICENSE file.
 4 | 
 5 | // Functions to access/create device major and minor numbers matching the
 6 | // encoding used in NetBSD's sys/types.h header.
 7 | 
 8 | package unix
 9 | 
10 | // Major returns the major component of a NetBSD device number.
11 | func Major(dev uint64) uint32 {
12 | 	return uint32((dev & 0x000fff00) >> 8)
13 | }
14 | 
15 | // Minor returns the minor component of a NetBSD device number.
16 | func Minor(dev uint64) uint32 {
17 | 	minor := uint32((dev & 0x000000ff) >> 0)
18 | 	minor |= uint32((dev & 0xfff00000) >> 12)
19 | 	return minor
20 | }
21 | 
22 | // Mkdev returns a NetBSD device number generated from the given major and minor
23 | // components.
24 | func Mkdev(major, minor uint32) uint64 {
25 | 	dev := (uint64(major) << 8) & 0x000fff00
26 | 	dev |= (uint64(minor) << 12) & 0xfff00000
27 | 	dev |= (uint64(minor) << 0) & 0x000000ff
28 | 	return dev
29 | }
30 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/unix/dev_openbsd.go:
--------------------------------------------------------------------------------
 1 | // Copyright 2017 The Go Authors. All rights reserved.
 2 | // Use of this source code is governed by a BSD-style
 3 | // license that can be found in the LICENSE file.
 4 | 
 5 | // Functions to access/create device major and minor numbers matching the
 6 | // encoding used in OpenBSD's sys/types.h header.
 7 | 
 8 | package unix
 9 | 
10 | // Major returns the major component of an OpenBSD device number.
11 | func Major(dev uint64) uint32 {
12 | 	return uint32((dev & 0x0000ff00) >> 8)
13 | }
14 | 
15 | // Minor returns the minor component of an OpenBSD device number.
16 | func Minor(dev uint64) uint32 {
17 | 	minor := uint32((dev & 0x000000ff) >> 0)
18 | 	minor |= uint32((dev & 0xffff0000) >> 8)
19 | 	return minor
20 | }
21 | 
22 | // Mkdev returns an OpenBSD device number generated from the given major and minor
23 | // components.
24 | func Mkdev(major, minor uint32) uint64 {
25 | 	dev := (uint64(major) << 8) & 0x0000ff00
26 | 	dev |= (uint64(minor) << 8) & 0xffff0000
27 | 	dev |= (uint64(minor) << 0) & 0x000000ff
28 | 	return dev
29 | }
30 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/unix/dirent.go:
--------------------------------------------------------------------------------
 1 | // Copyright 2009 The Go Authors. All rights reserved.
 2 | // Use of this source code is governed by a BSD-style
 3 | // license that can be found in the LICENSE file.
 4 | 
 5 | // +build aix darwin dragonfly freebsd linux nacl netbsd openbsd solaris
 6 | 
 7 | package unix
 8 | 
 9 | import "syscall"
10 | 
11 | // ParseDirent parses up to max directory entries in buf,
12 | // appending the names to names. It returns the number of
13 | // bytes consumed from buf, the number of entries added
14 | // to names, and the new names slice.
15 | func ParseDirent(buf []byte, max int, names []string) (consumed int, count int, newnames []string) {
16 | 	return syscall.ParseDirent(buf, max, names)
17 | }
18 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/unix/endian_big.go:
--------------------------------------------------------------------------------
 1 | // Copyright 2016 The Go Authors. All rights reserved.
 2 | // Use of this source code is governed by a BSD-style
 3 | // license that can be found in the LICENSE file.
 4 | //
 5 | // +build ppc64 s390x mips mips64
 6 | 
 7 | package unix
 8 | 
 9 | const isBigEndian = true
10 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/unix/endian_little.go:
--------------------------------------------------------------------------------
 1 | // Copyright 2016 The Go Authors. All rights reserved.
 2 | // Use of this source code is governed by a BSD-style
 3 | // license that can be found in the LICENSE file.
 4 | //
 5 | // +build 386 amd64 amd64p32 arm arm64 ppc64le mipsle mips64le
 6 | 
 7 | package unix
 8 | 
 9 | const isBigEndian = false
10 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/unix/env_unix.go:
--------------------------------------------------------------------------------
 1 | // Copyright 2010 The Go Authors. All rights reserved.
 2 | // Use of this source code is governed by a BSD-style
 3 | // license that can be found in the LICENSE file.
 4 | 
 5 | // +build aix darwin dragonfly freebsd linux netbsd openbsd solaris
 6 | 
 7 | // Unix environment variables.
 8 | 
 9 | package unix
10 | 
11 | import "syscall"
12 | 
13 | func Getenv(key string) (value string, found bool) {
14 | 	return syscall.Getenv(key)
15 | }
16 | 
17 | func Setenv(key, value string) error {
18 | 	return syscall.Setenv(key, value)
19 | }
20 | 
21 | func Clearenv() {
22 | 	syscall.Clearenv()
23 | }
24 | 
25 | func Environ() []string {
26 | 	return syscall.Environ()
27 | }
28 | 
29 | func Unsetenv(key string) error {
30 | 	return syscall.Unsetenv(key)
31 | }
32 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/unix/fcntl.go:
--------------------------------------------------------------------------------
 1 | // Copyright 2014 The Go Authors. All rights reserved.
 2 | // Use of this source code is governed by a BSD-style
 3 | // license that can be found in the LICENSE file.
 4 | 
 5 | // +build darwin dragonfly freebsd linux netbsd openbsd
 6 | 
 7 | package unix
 8 | 
 9 | import "unsafe"
10 | 
11 | // fcntl64Syscall is usually SYS_FCNTL, but is overridden on 32-bit Linux
12 | // systems by flock_linux_32bit.go to be SYS_FCNTL64.
13 | var fcntl64Syscall uintptr = SYS_FCNTL
14 | 
15 | // FcntlInt performs a fcntl syscall on fd with the provided command and argument.
16 | func FcntlInt(fd uintptr, cmd, arg int) (int, error) {
17 | 	valptr, _, errno := Syscall(fcntl64Syscall, fd, uintptr(cmd), uintptr(arg))
18 | 	var err error
19 | 	if errno != 0 {
20 | 		err = errno
21 | 	}
22 | 	return int(valptr), err
23 | }
24 | 
25 | // FcntlFlock performs a fcntl syscall for the F_GETLK, F_SETLK or F_SETLKW command.
26 | func FcntlFlock(fd uintptr, cmd int, lk *Flock_t) error {
27 | 	_, _, errno := Syscall(fcntl64Syscall, fd, uintptr(cmd), uintptr(unsafe.Pointer(lk)))
28 | 	if errno == 0 {
29 | 		return nil
30 | 	}
31 | 	return errno
32 | }
33 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/unix/fcntl_linux_32bit.go:
--------------------------------------------------------------------------------
 1 | // +build linux,386 linux,arm linux,mips linux,mipsle
 2 | 
 3 | // Copyright 2014 The Go Authors. All rights reserved.
 4 | // Use of this source code is governed by a BSD-style
 5 | // license that can be found in the LICENSE file.
 6 | 
 7 | package unix
 8 | 
 9 | func init() {
10 | 	// On 32-bit Linux systems, the fcntl syscall that matches Go's
11 | 	// Flock_t type is SYS_FCNTL64, not SYS_FCNTL.
12 | 	fcntl64Syscall = SYS_FCNTL64
13 | }
14 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/unix/gccgo.go:
--------------------------------------------------------------------------------
 1 | // Copyright 2015 The Go Authors. All rights reserved.
 2 | // Use of this source code is governed by a BSD-style
 3 | // license that can be found in the LICENSE file.
 4 | 
 5 | // +build gccgo
 6 | // +build !aix
 7 | 
 8 | package unix
 9 | 
10 | import "syscall"
11 | 
12 | // We can't use the gc-syntax .s files for gccgo. On the plus side
13 | // much of the functionality can be written directly in Go.
14 | 
15 | //extern gccgoRealSyscallNoError
16 | func realSyscallNoError(trap, a1, a2, a3, a4, a5, a6, a7, a8, a9 uintptr) (r uintptr)
17 | 
18 | //extern gccgoRealSyscall
19 | func realSyscall(trap, a1, a2, a3, a4, a5, a6, a7, a8, a9 uintptr) (r, errno uintptr)
20 | 
21 | func SyscallNoError(trap, a1, a2, a3 uintptr) (r1, r2 uintptr) {
22 | 	syscall.Entersyscall()
23 | 	r := realSyscallNoError(trap, a1, a2, a3, 0, 0, 0, 0, 0, 0)
24 | 	syscall.Exitsyscall()
25 | 	return r, 0
26 | }
27 | 
28 | func Syscall(trap, a1, a2, a3 uintptr) (r1, r2 uintptr, err syscall.Errno) {
29 | 	syscall.Entersyscall()
30 | 	r, errno := realSyscall(trap, a1, a2, a3, 0, 0, 0, 0, 0, 0)
31 | 	syscall.Exitsyscall()
32 | 	return r, 0, syscall.Errno(errno)
33 | }
34 | 
35 | func Syscall6(trap, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr, err syscall.Errno) {
36 | 	syscall.Entersyscall()
37 | 	r, errno := realSyscall(trap, a1, a2, a3, a4, a5, a6, 0, 0, 0)
38 | 	syscall.Exitsyscall()
39 | 	return r, 0, syscall.Errno(errno)
40 | }
41 | 
42 | func Syscall9(trap, a1, a2, a3, a4, a5, a6, a7, a8, a9 uintptr) (r1, r2 uintptr, err syscall.Errno) {
43 | 	syscall.Entersyscall()
44 | 	r, errno := realSyscall(trap, a1, a2, a3, a4, a5, a6, a7, a8, a9)
45 | 	syscall.Exitsyscall()
46 | 	return r, 0, syscall.Errno(errno)
47 | }
48 | 
49 | func RawSyscallNoError(trap, a1, a2, a3 uintptr) (r1, r2 uintptr) {
50 | 	r := realSyscallNoError(trap, a1, a2, a3, 0, 0, 0, 0, 0, 0)
51 | 	return r, 0
52 | }
53 | 
54 | func RawSyscall(trap, a1, a2, a3 uintptr) (r1, r2 uintptr, err syscall.Errno) {
55 | 	r, errno := realSyscall(trap, a1, a2, a3, 0, 0, 0, 0, 0, 0)
56 | 	return r, 0, syscall.Errno(errno)
57 | }
58 | 
59 | func RawSyscall6(trap, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr, err syscall.Errno) {
60 | 	r, errno := realSyscall(trap, a1, a2, a3, a4, a5, a6, 0, 0, 0)
61 | 	return r, 0, syscall.Errno(errno)
62 | }
63 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/unix/gccgo_c.c:
--------------------------------------------------------------------------------
 1 | // Copyright 2015 The Go Authors. All rights reserved.
 2 | // Use of this source code is governed by a BSD-style
 3 | // license that can be found in the LICENSE file.
 4 | 
 5 | // +build gccgo
 6 | // +build !aix
 7 | 
 8 | #include <errno.h>
 9 | #include <stdint.h>
10 | #include <unistd.h>
11 | 
12 | #define _STRINGIFY2_(x) #x
13 | #define _STRINGIFY_(x) _STRINGIFY2_(x)
14 | #define GOSYM_PREFIX _STRINGIFY_(__USER_LABEL_PREFIX__)
15 | 
16 | // Call syscall from C code because the gccgo support for calling from
17 | // Go to C does not support varargs functions.
18 | 
19 | struct ret {
20 | 	uintptr_t r;
21 | 	uintptr_t err;
22 | };
23 | 
24 | struct ret
25 | gccgoRealSyscall(uintptr_t trap, uintptr_t a1, uintptr_t a2, uintptr_t a3, uintptr_t a4, uintptr_t a5, uintptr_t a6, uintptr_t a7, uintptr_t a8, uintptr_t a9)
26 | {
27 | 	struct ret r;
28 | 
29 | 	errno = 0;
30 | 	r.r = syscall(trap, a1, a2, a3, a4, a5, a6, a7, a8, a9);
31 | 	r.err = errno;
32 | 	return r;
33 | }
34 | 
35 | uintptr_t
36 | gccgoRealSyscallNoError(uintptr_t trap, uintptr_t a1, uintptr_t a2, uintptr_t a3, uintptr_t a4, uintptr_t a5, uintptr_t a6, uintptr_t a7, uintptr_t a8, uintptr_t a9)
37 | {
38 | 	return syscall(trap, a1, a2, a3, a4, a5, a6, a7, a8, a9);
39 | }
40 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/unix/gccgo_linux_amd64.go:
--------------------------------------------------------------------------------
 1 | // Copyright 2015 The Go Authors. All rights reserved.
 2 | // Use of this source code is governed by a BSD-style
 3 | // license that can be found in the LICENSE file.
 4 | 
 5 | // +build gccgo,linux,amd64
 6 | 
 7 | package unix
 8 | 
 9 | import "syscall"
10 | 
11 | //extern gettimeofday
12 | func realGettimeofday(*Timeval, *byte) int32
13 | 
14 | func gettimeofday(tv *Timeval) (err syscall.Errno) {
15 | 	r := realGettimeofday(tv, nil)
16 | 	if r < 0 {
17 | 		return syscall.GetErrno()
18 | 	}
19 | 	return 0
20 | }
21 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/unix/ioctl.go:
--------------------------------------------------------------------------------
 1 | // Copyright 2018 The Go Authors. All rights reserved.
 2 | // Use of this source code is governed by a BSD-style
 3 | // license that can be found in the LICENSE file.
 4 | 
 5 | // +build darwin dragonfly freebsd linux netbsd openbsd solaris
 6 | 
 7 | package unix
 8 | 
 9 | import "runtime"
10 | 
11 | // IoctlSetWinsize performs an ioctl on fd with a *Winsize argument.
12 | //
13 | // To change fd's window size, the req argument should be TIOCSWINSZ.
14 | func IoctlSetWinsize(fd int, req uint, value *Winsize) error {
15 | 	// TODO: if we get the chance, remove the req parameter and
16 | 	// hardcode TIOCSWINSZ.
17 | 	err := ioctlSetWinsize(fd, req, value)
18 | 	runtime.KeepAlive(value)
19 | 	return err
20 | }
21 | 
22 | // IoctlSetTermios performs an ioctl on fd with a *Termios.
23 | //
24 | // The req value will usually be TCSETA or TIOCSETA.
25 | func IoctlSetTermios(fd int, req uint, value *Termios) error {
26 | 	// TODO: if we get the chance, remove the req parameter.
27 | 	err := ioctlSetTermios(fd, req, value)
28 | 	runtime.KeepAlive(value)
29 | 	return err
30 | }
31 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/unix/mksysnum_darwin.pl:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env perl
 2 | # Copyright 2009 The Go Authors. All rights reserved.
 3 | # Use of this source code is governed by a BSD-style
 4 | # license that can be found in the LICENSE file.
 5 | #
 6 | # Generate system call table for Darwin from sys/syscall.h
 7 | 
 8 | use strict;
 9 | 
10 | if($ENV{'GOARCH'} eq "" || $ENV{'GOOS'} eq "") {
11 | 	print STDERR "GOARCH or GOOS not defined in environment\n";
12 | 	exit 1;
13 | }
14 | 
15 | my $command = "mksysnum_darwin.pl " . join(' ', @ARGV);
16 | 
17 | print <<EOF;
18 | // $command
19 | // Code generated by the command above; see README.md. DO NOT EDIT.
20 | 
21 | // +build $ENV{'GOARCH'},$ENV{'GOOS'}
22 | 
23 | package unix
24 | 
25 | const (
26 | EOF
27 | 
28 | while(<>){
29 | 	if(/^#define\s+SYS_(\w+)\s+([0-9]+)/){
30 | 		my $name = $1;
31 | 		my $num = $2;
32 | 		$name =~ y/a-z/A-Z/;
33 | 		print "	SYS_$name = $num;"
34 | 	}
35 | }
36 | 
37 | print <<EOF;
38 | )
39 | EOF
40 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/unix/mksysnum_dragonfly.pl:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env perl
 2 | # Copyright 2009 The Go Authors. All rights reserved.
 3 | # Use of this source code is governed by a BSD-style
 4 | # license that can be found in the LICENSE file.
 5 | #
 6 | # Generate system call table for DragonFly from master list
 7 | # (for example, /usr/src/sys/kern/syscalls.master).
 8 | 
 9 | use strict;
10 | 
11 | if($ENV{'GOARCH'} eq "" || $ENV{'GOOS'} eq "") {
12 | 	print STDERR "GOARCH or GOOS not defined in environment\n";
13 | 	exit 1;
14 | }
15 | 
16 | my $command = "mksysnum_dragonfly.pl " . join(' ', @ARGV);
17 | 
18 | print <<EOF;
19 | // $command
20 | // Code generated by the command above; see README.md. DO NOT EDIT.
21 | 
22 | // +build $ENV{'GOARCH'},$ENV{'GOOS'}
23 | 
24 | package unix
25 | 
26 | const (
27 | EOF
28 | 
29 | while(<>){
30 | 	if(/^([0-9]+)\s+STD\s+({ \S+\s+(\w+).*)$/){
31 | 		my $num = $1;
32 | 		my $proto = $2;
33 | 		my $name = "SYS_$3";
34 | 		$name =~ y/a-z/A-Z/;
35 | 
36 | 		# There are multiple entries for enosys and nosys, so comment them out.
37 | 		if($name =~ /^SYS_E?NOSYS$/){
38 | 			$name = "// $name";
39 | 		}
40 | 		if($name eq 'SYS_SYS_EXIT'){
41 | 			$name = 'SYS_EXIT';
42 | 		}
43 | 
44 | 		print "	$name = $num;  // $proto\n";
45 | 	}
46 | }
47 | 
48 | print <<EOF;
49 | )
50 | EOF
51 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/unix/mksysnum_freebsd.pl:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env perl
 2 | # Copyright 2009 The Go Authors. All rights reserved.
 3 | # Use of this source code is governed by a BSD-style
 4 | # license that can be found in the LICENSE file.
 5 | #
 6 | # Generate system call table for FreeBSD from master list
 7 | # (for example, /usr/src/sys/kern/syscalls.master).
 8 | 
 9 | use strict;
10 | 
11 | if($ENV{'GOARCH'} eq "" || $ENV{'GOOS'} eq "") {
12 | 	print STDERR "GOARCH or GOOS not defined in environment\n";
13 | 	exit 1;
14 | }
15 | 
16 | my $command = "mksysnum_freebsd.pl " . join(' ', @ARGV);
17 | 
18 | print <<EOF;
19 | // $command
20 | // Code generated by the command above; see README.md. DO NOT EDIT.
21 | 
22 | // +build $ENV{'GOARCH'},$ENV{'GOOS'}
23 | 
24 | package unix
25 | 
26 | const (
27 | EOF
28 | 
29 | while(<>){
30 | 	if(/^([0-9]+)\s+\S+\s+(?:NO)?STD\s+({ \S+\s+(\w+).*)$/){
31 | 		my $num = $1;
32 | 		my $proto = $2;
33 | 		my $name = "SYS_$3";
34 | 		$name =~ y/a-z/A-Z/;
35 | 
36 | 		# There are multiple entries for enosys and nosys, so comment them out.
37 | 		if($name =~ /^SYS_E?NOSYS$/){
38 | 			$name = "// $name";
39 | 		}
40 | 		if($name eq 'SYS_SYS_EXIT'){
41 | 			$name = 'SYS_EXIT';
42 | 		}
43 | 
44 | 		print "	$name = $num;  // $proto\n";
45 | 	}
46 | }
47 | 
48 | print <<EOF;
49 | )
50 | EOF
51 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/unix/mksysnum_netbsd.pl:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env perl
 2 | # Copyright 2009 The Go Authors. All rights reserved.
 3 | # Use of this source code is governed by a BSD-style
 4 | # license that can be found in the LICENSE file.
 5 | #
 6 | # Generate system call table for OpenBSD from master list
 7 | # (for example, /usr/src/sys/kern/syscalls.master).
 8 | 
 9 | use strict;
10 | 
11 | if($ENV{'GOARCH'} eq "" || $ENV{'GOOS'} eq "") {
12 | 	print STDERR "GOARCH or GOOS not defined in environment\n";
13 | 	exit 1;
14 | }
15 | 
16 | my $command = "mksysnum_netbsd.pl " . join(' ', @ARGV);
17 | 
18 | print <<EOF;
19 | // $command
20 | // Code generated by the command above; see README.md. DO NOT EDIT.
21 | 
22 | // +build $ENV{'GOARCH'},$ENV{'GOOS'}
23 | 
24 | package unix
25 | 
26 | const (
27 | EOF
28 | 
29 | my $line = '';
30 | while(<>){
31 | 	if($line =~ /^(.*)\\$/) {
32 | 		# Handle continuation
33 | 		$line = $1;
34 | 		$_ =~ s/^\s+//;
35 | 		$line .= $_;
36 | 	} else {
37 | 		# New line
38 | 		$line = $_;
39 | 	}
40 | 	next if $line =~ /\\$/;
41 | 	if($line =~ /^([0-9]+)\s+((STD)|(NOERR))\s+(RUMP\s+)?({\s+\S+\s*\*?\s*\|(\S+)\|(\S*)\|(\w+).*\s+})(\s+(\S+))?$/) {
42 | 		my $num = $1;
43 | 		my $proto = $6;
44 | 		my $compat = $8;
45 | 		my $name = "$7_$9";
46 | 
47 | 		$name = "$7_$11" if $11 ne '';
48 | 		$name =~ y/a-z/A-Z/;
49 | 
50 | 		if($compat eq '' || $compat eq '13' || $compat eq '30' || $compat eq '50') {
51 | 			print "	$name = $num;  // $proto\n";
52 | 		}
53 | 	}
54 | }
55 | 
56 | print <<EOF;
57 | )
58 | EOF
59 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/unix/mksysnum_openbsd.pl:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env perl
 2 | # Copyright 2009 The Go Authors. All rights reserved.
 3 | # Use of this source code is governed by a BSD-style
 4 | # license that can be found in the LICENSE file.
 5 | #
 6 | # Generate system call table for OpenBSD from master list
 7 | # (for example, /usr/src/sys/kern/syscalls.master).
 8 | 
 9 | use strict;
10 | 
11 | if($ENV{'GOARCH'} eq "" || $ENV{'GOOS'} eq "") {
12 | 	print STDERR "GOARCH or GOOS not defined in environment\n";
13 | 	exit 1;
14 | }
15 | 
16 | my $command = "mksysnum_openbsd.pl " . join(' ', @ARGV);
17 | 
18 | print <<EOF;
19 | // $command
20 | // Code generated by the command above; see README.md. DO NOT EDIT.
21 | 
22 | // +build $ENV{'GOARCH'},$ENV{'GOOS'}
23 | 
24 | package unix
25 | 
26 | const (
27 | EOF
28 | 
29 | while(<>){
30 | 	if(/^([0-9]+)\s+STD\s+(NOLOCK\s+)?({ \S+\s+\*?(\w+).*)$/){
31 | 		my $num = $1;
32 | 		my $proto = $3;
33 | 		my $name = $4;
34 | 		$name =~ y/a-z/A-Z/;
35 | 
36 | 		# There are multiple entries for enosys and nosys, so comment them out.
37 | 		if($name =~ /^SYS_E?NOSYS$/){
38 | 			$name = "// $name";
39 | 		}
40 | 		if($name eq 'SYS_SYS_EXIT'){
41 | 			$name = 'SYS_EXIT';
42 | 		}
43 | 
44 | 		print "	$name = $num;  // $proto\n";
45 | 	}
46 | }
47 | 
48 | print <<EOF;
49 | )
50 | EOF
51 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/unix/openbsd_pledge.go:
--------------------------------------------------------------------------------
 1 | // Copyright 2016 The Go Authors. All rights reserved.
 2 | // Use of this source code is governed by a BSD-style
 3 | // license that can be found in the LICENSE file.
 4 | 
 5 | // +build openbsd
 6 | // +build 386 amd64 arm
 7 | 
 8 | package unix
 9 | 
10 | import (
11 | 	"errors"
12 | 	"fmt"
13 | 	"strconv"
14 | 	"syscall"
15 | 	"unsafe"
16 | )
17 | 
18 | const (
19 | 	_SYS_PLEDGE = 108
20 | )
21 | 
22 | // Pledge implements the pledge syscall.
23 | //
24 | // The pledge syscall does not accept execpromises on OpenBSD releases
25 | // before 6.3.
26 | //
27 | // execpromises must be empty when Pledge is called on OpenBSD
28 | // releases predating 6.3, otherwise an error will be returned.
29 | //
30 | // For more information see pledge(2).
31 | func Pledge(promises, execpromises string) error {
32 | 	maj, min, err := majmin()
33 | 	if err != nil {
34 | 		return err
35 | 	}
36 | 
37 | 	// If OpenBSD <= 5.9, pledge is not available.
38 | 	if (maj == 5 && min != 9) || maj < 5 {
39 | 		return fmt.Errorf("pledge syscall is not available on OpenBSD %d.%d", maj, min)
40 | 	}
41 | 
42 | 	// If OpenBSD <= 6.2 and execpromises is not empty
43 | 	// return an error - execpromises is not available before 6.3
44 | 	if (maj < 6 || (maj == 6 && min <= 2)) && execpromises != "" {
45 | 		return fmt.Errorf("cannot use execpromises on OpenBSD %d.%d", maj, min)
46 | 	}
47 | 
48 | 	pptr, err := syscall.BytePtrFromString(promises)
49 | 	if err != nil {
50 | 		return err
51 | 	}
52 | 
53 | 	// This variable will hold either a nil unsafe.Pointer or
54 | 	// an unsafe.Pointer to a string (execpromises).
55 | 	var expr unsafe.Pointer
56 | 
57 | 	// If we're running on OpenBSD > 6.2, pass execpromises to the syscall.
58 | 	if maj > 6 || (maj == 6 && min > 2) {
59 | 		exptr, err := syscall.BytePtrFromString(execpromises)
60 | 		if err != nil {
61 | 			return err
62 | 		}
63 | 		expr = unsafe.Pointer(exptr)
64 | 	}
65 | 
66 | 	_, _, e := syscall.Syscall(_SYS_PLEDGE, uintptr(unsafe.Pointer(pptr)), uintptr(expr), 0)
67 | 	if e != 0 {
68 | 		return e
69 | 	}
70 | 
71 | 	return nil
72 | }
73 | 
74 | // majmin returns major and minor version number for an OpenBSD system.
75 | func majmin() (major int, minor int, err error) {
76 | 	var v Utsname
77 | 	err = Uname(&v)
78 | 	if err != nil {
79 | 		return
80 | 	}
81 | 
82 | 	major, err = strconv.Atoi(string(v.Release[0]))
83 | 	if err != nil {
84 | 		err = errors.New("cannot parse major version number returned by uname")
85 | 		return
86 | 	}
87 | 
88 | 	minor, err = strconv.Atoi(string(v.Release[2]))
89 | 	if err != nil {
90 | 		err = errors.New("cannot parse minor version number returned by uname")
91 | 		return
92 | 	}
93 | 
94 | 	return
95 | }
96 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/unix/pagesize_unix.go:
--------------------------------------------------------------------------------
 1 | // Copyright 2017 The Go Authors. All rights reserved.
 2 | // Use of this source code is governed by a BSD-style
 3 | // license that can be found in the LICENSE file.
 4 | 
 5 | // +build aix darwin dragonfly freebsd linux netbsd openbsd solaris
 6 | 
 7 | // For Unix, get the pagesize from the runtime.
 8 | 
 9 | package unix
10 | 
11 | import "syscall"
12 | 
13 | func Getpagesize() int {
14 | 	return syscall.Getpagesize()
15 | }
16 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/unix/race.go:
--------------------------------------------------------------------------------
 1 | // Copyright 2012 The Go Authors. All rights reserved.
 2 | // Use of this source code is governed by a BSD-style
 3 | // license that can be found in the LICENSE file.
 4 | 
 5 | // +build darwin,race linux,race freebsd,race
 6 | 
 7 | package unix
 8 | 
 9 | import (
10 | 	"runtime"
11 | 	"unsafe"
12 | )
13 | 
14 | const raceenabled = true
15 | 
16 | func raceAcquire(addr unsafe.Pointer) {
17 | 	runtime.RaceAcquire(addr)
18 | }
19 | 
20 | func raceReleaseMerge(addr unsafe.Pointer) {
21 | 	runtime.RaceReleaseMerge(addr)
22 | }
23 | 
24 | func raceReadRange(addr unsafe.Pointer, len int) {
25 | 	runtime.RaceReadRange(addr, len)
26 | }
27 | 
28 | func raceWriteRange(addr unsafe.Pointer, len int) {
29 | 	runtime.RaceWriteRange(addr, len)
30 | }
31 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/unix/race0.go:
--------------------------------------------------------------------------------
 1 | // Copyright 2012 The Go Authors. All rights reserved.
 2 | // Use of this source code is governed by a BSD-style
 3 | // license that can be found in the LICENSE file.
 4 | 
 5 | // +build aix darwin,!race linux,!race freebsd,!race netbsd openbsd solaris dragonfly
 6 | 
 7 | package unix
 8 | 
 9 | import (
10 | 	"unsafe"
11 | )
12 | 
13 | const raceenabled = false
14 | 
15 | func raceAcquire(addr unsafe.Pointer) {
16 | }
17 | 
18 | func raceReleaseMerge(addr unsafe.Pointer) {
19 | }
20 | 
21 | func raceReadRange(addr unsafe.Pointer, len int) {
22 | }
23 | 
24 | func raceWriteRange(addr unsafe.Pointer, len int) {
25 | }
26 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/unix/sockcmsg_linux.go:
--------------------------------------------------------------------------------
 1 | // Copyright 2011 The Go Authors. All rights reserved.
 2 | // Use of this source code is governed by a BSD-style
 3 | // license that can be found in the LICENSE file.
 4 | 
 5 | // Socket control messages
 6 | 
 7 | package unix
 8 | 
 9 | import "unsafe"
10 | 
11 | // UnixCredentials encodes credentials into a socket control message
12 | // for sending to another process. This can be used for
13 | // authentication.
14 | func UnixCredentials(ucred *Ucred) []byte {
15 | 	b := make([]byte, CmsgSpace(SizeofUcred))
16 | 	h := (*Cmsghdr)(unsafe.Pointer(&b[0]))
17 | 	h.Level = SOL_SOCKET
18 | 	h.Type = SCM_CREDENTIALS
19 | 	h.SetLen(CmsgLen(SizeofUcred))
20 | 	*((*Ucred)(cmsgData(h))) = *ucred
21 | 	return b
22 | }
23 | 
24 | // ParseUnixCredentials decodes a socket control message that contains
25 | // credentials in a Ucred structure. To receive such a message, the
26 | // SO_PASSCRED option must be enabled on the socket.
27 | func ParseUnixCredentials(m *SocketControlMessage) (*Ucred, error) {
28 | 	if m.Header.Level != SOL_SOCKET {
29 | 		return nil, EINVAL
30 | 	}
31 | 	if m.Header.Type != SCM_CREDENTIALS {
32 | 		return nil, EINVAL
33 | 	}
34 | 	ucred := *(*Ucred)(unsafe.Pointer(&m.Data[0]))
35 | 	return &ucred, nil
36 | }
37 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/unix/sockcmsg_unix.go:
--------------------------------------------------------------------------------
  1 | // Copyright 2011 The Go Authors. All rights reserved.
  2 | // Use of this source code is governed by a BSD-style
  3 | // license that can be found in the LICENSE file.
  4 | 
  5 | // +build aix darwin dragonfly freebsd linux netbsd openbsd solaris
  6 | 
  7 | // Socket control messages
  8 | 
  9 | package unix
 10 | 
 11 | import "unsafe"
 12 | 
 13 | // Round the length of a raw sockaddr up to align it properly.
 14 | func cmsgAlignOf(salen int) int {
 15 | 	salign := sizeofPtr
 16 | 	// NOTE: It seems like 64-bit Darwin, DragonFly BSD and
 17 | 	// Solaris kernels still require 32-bit aligned access to
 18 | 	// network subsystem.
 19 | 	if darwin64Bit || dragonfly64Bit || solaris64Bit {
 20 | 		salign = 4
 21 | 	}
 22 | 	return (salen + salign - 1) & ^(salign - 1)
 23 | }
 24 | 
 25 | // CmsgLen returns the value to store in the Len field of the Cmsghdr
 26 | // structure, taking into account any necessary alignment.
 27 | func CmsgLen(datalen int) int {
 28 | 	return cmsgAlignOf(SizeofCmsghdr) + datalen
 29 | }
 30 | 
 31 | // CmsgSpace returns the number of bytes an ancillary element with
 32 | // payload of the passed data length occupies.
 33 | func CmsgSpace(datalen int) int {
 34 | 	return cmsgAlignOf(SizeofCmsghdr) + cmsgAlignOf(datalen)
 35 | }
 36 | 
 37 | func cmsgData(h *Cmsghdr) unsafe.Pointer {
 38 | 	return unsafe.Pointer(uintptr(unsafe.Pointer(h)) + uintptr(cmsgAlignOf(SizeofCmsghdr)))
 39 | }
 40 | 
 41 | // SocketControlMessage represents a socket control message.
 42 | type SocketControlMessage struct {
 43 | 	Header Cmsghdr
 44 | 	Data   []byte
 45 | }
 46 | 
 47 | // ParseSocketControlMessage parses b as an array of socket control
 48 | // messages.
 49 | func ParseSocketControlMessage(b []byte) ([]SocketControlMessage, error) {
 50 | 	var msgs []SocketControlMessage
 51 | 	i := 0
 52 | 	for i+CmsgLen(0) <= len(b) {
 53 | 		h, dbuf, err := socketControlMessageHeaderAndData(b[i:])
 54 | 		if err != nil {
 55 | 			return nil, err
 56 | 		}
 57 | 		m := SocketControlMessage{Header: *h, Data: dbuf}
 58 | 		msgs = append(msgs, m)
 59 | 		i += cmsgAlignOf(int(h.Len))
 60 | 	}
 61 | 	return msgs, nil
 62 | }
 63 | 
 64 | func socketControlMessageHeaderAndData(b []byte) (*Cmsghdr, []byte, error) {
 65 | 	h := (*Cmsghdr)(unsafe.Pointer(&b[0]))
 66 | 	if h.Len < SizeofCmsghdr || uint64(h.Len) > uint64(len(b)) {
 67 | 		return nil, nil, EINVAL
 68 | 	}
 69 | 	return h, b[cmsgAlignOf(SizeofCmsghdr):h.Len], nil
 70 | }
 71 | 
 72 | // UnixRights encodes a set of open file descriptors into a socket
 73 | // control message for sending to another process.
 74 | func UnixRights(fds ...int) []byte {
 75 | 	datalen := len(fds) * 4
 76 | 	b := make([]byte, CmsgSpace(datalen))
 77 | 	h := (*Cmsghdr)(unsafe.Pointer(&b[0]))
 78 | 	h.Level = SOL_SOCKET
 79 | 	h.Type = SCM_RIGHTS
 80 | 	h.SetLen(CmsgLen(datalen))
 81 | 	data := cmsgData(h)
 82 | 	for _, fd := range fds {
 83 | 		*(*int32)(data) = int32(fd)
 84 | 		data = unsafe.Pointer(uintptr(data) + 4)
 85 | 	}
 86 | 	return b
 87 | }
 88 | 
 89 | // ParseUnixRights decodes a socket control message that contains an
 90 | // integer array of open file descriptors from another process.
 91 | func ParseUnixRights(m *SocketControlMessage) ([]int, error) {
 92 | 	if m.Header.Level != SOL_SOCKET {
 93 | 		return nil, EINVAL
 94 | 	}
 95 | 	if m.Header.Type != SCM_RIGHTS {
 96 | 		return nil, EINVAL
 97 | 	}
 98 | 	fds := make([]int, len(m.Data)>>2)
 99 | 	for i, j := 0, 0; i < len(m.Data); i += 4 {
100 | 		fds[j] = int(*(*int32)(unsafe.Pointer(&m.Data[i])))
101 | 		j++
102 | 	}
103 | 	return fds, nil
104 | }
105 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/unix/str.go:
--------------------------------------------------------------------------------
 1 | // Copyright 2009 The Go Authors. All rights reserved.
 2 | // Use of this source code is governed by a BSD-style
 3 | // license that can be found in the LICENSE file.
 4 | 
 5 | // +build aix darwin dragonfly freebsd linux netbsd openbsd solaris
 6 | 
 7 | package unix
 8 | 
 9 | func itoa(val int) string { // do it here rather than with fmt to avoid dependency
10 | 	if val < 0 {
11 | 		return "-" + uitoa(uint(-val))
12 | 	}
13 | 	return uitoa(uint(val))
14 | }
15 | 
16 | func uitoa(val uint) string {
17 | 	var buf [32]byte // big enough for int64
18 | 	i := len(buf) - 1
19 | 	for val >= 10 {
20 | 		buf[i] = byte(val%10 + '0')
21 | 		i--
22 | 		val /= 10
23 | 	}
24 | 	buf[i] = byte(val + '0')
25 | 	return string(buf[i:])
26 | }
27 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/unix/syscall.go:
--------------------------------------------------------------------------------
 1 | // Copyright 2009 The Go Authors. All rights reserved.
 2 | // Use of this source code is governed by a BSD-style
 3 | // license that can be found in the LICENSE file.
 4 | 
 5 | // +build aix darwin dragonfly freebsd linux netbsd openbsd solaris
 6 | 
 7 | // Package unix contains an interface to the low-level operating system
 8 | // primitives. OS details vary depending on the underlying system, and
 9 | // by default, godoc will display OS-specific documentation for the current
10 | // system. If you want godoc to display OS documentation for another
11 | // system, set $GOOS and $GOARCH to the desired system. For example, if
12 | // you want to view documentation for freebsd/arm on linux/amd64, set $GOOS
13 | // to freebsd and $GOARCH to arm.
14 | //
15 | // The primary use of this package is inside other packages that provide a more
16 | // portable interface to the system, such as "os", "time" and "net".  Use
17 | // those packages rather than this one if you can.
18 | //
19 | // For details of the functions and data types in this package consult
20 | // the manuals for the appropriate operating system.
21 | //
22 | // These calls return err == nil to indicate success; otherwise
23 | // err represents an operating system error describing the failure and
24 | // holds a value of type syscall.Errno.
25 | package unix // import "golang.org/x/sys/unix"
26 | 
27 | import "strings"
28 | 
29 | // ByteSliceFromString returns a NUL-terminated slice of bytes
30 | // containing the text of s. If s contains a NUL byte at any
31 | // location, it returns (nil, EINVAL).
32 | func ByteSliceFromString(s string) ([]byte, error) {
33 | 	if strings.IndexByte(s, 0) != -1 {
34 | 		return nil, EINVAL
35 | 	}
36 | 	a := make([]byte, len(s)+1)
37 | 	copy(a, s)
38 | 	return a, nil
39 | }
40 | 
41 | // BytePtrFromString returns a pointer to a NUL-terminated array of
42 | // bytes containing the text of s. If s contains a NUL byte at any
43 | // location, it returns (nil, EINVAL).
44 | func BytePtrFromString(s string) (*byte, error) {
45 | 	a, err := ByteSliceFromString(s)
46 | 	if err != nil {
47 | 		return nil, err
48 | 	}
49 | 	return &a[0], nil
50 | }
51 | 
52 | // Single-word zero for use when we need a valid pointer to 0 bytes.
53 | // See mkunix.pl.
54 | var _zero uintptr
55 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/unix/syscall_aix_ppc.go:
--------------------------------------------------------------------------------
 1 | // Copyright 2018 The Go Authors. All rights reserved.
 2 | // Use of this source code is governed by a BSD-style
 3 | // license that can be found in the LICENSE file.
 4 | 
 5 | // +build aix
 6 | // +build ppc
 7 | 
 8 | package unix
 9 | 
10 | //sysnb	Getrlimit(resource int, rlim *Rlimit) (err error) = getrlimit64
11 | //sysnb	Setrlimit(resource int, rlim *Rlimit) (err error) = setrlimit64
12 | //sys	Seek(fd int, offset int64, whence int) (off int64, err error) = lseek64
13 | 
14 | //sys	mmap(addr uintptr, length uintptr, prot int, flags int, fd int, offset int64) (xaddr uintptr, err error)
15 | 
16 | func setTimespec(sec, nsec int64) Timespec {
17 | 	return Timespec{Sec: int32(sec), Nsec: int32(nsec)}
18 | }
19 | 
20 | func setTimeval(sec, usec int64) Timeval {
21 | 	return Timeval{Sec: int32(sec), Usec: int32(usec)}
22 | }
23 | 
24 | func (iov *Iovec) SetLen(length int) {
25 | 	iov.Len = uint32(length)
26 | }
27 | 
28 | func (msghdr *Msghdr) SetControllen(length int) {
29 | 	msghdr.Controllen = uint32(length)
30 | }
31 | 
32 | func (cmsg *Cmsghdr) SetLen(length int) {
33 | 	cmsg.Len = uint32(length)
34 | }
35 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/unix/syscall_aix_ppc64.go:
--------------------------------------------------------------------------------
 1 | // Copyright 2018 The Go Authors. All rights reserved.
 2 | // Use of this source code is governed by a BSD-style
 3 | // license that can be found in the LICENSE file.
 4 | 
 5 | // +build aix
 6 | // +build ppc64
 7 | 
 8 | package unix
 9 | 
10 | //sysnb	Getrlimit(resource int, rlim *Rlimit) (err error)
11 | //sysnb	Setrlimit(resource int, rlim *Rlimit) (err error)
12 | //sys	Seek(fd int, offset int64, whence int) (off int64, err error) = lseek
13 | 
14 | //sys	mmap(addr uintptr, length uintptr, prot int, flags int, fd int, offset int64) (xaddr uintptr, err error) = mmap64
15 | 
16 | func setTimespec(sec, nsec int64) Timespec {
17 | 	return Timespec{Sec: sec, Nsec: nsec}
18 | }
19 | 
20 | func setTimeval(sec, usec int64) Timeval {
21 | 	return Timeval{Sec: int64(sec), Usec: int32(usec)}
22 | }
23 | 
24 | func (iov *Iovec) SetLen(length int) {
25 | 	iov.Len = uint64(length)
26 | }
27 | 
28 | func (msghdr *Msghdr) SetControllen(length int) {
29 | 	msghdr.Controllen = uint32(length)
30 | }
31 | 
32 | func (cmsg *Cmsghdr) SetLen(length int) {
33 | 	cmsg.Len = uint32(length)
34 | }
35 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/unix/syscall_darwin_386.go:
--------------------------------------------------------------------------------
 1 | // Copyright 2009 The Go Authors. All rights reserved.
 2 | // Use of this source code is governed by a BSD-style
 3 | // license that can be found in the LICENSE file.
 4 | 
 5 | // +build 386,darwin
 6 | 
 7 | package unix
 8 | 
 9 | import (
10 | 	"syscall"
11 | 	"unsafe"
12 | )
13 | 
14 | func setTimespec(sec, nsec int64) Timespec {
15 | 	return Timespec{Sec: int32(sec), Nsec: int32(nsec)}
16 | }
17 | 
18 | func setTimeval(sec, usec int64) Timeval {
19 | 	return Timeval{Sec: int32(sec), Usec: int32(usec)}
20 | }
21 | 
22 | //sysnb	gettimeofday(tp *Timeval) (sec int32, usec int32, err error)
23 | func Gettimeofday(tv *Timeval) (err error) {
24 | 	// The tv passed to gettimeofday must be non-nil
25 | 	// but is otherwise unused. The answers come back
26 | 	// in the two registers.
27 | 	sec, usec, err := gettimeofday(tv)
28 | 	tv.Sec = int32(sec)
29 | 	tv.Usec = int32(usec)
30 | 	return err
31 | }
32 | 
33 | func SetKevent(k *Kevent_t, fd, mode, flags int) {
34 | 	k.Ident = uint32(fd)
35 | 	k.Filter = int16(mode)
36 | 	k.Flags = uint16(flags)
37 | }
38 | 
39 | func (iov *Iovec) SetLen(length int) {
40 | 	iov.Len = uint32(length)
41 | }
42 | 
43 | func (msghdr *Msghdr) SetControllen(length int) {
44 | 	msghdr.Controllen = uint32(length)
45 | }
46 | 
47 | func (cmsg *Cmsghdr) SetLen(length int) {
48 | 	cmsg.Len = uint32(length)
49 | }
50 | 
51 | func sendfile(outfd int, infd int, offset *int64, count int) (written int, err error) {
52 | 	var length = uint64(count)
53 | 
54 | 	_, _, e1 := Syscall9(SYS_SENDFILE, uintptr(infd), uintptr(outfd), uintptr(*offset), uintptr(*offset>>32), uintptr(unsafe.Pointer(&length)), 0, 0, 0, 0)
55 | 
56 | 	written = int(length)
57 | 
58 | 	if e1 != 0 {
59 | 		err = e1
60 | 	}
61 | 	return
62 | }
63 | 
64 | func Syscall9(num, a1, a2, a3, a4, a5, a6, a7, a8, a9 uintptr) (r1, r2 uintptr, err syscall.Errno)
65 | 
66 | // SYS___SYSCTL is used by syscall_bsd.go for all BSDs, but in modern versions
67 | // of darwin/386 the syscall is called sysctl instead of __sysctl.
68 | const SYS___SYSCTL = SYS_SYSCTL
69 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/unix/syscall_darwin_amd64.go:
--------------------------------------------------------------------------------
 1 | // Copyright 2009 The Go Authors. All rights reserved.
 2 | // Use of this source code is governed by a BSD-style
 3 | // license that can be found in the LICENSE file.
 4 | 
 5 | // +build amd64,darwin
 6 | 
 7 | package unix
 8 | 
 9 | import (
10 | 	"syscall"
11 | 	"unsafe"
12 | )
13 | 
14 | func setTimespec(sec, nsec int64) Timespec {
15 | 	return Timespec{Sec: sec, Nsec: nsec}
16 | }
17 | 
18 | func setTimeval(sec, usec int64) Timeval {
19 | 	return Timeval{Sec: sec, Usec: int32(usec)}
20 | }
21 | 
22 | //sysnb	gettimeofday(tp *Timeval) (sec int64, usec int32, err error)
23 | func Gettimeofday(tv *Timeval) (err error) {
24 | 	// The tv passed to gettimeofday must be non-nil
25 | 	// but is otherwise unused. The answers come back
26 | 	// in the two registers.
27 | 	sec, usec, err := gettimeofday(tv)
28 | 	tv.Sec = sec
29 | 	tv.Usec = usec
30 | 	return err
31 | }
32 | 
33 | func SetKevent(k *Kevent_t, fd, mode, flags int) {
34 | 	k.Ident = uint64(fd)
35 | 	k.Filter = int16(mode)
36 | 	k.Flags = uint16(flags)
37 | }
38 | 
39 | func (iov *Iovec) SetLen(length int) {
40 | 	iov.Len = uint64(length)
41 | }
42 | 
43 | func (msghdr *Msghdr) SetControllen(length int) {
44 | 	msghdr.Controllen = uint32(length)
45 | }
46 | 
47 | func (cmsg *Cmsghdr) SetLen(length int) {
48 | 	cmsg.Len = uint32(length)
49 | }
50 | 
51 | func sendfile(outfd int, infd int, offset *int64, count int) (written int, err error) {
52 | 	var length = uint64(count)
53 | 
54 | 	_, _, e1 := Syscall6(SYS_SENDFILE, uintptr(infd), uintptr(outfd), uintptr(*offset), uintptr(unsafe.Pointer(&length)), 0, 0)
55 | 
56 | 	written = int(length)
57 | 
58 | 	if e1 != 0 {
59 | 		err = e1
60 | 	}
61 | 	return
62 | }
63 | 
64 | func Syscall9(num, a1, a2, a3, a4, a5, a6, a7, a8, a9 uintptr) (r1, r2 uintptr, err syscall.Errno)
65 | 
66 | // SYS___SYSCTL is used by syscall_bsd.go for all BSDs, but in modern versions
67 | // of darwin/amd64 the syscall is called sysctl instead of __sysctl.
68 | const SYS___SYSCTL = SYS_SYSCTL
69 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/unix/syscall_darwin_arm.go:
--------------------------------------------------------------------------------
 1 | // Copyright 2015 The Go Authors. All rights reserved.
 2 | // Use of this source code is governed by a BSD-style
 3 | // license that can be found in the LICENSE file.
 4 | 
 5 | package unix
 6 | 
 7 | import (
 8 | 	"syscall"
 9 | 	"unsafe"
10 | )
11 | 
12 | func setTimespec(sec, nsec int64) Timespec {
13 | 	return Timespec{Sec: int32(sec), Nsec: int32(nsec)}
14 | }
15 | 
16 | func setTimeval(sec, usec int64) Timeval {
17 | 	return Timeval{Sec: int32(sec), Usec: int32(usec)}
18 | }
19 | 
20 | //sysnb	gettimeofday(tp *Timeval) (sec int32, usec int32, err error)
21 | func Gettimeofday(tv *Timeval) (err error) {
22 | 	// The tv passed to gettimeofday must be non-nil
23 | 	// but is otherwise unused. The answers come back
24 | 	// in the two registers.
25 | 	sec, usec, err := gettimeofday(tv)
26 | 	tv.Sec = int32(sec)
27 | 	tv.Usec = int32(usec)
28 | 	return err
29 | }
30 | 
31 | func SetKevent(k *Kevent_t, fd, mode, flags int) {
32 | 	k.Ident = uint32(fd)
33 | 	k.Filter = int16(mode)
34 | 	k.Flags = uint16(flags)
35 | }
36 | 
37 | func (iov *Iovec) SetLen(length int) {
38 | 	iov.Len = uint32(length)
39 | }
40 | 
41 | func (msghdr *Msghdr) SetControllen(length int) {
42 | 	msghdr.Controllen = uint32(length)
43 | }
44 | 
45 | func (cmsg *Cmsghdr) SetLen(length int) {
46 | 	cmsg.Len = uint32(length)
47 | }
48 | 
49 | func sendfile(outfd int, infd int, offset *int64, count int) (written int, err error) {
50 | 	var length = uint64(count)
51 | 
52 | 	_, _, e1 := Syscall9(SYS_SENDFILE, uintptr(infd), uintptr(outfd), uintptr(*offset), uintptr(*offset>>32), uintptr(unsafe.Pointer(&length)), 0, 0, 0, 0)
53 | 
54 | 	written = int(length)
55 | 
56 | 	if e1 != 0 {
57 | 		err = e1
58 | 	}
59 | 	return
60 | }
61 | 
62 | func Syscall9(num, a1, a2, a3, a4, a5, a6, a7, a8, a9 uintptr) (r1, r2 uintptr, err syscall.Errno) // sic
63 | 
64 | // SYS___SYSCTL is used by syscall_bsd.go for all BSDs, but in modern versions
65 | // of darwin/arm the syscall is called sysctl instead of __sysctl.
66 | const SYS___SYSCTL = SYS_SYSCTL
67 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/unix/syscall_darwin_arm64.go:
--------------------------------------------------------------------------------
 1 | // Copyright 2015 The Go Authors. All rights reserved.
 2 | // Use of this source code is governed by a BSD-style
 3 | // license that can be found in the LICENSE file.
 4 | 
 5 | // +build arm64,darwin
 6 | 
 7 | package unix
 8 | 
 9 | import (
10 | 	"syscall"
11 | 	"unsafe"
12 | )
13 | 
14 | func setTimespec(sec, nsec int64) Timespec {
15 | 	return Timespec{Sec: sec, Nsec: nsec}
16 | }
17 | 
18 | func setTimeval(sec, usec int64) Timeval {
19 | 	return Timeval{Sec: sec, Usec: int32(usec)}
20 | }
21 | 
22 | //sysnb	gettimeofday(tp *Timeval) (sec int64, usec int32, err error)
23 | func Gettimeofday(tv *Timeval) (err error) {
24 | 	// The tv passed to gettimeofday must be non-nil
25 | 	// but is otherwise unused. The answers come back
26 | 	// in the two registers.
27 | 	sec, usec, err := gettimeofday(tv)
28 | 	tv.Sec = sec
29 | 	tv.Usec = usec
30 | 	return err
31 | }
32 | 
33 | func SetKevent(k *Kevent_t, fd, mode, flags int) {
34 | 	k.Ident = uint64(fd)
35 | 	k.Filter = int16(mode)
36 | 	k.Flags = uint16(flags)
37 | }
38 | 
39 | func (iov *Iovec) SetLen(length int) {
40 | 	iov.Len = uint64(length)
41 | }
42 | 
43 | func (msghdr *Msghdr) SetControllen(length int) {
44 | 	msghdr.Controllen = uint32(length)
45 | }
46 | 
47 | func (cmsg *Cmsghdr) SetLen(length int) {
48 | 	cmsg.Len = uint32(length)
49 | }
50 | 
51 | func sendfile(outfd int, infd int, offset *int64, count int) (written int, err error) {
52 | 	var length = uint64(count)
53 | 
54 | 	_, _, e1 := Syscall6(SYS_SENDFILE, uintptr(infd), uintptr(outfd), uintptr(*offset), uintptr(unsafe.Pointer(&length)), 0, 0)
55 | 
56 | 	written = int(length)
57 | 
58 | 	if e1 != 0 {
59 | 		err = e1
60 | 	}
61 | 	return
62 | }
63 | 
64 | func Syscall9(num, a1, a2, a3, a4, a5, a6, a7, a8, a9 uintptr) (r1, r2 uintptr, err syscall.Errno) // sic
65 | 
66 | // SYS___SYSCTL is used by syscall_bsd.go for all BSDs, but in modern versions
67 | // of darwin/arm64 the syscall is called sysctl instead of __sysctl.
68 | const SYS___SYSCTL = SYS_SYSCTL
69 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/unix/syscall_dragonfly_amd64.go:
--------------------------------------------------------------------------------
 1 | // Copyright 2009 The Go Authors. All rights reserved.
 2 | // Use of this source code is governed by a BSD-style
 3 | // license that can be found in the LICENSE file.
 4 | 
 5 | // +build amd64,dragonfly
 6 | 
 7 | package unix
 8 | 
 9 | import (
10 | 	"syscall"
11 | 	"unsafe"
12 | )
13 | 
14 | func setTimespec(sec, nsec int64) Timespec {
15 | 	return Timespec{Sec: sec, Nsec: nsec}
16 | }
17 | 
18 | func setTimeval(sec, usec int64) Timeval {
19 | 	return Timeval{Sec: sec, Usec: usec}
20 | }
21 | 
22 | func SetKevent(k *Kevent_t, fd, mode, flags int) {
23 | 	k.Ident = uint64(fd)
24 | 	k.Filter = int16(mode)
25 | 	k.Flags = uint16(flags)
26 | }
27 | 
28 | func (iov *Iovec) SetLen(length int) {
29 | 	iov.Len = uint64(length)
30 | }
31 | 
32 | func (msghdr *Msghdr) SetControllen(length int) {
33 | 	msghdr.Controllen = uint32(length)
34 | }
35 | 
36 | func (cmsg *Cmsghdr) SetLen(length int) {
37 | 	cmsg.Len = uint32(length)
38 | }
39 | 
40 | func sendfile(outfd int, infd int, offset *int64, count int) (written int, err error) {
41 | 	var writtenOut uint64 = 0
42 | 	_, _, e1 := Syscall9(SYS_SENDFILE, uintptr(infd), uintptr(outfd), uintptr(*offset), uintptr(count), 0, uintptr(unsafe.Pointer(&writtenOut)), 0, 0, 0)
43 | 
44 | 	written = int(writtenOut)
45 | 
46 | 	if e1 != 0 {
47 | 		err = e1
48 | 	}
49 | 	return
50 | }
51 | 
52 | func Syscall9(num, a1, a2, a3, a4, a5, a6, a7, a8, a9 uintptr) (r1, r2 uintptr, err syscall.Errno)
53 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/unix/syscall_freebsd_386.go:
--------------------------------------------------------------------------------
 1 | // Copyright 2009 The Go Authors. All rights reserved.
 2 | // Use of this source code is governed by a BSD-style
 3 | // license that can be found in the LICENSE file.
 4 | 
 5 | // +build 386,freebsd
 6 | 
 7 | package unix
 8 | 
 9 | import (
10 | 	"syscall"
11 | 	"unsafe"
12 | )
13 | 
14 | func setTimespec(sec, nsec int64) Timespec {
15 | 	return Timespec{Sec: int32(sec), Nsec: int32(nsec)}
16 | }
17 | 
18 | func setTimeval(sec, usec int64) Timeval {
19 | 	return Timeval{Sec: int32(sec), Usec: int32(usec)}
20 | }
21 | 
22 | func SetKevent(k *Kevent_t, fd, mode, flags int) {
23 | 	k.Ident = uint32(fd)
24 | 	k.Filter = int16(mode)
25 | 	k.Flags = uint16(flags)
26 | }
27 | 
28 | func (iov *Iovec) SetLen(length int) {
29 | 	iov.Len = uint32(length)
30 | }
31 | 
32 | func (msghdr *Msghdr) SetControllen(length int) {
33 | 	msghdr.Controllen = uint32(length)
34 | }
35 | 
36 | func (cmsg *Cmsghdr) SetLen(length int) {
37 | 	cmsg.Len = uint32(length)
38 | }
39 | 
40 | func sendfile(outfd int, infd int, offset *int64, count int) (written int, err error) {
41 | 	var writtenOut uint64 = 0
42 | 	_, _, e1 := Syscall9(SYS_SENDFILE, uintptr(infd), uintptr(outfd), uintptr(*offset), uintptr((*offset)>>32), uintptr(count), 0, uintptr(unsafe.Pointer(&writtenOut)), 0, 0)
43 | 
44 | 	written = int(writtenOut)
45 | 
46 | 	if e1 != 0 {
47 | 		err = e1
48 | 	}
49 | 	return
50 | }
51 | 
52 | func Syscall9(num, a1, a2, a3, a4, a5, a6, a7, a8, a9 uintptr) (r1, r2 uintptr, err syscall.Errno)
53 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/unix/syscall_freebsd_amd64.go:
--------------------------------------------------------------------------------
 1 | // Copyright 2009 The Go Authors. All rights reserved.
 2 | // Use of this source code is governed by a BSD-style
 3 | // license that can be found in the LICENSE file.
 4 | 
 5 | // +build amd64,freebsd
 6 | 
 7 | package unix
 8 | 
 9 | import (
10 | 	"syscall"
11 | 	"unsafe"
12 | )
13 | 
14 | func setTimespec(sec, nsec int64) Timespec {
15 | 	return Timespec{Sec: sec, Nsec: nsec}
16 | }
17 | 
18 | func setTimeval(sec, usec int64) Timeval {
19 | 	return Timeval{Sec: sec, Usec: usec}
20 | }
21 | 
22 | func SetKevent(k *Kevent_t, fd, mode, flags int) {
23 | 	k.Ident = uint64(fd)
24 | 	k.Filter = int16(mode)
25 | 	k.Flags = uint16(flags)
26 | }
27 | 
28 | func (iov *Iovec) SetLen(length int) {
29 | 	iov.Len = uint64(length)
30 | }
31 | 
32 | func (msghdr *Msghdr) SetControllen(length int) {
33 | 	msghdr.Controllen = uint32(length)
34 | }
35 | 
36 | func (cmsg *Cmsghdr) SetLen(length int) {
37 | 	cmsg.Len = uint32(length)
38 | }
39 | 
40 | func sendfile(outfd int, infd int, offset *int64, count int) (written int, err error) {
41 | 	var writtenOut uint64 = 0
42 | 	_, _, e1 := Syscall9(SYS_SENDFILE, uintptr(infd), uintptr(outfd), uintptr(*offset), uintptr(count), 0, uintptr(unsafe.Pointer(&writtenOut)), 0, 0, 0)
43 | 
44 | 	written = int(writtenOut)
45 | 
46 | 	if e1 != 0 {
47 | 		err = e1
48 | 	}
49 | 	return
50 | }
51 | 
52 | func Syscall9(num, a1, a2, a3, a4, a5, a6, a7, a8, a9 uintptr) (r1, r2 uintptr, err syscall.Errno)
53 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/unix/syscall_freebsd_arm.go:
--------------------------------------------------------------------------------
 1 | // Copyright 2012 The Go Authors. All rights reserved.
 2 | // Use of this source code is governed by a BSD-style
 3 | // license that can be found in the LICENSE file.
 4 | 
 5 | // +build arm,freebsd
 6 | 
 7 | package unix
 8 | 
 9 | import (
10 | 	"syscall"
11 | 	"unsafe"
12 | )
13 | 
14 | func setTimespec(sec, nsec int64) Timespec {
15 | 	return Timespec{Sec: sec, Nsec: int32(nsec)}
16 | }
17 | 
18 | func setTimeval(sec, usec int64) Timeval {
19 | 	return Timeval{Sec: sec, Usec: int32(usec)}
20 | }
21 | 
22 | func SetKevent(k *Kevent_t, fd, mode, flags int) {
23 | 	k.Ident = uint32(fd)
24 | 	k.Filter = int16(mode)
25 | 	k.Flags = uint16(flags)
26 | }
27 | 
28 | func (iov *Iovec) SetLen(length int) {
29 | 	iov.Len = uint32(length)
30 | }
31 | 
32 | func (msghdr *Msghdr) SetControllen(length int) {
33 | 	msghdr.Controllen = uint32(length)
34 | }
35 | 
36 | func (cmsg *Cmsghdr) SetLen(length int) {
37 | 	cmsg.Len = uint32(length)
38 | }
39 | 
40 | func sendfile(outfd int, infd int, offset *int64, count int) (written int, err error) {
41 | 	var writtenOut uint64 = 0
42 | 	_, _, e1 := Syscall9(SYS_SENDFILE, uintptr(infd), uintptr(outfd), uintptr(*offset), uintptr((*offset)>>32), uintptr(count), 0, uintptr(unsafe.Pointer(&writtenOut)), 0, 0)
43 | 
44 | 	written = int(writtenOut)
45 | 
46 | 	if e1 != 0 {
47 | 		err = e1
48 | 	}
49 | 	return
50 | }
51 | 
52 | func Syscall9(num, a1, a2, a3, a4, a5, a6, a7, a8, a9 uintptr) (r1, r2 uintptr, err syscall.Errno)
53 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/unix/syscall_linux_amd64_gc.go:
--------------------------------------------------------------------------------
 1 | // Copyright 2016 The Go Authors. All rights reserved.
 2 | // Use of this source code is governed by a BSD-style
 3 | // license that can be found in the LICENSE file.
 4 | 
 5 | // +build amd64,linux
 6 | // +build !gccgo
 7 | 
 8 | package unix
 9 | 
10 | import "syscall"
11 | 
12 | //go:noescape
13 | func gettimeofday(tv *Timeval) (err syscall.Errno)
14 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/unix/syscall_linux_gc.go:
--------------------------------------------------------------------------------
 1 | // Copyright 2018 The Go Authors. All rights reserved.
 2 | // Use of this source code is governed by a BSD-style
 3 | // license that can be found in the LICENSE file.
 4 | 
 5 | // +build linux,!gccgo
 6 | 
 7 | package unix
 8 | 
 9 | // SyscallNoError may be used instead of Syscall for syscalls that don't fail.
10 | func SyscallNoError(trap, a1, a2, a3 uintptr) (r1, r2 uintptr)
11 | 
12 | // RawSyscallNoError may be used instead of RawSyscall for syscalls that don't
13 | // fail.
14 | func RawSyscallNoError(trap, a1, a2, a3 uintptr) (r1, r2 uintptr)
15 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/unix/syscall_linux_gc_386.go:
--------------------------------------------------------------------------------
 1 | // Copyright 2018 The Go Authors. All rights reserved.
 2 | // Use of this source code is governed by a BSD-style
 3 | // license that can be found in the LICENSE file.
 4 | 
 5 | // +build linux,!gccgo,386
 6 | 
 7 | package unix
 8 | 
 9 | import "syscall"
10 | 
11 | // Underlying system call writes to newoffset via pointer.
12 | // Implemented in assembly to avoid allocation.
13 | func seek(fd int, offset int64, whence int) (newoffset int64, err syscall.Errno)
14 | 
15 | func socketcall(call int, a0, a1, a2, a3, a4, a5 uintptr) (n int, err syscall.Errno)
16 | func rawsocketcall(call int, a0, a1, a2, a3, a4, a5 uintptr) (n int, err syscall.Errno)
17 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/unix/syscall_linux_gccgo_386.go:
--------------------------------------------------------------------------------
 1 | // Copyright 2018 The Go Authors. All rights reserved.
 2 | // Use of this source code is governed by a BSD-style
 3 | // license that can be found in the LICENSE file.
 4 | 
 5 | // +build linux,gccgo,386
 6 | 
 7 | package unix
 8 | 
 9 | import (
10 | 	"syscall"
11 | 	"unsafe"
12 | )
13 | 
14 | func seek(fd int, offset int64, whence int) (int64, syscall.Errno) {
15 | 	var newoffset int64
16 | 	offsetLow := uint32(offset & 0xffffffff)
17 | 	offsetHigh := uint32((offset >> 32) & 0xffffffff)
18 | 	_, _, err := Syscall6(SYS__LLSEEK, uintptr(fd), uintptr(offsetHigh), uintptr(offsetLow), uintptr(unsafe.Pointer(&newoffset)), uintptr(whence), 0)
19 | 	return newoffset, err
20 | }
21 | 
22 | func socketcall(call int, a0, a1, a2, a3, a4, a5 uintptr) (int, syscall.Errno) {
23 | 	fd, _, err := Syscall(SYS_SOCKETCALL, uintptr(call), uintptr(unsafe.Pointer(&a0)), 0)
24 | 	return int(fd), err
25 | }
26 | 
27 | func rawsocketcall(call int, a0, a1, a2, a3, a4, a5 uintptr) (int, syscall.Errno) {
28 | 	fd, _, err := RawSyscall(SYS_SOCKETCALL, uintptr(call), uintptr(unsafe.Pointer(&a0)), 0)
29 | 	return int(fd), err
30 | }
31 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/unix/syscall_linux_gccgo_arm.go:
--------------------------------------------------------------------------------
 1 | // Copyright 2018 The Go Authors. All rights reserved.
 2 | // Use of this source code is governed by a BSD-style
 3 | // license that can be found in the LICENSE file.
 4 | 
 5 | // +build linux,gccgo,arm
 6 | 
 7 | package unix
 8 | 
 9 | import (
10 | 	"syscall"
11 | 	"unsafe"
12 | )
13 | 
14 | func seek(fd int, offset int64, whence int) (int64, syscall.Errno) {
15 | 	var newoffset int64
16 | 	offsetLow := uint32(offset & 0xffffffff)
17 | 	offsetHigh := uint32((offset >> 32) & 0xffffffff)
18 | 	_, _, err := Syscall6(SYS__LLSEEK, uintptr(fd), uintptr(offsetHigh), uintptr(offsetLow), uintptr(unsafe.Pointer(&newoffset)), uintptr(whence), 0)
19 | 	return newoffset, err
20 | }
21 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/unix/syscall_netbsd_386.go:
--------------------------------------------------------------------------------
 1 | // Copyright 2009 The Go Authors. All rights reserved.
 2 | // Use of this source code is governed by a BSD-style
 3 | // license that can be found in the LICENSE file.
 4 | 
 5 | // +build 386,netbsd
 6 | 
 7 | package unix
 8 | 
 9 | func setTimespec(sec, nsec int64) Timespec {
10 | 	return Timespec{Sec: sec, Nsec: int32(nsec)}
11 | }
12 | 
13 | func setTimeval(sec, usec int64) Timeval {
14 | 	return Timeval{Sec: sec, Usec: int32(usec)}
15 | }
16 | 
17 | func SetKevent(k *Kevent_t, fd, mode, flags int) {
18 | 	k.Ident = uint32(fd)
19 | 	k.Filter = uint32(mode)
20 | 	k.Flags = uint32(flags)
21 | }
22 | 
23 | func (iov *Iovec) SetLen(length int) {
24 | 	iov.Len = uint32(length)
25 | }
26 | 
27 | func (msghdr *Msghdr) SetControllen(length int) {
28 | 	msghdr.Controllen = uint32(length)
29 | }
30 | 
31 | func (cmsg *Cmsghdr) SetLen(length int) {
32 | 	cmsg.Len = uint32(length)
33 | }
34 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/unix/syscall_netbsd_amd64.go:
--------------------------------------------------------------------------------
 1 | // Copyright 2009 The Go Authors. All rights reserved.
 2 | // Use of this source code is governed by a BSD-style
 3 | // license that can be found in the LICENSE file.
 4 | 
 5 | // +build amd64,netbsd
 6 | 
 7 | package unix
 8 | 
 9 | func setTimespec(sec, nsec int64) Timespec {
10 | 	return Timespec{Sec: sec, Nsec: nsec}
11 | }
12 | 
13 | func setTimeval(sec, usec int64) Timeval {
14 | 	return Timeval{Sec: sec, Usec: int32(usec)}
15 | }
16 | 
17 | func SetKevent(k *Kevent_t, fd, mode, flags int) {
18 | 	k.Ident = uint64(fd)
19 | 	k.Filter = uint32(mode)
20 | 	k.Flags = uint32(flags)
21 | }
22 | 
23 | func (iov *Iovec) SetLen(length int) {
24 | 	iov.Len = uint64(length)
25 | }
26 | 
27 | func (msghdr *Msghdr) SetControllen(length int) {
28 | 	msghdr.Controllen = uint32(length)
29 | }
30 | 
31 | func (cmsg *Cmsghdr) SetLen(length int) {
32 | 	cmsg.Len = uint32(length)
33 | }
34 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/unix/syscall_netbsd_arm.go:
--------------------------------------------------------------------------------
 1 | // Copyright 2013 The Go Authors. All rights reserved.
 2 | // Use of this source code is governed by a BSD-style
 3 | // license that can be found in the LICENSE file.
 4 | 
 5 | // +build arm,netbsd
 6 | 
 7 | package unix
 8 | 
 9 | func setTimespec(sec, nsec int64) Timespec {
10 | 	return Timespec{Sec: sec, Nsec: int32(nsec)}
11 | }
12 | 
13 | func setTimeval(sec, usec int64) Timeval {
14 | 	return Timeval{Sec: sec, Usec: int32(usec)}
15 | }
16 | 
17 | func SetKevent(k *Kevent_t, fd, mode, flags int) {
18 | 	k.Ident = uint32(fd)
19 | 	k.Filter = uint32(mode)
20 | 	k.Flags = uint32(flags)
21 | }
22 | 
23 | func (iov *Iovec) SetLen(length int) {
24 | 	iov.Len = uint32(length)
25 | }
26 | 
27 | func (msghdr *Msghdr) SetControllen(length int) {
28 | 	msghdr.Controllen = uint32(length)
29 | }
30 | 
31 | func (cmsg *Cmsghdr) SetLen(length int) {
32 | 	cmsg.Len = uint32(length)
33 | }
34 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/unix/syscall_openbsd_386.go:
--------------------------------------------------------------------------------
 1 | // Copyright 2009 The Go Authors. All rights reserved.
 2 | // Use of this source code is governed by a BSD-style
 3 | // license that can be found in the LICENSE file.
 4 | 
 5 | // +build 386,openbsd
 6 | 
 7 | package unix
 8 | 
 9 | func setTimespec(sec, nsec int64) Timespec {
10 | 	return Timespec{Sec: sec, Nsec: int32(nsec)}
11 | }
12 | 
13 | func setTimeval(sec, usec int64) Timeval {
14 | 	return Timeval{Sec: sec, Usec: int32(usec)}
15 | }
16 | 
17 | func SetKevent(k *Kevent_t, fd, mode, flags int) {
18 | 	k.Ident = uint32(fd)
19 | 	k.Filter = int16(mode)
20 | 	k.Flags = uint16(flags)
21 | }
22 | 
23 | func (iov *Iovec) SetLen(length int) {
24 | 	iov.Len = uint32(length)
25 | }
26 | 
27 | func (msghdr *Msghdr) SetControllen(length int) {
28 | 	msghdr.Controllen = uint32(length)
29 | }
30 | 
31 | func (cmsg *Cmsghdr) SetLen(length int) {
32 | 	cmsg.Len = uint32(length)
33 | }
34 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/unix/syscall_openbsd_amd64.go:
--------------------------------------------------------------------------------
 1 | // Copyright 2009 The Go Authors. All rights reserved.
 2 | // Use of this source code is governed by a BSD-style
 3 | // license that can be found in the LICENSE file.
 4 | 
 5 | // +build amd64,openbsd
 6 | 
 7 | package unix
 8 | 
 9 | func setTimespec(sec, nsec int64) Timespec {
10 | 	return Timespec{Sec: sec, Nsec: nsec}
11 | }
12 | 
13 | func setTimeval(sec, usec int64) Timeval {
14 | 	return Timeval{Sec: sec, Usec: usec}
15 | }
16 | 
17 | func SetKevent(k *Kevent_t, fd, mode, flags int) {
18 | 	k.Ident = uint64(fd)
19 | 	k.Filter = int16(mode)
20 | 	k.Flags = uint16(flags)
21 | }
22 | 
23 | func (iov *Iovec) SetLen(length int) {
24 | 	iov.Len = uint64(length)
25 | }
26 | 
27 | func (msghdr *Msghdr) SetControllen(length int) {
28 | 	msghdr.Controllen = uint32(length)
29 | }
30 | 
31 | func (cmsg *Cmsghdr) SetLen(length int) {
32 | 	cmsg.Len = uint32(length)
33 | }
34 | 
35 | // SYS___SYSCTL is used by syscall_bsd.go for all BSDs, but in modern versions
36 | // of openbsd/amd64 the syscall is called sysctl instead of __sysctl.
37 | const SYS___SYSCTL = SYS_SYSCTL
38 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/unix/syscall_openbsd_arm.go:
--------------------------------------------------------------------------------
 1 | // Copyright 2017 The Go Authors. All rights reserved.
 2 | // Use of this source code is governed by a BSD-style
 3 | // license that can be found in the LICENSE file.
 4 | 
 5 | // +build arm,openbsd
 6 | 
 7 | package unix
 8 | 
 9 | func setTimespec(sec, nsec int64) Timespec {
10 | 	return Timespec{Sec: sec, Nsec: int32(nsec)}
11 | }
12 | 
13 | func setTimeval(sec, usec int64) Timeval {
14 | 	return Timeval{Sec: sec, Usec: int32(usec)}
15 | }
16 | 
17 | func SetKevent(k *Kevent_t, fd, mode, flags int) {
18 | 	k.Ident = uint32(fd)
19 | 	k.Filter = int16(mode)
20 | 	k.Flags = uint16(flags)
21 | }
22 | 
23 | func (iov *Iovec) SetLen(length int) {
24 | 	iov.Len = uint32(length)
25 | }
26 | 
27 | func (msghdr *Msghdr) SetControllen(length int) {
28 | 	msghdr.Controllen = uint32(length)
29 | }
30 | 
31 | func (cmsg *Cmsghdr) SetLen(length int) {
32 | 	cmsg.Len = uint32(length)
33 | }
34 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/unix/syscall_solaris_amd64.go:
--------------------------------------------------------------------------------
 1 | // Copyright 2009 The Go Authors. All rights reserved.
 2 | // Use of this source code is governed by a BSD-style
 3 | // license that can be found in the LICENSE file.
 4 | 
 5 | // +build amd64,solaris
 6 | 
 7 | package unix
 8 | 
 9 | func setTimespec(sec, nsec int64) Timespec {
10 | 	return Timespec{Sec: sec, Nsec: nsec}
11 | }
12 | 
13 | func setTimeval(sec, usec int64) Timeval {
14 | 	return Timeval{Sec: sec, Usec: usec}
15 | }
16 | 
17 | func (iov *Iovec) SetLen(length int) {
18 | 	iov.Len = uint64(length)
19 | }
20 | 
21 | func (cmsg *Cmsghdr) SetLen(length int) {
22 | 	cmsg.Len = uint32(length)
23 | }
24 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/unix/syscall_unix_gc.go:
--------------------------------------------------------------------------------
 1 | // Copyright 2016 The Go Authors. All rights reserved.
 2 | // Use of this source code is governed by a BSD-style
 3 | // license that can be found in the LICENSE file.
 4 | 
 5 | // +build darwin dragonfly freebsd linux netbsd openbsd solaris
 6 | // +build !gccgo
 7 | 
 8 | package unix
 9 | 
10 | import "syscall"
11 | 
12 | func Syscall(trap, a1, a2, a3 uintptr) (r1, r2 uintptr, err syscall.Errno)
13 | func Syscall6(trap, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr, err syscall.Errno)
14 | func RawSyscall(trap, a1, a2, a3 uintptr) (r1, r2 uintptr, err syscall.Errno)
15 | func RawSyscall6(trap, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr, err syscall.Errno)
16 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/unix/timestruct.go:
--------------------------------------------------------------------------------
 1 | // Copyright 2017 The Go Authors. All rights reserved.
 2 | // Use of this source code is governed by a BSD-style
 3 | // license that can be found in the LICENSE file.
 4 | 
 5 | // +build aix darwin dragonfly freebsd linux netbsd openbsd solaris
 6 | 
 7 | package unix
 8 | 
 9 | import "time"
10 | 
11 | // TimespecToNsec converts a Timespec value into a number of
12 | // nanoseconds since the Unix epoch.
13 | func TimespecToNsec(ts Timespec) int64 { return int64(ts.Sec)*1e9 + int64(ts.Nsec) }
14 | 
15 | // NsecToTimespec takes a number of nanoseconds since the Unix epoch
16 | // and returns the corresponding Timespec value.
17 | func NsecToTimespec(nsec int64) Timespec {
18 | 	sec := nsec / 1e9
19 | 	nsec = nsec % 1e9
20 | 	if nsec < 0 {
21 | 		nsec += 1e9
22 | 		sec--
23 | 	}
24 | 	return setTimespec(sec, nsec)
25 | }
26 | 
27 | // TimeToTimespec converts t into a Timespec.
28 | // On some 32-bit systems the range of valid Timespec values are smaller
29 | // than that of time.Time values.  So if t is out of the valid range of
30 | // Timespec, it returns a zero Timespec and ERANGE.
31 | func TimeToTimespec(t time.Time) (Timespec, error) {
32 | 	sec := t.Unix()
33 | 	nsec := int64(t.Nanosecond())
34 | 	ts := setTimespec(sec, nsec)
35 | 
36 | 	// Currently all targets have either int32 or int64 for Timespec.Sec.
37 | 	// If there were a new target with floating point type for it, we have
38 | 	// to consider the rounding error.
39 | 	if int64(ts.Sec) != sec {
40 | 		return Timespec{}, ERANGE
41 | 	}
42 | 	return ts, nil
43 | }
44 | 
45 | // TimevalToNsec converts a Timeval value into a number of nanoseconds
46 | // since the Unix epoch.
47 | func TimevalToNsec(tv Timeval) int64 { return int64(tv.Sec)*1e9 + int64(tv.Usec)*1e3 }
48 | 
49 | // NsecToTimeval takes a number of nanoseconds since the Unix epoch
50 | // and returns the corresponding Timeval value.
51 | func NsecToTimeval(nsec int64) Timeval {
52 | 	nsec += 999 // round up to microsecond
53 | 	usec := nsec % 1e9 / 1e3
54 | 	sec := nsec / 1e9
55 | 	if usec < 0 {
56 | 		usec += 1e6
57 | 		sec--
58 | 	}
59 | 	return setTimeval(sec, usec)
60 | }
61 | 
62 | // Unix returns ts as the number of seconds and nanoseconds elapsed since the
63 | // Unix epoch.
64 | func (ts *Timespec) Unix() (sec int64, nsec int64) {
65 | 	return int64(ts.Sec), int64(ts.Nsec)
66 | }
67 | 
68 | // Unix returns tv as the number of seconds and nanoseconds elapsed since the
69 | // Unix epoch.
70 | func (tv *Timeval) Unix() (sec int64, nsec int64) {
71 | 	return int64(tv.Sec), int64(tv.Usec) * 1000
72 | }
73 | 
74 | // Nano returns ts as the number of nanoseconds elapsed since the Unix epoch.
75 | func (ts *Timespec) Nano() int64 {
76 | 	return int64(ts.Sec)*1e9 + int64(ts.Nsec)
77 | }
78 | 
79 | // Nano returns tv as the number of nanoseconds elapsed since the Unix epoch.
80 | func (tv *Timeval) Nano() int64 {
81 | 	return int64(tv.Sec)*1e9 + int64(tv.Usec)*1000
82 | }
83 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/unix/zptrace386_linux.go:
--------------------------------------------------------------------------------
 1 | // Code generated by linux/mkall.go generatePtracePair(386, amd64). DO NOT EDIT.
 2 | 
 3 | // +build linux
 4 | // +build 386 amd64
 5 | 
 6 | package unix
 7 | 
 8 | import "unsafe"
 9 | 
10 | // PtraceRegs386 is the registers used by 386 binaries.
11 | type PtraceRegs386 struct {
12 | 	Ebx      int32
13 | 	Ecx      int32
14 | 	Edx      int32
15 | 	Esi      int32
16 | 	Edi      int32
17 | 	Ebp      int32
18 | 	Eax      int32
19 | 	Xds      int32
20 | 	Xes      int32
21 | 	Xfs      int32
22 | 	Xgs      int32
23 | 	Orig_eax int32
24 | 	Eip      int32
25 | 	Xcs      int32
26 | 	Eflags   int32
27 | 	Esp      int32
28 | 	Xss      int32
29 | }
30 | 
31 | // PtraceGetRegs386 fetches the registers used by 386 binaries.
32 | func PtraceGetRegs386(pid int, regsout *PtraceRegs386) error {
33 | 	return ptrace(PTRACE_GETREGS, pid, 0, uintptr(unsafe.Pointer(regsout)))
34 | }
35 | 
36 | // PtraceSetRegs386 sets the registers used by 386 binaries.
37 | func PtraceSetRegs386(pid int, regs *PtraceRegs386) error {
38 | 	return ptrace(PTRACE_SETREGS, pid, 0, uintptr(unsafe.Pointer(regs)))
39 | }
40 | 
41 | // PtraceRegsAmd64 is the registers used by amd64 binaries.
42 | type PtraceRegsAmd64 struct {
43 | 	R15      uint64
44 | 	R14      uint64
45 | 	R13      uint64
46 | 	R12      uint64
47 | 	Rbp      uint64
48 | 	Rbx      uint64
49 | 	R11      uint64
50 | 	R10      uint64
51 | 	R9       uint64
52 | 	R8       uint64
53 | 	Rax      uint64
54 | 	Rcx      uint64
55 | 	Rdx      uint64
56 | 	Rsi      uint64
57 | 	Rdi      uint64
58 | 	Orig_rax uint64
59 | 	Rip      uint64
60 | 	Cs       uint64
61 | 	Eflags   uint64
62 | 	Rsp      uint64
63 | 	Ss       uint64
64 | 	Fs_base  uint64
65 | 	Gs_base  uint64
66 | 	Ds       uint64
67 | 	Es       uint64
68 | 	Fs       uint64
69 | 	Gs       uint64
70 | }
71 | 
72 | // PtraceGetRegsAmd64 fetches the registers used by amd64 binaries.
73 | func PtraceGetRegsAmd64(pid int, regsout *PtraceRegsAmd64) error {
74 | 	return ptrace(PTRACE_GETREGS, pid, 0, uintptr(unsafe.Pointer(regsout)))
75 | }
76 | 
77 | // PtraceSetRegsAmd64 sets the registers used by amd64 binaries.
78 | func PtraceSetRegsAmd64(pid int, regs *PtraceRegsAmd64) error {
79 | 	return ptrace(PTRACE_SETREGS, pid, 0, uintptr(unsafe.Pointer(regs)))
80 | }
81 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/unix/zptracearm_linux.go:
--------------------------------------------------------------------------------
 1 | // Code generated by linux/mkall.go generatePtracePair(arm, arm64). DO NOT EDIT.
 2 | 
 3 | // +build linux
 4 | // +build arm arm64
 5 | 
 6 | package unix
 7 | 
 8 | import "unsafe"
 9 | 
10 | // PtraceRegsArm is the registers used by arm binaries.
11 | type PtraceRegsArm struct {
12 | 	Uregs [18]uint32
13 | }
14 | 
15 | // PtraceGetRegsArm fetches the registers used by arm binaries.
16 | func PtraceGetRegsArm(pid int, regsout *PtraceRegsArm) error {
17 | 	return ptrace(PTRACE_GETREGS, pid, 0, uintptr(unsafe.Pointer(regsout)))
18 | }
19 | 
20 | // PtraceSetRegsArm sets the registers used by arm binaries.
21 | func PtraceSetRegsArm(pid int, regs *PtraceRegsArm) error {
22 | 	return ptrace(PTRACE_SETREGS, pid, 0, uintptr(unsafe.Pointer(regs)))
23 | }
24 | 
25 | // PtraceRegsArm64 is the registers used by arm64 binaries.
26 | type PtraceRegsArm64 struct {
27 | 	Regs   [31]uint64
28 | 	Sp     uint64
29 | 	Pc     uint64
30 | 	Pstate uint64
31 | }
32 | 
33 | // PtraceGetRegsArm64 fetches the registers used by arm64 binaries.
34 | func PtraceGetRegsArm64(pid int, regsout *PtraceRegsArm64) error {
35 | 	return ptrace(PTRACE_GETREGS, pid, 0, uintptr(unsafe.Pointer(regsout)))
36 | }
37 | 
38 | // PtraceSetRegsArm64 sets the registers used by arm64 binaries.
39 | func PtraceSetRegsArm64(pid int, regs *PtraceRegsArm64) error {
40 | 	return ptrace(PTRACE_SETREGS, pid, 0, uintptr(unsafe.Pointer(regs)))
41 | }
42 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/unix/zptracemips_linux.go:
--------------------------------------------------------------------------------
 1 | // Code generated by linux/mkall.go generatePtracePair(mips, mips64). DO NOT EDIT.
 2 | 
 3 | // +build linux
 4 | // +build mips mips64
 5 | 
 6 | package unix
 7 | 
 8 | import "unsafe"
 9 | 
10 | // PtraceRegsMips is the registers used by mips binaries.
11 | type PtraceRegsMips struct {
12 | 	Regs     [32]uint64
13 | 	Lo       uint64
14 | 	Hi       uint64
15 | 	Epc      uint64
16 | 	Badvaddr uint64
17 | 	Status   uint64
18 | 	Cause    uint64
19 | }
20 | 
21 | // PtraceGetRegsMips fetches the registers used by mips binaries.
22 | func PtraceGetRegsMips(pid int, regsout *PtraceRegsMips) error {
23 | 	return ptrace(PTRACE_GETREGS, pid, 0, uintptr(unsafe.Pointer(regsout)))
24 | }
25 | 
26 | // PtraceSetRegsMips sets the registers used by mips binaries.
27 | func PtraceSetRegsMips(pid int, regs *PtraceRegsMips) error {
28 | 	return ptrace(PTRACE_SETREGS, pid, 0, uintptr(unsafe.Pointer(regs)))
29 | }
30 | 
31 | // PtraceRegsMips64 is the registers used by mips64 binaries.
32 | type PtraceRegsMips64 struct {
33 | 	Regs     [32]uint64
34 | 	Lo       uint64
35 | 	Hi       uint64
36 | 	Epc      uint64
37 | 	Badvaddr uint64
38 | 	Status   uint64
39 | 	Cause    uint64
40 | }
41 | 
42 | // PtraceGetRegsMips64 fetches the registers used by mips64 binaries.
43 | func PtraceGetRegsMips64(pid int, regsout *PtraceRegsMips64) error {
44 | 	return ptrace(PTRACE_GETREGS, pid, 0, uintptr(unsafe.Pointer(regsout)))
45 | }
46 | 
47 | // PtraceSetRegsMips64 sets the registers used by mips64 binaries.
48 | func PtraceSetRegsMips64(pid int, regs *PtraceRegsMips64) error {
49 | 	return ptrace(PTRACE_SETREGS, pid, 0, uintptr(unsafe.Pointer(regs)))
50 | }
51 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/unix/zptracemipsle_linux.go:
--------------------------------------------------------------------------------
 1 | // Code generated by linux/mkall.go generatePtracePair(mipsle, mips64le). DO NOT EDIT.
 2 | 
 3 | // +build linux
 4 | // +build mipsle mips64le
 5 | 
 6 | package unix
 7 | 
 8 | import "unsafe"
 9 | 
10 | // PtraceRegsMipsle is the registers used by mipsle binaries.
11 | type PtraceRegsMipsle struct {
12 | 	Regs     [32]uint64
13 | 	Lo       uint64
14 | 	Hi       uint64
15 | 	Epc      uint64
16 | 	Badvaddr uint64
17 | 	Status   uint64
18 | 	Cause    uint64
19 | }
20 | 
21 | // PtraceGetRegsMipsle fetches the registers used by mipsle binaries.
22 | func PtraceGetRegsMipsle(pid int, regsout *PtraceRegsMipsle) error {
23 | 	return ptrace(PTRACE_GETREGS, pid, 0, uintptr(unsafe.Pointer(regsout)))
24 | }
25 | 
26 | // PtraceSetRegsMipsle sets the registers used by mipsle binaries.
27 | func PtraceSetRegsMipsle(pid int, regs *PtraceRegsMipsle) error {
28 | 	return ptrace(PTRACE_SETREGS, pid, 0, uintptr(unsafe.Pointer(regs)))
29 | }
30 | 
31 | // PtraceRegsMips64le is the registers used by mips64le binaries.
32 | type PtraceRegsMips64le struct {
33 | 	Regs     [32]uint64
34 | 	Lo       uint64
35 | 	Hi       uint64
36 | 	Epc      uint64
37 | 	Badvaddr uint64
38 | 	Status   uint64
39 | 	Cause    uint64
40 | }
41 | 
42 | // PtraceGetRegsMips64le fetches the registers used by mips64le binaries.
43 | func PtraceGetRegsMips64le(pid int, regsout *PtraceRegsMips64le) error {
44 | 	return ptrace(PTRACE_GETREGS, pid, 0, uintptr(unsafe.Pointer(regsout)))
45 | }
46 | 
47 | // PtraceSetRegsMips64le sets the registers used by mips64le binaries.
48 | func PtraceSetRegsMips64le(pid int, regs *PtraceRegsMips64le) error {
49 | 	return ptrace(PTRACE_SETREGS, pid, 0, uintptr(unsafe.Pointer(regs)))
50 | }
51 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/windows/aliases.go:
--------------------------------------------------------------------------------
 1 | // Copyright 2018 The Go Authors. All rights reserved.
 2 | // Use of this source code is governed by a BSD-style
 3 | // license that can be found in the LICENSE file.
 4 | 
 5 | // +build windows
 6 | // +build go1.9
 7 | 
 8 | package windows
 9 | 
10 | import "syscall"
11 | 
12 | type Errno = syscall.Errno
13 | type SysProcAttr = syscall.SysProcAttr
14 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/windows/asm_windows_386.s:
--------------------------------------------------------------------------------
 1 | // Copyright 2009 The Go Authors. All rights reserved.
 2 | // Use of this source code is governed by a BSD-style
 3 | // license that can be found in the LICENSE file.
 4 | 
 5 | //
 6 | // System calls for 386, Windows are implemented in runtime/syscall_windows.goc
 7 | //
 8 | 
 9 | TEXT ·getprocaddress(SB), 7, $0-16
10 | 	JMP	syscall·getprocaddress(SB)
11 | 
12 | TEXT ·loadlibrary(SB), 7, $0-12
13 | 	JMP	syscall·loadlibrary(SB)
14 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/windows/asm_windows_amd64.s:
--------------------------------------------------------------------------------
 1 | // Copyright 2009 The Go Authors. All rights reserved.
 2 | // Use of this source code is governed by a BSD-style
 3 | // license that can be found in the LICENSE file.
 4 | 
 5 | //
 6 | // System calls for amd64, Windows are implemented in runtime/syscall_windows.goc
 7 | //
 8 | 
 9 | TEXT ·getprocaddress(SB), 7, $0-32
10 | 	JMP	syscall·getprocaddress(SB)
11 | 
12 | TEXT ·loadlibrary(SB), 7, $0-24
13 | 	JMP	syscall·loadlibrary(SB)
14 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/windows/env_windows.go:
--------------------------------------------------------------------------------
 1 | // Copyright 2010 The Go Authors. All rights reserved.
 2 | // Use of this source code is governed by a BSD-style
 3 | // license that can be found in the LICENSE file.
 4 | 
 5 | // Windows environment variables.
 6 | 
 7 | package windows
 8 | 
 9 | import "syscall"
10 | 
11 | func Getenv(key string) (value string, found bool) {
12 | 	return syscall.Getenv(key)
13 | }
14 | 
15 | func Setenv(key, value string) error {
16 | 	return syscall.Setenv(key, value)
17 | }
18 | 
19 | func Clearenv() {
20 | 	syscall.Clearenv()
21 | }
22 | 
23 | func Environ() []string {
24 | 	return syscall.Environ()
25 | }
26 | 
27 | func Unsetenv(key string) error {
28 | 	return syscall.Unsetenv(key)
29 | }
30 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/windows/eventlog.go:
--------------------------------------------------------------------------------
 1 | // Copyright 2012 The Go Authors. All rights reserved.
 2 | // Use of this source code is governed by a BSD-style
 3 | // license that can be found in the LICENSE file.
 4 | 
 5 | // +build windows
 6 | 
 7 | package windows
 8 | 
 9 | const (
10 | 	EVENTLOG_SUCCESS          = 0
11 | 	EVENTLOG_ERROR_TYPE       = 1
12 | 	EVENTLOG_WARNING_TYPE     = 2
13 | 	EVENTLOG_INFORMATION_TYPE = 4
14 | 	EVENTLOG_AUDIT_SUCCESS    = 8
15 | 	EVENTLOG_AUDIT_FAILURE    = 16
16 | )
17 | 
18 | //sys	RegisterEventSource(uncServerName *uint16, sourceName *uint16) (handle Handle, err error) [failretval==0] = advapi32.RegisterEventSourceW
19 | //sys	DeregisterEventSource(handle Handle) (err error) = advapi32.DeregisterEventSource
20 | //sys	ReportEvent(log Handle, etype uint16, category uint16, eventId uint32, usrSId uintptr, numStrings uint16, dataSize uint32, strings **uint16, rawData *byte) (err error) = advapi32.ReportEventW
21 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/windows/exec_windows.go:
--------------------------------------------------------------------------------
 1 | // Copyright 2009 The Go Authors. All rights reserved.
 2 | // Use of this source code is governed by a BSD-style
 3 | // license that can be found in the LICENSE file.
 4 | 
 5 | // Fork, exec, wait, etc.
 6 | 
 7 | package windows
 8 | 
 9 | // EscapeArg rewrites command line argument s as prescribed
10 | // in http://msdn.microsoft.com/en-us/library/ms880421.
11 | // This function returns "" (2 double quotes) if s is empty.
12 | // Alternatively, these transformations are done:
13 | // - every back slash (\) is doubled, but only if immediately
14 | //   followed by double quote (");
15 | // - every double quote (") is escaped by back slash (\);
16 | // - finally, s is wrapped with double quotes (arg -> "arg"),
17 | //   but only if there is space or tab inside s.
18 | func EscapeArg(s string) string {
19 | 	if len(s) == 0 {
20 | 		return "\"\""
21 | 	}
22 | 	n := len(s)
23 | 	hasSpace := false
24 | 	for i := 0; i < len(s); i++ {
25 | 		switch s[i] {
26 | 		case '"', '\\':
27 | 			n++
28 | 		case ' ', '\t':
29 | 			hasSpace = true
30 | 		}
31 | 	}
32 | 	if hasSpace {
33 | 		n += 2
34 | 	}
35 | 	if n == len(s) {
36 | 		return s
37 | 	}
38 | 
39 | 	qs := make([]byte, n)
40 | 	j := 0
41 | 	if hasSpace {
42 | 		qs[j] = '"'
43 | 		j++
44 | 	}
45 | 	slashes := 0
46 | 	for i := 0; i < len(s); i++ {
47 | 		switch s[i] {
48 | 		default:
49 | 			slashes = 0
50 | 			qs[j] = s[i]
51 | 		case '\\':
52 | 			slashes++
53 | 			qs[j] = s[i]
54 | 		case '"':
55 | 			for ; slashes > 0; slashes-- {
56 | 				qs[j] = '\\'
57 | 				j++
58 | 			}
59 | 			qs[j] = '\\'
60 | 			j++
61 | 			qs[j] = s[i]
62 | 		}
63 | 		j++
64 | 	}
65 | 	if hasSpace {
66 | 		for ; slashes > 0; slashes-- {
67 | 			qs[j] = '\\'
68 | 			j++
69 | 		}
70 | 		qs[j] = '"'
71 | 		j++
72 | 	}
73 | 	return string(qs[:j])
74 | }
75 | 
76 | func CloseOnExec(fd Handle) {
77 | 	SetHandleInformation(Handle(fd), HANDLE_FLAG_INHERIT, 0)
78 | }
79 | 
80 | // FullPath retrieves the full path of the specified file.
81 | func FullPath(name string) (path string, err error) {
82 | 	p, err := UTF16PtrFromString(name)
83 | 	if err != nil {
84 | 		return "", err
85 | 	}
86 | 	n := uint32(100)
87 | 	for {
88 | 		buf := make([]uint16, n)
89 | 		n, err = GetFullPathName(p, uint32(len(buf)), &buf[0], nil)
90 | 		if err != nil {
91 | 			return "", err
92 | 		}
93 | 		if n <= uint32(len(buf)) {
94 | 			return UTF16ToString(buf[:n]), nil
95 | 		}
96 | 	}
97 | }
98 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/windows/memory_windows.go:
--------------------------------------------------------------------------------
 1 | // Copyright 2017 The Go Authors. All rights reserved.
 2 | // Use of this source code is governed by a BSD-style
 3 | // license that can be found in the LICENSE file.
 4 | 
 5 | package windows
 6 | 
 7 | const (
 8 | 	MEM_COMMIT      = 0x00001000
 9 | 	MEM_RESERVE     = 0x00002000
10 | 	MEM_DECOMMIT    = 0x00004000
11 | 	MEM_RELEASE     = 0x00008000
12 | 	MEM_RESET       = 0x00080000
13 | 	MEM_TOP_DOWN    = 0x00100000
14 | 	MEM_WRITE_WATCH = 0x00200000
15 | 	MEM_PHYSICAL    = 0x00400000
16 | 	MEM_RESET_UNDO  = 0x01000000
17 | 	MEM_LARGE_PAGES = 0x20000000
18 | 
19 | 	PAGE_NOACCESS          = 0x01
20 | 	PAGE_READONLY          = 0x02
21 | 	PAGE_READWRITE         = 0x04
22 | 	PAGE_WRITECOPY         = 0x08
23 | 	PAGE_EXECUTE_READ      = 0x20
24 | 	PAGE_EXECUTE_READWRITE = 0x40
25 | 	PAGE_EXECUTE_WRITECOPY = 0x80
26 | )
27 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/windows/mksyscall.go:
--------------------------------------------------------------------------------
1 | // Copyright 2009 The Go Authors. All rights reserved.
2 | // Use of this source code is governed by a BSD-style
3 | // license that can be found in the LICENSE file.
4 | 
5 | package windows
6 | 
7 | //go:generate go run $GOROOT/src/syscall/mksyscall_windows.go -output zsyscall_windows.go eventlog.go service.go syscall_windows.go security_windows.go
8 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/windows/race.go:
--------------------------------------------------------------------------------
 1 | // Copyright 2012 The Go Authors. All rights reserved.
 2 | // Use of this source code is governed by a BSD-style
 3 | // license that can be found in the LICENSE file.
 4 | 
 5 | // +build windows,race
 6 | 
 7 | package windows
 8 | 
 9 | import (
10 | 	"runtime"
11 | 	"unsafe"
12 | )
13 | 
14 | const raceenabled = true
15 | 
16 | func raceAcquire(addr unsafe.Pointer) {
17 | 	runtime.RaceAcquire(addr)
18 | }
19 | 
20 | func raceReleaseMerge(addr unsafe.Pointer) {
21 | 	runtime.RaceReleaseMerge(addr)
22 | }
23 | 
24 | func raceReadRange(addr unsafe.Pointer, len int) {
25 | 	runtime.RaceReadRange(addr, len)
26 | }
27 | 
28 | func raceWriteRange(addr unsafe.Pointer, len int) {
29 | 	runtime.RaceWriteRange(addr, len)
30 | }
31 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/windows/race0.go:
--------------------------------------------------------------------------------
 1 | // Copyright 2012 The Go Authors. All rights reserved.
 2 | // Use of this source code is governed by a BSD-style
 3 | // license that can be found in the LICENSE file.
 4 | 
 5 | // +build windows,!race
 6 | 
 7 | package windows
 8 | 
 9 | import (
10 | 	"unsafe"
11 | )
12 | 
13 | const raceenabled = false
14 | 
15 | func raceAcquire(addr unsafe.Pointer) {
16 | }
17 | 
18 | func raceReleaseMerge(addr unsafe.Pointer) {
19 | }
20 | 
21 | func raceReadRange(addr unsafe.Pointer, len int) {
22 | }
23 | 
24 | func raceWriteRange(addr unsafe.Pointer, len int) {
25 | }
26 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/windows/str.go:
--------------------------------------------------------------------------------
 1 | // Copyright 2009 The Go Authors. All rights reserved.
 2 | // Use of this source code is governed by a BSD-style
 3 | // license that can be found in the LICENSE file.
 4 | 
 5 | // +build windows
 6 | 
 7 | package windows
 8 | 
 9 | func itoa(val int) string { // do it here rather than with fmt to avoid dependency
10 | 	if val < 0 {
11 | 		return "-" + itoa(-val)
12 | 	}
13 | 	var buf [32]byte // big enough for int64
14 | 	i := len(buf) - 1
15 | 	for val >= 10 {
16 | 		buf[i] = byte(val%10 + '0')
17 | 		i--
18 | 		val /= 10
19 | 	}
20 | 	buf[i] = byte(val + '0')
21 | 	return string(buf[i:])
22 | }
23 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/windows/syscall.go:
--------------------------------------------------------------------------------
 1 | // Copyright 2009 The Go Authors. All rights reserved.
 2 | // Use of this source code is governed by a BSD-style
 3 | // license that can be found in the LICENSE file.
 4 | 
 5 | // +build windows
 6 | 
 7 | // Package windows contains an interface to the low-level operating system
 8 | // primitives. OS details vary depending on the underlying system, and
 9 | // by default, godoc will display the OS-specific documentation for the current
10 | // system. If you want godoc to display syscall documentation for another
11 | // system, set $GOOS and $GOARCH to the desired system. For example, if
12 | // you want to view documentation for freebsd/arm on linux/amd64, set $GOOS
13 | // to freebsd and $GOARCH to arm.
14 | //
15 | // The primary use of this package is inside other packages that provide a more
16 | // portable interface to the system, such as "os", "time" and "net".  Use
17 | // those packages rather than this one if you can.
18 | //
19 | // For details of the functions and data types in this package consult
20 | // the manuals for the appropriate operating system.
21 | //
22 | // These calls return err == nil to indicate success; otherwise
23 | // err represents an operating system error describing the failure and
24 | // holds a value of type syscall.Errno.
25 | package windows // import "golang.org/x/sys/windows"
26 | 
27 | import (
28 | 	"syscall"
29 | )
30 | 
31 | // ByteSliceFromString returns a NUL-terminated slice of bytes
32 | // containing the text of s. If s contains a NUL byte at any
33 | // location, it returns (nil, syscall.EINVAL).
34 | func ByteSliceFromString(s string) ([]byte, error) {
35 | 	for i := 0; i < len(s); i++ {
36 | 		if s[i] == 0 {
37 | 			return nil, syscall.EINVAL
38 | 		}
39 | 	}
40 | 	a := make([]byte, len(s)+1)
41 | 	copy(a, s)
42 | 	return a, nil
43 | }
44 | 
45 | // BytePtrFromString returns a pointer to a NUL-terminated array of
46 | // bytes containing the text of s. If s contains a NUL byte at any
47 | // location, it returns (nil, syscall.EINVAL).
48 | func BytePtrFromString(s string) (*byte, error) {
49 | 	a, err := ByteSliceFromString(s)
50 | 	if err != nil {
51 | 		return nil, err
52 | 	}
53 | 	return &a[0], nil
54 | }
55 | 
56 | // Single-word zero for use when we need a valid pointer to 0 bytes.
57 | // See mksyscall.pl.
58 | var _zero uintptr
59 | 
60 | func (ts *Timespec) Unix() (sec int64, nsec int64) {
61 | 	return int64(ts.Sec), int64(ts.Nsec)
62 | }
63 | 
64 | func (tv *Timeval) Unix() (sec int64, nsec int64) {
65 | 	return int64(tv.Sec), int64(tv.Usec) * 1000
66 | }
67 | 
68 | func (ts *Timespec) Nano() int64 {
69 | 	return int64(ts.Sec)*1e9 + int64(ts.Nsec)
70 | }
71 | 
72 | func (tv *Timeval) Nano() int64 {
73 | 	return int64(tv.Sec)*1e9 + int64(tv.Usec)*1000
74 | }
75 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/windows/types_windows_386.go:
--------------------------------------------------------------------------------
 1 | // Copyright 2011 The Go Authors. All rights reserved.
 2 | // Use of this source code is governed by a BSD-style
 3 | // license that can be found in the LICENSE file.
 4 | 
 5 | package windows
 6 | 
 7 | type WSAData struct {
 8 | 	Version      uint16
 9 | 	HighVersion  uint16
10 | 	Description  [WSADESCRIPTION_LEN + 1]byte
11 | 	SystemStatus [WSASYS_STATUS_LEN + 1]byte
12 | 	MaxSockets   uint16
13 | 	MaxUdpDg     uint16
14 | 	VendorInfo   *byte
15 | }
16 | 
17 | type Servent struct {
18 | 	Name    *byte
19 | 	Aliases **byte
20 | 	Port    uint16
21 | 	Proto   *byte
22 | }
23 | 


--------------------------------------------------------------------------------
/vendor/golang.org/x/sys/windows/types_windows_amd64.go:
--------------------------------------------------------------------------------
 1 | // Copyright 2011 The Go Authors. All rights reserved.
 2 | // Use of this source code is governed by a BSD-style
 3 | // license that can be found in the LICENSE file.
 4 | 
 5 | package windows
 6 | 
 7 | type WSAData struct {
 8 | 	Version      uint16
 9 | 	HighVersion  uint16
10 | 	MaxSockets   uint16
11 | 	MaxUdpDg     uint16
12 | 	VendorInfo   *byte
13 | 	Description  [WSADESCRIPTION_LEN + 1]byte
14 | 	SystemStatus [WSASYS_STATUS_LEN + 1]byte
15 | }
16 | 
17 | type Servent struct {
18 | 	Name    *byte
19 | 	Aliases **byte
20 | 	Proto   *byte
21 | 	Port    uint16
22 | }
23 | 


--------------------------------------------------------------------------------
/vendor/gopkg.in/urfave/cli.v1/LICENSE:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) 2016 Jeremy Saenz & Contributors
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/vendor/gopkg.in/urfave/cli.v1/appveyor.yml:
--------------------------------------------------------------------------------
 1 | version: "{build}"
 2 | 
 3 | os: Windows Server 2016
 4 | 
 5 | image: Visual Studio 2017
 6 | 
 7 | clone_folder: c:\gopath\src\github.com\urfave\cli
 8 | 
 9 | environment:
10 |   GOPATH: C:\gopath
11 |   GOVERSION: 1.8.x
12 |   PYTHON: C:\Python36-x64
13 |   PYTHON_VERSION: 3.6.x
14 |   PYTHON_ARCH: 64
15 | 
16 | install:
17 | - set PATH=%GOPATH%\bin;C:\go\bin;%PATH%
18 | - go version
19 | - go env
20 | - go get github.com/urfave/gfmrun/...
21 | - go get -v -t ./...
22 | 
23 | build_script:
24 | - python runtests vet
25 | - python runtests test
26 | - python runtests gfmrun
27 | 


--------------------------------------------------------------------------------
/vendor/gopkg.in/urfave/cli.v1/category.go:
--------------------------------------------------------------------------------
 1 | package cli
 2 | 
 3 | // CommandCategories is a slice of *CommandCategory.
 4 | type CommandCategories []*CommandCategory
 5 | 
 6 | // CommandCategory is a category containing commands.
 7 | type CommandCategory struct {
 8 | 	Name     string
 9 | 	Commands Commands
10 | }
11 | 
12 | func (c CommandCategories) Less(i, j int) bool {
13 | 	return c[i].Name < c[j].Name
14 | }
15 | 
16 | func (c CommandCategories) Len() int {
17 | 	return len(c)
18 | }
19 | 
20 | func (c CommandCategories) Swap(i, j int) {
21 | 	c[i], c[j] = c[j], c[i]
22 | }
23 | 
24 | // AddCommand adds a command to a category.
25 | func (c CommandCategories) AddCommand(category string, command Command) CommandCategories {
26 | 	for _, commandCategory := range c {
27 | 		if commandCategory.Name == category {
28 | 			commandCategory.Commands = append(commandCategory.Commands, command)
29 | 			return c
30 | 		}
31 | 	}
32 | 	return append(c, &CommandCategory{Name: category, Commands: []Command{command}})
33 | }
34 | 
35 | // VisibleCommands returns a slice of the Commands with Hidden=false
36 | func (c *CommandCategory) VisibleCommands() []Command {
37 | 	ret := []Command{}
38 | 	for _, command := range c.Commands {
39 | 		if !command.Hidden {
40 | 			ret = append(ret, command)
41 | 		}
42 | 	}
43 | 	return ret
44 | }
45 | 


--------------------------------------------------------------------------------
/vendor/gopkg.in/urfave/cli.v1/cli.go:
--------------------------------------------------------------------------------
 1 | // Package cli provides a minimal framework for creating and organizing command line
 2 | // Go applications. cli is designed to be easy to understand and write, the most simple
 3 | // cli application can be written as follows:
 4 | //   func main() {
 5 | //     cli.NewApp().Run(os.Args)
 6 | //   }
 7 | //
 8 | // Of course this application does not do much, so let's make this an actual application:
 9 | //   func main() {
10 | //     app := cli.NewApp()
11 | //     app.Name = "greet"
12 | //     app.Usage = "say a greeting"
13 | //     app.Action = func(c *cli.Context) error {
14 | //       println("Greetings")
15 | //       return nil
16 | //     }
17 | //
18 | //     app.Run(os.Args)
19 | //   }
20 | package cli
21 | 
22 | //go:generate python ./generate-flag-types cli -i flag-types.json -o flag_generated.go
23 | 


--------------------------------------------------------------------------------
/vendor/gopkg.in/urfave/cli.v1/errors.go:
--------------------------------------------------------------------------------
  1 | package cli
  2 | 
  3 | import (
  4 | 	"fmt"
  5 | 	"io"
  6 | 	"os"
  7 | 	"strings"
  8 | )
  9 | 
 10 | // OsExiter is the function used when the app exits. If not set defaults to os.Exit.
 11 | var OsExiter = os.Exit
 12 | 
 13 | // ErrWriter is used to write errors to the user. This can be anything
 14 | // implementing the io.Writer interface and defaults to os.Stderr.
 15 | var ErrWriter io.Writer = os.Stderr
 16 | 
 17 | // MultiError is an error that wraps multiple errors.
 18 | type MultiError struct {
 19 | 	Errors []error
 20 | }
 21 | 
 22 | // NewMultiError creates a new MultiError. Pass in one or more errors.
 23 | func NewMultiError(err ...error) MultiError {
 24 | 	return MultiError{Errors: err}
 25 | }
 26 | 
 27 | // Error implements the error interface.
 28 | func (m MultiError) Error() string {
 29 | 	errs := make([]string, len(m.Errors))
 30 | 	for i, err := range m.Errors {
 31 | 		errs[i] = err.Error()
 32 | 	}
 33 | 
 34 | 	return strings.Join(errs, "\n")
 35 | }
 36 | 
 37 | type ErrorFormatter interface {
 38 | 	Format(s fmt.State, verb rune)
 39 | }
 40 | 
 41 | // ExitCoder is the interface checked by `App` and `Command` for a custom exit
 42 | // code
 43 | type ExitCoder interface {
 44 | 	error
 45 | 	ExitCode() int
 46 | }
 47 | 
 48 | // ExitError fulfills both the builtin `error` interface and `ExitCoder`
 49 | type ExitError struct {
 50 | 	exitCode int
 51 | 	message  interface{}
 52 | }
 53 | 
 54 | // NewExitError makes a new *ExitError
 55 | func NewExitError(message interface{}, exitCode int) *ExitError {
 56 | 	return &ExitError{
 57 | 		exitCode: exitCode,
 58 | 		message:  message,
 59 | 	}
 60 | }
 61 | 
 62 | // Error returns the string message, fulfilling the interface required by
 63 | // `error`
 64 | func (ee *ExitError) Error() string {
 65 | 	return fmt.Sprintf("%v", ee.message)
 66 | }
 67 | 
 68 | // ExitCode returns the exit code, fulfilling the interface required by
 69 | // `ExitCoder`
 70 | func (ee *ExitError) ExitCode() int {
 71 | 	return ee.exitCode
 72 | }
 73 | 
 74 | // HandleExitCoder checks if the error fulfills the ExitCoder interface, and if
 75 | // so prints the error to stderr (if it is non-empty) and calls OsExiter with the
 76 | // given exit code.  If the given error is a MultiError, then this func is
 77 | // called on all members of the Errors slice and calls OsExiter with the last exit code.
 78 | func HandleExitCoder(err error) {
 79 | 	if err == nil {
 80 | 		return
 81 | 	}
 82 | 
 83 | 	if exitErr, ok := err.(ExitCoder); ok {
 84 | 		if err.Error() != "" {
 85 | 			if _, ok := exitErr.(ErrorFormatter); ok {
 86 | 				fmt.Fprintf(ErrWriter, "%+v\n", err)
 87 | 			} else {
 88 | 				fmt.Fprintln(ErrWriter, err)
 89 | 			}
 90 | 		}
 91 | 		OsExiter(exitErr.ExitCode())
 92 | 		return
 93 | 	}
 94 | 
 95 | 	if multiErr, ok := err.(MultiError); ok {
 96 | 		code := handleMultiError(multiErr)
 97 | 		OsExiter(code)
 98 | 		return
 99 | 	}
100 | }
101 | 
102 | func handleMultiError(multiErr MultiError) int {
103 | 	code := 1
104 | 	for _, merr := range multiErr.Errors {
105 | 		if multiErr2, ok := merr.(MultiError); ok {
106 | 			code = handleMultiError(multiErr2)
107 | 		} else {
108 | 			fmt.Fprintln(ErrWriter, merr)
109 | 			if exitErr, ok := merr.(ExitCoder); ok {
110 | 				code = exitErr.ExitCode()
111 | 			}
112 | 		}
113 | 	}
114 | 	return code
115 | }
116 | 


--------------------------------------------------------------------------------
/vendor/gopkg.in/urfave/cli.v1/flag-types.json:
--------------------------------------------------------------------------------
 1 | [
 2 |   {
 3 |     "name": "Bool",
 4 |     "type": "bool",
 5 |     "value": false,
 6 |     "context_default": "false",
 7 |     "parser": "strconv.ParseBool(f.Value.String())"
 8 |   },
 9 |   {
10 |     "name": "BoolT",
11 |     "type": "bool",
12 |     "value": false,
13 |     "doctail": " that is true by default",
14 |     "context_default": "false",
15 |     "parser": "strconv.ParseBool(f.Value.String())"
16 |   },
17 |   {
18 |     "name": "Duration",
19 |     "type": "time.Duration",
20 |     "doctail": " (see https://golang.org/pkg/time/#ParseDuration)",
21 |     "context_default": "0",
22 |     "parser": "time.ParseDuration(f.Value.String())"
23 |   },
24 |   {
25 |     "name": "Float64",
26 |     "type": "float64",
27 |     "context_default": "0",
28 |     "parser": "strconv.ParseFloat(f.Value.String(), 64)"
29 |   },
30 |   {
31 |     "name": "Generic",
32 |     "type": "Generic",
33 |     "dest": false,
34 |     "context_default": "nil",
35 |     "context_type": "interface{}"
36 |   },
37 |   {
38 |     "name": "Int64",
39 |     "type": "int64",
40 |     "context_default": "0",
41 |     "parser": "strconv.ParseInt(f.Value.String(), 0, 64)"
42 |   },
43 |   {
44 |     "name": "Int",
45 |     "type": "int",
46 |     "context_default": "0",
47 |     "parser": "strconv.ParseInt(f.Value.String(), 0, 64)",
48 |     "parser_cast": "int(parsed)"
49 |   },
50 |   {
51 |     "name": "IntSlice",
52 |     "type": "*IntSlice",
53 |     "dest": false,
54 |     "context_default": "nil",
55 |     "context_type": "[]int",
56 |     "parser": "(f.Value.(*IntSlice)).Value(), error(nil)"
57 |   },
58 |   {
59 |     "name": "Int64Slice",
60 |     "type": "*Int64Slice",
61 |     "dest": false,
62 |     "context_default": "nil",
63 |     "context_type": "[]int64",
64 |     "parser": "(f.Value.(*Int64Slice)).Value(), error(nil)"
65 |   },
66 |   {
67 |     "name": "String",
68 |     "type": "string",
69 |     "context_default": "\"\"",
70 |     "parser": "f.Value.String(), error(nil)"
71 |   },
72 |   {
73 |     "name": "StringSlice",
74 |     "type": "*StringSlice",
75 |     "dest": false,
76 |     "context_default": "nil",
77 |     "context_type": "[]string",
78 |     "parser": "(f.Value.(*StringSlice)).Value(), error(nil)"
79 |   },
80 |   {
81 |     "name": "Uint64",
82 |     "type": "uint64",
83 |     "context_default": "0",
84 |     "parser": "strconv.ParseUint(f.Value.String(), 0, 64)"
85 |   },
86 |   {
87 |     "name": "Uint",
88 |     "type": "uint",
89 |     "context_default": "0",
90 |     "parser": "strconv.ParseUint(f.Value.String(), 0, 64)",
91 |     "parser_cast": "uint(parsed)"
92 |   }
93 | ]
94 | 


--------------------------------------------------------------------------------
/vendor/gopkg.in/urfave/cli.v1/funcs.go:
--------------------------------------------------------------------------------
 1 | package cli
 2 | 
 3 | // BashCompleteFunc is an action to execute when the bash-completion flag is set
 4 | type BashCompleteFunc func(*Context)
 5 | 
 6 | // BeforeFunc is an action to execute before any subcommands are run, but after
 7 | // the context is ready if a non-nil error is returned, no subcommands are run
 8 | type BeforeFunc func(*Context) error
 9 | 
10 | // AfterFunc is an action to execute after any subcommands are run, but after the
11 | // subcommand has finished it is run even if Action() panics
12 | type AfterFunc func(*Context) error
13 | 
14 | // ActionFunc is the action to execute when no subcommands are specified
15 | type ActionFunc func(*Context) error
16 | 
17 | // CommandNotFoundFunc is executed if the proper command cannot be found
18 | type CommandNotFoundFunc func(*Context, string)
19 | 
20 | // OnUsageErrorFunc is executed if an usage error occurs. This is useful for displaying
21 | // customized usage error messages.  This function is able to replace the
22 | // original error messages.  If this function is not set, the "Incorrect usage"
23 | // is displayed and the execution is interrupted.
24 | type OnUsageErrorFunc func(context *Context, err error, isSubcommand bool) error
25 | 
26 | // FlagStringFunc is used by the help generation to display a flag, which is
27 | // expected to be a single line.
28 | type FlagStringFunc func(Flag) string
29 | 


--------------------------------------------------------------------------------
/vendor/gopkg.in/urfave/cli.v1/runtests:
--------------------------------------------------------------------------------
  1 | #!/usr/bin/env python
  2 | from __future__ import print_function
  3 | 
  4 | import argparse
  5 | import os
  6 | import sys
  7 | import tempfile
  8 | 
  9 | from subprocess import check_call, check_output
 10 | 
 11 | 
 12 | PACKAGE_NAME = os.environ.get(
 13 |     'CLI_PACKAGE_NAME', 'github.com/urfave/cli'
 14 | )
 15 | 
 16 | 
 17 | def main(sysargs=sys.argv[:]):
 18 |     targets = {
 19 |         'vet': _vet,
 20 |         'test': _test,
 21 |         'gfmrun': _gfmrun,
 22 |         'toc': _toc,
 23 |         'gen': _gen,
 24 |     }
 25 | 
 26 |     parser = argparse.ArgumentParser()
 27 |     parser.add_argument(
 28 |         'target', nargs='?', choices=tuple(targets.keys()), default='test'
 29 |     )
 30 |     args = parser.parse_args(sysargs[1:])
 31 | 
 32 |     targets[args.target]()
 33 |     return 0
 34 | 
 35 | 
 36 | def _test():
 37 |     if check_output('go version'.split()).split()[2] < 'go1.2':
 38 |         _run('go test -v .')
 39 |         return
 40 | 
 41 |     coverprofiles = []
 42 |     for subpackage in ['', 'altsrc']:
 43 |         coverprofile = 'cli.coverprofile'
 44 |         if subpackage != '':
 45 |             coverprofile = '{}.coverprofile'.format(subpackage)
 46 | 
 47 |         coverprofiles.append(coverprofile)
 48 | 
 49 |         _run('go test -v'.split() + [
 50 |             '-coverprofile={}'.format(coverprofile),
 51 |             ('{}/{}'.format(PACKAGE_NAME, subpackage)).rstrip('/')
 52 |         ])
 53 | 
 54 |     combined_name = _combine_coverprofiles(coverprofiles)
 55 |     _run('go tool cover -func={}'.format(combined_name))
 56 |     os.remove(combined_name)
 57 | 
 58 | 
 59 | def _gfmrun():
 60 |     go_version = check_output('go version'.split()).split()[2]
 61 |     if go_version < 'go1.3':
 62 |         print('runtests: skip on {}'.format(go_version), file=sys.stderr)
 63 |         return
 64 |     _run(['gfmrun', '-c', str(_gfmrun_count()), '-s', 'README.md'])
 65 | 
 66 | 
 67 | def _vet():
 68 |     _run('go vet ./...')
 69 | 
 70 | 
 71 | def _toc():
 72 |     _run('node_modules/.bin/markdown-toc -i README.md')
 73 |     _run('git diff --exit-code')
 74 | 
 75 | 
 76 | def _gen():
 77 |     go_version = check_output('go version'.split()).split()[2]
 78 |     if go_version < 'go1.5':
 79 |         print('runtests: skip on {}'.format(go_version), file=sys.stderr)
 80 |         return
 81 | 
 82 |     _run('go generate ./...')
 83 |     _run('git diff --exit-code')
 84 | 
 85 | 
 86 | def _run(command):
 87 |     if hasattr(command, 'split'):
 88 |         command = command.split()
 89 |     print('runtests: {}'.format(' '.join(command)), file=sys.stderr)
 90 |     check_call(command)
 91 | 
 92 | 
 93 | def _gfmrun_count():
 94 |     with open('README.md') as infile:
 95 |         lines = infile.read().splitlines()
 96 |         return len(filter(_is_go_runnable, lines))
 97 | 
 98 | 
 99 | def _is_go_runnable(line):
100 |     return line.startswith('package main')
101 | 
102 | 
103 | def _combine_coverprofiles(coverprofiles):
104 |     combined = tempfile.NamedTemporaryFile(
105 |         suffix='.coverprofile', delete=False
106 |     )
107 |     combined.write('mode: set\n')
108 | 
109 |     for coverprofile in coverprofiles:
110 |         with open(coverprofile, 'r') as infile:
111 |             for line in infile.readlines():
112 |                 if not line.startswith('mode: '):
113 |                     combined.write(line)
114 | 
115 |     combined.flush()
116 |     name = combined.name
117 |     combined.close()
118 |     return name
119 | 
120 | 
121 | if __name__ == '__main__':
122 |     sys.exit(main())
123 | 


--------------------------------------------------------------------------------